Changes

App [next release - last updated 28 Oct 2000]

• An explicit Cons__<A> dtor has been added to beta.h that requires O(1) space rather than O(n) for n-length lists. It can be disabled at compile-time by defining APP_NO_ITER_CONS_DTOR. For huge lists this can be a significant issue. A listing of the relevant parts of the new List<A> and Cons__<A> declarations follows; the Cons__ code uses a new public function called Top__::reference_count in alpha.h (also listed), a non-virtual version of the existing Top__::counter function.

      // alpha.h, class Top__, public
      int reference_count() const {return count;} // non-virtual version
  
      // beta.h
      $data List<class A> = 0 | Cons(A a, List<A> b) {
        A a(A new_a) {return a_ = new_a;}
        List<A> b(List<A> new_b) {return b_ = new_b;}
        bool print(ostream& os);
      #ifndef APP_NO_ITER_CONS_DTOR
        virtual ~Cons__(); // see below
      #endif
      } : {
        .
        .
        .
      };
      .
      .
      .
      #ifndef APP_NO_ITER_CONS_DTOR
      // For length n lists this dtor consumes O(1) space v. O(n) that can arise
      // from compiler generated recursive dtor code for member variable b_.
      template <class A>
      Cons__<A>::~Cons__<A>() {
        List<A> next = b_;
        b_ = List<A>();
        List<A> curr = next;
        next = List<A>();
        while (curr()) {
          if (curr()->reference_count() > 1) break;
          next = curr.tail();
          curr.tail(List<A>());
          curr = next;
          next = List<A>();
        }
      }
      #endif // APP_NO_ITER_CONS_DTOR
  

• A new class Output_Control has been added to allow for easier customization of the internal output.* code via the factory::make mechanism.
• The generation of initial #line directives has been improved; the directives now account for option '-lfp' for both multiple and single input files.
• APP_NO_SHARED has been renamed APP_NO__SHARED and added to applib_config.h.
• Fixed bugs:
  • As of app 2.1 the '--include=d' option stopped working. This bug was introduced while adding the fix code to driver.cpp needed to get around the buggy g++ iostream support. As a workaround just avoid the option and specify include directories for each include file argument directly.
• Known unfixed bugs:
  • (none)

App 2.2 [released 29 May 2000]

• Certain beta.h functions have been rewritten to avoid requiring default ctors of their type parameters. With the possible exception of List<A>::at, which now always escapes for invalid indices (the optional 'escapes' parameter has been eliminated), the changes should be transparent. The changes affect all functions that previously required default ctors, with the exception of Associative_List<A, B>::get, which remains unchanged.
• New files shared.h & _shared.h have been added to applib with classes that provide general non-intrusive reference counting capabilities. The shared.h file is an app source; _shared.h is the app generated version.
• A new core function escape_output has been added to set/get the output stream used by escape for when APP_NO_FLOW is defined; the Flow code now uses a current output stream defined by a new function Flow::output.
• The 'Extending_List' beta.h class has been augmented with new functions that give it stack/queue/deque capabilities.
• The app syntax now allows the 'explicit' C++ keyword for base types, unit types, and data type itors. The keyword applies to the associated handle class ctors that instantiate body objects.
• A new option '--stor_method=m' has been added, where m=d means use (as usual) dynamic_cast in generated runtime type selection code, and m=r means use a new alpha core function "raw_type_is" in generated code, which provides for generally faster (but perhaps less generally applicable) generated code. The default remains dynamic_cast. The option may be applied either globally via the command-line, or locally on a match statement basis via the $option syntactic construct.
• Option '--skeletons=f' is now available via the $option construct.
• The Match and Alpha_Type_Decl Local_Formatter classes have been defriended, by publically exposing relevant member variables via accessor functions, allowing for easier customization of the internal Local_Formatter classes.
• Added defines in applib_config.h to make the core allocation and deallocation functions easier to customize and more efficient via conditional inlining.
• Top__::report now has the synonym Top::report (for convenience).
• Fixed bugs:
  • A match statement embedded within the user-code part of an alpha type declaration (e.g. in the body of an inline member function) is translated to the initial output stream rather than the string stream associated with the related filled skeleton.
  • In beta.h the == and < operators for Single types contain typos that don't show up as errors unless the operators are actually used. As a workaround, if needed, edit (and re-app) the beta.h file so that "empty" replaces "no" and "not_empty" replaces "yes".
