Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > comp.lang.c++ > #89160 > unrolled thread

Is this safe?

Started byMuttley@dastardlyhq.com
First post2023-02-20 16:45 +0000
Last post2023-02-21 08:15 -0800
Articles 20 on this page of 203 — 22 participants

Back to article view | Back to comp.lang.c++


Contents

  Is this safe? Muttley@dastardlyhq.com - 2023-02-20 16:45 +0000
    Re: Is this safe? Bonita Montero <Bonita.Montero@gmail.com> - 2023-02-20 18:34 +0100
      Re: Is this safe? Chris Vine <vine24683579@gmail.com> - 2023-02-20 11:16 -0800
        Re: Is this safe? Bonita Montero <Bonita.Montero@gmail.com> - 2023-02-20 21:39 +0100
          Re: Is this safe? Chris Vine <vine24683579@gmail.com> - 2023-02-20 12:56 -0800
            Re: Is this safe? Tony Oliver <guinness.tony@gmail.com> - 2023-02-20 16:17 -0800
              Re: Is this safe? Manu Raju <MR@invalid.invalid> - 2023-02-21 01:57 +0000
                Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-21 09:15 +0000
                  Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-21 12:31 +0200
            Re: Is this safe? Bonita Montero <Bonita.Montero@gmail.com> - 2023-02-21 05:36 +0100
              Re: Is this safe? Chris Vine <vine24683579@gmail.com> - 2023-02-21 02:19 -0800
                Re: Is this safe? Bonita Montero <Bonita.Montero@gmail.com> - 2023-02-21 14:16 +0100
                  Re: Is this safe? Ralf Goertz <me@myprovider.invalid> - 2023-02-21 14:40 +0100
                  Re: Is this safe? Chris Vine <vine24683579@gmail.com> - 2023-02-21 05:51 -0800
                  Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-21 15:58 +0200
                    Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-21 14:55 +0000
                      Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-21 19:02 +0200
                        Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-21 17:13 +0000
                          Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-21 19:58 +0200
                            Re: Is this safe? "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2023-02-21 12:15 -0800
                              Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-21 23:41 +0200
                                Re: Is this safe? "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2023-03-03 12:57 -0800
        Re: Is this safe? Tony Oliver <guinness.tony@gmail.com> - 2023-02-20 16:14 -0800
          Re: Is this safe? James Kuyper <jameskuyper@alumni.caltech.edu> - 2023-02-20 23:48 -0500
        Re: Is this safe? Öö Tiib <ootiib@hot.ee> - 2023-02-21 00:05 -0800
      Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-21 09:14 +0000
    Re: Is this safe? Richard Damon <Richard@Damon-Family.org> - 2023-02-20 21:18 -0500
    Re: Is this safe? Andrey Tarasevich <andreytarasevich@hotmail.com> - 2023-02-20 20:38 -0800
      Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-21 09:18 +0000
        Re: Is this safe? "Alf P. Steinbach" <alf.p.steinbach@gmail.com> - 2023-02-21 15:12 +0100
          Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-21 14:53 +0000
            Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-02-21 10:35 -0800
              Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-22 09:25 +0000
                Re: Is this safe? "Alf P. Steinbach" <alf.p.steinbach@gmail.com> - 2023-02-22 22:33 +0100
                  Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 09:25 +0000
                    Re: Is this safe? Andrey Tarasevich <andreytarasevich@hotmail.com> - 2023-02-23 07:05 -0800
                Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-02-22 21:21 -0800
                Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-23 09:39 +0200
                  Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 09:35 +0000
                    Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-23 12:30 +0200
                      Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 10:34 +0000
                        Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-23 13:20 +0200
                          Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 16:00 +0000
                            Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-23 18:24 +0200
                              Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 16:28 +0000
                                Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-23 19:01 +0200
                              Re: Is this safe? James Kuyper <jameskuyper@alumni.caltech.edu> - 2023-02-23 11:57 -0500
                                Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-23 19:12 +0200
                          Re: Is this safe? James Kuyper <jameskuyper@alumni.caltech.edu> - 2023-02-23 11:57 -0500
                            Re: Is this safe? Richard Damon <Richard@Damon-Family.org> - 2023-02-23 12:20 -0500
                              Re: Is this safe? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2023-02-24 02:15 +0000
                                Re: Is this safe? Tim Rentsch <tr.17687@z991.linuxsc.com> - 2023-02-24 15:24 -0800
                              Re: Is this safe? James Kuyper <jameskuyper@alumni.caltech.edu> - 2023-02-24 02:14 -0500
                        Re: Is this safe? Richard Damon <Richard@Damon-Family.org> - 2023-02-23 07:18 -0500
                          Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 16:01 +0000
                            Re: Is this safe? Richard Damon <Richard@Damon-Family.org> - 2023-02-23 11:50 -0500
                              Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-02-23 14:41 -0800
                            Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-23 19:44 +0100
                        Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-23 15:02 +0100
                          Re: Is this safe? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2023-02-23 14:49 +0000
                            Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-23 16:25 +0100
                          Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 16:10 +0000
                            Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-23 20:46 +0100
                              Re: Is this safe? scott@slp53.sl.home (Scott Lurndal) - 2023-02-23 20:05 +0000
                                Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-02-23 14:48 -0800
                                  Re: Is this safe? Richard Damon <Richard@Damon-Family.org> - 2023-02-23 22:12 -0500
                                  Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-24 10:49 +0200
                                Re: Is this safe? Ralf Fassel <ralfixx@gmx.de> - 2023-02-24 11:36 +0100
                                  Re: Is this safe? scott@slp53.sl.home (Scott Lurndal) - 2023-02-24 15:39 +0000
                              Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-24 10:29 +0000
                                Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-24 17:20 +0100
                                  Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-24 17:09 +0000
                                    Re: Is this safe? scott@slp53.sl.home (Scott Lurndal) - 2023-02-24 17:32 +0000
                                      Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-25 11:56 +0000
                                        Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-25 16:04 +0100
                                          Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-25 15:47 +0000
                                            Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-25 19:13 +0100
                                              Re: Is this safe? scott@slp53.sl.home (Scott Lurndal) - 2023-02-25 19:00 +0000
                                              Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-27 08:43 +0000
                                                Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-27 10:31 +0100
                                          Re: Is this safe? scott@slp53.sl.home (Scott Lurndal) - 2023-02-25 16:40 +0000
                                    Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-24 18:42 +0100
                                      Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-25 11:58 +0000
                                        Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-25 16:25 +0100
                                          Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-25 15:45 +0000
                                            Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-25 19:15 +0100
                                              Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-27 08:44 +0000
                                                Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-27 10:40 +0100
                                                  Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-27 10:24 +0000
                                                    Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-27 18:31 +0100
                                                      Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-28 08:38 +0000
                                                        Re: Is this safe? Öö Tiib <ootiib@hot.ee> - 2023-02-28 01:33 -0800
                                                          Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-28 10:17 +0000
                                                            Re: Is this safe? Öö Tiib <ootiib@hot.ee> - 2023-02-28 02:43 -0800
                                                              Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-28 16:50 +0100
                                                        Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-02-28 03:19 -0800
                                                          Re: Is this safe? Richard Damon <Richard@Damon-Family.org> - 2023-02-28 08:10 -0500
                                                            Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-02-28 05:42 -0800
                                                              Re: Is this safe? Richard Damon <Richard@Damon-Family.org> - 2023-02-28 09:39 -0500
                                                                Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-02-28 07:12 -0800
                                                                  Re: Is this safe? Richard Damon <Richard@Damon-Family.org> - 2023-02-28 11:29 -0500
                                                              Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-28 16:45 +0100
                                                                Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-02-28 11:31 -0800
                                                                  Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-28 20:59 +0100
                                                              Re: Is this safe? "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2023-03-01 14:29 -0800
                                                        Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-28 16:37 +0100
                                                          Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-28 15:56 +0000
                                                            Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-28 18:34 +0100
                                                              Re: Is this safe? Muttley@dastardlyhq.com - 2023-03-01 09:37 +0000
                                                                Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-03-01 02:29 -0800
                                                                  Re: Is this safe? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2023-03-01 19:56 +0000
                                                                    Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-03-01 12:53 -0800
                                                                      Re: Is this safe? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2023-03-01 21:13 +0000
                                                                        Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-03-02 01:48 -0800
                                                                          Re: Is this safe? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2023-03-03 21:44 +0000
                                                                            Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-03-03 20:16 -0800
                                                                              Re: Is this safe? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2023-03-04 22:55 +0000
                                                                                Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-03-05 07:11 -0800
                                                                                  Re: Is this safe? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2023-03-05 20:44 +0000
                                                                                    Re: Is this safe? Mr Flibble <flibble2@reddwarf.jmc.corp> - 2023-03-05 21:00 +0000
                                                                                      Re: Is this safe? "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2023-03-05 13:59 -0800
                                                                                        Re: Is this safe? Mr Flibble <flibble2@reddwarf.jmc.corp> - 2023-03-05 23:07 +0000
                                                                                      Re: Is this safe? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2023-03-06 00:22 +0000
                                                                                    Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-03-05 14:26 -0800
                                                                                      Re: Is this safe? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2023-03-06 00:51 +0000
                                                                                        Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-03-06 02:17 -0800
                                                                              Re: Is this safe? Tim Rentsch <tr.17687@z991.linuxsc.com> - 2023-03-05 08:13 -0800
                                                                                Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-03-05 09:05 -0800
                                                                        Re: Is this safe? Tim Rentsch <tr.17687@z991.linuxsc.com> - 2023-03-14 09:47 -0700
                                                                      Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-03-01 14:40 -0800
                                                                      Re: Is this safe? Muttley@dastardlyhq.com - 2023-03-02 09:07 +0000
                                                                  Re: Is this safe? Richard Damon <Richard@Damon-Family.org> - 2023-03-01 21:37 -0500
                                                                    Re: Is this safe? Öö Tiib <ootiib@hot.ee> - 2023-03-01 22:30 -0800
                                                                Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-03-01 14:27 +0100
                                                                  Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-03-01 10:48 -0800
                                                                    Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-03-02 10:29 +0100
                                                                Re: Is this safe? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2023-03-01 19:53 +0000
                                                                  Re: Is this safe? Muttley@dastardlyhq.com - 2023-03-02 09:08 +0000
                                                                    Re: Is this safe? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2023-03-02 01:32 -0800
                                                                      Re: Is this safe? Muttley@dastardlyhq.com - 2023-03-02 09:56 +0000
                                                                        Re: Is this safe? Öö Tiib <ootiib@hot.ee> - 2023-03-02 04:02 -0800
                                                                          Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-03-02 15:00 +0100
                                                                            Re: Is this safe? Öö Tiib <ootiib@hot.ee> - 2023-03-02 07:59 -0800
                                                                          Re: Is this safe? Muttley@dastardlyhq.com - 2023-03-02 15:38 +0000
                                                                            Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-03-02 11:16 -0800
                                                                    Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-03-02 11:08 -0800
                                                                      Re: Is this safe? Muttley@dastardlyhq.com - 2023-03-03 09:53 +0000
                                                                        Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-03-04 06:47 -0800
                                                                    Re: Is this safe? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2023-03-02 19:35 +0000
                                                        Re: Is this safe? "Alf P. Steinbach" <alf.p.steinbach@gmail.com> - 2023-02-28 17:40 +0100
                                  Re: Is this safe? James Kuyper <jameskuyper@alumni.caltech.edu> - 2023-02-24 12:16 -0500
                                    Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-24 18:39 +0100
                                      Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-02-24 10:03 -0800
                                        Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-24 19:59 +0100
                                      Re: Is this safe? "Alf P. Steinbach" <alf.p.steinbach@gmail.com> - 2023-02-25 06:47 +0100
                                        Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-25 10:23 +0200
                        Re: Is this safe? Andrey Tarasevich <andreytarasevich@hotmail.com> - 2023-02-23 07:16 -0800
                          Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-02-23 14:31 -0800
                        Re: Is this safe? "Alf P. Steinbach" <alf.p.steinbach@gmail.com> - 2023-02-23 16:34 +0100
                          Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 16:15 +0000
                            Re: Is this safe? "Alf P. Steinbach" <alf.p.steinbach@gmail.com> - 2023-02-24 12:17 +0100
                              Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-24 12:24 +0000
                                Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-24 15:18 +0200
                                  Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-24 15:55 +0000
                                    Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-24 18:20 +0200
                                      Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-24 17:05 +0000
                                        Re: Is this safe? Paavo Helde <eesnimi@osa.pri.ee> - 2023-02-24 19:24 +0200
                                        Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-02-24 09:46 -0800
                                Re: Is this safe? David Brown <david.brown@hesbynett.no> - 2023-02-24 17:30 +0100
                        Re: Is this safe? scott@slp53.sl.home (Scott Lurndal) - 2023-02-23 17:12 +0000
                    Re: Is this safe? Öö Tiib <ootiib@hot.ee> - 2023-02-23 02:47 -0800
                      Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 15:59 +0000
                        Re: Is this safe? Richard Damon <Richard@Damon-Family.org> - 2023-02-23 11:55 -0500
                    Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-02-23 08:37 -0800
                      Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-02-23 14:19 -0800
                  Re: Is this safe? scott@slp53.sl.home (Scott Lurndal) - 2023-02-23 17:09 +0000
                    Re: Is this safe? Richard Damon <Richard@Damon-Family.org> - 2023-02-23 12:21 -0500
                      Re: Is this safe? scott@slp53.sl.home (Scott Lurndal) - 2023-02-23 17:55 +0000
                        Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-02-23 13:57 -0800
                          Re: Is this safe? Andrey Tarasevich <andreytarasevich@hotmail.com> - 2023-02-23 17:28 -0800
                            Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-02-23 21:44 -0800
                              Re: Is this safe? Tim Rentsch <tr.17687@z991.linuxsc.com> - 2023-02-24 08:48 -0800
            Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-02-21 10:58 -0800
              Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-22 09:26 +0000
                Re: Is this safe? "Alf P. Steinbach" <alf.p.steinbach@gmail.com> - 2023-02-22 22:34 +0100
                  Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 09:29 +0000
                    Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-02-23 08:28 -0800
                      Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 17:16 +0000
                        Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-02-23 22:24 -0800
                Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-02-22 21:30 -0800
                  Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-23 09:31 +0000
                    Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-02-23 22:00 -0800
                      Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-02-23 22:20 -0800
                        Re: Is this safe? James Kuyper <jameskuyper@alumni.caltech.edu> - 2023-02-24 01:34 -0500
                      Re: Is this safe? Muttley@dastardlyhq.com - 2023-02-24 10:32 +0000
                        Re: Is this safe? "james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> - 2023-02-25 00:19 -0800
              Re: Is this safe? Andrey Tarasevich <andreytarasevich@hotmail.com> - 2023-02-22 08:09 -0800
          Re: Is this safe? Andrey Tarasevich <andreytarasevich@hotmail.com> - 2023-02-21 22:32 -0800
            Re: Is this safe? Tim Rentsch <tr.17687@z991.linuxsc.com> - 2023-02-22 08:32 -0800
              Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-02-22 09:17 -0800
                Re: Is this safe? Tim Rentsch <tr.17687@z991.linuxsc.com> - 2023-04-04 23:28 -0700
                  Re: Is this safe? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2023-04-05 11:08 -0700
        Re: Is this safe? Andrey Tarasevich <andreytarasevich@hotmail.com> - 2023-02-21 08:15 -0800

