HDTenEightyP/NetNews huggingface dataset:
From: sip1@ellis.uchicago.edu (Timothy F. Sipples)
Subject: 16-bit CRC Routine?
Reply-To: sip1@midway.uchicago.edu
Organization: Dept. of Econ., Univ. of Chicago
Date: Tue, 8 Sep 1992 16:19:03 GMT

Does anyone have a TINY 16-bit CRC generation routine in REXX?  By
tiny I mean the smallest fragment of REXX code possible.

It may be incorporated in a future version of REXXShip.

-- 
Timothy F. Sipples      | The OS/2 FREQ. ASKED QUESTIONS LIST is avail. from
sip1@ellis.uchicago.edu | 128.123.35.151, anonymous ftp, in /pub/os2/all/faq.
Dept. of Econ., Univ.   | Or from LISTSERV@BLEKUL11.BITNET (send "HELP").
of Chicago, 60637       | Family Values Means a Job
From: martinc@grover.cs.unc.edu (Charles R. Martin)
Newsgroups: comp.lang.rexx
Subject: Re: new rexx programmer
Date: 14 Sep 92 01:06:19 GMT
Distribution: comp
Organization: UNC Department of Computer Science
In-reply-to: jeff.zeitlin@execnet.com's message of 13 Sep 92 00:48:57 GMT

In article <1992Sep12.819.850@execnet> jeff.zeitlin@execnet.com (jeff zeitlin) writes:

	Subject: (was: newbie rexx programmer asks silly questions)

   CRM::>Just discovered rexx in the process of writing some OS 2 tools.

   CRM::>Question 1: Can someone recommend a particular rexx implementation for
      ::>DOS? Are there any pros and cons to be considered, or is one as good as
      ::>another?

      As far as I know, the only DOS implementation of the REXX language
      is Personal Rexx from Quercus Systems, POBox 2157, Saratoga CA
      95070.  Phone +1 408/867-7399, FAX +1 408/867-7489, BBS +1
      408/867-7488 2400-8N1. Part of the documentation you receive is a
      copy of Cowlishaw, 2ed.

      Personal Rexx is available for both DOS and OS/2.

