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

Groups > comp.lang.forth > #16855 > unrolled thread

Is there a better way?

Back to article view | Back to comp.lang.forth

Contents

  Is there a better way? Mark Wills <forthfreak@gmail.com> - 2012-10-31 04:58 -0700
    Re: Is there a better way? Paul Rubin <no.email@nospam.invalid> - 2012-10-31 05:22 -0700
      Re: Is there a better way? Mark Wills <forthfreak@gmail.com> - 2012-10-31 05:44 -0700
        Re: Is there a better way? "Rod Pemberton" <do_not_have@notemailnotz.cnm> - 2012-10-31 11:29 -0400
          Re: Is there a better way? "Rod Pemberton" <do_not_have@notemailnotz.cnm> - 2012-10-31 11:40 -0400
            Re: Is there a better way? Mark Wills <forthfreak@gmail.com> - 2012-10-31 08:45 -0700
              Re: Is there a better way? "Rod Pemberton" <do_not_have@notemailnotz.cnm> - 2012-11-02 04:48 -0400
            Re: Is there a better way? rickman <gnuarm@gmail.com> - 2012-10-31 21:42 -0400
              Re: Is there a better way? Hugh Aguilar <hughaguilar96@yahoo.com> - 2012-11-01 19:19 -0700
                Re: Is there a better way? rickman <gnuarm@gmail.com> - 2012-11-02 13:06 -0400
                  Re: Is there a better way? Andrew Haley <andrew29@littlepinkcloud.invalid> - 2012-11-02 12:18 -0500
                    Re: Is there a better way? rickman <gnuarm@gmail.com> - 2012-11-02 14:34 -0400
                      Re: Is there a better way? Paul Rubin <no.email@nospam.invalid> - 2012-11-02 11:39 -0700
                        Re: Is there a better way? rickman <gnuarm@gmail.com> - 2012-11-02 14:43 -0400
                          Re: Is there a better way? Andrew Haley <andrew29@littlepinkcloud.invalid> - 2012-11-04 02:36 -0600
                            Re: Is there a better way? rickman <gnuarm@gmail.com> - 2012-11-04 14:18 -0500
                      Re: Is there a better way? Mark Wills <forthfreak@gmail.com> - 2012-11-02 14:38 -0700
                        Re: Is there a better way? Andrew Haley <andrew29@littlepinkcloud.invalid> - 2012-11-04 03:01 -0600
                          Re: Is there a better way? Mark Wills <forthfreak@gmail.com> - 2012-11-04 03:54 -0800
                            Re: Is there a better way? Andrew Haley <andrew29@littlepinkcloud.invalid> - 2012-11-04 07:59 -0600
                            Re: Is there a better way? Elizabeth D Rather <erather@forth.com> - 2012-11-04 08:34 -1000
                              Re: Is there a better way? Hugh Aguilar <hughaguilar96@yahoo.com> - 2012-11-04 15:22 -0800
                                Re: Is there a better way? Mark Wills <forthfreak@gmail.com> - 2012-11-05 02:39 -0800
                                  Words consuming arguments, was [Re: Is there a better way?] "Rod Pemberton" <do_not_have@notemailnotz.cnm> - 2012-11-05 14:01 -0500
                                    Re: Words consuming arguments, was [Re: Is there a better way?] "Elizabeth D. Rather" <erather@forth.com> - 2012-11-05 10:39 -1000
                                      Re: Words consuming arguments, was [Re: Is there a better way?] Hugh Aguilar <hughaguilar96@yahoo.com> - 2012-11-05 21:07 -0800
                                        Re: Words consuming arguments, was [Re: Is there a better way?] "Rod Pemberton" <do_not_have@notemailnotz.cnm> - 2012-11-06 20:57 -0500
                                          Re: Words consuming arguments, was [Re: Is there a better way?] Hugh Aguilar <hughaguilar96@yahoo.com> - 2012-11-06 21:43 -0800
                                            Re: Words consuming arguments, was [Re: Is there a better way?] Mark Wills <forthfreak@gmail.com> - 2012-11-07 03:52 -0800
                                            Re: Words consuming arguments, was [Re: Is there a better way?] "Rod Pemberton" <do_not_have@notemailnotz.cnm> - 2012-11-07 19:55 -0500
                                              Re: Words consuming arguments, was [Re: Is there a better way?] "Elizabeth D. Rather" <erather@forth.com> - 2012-11-07 20:46 -1000
                                                Re: Words consuming arguments, was [Re: Is there a better way?] stephenXXX@mpeforth.com (Stephen Pelc) - 2012-11-08 10:39 +0000
                                              Re: Words consuming arguments, was [Re: Is there a better way?] Andrew Haley <andrew29@littlepinkcloud.invalid> - 2012-11-12 03:48 -0600
                                                Re: Words consuming arguments, was [Re: Is there a better way?] "Elizabeth D. Rather" <erather@forth.com> - 2012-11-12 07:57 -1000
                                                  Re: Words consuming arguments, was [Re: Is there a better way?] "Rod Pemberton" <do_not_have@notemailnotz.cnm> - 2012-11-12 19:50 -0500
                                                Re: Words consuming arguments, was [Re: Is there a better way?] "Rod Pemberton" <do_not_have@notemailnotz.cnm> - 2012-11-12 19:49 -0500
                                                  Re: Words consuming arguments, was [Re: Is there a better way?] "Elizabeth D. Rather" <erather@forth.com> - 2012-11-12 15:00 -1000
                                                    Re: Words consuming arguments, was [Re: Is there a better way?] Mark Wills <forthfreak@gmail.com> - 2012-11-13 00:50 -0800
                                                      Re: Words consuming arguments, was [Re: Is there a better way?] Mark Wills <forthfreak@gmail.com> - 2012-11-13 00:58 -0800
                                                        Re: Words consuming arguments, was [Re: Is there a better way?] "Elizabeth D. Rather" <erather@forth.com> - 2012-11-12 23:17 -1000
                                                      Re: Words consuming arguments, was [Re: Is there a better way?] albert@spenarnc.xs4all.nl (Albert van der Horst) - 2012-11-13 13:44 +0000
                                                      Re: Words consuming arguments, was [Re: Is there a better way?] anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2012-11-13 13:53 +0000
                                                        Re: Words consuming arguments, was [Re: Is there a better way?] Alex McDonald <blog@rivadpm.com> - 2012-11-13 06:39 -0800
                                                          Re: Words consuming arguments, was [Re: Is there a better way?] anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2012-11-13 18:02 +0000
                                                            Re: Words consuming arguments, was [Re: Is there a better way?] Alex McDonald <blog@rivadpm.com> - 2012-11-13 12:10 -0800
                                                              Re: Words consuming arguments, was [Re: Is there a better way?] anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2012-11-15 16:59 +0000
                                                        Re: Words consuming arguments, was [Re: Is there a better way?] Mark Wills <forthfreak@gmail.com> - 2012-11-13 07:55 -0800
                                                          Re: Words consuming arguments, was [Re: Is there a better way?] "Rod Pemberton" <do_not_have@notemailnotz.cnm> - 2012-11-14 06:34 -0500
                                                            Re: Words consuming arguments, was [Re: Is there a better way?] Mark Wills <forthfreak@gmail.com> - 2012-11-14 05:01 -0800
                                                              Re: Words consuming arguments, was [Re: Is there a better way?] albert@spenarnc.xs4all.nl (Albert van der Horst) - 2012-11-14 16:11 +0000
                                                              Re: Words consuming arguments, was [Re: Is there a better way?] "Elizabeth D. Rather" <erather@forth.com> - 2012-11-14 09:36 -1000
                                                                Re: Words consuming arguments, was [Re: Is there a better way?] humptydumpty <ouatubi@gmail.com> - 2012-11-14 12:19 -0800
                                                      Re: Words consuming arguments, was [Re: Is there a better way?] Andrew Haley <andrew29@littlepinkcloud.invalid> - 2012-11-13 10:20 -0600
                                                      Re: Words consuming arguments, was [Re: Is there a better way?] Brad Eckert <hwfwguy@gmail.com> - 2012-11-13 08:50 -0800
                                                      Re: Words consuming arguments, was [Re: Is there a better way?] "Rod Pemberton" <do_not_have@notemailnotz.cnm> - 2012-11-14 06:42 -0500
                                                        Re: Words consuming arguments, was [Re: Is there a better way?] stephenXXX@mpeforth.com (Stephen Pelc) - 2012-11-14 14:14 +0000
                                                          Re: Words consuming arguments, was [Re: Is there a better way?] anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2012-11-14 15:28 +0000
                                                            Re: Words consuming arguments, was [Re: Is there a better way?] Bernd Paysan <bernd.paysan@gmx.de> - 2012-11-14 17:54 +0100
                                                          Re: Words consuming arguments, was [Re: Is there a better way?] Hugh Aguilar <hughaguilar96@yahoo.com> - 2012-11-14 15:01 -0800
                                                            Re: Words consuming arguments, was [Re: Is there a better way?] Mark Wills <forthfreak@gmail.com> - 2012-11-15 00:08 -0800
                                                              Strings (was: Words consuming arguments) anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2012-11-15 15:18 +0000
                                                                Re: Strings (was: Words consuming arguments) albert@spenarnc.xs4all.nl (Albert van der Horst) - 2012-11-15 16:36 +0000
                                                                Re: Strings (was: Words consuming arguments) "Rod Pemberton" <do_not_have@notemailnotz.cnm> - 2012-11-15 18:35 -0500
                                                                  Re: Strings (was: Words consuming arguments) stephenXXX@mpeforth.com (Stephen Pelc) - 2012-11-16 00:36 +0000
                                                                    Re: Strings (was: Words consuming arguments) anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2012-11-16 17:42 +0000
                                                                  Re: Strings (was: Words consuming arguments) anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2012-11-16 17:55 +0000
                                                              Re: Words consuming arguments, was [Re: Is there a better way?] Hugh Aguilar <hughaguilar96@yahoo.com> - 2012-11-17 04:18 -0800
                                                                Re: Words consuming arguments, was [Re: Is there a better way?] Alex McDonald <blog@rivadpm.com> - 2012-11-17 04:56 -0800
                                                                  Re: Words consuming arguments, was [Re: Is there a better way?] "Elizabeth D. Rather" <erather@forth.com> - 2012-11-17 07:24 -1000
                                                                    Re: Words consuming arguments, was [Re: Is there a better way?] Hugh Aguilar <hughaguilar96@yahoo.com> - 2012-11-19 15:58 -0800
                                                                      Re: Words consuming arguments, was [Re: Is there a better way?] Brad Eckert <hwfwguy@gmail.com> - 2012-11-20 08:17 -0800
                                                    Re: Words consuming arguments, was [Re: Is there a better way?] "Rod Pemberton" <do_not_have@notemailnotz.cnm> - 2012-11-14 06:30 -0500
                                                      Re: Words consuming arguments, was [Re: Is there a better way?] "Elizabeth D. Rather" <erather@forth.com> - 2012-11-14 09:06 -1000
                                                        Re: Words consuming arguments, was [Re: Is there a better way?] "Rod Pemberton" <do_not_have@notemailnotz.cnm> - 2012-11-15 06:18 -0500
                                                  Re: Words consuming arguments, was [Re: Is there a better way?] Andrew Haley <andrew29@littlepinkcloud.invalid> - 2012-11-13 04:26 -0600
                                                    Re: Words consuming arguments, was [Re: Is there a better way?] "Rod Pemberton" <do_not_have@notemailnotz.cnm> - 2012-11-14 06:29 -0500
                                                      Re: Words consuming arguments, was [Re: Is there a better way?] Andrew Haley <andrew29@littlepinkcloud.invalid> - 2012-11-14 06:03 -0600
                                                        Re: Words consuming arguments, was [Re: Is there a better way?] "Rod Pemberton" <do_not_have@notemailnotz.cnm> - 2012-11-15 07:15 -0500
                                                          Re: Words consuming arguments, was [Re: Is there a better way?] Andrew Haley <andrew29@littlepinkcloud.invalid> - 2012-11-15 11:51 -0600
                                                            Re: Words consuming arguments, was [Re: Is there a better way?] "Rod Pemberton" <do_not_have@notemailnotz.cnm> - 2012-11-15 18:44 -0500
                                                              Re: Words consuming arguments, was [Re: Is there a better way?] Andrew Haley <andrew29@littlepinkcloud.invalid> - 2012-11-16 03:50 -0600
                                                          Re: Words consuming arguments, was [Re: Is there a better way?] "Elizabeth D. Rather" <erather@forth.com> - 2012-11-15 08:09 -1000
                                          Re: Words consuming arguments, was [Re: Is there a better way?] "Elizabeth D. Rather" <erather@forth.com> - 2012-11-06 21:19 -1000
                                            Re: Words consuming arguments, was [Re: Is there a better way?] "Rod Pemberton" <do_not_have@notemailnotz.cnm> - 2012-11-07 20:00 -0500
                                              Re: Words consuming arguments, was [Re: Is there a better way?] stephenXXX@mpeforth.com (Stephen Pelc) - 2012-11-08 10:49 +0000
                                          Re: Words consuming arguments, was [Re: Is there a better way?] albert@spenarnc.xs4all.nl (Albert van der Horst) - 2012-11-07 14:01 +0000
                        Re: Is there a better way? awegel@arcor.de (Alex Wegel) - 2012-11-04 11:07 +0100
                          Re: Is there a better way? awegel@arcor.de (Alex Wegel) - 2012-11-04 11:36 +0100
                            Re: Is there a better way? Mark Wills <forthfreak@gmail.com> - 2012-11-04 03:48 -0800
                              Re: Is there a better way? awegel@arcor.de (Alex Wegel) - 2012-11-04 13:31 +0100
                              Re: Is there a better way? Coos Haak <chforth@hccnet.nl> - 2012-11-04 13:29 +0100
                                Re: Is there a better way? Mark Wills <forthfreak@gmail.com> - 2012-11-04 04:42 -0800
                      Re: Is there a better way? Andrew Haley <andrew29@littlepinkcloud.invalid> - 2012-11-04 02:38 -0600
      Re: Is there a better way? Doug Hoffman <glidedog@gmail.com> - 2012-10-31 10:20 -0400
    Re: Is there a better way? humptydumpty <ouatubi@gmail.com> - 2012-10-31 05:53 -0700
    Re: Is there a better way? Doug Hoffman <glidedog@gmail.com> - 2012-10-31 09:23 -0400
      Re: Is there a better way? Mark Wills <forthfreak@gmail.com> - 2012-10-31 06:41 -0700
        Re: Is there a better way? Andrew Haley <andrew29@littlepinkcloud.invalid> - 2012-10-31 11:46 -0500
          Re: Is there a better way? Mark Wills <forthfreak@gmail.com> - 2012-10-31 14:27 -0700
            Re: Is there a better way? Paul Rubin <no.email@nospam.invalid> - 2012-10-31 14:32 -0700
              Re: Is there a better way? Hugh Aguilar <hughaguilar96@yahoo.com> - 2012-10-31 16:15 -0700
            Re: Is there a better way? Coos Haak <chforth@hccnet.nl> - 2012-10-31 22:49 +0100
            Re: Is there a better way? Andrew Haley <andrew29@littlepinkcloud.invalid> - 2012-10-31 17:13 -0500
              Re: Is there a better way? Mark Wills <forthfreak@gmail.com> - 2012-10-31 23:39 -0700
                Re: Is there a better way? "Elizabeth D. Rather" <erather@forth.com> - 2012-10-31 20:58 -1000
                Re: Is there a better way? Hugh Aguilar <hughaguilar96@yahoo.com> - 2012-11-01 02:04 -0700
            Re: Is there a better way? "Rod Pemberton" <do_not_have@notemailnotz.cnm> - 2012-10-31 19:13 -0400
            Re: Is there a better way? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2012-11-02 17:31 +0000
              Re: Is there a better way? Paul Rubin <no.email@nospam.invalid> - 2012-11-02 10:37 -0700
                Re: Is there a better way? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2012-11-02 18:12 +0000
                  Re: Is there a better way? "Elizabeth D. Rather" <erather@forth.com> - 2012-11-02 08:29 -1000
                    Re: Is there a better way? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2012-11-05 14:53 +0000
                  Re: Is there a better way? Paul Rubin <no.email@nospam.invalid> - 2012-11-02 11:30 -0700
                    Re: Is there a better way? Bernd Paysan <bernd.paysan@gmx.de> - 2012-11-03 00:15 +0100
                      Re: Is there a better way? rickman <gnuarm@gmail.com> - 2012-11-02 19:21 -0400
                        Re: Is there a better way? Bernd Paysan <bernd.paysan@gmx.de> - 2012-11-03 00:42 +0100
                          Re: Is there a better way? rickman <gnuarm@gmail.com> - 2012-11-02 20:21 -0400
                            Re: Is there a better way? Bernd Paysan <bernd.paysan@gmx.de> - 2012-11-03 01:44 +0100
                              Re: Is there a better way? rickman <gnuarm@gmail.com> - 2012-11-03 12:12 -0400
                                Re: Is there a better way? Bernd Paysan <bernd.paysan@gmx.de> - 2012-11-03 18:24 +0100
                                  Re: Is there a better way? rickman <gnuarm@gmail.com> - 2012-11-03 14:00 -0400
                                Re: Is there a better way? Paul Rubin <no.email@nospam.invalid> - 2012-11-03 10:29 -0700
                      Re: Is there a better way? Paul Rubin <no.email@nospam.invalid> - 2012-11-02 18:42 -0700
                    Re: Is there a better way? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2012-11-05 11:45 +0000
          Re: Is there a better way? albert@spenarnc.xs4all.nl (Albert van der Horst) - 2012-11-01 21:00 +0000
    Re: Is there a better way? albert@spenarnc.xs4all.nl (Albert van der Horst) - 2012-10-31 15:26 +0000
      Re: Is there a better way? Doug Hoffman <glidedog@gmail.com> - 2012-10-31 12:22 -0400
        Re: Is there a better way? Mark Wills <forthfreak@gmail.com> - 2012-10-31 15:07 -0700
          Re: Is there a better way? Doug Hoffman <glidedog@gmail.com> - 2012-10-31 19:16 -0400
            Re: Is there a better way? Mark Wills <forthfreak@gmail.com> - 2012-11-01 06:31 -0700
              Re: Is there a better way? Doug Hoffman <glidedog@gmail.com> - 2012-11-01 10:34 -0400
                Re: Is there a better way? Doug Hoffman <glidedog@gmail.com> - 2012-11-01 10:48 -0400
                  Re: Is there a better way? Mark Wills <forthfreak@gmail.com> - 2012-11-01 08:55 -0700
                Re: Is there a better way? Mark Wills <forthfreak@gmail.com> - 2012-11-01 08:49 -0700
                  Re: Is there a better way? Doug Hoffman <glidedog@gmail.com> - 2012-11-01 12:46 -0400
              Re: Is there a better way? Andrew Haley <andrew29@littlepinkcloud.invalid> - 2012-11-01 09:37 -0500
              Re: Is there a better way? Paul Rubin <no.email@nospam.invalid> - 2012-11-01 07:41 -0700
                Re: Is there a better way? Mark Wills <forthfreak@gmail.com> - 2012-11-01 08:52 -0700
                  Re: Is there a better way? Andrew Haley <andrew29@littlepinkcloud.invalid> - 2012-11-01 12:18 -0500
                    Re: Is there a better way? Hugh Aguilar <hughaguilar96@yahoo.com> - 2012-11-01 19:38 -0700
                      Re: Is there a better way? Mark Wills <forthfreak@gmail.com> - 2012-11-02 02:29 -0700
                        Re: Is there a better way? Hugh Aguilar <hughaguilar96@yahoo.com> - 2012-11-04 21:48 -0800
                          Re: Is there a better way? Mark Wills <forthfreak@gmail.com> - 2012-11-05 02:44 -0800
              Re: Is there a better way? Graham NEWS <gray@forthman.plus.com> - 2012-11-01 15:52 +0000
            Re: Is there a better way? Josh Grams <josh@qualdan.com> - 2012-11-03 16:38 +0000
      Re: Is there a better way? Mark Wills <forthfreak@gmail.com> - 2012-10-31 14:26 -0700
        Re: Is there a better way? rickman <gnuarm@gmail.com> - 2012-11-01 13:42 -0400
    Re: Is there a better way? Graham <""gray\"@forthman@plus.com"> - 2012-10-31 17:05 +0000
      Re: Is there a better way? Peter Fälth <peter.falth@tin.it> - 2012-10-31 12:07 -0700
        Re: Is there a better way? Paul Rubin <no.email@nospam.invalid> - 2012-10-31 12:12 -0700
          Re: Is there a better way? Mark Wills <forthfreak@gmail.com> - 2012-10-31 14:17 -0700
      Re: Is there a better way? Mark Wills <forthfreak@gmail.com> - 2012-10-31 14:21 -0700
        Re: Is there a better way? Pablo Hugo Reda <pabloreda@gmail.com> - 2012-10-31 14:50 -0700
          Re: Is there a better way? Pablo Hugo Reda <pabloreda@gmail.com> - 2012-10-31 14:51 -0700
            Re: Is there a better way? Paul Rubin <no.email@nospam.invalid> - 2012-10-31 14:57 -0700
              Re: Is there a better way? Coos Haak <chforth@hccnet.nl> - 2012-10-31 23:47 +0100
                Re: Is there a better way? mhx@iae.nl (Marcel Hendrix) - 2012-11-01 21:28 +0200
          Re: Is there a better way? Mark Wills <forthfreak@gmail.com> - 2012-10-31 15:11 -0700
            Re: Is there a better way? Pablo Hugo Reda <pabloreda@gmail.com> - 2012-10-31 15:44 -0700
              Re: Is there a better way? rickman <gnuarm@gmail.com> - 2012-11-01 13:55 -0400
    Re: Is there a better way? Hugh Aguilar <hughaguilar96@yahoo.com> - 2012-10-31 16:10 -0700
    Re: Is there a better way? Charles Mélice <charles.melice@gmail.com> - 2012-11-02 01:10 -0700
      Re: Is there a better way? Charles Mélice <charles.melice@gmail.com> - 2012-11-02 01:18 -0700
      Re: Is there a better way? Mark Wills <forthfreak@gmail.com> - 2012-11-02 01:58 -0700
        Re: Is there a better way? Charles Mélice <charles.melice@gmail.com> - 2012-11-02 02:14 -0700
          Re: Is there a better way? Charles Mélice <charles.melice@gmail.com> - 2012-11-02 02:16 -0700
            Re: Is there a better way? Andrew Haley <andrew29@littlepinkcloud.invalid> - 2012-11-02 06:16 -0500
              Re: Is there a better way? Charles Mélice <charles.melice@gmail.com> - 2012-11-02 06:04 -0700
      Re: Is there a better way? rickman <gnuarm@gmail.com> - 2012-11-02 13:13 -0400

