Revision history for CORBA-IDLtree

2.06  2025/04/20
      * In the SUBORDINATES of ENUM, when $enable_comments is set
        change the layout for a comment to conform to the REMARK
        node layout.
      * Change sub info to only print if $verbose is set.
      * Fix handling of annotations applied on members of
        constructed types.
      * On encountering unknown annotation, downgrade severity
        from error to warning.

2.05  2021/06/13
      * Increase minimum required perl version to 5.8 due to
        addition of "use utf8".
      * Add handling of Windows CP-1252 character encoding in
        input file:
        - Add `use utf8`.
        - Require module Encode::Guess.
        - In sub get_items:
          - On encountering a non printable character call
            Encode::Guess->guess.
          - If the call returns a ref then a decoder was found
            and no special action is required.
          - If the call returns "No appropriate encodings found"
            then assign $l from Encode::decode("cp-1252", $l).
          - If the call returns none of the above then print a
            warning "Unsupported character encoding" and replace
            the non printable characters in $l by space.
        - In sub Parse_File_i case $file case $emucpp call to
          `open $in`, the encoding directive for UTF-8 is no
          longer needed due to use of Encode::Guess (see above).
      * In sub skip_input fix handling of preprocessor directives
        where the "#" is not placed in column 1 but is preceded by
        whitespace.
      * Fix sub scoped_name in case of chained module reopenings.

2.04    2020/06/20
        * In sub Parse_File_i case $file case $emucpp open $in
          with encoding(UTF-8) to ensure that IDL files are parsed
          as utf8.
        * New sub discard_bom discards a possible Unicode or UTF-8
          BOM (Byte Order Mark) at the start of the given line.
          In sub get_items add optional argument $firstline.
          If $firstline is given and true then discard_bom will be
          called on the first line read from file.
          In sub Parse_File_i outer while-loop add local
          $firstline for call to sub get_items.
        * New sub has_default_branch checks whether the given union
          subordinates contain a DEFAULT branch.  This fixes a bug
          related to checking that a union has an enum type as its
          switch and does not have a default branch.
          A false warning was generated in case the default branch
          was preceded by a comment.
        * Improvements to preprocessor emulation:
          - Support "#if defined XYZ" without parentheses around
            the symbol.  Fix evaluation of the symbol.
          - Do not attempt evaluating preprocessor directives when
            inside multi line comments.
          - Fix handling of #endif in nested #if/#ifdef/#ifndef.
        * In @annoDefs add java_mapping annotations defined by the
          IDL4 to Java mapping proposal.

2.03    2019/04/27
        * Fixed a bug related to Dump_Symbols whereby when using
          a string array ref as the optional argument, repeated
          calls to the sub would accumulate the text.
        * In sub parse_members, optional argument $comment fixes
          processing of trailing comment at members of struct,
          exception, and valuetype.

2.02    2018/08/15
        * Fixed a few typos in documentation.
        * Added support for IDL4 struct inheritance defined by the
          Building Block Extended Data-Types:
          In case of STRUCT, the first SUBORDINATES element of may
          be a reference to a further STRUCT node instead of the
          reference to quintuplet. In this case, the first element
          indicates the IDL4 parent struct type of the current
          struct.  The function isnode() can be used for detecting
          this case. The support for IDL4 struct inheritance is
          implemented in sub Parse_File_i case $kw eq 'struct'.
        * In sub is_elementary_type return early on undefined
          $tdesc.
        * In sub info check for valid $currfile and @infilename
          before accessing $infilename[$currfile].
        * In sub error avoid code duplication by reusing the
          implemenation of sub info.
        * In sub dump_symbols_internal handling of METHOD, pop
          @arg only if @arg is non empty and $arg[-1] contains
          the exception list.  We need these extra tests because
          METHODs in VALUETYPEs do not have an exception list as
          the last element of the SUBORDINATES.
        * In sub dump_symbols_internal handling of REMARK nodes,
          on calling sub dump_comment swap elements of anonymous
          constructed array: $name comes first, then $subord.
          (COMMENT nodes use the same layout.)