There are also at least two others: The various Rexxes from Kilowatt
Software, including one that is apparently for Windows and included a
bunch of Windows human-interface stuff (I've not been able to
investigate further, but I just got my new catalogue from the
Programmer's Shop.)

   CRM::>Question 2: Given a string like this

   CRM::>A*B*C*D*E*F/

      WHere/how did this fail?  I just tried it on my system, using your
      delimiters and the correction I noted above, and got what I
      expected.  Note that I am using the Quercus Systems (Personal) Rexx
      that I mentioned above.

Thanks, we've determined that it was a buggy UNIX implementation here.
I've since tried it on my OS/2 box at my consulting job and discuovered
that modulo dyslexing the slash my version worked fine.  I also had
pointed out the fascinating code-squeeze of:

	do ix=1 to umpteen while line <> ''
	   parse ...
	end
 
--
Charles R. Martin/(Charlie)/martinc@cs.unc.edu/(ne crm@cs.duke.edu) 
O/Dept. of Computer Science/CB #3175 UNC-CH/Chapel Hill, NC 27599-3175
H/3611 University Dr #13M/Durham, NC 27707/(919) 419 1754
----------------------------------------------------------------------
"I am he who walks the States with a barb'd tongue, questioning every
one I meet,/Who are you that wanted only to be told what you knew
before?/ Who are you that wanted only a book to join you in your
nonsense?"  _Leaves of Grass_ xxiii.4.
From: martinc@grover.cs.unc.edu (Charles R. Martin)
Newsgroups: comp.lang.rexx
Subject: Re: Regular expression syntax
Date: 9 Sep 92 00:00:40 GMT
Organization: UNC Department of Computer Science
In-reply-to: imc@comlab.ox.ac.uk's message of 8 Sep 92 16:12:49 GMT

After a fair bit of thought about it, I'm becoming more and more
convinced -- brace yourselves -- that the better solution is to make a
regular expression syntax the PRIMITIVE notion in rexx, and make all the
current semantics abbreviations for some r.e.

After all, we're guaranteed that anything we want to do with rexx is
going to be finite-state; we can't lose any semantic power by doing so.
But we make available lots of potential power that doesn't appear to be
there now.  A regular expression compiler and interpreter is a
straightforward exercise, and would probably be simpler than handling a
lot of special cases.  And by having the power of a full FSA available,
we can avoid worrying about what whitespace etc is, because anyone can
get exactly the desired semantics by explicitly coding the approriate
r.e., while not changing the overlaid "old rexx" language in any way.
--
Charles R. Martin/(Charlie)/martinc@cs.unc.edu/(ne crm@cs.duke.edu) 
O/Dept. of Computer Science/CB #3175 UNC-CH/Chapel Hill, NC 27599-3175
H/3611 University Dr #13M/Durham, NC 27707/(919) 419 1754
----------------------------------------------------------------------
"I am he who walks the States with a barb'd tongue, questioning every
one I meet,/Who are you that wanted only to be told what you knew
before?/ Who are you that wanted only a book to join you in your
nonsense?"  _Leaves of Grass_ xxiii.4.
Comments: Gated by NETNEWS@AUVM.AMERICAN.EDU
X-Acknowledge-To: <RZOTTO@DKNKURZ1>
Newsgroups: comp.lang.rexx
Date:         Wed, 9 Sep 1992 16:20:32 MEZ
From:         Otto Stolz <RZOTTO@DKNKURZ1.BITNET>
Subject:      Re: Blanks, REXX, and portability...

On Tue, 8 Sep 92 21:45:13 PDT Dave Gomberg said:
> Dan, even without normalization (such as is called for by FORTRAN and
> the floating point ANSI standards) you will still have problems with:
>    X=expr
>    PUSH X
>    whatever code on X
>    PULL X
>    whatever code on X
> and the two versions of the whatever code don't do the same thing.

Please explain! I cannot see how any of the proposals we have discussed
could produce such erratic behaviour.

Happy programming,
                    Otto Stolz <RZOTTO@DKNKURZ1.Bitnet>
                               <RZOTTO@nyx.uni-konstanz.de>
From: jasienrt@outb.wimsey.bc.ca (Jason Sienart)
Newsgroups: comp.lang.rexx
Subject: Requesters.. How do i get rid of 'em..
Date: 6 Sep 92 17:56:51 PDT
Organization: Wizard Online

In ARexx.. How can i check if an assign/disk/partion exists. Well what i mean
is how can i find out if it exists without a requester poping up. I phone my
computer from remotely and hate crashing my BBS with a requester waiting for me to insert hhh: in any drive..

--- Via UCI v1.02 (C-Net Amiga)

#----------------------------------------------------------------------------#
|                                                                            |
|       J A S O N   S I E N A E R T     -    jasienrt@outb.wimsey.bc.ca.     |
|                                                                            |
#----------------------------------------------------------------------------#
From: "jeff zeitlin" <jeff.zeitlin@execnet.com>
Newsgroups: comp.lang.rexx
Subject: new rexx programmer
Date: 12 Sep 92 19:48:57 EST
Reply-To: "jeff zeitlin" <jeff.zeitlin@execnet.com>
Distribution: comp
Organization: Executive Networks Information

     Subject: (was: newbie rexx programmer asks silly questions)

CRM::>Just discovered rexx in the process of writing some OS 2 tools.

CRM::>Question 1: Can someone recommend a particular rexx implementation for
   ::>DOS? Are there any pros and cons to be considered, or is one as good as
   ::>another?

   As far as I know, the only DOS implementation of the REXX language
   is Personal Rexx from Quercus Systems, POBox 2157, Saratoga CA
   95070.  Phone +1 408/867-7399, FAX +1 408/867-7489, BBS +1
   408/867-7488 2400-8N1. Part of the documentation you receive is a
   copy of Cowlishaw, 2ed.

   Personal Rexx is available for both DOS and OS/2.

CRM::>Question 2: Given a string like this

CRM::>A*B*C*D*E*F/

CRM::>where the fields represented by cap letters can be arbitrary length,
   ::>where * is a field separator, and / is a message terminator, I would
   ::>like to parse it including the possibility that there will be null
   ::>fields.  That is, of one message were A*B**D*E*F/, I'd like to parse it
   ::>into say an "array"

CRM::>a.1 = 'A'; a.2 = 'B'; a.3 = ''; a.4 = 'd' and so on.

CRM::>My first cut at that was
   ::>        line = "A*B**D*E*F\" <----------------------+
   ::>        ix = 1                                      |
   ::>        do while line <> ''                         |
   ::>           parse value line with fld'*'line'/' <----+
   ::>           a.ix = fld                               |
   ::>           ix = ix + 1                              |
   ::>        end                                         |
                                                          |
   I am assuming that both of these slashes should be the same, "/".

CRM::>which didn't quite work.  Any suggestions?  (By the way, there's an
   ::>obvious recursive reformulation of this: are there advantages of the
   ::>iterative vs recursive expression?)

   WHere/how did this fail?  I just tried it on my system, using your
   delimiters and the correction I noted above, and got what I
   expected.  Note that I am using the Quercus Systems (Personal) Rexx
   that I mentioned above.

  J/
  jeff.zeitlin@execnet.com
  ==================================================================
  Anything I say in this or any communication to this or any medium
  is strictly my own non-authoritative opinion, unless otherwise
  explicitly noted.  Except for myself, or where explicitly noted
  otherwise, I do not speak for any individual or organization.
  ==================================================================

 * OLX 2.2 * Proofread carefully to see if you any words out.
