www.digitalmars.com         C & C++   DMDScript  

D - Code documentation - 1 attachment

reply Juarez Rudsatz <juarez correio.com> writes:
Hi all!

    	I am sending a very preliminary version of a specification for 
implementing a sintax for document source files using the /* */ comments.
    	It's a preliminary version and contain, certainly, design and 
language errors.
    	Please read the attached html file and send your comments.

Juarez Rudsatz
Jul 12 2002
next sibling parent reply "anderson" <anderson firestar.com.au> writes:
Content-Type: text/plain;
	charset="iso-8859-1"
Content-Transfer-Encoding: quoted-printable

Source code documentation with coddocThis is very complete and I can't =
think of much to add. =20

Is it possible to have html links in documentation, or better yet html =
code? I know "see" has this ablity, but what about in a general comment. =
For example In some cases you may want to insert a picture of what your =
talking about.
Jul 12 2002
parent reply "OddesE" <OddesE_XYZ hotmail.com> writes:
Source code documentation with coddoc"anderson" <anderson firestar.com.au>
wrote in message news:agoaa2$16a9 $1 digitaldaemon.com...
 This is very complete and I can't think of much to add.

 Is it possible to have html links in documentation,
 or better yet html code?
 I know "see" has this ablity, but what about in a general
 comment. For example In some cases you may want to insert
 a picture of what your talking about.

I agree, this is a very useful feature, and most tools support this. -- Stijn OddesE_XYZ hotmail.com http://OddesE.cjb.net _________________________________________________ Remove _XYZ from my address when replying by mail
Jul 14 2002
parent "Robert M. Münch" <robert.muench robertmuench.de> writes:
"OddesE" <OddesE_XYZ hotmail.com> schrieb im Newsbeitrag
news:agt6tf$9to$1 digitaldaemon.com...

 I agree, this is a very useful feature, and most
 tools support this.

Hi, if you want to write TXT in a very easy manner and get good looking HTML out of it have a look at my make-doc-pro on my homepage. This is a Rebol script and you will find some getting-started infos too. My homepage has been done with this tool. If you have any questions let me know. -- Robert M. Münch IT & Management Freelancer Mobile: +49 (0)177 2452 802 Fax : +49 (0)721 8408 9112 Web : http://www.robertmuench.de
Jul 15 2002
prev sibling next sibling parent reply "OddesE" <OddesE_XYZ hotmail.com> writes:
Source code documentation with coddocI read the document, and I think it is
a very good initiative.
We definitely need some kind of standard for this, or we will
end up with a whole bunch of similar standards that differ in
just enough respect to be a pain in the you-know-where.

I do propose one big and a whole bunch of small alterations
to the standard. I have marked sections that I have added in
green, comments in red and sections that I think should be
deleted in gray.

The text that still is black also had changes in them, but
these are just small things such as corrected spelling
errors, they don't change the standard in any way.

The modified file is attached.


--
Stijn
OddesE_XYZ hotmail.com
http://OddesE.cjb.net
_________________________________________________
Remove _XYZ from my address when replying by mail
Jul 14 2002
next sibling parent "anderson" <anderson firestar.com.au> writes:
Content-Type: text/plain;
	charset="iso-8859-1"
Content-Transfer-Encoding: quoted-printable

Some good points. I like the XML (although it'll mean more typing). What =
will happen if the D file is saved as a html? You'd have to do a bit of =
stuffing I supose. Parhaps that should be in the documentation.
  "OddesE" <OddesE_XYZ hotmail.com> wrote in message =
news:agt6me$9ht$1 digitaldaemon.com...
  Source code documentation with coddocI read the document, and I think =
it is
  a very good initiative.
  We definitely need some kind of standard for this, or we will
  end up with a whole bunch of similar standards that differ in
  just enough respect to be a pain in the you-know-where.

  I do propose one big and a whole bunch of small alterations
  to the standard. I have marked sections that I have added in
  green, comments in red and sections that I think should be
  deleted in gray.

  The text that still is black also had changes in them, but
  these are just small things such as corrected spelling
  errors, they don't change the standard in any way.

  The modified file is attached.


  --
  Stijn
  OddesE_XYZ hotmail.com
  http://OddesE.cjb.net
  _________________________________________________
  Remove _XYZ from my address when replying by mail
Jul 14 2002
prev sibling next sibling parent reply Juarez Rudsatz <juarez nowhere.com> writes:
Hi,

    	I busy right now. I will read carefuly all posts and reply late. I 
think the initiative must not be closed. And many "D" people should 
contribute. 

"OddesE" <OddesE_XYZ hotmail.com> wrote in
news:agt6me$9ht$1 digitaldaemon.com: 

 Source code documentation with coddocI read the document, and I think
 it is a very good initiative.
 We definitely need some kind of standard for this, or we will
 end up with a whole bunch of similar standards that differ in
 just enough respect to be a pain in the you-know-where.
 
 I do propose one big and a whole bunch of small alterations
 to the standard. I have marked sections that I have added in
 green, comments in red and sections that I think should be
 deleted in gray.
 
 The text that still is black also had changes in them, but
 these are just small things such as corrected spelling
 errors, they don't change the standard in any way.
 
 The modified file is attached.
 
 --
 Stijn
 OddesE_XYZ hotmail.com
 http://OddesE.cjb.net
 _________________________________________________

Jul 15 2002
parent reply "Sean L. Palmer" <seanpalmer earthlink.net> writes:
Some D people Just Don't Care that much about Standardized Documentation.
I'm sure you guys will come up with something good.

Sean

"Juarez Rudsatz" <juarez nowhere.com> wrote in message
news:Xns924C7EB89CDB6juarezcom 63.105.9.61...
     I busy right now. I will read carefuly all posts and reply late. I
 think the initiative must not be closed. And many "D" people should
 contribute.

Jul 15 2002
parent "OddesE" <OddesE_XYZ hotmail.com> writes:
"Sean L. Palmer" <seanpalmer earthlink.net> wrote in message
news:agv4b1$2cb9$1 digitaldaemon.com...
 Some D people Just Don't Care that much about Standardized Documentation.
 I'm sure you guys will come up with something good.

 Sean

Have you ever used programs like DoxyGen or JavaDoc? They rule! I have an assertion that says: "If your public class or function is not documented, it might as well be private." It is a little rough, but think of the undocumented Windows API functions, or undocumented Delphi classes or functions, and it is (kinda :) true. Good documentation helps code-reuse, and thus it is important. Tools like Javadoc have really helped, but Javadoc is a standard tool in the Java SDK. If we as the D community want such tools too, we have to find someone crazy enough to build one. It would be cool if it would be built to a standard that was reached in concensus, instead of to the whims of whoever was designing it at that point... Fortunately Walter has made all the parsing code open source and published it, so that should help someone wanting to do an implementation. -- Stijn OddesE_XYZ hotmail.com http://OddesE.cjb.net _________________________________________________ Remove _XYZ from my address when replying by mail
Jul 16 2002
prev sibling parent reply Juarez Rudsatz <juarez nowhere.com> writes:
I wanna discuss the proposal about xml:

<quoted from="post" author="OddesE" day="dom">

As you will see in the next section I propose a change in the standard that 
is pretty big. I say we change the way tags are described to a method that 
is essentially xml compliant. There are a few reasons for this:

- xml is a standard. ;) 
- xml has been well thought out and will most likely be more easy to write 
a parser for, but better still, we probably don't even have to do this, 
because we can use an existing parser. 
xml is well known so people will probably understand it easier. 
- This way we don't have to differentiate between single-line and multi-
line tags. 
- You can write a dtd or schema which states the rules for comments in a 
machine readable way, so checking if the code is ok could be automatic. 
- You can write an xslt stylesheet for translating the xml code to other 
document formats. 
- The code to parse xml, check it's syntax using schema's or dtd's and 
transforming it into other documents using stylesheets has already been 
written, and is available, for free, on almost any platform and in almost 
any language. This would greatly simplify the creation of a DDoc 
application. 

</quoted>
  

Basically the reasons for adopting xml as commenting are:

- xml is standart and well known
- The syntax is strong
- Could be easy write a program to parse comments with xml
- You can use already coded programs to simplify generation of programs

    	I have thinked about using xml. But IMHO xml don't satisfy all 
objectives of a documentation tool.
    	Some of objectives for me are:

1 - Programmer must do the minimal effort possible
2 - The documentation in source code must be clear
3 - Syntax must be strong and non ambigous
4 - Syntax must be flexible enough for the tools generate many formats as 
possible

I have looked in documentation of some tools, like Javadoc, doxygen and so 
on. My motivation for using the format proposed is :

* author: name
* <author>name</author>
*  author: name

    	The first is more intuitiv, clear and easy to write. The tools can 
easily parse documents like this and couldn't be so hard to write a lexer 
or a parse for this.
    	The xml form is not so clear as the first and adds unnecessary 
garbage, the closing tag. Once the comments can have a visual effect 
newlines can be used for end-of-element parsing. I think using xml we pass 
to programmer the work what must be of compiler. So IMHO the xml fails in 
(1) and (2).
    	All good points for xml came from it can satisfy (3) and (4). 
    	For (4) I have thinked in a simple solution : decouple the document 
generation from document parsing. The tool must not generate a final 
document. Is best, for example, generate a xml docbook and than apply a new 
tool for generating the document, jade, xlst, etc... But this is work for a 
compiler ( for human knowledge to general programming format like xml ).
    	The problem is (3) yet. I don't sure syntax proposed is non-ambiguos 
or easy to parse. But the problems must be stripped or remodeled. For 
example, the tag parameters in the proposed syntax are ugly.
    	
    	I think this is the first point to discuss and define. And maturing a 
little bit more could be good. 
    	The all post until now have been good and showed anothers 
perspectives for the documentation. Let's continue...

Juarez Rudsatz

"OddesE" <OddesE_XYZ hotmail.com> wrote in
news:agt6me$9ht$1 digitaldaemon.com: 

 Source code documentation with coddocI read the document, and I think
 it is a very good initiative.
 We definitely need some kind of standard for this, or we will
 end up with a whole bunch of similar standards that differ in
 just enough respect to be a pain in the you-know-where.
 
 I do propose one big and a whole bunch of small alterations
 to the standard. I have marked sections that I have added in
 green, comments in red and sections that I think should be
 deleted in gray.
 
 The text that still is black also had changes in them, but
 these are just small things such as corrected spelling
 errors, they don't change the standard in any way.
 
 The modified file is attached.
 

Jul 16 2002
next sibling parent reply "anderson" <anderson firestar.com.au> writes:
If the docgen program supported both XML and ":" (and I'm not saying that's
a good idea), which would you end up using? I would and up using the ":"
format because it's so much faster to type. It requires no duplication, only
one shift key and looks neat.
Jul 16 2002
parent reply "Sean L. Palmer" <seanpalmer earthlink.net> writes:
XML and HTML are meant to be generated by tools, not typed in by hand.
Right-click, select Insert Documentation | Comment....  Just like
autocomplete does today, the editor could watch for /* and // and create
comment blocks for you.  During save or before passing to the compiler it
could transform them back to /*abc*/ and //abc with special tags.  I suppose
you guys are deciding what the tags should be.

Sean

"anderson" <anderson firestar.com.au> wrote in message
news:ah2uid$63r$1 digitaldaemon.com...
 If the docgen program supported both XML and ":" (and I'm not saying

 a good idea), which would you end up using? I would and up using the ":"
 format because it's so much faster to type. It requires no duplication,

 one shift key and looks neat.

Jul 17 2002
parent reply "anderson" <anderson firestar.com.au> writes:
"Sean L. Palmer" <seanpalmer earthlink.net> wrote in message
news:ah379p$hbh$1 digitaldaemon.com...
 XML and HTML are meant to be generated by tools, not typed in by hand.
 Right-click, select Insert Documentation | Comment....  Just like
 autocomplete does today, the editor could watch for /* and // and create
 comment blocks for you.  During save or before passing to the compiler it
 could transform them back to /*abc*/ and //abc with special tags.  I

 you guys are deciding what the tags should be.

 Sean

Exactly. OddesE was suggesting that we use XML for the text comment formating, not the generator. The most of these tags are definded in Juarez Rudastz first document. They may just need a bit of tweeking (where I don't know).
Jul 17 2002
parent reply "OddesE" <OddesE_XYZ hotmail.com> writes:
I guess you are all right... :)
When writing the document I was also running into
the fact that the xml is too verbose to type by hand.
I think Juarez solution, parse source code comments,
generate intermediate xml and from that generate
resulting documentation, is best. I just wanted to show
another way of doing it.
But there still remain some issues with Juarez'
proposed syntax. Especially when to know if a tag
closes...EOL is good for single line tags, but what
if I have an author with a really long name or
something? Maybe we could use some kind of 'continue
on next line tag, like this:

/**
 * author: My author with a very long name must :-->
 * be continued on the next line.
**/

Or, how about mixing them?
Use the colon notation for single line tags, which
must end at the end of line, and use xml-style notation
if you need more than one line:

/**
 * author: OddesE
 * <author>My author with a very long name must
 * be continued on the next line.</author>
**/

With the very long contents of the second tag,
having to write a closing tag becomes less of a
burden. Plus, in practice allmost all tags are
one line, so generally you would have the
advantage of the colon notation.


--
Stijn
OddesE_XYZ hotmail.com
http://OddesE.cjb.net
_________________________________________________
Remove _XYZ from my address when replying by mail
Jul 17 2002
parent reply "anderson" <anderson firestar.com.au> writes:
 something? Maybe we could use some kind of 'continue
 on next line tag, like this:

 /**
  * author: My author with a very long name must :-->
  * be continued on the next line.
 **/

If line continuation must be known then I'd propose _ like VB uses. But I don't think it's nessary.
 Or, how about mixing them?
 Use the colon notation for single line tags, which
 must end at the end of line, and use xml-style notation
 if you need more than one line:

 /**
  * author: OddesE
  * <author>My author with a very long name must
  * be continued on the next line.</author>
 **/

I thought of that also but tossed out the idea. A return is simple enough to determine a new line.
 /**
  * author: OddesE
  * author: My author with a very long name must
  * be continued on the next line.
 **/

The end of a tag definition can be found at either the start of the next tag or the end of the comment.
 With the very long contents of the second tag,
 having to write a closing tag becomes less of a
 burden. Plus, in practice allmost all tags are
 one line, so generally you would have the
 advantage of the colon notation.

I'd also propose that </> be used to indicate end of line (If it must be known). But I don't think this is necessary. And if you want to use XML code still. /** * author: OddesE * <author>My author with a very long name must * be continued on the next line.</> **/ But that's still worse then. /** * author: OddesE * author: My author with a very long name must * be continued on the next line. **/ Even javaDoc did that. It should be noted that XML is used for hierarchical data. ie <B><I></I></B> and this documentation form doesn't need that.
Jul 17 2002
next sibling parent Juarez Rudsatz <juarez nowhere.com> writes:
Hi all,

    	Some comments :