Page 5 of 9 — ← Prev page 1 2 3 4 [5] 6 7 8 9  Next page →

#17312 — Re: Words consuming arguments, was [Re: Is there a better way?]

Rod Pemberton <do_not_have@notemailnotz.cnm> wrote:
> "Andrew Haley" <andrew29@littlepinkcloud.invalid> wrote in message
> news:yPednYu6mvIKtjjNnZ2dnUVZ8radnZ2d@supernews.com...
>> Rod Pemberton <do_not_have@notemailnotz.cnm> wrote:
>> > "Andrew Haley" <andrew29@littlepinkcloud.invalid> wrote in message
>> > news:GtOdnYh--vAWFT7NnZ2dnUVZ8iCdnZ2d@supernews.com...
> ...
> 
>> >> fig-FORTH isn't a standard; it is defined by its implementation.
>> >
>> > It's a standard of the Forth Interest Group.  You mean it's not a
>> > standard by a standards organization.
>>
>> No, I don't.  It's not really any kind of a standard, more a portable
>> implementation.  And it still defines COUNT the way every other Forth
>> does!  fig-FORTH was never going to be any use as a standard, so
>> FORTH-79, which defines COUNT in the usual way, came along shortly
>> after.
>>
>> Of course you are free to define COUNT in any way you like, but to
>> claim historical authority from a fig-FORTH glossary entry is absurd.
> 
> Well, I'm getting the impression that you've never actually seen the
> fig-Forth standards.  You seem to think it's nothing more than a
> glossary.