--
Executive Network Information System  (914) 667-4567
International ILink Host
From: eric@sejnet.sunet.se (Eric Thomas)
Subject: Re:      Re: Blanks, REXX, and portability...
Reply-To: ERIC@SEARN.SUNET.SE
Organization: SUNET, Stockholm, Sweden
Date: Sun, 13 Sep 1992 01:28:01 GMT

In article <1992Sep11.190834.16887@hou.amoco.com>, zjlc12@hou.amoco.com (Jerry Campbell) writes:
>     3 - each word oriented, builtin function will have an extra parameter that
>         can be used to override the implementation default.  

Many of these functions already have a bunch of optional parameters. We're
talking about ending up with things like FUNCTION(A,B,,,'20090D0A'x) with each
function having a different amount of commas, not to mention the hassle of
typing the list of delimiters every time.

>     4 - logical comparisons will use the implementation default delimiters to
>         fudge the ends of strings.  Unless the strict comparator operators are 
>         used.  

Which gives you an incomplete/inconsistent tools - for some things you can
define your delimiters, for others you can. Not very convenient I'm afraid.

  Eric
Newsgroups: comp.lang.rexx
From: SEB1525@MVS.draper.com (Steve Bacher)
Subject: Using whitespace characters as delimiters (was: Blanks, REXX, and portability...)
Organization: Draper Laboratory
Date: Tue, 8 Sep 1992 22:21:00 GMT

In article <1992Sep8.154048.1@sejnet.sunet.se>,
eric@sejnet.sunet.se (Eric Thomas) writes:

>In article <19920907131702SEB1525@MVS.draper.com>, SEB1525@MVS.draper.com (Steve Bacher) writes:
>> At least with the more reasonable proposals,
>>
>>  PARSE VALUE DIAG(something) WITH var1 var2 '15'x var3 var4 '15'x var5
>>
>> should continue to work just fine, regardless of whether '15'x is
>> considered whitespace or not.  A correct implementation of REXX will
>> break up the line at the '15'xes and only then perform the whitespace
>> analysis on the resulting pieces.
>
>Yes, that much will work, and it is indeed what people generally code to
>process the output of commands which produce a fixed-size answer (like when
>extracting the time zone name from QUERY TIME). But there are many commands
>which produce variable-size output that one processes in a loop (example: QUERY
>NAMES). 

