digitalmars.D.learn - Idiom for debug printf?
- Bill Baxter (15/15) Sep 30 2007 Is there a common idiom for a version-specific printf?
- 0ffh (4/14) Sep 30 2007 No idea what it /should/ be done like, but in the else case I use
- BCS (28/45) Sep 30 2007 I don't bother with switching the function out, I just put each debug li...
- Bill Baxter (4/31) Oct 01 2007 Well, I'm not quite so macho, so I'll just stick with the void
- BCS (6/15) Oct 01 2007 I would need to use my form regardless (with conditional debugs). Otherw...
- 0ffh (3/9) Oct 01 2007 You're all marked down for 99 sympathy brownie points! :)
- Max Samukha (12/43) Oct 01 2007 You could use templates:
- Max Samukha (4/49) Oct 01 2007 Ignore. That would only work if the compiler optimized out the empty
- Kris (5/51) Oct 02 2007 Better to use the recent Trace.format() instead of Stdout, per the post ...
Is there a common idiom for a version-specific printf? Something like: version(Verbose) { alias writefln debugfln; } else { ... what goes here? ... } The idea is that it should work just like a call to writefln in the version=Verbose case, but it should be a complete no-op otherwise (meaning it also shouldn't evaluate its arguments). I thought there was some way to do this with 'lazy' or somesuch, but I don't recall the exact syntax. Thanks, --bb
Sep 30 2007
Bill Baxter wrote:version(Verbose) { alias writefln debugfln; } else { ... what goes here? ... } The idea is that it should work just like a call to writefln in the version=Verbose case, but it should be a complete no-op otherwise (meaning it also shouldn't evaluate its arguments).No idea what it /should/ be done like, but in the else case I use "void debugfln(...) {}" and rely on compiler optimisation... :) Regards, Frank
Sep 30 2007
Reply to Bill,Is there a common idiom for a version-specific printf? Something like: version(Verbose) { alias writefln debugfln; } else { ... what goes here? ... } The idea is that it should work just like a call to writefln in the version=Verbose case, but it should be a complete no-op otherwise (meaning it also shouldn't evaluate its arguments). I thought there was some way to do this with 'lazy' or somesuch, but I don't recall the exact syntax. Thanks, --bbI don't bother with switching the function out, I just put each debug line in it's own debug statement. my idium of choice is this: debug(DebugIdent) writef(__FILE__":("~itoa!(__LINE__)~"): the message to print\n"); this uses this little gem: /** Don Clugston's decimalDigit. see http://trac.dsource.org/projects/ddl/browser/trunk/meta/conv.d */ template decimalDigit(int n) { const char[] decimalDigit = "0123456789"[n..n+1]; } /** Don Clugston's itoa. see http://trac.dsource.org/projects/ddl/browser/trunk/meta/conv.d */ template itoa(long n) { static if (n < 0) const char[] itoa = "-" ~ itoa!(-n); else static if (n < 10) const char[] itoa = decimalDigit!(n); else const char[] itoa = itoa!(n/10L) ~ decimalDigit!(n%10L); }
Sep 30 2007
BCS wrote:Reply to Bill,Well, I'm not quite so macho, so I'll just stick with the void debugfln(...){}, and say my prayers to the deities of optimization. --bbIs there a common idiom for a version-specific printf? Something like: version(Verbose) { alias writefln debugfln; } else { ... what goes here? ... } The idea is that it should work just like a call to writefln in the version=Verbose case, but it should be a complete no-op otherwise (meaning it also shouldn't evaluate its arguments). I thought there was some way to do this with 'lazy' or somesuch, but I don't recall the exact syntax. Thanks, --bbI don't bother with switching the function out, I just put each debug line in it's own debug statement. my idium of choice is this: debug(DebugIdent) writef(__FILE__":("~itoa!(__LINE__)~"): the message to print\n");
Oct 01 2007
Reply to Bill,BCS wrote:I would need to use my form regardless (with conditional debugs). Otherwise I'd be completely inundated with logging. (ever try reading though 400k loins of log? ;) I have a tendency to do printf debugging and then never remove the printfs (I just turn them off)debug(DebugIdent) writef(__FILE__":("~itoa!(__LINE__)~"): message\n");Well, I'm not quite so macho, so I'll just stick with the void debugfln(...){}, and say my prayers to the deities of optimization. --bb
Oct 01 2007
BCS wrote:Reply to Bill,You're all marked down for 99 sympathy brownie points! :) Regards, FrankWell, I'm not quite so macho, so I'll just stick with the void debugfln(...){}, and say my prayers to the deities of optimization.[...] I have a tendency to do printf debugging and then never remove the printfs (I just turn them off)
Oct 01 2007
On Mon, 01 Oct 2007 20:29:45 +0900, Bill Baxter <dnewsgroup billbaxter.com> wrote:BCS wrote:You could use templates: import tango.io.Stdout; void debugfln(A...)(A a) { version (Verbose) Stdout.format(a).newline; } void main() { debugfln("1: {}, 2: {}", 1, 2); }Reply to Bill,Well, I'm not quite so macho, so I'll just stick with the void debugfln(...){}, and say my prayers to the deities of optimization. --bbIs there a common idiom for a version-specific printf? Something like: version(Verbose) { alias writefln debugfln; } else { ... what goes here? ... } The idea is that it should work just like a call to writefln in the version=Verbose case, but it should be a complete no-op otherwise (meaning it also shouldn't evaluate its arguments). I thought there was some way to do this with 'lazy' or somesuch, but I don't recall the exact syntax. Thanks, --bbI don't bother with switching the function out, I just put each debug line in it's own debug statement. my idium of choice is this: debug(DebugIdent) writef(__FILE__":("~itoa!(__LINE__)~"): the message to print\n");
Oct 01 2007
On Tue, 02 Oct 2007 09:21:36 +0300, Max Samukha <samukha voliacable.com.removethis> wrote:On Mon, 01 Oct 2007 20:29:45 +0900, Bill Baxter <dnewsgroup billbaxter.com> wrote:Ignore. That would only work if the compiler optimized out the empty function. It's a rephrasing of Frank's solution.BCS wrote:You could use templates: import tango.io.Stdout; void debugfln(A...)(A a) { version (Verbose) Stdout.format(a).newline; } void main() { debugfln("1: {}, 2: {}", 1, 2); }Reply to Bill,Well, I'm not quite so macho, so I'll just stick with the void debugfln(...){}, and say my prayers to the deities of optimization. --bbIs there a common idiom for a version-specific printf? Something like: version(Verbose) { alias writefln debugfln; } else { ... what goes here? ... } The idea is that it should work just like a call to writefln in the version=Verbose case, but it should be a complete no-op otherwise (meaning it also shouldn't evaluate its arguments). I thought there was some way to do this with 'lazy' or somesuch, but I don't recall the exact syntax. Thanks, --bbI don't bother with switching the function out, I just put each debug line in it's own debug statement. my idium of choice is this: debug(DebugIdent) writef(__FILE__":("~itoa!(__LINE__)~"): the message to print\n");
Oct 01 2007
Better to use the recent Trace.format() instead of Stdout, per the post in "announce". Alternatively, consider using tango.util.log instead? - Kris "Max Samukha" <samukha voliacable.com.removethis> wrote in message news:ldo3g3pbi1tucigvu5fd8reisdh1nd2mvu 4ax.com...On Mon, 01 Oct 2007 20:29:45 +0900, Bill Baxter <dnewsgroup billbaxter.com> wrote:BCS wrote:You could use templates: import tango.io.Stdout; void debugfln(A...)(A a) { version (Verbose) Stdout.format(a).newline; } void main() { debugfln("1: {}, 2: {}", 1, 2); }Reply to Bill,Well, I'm not quite so macho, so I'll just stick with the void debugfln(...){}, and say my prayers to the deities of optimization. --bbIs there a common idiom for a version-specific printf? Something like: version(Verbose) { alias writefln debugfln; } else { ... what goes here? ... } The idea is that it should work just like a call to writefln in the version=Verbose case, but it should be a complete no-op otherwise (meaning it also shouldn't evaluate its arguments). I thought there was some way to do this with 'lazy' or somesuch, but I don't recall the exact syntax. Thanks, --bbI don't bother with switching the function out, I just put each debug line in it's own debug statement. my idium of choice is this: debug(DebugIdent) writef(__FILE__":("~itoa!(__LINE__)~"): the message to print\n");
Oct 02 2007