"anderson" <anderson firestar.com.au> wrote in
news:ah41br$1dih$1 digitaldaemon.com: 

 
 I thought of that also but tossed out the idea. A return is simple
 enough to determine a new line.
 
 /**
  * author: OddesE
  * author: My author with a very long name must
  * be continued on the next line.
 **/

The end of a tag definition can be found at either the start of the next tag or the end of the comment.
 With the very long contents of the second tag,
 having to write a closing tag becomes less of a
 burden. Plus, in practice allmost all tags are
 one line, so generally you would have the
 advantage of the colon notation.


I think exists a regular expression, commonly used in lex, for lexing the format. If one regexp could be found then the sintax is not ambiguos. Please correct if I am wrong. STARTDOC = '/**'['*']*\b ENDDOC = ['*']'**/' SINLINEDOC = '//*'\b IDENTATION = [\b\t]*'*'\b TAG = [a-z][a-z]*':' TEXT = . Someone could correct this ?
Jul 17 2002
prev sibling parent reply "OddesE" <OddesE_XYZ hotmail.com> writes:
"anderson" <anderson firestar.com.au> wrote in message
news:ah41br$1dih$1 digitaldaemon.com...

 I thought of that also but tossed out the idea. A return is simple enough

 determine a new line.

 /**
  * author: OddesE
  * author: My author with a very long name must
  * be continued on the next line.
 **/

The end of a tag definition can be found at either the start of the next

 or the end of the comment.

Ok, but what about this: /** * author: OddesE * author: My author with a very long name must * be continued on the next line. * This module serves the purpose of demonstrating * examples of code comments. **/ module test; Ways to prevent problems here could be: - Mandating that properties come after the comment text - Mandating an empty line between properties and comment text - Line-continue tokens such as suggested - Closing tags such as suggested I guess that mandating an empty line between properties and comment tags is easy and looks natural: /** * author: OddesE * author: My author with a very long name must * be continued on the next line. * * This module serves the purpose of demonstrating * examples of code comments. **/ module test; Ofcourse there are no problems when the comment text is followed by properties instead of being preceded by them.
 It should be noted that XML is used for hierarchical data. ie

 and this documentation form doesn't need that.

I guess you are right about that. -- Stijn OddesE_XYZ hotmail.com http://OddesE.cjb.net _________________________________________________ Remove _XYZ from my address when replying by mail
Jul 19 2002
parent Juarez Rudsatz <juarez nowhere.com> writes:
"OddesE" <OddesE_XYZ hotmail.com> wrote in news:ah95mq$2afp$1
 digitaldaemon.com:

 
 I guess that mandating an empty line between properties and
 comment tags is easy and looks natural:
 

I agree with the comment about the statement can be writed before the tags or need a empty line.
Jul 19 2002
prev sibling parent reply Juarez Rudsatz <juarez nowhere.com> writes:
Juarez Rudsatz <juarez nowhere.com> wrote in
news:Xns924D92B1EB48Djuarezcorreiocom 63.105.9.61: 

          The problem is (3) yet. I don't sure syntax proposed is
          non-ambiguos 
 or easy to parse. But the problems must be stripped or remodeled. For 
 example, the tag parameters in the proposed syntax are ugly.
 

I have seen the form is used in mail specification for parameters: MIME-version: 1.0 MIME-encoding: 7 bit Enabling this "subtags" could be a good form of dealing with parameters for comments ? What do you think ? There are another good way ? E.g.: /** * copyright: Pavel "EvilOne" Minayev * copyright-date: 2001 * license : GPL * license-site : http://www.gnu.org/copyleft/gpl.html * version : 2.95.0.3 * version-status : stable * bug : Windows 9x does not pass the correct memory used * bug-severity : low **/
Jul 17 2002
parent "anderson" <anderson firestar.com.au> writes:
Content-Type: text/plain;
	charset="iso-8859-1"
Content-Transfer-Encoding: quoted-printable


"Juarez Rudsatz" <juarez nowhere.com> wrote in message =
news:Xns924E86EA83162juarezcorreiocom 63.105.9.61...
 Juarez Rudsatz <juarez nowhere.com> wrote in
 news:Xns924D92B1EB48Djuarezcorreiocom 63.105.9.61:=20
=20
          The problem is (3) yet. I don't sure syntax proposed is
          non-ambiguos=20
 or easy to parse. But the problems must be stripped or remodeled. =


 example, the tag parameters in the proposed syntax are ugly.
=20

I have seen the form is used in mail specification for parameters: =20 MIME-version: 1.0 MIME-encoding: 7 bit =20 Enabling this "subtags" could be a good form of dealing with=20 parameters for comments ? What do you think ? There are another good =

=20
 E.g.:
=20
 /**
  * copyright: Pavel "EvilOne" Minayev
  * copyright-date: 2001
  * license : GPL
  * license-site : http://www.gnu.org/copyleft/gpl.html
  * version : 2.95.0.3
  * version-status : stable
  * bug : Windows 9x does not pass the correct memory used
  * bug-severity : low
  **/

Looks good, although I don't know how often I'd use it. It'd be good for = project programming. I guess if its there... I'd be nice if there was = some central base for bug produced by the gen (perhaps optional). This = way you could quickly find bugs to attempt to fix. How about, * bug-fixed : Windows 9x does not pass the correct memory used for fixed bugs (simply add the -fixed to bug) Also bugs should have optional titles as it makes things easier to fix = if bugs have long definitions. * bug-name : Win9x memory error And also how about a company logo that will be placed on every page = (next to copy write) * logo : logo.gif=20 And a=20 * Updated : 2002.10.10 Although that could be determined though the file's attributes by = default for the class; file dates are not always a correct indication of = an update and not every method in a class will be updated every time. -------------------------------------------------------------------------= ------- On another note I'd think it would be also be nice to have the gen program produce html = documents from a html templates. Of corse there would be a default one = that comes with the program that you could customise. You'd probably have these templates: Index.htm - Frame based page SideBar.htm - Hierarchical side bar Class.htm - Class layout template Method.htm - Methods layout Property.htm - Property layout Of course more though needs to be put into that. Basically the generation program would copy the files as needed and look = for special tags in the files to replace with code from the files. A bit = of though will have to go into how list will be produced. Perhaps an XML = derivative (without need for closing except on lists) could be used as = tags in the html template files. For example (Although I don't like the extra typyness of xml it could be used for = lists.) ...Sample html template code for Class... //Other html code... [CLASS] <H1>[CLASS NAME]</H1> Version : <B>[CLASS VERSION]</B> [METHOD LIST] <H2>[METHOD NAME/]</H2> [COMMENT/] <I>[AUTHOR/]</I> <TAB>Version: <B>[VERSION/]</B></TAB> [/METHOD LIST] [/CLASS] //Other html code... The gen would search for the square brackets (I don't care what is used, = except <> will be confided with html) and replace them with actual = comments. This way pages could be enhanced for the particular operation. I know = it's good to have a common standard, but what if - say a company want to = make all the pages in the same style as there webpage. It would be far = easier to do this with template html. Also this would mean the layout of = the gen could be improved over time. If I had time (an I don't) I'd = program this myself in D as it doesn't look like a very tough job (but I = could be wrong).
Jul 17 2002
prev sibling next sibling parent reply "anderson" <anderson firestar.com.au> writes:
Content-Type: text/plain;
	charset="iso-8859-1"
Content-Transfer-Encoding: quoted-printable

Source code documentation with coddocThis is more of a doc generation =
suggestion.  I think it would be good if of doc generator had some =
infromation about the line number where the code begins. This would help =
enable furture IDE's to use the documentation as a basics for the IDE =
layout.

I know I've said this before, but It would be cool if the docgen could =
produce code in an uml format.

PS - Robert M. M=FCnch tool produces quite nice output, and I'd =
recommend it for this "Code documentation attachement". Also it mite be =
an idea for the D Journal if documents are to be produced to some =
standard (although it may mean extra reformating work). It handles code =
segments especially well (by picking up tabs).
Jul 15 2002
parent reply "Robert M. Münch" <robert.muench robertmuench.de> writes:
Source code documentation with coddocHi, thanks a lot. There is something
that comes to mind: D can compile HTML files! So it maybe best to include D
code into the documentation and not documentation into D code. My script
could easly be changed to produce a compileable output file. With this we
would be able to move more into the WEB idea of litteral programming. Code
is already recognized as mentioned. What do you think? Robert


"anderson" <anderson firestar.com.au> schrieb im Newsbeitrag
news:ah0fv5$m3f$1 digitaldaemon.com...
PS - Robert M. Münch tool produces quite nice output, and I'd recommend it
for this "Code documentation attachement". Also it mite be an idea for the D
Journal if documents are to be produced to some standard (although it may
mean extra reformating work). It handles code segments especially well (by
picking up tabs).
Jul 16 2002
next sibling parent "Sean L. Palmer" <seanpalmer earthlink.net> writes:
Just have the documentation have hyperlinks to the appropriate section of
the D file, and the D file has marker tags you can hyperlink to, one for
each thingy such as class or function.  It'd also be nice for a member
function to have a hyperlink to the class declaration, an import module
directive to have a hyperlink to that module, etc.  In fact these could be
generated automatically;  perhaps the compiler could insert them if
requested to do so.

Sean

"Robert M. Münch" <robert.muench robertmuench.de> wrote in message
news:ah0ggd$niq$1 digitaldaemon.com...
 Source code documentation with coddocHi, thanks a lot. There is something
 that comes to mind: D can compile HTML files! So it maybe best to include

 code into the documentation and not documentation into D code. My script
 could easly be changed to produce a compileable output file. With this we
 would be able to move more into the WEB idea of litteral programming. Code
 is already recognized as mentioned. What do you think? Robert


 "anderson" <anderson firestar.com.au> schrieb im Newsbeitrag
 news:ah0fv5$m3f$1 digitaldaemon.com...
 PS - Robert M. Münch tool produces quite nice output, and I'd recommend it
 for this "Code documentation attachement". Also it mite be an idea for the

 Journal if documents are to be produced to some standard (although it may
 mean extra reformating work). It handles code segments especially well (by
 picking up tabs).

Jul 16 2002
prev sibling next sibling parent reply "anderson" <anderson firestar.com.au> writes:
Content-Type: text/plain;
	charset="iso-8859-1"
Content-Transfer-Encoding: quoted-printable

Perhaps, there could be automatic hierarchical generation in some docgen =
like program. I think something along these lines was mentioned before =
(except it was compiler based). The hierarchical generator would simply =
scan all the D html files and built a code map, possibly using a UML =
derivative.  It would also generate a framed index file. So I still see =
a need for tags.=20

  The program could reformat these tags and automatically add things =
like see. This would provide a way to have automatically generated =
comments in the code itself not just the html. Now if someone is using a =
text editor for D, this could make things messy so the html (or xhtml) =
would have to be kept neat in a text form as well. There could also be =
special tags to indicate not to do certain things.=20

      /**
       * <author>Micky mouse</author>
       * <version>1.0</version>
       *
       *  The does blah blah blah blah blah blah blah blah blah blah =
blah blah=20
      *   blah blah blah blah blah blah blah blah blah blah blah blah =
blah blah=20
      *   blah blah blah blah blah=20
      **/
void func(int a)
{
...
}

Would change to
  void func(int a)
      Parameters

      a : Unknown
    =20



      The does blah blah blah blah blah blah blah blah blah blah blah =
blah blah blah blah blah blah blah blah blah blah blah blah blah blah =
blah blah blah blah blah blah=20

      Micky mouse

      See
             func2, func3
          =20




      V 1.0
    =20


      =20

      {

      ...
      }=20

=20


Anyway that's just an idea of a possible layout (athough it'll need alot =
more work).  The docGen should reconise both formats so that it can =
reconise what it has generated. Also classes could be done in a UML =
style by dividing the varaibles from the functions.

"Robert M. M=FCnch" <robert.muench robertmuench.de> wrote in message =
news:ah0ggd$niq$1 digitaldaemon.com...
 Source code documentation with coddocHi, thanks a lot. There is =

 that comes to mind: D can compile HTML files! So it maybe best to =

 code into the documentation and not documentation into D code. My =

 could easly be changed to produce a compileable output file. With this =

 would be able to move more into the WEB idea of litteral programming. =

 is already recognized as mentioned. What do you think? Robert
=20
=20
 "anderson" <anderson firestar.com.au> schrieb im Newsbeitrag
 news:ah0fv5$m3f$1 digitaldaemon.com...
 PS - Robert M. M=FCnch tool produces quite nice output, and I'd =

 for this "Code documentation attachement". Also it mite be an idea for =

 Journal if documents are to be produced to some standard (although it =

 mean extra reformating work). It handles code segments especially well =

 picking up tabs).
=20
=20

Jul 16 2002
parent reply "OddesE" <OddesE_XYZ hotmail.com> writes:
Content-Type: text/plain;
	charset="iso-8859-1"
Content-Transfer-Encoding: quoted-printable

  "anderson" <anderson firestar.com.au> wrote in message =
news:ah0pub$111p$1 digitaldaemon.com...
  Perhaps, there could be automatic hierarchical generation in some =
docgen like program. I think something along these lines was mentioned =
before (except it was compiler based). The hierarchical generator would =
simply scan all the D html files and built a code map, possibly using a =
UML derivative.  It would also generate a framed index file. So I still =
see a need for tags.=20

    The program could reformat these tags and automatically add things =
like see. This would provide a way to have automatically generated =
comments in the code itself not just the html. Now if someone is using a =
text editor for D, this could make things messy so the html (or xhtml) =
would have to be kept neat in a text form as well. There could also be =
special tags to indicate not to do certain things. =20

        /**
         * <author>Micky mouse</author>
         * <version>1.0</version>
         *
         *  The does blah blah blah blah blah blah blah blah blah blah =
blah blah=20
        *   blah blah blah blah blah blah blah blah blah blah blah blah =
blah blah=20
        *   blah blah blah blah blah=20
        **/
  void func(int a)
  {
  ...
  }

  Would change to
    void func(int a)
        Parameters

        a : Unknown
      =20



        The does blah blah blah blah blah blah blah blah blah blah blah =
blah blah blah blah blah blah blah blah blah blah blah blah blah blah =
blah blah blah blah blah blah=20

        Micky mouse

        See
               func2, func3
            =20


        =20

        V 1.0
      =20




        {

        ...
        }=20

  =20


  Anyway that's just an idea of a possible layout (athough it'll need =
alot more work).  The docGen should reconise both formats so that it can =
reconise what it has generated. Also classes could be done in a UML =
style by dividing the varaibles from the functions.

  "Robert M. M=FCnch" <robert.muench robertmuench.de> wrote in message =
news:ah0ggd$niq$1 digitaldaemon.com...
  > Source code documentation with coddocHi, thanks a lot. There is =