Still not that much of a problem, if you do:

temp = diag(something)
 or
parse value diag(something) with temp

do while words(temp) = 0   /* or temp ^= "", or whatever */
 parse var temp stuff '15'x temp
 call do_something_with stuff
end

The same rules should apply.

I do see your point about all components of the language that deal with
whitespace needing to behave consistently.  I take that as a given.

--
Steve Bacher (Batchman)                 Draper Laboratory
Internet: seb@draper.com                Cambridge, MA, USA
Newsgroups: comp.lang.rexx
From: ets@wrkgrp.COM (Edward T Spire)
Subject: Re: NOVALUE (was: Blanks, REXX, and portability...)
Organization: The Workstation Group
Date: Tue, 15 Sep 92 21:24:07 GMT

imc@comlab.ox.ac.uk (Ian Collier) writes:
: And in article <1686052F.GILMART@LSTC2VM.stortek.com>, he quoth:
: 
: >But it would be a real pain if this were reported as an error unless there
: >were some way to use explicit constants -- better by far, general expressions
: >-- as compound variable indices.  Namely:
:  
: >   say a.'X'   /* so I don't have to assign 'X' to dummy */
: >               /* and even:  */
: >   say a.(substr('UVWXYZ',4,1))   /* Why not, haven't you wanted it? */
:  
: >Is anyone proposing this extremely desirable extension?
:  
: You can already do this on REXX/imc.  Of course, I'm not asking anyone
: actually to use that feature! :-)

So in REXX/imc, what does this say:

a.=1
a.x=2
say a.'X'

I got the impression from the above that it would say 2.
Shouldn't it say 1X (i.e., abbutal concatenation)?

I don't think you can extend the language in this specific manner
without breakage.  And yet this requirement has been discussed,
I'm just not up on the details of any proposed syntax.  Maybe they
exhibit the same problem...

-Ed
Newsgroups: comp.lang.rexx
From: anders@lise3.lise.unit.no (Anders Christensen)
Subject: Re: Blanks, REXX, and portability...
Organization: University of Trondheim, Norway
Date: 8 Sep 92 14:38:20

In article <REXXLIST%92090701365930@UGA.CC.UGA.EDU> Dave Gomberg <GOMBERG@UCSFVM.BITNET> writes:
                                                             
> I would really like Anders 
> and other Unix types to say if they can stand it that:
>
>     c=a||b;  say pos(a,c)
>
> would say 0?

Why are you focusing on POS()? The description of POS() in TRL (2nd
ed) doesn't even mention 'blank' or 'blanks'. Thus, POS() has nothing
to do with whitespace, and is only suited to obscure this discussion.

The WORDPOS() built-in function is much more interesting, relevant and
illustrative. I think it should return (using "\t" to denote Tabs, but
note that this applies to other whitespace characters as well):

   wordpos( "a b",  "a b"  )   -->   1
   wordpos( "a  b", "a b"  )   -->   1
   wordpos( "a\tb", "a b"  )   -->   1
   wordpos( "a b",  "a  b" )   -->   1
   wordpos( "a b",  "a\tb" )   -->   1

Calling POS() instead, only the first of these returns 1, the rest
return 0. (Unless you introduce regular expressions which, although a
very interesting extension, is a totally different tread.)

-anders

PS: Under normal circumstances, your example says "0" iff 'a' is a
    variable set to the nullstring.
From: mwm@contessa.palo-alto.ca.us (Mike Meyer)
Subject: Re: Blanks, REXX, and portability...
Newsgroups: comp.lang.rexx
Distribution: world
X-NewsSoftware: Amiga Yarn 3.4, 1992/08/12 15:49:52
Keywords: 
Summary: 
Date: 29 Aug 92 22:49:29 PST
Organization: Missionaria Phonibalonica