fig-FORTH is an implementation of Forth.

> If you had seen them, I think you'd belittle FORTH-79 as a standard.
> By comparison, it's a joke.  fig-Forth has far more than a glossary.
> It has memory diagrams for implementation of the system such what
> types of stacks, and where the stacks are supposed to be located.

Well, yes.  It's an implementation.  That's why it specifies such
things; language standards don't.

> One of them has a complete fig-Forth almost entirely in Forth with
> just minimal assembly.  It also has code for a line editor. 

Well, yes.  The fig-FORTH model.

> There are two fig-Forth document scans as text on the Internet.  One
> of them is basically just a "glossary" while the other is the more
> complete version.  There are also numerous other .pdf's which just
> include fig-Forth code in assembly for a specific platform.  Those
> don't have a "glossary" just Forth definitions in assembly.  Anyway,
> I've posted links to both scans in c.l.f. previously.

I still have a rather worn paper copy from almost 30 years ago, which
I used to port my first Forth.  Your point?

Andrew.

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

#17303 — Re: Words consuming arguments, was [Re: Is there a better way?]

On 11/15/12 2:15 AM, Rod Pemberton wrote:
...
>> FWIW, this isn't the "original" definition of COUNT .  COUNT dates
>> from before fig-FORTH, and we'd need Elizabeth's help to find its
>> earliest definition.
>>
>
> "FORTH - A Language for Interactive Computing" by Charles Moore and Geoffery
> C. Leach, 1970 doesn't have COUNT or an equivalent that I see.
>
> "Forth - The Early Years" by Chuck Moore, 1991 from HOPL, summarizes Forth
> from 1958 to 1971.  It doesn't have COUNT or an equivalent listed.
>
> Ms. Rather said COUNT has been around since 1971 elsewhere in this thread.

