Re: Git development

Wolfgang Jansen <[email protected]> Fri, 14 Aug 2009 19:09:06 +0200

Newsgroups	gmane.comp.lang.eiffel.gobo.devel
Organization	University of Potsdam, Institute of Informatics
Message-ID	<[email protected]>

Hi Howard,

Howard Thomson wrote:
>
> Hi Eric & Wolfgang,
>
> I would welcome a move to using Git as the SCM system for Gobo.
>
> I see that there is a useful page on wikipedia about git, with 
> reference to Windows implementations:
>
> http://en.wikipedia.org/wiki/Git_(software)#Implementation
>
> There is also an excellent website detailing how to use git ...
>
> http://progit.org/
>
> Regarding my own project:
>
> I have recently, I think [famous last words], reached stability with my
>
> GC when compiling with my modified 'gec', albeit that I have only so
>
> far tested it on Linux. A Win32 version should be a fairly trivial 
> adaptation,
>
> as it should be no more than adaptation of a single, smallish, routine.
>
> I am also thinking of renaming my project as 'guide',
>
> the Gobo-eiffel Users' Integrated Development Environment,
>
> from 'edp', the Eiffel Developers' Project. Although there a few
>
> classes [from other sources] that are LGPL, nearly all code that does
>
> not already derive from gobo, is EFFLv2 or MIT.
>
> I am very interested to hear about the introspection and debugger code, as
>
> I need such facilities for my intended future coding.
>
Description of introspection and debugger code may be really large.
Here, a short outline.
Descendant classes of ET_C_GENERATOR (extending the work of that class)
generate a description of the system to be compiled for use during runtime:
they extract information from objects of types
ET_DYNAMIC_SYSTEM, ET_DYNAMIC_TYPE etc. and puts
the information into objects of types ET_IN_SYSTEM, ET_IN_TYPE etc.
The resulting description is put onto C code (additional to the usual code)
using a special output mode of the persistence closure classes.
This code is C compiled, and the system description is available
during runtime (after a few adaptations at startup) as Eiffel objects.
More precisely, the root object of the description is provided by an 
external
routine that fetches the object's address from C code, the other objects
are then recursively available by Eiffel calls on the root object.
The attachment contains the interface of an example class
to show what kind of information is available during runtime.

Introspection for persistence closure and debugging differs in the amount
of information in the system description. For example, the debugger needs
information about routines but the persistence closure does not.
Moreover, in case of debugging many calls to the debugger have been 
inserted
into the "normal" code. The debugger then decides whether switching
into interactive mode (say a breakpoint has been reached)
or returning immediately to the caller.

Historically, the work started with the persistence closure.
I soon realized the introspection is a necessary prerequisite.
Then, having introspection, the idea was to utilize it also
for other purposes, e.g. for the "print" command of a debugger.
So, the debugger has been developed.

The approach to implement the persistence closure etc.
may be emphasized as follows:
The Eiffel compiler is written in Eiffel.
So, why not also implementing the Eiffel runtime system in Eiffel?  

BTW, does your GC mark/seep or move/compress? In the former case,
object marking may also be interesting when building the persistence 
closure.
Currently, the already seen objects are registered
in a DS_HASH_TABLE[INTEGER,POINTER]. This is inconvenient
because of the POINTER keys. Marking like the GC would be an
interesting alternative.

> One of the areas of the code generator that I intend to alter is the 
> polymorphic
>
> dispatch implementation, for two reasons:
>
> Firstly for rapid re-compilation, I want to be able to generate an 
> initial code package as
>
> an executable stub with dynamic library, where libraries register 
> their routine addresses
>
> with the runtime, with subsequent partial re-compilation code 
> generated as an additional
>
> dynamic library whose routines override the registered routines of the 
> initial library. This
>
> requires that routine dispatch be done using a tree data structure, of 
> some sort ...
>
> Secondly, I envisage that it should be possible, as with Java and 
> other languages [mostly interpreted ..],
>
> to dynamically add class libraries to an executable system, where such 
> libraries have been packaged,
>
> [compiled or otherwise verified against] to be compatible with classes 
> already in the current system.
>
> That would also require that the dispatch to reachable routines be 
> dynamically extendable.
>
This sounds very interesting. Extendibility of a program, dynamic 
linking etc. seems to be
necessary for contemporary software (otherwise, Eiffel will never have a 
chance).
>
> I am adapting my work on the Eiffel GUI toolkit derived from the 
> Fox-toolkit to use the Vision2 interface,
>
> providing an X11/Win32 all Eiffel GUI Toolkit, which has its 
> advantages ...
>
> I am working toward using LLVM as the basis for code generation for 
> native Eiffel routines, initially to emit
>
> LLVM assembler with llvm-as invocation, and with the possibility 
> [much] later of emitting machine code directly.
>
> I think using Git would assist in cooperation between myself and other 
> gobo-eiffel contributors and developers.
>
> Regards,
>
> Howard Thomson
>
> --
>
> "Only two things are infinite, the universe and human stupidity,
>
> and I'm not sure about the former." -- Albert Einstein
>


-- 
Dr. Wolfgang Jansen
University of Potsdam, Germany
Institute of Computer Science
Tel: +49 331 / 977 3047
mailto: [email protected]

------------------------------------------------------------------------------
Let Crystal Reports handle the reporting - Free Crystal Reports 2008 30-Day 
trial. Simplify your report design, integration and deployment - and focus on 
what you do best, core application coding. Discover what's new with 
Crystal Reports now.  http://p.sf.net/sfu/bobj-july

_______________________________________________
gobo-eiffel-develop mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/gobo-eiffel-develop

in_type.html (text/html, 36.9 KB)

<!doctype html system>
<!-- Generated by SmallEiffel short -html1 style hooks -->
<html>
<head>
<title>
IN_TYPE: Eiffel class interface</title>
</head>
<body>
<pre>
<strong>deferred class interface</strong> <a href="in_type.html">IN_TYPE</a>