Page 8 of 11 — ← Prev page 1 … 6 7 [8] 9 10 11  Next page →


#89382

FromÖö Tiib <ootiib@hot.ee>
Date2023-03-02 04:02 -0800
Message-ID<24830ba7-c690-4eef-af91-0e37edc0af5an@googlegroups.com>
In reply to#89381
On Thursday, 2 March 2023 at 11:56:46 UTC+2, Mut...@dastardlyhq.com wrote:
> On Thu, 2 Mar 2023 01:32:07 -0800 (PST) 
> Malcolm McLean <malcolm.ar...@gmail.com> wrote: 
> >On Thursday, 2 March 2023 at 09:09:02 UTC, Mut...@dastardlyhq.com wrote: 
> >> On Wed, 01 Mar 2023 19:53:36 +0000 
> >> Ben Bacarisse <ben.u...@bsb.me.uk> wrote: 
> >> >Mut...@dastardlyhq.com writes: 
> >> > 
> >> >> On Tue, 28 Feb 2023 18:34:10 +0100 
> >> >> David Brown <david...@hesbynett.no> wrote: 
> >> >>>On 28/02/2023 16:56, Mut...@dastardlyhq.com wrote: 
> >> >>>> A function can follow specifications to the letter and still have 
> >hidden 
> >> >>>> bugs. 
> >> >>> 
> >> >>>The /specification/ can have bugs or be inappropriate in some way. The 
> >> >>>/hardware/ can have bugs. But if a piece of code gives the specified 
> >> >>>output and effects for the specified inputs, then it is correct and 
> >> >>>bug-free. 
> >> >> 
> >> >> Really? 
> >> >> 
> >> >> Spec: function always returns 10 
> >> >> 
> >> >> int func() 
> >> >> { 
> >> >> char *ptr = 0; 
> >> >> for(int i=0;i < 100000;++i) ptr[i] = 0; 
> >> >> return 10; 
> >> >> } 
> >> >> 
> >> >> Bug free? 
> >> > 
> >> >No, the code does not meet it's specification. In fact, the code has 
> >> >no defined behaviour at all. 
> >> The specifaction is it returns 10. It does that. You're assuming it will 
> >> always crash which isn't necessarily the case depending on what machine its 
> >> running on. 
> >> 
> >Not necessarily. It might crash or might not. Or it might even overwrite the 
> >area of memory used to hold return values, and return a value other than 10.
> The return value will be a literal in the program text area and if it 
> changed that it would probably be changing the program code itself. 
> 
> Regardless - the function returns 10 as per the spec. The spec doesn't mention 
> that it also shouldn't crash.
> 
Are you suggesting that "should not leak resources", "should not crash,
should not hang, should not reboot the system" etc. (billions of bad
things)  "when  preconditions are met" must be specified per each function? 
Good luck trying to find anyone who wants to pay for that.
 

