symbol: make get_domain() a virtual method, remove symbol::domain.

This cuts yet another 4 bytes from GiNaC::symbol. While at it, fix a memory
leak in ginsh.

diff --git a/ginac/symbol.cpp b/ginac/symbol.cpp
index a1c15ed16cbc270879f7490eb60f44644bdf9e89..9a729919fcd6ed4d732752cbcd281666f7a6e452 100644 (file)
--- a/ginac/symbol.cpp
+++ b/ginac/symbol.cpp
@@ -45,25 +45,18 @@ GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(symbol, basic,
 
 // symbol
 
 
 // symbol
 

-symbol::symbol()
- :  serial(next_serial++), name(""), TeX_name(""), domain(domain::complex)
+symbol::symbol() : serial(next_serial++), name(""), TeX_name("")

 {
        setflag(status_flags::evaluated | status_flags::expanded);
 }
 
 // realsymbol
 
 {
        setflag(status_flags::evaluated | status_flags::expanded);
 }
 
 // realsymbol
 

-realsymbol::realsymbol()
-{
-       domain = domain::real;
-}
+realsymbol::realsymbol() : symbol() { }

 
 // possymbol
 
 
 // possymbol
 

-possymbol::possymbol()
-{
-       domain = domain::positive;
-}
+possymbol::possymbol() : realsymbol() { }

 
 //////////
 // other constructors
 
 //////////
 // other constructors


@@ -73,34 +66,31 @@ possymbol::possymbol()
 
 // symbol
 
 
 // symbol
 

-symbol::symbol(const std::string & initname, unsigned domain) :
-       serial(next_serial++), name(initname), TeX_name(""),
-       domain(domain)
+symbol::symbol(const std::string & initname) : serial(next_serial++),
+       name(initname), TeX_name("")

 {
        setflag(status_flags::evaluated | status_flags::expanded);
 }
 
 {
        setflag(status_flags::evaluated | status_flags::expanded);
 }
 

-symbol::symbol(const std::string & initname, const std::string & texname, unsigned domain) :
-       serial(next_serial++), name(initname), TeX_name(texname), domain(domain)
+symbol::symbol(const std::string & initname, const std::string & texname) :
+       serial(next_serial++), name(initname), TeX_name(texname)

 {
        setflag(status_flags::evaluated | status_flags::expanded);
 }
 
 // realsymbol
        
 {
        setflag(status_flags::evaluated | status_flags::expanded);
 }
 
 // realsymbol
        

-realsymbol::realsymbol(const std::string & initname, unsigned domain)
- : symbol(initname, domain) { }
+realsymbol::realsymbol(const std::string & initname) : symbol(initname) { }

 
 

-realsymbol::realsymbol(const std::string & initname, const std::string & texname, unsigned domain)
- : symbol(initname, texname, domain) { }
+realsymbol::realsymbol(const std::string & initname, const std::string & texname)
+       : symbol(initname, texname) { }

 
 // possymbol
        
 
 // possymbol
        

-possymbol::possymbol(const std::string & initname, unsigned domain)
- : symbol(initname, domain) { }
+possymbol::possymbol(const std::string & initname) : realsymbol(initname) { }

 
 

-possymbol::possymbol(const std::string & initname, const std::string & texname, unsigned domain)
- : symbol(initname, texname, domain) { }
+possymbol::possymbol(const std::string & initname, const std::string & texname) 
+       : realsymbol(initname, texname) { }

 
 //////////
 // archiving
 
 //////////
 // archiving


@@ -114,8 +104,6 @@ symbol::symbol(const archive_node &n, lst &sym_lst)
                name = std::string("");
        if (!n.find_string("TeXname", TeX_name))
                TeX_name = std::string("");
                name = std::string("");
        if (!n.find_string("TeXname", TeX_name))
                TeX_name = std::string("");

-       if (!n.find_unsigned("domain", domain))
-               domain = domain::complex;

        setflag(status_flags::evaluated | status_flags::expanded);
 }
 
        setflag(status_flags::evaluated | status_flags::expanded);
 }
 


@@ -144,8 +132,6 @@ void symbol::archive(archive_node &n) const
                n.add_string("name", name);
        if (!TeX_name.empty())
                n.add_string("TeX_name", TeX_name);
                n.add_string("name", name);
        if (!TeX_name.empty())
                n.add_string("TeX_name", TeX_name);