<strong>feature(s) from </strong><a href="introspection.html">INTROSPECTION</a>
<em>   -- Constants
</em>
   Boolean_ident: <a href="integer.html">INTEGER</a>

   Character_ident: <a href="integer.html">INTEGER</a>

   Integer_ident: <a href="integer.html">INTEGER</a>

   Int8_ident: <a href="integer.html">INTEGER</a>

   Int16_ident: <a href="integer.html">INTEGER</a>

   Int32_ident: <a href="integer.html">INTEGER</a>

   Int64_ident: <a href="integer.html">INTEGER</a>

   Real_ident: <a href="integer.html">INTEGER</a>

   Double_ident: <a href="integer.html">INTEGER</a>

   Pointer_ident: <a href="integer.html">INTEGER</a>

   String_ident: <a href="integer.html">INTEGER</a>

   Foreign_flag: <a href="integer.html">INTEGER</a>

   Scoop_flag: <a href="integer.html">INTEGER</a>

   No_gc_flag: <a href="integer.html">INTEGER</a>

   Reference_flag: <a href="integer.html">INTEGER</a>

   Separate_flag: <a href="integer.html">INTEGER</a>

   Expanded_flag: <a href="integer.html">INTEGER</a>

   Living_flag: <a href="integer.html">INTEGER</a>

   Native_array_flag: <a href="integer.html">INTEGER</a>

   Basic_expanded_flag: <a href="integer.html">INTEGER</a>

   Capacity_index_flag: <a href="integer.html">INTEGER</a>

   Tuple_flag: <a href="integer.html">INTEGER</a>

   Agent_flag: <a href="integer.html">INTEGER</a>

   Missing_id_flag: <a href="integer.html">INTEGER</a>

   Bits_flag: <a href="integer.html">INTEGER</a>

   Deep_reference_flag: <a href="integer.html">INTEGER</a>

   Invariant_flag: <a href="integer.html">INTEGER</a>

   Generic_flag: <a href="integer.html">INTEGER</a>

   Sedb_flag: <a href="integer.html">INTEGER</a>

   Do_flag: <a href="integer.html">INTEGER</a>

   External_flag: <a href="integer.html">INTEGER</a>

   Once_flag: <a href="integer.html">INTEGER</a>

   Deferred_flag: <a href="integer.html">INTEGER</a>

   Frozen_flag: <a href="integer.html">INTEGER</a>

   Creation_flag: <a href="integer.html">INTEGER</a>

   Rescue_flag: <a href="integer.html">INTEGER</a>

   No_current_flag: <a href="integer.html">INTEGER</a>

   Side_effect_flag: <a href="integer.html">INTEGER</a>

   Inline_flag: <a href="integer.html">INTEGER</a>

   Attribute_flag: <a href="integer.html">INTEGER</a>

   Constant_flag: <a href="integer.html">INTEGER</a>

   Unique_flag: <a href="integer.html">INTEGER</a>

   Precomputable_flag: <a href="integer.html">INTEGER</a>

   Target: <a href="integer.html">INTEGER</a>

   Argument: <a href="integer.html">INTEGER</a>

   Old_value: <a href="integer.html">INTEGER</a>

   Local_var: <a href="integer.html">INTEGER</a>

   Result_value: <a href="integer.html">INTEGER</a>

   runtime_system: <a href="intro_runtime_system.html">IN_RUNTIME_SYSTEM</a>
<em>      -- The actual IN_SYSTEM.
</em>
      <strong>ensure</strong>
         not_void: Result /= Void

<strong>feature(s) from </strong><a href="comparable.html">COMPARABLE</a>
   is_equal (other: like Current): <a href="boolean.html">BOOLEAN</a>
      <strong>require</strong>
         other /= Void
      <strong>ensure</strong>
         generating_type = other.generating_type implies Result = other.is_equal(Current);
         trichotomy: Result = (not (Current < other) and not (other < Current))

   infix "<" (other: <a href="in_type.html">IN_TYPE</a>): <a href="boolean.html">BOOLEAN</a>
<em>      -- Comparison by ident.
</em>
      <strong>require</strong>
         other_exists: other /= Void
      <strong>ensure</strong>
         asymmetric: Result implies not (other < Current)

   infix "<=" (other: like Current): <a href="boolean.html">BOOLEAN</a>
<em>      -- Is </em>Current<em> less than or equal </em>other<em>?
</em>
      <strong>require</strong>
         other_exists: other /= Void
      <strong>ensure</strong>
         definition: Result = (Current < other or is_equal(other))

   infix ">" (other: like Current): <a href="boolean.html">BOOLEAN</a>
<em>      -- Is </em>Current<em> strictly greater than </em>other<em>?
</em>
      <strong>require</strong>
         other_exists: other /= Void
      <strong>ensure</strong>
         definition: Result = (other < Current)

   infix ">=" (other: like Current): <a href="boolean.html">BOOLEAN</a>
<em>      -- Is </em>Current<em> greater than or equal than </em>other<em>?
</em>
      <strong>require</strong>
         other_exists: other /= Void
      <strong>ensure</strong>
         definition: Result = (other <= Current)

   in_range (lower, upper: like Current): <a href="boolean.html">BOOLEAN</a>
<em>      -- Return true if </em>Current<em> is in range [</em>lower<em>..</em>upper<em>]
</em>
      <strong>ensure</strong>
         Result = (Current >= lower and Current <= upper)

   compare (other: like Current): <a href="integer.html">INTEGER</a>
<em>      -- If current object equal to </em>other<em>, 0
      -- if smaller,  -1; if greater, 1.