1971 is when I first started working with Forth. At that time Chuck's 
implementations, which had been in use at the NRAO 36' radio telescope 
for over a year, had several hundred words, most of which weren't 
mentioned in that article. Counted strings were an essential component 
of this system, and the universal representation of strings (including 
definition headers, which were stored as a full count plus the first 
three characters).

> In "Threads of a FORTH Tapestry" by Gregg Williams, BYTE Magazine,
> August 1980, he said that in 1979 he saw COUNT defined as:
>
>    : COUNT 0 DO I . LOOP ;
>
> COUNT is not listed in the Forth glossary in that 1980 issue.
>
> Forth Dimensions, Vol.1 #2, 1978 - COUNT not listed in abbreviated glossary.
> Forth Dimensions, Vol.2 #3, 1980 - COUNT used in another manner.
> Forth Dimensions, Vol.3 #1, 1981 - COUNT used correctly in code.
>
> Two fig-Forth documents from 1979 and 1980 have COUNT as posted.

figForths were pretty varied in the early years. Some of them were based 
on the NRAO systems, and some were more-or-less independently derived.

> COUNT appears in Chapter 10 of the online version of "Starting Forth" by Leo
> Brodie, 1982.
>
> Google Books shows various Forth books from 1983 to 1986 have COUNT.
>
> COUNT is in John Hayes' VAX FORTH, 1984, net.lang.forth.
>
>
> So, COUNT likely became available somewhere between 1971 and 1979.  To me,
> it looks like it's more towards fig-Forth, since 1) that's where we found it
> to be defined and 2) there are two uses of COUNT where it wasn't being used
> correctly just prior to fig-Forth.  However, I didn't locate many references
> online between those two dates.

Counted strings were in use from at least 1970, maybe in some of the 
Mohasco prototypes earlier. They were certainly essential features of 
the NRAO implementations from 1970 on. Trust me, I was there!

>>>>> It doesn't assume counted strings.
>>>>
>>>> Yes it does.  Read it again.
>>>
>>> No it doesn't.  Read it again.
>>>
>>> This time look for the word "presumed".
>>> Look up the definition for "presumed".
>>
>> It's the past participle of the verb "to presume", which means
>> variously, to assume to be true, to take for granted, to suppose, etc.
>
> FYI, "assumed to be true" is different from "is true".  One is absolutely
> true.  The other is predominantly true, but doesn't have to be true.

Funny thing, the dictionary doesn't seem to make that distinction.

> E.g., Dick Pountain's "Object-oriented Forth: implementation of data
> structures" says:
>
> "... For example, WORD returns the address of a packed string, but TYPE
> wants an unpacked string argument, so the word COUNT must be used to
> convert one to the other.  (Just for good measure Forth also throws in null
> terminated strings in the inner workings of EXPECT which covers the gamut
> of posssibilities.)"

Yes, there were also )-terminated strings to end comments and 
"-terminated strings to end strings. In other words, there was parsing, 
also dating from at least 1970.

Cheers,
Elizabeth

-- 
==================================================
Elizabeth D. Rather   (US & Canada)   800-55-FORTH
FORTH Inc.                         +1 310.999.6784
5959 West Century Blvd. Suite 700
Los Angeles, CA 90045
http://www.forth.com

"Forth-based products and Services for real-time
applications since 1973."
==================================================

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

#17102 — Re: Words consuming arguments, was [Re: Is there a better way?]

On 11/6/12 3:57 PM, Rod Pemberton wrote:
...
> What about a word like COUNT ?
>
>    COUNT ( addr -- addr len )
>
> Would you rather use a DUP every time you needed to use COUNT at the prompt?
> E.g., DUP in front of a COUNT TYPE sequence?  No, you're not going to do
> that ...  You're going to forget to use the 'pesky' DUP just as easily as
> you'd forget a 'pesky' DROP.  So, you're going to move the needed DUP into
> COUNT - as was done.   Or, you're going to rework TYPE to have DUP COUNT in
> TYPE's definition so a COUNT isn't needed prior to TYPE.  Of course, if you
> rework TYPE, then you're going to need to rework all the other words that
> COUNT is used with or within: TYPE SPAN >IN WORD S" .( EXPECT etc.  One
> solution is less work.

You're missing the point that the address COUNT returns is different 
from the input argument address: it's the address of the string (which 
us usually, though not necessarily, 1 char past the input argument. So 
COUNT does destroy its arguments, and leave results.

Cheers,
Elizabeth

-- 
==================================================
Elizabeth D. Rather   (US & Canada)   800-55-FORTH
FORTH Inc.                         +1 310.999.6784
5959 West Century Blvd. Suite 700
Los Angeles, CA 90045
http://www.forth.com

"Forth-based products and Services for real-time
applications since 1973."
==================================================

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

#17133 — Re: Words consuming arguments, was [Re: Is there a better way?]