[toc] | [prev] | [next] | [standalone]


#89383

FromDavid Brown <david.brown@hesbynett.no>
Date2023-03-02 15:00 +0100
Message-ID<ttqa6o$afal$1@dont-email.me>
In reply to#89382
On 02/03/2023 13:02, Öö Tiib wrote:
> On Thursday, 2 March 2023 at 11:56:46 UTC+2, Mut...@dastardlyhq.com wrote:
>>
>> Regardless - the function returns 10 as per the spec. The spec doesn't mention
>> that it also shouldn't crash.
>>
> Are you suggesting that "should not leak resources", "should not crash,
> should not hang, should not reboot the system" etc. (billions of bad
> things)  "when  preconditions are met" must be specified per each function?
> Good luck trying to find anyone who wants to pay for that.
>   
> 

It is not actually /entirely/ a bad idea to specify what should /not/ 
happen, at least in some circumstances.  I don't think it is helpful in 
software specifications here - I think it is entirely reasonable to view 
"no possible impact on observable behaviour unless specified" as standard.

It is also normal for things like "must be written in C++17 standard", 
"must be clear and maintainable code", "must be reasonably efficient", 
etc., to be part of a "global" specification for code.  (Projects will, 
obviously, vary wildly in regards to their needs here.)

However, for some things, there can be other aspects that are 
requirements but which do not fit quite so well with the idea of pre- 
and post-conditions, such as speed or timing limits.  Formally, these 
could be viewed in terms of inputs and outputs, much like input/output 
actions can be viewed in pure functional languages in terms of inputting 
the world before the action, and returning the world after the action. 
But it could easily be messy, and there are better ways to specify such 
requirements.