</em>
      <strong>require</strong>
         other_exists: other /= Void
      <strong>ensure</strong>
         equal_zero: Result = 0 = is_equal(other);
         smaller_negative: Result = -1 = (Current < other);
         greater_positive: Result = 1 = (Current > other)

   three_way_comparison (other: like Current): <a href="integer.html">INTEGER</a>
<em>      -- If current object equal to </em>other<em>, 0
      -- if smaller,  -1; if greater, 1.
</em>
      <strong>require</strong>
         other_exists: other /= Void
      <strong>ensure</strong>
         equal_zero: Result = 0 = is_equal(other);
         smaller_negative: Result = -1 = (Current < other);
         greater_positive: Result = 1 = (Current > other)

   min (other: like Current): like Current
<em>      -- Minimum of </em>Current<em> and </em>other<em>.
</em>
      <strong>require</strong>
         other /= Void
      <strong>ensure</strong>
         Result <= Current and then Result <= other;
         compare(Result) = 0 or else other.compare(Result) = 0

   max (other: like Current): like Current
<em>      -- Maximum of </em>Current<em> and </em>other<em>.
</em>
      <strong>require</strong>
         other /= Void
      <strong>ensure</strong>
         Result >= Current and then Result >= other;
         compare(Result) = 0 or else other.compare(Result) = 0

<strong>feature(s) from </strong><a href="hashable.html">HASHABLE</a>
   hash_code: <a href="integer.html">INTEGER</a>
<em>      -- The hash-code value of </em>Current<em>.
</em>
      <strong>ensure</strong>
         good_hash_value: Result >= 0

<strong>feature(s) from </strong><a href="general.html">GENERAL</a>
<em>   -- Access:
</em>
   generating_type: <a href="string.html">STRING</a>
<em>      -- Name of current object's generating type (type of
      -- which it is a direct instance).
</em>

   generator: <a href="string.html">STRING</a>
<em>      -- Name of current object's generating class (base class
      -- of the type of which it is a direct instance).
</em>

   stripped (other: <a href="general.html">GENERAL</a>): like other
<em>      -- Newly created object with fields copied from current object,
      -- but limited to attributes of type of </em>other<em>.
</em>
      <strong>require</strong>
         conformance: conforms_to(other)
      <strong>ensure</strong>
         stripped_to_other: Result.same_dynamic_type(other)

<strong>feature(s) from </strong><a href="general.html">GENERAL</a>
<em>   -- Status report:
</em>
   conforms_to (other: <a href="general.html">GENERAL</a>): <a href="boolean.html">BOOLEAN</a>
<em>      -- Is dynamic type of </em>Current<em> a descendant of dynamic type of
      -- </em>other<em> ?
      --
      -- Note: because of automatic conversion from expanded to reference
      -- type when passing argument </em>other<em>, do not expect a correct
      -- behavior with  expanded types.
</em>
      <strong>require</strong>
         not is_expanded_type;
         other_not_void: other /= Void

   same_dynamic_type (other: like Current): <a href="boolean.html">BOOLEAN</a>
<em>      -- Is the dynamic type of </em>Current<em> identical to the dynamic type 
      -- of </em>other<em>?
</em>

<strong>feature(s) from </strong><a href="general.html">GENERAL</a>
<em>   -- Comparison:
</em>
   equal (some: <a href="any.html">ANY</a>; other: like some): <a href="boolean.html">BOOLEAN</a>
<em>      -- Are </em>some<em> and </em>other<em> both Void or attached to objects 
      -- considered equal ?
</em>
      <strong>ensure</strong>
         symmetric: Result implies equal(other,some)

   standard_equal (some: <a href="any.html">ANY</a>; other: like some): <a href="boolean.html">BOOLEAN</a>
<em>      -- Are </em>some<em> and </em>other<em> both Void or attached to
      -- field-by-field objects of the same type ?
      -- Always use the default object comparison criterion.
</em>
      <strong>ensure</strong>
         definition: Result = (some = Void and other = Void) or else some /= Void and other /= Void and then some.standard_is_equal(other)

   standard_is_equal (other: like Current): <a href="boolean.html">BOOLEAN</a>
<em>      -- Are Current and </em>other<em> field-by-field identical?
</em>
      <strong>require</strong>
         other /= Void
      <strong>ensure</strong>
         same_dynamic_type(other) implies Result = other.standard_is_equal(Current)

<strong>feature(s) from </strong><a href="general.html">GENERAL</a>
<em>   -- Deep Comparison:
</em>
   deep_equal (some: <a href="any.html">ANY</a>; other: like some): <a href="boolean.html">BOOLEAN</a>
<em>      -- Are </em>some<em> and </em>other<em> either both Void or attached to
      -- recursively isomorphic object structures ?
</em>
      <strong>ensure</strong>
         shallow_implies_deep: standard_equal(some,other) implies Result

   is_deep_equal (other: like Current): <a href="boolean.html">BOOLEAN</a>
<em>      -- Is </em>Current<em> recursively isomorph with </em>other<em> ?
</em>
      <strong>require</strong>
         other_not_void: other /= Void

<strong>feature(s) from </strong><a href="general.html">GENERAL</a>
<em>   -- Duplication:
</em>
   clone (other: <a href="any.html">ANY</a>): like other
<em>      -- When argument </em>other<em> is Void, return Void otherwise 
      -- return </em>other.twin<em>.
</em>
      <strong>ensure</strong>
         equal: equal(Result,other)

   twin: like Current
<em>      -- Return a new object with the dynamic type of Current.
      -- Before being returned, the new object is initialized using
      -- feature </em>copy<em> (Current is passed as the argument).
      -- Thus, when feature </em>copy<em> of GENERAL is not redefined,
      -- </em>twin<em> has exactly the same behaviour as </em>standard_twin<em>.