In <1992Aug26.155501.2612@hou.amoco.com>, zjlc12@hou.amoco.com (Jerry Campbell) wrote:
> Just an observation from someone whose done a LOT of Rexx programming 
> under CMS and not a whole lot under Unix.  The commonly accepted "style"
> (at least in my shop) for constructing data streams to feed to Rexx or
> for interpreting system information (msgs, cmd output, what not) many
> times leads to code such as this:
> 
>    Parse Var sometin 1 parm1 +4 5 parm2 +4 ....
> 
> All very byte position oriented.  The programmer expects to intepret things
> in terms of "card columns".  Many programs are written with that kind of 
> dependency on CMS.  Unix seems to require a different conceptualization
> of data streams.   

Quite right - unix programs use whitespace to seperate output items,
and expect whitespace to seperate input items. Trying to use stock
Unix tools on position-oriented data with no seperation is
frustrating, at best.

	<mike
Newsgroups: comp.lang.rexx
From: eric@sejnet.sunet.se (Eric Thomas)
Subject: Re: Blanks, REXX, and portability...
Reply-To: ERIC@SEARN.SUNET.SE
Organization: SUNET, Stockholm, Sweden
Date: Sat, 5 Sep 1992 13:24:40 GMT

In article <mwm.1p79@contessa.palo-alto.ca.us>, mwm@contessa.palo-alto.ca.us (Mike Meyer) writes:
> A question for all of you using EBCDIC who don't think that arbitrary
> whitespace should be allowed to seperate words: Why do you care?

I have to use unix systems from time to time to get my job done. If some day
they have a REXX interpreter, I would like to use it to make my job easier and
for that it has to behave predictably. If I code POS('A B',string), I want it
to locate A-blank-B, not A-tab-B. I have said that 200 times already, maybe you
should read more carefully before you flame?

> A similar problem shows up in the ANSI C standard. It has this idiotic
> restriction that external identifiers must be unique in the first six
> characters, case insensitive. I don't know of _anybody_ who liked
> this, but there was a very popular system which had a standard linker
> with that antiquated restriction. Removing this brain-dead restriction
> meant that you couldn't write an ANSI C compiler for that system,
> which was considered a bad thing - so the restriction stayed in.

In case I interpreted the snide remark correctly, the standard IBM linker uses
EIGHT characters names, not 6. Furthermore the C compiler performs a mapping
between C names and internally generated linker names to allow C programmers to
have function names of the length they want. So I have to conclude that the
system in question is not an IBM system, and therefore not an EBCDIC system.

> While requiring that only space can be treated as a blank character
> won't prevent people from implemeting "standard Rexx" on any
> particular machine, it will make Rexx hard to use, and cause people to
> look to other tools.

It will make REXX hard to use for people who, for religious reasons, refuse to
type PARSE EXPAND instead of PARSE wherever necessary. That is their problem,
as far as I am concerned; I have no such religious diktat.

  Eric
Organization: Penn State University
Date: Tue, 15 Sep 1992 15:43:28 EDT
From: Linda Littleton <LRL@psuvm.psu.edu>
Newsgroups: comp.lang.rexx
Subject: Re: Blanks, REXX, and portability...

Whew!  I finally finished wading through this long discussion, and
since I attended the ANSI meeting last week, I thought I'd chime in
with what got discussed there.

The topic came up the afternoon of the first day and consumed the
better part of that afternoon.  One group member read a few quotes
of postings from comp.lang.rexx.  The discussion here definitely
had its influence.

There was unanimous agreement that tabs (and other white space
characters) need to be acceptable in Rexx source and that tabs
in literal strings should be considered as tabs only.

For tabs in data, the programmer would have the ability to specify
whether or not tabs should be translated to spaces.  So, even within
the same program, the programmer could sometimes have tabs translated
and sometimes not.

