c++-annotations-10.6.0/build0000755000175000017500000000757212745054221014527 0ustar frankfrank#!/usr/bin/icmake -qt/tmp/cppannotations #define LOGENV "CPPANNOT" #include "INSTALL.im" #include "compilers.im" list g_log; string g_logPath = getenv(LOGENV)[1], g_logMark, // unique-marker for g_log entries g_cwd = chdir("."); // current WD, including trailing / int g_echo = ON; int g_installing; // set to 1 by install. int g_lognr; // unique-marker number counter for g_log entries #include "icmake/cuteoln" #include "icmake/backtick" #include "icmake/run" #include "icmake/mark" #include "icmake/md" #include "icmake/md5sum" #include "icmake/log" #include "icmake/logzipr" #include "icmake/logzip" #include "icmake/writelog" #include "icmake/findall" #include "icmake/loglink" #include "icmake/loginstall" #include "icmake/clean" #include "icmake/programs" #include "icmake/man" #include "icmake/docs" #include "icmake/latex" #include "icmake/pre" #include "icmake/install" #include "icmake/distclean" #include "icmake/zips" #include "icmake/examples" #include "icmake/verify" #include "icmake/github" #include "icmake/readlog" #include "icmake/remove" #include "icmake/removedir" #include "icmake/uninstall" void main(int argc, list argv, list envp) { string option; if (argv[1] == "-q") { g_echo = OFF; argv -= (list)"-q"; } echo(g_echo); option = argv[1]; if (option == "clean") clean(1); if (option == "examples") examples(); if (option == "programs") { programs(0); programs(1); exit(0); } if (option == "distclean") distclean(); if (option == "pre") pre(); if (option == "docs") docs(); if (option == "html") runhtml(); if (option == "latex") latex(); if (option == "ps") runps(); if (option == "txt") runtxt(); if (option == "verify") verify(); if (option == "zips") zips(); if (option == "man") { man(); exit(0); } if (option == "github") github(); if (option == "uninstall") uninstall(); if (option == "install") install(argv[2]); printf("Usage: build [-q] what\n" "Where\n" " [-q]: run quietly, do not show executed commands\n" "`what' is one of:\n" " clean - clean up remnants of previous compilations\n" " distclean - clean remnants of locally run ./bin/ scripts\n" "\n" " docs - construct the C++ Annotations\n" " Run 'build programs' and 'build pre' at least\n" " once before 'build docs'\n" "\n" " examples - compile all examples\n" " install [base] - install the C++ Annotations in the locations\n" " defined in the INSTALL.im file, optionally\n" " below 'base'\n" " html - force the html construction\n" " latex - force the latex construction, (cf 'verify')\n" " man - build the manual page (requires Yodl)\n" " pre - prepare files for independent `docs' call\n" " ps - create .ps/.pdf files afer 'build latex'\n" " programs - build support programs\n" " txt - force the txt construction\n" " verify - run after `build docs' to find overfull boxes\n" " or undefined references in\n" " tmp/docs/latex/cplusplus.log\n" " zips - zip archives (after doc)\n" " uninstall - remove installed files and empty directories\n" " github - prepare github's gh-pages update\n" " (internal use only)\n" "\n" ); exit(1); } c++-annotations-10.6.0/changelog0000644000175000017500000004274213005336310015342 0ustar frankfrankC++-annotations (10.6.0) * Added new section (Lvalues, rvalues and more, first/lvalues.yo) about various kinds of l/rvalues distinguished by C++. * Added new section (Standard Exceptions: to use or not to use?, exceptions/usestandard.yo) about the distinction between standard and non-standard exceptions. * Section 'Allocating arrays' (in chapter 'Classes and Memory Allocation') now describes how to initialize memory using the 'new Type[size]()' syntax. * Section 'explicit conversion operators' (in chapter 'More Operator Overloading) received an overhaul. * Changed uses of shared_ptr objects to unique_ptr objects in stl/uniqueptr.yo. -- Frank B. Brokken Sun, 30 Oct 2016 10:25:03 +0100 C++-annotations (10.5.1) * Fixed various typos and completed several cosmetic modifications -- Frank B. Brokken Sun, 24 Jul 2016 07:41:38 +0200 C++-annotations (10.5.0) * Rewrote the section about converting time to text, covering std::localtime, std::gmtime, std::put_time as well as the full table of put_time's format specifiers. * Removed the sections at the beginning of each chapter encouraging readers to send in suggestions for improvements. Instead, this encouragement is now shown at the end of the Annotation's `abstract'. * Updated the kindle-book conversion script, so that cplusplus.css is not used with the kindle book construction. * Several typos were fixed. -- Frank B. Brokken Wed, 23 Dec 2015 13:09:08 +0100 C++-annotations (10.4.1-pre) * Improved the html layout, following suggestions by Harmen Stoppels * Removed repeated 'mailus' files from chapter openings. The 'mailus' info is now shown as part of the abstract. -- Frank B. Brokken Sat, 19 Dec 2015 22:19:18 +0100 C++-annotations (10.4.0) * Added a section about reference bindings to the Overloading chapter * Added cplusplus.css which can be used to fine-tune the layout of the Annotatiions' html conversion. * Standardized the installation procedure * Fixed typos -- Frank B. Brokken Sun, 11 Dec 2015 17:12:31 +0100 C++-annotations (10.3.0) * Added new sections about expression templates, about attributes, about shared mutexes, about shared locks, about heterogeneous lookups, about sized deallocation functions, and about moving and swapping streams * Added new C++14 elements to relevant sections * Reorganized the section about lambda expression * Added the file ./compiler.im providing all #defines for compiling the support programs. See that file for specific information. * Fixed a compilation problem encountered with g++-5. * Fixed some typos. -- Frank B. Brokken Sun, 16 Aug 2015 15:21:10 +0200 C++-annotations (10.2.0) * Rewrote the sections covering the regular expression matching classes. * The section about lambda expression also covers generic lambda expressions. * The coverage of binders now concentrates on stl::bind. * Added a section about stl::placeholders to chapter 4 (Namespaces) * Removed superfluous 'return 0;' statements from main functions. * Conversion related stamp files (e.g., html-stamp) no longer used. Build-commands are now unconditionally executed. * Added a section to class templates covering a bare bones implementation of not_fn, which will likely be added in C++17. * Added some notes about C++17. * Several cosmetic improvements were made. * Html files now use html5. -- Frank B. Brokken Thu, 28 May 2015 12:06:01 +0200 C++-annotations (10.1.0) * Typos and added a section about regular expression, moving the topic from containers to stl. * Fixed various typos and inconsistencies -- Frank B. Brokken Wed, 24 Dec 2014 19:54:28 +0100 C++-annotations (10.0.0) * Added new chapter: Multi Threading, containing all previously defined sections related to multi threading. A paragraph about std::distance was added, some typos were repaired, and other cosmetic changes were made to this version. * Redefined the standard verb(...) yodl macro by a version which does not do the extra newlines before and after the verbatim section. * The build script was extended. The support script `pathbuild' is not used, but can be used in cases where an additional element to PATH must be used. * All verbatim file inclusions are now run through the new release of yodlverbinsert. -- Frank B. Brokken Thu, 30 Oct 2014 20:17:12 +0100 C++-annotations (9.9.1) * Fixed LaTex formatting problems rendering (in particular) the cplusplusus.ps/pdf files (note: cplusplusUS) less useful (cf. scythal's user review on http://sourceforge.net/projects/cppannotations/). -- Frank B. Brokken Thu, 05 Jun 2014 14:16:31 +0200 C++-annotations (9.9.0) * STL facilities for specifying absolute and relative time were rewritten and are now in a separate section, instead of using subsections of the section about Multi Threading. Sections about condition_variables were also rewritten. * c++0x has been replaced by c++11 -- Frank B. Brokken Tue, 03 Jun 2014 13:24:54 +0200 C++-annotations (9.8.2) * Extended and completed the list of available type traits (in section `Available Type Traits', chapter `Advanced Templates') -- Frank B. Brokken Fri, 07 Mar 2014 14:49:22 +0100 C++-annotations (9.8.1) * Added explanatory paragraphs about using static_casts to derived classes using shared_ptr or unique_ptr objects holding pointers to base classes (cf. the class 'unique_ptr' and Casting shared pointers) * Added explanatory paragraphs about defining (const_)iterators and (const_)reverse_iterators (cf. 21.14.2: Implementing a `reverse_iterator'). * Added an example showing how to declare a bound friend function template to a class template (cf. Templates instantiated for specific types as friends) C++-annotations (9.8.0) * Added a section about static polymorphism to the class templates chapter * Removed the `text to anything convertor' section, which is now obsoleted by existing std::string conversion functions. * Removed the C++11 labels from section headers, as the C++11 standard has been implemented by g++ 4.8.2. Note that the --std=c++11 compiler flag is still required. * Several typos were fixed -- Frank B. Brokken Sat, 18 Jan 2014 13:55:37 +0100 C++-annotations (9.7.3) * Fixed several typos. -- Frank B. Brokken Wed, 21 Aug 2013 15:00:30 +0200 C++-annotations (9.7.2) * Repaired some minor flaws, which were still waiting to be processed. * Added for internal use steps to create a Kindle version of the Annotations (see also http://www.amazon.com, look for ('c++ annotations') -- Frank B. Brokken Thu, 30 May 2013 12:45:58 +0200 C++-annotations (9.7.1) * Added changes of 9.7.0 to the Annotations' `what's new' section * Release 9.7.0 was not published as a separate release. -- Frank B. Brokken Thu, 30 May 2013 09:43:34 +0200 C++-annotations (9.7.0) * Added several new sections about time specification (stl/time, etc.) * Added new section about 'this_thread' (stl/thisthread) * Added new section about locks (stl/locks) * Added new section (classes/ambiguity) about Ambiguity Resolution. * Added new section 'system_error' (exception/systemerror) * Added new section 'the class `error category'' (exception/errorcategory) * Added new section 'the class `error code'' (exception/errorcode) * Rewrote all sections about multi-threading) * Rewrote the section about lamba expressions * Replaced references to `ascii-z string' by `null terminated byte string' (NTBS), following the C++11 standard's terminology. * Repaired flaws in function names and return tyes of several sto* functions in string/convertors.yo * `0b' constants are not mentioned in the C++11 standard (but maybe compiler supported) * In section references `C++11, 4.7' the `, 4.7' was dropped * intro/main.yo was updated -- Frank B. Brokken Wed, 29 May 2013 20:11:20 +0200 C++-annotations (9.6.0) * Updated the list of C++ keywords * Added advancedtemplates/noexcept.yo covering the noexcept keyword * Updated the string chapter -- Frank B. Brokken Thu, 10 Jan 2013 20:23:05 +0100 C++-annotations (9.5.0) * Updated (to the current C++11 state) the reference of member functions of the Abstract Containers. * Added a new section (Allocators) just before introducing the sequential containers. * Rephrased sentenses like 'this member s' to 's', in particular in the chapter on Abstract Containers. * Repaired typos, reformulated the section about nested namespaces (Meir Shani). -- Frank B. Brokken Fri, 14 Dec 2012 12:53:53 +0100 C++-annotations (9.4.0) * Added new section make_shared in the stl chapter. -- Frank B. Brokken Thu, 28 Jun 2012 20:48:47 +0200 C++-annotations (9.3.0) * Coverage of the static_cast and reinterpret_cast was refined, following a suggestion provided by Gido Schoenmacker. -- Frank B. Brokken Tue, 06 Mar 2012 20:34:11 +0100 C++-annotations (9.2.1) * Starting this release all release tags (using names that are identical to the version number, so for this release the tag is 9.2.1) are signed to allow authentication. -- Frank B. Brokken Mon, 27 Feb 2012 13:42:38 +0100 9.2.0 * Converted scanner generations from flex to flexc++ * Rewrote the Concrete chapter's section about polymorphic semantic values * Rewrote the Containers chapter's section about unrestricted unions * Removed the Concrete chapter's section about unrestricted union semantic values -- Frank B. Brokken Sun, 26 Feb 2012 17:10:55 +0100 9.1.0 * Added sections about features of C++11 now implemented in g++-4.7 * Added a script to create a beautiful C++ bound book * Repaired typos and stuff -- Frank B. Brokken Fri, 20 Jan 2012 11:50:01 +0100 9.0.2 * Removed excessive use of the verb 'will' from the Annotations. * The required operators for each of the standard interators (input, output, forward, bidirectional, random_access) are now explicitly mentioned in the paragraphs covering them. -- Frank B. Brokken Mon, 12 Sep 2011 16:01:07 +0200 9.0.1 * Repaired some new annoying typos and slightly rephrased some paragraphs of the `Koenig lookup' section. -- Frank B. Brokken Wed, 20 Jul 2011 12:21:33 +0200 9.0.0 * The form of move special members (move constructors, move assignment operators, other functions defining rvalue type parameters) was synchronized with the form proposed by the C++0x standard. This resulted, in the Annotations relaxing the principle of const-correctness, and in modifying the declarations and implementations of move special members in this release. This shift in position (adopted by the Annotations since its very early releases) profoundly affects much of the Annotation's contents, and warrants an upgrade to the next major release. See the remarks in the `what's new' file for more details. * Several sections were added and sometimes moved. The section about 'unrestricted unions' was completed and moved to the `Containers' chapter, and an new section about adding binary operators to classes using function templates was added to the Annotations' final chapter (concrete examples). * Repaired badly formatted LaTeX table of contents: see bin/latexonly * Many typos were repaired 8.3.1 * Many typos, textual corrections and clarifications were processed, almost all were provided by Francesco Poli. * Sections about move operations were split into subsections * The Portuguese translations are lagging too much behind. I've removed them from the source archives, although they remain available at the svn repository. -- Frank B. Brokken Mon, 20 Dec 2010 15:25:30 +0100 8.3.0 * New sections about various (member) function adaptors * Sections about statistical sampling functions added/modified * Sections referring to C++0x elements now assume g++ 4.4 is available and the required compiler version is no longer listed for those sections * Typos repaired -- Frank B. Brokken Tue, 07 Sep 2010 12:12:18 +0200 8.2.0 * Bumped up the version. Should have been done earlier, considering that the 'what's new' file already refers to version 8.2.0. * Added 'export' to the list of keywords * New typos and unclear passages were processed/improved * KNOWN ISSUE WITH THE PDF VERSION: Due to a known bug in the ps2pdf conversion the pdf versions of the Annotations may show multiple Error: Illegal entry in bfrange block in ToUnicode CMap error messages. Once the bug has been repaired a new sub-minor release of the Annotations will be made available. -- Frank B. Brokken Thu, 26 Aug 2010 09:03:37 +0200 8.1.2 * New typos and unclear passages were processed/improved -- Frank B. Brokken Thu, 06 May 2010 19:39:46 +0200 8.1.1 * Many typos and minor cosmetic flaws that had escaped the previous update were processed -- Frank B. Brokken Thu, 11 Mar 2010 21:00:43 +0100 8.1.0 * The text and examples of the Annotations have completely been overhauled. Before this final 8.1.0 release two pre-releases were issued, partially completing the overhaul (see the two entries below) Over the years many inconsistencies had crept into the text and examples, that are now removed; streamlining the text and the examples. All of the code examples have received a work-over, removing endl in favor of '\n', making virtual functions private, etc., etc. Many sections labeled C++0x were improved and sections in the table of contents showing C++0x now also mention the g++ version in which the new feature will be made available, using `?' if this is as yet unknown. No version is shown if the feature is already available in g++ 4.3 (or in one of its subreleases, like 4.3.3). I received a host of suggestions from Francesco Poli (thanks, Francesco (and several others), for all the effort you've put into sending me those corrections). -- Frank B. Brokken Mon, 01 Mar 2010 09:11:21 +0100 8.1.0~pre2 * Cleanup completed until (including) chapter 16 -- Frank B. Brokken Thu, 24 Dec 2009 11:36:44 +0100 8.1.0~pre1 * Removed the 'template concepts' section from advancedtemplates: removed from the C++0x standard. * Started a cleanup operation on the C++ Annotations aiming at improving its internal consistency in examples and text. In this version completed until (including) chapter 8. -- Frank B. Brokken Thu, 05 Nov 2009 21:08:10 +0100 8.0.1 - Added --std=c++0x to the g++ compiler options 8.0.0 - New sections added describing elements of the new C++0x standard New chapters: name spaces, generic algorithm. The Portuguese translation of the Annotations (in the contributions directory) are still at version 7.0.0., Sergio Bacchi wrote that a new version is currently under construction. 7.3.1 - Readers are referred to sourceforge for the C++ Annotations archives 7.2.2 - Textual modifications and minor modifications of the programs due to new Bobcat library. 7.0.1 - Processed extensive feedback received from Eric S. Raymond and Edward Welbourne. Reorganized yo/string/members.yo. See the yo/history.yo file for details. 7.0.0 - Added new chapter (advanced template applications) and changed many other things. See the yo/history.yo file for details. 6.5.0 - Changed all unsigned types to size_t (where appropriate) Added the Portuguese translation to the distribution, since Sergio Bacchi's acceptance was received Repaired various minor problems in compiling/running examples Moved in-class definitions of member functions to below their class Added paragraphs about size_t and other derived int-types and about implementing pure virtual member functions 6.4.1 - Legal restriction leftover removed from Chapter 2's introduction. Portuguese translation and `The history of C' removed from the distribution, until formal permission to include them is received from their authors. Changes down to 6.2.4: see yo/history.yo -- Frank B. Brokken Tue, 19 Sep 2006 13:03:29 +0200 6.2.4f - fixed basic-type counting in par. 3.3 -- Frank B. Brokken Thu, 07 Sep 2006 14:04:27 +0200 6.2.4 - See yo/history.yo 6.2.2 - See yo/history.yo 6.2.0 - See yo/history.yo 6.1.3(-pre) Repaired several textual imperfections and delete -> delete [] where new [] was used. 6.1.2. This file was defined to summarize intermediate modifications. - description of ios condition flags refined - description of string::getline() refined. - open_mode `creat' changed into `trunc' (reading and writing streams) 6.1.1b Minor textual modifications since 6.1.0 c++-annotations-10.6.0/compilers.im0000644000175000017500000000206712745054221016020 0ustar frankfrank// This file was added shortly before the Gnu C and C++ release 5 of the // compilers became available. A new version of the compilers can simply be // tested by specifying the new compilers' version at CVERSION // // To check the software using the 5-version of the bobcat library that // library can be made available in a separate directory (e.g., // ISN // /usr/lib/bobcat-5) and an /etc/ld.so.conf.d/bobcat-5.conf file can be // ISN // prepared specifying /usr/lib/bobcat-5. That directory should then have the // ISN // libbobcat-5.so* library and links, and after `ldconfig -v' the linker will // ISN // detect the proper library. #define CVERSION "" //#define CVERSION "-5" // the used compilers #define GPP "g++" ${CVERSION} #define GCC "gcc" ${CVERSION} // options to be used by the compilers #define COPT "-Wall -O2 -fdiagnostics-color=never -g" #define CPPOPT "--std=c++14 -Wall -O2 -fdiagnostics-color=never -g" // extra library for the C++ programs #define BOBCAT "bobcat" //#define LPATH "/lib" #define LPATH "/tmp/bobcat" c++-annotations-10.6.0/contrib/0000755000175000017500000000000012745054221015127 5ustar frankfrankc++-annotations-10.6.0/contrib/concrete/0000755000175000017500000000000012745054221016731 5ustar frankfrankc++-annotations-10.6.0/contrib/concrete/refcountautoptr.h0000644000175000017500000001172312745054221022352 0ustar frankfrank#ifndef INCLUDED_REFCOUNTAUTOPTR_H_ #define INCLUDED_REFCOUNTAUTOPTR_H_ #include // Implementation of auto_ptr using reference counting. // This implementation was provided and offered for inclusion in the // C++ Annotations by Jesse van den Kieboom (jesse at icecrew.nl). template class auto_ptr { class auto_ptr_data { Type *d_ptr; size_t d_refcount; public: typedef Type element_type; auto_ptr_data(element_type *ptr = 0); ~auto_ptr_data(); element_type *get() const; // Refcounting size_t refcount() const; auto_ptr_data *ref(); bool unref(); element_type *release(); private: auto_ptr_data(auto_ptr_data const &other); // NI void destroy(); }; auto_ptr_data *d_data; public: /// The pointed-to type. typedef Type element_type; explicit auto_ptr(element_type *ptr = 0); auto_ptr(auto_ptr const &other); ~auto_ptr(); // Assignment operator auto_ptr &operator=(auto_ptr &other); // Dereference operators element_type &operator*() const; element_type *operator->() const; // Get and release element_type *get() const; element_type *release(); void reset(element_type *ptr = 0); private: void destroy(); }; /// auto_ptr_data template auto_ptr::auto_ptr_data::auto_ptr_data(element_type *ptr) : d_ptr(ptr), d_refcount(!ptr ? 0 : 1) { } template auto_ptr::auto_ptr_data::~auto_ptr_data() { // Destroy our pointer if (d_refcount) destroy(); } template inline size_t auto_ptr::auto_ptr_data::refcount() const { return d_refcount; } template inline Type *auto_ptr::auto_ptr_data::get() const { return d_ptr; } template Type *auto_ptr::auto_ptr_data::release() { // This function releases the pointer so it's no longer // maintained by this object. if (!d_refcount) return 0; --d_refcount; Type *tmp = d_ptr; d_ptr = 0; return tmp; } // Refcounting template typename auto_ptr::auto_ptr_data *auto_ptr::auto_ptr_data::ref() { if (d_ptr) ++d_refcount; return this; } template bool auto_ptr::auto_ptr_data::unref() { if (!d_refcount) return false; --d_refcount; if (!d_refcount) destroy(); return d_refcount != 0; } template void auto_ptr::auto_ptr_data::destroy() { delete d_ptr; d_ptr = 0; } /// auto_ptr template inline auto_ptr::auto_ptr(element_type *ptr) { d_data = new auto_ptr_data(ptr); } template inline auto_ptr::auto_ptr(auto_ptr const &other) : d_data(other.d_data->ref()) {} template inline auto_ptr::~auto_ptr() { destroy(); } template auto_ptr &auto_ptr::operator=(auto_ptr &other) { if (&other != this) { destroy(); d_data = other.d_data->ref(); } return *this; } template inline Type &auto_ptr::operator*() const { return *d_data->get(); } template inline Type *auto_ptr::operator->() const { return d_data->get(); } template inline Type *auto_ptr::get() const { return d_data->get(); } // Warning: when releasing a refcounting auto pointer the data // itself is released and no longer maintained by any of the // auto pointers. All these auto pointers will now return 0. // It's your responsibility to handle this properly (and to // free the released pointer of course) template Type *auto_ptr::release() { Type *ptr = d_data->release(); return ptr; } template void auto_ptr::reset(Type *ptr) { // Prevent creating a wild pointer by resetting if (ptr == d_data->get()) return; // Unref current data destroy(); // Set new data d_data = new auto_ptr_data(ptr); } template void auto_ptr::destroy() { if (!d_data->unref()) delete d_data; } #endif c++-annotations-10.6.0/contrib/classtemplates/0000755000175000017500000000000012745054221020153 5ustar frankfrankc++-annotations-10.6.0/contrib/classtemplates/cloneable.h0000644000175000017500000001022012745054221022243 0ustar frankfrank/* Cloneable template class protects a derived object from slicing when used with stl containers Author: Jesse van den Kieboom Jesse provides the following example based on his class template Cloneable: vector > vec; vec.push_back(B()); vec.push_back(B()); Cloneable a = B(); a->(functie op A/B) Cloneable b = B(); a = b; */ #ifndef __CLONEABLE_H__ #define __CLONEABLE_H__ namespace jessevdk { template class Cloneable { Base *d_base; public: /* Default constructor */ Cloneable(); template Cloneable(Cloneable const &other); /* Specialisation needed to override default copy constructor */ Cloneable(Cloneable const &other); template Cloneable(Other const &other); /* Deconstructor */ virtual ~Cloneable(); /* Public functions */ template Cloneable &operator=(Cloneable const &other); /* Specialisation needed to override default assignment operator */ Cloneable &operator=(Cloneable const &other); template Cloneable &operator=(Other const &other); /* Operators */ Base &operator*(); Base const &operator*() const; Base *operator->(); Base const *operator->() const; operator Base&(); private: /* Private functions */ void destroy(); template Cloneable &assign(Other const &other); }; /* Constructors */ template inline Cloneable::Cloneable() { d_base = new Base(); } template template inline Cloneable::Cloneable(Other const &other) { /* Clone other */ d_base = other.clone(); } template inline Cloneable::Cloneable(Cloneable const &other) { /* Clone other from cloneable */ d_base = other->clone(); } template template inline Cloneable::Cloneable(Cloneable const &other) { /* Clone other from cloneable */ d_base = other->clone(); } /* Destructor */ template inline Cloneable::~Cloneable() { destroy(); } template template Cloneable& Cloneable::assign(Other const &other) { /* Assign other to this cloneable with self-destroy check */ if (d_base != &other) { destroy(); d_base = other.clone(); } return *this; } template Cloneable& Cloneable::operator=(Cloneable const &other) { return assign(*other); } template template Cloneable& Cloneable::operator=(Cloneable const &other) { return assign(*other); } template template Cloneable& Cloneable::operator=(Other const &other) { return assign(other); } template inline void Cloneable::destroy() { delete d_base; } /* Operators */ template inline Base &Cloneable::operator*() { return *d_base; } template inline Base *Cloneable::operator->() { return d_base; } template inline Base const &Cloneable::operator*() const { return *d_base; } template inline Base const *Cloneable::operator->() const { return d_base; } template inline Cloneable::operator Base&() { return *d_base; } } #endif /* __CLONEABLE_H__ */ c++-annotations-10.6.0/contributions/0000755000175000017500000000000012745054221016371 5ustar frankfrankc++-annotations-10.6.0/contributions/FAQ0000644000175000017500000000217012745054221016723 0ustar frankfrank1. Too many consts? -------------------------------------------------------------------------- 1. Too many consts? > int compareWrapper(void const *p1, void const *p2) > { > return > Person::compare > ( > static_cast(p1), > static_cast(p2) > ); > } > Isn't it const *const * one const * too much? To answer your question: well, you could omit one const, but it blurrs the intention. Person::compare's prototype is int Person::compare(Person const *const *p1, Person const *const *p2); which mentions two consts: the parameters are pointers to pointers should not be modified nor should be modified what these latter pointers point to. Hence two consts in the static cast. The last const matches the const in void const *, and the first const matches the intention of Person::compare's function. Leave out the last const and the compiler complains, leave out the first const and the compiler will pass a non-const pointer to a const * parameter, which by itself is OK, but blurrs your intention. c++-annotations-10.6.0/contributions/porter.scobey0000644000175000017500000001174012745054221021115 0ustar frankfrankFrom porter.scobey@SMU.CA Sun Sep 17 16:54:15 2006 Received: from smtp1.rug.nl (smtp1.rug.nl [129.125.50.11]) by suffix.rc.rug.nl (8.13.7/8.13.7/Debian-2) with SMTP id k8HEsFqe020630 for ; Sun, 17 Sep 2006 16:54:15 +0200 Received: from smtp1.rug.nl ([129.125.50.11]) by smtp1.rug.nl (SMSSMTP 4.1.0.19) with SMTP id M2006091716540904671 for ; Sun, 17 Sep 2006 16:54:09 +0200 Received: from mail3.rug.nl (mail3.rug.nl [129.125.50.14]) by smtp1.rug.nl (8.12.11.20060308/8.12.11) with ESMTP id k8HEs7ba029629 for ; Sun, 17 Sep 2006 16:54:07 +0200 (MEST) Resent-Message-Id: <200609171454.k8HEs7ba029629@smtp1.rug.nl> Received: from by mail3.rug.nl (CommuniGate Pro RULES 4.3.9) with RULES id 26722890; Sun, 17 Sep 2006 16:54:07 +0200 X-Autogenerated: Mirror Resent-From: Resent-Date: Sun, 17 Sep 2006 16:54:07 +0200 Received: from smtp1.rug.nl ([129.125.50.11] verified) by mail3.rug.nl (CommuniGate Pro SMTP 4.3.9) with SMTP id 26722881 for f.b.brokken@rug.nl; Sun, 17 Sep 2006 16:54:07 +0200 Received: from smtp1.rug.nl ([129.125.50.11]) by smtp1.rug.nl (SMSSMTP 4.1.0.19) with SMTP id M2006091716540704669 for ; Sun, 17 Sep 2006 16:54:07 +0200 Received: from HUSKY0.SMU.CA (Husky0.smu.ca [140.184.1.100]) by smtp1.rug.nl (8.12.11.20060308/8.12.11) with ESMTP id k8HEs5Hr029615 for ; Sun, 17 Sep 2006 16:54:05 +0200 (MEST) Received: from [140.184.170.51] ("port 1263"@[140.184.170.51]) by HUSKY1.SMU.CA (PMDF V6.2-X25 #30841) with ESMTP id <01M7AU3VD1VW8ZFLAU@HUSKY1.SMU.CA> for f.b.brokken@rug.nl; Sun, 17 Sep 2006 11:54:04 -0300 Date: Sun, 17 Sep 2006 11:54:04 -0300 From: Porter Scobey Subject: Re: java_cpp_keywords.html In-reply-to: <20060916171615.GA16340@rc.rug.nl> To: f.b.brokken@rug.nl Cc: George Danchev , Tony Mancill Message-id: <450D618C.7070206@smu.ca> MIME-version: 1.0 Content-type: text/plain; format=flowed; charset=ISO-8859-1 Content-transfer-encoding: 7bit User-Agent: Thunderbird 1.5.0.7 (Windows/20060909) References: <20060916171615.GA16340@rc.rug.nl> X-Spam-Flag: NO X-Scanned-By: milter-spamc/1.4.366 (smtp1.rug.nl [129.125.50.11]); Sun, 17 Sep 2006 16:54:09 +0200 X-Scanned-By: milter-spamc/1.4.366 (smtp1.rug.nl [129.125.50.11]); Sun, 17 Sep 2006 16:54:07 +0200 X-Spam-Status: NO, hits=-4.80 required=4.00 X-Spam-Report: Spam detection software on "smtp1.rug.nl". Questions: postmaster@rug.nl Content analysis details: (-4.8 points, 4.0 required) FS_GAPPY_2=0.241,USER_IN_WHITELIST=-5 ____ Status: RO X-Status: A Content-Length: 2373 Lines: 65 Hello Frank, Thanks for your e-mail. Please accept this reply as permission to perform the two actions you mention below. To be more specific, you have permission to use my file at http://cs.stmarys.ca/~porter/csc/465/notes/java_cpp_keywords.html for inclusion in your site at ftp://ftp.rug.nl/contrib/frank/documents/annotations and also in your Annotations package to be offered to Debian. Furthermore, you may use this file with or without acknowledging its origin, you may modify it in any way that you deem necessary or convenient for your purposes, and you may pass along this permission to subsequent users if required. Best regards, Porter Scobey +--------------------------------------------------------------+ | Porter Scobey | McNally North 104 | | Associate Professor | (902)420-5790 (voice) | | Mathematics and Computing Science | (902)420-5035 (fax) | | Saint Mary's University | porter.scobey@smu.ca | | Halifax, NS, Canada B3H 3C3 | http://cs.smu.ca/~porter | +--------------------------------------------------------------+ Frank B. Brokken wrote: > Dear Mr. Scoby, > > I am the author of an Internet-published document called the `C++ > Annotations', which have been around for about a decade (currently: > http://www.icce.rug.nl/documents/). People who want to have a copy of their > own may download the document in various formats from > ftp://ftp.rug.nl/contrib/frank/documents/annotations. > > When they do visit that ftp site, they also find a copy of a page I downloaded > from your website: > http://cs.stmarys.ca/~porter/csc/465/notes/java_cpp_keywords.html > containing a list if C++ and Java keywords. > > However, I'm in the process of offering the Annotations to the Debian-Linux > distribution, and by doing so I think I should obtain your permission to > include your html file in the package that's currently being built for Debian > > In order to avoid embarrassment caused by improper handling of publication > rights, I'd like your permission to: > > - Keep java_cpp_keywords.html on > ftp://ftp.rug.nl/contrib/frank/documents/annotations > - Include the file in my C++ Annotations package as offered to Debian. > > Thanks in advance for your reaction to my request, > > Kind regards, > > [Cc: George Danchev, Tony Mancill] > > c++-annotations-10.6.0/contributions/GGD.algorithm0000644000175000017500000000314612745054221020706 0ustar frankfrankFrom d.j.heijs@wing.rug.nl Tue Jan 30 02:10:13 2001 Received: from oosix.icce.rug.nl (root@oosix.icce.rug.nl [129.125.14.80]) by suffix.icce.rug.nl (8.9.3/8.9.3/Debian 8.9.3-21) with ESMTP id CAA11404 for ; Tue, 30 Jan 2001 02:10:13 +0100 Received: from dep.cpedu.rug.nl (dep.cpedu.rug.nl [129.125.28.200]) by oosix.icce.rug.nl (8.9.3/8.9.3/Debian 8.9.3-21) with ESMTP id CAA25169 for ; Tue, 30 Jan 2001 02:10:15 +0100 Received: from skylos (client44-109.kabelA.oprit.rug.nl [129.125.44.109]) by dep.cpedu.rug.nl (8.9.3/8.9.3/Debian 8.9.3-21) with SMTP id CAA31441 for ; Tue, 30 Jan 2001 02:10:13 +0100 X-Authentication-Warning: dep.cpedu.rug.nl: Host client44-109.kabelA.oprit.rug.nl [129.125.44.109] claimed to be skylos Message-ID: <000701c08a59$d376baf0$0201a8c0@skylos> From: "Dirk-Jan Heijs" To: Subject: Gave ggd functie Date: Tue, 30 Jan 2001 02:13:16 +0100 MIME-Version: 1.0 Content-Type: text/plain; charset="iso-8859-1" Content-Transfer-Encoding: 7bit X-Priority: 3 X-MSMail-Priority: Normal X-Mailer: Microsoft Outlook Express 5.50.4133.2400 X-MimeOLE: Produced By Microsoft MimeOLE V5.50.4133.2400 Status: ROr Hoi Frank, gisteren hoorde ik van een vriend een mooie functie om de grootste gemene deler van twee getallen uit te rekenen (het grootste getal waardoor beide getallen deelbaar zijn). Hier is hij: // Copyright by Gerton Lunter int ggd(int a, int b) { while(a ^= b ^= a ^= b %= a); return(b); } // Copyright by Gerton Lunter Gaaf he? (Heb je er nog leuk commentaar op?) Groetjes, Dirk-Jan c++-annotations-10.6.0/contributions/README.makebook0000644000175000017500000000262212745054221021042 0ustar frankfrankThe following recipe was provided by Jurjen Bokma (j dot bokma at rug dot nl) for creating a neatly bound C++ Annotations book. He gave me one as a 2011 X-mas present, and I think it's a great gift. Thanks, Jurjen! The recipe then, is: - gunzip makebook.sh.gz - Call the script like this: ./makebook.sh --t7 -p2 cplusplus.pdf (t7 is for 7-sheet signatures, see below, and p2 is to prepend two empty pages, which you may or may not like/do) - Have the output, cplusplus_book.pdf, printed. For normal-size output, you need A3 paper. I use 60-gram paper, so I can keep all in one book. Print double-sided, short-edge-bind. - Separate the printout into bundles of 7 sheets. Don't mess up the order. - Fold every bundle neatly in half. - Take these folded signatures to a book binder, e.g. http://www.boekbinderijerends.nl and wait a few weeks, or try to DIY. Background: A bound book is made up of signatures, stacks of a small number n (e.g. 7) of sheets double the size of the book's page, folded in half. Each of these signatures gets sewn into the book casing. So the A4 PDF being processed must be reshuffled so that the pages are printed on A3 paper, in signatures of n sheets formed by 4*n original pages. That is what the script does. This results in an A4 sized book. If you need other sizes, adapt accordingly. c++-annotations-10.6.0/contributions/makebook.sh.gz0000644000175000017500000000502312745054221021134 0ustar frankfrankbNmakebook.shYmWK#ȨII=FXA&f 1ߧ{r,ѡ^jq cZC1Q IDO4ȡ)t,\/Bw9x+zҡߩ`44q"ě@D z%~{rb2b]C'loOJV37jNX "M;#!}C0rC5t=,a|xQP]ah\/[g[FZ6eO[I'ѽV O1^ϸ5S9Ijω?1]8" zm"QL\FJt~EجW塻^8o[!1svx0qP^p#$ClA濧nK;LCw30ߢ!\)Y.477Bxa, #tcCbI'>\/ =})hN8f? ay@׉͛z0^yAI^ݑ8KMꛎo~6zrǻAnɶҟp(.Wy kPq^J/d辂QH6*H'$cvߖ_; Y=lt-;oto=> 'P&Su2D|ع́C;2Ǚ -[L1rQOX<%R )WYQ8B|uب](LW;ê}Qvyơ$n}عE^7k0J,ƅ[`I@j_avR`+SLrEJSB2xo8LI~< Jz3Y9JI87dhA"4KcTbK,1x vDm.ezbH\9gniOG=(r$$2&g,˂@"$ݤD%{&x<="ȝW1R XI+O!&df.mY`841j%[K L% |{U.4đnWށK폱1~X1 s-v[;!5&4藃5+bAN {+Zmo ~q}fByYٻfjjĹ% DrhB)C6A`XPك(6Zd{'<8m2Өl= *ӫ9Jl]4VOokd'z%ov< ȪZkp蝞Q?P?9 PԍdÆ Nі禌h2P VI'$ddzg7i[,įy&72gӚՃ4]F[ئ2n~dRc.o|zt‘>68cjKtpTH_B2"b쉲N].w#ܒ F$j۲+3CZ䶚yYW \R=ʨt9lY<_|m%`X4t3SH&ޱMn}Rn?}G+LRBAAEc++-annotations-10.6.0/contributions/sator.proton0000644000175000017500000000242012745054221020762 0ustar frankfrankSubject: Thanks for the great book Date: Tue, 19 Feb 2013 03:26:06 +0900 Hi Frank, First I want to thank you for the excellent work you've put on the C++ Annotations (v9.6.0) book. I read it to refresh my knowledge on C++, and I can really feel it's a great book, especially for someone who wants to get a deeper knowledge on C++. I'd also like to tell you that I have converted the HTML files into MOBI book. I did it so I can read the book on my Kindle apps, and I should tell you that the conversion works without much difficulty, with the result looks really great on Kindle. I don't know if you've tried the conversion yourself, but as a token of my appreciation for your kindness to share the great book, I'd like to share the OPF file I had used to create the MOBI version. If you find the idea for MOBI conversion is good, please feel free to use (and reuse) the file. (It's just an XML file containing the metadata for the book, which you can inspect and edit for yourself.) To create the MOBI book, you just have to put it on the same directory as all the HTML files, and feed the OPF file to KindleGen tool (which is freely available from Amazon). Also, if you wish I could provide you with the MOBI file. Thank you, and please keep up the good work. Best regards, Sator Proton c++-annotations-10.6.0/contributions/java_cpp_keywords.html0000644000175000017500000001514212745054221022774 0ustar frankfrank Java Keywords and C++ Keywords

SAINT MARY'S UNIVERSITY
Department of Mathematics and Computing Science

Language Reference Material

Java Keywords and C++ Keywords

This page contains a table of both Java and C++ keywords, showing which are common to both languages and which appear in one language but not the other. Within each column of the table, the keywords are listed in alphabetical order.

C++ only Common Java only
    abstract
and    
and_eq    
asm    
    assert
auto    
bitand    
bitor    
    boolean
bool    
  break  
    byte
  case  
  catch  
  char  
  class  
compl    
  const  
const_cast    
  continue  
  default  
delete    
  do  
  double  
dynamic_cast    
  else  
enum    
explicit    
    extends
extern    
  false  
    final
    finally
  float  
  for  
friend    
  goto  
  if  
    implements
    import
inline    
    instanceof
  int  
    interface
  long  
mutable    
namespace    
    native
  new  
not    
not_eq    
    null
operator    
or    
or_eq    
    package
  private  
  protected  
  public  
register    
reinterpret_cast    
  return  
  short  
signed    
sizeof    
  static  
static_cast    
    strictfp
struct    
    super
  switch  
    synchronized
template    
  this  
  throw  
    throws
    transient
  true  
  try  
typedef    
typeid    
typename    
union    
unsigned    
using    
virtual    
  void  
  volatile  
wchar_t    
  while  
xor    
xor_eq    
Total = 40 Total = 33 Total = 19
c++-annotations-10.6.0/COPYING0000644000175000017500000004310312745054221014523 0ustar frankfrank GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. c++-annotations-10.6.0/html/0000755000175000017500000000000012745054221014433 5ustar frankfrankc++-annotations-10.6.0/html/annotations.gif0000644000175000017500000000772212745054221017467 0ustar frankfrankGIF89a{!!!"""###%%%&&&+++,,,...///000222333444666777888999:::;;;<<<===>>>???@@@AAABBBCCCDDDEEEFFFHHHJJJKKKLLLMMMNNNPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~!,{ H*\ȰÇ#JHŋ3jȱǏ CIɓ(S\ɲ˗0cʜI͛8sɳϟ@ JѣH*]ʴӧPJJիXjʵׯ`ÊKٳhӪ]˶۷pʝKݻx˷߿ LÈ+^̸ǐ#KL˘3k̹ϠCM4 0uװW D-چ70`뚨wnta ޼ҪW)7{;O{Jۧaj襷<_X_$GAב)T%R@ʇqY'P aF68Ryف!pQj*}IH^wwA֢{8{>zDy":U^Baw(xߒ P.H%Z@&"w[rvdw##a,k"AevإF@}hXJDbl$e xIt~*HZ鐕\jRjQ[ @vP&kB:+scrwl PD+5,M6dS.(Ftd,W™gum0&nok:s { Vnݾl [k [”}iqE݆t*رV^iGino-S¼u/e(wʳ/ [* a]/ۜ,kgsI]of~lQ mD*#VN ʦr,puW=7Bo8H_ߋ#wrq=A x؄=.ox%]Ћ&f`:7"XЉ;oW `$f 7'﫳gNvɶϦc۹o ߽ zdsL(M2 u ۥH>n{;UAX(|` U ЅTaȷFoēİ` L|h<񲇺p*7h uR<*+7ɰP,JmWטYj=_qw͆7v虲~4| Hl8KͿ!Dp,d)ga[ M?S;(Or;^^ 8EA~Бe4R.K8H*:#2=vp{~J$MhNlڞ٠MjЖ, IR'jO,Tjqq#+w*dzE'wK`>vD!{uTh0kZO|3+eBF4P(?;bzxӎP*Y'~O MsǢ:?i‡Sa si`s7V:YS_J˛@%a9sQyqxy.e$XRj1U"aeՏye,ETL*ZzP!V!=_qBW12{E>)ao$py􏬘U"&8p{[j5 [UvU+ s /pli J["CϾ߁W!&`!gv 0ŵ5tʢNn!e {16a`ΡA/ (uL0m-j+c8^#ԫmIU.єHI2 GA.(gT'M8"Iaٓ?S*L ii4 -YI^"Xq&(פgl}5Gd?C sfчFt!E@[Д뜺;WS Pz'mOj4iy[Mkl#w^MbNf;{WM%g5d`}{#l\ ,LFp+lQI"nmoIIДfY&̑ISF 94,o3im"ȴWsۗW)*Eŕub=؀/zKj.e!3ǙrT"} <<Ȕsz9Dr>sA77[r{5VC^4uIG}76MUu"wvAEkZJ ڣ{nodKzqPX=4kxmE6'^C~]DTh,mŔ+^j.ĆGtn5+Hՙ0ہjr4x:=}ޟB{uNWNoҪ-=zaЃs|Ko]ZAWfOtvp#V&9tA҅qOv"eCa9BV31򀖳*,FGe#uG>!A5Ve4]q+u"x[er2%2XAZ҂WWyf;Xa:DhBHbesK!D pr|dd.S@ȢZK1##`M:tp"Le5G*kV_#WvR;TPXbu;V'@X>E_(2%S4O #ug'Yh(_Å?qeX}'toз$W2u(H*hHC$U1B|؇H6[X'sHi38M1xx3߲?hhBu̱qݸ`U҉Bu옍*$w`JP:X#"0؏(Y*$S5[v(YIqhIfu#y Y5x?-.ᆊYQhűLAXFOwF9.&F(H[4H T&6oOҋu~AޔSӓSPgIA'ZL9/5E^c68lQHScUb\#_^]a%zٗ{qQ!;]wg-"X}G|[[ZOl[{I^5~G#b!*^s8x!J"4mFR^㛩Yb֜{#uhaVSffQhiFyx8ĞI9Mh1RG'G 6GwrH-X]7r rV:X**ڢ.02:4Z6z8:<ڣ>@B:DZFzHJLڤNPR:T;c++-annotations-10.6.0/html/first/0000755000175000017500000000000012745054221015562 5ustar frankfrankc++-annotations-10.6.0/html/first/datahiding.gif0000644000175000017500000001621712745054221020354 0ustar frankfrankGIF89ay """222333777888;;;@@@DDDPPPUUUXXXfffqqqwww!!4 Image generated by GPL Ghostscript (device=pnmraw) ,ydihlp,tmxypH,Ȥrl:ШtJZX7PxxL.zn|N-y?|{С׃~ ,h(0> f-0{z.> J ̛o2vR &AD!(VuqK? yR@:  a`f}+ƨ4XҟB5q0OAX}klwa=& r5&w23H~k`YLȀӠBI {pPu}笕:w@ y !mDxZa \0 o]ŗ"ˡZLrG-X7^z0l@f8O lGf`>4@6O= `=hAuUgA77uyAA|,@ bфuDE68@۩yTK] R~00319E ه|G OhJ=V9GUMOu#-Pm܃AC ]drCgO6D%T[ ik&J"ncmΩAIgUiL IG2EKfɇO'* z&h_e |!!R~ n0e$55 )g maQ0AlH#P tT"ⷬF+ 6EQ PHË7R 9# !TFOFZ$uIZ$&7IB (QQP$*Wʜ\e)cIKIβ.q]"sE/I `;S`B <<ێF5ͦn+dUlm(@" ND('jx10Cp)u窱!&-1,P{2Ph* p,^ oP co!MjM(m욨"דW˗@62E&sEjʝ*H\`@z6ёzX"B$mjUQ;(ґ%[]'6Z~*8 *@>Fu'0T/3^8Ɠ)'KX(: eRPDo滺%HhZ bNp͞(elKۆ= eq?9$4C09->S6s3?ϸ̃=C?k$0:'V7ω.uo=]vv4 gmiOaɂTH1>zOƿ! (,Ȑ|((oyEb~Ub:#A=O/x9_=#z[^v7}14}k'o|J> GC>m|Gڿ4,-0~2߉\L~#b] 7_I p B*LzW rCXUQ @p*?6 # R1#*SR+UZ$!?R"QA">_Mz'DaC**\)+b֢]ޡC!%XKQ(|( 3XZ,a*jItU <,3/CE"5v/x|G 3(_h}PSR >33?*RpmKo}'}UXO#g!21p?.OVW0Tsc֔׈(٢b<2A* =mR+O0K|~H]Ȍ^;+bA2$?p2H,6X40:Q$Gv"aTdG!GD>!8l2{FdW"|q &yڔВ.p'@594w8 :@BI7YwI D9F H7PV)t=IS(NٕaɒcId/akzJ} z* Z=MJkJъNe L/ͺ~I:*+ݺ*Z% Ji)PJ*y[-0Z 1 $xU+LjJfԕ@` .l4%NfGqG0cOu$=.Հd;[+PIVU),#0uXj4g\00##EXѓf+ fkz0uCp@1(Bl!eΊʘXX%!1w]1X<"-ɻ\ -yO~y" Y]zIV`dk kڱvf D:B[Kl̻, zkBx UƂWX|j|5_uCEXo l ߂M fMu"ݳUk!",o ;-. -"'L;YB/2VE;>!|utSadwk@x OTE[_} ޫ3K^]`̼uaS^*]&xw4X02] e0M NFl^BFV Q!CvU=,ߒP Vᄐg-=⌎2c.FX'rT[#' A`D]q857f 9elO'pK'ݨQ=8"~_>D%*)-N@Q>0]K6 ȶW!XZ{>D5Lv$`!cj3|\^kk8'C'!Pz>j2M6 U'!JQaI5\\&VSZn-Jx. ] %^|w+jn WŪ׶-jS.:Js z fߴx вrE;9_$TՐ*oӜOբ?Y֨?M x pO{+9v?Vm o " qgИSt" A"TƐn+ "DuF0a8rߘ. 0 l4EP`(i5n\5Hڨ 5r Gj5phL"uțXmrz1*XR@̘FFD CMZKC\ @΢Meأ DW@P1rr@pž€I֍p%RC!7Lo^ //J)@F>vFbIuoC.Ao x A#Ae+Bzi$!g.,R^,a-Rׄ#;ԑiذ`=( *\-ɖ5H*PKepw ,U <6ZVAYA="ҡ.m$Bo_=^DA{6( 0"ՁmW7tV/Yڷ7w tYWءY!164X8OJ{l'aQ{C5Gg 8x X d+܇mj٠t6ap_cρYMiqu|fYl :\34rI"c"r߃Y2biI(HyW̜@m fD$*̵e`y#C׋gTx*狀4KyY ,?JL 9xpVAcaTlmj JZZi*ފ@PT*q"=ڐARjLy Ëai"8)N:.Gñ܊*! D'Rfe _ʭ*!&.薪g@WhҦw-bndOAWbbz7c宱0>nI.ЕfEDt} "|9S7!v`Bf@ZXoTҀ6ASbYz#ذrM Sv_@^STc$]*<%y-'tN|&u({|8`P D9=.FA Dtqu$=cؗwKt&?B.[a<'܌f3(: !Y8 % <&12XX i::O|`wB. XX1,pO@֌VeE 18xdXOp,BX@ڐ!X)O 2>#'C/!1X,r^"K1cܢӨ5Nl|#s Mv D<D)Ak!E2̠##)IR򐐬$&3M$(CHO<+*|%,c)YҲ%.s]򲗾%0)aR:&2e2|&4)iRּ&6MhZ%&8)q<':өu|'<)yҳ'B;c++-annotations-10.6.0/html/advancedtemplates/0000755000175000017500000000000012745054221020117 5ustar frankfrankc++-annotations-10.6.0/html/advancedtemplates/multibase.gif0000644000175000017500000001461112745054221022576 0ustar frankfrankGIF89aJ          #$%&')*,,0"""+).;()>++333:7=K::DDDHEMR@DWGLYIIYLL]LRUUUWS\gXXfffealtdmto{wwwp{ww}!K,K $1' Ÿܭ1J;ᚦH H ?*b\#JXnK jȱG/9!œ(SBHRRƏ0cʜ/d˛ ɳgEz8I6*ӧӧY.]4ի3N:)ԯ`Iz*ֳh j%˖װpÎm;lڻxݻmܿNݵ|G Jt 5eh+̈!0C~m #Wk@Q͜5Gs(yQsr6I֡E!H]h _ FHLCD55&܁T 6Ip9!0!&Br!":QXzB|A !}9PF0Ce$?3Y!p0 9%btJ@BEȰa$C B#ăϽ CGÕCZ0QS&O*9(0 PiD"(p>JAoܗyj J ɖ؀"B PD+ i #9GT{-9G (WE|6&>"h) 1"@e&Ppk>{O35(pj3#9bh-OBRW%]*3KFsD=qnl)>g 3 jF̰jj;dz0?5rYΊ2ۼ@'(C.9I|;}9(#Rsno-0 +<XMj mb>x}WE4,Aȡ> uq(+袧QgAyt6O"/GG`%#PuR#6`Hgxa7* "8C@ HGMx`bɠp\90!Y:)9E0@i;ާ:đ(U _H.MD S$j7(pG⁜WQD{(,xH+`@p}G0_dn $UI//…a`CbcfE&6Yej~:ݧ49Yt&N~ꅞa%>}ބL( Ж4CߩЊj C!N'F3zr4(ECR 1IR|)L!әNY)N=i\jZRuF=*S05'N}jK*`$`jLՐr*X"քܴi9+ZmAյ<%+\*׹'؁`KMb:1*z@Zͬf7z h3;¯M)" "E´P܆p ;W9r{2w}tk6"ͮp]C`5w;nzޝrwm|Iwk}{WpGݯ'<gT0Ak^D ^WJ,b`tqUoK!DNRt$+8aT *,-\sBe3'Ԍ6g#a 2_CtsgՅpZz.ġTTmeCOZnc7N{ӐŴ[A@ ԨNWVհg jO S`uϜk]ם5+*D밑 _/;v  -վ6fnw$Klk>nwT- e6ݓtۃƦo'^Ex1D;8QӜ\aGw4,s *;/pł(d! Qn'647Pϲ*z~U4MjbSt9N(8cx EAt}R'%.G~%R{I@R<9d61%VR7ɔD<&| h/%wCy7d44yT2AGAgsBAr2F]J=@wC2Px8o*H6SR$9)5*374C7`1wH5yLJg ѕ2F)ne8y>ʴ,O97yX!9tՙib?ኳWYb՛@yIl !@y)f̉ɩPyؙaY E嶝iv4Vy)A 7Ja0  * -P 9pVZVj֡ fkbhPP&E Ƣ6Z.fg9fx v֣[;&%Jif9mJZbNQ 6QfTZ[$꩸ 7 PFz[BYuJZ8\(z%G,@ڬ:Zz8YƺvFيĞ*:Rjܪ\pz\ZڜzV[ٯ Eg߉!ư>Ffݚzl oYuq(p#4#'Z*+1! |(|4w!U"=g"?p,rY% D`Ftftf&mBuru=}y(3."+rI/L/I)u@!|ӘD!|WRBJ{gȗ"0wp,wu-w-]xtuSvv?Pz2+?vQ*7DDa0`X<:)@)FF)t)y=2/ysz2ziFcU,ׁ609hT|6AԈ$]`GXA岄I "d%T,[XLcB:ྚǸ2R ÈĽKŠR?w?rIH_VܔѬ@0E%æ%aGsiԉ(C˅$|Gq0N1:  ;(hIc;t)i͕\D+[[`0ɲ#"@Gp0S ,Vp.UCaI3GLJwI1#,lD+Ь 2w@r|~yYUU Ջ!LEs0Am/}=Ʊ&AC;RُpBR}Tm Ma<(1۴ ڵL`m=ý S]]$܇ ]W{I %v5TaڷݰyZ] >+=`V >^ Jl]H, ZEe~ Zթ&'N`)^cd0N^/N\2^|z%:~^9NA! F_\45:jP7T> W^V.Z>`Y aaJ_^N6攰h>aj^\gr>v>ey~nG|/FPN~a^_Fa9>d-^` 0ꤞW~p.š5na :욵~e>b=$N/bٮT^}hޮ^x1h~﬽Nt?/6eތ Xz&з+)01*ѷ[L0 "){KJ22P?j`QK7;vH5ȻO <@#FHV)<") 9/17+ayԋԃ )/ D{o&ݼ{ċ;7=ț[ܻ{\=;m>˻?k?O~ H`\`ԁP`:7N^߁n!gbbyvHb,}b؍hb.n26#@c>dBIdFdJ"N>0RNIeV^eZne^~ &PIf7afj&eiW ;c++-annotations-10.6.0/html/inheritance/0000755000175000017500000000000012745054221016724 5ustar frankfrankc++-annotations-10.6.0/html/inheritance/hierarchy.gif0000644000175000017500000000274412745054221021400 0ustar frankfrankGIF89a,!,,ڋ޼H扦ʶ L ĢL*̦ JԪjܮ N tiXW&hxxHHv)9IYiyYy8 *:zI:iz:K %[y;L %Lj||m-m\MuK͍n->\~. $M?\o M `% zR9<%…I! CV4䪍x48aJ1%T,]{Iag͞4b~?4ΤLkjS&ԒDNĪSdiFWHf GlȸsZd+0&(ďqD<˜j6r3&ʟiRΨgVtkWa=m s[Q[V(sroSR\YO9.=w 2$k%0gtRG:Ҭ\^뜲͵to9ig"%[%U-%Nڽ$H]$>-da>)9I.Ynix~6o7s^7w˞7;-{n'p"zΕy7/Gw8=W! ]=w7~tϗ+~5Og??./Ǣ<}`S 8(9 `8X9!H9SX9aD$̀!XC42׷d EA$ư-Jʢ)R ĸ$j7|șE& jĈ=ِd_YҸE9"^% 0tp GWt"O.` s,1d*sl3 hJsԬ5lj;c++-annotations-10.6.0/html/containers/0000755000175000017500000000000012745054221016600 5ustar frankfrankc++-annotations-10.6.0/html/containers/stack/0000755000175000017500000000000012745054221017705 5ustar frankfrankc++-annotations-10.6.0/html/containers/stack/stack.gif0000644000175000017500000000360212745054221021502 0ustar frankfrankGIF89a!,ڋ޼H扦ʶ L ĢL*̦ JԪjܮ N ((#pPhv8Hhx8UX9F p$jzzJʃ:j*;KAi+ `z kpL, `-<( Aa̼ j, ->^+`L1:|݊Or9)ug ؎b*W+#Fs&@%IbxQ?_~r|0^G=Yle \ޣb,3y[F?1]^h"o?Rť.A* v!}z ȝ [e^ERCBXÅ݆ $Ma}8b(nhbV+Yƌ4r2=r;?BdFdJ.dN> eRNIeV^eZne^~ fbIfffjfn grIgvމgzg~XJhh.h> iNJiRgni~ jJjjj kJkފkk lK-xñA栬"4pH12#_2'۟2+2/cnzW`W8 id@ڎC`!@ hA ~PaJЁaOA z l0>ǻT 9x-Th$ :\x'AP*/I{+ybHE1KhL=5:kz(u~$xY1t"YIRrYK$呓sd&C)UJ[%*E$W,_F^rd ^:/0-PKMD&dǔ&xgQLc7^~ L(sfsl; xs=|s? Ѐ t-AЄ*t 9 шJtE/ь*G? Ґt$-IOҔt,mK_ Әt4MoӜRo|bF' Q} ژ6$%hpۙ_!NuT*U6SjX{U. jjVQHP:EU<,VW_[ X9˛,1cY&J.5,g,^Y9-j kZ= ㍫h+Zp6mc\obSlR{BDs:]PCYi=eSUb5N w}w x.U;c++-annotations-10.6.0/html/containers/queue.gif0000644000175000017500000000227712745054221020423 0ustar frankfrankGIF89adర!,dڋ޼H扦ʶ L ĢL*̦ JԪjܮ N6Z&8p)9IYiy Gfx *:JzJ&P (J8[u;L\ %l< },M]d ]-~l~?J^?.kO/@z (0>@0:Cč(n" J<2J4r|yeK4k)͝+G N $y-94燢Gy&3]O65ZUǫN}N3#םYf`:g`ۺ*mZpK.nW݃S]ׯbO;8$^yReˏocHnHf>JɁU#d&N9& Bv4vǵDe2F3nrx9'WЇSa2 ~j%7+s{^}utbtr֜|卧ށՆE؞ X'o}Z~:깗b6آ ᝉGjv0"=*c"A"2);x$zhcQx"|Ȣ0RQ!/)bݔTHpjA~YOW&g&G|'@祜 F(MQ| *z!#a1ɡ݀XA}2ziｸ7&BaE]dVA.ܮck&~KjAκ-.m~kʴn+{m㒻Vޢ[|r^U,-[뮿  /spoS.UodRY1slp&1ʵr<-L 133ͩ|s89 =tCKsA 0I;tMMuVuACu)zaw5ٿdwPMurMwv wzw~ xNxx/x?yWzPAڎG 9 K@|+ʆ U^9}7;z"rm+~Vʾ%/z;3>:*_ȻGZ'jٟs>,b=b̓>>Oߏ p,P;c++-annotations-10.6.0/html/containers/list.gif0000644000175000017500000000234312745054221020244 0ustar frankfrankGIF89ad!,dڋ޼H扦ʶ L ĢL*̦ JԪjܮ N xgxH8PXxi@biH Y:* k'Zikz{J+kLG[{ڻj{) -y͖Lk,m|9-]-/_o~N<}~Bڵ}Zh0=|+@q01xcڨ̙,!IW7T"'eU1g/{@ CJ4E)ԀSNC*VYZ:+b)k{lۺEKܹSѽ+PZ 8 > ;~LXƐ+[.,U/{ @3ʠK7ɴję7/%:vdeFխ]6mU JylЋKLuսv٫2wN1H?[|$dNtU_;X91Y.D 5a(5aV_Db'~ȅT 8[H`+:#f0 !=hcx<IdLF҇d`/vM&V$qSRW-jyWy]*d2if*[ry&iBS։#xӛx~y %mJ)z'm2Y ~6i}yj{JJPj{x+Κе(x+h$Y.Aì|Yz# &l7E+ Ύϰ(v^~rֺn^r oO׵ܦ+yj;Z:2n"mu 0(;>oX7S/… 5b1B~ܒջpG )%'8cdHA21;5/i24=e0jcBkT9I:\XtkbÔK,Zk m.M]c:Wn8+1Z>xiČo0ɔ+[9͔R9љ=g%:沦JV ;vcF={ݢYClp͹?nȑV0.)ǟCWj}usE>{=k6O/[tI MZq`",^7.M4)=ءQXᅉ8bca↉ACƘ EciiՎ78v42D^ơCS/:$fFyJVYm%QVOx%feYfޙ8iqY̞|Ι~'m?h5#`rh6 ()mVץqv4s*d2:j2lbjJa z(k"*hklVp.,uuNlR-JޒYfn[nfe&iW6r/[WL%'DzC< 0C;k[LB a<*:KRƋs,[op׾lk0Jq7ϜtMxNM)A0[GFRf?ʲuSݬ07 V wL9TŽd枧(mi7s%G}E그NMNy]REM8S.O¹O»Wq:dS:0eckp~)9osƈ'pL+ȼt1[ |NQ "'- !Cw|C/Ph`I\ g0\b0Ҁb, h40T'h[;]yc=820~BV"񑸈dHHI@1d%4H v,k'%/Xe\JT^r %$jYYv)]D/pb""V`2"LdF@f3IA8LQ-@l6L9-sʤ29)pi'SGLy24> Oӟd(<jL*u'C-Z{^T}(D:e8hIz҅fԣ}ȶ R3hMIjN4PpR :@{"U7hAjCp0L]RU2QC ԪfUL<ʼ4VeX*VW=ב浩 \6%:Whho-lcۉj0,cŊY9O0(,l ) Ѧv5<˒umk3ֱ-Mm{[=ַmX %q*}nsVN7-weR]ml;X=j5@w5ooTwe}ޅok\B7*܃QgX (9awPp&51)`a [5.po8uo>.,6+N0#Or"+ky\ 0yd.<_x{C3HAHFͲ)c*ġL~{œPh+y WH) S4F>TDeH/gnt{i΄61JSV@h0ֲnE]>?ƈ Yd+{n hK{Ԯlk{ p{.ύt{nP;c++-annotations-10.6.0/html/containers/dellist.gif0000644000175000017500000000324312745054221020731 0ustar frankfrankGIF89ad!,dڋ޼H扦ʶ L ĢL*cfXJԪɈFA(lMvn|6Fe892g'Ɇ؉a():eəyʧw%I9JZx K֘KyZFz|-=M]m}{8,= [Y:]l̴NN n~oTf tBAc4x% qQFyhlQGh TXYHZ+մ#<}b!8SK+;SDPr97sG0MI#SRmZHV"[*l@za-ֵgsWOqN Ů^fx{ >8 (pW'Ŝ;{>͟KFYKvMe٘an՘ξ'im_'_銋#xiyɏ'B1ۿg$~vWyݤ|w|n`Sn)' 8!f5ŃE`,ԇԁF"H$H(!J4gcB;3[7.E-ҶUAdQFj$ 3H%S_iZZ]alFzf^xϩsrNDߟY%z≦xJY |rJZy(RȑfJi)X2zfV(JκVk~ꞦZ觔J,w:,vzP>[jNlRKڂm[Ƶz*D[z{+*K.Rl.Eo{K/&*x pʪfƨv\1_&2$hX#b%}+zÉRb8+@2)c#]E4QtÂJEJ,\7IN,J V MɿX / ` s,1d*sl3 hJ,ww7rDBՉS=,Qpa*6OM4=ASt,0Ç/ATdCO[tt"7@ȥ!딅'Qɍ$>/BJ4JYRc~,S)F@A)iL'F^C"&~O ըJuTUլju\W ְudA;c++-annotations-10.6.0/html/pointermembers/0000755000175000017500000000000012745054221017466 5ustar frankfrankc++-annotations-10.6.0/html/pointermembers/fig/0000755000175000017500000000000012745054221020233 5ustar frankfrankc++-annotations-10.6.0/html/pointermembers/fig/personfig.gif0000644000175000017500000000314112745054221022715 0ustar frankfrankGIF89aT!,Tڋ޼H扦ʶ Ls ĢL*̟ JT)=q\ zT7{ĵH3PhHph#@iai))y yFfJ6zX깪նP * *pKQ\{lG} ,mKWD nP-qn.*u_-ʛ0~w:iB/!fI`GopbQd ,eDM9#̔!#RK1e^O3I:4gĜ_teGT+S95+4ϯ`O%+*Y.,˶(TqY[7V׫yӚW][k?α^;Rf/ipe*\OGk͔E7ϪU8 ;GٴiwHkn7'ڕz̗e籯'HZ``|t{_swj"-X`~Uuy}qtagX*r%"@̉zഁngnDǢd ?ܰhBZdK>OvDDSBJW]jZ} fUff=iffm~曧StyHvI%gcAJbPr9*9i FzTjfզVj%v483Gx䪫k,l!4,1rʩbfj3, Z]׷fKnaje[n`鮺8%,ὔVmfлP{/'\3OR8Llb *)gbh!^/Lr ?c/#yLBϫRRg[+Vw۔X{FώQl[&wY,co{zMڂ8זag\yR=7yՕyڟzc5U:^*-~4ZI[ZcgwDزϻ]<׼s{ǷhA2)^ RϽ.g}# t 2J}觩zj*_ƿi^&yNC\Pvd( R0< 'yf$ 9/ǁq*X¬u3Cp<O$bK.KT"D'T,jXD(N1dlbx1qhd8qt kx7!>͈h/PSd?DFң?F d JP2$ =yGPђdI..`bYJWeoF\R̥/w^s,fHcRdf-KhS(eHB0@e9 SlD1IDTg:yFR^<'Nt6Sg49MVӝ$h? OTg>N38000111222333555888;;;<<<===???:BNAAABBBFFFKKKLLLMMMNNNFO]GP^PPPRRRSSSVVVYYYZZZ\\\]]]___MWgR\m]j|bbbdddeeeiiikkkmmmrrrtttzzz{{{iwo~p~uʘˣٯ!! ICCRGBG1012 mntrRGB XYZ acspAPPL, desc|cprtx(wtptbkptrXYZgXYZbXYZrTRC gTRC bTRC desc"Artifex Software sRGB ICC Profile"Artifex Software sRGB ICC ProfiletextCopyright Artifex Software 2011XYZ QXYZ XYZ o8XYZ bXYZ $curv #(-27;@EJOTY^chmrw| %+28>ELRY`gnu| &/8AKT]gqz !-8COZfr~ -;HUcq~ +:IXgw'7HYj{+=Oat 2FZn  % : O d y  ' = T j " 9 Q i  * C \ u & @ Z t .Id %A^z &Ca~1Om&Ed#Cc'Ij4Vx&IlAe@e Ek*Qw;c*R{Gp@j>i  A l !!H!u!!!"'"U"""# #8#f###$$M$|$$% %8%h%%%&'&W&&&''I'z''( (?(q(())8)k))**5*h**++6+i++,,9,n,,- -A-v--..L.../$/Z///050l0011J1112*2c223 3F3334+4e4455M555676r667$7`7788P8899B999:6:t::;-;k;;<' >`>>?!?a??@#@d@@A)AjAAB0BrBBC:C}CDDGDDEEUEEF"FgFFG5G{GHHKHHIIcIIJ7J}JK KSKKL*LrLMMJMMN%NnNOOIOOP'PqPQQPQQR1R|RSS_SSTBTTU(UuUVV\VVWDWWX/X}XYYiYZZVZZ[E[[\5\\]']x]^^l^__a_``W``aOaabIbbcCccd@dde=eef=ffg=ggh?hhiCiijHjjkOkklWlmm`mnnknooxop+ppq:qqrKrss]sttptu(uuv>vvwVwxxnxy*yyzFz{{c{|!||}A}~~b~#G k͂0WGrׇ;iΉ3dʋ0cʍ1fΏ6n֑?zM _ɖ4 uL$h՛BdҞ@iءG&vVǥ8nRĩ7u\ЭD-u`ֲK³8%yhYѹJº;.! zpg_XQKFAǿ=ȼ:ɹ8ʷ6˶5̵5͵6ζ7ϸ9к<Ѿ?DINU\dlvۀ܊ݖޢ)߯6DScs 2F[p(@Xr4Pm8Ww)Km, '! H*\ȰÇ#JHŋ ȱǏ CIɓ(S\0cʜI͛8s"ϟ@ JѣH*]ʴӠDtJJիX'|ʵׯ`Ê5ٳhӪ]Kpطpʝk,ۻxݫ-ݿ FjÈ;p +L坐3kTϠC_@3ӨS?,0I.X"Q4nIYNxF!{FX@LG'k׋Oyz6-nү=_"x\q`WT߂xB޵T#nhgsƇxh#p!ԈT!QXcO-<H'hD$J4f`FD:#4X_?R9HA\{[ǡO6H"fwFA"H8Tn'Pİ <#TP!hB,Zꪥe1Đ#F[ҺE%z[nON o|9+BvZ4e7KYd6[[pF?CB%ʈ6c+A.p&$GslYܾOJ "6,bd#*F̺tzlU6R(~=PѭfR&!{́a z(BcSC?͡T0kL\cz3Qs12\! >*6fAD#8w6ܸ%797dܓ~Gs֚^*XeŰLZ[8՟"TgS gp5kOJVgx-ꘐӤk*: וp!3-\h >&vXJa 2&+2 dz?6]bC5z}RՓ^iNe 'W" ҽ MVɔ!.'<5FհgMZָεw$zdhLqraj'0p8|v R$bZn{w}]=AhCqh1ubm`{V5A-~&7n"oLcr8'N[ |Y8E S|fuW_\ƥh;+a@.+yηȉHO:_똻zHLUX'~<~+`5aCR9G{zE}춆)v9r+Ww{g9kw:\)LvϼOƣk)uO9?kKq7߭Ͻw{D?@̮|BOn#Ͼet?ïmo=x4(uO7ǹ7@WWq`({ j(sG%.׀jt؁gⷁ`~xVd!(z}(4w,(2)+XzdȃF؃@y$hGFKMVP>8|x`H^Yw}#ŁaN4dX}UpH1l؆GxAsHAkՁ7Xxi{ȇLk'vPx؉_`pXՁ^P8Xx؋h6}kw(ʸ،؋x8DRxؘڸ؍A긎؎˜1{x?Cf9ȏ>h^I ِh W y8 !S 1h"I႒I>*ɒ4.I@1i3Y<7A9 RJHvv?yXVyXZ\ٕ[9??p(Q7p(7_Jɐw  ;h7aJP?Ўdy^p)(ȗh8mIؘx j^# ahJm _`J0(P9mp^mR wp#pmYI? 9ipwy^p@~ q0MH#Н7)qYYv 8 RpxY٘_`)9  QR0`Дɡ ٢0ږ ٖ_0%zjp ڡ!#mwY7^ 0X.]@@B;D[F{HIʰxjTkW:Z)Ęz$8Oۓ+ocKf}}P2*nbpWgɒ}+g 'H_[!kw͘rV۸s*w`u|{=v;+5Id{w[:/ t iЋȋDH׼qcb۱Pqثxë CZ!rKݛN94;A7Wː뷇 (F;l Lq% }gkj"\1x(̉k,™XǿWPlk(=< A C^9D1\.km2ڑJ||[Gꬑ''UyW\E\m>4 A_ n+w}w*d imkPDpsļFĶylV({ku !yw<\ȹF Ȏlqa;AɕL~} ˑɳɤlQʦkīʯ쀗pm>p&ɶ|̯g||˱mܑ܁i<\,͕6iY̴,z/L|Ϊ\7jh\~7C5 [<}<<7W8EnK}jQLq<*HEԤzCPwh0qZ-.HEե1Zf`-ovnMŔ@SJEEgSGu}'FMI=nLT4p@vT-o<ًqΣ,tEqGerNˢئ=uq֨]t=ImӨе|P*+@|BDtR m' ݒ-U-1}^]SޔM61߉,im߯b ?\5i. n;hǫlAm=V5խ&:-WE}*ܧ  *nR0NhH׎Z->s3O饾><ݾw츭W0-ln>ߧ>n?'.~~s8;n L6^V<]JX֋^.mA/Wo <(>De">f' ^r~1\?JC}T,7bQ(@h|c>fr=>bAoX|>/ć(jt>@?a(ښt~[^/ˢLޟ>,`?_ȑˣ2~&-.@'lsӐ > j{O+'چ}jYDqf   $ DPB @Æ)^Ę"Í vB%MDRJ-MN`L5m RN=5JSЊEbЃG>%ySԔvPŚueΧ]ZȡCXe͖( =ruG\9ޭKݼ{E!r޸sаV~%|侎n"]og@a`g|ldǫ]@TgJ*WR9\pŋ:ǀȍ;7]tsrBP"k`]xѷP1g-~"рKA[~w7 ;c9dp:D:CA /.6D1E[@320E0mdp /  xDRJ>РHK2^2KbKjD @ҾC>C 240rP4$ACV2PAKCz<C1>mPN>,,@J(O R4UUU*PW J@0U: )Zw=nKOu<@WI/~@ֶV_=4bMG4׆vZTkSqBfzZ/GsWKjZ ̵ͪXPw^}<ӣ4T[okJB"7Kلmjaň3ҵ2eh2erc:&KRC )c%m)&( %L9(׎hdVUe{Vbbސ%[Q⹐/. %{B&rP7`DC [R7Ӯe&Zj}̦ETk߿ 濒P{&]!fBL OL e8õς [F(wC/!v3 g% f;(/n q #xhЋ_ q<( xk?ܠy  g&;s^" HB |RHF0hX"m4DKy+YXi6Det|\Fb/3Y&⃡ʒIa0hʛ5384f6,'.'gLol&1qS! 8#>zANiMlSk'i;dϟ-t#/Bat%=iJWҗtK|hE9njR4fԧFIj-.Y=kZךk3[drֿv_{ɛlG-z'H@vmnwwŽ]_ѽnv(~r=F[KwLg߈ CD/+ O\gpC<wAqRq}+Q"B}OxOODg:8tFYr}|vqtG])zn{dz:]ϝw|9W{G9_.xF;c++-annotations-10.6.0/html/threading/time.gif0000644000175000017500000004461712745054221020041 0ustar frankfrankGIF89aL                  "#$&!()+,-.036 ""))*+ 0033 #$""&&(())++ &!'=!0033%%%!&,#(/-????15>>@#D%B+U.A0W0_4%@4f8m;p=DDQQUUWWBBAAddffww@@%29C3:D8?JBBDDQQTTUU:AM:BN;COv@wAddffwwDM[FO]GP^ZZZooOKTcMWgR\mOo`]j|^j}dglkkkHJNPSW]fhoxwboftiwm{uʘˣٯ!! ICCRGBG1012 mntrRGB XYZ acspAPPL, desc|cprtx(wtptbkptrXYZgXYZbXYZrTRC gTRC bTRC desc"Artifex Software sRGB ICC Profile"Artifex Software sRGB ICC ProfiletextCopyright Artifex Software 2011XYZ QXYZ XYZ o8XYZ bXYZ $curv #(-27;@EJOTY^chmrw| %+28>ELRY`gnu| &/8AKT]gqz !-8COZfr~ -;HUcq~ +:IXgw'7HYj{+=Oat 2FZn  % : O d y  ' = T j " 9 Q i  * C \ u & @ Z t .Id %A^z &Ca~1Om&Ed#Cc'Ij4Vx&IlAe@e Ek*Qw;c*R{Gp@j>i  A l !!H!u!!!"'"U"""# #8#f###$$M$|$$% %8%h%%%&'&W&&&''I'z''( (?(q(())8)k))**5*h**++6+i++,,9,n,,- -A-v--..L.../$/Z///050l0011J1112*2c223 3F3334+4e4455M555676r667$7`7788P8899B999:6:t::;-;k;;<' >`>>?!?a??@#@d@@A)AjAAB0BrBBC:C}CDDGDDEEUEEF"FgFFG5G{GHHKHHIIcIIJ7J}JK KSKKL*LrLMMJMMN%NnNOOIOOP'PqPQQPQQR1R|RSS_SSTBTTU(UuUVV\VVWDWWX/X}XYYiYZZVZZ[E[[\5\\]']x]^^l^__a_``W``aOaabIbbcCccd@dde=eef=ffg=ggh?hhiCiijHjjkOkklWlmm`mnnknooxop+ppq:qqrKrss]sttptu(uuv>vvwVwxxnxy*yyzFz{{c{|!||}A}~~b~#G k͂0WGrׇ;iΉ3dʋ0cʍ1fΏ6n֑?zM _ɖ4 uL$h՛BdҞ@iءG&vVǥ8nRĩ7u\ЭD-u`ֲK³8%yhYѹJº;.! zpg_XQKFAǿ=ȼ:ɹ8ʷ6˶5̵5͵6ζ7ϸ9к<Ѿ?DINU\dlvۀ܊ݖޢ)߯6DScs 2F[p(@Xr4Pm8Ww)Km,L$H*\ȰÇ#JH13jȱǏ CIRŒ(S\$˗0cʜIM.o2'ϟ@ JϢH&<ӧP"d*MVjU$֮`G~ Kٮc=Kv-۷pݻwڕ+-߿nAz ~xǐ&>\q䦖/kwi̜MV<`կ];duk+5aԷ ڴo y^ʽ)cuNmqnsѵ>~5z\=ɶ/ ۷LJ}-gP)'|Xo٧~=Hax] j(h-ء g2 [mᇒ5)})2]D\16dw(?.TVȢP¸u>F2ԥliZdD~d~En${栄VarQ}♨I#azpqȦv駜R訃#ng@6y&iA .: vt^G. 2%kb׮vņQx]ݹO #2>kX^2n֫bG+]un+D|iOt ,qyeº.~@<9lqJf.H‚2"9na wK"*k/,3sQH T ,"0G"H"N{ܳC_mhͷ+OZ,F Zu-T]kزV-2Tѻ|3eͷ~/[ 6,Lm6ڎxA~ûPn9ι w"}(_Y3Bz""U;˹Vo:E| }$-W?hO W(TEP?O/>H K2 L:'HpQTN4F GH(L WAKppfl^e(eB_G<@ "2\h ;Ȋ#<HEjbH1^*Ҟd%y2`$H:R1gFO! 2ᐈL"F:򑐌$ 1*z<| DL*WV򕰌)` KƱNpҤب&O&(ƽbȜ[-[xKH YlHfBOȦ6nn 8Ea&L!Zs&wDb;KL2j- 7-[l}ᆰ ;.1gqD,}nagYLp3F`{ qwB֙*:FRs[)]aN'vqp}sNu7A= ̔7dUԯВ$vdLC8!mޥwyXà j 0۽3I@ \ X@a|ܓ?yC9FI NLuORܨT|Ŷ ^ŋˎil˽Ɣ{[ٻj!Fl+NLP|S\Ź쨿˶`ŞP1,,J|eyY׌<\Ƽܨ=۬ uZχ*IAM{ٗܢ LKŵ`mШ|YP&ȌOq |юIHa<xϱ [ |H PlQk A`|OSxNB>]@pM_g {ד pj פD~rt׈}z ׃m=]ؐˉٙhB ÀB!8HWhٹwؚ}۵\8 ʡ؈ `\z:{K쯶=6i@-|ڍ ϫMKjԝ!$ ipߒp͈I`Y ϪJ .GۣKjZP+7  i${+jJX;  ڮ );z͈}ar;..Hh8N K2NJG- 7 :7s0z>ȳh+M͏w~|Z?x+TjAyRꌃn0XXˆ4k/9ZG;tnz GnɚžKZ ){ľIH>+^>_ }8Nxe̻g厀ɴ \Џ_t벋/{$lپ}ػAn8\}k^ dx!>vu A.݇`(~y 0༜+m D/`HV߾ V_O0s;.:_=O?X;8̊딅v X8i#dU^ŚUV]~%e͞EVYkݾ딋̙XxҕI+IDxXW&ֽ+@}b!LpPfΝ=w.qĥEZjcMmlj5I{7FYl?4.:{Na>0rKæ5Oݿ_|w*Y/ی -Hč  B4,a0?<3;CWdE_1FgMqd?wG1H!?s%2I@PD%*ѴJF+2qH/KӖXL3DL/94tM8%N9O=:?aPCE4QEeQGpӪJ-/4St-P4% TSOE0 .HT,\-UQI5VRg"V)5XWU`VPӵYg$ZkKmJ,eRH4Oq9Eeu]#h7xݥ^/AmF87 ss4UxaxV '.+6RTPXK8 ]u1-_嘛~W8FRHʑrfZ_#hCMzj6; cRF.XQ> YES@>(VE>;KY$ STqFR9@Fu:#OexMr|sY\UR>PgKWtOE9=TV%]vEX uS>>zs:_r+>{Os]WqtSyν;K)c&_|[4'@YsD4ѯ~bwEp,]&8St ˠ:΃t7=d\`.ז,7\@Qgk^La>Qn D Rn`JI ‰ItQb'7z1Y CQh bdll@,Pc*x:OEc3pnؘqtdN E*vd:y#$(olD%u "Xc3%Pujmk%RxC!=YM$=el=f4=cSвٔgFӛ&5khFnӜfiʺMvb*#yNz>%([g;yw3g=yOsQ? 4ԡhDy/FԢ(*P3(BE" @iJUR hiLeSlG)V1l?jP:TըGEjR b jT:UڂjjVU!48ͩ9kլ]ySVE-Uգb=k^WQml`1P jWzSfS+_%;Y^ lf֨v REC'؉qfd)Z֤-T7aZRE FKmjY;ܽ^a ڂ mx\1Qz"fuX`Pńj`CxPmJچַd„K\ո:o-j]@gmRz\ q`[ ^2&ů9UwqE^+/tjG}Uz x _}eys~z "4'^ /yσIj'|7χ~];O?>2ܧ!RycO|_V[K~ӯ~py=<1+>{+?칼 {)@\*âd@s@? ??< {B=B<ܣ@MPsC. P{j0x.7|5BBr{c87L1[/ 0  0HĄA̼ 0Q$R4SDTTUdVtW4E{(*5{1j>LxZ0+K4%#r'aftFcѻ"Ŭ#3'8ۄ 3F6E[gDt\edwxyz{{kT@)E25,4=8+;Gutȇ̌ht{GE*OhPHPF@AL0[X4r4d̼ȖtɈHm;[ȨF_ TS5V4O3P7 0Y[HcɗtJIDG)*`aCd|ʯtƨA*hJmJt$ d4K½ _IpK~KKHH_X_LL>=TcTG}T4TJeTKD:Q9OT MM5STUۿN5bpURXãJm՗K,0ͿtFd]^/T)L=$)V`lj.$U ֯m%HTF ;EJX@޼w0NDMxE bPi-V ŋ|͉P,X_w}ΚcmuV LBeB[`uM $6 חN4O[8Nb0O݄nY P0汳cdNPe6 LRNh XS XD6C~0bPc.֪F,L 54/3v.gcn_gD*Afo=[fUZ Zp\)w6xyg`K2CD4$ӯ۪*PCC0./jIIj?DήHNWNZݘ}[]0 [ij:KUkNh->(TjVB7C^jJl*H^lZpc 1!Hb5 akIxeaآT_Ӗm̖  cK$nk~DV^>313%1ql*+;eTv#m-ޭ-O ݋@5mW:OhYznHj̖-A,ajߪo6Pmrk739ӲS m>S. `W_c pE߻`S>`  `spfۢF1 j3 Z6%03?0/g7HA4DO?w@A݌М-OY'M 9ZEO0Y Rqֈx= ZRgVh6Dd#VC'wJ'خ]O[O"ܽ 5a!my vfG7?JK[$qgJr%O4m0齆[rez!M(絖s{rCVammdyJ"Xu伞NpHaO} i!z`cy_ nԵo:dyx]$! ] Y= $](}|pw??? RW / -!^=!MX!]!SmXbba#L'˜a x#9#=##Zd1$Ey$I*$YFSZĔTθI\Yy&i&m&n1& yyu' :(z(x((Zz)Fzʗ:*B j)W:kʡZ {(Ϊ>,7M:,k.[-0K ɭPy* x"."AAmrxa)"!㖋*f :?1n ӧp[~9[0 ݍ#'ߋ\7?M3,7ԏ5+rT昇{﵄Jis9'ޤKx̃zzʞ/a05V$ $79Lb!%m -7%kޮ?_^g,QBPQ=-``*<DZr>)t]0i0h^~76Plb}'T:h_:,QuESBS)>~KfBh.UKP@ID8a x 'ګO\1 r'j4uBB;|fۄ!zGmd(x9гFCK!!Zw,(H bI`c& CĤ&#  hR $&Tn2!$JxWKXf#(el4!<3BAh,Љ6X@+D! ?aǬ&@ ĐTaL$#_@ @r9(1j N Cʔb(,"lIXsڢ5'f6liچ& d-ֹ< /i fwF()yTbm%BJ T( eDjdzQc=0GMsl@3R5u+5;C<=\J6mDmQX|60[լ*V ,X-:h1p~T!ڊNOlv}K=Apz\jW͝ePb+\ GJ@)LVkeUWPժkDєcc+ފ[ū-6>tA8[lue,' B&t2T3bentbNj j"Ika.Sm-/iS _CZ`0,}D"и61s>qS/ .0nSdW Hհa,vAa Ⱦʆ[W !Wܰ4kP l8hذ-9M4lCͷ1~ṯ%#1 .,C)IO(V3j2tE-=:D;cri׆p|k`_Ƴ>j [JlhG{ps4!e'nckZD@~7-yӻ7]s;C_.p3|z7#0I//'8ț񐓼Sr͠|.9^ZӼ*29s>σ.t|Fyя'}N7yӟ.e+Q:=ڬs:]c/;ڇ|n; <H;A~7DH;BM?i"^)l#&~,cĻt1mW۳Ѕ24[~` ?Wh6?m Ki@ gEECi<֢ 4wkPM+T&3 Np~~q9)MjZ7_8[]Ni% Ux_58_IMJT --tzՇL]TIO]NM0 (][M-`B[n^= ~` Ԁ n1陗j'!ayLm{y-iaFaMaOIaBia :]Š5`p `ٕlz{]N|T\BP!`apiش^!jXL1Y Y נP0YPYbUP-5 a4.1ٟٞY ;%tb$ڢߝlZyZQ$c͙#:cZڼJM\A?c#=9sȺ $AFd!MBNFC:$@D~$QdMXd[tOFrAK$LƤL$M֤M$NJ>EiUEJ䦌Q%R&RfNDODPDUvI2W%]R&R'}R()R1*a+,[U;D\KC$??@QBer=WDAT)5@ [^\vKS]"S%TUaFs%V&\ŝU2<%-"*b۾ [_(mEn.v~rgZ. jʍv薮lnr$.!&nֵDf] @ h 6o&F L\T/NoLVodhoZrgvNJMD/Lvog ($mw"xZ}L6M`[0mhE"ϖM|T p`gJ<ȃ0 9ji$@k0' w c>_ cHiˢ}l1Dw. *ٜjCX ǀ3Ddqu lJkb5Mӿ9 5*ת*Ӑ0FqS1%I'kwKت2Թ:ank :k `]91&Ê&D1J2,P墡϶!,a2,_r.3&FG011s)2y,֖Vw26gr(3.S1l0o/s3/Kl+*ll;CQZ2'۳.s10ӱ8FowsO]m3C{IB,ZsE[4t)@AY@S4v4~6&٘L4MbB5z4t0:̙- sT3 xz1wXu 75>~f)2/V5ϴ[C \kYn^S^Y;_[v.dGvMb36ufl6gwg6hh6igWefj,]kgvжll6.oo6F@;c++-annotations-10.6.0/html/threading/sorting.gif0000644000175000017500000002020112745054221020547 0ustar frankfrankGIF89a       #$ &!!!"""$$$%%%'''!&,#(/)))+++,,,---%*1',4/5>111666===8?J:BNELRY`gnu| &/8AKT]gqz !-8COZfr~ -;HUcq~ +:IXgw'7HYj{+=Oat 2FZn  % : O d y  ' = T j " 9 Q i  * C \ u & @ Z t .Id %A^z &Ca~1Om&Ed#Cc'Ij4Vx&IlAe@e Ek*Qw;c*R{Gp@j>i  A l !!H!u!!!"'"U"""# #8#f###$$M$|$$% %8%h%%%&'&W&&&''I'z''( (?(q(())8)k))**5*h**++6+i++,,9,n,,- -A-v--..L.../$/Z///050l0011J1112*2c223 3F3334+4e4455M555676r667$7`7788P8899B999:6:t::;-;k;;<' >`>>?!?a??@#@d@@A)AjAAB0BrBBC:C}CDDGDDEEUEEF"FgFFG5G{GHHKHHIIcIIJ7J}JK KSKKL*LrLMMJMMN%NnNOOIOOP'PqPQQPQQR1R|RSS_SSTBTTU(UuUVV\VVWDWWX/X}XYYiYZZVZZ[E[[\5\\]']x]^^l^__a_``W``aOaabIbbcCccd@dde=eef=ffg=ggh?hhiCiijHjjkOkklWlmm`mnnknooxop+ppq:qqrKrss]sttptu(uuv>vvwVwxxnxy*yyzFz{{c{|!||}A}~~b~#G k͂0WGrׇ;iΉ3dʋ0cʍ1fΏ6n֑?zM _ɖ4 uL$h՛BdҞ@iءG&vVǥ8nRĩ7u\ЭD-u`ֲK³8%yhYѹJº;.! zpg_XQKFAǿ=ȼ:ɹ8ʷ6˶5̵5͵6ζ7ϸ9к<Ѿ?DINU\dlvۀ܊ݖޢ)߯6DScs 2F[p(@Xr4Pm8Ww)Km, ffóҜՂ׺Ɇ培ۇ˃ HӮTq毠Ç# D[aȱǏ(KQ}A\ɲt),q˛8sdrϟ@)ѣ+m"]ʴӧP'իbItנZj'j Xp¤O-MDL˷߿ LÈeԛͽF~ ݹÖOm{h qFo&m'%DfHZ-8<ө'$nR!j⊚q8x%}ܴU⍕hu,-D6HF鞒1A)QX Z)ri&p^zlSM9@Aƙtfgkg9hP@EtQ砢Y{&Z6裐F iFI襛vd4 G-Fyi2cF :Xj{#-Ζ)ҖHy^Kg-¢IJ-˥/VTR پʺ)0 ] g*GWţd1 1t ">?/?rUcL.O"G!H'L7PG-T3AA<*- pEdmhlpǝX̵ǁ<-߀.rMP$7G.W޸ J1J Ό߄.褣m@BꬷîF6֔:-}D:gGn;c H_}=goź}?=囏WH郲~O~=/G@MKjg;<hoQLc~-csc]+roL"lb%ɓa1"\ +IrlF]q *ydnEJaR@_J8@\ݹ=1keaX]h?]`TFL#HTtی.tL-/AƵ ^=Y4P:֙t2f;ЎMjC[Hn{{ lO Y .k^fݵ^ o6oz'&2snI$!O'oWw<-ys}; xE#=`6,w;>ۿ򽢄n%%Ы Q7Q ◼||Cҧ tDgїyl*9:#}5LYqܾ2P}?,~ܷnq'u~awp } "BoGYW!||S|QcG<@v'x0/0CEK#ӂ,: C/2IX#kq(WD- uA#L!3TX@h\^2`mh;##G|o El^gd"aw0y(vf? 'wc(7x>rOwlAxHZ3Sk<(g!C|WfXvjRXp7{؇(# Ǩ=zbΈ8}6prx׍n1Q8<7hfh3a򎢈1di~! ؀Ȍ!BqW g'؀PX~ؐ({ HhX  UF gpX(7X&I71s@yu 1(Ea#JMٓCM)N-7ǓVzD]YaAȕ@g[e c /[Ij)N%K)rPt/ทه 5'ԝə9Qi3(iyi؜(׹~婍fi|ɞc9G|(G ږ8 Z7q4IyȡWoXlB(mcbr֨/u13 c7Q՛.j"GlTFzHJL=PP;ФTZVTb A0H(Ja`t(: \ڣ'VOKTKAi5sHije'`4/~j[-a= h0ɴ$;* Jv*tb %Ъꪰ:*Zʫ: PJZ JJZzh*تzʫj`PV@(pR0;[{ [E@ + ;{%Pk%@V`NTa۱* `)˲2;w44 dpT,H.; N8T+;VcDK>P 1[bkAa;h6{Sn W a5ֵkZIpRo[e˴gU7kojeLwG˷E0I ۹+ 0[^:ж;˺N˸0^jĵ[n6=V [SP@Q˶4Oo-eD_Et6 E"T:;д #9뺅жQP@6\6TZ:DK.%_ Ka)0\JįdVtLdDijTKsg3€0ܾIdaZdY$NNp`KP=Ȃ@ELFj*tJNt}L |̲\5>7̲K4IËnCG%]eL HB5L#MRU6(aR#Y< \; ϼ\>Ӽ-%R tT*ElUFZcCIe6\:ܘ>˼ͼ,<\, ܌H ]6YVλ\EYUP=bU1wJ8->!#%6̼  >=%ҬG]*,>}k9mM6@6uO|ǠPe̛r>t^v~xzvp:~^~JkYZ/]ѥ;~ ܈/9q벞Ǡs#$WpȞʾ>[ĉgH%>^~>^~wÎ.71).~`Hs1 Y蒯LoH__ &y,B.)!iP3b);_Sى9)8;c++-annotations-10.6.0/html/polymorphism/0000755000175000017500000000000012745054221017175 5ustar frankfrankc++-annotations-10.6.0/html/polymorphism/multivtable.gif0000644000175000017500000003371012745054221022220 0ustar frankfrankGIF89a4  """&&&(((,,,222333666888???@@@CCCDDDHHHKKKPPPRRRUUUXXX^^^bbbdddfffkkkpppwwwxxx!!4 Image generated by GPL Ghostscript (device=pnmraw) ,@pH,Ȥrl:ШtJZجvzxL.zn|N~l0.,.33""&0e2., Ѿ)X"ӳۗ&"čHU)\ݾъPWS  ˟@d*hRtR/g+}O5D@1MJVXAhV|9wb߯a&"J߂{in*+tOT; Q )IUʗS{x/aBIh.+%Sc,*&BX+aiFg`m^}Wb >eMkMH #b!^t/ḷi+$./X+],t-w4#@ô!Jd!-]?>|!YS)H߁t`BU L LH Ctnh"3A%8E+Т(P_EF(. ZV̰ n&|R㍁g]o#.\Rh$~OP)"S4WA3^NޙbJ1PD`S1M"QaUQXg`Vp).!iMfBS|i,z Kg$.ȥk1kp0T@GFJ!"0+~kkcr&#(p0T! JD^kD^ hQ/u9UG+=^*lGC+ A/0 qEܶLD@!o\L~JۆFka[ɞ>BMT)P(`oEX48z oVE3~6eMľUÊvmmfb ,&dXɹQyz> 4Eh&4Ú挿:ˇ~M+ 2>Q BCz Q3-_`#QmK].8] <VȗTav %< ilId);OShi9+BA<вZ1p>cזG+]%wU kS댰BLLj ê?X@3+dIp|IAÂ$]dPF4ƂuzdnKARwpRoSbaiLʊ^EP&~N3O)J{Begx["a8 ҥhzt R$:-%B`BMJC3V@TP7j EW:Uʨ;^'Bg AZTT,$g"8>e XKL2GABU#IH-PIEY{uŲhV6{U24&òX w#ڸ\Zf(*$#TEPL^s„IEwUHą<ñ^p8Tq1.Y;!TPQvA.SuW@#Ml&2T⼨D }Gh=h]+ iZ74i*2XaNG6o$r[|H$Y62l  !&\j_LvC *\$peE "bT%@o &킧a鎴]${R6Z[r4L S(:~q\#!UOGrs\Վ''9jM9kn'E!ALo eMoOԛwrybyv;<څ .q"=_ *s%@jj|ҙ>kx4V}2]\t25N/I>26` {mGg>L&X3̱{3Mza#s kez160vh0iSXx0{'֐1ǂ0284X6x8:<؃>@B8DXFxH6(=nՄNPR8TXVxR\؅^`Tx &fxhjl؆mr8tXvx* 3|؇~8X؇c؈yx #xP_v^剚X n he8P x PXp֋ 6 ZH 2xxUhHШ ȋȌߘ`(sx񸎍ЎHH&H`~H"xH8&Yp-Ӑ 'B-{ 9y򘐺A ")()&"-z2y4ɐ6y :P?{ГI8D9F)$LQSٔo'.h0P!^ō\kg `Yf+s)mX8ŗAxqi"d0痍zYw9|P f!y ) YYp9 )I yTv9i‰)wy[М aIIع ߙHXـiJٕĹy|>ih۩)ݹRП8 # ٞ8 !Z١gYH 1ىl %&6zbɢ{@I٣> @DKʖGʓ9BM: UʙI:SW FxХ`ebI7d`@+`bj;x, v``M)Iu7ɨ?[@z*:ڧzZ* jcx:!Vtڢ Jڗ:KYfIȭ 3j5*IGiI ģʤ ZyXʮPePɰJ1k  ڱ)zic@#x +HoiJಆȳ$haA H_`Z( ɴI굉rɵ JҪ*Ejj'*iJf$涋*˩zk + {Pʷ8Jʶ3Z^*{ *gWp}E空*매[;{K;vۘ˜+;k+[{[ˋ{K[{랻݋[4+;K˥;;Z | < ;˹{*=H:ʹDp(”J ImЙg+:ja  R@%NQPX$*YKBJN;"zSV<FM'M?4gR3-K!q} @$\B-YR0> Ā#rq.]TQ_F2l5cRAg_PwuJg Vt <BDP/B 5?YrDN M2 ( +%}u7}JdJp0~]]XE#3 u@^.5V !R/Cl?+L>cMFr_C- ֊,IU-FbT~#g6$}P aXDqJ Z COP'FzMP_o86RXuG'~]SFb_L5P ݧTVIݝ]Qn إOC53\/mb L@r&vVd@hETaBRVN"k*,h*3#x SR2պ=us0Pp1Qqq0",PApFDs,)E#œf3)%j%BDiDcEFQu)STCdUEBDبUs&7n`Q}Fa>^~@$_> .QNAZbD)K!?m:48 9Ú+Yt,3%;yqXu3ziR!w) i VU V HlXc5n4uTo{oްqxӌz יq1 \r,<(0w%ex>x}ujv |GWUsE%CEx:ȤsWHxZ)2~=Вv0L@W@;:ŷwKY}L^gؿ,K˃< PQ0 e45PX" @@osCF#.k, DU )6j|){=X,֦4H$\\E^T 3\b9:3 5ē!\ %)>C"r1Y", nܜJY@#d0ԪFB(6O\'T=Ed LkXG5A%*fOB!fH5 5dWKU"kM $@kI%hud$zu)>2|ak%0D)q3wOP `67h\jtV "(rEmRSxdcr2*ZU, @)$$9D1,Xh0Og93cbK4Z&B6f!{ ꪩ66j|Iu)>#7ȈS2! hPQB)*$2C IX5 ,jnJ{HHCbo%qOy35{QP?'.jV:8,1B k)`o=qBt%@{ig]Z߱g}z07gx*ݧala?"fƕ$S-"fHpΑǹq*'+QEegqȨ$FCظ@31C Pii0Dpnk.17$QЬp$4<m\kGCEsH%-x!DŽI$)Q^Iَp"XmddCYqv|EUi0SCBqHW86QBlC+1@,(@<4`#a $1HL-x3rVtʁ;* c#Ѳ'j<99 #99фEd4(&aaCG&nY@%ک .?rDi س<ЀY I X 328eX`?1#y+c(ms9wJT'yS"/nM@eU=~@N⨅qn jz5Q,B۴)t8,G83ISx* +] _O4vҵJp3kRA7{F9"$ƪ 6H[2u58X*bHֈGYlcǒ^V'TĚb62D'hI ,pjMDJҽliK[nyRLެV\Ur\>ѕt[]^7n<]~x[^󞷹U:[ 6C%"_D ) ʹO,Naa g/:2<-Zfi}R1_ۑƉ◼0_'A ks-&EA+{O "N`)_ṗ"j9Pf3 PNUdwy2 @pщV`eꥀi95s~VQ\4#)0vAYjW@`iѠF)Fl=&# BV6[PYZ U=׃pEؠls;S,,͆ "9"LT[0 @{ ؾK+"zAuaz#`9nB 5:=6P[&^] xi^sW5vs%Iҙ~s;1~IOR]xϷ{haa{UL.Puj<32T廙O=yA 0@ZԌGm.[w;g? Ælx/6AyvRGIIHӎ[^׿#Ei_{J%8F_z%z׍^w|/ڽ0_'TU__~ ~2~zcU`oAߓ{Я;,mG/Z@JK "8C0$o *.2}6i0Dh@AK fp\%vzp^ n /X8ePd;8`KoP Ioڬ&𲠰 |N@ڐ> 10+pv (}PT@J ֆA +i )N`q SQTpR0SŨT OWЪq@ȍѲQ_̾1x[Mđ15ؐт ѱQ q dQ0@M$o dPF #_@(-Ƭ$qn)R/#Ϣpi ypq Wg2F` $-ܦq>` `!>$o@@фO O~q J\f!^({ 0%Z0@і&_@ 3ф//&-Һm33Ѷo!2]/S( !ħ ,24Mz-_4r2+14+q-6I lpRӋ9mMMT@S$S?Ͳ8-:3ݑ"^Tվ 6"t BrMQM;` "m%KڈWu 1$m!k5ޑo^PTVJOSSLQL{l0ZJJ@3T#-/x1#mlH[@58KX5MWZCEZ>u`._]S2B5=y_c` ?b;.apaTK+`$qֵ&2 bO2va}b_=ZN ^QVg06 )Ge`GTFf(iijVjjjkjͭLBeqe=hdy&OmR!liilIcQD*KVoVvⶑvCFUm = Y'2h;nISmqqMS}6Q6Mu w@)mqW*ok(IwMYFud"KasM70EFuQ*vn Wv7?FhssSD7Ҿ,l-pwCm4xwp}w#YBrsawx7~ {H{){cv; XTw\wBwycJA-ziz9'7 9aɖ!k4.P9nDQ|4Qw[EX]fWsY8Pnfm.4ut/ׇ9)X٪qgx?u7qwsŘxX5x{7?"i8|W'ϘauWqLXMų YO;;xLe(tXY<Ƒ̎5wDz!h%y$Tג+7qy >y7l.9LvQ88F}͙/L# %!;ՕRPy?{XiUU@2 xU:ؗSwi9 AD:'_Y8Û8{Xڹ4!j`DaZ8_wSw0%fjRؘ1Y59á.#x얰:j:zBN_YXڀk_oyw=٪SZTUCZŚ陁Ђ͸Z[<=ٮf#g!N7殚NS6$Adk۶os[w{۷;'WH[C LVֹm/{[dTyF`;[Ǜۼ[כ; W[WyEwV.{5;ì<(pںY\;5 /\4C#6Tɫ|gU;<[:ƽ\̳iUȣ˙ ̃m|ű\ϑ|\::{лܱұoѳ\ȟ:\/]Գovӱ{ͅ#G0O}SW]կ/ʵJG |%uD\]Y\!\ =r\m48ơ}u=':]"[}), ǽ9[Б݃Km9s āإ]n՝9^|쾵 3^y-K@♛9`]u*{ı[ѵ-S-.g=]֓CzO@Q?1 84@/[R[r$Zώ֌]7 >9ǜNQ݅˭ B2 ܘEO N1&9Z5W5rSOnSṫ&EXUbu!gn3_OG[1~V4 sOum=Z]<9]#t ׵yDc?tь6t sx[Ӂ_?9b.>SN'mS`%^!h<"0Ѣ)u֭q1l>tEj9nf=)0*90P@paQ=v}9z:-m24"AyWe #'*??kƶ0bsuEe+\ФsKaEpݢ╺}2(;pXRSx0/}GԂTx^'AZU;R$iaAijE0Kh&ok 8*^1[82VuUj8:1{9B"#9J^2cymX+=݂9b3|D@ =\-fl;9z3?!mC#:v '_7C*."] , H >~pMCu)lP;z_V?ŵe*n_pi.q˼XtCAP/ \4fX][eӖZvz9 7N  ¼Ku~v d,([55ֆތ .8é!~+:{)I*nҔ; ҮC'M.^}r %OɎ g :p$>&u,AT_ d^4G_Tue@A`u0\t\@@f(FH=d`   MM5U\! `j``  ^1a:BaJ֠ɀ U@a l!`#aaaaab b!!"b"*"2b#:#Bb$J$Rb%Z%bb&j&^;c++-annotations-10.6.0/html/polymorphism/virtbase.gif0000644000175000017500000000265612745054221021514 0ustar frankfrankGIF89a***!,H0I8ͻ`(dihlp,tmx|pH,Ȥrl:ШtJRجvzxL.)n8z%X}ȏ|!wURrrmu"SPg Q fzN X WBϿѻٹζa%$?yD$"TqÇ aT,F 7 ӸRǏ!c41fX.,!0kjfI7T`gO`?Gt |V$8S լ˪!%æ=`Kڴۍ^ɣ[7"wgZMعR!NL3/ə=kȠ?5Eh˺l~_4ZvI}y^K]mxlԼμZSsȼ9eCcoYuN٤ wv} :{}.z/![3qF\#塗 1~zQy4ۃ.Hń؛R`YVـa{QyXH$P~ɣ\QXbfUL%&ix0^&zjxʙ-N{a'&Hj馔ܝP(g!*([(jrZ2#!,**~ I,tbfKj.hͶjlR+|4n͒ -h*mo>？Ήé&eyܫwk6|æ \>p2ƞ^p.J2؋oG6L8A0+[qC{*E3}/wW[JD/`' ҝH=UM`8U0&<\Wz7[ǻx "r8<$&SfANwJs8@QM! z+ H2΂#HEQ#tGQc! ABM$2z@"IJˆ̤&7Nz (GIRL*W;c++-annotations-10.6.0/html/polymorphism/implementation.gif0000644000175000017500000001537212745054221022721 0ustar frankfrankGIF89a8  """###'''))),,,222333444777888;;;<<<@@@DDDKKKMMMRRRSSSUUUXXXZZZ^^^fffgggppptttwww!,pH,Ȥrl:ШtJZجv{yxL.zn|N~t/+/+-- +^"ck1"+`r fnbs+'3s-"13b"k1+bn'dm_sf(6 a4,D 0+}K!c MܾĠxc%ɛH]RDƍ#zI ij?/( WZh6`=Ջ^aU@8kNePE>f 9k |b5kg  )q5̭+O_ Œk ‰^)K3D(Mv RCxLvYO KviU@-; {jً`>CAJH+Ũеs/zo>}Fgֱ7ڋ>"yW^tX^ ̥_pƬ8P:+g 6LH@|i—}G1N|UAJu ߄i!aG")H4yy^Y؉ULbm8LU f//s(bvجsLH 9(@^HaeZI 5L9hԡ.hKn,Bq8Ca _HHbQ}֓hjH*C2V,?Q.4Ơ2-Ё)/&"F lSxUZHؼx_z#yr^f 2Yu-k B&9!3@l/"h@~'yz1b0ur,KҲ,1= @ Slza(\ '󊭈'̜)@@,BWo|GS}MwD_)2ʬJ:3Ppbr /5 ӡD'Jъ4( r<-JҒ4ը8P,4 CeѓLJQOx0kӢT@<+ K2h0`VKNT HjԲ.9xV*XyW< A^9)xDЪ\eiGʠ73d+V-# Oa)(DLm;e ^u%aW9 ucdʖPVq2QEI#! <`< @YJp(XCY`8X")AEd%xI  As@s#^ nm9]ؐBiASRvw]* {͖8@hUۂ@.NoAwzzNc6u- dЂ|>qAb(^^+H &zs= *a4 ?ٝSc,/(@ ~ҵVͪIp+XsJ|SŴo %"^%+0\Y%+Py\{zuҠ0PdVip]Vwx;X^ZghoT~ x|z0d)[ ~~L28yn0|;O(Ik2y%YlD}iY?Agՠ*IwB9 m-PSYdKL?/;-a 2wf8B4՜j @?:q:0Rys7^~XED!2! ""3'v P5pdysvsCjgTxXHYG v"%nH-(0bݷagb_5'6H!7 wi<(>S%V$> @1"}B!c(0 0`6WhS#^[ȅT1/3d.CJ' `pc7Zi;XEuz_ćd8jpe@+hsJEE HNLݔMM4HL$YAxWx؊HXRbM$@Xv؋֌θDҘ^rxT(oڸIԍׁ6'툎SxVAa2tWDSe~A_&d}TeVA2@EkuaAVAvJ<vL1FZ+s.iAIWc,Xw h#eُ\FqtU'AEiEy{")S+[&&Yv?Z{8@"(TsgœߗA*zspdXUpiUTZ7p9c%S4cU*@YwY'@?vpUHxTX`Z^Ȥ ??Xa ]9)ToVEkfK2`XyY{ pt W\x:'Gt Ag\)SYnu(WTv&sţ'ɊIQ^%^FkvL40ejL.Z/og~h64hGLh2j(@rAt` bTVAr"q()ڢ.+-@fY)9Pf fZTv[ic4'A&I]n%du/6ePuzUԙD#IУTp[IVla>iAlew uY;g gynUz DPT0vskEskZ9:YOHdx c&Nx O-]LWuJu[嫊T{yeEbx{HT@l%Y*t8fUVcKHn(gt`nufڪ#8I:fd+ Dl${%RhYi1F2z"Ւ"zdVO}{OyZKC"7B6\gXo g4H!F gQBNCR.p`c`ɣEZF((ODj*S N{3^k$dYkUI tHdxL깶b늺w{zkTxkMpC$tHdL$HKH`mJ;H hFɺ[kFAVK{ecF+ƻNĻKKFۼcT˻K F Eԛ]4[F;2 \Ծ C{c[d$lY0#[t B\Hɛ:F +$‡ "dZt(B*l$ܺ1 S9a[k9|B3\5gAL-YI\5i EܱhQ;eT <8صřP6FX,FƘ!XjS`x-@nv`ka̽>`cc>߃т>@B>DW(PmpUPP>T^V~T.X\>I K-^9pMFTn:\m>Y(aYce7)ֶ}p{  Lj~8^[~H^ߐ^.攎s^/޸tM !^3n|-.띎S =݉މ^nQA*nhByNٮ `)P|É}S CΌn`W(󢈚 ]It/l?X}?K"XƦU7| /Ig{ЭZvz}NtEOCοynBkDק%[_z[ZqdNt)C@pTfET.Mg@Un2 eV3-N7NTDfc䡊JG"aOn䔮 f#ъ%*ubk#SNzz eIF))i)Z lM}]͜|jBjǍJT6V&MIAF6QbGiaH>W@SB*22GEx3}ygN;yߴ,е3zhKyǥHTZ< Xif 0{BF'C:cRq#-̨4iZ[ \aŃ 7FqȈ+o(H9w6ӆ ѣI6}Z/ҵt*,**n@=Q(pK }=Q:܀Ab"|d+)5(<er}~;rNH%zŁqsUr }%;& Z@ e*zTp9*h gHzp@Dl'< @a86E5됋ꨰOh >T(cZG{2@?XhزJRN$@q k86xH4J*Jx$ 2oBxDG&E$TӾ6tIQTSON+AP.VTUODKWrl-xӫ^=cʦXmZ\ hc HkEOzet]T!(wD41QrM vݗ~kzTP; s]Pv0*60#69y-c9V\7Bŕ"!W.?\Coή>u( ߋ ]5n]J=ȥ>@nHLZ| 3̙2LhR ʋ*LH3СlR{ ҥL:}῔T%hDGA 6,=r5-M 0} w֟T&hwzh"mPY`iCnĠDY^,fxb3S#]椑)NZ6W>glyeC7esf{w5f h|N9h6ޓ!c(n Q:Te(oFG9aa(ZҫVڧz*~P<ў#zC2m5=sNkw2:l} n90߉;6oK^G_kv" .ox;zOݦζ~8q{ D ?s;HW5x(kG,(o-SM̻ۧCct[tҫk?B|WHo}tXئ]nF7B|^sF-dAlj\Z8 cڇ@y.(\.3KIM%<]OUSЕؗ1L-'_tzqJ+Qe-\njt"|wyvlOzfKfԴz]lk s O>>s_w&t6ҫn={ڻk\/oK%;.NK)O ^<n^6}ΟbP35D`QA9VEҾBЀBo1`-slWL6tV&!jdXFƆ!itX* QX9$*qLl(JqT, jq\W;c++-annotations-10.6.0/html/polymorphism/caumon.gif0000644000175000017500000000422312745054221021147 0ustar frankfrankGIF89a!,ڋ޼H扦ʶ L ĢL*̦ JԪjܮ N (8HXhx)9IYiy *:JZjz +;K[k;kpƫ[& \@9eO_/ٟ < 6CJ!CT#"hV"mƌ`U U4/izdْKgRΜ^E!dIGk:mTTԍTLUhVs"* 3رvMkiҩ+ٶew޼ -\0bK%.Gm&LY f3+NRgC6SϪz ;٩/оM*Cj3 _ cE~_5ݒύ3bj9=pM4gĶ2|UC|zeD]YEG ]Ju]L@2AIS=ǡνeZx졨֭!D=@ԉ@T߀8_Fc3X [R8lNδ!uXYfGb\%WY+2I1*W|^>>݄ˏ@⨐Z;Ҧg~6aPIt68hߐDfrkJp}I~ =h(ITJwre`p+W$*f뒤uGU.ˬH4 -CV lRbm{rk6* x&} W;o%njnAJ5U~j-osibi Xo ENK91-$qI"kn6̰>d |X˜ ./Wl.fҸ܁L,uTGu$?_صA[M[#_sk%/m,>usK=7ځ#^ۊ/9!AH.+X~?3xKk-{|lf ٫D;C1;d78ۧ}h'Jćz[dŢڋ_)|:E!BF@]aCԃRfdU3ZZ0)|_Q%kqa7*)i ;.Uӟ|0~# Xs!a h e+2 kE Q QD%^0,u!ꃭ[#TFꑉclA<vhE-ad H1^1\0$REґc< N}#:)BQBwTe6I"L풓\F3mVH^j,AL w$V+dPbDHUgaK#ȶԵsh(uKEiU5Tᴰ%-}W\=7ɭHcՅד9F/EٴlD> ]wЩn-ʈ N(37˨~L.X\@DG2#xBcUQCFV^9a..a!0H;=iڢFq9'Bks" 5C{A4b]n\^Eް̠Mq_CRdFd)tx} P۬ZSjj4DsІ4}ELU}tXmq6T賧PzԤ.OTzլn_ Xzִo\z׼ ` {.d+{n =;c++-annotations-10.6.0/html/classtemplates/0000755000175000017500000000000012745054221017457 5ustar frankfrankc++-annotations-10.6.0/html/classtemplates/notfn.gif0000644000175000017500000002443412745054221021301 0ustar frankfrankGIF89a    """%%)""-3.316 !!!###&&&'&'#(/+*+,,,---///%33/5>(88-??000434555777;;;=D=DLULUNWNW1DD:BN=UU>WW[f\fjwkwp}@@@AAAGGGFO]PPPRRR^^^R\mIff]j|Uww```jijpppuuuvvvyziwbgujnuz}ʣْ̔Οݯ!! ICCRGBG1012 mntrRGB XYZ acspAPPL, desc|cprtx(wtptbkptrXYZgXYZbXYZrTRC gTRC bTRC desc"Artifex Software sRGB ICC Profile"Artifex Software sRGB ICC ProfiletextCopyright Artifex Software 2011XYZ QXYZ XYZ o8XYZ bXYZ $curv #(-27;@EJOTY^chmrw| %+28>ELRY`gnu| &/8AKT]gqz !-8COZfr~ -;HUcq~ +:IXgw'7HYj{+=Oat 2FZn  % : O d y  ' = T j " 9 Q i  * C \ u & @ Z t .Id %A^z &Ca~1Om&Ed#Cc'Ij4Vx&IlAe@e Ek*Qw;c*R{Gp@j>i  A l !!H!u!!!"'"U"""# #8#f###$$M$|$$% %8%h%%%&'&W&&&''I'z''( (?(q(())8)k))**5*h**++6+i++,,9,n,,- -A-v--..L.../$/Z///050l0011J1112*2c223 3F3334+4e4455M555676r667$7`7788P8899B999:6:t::;-;k;;<' >`>>?!?a??@#@d@@A)AjAAB0BrBBC:C}CDDGDDEEUEEF"FgFFG5G{GHHKHHIIcIIJ7J}JK KSKKL*LrLMMJMMN%NnNOOIOOP'PqPQQPQQR1R|RSS_SSTBTTU(UuUVV\VVWDWWX/X}XYYiYZZVZZ[E[[\5\\]']x]^^l^__a_``W``aOaabIbbcCccd@dde=eef=ffg=ggh?hhiCiijHjjkOkklWlmm`mnnknooxop+ppq:qqrKrss]sttptu(uuv>vvwVwxxnxy*yyzFz{{c{|!||}A}~~b~#G k͂0WGrׇ;iΉ3dʋ0cʍ1fΏ6n֑?zM _ɖ4 uL$h՛BdҞ@iءG&vVǥ8nRĩ7u\ЭD-u`ֲK³8%yhYѹJº;.! zpg_XQKFAǿ=ȼ:ɹ8ʷ6˶5̵5͵6ζ7ϸ9к<Ѿ?DINU\dlvۀ܊ݖޢ)߯6DScs 2F[p(@Xr4Pm8Ww)Km,IIHGGFʳ̻~; H*oÇ#JHbD,jȱǏ a Iɓ(Sk˗0cN)͛8scϟ@A Jѣ"]ʴSrJJJ5gԪXj%y8`ÊKٳhӪ5f۷rݻx˷߿{UF+^̸`ֈ˘>̹d3ۥDFѨn犡A|G %o[ b컷P7YF37؉g y.W;;5 ^f F=qA=wx!Ci%~ Ѓ7 zu{w|u1Q_^5rDG߅!3j 24m/vW.F)!^7N 1Dv)v !y%`L$-d]7ܕϭ ^ֹܛ~bhi]U\urENCz*FɦeL' P}7q`]6ѣ27%u@ ߏszm<`A]1aJBzfVkz-Z]Pܖ(*$nBjkкɫ/C`~d/z{п+0 cA' WlE,ZI 1Aoegqjf43V3׬7W@/4rN?m=SUL'TK7-u>CXSMWg;[dTcv9aהpӶLoǽ1mwxC`Qބ}vSE&Q8} ŏ7J}`D&d*>n7)j7( |7(KL_'G!Wog}PL[Gw }觯g?~^?)?˟}P0^ =`P2D kư~PV@Yɠ@9aA wP}8G= e\MdX~իlˀ0LXܠW&jzU n- $ Z8JpG,  HL"F:l$*T5X@_P NX .Mӳd*oO! +%1IS~JADIJ! j2@ҳcjZf"-Gnz{,X s7(\wE顳 WO݀U% "_G8$G&< hz h:D|abJzOq'UOJN`\:Q] % IՎ=tQc_)M} *4{NyyTTQ6;jz>`D}T)0[1so8ϹwppH!.5jqmXϺַ2yTy<~YpNxϻ]6sW$aR̗#ϼ7y)(8v =J?z698:TLIw{Yh`Ќ}XHY9w)dB x{jYd'sJ|zx~ڦutq=D`x;=:@ǙEʉe(:NڍPK9X3ځq6Жqgګv.`oXwo wIh$*[wo٧ `ࡣ' wjwӺwx)Z /ZBPDڪF$ْLO)i:/8z ؁zx:w8ޚf@h8`*wʦ{%vfъ;rߪw ZfQڂ:ɁꚯY,و3 [p xڤȊzyBQ;9ȥY .+d),`y"`+w)v q+IȭYvတ"H AYDБ"k+ Cځw!u"03؎;u1@N+^[X_V&[h)LoW; k`Vk{zwwOwo. {[Kk+oywI;+صom. 9`nljۖH8ٿ+jtpl#ɋ`8K0Q3\؟V m)+,ti*:\=kE>X0O6<0$>.4umDn< J&MEw}K~,-\>VbM;h]G0=c)X8 8jJ .B.è熎y|:Շn1o.&y^k~>=0(.^m>X̴>ϟ.߸.*mSHul. >>{w,ЮԞ|>w_ xN^{ȶwފHv&釀)ږo z,imfhQiyh 2|2 ,S=6-4}1m["N(ڡz k}FwʞR Xqiuhb½*z^˽-Ȝ_[Ւ 8(L|PZͻa۱|k٘G`mmYnPkٗ;-IYvxOjڬ/[wb;wª ,{dzԭz퉣ǘO~mv [w閎xw\/ zyP=_ڭ́ǝ'hp[}`eFCHp Eh%(I(b%Hi69(:JiYʺ+;K[Pw ,!(q3MB,GT} YQ7c$n*r%h Kf6(f(S~rœ [.{K>ݱ/գu~]VrG ֬ح(2?.nPa7OyUv[`),fc51ܿ#Jiz{E lD4D䁌u׭]|D!R.tDd<IHbW}F G[b3w(FFhbJ.$E(Υb,, Dh!s.!BxED`aqqch$,Ō!DYID^"#n੧jeD0W(聿Pعd~'E17ʋyE[pqcz! BʦʋwHtڧmc/;Cwk,*\D /[| 8\Hnr&IN) +hZ/"BW ([\AAs7 })$/l`'Lｊg|ڹ람rʨ[һ,W8k33L_ BČRKG-<]\)rbEidL4u۫2keym[7ڇ-Dl톋8?C >+Dź#⊫܏ mҖnѬ/wwBzcκeK2uƐ[:`P~{0'/;4D| f<4g+|s}LJ%7?'!? /ֈ&+ o`Wt:B*#2[@[>w?x;>P$yp 0eEV:G<t% 444555767878999;:;;;;>>>=D>>A@?@DDIILUUU:@@:AA:BN[fffjwwwA@ABABBBBEDEEEEFFFGFG@KLFHL@LLJIJKJKLKLFO]EVWEWXORXQPQXWX_^_X\cR\mKabKbcMefPlnPno]j|VwyVyz`eoihignxiozmtyboiwqx[[azuaacffklqqvw{||ɂʘ˥ɭԣفӂԆޯ!! ICCRGBG1012 mntrRGB XYZ acspAPPL, desc|cprtx(wtptbkptrXYZgXYZbXYZrTRC gTRC bTRC desc"Artifex Software sRGB ICC Profile"Artifex Software sRGB ICC ProfiletextCopyright Artifex Software 2011XYZ QXYZ XYZ o8XYZ bXYZ $curv #(-27;@EJOTY^chmrw| %+28>ELRY`gnu| &/8AKT]gqz !-8COZfr~ -;HUcq~ +:IXgw'7HYj{+=Oat 2FZn  % : O d y  ' = T j " 9 Q i  * C \ u & @ Z t .Id %A^z &Ca~1Om&Ed#Cc'Ij4Vx&IlAe@e Ek*Qw;c*R{Gp@j>i  A l !!H!u!!!"'"U"""# #8#f###$$M$|$$% %8%h%%%&'&W&&&''I'z''( (?(q(())8)k))**5*h**++6+i++,,9,n,,- -A-v--..L.../$/Z///050l0011J1112*2c223 3F3334+4e4455M555676r667$7`7788P8899B999:6:t::;-;k;;<' >`>>?!?a??@#@d@@A)AjAAB0BrBBC:C}CDDGDDEEUEEF"FgFFG5G{GHHKHHIIcIIJ7J}JK KSKKL*LrLMMJMMN%NnNOOIOOP'PqPQQPQQR1R|RSS_SSTBTTU(UuUVV\VVWDWWX/X}XYYiYZZVZZ[E[[\5\\]']x]^^l^__a_``W``aOaabIbbcCccd@dde=eef=ffg=ggh?hhiCiijHjjkOkklWlmm`mnnknooxop+ppq:qqrKrss]sttptu(uuv>vvwVwxxnxy*yyzFz{{c{|!||}A}~~b~#G k͂0WGrׇ;iΉ3dʋ0cʍ1fΏ6n֑?zM _ɖ4 uL$h՛BdҞ@iءG&vVǥ8nRĩ7u\ЭD-u`ֲK³8%yhYѹJº;.! zpg_XQKFAǿ=ȼ:ɹ8ʷ6˶5̵5͵6ζ7ϸ9к<Ѿ?DINU\dlvۀ܊ݖޢ)߯6DScs 2F[p(@Xr4Pm8Ww)Km,TL($Ç6Hq0jqǎ ? IrɒOD9ғ˗0cʜI͛8sɳϟ@ z`ѣH*](S.>`AUU*+WZvz+ٱb5,ح\f5.]u]8lX ^Ka<]̸N2Ar2.q 0hl*Ú?ُaҜ~Sd س n04!93 F8B 1,[L0tDD Eh ^R)` 7a d@Mh <%zb 2(B^j=KjP$ MTa#2,X {:HG"DaM8 D DEz{Td#]B҇.)B zB d'bP(KyMzo10OV.[$ 7#P8+^Б- c# H1]29Yڃe)f>S DHOx2 +KZБtI<=+fHK^ R#'31)aBЄZ7+c9 J|_Z„+];oIHI %MKALD~>Ѧ\@|8I[ꔧ+$UGy gy~R\iK1.'Gf0R"Z`&R*u [J:d}gI՗T*O=obHRDMO/ ЀF jXcP q %b * XlވauI tꕱ!t'_VZI"eB2Qq]sjim-dށ^dg4^L!̣$+2(VIo +`gd2v9 `´c*la?/04 ?%Kۤ,ր{?`1FWō!N*x uHql$J fdJ9;g暰.)n.l̠&\n0u H)% _gnuIhhALRe#O)L@9+%ʣ?韀v> .k820AN \ЇS&4{Xe6!K06Nst ^XzTh&=۹]cc(QʠLvX”ɼ]NPx4JA(k7KZE^ryr:XQ^'_?ʒv"̽-5.C94Q9xN9C΄T3v%Yq>2k-+ùrr:REgIQĐROf)o7'>wxݎ"0lʝ^CJ/V7w|s-TT &Zs.$RD-C;(a6^۞%=zؚ(B^үǐw\){>zm_ }ueRn:P%IrTDgJR_%SoY}G. ?xu4ѼR81lu{G1gZWZE[&eZY:fYu$Coe[[QEi Ӆ=EGTEGG}Vy=W|scc~5!IA6v:h4SAs wyGUI4G3bф2;W3 L…;腷a8cX;Vrld(fiW!g?(Zhb}8Xxd։9MXx؊XBL؈0px؋8k6:Șʸ،$8n8{^[r?"mH聆G>HaF顎2Fݘ((ȇA!A2Ž߁@&R!?Aa>֏9xX" )|8$2r7([p.J;㸒H#640Ɉ: <8iXғk(Gɒ&mX)V&ɏLI#'A>aHwcIYy[)!])fَaIB)`ٔj9#xsuII~g9YoxF8:TD@ՙhn@#Yyٛi  I:ʹٜ9YyؙM@LQ9Y‰ȩٞɝ8i9 V):ZJ7ј ڠZũ pҙʡY 쉠K"*0@ZPUY7`U0g y2:Z :,ڤNʛ. ) z;WzZ_ Y` 9 a:I 803k@3?0OQ;:gPk꜆ʞљ홨Tp8Pi:&:޹i~j83 Z=tLP* _pQ@ Qb4b & t _4aڣgJϊczR@Y zX*Һjaਜp_ +`*Q+Ю7+਒I ʫjbIz⪩modIZбʟ) @b p[`,GຣG @d+٣_Ϲ4?my`o3!0[?=;*}-pa5޺ɚ@, ?Y_0-МKû {˜_,zkں_` kP^۵Y _pЩ3qdowIm`~r빠+C+Q  "ں;{,  ZwKc`˶2xL,ÜP ,` *=l ջT[ҩLj۾I۸d iK!+Mb:UV˼;;Ɯ?, C, pLЮ[XKZ{Wtifj)K+@ QУZ^ji]k| ƌ ˬܹkoo,v qmL@ k 0;\*Qk1jHJN̜Bޜ=jb0*M=d ̵Y^>Htw/) w-}N 5㰱<MʒyJ| yz^..n+):f׹Řڪč&3:zg :Y+b2 l* ,Nν~b5@Q@9 t[ xƓ*Z*yɹ $&,KE*|X;.^R`PEBztMԌ3IA-NL[e7!XqkčRE: \kG0e]c J_ۛ۱?= ]ؚ۸ʑ[uo?qPȆnܻ6/ l{nloL͐,?1_Ɔ͠?t`㾜 ȫѠ-l;ہ` ٍ; шʴ_hʾ?_1 ]ɗʠgUirPzr;9=hIAFL-礵Ġ!h#>I3052.CPA0d02" dk J1hZ6zg'~O߽׾{?|7|1GvM=~;? ؑsۍ8@SK VH !P7 E ,k5'@>/a e8CІ4n8Ї?aTAzm BIp,tRA axzwI?.. e" haE8{$MX1x!0/#H)l+XHE6P%"o$R8A* Of9+UHC!.JYDlA"P^/5e+XR@KARROlXЂ%3$DŽlŏd5kIcRxNOPڣ^ &)I,P@x $59D cmQ=PJND (zXPu#4iYA%c<6O)9q:j>[+JpLQk4 MStaqYGJ TDAn5$QiQAՒd,S5S*.UUiV\FڪKՌy#Yzׁ#{=[jXjh )^؍*6&YUb% d{ɵ]jXЦVFP+Rm-m-+Bfs!mC%wm3 -.sK*sin@bw n/󹬥w^YW#(gW;-I{W)FG8jĽ9G]v/p%^3%DsE3p=4-HC˸4/PoehYa6s]i:!`KzնܝĈ~gh^%6q Io am̹>ͯ}_r;6$V&wlqѝ9Edq;mۤލ^}8*x5qwyE>raʶs(ojN ye>s7yusb:95ǽOzԥ>ukKw_{>vg;얾LWo{q~tqh{w s?xKA/x7>~7_xWtwB}GvXG=1,zb d?{blΆ=!OnMy?Xwc qPD>&Td}"󋷁D~?<Lh!UϿL?,.>pSc? ?Kc?4S9哹9?3CAD@k9h@ė;j˝# :8`:A HB@ H $8?"8$L;᣿9Eh=$H>x+<@L9EX6989Ԅ8>7 h棹=%LPD<?FMF9,$hLFM<;E( BK?6(4` pZC@ńt[4E,dᛸ⃺nd;GrIÄ9Xr|ArT9ȃ8?@G=8AMd^ ŀB:HPE:7E E8 \@>X#J_Ǧ E,ȯK?BxH E1lj<6#K2/>nF9$l|C˼$Golܜă4LtTtl?&= E(Ȭ$? x<C=81ܻ\?=8tG<[m?@P>$ńL.),ЂӁqd}D u ?!u"}:LPL˄CRrYCQ;%<;s?Tc};'xUMX>{ЩCS$uTLԎI5U:4P?lu-K<EMٞK˃F٫mcX|#SB:+$BBB* H%]„$;#}@FD+.X9G+KDS>ECDA(˅WMs دDQXE|^U a4;%uE'zl>LGͭGMl:|ptG G$0GsC-йC]A[P23X^NdHd=B]¥;]!u;tǟZ1"I5aSJK^^?tB2?LTD;%@Zؘ3F='ܘMnL?hFڪ5L90]B2~=addNNlaDLЁL|PMAFL΄uЮՂOP`wOMbM`-&}JfUÁU$Q=E}]5S;9ƦU靎9iμitiii.J `*ji6W^gm꿂gꞮ蟮֫.jqU]fT&Ҭ.k> MkU1~dkEN^cV)* Rņxfȶ!T.bm˾l}"$v׆nm19ΈBRmdm*(nZ(.nmN(P8ndi:ͦվrz>uj)tnn5{&jBV𶳗"6 iƯ6r'/zo͎86^ppݑpr~?po ? fTOl%ǯ#&qnq.!"7r "Vrop(:b/sr rY*r-qvErP-s3p+_+:ZKC s4s4sfs2s?osUt,i@#:W!KtEj@kJKL?&tߙOPQ'uALKUgVwW؀ڀ?[KrQ[lƦX'[w.-] n*FvtriLݩk*f_/ivQvqp/ @w{rr>o(uGvTrxyGYw{9owv|xK0xw5ߑxxf,zxv7ww B<3~7y_K  r_(wyez{x-zk?rMz:( ЀozHФH"(HPH:(| @?<|op|o)OS7 MnO(%_3{Έ7TM:(0%) $?v_(WO|Ozrz݂xim_lg#~oM|?/o# ,%<8Nt Ł5r# G,iē*WlyKcҬif7?DiQC8Pd QGOH@ 6u'9=xUWfȷrέk#LKĂ4|:P_ثôV1b0"Z2);0)MKi5زgӞI-7T+څ "? 8R_$ q$PA)r)\{ <@wvq u (~8P&FsxbQW D`=WX `$__8%UZy%xWqNzY_R5)IP%em&ni`hIRwFZdfzsez2B (zʟsՙ)ijEǧ kU*를jɁbHz(!K,T*ˬ}z ꁼz]Jk]wl'~PRG ;% I&^Z̒;Qn=nNoŝ[ v,0U]](F/De /ޙp p~YB˦ Hw,݉G}q|.q}L>Emrp}رLJY.mM^dz-Q 2pm򽪵r\w.,( b>XهX% x.l>|Pn';?KTh,ЀerȄF1KDQi)C!Y^p)A rxQB bXD1  cLIӨ::&ۻSk@Sas\`Ȯ> @H-|˄dݤn` a+T9"UP2O{)´\24iVˉ, i3ϼvJ$M IRCv`B~jDicYY+zٺzb▉a6I^L$!IZbN9fJ&K64H 54Qʲ}HQĚhfL3l`.U>o- 3-a|V͹̚E3Kud$lv 6 ?s 4ֵJv+iI 46ɡd@F/? Amt qӶFS钄?hO7,x ,z4ukpO堐-uj?Y1i-[(ǧȷ>w_rݗ]! 5 xKtQx.8tKXGZ-^"v9@ˡYηʍY?e*^j"\N%+sX5S̄jOWC9t$Yruӓ$g~s+:xu?]upo0Le&n>}'މhϽ;[x_@ettw@gTu$8%OrӞ{Niʁ?JMJ]ZVb~͌~Qz/[(~H&?_,Uru?M'dn^\ Go^ fno4BI :`Ή `! > j ڠVR`&A1a R^U!Nha F_ᓠ!zNΡΠ桠!H5 $@"&"6b#."B#N"$.$Vb$:"&2Lh"%N&^b(nb)b%b)b'%)Nb'@.."/" @/0//"02.#36 3>#4Fc. @@;c++-annotations-10.6.0/html/stl/0000755000175000017500000000000012745054221015235 5ustar frankfrankc++-annotations-10.6.0/html/stl/fig/0000755000175000017500000000000012745054221016002 5ustar frankfrankc++-annotations-10.6.0/html/stl/fig/heap.gif0000644000175000017500000000250212745054221017405 0ustar frankfrankGIF89ah!,hڋ޼H扦ʶ L ĢL*̦ JԪjܮ N 6(8HwX8$aI9! Z#`@jCj j;@{˫+lP #퍸#~||1Oe`٣O;9=~\o]H\h`[h :Y0؜XPhXx(!rhT1mr ɝc ;A# Cp$,E* I$1Me Up%ٸ2&&됙e"pYb%瞀ify fP ('虉&:椟ae~(^J䣛頨jZ)E*묢Z뢙J[i(J뭸}z졶!:[Z,R;rق;ۚ j.Z[5ڻҘo,{!{溢*NqoKqpGQ1rCsW"%)HFt 2*;yrFr(.BS",L%B̄Bp;/tD/a4״OLLQJߚf 3vc p#]n=]nΫ(v6wxupgt)ί_jiޮ->\=9эy斟|.x{d~ݕn]n:ikv;8g1/zyKoB}:m?|ѯ&Z|z{νԙ_Cu}9r>a|sߒ=On,x *.| l hv} 8B}4MHAw3D=+ lA$*qLl(JqT,jq\0qd,ψ4;c++-annotations-10.6.0/html/iostreams/0000755000175000017500000000000012745054221016441 5ustar frankfrankc++-annotations-10.6.0/html/iostreams/sbbuffers.gif0000644000175000017500000001461112745054221021114 0ustar frankfrankGIF89a X؀!, XH0I8ͻ`(dihlp,tmx|pH,Ȥrl:ШtJZجvzxL.zn|N~|KeHVIFG4E"Cı ޼ڼ Wql!p HqTBr 8|(0#=VID EFH#0c*:1%ȏZ|)O@49ReПH9&Ħ9T7LC:%e8WÊ%!U7~:[.eJZsmڷxR"ӍP ,oT;'K o*ǘ3ґ%9ɻҒD*1yG A\d$Iѕz^.4]0Q7Lu4e/5{t1WQVSD]2vJVқc4#JYƲld6UͺuS7DN2\'릩@li^הv``7Xt4 B+=TFk8ۺYv\Yku?;>b8,OaNնLmb]X6:mSi[&Ը`E.4 ӹ.!Y٠Zwحnv[&ջKV ^ֲ U.YqkvկtAE}^!2n=;_ٷ5-{^0L_ X &mo6zݍolE\7o0U,X qG<pZ8%\a";w` {YCrE1`a\{\1ms27q>t=/Gߏ^4=AOM53%,6ULYu__zإ>v3{ׁ..4o'{5GX?o8 G*3~Yw9<x<6^7OxrV6Wkyt^oj>AXTV}INF?;h{>`}t">{?b/nOw~Կ w*Ax  x  5bw$4h)[0{Ò0A}a(O+y5'fb+uB,")"H; $(8H-j)Ѓҁ^!68%"|aPqr+W/yZԢ)C(it.FHB'*G)f Xy8e%Axr,wcHLH+R؅5l{ ؄S*[҂Pp^xp&HX Hzgz}N7@8XxȘʸ،؋Pq-g/X#UqK"/--( 0Ȃ,cw2~w!+9s2)&x_Pݢǐ 99Hx(H8&%*b#38w:*g07ؑٓJ)+KXȑR$Ti5IL[ "!fɕSinq$jk ^ɒLW0s/"@B:DZFzHJLڤNPR:TZVzXZ\ڥ^`b:dZfzhjl:/a"Ѧ0}(X/r0x: .|Iy~:3מ~¨PqQ,ىSj ,O7"xB|)AZ*$(uzZ 8º Īʬʬ*͊ JNJ\q,:ʭѪj*犮jJ ǚ"Z@%1JY੗Q˰  9rbXພ {/x⭼:zڭwuQ+' tz8wLwj ʳYF{L۴;RK[XZ\۵^`b;d[f{hjl۶npr;t[v{xz|۷~;[{۸;[{۹;[{ۺ;[{ۻJ};[{KrSCe4dnkqqCSomkSkDD[9lklۋG{l=;q7Y;l<Ľ{nnږq?{nhg|Ŀ+ [ ,9|f{˾߻EE|q!\9fH < \T,qlJ 4,AL6m^ pOnTG,pULp*i ?2 ę=TvF- y=]_,a?vwȈ+,:mLlj&bk ɏsȍZȚ|[āÅLȒ ƥ@Ɍʝh6Ll|ʢlʞɬ˻ʨ6˲\˴qL8xl͌ż\<ȷ|Bl̪L ̪#&lŌA ϭ:ŕ׌ټ[7ƟLN \N= L<լosl^Ϳi]M!dS g|;(,};|60 1M3M5Ϛ+):2mF]|<}$=֡[ F - ֠L̀ѓ|^=w"Q&]q}sm5iMOa-צؤ MO}هȍ-؏ّٓMky pjd -԰]Ǥ>ЉmۋmMoہM ܌kMz}xm/TMKmōݪػ-րS=ԗ\ݸ}ݺ=׮ĭ m6RMmޭD]- m:]Ԣǭܨ^ʓW -Ն%}SM#2q =~B@=6< ? -M:GI/~#MmN:8C.TNqnn>l]}N1N3(ޭ D>Au~V{ynݗʌ.>塎ߔJmZ`^.hj晞;>^f>W~Kb&.>^gNN[~؞nruG}l. Q Tz W{랎.| Nht@uT8x|>K t /v 0r_}/vxWw~ 9x(?02˕1_}(uؘhy=TA`yFLO%Gi7 VXC/#4K!~M]/prZivOs7.^k]e_Rߎݗ0 ֗X:Ggos!?,H0|ɲ |i*8`,'g0 oot$),?HWhhB*hOyXx9 7/&_-*C;ʾ^ڋ޼AH扦ʶ.(L=ŸGMƄANK*W J&֬_K ZW;}8W߹'8ChxXبIy7Yvٙ**ZjBzZ +;K[k{ ,N^n~/?\֔J?)S@@ F:8 D`F)al#EFY{d~7 iNJi^ini~ jJjjj kJkފkkN lKll.l> mNKm^mnm~ nKn枋nn oKoދoz;c++-annotations-10.6.0/html/iostreams/ioclasses.gif0000644000175000017500000001434312745054221021122 0ustar frankfrankGIF89aXX!,XXڋ޼H扦ʶ L ĢL*̦ JԪj Nm '8HX!ȸh))hy8U):yzJg*;Kz[[š+k|L<\ \X,=Km .m;NyV-D_~0`~0T1b =1r^}wQȑtxɕ,CPd]Ȗ4kN;b4hti3)MjB0SSαzҭ#9IQʘ&ǒ-UVgr}kVb!j2M*7``ୄIY:n)œ^43f{Sѵ Q\Ɵ[K\e vjXE]V0K .q̑!Ojy齞_CP:;^P;C%zvU|{L#oɯ5 x * Ja-! :xW2!&]<za}h&^!b)8T2p3޸ċ5cFdBId>H.)L>yR6e 9ie`epe)ffinf)g.ډgyy9 |I.Z> N^jniBh*jʘj@ꫯ*+֚ꭸ뮢bj챔&,6"*Vk-fv+販i뮙+ziZ櫯;C)0#)/ԁCRQgi(o,R΀$K)2}'lL|.C~3>܈: ij?3="82ȹ^05a,`ϙjwZR[6좮avjB_DP^OI S]x]#;#?xՒN5gw,CvG@9˽Ky 4BX3^u<zY}{Khú޻O|o.}'[|,_ľ=dmK9?d? tžuQFw@}t׀BP|$a=r+Yl(& j{kW F/ro8;΃׳_D-^4&L\ Ґw#^?N3 (.r(~"HlvS&s'̨Ґ7bاQD|{ݦ?rFC1"A22z(y!KBd_8I`{<"S-<5"gbSF&خal89sB\g:Nq~F;HusD r@7< E`mA qX(|Y4t3D(GaQ`7@E/шmc8 b:,|7%FPb14\tDΧ(M1J3P=Sѵ=^T V:p_"Sֳ2̩jNѪUNqMkAfӹudM"_ʋ>ƭK$j^W9T2֭e/_"1gzА}EaTЩtMbk]j^–l_KdCJmVprQXS,kMܝt2֍bBn ^Ծ7̭dne/G^vMXӖ׾A.7iS&شt wW ,e_>4EYK]8+UxׅXĠ}1ZVXx%_E.1 dzS4ݙv D^!Z.rQ|]&m0(ĜgfFAAf6 ssPg*Ywϛg;Cn9htm}֢EZYg*"LwHT!U2!LnGcz~`LezAl.ʵr*<tLկg M;^-w9piO;N\ ~;c]*>bnOWQ2AWh6}Wo~Tջ;.xBBF;\N\!͋N4ml2$kM#9.{sFc9;G͏tr4zS[տ4u?]'zٕ~v@aoKbAWL].Rv-ƲIXR֖]?ċcjnz|d/vQZWm_q1\W oܤtuu[aPƼ_N>NtRĹ. ,!g:^p6 OCh_1׿o6}ysg}igcxd'AL7GH{w~L!wwBg~q}zq6xё(KXmHs6WQTwUl(;r{v1x5yuؽ{t<H[{9f1{{aG쫿'v\Y (~h< 97ڪ{ w{-`zCPz 9%x˽CRVc{GG4ďxE\ yt$C13|G};ziܿؗ}ʷ],hILme[Ŧ‚q,#\zLl:h}{,& {ƹzjL'E辡 ɝ[P\ʒȟ<(MʜT Ø[ KǚˌBɟ3s'Ȉ ?\D<%Uƫ\F\QX ΪǺ,~RhSlBی DZl¸ EH]6 [ } "Ƹ\%L|{Xʋ(*&| <+}_r}(} lR-͈ =}{b,Ӧ܈&u[#Kk[ȪaiMp=r-֑8rxk kl}jv[p{ؿW\{؍Hu- {ٗmيٝ<ءPiؠm: ٫}V= ۱=7=յMўMگ]s ض Hĝ۰].i٫c]Нܕ8ݦzƝ}ݡʭMt=ޜ]ֽ]ݰޗߞ̝߫ܝ|Y# --߬ū0ndk0Q5j$5R⮑u⸲X5R/u㳲㮒~p1qrR\[J䀑26q5KQ奲2S’r+oO,huQ熦{n~;}.&^dnw6~茮NNBnn䍮RNn\^ꩮn..$赎屎 뻎hNN%N슚yn뽮1>Nh΋ٮ@@M.gx$ Ngnz PJ?O ?Ϻ"_VU[ ́Mh5-ЋNOl̹,- ŃX68\;4Їζ-OH4 JM[vӬkL$lP]R= Yo#.Euopw{(} o qOyo/?oO-&F2__/?ȿ"үԏoO/_/o?OSF9igy ő,31Еm噮R]T.M3sNUH]cV_ks}/gqёCQrR23S3rT3ԴiTu56V!7WwW6X-9Yy9u8:[{z<[|>~[ޞ]^_|aB 6Ԫ[]jkX$qiVkTekKlq%ޒs}3PWy`ح~ =odM&|.ˊ73|RrhJwӑ{l鼂IvVtlG:Iƪ_c,!ܵU}2fΫ{e+;c++-annotations-10.6.0/html/intro/0000755000175000017500000000000012745054221015566 5ustar frankfrankc++-annotations-10.6.0/html/intro/objects.gif0000644000175000017500000000341312745054221017707 0ustar frankfrankGIF89aؠ,ڋ޼H扦ʶ l" " hL*L JϩuܮWT0ޙkK]koXh ub)9IYiyii():JZjٹBx* k{k+{%S ELX*< jL0" FL=,< Fw^˽^ξ]>[~ iwmpx)C(N]@mDRx erMVx#l#QpJ\n@v nfsYlIgy^ h~Y.h2jM@'@i2饟*ѩQꠧ*hΪH*D1ځK,RXbR΂-$Nܭf,V{U-96MLyeOAt;o 5ˎ1poI4B.ƄG!-eG` !\zsoI54]Jy 3hn \q|ƴpiK帶=5M VafpPniu[φl J1+5gWqY4]FC.6vetҍ6[Ӷ 7d3TAv_=&P>a228d*v8 *Rzt.\H/{s{4_>ϔyzS_8}z/%_Qr [lMKnh@߄ xT*V<@J1P,+-yit7 V)4!aB 1$ wU0979Cn?aC_0ITbeቒ:" 8)Vd"ɳDCmW]HEWegF:ciU~{@GH`QQK" y%9r\&I>zl^ԏ]Jhn,+(Մd$rq$:Y-A1\ + 4LV&Cl *򂹜mm23[$ 0|YCLJ&s8-RKvs3x'V0Iқ g(7ʥ-E9ur[[^7A33K_z%=iOנ32TZ)ǚcبlʔjIm9/ؽr`%uPw:vNwJΗ\jJe_'#:@QS Frank B. Brokken (f.b.brokken@rug.nl)

c++-annotations-10.6.0/html/memory/0000755000175000017500000000000012745054221015743 5ustar frankfrankc++-annotations-10.6.0/html/memory/fswap.gif0000644000175000017500000000675612745054221017570 0ustar frankfrankGIF89a """&&&222333888DDDHHHUUUXXX\\\fffhhhpppwww!, $di%lptmrv_㻠GȤrTBPYsJ]>VuKfܰfp9Bw{-x}ߟo}~/x|iyf_{j0Xs,QB;ǝū9˥vבգ:σpӢ:"ݽA,4' ;\P.(0IQoTbbLP!@raxd%DE$!@v!6H5ojidA" /iGeAUYsװA$,r*D (ȝKݻs (!AL8޾A.HhOpv&wl׹ugL@Zg"aA RLZj Si hx0@ڴޮ='"Rx>Iz݈r$` `@f0T`p) dvȂ2 IƷBv-\JA+-X@NC DP>"DO@Q"g6hC\b[=6l=- _`i-w-@7Zp&W*tH^tTp.Tp`S9Л(8½+@ȅn+ Bо= XN`w1Hxc‡on £hOel @L@ As1'iTrT'.[_xF(6X%W`N`f6EqjcW1PY"D I3-gx{G(W98$ H`d(9B8ʕ0,% 9Ea65 'T>TV'AHᏖ]ptCxđɾеCn3lCS$zlXt$qf!@s# \v HEc$;fN'uxmez+&RPodiAIR./<(P0mF'lRtۦ>&@y3RԕE_Q^ Ǐ2X<'J!aYBt mY%%+- OOJX3/5LV3Zϊ!ȇP d z hGKҚMjWֺlgK6nw[K}(Z&/j1 siel]XQ fw_Uf 㽆Հ㦷ms߫*6KFuuYOh Ac#*B OAMuבdv I$>a TګCxH24(O7c?},ĉ[Lb.NCd8BG/|pY/sk<ƿ}G_o۞w}_" W\~|0Exw8\aL0azh e_ R&***-.80x4 7X$EփuY:X+fq5rAxHJL؄NN.*b."2}/jQ`///~0`TPN,3:i1fwql sH,02!d2͢98.L}&3xH+6H$ O,eWӶ4[=t4V7R|Y#61^6[7es6i#6(scF#0xC 4Q#@QSscRF(,e:49C5%809g::l=s#=3;0U=ijƃ<1B%;H=sMC>#Sɂ_sA&>^PM2cߤ:M%3C>4@NKj)G8N OxC?v,"ƓOStm,E%4!C,PCpCxkDœDyK;N$E?U,#+c4^.pFqFmdQtPNFtz$dPGbyq兽-`<^B,INr),PI3Kid u42}8$J@ cf+:OTM#ryHt3dpS?MrSӔ9Hp)6۴ryQ,t 䡉2gO?cRZOOɱ 5dCiIP7"%iK:~(,!/H k#3S(tx9t̓~gw+^|$ 5m H A(]9  ~bt` JRݖw!b6Gg_HqBMh߆7IA#$7N\QGdu'åflR 'V}] 3Rm>&xĉsv6hg.栅h#.ʨņii)V)u kBjӕF8i>7kdZ>\ ,,rylƀ,^mféY--*+n&ZUu{k q;1/\:N]k(׿m TKqt1XeP(7Z˱ a<lrJzź0(g҅8చmrKsd|sQ{sH+ So[q9I蚨dg5!M6P/tz7$2`GgW7Fk%>ʎG>}饥:w> P%]ڇMI'5L{؅U;T^СP{*^.&2I2bjS. XymwO>5?x ;/)tׁo㓟6Pڃo٫ ;!~?h+af*'3no2L Yh*oAP6 UO:CH'tT#-s4+N&l4gQ•e1qhܜٸq$4-2ы ̣0ɑ=lO!f:,cG[U<"7EbCxԘtJP"r&I!c T͜jlrzJY.G´_ 1ìׄYdQ&hvnilfpn%2ωtsl;xs= {s?ۙ t-AWS3 ]&7 Q3-D+5Q%h _c,M R^1H^L?"LVc iHdYC@e '1\T^d#GXhHM$#yH@TnP[9`Nƥ KUZ0Ce=jLjWB3b9yNrՓ(lZjAZ78UW5TJvEBZUγl(A"جER!|eBVO 3R^1xq*\]s}JӭnkB7ڕnqwk7]/{7(}י0_׸Aq٭|a N [92^3?.ĥ-hxbplIIq}V lH@э% xِkİ.K1Zk Ϊl< Y(&A>@w\pa%\:en(gs\6ֱlt:(DgqG>͝㖎yKNRC~fc$Ct ,IZ\,F{+7)|^gľF#Jp]>ĶalLtoi蹎w 'VSy1ξNk7[gg )uj3T~ي6S/sz[XcSsv _jgLvB zqfn7[/h{YimxZނ3Yo?+;Ϋ6Go\O֩?2`?U?~6eQ3{t\:gKW8[׀|rR3Rrҁ_zkqq"X~l GK81@#|$5z>(3/X{WJoCȃ$烛biFbOx8~';oQĄ)h9W}1@h~uwjNa0sGHvړ'}xN$9s:syƦjBy{vByX8cu_Xm8*4c"JSh=DGqHٗ8wX(3{z9}g)(2H;xlH~8~ahh(􌹷X\nĨ9X{WV؉TXHVoXDs7xs( DqxNNe`- uYNIdM Đ )MHiPɑ4 !) #i'+M1yU^#'e_J0XRp6Vy-0ղ|0TP7YX(A.S`V9+iM []YW*aT'@Q^ieZXe3;UX^XiXcjz9 +tVBYeZc [Xw4|X1|<9)XlQyyb~VuxY YW73d k$Rs>L%SQUyZ ]aiMŔْR}f4]ڹ ՂɝSoH\_):" )N/eT T98_WɟXsJd9Ġ9pP3cD^q詠 7!jV"JE&@ԠU\.ڎ9M6 ߕwʄxr=i[XqWxu^ |q]Uf4')tnu ;ˎN ۷yC2úKtx~x[ Zm0{|yꛎ\|wIAJB\xhh,óF hbH[싴j_e~hۛC݋d \B8TKj6[L(2hD^,3 ȗ[LJ[ .)U F;L|ͺ1̬;lה<8 HܑiƯh8 |Bhσ {l5ͥQ >>???CgC66D44C;;D<<\==u66DUXfw.D.DDUUXX9DBffwwDDDHHHJJJKKKPLLSLLVOOPPPVSSUUUXQQXXX[[[]ZZ`HH`\\c\\DfDPwPVfc```fffhhhmkkmmmrlldwspppqppvvvwww  '..''  ??..<<>>N ~__ll}}__NN^^nn~~2!}}C̍сș̦!, Hi(3ȰÇ#JHŋ3jȱ-1 rP3@:\ɲ˗0cR$ڴ;&H2USϟ@ j@%ʴӧP'.u5ek!I 13v5_HBUkRk~Jݻ& X5kዚ26Õ>òĮ]vځ] ZⰘc˞qz}&Uo̽ m˄ y؍9i{v%b.ugnv*I?*DU$e=BS| 6F(gUhfv.8!$h(j("Eb0(4h8cV@)DأE?L*yLI6)T$.\vY.^ ӏZzihE?)Jm/͉dt։{ɒzWk'k$zD"$X6h}B)XzDڧ2kj(=zjDB'U-*d'p+D&(g똙k,6,:cH,d/ E;дV{mW֭ր됝x,\i*n𪅮@2d B򻬞,BܯAvv<lp)M@IfE`/[œH T 7 2fb(CjZcl{WNˊB;p[[\-fÙdۘz}vk[wnmt-jrύ~8څSD!|6>ge[.vW)y .Ž:1误.~ή;Ȅ(a/o'|:n{ܾWogwO N觯E<㞐 ?+#>Tt '7Ӆ#?7?Odg ..Z Z H*A }xPȂ HpQG8~{2\2axE+7 r:(rDP;DZA  @O(x$DF78\ؾU`_"H2Fq2 3f#):j2"#ԧ5,S`X," :P*g2҆5򯞐*%k@8nOreݔ K](*RQT(0E z`[20czD*yM > t< Nf:wع'%+*KLCyTҜDv=> (H|I?;$< )$䣨"$VQSdNE 甩< ` 6!ϓrV1Ag44TCj:.|EZq(@: Jِp=N')pRԫ_ R'R*Qf7{rLEWTt|i>Rn~5!l.hLSIخB5aXG S%V4u=_+` p+Zgf%(wRָ`r_Kوbw_ 5d>Pq9 $h83*}_, C\AI؂DK0.I@NVD&ڀ&Ű*KkE*XbsXQxńa"Sob/n jL:Ϲy&$ܺyπg뾻%Zv气E|]UwBpӜ-9. W]25Q6WN5'=/[Wak_7jPv3MCNիuq-c:ɮlnztmх_tRS(68`Hmg/H,I5P2@0 8hU sQS`-PSP `aaQ!67 Z̀Iy17d /$0:C)66q (P@R1Hp@clu_A"! & F dsYAk /Q/b&Z" sz>ٯBDmЧm?&آҬc"Z۱ ihY"(k! Y9Ph8O(6kb278K_;8;)"6A{HG*?7G熭vTr'lq>16;,bS`PK֒-iہ>3.b.u  b XY/@0ۦ0P1K&Y+s-U;2k2;336SL@l.TI9?H2Zh>jlToL@dLZLLYjv+lK} ?J$Kb!\*HLTUUOtaYHGD>?Mޔ>Nc&1{PhʊLRAR+eX”|t\(>PQ Q Z PN p|U@̽5uS %#UTXWU[Xu J܁>VݴZ|WK i\g^Q^ y  7=.2ͯ@]u]Z۵_3,AN5 F af6 Ŕmƀ q=b>u>B-`dMOA6c:VRt$G.c%^|qٚ"Fb&E(*f-ĔhVeeSt-AJdT=3%Aٛ} νx ~= < rNL,c9<#\>$~:5n1 0r '.q#V;껾nP;@ގf½2-2~Q 9nLJB]rWkn Q MOP Q 1'KKN H`QCC1"Ymmp`'[΁>OM  @p@ C.l 9^0= "r \@a mľo֍.#P.^rg^(D>y Xn 3Gd׊f Нhw8֎3 v.}duSt!ҁq(%{')ρv j;~W6*@πJӞg@Ht9;ZN7P4'KYy[^||b/sd iM'8Xw18V}=X1I{/rkOm,Iw?#TT;y?Xe4/Y-Ore_W&Oo$#[J 6MЯuF*zX u-8gψ4H.!M@B Tذᢅ4I|PF3BRH%MDRe-;fQL0%NF#B]}TP5tّ5ꜙqU^ŚUV]x(THǖ mݾW\uЦҊE0#B… FXbƈc}^_ƜY3Ȃ3\rgɃ7F5ʕɶvm:lڎ_~놶\pōG^i®;tխ_nv5Sݣ5nɗG~2~=7W_~ǟ~n/C@vC @'\@D{6CCODD{6_ʓ-Fo|q-ñGQѾ$1Y\Hd߲OI'rC(7ڑB-K/9K1$L43M5TM6߄3NݔUN;tN.j׀ .s[oR{FoL򱽻˛? _۫7-Z?~BWz'8!%<aNHa^anȡ^}]A\f!@2Hc6WFn*6ލJ.dpbT%N~ f"R"j]ZiN(fvI&nYjƥo'ht9* 5ygboty[-0IH'>X**iMR0 ec '*u|h6ůjKŠdvΙjF*^%PV败mcTˮRɪ'o N`/3o|Wku KTſLqoq)9U (X0mW$?Wz}.43=',3BLt"UV_-qN:m

4~/Ka y^J.㎋*ᆎ90IC.?x~;좓^R>^󾃀T|K{񋮮;˃<5~ONe^݋U3~~c~vbOPc` wk`ՑiLO( ^%4!NPBЅ]Y@pm1$ >=kA MYGZ -hOlSE Mq 6 YEqJb|(5 BKka0Q~`<ԁo{cr QX^ˏreH.#ֽ[},$%C)gd: E<_oά, iZ҄*'/{Qp[H3T)FLR3_ޗ6A_lJ){5\(?jԛPzKؔ2a. 14-o NT1wƈ-nAQ7XW};|@ޣF(`Y`JEF'1RrߪZ! ^b%͸@gd$ӕOZ>VgJW[޶m.Z-i}H5y+y b9Dv '$~OȄ$0OVNCՉ&߬An~|,ɼ.D*J-oG[|o _9Iz݀BY4#߮t-GWv,Gn?h ǵ0z}QNqto6ta{F*ss;.wgw*-pW|`Ѿ>܎?w0 Fl㧌[پ\|tyAyWa;]C}BCB\=O|F:??IKί|!u<:&wz7SW~ f)USU%6Su@X,A[X7UHb>UZPUYYXWX#ϘXW\ Z}٤PcYZYvȐVY]I4UgHUZ匠ōI% gl8iHEiGɓ0hO/e0@iaaNYP X #F~]^)` ^u#mA+Q"{gBjv+/"a$'6va{9 MoY6%6_bK#e 6hNzƘ?2iҕ`h'a^ْ7a3_ɓ֎tvqG`o™z&qK)絚Vd|y]`g~pNIyUjQW(Be rWkEC7 #Sٓm9vUÝs؞ 9=V&T;7tyylY# {fK)mdö h)ʡ*$&  #'ڢ):+:,"plA'Z\֕<*3;j^9jy67L 246%:5WN*\:9ޔzU(o zEiɖiJv4UڤrVYz[J]T y }9nt@li`]jdɨmJhojN󧂪vsuڤ2ag3eykP`V&qj ]گ{ʯ0 !k 2 K'nYmZ:+ʱa ۳%`\*ˉsz619b8미Q0W+Y& W+QWG[SaV0)d<˵lKn52/'sd[d}5m۷oq۵Z{9DxKzukK; ;[K3f8Kk{ uKĹ1K~oA :XT[ATqXe2"kP#5+Y. H̨F˲(obcRzVV( ÉM֘뛼7uFV~KS4+KtpȴO2Kz;z[Gĺg۹lk[M#׿FK 4);+,ʿk8w+#ƀM,Nܱ8נI<և'ޛ6.U  ךWPܧfzJk]ԯ~_zR{گTk'՚rtU4o~Һ|=ǐ ǎJkܟ2l3K@w C++ Annotations Version 10.5.0 en-us EA989A949A Frank B. BrokkenThe University of Groningen9036704707Computing, Internet01/10/2013 annotations.gif c++-annotations-10.6.0/html/modaye0000644000175000017500000000010512745054221015630 0ustar frankfrank c++-annotations-10.6.0/html/functiontemplates/0000755000175000017500000000000012745054221020177 5ustar frankfrankc++-annotations-10.6.0/html/functiontemplates/selection.gif0000644000175000017500000004337612745054221022670 0ustar frankfrankGIF89a|    "" "2   """ #'#(/3"!3'&(+0+-1.05.38/5?222333346888;>_16T86_?=g*)!C)Tp+D"2D,-S)6D22F92E<*]2%m$1d #z#9u&aIreat65:@9P몾y <%X;V]%EZ.X.k .k 1YB:+z>jk@Ǻb@Kb1Z^+9dɻ<-Y @^H=VEiP|J5c24jżp @ؗ ģLlba|bq,T'(qn Hͫ3c~{6s`W<\CJiaִ BVJ4@?[C9!iKk%ҖkZp"͋ipM@uW ̍p,Rht%T{v)$Ưr#KͪIlrlRHesI#ȦF8R0? ߇>+]  yMff`2H3JWej1קʇ%uвe]NT3ZJ?(OՒէ1]:әLIWv]%[ ъnc2=8N :a/hܱɘɦYTB3LeF(qθBoJ,jd:wqHjrT| (U(eqhDә-4¨ ѣgaf.$[DprB(KgNaifRjL)l MIg=!YNuXERR[ES'=7ѧ~4j5@UzS?I <ҵ-lI!:**iiB3S#V;ƨU#VE*Ɩg-kCIы~MIwacבW`ȥ P$8c6ʱ=BA bjwZyC-˕ERSUnqWJt!ja 5VUYsk\@+UB BL*l1@8Wvbx >R- xKb 6UaKW*p x \JZӕ#) 4] 'l͵sov$EW,aOl4l9C]@6TTdOvD6rVܖ_mZxVzgb]`p[ dq a6gh@;.K bH6>48̞nKuo7ѯx3b8L^\WIXRgT9v˨cd;o]vT}brǢfk[ʱkh~v_t;{\Ab{xwKڍ|s0Z#l Zf g% ko*Yq@|c! +t%/9zN>\f"W>q|aL\rs8Kr'}*D.} š硓F_3Y2wL.+ao&\dMb'ozޒEr|)M&kFL@~Ao(ٻ$nO;H+=GS!zЉk%K_uÄmaYk\ywޘGPDyʑHL]d^%0fqx/4/arW}{λV#y/^1tsÖ΋mx˩G+GCU\"5e:59N}H0$<!& 9 MG}f}"}3ga{Vq/"<#ģ& 4,?5)&F;i'm' TJ4>a;FU5Q,&om7%5TxC<u%cS2T#!e6hA>G'z$XgBYX= ?T5ZcDU6"7b@?xI'g_XEτ?bM5N8EuA0؉X8 PSn5GĒ.PM.ƔA^S$iԊU548!_wx@ 8XxpTX\|r8xKE؎艝(Cuu؈B%Ex|gJ2PY]T`\YUOTqO ֑ AąJeh3Nm&$ D{ҋ+}bY/IHVX@"YF JQ0I`L %]YLdVX@qL4VSO26*Hx~6YSa’@9/1"9Ӹ xQ@QiHŨJKbFX1z" -`EpF[TEd7Cd/I3C(rcpabYe7}qmuuW5TRișƩ(8cb'03cwcbӁIJkakpb!6RHd$ NcteZZ[a3eeX!$)5f>X E4Y7aiiV\ J!Ra!EVk&h6Xla.2i3[R&2Pz!0r/;]-j#z"0;祆rȑv¥gJ&pzqfʐ¦5vs,uzuQ~)q_0ZI:cC5.b~[ q:aѩ)R, \ǪzrA21Q̚j~nZ71Z=YΚz9VUJn꫙Z2҃U;)ʮrٚixe*٥:cqƷc:ʬ[1v @I:pQ@V-"Ȍ*ڱ)$-0K>qs3𮷡2#2l6myJ7&% F SXB[e8,)B{Xvٷ.p8sKg'Y041'K(iG2 GH4Uسh2=sUz(kʪ=K"%NsH4_4iT"cCbzR!%c3@5A3lJ{)dU!&ZTdG!b1,µR_W&gmrQRZ] /oI#+W$;B2bC*r!G###Lbr/u!#/γ}pZw- R`O+)SUW*&ho0XR` C<@BDt3UͿa*f/CP6!u3O5bDՌ"? Zjx\aSB(>F U/R ]DGɺJiX\}do6eYqZΥ *g?Nݧ#颸uր:-!a,`kdi&cI 7V?*aBZaݙ} q&pqHN*P/KSΣA3itY>^^_Bd: dRFmn^p%{RU~Mmyn]~v>Vw1^芞v)1^ꦮ hsꮎ޿We뺾R>^~Ž =0^~؞ھ^~^T=T;~)ߨ_? ?_s " ?&(%,.+2?4o1_8:;>B?Do_HCJN/LR?4TXoV\^b`?f^hljpr_v?tz@~֘ 9G{}_?` _h_08OoCP oUoH@ȟ ˿uR֨?osCP!z_G?LQO5yo1@ DPB >QD-^ĘQF=~RH,RJ-]SL5USN=}TGCETRMiuUTU^ V]~TkXe͞EXmݾ([uśW#]}o`… :bƍTXdʕ)FYɘ9ZgѥM.Kj֭v[읡PƝ[MR"\pōG\r͝?=ҭ_Ǟ]vV ^x͟G^!>_Dp_~0@$@D0A'b%0B '9 e%vC?1DG$DOD1EWdq'2 gFođOTi2H!|Q!D2I%C,2%2w4RJ+&S1K/TrˏdL33dE1IM9dFȤ3,j|)B jZGt1wu4=MKpX T:cZ6bGֳv-d[^ԴnZ!& G>'lަ"*7 &"x`Cp7 WC<( N%y#q#@ǒmtn˺!DW!,$fOHU: V]\Jt؈./bhypIϏ~oG 7ZT/w9kۇڙMtCDLrJ@tizdQ1" :bc %)f16(-1@eP('1Q1l ~@,2b\? @Ù12j? T kR$[!:; ^{BiP0  )*"% oɚ»Z3BêbPhA% 5i*9 aPpK0C*/D0tџB= 5d"gU(C0* {A?>)A?fɉ+!ѦJX1QB,@cQ)n*y(!sɟF1? t_tˮ5|* /΢ٻҹD},y$r-.J&Qi#<B<>J,/A-~0K yB#jQ҅O(+=RI4I~ rGƅDC" ѯ?0"31E9DJSC;<}G 1\dH,J(̣,I;\(Fcbǡأ$9 =&R9ɼ"(૬µLD³tѴ7z!tʊiKI KHC˗4KjͬKY"˶̕:MNd)k@ɖ?1@*EjlOHN4%wyrOLjJO, !_LqLdy%eA&qI쒢Ъ޼6N -N۱޽|؄x]sOc=W[ֻ-3q?1,DXS5Q_9=/iP-m2 ?)VmT0>ZYu! f Qkጡʋa ~a` លaWaCk !B#6n"Vb_'$vV,>=+6\'bb,c3UcI)6n5@5];<=>?@A6CFDc(cuGHIJKILNd(bO&R6SFTV"% bP)Z[\]^_[N/X`6cV.)@fvge=ic}Xލ3PmNE XgP3s q r sfgP0y w x yg{gg灶WUP(8hH臦 Uhhƈh/~ 6i0(閎v i2vn Hu.j > e 9jXhjxg.ejj_S@(>vnhFl8/xkÐ릠wk0in}~lV좮ll63^bXE@.fmj|.[@EX>F[(e ^ ؎h;ھގZ(c8 V .nkPfnn N f(b@FX?hE@gF .oPlPo՞X6i> xiaЋn'j7 _XoYIp /bm  p8jWm6S R Su,`o~Z7 Y ZuDJ(pfGb _/`hvgOn knp_g׉hsq"vFP` ww"/b@hzo7r~7rnt{|O7s2OTwx@A/gx'xs8ޞ픏oUyByPkyxxXV^?sz(z^gkz_hzxz v zpr_v {0{@{kv  {o t}rG|{{`"rhF_o |/j|}}E~G>?t?t{_LjxI}=i~}y7! -؂'7GWgwȉzPG*pd710R,h „ 2l!Ĉ'R(ƌ7r#Ȑ"=S4enŊh^?P¹`r%;l&wrl7+Iş (NK7 {Ϯ">f>Tp%=^Np|;  ;@'LOes=UŠ`P$  \]x{ U E|NX?ʬGt'8`|r&Ewoaԅ@@!a@ ɦI `C.tA2ls]&ACN&؉bߠ@DۅE980PvtQ `Qu$(&F06M8^O =wJ.s‰͢=OT.2GhΜLl"'L\hڜBteAO!R%Fюr4diE}ȓb(Y)Ks4 :#S| " FD5*T-ӟWKuMԨr5bSI?*f]=+þeI!knֹ̊'u}ju ֈW6|դ h\w}uR29. JLh{Է( l},ênTkE{E=jOsMGNi[V=5aX\ز~psⶩ/'>@ g*!JA|\8KBD gi NsNh?~c`s f7JYqK*W~c. )|D_,3 D!ŰχU8SgA ȃ.{3Əu]4[RENL*y!tmb- *?+E&ȦE:q![m~CJ=^ٱY,}Xf[监 ;mWp|2Y4&¡as:ZYtƣbwG+ SJh.vz̄Yh@Ӓ>.[gZz]I=7 fEmSδHlMK0veJO~||.Y&nsȴ'QCd=b$nԝ.ضc+Kэ kMn S.^Zwx>r8y|\_1^lx>N[ 2+[%¬lsqkAWB^?IG#ݶ/q:RIdZf񡝞h랡c.[Ѹ~Hƹ@aܯNѵs}{/xzه 7OLyL.'Q/Eǭ; r-?2@̷'ԋYpy2ԡOԢ?Gӯ~ZЂB8@39h s@.Q,בuB@ @!pH8^A2 'tB/0OB I_5Kr#B22B8 8@\ -p#` '`Y*d ~ߗU~ *!!!0'؂1̅2Ba[m!Q\ z_!F/A6I`ɡQ__m*:IOan&uB>`iIi&'F ~џ_  ta 0BHU/n/.0>a/``.6j z߈dCVE@+Rd,c@$j_%2GDD02,F ))J.3FD#M#Ԣ ⟃ODH68=&1>`H7$#F%M]Fj Rn "(V:?cMdE&[FV>ڇٌ4%S\~I^BNb[GF4ڤ"rG)_P6f5>$JNJ~፥<%9r%_fTn_U^RbefV֣9H-"s`kY#Z%m#;UeEep.Wf# fEbsE:gc60dv] FbR!(PRy:Fa.ixdxigh@)Nfd4#Peg%!!k\&2>6ycfmnq_p;tg:c<F\gufD}`wEInDzeZghF&hY!h~n_(Qd)钂J_%ncST VH@j>ņޗimΟ BNha|V֩)dtA)@*&.*@yVV^*fn*v~**B <*\Hj*ƪf'Ϊ**S ++&.+6+@ 8N+V+檯n+v^*. H+++ƫ+JIN+Rk,,f>,Z*&^,fl.,jkvXȺǦ,N,QTƾ,Ƭ̚+iê.T),f*ά-kk,,ö4-Omn-v+ެV^u+B*X@Վ:zޭ.m-Jm, + ,(Zͦ m)@Ԓl-ކ^6R*涮@*PjԪ@릂@FB)L*tR*Dݎ.Fnp,.v/v..+(/+$*6oO=r_o˲ 4@s Z7 7yZH`x#/̺?¶G s3W:9Bo5{Jŋ>اn}<.>;lgmKJ,Kv36n_b{/ .@(a5p,9X2@%Z"cGA鱄3'QT I/aƔ7qԹ'LH lgћ4U)OF:jUWfպkוUތ;lYcbQ};WlI*]eA#pKH,ذAA/hPI}30 &@$}Wy_@+ 6p0Y0a{Q8fྉ#ALJޕ>zuױOK{wDo7oz^`a/Llk @Fod $^/' %˯"!NB`!HVp 9IO.iq4i;x1$7h J @.b:a d 9BIl+1,wK L`De/L{M,J TAݑC{l"%Hh&' 7@)!s͗2ud`NI6TLP%q=ܓ)_I-XcRԄCg)SVs$#TLU:qVUYڗ$ &]y3w፷a{)nnc MM]4wԘY V\>a"DlbxA^|I.dVn_s9%iˮrS͚xfHX]Cn駯䩩F4V\-雘Vy`AjsŘ@C݄mOdAE]Ojn*ksmKs@7$3 0t E#/tgKQg1tX뱗ǹﾮJ _/8u{eg_ʭoi> q7- A e%1A nAB%4M@)vq a@N5 =D!P:MtRLUE-n]F1 јF50 ;c++-annotations-10.6.0/icmake/0000755000175000017500000000000012745054221014720 5ustar frankfrankc++-annotations-10.6.0/icmake/examples0000644000175000017500000000341312745054221016462 0ustar frankfrankvoid tryCompile(string source) { string obj; obj = change_ext(source, "o"); if (obj newer source) return; if (strfind("koenig4.cc" "personconstr.cc" "stringsmove.cc" "binarystring.cc" "stringconversionerror.cc" "binaryambigu.cc" "binary1.cc" "virtconsorg.cc" "refwrap.cc" "ambiguous2.cc" "ambiguous.cc" "buffer.cc" "perfect.cc" "basename1.cc" , source) != -1) return; system("g++ --std=c++0x -c " + source); } void compile(string dir) { list sources; int idx; chdir(dir); printf(dir, "\n"); sources = makelist("*.cc"); for (idx = listlen(sources); idx--; ) tryCompile(sources[idx]); } void examples() { list dirs; int idx; string cwd; cwd = chdir("yo"); dirs = strtok( "intro/examples:first/examples:namespaces/examples:" "string/examples:iostreams/examples:iostreams/cc:" "classes/examples:memory/examples:exceptions/examples:" "overloading/examples:containers/examples:" "containers/queue:containers/set:inheritance/examples:" "polymorphism/examples:pointermembers/examples:nested/examples:" "stl/examples:generic/examples:functiontemplates/examples:" "classtemplates/examples:advancedtemplates/examples:" "concrete/examples:concrete/examples/monitor" , ":"); for (idx = listlen(dirs); idx--; ) { compile(dirs[idx]); chdir(cwd); } system(P_NOCHECK, "find ./ -type f -name *.o -delete"); exit(0); } c++-annotations-10.6.0/icmake/pre0000644000175000017500000000051012745054221015425 0ustar frankfrankvoid pre() { string files; programs(0); files = stringlist("", "yo", "*.yo"); cleanup("paren", files); files = stringlist("", "yo", "*.cc") + stringlist("", "yo", "*.h") + stringlist("", "yo", "*.ih"); cleanup("tab", files); cleanup("trim", files); exit(0); } c++-annotations-10.6.0/icmake/programs0000644000175000017500000000167712745054221016510 0ustar frankfrankvoid programs(int docs) { md("tmp/bin"); if (docs) { if (!exists("tmp/bin/htmlindex")) { chdir("src/htmlindex"); run("./build"); chdir("../../"); } if (!exists("tmp/bin/rmindexlines")) run(GPP " " CPPOPT " -o tmp/bin/rmindexlines src/rmindexlines/rmindexlines.cc -s"); return; } if (!exists("tmp/bin/paren")) run(GPP " " CPPOPT " -o tmp/bin/paren src/paren/paren.cc -L" LPATH " -l" BOBCAT " -s"); if (!exists("tmp/bin/trim")) run(GPP " " CPPOPT " -o tmp/bin/trim src/trim/trim.cc -s"); if (!exists("tmp/bin/verbnrs")) run(GPP " " CPPOPT " -o tmp/bin/verbnrs src/verbnrs.cc -s"); if (!exists("tmp/bin/tab")) { chdir("src/tab"); run(GCC " " COPT " -o ../../tmp/bin/tab *.c -lfl -s"); chdir("../../"); } } c++-annotations-10.6.0/icmake/latex0000644000175000017500000000043212745054221015757 0ustar frankfrankvoid latex() { md("tmp/docs/latex"); system("rm -f tmp/cplusplus*-stamp tmp/_cplusplus*-stamp tmp/dvi*-stamp " "tmp/docs/latex/cplusplus*"); latexdoc("", 0); latexdoc("us", 0); printf("the log files are in tmp/docs/latex\n"); exit(0); } c++-annotations-10.6.0/icmake/logzipr0000644000175000017500000000071612745054221016335 0ustar frankfrank// names may be a series of files or directories in src that are zipped into // dest/zip. dest/zip is logged. // src and dest do not have to end in / void logZip_r(string src, string names, string zip, string dest) { list files; int idx; string file; chdir(g_cwd); dest += "/"; md(dest); if (src != "") chdir(src); backtick("zip -r " + g_cwd + dest + zip + " " + names); chdir(g_cwd + dest); log(zip); } c++-annotations-10.6.0/icmake/findall0000644000175000017500000000107412745054221016256 0ustar frankfrank// assuming we're in g_cwd, all entries of type 'type' matching source/pattern // are returned w/o final \n list findAll(string type, string source, string pattern) { string cmd; list entries; list ret; int idx; chdir(source); cmd = "find ./ -mindepth 1 -maxdepth 1 -type " + type; if (pattern != "") pattern = "-name '" + pattern + "'"; entries = backtick(cmd + " " + pattern + " -printf \"%f\\n\""); for (idx = listlen(entries); idx--; ) ret += (list)cutEoln(entries[idx]); chdir(g_cwd); return ret; } c++-annotations-10.6.0/icmake/readlog0000644000175000017500000000023212745054221016255 0ustar frankfrankvoid readlog() { list line; while (line = fgets(g_logPath, line)) g_log += strtok(line[0], "\n"); // add logfile entries w/o \n } c++-annotations-10.6.0/icmake/log0000644000175000017500000000014212745054221015421 0ustar frankfrankvoid log(string file) { g_log += (list)(g_logMark + " file " + md5sum(file) + " " + file); } c++-annotations-10.6.0/icmake/man0000644000175000017500000000061412745054221015417 0ustar frankfrankvoid man() { md("tmp/man tmp/manhtml"); if ("man/c++-annotations.yo" younger "tmp/man/c++-annotations.7") { chdir("man"); system("yodl2man -o ../tmp/man/c++-annotations.7 c++-annotations"); system("yodl2html -o ../tmp/manhtml/c++-annotations-man.html " "c++-annotations"); chdir(g_cwd); } } c++-annotations-10.6.0/icmake/writelog0000644000175000017500000000034112745054221016475 0ustar frankfrankvoid writeLog() { int idx; if (g_logPath != "") // do not store uninstall info { for (idx = listlen(g_log); idx--; ) fprintf(g_logPath, g_log[idx], "\n"); } exit(0); } c++-annotations-10.6.0/icmake/verify0000644000175000017500000000057112745054221016152 0ustar frankfrankvoid verifyrun(string file) { printf("\n" "checking tmp/docs/latex/" + file + ":\n"); system(P_NOCHECK, "grep -i \"overfull\\|undefined\" " + file + " | " "fgrep -v polymorphism/undefined"); } void verify() { chdir("tmp/docs/latex"); verifyrun("cplusplus.log"); verifyrun("cplusplusus.log"); exit(0); } c++-annotations-10.6.0/icmake/mark0000644000175000017500000000012212745054221015570 0ustar frankfrankvoid mark() { g_logMark = backtick("printf '%3d' " + (string)g_lognr++)[0]; } c++-annotations-10.6.0/icmake/clean0000644000175000017500000000054612745054221015732 0ustar frankfrankstring remove1; string remove2; void setRemovals() { remove1 = "tmp ../sf/index.html ../sf/cppannotations"; remove2 = "o indexentry/o aux/o"; } void clean(int stop) { setRemovals(); run("rm -rf " + remove1); chdir("src/htmlindex"); run("rm -rf " + remove2); if (stop) exit(0); else chdir("../../"); } c++-annotations-10.6.0/icmake/uninstall0000644000175000017500000000144012745054221016653 0ustar frankfrankvoid uninstall() { string key; int idx; int nDirs; list entry; list dirs; string dir; if (g_logPath == "") // do not store uninstall info { printf(LOGENV " environment variable not available\n"); exit(0); } readlog(); for (idx = listlen(g_log); idx--; ) { entry = strtok(g_log[idx], " "); if (entry[1] == "dir") { dir = entry[2]; dirs += (list)dir; chdir(dir); } else if (entry[1] == "file") remove(entry); else if (entry[1] == "link") run("rm " + entry[2]); } for (idx = 0, nDirs = listlen(dirs); idx != nDirs; ++idx) removeDir(dirs[idx]); run("rm " + g_logPath); exit(0); } c++-annotations-10.6.0/icmake/cuteoln0000644000175000017500000000023312745054221016312 0ustar frankfrankstring cutEoln(string text) { int len; len = strlen(text) - 1; if (text[len] == "\n") text = substr(text, 0, len); return text; } c++-annotations-10.6.0/icmake/run0000644000175000017500000000015112745054221015444 0ustar frankfrankvoid run(string cmd) { if (g_echo == OFF) cmd += "> /dev/null 2>&1"; system(0, cmd); } c++-annotations-10.6.0/icmake/zips0000644000175000017500000000237512745054221015637 0ustar frankfrankvoid zip(string dst, string src) { system("zip -r cppannotations/zips/" + dst + " cppannotations/" + src); } void zips() { system("mkdir -p tmp/docs/zips"); system("rm -f tmp/docs/zips/*"); system("ln -sf tmp/docs cppannotations"); system("cp README single/legal.shtml cppannotations/txt"); zip("cplusplus.txt.zip", "txt/*"); system("cp README single/legal.shtml cppannotations/latex"); zip("cplusplus.ps.zip", "latex/*.ps"); zip("cplusplus.ps.zip", "latex/legal.shtml"); zip("cplusplus.ps.zip", "latex/README"); zip("cplusplus.pdf.zip", "latex/*.pdf"); zip("cplusplus.pdf.zip", "latex/legal.shtml"); zip("cplusplus.pdf.zip", "latex/README"); system("ln -s ../../../contrib tmp/docs/html/contrib"); system("cp README cppannotations/html"); zip("cplusplus.html.zip", "html/* -x *.svn*"); system("rm tmp/docs/html/contrib"); system("ln -sf ../../yo tmp/docs/yo"); system("ln -sf ../contrib yo/contrib"); system("cp single/legal.shtml changelog README yo"); zip("cplusplus.yo.zip", "yo/* -x *.svn*"); system("rm yo/contrib yo/legal.shtml yo/changelog yo/README"); system("rm tmp/docs/yo "); system("rm cppannotations"); exit(0); } c++-annotations-10.6.0/icmake/github0000644000175000017500000000027012745054221016124 0ustar frankfrankvoid github() { run("cp -r yo/version.yo tmp/manhtml/c++-annotations-man.html " "tmp/docs/zips ../../wip"); run("cp changelog ../../wip/changelog.txt"); exit(0); } c++-annotations-10.6.0/icmake/removedir0000644000175000017500000000137112745054221016641 0ustar frankfrankvoid removeDir(string dir) { list parts; int idx; int dirIdx; list entries; int warn = 1; if (!exists(dir)) // directory was already removed return; parts = findAll("d", dir, ""); // if there are still subdirs if (listlen(parts) != 0) // then remove at some later stage return; chdir(dir); parts = strtok(dir, "/"); for (idx = listlen(parts); idx--; ) { entries = backtick("ls -A"); if (listlen(entries) != 0) { if (warn) printf("not removing non-empty dir ", dir, "\n"); return; } warn = 0; chdir(".."); run("rmdir " + parts[idx]); } } c++-annotations-10.6.0/icmake/md0000644000175000017500000000153112745054221015243 0ustar frankfrank// md: target should be a series of blank-delimited directories to be created // If an element is a whildcard, the directory will always be created, // using mkdir -p. // // uses: run() // if the target directory does not exist it is created and its realpath is // logged. string g_lastLogged; void md(string target) { int idx; list paths; string dir; if (!exists(target)) run("mkdir -p " + target); else if (((int)stat(target)[0] & S_IFDIR) == 0) { printf(target + " exists, but is not a directory\n"); exit(1); } if (g_installing) { target = cutEoln(backtick("realpath " + target)[0]); if (target != g_lastLogged) { g_lastLogged = target; mark(); g_log += (list)(g_logMark + " dir " + target); } } } c++-annotations-10.6.0/icmake/remove0000644000175000017500000000042012745054221016134 0ustar frankfrankvoid remove(list entry) { int equal; string file; file = entry[3]; if (!exists(file)) return; equal = md5sum(file) == entry[2]; if (equal) run("rm " + file); else printf("not removing modified file ", file, "\n"); } c++-annotations-10.6.0/icmake/backtick0000644000175000017500000000016012745054221016413 0ustar frankfranklist backtick(string arg) { list ret; echo(OFF); ret = `arg`; echo(g_echo); return ret; } c++-annotations-10.6.0/icmake/md5sum0000644000175000017500000000015212745054221016053 0ustar frankfrankstring md5sum(string file) { return substr(strtok(backtick("md5sum " + file)[0], " \t")[0], 0, 5); } c++-annotations-10.6.0/icmake/install0000644000175000017500000000221712745054221016313 0ustar frankfrankvoid install(string base) { g_installing = 1; #ifdef DOC logZip("", "README README.papersize COPYING README.legalese changelog", base + DOC); logZip("tmp/docs/txt", "cplusplus.txt", base + DOC); logZip_r("tmp/docs", "html", "cplusplus.html.zip", base + DOC); logZip_r("tmp/docs/latex", "cplusplus*.ps", "cplusplus.ps.zip", base + DOC); logZip_r("tmp/docs/latex", "cplusplus*.pdf", "cplusplus.pdf.zip", base + DOC); logZip_r("tmp/docs/latex", "* -x cplusplus*.pdf -x cplusplus*ps", "cplusplus.latex.zip", base + DOC); #ifdef MAN logZip("tmp/manhtml", "c++-annotations-man.html", base + DOC); #endif logInstall("contributions", "*.zip", base + DOC "/contrib"); logZip("contributions", "GGD.algorithm " "chist.html chist.pdf chist.ps " "java_cpp_keywords.html", base + DOC "/contrib"); #endif #ifdef MAN logZip("tmp/man", "c++-annotations.7", base + MAN "/man7"); #endif printf("\n Installation completed\n"); writeLog(); } c++-annotations-10.6.0/icmake/loglink0000644000175000017500000000012112745054221016274 0ustar frankfrankvoid logLink(string file) { g_log += (list)(g_logMark + " link " + file); } c++-annotations-10.6.0/icmake/loginstall0000644000175000017500000000155512745054221017021 0ustar frankfrank// source and dest, absolute or reachable from g_cwd, should exist. // files and links in source matching dest (if empty: all) are copied to dest // and are logged in g_log // Before they are logged, dest is created void logInstall(string src, string pattern, string dest) { list entries; int idx; chdir(g_cwd); md(dest); src += "/"; dest += "/"; entries = findAll("f", src, pattern); for (idx = listlen(entries); idx--; ) run("cp " + src + entries[idx] + " " + dest); chdir(dest); for (idx = listlen(entries); idx--; ) log(entries[idx]); chdir(g_cwd); entries = findAll("l", src, pattern); for (idx = listlen(entries); idx--; ) run("cp " CPOPTS " " + src + entries[idx] + " " + dest); chdir(dest); for (idx = listlen(entries); idx--; ) logLink(entries[idx]); } c++-annotations-10.6.0/icmake/logzip0000644000175000017500000000134512745054221016152 0ustar frankfrank// names may be a series of files in src, not a wildcard. // if it's empty then all files in src are used. // the files are gzipped and logged in dest. // src and dest do not have to end in / void logZip(string src, string names, string dest) { list files; int idx; string file; chdir(g_cwd); dest += "/"; md(dest); if (src != "") chdir(src); if (names == "") files = makelist("*"); else files = strtok(names, " "); for (idx = listlen(files); idx--; ) { file = files[idx]; run("gzip -n -9 < " + file + " > " + g_cwd + dest + file + ".gz"); } chdir(g_cwd + dest); for (idx = listlen(files); idx--; ) log(files[idx] + ".gz"); } c++-annotations-10.6.0/icmake/distclean0000644000175000017500000000114612745054221016613 0ustar frankfrankvoid distclean() { list extensions; int idx; clean(0); run("rm -f script.log yo/legal.shtml latex/legal.shtml html/legal.shtml"); run("rm -f html/cplusplus*.html"); run("rm -f html/target.shtml html/contents.html html/index.html"); run("rm -f html/cppindex.html html/cplusplus.index zip/cplusplus.*.zip"); extensions = strtok("aux dvi idx ilg ind latex log out pdf ps toc", " "); for(idx = listlen(extensions); idx--; ) run("rm -f latex/cplusplus*." + extensions[idx]); run("rm -rf src/*/*/o src/*/o"); run("rm -rf zip/cplusplus.txt"); exit(0); } c++-annotations-10.6.0/icmake/docs0000644000175000017500000001325712745054221015603 0ustar frankfrankstring stringlist(string path, string subdir, string pattern) { list lst; string entry; int idx; string ret; path += subdir + "/"; chdir(subdir); lst = makelist(O_SUBDIR, "*"); for (idx = listlen(lst); idx--; ) ret += stringlist(path, element(idx, lst), pattern); lst = makelist(pattern); for (idx = listlen(lst); idx--; ) ret += path + element(idx, lst) + " "; chdir(".."); return ret; } void cleanup(string task, string files) { list filelist; int idx; filelist = strtok(files, " "); for (idx = listlen(filelist); idx--; ) system("tmp/bin/" + task + " -q " + element(idx, filelist)); } void txtdoc() { if (!exists("tmp/docs/txt/cplusplus.txt")) { md("tmp/docs/txt"); chdir("yo"); system("yodl2txt --no-warnings " "-o ../tmp/docs/txt/cplusplus.txt -l3 cplusplus"); chdir(".."); } } void htmldoc() { list htmlList; int idx; string html; md("tmp/docs/html"); // cp necessary files for HTML if (!exists("tmp/docs/html/annotations.gif")) system("cp -r html/* tmp/docs/html"); // convert .yo to .html if (!exists("tmp/docs/html/cplusplus.html")) { chdir("yo"); system("yodl2html --no-warnings -l3 cplusplus "); system("mv *.html ../tmp/docs/html"); system("cp cplusplus.css ../tmp/docs/html"); chdir(".."); } chdir("tmp/docs/html"); // index.html is the file holding the // c++-annotations-10.6.0/single/target.shtml0000644000175000017500000000431012745054221017305 0ustar frankfrank C++ Annotations

Table of contents:

Contents

Title Page

  1. All Chapters
  2. C++ Intro
  3. A First Impression
  4. Name Spaces
  5. Strings
  6. IOStreams
  7. Classes
  8. Static Data And Functions
  9. Memory Management
  10. Exceptions
  11. Operator Overloading
  12. Abstract Containers
  13. Inheritance
  14. Polymorphism
  15. Friends
  16. Pointers to Members
  17. Nested Classes
  18. Standard Template Library
  19. Generic Algorithms
  20. Multi Threading
  21. Function Templates
  22. Class Templates
  23. Advanced Template Use
  24. Examples

Index

Index:

c++-annotations-10.6.0/single/legal.shtml0000644000175000017500000000215112745054221017104 0ustar frankfrank Legal considerations for the C++ Annotations

Legal considerations for the C++ Annotations

The C++ Annotations are distributed under the GNU General Public License version 2 or later (See the file COPYING distributed with the C++ Annotations's distribution).

You are encouraged to read the C++ Annotations and to share the C++ Annotations with others. You are also encouraged to include links to the C++ Annotations in your own WWW documents and you are allowed to publish the C++ Annotations on your web-site.

If you intend to use the C++ Annotations for educational purposes please let me know: the more people tell me they use them, the easier it becomes for me to continue and maintain the C++ Annotations.

Direct all correspondence concerning suggestions, additions, improvements or changes in this document to Frank B. Brokken.

The document itself starts here. c++-annotations-10.6.0/src/0000755000175000017500000000000012745054221014256 5ustar frankfrankc++-annotations-10.6.0/src/tab/0000755000175000017500000000000012745054221015024 5ustar frankfrankc++-annotations-10.6.0/src/tab/fname.c0000644000175000017500000000042512745054221016257 0ustar frankfrank#include #ifdef MSDOS #define SEP '\\' #else #define SEP '/' #endif char *fname(char *prog) { register char *cp; if ( (cp = strrchr(prog, SEP)) ) cp++; else cp = prog; # ifdef MSDOS *strstr (cp, ".EXE") = '\0'; # endif return (cp); } c++-annotations-10.6.0/src/tab/flex.c0000644000175000017500000013710612745054221016136 0ustar frankfrank#define YY_NO_INPUT #line 2 "flex.c" #line 4 "flex.c" #define YY_INT_ALIGNED short int /* A lexical scanner generated by flex. yyunput not compiled: by Frank */ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 #define YY_FLEX_MINOR_VERSION 5 #define YY_FLEX_SUBMINOR_VERSION 33 #if YY_FLEX_SUBMINOR_VERSION > 0 #define FLEX_BETA #endif /* First, we deal with platform-specific or compiler-specific issues. */ /* begin standard C headers. */ #include #include #include #include /* end standard C headers. */ /* flex integer type definitions */ #ifndef FLEXINT_H #define FLEXINT_H /* C99 systems have . Non-C99 systems may or may not. */ #if __STDC_VERSION__ >= 199901L /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, * if you want the limit (max/min) macros for int types. */ #ifndef __STDC_LIMIT_MACROS #define __STDC_LIMIT_MACROS 1 #endif #include typedef int8_t flex_int8_t; typedef uint8_t flex_uint8_t; typedef int16_t flex_int16_t; typedef uint16_t flex_uint16_t; typedef int32_t flex_int32_t; typedef uint32_t flex_uint32_t; #else typedef signed char flex_int8_t; typedef short int flex_int16_t; typedef int flex_int32_t; typedef unsigned char flex_uint8_t; typedef unsigned short int flex_uint16_t; typedef unsigned int flex_uint32_t; #endif /* ! C99 */ /* Limits of integral types. */ #ifndef INT8_MIN #define INT8_MIN (-128) #endif #ifndef INT16_MIN #define INT16_MIN (-32767-1) #endif #ifndef INT32_MIN #define INT32_MIN (-2147483647-1) #endif #ifndef INT8_MAX #define INT8_MAX (127) #endif #ifndef INT16_MAX #define INT16_MAX (32767) #endif #ifndef INT32_MAX #define INT32_MAX (2147483647) #endif #ifndef UINT8_MAX #define UINT8_MAX (255U) #endif #ifndef UINT16_MAX #define UINT16_MAX (65535U) #endif #ifndef UINT32_MAX #define UINT32_MAX (4294967295U) #endif #endif /* ! FLEXINT_H */ #ifdef __cplusplus /* The "const" storage-class-modifier is valid. */ #define YY_USE_CONST #else /* ! __cplusplus */ #if __STDC__ #define YY_USE_CONST #endif /* __STDC__ */ #endif /* ! __cplusplus */ #ifdef YY_USE_CONST #define yyconst const #else #define yyconst #endif /* Returned upon end-of-file. */ #define YY_NULL 0 /* Promotes a possibly negative, possibly signed char to an unsigned * integer for use as an array index. If the signed char is negative, * we want to instead treat it as an 8-bit unsigned char, hence the * double cast. */ #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) /* Enter a start condition. This macro really ought to take a parameter, * but we do it the disgusting crufty way forced on us by the ()-less * definition of BEGIN. */ #define BEGIN (yy_start) = 1 + 2 * /* Translate the current start state into a value that can be later handed * to BEGIN to return to the state. The YYSTATE alias is for lex * compatibility. */ #define YY_START (((yy_start) - 1) / 2) #define YYSTATE YY_START /* Action number for EOF rule of a given start state. */ #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) /* Special action meaning "start processing a new file". */ #define YY_NEW_FILE yyrestart(yyin ) #define YY_END_OF_BUFFER_CHAR 0 /* Size of default input buffer. */ #ifndef YY_BUF_SIZE #define YY_BUF_SIZE 16384 #endif /* The state buf must be large enough to hold one state per character in the main buffer. */ #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) #ifndef YY_TYPEDEF_YY_BUFFER_STATE #define YY_TYPEDEF_YY_BUFFER_STATE typedef struct yy_buffer_state *YY_BUFFER_STATE; #endif extern int yyleng; extern FILE *yyin, *yyout; #define EOB_ACT_CONTINUE_SCAN 0 #define EOB_ACT_END_OF_FILE 1 #define EOB_ACT_LAST_MATCH 2 #define YY_LESS_LINENO(n) /* Return all but the first "n" matched characters back to the input stream. */ #define yyless(n) \ do \ { \ /* Undo effects of setting up yytext. */ \ int yyless_macro_arg = (n); \ YY_LESS_LINENO(yyless_macro_arg);\ *yy_cp = (yy_hold_char); \ YY_RESTORE_YY_MORE_OFFSET \ (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ YY_DO_BEFORE_ACTION; /* set up yytext again */ \ } \ while ( 0 ) #define unput(c) yyunput( c, (yytext_ptr) ) /* The following is because we cannot portably get our hands on size_t * (without autoconf's help, which isn't available because we want * flex-generated scanners to compile on their own). */ #ifndef YY_TYPEDEF_YY_SIZE_T #define YY_TYPEDEF_YY_SIZE_T typedef unsigned int yy_size_t; #endif #ifndef YY_STRUCT_YY_BUFFER_STATE #define YY_STRUCT_YY_BUFFER_STATE struct yy_buffer_state { FILE *yy_input_file; char *yy_ch_buf; /* input buffer */ char *yy_buf_pos; /* current position in input buffer */ /* Size of input buffer in bytes, not including room for EOB * characters. */ yy_size_t yy_buf_size; /* Number of characters read into yy_ch_buf, not including EOB * characters. */ int yy_n_chars; /* Whether we "own" the buffer - i.e., we know we created it, * and can realloc() it to grow it, and should free() it to * delete it. */ int yy_is_our_buffer; /* Whether this is an "interactive" input source; if so, and * if we're using stdio for input, then we want to use getc() * instead of fread(), to make sure we stop fetching input after * each newline. */ int yy_is_interactive; /* Whether we're considered to be at the beginning of a line. * If so, '^' rules will be active on the next match, otherwise * not. */ int yy_at_bol; int yy_bs_lineno; /**< The line count. */ int yy_bs_column; /**< The column count. */ /* Whether to try to fill the input buffer when we reach the * end of it. */ int yy_fill_buffer; int yy_buffer_status; #define YY_BUFFER_NEW 0 #define YY_BUFFER_NORMAL 1 /* When an EOF's been seen but there's still some text to process * then we mark the buffer as YY_EOF_PENDING, to indicate that we * shouldn't try reading from the input source any more. We might * still have a bunch of tokens to match, though, because of * possible backing-up. * * When we actually see the EOF, we change the status to "new" * (via yyrestart()), so that the user can continue scanning by * just pointing yyin at a new input file. */ #define YY_BUFFER_EOF_PENDING 2 }; #endif /* !YY_STRUCT_YY_BUFFER_STATE */ /* Stack of input buffers. */ static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ /* We provide macros for accessing buffer states in case in the * future we want to put the buffer states in a more general * "scanner state". * * Returns the top of the stack, or NULL. */ #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ : NULL) /* Same as previous macro, but useful when we know that the buffer stack is not * NULL or when we need an lvalue. For internal use only. */ #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] /* yy_hold_char holds the character lost when yytext is formed. */ static char yy_hold_char; static int yy_n_chars; /* number of characters read into yy_ch_buf */ int yyleng; /* Points to current character in buffer. */ static char *yy_c_buf_p = (char *) 0; static int yy_init = 0; /* whether we need to initialize */ static int yy_start = 0; /* start state number */ /* Flag which is used to allow yywrap()'s to do buffer switches * instead of setting up a fresh yyin. A bit of a hack ... */ static int yy_did_buffer_switch_on_eof; void yyrestart (FILE *input_file ); void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ); YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ); void yy_delete_buffer (YY_BUFFER_STATE b ); void yy_flush_buffer (YY_BUFFER_STATE b ); void yypush_buffer_state (YY_BUFFER_STATE new_buffer ); void yypop_buffer_state (void ); static void yyensure_buffer_stack (void ); static void yy_load_buffer_state (void ); static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ); #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ) YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ); YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ); YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len ); void *yyalloc (yy_size_t ); void *yyrealloc (void *,yy_size_t ); void yyfree (void * ); #define yy_new_buffer yy_create_buffer #define yy_set_interactive(is_interactive) \ { \ if ( ! YY_CURRENT_BUFFER ){ \ yyensure_buffer_stack (); \ YY_CURRENT_BUFFER_LVALUE = \ yy_create_buffer(yyin,YY_BUF_SIZE ); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ } #define yy_set_bol(at_bol) \ { \ if ( ! YY_CURRENT_BUFFER ){\ yyensure_buffer_stack (); \ YY_CURRENT_BUFFER_LVALUE = \ yy_create_buffer(yyin,YY_BUF_SIZE ); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ } #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) typedef unsigned char YY_CHAR; FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; typedef int yy_state_type; extern int yylineno; int yylineno = 1; extern char *yytext; #define yytext_ptr yytext static yy_state_type yy_get_previous_state (void ); static yy_state_type yy_try_NUL_trans (yy_state_type current_state ); static int yy_get_next_buffer (void ); static void yy_fatal_error (yyconst char msg[] ); /* Done after the current pattern has been matched and before the * corresponding action - sets up yytext. */ #define YY_DO_BEFORE_ACTION \ (yytext_ptr) = yy_bp; \ yyleng = (size_t) (yy_cp - yy_bp); \ (yy_hold_char) = *yy_cp; \ *yy_cp = '\0'; \ (yy_c_buf_p) = yy_cp; #define YY_NUM_RULES 5 #define YY_END_OF_BUFFER 6 /* This struct is not used in this scanner, but its presence is necessary. */ struct yy_trans_info { flex_int32_t yy_verify; flex_int32_t yy_nxt; }; static yyconst flex_int16_t yy_accept[9] = { 0, 0, 0, 6, 4, 2, 3, 1, 0 } ; static yyconst flex_int32_t yy_ec[256] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 } ; static yyconst flex_int32_t yy_meta[5] = { 0, 1, 1, 1, 1 } ; static yyconst flex_int16_t yy_base[9] = { 0, 0, 0, 5, 6, 6, 6, 6, 6 } ; static yyconst flex_int16_t yy_def[9] = { 0, 8, 1, 8, 8, 8, 8, 8, 0 } ; static yyconst flex_int16_t yy_nxt[11] = { 0, 4, 5, 6, 7, 8, 3, 8, 8, 8, 8 } ; static yyconst flex_int16_t yy_chk[11] = { 0, 1, 1, 1, 1, 3, 8, 8, 8, 8, 8 } ; static yy_state_type yy_last_accepting_state; static char *yy_last_accepting_cpos; extern int yy_flex_debug; int yy_flex_debug = 0; /* The intent behind this definition is that it'll catch * any uses of REJECT which flex missed. */ #define REJECT reject_used_but_not_detected #define yymore() yymore_used_but_not_detected #define YY_MORE_ADJ 0 #define YY_RESTORE_YY_MORE_OFFSET char *yytext; #line 1 "rules.lex" #line 2 "rules.lex" int column = 0, nspaces = 0; FILE *yyout; extern int entab, minspaces, tabpos; void process_spaces() { register int ntabs; if (nspaces >= minspaces) if ( (ntabs = column / tabpos - (column - nspaces) / tabpos) ) { nspaces = column % tabpos; for (; ntabs; ntabs--) fputc('\t', yyout); /* put out a tab char */ } while (nspaces--) fputc(' ', yyout); nspaces = 0; } #line 482 "flex.c" #define INITIAL 0 #ifndef YY_NO_UNISTD_H /* Special case for "unistd.h", since it is non-ANSI. We include it way * down here because we want the user's section 1 to have been scanned first. * The user has a chance to override it with an option. */ #include #endif #ifndef YY_EXTRA_TYPE #define YY_EXTRA_TYPE void * #endif static int yy_init_globals (void ); /* Macros after this point can all be overridden by user definitions in * section 1. */ #ifndef YY_SKIP_YYWRAP #ifdef __cplusplus extern "C" int yywrap (void ); #else extern int yywrap (void ); #endif #endif #if 0 static void yyunput (int c,char *buf_ptr ); #endif #ifndef yytext_ptr static void yy_flex_strncpy (char *,yyconst char *,int ); #endif #ifdef YY_NEED_STRLEN static int yy_flex_strlen (yyconst char * ); #endif #ifndef YY_NO_INPUT #ifdef __cplusplus static int yyinput (void ); #else static int input (void ); #endif #endif /* Amount of stuff to slurp up with each read. */ #ifndef YY_READ_BUF_SIZE #define YY_READ_BUF_SIZE 8192 #endif /* Copy whatever the last rule matched to the standard output. */ #ifndef ECHO /* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite(). */ #define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) #endif /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, * is returned in "result". */ #ifndef YY_INPUT #define YY_INPUT(buf,result,max_size) \ if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ { \ int c = '*'; \ size_t n; \ for ( n = 0; n < max_size && \ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ if ( c == '\n' ) \ buf[n++] = (char) c; \ if ( c == EOF && ferror( yyin ) ) \ YY_FATAL_ERROR( "input in flex scanner failed" ); \ result = n; \ } \ else \ { \ errno=0; \ while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ { \ if( errno != EINTR) \ { \ YY_FATAL_ERROR( "input in flex scanner failed" ); \ break; \ } \ errno=0; \ clearerr(yyin); \ } \ }\ \ #endif /* No semi-colon after return; correct usage is to write "yyterminate();" - * we don't want an extra ';' after the "return" because that will cause * some compilers to complain about unreachable statements. */ #ifndef yyterminate #define yyterminate() return YY_NULL #endif /* Number of entries by which start-condition stack grows. */ #ifndef YY_START_STACK_INCR #define YY_START_STACK_INCR 25 #endif /* Report a fatal error. */ #ifndef YY_FATAL_ERROR #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) #endif /* end tables serialization structures and prototypes */ /* Default declaration of generated scanner - a define so the user can * easily add parameters. */ #ifndef YY_DECL #define YY_DECL_IS_OURS 1 extern int yylex (void); #define YY_DECL int yylex (void) #endif /* !YY_DECL */ /* Code executed at the beginning of each rule, after yytext and yyleng * have been set up. */ #ifndef YY_USER_ACTION #define YY_USER_ACTION #endif /* Code executed at the end of each rule. */ #ifndef YY_BREAK #define YY_BREAK break; #endif #define YY_RULE_SETUP \ YY_USER_ACTION /** The main scanner function which does all the work. */ YY_DECL { register yy_state_type yy_current_state; register char *yy_cp, *yy_bp; register int yy_act; #line 32 "rules.lex" #line 637 "flex.c" if ( !(yy_init) ) { (yy_init) = 1; #ifdef YY_USER_INIT YY_USER_INIT; #endif if ( ! (yy_start) ) (yy_start) = 1; /* first start state */ if ( ! yyin ) yyin = stdin; if ( ! yyout ) yyout = stdout; if ( ! YY_CURRENT_BUFFER ) { yyensure_buffer_stack (); YY_CURRENT_BUFFER_LVALUE = yy_create_buffer(yyin,YY_BUF_SIZE ); } yy_load_buffer_state( ); } while ( 1 ) /* loops until end-of-file is reached */ { yy_cp = (yy_c_buf_p); /* Support of yytext. */ *yy_cp = (yy_hold_char); /* yy_bp points to the position in yy_ch_buf of the start of * the current run. */ yy_bp = yy_cp; yy_current_state = (yy_start); yy_match: do { register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; if ( yy_accept[yy_current_state] ) { (yy_last_accepting_state) = yy_current_state; (yy_last_accepting_cpos) = yy_cp; } while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 9 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; ++yy_cp; } while ( yy_base[yy_current_state] != 6 ); yy_find_action: yy_act = yy_accept[yy_current_state]; if ( yy_act == 0 ) { /* have to back up */ yy_cp = (yy_last_accepting_cpos); yy_current_state = (yy_last_accepting_state); yy_act = yy_accept[yy_current_state]; } YY_DO_BEFORE_ACTION; do_action: /* This label is used only to access EOF actions. */ switch ( yy_act ) { /* beginning of action switch */ case 0: /* must back up */ /* undo the effects of YY_DO_BEFORE_ACTION */ *yy_cp = (yy_hold_char); yy_cp = (yy_last_accepting_cpos); yy_current_state = (yy_last_accepting_state); goto yy_find_action; case 1: YY_RULE_SETUP #line 33 "rules.lex" { column++; nspaces++; if (!entab) /* write blank if detab */ fputc(' ', yyout); } YY_BREAK case 2: YY_RULE_SETUP #line 41 "rules.lex" { if (entab) { process_spaces(); fputc('\t', yyout); } else { do fputc(' ', yyout); while (++column % tabpos); } column = 0; /* as we are at a tab-position */ } YY_BREAK case 3: /* rule 3 can match eol */ YY_RULE_SETUP #line 56 "rules.lex" { fputc(yytext[0], yyout); column = nspaces = 0; /* process spaces are ignored */ } YY_BREAK case 4: YY_RULE_SETUP #line 61 "rules.lex" { if (entab) process_spaces(); column++; fputc(yytext[0], yyout); } YY_BREAK case 5: YY_RULE_SETUP #line 67 "rules.lex" ECHO; YY_BREAK #line 773 "flex.c" case YY_STATE_EOF(INITIAL): yyterminate(); case YY_END_OF_BUFFER: { /* Amount of text matched not including the EOB char. */ int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; /* Undo the effects of YY_DO_BEFORE_ACTION. */ *yy_cp = (yy_hold_char); YY_RESTORE_YY_MORE_OFFSET if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) { /* We're scanning a new file or input source. It's * possible that this happened because the user * just pointed yyin at a new source and called * yylex(). If so, then we have to assure * consistency between YY_CURRENT_BUFFER and our * globals. Here is the right place to do so, because * this is the first action (other than possibly a * back-up) that will match for the new input source. */ (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; } /* Note that here we test for yy_c_buf_p "<=" to the position * of the first EOB in the buffer, since yy_c_buf_p will * already have been incremented past the NUL character * (since all states make transitions on EOB to the * end-of-buffer state). Contrast this with the test * in input(). */ if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) { /* This was really a NUL. */ yy_state_type yy_next_state; (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; yy_current_state = yy_get_previous_state( ); /* Okay, we're now positioned to make the NUL * transition. We couldn't have * yy_get_previous_state() go ahead and do it * for us because it doesn't know how to deal * with the possibility of jamming (and we don't * want to build jamming into it because then it * will run more slowly). */ yy_next_state = yy_try_NUL_trans( yy_current_state ); yy_bp = (yytext_ptr) + YY_MORE_ADJ; if ( yy_next_state ) { /* Consume the NUL. */ yy_cp = ++(yy_c_buf_p); yy_current_state = yy_next_state; goto yy_match; } else { yy_cp = (yy_c_buf_p); goto yy_find_action; } } else switch ( yy_get_next_buffer( ) ) { case EOB_ACT_END_OF_FILE: { (yy_did_buffer_switch_on_eof) = 0; if ( yywrap( ) ) { /* Note: because we've taken care in * yy_get_next_buffer() to have set up * yytext, we can now set up * yy_c_buf_p so that if some total * hoser (like flex itself) wants to * call the scanner after we return the * YY_NULL, it'll still work - another * YY_NULL will get returned. */ (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; yy_act = YY_STATE_EOF(YY_START); goto do_action; } else { if ( ! (yy_did_buffer_switch_on_eof) ) YY_NEW_FILE; } break; } case EOB_ACT_CONTINUE_SCAN: (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; yy_current_state = yy_get_previous_state( ); yy_cp = (yy_c_buf_p); yy_bp = (yytext_ptr) + YY_MORE_ADJ; goto yy_match; case EOB_ACT_LAST_MATCH: (yy_c_buf_p) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; yy_current_state = yy_get_previous_state( ); yy_cp = (yy_c_buf_p); yy_bp = (yytext_ptr) + YY_MORE_ADJ; goto yy_find_action; } break; } default: YY_FATAL_ERROR( "fatal flex scanner internal error--no action found" ); } /* end of action switch */ } /* end of scanning one token */ } /* end of yylex */ /* yy_get_next_buffer - try to read in a new buffer * * Returns a code representing an action: * EOB_ACT_LAST_MATCH - * EOB_ACT_CONTINUE_SCAN - continue scanning from current position * EOB_ACT_END_OF_FILE - end of file */ static int yy_get_next_buffer (void) { register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; register char *source = (yytext_ptr); register int number_to_move, i; int ret_val; if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) YY_FATAL_ERROR( "fatal flex scanner internal error--end of buffer missed" ); if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) { /* Don't try to fill the buffer, so this is an EOF. */ if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) { /* We matched a single character, the EOB, so * treat this as a final EOF. */ return EOB_ACT_END_OF_FILE; } else { /* We matched some text prior to the EOB, first * process it. */ return EOB_ACT_LAST_MATCH; } } /* Try to read more data. */ /* First move last chars to start of buffer. */ number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; for ( i = 0; i < number_to_move; ++i ) *(dest++) = *(source++); if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) /* don't do the read, it's not guaranteed to return an EOF, * just force an EOF */ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; else { int num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; while ( num_to_read <= 0 ) { /* Not enough room in the buffer - grow it. */ /* just a shorter name for the current buffer */ YY_BUFFER_STATE b = YY_CURRENT_BUFFER; int yy_c_buf_p_offset = (int) ((yy_c_buf_p) - b->yy_ch_buf); if ( b->yy_is_our_buffer ) { int new_size = b->yy_buf_size * 2; if ( new_size <= 0 ) b->yy_buf_size += b->yy_buf_size / 8; else b->yy_buf_size *= 2; b->yy_ch_buf = (char *) /* Include room in for 2 EOB chars. */ yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ); } else /* Can't grow it, we don't own it. */ b->yy_ch_buf = 0; if ( ! b->yy_ch_buf ) YY_FATAL_ERROR( "fatal error - scanner input buffer overflow" ); (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; } if ( num_to_read > YY_READ_BUF_SIZE ) num_to_read = YY_READ_BUF_SIZE; /* Read in more data. */ YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), (yy_n_chars), (size_t) num_to_read ); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); } if ( (yy_n_chars) == 0 ) { if ( number_to_move == YY_MORE_ADJ ) { ret_val = EOB_ACT_END_OF_FILE; yyrestart(yyin ); } else { ret_val = EOB_ACT_LAST_MATCH; YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_EOF_PENDING; } } else ret_val = EOB_ACT_CONTINUE_SCAN; (yy_n_chars) += number_to_move; YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; return ret_val; } /* yy_get_previous_state - get the state just before the EOB char was reached */ static yy_state_type yy_get_previous_state (void) { register yy_state_type yy_current_state; register char *yy_cp; yy_current_state = (yy_start); for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) { register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); if ( yy_accept[yy_current_state] ) { (yy_last_accepting_state) = yy_current_state; (yy_last_accepting_cpos) = yy_cp; } while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 9 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; } return yy_current_state; } /* yy_try_NUL_trans - try to make a transition on the NUL character * * synopsis * next_state = yy_try_NUL_trans( current_state ); */ static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) { register int yy_is_jam; register char *yy_cp = (yy_c_buf_p); register YY_CHAR yy_c = 1; if ( yy_accept[yy_current_state] ) { (yy_last_accepting_state) = yy_current_state; (yy_last_accepting_cpos) = yy_cp; } while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 9 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; yy_is_jam = (yy_current_state == 8); return yy_is_jam ? 0 : yy_current_state; } #if 0 static void yyunput (int c, register char * yy_bp ) { register char *yy_cp; yy_cp = (yy_c_buf_p); /* undo effects of setting up yytext */ *yy_cp = (yy_hold_char); if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) { /* need to shift things up to make room */ /* +2 for EOB chars. */ register int number_to_move = (yy_n_chars) + 2; register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; register char *source = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) *--dest = *--source; yy_cp += (int) (dest - source); yy_bp += (int) (dest - source); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size; if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) YY_FATAL_ERROR( "flex scanner push-back overflow" ); } *--yy_cp = (char) c; (yytext_ptr) = yy_bp; (yy_hold_char) = *yy_cp; (yy_c_buf_p) = yy_cp; } #endif #ifndef YY_NO_INPUT #ifdef __cplusplus static int yyinput (void) #else static int input (void) #endif { int c; *(yy_c_buf_p) = (yy_hold_char); if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) { /* yy_c_buf_p now points to the character we want to return. * If this occurs *before* the EOB characters, then it's a * valid NUL; if not, then we've hit the end of the buffer. */ if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) /* This was really a NUL. */ *(yy_c_buf_p) = '\0'; else { /* need more input */ int offset = (yy_c_buf_p) - (yytext_ptr); ++(yy_c_buf_p); switch ( yy_get_next_buffer( ) ) { case EOB_ACT_LAST_MATCH: /* This happens because yy_g_n_b() * sees that we've accumulated a * token and flags that we need to * try matching the token before * proceeding. But for input(), * there's no matching to consider. * So convert the EOB_ACT_LAST_MATCH * to EOB_ACT_END_OF_FILE. */ /* Reset buffer status. */ yyrestart(yyin ); /*FALLTHROUGH*/ case EOB_ACT_END_OF_FILE: { if ( yywrap( ) ) return EOF; if ( ! (yy_did_buffer_switch_on_eof) ) YY_NEW_FILE; #ifdef __cplusplus return yyinput(); #else return input(); #endif } case EOB_ACT_CONTINUE_SCAN: (yy_c_buf_p) = (yytext_ptr) + offset; break; } } } c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ *(yy_c_buf_p) = '\0'; /* preserve yytext */ (yy_hold_char) = *++(yy_c_buf_p); return c; } #endif /* ifndef YY_NO_INPUT */ /** Immediately switch to a different input stream. * @param input_file A readable stream. * * @note This function does not reset the start condition to @c INITIAL . */ void yyrestart (FILE * input_file ) { if ( ! YY_CURRENT_BUFFER ){ yyensure_buffer_stack (); YY_CURRENT_BUFFER_LVALUE = yy_create_buffer(yyin,YY_BUF_SIZE ); } yy_init_buffer(YY_CURRENT_BUFFER,input_file ); yy_load_buffer_state( ); } /** Switch to a different input buffer. * @param new_buffer The new input buffer. * */ void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) { /* TODO. We should be able to replace this entire function body * with * yypop_buffer_state(); * yypush_buffer_state(new_buffer); */ yyensure_buffer_stack (); if ( YY_CURRENT_BUFFER == new_buffer ) return; if ( YY_CURRENT_BUFFER ) { /* Flush out information for old buffer. */ *(yy_c_buf_p) = (yy_hold_char); YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); } YY_CURRENT_BUFFER_LVALUE = new_buffer; yy_load_buffer_state( ); /* We don't actually know whether we did this switch during * EOF (yywrap()) processing, but the only time this flag * is looked at is after yywrap() is called, so it's safe * to go ahead and always set it. */ (yy_did_buffer_switch_on_eof) = 1; } static void yy_load_buffer_state (void) { (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; (yy_hold_char) = *(yy_c_buf_p); } /** Allocate and initialize an input buffer state. * @param file A readable stream. * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. * * @return the allocated buffer state. */ YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) { YY_BUFFER_STATE b; b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); b->yy_buf_size = size; /* yy_ch_buf has to be 2 characters longer than the size given because * we need to put in 2 end-of-buffer characters. */ b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ); if ( ! b->yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); b->yy_is_our_buffer = 1; yy_init_buffer(b,file ); return b; } /** Destroy the buffer. * @param b a buffer created with yy_create_buffer() * */ void yy_delete_buffer (YY_BUFFER_STATE b ) { if ( ! b ) return; if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; if ( b->yy_is_our_buffer ) yyfree((void *) b->yy_ch_buf ); yyfree((void *) b ); } #ifndef __cplusplus extern int isatty (int ); #endif /* __cplusplus */ /* Initializes or reinitializes a buffer. * This function is sometimes called more than once on the same buffer, * such as during a yyrestart() or at EOF. */ static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) { int oerrno = errno; yy_flush_buffer(b ); b->yy_input_file = file; b->yy_fill_buffer = 1; /* If b is the current buffer, then yy_init_buffer was _probably_ * called from yyrestart() or through yy_get_next_buffer. * In that case, we don't want to reset the lineno or column. */ if (b != YY_CURRENT_BUFFER){ b->yy_bs_lineno = 1; b->yy_bs_column = 0; } b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; errno = oerrno; } /** Discard all buffered characters. On the next scan, YY_INPUT will be called. * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. * */ void yy_flush_buffer (YY_BUFFER_STATE b ) { if ( ! b ) return; b->yy_n_chars = 0; /* We always need two end-of-buffer characters. The first causes * a transition to the end-of-buffer state. The second causes * a jam in that state. */ b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; b->yy_buf_pos = &b->yy_ch_buf[0]; b->yy_at_bol = 1; b->yy_buffer_status = YY_BUFFER_NEW; if ( b == YY_CURRENT_BUFFER ) yy_load_buffer_state( ); } /** Pushes the new state onto the stack. The new state becomes * the current state. This function will allocate the stack * if necessary. * @param new_buffer The new state. * */ void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) { if (new_buffer == NULL) return; yyensure_buffer_stack(); /* This block is copied from yy_switch_to_buffer. */ if ( YY_CURRENT_BUFFER ) { /* Flush out information for old buffer. */ *(yy_c_buf_p) = (yy_hold_char); YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); } /* Only push if top exists. Otherwise, replace top. */ if (YY_CURRENT_BUFFER) (yy_buffer_stack_top)++; YY_CURRENT_BUFFER_LVALUE = new_buffer; /* copied from yy_switch_to_buffer. */ yy_load_buffer_state( ); (yy_did_buffer_switch_on_eof) = 1; } /** Removes and deletes the top of the stack, if present. * The next element becomes the new top. * */ void yypop_buffer_state (void) { if (!YY_CURRENT_BUFFER) return; yy_delete_buffer(YY_CURRENT_BUFFER ); YY_CURRENT_BUFFER_LVALUE = NULL; if ((yy_buffer_stack_top) > 0) --(yy_buffer_stack_top); if (YY_CURRENT_BUFFER) { yy_load_buffer_state( ); (yy_did_buffer_switch_on_eof) = 1; } } /* Allocates the stack if it does not exist. * Guarantees space for at least one push. */ static void yyensure_buffer_stack (void) { int num_to_alloc; if (!(yy_buffer_stack)) { /* First allocation is just for 2 elements, since we don't know if this * scanner will even need a stack. We use 2 instead of 1 to avoid an * immediate realloc on the next call. */ num_to_alloc = 1; (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc (num_to_alloc * sizeof(struct yy_buffer_state*) ); memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); (yy_buffer_stack_max) = num_to_alloc; (yy_buffer_stack_top) = 0; return; } if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ /* Increase the buffer to prepare for a possible push. */ int grow_size = 8 /* arbitrary grow size */; num_to_alloc = (yy_buffer_stack_max) + grow_size; (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc ((yy_buffer_stack), num_to_alloc * sizeof(struct yy_buffer_state*) ); /* zero only the new slots.*/ memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); (yy_buffer_stack_max) = num_to_alloc; } } /** Setup the input buffer state to scan directly from a user-specified character buffer. * @param base the character buffer * @param size the size in bytes of the character buffer * * @return the newly allocated buffer state object. */ YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) { YY_BUFFER_STATE b; if ( size < 2 || base[size-2] != YY_END_OF_BUFFER_CHAR || base[size-1] != YY_END_OF_BUFFER_CHAR ) /* They forgot to leave room for the EOB's. */ return 0; b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ b->yy_buf_pos = b->yy_ch_buf = base; b->yy_is_our_buffer = 0; b->yy_input_file = 0; b->yy_n_chars = b->yy_buf_size; b->yy_is_interactive = 0; b->yy_at_bol = 1; b->yy_fill_buffer = 0; b->yy_buffer_status = YY_BUFFER_NEW; yy_switch_to_buffer(b ); return b; } /** Setup the input buffer state to scan a string. The next call to yylex() will * scan from a @e copy of @a str. * @param yystr a NUL-terminated string to scan * * @return the newly allocated buffer state object. * @note If you want to scan bytes that may contain NUL values, then use * yy_scan_bytes() instead. */ YY_BUFFER_STATE yy_scan_string (yyconst char * yystr ) { return yy_scan_bytes(yystr,strlen(yystr) ); } /** Setup the input buffer state to scan the given bytes. The next call to yylex() will * scan from a @e copy of @a bytes. * @param bytes the byte buffer to scan * @param len the number of bytes in the buffer pointed to by @a bytes. * * @return the newly allocated buffer state object. */ YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, int _yybytes_len ) { YY_BUFFER_STATE b; char *buf; yy_size_t n; int i; /* Get memory for full buffer, including space for trailing EOB's. */ n = _yybytes_len + 2; buf = (char *) yyalloc(n ); if ( ! buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); for ( i = 0; i < _yybytes_len; ++i ) buf[i] = yybytes[i]; buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; b = yy_scan_buffer(buf,n ); if ( ! b ) YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); /* It's okay to grow etc. this buffer, and we should throw it * away when we're done. */ b->yy_is_our_buffer = 1; return b; } #ifndef YY_EXIT_FAILURE #define YY_EXIT_FAILURE 2 #endif static void yy_fatal_error (yyconst char* msg ) { (void) fprintf( stderr, "%s\n", msg ); exit( YY_EXIT_FAILURE ); } /* Redefine yyless() so it works in section 3 code. */ #undef yyless #define yyless(n) \ do \ { \ /* Undo effects of setting up yytext. */ \ int yyless_macro_arg = (n); \ YY_LESS_LINENO(yyless_macro_arg);\ yytext[yyleng] = (yy_hold_char); \ (yy_c_buf_p) = yytext + yyless_macro_arg; \ (yy_hold_char) = *(yy_c_buf_p); \ *(yy_c_buf_p) = '\0'; \ yyleng = yyless_macro_arg; \ } \ while ( 0 ) /* Accessor methods (get/set functions) to struct members. */ /** Get the current line number. * */ int yyget_lineno (void) { return yylineno; } /** Get the input stream. * */ FILE *yyget_in (void) { return yyin; } /** Get the output stream. * */ FILE *yyget_out (void) { return yyout; } /** Get the length of the current token. * */ int yyget_leng (void) { return yyleng; } /** Get the current token. * */ char *yyget_text (void) { return yytext; } /** Set the current line number. * @param line_number * */ void yyset_lineno (int line_number ) { yylineno = line_number; } /** Set the input stream. This does not discard the current * input buffer. * @param in_str A readable stream. * * @see yy_switch_to_buffer */ void yyset_in (FILE * in_str ) { yyin = in_str ; } void yyset_out (FILE * out_str ) { yyout = out_str ; } int yyget_debug (void) { return yy_flex_debug; } void yyset_debug (int bdebug ) { yy_flex_debug = bdebug ; } static int yy_init_globals (void) { /* Initialization is the same as for the non-reentrant scanner. * This function is called from yylex_destroy(), so don't allocate here. */ (yy_buffer_stack) = 0; (yy_buffer_stack_top) = 0; (yy_buffer_stack_max) = 0; (yy_c_buf_p) = (char *) 0; (yy_init) = 0; (yy_start) = 0; /* Defined in main.c */ #ifdef YY_STDINIT yyin = stdin; yyout = stdout; #else yyin = (FILE *) 0; yyout = (FILE *) 0; #endif /* For future reference: Set errno on error, since we are called by * yylex_init() */ return 0; } /* yylex_destroy is for both reentrant and non-reentrant scanners. */ int yylex_destroy (void) { /* Pop the buffer stack, destroying each element. */ while(YY_CURRENT_BUFFER){ yy_delete_buffer(YY_CURRENT_BUFFER ); YY_CURRENT_BUFFER_LVALUE = NULL; yypop_buffer_state(); } /* Destroy the stack itself. */ yyfree((yy_buffer_stack) ); (yy_buffer_stack) = NULL; /* Reset the globals. This is important in a non-reentrant scanner so the next time * yylex() is called, initialization will occur. */ yy_init_globals( ); return 0; } /* * Internal utility routines. */ #ifndef yytext_ptr static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) { register int i; for ( i = 0; i < n; ++i ) s1[i] = s2[i]; } #endif #ifdef YY_NEED_STRLEN static int yy_flex_strlen (yyconst char * s ) { register int n; for ( n = 0; s[n]; ++n ) ; return n; } #endif void *yyalloc (yy_size_t size ) { return (void *) malloc( size ); } void *yyrealloc (void * ptr, yy_size_t size ) { /* The cast to (char *) in the following accommodates both * implementations that use char* generic pointers, and those * that use void* generic pointers. It works with the latter * because both ANSI C and C++ allow castless assignment from * any pointer type to void*, and deal with argument conversions * as though doing an assignment. */ return (void *) realloc( (char *) ptr, size ); } void yyfree (void * ptr ) { free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ } #define YYTABLES_NAME "yytables" #line 67 "rules.lex" c++-annotations-10.6.0/src/tab/tab.c0000644000175000017500000001036612745054221015744 0ustar frankfrank/* TAB.C 92 11 24 Ported for Unix KK 94 04 06 Port and maintenance for ELF: FBB 96/08/xx Skipping symbolic links: FBB 2001/07/22 Repairing EOF swallow: FBB 2001/09/09 */ #ifdef MSDOS #if !defined(M_I86SM) #error SMALL memory model expected #endif #endif #include #include #include #ifndef MSDOS #include #include #include #endif extern int yylex (void); extern char *fname (char *); extern FILE *yyin, *yyout; extern int column, nspaces; int quiet = 0, entab = 0, minspaces = 4, tabpos = 8; char version[] = "1.41", tempfile[] = "tab.tmp"; int main(int argc, char **argv) { int piping = 0; char *progname; struct stat fileinfo; progname = fname(argv[0]); while (argc > 1 && *argv[1] == '-') { switch (argv[1][1]) { case 'd': entab = 0; break; case 'e': entab = 1; break; case 's': if (!(minspaces = atoi(argv [1] + 2))) { printf("%s: missing or illegal space count at -s, " "assuming 4\n", progname); minspaces = 4; } break; case 'c': if (!(tabpos = atoi(argv [1] + 2))) { printf("%s: missing or illegal column count at -c, " "assuming 8\n", progname); tabpos = 8; } break; case 'q': quiet = 1; break; default: if (!argv[1][1]) { piping = 1; break; } printf("%s: unknown flag '-%c,' ignored\n", progname, *(*argv + 1)); break; } argv++; argc--; } if (argc == 1 && !piping) /* error */ { printf("\nTAB Entabber/Detabber V%s\n" "Copyright (c) GPL 1989-2006. All rights reserved.\n" "\n" "%s by Frank B. Brokken (f.b.brokken@rc.rug.nl).\n" "\n" "Usage: %s [-d | -e | -snnn | -cnnn]* file(s)\n" "where:\n" " -c - entab at / detab to multiples of nnn columns " "(default: 8)\n" " -d - tabs in file(s) are removed (detab)\n" " (default action)\n" " -e - spaces in file(s) are changed into tabs (entab)\n" " -q - quiet: less output than otherwise\n" " -s - entab/detab a minimum number of nnn spaces " "(default: 4)\n" " file(s) - file(s) to entab/detab (are overwritten)\n" " use - to filter stdin to stdout\n" " non-regular files (e.g. symbolic links) are " "skipped.\n" "\n" , version, progname, progname); return (1); } if (piping) { yyin = stdin; yyout = stdout; yylex(); return (0); } for (++argv; *argv; ++argv) { if (lstat(*argv, &fileinfo)) { printf("Can't stat %s: skipping\n", *argv); continue; } if (!S_ISREG(fileinfo.st_mode)) /* not a regular file */ continue; /* skip it silently */ if (!quiet) printf("processing %s\n", *argv); unlink(tempfile); if (rename(*argv, tempfile)) { printf("%s: can't rename %s\n", progname, *argv); return (1); } if ( !(yyin = fopen(tempfile, "r")) || !(yyout = fopen(*argv, "w")) ) { printf ("%s: cannot open in- or output file\n", progname); return (1); } yylex(); fclose (yyin); fclose (yyout); } unlink(tempfile); return (0); } c++-annotations-10.6.0/src/htmlindex/0000755000175000017500000000000013005341547016252 5ustar frankfrankc++-annotations-10.6.0/src/htmlindex/build0000755000175000017500000001463512745054221017310 0ustar frankfrank#!/usr/bin/icmake -qt/tmp/htmlindex #include "../../compilers.im" string CLASSES; void setClasses() { CLASSES += " aux indexentry"; } #define ECHO_REQUEST ON // Extra libraries required. Remove lib and .a from the library names. // E.g., #define LIBS "m Xt" to link libm.a and libXt.a explicitly // Specify libs from the most specific to the most general one. #define LIBS ${BOBCAT} // Extra library-paths required. // E.g., #define LIBPATH "/some/path /some/other/path" to search these paths // apart from the default paths #define LIBPATH ${LPATH} // DO NOT ALTER THINGS BELOW THIS LINE string // contain options for libs, // extra libs, e.g., "-lrss -licce" libpath, // extra lib-paths, eg, "-L../rss" lopt, libxxxa; // expanded lib-name string ofiles, // wildcards for o-files sources, // sources to be used wild, // wildcard of extension current; // contains name of current dir. list objfiles(list files) { string file, objfile; int i; for (i = 0; i < listlen(files); i++) { file = element(i, files); // determine element of the list objfile = "./o/" + change_ext(file, "o"); // make obj-filename if (objfile younger file) // objfile is younger { files -= (list)file; // remove the file from the list i--; // reduce i to test the next } } return (files); } list altered(list files, string target) { int i; string file; for (i = 0; i < listlen(files); i++) // try all elements of the list { file = element(i, files); // use element i of the list if (file older target) // a file is older than the target { files -= (list)file; // remove the file from the list i--; // reduce i to inspect the next } // file of the list } return (files); // return the new list } list file_list(string type, string library) { list files; files = makelist(type); // make all files of certain type files = objfiles(files); // remove if younger .obj exist return (files); } void link(string library, string exe) { exec(GPP, "-o", exe, ofiles, libs, "-L.", libpath, lopt ); } void c_compile(list cfiles) { string nextfile; int i; if (!exists("o")) system("mkdir o"); if (listlen(cfiles)) // files to compile ? { printf(current, "\n"); // compile all files separately for (i = 0; nextfile = element(i, cfiles); i++) { exec(GPP, "-c -o o/" + change_ext(nextfile, "o") + " " CPPOPT + " " + nextfile); } } } void updatelib(string library) { list arlist, objlist; string to, from; objlist = makelist("*.o"); if (!listlen(objlist)) return; printf("\n"); exec("ar", "rvs", library, "*.o"); exec("rm", "*.o"); printf("\n"); } void prefix_class(string class_id) { list o_files; string o_file; int i; o_files = makelist("*.o"); for (i = 0; o_file = element(i, o_files); i++) exec("mv", o_file, class_id + o_file); } void std_cpp(string library) { list cfiles; cfiles = file_list(wild, library); // make list of all cpp-files c_compile(cfiles); // compile cpp-files } void cpp_make(string mainfile, string library, string exe) { int n, index; list classes; string cwd; setClasses(); // remaining classes cwd = chdir("."); ofiles = "o/*.o"; // std set of o-files classes = strtok(CLASSES, " "); // list of classes if (n = listlen(classes)) ofiles += " */o/*.o"; // set ofiles for no LIBRARY use wild = sources; // make library name libxxxa = chdir(".") + "lib" + library + ".a"; // first process all classes for (index = 0; index < n; index++) { current = element(index, classes); // next class to process chdir(current); // change to directory current = "subdir " + current; std_cpp (libxxxa); // compile all files chdir( cwd); // go back to parent dir } current = "auxiliary " + wild + " files"; std_cpp (libxxxa); // compile all files in current dir for (index = 0; index < n; index++) { current = element(index, classes); // determine class name chdir( current); // chdir to a class directory. chdir(cwd); // go back to parent dir } current = ""; // no class anymore if (mainfile != "") // mainfile -> do link link(library, exe); } void setlibs() { int n, index; list cut; cut = strtok(LIBS, " "); // cut op libraries n = listlen(cut); for (index = 0; index < n; index++) libs += " -l" + element(index, cut); cut = strtok(LIBPATH, " "); // cut up the paths n = listlen(cut); for (index = 0; index < n; index++) libpath += " -L" + element(index, cut); } void main() { echo(ECHO_REQUEST); sources = "*.cc"; setlibs(); lopt = "-s"; system("mkdir -p ../../tmp/bin"); // make destination if it doesn't // already exist cpp_make ( "htmlindex.cc", // program source "htmlindex", // program library "../../tmp/bin/htmlindex" // binary program ); } c++-annotations-10.6.0/src/htmlindex/htmlindex.cc0000644000175000017500000000245012745054221020556 0ustar frankfrank/* htmlindex.cc */ #include "htmlindex.h" HashString indexHash; vector indexVector; vector filenameVector; string lastFilename; char indexSection = 'A' - 1; int returnValue = 0; int main(int argc, char **argv) { Arg::initialize("", argc, argv); Arg &arg(Arg::instance()); if (isatty(STDIN_FILENO)) usage(arg.basename()); getKeys(); sort(indexVector.begin(), indexVector.end()); head(); unsigned n = indexVector.size(), halfway = (n + 1) / 2; cout << "\n" << "\n"; // left column as a table for (unsigned idx = 0; idx < halfway; idx++) // print left column { cout << "\n"; display(idx); cout << "\n"; } cout << "
\n" << "\n" << // left column done "\n" << "\n"; // right column as a table for (unsigned idx = halfway; idx < n; idx++) // print right column { cout << "\n"; display(idx); cout << "\n"; } cout << "
\n" << "\n"; // right column done tail(); return returnValue; } c++-annotations-10.6.0/src/htmlindex/indexentry/0000755000175000017500000000000013005341547020443 5ustar frankfrankc++-annotations-10.6.0/src/htmlindex/indexentry/operatorless.cc0000644000175000017500000000065412745054221023501 0ustar frankfrank#include "../htmlindex.h" bool IndexEntry::operator<(IndexEntry const &other) const { if (isalnum(uppercaseKey[0]) && !isalnum(other.uppercaseKey[0])) return false; // alphanumeric entries after special chars if (!isalnum(uppercaseKey[0]) && isalnum(other.uppercaseKey[0])) return true; // special chars before alphanumeric entries return uppercaseKey < other.uppercaseKey; } c++-annotations-10.6.0/src/htmlindex/indexentry/showrefs.cc0000644000175000017500000000062312745054221022613 0ustar frankfrank#include "../htmlindex.h" void IndexEntry::showRefs() { for ( vector >::iterator it = labels.begin(); it != labels.end(); it++ ) cout << " second << " target=info>" << it->second << " \n"; } c++-annotations-10.6.0/src/htmlindex/indexentry/indexentry.cc0000644000175000017500000000056412745054221023150 0ustar frankfrank#include "../htmlindex.h" IndexEntry::IndexEntry(string const &keystring, unsigned filenameIndex, unsigned labelNr) : key(keystring) { for (string::iterator it = key.begin(); it != key.end(); it++) if (*it != ' ') uppercaseKey += toupper(*it); labels.push_back(pair(filenameIndex, labelNr)); } c++-annotations-10.6.0/src/htmlindex/indexentry/indexentry.h0000644000175000017500000000000012745054221022773 0ustar frankfrankc++-annotations-10.6.0/src/htmlindex/man/0000755000175000017500000000000012745054221017025 5ustar frankfrankc++-annotations-10.6.0/src/htmlindex/man/htmlindex.yo0000644000175000017500000000531212745054221021373 0ustar frankfrankCOMMENT( Leave a definition of a label empty if not used. E.g., if you don't have other programs related to this one, use: SUBST(@SEEALSO) () Use bf() for items that should appear literally in commands, etc. use em() for formal names, that should be replaced by actual values in real life. ) SUBST(@SECTION) (1) SUBST(@DATE) (2003) SUBST(@AUTHOR) (Frank B. Brokken (bf(f.b.brokken@rc.rug.nl)).) SUBST(@ORGANIZATION) (Computing Center, University of Groningen.) SUBST(@PROGRAM) (htmlindex) SUBST(@PROJECT) (C++ Annotations Software) SUBST(@DISTRIBUTION) (htmlindex-X.YY.tar.gz) SUBST(@SHORTDESC) (Create html index from Yodl index entries) SUBST(@SYNOPSYS)( @PROGRAM < indexpage > outputpage ) SUBST(@OPTIONS)( startit() it() tt(indexpage): file obtained from Yodl-html pages containing lines like verb( ) which can be created from Yold-macros like COMMENT(Make sure a blank is written behind the backslashes in the following verb()-block.) verb( NEWCOUNTER(htmlAnchor) def(hix)(1)(\ IFDEF(html)\ (label(an+USECOUNTER(htmlAnchor))\ htmlcommand( )\ )\ (IFDEF(latex)\ (latexcommand(\index{)ARG1+latexcommand(}))\ ()\ )) ) using lines like: verb( hix(http://www.xs4all.nl/.../yodl/) ) it() tt(outputpage): indexfile written as a html-page to the standard output, as a two-column table, sorted, clickable entry file, referring back to labels defined in the pages where the index entries were found. E.g., the table contains entries like verb( http://www.xs4all.nl/.../yodl/ 4  ) endit() ) SUBST(@DESCRIPTION)( See the description of the options. The conversion of index entries in the html file to labels within files may be performed by a simple script, like: verb( #!/bin/sh cd ../html for x in `ls cplusplus[0-9][0-9].html` ; do grep -v '^ ${x}2 mv ${x}2 $x done ) ) SUBST(@FILES)(-) SUBST(@SEEALSO)(-) SUBST(@DIAGNOSTICS)(-) SUBST(@BUGS) (No Documented Bugs.) SUBST(@COPYRIGHT)( This is free software, distributed under the terms of the GNU General Public License. ) COMMENT(Do not modify from here) INCLUDEFILE(/usr/local/share/makemanpage/executables.1/pagedef.yo) c++-annotations-10.6.0/src/htmlindex/aux/0000755000175000017500000000000013005341547017047 5ustar frankfrankc++-annotations-10.6.0/src/htmlindex/aux/getkeys.cc0000644000175000017500000000456112745054221021037 0ustar frankfrank#include "../htmlindex.h" void getKeys() { string line; Pattern pattern("([^:]+):"); unsigned filenameIndex = 0; while (getline(cin, line)) { try { pattern.match(line); } catch (...) { cerr << "Invalid entry at line `" << line << "'\n"; returnValue = 1; continue; } Pattern::Position pos = pattern.position(3); if (pos.first == pos.second) { cerr << "Missing key at line `" << line << "'\n"; returnValue = 1; continue; } string filename = pattern[1], key = pattern[3]; unsigned labelNr = atoi(pattern[2].c_str()); if (filename != lastFilename) { filenameIndex = filenameVector.size(); filenameVector.push_back(filename); lastFilename = filename; cerr << "File " << filename << " at " << filenameIndex << endl; } /* hash indexHash contains the key and an idx in `index' where IndexEntry objects are stored. vector index; IndexEntry: contains the key (and for comparisons speedup the lowercase key, and vector of unsigned label numbers. First hash (and index) are filled. */ hash_iterator it = indexHash.find(key); if (it != indexHash.end()) // key already available { //cerr << "duplicate key: " << key; indexVector[it->second].push_back(filenameIndex, labelNr); } else { // new key: add to the hashtable //cerr << "new key: " << key; indexHash.insert ( //hash_map::value_type HashString::value_type ( key, indexVector.size() ) ); //cerr << "..."; // and add to the `index' vector indexVector.push_back(IndexEntry(key, filenameIndex, labelNr)); } //cerr << " inserted\n"; } } c++-annotations-10.6.0/src/htmlindex/aux/usage.cc0000644000175000017500000000113012745054221020455 0ustar frankfrank#include "../htmlindex.h" void usage(string const &basename) { cout << "\n" << basename << " by Frank B. Brokken (f.b.brokken@rug.nl)\n" "\n" "C++ Annotations html index page builder, V. " << version << endl << "Copyright (c) 2001-2006 Frank B. Brokken. GPL.\n" "\n" "Usage: " << basename << " < indexpage > outputpage\n" "Where:\n" " indexpage: file containing `' index entries\n" " outputpage: file to write the index page to (e.g., " "cplusplusidx.html)\n" << endl; exit(1); } c++-annotations-10.6.0/src/htmlindex/aux/head.cc0000644000175000017500000000042612745054221020261 0ustar frankfrank#include "../htmlindex.h" void head() { cout << "\n" "\n" "C++ Annotations HTML Index \n" "\n" "\n" "\n" "\n" "

Index

\n" "\n" "\n" "\n"; } c++-annotations-10.6.0/src/htmlindex/aux/display.cc0000644000175000017500000000106212745054221021022 0ustar frankfrank#include "../htmlindex.h" void display(unsigned idx) { IndexEntry &ie = indexVector[idx]; if (ie.firstChar() > indexSection && isalnum(ie.firstChar())) { indexSection = ie.firstChar(); cout << " \n" "\n" "\n"; } cout << " \n" << " \n"; } c++-annotations-10.6.0/src/htmlindex/aux/tail.cc0000644000175000017500000000015012745054221020303 0ustar frankfrank#include "../htmlindex.h" void tail() { cout << "\n" "\n" "
 

" << indexSection << "

" << ie.getKey() << " \n"; ie.showRefs(); cout << "
\n" "\n"; } c++-annotations-10.6.0/src/htmlindex/version.cc0000644000175000017500000000011712745054221020245 0ustar frankfrank#include "htmlindex.h" char version[] = "1.13", year[] = "2001-2014"; c++-annotations-10.6.0/src/htmlindex/htmlindex.h0000644000175000017500000000275312745054221020426 0ustar frankfrank// htmlindex.h #ifndef _H_htmlindex_ #define _H_htmlindex_ #include #include #include #include #include #include #include #include #include using namespace FBB; using namespace std; void usage(string const &basename); void getKeys(); void head(); void display(unsigned idx); void tail(); extern char indexSection, version[], year[]; extern int returnValue; extern string lastFilename; extern vector filenameVector; extern HashString // hash_map indexHash; typedef HashString::iterator // hash_map::iterator hash_iterator; class IndexEntry { public: IndexEntry(string const &key, unsigned filenameIndex, unsigned labelNr); void push_back(unsigned filenameIndex, unsigned labelNr) { labels.push_back(pair(filenameIndex, labelNr)); } bool operator<(IndexEntry const &other) const; string const &getKey() { return key; } char firstChar() { return uppercaseKey[0]; } void showRefs(); private: string uppercaseKey, key; vector > labels; }; extern vector indexVector; #endif c++-annotations-10.6.0/src/verbnrs.cc0000644000175000017500000000325412745054221016252 0ustar frankfrank#include #include #include #include using namespace std; // first argument: file to process, 2nd argument (optional): indentation (by // default 1, which is also the minimum indentation that is used.) int main(int argc, char **argv) { string line; bool empty = true; ifstream in(argv[1]); while (getline(in, line)) // find the first non-empty line { if (line.find_first_not_of(" \t") != string::npos) // non-empty line { empty = false; // avoid doubly checking `line' break; } } if (empty) // nothing but emptyness... return 0; size_t indent = 0; if (argc > 2) indent = stoul(argv[2]); size_t lineNr = 0; size_t nEmpty = 0; // counts empty lines cout << "\n" "verb(" << setw(indent) << ' ' << setw(2) << ++lineNr << ' ' << line; // show the 1st line while (getline(in, line)) // read the rest of the file { if (line.find_first_not_of(" \t") == string::npos) // empty line { ++nEmpty; // count it continue; // proceed with the next line } if (lineNr != 0) cout << '\n'; for (size_t nr = 0; nr != nEmpty; ++nr) // 'for': # iterations known cout << setw(indent) << ' ' << setw(2) << ++lineNr << '\n'; nEmpty = 0; // reset the counter cout << setw(indent) << ' ' << setw(2) << ++lineNr << ' ' << line; // show the line } cout << ")\n"; } c++-annotations-10.6.0/src/trim/0000755000175000017500000000000012745054221015231 5ustar frankfrankc++-annotations-10.6.0/src/trim/trim.cc0000644000175000017500000000417112745054221016516 0ustar frankfrank#include #include #include #include #include #include using namespace std; bool silent; namespace std { istream &operator>>(istream &in, string &line) { return getline(in, line); } } class NonEmpty { public: bool operator()(string const &str) const { return str.find_first_not_of(" \t") != string::npos; } }; class Trimmer { ostream &d_out; public: Trimmer(ostream &out) : d_out(out) {} void operator()(string const &str) const { // find last non ws string::size_type idx = str.find_last_not_of(" \t"); if (idx == string::npos) // no non-ws char: print empty line d_out << endl; else if (idx + 1 == str.length()) // no trailing ws d_out << str << endl; else // \ requires 1 space d_out << str.substr(0, idx + 1) << endl; } }; void trim(char const *name = 0) { ifstream in; istream *ip; vector vs; if (!name) ip = &cin; else { if (!silent) cout << "trimming `" << name << "'\n"; in.open(name); if (!in) { cout << "no such file `" << name << "': skipped.\n"; return; } ip = ∈ } copy(istream_iterator(*ip), istream_iterator(), back_inserter(vs)); vector::reverse_iterator it = find_if(vs.rbegin(), vs.rend(), NonEmpty()); ofstream out; ostream *op; if (!name) op = &cout; else { in.close(); out.open(name); op = &out; } for_each(vs.begin(), vector::iterator(&*(it - 1)), Trimmer(*op)); } int main(int argc, char **argv) { if (argc == 1) trim(); else { if (argc > 1) silent = string("-q") == argv[1]; for (int idx = 1 + silent; idx < argc; idx++) trim(argv[idx]); } } c++-annotations-10.6.0/src/rmindexlines/0000755000175000017500000000000012745054221016757 5ustar frankfrankc++-annotations-10.6.0/src/rmindexlines/rmindexlines.cc0000644000175000017500000000110112745054221021760 0ustar frankfrank#include #include using namespace std; int main() { string line1; string line2; getline(cin, line1); // initialization: pick up line 1 // which is never a \n while (getline(cin, line2)) { cout << line1; if (line2.find(" #include #include #include #include #include #include #include #include using namespace std; using namespace FBB; string keywords = "alignas " "alignof and compl explicit new requires typedef and_eq concept extern not " "bool delete if private switch void break do inline protected template " "volatile " "case double int public this wchar_t catch dynamic_cast long register throw " "decltype friend or static_cast using bitor default goto or_eq struct " "virtual " "nullptr sizeof union axiom continue for operator static unsigned bitand " "short typeid asm const false not_eq signed typename auto const_cast float " "try xor_eq constexpr import export " "while char else mutable reinterpret_cast true xor class enum namespace " "char16_t char32_t noexcept static_assert thread_local " "return" ; struct Support: public TableSupport { void vline(size_t col) const { if (col > 0) out() << ' '; } }; int main() { set keyword; istringstream in(keywords); copy(istream_iterator(in), istream_iterator(), inserter(keyword, keyword.begin())); Support support; support << 0; for (size_t col = 0; col != 6; ++col) support << 1; Table table(support, 6, Table::COLUMNWISE); table.fill(keyword.begin(), keyword.end()); for(size_t col = 0; col != 6; ++col) table << Align(col, std::left); cout << table << '\n'; } c++-annotations-10.6.0/src/tabs/0000755000175000017500000000000012745054221015207 5ustar frankfrankc++-annotations-10.6.0/src/tabs/normalfile.cc0000644000175000017500000000040712745054221017647 0ustar frankfrank#include "main.ih" bool normalFile(char const *fileName) { struct stat fileInfo; if (lstat(fileName, &fileInfo)) { cout << "Can't stat `" << fileName << "': skipping\n"; return false; } return S_ISREG(fileInfo.st_mode); } c++-annotations-10.6.0/src/tabs/data.cc0000644000175000017500000000016012745054221016424 0ustar frankfrank#include "main.ih" bool g_entab = false; bool g_quiet = false; size_t g_minSpaces = 4; size_t g_tabWidth = 8; c++-annotations-10.6.0/src/tabs/arguments.cc0000644000175000017500000000140012745054221017516 0ustar frankfrank#include "main.ih" bool arguments(int argc, char **argv) { if (argc == 1) { string progname(argv[0]); size_t pos = progname.find_last_of('/'); if (pos != string::npos) progname.erase(0, pos + 1); usage(progname); return false; } while (true) { switch (getopt(argc, argv, "c:des:q")) { case 'e': g_entab = true; break; case 's': g_minSpaces = stoul(optarg); break; case 'c': g_tabWidth = stoul(optarg); break; case 'q': g_quiet = true; break; default: return true; } } } c++-annotations-10.6.0/src/tabs/usage.cc0000644000175000017500000000212612745054221016623 0ustar frankfrank// usage.cc #include "main.ih" void usage(std::string const &progname) { cout << '\n' << progname << " by " << Icmbuild::author << "\n" << progname << " V" << Icmbuild::version << " " << Icmbuild::years << "\n" "Copyright (c) GPL " << Icmbuild::years << ". All rights reserved.\n" "\n" "Usage: %s [-d | -e | -snnn | -cnnn]* file(s)\n" "Where:\n" " -c - entab at / detab to multiples of nnn columns " "(default: 8)\n" " -d - tabs in file(s) are removed (detab)\n" " (default action)\n" " -e - spaces in file(s) are changed into tabs (entab)\n" " -q - quiet: less output than otherwise\n" " -s - entab/detab a minimum number of nnn spaces " "(default: 4)\n" " file(s) - file(s) to entab/detab (are overwritten)\n" " use - to filter stdin to stdout\n" " non-regular files (e.g. symbolic links) are " "skipped.\n" "\n"; } c++-annotations-10.6.0/src/tabs/tabber/0000755000175000017500000000000012745054221016446 5ustar frankfrankc++-annotations-10.6.0/src/tabs/tabber/incColumn.cc0000644000175000017500000000013412745054221020702 0ustar frankfrank#include "tabber.ih" bool Tabber::tabColumn() { return ++d_column % g_tabWidth == 0; } c++-annotations-10.6.0/src/tabs/tabber/space.cc0000644000175000017500000000102512745054221020046 0ustar frankfrank#include "tabber.ih" void Tabber::space() { ++d_nSpaces; if (d_column % g_tabWidth != 0) // not at a tab-position return; if (d_nSpaces < g_minSpaces) // to few spaces to write a tab { d_out << setw(d_nSpaces) << ' '; // write blanks up to the tab-pos d_nSpaces = 0; } else // enough spaces to write a tab { d_nSpaces -= g_minSpaces; // remove #spaces converted to \t d_out.put('\t'); } } c++-annotations-10.6.0/src/tabs/tabber/tabber1.cc0000644000175000017500000000013312745054221020272 0ustar frankfrank#include "tabber.ih" Tabber::Tabber() : d_in(cin.rdbuf()), d_out(cout.rdbuf()) {} c++-annotations-10.6.0/src/tabs/tabber/run.cc0000644000175000017500000000017412745054221017563 0ustar frankfrank#include "tabber.ih" void Tabber::run() { d_column = 0; if (g_entab) entab(); else detab(); } c++-annotations-10.6.0/src/tabs/tabber/run2.cc0000644000175000017500000000031712745054221017644 0ustar frankfrank#include "tabber.ih" void Tabber::run(char const *inName, char const *outName) { ifstream in(inName); ofstream out(outName); d_in.rdbuf(in.rdbuf()); d_out.rdbuf(out.rdbuf()); run(); } c++-annotations-10.6.0/src/tabs/tabber/detab.cc0000644000175000017500000000154412745054221020040 0ustar frankfrank#include "tabber.ih" // d_column is the # of characters so far in the actual field of g_tabWidth // characters. void Tabber::detab() { char ch; while (d_in.get(ch)) { switch (ch) { case '\n': d_column = 0; // no characters in the current field, // since after this we're on the next line break; case '\t': d_out << setw(g_tabWidth - d_column) << ' '; d_column = 0; // no chars in the current field, as we // just filled it up by blanks continue; // process the next character default: d_column = (d_column + 1) % g_tabWidth; break; } d_out.put(ch); // write ordinary char. } } c++-annotations-10.6.0/src/tabs/tabber/tabber.ih0000644000175000017500000000017712745054221020234 0ustar frankfrank#include "tabber.h" #include #include #include #include "../globals.h" using namespace std; c++-annotations-10.6.0/src/tabs/tabber/entab.cc0000644000175000017500000000152612745054221020052 0ustar frankfrank#include "tabber.ih" void Tabber::entab() { char ch; while (d_in.get(ch)) { switch (ch) { case ' ': ++d_nSpaces; // got a space if (tabColumn()) // we're at a tab column { if (d_nSpaces < g_minSpaces) outSpaces(); else { d_nSpaces = 0; d_out.put('\t'); } } break; case '\n': case '\t': outSpaces(); d_out.put(ch); d_column = 0; break; default: outSpaces(); d_out.put(ch); ++d_column; break; } } } c++-annotations-10.6.0/src/tabs/tabber/tab.cc0000644000175000017500000000005512745054221017523 0ustar frankfrank#include "tabber.ih" void Tabber::tab() { } c++-annotations-10.6.0/src/tabs/tabber/outspaces.cc0000644000175000017500000000020712745054221020762 0ustar frankfrank#include "tabber.ih" void Tabber::outSpaces() { if (d_nSpaces != 0) d_out << setw(d_nSpaces) << ' '; d_nSpaces = 0; } c++-annotations-10.6.0/src/tabs/tabber/tabber.h0000644000175000017500000000075412745054221020064 0ustar frankfrank#ifndef INCLUDED_TABBER_ #define INCLUDED_TABBER_ #include #include class Tabber { std::istream d_in; std::ostream d_out; size_t d_nSpaces = 0; size_t d_column = 0; public: Tabber(); void run(); void run(char const *inName, char const *outName); private: void detab(); void entab(); bool tabColumn(); void outSpaces(); void space(); void tab(); }; #endif c++-annotations-10.6.0/src/tabs/tabber/frame0000644000175000017500000000004312745054221017460 0ustar frankfrank#include "tabber.ih" Tabber:: { } c++-annotations-10.6.0/src/tabs/VERSION0000644000175000017500000000015312745054221016256 0ustar frankfrank#define AUTHOR "Frank B. Brokken (f.b.brokken@rug.nl)" #define VERSION "2.00.00" #define YEARS "1999-2014" c++-annotations-10.6.0/src/tabs/icmconf0000644000175000017500000000161412745054221016552 0ustar frankfrank#define ADD_LIBRARIES "" #define ADD_LIBRARY_PATHS "" //#define CLS #define CXX "g++" #define CXXFLAGS " --std=c++0x -Wall -g -O2" //#define CFLAGS " -Wall -g -O2" #define LDFLAGS "" //#define LIBRARY "modules" #define MAIN "main.cc" #define OBJ_EXT ".o" #define PARSER_DIR "" //#define PARSFILES "" #define PARSFLAGS "" #define PARSGEN "" #define PARSOUT "" #define PARSSPEC "" //#define REFRESH #define SCANNER_DIR "" //#define SCANFILES "" #define SCANFLAGS "" #define SCANGEN "" #define SCANOUT "" #define SCANSPEC "" #define SHAREDREQ "" #define SOURCES "*.cc" #define TMP_DIR "tmp" #define USE_ECHO ON #define USE_VERSION #define DEFCOM "program" c++-annotations-10.6.0/src/tabs/main.cc0000644000175000017500000000046412745054221016446 0ustar frankfrank#include "main.ih" int main(int argc, char **argv) try { if (not arguments(argc, argv)) return 0; argv += optind; argc -= optind; Tabber tabber; if (argv[0][0] == '-') tabber.run(); if (not process(argv, tabber)) return 1; } catch (...) { return 1; } c++-annotations-10.6.0/src/tabs/version.cc0000644000175000017500000000056312745054221017207 0ustar frankfrank// version.cc #include "main.ih" #include "icmconf" #ifdef USE_VERSION #include "VERSION" #endif #ifndef AUTHOR #define AUTHOR "" #endif #ifndef VERSION #define VERSION "0.00.00" #endif #ifndef YEARS #define YEARS "2012" #endif namespace Icmbuild { char version[] = VERSION; char years[] = YEARS; char author[] = AUTHOR; } c++-annotations-10.6.0/src/tabs/process.cc0000644000175000017500000000101512745054221017171 0ustar frankfrank#include "main.ih" bool process(char **argv, Tabber &tabber) { char tempfile[] = "tab.tmp"; for (; *argv; ++argv) { if (not normalFile(*argv)) continue; if (!g_quiet) cout << "processing `" << *argv << "'\n"; unlink(tempfile); if (rename(*argv, tempfile)) { cout << "can't rename `" << *argv << "'\n"; return false; } tabber.run(tempfile, *argv); } unlink(tempfile); return true; } c++-annotations-10.6.0/src/tabs/main.ih0000644000175000017500000000071512745054221016460 0ustar frankfrank#include #include #include #include #include #include #include "globals.h" #include "tabber/tabber.h" namespace Icmbuild { extern char version[]; extern char years[]; extern char author[]; }; bool arguments(int argc, char **argv); void usage(std::string const &progname); bool normalFile(char const *fileName); bool process(char **argv, Tabber &tabber); using namespace std; c++-annotations-10.6.0/src/tabs/globals.h0000644000175000017500000000026512745054221017006 0ustar frankfrank#ifndef INCLUDED_GLOBALS_H_ #define INCLUDED_GLOBALS_H_ #include extern size_t g_minSpaces; extern size_t g_tabWidth; extern bool g_entab; extern bool g_quiet; #endif c++-annotations-10.6.0/src/tabs/CLASSES0000644000175000017500000000000712745054221016224 0ustar frankfranktabber c++-annotations-10.6.0/src/paren/0000755000175000017500000000000012745054221015363 5ustar frankfrankc++-annotations-10.6.0/src/paren/paren.cc0000644000175000017500000000516212745054221017003 0ustar frankfrank// paren.cc #include #include #include #include #include #include using namespace std; using namespace FBB; bool hdr = false; bool verbose; string version("2.00"); string years("1999-2006"); void header(char const *fn) { if (hdr) return; hdr = true; if (verbose) cout << "PROCESSING " << fn << endl; } void usage(string const &prog) { cout << "\n" << prog << " by Frank B. Brokken (f.b.brokken@rug.nl)\n" "Copyright " << years << " (c) GPL, V " << version << ".\n" "\n" "Usage: " << prog << " [-v] file(s)\n" "Where:\n" " -h: print this help-info\n" " -q: quiet: less output than otherwise\n" " -v: show the version\n" " file(s): file(s) to check for unbalanced parentheses.\n" " (A simple algorithm is used, in which all \n" " characters are treated equal).\n" "\n"; } int main(int argc, char **argv) try { Arg &arg = Arg::initialize("hqv", argc, argv); arg.versionHelp(usage, version.c_str(), 1); verbose = !arg.option('q'); bool ok = true; for (size_t idx = arg.nArgs(); idx--; ) { ifstream in(arg[idx]); if (!in) { cout << "Can't read " << arg[idx] << endl; ok = false; continue; } hdr = false; stack linenr; unsigned line = 0; string text; while (getline(in, text)) { ++line; for (char ch: text) { switch (ch) { case '(': linenr.push(line); break; case ')': if (linenr.empty()) { header(arg[idx]); cout << "\tExtra closepar in line " << line << endl; ok = false; break; } linenr.pop(); break; } } } while (!linenr.empty()) { header(arg[idx]); cout << "\tUnbalanced openpar in line " << linenr.top() << endl; linenr.pop(); ok = false; } } return ok ? 0 : 1; } catch(exception const &e) { cout << e.what() << endl; return 1; } catch(...) { return 1; } c++-annotations-10.6.0/TODO0000644000175000017500000000021312745054221014153 0ustar frankfrankAdd weak_ptr is_default_constructible instead of has_trivial_default_constructor, and other remove the has_trivial things -- all done -- c++-annotations-10.6.0/yo/0000755000175000017500000000000013005341513014107 5ustar frankfrankc++-annotations-10.6.0/yo/static.yo0000644000175000017500000000127512745054222015764 0ustar frankfrankincludefile(static/intro) lsect(StaticData)(Static data) includefile(static/data) subsect(Private static data) includefile(static/private) subsect(Public static data) includefile(static/public) subsect(Initializing static const data) includefile(static/const) lsubsect(GENCONST)(Generalized constant expressions (constexpr)) includefile(static/genconst) lsubsubsect(CONSTEXPR)(Constant expression data) includefile(static/constexprdata) sect(Static member functions) includefile(static/function) lsubsect(CALLINGCONVENTION)(Calling conventions) includefile(static/calling) c++-annotations-10.6.0/yo/namespaces/0000755000175000017500000000000012745054222016236 5ustar frankfrankc++-annotations-10.6.0/yo/namespaces/examples/0000755000175000017500000000000013005340354020046 5ustar frankfrankc++-annotations-10.6.0/yo/namespaces/examples/koenig1.cc0000644000175000017500000000067513005340356021724 0ustar frankfrank #include namespace FBB { enum Value // defines FBB::Value { FIRST }; void fun(Value x) { std::cout << "fun called for " << x << '\n'; } } int main() { fun(FBB::FIRST); // Koenig lookup: no namespace // for fun() specified } /* generated output: fun called for 0 */ c++-annotations-10.6.0/yo/namespaces/examples/koenig3.cc0000644000175000017500000000145313005340356021721 0ustar frankfrank #include namespace ES { enum Value // defines ES::Value { FIRST }; } namespace FBB { enum Value // defines FBB::Value { FIRST }; void fun(Value x, ES::Value y) { std::cout << "FBB::fun() called\n"; } } namespace ES { void fun(FBB::Value x, Value y) { std::cout << "ES::fun() called\n"; } } int main() { // fun(FBB::FIRST, ES::FIRST); ambiguity: resolved by // explicitly mentioning // the namespace ES::fun(FBB::FIRST, ES::FIRST); } /* generated output: ES::fun() called */ c++-annotations-10.6.0/yo/namespaces/examples/nesting.cc0000644000175000017500000000156213005340356022032 0ustar frankfranknamespace CppAnnotations { int value; namespace Virtual { void *pointer; } } // // 0 //using namespace CppAnnotations; // 1 //using namespace CppAnnotations::Virtual; // 2 //using namespace CppAnnotations; // 3 //using namespace Virtual; //using CppAnnotations::value; // 4 //using CppAnnotations::Virtual::pointer; //using namespace CppAnnotations::Virtual; // 5 //using CppAnnotations::value; int main() { // CppAnnotations::Virtual::pointer = 0; // 0 // CppAnnotations::value = 0; // value = 0; // 1 // Virtual::pointer = 0; // CppAnnotations::value = 0; // 2 // pointer = 0; // value = 0; // 3, 4, 5 // pointer = 0; } c++-annotations-10.6.0/yo/namespaces/examples/compound.cc0000644000175000017500000000044613005340356022207 0ustar frankfrank#include #include struct Namespace { // using namespace std; cannot be used here std::string d_str; std::string text() const; }; int main() { using namespace std; // but here is OK string text; Namespace ns; cout << ns.text(); } c++-annotations-10.6.0/yo/namespaces/examples/koenig2.cc0000644000175000017500000000113313005340356021713 0ustar frankfrank #include namespace FBB { enum Value // defines FBB::Value { FIRST }; void fun(Value x) { std::cout << "FBB::fun() called for " << x << '\n'; } } namespace ES { void fun(FBB::Value x) { std::cout << "ES::fun() called for " << x << '\n'; } } int main() { fun(FBB::FIRST); // No ambiguity: argument determines // the namespace } /* generated output: FBB::fun() called for 0 */ c++-annotations-10.6.0/yo/namespaces/examples/koenig4.cc0000644000175000017500000000043113005340356021715 0ustar frankfrank namespace FBB { struct Value {}; void fun(int x); void gun(Value x); } namespace ES { void fun(int x) { fun(x); } void gun(FBB::Value x) { gun(x); } } c++-annotations-10.6.0/yo/namespaces/defining.yo0000644000175000017500000000257112745054222020377 0ustar frankfrankNamespaces are defined according to the following syntax: verb( namespace identifier { // declared or defined entities // (declarative region) } ) The identifier used when defining a namespace is a standard bf(C++) identifier. Within the emi(declarative region), introduced in the above code example, functions, variables, structs, classes and even (nested) namespaces can be defined or declared. Namespaces cannot be defined within a function body. However, it is possible to define a namespace using multiple em(namespace) declarations. Namespaces are `em(open)' meaning that a namespace tt(CppAnnotations) could be defined in a file tt(file1.cc) and also in a file tt(file2.cc). Entities defined in the tt(CppAnnotations) namespace of files tt(file1.cc) and tt(file2.cc) are then united in one tt(CppAnnotations) namespace region. For example: verb( // in file1.cc namespace CppAnnotations { double cos(double argInDegrees) { ... } } // in file2.cc namespace CppAnnotations { double sin(double argInDegrees) { ... } } ) Both tt(sin) and tt(cos) are now defined in the same tt(CppAnnotations) namespace. Namespace entities can be defined outside of their namespaces. This topic is discussed in section ref(OUTSIDE). c++-annotations-10.6.0/yo/namespaces/placeholders.yo0000644000175000017500000000217312745054222021257 0ustar frankfrankThis section contains quite a few forward references. It merely introduces the emi(placeholders) namespace, which is nested under the tt(std) namespace; this section can be skipped without loss of continuity. Before using the namespace tt(std::placeholders) the tthi(functional) header file must be included. Further down the annotations() we will encounter em(function objects) (section ref(FUNOBJ)), which are `objects' that can be used as functions. Such function objects (also called em(functors)) are extensively used in the em(Standard Template Library) (STL, chapter ref(STL)). The STL offers a function (tt(bind), see section ref(BIND)), returning a function adaptor in which a function is called which may or may not already have received its arguments. If not, then em(placeholders) for arguments must be used, for which actual arguments must be specified once the functor that is returned by tt(bind) is called. Such placeholders have predefined names: tt(_1, _2, _3,) etc. These placeholders are defined in the tt(std::placeholders) namespace. Several illustrations of the use of these placeholders are found in section ref(BIND). c++-annotations-10.6.0/yo/namespaces/declaring.yo0000644000175000017500000000071212745054222020537 0ustar frankfrank Instead of em(defining) entities in a namespace, entities may also be em(declared) in a namespace. This allows us to put all the hi(namespace declarations) declarations in a header file that can thereupon be included in sources using the entities defined in the namespace. Such a header file could contain, e.g., verb( namespace CppAnnotations { double cos(double degrees); double sin(double degrees); } ) c++-annotations-10.6.0/yo/namespaces/nesting.yo0000644000175000017500000000712512745054222020263 0ustar frankfrankNamespaces can be nested. Here is an example: verb( namespace CppAnnotations { int value; namespace Virtual { void *pointer; } } ) The variable tt(value) is defined in the tt(CppAnnotations) namespace. Within the tt(CppAnnotations) namespace another namespace (tt(Virtual)) is nested. Within that latter namespace the variable tt(pointer) is defined. To refer to these variable the following options are available: itemization( it() The hi(fully qualified name)em(fully qualified names) can be used. A fully qualified name of an entity is a list of all the namespaces that are encountered until reaching the definition of the entity. The namespaces and entity are glued together by the scope resolution operator: verb( int main() { CppAnnotations::value = 0; CppAnnotations::Virtual::pointer = 0; } ) it() A tt(using namespace CppAnnotations) directive can be provided. Now tt(value) can be used without any prefix, but tt(pointer) must be used with the tt(Virtual::) prefix: verb( using namespace CppAnnotations; int main() { value = 0; Virtual::pointer = 0; } ) it() A tt(using namespace) directive for the full namespace chain can be used. Now tt(value) needs its tt(CppAnnotations) prefix again, but tt(pointer) doesn't require a prefix anymore: verb( using namespace CppAnnotations::Virtual; int main() { CppAnnotations::value = 0; pointer = 0; } ) it() When using two separate tt(using namespace) directives none of the namespace prefixes are required anymore: verb( using namespace CppAnnotations; using namespace Virtual; int main() { value = 0; pointer = 0; } ) it() The same can be accomplished (i.e., no namespace prefixes) for specific variables by providing specific tt(using) declarations: verb( using CppAnnotations::value; using CppAnnotations::Virtual::pointer; int main() { value = 0; pointer = 0; } ) it() A combination of tt(using namespace) directives and tt(using) declarations can also be used. E.g., a tt(using namespace) directive can be used for the tt(CppAnnotations::Virtual) namespace, and a tt(using) declaration can be used for the tt(CppAnnotations::value) variable: verb( using namespace CppAnnotations::Virtual; using CppAnnotations::value; int main() { pointer = 0; } ) ) Following a tt(using namespace) directive all entities of that namespace can be used without any further prefix. If a single tt(using namespace) directive is used to refer to a nested namespace, then all entities of that nested namespace can be used without any further prefix. However, the entities defined in the more shallow namespace(s) still need the shallow namespace's name(s). Only after providing specific tt(using namespace) directives or tt(using) declarations namespace qualifications can be omitted. When fully qualified names are preferred but a long name like verb( CppAnnotations::Virtual::pointer ) is considered too long, a emi(namespace alias) may be used: verb( namespace CV = CppAnnotations::Virtual; ) This defines tt(CV) as an em(alias) for the full name. The variable tt(pointer) may now be accessed using: verb( CV::pointer = 0; ) A namespace alias can also be used in a tt(using namespace) directive or tt(using) declaration: verb( namespace CV = CppAnnotations::Virtual; using namespace CV; ) c++-annotations-10.6.0/yo/namespaces/referring.yo0000644000175000017500000000415312745054222020575 0ustar frankfrankGiven a namespace and its entities, the i(scope resolution operator) can be used to refer to its entities. For example, the function tt(cos()) defined in the tt(CppAnnotations) namespace may be used as follows: verb( // assume CppAnnotations namespace is declared in the // following header file: #include int main() { cout << "The cosine of 60 degrees is: " << CppAnnotations::cos(60) << '\n'; } ) This is a rather cumbersome way to refer to the tt(cos()) function in the tt(CppAnnotations) namespace, especially so if the function is frequently used. In cases like these an em(abbreviated) form can be used after specifying a emi(using declaration). Following verb( using CppAnnotations::cos; // note: no function prototype, // just the name of the entity // is required. ) calling tt(cos) results in a call of the tt(cos) function defined in the tt(CppAnnotations) namespace. This implies that the standard tt(cos) function, accepting radians, is not automatically called anymore. To call that latter tt(cos) function the plain scope resolution operator should be used: verb( int main() { using CppAnnotations::cos; ... cout << cos(60) // calls CppAnnotations::cos() << ::cos(1.5) // call the standard cos() function << '\n'; } ) A tt(using) declaration can have restricted scope. It can be used inside a block. The tt(using) declaration prevents the definition of entities having the same name as the one used in the tt(using) declaration. It is not possible to specify a tt(using) declaration for a variable tt(value) in some namespace, and to define (or declare) an identically named object in a block also containing a tt(using) declaration. Example: verb( int main() { using CppAnnotations::value; ... cout << value << '\n'; // uses CppAnnotations::value int value; // error: value already declared. } ) c++-annotations-10.6.0/yo/namespaces/std.yo0000644000175000017500000000372112745054222017404 0ustar frankfrankThe tt(std) namespace is reserved by bf(C++). The standard defines many entities that are part of the runtime available software (e.g., tt(cout, cin, cerr)); the templates defined in the em(Standard Template Library) (cf. chapter ref(STL)); and the em(Generic Algorithms) (cf. chapter ref(GENERIC)) are defined in the tt(std) namespace. Regarding the discussion in the previous section, tt(using) declarations may be used when referring to entities in the tt(std) namespace. For example, to use the tt(std::cout) stream, the code may declare this object as follows: verb( #include using std::cout; ) Often, however, the identifiers defined in the tt(std) namespace can all be accepted without much thought. Because of that, one frequently encounters a tt(using) directive, allowing the programmer to omit a namespace prefix when referring to any of the entities defined in the namespace specified with the tt(using) directive. Instead of specifying tt(using) declarations the following tt(using) directive is frequently encountered: construction like verb( #include using namespace std; ) Should a tt(using) directive, rather than tt(using) declarations be used? As a i(rule of thumb) one might decide to stick to tt(using) declarations, up to the point where the list becomes impractically long, at which point a tt(using) directive could be considered. Two hi(using: restrictions) restrictions apply to tt(using) directives and declarations: itemization( it() Programmers should not declare or define anything inside the tt(namespace std). This is em(not) compiler enforced but is imposed upon user code by the standard; it() tt(Using) declarations and directives should not be imposed upon code written by third parties. In practice this means that tt(using) directives and declarations should be banned from header files and should only be used in source files (cf. section ref(NAMESPACEHDR)). ) c++-annotations-10.6.0/yo/namespaces/intro.yo0000644000175000017500000000200012745054222017732 0ustar frankfrankImagine a math teacher who wants to develop an interactive math program. For this program functions like tt(cos, sin, tan) etc. are to be used accepting arguments in degrees rather than arguments in radians. Unfortunately, the function name tt(cos) is already in use, and that function accepts radians as its arguments, rather than degrees. Problems like these are usually solved by defining another name, e.g., the function name tt(cosDegrees) is defined. bf(C++) offers an alternative solution through hi(namespace)em(namespaces). Namespaces can be considered as areas or regions in the code in which identifiers may be defined. Identifiers defined in a namespace normally won't conflict with names already defined elsewhere (i.e., outside of their namespaces). So, a function tt(cos) (expecting angles in degrees) could be defined in a namespace tt(Degrees). When calling tt(cos) from within tt(Degrees) you would call the tt(cos) function expecting degrees, rather than the standard tt(cos) function expecting radians. c++-annotations-10.6.0/yo/namespaces/koenig.yo0000644000175000017500000000634112745054222020067 0ustar frankfrankIf emi(Koenig lookup) were called the `Koenig principle', it could have been the title of a new i(Ludlum) novel. However, it is not. Instead it refers to a bf(C++) technicality. `Koenig lookup' refers to the fact that if a function is called without specifying its namespace, then the namespaces of its argument types are used to determine the function's namespace. If the namespace in which the argument types are defined contains such a function, then that function is used. This procedure is called the `Koenig lookup'. As an illustration consider the next example. The function tt(FBB::fun(FBB::Value v)) is defined in the tt(FBB) namespace. It can be called without explicitly mentioning its namespace: verbinclude(-a examples/koenig1.cc) The compiler is rather smart when handling namespaces. If tt(Value) in the tt(namespace FBB) would have been defined as tt(typedef int Value) then tt(FBB::Value) would be recognized as tt(int), thus causing the Koenig lookup to fail. As another example, consider the next program. Here two namespaces are involved, each defining their own tt(fun) function. There is no ambiguity, since the argument defines the namespace and tt(FBB::fun) is called: verbinclude(-a examples/koenig2.cc) Here is an example in which there em(is) an ambiguity: tt(fun) has two arguments, one from each namespace. The ambiguity must be resolved by the programmer: verbinclude(-a examples/koenig3.cc) An interesting subtlety with namespaces is that definitions in one namespace may break the code defined in another namespace. It shows that namespaces may affect each other and that namespaces may backfire if we're not aware of their peculiarities. Consider the following example: verbinclude(-a examples/koenig4.cc) Whatever happens, the programmer'd better not use any of the tt(ES::fun) functions since it results in infinite recursion. However, that's not the point. The point is that the programmer won't even be given the opportunity to call tt(ES::fun) since the compilation fails. Compilation fails for tt(gun) but not for tt(fun). But why is that so? Why is tt(ES::fun) flawlessly compiling while tt(ES::gun) isn't? In tt(ES::fun) tt(fun(x)) is called. As tt(x)'s type is not defined in a namespace the Koenig lookup does not apply and tt(fun) calls itself with infinite recursion. With tt(ES::gun) the argument is defined in the tt(FBB) namespace. Consequently, the tt(FBB::gun) function is a possible candidate to be called. But tt(ES::gun) itself also is possible as tt(ES::gun)'s prototype perfectly matches the call tt(gun(x)). Now consider the situation where tt(FBB::gun) has not yet been declared. Then there is of course no ambiguity. The programmer responsible for the tt(ES) namespace is resting happily. Some time after that the programmer who's maintaining the tt(FBB) namespace decides it may be nice to add a function tt(gun(Value x)) to the tt(FBB) namespace. Now suddenly the code in the namespace tt(ES) breaks because of an addition in a completely other namespace (tt(FBB)). Namespaces clearly are not completely independent of each other and we should be aware of subtleties like the above. Later in the annotations() (chapter ref(OVERLOADING)) we'll return to this issue. c++-annotations-10.6.0/yo/namespaces/outside.yo0000644000175000017500000000660612745054222020273 0ustar frankfrankIt is not strictly necessary to i(define members of namespaces) inside a namespace region. But before an entity is defined em(outside) of a namespace it must have been declared em(inside) its namespace. To define an entity outside of its namespace its name must be em(fully qualified) by prefixing the member by its namespaces. The definition may be provided at the global level or at intermediate levels in the case of nested namespaces. This allows us to define an entity belonging to namespace tt(A::B) within the region of namespace tt(A). Assume the type tt(int INT8[8]) is defined in the tt(CppAnnotations::Virtual) namespace. Furthermore assume that it is our intent to define a function tt(squares), inside the namespace nl() tt(CppAnnotations::Virtual) returning a pointer to tt(CppAnnotations::Virtual::INT8). Having defined the prerequisites within the tt(CppAnnotations::)tt(Virtual) namespace, our function could be defined as follows (cf. chapter ref(MEMORY) for coverage of the memory allocation operator tt(new[])): verb( namespace CppAnnotations { namespace Virtual { void *pointer; typedef int INT8[8]; INT8 *squares() { INT8 *ip = new INT8[1]; for (size_t idx = 0; idx != sizeof(INT8) / sizeof(int); ++idx) (*ip)[idx] = (idx + 1) * (idx + 1); return ip; } } } ) The function tt(squares) defines an array of one tt(INT8) vector, and returns its address after initializing the vector by the squares of the first eight natural numbers. Now the function tt(squares) can be defined outside of the tt(CppAnnotations::)tt(Virtual) namespace: verb( namespace CppAnnotations { namespace Virtual { void *pointer; typedef int INT8[8]; INT8 *squares(); } } CppAnnotations::Virtual::INT8 *CppAnnotations::Virtual::squares() { INT8 *ip = new INT8[1]; for (size_t idx = 0; idx != sizeof(INT8) / sizeof(int); ++idx) (*ip)[idx] = (idx + 1) * (idx + 1); return ip; } ) In the above code fragment note the following: itemization( itt(squares) is declared inside of the tt(CppAnnotations::Virtual) namespace. itt() The definition outside of the namespace region requires us to use the fully qualified name of the function em(and) of its return type. itt() em(Inside) the body of the function tt(squares) we are within the tt(CppAnnotations::)tt(Virtual) namespace, so inside the function fully qualified names (e.g., for tt(INT8)) are not required any more. ) Finally, note that the function could also have been defined in the tt(CppAnnotations) region. In that case the tt(Virtual) namespace would have been required when defining tt(squares()) and when specifying its return type, while the internals of the function would remain the same: verb( namespace CppAnnotations { namespace Virtual { void *pointer; typedef int INT8[8]; INT8 *squares(); } Virtual::INT8 *Virtual::squares() { INT8 *ip = new INT8[1]; for (size_t idx = 0; idx != sizeof(INT8) / sizeof(int); ++idx) (*ip)[idx] = (idx + 1) * (idx + 1); return ip; } } ) c++-annotations-10.6.0/yo/namespaces/closed.yo0000644000175000017500000000133612745054222020063 0ustar frankfrankNamespaces can be defined without a name. Such an hi(namespace: anonymous) anonymous namespace restricts the visibility of the defined entities to the source file defining the anonymous namespace. Entities defined in the anonymous namespace are comparable to bf(C)'s ti(static) functions and variables. In bf(C++) the tt(static) keyword can still be used, but its preferred use is in tt(class) definitions (see chapter ref(Classes)). In situations where in bf(C) static variables or functions would have been used the anonymous namespace should be used in bf(C++). The anonymous namespace is a hi(namespace: closed) closed namespace: it is not possible to add entities to the same anonymous namespace using different source files. c++-annotations-10.6.0/yo/namespaces/directive.yo0000644000175000017500000000373012745054222020570 0ustar frankfrankA generalized alternative to the tt(using) declaration is the emi(using directive): verb( using namespace CppAnnotations; ) Following this directive, em(all) entities defined in the tt(CppAnnotations) namespace are used as if they were declared by tt(using) declarations. While the tt(using) directive is a quick way to hi(namespace: import all names) import all the names of a namespace (assuming the namespace has previously been declared or defined), it is at the same time a somewhat dirty way to do so, as it is less clear what entity is actually used in a particular block of code. If, e.g., tt(cos) is defined in the tt(CppAnnotations) namespace, tt(CppAnnotations::cos) is going to be used when tt(cos) is called. However, if tt(cos) is em(not) defined in the tt(CppAnnotations) namespace, the standard tt(cos) function will be used. The tt(using) directive does not document as clearly as the tt(using) declaration what entity will actually be used. Therefore use caution when applying the tt(using) directive. Namespace declarations are context sensitive: when a tt(using namespace) declaration is specified inside a compound statement then the declaration is valid until the compound statement's closing curly bracket has been encountered. In the next example a string tt(first) is defined without explicit specfying tt(std::string), but once the compound statement has ended the scope of the tt(using namespace std) declaration has also ended, and so tt(std::) is required once again when defining tt(second): verb( #include int main() { { using namespace std; string first; } std::string second; } ) A tt(using namespace) directive cannot be used within the declaration block of a class- or enumeration-type. E.g., the following example won't compile: verb( struct Namespace { using namespace std; // won't compile }; ) c++-annotations-10.6.0/yo/concrete/0000755000175000017500000000000012745054222015721 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/fdunget.yo0000644000175000017500000001056112745054221017730 0ustar frankfranktt(Streambuf) classes and classes derived from ti(streambuf) should support em(at least) ungetting the last read character. Special care must be taken when em(series) of ti(unget) calls must be supported. In this section the construction of a class supporting a configurable number of tt(istream::unget) or hi(putback)tt(istream::putback) calls is discussed. Support for multiple (say `tt(n)') tt(unget) calls is implemented by reserving an initial section of the input buffer, which is gradually filled up to contain the last tt(n) characters read. The class is implemented as follows: itemization( it() Once again, the class is derived from tt(std::streambuf). It defines several data members, allowing the class to perform the bookkeeping required to maintain an unget-buffer of a configurable size: verbinclude(//CLASS examples/fdunget.h) it() The class's constructor expects a i(file descriptor), a buffer size and the number of characters that can be ungot or pushed back as its arguments. This number determines the size of a em(reserved) area, defined as the first tt(d_reserved) bytes of the class's input buffer. itemization( it() The input buffer will always be at least one byte larger than tt(d_reserved). So, a certain number of bytes may be read. Once tt(d_reserved) bytes have been read at most tt(d_reserved) bytes can be ungot. it() Next, the starting point for reading operations is configured. It is called tt(d_base), pointing to a location tt(d_reserved) bytes beyond the location represented by tt(d_buffer). This is always the location where buffer refills start. it() Now that the buffer has been constructed, we're ready to define tt(streambuf)'s buffer pointers using tt(setg). As no characters have been read yet, all pointers are set to point to tt(d_base). If tt(unget) is called at this point, no characters are available, and tt(unget) (correctly) fails. it() Eventually, the refill buffer's size is determined as the number of allocated bytes minus the size of the reserved area. ) Here is the class's constructor: verbinclude(//CONS examples/fdunget.h) it() The class's destructor simply returns the memory allocated for the buffer to the common pool: verbinclude(//DESTR examples/fdunget.h) it() Finally, tt(underflow) is overridden as follows: itemization( it() First tt(underflow) determines the number of characters that could potentially be ungot. If that number of characters are ungot, the input buffer is exhausted. So this value may be any value between 0 (the initial state) or the input buffer's size (when the reserved area has been filled up completely, and all current characters in the remaining section of the buffer have also been read); it() Next the number of bytes to move into the reserved area is computed. This number is at most tt(d_reserved), but it is set equal to the actual number of characters that can be ungot if this value is smaller; it() Now that the number of characters to move into the reserved area is known, this number of characters is moved from the input buffer's end to the area immediately before tt(d_base); it() Then the buffer is refilled. This all is standard, but notice that reading starts from tt(d_base) and not from tt(d_buffer); it() Finally, tt(streambuf)'s read buffer pointers are set up. hi(eback) tt(Eback) is set to tt(move) locations before tt(d_base), thus defining the guaranteed unget-area, ti(gptr) is set to tt(d_base), since that's the location of the first read character after a refill, and ti(egptr) is set just beyond the location of the last character read into the buffer. ) Here is tt(underflow)'s implementation: verbinclude(//UNDERFLOW examples/fdunget.h) ) bf(An example using FdUnget) The next example program illustrates the use of the class tt(FdUnget). It reads at most 10 characters from the standard input, stopping at endOfFile(). A guaranteed unget-buffer of 2 characters is defined in a buffer holding 3 characters. Just before reading a character, the program tries to unget at most 6 characters. This is, of course, not possible; but the program nicely ungets as many characters as possible, considering the actual number of characters read: verbinclude(-a examples/fdunget.cc) c++-annotations-10.6.0/yo/concrete/predicates.yo0000644000175000017500000000710512745054222020420 0ustar frankfrankMany tt(STL) algorithms require us to specify predicates. For example tt(count_if()) (ref(COUNTIF)), tt(find_if()) (ref(FINDIF)), tt(min_element()) (ref(MINEL)) or tt(search()) (ref(SEARCH)). In these cases a function object must be provided whose tt(operator()()) member is called, defining the predicate function. Conditional to its argument(s), it returns tt(true) or tt(false). Sometimes a simple emi(predicate function) already exists. For example tt(int isdigit(int)) returns if its argument is a character representing a digit, otherwise 0; tt(char *strchr(char const *, int)) returns a non-0 pointer if the set of characters provided as its first argument contains the character represented by its second argument, and returns 0 otherwise. Existing unary predicate functions may be specified with the tt(PredicateFunction1) class template, defining a unary predicate class. Its tt(typedef) ti(argument_type) is required by, e.g., function adapters: verbinclude(//UNARYPRED examples/predicates.h) Existing binary predicate functions may be specified with the tt(PredicateFunction2) class template, defining a binary predicate class. Its tt(typedef)s ti(first_argument_type), ti(second_argument_type) and ti(result_type) are required by, e.g., function adapters: verbinclude(//BINPRED examples/predicates.h) Here is an example of their use, counting the number of digits appearing at the program's standard input stream: verbinclude(-a examples/predfun.cc) Alternatively, although the function operator is called when a predicate function is used, the actual member function we have available might be another function or a useful member may be available from an object of another class. In that case an object acting as em(man in the middle) might come in handy. The following class tt(PredicateObject1) performs exactly that function. It defines a class template whose parameters refer to a class and a data type. Its constructors expect a pointer or reference to an object of the template parameter's class as well as a pointer to a member function of that class implementing a predicate. By default it's the class's function object operator. Here is its definition: verbinclude(//PREDOBJ1 examples/predicates.h) The class tt(PredicateObject2) can be used to construct a emi(binary predicate) object. Here the class template has three parameters: the class type of the object passed to its constructor as well as the types of the two arguments of the binary predicate member that's called: verbinclude(//PREDOBJ2 examples/predicates.h) The object passed to these constructors is not copied by generic algorithms, in contrast to the tt(PredicateObject)s themselves, which em(are) copied. The object specified when instantiating the tt(PredicateObject)s must actually exist before the instantiation takes place. Also, the object's members do not have to be tt(const) member functions, thus allowing modifications of the passed object's data. Function adaptors may be used with the tt(PredicateObject)s as well. Here is an example using tt(PredicateObject)s. The program counts the number of words containing vowels appearing at the program's standard input stream. First a support class tt(Contains) is defined. It's a simple class defining unary and binary predicate functions: verbinclude(//CONTAINS examples/predobj.cc) When the program is called without arguments its unary predicate object functionality is used, otherwise its binary predicate object functionality. Here is the program's tt(main()) function: verbinclude(//MAIN examples/predobj.cc) c++-annotations-10.6.0/yo/concrete/examples/0000755000175000017500000000000013005340354017531 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/examples/fork.h0000644000175000017500000000105413005340354020643 0ustar frankfrank//CLASS class Fork { int d_pid; public: virtual ~Fork(); void fork(); protected: int pid() const; int waitForChild(); // returns the status private: virtual void childRedirections(); virtual void parentRedirections(); virtual void childProcess() = 0; // pure virtual members virtual void parentProcess() = 0; }; //= //PID inline int Fork::pid() const { return d_pid; } //= c++-annotations-10.6.0/yo/concrete/examples/binary5.h0000644000175000017500000000057413005340354021261 0ustar frankfrank #ifndef INCLUDED_BINOPS_H_ #define INCLUDED_BINOPS_H_ #include template Type operator+(Type &&lhs, Type const &rhs) { return lhs += rhs; } template Type operator+(Type const &lhs, Type const &rhs) { Type tmp(lhs); return operator+(std::move(tmp), rhs); } #endif c++-annotations-10.6.0/yo/concrete/examples/stringptr.h0000644000175000017500000000222213005340355021735 0ustar frankfrank #ifndef INCLUDED_STRINGPTR_H_ #define INCLUDED_STRINGPTR_H_ #include #include #include "iterator.h" class StringPtr: public std::vector { public: typedef RandomPtrIterator < StringPtr, std::vector::iterator, std::string > iterator; typedef std::reverse_iterator reverse_iterator; iterator begin(); iterator end(); reverse_iterator rbegin(); reverse_iterator rend(); }; inline StringPtr::iterator StringPtr::begin() { return iterator(this->std::vector::begin() ); } inline StringPtr::iterator StringPtr::end() { return iterator(this->std::vector::end()); } inline StringPtr::reverse_iterator StringPtr::rbegin() { return reverse_iterator(end()); } inline StringPtr::reverse_iterator StringPtr::rend() { return reverse_iterator(begin()); } #endif c++-annotations-10.6.0/yo/concrete/examples/bitand.h0000644000175000017500000000037613005340354021151 0ustar frankfrank #include template struct bitAnd: public std::binary_function<_Tp, _Tp, _Tp> { _Tp &&operator()(_Tp const &__x, _Tp const &__y) const { return std::move(__x & __y); } }; c++-annotations-10.6.0/yo/concrete/examples/ifdnbuf.h0000644000175000017500000000423513005340354021323 0ustar frankfrank #ifndef IFDNBUF_H_ #define IFDNBUF_H_ #include #include #include //CLASS class IFdNStreambuf: public std::streambuf { protected: int d_fd; size_t d_bufsize; char* d_buffer; public: IFdNStreambuf(); IFdNStreambuf(int fd, size_t bufsize = 1); virtual ~IFdNStreambuf(); void open(int fd, size_t bufsize = 1); private: virtual int underflow(); virtual std::streamsize xsgetn(char *dest, std::streamsize n); }; //= //CONS inline IFdNStreambuf::IFdNStreambuf() : d_bufsize(0), d_buffer(0) {} inline IFdNStreambuf::IFdNStreambuf(int fd, size_t bufsize) { open(fd, bufsize); } //= // In real applications, the following members should be defined in // source files. Headers should not have external linkage. //DESTR IFdNStreambuf::~IFdNStreambuf() { if (d_bufsize) { close(d_fd); delete[] d_buffer; } } //= //OPEN void IFdNStreambuf::open(int fd, size_t bufsize) { d_fd = fd; d_bufsize = bufsize; d_buffer = new char[d_bufsize]; setg(d_buffer, d_buffer + d_bufsize, d_buffer + d_bufsize); } //= //UFLOW int IFdNStreambuf::underflow() { if (gptr() < egptr()) return *gptr(); int nread = read(d_fd, d_buffer, d_bufsize); if (nread <= 0) return EOF; setg(d_buffer, d_buffer, d_buffer + nread); return *gptr(); } //= //XSGETN std::streamsize IFdNStreambuf::xsgetn(char *dest, std::streamsize n) { int nread = 0; while (n) { if (!in_avail()) { if (underflow() == EOF) break; } int avail = in_avail(); if (avail > n) avail = n; memcpy(dest + nread, gptr(), avail); gbump(avail); nread += avail; n -= avail; } return nread; } //= #endif c++-annotations-10.6.0/yo/concrete/examples/foreach.OBS0000644000175000017500000000216412745054221021515 0ustar frankfrank #include #include #include "foreach.h" #include using namespace std; // ----------------------------------------------------------------- class X { public: void handler(std::string const &str) { std::cout << str << '\n'; } void handler(std::string const &str) const { std::cout << "const: " << str << '\n'; } void constMember(std::string const &str) const { std::cout << "const member: " << str << '\n'; } void nonConstMember(std::string const &str) { std::cout << "non-const member: " << str << '\n'; } void operator()(std::string const &str) const { std::cout << "op()() cons " << str << '\n'; } }; int main(int argc, char **argv) { X x; STL(argv, argv + argc, &std::for_each >, x, &X::constMember); } c++-annotations-10.6.0/yo/concrete/examples/command.OBS0000644000175000017500000000312312745054221021520 0ustar frankfrank #include #include #include enum { UNKNOWN, START, EXIT, STOP, TEXT }; int next(int &value, std::string &line) { if (!getline(std::cin, line)) throw "Command::next(): reading cin failed"; if (line == "start") return START; if (line == "exit") return EXIT; if (line.find("stop") == 0) { std::istringstream istr(line.substr(4)); istr >> value; return !istr ? UNKNOWN : STOP; } std::istringstream istr(line.c_str()); istr >> value; if (istr) { getline(istr, line); return line = istr.str(); return !istr ? UNKNOWN : TEXT; } int main() { while (true) { std::string line; int value; std::cout << "? " << std::flush; switch (next(value, line)) { case START: std::cout << "start\n"; break; case EXIT: std::cout << "exit\n"; return 0; break; case STOP: std::cout << "stop " << value << "\n"; break; case TEXT: std::cout << "text: " << line << "\n"; break; default: std::cout << "unknown: " << line << "\n"; break; } } } c++-annotations-10.6.0/yo/concrete/examples/lines0.h0000644000175000017500000000034713005340354021100 0ustar frankfrank #include #include //LINES class Lines { std::vector d_line; public: Lines(std::istream &in); std::string &operator[](size_t idx); }; //= c++-annotations-10.6.0/yo/concrete/examples/buildslurp0000755000175000017500000000010712745054221021647 0ustar frankfrank#!/bin/bash g++ -Wall parentslurp.cc fork.cc pipe.cc waitforchild.cc c++-annotations-10.6.0/yo/concrete/examples/bitnot.h0000644000175000017500000000033613005340354021203 0ustar frankfrank #include template struct bit_not: public std::unary_function<_Tp, _Tp> { _Tp &&operator()(_Tp const &__x) const { return _Tp(~__x); } }; c++-annotations-10.6.0/yo/concrete/examples/fdout.cc0000644000175000017500000000143713005340355021167 0ustar frankfrank #include #include #include #include "fdout.h" using namespace std; int main(int argc, char **argv) { OFdnStreambuf fds(STDOUT_FILENO, 500); ostream os(&fds); switch (argc) { case 1: for (string s; getline(cin, s); ) os << s << '\n'; os << "COPIED cin LINE BY LINE\n"; break; case 2: cin >> os.rdbuf(); // Alternatively, use: cin >> &fds; os << "COPIED cin BY EXTRACTING TO os.rdbuf()\n"; break; case 3: os << cin.rdbuf(); os << "COPIED cin BY INSERTING cin.rdbuf() into os\n"; break; } } c++-annotations-10.6.0/yo/concrete/examples/fdunget.cc0000644000175000017500000000402013005340355021471 0ustar frankfrank #include "fdunget.h" #include #include #include using namespace std; int main() { FdUnget fds(0, 3, 2); istream is(&fds); char c; for (int idx = 0; idx < 10; ++idx) { cout << "after reading " << idx << " characters:\n"; for (int ug = 0; ug <= 6; ++ug) { if (!is.unget()) { cout << "\tunget failed at attempt " << (ug + 1) << "\n" << "\trereading: '"; is.clear(); while (ug--) { is.get(c); cout << c; } cout << "'\n"; break; } } if (!is.get(c)) { cout << " reached\n"; break; } cout << "Next character: " << c << '\n'; } } /* Generated output after 'echo abcde | program': after reading 0 characters: unget failed at attempt 1 rereading: '' Next character: a after reading 1 characters: unget failed at attempt 2 rereading: 'a' Next character: b after reading 2 characters: unget failed at attempt 3 rereading: 'ab' Next character: c after reading 3 characters: unget failed at attempt 4 rereading: 'abc' Next character: d after reading 4 characters: unget failed at attempt 4 rereading: 'bcd' Next character: e after reading 5 characters: unget failed at attempt 4 rereading: 'cde' Next character: after reading 6 characters: unget failed at attempt 4 rereading: 'de ' reached */ c++-annotations-10.6.0/yo/concrete/examples/foreach.h0000644000175000017500000000205513005340354021313 0ustar frankfrank //FOREACH1 template Class &ForEach(Iterator begin, Iterator end, Class &object, void (Class::*member)(Data &)) { while (begin != end) (object.*member)(*begin++); return object; } //= //FOREACH2 template Class &ForEach(Iterator begin, Iterator end, Class &object, void (Class::*member)(Data &) const) { while (begin != end) (object.*member)(*begin++); return object; } //= //FOREACH3 template Class &ForEach(Iterator begin, Iterator end, Class &object) { while (begin != end) object(*begin++); return object; } //= //FOREACH4 template void ForEach(Iterator begin, Iterator end, Data(*function)(Data)) { for (; begin != end; ++begin) *begin = function(*begin); } //= c++-annotations-10.6.0/yo/concrete/examples/fork.ih0000644000175000017500000000017213005340354021014 0ustar frankfrank #include "fork.h" #include #include #include #include c++-annotations-10.6.0/yo/concrete/examples/removeodd.cc0000644000175000017500000000102013005340355022016 0ustar frankfrank #include #include #include #include #include "bitand.h" using namespace std; int main() { vector vi; for (int idx = 0; idx < 10; ++idx) vi.push_back(idx); copy ( vi.begin(), remove_if(vi.begin(), vi.end(), bind2nd(bitAnd(), 1)), ostream_iterator(cout, " ") ); cout << '\n'; } /* Generated output: 0 2 4 6 8 */ c++-annotations-10.6.0/yo/concrete/examples/predfun.cc0000644000175000017500000000206313005340355021505 0ustar frankfrank #include #include #include #include #include #include #include "predicates.h" using namespace std; int main(int argc, char **argv) { if (argc == 1) cout << "Counted " << count_if(istream_iterator(cin), istream_iterator(), PredicateFunction1(isdigit)) << " digits\n"; else cout << "Counted " << count_if(istream_iterator(cin), istream_iterator(), bind1st( PredicateFunction2(strchr), "0123456789") ) << " digits\n"; } /* Generated output after echo 1 world, there are 6 continents and 3 oceans | a.out or: echo 1 world, there are 6 continents and 3 oceans | a.out 2 Counted 3 digits */ c++-annotations-10.6.0/yo/concrete/examples/command.h0000644000175000017500000000062413005340354021322 0ustar frankfrank #include #include #include class Command { std::string d_line; std::vector d_command; public: Command(size_t n, char const **commands) { copy(commands, commands + n, back_inserter(d_command)); } int next(std::string &line); }; c++-annotations-10.6.0/yo/concrete/examples/foreachfbbdemo.OBS0000644000175000017500000000171612745054221023036 0ustar frankfrank#include #include #include #include template class Vector2: public std::vector > { template friend Class &FBB::ForEach(Iterator begin, Iterator end, Class *object, void (Class::*member)(Data &)); public: void process() { FBB::ForEach(begin(), end(), this, &Vector2::rows); } private: void rows(std::vector &row) { FBB::ForEach(row.begin(), row.end(), this, &Vector2::columns); std::cout << '\n'; } void columns(Type &str) { std::cout << str << " "; } }; using namespace std; int main() { Vector2 c; c.push_back(vector(3, "Hello")); c.push_back(vector(2, "World")); c.process(); } c++-annotations-10.6.0/yo/concrete/examples/fdout.h0000644000175000017500000000306013005340354021022 0ustar frankfrank #ifndef OFDNSTREAMBUF_H_ #define OFDNSTREAMBUF_H_ #include #include //CLASS class OFdnStreambuf: public std::streambuf { size_t d_bufsize; int d_fd; char *d_buffer; public: OFdnStreambuf(); OFdnStreambuf(int fd, size_t bufsize = 1); virtual ~OFdnStreambuf(); void open(int fd, size_t bufsize = 1); private: virtual int sync(); virtual int overflow(int c); }; //= //CONS inline OFdnStreambuf::OFdnStreambuf() : d_bufsize(0), d_buffer(0) {} inline OFdnStreambuf::OFdnStreambuf(int fd, size_t bufsize) { open(fd, bufsize); } //= //DESTR inline OFdnStreambuf::~OFdnStreambuf() { if (d_buffer) { sync(); delete[] d_buffer; } } //= //OPEN inline void OFdnStreambuf::open(int fd, size_t bufsize) { d_fd = fd; d_bufsize = bufsize == 0 ? 1 : bufsize; d_buffer = new char[d_bufsize]; setp(d_buffer, d_buffer + d_bufsize); } //= //SYNC inline int OFdnStreambuf::sync() { if (pptr() > pbase()) { write(d_fd, d_buffer, pptr() - pbase()); setp(d_buffer, d_buffer + d_bufsize); } return 0; } //= //OVERFLOW inline int OFdnStreambuf::overflow(int c) { sync(); if (c != EOF) { *pptr() = c; pbump(1); } return c; } //= #endif c++-annotations-10.6.0/yo/concrete/examples/lines.h0000644000175000017500000000227113005340354021016 0ustar frankfrank#include #include #include #include //LINES class Lines { std::vector d_line; public: class Proxy; Proxy operator[](size_t idx); class Proxy { friend Proxy Lines::operator[](size_t idx); std::string &d_str; Proxy(std::string &str); public: std::string &operator=(std::string const &rhs); operator std::string const &() const; }; Lines(std::istream &in); }; //= //MEMBERS inline Lines::Proxy::Proxy(std::string &str) : d_str(str) {} inline std::string &Lines::Proxy::operator=(std::string const &rhs) { return d_str = rhs; } inline Lines::Proxy::operator std::string const &() const { return d_str; } //= //INSERT inline std::ostream &operator<<(std::ostream &out, Lines::Proxy const &proxy) { return out << static_cast(proxy); } //= //OPIDX inline Lines::Proxy Lines::operator[](size_t idx) { Proxy ret(d_line[idx]); return ret; } //= c++-annotations-10.6.0/yo/concrete/examples/iterators.cc0000644000175000017500000000125113005340355022054 0ustar frankfrank#include #include #include "stringptr.h" using namespace std; int main(int argc, char **argv) { StringPtr sp; while (*argv) sp.push_back(new string(*argv++)); sort(sp.begin(), sp.end()); copy(sp.begin(), sp.end(), ostream_iterator(cout, " ")); cout << "\n======\n"; sort(sp.rbegin(), sp.rend()); copy(sp.begin(), sp.end(), ostream_iterator(cout, " ")); cout << '\n'; } /* when called as: a.out bravo mike charlie zulu quebec generated output: a.out bravo charlie mike quebec zulu ====== zulu quebec mike charlie bravo a.out */ c++-annotations-10.6.0/yo/concrete/examples/a2x.h0000644000175000017500000000232713005340354020400 0ustar frankfrank#ifndef INCLUDED_A2X_H_ #define INCLUDED_A2X_H_ #include #include //CLASS class A2x: public std::istringstream { public: A2x() = default; A2x(char const *txt); A2x(std::string const &str); template operator Type(); template Type to(); A2x &operator=(char const *txt); A2x &operator=(std::string const &str); A2x &operator=(A2x const &other); }; //= //CONS inline A2x::A2x(char const *txt) // initialize from text : std::istringstream(txt) {} inline A2x::A2x(std::string const &str) : std::istringstream(str.c_str()) {} //= //TO template inline Type A2x::to() { Type t; return (*this >> t) ? t : Type(); } //= //TYPE template inline A2x::operator Type() { return to(); } //= inline A2x &A2x::operator=(std::string const &str) { return operator=(str.c_str()); } //OP= inline A2x &A2x::operator=(A2x const &other) { return operator=(other.str()); } //= #endif c++-annotations-10.6.0/yo/concrete/examples/rsh.cc0000644000175000017500000000300413005340355020632 0ustar frankfrank #include #include #include #include #include using namespace std; int main() { while (true) { string cmd; cout << "rsh: " << flush; cin >> cmd; if (cmd == "exit") { cout << "terminating the shell\n"; return 0; } if (cmd == "date" || cmd == "id") { pid_t pid = fork(); if (pid == 0) { execlp(cmd.c_str(), cmd.c_str(), 0); cerr << "Execution of " << cmd << " failed\n"; return 1; } if (pid < 0) { cerr << "Fork() failed\n"; return 1; } int status; wait(&status); if ((status = WEXITSTATUS(status))) cerr << cmd << " returned exit status " << status << '\n'; } else cout << "Command " << cmd << " disallowed\n"; } } /* Example of generated conversation: rsh: opa Command opa disallowed rsh: date Tue Jul 17 23:19:08 CEST 2001 rsh: id uid=405(frank) gid=100(users) groups=100(users),4(adm) rsh: quit Command quit disallowed rsh: exit terminating the shell */ c++-annotations-10.6.0/yo/concrete/examples/pipe.cc0000644000175000017500000000164513005340355021004 0ustar frankfrank #include "pipe.h" #include //CONS Pipe::Pipe() { if (pipe(d_fd)) throw "Pipe::Pipe(): pipe() failed"; } //= //REDIRECT void Pipe::redirect(int d_fd, int alternateFd) { if (dup2(d_fd, alternateFd) < 0) throw "Pipe: redirection failed"; } //= //READ int Pipe::readOnly() { close(d_fd[WRITE]); return d_fd[READ]; } void Pipe::readFrom(int fd) { readOnly(); redirect(d_fd[READ], fd); close(d_fd[READ]); } //= //WRITE int Pipe::writeOnly() { close(d_fd[READ]); return d_fd[WRITE]; } void Pipe::writtenBy(int fd) { writtenBy(&fd, 1); } void Pipe::writtenBy(int const *fd, size_t n) { writeOnly(); for (size_t idx = 0; idx < n; idx++) redirect(d_fd[WRITE], fd[idx]); close(d_fd[WRITE]); } //= c++-annotations-10.6.0/yo/concrete/examples/iterators/0000755000175000017500000000000013005340354021545 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/examples/iterators/output.cc0000644000175000017500000000022013005340355023407 0ustar frankfrank#include "input.h" #include "output.h" #include int main() { copy(InputIterator(0), InputIterator(100), OutputIterator(0)); } c++-annotations-10.6.0/yo/concrete/examples/iterators/random.h0000644000175000017500000000335713005340355023207 0ustar frankfrank #include class RandomIterator: public std::iterator { int d_value; public: RandomIterator(int init); // standard: bool operator==(RandomIterator const &other) const; bool operator!=(RandomIterator const &other) const; int &operator*(); RandomIterator &operator++(); // required: int operator-(RandomIterator const &rhs) const; RandomIterator operator+(int step) const; RandomIterator operator-(int step) const; bool operator<(RandomIterator const &other) const; // consider: int *operator->() const; RandomIterator &operator--(); RandomIterator operator--(int); RandomIterator operator++(int); RandomIterator &operator-=(int step); RandomIterator &operator+=(int step); }; RandomIterator::RandomIterator(int init) : d_value(init) {} bool RandomIterator::operator!=(RandomIterator const &other) const { return d_value != other.d_value; } bool RandomIterator::operator==(RandomIterator const &other) const { return d_value == other.d_value; } bool RandomIterator::operator<(RandomIterator const &other) const { return d_value < other.d_value; } int RandomIterator::operator-(RandomIterator const &rhs) const { return 0; } RandomIterator RandomIterator::operator+(int step) const { return *this; } RandomIterator RandomIterator::operator-(int step) const { return *this; } RandomIterator &RandomIterator::operator--() { return *this; } RandomIterator &RandomIterator::operator++() { return *this; } int &RandomIterator::operator*() { return d_value; } c++-annotations-10.6.0/yo/concrete/examples/iterators/forward.cc0000644000175000017500000000017013005340355023517 0ustar frankfrank#include "forward.h" #include int main() { adjacent_find(ForwardIterator(0), ForwardIterator(100)); } c++-annotations-10.6.0/yo/concrete/examples/iterators/iterator.h0000644000175000017500000000231213005340355023546 0ustar frankfrank #include class RandomIterator: public std::iterator { int d_value; public: RandomIterator(int init); bool operator==(RandomIterator const &other) const; int operator-(RandomIterator const &rhs) const; RandomIterator operator+(int step) const; RandomIterator &operator--() int &operator*(); int *operator->() const; bool operator<(RandomIterator const &other) const; RandomIterator operator--(int); RandomIterator &operator++(); RandomIterator operator++(int); RandomIterator operator-(int step) const; RandomIterator &operator-=(int step); RandomIterator &operator+=(int step); }; RandomIterator::RandomIterator(int init) : d_value(init) {} bool RandomIterator::operator!=(RandomIterator const &other) const { return d_value != other.d_value; } int RandomIterator::operator-(RandomIterator const &rhs) const { return 0; } RandomIterator &RandomIterator::operator--() { return *this; } int &RandomIterator::operator*() { return d_value; } c++-annotations-10.6.0/yo/concrete/examples/iterators/bidirectional.h0000644000175000017500000000214013005340355024524 0ustar frankfrank #include class BidirectionalIterator: public std::iterator { int d_value; public: BidirectionalIterator(int init); // standard: bool operator==(BidirectionalIterator const &other) const; bool operator!=(BidirectionalIterator const &other) const; int &operator*(); BidirectionalIterator &operator++(); // required: BidirectionalIterator &operator--(); // consider: int *operator->(); }; BidirectionalIterator::BidirectionalIterator(int init) : d_value(init) {} bool BidirectionalIterator::operator!=(BidirectionalIterator const &other) const { return d_value != other.d_value; } bool BidirectionalIterator::operator==(BidirectionalIterator const &other) const { return d_value == other.d_value; } BidirectionalIterator &BidirectionalIterator::operator++() { return *this; } BidirectionalIterator &BidirectionalIterator::operator--() { return *this; } int &BidirectionalIterator::operator*() { return d_value; } c++-annotations-10.6.0/yo/concrete/examples/iterators/bidirectional.cc0000644000175000017500000000041613005340355024666 0ustar frankfrank#include "bidirectional.h" #include int main() { inplace_merge(BidirectionalIterator(0), BidirectionalIterator(100), BidirectionalIterator(200)); next_permutation(BidirectionalIterator(0), BidirectionalIterator(100)); } c++-annotations-10.6.0/yo/concrete/examples/iterators/input.cc0000644000175000017500000000016213005340355023213 0ustar frankfrank#include "input.h" #include int main() { accumulate(InputIterator(0), InputIterator(100), 0); } c++-annotations-10.6.0/yo/concrete/examples/iterators/input.h0000644000175000017500000000157313005340355023064 0ustar frankfrank #include class InputIterator: public std::iterator { int d_value; public: InputIterator(int init); // standard: bool operator==(InputIterator const &other) const; bool operator!=(InputIterator const &other) const; int const &operator*() const; InputIterator &operator++(); // consider: int const *operator->() const; }; InputIterator::InputIterator(int init) : d_value(init) {} bool InputIterator::operator!=(InputIterator const &other) const { return d_value != other.d_value; } bool InputIterator::operator==(InputIterator const &other) const { return d_value == other.d_value; } InputIterator &InputIterator::operator++() { return *this; } int const &InputIterator::operator*() const { return d_value; } c++-annotations-10.6.0/yo/concrete/examples/iterators/output.h0000644000175000017500000000154613005340355023265 0ustar frankfrank #include class OutputIterator: public std::iterator { int d_value; public: OutputIterator(int init); // standard: bool operator==(OutputIterator const &other) const; bool operator!=(OutputIterator const &other) const; int &operator*(); OutputIterator &operator++(); // consider: int *operator->(); }; OutputIterator::OutputIterator(int init) : d_value(init) {} bool OutputIterator::operator!=(OutputIterator const &other) const { return d_value != other.d_value; } bool OutputIterator::operator==(OutputIterator const &other) const { return d_value == other.d_value; } OutputIterator &OutputIterator::operator++() { return *this; } int &OutputIterator::operator*() { return d_value; } c++-annotations-10.6.0/yo/concrete/examples/iterators/random.cc0000644000175000017500000000015413005340355023335 0ustar frankfrank#include "random.h" #include int main() { sort(RandomIterator(0), RandomIterator(100)); } c++-annotations-10.6.0/yo/concrete/examples/iterators/forward.h0000644000175000017500000000156513005340355023372 0ustar frankfrank #include class ForwardIterator: public std::iterator { int d_value; public: ForwardIterator(int init); // standard: bool operator==(ForwardIterator const &other) const; bool operator!=(ForwardIterator const &other) const; int &operator*(); ForwardIterator &operator++(); // consider: int *operator->(); }; ForwardIterator::ForwardIterator(int init) : d_value(init) {} bool ForwardIterator::operator!=(ForwardIterator const &other) const { return d_value != other.d_value; } bool ForwardIterator::operator==(ForwardIterator const &other) const { return d_value == other.d_value; } ForwardIterator &ForwardIterator::operator++() { return *this; } int &ForwardIterator::operator*() { return d_value; } c++-annotations-10.6.0/yo/concrete/examples/noredir.cc0000644000175000017500000000077113005340355021510 0ustar frankfrank #include #include #include using namespace std; int main() { ofstream of("outfile"); streambuf *buf = cout.rdbuf(of.rdbuf()); cout << "To the of stream\n"; system("echo hello world"); cout << "To the of stream\n"; cout.rdbuf(buf); } /* Generated output: on the file `outfile' To the of stream To the of stream On standard output: hello world */ c++-annotations-10.6.0/yo/concrete/examples/iterator.h0000644000175000017500000001154213005340354021536 0ustar frankfrank #ifndef INCLUDED_ITERATOR_H_ #define INCLUDED_ITERATOR_H_ //HEAD #include template class RandomPtrIterator: public std::iterator { friend RandomPtrIterator Class::begin(); friend RandomPtrIterator Class::end(); BaseIterator d_current; RandomPtrIterator(BaseIterator const ¤t); public: bool operator!=(RandomPtrIterator const &other) const; int operator-(RandomPtrIterator const &rhs) const; RandomPtrIterator operator+(int step) const; Type &operator*() const; bool operator<(RandomPtrIterator const &other) const; RandomPtrIterator &operator--(); RandomPtrIterator operator--(int); RandomPtrIterator &operator++(); RandomPtrIterator operator++(int); bool operator==(RandomPtrIterator const &other) const; RandomPtrIterator operator-(int step) const; RandomPtrIterator &operator-=(int step); RandomPtrIterator &operator+=(int step); Type *operator->() const; }; template RandomPtrIterator::RandomPtrIterator( BaseIterator const ¤t) : d_current(current) {} //= template bool RandomPtrIterator::operator!=( RandomPtrIterator const &other) const { return d_current != other.d_current; } template int RandomPtrIterator::operator-( RandomPtrIterator const &rhs) const { return d_current - rhs.d_current; } template RandomPtrIterator RandomPtrIterator::operator+(int step) const { return RandomPtrIterator(d_current + step); } //OP* template Type &RandomPtrIterator::operator*() const { return **d_current; } //= //CMP template bool RandomPtrIterator::operator<( RandomPtrIterator const &other) const { return **d_current < **other.d_current; } //= template RandomPtrIterator &RandomPtrIterator::operator--() { --d_current; return *this; } template RandomPtrIterator RandomPtrIterator::operator--(int) { return RandomPtrIterator(d_current--); } //INC template RandomPtrIterator &RandomPtrIterator::operator++() { ++d_current; return *this; } template RandomPtrIterator RandomPtrIterator::operator++(int) { return RandomPtrIterator(d_current++); } //= template bool RandomPtrIterator::operator==( RandomPtrIterator const &other) const { return d_current == other.d_current; } template RandomPtrIterator RandomPtrIterator::operator-(int step) const { return RandomPtrIterator(d_current - step); } template RandomPtrIterator &RandomPtrIterator::operator-=(int step) { d_current -= step; return *this; } template RandomPtrIterator &RandomPtrIterator::operator+=(int step) { d_current += step; return *this; } template Type *RandomPtrIterator::operator->() const { return *d_current; } #endif c++-annotations-10.6.0/yo/concrete/examples/foreachdemo.cc0000644000175000017500000000264613005340355022325 0ustar frankfrank#include #include #include #include "foreach.h" //VECTOR2 template class Vector2: public std::vector > { typedef typename Vector2::iterator iterator; template friend Class &ForEach(Iterator begin, Iterator end, Class &object, void (Class::*member)(Data &)); public: void process(); private: void rows(std::vector &row); void columns(Type &str); }; template void Vector2::process() { ForEach, std::vector > (this->begin(), this->end(), *this, &Vector2::rows); } template void Vector2::rows(std::vector &row) { ForEach(row.begin(), row.end(), *this, &Vector2::columns); std::cout << '\n'; } template void Vector2::columns(Type &str) { std::cout << str << " "; } using namespace std; int main() { Vector2 c; c.push_back(vector(3, "Hello")); c.push_back(vector(2, "World")); c.process(); } /* Generated output: Hello Hello Hello World World */ //= c++-annotations-10.6.0/yo/concrete/examples/binop.cc0000644000175000017500000000252113005340355021150 0ustar frankfrank#include using namespace std; template Class &&operator+(Class &&lhs, Class const &rhs) { cout << "operator+(Class &&lhs, Class const &rhs)\n"; return std::move(lhs += rhs); } template Class &&operator+(Class const &lhs, Class const &rhs) { cout << "operator+(Class const &, Class const &)\n"; Class tmp(lhs); return operator+(std::move(tmp), rhs); } template Class &&operator-(Class &&lhs, Class const &rhs) { return std::move(lhs -= rhs); } template Class &&operator-(Class const &lhs, Class const &rhs) { Class tmp(lhs); return operator-(std::move(tmp), rhs); } class Class { public: Class() = default; Class(Class const &other) = default; Class(int) {} Class(Class &&tmp) { cout << "Move constructor\n"; } Class &operator=(Class const &rhs) = default; Class &operator+=(Class const &rhs) { cout << "operator+=\n"; return *this; } }; Class factory() { return Class{}; } int main() { Class lhs; Class rhs; Class result; result = lhs + rhs; result = factory() + rhs; // result = lhs - rhs; // this won't compile as operator-= hasn't been // defined } c++-annotations-10.6.0/yo/concrete/examples/fistream/0000755000175000017500000000000013005340354021343 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/examples/fistream/fistream.ih0000644000175000017500000000020113005340354023470 0ustar frankfrank#include "fistream.h" // #include #include #include using namespace std; using namespace FBB; c++-annotations-10.6.0/yo/concrete/examples/fistream/fisin0000644000175000017500000000004512745054221022402 0ustar frankfrankba10 hello world My+name+is+%60Ed%27 c++-annotations-10.6.0/yo/concrete/examples/fistream/fistream.h0000644000175000017500000000337413005340355023336 0ustar frankfrank#ifndef INCLUDED_FISTREAM_H_ #define INCLUDED_FISTREAM_H_ #include #include #include #include #include /* fis >> field(3) >> x extracts x over max 3 positions. First, 3 chars are extracted from fis itself. They are put in a separate buffer which is then extracted. What if the extraction is not complete? Then a rest remains in the buffer, most likely resulting in a failing read, thereafter. Manipulators are provided to prevent this: field(0) returns to the non-fixed reading: the last field, even if not completely read, is then further ignored. field() reads the next field, same width as the previous field. If no field has been set before, field() has no effect. */ namespace FBB { class field; //INITIAL class Fistream: public std::istream { std::unique_ptr d_filebuf; std::streambuf *d_streambuf; std::istringstream d_iss; size_t d_width; //= public: //CONS Fistream(std::istream &stream); Fistream(char const *name, std::ios::openmode mode = std::ios::in); //= std::istream &setField(field const ¶ms); private: void setBuffer(); }; //FIELD class field { friend class Fistream; size_t d_width; bool d_newWidth; public: field(size_t width); field(); }; inline field::field(size_t width) : d_width(width), d_newWidth(true) {} inline field::field() : d_newWidth(false) {} //= } // FBB //OPEX namespace std { istream &operator>>(istream &str, FBB::field const ¶ms); } //= #endif c++-annotations-10.6.0/yo/concrete/examples/fistream/fistream.cc0000644000175000017500000000254113005340355023467 0ustar frankfrank#include "fistream.ih" //OPEX istream &std::operator>>(istream &str, field const ¶ms) { return static_cast(&str)->setField(params); } //= //CONS1 Fistream::Fistream(istream &stream) : istream(stream.rdbuf()), d_streambuf(rdbuf()), d_width(0) {} //= //CONS2 Fistream::Fistream(char const *name, ios::openmode mode) : istream(new filebuf()), d_filebuf(static_cast(rdbuf())), d_streambuf(d_filebuf.get()), d_width(0) { d_filebuf->open(name, mode); } //= //SETFIELD std::istream &Fistream::setField(field const ¶ms) { if (params.d_newWidth) // new field size requested d_width = params.d_width; // set new width if (!d_width) // no width? rdbuf(d_streambuf); // return to the old buffer else setBuffer(); // define the extraction buffer return *this; } //= //SETBUFFER void Fistream::setBuffer() { char *buffer = new char[d_width + 1]; rdbuf(d_streambuf); // use istream's buffer to buffer[read(buffer, d_width).gcount()] = 0; // read d_width chars, // terminated by a 0-byte d_iss.str(buffer); delete[] buffer; rdbuf(d_iss.rdbuf()); // switch buffers } //= c++-annotations-10.6.0/yo/concrete/examples/fistream/main.cc0000644000175000017500000000151513005340355022601 0ustar frankfrank#include #include "fistream.h" using namespace std; using namespace FBB; //MAIN int main() { Fistream fis(cin); fis >> hex; while (true) { size_t x; switch (x = fis.get()) { case '\n': cout << '\n'; break; case '+': cout << ' '; break; case '%': fis >> field(2) >> x >> field(0); // FALLING THROUGH default: cout << static_cast(x); break; case EOF: return 0; } } } /* Generated output after: echo My+name+is+%60Ed%27 | a.out My name is `Ed' */ //= c++-annotations-10.6.0/yo/concrete/examples/predicates.h0000644000175000017500000000570013005340355022030 0ustar frankfrank//UNARYPRED template class PredicateFunction1 { F_PTR d_fun; public: typedef Type argument_type; PredicateFunction1(F_PTR const &ptr) : d_fun(ptr) {} bool operator()(Type const &t) const { return d_fun(t); } }; //= //BINPRED template class PredicateFunction2 { F_PTR d_fun; public: typedef Type1 first_argument_type; typedef Type2 second_argument_type; typedef bool result_type; PredicateFunction2(F_PTR const &ptr) : d_fun(ptr) {} bool operator()(Type1 const &t1, Type2 const &t2) const { return d_fun(t1, t2); } }; //= //PREDOBJ1 template class PredicateObject1 { Class &d_cl; bool (Class::*d_member)(Type const &); public: typedef Type argument_type; PredicateObject1(Class &cl, bool (Class::*member)(Type const &) = &Class::operator()) : d_cl(cl), d_member(member) {} PredicateObject1(Class *cl, bool (Class::*member)(Type const &) = &Class::operator()) : d_cl(*cl), d_member(member) {} bool operator()(Type const &t) const { return (d_cl.*d_member)(t); } operator Class() const { return d_cl; } }; //= //PREDOBJ2 template class PredicateObject2 { Class &d_cl; bool (Class::*d_member)(Type1 const &, Type2 const &); public: typedef Type1 first_argument_type; typedef Type2 second_argument_type; typedef bool result_type; PredicateObject2(Class &cl, bool (Class::*member)(Type1 const &, Type2 const &) = &Class::operator()) : d_cl(cl), d_member(member) {} PredicateObject2(Class *cl, bool (Class::*member)(Type1 const &, Type2 const &) = &Class::operator()) : d_cl(*cl), d_member(member) {} bool operator()(Type1 const &t1, Type2 const &t2) const { return (d_cl.*d_member)(t1, t2); } operator Class() const { return d_cl; } }; //= c++-annotations-10.6.0/yo/concrete/examples/lines.cc0000644000175000017500000000101613005340355021151 0ustar frankfrank#include "lines.h" #include Lines::Lines(std::istream &in) { std::string str; while (getline(in, str)) d_line.push_back(str); } using namespace std; //MAIN int main() { ifstream in("lines.cc"); Lines lines(in); string s = lines[0]; // rvalue use lines[0] = s; // lvalue use cout << lines[0] << '\n'; // rvalue use lines[0] = "hello world"; // lvalue use cout << lines[0] << '\n'; // rvalue use } //= c++-annotations-10.6.0/yo/concrete/examples/parentslurp.cc0000644000175000017500000000117613005340355022425 0ustar frankfrank #include "parentslurp.h" #include #include //PARENT void ParentSlurp::parentProcess() { std::string line; size_t nr = 1; while (getline(std::cin, line)) std::cout << nr++ << ": " << line << '\n'; waitForChild(); } //= //MAIN int main() { ParentSlurp().fork(); } /* Generated Output (example only, actually obtained output may differ): 1: a.out 2: bitand.h 3: bitfunctional 4: bitnot.h 5: daemon.cc 6: fdinseek.cc 7: fdinseek.h ... */ //= c++-annotations-10.6.0/yo/concrete/examples/daemon.cc0000644000175000017500000000130513005340355021303 0ustar frankfrank #include #include #include "fork.h" class Daemon: public Fork { virtual void parentProcess() // the parent does nothing. {} virtual void childProcess() // actions by the child { sleep(3); // just a message... std::cout << "Hello from the child process\n"; throw 0; // The child process ends } }; int main() try { Daemon().fork(); } catch(...) {} /* Generated output: The next command prompt, then after 3 seconds: Hello from the child process */ c++-annotations-10.6.0/yo/concrete/examples/monitor/0000755000175000017500000000000013005340354021220 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/examples/monitor/monitor.h0000644000175000017500000000335513005340355023067 0ustar frankfrank #include #include #include #include "../selector.h" #include "child.h" //CLASS class Monitor { enum Commands { UNKNOWN, START, EXIT, STOP, TEXT, sizeofCommands }; typedef std::map> MapIntChild; friend class Find; class Find { int d_nr; public: Find(int nr); bool operator()(MapIntChild::value_type &vt) const; }; Selector d_selector; int d_nr; MapIntChild d_child; static void (Monitor::*s_handler[])(int, std::string const &); static int s_initialize; public: enum Done {}; Monitor(); void run(); private: static void killChild(MapIntChild::value_type it); static int initialize(); Commands next(int *value, std::string *line); void processInput(); void processChild(int fd); void createNewChild(int, std::string const &); void exiting(int = 0, std::string const &msg = std::string()); void sendChild(int value, std::string const &line); void stopChild(int value, std::string const &); void unknown(int, std::string const &); }; //= //CONS inline Monitor::Monitor() : d_nr(0) {} //= //FINDIMP inline Monitor::Find::Find(int nr) : d_nr(nr) {} inline bool Monitor::Find::operator()(MapIntChild::value_type &vt) const { return d_nr == vt.second->nr(); } //= c++-annotations-10.6.0/yo/concrete/examples/monitor/build0000755000175000017500000000017212745054221022252 0ustar frankfrank#!/bin/sh g++ --std=c++11 *.cc ../selector.cc ../fork.cc ../forkvirtual.cc \ ../pipe.cc -lbobcat -s c++-annotations-10.6.0/yo/concrete/examples/monitor/data.compiletime0000644000175000017500000000051012745054221024363 0ustar frankfrank #include "monitor.ih" //HANDLER void (Monitor::*Monitor::s_handler[])(int, string const &) = { &Monitor::unknown, // order follows enum Command's &Monitor::createNewChild, // elements &Monitor::exiting, &Monitor::stopChild, &Monitor::sendChild, }; //= c++-annotations-10.6.0/yo/concrete/examples/monitor/run.cc0000644000175000017500000000132313005340355022333 0ustar frankfrank #include "monitor.ih" int Monitor::s_initialize = Monitor::initialize(); void Monitor::run() { d_selector.addReadFd(STDIN_FILENO); while (true) { cout << "? " << flush; try { d_selector.wait(); int fd; while ((fd = d_selector.readFd()) != -1) { if (fd == STDIN_FILENO) processInput(); else processChild(fd); } cout << "NEXT ...\n"; } catch (char const *msg) { exiting(1, msg); } } } c++-annotations-10.6.0/yo/concrete/examples/monitor/child.h0000644000175000017500000000234213005340355022456 0ustar frankfrank #include "../pipe.h" #include "../fork.h" #include "../selector.h" #include #include #include #include //CLASS class Child: public Fork { Pipe d_in; Pipe d_out; int d_parentReadFd; int d_parentWriteFd; int d_nr; public: Child(int nr); virtual ~Child(); int readFd() const; int writeFd() const; int pid() const; int nr() const; private: virtual void childRedirections(); virtual void parentRedirections(); virtual void childProcess(); virtual void parentProcess(); }; //= //CONS inline Child::Child(int nr) : d_nr(nr) {} //= //PIPES inline int Child::readFd() const { return d_parentReadFd; } inline int Child::writeFd() const { return d_parentWriteFd; } //= //PIDNR inline int Child::pid() const { return Fork::pid(); } inline int Child::nr() const { return d_nr; } //= inline void Child::parentProcess() {} c++-annotations-10.6.0/yo/concrete/examples/monitor/monitor.cc0000644000175000017500000000175413005340355023226 0ustar frankfrank #include "monitor.ih" //KILL void Monitor::killChild(MapIntChild::value_type it) { if (kill(it.second->pid(), SIGTERM)) cerr << "Couldn't kill process " << it.second->pid() << '\n'; // reap defunct child process int status = 0; while( waitpid( it.second->pid(), &status, WNOHANG) > -1) ; } //= //EXIT void Monitor::exiting(int value, string const &msg) { for_each(d_child.begin(), d_child.end(), killChild); if (msg.length()) cerr << msg << '\n'; throw value; } //= //INIT void (Monitor::*Monitor::s_handler[sizeofCommands])(int, string const &); int Monitor::initialize() { s_handler[UNKNOWN] = &Monitor::unknown; s_handler[START] = &Monitor::createNewChild; s_handler[EXIT] = &Monitor::exiting; s_handler[STOP] = &Monitor::stopChild; s_handler[TEXT] = &Monitor::sendChild; return 0; } //= c++-annotations-10.6.0/yo/concrete/examples/monitor/processchild.cc0000644000175000017500000000041013005340355024205 0ustar frankfrank #include "monitor.ih" //CHILD void Monitor::processChild(int fd) { IFdStreambuf ifdbuf(fd); istream istr(&ifdbuf); string line; getline(istr, line); cout << d_child[fd]->pid() << ": " << line << '\n'; } //= c++-annotations-10.6.0/yo/concrete/examples/monitor/monitor.ih0000644000175000017500000000037713005340354023240 0ustar frankfrank #include "monitor.h" #include #include #include #include #include #include #include "../ifdbuf.h" #include "../fdout.h" using namespace std; c++-annotations-10.6.0/yo/concrete/examples/monitor/processinput.cc0000644000175000017500000000165613005340355024276 0ustar frankfrank #include "monitor.ih" //INPUT void Monitor::processInput() { string line; int value; Commands cmd = next(&value, &line); (this->*s_handler[cmd])(value, line); } //= //NEXT Monitor::Commands Monitor::next(int *value, string *line) { if (!getline(cin, *line)) exiting(1, "Monitor::next(): reading cin failed"); if (*line == "start") return START; if (*line == "exit" || *line == "quit") { *value = 0; return EXIT; } if (line->find("stop") == 0) { istringstream istr(line->substr(4)); istr >> *value; return !istr ? UNKNOWN : STOP; } istringstream istr(line->c_str()); istr >> *value; if (istr) { getline(istr, *line); return TEXT; } return UNKNOWN; } //= c++-annotations-10.6.0/yo/concrete/examples/monitor/sendchild.cc0000644000175000017500000000064013005340355023465 0ustar frankfrank #include "monitor.ih" //SEND void Monitor::sendChild(int nr, string const &line) { auto it = find_if(d_child.begin(), d_child.end(), Find(nr)); if (it == d_child.end()) cerr << "No child number " << nr << '\n'; else { OFdnStreambuf ofdn(it->second->writeFd()); ostream out(&ofdn); out << line << '\n'; } } //= c++-annotations-10.6.0/yo/concrete/examples/monitor/main.cc0000644000175000017500000000144413005340355022457 0ustar frankfrank #include "monitor.h" //MAIN int main() try { Monitor().run(); } catch (int exitValue) { return exitValue; } //= /* Example of a session: # a.out ? start Child 1 started ? 1 hello world ? 3394: Child 1:1: hello world ? 1 hi there! ? 3394: Child 1:2: hi there! ? start Child 2 started ? 3394: Child 1: standing by ? 3395: Child 2: standing by ? 3394: Child 1: standing by ? 3395: Child 2: standing by ? stop 1 ? 3395: Child 2: standing by ? 2 hello world ? 3395: Child 2:1: hello world ? 1 hello world No child number 1 ? exit3395: Child 2: standing by ? # */ c++-annotations-10.6.0/yo/concrete/examples/monitor/unknown.cc0000644000175000017500000000020713005340355023226 0ustar frankfrank #include "monitor.ih" void Monitor::unknown(int, string const &line) { cout << "unknown: " << line << "\n"; } c++-annotations-10.6.0/yo/concrete/examples/monitor/stopchild.cc0000644000175000017500000000057213005340355023525 0ustar frankfrank #include "monitor.ih" //STOP void Monitor::stopChild(int nr, string const &) { auto it = find_if(d_child.begin(), d_child.end(), Find(nr)); if (it == d_child.end()) cerr << "No child number " << nr << '\n'; else { d_selector.rmReadFd(it->second->readFd()); d_child.erase(it); } } //= c++-annotations-10.6.0/yo/concrete/examples/monitor/child.cc0000644000175000017500000000275213005340355022621 0ustar frankfrank #include "child.h" #include #include #include using namespace std; //CHILD void Child::childRedirections() { d_in.readFrom(STDIN_FILENO); d_out.writtenBy(STDOUT_FILENO); } //= //PARENT void Child::parentRedirections() { d_parentReadFd = d_out.readOnly(); d_parentWriteFd = d_in.writeOnly(); } //= //PROCESS void Child::childProcess() { Selector selector; size_t message = 0; selector.addReadFd(STDIN_FILENO); selector.setAlarm(5); while (true) { try { if (!selector.wait()) // timeout cout << "Child " << d_nr << ": standing by\n"; else { string line; getline(cin, line); cout << "Child " << d_nr << ":" << ++message << ": " << line << '\n'; } } catch (...) { cout << "Child " << d_nr << ":" << ++message << ": " << "select() failed" << '\n'; } } exit(0); } //= //CHILDDES Child::~Child() { if (pid()) { cout << "Killing process " << pid() << "\n"; kill(pid(), SIGTERM); int status; wait(&status); } } //= c++-annotations-10.6.0/yo/concrete/examples/monitor/createnewchild.cc0000644000175000017500000000047213005340355024514 0ustar frankfrank #include "monitor.ih" //CHILD void Monitor::createNewChild(int, string const &) { Child *cp = new Child(++d_nr); cp->fork(); int fd = cp->readFd(); d_selector.addReadFd(fd); d_child[fd].reset(cp); cerr << "Child " << d_nr << " started\n"; } //= c++-annotations-10.6.0/yo/concrete/examples/parentslurp.h0000644000175000017500000000133713005340355022266 0ustar frankfrank // compile with 'g++ parentslurp.cc fork.cc waitforchild.cc pipe.cc' #include "fork.h" #include "pipe.h" #include //CLASS class ParentSlurp: public Fork { Pipe d_pipe; virtual void childRedirections(); virtual void parentRedirections(); virtual void childProcess(); virtual void parentProcess(); }; //= //CHILDREDIR inline void ParentSlurp::childRedirections() { d_pipe.writtenBy(STDOUT_FILENO); } //= //PARENTREDIR inline void ParentSlurp::parentRedirections() { d_pipe.readFrom(STDIN_FILENO); } //= //CHILDPROC inline void ParentSlurp::childProcess() { execl("/bin/ls", "/bin/ls", 0); } //= c++-annotations-10.6.0/yo/concrete/examples/selector.h0000644000175000017500000000453613005340355021533 0ustar frankfrank #ifndef INCLUDED_SELECTOR_H_ #define INCLUDED_SELECTOR_H_ //HEADERS #include #include #include #include //= //CLASS class Selector { fd_set d_read; fd_set d_write; fd_set d_except; fd_set d_ret_read; fd_set d_ret_write; fd_set d_ret_except; timeval d_alarm; int d_max; int d_ret; int d_readidx; int d_writeidx; int d_exceptidx; public: Selector(); int exceptFd(); int nReady(); int readFd(); int wait(); int writeFd(); void addExceptFd(int fd); void addReadFd(int fd); void addWriteFd(int fd); void noAlarm(); void rmExceptFd(int fd); void rmReadFd(int fd); void rmWriteFd(int fd); void setAlarm(int sec, int usec = 0); private: int checkSet(int *index, fd_set &set); void addFd(fd_set *set, int fd); }; //= //NREADY inline int Selector::nReady() { return d_ret; } //= //READFD inline int Selector::readFd() { return checkSet(&d_readidx, d_ret_read); } //= inline int Selector::writeFd() { return checkSet(&d_writeidx, d_ret_write); } inline int Selector::exceptFd() { return checkSet(&d_exceptidx, d_ret_except); } //SETALARM inline void Selector::setAlarm(int sec, int usec) { d_alarm.tv_sec = sec; d_alarm.tv_usec = usec; } //= //NOALARM inline void Selector::noAlarm() { setAlarm(-1, -1); } //= //ADDREAD inline void Selector::addReadFd(int fd) { addFd(&d_read, fd); } //= inline void Selector::addWriteFd(int fd) { addFd(&d_write, fd); } inline void Selector::addExceptFd(int fd) { addFd(&d_except, fd); } //RMREAD inline void Selector::rmReadFd(int fd) { FD_CLR(fd, &d_read); } //= inline void Selector::rmWriteFd(int fd) { FD_CLR(fd, &d_write); } inline void Selector::rmExceptFd(int fd) { FD_CLR(fd, &d_except); } #endif c++-annotations-10.6.0/yo/concrete/examples/ifdbuf.h0000644000175000017500000000120213005340354021134 0ustar frankfrank #include #include //CLASS class IFdStreambuf: public std::streambuf { protected: int d_fd; char d_buffer[1]; public: IFdStreambuf(int fd); private: int underflow(); }; //= //CONS inline IFdStreambuf::IFdStreambuf(int fd) : d_fd(fd) { setg(d_buffer, d_buffer + 1, d_buffer + 1); } //= //UFLOW inline int IFdStreambuf::underflow() { if (read(d_fd, d_buffer, 1) <= 0) return EOF; setg(d_buffer, d_buffer, d_buffer + 1); return *gptr(); } //= c++-annotations-10.6.0/yo/concrete/examples/a2x.cc0000644000175000017500000000171713005340355020541 0ustar frankfrank#include #include "a2x.h" using namespace std; // compile with a2xis.cc int main() { //MAIN int x = A2x("12"); // initialize int x from a string "12" A2x a2x("12.50"); // explicitly create an A2x object double d; d = a2x; // assign a variable using an A2x object cout << d << '\n'; a2x = "err"; d = a2x; // d is 0: the conversion failed, cout << d << '\n'; // and a2x.good() == false a2x = " a"; // reassign a2x to new text char c = a2x; // c now 'a': internally operator>>() is used cout << c << '\n'; // so initial blanks are skipped. int expectsInt(int x); // initialize a parameter using an expectsInt(A2x("1200")); // anonymous A2x object d = A2x("12.45").to(); // d is 12, not 12.45 cout << d << '\n'; //= } int expectsInt(int x) { cout << x << '\n'; return x; } c++-annotations-10.6.0/yo/concrete/examples/waitforchild.cc0000644000175000017500000000023713005340355022522 0ustar frankfrank #include "fork.ih" int Fork::waitForChild() { int status; waitpid(d_pid, &status, 0); return WEXITSTATUS(status); } c++-annotations-10.6.0/yo/concrete/examples/ifdbuf.cc0000644000175000017500000000035313005340355021301 0ustar frankfrank #include #include #include "ifdbuf.h" using namespace std; //MAIN int main() { IFdStreambuf fds(STDIN_FILENO); istream is(&fds); cout << is.rdbuf(); } //= c++-annotations-10.6.0/yo/concrete/examples/oformstream.h0000644000175000017500000000046713005340354022247 0ustar frankfrank #include class oformstream: public std::ostream // 1 { public: oformstream(std::ostream &ostr) // 2 : std::ostream(ostr.rdbuf()) {} std::ostream &form(char const *fmt, ...); // 3 }; c++-annotations-10.6.0/yo/concrete/examples/ifdnbuf.cc0000644000175000017500000000102613005340355021455 0ustar frankfrank #include #include #include #include "ifdnbuf.h" using namespace std; int main() { // internally: 30 char buffer IFdNStreambuf fds(STDIN_FILENO, 30); char buf[80]; // main() reads blocks of 80 // chars while (true) { size_t n = fds.sgetn(buf, 80); if (n == 0) break; cout.write(buf, n); } } c++-annotations-10.6.0/yo/concrete/examples/fdunget.h0000644000175000017500000000257213005340354021344 0ustar frankfrank #include #include #include #include #include //CLASS class FdUnget: public std::streambuf { int d_fd; size_t d_bufsize; size_t d_reserved; char *d_buffer; char *d_base; public: FdUnget(int fd, size_t bufsz, size_t unget); virtual ~FdUnget(); private: int underflow(); }; //= //CONS FdUnget::FdUnget(int fd, size_t bufsz, size_t unget) : d_fd(fd), d_reserved(unget) { size_t allocate = bufsz > d_reserved ? bufsz : d_reserved + 1; d_buffer = new char[allocate]; d_base = d_buffer + d_reserved; setg(d_base, d_base, d_base); d_bufsize = allocate - d_reserved; } //= //DESTR inline FdUnget::~FdUnget() { delete[] d_buffer; } //= //UNDERFLOW int FdUnget::underflow() { size_t ungetsize = gptr() - eback(); size_t move = std::min(ungetsize, d_reserved); memcpy(d_base - move, egptr() - move, move); int nread = read(d_fd, d_base, d_bufsize); if (nread <= 0) // none read -> return EOF return EOF; setg(d_base - move, d_base, d_base + nread); return *gptr(); } //= c++-annotations-10.6.0/yo/concrete/examples/for3.cc0000644000175000017500000000127613005340355020720 0ustar frankfrank #include #include #include #include "foreach.h" using namespace std; class StringVector: public vector { public: StringVector(char **begin, char **end) : vector(begin, end) {} void operator()(string const &str) { cout << str << " "; } }; int main(int argc, char **argv) { StringVector vs(argv, argv + argc); ForEach(vs.begin(), vs.end(), vs); cout << '\n'; } /* Output generated when running a.out alpha bravo charley a.out alpha bravo charley */ c++-annotations-10.6.0/yo/concrete/examples/ipipe.h0000644000175000017500000000072413005340354021013 0ustar frankfrank#ifndef INCLUDED_IPIPE_H_ #define INCLUDED_IPIPE_H_ #ifndef INCLUDED_PIPE_H_ #include "../pipe/pipe.h" #endif #ifndef INCLUDED_IFDSTREAMBUF_H_ #include "../ifdstreambuf/ifdstreambuf.h" #endif #ifndef SYSINC_ISTREAM_ #include #define SYSINC_ISTREAM_ #endif namespace FBB { class IPipe: public Pipe, private IFdStreambuf, public std::istream { public: IPipe(size_t size = 500); void closeWriteFd(); }; } #endif c++-annotations-10.6.0/yo/concrete/examples/bitfunctional0000644000175000017500000000327512745054221022331 0ustar frankfrank#ifndef BITFUNCTIONAL__ #define BITFUNCTIONAL__ #include /* Frank B. Brokken, july 19, 2001. f.b.brokken@rug.nl This file predefines function-objects that are non-standard. The following function objects are defined: name operator ---------------------------- shift_left << shift_right >> bit_not ~ bit_and & bit_or | bit_xor ^ ---------------------------- In order to make these objects available, install this file in a directory where your compiler finds it, and let sources do: #include This include directive implies #include */ template struct shift_left : public binary_function<_Tp,_Tp,_Tp> { _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x << __y; } }; template struct shift_right : public binary_function<_Tp,_Tp,_Tp> { _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x >> __y; } }; template struct bit_not : public unary_function<_Tp,_Tp> { _Tp operator()(const _Tp& __x) const { return ~__x; } }; template struct bit_and : public binary_function<_Tp,_Tp,_Tp> { _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x & __y; } }; template struct bit_or : public binary_function<_Tp,_Tp,_Tp> { _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x | __y; } }; template struct bit_xor : public binary_function<_Tp,_Tp,_Tp> { _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x ^ __y; } }; #endif c++-annotations-10.6.0/yo/concrete/examples/forkvirtual.cc0000644000175000017500000000022613005340355022411 0ustar frankfrank #include "fork.ih" //REDIRECT void Fork::childRedirections() {} void Fork::parentRedirections() {} //= Fork::~Fork() {} c++-annotations-10.6.0/yo/concrete/examples/oformstream.cc0000644000175000017500000000144513005340355022403 0ustar frankfrank #include "oformstream.h" #include #include std::ostream &oformstream::form(char const *fmt, ...) // 1 { va_list list; va_start(list, fmt); size_t n = vsnprintf(0, 0, fmt, list); // 2 std::auto_ptr buf(new char[n + 1]); // 3 vsprintf(buf.get(), fmt, list); // 4 return *this << buf.get(); // 5 } using namespace std; int main() { oformstream of(cout); of << "Hello world\n"; cout << "Ok, "; of << "That's all, folks\n"; of.form("%s\n", "Hello world of C++") << '\n'; }; /* Generated output: Hello world Ok, That's all, folks Hello world of C++ */ c++-annotations-10.6.0/yo/concrete/examples/a2xis.cc0000644000175000017500000000035513005340355021072 0ustar frankfrank#include "a2x.h" A2x &A2x::operator=(char const *txt) { clear(); // very important!!! If a conversion failed, the object // remains useless until executing this statement str(txt); return *this; } c++-annotations-10.6.0/yo/concrete/examples/fork.cc0000644000175000017500000000072513005340355021006 0ustar frankfrank #include "fork.ih" void Fork::fork() { if ((d_pid = ::fork()) < 0) throw "Fork::fork() failed"; if (d_pid == 0) // childprocess has pid == 0 { childRedirections(); childProcess(); exit(1); // we shouldn't come here: } // childProcess() should exit parentRedirections(); parentProcess(); } c++-annotations-10.6.0/yo/concrete/examples/for1.OBS0000644000175000017500000000074112745054221020754 0ustar frankfrank #include #include #include #include "foreach.h" using namespace std; int main() { vector vs; ForEach(istream_iterator(cin), istream_iterator(), vs, &vector::push_back); cout << "The vector contains " << vs.size() << " strings\n"; } /* Output generated when the program reads this source: The vector contains 47 strings */ c++-annotations-10.6.0/yo/concrete/examples/predobj.cc0000644000175000017500000000361613005340355021474 0ustar frankfrank #include #include #include #include #include #include "predicates.h" using namespace std; //CONTAINS class Contains { string d_target; size_t d_count; public: Contains(char const *target) : d_target(target), d_count(0) {} bool operator()(string const &str) { d_count++; return str.find_first_of(d_target) != string::npos; } bool operator()(string const &s1, string const &s2) { d_count++; return s1.find_first_of(s2) != string::npos; } size_t count() const { return d_count; } }; //= //MAIN int main(int argc, char **argv) { Contains contains("aeiou"); if (argc == 1) cout << "Counted " << count_if(istream_iterator(cin), istream_iterator(), PredicateObject1(contains) ) << " words containing vowels "; else cout << "Counted " << count_if(istream_iterator(cin), istream_iterator(), bind2nd ( PredicateObject2(contains), "aeiou" ) ) << " words containing vowels "; cout << "(read " << contains.count() << " strings)\n"; } /* Generated output after executing (predobj.cc being this soure file) a.out < predobj.cc or a.out 2 < predobj.cc Counted 97 words containing vowels (read 149 strings) */ //= c++-annotations-10.6.0/yo/concrete/examples/for2.cc0000644000175000017500000000133113005340355020707 0ustar frankfrank #include #include #include #include "foreach.h" using namespace std; class StringVector: public vector { public: StringVector(char **begin, char **end) : vector(begin, end) {} void display(string const &str) const { cout << str << " "; } }; int main(int argc, char **argv) { StringVector vs(argv, argv + argc); ForEach(vs.begin(), vs.end(), vs, &StringVector::display); cout << '\n'; } /* Output generated when running a.out alpha bravo charley a.out alpha bravo charley */ c++-annotations-10.6.0/yo/concrete/examples/fdinseek.cc0000644000175000017500000000132413005340355021631 0ustar frankfrank #include "fdinseek.h" #include #include #include #include using namespace std; int main() { IFdSeek fds(0); istream is(&fds); string s; while (true) { if (!getline(is, s)) break; streampos pos = is.tellg(); cout << setw(5) << pos << ": `" << s << "'\n"; if (!getline(is, s)) break; streampos pos2 = is.tellg(); cout << setw(5) << pos2 << ": `" << s << "'\n"; if (!is.seekg(pos)) { cout << "Seek failed\n"; break; } } } c++-annotations-10.6.0/yo/concrete/examples/selector.cc0000644000175000017500000000203513005340355021661 0ustar frankfrank #include "selector.h" //SELECTOR Selector::Selector() { FD_ZERO(&d_read); FD_ZERO(&d_write); FD_ZERO(&d_except); noAlarm(); d_max = 0; } //= //WAIT int Selector::wait() { timeval t = d_alarm; d_ret_read = d_read; d_ret_write = d_write; d_ret_except = d_except; d_readidx = 0; d_writeidx = 0; d_exceptidx = 0; d_ret = select(d_max, &d_ret_read, &d_ret_write, &d_ret_except, t.tv_sec == -1 && t.tv_usec == -1 ? 0 : &t); if (d_ret < 0) throw "Selector::wait()/select() failed"; return d_ret; } //= //ADDFD void Selector::addFd(fd_set *set, int fd) { FD_SET(fd, set); if (fd >= d_max) d_max = fd + 1; } //= //CHECKSET int Selector::checkSet(int *index, fd_set &set) { int &idx = *index; while (idx < d_max && !FD_ISSET(idx, &set)) ++idx; return idx == d_max ? -1 : idx++; } //= c++-annotations-10.6.0/yo/concrete/examples/fdinseek.h0000644000175000017500000000236413005340354021477 0ustar frankfrank #include "ifdbuf.h" #include #include //CLASS class IFdSeek: public IFdStreambuf { typedef std::streambuf::pos_type pos_type; typedef std::streambuf::off_type off_type; typedef std::ios::seekdir seekdir; typedef std::ios::openmode openmode; public: IFdSeek(int fd); private: pos_type seekoff(off_type offset, seekdir dir, openmode); pos_type seekpos(pos_type offset, openmode mode); }; //= //CONS inline IFdSeek::IFdSeek(int fd) : IFdStreambuf(fd) {} //= //SEEKOFF IFdSeek::pos_type IFdSeek::seekoff(off_type off, seekdir dir, openmode) { pos_type pos = lseek ( d_fd, off, (dir == std::ios::beg) ? SEEK_SET : (dir == std::ios::cur) ? SEEK_CUR : SEEK_END ); if (pos < 0) return -1; setg(d_buffer, d_buffer + 1, d_buffer + 1); return pos; } //= //SEEKPOS inline IFdSeek::pos_type IFdSeek::seekpos(pos_type off, openmode mode) { return seekoff(off, std::ios::beg, mode); } //= c++-annotations-10.6.0/yo/concrete/examples/pipe.h0000644000175000017500000000070113005340355020636 0ustar frankfrank#include //HEAD class Pipe { enum RW { READ, WRITE }; int d_fd[2]; //= public: Pipe(); int readOnly(); void readFrom(int fileDescriptor); int writeOnly(); void writtenBy(int fileDescriptor); void writtenBy(int const *fileDescriptors, size_t n = 2); private: void redirect(int d_fd, int alternateFd); }; c++-annotations-10.6.0/yo/concrete/bitwise.yo0000644000175000017500000000415412745054221017743 0ustar frankfrank In section ref(PREDEFINED) several i(predefined function object)s were introduced. Predefined function objects performing i(arithmetic operations), i(relational operations), and i(logical operations) exist, corresponding to a multitude of hi(binary operator) binary- and hi(unary operator) unary operators. Some operators appear to be missing: there appear to be no predefined function objects corresponding to i(bitwise operations). However, their construction is, given the available predefined function objects, not difficult. The following examples show a i(class template) implementing a function object calling the i(bitwise and) (ti(operator&)), and a template class implementing a function object calling the i(unary not) (ti(operator~)). It is left to the reader to construct similar function objects for other operators. Here is the implementation of a function object calling the i(bitwise) tt(operator&): verbinclude(-a examples/bitand.h) Here is the implementation of a function object calling tt(operator~()): verbinclude(-a examples/bitnot.h) These and other missing predefined function objects are also implemented in the file ti(bitfunctional), which is found in the tt(cplusplus.yo.zip) archive. These classes are derived from existing class templates (e.g., hi(binary_function)tt(std::binary_function) and hi(unary_function)tt(std::unary_function)). These base classes hi(types: required by STL)hi(STL: required types) define several types which are expected (used) by various generic algorithms as defined in the STL (cf. chapter ref(GENERIC)), thus following the advice offered in, e.g., the bf(C++) header file ti(bits/stl_function.h): verb( * The standard functors are derived from structs named unary_function * and binary_function. These two classes contain nothing but typedefs, * to aid in generic (template) programming. If you write your own * functors, you might consider doing the same. ) Here is an example using tt(bit_and), removing all odd numbers from a vector of tt(int) values: verbinclude(-a examples/removeodd.cc) c++-annotations-10.6.0/yo/concrete/a2x.yo0000644000175000017500000000677612745054221017003 0ustar frankfrank The standard bf(C) library offers conversion functions like ti(atoi), ti(atol), and other functions that can be used to convert NTB strings to numeric values. In bf(C++), these functions are still available, but a more em(type safe) way to convert text to other types uses objects of the class hi(istringstream)tt(std::istringsteam). Using the class tt(istringstream) instead of the bf(C) standard conversion functions may have the advantage of type-safety, but it also appears to be a rather cumbersome alternative. After all, we first have to construct and initialize a tt(std::istringstream) object before we're able to extract a value of some type from it. This requires us to use a variable. Then, in cases where the extracted value is only needed to initialize some function-parameter, one might wonder whether the added variable and the tt(istringstream) construction can somehow be avoided. In this section we'll develop a class hi(A2x)(tt(A2x)) preventing all the disadvantages of the standard bf(C) library functions, without requiring the cumbersome definitions of tt(istringstream) objects over and over again. The class is called tt(A2x), meaning hi(ascii to anything) `i(ascii to anything)'. tt(A2x) objects can be used to extract values of any type extractable from tt(std::istream) objects. Since tt(A2x) represents the object-variant of the bf(C) functions, it is not only type-safe but em(also) extensible. So its use is greatly preferred over using the standard bf(C) functions. Here are its characteristics: itemization( it() tt(A2x) is derived from tt(std::istringstream), and so all members of the class tt(istringstream) are available for tt(A2x) objects. Extractions of values of variables can always effortlessly be performed. Here's the class's interface: verbinclude(//CLASS examples/a2x.h) it() tt(A2x) has a default constructor and a constructor expecting a tt(std::string) argument. The latter constructor may be used to initialize tt(A2x) objects with text to be converted (e.g., a line of text obtained from reading a configuration file): verbinclude(//CONS examples/a2x.h) it() tt(A2x)'s real strength comes from its tt(operator Type()) conversion member template. As it is a member template, it automatically adapts itself to the type of the variable that should be given a value, obtained by converting the text stored inside the tt(A2x) object to the variable's type. When the extraction fails, tt(A2x)'s inherited tt(good) member returns tt(false). it() Occasionally the compiler may not be able to determine which type to convert to. In that case, an em(explicit template type) could be used: verb( A2x.operator int(); // or just: A2x.operator int(); ) As neither syntax looks attractive, the member template tt(to) is provided too, allowing constructions like: verb( A2x.to(); ) Here is its implementation: verbinclude(//TO examples/a2x.h) it() The tt(to) member makes it easy to implement tt(operator Type()): verbinclude(//TYPE examples/a2x.h) it() Once an tt(A2x) object is available, it may be reinitialized using tt(operator=): verbinclude(-a examples/a2xis.cc) ) Here are some examples showing tt(A2x) being used: verbinclude(//MAIN examples/a2x.cc) A complementary class hi(X2a) (tt(X2a)), converting values to text, can be constructed as well. Its construction is left as an exercise to the reader. c++-annotations-10.6.0/yo/concrete/fdinput.yo0000644000175000017500000000120712745054221017742 0ustar frankfrank When classes for input operation are derived from ti(std::streambuf), they should be provided with an input buffer of at least one character. The one-character input buffer allows for the use of the member functions tt(istream::putback) or tt(istream::ungetc). Strictly speaking it is not necessary to implement a buffer in classes derived from tt(streambuf). But using buffers in these classes is strongly advised. Their implementation is very simple and straightforward and the applicability of such classes is greatly improved. Therefore, all our classes derived from the class tt(streambuf) define a buffer of em(at least) one character. c++-annotations-10.6.0/yo/concrete/foreach.OBS0000644000175000017500000001030012745054221017666 0ustar frankfrank The tt(for_each()) (ref(FOREACH)) generic algorithm implements a very useful algorithm: each of its visited elements may be modified by either a function or a function object. However, in practice it is often somewhat complex to use this algorithm. Functions passed to the algorithm cannot maintain state, and so special classes for function objects passed to the algorithm often have to be constructed. In many cases the functionality performed by the function object passed to the tt(for_each()) generic algorithm is actually already available in the class whose members use tt(for_each()). However, when tt(*this) is passed as tt(for_each())'s function object, then the object used by tt(for_each()) is actually a copy of the object tt(this) points to, which is usually also undesirable. The following function template ti(ForEach()) was designed to remedy these drawbacks. The tt(ForEach()) function template has three template parameters: tt(Iterator) represents the iterator type used to iterate over a series of elements; tt(Class) represents a class type; tt(Data) represents the data type to which tt(Iterators) refer. The actual types of these parameters are deduced by the compiler when tt(ForEach()) is called. This function template itself defines four parameters: itemization( itt(Iterator begin): the begin point of an iterator range rangett(begin, end); itt(Iterator end): the endpoint of the iterator range rangett(begin, end); itt(Class &object): a reference to an object of class type tt(Class); itt(void (Class::*member)(Data &)): a pointer to a member function of the class tt(Class), expecting a reference to a tt(Data) element. This member function is called for the tt(object) passed to tt(ForEach()) as its third argument. ) Here is its implementation: verbinsert(FOREACH1)(examples/foreach.h) When this function is used, each element in the iterator range defined by its first two arguments will be passed in turn to tt(object)'s tt(member()) function. Using tt(ForEach()) is easy. It requires us to specify an iterator range, an object and one of its members. For example, the following program extracts strings from the standard input and stores them in a vector of strings using the vector's member tt(push_back()): verbinclude(examples/for1.cc) tt(ForEach()) has several overloaded versions: itemization( it() The first overloaded version is used with constant member functions and non-constant objects. The function expects a pointer to one of its constant member functions. Here is tt(ForEach())'s implementation calling constant member functions: verbinsert(FOREACH2)(examples/foreach.h) The next program uses this overloaded function. A simple class tt(StringVector) is derived from tt(vector). It contains the constant member tt(display()), displaying its argument to the standard output stream. Note that tt(ForEach())'s em(first) implementation is used when the tt(vs) object itself is defined as a tt(const vs) object: verbinclude(examples/for2.cc) it() The second overloaded version assumes that tt(object) itself is a function object, and thus its tt(operator()()) function is called. Since the data type remains implicit, it is removed from the template's parameter list. Eventually, the compiler will infer its type when tt(ForEachObj)'s tt(operator()()) is called. Here is tt(ForEach())'s the second overloaded version: verbinsert(FOREACH3)(examples/foreach.h) The following program illustrates its use. Again, the tt(StringVector) object and its tt(operator()()) member may or may not be given a tt(const) modifier (except, of course, a constant object and a non-constant member): verbinclude(examples/for3.cc) In practice, this final overloaded version should be used sparingly. When a class overloads its function call operator, then multiple tt(ForEach()) calls may be used, distinguishable only by their iterator types. The resulting sources are harder to read than tt(ForEach()) calls in which explicit member functions, suggesting their purposes, are used. As a i(rule of thumb) this final overloaded version should be used only when the class's tt(operator()()) member was em(not) overloaded. ) c++-annotations-10.6.0/yo/concrete/select.yo0000644000175000017500000000256012745054222017554 0ustar frankfrank The ti(select) system call was developed to handle asynchronous hi(multiplexing)emi(I/O multiplexing). The tt(select) system call is used to handle, e.g., input appearing simultaneously at a set of file descriptors. The tt(select) function is rather complex, and its full discussion is beyond the annotations()' scope. By encapsulating tt(select) in a tt(class Selector), hiding its details and offering an intuitively attractive interface, its use is simplified. The tt(Selector) class has these features: itemization( it() Efficiency. As most of tt(Select)'s members are very small, most members can be implemented inline. The class requires quite a few data members. Most of these data members belong to types that require some system headers to be included first: verbinclude(//HEADERS examples/selector.h) it() The class interface can now be defined. The data type tt(fd_set) is a type designed to be used by tt(select) and variables of this type contain the set of file descriptors on which tt(select) may sense some activity. Furthermore, tt(select) allows us to fire an emi(asynchronous alarm). To set the alarm time, the class tt(Selector) defines a ti(timeval) data member. Other members are used for internal bookkeeping purposes. Here is the class tt(Selector)'s interface: verbinclude(//CLASS examples/selector.h) ) c++-annotations-10.6.0/yo/concrete/oformstream.yo0000644000175000017500000000355712745054222020642 0ustar frankfrankIn the i(ANSI/ISO) standard does not include the previously available i(Gnu) extension ti(form()) (and ti(scan())) for stream objects. In this section the construction of a class ti(oformstream) is described, which is derived from hi(derived class) ti(ostream) and does support tt(form()) and ti(vform()). Analogously to tt(oformstream) a tt(class) ti(iscanstream) can be developed, supporting tt(scan()) and ti(vscan()). The contruction of this latter class is left as an i(exercise) to the reader. Here is the class interface and definition. It is annotated below: verbinclude(-a examples/oformstream.h) itemization( it() At 1 the class is defined: it is derived from tt(ostream), so it inherits tt(ostream)'s capabilities. it() At 2 a simple constructor is defined. It expects a reference to a tt(std::ostream) object. it() At 3 the member tt(form()) is declared. Its definition is given shortly. ) A program using the class tt(oformstream) is given in the next example. It prints a well-known string and some marker text: verbinclude(-a examples/oformstream.cc) In the above example: itemization( it() At 1 the function tt(form()) is defined. it() At 2 the function ti(vsnprintf()) is given a buffer size of 0 and tt(0) as the pointer to the buffer. According to the ti(ISO/IEC 9899:1999) standard, the function tt(vsnprintf()) returns the number of required characters for the formatted string (not including the final 0-valued character) (see the tt(vsnprintf()) man page for details and possible alternative implementations of tt(vsnprintf())). it() At 3 an ti(auto_ptr) is used to manage the dynamically hi(dynamic allocation) allocated buffer. it() At 4 the text is formatted. it() At 5 the contents of the buffer are written to the tt(ostream) base class, and the tt(oformstream) object is returned. ) c++-annotations-10.6.0/yo/concrete/parserh.yo0000644000175000017500000000117412745054222017741 0ustar frankfrankSeveral class members called from the grammar are defined as member templates. tt(Bisonc++) generates multiple files, among which the file defining the parser's class. Functions called from the production rule's action blocks are usually member functions of the parser. These member functions must be declared and defined. Once tt(bisonc++) has generated the header file defining the parser's class, that header file isn't automatically rewritten, allowing the programmer to add new members to the parser class whenever required. Here is `tt(parser.h)' as used in our little calculator: verbinclude(-a bisonc++/parser/parser.h) c++-annotations-10.6.0/yo/concrete/streambuf/0000755000175000017500000000000012745054222017711 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/streambuf/fdstreambuf/0000755000175000017500000000000013005340354022205 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/streambuf/fdstreambuf/fdin2cout.cc0000644000175000017500000000055713005340355024421 0ustar frankfrank#include "fdstreambuf.h" #include #include #include using namespace std; // Calls uflow() repeatedly int main(int argc) { fdstreambuf fds(0, ios::in); istream is(&fds); cout << "START\n"; char c; while (is.get(c)) cout << "GOT " << c << '\n'; cout << "Using fds(0)\n"; } c++-annotations-10.6.0/yo/concrete/streambuf/fdstreambuf/fdinrdbuf.cc0000644000175000017500000000057013005340355024462 0ustar frankfrank#include "inok/buf.1.h" #include #include #include using namespace std; // Calls uflow() repeatedly int main(int argc) { fdstreambuf fds(0, ios::in); istream is(&fds); cout << "START\n"; cout << &fds;//is.rdbuf(); cout.clear(); // because of cerr.eof() cout << "Using fds(0)\n"; } c++-annotations-10.6.0/yo/concrete/streambuf/fdstreambuf/fdinbuf100.cc0000644000175000017500000000077013005340355024357 0ustar frankfrank#include "fdstreambuf.h" #include #include #include using namespace std; int main(int argc) { fdstreambuf fds(0, 5, ios::in); istream is(&fds); string s; cout << "START\n"; for (size_t line = 0; getline(is, s); line++) { cout << s << '\n'; if ((line & 3) == 0) { is.unget(); is.unget(); is.unget(); is.unget(); } is.clear(); } } c++-annotations-10.6.0/yo/concrete/streambuf/fdstreambuf/fdstreambuf.h0000644000175000017500000000370513005340355024666 0ustar frankfrank#include #include #include #include using namespace std; class fdstreambuf: public std::streambuf { public: fdstreambuf(int fd, size_t bufsize, size_t minimum, std::ios::openmode mode = std::ios::in | std::ios::out) : fd(fd), bufsize(bufsize), minimum(minimum), buffer(new char[bufsize]) { /* initialize buffer from minimum position to beyond, set gptr() to beyond, so the buffer is filled immediately Assume bufsize - minimum > minimum */ if (mode & std::ios::in) setg(buffer + minimum, buffer + bufsize, buffer + bufsize); } ~fdstreambuf() { delete buffer; } int underflow() // inspects the character { if (gptr() < egptr()) return *gptr(); // return next char waiting in the buffer /* Now that the buffer is refilled, what do we have? buffer eback() gptr() == egptr() ^ ^ ^ ------------------------------- n m <= bufsize - minimum n characters at chars before gptr() are moved left, eback() is moved left over n filling starts are buffer + minimum */ size_t n2move = min(minimum, (size_t)(gptr() - eback())); memcpy(buffer, egptr() - n2move, n2move); /* Read chars to the area beyond the unget-buffer */ int nread = read(fd, buffer + minimum, bufsize - minimum); if (nread <= 0) // none read -> return EOF; setg(buffer + minimum - n2move, buffer + minimum, buffer + minimum + nread); return *gptr(); } private: int fd; size_t bufsize; size_t minimum; char* buffer; }; c++-annotations-10.6.0/yo/concrete/streambuf/fdstreambuf/input0000644000175000017500000000000712745054222023272 0ustar frankfranks a a c++-annotations-10.6.0/yo/concrete/streambuf/fdstreambuf/fdinmininum.cc0000644000175000017500000000074513005340355025040 0ustar frankfrank#include "inok/minimum.h" #include #include #include using namespace std; int main(int argc) { fdstreambuf fds(0, 12, 5, ios::in); istream is(&fds); string s; for (size_t line = 0; getline(is, s); line++) { cout << s << '\n'; if ((line & 3) == 0) { is.unget(); is.unget(); is.unget(); is.unget(); } is.clear(); } } c++-annotations-10.6.0/yo/concrete/streambuf/fdstreambuf/fdinextracttocout.cc0000644000175000017500000000056113005340355026270 0ustar frankfrank#include "inok/buf.1.h" #include #include #include using namespace std; // Calls uflow() repeatedly int main(int argc) { fdstreambuf fds(0, ios::in); istream is(&fds); cerr << "START\n"; char c; while (is >> c) cerr << "\t\tGOT " << c << '\n'; cerr << "Using fds(0)\n"; } c++-annotations-10.6.0/yo/concrete/streambuf/fdstreambuf/fdinputback.cc0000644000175000017500000000050613005340355025010 0ustar frankfrank#include "inok/buf.1.h" #include #include #include using namespace std; int main(int argc) { fdstreambuf fds(0, ios::in); istream is(&fds); cout << "START\n"; char c; is.get(c); cout << c << '\n'; is.unget(); cout << is.rdbuf(); } c++-annotations-10.6.0/yo/concrete/streambuf/fdstreambuf/fbinbufn.cc0000644000175000017500000000077013005340355024312 0ustar frankfrank#include "fdstreambuf.h" #include #include #include using namespace std; int main(int argc) { fdstreambuf fds(0, 5, ios::in); istream is(&fds); string s; cout << "START\n"; for (size_t line = 0; getline(is, s); line++) { cout << s << '\n'; if ((line & 3) == 0) { is.unget(); is.unget(); is.unget(); is.unget(); } is.clear(); } } c++-annotations-10.6.0/yo/concrete/streambuf/fdstreambuf/fdstreambuf.h00000644000175000017500000000324412745054222024751 0ustar frankfrank#include #include #include #include using std::cerr; class fdstreambuf: public std::streambuf { public: fdstreambuf(int fd, std::ios::openmode mode = std::ios::in | std::ios::out) : fd(fd), input_char(EOF), mode(mode) { std::streambuf::_M_mode = mode; // char // dummy; // if (mode & std::ios::in) // setg(&dummy, &dummy, &dummy); // if (mode & std::ios::out) // setp(&dummy, &dummy); } int uflow() // consumes the character { std::cerr << "uflow\n"; if (input_char != EOF) { int next = input_char; input_char = EOF; return next; } return underflow(); } int underflow() // inspects the character { std::cerr << "underflow, in_avail() = " << in_avail() << "\n"; char c; if (read(fd, &c, 1)) { // std::cerr << "Got " << c; input_char = c; std::cerr << ", input_char is " << input_char << " (" << (char)input_char << ")\n"; return input_char; } //std::cerr << "EOF underflow\n"; return input_char = EOF; } int overflow(int c) { if (c != EOF) { if (write(fd, &c, 1) != 1) return EOF; } return c; } private: std::ios::openmode mode; int fd, input_char; }; c++-annotations-10.6.0/yo/concrete/streambuf/fdstreambuf/inok/0000755000175000017500000000000013005340353023144 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/streambuf/fdstreambuf/inok/seek.1.h0000644000175000017500000000323713005340355024412 0ustar frankfrank#include #include #include #include #include #include using namespace std; class fdstreambuf: public std::streambuf { public: fdstreambuf(int fd, std::ios::openmode mode = std::ios::in | std::ios::out) : fd(fd) { if (mode & std::ios::in) setg(buffer, buffer + 1, buffer + 1); } pos_type seekoff(off_type offset, ios::seekdir dir, ios_base::openmode) { pos_type pos = lseek ( fd, offset, (dir == ios::beg) ? SEEK_SET : (dir == ios::cur) ? SEEK_CUR : SEEK_END ); if (pos < 0) return -1; setg(buffer, buffer + 1, buffer + 1); return pos; } pos_type // used by seekg() seekpos(pos_type offset, ios_base::openmode mode) { return seekoff(offset, ios::beg, mode); } int underflow() // inspects the character { if (gptr() < egptr()) return *gptr(); // return next char waiting in the buffer if (read(fd, buffer, 1) <= 0) // none read -> { return EOF; } setg(buffer, buffer, buffer + 1); return *gptr(); } private: char buffer[1]; int fd; }; c++-annotations-10.6.0/yo/concrete/streambuf/fdstreambuf/inok/buf.n.h0000644000175000017500000000203513005340355024327 0ustar frankfrank#include #include #include class fdstreambuf: public std::streambuf { public: fdstreambuf(int fd, size_t bufsize, std::ios::openmode mode = std::ios::in | std::ios::out) : fd(fd), bufsize(bufsize), buffer(new char[bufsize]) { if (mode & std::ios::in) setg(buffer, buffer + bufsize, buffer + bufsize); } ~fdstreambuf() { delete buffer; } int underflow() // inspects the character { if (gptr() < egptr()) return *gptr(); // return next char waiting in the buffer int nread = read(fd, buffer, bufsize); if (nread <= 0) // none read -> return EOF; setg(buffer, buffer, buffer + nread); return *gptr(); } private: int fd; size_t bufsize; char* buffer; }; c++-annotations-10.6.0/yo/concrete/streambuf/fdstreambuf/inok/minimum.h0000644000175000017500000000370513005340355024777 0ustar frankfrank#include #include #include #include using namespace std; class fdstreambuf: public std::streambuf { public: fdstreambuf(int fd, size_t bufsize, size_t minimum, std::ios::openmode mode = std::ios::in | std::ios::out) : fd(fd), bufsize(bufsize), minimum(minimum), buffer(new char[bufsize]) { /* initialize buffer from minimum position to beyond, set gptr() to beyond, so the buffer is filled immediately Assume bufsize - minimum > minimum */ if (mode & std::ios::in) setg(buffer + minimum, buffer + bufsize, buffer + bufsize); } ~fdstreambuf() { delete buffer; } int underflow() // inspects the character { if (gptr() < egptr()) return *gptr(); // return next char waiting in the buffer /* Now that the buffer is refilled, what do we have? buffer eback() gptr() == egptr() ^ ^ ^ ------------------------------- n m <= bufsize - minimum n characters at chars before gptr() are moved left, eback() is moved left over n filling starts are buffer + minimum */ size_t n2move = min(minimum, (size_t)(gptr() - eback())); memcpy(buffer, egptr() - n2move, n2move); /* Read chars to the area beyond the unget-buffer */ int nread = read(fd, buffer + minimum, bufsize - minimum); if (nread <= 0) // none read -> return EOF; setg(buffer + minimum - n2move, buffer + minimum, buffer + minimum + nread); return *gptr(); } private: int fd; size_t bufsize; size_t minimum; char* buffer; }; c++-annotations-10.6.0/yo/concrete/streambuf/fdstreambuf/fdinseek.cc0000644000175000017500000000131213005340355024302 0ustar frankfrank#include "fdstreambuf.h" #include #include #include #include using namespace std; int main(int argc) { fdstreambuf fds(0, ios::in); istream is(&fds); string s; cout << "START\n"; while (true) { if (!getline(is, s)) break; streampos pos = is.tellg(); cout << setw(5) << pos << ": `" << s << "'\n"; if (!getline(is, s)) break; streampos pos2 = is.tellg(); cout << setw(5) << pos2 << ": `" << s << "'\n"; if (!is.seekg(pos)) { cout << "Seek failed\n"; return 1; } } } c++-annotations-10.6.0/yo/concrete/poly/0000755000175000017500000000000013005340354016676 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/poly/input0000644000175000017500000000002512745054222017763 0ustar frankfrankabc(def); xyz = 5; c++-annotations-10.6.0/yo/concrete/poly/semantic/0000755000175000017500000000000013005340353020500 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/poly/semantic/semantic.h0000644000175000017500000000111713005340355022456 0ustar frankfrank#ifndef INCLUDED_SEMANTIC_ #define INCLUDED_SEMANTIC_ #include #include #include "../base/base.h" class Semantic: public std::shared_ptr { friend std::ostream &operator<<(std::ostream &out, Semantic const &obj); public: Semantic(Base *bp = 0); // Semantic owns the bp ~Semantic() = default; }; inline Semantic::Semantic(Base *bp) : std::shared_ptr(bp) {} inline std::ostream &operator<<(std::ostream &out, Semantic const &obj) { if (obj) return out << *obj; return out << ""; } #endif c++-annotations-10.6.0/yo/concrete/poly/parser/0000755000175000017500000000000013005340353020171 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/poly/parser/parser.h0000644000175000017500000000202013005340355021632 0ustar frankfrank#ifndef Parser_h_included #define Parser_h_included // $insert baseclass #include "parserbase.h" // $insert scanner.h #include "../scanner/scanner.h" #undef Parser class Parser: public ParserBase { // $insert scannerobject Scanner d_scanner; public: Parser(); int parse(); private: void error(char const *msg); // called on (syntax) errors int lex(); // returns the next token from the // lexical scanner. void print(); // use, e.g., d_token, d_loc // support functions for parse(): void executeAction(int ruleNr); void errorRecovery(); int lookup(bool recovery); void nextToken(); }; inline void Parser::error(char const *msg) { std::cerr << msg << '\n'; } // $insert lex inline int Parser::lex() { return d_scanner.yylex(); } inline void Parser::print() // use d_token, d_loc {} inline Parser::Parser() : d_scanner(&d_val__) {} #endif c++-annotations-10.6.0/yo/concrete/poly/parser/parser.ih0000644000175000017500000000017313005340354022011 0ustar frankfrank // Include this file in the sources of the class Parser. // $insert class.h #include "parser.h" using namespace std; c++-annotations-10.6.0/yo/concrete/poly/parser/grammar0000644000175000017500000000054612745054222021556 0ustar frankfrank%filenames parser %scanner ../scanner/scanner.h %baseclass-preinclude preinclude.h %stype Semantic %token INT IDENTIFIER %% rules: rules rule | rule ; rule: IDENTIFIER '(' IDENTIFIER ')' ';' { cout << $1 << " " << $3 << '\n'; } | IDENTIFIER '=' INT ';' { cout << $1 << " " << $3 << '\n'; } ; c++-annotations-10.6.0/yo/concrete/poly/parser/preinclude.h0000644000175000017500000000023413005340355022475 0ustar frankfrank#ifndef INCLUDED_PREINCLUDE_H_ #define INCLUDED_PREINCLUDE_H_ #include "../int/int.h" #include "../text/text.h" #include "../semantic/semantic.h" #endif c++-annotations-10.6.0/yo/concrete/poly/scanner/0000755000175000017500000000000013005340353020326 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/poly/scanner/scanner.ih0000644000175000017500000000175613005340354022313 0ustar frankfrank/* Declare here what's only used in the Scanner class and let Scanner's sources include "scanner.ih" */ #include "scanner.h" //#include // #include // #include // #include /* In the current Debian distribution of flex, YY_CURRENT_BUFFER and YY_START are not available to members of the flex-generated class (See `Values Available To The User' in the flex info-file). Use the following macros to make these values available. (Note that the need for these defines may be superfluous in the near future): */ // uncomment if you want to use YY_CURRENT_BUFFER in the scanner's members: /* #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ : NULL) */ // uncomment if you want to use YY_START in the scanner's members: // #define YY_START (((yy_start) - 1) / 2) // end of scanner.ih c++-annotations-10.6.0/yo/concrete/poly/scanner/scanner.h0000644000175000017500000000062713005340355022137 0ustar frankfrank#ifndef SCANNER_H_ #define SCANNER_H_ #include "../semantic/semantic.h" #if ! defined(SKIP_FLEXLEXER_) && ! defined(SYSINC_FLEXLEXER_H_) #include #define SYSINC_FLEXLEXER_H_ #endif class Scanner: public yyFlexLexer { Semantic *d_semval; public: Scanner(Semantic *semval); int yylex(); }; inline Scanner::Scanner(Semantic *semval) : d_semval(semval) {} #endif c++-annotations-10.6.0/yo/concrete/poly/scanner/lexer0000644000175000017500000000117312745054222021401 0ustar frankfrank%{ #define SKIP_FLEXLEXER_ #include "scanner.ih" #include "../parser/preinclude.h" #include "../parser/parserbase.h" %} %option yyclass="Scanner" outfile="yylex.cc" %option c++ 8bit warn noyywrap yylineno %option debug %% [ \t]+ // Often used: skip white space \n // same [0-9]+ { d_semval->reset(new Int(yytext)); return Parser::INT; } [a-zA-Z_][a-zA-Z0-9_]* { d_semval->reset(new Text(yytext)); return Parser::IDENTIFIER; } . return yytext[0]; %% c++-annotations-10.6.0/yo/concrete/poly/base/0000755000175000017500000000000013005340354017610 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/poly/base/base.ih0000644000175000017500000000005013005340354021037 0ustar frankfrank#include "base.h" using namespace std; c++-annotations-10.6.0/yo/concrete/poly/base/clone.cc0000644000175000017500000000011113005340355021211 0ustar frankfrank#include "base.ih" Base *Base::clone() const { return ownClone(); } c++-annotations-10.6.0/yo/concrete/poly/base/base.h0000644000175000017500000000103013005340355020666 0ustar frankfrank #ifndef INCLUDED_BASE_ #define INCLUDED_BASE_ #include class Base { friend std::ostream &operator<<(std::ostream &out, Base const &obj); public: virtual ~Base() = default; Base *clone() const; private: virtual Base *ownClone() const = 0; virtual std::ostream &insert(std::ostream &os) const = 0; }; inline std::ostream &operator<<(std::ostream &out, Base const &obj) { return obj.insert(out); } #endif c++-annotations-10.6.0/yo/concrete/poly/base/frame0000644000175000017500000000004712745054222020634 0ustar frankfrank#include "base.ih" Base::() const { } c++-annotations-10.6.0/yo/concrete/poly/icmconf0000644000175000017500000000675012745054222020255 0ustar frankfrank // Inspect the following #defines. Change them to taste. If you don't // need a particular option, change its value into an empty string // should commands be echoed (ON) or not (OFF) ? #define USE_ECHO ON // The final program and source containing main(): // =============================================== // define the name of the program to create: #define BINARY "../../poly" // define the name of the source containing main(): #define MAIN "main.cc" // #defines used for compilation and linking: // ========================================== // define the compiler to use: #define COMPILER "g++" // define the compiler options to use: #define COMPILER_OPTIONS "-g --std=c++0x -Wall -O2" // define the pattern to locate sources in a directory: #define SOURCES "*.cc" // define the options used for linking: #define LINKER_OPTIONS "-s" // define any additional libraries BINARY may need: #define ADD_LIBRARIES "bobcat" // define any additional paths (other than the standard paths) the // additional libraries are located in: #define ADD_LIBRARY_PATHS "" // #defines used for the final product: // ==================================== #define BIN_INSTALL "/usr/local/bin" // Some advanced #defines, used to create parsers and lexical scanners // =================================================================== // Lexical Scanner section // ======================= // Should a lexical scanner be constructed? If so, define the subdirectory // containing the scanner's specification file. #define SCANNER_DIR "scanner" // What is the program generating the lexical scanner? #define SCANGEN "flex" // Flags to provide SCANGEN with: #define SCANFLAGS "-I" // Name of the lexical scanner specification file #define SCANSPEC "lexer" // Name of the file generated by the lexical scanner #define SCANOUT "yylex.cc" // Parser section // ============== // Should a parser be constructed? If so, define the subdirectory // containing the parser's specification file #define PARSER_DIR "parser" // If a parser must be constructed, should the script (provided in the // skeleton file parser/gramspec/grambuild) `parser/gramspec/grambuild' // **NOT** be called? If it must NOT be called, comment out the following // #define directive: // #define GRAMBUILD // What it the program generating a parser? #define PARSGEN "bisonc++" // What it the grammar specificication file? #define PARSSPEC "grammar" // Flags to provide PARSGEN with: #define PARSFLAGS "-V -l" // Name of the file generated by the parser generator containing the // parser function #define PARSOUT "parse.cc" // Additional defines, which should normally not be modified // ========================================================= // Directory below this directory to contain temporary results #define TMP_DIR "tmp" // Local program library to use (change to an empty string if you want to // use the object modules themselves, rather than a library) #define LIBRARY "modules" // The extension of object modules: #define OBJ_EXT ".o" // below #define DEFCOM "program" or "library" may be added by icmstart #define DEFCOM "program" c++-annotations-10.6.0/yo/concrete/poly/main.cc0000644000175000017500000000020113005340355020123 0ustar frankfrank#include "main.ih" int main(int argc, char **argv) { Parser parser; parser.setDebug(argc == 1); parser.parse(); } c++-annotations-10.6.0/yo/concrete/poly/main.ih0000644000175000017500000000016313005340354020144 0ustar frankfrank#include #include #include #include "parser/preinclude.h" #include "parser/parser.h" c++-annotations-10.6.0/yo/concrete/poly/int/0000755000175000017500000000000013005340353017467 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/poly/int/int.h0000644000175000017500000000134413005340355020436 0ustar frankfrank#ifndef INCLUDED_INT_ #define INCLUDED_INT_ #include #include #include "../base/base.h" class Int: public Base { int d_value; public: Int(char const *text); Int(int v); int value() const; // directly access the value private: virtual Base *ownClone() const; virtual std::ostream &insert(std::ostream &os) const; }; inline Int::Int(char const *txt) : d_value(FBB::A2x(txt)) {} inline Int::Int(int v) : d_value(v) {} inline Base *Int::ownClone() const { return new Int(*this); } inline int Int::value() const { return d_value; } inline std::ostream &Int::insert(std::ostream &out) const { return out << d_value; } #endif c++-annotations-10.6.0/yo/concrete/poly/text/0000755000175000017500000000000013005340353017661 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/poly/text/text.h0000644000175000017500000000126113005340355021020 0ustar frankfrank#ifndef INCLUDED_TEXT_ #define INCLUDED_TEXT_ #include #include #include "../base/base.h" class Text: public Base { std::string d_text; public: Text(char const *id); std::string const &id() const; // directly access the name. private: virtual Base *ownClone() const; virtual std::ostream &insert(std::ostream &os) const; }; inline Text::Text(char const *id) : d_text(id) {} inline Base *Text::ownClone() const { return new Text(*this); } inline std::string const &Text::id() const { return d_text; } inline std::ostream &Text::insert(std::ostream &out) const { return out << d_text; } #endif c++-annotations-10.6.0/yo/concrete/fdout.yo0000644000175000017500000001424112745054221017414 0ustar frankfrank Reading and writing from and to emi(file descriptors) are not part of the bf(C++) standard. But on most operating systems file descriptors em(are) available and can be considered a i(device). It seems natural to use the class hi(streambuf)tt(std::streambuf) as the starting point for constructing classes interfacing such file descriptor devices. Below we'll construct classes that can be used to write to a device given its file descriptor. The devices may be files, but they could also be i(pipe)s or i(socket)s. Section ref(STRBUF) covers reading from such devices; section ref(REDIRECTION) reconsiders redirection, discussed earlier in section ref(REDIR). Using the tt(streambuf) class as a base class it is relatively easy to design classes for output operations. The only member function that em(must) be overridden is the (virtual) member hi(overflow) tt(int streambuf::overflow(int c)). This member's responsibility is to write characters to the device. If tt(fd) is an output file descriptor and if output should not be buffered then the member tt(overflow()) can simply be implemented as: verb( class UnbufferedFD: public std::streambuf { public: virtual int overflow(int c); ... }; int UnbufferedFD::overflow(int c) { if (c != EOF) { if (write(d_fd, &c, 1) != 1) return EOF; } return c; } ) The argument received by tt(overflow) is either written to the file descriptor (and returned from tt(overflow)), or endOfFile() is returned. This simple function does not use output buffering. For various reasons, using a buffer is usually a good idea (see also the next section). When output buffering is used, the tt(overflow) member is a bit more complex as it is only called when the buffer is full. Once the buffer is full, we em(first) have to flush the buffer. Flushing the buffer is the responsibility of the (virtual) function hi(sync)tt(streambuf::sync). Since tt(sync) is a virtual function, classes derived from tt(streambuf) may redefine tt(sync) to flush a buffer tt(streambuf) itself doesn't know about. Overriding tt(sync) and using it in tt(overflow) is not all that has to be done. When the object of the class defining the buffer reaches the end of its lifetime the buffer may be only partially full. In that situation the buffer must also be flushed. This is easily done by simply calling tt(sync) from the class's destructor. Now that we've considered the consequences of using an output buffer, we're almost ready to design our derived class. Several more features are added as well, though: itemization( it() First, we should allow the user of the class to specify the size of the output buffer. it() Second, it should be possible to construct an object of our class before the file descriptor is actually known. Later, in section ref(FORK) we'll encounter a situation where this feature is actually used. ) To save some space in the annotations(), the successful completion of the functions designed here is not checked in the example code. In `real life' implementations these checks should of course not be omitted. Our class tt(OFdnStreambuf) has the following characteristics: itemization( it() Its member functions use low-level functions operating on file descriptors. So apart from tt(streambuf) the tthi(unistd.h) header file must have been read by the compiler before its member functions can be compiled. it() The class is derived from tt(std::streambuf). it() It defines three data members. These data members keep track of, respectively, the size of the buffer, the file descriptor, and the buffer itself. Here is the full class interface verbinclude(//CLASS examples/fdout.h) it() Its default constructor merely initializes the buffer to 0. Slightly more interesting is its constructor expecting a file descriptor and a buffer size. This constructor passes its arguments on to the class's tt(open) member (see below). Here are the constructors: verbinclude(//CONS examples/fdout.h) it() The destructor calls tt(sync), flushing any characters stored in the output buffer to the device. In implementations not using a buffer the destructor can be given a default implementation: verbinclude(//DESTR examples/fdout.h) This implementation does not close the device. It is left as an exercise to the reader to change this class in such a way that the device is optionally closed (or optionally remains open). This approach was adopted by, e.g., the url(Bobcat library)(http://fbb-git.github.io/bobcat/). hi(Bobcat library)hi(http://fbb-git.github.io/bobcat/) See also section ref(IFDNBUF). it() The ti(open) member initializes the buffer. Using hi(setp)tt(streambuf::setp), the begin and end points of the buffer are defined. This is used by the tt(streambuf) base class to initialize hi(pbase)tt(streambuf::pbase), hi(pptr)tt(streambuf::pptr), and hi(epptr)tt(streambuf::epptr): verbinclude(//OPEN examples/fdout.h) it() The member ti(sync) flushes the as yet unflushed contents of the buffer to the device. After the flush the buffer is reinitialized using tt(setp). After successfully flushing the buffer tt(sync) returns 0: verbinclude(//SYNC examples/fdout.h) it() The member hi(overflow)tt(streambuf::overflow) is also overridden. Since this member is called from the tt(streambuf) base class when the buffer is full it should first call tt(sync) to flush the buffer to the device. Next it should write the character tt(c) to the (now empty) buffer. The character tt(c) should be written using tt(pptr) and hi(pbump)tt(streambuf::pbump). Entering a character into the buffer should be implemented using available tt(streambuf) member functions, rather than `by hand' as doing so might invalidate tt(streambuf)'s internal bookkeeping. Here is tt(overflow)'s implementation: verbinclude(//OVERFLOW examples/fdout.h) ) The next program uses the tt(OFfdStreambuf) class to copy its standard input to file descriptor ti(STDOUT_FILENO), which is the symbolic name of the file descriptor used for the standard output: verbinclude(-a examples/fdout.cc) c++-annotations-10.6.0/yo/concrete/rules.yo0000644000175000017500000000233312745054222017425 0ustar frankfrank The rules and actions of the grammar are specified as usual. The grammar for our little calculator is given below. There are quite a few rules, but they illustrate various features offered by tt(bisonc++). In particular, note that no action block requires more than a single line of code. This keeps the grammar simple, and therefore enhances its readability and understandability. Even the rule defining the parser's proper termination (the empty line in the tt(line) rule) uses a single member function called tt(done). The implementation of that function is simple, but it is worth while noting that it calls bf(Parser::ACCEPT), showing that bf(ACCEPT) can be called indirectly from a production rule's action block. Here are the grammar's production rules: verbinclude(//RULES bisonc++/parser/grammar) This grammar is used to implement a simple calculator in which integer and real values can be negated, added, and multiplied and in which standard priority rules can be overruled by parentheses. The grammar shows the use of typed nonterminal symbols: tt(doubleExpr) is linked to real (double) values, tt(intExpr) is linked to integer values. Precedence and type association is defined in the parser's definition section. c++-annotations-10.6.0/yo/concrete/lexerspec.yo0000644000175000017500000000331012745054222020261 0ustar frankfrank The i(lexical scanner specification file) is organized comparably to the one used for tt(flex) in bf(C) contexts. However, in bf(C++) contexts, tt(flexc++) creates a class tt(Scanner), rather than just a scanner function. Flexc++'s specification file consists of two sections: itemization( it() The specification file's first section is tt(flexc++)'s emi(symbol area), used to define symbols, like a i(mini scanner), or emi(options). The following options are suggested: itemization( it() ti(%debug): includes em(debugging) hi(flexc++: debugging code) code into the code generated by tt(flexc++). Calling the member function hi(setDebug) hi(flexc++: setDebug) tt(setDebug(true)) activates this debugging code at run-time. When activated, information about the matching process is written to the standard output stream. The execution of debug code is suppressed after calling the member function tt(setDebug(false)). it() ti(%filenames): defines the base-name of the class header files generated by tt(flexc++). By default the class name (itself using the default tt(Scanner)) is used. ) Here is the specification files' symbol area: verbinclude(//SYMBOLS lexer/scanner/lexer) it() The specification file's second section is a em(rules section) in which the regular expressions and their associated actions are defined. In the example developed here, the lexer should copy information from the standard input stream (tt(std::cin)) to the standard output stream (tt(std::cout)). For this the predefined macro ti(ECHO) can be used. Here are the rules: verbinclude(//RULES lexer/scanner/lexer) ) c++-annotations-10.6.0/yo/concrete/monitorexample.yo0000644000175000017500000000755712745054222021353 0ustar frankfrank Now that tt(run)'s implementation has been covered, we'll concentrate on the various commands users might enter: itemization( it() When the tt(start) command is issued, a new child process is started. A new element is added to tt(d_child) by the member tt(createNewChild). Next, the tt(Child) object should start its activities, but the tt(Monitor) object can not wait for the child process to complete its activities, as there is no well-defined endpoint in the near future, and the user probably wants to be able to enter more commands. Therefore, the tt(Child) process must run as a emi(daemon). So the forked process terminates immediately, but its own child process continues to run (in the background). Consequently, tt(createNewChild) calls the child's tt(fork) member. Although it is the child's tt(fork) function that is called, it is still the monitor program wherein that tt(fork) function is called. So, the em(monitor) program is duplicated by tt(fork). Execution then continues: itemization( it() At the tt(Child)'s tt(parentProcess) in its parent process; it() At the tt(Child)'s tt(childProcess) in its child process ) As the tt(Child)'s tt(parentProcess) is an empty function, returning immediately, the tt(Child)'s parent process effectively continues immediately below tt(createNewChild)'s tt(cp->fork()) statement. As the child process never returns (see section ref(CHILD)), the code below tt(cp->fork()) is never executed by the tt(Child)'s child process. This is exactly as it should be. In the parent process, tt(createNewChild)'s remaining code simply adds the file descriptor that's available for reading information from the child to the set of input file descriptors monitored by tt(d_select), and uses tt(d_child) to establish the association between that file descriptor and the tt(Child) object's address: verbinclude(//CHILD examples/monitor/createnewchild.cc) it() Direct communication with the child is required for the tt(stop ) and tt( text) commands. The former command terminates child process tt(), by calling tt(stopChild). This function locates the child process having the order number using an anonymous object of the class tt(Find), nested inside tt(Monitor). The class tt(Find) simply compares the provided tt(nr) with the children's order number returned by their tt(nr) members: verbinclude(//FINDIMP examples/monitor/monitor.h) If the child process having order number tt(nr) was found, its file descriptor is removed from tt(d_selector)'s set of input file descriptors. Then the child process itself is terminated by the static member tt(killChild). The member tt(killChild) is declared as a em(static) member function, as it is used as function argument of the tt(for_each) generic algorithm by tt(exiting) (see below). Here is tt(killChild)'s implementation: verbinclude(//KILL examples/monitor/monitor.cc) Having terminated the specified child process, the corresponding tt(Child) object is destroyed and its pointer is removed from tt(d_child): verbinclude(//STOP examples/monitor/stopchild.cc) it() The command tt( text) sends tt(text) to child process tt(nr) using the member function tt(sendChild). This function also uses a tt(Find) object to locate the child-process having order number tt(nr), and simply inserts the text into the writing end of a pipe connected to that child process: verbinclude(//SEND examples/monitor/sendchild.cc) it() When users enter tt(exit) or tt(quit) the member tt(exiting) is called. It terminates all child processes using the ti(for_each) generic algorithm (see section ref(FOREACH)) to visit all elements of tt(d_child). Then the program itself ends: verbinclude(//EXIT examples/monitor/monitor.cc) ) The program's tt(main) function is simple and needs no further comment: verbinclude(//MAIN examples/monitor/main.cc) c++-annotations-10.6.0/yo/concrete/scanmain.yo0000644000175000017500000000140412745054222020062 0ustar frankfrank The program using our tt(Scanner) is very simple. It expects a filename indicating where to start the scanning process. The program first checks the number of arguments. If at least one argument was given, then that argument is passed to tt(Scanner)'s constructor, together with a second argument tt("-"), indicating that the output should go to the standard output stream. If the program receives more than one argument debug output, extensively documenting the lexical scanner's actions, is written to the standard output stream as well. Next the tt(Scanner)'s tt(lex) member is called. If anything fails, a tt(std::exception) is thrown, which is caught by tt(main)'s try-block's catch clause. Here is the program's source: verbinclude(-a lexer/lexer.cc) c++-annotations-10.6.0/yo/concrete/unrestricted/0000755000175000017500000000000013005340354020426 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/unrestricted/input0000644000175000017500000000002512745054222021513 0ustar frankfrankabc(def); xyz = 5; c++-annotations-10.6.0/yo/concrete/unrestricted/semantic/0000755000175000017500000000000013005340354022231 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/unrestricted/semantic/semantic2.cc0000644000175000017500000000041613005340355024427 0ustar frankfrank#include "semantic.ih" Semantic::Semantic(Semantic const &other) : d_int(other.d_int) // blunt copy of d_int { if (d_int.first == IDENTIFIER) // if a string: copy it new (&d_str.second) string(other.d_str.second); } c++-annotations-10.6.0/yo/concrete/unrestricted/semantic/semantic1.cc0000644000175000017500000000041313005340355024423 0ustar frankfrank#include "semantic.ih" Semantic::Semantic(Type type, char const *txt) { d_int.first = static_cast(type); if (type == IDENTIFIER) new (&d_str.second) string(txt); else { istringstream in(txt); in >> d_int.second; } } c++-annotations-10.6.0/yo/concrete/unrestricted/semantic/semantic.ih0000644000175000017500000000012313005340354024352 0ustar frankfrank#include "semantic.h" #include #include using namespace std; c++-annotations-10.6.0/yo/concrete/unrestricted/semantic/semantic.h0000644000175000017500000000122213005340355024203 0ustar frankfrank#ifndef INCLUDED_SEMANTIC_ #define INCLUDED_SEMANTIC_ #include #include union Semantic { friend std::ostream &operator<<(std::ostream &out, Semantic const &obj); std::pair d_int; std::pair d_str; public: enum Type { INT, IDENTIFIER }; Semantic(); Semantic(Type type, char const *txt); Semantic(Semantic const &other); // 2 ~Semantic(); Semantic &operator=(Semantic const &rhs); void swap(Semantic &other); }; inline Semantic::Semantic() : d_int {INT, 0} {} #endif c++-annotations-10.6.0/yo/concrete/unrestricted/semantic/operatorinsert.cc0000644000175000017500000000035213005340355025621 0ustar frankfrank#include "semantic.ih" std::ostream &operator<<(std::ostream &out, Semantic const &obj) { if (obj.d_int.first == Semantic::IDENTIFIER) out << obj.d_str.second; else out << obj.d_int.second; return out; } c++-annotations-10.6.0/yo/concrete/unrestricted/semantic/destructor.cc0000644000175000017500000000023413005340355024736 0ustar frankfrank#include "semantic.ih" Semantic::~Semantic() { if (d_int.first == IDENTIFIER) d_str.second.~string(); // destroy the string's memory } c++-annotations-10.6.0/yo/concrete/unrestricted/semantic/operatorassign.cc0000644000175000017500000000020713005340355025600 0ustar frankfrank#include "semantic.ih" Semantic &Semantic::operator=(Semantic const &rhs) { Semantic tmp(rhs); swap(tmp); return *this; } c++-annotations-10.6.0/yo/concrete/unrestricted/semantic/swap.cc0000644000175000017500000000035313005340355023514 0ustar frankfrank#include "semantic.ih" void Semantic::swap(Semantic &other) { char buffer[sizeof(Semantic)]; memcpy(buffer, this, sizeof(Semantic)); memcpy(this, &other, sizeof(Semantic)); memcpy(&other, buffer, sizeof(Semantic)); } c++-annotations-10.6.0/yo/concrete/unrestricted/semantic/frame0000644000175000017500000000004712745054222023255 0ustar frankfrank#include "semantic.ih" Semantic:: { } c++-annotations-10.6.0/yo/concrete/unrestricted/parser/0000755000175000017500000000000013005340353021721 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/unrestricted/parser/parser.h0000644000175000017500000000202013005340355023362 0ustar frankfrank#ifndef Parser_h_included #define Parser_h_included // $insert baseclass #include "parserbase.h" // $insert scanner.h #include "../scanner/scanner.h" #undef Parser class Parser: public ParserBase { // $insert scannerobject Scanner d_scanner; public: Parser(); int parse(); private: void error(char const *msg); // called on (syntax) errors int lex(); // returns the next token from the // lexical scanner. void print(); // use, e.g., d_token, d_loc // support functions for parse(): void executeAction(int ruleNr); void errorRecovery(); int lookup(bool recovery); void nextToken(); }; inline void Parser::error(char const *msg) { std::cerr << msg << '\n'; } // $insert lex inline int Parser::lex() { return d_scanner.yylex(); } inline void Parser::print() // use d_token, d_loc {} inline Parser::Parser() : d_scanner(&d_val__) {} #endif c++-annotations-10.6.0/yo/concrete/unrestricted/parser/parser.ih0000644000175000017500000000017313005340354023541 0ustar frankfrank // Include this file in the sources of the class Parser. // $insert class.h #include "parser.h" using namespace std; c++-annotations-10.6.0/yo/concrete/unrestricted/parser/grammar0000644000175000017500000000063712745054222023307 0ustar frankfrank%class-name Parser %filenames parser %parsefun-source parse.cc %scanner ../scanner/scanner.h // %debug %baseclass-preinclude preinclude.h %stype Semantic %token INT IDENTIFIER %% rules: rules rule | rule ; rule: IDENTIFIER '(' IDENTIFIER ')' ';' { cout << $1 << " " << $3 << '\n'; } | IDENTIFIER '=' INT ';' { cout << $1 << " " << $3 << '\n'; } ; c++-annotations-10.6.0/yo/concrete/unrestricted/parser/preinclude.h0000644000175000017500000000015113005340355024223 0ustar frankfrank#ifndef INCLUDED_PREINCLUDE_H_ #define INCLUDED_PREINCLUDE_H_ #include "../semantic/semantic.h" #endif c++-annotations-10.6.0/yo/concrete/unrestricted/scanner/0000755000175000017500000000000013005340353022056 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/unrestricted/scanner/scanner.ih0000644000175000017500000000175613005340354024043 0ustar frankfrank/* Declare here what's only used in the Scanner class and let Scanner's sources include "scanner.ih" */ #include "scanner.h" //#include // #include // #include // #include /* In the current Debian distribution of flex, YY_CURRENT_BUFFER and YY_START are not available to members of the flex-generated class (See `Values Available To The User' in the flex info-file). Use the following macros to make these values available. (Note that the need for these defines may be superfluous in the near future): */ // uncomment if you want to use YY_CURRENT_BUFFER in the scanner's members: /* #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ : NULL) */ // uncomment if you want to use YY_START in the scanner's members: // #define YY_START (((yy_start) - 1) / 2) // end of scanner.ih c++-annotations-10.6.0/yo/concrete/unrestricted/scanner/scanner.h0000644000175000017500000000066513005340355023671 0ustar frankfrank#ifndef SCANNER_H_ #define SCANNER_H_ #include "../semantic/semantic.h" #if ! defined(SKIP_FLEXLEXER_) && ! defined(SYSINC_FLEXLEXER_H_) #include #define SYSINC_FLEXLEXER_H_ #endif class Scanner: public yyFlexLexer { Semantic *d_semval; // received fm the parser public: Scanner(Semantic *semval); int yylex(); }; inline Scanner::Scanner(Semantic *semval) : d_semval(semval) {} #endif c++-annotations-10.6.0/yo/concrete/unrestricted/scanner/lexer0000644000175000017500000000121312745054222023124 0ustar frankfrank%{ #define SKIP_FLEXLEXER_ #include "scanner.ih" #include "../parser/preinclude.h" #include "../parser/parserbase.h" %} %option yyclass="Scanner" outfile="yylex.cc" %option c++ 8bit warn noyywrap yylineno %option debug %% [ \t]+ // skip white space \n // same [0-9]+ { *d_semval = Semantic(Semantic::INT, yytext); return Parser::INT; } [a-zA-Z_][a-zA-Z0-9_]* { *d_semval = Semantic(Semantic::IDENTIFIER, yytext); return Parser::IDENTIFIER; } . return yytext[0]; %% c++-annotations-10.6.0/yo/concrete/unrestricted/icmconf0000644000175000017500000000675012745054222022005 0ustar frankfrank // Inspect the following #defines. Change them to taste. If you don't // need a particular option, change its value into an empty string // should commands be echoed (ON) or not (OFF) ? #define USE_ECHO ON // The final program and source containing main(): // =============================================== // define the name of the program to create: #define BINARY "../../poly" // define the name of the source containing main(): #define MAIN "main.cc" // #defines used for compilation and linking: // ========================================== // define the compiler to use: #define COMPILER "g++" // define the compiler options to use: #define COMPILER_OPTIONS "-g --std=c++0x -Wall -O2" // define the pattern to locate sources in a directory: #define SOURCES "*.cc" // define the options used for linking: #define LINKER_OPTIONS "-s" // define any additional libraries BINARY may need: #define ADD_LIBRARIES "bobcat" // define any additional paths (other than the standard paths) the // additional libraries are located in: #define ADD_LIBRARY_PATHS "" // #defines used for the final product: // ==================================== #define BIN_INSTALL "/usr/local/bin" // Some advanced #defines, used to create parsers and lexical scanners // =================================================================== // Lexical Scanner section // ======================= // Should a lexical scanner be constructed? If so, define the subdirectory // containing the scanner's specification file. #define SCANNER_DIR "scanner" // What is the program generating the lexical scanner? #define SCANGEN "flex" // Flags to provide SCANGEN with: #define SCANFLAGS "-I" // Name of the lexical scanner specification file #define SCANSPEC "lexer" // Name of the file generated by the lexical scanner #define SCANOUT "yylex.cc" // Parser section // ============== // Should a parser be constructed? If so, define the subdirectory // containing the parser's specification file #define PARSER_DIR "parser" // If a parser must be constructed, should the script (provided in the // skeleton file parser/gramspec/grambuild) `parser/gramspec/grambuild' // **NOT** be called? If it must NOT be called, comment out the following // #define directive: // #define GRAMBUILD // What it the program generating a parser? #define PARSGEN "bisonc++" // What it the grammar specificication file? #define PARSSPEC "grammar" // Flags to provide PARSGEN with: #define PARSFLAGS "-V -l" // Name of the file generated by the parser generator containing the // parser function #define PARSOUT "parse.cc" // Additional defines, which should normally not be modified // ========================================================= // Directory below this directory to contain temporary results #define TMP_DIR "tmp" // Local program library to use (change to an empty string if you want to // use the object modules themselves, rather than a library) #define LIBRARY "modules" // The extension of object modules: #define OBJ_EXT ".o" // below #define DEFCOM "program" or "library" may be added by icmstart #define DEFCOM "program" c++-annotations-10.6.0/yo/concrete/unrestricted/main.cc0000644000175000017500000000020113005340355021653 0ustar frankfrank#include "main.ih" int main(int argc, char **argv) { Parser parser; parser.setDebug(argc == 1); parser.parse(); } c++-annotations-10.6.0/yo/concrete/unrestricted/main.ih0000644000175000017500000000016313005340354021674 0ustar frankfrank#include #include #include #include "parser/preinclude.h" #include "parser/parser.h" c++-annotations-10.6.0/yo/concrete/unrestricted/CLASSES0000644000175000017500000000001112745054222021444 0ustar frankfranksemantic c++-annotations-10.6.0/yo/concrete/command.yo0000644000175000017500000000131112745054221017703 0ustar frankfrank The tt(class Command) defines the interface to be used for scanning commands from the standard input. Its constructor expects an array of strings, which are the commands to be recognized, as well as the number of commands. The command tt(\d) represents a digit, tt(*) represents any text until end of line. Blanks may appear before or after the commands. The class does nothing fancy: if anything more complex is required, a formal emi(grammar) should be specified (see section(BISONFLEX)). Its member tt(int next(std::string &text)) returns the number of the interpreted command, with tt(text) containing the actual text that was received. Here is the class interface: verbinclude(-a examples/command.h) c++-annotations-10.6.0/yo/concrete/fistream.yo0000644000175000017500000000777112745054221020117 0ustar frankfrankUsually when extracting information from tt(istream) objects oprshift(), the standard extraction operator is perfectly suited for the task as in most cases the extracted fields are white-space (or otherwise clearly) separated from each other. But this does not hold true in all situations. For example, when a web-form is posted to some processing script or program, the receiving program may receive the form field's values as em(url-encoded) characters: letters and digits are sent unaltered, blanks are sent as tt(+) characters, and all other characters start with tt(%) followed by the character's i(ascii-value) represented by its two digit hexadecimal value. When decoding url-encoded information, simple hexadecimal extraction won't work, as that extracts as many hexadecimal characters as available, instead of just two. Since the letters tt(a-f`) and tt(0-9) are legal hexadecimal characters, a text like tt(My name is `Ed'), url-encoded as verb( My+name+is+%60Ed%27 ) results in the extraction of the hexadecimal values tt(60ed) and tt(27), instead of tt(60) and tt(27). The name tt(Ed) disappears from view, which is clearly not what we want. In this case, having seen the tt(%), we could extract 2 characters, put them in an ti(istringstream) object, and extract the hexadecimal value from the tt(istringstream) object. A bit cumbersome, but doable. Other approaches are possible as well. The class ti(Fistream) for em(fixed-sized field istream) defines an tt(istream) class supporting both fixed-sized field extractions and blank-delimited extractions (as well as unformatted tt(read) calls). The class may be initialized as a emi(wrapper) around an existing tt(istream), or it can be initialized using the name of an existing file. The class is derived from tt(istream), allowing all extractions and operations supported by tt(istream)s in general. tt(Fistream) defines the following data members: itemization( itt(d_filebuf): a filebuffer used when tt(Fistream) reads its information from a named (existing) file. Since the filebuffer is only needed in that case, and since it must be allocated dynamically, it is defined as a tt(unique_ptr) object. itt(d_streambuf): a pointer to tt(Fistream)'s tt(streambuf). It points to tt(d_filebuf) when tt(Fistream) opens a file by name. When an existing tt(istream) is used to construct an tt(Fistream), it points to the existing tt(istream)'s tt(streambuf). itt(d_iss): an tt(istringstream) object used for the fixed field extractions. itt(d_width): a tt(size_t) indicating the width of the field to extract. If 0 no fixed field extractions is used, but information is extracted from the tt(istream) base class object using standard extractions. ) Here is the initial section of tt(Fistream)'s class interface: verbinclude(//INITIAL examples/fistream/fistream.h) As stated, tt(Fistream) objects can be constructed from either a filename or an existing tt(istream) object. The class interface therefore declares two constructors: verbinclude(//CONS examples/fistream/fistream.h) When an tt(Fistream) object is constructed using an existing tt(istream) object, the tt(Fistream)'s tt(istream) part simply uses the tt(stream)'s tt(streambuf) object: verbinclude(//CONS1 examples/fistream/fistream.cc) When an tt(fstream) object is constructed using a filename, the tt(istream) base initializer is given a new tt(filebuf) object to be used as its tt(streambuf). Since the class's data members are not initialized before the class's base class has been constructed, tt(d_filebuf) can only be initialized thereafter. By then, the tt(filebuf) is only available as tt(rdbuf), returning a tt(streambuf). However, as it is actually a tt(filebuf), a tt(static_cast) is used to cast the tt(streambuf) pointer returned by tt(rdbuf) to tt(a filebuf *), so tt(d_filebuf) can be initialized: verbinclude(//CONS2 examples/fistream/fistream.cc) c++-annotations-10.6.0/yo/concrete/addtypes.yo0000644000175000017500000000070612745054221020111 0ustar frankfrankThese are the steps to take when another semantic data type must be added to an existing set: itemization( it() Add a tag name representing the new semantic value type to the tt(enum class Tag) (section ref(TAG)); it() Add a specialization to the tt(TagTrait) trait class (section ref(TAGTRAIT)) defining the added semantic value's data type, and whether or not the data on the parser's semantic stack should be considered (im)mutable. ) c++-annotations-10.6.0/yo/concrete/proxy.yo0000644000175000017500000001303312745054222017453 0ustar frankfrankA problem with ti(operator[]) is that it can't distinguish between its hi(lvalue: distinguish from rvalue)hi(rvalue: distinguish from lvalue) use as an em(lvalue) and as an em(rvalue). It is a familiar misconception to think that verb( Type const &operator[](size_t index) const ) is used as em(rvalue) (as the object isn't modified), and that verb( Type &operator[](size_t index) ) is used as em(lvalue) (as the returned value can be modified). The compiler, however, distinguishes between the two operators only by the tt(const)-status of the object for which tt(operator[]) is called. With tt(const) objects the former operator is called, with non-tt(const) objects the latter is always used. It is always used, irrespective of it being used as lvalue or rvalue. Being able to distinguish between lvalues and rvalues can be very useful. Consider the situation where a class supporting tt(operator[]) stores data of a type that is very hard to copy. With data like that reference counting (e.g., using tt(shared_ptr)s) is probably used to prevent needless copying. As long as tt(operator[]) is used as rvalue there's no need to copy the data, but the information em(must) be copied if it is used as lvalue. The emi(Proxy Design Pattern) (cf. hi(Gamma, E.)em(Gamma et al.) (1995)) can be used to distinguish between lvalues and rvalues. With the Proxy Design Pattern an object of another class (the Proxy class) is used to act as a em(stand in) for the `real thing'. The proxy class offers functionality that cannot be offered by the data themselves, like distinguishing between its use as lvalue or rvalue. A proxy class can be used in many situations where access to the real data cannot or should not be directly provided. In this regard em(iterator) types are examples of proxy classes as they create a layer between the real data and the software using the data. Proxy classes could also dereference pointers in a class storing its data by pointers. In this section we concentrate on the distinction between using tt(operator[]) as lvalue and rvalue. Let's assume we have a class tt(Lines) storing lines from a file. Its constructor expects the name of a stream from which the lines are read and it offers a non-const tt(operator[]) that can be used as lvalue or rvalue (the tt(const) version of tt(operator[]) is omitted as it causes no confusion because it is always used as rvalue): verbinclude(//LINES examples/lines0.h) To distinguish between lvalues and rvalues we must find distinguishing characteristics of lvalues and rvalues that we can exploit. Such distinguishing characteristics are tt(operator=) (which is always used as lvalue) and the conversion operator (which is always used as rvalue). Rather than having tt(operator[]) return a tt(string &) we can let it return a tt(Proxy) object that is able to distinguish between its use as lvalue and rvalue. The class tt(Proxy) thus needs tt(operator=(string const &other)) (acting as lvalue) and tt(operator std::string const &() const) (acting as rvalue). Do we need more operators? The tt(std::string) class also offers tt(operator+=), so we should probably implement that operator as well. Plain characters can also be assigned to tt(string) objects (even using their numeric values). As tt(string) objects cannot be em(constructed) from plain characters em(promotion) cannot be used with tt(operator=(string const &other)) if the right-hand side argument is a character. Implementing tt(operator=(char value)) could therefore also be considered. These additional operators are left out of the current implementation but `real life' proxy classes should consider implementing these additional operators as well. Another subtlety is hi(Proxy: stream insertion and extraction) that tt(Proxy)'s tt(operator std::string const &() const) is not used when using tt(ostream)'s insertion operator or tt(istream)'s extraction operator as these operators are implemented as templates not recognizing our tt(Proxy) class type. So when stream insertion and extraction is required (it probably is) then tt(Proxy) must be given its own overloaded insertion and extraction operator. Here is an implementation of the overloaded insertion operator inserting the object for which tt(Proxy) is a stand-in: verbinclude(//INSERT examples/lines.h) There's no need for any code (except tt(Lines)) to create or copy tt(Proxy) objects. tt(Proxy)'s constructor should therefore be made private, and tt(Proxy) can declare tt(Lines) to be its friend. In fact, tt(Proxy) is intimately related to tt(Lines) and can be defined as a nested class. In the revised tt(Lines) class tt(operator[]) no longer returns a tt(string) but instead a tt(Proxy) is returned. Here is the revised tt(Lines) class, including its nested tt(Proxy) class: verbinclude(//LINES examples/lines.h) tt(Proxy)'s members are very lightweight and can usually be implemented inline: verbinclude(//MEMBERS examples/lines.h) The member tt(Lines::operator[]) can also be implemented inline: it merely returns a tt(Proxy) object initialized with the tt(string) associated with index tt(idx). Now that the class tt(Proxy) has been developed it can be used in a program. Here is an example using the tt(Proxy) object as lvalue or rvalue. On the surface tt(Lines) objects won't behave differently from tt(Lines) objects using the original implementation, but by adding an identifying tt(cout) statement to tt(Proxy)'s members it can be shown that tt(operator[]) behaves differently when used as lvalue or as rvalue: verbinclude(//MAIN examples/lines.cc) c++-annotations-10.6.0/yo/concrete/access.yo0000644000175000017500000000356312745054221017541 0ustar frankfrankHow to access the data that are actually stored inside a semantic value class that is derived from the semantic values polymorphic base class? Depending on the status (mutable or immutable) and type (basic or class type) of the actual semantic data we recognize three situations: itemization( it() If the data within the semantic value class are mutable, then an accessor should return a reference to the data stored within the semantic value class; it() Immutable non-class type values should be made available by value; it() Immutable class type values should be made available as const references. ) Next, a trait class template tt(Trait) is defined, requiring a tt(Tag) template non-type parameter. This trait class uses the tt(Tag) to determine the data type that is associated with the tt(Tag), making its local type tt(DataType) as synonym of that data type. Next, to determine whether an actual data type is a class type or a basic type template meta programming, as outlined in section ref(CLASSORNOT), is used. Using template meta programming a value tt(isBasicType) of an tt(enum: bool) anonymous enum is set to true if tt(DataType) represents a basic data type. This enum also defines a value tt(isMutable) indicating whether or not the actual data stored in a semantic value class is mutable or not. Next, conditional to the combinations of tt(isMutable) and tt(isBasicType) the tt(Trait) trait class defines the type tt(ReturnType). For this the available tt(std::conditional) trait class is used (cf. section ref(TYPETRAITS)). Now we're able, e.g., to state tt(Trait::DataType) to obtain the tt(int) data type, or to state tt(Trait::ReturnType) to obtain the `tt(std::vector> &)' return type. Here is the implementation of the trait class template tt(Trait): verbinclude(//CLASSTRAIT poly2/sembase/sembase.h) c++-annotations-10.6.0/yo/concrete/spsembase.yo0000644000175000017500000000051712745054222020257 0ustar frankfrankThe parser uses tt(spSemBase) as its semantic value. The class tt(spSemBase) is a wrapper around tt(std::shared_ptr), offering a constructor member template which must be given a pointer to a dynamically allocated tt(Semantic) object. Its interface is all that is required: verbinclude(-a poly2/spsembase/spsembase.h) c++-annotations-10.6.0/yo/concrete/tag.yo0000644000175000017500000000037212745054222017047 0ustar frankfrankOur program handles three types of semantic values: numbers, text, and vectors of semantic values, which are either numbers or text. These distinct types are indicated by em(tag) enumeration values: verbinclude(//TAG poly2/sembase/sembase.h) c++-annotations-10.6.0/yo/concrete/scanner.yo0000644000175000017500000000424012745054222017723 0ustar frankfrank The tt(class Scanner) is generated once by bi(flexc++). This class has access to several members defined by its base class tt(ScannerBase). Some of these members have public access rights and can be used by code external to the class tt(Scanner). These members are extensively documented in the bf(flexc++)(1) man-page, and the reader is referred to this man-page for further information. Our scanner performs the following tasks: itemization( it() it matches regular expressions, ignoring comment, and writing the matched text to the standard output stream; it() it switches to other files, and returns to the previous file once a file has completely been processed, ending the lexical scan once the end of the first input file has been reached. ) The tt(#include) statements in the input allow the scanner to distill the name of the file where the scanning process must continue. This file name is stored in a local variable tt(d_nextSource) and a member tt(stackSource) handles the switch to the next source. Nothing else is required. Pushing and popping input files is handled by the scanner's members tt(pushStream) and tt(popStream), provided by tt(flexc++). tt(Scanner)'s interface, therefore, only needs one additional function declaration: tt(switchSource). Switching streams is handled as follows: once the scanner has extracted a filename from an tt(#include) directive, a switch to another file is realized by tt(switchSource). This member calls tt(pushStream), defined by tt(flexc++), to stack the current input stream and to switch to the stream whose name is stored in tt(d_nextSource). This also ends the tt(include) mini-scanner, so to return the scanner to its default scanning mode tt(begin(StartCondition__::INITIAL)) is called. Here is its source: verbinclude(-a lexer/scanner/switchsource.cc) The member tt(pushStream), defined by tt(flexc++), handles all necessary checks, throwing an exception if the file could not be opened or if too many files are stacked. The member performing the lexical scan is defined by tt(flexc++) in tt(Scanner::lex), and this member can be called by code to process the tokens returned by the scanner. c++-annotations-10.6.0/yo/concrete/polymorphic.yo0000644000175000017500000000756612745054222020655 0ustar frankfrankInstead of using unions to store various semantic values tt(bisonc++) could also use a polymorphic base class to handle semantic values of various types. Using a polymorphic base class is covered in this section. The described method is a direct result of a suggestion initially brought forward by Dallas A. Clement in September 2007. One may wonder why tt(union)s are still used by Bisonc++, as bf(C++) offers inherently superior ways to handle multiple semantic types: a poymorphic base class and a series of derived classes implementing the alternative data types. On the other hand, a polymorphic base class also seems to imply a lot of additional work: classes must be derived from a base class, virtual members must be declared and overridden in derived classes, and the base class must be aware of the relevant interfaces of all derived classes. All this does more to hinder than to promote the construction of reusable software. So, how to proceed? It turns out that the required effort to implement and use polymorphic semantic values is fairly small. In fact, only a very basic polymorphic semantic base class needs to be implemented. Having defined the polymorphic base class template meta programming techniques can be used to let the compiler create all derived classes we might need. The amount of works turns out to be astonishingly small. What about the `free lunch'? Well, the approach works fine in situations where we either can deduct the actual semantic value from the grammar (i.e., the syntax) itself, or where we occasionally are willing to use a switch to select the actual semantic value. This rather weak assumption holds true for the grammar used by the program developed in this section, so let's get on with it! The program developed in this section recognizes input consisting of lines suggesting assignment statements or function calls: verb( value: int | ident ; arglist: arglist ',' value | value ; rule: ident '(' arglist ')' ';' | ident '=' int ';' ; ) An essential characteristic of these simple rules is that three different semantic value types are used: int-values, names, and vectors of arguments. Other types could easily be used as well: doubles, complex numbers, sets; you name it. Our semantic value must accomodate all of these different types, and must also allow us to determine the actual type that's stored in a semantic value in cases where we cannot deduct the actual type merely from the syntax (which happens, e.g., for the various semantic value types that may be contained in an tt(arglist)). In the following sections we'll develop the parser using a polymorphic base class to handle its semantic values. To prevent excessive copying of semantic values the parser's actual semantic value is not the semantic value itself but a tt(spSemBase), which is a wrapper around a tt(std::shared_ptr), where tt(SemBase) is our polymorphic base class (cf. section ref(SPSEMBASE)). We'll develop the generic tt(Semantic) class template in steps: itemization( it() In the next section we'll start by defining em(tags) for the various semantic data types; it() Next, support structs are developed allowing us to indicate whether semantic data can be modified by the parser or not; it() Following this, a trait class is developed allowing us to obtain data types from tags; it() Another trait class is needed to determine the data type that is returned by the conversion operators of the different semantic data types; it() Hereafter the polymorphic base class tt(SemBase) is developed; it() Finally, de class template tt(Semantic) is defined, allowing us to define various semantic value classes, all derived from tt(SemBase) ) The complete demo program is available in the annotation()'s source archive under the directory tt(yo/concrete/poly2). c++-annotations-10.6.0/yo/concrete/unrestricted.yo0000644000175000017500000000710112745054222021004 0ustar frankfrankUnions revived in bf(C++) with the advent of unrestricted unions. In this section we'll have a look at how to used them as semantic values in a Bisonc++ generated parser. The just developed polymorphic semantic value had to support itemization( itt(int) values; itt(textual) values of type tt(string); ) When unrestricted unions are used, the union must be able to support tt(int) and tt(string) values. Using the tt(pair) to allow the union to do `introspection' (cf. section ref(UNIONS)), we now define a em(union) tt(Semantic) having the following data members: verb( std::pair d_int; std::pair d_str; ) Since an unrestricted union by default deletes all its standard constructors and operators (it must do so, as it cannot tell which data variant is currently active) they must all be implemented explicitly by the tt(Semantic) union. To aid the introspection a type is defined, indicating whether the variant is an tt(int) or a tt(string), and the default constructor simply defines an tt(INT) value 0. Here is tt(Semantic)'s interface: verbinclude(-a unrestricted/semantic/semantic.h) tt(Semantic) objects are as big as required to accomodate all its variants. However, as tt(Semantic) is a union, its constructors and destructor cannot predefine or destroy all of its variants. Rather, it must pick the appropriate field based on the tt(pair)'s tt(first) field. For tt(int) values a simple assignment is OK, but for tt(string) values a constructor and destructor must be used. For this, placement new and an explicit destructor call is required. Here are tt(Semantic)'s tt(Semantic(Type, char const *)), its copy constructor and its destructor: verbinclude(-a unrestricted/semantic/semantic1.cc) verbinclude(-a unrestricted/semantic/semantic2.cc) verbinclude(-a unrestricted/semantic/destructor.cc) Our little parser only needs to be able to insert semantic values. For this an overloaded insertion operator can be used: verbinclude(-a unrestricted/semantic/operatorinsert.cc) The remaining members (tt(operator=, swap)) are standard, and need no further explanation. As tt(Semantic) objects know what type of value they represent, the parser's grammar specification needs no modification. Minor modifications for the scanner's specification, tt(lexer), however are required. Since tt(Semantic) is no longer a wrapper class for a polymorphic base class, using a shared pointer, the previously used tt(shared_ptr)'s tt(reset) calls need to be replaced by direct assignments of tt(Semantic) values to the tt(*d_semval) semantic value. The relevant section of the scanner's specification file tt(lexer) now becomes: verb( [0-9]+ { *d_semval = Semantic(Semantic::INT, yytext); return Parser::INT; } [a-zA-Z_][a-zA-Z0-9_]* { *d_semval = Semantic(Semantic::IDENTIFIER, yytext); return Parser::IDENTIFIER; } ) This is all that is required to change a parser using a polymorphic base class to a parser using an unrestricted union. As memory allocation using placement new is fast, an unrestricted union is an efficient way to store multiple data types. Moreover, the semantic value classes implementing the polymorphic semantic value behavior, tt(Base, Int), and tt(Text) are no longer required, nor is the use of the tt(shared_ptr) in a wrapper class (the previously used tt(Semantic) value) required anymore. All in, using an unrestricted union for the parser's semantic values seems like a good deal. c++-annotations-10.6.0/yo/concrete/mutable.yo0000644000175000017500000000115612745054222017726 0ustar frankfrankIn cases where the data stored in the classes derived from the polymorphic base class may either or not be mutable by the parser, there must be a way to indicate so when the derived class is created. Two small support structs define tt(isMutable) enum values indicating whether the data should be considered mutable or not. To make matters concrete, let's assume that we'll need tt(INT) and tt(TEXT) semantic values to be immutable, while tt(VECTOR) semantic values need to be mutable. Here are these structs, defined in the anonymous namespace within tt(sembase.h): verbinclude(//MUTABLE poly2/sembase/sembase.h) c++-annotations-10.6.0/yo/concrete/fork2/0000755000175000017500000000000012745054222016744 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/fork2/parentprocess/0000755000175000017500000000000013005340353021625 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/fork2/parentprocess/parentprocess.h0000644000175000017500000000111113005340355024662 0ustar frankfrank#ifndef INCLUDED_PARENTPROCESS_H_ #define INCLUDED_PARENTPROCESS_H_ #ifndef INCLUDED_IOSFWD_ #include #define INCLUDED_IOSFWD_ #endif namespace FBB { class ParentProcess { public: virtual ~ParentProcess() {} virtual void run // pure virtual function: implement in ( // derived classes int pid, std::istream &readChildCout, std::istream &readChildCerr, std::ostream &writeChildCin ) = 0; }; } #endif c++-annotations-10.6.0/yo/concrete/fork2/build0000755000175000017500000003032312745054221017771 0ustar frankfrank#!/usr/bin/icmake -qt/tmp/fork // script generated by the C++ icmake script version 1.62 /* Configurable defines for the build script: CLASSES: string of directory-names under which sources of classes are found. E.g., CLASSES = "class1 class2" All class-names must be stored in one string. If classes are removed from the CLASSES definition or if the names in the CLASSES definition are reordered, the compilation should start again from scratch. */ string CLASSES; void setClasses() { // ADD ADDITIONAL DIRECTORIES CONTAINING SOURCES OF CLASSES HERE // Use the construction `CLASSES += "classname1 classname2";' etc. CLASSES += "pipe ofdnstreambuf ifdnstreambuf opipe cinredirector " "childprocess fork"; } /* COMPILER: "g++" for C++ sources. Do not change this, unless you're sure you want something else. COPT: C-options used by COMPILER ECHO_REQUEST: ON (default) if command echoing is wanted, otherwise: set to OFF GDB: define if gdb-symbolic debug information is wanted (not defined by default) LIBS: Extra libraries used for linking LIBPATH: Extra library-searchpaths used for linking USE_LIBRARY: define this if you want a library for the object modules. Undefined by default: so NO LIBRARY IS USED. PROGRAM: define if a program is to be built. If not defined, library maintenance is assumed. (default: defined) RELINK: Defined by default, causing a program to be relinked every time the script is called. Do not define it if relinking should only occur if a source is compiled. No effect for library maintenance. Current values: */ #define COMPILER "g++" // COPT: the set of C-options #define COPT "--std=c++11 -Wall" #define ECHO_REQUEST ON // #define GDB // Extra libraries required. Remove lib and .a from the library names. // E.g., #define LIBS "m Xt" to link libm.a and libXt.a explicitly // Specify libs from the most specific to the most general one. #define LIBS "" // Extra library-paths required. // E.g., #define LIBPATH "/some/path /some/other/path" to search these paths // apart from the default paths #define LIBPATH "" // uncomment if you WANT to use a library #define USE_LIBRARY // #define PROGRAM #define RELINK // DO NOT ALTER THINGS BELOW THIS LINE string // contain options for libs, // extra libs, e.g., "-lrss -licce" libpath, // extra lib-paths, eg, "-L../rss" copt, lopt, libxxxa; // expanded lib-name int relink; // internally used: != 0 to relink string ofiles, // wildcards for o-files sources, // sources to be used wild, // wildcard of extension current; // contains name of current dir. /* O B J F I L E S . I M */ list objfiles(list files) { string file, objfile; int i; for (i = 0; i < sizeof(files); i++) { file = element(i, files); // determine element of the list #ifdef USE_LIBRARY objfile = change_ext(file, "o"); // make obj-filename #else objfile = "./o/" + change_ext(file, "o"); // make obj-filename #endif if (objfile younger file) // objfile is younger { files -= (list)file; // remove the file from the list i--; // reduce i to test the next } } return (files); } /* parser.im */ void parser() { chdir("parser/gramspec"); system("grambuild"); chdir(".."); if ( exists("grammar") && "grammar" younger "parser.cc" ) // new parser needed { exec("bison++", "-d", "-o", "parser.cc", "grammar"); printf("Note: the compilation of parser.cc may produce " "several compiler warnings.\n"); } chdir(".."); } /* scanner.im */ void scanner() { chdir("scanner"); if ( // new lexer needed exists("lexer") && ( "lexer" younger "yylex.cc" || "../parser/parser.h" younger "yylex.cc" ) ) { exec("flex", #ifdef INTERACTIVE "-I", #endif "-oyylex.cc", "lexer"); printf("Note: the compilation of yylex.cc may produce " "several compiler warnings.\n"); } chdir(".."); } /* A L T E R E D . I M */ list altered(list files, string target) { int i; string file; for (i = 0; i < sizeof(files); i++) // try all elements of the list { file = element(i, files); // use element i of the list if (file older target) // a file is older than the target { files -= (list)file; // remove the file from the list i--; // reduce i to inspect the next } // file of the list } return (files); // return the new list } /* F I L E L I S T . I M */ list file_list(string type, string library) { list files; files = makelist(type); // make all files of certain type #ifdef USE_LIBRARY files = altered(files, library); // keep all files newer than lib. #endif files = objfiles(files); // remove if younger .obj exist return (files); } /* L I N K . I M */ void link(string library, string exe) { #ifndef RELINK if ( relink // new library, new main.obj || !exists(exe) // final program doesn't exist ) #endif { printf("\n"); exec(COMPILER, "-o", exe, #ifdef USE_LIBRARY "-l" + library, #else ofiles, #endif libs, "-L.", libpath, lopt #ifndef GDB , "-s" #endif ); printf("ok: ", exe, "\n"); } } /* C C O M P I L E . I M */ void c_compile(list cfiles) { string nextfile; int i; #ifndef USE_LIBRARY if (!exists("o")) system("mkdir o"); #endif if (sizeof(cfiles)) // files to compile ? { printf("\ncompiling: ", current, "\n\n"); // compile all files separately for (i = 0; nextfile = element(i, cfiles); i++) { #ifdef USE_LIBRARY exec(COMPILER, "-c " COPT + " " + copt + " " + nextfile); #else exec(COMPILER, "-c -o o/" + change_ext(nextfile, "o") + " " COPT + " " + copt + " " + nextfile); #endif } relink = 1; printf("\n"); } printf("ok: ", current, "\n"); } /* U P D A T E L I . I M */ void updatelib(string library) { list arlist, objlist; string to, from; objlist = makelist("*.o"); if (!sizeof(objlist)) return; printf("\n"); relink = 1; exec("ar", "rvs", library, "*.o"); exec("rm", "*.o"); printf("\n"); } void prefix_class(string class_id) { list o_files; string o_file; int i; o_files = makelist("*.o"); for (i = 0; o_file = element(i, o_files); i++) exec("mv", o_file, class_id + o_file); } /* S T D C P P . I M */ void std_cpp(string library) { list cfiles; cfiles = file_list(wild, library); // make list of all cpp-files c_compile(cfiles); // compile cpp-files } /* C P P M A K E . C CPP files are processed by stdmake. Arguments of CPPMAKE: cpp_make( string mainfile, : name of the main .cpp file, or "" for library maintenance string library, : name of the local library to use/create (without lib prefix, .a suffix if main is given here, libmain.a is created) string exe, : (path) name of the exe file to create ) Both mainfile and library MUST be in the current directory */ void cpp_make(string mainfile, string library, string exe) { int n, index; list classes; string cwd; #ifdef BISON++ CLASSES += "parser "; if (exists("parser")) // subdir parser exists parser(); #endif #ifdef FLEX++ CLASSES += "scanner "; if (exists("scanner")) // subdir scannerexists scanner(); #endif setClasses(); // remaining classes cwd = chdir("."); ofiles = "o/*.o"; // std set of o-files classes = strtok(CLASSES, " "); // list of classes if (n = sizeof(classes)) ofiles += " */o/*.o"; // set ofiles for no LIBRARY use wild = sources; // make library name libxxxa = chdir(".") + "lib" + library + ".a"; // first process all classes for (index = 0; index < n; index++) { current = element(index, classes); // next class to process chdir(current); // change to directory current = "subdir " + current; std_cpp (libxxxa); // compile all files chdir( cwd); // go back to parent dir } current = "auxiliary " + wild + " files"; std_cpp (libxxxa); // compile all files in current dir for (index = 0; index < n; index++) { current = element(index, classes); // determine class name chdir( current); // chdir to a class directory. #ifdef USE_LIBRARY prefix_class((string)index); // prefix class-number for .o files updatelib(libxxxa); #endif chdir(cwd); // go back to parent dir } current = ""; // no class anymore #ifdef USE_LIBRARY updatelib(libxxxa); // update lib in current dir #endif if (mainfile != "") // mainfile -> do link { link(library, exe); printf ( "\nProgram construction completed.\n" "\n" ); } } /* S E T L I B S . I M */ void setlibs() { int n, index; list cut; cut = strtok(LIBS, " "); // cut op libraries n = sizeof(cut); for (index = 0; index < n; index++) libs += " -l" + element(index, cut); #ifdef FLEX++ libs += " -lfl"; #endif cut = strtok(LIBPATH, " "); // cut up the paths n = sizeof(cut); for (index = 0; index < n; index++) libpath += " -L" + element(index, cut); } void main() { echo(ECHO_REQUEST); sources = "*.cc"; setlibs(); #ifdef GDB copt = "-g"; #endif #ifdef PROGRAM cpp_make ( "fork.cc", // program source "fork", // program library "fork" // binary program ); #else cpp_make ( "", "fork", // program library "" ); #endif } c++-annotations-10.6.0/yo/concrete/fork2/opipe/0000755000175000017500000000000013005340354020052 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/fork2/opipe/opipe.ih0000644000175000017500000000007613005340354021513 0ustar frankfrank#include "opipe.h" using namespace FBB; using namespace std; c++-annotations-10.6.0/yo/concrete/fork2/opipe/opipe.cc0000644000175000017500000000021513005340355021474 0ustar frankfrank#include "opipe.ih" OPipe::OPipe(size_t size) : Pipe(), OFdNStreambuf(Pipe::d_fd[READ], size == 0 ? 1 : size), ostream(this) {} c++-annotations-10.6.0/yo/concrete/fork2/opipe/opipe.h0000644000175000017500000000067413005340355021347 0ustar frankfrank#ifndef INCLUDED_OPIPE_H_ #define INCLUDED_OPIPE_H_ #ifndef INCLUDED_PIPE_H_ #include "../pipe/pipe.h" #endif #ifndef INCLUDED_OFDNSTREAMBUF_H_ #include "../ofdnstreambuf/ofdnstreambuf.h" #endif #ifndef INCLUDED_OSTREAM_ #include #define INCLUDED_OSTREAM_ #endif namespace FBB { class OPipe: public Pipe, private OFdNStreambuf, public std::ostream { public: OPipe(size_t size = 500); }; } #endif c++-annotations-10.6.0/yo/concrete/fork2/ifdnstreambuf/0000755000175000017500000000000013005340354021567 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/fork2/ifdnstreambuf/open.cc0000644000175000017500000000031213005340355023034 0ustar frankfrank#include "ifdnstreambuf.ih" void IFdNStreambuf::open(int fd, size_t n) { d_fd = fd; d_n = (n == 0) ? 1 : n; d_buffer = new char[d_n]; setg(d_buffer, d_buffer + d_n, d_buffer + d_n); } c++-annotations-10.6.0/yo/concrete/fork2/ifdnstreambuf/xsgetn.cc0000644000175000017500000000072013005340355023406 0ustar frankfrank#include "ifdnstreambuf.ih" std::streamsize IFdNStreambuf::xsgetn(char *dest, std::streamsize n) { int nread = 0; while (n) { if (!in_avail()) { if (underflow() == EOF) break; } int avail = in_avail(); if (avail > n) avail = n; memcpy(dest + nread, gptr(), avail); gbump(avail); nread += avail; n -= avail; } return nread; } c++-annotations-10.6.0/yo/concrete/fork2/ifdnstreambuf/ifdnstreambuf.ih0000644000175000017500000000013113005340354024735 0ustar frankfrank#include "ifdnstreambuf.h" #include #include using namespace FBB; c++-annotations-10.6.0/yo/concrete/fork2/ifdnstreambuf/ifdnstreambuf.h0000644000175000017500000000163013005340355024572 0ustar frankfrank#ifndef INCLUDED_IFDNSTREAMBUF_H_ #define INCLUDED_IFDNSTREAMBUF_H_ #ifndef INCLUDED_STREAMBUF_ #include #define INCLUDED_STREAMBUF_ #endif namespace FBB { class IFdNStreambuf: public std::streambuf { private: int d_fd; size_t d_n; char* d_buffer; public: IFdNStreambuf() : d_n(0), d_buffer(0) {} IFdNStreambuf(int fd, size_t n = 1) { open(fd, n); } ~IFdNStreambuf(); void open(int xfd, size_t n = 1); int underflow(); std::streamsize xsgetn(char *dest, std::streamsize n); private: IFdNStreambuf(IFdNStreambuf const &other); // NI IFdNStreambuf &operator=(IFdNStreambuf const &other); // NI }; } #endif c++-annotations-10.6.0/yo/concrete/fork2/ifdnstreambuf/destructor.cc0000644000175000017500000000021513005340355024273 0ustar frankfrank#include "ifdnstreambuf.ih" IFdNStreambuf::~IFdNStreambuf() { if (d_buffer) { close(d_fd); delete d_buffer; } } c++-annotations-10.6.0/yo/concrete/fork2/ifdnstreambuf/underflow.cc0000644000175000017500000000041413005340355024103 0ustar frankfrank#include "ifdnstreambuf.ih" int IFdNStreambuf::underflow() { if (gptr() < egptr()) return *gptr(); int nread = read(d_fd, d_buffer, d_n); if (nread <= 0) return EOF; setg(d_buffer, d_buffer, d_buffer + nread); return *gptr(); } c++-annotations-10.6.0/yo/concrete/fork2/fork/0000755000175000017500000000000013005340354017677 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/fork2/fork/fork.h0000644000175000017500000000136213005340355021014 0ustar frankfrank#ifndef INCLUDED_FORK_H_ #define INCLUDED_FORK_H_ namespace FBB { class Redirector; class ChildProcess; class ParentProcess; class Fork { protected: Redirector &d_redirector; ChildProcess &d_child; ParentProcess &d_parent; public: Fork(Redirector &redirector, ChildProcess &child, ParentProcess &parent) : d_redirector(redirector), d_child(child), d_parent(parent) {} void fork() const; private: Fork(Fork const &other); // NI Fork &operator=(Fork const &other); // NI }; } #endif c++-annotations-10.6.0/yo/concrete/fork2/fork/fork.ih0000644000175000017500000000070313005340354021162 0ustar frankfrank#include "fork.h" #ifndef INCLUDED_CHILDPROCESS_H_ #include "../childprocess/childprocess.h" #endif #ifndef INCLUDED_REDIRECTOR_H_ #include "../redirector/redirector.h" #endif #ifndef INCLUDED_PARENTPROCESS_H_ #include "../parentprocess/parentprocess.h" #endif #ifndef INCLUDED_TYPES_H_ #include #define INCLUDED_TYPES_H_ #endif #ifndef INCLUDED_UNISTD_H_ #include #define INCLUDED_UNISTD_H_ #endif using namespace FBB; c++-annotations-10.6.0/yo/concrete/fork2/fork/forkfork.cc0000644000175000017500000000064413005340355022036 0ustar frankfrank#include "fork.ih" void Fork::fork() const { int pid = ::fork(); if (pid == 0) // childprocess has pid == 0 { d_redirector.childRedirections(); d_child.run(); } d_redirector.parentRedirections(); d_parent.run(pid, d_redirector.readChildCout(), d_redirector.readChildCerr(), d_redirector.writeChildCin()); } c++-annotations-10.6.0/yo/concrete/fork2/childprocess/0000755000175000017500000000000013005340354021420 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/fork2/childprocess/childprocess.ih0000644000175000017500000000017713005340354024431 0ustar frankfrank#include "childprocess.h" #ifndef INCLUDED_CSTDLIB_ #include #define INCLUDED_CSTDLIB_ #endif using namespace FBB; c++-annotations-10.6.0/yo/concrete/fork2/childprocess/run.cc0000644000175000017500000000022013005340355022526 0ustar frankfrank#include "childprocess.ih" void ChildProcess::run() { executeChildProcess(); exit(-1); // doProcess itself should stop } c++-annotations-10.6.0/yo/concrete/fork2/childprocess/childprocess.h0000644000175000017500000000055613005340355024262 0ustar frankfrank#ifndef INCLUDED_CHILDPROCESS_H_ #define INCLUDED_CHILDPROCESS_H_ namespace FBB { class ChildProcess { public: virtual ~ChildProcess() {} void run(); protected: // implemented in derived classes virtual void executeChildProcess() = 0; }; } #endif c++-annotations-10.6.0/yo/concrete/fork2/pipe/0000755000175000017500000000000013005340354017673 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/fork2/pipe/readvia.cc0000644000175000017500000000016513005340355021620 0ustar frankfrank#include "pipe.ih" void Pipe::readVia(int fd) { close(d_fd[WRITE]); dup(READ, fd); close(d_fd[READ]); } c++-annotations-10.6.0/yo/concrete/fork2/pipe/writevia2.cc0000644000175000017500000000027413005340355022122 0ustar frankfrank#include "pipe.ih" void Pipe::writeVia(int const *fd, size_t n) { close(d_fd[READ]); for (size_t idx = 0; idx < n; idx++) dup(WRITE, fd[idx]); close(d_fd[WRITE]); } c++-annotations-10.6.0/yo/concrete/fork2/pipe/pipe.cc0000644000175000017500000000012313005340355021134 0ustar frankfrank#include "pipe.ih" Pipe::Pipe() { if (pipe(d_fd)) throw bad_pipe(); } c++-annotations-10.6.0/yo/concrete/fork2/pipe/pipe.ih0000644000175000017500000000017213005340354021152 0ustar frankfrank#include "pipe.h" #ifndef INCLUDED_UNISTD_H_ #include #define INCLUDED_UNISTD_H_ #endif using namespace FBB; c++-annotations-10.6.0/yo/concrete/fork2/pipe/dup.cc0000644000175000017500000000017213005340355020773 0ustar frankfrank#include "pipe.ih" void Pipe::dup(RW rw, int fd) { if (dup2(d_fd[rw], fd) < 0) throw redirection_failed(); } c++-annotations-10.6.0/yo/concrete/fork2/pipe/writevia.cc0000644000175000017500000000016713005340355022041 0ustar frankfrank#include "pipe.ih" void Pipe::writeVia(int fd) { close(d_fd[READ]); dup(WRITE, fd); close(d_fd[WRITE]); } c++-annotations-10.6.0/yo/concrete/fork2/pipe/readvia2.cc0000644000175000017500000000027213005340355021701 0ustar frankfrank#include "pipe.ih" void Pipe::readVia(int const *fd, size_t n) { close(d_fd[WRITE]); for (size_t idx = 0; idx < n; idx++) dup(READ, fd[idx]); close(d_fd[READ]); } c++-annotations-10.6.0/yo/concrete/fork2/pipe/pipe.h0000644000175000017500000000313513005340355021004 0ustar frankfrank#ifndef INCLUDED_PIPE_H_ #define INCLUDED_PIPE_H_ #include namespace FBB { class Pipe { protected: int d_fd[2]; public: enum bad_pipe {}; enum redirection_failed {}; Pipe(); Pipe(int socket) { d_fd[READ] = socket; d_fd[WRITE] = socket; } Pipe(int const *fd) { d_fd[READ] = fd[READ]; d_fd[WRITE] = fd[WRITE]; } // readVia(): set up redirection from d_fd[READ] to the given // filedescriptor(s): reading from d_fd[READ] // is done via the filedescriptor(s) void readVia(int filedescriptor); // not tested: void readVia(int const *filedescriptor, size_t n); // writeVia(): set up redirection from d_fd[WRITE] to the given // filedescriptor(s): writing to d_fd[WRITE] // is done via the filedescriptor(s) void writeVia(int filedescriptor); void writeVia(int const *filedescriptor, size_t n = 2); int readFd() { return d_fd[READ]; } int writeFd() { return d_fd[WRITE]; } protected: enum RW { READ, WRITE }; private: void dup(RW rw, int fd); Pipe(Pipe const &other); // NI Pipe &operator=(Pipe const &other); // NI }; } #endif c++-annotations-10.6.0/yo/concrete/fork2/pipe/driver/0000755000175000017500000000000013005340354021166 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/fork2/pipe/driver/build0000755000175000017500000003021712745054222022224 0ustar frankfrank#!/usr/bin/icmake -qt/tmp/driver // script generated by the C++ icmake script version 1.62 /* Configurable defines for the build script: CLASSES: string of directory-names under which sources of classes are found. E.g., CLASSES = "class1 class2" All class-names must be stored in one string. If classes are removed from the CLASSES definition or if the names in the CLASSES definition are reordered, the compilation should start again from scratch. */ string CLASSES; void setClasses() { // ADD ADDITIONAL DIRECTORIES CONTAINING SOURCES OF CLASSES HERE // Use the construction `CLASSES += "classname1 classname2";' etc. CLASSES += " "; } /* COMPILER: "g++" for C++ sources. Do not change this, unless you're sure you want something else. COPT: C-options used by COMPILER ECHO_REQUEST: ON (default) if command echoing is wanted, otherwise: set to OFF GDB: define if gdb-symbolic debug information is wanted (not defined by default) LIBS: Extra libraries used for linking LIBPATH: Extra library-searchpaths used for linking USE_LIBRARY: define this if you want a library for the object modules. Undefined by default: so NO LIBRARY IS USED. PROGRAM: define if a program is to be built. If not defined, library maintenance is assumed. (default: defined) RELINK: Defined by default, causing a program to be relinked every time the script is called. Do not define it if relinking should only occur if a source is compiled. No effect for library maintenance. Current values: */ #define COMPILER "g++" // COPT: the set of C-options #define COPT "--std=c++11 -Wall" #define ECHO_REQUEST ON // #define GDB // Extra libraries required. Remove lib and .a from the library names. // E.g., #define LIBS "m Xt" to link libm.a and libXt.a explicitly // Specify libs from the most specific to the most general one. #define LIBS "fork" // Extra library-paths required. // E.g., #define LIBPATH "/some/path /some/other/path" to search these paths // apart from the default paths #define LIBPATH "../.." // uncomment if you WANT to use a library // #define USE_LIBRARY #define PROGRAM #define RELINK // DO NOT ALTER THINGS BELOW THIS LINE string // contain options for libs, // extra libs, e.g., "-lrss -licce" libpath, // extra lib-paths, eg, "-L../rss" copt, lopt, libxxxa; // expanded lib-name int relink; // internally used: != 0 to relink string ofiles, // wildcards for o-files sources, // sources to be used wild, // wildcard of extension current; // contains name of current dir. /* O B J F I L E S . I M */ list objfiles(list files) { string file, objfile; int i; for (i = 0; i < sizeof(files); i++) { file = element(i, files); // determine element of the list #ifdef USE_LIBRARY objfile = change_ext(file, "o"); // make obj-filename #else objfile = "./o/" + change_ext(file, "o"); // make obj-filename #endif if (objfile younger file) // objfile is younger { files -= (list)file; // remove the file from the list i--; // reduce i to test the next } } return (files); } /* parser.im */ void parser() { chdir("parser/gramspec"); system("grambuild"); chdir(".."); if ( exists("grammar") && "grammar" younger "parser.cc" ) // new parser needed { exec("bison++", "-d", "-o", "parser.cc", "grammar"); printf("Note: the compilation of parser.cc may produce " "several compiler warnings.\n"); } chdir(".."); } /* scanner.im */ void scanner() { chdir("scanner"); if ( // new lexer needed exists("lexer") && ( "lexer" younger "yylex.cc" || "../parser/parser.h" younger "yylex.cc" ) ) { exec("flex", #ifdef INTERACTIVE "-I", #endif "-oyylex.cc", "lexer"); printf("Note: the compilation of yylex.cc may produce " "several compiler warnings.\n"); } chdir(".."); } /* A L T E R E D . I M */ list altered(list files, string target) { int i; string file; for (i = 0; i < sizeof(files); i++) // try all elements of the list { file = element(i, files); // use element i of the list if (file older target) // a file is older than the target { files -= (list)file; // remove the file from the list i--; // reduce i to inspect the next } // file of the list } return (files); // return the new list } /* F I L E L I S T . I M */ list file_list(string type, string library) { list files; files = makelist(type); // make all files of certain type #ifdef USE_LIBRARY files = altered(files, library); // keep all files newer than lib. #endif files = objfiles(files); // remove if younger .obj exist return (files); } /* L I N K . I M */ void link(string library, string exe) { #ifndef RELINK if ( relink // new library, new main.obj || !exists(exe) // final program doesn't exist ) #endif { printf("\n"); exec(COMPILER, "-o", exe, #ifdef USE_LIBRARY "-l" + library, #else ofiles, #endif libs, "-L.", libpath, lopt #ifndef GDB , "-s" #endif ); printf("ok: ", exe, "\n"); } } /* C C O M P I L E . I M */ void c_compile(list cfiles) { string nextfile; int i; #ifndef USE_LIBRARY if (!exists("o")) system("mkdir o"); #endif if (sizeof(cfiles)) // files to compile ? { printf("\ncompiling: ", current, "\n\n"); // compile all files separately for (i = 0; nextfile = element(i, cfiles); i++) { #ifdef USE_LIBRARY exec(COMPILER, "-c " COPT + " " + copt + " " + nextfile); #else exec(COMPILER, "-c -o o/" + change_ext(nextfile, "o") + " " COPT + " " + copt + " " + nextfile); #endif } relink = 1; printf("\n"); } printf("ok: ", current, "\n"); } /* U P D A T E L I . I M */ void updatelib(string library) { list arlist, objlist; string to, from; objlist = makelist("*.o"); if (!sizeof(objlist)) return; printf("\n"); relink = 1; exec("ar", "rvs", library, "*.o"); exec("rm", "*.o"); printf("\n"); } void prefix_class(string class_id) { list o_files; string o_file; int i; o_files = makelist("*.o"); for (i = 0; o_file = element(i, o_files); i++) exec("mv", o_file, class_id + o_file); } /* S T D C P P . I M */ void std_cpp(string library) { list cfiles; cfiles = file_list(wild, library); // make list of all cpp-files c_compile(cfiles); // compile cpp-files } /* C P P M A K E . C CPP files are processed by stdmake. Arguments of CPPMAKE: cpp_make( string mainfile, : name of the main .cpp file, or "" for library maintenance string library, : name of the local library to use/create (without lib prefix, .a suffix if main is given here, libmain.a is created) string exe, : (path) name of the exe file to create ) Both mainfile and library MUST be in the current directory */ void cpp_make(string mainfile, string library, string exe) { int n, index; list classes; string cwd; #ifdef BISON++ CLASSES += "parser "; if (exists("parser")) // subdir parser exists parser(); #endif #ifdef FLEX++ CLASSES += "scanner "; if (exists("scanner")) // subdir scannerexists scanner(); #endif setClasses(); // remaining classes cwd = chdir("."); ofiles = "o/*.o"; // std set of o-files classes = strtok(CLASSES, " "); // list of classes if (n = sizeof(classes)) ofiles += " */o/*.o"; // set ofiles for no LIBRARY use wild = sources; // make library name libxxxa = chdir(".") + "lib" + library + ".a"; // first process all classes for (index = 0; index < n; index++) { current = element(index, classes); // next class to process chdir(current); // change to directory current = "subdir " + current; std_cpp (libxxxa); // compile all files chdir( cwd); // go back to parent dir } current = "auxiliary " + wild + " files"; std_cpp (libxxxa); // compile all files in current dir for (index = 0; index < n; index++) { current = element(index, classes); // determine class name chdir( current); // chdir to a class directory. #ifdef USE_LIBRARY prefix_class((string)index); // prefix class-number for .o files updatelib(libxxxa); #endif chdir(cwd); // go back to parent dir } current = ""; // no class anymore #ifdef USE_LIBRARY updatelib(libxxxa); // update lib in current dir #endif if (mainfile != "") // mainfile -> do link { link(library, exe); printf ( "\nProgram construction completed.\n" "\n" ); } } /* S E T L I B S . I M */ void setlibs() { int n, index; list cut; cut = strtok(LIBS, " "); // cut op libraries n = sizeof(cut); for (index = 0; index < n; index++) libs += " -l" + element(index, cut); #ifdef FLEX++ libs += " -lfl"; #endif cut = strtok(LIBPATH, " "); // cut up the paths n = sizeof(cut); for (index = 0; index < n; index++) libpath += " -L" + element(index, cut); } void main() { echo(ECHO_REQUEST); sources = "*.cc"; setlibs(); #ifdef GDB copt = "-g"; #endif #ifdef PROGRAM cpp_make ( "driver.cc", // program source "driver", // program library "driver" // binary program ); #else cpp_make ( "", "driver", // program library "" ); #endif } c++-annotations-10.6.0/yo/concrete/fork2/pipe/driver/driver.cc0000644000175000017500000000174713005340355023002 0ustar frankfrank/* driver.cc */ #include "../pipe.h" #include #include #include #include #include using namespace std; using namespace FBB; int main(int argc, char **argv) { Pipe p; // construct a pipe cout << "Read file descriptor: " << p.readFd() << '\n'; cout << "Write file descriptor: " << p.writeFd() << '\n'; int pid = fork(); if (pid == -1) return 1; if (!pid) //child { p.readVia(STDIN_FILENO); // read what goes into the pipe from cin string s; getline(cin, s); cout << "Got: " << s << '\n'; getline(cin, s); cout << "Got: " << s << '\n'; return 0; } int stdfd[] = {STDOUT_FILENO, STDERR_FILENO}; p.writeVia(stdfd); // write to the pipe via cout cout << "first line" << '\n'; cerr << "second line" << '\n'; waitpid(pid, 0, 0); } c++-annotations-10.6.0/yo/concrete/fork2/pipe/driver/driver.h0000644000175000017500000000053113005340355022632 0ustar frankfrank// driver.h #ifndef H_driver_ #define H_driver_ /* $Id: driver.h 2 2003-05-27 19:11:03Z frank $ $Log$ Revision 1.1 2003/05/27 19:11:04 frank Initial revision */ //#include //#include //#include //#include //#include //using namespace std; #endif c++-annotations-10.6.0/yo/concrete/fork2/ofdnstreambuf/0000755000175000017500000000000013005340354021575 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/fork2/ofdnstreambuf/ofdnstreambuf.ih0000644000175000017500000000013113005340354024751 0ustar frankfrank#include "ofdnstreambuf.h" #include #include using namespace FBB; c++-annotations-10.6.0/yo/concrete/fork2/ofdnstreambuf/overflow.cc0000644000175000017500000000024313005340355023747 0ustar frankfrank#include "ofdnstreambuf.ih" int OFdNStreambuf::overflow(int c) { sync(); if (c != EOF) { *pptr() = c; pbump(1); } return c; } c++-annotations-10.6.0/yo/concrete/fork2/ofdnstreambuf/open.cc0000644000175000017500000000027213005340355023047 0ustar frankfrank#include "ofdnstreambuf.ih" void OFdNStreambuf::open(int fd, size_t n) { d_fd = fd; d_n = (n == 0) ? 1 : n; d_buffer = new char[d_n]; setp(d_buffer, d_buffer + d_n); } c++-annotations-10.6.0/yo/concrete/fork2/ofdnstreambuf/sync.cc0000644000175000017500000000031013005340355023053 0ustar frankfrank#include "ofdnstreambuf.ih" int OFdNStreambuf::sync() { if (pptr() > pbase()) { write(d_fd, d_buffer, pptr() - pbase()); setp(d_buffer, d_buffer + d_n); } return 0; } c++-annotations-10.6.0/yo/concrete/fork2/ofdnstreambuf/destructor.cc0000644000175000017500000000021013005340355024274 0ustar frankfrank#include "ofdnstreambuf.ih" OFdNStreambuf::~OFdNStreambuf() { if (d_buffer) { sync(); delete d_buffer; } } c++-annotations-10.6.0/yo/concrete/fork2/ofdnstreambuf/ofdnstreambuf.h0000644000175000017500000000156013005340355024610 0ustar frankfrank#ifndef INCLUDED_OFDNSTREAMBUF_H_ #define INCLUDED_OFDNSTREAMBUF_H_ #ifndef INCLUDED_STREAMBUF_ #include #define INCLUDED_STREAMBUF_ #endif namespace FBB { class OFdNStreambuf: public std::streambuf { private: size_t d_n; int d_fd; char *d_buffer; public: OFdNStreambuf() : d_n(0), d_buffer(0) {} OFdNStreambuf(int fd, size_t n = 1) { open(fd, n); } ~OFdNStreambuf(); void open(int fd, size_t n = 1); int sync(); int overflow(int c); private: OFdNStreambuf(OFdNStreambuf const &other); // NI OFdNStreambuf &operator=(OFdNStreambuf const &other); // NI }; } #endif c++-annotations-10.6.0/yo/concrete/fork2/cinredirector/0000755000175000017500000000000013005340354021572 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/fork2/cinredirector/cinredirector.h0000644000175000017500000000106013005340355024575 0ustar frankfrank#ifndef INCLUDED_CINREDIRECTOR_H_ #define INCLUDED_CINREDIRECTOR_H_ #ifndef INCLUDED_REDIRECTOR_H_ #include "../redirector/redirector.h" #endif #ifndef INCLUDED_OPIPE_H_ #include "../opipe/opipe.h" #endif namespace FBB { class CinRedirector: public Redirector { private: OPipe d_cinPipe; public: virtual void childRedirections(); virtual void parentRedirections(); virtual std::ostream &writeChildCin() { return d_cinPipe; } }; } #endif c++-annotations-10.6.0/yo/concrete/fork2/cinredirector/childredirections.cc0000644000175000017500000000023113005340355025574 0ustar frankfrank#include "cinredirector.ih" void CinRedirector::childRedirections() { // redirect STDIN_FILENO to the pipe: d_cinPipe.readVia(STDIN_FILENO); } c++-annotations-10.6.0/yo/concrete/fork2/cinredirector/parentredirections.cc0000644000175000017500000000015113005340355026003 0ustar frankfrank#include "cinredirector.ih" void CinRedirector::parentRedirections() { close(d_cinPipe.readFd()); } c++-annotations-10.6.0/yo/concrete/fork2/cinredirector/cinredirector.ih0000644000175000017500000000020313005340354024743 0ustar frankfrank#include "cinredirector.h" #ifndef INCLUDED_UNISTD_H_ #include #define INCLUDED_UNISTD_H_ #endif using namespace FBB; c++-annotations-10.6.0/yo/concrete/fork2/redirector/0000755000175000017500000000000013005340353021077 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/fork2/redirector/redirector.h0000644000175000017500000000174213005340355023420 0ustar frankfrank#ifndef INCLUDED_REDIRECTOR_H_ #define INCLUDED_REDIRECTOR_H_ #ifndef INCLUDED_IOSFWD_ #include #define INCLUDED_IOSFWD_ #endif #ifndef INCLUDED_IOSTREAM_ #include #define INCLUDED_IOSTREAM_ #endif namespace FBB { class Redirector { public: enum { READ, WRITE }; virtual ~Redirector() {} // sets up redirections in the child virtual void childRedirections() {} // sets up redirections in the parent virtual void parentRedirections() {} virtual std::ostream &writeChildCin() { return std::cout; } virtual std::istream &readChildCout() { return std::cin; } virtual std::istream &readChildCerr() { return std::cin; } }; } #endif c++-annotations-10.6.0/yo/concrete/fork2/ipipe/0000755000175000017500000000000013005340353020043 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/fork2/ipipe/ipipe.h0000644000175000017500000000150513005340355021325 0ustar frankfrank#ifndef INCLUDED_IPIPE_H_ #define INCLUDED_IPIPE_H_ #ifndef INCLUDED_PIPE_H_ #include "../pipe/pipe.h" #endif #ifndef INCLUDED_ISTREAM_ #include #define INCLUDED_ISTREAM_ #endif namespace FBB { class IPipe: virtual public Pipe { private: IfdNstreambuf d_ibuf; std::istream d_istr; public: IPipe(size_t size = 500) : Pipe(socket), d_ibuf(d_fd[READ], size == 0 ? 1 : size), d_istr(&d_ibuf) {} IPipe(int socket, size_t size) : Pipe(socket), d_ibuf(d_fd[READ], size == 0 ? 1 : size), d_istr(&d_ibuf) {} istream &istream() { return d_istr; } }; } #endif c++-annotations-10.6.0/yo/concrete/ranger.yo0000644000175000017500000001154012745054222017551 0ustar frankfrankThe standard i(range-based for-loop) requires for its range-specificiation an array, an initializer list, or an iterator range as offered by, e.g., containers (through their tt(begin) and tt(end) members). Ranges defined by a pointer pair or by a subrange defined by iterator expressions cannot currently be used in combination with range-based for-loops. The ti(Ranger) class template developed in this section defines ranges that can be used with range-based for-loops. tt(Ranger) extends the applicability of range-based for-loops by turning pointer pairs,, an initial pointer or iterator and a pointer count, or a pair of iterators into a range that can be used by range-based for-loops. The tt(Ranger) class template can also be used to process a pair of reverse iterators, normally not supported by range-based for-loops. The tt(Ranger) class template requires but one template type parameter: tt(Iterator), representing an iterator or pointer type reaching the data when dereferenced. In practical applications users don't have to specify tt(Ranger)'s template type. The function template tt(ranger) deduces the required tt(Iterator) type and returns the appropriate tt(Ranger) object. The tt(ranger) function template can be used in various ways: itemization( itt(Ranger ranger(Iterator const &begin, Iterator const &end)) this function template returns a tt(Ranger) object for the (sub)range defined by two (reverse) iterators. Its definition is: verb( template Ranger ranger(Iter &&begin, Iter &&end) { return Ranger(begin, end); } ) itt(Ranger ranger(Iterator const &begin, size_t count)) this function template returns a tt(Ranger) object for the (sub)range defined by the (reverse) iterator range tt(begin) and tt(begin + count). Its definition is: verb( template Ranger ranger(Data *begin, Data *end) { return Ranger(begin, end); } ) itt(Ranger ranger(Data *begin, Data *end)) this function template returns a tt(Ranger) object for the (sub)range defined by the two pointers tt(begin) and tt(end). Its definition is: verb( template Ranger ranger(Iter &&begin, size_t count) { return Ranger(begin, begin + count); } ) itt(Ranger ranger(Data *begin, size_t count)) this function template returns a tt(Ranger) object for the (sub)range defined by the two pointers tt(begin) and tt(begin + count). Its definition is: verb( template Ranger ranger(Data *begin, size_t count) { return Ranger(begin, begin + count); } ) ) The tt(Ranger) class template itself offers a constructor expecting two tt(Iterator const &) parameters, where tt(Iterator) is tt(Ranger)'s template type parameter. Although named 'Iterator' it can also be a pointer to some data type (e.g., tt(std::string *)). The class only needs two members, tt(begin) and tt(end), since these are the only members called by range-based for-loops. These members can be tt(const) members, returning tt(Iterator const) references. This also is the required return type if tt(Iterator) itself was a pointer type (like tt(int *)). Since a `tt(Iterator const &)' does not imply that the dereferenced tt(Iterator) is immutable, the data to which the iterator returned by tt(begin()) can actually be modified, if tt(Iterator) unless tt(Iterator) is a tt(Type const *) or a tt(const_iterator) type. If reverse iterators are passed to tt(Ranger)'s constructor (the reversed begin iterator should be passed as tt(Ranger) constructor's first argument, the reversed end iterator as its second argument), then tt(Ranger)'s tt(begin) and tt(end) members return em(reverse iterators). Since the intended use of tt(Ranger) objects is to define a range for range-base for-loops, members like tt(rbegin) and tt(rend) were omitted from tt(Ranger)'s interface. Here is tt(Ranger)'s implementation (using in-class implementations for brevity): verb( template class Ranger { Iter d_begin; Iter d_end; public: Ranger(Iter const &begin, Iter const &end) : d_begin(begin), d_end(end) {} Iter const &begin() const { return d_begin; } Iter const &end() const { return d_end; } }; ) Using tt(ranger) is easy. Here is an example of a program displaying a program's command-line arguments using a range-based for-loop: verb( // insert all required declarations here int main(int argc, char **argv) { for (auto ptr: ranger(argv, argc)) cout << ptr << '\n'; } ) c++-annotations-10.6.0/yo/concrete/pipes.yo0000644000175000017500000001073412745054222017417 0ustar frankfrank Redirection at the system level requires the use of emi(file descriptors), created by the ti(pipe) system call. When two processes want to communicate using such file descriptors, the following happens: itemization( it() The process constructs two em(associated file descriptors) using the tt(pipe) system call. One of the file descriptors is used for writing, the other file descriptor is used for reading. it() Forking takes place (i.e., the system tt(fork) function is called), duplicating the file descriptors. Now we have four file descriptors as the child process and the parent process both have their own copies of the two file descriptors created by tt(pipe). it() One process (say, the parent process) uses the file descriptors for em(reading). It should close its file descriptor intended for em(writing). it() The other process (say, the child process) uses the file descriptors for em(writing). It should therefore close its file descriptor intended for em(reading). it() All information written by the child process to the file descriptor intended for writing, can now be read by the parent process from the corresponding file descriptor intended for reading, thus establishing a communication channel between the child and the parent process. ) Though basically simple, errors may easily creep in. Functions of file descriptors available to the two processes (child or parent) may easily get mixed up. To prevent bookkeeping errors, the bookkeeping may be properly set up once, to be hidden thereafter inside a class like the tt(Pipe) class developed here. Let's have a look at its characteristics (before using functions like tt(pipe) and tt(dup) the compiler must have read the tthi(unistd.h) header file): itemization( it() The tt(pipe) system call expects a pointer to two tt(int) values, representing, respectively, the file descriptor used for reading and the file descriptor used for writing. To avoid confusion, the class tt(Pipe) defines an tt(enum) having values associating the indices of the array of 2-tt(int)s with symbolic constants. The two file descriptors themselves are stored in a data member tt(d_fd). Here is the initial section of the class's interface: verbinclude(//HEAD examples/pipe.h) it() The class only needs a default constructor. This constructor calls tt(pipe) to create a set of associated file descriptors used for accessing both ends of a pipe: verbinclude(//CONS examples/pipe.cc) it() The members tt(readOnly) and tt(readFrom) are used to configure the pipe's reading end. The latter function is used when using redirection. It is provided with an alternate file descriptor to be used for reading from the pipe. Usually this alternate file descriptor is ti(STDIN_FILENO), allowing tt(cin) to extract information from the pipe. The former function is merely used to configure the reading end of the pipe. It closes the matching writing end and returns a file descriptor that can be used to read from the pipe: verbinclude(//READ examples/pipe.cc) it() tt(writeOnly) and two tt(writtenBy) members are available to configure the writing end of a pipe. The former function is only used to configure the writing end of the pipe. It closes the reading end, and returns a file descriptor that can be used for writing to the pipe: verbinclude(//WRITE examples/pipe.cc) For the latter member two overloaded versions are available: itemization( itt(writtenBy(int fd)) is used to configure em(single) redirection, so that a specific file descriptor (usually ti(STDOUT_FILENO) or ti(STDERR_FILENO)) can be used to write to the pipe; itt((writtenBy(int const *fd, size_t n))) may be used to configure em(multiple) redirection, providing an array argument containing file descriptors. Information written to any of these file descriptors is actually written to the pipe. ) it() The class has one private data member, tt(redirect), used to set up redirection through the ti(dup2) system call. This function expects two file descriptors. The first file descriptor represents a file descriptor that can be used to access the device's information; the second file descriptor is an alternate file descriptor that may also be used to access the device's information. Here is tt(redirect)'s implementation: verbinclude(//REDIRECT examples/pipe.cc) ) Now that redirection can be configured easily using one or more tt(Pipe) objects, we'll use tt(Fork) and tt(Pipe) in various example programs. c++-annotations-10.6.0/yo/concrete/usingbison.yo0000644000175000017500000000506512745054222020460 0ustar frankfrankOnce an i(input language) exceeds a certain level of complexity, a emi(parser) is often used to control the complexity of the language. In this case, a emi(parser generator) can be used to generate the code verifying the input's grammatical correctness. The lexical scanner (preferably composed into the parser) provides chunks of the input, called hi(token)em(tokens). The parser then processes the series of tokens generated by the lexical scanner. Starting point when developing programs that use both parsers and scanners is the i(grammar). The grammar defines a em(set of tokens) that can be returned by the lexical scanner (called the emi(scanner) below). Finally, auxiliary code is provided to `fill in the blanks': the i(actions) performed by the parser and by the scanner are not normally specified literally in the grammar rules or lexical regular expressions, but should be implemented in em(member functions), called from the parser's rules or which are associated with the scanner's regular expressions. In the previous section we've seen an example of a bf(C++) class generated by ti(flexc++). In the current section we concentrate on the parser. The parser can be generated from a grammar specification file, processed by the program ti(bisonc++). The grammar specification file required by tt(bisonc++) is similar to the file processed by ti(bison) (or ti(bison++), tt(bisonc++)'s predecessor, written in the early nineties by hi(Coetmeur, A.) em(Alain Coetmeur)). In this section a program is developed converting em(infix expressions), where binary operators are written between their operands, to em(postfix expressions), where operators are written behind their operands. Also, the unary operator tt(-) is converted from its prefix notation to a postfix form. The unary tt(+) operator is ignored as it requires no further actions. In essence our little calculator is a micro compiler, transforming numeric expressions into assembly-like instructions. Our calculator recognizes a rather basic set of operators: multiplication, addition, parentheses, and the unary minus. We'll distinguish real numbers from integers, to illustrate a subtlety in bison-like grammar specifications. That's all. The purpose of this section is, after all, to illustrate the construction of a bf(C++) program that uses both a parser and a lexical scanner, rather than to construct a full-fledged calculator. In the coming sections we'll develop the grammar specification for tt(bisonc++). Then, the regular expressions for the scanner are specified. Following that, the final program is constructed. c++-annotations-10.6.0/yo/concrete/children.yo0000644000175000017500000000236012745054221020062 0ustar frankfrank The next step up the ladder is the construction of a child-process monitor. Here, the parent process is responsible for all its child processes, but it also must read their standard output. The user enters information at the standard input of the parent process. A simple emi(command language) is used for this: itemization( itt(start): this starts a new child process. The parent returns the child's ID (a number) to the user. The ID is thereupon be used to identify a particular child process; itt( text) sends ``tt(text)'' to the child process having ID tt(); itt(stop ) terminates the child process having ID tt(); itt(exit) terminates the parent as well as all its child processes. ) If a child process hasn't received text for some time it will complain by sending a message to the parent-process. Those messages are simply transmitted to the user by copying them to the standard output stream. A problem with programs like our monitor is that they allow emi(asynchronous input) from multiple sources. Input may appear at the standard input as well as at the input-sides of pipes. Also, multiple output channels are used. To handle situations like these, the ti(select) system call was developed. c++-annotations-10.6.0/yo/concrete/selectimpl.yo0000644000175000017500000001057612745054222020444 0ustar frankfrank Selector's member functions serve the following tasks: itemization( itht(Selector)(Selector()): the (default) constructor. It clears the read, write, and execute tt(fd_set) variables, and switches off the alarm. Except for tt(d_max), the remaining data members do not require specific initializations: verbinclude(//SELECTOR examples/selector.cc) itht(wait)(int wait()): this member em(blocks) until the em(alarm) times out or until activity is sensed at any of the file descriptors monitored by the tt(Selector) object. It throws an exception when the tt(select) system call itself fails: verbinclude(//WAIT examples/selector.cc) itht(nReady)(int nReady): this member function's return value is only defined when tt(wait) has returned. In that case it returns 0 for an alarm-timeout, -1 if tt(select) failed, and otherwise the number of file descriptors on which activity was sensed: verbinclude(//NREADY examples/selector.h) itht(readFd)(int readFd()): this member function's return value is also only defined after tt(wait) has returned. Its return value is -1 if no (more) input file descriptors are available. Otherwise the next file descriptor available for reading is returned: verbinclude(//READFD examples/selector.h) itht(writeFd)(int writeFd()): operating analogously to tt(readFd), it returns the next file descriptor to which output is written. It uses tt(d_writeidx) and tt(d_ret_read) and is implemented analogously to tt(readFd); itht(exceptFd)(int exceptFd()): operating analogously to tt(readFd), it returns the next exception file descriptor on which activity was sensed. It uses tt(d_except_idx) and tt(d_ret_except) and is implemented analogously to tt(readFd); itht(setAlarm)(void setAlarm(int sec, int usec = 0)): this member activates tt(Select)'s alarm facility. At least the number of seconds to wait for the alarm to go off must be specified. It simply assigns values to tt(d_alarm)'s fields. At the next tt(Select::wait) call, the alarm fires (i.e., tt(wait) returns with return value 0) once the configured alarm-interval has passed: verbinclude(//SETALARM examples/selector.h) itht(noAlarm)(void noAlarm()): this member switches off the alarm, by simply setting the alarm interval to a very long period: verbinclude(//NOALARM examples/selector.h) itht(addReadFd)(void addReadFd(int fd)): this member adds a file descriptor to the set of input file descriptors monitored by the tt(Selector) object. The member function tt(wait) returns once input is available at the indicated file descriptor: verbinclude(//ADDREAD examples/selector.h) itht(addWriteFd)(void addWriteFd(int fd)): this member adds a file descriptor to the set of output file descriptors monitored by the tt(Selector) object. The member function tt(wait) returns once output is available at the indicated file descriptor. Using tt(d_write), it is implemented analogously to tt(addReadFd); itht(addExceptFd)(void addExceptFd(int fd)): this member adds a file descriptor to the set of exception file descriptors to be monitored by the tt(Selector) object. The member function tt(wait) returns once activity is sensed at the indicated file descriptor. Using tt(d_except), it is implemented analogously to tt(addReadFd); itht(rmReadFd)(void rmReadFd(int fd)): this member removes a file descriptor from the set of input file descriptors monitored by the tt(Selector) object: verbinclude(//RMREAD examples/selector.h) itht(rmWriteFd)(void rmWriteFd(int fd)): this member removes a file descriptor from the set of output file descriptors monitored by the tt(Selector) object. Using tt(d_write), it is implemented analogously to tt(rmReadFd); itht(rmExceptFd)(void rmExceptFd(int fd)): this member removes a file descriptor from the set of exception file descriptors to be monitored by the tt(Selector) object. Using tt(d_except), it is implemented analogously to tt(rmReadFd); ) The class's remaining (two) members are support members, and should not be used by non-member functions. Therefore, they are declared in the class's tt(private) section: itemization( it() The member tt(addFd) adds a file descriptor to a tt(fd_set): verbinclude(//ADDFD examples/selector.cc) it() The member tt(checkSet) tests whether a file descriptor (tt(*index)) is found in a tt(fd_set): verbinclude(//CHECKSET examples/selector.cc) ) c++-annotations-10.6.0/yo/concrete/bisonflex.yo0000644000175000017500000001055712745054221020272 0ustar frankfrank The example discussed below digs into the peculiarities of using i(parser)- and i(scanner) generators generating bf(C++) sources. Once the input for a program exceeds a certain level of complexity, it becomes attractive to use scanner- and parser-generators generating the code which does the actual input recognition. The examples in this and subsequent sections assume that the reader knows how to use the i(scanner generator) ti(flex) and the i(parser generator) ti(bison). Both tt(bison) and tt(flex) are well documented elsewhere. The original predecessors of tt(bison) and tt(flex), called ti(yacc) and ti(lex) are described in several books, e.g. in hi(http://www.oreilly.com/catalog/lex) O'Reilly's book url(`lex & yacc')(http://www.oreilly.com/catalog/lex). Scanner- and parser generators are also available as free software. Both tt(bison) and tt(flex) are usually part of software distributions or they can be obtained from hi(ftp::/prep.ai.mit.edu/pub/non-gnu) tlurl(ftp://prep.ai.mit.edu/pub/non-gnu). tt(Flex) creates a tt(C++) class when ti(%option c++) is specified. For parser generators the program ti(bison) is available. In the early 90's em(Alain Coetmeur) (url(coetmeur@icdc.fr)(mailto:coetmeur@icdc.fr)) created a bf(C++) variant (ti(bison++)) creating a parser class. Although the tt(bison++) program produces code that can be used in bf(C++) programs it also shows many characteristics that are more suggestive of a bf(C) context than a bf(C++) context. In January 2005 I rewrote parts of Alain's tt(bison++) program, resulting in the original version of the program hi(bisonc++) bf(bisonc++). Then, in May 2005 a complete rewrite of the tt(bisonc++) parser generator was completed (version number 0.98). Current versions of tt(bisonc++) can be downloaded from tlurl(http://bisoncpp.sourceforge.net/), where it is available as source archive and as binary (i386) url(Debian)(http://www.debian.org) package (including tt(bisonc++)'s documentation). tt(Bisonc++) creates a cleaner parser class than tt(bison++). In particular, it derives the parser class from a base-class, containing the parser's token- and type-definitions as well as all member functions which should not be (re)defined by the programmer. As a result of this approach, the generated parser class is very small, declaring only members that are actually defined by the programmer (as well as some other members, generated by tt(bisonc++) itself, implementing the parser's ti(parse()) member). One member that is em(not) implemented by default is tt(lex), producing the next lexical token. When the directive tt(%scanner) (see section ref(BISONDEF)) is used, tt(bisonc++) produces a standard implementation for this member; otherwise it must be implemented by the programmer. In early 2012 the program hi(flexc++) bf(flexc++) tlurl(http://flexcpp.org/) reached its initial release. Like tt(bisonc++) it is part of the url(Debian linux distribution)(http://www.debian.org). Jean-Paul van Oosten (email(j.p.van.oosten@rug.nl)) and Richard Berendsen (email(richardberendsen@xs4all.nl)) started the tt(flexc++) project in 2008 and the final program was completed by Jean-Paul and me between 2010 and 2012. These sections of the annotations() focus on tt(bisonc++) as our emi(parser generator) and tt(flexc++) as our lexical scanner generator. Previous releases of the annotations() were using tt(flex) as the scanner generator. Using tt(flex++) and tt(bisonc++) tt(class)-based scanners and parsers are generated. The advantage of this approach is that the interface to the scanner and the parser tends to become cleaner than without using tt(class) interfaces. Furthermore, classes allow us to get rid of most if not all global variables, making it easy to use multiple parsers in one program. Below two example programs are developed. The first example only uses tt(flexc++). The generated scanner monitors the production of a file from several parts. That example focuses on the lexical scanner and on switching files while churning through the information. The second example uses both tt(flexc++) and tt(bisonc++) to generate a scanner and a parser transforming standard arithmetic expressions to their postfix notations, commonly used in code generated by compilers and in tt(HP)-calculators. In the second example the emphasis is mainly on tt(bisonc++) and on composing a scanner object inside a generated parser. c++-annotations-10.6.0/yo/concrete/parentslurp.yo0000644000175000017500000000570412745054222020657 0ustar frankfrank The class ti(ParentSlurp), derived from tt(Fork), starts a child process executing a stand-alone program (like tt(/bin/ls)). The (standard) output of the executed program is not shown on the screen but is read by the parent process. For demonstration purposes the parent process writes the lines it receives to its standard output stream, prepending linenumbers to the lines. It is attractive to redirect the parent's standard em(input) stream to allow the parent to read the em(output) from the child process using its tt(std::cin) em(input) stream. Therefore, the only pipe in the program is used as an em(input) pipe for the parent, and an em(output) pipe for the child. The class tt(ParentSlurp) has the following characteristics: itemization( it() It is derived from tt(Fork). Before starting tt(ParentSlurp)'s class interface, the compiler must have read tt(fork.h) and tt(pipe.h). The class only uses one data member, a tt(Pipe) object tt(d_pipe). it() As tt(Pipe)'s constructor already defines a pipe, and as tt(d_pipe) is automatically initialized by tt(ParentSlurp)'s default constructor, which is implicitly provided, all additional members only exist for tt(ParentSlurp)'s own benefit so they can be defined in the class's (implicit) tt(private) section. Here is the class's interface: verbinclude(//CLASS examples/parentslurp.h) it() The tt(childRedirections) member configures the writing end of the pipe. So, all information written to the child's standard output stream ends up in the pipe. The big advantage of this is that no additional streams are needed to write to a file descriptor: verbinclude(//CHILDREDIR examples/parentslurp.h) it() The tt(parentRedirections) member, configures the reading end of the pipe. It does so by connecting the reading end of the pipe to the parent's standard input file descriptor (tt(STDIN_FILENO)). This allows the parent to perform extractions from tt(cin), not requiring any additional streams for reading. verbinclude(//PARENTREDIR examples/parentslurp.h) it() The tt(childProcess) member only needs to concentrate on its own actions. As it only needs to execute a program (writing information to its standard output), the member can consist of one single statement: verbinclude(//CHILDPROC examples/parentslurp.h) it() The tt(parentProcess) member simply `slurps' the information appearing at its standard input. Doing so, it actually reads the child's output. It copies the received lines to its standard output stream prefixing line numbers to them: verbinclude(//PARENT examples/parentslurp.cc) ) The following program simply constructs a tt(ParentSlurp) object, and calls its tt(fork()) member. Its output consists of a numbered list of files in the directory where the program is started. Note that the program also needs the tt(fork.o, pipe.o) and tt(waitforchild.o) object files (see earlier sources): verbinclude(//MAIN examples/parentslurp.cc) c++-annotations-10.6.0/yo/concrete/basicfork.yo0000644000175000017500000001161312745054221020236 0ustar frankfrank A basic tt(Fork) class should hide all bookkeeping details of a system call like tt(fork) from its users. The class tt(Fork) developed here does just that. The class itself only ensures the proper execution of the tt(fork) system call. Normally, tt(fork) is called to start a child process, usually boiling down to the execution of a separate process. This child process may expect input at its standard input stream and/or may generate output to its standard output and/or standard error streams. tt(Fork) does not know all this, and does not have to know what the child process will do. tt(Fork) objects should be able to start their child processes. tt(Fork)'s constructor cannot know what actions its child process should perform. Similarly, it cannot know what actions the parent process should perform. For these kind of situations, the emi(template method design pattern) hi(design pattern: template method) was developed. According to Gamma c.s., the em(template method design pattern) quote( ``Define(s) the skeleton of an algorithm in an operation, deferring some steps to subclasses. [The] Template Method (design pattern) lets subclasses redefine certain steps of an algorithm, without changing the algorithm's structure.'' ) This design pattern allows us to define an emi(abstract base class) hi(base class) already providing the essential steps related to the tt(fork) system call, deferring the implementation of other parts of the tt(fork) system call to subclasses. The tt(Fork) abstract base class has the following characteristics: itemization( it() It defines a data member tt(d_pid). In the parent process this data member contains the child's emi(process id) and in the child process it has the value 0. Its public interface declares only two members: itemization( it() a ti(fork) member function, responsible for the actual forking (i.e., it creates the (new) child process); it() a tt(virtual) destructor tt(~Fork) (having an empty body). ) Here is tt(Fork)'s interface: verbinclude(//CLASS examples/fork.h) it() All other non-virtual member functions are declared in the class's tt(protected) section and can thus em(only) be used by derived classes. They are: itemization( itt(pid()): The member function tt(pid) allows derived classes to access the system tt(fork)'s return value: verbinclude(//PID examples/fork.h) itt(waitForChild()): The member tt(int waitForChild) can be called by parent processes to wait for the completion of their child processes (as discussed below). This member is declared in the class interface. Its implementation is: verbinclude(-a examples/waitforchild.cc) This simple implementation returns the child's emi(exit status) to the parent. The called system function ti(waitpid) em(blocks) until the child terminates. ) it() When tt(fork) system calls are used, em(parent processes) hi(parent process) and em(child processes) hi(child process) must always be distinguished. The main distinction between these processes is that tt(d_pid) becomes the child's process-id in the parent process, while tt(d_pid) becomes 0 in the child process itself. Since these two processes must always be distinguished (and present), their implementation by classes derived from tt(Fork) is enforced by tt(Fork)'s interface: the members tt(childProcess), defining the child process' actions and tt(parentProcess), defining the parent process' actions were defined as pure virtual functions. it() communication between parent- and child processes may use standard streams or other facilities, like em(pipes) (cf. section ref(PIPE)). To facilitate this inter-process communication, derived classes em(may) implement: itemization( itt(childRedirections()): this member should be overridden by derived classes if any standard stream (tt(cin, cout,)) or tt(cerr) must be redirected in the em(child) process (cf. section ref(REDIRECTION)). By default it has an empty implementation; itt(parentRedirections()): this member should be overridden by derived classes if any standard stream (tt(cin, cout,)) or tt(cerr) must be redirected in the em(parent) process. By default it has an empty implementation. ) Redirection of the standard streams is necessary if parent and child processes must communicate with each other via the standard streams. Here are their default definitions. Since these functions are virtual functions they should not be implemented inline, but in their own source file: verbinclude(//REDIRECT examples/forkvirtual.cc) ) c++-annotations-10.6.0/yo/concrete/monitor.yo0000644000175000017500000000232212745054222017760 0ustar frankfrank The tt(monitor) program uses a tt(Monitor) object doing most of the work. The class tt(Monitor)'s public interface only offers a default constructor and one member, tt(run), to perform its tasks. All other member functions are located in the class's tt(private) section. tt(Monitor) defines the tt(private) enum tt(Commands), symbolically listing the various commands its input language supports, as well as several data members. Among the data members are a tt(Selector) object and a tt(map) using child order numbers as its keys and pointer to tt(Child) objects (see section ref(CHILD)) as its values. Furthermore, tt(Monitor) has a static array member tt(s_handler[]), storing pointers to member functions handling user commands. A destructor should be implemented as well, but its implementation is left as an exercise to the reader. Here is tt(Monitor)'s interface, including the interface of the nested class tt(Find) that is used to create a function object: verbinclude(//CLASS examples/monitor/monitor.h) Since there's only one non-class type data member, the class's constructor is a very simple function which could be implemented inline: verbinclude(//CONS examples/monitor/monitor.h) c++-annotations-10.6.0/yo/concrete/polygram.yo0000644000175000017500000000265412745054222020133 0ustar frankfrankNow that the tt(Semantic) class template has been developed it's time to put it to use in the tt(Parser) class. The parser's semantic value is tt(spSemBase). The parser's base class must be informed about this type, for which the tt(%baseclass-preinclude) directive is used. All other directives are standard and do not require further explanations: verbinclude(//HEAD poly2/parser/grammar) The grammar's rules simply consist of a series of tt(rule) nonterminals: verbinclude(//RULES poly2/parser/grammar) tt(Int) values are stored in tt(Semantic) objects, text is stored in tt(Semantic) values: verbinclude(//INT poly2/parser/grammar) Comma separated lists of arguments are processed as follows: the first argument is stored in a tt(Semantic); additional values are added to the vector using tt(vector::push_back). Note that we've defined the vector as mutable: addition of values to the vector is OK, but the values themselves remain as-is, and so the vector stores shared pointers to tt(SemBase const) values: verbinclude(//ARGS poly2/parser/grammar) The definition of the tt(rule) production rule completes our little grammar: an alternative suggesting an assignment echoes the received names and values, and an alternative suggesting a function call uses a support member tt(display) to display the received name and arguments: verbinclude(//RULE poly2/parser/grammar) c++-annotations-10.6.0/yo/concrete/binop.yo0000644000175000017500000000420312745054221017377 0ustar frankfrankAs we've seen in section ref(OVERLOADBINARY) binary operators expecting tt(const &) arguments can be implemented in move-aware classes using a move-aware binary operator, using a rvalue reference for its first argument. This latter function can in turn be implemented using the binary assignment member. The following examples illustrated this approach for a fictitious class tt(Binary): verbinclude(-a ../overloading/examples/binary4.h) Therefore, the implementations of the binary operators eventually depend on the availability of the binary assignment operator. Since template functions are not instantiated before their actually used we can mention a non-existing function in a template that is never instantiated. If such a function would actually be called then the compiler would generated an error message, complaining about the missing function. This allows us to implement all binary operators, movable and non-movable, as templates. It is then only possible to call the binary operators for which a matching binary assignment exists. The template functions implementing the above addition binary operators look like this: verbinclude(-a examples/binary5.h) em(Caveat): when defining these function templates ensure that the binary operator specifying an rvalue reference as its first parameter is defined before the binary operator specifying a const lrvalue reference as its first parameter, or programs using these templates fail due to infinite recursion. The function templates for the other binary operators can easily be added to these addition operators. After collecting them in a file tt(binops.h) include this file in, e.g., your class header file to add the binary operators to your class. Interestingly, classes em(not) implementing move constructors can still use these templates, as the move constructor itself is never called by the implementations of the binary operator (and its call is usually optimized away by copy elision). The following program (using modified function templates containing output statements) behaves identically whether or not the move constructor is defined: verbinclude(-a examples/binop.cc) c++-annotations-10.6.0/yo/concrete/fistreamexample.yo0000644000175000017500000000641212745054221021462 0ustar frankfrank There is only one additional public member: tt(setField(field const &)). This member defines the size of the next field to extract. Its parameter is a reference to a tt(field) class, a em(manipulator class) defining the width of the next field. Since a tt(field &) is mentioned in tt(Fistream)'s interface, tt(field) must be declared before tt(Fistream)'s interface starts. The class tt(field) itself is simple and declares tt(Fistream) as its friend. It has two data members: tt(d_width) specifies the width of the next field, and tt(d_newWidth) which is set to tt(true) if tt(d_width)'s value should actually be used. If tt(d_newWidth) is false, tt(Fistream) returns to its standard extraction mode. The class tt(field) has two constructors: a default constructor, setting tt(d_newWidth) to tt(false), and a second constructor expecting the width of the next field to extract as its value. Here is the class tt(field): verbinclude(//FIELD examples/fistream/fistream.h) Since tt(field) declares tt(Fistream) as its friend, tt(setField) may inspect tt(field)'s members directly. Time to return to tt(setField). This function expects a reference to a tt(field) object, initialized in one of three different ways: itemization( itt(field()): When tt(setField)'s argument is a tt(field) object constructed by its default constructor the next extraction will use the same fieldwidth as the previous extraction. itt(field(0)): When this tt(field) object is used as tt(setField)'s argument, fixed-sized field extraction stops, and the tt(Fistream) acts like any standard tt(istream) object again. itt(field(x)): When the tt(field) object itself is initialized by a non-zero size_t value tt(x), then the next field width is tt(x) characters wide. The preparation of such a field is left to tt(setBuffer), tt(Fistream)'s only private member. ) Here is tt(setField)'s implementation: verbinclude(//SETFIELD examples/fistream/fistream.cc) The private member tt(setBuffer) defines a buffer of tt(d_width + 1) characters and uses tt(read) to fill the buffer with tt(d_width) characters. The buffer is an NTBS. This buffer is used to initialize the tt(d_iss) member. tt(Fistream)'s tt(rdbuf) member is used to extract the tt(d_str)'s data via the tt(Fistream) object itself: verbinclude(//SETBUFFER examples/fistream/fistream.cc) Although tt(setField) could be used to configure tt(Fistream) to use or not to use fixed-sized field extraction, using manipulators is probably preferable. To allow tt(field) objects to be used as manipulators an overloaded extraction operator was defined. This extraction operator accepts tt(istream &) and a tt(field const &) objects. Using this extraction operator, statements like verb(fis >> field(2) >> x >> field(0);) are possible (assuming tt(fis) is a tt(Fistream) object). Here is the overloaded oprshift(), as well as its declaration: verbinclude(//OPEX examples/fistream/fistream.cc) Declaration: verbinclude(//OPEX examples/fistream/fistream.h) Finally, an example. The following program uses a tt(Fistream) object to url-decode url-encoded information appearing at its standard input: verbinclude(//MAIN examples/fistream/main.cc) c++-annotations-10.6.0/yo/concrete/definition.yo0000644000175000017500000001636212745054221020431 0ustar frankfrank The i(declaration section) contains several sets of declarations, among which definitions of all the tokens used in the grammar and the priorities and associativities of the mathematical operators. Moreover, several new and important specifications can be used here as well. Those relevant to our current example and only available in tt(bisonc++) are discussed here. The reader is referred to tt(bisonc++)'s man-page for a full description. itemization( it() bi(%baseclass-preinclude) tt(header)nl() Use tt(header) as the pathname to the file pre-included in the parser's base-class header. This declaration is useful in situations where the base class header file refers to types which might not yet be known. E.g., with ti(%union) a tt(std::string *) field might be used. Since the class tt(std::string) might not yet be known to the compiler once it processes the base class header file we need a way to inform the compiler about these classes and types. The suggested procedure is to use a pre-include header file declaring the required types. By default tt(header) is surrounded by double quotes (using, e.g., tt(#include "header")). When the argument is surrounded by angle brackets tt(#include
) is included. In the latter case, quotes might be required to escape interpretation by the shell (e.g., using tt(-H '
')). it() bi(%filenames) tt(header) nl() Defines the generic name of all generated files, unless overridden by specific names. By default the generated files use the class-name as the generic file name. it() bi(%scanner) tt(header)nl() Use tt(header) as the pathname to the file pre-included in the parser's class header. This file should define a class tt(Scanner), offering a member tt(int lex()) producing the next token from the input stream to be analyzed by the parser generated by tt(bisonc++). When this option is used the parser's member tt(int lex()) is predefined as (assuming the default parser class name tt(Parser) is used): verb( inline int Parser::lex() { return d_scanner.lex(); } ) and an object tt(Scanner d_scanner) is composed into the parser. The tt(d_scanner) object is constructed by its default constructor. If another constructor is required, the parser class may be provided with an appropriate (overloaded) parser constructor after having constructed the default parser class header file using tt(bisonc++). By default tt(header) is surrounded by double quotes (using, e.g., tt(#include "header")). When the argument is surrounded by angle brackets tt(#include
) is included. it() bi(%stype) tt(typename) nl() The type of the semantic value of tokens. The specification tt(typename) should be the name of an unstructured type (e.g., tt(size_t)). By default it is tt(int). See tt(YYSTYPE) in tt(bison). It should not be used if a tt(%union) specification is used. Within the parser class, this type may be used as tt(STYPE). it() bi(%union) tt(union-definition) nl() Acts identically to the tt(bison) declaration. As with tt(bison) this generates a union for the parser's semantic type. The union type is named tt(STYPE). If no tt(%union) is declared, a simple stack-type may be defined using the tt(%stype) declaration. If no tt(%stype) declaration is used, the default stacktype (tt(int)) is used. ) An example of a tt(%union) declaration is: verb( %union { int i; double d; }; ) In pre-C++11 code a i(union) cannot contain objects as its fields, as constructors cannot be called when a union is created. This means that hi(string: as union member) a tt(string) cannot be a member of the union. A tt(string *), however, em(is) a possible union member. It might also be possible to use em(unrestricted unions) (cf. section ref(UNIONS)), having class type objects as fields. As an aside: the scanner does not have to know about such a union. It can simply pass its scanned text to the parser through its ti(matched) member function. For example using a statement like verb( $$.i = A2x(d_scanner.matched()); ) matched text is converted to a value of an appropriate type. Tokens and non-terminals can be associated with union fields. This is strongly advised, as it prevents type mismatches, since the compiler may then check for type correctness. At the same time, the bison specific variables tt($$), tt($1), tt($2), etc. may be used, rather than the full field specification (like tt($$.i)). A non-terminal or a token may be associated with a union field using the tt() specification. E.g., verb( %token INT // token association (deprecated, see below) DOUBLE %type intExpr // non-terminal association ) In the example developed here, both the tokens and the non-terminals can be associated with a union field. However, as noted before, the scanner does not have to know about all this. In our opinion, it is cleaner to let the scanner do just one thing: scan texts. The em(parser), knowing what the input is all about, may then convert strings like tt("123") to an integer value. Consequently, the association of a union field and a token is discouraged. Below, while describing the grammar's rules, this is further illustrated. In the tt(%union) discussion the ti(%token) and ti(%type) specifications should be noted. They are used to specify the tokens (terminal symbols) that can be returned by the scanner, and to specify the return types of non-terminals. Apart from tt(%token) the token declarators ti(%left), ti(%right), and ti(%nonassoc) can be used to specify the associativity of operators. The tokens mentioned at these indicators are interpreted as tokens indicating operators, associating in the indicated direction. The precedence of operators is defined by their order: the first specification has the lowest priority. To overrule a certain precedence in a certain context ti(%prec) can be used. As all this is standard tt(bisonc++) practice, it isn't further elaborated here. The documentation provided with tt(bisonc++)'s distribution should be consulted for further reference. Here is the specification of the calculator's declaration section: verbinclude(//DECLARATION bisonc++/parser/grammar) In the declaration section tt(%type) specifiers are used, associating the tt(intExpr) rule's value (see the next section) to the tt(i)-field of the semantic-value union, and associating tt(doubleExpr)'s value to the tt(d)-field. This approach, admittedly, is rather complex, as expression rules must be included for each of the supported union types. Alternatives are definitely possible, and involve the use of em(polymorphic semantic values), covered in detail in the url(Bisonc++ user guide)(http://bisoncpp.sourceforge.net/). c++-annotations-10.6.0/yo/concrete/bison.yo0000644000175000017500000000571012745054221017406 0ustar frankfrankThe i(grammar specification file) required by ti(bisonc++) is comparable to the specification file required by ti(bison). Differences are related to the class nature of the resulting parser. Our calculator distinguishes real numbers from integers, and supports a basic set of arithmetic operators. tt(Bisonc++) should be used as follows: itemization( it() As usual, a grammar is defined. With tt(bisonc++) this is no different, and tt(bisonc++) grammar definitions are for all practical purposes identical to tt(bison)'s grammar definitions. it() Having specified the grammar and (usually) some declarations tt(bisonc++) can generate files defining the parser class and the implementation of the member function tt(parse). it() All class members (except those that are required for the proper functioning of the member tt(parse)) must be separately implemented. Of course, they should also be declared in the parser class's header. At the very least the member ti(lex) must be implemented. This member is called by tt(parse) to obtain the next available token. However, tt(bisonc++) offers a facility providing a standard implementation of the function tt(lex). The member function hi(error)tt(error(char const *msg)) is given a simple default implementation that may be modified by the programmer. The member function tt(error) is called when tt(parse) detects (syntactic) errors. it() The parser can now be used in a program. A very simple example would be: verb( int main() { Parser parser; return parser.parse(); } ) ) The tt(bisonc++) hi(bisonc++: grammar file) specification file has two sections: itemization( it() The em(declaration section). In this section bison's tokens, and the priority rules for the operators are declared. However, tt(bisonc++) also supports several new declarations. These new declarations are important and are discussed below. it() The em(rules section). The i(grammatical rules) define the grammar. This section is identical to the one required by tt(bison), albeit that some members that were available in tt(bison) and tt(bison++) are obsolete in tt(bisonc++), while other members can be used in a wider context. For example, bf(ACCEPT) and bf(ABORT) can be called from any member called from the parser's action blocks to terminate the parsing process. ) Readers familiar with tt(bison) may note that there is no emi(header section) anymore. Header sections are used by bison to provide for the necessary declarations allowing the compiler to compile the bf(C) function generated by tt(bison). In bf(C++) declarations are part of or already used by class definitions. Therefore, a parser generator generating a bf(C++) class and some of its member functions does not require a header section anymore. c++-annotations-10.6.0/yo/concrete/run.yo0000644000175000017500000000544312745054222017104 0ustar frankfrank tt(Monitor)'s core activities are performed by tt(run). It performs the following tasks: itemization( it() Initially, the tt(Monitor) object only monitors its standard input. The set of input file descriptors to which tt(d_selector) listens is initialized to tt(STDIN_FILENO). it() Then, in a loop tt(d_selector)'s tt(wait) function is called. If input on tt(cin) is available, it is processed by tt(processInput). Otherwise, the input has arrived from a child process. Information sent by children is processed by tt(processChild). it() To prevent emi(zombie)em(s), the child processes must catch em(their) children's termination signals. This is discussed below. As noted by Ben Simons (tt(ben at mrxfx dot com)) tt(Monitor) must not catch the termination signals. Instead, the process spawning child processes has that responsibility (the underlying principle being that a parent process is responsible for its child processes; a child process, in turn, is responsible for its own child processes). it() As stated, tt(run)'s source file also defines and initializes tt(s_initialize) to ensure the proper initialization of the tt(s_handler) array. ) Here is tt(run)'s implementation and tt(s_initialize)'s definition: verbinclude(-a examples/monitor/run.cc) The member function tt(processInput) reads the commands entered by the user using the program's standard input stream. The member itself is rather simple. It calls tt(next) to obtain the next command entered by the user, and then calls the corresponding function using the matching element of the tt(s_handler[]) array. Here are the members tt(processInput) and tt(next): verbinclude(//INPUT examples/monitor/processinput.cc) verbinclude(//NEXT examples/monitor/processinput.cc) All other input sensed by tt(d_select) is created by child processes. Because tt(d_select)'s tt(readFd) member returns the corresponding input file descriptor, this descriptor can be passed to tt(processChild). Using a ti(IFdStreambuf) (see section ref(IFDBUF)), its information is read from an input stream. The communication protocol used here is rather basic. For every line of input sent to a child, the child replies by sending back exactly one line of text. This line is then read by tt(processChild): verbinclude(//CHILD examples/monitor/processchild.cc) The construction tt(d_child[fd]->pid()) used in the above source deserves some special attention. tt(Monitor) defines the data member tt(map> d_child). This map contains the child's order number as its key, and a (shared) pointer to the tt(Child) object as its value. A shared pointer is used here, rather than a tt(Child) object, since we want to use the facilities offered by the map, but don't want to copy a tt(Child) object time and again. c++-annotations-10.6.0/yo/concrete/lexer.yo0000644000175000017500000000234512745054222017415 0ustar frankfrank The function matching the i(regular expression) rules (tt(lex)) is a member of the class hi(scanner)tt(Scanner). Since tt(Scanner) is derived from tt(ScannerBase), it has access to all of tt(ScannerBase)'s protected members that execute the lexical scanner's regular expression matching algorithm. Looking at the regular expressions themselves, notice that we need rules to recognize comment, ti(#include) directives, and all remaining characters. This all is fairly standard practice. When an tt(#include) directive is sensed, the directive is parsed by the scanner. This too is common practice. Our lexical scanner performs the following tasks: itemization( it() As usual, i(preprocessor directive)s are not analyzed by a parser, but by the lexical scanner; it() The scanner uses a i(mini scanner) to extract the filename from the directive, throwing a exception if this fails; it() If the filename could be extracted, processing switches to the next stream, controlling for a maximum nesting depth. it() Once the end of the current file has been reached processing automatically returns to the previous file, restoring the previous file name an line number. The scanner returns 0 if all files have been processed. ) c++-annotations-10.6.0/yo/concrete/fork.yo0000644000175000017500000000276312745054221017242 0ustar frankfrankFrom the bf(C) programming language the ti(fork) system call is well known. When a program needs to start a new process, ti(system) can be used. The function tt(system) requires the program to wait for the emi(child process) to terminate. The more general way to spawn subprocesses is to use tt(fork). In this section we investigate how bf(C++) can be used to wrap classes around a complex system call like tt(fork). Much of what follows in this section directly applies to the Unix operating system, and the discussion therefore focuses on that operating system. Other systems usually provide comparable facilities. What follows is closely related to the em(Template Design Pattern)hi(design pattern) (cf. em(Gamma et al.) (1995) hi(Gamma, E.) i(Design Patterns), Addison-Wesley) When tt(fork) is called, the current program is duplicated in memory, thus creating a new process. Following this duplication both processes continue their execution just below the tt(fork) system call. The two processes may inspect tt(fork)'s return value: the return value in the original process (called the emi(parent process)) differs from the return value in the newly created process (called the emi(child process)): itemization( it() In the em(parent process) tt(fork) returns the emi(process ID) of the (child) process that was created by the tt(fork) system call. This is a positive integer value. it() In the em(child process) tt(fork) returns 0. it() If tt(fork) fails, -1 is returned. ) c++-annotations-10.6.0/yo/concrete/promotions.yo0000644000175000017500000001175512745054222020514 0ustar frankfrankThe function templates introduced in the previous section do not support promotions. E.g., a statement like verb( result = rhs + 2; ) generates a compilation error as promotions are not recognized by the template argument deduction algoritm. Currently, the above statement needs to be rewritten to have it accepted by the compiler: verb( result = rhs + Class(2); ) If promotions are welcome, how can we change the arithmetic operator function templates so that promotions are performed? With promotions the arguments of the operator functions may be of any type, at least one of them must be of the class type offering the matching compound assignment operator. But when designing the function template we can't say which of the two operands has that class type. So we have to specify two template types parameters for the two parameters of the operator functions. The function template must therefore start with something like this: verb( template ReturnType operator+(LHS const &lhs, RHS const &rhs) ) At this point we can't yet specify tt(ReturnType). It is tt(LHS) if tt(RHS) can be promoted to or is equal to tt(LHS), it is be tt(RHS) if tt(LHS) is promoted to tt(RHS). To determine whether tt(RHS) can be promoted to tt(LHS) we now design a simple template meta programming class tt(LpromotesR) using two template type parameters, defining the value tt(true) (1) if the second (right hand) type can be promoted to the first (left-hand) type, and defining the value tt(false) (0) if not. Here we use the same principle seen before in section ref(TYPECONV), link(type convertibility)(TYPECONV): verb( template class LpromotesR { struct Char2 { char array[2]; }; static R const &makeR(); static char test(L const &); static Char2 test(...); public: LpromotesR() = delete; enum { yes = sizeof(test(makeR())) == sizeof(char) }; }; ) In tt(class LpromotesR) the function tt(test(L const &)) is selected if tt(R) can be promoted to tt(L), and tt(test(...)) is selected if not. The different sizes of the return types of these two tt(test) functions allows the compiler to assign 1 or 0 to the class's tt(enum) value tt(yes). The value tt(yes) (correctly) is 0 for tt(R) types mentioned in constructors declared with the tt(explicit) keyword, and it (correctly) is 1 if tt(L) and tt(R) happen to be the same types. Now that we can determine whether a type can be promoted to another type, it is possible to select either tt(LHS) or tt(RHS) as the function template's return type. If tt(RHS) can be promoted to tt(LHS) use tt(LHS) as the function template's return type, otherwise use RHS. Of course there is a third possibility: the tt(LHS) and tt(RHS) types cannot be used by each other's constructors. In that case, unless there is another constructor lying around somewhere handling that situation, the compiler generates an error like: verb( no match for 'operator+' in '...' ) Back to promotable types. We are now able to determine which type can be promoted, using tt(LpromotesR). This yields a value that can be used as selector in the tt(IfElse) template meta programming class template, introduced earlier (cf. section ref(IFELSE)). Now that we can select either tt(LHS) or tt(RHS) as the operator template function's return type, we're able to construct our arithmetic operator function template supporting promotions: verb( template typename FBB::IfElse::yes, LHS, RHS>::type operator<<(LHS const &lhs, RHS const &rhs) { typedef typename FBB::IfElse< FBB::LpromotesR< LHS, RHS >::yes, LHS, RHS >::type Type; Type tmp(lhs); return std::move(tmp) << type(rhs); } ) The function's return type is tt(IfElse)'s tt(type), selected as either tt(LHS) (if tt(RHS) can be promoted to tt(LHS)) or tt(RHS). The same trick is used in the function's body to determine tt(tmp)'s type. Now promotions are possible. The function template defining an rvalue reference parameter remains as-is. Together they allow the compiler to make the following decisions (using tt(Class) as the intended class name, tt(Type) as a type that is promotable to tt(Class), and tt(@) as the generic indication of the used operator). Unless otherwise specified the function template defining the parameter list tt((LHS const &lhs, RHS const &rhs)) is used: verb( Class obj; Type value; obj @ obj // no promotions obj @ Class() // same obj @ value; // value is promoted to Class Class() @ value; // same value @ obj; // same value @ Class(); // same Class() @ obj; // calls operator@(Class &&, Class const &) Class() @ Class(); // same ) c++-annotations-10.6.0/yo/concrete/intro.yo0000644000175000017500000000167512745054222017436 0ustar frankfrankIn this chapter concrete examples of bf(C++) programs, classes and templates are presented. Topics covered by the annotations() such as virtual functions, tt(static) members, etc. are illustrated in this chapter. The examples roughly follow the organization of earlier chapters. As an additional topic, not just providing examples of bf(C++) the subjects of i(scanner) and i(parser) generators are covered. We show how these tools may be used in bf(C++) programs. These additional examples assume a certain familiarity with the concepts underlying these tools, like grammars, parse-trees and hi(grammar) hi(parse-tree) parse-tree decoration. Once the input for a program exceeds a certain level of complexity, it's attractive to use scanner- and parser-generators to create the code doing the actual input processing. One of the link(examples)(BisonAndFlex) in this chapter describes the usage of these tools in a bf(C++) environment. c++-annotations-10.6.0/yo/concrete/child.yo0000644000175000017500000001011312745054221017350 0ustar frankfrank When the tt(Monitor) object starts a child process, it creates an object of the class tt(Child). The tt(Child) class is derived from the class tt(Fork), allowing it to operate as a emi(daemon) (as discussed in the previous section). Since tt(Child) is a daemon class, we know that its parent process must be defined as an empty function. Its tt(childProcess) member has a non-empty implementation. Here are the characteristics of the class tt(Child): itemization( it() The tt(Child) class has two tt(Pipe) data members, to handle communications between its own child- and parent processes. As these pipes are used by the tt(Child)'s child process, their names refer to the child process. The child process reads from tt(d_in), and writes to tt(d_out). Here is the interface of the class tt(Child): verbinclude(//CLASS examples/monitor/child.h) it() The tt(Child)'s constructor simply stores its argument, a child-process order number, in its own tt(d_nr) data member: verbinclude(//CONS examples/monitor/child.h) it() The tt(Child)'s child process obtains commands from its standard input stream and writes its output to its standard output stream. Since the actual communication channels are pipes, redirections must be used. The tt(childRedirections) member looks like this: verbinclude(//CHILD examples/monitor/child.cc) it() Although the parent process performs no actions, it must configure some redirections. Realizing that the names of the pipes indicate their functions in the child process. So the parent em(writes) to tt(d_in) and em(reads) from tt(d_out). Here is tt(parentRedirections): verbinclude(//PARENT examples/monitor/child.cc) it() The tt(Child) object exists until it is destroyed by the tt(Monitor)'s tt(stopChild) member. By allowing its creator, the tt(Monitor) object, to access the parent-side ends of the pipes, the tt(Monitor) object can communicate with the tt(Child)'s child process via those pipe-ends. The members tt(readFd) and tt(writeFd) allow the tt(Monitor) object to access these pipe-ends: verbinclude(//PIPES examples/monitor/child.h) it() The tt(Child) object's child process performs two tasks: itemization( it() It must reply to information appearing at its standard input stream; it() If no information has appeared within a certain time frame (the implementations uses an interval of five seconds), then a message is written to its standard output stream. ) To implement this behavior, tt(childProcess) defines a local tt(Selector) object, adding tt(STDIN_FILENO) to its set of monitored input file descriptors. Then, in an endless loop, tt(childProcess) waits for tt(selector.wait()) to return. When the alarm goes off it sends a message to its standard output (hence, into the writing pipe). Otherwise, it echoes the messages appearing at its standard input to its standard output. Here is the tt(childProcess) member: verbinclude(//PROCESS examples/monitor/child.cc) it() Two accessors are defined allowing the tt(Monitor) object to obtain the tt(Child)'s process ID and its order number: verbinclude(//PIDNR examples/monitor/child.h) it() A tt(Child) process terminates when the user enters a tt(stop) command. When an existing child process number was entered, the corresponding tt(Child) object is removed from tt(Monitor)'s tt(d_child) map. As a result, its destructor is called. tt(Child)'s destructor calls tt(kill) to terminate its child, and then waits for the child to terminate. Once its child has terminated, the destructor has completed its work and returns, thus completing the erasure from tt(d_child). The current implementation fails if the child process doesn't react to the tt(SIGTERM) signal. In this demonstration program this does not happen. In `real life' more elaborate killing-procedures may be required (e.g., using tt(SIGKILL) in addition to tt(SIGTERM)). As discussed in section ref(CONSEXCEPTIONS) it em(is) important to ensure the proper destruction. Here is the tt(Child)'s destructor: verbinclude(//CHILDDES examples/monitor/child.cc) ) c++-annotations-10.6.0/yo/concrete/lexer/0000755000175000017500000000000013005340354017032 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/lexer/build0000755000175000017500000000075212745054222020071 0ustar frankfrank#!/bin/bash case "$1" in ("") echo " usage: 'build prog' to build the program, 'build clean' to cleanup " exit 1 ;; (prog) cd scanner flexc++ lexer || exit 1 cd .. g++ --std=c++11 -Wall -olexer lexer.cc scanner/*.cc || exit 1 echo " ready; run the program as 'lexer in.1' " ;; (clean) cd scanner rm -f ../lexer lex.cc scannerbase.h echo " done " ;; esac exit 1 c++-annotations-10.6.0/yo/concrete/lexer/in.10000644000175000017500000000005512745054222017530 0ustar frankfrankbefore #include #include after c++-annotations-10.6.0/yo/concrete/lexer/lexer.cc0000644000175000017500000000051513005340355020462 0ustar frankfrank#include "lexer.ih" int main(int argc, char **argv) try { if (argc == 1) { cerr << "Filename argument required\n"; return 1; } Scanner scanner(argv[1], "-"); scanner.setDebug(argc > 2); return scanner.lex(); } catch (exception const &exc) { cerr << exc.what() << '\n'; return 1; } c++-annotations-10.6.0/yo/concrete/lexer/scanner/0000755000175000017500000000000013005340354020463 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/lexer/scanner/scanner.ih0000644000175000017500000000005313005340354022434 0ustar frankfrank#include "scanner.h" using namespace std; c++-annotations-10.6.0/yo/concrete/lexer/scanner/scanner.h0000644000175000017500000000243513005340355022272 0ustar frankfrank// Generated by Flexc++ V0.94.00 on Thu, 23 Feb 2012 16:23:09 +0100 #ifndef Scanner_H_INCLUDED_ #define Scanner_H_INCLUDED_ // $insert baseclass_h #include "scannerbase.h" // $insert classHead class Scanner: public ScannerBase { std::string d_nextSource; public: explicit Scanner(std::istream &in = std::cin, std::ostream &out = std::cout); Scanner(std::string const &infile, std::string const &outfile); // $insert lexFunctionDecl int lex(); private: int lex__(); int executeAction__(size_t ruleNr); void print(); void preCode(); // re-implement this function for code that must // be exec'ed before the patternmatching starts void switchSource(); }; // $insert scannerConstructors inline Scanner::Scanner(std::istream &in, std::ostream &out) : ScannerBase(in, out) {} inline Scanner::Scanner(std::string const &infile, std::string const &outfile) : ScannerBase(infile, outfile) {} // $insert inlineLexFunction inline int Scanner::lex() { return lex__(); } inline void Scanner::preCode() { // optionally replace by your own code } inline void Scanner::print() { print__(); } #endif // Scanner_H_INCLUDED_ c++-annotations-10.6.0/yo/concrete/lexer/scanner/lexer0000644000175000017500000000136612745054222021541 0ustar frankfrank//SYMBOLS %filenames scanner %debug %max-depth 3 %x comment %x include //= //RULES %% // The comment-rules: comment is ignored. //.* // ignore eoln comment "/*" begin(StartCondition__::comment); { .|\n // ignore all characters in std C comment "*/" begin(StartCondition__::INITIAL); } // File switching: #include #include[ \t]+"<" begin(StartCondition__::include); { [^ \t>]+ d_nextSource = matched(); ">"[ \t]*\n switchSource(); .|\n throw runtime_error("Invalid include statement"); } // The default rule: echo anything else to std::cout .|\n echo(); //= c++-annotations-10.6.0/yo/concrete/lexer/scanner/switchsource.cc0000644000175000017500000000017413005340355023517 0ustar frankfrank#include "scanner.ih" void Scanner::switchSource() { pushStream(d_nextSource); begin(StartCondition__::INITIAL); } c++-annotations-10.6.0/yo/concrete/lexer/lexer.ih0000644000175000017500000000010713005340354020471 0ustar frankfrank#include #include "scanner/scanner.h" using namespace std; c++-annotations-10.6.0/yo/concrete/lexer/in.20000644000175000017500000000003012745054222017522 0ustar frankfrankin in.2 #include c++-annotations-10.6.0/yo/concrete/poly2/0000755000175000017500000000000013005340354016760 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/poly2/build0000755000175000017500000000115712745054222020017 0ustar frankfrank#!/bin/bash case "$1" in (prog) cd parser bisonc++ --print-tokens grammar || exit 1 cd ../scanner flexc++ lexer || exit 1 cd .. g++ --std=c++11 -Wall -opoly *.cc */*.cc -lbobcat || exit 1 echo " ready; run the program as './poly < input' " ;; (clean) rm -f poly cd parser rm -f parse.cc parserbase.h cd ../scanner rm -f lex.cc scannerbase.h echo " done " ;; (*) echo " usage: 'build prog' to build the program, 'build clean' to cleanup " exit 1 ;; esac exit 1 c++-annotations-10.6.0/yo/concrete/poly2/input0000644000175000017500000000006112745054222020045 0ustar frankfrankvar = 5 ; var(var, 5, ok, 18); var(5); var(ok); c++-annotations-10.6.0/yo/concrete/poly2/parser/0000755000175000017500000000000013005340354020254 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/poly2/parser/parser.h0000644000175000017500000000221013005340355021715 0ustar frankfrank// Generated by Bisonc++ V3.00.00 on Fri, 24 Feb 2012 15:09:41 +0100 #ifndef Parser_h_included #define Parser_h_included // $insert baseclass #include "parserbase.h" // $insert scanner.h #include "../scanner/scanner.h" #undef Parser class Parser: public ParserBase { // $insert scannerobject Scanner d_scanner; public: int parse(); private: void error(char const *msg); // called on (syntax) errors int lex(); // returns the next token from the // lexical scanner. void print(); // use, e.g., d_token, d_loc void display(STYPE__ const &id, STYPE__ &vect); // support functions for parse(): void executeAction(int ruleNr); void errorRecovery(); int lookup(bool recovery); void nextToken(); void print__(); }; inline void Parser::error(char const *msg) { std::cerr << msg << '\n'; } // $insert lex inline int Parser::lex() { return d_scanner.lex(); } inline void Parser::print() { print__(); // displays tokens if --print was specified } #endif c++-annotations-10.6.0/yo/concrete/poly2/parser/parser.ih0000644000175000017500000000024713005340354022075 0ustar frankfrank // Include this file in the sources of the class Parser. // $insert class.h #include "parser.h" #include using namespace std; using namespace FBB; c++-annotations-10.6.0/yo/concrete/poly2/parser/display.cc0000644000175000017500000000112013005340355022223 0ustar frankfrank#include "parser.ih" void Parser::display(STYPE__ const &id, STYPE__ &vect) { cout << id->as() << "("; char const *sep = ""; for (auto &sp: vect->as()) { cout << sep; switch (sp->tag()) { case Tag::INT: cout << sp->as(); break; case Tag::TEXT: cout << sp->as(); break; default: // Tag::VECTOR intentionally not handled break; } sep = ", "; } cout << ")\n"; } c++-annotations-10.6.0/yo/concrete/poly2/parser/grammar0000644000175000017500000000157512745054222021643 0ustar frankfrank//HEAD %filenames parser %scanner ../scanner/scanner.h %baseclass-preinclude ../spsembase/spsembase.h %stype spSemBase %token INT IDENT //= %% //RULES rules: rules rule | rule ; //= //INT int: INT { $$ = new Semantic(A2x(d_scanner.matched()).to()); } ; ident: IDENT { $$ = new Semantic(d_scanner.matched()); } ; //= //ARGS value: int | ident ; arglist: arglist ',' value { $1->as().push_back($3); } | value { $$ = new Semantic( vector> {$1}); } ; //= //RULE rule: ident '(' arglist ')' ';' { display($1, $3); } | ident '=' int ';' { cout << $1->as() << " = " << $3->as() << ";\n"; } ; //= c++-annotations-10.6.0/yo/concrete/poly2/scanner/0000755000175000017500000000000013005340353020410 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/poly2/scanner/scanner.ih0000644000175000017500000000037413005340354022370 0ustar frankfrank// Declare here // what's only used in the Scanner class // and let Scanner's sources include "scanner.ih" #include "scanner.h" #include "../parser/parserbase.h" // end of scanner.ih c++-annotations-10.6.0/yo/concrete/poly2/scanner/scanner.h0000644000175000017500000000231613005340355022216 0ustar frankfrank// Generated by Flexc++ V0.94.00 on Fri, 24 Feb 2012 15:08:50 +0100 #ifndef Scanner_H_INCLUDED_ #define Scanner_H_INCLUDED_ // $insert baseclass_h #include "scannerbase.h" // $insert classHead class Scanner: public ScannerBase { public: explicit Scanner(std::istream &in = std::cin, std::ostream &out = std::cout); Scanner(std::string const &infile, std::string const &outfile); // $insert lexFunctionDecl int lex(); private: int lex__(); int executeAction__(size_t ruleNr); void print(); void preCode(); // re-implement this function for code that must // be exec'ed before the patternmatching starts }; // $insert scannerConstructors inline Scanner::Scanner(std::istream &in, std::ostream &out) : ScannerBase(in, out) {} inline Scanner::Scanner(std::string const &infile, std::string const &outfile) : ScannerBase(infile, outfile) {} // $insert inlineLexFunction inline int Scanner::lex() { return lex__(); } inline void Scanner::preCode() { // optionally replace by your own code } inline void Scanner::print() { print__(); } #endif // Scanner_H_INCLUDED_ c++-annotations-10.6.0/yo/concrete/poly2/scanner/lexer0000644000175000017500000000035712745054222021466 0ustar frankfrank%filenames scanner %% [[:space:]]+ // skip white space [[:digit:]]+ return Parser::INT; [[:alpha:]_][[:alnum:]_]* return Parser::IDENT; . return matched()[0]; c++-annotations-10.6.0/yo/concrete/poly2/spsembase/0000755000175000017500000000000013005340353020741 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/poly2/spsembase/spsembase.h0000644000175000017500000000055313005340355023101 0ustar frankfrank#ifndef INCLUDED_SPSEMBASE_ #define INCLUDED_SPSEMBASE_ #include "../sembase/sembase.h" class spSemBase: public std::shared_ptr { public: spSemBase() = default; template spSemBase(Type *obj); }; template inline spSemBase::spSemBase(Type *obj) : std::shared_ptr(obj) {} #endif c++-annotations-10.6.0/yo/concrete/poly2/spsembase/frame0000644000175000017500000000005112745054222021761 0ustar frankfrank#include "spsembase.ih" spSemBase:: { } c++-annotations-10.6.0/yo/concrete/poly2/sembase/0000755000175000017500000000000013005340354020377 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/poly2/sembase/sembase.h0000644000175000017500000001540713005340355022177 0ustar frankfrank#ifndef INCLUDED_SEMBASE_ #define INCLUDED_SEMBASE_ #include #include #include #include class SemBase; //TAG enum class Tag // defines the various semantic values { // Tags are used to instantiate the proper INT, // Semantic type, deriving from a polymorphic base TEXT, // class VECTOR, }; //= // In separate anonymous namespace sections parts of the various semantic // types are defined. Sections labeled 'IUO' are `Internal Use Only' and // contain no serviceable parts namespace { // IUO //MUTABLE struct Mutable // Semantic values may or may { // not be mutable. By deriving enum: bool { isMutable = true }; // BasicTrait, below, from }; // either Mutable or Immutable // this trait is associated with struct Immutable // a semantic value BasicTrait. { enum: bool { isMutable = false }; }; //= // For each semantic value type define a TagTrait specialization which // is either derived from Immutable (in which case the Parser cannot // change the semantic value) or from Mutable (In which case changing the // semantic value on the semantic value stack *is* allowed) // In addition, define the data type to use, as received in the // initialization (e.g., int, std::string, vector). //TRAITTAG template struct TagTrait; template <> struct TagTrait: public Immutable { typedef int DataType; }; template <> struct TagTrait: public Immutable { typedef std::string DataType; }; template <> struct TagTrait: public Mutable { typedef std::vector> DataType; }; //= // In this section of the anonymous namespace it is determined whether a // semantic value type is a basic type (in which case the return type of // the Semantic class's conversion operator can be equal to the type // itself) or a class-type (in which case a reference is returned). /// Its logic is based on two function templates 'test' expecting either // any type of argument or expecting a pointer to a member function of the // type provided to the template. Since basic types have no members, the // `any argument' variant is selected by the compiler for basic // types. These two functions return values having different sizes, // allowing the template to determine whether the type is a basic type or // not. The enum value 'isBasicType' is initialized accordingly. /// For the ReturnType (i.e., the conversion operator's return type the // std::conditional template meta programming function is used). For a // mutable data type a reference to the Semantic class's data memebr is // returned, for an immutable basic data type a copy of the data member's // value is returned, otherwise a const & is returned. //CLASSTRAIT struct C2 { char _[2]; }; struct C1 { char _; }; template C1 test(...); template C2 test(void (T::*)()); template struct Trait: public TagTrait { typedef typename Trait::DataType DataType; enum: bool { isMutable = Trait::isMutable, isBasicType = sizeof(test(0)) == sizeof(C1) }; typedef typename std::conditional< isMutable, DataType &, typename std::conditional< isBasicType, DataType, DataType const & >::type >::type ReturnType; }; //= } /// The implementation of the polymorphic semantic value in fact implements // a type-safe polymorphic semantic union. This is a non-existing data // type in C++, but the parser may handle semantic values as unions: it // always knows the actual type of semantic value that's used at a // particular point in the grammar, and if not, it can inspect the // SemBase's tag fields. Since the parser knows, or can determine what the // actual semantic type is, it can always perform a downcast, resulting in // a *very* lightweight SemBase base class: there's only a virtual // destructor. No other virtual members are required. Downcasting itself // is encapsulated in its 'as' member, allowing constructions like /// $1->as() /// to downcast the $1 SemBase to a Semantic, and then, // usually by implication, to a std::string, using the Semantic's // conversion operator. //SEMBASE class SemBase { Tag d_tag; public: SemBase(SemBase const &other) = delete; virtual ~SemBase(); Tag tag() const; template typename Trait::ReturnType as() const; protected: SemBase(Tag tag); }; //= inline Tag SemBase::tag() const { return d_tag; } inline SemBase::SemBase(Tag tag) : d_tag(tag) {} // The Semantic class template is derived from SemBase. It always defines // its data member as mutable (I can't do this under template control, but // I could define, e.g., two anonymous structs holding, respectively, a // mutable and non-mutable DataType data member, but Semantic isn't doing // anything with d_data anyway, so by always declaring d_data as mutable // it can be returned from the conversion operator, which itself is a // const member. /// Again: Semantic is extremely light-weight. Only initialization and // conversion to the embedded data member need to be supported. //SEMANTIC template class Semantic: public SemBase { typedef typename Trait::DataType DataType; enum: bool { isMutable = Trait::isMutable }; mutable DataType d_data; public: typedef typename Trait::ReturnType ReturnType; Semantic(DataType const &data); operator ReturnType() const; }; template Semantic::Semantic(DataType const &data) : SemBase(tg_), d_data(data) {} template Semantic::operator ReturnType() const { return d_data; } //= // The 'as' member simply performs the required downcast. It is // implemented here, since it refers to Semantic. Since this class // has just been defined, no forward declaration is required anymore. //AS template inline typename Trait::ReturnType SemBase::as() const { return dynamic_cast const &>(*this); } //= #endif c++-annotations-10.6.0/yo/concrete/poly2/sembase/destructor.cc0000644000175000017500000000005513005340355023105 0ustar frankfrank#include "sembase.h" SemBase::~SemBase() {} c++-annotations-10.6.0/yo/concrete/poly2/main.cc0000644000175000017500000000011213005340355020206 0ustar frankfrank#include "main.ih" int main() { Parser parser; parser.parse(); } c++-annotations-10.6.0/yo/concrete/poly2/main.ih0000644000175000017500000000010213005340354020217 0ustar frankfrank#include #include #include "parser/parser.h" c++-annotations-10.6.0/yo/concrete/header.yo0000644000175000017500000000030212745054222017515 0ustar frankfrank Here is the specification of the header-section of our tt(bison++) specification file. Note the inclusion of the scanner's header file. verbinclude(-a parser/parser/gramspec/header.gr0) c++-annotations-10.6.0/yo/concrete/fdninbuf.yo0000644000175000017500000001024012745054221020061 0ustar frankfrank How complex would things get if we decided to use a buffer of substantial size? Not that complex. The following class allows us to specify the size of a buffer, but apart from that it is basically the same class as tt(IFdStreambuf) developed in the previous section. To make things a bit more interesting, in the class ti(IFdNStreambuf) developed here, the member hi(xsgetn)tt(streambuf::xsgetn) is also overridden, to optimize reading a series of characters. Also a default constructor is provided that can be used in combination with the tt(open) member to construct an tt(istream) object before the file descriptor becomes available. In that case, once the descriptor becomes available, the tt(open) member can be used to initiate the object's buffer. Later, in section ref(FORK), we'll encounter such a situation. To save some space, the success of various calls was not checked. In `real life' implementations, these checks should of course not be omitted. The class tt(IFdNStreambuf) has the following characteristics: itemization( it() Its member functions use low-level functions operating on file descriptors. So apart from tt(streambuf) the tthi(unistd.h) header file must have been read by the compiler before its member functions can be compiled. it() As usual, it is derived from hi(streambuf)tt(std::streambuf). it() Like the class tt(IFdStreambuf) (section ref(IFDBUF)), its data members are protected. Since the buffer's size is configurable, this size is kept in a dedicated data member, tt(d_bufsize): verbinclude(//CLASS examples/ifdnbuf.h) it() The default constructor does not allocate a buffer. It can be used to construct an object before the file descriptor becomes known. A second constructor simply passes its arguments to tt(open). tt(Open) will then initialize the object so that it can actually be used: verbinclude(//CONS examples/ifdnbuf.h) it() Once the object has been initialized by tt(open), its destructor will both delete the object's buffer and use the file descriptor to close the device: verbinclude(//DESTR examples/ifdnbuf.h) Even though the device is closed in the above implementation this may not always be desirable. In cases where the open file descriptor is already available the intention may be to use that descriptor repeatedly, each time using a newly constructed tt(IFdNStreambuf) object. It is left as an exercise to the reader to change this class in such a way that the device may optionally be closed. This approach was followed in, e.g., the url(Bobcat library)(http://fbb-git.github.io/bobcat/). hi(Bobcat library)hi(http://fbb-git.github.io/bobcat/) it() The tt(open) member simply allocates the object's buffer. It is assumed that the calling program has already opened the device. Once the buffer has been allocated, the base class member ti(setg) is used to ensure that hi(eback) tt(streambuf::eback) hi(gptr) tt(streambuf::gptr) and hi(egptr) tt(streambuf::egptr) return correct values: verbinclude(//OPEN examples/ifdnbuf.h) it() The overridden member tt(underflow) is implemented almost identically to tt(IFdStreambuf)'s (section ref(IFDBUF)) member. The only difference is that the current class supports buffers of larger sizes. Therefore, more characters (up to tt(d_bufsize)) may be read from the device at once: verbinclude(//UFLOW examples/ifdnbuf.h) it() Finally ti(xsgetn) is overridden. In a loop, tt(n) is reduced until 0, at which point the function terminates. Alternatively, the member returns if tt(underflow) fails to obtain more characters. This member optimizes the reading of series of characters. Instead of calling hi(sbumpc) tt(streambuf::sbumpc) tt(n) times, a block of tt(avail) characters is copied to the destination, using hi(gbump)tt(streambuf::gbump) to consume tt(avail) characters from the buffer using one function call: verbinclude(//XSGETN examples/ifdnbuf.h) ) The member function ti(xsgetn) is called by hi(sgetn)tt(streambuf::sgetn), which is a tt(streambuf) member. Here is an example illustrating the use of this member function with an tt(IFdNStreambuf) object: verbinclude(-a examples/ifdnbuf.cc) c++-annotations-10.6.0/yo/concrete/codegeneration.yo0000644000175000017500000000213012745054221021253 0ustar frankfrankThe calculator is built using tt(bisonc++) and tt(flexc++). Here is the implentation of the calculator's tt(main) function: verbinclude(-a bisonc++/calculator.cc) The parser's files tt(parse.cc) and tt(parserbase.h) are generated by the command: verb( bisonc++ grammar ) The file tt(parser.h) is created only once, to allow the developer to add members to the tt(Parser) class occe the need for them arises. The program ti(flexc++) is used to create a lexical scanner: verb( flexc++ lexer ) On i(Unix) systems a command like verb( g++ --std=c++14 -Wall -o calc *.cc -lbobcat -s ) can be used to compile and link the source of the main program and the sources produced by the scanner and parser generators. The example uses the tt(A2x) class, which is part of the ti(bobcat) library (cf. section ref(BUILDFLEX)) (the bobcat library is available on systems offering either tt(bisonc++) or tt(flexc++)). tt(Bisonc++) can be downloaded from hi(http://bisoncpp.sourceforge.net/) tlurl(http://bisoncpp.sourceforge.net/). c++-annotations-10.6.0/yo/concrete/sembase.yo0000644000175000017500000000227412745054222017716 0ustar frankfrankThe polymorphic semantic value in fact implements a type-safe hi(union: polymorphic) emi(polymorphic semantic union). In bf(C++) this data type does not exist, but the parser may handle semantic values as unions. It always knows the actual kind of semantic value that's used at a particular point in the grammar. If not, it can inspect tt(SemBase's) tag fields. The parser, knowing what the actual semantic type is, may then perform a i(downcast), resulting in a em(very) lightweight tt(SemBase) base class. The tt(SemBase) class only requires one virtual member: an empty virtual destructor. Downcasting is encapsulated in tt(SemBase)'s 'tt(as)' member. Consequently, the parser, defining its semantic value as an tt(spSembase) (i.e., a tt(shared_ptr) to a tt(Sembase), cf. section ref(BISONSEM)), can then use constructions like verb( $1->as() ) to access the tt(std::string) that is stored in the actual semantic value to which tt($1) points. Here is tt(SemBase)'s class interface (the implementation of its `tt(as)' member template follows, implementations of its remaining members are trivial): verbinclude(//SEMBASE poly2/sembase/sembase.h) c++-annotations-10.6.0/yo/concrete/usingflex.yo0000644000175000017500000000400412745054222020274 0ustar frankfrankThe lexical scanner developed in this section is used to monitor the production of a file from several subfiles. The setup is as follows: the input-language defines tt(#include) directives, followed by a text string specifying the file (path) which should be included at the location of the tt(#include). In order to avoid complexities irrelevant to the current example, the format of the tt(#include) statement is restricted to the form tt(#include ). The file specified between the pointed brackets should be available at the location indicated by tt(filepath). If the file is not available, the program terminates after issuing an error message. The program is started with one or two filename arguments. If the program is started with just one filename argument, the output is written to the standard output stream tt(cout). Otherwise, the output is written to the stream whose name is given as the program's second argument. The program defines a maximum i(nesting depth). Once this maximum is exceeded, the program terminates after issuing an error message. In that case, the filename stack indicating where which file was included is printed. An additional feature of the program is that (standard bf(C++)) comment-lines are ignored. Include-directives in comment-lines are also ignored. The program is created in five major steps: itemization( it() First, the file tt(lexer) is constructed, containing the input-language specifications. it() From the specifications in tt(lexer) the requirements for the tt(class Scanner) evolve. The tt(Scanner) class derives from the base class ti(ScannerBase) generated by ti(flexc++). it() Next, tt(main) is constructed. A tt(Scanner) object is created inspecting the command-line arguments. If successful, the scanner's member tt(lex) is called to produce the program's output. it() Now that the global setup of the program has been specified, the member functions of the various classes are implemented. it() Finally, the program is compiled and linked. ) c++-annotations-10.6.0/yo/concrete/semantic.yo0000644000175000017500000000221712745054222020077 0ustar frankfrankFinally we reach the class template tt(Semantic), publicly derived from tt(SemBase). This class template only requires one tt(Tag) non-type parameter, defining the kind of data that can be handled by objects of the class. Like tt(SemBase) the class tt(Semantic) is extremely light-weight. Only initialization and a conversion operator to the encapsulated data member must be supported. tt(Semantic) defines its data member as mutable, which is fine as the class itself doesn't manipulate its data, and proper access to the data is guaranteed by its tt(operator ReturnType() const) conversion operator. tt(ReturnType), of course, is obtained through the tt(Trait) trait class template. Here is the class's interface and member definitions: verbinclude(//SEMANTIC poly2/sembase/sembase.h) To access the information stored in a semantic value class the hi(as (SemBase::as)) tt(SemBase::as) member template is used. This member template is provided with a tag value and returns the value stored inside the actual tt(Semantic) object. Its use was shown in the previous section. Here is its implementation: verbinclude(//AS poly2/sembase/sembase.h) c++-annotations-10.6.0/yo/concrete/tagtrait.yo0000644000175000017500000000072512745054222020115 0ustar frankfrankThe ti(TagTrait) trait class defines, for each of the distinct semantic values, what the actual data type (tt(DataType)) is that is associated with the tag and whether the data are mutable or immutable. Mutable data on the parser's semantic stack may be modified, immutable data may not. Here is the tt(TagTrait) meta template struct template and its specializations for the three data types used by our parser. verbinclude(//TRAITTAG poly2/sembase/sembase.h) c++-annotations-10.6.0/yo/concrete/bisonflexspec.yo0000644000175000017500000000067312745054221021143 0ustar frankfrank The flex-specification file used by the calculator is simple: blanks are ignored, single characters are returned, and numeric values are returned as either tt(Parser::INT) or tt(Parser::DOUBLE) tokens. The tt(flexc++) directive tt(%interactive) is provided since the calculator is a program actively interacting with its human user. Here is the complete tt(flexc++) specification file: verbinclude(-a bisonc++/scanner/lexer) c++-annotations-10.6.0/yo/concrete/parser.yo0000644000175000017500000000320412745054222017565 0ustar frankfrankAs noted in the previous section, Bisonc++'s grammar specification declares tt(%stype), the semantic value type, as tt(spSembase). A simple grammar is defined for this illustrative example. The grammar expects input according to the following rule: verb( rule: IDENTIFIER '(' IDENTIFIER ')' ';' | IDENTIFIER '=' INT ';' ; ) The rule's actions simply echo the received identifiers and tt(int) values to tt(cout). Here is an example of a decorated production rule, where due to tt(Semantic)'s overloaded insertion operator the insertion of the object controlled by tt(Semantic) is automatically performed: verb( IDENTIFIER '=' INT ';' { cout << $1 << " " << $3 << '\n'; } ) Bisonc++'s parser stores em(all) semantic values on its semantic values stack (irrespective of the number of tokens that were defined in a particular production rule). At any time em(all) semantic values associated with previously recognized tokens are available in an action block. Once the semantic value stack is reduced, the tt(Semantic) class's destructor takes care of the proper destruction of the objects controlled by its tt(shared_ptr) base class. In order to assign the parser's latest semantic value, the scanner is given access to that data member, which is the parser's data member tt(d_val__). Its address or reference can be passed to the scanner when it is constructed. E.g., if the scanner's constructor expects an tt(STYPE__ &) argument, then the parser's constructor could simply be implemented as: verb( inline Parser::Parser() : d_scanner(d_val__) {} ) c++-annotations-10.6.0/yo/concrete/parents.yo0000644000175000017500000000606212745054222017752 0ustar frankfrank The member function tt(fork) calls the system function tt(fork) (Caution: since the system function tt(fork) is called by a member function having the same name, the tt(::) scope resolution operator must be used to prevent a recursive call of the member function itself). The function tt(::fork)'s return value determines whether tt(parentProcess) or tt(childProcess) is called. Maybe redirection is necessary. tt(Fork::fork)'s implementation calls tt(childRedirections) just before calling tt(childProcess), and tt(parentRedirections) just before calling tt(parentProcess): verbinclude(-a examples/fork.cc) In tt(fork.cc) the class's emi(internal header file) tt(fork.ih) is included. This header file takes care of the inclusion of the necessary system header files, as well as the inclusion of tt(fork.h) itself. Its implementation is: verbinclude(-a examples/fork.ih) Child processes should not return: once they have completed their tasks, they should terminate. This happens automatically when the child process performs a call to a member of the ti(exec...) family, but if the child itself remains active, then it must make sure that it terminates properly. A child process normally uses ti(exit) to terminate itself, but note that tt(exit) prevents the activation of destructors of objects hi(destructor: called at exit) hi(exit: calling destructors) defined at the same or more superficial nesting levels than the level at which tt(exit) is called. Destructors of globally defined objects em(are) activated when tt(exit) is used. When using tt(exit) to terminate tt(childProcess), it should either itself call a support member function defining all nested objects it needs, or it should define all its objects in a compound statement (e.g., using a tt(throw) block) calling tt(exit) beyond the compound statement. Parent processes should normally wait for their children to complete. Terminating child processes inform their parents that they are about to terminate by sending a emi(signal) that should be caught by their parents. If child processes terminate and their parent processes do not catch those signals then such child processes remain visible as so-called emi(zombie) processes. If parent processes must wait for their children to complete, they may call the member tt(waitForChild). This member returns the exit status of a child process to its parent. There exists a situation where the em(child) process em(continues) to live, but the em(parent) dies. This is a fairly natural event: parents tend to die before their children do. In our context (i.e. bf(C++)), this is called a emi(daemon) program. In a daemon the parent process dies and the child program continues to run as a child of the basic ti(init) process. Again, when the child eventually dies a signal is sent to its `step-parent' ti(init). This does not create a zombie as tt(init) catches the termination signals of all its (step-) children. The construction of a daemon process is very simple, given the availability of the class tt(Fork) (cf. section ref(DAEMON)). c++-annotations-10.6.0/yo/concrete/bisonc++/0000755000175000017500000000000013005340354017316 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/bisonc++/build0000755000175000017500000000113112745054221020344 0ustar frankfrank#!/bin/bash case "$1" in ("") echo " usage: 'build prog' to build the program, 'build clean' to cleanup " exit 1 ;; (prog) cd parser bisonc++ grammar || exit 1 cd ../scanner flexc++ lexer || exit 1 cd .. g++ --std=c++11 -Wall -ocalc *.cc */*.cc -lbobcat || exit 1 echo " ready; run the program as './calc' " ;; (clean) rm -f calc cd parser rm -f parse.cc parserbase.h cd ../scanner rm -f lex.cc scannerbase.h echo " done " ;; esac exit 1 c++-annotations-10.6.0/yo/concrete/bisonc++/parser/0000755000175000017500000000000013005340354020612 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/bisonc++/parser/parser.h0000644000175000017500000000307713005340354022266 0ustar frankfrank#ifndef Parser_h_included #define Parser_h_included #include #include #include #include "parserbase.h" #include "../scanner/scanner.h" #undef Parser class Parser: public ParserBase { std::ostringstream d_rpn; // $insert scannerobject Scanner d_scanner; public: int parse(); private: template Type exec(char c, Type left, Type right); template Type neg(Type op); template Type convert(); void display(int x); void display(double x); void done() const; void reset(); void error(char const *msg); int lex(); void print(); static double d(int i); // support functions for parse(): void executeAction(int d_ruleNr); void errorRecovery(); int lookup(bool recovery); void nextToken(); void print__(); }; inline double Parser::d(int i) { return i; } template Type Parser::exec(char c, Type left, Type right) { d_rpn << " " << c << " "; return c == '*' ? left * right : left + right; } template Type Parser::neg(Type op) { d_rpn << " n "; return -op; } template Type Parser::convert() { Type ret = FBB::A2x(d_scanner.matched()); d_rpn << " " << ret << " "; return ret; } inline void Parser::error(char const *msg) { std::cerr << msg << '\n'; } inline int Parser::lex() { return d_scanner.lex(); } inline void Parser::print() {} #endif c++-annotations-10.6.0/yo/concrete/bisonc++/parser/display1.cc0000644000175000017500000000023513005340355022650 0ustar frankfrank#include "parser.ih" void Parser::display(int x) { cerr << "RPN: " << d_rpn.str() << '\n'; cerr << "int: " << x << '\n'; d_rpn.str(string()); } c++-annotations-10.6.0/yo/concrete/bisonc++/parser/display2.cc0000644000175000017500000000024313005340355022650 0ustar frankfrank#include "parser.ih" void Parser::display(double x) { cerr << "RPN: " << d_rpn.str() << '\n'; cerr << "double: " << x << '\n'; d_rpn.str(string()); } c++-annotations-10.6.0/yo/concrete/bisonc++/parser/reset.cc0000644000175000017500000000013313005340355022241 0ustar frankfrank#include "parser.ih" void Parser::reset() { d_rpn.clear(); d_rpn.str(string()); } c++-annotations-10.6.0/yo/concrete/bisonc++/parser/parser.ih0000644000175000017500000000055113005340354022431 0ustar frankfrank// include this file in the sources of the class Parser, // and add any includes etc. that are only needed for // the compilation of these sources. // include the file defining the parser class: #include "parser.h" #include #include #include using FBB::A2x; using std::string; using std::cerr; using std::cout; using std::endl; c++-annotations-10.6.0/yo/concrete/bisonc++/parser/grammar0000644000175000017500000000352412745054221022174 0ustar frankfrank//DECLARATION %filenames parser %scanner ../scanner/scanner.h %union { int i; double d; }; %token INT DOUBLE %type intExpr %type doubleExpr %left '+' %left '*' %right UnaryMinus //= %% //RULES lines: lines line | line ; line: intExpr '\n' { display($1); } | doubleExpr '\n' { display($1); } | '\n' { done(); } | error '\n' { reset(); } ; intExpr: intExpr '*' intExpr { $$ = exec('*', $1, $3); } | intExpr '+' intExpr { $$ = exec('+', $1, $3); } | '(' intExpr ')' { $$ = $2; } | '-' intExpr %prec UnaryMinus { $$ = neg($2); } | INT { $$ = convert(); } ; doubleExpr: doubleExpr '*' doubleExpr { $$ = exec('*', $1, $3); } | doubleExpr '*' intExpr { $$ = exec('*', $1, d($3)); } | intExpr '*' doubleExpr { $$ = exec('*', d($1), $3); } | doubleExpr '+' doubleExpr { $$ = exec('+', $1, $3); } | doubleExpr '+' intExpr { $$ = exec('+', $1, d($3)); } | intExpr '+' doubleExpr { $$ = exec('+', d($1), $3); } | '(' doubleExpr ')' { $$ = $2; } | '-' doubleExpr %prec UnaryMinus { $$ = neg($2); } | DOUBLE { $$ = convert(); } ; //= c++-annotations-10.6.0/yo/concrete/bisonc++/parser/done.cc0000644000175000017500000000013413005340355022045 0ustar frankfrank#include "parser.ih" void Parser::done() const { cout << "Good bye\n"; ACCEPT(); } c++-annotations-10.6.0/yo/concrete/bisonc++/scanner/0000755000175000017500000000000013005340353020746 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/bisonc++/scanner/scanner.ih0000644000175000017500000000011513005340354022717 0ustar frankfrank#include "scanner.h" #include "../parser/parserbase.h" // end of scanner.ih c++-annotations-10.6.0/yo/concrete/bisonc++/scanner/scanner.h0000644000175000017500000000170013005340354022547 0ustar frankfrank// Generated by Flexc++ V0.94.00 on Fri, 24 Feb 2012 10:34:13 +0100 #ifndef Scanner_H_INCLUDED_ #define Scanner_H_INCLUDED_ // $insert baseclass_h #include "scannerbase.h" // $insert classHead class Scanner: public ScannerBase { public: explicit Scanner(std::istream &in = std::cin, std::ostream &out = std::cout); // $insert lexFunctionDecl int lex(); private: int lex__(); int executeAction__(size_t ruleNr); void print(); void preCode(); // re-implement this function for code that must // be exec'ed before the patternmatching starts }; // $insert scannerConstructors inline Scanner::Scanner(std::istream &in, std::ostream &out) : ScannerBase(in, out) {} inline void Scanner::preCode() { // optionally replace by your own code } inline void Scanner::print() { print__(); } #endif // Scanner_H_INCLUDED_ c++-annotations-10.6.0/yo/concrete/bisonc++/scanner/lexer0000644000175000017500000000040112745054221022011 0ustar frankfrank%interactive %filenames scanner %% [ \t] // ignored [0-9]+ return Parser::INT; "."[0-9]* | [0-9]+("."[0-9]*)? return Parser::DOUBLE; .|\n return matched()[0]; c++-annotations-10.6.0/yo/concrete/bisonc++/calculator.cc0000644000175000017500000000041713005340355021761 0ustar frankfrank#include "parser/parser.h" using namespace std; int main() { Parser parser; cout << "Enter (nested) expressions containing ints, doubles, *, + and " "unary -\n" "operators. Enter an empty line to stop.\n"; return parser.parse(); } c++-annotations-10.6.0/yo/concrete/daemon.yo0000644000175000017500000000221012745054221017527 0ustar frankfrank Applications exist in which the only purpose of ti(fork) is to start a child process. The parent process terminates immediately after spawning the child process. If this happens, the child process continues to run as a child process of ti(init), the always running first process on i(Unix) systems. Such a process is often called a emi(daemon), running as a i(background process). Although the next example can easily be constructed as a plain bf(C) program, it was included in the bf(C++) Annotations because it is so closely related to the current discussion of the tt(Fork) class. I thought about adding a tt(daemon) member to that class, but eventually decided against it because the construction of a daemon program is very simple and requires no features other than those currently offered by the class tt(Fork). Here is an example illustrating the construction of such a daemon program. Its child process doesn't do ti(exit) but tt(throw 0) which is caught by the tt(catch) clause of the child's tt(main) function. Doing this ensures that any objects defined by the child process are properly destroyed: verbinclude(-a examples/daemon.cc) c++-annotations-10.6.0/yo/concrete/redirection.yo0000644000175000017500000000316512745054222020606 0ustar frankfrank Earlier, in section ref(REDIR) streams were hi(redirection) redirected using the hi(rdbuf)tt(ios::rdbuf) member function. By assigning the tt(streambuf) of a stream to another stream, both stream objects access the same tt(streambuf), thus implementing redirection at the level of the programming language itself. This may be fine within the context of a bf(C++) program, but once we leave that context the redirection terminates. The operating system does not know about tt(streambuf) objects. This situation is encountered, e.g., when a program uses a ti(system) call to start a subprogram. The example program at the end of this section uses bf(C++) redirection to redirect the information inserted into ti(cout) to a file, and then calls verb( system("echo hello world") ) to echo a well-known line of text. Since tt(echo) writes its information to the standard output, this would be the program's redirected file if the operating system would recognize bf(C++)'s redirection. But redirection doesn't happen. Instead, tt(hello world) still appears at the program's standard output and the redirected file is left untouched. To write tt(hello world) to the redirected file redirection must be realized at the operating system level. Some operating systems (e.g., i(Unix) and friends) provide system calls like ti(dup) and ti(dup2) to accomplish this. Examples of the use of these system calls are given in section ref(PIPE). Here is the example of the em(failing redirection) at the system level following bf(C++) redirection using tt(streambuf) redirection: verbinclude(-a examples/noredir.cc) c++-annotations-10.6.0/yo/concrete/scancompile.yo0000644000175000017500000000132612745054222020571 0ustar frankfrank The final program is constructed in two steps. These steps are given for a i(Unix) system, on which ti(flexc++) and the i(Gnu) bf(C++) compiler ti(g++) have been installed: itemization( it() First, the lexical scanner's source is created using tt(flexc++). For this the following command can be given: verb( flexc++ lexer ) it() Next, all sources are compiled and linked: verb( g++ --std=c++14 -Wall *.cc ) ) tt(Flexc++) can be downloaded from hi(http://flexcpp.sourceforge.net/) tlurl(http://flexcpp.sf.net/), and requires the ti(bobcat) library, which can be downloaded from hi(http://fbb-git.github.io/bobcat//) tlurl(http://bobcat.sf.net/). c++-annotations-10.6.0/yo/concrete/fdinseek.yo0000644000175000017500000000514712745054221020070 0ustar frankfrank When devices support em(seek operations), classes derived from hi(streambuf) tt(std::streambuf) should override the members hi(seekoff) tt(streambuf::seekoff) and hi(seekpos)tt(streambuf::seekpos). The class ti(IFdSeek), developed in this section, can be used to read information from devices supporting seek operations. The class tt(IFdSeek) was derived from tt(IFdStreambuf), so it uses a character buffer of just one character. The facilities to perform seek operations, which are added to our new class tt(IFdSeek), ensure that the input buffer is reset when a seek operation is requested. The class could also be derived from the class tt(IFdNStreambuf). In that case the arguments to reset the input buffer must be adapted so that its second and third parameters point beyond the available input buffer. Let's have a look at the characteristics of tt(IFdSeek): itemization( it() As mentioned, tt(IFdSeek) is derived from tt(IFdStreambuf). Like the latter class, tt(IFdSeek)'s member functions use facilities declared in tt(unistd.h). So, the header file tthi(unistd.h) must have been read by the compiler before it can compile the class's members functions. To reduce the amount of typing when specifying types and constants from tt(streambuf) and hi(ios)tt(std::ios), several tt(typedef)s are defined by the class. These typedefs refer to types that are defined in the header file tthi(ios), which must therefore also be included before the compiler can compile tt(IFdSeek)'s class interface: verbinclude(//CLASS examples/fdinseek.h) it() The class has a very basic interface. Its (only) constructor expects the device's i(file descriptor). It has no special tasks to perform and just calls its i(base class) constructor: verbinclude(//CONS examples/fdinseek.h) it() The member ti(seek_off) is responsible for performing the actual seek operations. It calls ti(lseek) to seek a new position in a device whose file descriptor is known. If seeking succeeds, ti(setg) is called to define an already empty buffer, so that the base class's tt(underflow) member refills the buffer at the next input request. verbinclude(//SEEKOFF examples/fdinseek.h) it() Finally, the companion function ti(seekpos) is overridden as well: it is actually defined as a call to tt(seekoff): verbinclude(//SEEKPOS examples/fdinseek.h) ) Here is an example of a program using the class tt(IFdSeek). If this program is given its own source file using input redirection then seeking is supported (and with the exception of the first line, every other line is shown twice): verbinclude(-a examples/fdinseek.cc) c++-annotations-10.6.0/yo/concrete/lvalues/0000755000175000017500000000000013005340354017366 5ustar frankfrankc++-annotations-10.6.0/yo/concrete/lvalues/lvalues.cc0000644000175000017500000001121013005340355021344 0ustar frankfrank#include #include using namespace std; class Data { friend class Wrapper; // Our Wrapper class is allowed to access our data // too. vector d_v; // here are Data's data public: class Wrapper { Data & d_data; size_t d_index; public: // For all situations in which data[x] is used as lvalue, // an operator must be defined accepting data[x] as lvalue and // all acceptable types as rvalue. Here I've defined two, but // generalizations are straightforward: Wrapper &operator=(Wrapper const &other); // Use our (*this) data as lvalue, the other's data as // rvalue. This is just one situation where our data are // used as lvalue. If data[x] += data[y] is needed too, // then that operator must be defined as well. Wrapper &operator=(int value); // Our data as lvalue. This again is but one example. To // implement data[x] += y etc, those operators must be // overloaded too. // There's only one situation where data[x] is used as rvalue: // when it's returning its data[x] element. This is // accomplished by defining the appropriate conversion // operator: operator int() const; // Our data as rvalue. Can't use things like int &n = // data[3] or int *p = &data[3] here, because the data[3] // expression is parsed as an rvalue, returning an int (in // this case). so if you want to use that, define an // explicit reference and/or pointer returning member, // like int &n = data.ref(3). private: // nobody but Data has anything to do with Wrapper's // constructor so it's made private, declaring Data as its // friend. friend class Data; Wrapper(Data &data, size_t index); }; Data(); int operator[](size_t index) const; // Always rvalue: operator[] of const objects Wrapper operator[](size_t index); // With non-const objects: the Wrapper is returned, to which // a value can be assigned, in which case it's is an lvalue, or // whose value can be requested, in which case the int-conversion // operator is called. }; // I've defined all members inline, although you shouldn't do so in real life. inline Data::Wrapper &Data::Wrapper::operator=(Wrapper const &other) { cout << "data[x] = data[y], lvalue = rvalue\n"; d_data.d_v[d_index] = other.d_data.d_v[other.d_index]; cout << "assignment performed\n"; return *this; } inline Data::Wrapper &Data::Wrapper::operator=(int value) { cout << "data[x] = y, lvalue = expression\n"; d_data.d_v[d_index] = value; return *this; } inline Data::Wrapper::operator int() const { cout << "using the conversion operator, " "returning an rvalue\n"; return d_data.d_v[d_index]; } inline Data::Wrapper::Wrapper(Data &data, size_t index) : d_data(data), d_index(index) {} inline Data::Data() : d_v(5) { for (size_t idx = 0; idx < 5; ++idx) // assign some values d_v[idx] = 2 * idx; } inline int Data::operator[](size_t index) const { cout << "rvalue-only from const object\n"; return d_v[index]; } inline Data::Wrapper Data::operator[](size_t index) { return Wrapper(*this, index); } int main() { Data test; // a non-const object Data const testConst; // a const object (normally via, e.g., a // 'Data const &' parameter // insert some (r)values: cout << "Inserting rvalues:\n" << test[1] << " " << test[2] << "\n\n"; cout << "data[x] to data[y] assignment:\n"; test[1] = test[2]; cout << "Resulting in: " << test[1] << " " << test[2] << "\n\n"; cout << "Assignment from testConst:\n"; test[1] = testConst[4]; cout << "Resulting in: " << test[1] << "\n\n"; cout << "Direct assignment to test[0] (now " << test[0] << ") as an lvalue:\n"; test[0] = 11; cout << "Resulting in: " << test[0] << "\n\n"; cout << "Using test[1] (= " << test[1] << " + 2) in an expression as rvalue\n"; int n = test[1] + 2; } c++-annotations-10.6.0/yo/concrete/shandler.yo0000644000175000017500000000364212745054222020077 0ustar frankfrankThe array tt(s_handler), storing pointers to functions needs to be initialized as well. This can be accomplished in several ways: itemization( it() Since the tt(Commands) enumeration only specifies a fairly limited set of commands, compile-time initialization could be considered: verbinclude(//HANDLER examples/monitor/data.compiletime) The advantage of this is that it's simple, not requiring any run-time effort. The disadvantage is of course relatively complex maintenance. If for some reason tt(Commands) is modified, tt(s_handler) must be modified as well. In cases like these, compile-time initialization often is asking for trouble. There is a simple alternative though. it() Looking at tt(Monitor)'s interface we see a static data member tt(s_initialize) and a static member function tt(initialize). The static member function handles the initialization of the tt(s_handler) array. It explicitly assigns the array's elements and any modification in ordering of tt(enum Commands)' values is automatically accounted for by recompiling tt(initialize): verbinclude(//INIT examples/monitor/monitor.cc) The member tt(initialize) is a static member and so it can be called to initialize tt(s_initialize), a static tt(int) variable. The initialization is enforced by placing the initialization statement in the source file of a function that is known to be executed. It could be tt(main), but if we're tt(Monitor)'s maintainers and only have control over the library containing tt(Monitor)'s code then that's not an option. In those cases the source file containing the destructor is a em(very) good candidate. If a class has only one constructor and it's em(not) defined inline then the constructor's source file is a good candidate as well. In tt(Monitor)'s current implementation the initialization statement is put in tt(run)'s source file, reasoning that tt(s_handler) is only needed when tt(run) is used. ) c++-annotations-10.6.0/yo/concrete/iterators.yo0000644000175000017500000001104012745054222020302 0ustar frankfrankIn section ref(RANDOMIT) the construction of iterators and reverse iteraters was discussed. In that section the iterator was constructed as an inner class in a class derived from a vector of pointers to strings. An object of this nested iterator class handles the dereferencing of the pointers stored in the vector. This allowed us to sort the em(strings) pointed to by the vector's elements rather than the em(pointers). A drawback of this is that the class implementing the iterator is closely tied to the derived class as the iterator class was implemented as a nested class. What if we would like to provide any class derived from a container class storing pointers with an iterator handling pointer-dereferencing? In this section a variant of the earlier (nested class) approach is discussed. Here the iterator class is defined as a class template, hi(iterator: as class template) not only parameterizing the data type to which the container's elements point but also the container's iterator type itself. Once again, we concentrate on developing a emi(RandomIterator) as it is the most complex iterator type. Our class is named tt(RandomPtrIterator), indicating that it is a random iterator operating on pointer values. The class template defines three template type parameters: itemization( it() The first parameter specifies the derived class type (tt(Class)). Like before, tt(RandomPtrIterator)'s constructor is private. Therefore tt(friend) declarations are needed to allow client classes to construct tt(RandomPtrIterators). However, a tt(friend class Class) cannot be used as template parameter types cannot be hi(friend: using a template parameter) used in tt(friend class ...) declarations. But this is a minor problem as not every member of the client class needs to construct iterators. In fact, only tt(Class)'s tt(begin) and tt(end) members must construct iterators. Using the template's first parameter, friend declarations can be specified for the client's tt(begin) and tt(end) members. it() The second template parameter parameterizes the container's iterator type (tt(BaseIterator)); it() The third template parameter indicates the data type to which the pointers point (tt(Type)). ) tt(RandomPtrIterator) has one private data member, a tt(BaseIterator). Here is the class interface and the constructor's implementation: verbinclude(//HEAD examples/iterator.h) Looking at its tt(friend) declarations, we see that the members tt(begin) and tt(end) of a class tt(Class), returning a tt(RandomPtrIterator) object for the types tt(Class, BaseIterator) and tt(Type) are granted access to tt(RandomPtrIterator)'s private constructor. That is exactly what we want. The tt(Class)'s tt(begin) and tt(end) members are declared as em(bound friends). All tt(RandomPtrIterator)'s remaining members are public. Since tt(RandomPtrIterator) is just a generalization of the nested class tt(iterator) developed in section ref(RANDOMIT), re-implementing the required member functions is easy and only requires us to change tt(iterator) into tt(RandomPtrIterator) and to change tt(std::string) into tt(Type). For example, tt(operator<), defined in the class tt(iterator) as verbinclude(//CMP ../classtemplates/examples/stringptr.h) is now implemented as: verbinclude(//CMP examples/iterator.h) Some additional examples: tt(operator*), defined in the class tt(iterator) as verbinclude(//OP* ../classtemplates/examples/stringptr.h) is now implemented as: verbinclude(//OP* examples/iterator.h) The pre- and postfix increment operators are now implemented as: verbinclude(//INC examples/iterator.h) Remaining members can be implemented accordingly, their actual implementations are left as exercises to the reader (or can be obtained from the tt(cplusplus.yo.zip) archive, of course). Re-implementing the class tt(StringPtr) developed in section ref(RANDOMIT) is not difficult either. Apart from including the header file defining the class template tt(RandomPtrIterator), it only requires a single modification. Its tt(iterator) typedef must now be associated with a tt(RandomPtrIterator). Here is the full class interface and the class's inline member definitions: verbinclude(-a examples/stringptr.h) Including tt(StringPtr)'s modified header file into the program given in section ref(REVERSEIT) results in a program behaving identically to its earlier version. In this case tt(StringPtr::begin) and tt(StringPtr::end) return iterator objects constructed from a template definition. c++-annotations-10.6.0/yo/concrete/fdinbuf.yo0000644000175000017500000000414512745054221017712 0ustar frankfrank When deriving a class (e.g., ti(IFdStreambuf)) from tt(streambuf) using a buffer of one character, at least its member hi(underflow) tt(streambuf::underflow) should be overridden, as this member eventually receives all requests for input. The member hi(setg) tt(streambuf::setg) is used to inform the tt(streambuf) base class of the size and location of the input buffer, so that it is able to set up its input buffer pointers accordingly. This ensures that hi(eback) tt(streambuf::eback), hi(gptr) tt(streambuf::gptr), and hi(egptr) tt(streambuf::egptr) return correct values. The class tt(IFdStreambuf) is designed like this: itemization( it() Its member functions use low-level functions operating on file descriptors. Therefore, in addition to tt(streambuf), the tthi(unistd.h) header file must have been read by the compiler before its member functions can be compiled. it() Like most classes designed for input operations, this class is derived from hi(streambuf)tt(std::streambuf) as well. it() The class defines two data members, one of them a fixed-sized one character buffer. The data members are defined as ti(protected) data members so that derived classes (e.g., see section ref(IFDSEEK)) can access them. Here is the full class interface: verbinclude(//CLASS examples/ifdbuf.h) it() The constructor initializes the buffer. However, the initialization sets ti(gptr)'s return value equal to ti(egptr)'s return value. This implies that the buffer is empty so tt(underflow) is immediately called to fill the buffer: verbinclude(//CONS examples/ifdbuf.h) it() Finally tt(underflow) is overridden. The buffer is refilled by reading from the file descriptor. If this fails (for whatever reason), endOfFile() is returned. More sophisticated implementations could act more intelligently here, of course. If the buffer could be refilled, ti(setg) is called to set up tt(streambuf)'s buffer pointers correctly: verbinclude(//UFLOW examples/ifdbuf.h) ) The following tt(main) function shows how tt(IFdStreambuf) can be used: verbinclude(//MAIN examples/ifdbuf.cc) c++-annotations-10.6.0/yo/concrete/semscanner.yo0000644000175000017500000000042312745054222020427 0ustar frankfrankThe scanner for the polymorphic parser is simple and only needs to recognize numbers, identifiers and some simple characters, returned as character tokens. Here is the scanner's complete specification file, as used by ti(flexc++): verbinclude(-a poly2/scanner/lexer) c++-annotations-10.6.0/yo/inheritance.yo0000644000175000017500000000275612745054222016773 0ustar frankfrankincludefile(inheritance/intro) lsect(VehicleSystem)(Related types) includefile(inheritance/related) subsect(Inheritance depth: desirable?) includefile(inheritance/depth) sect(Access rights: public, private, protected) includefile(inheritance/accessrights) lsubsect(DERIVATIONTYPES)(Public, protected and private derivation) includefile(inheritance/derivationtypes) lsubsect(ACCESSPROMOTION)(Promoting access rights) includefile(inheritance/accessprom) sect(The constructor of a derived class) includefile(inheritance/constructor) subsect(Move construction) includefile(inheritance/move) subsect(Move assignment) includefile(inheritance/assignment) lsubsect(BASECONS)(Inheriting constructors) includefile(inheritance/usingbase) sect(The destructor of a derived class) includefile(inheritance/destructor) lsect(Truck)(Redefining member functions) includefile(inheritance/redefining) lsect(MULTIPLE)(Multiple inheritance) includefile(inheritance/multiple) sect(Conversions between base classes and derived classes) includefile(inheritance/conversions) subsect(Conversions with object assignments) includefile(inheritance/objectconv) subsect(Conversions with pointer assignments) includefile(inheritance/pointerconv) lsect(NONDEFINIT)(Using non-default constructors with new[]) includefile(inheritance/nondefault) c++-annotations-10.6.0/yo/first/0000755000175000017500000000000013005341451015237 5ustar frankfrankc++-annotations-10.6.0/yo/first/rawstring.yo0000644000175000017500000000211412745054222017635 0ustar frankfrankStandard ASCII-C strings are delimited by double quotes, supporting hi(escape sequence) escape sequences like tt(\n, \\) and tt(\"). In some cases it is useful to avoid escaping strings (e.g., in the context of XML). To this end, bf(C++) offers hi(raw string literal) em(raw string literals). Raw string literals start with an tt(R), followed by a double quote, followed by a label (which is an arbitrary sequence of characters not equal to tt(OPENPAR)), followed by tt(OPENPAR). The raw string ends at the closing parenthesis tt(CLOSEPAR), followed by the label which is in turn followed by a double quote. Example: verb( R"(A Raw \ "String")" R"delimiter(Another \ Raw "(String))delimiter" ) In the first case, everything between tt("OPENPAR) and tt(CLOSEPAR") is part of the string. Escape sequences aren't supported so the text tt(\ ") within the first raw string literal defines three characters: a backslash, a blank character and a double quote. The second example shows a raw string defined between the markers tt("delimiter+OPENPAR) and tt(CLOSEPARdelimiter"). c++-annotations-10.6.0/yo/first/unicode.yo0000644000175000017500000000233312745054222017246 0ustar frankfrankIn bf(C++) string literals can be defined as NTB strings. Prepending an NTBS by tt(L) (e.g., tt(L"hello")) defines a tt(wchar_t) string literal. bf(C++) also supports 8, 16 and 32 bit i(Unicode) encoded strings. Furthermore, two new data types are introduced: tt(char16_t) and tt(char32_t) storing, respectively, a ti(UTF-16) and ti(UTF-32) unicode value. In addition, a tt(char) type variable is large enough to contain any ti(UTF-8) unicode value as well (i.e., it remains an 8-bit value). String literals for the various types of unicode encodings (and associated variables) can be defined as follows: verb( char utf_8[] = u8"This is UTF-8 encoded."; char16_t utf16[] = u"This is UTF-16 encoded."; char32_t utf32[] = U"This is UTF-32 encoded."; ) Alternatively, unicode constants may be defined using the ti(\u) escape sequence, followed by a hexadecimal value. Depending on the type of the unicode variable (or constant) a tt(UTF-8, UTF-16) or tt(UTF-32) value is used. E.g., verb( char utf_8[] = u8"\u2018"; char16_t utf16[] = u"\u2018"; char32_t utf32[] = U"\u2018"; ) Unicode strings can be delimited by double quotes but raw string literals can also be used. c++-annotations-10.6.0/yo/first/extensions.yo0000644000175000017500000000043412745054222020017 0ustar frankfrankBefore we continue with the `real' object-approach to programming, we first introduce some notable differences with the bf(C) programming language: not mere differences between bf(C) and bf(C++), but important syntactic constructs and keywords not found or differently used in bf(C). c++-annotations-10.6.0/yo/first/examples/0000755000175000017500000000000013005340354017056 5ustar frankfrankc++-annotations-10.6.0/yo/first/examples/initializer.cc0000644000175000017500000000045213005340355021712 0ustar frankfrank#include using namespace std; void values(std::initializer_list iniValues) { } void values2(std::initializer_list> iniValues) { } int main() { values({2, 3, 5, 7, 11, 13}); values2({{1, 2}, {2, 3}, {3, 5}, {4, 7}, {5, 11}, {6, 13}}); } c++-annotations-10.6.0/yo/first/examples/rvalueref.cc0000644000175000017500000000264713005340355021372 0ustar frankfrank#include #include using namespace std; template void mswap(T &a, T &b) { T tmp(std::move(a)); a = std::move(b); b = std::move(tmp); } struct Data { char *text; void copy(Data const &other) { cout << "A " << (void *)other.text << '\n'; text = strdup(other.text); cout << "B " << (void *)text << '\n'; } void copy(Data &&other) { cout << "D " << (void *)other.text << '\n'; text = other.text; other.text = 0; } }; Data makeData(char const *txt) { Data ret; ret.text = strdup(txt); cout << "C " << (void *)ret.text << '\n'; return ret; } class X { public: X() { cout << "Constructor\n"; } X(X const &other) { cout << "Copycons\n"; } X(X &&other) { cout << "Move constructor\n"; } X &operator=(X const &other) { cout << "std op=\n"; return *this; }; X &operator=(X &&other) { cout << "rref op=\n"; return *this; }; }; X &&fun() { X x; return std::move(x); } int main() { int &&i = int(3); ++i; cout << i << '\n'; Data d1 = {strdup("hello")}; Data d2; d2.copy(d1); cout << "sep\n"; Data d3; d3.copy(makeData("hello")); cout << "sep 2\n"; X &&xr = X(); X x(fun()); // see memory/move.yo: // No initialization of class objects by rvalues yet cout << "sep 3\n"; mswap(xr, x); } c++-annotations-10.6.0/yo/first/cvscpp.yo0000644000175000017500000000270512745054222017121 0ustar frankfrankIn this section we'll discuss an important difference between bf(C) and bf(C++) structs and (member) functions. In bf(C) it is common to define several functions to process a tt(struct), which then require a pointer to the tt(struct) as one of their arguments. An imaginary bf(C) header file showing this concept is: verb( /* definition of a struct PERSON This is C */ typedef struct { char name[80]; char address[80]; } PERSON; /* some functions to manipulate PERSON structs */ /* initialize fields with a name and address */ void initialize(PERSON *p, char const *nm, char const *adr); /* print information */ void print(PERSON const *p); /* etc.. */ ) In bf(C++), the declarations of the involved functions are put inside the definition of the tt(struct) or tt(class). The argument denoting which tt(struct) is involved is no longer needed. verb( class Person { char d_name[80]; char d_address[80]; public: void initialize(char const *nm, char const *adr); void print(); // etc.. }; ) In bf(C++) the tt(struct) parameter is not used. A bf(C) function call such as: verb( PERSON x; initialize(&x, "some name", "some address"); ) becomes in bf(C++): verb( Person x; x.initialize("some name", "some address"); ) c++-annotations-10.6.0/yo/first/datatypes.yo0000644000175000017500000000776312745054222017632 0ustar frankfrankIn bf(C) the following i(built-in) data types are available: tt(void, char, short, int, long, float) and tt(double). bf(C++) extends these built-in types with several additional built-in types: the types ti(bool), ti(wchar_t), ti(long long) and ti(long double) (Cf. i(ANSI/ISO) draft (1995), par. 27.6.2.4.1 for examples of these very long types). The type ti(long long) is merely a double-long tt(long) datatype. The type ti(long double) is merely a double-long tt(double) datatype. These built-in types as well as pointer variables are called emi(primitive types)hi(type: primitive) in the annotations(). There is a subtle issue to be aware of when converting applications developed for 32-bit architectures to 64-bit architectures. When converting 32-bit programs to 64-bit programs, only tt(long) types and pointer types change in size from 32 bits to 64 bits; integers of type tt(int) remain at their size of 32 bits. This may cause data truncation when assigning pointer or tt(long) types to tt(int) types. Also, problems with sign extension can occur when assigning expressions using types shorter than the size of an tt(int) to an tt(unsigned long) or to a pointer. More information about this issue can be found url(here)(http://developers.sun.com/solaris/articles/ILP32toLP64Issues.html). Except for these built-in types the class-type tt(string) is available for handling character strings. The datatypes tt(bool), and tt(wchar_t) are covered in the following sections, the datatype tt(string) is covered in chapter ref(String). Note that recent versions of bf(C) may also have adopted some of these newer data types (notably tt(bool) and tt(wchar_t)). Traditionally, however, bf(C) doesn't support them, hence they are mentioned here. Now that these new types are introduced, let's refresh your memory about em(letters) that can be used in emi(literal constants) of various hi(letters in literal constants) types. They are: itemization( it() ti(b) or tt(B): in addition to its use to indicate a hexadecimal value, it can also be used to define a emi(binary constant). E.g., tt(0b101) equals the decimal value 5. The tt(0b) prefix can be used to specify binary constants starting with the C++14 standard. it() ti(E) or tt(e): hi(literal floating point value using E) the emi(exponentiation) character in floating point literal values. For example: tt(1.23E+3). Here, tt(E) should be pronounced (and interpreted) as: em(times 10 to the power). Therefore, tt(1.23E+3) represents the value tt(1230). it() ti(F) hi(literal float using F) can be used as em(postfix) to a non-integral numeric constant to indicate a value of type tt(float), rather than tt(double), which is the default. For example: tt(12.F) (the dot transforms 12 into a floating point value); tt(1.23E+3F) (see the previous example. tt(1.23E+3) is a tt(double) value, whereas tt(1.23E+3F) is a tt(float) value). it() ti(L) hi(literal wchar_t string L) can be used as em(prefix) to indicate a character string whose elements are tt(wchar_t)-type characters. For example: tt(L"hello world"). it() tt(L) hi(literal long int using L) can be used as em(postfix) to an integral value to indicate a value of type tt(long), rather than tt(int), which is the default. Note that there is no letter indicating a tt(short) type. For that a tt(static_cast()) must be used. it() ti(p), to specify the power hi(power specification using p) in hexadecimal floating point numbers. E.g. tt(0x10p4). The exponent itself is read as a decimal constant and can therefore not start with 0x. The exponent part is interpreted as a power of 2. So tt(0x10p2) is (decimal) equal to 64: tt(16 * 2^2). it() ti(U) hi(literal unsigned using U) can be used as em(postfix) to an integral value to indicate an tt(unsigned) value, rather than an tt(int). It may also be combined with the postfix tt(L) to produce an tt(unsigned long int) value. ) And, of course: the tt(x) and tt(a) until tt(f) characters can be used to specify hexadecimal constants (optionally using capital letters). c++-annotations-10.6.0/yo/first/stronglytyped.yo0000644000175000017500000000375112745054222020554 0ustar frankfrankEnumeration values in bf(C++) are in fact tt(int) values, thereby bypassing type safety. E.g., values of different enumeration types may be compared for (in)equality, albeit through a (static) type cast. Another problem with the current tt(enum) type is that their values are not restricted to the enum type name itself, but to the scope where the enumeration is defined. As a consequence, two enumerations having the same scope cannot have identical names. Such problems are solved by defining em(enum classes). An emi(enum class) can be defined as in the following example: verb( enum class SafeEnum { NOT_OK, // 0, by implication OK = 10, MAYBE_OK // 11, by implication }; ) Enum classes use tt(int) values by default, but the used value type can easily be changed using the tt(: type) notation, as in: verb( enum class CharEnum: unsigned char { NOT_OK, OK }; ) To use a value defined in an enum class its enumeration name must be provided as well. E.g., tt(OK) is not defined, tt(CharEnum::OK) is. Using the data type specification (noting that it defaults to tt(int)) it is possible to use enum class forward declarations. hi(forward declaration: enum class) E.g., verb( enum Enum1; // Illegal: no size available enum Enum2: unsigned int; // Legal: explicitly declared type enum class Enum3; // Legal: default int type is used enum class Enum4: char; // Legal: explicitly declared type ) A sequence of symbols of a strongly typed enumeration can also be indicated in a tt(switch) using the i(ellipsis) syntax, as shown in the next example: verb( SafeEnum enumValue(); switch (enumValue()) { case SafeEnum::NOT_OK ... SafeEnum::OK: cout << "Status is known\n"; break; default: cout << "Status unknown\n"; break; } ) c++-annotations-10.6.0/yo/first/public.yo0000644000175000017500000001155712745054222017106 0ustar frankfrankAs mentioned before (see section ref(Pretensions)), bf(C++) contains specialized syntactic possibilities to implement i(data hiding). Data hiding is the capability of sections of a program to hide its data from other sections. This results in very clean data definitions. It also allows these sections to enforce the integrity of their data. bf(C++) has three keywords that are related to data hiding: ti(private), ti(protected) and ti(public). These keywords can be used in the definition of tt(struct)s. The keyword tt(public) allows all subsequent fields of a structure to be accessed by all code; the keyword tt(private) only allows code that is part of the tt(struct) itself to access subsequent fields. The keyword tt(protected) is discussed in chapter ref(INHERITANCE), and is somewhat outside of the scope of the current discussion. In a tt(struct) all fields are tt(public), unless explicitly stated otherwise. Using this knowledge we can expand the tt(struct) tt(Person): verb( struct Person { private: char d_name[80]; char d_address[80]; public: void setName(char const *n); void setAddress(char const *a); void print(); char const *name(); char const *address(); }; ) As the data fields tt(d_name) and tt(d_address) are in a tt(private) section they are only accessible to the member functions which are defined in the tt(struct): these are the functions tt(setName), tt(setAddress) etc.. As an illustration consider the following code: verb( Person fbb; fbb.setName("Frank"); // OK, setName is public strcpy(fbb.d_name, "Knarf"); // error, x.d_name is private ) Data integrity is implemented as follows: the actual data of a tt(struct) tt(Person) are mentioned in the structure definition. The data are accessed by the outside world using special functions that are also part of the definition. These member functions control all traffic between the data fields and other parts of the program and are therefore also called `interface' functions. The thus implemented data hiding is illustrated in fig(datahiding). figure(first/datahiding) (Private data and public interface functions of the class Person.) (datahiding) The members tt(setName) and tt(setAddress) are declared with tt(char const *) parameters. This indicates that the functions will not alter the strings which are supplied as their arguments. Analogously, the members tt(name) and tt(address) return tt(char const *)s: the compiler prevents callers of those members from modifying the information made accessible through the return values of those members. Two examples of member functions of the tt(struct) tt(Person) are shown below: verb( void Person::setName(char const *n) { strncpy(d_name, n, 79); d_name[79] = 0; } char const *Person::name() { return d_name; } ) The power of member functions and of the concept of data hiding results from the abilities of member functions to perform special tasks, e.g., checking the validity of the data. In the above example tt(setName) copies only up to 79 characters from its argument to the data member tt(name), thereby avoiding a i(buffer overflow). Another illustration of the concept of data hiding is the following. As an alternative to member functions that keep their data in memory a library could be developed featuring member functions storing data on file. To convert a program storing tt(Person) structures in memory to one that stores the data on disk no special modifications are required. After recompilation and linking the program to a new library it is converted from storage in memory to storage on disk. This example illustrates a broader concept than data hiding; it illustrates emi(encapsulation). Data hiding is a kind of encapsulation. Encapsulation in general results in reduced coupling of different sections of a program. This in turn greatly enhances reusability and maintainability of the resulting software. By having the structure encapsulate the actual storage medium the program using the structure becomes independent of the actual storage medium that is used. Though data hiding can be implemented using tt(struct)s, more often (almost always) em(classes) are used instead. A class is a kind of struct, except that a class uses private access by default, whereas structs use public access by default. The definition of a tt(class) tt(Person) is therefore identical to the one shown above, except for the fact that the keyword tt(class) has replaced tt(struct) while the initial tt(private:) clause can be omitted. Our typographic suggestion for class names (and other type names defined by the programmer) is to start with a capital character to be followed by the remainder of the type name using lower case letters (e.g., tt(Person)). c++-annotations-10.6.0/yo/first/sizet.yo0000644000175000017500000000256212745054222016762 0ustar frankfrankThe ti(size_t) type is not really a built-in primitive data type, but a data type that is promoted by bi(POSIX) as a typename to be used for non-negative integral values answering questions like `how much' and `how many', in which case it should be used instead of ti(unsigned int). It is not a specific bf(C++) type, but also available in, e.g., bf(C). Usually it is defined implictly when a (any) system header file is included. The header file `officially' defining tt(size_t) in the context of bf(C++) is ti(cstddef). Using tt(size_t) has the advantage of being a em(conceptual) type, rather than a standard type that is then modified by a modifier. Thus, it improves the self-documenting value of source code. Sometimes functions explictly require tt(unsigned int) to be used. E.g., on ti(amd)-architectures the i(X-windows) function ti(XQueryPointer) explicitly requires a pointer to an tt(unsigned int) variable as one of its arguments. In such situations a pointer to a tt(size_t) variable can't be used, but the address of an tt(unsigned int) must be provided. Such situations are exceptional, though. Other useful bit-represented types also exists. E.g., ti(uint32_t) is guaranteed to hold 32-bits unsigned values. Analogously, ti(int32_t) holds 32-bits signed values. Corresponding types exist for 8, 16 and 64 bits values. These types are defined in the header file ti(cstdint). c++-annotations-10.6.0/yo/first/using.yo0000644000175000017500000000521612745054222016750 0ustar frankfrankIn bf(C++) tt(typedef) is commonly used to define shorthand notations for complex types. Assume we want to define a shorthand for `a pointer to a function expecting a double and an int, and returning an unsigned long long int'. Such a function could be: verb( unsigned long long int compute(double, int); ) A pointer to such a function has the following form: verb( unsigned long long int (*pf)(double, int); ) If this kind of pointer is frequently used, consider defining it using tt(typedef): simply put tt(typedef) in front of it and the pointer's name is turned into the name of a type. It could be capitalized to let it stand out more clearly as the name of a type: verb( typedef unsigned long long int (*PF)(double, int); ) After having defined this type, it can be used to declare or define such pointers: verb( PF pf = compute; // initialize the pointer to a function like // 'compute' void fun(PF pf); // fun expects a pointer to a function like // 'compute' ) However, including the pointer in the typedef might not be a very good idea, as it masks the fact that tt(pf) is a pointer. After all, tt(PF pf) looks more like `tt(int x)' than `tt(int *x)'. To document that tt(pf) is in fact a pointer, slightly change the tt(typedef): verb( typedef unsigned long long int FUN(double, int); FUN *pf = compute; // now pf clearly is a pointer. ) The scope of typedefs is restricted to compilation units. Therefore, typedefs are usually embedded in header files which are then included by multiple source files in which the typedefs should be used. In addition to tt(typedef) bf(C++) offers the ti(using) keyword to associate a type and and identifier. In practice tt(typedef) and tt(using) can be used interchangeably. The tt(using) keyword arguably result in more readable type definitions. Consider the following three (equivalent) definitions: itemization( it() The traditional, bf(C) style definition of a type, embedding the type name in the definition (turning a variable name into a type name): verb( typedef unsigned long long int FUN(double, int); ) it() Apply tt(using) to improve the visibility (for humans) of the type name, by moving the type name to the front of the definition: verb( using FUN = unsigned long long int (double, int); ) it() An alternative construction, using a late-specified return type (cf. section ref(AUTO)): verb( using FUN = auto (double, int) -> unsigned long long int; ) ) c++-annotations-10.6.0/yo/first/staticcast.yo0000644000175000017500000000725012745054222017765 0ustar frankfrankThe hi(static_cast)tt(static_cast(expression)) is used to convert `conceptually comparable or related types' to each other. Here as well as in other bf(C++) style casts tt(type) is the type to which the type of tt(expression) should be cast. Here are some examples of situations where the tt(static_cast) can (or should) be used: itemization( it() When converting an tt(int) to a tt(double). nl() This happens, for example when the quotient of two tt(int) values must be computed without losing the fraction part of the division. The tt(sqrt) function called in the following fragment returns 2: verb( int x = 19; int y = 4; sqrt(x / y); ) whereas it returns 2.179 when a tt(static_cast) is used, as in: verb( sqrt(static_cast(x) / y); ) The important point to notice here is that a tt(static_cast) is allowed to change the representation of its tt(expression) into the representation that's used by the destination type. Also note that the division is put outside of the cast expression. If the division is performed within the cast's tt(expression) (as in tt(static_cast(x / y))) an emi(integer division) has already been performed em(before) the cast has had a chance to convert the type of an operand to tt(double). it() When converting tt(enum) values to tt(int) values (in any direction). nl() Here the two types use identical representations, but different semantics. Assigning an ordinary tt(enum) value to an tt(int) doesn't require a cast, but when the enum is a em(strongly typed enum) a cast em(is) required. Conversely, a tt(static_cast) is required when assigning an tt(int) value to a variable of some enum type. Here is an example: verb( enum class Enum { VALUE }; cout << static_cast(VALUE); // show the numeric value ) it() When converting related pointers to each other.nl() The tt(static_cast) is used in the context of class inheritance (cf. chapter ref(INHERITANCE)) to convert a pointer to a so-called `derived class' to a pointer to its `base class'. It cannot be used for casting unrelated types to each other (e.g., a tt(static_cast) can+em(not) be used to cast a pointer to a tt(short) to a pointer to an tt(int)). A tt(void *) is a em(generic pointer). It is frequently used by functions in the bf(C) library (e.g., bf(memcpy)(3)). Since it is the generic pointer it is related to any other pointer, and a tt(static_cast) should be used to convert a tt(void *) to an intended destination pointer. This is a somewhat awkward left-over from bf(C), which should probably only be used in that context. Here is an example: The tt(qsort) functions from the bf(C) library expects a pointer to a (comparison) function having two tt(void const *) parameters. In fact, these parameters point to data elements of the array to be sorted, and so the comparison function must cast the tt(void const *) parameters to pointers to the elements of the array to be sorted. So, if the array is an tt(int array[]) and the compare function's parameters are tt(void const *p1) and tt(void const *p2) then the compare function obtains the address of the tt(int) pointed to by tt(p1) by using: verb( static_cast(p1); ) it() When undoing or introducing the signed-modifier of an tt(int)-typed variable (remember that a tt(static_cast) is allowed to change the expression's representation!). nl() Here is an example: the bf(C) function tt(tolower) requires an tt(int) representing the value of an tt(unsigned char). But tt(char) by default is a signed type. To call tt(tolower) using an available tt(char ch) we should use: verb( tolower(static_cast(ch))) ) c++-annotations-10.6.0/yo/first/initializer.yo0000644000175000017500000000412112745054222020140 0ustar frankfrankThe bf(C) language defines the i(initializer list) as a list of values enclosed by curly braces, possibly themselves containing initializer lists. In bf(C) these initializer lists are commonly used to initialize arrays and structs. bf(C++) extends this concept by introducing the em(type) tt(initializer_list) where tt(Type) is replaced by the type name of the values used in the initializer list. Initializer lists in bf(C++) are, like their counterparts in bf(C), recursive, so they can also be used with multi-dimensional arrays, structs and classes. Before using the tt(initializer_list) the tthi(initializer_list) header file must be included. Like in bf(C), initializer lists consist of a list of values surrounded by curly braces. But unlike bf(C), em(functions) can define initializer list parameters. E.g., verb( void values(std::initializer_list iniValues) { } ) A function like tt(values) could be called as follows: verb( values({2, 3, 5, 7, 11, 13}); ) The initializer list appears as an argument which is a list of values surrounded by curly braces. Due to the recursive nature of initializer lists a two-dimensional series of values can also be passes, as shown in the next example: verb( void values2(std::initializer_list> iniValues) {} values2({{1, 2}, {2, 3}, {3, 5}, {4, 7}, {5, 11}, {6, 13}}); ) Initializer lists are constant expressions and cannot be modified. However, their em(size) and values may be retrieved using their tt(size, begin), and tt(end) members as follows: verb( void values(initializer_list iniValues) { cout << "Initializer list having " << iniValues.size() << "values\n"; for ( initializer_list::const_iterator begin = iniValues.begin(); begin != iniValues.end(); ++begin ) cout << "Value: " << *begin << '\n'; } ) Initializer lists can also be used to initialize objects of classes (cf. section ref(UNIFORMINIT)). c++-annotations-10.6.0/yo/first/rangebased.yo0000644000175000017500000000630312745054222017714 0ustar frankfrankThe bf(C++) for-statement is identical to bf(C)'s for-statement: verb( for (init; cond; inc) statement ) Often the initialization, condition, and increment parts are fairly obvious, as in situations where all elements of an array or vector must be processed. Many languages offer the tt(foreach) statement for that and bf(C++) offers the tt(std::for_each) generic algorithm (cf. section ref(FOREACH)). In addition to the traditional syntax bf(C++) adds new syntax for the tt(for)-statement: the emi(range-based for-loop). This new syntax can be used to process all element of a i(range) in turn. Three types of ranges are distinguished: itemization( it() Plain arrays (e.g., tt(int array[10])); it() Initializer lists; it() Standard containers (or comparable) (cf. chapter ref(CONTAINERS)); it() Any other type offering tt(begin()) and tt(end()) functions returning so-called em(iterators) (cf. section ref(ITERATORS)). ) Here the following additional i(for-statement) syntax is available: verb( // assume int array[30] for (auto &element: array) statement ) The part to the left of the colon is called the emi(for range declaration). The declared variable (tt(element)) is a formal name; use any identifier you like. The variable is only available within the nested statement, and it refers to (or is a copy of) each of the elements of the range, from the first element up to the last. There's no formal requirement to use tt(auto), but using tt(auto) is extremely useful in many situations. Not only in situations where the range refers to elements of some complex type, but also in situations where you know what you can do with the elements in the range, but don't care about their exact type names. In the above example tt(int) could also have been used. The reference symbol (tt(&)) is important in the following cases: itemization( it() if you want to modify the elements in the nested statements it() if the elements themselves are tt(struct)s (or em(classes), cf. chapter ref(Classes)) ) When the reference symbol is omitted the variable will be a copy of each of the subsequent elements of the range. Fine, probably, if you merely need to look at the variables when they are of primitive types, but needlessly inefficient if you have an array of tt(BigStruct) elements: verb( struct BigStruct { double array[100]; int last; }; ) Inefficient, because you don't need to make copies of the array's elements. Instead, use refences to elements: verb( BigStruct data[100]; // assume properly initialized elsewhere int countUsed() { int sum = 0; // const &: the elements aren't modified for (auto const &element: data) sum += element.last; return sum; } ) If tt(data) is only available as a pointer to its first element in combination with the number of elements, range-based for loops can also be used, but require a little help. Section ref(RANGER) describes a generic approach to using range based for loops in such cases. c++-annotations-10.6.0/yo/first/reinterpretcast.yo0000644000175000017500000000526612745054222021046 0ustar frankfrankThe third new-style cast is used to change the em(interpretation) of information: the tt(reinterpret_cast). It is somewhat reminiscent of the tt(static_cast), but tt(reinterpret_cast) should only be used when it is em(known) that the information as defined in fact is or can be interpreted as something completely different. Its syntax is: verb( reinterpret_cast(pointer expression)) Think of the tt(reinterpret_cast) as a cast offering a poor-man's union: the same memory location may be interpreted in completely different ways. The tt(reinterpret_cast) is used, for example, in combination with the tt(write) function that is available for em(streams). In bf(C++) streams are the preferred interface to, e.g., disk-files. The standard streams like tt(std::cin) and tt(std::cout) also are stream objects. Streams intended for writing (`output streams' like tt(cout)) offer tt(write) members having the prototype verb( write(char const *buffer, int length)) To write the value stored within a tt(double) variable to a stream in its un-interpreted binary form the stream's tt(write) member is used. However, as a tt(double *) and a tt(char *) point to variables using different and unrelated representations, a tt(static_cast) cannot be used. In this case a tt(reinterpret_cast) is required. To write the raw bytes of a variable tt(double value) to tt(cout) we use: verb( cout.write(reinterpret_cast(&value), sizeof(double)); ) All casts are potentially dangerous, but the tt(reinterpret_cast) is the most dangerous of them all. Effectively we tell the compiler: back off, we know what we're doing, so stop fuzzing. All bets are off, and we'd better em(do) know what we're doing in situations like these. As a case in point consider the following code: verb( int value = 0x12345678; // assume a 32-bits int cout << "Value's first byte has value: " << hex << static_cast( *reinterpret_cast(&value) ); ) The above code produces different results on little and big endian computers. Little endian computers show the value 78, big endian computers the value 12. Also note that the different representations used by little and big endian computers renders the previous example (tt(cout.write(...))) non-portable over computers of different architectures. As a i(rule of thumb): if circumstances arise in which casts em(have) to be used, clearly document the reasons for their use in your code, making double sure that the cast does not eventually cause a program to misbehave. Also: avoid tt(reinterpret_casts) unless you em(have) to use them. c++-annotations-10.6.0/yo/first/wchar.yo0000644000175000017500000000102212745054222016716 0ustar frankfrankThe ti(wchar_t) type is an extension of the tt(char) built-in type, to accomodate em(wide) character values (but see also the next section). The tt(g++) compiler reports tt(sizeof(wchar_t)) as 4, which easily accomodates all 65,536 different em(Unicode) character values. Note that bf(Java)'s tt(char) data type is somewhat comparable to bf(C++)'s tt(wchar_t) type. bf(Java)'s tt(char) type is 2 bytes wide, though. On the other hand, bf(Java)'s tt(byte) data type is comparable to bf(C++)'s tt(char) type: one byte. Confusing? c++-annotations-10.6.0/yo/first/keywords.yo0000644000175000017500000000452312745054222017472 0ustar frankfrankbf(C++)'s i(keywords) are a superset of bf(C)'s keywords. Here is a list of all keywords of the language: COMMENT(table generated by src/keywordsort.cc) verb( alignas char32_t enum namespace return typedef alignof class explicit new short typeid and compl export noexcept signed typename and_eq concept extern not sizeof union asm const false not_eq static unsigned auto const_cast float nullptr static_assert using axiom constexpr for operator static_cast virtual bitand continue friend or struct void bitor decltype goto or_eq switch volatile bool default if private template wchar_t break delete import protected this while case do inline public thread_local xor catch double int register throw xor_eq char dynamic_cast long reinterpret_cast true char16_t else mutable requires try ) Notes: itemization( it() The ti(export) keyword is no longer actively used by bf(C++), but it is kept as a keyword, reserved for future use. it() the hi(operator: keywords)em(operator keywords): tt(and, and_eq, bitand, bitor, compl, not, not_eq, or, or_eq, xor) and tt(xor_eq) are symbolic alternatives for, respectively, tt(&&, &=, &, |, ~, !, !=, ||, |=, ^) and tt(^=). it() bf(C++) also recognizes the special identifiers tt(final) and tt(override). These identifiers are special in the sense that they acquire special meanings when declaring classes or polymorphic functions. Section ref(FINAL) provides further details. ) Keywords can only be used for their intended purpose and cannot be used as names for other entities (e.g., variables, functions, class-names, etc.). In addition to keywords i(identifiers starting with an underscore) and living in the emi(global namespace) (i.e., not using any explicit namespace or using the mere tt(::) namespace specification) or living in the em(std namespace) are i(reserved identifiers) in the sense that their use is a prerogative of the implementor. c++-annotations-10.6.0/yo/first/bool.yo0000644000175000017500000000522712745054222016560 0ustar frankfrank The type tt(bool) represents boolean (logical) values, for which the (now reserved) constants ti(true) and ti(false) may be used. Except for these reserved values, integral values may also be assigned to variables of type tt(bool), which are then implicitly converted to tt(true) and tt(false) according to the following i(conversion rules) (assume tt(intValue) is an tt(int)-variable, and tt(boolValue) is a tt(bool)-variable): verb( // from int to bool: boolValue = intValue ? true : false; // from bool to int: intValue = boolValue ? 1 : 0; ) Furthermore, when tt(bool) values are inserted into streams then tt(true) is represented by tt(1), and tt(false) is represented by tt(0). Consider the following example: verb( cout << "A true value: " << true << "\n" "A false value: " << false << '\n'; ) The tt(bool) data type is found in other programming languages as well. bf(Pascal) has its type tt(Boolean); bf(Java) has a tt(boolean) type. Different from these languages, bf(C++)'s type tt(bool) acts like a kind of tt(int) type. It is primarily a documentation-improving type, having just two values tt(true) and tt(false). Actually, these values can be interpreted as tt(enum) values for tt(1) and tt(0). Doing so would ignore the philosophy behind the tt(bool) data type, but nevertheless: assigning tt(true) to an tt(int) variable neither produces warnings nor errors. Using the tt(bool)-type is usually clearer than using tt(int). Consider the following prototypes: verb( bool exists(char const *fileName); // (1) int exists(char const *fileName); // (2) ) With the first prototype, readers expect the function to return tt(true) if the given filename is the name of an existing file. However, with the second prototype some ambiguity arises: intuitively the return value 1 is appealing, as it allows constructions like verb( if (exists("myfile")) cout << "myfile exists"; ) On the other hand, many system functions (like ti(access), ti(stat), and many other) return 0 to indicate a successful operation, reserving other values to indicate various types of errors. As a rule of thumb I suggest the following: if a function should inform its caller about the success or failure of its task, let the function return a tt(bool) value. If the function should return success or various types of errors, let the function return em(enum) values, documenting the situation by its various symbolic constants. Only when the function returns a conceptually meaningful integral value (like the sum of two tt(int) values), let the function return an tt(int) value. c++-annotations-10.6.0/yo/first/namespaces.yo0000644000175000017500000000161312745054222017737 0ustar frankfrankbf(C++) introduces the notion of a emi(namespace): all symbols are defined in a larger context, called a em(namespace). Namespaces are used to avoid i(name conflicts) that could arise when a programmer would like to define a function like tt(sin) operating on em(degrees), but does not want to lose the capability of using the standard tt(sin) function, operating on em(radians). Namespaces are covered extensively in chapter ref(NAMESPACE). For now it should be noted that most compilers require the explicit declaration of a emi(standard namespace): tt(std). So, unless otherwise indicated, it is stressed that all examples in the Annotations now implicitly use the hi(using namespace std) verb( using namespace std;) declaration. So, if you actually intend to compile examples given in the annotations(), make sure that the sources start with the above tt(using) declaration. c++-annotations-10.6.0/yo/first/longlongint.yo0000644000175000017500000000014412745054222020150 0ustar frankfrankbf(C++) also supports the type ti(long long int). On 32 bit systems it has at least 64 usable bits. c++-annotations-10.6.0/yo/first/rvalueref.yo0000644000175000017500000001640313005113542017605 0ustar frankfrankIn bf(C++), temporary (rvalue) values are indistinguishable from tt(const &) types. bf(C++) introduces a new reference type called an emi(rvalue reference), which is defined as ti(typename &&). The name em(rvalue) reference is derived from assignment statements, where the variable to the left of the assignment operator is called an emi(lvalue) and the expression to the right of the assignment operator is called an emi(rvalue). Rvalues are often temporary, anonymous values, like values returned by functions. In this parlance the bf(C++) reference should be considered an emi(lvalue reference) (using the notation tt(typename &)). They can be contrasted to em(rvalue references) (using the notation tt(typename &&)). The key to understanding rvalue references is the concept of an emi(anonymous variable). An anonymous variable has no name and this is the distinguishing feature for the compiler to associate it automatically with an rvalue reference if it has a choice. Before introducing some interesting constructions let's first have a look at some standard situations where em(lvalue) references are used. The following function returns a temporary (anonymous) value: verb( int intVal() { return 5; } ) Although tt(intVal)'s return value can be assigned to an tt(int) variable it requires copying, which might become prohibitive when a function does not return an tt(int) but instead some large object. A em(reference) or em(pointer) cannot be used either to collect the anonymous return value as the return value won't survive beyond that. So the following is illegal (as noted by the compiler): verb( int &ir = intVal(); // fails: refers to a temporary int const &ic = intVal(); // OK: immutable temporary int *ip = &intVal(); // fails: no lvalue available ) Apparently it is not possible to modify the temporary returned by tt(intVal). But now consider these functions: verb( void receive(int &value) // note: lvalue reference { cout << "int value parameter\n"; } void receive(int &&value) // note: rvalue reference { cout << "int R-value parameter\n"; } ) and let's call this function from tt(main): verb( int main() { receive(18); int value = 5; receive(value); receive(intVal()); } ) This program produces the following output: verb( int R-value parameter int value parameter int R-value parameter ) The program's output shows the compiler selecting tt(receive(int &&value)) in all cases where it receives an anonymous tt(int) as its argument. Note that this includes tt(receive(18)): a value 18 has no name and thus tt(receive(int &&value)) is called. Internally, it actually uses a temporary variable to store the 18, as is shown by the following example which modifies tt(receive): verb( void receive(int &&value) { ++value; cout << "int R-value parameter, now: " << value << '\n'; // displays 19 and 6, respectively. } ) Contrasting tt(receive(int &value)) with tt(receive(int &&value)) has nothing to do with tt(int &value) not being a const reference. If tt(receive(int const &value)) is used the same results are obtained. Bottom line: the compiler selects the overloaded function using the rvalue reference if the function is passed an anonymous value. The compiler runs into problems if tt(void receive(int &value)) is replaced by tt(void receive(int value)), though. When confronted with the choice between a value parameter and a reference parameter (either lvalue or rvalue) it cannot make a decision and reports an ambiguity. In practical contexts this is not a problem. Rvalue refences were added to the language in order to be able to distinguish the two forms of references: named values (for which lvalue references are used) and anonymous values (for which rvalue references are used). It is this distinction that allows the implementation of emi(move semantics) and emi(perfect forwarding). At this point the concept of emi(move semantics) cannot yet fully be discussed (but see section ref(MOVE) for a more thorough discussusion) but it is very well possible to illustrate the underlying ideas. Consider the situation where a function returns a tt(struct Data) containing a pointer to dynamically allocated characters. Moreover, the struct defines a member function tt(copy(Data const &other)) that takes another tt(Data) object and copies the other's data into the current object. The (partial) definition of the tt(struct Data) might look like this+footnote(To the observant reader: in this example the memory leak that results from using Data::copy() should be ignored): verb( struct Data { char *text; size_t size; void copy(Data const &other) { text = strdup(other.text); size = strlen(text); } }; ) Next, functions tt(dataFactory) and tt(main) are defined as follows: verb( Data dataFactory(char const *txt) { Data ret = {strdup(txt), strlen(txt)}; return ret; } int main() { Data d1 = {strdup("hello"), strlen("hello")}; Data d2; d2.copy(d1); // 1 (see text) Data d3; d3.copy(dataFactory("hello")); // 2 } ) At (1) tt(d2) appropriately receives a copy of tt(d1)'s text. But at (2) tt(d3) receives a copy of the text stored in the temporary returned by the tt(dataFactory) function. As the temporary ceases to exist after the call to tt(copy()) two releated and unpleasant consequences are observed: itemization( it() The return value is a temporary object: its only reason for existence is to pass its data on to tt(d3). Now tt(d3) copies the temporary's data which clearly is somewhat overdone. it() The temporary tt(Data) object is lost following the call to tt(copy()). Unfortunately its dynamically allocated data is lost as well resulting in a memory leak. ) In cases like these em(rvalue reference) should be used. By overloading the tt(copy) member with a member tt(copy(Data &&other)) the compiler is able to distinguish situations (1) and (2). It now calls the initial tt(copy()) member in situation (1) and the newly defined overloaded tt(copy()) member in situation (2): verb( struct Data { char *text; size_t size; void copy(Data const &other) { text = strdup(other.text); } void copy(Data &&other) { text = other.text; other.text = 0; } }; ) Note that the overloaded tt(copy()) function merely moves the tt(other.text) pointer to the current object's tt(text) pointer followed by reassigning 0 to tt(other.text). tt(Struct Data) suddenly has become emi(move-aware) and implements em(move semantics), removing the drawbacks of the previously shown approach: itemization( it() Instead of making a deep copy (which is required in situation (1)), the pointer value is simply moved to its new owner; it() Since the tt(other.text) doesn't point to dynamically allocated memory anymore the memory leak is prevented. ) c++-annotations-10.6.0/yo/first/separators.yo0000644000175000017500000000077212745054222020010 0ustar frankfrankTo improve the readability of large numbers em(digit separators)hi(digit separator) for integer and floating point literals. The digit separator is a single quote which may be inserted between digits of such literals to enhance human readability. Multiple digit separators may be used, but only one separator can be inserted between successive digits. E.g., verb( 1'000'000 3.141'592'653'589'793'238'5 ''123 // won't compile 1''23 // won't compile either ) c++-annotations-10.6.0/yo/first/structs.yo0000644000175000017500000000323412745054222017330 0ustar frankfrankEarlier we noted that functions can be part of tt(struct)s (see section ref(FunctionInStruct)). Such functions are called hi(member function)em(member functions). This section briefly discusses how to define such functions. The code fragment below shows a tt(struct) having data fields for a person's name and address. A function tt(print) is included in the tt(struct)'s definition: verb( struct Person { char name[80]; char address[80]; void print(); }; ) When defining the member function tt(print) the structure's name (tt(Person)) and the scope resolution operator (tt(::)) are used: verb( void Person::print() { cout << "Name: " << name << "\n" "Address: " << address << '\n'; } ) The implementation of tt(Person::print) shows how the fields of the tt(struct) can be accessed without using the structure's type name. Here the function tt(Person::print) prints a variable tt(name). Since tt(Person::print) is itself a part of tt(struct) tt(person), the variable tt(name) implicitly refers to the same type. This tt(struct Person) could be used as follows: verb( Person person; strcpy(person.name, "Karel"); strcpy(person.address, "Marskramerstraat 33"); person.print(); ) The advantage of member functions is that the called function automatically accesses the data fields of the structure for which it was invoked. In the statement tt(person.print()) the object tt(person) is the `substrate': the variables tt(name) and tt(address) that are used in the code of tt(print) refer to the data stored in the tt(person) object. c++-annotations-10.6.0/yo/first/sharedcast.yo0000644000175000017500000000127112745054222017741 0ustar frankfrankThis section can safely be skipped without loss of continuity. In the context of the class tt(shared_ptr), which is covered in section ref(SHAREDPTR), several more new-style casts are availble. Actual coverage of these specialized casts is postponed until section ref(SHAREDCAST). These specialized casts are: itemization( itt(static_pointer_cast), returning a tt(shared_ptr) to the base-class section of a derived class object; itt(const_pointer_cast), returing a tt(shared_ptr) to a non-const object from a tt(shared_ptr) to a constant object; itt(dynamic_pointer_cast), returning a tt(shared_ptr) to a derived class object from a tt(shared_ptr) to a base class object. ) c++-annotations-10.6.0/yo/first/scope.yo0000644000175000017500000000202612745054222016730 0ustar frankfrankbf(C++) introduces several new operators, among which the i(scope resolution operator) (ti(::)). This operator can be used in situations where a global variable exists having the same name as a local variable: verb( #include double counter = 50; // global variable int main() { for (int counter = 1; // this refers to the counter != 10; // local variable ++counter) { printf("%d\n", ::counter // global variable / // divided by counter); // local variable } } ) In the above program the scope operator is used to address a global variable instead of the local variable having the same name. In bf(C++) the scope operator is used extensively, but it is seldom used to reach a global variable shadowed by an identically named local variable. Its main purpose is encountered in chapter ref(Classes). c++-annotations-10.6.0/yo/first/binary.yo0000644000175000017500000000137212745054222017106 0ustar frankfrankIn addition to hexadecimal hi(hexadecimal constants) integral constants (starting with i(0x)), octal integral hi(octal constants) constants (starting with i(0)), and decimal integral hi(decimal constants) constants (starting with one of the digits 1..9), em(binary) integral hi(binary constants) constants can be defined using the prefixes i(0b) or i(0B). E.g., to represent the (decimal) value 5 the notation tt(0b101) can also be used. Formally binary constants are supported by bf(C++) since the C++14 standard, but compilers usually supported this well before implementing this standard. The binary constants come in handy in the context of, e.g., i(bit-flags), as it immediately shows which bit-fields are set, while other notations are less informative. c++-annotations-10.6.0/yo/first/lvalues.yo0000644000175000017500000001022113005341451017257 0ustar frankfrankAlthough this section contains forward references to chapters ref(String), ref(Classes), and ref(PointMembers), its topic best fits the current chapter. This section can be skipped without loss of continuity, and you might consider returning to it once you're familiar with the contents of these future chapters. Historically, the bf(C) programming language distinguished between em(lvalues) and em(rvalues). The terminology was based on assignment expressions, where the value to the left of the assignment operator receives a value (e.g., it referred to a location in memory where a value could be written into, like a variable), while the value to the right of the assignment operator only had to represent a value (it could be a temporary variable, a constant value or the value stored in a variable): verb( lvalue = rvalue; ) bf(C++) adds to this basic distinction several new ways of referring to values: itemization( itt(lvalue): an emi(lvalue) in bf(C++) has the same meaning as in bf(C). It refers to a location where a value can be stored, like a variable, a reference to a variable, or a dereferenced pointer. itt(xvalue): an emi(xvalue) indicates an emi(expiring value). An expiring value refers to an em(object) (cf. chapter ref(Classes)) just before its lifetime ends. Such objects normally have to make sure that resources they own (like dynamically allocated memory) also cease to exist, but such resources may, just before the object's lifetime ends, be moved to another location, thus preventing their destruction. itt(gvalue): a emi(gvalue) is a emi(generalized lvalue). A generalized lvalue refers to anything that may receive a value. It is either an lvalue or an xvalue. itt(prvalue): a emi(prvalue) is a emi(pure rvalue): a literal value (like tt(1.2e3)) or an immutable object (e.g., the value returned from a function returning a constant tt(std::string) (cf. chapter ref(String))) ) An expression's value is an xvalue if it is: itemization( it() the value returned by a function returning an rvalue reference to an object; it() an object that is cast to an rvalue reference; it() an expression accessing a non-static class data member whose object is itemization( it() an xvalue, or it() a tt(.*) (pointer-to-member) expression (cf. chapter ref(PointMembers)) in which the left-hand side operand is an xvalue and the right-hand side operand is a pointer to a data member. ) The effect of this rule is that named rvalue references are treated as lvalues and anonymous rvalue references to objects are treated as xvalues.nl() Rvalue references to functions are treated as lvalues whether anonymous or not. ) Here is a small example. Consider this simple struct: verb( struct Demo { int d_value; }; ) In addition we have these function declarations and definitions: verb( Demo &&operator+(Demo const &lhs, Demo const &rhs); Demo &&factory(); Demo demo; Demo &&rref = static_cast(demo); ) Expressions like verb( factory(); factory().d_value; static_cast(demo); demo + demo ) are xvalues. However, the expression verb( rref; ) is an lvalue. In many situations it's not particularly important to know what kind of gvalue or what kind of rvalue is actually used. In the annotations() the term emi(lhs) (i(left hand side)) is frequently used to indicate an operand that's written to the left of a binary operator, while the term emi(rhs) (i(right hand side)) is frequently used to indicate an operand that's written to the right of a binary operator. Lhs and rhs operands could actually be gvalues (e.g., when representing ordinary variables), but they could also be prvalues (e.g., numeric values added together using the addition operator). Whether or not lhs and rhs operands are glvalues can always be determined from the context in which they are used. c++-annotations-10.6.0/yo/first/first.yo0000644000175000017500000000045712745054222016754 0ustar frankfrankIn this chapter bf(C++) is further explored. The possibility to declare functions in tt(struct)s is illustrated in various examples; the concept of a tt(class) is introduced; casting is covered in detail; many new types are introduced and several important notational extensions to bf(C) are discussed. c++-annotations-10.6.0/yo/first/dynamiccast.yo0000644000175000017500000000132712745054222020121 0ustar frankfrankFinally there is a new style cast that is used in combination with polymorphism (see chapter ref(POLYMORPHISM)). Its syntax is: verb( dynamic_cast(expression)) Different from the tt(static_cast), whose actions are completely determined em(compile-time), the tt(dynamic_cast)'s actions are determined em(run-time) to convert a pointer to an object of some class (e.g., tt(Base)) to a pointer to an object of another class (e.g., tt(Derived)) which is found further down its so-called em(class hierarchy) (this is also called em(downcasting)). At this point in the em(Annotations) a tt(dynamic_cast) cannot yet be discussed extensively, but we return to this topic in section ref(DYNAMICCAST). c++-annotations-10.6.0/yo/first/typeinference.yo0000644000175000017500000001360712745054222020466 0ustar frankfrankThe keyword ti(auto) can be used to simplify type definitions of variables and return types of functions if the compiler is able to determine the proper types of such variables or functions. In additon, the use of tt(auto) as a storage class specifier is no longer supported by bf(C++): a variable definition like tt(auto int var) results in a compilation error. This can be very useful in situations where it is very hard to determine the variable's type in advance. These situations occur, e.g., in the context of em(templates), topics covered in chapters ref(STL) until ref(ADVANCEDTEMPL). At this point in the Annotations only simple examples can be given. Also, some hints will be provided about more general uses of the tt(auto) keyword. When defining and initializing a variable tt(int variable = 5) the type of the initializing expression is well known: it's an tt(int), and unless the programmer's intentions are different this could be used to define tt(variable)'s type (although it shouldn't in normal circumstances as it reduces rather than improves the clarity of the code): verb( auto variable = 5; ) Here are some examples where using tt(auto) em(is) useful. In chapter ref(String) the emi(iterator) concept is introduced (see also chapters ref(CONTAINERS) and ref(STL)). Iterators sometimes have long type definitions, like verb( std::vector::const_reverse_iterator ) Functions may return types like this. Since the compiler knows the types returned by functions we may exploit this knowledge using tt(auto). Assuming that a function tt(begin()) is declared as follows: verb( std::vector::const_reverse_iterator begin(); ) Rather than writing the verbose variable definition (at tt(// 1)) a much shorter definition (at tt(// 2)) may be used: verb( std::vector::const_reverse_iterator iter = begin(); // 1 auto iter = begin(); // 2 ) It's easy to define additional variables of this type. When initializing those variables using tt(iter) the tt(auto) keyword can be used again: verb( auto start = iter; ) Merely using tt(auto) always results in a non-reference type. If tt(auto) should refer to a reference type, ti(auto &&) should be used. If tt(start) can't be initialized immediately using an existing variable the type of a well known variable or function can be used in combination with the ti(decltype) keyword, as in: verb( decltype(iter) start; decltype(begin()) spare; ) The keyword tt(decltype) may also receive an expression as its argument. E.g., tt(decltype(3 + 5)) represents an int, tt(decltype(3 / double(3))) represents tt(double). Different from tt(auto) the type deduced by tt(decltype) may either be a value or a reference type, depending on the kind of expression that is passed to tt(decltype). E.g, if tt(int intVal) and tt(int &&intTmp()) are available, then verb( decltype(intVal) iv(3); // iv is an int declType( (intVal) ) iref(intVal); // iref is an int & declType(intTmp()) tmpRef(f()); // tmpRef is an int && ) In addition to this, tt(decltype(auto)) specifications, in which case tt(decltype's) rules are applied to tt(auto) are supported since the C++14 standard. E.g., verb( decltype(auto) iref2((intVal)); // iref2 is an int & auto iref3((intVal)); // iref3 is an int ) The tt(auto) keyword can also be used to postpone the definition of a function's return type. The declaration of a function tt(intArrPtr) returning a pointer to an array of 10 tt(int)s looks like this: verb( int (*intArrPtr())[10]; ) Such a declaration is fairly complex. E.g., among other complexities it requires `protection of the pointer'hi(pointer protection) using parentheses in combination with the function's parameter list. In situations like these the specification of the return type can be postponed using the tt(auto) return type, followed by the specification of the function's return type after any other specification the function might receive (e.g., as a const member (cf. section ref(ConstFunctions)) or following its tt(noexcept) specification (cf. section ref(NOEXCEPT))). Using tt(auto) to declare the above function, the declaration becomes: verb( auto intArrPtr() -> int (*)[10]; ) A return type specification using tt(auto) is called a emi(late-specified return type). The tt(auto) keyword can also be used to defined types that are related to the actual tt(auto) associated type. Here are some examples: verb( vector vi; auto iter = vi.begin(); // standard: auto is vector::iterator auto &&rref = vi.begin(); // auto is rvalue ref. to the iterator type auto *ptr = &iter; // auto is pointer to the iterator type auto *ptr = &rref; // same ) Since the C++14 standard late return type specifications are no longer required for functions returning tt(auto). Such functions can now simply be declared like this: verb( auto autoReturnFunction(); ) In this case some restrictions apply, both to the function definitions and the function declarations: itemization( it() If multiple return statements are used in function definitions they all must be of the same type; it() Functions merely returning tt(auto) cannot be used before the compiler has seen their definitions. So they cannot be used after mere declarations; it() When functions returning tt(auto) are implemented as recursive function then at least one return statement must have been seen before the recursive call. E.g., verb( auto fibonacci(size_t n) { if (n <= 1) return n; return fibonacci(n - 1) + fibonacci(n - 2); } ) ) c++-annotations-10.6.0/yo/first/cast.yo0000644000175000017500000000155712745054222016561 0ustar frankfrankTraditionally, bf(C) offers the following em(cast) syntax: verb( (typename)expression) here tt(typename) is the name of a valid em(type), and tt(expression) is an expression. bf(C) style casts are now deprecated. bf(C++) programs should merely use the new style bf(C++) casts as they offer the compiler facilities to verify the sensibility of the cast. Facilities which are not offered by the classic bf(C)-style cast. A cast should not be confused with the often used emi(constructor notation): verb( typename(expression) ) the constructor notation is not a cast, but a request to the compiler to construct an (anonymous) variable of type tt(typename) from tt(expression). If casts are really necessary one of several emi(new-style casts) should be used. These new-style casts are introduced in the upcoming sections. c++-annotations-10.6.0/yo/first/references.yo0000644000175000017500000002064313005331173017736 0ustar frankfrankIn addition to the common ways to define variables (plain variables or pointers) bf(C++) introduces hi(reference)em(references) defining synonyms for variables. A reference to a variable is like an em(alias); the variable and the reference can both be used in statements involving the variable: verb( int int_value; int &ref = int_value; ) In the above example a variable tt(int_value) is defined. Subsequently a reference tt(ref) is defined, which (due to its initialization) refers to the same memory location as tt(int_value). In the definition of tt(ref), the i(reference operator) hi(operator&) tt(&) indicates that tt(ref) is not itself an tt(int) but a reference to one. The two statements verb( ++int_value; ++ref; ) have the same effect: they increment tt(int_value)'s value. Whether that location is called tt(int_value) or tt(ref) does not matter. References serve an important function in bf(C++) as a means to pass modifiable arguments to functions. E.g., in standard bf(C), a function that increases the value of its argument by five and returning nothing needs a pointer parameter: verb( void increase(int *valp) // expects a pointer { // to an int *valp += 5; } int main() { int x; increase(&x); // pass x's address } ) This construction can em(also) be used in bf(C++) but the same effect is also achieved using a reference: verb( void increase(int &valr) // expects a reference { // to an int valr += 5; } int main() { int x; increase(x); // passed as reference } ) It is arguable whether code such as the above should be preferred over bf(C)'s method, though. The statement tt(increase) tt((x)) suggests that not tt(x) itself but a em(copy) is passed. Yet the value of tt(x) changes because of the way tt(increase()) is defined. However, references can also be used to pass objects that are only inspected (without the need for a copy or a const *) or to pass objects whose modification is an accepted side-effect of their use. In those cases using references are strongly preferred over existing alternatives like copy by value or passing pointers. Behind the scenes references are implemented using pointers. So, as far as the compiler is concerned references in bf(C++) are just const pointers. With references, however, the programmer does not need to know or to bother about levels of indirection. An important distinction between plain pointers and references is of course that with references no indirection takes place. For example: verb( extern int *ip; extern int &ir; ip = 0; // reassigns ip, now a 0-pointer ir = 0; // ir unchanged, the int variable it refers to // is now 0. ) In order to prevent confusion, we suggest to adhere to the following: itemization( it() In those situations where a function does not alter its parameters of a built-in or pointer type, value parameters can be used: verb( void some_func(int val) { cout << val << '\n'; } int main() { int x; some_func(x); // a copy is passed } ) it() When a function explicitly must change the values of its arguments, a pointer parameter is preferred. These pointer parameters should preferably be the function's initial parameters. This is called emi(return by argument). verb( void by_pointer(int *valp) { *valp += 5; } ) it() When a function doesn't change the value of its class- or struct-type arguments, or if the modification of the argument is a trivial side-effect (e.g., the argument is a stream) references can be used. Const-references should be used if the function does not modify the argument: verb( void by_reference(string const &str) { cout << str; // no modification of str } int main () { int x = 7; by_pointer(&x); // a pointer is passed // x might be changed string str("hello"); by_reference(str); // str is not altered } ) References play an important role in cases where the argument is not changed by the function but where it is undesirable to copy the argument to initialize the parameter. Such a situation occurs when a large object is passed as argument, or is returned by the function. In these cases the copying operation tends to become a significant factor, as the entire object must be copied. In these cases references are preferred. If the argument isn't modified by the function, or if the caller shouldn't modify the returned information, the tt(const) keyword should be used. Consider the following example: verb( struct Person // some large structure { char name[80]; char address[90]; double salary; }; Person person[50]; // database of persons // printperson expects a // reference to a structure // but won't change it void printperson (Person const &p) { cout << "Name: " << p.name << '\n' << "Address: " << p.address << '\n'; } // get a person by indexvalue Person const &personIdx(int index) { return person[index]; // a reference is returned, } // not a copy of person[index] int main() { Person boss; printperson (boss); // no pointer is passed, // so variable won't be // altered by the function printperson(personIdx(5)); // references, not copies // are passed here } ) it() Furthermore, note that there is yet another reason for using references when passing objects as function arguments. When passing a reference to an object, the activation of a so called em(copy constructor) is avoided. Copy constructors are covered in chapter ref(MEMORY). ) References em(could) result in extremely `ugly' code. A function may return a reference to a variable, as in the following example: verb( int &func() { static int value; return value; } ) This allows the use of the following constructions: verb( func() = 20; func() += func(); ) It is probably superfluous to note that such constructions should normally not be used. Nonetheless, there are situations where it is useful to return a reference. We have actually already seen an example of this phenomenon in our previous discussion of streams. In a statement like tt(cout) lshift() tt("Hello") lshift() tt('\n';) the insertion operator returns a reference to tt(cout). So, in this statement first the tt("Hello") is inserted into tt(cout), producing a reference to tt(cout). Through this reference the tt('\n') is then inserted in the tt(cout) object, again producing a reference to tt(cout), which is then ignored. Several differences between pointers and references are pointed out in the next list below: itemization( it() A reference cannot exist by itself, i.e., without something to refer to. A declaration of a reference like center(tt(int &ref;)) is not allowed; what would tt(ref) refer to? it() References can be declared as tt(external). These references were initialized elsewhere. it() References may exist as parameters of functions: they are initialized when the function is called. it() References may be used in the return types of functions. In those cases the function determines what the return value refers to. it() References may be used as data members of classes. We return to this usage later. it() Pointers are variables by themselves. They point at something concrete or just ``at nothing''. it() References are aliases for other variables and cannot be re-aliased to another variable. Once a reference is defined, it refers to its particular variable. it() Pointers (except for const pointers) can be reassigned to point to different variables. it() When an i(address-of operator) hi(operator&) ti(&) is used with a reference, the expression yields the address of the variable to which the reference applies. In contrast, ordinary pointers are variables themselves, so the address of a pointer variable has nothing to do with the address of the variable pointed to. ) c++-annotations-10.6.0/yo/first/cout.yo0000644000175000017500000001515412745054222016577 0ustar frankfrankAnalogous to bf(C), bf(C++) defines standard input- and output streams which are available when a program is executed. The streams are: itemization( it() ti(cout), analogous to ti(stdout), it() ti(cin), analogous to ti(stdin), it() ti(cerr), analogous to ti(stderr). ) Syntactically these streams are not used as functions: instead, data are written to streams or read from them using the operators lshift(), called the emi(insertion operator) and rshift(), called the emi(extraction operator). This is illustrated in the next example: verb( #include using namespace std; int main() { int ival; char sval[30]; cout << "Enter a number:\n"; cin >> ival; cout << "And now a string:\n"; cin >> sval; cout << "The number is: " << ival << "\n" "And the string is: " << sval << '\n'; } ) This program reads a number and a string from the tt(cin) stream (usually the keyboard) and prints these data to tt(cout). With respect to streams, please note: itemization( it() The standard streams are declared in the header file ti(iostream). In the examples in the annotations() this header file is often not mentioned explicitly. Nonetheless, it em(must) be included (either directly or indirectly) when these streams are used. Comparable to the use of the tt(using namespace std;) clause, the reader is expected to tt(#include ) with all the examples in which the standard streams are used. it() The streams tt(cout), tt(cin) and tt(cerr) are variables of so-called emi(class)-types. Such variables are commonly called em(objects). Classes are discussed in detail in chapter ref(Classes) and are used extensively in bf(C++). it() The stream tt(cin) extracts data from a stream and copies the extracted information to variables (e.g., tt(ival) in the above example) using the extraction operator (two consecutive tt(>) characters: rshift()). Later in the Annotations we will describe how operators in bf(C++) can perform quite different actions than what they are defined to do by the language, as is the case here. Function overloading has already been mentioned. In bf(C++) em(operators) can also have multiple definitions, which is called em(operator overloading). it() The operators which manipulate tt(cin), tt(cout) and tt(cerr) (i.e., rshift() and lshift()) also manipulate variables of different types. In the above example tt(cout) lshift() tt(ival) results in the printing of an integer value, whereas tt(cout) lshift() tt("Enter a number") results in the printing of a string. The actions of the operators therefore depend on the types of supplied variables. it() The emi(extraction operator) (rshift()) performs a so called emi(type safe) assignment to a variable by `extracting' its value from a text stream. Normally, the extraction operator skips all emi(white space) hi(skipping leading blanks) characters preceding the values to be extracted. it() Special i(symbolic constants) are used for special situations. Normally a line is terminated by inserting tt("\n") or tt('\n'). But when inserting the ti(endl) symbol the line is terminated followed by the flushing of the stream's internal buffer. Thus, tt(endl) can usually be avoided in favor of tt('\n') resulting in somewhat more efficient code. ) The stream objects tt(cin), tt(cout) and tt(cerr) are not part of the bf(C++) grammar proper. The streams are part of the definitions in the header file tt(iostream). This is comparable to functions like tt(printf) that are not part of the bf(C) grammar, but were originally written by people who considered such functions important and collected them in a run-time library. A program may still use the old-style functions like tt(printf) and tt(scanf) rather than the new-style streams. The two styles can even be mixed. But streams offer several clear advantages and in many bf(C++) programs have completely replaced the old-style bf(C) functions. Some advantages of using streams are: itemization( it() Using insertion and extraction operators is emi(type-safe). The format strings which are used with tt(printf) and tt(scanf) can define wrong format specifiers for their arguments, for which the compiler sometimes can't warn. In contrast, argument checking with tt(cin), tt(cout) and tt(cerr) is performed by the compiler. Consequently it isn't possible to err by providing an tt(int) argument in places where, according to the format string, a string argument should appear. With streams there are no format strings. it() The functions tt(printf) and tt(scanf) (and other functions using format strings) in fact implement a em(mini-language) which is interpreted at run-time. In contrast, with streams the bf(C++) compiler knows exactly which in- or output action to perform given the arguments used. No mini-language here. it() In addition the possibilities of the insertion and extraction operators may be em(extended) allowing objects of classes that didn't exist when the streams were originally designed to be inserted into or extracted from streams. Mini languages as used with tt(printf) cannot be extended. it() The usage of the left-shift and right-shift operators in the context of the streams illustrates yet another capability of bf(C++): operator overloading allowing us to redefine the actions an operator performs in certain contexts. Coming from bf(C) operator overloading requires some getting used to, but after a short little while these overloaded operators feel rather comfortable. it() Streams are independent of the media they operate upon. This (at this point somewhat abstract) notion means that the same code can be used without em(any) modification at all to interface your code to em(any) kind of device. The code using streams can be used when the device is a file on disk; an Internet connection; a digital camera; a DVD device; a satellite link; and much more: you name it. Streams allow your code to be decoupled (independent) of the devices your code is supposed to operate on, which eases maintenance and allows reuse of the same code in new situations. ) The em(iostream library) has a lot more to offer than just tt(cin, cout) and tt(cerr). In chapter ref(IOStreams) em(iostreams) are covered in greater detail. Even though ti(printf) and friends can still be used in bf(C++) programs, streams have practically replaced the old-style bf(C) tt(I/O) functions like tt(printf). If you em(think) you still need to use tt(printf) and related functions, think again: in that case you've probably not yet completely grasped the possibilities of stream objects. c++-annotations-10.6.0/yo/first/attributes.yo0000644000175000017500000000670312745054222020013 0ustar frankfrankAttributes hi(attribute) are compiler directives that are inserted into source files to inform the compiler of some peculiarity of the code (variable or function) following the attribute. The C++ standard defines the following attributes: itemization( ithtq(noreturn)([[noreturn]]) (tt([[noreturn]]) indicates that the function does not return. tt([[noreturn]]'s) behavior is undefined if the function declared with this attribute actually returns. The following standard functions have this attribute: tt(std::_Exit, std::abort, std::exit, std::quick_exit, std::unexpected, std::terminate, std::rethrow_exception, std::throw_with_nested, std::nested_exception::rethrow_nested), Here is an example of a function declaration and definition using the tt([[noreturn]]) attribute: verb( [[noreturn]] void doesntReturn(); [[noreturn]] void doesntReturn() { exit(0); } ) ) ithtq(carries_dependency)([[carries_dependency]]) (This attribute is currently not yet covered by the annotations(). At this point in the annotations() it can safely be ignored. COMMENT( tt([[carries_dependency]]) Indicates that dependency chain in release-consume std::memory_order propagates in and out of the function, which allows the compiler to skip unnecessary memory fence instructions. This attribute may appear in two situations: (1) it may apply to the parameter declarations of a function or lambda-expressions, in which case it indicates that initialization of the parameter carries dependency into lvalue-to-rvalue conversion of that object. (2) It may apply to the function declaration as a whole, in which case it indicates that the return value carries dependency to the evaluation of the function call expression. This attribute must appear on the first declaration of a function or one of its parameters in any translation unit. If it is not used on the first declaration of a function or one of its parameters in another translation unit, the program is ill-formed; no diagnostic required. See std::kill_dependency for example usage END) ) ithtq(deprecated)([[deprecated]]) (This attribute (and its alternative form tt([[deprecated("reason")]])) is available since the C++14 standard. It indicates that the use of the name or entity declared with this attribute is allowed, but discouraged for some reason. This attribute can be used for classes, typedef-names, variables, non-static data members, functions, enumerations, and template specializations. An existing non-deprecated entity may be redeclared deprecated, but once an entity has been declared deprecated it cannot be redeclared as `undeprecated'. When encountering the tt([[deprecated]]) attribute the compiler generates a warning, e.g., verb( demo.cc:12:24: warning: 'void deprecatedFunction()' is deprecated [-Wdeprecated-declarations] deprecatedFunction(); demo.cc:5:21: note: declared here [[deprecated]] void deprecatedFunction() ) When using the alternative form (e.g., tt([[deprecated("do not use")]] void fun())) the compiler generates a warning showing the text between the double quotes, e.g., verb( demo.cc:12:24: warning: 'void deprecatedFunction()' is deprecated: do not use [-Wdeprecated-declarations] deprecatedFunction(); demo.cc:5:38: note: declared here [[deprecated("do not use")]] void deprecatedFunction() ) ) ) c++-annotations-10.6.0/yo/first/constcast.yo0000644000175000017500000000210212745054222017613 0ustar frankfrankThe tt(const) keyword has been given a special place in casting. Normally anything tt(const) is tt(const) for a good reason. Nonetheless situations may be encountered where the tt(const) can be ignored. For these special situations the tt(const_cast) should be used. Its syntax is: verb( const_cast(expression)) A ti(const_cast(expression)) expression is used to undo the tt(const) attribute of a (pointer) type. The need for a tt(const_cast) may occur in combination with functions from the standard bf(C) library which traditionally weren't always as const-aware as they should. A function tt(strfun(char *s)) might be available, performing some operation on its tt(char *s) parameter without actually modifying the characters pointed to by tt(s). Passing tt(char const hello[] = "hello";) to tt(strfun) produces the warning verb( passing `const char *' as argument 1 of `fun(char *)' discards const) A tt(const_cast) is the appropriate way to prevent the warning: verb( strfun(const_cast(hello));) c++-annotations-10.6.0/yo/first/const.yo0000644000175000017500000001576212745054222016760 0ustar frankfrankEven though the keyword ti(const) is part of the bf(C) grammar, its use is more important and much more common and strictly used in bf(C++) than it is in bf(C). The tt(const) keyword is a modifier stating that the value of a variable or of an argument may not be modified. In the following example the intent is to change the value of a variable tt(ival), which fails: verb( int main() { int const ival = 3; // a constant int // initialized to 3 ival = 4; // assignment produces // an error message } ) This example shows how tt(ival) may be initialized to a given value in its definition; attempts to change the value later (in an assignment) are not permitted. Variables that are declared tt(const) can, in contrast to bf(C), be used to specify the size of an array, as in the following example: verb( int const size = 20; char buf[size]; // 20 chars big ) Another use of the keyword tt(const) is seen in the declaration of pointers, e.g., in pointer-arguments. In the declaration verb( char const *buf; ) tt(buf) is a pointer variable pointing to tt(char)s. Whatever is pointed to by tt(buf) may not be changed through tt(buf): the tt(char)s are declared as tt(const). The pointer tt(buf) itself however may be changed. A statement like tt(*buf = 'a';) is therefore not allowed, while tt(++buf) is. In the declaration verb( char *const buf; ) tt(buf) itself is a tt(const) pointer which may not be changed. Whatever tt(char)s are pointed to by tt(buf) may be changed at will. Finally, the declaration verb( char const *const buf; ) is also possible; here, neither the pointer nor what it points to may be changed. The i(rule of thumb) for the placement of the keyword tt(const) is the following: whatever occurs to the em(left) to the keyword may not be changed. Although simple, this rule of thumb is often used. For example, hi(Stroustrup) Bjarne Stroustrup states (in hi(http://www.research.att.com/...) tlurl(http://www.research.att.com/~bs/bs_faq2.html#constplacement)): quote( em(Should I put "const" before or after the type?) em(I put it before, but that's a matter of taste. "const T" and "T const" were always (both) allowed and equivalent. For example:) verb( const int a = 1; // OK int const b = 2; // also OK ) em(My guess is that using the first version will confuse fewer programmers (``is more idiomatic'').) ) But we've already seen an example where applying this simple `before' placement rule for the keyword tt(const) produces unexpected (i.e., unwanted) results as we will shortly see (below). Furthermore, the `idiomatic' before-placement also conflicts with the notion of emi(const functions), which we will encounter in section ref(ConstFunctions). With const functions the keyword tt(const) is also placed behind rather than before the name of the function. The definition or declaration (either or not containing tt(const)) should always be read from the variable or function identifier back to the type indentifier: quote( ``Buf is a const pointer to const characters'' ) This rule of thumb is especially useful in cases where confusion may occur. In examples of bf(C++) code published in other places one often encounters the reverse: tt(const) em(preceding) what should not be altered. That this may result in sloppy code is indicated by our second example above: verb( char const *buf; ) What must remain constant here? According to the sloppy interpretation, the pointer cannot be altered (as tt(const) precedes the pointer). In fact, the char values are the constant entities here, as becomes clear when we try to compile the following program: verb( int main() { char const *buf = "hello"; ++buf; // accepted by the compiler *buf = 'u'; // rejected by the compiler } ) Compilation fails on the statement tt(*buf = 'u';) and em(not) on the statement tt(++buf). hi(Cline) hi(http://www/parashift.com/c++-faq-lite/) i(Marshall Cline)'s turl(C++ FAQ) (http://www.parashift.com/c++-faq-lite/const-correctness.html) gives the same rule (paragraph 18.5) , in a similar context: quote(em( [18.5] What's the difference between "const Fred* p", "Fred* const p" and "const Fred* const p"?) em(You have to read pointer declarations right-to-left.) ) Marshall Cline's advice can be improved, though. Here's a recipe that will effortlessly dissect even the most complex declaration: enumeration( eit() start reading at the variable's name eit() read as far as possible until you reach the end of the declaration or an (as yet unmatched) closing parenthesis. eit() return to the point where you started reading, and read backwards until you reach the beginning of the declaration or a matching opening parenthesis. eit() If you reached an opening parenthese, continue at step 2 beyond the parenthesis where you previously stopped. ) Let's apply this recipe to the following (by itself irrelevant) complex declaration. Little arrows indicate how far we should read at each step and the direction of the arrow indicates the reading direction: verb( char const *(* const (*(*ip)())[])[] ip Start at the variable's name: 'ip' is ip+CHAR(41) Hitting a closing paren: revert --> (*ip) Find the matching open paren: <- 'a pointer to' (*ip)()CHAR(41) The next unmatched closing par: --> 'a function (not expecting arguments)' (*(*ip)()) Find the matching open paren: <- 'returning a pointer to' (*(*ip)())[]CHAR(41) The next closing par: --> 'an array of' (* const (*(*ip)())[]) Find the matching open paren: <-------- 'const pointers to' (* const (*(*ip)())[])[] Read until the end: -> 'an array of' char const *(* const (*(*ip)())[])[] Read backwards what's left: <----------- 'pointers to const chars' ) Collecting all the parts, we get for tt(char const *(* const (*(*ip)())[])[]): em(ip is a pointer to a function (not expecting arguments), returning a pointer to an array of const pointers to an array of pointers to const chars). This is what tt(ip) represents; the recipe can be used to parse any declaration you ever encounter. c++-annotations-10.6.0/yo/string/0000755000175000017500000000000012745054222015425 5ustar frankfrankc++-annotations-10.6.0/yo/string/examples/0000755000175000017500000000000013005340354017235 5ustar frankfrankc++-annotations-10.6.0/yo/string/examples/stringreplace.cc0000644000175000017500000000213313005340356022407 0ustar frankfrank #include #include using namespace std; int main(int argc, char **argv) { if (argc != 3) { cerr << "Usage: to process " "stdin\n"; return 1; } string search(argv[1]); string replace(argv[2]); if (search == replace) { cerr << "The replace and search texts should be different\n"; return 1; } string line; while (getline(cin, line)) { string::size_type idx = 0; while (true) { idx = line.find(search, idx); // find(): another string member // see `searching' below if (idx == string::npos) break; line.replace(idx, search.size(), replace); idx += replace.length(); // don't change the replacement } cout << line << '\n'; } } c++-annotations-10.6.0/yo/string/examples/stringempty.cc0000644000175000017500000000077713005340356022146 0ustar frankfrank #include #include using namespace std; int main() { string stringOne; cout << "The length of the stringOne string is " << stringOne.size() << " characters\n" "It is " << (stringOne.empty() ? "" : " not ") << "empty\n"; stringOne = ""; cout << "After assigning a \"\"-string to a string-object\n" "it is " << (stringOne.empty() ? "also" : " not") << " empty\n"; } c++-annotations-10.6.0/yo/string/examples/stringinsert.cc0000644000175000017500000000071613005340356022305 0ustar frankfrank #include #include using namespace std; int main() { string stringOne("Hell ok."); // Insert "o " at position 4 stringOne.insert(4, "o "); string world("The World of C++"); // insert "World" into stringOne stringOne.insert(6, world, 4, 5); cout << "Guess what ? It is: " << stringOne << '\n'; } c++-annotations-10.6.0/yo/string/examples/stringcompare.cc0000644000175000017500000000163213005340356022425 0ustar frankfrank #include #include using namespace std; int main() { string stringOne("Hello World"); string stringTwo; if (stringOne != stringTwo) stringTwo = stringOne; if (stringOne == stringTwo) stringTwo = "Something else"; if (stringOne.compare(stringTwo) > 0) cout << "stringOne after stringTwo in the alphabet\n"; else if (stringOne.compare(stringTwo) < 0) cout << "stringOne before stringTwo in the alphabet\n"; else cout << "The two strings are the same\n"; // Alternatively: if (stringOne > stringTwo) cout << "stringOne after stringTwo in the alphabet\n"; else if (stringOne < stringTwo) cout << "stringOne before stringTwo in the alphabet\n"; else cout << "The two strings are the same\n"; } c++-annotations-10.6.0/yo/string/examples/stringswap.cc0000644000175000017500000000063613005340356021754 0ustar frankfrank #include #include using namespace std; int main() { string stringOne("Hello"); string stringTwo("World"); cout << "Before: stringOne: " << stringOne << ", stringTwo: " << stringTwo << '\n'; stringOne.swap(stringTwo); cout << "After: stringOne: " << stringOne << ", stringTwo: " << stringTwo << '\n'; } c++-annotations-10.6.0/yo/string/examples/stringsubstr.cc0000644000175000017500000000043613005340356022322 0ustar frankfrank #include #include using namespace std; int main() { string stringOne("Hello World"); cout << stringOne.substr(0, 5) << '\n' << stringOne.substr(6) << '\n' << stringOne.substr() << '\n'; } c++-annotations-10.6.0/yo/string/examples/stringsize.cc0000644000175000017500000000037213005340356021751 0ustar frankfrank #include #include using namespace std; int main() { string stringOne("Hello World"); cout << "The length of the stringOne string is " << stringOne.size() << " characters\n"; } c++-annotations-10.6.0/yo/string/examples/stringdata.cc0000644000175000017500000000166413005340356021715 0ustar frankfrank #include #include using namespace std; int main() { string stringOne("Hello World 12345678901234567890 "), stringTwo(5, 'a'), stringThree(stringOne.rbegin(), stringOne.rend()); stringOne.resize(20, 'z'); cout << "World at: " << stringOne.find("World") << '\n'; cout << stringOne << '\n'; stringTwo.append("hello world", 3, 5); stringTwo.insert(1, "..."); cout << stringTwo << '\n'; cout << (stringOne.data() ? "not a 0 ptr." : "0 ptr.") << '\n'; cout << (stringTwo.data() ? "not a 0 ptr." : "0 ptr.") << '\n'; cout << stringOne.data() << '\n' << "'" << stringTwo.data() << "'" << '\n'; cout << stringOne.max_size() << ", " << stringOne.capacity() << '\n'; cout << stringTwo.max_size() << ", " << stringTwo.capacity() << '\n'; return (0); } c++-annotations-10.6.0/yo/string/examples/stringassign.cc0000644000175000017500000000043213005340356022260 0ustar frankfrank #include using namespace std; int main() { string stringOne("Hello World"); string stringTwo; stringTwo = stringOne; // assign stringOne to stringTwo stringTwo = "Hello world"; // assign a C-string to StringTwo } c++-annotations-10.6.0/yo/string/examples/stringcompare2.cc0000644000175000017500000000346513005340356022515 0ustar frankfrank #include #include using namespace std; int main() { string stringOne("Hello World"); // comparing from a certain offset in stringOne if (!stringOne.compare(1, stringOne.length() - 1, "ello World")) cout << "comparing 'Hello world' from index 1" " to 'ello World': ok\n"; // the number of characters to compare (2nd arg.) // may exceed the number of available characters: if (!stringOne.compare(1, string::npos, "ello World")) cout << "comparing 'Hello world' from index 1" " to 'ello World': ok\n"; // comparing from a certain offset in stringOne over a // certain number of characters with a second C-string // This fails, as 3 chars in stringOne starting at // index 6 are compared with "World" if (!stringOne.compare(6, 3, "World")) cout << "comparing 'Hello World' from index 6 over" " 3 positions to 'World and more': ok\n"; else cout << "Unequal (sub)strings\n"; // This one will report a match, as only 5 characters are // compared of the source and target strings if (!stringOne.compare(6, 5, "World and more", 0, 5)) cout << "comparing 'Hello World' from index 6 over" " 5 positions to 'World and more': ok\n"; else cout << "Unequal (sub)strings\n"; } /* Generated output: comparing 'Hello world' from index 1 to 'ello World': ok comparing 'Hello world' from index 1 to 'ello World': ok Unequal (sub)strings comparing 'Hello World' from index 6 over 5 positions to 'World and more': ok */ c++-annotations-10.6.0/yo/string/examples/stringerase.cc0000644000175000017500000000043613005340356022077 0ustar frankfrank #include #include using namespace std; int main() { string stringOne("Hello Cruel World"); stringOne.erase(5, 6); cout << stringOne << '\n'; stringOne.erase(); cout << "'" << stringOne << "'\n"; } c++-annotations-10.6.0/yo/string/examples/stringcstr.cc0000644000175000017500000000033713005340356021753 0ustar frankfrank #include #include using namespace std; int main() { string stringOne("Hello World"); char const *cString = stringOne.c_str(); cout << cString << '\n'; } c++-annotations-10.6.0/yo/string/examples/stringfindfirst.cc0000644000175000017500000000226513005340356022772 0ustar frankfrank #include #include using namespace std; int main() { string line; getline(cin, line); string::size_type pos; cout << "Line: " << line << '\n' << "Starting at the first vowel:\n" << "'" << ( (pos = line.find_first_of("aeiouAEIOU")) != string::npos ? line.substr(pos) : "*** not found ***" ) << "'\n" << "Starting at the last vowel:\n" << "'" << ( (pos = line.find_last_of("aeiouAEIOU")) != string::npos ? line.substr(pos) : "*** not found ***" ) << "'\n" << "Starting at the first non-digit:\n" << "'" << ( (pos = line.find_first_not_of("1234567890")) != string::npos ? line.substr(pos) : "*** not found ***" ) << "'\n"; } c++-annotations-10.6.0/yo/string/examples/stringappend.cc0000644000175000017500000000114413005340356022244 0ustar frankfrank #include #include using namespace std; int main() { string stringOne("Hello"); string stringTwo("World"); stringOne += " " + stringTwo; stringOne = "hello"; stringOne.append(" world"); // append 5 characters: stringOne.append(" ok. >This is not used<", 5); cout << stringOne << '\n'; string stringThree("Hello"); // append " world": stringThree.append(stringOne, 5, 6); cout << stringThree << '\n'; } c++-annotations-10.6.0/yo/string/examples/stringsubscript.cc0000644000175000017500000000117713005340356023021 0ustar frankfrank #include #include using namespace std; int main() { string stringOne("Hello World"); stringOne[6] = 'w'; // now "Hello world" if (stringOne[0] == 'H') stringOne[0] = 'h'; // now "hello world" // *stringOne = 'H'; // THIS WON'T COMPILE stringOne = "Hello World"; // Now using the at() // member function: stringOne.at(6) = stringOne.at(0); // now "Hello Horld" if (stringOne.at(0) == 'H') stringOne.at(0) = 'W'; // now "Wello Horld" } c++-annotations-10.6.0/yo/string/members.yo0000644000175000017500000005122612745054222017436 0ustar frankfrankThe tt(std::string) class offers many member function as well as additional non-member functions that should be considered part of the string class. All these functions are listed below in alphabetic order. The symbolic value tt(string::npos) is defined by the string class. It represents `index-not-found' when returned by member functions returning string offset positions. Example: when calling `tt(object.find('x'))' (see below) on a string object not containing the character tt('x'), tt(npos) is returned, as the requested position does not exist. The final 0-byte used in bf(C) strings to indicate the end of an NTBS is em(not) considered part of a bf(C++) string, and so the member function will return tt(npos), rather than tt(length()) when looking for 0 in a string object containing the characters of a bf(C) string. Here are the standard functions that operate on objects of the class string. When a parameter of tt(size_t) is mentioned it may be interpreted as a parameter of type tt(string::size_type), but without defining a default argument value. The type tt(size_type) should be read as tt(string::size_type). With tt(size_type) the default argument values mentioned in section ref(STRINGOVERVIEW) apply. All quoted functions are member functions of the class tt(std::string), except where indicated otherwise. itemization( ithtq(at)(char &at(size_t opos)) (a reference to the character at the indicated position is returned. When called with tt(string const) objects a tt(char const &) is returned. The member function performs range-checking, raising an exception (that by default aborts the program) if an invalid index is passed.) ithtq(append) (string &append(InputIterator begin, InputIterator end)) (the characters in the range defined by tt(begin) and tt(end) are appended to the current string object.) ittq(string &append(string const &argument, size_type apos, size_type an)) (tt(argument) (or a substring) is appended to the current string object.) ittq(string &append(char const *argument, size_type an)) (the first tt(an) characters of tt(argument) are appended to the string object.) ittq(string &append(size_type n, char ch)) (tt(n) characters tt(ch) are appended to the current string object.) ithtq(assign)(string &assign(string const &argument, size_type apos, size_type an)) (tt(argument) (or a substring) is assigned to the string object. If tt(argument) is of type tt(char const *) and one additional argument is provided the second argument is interpreted as a value initializing tt(an), using 0 to initialize tt(apos).) ittq(string &assign(size_type n, char ch)) (tt(n) characters tt(ch) are assigned to the current string object.) ithtq(back)(char &back()) (returns a reference to the last tt(char) stored inside the string object. The result is undefined for empty strings.) ithtq(begin)(string::iterator begin()) (an iterator referring to the first character of the current string object is returned. With tt(const) string objects a tt(const_iterator) is returned.) ithtq(capacity)(size_type capacity() const) (the number of characters that can currently be stored in the string object without needing to resize it is returned.) ithtq(cbegin)(string::const_iterator cbegin()) (a tt(const_iterator) referring to the first character of the current string object is returned.) ithtq(cend)(string::const_iterator cend()) (a tt(const_iterator) referring to the end of the current string object is returned.) ithtq(compare)(int compare(string const &argument) const) (the text stored in the current string object and the text stored in tt(argument) is compared using a lexicographical comparison using the ASCII character collating sequence. zero is returned if the two strings have identical contents, a negative value is returned if the text in the current object should be ordered em(before) the text in tt(argument); a positive value is returned if the text in the current object should be ordered em(beyond) the text in tt(argument).) ittq(int compare(size_t opos, size_t on, string const &argument) const) (a substring of the text stored in the current string object is compared to the text stored in tt(argument). At most tt(on) characters starting at offset tt(opos) are compared to the text in tt(argument).) ittq(int compare(size_t opos, size_t on, string const &argument, size_type apos, size_type an)) (a substring of the text stored in the current string object is compared to a substring of the text stored in tt(argument). At most tt(on) characters of the current string object, starting at offset tt(opos), are compared to at most tt(an) characters of tt(argument), starting at offset tt(apos). In this case tt(argument) em(must) be a string object.) ittq(int compare(size_t opos, size_t on, char const *argument, size_t an)) (a substring of the text stored in the current string object is compared to a substring of the text stored in tt(argument). At most tt(on) characters of the current string object starting at offset tt(opos) are compared to at most tt(an) characters of tt(argument). tt(Argument) must have at least tt(an) characters. The characters may have arbitrary values: 0-valued characters have no special meanings.) ithtq(copy)(size_t copy(char *argument, size_t on, size_type opos) const) (the contents of the current string object are (partially) copied into tt(argument). The actual number of characters copied is returned. The second argument, specifying the number of characters to copy, from the current string object is required. No 0-valued character is appended to the copied string but can be appended to the copied text using an idiom like the following: verb( argument[object.copy(argument, string::npos)] = 0; ) Of course, the programmer should make sure that tt(argument)'s size is large enough to accomodate the additional 0-byte.) ithtq(crbegin)(string::const_reverse_iterator crbegin()) (a tt(const_reverse_iterator) referring to the last character of the current string object is returned.) ithtq(crend)(string::const_reverse_iterator crend()) (a tt(const_reverse_iterator) referring to the begin of the current string object is returned.) ithtq(c_str)(char const *c_str() const) (the contents of the current string object as an NTBS.) ithtq(data)(char const *data() const) (the raw contents of the current string object are returned. Since this member does not return an NTBS (as tt(c_str) does), it can be used to retrieve any kind of information stored inside the current string object including, e.g., series of 0-bytes: verb( string s(2, 0); cout << static_cast(s.data()[1]) << '\n'; ) ) ithtq(empty)(bool empty() const) (tt(true) is returned if the current string object contains no data.) ithtq(end)(string::iterator end()) (an iterator referring to the position just beyond the last character of the current string object is returned. With tt(const) string objects a tt(const_iterator) is returned.) ithtq(erase)(string &erase(size_type opos, size_type on)) (a (sub)string of the information stored in the current string object is erased.) ittq(string::iterator erase(string::iterator begin, string::iterator end)) (the parameter tt(end) is optional. If omitted the value returned by the current object's tt(end) member is used. The characters defined by the tt(begin) and tt(end) iterators are erased. The iterator tt(begin) is returned, which is then referring to the position immediately following the last erased character.) ithtq(find)(size_t find(string const &argument, size_type opos) const) (the first index in the current string object where tt(argument) is found is returned.) ittq(size_t find(char const *argument, size_type opos, size_type an) const) (the first index in the current string object where tt(argument) is found is returned. When all three arguments are specified the first argument em(must) be a tt(char const *).) ittq(size_t find(char ch, size_type opos) const) (the first index in the current string object where tt(ch) is found is returned.) ithtq(find_first_of)(size_t find_first_of(string const &argument, size_type opos) const) (the first index in the current string object where any character in tt(argument) is found is returned.) ittq(size_type find_first_of(char const *argument, size_type opos, size_type an) const) (the first index in the current string object where any character in tt(argument) is found is returned. If tt(opos) is provided it refers to the first index in the current string object where the search for tt(argument) should start. If omitted, the string object is scanned completely. If tt(an) is provided it indicates the number of characters of the tt(char const *) argument that should be used in the search. It defines a substring starting at the beginning of tt(argument). If omitted, all of tt(argument)'s characters are used.) ittq(size_type find_first_of(char ch, size_type opos)) (the first index in the current string object where character tt(ch) is found is returned.) ittq(size_t find_first_not_of(char ch, size_type opos) const) (the first index in the current string object where another character than tt(ch) is found is returned.) ithtq(find_last_of)(size_t find_last_of(string const &argument, size_type opos) const) (the last index in the current string object where any character in tt(argument) is found is returned.) ittq(size_type find_last_of(char const *argument, size_type opos, size_type an) const) (the last index in the current string object where any character in tt(argument) is found is returned. If tt(opos) is provided it refers to the last index in the current string object where the search for tt(argument) should start. If omitted, the string object is scanned completely. If tt(an) is provided it indicates the number of characters of the tt(char const *) argument that should be used in the search. It defines a substring starting at the beginning of tt(argument). If omitted, all of tt(argument)'s characters are used.) ittq(size_type find_last_of(char ch, size_type opos)) (the last index in the current string object where character tt(ch) is found is returned.) ithtq(find_last_not_of)(size_t find_last_not_of(string const &argument, size_type opos) const) (the last index in the current string object where any character em(not) appearing in tt(argument) is found is returned.) ithtq(front)(char &front()) (returns a reference to the first tt(char) stored inside the string object. The result is undefined for empty strings.) ithtq(get_allocator)(allocator_type get_allocator()) (returns the allocator of the class tt(std::string)) ithtq(getline)(istream &std::getline(istream &istr, string &object, char delimiter = '\n')) (Note: this is em(not) a member function of the class tt(string).nl() A line of text is read from tt(istr). All characters until tt(delimiter) (or the end of the stream, whichever comes first) are read from tt(istr) and are stored in tt(object). If the delimiter is encountered it is removed from the stream, but is not stored in tt(line).nl() If the delimiter is not found, tt(istr.eof) returns tt(true) (see section ref(IOSTATES)). Since streams may be interpreted as tt(bool) values (cf. section ref(IOSTATES)) a commonly encountered idiom to read all lines from a stream successively into a string object tt(line) looks like this: verb( while (getline(istr, line)) process(line); ) The contents of the last line, whether or not it was terminated by a delimiter, is eventually also assigned to tt(object).) ithtq(insert)(string &insert(size_t opos, string const &argument, size_type apos, size_type an)) (a (sub)string of tt(argument) is inserted into the current string object at the current string object's index position tt(opos). Arguments for tt(apos) and tt(an) must either both be provided or they must both be omitted.) ittq(string &insert(size_t opos, char const *argument, size_type an)) (tt(argument) (of type tt(char const *)) is inserted at index tt(opos) into the current string object.) ittq(string &insert(size_t opos, size_t count, char ch)) (tt(Count) characters tt(ch) are inserted at index tt(opos) into the current string object.) ittq(string::iterator insert(string::iterator begin, char ch)) (the character tt(ch) is inserted at the current object's position referred to by tt(begin). tt(Begin) is returned.) ittq(string::iterator insert(string::iterator begin, size_t count, char ch)) (tt(Count) characters tt(ch) are inserted at the current object's position referred to by tt(begin). tt(Begin) is returned.) ittq(string::iterator insert(string::iterator begin, InputIterator abegin, InputIterator aend)) (the characters in the range defined by the tt(InputIterators abegin) and tt(aend) are inserted at the current object's position referred to by tt(begin). tt(Begin) is returned.) ithtq(length)(size_t length() const) (the number of characters stored in the current string object is returned.) ithtq(max_size)(size_t max_size() const) (the maximum number of characters that can be stored in the current string object is returned.) ithtq(pop_back)(void pop_back()) (The string's last character is removed from the string object.) ithtq(push_back)(void push_back(char ch)) (The character tt(ch) is appended to the string object.) ithtq(rbegin)(string::reverse_iterator rbegin()) (a reverse iterator referring to the last character of the current string object is returned. With tt(const) string objects a tt(reverse_const_iterator) is returned.) ithtq(rend)(string::iterator rend()) (a reverse iterator referring to the position just before the first character of the current string object is returned. With tt(const) string objects a tt(reverse_const_iterator) is returned.) ithtq(replace)(string &replace(size_t opos, size_t on, string const &argument, size_type apos, size_type an)) (a (sub)string of characters in tt(object) are replaced by the (subset of) characters of tt(argument). If tt(on) is specified as 0 tt(argument) is inserted into tt(object) at offset tt(opos).) ittq(string &replace(size_t opos, size_t on, char const *argument, size_type an)) (a series of characters in tt(object) are replaced by the first tt(an) characters of tt(char const *) argument.) ittq(string &replace(size_t opos, size_t on, size_type count, char ch)) (tt(on) characters of the current string object, starting at index position tt(opos), are replaced by tt(count) characters tt(ch).) ittq(string &replace(string::iterator begin, string::iterator end, string const &argument)) (the series of characters in the current string object defined by the iterators tt(begin) and tt(end) are replaced by tt(argument). If tt(argument) is a tt(char const *), an additional argument tt(an) may be used, specifying the number of characters of tt(argument) that are used in the replacement.) ittq(string &replace(string::iterator begin, string::iterator end, size_type count, char ch)) (the series of characters in the current string object defined by the iterators tt(begin) and tt(end) are replaced by tt(count) characters having values tt(ch).) ittq(string &replace(string::iterator begin, string::iterator end, InputIterator abegin, InputIterator aend)) (the series of characters in the current string object defined by the iterators tt(begin) and tt(end) are replaced by the characters in the range defined by the tt(InputIterators abegin) and tt(aend).) ithtq(reserve)(void reserve(size_t request)) (the current string object's capacity is changed to at least tt(request). After calling this member, tt(capacity)'s return value will be at least tt(request). A request for a smaller size than the value returned by tt(capacity) is ignored. A hi(length_error)tt(std::length_error) exception is thrown if tt(request) exceeds the value returned by tt(max_size) (tt(std::length_error) is defined in the ti(stdexcept) header). Calling tt(reserve()) has the effect of redefining a string's capacity, not of actually making available the memory to the program. This is illustrated by the exception thrown by the string's tt(at()) member when trying to access an element exceeding the string's tt(size) but not the string's tt(capacity).) ithtq(resize)(void resize(size_t size, char ch = 0)) (the current string object is resized to tt(size) characters. If the string object is resized to a size larger than its current size the additional characters will be initialized to tt(ch). If it is reduced in size the characters having the highest indices are chopped off.) ithtq(rfind)(size_t rfind(string const &argument, size_type opos) const) (the last index in the current string object where tt(argument) is found is returned. Searching proceeds from the current object's offset tt(opos) back to its beginning.) ittq(size_t rfind(char const *argument, size_type opos, size_type an) const) (the last index in the current string object where tt(argument) is found is returned. Searching proceeds from the current object's offset tt(opos) back to its beginning. The parameter tt(an) specifies the length of the substring of tt(argument) to look for, starting at tt(argument)'s beginning.) ittq(size_t rfind(char ch, size_type opos)const) (the last index in the current string object where tt(ch) is found is returned. Searching proceeds from the current object's offset tt(opos) back to its beginning.) ithtq(shrink_to_fit)(void shrink_to_fit()) (optionally reduces the amount of memory allocated by a vector to its current size. The implementor is free to ignore or otherwise optimize this request. In order to guarantee a `shrink to fit' operation the verb( string(stringObject).swap(stringObject) ) idiom can be used.) ithtq(size)(size_t size() const) (the number of characters stored in the current string object is returned. This member is a synonym of tt(length()).) ithtq(substr)(string substr(size_type opos, size_type on) const) (a substring of the current string object of at most tt(on) characters starting at index tt(opos) is returned.) ithtq(swap)(void swap(string &argument)) (the contents of the current string object are swapped with the contents of tt(argument). For this member tt(argument) must be a string object and cannot be a tt(char const *).) ) COMMENT( verbinclude(-a examples/stringassign.cc) verbinclude(-a examples/stringcstr.cc) verbinclude(-a examples/stringsubscript.cc) verbinclude(-a examples/stringcompare.cc) verbinclude(-a examples/stringcompare2.cc) verbinclude(-a examples/stringappend.cc) verbinclude(-a examples/stringinsert.cc) verbinclude(-a examples/stringreplace.cc) verbinclude(-a examples/stringswap.cc) verbinclude(-a examples/stringerase.cc) verbinclude(-a examples/stringsubstr.cc) verbinclude(-a examples/stringfindfirst.cc) verbinclude(-a examples/stringsize.cc) verbinclude(-a examples/stringempty.cc) END COMMENT) c++-annotations-10.6.0/yo/string/convertors.yo0000644000175000017500000001257312745054222020212 0ustar frankfrankSeveral string conversion functions are available operating on or producing tt(std::string) objects. These functions are listed below in alphabetic order. They are not member functions, but class-less (free) functions declared in the tt(std) namespace. The tthi(string) header file must be included before they can be used. itemization( ithtq(stof)(float stof(std::string const &str, size_t *pos = 0)) (Initial white space characters in tt(str) are ignored. Then the following sequences of characters are converted to a tt(float) value, which is returned: itemization( it() A decimal floating point constant: itemization( it() An optional + or - character it() A series of decimal digits, possibly containing one decimal point character it() An optional e or E character, followed by an optional - or + character, followed by a series of decimal digits ) it() A hexadecimal floating point constant: itemization( it() An optional + or - character it() 0x or 0X it() A series of hexadecimal digits, possibly containing one decimal point character it() An optional p or P character, followed by an optional - or + character, followed by a series of decimal digits ) it() An infinity expression: itemization( it() An optional + or - character it() The words tt(inf) or tt(infinity) (case insensitive words) ) it() A `not a number' expression: itemization( it() An optional + or - character it() The words tt(nan) or tt(nan(alphanumeric character sequence)) (tt(nan) is a case insensitive word), resulting in a tt(NaN) floating point value ) ) If tt(pos != 0) the index of the first character in tt(str) which was not converted is returned in tt(*pos). A tt(std::invalid_argument) exception is thrown if the characters in tt(str) could not be converted to a tt(float), a tt(std::out_of_range) exception is thrown if the converted value would have exceeded the range of tt(float) values.) ithtq(stod)(double stod(std::string const &str, size_t *pos = 0)) (A conversion as described with tt(stof) is performed, but now to a value of type tt(double).) ithtq(stold)(double stold(std::string const &str, size_t *pos = 0)) (A conversion as described with tt(stof) is performed, but now to a value of type tt(long double).) ithtq(stoi)(int stoi(std::string const &str, size_t *pos = 0, int base = 10)) (Initial white space characters in tt(str) are ignored. Then all characters representing numeric constants of the number system whose tt(base) is specified are converted to an tt(int) value, which is returned. An optional + or - character may prefix the numeric characters. Values starting with 0 are automatically interpreted as octal values, values starting with 0x or 0X as hexadecimal characters. The value tt(base) must be between 2 and 36. If tt(pos != 0) the index of the first character in tt(str) which was not converted is returned in tt(*pos). A tt(std::invalid_argument) exception is thrown if the characters in tt(str) could not be converted to an tt(int), a tt(std::out_of_range) exception is thrown if the converted value would have exceeded the range of tt(int) values. Here is an example of its use: verb( int value = stoi(string(" -123")); // assigns value -123 value = stoi(string(" 123"), 0, 5); // assigns value 38 ) ) ithtq(stol)(long stol(std::string const &str, size_t *pos = 0, int base = 10)) (A conversion as described with tt(stoi) is performed, but now to a value of type tt(long).) ithtq(stoll)(long long stoll(std::string const &str, size_t *pos = 0, int base = 10)) (A conversion as described with tt(stoi) is performed, but now to a value of type tt(long long).) ithtq(stoul)(unsigned long stoul(std::string const &str, size_t *pos = 0, int base = 10)) (A conversion as described with tt(stoi) (not allowing an initial + or - character) is performed, but now to a value of type tt(unsigned long).) ithtq(stoull)(unsigned long long stoull(std::string const &str, size_t *pos = 0, int base = 10)) (A conversion as described with tt(stoul) is performed, but now to a value of type tt(unsigned long long).) ithtq(to_string)(std::string to_string(Type value)) (Type can be of the types tt(int, long, long long, unsigned, unsigned long, unsigned long long, float, double,) or tt(long double). The value of the argument is converted to a textual representation, which is returned as a tt(std::string) value. ) ithtq(to_wstring)(std::string to_wstring(Type value)) (The conversion as described at tt(to_string) is performed, returning a ti(std::wstring).) ) c++-annotations-10.6.0/yo/string/string.yo0000644000175000017500000000545312745054222017313 0ustar frankfrankbf(C++) offers many solutions for common problems. Most of these facilities are part of the em(Standard Template Library) or they are implemented as em(generic algorithms) (see chapter ref(GENERIC)). Among the facilities bf(C++) programmers have developed over and over again are those manipulating chunks of text, commonly called em(strings). The bf(C) programming language offers rudimentary string support. bf(C)'s emi(NTBS) is the foundation upon which an enormous amount of code has been built+footnote(An em(NTBS) (null-terminated byte string, also emi(NTB string)) is a character sequence whose highest-addressed element with defined content has the value zero (the terminating null character); no other character in the sequence has the value zero.). To process text bf(C++) offers a hi(string)tt(std::string) type. In bf(C++) the traditional bf(C) library functions manipulating NTB strings are deprecated in favor of using tt(string) objects. Many problems in bf(C) programs are caused by buffer overruns, boundary errors and allocation problems that can be traced back to improperly using these traditional bf(C) string library functions. Many of these problems can be prevented using bf(C++) string objects. Actually, tt(string) objects are em(class type) variables, and in that sense they are comparable to stream objects like tt(cin) and tt(cout). In this section the use of tt(string) type objects is covered. The focus is on their definition and their use. When using tt(string) objects the emi(member function) em(syntax) is commonly used: verb( stringVariable.operation(argumentList)) For example, if tt(string1) and tt(string2) are variables of type tt(std::string), then verb( string1.compare(string2)) can be used to compare both strings. In addition to the common member functions the tt(string) class also offers a wide variety of em(operators), like the assignment (tt(=)) and the comparison operator (tt(==)). Operators often result in code that is easy to understand and their use is generally preferred over the use of member functions offering comparable functionality. E.g., rather than writing verb( if (string1.compare(string2) == 0) ) the following is generally preferred: verb( if (string1 == string2) ) To define and use tt(string)-type objects, sources must include the header file tthi(string). To merely hi(string: declaring) em(declare) the string type the header i(iosfwd) can be included. In addition to tt(std::string), the header file tt(string) defines the following string types: itemization( iti(std::wstring), a string type consisting of tt(wchar_t) characters; iti(std::u16string), a string type consisting of tt(char16_t) characters; iti(std::u32string), a string type consisting of tt(char32_t) characters. ) c++-annotations-10.6.0/yo/string/initializers.yo0000644000175000017500000000207412745054222020507 0ustar frankfrankAfter defining string objects they are guaranteed to be in a valid state. At em(definition time) string objects may be initialized in one of the following ways: The following tt(string) constructors hi(string constructors) are available: itemization( ittq(string object) (initializes tt(object) to an empty string. When defining a tt(string) this way no argument list may be specified;) ittq(string object(string::size_type count, char ch)) (initializes tt(object) with tt(count) characters tt(ch);) ittq(string object(string const &argument)) (initializes tt(object) with tt(argument);) ittq(string object(std::string const &argument, string::size_type apos, string::size_type an)) (initializes tt(object) with tt(argument)'s contents starting at index position tt(apos), using at most tt(an) of tt(argument)'s characters;) ittq(string object(InputIterator begin, InputIterator end)) (initializes tt(object) with the characters in the range of characters defined by the two tt(InputIterators).) ) c++-annotations-10.6.0/yo/string/operators.yo0000644000175000017500000000620112745054222020013 0ustar frankfrankString objects may be manipulated by member functions but also by operators. Using operators often results in more natural-looking code. In cases where operators are available having equivalent functionality as member function the operator is practically always preferred. The following operators are available for tt(string) objects (in the examples `object' and `argument' refer to existing tt(std::string) objects). itemization( it() plain assignment: quote(a character, bf(C) or bf(C++) string may be assigned to a tt(string) object. The assignment operator returns its left-hand side operand. Example: verb( object = argument; object = "C string"; object = 'x'; object = 120; // same as object = 'x' ) ) it() addition: quote(the arithmetic additive assignment operator and the addition operator add text to a tt(string) object. The compound assignment operator returns its left-hand side operand, the addition operator returns its result in a temporary string object. When using the addition operator either the left-hand side operand or the right-hand side operand must be a tt(std::string) object. The other operand may be a char, a bf(C) string or a bf(C++) string. Example: verb( object += argument; object += "hello"; object += 'x'; // integral expressions are OK argument + otherArgument; // two std::string objects argument + "hello"; // using + at least one "hello" + argument; // std::string is required argument + 'a'; // integral expressions are OK 'a' + argument; ) ) it() index operator: quote(The index operator may be used to retrieve tt(object)'s individual characters, or to assign new values to individual characters of a non-const string object. There is no range-checking (use the tt(at()) member function for that). This operator returns a tt(char &) or tt(char const &). Example: verb( object[3] = argument[5]; ) ) it() logical operators: quote(the logical comparison operators may be applied to two string objects or to a string object and a bf(C) string to compare their contents. These operators return a tt(bool) value. The tt(==, !=, >, >=, <,) and tt(<=) operators are available. The ordering operators perform a lexicographical comparison of their contents using the ASCII character collating sequence. Example: verb( object == object; // true object != (object + 'x'); // true object <= (object + 'x'); // true ) ) it() stream related operators: quote(the insertion-operator (cf. section ref(CoutCinCerr)) may be used to insert a tt(string) object into an tt(ostream), the extraction-operator may be used to extract a string object from an tt(istream). The extraction operator by default first ignores all white space characters and then extracts all consecutively non-blank characters from an tt(istream). Instead of a string a character array may be extracted as well, but the advantage of using a string object should be clear: the destination string object is automatically resized to the required number of characters. Example: verb( cin >> object; cout << object; ) ) ) c++-annotations-10.6.0/yo/string/iterators.yo0000644000175000017500000000246312745054222020017 0ustar frankfrank See section ref(ITERATORS) for details about em(iterators). As a quick introduction to iterators: an iterator acts like a pointer, and pointers can often be used in situations where iterators are requested. Iterators usually come in pairs, defining a range of entities. The begin-iterator points to the first entity, the end-iterator points just beyond the last entity of the range. Their difference is equal to the number of entities in the iterator-range. Iterators play an important role in the context of em(generic algorithms) (cf. chapter ref(GENERIC)). The class tt(std::string) defines the following hi(string: iterator types)em(iterator types): itemization( itt(string::iterator) and tt(string::const_iterator): quote(these iterators are emi(forward iterators). The tt(const_iterator) is returned by tt(string const) objects, the plain tt(iterator) is returned by non-const string objects. Characters referred to by tt(iterators) may be modified;) itt(string::reverse_iterator) and tt(string::reverse_const_iterator): quote(these iterators are also emi(forward iterators) but when em(incrementing) the iterator the em(previous) character in the string object is reached. Other than that they are comparable to, respectively, tt(string::iterator) and tt(string::const_iterator).) ) c++-annotations-10.6.0/yo/string/overview.yo0000644000175000017500000000644012745054222017650 0ustar frankfrankIn this section the string members and string-related operations are referenced. The subsections cover, respectively the string's initializers, iterators, operators, and member functions. The following terminology is used throughout this section: itemization( it() tt(object) is always a tt(string)-object; it() tt(argument) is a tt(string const &) or a tt(char const *) unless indicated otherwise. The contents of an tt(argument) never is modified by the operation processing the tt(argument); it() tt(opos) refers to an offset into an tt(object) string; it() tt(apos) refers to an offset into an tt(argument); it() tt(on) represents a number of characters in an tt(object) (starting at tt(opos)); it() tt(an) represents a number of characters in an tt(argument) (starting at tt(apos)). ) Both tt(opos) and tt(apos) must refer to existing offsets, or an exception (cf. chapter ref(EXCEPTIONS)) is generated. In contrast, tt(an) and tt(on) may exceed the number of available characters, in which case only the available characters are considered. Many members declare default values for tt(on, an) and tt(apos). Some members declare default values for tt(opos). Default offset values are 0, the default values of tt(on) and tt(an) is tt(string::npos), which can be interpreted as `the required number of characters to reach the end of the string'. With members starting their operations at the end of the string object's contents proceeding backwards, the default value of tt(opos) is the index of the object's em(last) character, with tt(on) by default equal to tt(opos + 1), representing the length of the substring em(ending) at tt(opos). In the overview of member functions presented below it may be assumed that all these parameters accept default values unless indicated otherwise. Of course, the default argument values cannot be used if a function requires additional arguments beyond the ones otherwise accepting default values. Some members have overloaded versions expecting an initial argument of type tt(char const *). But even if that is not the case the first argument can em(always) be of type tt(char const *) where a parameter of tt(std::string) is defined. Several member functions accept em(iterators). Section ref(ITERATORS) covers the technical aspects of em(iterators), but these may be ignored at this point without loss of continuity. Like tt(apos) and tt(opos), iterators must refer to existing positions and/or to an existing range of characters within the string object's contents. All tt(string)-member functions computing indices return the predefined constant tt(string::npos) on failure. The the ti(s) i(literal suffix) to indicate that a tt(std::string) constant is intended when a string literal (like tt("hello world")) is used. It can be used after declaring tt(using namespace std) or, more specific, after declaring hi(literals namespace)hi(string_literals namespace) tt(using namespace std::literals::string_literals). When string literals are used when explicitly defining or using tt(std::string) objects the tt(s)-suffix is hardly ever required, but it may come in handy when using the tt(auto) keyword. E.g., tt(auto str = "hello world"s) defines tt(std::string str), whereas it would have been a tt(char const *) if the literal suffix had been omitted. c++-annotations-10.6.0/yo/string/ops.yo0000644000175000017500000001132712745054222016603 0ustar frankfrankSome of the operations that can be performed on strings return indices within the strings. Whenever such an operation fails to find an appropriate index, the em(value) hi(npos)tt(string::npos) is returned. This value is a symbolic value of type hi(size_type)ti(string::size_type), which is (for all practical purposes) an (tt(unsigned)) tt(int). All tt(string) members accepting tt(string) objects as arguments also accept tt(char const *) (NTBS) arguments. The same usually holds true for operators accepting tt(string) objects. Some tt(string)-members use em(iterators). Iterators are formally introduced in section ref(ITERATORS). Member functions using iterators are listed in the next section (ref(STRINGOVERVIEW)), but the iterator concept itself is not further covered by this chapter. Strings support a large variety of members and operators. A short overview listing their capabilities is provided in this section, with subsequent sections offering a detailed discussion. The bottom line: bf(C++) strings are extremely versatile and there is hardly a reason for falling back on the bf(C) library to process text. bf(C++) strings handle all the required memory management and thus memory related problems, which is the #1 source of problems in bf(C) programs, can be prevented when bf(C++) strings are used. Strings do come at a price, though. The class's extensive capabilities have also turned it into a beast. It's hard to learn and master all its features and in the end you'll find that not all that you expected is actually there. For example, tt(std::string) doesn't offer case-insensitive comparisons. But in the end it isn't even as simple as that. It em(is) there, but it is somewhat hidden and at this point in the annotations() it's too early to study into that hidden corner yet. Instead, realize that bf(C)'s standard library em(does) offer useful functions that can be used as long as we're aware of their limitations and are able to avoid their traps. So for now, to perform a traditional i(case-insensitive) comparison of the contents of two tt(std::string) objects tt(str1) and tt(str2) the following will do: hi(strcasecmp) verb( strcasecmp(str1.c_str(), str2.c_str()); ) Strings support the following functionality: itemization( ittq(initialization) (when string objects are defined they are always properly initialized. In other words, they are always in a i(valid state). Strings may be initialized empty or already existing text can be used to initialize strings.) ittq(assignment) (strings may be given new values. New values may be assigned using member functions (like tt(assign)) but a plain assignment operator (i.e., tt(=))may also be used. Furthermore, assignment em(to) a character buffer is also supported.) ittq(conversions) (the partial or complete contents of string objects may be interpreted as bf(C) strings but the string's contents may also be processed as a series of raw binary bytes, not necessarily terminating in a 0-valued character. Furthermore, in many situations plain characters and bf(C) strings may be used where tt(std::string)s are accepted as well.) ittq(breakdown) (the individual characters stored in a string can be accessed using the familiar index operator (tt([])) allowing us to either access or modify information in the middle of a string.) ittq(comparisons) (strings may be compared to other strings (NTB strings) using the familiar logical comparison operators tt(==, !=, <, <=, >) and tt(>=). There are also member functions available offering a more fine-grained comparison.) ittq(modification) (the contents of strings may be modified in many ways. Operators are available to add information to string objects, to insert information in the middle of string objects, or to replace or erase (parts of) a string's contents.) ittq(swapping) (the string's swapping capability allows us in principle to exchange the contents of two string objects without a byte-by-byte copying operation of the string's contents.) ittq(searching) (the locations of characters, sets of characters, or series of characters may be searched for from any position within the string object and either searching in a forward or backward direction.) ittq(housekeeping) (several housekeeping facilities are offered: the string's length, or its empty-state may be interrogated. But string objects may also be resized.) ittq(stream I/O) (strings may be extracted from or inserted into streams. In addition to plain string extraction a line of a text file may be read without running the risk of a buffer overrun. Since extraction and insertion operations are stream based the I/O facilities are em(device independent).) ) c++-annotations-10.6.0/yo/advancedtemplates/0000755000175000017500000000000012745054221017602 5ustar frankfrankc++-annotations-10.6.0/yo/advancedtemplates/examples/0000755000175000017500000000000013005340354021413 5ustar frankfrankc++-annotations-10.6.0/yo/advancedtemplates/examples/typeat.cc0000644000175000017500000000132213005340355023227 0ustar frankfrank#include #include #include "typeat.h" using namespace std; int main() { //EXAMPLE typedef TypeList list3; // TypeAt<3, list3>::Type invalid; TypeAt<0, list3>::Type intVariable = 13; TypeAt<2, list3>::Type boolVariable = true; cout << "The size of the first type is " << sizeof(TypeAt<0, list3>::Type) << ", " "the size of the third type is " << sizeof(TypeAt<2, list3>::Type) << "\n"; if (typeid(TypeAt<1, list3>::Type) == typeid(char)) cout << "The typelist's 2nd type is char\n"; if (typeid(TypeAt<2, list3>::Type) != typeid(char)) cout << "The typelist's 3nd type is not char\n"; //= } c++-annotations-10.6.0/yo/advancedtemplates/examples/append.h0000644000175000017500000000103713005340354023034 0ustar frankfrank#ifndef INCLUDED_APPEND_H_ #define INCLUDED_APPEND_H_ #include "typelist.h" //STRUCTS template struct Append; template struct Prefix; //= //ADDTYPE template struct Append, NewType> { typedef TypeList List; }; template struct Prefix> { typedef TypeList List; }; //= #endif c++-annotations-10.6.0/yo/advancedtemplates/examples/listsize.OBS0000644000175000017500000000020012745054221023623 0ustar frankfrank#include #include "listsize.h" int main() { std::cout << ListSize::size << "\n"; } c++-annotations-10.6.0/yo/advancedtemplates/examples/typeat.h0000644000175000017500000000130613005340354023072 0ustar frankfrank#ifndef INCLUDED_TYPEAT_H_ #define INCLUDED_TYPEAT_H_ #include "typelist.h" //TYPEAT template struct TypeAt; //= //INVALID template struct TypeAt> { static_assert(index < 0, "TypeAt index out of bounds"); typedef TypeAt Type; }; //= //ZERO template struct TypeAt<0, TypeList> { typedef Head Type; }; //= //TYPELIST template struct TypeAt> { typedef typename TypeAt>::Type Type; }; //= #endif c++-annotations-10.6.0/yo/advancedtemplates/examples/basictraits.cc0000644000175000017500000000323613005340355024237 0ustar frankfrank#include #include "basictraits.h" using namespace std; int main() { //MAIN cout << "int: plain type? " << BasicTraits::isPlainType << "\n" "int: ptr? " << BasicTraits::isPointerType << "\n" "int: const? " << BasicTraits::isConst << "\n" "int *: ptr? " << BasicTraits::isPointerType << "\n" "int const *: ptr? " << BasicTraits::isPointerType << "\n" "int const: const? " << BasicTraits::isConst << "\n" "int: reference? " << BasicTraits::isReferenceType << "\n" "int &: reference? " << BasicTraits::isReferenceType << "\n" "int const &: ref ? " << BasicTraits::isReferenceType << "\n" "int const &: const ? " << BasicTraits::isConst << "\n" "int &&: r-reference? " << BasicTraits::isRvalueReferenceType << "\n" "int &&: const? " << BasicTraits::isConst << "\n" "int const &&: r-ref ? "<< BasicTraits:: isRvalueReferenceType << "\n" "int const &&: const ? "<< BasicTraits::isConst << "\n" "\n"; BasicTraits::ValueType value = 12; BasicTraits::RvalueRefType rvalue = int(10); BasicTraits::PtrType ptr = new int(14); cout << value << ' ' << rvalue << ' ' << *ptr << '\n'; //= } c++-annotations-10.6.0/yo/advancedtemplates/examples/userdefined.cc0000644000175000017500000000073513005340355024225 0ustar frankfrank#include using namespace std; template double _kmh(Chars ...chars); double _kmh() { return 0; } template struct factor { enum { value = 10 * factor::value }; }; template<> struct factor<0> { enum {value = 1}; }; template double _kmh(char c, Chars ...chars) { return (c - '0') * factor::value + _kmh(chars ...); } int main() { cout << _kmh('1', '2', '3') << '\n'; } c++-annotations-10.6.0/yo/advancedtemplates/examples/multi.h0000644000175000017500000000677513005340354022735 0ustar frankfrank#include template struct TypeList { TypeList(TypeList const &) = delete; enum { size = sizeof ...(Types) }; }; //VECTOR template struct Vector: public std::vector { Vector(std::initializer_list iniValues) : std::vector(iniValues) {} }; //= //UWRAP template struct UWrap: public Type { UWrap(Type const &type) : Type(type) {} }; //= //MULTIBASE template struct MultiBase; //= //MULTIBASEREC template struct MultiBase : public UWrap, public MultiBase { typedef PolicyT1 Type; typedef MultiBase Base; MultiBase(PolicyT1 && policyt1, PolicyTypes &&...policytypes) : UWrap(std::forward(policyt1)), MultiBase( std::forward(policytypes)...) {} }; //= //MULTIBASEDONE template struct MultiBase {}; //= //MULTI template