2.01    2018/01/23
        * Fixed parsing of named argument values in sub
          parse_annotation_app:  At case
            @$argref && $argref->[0] eq '('
          while-loop over @$argref case
            $val =~ /^[a-z]/i and $argref->[0] eq '='
          for-loop of $ai case
            $adef[$ai]->[1] eq $parname,
          after assigning $param_index execute `last' instead of
          `return'.
        * Declared globals %annoEnum and @annoDefs as `our' to
          make them accessible from outside.
        * Added 'port' to global %keywords.
        * Fixed calls to sub annotation so that more than one
          annotation may accumulate on a given IDL item.
        * Fixed changelog entry for v. 1.6 modification of REMARK
          NAME/SUBORDINATES.

2.00    2018/01/05
        * Fixed parsing of parameterless annotation with empty
          @$argref in sub parse_annotation_app.
        * Changed version numbering to conform to CPAN format.
        * Based distro on skeleton generated by module-starter.
        * Started converting inline documentation to POD format.

1.6     2018/01/01
        * Fixed parsing of inheritance from an absolute qualified
          superclass such as e.g.
          valuetype vt : ::absolute::qualified::superclass {...};
        * Added variable $global_idlfile, a copy of the file name
          passed into the most recent call to Parse_File.
        * Simplified the REMARK node as follows:
          - Its NAME contains the starting line number of the
            comment lines.
          - Its SUBORDINATES points to a simple array of lines.
            The file name and line number elements are no longer
            part of the lines array.
        * The COMMENT element now points to a tuple of (starting)
          line number and reference to simple array of lines.
          I.e. the file name and line number elements are no
          longer part of the lines array.
        * Added support for IDL4 standard annotations and user
          defined @annotation.  See below for documentation on
          the new node element ANNOTATIONS.
          IDL4 annotations are currently supported in the
          following locations:
          - Type declarations
          - Member declarations of structured types
          - Enum literal value declarations
          Modified the node structure of these constructs
          accordingly.
        * New sub enum_literals returns the net literals of an
          ENUM.  It is intended to shield against the node
          structure change at enum literals. Direct usages of
          enum SUBORDINATES should be replaced by calls to this
          sub when possible.
        * Removed support for non standard enum value repre-
          sentation as in: enum MyEnum { zero=0, one=1 };
          This is superseded by the @value annotation.

1.5     2017/07/23
        The SCOPEREF of a MODULE now points to the previous
        opening of the module.
        Changed the COMMENT node element and the NAME element of
        the REMARK node as follows: Each element in the comment
        array is a ref to an array that contains the name of the
        file, the line number, and the comment text in that order.

1.4     2003/07/25
        Implemented #elif in the emulated preprocessor and fixed
        the handling of preprocessor conditions.
        Changed the COMMENT element of the node structure to only
        contain the post-comment. Turned the former pre-comment
        into an independent node, REMARK. See documentation below.
        Added global switch $cache_trees.  It buys speed when
        submitting related IDL files to consecutive Parse_File
        calls by saving and reusing the trees built for #included
        files.  CAVEAT: The redefinition of #defined symbols
        is flagged as an error when using this switch.

1.3     2002/12/01
        #include statements that appear at places other than
        the global scope are no longer made into INCFILE nodes;
        instead, the included file is parsed inline.
        The SCOPEREF of declarations immediately inside an INCFILE
        now point to the INCFILE. This change makes possible the
        reopening of modules.
        Support self-referential valuetype definition, i.e.
        state members that are of the type currently being defined.

1.2     2002/07/08
        Added a further element to the node structure: COMMENT
        (see below for details.)
        Added user-level utilities is_a and root_type.
        Added PRAGMA for the general case of (unknown) pragmas.
        Relieved the constraint on the required perl version;
        perl versions after 5.002 should be fine.
        Privatized @predef_types. Apps should only use sub typeof.

1.1a    2002/06/27
        Added sub is_valid_identifier. Added a test directory.

1.1     2002/06/24
        Removed non-standard extensions.
        In the interest of IDL conformance, changed the scope
        separator used internally to "::". (This separator
        may appear at union CASE designators and in CONST
        and array dimension expressions.)
        Removed the LANG constants, and removed support for
        languages other than IDL in sub typeof.
        Corrected parsing of valuetype boxes.
        Repaired `const string' and implemented simple `const'
        used as a bounded-string bound expression.
        Added detection of unclosed comment at end of file.
        Added NATIVE.

