Quelle est la meilleure façon d'implémenter une instruction break sur un interpréteur?

Question

J'ai développé un interpréteur pour Brain (un langage semblable à Brainfuck) et j'ai quelques inquiétudes concernant la conception d'une déclaration de rupture .

Tenir compte le code suivant à JS:

var Stmt = (function() { 
    var Stmt = function() {}; 
    Stmt.prototype = { 
     update_expression: function(update) { return false; }, 
     value: function() { return this; }, 
     exec: function(delegate) { }, 
     zerofy: function (tapeObj) { 
     if (tapeObj.data[tapeObj.d_ptr] === undefined) { 
      tapeObj.data[tapeObj.d_ptr] = 0; 
     } 
    } 
    }; 

    return Stmt; 
})(); 

var BreakStmt = (function() { 
    var BreakStmt = function(){ }; 
    BreakStmt.prototype = Object.create(Stmt.prototype); 
    return BreakStmt; 
})(); 

var LoopStmt = (function() { 
    var LoopStmt = function(stmts, type) { 
    this.type = 'undefined'; 
    this.stmts = null; 

    if (tokens[type] === 'TT_BEGIN_WHILE' 
     || tokens[type] === 'TT_BEGIN_FOR') { 
     this.type = type; 
     this.stmts = stmts; 
    } 
    }; 

    LoopStmt.prototype = Object.create(Stmt.prototype); 
    return LoopStmt; 
})(); 

var IfStmt = (function() { 
    var IfStmt = function(stmts_then) { 
    this.stmts_then = stmts_then; 
    this.stmts_else = null; 
    }; 

    IfStmt.prototype = Object.create(Stmt.prototype); 
    IfStmt.prototype.set_else = function(stmts_else) { 
     this.stmts_else = stmts_else; 
    }; 

    return IfStmt; 
})(); 

L'analyseur passera par les déclarations récursive puis retourner un AST. Maintenant, imaginez un AST avec les énoncés suivants:

LoopStmt 
    IfStmt 
    IfStmt 
     BreakStmt 
... 

La fonction des éléments exec va également récursive. En dépit d'avoir beaucoup d'idées pour cette implémentation, après beaucoup de recherches, je n'arrive toujours pas à trouver le meilleur moyen de stopper récursivement cette récursivité (si cela a du sens) jusqu'à ce que je trouve le LoopStmt le plus proche.

Quel est le meilleur design pour cela? Toute aide serait géniale, merci!

Answer 1

Après beaucoup de recherches, je crois avoir trouvé la réponse. La mise en œuvre de l'approche tree accumulation serait l'une des meilleures idées pour mon design. En fait, pour cela, nous n'utiliserions l'approche de accumulation ascendante, où chaque nœud (dans ce cas mon Stmts) a des informations sur ses descendants.

Dans ce cas, le dit AST:

1. LoopStmt 
2. IfStmt 
3. IfStmt 
4.  BreakStmt 
    ... 

Tout ce que nous aurions besoin de faire est de stocker (ou accumuler) les informations du #4 Stmt dans le #3 Stmt, les informations du #3 dans le #2 et enfin #2 en #1. Nous romprions alors récursivement l'exécution des instructions jusqu'à la boucle la plus proche.

J'espère que j'aiderai n'importe qui!