-       if (domain != domain::complex)
-               n.add_unsigned("domain", domain);

 }
 
 //////////
 }
 
 //////////


@@ -180,7 +166,7 @@ void symbol::do_print_tree(const print_tree & c, unsigned level) const
        c.s << std::string(level, ' ') << name << " (" << class_name() << ")" << " @" << this
            << ", serial=" << serial
            << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec
        c.s << std::string(level, ' ') << name << " (" << class_name() << ")" << " @" << this
            << ", serial=" << serial
            << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec

-           << ", domain=" << domain
+           << ", domain=" << get_domain()

            << std::endl;
 }
 
            << std::endl;
 }
 


@@ -209,10 +195,10 @@ bool symbol::info(unsigned inf) const
                case info_flags::expanded:
                        return true;
                case info_flags::real:
                case info_flags::expanded:
                        return true;
                case info_flags::real:

-                       return domain == domain::real || domain == domain::positive;
+                       return get_domain() == domain::real || get_domain() == domain::positive;

                case info_flags::positive:
                case info_flags::nonnegative:
                case info_flags::positive:
                case info_flags::nonnegative:

-                       return domain == domain::positive;
+                       return get_domain() == domain::positive;

                case info_flags::has_indices:
                        return false;
        }
                case info_flags::has_indices:
                        return false;
        }


@@ -221,24 +207,16 @@ bool symbol::info(unsigned inf) const
 
 ex symbol::conjugate() const
 {
 
 ex symbol::conjugate() const
 {

-       if (this->domain == domain::complex) {
-               return conjugate_function(*this).hold();
-       } else {
-               return *this;
-       }
+       return conjugate_function(*this).hold();

 }
 
 ex symbol::real_part() const
 {
 }
 
 ex symbol::real_part() const
 {

-       if (domain==domain::real || domain==domain::positive)
-               return *this;

        return real_part_function(*this).hold();
 }
 
 ex symbol::imag_part() const
 {
        return real_part_function(*this).hold();
 }
 
 ex symbol::imag_part() const
 {

-       if (domain==domain::real || domain==domain::positive)
-               return 0;

        return imag_part_function(*this).hold();
 }
 
        return imag_part_function(*this).hold();
 }
 

diff --git a/ginac/symbol.h b/ginac/symbol.h
index 42c6ae3203a421dad3d78dc6d34c8cb07b491626..bd894c9479dad78eb0a985eb2243ced0dcf73be9 100644 (file)
--- a/ginac/symbol.h
+++ b/ginac/symbol.h
@@ -37,15 +37,10 @@ class symbol : public basic
 {
        GINAC_DECLARE_REGISTERED_CLASS(symbol, basic)
 
 {
        GINAC_DECLARE_REGISTERED_CLASS(symbol, basic)
 

-       friend class realsymbol;
-       friend class possymbol;
-
-// member functions
-       

        // other constructors
 public:
        // other constructors
 public:

-       explicit symbol(const std::string & initname, unsigned domain = domain::complex);
-       symbol(const std::string & initname, const std::string & texname, unsigned domain = domain::complex);
+       explicit symbol(const std::string & initname);
+       symbol(const std::string & initname, const std::string & texname);

        
        // functions overriding virtual functions from base classes
 public:
        
        // functions overriding virtual functions from base classes
 public:


@@ -70,7 +65,7 @@ protected:
 public:
        void set_name(const std::string & n) { name = n; }
        std::string get_name() const { return name; }
 public:
        void set_name(const std::string & n) { name = n; }
        std::string get_name() const { return name; }

-       unsigned get_domain() const { return domain; }
+       virtual unsigned get_domain() const { return domain::complex; }

 protected:
        void do_print(const print_context & c, unsigned level) const;
        void do_print_latex(const print_latex & c, unsigned level) const;
 protected:
        void do_print(const print_context & c, unsigned level) const;
        void do_print_latex(const print_latex & c, unsigned level) const;


@@ -83,7 +78,6 @@ protected:
        unsigned serial;                 ///< unique serial number for comparison
        std::string name;                ///< printname of this symbol
        std::string TeX_name;            ///< LaTeX name of this symbol
        unsigned serial;                 ///< unique serial number for comparison
        std::string name;                ///< printname of this symbol
        std::string TeX_name;            ///< LaTeX name of this symbol

-       unsigned domain;                 ///< domain of symbol, complex (default) or real

 private:
        static unsigned next_serial;
 };
 private:
        static unsigned next_serial;
 };