Things can get more complicated in hardware, especially from the 
security viewpoint.  There are so many minor effects that are not 
intended to be observable, and are not part of the functionality, making 
them very difficult to specify.  Here you can't just say "don't do 
anything else" - that is fine for abstract ideas like software, but not 
for real, physical things.  How can you specify "the cpu should not be 
vulnerable to Spectra or Meltdown or Rowhammer or similar attacks" ?  At 
best, once an attack is described, you can specify for that particular 
effect - but you can't specify for things that haven't yet been 
considered.  And if you can't specify it, you can't be sure it is correct.

[toc] | [prev] | [next] | [standalone]


#89387

FromÖö Tiib <ootiib@hot.ee>
Date2023-03-02 07:59 -0800
Message-ID<cfc42520-65da-42d9-a15a-80c05761bc72n@googlegroups.com>
In reply to#89383
On Thursday, 2 March 2023 at 16:01:19 UTC+2, David Brown wrote:
> On 02/03/2023 13:02, Öö Tiib wrote: 
> > On Thursday, 2 March 2023 at 11:56:46 UTC+2, Mut...@dastardlyhq.com wrote: 
> >> 
> >> Regardless - the function returns 10 as per the spec. The spec doesn't mention 
> >> that it also shouldn't crash. 
> >> 
> > Are you suggesting that "should not leak resources", "should not crash, 
> > should not hang, should not reboot the system" etc. (billions of bad 
> > things) "when preconditions are met" must be specified per each function? 
> > Good luck trying to find anyone who wants to pay for that. 
> > 
> >
> It is not actually /entirely/ a bad idea to specify what should /not/ 
> happen, at least in some circumstances. I don't think it is helpful in 
> software specifications here - I think it is entirely reasonable to view 
> "no possible impact on observable behaviour unless specified" as standard.
> 
It is typically specified on some higher level guidelines and standards. These
are often hundreds of pages documents even for C ... like that should not
pass wrongly aligned pointers, should not use potentially tainted data as 
(part of) format strings, should not perform operations on "device" files,
should not copy FILE objects, should not leave return values that may
indicate failure (like calloc, snprintf etc.) unchecked etc. I was asking about
specification to *each* function.
> 
> It is also normal for things like "must be written in C++17 standard", 
> "must be clear and maintainable code", "must be reasonably efficient", 
> etc., to be part of a "global" specification for code. (Projects will, 
> obviously, vary wildly in regards to their needs here.) 
> 
Yes, and also the higher level documents differ per project.
> 
> However, for some things, there can be other aspects that are 
> requirements but which do not fit quite so well with the idea of pre- 
> and post-conditions, such as speed or timing limits. Formally, these 
> could be viewed in terms of inputs and outputs, much like input/output 
> actions can be viewed in pure functional languages in terms of inputting 
> the world before the action, and returning the world after the action. 
> But it could easily be messy, and there are better ways to specify such 
> requirements. 
> 
> Things can get more complicated in hardware, especially from the 
> security viewpoint. There are so many minor effects that are not 
> intended to be observable, and are not part of the functionality, making 
> them very difficult to specify. Here you can't just say "don't do 
> anything else" - that is fine for abstract ideas like software, but not 
> for real, physical things. How can you specify "the cpu should not be 
> vulnerable to Spectra or Meltdown or Rowhammer or similar attacks" ? At 
> best, once an attack is described, you can specify for that particular 
> effect - but you can't specify for things that haven't yet been 
> considered. And if you can't specify it, you can't be sure it is correct.
> 
Known hardware vulnerabilities can be worked against with software or
by using compilers/tools that are designed to work against those. 
Unknown vulnerabilities can be only fixed with patches after those 
become known.

[toc] | [prev] | [next] | [standalone]


#89385

FromMuttley@dastardlyhq.com
Date2023-03-02 15:38 +0000
Message-ID<ttqft2$b1lh$1@dont-email.me>
In reply to#89382
On Thu, 2 Mar 2023 04:02:55 -0800 (PST)
=?UTF-8?B?w5bDtiBUaWli?= <ootiib@hot.ee> wrote:
>On Thursday, 2 March 2023 at 11:56:46 UTC+2, Mut...@dastardlyhq.com wrote:
>> On Thu, 2 Mar 2023 01:32:07 -0800 (PST) 
>> Malcolm McLean <malcolm.ar...@gmail.com> wrote: 
>> >On Thursday, 2 March 2023 at 09:09:02 UTC, Mut...@dastardlyhq.com wrote: 
>> >> On Wed, 01 Mar 2023 19:53:36 +0000 
>> >> Ben Bacarisse <ben.u...@bsb.me.uk> wrote: 
>> >> >Mut...@dastardlyhq.com writes: 
>> >> > 
>> >> >> On Tue, 28 Feb 2023 18:34:10 +0100 
>> >> >> David Brown <david...@hesbynett.no> wrote: 
>> >> >>>On 28/02/2023 16:56, Mut...@dastardlyhq.com wrote: 
>> >> >>>> A function can follow specifications to the letter and still have 
>> >hidden 
>> >> >>>> bugs. 
>> >> >>> 
>> >> >>>The /specification/ can have bugs or be inappropriate in some way. The 
>
>> >> >>>/hardware/ can have bugs. But if a piece of code gives the specified 
>> >> >>>output and effects for the specified inputs, then it is correct and 
>> >> >>>bug-free. 
>> >> >> 
>> >> >> Really? 
>> >> >> 
>> >> >> Spec: function always returns 10 
>> >> >> 
>> >> >> int func() 
>> >> >> { 
>> >> >> char *ptr = 0; 
>> >> >> for(int i=0;i < 100000;++i) ptr[i] = 0; 
>> >> >> return 10; 
>> >> >> } 
>> >> >> 
>> >> >> Bug free? 
>> >> > 
>> >> >No, the code does not meet it's specification. In fact, the code has 
>> >> >no defined behaviour at all. 
>> >> The specifaction is it returns 10. It does that. You're assuming it will 
>> >> always crash which isn't necessarily the case depending on what machine
>its 
>> >> running on. 
>> >> 
>> >Not necessarily. It might crash or might not. Or it might even overwrite
>the 
>> >area of memory used to hold return values, and return a value other than 10.
>
>> The return value will be a literal in the program text area and if it 
>> changed that it would probably be changing the program code itself. 
>> 
>> Regardless - the function returns 10 as per the spec. The spec doesn't
>mention 
>> that it also shouldn't crash.
>> 
>Are you suggesting that "should not leak resources", "should not crash,
>should not hang, should not reboot the system" etc. (billions of bad
>things)  "when  preconditions are met" must be specified per each function? 
>Good luck trying to find anyone who wants to pay for that.