1.0     2002/02/04
        Turned all variables used as constants into subroutines.
        Attention, unfortunately this impacts all applications;
        e.g. the former $CORBA::IDLtree::BOOLEAN is now written
        &CORBA::IDLtree::BOOLEAN .
        Added "abstract" and OBV related keywords.
        Improved usage of gcc as a C preprocessor.
        However, there still are problems with using system
        preprocessors, due to variations in their options and
        behavior. The default is now to use preprocessor
        emulation. Removed sub emulate_cpp and added sub
        use_system_preprocessor to attempt usage of the system
        preprocessor.
        The builtin preprocessor now does simple substitutions
        (however, macro functions are still unimplemented.)

0.7b    1999/11/16
        Added pragma ID.

0.7a    1999/11/16
        Added sub emulate_cpp to force C preprocessor emulation.

0.7     1999/09/15
        Added wchar and wstring to the elementary types.
        The SUBORDINATES of an INTERFACE node were erroneously
        a tuple (ancestor ref plus ref to array of contained nodes)
        The ref-to-contained-nodes was one level of indirection
        too many. Corrected that to be a flat array; element 0 is
        the ancestor ref, following elements are the contained
        nodes.
        Dump_Symbols now generates exact IDL syntax.

0.6b    1999/08/03
        Improved C preprocessor emulation by Jacques Tremblay
        (jackt@gel.ulaval.ca)

0.6     1999/07/17
        Use C preprocessor; added optional argument $cpp_args
        at Parse_File

0.5b    1999/05/17
        Support IDL type "TypeCode"

0.5     1999/05/09
        Support IDL type "fixed" and the extra long types

0.4a    1999/04/29
        Added a node for interface forward declarations.
        First rough hack at the missing preprocessor directives
        #ifdef, #ifndef, #else, #endif, #define, #undef
        (no nested #ifdefs yet.) Perhaps this stuff shouldn't be
        done here at all and we should use the C preprocessor
        instead. Discussion welcome.

0.4     1999/04/20
        Design change: added a back pointer to the enclosing
                 scope to each node. The basic node now contains four
                 elements: ($TYPE, $NAME, $SUBORDINATES, $SCOPE)
                 Removed the %Prefixes hash that is thus obsolete.
                 Replaced sub check_scope by sub curr_scope.

0.3     1999/04/11
        Added a node for pragma prefix

0.2     1999/04/06
        Minor cosmetic changes; tested subs traverse_tree
        and traverse (for usage example, see idl2ada.pl)
        Preprocessor directives other than #include were
        actually mistreated (fixed so they are just ignored.)

0.1     1998/07/06
        Corrected the first parameter to the check_scope call
        in process_members.
        The two elements of @tuple in 'const' processing were
        the wrong way round, corrected that.
        Overhauled the explanation of the Symbol Tree which was
        buggy in itself.

0.0     1998/06/29
        First public release, alpha stage
        Things known to need thought: forward declarations,
        generation of Typecode information. The symbol trees
        generated are pretty much nude'n'crude -- what you see in
        IDL is what you get in ST. What kind of decorative info do
        we need? Any ideas/discussion, please email to addr. above

-.-     Mar 1998
        Start of development
        The first version of this worked as a simple one-pass
        text filter until I attempted implementing interface
        references. In order to generate a "Ref" for those (in
        Ada), it is necessary to distinguish them from other
        types (the Ada type name is different from the IDL type
        name.) This single requirement led to the abandonment
        of the direct text-to-text transformation approach.
        Instead, IDL source text is first translated into a
        target language independent intermediate representation
        (the symbol tree), and the target language text is
        then generated from that intermediate representation.