@@ -92,44 +86,33 @@ private:
 /** Specialization of symbol to real domain */
 class realsymbol : public symbol
 {
 /** Specialization of symbol to real domain */
 class realsymbol : public symbol
 {

-       // constructors

 public:
        realsymbol();
 public:
        realsymbol();

-       explicit realsymbol(const std::string & initname, unsigned domain = domain::real);
-       realsymbol(const std::string & initname, const std::string & texname, unsigned domain = domain::real);
+       explicit realsymbol(const std::string & initname);
+       realsymbol(const std::string & initname, const std::string & texname);
+
+       unsigned get_domain() const { return domain::real; }
+
+       ex conjugate() const { return *this; }
+       ex real_part() const { return *this; }
+       ex imag_part() const { return 0; }
+
+       realsymbol* duplicate() const { return new realsymbol(*this); }

 };
 
 
 /** Specialization of symbol to real domain */
 };
 
 
 /** Specialization of symbol to real domain */

-class possymbol : public symbol
+class possymbol : public realsymbol

 {
 {

-       // constructors

 public:
        possymbol();
 public:
        possymbol();

-       explicit possymbol(const std::string & initname, unsigned domain = domain::positive);
-       possymbol(const std::string & initname, const std::string & texname, unsigned domain = domain::positive);
-};
-
+       explicit possymbol(const std::string & initname);
+       possymbol(const std::string & initname, const std::string & texname);

 
 

-// utility functions
+       unsigned get_domain() const { return domain::positive; }

 
 

-/** Specialization of is_exactly_a<realsymbol>(obj) for realsymbol objects. */
-template<> inline bool is_exactly_a<realsymbol>(const basic & obj)
-{
-       if (!is_a<symbol>(obj))
-               return false;
-       unsigned domain = static_cast<const symbol &>(obj).get_domain();
-       return domain==domain::real || domain==domain::positive;
-}
-
-/** Specialization of is_exactly_a<possymbol>(obj) for possymbol objects. */
-template<> inline bool is_exactly_a<possymbol>(const basic & obj)
-{
-       if (!is_a<symbol>(obj))
-               return false;
-       unsigned domain = static_cast<const symbol &>(obj).get_domain();
-       return domain == domain::positive;
-}
+       possymbol* duplicate() const { return new possymbol(*this); }
+};

 
 } // namespace GiNaC
 
 
 } // namespace GiNaC
 

diff --git a/ginsh/ginsh.h b/ginsh/ginsh.h
index a4159b670c7b0b5184c6ebec0c7ddfbf0224ca8f..9d8ef85af64cf1c90086fcafd093b67115d99556 100644 (file)
--- a/ginsh/ginsh.h
+++ b/ginsh/ginsh.h
@@ -66,7 +66,7 @@ extern int num_files;
 extern char **file_list;
 
 // Table of all used symbols
 extern char **file_list;
 
 // Table of all used symbols

-typedef map<string, symbol> sym_tab;
+typedef map<string, ex> sym_tab;

 extern sym_tab syms;
 
 // Type of symbols to generate (real or complex)
 extern sym_tab syms;
 
 // Type of symbols to generate (real or complex)

diff --git a/ginsh/ginsh_lexer.ll b/ginsh/ginsh_lexer.ll
index 817df6ec1d505cb39266c16a70dd9765468380dd..cdb4237be29839949b63be81a32981a5340e8001 100644 (file)
--- a/ginsh/ginsh_lexer.ll
+++ b/ginsh/ginsh_lexer.ll
@@ -113,9 +113,13 @@ real_symbols    return T_REAL_SYMBOLS;
                                sym_tab::const_iterator i = syms.find(yytext);
                                if (i == syms.end()) {
                                        if (symboltype == domain::complex) {
                                sym_tab::const_iterator i = syms.find(yytext);
                                if (i == syms.end()) {
                                        if (symboltype == domain::complex) {

-                                               yylval = syms[yytext] = *(new symbol(yytext));
+                                               symbol tmp(yytext);
+                                               syms[yytext] = tmp;
+                                               yylval = tmp;

                                        } else {
                                        } else {

-                                               yylval = syms[yytext] = *(new symbol(yytext, domain::real));
+                                               realsymbol tmp(yytext);
+                                               syms[yytext] = tmp;
+                                               yylval = tmp;

                                        }
                                } else
                                        yylval = i->second;
                                        }
                                } else
                                        yylval = i->second;