diff --git a/tool/gedoc/Makefile b/tool/gedoc/Makefile new file mode 100644 index 000000000..83cd06ce0 --- /dev/null +++ b/tool/gedoc/Makefile @@ -0,0 +1,24 @@ +OPT=-finalize +DIR=F_code +DIR=W_code +ise: + ec -freeze -c_compile -config src/system.ecf + +clean_ise: + ec -clean -config src/system.ecf + + +OPT= --gc=no --capability=concurrency=none # --finalize --no-benchmark +gobo: # does not work: https://github.com/gobo-eiffel/gobo/issues/71 + gec $(OPT) src/system.ecf + +fmt=implicit_converts +fmt=attr_rename + +demo_ecf = ./test/tool/system.ecf +demo_ecf = src/system.ecf +demo: + gedoc --format=$(fmt) $(demo_ecf) > inherited_fields.path + +clean: + $(RM) -fr *.c *.o *.make *.h *.sh EIFGENs/ diff --git a/tool/gedoc/README.md b/tool/gedoc/README.md new file mode 100644 index 000000000..19af84cbf --- /dev/null +++ b/tool/gedoc/README.md @@ -0,0 +1,244 @@ +# New tool: Detect attribute (i.e field) renaming in diamond inheritance + +## Background: + +We discovered a semantic problem in Eiffel's attribute renaming mechanism when applied to the diamond problem of multiple inheritance, +and confirmed it by showing divergent and problematic outputs for the same example code in three major different +Eiffel compilers. + +Please check the detail here: +[https://github.com/joortcom/eiffel\_rename](https://github.com/joortcom/eiffel_rename) + +and doc here: [https://github.com/joortcom/eiffel\_rename/blob/main/eiffel\_rename.pdf](https://github.com/joortcom/eiffel_rename/blob/main/eiffel_rename.pdf) + +### Executive summary: +For the time being (before Eiffel's attribute renaming semantics is settled & fixed +-- which most likely will be a *breaking* change of existing code), +please avoid attribute renaming in any diamond inheritance. + +### A bit more detail: + +In [ECMA-367 (specification for the Eiffel programming language)](https://www.ecma-international.org/wp-content/uploads/ECMA-367_2nd_edition_june_2006.pdf) + +1) by 8.16.2 “Any two of these features inherited under a different name yield two features of D”: +which means replicated (i.e. separated copies) features (attributes in particular) in the diamond bottom class D; + +2) while by 8.6.16 “Semantics: Renaming principle”: “Renaming does not affect the semantics of an inherited feature”: +which is not a very precise description. + +So in the actual compiler implementations: + +* ISE compiler (tested the lastest version 23.09): + * In workbench mode: implemented (2) 8.6.16 as reference identity semantics: i.e renamed attributes are all reference equal! + * In finalized mode: skipped (2) 8.6.16, only implemented (1) 8.16.2: i.e renamed attributes are replicated. +* GOBO compiler (tested the lastest version 22.01): + * skipped (2) 8.6.16, only implemented (1) 8.16.2: i.e renamed attributes are replicated. +* SmartEiffel compiler (tested the last known ECMA compilant version 1.1): + * skipped (2) 8.6.16, only implemented (1) 8.16.2: i.e renamed attributes are replicated. + + +## Goal: + +Help Eiffel programmers to detect and avoid attribute renaming in a diamond inheritance. + +## Usage: + +Tool is here: [detect\_diamond.py](https://github.com/joortcom/gobo/blob/detect_diamond/tool/gedoc/detect_diamond.py) + +``` +$GOBO/tool/gedoc/detect_diamond.py or +``` + +## Demo: + +First, from *THIS branch* build all the GOBO tools, esp `gec` and `gedoc` as you usually do. + +Then, run the `detect_diamond.py` tool + +``` +$ cd $GOBO/tool/gedoc/example/rename +$ $GOBO/tool/gedoc/detect_diamond.py app.ecf +check: app.ecf +======================================== app.ecf total fields: 966 +diamond found, full paths: PERSON.addr => RESEARCH_ASSISTANT.{student_addr, faculty_addr, addr} + student_addr {('PERSON.addr', 'STUDENT.addr', 'RESEARCH_ASSISTANT.student_addr')} + faculty_addr {('PERSON.addr', 'FACULTY.addr', 'RESEARCH_ASSISTANT.faculty_addr')} + addr {('PERSON.addr', 'RESEARCH_ASSISTANT.addr')} +new_fields: RESEARCH_ASSISTANT.{student_addr, faculty_addr, addr} +diamond core: PERSON.addr => RESEARCH_ASSISTANT.{student_addr, faculty_addr, addr} + student_addr [('PERSON.addr', 'STUDENT.addr', 'RESEARCH_ASSISTANT.student_addr')] + faculty_addr [('PERSON.addr', 'FACULTY.addr', 'RESEARCH_ASSISTANT.faculty_addr')] + addr [('PERSON.addr', 'RESEARCH_ASSISTANT.addr')] +``` + +And, run the compiler to see different outputs for the *same* code: + +* ISE compiler implements the reference identity semantics in workbench mode +* ISE compiler implements the replica semantics in finalize mode +* GOGO compiler implements the replica semantics + +``` +$ cd $GOBO/tool/gedoc/example/rename # the same dir as above +$ make ise +============================================================================================ +NOTE: ISE compiler implements the troublesome reference identity semantics in workbench mode +============================================================================================ + +ec -clean -full app.e + +... + +C compilation completed +chmod +x ./app +mv app app_w +============================================================================================ +./app_w > ise_w.out +cat ise_w.out +ResAssis has 3 addresses: +PERSON size: 32 +STUDENT size: 32 +FACULTY size: 32 +RESEARCH_ASSISTANT size: 48 +ResAssis do_benchwork in the: home +ResAssis take_rest in the: home +-- print_student|faculty_addr_direct_field +ResAssis as STUDENT.addr: home +ResAssis as FACULTY.addr: home +-- print_student|faculty_addr_via_accessor +ResAssis as STUDENT.addr: home +ResAssis as FACULTY.addr: home +-- check reference identity +ra.addr = ra.faculty_addr +ra.addr = ra.student_addr +ra.student_addr = ra.faculty_addr +-- test some assignment: suppose ra moved both lab2 and dorm2 +ResAssis has 3 addresses: +ResAssis has 3 addresses: +============================== Press enter to continue ============================== + + +============================================================================================ +***NOTE***: ISE compiler implements the replica semantics in finalize mode +============================================================================================ +ec -clean -finalize -full app.e +C compilation completed +chmod +x ./app +mv app app_f +============================================================================================ +./app_f > ise_f.out +cat ise_f.out +ResAssis has 3 addresses: +PERSON size: 32 +STUDENT size: 32 +FACULTY size: 32 +RESEARCH_ASSISTANT size: 48 +ResAssis do_benchwork in the: home +ResAssis take_rest in the: home +-- print_student|faculty_addr_direct_field +ResAssis as STUDENT.addr: home +ResAssis as FACULTY.addr: home +-- print_student|faculty_addr_via_accessor +ResAssis as STUDENT.addr: home +ResAssis as FACULTY.addr: home +-- check reference identity +ra.addr != ra.faculty_addr +ra.addr != ra.student_addr +ra.student_addr != ra.faculty_addr +-- test some assignment: suppose ra moved both lab2 and dorm2 +ResAssis has 3 addresses: +ResAssis has 3 addresses: + +$ make gobo +/bin/gec app.ecf +... +============================================================================================ +./app > gobo.out +cat gobo.out +ResAssis has 3 addresses: +PERSON size: 32 +STUDENT size: 32 +FACULTY size: 32 +RESEARCH_ASSISTANT size: 48 +ResAssis do_benchwork in the: home +ResAssis take_rest in the: home +-- print_student|faculty_addr_direct_field +ResAssis as STUDENT.addr: home +ResAssis as FACULTY.addr: home +-- print_student|faculty_addr_via_accessor +ResAssis as STUDENT.addr: home +ResAssis as FACULTY.addr: home +-- check reference identity +ra.addr != ra.faculty_addr +ra.addr != ra.student_addr +ra.student_addr != ra.faculty_addr +-- test some assignment: suppose ra moved both lab2 and dorm2 +ResAssis has 3 addresses: +ResAssis has 3 addresses: + +``` + +## Diamonds found in real code: + +In ISE 23.09: + +``` +$ cd $ISE_EIFFEL/examples/docking/simple/ +$ $GOBO/tool/gedoc/detect_diamond.py . +check: . + +... + +======================================== ./docking_simple.ecf total fields: 15892 +diamond found, full paths: EV_PIXMAPABLE.implementation => SD_PLACE_HOLDER_ZONE.{implementation, implementation_upper_zone} + implementation {('EV_PIXMAPABLE.implementation', 'EV_CONTAINER.implementation', 'EV_CELL.implementation', 'SD_DOCKING_ZONE.implementation', 'SD_PLACE_HOLDER_ZONE.implementation')} + implementation_upper_zone {('EV_PIXMAPABLE.implementation', 'EV_CONTAINER.implementation', 'SD_UPPER_ZONE.implementation_upper_zone', 'SD_PLACE_HOLDER_ZONE.implementation_upper_zone')} +new_fields: SD_PLACE_HOLDER_ZONE.{implementation, implementation_upper_zone} +diamond core: EV_CONTAINER.implementation => SD_PLACE_HOLDER_ZONE.{implementation, implementation_upper_zone} + implementation [('EV_CONTAINER.implementation', 'EV_CELL.implementation', 'SD_DOCKING_ZONE.implementation', 'SD_PLACE_HOLDER_ZONE.implementation')] + implementation_upper_zone [('EV_CONTAINER.implementation', 'SD_UPPER_ZONE.implementation_upper_zone', 'SD_PLACE_HOLDER_ZONE.implementation_upper_zone')] +``` + +And if you run the workbench build, it will run normally: +``` +/Eiffel_23.09/examples/docking/simple$ ./EIFGENs/docking_simple/W_code/docking_simple +``` + +but if you run the finalized build, it will fail (Ubuntu 22.04.3 LTS, x86_64), it will fail: +``` +/Eiffel_23.09/examples/docking/simple$ ./EIFGENs/docking_simple/F_code/docking_simple + +docking_simple: system execution failed. +Following is the set of recorded exceptions: + +******************************** Thread exception ***************************** +In thread Root thread 0x0 (thread id) +******************************************************************************* +------------------------------------------------------------------------------- +Class / Object Routine Nature of exception Effect +------------------------------------------------------------------------------- +VISION2_APPLICATION root's creation Segmentation fault: +<00007FC1A8207558> Operating system signal. Exit +------------------------------------------------------------------------------- +VISION2_APPLICATION root's creation +<00007FC1A8207558> Routine failure. Exit +------------------------------------------------------------------------------- +``` + +## TODO & Feedbacks: + +Right now this tool is still a prototype, but good enough to detect problems in the real code. +Eric Bezault has kindly agreed to properly integrate into `gedoc` in the near future +[https://github.com/gobo-eiffel/gobo/pull/77#issuecomment-1986971690](https://github.com/gobo-eiffel/gobo/pull/77#issuecomment-1986971690). +Many thanks to Eric for his help in developing this prototype! + +But everybody is busy, if you are good at (GOBO) Eiffel and can help, please +[follow the suggestions by Eric](https://github.com/gobo-eiffel/gobo/pull/77#issuecomment-1986805714) +and create a new PR for Eric to review. + +If you have questions, comments, or just want to inform us the problems found in your own code +by using this tool, please log an issue *in the other repo* (*NOT* here in this GOBO repo) +[https://github.com/joortcom/eiffel\_rename](https://github.com/joortcom/eiffel_rename), +So everything regarding Eiffel `rename` (not *GOBO*) can be easily tracked *there*. + +Thanks! + diff --git a/tool/gedoc/detect_diamond.py b/tool/gedoc/detect_diamond.py new file mode 100644 index 000000000..0a7d99b0a --- /dev/null +++ b/tool/gedoc/detect_diamond.py @@ -0,0 +1,140 @@ +#!/usr/bin/env python3 + +import glob +import os +import sys +import pandas as pd +import pathlib +import traceback +import pdb + +home_dir = os.path.expanduser('~') +script_path = os.path.abspath(__file__) +script_dir = os.path.dirname(script_path) + + +# map each field to its *direct* superclasses' fields that it inherited redefined or renamed +# field => set(field) +parent_fields = {} + +# map each field to its subclasses' fields at *any* level +# field => {class name: {field: set(path)}} +descendant_fields = {} + + +# walk the parent_fields dict all the way up to the root from arg: path[ ... field] +def mark_descendants(path): + head_field = path[0] # head of the path! + if head_field not in parent_fields: # head_field has no parent_fields + return + parents = parent_fields[head_field] + + class_name, field_name = path[-1].split(".") # only take the leaf field! + + for parent_field in parents: + curr_path = (parent_field,) + path + if parent_field not in descendant_fields: + descendant_fields[parent_field] = {} + if class_name not in descendant_fields[parent_field]: + descendant_fields[parent_field][class_name] = {} + if field_name not in descendant_fields[parent_field][class_name]: + descendant_fields[parent_field][class_name][field_name] = set() + descendant_fields[parent_field][class_name][field_name].add(curr_path) + + mark_descendants(curr_path) # recursive call + + +def find_longest_common_ancestors_len(paths): + n = len(paths) + if n == 0: + return 0 + + l = min([len(path) for path in paths]) + for i in range(l): + if n != sum([path[i] == paths[0][i] for path in paths]): + return i + + return l + + +# for pretty print +def path_string(path): + # pdb.set_trace() + # assert(isinstance(path, set)) + return ',\n\t'.join(path) + + +INHERITED_FIELDS_FN = "inherited_fields.path" +def detect_diamond(ecf_fn): + edges = pd.read_csv(INHERITED_FIELDS_FN, sep="[,\.]", skiprows=3, skipfooter=1, engine='python', + names=["kind", "src_class", "src_field", "tgt_class", "tgt_field"]).dropna() + # print(edges) + + # populate the direct parent_fields dict + for i, edge in edges.iterrows(): + try: + # print(edge) + tgt = edge["tgt_class"] + "." + edge["tgt_field"] + src = edge["src_class"] + "." + edge["src_field"] + if tgt not in parent_fields: + parent_fields[tgt] = set() + parent_fields[tgt].add(src) + except: + print("skip ", ecf_fn) + # pdb.set_trace() + sys.exit(-1) + + # print("total fields: ", len(parent_fields)) + + for field in parent_fields.keys(): # mark all the field's ancestors at *any* level + mark_descendants((field,)) + + # check descendant_fields, if any field mapped into a same class' multiple target field + for field, clazzs in descendant_fields.items(): + for class_name, field_paths in clazzs.items(): + if len(field_paths.keys()) >= 2: # i.e ends up with >=2 different names + print('=' * 40, ecf_fn, "total fields: ", len(parent_fields)) + new_fields = "%s.{%s}" % (class_name, ", ".join(field_paths.keys())) + print("diamond found, full paths: ", field, " => ", new_fields) + paths = [] + for new_field, path in field_paths.items(): + assert(isinstance(path, set)) + paths.extend(path) + print(" ", new_field, path) + l = find_longest_common_ancestors_len(paths) + print("new_fields:", new_fields) + print("diamond core: ", paths[0][l-1], " => ", new_fields) + for new_field, path in field_paths.items(): + print(" %s:\n\t%s" % (new_field, ';'.join([path_string(p[l-1:]) for p in path]))) + + +def process_all_ecf(dir): + ecf_fns = glob.glob(dir + '/**/*.ecf', recursive=True) + for ecf_fn in ecf_fns: + process_ecf(ecf_fn) + + +def process_ecf(ecf_fn): + try: + # "%s/project/contrib/gobo/tool/gedoc" home_dir + pathlib.Path(INHERITED_FIELDS_FN).unlink(missing_ok=True) + cmd = "%s/gedoc --format=attr_rename %s > %s" % (script_dir, ecf_fn, INHERITED_FIELDS_FN) + # print(cmd) + os.system(cmd) + detect_diamond(ecf_fn) + except: + traceback.print_exc() + print("skip ", ecf_fn) + +if __name__ == "__main__": + if len(sys.argv) >= 2: + f = sys.argv[1] + else: + f = "./" + + print("check: ", f) + if os.path.isdir(f): + process_all_ecf(f) + else: + process_ecf(f) + diff --git a/tool/gedoc/example/rename/Makefile b/tool/gedoc/example/rename/Makefile new file mode 100644 index 000000000..212a41aed --- /dev/null +++ b/tool/gedoc/example/rename/Makefile @@ -0,0 +1,51 @@ +OPT= -clean #-sedb + +ISE_OPT = -full #: with full class checking regardless of ECF settings. + +SE=compile # SmartEiffel +EC=ec + +se_: + cd se && make se +se: + $(SE) $(OPT) app.e -o app + @echo "============================================================================================" + ./app > se.out + cat se.out + +ise: + @echo "============================================================================================" + @echo "NOTE: ISE compiler implements the troublesome reference identity semantics in workbench mode" + @echo "============================================================================================" + $(EC) $(OPT) $(ISE_OPT) app.e + chmod +x ./app + mv app app_w + @echo "============================================================================================" + ./app_w > ise_w.out + cat ise_w.out + @printf "%s " "============================== Press enter to continue ==============================" + @read ans + @echo "============================================================================================" + @echo "***NOTE***: ISE compiler implements the replica semantics in finalize mode" + @echo "============================================================================================" + $(EC) $(OPT) -finalize $(ISE_OPT) app.e + chmod +x ./app + mv app app_f + @echo "============================================================================================" + ./app_f > ise_f.out + cat ise_f.out + +gobo: + $(PROJECT)/gobo/bin/gec app.ecf + @echo "============================================================================================" + ./app > gobo.out + cat gobo.out + +fmt=attr_rename +demo: + ../../gedoc --format=$(fmt) app.ecf > inherited_fields.path + ../../detect_diamond.py + +clean: + $(RM) -fr app a.out EIFGENs/ app.make app.sh *.c *.h *.out *.o + clean app diff --git a/tool/gedoc/example/rename/app.e b/tool/gedoc/example/rename/app.e new file mode 100644 index 000000000..667be65b8 --- /dev/null +++ b/tool/gedoc/example/rename/app.e @@ -0,0 +1,68 @@ +-- to build with SmartEiffel: compile app.e -o app +class APP inherit INTERNAL + +create {ANY} + make + +feature {ANY} + ra: RESEARCH_ASSISTANT + p: PERSON + s: STUDENT + f: FACULTY + + -- problematic implementation: direct field access + print_student_addr_direct_field(u: STUDENT) is + do io.put_string(u.name + " as STUDENT.addr: " + u.addr + "%N") end + print_faculty_addr_direct_field(u: FACULTY) is + do io.put_string(u.name + " as FACULTY.addr: " + u.addr + "%N") end + + -- correct implementation: use semantic assigning accessor + print_student_addr_via_accessor(u: STUDENT) is + do io.put_string(u.name + " as STUDENT.addr: " + u.get_student_addr() + "%N") end + print_faculty_addr_via_accessor(u: FACULTY) is + do io.put_string(u.name + " as FACULTY.addr: " + u.get_faculty_addr() + "%N") end + + make is + do + create p.default_create + create s.default_create + create f.default_create + create ra.make + + ra.print_ra() + io.put_string("PERSON size: " +physical_size(p ).out+ "%N") + io.put_string("STUDENT size: " +physical_size(s ).out+ "%N") + io.put_string("FACULTY size: " +physical_size(f ).out+ "%N") + io.put_string("RESEARCH_ASSISTANT size: " +physical_size(ra).out+ "%N") + + ra.do_benchwork() -- which addr field will this calls access? + ra.take_rest() -- which addr field will this calls access? + + io.put_string("-- print_student|faculty_addr_direct_field%N") + print_student_addr_direct_field(ra) + print_faculty_addr_direct_field(ra) + + io.put_string("-- print_student|faculty_addr_via_accessor%N") + print_student_addr_via_accessor(ra) + print_faculty_addr_via_accessor(ra) + + io.put_string("-- check reference identity%N") + if ra.addr = ra.faculty_addr + then io.put_string("ra.addr = ra.faculty_addr%N") + else io.put_string("ra.addr != ra.faculty_addr%N") end + + if ra.addr = ra.student_addr + then io.put_string("ra.addr = ra.student_addr%N") + else io.put_string("ra.addr != ra.student_addr%N") end + + if ra.student_addr = ra.faculty_addr + then io.put_string("ra.student_addr = ra.faculty_addr%N") + else io.put_string("ra.student_addr != ra.faculty_addr%N") end + + io.put_string("-- test some assignment: suppose ra moved both lab2 and dorm2%N") + ra.set_faculty_addr("lab2") + ra.print_ra() + ra.set_student_addr("dorm2") + ra.print_ra() + end +end diff --git a/tool/gedoc/example/rename/app.ecf b/tool/gedoc/example/rename/app.ecf new file mode 100644 index 000000000..50b3ac4cf --- /dev/null +++ b/tool/gedoc/example/rename/app.ecf @@ -0,0 +1,14 @@ + + + + + + + + + + + + diff --git a/tool/gedoc/example/rename/faculty.e b/tool/gedoc/example/rename/faculty.e new file mode 100644 index 000000000..83bfed65f --- /dev/null +++ b/tool/gedoc/example/rename/faculty.e @@ -0,0 +1,12 @@ +class FACULTY +inherit PERSON + +feature {ANY} + get_faculty_addr():STRING is do Result := get_addr() end -- assign lab semantics to addr + set_faculty_addr(a:STRING) is do set_addr(a) end + + do_benchwork() is + do + io.put_string(name + " do_benchwork in the: " + get_faculty_addr() + "%N"); + end +end diff --git a/tool/gedoc/example/rename/inherited_fields.path b/tool/gedoc/example/rename/inherited_fields.path new file mode 100644 index 000000000..657e27b1a --- /dev/null +++ b/tool/gedoc/example/rename/inherited_fields.path @@ -0,0 +1,2072 @@ +Degree 6: 0/0/0 0:0:0.013 +Degree 5: 0/0/0 0:0:0.688 +Degree 4: 0/0/0 0:0:0.091 +inherited,PERSON.name,FACULTY.name + +inherited,PERSON.addr,FACULTY.addr + +renamed,STUDENT.addr,RESEARCH_ASSISTANT.student_addr + +inherited,STUDENT.name,RESEARCH_ASSISTANT.name + +renamed,FACULTY.addr,RESEARCH_ASSISTANT.faculty_addr + +inherited,FACULTY.name,RESEARCH_ASSISTANT.name + +inherited,PERSON.name,RESEARCH_ASSISTANT.name + +inherited,PERSON.addr,RESEARCH_ASSISTANT.addr + +inherited,PERSON.name,STUDENT.name + +inherited,PERSON.addr,STUDENT.addr + +inherited,RESIZABLE.object_comparison,ARRAY.object_comparison + +inherited,INDEXABLE.object_comparison,ARRAY.object_comparison + +inherited,TO_SPECIAL.area,ARRAY.area + +inherited,ROUTINE.operands,FUNCTION.operands + +inherited,ROUTINE.is_target_closed,FUNCTION.is_target_closed + +inherited,ROUTINE.open_count,FUNCTION.open_count + +inherited,ROUTINE.closed_operands,FUNCTION.closed_operands + +inherited,ROUTINE.rout_disp,FUNCTION.rout_disp + +inherited,ROUTINE.calc_rout_addr,FUNCTION.calc_rout_addr + +inherited,ROUTINE.open_map,FUNCTION.open_map + +inherited,ROUTINE.encaps_rout_disp,FUNCTION.encaps_rout_disp + +inherited,ROUTINE.routine_id,FUNCTION.routine_id + +inherited,ROUTINE.is_basic,FUNCTION.is_basic + +inherited,ROUTINE.written_type_id_inline_agent,FUNCTION.written_type_id_inline_agent + +inherited,ROUTINE.open_types,FUNCTION.open_types + +inherited,READABLE_STRING_8.count,IMMUTABLE_STRING_8.count + +inherited,READABLE_STRING_8.area,IMMUTABLE_STRING_8.area + +inherited,READABLE_STRING_8.internal_case_insensitive_hash_code,IMMUTABLE_STRING_8.internal_case_insensitive_hash_code + +inherited,READABLE_STRING_8.internal_hash_code,IMMUTABLE_STRING_8.internal_hash_code + +inherited,IMMUTABLE_STRING_GENERAL.internal_case_insensitive_hash_code,IMMUTABLE_STRING_8.internal_case_insensitive_hash_code + +inherited,IMMUTABLE_STRING_GENERAL.internal_hash_code,IMMUTABLE_STRING_8.internal_hash_code + +inherited,READABLE_STRING_32.count,IMMUTABLE_STRING_32.count + +inherited,READABLE_STRING_32.area,IMMUTABLE_STRING_32.area + +inherited,READABLE_STRING_32.internal_case_insensitive_hash_code,IMMUTABLE_STRING_32.internal_case_insensitive_hash_code + +inherited,READABLE_STRING_32.internal_hash_code,IMMUTABLE_STRING_32.internal_hash_code + +inherited,IMMUTABLE_STRING_GENERAL.internal_case_insensitive_hash_code,IMMUTABLE_STRING_32.internal_case_insensitive_hash_code + +inherited,IMMUTABLE_STRING_GENERAL.internal_hash_code,IMMUTABLE_STRING_32.internal_hash_code + +inherited,FUNCTION.last_result,PREDICATE.last_result + +inherited,FUNCTION.open_types,PREDICATE.open_types + +inherited,FUNCTION.written_type_id_inline_agent,PREDICATE.written_type_id_inline_agent + +inherited,FUNCTION.is_basic,PREDICATE.is_basic + +inherited,FUNCTION.routine_id,PREDICATE.routine_id + +inherited,FUNCTION.encaps_rout_disp,PREDICATE.encaps_rout_disp + +inherited,FUNCTION.open_map,PREDICATE.open_map + +inherited,FUNCTION.calc_rout_addr,PREDICATE.calc_rout_addr + +inherited,FUNCTION.rout_disp,PREDICATE.rout_disp + +inherited,FUNCTION.closed_operands,PREDICATE.closed_operands + +inherited,FUNCTION.open_count,PREDICATE.open_count + +inherited,FUNCTION.is_target_closed,PREDICATE.is_target_closed + +inherited,FUNCTION.operands,PREDICATE.operands + +inherited,ROUTINE.operands,PROCEDURE.operands + +inherited,ROUTINE.is_target_closed,PROCEDURE.is_target_closed + +inherited,ROUTINE.open_count,PROCEDURE.open_count + +inherited,ROUTINE.closed_operands,PROCEDURE.closed_operands + +inherited,ROUTINE.rout_disp,PROCEDURE.rout_disp + +inherited,ROUTINE.calc_rout_addr,PROCEDURE.calc_rout_addr + +inherited,ROUTINE.open_map,PROCEDURE.open_map + +inherited,ROUTINE.encaps_rout_disp,PROCEDURE.encaps_rout_disp + +inherited,ROUTINE.routine_id,PROCEDURE.routine_id + +inherited,ROUTINE.is_basic,PROCEDURE.is_basic + +inherited,ROUTINE.written_type_id_inline_agent,PROCEDURE.written_type_id_inline_agent + +inherited,ROUTINE.open_types,PROCEDURE.open_types + +inherited,READABLE_STRING_8.count,STRING_8.count + +inherited,READABLE_STRING_8.area,STRING_8.area + +inherited,READABLE_STRING_8.internal_case_insensitive_hash_code,STRING_8.internal_case_insensitive_hash_code + +inherited,READABLE_STRING_8.internal_hash_code,STRING_8.internal_hash_code + +inherited,STRING_GENERAL.internal_case_insensitive_hash_code,STRING_8.internal_case_insensitive_hash_code + +inherited,STRING_GENERAL.internal_hash_code,STRING_8.internal_hash_code + +inherited,DYNAMIC_TABLE.object_comparison,STRING_8.object_comparison + +renamed,INDEXABLE.upper,STRING_8.count + +inherited,INDEXABLE.object_comparison,STRING_8.object_comparison + +inherited,RESIZABLE.object_comparison,STRING_8.object_comparison + +inherited,TO_SPECIAL.area,STRING_8.area + +inherited,READABLE_STRING_32.count,STRING_32.count + +inherited,READABLE_STRING_32.area,STRING_32.area + +inherited,READABLE_STRING_32.internal_case_insensitive_hash_code,STRING_32.internal_case_insensitive_hash_code + +inherited,READABLE_STRING_32.internal_hash_code,STRING_32.internal_hash_code + +inherited,STRING_GENERAL.internal_case_insensitive_hash_code,STRING_32.internal_case_insensitive_hash_code + +inherited,STRING_GENERAL.internal_hash_code,STRING_32.internal_hash_code + +inherited,DYNAMIC_TABLE.object_comparison,STRING_32.object_comparison + +renamed,INDEXABLE.upper,STRING_32.count + +inherited,INDEXABLE.object_comparison,STRING_32.object_comparison + +inherited,RESIZABLE.object_comparison,STRING_32.object_comparison + +inherited,TO_SPECIAL.area,STRING_32.area + +inherited,READABLE_STRING_GENERAL.internal_hash_code,READABLE_STRING_8.internal_hash_code + +inherited,READABLE_STRING_GENERAL.internal_case_insensitive_hash_code,READABLE_STRING_8.internal_case_insensitive_hash_code + +renamed,READABLE_INDEXABLE.upper,READABLE_STRING_8.count + +inherited,ENCODING_I.last_converted_string,UNICODE_CONVERSION.last_converted_string + +inherited,ENCODING_I.last_conversion_successful,UNICODE_CONVERSION.last_conversion_successful + +inherited,ENCODING_I.last_was_wide_string,UNICODE_CONVERSION.last_was_wide_string + +inherited,DEVELOPER_EXCEPTION.internal_trace,CONVERSION_FAILURE.internal_trace + +inherited,DEVELOPER_EXCEPTION.internal_is_ignorable,CONVERSION_FAILURE.internal_is_ignorable + +inherited,DEVELOPER_EXCEPTION.c_description,CONVERSION_FAILURE.c_description + +inherited,DEVELOPER_EXCEPTION.throwing_exception,CONVERSION_FAILURE.throwing_exception + +inherited,DEVELOPER_EXCEPTION.line_number,CONVERSION_FAILURE.line_number + +inherited,DEVELOPER_EXCEPTION.type_name,CONVERSION_FAILURE.type_name + +inherited,DEVELOPER_EXCEPTION.recipient_name,CONVERSION_FAILURE.recipient_name + +inherited,ENCODING_I.last_converted_string,ENCODING_IMP.last_converted_string + +inherited,ENCODING_I.last_conversion_successful,ENCODING_IMP.last_conversion_successful + +inherited,ENCODING_I.last_was_wide_string,ENCODING_IMP.last_was_wide_string + +inherited,TREE.parent,DYNAMIC_TREE.parent + +inherited,TREE.object_comparison,DYNAMIC_TREE.object_comparison + +inherited,CELL.item,FIXED_TREE.item + +inherited,TREE.parent,FIXED_TREE.parent + +inherited,TREE.object_comparison,FIXED_TREE.object_comparison + +inherited,CELL.item,ARRAYED_TREE.item + +inherited,DYNAMIC_TREE.parent,ARRAYED_TREE.parent + +inherited,DYNAMIC_TREE.object_comparison,ARRAYED_TREE.object_comparison + +inherited,DYNAMIC_TREE.parent,TWO_WAY_TREE.parent + +inherited,DYNAMIC_TREE.object_comparison,TWO_WAY_TREE.object_comparison + +renamed,BI_LINKABLE.left,TWO_WAY_TREE.left_sibling + +renamed,BI_LINKABLE.right,TWO_WAY_TREE.right_sibling + +inherited,BI_LINKABLE.item,TWO_WAY_TREE.item + +renamed,TWO_WAY_LIST.active,TWO_WAY_TREE.child + +renamed,TWO_WAY_LIST.after,TWO_WAY_TREE.child_after + +renamed,TWO_WAY_LIST.before,TWO_WAY_TREE.child_before + +renamed,TWO_WAY_LIST.count,TWO_WAY_TREE.arity + +renamed,TWO_WAY_LIST.first_element,TWO_WAY_TREE.first_child + +renamed,TWO_WAY_LIST.last_element,TWO_WAY_TREE.last_child + +inherited,TWO_WAY_LIST.sublist,TWO_WAY_TREE.sublist + +inherited,TWO_WAY_LIST.object_comparison,TWO_WAY_TREE.object_comparison + +inherited,CELL.item,BINARY_TREE.item + +inherited,TREE.parent,BINARY_TREE.parent + +inherited,TREE.object_comparison,BINARY_TREE.object_comparison + +inherited,BINARY_TREE.parent,BINARY_SEARCH_TREE.parent + +inherited,BINARY_TREE.child_index,BINARY_SEARCH_TREE.child_index + +inherited,BINARY_TREE.left_child,BINARY_SEARCH_TREE.left_child + +inherited,BINARY_TREE.right_child,BINARY_SEARCH_TREE.right_child + +inherited,BINARY_TREE.item,BINARY_SEARCH_TREE.item + +inherited,BINARY_TREE.object_comparison,BINARY_SEARCH_TREE.object_comparison + +inherited,DYNAMIC_TREE.parent,LINKED_TREE.parent + +inherited,DYNAMIC_TREE.object_comparison,LINKED_TREE.object_comparison + +renamed,LINKABLE.right,LINKED_TREE.right_sibling + +inherited,LINKABLE.item,LINKED_TREE.item + +renamed,LINKED_LIST.active,LINKED_TREE.child + +renamed,LINKED_LIST.after,LINKED_TREE.child_after + +renamed,LINKED_LIST.before,LINKED_TREE.child_before + +renamed,LINKED_LIST.count,LINKED_TREE.arity + +renamed,LINKED_LIST.first_element,LINKED_TREE.first_child + +inherited,LINKED_LIST.object_comparison,LINKED_TREE.object_comparison + +inherited,CONTAINER.object_comparison,TREE.object_comparison + +inherited,LINEAR.object_comparison,BILINEAR.object_comparison + +inherited,CONTAINER.object_comparison,TRAVERSABLE.object_comparison + +inherited,TRAVERSABLE.object_comparison,LINEAR.object_comparison + +inherited,TRAVERSABLE.object_comparison,HIERARCHICAL.object_comparison + +inherited,STACK.object_comparison,LINKED_STACK.object_comparison + +inherited,LINKED_LIST.first_element,LINKED_STACK.first_element + +inherited,LINKED_LIST.count,LINKED_STACK.count + +inherited,LINKED_LIST.after,LINKED_STACK.after + +inherited,LINKED_LIST.before,LINKED_STACK.before + +inherited,LINKED_LIST.active,LINKED_STACK.active + +inherited,LINKED_LIST.object_comparison,LINKED_STACK.object_comparison + +inherited,STACK.object_comparison,ARRAYED_STACK.object_comparison + +inherited,ARRAYED_LIST.index,ARRAYED_STACK.index + +inherited,ARRAYED_LIST.area_v2,ARRAYED_STACK.area_v2 + +inherited,ARRAYED_LIST.object_comparison,ARRAYED_STACK.object_comparison + +inherited,DISPENSER.object_comparison,STACK.object_comparison + +inherited,QUEUE.object_comparison,ARRAYED_QUEUE.object_comparison + +inherited,RESIZABLE.object_comparison,ARRAYED_QUEUE.object_comparison + +inherited,QUEUE.object_comparison,LINKED_QUEUE.object_comparison + +inherited,LINKED_LIST.first_element,LINKED_QUEUE.first_element + +inherited,LINKED_LIST.count,LINKED_QUEUE.count + +inherited,LINKED_LIST.after,LINKED_QUEUE.after + +inherited,LINKED_LIST.before,LINKED_QUEUE.before + +inherited,LINKED_LIST.active,LINKED_QUEUE.active + +inherited,LINKED_LIST.object_comparison,LINKED_QUEUE.object_comparison + +inherited,PRIORITY_QUEUE.object_comparison,HEAP_PRIORITY_QUEUE.object_comparison + +inherited,RESIZABLE.object_comparison,HEAP_PRIORITY_QUEUE.object_comparison + +inherited,DISPENSER.object_comparison,QUEUE.object_comparison + +inherited,DISPENSER.object_comparison,PRIORITY_QUEUE.object_comparison + +inherited,SORTED_TWO_WAY_LIST.last_element,LINKED_PRIORITY_QUEUE.last_element + +inherited,SORTED_TWO_WAY_LIST.active,LINKED_PRIORITY_QUEUE.active + +inherited,SORTED_TWO_WAY_LIST.first_element,LINKED_PRIORITY_QUEUE.first_element + +inherited,SORTED_TWO_WAY_LIST.sublist,LINKED_PRIORITY_QUEUE.sublist + +inherited,SORTED_TWO_WAY_LIST.count,LINKED_PRIORITY_QUEUE.count + +inherited,SORTED_TWO_WAY_LIST.object_comparison,LINKED_PRIORITY_QUEUE.object_comparison + +inherited,SORTED_TWO_WAY_LIST.after,LINKED_PRIORITY_QUEUE.after + +inherited,SORTED_TWO_WAY_LIST.before,LINKED_PRIORITY_QUEUE.before + +inherited,PRIORITY_QUEUE.object_comparison,LINKED_PRIORITY_QUEUE.object_comparison + +inherited,ACTIVE.object_comparison,DISPENSER.object_comparison + +inherited,FINITE.object_comparison,DISPENSER.object_comparison + +inherited,ARRAYED_QUEUE.count,BOUNDED_QUEUE.count + +inherited,ARRAYED_QUEUE.area,BOUNDED_QUEUE.area + +inherited,ARRAYED_QUEUE.out_index,BOUNDED_QUEUE.out_index + +inherited,ARRAYED_QUEUE.object_comparison,BOUNDED_QUEUE.object_comparison + +inherited,BOUNDED.object_comparison,BOUNDED_QUEUE.object_comparison + +inherited,ARRAYED_STACK.area_v2,BOUNDED_STACK.area_v2 + +inherited,ARRAYED_STACK.object_comparison,BOUNDED_STACK.object_comparison + +inherited,ARRAYED_STACK.index,BOUNDED_STACK.index + +inherited,BOUNDED.object_comparison,BOUNDED_STACK.object_comparison + +inherited,ITERATOR.target,LINEAR_ITERATOR.target + +inherited,LINEAR_ITERATOR.target,CURSOR_TREE_ITERATOR.target + +inherited,LINEAR_ITERATOR.target,CURSOR_TREE_ITERATOR.target + +inherited,LINEAR_ITERATOR.target,CURSOR_TREE_ITERATOR.target + +inherited,LINEAR_ITERATOR.target,TWO_WAY_CHAIN_ITERATOR.target + +inherited,LINEAR_ITERATOR.target,TWO_WAY_CHAIN_ITERATOR.target + +inherited,GENERAL_SPECIAL_ITERATION_CURSOR.area,ARRAY_ITERATION_CURSOR.area + +inherited,GENERAL_SPECIAL_ITERATION_CURSOR.area_index,ARRAY_ITERATION_CURSOR.area_index + +inherited,GENERAL_SPECIAL_ITERATION_CURSOR.area_last_index,ARRAY_ITERATION_CURSOR.area_last_index + +inherited,GENERAL_SPECIAL_ITERATION_CURSOR.area,STRING_32_ITERATION_CURSOR.area + +inherited,GENERAL_SPECIAL_ITERATION_CURSOR.area_index,STRING_32_ITERATION_CURSOR.area_index + +inherited,GENERAL_SPECIAL_ITERATION_CURSOR.area_last_index,STRING_32_ITERATION_CURSOR.area_last_index + +inherited,LINKED_LIST_CURSOR.active,TWO_WAY_LIST_CURSOR.active + +inherited,LINKED_LIST_CURSOR.after,TWO_WAY_LIST_CURSOR.after + +inherited,LINKED_LIST_CURSOR.before,TWO_WAY_LIST_CURSOR.before + +inherited,GENERAL_SPECIAL_ITERATION_CURSOR.area,ARRAYED_LIST_ITERATION_CURSOR.area + +inherited,GENERAL_SPECIAL_ITERATION_CURSOR.area_index,ARRAYED_LIST_ITERATION_CURSOR.area_index + +inherited,GENERAL_SPECIAL_ITERATION_CURSOR.area_last_index,ARRAYED_LIST_ITERATION_CURSOR.area_last_index + +inherited,LINKED_LIST_ITERATION_CURSOR.target,TWO_WAY_LIST_ITERATION_CURSOR.target + +inherited,LINKED_LIST_ITERATION_CURSOR.active,TWO_WAY_LIST_ITERATION_CURSOR.active + +inherited,LINKED_LIST_ITERATION_CURSOR.version,TWO_WAY_LIST_ITERATION_CURSOR.version + +inherited,LINKED_LIST_ITERATION_CURSOR.is_reversed,TWO_WAY_LIST_ITERATION_CURSOR.is_reversed + +inherited,LINKED_LIST_ITERATION_CURSOR.step,TWO_WAY_LIST_ITERATION_CURSOR.step + +inherited,LINKED_LIST_ITERATION_CURSOR.last_index,TWO_WAY_LIST_ITERATION_CURSOR.last_index + +inherited,LINKED_LIST_ITERATION_CURSOR.first_index,TWO_WAY_LIST_ITERATION_CURSOR.first_index + +inherited,LINKED_LIST_ITERATION_CURSOR.target_index,TWO_WAY_LIST_ITERATION_CURSOR.target_index + +inherited,GENERAL_SPECIAL_ITERATION_CURSOR.area,STRING_8_ITERATION_CURSOR.area + +inherited,GENERAL_SPECIAL_ITERATION_CURSOR.area_index,STRING_8_ITERATION_CURSOR.area_index + +inherited,GENERAL_SPECIAL_ITERATION_CURSOR.area_last_index,STRING_8_ITERATION_CURSOR.area_last_index + +inherited,TREE_ITERATION_CURSOR.node,TWO_WAY_TREE_ITERATION_CURSOR.node + +inherited,TREE_ITERATION_CURSOR.child_index,TWO_WAY_TREE_ITERATION_CURSOR.child_index + +renamed,TWO_WAY_LIST_ITERATION_CURSOR.active,TWO_WAY_TREE_ITERATION_CURSOR.node + +inherited,TWO_WAY_LIST_ITERATION_CURSOR.target,TWO_WAY_TREE_ITERATION_CURSOR.target + +inherited,TWO_WAY_LIST_ITERATION_CURSOR.version,TWO_WAY_TREE_ITERATION_CURSOR.version + +inherited,TWO_WAY_LIST_ITERATION_CURSOR.is_reversed,TWO_WAY_TREE_ITERATION_CURSOR.is_reversed + +inherited,TWO_WAY_LIST_ITERATION_CURSOR.step,TWO_WAY_TREE_ITERATION_CURSOR.step + +inherited,TWO_WAY_LIST_ITERATION_CURSOR.last_index,TWO_WAY_TREE_ITERATION_CURSOR.last_index + +inherited,TWO_WAY_LIST_ITERATION_CURSOR.first_index,TWO_WAY_TREE_ITERATION_CURSOR.first_index + +inherited,TWO_WAY_LIST_ITERATION_CURSOR.target_index,TWO_WAY_TREE_ITERATION_CURSOR.target_index + +inherited,TWO_WAY_LIST_CURSOR.active,TWO_WAY_TREE_CURSOR.active + +inherited,TWO_WAY_LIST_CURSOR.before,TWO_WAY_TREE_CURSOR.before + +inherited,TWO_WAY_LIST_CURSOR.after,TWO_WAY_TREE_CURSOR.after + +renamed,GENERAL_SPECIAL_ITERATION_CURSOR.area,SPECIAL_ITERATION_CURSOR.target + +inherited,GENERAL_SPECIAL_ITERATION_CURSOR.area_index,SPECIAL_ITERATION_CURSOR.area_index + +inherited,GENERAL_SPECIAL_ITERATION_CURSOR.area_last_index,SPECIAL_ITERATION_CURSOR.area_last_index + +inherited,TREE_ITERATION_CURSOR.node,LINKED_TREE_ITERATION_CURSOR.node + +inherited,TREE_ITERATION_CURSOR.child_index,LINKED_TREE_ITERATION_CURSOR.child_index + +renamed,LINKED_LIST_ITERATION_CURSOR.active,LINKED_TREE_ITERATION_CURSOR.node + +inherited,LINKED_LIST_ITERATION_CURSOR.target,LINKED_TREE_ITERATION_CURSOR.target + +inherited,LINKED_LIST_ITERATION_CURSOR.version,LINKED_TREE_ITERATION_CURSOR.version + +inherited,LINKED_LIST_ITERATION_CURSOR.is_reversed,LINKED_TREE_ITERATION_CURSOR.is_reversed + +inherited,LINKED_LIST_ITERATION_CURSOR.step,LINKED_TREE_ITERATION_CURSOR.step + +inherited,LINKED_LIST_ITERATION_CURSOR.last_index,LINKED_TREE_ITERATION_CURSOR.last_index + +inherited,LINKED_LIST_ITERATION_CURSOR.first_index,LINKED_TREE_ITERATION_CURSOR.first_index + +inherited,LINKED_LIST_ITERATION_CURSOR.target_index,LINKED_TREE_ITERATION_CURSOR.target_index + +renamed,READABLE_INDEXABLE_ITERATION_CURSOR.target_index,HASH_TABLE_ITERATION_CURSOR.iteration_position + +inherited,READABLE_INDEXABLE_ITERATION_CURSOR.first_index,HASH_TABLE_ITERATION_CURSOR.first_index + +inherited,READABLE_INDEXABLE_ITERATION_CURSOR.last_index,HASH_TABLE_ITERATION_CURSOR.last_index + +inherited,READABLE_INDEXABLE_ITERATION_CURSOR.step,HASH_TABLE_ITERATION_CURSOR.step + +inherited,READABLE_INDEXABLE_ITERATION_CURSOR.version,HASH_TABLE_ITERATION_CURSOR.version + +inherited,READABLE_INDEXABLE_ITERATION_CURSOR.is_reversed,HASH_TABLE_ITERATION_CURSOR.is_reversed + +inherited,READABLE_INDEXABLE_ITERATION_CURSOR.target,HASH_TABLE_ITERATION_CURSOR.target + +inherited,READABLE_INDEXABLE_ITERATION_CURSOR.target_index,LINKED_LIST_ITERATION_CURSOR.target_index + +inherited,READABLE_INDEXABLE_ITERATION_CURSOR.first_index,LINKED_LIST_ITERATION_CURSOR.first_index + +inherited,READABLE_INDEXABLE_ITERATION_CURSOR.last_index,LINKED_LIST_ITERATION_CURSOR.last_index + +inherited,READABLE_INDEXABLE_ITERATION_CURSOR.step,LINKED_LIST_ITERATION_CURSOR.step + +inherited,READABLE_INDEXABLE_ITERATION_CURSOR.version,LINKED_LIST_ITERATION_CURSOR.version + +inherited,READABLE_INDEXABLE_ITERATION_CURSOR.is_reversed,LINKED_LIST_ITERATION_CURSOR.is_reversed + +inherited,READABLE_INDEXABLE_ITERATION_CURSOR.target,LINKED_LIST_ITERATION_CURSOR.target + +inherited,LINKED_LIST_CURSOR.active,LINKED_TREE_CURSOR.active + +inherited,LINKED_LIST_CURSOR.after,LINKED_TREE_CURSOR.after + +inherited,LINKED_LIST_CURSOR.before,LINKED_TREE_CURSOR.before + +inherited,UNBOUNDED.object_comparison,HASH_TABLE.object_comparison + +inherited,DYNAMIC_TABLE.object_comparison,HASH_TABLE.object_comparison + +inherited,HASH_TABLE.found_item,STRING_TABLE.found_item + +inherited,HASH_TABLE.count,STRING_TABLE.count + +inherited,HASH_TABLE.capacity,STRING_TABLE.capacity + +inherited,HASH_TABLE.hash_table_version_64,STRING_TABLE.hash_table_version_64 + +inherited,HASH_TABLE.content,STRING_TABLE.content + +inherited,HASH_TABLE.keys,STRING_TABLE.keys + +inherited,HASH_TABLE.indexes_map,STRING_TABLE.indexes_map + +inherited,HASH_TABLE.deleted_marks,STRING_TABLE.deleted_marks + +inherited,HASH_TABLE.item_position,STRING_TABLE.item_position + +inherited,HASH_TABLE.has_default,STRING_TABLE.has_default + +inherited,HASH_TABLE.iteration_position,STRING_TABLE.iteration_position + +inherited,HASH_TABLE.control,STRING_TABLE.control + +inherited,HASH_TABLE.deleted_item_position,STRING_TABLE.deleted_item_position + +inherited,HASH_TABLE.ht_lowest_deleted_position,STRING_TABLE.ht_lowest_deleted_position + +inherited,HASH_TABLE.ht_deleted_item,STRING_TABLE.ht_deleted_item + +inherited,HASH_TABLE.ht_deleted_key,STRING_TABLE.ht_deleted_key + +inherited,HASH_TABLE.object_comparison,STRING_TABLE.object_comparison + +inherited,TABLE.object_comparison,DYNAMIC_TABLE.object_comparison + +inherited,ARRAY.lower,ARRAY2.lower + +inherited,ARRAY.upper,ARRAY2.upper + +inherited,ARRAY.area,ARRAY2.area + +inherited,ARRAY.object_comparison,ARRAY2.object_comparison + +inherited,LINEAR_SUBSET.object_comparison,ARRAYED_SET.object_comparison + +inherited,ARRAYED_LIST.index,ARRAYED_SET.index + +inherited,ARRAYED_LIST.area_v2,ARRAYED_SET.area_v2 + +inherited,ARRAYED_LIST.object_comparison,ARRAYED_SET.object_comparison + +inherited,SUBSET.object_comparison,COMPARABLE_SET.object_comparison + +inherited,COMPARABLE_STRUCT.object_comparison,COMPARABLE_SET.object_comparison + +inherited,SUBSET.object_comparison,TRAVERSABLE_SUBSET.object_comparison + +inherited,LINEAR_SUBSET.object_comparison,LINKED_SET.object_comparison + +inherited,LINKED_LIST.first_element,LINKED_SET.first_element + +inherited,LINKED_LIST.count,LINKED_SET.count + +inherited,LINKED_LIST.after,LINKED_SET.after + +inherited,LINKED_LIST.before,LINKED_SET.before + +inherited,LINKED_LIST.active,LINKED_SET.active + +inherited,LINKED_LIST.object_comparison,LINKED_SET.object_comparison + +inherited,SET.object_comparison,SUBSET.object_comparison + +inherited,COMPARABLE_SET.object_comparison,BINARY_SEARCH_TREE_SET.object_comparison + +inherited,TRAVERSABLE_SUBSET.object_comparison,BINARY_SEARCH_TREE_SET.object_comparison + +inherited,TRAVERSABLE_SUBSET.object_comparison,LINEAR_SUBSET.object_comparison + +inherited,COMPARABLE_SET.object_comparison,TWO_WAY_SORTED_SET.object_comparison + +inherited,LINEAR_SUBSET.object_comparison,TWO_WAY_SORTED_SET.object_comparison + +inherited,SORTED_TWO_WAY_LIST.last_element,TWO_WAY_SORTED_SET.last_element + +inherited,SORTED_TWO_WAY_LIST.active,TWO_WAY_SORTED_SET.active + +inherited,SORTED_TWO_WAY_LIST.first_element,TWO_WAY_SORTED_SET.first_element + +inherited,SORTED_TWO_WAY_LIST.sublist,TWO_WAY_SORTED_SET.sublist + +inherited,SORTED_TWO_WAY_LIST.count,TWO_WAY_SORTED_SET.count + +inherited,SORTED_TWO_WAY_LIST.object_comparison,TWO_WAY_SORTED_SET.object_comparison + +inherited,SORTED_TWO_WAY_LIST.after,TWO_WAY_SORTED_SET.after + +inherited,SORTED_TWO_WAY_LIST.before,TWO_WAY_SORTED_SET.before + +inherited,LINEAR_SUBSET.object_comparison,PART_SORTED_SET.object_comparison + +inherited,PART_SORTED_TWO_WAY_LIST.last_element,PART_SORTED_SET.last_element + +inherited,PART_SORTED_TWO_WAY_LIST.active,PART_SORTED_SET.active + +inherited,PART_SORTED_TWO_WAY_LIST.first_element,PART_SORTED_SET.first_element + +inherited,PART_SORTED_TWO_WAY_LIST.sublist,PART_SORTED_SET.sublist + +inherited,PART_SORTED_TWO_WAY_LIST.count,PART_SORTED_SET.count + +inherited,PART_SORTED_TWO_WAY_LIST.object_comparison,PART_SORTED_SET.object_comparison + +inherited,PART_SORTED_TWO_WAY_LIST.after,PART_SORTED_SET.after + +inherited,PART_SORTED_TWO_WAY_LIST.before,PART_SORTED_SET.before + +inherited,COLLECTION.object_comparison,SET.object_comparison + +inherited,CURSOR_TREE.below,RECURSIVE_CURSOR_TREE.below + +inherited,CURSOR_TREE.object_comparison,RECURSIVE_CURSOR_TREE.object_comparison + +inherited,HIERARCHICAL.object_comparison,CURSOR_TREE.object_comparison + +inherited,CURSOR_STRUCTURE.object_comparison,CURSOR_TREE.object_comparison + +inherited,LINEAR.object_comparison,CURSOR_TREE.object_comparison + +inherited,LINEAR.object_comparison,CURSOR_TREE.object_comparison + +inherited,BILINEAR.object_comparison,COMPARABLE_STRUCT.object_comparison + +inherited,COMPARABLE_STRUCT.object_comparison,SORTED_STRUCT.object_comparison + +inherited,INDEXABLE.object_comparison,SORTED_STRUCT.object_comparison + +inherited,LINEAR.object_comparison,SORTED_STRUCT.object_comparison + +inherited,TABLE.object_comparison,INDEXABLE.object_comparison + +inherited,BAG.object_comparison,ACTIVE.object_comparison + +inherited,BAG.object_comparison,TABLE.object_comparison + +inherited,COLLECTION.object_comparison,BAG.object_comparison + +inherited,ACTIVE.object_comparison,CURSOR_STRUCTURE.object_comparison + +inherited,CONTAINER.object_comparison,COLLECTION.object_comparison + +inherited,CURSOR_STRUCTURE.object_comparison,CHAIN.object_comparison + +inherited,INDEXABLE.object_comparison,CHAIN.object_comparison + +inherited,SEQUENCE.object_comparison,CHAIN.object_comparison + +inherited,DYNAMIC_CIRCULAR.internal_exhausted,LINKED_CIRCULAR.internal_exhausted + +inherited,DYNAMIC_CIRCULAR.object_comparison,LINKED_CIRCULAR.object_comparison + +inherited,LIST.object_comparison,LINKED_CIRCULAR.object_comparison + +inherited,LIST.object_comparison,PART_SORTED_LIST.object_comparison + +inherited,LINKED_LIST.first_element,TWO_WAY_LIST.first_element + +inherited,LINKED_LIST.count,TWO_WAY_LIST.count + +inherited,LINKED_LIST.after,TWO_WAY_LIST.after + +inherited,LINKED_LIST.before,TWO_WAY_LIST.before + +inherited,LINKED_LIST.active,TWO_WAY_LIST.active + +inherited,LINKED_LIST.object_comparison,TWO_WAY_LIST.object_comparison + +inherited,TWO_WAY_LIST.first_element,SORTED_TWO_WAY_LIST.first_element + +inherited,TWO_WAY_LIST.last_element,SORTED_TWO_WAY_LIST.last_element + +inherited,TWO_WAY_LIST.sublist,SORTED_TWO_WAY_LIST.sublist + +inherited,TWO_WAY_LIST.active,SORTED_TWO_WAY_LIST.active + +inherited,TWO_WAY_LIST.count,SORTED_TWO_WAY_LIST.count + +inherited,TWO_WAY_LIST.object_comparison,SORTED_TWO_WAY_LIST.object_comparison + +inherited,TWO_WAY_LIST.after,SORTED_TWO_WAY_LIST.after + +inherited,TWO_WAY_LIST.before,SORTED_TWO_WAY_LIST.before + +inherited,SORTED_LIST.object_comparison,SORTED_TWO_WAY_LIST.object_comparison + +inherited,DYNAMIC_LIST.object_comparison,MULTI_ARRAY_LIST.object_comparison + +inherited,DYNAMIC_LIST.object_comparison,LINKED_LIST.object_comparison + +inherited,ACTIVE.object_comparison,SEQUENCE.object_comparison + +inherited,BILINEAR.object_comparison,SEQUENCE.object_comparison + +inherited,FINITE.object_comparison,SEQUENCE.object_comparison + +renamed,TO_SPECIAL.area,ARRAYED_LIST.area_v2 + +inherited,RESIZABLE.object_comparison,ARRAYED_LIST.object_comparison + +inherited,DYNAMIC_LIST.object_comparison,ARRAYED_LIST.object_comparison + +inherited,CHAIN.object_comparison,LIST.object_comparison + +inherited,ARRAYED_LIST.index,FIXED_LIST.index + +inherited,ARRAYED_LIST.area_v2,FIXED_LIST.area_v2 + +inherited,ARRAYED_LIST.object_comparison,FIXED_LIST.object_comparison + +inherited,FIXED.object_comparison,FIXED_LIST.object_comparison + +inherited,CIRCULAR.internal_exhausted,DYNAMIC_CIRCULAR.internal_exhausted + +inherited,CIRCULAR.object_comparison,DYNAMIC_CIRCULAR.object_comparison + +inherited,DYNAMIC_CHAIN.object_comparison,DYNAMIC_CIRCULAR.object_comparison + +inherited,CELL.item,LINKABLE.item + +inherited,DYNAMIC_CIRCULAR.internal_exhausted,ARRAYED_CIRCULAR.internal_exhausted + +inherited,DYNAMIC_CIRCULAR.object_comparison,ARRAYED_CIRCULAR.object_comparison + +inherited,LIST.object_comparison,ARRAYED_CIRCULAR.object_comparison + +inherited,PART_SORTED_LIST.object_comparison,SORTED_LIST.object_comparison + +inherited,TWO_WAY_LIST.first_element,PART_SORTED_TWO_WAY_LIST.first_element + +inherited,TWO_WAY_LIST.last_element,PART_SORTED_TWO_WAY_LIST.last_element + +inherited,TWO_WAY_LIST.sublist,PART_SORTED_TWO_WAY_LIST.sublist + +inherited,TWO_WAY_LIST.active,PART_SORTED_TWO_WAY_LIST.active + +inherited,TWO_WAY_LIST.count,PART_SORTED_TWO_WAY_LIST.count + +inherited,TWO_WAY_LIST.object_comparison,PART_SORTED_TWO_WAY_LIST.object_comparison + +inherited,TWO_WAY_LIST.after,PART_SORTED_TWO_WAY_LIST.after + +inherited,TWO_WAY_LIST.before,PART_SORTED_TWO_WAY_LIST.before + +inherited,PART_SORTED_LIST.object_comparison,PART_SORTED_TWO_WAY_LIST.object_comparison + +inherited,LINKED_CIRCULAR.starter,TWO_WAY_CIRCULAR.starter + +inherited,LINKED_CIRCULAR.list,TWO_WAY_CIRCULAR.list + +inherited,LINKED_CIRCULAR.internal_exhausted,TWO_WAY_CIRCULAR.internal_exhausted + +inherited,LINKED_CIRCULAR.object_comparison,TWO_WAY_CIRCULAR.object_comparison + +inherited,LIST.object_comparison,DYNAMIC_LIST.object_comparison + +inherited,DYNAMIC_CHAIN.object_comparison,DYNAMIC_LIST.object_comparison + +inherited,CHAIN.object_comparison,DYNAMIC_CHAIN.object_comparison + +inherited,UNBOUNDED.object_comparison,DYNAMIC_CHAIN.object_comparison + +inherited,DYNAMIC_TABLE.object_comparison,DYNAMIC_CHAIN.object_comparison + +inherited,CHAIN.object_comparison,CIRCULAR.object_comparison + +inherited,LINKABLE.right,BI_LINKABLE.right + +inherited,LINKABLE.item,BI_LINKABLE.item + +inherited,FINITE.object_comparison,BOUNDED.object_comparison + +inherited,BOX.object_comparison,FINITE.object_comparison + +inherited,FINITE.object_comparison,UNBOUNDED.object_comparison + +inherited,BOX.object_comparison,INFINITE.object_comparison + +inherited,BOUNDED.object_comparison,RESIZABLE.object_comparison + +inherited,BOUNDED.object_comparison,FIXED.object_comparison + +inherited,CONTAINER.object_comparison,BOX.object_comparison + +inherited,INFINITE.object_comparison,COUNTABLE.object_comparison + +inherited,OBJECT_GRAPH_TRAVERSABLE.root_object,OBJECT_GRAPH_BREADTH_FIRST_TRAVERSABLE.root_object + +inherited,OBJECT_GRAPH_TRAVERSABLE.on_processing_object_action,OBJECT_GRAPH_BREADTH_FIRST_TRAVERSABLE.on_processing_object_action + +inherited,OBJECT_GRAPH_TRAVERSABLE.on_processing_reference_action,OBJECT_GRAPH_BREADTH_FIRST_TRAVERSABLE.on_processing_reference_action + +inherited,OBJECT_GRAPH_TRAVERSABLE.object_action,OBJECT_GRAPH_BREADTH_FIRST_TRAVERSABLE.object_action + +inherited,OBJECT_GRAPH_TRAVERSABLE.visited_objects,OBJECT_GRAPH_BREADTH_FIRST_TRAVERSABLE.visited_objects + +inherited,OBJECT_GRAPH_TRAVERSABLE.visited_types,OBJECT_GRAPH_BREADTH_FIRST_TRAVERSABLE.visited_types + +inherited,OBJECT_GRAPH_TRAVERSABLE.has_failed,OBJECT_GRAPH_BREADTH_FIRST_TRAVERSABLE.has_failed + +inherited,OBJECT_GRAPH_TRAVERSABLE.has_reference_with_copy_semantics,OBJECT_GRAPH_BREADTH_FIRST_TRAVERSABLE.has_reference_with_copy_semantics + +inherited,OBJECT_GRAPH_TRAVERSABLE.is_skip_transient,OBJECT_GRAPH_BREADTH_FIRST_TRAVERSABLE.is_skip_transient + +inherited,OBJECT_GRAPH_TRAVERSABLE.is_skip_copy_semantics_reference,OBJECT_GRAPH_BREADTH_FIRST_TRAVERSABLE.is_skip_copy_semantics_reference + +inherited,OBJECT_GRAPH_TRAVERSABLE.is_exception_on_copy_suppressed,OBJECT_GRAPH_BREADTH_FIRST_TRAVERSABLE.is_exception_on_copy_suppressed + +inherited,OBJECT_GRAPH_TRAVERSABLE.is_exception_propagated,OBJECT_GRAPH_BREADTH_FIRST_TRAVERSABLE.is_exception_propagated + +inherited,COUNTABLE_SEQUENCE.index,FIBONACCI.index + +inherited,COUNTABLE_SEQUENCE.object_comparison,FIBONACCI.object_comparison + +inherited,REFLECTED_OBJECT.dynamic_type,REFLECTED_COPY_SEMANTICS_OBJECT.dynamic_type + +inherited,HASH_TABLE.found_item,MISMATCH_INFORMATION.found_item + +inherited,HASH_TABLE.count,MISMATCH_INFORMATION.count + +inherited,HASH_TABLE.capacity,MISMATCH_INFORMATION.capacity + +inherited,HASH_TABLE.hash_table_version_64,MISMATCH_INFORMATION.hash_table_version_64 + +inherited,HASH_TABLE.content,MISMATCH_INFORMATION.content + +inherited,HASH_TABLE.keys,MISMATCH_INFORMATION.keys + +inherited,HASH_TABLE.indexes_map,MISMATCH_INFORMATION.indexes_map + +inherited,HASH_TABLE.deleted_marks,MISMATCH_INFORMATION.deleted_marks + +inherited,HASH_TABLE.item_position,MISMATCH_INFORMATION.item_position + +inherited,HASH_TABLE.has_default,MISMATCH_INFORMATION.has_default + +inherited,HASH_TABLE.iteration_position,MISMATCH_INFORMATION.iteration_position + +inherited,HASH_TABLE.control,MISMATCH_INFORMATION.control + +inherited,HASH_TABLE.deleted_item_position,MISMATCH_INFORMATION.deleted_item_position + +inherited,HASH_TABLE.ht_lowest_deleted_position,MISMATCH_INFORMATION.ht_lowest_deleted_position + +inherited,HASH_TABLE.ht_deleted_item,MISMATCH_INFORMATION.ht_deleted_item + +inherited,HASH_TABLE.ht_deleted_key,MISMATCH_INFORMATION.ht_deleted_key + +inherited,HASH_TABLE.object_comparison,MISMATCH_INFORMATION.object_comparison + +inherited,OBJECT_GRAPH_TRAVERSABLE.root_object,OBJECT_GRAPH_DEPTH_FIRST_TRAVERSABLE.root_object + +inherited,OBJECT_GRAPH_TRAVERSABLE.on_processing_object_action,OBJECT_GRAPH_DEPTH_FIRST_TRAVERSABLE.on_processing_object_action + +inherited,OBJECT_GRAPH_TRAVERSABLE.on_processing_reference_action,OBJECT_GRAPH_DEPTH_FIRST_TRAVERSABLE.on_processing_reference_action + +inherited,OBJECT_GRAPH_TRAVERSABLE.object_action,OBJECT_GRAPH_DEPTH_FIRST_TRAVERSABLE.object_action + +inherited,OBJECT_GRAPH_TRAVERSABLE.visited_objects,OBJECT_GRAPH_DEPTH_FIRST_TRAVERSABLE.visited_objects + +inherited,OBJECT_GRAPH_TRAVERSABLE.visited_types,OBJECT_GRAPH_DEPTH_FIRST_TRAVERSABLE.visited_types + +inherited,OBJECT_GRAPH_TRAVERSABLE.has_failed,OBJECT_GRAPH_DEPTH_FIRST_TRAVERSABLE.has_failed + +inherited,OBJECT_GRAPH_TRAVERSABLE.has_reference_with_copy_semantics,OBJECT_GRAPH_DEPTH_FIRST_TRAVERSABLE.has_reference_with_copy_semantics + +inherited,OBJECT_GRAPH_TRAVERSABLE.is_skip_transient,OBJECT_GRAPH_DEPTH_FIRST_TRAVERSABLE.is_skip_transient + +inherited,OBJECT_GRAPH_TRAVERSABLE.is_skip_copy_semantics_reference,OBJECT_GRAPH_DEPTH_FIRST_TRAVERSABLE.is_skip_copy_semantics_reference + +inherited,OBJECT_GRAPH_TRAVERSABLE.is_exception_on_copy_suppressed,OBJECT_GRAPH_DEPTH_FIRST_TRAVERSABLE.is_exception_on_copy_suppressed + +inherited,OBJECT_GRAPH_TRAVERSABLE.is_exception_propagated,OBJECT_GRAPH_DEPTH_FIRST_TRAVERSABLE.is_exception_propagated + +inherited,COUNTABLE_SEQUENCE.index,PRIMES.index + +inherited,COUNTABLE_SEQUENCE.object_comparison,PRIMES.object_comparison + +inherited,HASH_TABLE.found_item,CLASS_NAME_TRANSLATIONS.found_item + +inherited,HASH_TABLE.count,CLASS_NAME_TRANSLATIONS.count + +inherited,HASH_TABLE.capacity,CLASS_NAME_TRANSLATIONS.capacity + +inherited,HASH_TABLE.hash_table_version_64,CLASS_NAME_TRANSLATIONS.hash_table_version_64 + +inherited,HASH_TABLE.content,CLASS_NAME_TRANSLATIONS.content + +inherited,HASH_TABLE.keys,CLASS_NAME_TRANSLATIONS.keys + +inherited,HASH_TABLE.indexes_map,CLASS_NAME_TRANSLATIONS.indexes_map + +inherited,HASH_TABLE.deleted_marks,CLASS_NAME_TRANSLATIONS.deleted_marks + +inherited,HASH_TABLE.item_position,CLASS_NAME_TRANSLATIONS.item_position + +inherited,HASH_TABLE.has_default,CLASS_NAME_TRANSLATIONS.has_default + +inherited,HASH_TABLE.iteration_position,CLASS_NAME_TRANSLATIONS.iteration_position + +inherited,HASH_TABLE.control,CLASS_NAME_TRANSLATIONS.control + +inherited,HASH_TABLE.deleted_item_position,CLASS_NAME_TRANSLATIONS.deleted_item_position + +inherited,HASH_TABLE.ht_lowest_deleted_position,CLASS_NAME_TRANSLATIONS.ht_lowest_deleted_position + +inherited,HASH_TABLE.ht_deleted_item,CLASS_NAME_TRANSLATIONS.ht_deleted_item + +inherited,HASH_TABLE.ht_deleted_key,CLASS_NAME_TRANSLATIONS.ht_deleted_key + +inherited,HASH_TABLE.object_comparison,CLASS_NAME_TRANSLATIONS.object_comparison + +inherited,COUNTABLE.object_comparison,COUNTABLE_SEQUENCE.object_comparison + +inherited,LINEAR.object_comparison,COUNTABLE_SEQUENCE.object_comparison + +inherited,ACTIVE.object_comparison,COUNTABLE_SEQUENCE.object_comparison + +inherited,TO_SPECIAL.area,BOOL_STRING.area + +inherited,COUNTABLE_SEQUENCE.index,RANDOM.index + +inherited,COUNTABLE_SEQUENCE.object_comparison,RANDOM.object_comparison + +inherited,FORMAT_INTEGER.fill_character,FORMAT_DOUBLE.fill_character + +inherited,FORMAT_INTEGER.width,FORMAT_DOUBLE.width + +inherited,FORMAT_INTEGER.separator,FORMAT_DOUBLE.separator + +inherited,FORMAT_INTEGER.justification,FORMAT_DOUBLE.justification + +inherited,FORMAT_INTEGER.trailing_sign,FORMAT_DOUBLE.trailing_sign + +inherited,FORMAT_INTEGER.sign_format,FORMAT_DOUBLE.sign_format + +inherited,FORMAT_INTEGER.sign_string,FORMAT_DOUBLE.sign_string + +inherited,FORMAT_INTEGER.bracketted_negative,FORMAT_DOUBLE.bracketted_negative + +inherited,REFLECTED_OBJECT.dynamic_type,REFLECTED_REFERENCE_OBJECT.dynamic_type + +inherited,IO_MEDIUM.last_character,STREAM.last_character + +inherited,IO_MEDIUM.last_string,STREAM.last_string + +inherited,IO_MEDIUM.last_integer,STREAM.last_integer + +inherited,IO_MEDIUM.last_integer_64,STREAM.last_integer_64 + +inherited,IO_MEDIUM.last_integer_16,STREAM.last_integer_16 + +inherited,IO_MEDIUM.last_integer_8,STREAM.last_integer_8 + +inherited,IO_MEDIUM.last_natural_64,STREAM.last_natural_64 + +inherited,IO_MEDIUM.last_natural,STREAM.last_natural + +inherited,IO_MEDIUM.last_natural_16,STREAM.last_natural_16 + +inherited,IO_MEDIUM.last_natural_8,STREAM.last_natural_8 + +inherited,IO_MEDIUM.last_real,STREAM.last_real + +inherited,IO_MEDIUM.last_double,STREAM.last_double + +inherited,IO_MEDIUM.bytes_read,STREAM.bytes_read + +inherited,PATH_NAME.area,DIRECTORY_NAME.area + +inherited,PATH_NAME.internal_case_insensitive_hash_code,DIRECTORY_NAME.internal_case_insensitive_hash_code + +inherited,PATH_NAME.internal_hash_code,DIRECTORY_NAME.internal_hash_code + +inherited,PATH_NAME.count,DIRECTORY_NAME.count + +inherited,PATH_NAME.object_comparison,DIRECTORY_NAME.object_comparison + +inherited,FILE_INFO.exists,UNIX_FILE_INFO.exists + +inherited,FILE_INFO.is_following_symlinks,UNIX_FILE_INFO.is_following_symlinks + +inherited,FILE_INFO.internal_file_name,UNIX_FILE_INFO.internal_file_name + +inherited,FILE_INFO.internal_name_pointer,UNIX_FILE_INFO.internal_name_pointer + +inherited,FILE_INFO.buffered_file_info,UNIX_FILE_INFO.buffered_file_info + +renamed,TO_SPECIAL.area,FILE_INFO.buffered_file_info + +inherited,MEMORY_STRUCTURE.shared,MEM_INFO.shared + +inherited,MEMORY_STRUCTURE.internal_item,MEM_INFO.internal_item + +inherited,MEMORY_STRUCTURE.managed_pointer,MEM_INFO.managed_pointer + +inherited,FILE.descriptor_available,RAW_FILE.descriptor_available + +inherited,FILE.separator,RAW_FILE.separator + +inherited,FILE.file_pointer,RAW_FILE.file_pointer + +inherited,FILE.internal_name,RAW_FILE.internal_name + +inherited,FILE.internal_detachable_name_pointer,RAW_FILE.internal_detachable_name_pointer + +inherited,FILE.mode,RAW_FILE.mode + +inherited,FILE.bytes_read,RAW_FILE.bytes_read + +inherited,FILE.last_double,RAW_FILE.last_double + +inherited,FILE.last_real,RAW_FILE.last_real + +inherited,FILE.last_natural_8,RAW_FILE.last_natural_8 + +inherited,FILE.last_natural_16,RAW_FILE.last_natural_16 + +inherited,FILE.last_natural,RAW_FILE.last_natural + +inherited,FILE.last_natural_64,RAW_FILE.last_natural_64 + +inherited,FILE.last_integer_8,RAW_FILE.last_integer_8 + +inherited,FILE.last_integer_16,RAW_FILE.last_integer_16 + +inherited,FILE.last_integer_64,RAW_FILE.last_integer_64 + +inherited,FILE.last_integer,RAW_FILE.last_integer + +inherited,FILE.last_string,RAW_FILE.last_string + +inherited,FILE.last_character,RAW_FILE.last_character + +inherited,FILE.object_comparison,RAW_FILE.object_comparison + +inherited,FILE.descriptor_available,PLAIN_TEXT_FILE.descriptor_available + +inherited,FILE.separator,PLAIN_TEXT_FILE.separator + +inherited,FILE.file_pointer,PLAIN_TEXT_FILE.file_pointer + +inherited,FILE.internal_name,PLAIN_TEXT_FILE.internal_name + +inherited,FILE.internal_detachable_name_pointer,PLAIN_TEXT_FILE.internal_detachable_name_pointer + +inherited,FILE.mode,PLAIN_TEXT_FILE.mode + +inherited,FILE.bytes_read,PLAIN_TEXT_FILE.bytes_read + +inherited,FILE.last_double,PLAIN_TEXT_FILE.last_double + +inherited,FILE.last_real,PLAIN_TEXT_FILE.last_real + +inherited,FILE.last_natural_8,PLAIN_TEXT_FILE.last_natural_8 + +inherited,FILE.last_natural_16,PLAIN_TEXT_FILE.last_natural_16 + +inherited,FILE.last_natural,PLAIN_TEXT_FILE.last_natural + +inherited,FILE.last_natural_64,PLAIN_TEXT_FILE.last_natural_64 + +inherited,FILE.last_integer_8,PLAIN_TEXT_FILE.last_integer_8 + +inherited,FILE.last_integer_16,PLAIN_TEXT_FILE.last_integer_16 + +inherited,FILE.last_integer_64,PLAIN_TEXT_FILE.last_integer_64 + +inherited,FILE.last_integer,PLAIN_TEXT_FILE.last_integer + +inherited,FILE.last_string,PLAIN_TEXT_FILE.last_string + +inherited,FILE.last_character,PLAIN_TEXT_FILE.last_character + +inherited,FILE.object_comparison,PLAIN_TEXT_FILE.object_comparison + +inherited,PATH_NAME.area,FILE_NAME.area + +inherited,PATH_NAME.internal_case_insensitive_hash_code,FILE_NAME.internal_case_insensitive_hash_code + +inherited,PATH_NAME.internal_hash_code,FILE_NAME.internal_hash_code + +inherited,PATH_NAME.count,FILE_NAME.count + +inherited,PATH_NAME.object_comparison,FILE_NAME.object_comparison + +inherited,MEMORY_STRUCTURE.shared,GC_INFO.shared + +inherited,MEMORY_STRUCTURE.internal_item,GC_INFO.internal_item + +inherited,MEMORY_STRUCTURE.managed_pointer,GC_INFO.managed_pointer + +inherited,UNBOUNDED.object_comparison,FILE.object_comparison + +inherited,SEQUENCE.object_comparison,FILE.object_comparison + +renamed,IO_MEDIUM.handle_available,FILE.descriptor_available + +inherited,IO_MEDIUM.last_character,FILE.last_character + +inherited,IO_MEDIUM.last_string,FILE.last_string + +inherited,IO_MEDIUM.last_integer,FILE.last_integer + +inherited,IO_MEDIUM.last_integer_64,FILE.last_integer_64 + +inherited,IO_MEDIUM.last_integer_16,FILE.last_integer_16 + +inherited,IO_MEDIUM.last_integer_8,FILE.last_integer_8 + +inherited,IO_MEDIUM.last_natural_64,FILE.last_natural_64 + +inherited,IO_MEDIUM.last_natural,FILE.last_natural + +inherited,IO_MEDIUM.last_natural_16,FILE.last_natural_16 + +inherited,IO_MEDIUM.last_natural_8,FILE.last_natural_8 + +inherited,IO_MEDIUM.last_real,FILE.last_real + +inherited,IO_MEDIUM.last_double,FILE.last_double + +inherited,IO_MEDIUM.bytes_read,FILE.bytes_read + +inherited,RESIZABLE.object_comparison,INTEGER_INTERVAL.object_comparison + +inherited,INDEXABLE.object_comparison,INTEGER_INTERVAL.object_comparison + +inherited,SET.object_comparison,INTEGER_INTERVAL.object_comparison + +inherited,PLAIN_TEXT_FILE.last_string_32,CONSOLE.last_string_32 + +inherited,PLAIN_TEXT_FILE.internal_encoding,CONSOLE.internal_encoding + +inherited,PLAIN_TEXT_FILE.is_sequence_an_expected_numeric,CONSOLE.is_sequence_an_expected_numeric + +inherited,PLAIN_TEXT_FILE.mode,CONSOLE.mode + +inherited,PLAIN_TEXT_FILE.internal_detachable_name_pointer,CONSOLE.internal_detachable_name_pointer + +inherited,PLAIN_TEXT_FILE.internal_name,CONSOLE.internal_name + +inherited,PLAIN_TEXT_FILE.file_pointer,CONSOLE.file_pointer + +inherited,PLAIN_TEXT_FILE.separator,CONSOLE.separator + +inherited,PLAIN_TEXT_FILE.bytes_read,CONSOLE.bytes_read + +inherited,PLAIN_TEXT_FILE.last_double,CONSOLE.last_double + +inherited,PLAIN_TEXT_FILE.last_real,CONSOLE.last_real + +inherited,PLAIN_TEXT_FILE.last_natural_8,CONSOLE.last_natural_8 + +inherited,PLAIN_TEXT_FILE.last_natural_16,CONSOLE.last_natural_16 + +inherited,PLAIN_TEXT_FILE.last_natural,CONSOLE.last_natural + +inherited,PLAIN_TEXT_FILE.last_natural_64,CONSOLE.last_natural_64 + +inherited,PLAIN_TEXT_FILE.last_integer_8,CONSOLE.last_integer_8 + +inherited,PLAIN_TEXT_FILE.last_integer_16,CONSOLE.last_integer_16 + +inherited,PLAIN_TEXT_FILE.last_integer_64,CONSOLE.last_integer_64 + +inherited,PLAIN_TEXT_FILE.last_integer,CONSOLE.last_integer + +inherited,PLAIN_TEXT_FILE.last_string,CONSOLE.last_string + +inherited,PLAIN_TEXT_FILE.last_character,CONSOLE.last_character + +inherited,PLAIN_TEXT_FILE.descriptor_available,CONSOLE.descriptor_available + +inherited,PLAIN_TEXT_FILE.object_comparison,CONSOLE.object_comparison + +inherited,STRING.area,PATH_NAME.area + +inherited,STRING.internal_case_insensitive_hash_code,PATH_NAME.internal_case_insensitive_hash_code + +inherited,STRING.internal_hash_code,PATH_NAME.internal_hash_code + +inherited,STRING.count,PATH_NAME.count + +inherited,STRING.object_comparison,PATH_NAME.object_comparison + +inherited,SYS_EXCEPTION.internal_trace,EIF_EXCEPTION.internal_trace + +inherited,SYS_EXCEPTION.internal_is_ignorable,EIF_EXCEPTION.internal_is_ignorable + +inherited,SYS_EXCEPTION.c_description,EIF_EXCEPTION.c_description + +inherited,SYS_EXCEPTION.throwing_exception,EIF_EXCEPTION.throwing_exception + +inherited,SYS_EXCEPTION.line_number,EIF_EXCEPTION.line_number + +inherited,SYS_EXCEPTION.type_name,EIF_EXCEPTION.type_name + +inherited,SYS_EXCEPTION.recipient_name,EIF_EXCEPTION.recipient_name + +inherited,EIF_EXCEPTION.internal_trace,LANGUAGE_EXCEPTION.internal_trace + +inherited,EIF_EXCEPTION.internal_is_ignorable,LANGUAGE_EXCEPTION.internal_is_ignorable + +inherited,EIF_EXCEPTION.c_description,LANGUAGE_EXCEPTION.c_description + +inherited,EIF_EXCEPTION.throwing_exception,LANGUAGE_EXCEPTION.throwing_exception + +inherited,EIF_EXCEPTION.line_number,LANGUAGE_EXCEPTION.line_number + +inherited,EIF_EXCEPTION.type_name,LANGUAGE_EXCEPTION.type_name + +inherited,EIF_EXCEPTION.recipient_name,LANGUAGE_EXCEPTION.recipient_name + +inherited,MACHINE_EXCEPTION.internal_trace,OPERATING_SYSTEM_EXCEPTION.internal_trace + +inherited,MACHINE_EXCEPTION.internal_is_ignorable,OPERATING_SYSTEM_EXCEPTION.internal_is_ignorable + +inherited,MACHINE_EXCEPTION.c_description,OPERATING_SYSTEM_EXCEPTION.c_description + +inherited,MACHINE_EXCEPTION.throwing_exception,OPERATING_SYSTEM_EXCEPTION.throwing_exception + +inherited,MACHINE_EXCEPTION.line_number,OPERATING_SYSTEM_EXCEPTION.line_number + +inherited,MACHINE_EXCEPTION.type_name,OPERATING_SYSTEM_EXCEPTION.type_name + +inherited,MACHINE_EXCEPTION.recipient_name,OPERATING_SYSTEM_EXCEPTION.recipient_name + +inherited,ASSERTION_VIOLATION.internal_trace,CHECK_VIOLATION.internal_trace + +inherited,ASSERTION_VIOLATION.internal_is_ignorable,CHECK_VIOLATION.internal_is_ignorable + +inherited,ASSERTION_VIOLATION.c_description,CHECK_VIOLATION.c_description + +inherited,ASSERTION_VIOLATION.throwing_exception,CHECK_VIOLATION.throwing_exception + +inherited,ASSERTION_VIOLATION.line_number,CHECK_VIOLATION.line_number + +inherited,ASSERTION_VIOLATION.type_name,CHECK_VIOLATION.type_name + +inherited,ASSERTION_VIOLATION.recipient_name,CHECK_VIOLATION.recipient_name + +inherited,EXCEPTION.recipient_name,ASSERTION_VIOLATION.recipient_name + +inherited,EXCEPTION.type_name,ASSERTION_VIOLATION.type_name + +inherited,EXCEPTION.line_number,ASSERTION_VIOLATION.line_number + +inherited,EXCEPTION.throwing_exception,ASSERTION_VIOLATION.throwing_exception + +inherited,EXCEPTION.c_description,ASSERTION_VIOLATION.c_description + +inherited,EXCEPTION.internal_is_ignorable,ASSERTION_VIOLATION.internal_is_ignorable + +inherited,EXCEPTION.internal_trace,ASSERTION_VIOLATION.internal_trace + +inherited,EXCEPTION.recipient_name,DEVELOPER_EXCEPTION.recipient_name + +inherited,EXCEPTION.type_name,DEVELOPER_EXCEPTION.type_name + +inherited,EXCEPTION.line_number,DEVELOPER_EXCEPTION.line_number + +inherited,EXCEPTION.throwing_exception,DEVELOPER_EXCEPTION.throwing_exception + +inherited,EXCEPTION.c_description,DEVELOPER_EXCEPTION.c_description + +inherited,EXCEPTION.internal_is_ignorable,DEVELOPER_EXCEPTION.internal_is_ignorable + +inherited,EXCEPTION.internal_trace,DEVELOPER_EXCEPTION.internal_trace + +inherited,ASSERTION_VIOLATION.internal_trace,VARIANT_VIOLATION.internal_trace + +inherited,ASSERTION_VIOLATION.internal_is_ignorable,VARIANT_VIOLATION.internal_is_ignorable + +inherited,ASSERTION_VIOLATION.c_description,VARIANT_VIOLATION.c_description + +inherited,ASSERTION_VIOLATION.throwing_exception,VARIANT_VIOLATION.throwing_exception + +inherited,ASSERTION_VIOLATION.line_number,VARIANT_VIOLATION.line_number + +inherited,ASSERTION_VIOLATION.type_name,VARIANT_VIOLATION.type_name + +inherited,ASSERTION_VIOLATION.recipient_name,VARIANT_VIOLATION.recipient_name + +inherited,EXCEPTION.recipient_name,MACHINE_EXCEPTION.recipient_name + +inherited,EXCEPTION.type_name,MACHINE_EXCEPTION.type_name + +inherited,EXCEPTION.line_number,MACHINE_EXCEPTION.line_number + +inherited,EXCEPTION.throwing_exception,MACHINE_EXCEPTION.throwing_exception + +inherited,EXCEPTION.c_description,MACHINE_EXCEPTION.c_description + +inherited,EXCEPTION.internal_is_ignorable,MACHINE_EXCEPTION.internal_is_ignorable + +inherited,EXCEPTION.internal_trace,MACHINE_EXCEPTION.internal_trace + +inherited,LANGUAGE_EXCEPTION.internal_trace,BAD_INSPECT_VALUE.internal_trace + +inherited,LANGUAGE_EXCEPTION.internal_is_ignorable,BAD_INSPECT_VALUE.internal_is_ignorable + +inherited,LANGUAGE_EXCEPTION.c_description,BAD_INSPECT_VALUE.c_description + +inherited,LANGUAGE_EXCEPTION.throwing_exception,BAD_INSPECT_VALUE.throwing_exception + +inherited,LANGUAGE_EXCEPTION.line_number,BAD_INSPECT_VALUE.line_number + +inherited,LANGUAGE_EXCEPTION.type_name,BAD_INSPECT_VALUE.type_name + +inherited,LANGUAGE_EXCEPTION.recipient_name,BAD_INSPECT_VALUE.recipient_name + +inherited,EIF_EXCEPTION.internal_trace,EIFFEL_RUNTIME_EXCEPTION.internal_trace + +inherited,EIF_EXCEPTION.internal_is_ignorable,EIFFEL_RUNTIME_EXCEPTION.internal_is_ignorable + +inherited,EIF_EXCEPTION.c_description,EIFFEL_RUNTIME_EXCEPTION.c_description + +inherited,EIF_EXCEPTION.throwing_exception,EIFFEL_RUNTIME_EXCEPTION.throwing_exception + +inherited,EIF_EXCEPTION.line_number,EIFFEL_RUNTIME_EXCEPTION.line_number + +inherited,EIF_EXCEPTION.type_name,EIFFEL_RUNTIME_EXCEPTION.type_name + +inherited,EIF_EXCEPTION.recipient_name,EIFFEL_RUNTIME_EXCEPTION.recipient_name + +inherited,MACHINE_EXCEPTION.internal_trace,HARDWARE_EXCEPTION.internal_trace + +inherited,MACHINE_EXCEPTION.internal_is_ignorable,HARDWARE_EXCEPTION.internal_is_ignorable + +inherited,MACHINE_EXCEPTION.c_description,HARDWARE_EXCEPTION.c_description + +inherited,MACHINE_EXCEPTION.throwing_exception,HARDWARE_EXCEPTION.throwing_exception + +inherited,MACHINE_EXCEPTION.line_number,HARDWARE_EXCEPTION.line_number + +inherited,MACHINE_EXCEPTION.type_name,HARDWARE_EXCEPTION.type_name + +inherited,MACHINE_EXCEPTION.recipient_name,HARDWARE_EXCEPTION.recipient_name + +inherited,ASSERTION_VIOLATION.internal_trace,LOOP_INVARIANT_VIOLATION.internal_trace + +inherited,ASSERTION_VIOLATION.internal_is_ignorable,LOOP_INVARIANT_VIOLATION.internal_is_ignorable + +inherited,ASSERTION_VIOLATION.c_description,LOOP_INVARIANT_VIOLATION.c_description + +inherited,ASSERTION_VIOLATION.throwing_exception,LOOP_INVARIANT_VIOLATION.throwing_exception + +inherited,ASSERTION_VIOLATION.line_number,LOOP_INVARIANT_VIOLATION.line_number + +inherited,ASSERTION_VIOLATION.type_name,LOOP_INVARIANT_VIOLATION.type_name + +inherited,ASSERTION_VIOLATION.recipient_name,LOOP_INVARIANT_VIOLATION.recipient_name + +inherited,SYS_EXCEPTION.internal_trace,OLD_VIOLATION.internal_trace + +inherited,SYS_EXCEPTION.internal_is_ignorable,OLD_VIOLATION.internal_is_ignorable + +inherited,SYS_EXCEPTION.c_description,OLD_VIOLATION.c_description + +inherited,SYS_EXCEPTION.throwing_exception,OLD_VIOLATION.throwing_exception + +inherited,SYS_EXCEPTION.line_number,OLD_VIOLATION.line_number + +inherited,SYS_EXCEPTION.type_name,OLD_VIOLATION.type_name + +inherited,SYS_EXCEPTION.recipient_name,OLD_VIOLATION.recipient_name + +inherited,ASSERTION_VIOLATION.internal_trace,PRECONDITION_VIOLATION.internal_trace + +inherited,ASSERTION_VIOLATION.internal_is_ignorable,PRECONDITION_VIOLATION.internal_is_ignorable + +inherited,ASSERTION_VIOLATION.c_description,PRECONDITION_VIOLATION.c_description + +inherited,ASSERTION_VIOLATION.throwing_exception,PRECONDITION_VIOLATION.throwing_exception + +inherited,ASSERTION_VIOLATION.line_number,PRECONDITION_VIOLATION.line_number + +inherited,ASSERTION_VIOLATION.type_name,PRECONDITION_VIOLATION.type_name + +inherited,ASSERTION_VIOLATION.recipient_name,PRECONDITION_VIOLATION.recipient_name + +inherited,OPERATING_SYSTEM_EXCEPTION.internal_trace,COM_FAILURE.internal_trace + +inherited,OPERATING_SYSTEM_EXCEPTION.internal_is_ignorable,COM_FAILURE.internal_is_ignorable + +inherited,OPERATING_SYSTEM_EXCEPTION.c_description,COM_FAILURE.c_description + +inherited,OPERATING_SYSTEM_EXCEPTION.throwing_exception,COM_FAILURE.throwing_exception + +inherited,OPERATING_SYSTEM_EXCEPTION.line_number,COM_FAILURE.line_number + +inherited,OPERATING_SYSTEM_EXCEPTION.type_name,COM_FAILURE.type_name + +inherited,OPERATING_SYSTEM_EXCEPTION.recipient_name,COM_FAILURE.recipient_name + +inherited,OPERATING_SYSTEM_EXCEPTION.internal_trace,OPERATING_SYSTEM_SIGNAL_FAILURE.internal_trace + +inherited,OPERATING_SYSTEM_EXCEPTION.internal_is_ignorable,OPERATING_SYSTEM_SIGNAL_FAILURE.internal_is_ignorable + +inherited,OPERATING_SYSTEM_EXCEPTION.c_description,OPERATING_SYSTEM_SIGNAL_FAILURE.c_description + +inherited,OPERATING_SYSTEM_EXCEPTION.throwing_exception,OPERATING_SYSTEM_SIGNAL_FAILURE.throwing_exception + +inherited,OPERATING_SYSTEM_EXCEPTION.line_number,OPERATING_SYSTEM_SIGNAL_FAILURE.line_number + +inherited,OPERATING_SYSTEM_EXCEPTION.type_name,OPERATING_SYSTEM_SIGNAL_FAILURE.type_name + +inherited,OPERATING_SYSTEM_EXCEPTION.recipient_name,OPERATING_SYSTEM_SIGNAL_FAILURE.recipient_name + +inherited,ASSERTION_VIOLATION.internal_trace,INVARIANT_VIOLATION.internal_trace + +inherited,ASSERTION_VIOLATION.internal_is_ignorable,INVARIANT_VIOLATION.internal_is_ignorable + +inherited,ASSERTION_VIOLATION.c_description,INVARIANT_VIOLATION.c_description + +inherited,ASSERTION_VIOLATION.throwing_exception,INVARIANT_VIOLATION.throwing_exception + +inherited,ASSERTION_VIOLATION.line_number,INVARIANT_VIOLATION.line_number + +inherited,ASSERTION_VIOLATION.type_name,INVARIANT_VIOLATION.type_name + +inherited,ASSERTION_VIOLATION.recipient_name,INVARIANT_VIOLATION.recipient_name + +inherited,EXCEPTION.recipient_name,SYS_EXCEPTION.recipient_name + +inherited,EXCEPTION.type_name,SYS_EXCEPTION.type_name + +inherited,EXCEPTION.line_number,SYS_EXCEPTION.line_number + +inherited,EXCEPTION.throwing_exception,SYS_EXCEPTION.throwing_exception + +inherited,EXCEPTION.c_description,SYS_EXCEPTION.c_description + +inherited,EXCEPTION.internal_is_ignorable,SYS_EXCEPTION.internal_is_ignorable + +inherited,EXCEPTION.internal_trace,SYS_EXCEPTION.internal_trace + +inherited,OPERATING_SYSTEM_EXCEPTION.internal_trace,OPERATING_SYSTEM_FAILURE.internal_trace + +inherited,OPERATING_SYSTEM_EXCEPTION.internal_is_ignorable,OPERATING_SYSTEM_FAILURE.internal_is_ignorable + +inherited,OPERATING_SYSTEM_EXCEPTION.c_description,OPERATING_SYSTEM_FAILURE.c_description + +inherited,OPERATING_SYSTEM_EXCEPTION.throwing_exception,OPERATING_SYSTEM_FAILURE.throwing_exception + +inherited,OPERATING_SYSTEM_EXCEPTION.line_number,OPERATING_SYSTEM_FAILURE.line_number + +inherited,OPERATING_SYSTEM_EXCEPTION.type_name,OPERATING_SYSTEM_FAILURE.type_name + +inherited,OPERATING_SYSTEM_EXCEPTION.recipient_name,OPERATING_SYSTEM_FAILURE.recipient_name + +inherited,HARDWARE_EXCEPTION.internal_trace,FLOATING_POINT_FAILURE.internal_trace + +inherited,HARDWARE_EXCEPTION.internal_is_ignorable,FLOATING_POINT_FAILURE.internal_is_ignorable + +inherited,HARDWARE_EXCEPTION.c_description,FLOATING_POINT_FAILURE.c_description + +inherited,HARDWARE_EXCEPTION.throwing_exception,FLOATING_POINT_FAILURE.throwing_exception + +inherited,HARDWARE_EXCEPTION.line_number,FLOATING_POINT_FAILURE.line_number + +inherited,HARDWARE_EXCEPTION.type_name,FLOATING_POINT_FAILURE.type_name + +inherited,HARDWARE_EXCEPTION.recipient_name,FLOATING_POINT_FAILURE.recipient_name + +inherited,LANGUAGE_EXCEPTION.internal_trace,ROUTINE_FAILURE.internal_trace + +inherited,LANGUAGE_EXCEPTION.internal_is_ignorable,ROUTINE_FAILURE.internal_is_ignorable + +inherited,LANGUAGE_EXCEPTION.c_description,ROUTINE_FAILURE.c_description + +inherited,LANGUAGE_EXCEPTION.throwing_exception,ROUTINE_FAILURE.throwing_exception + +inherited,LANGUAGE_EXCEPTION.line_number,ROUTINE_FAILURE.line_number + +inherited,LANGUAGE_EXCEPTION.type_name,ROUTINE_FAILURE.type_name + +inherited,LANGUAGE_EXCEPTION.recipient_name,ROUTINE_FAILURE.recipient_name + +inherited,LANGUAGE_EXCEPTION.internal_trace,VOID_TARGET.internal_trace + +inherited,LANGUAGE_EXCEPTION.internal_is_ignorable,VOID_TARGET.internal_is_ignorable + +inherited,LANGUAGE_EXCEPTION.c_description,VOID_TARGET.c_description + +inherited,LANGUAGE_EXCEPTION.throwing_exception,VOID_TARGET.throwing_exception + +inherited,LANGUAGE_EXCEPTION.line_number,VOID_TARGET.line_number + +inherited,LANGUAGE_EXCEPTION.type_name,VOID_TARGET.type_name + +inherited,LANGUAGE_EXCEPTION.recipient_name,VOID_TARGET.recipient_name + +inherited,LANGUAGE_EXCEPTION.internal_trace,VOID_ASSIGNED_TO_EXPANDED.internal_trace + +inherited,LANGUAGE_EXCEPTION.internal_is_ignorable,VOID_ASSIGNED_TO_EXPANDED.internal_is_ignorable + +inherited,LANGUAGE_EXCEPTION.c_description,VOID_ASSIGNED_TO_EXPANDED.c_description + +inherited,LANGUAGE_EXCEPTION.throwing_exception,VOID_ASSIGNED_TO_EXPANDED.throwing_exception + +inherited,LANGUAGE_EXCEPTION.line_number,VOID_ASSIGNED_TO_EXPANDED.line_number + +inherited,LANGUAGE_EXCEPTION.type_name,VOID_ASSIGNED_TO_EXPANDED.type_name + +inherited,LANGUAGE_EXCEPTION.recipient_name,VOID_ASSIGNED_TO_EXPANDED.recipient_name + +inherited,ASSERTION_VIOLATION.internal_trace,POSTCONDITION_VIOLATION.internal_trace + +inherited,ASSERTION_VIOLATION.internal_is_ignorable,POSTCONDITION_VIOLATION.internal_is_ignorable + +inherited,ASSERTION_VIOLATION.c_description,POSTCONDITION_VIOLATION.c_description + +inherited,ASSERTION_VIOLATION.throwing_exception,POSTCONDITION_VIOLATION.throwing_exception + +inherited,ASSERTION_VIOLATION.line_number,POSTCONDITION_VIOLATION.line_number + +inherited,ASSERTION_VIOLATION.type_name,POSTCONDITION_VIOLATION.type_name + +inherited,ASSERTION_VIOLATION.recipient_name,POSTCONDITION_VIOLATION.recipient_name + +inherited,EXCEPTION.recipient_name,OBSOLETE_EXCEPTION.recipient_name + +inherited,EXCEPTION.type_name,OBSOLETE_EXCEPTION.type_name + +inherited,EXCEPTION.line_number,OBSOLETE_EXCEPTION.line_number + +inherited,EXCEPTION.throwing_exception,OBSOLETE_EXCEPTION.throwing_exception + +inherited,EXCEPTION.c_description,OBSOLETE_EXCEPTION.c_description + +inherited,EXCEPTION.internal_is_ignorable,OBSOLETE_EXCEPTION.internal_is_ignorable + +inherited,EXCEPTION.internal_trace,OBSOLETE_EXCEPTION.internal_trace + +inherited,STRING_SEARCHER.deltas,STRING_8_SEARCHER.deltas + +inherited,STRING_SEARCHER.deltas_array,STRING_8_SEARCHER.deltas_array + +inherited,STRING_SEARCHER.deltas,STRING_32_SEARCHER.deltas + +inherited,STRING_SEARCHER.deltas_array,STRING_32_SEARCHER.deltas_array + +inherited,READABLE_STRING_GENERAL.internal_hash_code,STRING_GENERAL.internal_hash_code + +inherited,READABLE_STRING_GENERAL.internal_case_insensitive_hash_code,STRING_GENERAL.internal_case_insensitive_hash_code + +inherited,STRING_TO_NUMERIC_CONVERTOR.trailing_separators_acceptable,HEXADECIMAL_STRING_TO_INTEGER_CONVERTER.trailing_separators_acceptable + +inherited,STRING_TO_NUMERIC_CONVERTOR.leading_separators_acceptable,HEXADECIMAL_STRING_TO_INTEGER_CONVERTER.leading_separators_acceptable + +inherited,STRING_TO_NUMERIC_CONVERTOR.leading_separators,HEXADECIMAL_STRING_TO_INTEGER_CONVERTER.leading_separators + +inherited,STRING_TO_NUMERIC_CONVERTOR.trailing_separators,HEXADECIMAL_STRING_TO_INTEGER_CONVERTER.trailing_separators + +inherited,STRING_TO_NUMERIC_CONVERTOR.conversion_type,HEXADECIMAL_STRING_TO_INTEGER_CONVERTER.conversion_type + +inherited,STRING_TO_NUMERIC_CONVERTOR.last_state,HEXADECIMAL_STRING_TO_INTEGER_CONVERTER.last_state + +inherited,STRING_TO_NUMERIC_CONVERTOR.sign,HEXADECIMAL_STRING_TO_INTEGER_CONVERTER.sign + +inherited,STRING_TO_NUMERIC_CONVERTOR.trailing_separators_acceptable,STRING_TO_INTEGER_CONVERTOR.trailing_separators_acceptable + +inherited,STRING_TO_NUMERIC_CONVERTOR.leading_separators_acceptable,STRING_TO_INTEGER_CONVERTOR.leading_separators_acceptable + +inherited,STRING_TO_NUMERIC_CONVERTOR.leading_separators,STRING_TO_INTEGER_CONVERTOR.leading_separators + +inherited,STRING_TO_NUMERIC_CONVERTOR.trailing_separators,STRING_TO_INTEGER_CONVERTOR.trailing_separators + +inherited,STRING_TO_NUMERIC_CONVERTOR.conversion_type,STRING_TO_INTEGER_CONVERTOR.conversion_type + +inherited,STRING_TO_NUMERIC_CONVERTOR.last_state,STRING_TO_INTEGER_CONVERTOR.last_state + +inherited,STRING_TO_NUMERIC_CONVERTOR.sign,STRING_TO_INTEGER_CONVERTOR.sign + +inherited,READABLE_STRING_GENERAL.internal_hash_code,IMMUTABLE_STRING_GENERAL.internal_hash_code + +inherited,READABLE_STRING_GENERAL.internal_case_insensitive_hash_code,IMMUTABLE_STRING_GENERAL.internal_case_insensitive_hash_code + +inherited,READABLE_STRING_GENERAL.internal_hash_code,READABLE_STRING_32.internal_hash_code + +inherited,READABLE_STRING_GENERAL.internal_case_insensitive_hash_code,READABLE_STRING_32.internal_case_insensitive_hash_code + +renamed,READABLE_INDEXABLE.upper,READABLE_STRING_32.count + +inherited,STRING_TO_NUMERIC_CONVERTOR.trailing_separators_acceptable,STRING_TO_REAL_CONVERTOR.trailing_separators_acceptable + +inherited,STRING_TO_NUMERIC_CONVERTOR.leading_separators_acceptable,STRING_TO_REAL_CONVERTOR.leading_separators_acceptable + +inherited,STRING_TO_NUMERIC_CONVERTOR.leading_separators,STRING_TO_REAL_CONVERTOR.leading_separators + +inherited,STRING_TO_NUMERIC_CONVERTOR.trailing_separators,STRING_TO_REAL_CONVERTOR.trailing_separators + +inherited,STRING_TO_NUMERIC_CONVERTOR.conversion_type,STRING_TO_REAL_CONVERTOR.conversion_type + +inherited,STRING_TO_NUMERIC_CONVERTOR.last_state,STRING_TO_REAL_CONVERTOR.last_state + +inherited,STRING_TO_NUMERIC_CONVERTOR.sign,STRING_TO_REAL_CONVERTOR.sign + +inherited,STRING.area,SEQ_STRING.area + +inherited,STRING.internal_case_insensitive_hash_code,SEQ_STRING.internal_case_insensitive_hash_code + +inherited,STRING.internal_hash_code,SEQ_STRING.internal_hash_code + +inherited,STRING.count,SEQ_STRING.count + +inherited,STRING.object_comparison,SEQ_STRING.object_comparison + +inherited,SEQUENCE.object_comparison,SEQ_STRING.object_comparison + +inherited,RT_DBG_VALUE_RECORD.position,RT_DBG_LOCAL_RECORD.position + +inherited,RT_DBG_VALUE_RECORD.type,RT_DBG_LOCAL_RECORD.type + +inherited,RT_DBG_VALUE_RECORD.breakable_info,RT_DBG_LOCAL_RECORD.breakable_info + +renamed,RT_DBG_VALUE_RECORD.position,RT_DBG_FIELD_RECORD.index + +inherited,RT_DBG_VALUE_RECORD.type,RT_DBG_FIELD_RECORD.type + +inherited,RT_DBG_VALUE_RECORD.breakable_info,RT_DBG_FIELD_RECORD.breakable_info + +renamed,RT_DBG_VALUE_RECORD.position,RT_DBG_ATTRIBUTE_RECORD.offset + +inherited,RT_DBG_VALUE_RECORD.type,RT_DBG_ATTRIBUTE_RECORD.type + +inherited,RT_DBG_VALUE_RECORD.breakable_info,RT_DBG_ATTRIBUTE_RECORD.breakable_info + +inherited,ARRAYED_LIST.index,INTERACTIVE_LIST.index + +inherited,ARRAYED_LIST.area_v2,INTERACTIVE_LIST.area_v2 + +inherited,ARRAYED_LIST.object_comparison,INTERACTIVE_LIST.object_comparison + +inherited,INTEGER_INTERVAL.lower,ACTIVE_INTEGER_INTERVAL.lower + +inherited,INTEGER_INTERVAL.upper,ACTIVE_INTEGER_INTERVAL.upper + +inherited,INTEGER_INTERVAL.object_comparison,ACTIVE_INTEGER_INTERVAL.object_comparison + +inherited,INTERACTIVE_LIST.in_operation,ACTIVE_LIST.in_operation + +inherited,INTERACTIVE_LIST.area_v2,ACTIVE_LIST.area_v2 + +inherited,INTERACTIVE_LIST.object_comparison,ACTIVE_LIST.object_comparison + +inherited,INTERACTIVE_LIST.index,ACTIVE_LIST.index + +inherited,INTERACTIVE_LIST.in_operation,ACTION_SEQUENCE.in_operation + +inherited,INTERACTIVE_LIST.area_v2,ACTION_SEQUENCE.area_v2 + +inherited,INTERACTIVE_LIST.object_comparison,ACTION_SEQUENCE.object_comparison + +inherited,INTERACTIVE_LIST.index,ACTION_SEQUENCE.index + +inherited,SED_ABSTRACT_OBJECTS_TABLE.last_index,SED_OBJECTS_TABLE.last_index + +renamed,HASH_TABLE.capacity,SED_OBJECTS_TABLE.table_capacity + +renamed,HASH_TABLE.count,SED_OBJECTS_TABLE.capacity + +inherited,HASH_TABLE.found_item,SED_OBJECTS_TABLE.found_item + +inherited,HASH_TABLE.hash_table_version_64,SED_OBJECTS_TABLE.hash_table_version_64 + +inherited,HASH_TABLE.content,SED_OBJECTS_TABLE.content + +inherited,HASH_TABLE.keys,SED_OBJECTS_TABLE.keys + +inherited,HASH_TABLE.indexes_map,SED_OBJECTS_TABLE.indexes_map + +inherited,HASH_TABLE.deleted_marks,SED_OBJECTS_TABLE.deleted_marks + +inherited,HASH_TABLE.item_position,SED_OBJECTS_TABLE.item_position + +inherited,HASH_TABLE.has_default,SED_OBJECTS_TABLE.has_default + +inherited,HASH_TABLE.iteration_position,SED_OBJECTS_TABLE.iteration_position + +inherited,HASH_TABLE.control,SED_OBJECTS_TABLE.control + +inherited,HASH_TABLE.deleted_item_position,SED_OBJECTS_TABLE.deleted_item_position + +inherited,HASH_TABLE.ht_lowest_deleted_position,SED_OBJECTS_TABLE.ht_lowest_deleted_position + +inherited,HASH_TABLE.ht_deleted_item,SED_OBJECTS_TABLE.ht_deleted_item + +inherited,HASH_TABLE.ht_deleted_key,SED_OBJECTS_TABLE.ht_deleted_key + +inherited,HASH_TABLE.object_comparison,SED_OBJECTS_TABLE.object_comparison + +inherited,SED_READER_WRITER.is_pointer_value_stored,SED_BINARY_READER_WRITER.is_pointer_value_stored + +inherited,SED_BINARY_READER_WRITER.is_for_reading,SED_MEDIUM_READER_WRITER.is_for_reading + +inherited,SED_BINARY_READER_WRITER.buffer,SED_MEDIUM_READER_WRITER.buffer + +inherited,SED_BINARY_READER_WRITER.medium,SED_MEDIUM_READER_WRITER.medium + +inherited,SED_BINARY_READER_WRITER.buffer_size,SED_MEDIUM_READER_WRITER.buffer_size + +inherited,SED_BINARY_READER_WRITER.buffer_position,SED_MEDIUM_READER_WRITER.buffer_position + +inherited,SED_BINARY_READER_WRITER.is_little_endian_storable,SED_MEDIUM_READER_WRITER.is_little_endian_storable + +inherited,SED_BINARY_READER_WRITER.stored_pointer_bytes,SED_MEDIUM_READER_WRITER.stored_pointer_bytes + +inherited,SED_BINARY_READER_WRITER.is_pointer_value_stored,SED_MEDIUM_READER_WRITER.is_pointer_value_stored + +inherited,SED_BINARY_READER_WRITER.is_for_reading,SED_MEMORY_READER_WRITER.is_for_reading + +inherited,SED_BINARY_READER_WRITER.buffer,SED_MEMORY_READER_WRITER.buffer + +inherited,SED_BINARY_READER_WRITER.medium,SED_MEMORY_READER_WRITER.medium + +inherited,SED_BINARY_READER_WRITER.buffer_size,SED_MEMORY_READER_WRITER.buffer_size + +inherited,SED_BINARY_READER_WRITER.buffer_position,SED_MEMORY_READER_WRITER.buffer_position + +inherited,SED_BINARY_READER_WRITER.is_little_endian_storable,SED_MEMORY_READER_WRITER.is_little_endian_storable + +inherited,SED_BINARY_READER_WRITER.stored_pointer_bytes,SED_MEMORY_READER_WRITER.stored_pointer_bytes + +inherited,SED_BINARY_READER_WRITER.is_pointer_value_stored,SED_MEMORY_READER_WRITER.is_pointer_value_stored + +inherited,SED_BINARY_READER_WRITER.is_for_reading,SED_MEDIUM_READER_WRITER_1.is_for_reading + +inherited,SED_BINARY_READER_WRITER.buffer,SED_MEDIUM_READER_WRITER_1.buffer + +inherited,SED_BINARY_READER_WRITER.medium,SED_MEDIUM_READER_WRITER_1.medium + +inherited,SED_BINARY_READER_WRITER.buffer_size,SED_MEDIUM_READER_WRITER_1.buffer_size + +inherited,SED_BINARY_READER_WRITER.buffer_position,SED_MEDIUM_READER_WRITER_1.buffer_position + +inherited,SED_BINARY_READER_WRITER.is_little_endian_storable,SED_MEDIUM_READER_WRITER_1.is_little_endian_storable + +inherited,SED_BINARY_READER_WRITER.stored_pointer_bytes,SED_MEDIUM_READER_WRITER_1.stored_pointer_bytes + +inherited,SED_BINARY_READER_WRITER.is_pointer_value_stored,SED_MEDIUM_READER_WRITER_1.is_pointer_value_stored + +inherited,SED_STORABLE_FACILITIES.retrieved_errors,SED_MULTI_OBJECT_SERIALIZATION.retrieved_errors + +inherited,SED_BASIC_DESERIALIZER.dynamic_type_table,SED_RECOVERABLE_DESERIALIZER.dynamic_type_table + +inherited,SED_BASIC_DESERIALIZER.version,SED_RECOVERABLE_DESERIALIZER.version + +inherited,SED_BASIC_DESERIALIZER.has_reference_with_copy_semantics,SED_RECOVERABLE_DESERIALIZER.has_reference_with_copy_semantics + +inherited,SED_BASIC_DESERIALIZER.object_references,SED_RECOVERABLE_DESERIALIZER.object_references + +inherited,SED_BASIC_DESERIALIZER.reflected_object,SED_RECOVERABLE_DESERIALIZER.reflected_object + +inherited,SED_BASIC_DESERIALIZER.reflector,SED_RECOVERABLE_DESERIALIZER.reflector + +inherited,SED_BASIC_DESERIALIZER.errors,SED_RECOVERABLE_DESERIALIZER.errors + +inherited,SED_BASIC_DESERIALIZER.last_decoded_object,SED_RECOVERABLE_DESERIALIZER.last_decoded_object + +inherited,SED_BASIC_DESERIALIZER.deserializer,SED_RECOVERABLE_DESERIALIZER.deserializer + +inherited,SED_BASIC_SERIALIZER.has_reference_with_copy_semantics,SED_INDEPENDENT_SERIALIZER.has_reference_with_copy_semantics + +inherited,SED_BASIC_SERIALIZER.version,SED_INDEPENDENT_SERIALIZER.version + +inherited,SED_BASIC_SERIALIZER.object_indexes,SED_INDEPENDENT_SERIALIZER.object_indexes + +inherited,SED_BASIC_SERIALIZER.traversable,SED_INDEPENDENT_SERIALIZER.traversable + +inherited,SED_BASIC_SERIALIZER.reflected_object,SED_INDEPENDENT_SERIALIZER.reflected_object + +inherited,SED_BASIC_SERIALIZER.reflector,SED_INDEPENDENT_SERIALIZER.reflector + +inherited,SED_BASIC_SERIALIZER.is_root_object_set,SED_INDEPENDENT_SERIALIZER.is_root_object_set + +inherited,SED_BASIC_SERIALIZER.serializer,SED_INDEPENDENT_SERIALIZER.serializer + +inherited,SED_BASIC_SERIALIZER.has_reference_with_copy_semantics,SED_RECOVERABLE_SERIALIZER.has_reference_with_copy_semantics + +inherited,SED_BASIC_SERIALIZER.version,SED_RECOVERABLE_SERIALIZER.version + +inherited,SED_BASIC_SERIALIZER.object_indexes,SED_RECOVERABLE_SERIALIZER.object_indexes + +inherited,SED_BASIC_SERIALIZER.traversable,SED_RECOVERABLE_SERIALIZER.traversable + +inherited,SED_BASIC_SERIALIZER.reflected_object,SED_RECOVERABLE_SERIALIZER.reflected_object + +inherited,SED_BASIC_SERIALIZER.reflector,SED_RECOVERABLE_SERIALIZER.reflector + +inherited,SED_BASIC_SERIALIZER.is_root_object_set,SED_RECOVERABLE_SERIALIZER.is_root_object_set + +inherited,SED_BASIC_SERIALIZER.serializer,SED_RECOVERABLE_SERIALIZER.serializer + +inherited,SED_BASIC_DESERIALIZER.dynamic_type_table,SED_INDEPENDENT_DESERIALIZER.dynamic_type_table + +inherited,SED_BASIC_DESERIALIZER.version,SED_INDEPENDENT_DESERIALIZER.version + +inherited,SED_BASIC_DESERIALIZER.has_reference_with_copy_semantics,SED_INDEPENDENT_DESERIALIZER.has_reference_with_copy_semantics + +inherited,SED_BASIC_DESERIALIZER.object_references,SED_INDEPENDENT_DESERIALIZER.object_references + +inherited,SED_BASIC_DESERIALIZER.reflected_object,SED_INDEPENDENT_DESERIALIZER.reflected_object + +inherited,SED_BASIC_DESERIALIZER.reflector,SED_INDEPENDENT_DESERIALIZER.reflector + +inherited,SED_BASIC_DESERIALIZER.errors,SED_INDEPENDENT_DESERIALIZER.errors + +inherited,SED_BASIC_DESERIALIZER.last_decoded_object,SED_INDEPENDENT_DESERIALIZER.last_decoded_object + +inherited,SED_BASIC_DESERIALIZER.deserializer,SED_INDEPENDENT_DESERIALIZER.deserializer + +inherited,SED_SESSION_SERIALIZER.serializer,SED_BASIC_SERIALIZER.serializer + +inherited,SED_SESSION_SERIALIZER.is_root_object_set,SED_BASIC_SERIALIZER.is_root_object_set + +inherited,SED_SESSION_SERIALIZER.reflector,SED_BASIC_SERIALIZER.reflector + +inherited,SED_SESSION_SERIALIZER.reflected_object,SED_BASIC_SERIALIZER.reflected_object + +inherited,SED_SESSION_SERIALIZER.traversable,SED_BASIC_SERIALIZER.traversable + +inherited,SED_SESSION_SERIALIZER.object_indexes,SED_BASIC_SERIALIZER.object_indexes + +inherited,SED_SESSION_SERIALIZER.version,SED_BASIC_SERIALIZER.version + +inherited,SED_SESSION_SERIALIZER.has_reference_with_copy_semantics,SED_BASIC_SERIALIZER.has_reference_with_copy_semantics + +inherited,SED_SESSION_DESERIALIZER.deserializer,SED_BASIC_DESERIALIZER.deserializer + +inherited,SED_SESSION_DESERIALIZER.last_decoded_object,SED_BASIC_DESERIALIZER.last_decoded_object + +inherited,SED_SESSION_DESERIALIZER.errors,SED_BASIC_DESERIALIZER.errors + +inherited,SED_SESSION_DESERIALIZER.reflector,SED_BASIC_DESERIALIZER.reflector + +inherited,SED_SESSION_DESERIALIZER.reflected_object,SED_BASIC_DESERIALIZER.reflected_object + +inherited,SED_SESSION_DESERIALIZER.object_references,SED_BASIC_DESERIALIZER.object_references + +inherited,SED_SESSION_DESERIALIZER.has_reference_with_copy_semantics,SED_BASIC_DESERIALIZER.has_reference_with_copy_semantics + +inherited,SED_SESSION_DESERIALIZER.version,SED_BASIC_DESERIALIZER.version + +inherited,SED_SESSION_DESERIALIZER.dynamic_type_table,SED_BASIC_DESERIALIZER.dynamic_type_table + +inherited,EIFFELSTUDIO_SPECIFIC_LANGUAGE_EXCEPTION.internal_trace,ADDRESS_APPLIED_TO_MELTED_FEATURE.internal_trace + +inherited,EIFFELSTUDIO_SPECIFIC_LANGUAGE_EXCEPTION.internal_is_ignorable,ADDRESS_APPLIED_TO_MELTED_FEATURE.internal_is_ignorable + +inherited,EIFFELSTUDIO_SPECIFIC_LANGUAGE_EXCEPTION.c_description,ADDRESS_APPLIED_TO_MELTED_FEATURE.c_description + +inherited,EIFFELSTUDIO_SPECIFIC_LANGUAGE_EXCEPTION.throwing_exception,ADDRESS_APPLIED_TO_MELTED_FEATURE.throwing_exception + +inherited,EIFFELSTUDIO_SPECIFIC_LANGUAGE_EXCEPTION.line_number,ADDRESS_APPLIED_TO_MELTED_FEATURE.line_number + +inherited,EIFFELSTUDIO_SPECIFIC_LANGUAGE_EXCEPTION.type_name,ADDRESS_APPLIED_TO_MELTED_FEATURE.type_name + +inherited,EIFFELSTUDIO_SPECIFIC_LANGUAGE_EXCEPTION.recipient_name,ADDRESS_APPLIED_TO_MELTED_FEATURE.recipient_name + +inherited,LANGUAGE_EXCEPTION.internal_trace,EIFFELSTUDIO_SPECIFIC_LANGUAGE_EXCEPTION.internal_trace + +inherited,LANGUAGE_EXCEPTION.internal_is_ignorable,EIFFELSTUDIO_SPECIFIC_LANGUAGE_EXCEPTION.internal_is_ignorable + +inherited,LANGUAGE_EXCEPTION.c_description,EIFFELSTUDIO_SPECIFIC_LANGUAGE_EXCEPTION.c_description + +inherited,LANGUAGE_EXCEPTION.throwing_exception,EIFFELSTUDIO_SPECIFIC_LANGUAGE_EXCEPTION.throwing_exception + +inherited,LANGUAGE_EXCEPTION.line_number,EIFFELSTUDIO_SPECIFIC_LANGUAGE_EXCEPTION.line_number + +inherited,LANGUAGE_EXCEPTION.type_name,EIFFELSTUDIO_SPECIFIC_LANGUAGE_EXCEPTION.type_name + +inherited,LANGUAGE_EXCEPTION.recipient_name,EIFFELSTUDIO_SPECIFIC_LANGUAGE_EXCEPTION.recipient_name + +inherited,EIFFEL_RUNTIME_EXCEPTION.internal_trace,EXTERNAL_FAILURE.internal_trace + +inherited,EIFFEL_RUNTIME_EXCEPTION.internal_is_ignorable,EXTERNAL_FAILURE.internal_is_ignorable + +inherited,EIFFEL_RUNTIME_EXCEPTION.c_description,EXTERNAL_FAILURE.c_description + +inherited,EIFFEL_RUNTIME_EXCEPTION.throwing_exception,EXTERNAL_FAILURE.throwing_exception + +inherited,EIFFEL_RUNTIME_EXCEPTION.line_number,EXTERNAL_FAILURE.line_number + +inherited,EIFFEL_RUNTIME_EXCEPTION.type_name,EXTERNAL_FAILURE.type_name + +inherited,EIFFEL_RUNTIME_EXCEPTION.recipient_name,EXTERNAL_FAILURE.recipient_name + +inherited,OBSOLETE_EXCEPTION.internal_trace,EXCEPTION_IN_SIGNAL_HANDLER_FAILURE.internal_trace + +inherited,OBSOLETE_EXCEPTION.internal_is_ignorable,EXCEPTION_IN_SIGNAL_HANDLER_FAILURE.internal_is_ignorable + +inherited,OBSOLETE_EXCEPTION.c_description,EXCEPTION_IN_SIGNAL_HANDLER_FAILURE.c_description + +inherited,OBSOLETE_EXCEPTION.throwing_exception,EXCEPTION_IN_SIGNAL_HANDLER_FAILURE.throwing_exception + +inherited,OBSOLETE_EXCEPTION.line_number,EXCEPTION_IN_SIGNAL_HANDLER_FAILURE.line_number + +inherited,OBSOLETE_EXCEPTION.type_name,EXCEPTION_IN_SIGNAL_HANDLER_FAILURE.type_name + +inherited,OBSOLETE_EXCEPTION.recipient_name,EXCEPTION_IN_SIGNAL_HANDLER_FAILURE.recipient_name + +inherited,DATA_EXCEPTION.internal_trace,MISMATCH_FAILURE.internal_trace + +inherited,DATA_EXCEPTION.internal_is_ignorable,MISMATCH_FAILURE.internal_is_ignorable + +inherited,DATA_EXCEPTION.c_description,MISMATCH_FAILURE.c_description + +inherited,DATA_EXCEPTION.throwing_exception,MISMATCH_FAILURE.throwing_exception + +inherited,DATA_EXCEPTION.line_number,MISMATCH_FAILURE.line_number + +inherited,DATA_EXCEPTION.type_name,MISMATCH_FAILURE.type_name + +inherited,DATA_EXCEPTION.recipient_name,MISMATCH_FAILURE.recipient_name + +inherited,DATA_EXCEPTION.internal_trace,SERIALIZATION_FAILURE.internal_trace + +inherited,DATA_EXCEPTION.internal_is_ignorable,SERIALIZATION_FAILURE.internal_is_ignorable + +inherited,DATA_EXCEPTION.c_description,SERIALIZATION_FAILURE.c_description + +inherited,DATA_EXCEPTION.throwing_exception,SERIALIZATION_FAILURE.throwing_exception + +inherited,DATA_EXCEPTION.line_number,SERIALIZATION_FAILURE.line_number + +inherited,DATA_EXCEPTION.type_name,SERIALIZATION_FAILURE.type_name + +inherited,DATA_EXCEPTION.recipient_name,SERIALIZATION_FAILURE.recipient_name + +inherited,DATA_EXCEPTION.internal_trace,IO_FAILURE.internal_trace + +inherited,DATA_EXCEPTION.internal_is_ignorable,IO_FAILURE.internal_is_ignorable + +inherited,DATA_EXCEPTION.c_description,IO_FAILURE.c_description + +inherited,DATA_EXCEPTION.throwing_exception,IO_FAILURE.throwing_exception + +inherited,DATA_EXCEPTION.line_number,IO_FAILURE.line_number + +inherited,DATA_EXCEPTION.type_name,IO_FAILURE.type_name + +inherited,DATA_EXCEPTION.recipient_name,IO_FAILURE.recipient_name + +inherited,EIFFELSTUDIO_SPECIFIC_LANGUAGE_EXCEPTION.internal_trace,CREATE_ON_DEFERRED.internal_trace + +inherited,EIFFELSTUDIO_SPECIFIC_LANGUAGE_EXCEPTION.internal_is_ignorable,CREATE_ON_DEFERRED.internal_is_ignorable + +inherited,EIFFELSTUDIO_SPECIFIC_LANGUAGE_EXCEPTION.c_description,CREATE_ON_DEFERRED.c_description + +inherited,EIFFELSTUDIO_SPECIFIC_LANGUAGE_EXCEPTION.throwing_exception,CREATE_ON_DEFERRED.throwing_exception + +inherited,EIFFELSTUDIO_SPECIFIC_LANGUAGE_EXCEPTION.line_number,CREATE_ON_DEFERRED.line_number + +inherited,EIFFELSTUDIO_SPECIFIC_LANGUAGE_EXCEPTION.type_name,CREATE_ON_DEFERRED.type_name + +inherited,EIFFELSTUDIO_SPECIFIC_LANGUAGE_EXCEPTION.recipient_name,CREATE_ON_DEFERRED.recipient_name + +inherited,EIFFEL_RUNTIME_EXCEPTION.internal_trace,NO_MORE_MEMORY.internal_trace + +inherited,EIFFEL_RUNTIME_EXCEPTION.internal_is_ignorable,NO_MORE_MEMORY.internal_is_ignorable + +inherited,EIFFEL_RUNTIME_EXCEPTION.c_description,NO_MORE_MEMORY.c_description + +inherited,EIFFEL_RUNTIME_EXCEPTION.throwing_exception,NO_MORE_MEMORY.throwing_exception + +inherited,EIFFEL_RUNTIME_EXCEPTION.line_number,NO_MORE_MEMORY.line_number + +inherited,EIFFEL_RUNTIME_EXCEPTION.type_name,NO_MORE_MEMORY.type_name + +inherited,EIFFEL_RUNTIME_EXCEPTION.recipient_name,NO_MORE_MEMORY.recipient_name + +inherited,EIFFEL_RUNTIME_EXCEPTION.internal_trace,DATA_EXCEPTION.internal_trace + +inherited,EIFFEL_RUNTIME_EXCEPTION.internal_is_ignorable,DATA_EXCEPTION.internal_is_ignorable + +inherited,EIFFEL_RUNTIME_EXCEPTION.c_description,DATA_EXCEPTION.c_description + +inherited,EIFFEL_RUNTIME_EXCEPTION.throwing_exception,DATA_EXCEPTION.throwing_exception + +inherited,EIFFEL_RUNTIME_EXCEPTION.line_number,DATA_EXCEPTION.line_number + +inherited,EIFFEL_RUNTIME_EXCEPTION.type_name,DATA_EXCEPTION.type_name + +inherited,EIFFEL_RUNTIME_EXCEPTION.recipient_name,DATA_EXCEPTION.recipient_name + +inherited,SYS_EXCEPTION.internal_trace,EIFFEL_RUNTIME_PANIC.internal_trace + +inherited,SYS_EXCEPTION.internal_is_ignorable,EIFFEL_RUNTIME_PANIC.internal_is_ignorable + +inherited,SYS_EXCEPTION.c_description,EIFFEL_RUNTIME_PANIC.c_description + +inherited,SYS_EXCEPTION.throwing_exception,EIFFEL_RUNTIME_PANIC.throwing_exception + +inherited,SYS_EXCEPTION.line_number,EIFFEL_RUNTIME_PANIC.line_number + +inherited,SYS_EXCEPTION.type_name,EIFFEL_RUNTIME_PANIC.type_name + +inherited,SYS_EXCEPTION.recipient_name,EIFFEL_RUNTIME_PANIC.recipient_name + +inherited,OBSOLETE_EXCEPTION.internal_trace,RESCUE_FAILURE.internal_trace + +inherited,OBSOLETE_EXCEPTION.internal_is_ignorable,RESCUE_FAILURE.internal_is_ignorable + +inherited,OBSOLETE_EXCEPTION.c_description,RESCUE_FAILURE.c_description + +inherited,OBSOLETE_EXCEPTION.throwing_exception,RESCUE_FAILURE.throwing_exception + +inherited,OBSOLETE_EXCEPTION.line_number,RESCUE_FAILURE.line_number + +inherited,OBSOLETE_EXCEPTION.type_name,RESCUE_FAILURE.type_name + +inherited,OBSOLETE_EXCEPTION.recipient_name,RESCUE_FAILURE.recipient_name + +inherited,OBSOLETE_EXCEPTION.internal_trace,RESUMPTION_FAILURE.internal_trace + +inherited,OBSOLETE_EXCEPTION.internal_is_ignorable,RESUMPTION_FAILURE.internal_is_ignorable + +inherited,OBSOLETE_EXCEPTION.c_description,RESUMPTION_FAILURE.c_description + +inherited,OBSOLETE_EXCEPTION.throwing_exception,RESUMPTION_FAILURE.throwing_exception + +inherited,OBSOLETE_EXCEPTION.line_number,RESUMPTION_FAILURE.line_number + +inherited,OBSOLETE_EXCEPTION.type_name,RESUMPTION_FAILURE.type_name + +inherited,OBSOLETE_EXCEPTION.recipient_name,RESUMPTION_FAILURE.recipient_name + +Total Time: 0/0/0 0:0:1.103 diff --git a/tool/gedoc/example/rename/person.e b/tool/gedoc/example/rename/person.e new file mode 100644 index 000000000..504163413 --- /dev/null +++ b/tool/gedoc/example/rename/person.e @@ -0,0 +1,16 @@ +class PERSON +inherit ANY redefine default_create end -- needed by ISE and GOBO compiler; but not by SmartEiffel + +feature {ANY} + name: STRING + addr: STRING + + get_addr():STRING is do Result := addr end -- accessor method, to read + set_addr(a:STRING) is do addr := a end -- accessor method, to write + + default_create is -- the constructor + do + name := "name" + addr := "addr" + end +end diff --git a/tool/gedoc/example/rename/research_assistant.e b/tool/gedoc/example/rename/research_assistant.e new file mode 100644 index 000000000..343c5c376 --- /dev/null +++ b/tool/gedoc/example/rename/research_assistant.e @@ -0,0 +1,24 @@ +class RESEARCH_ASSISTANT +inherit + STUDENT rename addr as student_addr end -- field student_addr inherit the dorm semantics + FACULTY rename addr as faculty_addr end -- field faculty_addr inherit the lab semantics + -- then select, NOTE: not needed by SmartEiffel, but needed by GOBO and ISE compiler + PERSON select addr end + +create {ANY} + make + +feature {ANY} + print_ra() is -- print out all 3 addresses + do + io.put_string(name +" has 3 addresses: <"+ addr +", "+ student_addr +", "+ faculty_addr + ">%N") + end + + make is -- the constructor + do + name := "ResAssis" + addr := "home" -- the home semantics + student_addr := "dorm" -- the dorm semantics + faculty_addr := "lab" -- the lab semantics + end +end diff --git a/tool/gedoc/example/rename/student.e b/tool/gedoc/example/rename/student.e new file mode 100644 index 000000000..6c310cf19 --- /dev/null +++ b/tool/gedoc/example/rename/student.e @@ -0,0 +1,12 @@ +class STUDENT +inherit PERSON + +feature {ANY} + get_student_addr():STRING is do Result := get_addr() end -- assign dorm semantics to addr + set_student_addr(a:STRING) is do set_addr(a) end + + take_rest() is + do + io.put_string(name + " take_rest in the: " + get_student_addr() + "%N"); + end +end diff --git a/tool/gedoc/src/gedoc.e b/tool/gedoc/src/gedoc.e index f74dde7d6..0e6edc804 100644 --- a/tool/gedoc/src/gedoc.e +++ b/tool/gedoc/src/gedoc.e @@ -183,11 +183,12 @@ feature -- Argument parsing format_option.extend ("pretty_print") format_option.extend ("html_ise_stylesheet") format_option.extend ("descendants") + format_option.extend ("attr_rename") format_option.extend ("implicit_converts") format_option.extend ("explicit_converts") format_option.extend ("ecf_pretty_print") format_option.extend ("available_targets") - format_option.set_parameter_description ("pretty_print|html_ise_stylesheet|descendants|implicit_converts|explicit_converts|ecf_pretty_print|available_targets") + format_option.set_parameter_description ("pretty_print|html_ise_stylesheet|descendants|attr_rename|implicit_converts|explicit_converts|ecf_pretty_print|available_targets") l_parser.options.force_last (format_option) -- class. create class_option.make ('c', "class") @@ -286,6 +287,8 @@ feature -- Argument parsing create {GEDOC_HTML_ISE_STYLESHEET_FORMAT} l_format.make (l_input_filename, new_system_processor (thread_option)) elseif format_option.parameter ~ "descendants" then create {GEDOC_DESCENDANTS_FORMAT} l_format.make (l_input_filename, new_system_processor (thread_option)) + elseif format_option.parameter ~ "attr_rename" then + create {GEDOC_ATTR_RENAME_FORMAT} l_format.make (l_input_filename, new_system_processor (thread_option)) elseif format_option.parameter ~ "implicit_converts" then create {GEDOC_IMPLICIT_CONVERTS_FORMAT} l_format.make (l_input_filename, new_system_processor (thread_option)) elseif format_option.parameter ~ "explicit_converts" then diff --git a/tool/gedoc/src/gedoc_attr_rename_format.e b/tool/gedoc/src/gedoc_attr_rename_format.e new file mode 100644 index 000000000..3c9f13922 --- /dev/null +++ b/tool/gedoc/src/gedoc_attr_rename_format.e @@ -0,0 +1,292 @@ +note + + description: + + "Gobo Eiffel Documentation Format: detect attribute renaming in a diamond" + + copyright: "Copyright (c) 2020, Eric Bezault and others" + license: "MIT License" + +class GEDOC_ATTR_RENAME_FORMAT + +inherit + + GEDOC_FORMAT + redefine + make, + prepare_system, + set_ast_factory + end + +create + + make + +create {GEDOC_ATTR_RENAME_FORMAT} + + make_from_format + +feature {NONE} -- Initialization + + make (a_input_filename: STRING; a_system_processor: like system_processor) + -- + do + create explicit_convert_expression_finder.make + create explicit_convert_expressions.make (250) + precursor (a_input_filename, a_system_processor) + end + +feature {NONE} -- Processing + + prepare_system (a_system: ET_SYSTEM) + -- Prepare `a_system' before being processed. + do + precursor (a_system) + system_processor.set_flat_mode (False) + system_processor.set_flat_dbc_mode (False) + end + + set_ast_factory + -- Configure the AST factory as needed. + local + l_ast_factory: ET_DECORATED_AST_FACTORY + do + create l_ast_factory.make + set_explicit_convert_class_names (l_ast_factory) + system_processor.set_ast_factory (l_ast_factory) + end + + set_explicit_convert_class_names (a_ast_factory: ET_DECORATED_AST_FACTORY) + -- Set 'explicit_convert_class_names' in `a_ast_factory'. + require + a_ast_factory_not_void: a_ast_factory /= Void + local + l_conversions: DS_ARRAYED_LIST [TUPLE [detachable LX_DFA_WILDCARD, detachable LX_DFA_WILDCARD]] + l_regexp: RX_PCRE_REGULAR_EXPRESSION + l_pattern: STRING + l_from_wildcard: LX_DFA_WILDCARD + l_to_wildcard: LX_DFA_WILDCARD + do + create l_conversions.make_default + if attached override_variables as l_override_variables then + if attached l_override_variables.primary_value ("convert") as l_convert then + create l_regexp.make + l_regexp.compile ("(([^-]|-[^>])*)->(.*)") + if l_regexp.recognizes (l_convert) then + l_pattern := l_regexp.captured_substring (1) + l_pattern.left_adjust + l_pattern.right_adjust + create l_from_wildcard.compile_case_insensitive (l_pattern) + if not l_from_wildcard.is_compiled then + report_invalid_class_wildcard_error (l_pattern) + end + l_pattern := l_regexp.captured_substring (3) + l_pattern.left_adjust + l_pattern.right_adjust + create l_to_wildcard.compile_case_insensitive (l_pattern) + if not l_to_wildcard.is_compiled then + report_invalid_class_wildcard_error (l_pattern) + end + l_conversions.force_last ([l_from_wildcard, l_to_wildcard]) + end + end + end + a_ast_factory.set_explicit_convert_class_names (l_conversions) + end + + process_system (a_system: ET_SYSTEM) + -- Process `input_classes' from `a_system'. + local + l_input_classes: like input_classes + l_all_classes: like input_classes + l_formats: DS_ARRAYED_LIST [like Current] + do + create l_all_classes.make (a_system.class_count_recursive) + a_system.classes_do_unless_recursive (agent l_all_classes.force_last, agent {ET_CLASS}.is_none) + l_input_classes := input_classes + system_processor.compile_degree_5 (l_all_classes, False) + system_processor.compile_degree_4 (l_all_classes) + -- system_processor.compile_degree_3 (l_input_classes) + create l_formats.make (system_processor.processor_count) + system_processor.do_all (agent add_format (?, l_formats)) + l_input_classes.do_all (agent {ET_CLASS}.set_marked (False)) + system_processor.process_custom (l_input_classes) + has_error := l_formats.there_exists (agent {like Current}.has_error) + end + +feature {GEDOC_ATTR_RENAME_FORMAT} -- Processing + + is_direct_parent(sub_class: ET_CLASS; super_class: ET_CLASS): BOOLEAN + local + i, nb: INTEGER + j, nb2: INTEGER + l_parent_list: ET_PARENT_LIST + l_parent: ET_PARENT + do + Result := False + if attached sub_class.parent_clauses as l_parents then + nb := l_parents.count + from i := 1 until (i > nb or Result) loop + l_parent_list := l_parents.item (i) + nb2 := l_parent_list.count + from j := 1 until (j > nb2 or Result) loop + l_parent := l_parent_list.parent (j) + if l_parent.type.base_class = super_class then + Result := True + end + j := j + 1 + end + i := i + 1 + end + end + end + + + process_parent_clauses(a_class: ET_CLASS) + local + i, k, nb, nr: INTEGER + j, nb2: INTEGER + old_name: STRING + l_parent_list: ET_PARENT_LIST + parent: ET_PARENT + l_item: ET_RENAME_ITEM + l_rename: ET_RENAME + attr_table: HASH_TABLE [BOOLEAN, STRING] + do + if attached a_class.parent_clauses as l_parent_clauses then + nb := l_parent_clauses.count + from i := 1 until i > nb loop + l_parent_list := l_parent_clauses.item (i) + nb2 := l_parent_list.count + from j := 1 until j > nb2 loop + parent := l_parent_list.parent (j) + + -- collect all the fields + -- assumption: parent.base_class.queries is flattened / conslidated + attr_table := collect_all_attributes(parent.type.base_class) + + -- loop on renames, and report + if attached parent.renames as l_renames then + -- e.g. STUDENT.addr => RESEARCH_ASSISTANT.student_addr only reported here + nr := l_renames.count + from k := 1 until k > nr loop + l_item := l_renames.item(k) + l_rename := l_item.rename_pair + if attached a_class.named_query(l_rename.new_name.feature_name) as query then + if query.is_attribute then + old_name := l_rename.old_name.lower_name + error_handler.report_info_message ("renamed," + parent.type.upper_name + "." + old_name + + "," + a_class.upper_name + "." + query.lower_name + "%N") + attr_table.remove (old_name) + end + end + k := k + 1 + end + end + + -- report un-renamed, directly inherited fields + across attr_table as it loop + error_handler.report_info_message ("inherited," + parent.type.upper_name + "." + @ it.key + + "," + a_class.upper_name + "." + @ it.key + "%N") + end + j := j + 1 + end + i := i + 1 + end + end + end + + collect_all_attributes (a_class: ET_CLASS): HASH_TABLE [BOOLEAN, STRING] + local + i, nb: INTEGER + query: ET_QUERY + do + create Result.make (10) + nb := a_class.queries.count + -- print(a_class.upper_name + ":"); print(nb); print("%N") + from i := 1 until i > nb loop + query := a_class.queries.item(i) + -- print(query.lower_name + "%N") + if query.is_attribute then + Result.put (False, query.lower_name) + end + i := i + 1 + end + -- print("%N") + end + + process_implicit_converts (a_class: ET_CLASS) + -- Process implicit conversions in `a_class' if it has not been marked yet. + require + a_class_not_void: a_class /= Void + local + i, nb, j, np: INTEGER + l_expression: ET_EXPLICIT_CONVERT_EXPRESSION + l_position: ET_POSITION + query: ET_QUERY + l_other_precursor: ET_FEATURE + do + if not {PLATFORM}.is_thread_capable or else a_class.processing_mutex.try_lock then + if not a_class.is_marked then + if a_class.is_none then + -- Do nothing. + else + process_parent_clauses(a_class) + end + system_processor.report_class_processed (a_class) + a_class.set_marked (True) + end + a_class.processing_mutex.unlock + end + end + +feature {NONE} -- Implementation + + add_format (a_system_processor: ET_SYSTEM_PROCESSOR; a_formats: DS_ARRAYED_LIST [like Current]) + -- Add format associated with `a_system_processor' to `a_formats'. + require + a_system_processor_not_void: a_system_processor /= Void + a_formats_not_void: a_formats /= Void + no_void_format: not a_formats.has_void + local + l_format: like Current + do + if a_system_processor = system_processor then + l_format := Current + else + create l_format.make_from_format (Current, a_system_processor) + end + a_system_processor.set_custom_processor (agent l_format.process_implicit_converts) + a_formats.force_last (l_format) + ensure + no_void_format: not a_formats.has_void + one_more: a_formats.count = old a_formats.count + 1 + system_processor_set: a_formats.last.system_processor = a_system_processor + end + + explicit_convert_expression_finder: ET_EXPLICIT_CONVERT_EXPRESSION_FINDER + -- Used to find convert expressions + + explicit_convert_expressions: DS_ARRAYED_LIST [ET_EXPLICIT_CONVERT_EXPRESSION] + -- Convert expressions found by `explicit_convert_expression_finder' + +feature {NONE} -- Error handling + + report_invalid_class_wildcard_error (a_wildcard: STRING) + -- Report that the wildcard specified for conversion is invalid. + require + a_wildcard_not_void: a_wildcard /= Void + local + l_error: UT_MESSAGE + do + create l_error.make ("Invalid wildcard '" + a_wildcard + "' in variable 'convert'.") + report_error (l_error) + end + +invariant + + explicit_convert_expression_finder_not_void: explicit_convert_expression_finder /= Void + explicit_convert_expressions_not_void: explicit_convert_expressions /= Void + no_void_explicit_convert_expression: not explicit_convert_expressions.has_void + +end