"Elizabeth D. Rather" <erather@forth.com> wrote in message
news:Zb6dnZJPOo8dlgfNnZ2dnUVZ_oOdnZ2d@supernews.com...
> On 11/6/12 3:57 PM, Rod Pemberton wrote:
> ...
> > What about a word like COUNT ?
> >
> >    COUNT ( addr -- addr len )
> >
> > Would you rather use a DUP every time you needed to use COUNT at the
> > prompt?  E.g., DUP in front of a COUNT TYPE sequence?  No, you're
> > not going to do that ...  You're going to forget to use the 'pesky' DUP
> > just as easily as you'd forget a 'pesky' DROP.  So, you're going to move
> > the needed DUP into COUNT - as was done.   Or, you're going to rework
> > TYPE to have DUP COUNT in TYPE's definition so a COUNT isn't
> > needed prior to TYPE.  Of course, if you rework TYPE, then you're going
> > to need to rework all the other words that COUNT is used with or within:
> > TYPE SPAN >IN WORD S" .( EXPECT etc.  One solution is less work.
>
> You're missing the point that the address COUNT returns is different
> from the input argument address: it's the address of the string (which
> us usually, though not necessarily, 1 char past the input argument. So
> COUNT does destroy its arguments, and leave results.
>

Are you really attempting to tell me that adding one to the primary address
constitutes destroying it's arguments and leaving new results?

No, I'm not missing the point that the address *can* be different.  Nothing
*requires* them to be different.  There is only a requirement that COUNT
returns an address to the start of the string.  Historically, since counted
strings are used in Forth, where the count precedes the string, they are
different, as I stated.  But, if no count precedes the string, they'll be
the same.  For my Forth, they are the same, as I stated too.

Either way (counted string or not), a DUP is still required to obtain the
second address from the first for COUNT.  So, the issue of needing DUP or
DROP is still valid.  It's just a matter of which do you want and where do
you want to put it.


Rod Pemberton

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

#17144 — Re: Words consuming arguments, was [Re: Is there a better way?]

On Wed, 7 Nov 2012 20:00:00 -0500, "Rod Pemberton"
<do_not_have@notemailnotz.cnm> wrote:

>No, I'm not missing the point that the address *can* be different.  Nothing
>*requires* them to be different.

Except the ANS standard.

>There is only a requirement that COUNT
>returns an address to the start of the string.  Historically, since counted
>strings are used in Forth, where the count precedes the string, they are
>different, as I stated.  But, if no count precedes the string, they'll be
>the same.  For my Forth, they are the same, as I stated too.

At least one influential member of the ANS committee believes that it
is perfectly fine to use COUNT to step through memory
  c-addr -- c-addr+1 byte
Hence the wording in the ANS document which attempts to preserve
this entitlement. Much to my horror, the Forth200x primitive pchar
embeds this entitlement even deeper.

>Either way (counted string or not), a DUP is still required to obtain the
>second address from the first for COUNT.  So, the issue of needing DUP or
>DROP is still valid.  It's just a matter of which do you want and where do
>you want to put it.

Experience wil eventually show you that tradition, like stereotypes,
has valid roots.

Stephen

-- 
Stephen Pelc, stephenXXX@mpeforth.com
MicroProcessor Engineering Ltd - More Real, Less Time
133 Hill Lane, Southampton SO15 5AF, England
tel: +44 (0)23 8063 1441, fax: +44 (0)23 8033 9691
web: http://www.mpeforth.com - free VFX Forth downloads

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

#17118 — Re: Words consuming arguments, was [Re: Is there a better way?]

In article <k7ceuc$fb4$1@speranza.aioe.org>,
Rod Pemberton <do_not_have@notemailnotz.cnm> wrote:
>"Hugh Aguilar" <hughaguilar96@yahoo.com> wrote in message
>news:aafcb3a4-dab1-4390-8e10-b894284686c2@6g2000pbh.googlegroups.com...
>> On Nov 5, 1:39 pm, "Elizabeth D. Rather" <erat...@forth.com> wrote:
>> > On 11/5/12 9:01 AM, Rod Pemberton wrote:
>...
>
>> > > I take it this is to make sure extra arguments aren't left on the
>> > > stack as a primitive form of "error checking". However, I really
>> > > don't see the point of this. In certain situations, the style that
>> > > breaks the "rule" may [...] create more effective coding.
>>
>> > > As I see it (AISI), the primary effect of this "rule" is to shift the
>> > > location where parameters are duplicated or copied, and/or dropped. If
>> > > a word preserves arguments, then the copying is internal. If it
>> > > doesn't, then external. While the example below with the DROP has the
>> > > disadvantage of using a DROP, it has the advantage that it can modify
>> > > 'addr'. This seems to be very useful for parsing words and
>> > > linked-lists. Isn't it?
>>
>> > > : OPR ( addr -- addr ) DUP ... ;
>> > > ' addr' OPR OPR OPR OPR DROP
>>
>> > > : OPR ( addr -- ) ... ;
>> > > 'addr' DUP OPR DUP OPR DUP OPR OPR
>>
>> > Sure, there are situations when you're coding part of a process that
>> > needs to pass things right through the process. The classic example
>> > would be the output number formatting words:
>>
>> > <# starts the process, taking a double and initializing the string
>> > output area.
>>
>> > Then words like # and #s do things to the double, affecting the string
>> > under construction and passing on the modified double, and the process
>> > is completed by #> .
>>
>> > But note that # etc. are *useless* outside of this particular context.
>> > That is the tradeoff. Most of the time, it's better to code the word
>> > such that it isn't context-dependent, even though the first time you
>> > invent it it's within a specific context.
>>
>> This is what I meant earlier by the word having a "ritualistic" use.
>> My example was INIT-LIST. This is used in a very specific context and
>> always in the same way.
>>
>> Whenever you create a node, the first thing that you do with the
>> address is initialize it for whatever type it is going to be, and the
>> datum (the node address) is being carried along. This is similar to
>> how # is used only inside of <# and #>, and the datum (the double-
>> precision integer) is being carried along.
>>
>> Putting the DUP (or 2DUP or whatever) inside the word helps with
>> efficiency because the ritualistic word is typically so commonly used
>> that you will likely write in in assembly-language.
>>
>> If the word isn't used in a ritualistic manner though, then you don't
>> know if the datum is going to be needed afterward or not. You may
>> either have a DUP before the word (if it consumes its argument) or a
>> DROP after the word (if it doesn't). It is best to be consistent and
>> have the words consume their arguments. This way there is no confusion
>> about whether you need a DUP or a DROP. Also, it tends to be more
>> efficient because the code inside of the word consumes the data and
>> you don't have an explicit DROP.
>>
>> As an example, here are two ways to write the + word:
>>
>> : +  ( a b -- a+b )
>> which is used like this:
>> 5 7 + .
>> 12 ok
>>
>> or
>>
>> : +  ( a b -- a b a+b )
>> which is used like this:
>> 5 7 + . 2drop
>> 12 ok
>>
>> Pretty obvious which makes for the most readable code,
>> don't you think?
>>
>
>No, I think it depends on what is needed the most.
>
>What about a word like COUNT ?
>
>  COUNT ( addr -- addr len )
>
>Would you rather use a DUP every time you needed to use COUNT at the prompt?
>E.g., DUP in front of a COUNT TYPE sequence?  No, you're not going to do
>that ...  You're going to forget to use the 'pesky' DUP just as easily as
>you'd forget a 'pesky' DROP.  So, you're going to move the needed DUP into
>COUNT - as was done.   Or, you're going to rework TYPE to have DUP COUNT in
>TYPE's definition so a COUNT isn't needed prior to TYPE.  Of course, if you
>rework TYPE, then you're going to need to rework all the other words that
>COUNT is used with or within: TYPE SPAN >IN WORD S" .( EXPECT etc.  One
>solution is less work.
>
>I.e., Forth words that use a string seem to require both an address and
>length and so "readability" and/or "ritualistic use" doesn't seem like sound
>reasons.
>
>COUNT returns an address because of Forth's historical use of counted
>strings with the length at the start, i.e., addr needs an adjustment because
>of counted strings.  Fortunately, the fact that COUNT seems to be used as
>the primary mechanism in Forth to obtain an address and length pair for
>string related Forth words from just a string address, completely hides the
>fact that I'm using null-terminated C strings.  If Forth used other methods,
>or multiple methods, or had ways other than just one word: COUNT, then I'd
>have some problems using C style strings.  So far (it may reveal itself
>later on ...), there is only an issue if strings are constructed manually as
>counted strings, as is done in Hayes core for one of it's tests.  I.e.,
>Hayes core assumes counted strings are used in Forth.  I've not checked to
>see if they're a requirement or not, but I'm having good luck so far without
>them.  There is another situation where I had used pointers/addresses
>instead of offsets.  This is faster.  But, one of the new ANS words
>basically "forced" use of offsets.  At the time, I didn't see anything
>*requiring* offsets.  So, I may look at whether it is possible to convert
>back to pointers instead of offsets in the future.

In ciforth COUNT is called $@-BD  (string fetch "brain damaged" )

Now go figure why fetching a string - be it a brain damaged one -
is different from the usual meaning of words as a transformation of
one datum into an other one.

E.g. explain where it is different from FSIN.

>
>Rod Pemberton

Groetjes Albert

>
>
-- 
Albert van der Horst, UTRECHT,THE NETHERLANDS
Economic growth -- being exponential -- ultimately falters.
albert@spe&ar&c.xs4all.nl &=n http://home.hccnet.nl/a.w.m.van.der.horst

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

#17027

Mark Wills <forthfreak@gmail.com> wrote:

>  It was a requirement that the
> address and length be retained for further tests (the string might be
> something else that I am looking for).

Maybe you really want a proper parsing function?

I.e. more along the lines of sth like:

( c-addr1 u1 -- c-addr1 u1 false | c-addr2 u2 true )

Where c-addr2 u2 is the original string with the leading part (the "}}")
cut off.

There are some packages out there for doing stuff like that.

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

#17028

Alex Wegel <awegel@arcor.de> wrote:

> Mark Wills <forthfreak@gmail.com> wrote:
> 
> >  It was a requirement that the
> > address and length be retained for further tests (the string might be
> > something else that I am looking for).
> 
> Maybe you really want a proper parsing function?
> 
> I.e. more along the lines of sth like:
> 
> ( c-addr1 u1 -- c-addr1 u1 false | c-addr2 u2 true )
> 
> Where c-addr2 u2 is the original string with the leading part (the "}}")
> cut off.
> 
> There are some packages out there for doing stuff like that.

On a second thought: If you just want to collect some words up to the
terminating "}}", you might just define a word called }} and let the
interpreter look for it, like in:

: }} ;

: {{ ( -- )
  begin bl word find while ( xt )
    dup ['] }} = if drop exit then
    ( xt ) do-sth ( )
  repeat
 ( c-addr ) drop
;

My point is: As usual, it all depends on what you *really* want this
for, and thus can't be answered (in the sense of "what's better")
without knowing more about the context.

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

#17031

On Nov 4, 10:36 am, awe...@arcor.de (Alex Wegel) wrote:
> Alex Wegel <awe...@arcor.de> wrote:
> > Mark Wills <forthfr...@gmail.com> wrote:
>
> > >  It was a requirement that the
> > > address and length be retained for further tests (the string might be
> > > something else that I am looking for).
>
> > Maybe you really want a proper parsing function?
>
> > I.e. more along the lines of sth like:
>
> > ( c-addr1 u1 -- c-addr1 u1 false | c-addr2 u2 true )
>
> > Where c-addr2 u2 is the original string with the leading part (the "}}")
> > cut off.
>
> > There are some packages out there for doing stuff like that.
>
> On a second thought: If you just want to collect some words up to the
> terminating "}}", you might just define a word called }} and let the
> interpreter look for it, like in:
>
> : }} ;
>
> : {{ ( -- )
>   begin bl word find while ( xt )
>     dup ['] }} = if drop exit then
>     ( xt ) do-sth ( )
>   repeat
>  ( c-addr ) drop
> ;
>
> My point is: As usual, it all depends on what you *really* want this
> for, and thus can't be answered (in the sense of "what's better")
> without knowing more about the context.

I agree with you Alex.

In fact, my first incarnation of the code did *exactly* that. I may
actually revert to that method, we'll see. The code is exeperimental.

To supply some context, this code is a small part of a local variable
implementation for my 16-bit home-brew Forth 83 system:

: word {{ tom dick harry }}
  ... ... ... ;

Top of stack goes to harry, next to dick, next to tom. The locals are
fleeting, they do not exist within the dictionary. They exist on a
separate stack; thus they can be nested for recursion etc as one would
expect normal local variables to nest in other languages.

The names of the locals are hashed. At this time, I'm using a simple
CRC-16 algorithm to perform the 'hash' though I think it's probably
unsuitable for use I am putting it to. I have already proved (by
running the algorithm through words on a web page) that collisions are
quite common. I may have to move to a 32 bit CRC. Not really a
problem. It just takes a little longer at compile time; there's no run-
time overhead. Locals, when compiled into definitions, actually
produce run time code that produces an offset into the locals stack.

That's currently how my (planned) implementation will work :-) I kind
of got side-tracked into writing a tagged object assembly code loader
(anyone that worked on TI mini's back in the 70's and 80's will know
what they are) for a guy that is developing a floating point package
for my system. I hope to get back at it next week.

I am still enjoying writing Forth code and I think I am improving with
each application I write.

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

#17033

Mark Wills <forthfreak@gmail.com> wrote:

> To supply some context, this code is a small part of a local variable
> implementation for my 16-bit home-brew Forth 83 system:
> 
> : word {{ tom dick harry }}
>   ... ... ... ;

Ah so.
Hmm - changing this to

: word { tom dick harry } ... ;

would solve half of the problem already (and save two chars for each
word using locals :-).

I don't really want to go into the locals stuff itself, mostly because i
don't use them very often (and i feel that there are multiple possible
strategies, the [dis-]advantages of which are another complex topic,
esp. on a 16-bit system).

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

#17034

Op Sun, 4 Nov 2012 03:48:52 -0800 (PST) schreef Mark Wills:

> On Nov 4, 10:36 am, awe...@arcor.de (Alex Wegel) wrote:
>> Alex Wegel <awe...@arcor.de> wrote:
>>> Mark Wills <forthfr...@gmail.com> wrote:
>>
>>> >  It was a requirement that the
>>> > address and length be retained for further tests (the string might be
>>> > something else that I am looking for).
>>
>>> Maybe you really want a proper parsing function?
>>
>>> I.e. more along the lines of sth like:
>>
>>> ( c-addr1 u1 -- c-addr1 u1 false | c-addr2 u2 true )
>>
>>> Where c-addr2 u2 is the original string with the leading part (the "}}")
>>> cut off.
>>
>>> There are some packages out there for doing stuff like that.
>>
>> On a second thought: If you just want to collect some words up to the
>> terminating "}}", you might just define a word called }} and let the
>> interpreter look for it, like in:
>>
>>: }} ;
>>
>>: {{ ( -- )
>>   begin bl word find while ( xt )
>>     dup ['] }} = if drop exit then
>>     ( xt ) do-sth ( )
>>   repeat
>>  ( c-addr ) drop
>> ;
>>
>> My point is: As usual, it all depends on what you *really* want this
>> for, and thus can't be answered (in the sense of "what's better")
>> without knowing more about the context.
> 
> I agree with you Alex.
> 
> In fact, my first incarnation of the code did *exactly* that. I may
> actually revert to that method, we'll see. The code is exeperimental.
> 
> To supply some context, this code is a small part of a local variable
> implementation for my 16-bit home-brew Forth 83 system:
> 
>: word {{ tom dick harry }}
>   ... ... ... ;
> 
> Top of stack goes to harry, next to dick, next to tom. The locals are
> fleeting, they do not exist within the dictionary. They exist on a
> separate stack; thus they can be nested for recursion etc as one would
> expect normal local variables to nest in other languages.
> 
> The names of the locals are hashed. At this time, I'm using a simple
> CRC-16 algorithm to perform the 'hash' though I think it's probably
> unsuitable for use I am putting it to. I have already proved (by
> running the algorithm through words on a web page) that collisions are
> quite common. I may have to move to a 32 bit CRC. Not really a
> problem. It just takes a little longer at compile time; there's no run-
> time overhead. Locals, when compiled into definitions, actually
> produce run time code that produces an offset into the locals stack.
> 
> That's currently how my (planned) implementation will work :-) I kind
> of got side-tracked into writing a tagged object assembly code loader
> (anyone that worked on TI mini's back in the 70's and 80's will know
> what they are) for a guy that is developing a floating point package
> for my system. I hope to get back at it next week.
> 
> I am still enjoying writing Forth code and I think I am improving with
> each application I write.

Why do you need hashing? Are you planning to use more than a couple of
locals per definition? I use normal strings. When the word is finished,
there are no local names to be foundy. When interpreting, looking for
locals is senseless anyway. When compiling, find them in a simple locals
dictionary, with string matching. Fast enough for any processor.

-- 
Coos

CHForth, 16 bit DOS applications
http://home.hccnet.nl/j.j.haak/forth.html 

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

#17035

On Nov 4, 12:32 pm, Coos Haak <chfo...@hccnet.nl> wrote:
> Op Sun, 4 Nov 2012 03:48:52 -0800 (PST) schreef Mark Wills:
>
>
>
>
>
>
>
>
>
> > On Nov 4, 10:36 am, awe...@arcor.de (Alex Wegel) wrote:
> >> Alex Wegel <awe...@arcor.de> wrote:
> >>> Mark Wills <forthfr...@gmail.com> wrote:
>
> >>> >  It was a requirement that the
> >>> > address and length be retained for further tests (the string might be
> >>> > something else that I am looking for).
>
> >>> Maybe you really want a proper parsing function?
>
> >>> I.e. more along the lines of sth like:
>
> >>> ( c-addr1 u1 -- c-addr1 u1 false | c-addr2 u2 true )
>
> >>> Where c-addr2 u2 is the original string with the leading part (the "}}")
> >>> cut off.
>
> >>> There are some packages out there for doing stuff like that.
>
> >> On a second thought: If you just want to collect some words up to the
> >> terminating "}}", you might just define a word called }} and let the
> >> interpreter look for it, like in:
>
> >>: }} ;
>
> >>: {{ ( -- )
> >>   begin bl word find while ( xt )
> >>     dup ['] }} = if drop exit then
> >>     ( xt ) do-sth ( )
> >>   repeat
> >>  ( c-addr ) drop
> >> ;
>
> >> My point is: As usual, it all depends on what you *really* want this
> >> for, and thus can't be answered (in the sense of "what's better")
> >> without knowing more about the context.
>
> > I agree with you Alex.
>
> > In fact, my first incarnation of the code did *exactly* that. I may
> > actually revert to that method, we'll see. The code is exeperimental.
>
> > To supply some context, this code is a small part of a local variable
> > implementation for my 16-bit home-brew Forth 83 system:
>
> >: word {{ tom dick harry }}
> >   ... ... ... ;
>
> > Top of stack goes to harry, next to dick, next to tom. The locals are
> > fleeting, they do not exist within the dictionary. They exist on a
> > separate stack; thus they can be nested for recursion etc as one would
> > expect normal local variables to nest in other languages.
>
> > The names of the locals are hashed. At this time, I'm using a simple
> > CRC-16 algorithm to perform the 'hash' though I think it's probably
> > unsuitable for use I am putting it to. I have already proved (by
> > running the algorithm through words on a web page) that collisions are
> > quite common. I may have to move to a 32 bit CRC. Not really a
> > problem. It just takes a little longer at compile time; there's no run-
> > time overhead. Locals, when compiled into definitions, actually
> > produce run time code that produces an offset into the locals stack.
>
> > That's currently how my (planned) implementation will work :-) I kind
> > of got side-tracked into writing a tagged object assembly code loader
> > (anyone that worked on TI mini's back in the 70's and 80's will know
> > what they are) for a guy that is developing a floating point package
> > for my system. I hope to get back at it next week.
>
> > I am still enjoying writing Forth code and I think I am improving with
> > each application I write.
>
> Why do you need hashing? Are you planning to use more than a couple of
> locals per definition? I use normal strings. When the word is finished,
> there are no local names to be foundy. When interpreting, looking for
> locals is senseless anyway. When compiling, find them in a simple locals
> dictionary, with string matching. Fast enough for any processor.
>
> --
> Coos
>
> CHForth, 16 bit DOS applicationshttp://home.hccnet.nl/j.j.haak/forth.html

Hi Coos

Simply because it makes looking them up during compilation very simple
indeed - the names of the locals have been changed to 16-bit cells.
You're looking for numbers, rather than strings.

The original intention was to make look-ups faster. There's a little
bit of expense to crunch the string to a number (I hesitate to use the
word hash here, because I'm not sure it's a hash; it's actually a
widely known CRC algorithm that I'm using) but subsequent searches
through the (temporary) locals dictionary are very fast.

Perhaps I'll try both methods, there may actually be very little
difference in search times, given the number of times the names of the
locals may actually appear.

Thanks for the comment.

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

#17025

rickman <gnuarm@gmail.com> wrote:
> On 11/2/2012 1:18 PM, Andrew Haley wrote:
>> rickman<gnuarm@gmail.com>  wrote:
>>> On 11/1/2012 10:19 PM, Hugh Aguilar wrote:
>>>> On Oct 31, 6:42 pm, rickman<gnu...@gmail.com>   wrote:
>>>>> How about this?
>>>>>
>>>>> : }}? ( addr len -- addr len flag )
>>>>>      2dup s" }}" compare 0= ;
>>>>
>>>> Good Forth style is for functions to consume their arguments:
>>>>
>>>> : }}? ( adr cnt -- equal? )
>>>>       s" }}" compare 0= ;
>>>
>>> This is not what the OP asked for.  I try to give people what they
>>> want rather than asking them to change what they want to what I
>>> prefer to offer them... unless that is the only choice of course.
>>
>> This is a discussion group, not a helpline; people might get advice
>> they don't want to hear.  As long as it's good advice, that's just
>> fine.  And that 2DUP is poor style!
> 
> That's your opinion.

