Merge pull request #9 from blorente/gdb

FInish basic debugging commands

.gitignore

@@ -30,17 +30,18 @@
 
 # Build files
 bin/
-cmake-build-debug/
-/cmake-build-debug/
+cmake-build-beginDebug/
+/cmake-build-beginDebug/
 *.make
-cmake-build-debug/CMakeFiles/Makefile2
+cmake-build-beginDebug/CMakeFiles/Makefile2
 
 /interpreter/src/core/parser/generated/
 /deps/antlr/build/
 /build/
 /deps/antlr/run/
 /deps/antlr/cmake/
 .idea
-/cmake-build-debug/antlr4cpp_generated_src/
-/cmake-build-debug/locals/
+/cmake-build-debug/
 /docs/page/_site
+/cmake-build-debugclang/
+/cmake-build-release/

examples/Debug.grace

@@ -0,0 +1,8 @@
+def out1 = 4;
+def obj = object {
+  var in1 := 3;
+  var in2 := 5;
+  var in3 := 8;
+};
+def out2 = 6;
+def out3 = 6;

examples/Lines.grace

@@ -0,0 +1,3 @@
+var in1 := 3;
+var in2 := 5;
+var in3 := 8;

examples/Method.grace

@@ -0,0 +1,4 @@
+method add(a)to(b) {
+    a + b;
+}
+var x := {ba, bb -> add(ba)to(bb);}.apply(2, 4);

grammars/GraceLexer.g4

@@ -41,7 +41,7 @@ tokens {
 	DUMMY
 }
 
-WS : [ \r\t\n]+ -> skip ;
+WS : [ \r\t\n]+ -> channel(HIDDEN);
 INT: Digit+;
 Digit: [0-9];
 

interpreter/src/core/control/DebugState.h

@@ -0,0 +1,15 @@
+//
+// Copyright (c) 2017 by Borja Lorente.
+// Distributed under the GPLv3 license.
+//
+
+#ifndef NAYLANG_DEBUGSTATE_H
+#define NAYLANG_DEBUGSTATE_H
+enum DebugState {
+    CONTINUE,
+    STOP,
+    STEP_IN,
+    STEP_OVER,
+    STEP_OVER_SKIP
+};
+#endif //NAYLANG_DEBUGSTATE_H

interpreter/src/core/control/Debugger.cpp

@@ -0,0 +1,59 @@
+//
+// Copyright (c) 2016 by Borja Lorente.
+// Distributed under the GPLv3 license.
+//
+
+#include "Debugger.h"
+
+namespace naylang {
+
+Debugger::Debugger(DebugMode *mode, const std::string &code) :
+        Interpreter(std::make_unique<ExecutionEvaluator>(this)),
+        _frontend{mode},
+        _AST{parse(code)}{}
+
+void Debugger::run() {
+    _eval->setDebugState(CONTINUE);
+    _eval->evaluateAST(_AST);
+    finish();
+}
+
+void Debugger::setBreakpoint(int line) {
+    _breakpoints.insert(line);
+    std::cout << "Breakpoint set at line " << line << std::endl;
+}
+
+void Debugger::printEnvironment() {
+    std::cout << "Current environment: " << std::endl;
+    std::cout << _eval->currentScope()->prettyPrint(0) << std::endl;
+}
+
+void Debugger::resume() {
+    _eval->setDebugState(CONTINUE);
+}
+
+void Debugger::debug(Statement *node) {
+    if (node->stoppable()) {
+        if (_breakpoints.count(node->line()) != 0) {
+            std::cout << "Breakpoint found at line " << node->line() << ". Stop." << std::endl;
+            _eval->setDebugState(STOP);
+        }
+        while(_eval->getDebugState() == STOP) {
+            _frontend->executeNextCommand();
+        }
+    }
+}
+
+void Debugger::stepIn() {
+    _eval->setDebugState(STEP_IN);
+}
+
+void Debugger::stepOver() {
+    _eval->setDebugState(STEP_OVER);
+}
+
+void Debugger::finish() {
+    std::cout << "Process finished. Resulting environment: " << std::endl;
+    std::cout << _eval->currentScope()->prettyPrint(0) << std::endl;
+}
+}