Thats my point! Specs do NOT include that sort of detail so a function can
follow a spec perfectly but still crash or fail in some other way which
is contrary to what Mr Brown was saying.

[toc] | [prev] | [next] | [standalone]


#89393

From"james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu>
Date2023-03-02 11:16 -0800
Message-ID<8cc85097-3b69-4ed6-8b81-c6ae057ae72bn@googlegroups.com>
In reply to#89385
On Thursday, March 2, 2023 at 10:38:24 AM UTC-5, Mut...@dastardlyhq.com wrote:
> On Thu, 2 Mar 2023 04:02:55 -0800 (PST) 
...
> >Are you suggesting that "should not leak resources", "should not crash, 
> >should not hang, should not reboot the system" etc. (billions of bad 
> >things) "when preconditions are met" must be specified per each function? 
> >Good luck trying to find anyone who wants to pay for that.
> Thats my point! Specs do NOT include that sort of detail so a function can 
> follow a spec perfectly but still crash or fail in some other way which 
> is contrary to what Mr Brown was saying.

If the crash does not occur until after the routine has returned a value of 10,
and the calling routine has completed everything it needs to do, that might be
the case. But if this code results in a crash, it's likely to occur before the
return statement. Code which fails to return a value of 10, because it caused
a crash, cannot be said to have met the specification. Code which defers the
crash until after the value of 10 has been returned, but before the calling
routine can make any use of that value, is just as bad.

[toc] | [prev] | [next] | [standalone]


#89392

From"james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu>
Date2023-03-02 11:08 -0800
Message-ID<a4f084ce-8365-4098-a010-79edd1139f40n@googlegroups.com>
In reply to#89376
On Thursday, March 2, 2023 at 4:09:02 AM UTC-5, Mut...@dastardlyhq.com wrote:
> On Wed, 01 Mar 2023 19:53:36 +0000 
> Ben Bacarisse <ben.u...@bsb.me.uk> wrote: 
> >Mut...@dastardlyhq.com writes: 
...
> >> Spec: function always returns 10 
> >> 
> >> int func() 
> >> { 
> >> char *ptr = 0; 
> >> for(int i=0;i < 100000;++i) ptr[i] = 0; 
> >> return 10; 
> >> } 
> >> 
> >> Bug free? 
> > 
> >No, the code does not meet it's specification. In fact, the code has 
> >no defined behaviour at all.
> The specifaction is it returns 10. It does that. You're assuming it will 
> always crash which isn't necessarily the case depending on what machine its 
> running on.

He didn't say "will always crash", he said "no defined behavior". If the standard
were changed to guarantee that this code would always crash, that would
constitute defined behavior. Undefined behavior means "behavior for which
this document [the C++ standard] imposes no requirements" (3.30). That code
dereferences a null pointer value, and adds a number greater than 0 to that
pointer value - two separate reasons whey the behavior is undefined. Some
other document might define what the behavior of that code is, but the C++
standard does not.

A program can only be considered to meet a specification if there is
something, somewhere, that defines what the behavior of that program will
be, and only if that behavior matches the specification. Can you identify some
other relevant document, anywhere, that does define the behavior of this code?
What, specifically, does that document say about dereferencing null pointers
and adding non-zero quantities to null pointers?

[toc] | [prev] | [next] | [standalone]


#89406

FromMuttley@dastardlyhq.com
Date2023-03-03 09:53 +0000
Message-ID<ttsg2p$jst2$1@dont-email.me>
In reply to#89392
On Thu, 2 Mar 2023 11:08:54 -0800 (PST)
"james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu> wrote:
>On Thursday, March 2, 2023 at 4:09:02=E2=80=AFAM UTC-5, Mut...@dastardlyhq.=
>com wrote:
>> >No, the code does not meet it's specification. In fact, the code has=20
>> >no defined behaviour at all.
>> The specifaction is it returns 10. It does that. You're assuming it will=
>=20
>> always crash which isn't necessarily the case depending on what machine i=
>ts=20
>> running on.
>
>He didn't say "will always crash", he said "no defined behavior". If the st=
>andard
>were changed to guarantee that this code would always crash, that would
>constitute defined behavior. Undefined behavior means "behavior for which
>this document [the C++ standard] imposes no requirements" (3.30). That code
>dereferences a null pointer value, and adds a number greater than 0 to that
>pointer value - two separate reasons whey the behavior is undefined. Some
>other document might define what the behavior of that code is, but the C++
>standard does not.
>
>A program can only be considered to meet a specification if there is
>something, somewhere, that defines what the behavior of that program will
>be, and only if that behavior matches the specification. Can you identify s=
>ome
>other relevant document, anywhere, that does define the behavior of this co=
>de?
>What, specifically, does that document say about dereferencing null pointer=
>s
>and adding non-zero quantities to null pointers?

Whooosh....

[toc] | [prev] | [next] | [standalone]


#89423

From"james...@alumni.caltech.edu" <jameskuyper@alumni.caltech.edu>
Date2023-03-04 06:47 -0800
Message-ID<5ed58429-45ab-48b3-b3fa-7eb870524c41n@googlegroups.com>
In reply to#89406
On Friday, March 3, 2023 at 4:53:43 AM UTC-5, Mut...@dastardlyhq.com wrote:
> On Thu, 2 Mar 2023 11:08:54 -0800 (PST) 
> "james...@alumni.caltech.edu" <james...@alumni.caltech.edu> wrote: 
> >On Thursday, March 2, 2023 at 4:09:02=E2=80=AFAM UTC-5, Mut...@dastardlyhq.= 
> >com wrote: 
> >> >No, the code does not meet it's specification. In fact, the code has=20
> >> >no defined behaviour at all.
> >> The specifaction is it returns 10. It does that. You're assuming it will= 
> >=20 
> >> always crash which isn't necessarily the case depending on what machine i= 
> >ts=20 
> >> running on. 
...
> Whooosh....