</em>
      <strong>ensure</strong>
         equal: Result.is_equal(Current)

   copy (other: like Current)
      <strong>require</strong>
         same_dynamic_type(other)
      <strong>ensure</strong>
         is_equal(other)

   standard_clone (other: <a href="any.html">ANY</a>): like other
<em>      -- Void if </em>other<em> is Void; otherwise new object
      -- field-by-field identical to </em>other<em>.
      -- Always use the default copying semantics.
</em>
      <strong>ensure</strong>
         equal: standard_equal(Result,other)

   standard_twin: like Current
<em>      -- Return a new object with the dynamic type of Current.
      -- Before being returned, the new object is initialized using
      -- feature </em>standard_copy<em> (Current is passed as the argument).
</em>

   standard_copy (other: like Current)
<em>      -- Copy every field of </em>other<em> onto corresponding field of
      -- current object.
</em>
      <strong>require</strong>
         other_not_void: other /= Void
      <strong>ensure</strong>
         standard_is_equal(other)

   box: <a href="reference.html">REFERENCE</a>[like Current]
<em>      -- Create a REFERENCe object referring to Current 
</em>

<strong>feature(s) from </strong><a href="general.html">GENERAL</a>
<em>   -- Deep Duplication:
</em>
   deep_clone (other: <a href="any.html">ANY</a>): like other
<em>      -- When argument </em>other<em> is Void, return Void
      -- otherwise return </em>other.deep_twin<em>.
</em>
      <strong>ensure</strong>
         deep_equal(other,Result)

   deep_twin: like Current
<em>      -- Return a new object with the dynamic type of Current.
      -- The new object structure is recursively duplicated from the one
      -- attached to </em>Current<em>.
</em>

<strong>feature(s) from </strong><a href="general.html">GENERAL</a>
<em>   -- Basic operations:
</em>
   default: like Current
<em>      -- Default value of entities declared with the </em>Current<em> type.
      -- Hence, the </em>Result<em> is Void for all reference types and, as another 
      -- example, the </em>Result<em> is 0 for an INTEGER expression.
</em>

   is_default: <a href="boolean.html">BOOLEAN</a>
<em>      -- Is the </em>Current<em> object in the </em>default<em> state?
      -- For example, when this feature is applied on an INTEGER, the 
      -- </em>Result<em> is True only when the INTEGER is 0.  If not redefined, the 
      -- </em>Result<em> is always False for a reference expression. Actually, this 
      -- </em>is_default<em> predicate may be useful for user-defined expanded 
      -- objects stored in collection (see </em>all_default<em> of class 
      -- COLLECTION).
</em>

   default_pointer: <a href="pointer.html">POINTER</a>
<em>      -- Default value of type POINTER (avoid the need to write p.default 
      -- for some </em>p<em> of type POINTER).
</em>
      <strong>ensure</strong>
         Result = Result.default

   default_rescue
<em>      -- Handle exception if no Rescue clause. (Default: do nothing.)
</em>

<strong>feature(s) from </strong><a href="general.html">GENERAL</a>
<em>   -- Input and Output:
</em>
   io: <a href="std_input_output.html">STD_INPUT_OUTPUT</a>
<em>      -- Handle to standard file setup.
      -- To use the standard input/output file.
      -- Has type STD_FILES in ELKS 95.
</em>
      <strong>ensure</strong>
         Result /= Void

   std_input: <a href="std_input.html">STD_INPUT</a>
<em>      -- To use the standard input file.
</em>

   std_output: <a href="std_output.html">STD_OUTPUT</a>
<em>      -- To use the standard output file.
</em>

   std_error: <a href="std_error.html">STD_ERROR</a>
<em>      -- To use the standard error file.
</em>

<strong>feature(s) from </strong><a href="general.html">GENERAL</a>
<em>   -- Object Printing:
</em>
   print (some: <a href="general.html">GENERAL</a>)
<em>      -- Write terse external representation of </em>some<em> on
      -- </em>standard_output<em>.
      -- To customize printing, one may redefine
      -- </em>fill_tagged_out_memory<em> or </em>out_in_tagged_out_memory<em> (see
      -- for example how it works in class COLLECTION).
      -- Not frozen in ELKS 95.
</em>

   print_on (file: <a href="output_stream.html">OUTPUT_STREAM</a>)
<em>      -- Default printing of current object on a </em>file<em>.
      -- One may redefine </em>fill_tagged_out_memory<em> or
      -- </em>out_in_tagged_out_memory<em> to adapt the behavior of
      -- </em>print_on<em>.
      --
</em>

   tagged_out: <a href="string.html">STRING</a>
<em>      -- New string containing printable representation of current
      -- object, each field preceded by its attribute name, a
      -- colon and a space.
</em>

   out: <a href="string.html">STRING</a>

   out_in_tagged_out_memory
<em>      -- Append terse printable represention of current object
      -- in </em>tagged_out_memory<em>.
</em>
      <strong>ensure</strong>
         not_cleared: tagged_out_memory.count >= old tagged_out_memory.count;
         append_only: (old tagged_out_memory.twin).is_equal(tagged_out_memory.substring(1,old tagged_out_memory.count))

   tagged_out_memory: <a href="string.html">STRING</a>

   fill_tagged_out_memory
<em>      -- Append a viewable information in </em>tagged_out_memory<em> in
      -- order to affect the behavior of </em>out<em>, </em>tagged_out<em>, etc.
</em>

<strong>feature(s) from </strong><a href="general.html">GENERAL</a>
<em>   -- Access to command-line arguments:
</em>
   argument_count: <a href="integer.html">INTEGER</a>
<em>      -- Number of arguments given to command that started
      -- system execution (command name does not count).
</em>
      <strong>ensure</strong>
         Result >= 0

   argument (i: <a href="integer.html">INTEGER</a>): <a href="string.html">STRING</a>
<em>      -- </em>i<em> th argument of command that started system execution
      -- Gives the command name if </em>i<em> is 0.
