Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.lang.c > #95408 > unrolled thread
| Started by | fir <profesor.fir@gmail.com> |
|---|---|
| First post | 2016-10-30 05:42 -0700 |
| Last post | 2016-11-03 03:58 -0700 |
| Articles | 20 on this page of 410 — 25 participants |
Back to article view | Back to comp.lang.c
usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-10-30 05:42 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-10-30 17:17 +0000
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-10-31 11:02 -0700
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-10-30 12:13 -0700
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-10-30 12:52 -0700
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-10-30 13:38 -0700
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-10-30 14:32 -0700
Re: usecases of void foo(char **b) {} "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2016-10-30 13:49 -0700
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-10-30 14:04 -0700
Re: usecases of void foo(char **b) {} "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2016-10-30 14:14 -0700
Re: usecases of void foo(char **b) {} "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2016-10-30 14:20 -0700
Re: usecases of void foo(char **b) {} "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2016-10-30 14:23 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-10-31 13:40 +0000
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-01 01:45 +0000
Re: usecases of void foo(char **b) {} Tim Rentsch <txr@alumni.caltech.edu> - 2016-11-01 07:55 -0700
Re: usecases of void foo(char **b) {} mark.bluemel@gmail.com - 2016-11-01 08:07 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-01 16:55 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-01 11:58 -0700
Re: usecases of void foo(char **b) {} John Bode <jfbode1029@gmail.com> - 2016-11-01 12:34 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-01 12:49 -0700
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-01 20:13 +0000
Re: usecases of void foo(char **b) {} Tim Rentsch <txr@alumni.caltech.edu> - 2016-11-02 12:45 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-02 20:37 +0000
Re: usecases of void foo(char **b) {} Tim Rentsch <txr@alumni.caltech.edu> - 2016-11-15 10:50 -0800
Re: usecases of void foo(char **b) {} David Brown <david.brown@hesbynett.no> - 2016-10-31 12:37 +0100
Re: usecases of void foo(char **b) {} "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2016-10-31 06:01 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-10-31 11:11 -0700
Re: usecases of void foo(char **b) {} Ike Naar <ike@iceland.freeshell.org> - 2016-10-31 01:26 +0000
Re: usecases of void foo(char **b) {} "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2016-10-30 12:49 -0700
Re: usecases of void foo(char **b) {} "Pascal J. Bourguignon" <pjb@informatimago.com> - 2016-10-31 14:16 +0100
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-10-31 14:20 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-10-31 14:55 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-10-31 08:10 -0700
Re: usecases of void foo(char **b) {} "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2016-10-31 08:27 -0700
Re: usecases of void foo(char **b) {} John Bode <jfbode1029@gmail.com> - 2016-10-31 09:12 -0700
Re: usecases of void foo(char **b) {} "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2016-10-31 09:20 -0700
Re: usecases of void foo(char **b) {} "Pascal J. Bourguignon" <pjb@informatimago.com> - 2016-11-05 04:24 +0100
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-10-31 16:35 +0000
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-10-31 09:59 -0700
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-10-31 17:04 +0000
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-10-31 12:16 -0700
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-10-31 19:19 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-01 08:31 -0700
Re: usecases of void foo(char **b) {} Jerry Stuckle <jstucklex@attglobal.net> - 2016-11-01 22:07 -0400
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-02 01:55 -0700
Re: usecases of void foo(char **b) {} Jerry Stuckle <jstucklex@attglobal.net> - 2016-11-02 09:18 -0400
Re: usecases of void foo(char **b) {} David Brown <david.brown@hesbynett.no> - 2016-11-02 15:45 +0100
Re: usecases of void foo(char **b) {} luser droog <luser.droog@gmail.com> - 2016-11-02 07:48 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-02 07:58 -0700
Re: usecases of void foo(char **b) {} luser droog <luser.droog@gmail.com> - 2016-11-02 08:05 -0700
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-02 17:17 +0000
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-02 10:37 -0700
Re: usecases of void foo(char **b) {} David Brown <david.brown@hesbynett.no> - 2016-11-02 20:38 +0100
Re: usecases of void foo(char **b) {} "Pascal J. Bourguignon" <pjb@informatimago.com> - 2016-11-05 04:37 +0100
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-05 14:12 -0700
Re: usecases of void foo(char **b) {} "Pascal J. Bourguignon" <pjb@informatimago.com> - 2016-11-07 00:37 +0100
Re: usecases of void foo(char **b) {} Jerry Stuckle <jstucklex@attglobal.net> - 2016-11-02 11:03 -0400
Re: usecases of void foo(char **b) {} John Bode <jfbode1029@gmail.com> - 2016-10-31 11:20 -0700
Re: usecases of void foo(char **b) {} "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2016-10-31 11:24 -0700
Re: usecases of void foo(char **b) {} John Bode <jfbode1029@gmail.com> - 2016-11-01 09:02 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-01 16:27 +0000
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-01 17:46 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-01 11:46 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-01 19:41 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-01 13:10 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-01 20:50 +0000
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-01 21:04 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-01 22:22 +0000
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-01 22:54 +0000
Re: usecases of void foo(char **b) {} John Bode <jfbode1029@gmail.com> - 2016-11-02 07:02 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-02 18:53 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-02 12:24 -0700
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-02 20:12 +0000
Re: usecases of void foo(char **b) {} John Bode <jfbode1029@gmail.com> - 2016-11-02 13:21 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-02 21:11 +0000
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-01 14:46 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-01 15:28 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-02 02:32 -0700
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-01 15:26 -0700
Re: usecases of void foo(char **b) {} John Bode <jfbode1029@gmail.com> - 2016-11-01 15:55 -0700
Re: usecases of void foo(char **b) {} Tim Rentsch <txr@alumni.caltech.edu> - 2016-11-02 12:53 -0700
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-01 16:39 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-01 16:55 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-02 02:21 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-02 05:02 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-02 12:58 +0000
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-02 08:03 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-02 08:14 -0700
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-02 09:19 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-02 17:54 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-02 11:47 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-02 19:01 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-02 12:28 -0700
Re: usecases of void foo(char **b) {} Tim Rentsch <txr@alumni.caltech.edu> - 2016-11-12 13:36 -0800
Re: usecases of void foo(char **b) {} Ian Collins <ian-news@hotmail.com> - 2016-11-13 11:07 +1300
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-12 22:27 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-12 14:49 -0800
Re: usecases of void foo(char **b) {} Tim Rentsch <txr@alumni.caltech.edu> - 2016-11-15 10:23 -0800
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-12 14:47 -0800
Re: usecases of void foo(char **b) {} Tim Rentsch <txr@alumni.caltech.edu> - 2016-11-15 10:05 -0800
Re: usecases of void foo(char **b) {} Jerry Stuckle <jstucklex@attglobal.net> - 2016-11-12 17:06 -0500
Re: usecases of void foo(char **b) {} Gareth Owen <gwowen@gmail.com> - 2016-11-02 19:35 +0000
Re: usecases of void foo(char **b) {} John Bode <jfbode1029@gmail.com> - 2016-11-01 13:12 -0700
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-01 13:37 -0700
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-01 09:45 -0700
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-10-31 18:33 +0000
Re: usecases of void foo(char **b) {} John Bode <jfbode1029@gmail.com> - 2016-10-31 11:41 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-10-31 18:51 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-01 08:43 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-01 16:14 +0000
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-10-31 16:04 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-10-31 16:22 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-10-31 23:45 +0000
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-10-31 16:58 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-10-31 17:11 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-01 01:27 +0000
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-01 02:31 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-01 02:41 -0700
Re: usecases of void foo(char **b) {} asetofsymbols@gmail.com - 2016-11-01 03:15 -0700
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-01 11:14 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-01 11:30 +0000
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-01 12:10 +0000
Re: usecases of void foo(char **b) {} Jerry Stuckle <jstucklex@attglobal.net> - 2016-11-01 11:23 -0400
Re: usecases of void foo(char **b) {} jameskuyper@verizon.net - 2016-11-01 09:33 -0700
Re: usecases of void foo(char **b) {} Jerry Stuckle <jstucklex@attglobal.net> - 2016-11-01 22:16 -0400
Re: usecases of void foo(char **b) {} jameskuyper@verizon.net - 2016-11-01 20:36 -0700
Re: usecases of void foo(char **b) {} Jerry Stuckle <jstucklex@attglobal.net> - 2016-11-02 09:20 -0400
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-02 09:02 -0700
Re: usecases of void foo(char **b) {} James Kuyper <jameskuyper@verizon.net> - 2016-11-03 22:09 -0400
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-01 17:37 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-01 11:59 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-01 05:51 -0700
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-01 06:26 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-01 07:32 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-01 15:37 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-01 08:50 -0700
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-01 09:05 -0700
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-01 17:48 +0000
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-01 12:38 -0700
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-01 22:55 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-02 00:04 +0000
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-02 02:06 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-02 10:05 +0000
Re: usecases of void foo(char **b) {} John Bode <jfbode1029@gmail.com> - 2016-11-02 08:07 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-02 08:45 -0700
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-02 09:17 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-02 19:10 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-02 12:55 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-02 20:13 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-02 13:37 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-02 19:18 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-02 13:04 -0700
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-02 20:54 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-02 22:31 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-02 23:53 +0000
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-03 08:41 -0700
Re: usecases of void foo(char **b) {} John Bode <jfbode1029@gmail.com> - 2016-11-02 14:05 -0700
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-02 16:17 -0700
Re: usecases of void foo(char **b) {} Ian Collins <ian-news@hotmail.com> - 2016-11-03 17:31 +1300
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-03 08:20 -0700
Re: usecases of void foo(char **b) {} Ian Collins <ian-news@hotmail.com> - 2016-11-04 07:59 +1300
Re: usecases of void foo(char **b) {} David Brown <david.brown@hesbynett.no> - 2016-11-04 09:53 +0100
Re: usecases of void foo(char **b) {} Ian Collins <ian-news@hotmail.com> - 2016-11-04 22:32 +1300
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-04 07:57 -0700
Re: usecases of void foo(char **b) {} David Brown <david.brown@hesbynett.no> - 2016-11-04 16:47 +0100
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-04 09:09 -0700
Re: usecases of void foo(char **b) {} David Brown <david.brown@hesbynett.no> - 2016-11-04 18:04 +0100
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-04 12:27 -0700
Re: usecases of void foo(char **b) {} David Brown <david.brown@hesbynett.no> - 2016-11-05 14:42 +0100
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-05 14:04 -0700
Re: usecases of void foo(char **b) {} David Brown <david.brown@hesbynett.no> - 2016-11-06 17:29 +0100
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-06 18:42 -0800
Re: usecases of void foo(char **b) {} Tim Rentsch <txr@alumni.caltech.edu> - 2016-11-15 10:51 -0800
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-15 12:16 -0800
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-15 12:34 -0800
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-15 13:27 -0800
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-15 13:43 -0800
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-15 14:02 -0800
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-15 15:01 -0800
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-15 16:00 -0800
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-15 17:06 -0800
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-15 22:49 -0800
Re: usecases of void foo(char **b) {} jameskuyper@verizon.net - 2016-11-16 04:30 -0800
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-16 08:37 -0800
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-16 09:34 -0800
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-16 09:49 -0800
Re: usecases of void foo(char **b) {} jameskuyper@verizon.net - 2016-11-16 10:27 -0800
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-17 13:03 -0800
Re: usecases of void foo(char **b) {} raltbos@xs4all.nl (Richard Bos) - 2016-11-18 09:08 +0000
Re: usecases of void foo(char **b) {} Tim Rentsch <txr@alumni.caltech.edu> - 2016-11-16 10:31 -0800
Re: usecases of void foo(char **b) {} Ian Collins <ian-news@hotmail.com> - 2016-11-05 08:14 +1300
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-02 21:43 +0000
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-02 16:16 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-03 00:05 +0000
Re: usecases of void foo(char **b) {} Gareth Owen <gwowen@gmail.com> - 2016-11-03 06:07 +0000
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-03 01:59 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-03 02:19 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-03 03:25 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-03 10:51 +0000
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-03 11:58 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-03 12:26 +0000
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-03 13:05 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-03 14:50 +0000
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-03 15:00 +0000
Re: usecases of void foo(char **b) {} David Brown <david.brown@hesbynett.no> - 2016-11-03 16:27 +0100
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-03 08:38 -0700
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-03 09:07 -0700
Re: usecases of void foo(char **b) {} David Brown <david.brown@hesbynett.no> - 2016-11-04 10:00 +0100
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-03 09:00 -0700
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-03 16:29 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-03 16:43 +0000
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-03 17:14 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-03 17:23 +0000
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-03 18:18 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-03 18:38 +0000
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-03 18:42 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-03 18:56 +0000
Re: usecases of void foo(char **b) {} John Bode <jfbode1029@gmail.com> - 2016-11-03 12:15 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-03 20:26 +0000
Re: usecases of void foo(char **b) {} John Bode <jfbode1029@gmail.com> - 2016-11-03 13:55 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-03 21:58 +0000
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-03 19:46 +0000
Re: usecases of void foo(char **b) {} "Mr. Man-wai Chang" <toylet.toylet@gmail.com> - 2016-11-04 02:46 +0800
[OT] "Mr. Man-wai Chang" <toylet.toylet@gmail.com> - 2016-11-04 11:59 +0800
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-03 12:14 -0700
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-03 15:27 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-03 08:45 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-03 16:33 +0000
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-03 09:57 -0700
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-03 12:12 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-04 02:02 +0000
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-04 11:15 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-04 12:12 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-04 13:52 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-04 15:28 +0000
Re: usecases of void foo(char **b) {} Gareth Owen <gwowen@gmail.com> - 2016-11-04 17:17 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-04 19:04 +0000
Re: usecases of void foo(char **b) {} Thiago Adams <thiago.adams@gmail.com> - 2016-11-04 12:34 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-04 20:20 +0000
Re: usecases of void foo(char **b) {} Gareth Owen <gwowen@gmail.com> - 2016-11-05 14:52 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-05 15:42 +0000
Re: usecases of void foo(char **b) {} jameskuyper@verizon.net - 2016-11-05 11:40 -0700
Re: usecases of void foo(char **b) {} Gareth Owen <gwowen@gmail.com> - 2016-11-05 21:24 +0000
Re: usecases of void foo(char **b) {} Gareth Owen <gwowen@gmail.com> - 2016-11-05 21:23 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-05 21:58 +0000
Re: usecases of void foo(char **b) {} jameskuyper@verizon.net - 2016-11-05 15:57 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-05 17:00 -0700
Re: usecases of void foo(char **b) {} Gareth Owen <gwowen@gmail.com> - 2016-11-06 19:59 +0000
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-04 17:48 +0000
Re: usecases of void foo(char **b) {} asetofsymbols@gmail.com - 2016-11-04 12:55 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-04 20:30 +0000
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-04 21:13 +0000
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-04 15:13 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-04 22:37 +0000
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-04 17:02 -0700
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-04 16:19 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-04 22:58 +0000
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-05 02:14 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-05 11:13 +0000
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-05 14:23 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-05 15:38 +0000
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-05 16:13 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-05 17:01 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-05 14:04 -0700
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-05 23:01 +0000
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-05 16:20 -0700
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-05 23:46 +0000
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-06 08:26 -0800
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-05 18:41 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-05 23:57 +0000
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-06 00:48 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-06 02:12 +0000
Re: usecases of void foo(char **b) {} Ian Collins <ian-news@hotmail.com> - 2016-11-06 16:52 +1300
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-06 12:02 +0000
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-06 11:02 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-06 11:45 +0000
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-06 12:51 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-06 14:19 +0000
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-06 14:49 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-06 15:49 +0000
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-06 15:57 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-06 16:31 +0000
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-06 17:40 +0000
Re: usecases of void foo(char **b) {} Thiago Adams <thiago.adams@gmail.com> - 2016-11-06 10:16 -0800
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-06 19:18 +0000
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-06 19:40 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-06 20:12 +0000
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-06 21:01 +0000
Re: usecases of void foo(char **b) {} Ian Collins <ian-news@hotmail.com> - 2016-11-07 20:42 +1300
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-07 08:17 +0000
Re: usecases of void foo(char **b) {} Ian Collins <ian-news@hotmail.com> - 2016-11-07 22:27 +1300
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-07 12:37 +0000
Re: usecases of void foo(char **b) {} Ian Collins <ian-news@hotmail.com> - 2016-11-08 11:12 +1300
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-08 00:09 +0000
Re: usecases of void foo(char **b) {} Ian Collins <ian-news@hotmail.com> - 2016-11-08 13:46 +1300
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-06 13:10 -0800
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-06 21:22 +0000
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-06 21:44 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-06 21:58 +0000
Re: usecases of void foo(char **b) {} jameskuyper@verizon.net - 2016-11-06 14:11 -0800
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-06 22:47 +0000
Re: usecases of void foo(char **b) {} "James R. Kuyper" <jameskuyper@verizon.net> - 2016-11-06 18:14 -0500
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-07 01:36 +0000
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-07 00:49 +0000
Re: usecases of void foo(char **b) {} "James R. Kuyper" <jameskuyper@verizon.net> - 2016-11-07 11:32 -0500
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-07 09:28 -0800
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-07 10:49 -0800
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-06 22:37 +0000
Re: usecases of void foo(char **b) {} jameskuyper@verizon.net - 2016-11-06 14:02 -0800
Re: usecases of void foo(char **b) {} John Bode <jfbode1029@gmail.com> - 2016-11-07 10:57 -0800
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-07 21:55 +0000
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-07 22:38 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-07 23:49 +0000
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-08 00:02 +0000
Re: usecases of void foo(char **b) {} "James R. Kuyper" <jameskuyper@verizon.net> - 2016-11-07 19:21 -0500
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-08 00:25 +0000
Re: usecases of void foo(char **b) {} John Bode <jfbode1029@gmail.com> - 2016-11-08 07:02 -0800
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-08 15:49 +0000
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-08 16:03 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-08 08:10 -0800
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-08 16:31 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-08 18:15 +0000
Re: usecases of void foo(char **b) {} Robert Wessel <robertwessel2@yahoo.com> - 2016-11-09 23:32 -0600
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-08 08:04 -0800
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-06 20:54 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-06 13:02 -0800
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-06 12:53 -0800
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-11-06 21:06 +0000
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-06 21:36 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-06 14:06 -0800
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-07 00:39 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-06 18:12 -0800
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-06 19:18 -0800
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-07 10:55 +0000
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-07 12:00 -0800
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-07 22:01 +0000
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-07 21:03 -0800
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-08 10:26 +0000
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-08 06:34 -0800
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-08 08:06 -0800
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-08 08:35 -0800
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-08 11:26 -0800
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-08 11:58 -0800
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-08 12:10 -0800
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-08 12:35 -0800
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-08 13:27 -0800
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-08 21:39 +0000
Re: usecases of void foo(char **b) {} supercat@casperkitty.com - 2016-11-08 13:55 -0800
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-08 16:44 -0800
Re: usecases of void foo(char **b) {} Gareth Owen <gwowen@gmail.com> - 2016-11-07 18:54 +0000
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-06 13:27 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-06 12:59 -0800
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-06 21:35 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-06 13:56 -0800
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-06 22:01 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-06 14:33 -0800
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-06 14:08 -0800
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-06 22:32 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-06 23:00 +0000
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-07 01:02 +0000
Re: usecases of void foo(char **b) {} Ian Collins <ian-news@hotmail.com> - 2016-11-05 12:16 +1300
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-05 01:32 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-04 19:13 -0700
Re: usecases of void foo(char **b) {} Ian Collins <ian-news@hotmail.com> - 2016-11-05 16:34 +1300
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-05 11:29 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-05 14:09 -0700
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-04 20:49 +0000
Re: usecases of void foo(char **b) {} asetofsymbols@gmail.com - 2016-11-05 02:06 -0700
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-04 09:05 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-04 17:05 +0000
Re: usecases of void foo(char **b) {} asetofsymbols@gmail.com - 2016-11-03 15:08 -0700
Re: usecases of void foo(char **b) {} Gareth Owen <gwowen@gmail.com> - 2016-11-03 20:21 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-03 20:35 +0000
Re: usecases of void foo(char **b) {} Gareth Owen <gwowen@gmail.com> - 2016-11-03 21:47 +0000
Re: usecases of void foo(char **b) {} Gareth Owen <gwowen@gmail.com> - 2016-11-03 21:48 +0000
Re: usecases of void foo(char **b) {} John Bode <jfbode1029@gmail.com> - 2016-11-03 08:02 -0700
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-03 18:09 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-03 18:48 +0000
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-03 19:53 +0000
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-03 20:52 +0000
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-03 23:09 +0000
Re: usecases of void foo(char **b) {} John Bode <jfbode1029@gmail.com> - 2016-11-04 07:08 -0700
Re: usecases of void foo(char **b) {} James Kuyper <jameskuyper@verizon.net> - 2016-11-03 22:24 -0400
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-01 11:50 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-11-01 16:28 +0000
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-01 05:07 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-01 05:18 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-01 05:30 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-11-01 05:38 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-10-31 16:47 -0700
Re: usecases of void foo(char **b) {} "Pascal J. Bourguignon" <pjb@informatimago.com> - 2016-11-05 04:11 +0100
Re: usecases of void foo(char **b) {} Ben Bacarisse <ben.usenet@bsb.me.uk> - 2016-11-05 10:48 +0000
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-05 14:06 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-10-31 17:38 +0000
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-10-31 17:44 +0000
Re: usecases of void foo(char **b) {} "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2016-10-31 11:04 -0700
Re: usecases of void foo(char **b) {} BartC <bc@freeuk.com> - 2016-10-31 19:12 +0000
Re: usecases of void foo(char **b) {} Richard Heathfield <rjh@cpax.org.uk> - 2016-10-31 19:18 +0000
Re: usecases of void foo(char **b) {} "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2016-10-31 10:53 -0700
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-11-01 08:25 -0700
Re: usecases of void foo(char **b) {} Keith Thompson <kst-u@mib.org> - 2016-10-31 08:05 -0700
Re: usecases of void foo(char **b) {} John Bode <jfbode1029@gmail.com> - 2016-10-31 08:27 -0700
Re: usecases of void foo(char **b) {} John Bode <jfbode1029@gmail.com> - 2016-10-31 07:59 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-10-31 10:36 -0700
Re: usecases of void foo(char **b) {} John Bode <jfbode1029@gmail.com> - 2016-10-31 11:36 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-10-31 12:12 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-10-31 12:59 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-10-31 13:27 -0700
Re: usecases of void foo(char **b) {} fir <profesor.fir@gmail.com> - 2016-10-31 13:40 -0700
Re: usecases of void foo(char **b) {} Thiago Adams <thiago.adams@gmail.com> - 2016-11-03 03:58 -0700
Page 5 of 21 — ← Prev page 1 … 3 4 [5] 6 7 … 21 Next page →
| From | Tim Rentsch <txr@alumni.caltech.edu> |
|---|---|
| Date | 2016-11-02 12:53 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <kfnzilhmzf8.fsf@x-alumni2.alumni.caltech.edu> |
| In reply to | #95555 |
John Bode <jfbode1029@gmail.com> writes: > Goddamned cdecl has rotted everyone's brains. Not mine! I don't use it. :) >> -- >> Bartc Can you fix your newsreader so that it doesn't include the quoted signature blocks? It would be much appreciated.
[toc] | [prev] | [next] | [standalone]
| From | Keith Thompson <kst-u@mib.org> |
|---|---|
| Date | 2016-11-01 16:39 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <lnd1ie3h46.fsf@kst-u.example.com> |
| In reply to | #95547 |
BartC <bc@freeuk.com> writes:
> On 01/11/2016 20:10, Keith Thompson wrote:
>> BartC <bc@freeuk.com> writes:
>
>>> But, to throw in something more concrete, imagine there purpose of all
>>> this is to end up with the value of the expression in a register, while
>>> all objects with storage reside in memory.
>>
>> "You're getting bogged down in what likely happens in a real machine."
>
> I'm tryin to find something to say that will stop you saying 'almost
> certainly no code is likely to be generated'.
Why do you object to my saying that, when it happens to be true?
But since it matters to you, you can just ask me about what happens in
the abstract machine, ignoring optimizations.
[...]
>>> The point of the example is that it is possible, without knowing exactly
>>> what machine this is to be run on, to see that A, B, C and D each
>>> involve progressively more data memory accesses, from 0 to 3.
>>
>> Now you've moved the goalposts from "dereferences" to "data memory
>> accesses".
>
> What's the difference?
I don't know. It depends on what you mean by "dereference". I've
already told you my objections to the way you use the word.
>> I don't see any non-trivial point in what you've said so far.
>
> You've snipped my set of likely load operations that correspond to
> each of the memory access levels I listed:
>
> load R, A # A;
> load R, [B] # B;
> load R, [C]; load R,[R] # *C;
> load R, [D]; load R,[R]; load R,[R] # **D;
>
> To me, knowing what goes on at this level is absolutely essential,
> both for implementing this kind of language (which I've done many
> times) and for trying to understand what C gets up to (for the
> purposes of interfacing to it or for using it to emulate the behaviour
> of another language).
To me, knowing what goes on at this level is not particularly useful in
most cases. I might potentially compile and run the same code in
x86_64, x86, SPARC, MIPS, or ARM, and I don't know any of those
architectures nearly as well as I know C. If you want to know the
details of what happens on the machine level, you're asking the wrong
person in the wrong forum.
Upthread, the declarations were:
enum {A};
int B;
int *C;
int **D;
and the statements you presented were:
A; // no dereference (immediate load)
B; // one implicit deref (equating to *&B)
*C; // one explicit deref
**D; // two explicit derefs
Assuming everything is initialized and all pointers are non-null, and
assuming no optimization, what happens in the C abstract machine is:
A constant of type int with value 0 is evaluated and discarded.
The current value of the int object B is evaluated and the result is
discarded.
The current value of the int* object C is evaluated, then
dereferenced to yield the value of the int object it points to.
That value is then discarded.
The current value of the int** object D is evaluated. That value is
dereferenced to yield the value of the int* object that D points to.
*That* value is then dereferenced to yield the value of the int
object that it points to. The resulting int value is then
discarded.
If you find it easier to talk about that in terms of "load" operations,
feel free. I don't.
Richard already addressed the rest of your post, which consists of code
snippets that cannot reasonably be understood without seeing the
relevant declarations.
Yes, that's right, you can't know what A[i][j] means without seeing the
declarations of A, i, and j.
[...]
> And you're the one of accusing *ME* of trying to sow confusion!
Yes.
--
Keith Thompson (The_Other_Keith) kst-u@mib.org <http://www.ghoti.net/~kst>
Working, but not speaking, for JetHead Development, Inc.
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2016-11-01 16:55 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <4b008cb8-2691-4e65-b725-3acddda41eb7@googlegroups.com> |
| In reply to | #95556 |
> Yes, that's right, you can't know what A[i][j] means without seeing the > declarations of A, i, and j. > this property of c that its syntax change on types / is type dependant is good... imo c should evolve yet more in this way imagine for example that [ and ] coud work differently dependant on the type i mean if i is integer this is array indexing but if i is float it may be something other.. - this way one could build very capacious syntax (probably much more than it is capacious tday) - and not necessary hard to read/encode if programmer get ussed to it oposite things are typeholes, this is when you see damn f(char*p) but you dont know what it is really used to and must spay probably on some code 9when type could be hust provided) which is bad
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2016-11-02 02:21 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <d65a860f-bf95-4efe-bf0e-bf1e0f779653@googlegroups.com> |
| In reply to | #95557 |
W dniu środa, 2 listopada 2016 00:55:46 UTC+1 użytkownik fir napisał: if programmer get ussed to it > > oposite things are typeholes, this is when you see damn f(char*p) but you dont know what it is really used to and must spay probably on some code 9when type could be hust provided) which is bad worth noting even f(char*p) opens a typehole of a couple of usecases (say like five or so (it may be adress for x-size block to read, it may be pointer to one char, it may be pointer to null-ended string, it may be pointer for something to write etc) i am as i say not even sure for what typehole opens foo(char**p) - [typeholes are like a gates of chaos where evil comes*] * i was thinking on this recently, and it s probably becouse if you talk about concise type it is concise type, when you think on hole, hole is not concise (until probably doin a very lot of mind work - more is hard to say) (fir)
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2016-11-02 05:02 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <a3d88af0-8234-4284-8656-daaaf98f307b@googlegroups.com> |
| In reply to | #95570 |
W dniu środa, 2 listopada 2016 10:22:01 UTC+1 użytkownik fir napisał: > W dniu środa, 2 listopada 2016 00:55:46 UTC+1 użytkownik fir napisał: > if programmer get ussed to it > > > > oposite things are typeholes, this is when you see damn f(char*p) but you dont know what it is really used to and must spay probably on some code 9when type could be hust provided) which is bad > > worth noting even f(char*p) opens a typehole of a couple of usecases (say like five or so (it may be adress for x-size block to read, it may be pointer to one char, it may be pointer to null-ended string, it may be pointer for something to write etc) i am as i say not even sure for what typehole opens foo(char**p) - [typeholes are like a gates of chaos where evil comes*] > > * i was thinking on this recently, and it s probably becouse if you talk about concise type it is concise type, when you think on hole, hole is not concise (until probably doin a very lot of mind work - more is hard to say) > > (fir) so if somebody will ask you what is that: char *b and what is that: char** b tell him "the first is a "smaller gate of chaos" and the second is "bigger gate of chaos""
[toc] | [prev] | [next] | [standalone]
| From | BartC <bc@freeuk.com> |
|---|---|
| Date | 2016-11-02 12:58 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <nvcnsa$tmm$1@dont-email.me> |
| In reply to | #95574 |
On 02/11/2016 12:02, fir wrote: > W dniu środa, 2 listopada 2016 10:22:01 UTC+1 użytkownik fir napisał: >> W dniu środa, 2 listopada 2016 00:55:46 UTC+1 użytkownik fir napisał: >> if programmer get ussed to it >>> >>> oposite things are typeholes, this is when you see damn f(char*p) but you dont know what it is really used to and must spay probably on some code 9when type could be hust provided) which is bad >> >> worth noting even f(char*p) opens a typehole of a couple of usecases (say like five or so (it may be adress for x-size block to read, it may be pointer to one char, it may be pointer to null-ended string, it may be pointer for something to write etc) i am as i say not even sure for what typehole opens foo(char**p) - [typeholes are like a gates of chaos where evil comes*] >> >> * i was thinking on this recently, and it s probably becouse if you talk about concise type it is concise type, when you think on hole, hole is not concise (until probably doin a very lot of mind work - more is hard to say) >> >> (fir) > > so if somebody will ask you > > what is that: > char *b > and what is that: > char** b > > tell him "the first is a "smaller gate of chaos" and the second is "bigger gate of chaos"" char pointers aren't too bad. char* is commonly used to denote a string. char** can then be considered as a pointer to array of strings (or pointer to the first string of such an array). An actual array of strings would be char*[], but as a parameter type, it's interpreted as char** anyway. Of course, char** might simply be a pointer to a single string, or a char* array. ... On the other hand, you might be right. If char* and char** need so many qualifying statements, then 'chaos' might be more apt. (How I deal with char* and char**: http://pastebin.com/K8g8d3vx)
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2016-11-02 08:03 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <ee99ee20-106c-45e9-8687-2738e1c15806@googlegroups.com> |
| In reply to | #95577 |
W dniu środa, 2 listopada 2016 13:58:21 UTC+1 użytkownik Bart napisał: > On 02/11/2016 12:02, fir wrote: > > W dniu środa, 2 listopada 2016 10:22:01 UTC+1 użytkownik fir napisał: > >> W dniu środa, 2 listopada 2016 00:55:46 UTC+1 użytkownik fir napisał: > >> if programmer get ussed to it > >>> > >>> oposite things are typeholes, this is when you see damn f(char*p) but you dont know what it is really used to and must spay probably on some code 9when type could be hust provided) which is bad > >> > >> worth noting even f(char*p) opens a typehole of a couple of usecases (say like five or so (it may be adress for x-size block to read, it may be pointer to one char, it may be pointer to null-ended string, it may be pointer for something to write etc) i am as i say not even sure for what typehole opens foo(char**p) - [typeholes are like a gates of chaos where evil comes*] > >> > >> * i was thinking on this recently, and it s probably becouse if you talk about concise type it is concise type, when you think on hole, hole is not concise (until probably doin a very lot of mind work - more is hard to say) > >> > >> (fir) > > > > so if somebody will ask you > > > > what is that: > > char *b > > and what is that: > > char** b > > > > tell him "the first is a "smaller gate of chaos" and the second is "bigger gate of chaos"" > > char pointers aren't too bad. > they are bad (not /that/ bad thats becouse i call it /small/ gate of chaos) their badnes is masked by common convention of using its mainly for zero-ended literals, but they are rarelu used for few other cases and it may shows then they bad (ps to close the gate one could use what i said -> read char * x; //is only pointer on one char to read write char * x; //is only pointer on one char to write read write char * x; // pointer for one char to read write read can be default as function args so "char*" would be pointer one char to read, and for example read write would be default for globals and locals etc char[10] x; //array for 10 chars char[10]* x; //pointer for table of 10 chars not sure if read write attributes should be uset to pointers itself or only to destinations richt naw small gate of chaos opnes hole for such cases read char*, write char*, read write char*, read char[N]*, write char[N]*, read write char[N]*, read char[]*, write char[]*, read write char[]* [[and possibly more (becouse you could and maybe should type more here, like memory type "foo(heap write[]* x)" could mean you pass a pointer to memory that could be reallocked 9though you will most probably need "foo(heap write[]** x)" )]] for read char[]* i understand pointer for chunk of chars of undefined size (like null terminated literal string) > char* is commonly used to denote a string. > > char** can then be considered as a pointer to array of strings (or > pointer to the first string of such an array). > > An actual array of strings would be char*[], but as a parameter type, > it's interpreted as char** anyway. > > Of course, char** might simply be a pointer to a single string, or a > char* array. > > ... On the other hand, you might be right. If char* and char** need so > many qualifying statements, then 'chaos' might be more apt. > > (How I deal with char* and char**: http://pastebin.com/K8g8d3vx)
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2016-11-02 08:14 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <63d5e857-243f-4c14-ae49-430bec0fe485@googlegroups.com> |
| In reply to | #95588 |
W dniu środa, 2 listopada 2016 16:03:38 UTC+1 użytkownik fir napisał: > W dniu środa, 2 listopada 2016 13:58:21 UTC+1 użytkownik Bart napisał: > > On 02/11/2016 12:02, fir wrote: > > > W dniu środa, 2 listopada 2016 10:22:01 UTC+1 użytkownik fir napisał: > > >> W dniu środa, 2 listopada 2016 00:55:46 UTC+1 użytkownik fir napisał: > > >> if programmer get ussed to it > > >>> > > >>> oposite things are typeholes, this is when you see damn f(char*p) but you dont know what it is really used to and must spay probably on some code 9when type could be hust provided) which is bad > > >> > > >> worth noting even f(char*p) opens a typehole of a couple of usecases (say like five or so (it may be adress for x-size block to read, it may be pointer to one char, it may be pointer to null-ended string, it may be pointer for something to write etc) i am as i say not even sure for what typehole opens foo(char**p) - [typeholes are like a gates of chaos where evil comes*] > > >> > > >> * i was thinking on this recently, and it s probably becouse if you talk about concise type it is concise type, when you think on hole, hole is not concise (until probably doin a very lot of mind work - more is hard to say) > > >> > > >> (fir) > > > > > > so if somebody will ask you > > > > > > what is that: > > > char *b > > > and what is that: > > > char** b > > > > > > tell him "the first is a "smaller gate of chaos" and the second is "bigger gate of chaos"" > > > > char pointers aren't too bad. > > > > > > they are bad (not /that/ bad thats becouse i call it /small/ gate of chaos) > their badnes is masked by common convention of using its mainly for zero-ended literals, but they are rarelu used for few other cases and it may shows then they bad > > (ps > to close the gate one could use what i said -> > > read char * x; //is only pointer on one char to read > write char * x; //is only pointer on one char to write > read write char * x; // pointer for one char to read write > > read can be default as function args so "char*" would be > pointer one char to read, and for example read write would be default > for globals and locals etc > > > char[10] x; //array for 10 chars > char[10]* x; //pointer for table of 10 chars > > not sure if read write attributes should be uset to pointers itself or only to destinations > > richt naw small gate of chaos opnes hole for such cases > > read char*, write char*, read write char*, > read char[N]*, write char[N]*, read write char[N]*, > read char[]*, write char[]*, read write char[]* > > [[and possibly more (becouse you could and maybe should type more here, like memory type "foo(heap write[]* x)" could mean you pass a pointer to memory that could be reallocked 9though you will most probably need "foo(heap write[]** x)" )]] > > for read char[]* i understand pointer for chunk of chars of > undefined size (like null terminated literal string) > > > > > > > > char* is commonly used to denote a string. > > > > char** can then be considered as a pointer to array of strings (or > > pointer to the first string of such an array). > > > > An actual array of strings would be char*[], but as a parameter type, > > it's interpreted as char** anyway. > > > > Of course, char** might simply be a pointer to a single string, or a > > char* array. > > > > ... On the other hand, you might be right. If char* and char** need so > > many qualifying statements, then 'chaos' might be more apt. > > > > (How I deal with char* and char**: http://pastebin.com/K8g8d3vx) PS the core of this my joke is (i say it to make sure it is undetstood as it is good joke imo) tjat char*b REALLy isnt pointer to char and it really is "small gato of chaos" char* is realy small gate of chaos - c is founded around gates of chaos
[toc] | [prev] | [next] | [standalone]
| From | Keith Thompson <kst-u@mib.org> |
|---|---|
| Date | 2016-11-02 09:19 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <lnwpgl26sk.fsf@kst-u.example.com> |
| In reply to | #95577 |
BartC <bc@freeuk.com> writes:
[...]
> Of course, char** might simply be a pointer to a single string, or a
> char* array.
No. A char* can be a pointer to a string. A char** cannot be.
[...]
--
Keith Thompson (The_Other_Keith) kst-u@mib.org <http://www.ghoti.net/~kst>
Working, but not speaking, for JetHead Development, Inc.
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"
[toc] | [prev] | [next] | [standalone]
| From | BartC <bc@freeuk.com> |
|---|---|
| Date | 2016-11-02 17:54 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <nvd971$thl$1@dont-email.me> |
| In reply to | #95598 |
On 02/11/2016 16:19, Keith Thompson wrote: > BartC <bc@freeuk.com> writes: > [...] >> Of course, char** might simply be a pointer to a single string, or a >> char* array. > > No. A char* can be a pointer to a string. A char** cannot be. You snipped the bit where I said: > char* is commonly used to denote a string. Then char** must be a pointer to such a string. -- Bartc
[toc] | [prev] | [next] | [standalone]
| From | Keith Thompson <kst-u@mib.org> |
|---|---|
| Date | 2016-11-02 11:47 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <lnoa1x1zyx.fsf@kst-u.example.com> |
| In reply to | #95602 |
BartC <bc@freeuk.com> writes:
> On 02/11/2016 16:19, Keith Thompson wrote:
>> BartC <bc@freeuk.com> writes:
>> [...]
>>> Of course, char** might simply be a pointer to a single string, or a
>>> char* array.
>>
>> No. A char* can be a pointer to a string. A char** cannot be.
>
> You snipped the bit where I said:
>
> > char* is commonly used to denote a string.
>
> Then char** must be a pointer to such a string.
I skipped over that because I thought you were using the word "denote"
loosely.
A char* value is commonly used to *point to* a string. It is not
itself a string. A char** value cannot be a pointer to a string,
because a char* object cannot be a string.
By definition, a *string* is "a contiguous sequence of characters
terminated by and including the first null character", and a
*pointer to a string* is "a pointer to its initial (lowest addressed)
character" (N1570 7.1.1p1).
(Note that this is a specific definition of the phrase "pointer to
a string". It does not imply that a pointer to the initial element
of an array object is a pointer to the entire array.)
I reject any attempt to confuse matters by using the word "string"
or the phrase "pointer to a string" with other meanings.
--
Keith Thompson (The_Other_Keith) kst-u@mib.org <http://www.ghoti.net/~kst>
Working, but not speaking, for JetHead Development, Inc.
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"
[toc] | [prev] | [next] | [standalone]
| From | BartC <bc@freeuk.com> |
|---|---|
| Date | 2016-11-02 19:01 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <nvdd6c$e7j$1@dont-email.me> |
| In reply to | #95603 |
On 02/11/2016 18:47, Keith Thompson wrote: > BartC <bc@freeuk.com> writes: >> On 02/11/2016 16:19, Keith Thompson wrote: >>> BartC <bc@freeuk.com> writes: >>> [...] >>>> Of course, char** might simply be a pointer to a single string, or a >>>> char* array. >>> >>> No. A char* can be a pointer to a string. A char** cannot be. >> >> You snipped the bit where I said: >> >> > char* is commonly used to denote a string. >> >> Then char** must be a pointer to such a string. > > I skipped over that because I thought you were using the word "denote" > loosely. > > A char* value is commonly used to *point to* a string. It is not > itself a string. A char** value cannot be a pointer to a string, > because a char* object cannot be a string. > > By definition, a *string* is "a contiguous sequence of characters > terminated by and including the first null character", and a > *pointer to a string* is "a pointer to its initial (lowest addressed) > character" (N1570 7.1.1p1). > > (Note that this is a specific definition of the phrase "pointer to > a string". It does not imply that a pointer to the initial element > of an array object is a pointer to the entire array.) > > I reject any attempt to confuse matters by using the word "string" > or the phrase "pointer to a string" with other meanings. Again it seems to be me who's trying to make things less confusing, and you who's trying to stop me doing do. What proportion of C programmers actually read the C standard? And as a minutely as the regulars here? So constantly referring to that may not be helpful. What I was doing was similar to: typedef char* string; // pointer to zero-terminated sequence string s; // a string string* t; // a pointer to a string or a block of strings That's in place of: char* s; char** t; Which might mean the same as the above or they might not. Use of a specific term or a specific typedef signals some intention that is not present in a bare 'char*'. -- Bartc
[toc] | [prev] | [next] | [standalone]
| From | Keith Thompson <kst-u@mib.org> |
|---|---|
| Date | 2016-11-02 12:28 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <lnfun91y2a.fsf@kst-u.example.com> |
| In reply to | #95605 |
BartC <bc@freeuk.com> writes:
> On 02/11/2016 18:47, Keith Thompson wrote:
[...]
>> I reject any attempt to confuse matters by using the word "string"
>> or the phrase "pointer to a string" with other meanings.
>
> Again it seems to be me who's trying to make things less confusing, and
> you who's trying to stop me doing do.
>
> What proportion of C programmers actually read the C standard? And as a
> minutely as the regulars here? So constantly referring to that may not
> be helpful.
I don't know how many C programmers read the standard. But when I quote
what the standard says about strings, almost all of them are capable of
understanding it and accepting it. You are a notable exception.
> What I was doing was similar to:
>
> typedef char* string; // pointer to zero-terminated sequence
I understand that that typedef is common. I dislike it, because, once
again, a char* can be a pointer to a string, but it cannot be a string.
> string s; // a string
> string* t; // a pointer to a string or a block of strings
>
> That's in place of:
>
> char* s;
> char** t;
>
> Which might mean the same as the above or they might not. Use of a
> specific term or a specific typedef signals some intention that is not
> present in a bare 'char*'.
Perhaps you'd accept
typedef char *string_pointer;
I wouldn't use it myself (I'd just use char* and figure out from context
whether it's intended to point to a string), but it's less objectionable
than `typedef char* string;`.
--
Keith Thompson (The_Other_Keith) kst-u@mib.org <http://www.ghoti.net/~kst>
Working, but not speaking, for JetHead Development, Inc.
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"
[toc] | [prev] | [next] | [standalone]
| From | Tim Rentsch <txr@alumni.caltech.edu> |
|---|---|
| Date | 2016-11-12 13:36 -0800 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <kfnfumwv0ry.fsf@x-alumni2.alumni.caltech.edu> |
| In reply to | #95609 |
Keith Thompson <kst-u@mib.org> writes: > BartC <bc@freeuk.com> writes: >> On 02/11/2016 18:47, Keith Thompson wrote: > > [...] > >> What I was doing was similar to: >> >> typedef char* string; // pointer to zero-terminated sequence > > I understand that that typedef is common. I dislike it, because, once > again, a char* can be a pointer to a string, but it cannot be a string. I have a different reaction. I think string (or String) is a fine type name for places where (char *) or (const char *) is used to designate a null-terminated character array. I should add though that I am used to languages or interfaces that use reference semantics, where variables are not "things" but rather are "pointers to things", also sometimes referred to as "handles" rather than "pointers". (Note: not exclusively - I'm also used to regular C programming, which typically uses value semantics and not reference semantics.) Seen from this perspective, I think string or String is a quite appropriate name, and not a misleading one.
[toc] | [prev] | [next] | [standalone]
| From | Ian Collins <ian-news@hotmail.com> |
|---|---|
| Date | 2016-11-13 11:07 +1300 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <e8pi5fF4om6U1@mid.individual.net> |
| In reply to | #96430 |
On 11/13/16 10:36 AM, Tim Rentsch wrote: > Keith Thompson <kst-u@mib.org> writes: > >> BartC <bc@freeuk.com> writes: >>> On 02/11/2016 18:47, Keith Thompson wrote: >> >> [...] >> >>> What I was doing was similar to: >>> >>> typedef char* string; // pointer to zero-terminated sequence >> >> I understand that that typedef is common. I dislike it, because, once >> again, a char* can be a pointer to a string, but it cannot be a string. > > I have a different reaction. I think string (or String) is a > fine type name for places where (char *) or (const char *) is > used to designate a null-terminated character array. I should > add though that I am used to languages or interfaces that use > uses , where variables are not "things" but rather > are "pointers to things", also sometimes referred to as "handles" > rather than "pointers". (Note: not exclusively - I'm also used > to regular C programming, which typically uses value semantics > and not reference semantics.) > > Seen from this perspective, I think string or String is a quite > appropriate name, and not a misleading one. But surely even form that perspective it is misleading? I can't think of a language that uses reference semantics where something like String a = "abc"; String b = a; b[1] = 'e'; Would change both a and b. A char* does not behave like a string object. -- Ian
[toc] | [prev] | [next] | [standalone]
| From | BartC <bc@freeuk.com> |
|---|---|
| Date | 2016-11-12 22:27 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <o08502$pmh$1@dont-email.me> |
| In reply to | #96434 |
On 12/11/2016 22:07, Ian Collins wrote: > On 11/13/16 10:36 AM, Tim Rentsch wrote: >> Seen from this perspective, I think string or String is a quite >> appropriate name, and not a misleading one. > > But surely even form that perspective it is misleading? I can't think > of a language that uses reference semantics where something like > > String a = "abc"; > String b = a; > > b[1] = 'e'; > > Would change both a and b. > > A char* does not behave like a string object. What string object? Such a thing doesn't exist in C, at least not with the behaviour you seem to expect. Here a and b refer to the same string. That happens in Python: a = ["a","b","c"] b = a b[1] = "e" print (a) print (b) Both a and b refer to the same object, and both are changed. Except I had to use a list as Python strings, while shared, are not mutable. (I tried this on my own dynamic language, where strings are shared /and/ mutable. But an extra complication means that only b is changed. (Because 'a' and 'b' point to the same read-only string constant, an attempt to modify b triggers a copy-on-write, but only for b. Probably I will have to do something about that to minimise unexpected behaviours. And actually your example as it is will likely crash in C for related reasons.) -- Bartc
[toc] | [prev] | [next] | [standalone]
| From | Keith Thompson <kst-u@mib.org> |
|---|---|
| Date | 2016-11-12 14:49 -0800 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <lnlgwol3ec.fsf@kst-u.example.com> |
| In reply to | #96436 |
BartC <bc@freeuk.com> writes:
> On 12/11/2016 22:07, Ian Collins wrote:
>> On 11/13/16 10:36 AM, Tim Rentsch wrote:
>
>>> Seen from this perspective, I think string or String is a quite
>>> appropriate name, and not a misleading one.
>>
>> But surely even form that perspective it is misleading? I can't think
>> of a language that uses reference semantics where something like
>>
>> String a = "abc";
>> String b = a;
>>
>> b[1] = 'e';
>>
>> Would change both a and b.
>>
>> A char* does not behave like a string object.
>
> What string object? Such a thing doesn't exist in C, at least not with
> the behaviour you seem to expect. Here a and b refer to the same string.
Ok, not a string object, but an array object that contains a string.
[...]
> And actually your example as it is will likely crash in C for related
> reasons.)
True.
--
Keith Thompson (The_Other_Keith) kst-u@mib.org <http://www.ghoti.net/~kst>
Working, but not speaking, for JetHead Development, Inc.
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"
[toc] | [prev] | [next] | [standalone]
| From | Tim Rentsch <txr@alumni.caltech.edu> |
|---|---|
| Date | 2016-11-15 10:23 -0800 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <kfn4m38txeu.fsf@x-alumni2.alumni.caltech.edu> |
| In reply to | #96434 |
Ian Collins <ian-news@hotmail.com> writes:
> On 11/13/16 10:36 AM, Tim Rentsch wrote:
>> Keith Thompson <kst-u@mib.org> writes:
>>
>>> BartC <bc@freeuk.com> writes:
>>>> On 02/11/2016 18:47, Keith Thompson wrote:
>>>
>>> [...]
>>>
>>>> What I was doing was similar to:
>>>>
>>>> typedef char* string; // pointer to zero-terminated sequence
>>>
>>> I understand that that typedef is common. I dislike it, because, once
>>> again, a char* can be a pointer to a string, but it cannot be a string.
>>
>> I have a different reaction. I think string (or String) is a
>> fine type name for places where (char *) or (const char *) is
>> used to designate a null-terminated character array. I should
>> add though that I am used to languages or interfaces that use
>> uses , where variables are not "things" but rather
>> are "pointers to things", also sometimes referred to as "handles"
>> rather than "pointers". (Note: not exclusively - I'm also used
>> to regular C programming, which typically uses value semantics
>> and not reference semantics.)
>>
>> Seen from this perspective, I think string or String is a quite
>> appropriate name, and not a misleading one.
>
> But surely even form that perspective it is misleading? I can't think
> of a language that uses reference semantics where something like
>
> String a = "abc";
> String b = a;
>
> b[1] = 'e';
>
> Would change both a and b.
Your experience must be very different from mine. To me that is
what reference semantics means, that assignment doesn't copy
the value but rather copies (what is in effect) a pointer, so
that the value is shared. Offhand I can't think of a language
that has reference semantics that does NOT change both a and
b in such cases.
> A char* does not behave like a string object.
Right, it doesn't. It behaves like a pointer, or reference, to a
shared something. That's what "reference semantics" means, as I
am used to using the term. I searched for "reference semantics"
and found this:
Reference Semantics Explained
In a nutshell, reference semantics can be understood by the
following analogy: If I give you a URL, I provide you with
a reference to a web page. You, I and the owner of the web
page can access that web page with that URL. And if the
owner changes the content, then you will see these changes
next time you connect to the URL.
Contrarily, if I print out the web page and give you that
print out, then I provide you with a disconnected copy of the
web page. You may modify that copy (e.g. by highlighting
passages with a marker), but I will not see these changes, nor
will you see changes made in the original page by the owner.
This is value semantics.
This explanation matches my usage. Maybe C++ uses the terms
differently?
[toc] | [prev] | [next] | [standalone]
| From | Keith Thompson <kst-u@mib.org> |
|---|---|
| Date | 2016-11-12 14:47 -0800 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <lnpom0l3he.fsf@kst-u.example.com> |
| In reply to | #96430 |
Tim Rentsch <txr@alumni.caltech.edu> writes:
> Keith Thompson <kst-u@mib.org> writes:
>
>> BartC <bc@freeuk.com> writes:
>>> On 02/11/2016 18:47, Keith Thompson wrote:
>>
>> [...]
>>
>>> What I was doing was similar to:
>>>
>>> typedef char* string; // pointer to zero-terminated sequence
>>
>> I understand that that typedef is common. I dislike it, because, once
>> again, a char* can be a pointer to a string, but it cannot be a string.
>
> I have a different reaction. I think string (or String) is a
> fine type name for places where (char *) or (const char *) is
> used to designate a null-terminated character array.
As you of course know, a char* or const char* doesn't designate a
string, it points to it.
[...]
--
Keith Thompson (The_Other_Keith) kst-u@mib.org <http://www.ghoti.net/~kst>
Working, but not speaking, for JetHead Development, Inc.
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"
[toc] | [prev] | [next] | [standalone]
| From | Tim Rentsch <txr@alumni.caltech.edu> |
|---|---|
| Date | 2016-11-15 10:05 -0800 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <kfn8tskty8e.fsf@x-alumni2.alumni.caltech.edu> |
| In reply to | #96440 |
Keith Thompson <kst-u@mib.org> writes: > Tim Rentsch <txr@alumni.caltech.edu> writes: >> Keith Thompson <kst-u@mib.org> writes: >> >>> BartC <bc@freeuk.com> writes: >>>> On 02/11/2016 18:47, Keith Thompson wrote: >>> >>> [...] >>> >>>> What I was doing was similar to: >>>> >>>> typedef char* string; // pointer to zero-terminated sequence >>> >>> I understand that that typedef is common. I dislike it, because, once >>> again, a char* can be a pointer to a string, but it cannot be a string. >> >> I have a different reaction. I think string (or String) is a >> fine type name for places where (char *) or (const char *) is >> used to designate a null-terminated character array. > > As you of course know, a char* or const char* doesn't designate a > string, it points to it. Oh sorry, I meant designate more in a regular English sense, not the sense that it it used in the Standard. "Refer to" probably would have been better.
[toc] | [prev] | [next] | [standalone]
Page 5 of 21 — ← Prev page 1 … 3 4 [5] 6 7 … 21 Next page →
Back to top | Article view | comp.lang.c
csiph-web