That's a useless response. Let me simplify my answer in the hopes of provoking a
more useful response.
He did not in any way assume that it will always crash. He, in fact, said absolutely
nothing about crashing. He only claimed that it had no defined behavior. Since you
claim he made that assumption, please explain what led you to that false conclusion.

[toc] | [prev] | [next] | [standalone]


#89394

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2023-03-02 19:35 +0000
Message-ID<87sfenq74o.fsf@bsb.me.uk>
In reply to#89376
Muttley@dastardlyhq.com writes:

> On Wed, 01 Mar 2023 19:53:36 +0000
> Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>>Muttley@dastardlyhq.com writes:
>>
>>> On Tue, 28 Feb 2023 18:34:10 +0100
>>> David Brown <david.brown@hesbynett.no> wrote:
>>>>On 28/02/2023 16:56, Muttley@dastardlyhq.com wrote:
>>>>> A function can follow specifications to the letter and still have hidden
>>>>> bugs.
>>>>
>>>>The /specification/ can have bugs or be inappropriate in some way.  The 
>>>>/hardware/ can have bugs.  But if a piece of code gives the specified 
>>>>output and effects for the specified inputs, then it is correct and 
>>>>bug-free.
>>>
>>> Really?
>>>
>>> Spec: function always returns 10
>>>
>>> int func()
>>> {
>>> 	char *ptr = 0;
>>> 	for(int i=0;i < 100000;++i) ptr[i] = 0;
>>> 	return 10;
>>> }
>>>
>>> Bug free?
>>
>>No, the code does not meet it's specification.  In fact, the code has
>>no defined behaviour at all.
>
> The specifaction is it returns 10. It does that. You're assuming it will
> always crash which isn't necessarily the case depending on what machine its
> running on.

I am not assuming that.  I am assuming the semantics as defined by the C
language standard which states that the code you posted as, to put it
informally, no meaning at all.

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#89340

From"Alf P. Steinbach" <alf.p.steinbach@gmail.com>
Date2023-02-28 17:40 +0100
Message-ID<ttlaqc$3lckd$1@dont-email.me>
In reply to#89326
On 2023-02-28 9:38 AM, Muttley@dastardlyhq.com wrote:
> 
> Whatever you say. I'm surprised you even post to a C++ group as why would you
> need the safety benefits of the language when clearly you're a master of
> unchecked accesses? Real programmers don't bounds check arrays or check for
> valid pointer values before they use them - just do a Nike, right?

In case you're not just trolling, to get more background on the "no 
precondition check" view I recommend diving into Bertrand Meyer's 
classic book Object-Oriented Software Construction, in particular 
chapter 11 "Design by Contract: building reliable software" and chapter 
12 "When the contract is broken: exception handling".

