RawParser VS leo-editor

I have started working on a program that can parse Markdown files with fragments of C code and weave those fragments into a C program that can be compiled. For an example input, see https://github.com/FransFaase/RawParser#documentation

The distinction between a scanner and a parser is somewhat arbitrary. One could use one and the same formalism for it. The scanner usually deals with things that are considered 'atomic' elements in the language, while grammar is used for 'compound' elements consisting of one or more other elements. If there are seen as one and the same, than it naturally flows that the scanner is called from the parser, and not how it is traditionally done, that the scanner acts as a first pass. This seems a logical approach, but in practices, when scanning is context sensitive, requires the implementation of all kinds of hacks. Also, the treatment of keywords (where it is possible that they are case insensitive) it is better to have a grammar for parsing a keyword 'identifier' and a check whether the result matches the keyword. For pure performance this would not be the best solution, but I understand that Carburetta is not design for that. I have been developing a parser that makes no distinction between scanning and parsing in C, which I called RawParser: https://github.com/FransFaase/RawParser . It also offers more powerful grammar constructs and gives examples on how to implement memory management in a uniform way.

What are your experiences with literate programming for handover of code?

I am thinking of tools like noweb (https://en.wikipedia.org/wiki/Noweb), LEO (http://leoeditor.com/) org-mode (http://cachestocaches.com/2018/6/org-literate-programming/), scribble/lp2 (https://docs.racket-lang.org/scribble/lp.html#%28part._scribble_lp2_.Language%29),

My experience so far is that it can be a fantastic tool for documenting and handing over complex algorithms to successor developers. I use extensively use ersonal wikis (sometimes MoinMoin, sometimes Zim Wiki, in the last time often a combination of github with reStructuredText) for work. That might also be sufficient when handing over boring code.

I know what folding is, that's just not what I want. I want to completely hide everything that is not related to the current function. For a while, I used http://leoeditor.com/ where I could have every function/method as a node in a tree, with the node body containing just that. Looking for a way to achieve the same in vim if possible.

The lack of good node/graph based APIs for Org Mode is my beef as well. When you compare it with the APIs of the Leo Editor[1], Org pales in comparison. Manipulation that is trivial in the Leo Editor can be quite a pain in Org mode.

[1] https://leoeditor.com/

> What outliners do you know which allow end-users to feed their data into formulas for processing it without using general-purpose programming languages?

Bit of a pointless constraint, the talk is about outliners, not no-code-datamangment. Which tool today does this even offer on a useful level?

But you can look at leo editor (https://leoeditor.com), which is active for 20+ years, fully scriptable and extendable. Though, it's a hot piece of garbage for laymen. It's offers a bunch of features and plugins even for non-coders, but I'm not sure it would satisfy you for this area, if you can't code.

But I'm not sure if there ever is a tool which will satisfy everyone with just a no-code-approach.

Hmm maybe you mean:

- Programming based on fragments, not documents (e.g. LEO https://leoeditor.com/)

- Live programming (e.g. smalltalk environments)

- ... where certain actions are not available, e.g. a PL geared towards speech recognition may not support "hover"

There's also https://leoeditor.com/ where you can have a tree of nodes and execute any of them.

I had this problem until I found an editor that had outlining as it's core design paradigm. Now, with the outline always visible, it's _really_ easy to navigate any length file.

Unfortunately, at one point I got so used to navigating with the outline that I ended up making a 1500 line function in C (I was an even worse C programmer then than I am now). Because of the outline, I could read and follow it easily, but anyone with a different editor was royally screwed :-(

If you're interested, the editor is LEO (http://leoeditor.com/) it's been mentioned on HN a few times