Of course it's my opinion.  I wouldn't have posted it if it weren't.

> There may be a perfectly good reason to include the 2DUP.

There may be, but that's unlikely.

Andrew.

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

#16861

On 10/31/12 8:22 AM, Paul Rubin wrote:
> Mark Wills <forthfreak@gmail.com> writes:
>> The following routine is checking to see if a string is "}}" i.e.
>> consists of two consequtive right curly braces.
>>
>> : }}? ( addr len -- addr len flag)
>
>      : }? ( caddr -- flag ) c@ 125 = ;
>      : }}? ( caddr len -- flag )
>          2 = if dup }? swap }? and else 0 then ;

Both uses of }? are checking the same address.  You need to bump the 
address up by one for one of the checks:

: }}? ( caddr len -- flag )
    2 = if dup }? swap 1+ }? and else 0 then ;

There is value in unit testing (type checking would not have helped here).

-Doug

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

#16858

On Wednesday, October 31, 2012 1:58:24 PM UTC+2, M.R.W Wills wrote:
> The following routine is checking to see if a string is "}}" i.e.
> 
> consists of two consequtive right curly braces.
> 
> 
> 
> : }}? ( addr len -- addr len flag)
> 
>   dup 2= if
> 
>     over dup c@   swap 1+ c@   125 =   swap 125 =   and
> 
>   else
> 
>     false
> 
>   then ;
> 
> 
> 
> As can be seen, the first check is the length; if the length is not
> 
> exactly 2 then we just return false. If the length is 2 then we check
> 
> to see if both characters are ASCII 125. That's the bit I am looking
> 
> at and saying "Meh... seems a bit convoluted/lengthy.
> 
> 
> 
> Is there a better way?
> 
> 
> 
> I was thinking maybe:
> 
> 
> 
> ... c@ 125 OR swap   1+ c@ 125 OR  125 XOR 0=
> 
> 
> 
> Which is perhaps "cleverer" but not as clear as to the intention of
> 
> the code and no shorter...