With Eiffel (BM's own language) one can turn checking on or off, sort of 
like `assert`s in C++.

The ideal BM argues for relies heavily on that and other language and 
tool support that just isn't there for C++ in general.

However, there's are reasons why C++ is still popular and BM's newer 
more ideal language Eiffel never gained widespread popularity, and IMO a 
main one is that C++ is very much about dealing with an imperfect real 
world, including imperfect language and tool support.

And that includes that not everything needs to be automated: with a 
little extra effort we can do without the conveniences of Eiffel, and 
then (with that little extra effort) "no checking" can be practical.


- Alf

Link: https://en.wikipedia.org/wiki/Object-Oriented_Software_Construction

[toc] | [prev] | [next] | [standalone]


#89295

FromJames Kuyper <jameskuyper@alumni.caltech.edu>
Date2023-02-24 12:16 -0500
Message-ID<ttarcv$28r96$1@dont-email.me>
In reply to#89287
On 2/24/23 11:20, David Brown wrote:
...
> more posts.  Both the "is*()" functions and "printf" are specified in 
> the C standards, which do not distinguish between the "core language" 
> and the "standard library" - both aspects are part of the C programming 
> language.

That's not quite the case. Section 6 is titled "Language", and section 7
is titled "Library", so it does distinguish them - but it provides
specifications for both, and mandates that in a conforming
implementation, they work together to meet the requirements imposed upon
the implementation.

Since we are discussing the C standard in comp.lang.c++ (without having
veered off-topic - the C++ standard defines the behavior of the <ctype>
functions only by cross-referencing the definitions of the <ctype.h>
functions in the C standard), it should be noted that it isn't quite the
same in the C++ standard. Sections 16-32 of the C++ standard each have a
title referring to the C++ standard library, but sections 5-15, which
describe the C++ language, don't say so in their titles. However,
section 4.2p1-2 does explicitly describe this organizational structure

[toc] | [prev] | [next] | [standalone]


#89298

FromDavid Brown <david.brown@hesbynett.no>
Date2023-02-24 18:39 +0100
Message-ID<ttasos$293ua$1@dont-email.me>
In reply to#89295
On 24/02/2023 18:16, James Kuyper wrote:
> On 2/24/23 11:20, David Brown wrote:
> ...
>> more posts.  Both the "is*()" functions and "printf" are specified in
>> the C standards, which do not distinguish between the "core language"
>> and the "standard library" - both aspects are part of the C programming
>> language.
> 
> That's not quite the case. Section 6 is titled "Language", and section 7
> is titled "Library", so it does distinguish them - but it provides
> specifications for both, and mandates that in a conforming
> implementation, they work together to meet the requirements imposed upon
> the implementation.
> 
> Since we are discussing the C standard in comp.lang.c++ (without having
> veered off-topic - the C++ standard defines the behavior of the <ctype>
> functions only by cross-referencing the definitions of the <ctype.h>
> functions in the C standard), it should be noted that it isn't quite the
> same in the C++ standard. Sections 16-32 of the C++ standard each have a
> title referring to the C++ standard library, but sections 5-15, which
> describe the C++ language, don't say so in their titles. However,
> section 4.2p1-2 does explicitly describe this organizational structure

While there are different sections of the standards that cover the 
library in detail, the standard libraries (in both C and C++) are 
intertwined with the "core language" to some extent.  For example, the C 
"sizeof" operator returns a type that is declared in library headers, 
some uses of the C++ "new" operator require inclusion of a standard 
library header, and both languages have standard library functions that 
cannot be implemented purely in the language itself.

Sometimes it is useful to distinguish a bit between "core language" 
features and "standard library" features, and sometimes compilers and 
standard libraries are implemented by separate groups.  But they are 
still defined in the same standards documents, still part of an 
"implementation", and of very limited use if considered separately.

[toc] | [prev] | [next] | [standalone]


#89303

FromKeith Thompson <Keith.S.Thompson+u@gmail.com>
Date2023-02-24 10:03 -0800
Message-ID<87h6vbndod.fsf@nosuchdomain.example.com>
In reply to#89298
David Brown <david.brown@hesbynett.no> writes:
[...]
> While there are different sections of the standards that cover the
> library in detail, the standard libraries (in both C and C++) are 
> intertwined with the "core language" to some extent.  For example, the
> C "sizeof" operator returns a type that is declared in library
> headers, some uses of the C++ "new" operator require inclusion of a
> standard library header, and both languages have standard library
> functions that cannot be implemented purely in the language itself.

I mostly agree, but I don't think sizeof is a good example.

The language-defined sizeof operator yields a result of an
implementation-defined unsigned integer type.  The library provides a
name for that type, but a program can use sizeof without referring to
that name.

-- 
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for XCOM Labs
void Void(void) { Void(); } /* The recursive call of the void */

[toc] | [prev] | [next] | [standalone]


#89304

FromDavid Brown <david.brown@hesbynett.no>
Date2023-02-24 19:59 +0100
Message-ID<ttb1f6$29kd9$1@dont-email.me>
In reply to#89303
On 24/02/2023 19:03, Keith Thompson wrote:
> David Brown <david.brown@hesbynett.no> writes:
> [...]
>> While there are different sections of the standards that cover the
>> library in detail, the standard libraries (in both C and C++) are
>> intertwined with the "core language" to some extent.  For example, the
>> C "sizeof" operator returns a type that is declared in library
>> headers, some uses of the C++ "new" operator require inclusion of a
>> standard library header, and both languages have standard library
>> functions that cannot be implemented purely in the language itself.
> 
> I mostly agree, but I don't think sizeof is a good example.
> 
> The language-defined sizeof operator yields a result of an
> implementation-defined unsigned integer type.  The library provides a
> name for that type, but a program can use sizeof without referring to
> that name.
> 

Fair point.

[toc] | [prev] | [next] | [standalone]


#89306

From"Alf P. Steinbach" <alf.p.steinbach@gmail.com>
Date2023-02-25 06:47 +0100
Message-ID<ttc7dd$2gar3$1@dont-email.me>
In reply to#89298
On 2023-02-24 6:39 PM, David Brown wrote:
> On 24/02/2023 18:16, James Kuyper wrote:
>> On 2/24/23 11:20, David Brown wrote:
>> ...
>>> more posts.  Both the "is*()" functions and "printf" are specified in
>>> the C standards, which do not distinguish between the "core language"
>>> and the "standard library" - both aspects are part of the C programming
>>> language.
>>
>> That's not quite the case. Section 6 is titled "Language", and section 7
>> is titled "Library", so it does distinguish them - but it provides
>> specifications for both, and mandates that in a conforming
>> implementation, they work together to meet the requirements imposed upon
>> the implementation.
>>
>> Since we are discussing the C standard in comp.lang.c++ (without having
>> veered off-topic - the C++ standard defines the behavior of the <ctype>
>> functions only by cross-referencing the definitions of the <ctype.h>
>> functions in the C standard), it should be noted that it isn't quite the
>> same in the C++ standard. Sections 16-32 of the C++ standard each have a
>> title referring to the C++ standard library, but sections 5-15, which
>> describe the C++ language, don't say so in their titles. However,
>> section 4.2p1-2 does explicitly describe this organizational structure
> 
> While there are different sections of the standards that cover the 
> library in detail, the standard libraries (in both C and C++) are 
> intertwined with the "core language" to some extent.  For example, the C 
> "sizeof" operator returns a type that is declared in library headers, 
> some uses of the C++ "new" operator require inclusion of a standard 
> library header, and both languages have standard library functions that 
> cannot be implemented purely in the language itself.

     #include    <initializer_list>  // std::initializer_list, for use 
in range based `for`.
     #include    <new>               // std::operator new, for placement 
`new` expressions.
     #include    <typeinfo>          // std::type/info, for using `typeid`.

     #if CPP_VERSION >= CPP20
     #   include     <compare>           // for checking result of 
spaceship operator `<=>`.
     #endif


> Sometimes it is useful to distinguish a bit between "core language" 
> features and "standard library" features, and sometimes compilers and 
> standard libraries are implemented by separate groups.  But they are 
> still defined in the same standards documents, still part of an 
> "implementation", and of very limited use if considered separately.

It's freaking brain-dead to have the core language depend on 4 library 
headers. Or even 1. So the question is, WHO has come up with this madness?

I almost guarantee, it's not Bjarne.


- Alf


[toc] | [prev] | [next] | [standalone]


#89308

FromPaavo Helde <eesnimi@osa.pri.ee>
Date2023-02-25 10:23 +0200
Message-ID<ttcghe$2h1im$1@dont-email.me>
In reply to#89306
25.02.2023 07:47 Alf P. Steinbach kirjutas:
> On 2023-02-24 6:39 PM, David Brown wrote:

>> While there are different sections of the standards that cover the 
>> library in detail, the standard libraries (in both C and C++) are 
>> intertwined with the "core language" to some extent.  For example, the 
>> C "sizeof" operator returns a type that is declared in library 
>> headers, some uses of the C++ "new" operator require inclusion of a 
>> standard library header, and both languages have standard library 
>> functions that cannot be implemented purely in the language itself.
> 
>      #include    <initializer_list>  // std::initializer_list, for use 
> in range based `for`.
>      #include    <new>               // std::operator new, for placement 
> `new` expressions.
>      #include    <typeinfo>          // std::type/info, for using `typeid`.
> 
>      #if CPP_VERSION >= CPP20
>      #   include     <compare>           // for checking result of 
> spaceship operator `<=>`.
>      #endif
> 
> 
>> Sometimes it is useful to distinguish a bit between "core language" 
>> features and "standard library" features, and sometimes compilers and 
>> standard libraries are implemented by separate groups.  But they are 
>> still defined in the same standards documents, still part of an 
>> "implementation", and of very limited use if considered separately.
> 
> It's freaking brain-dead to have the core language depend on 4 library 
> headers. Or even 1. So the question is, WHO has come up with this madness?
> 
> I almost guarantee, it's not Bjarne.

Already this requires a header include:

int main() {
	return EXIT_FAILURE;
}

[toc] | [prev] | [next] | [standalone]


#89229

FromAndrey Tarasevich <andreytarasevich@hotmail.com>
Date2023-02-23 07:16 -0800
Message-ID<tt7vvu$1t5b1$2@dont-email.me>
In reply to#89222
On 02/23/23 2:34 AM, Muttley@dastardlyhq.com wrote:
>>
>> Undefined behavior may or may not involve a program crash.
> 
> I would still consider a crash to be a bug. Undefined would just be returning
> rubbish.

Nope. "Returning rubbish" would be an example _unspecified behavior_. 
Undefined is a wholly different thing.

-- 
Best regards,
Andrey

[toc] | [prev] | [next] | [standalone]


#89262

FromKeith Thompson <Keith.S.Thompson+u@gmail.com>
Date2023-02-23 14:31 -0800
Message-ID<878rgoovxs.fsf@nosuchdomain.example.com>
In reply to#89229
Andrey Tarasevich <andreytarasevich@hotmail.com> writes:
> On 02/23/23 2:34 AM, Muttley@dastardlyhq.com wrote:
>>>
>>> Undefined behavior may or may not involve a program crash.
>> I would still consider a crash to be a bug. Undefined would just be
>> returning
>> rubbish.
>
> Nope. "Returning rubbish" would be an example _unspecified
> behavior_. Undefined is a wholly different thing.

Crashing, returning rubbish, returning a sensible result, and
making demons fly out of your nose are *all* permitted consequences
of undefined behavior.

Unspecified behavior is limited to two or more possibilities
that are always (C) or usually (C++) specified by the standard.
Implementation-defined behavior is unspecified behavior where
the implementation must document its choice.  The standard never
includes nasal demons as one of the possibilities.

-- 
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for XCOM Labs
void Void(void) { Void(); } /* The recursive call of the void */

[toc] | [prev] | [next] | [standalone]


#89231

From"Alf P. Steinbach" <alf.p.steinbach@gmail.com>
Date2023-02-23 16:34 +0100
Message-ID<tt8131$1tbdv$1@dont-email.me>
In reply to#89222
On 2023-02-23 11:34 AM, Muttley@dastardlyhq.com wrote:
> On Thu, 23 Feb 2023 12:30:39 +0200
> Paavo Helde <eesnimi@osa.pri.ee> wrote:
>> 23.02.2023 11:35 Muttley@dastardlyhq.com kirjutas:
>>> On Thu, 23 Feb 2023 09:39:04 +0200
>>> Paavo Helde <eesnimi@osa.pri.ee> wrote:
>>>> 22.02.2023 11:25 Muttley@dastardlyhq.com kirjutas:
>>>>
>>>>> Absolute rubbish. Why would UTF8 have anything to do with "safety"? Safety
>>>>> means will the program crash or have hidden bugs, not whether a string gets
>>
>>>>> translated into uppercase properly or not which would be immediately
>> obvious.
>>>>
>>>>
>>>>
>>>> Because you asked: I have seen isdigit() crashing hard on negative
>>>
>>> Thats clearly a library bug. All bets are off when they exist.
>>
>> What makes you think so? The C standard clearly says in 7.4 (Character
>> handling <ctype.h>):
>>
>> "In all cases the argument is an int, the value of which shall be
>> representable as an unsigned char or shall equal the value of the macro
>> EOF. If the argument has any other value, the behavior is undefined."
>>
>> Undefined behavior may or may not involve a program crash.
> 
> I would still consider a crash to be a bug. Undefined would just be returning
> rubbish. I can't even figure out HOW it would crash since all its doing is
> 
> return (c >= '0' && c <= '9')
> 
> unless there's some obscure way of doing that test even faster.
> 

An MS runtime library example, but apparently this is old code, not for 
the current version:

<url: 
https://github.com/ojdkbuild/tools_toolchain_sdk10_1607/blob/master/Source/10.0.14393.0/ucrt/convert/isctype.cpp#L34-L39>

     // The _chvalidator function is called by the character 
classification functions
     // in the debug CRT.  This function tests the character argument to 
ensure that
     // it is not out of range.  For performance reasons, this function 
is not used
     // in the retail CRT.
     #if defined _DEBUG

     extern "C" int __cdecl _chvalidator(int const c, int const mask)
     {
         _ASSERTE(c >= -1 && c <= 255);
         return _chvalidator_l(nullptr, c, mask);
     }

     extern "C" int __cdecl _chvalidator_l(_locale_t const locale, int 
const c, int const mask)
     {
         _ASSERTE(c >= -1 && c <= 255);

         _LocaleUpdate locale_update(locale);

         int const index = (c >= -1 && c <= 255) ? c : -1;

         return 
locale_update.GetLocaleT()->locinfo->_public._locale_pctype[index] & mask;
     }

     #endif // _DEBUG

In addition to explicit assertions, array indexing out of bounds can 
cause a crash, in the Linux world a "segfault".

Implementations do access arrays with the character code as index 
because functions like `toupper` are locale dependent and in practice 
support a number of encodings such as Latin-1, in addition to ASCII.

- Alf

[toc] | [prev] | [next] | [standalone]


#89237

FromMuttley@dastardlyhq.com
Date2023-02-23 16:15 +0000
Message-ID<tt83ei$1tlre$1@dont-email.me>
In reply to#89231
On Thu, 23 Feb 2023 16:34:57 +0100
"Alf P. Steinbach" <alf.p.steinbach@gmail.com> wrote:
>On 2023-02-23 11:34 AM, Muttley@dastardlyhq.com wrote:
>Implementations do access arrays with the character code as index 
>because functions like `toupper` are locale dependent and in practice 
>support a number of encodings such as Latin-1, in addition to ASCII.

The digit characters are the same valid regardless of which 8 bit code page is
being used. Ditto UTF16 and UTF8, so I have no idea in which locale the
numeric digits would have different values.

[toc] | [prev] | [next] | [standalone]


Page 8 of 11 — ← Prev page 1 … 6 7 [8] 9 10 11  Next page →

Back to top | Article view | comp.lang.c++


csiph-web