- added registry for print_context classes (use print_context_class_info::dump_hierar...
authorChristian Bauer <Christian.Bauer@uni-mainz.de>
Tue, 22 Jul 2003 21:27:46 +0000 (21:27 +0000)
committerChristian Bauer <Christian.Bauer@uni-mainz.de>
Tue, 22 Jul 2003 21:27:46 +0000 (21:27 +0000)
  to show the class hierarchy tree)
- the default output format is now handled by the print_dflt type, but
  print_context remains the base class for the print context hierarchy
- you can override the default output format for functions on a per-function
  basis by specifying one or multiple print_func<C>() (C is a print_context
  type) function options (see inifcns.cpp/abs() for an example)
- better LaTeX and C source output for abs()

ginac/function.pl
ginac/inifcns.cpp
ginac/operators.cpp
ginac/print.cpp
ginac/print.h
ginac/registrar.h
ginac/structure.cpp

index 5397d8d..b3183da 100755 (executable)
@@ -62,6 +62,10 @@ $typedef_series_funcp=generate(
 'typedef ex (* series_funcp_${N})(${SEQ1}, const relational &, int, unsigned);'."\n",
 'const ex &','','');
 
+$typedef_print_funcp=generate(
+'typedef void (* print_funcp_${N})(${SEQ1}, const print_context &);'."\n",
+'const ex &','','');
+
 $eval_func_interface=generate('    function_options & eval_func(eval_funcp_${N} e);'."\n",'','','');
 
 $evalf_func_interface=generate('    function_options & evalf_func(evalf_funcp_${N} ef);'."\n",'','','');
