Is it possible to start a cling repl from inside lldb?

Question

So I coming from a python world, trying to learn cpp fast. (at least the basics). The thing that I miss most from the python world was - how you can just add breakpoint anywhere in the code and start an interactive repl session with the context.

I am looking for something similar in cpp. I know this not going to be popular in cppworld, but it really helps in prototyping a solution fast! I found https://github.com/tehrengruber/Defrustrator which gives me some more promise.

There is also this: https://github.com/inspector-repl/inspector which looks interesting and is similar to what I am looking for!

Would it help if I embed the cling interpreter inside my program?

Thanks for reading!

EDIT: To clarify, ideally I am seeking something on lines of - how you can enter swift repl while using lldb. I am not sure why CPP community does not see advantage in this. This would be an amazing feature to have! This would encourage a lot of people like myself to take up CPP more readily.

Answer 1

This is not directly answering your question, but if you run your program under lldb and stop somewhere, the lldb expr command is pretty close to a REPL. It doesn't run in a REPL like mode where you are just entering program text, instead you run the "expr" command and either put in the program text as command arguments or hit a return to enter into a little mini-editor. But you can call any methods of any of the objects you have, and can make new objects and in even make new classes and play with them as well as program objects.

There are some provisos. You can create classes in the expr, but you have to do it in one go (C++ is not about incremental building up of classes). Because the expression evaluator is meant primarily for exploring extant code and tries to avoid shadowing program variables, all types & variables defined in the expr command have to be preceded by a $. So for instance:

(lldb) expr
Enter expressions, then terminate with an empty line to evaluate:
  1: class $MyClass {  
  2: public:  
  3: int doSomething() {  
  4:   return m_ivar1 * m_ivar2;  
  5: } 
  6: private: 
  7:   int m_ivar1 = 100;  
  8:   int m_ivar2 = 200; 
  9: }
(lldb) expr $MyClass $my_var 
(lldb) expr $my_var.doSomething()
(int) $0 = 20000

So you can do a fair amount of playing here.

The other funny limitation is that though you can define classes in expr, you can't define free functions. By default the expr command is trying to run expression text "as if it was typed at the point you are stopped in your program", so you will have access to the current frame's ivars, etc. But under the covers that means wrapping the expression in some function, and C/C++ doesn't allow internal functions...

So to define free functions and otherwise more freely add to the state of your program, you can use the --top-level flag to expr to have your expression text evaluated as if it were in a top-level source file. You won't have access to any local state, but you aren't required to use initial $'s and can do some more things that aren't allowed in a function by C.