• Known unfixed bugs:
  • (none)

App 2.1 [released 26 Feb 2000]

• App now runs under g++ 2.95.2 (cygwin) and 2.91.66 (slackware 7 linux). The g++ support for iostreams is however still a little buggy, and as a result there are certain limitations: option '-ori' is ineffectual, and #line directives that point back to the generated output file are not generated (the app code specializes the filebuf and ofstream classes and that appears to be a problem with g++). Also g++ is pretty sensitive to namespace issues and refuses to compile the test.cpp app source file, so that code is stubbed out under g++ (an internal issue that doesn't impact users directly).
• The installation scripts now reapply app to beta.h prior to copying to the INCLUDE location if needed, to adjust generated #line directives in _beta.h to reflect an INCLUDE differing from the default INCLUDE.
• The native type 'float' and boxed version 'Float' have been added to beta.h as alpha base type declarations.
• Option '-o=-' ('--output=-') now means: use cout for output.
• The applib_config.h file now conditionally defines 'alpha' as APP_LIB_NS a.k.a. 'applib' (by default).
• The Top__::report function now returns the byte leak count as a result and also has a new parameter 'quiet' (default false) to tell it not to write.
• Fixed bugs:
  • In beta.h the List<A> concat(A) & extend(A) functions should be defined outline not inline (due to the forward Cons<A> itor references). This would cause compile-time errors but only when you actually tried to use them (with MS VC++; with g++ the errors are reported in any case). As a workaround, edit (and re-app) the beta.h file so that those functions are defined outline ala List<A>::length() etc.
  • In beta.h the base type declarations for Associative_List & Extending_List are missing template parameters. This would cause app warnings or compile- time errors but only when you actually tried to use them. As a workaround, edit (and re-app) the beta.h file so that:

          $base Associative_List<class A, class B>;
          $base Extending_List<class A>;
    

• Known unfixed bugs:
  • (none)

App 2.0 [released 22 Jan 2000]

• Nonpositional (a.k.a. keyword) pattern matching is now supported; a pattern of the form "x:y" is nonpositional, where x is an alpha unit or data type product-decl id and y is a positional pattern that may contain nonpositional subpatterns. A nonpositional pattern of the form "x:" is taken as shorthand for the nonpositional pattern "x:x". A nonpositional pattern of the form "..." is taken as "any other pattern not explicitly mentioned is '_' i.e. a wildcard". App internally rewrites nonpositional patterns as equivalent positional patterns. Here's an example.

      $data A = B(int c, Atom d, A e) | F();
      ...
      A a = B(0, "ok", B(0, "ok", F()));
      ...
      $match (a) {
        (B(e:B(d:g, c:, ...), ...)) => {...c...g...} // internally rewritten as:
        (B(_, _, B(c, g, _))) => {...c...g...}
        ...
      }
  

• A concept called a "safety case" has been introduced. A safety case is any pattern case that follows another pattern case in which all patterns are ids including '_' (i.e. any pattern case that follows a default case). Safety cases are useful when the efficiency implied by default cases is desired but for case coverage analysis and documentation purposes it is also desired to explicate all relevant cases. In effect they prevent default cases from short-circuiting app's analysis algorithm. Pattern cases following a default case are now treated as irrelevant at run time and are excluded from the translation. App warns you if a safety case has associated guard or statement code. Here's an example.

      $data A = B(int c, Atom d) | E(int f) | G(Atom h, int i);
      ...
      A a = B(0, "ok");
      ...
      $match (a) {
        (B(x, y)) => {...}
        (_) => {} // default case
        (E(...)) => {} // safety case
        (G(...)) => {} // safety case
      }
  