something
  > that comes to mind: D can compile HTML files! So it maybe best to =
include D
  > code into the documentation and not documentation into D code. My =
script
  > could easly be changed to produce a compileable output file. With =
this we
  > would be able to move more into the WEB idea of litteral =
programming. Code
  > is already recognized as mentioned. What do you think? Robert
  >=20
  >=20
  > "anderson" <anderson firestar.com.au> schrieb im Newsbeitrag
  > news:ah0fv5$m3f$1 digitaldaemon.com...
  > PS - Robert M. M=FCnch tool produces quite nice output, and I'd =
recommend it
  > for this "Code documentation attachement". Also it mite be an idea =
for the D
  > Journal if documents are to be produced to some standard (although =
it may
  > mean extra reformating work). It handles code segments especially =
well (by
  > picking up tabs).
  >=20
  >=20

Yes I definitely agree with this.
Putting the code in an .html file is a nice feature for demo programs=20
that get posted on web sites, but it doesn't work so well for pure=20
documentation. I don't know if the people that mentioned this have=20
tried javadoc or doxygen, but creating documentation from source code=20
and embedding source code in .html are just two completely different=20
things. I don't see myself typing all the .html to create fancy layout=20
like above when writing a .d program. Also Javadoc and Doxygen create=20
hierarchical structures of your classes, summary and index files,=20
links from one class to the others that are mentioned and to its=20
parents, etc, etc, etc. Am I supposed to do this all by hand?

Even if I was willing and capable of doing all this by hand, I could=20
never benefit from other people using it to and all formats would be=20
radically different.

Just search the web for Java documentation. Notice how it is all=20
uniform and looks alike? This is because all this documentation is=20
generated using Javadoc. The 'embed d code in a .html file' technique=20
is not an option for documentation generation.


--=20
Stijn
OddesE_XYZ hotmail.com
http://OddesE.cjb.net
_________________________________________________
Remove _XYZ from my address when replying by mail
Jul 16 2002
next sibling parent "anderson" <anderson firestar.com.au> writes:
Content-Type: text/plain;
	charset="iso-8859-1"
Content-Transfer-Encoding: quoted-printable

Sorry must have been a brake down in my comunication. I think javaDoc is =
cool. The code segment should be left out, parhaps an optional line =
number instead. In a D IDE it'd be good to have a switch that turns =
automatic html formating that could be toggled on and off that would do =
formating simular to the javaDoc (but with code segs).
  "OddesE" <OddesE_XYZ hotmail.com> wrote in message =
news:ah19po$1hh9$1 digitaldaemon.com...
    "anderson" <anderson firestar.com.au> wrote in message =
news:ah0pub$111p$1 digitaldaemon.com...
    Perhaps, there could be automatic hierarchical generation in some =
docgen like program. I think something along these lines was mentioned =
before (except it was compiler based). The hierarchical generator would =
simply scan all the D html files and built a code map, possibly using a =
UML derivative.  It would also generate a framed index file. So I still =
see a need for tags.=20

      The program could reformat these tags and automatically add things =
like see. This would provide a way to have automatically generated =
comments in the code itself not just the html. Now if someone is using a =
text editor for D, this could make things messy so the html (or xhtml) =
would have to be kept neat in a text form as well. There could also be =
special tags to indicate not to do certain things. =20

          /**
           * <author>Micky mouse</author>
           * <version>1.0</version>
           *
           *  The does blah blah blah blah blah blah blah blah blah blah =
blah blah=20
          *   blah blah blah blah blah blah blah blah blah blah blah =
blah blah blah=20
          *   blah blah blah blah blah=20
          **/
    void func(int a)
    {
    ...
    }

    Would change to
      void func(int a)
          Parameters

          a : Unknown
        =20



          The does blah blah blah blah blah blah blah blah blah blah =
blah blah blah blah blah blah blah blah blah blah blah blah blah blah =
blah blah blah blah blah blah blah=20

          Micky mouse

          See
                 func2, func3
              =20


          =20

          V 1.0
        =20




          {

          ...
          }=20

    =20


    Anyway that's just an idea of a possible layout (athough it'll need =
alot more work).  The docGen should reconise both formats so that it can =
reconise what it has generated. Also classes could be done in a UML =
style by dividing the varaibles from the functions.

    "Robert M. M=FCnch" <robert.muench robertmuench.de> wrote in message =
news:ah0ggd$niq$1 digitaldaemon.com...
    > Source code documentation with coddocHi, thanks a lot. There is =
something
    > that comes to mind: D can compile HTML files! So it maybe best to =
include D
    > code into the documentation and not documentation into D code. My =
script
    > could easly be changed to produce a compileable output file. With =
this we
    > would be able to move more into the WEB idea of litteral =
programming. Code
    > is already recognized as mentioned. What do you think? Robert
    >=20
    >=20
    > "anderson" <anderson firestar.com.au> schrieb im Newsbeitrag
    > news:ah0fv5$m3f$1 digitaldaemon.com...
    > PS - Robert M. M=FCnch tool produces quite nice output, and I'd =
recommend it
    > for this "Code documentation attachement". Also it mite be an idea =
for the D
    > Journal if documents are to be produced to some standard (although =
it may
    > mean extra reformating work). It handles code segments especially =
well (by
    > picking up tabs).
    >=20
    >=20

  Yes I definitely agree with this.
  Putting the code in an .html file is a nice feature for demo programs=20
  that get posted on web sites, but it doesn't work so well for pure=20
  documentation. I don't know if the people that mentioned this have=20
  tried javadoc or doxygen, but creating documentation from source code=20
  and embedding source code in .html are just two completely different=20
  things. I don't see myself typing all the .html to create fancy layout =

  like above when writing a .d program. Also Javadoc and Doxygen create=20
  hierarchical structures of your classes, summary and index files,=20
  links from one class to the others that are mentioned and to its=20
  parents, etc, etc, etc. Am I supposed to do this all by hand?

  Even if I was willing and capable of doing all this by hand, I could=20
  never benefit from other people using it to and all formats would be=20
  radically different.

  Just search the web for Java documentation. Notice how it is all=20
  uniform and looks alike? This is because all this documentation is=20
  generated using Javadoc. The 'embed d code in a .html file' technique=20
  is not an option for documentation generation.


  --=20
  Stijn
  OddesE_XYZ hotmail.com
  http://OddesE.cjb.net
  _________________________________________________
  Remove _XYZ from my address when replying by mail
Jul 16 2002
prev sibling next sibling parent reply "Robert M. Münch" <robert.muench robertmuench.de> writes:
"OddesE" <OddesE_XYZ hotmail.com> schrieb im Newsbeitrag
news:ah19po$1hh9$1 digitaldaemon.com....

tried javadoc or doxygen, but creating documentation from source code
and embedding source code in .html are just two completely different
things. I don't see myself typing all the .html to create fancy layout
like above when writing a .d program.

Hi, you don't have to that's what the generator will do for you.
Also Javadoc and Doxygen create
hierarchical structures of your classes, summary and index files,
links from one class to the others that are mentioned and to its
parents, etc, etc, etc. Am I supposed to do this all by hand?

No, but these are just some special sections/summaries/references the generator can include.
Just search the web for Java documentation. Notice how it is all
uniform and looks alike? This is because all this documentation is
generated using Javadoc. The 'embed d code in a .html file' technique
is not an option for documentation generation.

Well, the literate programming people will say something different. Here is a short example of how such a file could look like: ===Introduction Bla bla ---Colors Colors for syntax highlighting, default values are my preferences in Microsoft Visual Studio editor class Colors { static char[] keyword = "0000FF"; static char[] number = "008000"; static char[] string = "000080"; static char[] comment = "808080"; } etc. The indented code will be compileable by D the rest will be used to generate HTML output. That's easy! Adding all kinf of special source-code documentation features shouldn't be a problem. Robert
Jul 16 2002
parent reply "anderson" <anderson firestar.com.au> writes:
 Well, the literate programming people will say something different. Here

 a short example of how such a file could look like:

 ===Introduction
 Bla bla

 ---Colors
 Colors for syntax highlighting, default values are my preferences in
 Microsoft Visual Studio editor

     class Colors
     {
      static char[] keyword = "0000FF";
      static char[] number = "008000";
      static char[] string = "000080";
      static char[] comment = "808080";
     }

 etc.

 The indented code will be compileable by D the rest will be used to

 HTML output. That's easy! Adding all kinf of special source-code
 documentation features shouldn't be a problem. Robert

I know you've looked into Javadoc and Doxygen, but they also remove all the code body parts which your app doesn't do. In most documentation cases it is important to hide the body and only show the header stuff. This means that the hierarchical structures / summary and index files are the most important aspects of the doc generation program.
Jul 16 2002
parent reply "Robert M. Münch" <robert.muench robertmuench.de> writes:
"anderson" <anderson firestar.com.au> schrieb im Newsbeitrag
news:ah1mdt$1ugv$1 digitaldaemon.com...

 I know you've looked into Javadoc and Doxygen, but they also remove all

 code body parts which your app doesn't do.

Hi, my app doesn't do anything at the moment. I'm just thinking loud... It's no problem to just keep the header stuff. But sometimes it even makes sense to comment/explain your body. So both things should be supported very easy.
 In most documentation cases it is
 important to hide the body and only show the header stuff. This means that
 the hierarchical structures / summary and index files are the most

 aspects of the doc generation program.

As said, these are just summaries of all the information collected while generating the output. So there is no problem to generate all kind of summaries in different level of detail. The question I find most interesting is how can we write code comfortable and add documentation where it needs to be. What kind of syntax should be used, what features are needed, what's the best usage pattern... etc. Of course it's a question of style but I don't like hughe comment boxes and special comment characters sequences to indicate what I want the output to look like. Of couse markup is needed but it should be as userfriendly as possible. -- Robert M. Münch IT & Management Freelancer Mobile: +49 (0)177 2452 802 Fax : +49 (0)721 8408 9112 Web : http://www.robertmuench.de
Jul 16 2002
next sibling parent reply "Sean L. Palmer" <seanpalmer earthlink.net> writes:
I'd prefer the boxes to be done with HTML frames instead of ascii art.

Actual source code could go into <CODE> <D> for (int i=0; i<100; ++i) {
printf("D rocks!"); }</D> </CODE> blocks.  Which of course the editor
wouldn't show you.

Sean

"Robert M. Münch" <robert.muench robertmuench.de> wrote in message
news:ah345k$c5o$1 digitaldaemon.com...
 As said, these are just summaries of all the information collected while
 generating the output. So there is no problem to generate all kind of
 summaries in different level of detail. The question I find most

 is how can we write code comfortable and add documentation where it needs

 be. What kind of syntax should be used, what features are needed, what's

 best usage pattern... etc. Of course it's a question of style but I don't
 like hughe comment boxes and special comment characters sequences to
 indicate what I want the output to look like. Of couse markup is needed

 it should be as userfriendly as possible.

Jul 17 2002
parent reply "anderson" <anderson firestar.com.au> writes:
Yes interesting point.

You could write a book on D IDE's before they even come out. More then most
languages I think that D would greatly from having it's own IDE. D code
would become much neater on the web then other code more efficiently
produced. I wouldn't be surprised if the D IDE had "an upload to web button"
included (just kidding).  I suppose D could probably go a lot further
(without abandoning the humble text editor) in supporting the IDE of the
future, but I can't think of it how.

At the moment were stuck with 1990 style IDE's, with a language that was
made for much classier IDE's. Most languages were born in the days of text
editors, so they never though about support for IDE's. Instead the IDE's
supported them.  Newer languages such as VB, Java and C# do have a lot of
support IDE's. Those language (with exception of Java) I wouldn't dare
attempt without the supporting IDE. D supports the best of both worlds
although there's no real GUI object language (like VB and C# support) for it
which is a downer. Besides D is in it's alpha stage so a GUI object language
is long off I suppose.

"Sean L. Palmer" <seanpalmer earthlink.net> wrote in message
news:ah371f$h3i$1 digitaldaemon.com...
 I'd prefer the boxes to be done with HTML frames instead of ascii art.

 Actual source code could go into <CODE> <D> for (int i=0; i<100; ++i) {
 printf("D rocks!"); }</D> </CODE> blocks.  Which of course the editor
 wouldn't show you.

 Sean

Jul 17 2002
parent "Walter" <walter digitalmars.com> writes:
"anderson" <anderson firestar.com.au> wrote in message
news:ah5a2g$2rcv$1 digitaldaemon.com...
 Yes interesting point.

 You could write a book on D IDE's before they even come out. More then

 languages I think that D would greatly from having it's own IDE. D code
 would become much neater on the web then other code more efficiently
 produced. I wouldn't be surprised if the D IDE had "an upload to web

 included (just kidding).  I suppose D could probably go a lot further
 (without abandoning the humble text editor) in supporting the IDE of the
 future, but I can't think of it how.

I have some familiarity with syntax directed editors, and how it is impossible to get right for C and C++ without writing a nearly complete compiler front end. In D, since the tokens and syntax is completely independent of semantic analysis, it becomes easy to write syntax aware editors.
Aug 13 2002
prev sibling parent Juarez Rudsatz <juarez nowhere.com> writes:
Hi all,

    	I have thinked in tag like "glossary" and "category" for generating 
indexes of hierarquical structures following different subjects.
    	It's possible generate indexes for each type of statement, classes, 
modules, functions, contants.
    	This appear to be sufficient IMHO. What do you think?

"Robert M. Münch" <robert.muench robertmuench.de> wrote in
news:ah345k$c5o$1 digitaldaemon.com: 

 "anderson" <anderson firestar.com.au> schrieb im Newsbeitrag
 news:ah1mdt$1ugv$1 digitaldaemon.com...
 
 I know you've looked into Javadoc and Doxygen, but they also remove
 all 

 code body parts which your app doesn't do.

Hi, my app doesn't do anything at the moment. I'm just thinking loud... It's no problem to just keep the header stuff. But sometimes it even makes sense to comment/explain your body. So both things should be supported very easy.
 In most documentation cases it is
 important to hide the body and only show the header stuff. This means
 that the hierarchical structures / summary and index files are the
 most 

 aspects of the doc generation program.

As said, these are just summaries of all the information collected while generating the output. So there is no problem to generate all kind of summaries in different level of detail. The question I find most interesting is how can we write code comfortable and add documentation where it needs to be. What kind of syntax should be used, what features are needed, what's the best usage pattern... etc. Of course it's a question of style but I don't like hughe comment boxes and special comment characters sequences to indicate what I want the output to look like. Of couse markup is needed but it should be as userfriendly as possible. -- Robert M. Münch

Jul 17 2002
prev sibling parent reply "Sean L. Palmer" <seanpalmer earthlink.net> writes:
Content-Type: text/plain;
	charset="iso-8859-1"
Content-Transfer-Encoding: quoted-printable

