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 12 of 21 — ← Prev page 1 … 10 11 [12] 13 14 … 21 Next page →
| From | BartC <bc@freeuk.com> |
|---|---|
| Date | 2016-11-03 21:58 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <nvgbtm$2cn$1@dont-email.me> |
| In reply to | #95697 |
On 03/11/2016 20:55, John Bode wrote: > On Thursday, November 3, 2016 at 3:26:33 PM UTC-5, Bart wrote: >> That was a nonsense type-spec, this is a real one (translated to C): >> >> pcptr = (*(int * (**) (void))pcptr)(); >> >> This includes an assignment, dereference, cast and function call, but >> which bit is which? > > (int *(**)(void)) pcptr is the cast operation. It casts pcptr to type > pointer to pointer to function taking void and returning pointer to int. > > *(int *(**)(void)) pcptr is the dereference. The result of the > dereference is a pointer to a function taking void and returning pointer > to int. > > (*(int *(**)(void)) pcptr)() is the function call, executed via the pointer > value evaluated above. > > pcptr = (*(int *(**)(void))pcptr)() is the assignment. > > Not sure about the validity of it, though - are we treating pcptr as both > a pointer to an int and a pointer to a function? That seems...wrong, > somehow. (There is an array of values (which is to do with byte-code instructions) where each element is a pointer to a function (the handler for a byte-code), or an operand. pcptr is a pointer into that array. The handler function being called returns a pointer to the next instruction in the array. The example above was generated for 32 bits - the int is really int32_t - which accommodates both pointers and operands. Maybe an array of unions is a better solution but this cast method works fine.) -- Bartc
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2016-11-03 19:46 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <87twboiby9.fsf@bsb.me.uk> |
| In reply to | #95677 |
BartC <bc@freeuk.com> writes: <snip stuff on reading C types> > ... But, what happens above where there > is no name in the declaration? As in: > > (char (*(*[3])())[5]) I'm wondering if that's a serious question? Assuming it is, I'll take a stan at answering it: you look for the place where the name would go in a similar declaration. There will always be only one such place or the type name (it's no longer a declaration when you remove the name) is a syntax error. Here it's obvious because '*[' always means a name is missing. To my eyes it's obvious in every other case I've actually had to deal with as well, but I accept that I may not be typical in this regard. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | "Mr. Man-wai Chang" <toylet.toylet@gmail.com> |
|---|---|
| Date | 2016-11-04 02:46 +0800 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <nvg0kf$m6e$1@dont-email.me> |
| In reply to | #95672 |
On 4/11/2016 2:18 AM, Richard Heathfield wrote: > I hope (but do not trust) that Usenet will preserve the spacing > correctly. Use a fixed-pitch font (or "Show Original" in GG). > > ^ = up, > = right, V = down, < = left > > Start with the declaration, and then spiral clockwise, starting by going > up (or, in the southern hemisphere, spiral anticlockwise and start by > going down): I didn't know that. Did I miss a page from The C Programming Language First Edition? :)
[toc] | [prev] | [next] | [standalone]
| From | "Mr. Man-wai Chang" <toylet.toylet@gmail.com> |
|---|---|
| Date | 2016-11-04 11:59 +0800 |
| Subject | [OT] |
| Message-ID | <nvh11e$2lq$1@dont-email.me> |
| In reply to | #95672 |
On 4/11/2016 2:18 AM, Richard Heathfield wrote: > > ... The way to do it is to read it boustrophedonically..... > >>>>>>>>>>>>>>>>>>>>>>>V > ^ V > ^ >>>>>>>>>>>>V V > ^ ^ V V > ^ ^ >>>>V V V > ^ ^ ^ V V V > char (* (* x [3]) ( ) ) [5] > ^ ^ ^ V V V > ^ ^ ^<<<<<<< V V > ^ ^ V V > ^ ^<<<<<<<<<<<<<<<< V > ^ V > ^<<<<<<<<<<<<<<<<<<<<<<<<<<<< BTW, this is a spiral, a clockwise one!
[toc] | [prev] | [next] | [standalone]
| From | Keith Thompson <kst-u@mib.org> |
|---|---|
| Date | 2016-11-03 12:14 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <ln37j8z882.fsf@kst-u.example.com> |
| In reply to | #95668 |
BartC <bc@freeuk.com> writes:
> On 03/11/2016 17:14, Richard Heathfield wrote:
>> On 03/11/16 16:43, BartC wrote:
>
>>> It doesn't matter what it is. You can just read it. Like reading
>>> something in English without using a translator or having to learn a new
>>> language.
>>
>> Actually, I couldn't read it, and needed supercat's translation in order
>> to understand it.
>
> I don't believe you. "Array[0..5] of Integer"? Come on!
>
> The big difference from C is that a declaration is linear; it's not
> nested like an expression, requiring to jump forwards and backwards
> within it, and with the name of whatever is being declared buried
> somewhere inside.
>
> THAT is what makes C hard; take that away and you can usually figure out
> whatever syntax is being used.
Take that away and you have something that your compiler will reject
(or, if you're unlucky, interpret correctly but not in the way you
intended). Have fun with that.
--
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 | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2016-11-03 15:27 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <87a8dgk2i5.fsf@bsb.me.uk> |
| In reply to | #95638 |
BartC <bc@freeuk.com> writes: > On 03/11/2016 06:07, Gareth Owen wrote: >> BartC <bc@freeuk.com> writes: >> >>> I am not however spreading disinformation just because my view of C is >>> wider than your narrow one. >> >> Have you considered, even for a second, the possibility that you might >> be wrong? >> > > Go back and show me what I said that was wrong. I'd decided to duck out of the thread, but since it's your denial of my claim that Gareth is questioning, I feel I should clarify. First, Gareth is not saying you said anything wrong in posts that are up-thread. (He may have intended to say that -- I don't know --- but he didn't say it.) He is saying you may be wrong to deny that you are spreading disinformation. So what is the disinformation that you are spreading, the denial of which Gareth thinks you might be wrong about? It is that you posted three pars of C expressions: (*P).m vs. P->m, (*A)[i] vs. A[i] and (*F)(a) vs. F(a). You go on to say that the if the syntax for the first had not needed the parentheses, the second form would probably not have been invented. That's absurd. Of course the normal pointer indexing syntax A[i] would have evolved, no matter how simple the syntax to dereference a pointer to an array had been. That's because the array pair in your trio is quite different from the others. Unlike the other two, A[i] is not a simplified syntax invented to avoid having to write (*A)[i]. The other two pairs *are*, essentially, just syntactic simplifications. The array one isn't, and never has been. The two expressions mean entirely different things. > And without having to resort to saying that 6.17.348p4 defines such > and such a word differently, therefore my entire argument is invalid. > > It seems 'pointers to arrays' simply do not exist in C as far as Ben > Bacarisse is concerned. Or if he grudgingly admits they might, then > they are still dismissed as irrelevant. How on earth do you come up with these ideas? I've posted about them numerous times and they crop up all the time when dealing 2D arrays, and I've posted on that topic several times. > Yet I use them in C and they work. That's hardly surprising. They've been in C since prehistoric times, so of course they work. You can't even properly explain indexing int m[3][3]; without them. <snip> -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Keith Thompson <kst-u@mib.org> |
|---|---|
| Date | 2016-11-03 08:45 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <lnshr8zhx1.fsf@kst-u.example.com> |
| In reply to | #95638 |
BartC <bc@freeuk.com> writes:
> On 03/11/2016 06:07, Gareth Owen wrote:
>> BartC <bc@freeuk.com> writes:
>>> I am not however spreading disinformation just because my view of C is
>>> wider than your narrow one.
>>
>> Have you considered, even for a second, the possibility that you might
>> be wrong?
>
> Go back and show me what I said that was wrong.
We've been trying.
> And without having to resort to saying that 6.17.348p4 defines such and
> such a word differently, therefore my entire argument is invalid.
Do you not accept the C standard as an authority on the language? What
evidence would you accept?
> It seems 'pointers to arrays' simply do not exist in C as far as Ben
> Bacarisse is concerned.
This kind of nonsense is what makes discussing things with you so
frustrating. *Of course* pointers to array exist.
> Or if he grudgingly admits they might, then they
> are still dismissed as irrelevant.
They're not irrelevant. It just happens to be more convenient to
manipulate arrays via pointers to their elements.
> Yet I use them in C and they work. I implement the concept in other
> languages and they work even better. I really doubt whether I'm wrong.
> It seems the 'pointer to first element of array' idiom is so ingrained
> with the regulars that the possibility of doing it any other way is
> inconceivable.
Nonsense. The possibility of doing it differently is perfectly
conceivable. A lot of us have worked in languages other than C that
have more direct support for operations on arrays than C does.
(Implementations of those languages are often written in C, BTW.) And
you *can* use pointers to arrays in C if you really want to; nobody will
stop you. But decades of experience by thousands of C programmers have
indicated that using pointers to array elements is more convenient.
Here's an example of two functions that print the values of the elements
of an array object. func0() is what I would call idiomatic C; it takes
a pointer to the array's initial element. func1() is what I presume is
how you would prefer to do it; it takes a pointer to the entire array
(as a pointer to an incomplete array type). Again, nobody will stop you
from writing func1() -- but the func0() style works just as well and is
easier to work with *once you understand the idiom*.
#include <stdio.h>
void func0(int *ptr, size_t size) {
for (size_t i = 0; i < size; i ++) {
printf(" %d", ptr[i]);
}
putchar('\n');
}
void func1(int (*ptr)[], size_t size) {
for (size_t i = 0; i < size; i ++) {
printf(" %d", (*ptr)[i]);
}
putchar('\n');
}
int main(void) {
int array_object[] = { 10, 20, 30 };
size_t len = sizeof array_object / sizeof array_object[0];
func0(array_object, len);
func1(&array_object, len);
}
Do you think func1() is better than func0()? Why?
> (I was constantly being told I was simply wrong about C's 'for'
> statement, and now it seems that the authors of Rust feel exactly the
> same way. Therefore they must be wrong too.)
Your statement about C's "for" statement, if I recall correctly,
was an opinion, and of course you're entitled to that opinion.
The authors of Rust apparently agree, at least in part, with your
opinion -- and that's fine too. But the *fact* is that C programmers
are able to use its "for" statement successfully. You don't like it.
That's fine. I completely agree that you don't like 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 | BartC <bc@freeuk.com> |
|---|---|
| Date | 2016-11-03 16:33 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <nvfor6$nv8$1@dont-email.me> |
| In reply to | #95655 |
On 03/11/2016 15:45, Keith Thompson wrote:
> BartC <bc@freeuk.com> writes:
> Here's an example of two functions that print the values of the elements
> of an array object. func0() is what I would call idiomatic C; it takes
> a pointer to the array's initial element. func1() is what I presume is
> how you would prefer to do it; it takes a pointer to the entire array
> (as a pointer to an incomplete array type). Again, nobody will stop you
> from writing func1() -- but the func0() style works just as well and is
> easier to work with *once you understand the idiom*.
>
> #include <stdio.h>
>
> void func0(int *ptr, size_t size) {
> for (size_t i = 0; i < size; i ++) {
> printf(" %d", ptr[i]);
> }
> putchar('\n');
> }
>
> void func1(int (*ptr)[], size_t size) {
> for (size_t i = 0; i < size; i ++) {
> printf(" %d", (*ptr)[i]);
> }
> putchar('\n');
> }
>
> int main(void) {
> int array_object[] = { 10, 20, 30 };
> size_t len = sizeof array_object / sizeof array_object[0];
> func0(array_object, len);
> func1(&array_object, len);
> }
>
> Do you think func1() is better than func0()? Why?
(*) The data being passed is in an array. func1 passes a pointer to the
ARRAY so you know immediately that an array is being operated on
and not some individual int. func0 loses information in that regard.
(*) The main parameter type of func1 exactly reflects the data structure
that is being passed, unlike the parameter type of func0.
(*) func1 includes the term (*ptr)[i] so you know just from this line
that a pointer to array is involved. With func0, it could a normal
array, or it could be pointer to any block of memory. With func1,
the operation is completely transparent.
(*) Given 'int foo;', I can pass &foo to func0. But if I try that with
func1, I get a warning (from gcc)
The only thing bad about func1 is the extra syntax required. The "*" is
necessary to keep the transparency and make the interface and operation
on the data exactly match the task that is being done, rather than the
more roundabout way in func0.
The extra "()" are the subject of this sub-thread which I think was
originally brought up by supercat. With a postfix "*", func1 could have
looked like this (I've taken the liberty of altering the parameter
declaration to match the postfix *):
void func1(int ptr*[], size_t size) {
for (size_t i = 0; i < size; i ++) {
printf(" %d", ptr*[i]);
}
putchar('\n');
}
It's got two extra "*" compared with func0, but for that you get all
those advantages.
--
Bartc
[toc] | [prev] | [next] | [standalone]
| From | supercat@casperkitty.com |
|---|---|
| Date | 2016-11-03 09:57 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <2744bc97-585b-46c5-a42f-c2fa141cbf1f@googlegroups.com> |
| In reply to | #95662 |
On Thursday, November 3, 2016 at 11:33:13 AM UTC-5, Bart wrote:
> The extra "()" are the subject of this sub-thread which I think was
> originally brought up by supercat. With a postfix "*", func1 could have
> looked like this (I've taken the liberty of altering the parameter
> declaration to match the postfix *):
>
> void func1(int ptr*[], size_t size) {
Another place where C syntax is quirkier than many other languages is that
other languages place everything about the type of the new variables on
the same side of the variables, often using some kind of punctuation to
separate them. If C used a colon for that purpose, the syntax would
probably be something like:
void func1(*[] int ptr, size_t size);
which takes a pointer to array of int, called ptr, and a size_t, called
size. Putting things all on the same side would allow code to more cleanly
create multiple items of the same type. For example, if both x and y are
supposed to be arrays of 5 integers, it would be helpful to be able to
specify the 5 just once, without having to create a typedef. Conceptually
it would seem like it should be possible to say something like:
(int[5])x,y;
but parentheses are not allowed for that sort of grouping. Being able to
use a colon as a separator could be likewise helpful, so that
int[5] : a,b;
int* : p,q; // Using ordinary C placement for indirection operator
would make "a" and "b" both be of type "int[5]", and p and q of type "int*".
[toc] | [prev] | [next] | [standalone]
| From | Keith Thompson <kst-u@mib.org> |
|---|---|
| Date | 2016-11-03 12:12 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <ln7f8kz8c6.fsf@kst-u.example.com> |
| In reply to | #95662 |
BartC <bc@freeuk.com> writes:
> On 03/11/2016 15:45, Keith Thompson wrote:
>> Here's an example of two functions that print the values of the elements
>> of an array object. func0() is what I would call idiomatic C; it takes
>> a pointer to the array's initial element. func1() is what I presume is
>> how you would prefer to do it; it takes a pointer to the entire array
>> (as a pointer to an incomplete array type). Again, nobody will stop you
>> from writing func1() -- but the func0() style works just as well and is
>> easier to work with *once you understand the idiom*.
>>
>> #include <stdio.h>
>>
>> void func0(int *ptr, size_t size) {
>> for (size_t i = 0; i < size; i ++) {
>> printf(" %d", ptr[i]);
>> }
>> putchar('\n');
>> }
>>
>> void func1(int (*ptr)[], size_t size) {
>> for (size_t i = 0; i < size; i ++) {
>> printf(" %d", (*ptr)[i]);
>> }
>> putchar('\n');
>> }
>>
>> int main(void) {
>> int array_object[] = { 10, 20, 30 };
>> size_t len = sizeof array_object / sizeof array_object[0];
>> func0(array_object, len);
>> func1(&array_object, len);
>> }
>>
>> Do you think func1() is better than func0()? Why?
>
> (*) The data being passed is in an array. func1 passes a pointer to the
> ARRAY so you know immediately that an array is being operated on
> and not some individual int. func0 loses information in that regard.
Anyone with a reasonable knowledge of C knows that arrays are usually
manipulated via pointers to their elements. func0() is idiomatic.
func1() is not.
In fact, until recently I didn't even know that you could use pointers
to incomplete array types like that. (Now that I know, I doubt that
I'll make much use of the knowledge, but of course it's still good to
know.)
> (*) The main parameter type of func1 exactly reflects the data structure
> that is being passed, unlike the parameter type of func0.
>
> (*) func1 includes the term (*ptr)[i] so you know just from this line
> that a pointer to array is involved. With func0, it could a normal
> array, or it could be pointer to any block of memory. With func1,
> the operation is completely transparent.
Ok, let's look at the actual semantics of `(*ptr)[i]` in func1().
ptr is of type int(*)[], a pointer to an array of int with unspecified
size.
*ptr is an expression of type int[]. (It's unusual, in most code that
most C programmers write, to have an expression of incomplete array
type.)
Since this expression is not the operand of sizeof (which would be
invalid in this case) or of unary `&`, it's implicitly converted to
a pointer expression of type int*.
Applying the indexing operator adds the value of `i` to that int*
pointer expression, yielding a new int* value, and dereferences it. So
`(*ptr)[i]` is an lvalue designating an object of type int (specifically
that object is an element of array_object, defined in main()). Given
the context in which it's used, *lvalue conversion* is applied, yielding
the value of the object -- either 10, 20, or 30, depending on which
iteration of the loop we're on.
I have no doubt that you think this is far more complex than it should
be (and I don't necessarily disagree with that). But this is the actual
meaning of the expression that *you* think is better than the more
idiomatic ptr[i], where ptr is of type int*.
> (*) Given 'int foo;', I can pass &foo to func0. But if I try that with
> func1, I get a warning (from gcc)
Don't be fooled by the fact that the diagnostic is only a warning. In
fact passing &foo, an expression of type int*, to a function whose
corresponding parameter is of type int(*)[], is a constraint violation.
It is exactly as illegal as passing a structure to a function expecting
a long double. gcc's use of a warning, rather than a fatal error, is
permitted by the standard, but in my humble opinion it is a flaw in gcc.
Aside from that, you seem to be objecting to the fact that you can pass
the address of a single object to a function that's intended to operate
on an array. That's not a bug, it's a feature. For purposes of pointer
arithmetic, a single object can be treated as a single-element array,
and something like:
int foo;
func0(&foo, 1);
is perfectly valid. If you want to prevent that kind of call, well, I
guess you can do so by writing non-idiomatic code that takes an array
pointer. But it hardly seems worth it.
> The only thing bad about func1 is the extra syntax required. The "*" is
> necessary to keep the transparency and make the interface and operation
> on the data exactly match the task that is being done, rather than the
> more roundabout way in func0.
I've used a number of different programming languages. Rather than
trying to use idioms from language X in language Y, I prefer to approach
each language on its own terms. It makes for code that's much easier to
read for poeple familiar with the language I'm writing in. And, every
now and then, I learn something. I don't always *like* the idioms of
whatever language I'm using, but fighting against them would be a waste
of time.
> The extra "()" are the subject of this sub-thread which I think was
> originally brought up by supercat. With a postfix "*", func1 could have
> looked like this (I've taken the liberty of altering the parameter
> declaration to match the postfix *):
>
> void func1(int ptr*[], size_t size) {
> for (size_t i = 0; i < size; i ++) {
> printf(" %d", ptr*[i]);
> }
> putchar('\n');
> }
>
> It's got two extra "*" compared with func0, but for that you get all
> those advantages.
That's not C. Maybe C would have been better if unary * were postfix
rather than prefix. But it isn't.
--
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-04 02:02 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <nvgq64$ho3$1@dont-email.me> |
| In reply to | #95684 |
On 03/11/2016 19:12, Keith Thompson wrote: > BartC <bc@freeuk.com> writes: > Applying the indexing operator adds the value of `i` to that int* > pointer expression, yielding a new int* value, and dereferences it. So > `(*ptr)[i]` is an lvalue designating an object of type int (specifically > that object is an element of array_object, defined in main()). Given > the context in which it's used, *lvalue conversion* is applied, yielding > the value of the object -- either 10, 20, or 30, depending on which > iteration of the loop we're on. You've completely lost me there. If you start with a pointer to array, and apply a dereference, then you get an array. Then you index that array to get one of its elements. You're being put off by the fact, that, half-way through, C might implode if it has to deal, even temporarily, with an entire value array. That doesn't happen because of the following index. If you had a very large struct S, with member m, then evaluating S.m doesn't mean having to somehow load the entire struct before extracting that one field. (There's some subterfuge in both cases to prevent that happening. It happens in all (sensible) languages. It's doesn't need a special language rule that decays any pending value arrays to pointers; it's handled behind the scenes for all potentially large data such as arrays and structs.) But let me repeat that first bit: If you start with a pointer to array, and apply a dereference, then you get an array. Then you index an array to get one of it's element. That's all the programmer needs to know. All the 'idiomatic' stuff is playing with blocks of memory, pointers, and offsets > Aside from that, you seem to be objecting to the fact that you can pass > the address of a single object to a function that's intended to operate > on an array. That's not a bug, it's a feature. For purposes of pointer > arithmetic, a single object can be treated as a single-element array, > and something like: > > int foo; > func0(&foo, 1); > > is perfectly valid. If you want to prevent that kind of call, well, I > guess you can do so by writing non-idiomatic code that takes an array > pointer. But it hardly seems worth it. Yes, I think this was well-covered some months back. Some potentially catastrophic bug is a 'feature'. A function takes a int* for an array, and an int* for an 'in/out' length (for some processing it will do). Except that the caller passes the arguments in the wrong order. The compiler says nothing. Eventually - hopefully - the mistake will be discovered. > I've used a number of different programming languages. Rather than > trying to use idioms from language X in language Y, I prefer to approach > each language on its own terms. It makes for code that's much easier to > read for poeple familiar with the language I'm writing in. And, every > now and then, I learn something. I don't always *like* the idioms of > whatever language I'm using, but fighting against them would be a waste > of time. Have you ever thought that one day you might want to take your C code and port it to a language that takes a more disciplined approach to array-handling? You'd find it a lot easier if you used that array approach in C! -- Bart
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2016-11-04 11:15 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <871syrijhw.fsf@bsb.me.uk> |
| In reply to | #95716 |
BartC <bc@freeuk.com> writes: > On 03/11/2016 19:12, Keith Thompson wrote: >> BartC <bc@freeuk.com> writes: > >> Applying the indexing operator adds the value of `i` to that int* >> pointer expression, yielding a new int* value, and dereferences it. So >> `(*ptr)[i]` is an lvalue designating an object of type int (specifically >> that object is an element of array_object, defined in main()). Given >> the context in which it's used, *lvalue conversion* is applied, yielding >> the value of the object -- either 10, 20, or 30, depending on which >> iteration of the loop we're on. > > You've completely lost me there. > > If you start with a pointer to array, and apply a dereference, then > you get an array. Then you index that array to get one of its > elements. [i] is a pointer operator, not an array one. Classic C has only two array operators: sizeof and &. > You're being put off by the fact, that, half-way through, C might > implode if it has to deal, even temporarily, with an entire value > array. That doesn't happen because of the following index. The value of *A is an array. You can't apply [i] to an array. C does not implode, it simply states that array values are converted to pointers in this situation. <snip> > But let me repeat that first bit: > > If you start with a pointer to array, and apply a dereference, then > you get an array. Then you index an array to get one of it's element. Then let me repeat that [] is an operator only defined on pointers. x[y] means *(x + y). > That's all the programmer needs to know. I think the programmer can benefit from knowing that [] operates only on pointers. I think the programmer needs to know when array values are converted to pointer and when they are not. <snip> -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | BartC <bc@freeuk.com> |
|---|---|
| Date | 2016-11-04 12:12 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <nvhtuu$jun$1@dont-email.me> |
| In reply to | #95736 |
On 04/11/2016 11:15, Ben Bacarisse wrote:
> BartC <bc@freeuk.com> writes:
>> If you start with a pointer to array, and apply a dereference, then
>> you get an array. Then you index that array to get one of its
>> elements.
>
> [i] is a pointer operator, not an array one. Classic C has only two
> array operators: sizeof and &.
>> You're being put off by the fact, that, half-way through, C might
>> implode if it has to deal, even temporarily, with an entire value
>> array. That doesn't happen because of the following index.
>
> The value of *A is an array. You can't apply [i] to an array. C does
> not implode, it simply states that array values are converted to
> pointers in this situation.
Except this is not the abstract model that I want to use when coding. I
don't think I'm the only one either.
C is exposing some internal mechanisms it's using for array handling,
which also means you lose an important distinction between a pure
pointer and an array. (By being able to index a pointer, and, not quite
so serious because less will go wrong other than confusion, being able
to dereference an array).
> I think the programmer can benefit from knowing that [] operates only on
> pointers. I think the programmer needs to know when array values are
> converted to pointer and when they are not.
Entire languages exist where arrays are arrays and pointers are
pointers. You can do assume that in C too (other than value-arrays are
not allowed in most expressions). The danger comes when you mistakenly
mix them up but it is not diagnosed.
Plus of course it makes it harder to understand other people's code
where they are still mixed up. It took me ages to figure out how this
code worked from Tim Rentsch:
--------------------------------------------------------
static int
format_matrix( Formatter it, Format format, va_list *list, Channel out ){
int i, j, rows = va_arg( *list, int ), columns = va_arg( *list,
int );
const char *prefix = va_arg( *list, char * );
typedef int (*Matrix)[columns];
Matrix m = va_arg( *list, Matrix );
const char *final_prefix = va_arg( *list, char * );
int r = printx_send( out, "{\n" );
for( i = 0; r >= 0 && i < rows; i++ ){
r = printx_send( out, "%s{", prefix );
for( j = 0; r >= 0 && j < columns; j++ ){
r = printx_send( out, " %d,", m[i][j] );
}
r = r < 0 ? r : printx_send( out, " },\n" );
}
r = r < 0 ? r : printx_send( out, "%s}", final_prefix );
return r;
}
And a sample call:
int m[4][3] = {
{ 1, 2, 3 },
{ 2, 3, 4 },
{ 3, 4, 5 },
{ 4, 5, 6 },
};
printx( " m = %!;\n", Fmatrix, 4, 3, " ", m, " " );
--------------------------------------------------------
--
Bartc
[toc] | [prev] | [next] | [standalone]
| From | BartC <bc@freeuk.com> |
|---|---|
| Date | 2016-11-04 13:52 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <nvi3qb$8p2$1@dont-email.me> |
| In reply to | #95738 |
On 04/11/2016 12:12, BartC wrote: > Entire languages exist where arrays are arrays and pointers are > pointers. I can't remember what I'd intended to write there, but 'distinct' will do. Plus there have been languages that only have arrays and no pointers, and they seemed to manage. -- Bartc
[toc] | [prev] | [next] | [standalone]
| From | BartC <bc@freeuk.com> |
|---|---|
| Date | 2016-11-04 15:28 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <nvi9dl$tds$1@dont-email.me> |
| In reply to | #95743 |
On 04/11/2016 13:52, BartC wrote: > On 04/11/2016 12:12, BartC wrote: > >> Entire languages exist where arrays are arrays and pointers are >> pointers. > > I can't remember what I'd intended to write there, but 'distinct' will > do. I'm going mad I think - there was nothing wrong with the original statement! I just missed the first 'arrays are' bit when rereading it. Please ignore the first correction. (But I can't make up my mind if it makes sense to ask to ignore this one.) -- Bartc
[toc] | [prev] | [next] | [standalone]
| From | Gareth Owen <gwowen@gmail.com> |
|---|---|
| Date | 2016-11-04 17:17 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <87a8dfmaf8.fsf@gmail.com> |
| In reply to | #95738 |
BartC <bc@freeuk.com> writes: > Except this is not the abstract model that I want to use when > coding. I don't think I'm the only one either. Name three people who agree with you.
[toc] | [prev] | [next] | [standalone]
| From | BartC <bc@freeuk.com> |
|---|---|
| Date | 2016-11-04 19:04 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <nvim3r$ed8$1@dont-email.me> |
| In reply to | #95773 |
On 04/11/2016 17:17, Gareth Owen wrote: > BartC <bc@freeuk.com> writes: > >> Except this is not the abstract model that I want to use when >> coding. I don't think I'm the only one either. > > Name three people who agree with you. A list or array data structure, with the ability to randomly access any element, has been common in programming since the fifties. I'm sure there are more than three people on the planet who want to work with them without getting tied up in knots with pointers, offsets and decaying of array names, or having to double guess what a T** type might be supposed to represent. I don't know why C has to be different just because it can't do value arrays. Some other languages can't either, but an attempt to use value arrays can be just an error instead of turning it into something else. -- Bartc
[toc] | [prev] | [next] | [standalone]
| From | Thiago Adams <thiago.adams@gmail.com> |
|---|---|
| Date | 2016-11-04 12:34 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <de6aab48-c388-4e8e-95f3-54274eb8a43a@googlegroups.com> |
| In reply to | #95788 |
On Friday, November 4, 2016 at 5:05:03 PM UTC-2, Bart wrote: > On 04/11/2016 17:17, Gareth Owen wrote: > > BartC writes: > > > >> Except this is not the abstract model that I want to use when > >> coding. I don't think I'm the only one either. > > > > Name three people who agree with you. > > A list or array data structure, with the ability to randomly access any > element, has been common in programming since the fifties. > > I'm sure there are more than three people on the planet who want to work > with them without getting tied up in knots with pointers, offsets and > decaying of array names, or having to double guess what a T** type might > be supposed to represent. I think the problem is when we want to create tooling to check these things. We want to find a light way to express the information. With the spoken languages we have a lot of irregular/incomplete forms to express things and we understand each other by context. I think the C language it's the same. Because it's very stable most of C programmers knows when T** is a pointer array, pointer out etc.. We normally (not always) translate this constructs easily when we have the context (code). When we have only the header file, some documentation is necessary not only because of this ambiguity with pointers but many others that express cause and effect. What happens when I call this function? The sample I like: void Person_Set(Person* person, const char* name); What does this function do? (we have only header) is name a pointer to one char? -- To see some extra information in headers, Microsoft SAL is a sample https://msdn.microsoft.com/en-us/library/jj159525.aspx
[toc] | [prev] | [next] | [standalone]
| From | BartC <bc@freeuk.com> |
|---|---|
| Date | 2016-11-04 20:20 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <nviqhl$uui$1@dont-email.me> |
| In reply to | #95791 |
On 04/11/2016 19:34, Thiago Adams wrote: > On Friday, November 4, 2016 at 5:05:03 PM UTC-2, Bart wrote: >> On 04/11/2016 17:17, Gareth Owen wrote: >>> BartC writes: >>> >>>> Except this is not the abstract model that I want to use when >>>> coding. I don't think I'm the only one either. >>> >>> Name three people who agree with you. >> >> A list or array data structure, with the ability to randomly access any >> element, has been common in programming since the fifties. >> >> I'm sure there are more than three people on the planet who want to work >> with them without getting tied up in knots with pointers, offsets and >> decaying of array names, or having to double guess what a T** type might >> be supposed to represent. > > I think the problem is when we want to create tooling to check these things. We want to find a light way to express the information. > > With the spoken languages we have a lot of irregular/incomplete forms to express things and we understand each other by context. > > I think the C language it's the same. Because it's very stable most of C programmers knows when T** is a pointer array, pointer out etc.. We normally (not always) translate this constructs easily when we have the context (code). > > When we have only the header file, some documentation is necessary not only because of this ambiguity with pointers but many others that express cause and effect. What happens when I call this function? > > The sample I like: > > void Person_Set(Person* person, const char* name); > > What does this function do? (we have only header) > is name a pointer to one char? If it's a header the parameter names might be optional. Then you will see only char*. That's common enough that it /probably/ points to a zero-terminated string. But it could be any of: - Pointer to a single character (not just char) - Pointer to a single byte - Pointer to a block of characters of a given length - Pointer to a block of bytes of a given length - Pointer to a sequence of characters terminated by 0 (a string) (The character/byte distinction is that adding two characters usually does not make sense, but two bytes can do.) With char**, the possibilities double: it might be a pointer to a single one of those things above (and indexing makes sense), or it might be a pointer to a block of those pointers. -- Bartc
[toc] | [prev] | [next] | [standalone]
| From | Gareth Owen <gwowen@gmail.com> |
|---|---|
| Date | 2016-11-05 14:52 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <878tsy9dx1.fsf@gmail.com> |
| In reply to | #95788 |
BartC <bc@freeuk.com> writes: > On 04/11/2016 17:17, Gareth Owen wrote: >> BartC <bc@freeuk.com> writes: >> >>> Except this is not the abstract model that I want to use when >>> coding. I don't think I'm the only one either. >> >> Name three people who agree with you. > > A list or array data structure, with the ability to randomly access > any element, has been common in programming since the fifties. That doesn't answer the question
[toc] | [prev] | [next] | [standalone]
Page 12 of 21 — ← Prev page 1 … 10 11 [12] 13 14 … 21 Next page →
Back to top | Article view | comp.lang.c
csiph-web