</em>
      <strong>require</strong>
         i >= 0;
         i <= argument_count
      <strong>ensure</strong>
         Result /= Void

   command_arguments: <a href="fast_array.html">FAST_ARRAY</a>[<a href="string.html">STRING</a>]
<em>      -- Give acces to arguments command line including the
      -- command name at index 0.
</em>
      <strong>ensure</strong>
         not Result.is_empty

<strong>feature(s) from </strong><a href="general.html">GENERAL</a>
<em>   -- SCOOP:
</em>
   available: <a href="boolean.html">BOOLEAN</a>
<em>      -- Wait the result (By Necessity [TM])
      -- Always return True
      -- (Meaningless in a non-SCOOP world)
</em>

<strong>feature(s) from </strong><a href="general.html">GENERAL</a>
<em>   -- System calls and crashs:
</em>
   crash
<em>      -- Print Run Time Stack and then exit with </em>exit_failure_code<em>.
</em>

   trace_switch (flag: <a href="boolean.html">BOOLEAN</a>)
<em>      -- May be used in combination with option "-sedb" of command
      -- </em>compile_to_c<em> (see compile_to_c documentation for details).
</em>

   sedb_breakpoint
<em>      -- May be used in combination with option "-sedb" of command
      -- </em>compile_to_c<em> to set a breakpoint for sedb, the SmartEiffel debugger.
</em>

   die_with_code (code: <a href="integer.html">INTEGER</a>)
<em>      -- Terminate execution with exit status code </em>code<em>.
      -- Do not print any message.
      -- Note: you can use predefined </em>exit_success_code<em> or
      -- </em>exit_failure_code<em> as well as another code you need.
</em>

   exit_success_code: <a href="integer.html">INTEGER</a>

   exit_failure_code: <a href="integer.html">INTEGER</a>

<strong>feature(s) from </strong><a href="general.html">GENERAL</a>
<em>   -- Should not exist:
</em>
   not_yet_implemented

<strong>feature(s) from </strong><a href="general.html">GENERAL</a>
<em>   -- For ELS Compatibility:
</em>
   id_object (id: <a href="integer.html">INTEGER</a>): <a href="any.html">ANY</a>
<em>      -- Object for which </em>object_id<em> has returned </em>id<em>
      -- Void if none.
</em>
      <strong>require</strong>
         id /= 0

   object_id: <a href="integer.html">INTEGER</a>
<em>      -- Value identifying current reference object.
</em>
      <strong>require</strong>
         not is_expanded_type

<strong>feature(s) from </strong><a href="general.html">GENERAL</a>
<em>   -- The Guru section:
</em>
   to_pointer: <a href="pointer.html">POINTER</a>
<em>      -- This routine can be used only if the value of </em>Current<em> is really
      -- a memory address. (This is the case for all reference types and
      -- for the NATIVE_ARRAY type only.) Actually, this routine do
      -- nothing: the value of </em>Current<em> which is an address is returned
      -- unchanged. The compiler will emit a warning if you try to use
      -- </em>to_pointer<em> on some invalid type.
</em>

   is_expanded_type: <a href="boolean.html">BOOLEAN</a>
<em>      -- Target is not evaluated (Statically computed).
      -- Result is True if target static type is an expanded type.
      -- Useful for formal generic type.
</em>

   is_basic_expanded_type: <a href="boolean.html">BOOLEAN</a>
<em>      -- Target is not evaluated (Statically computed).
      -- Result is True if target static type is one of the
      -- following types: BOOLEAN, CHARACTER, INTEGER, REAL,
      -- DOUBLE or POINTER.
</em>
      <strong>ensure</strong>
         Result implies is_expanded_type

   object_size: <a href="integer.html">INTEGER</a>
<em>      -- Gives the size of the current object at first level
      -- only (pointed-to sub-object are not concerned).
      -- The result is given in number of CHARACTER.
</em>

<strong>feature(s) from </strong><a href="general.html">GENERAL</a>
<em>   -- Implementation of GENERAL (do not use directly):
</em>
   se_assigned_from (other: <a href="general.html">GENERAL</a>): <a href="boolean.html">BOOLEAN</a>
<em>      -- To implement </em>conforms_to<em> (must only be called inside
      -- </em>conforms_to<em> because of VJRV rule).
</em>
      <strong>require</strong>
         not is_expanded_type

<strong>feature(s) from </strong><a href="intro_base.html">IN_BASE</a>
<em>   -- Access
</em>
   name: <a href="string.html">STRING</a>
      <strong>ensure</strong>
         not_void: Result /= Void

<strong>feature(s) from </strong><a href="intro_base.html">IN_BASE</a>
<em>   -- Status
</em>
   has_name (s: <a href="string.html">STRING</a>): <a href="boolean.html">BOOLEAN</a>
<em>      -- Is </em>name<em> equal to </em>s<em> when ignoring letter case?
</em>
      <strong>require</strong>
         not_void: s /= Void

   name_has_prefix (s: <a href="string.html">STRING</a>): <a href="boolean.html">BOOLEAN</a>
<em>      -- Does </em>name<em> start with </em>s <em>when ignoring latter case?
</em>
      <strong>require</strong>
         not_void: s /= Void

<strong>feature(s) from </strong><a href="intro_base.html">IN_BASE</a>
<em>   -- Basic operation
</em>
   append_name (str: <a href="string.html">STRING</a>)
<em>      -- Append </em>name<em> to </em>s<em>.
</em>
      <strong>require</strong>
         not_void: str /= Void
      <strong>ensure</strong>
         appended: str.has_suffix(name)

<strong>feature(s) from </strong><a href="intro_base.html">IN_BASE</a>
<em>   -- COMPARABLE
</em>
   compare_name (nm: <a href="string.html">STRING</a>): <a href="integer.html">INTEGER</a>