Hi!

: '}?   ( ca -- f )     c@ 125 = ;
: }}?   ( ca u -- f )
        2 <> IF 0= ELSE dup 1+ '}? swap '}? and THEN ;

Have a nice day,
humptydumpty

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

#16859

On 10/31/12 7:58 AM, Mark Wills wrote:
> The following routine is checking to see if a string is "}}" i.e.
> consists of two consequtive right curly braces.
>
> : }}? ( addr len -- addr len flag)
>    dup 2= if
>      over dup c@   swap 1+ c@   125 =   swap 125 =   and
>    else
>      false
>    then ;
>
> As can be seen, the first check is the length; if the length is not
> exactly 2 then we just return false. If the length is 2 then we check
> to see if both characters are ASCII 125. That's the bit I am looking
> at and saying "Meh... seems a bit convoluted/lengthy.
>
> Is there a better way?
>
> I was thinking maybe:
>
> ... c@ 125 OR swap   1+ c@ 125 OR  125 XOR 0=
>
> Which is perhaps "cleverer" but not as clear as to the intention of
> the code and no shorter...
>

: }}? ( addr len -- addr len flag)
   2dup s" }}" compare 0= ;

-Doug

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

#16860

On Oct 31, 1:23 pm, Doug Hoffman <glide...@gmail.com> wrote:
> On 10/31/12 7:58 AM, Mark Wills wrote:
>
>
>
>
>
> > The following routine is checking to see if a string is "}}" i.e.
> > consists of two consequtive right curly braces.
>
> > : }}? ( addr len -- addr len flag)
> >    dup 2= if
> >      over dup c@   swap 1+ c@   125 =   swap 125 =   and
> >    else
> >      false
> >    then ;
>
> > As can be seen, the first check is the length; if the length is not
> > exactly 2 then we just return false. If the length is 2 then we check
> > to see if both characters are ASCII 125. That's the bit I am looking
> > at and saying "Meh... seems a bit convoluted/lengthy.
>
> > Is there a better way?
>
> > I was thinking maybe:
>
> > ... c@ 125 OR swap   1+ c@ 125 OR  125 XOR 0=
>
> > Which is perhaps "cleverer" but not as clear as to the intention of
> > the code and no shorter...
>
> : }}? ( addr len -- addr len flag)
>    2dup s" }}" compare 0= ;
>
> -Doug- Hide quoted text -
>
> - Show quoted text -

That's cheating ;-) COMPARE is in the ANS optional string word-set.
I'm still stuck in the 80's I'm afraid, using Forth 83 on a 30 year
old computer! Everyone should have a hobby!

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

#16882

Mark Wills <forthfreak@gmail.com> wrote:
> On Oct 31, 1:23?pm, Doug Hoffman <glide...@gmail.com> wrote:
>> On 10/31/12 7:58 AM, Mark Wills wrote:
>>
>> > The following routine is checking to see if a string is "}}" i.e.
>> > consists of two consequtive right curly braces.
>>
>> > : }}? ( addr len -- addr len flag)
>> >   ?dup 2= if
>> >      over dup c@   swap 1+ c@   125 =   swap 125 =   and
>> >    else
>> >      false
>> >    then ;
>>
>> > As can be seen, the first check is the length; if the length is not
>> > exactly 2 then we just return false. If the length is 2 then we check
>> > to see if both characters are ASCII 125. That's the bit I am looking
>> > at and saying "Meh... seems a bit convoluted/lengthy.
>>
>> > Is there a better way?
>>
>> > I was thinking maybe:
>>
>> > ... c@ 125 OR swap   1+ c@ 125 OR  125 XOR 0=
>>
>> > Which is perhaps "cleverer" but not as clear as to the intention of
>> > the code and no shorter...
>>
>> : }}? ( addr len -- addr len flag)
>>    2dup s" }}" compare 0= ;
>
> 
> That's cheating ;-) COMPARE is in the ANS optional string word-set.
> I'm still stuck in the 80's I'm afraid, using Forth 83 on a 30 year
> old computer! Everyone should have a hobby!

Well, yes, but the *correct* answer to your problem is therefore
"Write COMPARE, then use it".  COMPARE is not hard to write.

Andrew.

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

#16901

On Oct 31, 4:47 pm, Andrew Haley <andre...@littlepinkcloud.invalid>
wrote:
> Mark Wills <forthfr...@gmail.com> wrote:
> > On Oct 31, 1:23?pm, Doug Hoffman <glide...@gmail.com> wrote:
> >> On 10/31/12 7:58 AM, Mark Wills wrote:
>
> >> > The following routine is checking to see if a string is "}}" i.e.
> >> > consists of two consequtive right curly braces.
>
> >> > : }}? ( addr len -- addr len flag)
> >> >   ?dup 2= if
> >> >      over dup c@   swap 1+ c@   125 =   swap 125 =   and
> >> >    else
> >> >      false
> >> >    then ;
>
> >> > As can be seen, the first check is the length; if the length is not
> >> > exactly 2 then we just return false. If the length is 2 then we check
> >> > to see if both characters are ASCII 125. That's the bit I am looking
> >> > at and saying "Meh... seems a bit convoluted/lengthy.
>
> >> > Is there a better way?
>
> >> > I was thinking maybe:
>
> >> > ... c@ 125 OR swap   1+ c@ 125 OR  125 XOR 0=
>
> >> > Which is perhaps "cleverer" but not as clear as to the intention of
> >> > the code and no shorter...
>
> >> : }}? ( addr len -- addr len flag)
> >>    2dup s" }}" compare 0= ;
>
> > That's cheating ;-) COMPARE is in the ANS optional string word-set.
> > I'm still stuck in the 80's I'm afraid, using Forth 83 on a 30 year
> > old computer! Everyone should have a hobby!
>
> Well, yes, but the *correct* answer to your problem is therefore
> "Write COMPARE, then use it".  COMPARE is not hard to write.
>
> Andrew.

17.6.1.0935 COMPARE
STRING

	( c-addr1 u1 c-addr2 u2 -- n )

Compare the string specified by c-addr1 u1 to the string specified by
c-addr2 u2. The strings are compared, beginning at the given
addresses, character by character, up to the length of the shorter
string or until a difference is found. If the two strings are
identical, n is zero. If the two strings are identical up to the
length of the shorter string, n is minus-one (-1) if u1 is less than
u2 and one (1) otherwise. If the two strings are not identical up to
the length of the shorter string, n is minus-one (-1) if the first non-
matching character in the string specified by c-addr1 u1 has a lesser
numeric value than the corresponding character in the string specified
by c-addr2 u2 and one (1) otherwise.

WTF??????????????????????????????

Why can't COMPARE just push a flag for God's sake! Oh my goodness me!
I think I need to go for a lie down!

Just bonkers!!

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

#16902

Mark Wills <forthfreak@gmail.com> writes:
> Why can't COMPARE just push a flag for God's sake!

It's an ordered comparison function, e.g. you might want to sort a list
of strings lexicographically.

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

Page 5 of 9 — ← Prev page 1 2 3 4 [5] 6 7 8 9  Next page →

Back to top | Article view | comp.lang.forth

csiph-web