interpreter/src/core/control/Debugger.h

@@ -0,0 +1,40 @@
+//
+// Copyright (c) 2016 by Borja Lorente.
+// Distributed under the GPLv3 license.
+//
+
+#ifndef NAYLANG_DEBUGGER_H
+#define NAYLANG_DEBUGGER_H
+
+#include <frontends/modes/debug/DebugMode.h>
+#include <core/control/DebugState.h>
+#include "Interpreter.h"
+
+namespace naylang {
+class DebugMode;
+class Debugger : public Interpreter {
+
+    GraceAST _AST;
+    std::set<int> _breakpoints;
+    DebugMode *_frontend;
+
+public:
+
+    Debugger(DebugMode *frontend, const std::string &filename);
+
+    void run();
+    void setBreakpoint(int line);
+    void printEnvironment();
+    void resume();
+    void stepIn();
+    void stepOver();
+
+    void debug(Statement *node);
+
+private:
+
+    void finish();
+};
+}
+
+#endif //NAYLANG_DEBUGGER_H

interpreter/src/core/control/Interpreter.cpp

@@ -1,19 +1,16 @@
 //
-// Copyright (c) 2016 by Borja Lorente.
-// Distributed under the GPLv3 license.
+// Created by borja on 4/14/17.
 //
 
+#include "REPLInterpreter.h"
 #include "Interpreter.h"
 
 namespace naylang {
-void Interpreter::execute(const std::string &line) {
-    eval.evaluateAST(parse(line));
-    std::cout << eval.currentScope()->prettyPrint(0) << std::endl;
-}
 
-void Interpreter::printResult(const std::string &line) {
-    eval.evaluateAST(parse(line));
-    std::cout << eval.partial()->prettyPrint(0) << std::endl;
+void Interpreter::printResult(std::string line) {
+    colonize(line);
+    auto res = _eval->evaluateSandbox(parse(line));
+    std::cout << res->prettyPrint(0) << std::endl;
 }
 
 GraceAST Interpreter::parse(const std::string &line) const {
@@ -25,4 +22,10 @@ GraceAST Interpreter::parse(const std::string &line) const {
     parserVisitor.visit(parser.program());
     return parserVisitor.AST();
 }
-}
+
+void Interpreter::colonize(std::string &line) {
+    if (line.at(line.length() - 1) != ';') {
+        line.append(";");
+    }
+}
+}

interpreter/src/core/control/Interpreter.h

@@ -6,7 +6,6 @@
 #ifndef NAYLANG_INTERPRETER_H
 #define NAYLANG_INTERPRETER_H
 
-#include <core/parser/NaylangParserVisitor.h>
 #include <core/model/evaluators/ExecutionEvaluator.h>
 #include <core/model/execution/objects/GraceObject.h>
 #include <GraceLexer.h>
@@ -16,17 +15,17 @@ using namespace antlr4::tree;
 
 namespace naylang {
 class Interpreter {
-
-    ExecutionEvaluator eval;
+protected:
+    std::unique_ptr<ExecutionEvaluator> _eval;
 
 public:
+    Interpreter(std::unique_ptr<ExecutionEvaluator> eval) : _eval{std::move(eval)} {}
+    void printResult(std::string line);
 
-    void execute(const std::string &line);
-    void printResult(const std::string &line);
-
-private:
+protected:
     GraceAST parse(const std::string &line) const;
+    void colonize(std::string &line);
 };
-}
 
-#endif //NAYLANG__INTERPRETER_H
+}
+#endif //NAYLANG_INTERPRETER_H

interpreter/src/core/control/REPLInterpreter.cpp

@@ -0,0 +1,17 @@
+//
+// Copyright (c) 2016 by Borja Lorente.
+// Distributed under the GPLv3 license.
+//
+
+#include "REPLInterpreter.h"
+#include <core/control/Debugger.h>
+
+namespace naylang {
+void REPLInterpreter::execute(std::string line) {
+    colonize(line);
+    _eval->evaluateAST(parse(line));
+    std::cout << _eval->currentScope()->prettyPrint(0) << std::endl;
+}
+
+REPLInterpreter::REPLInterpreter() : Interpreter(std::make_unique<ExecutionEvaluator>()) {}
+}