@@ -70,6 +74,16 @@ $derivative_func_interface=generate('    function_options & derivative_func(deri
 
 $series_func_interface=generate('    function_options & series_func(series_funcp_${N} s);'."\n",'','','');
 
+$print_func_interface=generate(
+       <<'END_OF_PRINT_FUNC_INTERFACE','','','');
+    template <class Ctx> function_options & print_func(print_funcp_${N} p)
+    {
+       test_and_set_nparams(${N});
+       set_print_func(Ctx::reg_info.options.get_id(), print_funcp(p));
+       return *this;
+    }
+END_OF_PRINT_FUNC_INTERFACE
+
 $constructors_interface=generate(
 '    function(unsigned ser, ${SEQ1});'."\n",
 'const ex & param${N}','','');
@@ -86,33 +100,40 @@ END_OF_CONSTRUCTORS_IMPLEMENTATION
 $eval_switch_statement=generate(
        <<'END_OF_EVAL_SWITCH_STATEMENT','seq[${N}-1]','','');
        case ${N}:
-               eval_result = ((eval_funcp_${N})(registered_functions()[serial].eval_f))(${SEQ1});
+               eval_result = ((eval_funcp_${N})(opt.eval_f))(${SEQ1});
                break;
 END_OF_EVAL_SWITCH_STATEMENT
 
 $evalf_switch_statement=generate(
        <<'END_OF_EVALF_SWITCH_STATEMENT','eseq[${N}-1]','','');
        case ${N}:
-               return ((evalf_funcp_${N})(registered_functions()[serial].evalf_f))(${SEQ1});
+               return ((evalf_funcp_${N})(opt.evalf_f))(${SEQ1});
 END_OF_EVALF_SWITCH_STATEMENT
 
 $diff_switch_statement=generate(
        <<'END_OF_DIFF_SWITCH_STATEMENT','seq[${N}-1]','','');
        case ${N}:
-               return ((derivative_funcp_${N})(registered_functions()[serial].derivative_f))(${SEQ1},diff_param);
+               return ((derivative_funcp_${N})(opt.derivative_f))(${SEQ1},diff_param);
 END_OF_DIFF_SWITCH_STATEMENT
 
 $series_switch_statement=generate(
        <<'END_OF_SERIES_SWITCH_STATEMENT','seq[${N}-1]','','');
        case ${N}:
                try {
-                       res = ((series_funcp_${N})(registered_functions()[serial].series_f))(${SEQ1},r,order,options);
+                       res = ((series_funcp_${N})(opt.series_f))(${SEQ1},r,order,options);
                } catch (do_taylor) {
                        res = basic::series(r, order, options);
                }
                return res;
 END_OF_SERIES_SWITCH_STATEMENT
 
+$print_switch_statement=generate(
+       <<'END_OF_PRINT_SWITCH_STATEMENT','seq[${N}-1]','','');
+               case ${N}:
+                       ((print_funcp_${N})(pdt[id]))(${SEQ1}, c);
+                       break;
+END_OF_PRINT_SWITCH_STATEMENT
+
 $eval_func_implementation=generate(
        <<'END_OF_EVAL_FUNC_IMPLEMENTATION','','','');
 function_options & function_options::eval_func(eval_funcp_${N} e)
@@ -208,12 +229,14 @@ typedef ex (* eval_funcp)();
 typedef ex (* evalf_funcp)();
 typedef ex (* derivative_funcp)();
 typedef ex (* series_funcp)();
+typedef void (* print_funcp)();
 
 // the following lines have been generated for max. ${maxargs} parameters
 $typedef_eval_funcp
 $typedef_evalf_funcp
 $typedef_derivative_funcp
 $typedef_series_funcp
+$typedef_print_funcp
 // end of generated lines
 
 // Alternatively, an exvector may be passed into the static function, instead
@@ -222,6 +245,7 @@ typedef ex (* eval_funcp_exvector)(const exvector &);
 typedef ex (* evalf_funcp_exvector)(const exvector &);
 typedef ex (* derivative_funcp_exvector)(const exvector &, unsigned);
 typedef ex (* series_funcp_exvector)(const exvector &, const relational &, int, unsigned);
+typedef void (* print_funcp_exvector)(const exvector &, const print_context &);
 
 
 class function_options
@@ -240,24 +264,35 @@ $eval_func_interface
 $evalf_func_interface
 $derivative_func_interface
 $series_func_interface
+$print_func_interface
 // end of generated lines
        function_options & eval_func(eval_funcp_exvector e);
        function_options & evalf_func(evalf_funcp_exvector ef);
        function_options & derivative_func(derivative_funcp_exvector d);
        function_options & series_func(series_funcp_exvector s);
 
+       template <class Ctx> function_options & print_func(print_funcp_exvector p)
+       {
+               print_use_exvector_args = true;
+               set_print_func(Ctx::reg_info.options.get_id(), print_funcp(p));
+               return *this;
+       }
+
        function_options & set_return_type(unsigned rt, unsigned rtt=0);
        function_options & do_not_evalf_params();
        function_options & remember(unsigned size, unsigned assoc_size=0,
                                    unsigned strategy=remember_strategies::delete_never);
        function_options & overloaded(unsigned o);
        function_options & set_symmetry(const symmetry & s);
-       void test_and_set_nparams(unsigned n);
+
        std::string get_name() const { return name; }
        unsigned get_nparams() const { return nparams; }
-       bool has_derivative() const { return derivative_f != NULL; }
 
 protected:
+       bool has_derivative() const { return derivative_f != NULL; }
+       void test_and_set_nparams(unsigned n);
+       void set_print_func(unsigned id, print_funcp f);
+
        std::string name;
        std::string TeX_name;
 
@@ -267,6 +302,7 @@ protected:
        evalf_funcp evalf_f;
        derivative_funcp derivative_f;
        series_funcp series_f;
+       std::vector<print_funcp> print_dispatch_table;
 
        bool evalf_params_first;
 
@@ -283,6 +319,7 @@ protected:
        bool evalf_use_exvector_args;
        bool derivative_use_exvector_args;
        bool series_use_exvector_args;
+       bool print_use_exvector_args;
 
        unsigned functions_with_same_name;
 
@@ -464,6 +501,7 @@ void function_options::initialize()
        evalf_use_exvector_args = false;
        derivative_use_exvector_args = false;
        series_use_exvector_args = false;
+       print_use_exvector_args = false;
        use_remember = false;
        functions_with_same_name = 1;
        symtree = 0;
@@ -562,13 +600,20 @@ void function_options::test_and_set_nparams(unsigned n)
        } else if (nparams!=n) {
                // we do not throw an exception here because this code is
                // usually executed before main(), so the exception could not
-               // caught anyhow
+               // be caught anyhow
                std::cerr << "WARNING: " << name << "(): number of parameters ("
                          << n << ") differs from number set before (" 
                          << nparams << ")" << std::endl;
        }
 }
 
