Changeset 0aab93ba05631253155d0cdd5059158cae7f269b

Timestamp:

09/23/09 20:36:22 (3 years ago)

Author:

Antti-Juhani Kaijanaho <antti-juhani@…>

Children:

97ce4926752779cac0f6b8494b0cfdf096ee15f4

Parents:

130a42d34f091a92300eb9988d79070c9cd22deb

git-committer:

Antti-Juhani Kaijanaho <antti-juhani@…> (09/23/09 20:36:22)

Message:

[tlate::def] Set a limit to how many times a function can be called

The limit is of course arbitrary. The aim here is to protect against
overflowing the call stack with unbounded recursion in the template.

The downside of this fix is that it limits non-recursive calls as well.

A better fix would involve converting the evaluator into a bytecode
interpreter with an explicit call stack (this would allow monitoring
the actual stack usage instead of an indirect measure of calls).

Completes the fix of #12.

Signed-off-by: Antti-Juhani Kaijanaho <antti-juhani@…>

Location:

tlate

Files:

• def.cc (modified) (5 diffs)
• def.hh (modified) (1 diff)

tlate/def.cc

@@ -33 +33 @@
         class closure : public value 
         {
+                std::string name;
                 std::vector<std::string> parms;
                 seq::ptr body;
                 structured_value::ptr senv;
+                mutable size_t &eval_count;
                 std::string fname;
                 int line;
@@ -42 +44 @@
                 typedef boost::shared_ptr<const closure> const_ptr;
 
-                closure(std::vector<std::string> parms,
+                closure(std::string name,
+                        std::vector<std::string> parms,
                         seq::ptr body,
                         structured_value::ptr senv,
+                        size_t &eval_count,
                         std::string fname,
                         int line)
-                        : parms(parms)
+                        : name(name)
+                        , parms(parms)
                         , body(body)
                         , senv(senv)
+                        , eval_count(eval_count)
                         , fname(fname)
                         , line(line)
@@ -63 +69 @@
                                        std::string fname, int line) const
         {
+                if (eval_count++ > 5000)
+                {
+                        logger::logline ll;
+                        ll << this->fname << ":" << this->line 
+                           << ": too many calls to " << name;
+                        return empty_value::instance();
+                }
                 overriding_structured_value::ptr env
                         (new overriding_structured_value(senv));
@@ -89 +102 @@
         def::def(scanner &sc)
                 : tlate(sc.peekFileName(), sc.peekLineNo())
+                , eval_count(0)
         {
                 /*
@@ -132 +146 @@
                      it != bodyfvs.end(); it++)
                         senv->insert(*it, env->get(*it));
-                value::ptr cl(new closure(parms, body, senv, fname, line));
+                value::ptr cl(new closure(name, parms, body, senv, eval_count,
+                                          fname, line));
                 senv->insert(name, cl);
                 env->override(name, cl);

tlate/def.hh

@@ -38 +38 @@
                 seq::ptr body;
                 std::set<std::string> bodyfvs;
+                size_t eval_count;
         public:
                 typedef boost::shared_ptr<def> ptr;