• If a default case has no associated statement code it is now excluded from the translation (default cases do not have associated guard code).
• The generation of #line directives has been improved. Directives are now generated to reset the location at the end of a nested match statement when it appears as a final balanced-item* in a balanced-item-no-comma construct. Directives are also generated to account for guard code.
• A new option '--only_read_includes' causes app to treat the argument files f1..fn-1 as implicit include files as usual but which are excluded from the generated code. By using explicit #include directives for _f1.._fn-1 in your code together with this option (assuming default _f1.._fn-1 app outputs), you can reduce the size of the generated code and also the number of redundant symbols. This is particularly effective for use with class browsers etc.
• All generated classes are now user-extensible/definable via the $user {...} construct, including itor handle classes and forward root classes.
• A static function nil() has beed added to the common handle class methods for default skeletons so that generated handle classes provide an alternate way to generate corresponding null objects via function nil().
• The restriction that outer binding patterns (ids) must be wild has been removed. Though such patterns are unusual there is no real reason to prohibit them; the restriction simplified the implementation slightly but otherwise was artificial.
• Casting declarations are now not generated for inductive patterns that have no subpatterns and no optional id in the associated pattern-decl construct, a minor optimization (also a bug fix - q.v.).
• Pretty print indentation for generated "void write(ostream& _os_)" functions now depends on option line_indent_delta instead of being fixed at 2. The generated write() functions now rely on Alpha_Control functions to handle markup formatting, providing more customization capabilities. Additionally the alpha.h write_string() function is now customizable via Alpha_Control, and the Alpha_Control interface has been extended with a few new functions.
• The applib Alpha_Control and Flow classes can now be customized at any time.
• The Copy type in alpha.h is now a class, and associated enumerals nocopy and copyok are now const variables (this should be a transparent change).
• The Str class and Atom applib alpha types can now share dynamic buffers via ownership transfer.
• Added a new applib class Pretty_Printer that customizes the Alpha_Control alpha.h core class, providing pretty printing capabilities for alpha types.
• Augmented the grammar for base type declarations so that e.g. "$base int;" is taken as equivalent to "$base int() $user {} $user {};".
• The beta.h library code has been augmented; changes are upwards-compatible:- added declarations for certain "unboxed" native types e.g. bool, char, etc.; added a new Associative_List ctor that accepts an initial state argument and also new add/addnew overloads; added a new class Extending_List for efficient repeated destructive list appends; Associative_List now appears as an alpha base type as does Extending_List; added a new alpha type Single that models singleton sets; added const function qualifiers to the first() etc. Pair and Triple access functions. Added bool Top::not_null() and char* new_string() to alpha.h, and augmented dup_string() with an optional parameter to control use of ::malloc v. new[].
• The app source has been generally improved:- the generated code for match statements is a little more optimal; a new factory class allows for easier customization at a finer (class) level of granularity; the messaging code is easier to customize (via the factory class); the symbol table code uses more explicit alpha typing together with nonpositional patterns.
• The "docin" code has been replaced by a simpler version, "docins".
• Fixed bugs:
  • If a pattern-decl construct has an optional id but there are no associated subpatterns, as for example in the pattern "Foo f()", the corresponding generated casting declaration is omitted if the declarations for the other patterns in the associated pattern case are also omitted. This would cause a compile-time error. As a workaround, the id can be omitted, eliminating the need for a (missing) casting declaration, if the corresponding subject expression is named - if not already - and that name used instead.
  • Certain generated #line directives relating to nested inductive patterns are of the form #line 0 "" and could cause confused compiler messages. As a workaround, option '-nolds' can be used if/when there is a problem.
  • If the patterns in an initial pattern case are all ids including '_', the generated conditional expression is empty and would cause a compile-time error. This situation is unlikely as such cases effectively trivialize match statements.
  • A guarded pattern case in which all patterns are ids including '_' is considered a default case, and could cause omission of generated match statement epilog code that calls the escape() alpha.h core function if matching fails. This situation is unlikely as such pattern cases make little sense.
  • If a "=> const" accessor construct appears, the return type of generated access functions is not const qualified.
  • The List<A> comparison operators >= < > <= in beta.h have typos.
  • Empty guard expressions are accepted and which cause compile-time errors, a syntactic technicality.
  • Empty inputs are not accepted, contrary to the grammar.
• Known unfixed bugs:
  • (none)

App 1.0 [released 22 Sep 1999]

• Initial release.