www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - debug()

reply Orion- <thierry.passeron gmail.com> writes:
Hello people,

I'm just starting D programming. I'd like to make a printf like function to
print some debuging informations. The synopsis could be dprintf(char[] format,
...) and as an example:
dprintf("creating object at %a", self);
It would print something like:
debug: class1.d(13): creating object at 0XFFB8
where class1.d is the __FILE__ name and 13 is the __LINE__ where it was called.

So, here are my 2 questions:

  * How do you know 'self' inside a class member function in D?
  * How would you do to have __LINE__ being the line where dprintf was called
not the line where it is implemented ?

Here is my dprintf function so far:
void dprintf(...) {
        TypeInfo[] infos;
        void *data;

        void putc(dchar c) { fputc(c, stderr); }

        Box[] box1 = boxArray("debug: ");
        Box[] box2 = boxArray(_arguments, cast(void *)_argptr);
        boxArrayToArguments(box1 ~ box2, infos, data);
        std.format.doFormat(&putc, infos, cast(char *)data);
}

Regards,
Thierry
Feb 26 2008
next sibling parent reply Jason House <jason.james.house gmail.com> writes:
Orion- wrote:
 So, here are my 2 questions:
 
   * How do you know 'self' inside a class member function in D?

Use 'this'
   * How would you do to have __LINE__ being the line where dprintf was
   called not the line where it is implemented ?

I can't answer that part authoritatively, but... Are you doing dprintf(...) instead of debug printf(...) ? If so, I recommend trying out the d style. Using debug(n), where n is an int, can be very useful for looking at differing levels of output. I personally have mostly moved away from that and started using debug(ident) (possibly with debug=ident at the top of the file or adding -debug=ident to the dmd call). The nice thing with that is it becomes extremely easy to leave all your debug stuff in your source. When chasing down a bug later on, it can be helpful.
Feb 26 2008
parent reply Orion- <thierry.passeron gmail.com> writes:
Jason House Wrote:

 Orion- wrote:
 So, here are my 2 questions:
 
   * How do you know 'self' inside a class member function in D?

Use 'this'
   * How would you do to have __LINE__ being the line where dprintf was
   called not the line where it is implemented ?

I can't answer that part authoritatively, but... Are you doing dprintf(...) instead of debug printf(...) ? If so, I recommend trying out the d style. Using debug(n), where n is an int, can be very useful for looking at differing levels of output. I personally have mostly moved away from that and started using debug(ident) (possibly with debug=ident at the top of the file or adding -debug=ident to the dmd call). The nice thing with that is it becomes extremely easy to leave all your debug stuff in your source. When chasing down a bug later on, it can be helpful.

Thank Jason, could you point me to the/a debug(n) documentation? Regards, Thierry
Feb 27 2008
parent BCS <BCS pathlink.com> writes:
Orion- wrote:
 Jason House Wrote:
 
 Thank Jason, could you point me to the/a debug(n) documentation?
 
 Regards, Thierry

http://www.digitalmars.com/d/1.0/version.html#debug
Feb 27 2008
prev sibling next sibling parent BCS <ao pathlink.com> writes:
Reply to Orion-,

 * How would you do to have __LINE__ being the line where dprintf was
 called not the line where it is implemented ?

some runtime reflection that looks at the return pointer of the stack frame would do it, but Ouch. The best solution I know of passes __FILE__ and __LINE__ as args but to make that nice you then need to run the whole file through a preprocessor of some fort to auto insert them. In short, you can't do it without a lot of work.
Feb 26 2008
prev sibling next sibling parent reply Bill Baxter <dnewsgroup billbaxter.com> writes:
Orion- wrote:
 Hello people,
 
 I'm just starting D programming. I'd like to make a printf like function to
print some debuging informations. The synopsis could be dprintf(char[] format,
...) and as an example:
 dprintf("creating object at %a", self);
 It would print something like:
 debug: class1.d(13): creating object at 0XFFB8
 where class1.d is the __FILE__ name and 13 is the __LINE__ where it was called.
 
 So, here are my 2 questions:
 
   * How do you know 'self' inside a class member function in D?
   * How would you do to have __LINE__ being the line where dprintf was called
not the line where it is implemented ?
 
 Here is my dprintf function so far:
 void dprintf(...) {
         TypeInfo[] infos;
         void *data;
 
         void putc(dchar c) { fputc(c, stderr); }
 
         Box[] box1 = boxArray("debug: ");
         Box[] box2 = boxArray(_arguments, cast(void *)_argptr);
         boxArrayToArguments(box1 ~ box2, infos, data);
         std.format.doFormat(&putc, infos, cast(char *)data);
 }

