- prepared for 1.0.13 release
[ginac.git] / ginac / container.pl
1 if (($#ARGV!=0) and ($#ARGV!=1)) {
2         die 'usage: container.pl type [maxargs] (type=lst or exprseq)';
3 }
4
5 if ($ARGV[0] eq 'lst') {
6         $type='lst';
7 } elsif ($ARGV[0] eq 'exprseq') {
8         $type='exprseq';
9 } else {
10         die 'only lst and exprseq supported';
11 }
12
13 if ($#ARGV==1) {
14         $maxargs=$ARGV[1];
15 } else {
16         $maxargs=16; # must be greater or equal than the value used in function.pl
17 }
18
19 if ($type eq 'exprseq') {
20
21         # settings for exprseq
22         $CONTAINER="exprseq";
23         $STLHEADER="vector";
24         $reserve=1;
25         $prepend=0;
26         $sort=0;
27         $let_op=0;
28         $open_bracket='(';
29         $close_bracket=')';
30         
31 } elsif ($type eq 'lst') {
32  
33         # settings for lst
34         $CONTAINER="lst";
35         $STLHEADER="list";
36         $reserve=0;
37         $prepend=1;
38         $sort=1;
39         $let_op=1;
40         $open_bracket='{';
41         $close_bracket='}';
42
43 } else {
44         die "invalid type $type";
45 }
46
47 $CONTAINER_UC=uc(${CONTAINER});
48 $STLT="ex".$STLHEADER;
49
50 if ($reserve) {
51         $RESERVE_IMPLEMENTATION="#define RESERVE(s,size) (s).reserve(size)";
52 } else {
53         $RESERVE_IMPLEMENTATION="#define RESERVE(s,size) // no reserve needed for ${STLHEADER}";
54 }
55
56 if ($prepend) {
57         $PREPEND_INTERFACE=<<END_OF_PREPEND_INTERFACE;
58         virtual ${CONTAINER} & prepend(const ex & b);
59         virtual ${CONTAINER} & remove_first(void);
60 END_OF_PREPEND_INTERFACE
61
62         $PREPEND_IMPLEMENTATION=<<END_OF_PREPEND_IMPLEMENTATION;
63 ${CONTAINER} & ${CONTAINER}::prepend(const ex & b)
64 {
65         ensure_if_modifiable();
66         seq.push_front(b);
67         return *this;
68 }
69
70 ${CONTAINER} & ${CONTAINER}::remove_first(void)
71 {
72         ensure_if_modifiable();
73         seq.pop_front();
74         return *this;
75 }
76 END_OF_PREPEND_IMPLEMENTATION
77 } else {
78         $PREPEND_INTERFACE="    // no prepend possible for ${CONTAINER}";
79         $PREPEND_IMPLEMENTATION="";
80 }
81
82 if ($sort) {
83         $SORT_INTERFACE=<<END_OF_SORT_INTERFACE;
84         virtual ${CONTAINER} & sort(void);
85         virtual ${CONTAINER} & unique(void);
86 END_OF_SORT_INTERFACE
87
88         $SORT_IMPLEMENTATION=<<END_OF_SORT_IMPLEMENTATION;
89 ${CONTAINER} & ${CONTAINER}::sort(void)
90 {
91         ensure_if_modifiable();
92         seq.sort(ex_is_less());
93         return *this;
94 }
95
96 ${CONTAINER} & ${CONTAINER}::unique(void)
97 {
98         ensure_if_modifiable();
99         seq.unique(ex_is_equal());
100         return *this;
101 }
102 END_OF_SORT_IMPLEMENTATION
103 } else {
104         $SORT_INTERFACE="    // no sort possible for ${CONTAINER}";
105         $SORT_IMPLEMENTATION="";
106 }
107
108 if ($let_op) {
109         $LET_OP_IMPLEMENTATION=<<END_OF_LET_OP_IMPLEMENTATION
110 ex & ${CONTAINER}::let_op(int i)
111 {
112         GINAC_ASSERT(i>=0);
113         GINAC_ASSERT(i<nops());
114
115         ${STLT}::iterator it=seq.begin();
116         for (int j=0; j<i; j++) {
117                 ++it;
118         }
119         return *it;
120 }
121 END_OF_LET_OP_IMPLEMENTATION
122 } else {
123         $LET_OP_IMPLEMENTATION="// ${CONTAINER}::let_op() will be implemented by user elsewhere";
124 }
125
126 sub generate_seq {
127         my ($seq_template,$n,$separator)=@_;
128         my ($res,$N);
129         
130         $res='';
131         for ($N=1; $N<=$n; $N++) {
132                 $res .= eval('"' . $seq_template . '"');
133                 if ($N!=$n) {
134                         $res .= $separator;
135                 }
136         }
137         return $res;
138 }
139
140 sub generate_from_to {
141         my ($template,$seq_template1,$seq_separator1,$seq_template2,
142             $seq_separator2,$from,$to)=@_;
143         my ($res,$N,$SEQ);
144
145         $res='';
146         for ($N=$from; $N<=$to; $N++) {
147                 $SEQ1=generate_seq($seq_template1,$N,$seq_separator1);
148                 $SEQ2=generate_seq($seq_template2,$N,$seq_separator2);
149                 $res .= eval('"' . $template . '"');
150                 $SEQ1=''; # to avoid main::SEQ1 used only once warning
151                 $SEQ2=''; # same as above
152         }
153         return $res;
154 }
155
156 sub generate {
157         my ($template,$seq_template1,$seq_separator1,$seq_template2,
158             $seq_separator2)=@_;
159         return generate_from_to($template,$seq_template1,$seq_separator1,
160                                                         $seq_template2,$seq_separator2,1,$maxargs);
161 }
162
163 $constructors_interface=generate(
164 '       explicit ${CONTAINER}(${SEQ1});'."\n",
165 'const ex & param${N}',', ','','');
166
167 $constructors_implementation=generate(
168         <<'END_OF_CONSTRUCTORS_IMPLEMENTATION','const ex & param${N}',', ','    seq.push_back(param${N});',"\n");
169 ${CONTAINER}::${CONTAINER}(${SEQ1}) : basic(TINFO_${CONTAINER})
170 {
171         RESERVE(seq,${N});
172 ${SEQ2}
173 }
174 END_OF_CONSTRUCTORS_IMPLEMENTATION
175
176 $interface=<<END_OF_INTERFACE;
177 /** \@file ${CONTAINER}.h
178  *
179  *  Definition of GiNaC's ${CONTAINER}. */
180
181 /*
182  *  This file was generated automatically by container.pl.
183  *  Please do not modify it directly, edit the perl script instead!
184  *  container.pl options: \$CONTAINER=${CONTAINER}
185  *                        \$STLHEADER=${STLHEADER}
186  *                        \$reserve=${reserve}
187  *                        \$prepend=${prepend}
188  *                        \$sort=${sort}
189  *                        \$let_op=${let_op}
190  *                        \$open_bracket=${open_bracket}
191  *                        \$close_bracket=${close_bracket}
192  *                        \$maxargs=${maxargs}
193  *
194  *  GiNaC Copyright (C) 1999-2003 Johannes Gutenberg University Mainz, Germany
195  *
196  *  This program is free software; you can redistribute it and/or modify
197  *  it under the terms of the GNU General Public License as published by
198  *  the Free Software Foundation; either version 2 of the License, or
199  *  (at your option) any later version.
200  *
201  *  This program is distributed in the hope that it will be useful,
202  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
203  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
204  *  GNU General Public License for more details.
205  *
206  *  You should have received a copy of the GNU General Public License
207  *  along with this program; if not, write to the Free Software
208  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
209  */
210
211 #ifndef __GINAC_${CONTAINER_UC}_H__
212 #define __GINAC_${CONTAINER_UC}_H__
213
214 #include <${STLHEADER}>
215
216 // CINT needs <algorithm> to work properly with <vector> and <list> 
217 #include <algorithm>
218
219 #include "basic.h"
220 #include "ex.h"
221
222 namespace GiNaC {
223
224
225 typedef std::${STLHEADER}<ex> ${STLT};
226
227 class ${CONTAINER} : public basic
228 {
229         GINAC_DECLARE_REGISTERED_CLASS(${CONTAINER}, basic)
230
231 public:
232         ${CONTAINER}(${STLT} const & s, bool discardable = false);
233         ${CONTAINER}(${STLT} * vp); // vp will be deleted
234 ${constructors_interface}
235
236 public:
237         void print(const print_context & c, unsigned level = 0) const;
238         unsigned precedence(void) const {return 10;}
239         bool info(unsigned inf) const;
240         unsigned nops() const;
241         ex & let_op(int i);
242         ex map(map_function & f) const;
243         ex eval(int level=0) const;
244         ex subs(const lst & ls, const lst & lr, bool no_pattern = false) const;
245 protected:
246         bool is_equal_same_type(const basic & other) const;
247         unsigned return_type(void) const;
248
249         // new virtual functions which can be overridden by derived classes
250 public:
251         virtual ${CONTAINER} & append(const ex & b);
252         virtual ${CONTAINER} & remove_last(void);
253 ${PREPEND_INTERFACE}
254 ${SORT_INTERFACE}
255 protected:
256         virtual void printseq(const print_context & c, char openbracket, char delim,
257                               char closebracket, unsigned this_precedence,
258                               unsigned upper_precedence = 0) const;
259         virtual ex this${CONTAINER}(${STLT} const & v) const;
260         virtual ex this${CONTAINER}(${STLT} * vp) const;
261
262 protected:
263         bool is_canonical() const;
264         ${STLT} evalchildren(int level) const;
265         ${STLT} * subschildren(const lst & ls, const lst & lr, bool no_pattern = false) const;
266
267 protected:
268         ${STLT} seq;
269 };
270
271 // utility functions
272
273 /** Specialization of is_exactly_a<${CONTAINER}>(obj) for ${CONTAINER} objects. */
274 template<> inline bool is_exactly_a<${CONTAINER}>(const basic & obj)
275 {
276         return obj.tinfo()==TINFO_${CONTAINER};
277 }
278
279 } // namespace GiNaC
280
281 #endif // ndef __GINAC_${CONTAINER_UC}_H__
282
283 END_OF_INTERFACE
284
285 $implementation=<<END_OF_IMPLEMENTATION;
286 /** \@file ${CONTAINER}.cpp
287  *
288  *  Implementation of GiNaC's ${CONTAINER}. */
289
290 /*
291  *  This file was generated automatically by container.pl.
292  *  Please do not modify it directly, edit the perl script instead!
293  *  container.pl options: \$CONTAINER=${CONTAINER}
294  *                        \$STLHEADER=${STLHEADER}
295  *                        \$reserve=${reserve}
296  *                        \$prepend=${prepend}
297  *                        \$let_op=${let_op}
298  *                        \$open_bracket=${open_bracket}
299  *                        \$close_bracket=${close_bracket}
300  *                        \$maxargs=${maxargs}
301  *
302  *  GiNaC Copyright (C) 1999-2003 Johannes Gutenberg University Mainz, Germany
303  *
304  *  This program is free software; you can redistribute it and/or modify
305  *  it under the terms of the GNU General Public License as published by
306  *  the Free Software Foundation; either version 2 of the License, or
307  *  (at your option) any later version.
308  *
309  *  This program is distributed in the hope that it will be useful,
310  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
311  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
312  *  GNU General Public License for more details.
313  *
314  *  You should have received a copy of the GNU General Public License
315  *  along with this program; if not, write to the Free Software
316  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
317  */
318
319 #include <iostream>
320 #include <stdexcept>
321
322 #include "${CONTAINER}.h"
323 #include "ex.h"
324 #include "print.h"
325 #include "archive.h"
326
327 namespace GiNaC {
328
329 GINAC_IMPLEMENT_REGISTERED_CLASS(${CONTAINER}, basic)
330
331 ${RESERVE_IMPLEMENTATION}
332
333 //////////
334 // default ctor, dtor, copy ctor, assignment operator and helpers
335 //////////
336
337 // public
338
339 ${CONTAINER}::${CONTAINER}() : basic(TINFO_${CONTAINER}) {}
340
341 // protected
342
343 void ${CONTAINER}::copy(${CONTAINER} const & other)
344 {
345         inherited::copy(other);
346         seq=other.seq;
347 }
348
349 void ${CONTAINER}::destroy(bool call_parent)
350 {
351         seq.clear();
352         if (call_parent) inherited::destroy(call_parent);
353 }
354
355 //////////
356 // other ctors
357 //////////
358
359 // public
360
361 ${CONTAINER}::${CONTAINER}(${STLT} const & s, bool discardable) :  basic(TINFO_${CONTAINER})
362 {
363         if (discardable) {
364                 seq.swap(const_cast<${STLT} &>(s));
365         } else {
366                 seq=s;
367         }
368 }
369
370 ${CONTAINER}::${CONTAINER}(${STLT} * vp) : basic(TINFO_${CONTAINER})
371 {
372         GINAC_ASSERT(vp!=0);
373         seq.swap(*vp);
374         delete vp;
375 }
376
377 ${constructors_implementation}
378
379 //////////
380 // archiving
381 //////////
382
383 /** Construct object from archive_node. */
384 ${CONTAINER}::${CONTAINER}(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst)
385 {
386         for (unsigned int i=0; true; i++) {
387                 ex e;
388                 if (n.find_ex("seq", e, sym_lst, i))
389                         seq.push_back(e);
390                 else
391                         break;
392         }
393 }
394
395 /** Unarchive the object. */
396 ex ${CONTAINER}::unarchive(const archive_node &n, const lst &sym_lst)
397 {
398         return (new ${CONTAINER}(n, sym_lst))->setflag(status_flags::dynallocated);
399 }
400
401 /** Archive the object. */
402 void ${CONTAINER}::archive(archive_node &n) const
403 {
404         inherited::archive(n);
405         ${STLT}::const_iterator i = seq.begin(), end = seq.end();
406         while (i != end) {
407                 n.add_ex("seq", *i);
408                 ++i;
409         }
410 }
411
412 //////////
413 // functions overriding virtual functions from base classes
414 //////////
415
416 // public
417
418 void ${CONTAINER}::print(const print_context & c, unsigned level) const
419 {
420         if (is_a<print_tree>(c)) {
421
422                 c.s << std::string(level, ' ') << class_name()
423                     << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec
424                     << ", nops=" << nops()
425                     << std::endl;
426                 unsigned delta_indent = static_cast<const print_tree &>(c).delta_indent;
427                 ${STLT}::const_iterator i = seq.begin(), end = seq.end();
428                 while (i != end) {
429                         i->print(c, level + delta_indent);
430                         ++i;
431                 }
432                 c.s << std::string(level + delta_indent,' ') << "=====" << std::endl;
433         } else if (is_a<print_python>(c)) {
434                 printseq(c, '[', ',', ']', precedence(), precedence()+1);
435         } else if (is_a<print_python_repr>(c)) {
436                 c.s << class_name ();
437                 printseq(c, '(', ',', ')', precedence(), precedence()+1);
438         } else {
439                 // always print brackets around seq, ignore upper_precedence
440                 printseq(c, '${open_bracket}', ',', '${close_bracket}', precedence(), precedence()+1);
441         }
442 }
443
444 // ${CONTAINER}::info() will be implemented by user elsewhere";
445
446 unsigned ${CONTAINER}::nops() const
447 {
448         return seq.size();
449 }
450
451 ${LET_OP_IMPLEMENTATION}
452
453 ex ${CONTAINER}::map(map_function & f) const
454 {
455         // This implementation is here because basic::map() uses let_op()
456         // which is not defined for all containers
457         ${STLT} s;
458         RESERVE(s,seq.size());
459         ${STLT}::const_iterator i = seq.begin(), end = seq.end();
460         while (i != end) {
461                 s.push_back(f(*i));
462                 ++i;
463         }
464
465         return this${CONTAINER}(s);
466 }
467
468 ex ${CONTAINER}::eval(int level) const
469 {
470         if (level==1) {
471                 return this->hold();
472         }
473         return this${CONTAINER}(evalchildren(level));
474 }
475
476 ex ${CONTAINER}::subs(const lst & ls, const lst & lr, bool no_pattern) const
477 {
478         ${STLT} *vp = subschildren(ls, lr, no_pattern);
479         if (vp)
480                 return ex_to<basic>(this${CONTAINER}(vp)).basic::subs(ls, lr, no_pattern);
481         else
482                 return basic::subs(ls, lr, no_pattern);
483 }
484
485 // protected
486
487 int ${CONTAINER}::compare_same_type(const basic & other) const
488 {
489         GINAC_ASSERT(is_a<${CONTAINER}>(other));
490         ${CONTAINER} const & o = static_cast<const ${CONTAINER} &>(other);
491
492         ${STLT}::const_iterator it1 = seq.begin(), it1end = seq.end(),
493                                 it2 = o.seq.begin(), it2end = o.seq.end();
494
495         while (it1 != it1end && it2 != it2end) {
496                 int cmpval = it1->compare(*it2);
497                 if (cmpval)
498                         return cmpval;
499                 ++it1; ++it2;
500         }
501
502         return (it1 == it1end) ? (it2 == it2end ? 0 : -1) : 1;
503 }
504
505 bool ${CONTAINER}::is_equal_same_type(const basic & other) const
506 {
507         GINAC_ASSERT(is_a<${CONTAINER}>(other));
508         ${CONTAINER} const &o = static_cast<const ${CONTAINER} &>(other);
509
510         if (seq.size() != o.seq.size())
511                 return false;
512
513         ${STLT}::const_iterator it1 = seq.begin(), it1end = seq.end(),
514                                 it2 = o.seq.begin();
515
516         while (it1 != it1end) {
517                 if (!it1->is_equal(*it2))
518                         return false;
519                 ++it1; ++it2;
520         }
521
522         return true;
523 }
524
525 unsigned ${CONTAINER}::return_type(void) const
526 {
527         return return_types::noncommutative_composite;
528 }
529
530 //////////
531 // new virtual functions which can be overridden by derived classes
532 //////////
533
534 // public
535
536 ${CONTAINER} & ${CONTAINER}::append(const ex & b)
537 {
538         ensure_if_modifiable();
539         seq.push_back(b);
540         return *this;
541 }
542
543 ${CONTAINER} & ${CONTAINER}::remove_last(void)
544 {
545         ensure_if_modifiable();
546         seq.pop_back();
547         return *this;
548 }
549
550 ${PREPEND_IMPLEMENTATION}
551
552 ${SORT_IMPLEMENTATION}
553
554 // protected
555
556 void ${CONTAINER}::printseq(const print_context & c, char openbracket, char delim,
557                             char closebracket, unsigned this_precedence,
558                             unsigned upper_precedence) const
559 {
560         if (this_precedence <= upper_precedence)
561                 c.s << openbracket;
562
563         if (!seq.empty()) {
564                 ${STLT}::const_iterator it = seq.begin(), itend = seq.end();
565                 --itend;
566                 while (it != itend) {
567                         it->print(c, this_precedence);
568                         c.s << delim;
569                         ++it;
570                 }
571                 it->print(c, this_precedence);
572         }
573
574         if (this_precedence <= upper_precedence)
575                 c.s << closebracket;
576 }
577
578 ex ${CONTAINER}::this${CONTAINER}(${STLT} const & v) const
579 {
580         return ${CONTAINER}(v);
581 }
582
583 ex ${CONTAINER}::this${CONTAINER}(${STLT} * vp) const
584 {
585         return ${CONTAINER}(vp);
586 }
587
588 //////////
589 // non-virtual functions in this class
590 //////////
591
592 // public
593
594 // none
595
596 // protected
597
598 bool ${CONTAINER}::is_canonical() const
599 {
600         if (seq.size()<=1) { return 1; }
601
602         ${STLT}::const_iterator it = seq.begin(), itend = seq.end();
603         ${STLT}::const_iterator it_last=it;
604         for (++it; it!=itend; it_last=it, ++it) {
605                 if (it_last->compare(*it)>0) {
606                         if (it_last->compare(*it)>0) {
607                                 std::cout << *it_last << ">" << *it << "\\n";
608                                 return 0;
609                         }
610                 }
611         }
612         return 1;
613 }
614
615
616 ${STLT} ${CONTAINER}::evalchildren(int level) const
617 {
618         ${STLT} s;
619         RESERVE(s,seq.size());
620
621         if (level==1) {
622                 return seq;
623         }
624         if (level == -max_recursion_level) {
625                 throw(std::runtime_error("max recursion level reached"));
626         }
627         --level;
628         ${STLT}::const_iterator it = seq.begin(), itend = seq.end();
629         while (it != itend) {
630                 s.push_back(it->eval(level));
631                 ++it;
632         }
633         return s;
634 }
635
636 ${STLT} * ${CONTAINER}::subschildren(const lst & ls, const lst & lr, bool no_pattern) const
637 {
638         // returns a NULL pointer if nothing had to be substituted
639         // returns a pointer to a newly created epvector otherwise
640         // (which has to be deleted somewhere else)
641
642         ${STLT}::const_iterator cit = seq.begin(), end = seq.end();
643         while (cit != end) {
644                 const ex & subsed_ex = cit->subs(ls, lr, no_pattern);
645                 if (!are_ex_trivially_equal(*cit, subsed_ex)) {
646
647                         // something changed, copy seq, subs and return it
648                         ${STLT} *s=new ${STLT};
649                         RESERVE(*s, seq.size());
650
651                         // copy parts of seq which are known not to have changed
652                         ${STLT}::const_iterator cit2 = seq.begin();
653                         while (cit2 != cit) {
654                                 s->push_back(*cit2);
655                                 ++cit2;
656                         }
657
658                         // copy first changed element
659                         s->push_back(subsed_ex);
660                         ++cit2;
661
662                         // copy rest
663                         while (cit2 != end) {
664                                 s->push_back(cit2->subs(ls, lr, no_pattern));
665                                 ++cit2;
666                         }
667                         return s;
668                 }
669                 ++cit;
670         }
671         
672         return 0; // nothing has changed
673 }
674
675 } // namespace GiNaC
676
677 END_OF_IMPLEMENTATION
678
679 print "Creating interface file ${CONTAINER}.h...";
680 open OUT,">${CONTAINER}.h" or die "cannot open ${CONTAINER}.h";
681 print OUT $interface;
682 close OUT;
683 print "ok.\n";
684
685 print "Creating implementation file ${CONTAINER}.cpp...";
686 open OUT,">${CONTAINER}.cpp" or die "cannot open ${CONTAINER}.cpp";
687 print OUT $implementation;
688 close OUT;
689 print "ok.\n";
690
691 print "done.\n";