+void function_options::set_print_func(unsigned id, print_funcp f)
+{
+       if (id >= print_dispatch_table.size())
+               print_dispatch_table.resize(id + 1);
+       print_dispatch_table[id] = f;
+}
+
 /** This can be used as a hook for external applications. */
 unsigned function::current_serial = 0;
 
@@ -669,44 +714,67 @@ void function::archive(archive_node &n) const
 void function::print(const print_context & c, unsigned level) const
 {
        GINAC_ASSERT(serial<registered_functions().size());
+       const function_options &opt = registered_functions()[serial];
+       const std::vector<print_funcp> &pdt = opt.print_dispatch_table;
 
-       if (is_a<print_tree>(c)) {
-
-               c.s << std::string(level, ' ') << class_name() << " "
-                   << registered_functions()[serial].name
-                   << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec
-                   << ", nops=" << nops()
-                   << std::endl;
-               unsigned delta_indent = static_cast<const print_tree &>(c).delta_indent;
-               for (size_t i=0; i<seq.size(); ++i)
-                       seq[i].print(c, level + delta_indent);
-               c.s << std::string(level + delta_indent, ' ') << "=====" << std::endl;
+       // Dynamically dispatch on print_context type
+       const print_context_class_info *pc_info = &c.get_class_info();
 
-       } else if (is_a<print_csrc>(c)) {
+next_context:
+       unsigned id = pc_info->options.get_id();
+       if (id >= pdt.size() || pdt[id] == NULL) {
 
-               // Print function name in lowercase
-               std::string lname = registered_functions()[serial].name;
-               size_t num = lname.size();
-               for (size_t i=0; i<num; i++)
-                       lname[i] = tolower(lname[i]);
-               c.s << lname << "(";
+               // Method not found, try parent print_context class
+               const print_context_class_info *parent_pc_info = pc_info->get_parent();
+               if (parent_pc_info) {
+                       pc_info = parent_pc_info;
+                       goto next_context;
+               }
 
-               // Print arguments, separated by commas
-               exvector::const_iterator it = seq.begin(), itend = seq.end();
-               while (it != itend) {
-                       it->print(c);
-                       ++it;
-                       if (it != itend)
-                               c.s << ",";
+               // Method still not found, use default output
+               if (is_a<print_tree>(c)) {
+
+                       c.s << std::string(level, ' ') << class_name() << " "
+                           << opt.name
+                           << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec
+                           << ", nops=" << nops()
+                           << std::endl;
+                       unsigned delta_indent = static_cast<const print_tree &>(c).delta_indent;
+                       for (size_t i=0; i<seq.size(); ++i)
+                               seq[i].print(c, level + delta_indent);
+                       c.s << std::string(level + delta_indent, ' ') << "=====" << std::endl;
+
+               } else if (is_a<print_csrc>(c)) {
+
+                       // Print function name in lowercase
+                       std::string lname = opt.name;
+                       size_t num = lname.size();
+                       for (size_t i=0; i<num; i++)
+                               lname[i] = tolower(lname[i]);
+                       c.s << lname;
+                       printseq(c, '(', ',', ')', exprseq::precedence(), function::precedence());
+
+               } else if (is_a<print_latex>(c)) {
+                       c.s << opt.TeX_name;
+                       printseq(c, '(', ',', ')', exprseq::precedence(), function::precedence());
+               } else {
+                       c.s << opt.name;
+                       printseq(c, '(', ',', ')', exprseq::precedence(), function::precedence());
                }
-               c.s << ")";
 
-       } else if (is_a<print_latex>(c)) {
-               c.s << registered_functions()[serial].TeX_name;
-               printseq(c, '(', ',', ')', exprseq::precedence(), function::precedence());
        } else {
-               c.s << registered_functions()[serial].name;
-               printseq(c, '(', ',', ')', exprseq::precedence(), function::precedence());
+
+               // Method found, call it
+               current_serial = serial;
+               if (opt.print_use_exvector_args)
+                       ((print_funcp_exvector)pdt[id])(seq, c);
+               else switch (opt.nparams) {
+                       // the following lines have been generated for max. ${maxargs} parameters
+${print_switch_statement}
+                       // end of generated lines
+               default:
+                       throw(std::logic_error("function::print(): invalid nparams"));
+               }
        }
 }
 
@@ -721,13 +789,12 @@ ex function::expand(unsigned options) const
 
 ex function::eval(int level) const
 {
-       GINAC_ASSERT(serial<registered_functions().size());
-
        if (level>1) {
                // first evaluate children, then we will end up here again
                return function(serial,evalchildren(level));
        }
 
+       GINAC_ASSERT(serial<registered_functions().size());
        const function_options &opt = registered_functions()[serial];
 
        // Canonicalize argument order according to the symmetry properties
@@ -753,8 +820,8 @@ ex function::eval(int level) const
                return eval_result;
        }
        current_serial = serial;
-       if (registered_functions()[serial].eval_use_exvector_args)
-               eval_result = ((eval_funcp_exvector)(registered_functions()[serial].eval_f))(seq);
+       if (opt.eval_use_exvector_args)
+               eval_result = ((eval_funcp_exvector)(opt.eval_f))(seq);
        else
        switch (opt.nparams) {
                // the following lines have been generated for max. ${maxargs} parameters
@@ -772,7 +839,6 @@ ${eval_switch_statement}
 ex function::evalf(int level) const
 {
        GINAC_ASSERT(serial<registered_functions().size());
-
        const function_options &opt = registered_functions()[serial];
 
        // Evaluate children first
@@ -835,21 +901,22 @@ ex function::thiscontainer(exvector * vp) const
 ex function::series(const relational & r, int order, unsigned options) const
 {
        GINAC_ASSERT(serial<registered_functions().size());
+       const function_options &opt = registered_functions()[serial];
 
-       if (registered_functions()[serial].series_f==0) {
+       if (opt.series_f==0) {
                return basic::series(r, order);
        }
        ex res;
        current_serial = serial;
-       if (registered_functions()[serial].series_use_exvector_args) {
+       if (opt.series_use_exvector_args) {
                try {
-                       res = ((series_funcp_exvector)(registered_functions()[serial].series_f))(seq, r, order, options);
+                       res = ((series_funcp_exvector)(opt.series_f))(seq, r, order, options);
                } catch (do_taylor) {
                        res = basic::series(r, order, options);
                }
                return res;
        }
-       switch (registered_functions()[serial].nparams) {
+       switch (opt.nparams) {
                // the following lines have been generated for max. ${maxargs} parameters
 ${series_switch_statement}
                // end of generated lines
@@ -919,6 +986,7 @@ bool function::match_same_type(const basic & other) const
 
 unsigned function::return_type() const
 {
+       GINAC_ASSERT(serial<registered_functions().size());
        const function_options &opt = registered_functions()[serial];
 
        if (opt.use_return_type) {
@@ -936,6 +1004,7 @@ unsigned function::return_type() const
 
 unsigned function::return_type_tinfo() const
 {
+       GINAC_ASSERT(serial<registered_functions().size());
        const function_options &opt = registered_functions()[serial];
 
        if (opt.use_return_type) {
@@ -966,15 +1035,16 @@ unsigned function::return_type_tinfo() const
 ex function::pderivative(unsigned diff_param) const // partial differentiation
 {
        GINAC_ASSERT(serial<registered_functions().size());
+       const function_options &opt = registered_functions()[serial];
        
        // No derivative defined? Then return abstract derivative object
-       if (registered_functions()[serial].derivative_f == NULL)
+       if (opt.derivative_f == NULL)
                return fderivative(serial, diff_param, seq);
 
        current_serial = serial;
-       if (registered_functions()[serial].derivative_use_exvector_args)
-               return ((derivative_funcp_exvector)(registered_functions()[serial].derivative_f))(seq, diff_param);
-       switch (registered_functions()[serial].nparams) {
+       if (opt.derivative_use_exvector_args)
+               return ((derivative_funcp_exvector)(opt.derivative_f))(seq, diff_param);
+       switch (opt.nparams) {
                // the following lines have been generated for max. ${maxargs} parameters
 ${diff_switch_statement}
                // end of generated lines
index 7b9a0c6..e9c9393 100644 (file)
@@ -59,8 +59,21 @@ static ex abs_eval(const ex & arg)
                return abs(arg).hold();
 }
 
+static void abs_print_latex(const ex & arg, const print_context & c)
+{
+       c.s << "{|"; arg.print(c); c.s << "|}";
+}
+
+static void abs_print_csrc_float(const ex & arg, const print_context & c)
+{
+       c.s << "fabs("; arg.print(c); c.s << ")";
+}
+
 REGISTER_FUNCTION(abs, eval_func(abs_eval).
-                       evalf_func(abs_evalf));
+                       evalf_func(abs_evalf).
+                       print_func<print_latex>(abs_print_latex).
+                       print_func<print_csrc_float>(abs_print_csrc_float).
+                       print_func<print_csrc_double>(abs_print_csrc_float));
 
 
 //////////
index d588b98..345d8f5 100644 (file)
@@ -334,7 +334,7 @@ static void set_print_options(std::ostream & s, unsigned options)
 {
        print_context *p = get_print_context(s);
        if (p == 0)
-               set_print_context(s, print_context(s, options));
+               set_print_context(s, print_dflt(s, options));
        else
                p->options = options;
 }
@@ -343,7 +343,7 @@ std::ostream & operator<<(std::ostream & os, const ex & e)
 {
        print_context *p = get_print_context(os);
        if (p == 0)
-               e.print(print_context(os));
+               e.print(print_dflt(os));
        else
                e.print(*p);
        return os;
@@ -356,7 +356,7 @@ std::istream & operator>>(std::istream & is, ex & e)
 
 std::ostream & dflt(std::ostream & os)
 {
-       set_print_context(os, print_context(os));
+       set_print_context(os, print_dflt(os));
        set_print_options(os, 0);
        return os;
 }
index 1daede8..263aa51 100644 (file)
 
 namespace GiNaC {
 
+/** Next free ID for print_context types. */
+unsigned next_print_context_id = 0;
+
+
+GINAC_IMPLEMENT_PRINT_CONTEXT(print_context, void)
+GINAC_IMPLEMENT_PRINT_CONTEXT(print_dflt, print_context)
+GINAC_IMPLEMENT_PRINT_CONTEXT(print_latex, print_context)
+GINAC_IMPLEMENT_PRINT_CONTEXT(print_python, print_context)
+GINAC_IMPLEMENT_PRINT_CONTEXT(print_python_repr, print_context)
+GINAC_IMPLEMENT_PRINT_CONTEXT(print_tree, print_context)
+GINAC_IMPLEMENT_PRINT_CONTEXT(print_csrc, print_context)
+GINAC_IMPLEMENT_PRINT_CONTEXT(print_csrc_float, print_csrc)
+GINAC_IMPLEMENT_PRINT_CONTEXT(print_csrc_double, print_csrc)
+GINAC_IMPLEMENT_PRINT_CONTEXT(print_csrc_cl_N, print_csrc)
+
 print_context::print_context()
        : s(std::cout), options(0) {}
 print_context::print_context(std::ostream & os, unsigned opt)
        : s(os), options(opt) {}
 
+print_dflt::print_dflt()
+       : print_context(std::cout) {}
+print_dflt::print_dflt(std::ostream & os, unsigned opt)
+       : print_context(os, opt) {}
+
 print_latex::print_latex()
        : print_context(std::cout) {}
 print_latex::print_latex(std::ostream & os, unsigned opt)
@@ -46,6 +66,8 @@ print_python_repr::print_python_repr()
 print_python_repr::print_python_repr(std::ostream & os, unsigned opt)
        : print_context(os, opt) {}
 
+print_tree::print_tree()
+       : print_context(std::cout), delta_indent(4) {}
 print_tree::print_tree(unsigned d)
        : print_context(std::cout), delta_indent(d) {}
 print_tree::print_tree(std::ostream & os, unsigned opt, unsigned d)
index 8d4fc2f..54b6ca7 100644 (file)
 #include <iosfwd>
 #include <string>
 
+#include "class_info.h"
+
 namespace GiNaC {
 
 
-/*
- *  The following classes remain publicly visible for compatibility
- *  reasons only. New code should use the iostream manipulators defined
- *  in operators.h instead.
- */
+/** This class stores information about a registered print_context class. */
+class print_context_options {
+public:
+       print_context_options(const char *n, const char *p, unsigned i)
+        : name(n), parent_name(p), id(i) {}
+
+       const char *get_name() const { return name; }
+       const char *get_parent_name() const { return parent_name; }
+       unsigned get_id() const { return id; }
+
+private:
+       const char *name;         /**< Class name. */
+       const char *parent_name;  /**< Name of superclass. */
+       unsigned id;              /**< ID number (assigned automatically). */
+};
+
+typedef class_info<print_context_options> print_context_class_info;
 
 
 /** Flags to control the behavior of a print_context. */
@@ -45,53 +59,82 @@ public:
 };
 
 
-/** Context for default (ginsh-parsable) output. */
+/** Macro for inclusion in the declaration of a print_context class.
+ *  It declares some functions that are common to all classes derived
+ *  from 'print_context' as well as all required stuff for the GiNaC
+ *  registry. */
+#define GINAC_DECLARE_PRINT_CONTEXT(classname, supername) \
+public: \
+       typedef supername inherited; \
+       friend class function_options; \
+private: \
+       static GiNaC::print_context_class_info reg_info; \
+public: \
+       virtual const GiNaC::print_context_class_info &get_class_info() const { return reg_info; } \
+       virtual const char *class_name() const { return reg_info.options.get_name(); } \
+       \
+       classname(); \
+       classname * duplicate() const { return new classname(*this); } \
+private:
+
+/** Macro for inclusion in the implementation of each print_context class. */
+#define GINAC_IMPLEMENT_PRINT_CONTEXT(classname, supername) \
+       GiNaC::print_context_class_info classname::reg_info = GiNaC::print_context_class_info(print_context_options(#classname, #supername, next_print_context_id++));
+
+extern unsigned next_print_context_id;
+
+
+/** Base class for print_contexts. */
 class print_context
 {
+       GINAC_DECLARE_PRINT_CONTEXT(print_context, void)
 public:
-       print_context();
        print_context(std::ostream &, unsigned options = 0);
        virtual ~print_context() {}
-       virtual print_context * duplicate() const {return new print_context(*this);}
 
        std::ostream & s; /**< stream to output to */
        unsigned options; /**< option flags */
 };
 
+/** Context for default (ginsh-parsable) output. */
+class print_dflt : public print_context
+{
+       GINAC_DECLARE_PRINT_CONTEXT(print_dflt, print_context)
+public:
+       print_dflt(std::ostream &, unsigned options = 0);
+};
+
 /** Context for latex-parsable output. */
 class print_latex : public print_context
 {
+       GINAC_DECLARE_PRINT_CONTEXT(print_latex, print_context)
 public:
-       print_latex();
        print_latex(std::ostream &, unsigned options = 0);
-       print_context * duplicate() const {return new print_latex(*this);}
 };
 
 /** Context for python pretty-print output. */
 class print_python : public print_context
 {
+       GINAC_DECLARE_PRINT_CONTEXT(print_python, print_context)
 public:
-       print_python();
        print_python(std::ostream &, unsigned options = 0);
-       print_context * duplicate() const {return new print_python(*this);}
 };
 
 /** Context for python-parsable output. */
 class print_python_repr : public print_context
 {
+       GINAC_DECLARE_PRINT_CONTEXT(print_python_repr, print_context)
 public:
-       print_python_repr();
        print_python_repr(std::ostream &, unsigned options = 0);
-       print_context * duplicate() const {return new print_python_repr(*this);}
 };
 
 /** Context for tree-like output for debugging. */
 class print_tree : public print_context
 {
+       GINAC_DECLARE_PRINT_CONTEXT(print_tree, print_context)
 public:
-       print_tree(unsigned d = 4);
+       print_tree(unsigned d);
        print_tree(std::ostream &, unsigned options = 0, unsigned d = 4);
-       print_context * duplicate() const {return new print_tree(*this);}
 
        const unsigned delta_indent; /**< size of indentation step */
 };
@@ -99,43 +142,39 @@ public:
 /** Base context for C source output. */
 class print_csrc : public print_context
 {
+       GINAC_DECLARE_PRINT_CONTEXT(print_csrc, print_context)
 public:
-       print_csrc();
        print_csrc(std::ostream &, unsigned options = 0);
-       print_context * duplicate() const {return new print_csrc(*this);}
 };
 
 /** Context for C source output using float precision. */
 class print_csrc_float : public print_csrc
 {
+       GINAC_DECLARE_PRINT_CONTEXT(print_csrc_float, print_csrc)
 public:
-       print_csrc_float();
        print_csrc_float(std::ostream &, unsigned options = 0);
-       print_context * duplicate() const {return new print_csrc_float(*this);}
 };
 
 /** Context for C source output using double precision. */
 class print_csrc_double : public print_csrc
 {
+       GINAC_DECLARE_PRINT_CONTEXT(print_csrc_double, print_csrc)
 public:
-       print_csrc_double();
        print_csrc_double(std::ostream &, unsigned options = 0);
-       print_context * duplicate() const {return new print_csrc_double(*this);}
 };
 
 /** Context for C source output using CLN numbers. */
 class print_csrc_cl_N : public print_csrc
 {
+       GINAC_DECLARE_PRINT_CONTEXT(print_csrc_cl_N, print_csrc)
 public:
-       print_csrc_cl_N();
        print_csrc_cl_N(std::ostream &, unsigned options = 0);
-       print_context * duplicate() const {return new print_csrc_cl_N(*this);}
 };
 
 /** Check if obj is a T, including base classes. */
 template <class T>
 inline bool is_a(const print_context & obj)
-{ return dynamic_cast<const T *>(&obj)!=0; }
+{ return dynamic_cast<const T *>(&obj) != 0; }
 
 } // namespace GiNaC
 
index e6c083f..9dc3f24 100644 (file)
@@ -41,7 +41,7 @@ typedef container<std::list> lst;
 typedef ex (*unarch_func)(const archive_node &n, lst &sym_lst);
 
 
-/** This structure stores information about a registered GiNaC class. */
+/** This class stores information about a registered GiNaC class. */
 class registered_class_options {
 public:
        registered_class_options(const char *n, const char *p, unsigned ti, unarch_func f)
index 9c79333..2dc8849 100644 (file)
@@ -24,7 +24,7 @@
 
 namespace GiNaC {
 
-// Next free tinfo_key for structure types
+/** Next free tinfo_key for structure types. */
 unsigned next_structure_tinfo_key = TINFO_structure;
 
 } // namespace GiNaC