- switched to automake build environment
[ginac.git] / ginac / container.pl
1 #!/usr/bin/perl -w
2
3 if ($#ARGV!=0) {
4     die 'usage: container.pl type (type=lst or exprseq)';
5 }
6
7 if ($ARGV[0] eq 'lst') {
8     $type='lst';
9 } elsif ($ARGV[0] eq 'exprseq') {
10     $type='exprseq';
11 } else {
12     die 'only lst and exprseq supported';
13 }
14
15 #$type='lst';
16 #$type='exprseq';
17
18 if ($type eq 'exprseq') {
19
20     # settings for exprseq
21     $CONTAINER="exprseq";
22     $STLHEADER="vector";
23     $reserve=1;
24     $prepend=0;
25     $let_op=0;
26     $open_bracket='(';
27     $close_bracket=')';
28     
29 } elsif ($type eq 'lst') {
30  
31     # settings for lst
32     $CONTAINER="lst";
33     $STLHEADER="list";
34     $reserve=0;
35     $prepend=1;
36     $let_op=1;
37     $open_bracket='[';
38     $close_bracket=']';
39
40 } else {
41     die "invalid type $type";
42 }
43
44 $CONTAINER_UC=uc(${CONTAINER});
45 $STLT="ex".$STLHEADER;
46
47 if ($reserve) {
48     $RESERVE_IMPLEMENTATION="#define RESERVE(s,size) (s).reserve(size)";
49 } else {
50     $RESERVE_IMPLEMENTATION="#define RESERVE(s,size) // no reserve needed for ${STLHEADER}";
51 }
52
53 if ($prepend) {
54     $PREPEND_INTERFACE=<<END_OF_PREPEND_INTERFACE;
55     virtual ${CONTAINER} & prepend(ex const & b);
56 END_OF_PREPEND_INTERFACE
57
58     $PREPEND_IMPLEMENTATION=<<END_OF_PREPEND_IMPLEMENTATION;
59 ${CONTAINER} & ${CONTAINER}::prepend(ex const & b)
60 {
61     ensure_if_modifiable();
62     seq.push_front(b);
63     return *this;
64 }
65 END_OF_PREPEND_IMPLEMENTATION
66 } else {
67     $PREPEND_INTERFACE="    // no prepend possible for ${CONTAINER}";
68     $PREPEND_IMPLEMENTATION="";
69 }
70
71 if ($let_op) {
72     $LET_OP_IMPLEMENTATION=<<END_OF_LET_OP_IMPLEMENTATION
73 ex & ${CONTAINER}::let_op(int const i)
74 {
75     ASSERT(i>=0);
76     ASSERT(i<nops());
77
78     ${STLT}::iterator it=seq.begin();
79     for (int j=0; j<i; j++) {
80         ++it;
81     }
82     return *it;
83 }
84 END_OF_LET_OP_IMPLEMENTATION
85 } else {
86     $LET_OP_IMPLEMENTATION="// ${CONTAINER}::let_op() will be implemented by user elsewhere";
87 }
88
89 $interface=<<END_OF_INTERFACE;
90 /** \@file ${CONTAINER}.h
91  *
92  *  Definition of GiNaC's ${CONTAINER}. 
93  *  This file was generated automatically by container.pl.
94  *  Please do not modify it directly, edit the perl script instead!
95  *  container.pl options: \$CONTAINER=${CONTAINER}
96  *                        \$STLHEADER=${STLHEADER}
97  *                        \$reserve=${reserve}
98  *                        \$prepend=${prepend}
99  *                        \$let_op=${let_op}
100  *                        \$open_bracket=${open_bracket}
101  *                        \$close_bracket=${close_bracket} */
102
103 #ifndef _${CONTAINER_UC}_H_
104 #define _${CONTAINER_UC}_H_
105
106 #include <${STLHEADER}>
107
108 #include <ginac/ginac.h>
109
110 typedef ${STLHEADER}<ex> ${STLT};
111
112 class ${CONTAINER} : public basic
113 {
114
115 public:
116     ${CONTAINER}();
117     ~${CONTAINER}();
118     ${CONTAINER}(${CONTAINER} const & other);
119     ${CONTAINER} const & operator=(${CONTAINER} const & other);
120 protected:
121     void copy(${CONTAINER} const & other);
122     void destroy(bool call_parent);
123
124 public:
125     ${CONTAINER}(${STLT} const & s, bool discardable=0);
126     ${CONTAINER}(${STLT} * vp); // vp will be deleted
127     explicit ${CONTAINER}(ex const & e1);
128     explicit ${CONTAINER}(ex const & e1, ex const & e2);
129     explicit ${CONTAINER}(ex const & e1, ex const & e2, ex const & e3);
130     explicit ${CONTAINER}(ex const & e1, ex const & e2, ex const & e3,
131              ex const & e4);
132     explicit ${CONTAINER}(ex const & e1, ex const & e2, ex const & e3,
133              ex const & e4, ex const & e5);
134     explicit ${CONTAINER}(ex const & e1, ex const & e2, ex const & e3,
135              ex const & e4, ex const & e5, ex const & e6);
136     explicit ${CONTAINER}(ex const & e1, ex const & e2, ex const & e3,
137              ex const & e4, ex const & e5, ex const & e6,
138              ex const & e7);
139     explicit ${CONTAINER}(ex const & e1, ex const & e2, ex const & e3,
140              ex const & e4, ex const & e5, ex const & e6,
141              ex const & e7, ex const & e8);
142     explicit ${CONTAINER}(ex const & e1, ex const & e2, ex const & e3,
143              ex const & e4, ex const & e5, ex const & e6,
144              ex const & e7, ex const & e8, ex const & e9);
145     explicit ${CONTAINER}(ex const & e1, ex const & e2, ex const & e3,
146              ex const & e4, ex const & e5, ex const & e6,
147              ex const & e7, ex const & e8, ex const & e9,
148              ex const &e10);
149
150 public:
151     basic * duplicate() const;
152     void printraw(ostream & os) const;
153     void print(ostream & os, unsigned upper_precedence=0) const;
154     void printtree(ostream & os, unsigned indent) const;
155     bool info(unsigned inf) const;
156     int nops() const;
157     ex & let_op(int const i);
158     ex expand(unsigned options=0) const;
159     bool has(ex const & other) const;
160     ex eval(int level=0) const;
161     ex evalf(int level=0) const;
162     ex normal(lst &sym_lst, lst &repl_lst, int level=0) const;
163     ex diff(symbol const & s) const;
164     ex subs(lst const & ls, lst const & lr) const;
165 protected:
166     int compare_same_type(basic const & other) const;
167     bool is_equal_same_type(basic const & other) const;
168     unsigned return_type(void) const;
169
170     // new virtual functions which can be overridden by derived classes
171 public:
172     virtual ${CONTAINER} & append(ex const & b);
173 ${PREPEND_INTERFACE}
174 protected:
175     virtual void printseq(ostream & os, char openbracket, char delim,
176                           char closebracket, unsigned this_precedence,
177                           unsigned upper_precedence=0) const;
178     virtual ex this${CONTAINER}(${STLT} const & v) const;
179     virtual ex this${CONTAINER}(${STLT} * vp) const;
180
181 protected:
182     bool is_canonical() const;
183     ${STLT} evalchildren(int level) const;
184     ${STLT} evalfchildren(int level) const;
185     ${STLT} normalchildren(int level) const;
186     ${STLT} diffchildren(symbol const & s) const;
187     ${STLT} * subschildren(lst const & ls, lst const & lr) const;
188
189 protected:
190     ${STLT} seq;
191     static unsigned precedence;
192 };
193
194 // global constants
195
196 extern const ${CONTAINER} some_${CONTAINER};
197 extern type_info const & typeid_${CONTAINER};
198
199 // macros
200
201 #define ex_to_${CONTAINER}(X) (static_cast<${CONTAINER} const &>(*(X).bp))
202
203 #endif // ndef _${CONTAINER_UC}_H_
204
205 END_OF_INTERFACE
206
207 $implementation=<<END_OF_IMPLEMENTATION;
208 /** \@file ${CONTAINER}.cpp
209  *
210  *  Implementation of GiNaC's ${CONTAINER}. 
211  *  This file was generated automatically by container.pl.
212  *  Please do not modify it directly, edit the perl script instead!
213  *  container.pl options: \$CONTAINER=${CONTAINER}
214  *                        \$STLHEADER=${STLHEADER}
215  *                        \$reserve=${reserve}
216  *                        \$prepend=${prepend}
217  *                        \$let_op=${let_op}
218  *                        \$open_bracket=${open_bracket}
219  *                        \$close_bracket=${close_bracket} */
220
221 #include <iostream>
222 #include <stdexcept>
223
224 #include "ginac.h"
225
226 ${RESERVE_IMPLEMENTATION}
227
228 //////////
229 // default constructor, destructor, copy constructor assignment operator and helpers
230 //////////
231
232 // public
233
234 ${CONTAINER}::${CONTAINER}() : basic(TINFO_${CONTAINER_UC})
235 {
236     debugmsg("${CONTAINER} default constructor",LOGLEVEL_CONSTRUCT);
237 }
238
239 ${CONTAINER}::~${CONTAINER}()
240 {
241     debugmsg("${CONTAINER} destructor",LOGLEVEL_DESTRUCT);
242     destroy(0);
243 }
244
245 ${CONTAINER}::${CONTAINER}(${CONTAINER} const & other)
246 {
247     debugmsg("${CONTAINER} copy constructor",LOGLEVEL_CONSTRUCT);
248     copy(other);
249 }
250
251 ${CONTAINER} const & ${CONTAINER}::operator=(${CONTAINER} const & other)
252 {
253     debugmsg("${CONTAINER} operator=",LOGLEVEL_ASSIGNMENT);
254     if (this != &other) {
255         destroy(1);
256         copy(other);
257     }
258     return *this;
259 }
260
261 // protected
262
263 void ${CONTAINER}::copy(${CONTAINER} const & other)
264 {
265     basic::copy(other);
266     seq=other.seq;
267 }
268
269 void ${CONTAINER}::destroy(bool call_parent)
270 {
271     seq.clear();
272     if (call_parent) basic::destroy(call_parent);
273 }
274
275 //////////
276 // other constructors
277 //////////
278
279 // public
280
281 ${CONTAINER}::${CONTAINER}(${STLT} const & s, bool discardable) :  basic(TINFO_${CONTAINER_UC})
282 {
283     debugmsg("${CONTAINER} constructor from ${STLT}",
284              LOGLEVEL_CONSTRUCT);
285     if (discardable) {
286         seq.swap(const_cast<${STLT} &>(s));
287     } else {
288         seq=s;
289     }
290 }
291
292 ${CONTAINER}::${CONTAINER}(${STLT} * vp) : basic(TINFO_${CONTAINER_UC})
293 {
294     debugmsg("${CONTAINER} constructor from ${STLT} *",LOGLEVEL_CONSTRUCT);
295     ASSERT(vp!=0);
296     seq.swap(*vp);
297     delete vp;
298 }
299
300 ${CONTAINER}::${CONTAINER}(ex const & e1) :  basic(TINFO_${CONTAINER_UC})
301 {
302     debugmsg("${CONTAINER} constructor from 1 ex",
303              LOGLEVEL_CONSTRUCT);
304     RESERVE(seq,1);
305     seq.push_back(e1);
306 }
307
308 ${CONTAINER}::${CONTAINER}(ex const & e1, ex const & e2) : basic(TINFO_${CONTAINER_UC})
309 {
310     debugmsg("${CONTAINER} constructor from 2 ex",
311              LOGLEVEL_CONSTRUCT);
312     RESERVE(seq,2);
313     seq.push_back(e1);
314     seq.push_back(e2);
315 }
316
317 ${CONTAINER}::${CONTAINER}(ex const & e1, ex const & e2, ex const & e3)
318     : basic(TINFO_${CONTAINER_UC})
319 {
320     debugmsg("${CONTAINER} constructor from 3 ex",
321              LOGLEVEL_CONSTRUCT);
322     RESERVE(seq,3);
323     seq.push_back(e1);
324     seq.push_back(e2);
325     seq.push_back(e3);
326 }
327
328 ${CONTAINER}::${CONTAINER}(ex const & e1, ex const & e2, ex const & e3,
329                      ex const & e4) : basic(TINFO_${CONTAINER_UC})
330 {
331     debugmsg("${CONTAINER} constructor from 4 ex",
332              LOGLEVEL_CONSTRUCT);
333     RESERVE(seq,4);
334     seq.push_back(e1);
335     seq.push_back(e2);
336     seq.push_back(e3);
337     seq.push_back(e4);
338 }
339
340 ${CONTAINER}::${CONTAINER}(ex const & e1, ex const & e2, ex const & e3,
341                      ex const & e4, ex const & e5) : basic(TINFO_${CONTAINER_UC})
342 {
343     debugmsg("${CONTAINER} constructor from 5 ex",
344              LOGLEVEL_CONSTRUCT);
345     RESERVE(seq,5);
346     seq.push_back(e1);
347     seq.push_back(e2);
348     seq.push_back(e3);
349     seq.push_back(e4);
350     seq.push_back(e5);
351 }
352
353 ${CONTAINER}::${CONTAINER}(ex const & e1, ex const & e2, ex const & e3,
354                      ex const & e4, ex const & e5, ex const & e6)
355     : basic(TINFO_${CONTAINER_UC})
356 {
357     debugmsg("${CONTAINER} constructor from 6 ex",
358              LOGLEVEL_CONSTRUCT);
359     RESERVE(seq,6);
360     seq.push_back(e1);
361     seq.push_back(e2);
362     seq.push_back(e3);
363     seq.push_back(e4);
364     seq.push_back(e5);
365     seq.push_back(e6);
366 }
367
368 ${CONTAINER}::${CONTAINER}(ex const & e1, ex const & e2, ex const & e3,
369                      ex const & e4, ex const & e5, ex const & e6,
370                      ex const & e7) : basic(TINFO_${CONTAINER_UC})
371 {
372     debugmsg("${CONTAINER} constructor from 7 ex",
373              LOGLEVEL_CONSTRUCT);
374     RESERVE(seq,7);
375     seq.push_back(e1);
376     seq.push_back(e2);
377     seq.push_back(e3);
378     seq.push_back(e4);
379     seq.push_back(e5);
380     seq.push_back(e6);
381     seq.push_back(e7);
382 }
383
384 ${CONTAINER}::${CONTAINER}(ex const & e1, ex const & e2, ex const & e3,
385                      ex const & e4, ex const & e5, ex const & e6,
386                      ex const & e7, ex const & e8) : basic(TINFO_${CONTAINER_UC})
387 {
388     debugmsg("${CONTAINER} constructor from 8 ex",
389              LOGLEVEL_CONSTRUCT);
390     RESERVE(seq,8);
391     seq.push_back(e1);
392     seq.push_back(e2);
393     seq.push_back(e3);
394     seq.push_back(e4);
395     seq.push_back(e5);
396     seq.push_back(e6);
397     seq.push_back(e7);
398     seq.push_back(e8);
399 }
400
401 ${CONTAINER}::${CONTAINER}(ex const & e1, ex const & e2, ex const & e3,
402                      ex const & e4, ex const & e5, ex const & e6,
403                      ex const & e7, ex const & e8, ex const & e9)
404     : basic(TINFO_${CONTAINER_UC})
405 {
406     debugmsg("${CONTAINER} constructor from 9 ex",
407              LOGLEVEL_CONSTRUCT);
408     RESERVE(seq,9);
409     seq.push_back(e1);
410     seq.push_back(e2);
411     seq.push_back(e3);
412     seq.push_back(e4);
413     seq.push_back(e5);
414     seq.push_back(e6);
415     seq.push_back(e7);
416     seq.push_back(e8);
417     seq.push_back(e9);
418 }
419
420 ${CONTAINER}::${CONTAINER}(ex const & e1, ex const & e2, ex const & e3,
421                      ex const & e4, ex const & e5, ex const & e6,
422                      ex const & e7, ex const & e8, ex const & e9,
423                      ex const &e10)
424     : basic(TINFO_${CONTAINER_UC})
425 {
426     debugmsg("${CONTAINER} constructor from 10 ex",
427              LOGLEVEL_CONSTRUCT);
428     RESERVE(seq,10);
429     seq.push_back(e1);
430     seq.push_back(e2);
431     seq.push_back(e3);
432     seq.push_back(e4);
433     seq.push_back(e5);
434     seq.push_back(e6);
435     seq.push_back(e7);
436     seq.push_back(e8);
437     seq.push_back(e9);
438     seq.push_back(e10);
439 }
440
441 //////////
442 // functions overriding virtual functions from bases classes
443 //////////
444
445 // public
446
447 basic * ${CONTAINER}::duplicate() const
448 {
449     debugmsg("${CONTAINER} duplicate",LOGLEVEL_DUPLICATE);
450     return new ${CONTAINER}(*this);
451 }
452
453 void ${CONTAINER}::printraw(ostream & os) const
454 {
455     debugmsg("${CONTAINER} printraw",LOGLEVEL_PRINT);
456
457     os << "${CONTAINER}(";
458     for (${STLT}::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
459         (*cit).bp->printraw(os);
460         os << ",";
461     }
462     os << ")";
463 }
464
465 void ${CONTAINER}::print(ostream & os, unsigned upper_precedence) const
466 {
467     debugmsg("${CONTAINER} print",LOGLEVEL_PRINT);
468     // always print brackets around seq, ignore upper_precedence
469     printseq(os,'${open_bracket}',',','${close_bracket}',precedence,precedence+1);
470 }
471
472 void ${CONTAINER}::printtree(ostream & os, unsigned indent) const
473 {
474     debugmsg("${CONTAINER} printtree",LOGLEVEL_PRINT);
475
476     os << string(indent,' ') << "type=" << typeid(*this).name()
477        << ", hash=" << hashvalue << " (0x" << hex << hashvalue << dec << ")"
478        << ", flags=" << flags
479        << ", nops=" << nops() << endl;
480     for (${STLT}::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
481         (*cit).printtree(os,indent+delta_indent);
482     }
483     os << string(indent+delta_indent,' ') << "=====" << endl;
484 }
485
486 // ${CONTAINER}::info() will be implemented by user elsewhere";
487
488 int ${CONTAINER}::nops() const
489 {
490     return seq.size();
491 }
492
493 ${LET_OP_IMPLEMENTATION}
494
495 ex ${CONTAINER}::expand(unsigned options) const
496 {
497     ${STLT} s;
498     RESERVE(s,seq.size());
499     for (${STLT}::const_iterator it=seq.begin(); it!=seq.end(); ++it) {
500         s.push_back((*it).expand(options));
501     }
502
503     return this${CONTAINER}(s);
504 }
505
506 // a ${CONTAINER} 'has' an expression if it is this expression itself or a child 'has' it
507
508 bool ${CONTAINER}::has(ex const & other) const
509 {
510     ASSERT(other.bp!=0);
511     if (is_equal(*other.bp)) return true;
512     for (${STLT}::const_iterator it=seq.begin(); it!=seq.end(); ++it) {
513         if ((*it).has(other)) return true;
514     }
515     return false;
516 }
517
518 ex ${CONTAINER}::eval(int level) const
519 {
520     if (level==1) {
521         return this->hold();
522     }
523     return this${CONTAINER}(evalchildren(level));
524 }
525
526 ex ${CONTAINER}::evalf(int level) const
527 {
528     return this${CONTAINER}(evalfchildren(level));
529 }
530
531 /** Implementation of ex::normal() for ${CONTAINER}s. It normalizes the arguments
532  *  and replaces the ${CONTAINER} by a temporary symbol.
533  *  \@see ex::normal */
534 ex ${CONTAINER}::normal(lst &sym_lst, lst &repl_lst, int level) const
535 {
536     ex n=this${CONTAINER}(normalchildren(level));
537     return n.bp->basic::normal(sym_lst,repl_lst,level);
538 }
539
540 ex ${CONTAINER}::diff(symbol const & s) const
541 {
542     return this${CONTAINER}(diffchildren(s));
543 }
544
545 ex ${CONTAINER}::subs(lst const & ls, lst const & lr) const
546 {
547     ${STLT} * vp=subschildren(ls,lr);
548     if (vp==0) {
549         return *this;
550     }
551     return this${CONTAINER}(vp);
552 }
553
554 // protected
555
556 int ${CONTAINER}::compare_same_type(basic const & other) const
557 {
558     ASSERT(is_of_type(other,${CONTAINER}));
559     ${CONTAINER} const & o=static_cast<${CONTAINER} const &>
560                                     (const_cast<basic &>(other));
561     int cmpval;
562     ${STLT}::const_iterator it1=seq.begin();
563     ${STLT}::const_iterator it2=o.seq.begin();
564
565     for (; (it1!=seq.end())&&(it2!=o.seq.end()); ++it1, ++it2) {
566         cmpval=(*it1).compare(*it2);
567         if (cmpval!=0) return cmpval;
568     }
569
570     if (it1==seq.end()) {
571         return (it2==o.seq.end() ? 0 : -1);
572     }
573
574     return 1;
575 }
576
577 bool ${CONTAINER}::is_equal_same_type(basic const & other) const
578 {
579     ASSERT(is_of_type(other,${CONTAINER}));
580     ${CONTAINER} const & o=static_cast<${CONTAINER} const &>
581                                     (const_cast<basic &>(other));
582     if (seq.size()!=o.seq.size()) return false;
583
584     ${STLT}::const_iterator it1=seq.begin();
585     ${STLT}::const_iterator it2=o.seq.begin();
586
587     for (; it1!=seq.end(); ++it1, ++it2) {
588         if (!(*it1).is_equal(*it2)) return false;
589     }
590
591     return true;
592 }
593
594 unsigned ${CONTAINER}::return_type(void) const
595 {
596     return return_types::noncommutative_composite;
597 }
598
599 //////////
600 // new virtual functions which can be overridden by derived classes
601 //////////
602
603 // public
604
605 ${CONTAINER} & ${CONTAINER}::append(ex const & b)
606 {
607     ensure_if_modifiable();
608     seq.push_back(b);
609     return *this;
610 }
611
612 ${PREPEND_IMPLEMENTATION}
613
614 // protected
615
616 void ${CONTAINER}::printseq(ostream & os, char openbracket, char delim,
617                          char closebracket, unsigned this_precedence,
618                          unsigned upper_precedence) const
619 {
620     if (this_precedence<=upper_precedence) os << openbracket;
621     if (seq.size()!=0) {
622         ${STLT}::const_iterator it,it_last;
623         it=seq.begin();
624         it_last=seq.end();
625         --it_last;
626         for (; it!=it_last; ++it) {
627             (*it).bp->print(os,this_precedence);
628             os << delim;
629         }
630         (*it).bp->print(os,this_precedence);
631     }
632     if (this_precedence<=upper_precedence) os << closebracket;
633 }
634
635 ex ${CONTAINER}::this${CONTAINER}(${STLT} const & v) const
636 {
637     return ${CONTAINER}(v);
638 }
639
640 ex ${CONTAINER}::this${CONTAINER}(${STLT} * vp) const
641 {
642     return ${CONTAINER}(vp);
643 }
644
645 //////////
646 // non-virtual functions in this class
647 //////////
648
649 // public
650
651 // none
652
653 // protected
654
655 bool ${CONTAINER}::is_canonical() const
656 {
657     if (seq.size()<=1) { return 1; }
658
659     ${STLT}::const_iterator it=seq.begin();
660     ${STLT}::const_iterator it_last=it;
661     for (++it; it!=seq.end(); it_last=it, ++it) {
662         if ((*it_last).compare(*it)>0) {
663             if ((*it_last).compare(*it)>0) {
664                 cout << *it_last << ">" << *it << "\\n";
665                 return 0;
666                 }
667         }
668     }
669     return 1;
670 }
671
672
673 ${STLT} ${CONTAINER}::evalchildren(int level) const
674 {
675     ${STLT} s;
676     RESERVE(s,seq.size());
677
678     if (level==1) {
679         return seq;
680     }
681     if (level == -max_recursion_level) {
682         throw(std::runtime_error("max recursion level reached"));
683     }
684     --level;
685     for (${STLT}::const_iterator it=seq.begin(); it!=seq.end(); ++it) {
686         s.push_back((*it).eval(level));
687     }
688     return s;
689 }
690
691 ${STLT} ${CONTAINER}::evalfchildren(int level) const
692 {
693     ${STLT} s;
694     RESERVE(s,seq.size());
695
696     if (level==1) {
697         return seq;
698     }
699     if (level == -max_recursion_level) {
700         throw(std::runtime_error("max recursion level reached"));
701     }
702     --level;
703     for (${STLT}::const_iterator it=seq.begin(); it!=seq.end(); ++it) {
704         s.push_back((*it).evalf(level));
705     }
706     return s;
707 }
708
709 ${STLT} ${CONTAINER}::normalchildren(int level) const
710 {
711     ${STLT} s;
712     RESERVE(s,seq.size());
713
714     if (level==1) {
715         return seq;
716     }
717     if (level == -max_recursion_level) {
718         throw(std::runtime_error("max recursion level reached"));
719     }
720     --level;
721     for (${STLT}::const_iterator it=seq.begin(); it!=seq.end(); ++it) {
722         s.push_back((*it).normal(level));
723     }
724     return s;
725 }
726
727 ${STLT} ${CONTAINER}::diffchildren(symbol const & y) const
728 {
729     ${STLT} s;
730     RESERVE(s,seq.size());
731     for (${STLT}::const_iterator it=seq.begin(); it!=seq.end(); ++it) {
732         s.push_back((*it).diff(y));
733     }
734     return s;
735 }
736
737 /* obsolete subschildren
738 ${STLT} ${CONTAINER}::subschildren(lst const & ls, lst const & lr) const
739 {
740     ${STLT} s;
741     RESERVE(s,seq.size());
742     for (${STLT}::const_iterator it=seq.begin(); it!=seq.end(); ++it) {
743         s.push_back((*it).subs(ls,lr));
744     }
745     return s;
746 }
747 */
748
749 ${STLT} * ${CONTAINER}::subschildren(lst const & ls, lst const & lr) const
750 {
751     // returns a NULL pointer if nothing had to be substituted
752     // returns a pointer to a newly created epvector otherwise
753     // (which has to be deleted somewhere else)
754
755     ${STLT}::const_iterator last=seq.end();
756     ${STLT}::const_iterator cit=seq.begin();
757     while (cit!=last) {
758         ex const & subsed_ex=(*cit).subs(ls,lr);
759         if (!are_ex_trivially_equal(*cit,subsed_ex)) {
760
761             // something changed, copy seq, subs and return it
762             ${STLT} *s=new ${STLT};
763             RESERVE(*s,seq.size());
764
765             // copy parts of seq which are known not to have changed
766             ${STLT}::const_iterator cit2=seq.begin();
767             while (cit2!=cit) {
768                 s->push_back(*cit2);
769                 ++cit2;
770             }
771             // copy first changed element
772             s->push_back(subsed_ex);
773             ++cit2;
774             // copy rest
775             while (cit2!=last) {
776                 s->push_back((*cit2).subs(ls,lr));
777                 ++cit2;
778             }
779             return s;
780         }
781         ++cit;
782     }
783     
784     return 0; // nothing has changed
785 }
786
787 //////////
788 // static member variables
789 //////////
790
791 // protected
792
793 unsigned ${CONTAINER}::precedence=10;
794
795 //////////
796 // global constants
797 //////////
798
799 const ${CONTAINER} some_${CONTAINER};
800 type_info const & typeid_${CONTAINER}=typeid(some_${CONTAINER});
801
802 END_OF_IMPLEMENTATION
803
804 print "Creating interface file ${CONTAINER}.h...";
805 open OUT,">${CONTAINER}.h" or die "cannot open ${CONTAINER}.h";
806 print OUT $interface;
807 close OUT;
808 print "ok.\n";
809
810 print "Creating implementation file ${CONTAINER}.cpp...";
811 open OUT,">${CONTAINER}.cpp" or die "cannot open ${CONTAINER}.cpp";
812 print OUT $implementation;
813 close OUT;
814 print "ok.\n";
815
816 print "done.\n";