-*- org -*-
#+STARTUP: indent

* ne (nil engineering)

NE is (or will be) a toy-case: it read source-code, computes models, 
write/updates source-code.
C++ is difficult to parse, some experiments with parsers are done with a small
abstract OO language (AL=abstract language).
Normally parsers produce ASTs (abstract syntax trees). 
NE produces an AOM (abstract object model), that is more or less the same thing.
When produced an AOM you should able to represent it in form of diagrams, then 
visiting and make transformations on it, finally you may want to produce other 
source code from it, maybe in other languages, maybe just in ather forms.
Since sw engineering is a matter of re-iterating processes you may find yourself
on generating more than once the same project. And what about the hand-coded sources?
NE must merge generated code with hand-coded source.
CodeWorker may help on this: the simplest way (RR) is not too difficult to be followed.
The Borland way is best, but little more complicated.

** parsing
*** TheIDE

Not proper a parser: but do parse C++ quite well.
Would try to interface its parser with AOM.

*** CodeWorker

CodeWorker is a great tool for parsing, generating, trasnformate code,
written in C++ by Cedric Lamaire.
cworker is a ne/module based on CodeWorker.

*** coco/r
*** peg/leg
*** yacc/bison
*** antlr

** aom
** canvas
*** bugs
**** xxxxxxxxx
*** ugly
**** meta-notation
***** syntax => meaning
**** notation
***** [arg] => arg is optional
***** (arg..) => 1 or more arg's
***** arg1|arg2 => one of two
***** function -> type => function should return a value of type
**** datatypes
***** id = a numeric handle
***** name = an identifier
***** int
***** key = a keyboard pattern
***** qname = a qualified identifier
***** str
***** stexp = search-transform-expression
***** tpl = a template argument
***** filepath
**** note
***** assign key stexp                                              :control:
***** class [(tpl..)] id|name|qname -> aClass                           :aom:
***** demo [name]                                                   :control:
***** draw( [aDiagram] ) -> aDiagram                                :control:
***** function id|name|qname -> aFunction                               :aom:
***** generate                                                         :core:
***** invariant stexp                                                  :core:
***** leftString str int -> aString                                 :strings:
***** load [filename] -> nil|anError                                  :files:
***** move                                                             :core:
***** new id|name -> anObject                                       :control:
***** parse [filepath]                                                 :core:
***** quit                                                          :control:
***** run stexp                                                        :core:
***** removeSelected -> nil|anError                                 :control:
***** rename name str                                               :control:
***** rightSring str int -> aString                                 :strings:
***** search stexp                                                     :core:
***** selectAll -> nil|anError                                      :control:
***** subString str int int -> aString                              :strings:
***** save [filename] -> nil|anError                                :control:
***** transform stexp                                                  :core:

** dna
** graph

Visualizing many items requires one or more layout algorithms.
Would try boost-graph (others: igraph, ogdf).

** cworker



*** alc
for some reasons I tryied some parsers: alc is an AL parser based on CodeWorker.