Using a text editor as your main programming environment is dead.  Let's =
move on.

Sean
  Yes I definitely agree with this.
  Putting the code in an .html file is a nice feature for demo programs=20
  that get posted on web sites, but it doesn't work so well for pure=20
  documentation. I don't know if the people that mentioned this have=20
  tried javadoc or doxygen, but creating documentation from source code=20
  and embedding source code in .html are just two completely different=20
  things. I don't see myself typing all the .html to create fancy layout =

  like above when writing a .d program. Also Javadoc and Doxygen create=20
  hierarchical structures of your classes, summary and index files,=20
  links from one class to the others that are mentioned and to its=20
  parents, etc, etc, etc. Am I supposed to do this all by hand?

  Even if I was willing and capable of doing all this by hand, I could=20
  never benefit from other people using it to and all formats would be=20
  radically different.

  Just search the web for Java documentation. Notice how it is all=20
  uniform and looks alike? This is because all this documentation is=20
  generated using Javadoc. The 'embed d code in a .html file' technique=20
  is not an option for documentation generation.


  --=20
  Stijn
  OddesE_XYZ hotmail.com
  http://OddesE.cjb.net
Jul 16 2002
parent reply Jason Mills <jmills cs.mun.ca> writes:
Sean L. Palmer wrote:
 Using a text editor as your main programming environment is dead.  Let's 
 move on.

I disagree. I do most of my programming using a text editor (vim/gvim) and the command line, so I'm not sure what you mean by the above statement. Given that I have not been following this thread closely, I may have misinterpreted you. Jason
 Sean
 
     Yes I definitely agree with this.
     Putting the code in an .html file is a nice feature for demo programs
     that get posted on web sites, but it doesn't work so well for pure
     documentation. I don't know if the people that mentioned this have
     tried javadoc or doxygen, but creating documentation from source code
     and embedding source code in .html are just two completely different
     things. I don't see myself typing all the .html to create fancy layout
     like above when writing a .d program. Also Javadoc and Doxygen create
     hierarchical structures of your classes, summary and index files,
     links from one class to the others that are mentioned and to its
     parents, etc, etc, etc. Am I supposed to do this all by hand?
      
     Even if I was willing and capable of doing all this by hand, I could
     never benefit from other people using it to and all formats would be
     radically different.
      
     Just search the web for Java documentation. Notice how it is all
     uniform and looks alike? This is because all this documentation is
     generated using Javadoc. The 'embed d code in a .html file' technique
     is not an option for documentation generation.
      
 
     -- 
     Stijn
     OddesE_XYZ hotmail.com <mailto:OddesE_XYZ hotmail.com>
     http://OddesE.cjb.net
 

Jul 16 2002
parent reply "Sean L. Palmer" <seanpalmer earthlink.net> writes:
There exist technological advancements that allow you to browse and edit
code easily, configure how you want the code to be displayed (important on
large teams where everyone has their own style preferences and you can't get
a team to agree on indentation and spacing issues,) and integrate debugging,
source control, creating whatever makefile or linker script you need, and
many other tools such as bitmap and dialog editors.  You may not need all of
this, but I kinda like it.

I guess to each his own, I'm not stopping you from living in the stone age,
but there are electric lights and running water nowadays.  ;)   That said,
I've seen some pretty sophisticated text editors and I expect they'll keep
becoming stronger as well, to the point where they may just become IDE's, or
a tool for integrating tools.

Just like ASCII is giving way to UNICODE, plain text is quickly becoming
obsolete.  With the profusion of HTML, XML, and other editors, surely one
format will be nice enough for everyone to standardize on.  I sure would
like the ability to put foreign characters and wierd math symbols into my
source code.  But ASCII/ANSI have very little in the way of choices.  I
would like to see a mathematical expression editor that translates during
save to D code with overloaded operators.  ;)

Sean


"Jason Mills" <jmills cs.mun.ca> wrote in message
news:3D348934.9030609 cs.mun.ca...
 Sean L. Palmer wrote:
 Using a text editor as your main programming environment is dead.  Let's
 move on.

I disagree. I do most of my programming using a text editor (vim/gvim) and the command line, so I'm not sure what you mean by the above statement. Given that I have not been following this thread closely, I may have misinterpreted you. Jason
 Sean

     Yes I definitely agree with this.
     Putting the code in an .html file is a nice feature for demo


     that get posted on web sites, but it doesn't work so well for pure
     documentation. I don't know if the people that mentioned this have
     tried javadoc or doxygen, but creating documentation from source


     and embedding source code in .html are just two completely different
     things. I don't see myself typing all the .html to create fancy


     like above when writing a .d program. Also Javadoc and Doxygen


     hierarchical structures of your classes, summary and index files,
     links from one class to the others that are mentioned and to its
     parents, etc, etc, etc. Am I supposed to do this all by hand?

     Even if I was willing and capable of doing all this by hand, I could
     never benefit from other people using it to and all formats would be
     radically different.

     Just search the web for Java documentation. Notice how it is all
     uniform and looks alike? This is because all this documentation is
     generated using Javadoc. The 'embed d code in a .html file'


     is not an option for documentation generation.


     --
     Stijn
     OddesE_XYZ hotmail.com <mailto:OddesE_XYZ hotmail.com>
     http://OddesE.cjb.net


Jul 17 2002
parent reply Jason Mills <jmills cs.mun.ca> writes:
 There exist technological advancements that allow you to browse and
 edit code easily,

Any reasonable text editor with script capabilities can do this.
 configure how you want the code to be displayed (important on large
 teams where everyone has their own style preferences and you can't get
 a team to agree on indentation and spacing issues,)

Any reasonable text editor can do this as well, and much easier and with much more configuration options in most cases.
 and integrate debugging, source control, creating whatever makefile or
 linker script you need, and

I admit, these are not so easily done in a text editor, but doable just the same.
 many other tools such as bitmap and dialog editors.  You may not need
 all of this, but I kinda like it.

Yes, I agree bitmap and dialog editors are useful. However, in some decent GUI toolkits, dialog editors are not really necessary, especially if the toolkit dynamically lays out you dialog controls for you. Consider Java.
 I guess to each his own, I'm not stopping you from living in the stone
 age, but there are electric lights and running water nowadays.  ;)

I guess me and some well respected people in the software industry like living in the stone age ;) (e.g. see Allen Holub's editorial, Java Solutions, a supplement to C/C++ Users Journal). I have read many articles of those who have replaced their sophisticated IDE's and CASE tools, which suppose to increase productivity, with good programming text editors (e.g. gvim, emacs, etc.). Most programming is done in a text editor, so why does so many that come with IDEs stink? I use Visual C++ at work sometimes, but I find myself using gvim as my primary text editor for that reason. In addition I can use the same text editor, configured the way I like, for any programming language I happen to be coding in at the moment, including D, while others using IDE's often have to learn a new editor for each different IDE. In effect, the programming never really becomes proficient with any editor.
 That said, I've seen some pretty sophisticated text editors and I
 expect they'll keep becoming stronger as well, to the point where they
 may just become IDE's, or a tool for integrating tools.

Yes, and they behave the way you want them to behave.
 Just like ASCII is giving way to UNICODE, plain text is quickly
 becoming obsolete.  With the profusion of HTML, XML, and other
 editors, surely one format will be nice enough for everyone to
 standardize on.

But what is HTML and XML if it's not plain text? So is plain text really becoming obsolete? You can argue the opposite. E.g. instead of saving data as binary files, much data is now being saved as XML (plain text).
 I sure would like the ability to put foreign characters and wierd math
 symbols into my source code.  But ASCII/ANSI have very little in the
 way of choices.  I would like to see a mathematical expression editor
 that translates during save to D code with overloaded operators.  ;)

My main reason for staring this discussion is: when making decisions about D, don't forget the stone age folks like me who may have an interest in D ... there may be more of us than you think ;) Jason
Jul 17 2002
parent "anderson" <anderson firestar.com.au> writes:
"Jason Mills" <jmills cs.mun.ca> wrote in message
news:3D355879.2060807 cs.mun.ca...

 In addition I can
 use the same text editor, configured the way I like, for any programming
 language I happen to be coding in at the moment, including D, while
 others using IDE's often have to learn a new editor for each different
 IDE.

 Jason

I note that you said "often", but there are many multi-language IDE's out there including "PC-grasp", "epsilon", "Scintilla" and also all those built in ones that came with UNIX (which I forget). It's a matter of preference if you use an IDE or not. IDE's simplify a lot of common tasks such as compilation. Having to write/modify a make file everytime you write program is just another task you add to add to do. Alternatively having to workout how to make a multi-language IDE D proficient is another big task also (Although it only needs to be done once). Most IDE's use interface standards which makes switchingfrom one IDE to another easier. The only real problems faced is learning how to set things up and how to use the language specific tool (which you probably don't need anyway).
Jul 17 2002
prev sibling next sibling parent "anderson" <anderson firestar.com.au> writes:
Content-Type: text/plain;
	charset="iso-8859-1"
Content-Transfer-Encoding: quoted-printable

Perhaps, there could be automatic hierarchical generation in some docgen =
like program. I think something along these lines was mentioned before =
(except it was compiler based). The hierarchical generator would simply =
scan all the D html files and built a code map, possibly using a UML =
derivative.  It would also generate a framed index file. So I still see =
a need for tags.=20

  The program could reformat these tags and automatically add things =
like see. This would provide a way to have automatically generated =
comments in the code itself not just the html. Now if someone is using a =
text editor for D, this could make things messy so the html (or xhtml) =
would have to be kept neat in a text form as well. There could also be =
special tags to indicate not to do certain things.=20

      /**
       * <author>Micky mouse</author>
       * <version>1.0</version>
       *
       *  The does blah blah blah blah blah blah blah blah blah blah =
blah blah=20
      *   blah blah blah blah blah blah blah blah blah blah blah blah =
blah blah=20
      *   blah blah blah blah blah=20
      **/
void func(int a)
{
...
}

Would change to
  void func(int a)
      Parameters

      a : Unknown
    =20



      The does blah blah blah blah blah blah blah blah blah blah blah =
blah blah blah blah blah blah blah blah blah blah blah blah blah blah =
blah blah blah blah blah blah=20

      Micky mouse

      See
             func2, func3
          =20




      V 1.0
    =20


      =20

      {

      ...
      }=20

=20


Anyway that's just an idea of a possible layout (athough it'll need alot =
more work).  The docGen should reconise both formats so that it can =
reconise what it has generated. Also classes could be done in a UML =
style by dividing the varaibles from the functions.

"Robert M. M=FCnch" <robert.muench robertmuench.de> wrote in message =
news:ah0ggd$niq$1 digitaldaemon.com...
 Source code documentation with coddocHi, thanks a lot. There is =

 that comes to mind: D can compile HTML files! So it maybe best to =

 code into the documentation and not documentation into D code. My =

 could easly be changed to produce a compileable output file. With this =

 would be able to move more into the WEB idea of litteral programming. =

 is already recognized as mentioned. What do you think? Robert
=20
=20
 "anderson" <anderson firestar.com.au> schrieb im Newsbeitrag
 news:ah0fv5$m3f$1 digitaldaemon.com...
 PS - Robert M. M=FCnch tool produces quite nice output, and I'd =

 for this "Code documentation attachement". Also it mite be an idea for =

 Journal if documents are to be produced to some standard (although it =

 mean extra reformating work). It handles code segments especially well =

 picking up tabs).
=20
=20

Jul 16 2002
prev sibling parent reply Karl Bochert <kbochert ix.netcom.com> writes:
On Tue, 16 Jul 2002 09:08:15 +0200, "Robert M. Münch"
<robert.muench robertmuench.de> wrote:
 Source code documentation with coddocHi, thanks a lot. There is something
 that comes to mind: D can compile HTML files! So it maybe best to include D
 code into the documentation and not documentation into D code. My script
 could easly be changed to produce a compileable output file. With this we
 would be able to move more into the WEB idea of litteral programming. Code
 is already recognized as mentioned. What do you think? Robert
 
 

Hmm.. Maybe it's time we thought in terms of coding our documentation rather than documenting our code.
Jul 16 2002
parent reply "Walter" <walter digitalmars.com> writes:
"Karl Bochert" <kbochert ix.netcom.com> wrote in message
news:1103_1026833775 bose...
 Hmm.. Maybe it's time we thought in terms of coding our documentation
 rather than documenting our code.

In D, you code the contracts!
Aug 13 2002
parent reply andy <acoliver apache.org> writes:
Walter wrote:
 "Karl Bochert" <kbochert ix.netcom.com> wrote in message
 news:1103_1026833775 bose...
 
Hmm.. Maybe it's time we thought in terms of coding our documentation
rather than documenting our code.

In D, you code the contracts!

Poor developers will always find a way to rationalize not writing documentation.
Aug 14 2002
next sibling parent Pavel Minayev <evilone omen.ru> writes:
On Wed, 14 Aug 2002 08:03:38 -0400 andy <acoliver apache.org> wrote:

 In D, you code the contracts!

Poor developers will always find a way to rationalize not writing documentation.

Contracts ARE docs.
Aug 14 2002
prev sibling parent reply "Sean L. Palmer" <seanpalmer earthlink.net> writes:
Think of me what you will, but a given programming team has to have a
certain standard of skill for all members.  That usually at least means that
they are able to read existing code and figure out what it does.  Commenting
the obvious does not make anyone more productive.  Where you really need
comments are places where the code is doing more than is apparent at first
perusal.  Comment the code that is hard to read, not the code that is
self-explanatory to anyone with a "D for Dummies" book.

To me, standardized comment blocks look pretty, but are universally poorly
maintained and usually give you mostly redundant information.

I like putting documentation directly into the code itself whenever
possible... DBC contracts and asserts in D take that one step further.
Unlike a comment, a contract can be enforced by the compiler.  And actual
working code, once you know how to read it, never gets out of sync with
itself, as comments are wont to do.

Sean

"andy" <acoliver apache.org> wrote in message
news:3D5A471A.7040607 apache.org...
 Walter wrote:
 "Karl Bochert" <kbochert ix.netcom.com> wrote in message
 news:1103_1026833775 bose...

Hmm.. Maybe it's time we thought in terms of coding our documentation
rather than documenting our code.

In D, you code the contracts!

Poor developers will always find a way to rationalize not writing documentation.

Aug 15 2002
parent "Walter" <walter digitalmars.com> writes:
"Sean L. Palmer" <seanpalmer earthlink.net> wrote in message
news:ajflbd$j95$1 digitaldaemon.com...
 To me, standardized comment blocks look pretty, but are universally poorly
 maintained and usually give you mostly redundant information.

That's been my experience, too.
 I like putting documentation directly into the code itself whenever
 possible... DBC contracts and asserts in D take that one step further.
 Unlike a comment, a contract can be enforced by the compiler.  And actual
 working code, once you know how to read it, never gets out of sync with
 itself, as comments are wont to do.

