jdb/jlp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
3c34e080ef
jlp/doc/grammar.rst

30 lines
525 B
ReStructuredText
Raw Normal View History

Experimenting with a different AST structure and ideas. Ideas: * For literate output, format like Docco, tables like Doc | Code -----------|------------ | docblock | codeblock | | docblock | codeblock | | docblock | codeblock | * For javadoc output, maybe create a running 'pure source' object containing just the code lines. Then run an sup-parser for the language the code is written in and build a seperate AST for the code. This code AST then gets tagged onto the overall AST and is used in the generation phase for code comprehension. Would still need a way to map doc blocks to code blocks. I could probably use line numbers. In that case I would need to map the original source line from the commented input to the 'pure source' while processing the 'pure source' and store the original line number in the code AST. That would give me a reliable way to lookup the closest code structure to a doc block. * The code AST would need to made of generic pieces if I want to have language-agnostic generator code. What may be better is to allow the language parser to create it's code AST however is wants and just have some pluggable bit of the generator for each language. Would increase generator code complexity though.
2011-08-31 17:09:25 +00:00
SourceFile ->
(Block / DocBlock / CodeBlock)+
Started grammar definition.
2011-08-23 21:26:02 +00:00
Experimenting with a different AST structure and ideas. Ideas: * For literate output, format like Docco, tables like Doc | Code -----------|------------ | docblock | codeblock | | docblock | codeblock | | docblock | codeblock | * For javadoc output, maybe create a running 'pure source' object containing just the code lines. Then run an sup-parser for the language the code is written in and build a seperate AST for the code. This code AST then gets tagged onto the overall AST and is used in the generation phase for code comprehension. Would still need a way to map doc blocks to code blocks. I could probably use line numbers. In that case I would need to map the original source line from the commented input to the 'pure source' while processing the 'pure source' and store the original line number in the code AST. That would give me a reliable way to lookup the closest code structure to a doc block. * The code AST would need to made of generic pieces if I want to have language-agnostic generator code. What may be better is to allow the language parser to create it's code AST however is wants and just have some pluggable bit of the generator for each language. Would increase generator code complexity though.
2011-08-31 17:09:25 +00:00
Block ->
DocBlock CodeBlock
Started grammar definition.
2011-08-23 21:26:02 +00:00
Experimenting with a different AST structure and ideas. Ideas: * For literate output, format like Docco, tables like Doc | Code -----------|------------ | docblock | codeblock | | docblock | codeblock | | docblock | codeblock | * For javadoc output, maybe create a running 'pure source' object containing just the code lines. Then run an sup-parser for the language the code is written in and build a seperate AST for the code. This code AST then gets tagged onto the overall AST and is used in the generation phase for code comprehension. Would still need a way to map doc blocks to code blocks. I could probably use line numbers. In that case I would need to map the original source line from the commented input to the 'pure source' while processing the 'pure source' and store the original line number in the code AST. That would give me a reliable way to lookup the closest code structure to a doc block. * The code AST would need to made of generic pieces if I want to have language-agnostic generator code. What may be better is to allow the language parser to create it's code AST however is wants and just have some pluggable bit of the generator for each language. Would increase generator code complexity though.
2011-08-31 17:09:25 +00:00
DocBlock ->
(Directive / DocText)+
Implmented actions to build AST. * Rewrote grammar slightly. * Added parboiled parse section to JLPMain. * Added code to build the AST while parsing. * Created ASTNode classes.
2011-08-26 20:40:56 +00:00
Experimenting with a different AST structure and ideas. Ideas: * For literate output, format like Docco, tables like Doc | Code -----------|------------ | docblock | codeblock | | docblock | codeblock | | docblock | codeblock | * For javadoc output, maybe create a running 'pure source' object containing just the code lines. Then run an sup-parser for the language the code is written in and build a seperate AST for the code. This code AST then gets tagged onto the overall AST and is used in the generation phase for code comprehension. Would still need a way to map doc blocks to code blocks. I could probably use line numbers. In that case I would need to map the original source line from the commented input to the 'pure source' while processing the 'pure source' and store the original line number in the code AST. That would give me a reliable way to lookup the closest code structure to a doc block. * The code AST would need to made of generic pieces if I want to have language-agnostic generator code. What may be better is to allow the language parser to create it's code AST however is wants and just have some pluggable bit of the generator for each language. Would increase generator code complexity though.
2011-08-31 17:09:25 +00:00
Directive ->
DocLineStart AT (LongDirective / ShortDirective)
Finished basic grammar outline.
2011-08-25 12:13:39 +00:00
Implmented actions to build AST. * Rewrote grammar slightly. * Added parboiled parse section to JLPMain. * Added code to build the AST while parsing. * Created ASTNode classes.
2011-08-26 20:40:56 +00:00
LongDirective ->
Experimenting with a different AST structure and ideas. Ideas: * For literate output, format like Docco, tables like Doc | Code -----------|------------ | docblock | codeblock | | docblock | codeblock | | docblock | codeblock | * For javadoc output, maybe create a running 'pure source' object containing just the code lines. Then run an sup-parser for the language the code is written in and build a seperate AST for the code. This code AST then gets tagged onto the overall AST and is used in the generation phase for code comprehension. Would still need a way to map doc blocks to code blocks. I could probably use line numbers. In that case I would need to map the original source line from the commented input to the 'pure source' while processing the 'pure source' and store the original line number in the code AST. That would give me a reliable way to lookup the closest code structure to a doc block. * The code AST would need to made of generic pieces if I want to have language-agnostic generator code. What may be better is to allow the language parser to create it's code AST however is wants and just have some pluggable bit of the generator for each language. Would increase generator code complexity though.
2011-08-31 17:09:25 +00:00
("author" / "doc" / "example") RemainingLine DocText?
Worked on documentation, parser. * Added planning documentation regrding the process. * Updated grammer. * Refactored the test code a bit. * Added sample input file from vbs-suite * Refactored the AST node structure created by the parser.
2011-08-29 14:44:05 +00:00
Experimenting with a different AST structure and ideas. Ideas: * For literate output, format like Docco, tables like Doc | Code -----------|------------ | docblock | codeblock | | docblock | codeblock | | docblock | codeblock | * For javadoc output, maybe create a running 'pure source' object containing just the code lines. Then run an sup-parser for the language the code is written in and build a seperate AST for the code. This code AST then gets tagged onto the overall AST and is used in the generation phase for code comprehension. Would still need a way to map doc blocks to code blocks. I could probably use line numbers. In that case I would need to map the original source line from the commented input to the 'pure source' while processing the 'pure source' and store the original line number in the code AST. That would give me a reliable way to lookup the closest code structure to a doc block. * The code AST would need to made of generic pieces if I want to have language-agnostic generator code. What may be better is to allow the language parser to create it's code AST however is wants and just have some pluggable bit of the generator for each language. Would increase generator code complexity though.
2011-08-31 17:09:25 +00:00
ShortDirective ->
("org" / "copyright") RemainingLine
More work on grammar, starting parboiled implementation.
2011-08-25 12:47:01 +00:00
Experimenting with a different AST structure and ideas. Ideas: * For literate output, format like Docco, tables like Doc | Code -----------|------------ | docblock | codeblock | | docblock | codeblock | | docblock | codeblock | * For javadoc output, maybe create a running 'pure source' object containing just the code lines. Then run an sup-parser for the language the code is written in and build a seperate AST for the code. This code AST then gets tagged onto the overall AST and is used in the generation phase for code comprehension. Would still need a way to map doc blocks to code blocks. I could probably use line numbers. In that case I would need to map the original source line from the commented input to the 'pure source' while processing the 'pure source' and store the original line number in the code AST. That would give me a reliable way to lookup the closest code structure to a doc block. * The code AST would need to made of generic pieces if I want to have language-agnostic generator code. What may be better is to allow the language parser to create it's code AST however is wants and just have some pluggable bit of the generator for each language. Would increase generator code complexity though.
2011-08-31 17:09:25 +00:00
DocText ->
(DocLineStart !AT RemainingLine)+
Finished basic grammar outline.
2011-08-25 12:13:39 +00:00
Experimenting with a different AST structure and ideas. Ideas: * For literate output, format like Docco, tables like Doc | Code -----------|------------ | docblock | codeblock | | docblock | codeblock | | docblock | codeblock | * For javadoc output, maybe create a running 'pure source' object containing just the code lines. Then run an sup-parser for the language the code is written in and build a seperate AST for the code. This code AST then gets tagged onto the overall AST and is used in the generation phase for code comprehension. Would still need a way to map doc blocks to code blocks. I could probably use line numbers. In that case I would need to map the original source line from the commented input to the 'pure source' while processing the 'pure source' and store the original line number in the code AST. That would give me a reliable way to lookup the closest code structure to a doc block. * The code AST would need to made of generic pieces if I want to have language-agnostic generator code. What may be better is to allow the language parser to create it's code AST however is wants and just have some pluggable bit of the generator for each language. Would increase generator code complexity though.
2011-08-31 17:09:25 +00:00
DocLineStart ->
Space* DOC_LINE_START Space?
Implmented actions to build AST. * Rewrote grammar slightly. * Added parboiled parse section to JLPMain. * Added code to build the AST while parsing. * Created ASTNode classes.
2011-08-26 20:40:56 +00:00
Experimenting with a different AST structure and ideas. Ideas: * For literate output, format like Docco, tables like Doc | Code -----------|------------ | docblock | codeblock | | docblock | codeblock | | docblock | codeblock | * For javadoc output, maybe create a running 'pure source' object containing just the code lines. Then run an sup-parser for the language the code is written in and build a seperate AST for the code. This code AST then gets tagged onto the overall AST and is used in the generation phase for code comprehension. Would still need a way to map doc blocks to code blocks. I could probably use line numbers. In that case I would need to map the original source line from the commented input to the 'pure source' while processing the 'pure source' and store the original line number in the code AST. That would give me a reliable way to lookup the closest code structure to a doc block. * The code AST would need to made of generic pieces if I want to have language-agnostic generator code. What may be better is to allow the language parser to create it's code AST however is wants and just have some pluggable bit of the generator for each language. Would increase generator code complexity though.
2011-08-31 17:09:25 +00:00
CodeBlock ->
(!DocLineStart RemainingLine)+
Implmented actions to build AST. * Rewrote grammar slightly. * Added parboiled parse section to JLPMain. * Added code to build the AST while parsing. * Created ASTNode classes.
2011-08-26 20:40:56 +00:00
Experimenting with a different AST structure and ideas. Ideas: * For literate output, format like Docco, tables like Doc | Code -----------|------------ | docblock | codeblock | | docblock | codeblock | | docblock | codeblock | * For javadoc output, maybe create a running 'pure source' object containing just the code lines. Then run an sup-parser for the language the code is written in and build a seperate AST for the code. This code AST then gets tagged onto the overall AST and is used in the generation phase for code comprehension. Would still need a way to map doc blocks to code blocks. I could probably use line numbers. In that case I would need to map the original source line from the commented input to the 'pure source' while processing the 'pure source' and store the original line number in the code AST. That would give me a reliable way to lookup the closest code structure to a doc block. * The code AST would need to made of generic pieces if I want to have language-agnostic generator code. What may be better is to allow the language parser to create it's code AST however is wants and just have some pluggable bit of the generator for each language. Would increase generator code complexity though.
2011-08-31 17:09:25 +00:00
RemainingLine ->
((!EOL)* EOL) / ((!EOL)+ EOI)
Reference in New Issue Copy Permalink