There is a way to get the __LINE__ thing to work automatically, without typing __LINE__, but the cure is almost worse than the disease. For simplicity I'll just use a non-formatted string to demonstrate. string dprintf(string msg) { return `writefln("%s(%s): ", __FILE__,__LINE__, msg);`; } ... mixin( dprintf("Hey you!")); At least I think that works. I don't use it because I'm not about to go around typing mixin everywhere to do debug output. That's the kind of thing that should some day be doable with macros, though. Then you'll be able to call it without the "mixin" part. What I actually use is more like what Jason said. debug(ver) {}. I don't bother with __FILE__ and __LINE__ stuff. ----- module MyModule; import std.stdio; private{ debug(MyModule) { alias writefln debugfln; alias writef debugf; } else { void debugfln(...) {} void debugf(...) {} } } And I hope that the compiler is smart enough to inline an empty function. If it's not, I'm getting on the next plane to Seattle to whack Walter 50 times with a wet noodle. --bb
Feb 26 2008
next sibling parent "Jarrett Billingsley" <kb3ctd2 yahoo.com> writes:
"Bill Baxter" <dnewsgroup billbaxter.com> wrote in message 
news:fq2ccd$kbk$1 digitalmars.com...

 And I hope that the compiler is smart enough to inline an empty function. 
 If it's not, I'm getting on the next plane to Seattle to whack Walter 50 
 times with a wet noodle.

It does seem to. Whew! I was going to have to join you if it didn't.
Feb 26 2008
prev sibling parent Orion- <thierry.passeron gmail.com> writes:
Bill Baxter Wrote:

 Orion- wrote:
 Hello people,
 
 I'm just starting D programming. I'd like to make a printf like function to
print some debuging informations. The synopsis could be dprintf(char[] format,
...) and as an example:
 dprintf("creating object at %a", self);
 It would print something like:
 debug: class1.d(13): creating object at 0XFFB8
 where class1.d is the __FILE__ name and 13 is the __LINE__ where it was called.
 
 So, here are my 2 questions:
 
   * How do you know 'self' inside a class member function in D?
   * How would you do to have __LINE__ being the line where dprintf was called
not the line where it is implemented ?
 
 Here is my dprintf function so far:
 void dprintf(...) {
         TypeInfo[] infos;
         void *data;
 
         void putc(dchar c) { fputc(c, stderr); }
 
         Box[] box1 = boxArray("debug: ");
         Box[] box2 = boxArray(_arguments, cast(void *)_argptr);
         boxArrayToArguments(box1 ~ box2, infos, data);
         std.format.doFormat(&putc, infos, cast(char *)data);
 }

There is a way to get the __LINE__ thing to work automatically, without typing __LINE__, but the cure is almost worse than the disease. For simplicity I'll just use a non-formatted string to demonstrate. string dprintf(string msg) { return `writefln("%s(%s): ", __FILE__,__LINE__, msg);`; } ... mixin( dprintf("Hey you!")); At least I think that works. I don't use it because I'm not about to go around typing mixin everywhere to do debug output. That's the kind of thing that should some day be doable with macros, though. Then you'll be able to call it without the "mixin" part. What I actually use is more like what Jason said. debug(ver) {}. I don't bother with __FILE__ and __LINE__ stuff. ----- module MyModule; import std.stdio; private{ debug(MyModule) { alias writefln debugfln; alias writef debugf; } else { void debugfln(...) {} void debugf(...) {} } } And I hope that the compiler is smart enough to inline an empty function. If it's not, I'm getting on the next plane to Seattle to whack Walter 50 times with a wet noodle. --bb

Thanks Bill, do you know of any document explaining the debug() D function ? Regards, Thierry
Feb 27 2008
prev sibling parent Henning Hasemann <hhasemann web.de> writes:
Orion- <thierry.passeron gmail.com> wrote:
 Thanks Bill, do you know of any document explaining the debug() D
 function ?

Well, I'm not Bill, but I guess that won't hinder you looking here: http://www.digitalmars.com/d/1.0/version.html Henning -- GPG Public Key: http://gpg-keyserver.de/pks/lookup?op=get&search=0xDDD6D36D41911851
Feb 27 2008