The neat thing about contracts is that they can't get out of sync with the code, even if poorly written. Contracts are a major productivity enhancer completely missed by C++, C#, and Java.
Aug 15 2002
prev sibling next sibling parent reply "anderson" <anderson firestar.com.au> writes:
Content-Type: text/plain;
	charset="iso-8859-1"
Content-Transfer-Encoding: quoted-printable

Source code documentation with coddocHow about a "requires" tag. =
Requirements could be auto generated but the doc program, but sometimes =
users may wish to add more details. I find it useful to quickly findout =
what is needed for a class without having to read through the sentenced =
documentation.

requires: STL, opengl.d
Jul 16 2002
parent reply Juarez Rudsatz <juarez nowhere.com> writes:
"anderson" <anderson firestar.com.au> wrote in
news:ah2u5e$5or$1 digitaldaemon.com: 

 Source code documentation with coddocHow about a "requires" tag.
 Requirements could be auto generated but the doc program, but
 sometimes users may wish to add more details. I find it useful to
 quickly findout what is needed for a class without having to read
 through the sentenced documentation. 
 
 requires: STL, opengl.d
 

How this differs from having code in "import" statement ?
Jul 17 2002
parent "anderson" <anderson firestar.com.au> writes:
"Juarez Rudsatz" <juarez nowhere.com> wrote in message
news:Xns924E82C49F90juarezcorreiocom 63.105.9.61...
 "anderson" <anderson firestar.com.au> wrote in
 news:ah2u5e$5or$1 digitaldaemon.com:

 Source code documentation with coddocHow about a "requires" tag.
 Requirements could be auto generated but the doc program, but
 sometimes users may wish to add more details. I find it useful to
 quickly findout what is needed for a class without having to read
 through the sentenced documentation.

 requires: STL, opengl.d

How this differs from having code in "import" statement ?

Sorry I was tring to indicate that the program should pick up things in the import statement, but if they were entered by the user the the program would add them if they didn't exist (the user may be planning to add it later). Here's a more valid example, requires: A fast 3d card, opengl multi-texturing extention, Index.dba, texture.bmp These are things that can't be picked up by the doc generator but should be added in the same area include ones are does. Note that this should also be avaliable per-function as well.
Jul 17 2002
prev sibling next sibling parent reply Juarez Rudsatz <juarez nowhere.com> writes:
Hi all!

    	I am sending the second version of this especification.
    	Is not concluded yet. 
    	Let's comment, criticize, speculate, think, talk ....

Juarez Rudsatz

Juarez Rudsatz <juarez correio.com> wrote in
news:Xns9249C9E0B98EEjuarezcom 63.105.9.61: 

 Hi all!
 
          I am sending a very preliminary version of a specification
          for 
 implementing a sintax for document source files using the /* */
 comments. 
          It's a preliminary version and contain, certainly, design and
 language errors.
          Please read the attached html file and send your comments.
 

Aug 21 2002
next sibling parent "anderson" <anderson firestar.com.au> writes:
Source code documentation with coddocTag copyrigth ??? Spelling

"Juarez Rudsatz" <juarez nowhere.com> wrote in message
news:Xns9271CD52FD128juarezcorreiocom 63.105.9.61...
Hi all!

    I am sending the second version of this especification.
    Is not concluded yet.
    Let's comment, criticize, speculate, think, talk ....

Juarez Rudsatz

Juarez Rudsatz <juarez correio.com> wrote in
news:Xns9249C9E0B98EEjuarezcom 63.105.9.61:

 Hi all!

          I am sending a very preliminary version of a specification
          for
 implementing a sintax for document source files using the /* */
 comments.
          It's a preliminary version and contain, certainly, design and
 language errors.
          Please read the attached html file and send your comments.

Abstract A documentation model describes the format comments in the source code of a program must adhere to to be extractable by a documentation tool, which can then use the extracted information to create browsable or printable documentation, for instance in an html, pdf or word document format. This document is created with the purpose of specifying a clear and easy documentation model for the programming language D. Introduction Documentation comments are a method of reducing work by moving documentation from a separate document into the code itself in a way the documentation document could easily be generated. As every programmer knows, documentation tends to be incomplete, out of date, wrong, or non-existent. Moving the documentation into the code makes it easy to maintain with the program or library Tools for generating documentation of API's are commom today. They provide a simple method for programming and documenting at the same time. The documentation remains close to the source code for the API programmer, and for the application programmer will be in a more readable and easy to search format. They decrease the work of creating and maintaining documentation compared to writing it in a separate word processor. Most documentation generators will even be able to generate decent documentation from source code with no documentation comments in it at all, just from parsing the code itself. Adding good structured comments to the source code can greatly improve the value of the generated documentation however. How source code is documented Each feature of source code is composed by a set of language structures. For each structure is attached a comment providing a description of it functionality, a explaination of a component or classifying its atributes. See some examples below : A function being documented: /** * This function is a simple example **/ int function(int x) { return x; } A class being documented /** * author: Wolfrang Amadeus Mozart <wam music.org> * * This class plays a sinfonie of Mozart. It can be used for learning music * or for learning D documentation **/ class sinfonie{ ... } How tags are parsed Documented comments use a variation of the standart documentation for D. They starts with the string '/**´ and finish with the string '**´: /** This is a documented comment **/ typedef int normalvalue; Alternatively a single line format can be used with the string '//*´: //* This is a documented comment typedef int normalvalue; To place a single line comment behind the source line, as is common, use '//<´: typedef int normalvalue; //< This is a documented comment The documentation can span several lines. The extra blanks, tabulation and new lines are stripped, just as with html: /** This comment will have many lines as needed **/ If the documentation should be divided into more than one paragraph, you can add a blank line where you want to start a new paragraph: /** This is a paragraph And this is another **/ To allow the comment style often used by programmers where every line in the comment block starts with an asterisk (*) aligned with the first asterisk in the start comment tag, the first asterisk of the comment lines are stripped if every comment line starts with an asterisk as the first non-whitespace character: /** * This comment will have * many lines * as needed. * * And this is the second paragraph. **/ Aditional repeated chars at begin or at end are omited: /*********************************** * The repeated chars are omited ***********************************/ The comment can have also a "tag" which specifies the documentation of an specific atribute: /** * author: William Shakespeare <william literature.net> **/ module literature; The former tag specifies the author of the module. You can combine sereral tags and text in the comment: /** * author: William Shakespeare <william literature.net> * version: 1.0 * * This module implements the logic for understanding the real interpretation of my ideas. * It magically translate all ideas hidden from the simple reading and show to you. **/ module literature; Types of Tags The tags can be of two types : Taglines are tags described in one line. The tag end at the newline caracter. As example there are the version, since, category and glossary tags. Tag paragraphs are tages described in one or more lines. The tag end is at the next tag or the end of comment. Position of Tags Tags may be put before any declaration: /** * author: William Shakespeare <william literature.net> on 2002.03.04 05:06 * author: Wolfrang Amadeus Mozart <wam music.org> on 2002.04.06 08:16 * version: 0.3 alpha * category: Example of Code Documentation * see: anotherexample, example, "D Programming Tutorial" * * This module is provided as example of documenting code with coddoc. It is * a example of how use the coments for generating documentation. **/ module docexample; It is also allowed to place documentation comments after the declaration using the special start tag ´//<´. These comments may only span one line however. Both forms may be mixed freely. This is an example of a struct with documentation comments: struct SDL_Color { Uint8 r; //< The byte representing the red value for color Uint8 g; //< The byte representing the green value for color Uint8 b; //< The byte representing the blue value for color Uint8 unused; //< This byte is reserved for future use } Especific tags Tag author The following are examples of author taglines, which may be used in documentation comments for module and types declarations: /** * author: William Shakespeare<william literature.net> * author: Dante Aglieri * author: Jules Verne **/ module literature; Tag copyrigth The copyright tag may be used to describe the copyright holder information for the module, class or method /** * copyright: Pavel "EvilOne" Minayev (c) 2001-2002 * * This module provides a class library for windows programming. * It contains controls necessary for creating windowed applications * such as edit controls, list controls, menus, status bars and * many other controls. It is also possible to derive your own * custom controls. **/ module wind; Tag license The following is an example of a license paragraph, which may be used in documentation comments for module declarations: /** * license: * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Author makes no representations about * the suitability of this software for any purpose. It is provided * "as is" without express or implied warranty. **/ The license paragraph should contain all information applicable to licensing terms and permission of use. Tag version The following is an example of a version tagline, which may be used in documentation comments for type declarations: /** * version: 2.93.1 beta **/ module imported; Tag since Specify in what version when the name was added to the API specification (if different from the implementation). It could be used in type in reference to module version or in method in reference to class version. The following is an example of a since paragraph, which may be used in documentation comments for declarations of methods: /** * version: 0.3 alpha * * This class is on the third version **/ class widgetfarm : farm { /** * since: 0.2 * * This method is introduced in version 0.2 of this class **/ void initwidgets { ... } } Tag see The following are examples of see paragraphs, which may be used in any documentation comment to indicate a cross-reference to a type, method, constructor, field, URL, or any text: /** * see: c.stdio * see: string * see: string.equals * see: threads.thread.wait(int) * see: RandomAccessFile.RandomAccessFile(File) * see: RandomAccessFile.RandomAccessFile(File, String) * see: Character.MAX_RADIX * see: "D Language Specification" at http://www.digitalmars.com/d/spec.html * see: "D Programming Tutorial" **/ class implementation; The character "." separates the name of a module of a class and the name of a class from the name of one of its fields, methods, or constructors. The order of searching is package, module, type, method. One of several overloaded methods or constructors may be selected by including a parenthesized list of argument types after the method or constructor name. Tag category The category tagline specify in what category the type or method is gruped. It could be used in classes to classify the properties, methods and members in a closed scope. The following is an example of a category paragraph, which may be used in documentation comments for declarations of a functions: /** * category: Temperature handling routines **/ int temperature { ... } Tag example Adds a example copied verbatim to documentation. The following is an example of a example paragraph, which may be used in documentation comments for providing user examples: /** * example: * * // This ilustrate how to use a regexp to match a string * RegExp myRegExp = new RegExp("[A-Za-z\b!]*"); * if (RegExp.Match("Hello World!") * printf("Hello World!"); **/ class RegExp { ... } The formatting in the documentation remains exactly the same as it is in the source code. No whitespace is removed. A non-proportional font, such as courier is used for the examples, so simple ASCII drawings will survive the translation intact. Tag bug Specify known issue in types, methods or routines. The following is an example of a bug paragraph, which may be used in documentation comments for declarations of a functions: /** * bug: Severity High. Windows 9x dont pass the correct memory used **/ int memoryUsed { ... } Tag todo Specify work to be done, such as implementing, optimizing or or documenting certain types and methods. The following is an example of a todo paragraph, which may be used in documentation comments for declarations of a class: /** * version: 1.0 * todo: modify to permit evaluate a string caracter by caracter **/ class RegExp { ... } Tag glossary Specify a text to build a glossary by subject. The glossary tag is a tagline but a documentation comment may contain more than one glossary tag. The following is an example of a todo tagline, which may be used in documentation comments for declarations of a function: /** * glossary: Deleting files * glossary: Erasing files **/ void delelefile(string filename){ ... } Tag summary The following is an example of an summary tagline, which may be used for short describing a artifact: /** * summary: InterfaceDisconnect disconnects an IConnectionPoint interface. * * InterfaceDisconnect disconnects an IConnectionPoint interface connection * that was previously made by the InterfaceConnect procedure. * These procedures are wrappers for the ActiveX event-handling mechanism, * the IConnectionPointContainer and IConnectionPoint interfaces. **/ void InterfaceDisconnect(IUnknown Source, ClassIID IID); Generic tags Tags for parameters The following are examples of parameters paragraphs, which may be used in documentation comments for method and constructor declarations: /** * file: the file to be searched * pattern: the pattern to be matched during the search. The pattern could * consist of a simple string or a regular expression. * count: the max number of lines to brings for each match. O for all lines; * * Matches lines in a file which follow a pattern. **/ char[] matchLines(File file, char[] pattern, int count); The information in a parameter paragraph should consist of the name of the parameter followed by a short description. A documentation comment may contain more than one parameter tag. The usual convention is that if any parameter paragraphs are present in a documentation comment, then there should be one parameter paragraph for each parameter of the method or constructor, and the parameters paragraphs should appear in the order in which the parameters are declared but this is not mandatory. Tags for imports The following is an example of an import paragraph, which may be used in documentation comments for modules imports: /** * Auxiliary routines **/ import mymodule; The information in an import paragraph should consist of the name of an module (which may be a simple name or a qualified name) followed by a short description of the need or dependency reason. Additionaly, modules can be documented together simply by specifying the name of module contained in the colon list. /** * mymodule: Auxiliary rotines * c.stdio: needed for printf function * stream: needed for reading and writing to files **/ import mymodule, c.stdio, stream; Tags for exceptions The following is an example of an exception paragraph, which may be used in documentation comments for method and constructor declarations: void verifyWidget(Widget widget) { if (!widget.flanged) //* the widget does not have a flange, or its flange has size zero throw new UnflangedWidgetError(´Missing flange´); if (!widget.canUse) /** * the widget cannot be used. This happens because it was not * initialized, it was not attached to a manager, it was not * configured or it is hided. **/ throw new UnusableWidgetError(); if (widget.InUse) throw new LockWidgetError("Widget is already in use"); //< the widget is already used } The comment in an exception paragraph is attached with the method which the error is throwed. For documenting the exception use a normal tag once a exception is a class. The information in an exception paragraph should consist by a short description of the circumstances that cause the exception to be thrown. Tags for return values The following is an example of an return paragraph, which may be used in documentation comments for method and functions declarations: byte cmpString(char[] str1, char[] str2) { if (str1 < str2) /** if the first string is smaller than second. * return a positive number */ return 1; if (str1 == str2) //* if strings are equal return zero return = 0; if (str1 == str2) /** if the first string is greater than second. //* return a negative number return = -1; } Tags for Attributes Not all Attributes statements can be documented. There are no meaning in include documentation for the following tags: private protected public export Nevertheless the tool implementing documentation comments could include automatically the information and show or hide following user command. The following attributes can be commented: deprecated override abstract const final static /** * As of D 2.0, replaced by stream handling methods * see: stream **/ deprecated { char[] read(File f) { ... } int write(File f, char[] buffer) { .. } } Tags for Contracts Contracts are a breakthrough technique to reduce the programming effort for large projects. Contracts are the concept of preconditions, postconditions, errors, and invariants. Contracts form part of the specification for a program, moving it from the documentation to the code itself. The comment in an assert contract is attached with the method which the contract is verified. For documenting the contract use a normal tag explaining the reason os such restriction. Assert contract without a documentation comment is not added in the documentation. Not all contracts can be documented. Following tags are not documented: out contracts in methods unittest contracts There are no meaning in include documentation for these contracts because they are commonly used for verification of accuracy of results and for determining if the code is working properly. The following contracts can be commented: in contracts in methods class invariants In Contracts The following is an example of documentation of an assert contract in a function in contract: int div(int x , int y) in { //* The divisor cannot be zero. assert(y != 0); } body { return x / y; } Class Invariants The following is an example of documentation of an assert contract in a class invariant: class Date { int day; int hour; invariant() { //* The day must be between 1 and 31 assert(1 <= day && day <= 31); //* The hour must be between 0 and 23 assert(0 <= hour && hour < 24); } Tags and versioning Tags will be included in documentation following the versioning scheme. Tags and inheritance Inherited classes and structs will inherit tags for all methods defined in ancestral which are not modified by an new documentation comment. Compilaton process The compiler will parse each file and generate a new file containing the comments stripped from source and all information about the feature being documented. The format of all files generated is the docboock format. Each source file generates one new file containing a section in a docbook book. The document must be also a valid XML 1.0 document. Users could use a docbook processor for generate documentation in html format, text format, pdf format or any available format. Users can also write their own preprocessor since the output of code documentation will be a simple xml document. Sugested comments for statements Tags in simple types Tags in simple procedures Tags in functions Tags in structures Tags in classes Best practices A Style Guide The following are useful tips and conventions for writing descriptions in doc comments. When specifying data use formal and standard notation When specifying data such as dates and times use accepted standards such as ISO. This way foreign readers will not be confused by month, day positions. module greataddon; //< should be ready 2002.12.31 00:00:00. Omit parentheses for the general form of methods and constructors When referring to a method or constructor that has multiple forms, and you mean to refer to a specific form, use parentheses and argument types. For example, ArrayList has two add methods: add(Object) and add(int, Object). The add(int, Object) method adds an item at a specified position in this arraylist. However, if referring to both forms of the method, omit the parentheses altogether. It is misleading to include empty parentheses, because that would imply a particular form of the method. The intent here is to distinguish the general method from any of its particular forms. Include the word "method" to distinguish it as a method and not a field. The add method enables you to insert items. (preferred) The add() method enables you to insert items. (avoid when you mean "all forms" of the add method) Okay to use phrases instead of complete sentences In the interests of brevity this could be used. This holds especially in the initial summary and in parameter tag descriptions. Use 3rd person (descriptive) not 2nd person (prescriptive). The description is in 3rd person declarative rather than 2nd person imperative. Gets the label. (preferred) Get the label. (avoid) Method descriptions begin with a verb phrase. A method implements an operation, so it usually starts with a verb phrase. Gets the label of this button. (preferred) This method gets the label of this button. (avoid) Class/interface/field descriptions can omit the subject. they can simply state the object. These API often describe things rather than actions or behaviors: A button label. (preferred) This field is a button label. (avoid) Use "this" instead of "the" When referring to an object created from the current class is preferred use a more specific word. For example, the description of the getToolkit method should read as follows: Gets the toolkit for this component. (preferred) Gets the toolkit for the component. (avoid) Add description beyond the API name. The best API names are "self-documenting", meaning they tell you basically what the API does. If the doc comment merely repeats the API name in sentence form, it is not providing more information. For example, if method description uses only the words that appear in the method name, then it is adding nothing at all to what you could infer. The ideal comment goes beyond those words and should always reward you with some bit of information that was not immediately obvious from the API name. The description below says nothing beyond what you know from reading the method name. The words "set", "tool", "tip", and "text" are simply repeated in a sentence. It's better avoid this form of documentate. /** * Sets the tool tip text. * * text: The text of the tool tip. **/ public void setToolTipText(String text); This description more completely defines what a tool tip is, in the larger context of registering and being displayed in response to the cursor. This form is preferred in comparison with the first. /** * Registers the text to display in a tool tip. The text * displays when the cursor lingers over the component. * * text: The string to display. If the text is null, * the tool tip is turned off for this component. */ public void setToolTipText(String text); Be clear when using the term common term. Be aware that the common word as "field" can have many meanings and can confuse the reader. Avoid Latin Use "also known as" instead of "aka", use "that is" or "to be specific" instead of "i.e.", use "for example" instead of "e.g.", and use "in other words" or "namely" instead of "viz."
Aug 22 2002
prev sibling parent reply "anderson" <anderson firestar.com.au> writes:
Content-Type: text/plain;
	charset="iso-8859-1"
