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 20 of 21 — ← Prev page 1 … 18 19 [20] 21 Next page →
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2016-11-03 23:09 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <87d1ici2jf.fsf@bsb.me.uk> |
| In reply to | #95696 |
BartC <bc@freeuk.com> writes: > On 03/11/2016 19:53, Ben Bacarisse wrote: >> BartC <bc@freeuk.com> writes: > >>> But that evolved into a separate language. Still, for several years >>> now I've been able to declare pointers and arrays and use them in just >>> the way I like (as well as do a bunch of other things), and still end >>> up with standard C. So for me it's hardly a fantasy. >> >> Are you sure you have no previous life experience as a politician? You >> spin with consummate skill. I said that major changes to C were a >> fantasy. Linear type syntax is a reality in lots of languages, not just >> your own. Indeed, sophisticated examples pre-date C. > > I said that I can generate C. I can write 'ref[]int' and end up with > 'int(*)[]' to feed to a C compiler. Yes, I know you said that (though not in so many words). Please acknowledge that what I called a fantasy was not that undeniable fact. <snip> -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | John Bode <jfbode1029@gmail.com> |
|---|---|
| Date | 2016-11-04 07:08 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <1b877d88-5b7b-4b47-988a-b4ba544cce61@googlegroups.com> |
| In reply to | #95670 |
On Thursday, November 3, 2016 at 1:09:10 PM UTC-5, Ben Bacarisse wrote: [massive snippage] > > (You may already know that I agree with you about this but when you > reply to someone saying "sorry, ..." it suggests you are disabusing > them of some erroneous fantasy.) The "sorry" was for the off-topic rant. A reliable way to nerd-snipe me is to mention "flying cars". I've gotten into so many arguments with so many people who refuse to believe we're living in the future because we don't have flying cars (or personal jet packs) yet that it's become a reflex at this point. iPads, the Internet, genetic engineering, none of that counts - we don't have *flying cars*, so we're still living in the Stone Age. This is an aspect of my personality that I don't particularly like and have little control over. Certain topics just *demand* that I respond, and it's not until after I hit "Post" that I think, "you know, I didn't really need to send that".
[toc] | [prev] | [next] | [standalone]
| From | James Kuyper <jameskuyper@verizon.net> |
|---|---|
| Date | 2016-11-03 22:24 -0400 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <nvgrgn$o3d$1@dont-email.me> |
| In reply to | #95648 |
On 11/03/2016 11:02 AM, John Bode wrote: > On Wednesday, November 2, 2016 at 4:44:05 PM UTC-5, Ben Bacarisse wrote: ... >> Flying cars are better than road ones. Mind you, there aren't any >> usable ones yet, and maybe implementing them will be expensive. And who >> knows if there are any knock-on effects we've not yet thought through. >> > > <off-topic rant> > > We already have flying cars. They're called "airplanes". > > Yeah yeah yeah, I know that's not what people mean when they say "flying > cars". They mean that thing from the Jetsons that magically levitates > itself and zips along without any visible means (or effects) of thrust. > > That ain't happening. Ever. What we'll get are personal-scale VTOL > aircraft that, viewed from the right angle, might *look* like flying > cars, but they won't move or behave much like them. I'd always thought that the fundamentally enticing feature of flying cars was not the "magical levitation" - I've seen the same fantasy described more realistically by postulating the use of helicoptors or vtol aircraft. The key part of the fantasy was personal ownership and operation of those vehicles, just like cars are currently personally owned and operated by a large part of the population in much of the developed world (though not in high-density areas where public transport can be a workable alternative). And the fundamental problem with that scenario is: > ... people can't drive in 2 dimensions, > giving them an extra degree of freedom just means they'll find new and > exciting ways to crash into each other (and whatever poor schmuck happens > to be standing under them at the time). We'll never have personal flying vehicles until they can automate the piloting of such vehicles well enough that they can be flown safely by idiots. And I suspect that, even then, they still won't make economic sense for most people.
[toc] | [prev] | [next] | [standalone]
| From | Keith Thompson <kst-u@mib.org> |
|---|---|
| Date | 2016-11-01 11:50 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <ln1syv3uh6.fsf@kst-u.example.com> |
| In reply to | #95525 |
supercat@casperkitty.com writes:
> On Tuesday, November 1, 2016 at 10:50:28 AM UTC-5, Keith Thompson wrote:
>> supercat writes:
>
>> > Some other languages use words for their bitwise operators and/or use the
>> > at-sign and dollar-sign characters,
>>
>> Sure.
>>
>> > and thus have space in the character
>> > sets for a dedicated dereferencing character.
>>
>> What?
>
> In Pascal, for example (the only such language I've used, though other such
> languages exist), the caret operator is not used for xor, but is instead
> used for indirection. Thus, what in C would be (*myShapeHandle)->left
> would in Pascal be myShapeHandle^^.left (note that double-indirection poses
> no problem in Pascal, unlike C).
Ok, I think I see what you mean.
A few articles directly upthread, BartC wrote:
You mean that "*=" can't have a space in the middle?
When you wrote "... and thus have space ...", I assumed you were
referring to the space character.
Please try to write more clearly.
(I don't know what problem you think C has with double indirection that
Pascal doesn'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-01 16:28 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <nvafq0$46v$2@dont-email.me> |
| In reply to | #95523 |
On 01/11/2016 15:50, Keith Thompson wrote: > supercat@casperkitty.com writes: > [...] >> Some other languages use words for their bitwise operators and/or use the >> at-sign and dollar-sign characters, > > Sure. > >> and thus have space in the character >> sets for a dedicated dereferencing character. > > What? It means having the possibility of using something like "^" for a postfix dereferencing symbol. But C can't use it because "^" means exclusive-or. Another language however might use "xor" for that, thus freeing up "^". That is the point being made. -- Bartc
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2016-11-01 05:07 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <fe0fa0ce-cca0-496b-9f6a-ea9164e6e8a4@googlegroups.com> |
| In reply to | #95495 |
W dniu wtorek, 1 listopada 2016 12:14:21 UTC+1 użytkownik Ben Bacarisse napisał: > BartC <bc@freeuk.com> writes: > <snip> > > Yes, a postfix dereference op would have solved some problems > > (although not with * as 'b* = 10' currently means 'b *= 10'). > > I'm not entirely sure what you mean here (since there is a hypothetical > being discussed) but 'b* = 10' is currently a syntax error and, given a > hypothetical postfix * operator, would mean '(b*) = 10' unless some very > dramatic changes were made to how C defines its lexical tokens. > > <snip> good note (if true, i cant even check it as im not touching compiler over half a year ) btw the context of what im sain (to short some reslults) is that int*[5]**[6]** a; is concise type syntax which repairs some big type hole in c as to dereference ir at rightside though it seems anyway that reversed order need to be used a**[3]**[0]* = 10 though it seems now that leftside dereference *[5]**[6]**a = 10 would also work so maybe leftside is more logical
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2016-11-01 05:18 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <dba91bbb-537b-4741-8a30-2331285755ee@googlegroups.com> |
| In reply to | #95498 |
W dniu wtorek, 1 listopada 2016 13:08:05 UTC+1 użytkownik fir napisał: > W dniu wtorek, 1 listopada 2016 12:14:21 UTC+1 użytkownik Ben Bacarisse napisał: > > BartC <bc@freeuk.com> writes: > > <snip> > > > Yes, a postfix dereference op would have solved some problems > > > (although not with * as 'b* = 10' currently means 'b *= 10'). > > > > I'm not entirely sure what you mean here (since there is a hypothetical > > being discussed) but 'b* = 10' is currently a syntax error and, given a > > hypothetical postfix * operator, would mean '(b*) = 10' unless some very > > dramatic changes were made to how C defines its lexical tokens. > > > > <snip> > > good note (if true, i cant even check it as im not touching compiler over half a year ) > btw the context of what im sain (to short some reslults) is that > > int*[5]**[6]** a; > > is concise type syntax which repairs some big type hole in c > > as to dereference ir at rightside though it seems anyway that reversed order need to be used > > a**[3]**[0]* = 10 > > though it seems now that leftside dereference > > *[5]**[6]**a = 10 > would also work so maybe leftside is more logical i mean *[0]**[0]**a = 10 (as this abowe would be out of bounds of arrays) but no becoz if int*[10] a is table of 10 pointers dereference would need look like [3]a - is a 3rd pointer *[3]a - is a dereferenced int this is reversed, so a[3] and a[3]* seems more fit, though it is reversed seems no way to be not a bit reversed here
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2016-11-01 05:30 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <63e99814-6ba5-400f-8f7a-30d26a92ead7@googlegroups.com> |
| In reply to | #95501 |
W dniu wtorek, 1 listopada 2016 13:18:21 UTC+1 użytkownik fir napisał: > W dniu wtorek, 1 listopada 2016 13:08:05 UTC+1 użytkownik fir napisał: > > W dniu wtorek, 1 listopada 2016 12:14:21 UTC+1 użytkownik Ben Bacarisse napisał: > > > BartC <bc@freeuk.com> writes: > > > <snip> > > > > Yes, a postfix dereference op would have solved some problems > > > > (although not with * as 'b* = 10' currently means 'b *= 10'). > > > > > > I'm not entirely sure what you mean here (since there is a hypothetical > > > being discussed) but 'b* = 10' is currently a syntax error and, given a > > > hypothetical postfix * operator, would mean '(b*) = 10' unless some very > > > dramatic changes were made to how C defines its lexical tokens. > > > > > > <snip> > > > > good note (if true, i cant even check it as im not touching compiler over half a year ) > > btw the context of what im sain (to short some reslults) is that > > > > int*[5]**[6]** a; > > > > is concise type syntax which repairs some big type hole in c > > > > as to dereference ir at rightside though it seems anyway that reversed order need to be used > > > > a**[3]**[0]* = 10 > > > > though it seems now that leftside dereference > > > > *[5]**[6]**a = 10 > > would also work so maybe leftside is more logical > > i mean *[0]**[0]**a = 10 (as this abowe would be out of bounds of arrays) > > but no becoz if > int*[10] a is table of 10 pointers > > dereference would need look like > > [3]a - is a 3rd pointer > *[3]a - is a dereferenced int > > this is reversed, so a[3] and a[3]* seems more fit, though it > is reversed > seems no way to be not a bit reversed here (soprry i split meesages on the same topisc on a couple but this is more convenient) after all it seems so I) this one is least 'physically' reversed int*[320][200] a; //is a table of 320x200 pointers to int [199]a; // is one inner teble of 320 pointers to int *[30][20]a; //is some dereferenced int but it is reversed in regard to c convention of a[] for arrays II) this one is reversed but is more coherent to c convention int*[320][200] a; //is a table of 320x200 pointers to int a[199]; a[20][30]*; for my ovn stylistic sense probably the second would more fit 9though is more reversed)
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2016-11-01 05:38 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <1d7545ef-91b3-4fc7-87c7-b938178f4dd2@googlegroups.com> |
| In reply to | #95502 |
W dniu wtorek, 1 listopada 2016 13:30:53 UTC+1 użytkownik fir napisał: > W dniu wtorek, 1 listopada 2016 13:18:21 UTC+1 użytkownik fir napisał: > > W dniu wtorek, 1 listopada 2016 13:08:05 UTC+1 użytkownik fir napisał: > > > W dniu wtorek, 1 listopada 2016 12:14:21 UTC+1 użytkownik Ben Bacarisse napisał: > > > > BartC <bc@freeuk.com> writes: > > > > <snip> > > > > > Yes, a postfix dereference op would have solved some problems > > > > > (although not with * as 'b* = 10' currently means 'b *= 10'). > > > > > > > > I'm not entirely sure what you mean here (since there is a hypothetical > > > > being discussed) but 'b* = 10' is currently a syntax error and, given a > > > > hypothetical postfix * operator, would mean '(b*) = 10' unless some very > > > > dramatic changes were made to how C defines its lexical tokens. > > > > > > > > <snip> > > > > > > good note (if true, i cant even check it as im not touching compiler over half a year ) > > > btw the context of what im sain (to short some reslults) is that > > > > > > int*[5]**[6]** a; > > > > > > is concise type syntax which repairs some big type hole in c > > > > > > as to dereference ir at rightside though it seems anyway that reversed order need to be used > > > > > > a**[3]**[0]* = 10 > > > > > > though it seems now that leftside dereference > > > > > > *[5]**[6]**a = 10 > > > would also work so maybe leftside is more logical > > > > i mean *[0]**[0]**a = 10 (as this abowe would be out of bounds of arrays) > > > > but no becoz if > > int*[10] a is table of 10 pointers > > > > dereference would need look like > > > > [3]a - is a 3rd pointer > > *[3]a - is a dereferenced int > > > > this is reversed, so a[3] and a[3]* seems more fit, though it > > is reversed > > seems no way to be not a bit reversed here > > (soprry i split meesages on the same topisc on a couple but this is more convenient) > > after all it seems so > > I) this one is least 'physically' reversed > > int*[320][200] a; //is a table of 320x200 pointers to int > > [199]a; // is one inner teble of 320 pointers to int > *[30][20]a; //is some dereferenced int > > but it is reversed in regard to c convention of a[] for arrays > > II) this one is reversed but is more coherent to c convention > > int*[320][200] a; //is a table of 320x200 pointers to int > > a[199]; > a[20][30]*; > > for my ovn stylistic sense probably the second would more fit 9though is more reversed) bTw if im not wronk it shows as a side not that c convention for arrays a[y][x] (like a[200][320] when the most right indexes the smallest) is WRONG it should be a[x][y] (becouse you should be able to skip outer (here outer is [y] and left the inner make still sense, in forst case it has not much sense so a[x][y][z] is proper)
[toc] | [prev] | [next] | [standalone]
| From | fir <profesor.fir@gmail.com> |
|---|---|
| Date | 2016-10-31 16:47 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <a429d7ce-9bf5-4d2e-af5b-e550f590561f@googlegroups.com> |
| In reply to | #95477 |
W dniu wtorek, 1 listopada 2016 00:22:41 UTC+1 użytkownik fir napisał:
> W dniu wtorek, 1 listopada 2016 00:05:06 UTC+1 użytkownik fir napisał:
> > W dniu poniedziałek, 31 października 2016 19:21:11 UTC+1 użytkownik John Bode napisał:
> > > On Monday, October 31, 2016 at 11:35:21 AM UTC-5, Richard Heathfield wrote:
> > > > On 31/10/16 16:12, John Bode wrote:
> > > > > On Monday, October 31, 2016 at 10:27:25 AM UTC-5, Rick C. Hodgin wrote:
> > > > >> On Monday, October 31, 2016 at 11:09:04 AM UTC-4, Keith Thompson wrote:
> > > > >>> BartC <bc@freeuk.com> writes:
> > > > >>>> On 31/10/2016 14:20, Richard Heathfield wrote:
> > > > >>>>> On 31/10/16 13:16, Pascal J. Bourguignon wrote:
> > > > >>> [...]
> > > > >>>>>> In C, basically a pointer is equivalent to array.
> > > > >>>>>
> > > > >>>>> Except when it isn't. For example:
> > > > >>>>
> > > > >>>> Here we go again...
> > > > >>>
> > > > >>> Yes, here we go again.
> > > > >>>
> > > > >>>> Take the char** parameter type in the subject; each "*" might denote a
> > > > >>>> pointer to a single object, or a pointer to multiple objects, the common
> > > > >>>> idiom to pass an array (or possibly a string when char*) to a function.
> > > > >>>
> > > > >>> A (valid non-null) pointer is always a pointer to a single object. That
> > > > >>> single object may or may not be the initial element of an array object.
> > > > >>
> > > > >> A pointer (null, or non-null) is always a pointer to an array in memory.
> > > > >
> > > > > That is an incredibly confused and garbled understanding of pointers.
> > > >
> > > > Indeed.
> > > >
> > > > > NULL is a well-defined "nowhere" - it is *guaranteed* to never point to an
> > > > > object or function.
> > > >
> > > > Right.
> > > >
> > > > > A pointer value evaluates to the location of a single object. Period.
> > > >
> > > > Uh, not quite. It can evaluate to the location of a function.
> > >
> > > True, but since Rick was talking about arrays, I subconsciously focused on
> > > object pointers as opposed to function pointers (since you cannot create an
> > > array of functions).
> > >
> > > I think part of the disconnect is people thinking in terms of what happens
> > > in the machine code on a particular implementation, rather than the abstract
> > > machine defined by the C language. Yeah, sure, on real-world hardware, almost any address value can be the start of a sequence of bytes/words/whatever, but that's not how the language views it.
> > >
> > > An object pointer denotes the location of a single object, not a sequence
> > > of objects, *even if that pointer is the address of the first element of
> > > an array*. If I do something like
> > >
> > > int a[10] = {0};
> > > int *p = a;
> > >
> > > then the expression *p evaluates to the value of a[0] - that's it. Not the
> > > contents of the array. The *language* does not regard `p` as the first of
> > > a sequence of objects, even though in this case we are treating it as such.
> > > sizeof *p gives us the size of a single integer, not the size of the array
> > > to which p is pointing.
> >
> > i do not following (in read) this pointers vs arrays but one could say that if c has a lot of arrays (where most of it just are one element ones like "int x=5;" ;c) then all we got are just arrays and pointers to arrays (all pointers are always pointers to arrays - this is probably conceptuali quite ok, though lack of possibly 'healthy' size typing is again somewhat a glitch) [this dont mean that poiinters and arrays are the same - pointers and arrays are totlly differanyt things, nothing in common]
>
> underlying semantics are quite defined BTW so some syntax could be easilu used; not saying that this is good looking, but as semantic example:
>
> int - integer
> int[2] - table of two integers
> int* - pointer to integer
> int[7]* - pointer to table of 7 integers
> int*[6] - table of 6 pointers to integers
> int[3][2] - table of two tables of 3 integers
> int*[6]*[4]** - pointer to pointer to table of four pointers to table of six pointers of integers (if im not wrong)
>
> round parenthesis could be also used instead of square, im not quite sure how present c allows to code this information but it seems that full typing like thic could be encoded - it may semm that i contradict to myslelf saying that i consider such things like int**** as wrong and here typing this as okay, but im saying about somewhat different things (as in present c int**** or **** by slef is some kind of weird and wide category (which i found as probably harmfull) and here above this is strictly hardly defined simple type)
how to distinguish those mentioned two usecases in this syntac those with pack od strings would look like
void foo(char[]*[]* args)
{
// (*args)[i] would be i-th pointer to i-th string
}
void foo(char[]** x)
{
*x = "cat";
}
could be used for outerscope writing, both could be use for writing or reading and this is stil ambiguity whats why it is need to distinguish on types for read and tyopes for write.. i must check if one additional symbol for pointer to only-read will suffice
[toc] | [prev] | [next] | [standalone]
| From | "Pascal J. Bourguignon" <pjb@informatimago.com> |
|---|---|
| Date | 2016-11-05 04:11 +0100 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <m2vaw2mxhm.fsf@larissa.home> |
| In reply to | #95444 |
John Bode <jfbode1029@gmail.com> writes:
> On Monday, October 31, 2016 at 10:27:25 AM UTC-5, Rick C. Hodgin wrote:
>> On Monday, October 31, 2016 at 11:09:04 AM UTC-4, Keith Thompson wrote:
>> > A (valid non-null) pointer is always a pointer to a single object. That
>> > single object may or may not be the initial element of an array object.
No. See below valid non-null pointers pointing to no object.
>> A pointer (null, or non-null) is always a pointer to an array in memory.
Yes. And no.
Yes, because, because you can consider the pointer to an object as a
pointer to an array of one object:
int a;
int* p=&a;
p[0]=42;
assert(a==42);
No, because IIRC, considering the whole memory as an array of char
containing the data of the other arrays is not specified in C11, where
different memory models can exist.
> That is an incredibly confused and garbled understanding of pointers.
>
> NULL is a well-defined "nowhere" - it is *guaranteed* to never point to an
> object or function.
Yes.
> A pointer value evaluates to the location of a single object. Period.
No. Cf. below.
>> The only time it's not is if it's pointing to the last possible item in
>> physical memory.
No. There are other times:
int a[4]={1,2,3,4};
int* p=a+4; // is a valid pointer, that is not null and that points to
// no object at all: it cannot be dereferenced!
f(p); // good luck!
There is also the case of empty arrays:
#include <stdio.h>
void f(int* p){ printf("%p\n",p); }
int main(void){
int a[0];
int* p=a;
f(p);
f(a);
}
prints twice the same address, but this is an address that points to an
array, but to no value, since that array is empty.
>> C has a protocol which makes them different logically, and in practice
>> there may not be any additional elements out there, but C has no way of
>> knowing that as you can increment beyond the one object which exists
>> into invalid memory and keep computing.
>
> WHICH IS WHY WE TREAT IT AS A POINTER TO A SINGLE OBJECT, NOT A SEQUENCE
> OF OBJECTS. That's the only *safe* interpretation of a pointer value. Yes,
> you can use that pointer value in a larger expression to access additional
> elements of an array, but the *pointer value itself* denotes the location
> of a single object.
>
> Even when we're dealing with pointers to arrays like
>
> int (*p)[10];
>
> The expression *p evaluates to a single object - that object just happens to
> be a 10-element array of int.
>
> [snip remainder]
--
__Pascal Bourguignon__
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2016-11-05 10:48 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <87oa1ufbii.fsf@bsb.me.uk> |
| In reply to | #95820 |
A few clarifications...
"Pascal J. Bourguignon" <pjb@informatimago.com> writes:
> John Bode <jfbode1029@gmail.com> writes:
>
>> On Monday, October 31, 2016 at 10:27:25 AM UTC-5, Rick C. Hodgin wrote:
>>> On Monday, October 31, 2016 at 11:09:04 AM UTC-4, Keith Thompson wrote:
>>> > A (valid non-null) pointer is always a pointer to a single object. That
>>> > single object may or may not be the initial element of an array object.
>
> No. See below valid non-null pointers pointing to no object.
>
>>> A pointer (null, or non-null) is always a pointer to an array in memory.
>
> Yes. And no.
>
> Yes, because, because you can consider the pointer to an object as a
> pointer to an array of one object:
>
> int a;
> int* p=&a;
> p[0]=42;
> assert(a==42);
>
> No, because IIRC, considering the whole memory as an array of char
> containing the data of the other arrays is not specified in C11, where
> different memory models can exist.
True, but that makes it sound like a new notion (since C11 is the latest
standard). In fact it goes right back to the very earliest versions of
C.
>> That is an incredibly confused and garbled understanding of pointers.
>>
>> NULL is a well-defined "nowhere" - it is *guaranteed* to never point to an
>> object or function.
>
> Yes.
>
>> A pointer value evaluates to the location of a single object. Period.
>
> No. Cf. below.
>
>>> The only time it's not is if it's pointing to the last possible item in
>>> physical memory.
>
> No. There are other times:
>
>
> int a[4]={1,2,3,4};
> int* p=a+4; // is a valid pointer, that is not null and that points to
> // no object at all: it cannot be dereferenced!
>
> f(p); // good luck!
Passing p to f is fine, provided f does not (as you point out)
dereference it. It might have been clearer to show a problem use rather
than what is probably a problem use depending on what f does.
> There is also the case of empty arrays:
>
> #include <stdio.h>
> void f(int* p){ printf("%p\n",p); }
> int main(void){
> int a[0];
That's not permitted -- it's what the language standard calls a
constraint violation and must be diagnosed. After that, all bets are
off.
You are right that there are other examples, but an empty array is not
one of them. The one that springs to mind is an indeterminate pointer.
For example, after
free(p);
p is indeterminate and any use of it is undefined.
<snip>
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | Keith Thompson <kst-u@mib.org> |
|---|---|
| Date | 2016-11-05 14:06 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <lnlgwxvdoz.fsf@kst-u.example.com> |
| In reply to | #95820 |
"Pascal J. Bourguignon" <pjb@informatimago.com> writes:
[...]
> There is also the case of empty arrays:
No, there isn't. C doesn't permit empty arrays.
> #include <stdio.h>
> void f(int* p){ printf("%p\n",p); }
This printf call has undefined behavior. You need to cast the value of
p to void*.
> int main(void){
> int a[0];
This is a constraint violation.
> int* p=a;
> f(p);
> f(a);
> }
>
> prints twice the same address, but this is an address that points to an
> array, but to no value, since that array is empty.
[...]
--
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-10-31 17:38 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <nv7vhe$k84$1@dont-email.me> |
| In reply to | #95441 |
On 31/10/2016 15:10, Keith Thompson wrote: > BartC <bc@freeuk.com> writes: >> On 31/10/2016 14:20, Richard Heathfield wrote: >>> On 31/10/16 13:16, Pascal J. Bourguignon wrote: > [...] >>>> In C, basically a pointer is equivalent to array. >>> >>> Except when it isn't. For example: >> >> Here we go again... > > Yes, here we go again. > >> Take the char** parameter type in the subject; each "*" might denote a >> pointer to a single object, or a pointer to multiple objects, the common >> idiom to pass an array (or possibly a string when char*) to a function. > > A (valid non-null) pointer is always a pointer to a single object. That > single object may or may not be the initial element of an array object. > >> Hence char** can be interpreted in four different ways, some of which >> could involve arrays. > > Yes, some uses of char** may *involve* arrays. That doesn't mean > pointers and arrays are equivalent. It means you have to use "*" when dealing with a pointer to a standalone object, but you also have to to use "*" when dealing with a pointer to the first element of an array that is intended to be used like an array. In English, "*" is used, in common practice, for passing both pointers and arrays. Looking at Pascal JB's post again, he illustrates the possibilities beautifully. Four combinations, and yet all encoded as T** ! That's why I said it was magic. However it is also VERY confusing. Which of the four possibilities was intended when you see T** A? If you then see A[i][j], is that meaningful, or is it nonsensical? > Stop trying to make this more confusing than it really is. Better than trying to brush things under the carpet. -- Bartc
[toc] | [prev] | [next] | [standalone]
| From | Richard Heathfield <rjh@cpax.org.uk> |
|---|---|
| Date | 2016-10-31 17:44 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <nv7vti$ln3$1@dont-email.me> |
| In reply to | #95450 |
On 31/10/16 17:38, BartC wrote:
> On 31/10/2016 15:10, Keith Thompson wrote:
>> BartC <bc@freeuk.com> writes:
>>> On 31/10/2016 14:20, Richard Heathfield wrote:
>>>> On 31/10/16 13:16, Pascal J. Bourguignon wrote:
>> [...]
>>>>> In C, basically a pointer is equivalent to array.
>>>>
>>>> Except when it isn't. For example:
>>>
>>> Here we go again...
>>
>> Yes, here we go again.
>>
>>> Take the char** parameter type in the subject; each "*" might denote a
>>> pointer to a single object, or a pointer to multiple objects, the common
>>> idiom to pass an array (or possibly a string when char*) to a function.
>>
>> A (valid non-null) pointer is always a pointer to a single object. That
>> single object may or may not be the initial element of an array object.
>>
>>> Hence char** can be interpreted in four different ways, some of which
>>> could involve arrays.
>>
>> Yes, some uses of char** may *involve* arrays. That doesn't mean
>> pointers and arrays are equivalent.
>
> It means you have to use "*" when dealing with a pointer to a standalone
> object, but you also have to to use "*" when dealing with a pointer to
> the first element of an array that is intended to be used like an array.
Not true.
Consider:
char c = 'A';
char *pc = &c;
char arr[] = "ABCDEFG";
char *pa = arr;
printf("%c\n", *pc); /* as you say */
printf("%c\n", *pa); /* as you say */
printf("%c\n", pc[0]); /* not as you say, but perfectly legal */
printf("%c\n", pa[0]); /* not as you say, but perfectly legal */
> In English, "*" is used, in common practice, for passing both pointers
> and arrays.
In C, you can't pass arrays, because the use of the array name in a
value context (and parameter-passing *is* a value context, because it is
the value that is passed) is treated as a pointer to the first element
of the array.
> Looking at Pascal JB's post again, he illustrates the possibilities
> beautifully.
>
> Four combinations, and yet all encoded as T** ! That's why I said it was
> magic.
>
> However it is also VERY confusing.
Only if you try very hard to be confused.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within
[toc] | [prev] | [next] | [standalone]
| From | "Rick C. Hodgin" <rick.c.hodgin@gmail.com> |
|---|---|
| Date | 2016-10-31 11:04 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <bc9dfb6d-fa41-4e5e-a8f3-509631ba0e15@googlegroups.com> |
| In reply to | #95451 |
On Monday, October 31, 2016 at 1:44:54 PM UTC-4, Richard Heathfield wrote:
> On 31/10/16 17:38, BartC wrote:
> > On 31/10/2016 15:10, Keith Thompson wrote:
> >> BartC <bc@freeuk.com> writes:
> >>> On 31/10/2016 14:20, Richard Heathfield wrote:
> >>>> On 31/10/16 13:16, Pascal J. Bourguignon wrote:
> >> [...]
> >>>>> In C, basically a pointer is equivalent to array.
> >>>>
> >>>> Except when it isn't. For example:
> >>>
> >>> Here we go again...
> >>
> >> Yes, here we go again.
> >>
> >>> Take the char** parameter type in the subject; each "*" might denote a
> >>> pointer to a single object, or a pointer to multiple objects, the common
> >>> idiom to pass an array (or possibly a string when char*) to a function.
> >>
> >> A (valid non-null) pointer is always a pointer to a single object. That
> >> single object may or may not be the initial element of an array object.
> >>
> >>> Hence char** can be interpreted in four different ways, some of which
> >>> could involve arrays.
> >>
> >> Yes, some uses of char** may *involve* arrays. That doesn't mean
> >> pointers and arrays are equivalent.
> >
> > It means you have to use "*" when dealing with a pointer to a standalone
> > object, but you also have to to use "*" when dealing with a pointer to
> > the first element of an array that is intended to be used like an array.
>
> Not true.
>
> Consider:
>
> char c = 'A';
> char *pc = &c;
> char arr[] = "ABCDEFG";
> char *pa = arr;
>
> printf("%c\n", *pc); /* as you say */
> printf("%c\n", *pa); /* as you say */
> printf("%c\n", pc[0]); /* not as you say, but perfectly legal */
> printf("%c\n", pa[0]); /* not as you say, but perfectly legal */
Look at the underlying assembly code:
6: int main(int argc, char* argv[])
7: {
00EA1250 push ebp
00EA1251 mov ebp,esp
00EA1253 sub esp,58h
00EA1256 mov eax,dword ptr [___security_cookie (0EA6000h)]
00EA125B xor eax,ebp
00EA125D mov dword ptr [ebp-4],eax
00EA1260 push ebx
00EA1261 push esi
00EA1262 push edi
8: char c = 'A';
00EA1263 mov byte ptr [ebp-5],41h
9: char *pc = &c;
00EA1267 lea eax,[ebp-5]
00EA126A mov dword ptr [ebp-0Ch],eax
10: char arr[] = "ABCDEFG";
00EA126D mov eax,dword ptr [string "ABCDEFG" (0EA4740h)]
00EA1272 mov dword ptr [ebp-14h],eax
00EA1275 mov ecx,dword ptr ds:[0EA4744h]
00EA127B mov dword ptr [ebp-10h],ecx
11: char *pa = arr;
00EA127E lea eax,[ebp-14h]
00EA1281 mov dword ptr [ebp-18h],eax
12:
13: printf("%c\n", *pc); /* as you say */
00EA1284 mov eax,dword ptr [ebp-0Ch]
00EA1287 movsx ecx,byte ptr [eax]
00EA128A push ecx
00EA128B push offset string "%c\n" (0EA473Ch)
00EA1290 call dword ptr [__imp__printf (0EA7238h)]
00EA1296 add esp,8
14: printf("%c\n", *pa); /* as you say */
00EA1299 mov eax,dword ptr [ebp-18h]
00EA129C movsx ecx,byte ptr [eax]
00EA129F push ecx
00EA12A0 push offset string "%c\n" (0EA473Ch)
00EA12A5 call dword ptr [__imp__printf (0EA7238h)]
00EA12AB add esp,8
15: printf("%c\n", pc[0]); /* not as you say, but perfectly legal */
00EA12AE mov eax,dword ptr [ebp-0Ch]
00EA12B1 movsx ecx,byte ptr [eax]
00EA12B4 push ecx
00EA12B5 push offset string "%c\n" (0EA473Ch)
00EA12BA call dword ptr [__imp__printf (0EA7238h)]
00EA12C0 add esp,8
16: printf("%c\n", pa[0]); /* not as you say, but perfectly legal */
00EA12C3 mov eax,dword ptr [ebp-18h]
00EA12C6 movsx ecx,byte ptr [eax]
00EA12C9 push ecx
00EA12CA push offset string "%c\n" (0EA473Ch)
00EA12CF call dword ptr [__imp__printf (0EA7238h)]
00EA12D5 add esp,8
17: }
00EA12D8 xor eax,eax
00EA12DA pop edi
00EA12DB pop esi
00EA12DC pop ebx
00EA12DD mov ecx,dword ptr [ebp-4]
00EA12E0 xor ecx,ebp
00EA12E2 call @ILT+10(@__security_check_cookie@4) (0EA100Fh)
00EA12E7 mov esp,ebp
00EA12E9 pop ebp
00EA12EA ret
And specifically at these two lines for example:
13:printf("%c\n", *pc); /* as you say */
00EA1284 mov eax,dword ptr [ebp-0Ch]
00EA1287 movsx ecx,byte ptr [eax]
00EA128A push ecx
00EA128B push offset string "%c\n" (0EA473Ch)
00EA1290 call dword ptr [__imp__printf (0EA7238h)]
00EA1296 add esp,8
15:printf("%c\n", pc[0]); /* not as you say, but perfectly legal */
00EA12AE mov eax,dword ptr [ebp-0Ch]
00EA12B1 movsx ecx,byte ptr [eax]
00EA12B4 push ecx
00EA12B5 push offset string "%c\n" (0EA473Ch)
00EA12BA call dword ptr [__imp__printf (0EA7238h)]
00EA12C0 add esp,8
Now consecutively, line-by-line:
13:printf("%c\n", *pc); /* as you say */
15: printf("%c\n", pc[0]); /* not as you say, but perfectly legal */
284 mov eax,dword ptr [ebp-0Ch] // 13
2AE mov eax,dword ptr [ebp-0Ch] // 15
287 movsx ecx,byte ptr [eax] // 13
2B1 movsx ecx,byte ptr [eax] // 15
28A push ecx // 13
2B4 push ecx // 15
28B push offset string "%c\n" (0EA473Ch) // 13
2B5 push offset string "%c\n" (0EA473Ch) // 15
290 call dword ptr [__imp__printf (0EA7238h)] // 13
2BA call dword ptr [__imp__printf (0EA7238h)] // 15
296 add esp,8 // 13
2C0 add esp,8 // 15
They resolve to the exact same fundamental operations on the machine,
despite their being different logically in C.
> In C, you can't pass arrays, because the use of the array name in a
> value context (and parameter-passing *is* a value context, because it is
> the value that is passed) is treated as a pointer to the first element
> of the array.
That's a C protocol. You can perform the exact same operation by using
the address of the array through a union and reconstituting it on the
other side of the call.
Datawise it's no different, only protocol-wise.
Best regards,
Rick C. Hodgin
[toc] | [prev] | [next] | [standalone]
| From | BartC <bc@freeuk.com> |
|---|---|
| Date | 2016-10-31 19:12 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <nv851l$a0g$1@dont-email.me> |
| In reply to | #95451 |
On 31/10/2016 17:44, Richard Heathfield wrote:
> On 31/10/16 17:38, BartC wrote:
>> It means you have to use "*" when dealing with a pointer to a standalone
>> object, but you also have to to use "*" when dealing with a pointer to
>> the first element of an array that is intended to be used like an array.
>
> Not true.
>
> Consider:
>
> char c = 'A';
> char *pc = &c;
> char arr[] = "ABCDEFG";
> char *pa = arr;
>
> printf("%c\n", *pc); /* as you say */
> printf("%c\n", *pa); /* as you say */
> printf("%c\n", pc[0]); /* not as you say, but perfectly legal */
> printf("%c\n", pa[0]); /* not as you say, but perfectly legal */
I meant for declaring parameters that are intended to deal indirectly
with arrays. Although you can mix it up a bit by using [] in place of a
*, at the risk of confusion as [] in another context doesn't declare a
pointer.
>> In English, "*" is used, in common practice, for passing both pointers
>> and arrays.
>
> In C, you can't pass arrays, because the use of the array name in a
> value context (and parameter-passing *is* a value context, because it is
> the value that is passed) is treated as a pointer to the first element
> of the array.
In English again: the common way of 'passing an array to a function' is
to pass a pointer to that array's first element. That very often uses
"*" in the parameter type.
Effectively, "*", a pointer designator, is used to 'pass an array'.
>> However it is also VERY confusing.
>
> Only if you try very hard to be confused.
I didn't have to try hard. And I still don't know, when you see T** as
as parameter, exactly what data structure is being passed.
--
Bartc
[toc] | [prev] | [next] | [standalone]
| From | Richard Heathfield <rjh@cpax.org.uk> |
|---|---|
| Date | 2016-10-31 19:18 +0000 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <nv85do$bec$1@dont-email.me> |
| In reply to | #95465 |
On 31/10/16 19:12, BartC wrote: > And I still don't know, when you see T** as > as parameter, exactly what data structure is being passed. If you're writing the function, you /decide/ what data structure is being passed, and then you document the function so that people who call it will know what to pass it. If you're not writing the function, you find the documentation for that function, and read it. Either way, it's easy to know what data structure should be passed. If that turns out to be different from what is actually being passed, well, you found your bug, so fix it and move on. -- Richard Heathfield Email: rjh at cpax dot org dot uk "Usenet is a strange place" - dmr 29 July 1999 Sig line 4 vacant - apply within
[toc] | [prev] | [next] | [standalone]
| From | "Rick C. Hodgin" <rick.c.hodgin@gmail.com> |
|---|---|
| Date | 2016-10-31 10:53 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <e2e3e3ab-868d-482a-aad7-02b09655ab40@googlegroups.com> |
| In reply to | #95450 |
On Monday, October 31, 2016 at 1:38:25 PM UTC-4, Bart wrote: > Looking at Pascal JB's post again, he illustrates the possibilities > beautifully. I agree. When I saw JB's post, I thought to myself I would use his illustration for the C instruction video I'm preparing right now. Best regards, Rick C. Hodgin
[toc] | [prev] | [next] | [standalone]
| From | Keith Thompson <kst-u@mib.org> |
|---|---|
| Date | 2016-11-01 08:25 -0700 |
| Subject | Re: usecases of void foo(char **b) {} |
| Message-ID | <lnwpgn43z8.fsf@kst-u.example.com> |
| In reply to | #95441 |
Keith Thompson <kst-u@mib.org> writes:
[...]
> A (valid non-null) pointer is always a pointer to a single object. That
> single object may or may not be the initial element of an array object.
[...]
Sorry, I missed a couple of cases. A valid pointer can point just
past the last element of an array object, and a non-null pointer
of pointer-to-function type can point to a function.
And for purposes of pointer arithmetic, a single object is treated
as a element of a single-element array.
So, for example, this sets p to a valid pointer value (which cannot be
derferenced):
int n;
int *p = &n + 1;
--
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]
Page 20 of 21 — ← Prev page 1 … 18 19 [20] 21 Next page →
Back to top | Article view | comp.lang.c
csiph-web