<em>      -- Compare </em>Current<em>'s name with </em>nm<em> in the sense 
      -- of </em>three_way_comparison<em>. 
</em>

   same_name (other: <a href="intro_base.html">IN_BASE</a>): <a href="boolean.html">BOOLEAN</a>
<em>      -- Have </em>Current<em> and </em>other<em> the same name?
</em>

<strong>feature(s) from </strong><a href="platform.html">PLATFORM</a>
<em>   -- Maximum:
</em>
   Maximum_character_code: <a href="integer_16.html">INTEGER_16</a>
<em>      -- Largest supported code for CHARACTER values.
</em>
      <strong>ensure</strong>
         meaningful: Result >= 127

   Maximum_integer_8: <a href="integer_8.html">INTEGER_8</a>
<em>      -- Largest supported value of type INTEGER_8.
</em>

   Maximum_integer_16: <a href="integer_16.html">INTEGER_16</a>
<em>      -- Largest supported value of type INTEGER_16.
</em>

   Maximum_integer: <a href="integer.html">INTEGER</a>
<em>      -- Largest supported value of type INTEGER/INTEGER_32.
</em>

   Maximum_integer_32: <a href="integer.html">INTEGER</a>
<em>      -- Largest supported value of type INTEGER/INTEGER_32.
</em>

   Maximum_integer_64: <a href="integer_64.html">INTEGER_64</a>
<em>      -- Largest supported value of type INTEGER_64.
</em>

   Maximum_real: <a href="real.html">REAL</a>
<em>      -- Largest supported value of type REAL.
</em>
      <strong>ensure</strong>
         meaningful: Result >= 0.0

   Maximum_double: <a href="double.html">DOUBLE</a>
<em>      -- Largest supported value of type DOUBLE.
</em>
      <strong>ensure</strong>
         meaningful: Result >= Maximum_real

<strong>feature(s) from </strong><a href="platform.html">PLATFORM</a>
<em>   -- Minimum:
</em>
   Minimum_character_code: <a href="integer_16.html">INTEGER_16</a>
<em>      -- Smallest supported code for CHARACTER values.
</em>
      <strong>ensure</strong>
         meaningful: Result <= 0

   Minimum_integer_8: <a href="integer_8.html">INTEGER_8</a>
<em>      -- Smallest supported value of type INTEGER_8.
</em>

   Minimum_integer_16: <a href="integer_16.html">INTEGER_16</a>
<em>      -- Smallest supported value of type INTEGER_16.
</em>

   Minimum_integer: <a href="integer.html">INTEGER</a>
<em>      -- Smallest supported value of type INTEGER/INTEGER_32.
</em>

   Minimum_integer_32: <a href="integer.html">INTEGER</a>
<em>      -- Smallest supported value of type INTEGER/INTEGER_32.
</em>

   Minimum_integer_64: <a href="integer_64.html">INTEGER_64</a>
<em>      -- Smallest supported value of type INTEGER_64.
</em>

   Minimum_double: <a href="double.html">DOUBLE</a>
<em>      -- Smallest supported value of type DOUBLE.
</em>
      <strong>ensure</strong>
         meaningful: Result <= 0.0

   Minimum_real: <a href="real.html">REAL</a>
<em>      -- Smallest supported value of type REAL.
</em>
      <strong>ensure</strong>
         meaningful: Result <= 0.0

<strong>feature(s) from </strong><a href="platform.html">PLATFORM</a>
<em>   -- Bits:
</em>
   Boolean_bits: <a href="integer.html">INTEGER</a>
<em>      -- Number of bits in a value of type BOOLEAN.
</em>
      <strong>ensure</strong>
         meaningful: Result >= 1

   Character_bits: <a href="integer.html">INTEGER</a>
<em>      -- Number of bits in a value of type CHARACTER.
</em>
      <strong>ensure</strong>
         meaningful: Result >= 1;
         large_enough: (2).to_integer_32 ^ Result >= Maximum_character_code

   Integer_bits: <a href="integer.html">INTEGER</a>
<em>      -- Number of bits in a value of type INTEGER.
</em>
      <strong>ensure</strong>
         integer_definition: Result = 32

   Real_bits: <a href="integer.html">INTEGER</a>
<em>      -- Number of bits in a value of type REAL.
</em>
      <strong>ensure</strong>
         meaningful: Result >= 1

   Double_bits: <a href="integer.html">INTEGER</a>
<em>      -- Number of bits in a value of type DOUBLE.
</em>
      <strong>ensure</strong>
         meaningful: Result >= 1;
         meaningful: Result >= Real_bits

   Pointer_bits: <a href="integer.html">INTEGER</a>
<em>      -- Number of bits in a value of type POINTER.
</em>

<strong>feature(s) from </strong><a href="in_type.html">IN_TYPE</a>
<em>   -- Access
</em>
   ident: <a href="integer.html">INTEGER</a>
<em>      -- System wide unique identifier.
</em>

   bit_count: <a href="integer.html">INTEGER</a>
<em>      -- Number of bits if is a BIT_N type.
</em>

   base_class: <a href="intro_class.html">IN_CLASS_TEXT</a>
<em>      -- Type descriptor of base type.
</em>

   generic_count: <a href="integer.html">INTEGER</a>
<em>      -- Number of generics parameters.
</em>
      <strong>ensure</strong>
         not_negative: Result >= 0

   valid_generic (i: <a href="integer.html">INTEGER</a>): <a href="boolean.html">BOOLEAN</a>
      <strong>ensure</strong>
         validity: Result = (0 <= i and then i < generic_count)

   generic_at (i: <a href="integer.html">INTEGER</a>): <a href="in_type.html">IN_TYPE</a>