Content-Transfer-Encoding: quoted-printable

Source code documentation with coddocThe last email got muddled?

Simple typo - Copyright is spells wrong for one of the headings in that =
doc.
  "Juarez Rudsatz" <juarez nowhere.com> wrote in message =
news:Xns9271CD52FD128juarezcorreiocom 63.105.9.61...
  Hi all!

      I am sending the second version of this especification.
      Is not concluded yet.=20
      Let's comment, criticize, speculate, think, talk ....

  Juarez Rudsatz

  Juarez Rudsatz <juarez correio.com> wrote in
  news:Xns9249C9E0B98EEjuarezcom 63.105.9.61:=20

  > Hi all!
  >=20
  >          I am sending a very preliminary version of a specification
  >          for=20
  > implementing a sintax for document source files using the /* */
  > comments.=20
  >          It's a preliminary version and contain, certainly, design =
and
  > language errors.
  >          Please read the attached html file and send your comments.
  >=20



-------------------------------------------------------------------------=
-----


  Abstract
  A documentation model describes the format comments in the source code =
of a program must adhere to to be extractable by a documentation tool, =
which can then use the extracted information to create browsable or =
printable documentation, for instance in an html, pdf or word document =
format.

  This document is created with the purpose of specifying a clear and =
easy documentation model for the programming language D.

  Introduction
  Documentation comments are a method of reducing work by moving =
documentation from a separate document into the code itself in a way the =
documentation document could easily be generated. As every programmer =
knows, documentation tends to be incomplete, out of date, wrong, or =
non-existent. Moving the documentation into the code makes it easy to =
maintain with the program or library

  Tools for generating documentation of API's are commom today. They =
provide a simple method for programming and documenting at the same =
time. The documentation remains close to the source code for the API =
programmer, and for the application programmer will be in a more =
readable and easy to search format. They decrease the work of creating =
and maintaining documentation compared to writing it in a separate word =
processor. Most documentation generators will even be able to generate =
decent documentation from source code with no documentation comments in =
it at all, just from parsing the code itself. Adding good structured =
comments to the source code can greatly improve the value of the =
generated documentation however.

  How source code is documented
  Each feature of source code is composed by a set of language =
structures. For each structure is attached a comment providing a =
description of it functionality, a explaination of a component or =
classifying its atributes.

  See some examples below :

  A function being documented:
	/**
	 * This function is a simple example
	**/
	int function(int x) {
		return x;
	}

  A class being documented
	/**
	 * author: Wolfrang Amadeus Mozart <wam music.org>
	 *
	 * This class plays a sinfonie of Mozart. It can be used for learning =
music
	 * or for learning D documentation
	**/
	class sinfonie{
	...
	}

  How tags are parsed
  Documented comments use a variation of the standart documentation for =
D. They starts with the string '/**=B4 and finish with the string =
'**=B4:

	/** This is a documented comment **/
	typedef int normalvalue;

  Alternatively a single line format can be used with the string =
'//*=B4:

	//* This is a documented comment
	typedef int normalvalue;

  To place a single line comment behind the source line, as is common, =
use '//<=B4:

      typedef int normalvalue; //< This is a documented comment

  The documentation can span several lines. The extra blanks, tabulation =
and new lines are stripped, just as with html:

	/**
	This comment will have
	many lines
	as needed
	**/

  If the documentation should be divided into more than one paragraph, =
you can add a blank line where you want to start a new paragraph:

	/**
	This is a paragraph

	And this is another
	**/

  To allow the comment style often used by programmers where every line =
in the comment block starts with an asterisk (*) aligned with the first =
asterisk in the start comment tag, the first asterisk of the comment =
lines are stripped if every comment line starts with an asterisk as the =
first non-whitespace character:

	/**
	 * This comment will have
	 * many lines
	 * as needed.
	 *
	 * And this is the second paragraph.
	**/

  Aditional repeated chars at begin or at end are omited:

	/***********************************
	 * The repeated chars are omited
	***********************************/

  The comment can have also a "tag" which specifies the documentation of =
an specific atribute:

	/**
	 * author: William Shakespeare <william literature.net>
	**/
	module literature;

  The former tag specifies the author of the module. You can combine =
sereral tags and text in the comment:

	/**
	 * author: William Shakespeare <william literature.net>
	 * version: 1.0
	 *
	 * This module implements the logic for understanding the real =
interpretation of my ideas.
	 * It magically translate all ideas hidden from the simple reading and =
show to you.
	**/
	module literature;

  Types of Tags
  The tags can be of two types :

    a.. Taglines are tags described in one line. The tag end at the =
newline caracter. As example there are the version, since, category and =
glossary tags.=20
    b.. Tag paragraphs are tages described in one or more lines. The tag =
end is at the next tag or the end of comment.=20
  Position of Tags
  Tags may be put before any declaration:

	/**
	 * author: William Shakespeare <william literature.net> on 2002.03.04 =
05:06
	 * author: Wolfrang Amadeus Mozart <wam music.org> on 2002.04.06 08:16
	 * version: 0.3 alpha
	 * category: Example of Code Documentation
	 * see: anotherexample, example, "D Programming Tutorial"
	 *
	 * This module is provided as example of documenting code with coddoc. =
It is
	 * a example of how use the coments for generating documentation.
	**/
	module docexample;

  It is also allowed to place documentation comments after the =
declaration using the special start tag =B4//<=B4. These comments may =
only span one line however. Both forms may be mixed freely.

  This is an example of a struct with documentation comments:

	struct SDL_Color {
		Uint8 r;		//< The byte representing the red value for color
		Uint8 g;		//< The byte representing the green value for color
		Uint8 b;		//< The byte representing the blue value for color
		Uint8 unused;		//< This byte is reserved for future use
	}

  Especific tags
  Tag author
  The following are examples of author taglines, which may be used in =
documentation comments for module and types declarations:

	/**
	 * author: William Shakespeare<william literature.net>
	 * author: Dante Aglieri
	 * author: Jules Verne
	**/
	module literature;

  Tag copyrigth
  The copyright tag may be used to describe the copyright holder =
information for the module, class or method=20
	/**
	 * copyright: Pavel "EvilOne" Minayev (c) 2001-2002
	 *
	 * This module provides a class library for windows programming.
	 * It contains controls necessary for creating windowed applications
	 * such as edit controls, list controls, menus, status bars and
	 * many other controls. It is also possible to derive your own
	 * custom controls.
	**/
	module wind;

  Tag license
  The following is an example of a license paragraph, which may be used =
in documentation comments for module declarations:

	/**
	 * license:
	 * Permission to use, copy, modify, distribute and sell this software
	 * and its documentation for any purpose is hereby granted without fee,
	 * provided that the above copyright notice appear in all copies and
	 * that both that copyright notice and this permission notice appear
	 * in supporting documentation.  Author makes no representations about
	 * the suitability of this software for any purpose. It is provided
	 * "as is" without express or implied warranty.
	**/

  The license paragraph should contain all information applicable to =
licensing terms and permission of use.

  Tag version
  The following is an example of a version tagline, which may be used in =
documentation comments for type declarations:

	/**
	 * version: 2.93.1 beta
	**/
	module imported;

  Tag since
  Specify in what version when the name was added to the API =
specification (if different from the implementation). It could be used =
in type in reference to module version or in method in reference to =
class version.

  The following is an example of a since paragraph, which may be used in =
documentation comments for declarations of methods:

	/**
	 * version: 0.3 alpha
	 *
	 * This class is on the third version
	**/
	class widgetfarm : farm {
		/**
		 * since: 0.2
		 *
		 * This method is introduced in version 0.2 of this class
		**/
		void initwidgets {
		 ...
		}
	}

  Tag see
  The following are examples of see paragraphs, which may be used in any =
documentation comment to indicate a cross-reference to a type, method, =
constructor, field, URL, or any text:

	/**
	 * see: c.stdio
	 * see: string
	 * see: string.equals
	 * see: threads.thread.wait(int)
	 * see: RandomAccessFile.RandomAccessFile(File)
	 * see: RandomAccessFile.RandomAccessFile(File, String)
	 * see: Character.MAX_RADIX
	 * see: "D Language Specification" at =
http://www.digitalmars.com/d/spec.html
	 * see: "D Programming Tutorial"
	**/
	class implementation;

  The character "." separates the name of a module of a class and the =
name of a class from the name of one of its fields, methods, or =
constructors. The order of searching is package, module, type, method. =
One of several overloaded methods or constructors may be selected by =
including a parenthesized list of argument types after the method or =
constructor name.=20

  Tag category
  The category tagline specify in what category the type or method is =
gruped. It could be used in classes to classify the properties, methods =
and members in a closed scope.

  The following is an example of a category paragraph, which may be used =
in documentation comments for declarations of a functions:

	/**
	 * category: Temperature handling routines
	**/
	int temperature {
	...
	}

  Tag example
  Adds a example copied verbatim to documentation.

  The following is an example of a example paragraph, which may be used =
in documentation comments for providing user examples:

	/**
	 * example:
	 *
	 * // This ilustrate how to use a regexp to match a string
	 * RegExp myRegExp =3D new RegExp("[A-Za-z\b!]*");
	 * if (RegExp.Match("Hello World!")
	 *   printf("Hello World!");
	**/
	class RegExp
	{
	...
	}

  The formatting in the documentation remains exactly the same as it is =
in the source code. No whitespace is removed. A non-proportional font, =
such as courier is used for the examples, so simple ASCII drawings will =
survive the translation intact.

  Tag bug
  Specify known issue in types, methods or routines.

  The following is an example of a bug paragraph, which may be used in =
documentation comments for declarations of a functions:

	/**
	 * bug: Severity High. Windows 9x dont pass the correct memory used
	**/
	int memoryUsed {
	...
	}

  Tag todo
  Specify work to be done, such as implementing, optimizing or or =
documenting certain types and methods.

  The following is an example of a todo paragraph, which may be used in =
documentation comments for declarations of a class:

	/**
	 * version: 1.0
	 * todo: modify to permit evaluate a string caracter by caracter
	**/
	class RegExp
	{
	...
	}

  Tag glossary
  Specify a text to build a glossary by subject. The glossary tag is a =
tagline but a documentation comment may contain more than one glossary =
tag.

  The following is an example of a todo tagline, which may be used in =
documentation comments for declarations of a function:

	/**
	 * glossary: Deleting files
	 * glossary: Erasing files
	**/
	void delelefile(string filename){
	...
	}

  Tag summary
  The following is an example of an summary tagline, which may be used =