interpreter/src/core/control/REPLInterpreter.h

@@ -0,0 +1,22 @@
+//
+// Copyright (c) 2016 by Borja Lorente.
+// Distributed under the GPLv3 license.
+//
+
+#ifndef NAYLANG_REPLINTERPRETER_H
+#define NAYLANG_REPLINTERPRETER_H
+
+#include <core/parser/NaylangParserVisitor.h>
+#include "Interpreter.h"
+
+namespace naylang {
+class REPLInterpreter : public Interpreter {
+
+public:
+    REPLInterpreter();
+
+    void execute(std::string line);
+};
+}
+
+#endif //NAYLANG_REPLINTERPRETER_H

interpreter/src/core/model/ast/ASTNodeDefinitions.h

@@ -11,6 +11,7 @@
 #include <core/model/ast/control/IfThen.h>
 #include <core/model/ast/control/IfThenElse.h>
 #include <core/model/ast/control/While.h>
+#include <core/model/ast/control/Return.h>
 
 #include <core/model/ast/declarations/Declaration.h>
 #include <core/model/ast/declarations/ConstantDeclaration.h>

interpreter/src/core/model/ast/GraceAST.cpp

@@ -0,0 +1,28 @@
+//
+// Copyright (c) 2017 by Borja Lorente.
+// Distributed under the GPLv3 license.
+//
+
+#include "GraceAST.h"
+
+namespace naylang {
+StatementPtr GraceAST::operator[](int index) {
+    return _nodes[index];
+}
+
+void GraceAST::addNode(StatementPtr node) {
+    _nodes.push_back(node);
+}
+
+const std::vector<StatementPtr> &GraceAST::nodes() const {
+    return _nodes;
+}
+
+void GraceAST::addLineLink(StatementPtr node) {
+    if (_nodeLinks.count(node->line()) == 0) {
+        _nodeLinks[node->line()] = node;
+        _lastLine = node->line() > _lastLine ? node->line() : _lastLine;
+    }
+}
+}
+

interpreter/src/core/model/ast/GraceAST.h

@@ -0,0 +1,27 @@
+//
+// Copyright (c) 2017 by Borja Lorente.
+// Distributed under the GPLv3 license.
+//
+
+#ifndef NAYLANG_ASTTREEDEFINITION_H
+#define NAYLANG_ASTTREEDEFINITION_H
+
+#include <core/model/ast/ASTNodeDefinitions.h>
+#include <map>
+
+namespace naylang {
+class GraceAST {
+    std::vector<StatementPtr> _nodes;
+    std::map<int, StatementPtr> _nodeLinks;
+    int _lastLine = 0;
+
+public:
+
+    virtual StatementPtr operator[](int index);
+    void addNode(StatementPtr node);
+    void addLineLink(StatementPtr node);
+    const std::vector<StatementPtr> &nodes() const;
+
+};
+}
+#endif //NAYLANG_ASTTREEDEFINITION_H

interpreter/src/core/model/ast/Statement.h

@@ -21,16 +21,20 @@ class Statement {
 
     int _line;
     int _col;
+    bool _stoppable;
 
 public:
 
-    Statement() : _line{-1}, _col{-1} {}
-    Statement(int line, int col) : _line{line}, _col{col} {}
+    Statement() : _line{-1}, _col{-1}, _stoppable{false}{}
+    Statement(int line, int col) : _line{line}, _col{col}, _stoppable{false}{}
 
     virtual void accept(Evaluator &evaluator) = 0;
 
-    int line() {return _line;}
-    int col() {return _col;}
+    int line() const {return _line;}
+    int col() const {return _col;}
+
+    bool stoppable() {return _stoppable;}
+    void makeStoppable() {_stoppable = true;}
 };
 
 }

interpreter/src/core/model/ast/declarations/ConstantDeclaration.cpp

@@ -24,5 +24,4 @@ const std::string & ConstantDeclaration::name() const {
 ExpressionPtr ConstantDeclaration::value() const {
     return _value;
 }
-
 }