The programmer would specify either "do translations" or "do not do
translations" (syntax for specifying still needs to be discussed).
The leaning for a default was toward doing the translations; however,
I'm having second thoughts on this, thinking that it would be better
for the default to be the current method -- no translations.

The interpretation of "do translations" (i.e. which characters get
translated to space) might vary from implementation to implementation
according to what is commonly accepted on that system.  In the first
standard, if the programmer specifies that translation is to be done,
then it gets done however that implementation does it.  In a later
standard (when non-essential enhancements will be added), the user would
be able to specify exactly which characters get translated.

We discussed the possibility of having each installation specify which
characters get translated, but decided that it's not good to have the
same implementation work different ways at different installations.

As I mentioned, the syntax is not determined, but it would be a one-time-
per-program thing, rather than an extra parameter on each applicable
function call, as someone suggested.

Keep your comments coming.  Even though the volume can be overwhelming,
the folks at ANSI want to hear what you're saying and the message is
getting through.

-Linda
Comments: Gated by NETNEWS@AUVM.AMERICAN.EDU
Newsgroups: comp.lang.rexx
Date:         Tue, 8 Sep 1992 10:21:06 PDT
From:         Dave Gomberg <GOMBERG@UCSFVM.BITNET>
Subject:      Re: Blanks, REXX, and portability...
              8 Sep 1992 12:32:48 -0400 from <dsr@LNS598.TN.CORNELL.EDU>

On Tue, 8 Sep 1992 12:32:48 -0400 cultural elite said:
>Dave Gomberg <GOMBERG@UCSFVM.BITNET> writes:
>>I want that in MY os.  But there is no accounting for taste!   I would
>>really like Anders (I assume the first letter is in fact capitalized)
>>and other Unix types to say if they can stand it that:
>>
>>    c=a||b;  say pos(a,c)
>>
>>would say 0?  It is not what I mean by REXX.  Sorry this rambles so.  Dave
>
>Ok, call me blind, I but I can't see this hole I seem to be in.  You'll
>have to explain how you get c=a||b; pos(a,c)=0 out of any sensible
>proposal.

If the synonymy of tabs to a particular number of blanks were accepted, and
if assignment did normalization (as it often does, both in standards and in
practice) then c might well have a tab when a ended and b began with strings
of blanks.   Dave
Comments: Gated by NETNEWS@AUVM.AMERICAN.EDU
X-Acknowledge-To: <RZOTTO@DKNKURZ1>
Newsgroups: comp.lang.rexx
Date:         Fri, 11 Sep 1992 10:09:46 MEZ
From:         Otto Stolz <RZOTTO@DKNKURZ1.BITNET>
Subject:      Re: Curious Question
              9 Sep 92 16:17:41 PST from <Leon_Davidoff@PANAM.WIMSEY.BC.CA>

Hy REXXers,

on Wed, 9 Sep 92 16:17:41 PST Leon Davidoff said:
> During my testing I noticed something strange.
> /* Test1.rexx */
> Junk = '  x y'
> [...]
> parse var Junk a b
> /* Test2.rexx */
> Junk = '  x y'
> parse var Junk a b c
> [...]
> What I would like to know is why b in Test1 is assigned the value ' y'
> while in Test2 the value is 'y'.

According to TRL, and the documentation included with your favourite
REXX implementation,
: if [in the pattern] a variable [or single period] is directly followed
: by one or more other variables [or single periods], then [...] each
: blank-delimited word in the string is assigned to each variable in turn

Clearly, this rules out the last variable, or period, in a row of
variables or single periods, which is treated differently:
: the last variable [or single period] in the group [...] is assigned the
: remainder of the string.

Hence you may want to code the parse statement in test2.rexx thus:
  parse var Junk a b .
to ensure that both a and b contain single words.

This is also the solution to Jerry's scruples.

Happy programming,
                    Otto Stolz <RZOTTO@DKNKURZ1.Bitnet>
                               <RZOTTO@nyx.uni-konstanz.de>