for short describing a artifact:

	/**
	 * summary: InterfaceDisconnect disconnects an IConnectionPoint =
interface.
	 *
	 * InterfaceDisconnect disconnects an IConnectionPoint interface =
connection
	 * that was previously made by the InterfaceConnect procedure.
	 * These procedures are wrappers for the ActiveX event-handling =
mechanism,
	 * the  IConnectionPointContainer and IConnectionPoint interfaces.
	**/
	void InterfaceDisconnect(IUnknown Source, ClassIID IID);

  Generic tags
  Tags for parameters
  The following are examples of parameters paragraphs, which may be used =
in documentation comments for method and constructor declarations:

	/**
	 * file: the file to be searched
	 * pattern: the pattern to be matched during the search. The pattern =
could
	 * consist of a simple string or a regular expression.
	 * count: the max number of lines to brings for each match. O for all =
lines;
	 *
	 * Matches lines in a file which follow a pattern.
	**/
	char[] matchLines(File file, char[] pattern, int count);

  The information in a parameter paragraph should consist of the name of =
the parameter followed by a short description.

  A documentation comment may contain more than one parameter tag. The =
usual convention is that if any parameter paragraphs are present in a =
documentation comment, then there should be one parameter paragraph for =
each parameter of the method or constructor, and the parameters =
paragraphs should appear in the order in which the parameters are =
declared but this is not mandatory.

  Tags for imports
  The following is an example of an import paragraph, which may be used =
in documentation comments for modules imports:

	/**
	 * Auxiliary routines
	**/
	import mymodule;

  The information in an import paragraph should consist of the name of =
an module (which may be a simple name or a qualified name) followed by a =
short description of the need or dependency reason.

  Additionaly, modules can be documented together simply by specifying =
the name of module contained in the colon list.

	/**
	 * mymodule: Auxiliary rotines
	 * c.stdio: needed for printf function
	 * stream: needed for reading and writing to files
	**/
	import mymodule, c.stdio, stream;

  Tags for exceptions
  The following is an example of an exception paragraph, which may be =
used in documentation comments for method and constructor declarations:

	void verifyWidget(Widget widget)
	{
		if (!widget.flanged)
			//* the widget does not have a flange, or its flange has size zero
			throw new UnflangedWidgetError(=B4Missing flange=B4);
		if (!widget.canUse)
			/**
			 * the widget cannot be used. This happens because it was not
			 * initialized, it was not attached to a manager, it was not
			 * configured or it is hided.
			**/
			throw new UnusableWidgetError();
		if (widget.InUse)
			throw new LockWidgetError("Widget is already in use"); //< the widget =
is already used
	}

  The comment in an exception paragraph is attached with the method =
which the error is throwed. For documenting the exception use a normal =
tag once a exception is a class.

  The information in an exception paragraph should consist by a short =
description of the circumstances that cause the exception to be thrown.=20

  Tags for return values
  The following is an example of an return paragraph, which may be used =
in documentation comments for method and functions declarations:

	byte cmpString(char[] str1, char[] str2)
	{
		if (str1 < str2)
			/** if the first string is smaller than second.
			 * return a positive number
			 */
			return 1;
		if (str1 =3D=3D str2)
			//* if strings are equal return zero
			return =3D 0;
		if (str1 =3D=3D str2)
			/** if the first string is greater than second.
			//* return a negative number
			return =3D -1;
	}

  Tags for Attributes
  Not all Attributes statements can be documented. There are no meaning =
in include documentation for the following tags:

    a.. private=20
    b.. protected=20
    c.. public=20
    d.. export=20
  Nevertheless the tool implementing documentation comments could =
include automatically the information and show or hide following user =
command.

  The following attributes can be commented:


    a.. deprecated=20
    b.. override=20
    c.. abstract=20
    d.. const=20
    e.. final=20
    f.. static=20
	/**
	 * As of D 2.0, replaced by stream handling methods
	 * see: stream
	**/
	deprecated
	{
		char[] read(File f)
		{
		...
		}

		int write(File f, char[] buffer)
		{
		..
		}
	}

  Tags for Contracts
  Contracts are a breakthrough technique to reduce the programming =
effort for large projects. Contracts are the concept of preconditions, =
postconditions, errors, and invariants. Contracts form part of the =
specification for a program, moving it from the documentation to the =
code itself.


  The comment in an assert contract is attached with the method which =
the contract is verified. For documenting the contract use a normal tag =
explaining the reason os such restriction. Assert contract without a =
documentation comment is not added in the documentation.

  Not all contracts can be documented. Following tags are not =
documented:

    a.. out contracts in methods=20
    b.. unittest contracts=20
  There are no meaning in include documentation for these contracts =
because they are commonly used for verification of accuracy of results =
and for determining if the code is working properly.

  The following contracts can be commented:


    a.. in contracts in methods=20
    b.. class invariants=20
  In Contracts
  The following is an example of documentation of an assert contract in =
a function in contract:

	int div(int x , int y)
	in
	{
		//* The divisor cannot be zero.
		assert(y !=3D 0);
	}
	body
	{
		return x / y;
	}

  Class Invariants
  The following is an example of documentation of an assert contract in =
a class invariant:

	class Date
	{
	int day;
	int hour;

	invariant()
	{
		//* The day must be between 1 and 31
		assert(1 <=3D day && day <=3D 31);
		//* The hour must be between 0 and 23
		assert(0 <=3D hour && hour < 24);
	}

  Tags and versioning
  Tags will be included in documentation following the versioning =
scheme.

  Tags and inheritance
  Inherited classes and structs will inherit tags for all methods =
defined in ancestral which are not modified by an new documentation =
comment.

  Compilaton process
  The compiler will parse each file and generate a new file containing =
the comments stripped from source and all information about the feature =
being documented.

  The format of all files generated is the docboock format. Each source =
file generates one new file containing a section in a docbook book. The =
document must be also a valid XML 1.0 document.

  Users could use a docbook processor for generate documentation in html =
format, text format, pdf format or any available format.

  Users can also write their own preprocessor since the output of code =
documentation will be a simple xml document.


  Sugested comments for statements
  Tags in simple types
  Tags in simple procedures
  Tags in functions
  Tags in structures
  Tags in classes
  Best practices
  A Style Guide
  The following are useful tips and conventions for writing descriptions =
in doc comments.

  When specifying data use formal and standard notation
  When specifying data such as dates and times use accepted standards =
such as ISO. This way foreign readers will not be confused by month, day =
positions.

	module greataddon;  //< should be ready 2002.12.31 00:00:00.

  Omit parentheses for the general form of methods and constructors
  When referring to a method or constructor that has multiple forms, and =
you mean to refer to a specific form, use parentheses and argument =
types. For example, ArrayList has two add methods: add(Object) and =
add(int, Object).

	The add(int, Object) method adds an item at a specified position in =
this arraylist.

  However, if referring to both forms of the method, omit the =
parentheses altogether. It is misleading to include empty parentheses, =
because that would imply a particular form of the method. The intent =
here is to distinguish the general method from any of its particular =
forms. Include the word "method" to distinguish it as a method and not a =
field.

	The add method enables you to insert items.			(preferred)
	The add() method enables you to insert items.		(avoid when you mean =
"all forms" of the add method)

  Okay to use phrases instead of complete sentences
  In the interests of brevity this could be used. This holds especially =
in the initial summary and in parameter tag descriptions.

  Use 3rd person (descriptive) not 2nd person (prescriptive).
  The description is in 3rd person declarative rather than 2nd person =
imperative.


	Gets the label.			(preferred)
	Get the label.			(avoid)

  Method descriptions begin with a verb phrase.
  A method implements an operation, so it usually starts with a verb =
phrase.

	Gets the label of this button.					(preferred)
	This method gets the label of this button.		(avoid)

  Class/interface/field descriptions can omit the subject.
  they can simply state the object. These API often describe things =
rather than actions or behaviors:

	A button label.						(preferred)
	This field is a button label.		(avoid)

  Use "this" instead of "the"
  When referring to an object created from the current class is =
preferred use a more specific word. For example, the description of the =
getToolkit method should read as follows:

	Gets the toolkit for this component.		(preferred)
	Gets the toolkit for the component.			(avoid)

  Add description beyond the API name.
  The best API names are "self-documenting", meaning they tell you =
basically what the API does. If the doc comment merely repeats the API =
name in sentence form, it is not providing more information. For =
example, if method description uses only the words that appear in the =
method name, then it is adding nothing at all to what you could infer. =
The ideal comment goes beyond those words and should always reward you =
with some bit of information that was not immediately obvious from the =
API name.

  The description below says nothing beyond what you know from reading =
the method name. The words "set", "tool", "tip", and "text" are simply =
repeated in a sentence. It's better avoid this form of documentate.

	/**
	 * Sets the tool tip text.
	 *
	 * text:  The text of the tool tip.
	**/
	public void setToolTipText(String text);

  This description more completely defines what a tool tip is, in the =
larger context of registering and being displayed in response to the =
cursor. This form is preferred in comparison with the first.

	/**
	 * Registers the text to display in a tool tip.   The text
	 * displays when the cursor lingers over the component.
	 *
	 * text:  The string to display.  If the text is null,
	 * the tool tip is turned off for this component.
	 */
	public void setToolTipText(String text);

  Be clear when using the term common term.

  Be aware that the common word as "field" can have many meanings and =
can confuse the reader.


  Avoid Latin
  Use "also known as" instead of "aka", use "that is" or "to be =
specific" instead of "i.e.", use "for example" instead of "e.g.", and =
use "in other words" or "namely" instead of "viz."
Aug 22 2002
parent Juarez Rudsatz <juarez nowhere.com> writes:
"anderson" <anderson firestar.com.au> wrote in
news:ak2i1a$1agt$1 digitaldaemon.com: 

 Source code documentation with coddocThe last email got muddled?

Sorry, I am not a native english speaker. I have not understood what you writed. Can you explain please ?
Aug 23 2002
prev sibling next sibling parent reply Juarez Rudsatz <juarez nowhere.com> writes:
A new update in code documentation syntax. I think this have evolved much 
since the first version. But need more discution until reach a solid stage.
Maybe it is time of balancing the costs against the benefits.
Please take a look at the specification and send your comments, preferences 
and questions. This is a not so prioritary project, but it could bring good 
advantages for the language by having a start in this direction.

Saudaçġes

Juarez Rudsatz

Juarez Rudsatz <juarez correio.com> wrote in
news:Xns9249C9E0B98EEjuarezcom 63.105.9.61: 

 Hi all!
 
          I am sending a very preliminary version of a specification
          for 
 implementing a sintax for document source files using the /* */
 comments. 
          It's a preliminary version and contain, certainly, design and
 language errors.
          Please read the attached html file and send your comments.
 

Sep 04 2002
next sibling parent reply Mac Reiter <Mac_member pathlink.com> writes:
Nested numbered lists will have a problem with the following:

#1 Top list, item 1
#2 Top list, item 2
#1 Nest list, item 1
#2 Nest list, item 2
#3 Which list?, item 3

If indentation is a controlling mechanism, it needs to be documented as such.
You'll also need to document whether whitespace or tabs are to be used, how
translations between whitespace and tabs will be performed (some editors do
auto-indentation to align with previous lines, which can cause followup lines to
use spaces when the original line used tabs:

#1 Top list, item 1
#2 Top list, item 2
<tab>#1 Nest list, item 1
<sp><sp><sp><sp>#2 Nest list, item 2
#3 Which list?, item 3

It might be better to take the list ending blank line and also use it for
sublists:

#1 Top list, item 1
#2 Top list, item 2
#1 Nest list, item 1
#2 Nest list, item 2

#3 Top list, item 3

Of course, this just delays the inevitable:

#1 Top list, item 1
#2 Top list, item 2
#1 Nest list, item 1
#2 Nest list, item 2
#1 Deep list, item 1
#2 Deep list, item 2

#3 Which list?, item 3

Two blank lines in a row (the direct extension of my previous suggestion) is not
particularly obvious when you read it.  It may be necessary to make a
terminating symbol to end a (sub)list:

#1 Top list, item 1
#2 Top list, item 2
#1 Nest list, item 1
#2 Nest list, item 2
#x
#3 Top list, item 3
#x

Or some such...

Mac
In article <Xns927FC90E25C36juarezcom 63.105.9.61>, Juarez Rudsatz says...
A new update in code documentation syntax. I think this have evolved much 
since the first version. But need more discution until reach a solid stage.
Maybe it is time of balancing the costs against the benefits.
Please take a look at the specification and send your comments, preferences 
and questions. This is a not so prioritary project, but it could bring good 
advantages for the language by having a start in this direction.

Saudaçġes

Juarez Rudsatz

Juarez Rudsatz <juarez correio.com> wrote in
news:Xns9249C9E0B98EEjuarezcom 63.105.9.61: 

 Hi all!
 
          I am sending a very preliminary version of a specification
          for 
 implementing a sintax for document source files using the /* */
 comments. 
          It's a preliminary version and contain, certainly, design and
 language errors.
          Please read the attached html file and send your comments.
 


Sep 04 2002
parent reply Juarez Rudsatz <juarez nowhere.com> writes:
Mac Reiter <Mac_member pathlink.com> wrote in
news:al6380$2uv9$1 digitaldaemon.com: 

 Nested numbered lists will have a problem with the following:
 
 #1 Top list, item 1
 #2 Top list, item 2
 #1 Nest list, item 1
 #2 Nest list, item 2
 #3 Which list?, item 3
 
 If indentation is a controlling mechanism, it needs to be documented
 as such. 

No identation is not a good method of controling lists or any documentation structure, IMHO. However you could use it for better looking in the source code. I have thinked in this rules: 1. On Unordered lists changing the bullet (+-o) define a child list 2. On Ordered lists changing the sequence number define a child list So, tha above code could be rendered in html as : <ol> <li>Top list, item 1</li> <li>Top list, item 2</li> <ol> <li>Nest list, item 1</li> <li>Nest list, item 2</li> <li>Which list?, item 3</li> </ol> </ol>
 It might be better to take the list ending blank line and also use it
 for sublists:
 
 #1 Top list, item 1
 #2 Top list, item 2
 #1 Nest list, item 1
 #2 Nest list, item 2
 
 #3 Top list, item 3

The number #3 does not reflect, necessarily, the initial values. Doing this will increase the rules for implemantation and does not look nice. <ol> <li>Top list, item 1</li> <li>Top list, item 2</li> <ol> <li>Nest list, item 1</li> <li>Nest list, item 2</li> </ol> </ol> <ol> <li>Top list, item 3</li> </ol>
 Of course, this just delays the inevitable:
 
 #1 Top list, item 1
 #2 Top list, item 2
 #1 Nest list, item 1
 #2 Nest list, item 2
 #1 Deep list, item 1
 #2 Deep list, item 2
 
 #3 Which list?, item 3

<ol> <li>Top list, item 1</li> <li>Top list, item 2</li> <ol> <li>Nest list, item 1</li> <li>Nest list, item 2</li> <ol> <li>Deep list, item 1</li> <li>Deep list, item 2</li> </ol> </ol> <ol> <li>Which list?, item 3</li> </ol>
 Two blank lines in a row (the direct extension of my previous
 suggestion) is not particularly obvious when you read it.  It may be
 necessary to make a terminating symbol to end a (sub)list:
 
 #1 Top list, item 1
 #2 Top list, item 2
 #1 Nest list, item 1
 #2 Nest list, item 2
 #x
 #3 Top list, item 3
 #x

The more simple aproach is consider #x as valid text and this a multi- line issue. <ol> <li>Top list, item 1</li> <li>Top list, item 2 #x</li> <ol> <li>Nest list, item 1</li> <li>Nest list, item 2 #x</li> </ol> </ol> <ol> <li>Top list, item 3</li> </ol> There are no need of list terminators if following the 2 golden rules. Its just polute the visual IMHO. What you think ? It is consistent ? There are some bug ? Looks nice ? Saudaçġes Juarez Rudsatz
Sep 06 2002
parent reply Pavel Minayev <evilone omen.ru> writes:
Juarez Rudsatz wrote:

 So, tha above code could be rendered in html as :
 
 <ol>
     	<li>Top list, item 1</li>
     	<li>Top list, item 2</li>
     	<ol>
     	    	<li>Nest list, item 1</li>
     	    	<li>Nest list, item 2</li>
     	    	<li>Which list?, item 3</li>
     	</ol>
 </ol>

But what if I _want_ the "Which list?" item to be an item #3 in the top list?!
 What you think ? It is consistent ? There are some bug ? Looks nice ?

It seems like you're trying to solve a "dangling else"-like C problem... not aware of any solution better than C one though.
Sep 07 2002
parent reply Suporte Internet <suporte spica.mps.com.br> writes:
Pavel Minayev <evilone omen.ru> wrote:
 Juarez Rudsatz wrote:
 
 So, tha above code could be rendered in html as :
 
 <ol>
       <li>Top list, item 1</li>
       <li>Top list, item 2</li>
       <ol>
               <li>Nest list, item 1</li>
               <li>Nest list, item 2</li>
               <li>Which list?, item 3</li>
       </ol>
 </ol>

But what if I _want_ the "Which list?" item to be an item #3 in the top list?!
 What you think ? It is consistent ? There are some bug ? Looks nice ?

It seems like you're trying to solve a "dangling else"-like C problem... not aware of any solution better than C one though.

Good obsevation ! But what could be the solution? 1. Requering a empty item what will not render? #1 list 1, item 1 #1 list 2, item 1 #2 #2 list 1, item 2 2. Use a terminator for lists? #1 list1, item 1 #1 list2, item 1 #x #2 list1, item 2 3. Use a empty line as that terminator? #1 list1, item 1 #1 list2, item 1 #2 list1, item 2 Here continue the text out of list 4. Using a optional different sintax for last item? #1 list1, item 1 #1# list2, item 1, last item #2 list1, item 2 #3# list1, item 3, last item #4 list3, item 1 5. Using tabs, for list level? #1 list2, item 1 <tab> #1list 2, item 1 #2 list1, item 2 <tab><tab><tab><tab>#1 list level 4, item 1 Any comment?
Sep 09 2002
parent reply Pavel Minayev <evilone omen.ru> writes:
Suporte Internet wrote:

 Good obsevation !
 But what could be the solution?

My suggestion would be to use some kind of symbol, for example period, to indicate nesting level: #1 List 1, Item 1 #2 List 1, Item 2 #.1 List 2, Item 1 #..1 List 3, Item 1 #.2 List 2, Item 2 #3 List 1, Item 3
Sep 09 2002
parent Juarez Rudsatz <juarez nowhere.com> writes:
Pavel Minayev <evilone omen.ru> wrote in news:aliq8p$1vev$1
 digitaldaemon.com:

 Good obsevation !
 But what could be the solution?

My suggestion would be to use some kind of symbol, for example period, to indicate nesting level: #1 List 1, Item 1 #2 List 1, Item 2 #.1 List 2, Item 1 #..1 List 3, Item 1 #.2 List 2, Item 2 #3 List 1, Item 3

Maybe a "nested" number: #1 List 1, Item 1 #1.1 List 1, Sub Item 1 #2 List 1, Item 2
Sep 11 2002
prev sibling next sibling parent reply "anderson" <anderson firestar.com.au> writes:
Content-Type: text/plain;
	charset="iso-8859-1"
Content-Transfer-Encoding: quoted-printable


"Juarez Rudsatz" <juarez nowhere.com> wrote in message =
news:Xns927FC90E25C36juarezcom 63.105.9.61...
 A new update in code documentation syntax. I think this have evolved =

 since the first version. But need more discution until reach a solid =

 Maybe it is time of balancing the costs against the benefits.
 Please take a look at the specification and send your comments, =

 and questions. This is a not so prioritary project, but it could bring =

 advantages for the language by having a start in this direction.
=20
 Sauda=E7=F5es
=20
 Juarez Rudsatz

Looking great. This docGen thing will add value to D.=20 My suggestion,=20 Parhaps there could be a way to modularise the docGen, so that files = that don't change don't need to be re-worked with doc gen. That may not = need to be in the documentation though. Also it would be nice if users = could specify a webpage where the latest docgen document resides. That = way local versions could remain current. ie /* * web version: www.something.com/Documents/ */ Parhaps this could be done with see, however I think it could be neetly = formated into the headers(or footer) of the page. The above may produce something like (for the car page): Find the latest of this webpage Note that the docgen would point directly to the wepage = www.something.com/Documents/Car.html, and web version is just in generic = form. The class rocket ship under www.something.com/Documents/ would = point to (www.something.com/Documents/Rocket Ship.html) Of course theres the possiblily of bad links, like when the = webpage\class structure changes. In these cases a default docgen page = could also be created to capture these errors. It would be nice if the docgen produced pages into separt folders = depending on the package which they reside, optionally or a zip file. = That's more a docgen compiler thing then a spec thing. Joel Anderson PS - copyrigth ?? -> copyright
Sep 05 2002
next sibling parent Juarez Rudsatz <juarez nowhere.com> writes:
"anderson" <anderson firestar.com.au> wrote in
news:al7dgi$2nua$1 digitaldaemon.com: 

 Parhaps there could be a way to modularise the docGen, so that files
 that don't change don't need to be re-worked with doc gen. That may
 not need to be in the documentation though 

I have thinked in make : SOURCES = $(wilcard *.d) # get all files with extension d in this dir CHAPTERS = $(.d:.dch) # replace the extension .d by .dch $(CHAPERS) : $(SOURCES) # generate each chapter from source file coddoc $^ # compile using coddoc
Sep 05 2002
prev sibling next sibling parent Juarez Rudsatz <juarez nowhere.com> writes:
"anderson" <anderson firestar.com.au> wrote in
news:al7dgi$2nua$1 digitaldaemon.com: 

 Also it would be nice if users could specify a webpage where the
 latest docgen document resides. That way local versions could remain
 current. 
 
 ie
 /*
  * web version: www.something.com/Documents/
 */
 
 Parhaps this could be done with see, however I think it could be
 neetly formated into the headers(or footer) of the page. 
 
 The above may produce something like (for the car page):
 
 Find the latest of this webpage
 
 Note that the docgen would point directly to the wepage
 www.something.com/Documents/Car.html, and web version is just in
 generic form. The class rocket ship under www.something.com/Documents/
 would point to (www.something.com/Documents/Rocket Ship.html) 
 
 Of course theres the possiblily of bad links, like when the
 webpage\class structure changes. In these cases a default docgen page
 could also be created to capture these errors. 
 

What about two alternatives : 1. The user can include in the module source file: /** * see: "D Language Specification" at http://www.digitalmars.com/d/spec.html **/ import foo; and the compiler can detect the url and generate a html like: <p> <b>See Also:</b>"D Language Specification" at <a href="http://www.digitalmars.com/d/spec.html"> http://www.digitalmars.com/d/spec.html</a> But this is a quality of implementation issue. 2. The user can include a hand generated docbook chapter with references or another instruction and compile and generate the html, pdf, tex, text or what he want.
Sep 05 2002
prev sibling next sibling parent Juarez Rudsatz <juarez nowhere.com> writes:
"anderson" <anderson firestar.com.au> wrote in
news:al7dgi$2nua$1 digitaldaemon.com: 

 It would be nice if the docgen produced pages into separt folders
 depending on the package which they reside, optionally or a zip file.
 That's more a docgen compiler thing then a spec thing. 
 

I think initialy in two compilers: 1. A stripper :-) 2. A indexer 3. A formatter The stripper extracts the documentation and generate a new file by each source file parsed. This file must be a xml docbook, but a best format can be discussed. The indexer take a lot of these files and generate the indexes, glossaries and categories and a sample docbook book index file. The user can now compile the documentation in his preferred format using his preferred docbook toolset. The formater simply will help the user putting empty comments in declarations. The first two compilers need to be a part of specification ( maybe v15 :-)). I have thinked about a form of parametrizing the preferences like : o I dont wanna variable in documentation. o I dont wanna declarations without comment in documentation. o I wanna the oposite... What you think about all?
Sep 05 2002
prev sibling parent reply Juarez Rudsatz <juarez nowhere.com> writes:
"anderson" <anderson firestar.com.au> wrote in news:al7dgi$2nua$1
 digitaldaemon.com:

 copyrigth ?? -> copyright

copyrigth , lenght, widht, heigth, ligth ! I newer write this correctly !!! Portuguese is much more simple !!! :-)
Sep 05 2002
parent "anderson" <anderson firestar.com.au> writes:
I'm a bad speller myself, and I can't blame a second language :) I don't
mind if someone corrects me (not implying that you don't). One thing though,
"copyright" is something that a spell checker should pickup so it's even
less of a small deal.

"Juarez Rudsatz" <juarez nowhere.com> wrote in message
news:Xns9280BF864E127juarezcom 63.105.9.61...
 "anderson" <anderson firestar.com.au> wrote in news:al7dgi$2nua$1
  digitaldaemon.com:

 copyrigth ?? -> copyright

copyrigth , lenght, widht, heigth, ligth ! I newer write this correctly !!! Portuguese is much more simple !!! :-)