<em>      -- Type of the </em>i<em>-th actual generic parameter. 
</em>
      <strong>require</strong>
         valid_index: valid_generic(i)
      <strong>ensure</strong>
         result_not_void: Result /= Void

   effector_count: <a href="integer.html">INTEGER</a>
<em>      -- Number of </em>Currents<em>'s effecting types. 
</em>
      <strong>ensure</strong>
         not_negative: Result >= 0

   valid_effector (i: <a href="integer.html">INTEGER</a>): <a href="boolean.html">BOOLEAN</a>
      <strong>ensure</strong>
         validity: Result = (0 <= i and then i < effector_count)

   effector_at (i: <a href="integer.html">INTEGER</a>): <a href="in_type.html">IN_TYPE</a>
<em>      -- Type of </em>i<em>-th effective descentant.
</em>
      <strong>require</strong>
         valid: valid_effector(i)

   attribute_count: <a href="integer.html">INTEGER</a>
<em>      -- Number of variable attributes.
</em>
      <strong>ensure</strong>
         not_negative: Result >= 0

   valid_attribute (i: <a href="integer.html">INTEGER</a>): <a href="boolean.html">BOOLEAN</a>
      <strong>ensure</strong>
         validity: Result = (0 <= i and then i < attribute_count)

   attribute_at (i: <a href="integer.html">INTEGER</a>): <a href="intro_field.html">IN_FIELD</a>
<em>      -- </em>i<em>-th variable attribute. 
</em>
      <strong>require</strong>
         valid_index: valid_attribute(i)
      <strong>ensure</strong>
         not_void: Result /= Void

   constant_count: <a href="integer.html">INTEGER</a>
<em>      -- Number of constant attributes.
</em>
      <strong>ensure</strong>
         not_negative: Result >= 0

   valid_constant (i: <a href="integer.html">INTEGER</a>): <a href="boolean.html">BOOLEAN</a>
      <strong>ensure</strong>
         validity: Result = (0 <= i and then i < constant_count)

   constant_at (i: <a href="integer.html">INTEGER</a>): <a href="intro_const.html">IN_CONST</a>[<a href="any.html">ANY</a>]
<em>      -- </em>i<em>-th constant attribute. 
</em>
      <strong>require</strong>
         valid_index: valid_constant(i)
      <strong>ensure</strong>
         not_void: Result /= Void

   routine_count: <a href="integer.html">INTEGER</a>
<em>      -- Number of routines.
</em>
      <strong>ensure</strong>
         not_negative: Result >= 0

   valid_routine (i: <a href="integer.html">INTEGER</a>): <a href="boolean.html">BOOLEAN</a>
      <strong>ensure</strong>
         validity: Result = (0 <= i and then i < routine_count)

   routine_at (i: <a href="integer.html">INTEGER</a>): <a href="intro_routine.html">IN_ROUTINE</a>
<em>      -- </em>i<em>-th routine.
</em>
      <strong>require</strong>
         valid_index: valid_routine(i)

   invariant_function: like routine_at
<em>      -- Function computing the class invariant.
</em>

   has_bracket: <a href="boolean.html">BOOLEAN</a>
<em>      -- Has </em>Current<em> a bracket function?
</em>

   bracket: <a href="intro_routine.html">IN_ROUTINE</a>
<em>      -- The type's bracket function, if any.
</em>

<strong>feature(s) from </strong><a href="in_type.html">IN_TYPE</a>
<em>   -- Status
</em>
   flags: <a href="integer.html">INTEGER</a>

   is_expanded: <a href="boolean.html">BOOLEAN</a>

   is_basic_expanded: <a href="boolean.html">BOOLEAN</a>
      <strong>ensure</strong>
         is_expanded: Result implies is_expanded

   is_reference: <a href="boolean.html">BOOLEAN</a>

   is_separate: <a href="boolean.html">BOOLEAN</a>

   is_none: <a href="boolean.html">BOOLEAN</a>

   is_boolean: <a href="boolean.html">BOOLEAN</a>

   is_character: <a href="boolean.html">BOOLEAN</a>

   is_integer: <a href="boolean.html">BOOLEAN</a>

   is_real: <a href="boolean.html">BOOLEAN</a>

   is_double: <a href="boolean.html">BOOLEAN</a>

   is_pointer: <a href="boolean.html">BOOLEAN</a>

   is_char8: <a href="boolean.html">BOOLEAN</a>

   is_char32: <a href="boolean.html">BOOLEAN</a>

   is_int8: <a href="boolean.html">BOOLEAN</a>

   is_int16: <a href="boolean.html">BOOLEAN</a>

   is_int32: <a href="boolean.html">BOOLEAN</a>

   is_int64: <a href="boolean.html">BOOLEAN</a>

   is_nat8: <a href="boolean.html">BOOLEAN</a>

   is_nat16: <a href="boolean.html">BOOLEAN</a>

   is_nat32: <a href="boolean.html">BOOLEAN</a>

   is_nat64: <a href="boolean.html">BOOLEAN</a>

   is_bit_n: <a href="boolean.html">BOOLEAN</a>

   is_string: <a href="boolean.html">BOOLEAN</a>

   is_unicode: <a href="boolean.html">BOOLEAN</a>

   is_normal: <a href="boolean.html">BOOLEAN</a>

   is_special: <a href="boolean.html">BOOLEAN</a>

   is_tuple: <a href="boolean.html">BOOLEAN</a>

   is_agent: <a href="boolean.html">BOOLEAN</a>

   is_living: <a href="boolean.html">BOOLEAN</a>
<em>      -- Is the type alive (i.e. can instances be created) ?
</em>

   is_actionable: <a href="boolean.html">BOOLEAN</a>
<em>      -- Does the type's base class inherit from PC_ACTIONABLE?
</em>

   has_invariant: <a href="boolean.html">BOOLEAN</a>
<em>      -- Does the type's base class define an invariant clause?
</em>