Sep 06 2002
prev sibling parent reply Jason Mills <jmills cs.mun.ca> writes:
Juarez Rudsatz wrote:
 A new update in code documentation syntax. I think this have evolved much 
 since the first version. But need more discution until reach a solid stage.
 Maybe it is time of balancing the costs against the benefits.
 Please take a look at the specification and send your comments, preferences 
 and questions. This is a not so prioritary project, but it could bring good 
 advantages for the language by having a start in this direction.
 

I quickly scanned through the document and a couple of things did stand out to me (I'll do a more thorough read later). <quote> Alternatively a single line format can be used with the string '///´: /// This is a documented comment typedef int normalvalue; </quote> Can we use single line comments in place of the /** **/ style comments, as shown below: /// /// author: Wolfrang Amadeus Mozart <wam music.org> /// /// This class plays a sinfonie of Mozart. It can be used for learning /// music or for learning D documentation /// class sinfonie{ ... } <quote> To place a single line comment behind the source line, as is common, use '///<´: typedef int normalvalue; ///< This is a documented comment </quote> Just wondering... but why use ///< and not simply /// like the single line comments above? Jason
Sep 05 2002
next sibling parent reply Pavel Minayev <evilone omen.ru> writes:
Jason Mills wrote:

 To place a single line comment behind the source line, as is common, use
 '///<´:
 
   typedef int normalvalue; ///< This is a documented comment
 
 </quote>
 
 
 Just wondering... but why use ///< and not simply /// like the single
 line comments above?

So that the doc generator knows which line is commented (next or previous). It's doxygen syntax.
Sep 05 2002
parent reply Juarez Rudsatz <juarez nowhere.com> writes:
Pavel Minayev <evilone omen.ru> wrote in news:al7oem$8d7$1
 digitaldaemon.com:

 So that the doc generator knows which line is commented (next or 
 previous). It's doxygen syntax.
 

Yes. Maybe the easiest form of making a compiler for documentation will be writing a extension for doxygen.
Sep 05 2002
parent Jason Mills <jmills cs.mun.ca> writes:
Juarez Rudsatz wrote:
 Pavel Minayev <evilone omen.ru> wrote in news:al7oem$8d7$1
  digitaldaemon.com:
 
 
So that the doc generator knows which line is commented (next or 
previous). It's doxygen syntax.

Yes. Maybe the easiest form of making a compiler for documentation will be writing a extension for doxygen.

I have used doxygen for some C++ documentation, it's great. Maybe the easiest (best) solution to standard D source code documentation is to adopt doxygen style comments, i.e. use the doxygen spec and write an extension for doxygen as you suggested. A programmer could than use the same style comments for D, C++, and Java (and other languages doxygen supports). Jason
Sep 06 2002
prev sibling parent reply Juarez Rudsatz <juarez nowhere.com> writes:
Jason Mills <jmills cs.mun.ca> wrote in news:al7edl$2pih$1
 digitaldaemon.com:

 Can we use single line comments in place of the /** **/ style comments,
 as shown below:
 
 
    ///
    /// author: Wolfrang Amadeus Mozart <wam music.org>
    ///
    /// This class plays a sinfonie of Mozart. It can be used for learning
    /// music or for learning D documentation
    ///
    class sinfonie{
    ...
    }
 
 

I think it's ugly. But I think is valid. These are also: /** * author: Wolfrang Amadeus Mozart <wam music.org> **/ /** * This class plays a sinfonie of Mozart. It can be used for learning * music or for learning D documentation **/ class sinfonie{ ... } The rule I have thinked is the comment, if are in a body (not between { } ) is attached to next declaration. What this looks in your eyes ?
Sep 05 2002
parent Jason Mills <jmills cs.mun.ca> writes:
Can we use single line comments in place of the /** **/ style comments,
as shown below:


   ///
   /// author: Wolfrang Amadeus Mozart <wam music.org>
   ///
   /// This class plays a sinfonie of Mozart. It can be used for learning
   /// music or for learning D documentation
   ///
   class sinfonie{
   ...
   }

I think it's ugly. But I think is valid.

I (and some of my co-workers) like using /// as above.
 These are also:
 
  /** 
    * author: Wolfrang Amadeus Mozart <wam music.org>
   **/
  /** 
    * This class plays a sinfonie of Mozart. It can be used for learning
    * music or for learning D documentation
   **/
    class sinfonie{
    ...
    }
 
 The rule I have thinked is the comment, if are in a body (not between { } )
 is attached to next declaration.
 
 What this looks in your eyes ?

This *looks* like two seperate comments, but I guess it could be treated as one.
Sep 06 2002
prev sibling parent Juarez Rudsatz <juarez nowhere.com> writes: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Sep 04 2002