<strong>feature(s) from </strong><a href="in_type.html">IN_TYPE</a>
<em>   -- Instance sizes
</em>
   instance_size: <a href="integer.html">INTEGER</a>
<em>      -- Memory size (in bytes) of instances of the current type.
</em>

   boxed_size: <a href="integer.html">INTEGER</a>
<em>      -- Memory size of boxed expanded instances. 
</em>

   field_size: <a href="integer.html">INTEGER</a>
<em>      -- Memory size (in bytes) of objects within other objects.
</em>
      <strong>ensure</strong>
         not_negative: 0 <= Result;
         when_expanded: is_expanded implies Result = instance_size

   boxed_offset: <a href="integer.html">INTEGER</a>
<em>      -- Offset of unboxed item within boxed object.
</em>

<strong>feature(s) from </strong><a href="in_type.html">IN_TYPE</a>
<em>   -- Comparison
</em>
   less_by_name (other: <a href="in_type.html">IN_TYPE</a>): <a href="boolean.html">BOOLEAN</a>
<em>      -- Comparison by name.
</em>

   conformance (other: <a href="in_type.html">IN_TYPE</a>): <a href="integer.html">INTEGER</a>
<em>      -- How good does </em>Current<em> conform to </em>other<em>?
      -- </em>Result=0<em> means exact match, </em>Result=Maximum_integer<em> means no match,
      -- i.e. assignment like </em>other_obj:=current_obj<em> is not possible.
</em>
      <strong>require</strong>
         other_not_void: other /= Void
      <strong>ensure</strong>
         not_negative: Result >= 0

   conforms_to_type (other: <a href="in_type.html">IN_TYPE</a>): <a href="boolean.html">BOOLEAN</a>
<em>      -- Does type described by </em>Current<em> conform to type
      -- described by </em>other<em>?
</em>
      <strong>require</strong>
         not_void: other /= Void

   does_effect (other: <a href="in_type.html">IN_TYPE</a>): <a href="boolean.html">BOOLEAN</a>
<em>      -- Does type described by </em>Current<em> effect the type
      -- described by </em>other<em>?
</em>
      <strong>require</strong>
         not_void: other /= Void

<strong>feature(s) from </strong><a href="in_type.html">IN_TYPE</a>
<em>   -- Searching
</em>
   attribute_by_name (nm: <a href="string.html">STRING</a>): like attribute_at
<em>      -- </em>Current<em>s attribute with name </em>nm<em>
      -- </em>void<em> if no such attribute exists.
</em>
      <strong>require</strong>
         nm_not_void: nm /= Void
      <strong>ensure</strong>
         when_found: Result /= Void implies Result.has_name(nm) and then attributes.has(Result)

   constant_by_name (nm: <a href="string.html">STRING</a>): like constant_at
<em>      -- </em>Current<em>s constant attribute with name </em>nm<em>
      -- </em>void<em> if no such constant exists.
</em>
      <strong>require</strong>
         nm_not_void: nm /= Void
      <strong>ensure</strong>
         when_found: Result /= Void implies Result.has_name(nm) and then constants.has(Result)

   routine_by_name (nm: <a href="string.html">STRING</a>): like routine_at
<em>      -- routine in </em>Current<em>s class with name </em>nm<em>
      -- </em>void<em> if no such routine exists.
</em>
      <strong>require</strong>
         name_not_void: nm /= Void
      <strong>ensure</strong>
         when_found: Result /= Void implies Result.has_name(nm) and then routines.has(Result)

   push_type (t: <a href="in_type.html">IN_TYPE</a>)
      <strong>require</strong>
         not_void: t /= Void
      <strong>ensure</strong>
         type_stack_not_void: type_stack /= Void;
         stack_size: type_stack.count = old type_stack.count + 1

   top_type: <a href="in_type.html">IN_TYPE</a>
      <strong>ensure</strong>
         on_top: Result = type_stack.item(type_stack.count - 1);
         stack_size: type_stack.count = old type_stack.count

   pop_types (n: <a href="integer.html">INTEGER</a>)
<em>      -- Pop </em>n<em> types from the </em>type_stack<em>. 
</em>
      <strong>require</strong>
         not_negative: n >= 0
      <strong>ensure</strong>
         type_stack_size: type_stack.count = old type_stack.count - n

   routine_by_signature (res: <a href="intro_local.html">IN_LOCAL</a>; na: <a href="integer.html">INTEGER</a>; previous: like routine_at): like routine_at
<em>      -- Routine in </em>Current<em>s class with </em>na<em> argument types
      -- (which have been pushed previously to the type_stack) 
      -- and result type </em>res<em> (</em>Void<em> in case of a procedure).
      -- Search strats after </em>previous<em> (</em>Void<em> for the first call).
      -- Result is the next routine found
      -- (or </em>Void<em> if no more such routines). 
</em>
      <strong>require</strong>
         res_not_void: res /= Void;
         na_not_negative: na >= 0

<strong>feature(s) from </strong><a href="in_type.html">IN_TYPE</a>
<em>   -- Output
</em>
   append_indented (s: <a href="string.html">STRING</a>; indent, indent_increment: <a href="integer.html">INTEGER</a>)
<em>      -- Fill </em>s<em> by printable format of </em>Current<em> preceded by </em>indent<em>
      -- and closed by a new line character.
</em>
      <strong>require</strong>
         s_not_void: s /= Void;
         indent_not_negative: indent >= 0;
         increment_not_negative: indent_increment >= 0


<strong>invariant</strong>
   ident_not_negative: ident >= 0;
   base_class_not_void: base_class /= Void;
   instance_size_not_negative: instance_size >= 0;
   boxed_size_not_smaller_than_instance_size: boxed_size >= instance_size;

<strong>end of deferred <a href="in_type.html">IN_TYPE</a></strong></pre>
</body>
</html>