From icon-group-sender  Thu Jan  6 22:46:36 1994
Received: by cheltenham.cs.arizona.edu; Thu, 6 Jan 1994 21:31:46 MST
Date: 6 Jan 94 22:46:36 GMT
From: walter!news@rutgers.edu  (Darren New)
Organization: Bellcore
Subject: Re: Icon and sockets
Message-Id: <CJ8CLp.EqF@walter.bellcore.com>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

> To write servers, the best alternative may be to write a C program 
> that uses accept(2) and then forks an Icon program once a connection 
> is established. 

Actually, what I wanted was to manage several sockets simultaneously,
handling connects and disconnects dynamically. I chose to go with a C
process that managed the sockets and wrote to a file which I just poled.
Any better ideas? 


From icon-group-sender  Fri Jan  7 13:29:34 1994
Received: by cheltenham.cs.arizona.edu; Sun, 9 Jan 1994 19:06:01 MST
Date: 7 Jan 94 13:29:34 GMT
From: agate!howland.reston.ans.net!pipex!pipex!not-for-mail@ucbvax.Berkeley.EDU  (Ian Phillipps)
Organization: PIPEX Ltd, Cambridge, UK.
Subject: Re: Icon and sockets
Message-Id: <2gjo3u$213@tank.pipex.net>
References: <CJ8CLp.EqF@walter.bellcore.com>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

In article <CJ8CLp.EqF@walter.bellcore.com>,

>Actually, what I wanted was to manage several sockets simultaneously,
>handling connects and disconnects dynamically. I chose to go with a C
>process that managed the sockets and wrote to a file which I just poled.
>Any better ideas? 

Not sure if I'm allowed to say this here :-) but that sounds like more of a
job for Perl, if you want the flexibility of a high-level interpreted
language. Horses for courses, and all that....

[See comp.lang.perl - versions for Unix + other systems from various FTP sites]

Ian


From icon-group-sender  Wed Jan  5 18:38:58 1994
Received: by cheltenham.cs.arizona.edu; Sun, 9 Jan 1994 19:06:26 MST
Date: 5 Jan 94 18:38:58 GMT
From: cis.ohio-state.edu!math.ohio-state.edu!cyber2.cyberstore.ca!nntp.cs.ubc.ca!cs.ubc.ca!ubc-cs!lili@ucbvax.Berkeley.EDU  (Lili Liu)
Organization: University of British Columbia, Vancouver, B.C., Canada
Subject: ICON compiler
Message-Id: <2gf1g2$c6@cs.ubc.ca>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Hi,
I need to get the compiler for ICON language. 
Does anyone know the ftp site number and the directory to get it?
Thanks.


From icon-group-sender  Wed Jan  5 23:44:05 1994
Received: by cheltenham.cs.arizona.edu; Sun, 9 Jan 1994 19:06:40 MST
Date: 5 Jan 94 23:44:05 GMT
From: pipex!bnr.co.uk!corpgate!crchh327.bnr.ca!eaglesto@uunet.uu.net  (Robert Eaglestone)
Organization: Bell Northern Research, Richardson, TX
Subject: ICON FAQ, or just plain info!
Message-Id: <2gfjc5$qv4@crchh972.bnr.ca>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


Greetings!  What is ICON, and what does it resemble, and is there a shareware
compiler, and is it fun, interesting, easy, strongly typed, powerful, useful,
wonderful?

Any other adjectives?

regards,
rob

---

i don't speak for BNR.


From icon-group-sender  Thu Jan  6 10:19:55 1994
Received: by cheltenham.cs.arizona.edu; Mon, 10 Jan 1994 09:48:34 MST
Date: 6 Jan 94 10:19:55 GMT
From: cis.ohio-state.edu!magnus.acs.ohio-state.edu!math.ohio-state.edu!sdd.hp.com!caen!usenet.coe.montana.edu!netnews.nwnet.net!henson!markline@ucbvax.Berkeley.EDU  (Mark Line)
Organization: Western Washington University
Subject: Re: ICON FAQ, or just plain info!
Message-Id: <1994Jan6.101955.23906@henson.cc.wwu.edu>
References: <2gfjc5$qv4@crchh972.bnr.ca>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

eaglesto@bnr.ca (Robert Eaglestone) writes:


>Greetings!  What is ICON, and what does it resemble, and is there a shareware
>compiler,

>and is it fun,           Yes.
>interesting,             Yes.
>easy,                    Yes.
>strongly typed,          You must be joking.
>powerful,                Yes.
>useful,                  Yes.
>wonderful?               Yes.
>Any other adjectives?    Yes.

-- Mark

--------------------------------------------------------------------
Mark P. Line                       Phone: +1-206-733-6040
Open Pathways                        Fax: +1-206-733-6040
P.O. Box F                         Email: markline@henson.cc.wwu.edu
Bellingham, WA 98227-0296
--------------------------------------------------------------------


From icon-group-sender  Thu Jan  6 13:46:30 1994
Received: by cheltenham.cs.arizona.edu; Mon, 10 Jan 1994 09:49:00 MST
Date: 6 Jan 94 13:46:30 GMT
From: walter!news@uunet.uu.net  (Darren New)
Organization: Bellcore
Subject: Re: ICON FAQ, or just plain info!
Message-Id: <CJ7nLJ.DL6@walter.bellcore.com>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Just to clarify... 

> >Greetings!  What is ICON, 
> >and what does it resemble, 
It's a procedural language with backtracking, dynamic data typing, GC
and all that goes with that, co-routines (but not threads,
unfortunately) and many powerful built-in functions. 
> >and is there a shareware 
> >compiler, 
There are many free or shareware compilers and interpreters for it. 
> >and is it fun,           Yes. 
> >interesting,             Yes. 
> >easy,                    Yes. 
> >strongly typed,          You must be joking. 
Yes, it's strongly typed.  Dynamically typed, but strongly typed. 
That is, variables don't have types, but data does. 
> >powerful,                Yes. 
> >useful,                  Yes. 
> >wonderful?               Yes. 
> >Any other adjectives?    Yes. 
You can add portable, on-some-platforms-extensible, logical, (mostly)
consistant, fairly fast, graphics-supporting, easy to debug, supported,
mature, hmmm.... 

You can delete, unfortunately, easy low-level nonportable access to OS
features.  It's non-trivial to use sockets, for example, from inside
Icon, I've found.  But for doing programs you could use stdio to do in
C, it wins hands down. 

The best reference I've found, BTW, is "The Icon Programming Language"
by Ralph and Madge Griswold. I have the second edition, which is (c)
1990, ISBN 0-13-447889-4, Prentice-Hall. 
        -- Darren 
-- 
445 South St/MRE 2E-279/Morristown NJ 07960 USA/(201)829-4833 
Delivery of Electronic Multimedia over Networks (DEMON) 
Also, formal description techniques, programming languages. 
``Your fault: Core dumped.''                EFF#846 
``Sometimes, you just have to bite the silver bullet.'' 
 


From icon-group-sender  Thu Jan  6 20:11:01 1994
Received: by cheltenham.cs.arizona.edu; Mon, 10 Jan 1994 09:49:12 MST
Date: 6 Jan 94 20:11:01 GMT
From: cis.ohio-state.edu!math.ohio-state.edu!howland.reston.ans.net!agate!msuinfo!uchinews!quads!goer@ucbvax.Berkeley.EDU  (Richard L. Goerwitz)
Organization: University of Chicago
Subject: Re: ICON FAQ, or just plain info!
Message-Id: <1994Jan6.201101.25901@midway.uchicago.edu>
References: <2gfjc5$qv4@crchh972.bnr.ca>, <1994Jan6.101955.23906@henson.cc.wwu.edu>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

>>Greetings!  What is ICON, and what does it resemble, and is there a shareware
>>compiler,
>
>>and is it fun,           Yes.
>>interesting,             Yes.
>>easy,                    Yes.
>>strongly typed,          You must be joking.

Icon is very strongly typed.  At any given time the type of a given
variable or value is always known.  Type conversions are done in a
relatively high-level and sophisticated fashion.  Static typing and
strong typing are different things.

Mine is just an opinion of another user, so don't take this as gospel!

-- 

   -Richard L. Goerwitz              goer%midway@uchicago.bitnet
   goer@midway.uchicago.edu          rutgers!oddjob!ellis!goer


From icon-group-sender  Thu Jan  6 01:23:00 1994
Received: by cheltenham.cs.arizona.edu; Mon, 10 Jan 1994 12:05:36 MST
Date: 6 Jan 94 01:23:00 GMT
From: world!sgmlsh@uunet.uu.net  (Sam Hunting)
Organization: The World Public Access UNIX, Brookline, MA
Subject: SNOBOL/Spitbol
Message-Id: <CJ6p6D.7AG@world.std.com>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Is anyone out there using SNOBOL/SPitbol? Archives? FAQs? Bulletin 
boards? Mailing lists? I'd like to hear from you! Thanks, and Happy New Year.
-- 
<!-- 
  "To imagine a language is to imagine a form 
   of life."                   - Wittgenstein,
                 Philosophical Investigations


From icon-group-sender  Thu Jan  6 21:35:51 1994
Received: by cheltenham.cs.arizona.edu; Mon, 10 Jan 1994 12:06:01 MST
Date: 6 Jan 94 21:35:51 GMT
From: walter!flaubert!norman@rutgers.edu  (Norman Ramsey)
Organization: Bellcore, Morristown NJ
Subject: Icon and sockets
Message-Id: <CJ89Br.BpG@walter.bellcore.com>
References: <CJ7nLJ.DL6@walter.bellcore.com>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

In article <CJ7nLJ.DL6@walter.bellcore.com>,
Darren New  <dnew@thumper.bellcore.com> wrote:
>You can delete, unfortunately, easy low-level nonportable access to OS
>features.  It's non-trivial to use sockets, for example, from inside
>Icon, I've found. 

Yes, and it's a disappointment.  I had the idea of trying
	socket := open("telnet myhost 119", "bp")
on a Unix host to see if I could write network clients that way, but I
haven't actually gotten around to it yet.  If anyone gets something
similar to work, I would enjoy hearing about it.

To write servers, the best alternative may be to write a C program
that uses accept(2) and then forks an Icon program once a connection
is established.

Norman


From icon-group-sender  Mon Jan 10 14:29:43 1994
Received: by cheltenham.cs.arizona.edu; Mon, 10 Jan 1994 18:57:04 MST
Date: Mon, 10 Jan 94 14:29:43 pst
From: balexander@ccmail.com
Message-Id: <9400107582.AA758240983@smtpgate.ccmail.com>
To: icon-group@cs.arizona.edu,
        walter!flaubert!norman@rutgers.edu  (Norman Ramsey)
Subject: Re: Icon and sockets
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


You can't use the "b" open option with pipes, unfortunately.  The "p" 
option is implemented using the (non-ANSI) C library popen() facility, 
which only supports one way at a time.  I suspect that a both-way 
implementation could be done to support "b", but it would be 
non-trivial.

I've wished for this before -- wouldn't Icon be wonderful for 
controlling an external process!  I tried to do something using standard 
Icon and PTYs (in UNIX), but was unsuccessful.  If anyone has been able 
to do this, I encourage you to post your solution: it seems that others 
might be interested.

-- Bob (balexander@ccmail.com)


______________________________ Reply Separator _________________________________
Subject: Icon and sockets
Author:  walter!flaubert!norman@rutgers.edu  (Norman Ramsey) at internet-mail
Date:    1/10/94 11:17 AM


In article <CJ7nLJ.DL6@walter.bellcore.com>, 
Darren New  <dnew@thumper.bellcore.com> wrote:
>You can delete, unfortunately, easy low-level nonportable access to OS 
>features.  It's non-trivial to use sockets, for example, from inside 
>Icon, I've found. 

Yes, and it's a disappointment.  I had the idea of trying
 socket := open("telnet myhost 119", "bp")
on a Unix host to see if I could write network clients that way, but I 
haven't actually gotten around to it yet.  If anyone gets something 
similar to work, I would enjoy hearing about it.

To write servers, the best alternative may be to write a C program 
that uses accept(2) and then forks an Icon program once a connection 
is established.

Norman




From icon-group-sender  Tue Jan 11 18:48:06 1994
Received: by cheltenham.cs.arizona.edu; Tue, 11 Jan 1994 12:52:10 MST
From: sperber@provence.informatik.uni-tuebingen.de (Michael Sperber [Mr. Preprocessor])
Message-Id: <9401111748.AA28891@provence.informatik.uni-tuebingen.de>
To: icon-group@cs.arizona.edu
Reply-To: sperber@informatik.uni-tuebingen.de
Subject: Icon and PTYs
Date: Tue, 11 Jan 94 18:48:06 +0100
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

I posted about this a while ago, and back then I wrote a kludgy
solution called flush.  I use it for controlling an interactive SML
compiler from an Icon program.  The basic idea is that flush starts a
process on a tty, and forces all output to be flushed at each newline.
This means you can open(..,"p..") a file from Icon, redirect output to
a temp file an poll that file for output to arrive.

Problem is this is the first (and only) pty code I ever wrote.  I've
tried to conform to the BSD docs that I have, but I'm not sure it runs
on anything but AIX.  I'd be grateful if someone else could give this
a whirl and tell me what I need to change to make it run on other
architectures.

If there's interest, I could post the compiler driver also as an
example.

Since this project has shown me that Icon is - except for
pipe/socket/pty handling - ideally suited for controlling interactive
programs, I'd really appreciate Icon had an option to open that
would start a process on a pty pipe.

Cheers =8-} Chipsy

--snip, snip--
/* flush.c : execute the command on the command line
             through a pty making sure all the output
	     from the command is flushed on a
	     line-by-line basis. */

/* $Log: flush.c,v $
 * Revision 1.2  1993/07/20  13:41:30  sperber
 * New version with pty code from rxvt.
 * */

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <termio.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/wait.h>

static char rcsid[] = "$Id: flush.c,v 1.2 1993/07/20 13:41:30 sperber Exp sperber $";

int
main(int argc, char *argv[])
{
  void pass_through(int, int);
  static char ptynam[] = "/dev/ptyxx";
  static char ttynam[] = "/dev/ttyxx";
  struct termios ttmode;
  int ptyfd, ttyfd;
  int uid, gid;
  unsigned char *s3, *s4;
  int i;
  int width, height;
  static char ptyc3[] = "pqrstuvwxyz";
  static char ptyc4[] = "0123456789abcdef";
  unsigned char argv0[256];
  int comm_pid;

  /*  First find a master pty that we can open.
   */
  ptyfd = -1;
  for (s3 = ptyc3; *s3 != 0; s3++) 
    {
      for (s4 = ptyc4; *s4 != 0; s4++) 
	{
	  ptynam[8] = ttynam[8] = *s3;
	  ptynam[9] = ttynam[9] = *s4;
	  if ((ptyfd = open(ptynam, O_RDWR)) >= 0) 
	    {
	      if (geteuid() == 0 || access(ttynam, R_OK|W_OK) == 0)
		break;
	      else 
		{
		  close(ptyfd);
		  ptyfd = -1;
		}
	    }
	}
      if (ptyfd >= 0)
	break;
    }
  if (ptyfd < 0) 
    {
      perror("Can't open a pseudo teletype");
      return(-1);
    }

  fcntl(ptyfd, F_SETFL, O_NDELAY);
  
  comm_pid = fork();
  if (comm_pid < 0) 
    {
      perror("Can't fork");
      return(-1);
    }
  if (comm_pid == 0) 
    {
      if (setsid() < 0)
	perror("failed to set process group");
      
      if ((ttyfd = open(ttynam, O_RDWR)) < 0) 
	{
	  perror("could not open slave tty");
	  exit(1);
	}
      uid = getuid();

      dup2(ttyfd, fileno(stdin));
      dup2(ttyfd, fileno(stdout));
      dup2(ttyfd, fileno(stderr));

      ttmode.c_iflag = BRKINT | IGNPAR | ISTRIP | ICRNL | IXON | IMAXBEL;
      ttmode.c_oflag = OPOST | ONLCR;
      ttmode.c_cflag = B9600 | PARENB | CS8 | CREAD;
      ttmode.c_lflag = ISIG | IEXTEN | ICANON;
      ttmode.c_cc[VINTR] = 003;
      ttmode.c_cc[VQUIT] = 034;
      ttmode.c_cc[VERASE] = 0177;
      ttmode.c_cc[VKILL] = 025;
      ttmode.c_cc[VEOF] = 004;
      ttmode.c_cc[VEOL] = 000;
      ttmode.c_cc[VEOL2] = 001;
      ttmode.c_cc[VSTART] = 000;
      ttmode.c_cc[VSTOP] = 021;
      ttmode.c_cc[VSUSP] = 023;
      ttmode.c_cc[VDSUSP] = 032;
      ttmode.c_cc[VREPRINT] = 022;
      ttmode.c_cc[VDISCRD] = 022;
      ttmode.c_cc[VWERSE] = 017;
      ttmode.c_cc[VLNEXT] = 027;
	
      ioctl(0,TCSETS,(char *)&ttmode);

      setgid(getgid());
      setuid(uid);
      execvp(argv[1], argv+1);
      fprintf(stderr, "Couldn't execute %s",argv[1]);
      exit(1);
    }
  pass_through(comm_pid, ptyfd);
  exit(0);
}

void
pass_through(pid_t pid, int fd)
{
  char in_char = '\0', out_char;
  int n, in_pending = 0, term = 0, stdin_alive = 1;
  int fd_stdin = fileno(stdin);

  if (fcntl(fd_stdin, F_SETFL, fcntl(fd_stdin, F_GETFL, 0) | O_NONBLOCK) == -1)
    {
      perror("F_SETFL");
      exit(1);
    }

  for (;;)
    {
      if (in_pending)
	{
	  n = write(fd, &in_char, 1);
	  if (n == 1)
	    in_pending = 0;
	}

      if (stdin_alive && !in_pending) 
	{
	  n = read(fd_stdin, &in_char, 1);
	  if (n == -1)
	    {
	      if (errno != EAGAIN)
		{
		  perror("unknown error during unblocked read");
		  exit(1);
		}
	    }
	  else if (n == 1)
	    in_pending = 1;
	  else if (!n) /* EOF on stdin */
	    {
	      in_char = '\004';
	      in_pending = 1;
	      stdin_alive = 0; 
	    }
	}

      term = waitpid(pid, 0, WNOHANG);
      n = read(fd, &out_char, 1);
      if (n < 1 && term)
	{
	  fflush(stdout);
	  close(fd);
	  exit(0);
	}
      if (n == 1)
	{
	  putchar(out_char);
 	  if (out_char == '\n')
	    fflush(stdout);
	}
    }
}






From icon-group-sender  Sun Jan  9 17:32:56 1994
Received: by cheltenham.cs.arizona.edu; Thu, 13 Jan 1994 07:20:26 MST
Date: 9 Jan 94 17:32:56 GMT
From: cis.ohio-state.edu!math.ohio-state.edu!howland.reston.ans.net!cs.utexas.edu!swrinde!sgiblab!sgigate.sgi.com!olivea!news.bbn.com!noc.near.net!news.delphi.com!usenet@ucbvax.Berkeley.EDU  (Will Mengarini)
Organization: Delphi Internet
Subject: IconT that outputs MS-DOS .Exe files available
Message-Id: <940109.45176.MENGARINI@delphi.com>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

A version of the Icon v8.8 translator for MS-DOS that produces .Exe files
is available in the form of ready-to-use binaries (new versions of IconT
and IconX), along with a copy of the Usenet article that showed how to
hack the v8.8 translator source code to produce these binaries.
 
Do an anonymous FTP to bellcore.com; cd norman; binary; get iconexe.zip.
That will give you a .Zip file you can de-archive with PKUnZip v2.04;
InfoZip should work too though I haven't tried it.
 
The .Zip file contains a README telling you how to install the binaries.
 
Thanks to Norman Ramsey (norman@bellcore.com) for providing this FTP site.
Report bugs to mengarini@delphi.com, or preferably post in comp.lang.icon.


From icon-group-sender  Sun Jan  9 17:29:40 1994
Received: by cheltenham.cs.arizona.edu; Thu, 13 Jan 1994 10:05:54 MST
Date: 9 Jan 94 17:29:40 GMT
From: cis.ohio-state.edu!math.ohio-state.edu!darwin.sura.net!sgiblab!sgigate.sgi.com!olivea!news.bbn.com!noc.near.net!news.delphi.com!usenet@ucbvax.Berkeley.EDU  (Will Mengarini)
Organization: Delphi Internet
Subject: Re: ICON compiler
Message-Id: <940109.44980.MENGARINI@delphi.com>
References: <2gf1g2$c6@cs.ubc.ca>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: RO
Errors-To: icon-group-errors@cs.arizona.edu

Lili Liu <lili@cs.ubc.ca> writes:
 
>I need to get the compiler for ICON language. 
>Does anyone know the ftp site number and the directory to get it?
 
FTP cs.arizona.edu
cd icon
 
Then, your next cd command depends on whether you want the source code
for the compiler or just the executable binary. For source,
cd packages; for binaries, cd binaries.
 
Then do a dir command. The subdirectories you'll see will
correspond to operating systems; eg, there's a msdos directory
and a unix directory. The rest should be self-explanatory.
 
Ahem...this request was posted on 5 Jan, & I didn't see it until 9 Jan.
I answered immediately, but nobody else answered during those 4 days.
We shouldn't be so careless when we've a chance to initiate new Believers.
There were 2 weeks when this newsgroup was dead air--no articles.
It takes work to spread the faith.


From icon-group-sender  Thu Jan 13 12:40:48 1994
Received: by cheltenham.cs.arizona.edu; Thu, 13 Jan 1994 12:49:29 MST
Date: Thu, 13 Jan 1994 12:40:48 MST
From: "Ralph Griswold" <ralph>
Message-Id: <199401131940.AA01776@cheltenham.cs.arizona.edu>
To: icon-group
Subject: Icon FAQ
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


    Frequently Asked Questions About The Icon Programming Language

This FAQ answers various questions about the Icon programming language,
ranging from what it is to how you can get it.  This first version of the
Icon FAQ is devoted to the issues that are likely to be of most interest
to persons who don't know anything about Icon or who are relatively
new to it.  Future versions of this FAQ will answer questions from
more experienced Icon programmers.

This FAQ is written by Ralph Griswold with help from Cliff Hathaway,
Clint Jeffery, and Gregg Townsend.

Section I -- General Questions:

I.1.   What is Icon?
I.2.   What is Icon good for?
I.3.   Where did Icon come from?
I.4.   What does "Icon" stand for?
I.5.   What computers does Icon run on?
I.6.   Who did all these implementations?
I.7.   Are there other implementations in the works?
I.8.   Are there different versions of Icon?
I.9.   Which implementations of Icon have graphics/window capabilities?
I.10.  Where can I get Icon?
I.11.  Where can I get documentation about Icon?
I.12.  What is the Icon Project?
I.13.  Where can I find examples of Icon programs?
I.14.  What is Idol?
I.15.  How often is material in Icon's FTP area updated?
I.16.  How do I stay up to date with what's going on with Icon?
I.17.  Why isn't the Icon Newsletter available electronically?
I.18.  Is there a users' group for Icon?
I.19.  How do I get technical support?
I.20.  Is there an optimizing compiler for Icon?
I.21.  What do I need to run the interpreter?
I.22.  What do I need to run the compiler?
I.23.  Can I build my own implementation of Icon for a new platform?

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

I.1.   What is Icon?

Icon is a very high level general-purpose programming language with
extensive features for processing strings (text) and data structures.
Icon is an imperative, procedural language with a syntax that is
reminiscent of C and Pascal, but its semantics are at a much higher level
than those languages.

Icon has a novel expression-evaluation mechanism that integrates goal-
directed evaluation and backtracking with conventional control structures.
It has a string scanning facility for pattern matching that avoids 
the tedious details usually associated with analyzing strings. Icon's
built-in data structures include sets and tables with associative lookup,
lists that can be used as vectors or stacks and queues, and records.

Icon is a strongly, though not statically, typed language. It provides
transparent automatic type conversion. For example, if an integer is
used in an operation that requires a string, the integer is automatically
converted to a string.

Several implementations of Icon have high-level graphics facilities with
an easily programmed window interface.

Icon manages storage automatically. Objects are created as needed during
program execution and space is reclaimed by garbage collection as needed.
The sizes of strings and data structures are limited only by the amount
of available memory.


I.2.   What is Icon good for?

As a general-purpose programming language with a large computational
repertoire, Icon can be used for most programming tasks.  It's at
its best when used as a prototyping tool, for processing text, and when
ease of programming is needed for experimental and research applications.

Paradoxically, Icon is used most often for short, one-shot tasks and for very
complex applications.

Icon is designed to make programming easy; it emphasizes the value of
programmer's time and the importance of getting programs to work quickly.
This explains its usefulness for prototyping as well as the apparent
paradox of applicability to simple and complex applications.


I.3.   Where did Icon come from?

Icon is the latest in a series of high-level programming languages designed
to facilitate programming tasks involving strings and structures. The
original language, SNOBOL, was developed at Bell Telephone Laboratories
in the early 60s.  SNOBOL evolved into SNOBOL4, which is still in use.
Subsequent languages were developed at The University of Arizona with
support from the National Science Foundation.

Incidentally, Icon bears little physical resemblance to SNOBOL4, although
it has similar objectives and many similar capabilities.


I.4.   What does "Icon" stand for?

The name Icon (which is not spelled ICON) is not an acronym nor does it
stand for anything in particular, although the word iconoclastic was
mentioned at the time the name was chosen.  The name predates the now
common use of "icon" to refer to small images used in graphical user
interfaces.  This latter usage sometimes causes persons to think mistakenly
that Icon is designed to create or manipulate icons.  There's not much
that can be done about this.


I.5.   What computers does Icon run on?

The implementation of Icon is highly portable. There are versions for
the Acorn Archimedes, the Amiga, the Atari ST, IBM CMS and MVS, the
Macintosh, MS-DOS, OS/2, UNIX, and VMS.  Nearly 60 UNIX platforms are
supported.
Icon programs also are highly portable. Most Icon programs can run on
any platform that supports Icon.


I.6.   Who did all these implementations?

The original implementation of Icon for UNIX was done at The University
of Arizona.  Most of the other implementations originally were done
by volunteers scattered around the world.

It's worth noting that all implementations of Icon are based on the same
source code, which is written in C.  This contributes to the portability 
of Icon itself, as well as to the portability of programs written in Icon.


I.7.   Are there other implementations in the works?

Yes, work is constantly underway on implementations of Icon for new
platforms.  Present projects include Windows NT, Windows32, the DEC Alpha
running under UNIX, and a new Macintosh implementation.


I.8.   Are there different versions of Icon?

Icon has evolved through a series of versions with improved and extended
capabilities.  The latest major version number is 8.  Recent changes
and additions, notably in the graphics area, have brought the current
level to 8.10.  (Version 8.11 is, of course, in the works.)  Most
implementations are up to 8.10, although a few for less frequently
used platforms are still at 8.0.  Almost all 8.0 programs will run
under 8.10.


I.9.   Which implementations of Icon have graphics/window capabilities?

Icon's graphics facilities presently are supported on the OS/2, UNIX, and
VMS implementations.  The UNIX and VMS implementations use X, while the
OS/2 implementation uses Presentation Manager.

The NT, Windows32, and DEC Alpha implementations that are in progress
will support Icon's graphics facilities.  There also is a Macintosh
implementation to support graphics in the works.


I.10.  Where can I get Icon?

Most implementations of Icon are available via anonymous FTP to
cs.arizona.edu in /icon.  The directory /icon/binaries contains executable
versions of Icon for several systems, including several popular UNIX
platforms.  The directory /icon/packages contains source code and
related material.  All directories have READ.ME files with additional
information.

Icon also is available on a variety of physical media for prices ranging
from $15 to $50.  Contact:

	Icon Project
	Department of Computer Science
	The University of Arizona
	Tucson, AZ   85721

	602-621-8448 (voice)
	602-621-4246 (fax)

	icon-orders@cs.arizona.edu (e-mail)

Request a copy of the Icon Newsletter for a listing of what's available
and what the prices are.

Purchases can be made by credit card (MasterCard, Visa, or Discover) or
by check drawn on a bank with a branch in the United States and made
payable to The University of Arizona.


I.11.  Where can I get documentation about Icon?

The definitive work on Icon is the book

	The Icon Programming Language, Griswold and Griswold,
	Prentice-Hall, 1990, 367 pages, ISBN 0-13-447889-4.

This book is a complete description and reference manual for Version 8 of
Icon.

There also is a book on the implementation of Icon:

	The Implementation of the Icon Programming Language, Griswold
	and Griswold, Princeton University Press, 1986, 336 pages, ISBN
	0-691-08431-9.

This book describes the implementation as of Version 6 of Icon.  Although
the implementation has changed somewhat since then, the basic structure
is the same.  Technical reports describing recent implementation changes
are included with books purchased from the Icon Project.

These books are available from the Icon Project or from any book store
that handles special orders.

Additional documentation is available via FTP in /icon/doc.  Notable
documents are:

	TR 90-6	  an overview of Icon
	TR 93-9	  graphics/window facilities
	IPD212	  changes between Versions 8.0 and 8.10

There are manual pages for UNIX systems, but there is no complete
on-line documentation.  
	
The Icon Newsletter, which includes topical material about Icon and
a list of material available from the Icon Project, is published three
times a year.  Subscriptions are free; contact the Icon Project to get
a copy of the latest Newsletter and to be put on the mailing list.

The Icon Analyst, a technically oriented newsletter that features articles
about programming, is published six times a year.  There is a subscription
fee for the Analyst.  A sample copy is available on request.

All back issues of both newsletters are available for purchase.


I.12.  What is the Icon Project?

The Icon Project is a name used by the group at The University of
Arizona that develops, implements, distributes, and supports the
Icon programming language.

The Icon Project is not commercial organization.  It derives support
from The University of Arizona, grants, and (primarily) revenues from
the sale of program material and documentation.


I.13.  Where can I find examples of Icon programs?

There is a large program library for Icon.  It is an excellent resource
for both new and experienced programmers, containing numerous examples of
how to do things with Icon.  The library also provides many useful
applications, as well as hundreds of procedures that can be used to
supplement Icon's built-in repertoire.

The library, like other Icon material, is available via FTP (cd /icon/library)
and on physical media from the Icon Project.


I.14.  What is Idol?

Idol is an object-oriented extension to Icon that provides concepts such
as classes and multiple inheritance.  Idol is written in Idol and is
distributed as part of the Icon program library.  Idol runs on almost all
of the platforms that Icon runs on.

Additional Idol information is available from Clint Jeffery,
jeffery@ringer.cs.utsa.edu.


I.15.  How often is material in Icon's FTP area updated?

New material is added when it's available.  Established implementations
usually are only updated when there's a major new release.  This typically
is every year or two.  The Icon program library is updated on a similar
schedule.


I.16.  How do I stay up to date with what's going on with Icon?

The best way to find out about developments related to Icon is to
subscribe to the Icon Newsletter.  It's free, but it is distributed
only by postal mail, so you must provide a mailing address.

You can stay up to date on the source code, which is changed much more
frequently than the version on FTP is updated, by subscribing to the
source update service, which provides a new version about three times
a year.

There also is a subscription service for updates to the Icon program
library, which provides new material three or four times a year.

See the Icon Newsletter for information about subscribing to these
services.


I.17.  Why isn't the Icon Newsletter available electronically?

The Icon Newsletter contains diagrams, images, and other material that
cannot be rendered in plain ASCII text.  The Newsletter is prepared with
a desktop publishing system that produces PostScript, but the files are
enormous -- too large to justify their inclusion in the Icon FTP area.
Selected articles from the Newsletter are available by FTP in
/icon/doc/articles.


I.18.  Is there a users' group for Icon?

There is no official Icon users' group.  The Icon Project maintains a
mailing list, icon-group@cs.arizona.edu.  Mail sent to this address
is forwarded to subscribers.  To subscribe (or unsubscribe), send a
message to icon-group-request@cs.arizona.edu.

There is a gateway between icon-group and comp.lang.icon, an unmoderated
newsgroup for discussing issues related to Icon.  The gateway, which
exchanges messages between the two systems, is imperfect and not under
the control of the Icon Project.

The newsgroup generally provides faster response than the mailing list.
The newsgroup is less intrusive, but it sometimes suffers from inappropriate
postings.  The Icon Project usually sends messages of interest to the
Icon community to icon-group.

I.19.  How do I get technical support?

Free technical support is available from the Icon Project via electronic
mail to icon-project@cs.arizona.edu or by fax, telephone, and postal mail
to the Icon Project as listed above.

Since the Icon Project is not a commercial organization, support is limited
to what it can provide with its available resources.  If the Icon Project
cannot help with a problem (such as for a platform it doesn't have), it will
attempt to provide a contact with someone who can help.


I.20.  Is there an optimizing compiler for Icon?

Yes.  The original implementation was an interpreter.  An optimizing
compiler was added a few years ago.  The interpreter and compiler are
largely source-language compatible.

The interpreter is used by most Icon programmers because it gets into
execution quickly and runs fast enough for most applications.  The compiler
is best suited for applications that require the fastest possible
execution time.  In this case, it's generally best to develop the program
using the interpreter and compile the final result from production use.


I.21.  What do I need to run the interpreter?

The Icon interpreter will run on most computers.  It requires a reasonable
amount of memory, however.   Under MS-DOS, the Icon interpreter needs
500KB of RAM to work well.


I.22.  What do I need to run the compiler?

The Icon compiler is another matter.  It requires a C compiler, a fast
CPU for tolerable compilation times, a considerable amount of disk
space, and a lot of memory -- at least several megabytes.

The Icon compiler generates C code, which must then be compiled to
produce an executable program.  The flexibility that Icon provides to
programmers makes compilation technically difficult and the process
requires a large amount of memory.  The C code it produces is voluminous
and stresses the most robust C compilers.

Generally speaking, the Icon compiler is practical for platforms in
the workstation class but not for most personal computers.  Although
the compiler can be built and made to run on 286 platforms running
standard MS-DOS, only trivially small programs can be compiled.  In
principle, the Icon compiler is practical on MS-DOS 386/486 platforms
with extended memory, but the limited availability of suitable 32-bit C
compilers for this environment has discouraged the use of the Icon compiler
on such platforms.


I.23.  Can I build my own implementation of Icon for a new platform?

As mentioned above, Icon is written in C and the source code is available
via FTP and the Icon Project.  The existing implementations are testament
to its portability.  (There is a small amount of assembly-language code
required for a context switch, but this is only needed for an optional
feature that can be disabled without affecting most of Icon.)

New ports involve platform-specific configuration parameters and, in
some cases, platform-specific code.  The feasibility of a new port and
the amount of work it may take depends on the platform -- its architecture,
its C compiler, and its environment.

Ports to new UNIX platforms generally are easy, although some, such as the
DEC Alpha, present problems.  Ports to new operating systems generally are
more difficult, especially if Icon's graphics facilities are implemented.

The Icon Project provides what help it can with new ports.  In return, it
asks that code related to the port to be returned to the Icon Project for
inclusion in future versions of the source code for Icon.  This makes the
new port available to others as well as to the porter when Icon is updated.


From icon-group-sender  Mon Jan 10 13:48:33 1994
Received: by cheltenham.cs.arizona.edu; Fri, 14 Jan 1994 09:04:39 MST
Date: 10 Jan 94 13:48:33 GMT
From: cis.ohio-state.edu!math.ohio-state.edu!darwin.sura.net!news-feed-1.peachnet.edu!concert!corpgate!crchh327.bnr.ca!eaglesto@ucbvax.Berkeley.EDU  (Robert Eaglestone)
Organization: Bell Northern Research, Richardson, TX
Subject: Re: ICON compiler
Message-Id: <2grmbh$pgh@crchh972.bnr.ca>
References: <2gf1g2$c6@cs.ubc.ca>, <940109.44980.MENGARINI@delphi.com>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


In article <940109.44980.MENGARINI@delphi.com>, Will Mengarini <MENGARINI@delphi.com> writes:  
|> Ahem...this request was posted on 5 Jan, & I didn't see it until 9 Jan.
|> I answered immediately, but nobody else answered during those 4 days.
|> We shouldn't be so careless when we've a chance to initiate new Believers.
|> There were 2 weeks when this newsgroup was dead air--no articles.
|> It takes work to spread the faith.

...even when folks like me are eager to listen!

rob

---

assert(not_equal(rob, spokesperson(BNR)))


From icon-group-sender  Mon Jan 10 14:39:42 1994
Received: by cheltenham.cs.arizona.edu; Mon, 17 Jan 1994 20:20:15 MST
Date: 10 Jan 94 14:39:42 GMT
From: mlfarm!auda!ron@uunet.uu.net  (Ronald Florence)
Organization: Maple Lawn Farm, Stonington, CT
Subject: envelope.icn (addresses envelopes with barcodes)
Message-Id: <CJF4qB.5zD@mlfarm.com>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

I've missed the occasional posts of short, useful code we used to see
in this newsgroup, not only as a source of utilities, but as models of
good Icon coding techniques.  I'm posting this updated version of an
envelope addresser I wrote several years ago in the hope that someone
may find it useful, and that I may get back some suggestions of better
ways to do the string scanning and other Icon coding.

We've used this addresser with both Postscript and HP-laserjet
printers, for letters in groff and LaTeX, and mailing lists.

############################################################################
#
#	Name:	envelope.icn
#
#	Title:	Envelope Addresser (with barcodes)
#
#	Author:	Ronald Florence (ron@mlfarm.com)
#
#	Date:	10 January 1994
#
#	Version: 1.1
#
############################################################################
#  
#  This program addresses envelopes on a Postscript or HP-LJ printer,
#  including barcodes for the zip code.  A line beginning with `#' or
#  an optional alternate separator can be used to separate multiple
#  addresses.  The parser will strip the formatting commands from an
#  address in a troff or LaTeX letter.
#
#  usage: envelope [options] < address(es)
#  
#  Typically, envelope is used from inside an editor.  In emacs, mark
#  the region of the address and do
#	M-| envelope 
#  In vi, put the cursor on the first line of the address and do
#	:,+N w !envelope 
#  where N = number-of-lines-in-address.  
#
#  The barcode algorithm is adapted from a perl script by Todd Merriman
#  <todd@toolz.uucp>, Dave Buck <dave@dlb.uucp>, and Andy Rabagliati
#  <andyr@wizzy.com>.
#
############################################################################
#
#  Link: options
#
############################################################################

link options
global Printertype

procedure main(arg)
  local opts, lp, separator, printerinit, printerclear, 
	hpinit, hppos, xorigin, yorigin, rotate, font, 
	prn, addr, psprefix, preface, optstr, usage, goodline

  usage := ["usage: envelope [options] < address(es)",
	    "\t-p | -postscript",
	    "\t-h | -hplj",
	    "\t-l | -printer spooler-program",
	    "\t-s | -separator string",
	    "\t-i | -init  printer-init",
	    "\t-c | -clear printer-clear",
	    "\t-f | -font fontname    [Postscript only]",
	    "\t-x | -xorigin xorigin  [Postscript only]",
	    "\t-y | -yorigin yorigin  [Postscript only]",
	    "\t-r | -rotate rotation  [Postscript only]",
	    "\t-hpinit string  [hplj only]",
	    "\t-hppos  string  [hplj only]" ]
  psprefix := ["%! Postscript",
               "/adline { 10 y moveto show /y y 13 sub def } def",
               "/barcode {",
               "  /y y 13 sub 0.72 div def",
               "  0.72 dup scale 2 setlinewidth",
               "  /x 100 def",
               "  /next { x y moveto /x x 5 add def } def",
               "  /S { next 0 5 rlineto stroke } def",
               "  /L { next 0 12 rlineto stroke } def } def",
               "/newenvelope {",
               "  /y 80 def" ]
  optstr := "hpl:f:r+i:c:x+y+s:?"
  optstr ||:= "-help!-printer:-hpinit:-hppos:-postscript!:-font:-hplj!"
  optstr ||:= "-rotate+-xorigin+-yorigin+-init:-clear:-separator:"
  opts := options(arg, optstr)
  \opts["?"|"help"] | arg[1] == "?" & { 
    every write (!usage)
    exit (-1)
  }
					# change defaults below as needed
  Printertype := 				"hplj"
  lp := \opts["l"|"printer"] |			"lpr"
  separator := \opts["s"|"separator"] |		"#"
  printerinit := \opts["i"|"init"] |	      	""
  printerclear := \opts["c"|"clear"] |		""
					# the next four are Postscript-only
  xorigin := \opts["x"|"xorigin"] |		200	       
  yorigin := \opts["y"|"yorigin"] |		400
  rotate := \opts["r"|"rotate"] |		90
  font := \opts["f"|"font"] |			"Palatino-Bold"
					# these two are hplj-only
					# comm. env., manual feed, landscape
  hpinit := \opts["hpinit"] |			"\33&k2G\33&l81a3h1O"
  hppos := \opts["hppos"] |			"\33&a40L\33*p550Y"

  \opts["h"|"hplj"] & Printertype := "hplj"
  \opts["p"|"postscript"] & Printertype := "postscript"
  if "pipes" == &features then prn := open(lp, "pw")
  else if "MS-DOS" == &features then prn := open ("PRN", "w")
  else stop ("envelope: please configure printer")
  writes(prn, printerinit)

  if map(Printertype) == "postscript" then {
    every write(prn, !psprefix)
    write(prn, "  ", xorigin, " ", yorigin, " translate ", rotate, " rotate")
    write(prn, "  /", font, " findfont 12 scalefont setfont } def")
    preface := "newenvelope\n"
  }
  else preface := hpinit || hppos
  addr := []
  every !&input ? {
				# filter troff junk
    =(".DE" | ".fi") & break
    if =(".DS" | ".nf") then tab(0)
				# multiple addresses with separators
    if =separator then {
      (*addr > 0) & address(addr, prn, preface) 
      addr := []
      tab(0)
    }
				# filter LaTeX junk
    else {
      if ="\\begin" then { 
	every tab(upto('{')+1) \2
	goodline := clean(tab(0), '\\')
      }
      else goodline := clean(tab(0), '\\')
      put(addr, trim(goodline, ' }'))
    }
  }
  (*addr > 0) & address(addr, prn, preface)
  writes(prn, printerclear)
end


procedure address(addr, prn, preface)
  local zip, zline

  zip := ""
  writes(prn, preface)
  every !addr ? 
    if map(Printertype) == "postscript" then 
      write(prn, "(", tab(0), ") adline")
    else write(prn, tab(0))
				# scan for zipcode
  while *(zline := trim(pull(addr))) = 0
  reverse(zline) ? if many(&digits++'-') = (6|11) then
      while tab(upto(&digits)) do zip ||:= tab(many(&digits))
  (*zip = (5|9)) & barcode(reverse(zip), prn)
  if map(Printertype) == "postscript" then write(prn, "showpage")
  else writes(prn, "\33E")
end


procedure barcode(zip, prn)
  local z, zipstring, cksum, bar

  cksum := 0
  every cksum +:= !zip
  zip := zip || (100 - cksum) % 10
  bar := ["LLSSS", "SSSLL", "SSLSL", "SSLLS", "SLSSL", 
	  "SLSLS", "SLLSS", "LSSSL", "LSSLS", "LSLSS" ]
				# The barcode is wrapped in long marks
  zipstring := "L"
				# Icon lists are indexed from 1
  every z := !zip do zipstring ||:= bar[z + 1]
  zipstring ||:= "L"
  if map(Printertype) == "postscript" then write(prn, "barcode")
  else writes(prn, "\33*p990y1575X\33*c6A")	
  every !zipstring ? 
    if map(Printertype) == "postscript" then write(prn, tab(0))
    else {
      if =("S") then writes(prn, "\33*p+21Y\33*c15b0P\33*p-21Y")
      else writes(prn, "\33*c36b0P")
      writes(prn, "\33*p+15X")
    }
end


procedure clean(s, c)

  while i := upto(c, s) do s[i:many(c,s,i)] := ""
  return s
end

# ----------------------------[eof]---------------------------
--

				Ronald Florence
				ron@mlfarm.com


From icon-group-sender  Wed Jan 12 14:52:49 1994
Received: by cheltenham.cs.arizona.edu; Mon, 17 Jan 1994 20:20:58 MST
Date: 12 Jan 94 14:52:49 GMT
From: cis.ohio-state.edu!math.ohio-state.edu!howland.reston.ans.net!europa.eng.gtefsd.com!MathWorks.Com!noc.near.net!news.delphi.com!usenet@ucbvax.Berkeley.EDU  (Will Mengarini)
Organization: Delphi Internet
Subject: Re: ICON compiler
Message-Id: <940112.35569.MENGARINI@delphi.com>
References: <2gf1g2$c6@cs.ubc.ca>, <940109.44980.MENGARINI@delphi.com>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Will Mengarini <MENGARINI@delphi.com> writes:
 
>Ahem...this request was posted on 5 Jan, & I didn't see it until 9 Jan.
>I answered immediately, but nobody else answered during those 4 days.
>We shouldn't be so careless when we've a chance to initiate new Believers.
>There were 2 weeks when this newsgroup was dead air--no articles.
 
2 people e-mailed me that they had replied immediately by e-mail.
OK, that's reasonable, but bandwidth isn't really a pressing problem
in this group, & responding by posting instead notifies others that
the request has been met and allows an opportunity for glossing
each others' remarks if necessary.


From icon-group-sender  Tue Jan 18 12:22:17 1994
Received: by cheltenham.cs.arizona.edu; Tue, 18 Jan 1994 09:19:10 MST
Date: Tue, 18 Jan 94 12:22:17 +0100
From: karczma@univ-caen.fr (Jerzy Karczmarczuk)
Message-Id: <9401181122.AA05525@milou.univ-caen.fr>
To: icon-group@cs.arizona.edu
Subject: Graphics on PC
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


Excuse me if you find this question silly:

The distribution package of Icon for MS-Dos is equipped with the X-Icon
Library. But it doesn't work, open(... "x", ...) is illegal. Do I have
a wrong version of Icon for PC, or the X-Icon graphics is not implemented
at all, or I should do something really special, or...?

Yours
Jerzy Karczmarczuk
  University of Caen, France


From icon-group-sender  Tue Jan 18 09:58:15 1994
Received: by cheltenham.cs.arizona.edu; Tue, 18 Jan 1994 12:24:31 MST
Date: Tue, 18 Jan 1994 09:58:15 MST
From: "Ralph Griswold" <ralph>
Message-Id: <199401181658.AA04663@cheltenham.cs.arizona.edu>
To: karczma@univ-caen.fr
Subject: Re:  Graphics on PC
Cc: icon-group
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

The Icon program library distribution is the same for all formats and
always includes the graphics ("X") part, regardless of the platform.

MS-DOS Icon does not support graphics (OS/2 Icon does).

Just ignore the graphics part of the library if you're running Icon
on a platform that does not support graphics.
    
Ralph E. Griswold			ralph@cs.arizona.edu
Department of Computer Science 		 uunet!arizona!ralph
The University of Arizona		602-621-6609 (voice)
Tucson, AZ 85721			602-621-4246   (fax)


From icon-group-sender  Fri Jan 14 04:57:58 1994
Received: by cheltenham.cs.arizona.edu; Thu, 20 Jan 1994 09:07:11 MST
Date: 14 Jan 94 04:57:58 GMT
From: bloom-beacon.mit.edu!pad-thai.aktis.com!noc.near.net!news.delphi.com!dligda@uunet.uu.net  (David Ligda)
Organization: Delphi Internet Services Corporation
Subject: Need help outputing to file
Message-Id: <9401132354591.dligda.DLITE@delphi.com>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Hello All,
 
I need some help with a very simple ICON program.
 
I would like to write a program that takes two command line paramaters
(input file and output file), reads each line from the input file and writes
it to the output file.  Here is what I have so far:
 
 
procedure main(args)
       in := open(args[1]) | stop("Can't open input file")
       out := open(args[2], "w") | stop("cannot open output file")
      #
      #  Loop to process lines of file.
      #
        while out := read(in) do {
           write(out)
           }
end
 
This seems to read the input file O.K. but writes the output to the screen
rather than the output file.
 
Any hints on what I am doing wrong?
 
Thanks in advance.
 
David       


From icon-group-sender  Fri Jan 14 06:24:08 1994
Received: by cheltenham.cs.arizona.edu; Thu, 20 Jan 1994 09:07:54 MST
Date: 14 Jan 94 06:24:08 GMT
From: organpipe.uug.arizona.edu!CS.Arizona.EDU!not-for-mail@uunet.uu.net  (Nevin Liber)
Organization: University of Arizona CS Department, Tucson AZ
Subject: Re: Need help outputing to file
Message-Id: <2h5dq8$h5m@caslon.CS.Arizona.EDU>
References: <9401132354591.dligda.DLITE@delphi.com>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

In article <9401132354591.dligda.DLITE@delphi.com>,
David Ligda <dligda@delphi.com> wrote:

>procedure main(args)
>       in := open(args[1]) | stop("Can't open input file")
>       out := open(args[2], "w") | stop("cannot open output file")

This assigns "out" with a value of type "file".

>        while out := read(in) do {

Here is the bug.  This overwrites the old value of "out" with a value
of type "string" (the first line of the input file).

>           write(out)

Since "out" is not of type "file", write() writses its output to the
default stream &output.

One way to fix this is to use a different variable to keep the line of
the file currently being worked on.  For example:

	while line := read(in) do {
		write(out, line)
	}

There are ways to do this as a one-liner, such as:

	while write(out, read(in))

But it might seem more confusing at first.
-- 
	Nevin ":-)" Liber	nevin@cs.arizona.edu	(602) 293-2799
	                 	                    	 ^^^ (520) after 3/95


From icon-group-sender  Fri Jan 14 16:39:21 1994
Received: by cheltenham.cs.arizona.edu; Thu, 20 Jan 1994 13:34:30 MST
Date: 14 Jan 94 16:39:21 GMT
From: swampler@noao.edu
Organization: National Optical Astronomy Observatories, Tucson AZ
Subject: Re: Need help outputing to file
Message-Id: <1994Jan14.163921.14999@noao.edu>
References: <9401132354591.dligda.DLITE@delphi.com>, <2h5dq8$h5m@caslon.CS.Arizona.EDU>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

In article <2h5dq8$h5m@caslon.CS.Arizona.EDU>, nevin@CS.Arizona.EDU (Nevin Liber) writes:
|> There are ways to do this as a one-liner, such as:
|> 
|> 	while write(out, read(in))
|> 
|> But it might seem more confusing at first.

No, that's not confusing.  *This* is confusing (sorry, it's friday
and my brain is fried):

procedure main(args)
   every write(open(args[2],"w"), !open(args[1]))
end

-- 
Steve Wampler
swampler@noao.edu
Gemini Project (under AURA)


From icon-group-sender  Fri Jan 21 11:23:06 1994
Received: by cheltenham.cs.arizona.edu; Fri, 21 Jan 1994 12:43:28 MST
Date: Fri, 21 Jan 1994 11:23:06 -0600 (CST)
From: Chris Tenaglia - 257-8765 <TENAGLIA@MIS.MCW.EDU>
Subject: Sample Icon Program : Nodelist
To: icon-group@cs.arizona.edu
Message-Id: <01H7XXF03F6A8WWKB2@mis.mcw.edu>
Organization: Medical College of Wisconsin (Milwaukee, WI)
X-Vms-To: IN%"icon-group@cs.arizona.edu"
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; CHARSET=US-ASCII
Content-Transfer-Encoding: 7BIT
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


I have some associates who have email accounts on BBS. Many BBS are on
FIDONET which I think is a modem network that works like uucp but with
fido protocol instead of uucp. There are one or more fidonet gateways.
Sending email from internet to fidonet is a bit of a challenge but
from my internet site the addressing is something like:

          Chris_Tenaglia@f280.n154.z1.fidonet.org
                          specifies
          Chris Tenaglia on fidonet at 1:154/280 (Exec-PC BBS)

The  z  and # specify the continent. The f and $ specify a region, and the f
and  number  is  the bbs node number. fidonet.org has a nodelist database in
ZIP format (about 2MB unzipped) and it's a comma delimited text file. It has
several different record types.

I  needed  to look up some numbers and I couldn't get it to work on xmosaic.
So  I  decided  to download the database and search/grep through it. I found
what I needed, but it sure didn't look good, so I wrote an icon filter. It's
called  NODELIST  named  after the NODELIST.014 database file it searches. I
include  the  search  program below. If interested, you have to download and
unzip  the  database on your own. It uses VT100... escape sequences and I've
tested  it on unix and vms systems. It would work on a PC too if ANSI.SYS is
installed in CONFIG.SYS.

Chris Tenaglia (System Manager) |  "The past explained,     
Medical College of Wisconsin    |   the future fortold, 
8701 W. Watertown Plank Rd.     |   the present largely appologized for."
Milwaukee, WI 53226             |   Organon to The Doctor
(414)257-8765                   |     
tenaglia@mis.mcw.edu

#
# FILE : NODELIST.ICN
# DESC : FIDONET NODE NAME/NUMBER LOOKUP UTILITY
# USAGE: ICONX NODELIST substr [database]
#        NODELIST.014 COMES FROM FTP.FIDONET.ORG in
#        /pub/fidonet/nodelist/nodelist.zip
#
# UPDATE          BY          WHAT
# 21-jan-1994     tenaglia    initial write
#

global pattern

procedure main(param)
  (pattern  := map(param[1])) | stop("No Pattern Specified!")
  database  := param[2]       | "nodelist.014"
  (in := open(database))      | stop("Can't open database :",database)

  zone := "unknown"
  host := "unknown"
  bbs  := "unknown"
  ys   := [3,11,19,3,11,19]
  xs   := [5,5,5,45,45,45]
  i    := 1
  title()
  
  every line := !in do
    {                                               
    if match("Zone,",line) then zone := parse(line,',')[2]
    if match("Host,",line) then host := parse(line,',')[2]
    if find(pattern,map(line))  then
      {
      if any(&ucase,line) then
        {
        field := parse(line,',')
        device:= field[1]
        bbs   := field[2]
        ident := field[3]
        city  := field[4]
        sysop := field[5]
        phone := field[6]
        writes(at(ys[i],xs[i]),ident)
        writes(at(ys[i]+1,xs[i]),city)
        writes(at(ys[i]+2,xs[i]),sysop)
        writes(at(ys[i]+3,xs[i]),phone)
        writes(at(ys[i]+4,xs[i]),"(Device=",device,") ",zone,":",host,"/",bbs)
        } else {
        field := parse(line,',')
        bbs   := field[1]
        ident := field[2]
        city  := field[3]
        sysop := field[4]
        phone := field[5]
        writes(at(ys[i],xs[i]),ident)
        writes(at(ys[i]+1,xs[i]),city)
        writes(at(ys[i]+2,xs[i]),sysop)
        writes(at(ys[i]+3,xs[i]),phone)
        writes(at(ys[i]+4,xs[i]),zone,":",host,"/",bbs)
        }
      if i = 6 then
        input(at(17,28) || "\e[7;1m Press <RETURN> to Continue. \e[m") | break
      if (i+:=1) > 6 then
        {
        i := 1
        title()
        }
      }
    }
  close(in)
  msg := "Done Searching. Press <RETURN>"
  input(at(9,1) || center(msg,79))
  writes(at(24,1),"\e[K")
  end

procedure title()
  write("\e[2J\e[H",center("NODELIST LOOKUP FOR FIDONET",79))
  msg := "Searching for (" || pattern || ")"
  write(at(9,1),center(msg,79))
  end
  
procedure input(prompt)       
  writes(prompt)
  return read()
  end

procedure at(y,x)   
  return "\e[" || y || ";" || x || "f"
  end

procedure parse(line,delims)
  static chars
  chars  := &cset -- delims
  tokens := []
  line ? while tab(upto(chars)) do put(tokens,tab(many(chars)))
  return tokens
  end



From icon-group-sender  Sat Jan 15 05:17:52 1994
Received: by cheltenham.cs.arizona.edu; Sat, 22 Jan 1994 09:25:55 MST
Date: 15 Jan 94 05:17:52 GMT
From: cis.ohio-state.edu!math.ohio-state.edu!howland.reston.ans.net!noc.near.net!news.delphi.com!dligda@ucbvax.Berkeley.EDU  (David Ligda)
Organization: Delphi Internet Services Corporation
Subject: Re: Need help outputing to file
Message-Id: <9401150014591.dligda.DLITE@delphi.com>
References: <2h5dq8$h5m@caslon.CS.Arizona.EDU>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Nevin,

Thank you very much for your reply.

Unfortunately all my Icon reference material is back at my office while I
am travelling.  Since I just started w/Icon I am forced to ask really basic
questions.

Thanks for your patience and explanation.

BTW - got the program to work just fine. :-)  I am really enjoying things
now that I am past the "hump" of this initial problem.

David


From icon-group-sender  Sat Jan 15 18:20:55 1994
Received: by cheltenham.cs.arizona.edu; Sat, 22 Jan 1994 09:28:26 MST
Date: 15 Jan 94 18:20:55 GMT
From: cis.ohio-state.edu!math.ohio-state.edu!howland.reston.ans.net!noc.near.net!news.delphi.com!dligda@ucbvax.Berkeley.EDU  (David Ligda)
Organization: Delphi Internet Services Corporation
Subject: Suggestion to handle "or" type expres.
Message-Id: <9401151317591.dligda.DLITE@delphi.com>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: RO
Errors-To: icon-group-errors@cs.arizona.edu

Hello All,

Sorry to have to keep asking these beginner questions but I am travelling
and don't have my ICON books.

Could someone suggest a method to modify the following expression so that it
will also check for a letter (&letter) at position 56?  In other words the
expression is true if there is a digit at position 5 and there is a digit OR
a letter at position 56.

       if any(&digits, line[5] & line[56]) then    # Is there a number at
                                                   # pos. 5 and at pos. 56?

Thanks!

David


From icon-group-sender  Wed Jan 26 14:06:12 1994
Received: by cheltenham.cs.arizona.edu; Wed, 26 Jan 1994 09:13:54 MST
Via: uk.ac.edinburgh.festival; Wed, 26 Jan 1994 14:06:56 +0000
Date: 26 Jan 94 14:06:12 GMT
From: R J Hare <rjhare@festival.ed.ac.uk>
Subject: PS files in X-Icon
To: icon-group@cs.arizona.edu
Organisation: Edinburgh University Computing Service
Message-Id: <9401261406.aa16711@uk.ac.ed.festival>
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

I am away from my Icon documentation for the next few days and need an answer
to the question "Can X-Icon write PostScrpt format files?".

Can anyone help please?

Thanks.

Roger Hare.


From icon-group-sender  Wed Jan 26 09:40:24 1994
Received: by cheltenham.cs.arizona.edu; Wed, 26 Jan 1994 09:40:48 MST
Date: Wed, 26 Jan 1994 09:40:24 +0700
From: gmt (Gregg Townsend)
Message-Id: <9401261640.AA09546@owl.cs.arizona.edu>
To: icon-group@cs.arizona.edu, rjhare@festival.ed.ac.uk
Subject: Re: PS files in X-Icon
Content-Length: 581
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

There's no direct support for PostScript in X-Icon, but the library packages
"psrecord" and "autopost" may be useful under some circumstances.

"psrecord" intercepts calls to XDrawRectangle, XFillArc, etc., and writes
copies of those commands to a PostScript file; not all X-Icon primitives
are handled, though.

"autopost" provides a way to slip "psrecord" into an arbitrary Icon program
without modifying the program.

    Gregg Townsend / Computer Science Dept / Univ of Arizona / Tucson, AZ 85721
    +1 602 621 4325     gmt@cs.arizona.edu     110 57 16 W / 32 13 45 N / +758m


From icon-group-sender  Thu Jan 20 23:25:22 1994
Received: by cheltenham.cs.arizona.edu; Sat, 29 Jan 1994 17:48:16 MST
Date: 20 Jan 94 23:25:22 GMT
From: sgigate.sgi.com!olivea!charnel!rat!mimbres.cs.unm.edu!khaki!steveo@rutgers.edu  (Steven L. Anderson)
Subject: Where is mode for emacs?
Message-Id: <1994Jan20.232522.16674@khaki.uucp>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Gentles,

	I am very interested in an info mode for emacs - does anyone
know of a site where I can get the files for such a mode?

	-sTeve-O
-- 
    ************************************************************************
    *  sTeve-O						Steven L. Anderson *
    *  steveo@titan.nmt.edu				415 2nd Street     *
    *  							Socorro, NM 87801  *


From icon-group-sender  Sat Jan 29 13:28:45 1994
Received: by cheltenham.cs.arizona.edu; Sat, 29 Jan 1994 17:53:03 MST
Message-Id: <199401291928.AA11678@optima.CS.Arizona.EDU>
Mime-Version: 1.0
Content-Type: text/plain; charset="us-ascii"
To: icon-group@cs.arizona.edu
From: Christopher P Smith <smith101@maroon.tc.umn.edu> (Christopher P. Smith)
Subject: document formatting
Date: Sat, 29 Jan 94 13:28:45 -0600
Status: RO
Errors-To: icon-group-errors@cs.arizona.edu

Hello,

  I am interested in a simple text formatting program, something which is a
primitive form of nroff.  The input is a plain text file with special
formatting instructions which govern the format of the lines following the
command.  The most primitive set of commands might be something like

.lp (for left justified paragraphs)
.tt (to indicate that the following text is to be unaltered "typed text")

  The program would read the input file and produce an output file with
paragraphs formatted according to the embedded commands.

Does anyone know of such a program or Icon script which accomplishes this?

Thanks.

________
Chris...




From icon-group-sender  Fri Jan 28 20:38:01 1994
Received: by cheltenham.cs.arizona.edu; Sun, 30 Jan 1994 20:20:50 MST
Date: 28 Jan 94 20:38:01 GMT
From: agate!dog.ee.lbl.gov!overload.lbl.gov!lll-winken.llnl.gov!uop!not-for-mail@ucbvax.Berkeley.EDU  (William Clark)
Organization: University of the Pacific
Subject: Table look up questions?
Message-Id: <2ibt39$ojg@uop.cs.uop.edu>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


   I am working on a project which needs to use a table (or some other 
   date structure.  I'm open for suggestions) for a look-up and translate 
   function.  The key will be a scrambled string of various characters
   and the other half (if possible) will be the translated or matching
   string.
   
   Example:  User inputs:  H W <enter>
	     Output: Hello World
   
   Where "H W" is a key in the table and "Hello World" is the other
   half.
   
   My questions are:  Is there an algorithm already out there which
   I can use to solve this problem?  Or can someone write some brief
   code which implements loading a table and looking the data up?  Also,
   If someone could explain "Tags" in the table.  Are these used to
   restrict look up areas?  (i.e. if the above example had a tag of "H"
   on the key, would this restrict the look up area to the H's only?)

   I should have mentioned, I am new to the ICON programming language and
   have placed an order for _The_Icon_Programming_Language_, 2nd ed.

   Thanks.

   William R. Clark
   University of the Pacific
   wclark@thor.cs.uop.edu


From icon-group-sender  Sun Jan 23 10:35:09 1994
Received: by cheltenham.cs.arizona.edu; Sun, 30 Jan 1994 20:22:17 MST
Date: 23 Jan 94 10:35:09 GMT
From: noc.near.net!news.delphi.com!usenet@uunet.uu.net  (Will Mengarini)
Organization: Delphi Internet
Subject: MS-DOS drive/dir query routines
Message-Id: <940123.20109.MENGARINI@delphi.com>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: RO
Errors-To: icon-group-errors@cs.arizona.edu

I suggest the Icon Project incorporate this in BIPL.
 
-------------------------------<CUT HERE (duh)>------------------------------
############################################################################
#
#  File:     drivedir.icn
#
#  Subject:  Procedures to inquire MS-DOS working dirs & current drive
#
#  Author:   Will Mengarini
#
#  Date:     Sa 18 Sep 93
#
############################################################################
#
#  Requires:  MS-DOS, DR-DOS, or compatible system
#
############################################################################
#
#  Every disk drive on a MS-DOS system has a "working directory", which is
#  the directory referred to by any references to that drive that don't begin
#  with a backslash (& so are either direct references to that working
#  directory, or paths relative to it). There is also 1 "current drive", &
#  its working directory is called the "current working directory". Any paths
#  that don't explicitly specify a drive refer to the current drive. For
#  example, "name.ext" refers to the current drive's working directory, aka
#  the current working directory; "\name.ext" refers to the current drive's
#  root directory; & "d:name.ext" refers to the working directory on d:.
#
#  It's reasonable to want to inquire any of these values. The CD command
#  displays both, in the form of a complete path to the current working
#  directory. However, passing such a path to either CD or the Icon function
#  chdir() doesn't change to that dir on that drive; it changes that drive's
#  working directory to the specified path without changing the current
#  drive. The command to change the current drive is the system() function
#  of a command consisting of just the drive letter followed by ":".
#
#  This affects the design of inquiry functions. They could be implemented
#  with system(  "CD >" || ( name := tempname() )  ) & read(open(name)), but
#  because this requires a slow disk access (which could fail on a full disk)
#  it's unacceptable to need to do that *twice*, once for the drive & again
#  for the dir; so if that strategy were used, it'd be necessary to return a
#  structure containing the current drive & the working directory. That
#  structure, whether table, list, or string, would then need to be either
#  indexed or string-scanned to get the individual values, making the code
#  cumbersome & obscure. It's much better to have 2 separate inquiry
#  functions, 1 for each value; but for this to be acceptably efficient, it's
#  necessary to forgo the disk access & implement the functions with
#  interrupts.
#
#  getdrive() returns the current drive as a lowercase string with the ":".
#  getwd("g") and getwd("g:") return the working directory on drive g:, or
#  fail if g: doesn't exist. getwd() returns the current working directory.
#  getwd(...) always returns lowercase. It prepends the relevant drive letter
#  with its colon; that's harmless in a chdir(), & useful in an open().
#
############################################################################
 
procedure getdrive()
   return &lcase[iand( Int86([33,16r1900,0,0,0,0,0,0,0])[2], 255 )+1] || ":"
end
 
procedure getwd(drive)
   A := GetSpace(64) | stop( "getwd(): GetSpace() failed." )
   dx := ("36r" || !\drive) - 9 | 0
   si := iand( A, 16rffff ); ds := ishift( A, -16 )
   cf := !Int86([33,16r4700,0,0,dx,si,0,0,ds]) % 2
   Peek( A , 64 ) ? path := tab(many(~'\0')) | ""
   FreeSpace(A)
   cf = 0 | fail
   return (   map(!\drive) || ":"   |   getdrive()   ) || "\\" || map(path)
end
-------------------------------<CUT HERE (duh)>------------------------------


From icon-group-sender  Mon Jan 31 13:01:24 1994
Received: by cheltenham.cs.arizona.edu; Mon, 31 Jan 1994 12:20:10 MST
From: CHUCK.GIBBONS@sprint.sprint.com
Date: 31 Jan 94 13:01:24-0500
P1-Message-Id: US*TELEMAIL;FGJE-5900-8176/27
To: icon-group@cs.arizona.edu
Subject: RE: document formatting 
Message-Id: 
        <"FGJE-5900-8176/27"*/PN=CHUCK.GIBBONS/O=US.SPRINT/ADMD=TELEMAIL/C=US/@sprint.com>
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


>   I am interested in a simple text formatting program, something which is a
> primitive form of nroff.  The input is a plain text file with special
> formatting instructions which govern the format of the lines following the
> command.  The most primitive set of commands might be something like

I've used ``cawf'' with good results on a PC under MSDOS.  Use archie to
find the UNIX version.

The PC version is available at the Simtel archives

PD1:<MSDOS.TXTUTL>CAWF2.ZIP    Formats docs intended for nroff -man, w/C src

The ``readme'' file follows.

------------ start 00README ------------------------
Cawf - nroff-like text formatter

Cawf is a C version of awf, Henry Spencer's Amazingly Workable (text)
Formatter.  (Awf is written in awk and appears in comp.sources.unix,
Volume 23, Issue 27.)  Cawf and awf provide a usable subset of raw nroff
capabilities and the styles of the man(7) and ms(7) macro sets.  One of
cawf's virtues is that it will run on PC clones under MS-DOS.  It is
also, like awf, totally independent of any licensed Unix source code.

This is the second distribution of cawf.  Changes include:

	o  Support has been added for a few more nroff commands -- .di, .tr,
	   and \k.

	o  Known bugs have been corrected, including bugs in the man.mac
	   and ms.mac files:

		Error in skipping to predicate of argument string comparison
		.if;

		Improved .ti handling, including the undocumented, oft-used
		absolute form;

		Error in output of .NH numbers;

		Handle expressions that aren't separated from the command by
		white space -- e. g., ".ti0";

		Compensate for printers that can't print a blank line,
		followed by a FF without printing a blank page.

	o  A limited printer formatting capability has been added via a small
	   change to cawf (the -fe option) and the addition of a post-filter,
	   fontfilt(1).

	o  Documentation has been added to describe the additions.


CONTENTS
--------

This distribution of cawf includes:

	*.c and *.h	source files to build cawf, bsfilt (bsfilt
			removes Backspaces from cawf output) and
			fontfilt (fontfilt provides more elaborate
			font and type style filtering)
	bsfilt.1	nroff source for the bsfilt manual page
	bsfilt.exe	bsfilt executable for MS-DOS
	bsfilt.man	the formatted (with cawf -fn) bsfilt manual page
	cawf.1		nroff source for the cawf manual page
	cawf.exe	cawf executable for MS-DOS
	cawf.mak	MS-DOS, Quick-C make file for cawf
	cawf.man	the formatted (with cawf -fn) cawf manual page
	common		initialization file for CAWFLIB library
	dumb.dev	device description file for CAWFLIB library
	fontfilt.1	nroff source for the fontfilt manual page
	fontfilt.cf	device and font configuration file for fontfilt(1)
	fontfilt.exe	fontfilt executable for MS-DOS
	fontfilt.mak	MS-DOS Quick-C make file for fontfilt
	fontfilt.man	the formatted (with cawf -fn) fontfilt manual page
	makefile	Unix-style make file
	man.mac		man(7) macros for CAWFLIB library
	ms.mac		ms(7) macros for CAWFLIB library


LIBRARY
-------

To use cawf, you must select a location for the CAWFLIB library files.  The
distributed cawf.exe expects to find them in c:\sys\lib\cawf, but you can
alter that with the CAWFLIB environment variable, or you can change the
CAWFLIB #define in cawf.h and rebuild cawf from the sources.

CAWFLIB contains a minimum of five files:

	common		common raw nroff commands to get cawf started
	dumb.dev	a basic set of definitions for a plain, "dumb"
			output device - e. g., the console display or
			a generic line printer
	fontfilt.cf	the device and font configuration file for
			fontfilt(1)
	man.mac		the man(7) macros
	ms.mac		the ms(7) macros

You may want to add your own macro files to the library.  Just name them
"m[your-name].mac", following the usual nroff naming convention for macro
files.

If you have fancy output devices, you may want to generate new *.dev files
for them.  Follow the format of dumb.dev.  To define support for a new
device, select a name prefix for it and create a file in CAWFLIB with the
name "<prefix>.dev".  To use the new device file, set the TERM environment
variable to <prefix> - e. g., when I test cawf on Unix, I need a vt100.dev,
because my TERM environment variable value is usually vt100.  (All I need
do is make vt100.dev a symbolic link to dumb.dev.)

Through its -fe option and the fontfilt(1) post-filter cawf provides
limited support for printer devices.  Cawf and fontfilt can be directed
to issue specific printer codes for bold and italic characters, and one
font can be selected for the entire document.  A device and font
configuration file is used for these selections, and the file can be
easily changed for individual printers.


SOURCES
-------

A generic Unix make file and a cawf.mak file for version 2.5 of Microsoft
MS-DOS Quick-C are included.  The Unix make file has some definitions that
help tune it to the local Unix environment:

	CAWFLIB		is a string that can be used in lieu of changes
			to cawf.h's CWFLIB #define.

	UNIX		switches the build environment to Unix.

	USG		adjusts for System V.  (UNIX must also be defined.)

	STDLIB		indicates that standard library function prototype
			definitions may be found in <stddef.h>.

			If STDLIB is not defined, the cawf sources try to
			define their own library function return values.

Cawf has been successfully built and tested in the UNIX context under 4.3BSD
Tahoe, Ultrix 2.2, SunOS 4.0, Dynix 3.0.12, ETAV (a SYSV 3.2 derivative) and
NeXTStep 1.0a/2.0.  If you try to build under a BSD derivative Unix that
doesn't have the SYSV string functions, strchr() and strrchr(), simply
redefine them to the index() and rindex() functions.


MS-DOS CONSIDERATIONS
---------------------

The MS-DOS version of cawf was created to run under the KornShell of the
Mortis Kern Systems Toolkit.  One ramification of using MKS' ksh is that it
supports the separate standard error and standard output streams.  Hence,
cawf blithely distributes its error messages to the standard error file, and
assumes the user's shell is capable of separating them from standard output.

If you don't use the MKS KornShell, but do want to separate the output
streams, you'll have to modify the cawf source code.  As a rudimentary aid,
cawf uses a separate stream pointer, Efs, for writing error output, but sets
it to stderr.  You can change that process to open a separate error file and
set Efs to point to it.


COPYRIGHTS AND CREDITS
----------------------

The sources are copyrighted, but freely distributable under usual terms -
retention of credit, etc.

Please acknowledge:

	AT&T for their public-domain release of getopt(3) at the 1985
	UNIFORUM conference

	Chet Creider and Ted Campbell for their contributions to font
	filtering

	Henry Spencer for awf and his regular expression package

Henry says about awf, "I can't believe I really wrote this."  Those are
my sentiments exactly about cawf, but I also understand that necessity
sometimes forces us to do what we would prefer to avoid.


BUGS AND ENHANCEMENTS
---------------------

I'll be glad to hear about bugs and needs for enhancements, but make no
promises about delivering fixes or upgrades in response.

Vic Abell <abe@mace.cc.purdue.edu>
4 June 1991
-------------- end 00README ------------------------
Charles J. Gibbons          chuck.gibbons@sprint.sprint.com
home: 913/649-8175          work: 816/854-3802
 ----
 Don't take life so serious, son --- it ain't no how permanent.



From icon-group-sender  Mon Jan 31 14:24:29 1994
Received: by cheltenham.cs.arizona.edu; Mon, 31 Jan 1994 18:09:43 MST
From: mitch@roll.csd.sgi.com (Tom Mitchell)
Message-Id: <9401312224.AA10106@roll.csd.sgi.com>
Subject: Re: document formatting
To: smith101@maroon.tc.umn.edu (Christopher P. Smith)
Date: Mon, 31 Jan 1994 14:24:29 -0800 (PST)
Cc: icon-group@cs.arizona.edu
In-Reply-To: <199401291928.AA11678@optima.CS.Arizona.EDU> from "Christopher P. Smith" at Jan 29, 94 01:28:45 pm
X-Mailer: ELM [version 2.4 PL22]
Content-Type: text
Content-Length: 1151      
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


Look into the troff/nroff replacement that was published
in Dr. Dobbs a while back (written in C).

The problem with 'simple' is that it is only simple for one
person.  If you begin to roll your own look at TeX first.

The scope rules are much richer.  Operation names are not
restricted to two characters.

Consider:

  \ljp{
  Where nesting, blocks and scope \emp{are} better defined.
  }

  Where nesting, blocks and scope _ARE_ better defined.


> 
> Hello,
> 
>   I am interested in a simple text formatting program, something which is a
> primitive form of nroff.  The input is a plain text file with special
> formatting instructions which govern the format of the lines following the
> command.  The most primitive set of commands might be something like
> 
> .lp (for left justified paragraphs)
> .tt (to indicate that the following text is to be unaltered "typed text")
> 
>   The program would read the input file and produce an output file with
> paragraphs formatted according to the embedded commands.
> 
> Does anyone know of such a program or Icon script which accomplishes this?
> 
> Thanks.
> 
> ________
> Chris...
> 
> 
> 
> 
> 





From icon-group-sender  Tue Feb  1 11:11:49 1994
Received: by cheltenham.cs.arizona.edu; Tue, 1 Feb 1994 08:59:02 MST
Date:    Tue, 1 Feb 1994 11:11:49 +0300 (EET)
From: LARSSON@ntcclu.ntc.nokia.com
Message-Id: <940201111149.23409ee7@ntcclu.ntc.nokia.com>
Subject: Document formatting and SGML
To: icon-group@cs.arizona.edu
X-Vmsmail-To: INET::"icon-group@cs.arizona.edu"
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Concerning simple text formatting, Tom Mitchell, mitch@roll.csd.sgi.com,
said: 

>The problem with 'simple' is that it is only simple for one
>person.  If you begin to roll your own look at TeX first.

While you are at it, you might want to take a look at SGML, the
Standard Generalized Markup Language. A good place to start is
via anonymous ftp to ifi.uio.no, subdirectory SGML. This way you can
keep formatting and contents separated.

Arne
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
Arne Larsson			Nokia Telecommunications
Translator			Transmission Systems, Customer Services
larsson@ntc02.tele.nokia.fi	P.O. Box 12, SF-02611 Espoo, Finland
larsson@ntcclu.ntc.nokia.com	Phone +358 0 5117476, Fax +358 0 51044287
Arne.Larsson@ntc.nokia.com
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*






From icon-group-sender  Wed Jan 26 03:20:57 1994
Received: by cheltenham.cs.arizona.edu; Wed, 2 Feb 1994 15:02:28 MST
Date: 26 Jan 94 03:20:57 GMT
From: cis.ohio-state.edu!magnus.acs.ohio-state.edu!usenet.ins.cwru.edu!howland.reston.ans.net!usc!news.isi.edu!paulp@ucbvax.Berkeley.EDU  (Paul Postel)
Organization: USC Information Sciences Institute
Subject: icon compiler compiler?
Message-Id: <1994Jan25.191114@isi.edu>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


I vaguely recall some discussion here about a yacc-like utility in
icon.  If you have such a beast or can point me to where it resides,
please reply via email.

Thanks,

Paul Postel

--------
Paul Postel
USC/ISI
paulp@isi.edu


From icon-group-sender  Sun Jan 30 18:38:28 1994
Received: by cheltenham.cs.arizona.edu; Fri, 4 Feb 1994 09:22:47 MST
Date: 30 Jan 94 18:38:28 GMT
From: noc.near.net!news.delphi.com!usenet@uunet.uu.net  (Will Mengarini)
Organization: Delphi (info@delphi.com email, 800-695-4005 voice)
Subject: MS-DOS filename wildcard expander
Message-Id: <19940130.13382812.mengarini@delphi.com>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Goerwitz>> [...] MS-DOS is dying [...]
 
In reference to OS rwars, bear in mind that for people who only have
toy computers, only toy OSs are realistic; but with serious hacking we
can do serious work on these tiny machines. I can't program in real C++
on my mighty 286/10; I think the compiles are too slow even on the 486/50
I use at work. On the 286, tho, Icon works fine.
 
The following patch fixed a bug that looks to me like it should have made
the procedure unusable; I can't understand how it could ever have worked
as originally coded. I'd be interested in hearing from anybody who was able
to successfully use it in its original form, with specifics about the
compilers used to build Icon & the DOS version under which it ran. It'd be
particularly interesting to hear an explanation of why it could have worked.
 
I suggest this replace the current version in BIPL.
 
############################################################################
#
#  File:     dosfiles.icn
#
#  Subject:  Procedures to get MS-DOS file names
#
#  Author:   Paul Abrahams             Patched by:    Will Mengarini
#
#  Date:     September 24, 1990        Date:          We 20 Oct 93
#
############################################################################
#
#  dosfiles(pfn) accepts a DOS filename possibly containing wildcards.
#  The filename can also include a drive letter and path.
#  If the filename ends in "\" or ":", "*.*" is appended.
#
#  The result sequence is a sequence of the filenames corresponding to pfn.
#
############################################################################
#
#  Requires: MS-DOS extensions
#
############################################################################
#
#  Patches:
#
#  We 20 Oct 93 Will Mengarini
#     I tried dosfiles() using Icon 8.8 under MS-DOS 5.0.
#     It always gave I/O Error 3, "Path not found".
#     I'd built IconX & IconT using Borland C++ 3.1.
#     -- The pointer arithmetic was wrong. My patches caused the
#        code to work; they're flagged with "pointer arithmetic wrong: ".
#       *The pointer arithmetic was coded based on a correct understanding
#        that a 16-bit-mode far pointer (which is 32 bits, 16 each for
#        segment & offset) resolves (in real mode) to a 20-bit physical
#        address, formed by shifting the 16-bit segment left 1 nybble then
#        taking the resulting 20-bit address & adding the 16-bit offset.
#        However, on an Intel 80x86 processor this calculation is done in
#        hardware; software should almost never do it. This is because
#        calculation of a physical address in protected mode is completely
#        different, with the segment being used as an index into a segment
#        descriptor table; & this addressing difference needs to be
#        transparent to most of the object code, so real-mode code can be
#        relatively-painlessly converted into protected-mode code. Therefore,
#        Intel 80x86 object code always passes around 16-bit-mode far
#        pointers as 32-bit values, with the segment & offset each in a
#        separate 16-bit register or memory "word" (which is what Intel calls
#        what Real Computer people call a "halfword"), so when software must
#        convert between a 16-bit-mode far pointer (which is 32 bits) & a
#        pair of 16-bit segment & offset values, all 32 bits are significant;
#        just plop the 16-bit segment into the upper half of the 32-bit area,
#        or extract it from there. BTW, don't use expressions like
#        integer_value / 32768 to get the upper 16 bits, since Icon will
#        convert that to floating-point arithmetic; use
#        ishift( integer_value, -16 ).
#     -- The GetSpace() wasn't checked for failure, which could cause
#        a null pointer reference.
#     -- The GetSpace() had no FreeSpace(), so dosfiles() leaked memory.
#     Possible enhancements:
#     -- dosfiles() uses whatever the DTA was on entry. Therefore, multiple
#        distinct searches can't be in progress simultaneously. Several times
#        in professional C/C++ work I've needed that, for searching & also
#        for file attribute retrieval (which is done using the same DOS
#        call), & I've had to kluge because of runtime libraries that didn't
#        support reentrant searching. It could be implemented by allocating
#        space for a new DTA & storing the search data in that. However,
#        every time the program suspends | returns, it must restore the
#        default DTA to what it was on entry, in case some *other* process is
#        using that DTA; then, on resumption, it must restore its own DTA
#        pointer for its next outcome. FreeSpace() can be called on the
#        allocated DTA after the final result has been produced.
#       *IPD199.Doc warns that Icon expects its own internal allocations of
#        memory blocks to result in contiguous memory, so it's not clear
#        whether keeping a GetSpace() allocation around during a nontrivial
#        amount of other processing is unsafe.
#     -- Each time DOS returns a path name, it also returns all the other
#        information about that file that DOS shows in a Dir or Attrib
#        command. Somehow this should be accessible to the caller. To
#        maintain backward compatibility, dosfiles() could take an optional
#        2nd arg consisting of a string of letters each of which would
#        correspond to one element of a returned list of data about the found
#        file; for example, dosfiles("*.*", "psdta") would generate, for each
#        match of *.*, a list consisting of the full path for the file, its
#        size, its creation date, its creation time, & its attribute byte. As
#        it does now, &null instead of a string would just mean "generate the
#        names", & the results would be strings, not single-element lists
#        containing strings (as would be produced by a second arg of "p").
#
############################################################################
 
procedure dosfiles(pfn)
   local asciiz, fnr, prefix, k, name
   local ds, dx, result, fnloc, string_block
 
# Get Disk Transfer Address; filename locn is 30 beyond that.
 
   result := Int86([16r21, 16r2f00] ||| list(7,0))
   # pointer arithmetic wrong: fnloc := 16 * result[8] + result[3]+ 30
   fnloc := ishift( result[8], 16 ) + result[3] + 30
 
# Get the generalized filename.
 
   fnr := reverse(pfn)
   k := upto("\\:", fnr) | *fnr + 1
   prefix := reverse(fnr[k:0])
   name := "" ~== reverse(fnr[1:k]) | "*.*"
 
# Get the first file in the sequence.
 
   asciiz := prefix || name || "\x00"
   Poke(string_block := GetSpace(*asciiz), asciiz) |
      stop( "dosfiles(): GetSpace() failed." )
   # pointer arithmetic wrong: ds := string_block / 16
   # pointer arithmetic wrong: dx := string_block % 16
   ds := ishift( string_block, -16 )
   dx := iand( string_block, 16rffff )
   result := Int86([16r21, 16r4e00, 0, 0, dx, 0, 0, 0, ds])
   FreeSpace(string_block)
   case result[2] of {
      0 : {}
      18 : fail
      default : stop("I/O Error ", result[2])
      }
   suspend prefix || extract_name(fnloc)
 
# Get the remaining files in the sequence.
 
   while Int86([16r21, 16r4f00, 0, 0, 0, 0, 0, 0, 0])[2] = 0 do
      suspend prefix || extract_name(fnloc)
end
 
procedure extract_name(fnloc)
   local asciiz
   asciiz := Peek(fnloc, 13)
   return asciiz[1:upto("\x00", asciiz)]
end


From icon-group-sender  Thu Jan 27 17:25:03 1994
Received: by cheltenham.cs.arizona.edu; Fri, 4 Feb 1994 12:46:31 MST
Date: 27 Jan 94 17:25:03 GMT
From: sinetnews!news.u-tokyo.ac.jp!wnoc-tyo-news!sh.wide!wnoc-snd-ss2!sakunami!u-aizu!nh1!nehaniv@speedy.wisc.edu  (Chrystopher Nehaniv)
Organization: University of Aizu, Fukushima, Japan
Subject: Is Icon Compatible with Other Character Sets
Message-Id: <2i8tdf$i60@nh1.u-aizu.ac.jp>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


 If I try to use icon with character sets that are
 8 bit or 2 byte (like Japanese kanji), will it
 choke?

 Chrystopher Nehaniv



-- 
 Chrystopher Nehaniv                    e-mail: nehaniv@u-aizu.ac.jp
 School of Computer Science & Engineering
 The University of Aizu                 
 Aizu-Wakamatsu City                    fax:   +81-242-37-2733


From icon-group-sender  Thu Jan 27 22:41:52 1994
Received: by cheltenham.cs.arizona.edu; Sat, 5 Feb 1994 21:42:37 MST
Date: 27 Jan 94 22:41:52 GMT
From: cis.ohio-state.edu!magnus.acs.ohio-state.edu!usenet.ins.cwru.edu!howland.reston.ans.net!cs.utexas.edu!swrinde!elroy.jpl.nasa.gov!newncar!uchinews!quads!goer@ucbvax.Berkeley.EDU  (Richard L. Goerwitz)
Organization: University of Chicago
Subject: Re: Is Icon Compatible with Other Character Sets
Message-Id: <1994Jan27.224152.23594@midway.uchicago.edu>
References: <2i8tdf$i60@nh1.u-aizu.ac.jp>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

nehaniv@u-aizu.ac.jp (Chrystopher Nehaniv) writes:
>
> If I try to use icon with character sets that are
> 8 bit or 2 byte (like Japanese kanji), will it
> choke?

8 bit is fine.  But I don't think that Icon knows about so-called long
characters.

You'd think that a language renowned for character and string proces-
sing would handle multinational and extended character encoding stand-
ards, but in fact I think someone would have to go through and really
think hard about what they would mean for csets.  The implementation
would have to be altered on some basic level for strings, too, since
these assume 8-bit characters.  Probably lotsa other stuff, too.

I dunno:  Does anyone working on implementation details know whether
there are any plans for alternate-width characters?

-- 

   -Richard L. Goerwitz              goer%midway@uchicago.bitnet
   goer@midway.uchicago.edu          rutgers!oddjob!ellis!goer


From icon-group-sender  Fri Jan 28 03:01:13 1994
Received: by cheltenham.cs.arizona.edu; Sat, 5 Feb 1994 21:43:26 MST
Date: 28 Jan 94 03:01:13 GMT
From: eng.ufl.edu!usenet.ufl.edu!sinkhole.unf.edu!shite@g.ms.uky.edu  (Stephen Hite)
Organization: University of North Florida, Jacksonville
Subject: Re: icon compiler compiler?
Message-Id: <1994Jan28.030113.10028@sinkhole.unf.edu>
References: <1994Jan25.191114@isi.edu>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: RO
Errors-To: icon-group-errors@cs.arizona.edu

In article <1994Jan25.191114@isi.edu> paulp@isi.edu (Paul Postel) writes:
>
>I vaguely recall some discussion here about a yacc-like utility in
>icon.  If you have such a beast or can point me to where it resides,
>please reply via email.
>
>Thanks,
>
>Paul Postel
>
>--------
>Paul Postel
>USC/ISI
>paulp@isi.edu

   It's called ibpag2 and it's located at ftp.cs.arizona.edu in
/icon/contrib/ibpag2.tar.Z.


----------------------
Steve Hite
shite@sinkhole.unf.edu


From icon-group-sender  Fri Jan 28 22:30:28 1994
Received: by cheltenham.cs.arizona.edu; Sun, 6 Feb 1994 20:13:59 MST
Date: 28 Jan 94 22:30:28 GMT
From: cis.ohio-state.edu!magnus.acs.ohio-state.edu!math.ohio-state.edu!howland.reston.ans.net!cs.utexas.edu!swrinde!elroy.jpl.nasa.gov!newncar!csn!server!usenet@ucbvax.Berkeley.EDU  (Cheyenne Wills)
Organization: Storage Technology Corp.
Subject: Re: Table look up questions?
Message-Id: <CKD2Iu.HI9@stortek.com>
References: <2ibt39$ojg@uop.cs.uop.edu>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

In <2ibt39$ojg@uop.cs.uop.edu>, wclark@uop.edu (William Clark) writes:
 ........
>
>   Example:  User inputs:  H W <enter>
>	     Output: Hello World
>
>   Where "H W" is a key in the table and "Hello World" is the other
>   half.
 .......
>
>   William R. Clark
>   University of the Pacific
>   wclark@thor.cs.uop.edu
>

   Icon has builting table support, basically dynamic arrays that
are "indexed" by a string (associtive arrays).  So for your example:

procedure main()
   wordtbl := table()
   wordtbl["H W"] := "Hello World"
   wordtbl["G D"] := "Good Day"
   wordtbl["G B"] := "Good By"

   write("User input:")
   line := read()
   line := trim(line)
   newline := wordtbl[line]
   write("Output: ",newline)
end

Of course things like making checking to see if the data was in
the table can be done by simply testing to see if "wordtbl[line]"
is &null.  Also the issue of upper/lower case and multiple blanks
hasn't been addressed.


+--------------------------------------+---------------------------------+
| +-----+			       | Cheyenne Wills 		 |
| |	|      "From here on up it is  | Storage Technology Corporation  |
| |  +--+--+	 downhill all the way" | 2270 South 88th St.             |
| |  |	|  |			       | Louisville, Co. 80028-4232	 |
| +--+--+  |   These are not the       |				 |
|    |	   |   opinions or views of    | Cheyenne_Wills@stortek.com	 |
|    +-----+   Storage Technology      | cheyenne@witsend.stortek.com	 |
+--------------------------------------+---------------------------------+


From icon-group-sender  Fri Feb 11 10:19:55 1994
Received: by cheltenham.cs.arizona.edu; Fri, 11 Feb 1994 12:08:42 MST
Date: Fri, 11 Feb 1994 10:19:55 -0600 (CST)
From: Chris Tenaglia - 257-8765 <TENAGLIA@MIS.MCW.EDU>
Subject: keynames
To: icon-group@cs.arizona.edu
Message-Id: <01H8R7KUZDDE8WXRXT@mis.mcw.edu>
Organization: Medical College of Wisconsin (Milwaukee, WI)
X-Vms-To: IN%"icon-group@cs.arizona.edu"
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; CHARSET=US-ASCII
Content-Transfer-Encoding: 7BIT
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


I'm not Chinese, but I heard Chinese NewYear was this week. I don't
have a game to post to commemorate the holiday, but I do have something
that might turn out to be useful. I call it keyname. It's layered on
getch() and is easily modified. This program/routine was written for
PC, but it could probably be modified for other OSes too.

I thought it would be nice to get a name from a key strike rather than
just the raw control character(s). Under VMS BASIC the inkey$ function
actually returns the name of the key. Ascii characters for printables,
and names like F8 or PF3 or KP5. On the PC I found that there is no
distinction between numeric keypad 5 and typewriter 5. There is no
disctinction between edit keypad PgDn and numeric keypad PgDn, at least
as far as Icon getch() is concerned. In fact F11 and keypad 5 aren't
even detected. But still this routine can make the working keys return
names that can make a program more readible and easy to maintain. Enjoy!

Chris Tenaglia (System Manager) |  "The past explained,     
Medical College of Wisconsin    |   the future fortold, 
8701 W. Watertown Plank Rd.     |   the present largely appologized for."
Milwaukee, WI 53226             |   Organon to The Doctor
(414)257-8765                   |     
tenaglia@mis.mcw.edu

procedure main()                 # this main() tests the routine below
  repeat
    {
    k := getch()
    if k == "#" then break               # permit clean escape
    if k == "\000" then k ||:= getch()
    write(image(k)," = ",keyname(k))
    }
  end

procedure keyname(str)
  static  keys
  initial {
          keys := table("ANY")
          keys["\000;"] := "F1"
          keys["\000<"] := "F2"
          keys["\000="] := "F3"
          keys["\000>"] := "F4"
          keys["\000?"] := "F5"
          keys["\000@"] := "F6"
          keys["\000A"] := "F7"
          keys["\000B"] := "F8"
          keys["\000C"] := "F9"
          keys["\000D"] := "F10"
          keys["\000\373"] := "F12"

          keys["\000H"] := "UPARROW"
          keys["\000P"] := "DOWNARROW"
          keys["\000M"] := "RIGHTARROW"
          keys["\000K"] := "LEFTARROW"
          keys["\000I"] := "PAGEUP"
          keys["\000Q"] := "PAGEDOWN"
          keys["\000G"] := "HOME"
          keys["\000O"] := "END"
          keys["\000R"] := "INSERT"
          keys["\000S"] := "DELETE"
          
          keys["\e"]    := "ESCAPE"
          keys["\001"]  := "CTRL_A"
          keys["\002"]  := "CTRL_B"
          keys["\003"]  := "CTRL_C"
          keys["\004"]  := "CTRL_D"
          keys["\005"]  := "CTRL_E"
          keys["\006"]  := "CTRL_F"
          keys["\007"]  := "BELL"
          keys["\010"]  := "BACKSPACE"
          keys["\011"]  := "TAB"
          keys["\012"]  := "LINEFEED"
          keys["\013"]  := "CTRL_K"
          keys["\014"]  := "FORMFEED"
          keys["\015"]  := "RETURN"
          keys["\016"]  := "CTRL_N"
          keys["\017"]  := "CTRL_O"
          keys["\020"]  := "CTRL_P"
          keys["\021"]  := "CTRL_Q"
          keys["\022"]  := "CTRL_R"
          keys["\023"]  := "CTRL_S"
          keys["\024"]  := "CTRL_T"
          keys["\025"]  := "CTRL_U"
          keys["\026"]  := "CTRL_V"
          keys["\027"]  := "CTRL_W"
          keys["\030"]  := "CTRL_X"
          keys["\031"]  := "CTRL_Y"
          keys["\032"]  := "CTRL_Z"
          }
  return keys[str]
  end



From icon-group-sender  Sat Feb 12 14:29:53 1994
Received: by cheltenham.cs.arizona.edu; Sat, 12 Feb 1994 12:05:04 MST
Date: 12 Feb 94 14:29:53 GMT
From: swampler@noao.edu
Organization: National Optical Astronomy Observatories, Tucson AZ
Subject: Re: wishing for an Icon-like embedded language
Message-Id: <1994Feb12.142953.9522@noao.edu>
References: <CL0x83.BAr@walter.bellcore.com>, <1994Feb12.032054.26100@cs.rit.edu>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

In article <1994Feb12.032054.26100@cs.rit.edu>, nmw1638@cs.rit.edu (Nicolas M Williams) writes:
|> In article <CL0x83.BAr@walter.bellcore.com> norman@flash.bellcore.com (Norman Ramsey) writes:
|> >
|> >that the world of C programs is not ready for an extension language
|> >that requires a garbage collector.  Nonetheless, I would love to know
|> >of anyone out there has thought about using Icon as an extension
|> >language, or about how to identify a subset or design an extension
|> >language with the ``flavor'' of Icon.
|> 
|> I suspect that given the structure of the language, a garbage
|> collector for Icon could be "automatic", meaning that Icon keeps track
|> of the number of references to each object, and collects them as their
|> reference number drops to zero.
|> 
|> Or am I hopelessly wrong on this?
|> 
Well, Icon already has automatic GC, though not through reference counts (because
of self-referential structures).  Instead Icon finds all useful data and discards
the rest.

One reason why Icon hasn't been embedded is because of the sophisticated syntax -
parsers for Icon tend to be quite large, compared to those for languages with
(I know I'm going to regret this...) simple-minded syntax.  Of course, in this
day of bloated programs, maybe no one would notice the increase caused by putting
an Icon parser into an application!  (Hmmm, maybe someone should write an 'Icon
Server' that can handle parsing and interpreting from multiple Icon clients...)

--
Steve Wampler
swampler@noao.edu
Gemini Project (under AURA)


From icon-group-sender  Mon Feb 14 17:58:36 1994
Received: by cheltenham.cs.arizona.edu; Mon, 14 Feb 1994 18:06:17 MST
From: "Art Eschenlauer" <eschen@molbio.cbs.umn.edu>
Message-Id: <9402142358.AA25724@molbio.cbs.umn.edu>
Subject: Want info about next icon for mac
To: icon-group@cs.arizona.edu
Date: Mon, 14 Feb 94 17:58:36 CDT
X-Mailer: ELM [version 2.3test PL26]
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

So, I read the icon faq one day and learned that someone is working on a
more graphically-oriented interface for a mac implementation for it. If this
is true, who is, what are they up to, etc.? I already know about ProIcon,
but what is this new project? Or did I misunderstand?
-Art (eschen@molbio.cbs.umn.edu)
PS I have shelved a project to use icon to write text filters that would
use the clipboard for stdin and stdout, but I hope some day to get back
to it. FYI. Not real graphical interface, but it would be something that
I could easily use with any program using text, eg, word processors, molecular
biology packages, etc..



From icon-group-sender  Mon Feb 14 23:13:19 1994
Received: by cheltenham.cs.arizona.edu; Tue, 15 Feb 1994 07:30:25 MST
Date: Mon, 14 Feb 94 23:13:19 CST
From: jeffery@ringer.cs.utsa.edu (Clinton L. Jeffery)
Message-Id: <9402150513.AA05549@ringer.cs.utsa.edu.sunset>
To: eschen@molbio.cbs.umn.edu
Cc: icon-group@cs.arizona.edu
In-Reply-To: "Art Eschenlauer"'s message of Mon, 14 Feb 94 17:58:36 CDT <9402142358.AA25724@molbio.cbs.umn.edu>
Subject: Want info about next icon for mac
Content-Length: 798
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


At the University of Texas at San Antonio, we are working on a new
Macintosh Icon that is to include the graphics and user interface
functions that are already available for Icon under X Window and OS/2.
We also have a Microsoft Windows/NT effort underway.  The Mac project
will be based on the next version of Icon still in development, and is
being built using Think C on a Mac LC 475 running System 7.1.

Porting Icon's graphics facilities to the Mac will be non-trivial, and
its too early to tell how the project will turn out.  Funded development
is taking place between now and the end of this summer, so by the end
of summer we should be able to report the results to the Icon group.

Clint Jeffery
cjeffery@cs.arizona.edu, jeffery@ringer.cs.utsa.edu
The University of Texas at San Antonio


From icon-group-sender  Sat Feb 12 18:59:50 1994
Received: by cheltenham.cs.arizona.edu; Wed, 16 Feb 1994 12:36:31 MST
Date: 12 Feb 94 18:59:50 GMT
From: dog.ee.lbl.gov!overload.lbl.gov!agate!usenet.ins.cwru.edu!wariat.org!kf8nh!bsa@ucbvax.Berkeley.EDU  (Brandon S. Allbery)
Organization: Brandon's Linux box and AmPR node, Mentor, OH
Subject: Re: wishing for an Icon-like embedded language
Message-Id: <1994Feb12.185950.447@kf8nh.wariat.org>
References: <CL0x83.BAr@walter.bellcore.com>, <1994Feb12.032054.26100@cs.rit.edu>, <1994Feb12.142953.9522@noao.edu>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

In article <1994Feb12.142953.9522@noao.edu>, swampler@noao.edu () says:
+---------------
| In article <1994Feb12.032054.26100@cs.rit.edu>, nmw1638@cs.rit.edu (Nicolas M Williams) writes:
| |> In article <CL0x83.BAr@walter.bellcore.com> norman@flash.bellcore.com (Norman Ramsey) writes:
| |> >of anyone out there has thought about using Icon as an extension
| |> >language, or about how to identify a subset or design an extension
| |> >language with the ``flavor'' of Icon.
| |> 
| One reason why Icon hasn't been embedded is because of the sophisticated syntax -
+------------->8

Ahem.  Check out

#define IconCalling

in config/.../define.h.  It's normally left turned off according to the
documentation, because it incurs overhead in order to support recursive calls
from C to Icon and vice versa.  ---It also warns that this requires linking
the entire Icon interpreter and runtime system into the C program, so to that
extent you are correct.  (Heavyweight Tcl, anyone?  :-)

| an Icon parser into an application!  (Hmmm, maybe someone should write an 'Icon
| Server' that can handle parsing and interpreting from multiple Icon clients...)
+------------->8

Been there, done that... except it was for Prolog, not Icon.  I could probably
dig it up and change it to an Icon server if I had the time and the
inclination.

The biggest problem here is maintaining separate execution contexts for all
clients.  For the Prolog one I didn't need to; it was essentially a "Prolog
database server" which arbitrated access to a common rulebase.  Had I needed a
general *language* server mechanism it would have been more difficult.

++Brandon
-- 
Brandon S. Allbery	   kf8nh@kf8nh.ampr.org		 bsa@kf8nh.wariat.org
"MSDOS didn't get as bad as it is overnight -- it took over ten years
of careful development."  ---dmeggins@aix1.uottawa.ca


From icon-group-sender  Wed Feb 16 14:23:37 1994
Received: by cheltenham.cs.arizona.edu; Wed, 16 Feb 1994 15:39:16 MST
Date: Wed, 16 Feb 94 14:23:37 CST
From: jeffery@ringer.cs.utsa.edu (Clinton L. Jeffery)
Message-Id: <9402162023.AA10013@ringer.cs.utsa.edu.sunset>
To: kf8nh@kf8nh.ampr.org
Cc: icon-group@cs.arizona.edu
In-Reply-To: (Brandon S. Allbery's message of 12 Feb 94 18:59:50 GMT <1994Feb12.185950.447@kf8nh.wariat.org>
Subject: wishing for an Icon-like embedded language
Content-Length: 629
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


Brandon Allbery writes:
> The biggest problem here is maintaining separate execution contexts for all
> clients.  For the Prolog one I didn't need to; it was essentially a "Prolog
> database server" which arbitrated access to a common rulebase.

Well, the Icon interpreter has code (under yet another #ifdef that is turned
off by default) that supports separate execution contexts.  In fact, if we
could just settle on a few network interface functions, y'all could almost
write this heyah suhver y'all are talkin about in Ahcon.

Clint Jeffery
jeffery@ringer.cs.utsa.edu
Deep in the heart of Texas, no one can hear you scream.


From icon-group-sender  Sat Feb  5 00:23:26 1994
Received: by cheltenham.cs.arizona.edu; Thu, 17 Feb 1994 09:17:06 MST
Date: 5 Feb 94 00:23:26 GMT
From: cis.ohio-state.edu!pacific.mps.ohio-state.edu!math.ohio-state.edu!howland.reston.ans.net!pipex!uknet!festival!eddie@ucbvax.Berkeley.EDU  (Eddie Corns)
Organization: Edinburgh University
Subject: RadioButtons in WIT
Message-Id: <CKq6F4.H3s@festival.ed.ac.uk>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Hi, I've just been playing about with WIT via XIB.  I've constructed a simple
program with a RadioButton.  What I want to do is set the value before letting
the user get at it.  So I do
  VSet (radio_button1, type_v) | write ("oops")
and it always fails.  Having a look at vradio.icn I think someone forgot to
finish the set code because it doesn't seem to call the draw routine or the
callback and falls off the end (hence the failure).  As far as I can see the
sources to WIT are not stored seperately on arizona and I simply don't have
the space to hold the entire distribution without overwriting the current one.
So does anyone know if I'm talking nonsense and simply not using it right or
if it's been fixed?  I have a timestamp of Apr 5 on my source but I can't
remember if that's when I unpacked it or if it came like that.  If it's not
been fixed I will have a go but I have a sneaky suspicion there are other bits
of that file that are also incomplete.

Other than this little quirk the two systems look pretty neat, could do with a
spot more descriptive text though.

Thanks,
Eddie


From icon-group-sender  Sat Feb  5 00:23:26 1994
Received: by cheltenham.cs.arizona.edu; Thu, 17 Feb 1994 09:14:56 MST
Date: 5 Feb 94 00:23:26 GMT
From: cis.ohio-state.edu!pacific.mps.ohio-state.edu!math.ohio-state.edu!howland.reston.ans.net!pipex!uknet!festival!eddie@ucbvax.Berkeley.EDU  (Eddie Corns)
Organization: Edinburgh University
Subject: RadioButtons in WIT
Message-Id: <CKq6F4.H3s@festival.ed.ac.uk>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Hi, I've just been playing about with WIT via XIB.  I've constructed a simple
program with a RadioButton.  What I want to do is set the value before letting
the user get at it.  So I do
  VSet (radio_button1, type_v) | write ("oops")
and it always fails.  Having a look at vradio.icn I think someone forgot to
finish the set code because it doesn't seem to call the draw routine or the
callback and falls off the end (hence the failure).  As far as I can see the
sources to WIT are not stored seperately on arizona and I simply don't have
the space to hold the entire distribution without overwriting the current one.
So does anyone know if I'm talking nonsense and simply not using it right or
if it's been fixed?  I have a timestamp of Apr 5 on my source but I can't
remember if that's when I unpacked it or if it came like that.  If it's not
been fixed I will have a go but I have a sneaky suspicion there are other bits
of that file that are also incomplete.

Other than this little quirk the two systems look pretty neat, could do with a
spot more descriptive text though.

Thanks,
Eddie


From icon-group-sender  Sat Feb 12 18:01:33 1994
Received: by cheltenham.cs.arizona.edu; Thu, 17 Feb 1994 13:32:38 MST
Date: 12 Feb 94 18:01:33 GMT
From: dog.ee.lbl.gov!agate!howland.reston.ans.net!vixen.cso.uiuc.edu!news.eecs.uic.edu!uicvm.uic.edu!wheaton.wheaton.edu!not-for-mail@ucbvax.Berkeley.EDU  (Glauber Ribeiro)
Organization: The Bossa Nova University
Subject: Re: Icon functions reference card?
Message-Id: <2jj5ht$qvn@david.wheaton.edu>
References: <forb0004.97.000937A1@gold.tc.umn.edu>, <2jg1pfINN9vm@uwm.edu>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

In article <2jg1pfINN9vm@uwm.edu>, Alan D Corre <corre@csd4.csd.uwm.edu> wrote:
& In article <forb0004.97.000937A1@gold.tc.umn.edu> forb0004@gold.tc.umn.edu (Eric J. Forbis) writes:
& >Is there a "quick function reference card" for Icon?
&
& ProIcon for the Mac has an online help function that acts as a programming
& card. Might be nice if other versions did too.


I believe there is an "online help" program in the icon archives.
I'm sorry i don't remember the file name, but should not be
impossible to find. Now if i could only remember the name of the
archive site... ftp.cica.indiana.edu, maybe? Whatever is the
official Icon site also has a large library of Icon stuff.

         Glauber


--
glauber ribeiro
glauber@david.wheaton.edu
-------------------------
practice random kindness and senseless acts of beauty


From icon-group-sender  Thu Feb 17 14:33:53 1994
Received: by cheltenham.cs.arizona.edu; Thu, 17 Feb 1994 15:08:09 MST
Date: Thu, 17 Feb 1994 14:33:53 MST
From: "Cliff Hathaway" <cliff>
Message-Id: <199402172133.AA25134@cheltenham.cs.arizona.edu>
To: icon-group@cs.arizona.edu
Subject: Re: Icon functions reference card
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


The online help program is "ihelp.icn", and is part of the Icon program
library, available from ftp.cs.arizona.edu, in the /icon/library directory.

A description of the Icon program library is available in the /icon/doc
directory, in both text and compressed Postscript form: ipd211.doc and
ipd211.ps.Z, respectively.  This document has a listing of the contents
of the program library, with a brief description of each entry.

It should be noted that the most recent versions of all Icon material 
will be found at this ftp site.  I'm always surprised when I get a call
saying "I just downloaded Icon version 6.2 from site xxx and I was
wondering ...".


    Cliff Hathaway, Icon Project
    Dept. of Computer Science (602)621-4291
    University of Arizona     cliff@cs.arizona.edu 	        (internet) 
    Tucson, Ariz. 85721	      {cmcl2,noao,uunet}!arizona!cliff	(uucp)




From icon-group-sender  Thu Feb 17 20:43:27 1994
Received: by cheltenham.cs.arizona.edu; Thu, 17 Feb 1994 18:01:19 MST
Date: 17 Feb 94 20:43:27 GMT
From: agate!howland.reston.ans.net!math.ohio-state.edu!cs.utexas.edu!swrinde!sgiblab!pacbell.com!att-out!walter!flaubert!norman@ucbvax.Berkeley.EDU  (Norman Ramsey)
Organization: Bellcore
Subject: Icon is not *that* much bigger than tcl
Message-Id: <CLDywG.G9J@walter.bellcore.com>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


I looked that the numbers, and I may actually try using Icon as an
embedded language.  Here's the size of executable and library versions
of the tcl stuff:
 -rwxr-xr-x  1 norman     212992 Jan 31 15:16 /usr/public/bin/tclsh
 -rw-r--r--  1 norman     220690 Jan 31 15:01 /usr/public/pkg/tcl/lib/libtcl.a
And for Icon we have
 -rwxr-xr-x  1 norman     327680 Sep  8 22:36 /usr/public/pkg/icon/lib/iconx
 -rw-r--r--  1 norman     390918 Sep  8 22:34 /usr/public/pkg/icon/lib/rt.a
Of course, this is a little unfair since Icon is not usable without a
separate translation step, whereas that's included in the size of the
tcl goo.  But icont is not that big either:
 -rwxr-xr-x  1 norman     122880 Sep  8 22:36 /usr/public/pkg/icon/bin/icont
The fast turnaround of tcl is one of its advantages, but the Icon
experiment might be worth trying.  If I learn anything interesting,
I'll report it here...
--
Norman Ramsey
norman@bellcore.com


From icon-group-sender  Thu Feb 17 23:03:55 1994
Received: by cheltenham.cs.arizona.edu; Fri, 18 Feb 1994 10:10:32 MST
Date: 17 Feb 94 23:03:55 GMT
From: psinntp!newstand.syr.edu!npac.syr.edu!tolson@uunet.uu.net  (Todd Olson)
Organization: NPAC, Syracuse University - Syracuse, New York
Subject: Re: wishing for an Icon-like embedded language
Message-Id: <tolson.761526235@npac.syr.edu>
References: <CL0x83.BAr@walter.bellcore.com>, <1994Feb12.032054.26100@cs.rit.edu>, <1994Feb12.142953.9522@noao.edu>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

In <1994Feb12.142953.9522@noao.edu> swampler@noao.edu () writes:

>an Icon parser into an application!  (Hmmm, maybe someone should write an 'Icon
>Server' that can handle parsing and interpreting from multiple Icon clients...)

>--
>Steve Wampler
>swampler@noao.edu
>Gemini Project (under AURA)

Actually, on Macs there is a ready a server of sort in the idea of 
AppleScript.  I have been having idle thoughts of figuring out how to make
Icon be a "script" that works with the AppleScript system.  Then
I could control my Mac via Icon.

Todd Olson
tolson@npac.syr.edu


From icon-group-sender  Fri Feb 18 10:12:03 1994
Received: by cheltenham.cs.arizona.edu; Fri, 18 Feb 1994 10:14:10 MST
Date: Fri, 18 Feb 1994 10:12:03 +0700
From: gmt (Gregg Townsend)
Message-Id: <9402181712.AA06080@owl.cs.arizona.edu>
To: icon-group
Subject: Re: WIT questions
Content-Length: 666
Status: RO
Errors-To: icon-group-errors@cs.arizona.edu

I can confirm that there are problems with VSet, and not just for radio
buttons.  I will investigate a fix, but due to lots of other changes I
won't be able to supply anything until the next release of the library.
 
As for the question about "cheating" (by directly accessing the .data
field of a text vidget), it's probably bad form; but I don't know another
way to accomplish that, so I guess it's between you and your conscience.
I don't know of any pending changes that are likely to invalidate it.
 
    Gregg Townsend / Computer Science Dept / Univ of Arizona / Tucson, AZ 85721
    +1 602 621 4325     gmt@cs.arizona.edu     110 57 16 W / 32 13 45 N / +758m


From icon-group-sender  Fri Feb 18 09:03:47 1994
Received: by cheltenham.cs.arizona.edu; Fri, 18 Feb 1994 10:18:05 MST
Via: uk.ac.edinburgh.festival; Fri, 18 Feb 1994 09:03:53 +0000
Date: 18 Feb 94 09:03:47 GMT
From: R J Hare <rjhare@festival.ed.ac.uk>
Subject: Icon help prgram ihelp
To: icon-group@cs.arizona.edu
Organisation: Edinburgh University Computing Service
Message-Id: <9402180903.aa06614@uk.ac.ed.festival>
Status: RO
Errors-To: icon-group-errors@cs.arizona.edu

Further to the recent post about this program. This program is one of the
well-hidden highlights of the IPL. I find it very useful when I am separated
from my Icon dcumentation (which happens increasingly often these days). The
version of the data file I have is for Icon version 8.7.

Does anyone perhaps have an up to date version of the file (ie: for Version
8.10) which includes help information on the X-Icon graphics functions? This
would be extremely useful.

Roger Hare.


From icon-group-sender  Fri Feb 18 13:23:40 1994
Received: by cheltenham.cs.arizona.edu; Fri, 18 Feb 1994 15:01:21 MST
Date: Fri, 18 Feb 1994 13:23:40 -0600 (CST)
From: Ronan_Collis <Ronan_Collis@mbnet.mb.ca>
Subject: Re: Idea\Wish Lists
To: Ronan_Collis <Ronan_Collis@access.mbnet.mb.ca>
Cc: icon-group@cs.arizona.edu, icon-group-request@cs.arizona.edu,
        Ronan_Collis@mbnet.mb.ca
In-Reply-To: <Pine.3.05.9402181337.A16971-9100000@access.mbnet.mb.ca>
Message-Id: <Pine.3.05.9402181335.A16971-9100000@access.mbnet.mb.ca>
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; charset=US-ASCII
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

On Fri, 18 Feb 1994, Ronan_Collis wrote:

> Please advise if anyone is using Icon, or has used Icon to construct an
> intelligent data base for lexical/terminological data for
> computer-assisted translation. Two aspects of this would be text scanning
> for contexts of usage and switchable fixed phrase substitution. There is
> much need of this for less-used languages in developing areas and
> countries but nobody wants to reinvent the wheel.DRC
> 
> 






From icon-group-sender  Fri Feb 18 20:35:39 1994
Received: by cheltenham.cs.arizona.edu; Sun, 20 Feb 1994 19:15:38 MST
Date: Fri, 18 Feb 1994 20:35:39 -0600 (CST)
From: Ronan_Collis <Ronan_Collis@mbnet.mb.ca>
Subject: 
To: icon-group@cs.arizona.edu
Cc: Ronan_Collis@mbnet.mb.ca
Message-Id: <Pine.3.05.9402182039.A23957-8100000@access.mbnet.mb.ca>
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; charset=US-ASCII
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Would like to contact others in the group, if there are any, who have used
icon to program a lexical/terminological database to assist translaters. RC




From icon-group-sender  Sun Feb 20 18:29:49 1994
Received: by cheltenham.cs.arizona.edu; Sun, 20 Feb 1994 19:27:52 MST
From: pab (Peter A. Bigot)
Message-Id: <9402210129.AA26505@omnia.cs.arizona.edu>
Subject: generating both [lr]values of records
To: icon-group
Date: Sun, 20 Feb 1994 18:29:49 -0700 (MST)
X-Mailer: ELM [version 2.4 PL23]
Mime-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Content-Length: 1807      
Status: RO
Errors-To: icon-group-errors@cs.arizona.edu

I have a large number of different records (representing syntactic terms, if
it matters), which form trees, and I want to replace subtrees with a value
which is based on the current subtree (in effect, implement variable
substitution: t [expr/X]).

I don't care about the old value of the records, so an update-in-place would
be nice.  I also don't want to enumerate the different types of records, and
handle them with separate cases.  So, using the ! generator on the record,
and the neat trick that it generates lvalues, looks like the way to go.
I.e., "every !rec := expr".  But: how can I use the generated element (of
!rec) as part of the rhs of the assignment?

It seems to me I've seen this before, but can't recall the necessary
incantation.

Here are a few attempts, one of which works---but I'd like a better way.

record A (a1, a2, a3)           # some arbitrary record

procedure main ()
    ar := A (1, 2, 3)

    # Attempt one:  naively assume we can preserve the lvalue
    every (t := !ar) do
        t := (.t+1)
    writes (image (ar), " -- ")
    every writes (! ar, " ")
    write ()

    # Attempt two: maybe we can fool it
    every (t := !ar) := (t+1)
    writes (image (ar), " -- ")
    every writes (! ar, " ")
    write ()

    # Brute force: this works, but it's gotta be inefficient in both
    # time and space
    nr := list()
    every put (nr, !ar + 1)
    ar := type(ar) ! nr # -10 points for using arcane features....
    writes (image (ar), " -- ")
    every writes (! ar, " ")
    write ()

    # What I'd like:
    # every !ar := (&currentgenelt)+1
    # but for some reason that doesn't work....

    end # main

Is there a better way?

-- 
                     Peter A. Bigot -- pab@CS.Arizona.EDU
          Dept. of Computer Science, University of Arizona, Tucson AZ


From icon-group-sender  Mon Feb 21 00:30:21 1994
Received: by cheltenham.cs.arizona.edu; Mon, 21 Feb 1994 09:17:08 MST
Return-Path: <jeffery@ringer.cs.utsa.edu>
Date: Mon, 21 Feb 94 00:30:21 CST
From: jeffery@ringer.cs.utsa.edu (Clinton L. Jeffery)
Message-Id: <9402210630.AA27481@ringer.cs.utsa.edu.sunset>
To: pab@cs.arizona.edu
Cc: icon-group@cs.arizona.edu
In-Reply-To: Peter A. Bigot's message of Sun, 20 Feb 1994 18:29:49 -0700 (MST) <9402210129.AA26505@omnia.cs.arizona.edu>
Subject: generating both [lr]values of records
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

    Peter Bigot writes about record lvalues:
    # What I'd like:
    # every !ar := (&currentgenelt)+1
    # but for some reason that doesn't work....

Peter, !r does generate assignable references to record r's fields, but its
easy to inadvertently get yourself in trouble in the surrounding expression
(the usual mistake is to try to assign each field different results from a
generator; you need a co-expression for parallel evaluation of generators).
Anyhow, check out the following program, which assigns new values to a
record's fields (it writes out 1, 2, 3, and 4 on separate lines).

record r(a,b,c,d)

procedure main()
   r1 := r()
   every !r1 := foobar()
   every write(!r1)
end

procedure foobar()
   static i
   initial i := 0
   return i +:= 1
end

Clint Jeffery
cjeffery@cs.arizona.edu, jeffery@ringer.cs.utsa.edu
The University of Texas at San Antonio



From icon-group-sender  Mon Feb 21 06:28:54 1994
From: icon-group-sender
Message-Id: <199402211618.AA08254@cheltenham.cs.arizona.edu>
Received: by cheltenham.cs.arizona.edu; Mon, 21 Feb 1994 09:18:41 MST
Subject: Re: generating both [lr]values of records
To: jeffery@ringer.cs.utsa.edu (Clinton L. Jeffery)
Date: Mon, 21 Feb 1994 06:28:54 -0700 (MST)
Cc: icon-group
In-Reply-To: <9402210630.AA27481@ringer.cs.utsa.edu.sunset> from "Clinton L. Jeffery" at Feb 21, 94 00:30:21 am
X-Mailer: ELM [version 2.4 PL23]
Mime-Version: 1.0
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

>     Peter Bigot writes about record lvalues:
>     # What I'd like:
>     # every !ar := (&currentgenelt)+1
>     # but for some reason that doesn't work....
> 
> Peter, !r does generate assignable references to record r's fields, but its
> easy to inadvertently get yourself in trouble in the surrounding expression
> (the usual mistake is to try to assign each field different results from a
> generator; you need a co-expression for parallel evaluation of generators).

Hmn; yeah, I suppose I could do:
lval := create !ar
rval := create !ar
while (@lval := @rval+1)

That does what I want.  Or even:
rval := create !ar
every !ar := (@rval+1)

Which is getting back to the succinctness and incomprehensibility I like to
have in my Icon programs.  Isn't that going to be pretty expensive in
time/space too, though?  How does it compare to constructing a list of new
fields and using string evaluation on the record constructor?  I suppose I
could do timing tests, but I'd rather appeal to intuition (even if it isn't
mine).

This is an extremely small but potentially high-frequency part of what's
looking to be an ugly program that will probably be _very_ slow; but it's a
research tool, what do you want? ;-)

> Anyhow, check out the following program, which assigns new values to a
> record's fields (it writes out 1, 2, 3, and 4 on separate lines).

Thanks; unfortunately, that doesn't seem to show how you can use the current
value of the field being assigned to construct the new value.  In the actual
context, I can't reconstruct the current value from base principles.

It'd be "cool"(tm) if one could use a keyword or some other feature to
get multiple references to the currently-generated element within an
expression, although this probably has semantic overtones I'd rather not
think about at this hour of the morning.

Peter

-- 
                     Peter A. Bigot -- pab@CS.Arizona.EDU
          Dept. of Computer Science, University of Arizona, Tucson AZ


From icon-group-sender  Mon Feb 21 10:33:34 1994
Received: by cheltenham.cs.arizona.edu; Mon, 21 Feb 1994 10:03:56 MST
Date: Mon, 21 Feb 94 10:33:34 CST
From: jeffery@ringer.cs.utsa.edu (Clinton L. Jeffery)
Message-Id: <9402211633.AA08487@ringer.cs.utsa.edu.sunset>
To: pab@cs.arizona.edu
Cc: icon-group@cs.arizona.edu
In-Reply-To: Peter A. Bigot's message of Mon, 21 Feb 1994 06:28:55 -0700 (MST) <9402211328.AA27411@omnia.cs.arizona.edu>
Subject: generating both [lr]values of records
Content-Length: 448
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Co-expressions use up a fair amount of space, but they are pretty
fast.  I agree they are more than is needed here.  I am still not
sure why you aren't saying

every !ar +:= 1 # if all you really need is an augmented assignment
or
every i := 1 to *ar do ar[i] := arbitrary_computation(ar[i])

Cool, huh?  Icon records are really quite handy.

Clint Jeffery
cjeffery@cs.arizona.edu, jeffery@ringer.cs.utsa.edu
The University of Texas at San Antonio


From icon-group-sender  Tue Feb 22 17:43:32 1994
Received: by cheltenham.cs.arizona.edu; Tue, 22 Feb 1994 13:45:06 MST
Date: 22 Feb 94 17:43:32 GMT
From: dog.ee.lbl.gov!ihnp4.ucsd.edu!library.ucla.edu!csulb.edu!nic-nac.CSU.net!news.Cerritos.edu!news.Arizona.EDU!math.arizona.edu!CS.Arizona.EDU!not-for-mail@ucbvax.Berkeley.EDU  (Gregg Townsend)
Organization: University of Arizona CS Department, Tucson AZ
Subject: Re: interaction of deletion with enumeration (again)
Message-Id: <2kdg84$ab4@owl.CS.Arizona.EDU>
References: <CLDoGK.AKC@walter.bellcore.com>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Tables are like sets: it is safe to insert and delete items while the table
is being generated.  I don't know anywhere that this is explicitly mentioned.
The possible combinations of legal operations are not generally enumerated,
but it is reasonable for you to question whether this tricky case was
considered during implementation.  It was.

    Gregg Townsend / Computer Science Dept / Univ of Arizona / Tucson, AZ 85721
    +1 602 621 4325     gmt@cs.arizona.edu     110 57 16 W / 32 13 45 N / +758m


From icon-group-sender  Tue Feb 22 17:10:57 1994
Received: by cheltenham.cs.arizona.edu; Tue, 22 Feb 1994 19:41:29 MST
Date: Tue, 22 Feb 1994 17:10:57 -0600 (CST)
From: Chris Tenaglia - 257-8765 <TENAGLIA@MIS.MCW.EDU>
Subject: KEYNAMES
To: icon-group@cs.arizona.edu
Message-Id: <01H96Z4EC8IA8WW866@mis.mcw.edu>
Organization: Medical College of Wisconsin (Milwaukee, WI)
X-Vms-To: IN%"icon-group@cs.arizona.edu"
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; CHARSET=US-ASCII
Content-Transfer-Encoding: 7BIT
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


For Chinese NewYear I posted a routine that returned plain names for
keys pressed. That code was specific to MS-DOS. And since the PCs I
have access to for Icon programming are 8088s with 512K and small
keyboards there was probably more room for improvement.

My primary OS is VAX/VMS where icon also flourishes. I wrote a version
for that OS. Therefore it is geared toward DEC compatible terminals
rather than PCs. It probably should work with unix. However, the unix
system I have access to runs DEC Ultrix, and Icon getch() doesn't work
properly there. Typewriter keys return their values. But terminal keyboards
often have fancy keys like F-keys, PF-keys, and keypads. These fancy keys
return an escape sequence. This routine converts the sequence into a name.
So instead of getting \e[A for uparrow, you'd get UPARROW, which makes
following a program much easier. The routine is included below. Enjoy.

Chris Tenaglia (System Manager) |  "The past explained,     
Medical College of Wisconsin    |   the future fortold, 
8701 W. Watertown Plank Rd.     |   the present largely appologized for."
Milwaukee, WI 53226             |   Organon to The Doctor
(414)257-8765                   |     
tenaglia@mis.mcw.edu

#
# FILE : KEYVMS.ICN
# DESC : RETURN THE NAME OF A KEY PRESSED RATHER THAN THE ESCAPE SEQUENCE
#
# UPDATE          BY          WHAT
# 22-FEB-1994     TENAGLIA    INITIAL WRITE
#
procedure main()
  repeat
    {
    button := getch()
    if button == "\e" then
       {
       if kbhit() then
         {
         button ||:= getch()
         if button == "\eO" then button ||:= getch()
         if button == "\e[" then repeat
           {
           tmp      := getch()
           button ||:= tmp
           if any('ABCD~',tmp) then break
           }
         }
       }
    pressed  := keyname(button)
    if pressed == "ANY" then pressed := image(button)
    write(pressed," was pressed!")
    if button == "#" then break
    }
  end
     
#
# map unusual keys to a string
#
procedure keyname(str)
  static  keys
  initial {
          keys := table("ANY")

          keys["\e[A"]  := "UPARROW"
          keys["\e[B"]  := "DOWNARROW"
          keys["\e[C"]  := "RIGHTARROW"
          keys["\e[D"]  := "LEFTARROW"

          keys["\e[1~"] := "FIND"
          keys["\e[2~"] := "INSERT"
          keys["\e[3~"] := "REMOVE"
          keys["\e[4~"] := "SELECT"
          keys["\e[5~"] := "PREV"
          keys["\e[6~"] := "NEXT"

          keys["\eOP"]  := "PF1"
          keys["\eOQ"]  := "PF2"
          keys["\eOR"]  := "PF3"
          keys["\eOS"]  := "PF4"

          keys["\e[17~"]:= "F6"
          keys["\e[18~"]:= "F7"
          keys["\e[19~"]:= "F8"
          keys["\e[20~"]:= "F9"
          keys["\e[21~"]:= "F10"
          keys["\e[23~"]:= "F11"
          keys["\e[24~"]:= "F12"
          keys["\e[25~"]:= "F13"
          keys["\e[26~"]:= "F14"
          keys["\e[28~"]:= "HELP"
          keys["\e[29~"]:= "DO"
          keys["\e[31~"]:= "F17"
          keys["\e[32~"]:= "F18"
          keys["\e[33~"]:= "F19"
          keys["\e[34~"]:= "F20"

          keys["\eOw"]  := "KP7"
          keys["\eOx"]  := "KP8"
          keys["\eOy"]  := "KP9"
          keys["\eOm"]  := "KP-"
          keys["\eOt"]  := "KP4"
          keys["\eOu"]  := "KP5"
          keys["\eOv"]  := "KP6"
          keys["\eOl"]  := "KP,"
          keys["\eOq"]  := "KP1"
          keys["\eOr"]  := "KP2"
          keys["\eOs"]  := "KP3"
          keys["\eOM"]  := "KPENTER"
          keys["\eOp"]  := "KP0"
          keys["\eOn"]  := "KP."

          keys["\e"]    := "ESCAPE"
          keys["\001"]  := "CTRL_A"
          keys["\002"]  := "CTRL_B"
          keys["\003"]  := "CTRL_C"
          keys["\004"]  := "CTRL_D"
          keys["\005"]  := "CTRL_E"
          keys["\006"]  := "CTRL_F"
          keys["\007"]  := "BELL"
          keys["\010"]  := "BACKSPACE"
          keys["\011"]  := "TAB"
          keys["\012"]  := "LINEFEED"
          keys["\013"]  := "CTRL_K"
          keys["\014"]  := "FORMFEED"
          keys["\015"]  := "RETURN"
          keys["\016"]  := "CTRL_N"
          keys["\017"]  := "CTRL_O"
          keys["\020"]  := "CTRL_P"
          keys["\021"]  := "CTRL_Q"
          keys["\022"]  := "CTRL_R"
          keys["\023"]  := "CTRL_S"
          keys["\024"]  := "CTRL_T"
          keys["\025"]  := "CTRL_U"
          keys["\026"]  := "CTRL_V"
          keys["\027"]  := "CTRL_W"
          keys["\030"]  := "CTRL_X"
          keys["\031"]  := "CTRL_Y"
          keys["\032"]  := "CTRL_Z"
          }
  return keys[str]
  end



From icon-group-sender  Wed Feb 23 15:24:52 1994
Received: by cheltenham.cs.arizona.edu; Wed, 23 Feb 1994 15:09:16 MST
Date: Wed, 23 Feb 1994 15:24:52 -0600 (CST)
From: Ronan_Collis <Ronan_Collis@mbnet.mb.ca>
Subject: Re: KEYNAMES
To: Chris Tenaglia - 257-8765 <TENAGLIA@MIS.MCW.EDU>
Cc: icon-group@cs.arizona.edu, Ronan_Collis@mbnet.mb.ca
In-Reply-To: <01H96Z4EC8IA8WW866@mis.mcw.edu>
Message-Id: <Pine.3.05.9402231549.A17675-9100000@access.mbnet.mb.ca>
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; charset=US-ASCII
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Can anyone in the group supply me with information concerning
applications? Has icon been used in connection with computer-assisted
terminology, computer-assisted translation, strict-dependency (or case)
grammar or semantics oriented language engineering? DRFC 




From icon-group-sender  Mon Feb  7 19:16:51 1994
Received: by cheltenham.cs.arizona.edu; Wed, 23 Feb 1994 22:00:36 MST
Date: 7 Feb 94 19:16:51 GMT
From: cis.ohio-state.edu!magnus.acs.ohio-state.edu!math.ohio-state.edu!howland.reston.ans.net!pipex!uknet!festival!eddie@ucbvax.Berkeley.EDU  (Eddie Corns)
Organization: Edinburgh University
Subject: Cheating in WIT??
Message-Id: <CKvC85.n44@festival.ed.ac.uk>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Another quick question re: WIT.  Is it considered bad form to directly access
the .data field of a text vidget?  Is there another way of collecting all the
text inputs from a page full of text boxes without forcing the user to hit
return for every box that they edit?

A less simple question while I'm here.  Is anyone going to implement
multi-line text input vidgets?

Eddie


From icon-group-sender  Fri Feb 25 08:49:50 1994
Received: by cheltenham.cs.arizona.edu; Fri, 25 Feb 1994 08:39:05 MST
Date: Fri, 25 Feb 1994 08:49:50 -0600 (CST)
From: Chris Tenaglia - 257-8765 <TENAGLIA@MIS.MCW.EDU>
Subject: kbhit(), getch(), read()
To: icon-group@cs.arizona.edu
Cc: icon-project@cs.arizona.edu
Message-Id: <01H9AODUV2SI8WWBLD@mis.mcw.edu>
Organization: Medical College of Wisconsin (Milwaukee, WI)
X-Vms-To: IN%"icon-group@cs.arizona.edu"
X-Vms-Cc: IN%"icon-project@cs.arizona.edu"
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; CHARSET=US-ASCII
Content-Transfer-Encoding: 7BIT
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


I wrote a nifty program in DOS Icon V8.10. It used kbhit(), getch(),
and read() in certain ways. This was to make an intuitive user interface.
Now for work I use Icon V8.10 on VAX/VMS 5.5. I hoped that the only
differences would be the fancy key strings and drawing characters.
However, the kbhit(), getch(), and read() work differently and the same
program user interface doesn't work well. Is it spelled out anywhere
what these behaviour differences are? I'd like to port to unix too,
except that getch() under ultrix doesn't work right either.

Under VMS if I don't use kbhit() and getch() and instead do all character
input using read() all behaves as expected. Once I start using them, it
seems that some characters overflow. So when I hit a read() from &stdin
the first character disappears as if a getch() somewhere else intercepted
it. Then when I terminate the read() by pressing <RETURN>, the <RETURN>
character gets intercepted by a kbhit()/getch() somewhere else, and this
causes strange behavior in a user interface. Is there a way to flush the
buffers at certain points and start fresh when needed? Has anyone else
encountered these alternate behaviours?

The best I could do for now is to emulate read() with a getch() loop,
but it too seems to pick up \r at random intervals. Does it matter that
I'm using ansi escape sequences to turn the cursor off and on where
appropriate?

Chris.



From icon-group-sender  Sun Feb 27 14:29:48 1994
Received: by cheltenham.cs.arizona.edu; Sun, 27 Feb 1994 12:06:50 MST
Date: 27 Feb 94 14:29:48 GMT
From: agate!usenet.ins.cwru.edu!nigel.msen.com!caen!malgudi.oar.net!wariat.org!kf8nh!bsa@ucbvax.Berkeley.EDU  (Brandon S. Allbery)
Organization: Brandon's Linux box and AmPR node, Mentor, OH
Subject: Re: file dates
Message-Id: <1994Feb27.142948.431@kf8nh.wariat.org>
References: <1994Feb23.121210.9747@hemlock.cray.com>, <5a-oml5.mengarini@delphi.com>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

In article <5a-oml5.mengarini@delphi.com>, Will Mengarini <mengarini@delphi.com> says:
+---------------
| Can anybody name an Icon implementation for a system where
| files are created & stored in a way that doesn't keep track
| of both creation date & time, & last-change date & time?
+------------->8

Unix doesn't keep *creation* time, it keeps *last inode change* time.  This
catches changes made by e.g. chmod(), as opposed to writes.

++Brandon
-- 
Brandon S. Allbery	   kf8nh@kf8nh.ampr.org		 bsa@kf8nh.wariat.org
"MSDOS didn't get as bad as it is overnight -- it took over ten years
of careful development."  ---dmeggins@aix1.uottawa.ca


From icon-group-sender  Sun Feb 27 05:51:21 1994
Received: by cheltenham.cs.arizona.edu; Wed, 2 Mar 1994 10:46:14 MST
Date: 27 Feb 94 05:51:21 GMT
From: agate!howland.reston.ans.net!noc.near.net!news.delphi.com!usenet@ucbvax.Berkeley.EDU  (Will Mengarini)
Organization: Delphi (info@delphi.com email, 800-695-4005 voice)
Subject: Re: file dates
Message-Id: <5a-oml5.mengarini@delphi.com>
References: <1994Feb23.121210.9747@hemlock.cray.com>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

I've been doing MS-DOS-specific utilities for this kind of thing,
but I think this is a very good point that it'd be useful
for the language to define keywords or functions for things
that can reasonably be expected to be present on most or all
implementations.
 
Can anybody name an Icon implementation for a system where
files are created & stored in a way that doesn't keep track
of both creation date & time, & last-change date & time?
 
It would make sense for this to be a library capability
rather than a language capability, but then the icode
on a particular system should contain only the code for handling
that system, which wouldn't be the case if the system were
identified using a conditional expression based on &features.
I use IPP (an Icon preprocessor from BIPL) in all my programs,
but I'd expect most Unix people to use M4, which is incompatible.
Does anybody else have any relevant thoughts on preprocessing?


From icon-group-sender  Sun Feb 27 07:39:22 1994
Received: by cheltenham.cs.arizona.edu; Wed, 2 Mar 1994 10:48:22 MST
Date: 27 Feb 94 07:39:22 GMT
From: agate!library.ucla.edu!csulb.edu!nic-nac.CSU.net!news.Cerritos.edu!news.Arizona.EDU!math.arizona.edu!CS.Arizona.EDU!not-for-mail@ucbvax.Berkeley.EDU  (Nevin Liber)
Organization: University of Arizona CS Department, Tucson AZ
Subject: Re: file dates
Message-Id: <2kpina$fn5@caslon.CS.Arizona.EDU>
References: <1994Feb23.121210.9747@hemlock.cray.com>, <5a-oml5.mengarini@delphi.com>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

In article <5a-oml5.mengarini@delphi.com>,
Will Mengarini  <mengarini@delphi.com> wrote:
>but I think this is a very good point that it'd be useful
>for the language to define keywords or functions for things
>that can reasonably be expected to be present on most or all
>implementations.

You have to way that against increasing the size of the language
(bloating or creeping featurism).  If there is a way to do it without
adding a language feature (which you have already stated is possible
under MS-DOS, and I can think of ways to do it under Unix), then I'd
lean against adding it as a feature.

>Can anybody name an Icon implementation for a system where
>files are created & stored in a way that doesn't keep track
>of both creation date & time, & last-change date & time?

That's still not enough to make it useful.  At a minimum, you would
like to be able to compare dates (eg: is date1 later than date2).
You'd probably wish to know the amount of time between two dates, and a
way to compare it to the current date.  This would be highly machine
dependent (does the machine keep track of timestamps to the nearest
microsecond or to the nearest minute).  You'd probably want a standard
textual representation to make it easy to create new dates to compare
against.  But if you used something like &dateline as the standard
representation, should you provide functions to fix the redundant
fields (the day of the week can be calculated from the month day year
combination, making it redundant)?  Would you add functions to add or
subtract time to a given date?  Etc., etc.
-- 
	Nevin ":-)" Liber	nevin@cs.arizona.edu	(602) 293-2799
	                 	                    	 +++ (520) after 3/95
	                 	             office:	(602) 621-1685


From icon-group-sender  Wed Mar  2 16:47:28 1994
Received: by cheltenham.cs.arizona.edu; Wed, 2 Mar 1994 16:34:16 MST
Date: 2 Mar 94 16:47:28 GMT
From: ucivax!gateway@ucbvax.Berkeley.EDU  ("T. Owen O'Malley")
Subject: Icon FAQ as Wide World Web document
Message-Id: <3747.762626831@porte-de-st-ouen.ics.uci.edu>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


  I just wanted to announce that I did a simple conversion of the Icon FAQ
into html. It is available at:
  "http://www.ics.uci.edu/~omalley/icon.hmtl".
I converted the FAQ so that I could have a handy reference for the
documentation for one of my tools that is written in Icon. If there is
a "real" Icon WWW document, please give me a pointer to it.

Thanks,
  Owen O'Malley

...

From: omalley@porte-de-st-ouen.ICS.UCI.EDU ("T. Owen O'Malley")
[1] Correction to WWW document for Icon FAQ

That should be icon.html.
 
   Owen



From icon-group-sender  Thu Mar  3 10:15:32 1994
Received: by cheltenham.cs.arizona.edu; Thu, 3 Mar 1994 12:35:39 MST
Message-Id: <m0pcFDg-000NAjC@epic.truevision.com>
Date: 3 Mar 1994 10:15:32 -0500
From: "Paul Scherf" <paul_scherf@gatormail-m.truevision.com>
Subject: RE: file dates
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

I think this sounds like a great chance for defining a library interface
(collection of functions), that could be supported by many of the environments
in which ICON is used. My opinion is that new language keywords are a bit much.
I guess that makes me against adding keywords.

C (i.e. past history (-: ) effectively defines two collections of functions for
dealing with time. One collection deals with calendar dates and times of day
(e.g. "What was the time and date of lunch one week from now?"). The other
collection deals with stopwatch time (for scientific timing of events). Leap
seconds and leap days (these are decided by astronomers and relative positions
of celestial bodies) and calendars that vary with time (different number of
months in different years, these appear to be decided by politicians and
religous leaders), make these two kinds of time difficult to integrate.

Since ICON is often implemented in C, maybe an ICON interface to the C
libraries would be useful or even appropriate.
_______________________________________________________________________________
In article <5a-oml5.mengarini@delphi.com>,
Will Mengarini  <mengarini@delphi.com> wrote:
>but I think this is a very good point that it'd be useful
>for the language to define keywords or functions for things
>that can reasonably be expected to be present on most or all
>implementations.

You have to way that against increasing the size of the language
(bloating or creeping featurism).  If there is a way to do it without
adding a language feature (which you have already stated is possible
under MS-DOS, and I can think of ways to do it under Unix), then I'd
lean against adding it as a feature.

>Can anybody name an Icon implementation for a system where
>files are created & stored in a way that doesn't keep track
>of both creation date & time, & last-change date & time?

That's still not enough to make it useful.  At a minimum, you would
like to be able to compare dates (eg: is date1 later than date2).
You'd probably wish to know the amount of time between two dates, and a
way to compare it to the current date.  This would be highly machine
dependent (does the machine keep track of timestamps to the nearest
microsecond or to the nearest minute).  You'd probably want a standard
textual representation to make it easy to create new dates to compare
against.  But if you used something like &dateline as the standard
representation, should you provide functions to fix the redundant
fields (the day of the week can be calculated from the month day year
combination, making it redundant)?  Would you add functions to add or
subtract time to a given date?  Etc., etc.


From icon-group-sender  Sun Feb 20 14:17:08 1994
Received: by cheltenham.cs.arizona.edu; Sun, 6 Mar 1994 20:01:26 MST
Date: 20 Feb 94 14:17:08 GMT
From: cis.ohio-state.edu!math.ohio-state.edu!howland.reston.ans.net!noc.near.net!news.delphi.com!usenet@ucbvax.Berkeley.EDU  (Will Mengarini)
Organization: Delphi (info@delphi.com email, 800-695-4005 voice)
Subject: Re: ftp site for Icon.
Message-Id: <po1KmK8.mengarini@delphi.com>
References: <CLG9yH.K87@ucdavis.edu>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

A Z E E M <butt@otto.cs.ucdavis.edu> writes:
 
>Is there an ftp site where Icon can be obtained from?
 
cs.arizona.edu
 
There's also a FAQ; I don't know whether it's FTPable from
cs.arizona.edu, but I think it should be.
 
Also, somebody who knows their way around rtfm.mit.edu
(the standard site for FTPing FAQs) might tell us whether the
Icon FAQ is there yet (it's new), & (25 words or less)
how to get it.


From icon-group-sender  Mon Mar  7 09:21:35 1994
Received: by cheltenham.cs.arizona.edu; Mon, 7 Mar 1994 12:26:57 MST
Date: Mon, 7 Mar 1994 09:21:35 MST
From: "Cliff Hathaway" <cliff>
Message-Id: <199403071621.AA03874@cheltenham.cs.arizona.edu>
To: cis.ohio-state.edu!math.ohio-state.edu!howland.reston.ans.net!noc.near.net!news.delphi.com!usenet@ucbvax.Berkeley.EDU,
        icon-group@cs.arizona.edu
Subject: Re: ftp site for Icon.
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

> From icon-group-sender Sun Mar  6 20:01:53 1994
> Subject: Re: ftp site for Icon.
> To: icon-group@cs.arizona.edu

Will Mengarini writes:

> There's also a FAQ; I don't know whether it's FTPable from
> cs.arizona.edu, but I think it should be.

Yes.  It's faq.txt, in /icon/doc.  Last updated March 4, 1994.

>  
> Also, somebody who knows their way around rtfm.mit.edu
> (the standard site for FTPing FAQs) might tell us whether the
> Icon FAQ is there yet (it's new), & (25 words or less)
> how to get it.

on rtfm.mit.edu, cd to /pub/usenet/comp.lang.icon.
get Icon_Programming_Language_FAQ.

cliff


From icon-group-sender  Tue Mar  8 14:50:20 1994
Received: by cheltenham.cs.arizona.edu; Tue, 8 Mar 1994 15:07:44 MST
Date: Tue, 8 Mar 1994 14:50:20 -0600 (CST)
From: Ronan_Collis <Ronan_Collis@mbnet.mb.ca>
Subject: TOM The language profile program
To: icon-group@cs.arizona.edu
Cc: Ronan_Collis@mbnet.mb.ca
Message-Id: <Pine.3.05.9403081420.A3446-a100000@access.mbnet.mb.ca>
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; charset=US-ASCII
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

If any group member has heard of TOM or any program like it please
link me. TOM was written about 20 years ago for IBM 360-75 mainframes. It
was an artificial intelligence interface between the user and the
computer such that the user could in whatever his language was,
define what was a sentence and what were words and what each word
meant. It produced a spin-off which was a profile of the syntax and
the dictionary for the user's idiolect (or personal dialect). A
couple of years ago there was an article that a similar program had
been made for vax or pc or spark. It is or was used in discourse or
text linguistics or for any lesser used language in which it is
necessary to investigate the lexical morphology. RC




From icon-group-sender  Wed Mar  9 09:28:35 1994
Received: by cheltenham.cs.arizona.edu; Wed, 9 Mar 1994 09:06:06 MST
Date: Wed, 09 Mar 1994 09:28:35 -0600 (CST)
From: Chris Tenaglia - 257-8765 <TENAGLIA@MIS.MCW.EDU>
Subject: Re: TOM
To: icon-group@cs.arizona.edu
Message-Id: <01H9RH7R4NXE8WWU3G@mis.mcw.edu>
Organization: Medical College of Wisconsin (Milwaukee, WI)
X-Vms-To: IN%"icon-group@cs.arizona.edu"
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; CHARSET=US-ASCII
Content-Transfer-Encoding: 7BIT
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


About 10 years ago a company I worked for built IBM 360/20 compatible
workstations (believe it or not). I wrote a lot of manufacturing
software in BAL360 assembler back then. It didn't really have an
operating system, but rather a program loader. I started some work
on an operating system I called PLOS (Plan Language Operating System).
I read an Apple Whitepaper back then about the programmers goal shouldn't
necessarily be to reduce keystrokes, but rather 'brainstrokes'. For
example the backup command was SAVE and it worked like :

DOS> SAVE ALL SECTORS TO TAPE1       * FULL BACKUP
DOS> SAVE SOME SECTORS TO TAPE1      * INCREMENTAL BACKUP
DOS> SAVE ALL SECTORS FROM TAPE1     * FULL RESTORE

The system could recognize up to six tape drives, but only one floppy (8")
and  only one hard disk. The parser in SAVE would look for ALL or SOME and
determine the meaning.
Then SECTORS (for 512 byte blocks) or TRACKS (for 17408 byte blocks)
Then FROM or TO for restore or backup
Then the TAPEn drive number.

My  DOS  was  still basically a program loader but the original would only
accept 4 bytes of command (LOAD, RUN, DEL) and then prompt for the program
name  which  was  4 or 6 bytes. My loader permitted commands over 80 bytes
and  programs  could  access  those  commands  to  parse them. Gee, what a
concept! ;-)

Chris Tenaglia (System Manager) |  "The past explained,
Medical College of Wisconsin    |   the future fortold, 
8701 W. Watertown Plank Rd.     |   the present largely appologized for."
Milwaukee, WI 53226             |   Organon to The Doctor
(414)257-8765                   |     
tenaglia@mis.mcw.edu

> From:	IN%"Ronan_Collis@mbnet.mb.ca"  "Ronan_Collis"  8-MAR-1994 16:16:44.75
> To:	IN%"icon-group@cs.arizona.edu"
> CC:	IN%"Ronan_Collis@mbnet.mb.ca"
> Subj:	TOM The language profile program

> If any group member has heard of TOM or any program like it please
> link me. TOM was written about 20 years ago for IBM 360-75 mainframes. It
> was an artificial intelligence interface between the user and the
> computer such that the user could in whatever his language was,
> define what was a sentence and what were words and what each word
> meant. It produced a spin-off which was a profile of the syntax and
> the dictionary for the user's idiolect (or personal dialect). A
> couple of years ago there was an article that a similar program had
> been made for vax or pc or spark. It is or was used in discourse or
> text linguistics or for any lesser used language in which it is
> necessary to investigate the lexical morphology. RC




From icon-group-sender  Sat Mar 12 10:17:29 1994
Received: by cheltenham.cs.arizona.edu; Sat, 12 Mar 1994 20:52:37 MST
Date: 12 Mar 94 10:17:29 GMT
From: nntp.crl.com!crl2.crl.com!not-for-mail@decwrl.dec.com  (Bill Hogan)
Organization: Planet Earth
Subject: Re: make Configure i386_linux error.
Message-Id: <2ls4rp$k3p@crl2.crl.com>
References: <2lk1jo$vb@crl.crl.com>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


 In case anyone is interested in running Icon under Linux, the problem 
was easy to fix.

 Here is the diff between the fixed version of

	icon/config/unix/Config/Makefile

and the original:

62c62
< 		ed -s ../../../bin/icon_vt <../Config/dequote.ed
---
> 		ed - ../../../bin/icon_vt <../Config/dequote.ed

 After that, smooth as silk.

 Thanks to all who replied!

BH
-- 
  Bill Hogan
{bhogan@crl.com}


From icon-group-sender  Tue Mar 15 14:55:25 1994
Received: by cheltenham.CS.Arizona.EDU; Tue, 15 Mar 1994 10:51:12 MST
Via: uk.ac.edinburgh.festival; Tue, 15 Mar 1994 14:55:36 +0000
Date: 15 Mar 94 14:55:25 GMT
From: R J Hare <rjhare@festival.ed.ac.uk>
Subject: Diary Utility
To: icon-group@cs.arizona.edu
Organisation: Edinburgh University Computing Service
Message-Id: <9403151455.aa29609@uk.ac.ed.festival>
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

We are looking for an X utility which will allow a departmental diary to be
held centrally into which people will enter holiday, seminar and course dates
etc.

Has anyone written such a thing with X-Icon yet, that they would be willing to
share?

Thanks.

Roger Hare.


From icon-group-sender  Sun Apr  3 02:40:34 1994
Received: by cheltenham.cs.arizona.edu; Mon, 4 Apr 1994 09:33:23 MST
Path: ucbvax!agate!ihnp4.ucsd.edu!usc!elroy.jpl.nasa.gov!ncar!uchinews!iitmax!thssjlb
From: thssjlb@iitmax.acc.iit.edu (Anonymous Man)
Newsgroups: comp.lang.icon
Subject: Help with tw-dimensional table...
Message-Id: <1994Apr3.024034.14883@iitmax.iit.edu>
Date: 3 Apr 94 02:40:34 GMT
Organization: Illinois Institute of Technology, Chicago
Lines: 11
Apparently-To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Hello, I'm having trouble creating a two-dimensional array for parser
program I am writing.  How do I create one?  or is there another way
that is better.  Thank you for your time.


-- 
------------------------------------------------------------------------------
| John L Buntic              | "Health nuts are going to feel stupid one day,|
| thssjlb@iitmax.acc.iit.edu |  lying in hospital beds dying of nothing."    |
| If it feels good, do it!   |                                     -Redd Foxx|
------------------------------------------------------------------------------


From icon-group-sender  Mon Apr  4 13:03:45 1994
Received: by cheltenham.cs.arizona.edu; Mon, 4 Apr 1994 15:28:34 MST
Date: Mon, 04 Apr 1994 13:03:45 -0600 (CST)
From: Chris Tenaglia - 257-8765 <TENAGLIA@MIS.MCW.EDU>
Subject: 2d arrays in icon
To: icon-group@cs.arizona.edu
Message-Id: <01HAS0FEAPNM8WWQ0I@mis.mcw.edu>
Organization: Medical College of Wisconsin (Milwaukee, WI)
X-Vms-To: IN%"icon-group@cs.arizona.edu"
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; CHARSET=US-ASCII
Content-Transfer-Encoding: 7BIT
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


I have done it by constructing a key using the axes and a delimiter.

       xy   := table(0)
       seed := 64
       every i := 1 to 10 do
         every j := 1 to 10 do
           xy[i||","||j] := mandel(i,j,seed)
       write(xy["5,5"])

I think the delimited key is the most natural as long as you can be sure the
key  representation  is  reliable  and consistent. Leading zeroes or decimal
points  would cause mischief. The delimited index will also work in a string
parsing array. Uniqueness is still the important factor. Case and spaces are
the pitfalls in this regard. Good luck.

Chris Tenaglia (System Manager) |  "The past explained,     
Medical College of Wisconsin    |   the future fortold, 
8701 W. Watertown Plank Rd.     |   the present largely appologized for."
Milwaukee, WI 53226             |   Organon to The Doctor
(414)257-8765                   |     
tenaglia@mis.mcw.edu

> From:	IN%"thssjlb@iitmax.acc.iit.edu"  4-APR-1994 11:42:43.57
> To:	IN%"tenaglia@MIS.MCW.EDU"
> Subj:	Help with tw-dimensional table...

> Hello, I'm having trouble creating a two-dimensional array for parser
> program I am writing.  How do I create one?  or is there another way
> that is better.  Thank you for your time.
> ------------------------------------------------------------------------------
> | John L Buntic              | "Health nuts are going to feel stupid one day,|
> | thssjlb@iitmax.acc.iit.edu |  lying in hospital beds dying of nothing."    |
> | If it feels good, do it!   |                                     -Redd Foxx|
> ------------------------------------------------------------------------------



From icon-group-sender  Tue Apr  5 07:32:34 1994
Received: by cheltenham.cs.arizona.edu; Tue, 5 Apr 1994 09:01:18 MST
Via: uk.ac.edinburgh.festival; Tue, 5 Apr 1994 15:31:10 +0100
Date: 05 Apr 94 15:30:59 BST
From: R J Hare <rjhare@festival.ed.ac.uk>
Subject: 2-darrays
To: icon-group@cs.arizona.edu
Organisation: Edinburgh University Computing Service
Message-Id: <9404051531.aa04767@uk.ac.ed.festival>
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

The method on p52 of the the 1st edition of the Icon book (all I have to hand
at the moment) uses lists of lists:

procedure array(i,j,x)
a:=list(i,0)
k:=0
while a[k +:= 1] := list(j,x)
return a
end

I think I'd do it like this (in fact I have done and it seems to work) - to me
this is easier to read than the first version:

procedure array(i,j,x)
a:=list(i)
every !a=list(j,x)
return a
end

So:

shogiboard:=array(9,9," ")

would return an empty 9x9 board.

You refer to eleents of the array as a[i][j] - later versions of Icon allow
a[i,j].

Roger Hare.


From icon-group-sender  Tue Apr  5 08:26:42 1994
Received: by cheltenham.cs.arizona.edu; Tue, 5 Apr 1994 09:01:47 MST
Date: Tue, 5 Apr 1994 08:26:42 +0700
From: swampler@noao.edu
Message-Id: <9404051526.AA04963@orpheus.tuc.noao.edu>
Subject: Re: 2d arrays in Icon
To: icon-group@cs.arizona.edu
Content-Length: 690
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


In addition to Chris' approach using a table (which is also *very* nice for
sparse arrays), it's pretty easy to write a 2d array 'constructor' function:

   procedure array2d(num_rows, num_cols)
      local a

      a := list(num_rows)
      every !a := list(num_cols)

      return a
   end

You can then reference the result, as in:

   board := array2d(8, 8)
   board[1][1] := "Q"

One nice thing about 2d-arrays in Icon is that they are, indeed, dynamic
(since they are just constructed from lists) - it's not hard to write functions
to grow/shrink them, insert/remove columns/rows, etc. (columns are harder than
rows...)
--
Steve Wampler
swampler@noao.edu
Gemini Project (under AURA)


From icon-group-sender  Mon Mar 28 20:01:41 1994
Received: by cheltenham.cs.arizona.edu; Thu, 7 Apr 1994 18:35:13 MST
Path: ucbvax!agate!ames!pacbell.com!att-out!walter!news
From: dnew@thumper.bellcore.com (Darren New)
Newsgroups: comp.lang.icon
Subject: MS Windows 3.1 version of Icon
Message-Id: <CnE4yt.6p9@walter.bellcore.com>
Date: 28 Mar 94 20:01:41 GMT
Sender: news@walter.bellcore.com
Organization: Bellcore
Lines: 4
Nntp-Posting-Host: bambam.bellcore.com
Apparently-To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Is there a version of Icon that runs under Windows available? I see
"ms-dos" versions out there, but it's not clear to me which I should be
snagging. Thanks for your time!      -- Darren 
 


From icon-group-sender  Sun Apr 10 22:28:08 1994
Received: by cheltenham.cs.arizona.edu; Mon, 11 Apr 1994 11:06:18 MST
Date: Sun, 10 Apr 1994 22:28:08 -1000
From: David Bulman <dbulman@ACM.ORG>
Subject: Generate Names?
To: icon-group@cs.arizona.edu
Message-Id: <dbulman.1116440528C@acm.org>
X-Mailer: VersaTerm Link v1.1.4
Content-Transfer-Encoding: 7BIT
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

A friend of mine has a problem I'd like to try to solve with an 
Icon program. 

The problem is to generate very many unique 5 character names, 
which should be pronounceable in English, but each should sound 
different from all the others. I imagine that taking advantage 
of the fact that a word with alternating consonants (C) and 
vowels (V) is likely to be pronounceable, but probably bringing 
Soundex into play would help too. 

So, the problem sort of has 3 parts:
1. What makes a pronounceable name?
2. How can I tell if two names sound alike?
3. How should I attack this in Icon?

Dave
+----------------------------------------------------------------+
David M. Bulman       dbulman@acm.org      Voice: (808) 883-9011
P.O. Box 383429         Voice on AT&T Easy Reach:  0-700-DBULMAN
Waikoloa, HI 96738                           Fax: (808) 883-8172


From icon-group-sender  Mon Apr 11 13:43:10 1994
Received: by cheltenham.cs.arizona.edu; Mon, 11 Apr 1994 12:37:47 MST
Date: Mon, 11 Apr 1994 13:43:10 -0600 (CST)
From: Chris Tenaglia - 257-8765 <TENAGLIA@MIS.MCW.EDU>
Subject: Name/Word generator
To: icon-group@cs.arizona.edu
Message-Id: <01HB1UA5A5888WXLKI@mis.mcw.edu>
Organization: Medical College of Wisconsin (Milwaukee, WI)
X-Vms-To: IN%"icon-group@cs.arizona.edu"
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; CHARSET=US-ASCII
Content-Transfer-Encoding: 7BIT
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

> From:	IN%"dbulman@ACM.ORG"  "David Bulman" 11-APR-1994 13:21:32.86
> To:	IN%"icon-group@cs.arizona.edu"
> Subj:	Generate Names?

The icon library has soundex routines. Usually you feed a string to
soundex to get a string/number. But I think it could be used as a
comparison tool. I think phonetic spelling then is more important
that accurate english spelling. To keep things unique you could use
a table() with soundex keys to eliminate sound-a-likes. Then you
might be able to get more words by having it randomly or alternately
choose to begin with a vowel or consonant. Also dipthongs can be
considered, but carfully. sh, th, ch, br, bl,... and oi, io, ia, oo,
oa, ai,...

I have a similar tool, password generator. It also includes numerics.
These are distributed by paper and phone to I don't include letters or
numbers that look too much alike. We leave out O and 0, and 1, i, and
l. This is useful if you have foreigners who have trouble discerning
certain sounds especially over the phone.

Chris Tenaglia (System Manager) |  "The past explained,
Medical College of Wisconsin    |   the future fortold, 
8701 W. Watertown Plank Rd.     |   the present largely appologized for."
Milwaukee, WI 53226             |   Organon to The Doctor
(414)257-8765                   |     
tenaglia@mis.mcw.edu

> A friend of mine has a problem I'd like to try to solve with an 
> Icon program. 
> The problem is to generate very many unique 5 character names, 
> which should be pronounceable in English, but each should sound 
> different from all the others. I imagine that taking advantage 
> of the fact that a word with alternating consonants (C) and 
> vowels (V) is likely to be pronounceable, but probably bringing 
> Soundex into play would help too. 
> So, the problem sort of has 3 parts:
> 1. What makes a pronounceable name?
> 2. How can I tell if two names sound alike?
> 3. How should I attack this in Icon?
> Dave
> +----------------------------------------------------------------+
> David M. Bulman       dbulman@acm.org      Voice: (808) 883-9011
> P.O. Box 383429         Voice on AT&T Easy Reach:  0-700-DBULMAN
> Waikoloa, HI 96738                           Fax: (808) 883-8172



From icon-group-sender  Tue Apr 19 06:40:37 1994
Received: by cheltenham.cs.arizona.edu; Tue, 19 Apr 1994 09:23:09 MST
Via: uk.ac.edinburgh.festival; Tue, 19 Apr 1994 14:03:19 +0100
Date: 19 Apr 94 14:03:10 BST
From: R J Hare <rjhare@festival.ed.ac.uk>
Subject: random numbers
To: icon-group@cs.arizona.edu
Organisation: Edinburgh University Computing Service
Message-Id: <9404191403.aa04644@uk.ac.ed.festival>
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


I have a program in which I have an integer which marks the upper end of a
range from which I wish to randomly select a value. I am using:

i:=?range

so, if I have previously set range to (say) 13, I should get i in the range
1..13. In fact, I am getting i equals 1 or 3, ie: ? is apparently treating
range as a 2 character string and returning randomly the value of the 1st or
2nd character in the string. Is this behaviour correct?

If I do something like:

i:=?integer(range)

all is well.

I am a little puzzled by this behaviour and would be grateful if someone
could explain it...

Thanks.

RogerHare


From icon-group-sender  Tue Apr 19 10:06:42 1994
Received: by cheltenham.cs.arizona.edu; Tue, 19 Apr 1994 12:28:32 MST
Date: Tue, 19 Apr 1994 10:06:42 MST
From: "Ralph Griswold" <ralph>
Message-Id: <199404191706.AA11050@cheltenham.cs.arizona.edu>
To: rjhare@festival.ed.ac.uk
Subject: Re:  random numbers
Cc: icon-group
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Your problem is because range is a string.  ?s returns a randomly selected
character from the string s.  Since the ? operator applies to a variety
of data types, you need to convert strings that look like integers to
integers -- which your test shows to work.
    
Ralph E. Griswold			ralph@cs.arizona.edu
Department of Computer Science 		 uunet!arizona!ralph
The University of Arizona		602-621-6609 (voice)
Tucson, AZ 85721			602-621-4246   (fax)


From icon-group-sender  Tue Apr 19 13:05:06 1994
Received: by cheltenham.cs.arizona.edu; Tue, 19 Apr 1994 12:29:34 MST
Date: Tue, 19 Apr 94 13:05:06 CDT
From: jeffery@ringer.cs.utsa.edu (Clinton L. Jeffery)
Message-Id: <9404191805.AA15720@ringer.cs.utsa.edu.sunset>
To: rjhare@festival.ed.ac.uk
Cc: icon-group@cs.arizona.edu
In-Reply-To: R J Hare's message of 19 Apr 94 14:03:10 BST <9404191403.aa04644@uk.ac.ed.festival>
Subject: random numbers
Content-Length: 365
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

If variable i is a string instead of an integer, ?i will give you a random
character from the string instead of a random integer.  A little too much
polymorphism to handle unless you can figure such things out when you see
the behavior in question, heh heh.

Clint Jeffery
cjeffery@cs.arizona.edu, jeffery@ringer.cs.utsa.edu
The University of Texas at San Antonio



From icon-group-sender  Tue Apr 19 14:32:34 1994
Received: by cheltenham.cs.arizona.edu; Tue, 19 Apr 1994 15:53:29 MST
Date: Tue, 19 Apr 1994 14:32:34 -0500
From: John David Stone <stone@math.grin.edu>
Message-Id: <199404191932.OAA00763@russell.math.grin.edu>
To: rjhare@festival.ed.ac.uk
Cc: icon-group@cs.arizona.edu
In-Reply-To: R J Hare's message of 19 Apr 94 14:03:10 BST <9404191403.aa04644@uk.ac.ed.festival>
Subject: random numbers
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

        R. J. Hare writes:

>           I have a program in which I have an integer which marks the
>  upper end of a range from which I wish to randomly select a value. I am
>  using: 
>
>  i:=?range
>
>  so, if I have previously set range to (say) 13, I should get i in the
>  range 1..13. In fact, I am getting i equals 1 or 3, ie: ? is apparently
>  treating range as a 2 character string and returning randomly the value
>  of the 1st or 2nd character in the string. Is this behaviour correct?

        It is if the value of `range' is really a string.  How did this
variable acquire its value in the first place?  If it was typed in from
the keyboard in response to a prompt, e.g.,

                writes("Number, please: ")
                range := read()

then the value that is assigned to `range' really is a string, and if you
want to deal with an integer you should change the second statement to
something like

                (range := integer(read())) | stop("non-integer input")

------  John David Stone - Lecturer in Computer Science and Philosophy  -----
--------------  Manager of the Mathematics Local-Area Network  --------------
--------------  Grinnell College - Grinnell, Iowa 50112 - USA  --------------
--------  stone@math.grin.edu - (515) 269-3181 - stone@grin1.bitnet  --------


From icon-group-sender  Tue Apr 19 15:07:23 1994
Received: by cheltenham.cs.arizona.edu; Tue, 19 Apr 1994 15:55:08 MST
Date: Tue, 19 Apr 1994 15:07:23 MST
From: "Ralph Griswold" <ralph>
Message-Id: <199404192207.AA19451@cheltenham.cs.arizona.edu>
To: icon-group
Subject: sockets in Icon
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

I'm forwarding the following inquiry that came to me in hopes
someone in icon-group can answer.

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	I have asked before re sockets in Icon and been told there are none.
	I feel this is probably something someone has done before.
	Could you please give me any ideas how to track this down before
	trying to figure something out myself?

	-- 
	Thanks from: Doug Skuce                 | e-mail: doug@csi.uottawa.ca
	Department of Computer Science          |
	University of Ottawa                    | phone : (613) 564-5418
	Ottawa, K1N 6N5, Canada                 | fax   : (613) 564-9486






From icon-group-sender  Wed Apr 20 00:10:16 1994
Received: by cheltenham.cs.arizona.edu; Wed, 20 Apr 1994 08:31:17 MST
Via: uk.ac.edinburgh.festival; Wed, 20 Apr 1994 08:09:49 +0100
Date: 20 Apr 94 08:09:43 BST
From: R J Hare <rjhare@festival.ed.ac.uk>
Subject: Random numbers
To: icon-group@cs.arizona.edu
Organisation: Edinburgh University Computing Service
Message-Id: <9404200809.aa18437@uk.ac.ed.festival>
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Thank you all for responding to my query about 'strange' behaviour by the
random operator. I had always assumed that if a value was 'intrinsically'
numeric, it e was forced to the relevant type. I now see I was mistaken -
another valuable lesson.

For what it's worth, the value for range was set like this:

x:=arglist[1]|50

where arglist is the run-time argument list given to the program. If the
argument list is not given, the value defaults to 50 and as 50 *is* an
integer, and all is well...

Thanks again.

Roger Hare


From icon-group-sender  Wed Apr 20 10:53:50 1994
Received: by cheltenham.cs.arizona.edu; Wed, 20 Apr 1994 09:10:09 MST
Message-Id: <199404201555.AA17040@optima.CS.Arizona.EDU>
To: icon-group@cs.arizona.edu
From: "Stephen Del Rea" <SREA@UAEX.ARKNET.EDU>
Organization: UA Cooperative Extension Service
Date:         Wed, 20 Apr 1994 10:53:50 CST
Subject:      Snobol4 or Icon?
Priority: normal
X-Mailer:     WinPMail v1.0 (R2)
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

I have just got on the icon-group list, mainly to learn more about the 
language.  I have been using Snobol4 for many years, mainly for 
string manipulation and parsing, and am quite happy with it.  My 
question is:  Should I consider switching to Icon and, if so, what 
strengths and capabilities would Icon give me over Snobol4?  Please 
try to avoid the philosophical arguments of one over the other (which 
are as many as there are users of the languages!).  Thanks in 
advance for your input.

Stephen Rea
srea@uaex.arknet.edu


From icon-group-sender  Wed Apr 20 10:00:14 1994
Received: by cheltenham.cs.arizona.edu; Wed, 20 Apr 1994 12:45:53 MST
Date: Wed, 20 Apr 1994 10:00:14 -0700
From: Michael Shafto <shafto@eos.arc.nasa.gov>
Message-Id: <199404201700.KAA11036@eos.arc.nasa.gov>
To: SREA@UAEX.ARKNET.EDU, icon-group@cs.arizona.edu
Subject: Re:  Snobol4 or Icon?
Cc: shafto@eos.arc.nasa.gov
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Steve,
I have been a SNOBOL4 hacker for almost 25 years,
having learned it on an IBM 360 at Princeton,
starting in 1970.
I picked up Icon starting in about 1982, before
it was widely available on a lot of platforms.
I've used Icon extensively since about 1984, on
Vax, PC, and Mac platforms.
The following opinions are likely NOT to be
politically correct, but they're based on a lot
of practical programming experience.
1. Icon would probably be easier to learn from
scratch than would SNOBOL4, but this is irrelevant
if you're already fluent in SNOBOL4.
1a) However, if others have to read and
understand your code, Icon beats SNOBOL4.
2. If your applications are heavy on pattern
matching, SNOBOL4 is far better than Icon.
2a) If your applications are NOT heavily
dependent on sophistiacted pattern matching,
Icon is better.
3. SNOBOL4's advantages decrease the larger
your programs become. Icon is mcuh better if
you have to develop and maintain large programs,
using libraries.
4. Icon is better maintained than SNOBOL4, e.g.,
Ralph Griswold and friends are about to deliver
on a major investment in the enhancement of
Icon's graphics programming capabilities.
5. Both Icon code and SNOBOL4 code are highly
portable across different platforms; this is
a real strength for both of them.
6. There are two things you can do in SNOBOL4
that you simply cannot do in Icon:
(a) have patterns availble as first-class
data types: create them at run-time, have them
returned as values from subroutines, etc.;
(b) create, compile, and interpret code
at run-time (like LISP).
If these features are important, you should
use SNOBOL4.

Happy hacking!!!

(Icon and SNOBOL4 are my two favorite languages;
I know lots of others but I don't use them.)

Mike


From icon-group-sender  Wed Apr 20 12:59:29 1994
Received: by cheltenham.cs.arizona.edu; Wed, 20 Apr 1994 13:13:20 MST
Date: Wed, 20 Apr 1994 12:59:29 MST
From: "Ralph Griswold" <ralph>
Message-Id: <199404201959.AA19174@cheltenham.cs.arizona.edu>
To: shafto@eos.arc.nasa.gov
Subject: Re:  Snobol4 or Icon?
Cc: icon-group
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Mike Shafto's evaluation of SNOBOL4 and Icon generally agree with mine.

The issue of support may be very important to some persons.  Icon is
available on a wide variety of platforms and all implementations are
in the public domain.  New features are being added to Icon and there's
extensive documentation, including a free newsletter.

Implied in Mike's reply, but perhaps not obvious if you're not familiar
with the two languages, is that Icon has extensive high-level facilities
for graphics, while SNOBOL4 has none.  Icon's graphic facilities presently
are supported under UNIX, VMS, and OS/2.  We expect a Windows NT
implementation with graphics and have hopes of ones for Win32 and the Macintosh.

Ralph E. Griswold			ralph@cs.arizona.edu
Department of Computer Science 		 uunet!arizona!ralph
The University of Arizona		602-621-6609 (voice)
Tucson, AZ 85721			602-621-4246   (fax)


From icon-group-sender  Wed Apr 20 17:23:11 1994
Received: by cheltenham.cs.arizona.edu; Wed, 20 Apr 1994 18:39:06 MST
Date: Wed, 20 Apr 1994 17:23:11 -0500 (CDT)
From: Ronan_Collis <Ronan_Collis@mbnet.mb.ca>
Subject: Re: Snobol4 or Icon?
To: Ralph Griswold <ralph@cs.arizona.edu>
Cc: shafto@eos.arc.nasa.gov, icon-group@cs.arizona.edu
In-Reply-To: <199404201959.AA19174@cheltenham.cs.arizona.edu>
Message-Id: <Pine.3.05.9404201703.A21822-7100000@access.mbnet.mb.ca>
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; charset=US-ASCII
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Thank you for the news that there will, later be icon graphics support for
macintosh. Ronan_Collis@MBnet.MB.CA





From icon-group-sender  Fri Apr 22 13:06:56 1994
Received: by cheltenham.cs.arizona.edu; Fri, 22 Apr 1994 09:14:03 MST
Date: Fri, 22 Apr 1994 13:06:56 +0100
From: Jan Peter de Ruiter <janpeter@mpi.nl>
Message-Id: <9404221206.AA25564@mpix10.mpi.kun.nl>
To: icon-group@cs.arizona.edu
Subject: is this a bug?
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Hi Icon folks,

I hope someone can help me out with this.

I had a terrible bug in a program, and it was caused
by the following phenomenon:

------- example program -------------
link ximage
procedure main()
	t := table([]) # a table with default element []
	every put(t[1],generate(1,5)) # fill t[1], which is empty list
	every put(t[2],generate(6,9)) # fill t[2], which is empty list
	every(write(!t[1])) # write out all elements of t[1]
	write()
	every(write(!t[2])) # write out all elements of t[2]
	write(ximage(t)) # write out image of t 
end

procedure generate(a,b)
	every suspend (a to b)
end

-------- end example program -----------

Now I expected that t[1] would be [1,2,3,4,5] and 
t[2] would be [6,7,8,9]. However, the output was:

--------- program output ---------------

1
2
3
4
5
6
7
8
9

1
2
3
4
5
6
7
8
9
T1 := table({L1 := list(9)
         L1[1] := 1
         L1[2] := 2
         L1[3] := 3
         L1[4] := 4
         L1[5] := 5
         L1[6] := 6
         L1[7] := 7
         L1[8] := 8
         L1[9] := 9
      L1})
--------- end program output -------------
It seems there is actually one list here, with
both t[1] and t[2] pointing to it. This was
not what I expected.

Now my question is: have I understood the icon
semantics wrongly, or is this a bug? If anyone
understands what is happening here, could (s)he
please explain?

Thanks in advance,

Jan

janpeter@mpi.kun.nl


From icon-group-sender  Fri Apr 22 11:36:51 1994
Received: by cheltenham.cs.arizona.edu; Fri, 22 Apr 1994 12:34:52 MST
Date: Fri, 22 Apr 1994 11:36:51 -0500
From: John David Stone <stone@math.grin.edu>
Message-Id: <199404221636.LAA01303@russell.math.grin.edu>
To: janpeter@mpi.nl
Cc: icon-group@cs.arizona.edu
In-Reply-To: Jan Peter de Ruiter's message of Fri, 22 Apr 1994 13:06:56 +0100 <9404221206.AA25564@mpix10.mpi.kun.nl>
Subject: is this a bug?
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

        Here's an excerpt from _The Icon Programming Language_, second
edition (pages 76-77), that explains what's going on:

-----------------------------------------------------------------------------
        A structure value is reference (pointer) to an aggregate of values.
Furthermore, assignment copies the reference (pointer) but not the
aggregate of values to which it points.  There are several consequences of
these properties of structures that may not be immediately obvious.
Consider

                index := list(50, 0)
                temp := index
                temp[1] := 1

The assignment of the value of index to temp does not copy the 50 values
pointed to by the value of index.  Instead, index and temp both point to
the _same_ aggregate of values.  Therefore, the assignment of 1 to temp[1]
changes the contents of the list that temp and index share as their value.
The effect is as if

                index[1] := 1

had been evaluated. ... Since assignment does not copy structures, the
result of an expression such as

                L1 := L2 := list(i, 0)

is to assign the _same_list to both L1 and L2.  Subsequently, assignment to
a position in L2 changes the value of that position in L1, and conversely.
Similarly, the effect of

                L := list(3, list(5, 0))

is to assign the _same_ list of five values to each of the three values in
L.
-----------------------------------------------------------------------------

        De Ruiter is running up against the same problem; he has the _same_
(initially empty) list as the default value throughout table T1.
Consequently, when a call to put modifies the value of this list, the
effect is to change every entry in the table (because there _is_ actually
only one "aggregate of values" on the other end of all the pointers).

------  John David Stone - Lecturer in Computer Science and Philosophy  -----
--------------  Manager of the Mathematics Local-Area Network  --------------
--------------  Grinnell College - Grinnell, Iowa 50112 - USA  --------------
--------  stone@math.grin.edu - (515) 269-3181 - stone@grin1.bitnet  --------


From icon-group-sender  Fri Apr 22 09:58:30 1994
Received: by cheltenham.cs.arizona.edu; Fri, 22 Apr 1994 12:35:30 MST
From: Nevin Liber <nevin@caslon>
Message-Id: <199404221658.JAA20218@caslon.CS.Arizona.EDU>
Subject: Re: is this a bug?
To: icon-group@cs.arizona.edu (Icon Group)
Date: Fri, 22 Apr 1994 09:58:30 -0700 (MST)
Cc: janpeter@mpi.nl (Jan Peter de Ruiter)
In-Reply-To: <9404221206.AA25564@mpix10.mpi.kun.nl> from "Jan Peter de Ruiter" at Apr 22, 94 01:06:56 pm
X-Mailer: ELM [version 2.4 PL23]
Content-Type: text
Content-Length: 2482      
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Jan Peter de Ruiter proudly drove the following message along the Information SuperHypeway(TM) at breakneck speeds:

> procedure main()
> 	t := table([]) # a table with default element []
> 	every put(t[1],generate(1,5)) # fill t[1], which is empty list
> 	every put(t[2],generate(6,9)) # fill t[2], which is empty list
> 	every(write(!t[1])) # write out all elements of t[1]
> 	write()
> 	every(write(!t[2])) # write out all elements of t[2]
> 	write(ximage(t)) # write out image of t 
> end
> 
> procedure generate(a,b)
> 	every suspend (a to b)
> end

>{Expectation:  t[1] <- [1,2,3,4,5], t[2] <- [6,7,8,9]}
>{Result: (t[1] === t[2]) <- [1,2,3,4,5,6,7,8,9]]}

> Now my question is: have I understood the icon
> semantics wrongly, or is this a bug?

It is part of the semantics, and not a bug.

>If anyone
> understands what is happening here, could (s)he
> please explain?

Let xDefault = the default value of the table (in this case, []).

You were expecting copy(xDefault) to be returned; however, xDefault is
returned instead.  For structure types (lists, records, sets and
tables), operations on expressions that have the same value as
xDefault do their work on the same structure.  In other words, the
compare values operator (===) will always be true when getting the
xDefault element out of the table.

In your case, you never assign anything to the table, so t[1] and t[2]
always return the same default list.


BTW, even if tables had copy semantics for the xDefault element, the
above program still wouldn't work.  Since nothing is ever assigned to
the table, t[1] and t[2] would always return a copy of an empty list,
and the observable result of the above code would be:

	((t[1] <- []) ~=== (t[2] <- []))

[Actually, t[1] and t[2] are never defined; the above is if you did an
assignment like

	t1 := t[1]
	t2 := t[2]

and looked at t1 and t2.]


Just wondering:  can anyone think of a situation where copy semantics
would be desirable?


What you really were expecting is the first time you referenced an
element in a table, copy(xDefault) is assigned to that element.
However, I don't believe that the benefits of this outweigh the
consequences of having these semantics (eg: describing how tables work
and what is and isn't a key of that table would be a nightmare to try
and describe).
-- 
	Nevin ":-)" Liber	nevin@cs.arizona.edu	(602) 293-2799
	                 	                    	 +++ (520) after 3/95
	                 	             office:	(602) 621-1685


From icon-group-sender  Fri Apr 22 16:12:00 1994
Received: by cheltenham.cs.arizona.edu; Fri, 22 Apr 1994 18:01:20 MST
Date: Fri, 22 Apr 1994 16:12:00 -0600 (CST)
From: Chris Tenaglia - 257-8765 <TENAGLIA@MIS.MCW.EDU>
Subject: ff.icn
To: icon-group@cs.arizona.edu
Message-Id: <01HBHB4TC70Y8WYD3G@mis.mcw.edu>
Organization: Medical College of Wisconsin (Milwaukee, WI)
X-Vms-To: IN%"icon-group@cs.arizona.edu"
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; CHARSET=US-ASCII
Content-Transfer-Encoding: 7BIT
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


I haven't seen too many handy doodads recently. I have a unix icon
snippet of code. I guess I was too lazy to figure out the 'find' alias
I'd need, so I pieced together ff (file finder). I wrote it for the
Ultrix unix system. It requires the HOME environmental variable to
search ones directory tree. Don't use it from the root account, and
it only searches the directories beginning at HOME. If you have a
different unix, or your terminal doesn't support ansi highlighting,
you may have to modify some things. It doesn't do regular expressions,
but it does find substrings. Enjoy.

Chris Tenaglia (System Manager) | Medical College of Wisconsin
8701 W. Watertown Plank Rd.     | Milwaukee, WI 53226
(414)257-8765                   | tenaglia@mis.mcw.edu

#
# FILE : FF.ICN
# DESC : This program does a file find.
#        It works only from your home account directory tree.
#        Don't use if you're root or looking beyond your user account.
#        Highlights substring with ansi sequences.
# USE  : ff substr
#
# UPDATE         BY          WHAT
# 22-APR-1994    TENAGLIA    INITIAL WRITE
#
procedure main(param)
  home := getenv("HOME")
  command := "ls -alR " || home
  pipe := open(command,"pr")
  part := param[1] | stop("Nothing to ff!")

  every drip := !pipe do
    {
    if match("/",drip) then 
      {
      home := drip[1:upto(":",drip)]
      next
      }
    file := home || "/" || parse(drip,' ')[-1]      # construct full filename
    if match( ("./" | ".."), file) then next        # skip this junk
    if find(part,file) then                         # case sensitive matching
      {
      drip[46:0]  := ""
      drip      ||:= file
      drip[11:24] := ""
      i           := find(part,drip) - 1            # *** warning ***
      j           := i + *part                      # these lines put ansi
      (drip[j]  ||:= "\e[m") | (drip ||:= "\e[m")   # highlighting around
      drip[i]   ||:= "\e[1m"                        # the matched substring
      write(drip)
      }
    }
  close(pipe)
  end
#
# parse a string into a list using a delimiter
#
procedure parse(line,delims)
  static chars
  chars  := &cset -- delims
  tokens := []
  line ? while tab(upto(chars)) do put(tokens,tab(many(chars)))
  return tokens
  end



From icon-group-sender  Sun Apr 24 16:51:23 1994
Received: by cheltenham.cs.arizona.edu; Sun, 24 Apr 1994 13:53:14 MST
From: <janpeter@mpi.kun.nl>
Message-Id: <9404241551.AA17073@mpix10.mpi.kun.nl>
To: icon-group@cs.arizona.edu
Subject: Re: is this a bug? 
Date: Sun, 24 Apr 94 16:51:23 +0100
X-Mts: smtp
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

First of all, thank you for the help in understanding
Icon table / list semantics. I now see what the problem
was.

Nevin Liber writes:
> Jan Peter de Ruiter proudly drove the following message along the Information SuperHype way(TM) at breakneck speeds:

I can see no indication of "proudness" in my posting. I specifically
pointed out that lack of understanding of Icon on my part is a
potential cause for my problem. 

As John David Stone (stone@math.grin.edu) and Steve Wampler
(swampler@noao.edu) also pointed out, the thing I didn't realize
is that the initialisation 
	t := table([])
makes all table entries point at the *same* empty list.

Well, I understand now, but I must honestly say I don't 
like it. The denotation [] looks like a *value* to me,
but it isn't. 

I see that the statement

	l1 := l2 := list()

will make "pointers" to the same list, and I can appreciate
the performance reasons behind this. What I don't like it
the difference between initialisation and assignment in
tables, for it can lead to confusing effects. 

For example, the following fragments do not have the same
meaning:

# first fragment
t := table([])
put(t[1],"john")
put(t[2],"mary")

# second fragment
t := table([])
t[1] |||:= ["john"]
t[2] |||:= ["mary"]

Which is a pity, I think, for a higher level language where
you're supposed to be free of these details. This is the kind
of problem I expect to have in C++, but not in Icon.

But I am fully aware of the fact that I'll have to live with it.
And I can live with it, now I know what's going on.

Greetings,

Jan


From icon-group-sender  Thu Apr 21 06:30:52 1994
Received: by cheltenham.cs.arizona.edu; Sun, 24 Apr 1994 13:54:22 MST
Path: ucbvax!agate!ihnp4.ucsd.edu!swrinde!emory!europa.eng.gtefsd.com!MathWorks.Com!noc.near.net!hopscotch.ksr.com!tim
From: tim@ksr.com (Tim Peters)
Newsgroups: comp.lang.icon
Subject: Re: generate keys of a table?
Message-Id: <2p56is$k0t@hopscotch.ksr.com>
Date: 21 Apr 94 06:30:52 GMT
References: <MIKE.94Apr20181417@majestix.cs.uoregon.edu>
Distribution: inet
Organization: Kendall Square Research
Lines: 36
Nntp-Posting-Host: kaos.ksr.com
Apparently-To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

mike@majestix.cs.uoregon.edu (Mike Haertel) writes:

>Is there a way to enumerate keys of a table (not the entries)?

"key" is builtin generator that does what you're after.  See "The Icon
Programming Language", 2nd edition, pgs 74-75.  If you have a very old
version of Icon, "key" might not be in it.

Here's an example:

procedure main()
   local t, i
   t := table()
   every i := 1 to 10 do t[i] := "abcdefghij"[i]
   every writes( right(!t, 3) )
   write()
   every writes( right(key(t), 3) )
   write()
end

And here's its output:

  e  b  j  g  d  a  i  f  c  h
  5  2 10  7  4  1  9  6  3  8

key(table) generates table's keys in an arbitrary order, but so long as
you don't fiddle with table in the meantime, it's the same arbitrary
order that !table uses for generating table's entries.

BTW, I believe that if Dr. Griswold had it to do all over again, !table
would generate keys instead of entries.

why-languages-should-be-implemented-but-never-used<wink>-ly y'rs  - tim

Tim Peters   tim@ksr.com
not speaking for Kendall Square Research Corp


From icon-group-sender  Mon Apr 25 08:12:44 1994
Received: by cheltenham.cs.arizona.edu; Mon, 25 Apr 1994 09:25:47 MST
Date: Mon, 25 Apr 94 08:12:44 PDT
From: kwalker@sirtur.premenos.com (Ken Walker)
Message-Id: <9404251512.AA00951@sirtur.premenos.com>
To: icon-group@cs.arizona.edu
Subject: pointer semantics
X-Sun-Charset: US-ASCII
Content-Length: 1002
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

> From: <janpeter@mpi.kun.nl>
> Subject: Re: is this a bug? 
> 
> For example, the following fragments do not have the same
> meaning:
> 
> # first fragment
> t := table([])
> put(t[1],"john")
> put(t[2],"mary")
> 
> # second fragment
> t := table([])
> t[1] |||:= ["john"]
> t[2] |||:= ["mary"]
> 
> Which is a pity, I think, for a higher level language where
> you're supposed to be free of these details

A simplified example is:

   L := []
   put(L, "john")

   L := []
   L |||:= ["john"]

In the first case, you are modifying the list and in the second case you
are constructing a new list and assigning it to L. The "problem" is
inherent in an imperative language with pointer semantics. While it is
true that efficiency is one reason for having pointer semantics, pointer
semantics is also very convenient. You can modify part of a complex
data structure without being forced to rebuild the whole thing and pass
the changes on to everything that needs it.

   Ken Walker, kwalker@premenos.com


From icon-group-sender  Mon Apr 25 13:32:10 1994
Received: by cheltenham.cs.arizona.edu; Mon, 25 Apr 1994 12:37:11 MST
From: "Art Eschenlauer" <eschen@molbio.cbs.umn.edu>
Message-Id: <9404251832.AA02971@molbio.cbs.umn.edu>
Subject: tables, lists, and memory question
To: icon-group@cs.arizona.edu
Date: Mon, 25 Apr 94 13:32:10 CDT
X-Mailer: ELM [version 2.3test PL26]
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


I've been wondering for some time now about how (if) Icon knows what
things to trash.

For instance, if I have a function that calls table() and assigns it
to a pointer, can that function return that pointer (return, not
suspend) such that the table is accessible from the calling program?
If so, and I stuff the table full and use it and then have no more
use for it, is there a way to dispose of the table, e.g., untable(pointer)
or something? Or is the best I can do
every (thetable(key(thetable)) := 0)?

The same question goes for lists that are members of other lists, e.g.,
suppose I say 
thelist := [ [5], [6], [7] ] ; thelist := []
What happens to the memory containing lists [5], [6], and [7] ?

Thanks,
Art Eschenlauer


From icon-group-sender  Mon Apr 11 06:55:08 1994
Received: by cheltenham.cs.arizona.edu; Mon, 25 Apr 1994 18:01:27 MST
Path: ucbvax!cis.ohio-state.edu!magnus.acs.ohio-state.edu!usenet.ins.cwru.edu!eff!news.umbc.edu!europa.eng.gtefsd.com!howland.reston.ans.net!cs.utexas.edu!swrinde!elroy.jpl.nasa.gov!ncar!noao!CS.Arizona.EDU!pimacc.pima.edu!east.pima.edu!rharwood
From: rharwood@east.pima.edu
Newsgroups: comp.lang.icon
Subject: VMS non-DECwindows .EXE files wanted
Message-Id: <1994Apr10.235508.1@east.pima.edu>
Date: 11 Apr 94 06:55:08 GMT
Lines: 11
Nntp-Posting-Host: east
Nntp-Posting-User: rharwood
Apparently-To: icon-group@cs.arizona.edu
Status: RO
Errors-To: icon-group-errors@cs.arizona.edu

Does anyone have a set of VMS executables that dos NOT need the DECwindows
library?  I've got a VAX without DECwindows support installed, and really don't
want to have to rebuild the whole ball of wax if I can help it.

Thanks in advance,
Ray
-----
Ray Harwood         |Data Basix             || Adjunct Faculty, East Campus, 
Voice: (602)721-1988|PO Box 18324           ||     Pima Community College
FAX:   (602)721-7240|Tucson, AZ 85731       || Instructor in Ada and Pascal
           Internet:|rharwood@Data.Basix.COM|| rharwood@east.pima.edu


From icon-group-sender  Tue Apr 26 06:35:08 1994
Received: by cheltenham.cs.arizona.edu; Tue, 26 Apr 1994 08:58:23 MST
Date: Tue, 26 Apr 1994 06:35:08 -0600 (CST)
From: Chris Tenaglia - 257-8765 <TENAGLIA@MIS.MCW.EDU>
Subject: VMS executables
To: icon-group@cs.arizona.edu
Message-Id: <01HBMD6KK6NM8WVZ96@mis.mcw.edu>
Organization: Medical College of Wisconsin (Milwaukee, WI)
X-Vms-To: IN%"icon-group@cs.arizona.edu"
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; CHARSET=US-ASCII
Content-Transfer-Encoding: 7BIT
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


VMS icon has some compatibility problems since the X-stuff was added.
If you have the source and a c compiler you can edit

[icon.src.h]config.h

and there's an xwindows switch you can change and then rebuild the
package. But there is another problem with vms icon. There is at
least one byte value it can't write. Here's a sample...

procedure main()
  xff := char(255)  # or \377 or \xff or string(&cset)[-1]
  write(xff)
  end

I've found that you have to go back to Icon V8.6 to get that to run.
Otherwise you get some I/O error. Does the Icon Project still have
it? Will it be fixed in Icon V9? I could try to FTP my V8.6 (bins),
but I'm not sure what the procedure is to pack these and put them
the anon ftp area there. It would be kinder to bandwidth to have  the
icon project to place the older version out there too. V8.10 is ok
for X if you don't need to write X'FF'. Anyone else having similar
problems? I'm using VMS 5.5.

Chris Tenaglia (System Manager) |  "The past explained,     
Medical College of Wisconsin    |   the future fortold, 
8701 W. Watertown Plank Rd.     |   the present largely appologized for."
Milwaukee, WI 53226             |   Organon to The Doctor
(414)257-8765                   |     
tenaglia@mis.mcw.edu



From icon-group-sender  Wed Apr 27 02:04:53 1994
Received: by cheltenham.cs.arizona.edu; Wed, 27 Apr 1994 08:39:26 MST
Date: Wed, 27 Apr 94 06:56:03 BST
From: spuddy!cross (Mike Cross)
Message-Id: <9404270556.AA04111@spuddy>
To: icon-group@cs.arizona.edu
Subject: Icon for Solaris V2.x
Status: R
Errors-To: icon-group-errors@cs.arizona.edu



Has anyone produced a set of configuration files for Icon 
under Solaris V2.x for Sparc or x86?

Thanks

Mike Cross
cross%spuddy@britain.eu.net



From icon-group-sender  Wed Apr 27 15:40:08 1994
Received: by cheltenham.cs.arizona.edu; Wed, 27 Apr 1994 08:58:43 MST
Date: Wed, 27 Apr 94 15:40:08 +0200
From: karczma@univ-caen.fr (Jerzy Karczmarczuk)
Message-Id: <9404271340.AA00697@milou.univ-caen.fr>
To: icon-group@cs.arizona.edu
Subject: Details, please...
Status: RO
Errors-To: icon-group-errors@cs.arizona.edu


Dear gentlemen,

(last time when I began my letter in such a way, some 
 anti-sexists accused me of -- frankly, I don't remember exactly
 what, because I am still laughing...
 
 This time, hopefully, you will forgive me. I cannot address ladies
this time.)

I have on my desk The Icon Newsletter, no. 44.

Look at the page 2, the SNOBOL4 Corner.

We read:

..."For years, there's been talk about a C implementation of SIL, but nothing
has ever materialized --- until now.

Phil Budne has mastered the task. His implementation of SNOBOL4, which he
has placed in the pubic domain, presently runs..."
             ----------------


Yours truly

Jerzy Karczmarczuk, Dept. of Comp. Sci., Univ of Caen, France.


From icon-group-sender  Wed Apr 27 08:48:03 1994
Received: by cheltenham.cs.arizona.edu; Wed, 27 Apr 1994 09:01:12 MST
Date: Wed, 27 Apr 94 08:48:03 PDT
From: kwalker@sirtur.premenos.com (Ken Walker)
Message-Id: <9404271548.AA01384@sirtur.premenos.com>
To: icon-group@cs.arizona.edu
Subject: Re: tables, lists, and memory question
X-Sun-Charset: US-ASCII
Content-Length: 1871
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

> From: "Art Eschenlauer" <eschen@molbio.cbs.umn.edu>
> 
> 
> I've been wondering for some time now about how (if) Icon knows what
> things to trash.

Icon does its own storage management within the memory it malloc()s. When
it does not have room to allocate an object within the memory it has, it
performs a garbage collection to try to recover unused space before it
malloc()s more memory. To perform garbage collection, it starts from a
"basis" of locations that the Icon program can access, for example, the
program's variables, marking things that can be reached. For data types with
pointer semantics, it follows pointers until it reaches an end or reaches
something that has already been marked. When it has marked everything that
the program might use in the future, it can "free" everything else and
compact its allocated memory, relocating pointers to objects it moves.

Icon's garbage collection is not perfect, but it is conservative. It may
save a few things it doesn't need to. There is a rather subtle example.
If I remember correctly, it is something like:

procedure p()
   local c

   c := create write("Hi")
   c := create write("Bye")
   # do something that causes garbage collection
end 

Internally, the second co-expression get a copy of the variable c with
a reference to the first co-expression even thought it doesn't use the
variable c. There is no way to activate the first co-expression, but
the garbage collector will save it. Dispite a few holes like this, the
Icon interpreter is pretty good about only keeping things that might still
be accessed by the Icon program. The Icon compiler is a little sloppier
about it. It may leave things in temporary variables that are no longer
needed and the garbage collector will assume that they are needed. However,
in practice this doesn't seem to be a problem.

   Ken Walker, kwalker@premenos.com


From icon-group-sender  Wed Apr 27 09:10:35 1994
Received: by cheltenham.cs.arizona.edu; Wed, 27 Apr 1994 13:37:02 MST
Date: Wed, 27 Apr 1994 09:10:35 MST
From: "Cliff Hathaway" <cliff>
Message-Id: <199404271610.AA11286@cheltenham.cs.arizona.edu>
To: icon-group@cs.arizona.edu, spuddy!cross
Subject: Re:  Icon for Solaris V2.x
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

> From: spuddy!cross (Mike Cross)
> To: icon-group@cs.arizona.edu
> Subject: Icon for Solaris V2.x
> 
> Has anyone produced a set of configuration files for Icon 
> under Solaris V2.x for Sparc or x86?
> 
> Thanks
> 
> Mike Cross
> cross%spuddy@britain.eu.net

The latest Unix distribution of Icon (8.10) has configuration directories 
for Sun 4's running Solaris 2.x, using the Sun C compiler, CenterLine C,
and gcc.  It's available via anonymous ftp from ftp.cs.arizona.edu:
/icon/packages/unix/unix_tar.Z.  Also available on 3.5" DSHD diskettes
for $25 (+ $5 shipping to addresses outside of the U.S., Canada and Mexico).
Other media for the Unix distribution are QIC24 cartridge ($45+$10) and
9-track 1/2" tape ($30+$10).

Ordering info:

  Icon Project
  Computer Science Dept.
  University of Arizona
  Tucson AZ   85721
  USA

  voice:  (602) 621-8448
  fax:    (602) 621-4246
  email:  icon-orders@cs.arizona.edu

I'm not aware of any configuration for the x86 Solaris.


    Cliff Hathaway, Icon Project
    Dept. of Computer Science (602)621-4291
    University of Arizona     cliff@cs.arizona.edu 	        (internet) 
    Tucson, Ariz. 85721	      {cmcl2,noao,uunet}!arizona!cliff	(uucp)




From icon-group-sender  Sun May  1 21:20:11 1994
Received: by cheltenham.cs.arizona.edu; Sun, 1 May 1994 18:53:48 MST
Path: ucbvax!dog.ee.lbl.gov!ihnp4.ucsd.edu!swrinde!ringer!jeffery
From: jeffery@ringer.cs.utsa.edu (Clinton L. Jeffery)
Newsgroups: comp.lang.icon
Subject: Re: Icon in May94 BYTE Magazine -- what else & Windows?
Message-Id: <1994May1.212011.27547@ringer.cs.utsa.edu>
Date: 1 May 94 21:20:11 GMT
References: <2pvb7c$hel@redstone.interpath.net>
Distribution: inet
Organization: Univ of Texas at San Antonio
Lines: 14
Apparently-To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

> Is the NT version going to come out with the Windows version or are
> they separate?

We are "committed" to delivering a Win32 binary.  We hope it will run
under plain Windows 3.1 with Microsoft's Win32s compatibility library.

Running Win32 applications on Windows 3.1 doesn't work well on slower machines,
so we are also looking into producing a Win16, native Windows 3.1 binary, and
will do so if the development tools and our limited resources allow.

-- 
Clint Jeffery
cjeffery@cs.arizona.edu, jeffery@ringer.cs.utsa.edu
The University of Texas at San Antonio


From icon-group-sender  Mon May  2 22:09:38 1994
Received: by cheltenham.cs.arizona.edu; Mon, 2 May 1994 19:39:30 MST
Path: ucbvax!dog.ee.lbl.gov!ihnp4.ucsd.edu!swrinde!ringer!jeffery
From: jeffery@ringer.cs.utsa.edu (Clinton L. Jeffery)
Newsgroups: comp.lang.icon
Subject: Re: Icon in May94 BYTE Magazine -- what else & Windows?
Message-Id: <1994May2.220938.20367@ringer.cs.utsa.edu>
Date: 2 May 94 22:09:38 GMT
References: <1994May2.093307.5443@driftwood.cray.com>
Distribution: inet
Organization: Univ of Texas at San Antonio
Lines: 12
Apparently-To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

David S. Cargo writes:
> I was wondering how fonts were being handled in a portable way between
> the X Windows System and Microsoft Windows.

We define a portable syntax for font names, and translate that into
appropriate system fonts.  And we define four portable font names that are
known on all systems, covering the combinations of (fixed/proportional
spacing) and (serif/sans serif).
-- 
Clint Jeffery
cjeffery@cs.arizona.edu, jeffery@ringer.cs.utsa.edu
The University of Texas at San Antonio


From icon-group-sender  Tue May  3 19:17:11 1994
Received: by cheltenham.cs.arizona.edu; Tue, 3 May 1994 18:33:22 MST
Path: ucbvax!agate!howland.reston.ans.net!vixen.cso.uiuc.edu!uchinews!ellis!goer
From: goer@ellis.uchicago.edu (Richard L. Goerwitz)
Newsgroups: comp.lang.icon
Subject: Re: Spitbol vs. Icon
Keywords: Spitbol, ICON, pattern
Message-Id: <1994May3.191711.12437@midway.uchicago.edu>
Date: 3 May 94 19:17:11 GMT
References: <Cp8GJ4.G7y@world.std.com>
Sender: news@bluebird.uchicago.edu (News System)
Reply-To: goer@midway.uchicago.edu
Organization: University of Chicago
Lines: 20
Apparently-To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

In article <Cp8GJ4.G7y@world.std.com> sgmlsh@world.std.com (John Smith) writes:

>The headline says it all.... I've gotten used to the GOTO... In fact, I 
>enjoy it, now.... So Spitbol's lack of control structures doesn't bother 
>me. But switching to a language where I would lose all my lovingly built 
>up patterns would bother me a lot! 
>
>So how does Spitbol's pattern matching compare with Icon's? Could one map 
>directly to the other?

No.  Don't switch if you are looking for Snobol or Spitbol under a dif-
ferent name.  Some of the basic design principles are similar.  But scan-
ning happens on a much lower level in Icon.  And the overall program or-
ganization it enforces is more in line with post-Algol, procedural lang-
uages than with older label/goto-style ones.

-- 

   -Richard L. Goerwitz              goer%midway@uchicago.bitnet
   goer@midway.uchicago.edu          rutgers!oddjob!ellis!goer


From icon-group-sender  Wed Apr 20 09:05:17 1994
Received: by cheltenham.cs.arizona.edu; Wed, 4 May 1994 09:02:21 MST
Path: ucbvax!cis.ohio-state.edu!math.ohio-state.edu!howland.reston.ans.net!cs.utexas.edu!chpc.utexas.edu!news.utdallas.edu!corpgate!bnrgate!bnr.co.uk!pipex!uknet!bcc.ac.uk!link-1.ts.bcc.ac.uk!ucgadkw
From: ucgadkw@ucl.ac.uk (Dominik Wujastyk)
Newsgroups: comp.lang.icon
Subject: Re: Icon in BYTE Magazine
Message-Id: <1994Apr20.090517.31854@ucl.ac.uk>
Date: 20 Apr 94 09:05:17 GMT
References: <2p16lc$61f@amhux3.amherst.edu>
Distribution: inet
Organization: University College London
Lines: 15
Apparently-To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

kehandle@unix.amherst.edu (KEITH EDWARD HANDLEY) writes:

>The new BYTE (May, 1994) has an article by Ralph Griswold that is
>an introduction to Icon.  Pages 193-200 (but there are quite a few
>ads in there).

That's nice.  The last one (on Snobol) was in the 1985 Byte.  I bought 
that issue, which focussed on text processing, and there were a couple
of pieces on TeX too, including a brief interview with Knuth, which
started me down that slippery slope.  I still haven't recovered (but
I have some nice books to show for it).       

I wonder what else is in the May 94 Byte?

Dominik


From icon-group-sender  Wed May  4 13:47:52 1994
Received: by cheltenham.cs.arizona.edu; Wed, 4 May 1994 12:28:50 MST
From: "Art Eschenlauer" <eschen@molbio.cbs.umn.edu>
Message-Id: <9405041847.AA05442@molbio.cbs.umn.edu>
Subject: pattern searching for molecular biology
To: icon-group@cs.arizona.edu
Date: Wed, 4 May 94 13:47:52 CDT
X-Mailer: ELM [version 2.3test PL26]
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

I have a molecular biology problem that I am trying to solve with Icon.
It boils down to pattern searching. I suppose I should look up pattern
matching algorithms in a real comp sci book, but if you wish to read
further....

Genes consist of strings of bases A,C,G, and T. I want to look for patterns
in those strings (patterns that are recognized by enzymes that cut the
DNA at specific sequences in the DNA). So, I have a file of about 200
different recognition sequences, e.g., EcoRI is an enzyme that recognizes
and cuts at GAATTC sequences. Additionally, some of those recog seqs are
redundant; for example, StyI recognizes CCWWGG, where W = A|T, and MslI
recognizes CAYNNNNRTG, where Y = C|T, R = A|G, and N = A|C|G|T. Many recog
seqs are about 6 bases, but they range from 4 to 15 bases.

I want a way to match these sequences that is efficient with memory and
time. What is the FASTEST way to do this in Icon? The FIRST way that I
can think of doing it is with string invocation, e.g.,

# &subject has gene sequence, and recog sites are found using
#   every i := find( 
#      ((site := SiteGeneratorFunction())[1:2])( site[2:0] )
#      ) do { whatever }
# # the [1:2] substring is taken to produce 
# #    the 1 char name of the procedure to be invoked

# ... declare procedures A,B,C,D,G,H,K,M,N,R,S,T, and W

procedure Y(RestOfSite)
   if RestOfSite == "" then return ""
   suspend ( move(1) == ("C"|"T") ) || 
      (RestOfSite[1:2])( RestOfSite[2:0] ) 
end

(Please pardon [and point out] any gross errors ... I'm do not
have perfect understanding of string scanning and generators yet.)

Will that be fast? Is there a faster algorithm that is obvious or some
feature of Icon that I am missing? I hesitate to use coexpressions, since,
for example, CAYNNNNRTG would produce 2^2 * 4^4 = 1024 results! 


From icon-group-sender  Wed May  4 16:15:02 1994
Received: by cheltenham.cs.arizona.edu; Wed, 4 May 1994 15:36:16 MST
Path: ucbvax!agate!howland.reston.ans.net!europa.eng.gtefsd.com!MathWorks.Com!news.kei.com!ub!galileo.cc.rochester.edu!rochester!rit!nmw1638
From: nmw1638@cs.rit.edu (Nicolas M Williams)
Newsgroups: comp.lang.icon
Subject: Re: Spitbol vs. Icon
Message-Id: <1994May4.161502.9405@cs.rit.edu>
Date: 4 May 94 16:15:02 GMT
References: <Cp8GJ4.G7y@world.std.com> <1994May3.191711.12437@midway.uchicago.edu> <Cp8yyL.152@stortek.com>
Sender: news@cs.rit.edu (USENET News Admin)
Organization: Rochester Institute of Technology, Rochester, NY
Lines: 29
Nntp-Posting-Host: iowa
Apparently-To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

In article <Cp8yyL.152@stortek.com> cheyenne@witsend.stortek.com (Cheyenne Wills) writes:

>Actually -- if you want the pattern matching power of Snobol/Spitbol
>and the "control" structures of Icon, you might want to look at Rebus
>(available from the University of Arizona's anonymous FTP area I
>believe in the icon/misc? snobol/??? directories).

>Rebus is a hybrid language that takes Iconish control statements
>(sorry no generators, co-expressions, etc.) and spits out Snobol
>source code.  It provides
easy "access" to Snobol's pattern
>matching facilities.

What about Icon library routines for handling regular expressions? I'd
love something like that, Icon would leave perl in the dust....

>Cheyenne

Nick


From icon-group-sender Wed May  4 15:36 MST 1994
Received: from cheltenham.cs.arizona.edu (cheltenham.CS.Arizona.EDU [192.12.69.60]) by owl.CS.Arizona.EDU (8.6.7/8.6.6) with SMTP id PAA08122 for <gmt@owl>; Wed, 4 May 1994 15:36:34 -0700
Received: by cheltenham.cs.arizona.edu; Wed, 4 May 1994 15:35:18 MST
Date: Wed, 4 May 94 15:18:09 CDT
From: jeffery@ringer.cs.utsa.edu (Clinton L. Jeffery)
Message-Id: <9405042018.AA01224@ringer.cs.utsa.edu.sunset>
To: eschen@molbio.cbs.umn.edu
Cc: icon-group@cs.arizona.edu
In-Reply-To: "Art Eschenlauer"'s message of Wed, 4 May 94 13:47:52 CDT <9405041847.AA05442@molbio.cbs.umn.edu>
Subject: pattern searching for molecular biology
Status: R
Errors-To: icon-group-errors@cs.arizona.edu
Content-Type: text
Content-Length: 731

I am sure there will be a lot of good suggestions in this group, so I'll
limit myself to a couple quick thoughts.

First of all, you may find it runs faster and uses less memory if you allow
the built-in functions and operators (such as match()) do as much of your
work for you as possible, instead of peeling off characters one at a time
and doing a procedure call and a suspension for every character.  By the
way, s[1:2] is just a long-winded way of saying s[1].

Second, you may find it runs faster and uses less memory if you make more
effective use of the data structures available to you--lists of strings,
lists of lists, tables of tables--to encode some of what you are doing
with the logic in all that handwritten code.


From icon-group-sender  Thu Apr 21 06:23:11 1994
Received: by cheltenham.cs.arizona.edu; Thu, 5 May 1994 10:47:37 MST
Path: ucbvax!cis.ohio-state.edu!math.ohio-state.edu!howland.reston.ans.net!news.moneng.mei.com!hookup!ames!ncar!noao!CS.Arizona.EDU!not-for-mail
From: nevin@cs.arizona.edu (Nevin Liber)
Newsgroups: comp.lang.icon
Subject: Re: generate keys of a table?
Message-Id: <2p564f$jpe@caslon.CS.Arizona.EDU>
Date: 21 Apr 94 06:23:11 GMT
References: <MIKE.94Apr20181417@majestix.cs.uoregon.edu>
Organization: University of Arizona CS Department, Tucson AZ
Lines: 9
Nntp-Posting-Host: caslon.cs.arizona.edu
Apparently-To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

In article <MIKE.94Apr20181417@majestix.cs.uoregon.edu>,
Mike Haertel <mike@majestix.cs.uoregon.edu> wrote:
>Is there a way to enumerate keys of a table (not the entries)?

Yes.  The built in function key(T) will generate the keys in table T.
-- 
	Nevin ":-)" Liber	nevin@cs.arizona.edu	(602) 293-2799
	                 	                    	 +++ (520) after 3/95
	                 	             office:	(602) 621-1685


From icon-group-sender  Thu May  5 13:47:56 1994
Received: by cheltenham.cs.arizona.edu; Thu, 5 May 1994 12:24:29 MST
Date: Thu, 05 May 1994 13:47:56 -0600 (CST)
From: Chris Tenaglia - 257-8765 <TENAGLIA@MIS.MCW.EDU>
Subject: Bueno Cinco de Mayo
To: icon-group@cs.arizona.edu
Message-Id: <01HBZCVUT89U8WWD9C@mis.mcw.edu>
Organization: Medical College of Wisconsin (Milwaukee, WI)
X-Vms-To: IN%"icon-group@cs.arizona.edu"
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; CHARSET=US-ASCII
Content-Transfer-Encoding: 7BIT
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


For the Cinco de Mayo I'd like to offer a little Icon code segment.
This one was developed for unix (namely ultrix 4.3 rev 44). Maybe
it will work on some other unix too. I'd like to know. This program
is called 'when'. It's like a date based ls command. Some have told
me 'find' can do the same things, but I find find a bit arcane?

So 'when' is what I use. Here are some samples :

     Csh% when before 4/12/92      files before a date
     Csh% when before 300          files older than an age
     Csh% when after 3/25          or younger than a date this year
     Csh% when before 2/1/94 and after 10/31/93     even a range

More options and clauses are supported. Look at the code for clues.
This one only works in the current directory. It also has an interesting
property. Maybe this is just ultrix, maybe not, I'd like to know anyway...
The interpreted version works fine, but the compiled version has a
numeric overflow. That'll make for some fun debugging. I wrote it for
myself as a tool to locate old files for archiving or deleting. Study and
enjoy!

Chris Tenaglia (System Manager) |  "The past explained,     
Medical College of Wisconsin    |   the future fortold, 
8701 W. Watertown Plank Rd.     |   the present largely appologized for."
Milwaukee, WI 53226             |   Organon to The Doctor
(414)257-8765                   |     
tenaglia@mis.mcw.edu

#
# file : when.icn
# desc : date based ls command for unix
# use  : iconx when [to|before __] [from|since __] [asc | des] [long|brief] [do __]
#        brief output pipable to rm and others
#        long will include day age, but not protection mask
# spec : ls -al layout : month@33:3 day@37:2 yr@41:2|current
#
# update          by          what
# 06-apr-1994     tenaglia    initial write
#
global base,      # 1970 calculation baseline number
       today,     # displacement from 12:00:01am today
       now,       # upto the second mark for right now
       method,    # ascending or descending order
       output,    # long (ls -al) or brief (ls -1) style
       command,   # optional command to do on each file
       files      # list with files, sizes, and ages

procedure main(param)
  calc_today()
  files   := directory()
  method  := "none"
  output  := "long"
  command := ""
  if *param = 0 then show_age()
  every i := 1 to *param do
    {
    (option := param[i]) | break
    case option of
      {
      "to"     |
      "before" |
      "until"   : {
                  files := before(files,param[i+1])
                  i    +:= 1
                  }
      "from"  |
      "since" |
      "after"   : {
                  files := since(files,param[i+1])
                  i    +:= 1
                  }
      "asc"     : method:="ascending"
      "des"     : method:="descending"
      "long"    : output:="long"
      "brief"   : output:="brief"
      "do"      : {
                  every j := i+1 to *param do
                    command ||:= param[j] || " "
                  }
      default   : 5    # stop("Unrecognized option :",option)
      }
    }
  show_age()
  end

#
# just show another ls with days old numbers & optionally sorts
#
procedure show_age()
  case method of
    {
    "none" : {  
             every line := !files do
               {
               age := (today - parse(line,' ')[1]) / 86400
               ks  := parse(line,' ')[2] / 1024
               file:= line[23:0]
               (command == "") |
                 {
                 write(command,line[37:0])
                 system(command || line[37:0])
                 next
                 }
               if output == "brief" then text := line[37:0]
                                    else text:= right(age,6) || " days " || right(ks,6) || " kb | " || file
               write(text)
               }
             }
    "descending" : {
                   results := sort(files)
                   every line := !results do
                     {
                     age := (today - parse(line,' ')[1]) / 86400
                     ks  := parse(line,' ')[2] / 1024
                     file:= line[23:0]
                     (command == "") |
                       {
                       write(command,line[37:0])
                       system(command || line[37:0])
                       next
                       }
                     if output == "brief" then text := line[37:0]
                                          else text:= right(age,6) || " days " || right(ks,6) || " kb | " || file
                     write(text)
                     }
                   }
    "ascending" : {
                   results := sort(files)
                   every i := *results to 1 by -1 do
                     {
                     line:= results[i]
                     age := (today - parse(line,' ')[1]) / 86400
                     ks  := parse(line,' ')[2] / 1024
                     file:= line[23:0]
                     (command == "") |
                       {
                       write(command,line[37:0])
                       system(command || line[37:0])
                       next
                       }
                     if output == "brief" then text := line[37:0]
                                          else text:= right(age,6) || " days " || right(ks,6) || " kb | " || file
                     write(text)
                     }
                   }
    default : 5
    }
  end

#
# remove elements later than a date
#
procedure before(lst,days)
  static  mtab
  initial mtab := [0,31,59,90,120,151,181,212,243,273,304,334]
  if find("/",days) then
    {
    mo := parse(days,'/')[1]
    da := parse(days,'/')[2]
    yr := parse(days,'/')[3] | parse(&date,'/')[1]
    if yr < 100 then yr +:= 1900
    tmp := yr * 31557600
    dd  := mtab[mo] + da
    if ((yr % 4) = 0) & (mo > 2) then dd +:= 1
    tmp+:= dd * 86400
    age := tmp
    } else {
    age := now - (days * 86400)
    }
  work := []
  every file := !lst do
    {
    old := parse(file,' ')[1]
    if old <= age then put(work,file)
    }
  return copy(work)
  end

#
# remove elements earlier than a date
#
procedure since(lst,days)
  static  mtab
  initial mtab := [0,31,59,90,120,151,181,212,243,273,304,334]
  if find("/",days) then
    {
    mo := parse(days,'/')[1]
    da := parse(days,'/')[2]
    yr := parse(days,'/')[3] | parse(&date,'/')[1]
    if yr < 100 then yr +:= 1900
    tmp := yr * 31557600
    dd  := mtab[mo] + da
    if ((yr % 4) = 0) & (mo > 2) then dd +:= 1
    tmp+:= dd * 86400
    age := tmp
    } else {
    age := now - (days * 86400)
    }
  work := []
  every file := !lst do
    {
    old := parse(file,' ')[1]
    if old >= age then put(work,file)
    }
  return copy(work)
  end

#
# calculate today and now figures
#
procedure calc_today()
  static  mtab
  initial {
          base := 1970*31557600
          mtab := [0,31,59,90,120,151,181,212,243,273,304,334]
          }
  tmpy := parse(&date,'/')[1]
  tmpm := parse(&date,'/')[2]
  tmpd := parse(&date,'/')[3]
  here := tmpy * 31557600 +
          (mtab[tmpm] + tmpd) * 86400
  if ((tmpy%4) = 0) & (tmpm > 2) then here +:= 86400
  today := here
  now   := here +
           parse(&clock,':')[1] * 3600 +
           parse(&clock,':')[2] *   60 +
           parse(&clock,':')[3]
  end

#
# convert a ls -al output into a list for sorting and printing
#
procedure directory()
  static mtab
  initial {
          mtab := table(0)
          mtab["Jan"] := 0
          mtab["Feb"] := 31
          mtab["Mar"] := 59
          mtab["Apr"] := 90
          mtab["May"] := 120
          mtab["Jun"] := 151
          mtab["Jul"] := 181
          mtab["Aug"] := 212
          mtab["Sep"] := 243
          mtab["Oct"] := 273
          mtab["Nov"] := 304
          mtab["Dec"] := 334
          }
  pipe    := open("ls -al","pr")
  entries := []
  every line := !pipe do
    {
    if any('dclst',line) then next   # ignore info and dirs
    size := parse(line,' ')[4]
    file := line[33:0]
    day  := mtab[parse(line,' ')[5]] + parse(line,' ')[6]
    year := if line[40] == " " then parse(line,' ')[7] else parse(&date,'/')[1]
    sec  := if line[40] == " " then 0 else hhmm(parse(line,' ')[7])
    mark := year * 31557600 + day * 86400 + sec
    if (now-mark) < 0 then mark -:= 31557600
    text := right(mark,12) || right(size,10) || " " || file
    put(entries,text)
    }
  close(pipe)
  return entries
  end

#
# convert hh:mm into seconds since midnight
#
procedure hhmm(str)
  hh := str[1+:2]
  mm := str[4+:2]
  return hh*3600 + mm*60
  end

#
# parse a string into a list with respect to a delimiter
#
procedure parse(line,delims)
  static chars
  chars  := &cset -- delims
  tokens := []
  line ? while tab(upto(chars)) do put(tokens,tab(many(chars)))
  return tokens
  end



From icon-group-sender  Fri May  6 03:45:21 1994
Received: by cheltenham.cs.arizona.edu; Fri, 6 May 1994 08:10:48 MST
Path: ucbvax!agate!ihnp4.ucsd.edu!swrinde!ringer!jeffery
From: jeffery@ringer.cs.utsa.edu (Clinton L. Jeffery)
Newsgroups: comp.lang.icon
Subject: Re: help
Message-Id: <1994May6.034521.10430@ringer.cs.utsa.edu>
Date: 6 May 94 03:45:21 GMT
References: <srhee.5.001002EA@asc.upenn.edu>
Distribution: inet
Organization: Univ of Texas at San Antonio
Lines: 16
Apparently-To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

> From article <srhee.5.001002EA@asc.upenn.edu>, by srhee@asc.upenn.edu (JUNE WOONG RHEE):
> Status: R

> Or is there any FRQ about these kinds of language around here?

We have an Icon FAQ, but it is a closely guarded secret and we would
never dream of inadvertently posting it 323+ times to multiple newsgroups
in one-minute intervals!  ;^)

Seriously though, I hope the FAQ appears again some day -- once in *rare*
while, posted by hand or whatever... :-)  But until that day, perhaps someone
will mail you the FAQ (I figure you'll get about 323 copies by e-mail from
various folks, but if no-one sends it to you, send me a note and I'll send
you a copy).
-- 
Clint Jeffery
cjeffery@cs.arizona.edu, jeffery@ringer.cs.utsa.edu
The University of Texas at San Antonio


From icon-group-sender  Fri May  6 16:03:38 1994
Received: by cheltenham.cs.arizona.edu; Fri, 6 May 1994 12:53:55 MST
Path: ucbvax!agate!howland.reston.ans.net!usc!nic-nac.CSU.net!news.Cerritos.edu!news.Arizona.EDU!math.arizona.edu!CS.Arizona.EDU!not-for-mail
From: icon-project@cs.arizona.edu
Newsgroups: comp.lang.icon,comp.answers,news.answers
Subject: Icon Programming Language FAQ
Message-Id: <2qdpoq$od2@optima.cs.arizona.edu>
Date: 6 May 94 16:03:38 GMT
Sender: icon@cs.arizona.edu
Reply-To: icon-project@cs.arizona.edu
Followup-To: comp.lang.icon
Organization: University of Arizona CS Department, Tucson AZ
Lines: 402
Approved: news-answers-request@MIT.Edu
Nntp-Posting-Host: optima.cs.arizona.edu
Apparently-To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Archive-name: comp-lang-icon-faq


    Frequently Asked Questions About The Icon Programming Language

last updated: 03/04/94

This FAQ answers various questions about the Icon programming language,
ranging from what it is to how you can get it.  This first version of the
Icon FAQ is devoted to the issues that are likely to be of most interest
to persons who don't know anything about Icon or who are relatively
new to it.  Future versions of this FAQ will answer questions from
more experienced Icon programmers.

This FAQ is written by Ralph Griswold with help from Cliff Hathaway,
Clint Jeffery, and Gregg Townsend.

Section I -- General Questions:

I.1.   What is Icon?
I.2.   What is Icon good for?
I.3.   Where did Icon come from?
I.4.   What does "Icon" stand for?
I.5.   On what computers does Icon run?
I.6.   Who did all these implementations?
I.7.   Are there other implementations in the works?
I.8.   Are there different versions of Icon?
I.9.   Which implementations of Icon have graphics/window capabilities?
I.10.  Where can I get Icon?
I.11.  Where can I get documentation about Icon?
I.12.  What is the Icon Project?
I.13.  Where can I find examples of Icon programs?
I.14.  What is Idol?
I.15.  How often is material in Icon's FTP area updated?
I.16.  How do I stay up to date with what's going on with Icon?
I.17.  Why isn't the Icon Newsletter available electronically?
I.18.  Is there a users' group for Icon?
I.19.  How do I get technical support?
I.20.  Is there an optimizing compiler for Icon?
I.21.  What do I need to run the interpreter?
I.22.  What do I need to run the compiler?
I.23.  Can I build my own implementation of Icon for a new platform?

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

I.1.   What is Icon?

Icon is a very high level general-purpose programming language with
extensive features for processing strings (text) and data structures.
Icon is an imperative, procedural language with a syntax that is
reminiscent of C and Pascal, but its semantics are at a much higher level
than those languages.

Icon has a novel expression-evaluation mechanism that integrates goal-
directed evaluation and backtracking with conventional control structures.
It has a string scanning facility for pattern matching that avoids 
the tedious details usually associated with analyzing strings. Icon's
built-in data structures include sets and tables with associative lookup,
lists that can be used as vectors or stacks and queues, and records.

Icon is a strongly, though not statically, typed language. It provides
transparent automatic type conversion. For example, if an integer is
used in an operation that requires a string, the integer is automatically
converted to a string.

Several implementations of Icon have high-level graphics facilities with
an easily programmed window interface.

Icon manages storage automatically. Objects are created as needed during
program execution and space is reclaimed by garbage collection as needed.
The sizes of strings and data structures are limited only by the amount
of available memory.


I.2.   What is Icon good for?

As a general-purpose programming language with a large computational
repertoire, Icon can be used for most programming tasks.  It's at
its best when used as a prototyping tool, for processing text, and when
ease of programming is needed for experimental and research applications.

Paradoxically, Icon is used most often for short, one-shot tasks and for very
complex applications.

Icon is designed to make programming easy; it emphasizes the value of
programmer's time and the importance of getting programs to work quickly.
This explains its usefulness for prototyping as well as the apparent
paradox of applicability to simple and complex applications.


I.3.   Where did Icon come from?

Icon is the latest in a series of high-level programming languages designed
to facilitate programming tasks involving strings and structures. The
original language, SNOBOL, was developed at Bell Telephone Laboratories
in the early 60s.  SNOBOL evolved into SNOBOL4, which is still in use.
Subsequent languages were developed at The University of Arizona with
support from the National Science Foundation.

Incidentally, Icon bears little physical resemblance to SNOBOL4, although
it has similar objectives and many similar capabilities.


I.4.   What does "Icon" stand for?

The name Icon (which is not spelled ICON) is not an acronym nor does it
stand for anything in particular, although the word iconoclastic was
mentioned at the time the name was chosen.  The name predates the now
common use of "icon" to refer to small images used in graphical user
interfaces.  This latter usage sometimes causes persons to think mistakenly
that Icon is designed to create or manipulate icons.  There's not much
that can be done about this.


I.5.   On what computers does Icon run?

The implementation of Icon is highly portable. There are versions for
the Acorn Archimedes, the Amiga, the Atari ST, IBM CMS and MVS, the
Macintosh, MS-DOS, OS/2, UNIX, and VMS.  Nearly 60 UNIX platforms are
supported.
Icon programs also are highly portable. Most Icon programs can run on
any platform that supports Icon.


I.6.   Who did all these implementations?

The original implementation of Icon for UNIX was done at The University
of Arizona.  Most of the other implementations originally were done
by volunteers scattered around the world.

It's worth noting that all implementations of Icon are based on the same
source code, which is written in C.  This contributes to the portability 
of Icon itself, as well as to the portability of programs written in Icon.


I.7.   Are there other implementations in the works?

Yes, work is constantly underway on implementations of Icon for new
platforms.  Present projects include Windows NT, Win32, the DEC Alpha
running under UNIX, and a new Macintosh implementation.


I.8.   Are there different versions of Icon?

Icon has evolved through a series of versions with improved and extended
capabilities.  The latest major version number is 8.  Recent changes
and additions, notably in the graphics area, have brought the current
level to 8.10.  (Version 8.11 is, of course, in the works.)  Most
implementations are up to 8.10, although a few for less frequently
used platforms are still at 8.0.  Almost all 8.0 programs will run
under 8.10.


I.9.   Which implementations of Icon have graphics/window capabilities?

Icon's graphics facilities presently are supported on the OS/2, UNIX, and
VMS implementations.  The UNIX and VMS implementations use X, while the
OS/2 implementation uses Presentation Manager.

The NT, Win32, and DEC Alpha implementations that are in progress
will support Icon's graphics facilities.  A Macintosh
implementation to support graphics also is in the works.


I.10.  Where can I get Icon?

Most implementations of Icon are available via anonymous FTP to
cs.arizona.edu in /icon.  The directory /icon/binaries contains executable
versions of Icon for several systems, including several popular UNIX
platforms.  The directory /icon/packages contains source code and
related material.  All directories have READ.ME files with additional
information.

Icon also is available on a variety of physical media for prices ranging
from $15 to $50.  Contact:

	Icon Project
	Department of Computer Science
	The University of Arizona
	Tucson, AZ   85721

	602-621-8448 (voice)
	602-621-4246 (fax)

	icon-orders@cs.arizona.edu (e-mail)

Request a copy of the Icon Newsletter for a listing of what's available
and what the prices are.

Purchases can be made by credit card (MasterCard, Visa, or Discover) or
by check drawn on a bank with a branch in the United States and made
payable to The University of Arizona.


I.11.  Where can I get documentation about Icon?

The definitive work on Icon is the book

	The Icon Programming Language, Griswold and Griswold,
	Prentice-Hall, 1990, 368 pages, ISBN 0-13-447889-4.

This book is a complete description and reference manual for Version 8 of
Icon.

There also is a book on the implementation of Icon:

	The Implementation of the Icon Programming Language, Griswold
	and Griswold, Princeton University Press, 1986, 336 pages, ISBN
	0-691-08431-9.

This book describes the implementation as of Version 6 of Icon.  Although
the implementation has changed somewhat since then, the basic structure
is the same.  Technical reports describing recent implementation changes
are included with books purchased from the Icon Project.

These books are available from the Icon Project or from any book store
that handles special orders.

Additional documentation is available via FTP in /icon/doc.  Notable
documents are:

	TR 90-6	  an overview of Icon
	TR 93-9	  graphics/window facilities
	IPD212	  changes between Versions 8.0 and 8.10

There are manual pages for UNIX systems, but there is no complete
on-line documentation.  
	
The Icon Newsletter, which includes topical material about Icon and
a list of material available from the Icon Project, is published three
times a year.  Subscriptions are free; contact the Icon Project to get
a copy of the latest Newsletter and to be put on the mailing list.

The Icon Analyst, a technically oriented newsletter that features articles
about programming, is published six times a year.  There is a subscription
fee for the Analyst.  A sample copy is available on request.

All back issues of both newsletters are available for purchase.


I.12.  What is the Icon Project?

The Icon Project is a name used by the group at The University of
Arizona that develops, implements, distributes, and supports the
Icon programming language.

The Icon Project is not commercial organization.  It derives support
from The University of Arizona, grants, and (primarily) revenue from
the sale of program material and documentation.


I.13.  Where can I find examples of Icon programs?

There is a large program library for Icon.  It is an excellent resource
for both new and experienced programmers, containing numerous examples of
how to do things with Icon.  The library also provides many useful
applications, as well as hundreds of procedures that supplement Icon's
built-in repertoire.

The library, like other Icon material, is available via FTP (cd /icon/library)
and on physical media from the Icon Project.


I.14.  What is Idol?

Idol is an object-oriented extension to Icon that provides concepts such
as classes and multiple inheritance.  Idol is written in Idol and is
distributed as part of the Icon program library.  Idol runs on almost all
of the platforms that Icon runs on.

Additional Idol information is available from Clint Jeffery,
jeffery@ringer.cs.utsa.edu.


I.15.  How often is material in Icon's FTP area updated?

New material is added when it's available.  Established implementations
usually are only updated when there's a major new release.  This typically
is every year or two.  The Icon program library is updated on a similar
schedule.


I.16.  How do I stay up to date with what's going on with Icon?

The best way to find out about developments related to Icon is to
subscribe to the Icon Newsletter.  It's free, but it is distributed
only by postal mail, so you must provide a mailing address.

You can stay up to date on the source code, which is changed much more
frequently than the version on FTP is updated, by subscribing to the
source update service, which provides a new version about three times
a year.

There also is a subscription service for updates to the Icon program
library, which provides new material three or four times a year.

See the Icon Newsletter for information about subscribing to these
services.


I.17.  Why isn't the Icon Newsletter available electronically?

The Icon Newsletter contains diagrams, images, and other material that
cannot be rendered in plain ASCII text.  The Newsletter is prepared with
a desktop publishing system that produces PostScript, but the files are
enormous -- too large to include in the Icon FTP area.  Selected articles
from the Newsletter are available by FTP in /icon/doc/articles.


I.18.  Is there a users' group for Icon?

There is no official Icon users' group.  The Icon Project maintains an
electronic mailing list, icon-group@cs.arizona.edu.  Mail sent to this address
is forwarded to subscribers.  To subscribe (or unsubscribe), send a
message to icon-group-request@cs.arizona.edu.

There is a gateway between icon-group and comp.lang.icon, an unmoderated
newsgroup for discussing issues related to Icon.  The gateway, which
exchanges messages between the two systems, is imperfect and not under
the control of the Icon Project.

The newsgroup generally provides faster response than the mailing list.
The newsgroup is less intrusive, but it sometimes suffers from inappropriate
postings.  The Icon Project usually sends messages of interest to the
Icon community to icon-group.

I.19.  How do I get technical support?

Free technical support is available from the Icon Project via electronic
mail to icon-project@cs.arizona.edu or by fax, telephone, and postal mail
to the Icon Project as listed above.

Since the Icon Project is not a commercial organization, support is limited
to what it can provide with its available resources.  If the Icon Project
cannot help with a problem (such as for a platform it doesn't have), it will
attempt to provide a contact with someone who can help.


I.20.  Is there an optimizing compiler for Icon?

Yes.  The original implementation was an interpreter.  An optimizing
compiler was added a few years ago.  The interpreter and compiler are
largely source-language compatible.

The interpreter is used by most Icon programmers because it gets into
execution quickly and runs fast enough for most applications.  The compiler
is best suited for applications that require the fastest possible
execution time.  In this case, it's generally best to develop the program
using the interpreter and then compile the final result for production use.


I.21.  What do I need to run the interpreter?

The Icon interpreter will run on most computers.  It requires a reasonable
amount of memory, however.   Under MS-DOS, the Icon interpreter needs
500KB of application RAM to work well.


I.22.  What do I need to run the compiler?

The Icon compiler is another matter.  It requires a C compiler, a fast
CPU for tolerable compilation times, a considerable amount of disk
space, and a lot of memory -- at least several megabytes.

The Icon compiler generates C code, which must then be compiled to
produce an executable program.  The flexibility that Icon provides to
programmers makes compilation technically difficult and the process
requires a large amount of memory.  The C code it produces is voluminous
and stresses the most robust C compilers.

Generally speaking, the Icon compiler is practical for platforms in
the workstation class but not for most personal computers.  Although
the compiler can be built and made to run on 286 platforms running
standard MS-DOS, only trivially small programs can be compiled.  In
principle, the Icon compiler is practical on MS-DOS 386/486 platforms
with extended memory, but the limited availability of suitable 32-bit C
compilers for this environment has discouraged the use of the Icon compiler
on such platforms.


I.23.  Can I build my own implementation of Icon for a new platform?

As mentioned above, Icon is written in C and the source code is available
via FTP and the Icon Project.  The existing implementations are testament
to its portability.  (a small amount of assembly-language code is
required for a context switch, but this is only needed for an optional
feature -- co-expressions -- that can be disabled without affecting most
of Icon.)

New ports involve platform-specific configuration parameters and, in
some cases, platform-specific code.  The feasibility of a new port and
the amount of work it may take depends on the platform -- its architecture,
its C compiler, and its environment.

Ports to new UNIX platforms generally are easy, although novel architecture
may present problems.  Ports to new operating systems generally are
more difficult, especially if Icon's graphics facilities are implemented.

The Icon Project provides what help it can with new ports.  In return, it
asks that code related to the port to be returned to the Icon Project for
inclusion in future versions of the source code for Icon.  This makes the
new port available to others as well as to the porter when Icon is updated.


From icon-group-sender  Fri May  6 14:05:23 1994
Received: by cheltenham.cs.arizona.edu; Fri, 6 May 1994 13:58:54 MST
From: "Art Eschenlauer" <eschen@molbio.cbs.umn.edu>
Message-Id: <9405061905.AA21241@molbio.cbs.umn.edu>
Subject: Call for alpha testers of IClip 0.1 for Mac
To: icon-group@cs.arizona.edu
Date: Fri, 6 May 94 14:05:23 CDT
X-Mailer: ELM [version 2.3test PL26]
Status: RO
Errors-To: icon-group-errors@cs.arizona.edu

I am looking for volunteers to test/try/use IClip, a derivative of
the stand-alone Macintosh version of Icon version 8. The idea is that I
wanted a way to use the superb filtering capabilities of Icon in a
relatively mac-like way from all applications.

IClip reads standard input from the Mac Clipboard, applies an icon
program to it, and writes it back to the clipboard. The Icon programs
used are simply very-slightly-modified ICOD files, the ones iconx uses
in the stand-alone Icon version 8. (The modification is that the creator
is changed from Iconx to IClip.) Thus, new routines can be built and
debugged with the standalone package and then converted to IClip format
AFTER they have been translated. All I do is put the files in my Apple
menu items folder (under system 7). When I want to use them, I simply
copy the text I want filtered to the clipboard from whatever application
I am running (e.g., MSWord), select the filter program off the apple menu
and paste the result whereever I want it. Ultimately, this will form the
core for a set of frequently needed molecular biology routines (translating
mRNA sequence into protein sequence, determining complementary sequences,
formatting sequences for publication, etc.) which are easy to write in Icon
(a lot easier than in C, I must say!).

Version 0.1 alpha is up and running and hasn't crashed yet. If you are inter-
ested in using Icon on your mac for filtering tasks, i.e., without input
from the keyboard, send me email at
eschen@molbio.cbs.umn.edu.

Also, if you know about cool molecular biology routines in Icon that I
could or should convert, please let me know. Thanks.

- Art Eschenlauer


From icon-group-sender  Sat Apr 23 18:17:32 1994
Received: by cheltenham.cs.arizona.edu; Sun, 8 May 1994 22:07:02 MST
Path: ucbvax!cis.ohio-state.edu!math.ohio-state.edu!howland.reston.ans.net!darwin.sura.net!hearst.acc.Virginia.EDU!murdoch!murdoch.acc.virginia.edu!mwb5y
From: mwb5y@cs.virginia.edu (Mark Bailey)
Newsgroups: comp.lang.icon
Subject: Icon and parsers
Message-Id: <MWB5Y.94Apr23131732@cobra.cs.virginia.edu>
Date: 23 Apr 94 18:17:32 GMT
Sender: usenet@murdoch.acc.Virginia.EDU
Organization: Computer Science Department, University of Virginia
Lines: 11
Apparently-To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Does anyone know of a robust (for the most part) parser generator
package for Icon that works in much the same way as yacc? 

I've already got a yacc grammar that I'd rather not take much time to
convert over (recursive decent won't do).

Thanks in advance,
-mwb
--
Mark Bailey       (mark@virginia.edu)
Computer Science, University of Virginia


From icon-group-sender  Mon May  9 07:25:45 1994
Received: by cheltenham.cs.arizona.edu; Mon, 9 May 1994 08:35:53 MST
Path: ucbvax!agate!spool.mu.edu!sgiblab!munnari.oz.au!newsroom.utas.edu.au!cam!lawson!dting
From: dting@lawson.its.utas.edu.au (Donald Chung Ling Ting)
Newsgroups: comp.lang.icon
Subject: get icon
Message-Id: <1994May9.072545.23194@cam.compserv.utas.edu.au>
Date: 9 May 94 07:25:45 GMT
Sender: news@cam.compserv.utas.edu.au
Organization: University of Tasmania
Lines: 4
Apparently-To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


 Hi could someone there teel me where can I get the icon file from ?
or the software which can convert the *.bmp file to *.ico file ? thanks
very much for that !!!


From icon-group-sender  Sat May  7 17:33:23 1994
Received: by cheltenham.cs.arizona.edu; Mon, 9 May 1994 08:36:17 MST
Path: ucbvax!agate!howland.reston.ans.net!europa.eng.gtefsd.com!darwin.sura.net!udel!rochester!rit!nmw1638
From: nmw1638@cs.rit.edu (Nicolas M Williams)
Newsgroups: comp.lang.icon
Subject: Re: Regular expressions & dynamic linking (was Re: Spitbol vs. Icon)
Message-Id: <1994May7.173323.3010@cs.rit.edu>
Date: 7 May 94 17:33:23 GMT
References: <CpC86B.K2C@stortek.com> <1994May5.223307.19549@cs.rit.edu> <CpDx7B.H1o@stortek.com>
Sender: news@cs.rit.edu (USENET News Admin)
Organization: Rochester Institute of Technology, Rochester, NY
Lines: 76
Nntp-Posting-Host: iowa
Apparently-To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

In article <CpDx7B.H1o@stortek.com> cheyenne@witsend.stortek.com (Cheyenne Wills) writes:
>In <1994May5.223307.19549@cs.rit.edu>, nmw1638@cs.rit.edu (Nicolas M Williams) writes:
>>In article <CpC86B.K2C@stortek.com> cheyenne@witsend.stortek.com (Cheyenne Wills) writes:

>Hmmm.... well...
>One of Icon's design goals was (is) to provide a language that is
>fairly easily read.  While one can write unreadable code in any language,
>some languages lend themselves to being more unreadable then others.

Heh, sure, look, there are single characters that have a lot of meaning
in Icon, where their meaning depends on the situation (e.g. / and \).
Plus recursive generators can be hard to figure out. No, Icon can be
very cryptic, which I in particular don't mind very much, after all, I'm
used to C and awk and sed and....

>Regular expressions are themselves a fullblown language, they have
>their place.

They can complement Icon, see below.

>I'm not saying that adding regular expressions to Icon is bad (or good),
>I'm just tring to say that with Icon, one can achive the same end result
>with existing facilities.  In addition, Icon provides some facilities
>that just are not possible under regexps (try extracting "balanced
>strings" -- "(3+4*(5+6)*(10+11))".  With regexps the best you can do
>with the above is:  "(3+4*(5+6)".

Right, now imagine (I haven't seen the regexp library yet) a function
that returns the position of the subject string that marks the first
character of a string matched by a regexp, and another function that
returns the last character of said string provided you give it the
position of the first character of the matched string. That would fit in
quite well into the string scanning environment of Icon. I want regexps
not because they are good enough (which they are not), but because they
can simplify a lot of tasks.

>	In addition a programmer can extend
>string pattern matching with their own functions, something that one
>cannot do with regexps.  Once a useful pattern matching function
>has been built, one can save it for use later without having to
>reinvent it all over.  If I need a pattern to match labels, I have
>an Icon function already coded that will do that.  If I need a pattern
>to match "real numbers", I already have that, etc.

Yes, indeed, I have done this. So? Replacing a well commented regexp is
not that hard; I've done that too.

>Maintainability is always an issue.  Even "throw-a-way" code has a
>tendancy to live a life longer then the author may have intended.

Yes, but regexps are seldom huge (several lines long), and if their
actions are well commented, replacing that regexp with another one is
not very hard. Yes, there is a maintainability issue, but I claim that
it is not crucial, not as crucial as the maintainability of pages of C
(or Icon for that matter) code.

>regexp "package" in the Icon Program Library.

Ok, I'd never been able to find the Icon libs, but I just did (archie
IPL), so I'll be looking through that as soon as I can get the time.

>Cheyenne

>+--------------------------------------+---------------------------------+
>| +-----+			       | Cheyenne Wills 		 |
>| |	|      "From here on up it is  | Storage Technology Corporation  |
>| |  +--+--+	 downhill all the way" | 2270 South 88th St.             |
>| |  |	|  |			       | Louisville, Co. 80028-4232	 |
>| +--+--+  |   These are not the       |				 |
>|    |	   |   opinions or views of    | Cheyenne_Wills@stortek.com	 |
>|    +-----+   Storage Technology      | cheyenne@witsend.stortek.com	 |
>+--------------------------------------+---------------------------------+
>


Nick


From icon-group-sender  Mon May  9 22:16:03 1994
Received: by cheltenham.cs.arizona.edu; Mon, 9 May 1994 23:45:07 MST
Path: ucbvax!hplabs!sdd.hp.com!hp-pcd!news!edmoore
From: edmoore@vcd.hp.com (Ed Moore)
Newsgroups: comp.lang.icon
Subject: Icon for Unix scripts?
Message-Id: <CpK36s.MwA@vcd.hp.com>
Date: 9 May 94 22:16:03 GMT
Sender: news@vcd.hp.com (News user)
Organization: Hewlett-Packard VCD
Lines: 41
Nntp-Posting-Host: hpvcledm.vcd.hp.com
X-Newsreader: TIN [version 1.2 PL1.4]
Apparently-To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

I know nothing of Icon except what I read today in the FAQ.  I need a
better way than ksh to create Unix shell scripts.  I had come to believe
that method is perl.  My knowledge of perl consists of a couple of hours
reading of "Learning Perl".  Maybe I should consider Icon instead of perl.
From the FAQ:

: Icon is a very high level general-purpose programming language with
: extensive features for processing strings (text) and data structures.

This sounds vaguely like perl.

: Icon is an imperative, procedural language

What does imperative means in this context?

: It has a string scanning facility for pattern matching that avoids 
: the tedious details usually associated with analyzing strings.

Better than perl's?

: Several implementations of Icon have high-level graphics facilities with
: an easily programmed window interface.

Now this is what got my attention!  I need a way to create a simple,
graphical interface to a Unix script.  The script would open a window
showing all arguments for the script.  Each argument would have two
or more options.  A default option would be shown for some arguments.
Options would be chosen with mouse picks.  Choosing an option would mark
it in the window and unmark any conflicting options.  The window would
have a file scroll table from which multiple files could be selected
with the mouse.  Finally, the window would have a Do-It button to
execute the action of the script.  Can Icon fill this role?  We run on
HP-UX systems with X Windows.

Thanks for any help you can give me.

--
Ed Moore
Hewlett-Packard
Vancouver, WA, USA
edmoore@vcd.hp.com


From icon-group-sender  Tue May 10 12:21:22 1994
Received: by cheltenham.cs.arizona.edu; Tue, 10 May 1994 12:20:19 MST
From: "Art Eschenlauer" <eschen@molbio.cbs.umn.edu>
Message-Id: <9405101721.AA02391@molbio.cbs.umn.edu>
Subject: IconImplementQues: WhenShouldIPollKeyboardForInterrupt
To: icon-group@cs.arizona.edu (icon-group@cs.arizona.edu)
Date: Tue, 10 May 94 12:21:22 CDT
X-Mailer: ELM [version 2.3test PL26]
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

I am modifying the source code for mac standalone icon version 8. I would
like to poll the keyboard frequently to see if the user is trying to
interrupt the process (for instance, to get out of an infinite loop...).
I suppose that I want some routine that is called fairly regularly, like
at the end of every statement (for my use, polling only on input or output
is not sufficient). What C function is called in the interpreter for 
every statement? Should I poll the keyboard when that function is called
or in the loop in the calling function or doesn't it matter? (If the answer
is the second choice, what is the calling function?) I can probably figure
this out on my own, but I thought that I'd ask lest I miss something
obvious or not so obvious.
- Art Eschenlauer



From icon-group-sender  Tue May 10 13:18:43 1994
Received: by cheltenham.cs.arizona.edu; Tue, 10 May 1994 15:00:42 MST
Date: Tue, 10 May 94 13:18:43 PDT
From: kwalker@sirtur.premenos.com (Ken Walker)
Message-Id: <9405102018.AA11126@sirtur.premenos.com>
To: eschen@molbio.cbs.umn.edu
Subject: Re: IconImplementQues: WhenShouldIPollKeyboardForInterrupt
Cc: icon-group@cs.arizona.edu
X-Sun-Charset: US-ASCII
Content-Length: 767
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

> From: "Art Eschenlauer" <eschen@molbio.cbs.umn.edu>
> 
> I am modifying the source code for mac standalone icon version 8. I would
> like to poll the keyboard frequently to see if the user is trying to
> interrupt the process (for instance, to get out of an infinite loop...).

There is a function pollevent() used in windowing versions of Icon.
Presently it is under control of "#define Polling" which in turn is
under control of "#define XIcon". I think you can turn on Polling
independant of XIcon and supply your own pollevent() function, but
I haven't tried it. I'm not sure how this will fit with a future
version of Icon that does windowing on the MAC; you might have to
do some reorganization of the code at that point.

   Ken Walker, kwalker@premenos.com


From icon-group-sender  Tue May 10 15:19:18 1994
Received: by cheltenham.cs.arizona.edu; Tue, 10 May 1994 18:04:45 MST
Message-Id: <m0q1091-00001fC@sutr.cynic.org>
To: icon-group@cs.arizona.edu
Subject: Incrementally loading implementations?
From: Perry The Cynic <perry@cynic.org>
Date: Tue, 10 May 94 15:19:18 PDT
Sender: perry@sutr.cynic.org
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

I would like to know how hard it would be to incrementally load
ICON binary files (esp. the .u[12] type files for the interpreter).
Has anyone done this? Has anyone tried and found it too hard?

Background: I am designing a distributed system where code fragments
("packages") must migrate between systems, to be "plugged in" at
the destination system and run with relatively low overhead.
An important requirement for such "migrant code" is of course independence
from the host architecture and system, which makes the ICON .u[12]
formats look rather appealing.

Anybody? Thanks
  -- perry
---------------------------------------------------------------------------
Perry The Cynic                                             perry@cynic.org
To a blind optimist, an optimistic realist must seem like an Accursed Cynic.
---------------------------------------------------------------------------


From icon-group-sender  Tue May 10 22:49:27 1994
Received: by cheltenham.cs.arizona.edu; Tue, 10 May 1994 18:05:15 MST
Path: ucbvax!hplabs!sdd.hp.com!hp-pcd!news!edmoore
From: edmoore@vcd.hp.com (Ed Moore)
Newsgroups: comp.lang.icon
Subject: Re: Icon for Unix scripts?
Message-Id: <CpLzEG.Dry@vcd.hp.com>
Date: 10 May 94 22:49:27 GMT
References: <CpK36s.MwA@vcd.hp.com>
Sender: news@vcd.hp.com (News user)
Organization: Hewlett-Packard VCD
Lines: 5
Nntp-Posting-Host: hpvcledm.vcd.hp.com
X-Newsreader: TIN [version 1.2 PL1.4]
Apparently-To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Thanks to all who replied, including four by mail.  All are helpful.  In
the years I've been posting queries in USENET, this is the fastest I've
ever received so many useful replies.  The consensus is that I should be
looking at Tcl/Tk, nor Icon or perl.  So I've installed Tcl/Tk and am now
running through the demo exercises.  I think it is what I need.


From icon-group-sender  Wed May 11 03:33:55 1994
Received: by cheltenham.cs.arizona.edu; Wed, 11 May 1994 08:29:54 MST
Date: Wed, 11 May 94 03:33:55 CDT
From: jeffery@ringer.cs.utsa.edu (Clinton L. Jeffery)
Message-Id: <9405110833.AA18491@ringer.cs.utsa.edu.sunset>
To: perry@cynic.org
Cc: icon-group@cs.arizona.edu
In-Reply-To: Perry The Cynic's message of Tue, 10 May 94 15:19:18 PDT <m0q1091-00001fC@sutr.cynic.org>
Subject: Incrementally loading implementations?
Content-Length: 1047
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

   I would like to know how hard it would be to incrementally load
   ICON binary files (esp. the .u[12] type files for the interpreter).
   Has anyone done this? Has anyone tried and found it too hard?

Icon 8.10 and above come with a facility I wrote (turned off by default;
an experimental research product so far) that allows entire icode files to be
loaded as co-expressions; it sounds like you want not just dynamic *loading*
but also dynamic *linking* which will require further modifications to Icon
to make various global data areas (the global variables, the record field
table, etc) extensible as new code is loaded and linked in.

It is not un-doable (SmallTalk does it--it must be easy (just kidding))
and I would love to see it.  On the other hand, it would require intimate
knowledge of portions of the interpreter code, so its not a casual project.
I've thought about it a fair amount and would be happy to advise you on it.

Clint Jeffery
cjeffery@cs.arizona.edu, jeffery@ringer.cs.utsa.edu
The University of Texas at San Antonio


From icon-group-sender  Thu May 12 18:29:48 1994
Received: by cheltenham.cs.arizona.edu; Fri, 13 May 1994 07:27:47 MST
Subject: Re: Incrementally loading implementations?
To: icon-group@cs.arizona.edu
Date: Thu, 12 May 1994 18:29:48 -0600 (CDT)
In-Reply-To: <9405110833.AA18491@ringer.cs.utsa.edu.sunset> from "Clinton L. Jeffery" at May 11, 94 03:33:55 am
X-Mailer: ELM [version 2.4 PL21]
Mime-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Content-Length: 1342      
Message-Id: <9405122329.AA10047@rcmcon.com>
From: whm@rcmcon.com (William Mitchell)
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

> 
>    I would like to know how hard it would be to incrementally load
>    ICON binary files (esp. the .u[12] type files for the interpreter).
>    Has anyone done this? Has anyone tried and found it too hard?

As a grad school project (c. 1984) I took a version of Unipress Emacs and
embedded Icon in it alongside MLisp.  One could write Icon programs that used
MLisp primitives or vice-versa.  It had the ability to load Icon binary files
and merge globals into the existing namespace.  That portion of it was really
no big deal to do.  I think I used a new type of heap object and had the list
of globals in it.  When a file was loaded, I'd allocate a new whatever it was
and put the new list of globals in it.  I took the major shortcut of keeping
translation and linking external to "ice", as I called it.

There was a U of A CS department TR on it, but I've forgotten the number
(unless it's 84-8) and it's probably out of print anyway.

     /------------------------------\         /----------------\
    /      William H. Mitchell       \       / 7120 E. Kiva Way \
   /  Mitchell Software Engineering   \o----/ Tucson, AZ, 85715  \
   \ Consulting/Development/Training  /     \    602-577-6431    /
    \   OO Methods/C++/Icon/UNIX     /       \    whm@mse.com   /
     \------------------------------/         \----------------/


From icon-group-sender  Sat May 14 07:45:39 1994
Received: by cheltenham.cs.arizona.edu; Sat, 14 May 1994 10:06:26 MST
Date: Sat, 14 May 1994 07:45:39 -0600 (CST)
From: Chris Tenaglia - 257-8765 <TENAGLIA@MIS.MCW.EDU>
Subject: X-icon for Friday 13
To: icon-group@cs.arizona.edu
Message-Id: <01HCBLC3VIUQ8WWR6B@mis.mcw.edu>
Organization: Medical College of Wisconsin (Milwaukee, WI)
X-Vms-To: IN%"icon-group@cs.arizona.edu"
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; CHARSET=US-ASCII
Content-Transfer-Encoding: 7BIT
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

For Friday the 13th I'd like to post a little something for those
with a little bit of superstition. This is a biorythm plotter.
I thought it was a good excersize for X programming. I may not
have a full understanding of the cycles but basically it it plots
out 3 sine waves given a birthdate and year. It's not bulletproof
but it does multiple windows, and even has a different mouse
cursor for each window. This was written in Icon V8.10 and tested
on VAX/VMS 5.5 and Ultrix unix 4.3. It isn't the best sample of
Icon programming practice (I like global variables), but maybe it'll
spurr some ideas. Enjoy!

(I'm sending to the list too since I'm not sure if the postnews was working)

#
# file : bior.icn
# desc : for those with biorythm superstition
#
# update          by          what
# 12-may-1994     tenaglia    initial write
#
global xw1,xw2,         # display windows
       Birth_Date,      # birth date
       Plot_Year,       # month to plot
       age              # days old
#
# main line procedure
#
procedure main()
          get_birth_date_and_plot_month()
          draw_picture()
end

#
# draw the graph and plot the waveforms
#
procedure draw_picture()
  names     := ["JANUARY","FEBRUARY","MARCH","APRIL","MAY","JUNE",
                "JULY","AUGUST","SEPTEMBER","OCTOBER","NOVEMBER","DECEMBER"]
  shifts    := [0,31,60,91,121,152,182,213,244,274,305,335]
  pi        := 3.1415927
  pi2       := pi*2.0
  sumcolor  := "pink"
  
  (xw2 := open("BIOR " || Plot_Year || " VIA " || Birth_Date,"x",
                   "bg=black","fg=white",
                   "geometry=1098x200+50+500")) |
    {
    write("Can't open window. Press <RETURN>")
    stop("ABEND ANOX")
    }
  write(xw1,"")
  XAttrib(xw2,"pointer=heart")
  XAttrib(xw1,"fg=red")
  write(xw1,"          PHYSIO")
  XAttrib(xw1,"fg=green")
  write(xw1,"          EMOTA")
  XAttrib(xw1,"fg=yellow")
  write(xw1,"          INTELLA")
  XAttrib(xw1,"fg=" || sumcolor)
  write(xw1,"          SUMUM")
  XAttrib(xw1,"fg=white")
  XSync(xw1)
  
  XDrawLine(xw2,0,100,1098,100)
  every n := 2 to *shifts do
    {
    disp := shifts[n]*3
    XDrawLine(xw2,disp,0,disp,200)
    }
  a := 1
  every n := 5 to 1095 by 91 do
    {
    XDrawString(xw2,n,10,names[a])
    a +:= 1
    }
  every begin := !shifts do
    {
    every base := 5 to 25 by 5 do
      {
      disp := begin * 3 + base * 3
      XDrawLine(xw2,disp,95,disp,105)
      }
    }     
  oldx  := 0
     x  := 0
  magn  := 34
  oldyp := sin((age%23)*pi2/23)*magn + 200
  oldye := sin((age%28)*pi2/28)*magn + 200
  oldyi := sin((age%33)*pi2/33)*magn + 200
  oldyy :=(sin((age%23)*pi2/23) +
           sin((age%28)*pi2/28) +
           sin((age%33)*pi2/33))*magn + 100
  every point := age to age + 365 do
    {
    yp := sin((point%23)*pi2/23)*magn + 100
    ye := sin((point%28)*pi2/28)*magn + 100
    yi := sin((point%33)*pi2/33)*magn + 100
    yy :=(sin((point%23)*pi2/23) +
          sin((point%28)*pi2/28) +
          sin((point%33)*pi2/33))*magn + 100
    XAttrib(xw2,"fg=red")
    XDrawSegment(xw2,oldx,oldyp,x,yp)
    XAttrib(xw2,"fg=green")
    XDrawSegment(xw2,oldx,oldye,x,ye)
    XAttrib(xw2,"fg=yellow")
    XDrawSegment(xw2,oldx,oldyi,x,yi)
    XAttrib(xw2,"fg=" || sumcolor)
    XDrawSegment(xw2,oldx,oldyy,x,yy)
    XSync(xw2)
    oldyp := yp
    oldye := ye
    oldyi := yi
    oldyy := yy
    oldx  := x
    x    +:= 3
    }
  XAttrib(xw2,"fg=white")
  write("Click the Button!")
  press := open("Respond Please","x",
                "geometry=200x50+500+350","fg=black","bg=green")
  XAttrib(press,"pointer=leftbutton")
  XDrawString(press,20,30,"Click Me to finish ")
  XEvent(press)
  close(press)
  close(xw1)
  close(xw2)
  end         
  
#
# obtain starting information
#
procedure get_birth_date_and_plot_month()
  (xw1 := open("BIOR","x",
                   "bg=black","fg=white",
                   "lines=12","columns=40")) |
    {
    write("Can't open window. Press <RETURN>")
    stop("#1 ABEND ANOX")
    }
  XAttrib(xw1,"pointer=exchange")
  XGotoRC(xw1,1,1)
  write(xw1,"Enter Dates")
  XGotoRC(xw1,3,1)
  write(xw1,"BirthDate  MM/DD/YYYY:")
  XGotoRC(xw1,5,1)
  write(xw1,"    Year to plot YYYY:")
  XAttrib(xw1,"cursor=on")
  XGotoRC(xw1,3,23)
  Birth_Date := read(xw1)
  XGotoRC(xw1,5,23)
  Plot_Year := read(xw1)
  base1 := 0
  d1 := julian(Birth_Date)
  d2 := julian("01/01/" || Plot_Year)
  age:= d2 - d1
  end                 

#
# parse a string into a list with respect to a delimiter
#
procedure parse(line,delims)
  static chars
  chars  := &cset -- delims
  tokens := []
  line ? while tab(upto(chars)) do put(tokens,tab(many(chars)))
  return tokens
  end

#
# this procedure finds the julian number of a day given MM/DD/YYYY
#
procedure julian(date)
  static  months,shifts
  initial {
          months := [31,28,31,30,31,30,31,31,30,31,30,31]
          shifts := [0,31,59,90,120,151,181,212,243,273,304,334]
          }
  part   := parse(date,'-/')
  (mm    := integer(part[1])) | stop("julian(mm/dd/yyyy) format violation #1")
  (dd    := integer(part[2])) | stop("julian(mm/dd/yyyy) format violation #2")
  (yyyy  := integer(part[3])) | stop("julian(mm/dd/yyyy) format violation #3")
  (*part = 3)                 | stop("julian(mm/dd/yyyy) format violation #4")
  if yyyy%4 = 0 then
    {
    months[2] := 29
    shifts    := [0,31,60,91,121,152,182,213,244,274,305,335]
    }
  if (mm<1) | (mm>12) then stop("julian(MM/dd/yyyy) range error!")
  maxd := months[mm]
  if (dd<1) | (dd>maxd) then stop("julian (mm/DD/yyyy) range error!")
  if yyyy < 100 then yyyy +:= 1900
  if (yyyy<1901) | (yyyy>2100) then stop("julian (mm/dd/YYYY) range error!")
  number  := shifts[mm] + dd
  every i := 1901 to yyyy do
    {
    yl      := if (i%4)=0 then 366 else 365
    number +:= yl
    }
  return number
  end
  
-- 
Chris Tenaglia   (system manager)     |  tenaglia@mis.mcw.edu
Medical College of Wisconsin          |
8701 W. Watertown Plank Rd.           |  Ce que vous voyez est
Milwaukee, WI 53226   (414)257-8765   |  ce que vous obtenez !



From icon-group-sender  Fri May 20 13:49:50 1994
Received: by cheltenham.cs.arizona.edu; Fri, 20 May 1994 15:53:11 MST
From: Richard Hernandez <rick@sparc.sandiegoca.ncr.com>
Message-Id: <9405202049.AA07160@sv509.SanDiegoCA.ncr.com>
Subject: How do I place a system editor in an icon region?
To: icon-group@cs.arizona.edu
Date: Fri, 20 May 1994 13:49:50 -0700 (PDT)
X-Mailer: ELM [version 2.4 PL20]
Content-Type: text
Content-Length: 896       
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Hi Group!

I have just installed icon 8.10 and built my first program.
For those of you that are interested, platforms are:

MACHINE=NCR 3000 Family,  OS=NCR System V Release 4
MACHINE=Solbourne Series5 OS=Solbourne/Sun Microsystems sun4 4.1B

I have a question on how to add a system editor (vi,emacs)
within an icon window, that is, frame an editor in icon. I
would prefer not using icon to create an editor (why re-invent
the wheel?). Any help would be appreciated.

-- 
I do not represent AT&T or NCR and all correspondance regarding
AT&T or NCR should be sent to those that do ...

 _ __           Richard "Rick" Hernandez     MailStop: 1440
' )  )      /   c/o AT&T GLOBAL INFORMATION SOLUTIONS
 /--' o _. /_   17095 VIA DEL CAMPO       PHONE:  (619) 485-3467
/  \_(_(__/ <_  SAN DIEGO  CA 92127-1711  FAX:    (619) 485-3367
                E-MAIL:     Richard.Hernandez@SanDiegoCA.NCR.COM


From icon-group-sender  Sat May 21 07:30:56 1994
Received: by cheltenham.cs.arizona.edu; Sat, 21 May 1994 10:57:54 MST
Date: Sat, 21 May 1994 07:30:56 -0600 (CST)
From: Chris Tenaglia - 257-8765 <TENAGLIA@MIS.MCW.EDU>
Subject: Re: How do I place a system editor in an icon region?
To: rick@sparc.sandiegoca.ncr.com
Cc: icon-group@cs.arizona.edu
Message-Id: <01HCLCIE6EGI8WW2SH@mis.mcw.edu>
Organization: Medical College of Wisconsin (Milwaukee, WI)
X-Vms-To: IN%"rick@sparc.sandiegoca.ncr.com"
X-Vms-Cc: IN%"icon-group@cs.arizona.edu"
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; CHARSET=US-ASCII
Content-Transfer-Encoding: 7BIT
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


It sounds like Xwindows are present? I wrote an X-based menu that
needs to do something like that too. Mine called different
character based apps. Assuming you know what filename you want
to edit, here's the code segment I'd use.

     command := "/usr/bin/X11/xterm -e /usr/ucb/vi " || filename || " &"
     system(command)

I do this on a DEC ultrix unix system. My display is an Xterminal. This
runs the editor on the file and when the editor is exited "ZZ", the
spawned window disappears automatically.

Chris Tenaglia (System Manager) |  "The past explained,     
Medical College of Wisconsin    |   the future fortold, 
8701 W. Watertown Plank Rd.     |   the present largely appologized for."
Milwaukee, WI 53226             |   Organon to The Doctor
(414)257-8765                   |     
tenaglia@mis.mcw.edu

> From:	IN%"rick@sparc.sandiegoca.ncr.com"  "Richard Hernandez" 20-MAY-1994 18:02:25.04
> To:	IN%"icon-group@cs.arizona.edu"
> Subj:	How do I place a system editor in an icon region?

> Hi Group!
> I have just installed icon 8.10 and built my first program.
> For those of you that are interested, platforms are:

> MACHINE=NCR 3000 Family,  OS=NCR System V Release 4
> MACHINE=Solbourne Series5 OS=Solbourne/Sun Microsystems sun4 4.1B

> I have a question on how to add a system editor (vi,emacs)
> within an icon window, that is, frame an editor in icon. I
> would prefer not using icon to create an editor (why re-invent
> the wheel?). Any help would be appreciated.
> -- 
> I do not represent AT&T or NCR and all correspondance regarding
> AT&T or NCR should be sent to those that do ...

>  _ __           Richard "Rick" Hernandez     MailStop: 1440
> ' )  )      /   c/o AT&T GLOBAL INFORMATION SOLUTIONS
>  /--' o _. /_   17095 VIA DEL CAMPO       PHONE:  (619) 485-3467
> /  \_(_(__/ <_  SAN DIEGO  CA 92127-1711  FAX:    (619) 485-3367
>                 E-MAIL:     Richard.Hernandez@SanDiegoCA.NCR.COM



From icon-group-sender  Sat May 21 14:19:18 1994
Received: by cheltenham.cs.arizona.edu; Sat, 21 May 1994 22:24:43 MST
From: Richard Hernandez <rick@sparc.sandiegoca.ncr.com>
Message-Id: <9405212119.AA27468@sv509.SanDiegoCA.ncr.com>
Subject: Re: How do I place a system editor in an icon region?
To: icon-group@cs.arizona.edu
Date: Sat, 21 May 1994 14:19:18 -0700 (PDT)
In-Reply-To: <01HCLCIE6EGI8WW2SH@mis.mcw.edu> from "Chris Tenaglia - 257-8765" at May 21, 94 07:30:56 am
X-Mailer: ELM [version 2.4 PL20]
Content-Type: text
Content-Length: 3144      
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

> 
> It sounds like Xwindows are present? I wrote an X-based menu that
> needs to do something like that too. Mine called different
> character based apps. Assuming you know what filename you want
> to edit, here's the code segment I'd use.
> 
>      command := "/usr/bin/X11/xterm -e /usr/ucb/vi " || filename || " &"
>      system(command)
>
Thanks, I have implemented the above. What I really want is what is below.

        Icon window
         ________________________________________________
        |                                                :
        |   File   Options                               :
        |  -------------------------------------------   :
        |   _________________________________________    |
        |   |Editing a file with a system editor    :    :
        |   |within an icon window.                 :    :
        |   |~                                      :    :
        |   |~                                      :    :
        |   |~                                      :    :
        |   |~                                      :    :
        |   |~                                      :    :
        |   |~                                      :    :
        |   |~                                      :    :
        |   |"filename" [New file]                  :    :
        |   -----------------------------------------    |
        |                                                :
         ------------------------------------------------
> 
> I do this on a DEC ultrix unix system. My display is an Xterminal. This
> runs the editor on the file and when the editor is exited "ZZ", the
> spawned window disappears automatically.
> 
> Chris Tenaglia (System Manager) |  "The past explained,     
> Medical College of Wisconsin    |   the future fortold, 
> 8701 W. Watertown Plank Rd.     |   the present largely appologized for."
> Milwaukee, WI 53226             |   Organon to The Doctor
> (414)257-8765                   |     
> tenaglia@mis.mcw.edu
> 
> > From:	IN%"rick@sparc.sandiegoca.ncr.com"  "Richard Hernandez" 20-MAY-1994 18:02:25.04
> > To:	IN%"icon-group@cs.arizona.edu"
> > Subj:	How do I place a system editor in an icon region?
> 
> > Hi Group!
> > I have just installed icon 8.10 and built my first program.
> > For those of you that are interested, platforms are:
> 
> > MACHINE=NCR 3000 Family,  OS=NCR System V Release 4
> > MACHINE=Solbourne Series5 OS=Solbourne/Sun Microsystems sun4 4.1B
> 
> > I have a question on how to add a system editor (vi,emacs)
> > within an icon window, that is, frame an editor in icon. I
> > would prefer not using icon to create an editor (why re-invent
> > the wheel?). Any help would be appreciated.
-- 
I do not represent AT&T or NCR and all correspondance regarding
AT&T or NCR should be sent to those that do ...

 _ __           Richard "Rick" Hernandez     MailStop: 1440
' )  )      /   c/o AT&T GLOBAL INFORMATION SOLUTIONS
 /--' o _. /_   17095 VIA DEL CAMPO       PHONE:  (619) 485-3467
/  \_(_(__/ <_  SAN DIEGO  CA 92127-1711  FAX:    (619) 485-3367
                E-MAIL:     Richard.Hernandez@SanDiegoCA.NCR.COM


From icon-group-sender  Sun May 22 04:37:53 1994
Received: by cheltenham.cs.arizona.edu; Sun, 22 May 1994 08:38:59 MST
Date: Sun, 22 May 94 04:37:53 CDT
From: jeffery@ringer.cs.utsa.edu (Clinton L. Jeffery)
Message-Id: <9405220937.AA03737@ringer.cs.utsa.edu.sunset>
To: rick@sparc.sandiegoca.ncr.com
Cc: icon-group@cs.arizona.edu
In-Reply-To: Richard Hernandez's message of Sat, 21 May 1994 14:19:18 -0700 (PDT) <9405212119.AA27468@sv509.SanDiegoCA.ncr.com>
Subject: How do I place a system editor in an icon region?
Content-Length: 625
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

What you want to do is interesting, but there is no way to do it in Icon
right now.  To do it you need an interface to UNIX pseudo-tty's and Icon
doesn't presently have one.  There are a lot of neat things like this that
we'd like to do, but without industry sponsorship there are no resources
for this kind of development.  Given our limited resources, we add features
directly relevant to our research and occasionally code is contributed from
someone in the user community who has extended Icon in an important way.

Clint Jeffery
cjeffery@cs.arizona.edu, jeffery@ringer.cs.utsa.edu
The University of Texas at San Antonio


From icon-group-sender  Sun May 22 09:23:36 1994
Received: by cheltenham.cs.arizona.edu; Sun, 22 May 1994 15:49:35 MST
Date: Sun, 22 May 1994 09:23:36 MST
From: "Ralph Griswold" <ralph>
Message-Id: <199405221623.AA25643@cheltenham.cs.arizona.edu>
To: icon-group
Subject: Icon program library
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

I'm in the process of preparing the next update to the Icon program
library.  If you have material to contribute, please send it to
me within the next two weeks.

If you've submitted material before and aren't sure if I have it,
or if you're not sure I have the latest version, ask me or just
send what you have and I'll sort it out.

You can send material to me by e-mail (ralph@cs.arizona.edu), upload
it to /incoming by FTP (cs.arizona.edu), or send a MS-DOS or Macintosh
diskette.  If you upload by FTP, please let me know by e-mail so
that I can pick it up before it's garbage collected.
    
Ralph E. Griswold			ralph@cs.arizona.edu
Department of Computer Science 		 uunet!arizona!ralph
The University of Arizona		602-621-6609 (voice)
Tucson, AZ 85721			602-621-4246   (fax)


From icon-group-sender  Sun May 22 12:34:41 1994
Received: by cheltenham.cs.arizona.edu; Sun, 22 May 1994 15:50:21 MST
Date: Sun, 22 May 94 12:34:41 PDT
From: eric@star-semi.com (Eric Armstrong)
Message-Id: <9405221934.AA13629@star-semi.com>
To: icon-group@cs.arizona.edu
Subject: wish list?
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Has someone collected the ideas, suggestions, and wish-list items?

My usual experience with a new language (system, product, etc.) is that what
it WILL do is clearly documented, but what it WON'T do (that you might expect
it to) is only discovered by using it and "bumping into the walls."

An (annotated?) collection of wish-list features would help to establish
the boundaries of the language and circumscribe the problem domain in which
it is appropriate.

thanks
eric --new icon-ite.  or is that "icontaket" as in "I con take it" (boo...)
       iconizer?  icon-duit?  iconC, iconC!  (iconCede!)
 
-------------------------------------------------------------------------------
Eric Armstrong	             eric@star-semi.com             (408) 526-2160 x170
Star Semiconductor            2951 Zanker Road              San Jose  CA  95134


From icon-group-sender  Mon May 23 06:42:32 1994
Received: by cheltenham.cs.arizona.edu; Mon, 23 May 1994 09:35:00 MST
Date: Mon, 23 May 1994 06:42:32 -0600 (CST)
From: Chris Tenaglia - 257-8765 <TENAGLIA@MIS.MCW.EDU>
Subject: Re: wishlist?
To: icon-group@cs.arizona.edu
Message-Id: <01HCO3T4LOX48WW45U@mis.mcw.edu>
Organization: Medical College of Wisconsin (Milwaukee, WI)
X-Vms-To: IN%"icon-group@cs.arizona.edu"
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; CHARSET=US-ASCII
Content-Transfer-Encoding: 7BIT
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

> From:	IN%"eric@star-semi.com" 22-MAY-1994 17:55:08.74
> To:	IN%"icon-group@cs.arizona.edu"
> Subj:	wish list?

> Has someone collected the ideas, suggestions, and wish-list items?
> My usual experience with a new language (system, product, etc.) is that what
> it WILL do is clearly documented, but what it WON'T do (that you might expect
> it to) is only discovered by using it and "bumping into the walls."

  I've bumped into those walls. The most blatant is:

              every n := 0.0 to &pi*2.0 by &pi/180.0 do ...

  'every' cannot increment by reals. It can only do integers, strings,
  and structures. My other complaints are OS deficiencies. A feature that
  works fine under SUNOS or HPUX doesn't work the same under Ultrix or VMS,
  and sometimes doesn't work at all. The Icon Project told me that since
  those aren't popular platforms at arizona.edu they really don't have the
  time or people to look into it.

  I've also had problems with the VMS versions unable to read files that
  contain char(255) or \377 in them. This has been broken since V8.7 of
  Icon. Under MS-DOS getch() was unbreakable in version 8.5, but is under
  8.10, which weakened some password routines in my software. And it is
  also annoying that kbhit(), getch(), and getche() behave differently
  under VMS, UNIX, and DOS. The VMS version won't run unless your have
  X-windows or Motif installed, even if you rebuild it with the X-flags
  turned off. A lot of my gripes are because I write for so many
  different environments. If you only do DOS, or only do unix your life
  can stay simple.
  
> An (annotated?) collection of wish-list features would help to establish
> the boundaries of the language and circumscribe the problem domain in which
> it is appropriate.

  Icon seems to have 2 goals. I/O (files, pipes, and windows), and portability.
  Icon's portability is achieved by having a run time 'system' (virtual
  machine) that offers the same services to the language across all platforms.
  This is achieved by having C and OS gurus define the interfaces to the
  internals of the OS. The more consistent the design of the interfaces and
  the services offered across OS's the more portable the language. The
  more they do to hide the internals of a CPU from us, the more energy we
  can devote to solving the problem, and less fighting with the architecture.

  They've begun this now on the windowing implementations. This will unify
  the windowing between X-Windows, MS-windows, and OS/2 (presentation mgr).
  One of my wishlist things is in this same category, but it could be done
  as a user developed procedure too. It would be to have a uniform file system
  notation. This would avoid stuff like:
              file := case OS of
                        {
                        "MS-DOS" : "C:\\ICON\\CFG.DAT"
                        "VMS"    : "DISK1:[ICON]CFG.DAT"
                        "UNIX"   : "/usr/lib/icon/cfg.dat"
                        "AMIGA"  : ????
                        "ATARI"  : ????
                        "MAC"    : ????
                        "MVS"    : ????
                        }
  Another popular wish is for regular expression pattern matching although
  this could be written in user routines if someone had the time and patience
  to sink into it. Bidirectional pipes might be cool too to permit better
  interprocess communication.

> thanks
> eric --new icon-ite.  or is that "icontaket" as in "I con take it" (boo...)
>        iconizer?  icon-duit?  iconC, iconC!  (iconCede!)
> -------------------------------------------------------------------------------
> Eric Armstrong	             eric@star-semi.com             (408) 526-2160 x170
> Star Semiconductor            2951 Zanker Road              San Jose  CA  95134



From icon-group-sender  Mon May 23 10:24:05 1994
Received: by cheltenham.cs.arizona.edu; Mon, 23 May 1994 09:39:33 MST
Message-Id: <199405231424.AA17553@optima.cs.arizona.edu>
Date: Mon, 23 May 94 10:24:05 -0400
From: Mark Keil <keil@ch.hp.com>
To: icon-group@cs.arizona.edu
Subject: Japanese text processing & Japanese word counting?
Reply-To: keil@ch.hp.com
Status: RO
Errors-To: icon-group-errors@cs.arizona.edu

Folks:

 Has anyone out there used Icon to process japanese text?
 I'm looking for pointers or code to handle JIS or EUC encoded
 japanese text with Icon.

 This is an interesting problem, because regular ascii can be
 intermixed with two byte encoded Japanese text. There are several
 different ways to encode the japanese, one of which uses shift-in
 shift-out (shift JIS) codes to mark the transition. Japanese text
 also doesn't have spaces to seperate the words, making word detection
 interesting.

 Anybody have any ideas?

Thanks, Mark


From icon-group-sender  Tue May 24 08:13:20 1994
Received: by cheltenham.cs.arizona.edu; Tue, 24 May 1994 15:01:55 MST
Date: Tue, 24 May 94 08:13:20 PDT
From: kwalker@sirtur.premenos.com (Ken Walker)
Message-Id: <9405241513.AA01092@sirtur.premenos.com>
To: TENAGLIA@MIS.MCW.EDU, icon-group@cs.arizona.edu
Subject: Re: wishlist?
X-Sun-Charset: US-ASCII
Content-Length: 1155
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

> From: Chris Tenaglia - 257-8765 <TENAGLIA@MIS.MCW.EDU>
> 
>               every n := 0.0 to &pi*2.0 by &pi/180.0 do ...
> 
>   'every' cannot increment by reals. It can only do integers, strings,
>   and structures.

Technically speaking the problem is not with 'every'; the problem is
with 'to by'. This is illustrated by writing a toby() procedure that
mimics 'to by', but works fine with reals:

procedure toby(From, To, By)
    /By := 1

    if From < To then {
        if By <= 0 then
            stop("infinite sequence specified for toby()")
        while From <= To do {
            suspend From
            From +:= By
            }
        }
    else {
        if By >= 0 then
            stop("infinite sequence specified for toby()")
        while From >= To do {
            suspend From
            From +:= By
            }
        }
end

procedure main()
   local From, To, By

   repeat {
       writes("from ")
       From := read() | stop()
       writes("to ")
       To := read() | stop()
       writes("by ")
       By := read() | stop()
       every write("  ", toby(From, To, By))
       }
end


Ken Walker, kwalker@premenos.com


From icon-group-sender  Sun May  1 04:29:32 1994
Received: by cheltenham.cs.arizona.edu; Tue, 24 May 1994 15:03:54 MST
Path: ucbvax!cis.ohio-state.edu!math.ohio-state.edu!cs.utexas.edu!swrinde!sgiblab!sgigate.sgi.com!olivea!koriel!decwrl!get.hooked.net!news.sprintlink.net!redstone.interpath.net!mercury!brady
From: brady@mercury.interpath.net (Donald C Brady - Comintel Inc)
Newsgroups: comp.lang.icon
Subject: Re: Icon in May94 BYTE Magazine -- what else & Windows?
Message-Id: <2pvb7c$hel@redstone.interpath.net>
Date: 1 May 94 04:29:32 GMT
References: <balin.67.00072A78@vt.edu> <1994Apr28.181752.29607@ringer.cs.utsa.edu>
Distribution: inet
Organization: Interpath -- An Internet access provider
Lines: 20
Nntp-Posting-Host: mercury.interpath.net
X-Newsreader: TIN [version 1.2 PL2]
Apparently-To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

I also read the Byte article. I was very interested in it as I am a heavy 
user of Catspaw Spitbol/386, which is of course a SNOBOL4.

When I last looked at Icon, I concluded SNOBOL4/ SPITBOL was still the
better choice, because high-quality implementations were readily
available. Icon seemed immature and less-widely used.

Is this still the case? Or is Icon now starting to replace SNOBOL4?

I currently run WIndows/NT mainly, but alos have UNIXWARE, OS/2,
NExtStep.

Is the NT version going to come out with the Windows version or are
they separate?

What version of UNIX is best now for running or trying out Icon?

Or OS/2?

Thanks.


From icon-group-sender  Tue May 24 17:58:06 1994
Received: by cheltenham.cs.arizona.edu; Tue, 24 May 1994 15:05:57 MST
Path: ucbvax!agate!howland.reston.ans.net!gatech!concert!sas!mozart.unx.sas.com!sasghm
From: sasghm@theseus.unx.sas.com (Gary Merrill)
Newsgroups: comp.text.sgml,comp.text,comp.lang.misc,comp.lang.icon
Subject: Re: Spitbol reference?
Message-Id: <CqBJ8u.B6s@unx.sas.com>
Date: 24 May 94 17:58:06 GMT
References: <1994May17.140242.27932@tin.monsanto.com> <CpyDI0.M9M@world.std.com>
Sender: news@unx.sas.com (Noter of Newsworthy Events)
Organization: SAS Institute Inc.
Lines: 58
Originator: sasghm@theseus.unx.sas.com
Nntp-Posting-Host: theseus.unx.sas.com
Apparently-To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


In article <CpyDI0.M9M@world.std.com>, sgmlsh@world.std.com (John Smith) writes:
|> Joel Finkle <jjfink@skcla.monsanto.com> writes:
|> 
|> >I'm looking for reference material on the Spitbol language.
|> 
|> The vendor for Spitbol is:
|> 
|> Catspaw Inc.
|> PO Box 1123
|> Salida, CO 81201 USA
|> 1-719-539-3884
|> 
|> cats!support@cs.arizona.edu

I recall seeing the Catspaw SPITBOL environment some time ago,
and though I never used it, it looked quite nice.

|> -- 
|> <!-- 
|>   "To imagine a language is to imagine a form 
|>    of life."                   - Wittgenstein,
|>                  Philosophical Investigations

Yes, and the form of life of which SNOBOL is a model is likely
to be quite foreign to you.  It would be good to have a "pet"
SNOBOL (or SPITBOL) interpreter to help you get up to speed.

As far as references for the *langauge*, the following are
gathering dust on my shelves:

_The SNOBOL4 Programming Language, 2nd Ed., by Griswold, Poage,
and Polonsky.  Prentice Hall.

   This is the classic language reference text.

_The Programmer's Introduction to SNOBOL_ by Maurer.  Elsevier.

   This is part of a series in which each book seeks to introduce
   someone already skilled in programming to a new language.

_String and List Processing in Snobol4:  Techniques and Applications_,
by Griswold.  Prentice-Hall.

   Probably my favorite text on the language, this deals with
   somewhat more advanced topics and algorithms.

Isn't it great that SGML is providing such a rich environment for
the application of what many of us might have thought of as dead
languages and elderly sets of text processing tools?  A programmer's
paradise.  I hope you enjoy your use of SPITBOL.  It is one of
my favorite languages, though one hardly sees it used much any
more at all.  Perhaps this type of application to SGML environments
will stimulate a revival.
-- 
Gary H. Merrill  [Principal Systems Developer, Compiler and Tools Division]
SAS Institute Inc. / SAS Campus Dr. / Cary, NC  27513 / (919) 677-8000
sasghm@theseus.unx.sas.com ... !mcnc!sas!sasghm


From icon-group-sender  Thu May  5 16:22:56 1994
Received: by cheltenham.cs.arizona.edu; Tue, 24 May 1994 15:06:33 MST
Path: ucbvax!cis.ohio-state.edu!math.ohio-state.edu!sdd.hp.com!col.hp.com!csn!server!usenet
From: cheyenne@witsend.stortek.com (Cheyenne Wills)
Newsgroups: comp.lang.icon
Subject: Re: Spitbol vs. Icon
Message-Id: <CpC86B.K2C@stortek.com>
Date: 5 May 94 16:22:56 GMT
References: <1994May3.191711.12437@midway.uchicago.edu> <Cp8yyL.152@stortek.com> <1994May4.161502.9405@cs.rit.edu> <1994May5.012816.4786@midway.uchicago.edu>
Sender: usenet@stortek.com
Reply-To: cheyenne@witsend.stortek.com (Cheyenne Wills)
Organization: Storage Technology Corp.
Lines: 42
Nntp-Posting-Host: witsend.stortek.com
X-Newsreader: IBM NewsReader/2 v1.00
Apparently-To: icon-group@cs.arizona.edu
Status: RO
Errors-To: icon-group-errors@cs.arizona.edu

In <1994May5.012816.4786@midway.uchicago.edu>, goer@quads.uchicago.edu (Richard L. Goerwitz) writes:
>Nicolas M Williams writes:
>>
>>What about Icon library routines for handling regular expressions? I'd
>>love something like that, Icon would leave perl in the dust....
>
>Bob Alexander wrote some, and they're pretty good.  They should be
>in recent library releases.
>
>--
>
>   -Richard L. Goerwitz	      goer%midway@uchicago.bitnet
>   goer@midway.uchicago.edu	      rutgers!oddjob!ellis!goer

Just a comment about regular expressions and Icon.  One can view
regular expressions as an "assembly language" for a string matching
engine.  They are extremely powerful, and also extremely "cryptic"

You can code the same "patterns" in straight Icon that will probably
run "faster".

For example:
   "^[A-Z][A-Z0-9]* *[A-Z]*$"

can be "matched" by the following Icon segment

   line ?
	pos(1) &
	any(&ucase) & move(1) &
	tab(many(&ucase++&digits)) &
	tab(many(' ')) &
	tab(many(&ucase)) &
	pos(0)

+--------------------------------------+---------------------------------+
| +-----+			       | Cheyenne Wills 		 |
| |	|      "From here on up it is  | Storage Technology Corporation  |
| |  +--+--+	 downhill all the way" | 2270 South 88th St.             |
| |  |	|  |			       | Louisville, Co. 80028-4232	 |
| +--+--+  |   These are not the       |				 |
|    |	   |   opinions or views of    | Cheyenne_Wills@stortek.com	 |
|    +-----+   Storage Technology      | cheyenne@witsend.stortek.com	 |
+--------------------------------------+---------------------------------+


From icon-group-sender  Sat May  7 17:33:23 1994
Received: by cheltenham.cs.arizona.edu; Tue, 24 May 1994 20:10:59 MST
Path: ucbvax!cis.ohio-state.edu!math.ohio-state.edu!darwin.sura.net!udel!rochester!rit!nmw1638
From: nmw1638@cs.rit.edu (Nicolas M Williams)
Newsgroups: comp.lang.icon
Subject: Re: Regular expressions & dynamic linking (was Re: Spitbol vs. Icon)
Message-Id: <1994May7.173323.3010@cs.rit.edu>
Date: 7 May 94 17:33:23 GMT
References: <CpC86B.K2C@stortek.com> <1994May5.223307.19549@cs.rit.edu> <CpDx7B.H1o@stortek.com>
Sender: news@cs.rit.edu (USENET News Admin)
Organization: Rochester Institute of Technology, Rochester, NY
Lines: 76
Nntp-Posting-Host: iowa
Apparently-To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

In article <CpDx7B.H1o@stortek.com> cheyenne@witsend.stortek.com (Cheyenne Wills) writes:
>In <1994May5.223307.19549@cs.rit.edu>, nmw1638@cs.rit.edu (Nicolas M Williams) writes:
>>In article <CpC86B.K2C@stortek.com> cheyenne@witsend.stortek.com (Cheyenne Wills) writes:

>Hmmm.... well...
>One of Icon's design goals was (is) to provide a language that is
>fairly easily read.  While one can write unreadable code in any language,
>some languages lend themselves to being more unreadable then others.

Heh, sure, look, there are single characters that have a lot of meaning
in Icon, where their meaning depends on the situation (e.g. / and \).
Plus recursive generators can be hard to figure out. No, Icon can be
very cryptic, which I in particular don't mind very much, after all, I'm
used to C and awk and sed and....

>Regular expressions are themselves a fullblown language, they have
>their place.

They can complement Icon, see below.

>I'm not saying that adding regular expressions to Icon is bad (or good),
>I'm just tring to say that with Icon, one can achive the same end result
>with existing facilities.  In addition, Icon provides some facilities
>that just are not possible under regexps (try extracting "balanced
>strings" -- "(3+4*(5+6)*(10+11))".  With regexps the best you can do
>with the above is:  "(3+4*(5+6)".

Right, now imagine (I haven't seen the regexp library yet) a function
that returns the position of the subject string that marks the first
character of a string matched by a regexp, and another function that
returns the last character of said string provided you give it the
position of the first character of the matched string. That would fit in
quite well into the string scanning environment of Icon. I want regexps
not because they are good enough (which they are not), but because they
can simplify a lot of tasks.

>	In addition a programmer can extend
>string pattern matching with their own functions, something that one
>cannot do with regexps.  Once a useful pattern matching function
>has been built, one can save it for use later without having to
>reinvent it all over.  If I need a pattern to match labels, I have
>an Icon function already coded that will do that.  If I need a pattern
>to match "real numbers", I already have that, etc.

Yes, indeed, I have done this. So? Replacing a well commented regexp is
not that hard; I've done that too.

>Maintainability is always an issue.  Even "throw-a-way" code has a
>tendancy to live a life longer then the author may have intended.

Yes, but regexps are seldom huge (several lines long), and if their
actions are well commented, replacing that regexp with another one is
not very hard. Yes, there is a maintainability issue, but I claim that
it is not crucial, not as crucial as the maintainability of pages of C
(or Icon for that matter) code.

>regexp "package" in the Icon Program Library.

Ok, I'd never been able to find the Icon libs, but I just did (archie
IPL), so I'll be looking through that as soon as I can get the time.

>Cheyenne

>+--------------------------------------+---------------------------------+
>| +-----+			       | Cheyenne Wills 		 |
>| |	|      "From here on up it is  | Storage Technology Corporation  |
>| |  +--+--+	 downhill all the way" | 2270 South 88th St.             |
>| |  |	|  |			       | Louisville, Co. 80028-4232	 |
>| +--+--+  |   These are not the       |				 |
>|    |	   |   opinions or views of    | Cheyenne_Wills@stortek.com	 |
>|    +-----+   Storage Technology      | cheyenne@witsend.stortek.com	 |
>+--------------------------------------+---------------------------------+
>


Nick


From icon-group-sender  Wed May 25 15:40:02 1994
Received: by cheltenham.cs.arizona.edu; Wed, 25 May 1994 09:04:38 MST
Date: Wed, 25 May 1994 15:40:02 +0100
From: Jan Peter de Ruiter <janpeter@mpi.nl>
Message-Id: <9405251440.AA26803@mpix10.mpi.kun.nl>
To: icon-group@cs.arizona.edu
Subject: icon course
Cc: janpeter@mpi.kun.nl
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Hi folks,

I've finally convinced enough members of our institute to use
Icon to justify giving an Icon course. 

The goal of the course is to get them to write their own programs
in Icon, enabling them to bootstrap further if they want to do
fancy stuff. Given the nature of our work here, most programs will 
be "data laundry" programs, or grazing in lexical databases and 
corpora for certain linguistic entities like words or phrases.
Since many users here use(d) awk, I will put my Icon awk emulator
to good use, of course, showing the participants that they can do
awk stuff in Icon as well. 

In preparing for the course, I noticed that Icon is such a coherent
language that it is hard to know where to begin. Most concepts
rely on other concepts, and you have to break the circularity
somewhere.

Now this is not the first course I ever tought, so I think I'll 
manage to find a good course layout, but I'd like to know if there's 
any wisdom about teaching Icon you'd like to share with me, especially
if it's about the order of presentation of the many features Icon
has. 

Any comments welcome. 

Greetings,

Jan

P.S. I am *extremely* sad I can't obtain an Icon T-shirt
or Coffee Mug, just because I happen to live in Europe. I'd love
to wear an Icon T-Shirt here at the institute. Could anyone
perhaps send me a postscript file of an Icon logo that I can 
put on a T-shirt myself? It has to be approx. A4 size (we have 
these shops here that "xerox" pictures on t-shirts).

Jan Peter de Ruiter
-------------------
Max Planck Institute for Psycholinguistics
Nijmegen
The Netherlands


From icon-group-sender  Thu May 26 12:46:16 1994
Received: by cheltenham.cs.arizona.edu; Thu, 26 May 1994 15:04:06 MST
Date: Thu, 26 May 1994 12:46:16 MST
From: "Cliff Hathaway" <cliff>
Message-Id: <199405261946.AA08109@cheltenham.cs.arizona.edu>
To: icon-group@cs.arizona.edu, janpeter@mpi.nl
Subject: Re:  icon course
Cc: janpeter@mpi.kun.nl
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Jan Peter de Ruiter wrote:

> 
> Hi folks,
> 
> I've finally convinced enough members of our institute to use
> Icon to justify giving an Icon course. 

  [stuff about teaching Icon deleted - hopefully someone who has actually
   taught it can help Jan with this]

> 
> P.S. I am *extremely* sad I can't obtain an Icon T-shirt
> or Coffee Mug, just because I happen to live in Europe. I'd love
> to wear an Icon T-Shirt here at the institute. Could anyone
> perhaps send me a postscript file of an Icon logo that I can 
> put on a T-shirt myself? It has to be approx. A4 size (we have 
> these shops here that "xerox" pictures on t-shirts).
> 
> Jan Peter de Ruiter
> -------------------
> Max Planck Institute for Psycholinguistics
> Nijmegen
> The Netherlands
> 

There are many Icon-related images in the /icon/images directory at
the ftp archive: ftp.cs.arizona.edu.

cliff



From icon-group-sender  Mon May 30 19:16:46 1994
Received: by cheltenham.cs.arizona.edu; Mon, 30 May 1994 13:22:54 MST
Date: 30 May 94 19:16:46 GMT
From: agate!news.ossi.com!news.fai.com!amdahl!pacbell.com!ihnp4.ucsd.edu!usc!howland.reston.ans.net!EU.net!sunic!trane.uninett.no!nntp.uio.no!ifi.uio.no!naggum.no!comp-text-sgml@ucbvax.  (Ken Holman)
Subject: Re: Spitbol reference?
Message-Id: <9405252345.AA3100@notes.notes>
References: <CpyDI0.M9M@world.std.com>, <CqBJ8u.B6s@unx.sas.com>, <1994May24.212757.11431@midway.uchicago.edu>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

[Gary Merrill]

|   It is one of my favorite languages, though one hardly sees it used much
|   any more at all.

[John Smith]

|   I like Snobol

I, personally, hated using Snobol but was biased because I only had to
learn it and know it for two weeks to do a single assignment regarding
pattern matching in a languages course in 1978 and haven't needed to touch
it since.

What features of the language particularly helped you or made you feel that
the language was more useful than others?

The only thing I remember from Snobol was that there was no such thing as a
syntax error.  My recollection is that anything and everything that could
be typed on a line _meant_ something.  There were no bounds to help with
identifying typos, improperly typed constructs, etc.

Very frustrating when an assignment had to be done in short order.

--
G. Ken Holman                 | Phone:  +1 613 727-5696  x317
Vice President, R&D           | Fax:    +1 613 727-9491  
Microstar Software Ltd.       | US:      1 800 267-9975  
34 Colonnade Road North       | BBS:    +1 613 727-5272  
Nepean Ontario CANADA K2E-7J6 | E-mail: gkholman@msl.isis.org


From icon-group-sender  Sun May 29 07:21:44 1994
Received: by cheltenham.cs.arizona.edu; Mon, 30 May 1994 13:23:37 MST
Date: 29 May 94 07:21:44 GMT
From: dog.ee.lbl.gov!agate!msuinfo!uchinews!iitmax!news@ucbvax.Berkeley.EDU  (Michael Glass)
Organization: Illinois Institute Of Technology, Chicago.
Subject: Re: Spitbol reference?
Message-Id: <1994May29.072144.22870@iitmax.iit.edu>
References: <1994May24.212757.11431@midway.uchicago.edu>, <9405252345.AA3100@notes.notes>, <2s38k6$g2m@underdog.jpl.nasa.gov>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Let's not critize Mr. Holman.  There is a wonderful typographical error
in an example program at the end of the 2nd edition of the Snobol book
in which the "*" was omitted from a comment.  The result is that an
English sentence (sans punctuation) is mixed in with the program source.

Even with a random English sentence added, there are no errors and
the program works as it was designed.

Ken Holman wrote, in part:

> The only thing I remember from Snobol was that there was no such thing as a
> syntax error. 

-- Michael Glass
   Caveat Poster


From icon-group-sender  Sun May 29 23:57:42 1994
Received: by cheltenham.cs.arizona.edu; Mon, 30 May 1994 13:23:49 MST
Date: 29 May 94 23:57:42 GMT
From: news.delphi.com!usenet@uunet.uu.net  (Will Mengarini)
Organization: Delphi (info@delphi.com email, 800-695-4005 voice)
Subject: Re: Spitbol reference?
Message-Id: <ZY6vmRG.mengarini@delphi.com>
References: <9405252345.AA3100@notes.notes>, <2s38k6$g2m@underdog.jpl.nasa.gov>, <1994May29.072144.22870@iitmax.iit.edu>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Michael Glass <CSGLASS@minna.acc.iit.edu> writes:
 
>Ken Holman wrote, in part:
 
 
>> The only thing I remember from Snobol was that there was no such thing as a
>> syntax error. 
 
 
>Let's not critize Mr. Holman.  There is a wonderful typographical error
>in an example program at the end of the 2nd edition of the Snobol book
>in which the "*" was omitted from a comment.  The result is that an
>English sentence (sans punctuation) is mixed in with the program source.
 
 
>Even with a random English sentence added, there are no errors and
>the program works as it was designed.
 
This a program I'd like to see--is it short enough to type in?


From icon-group-sender  Mon May 30 05:08:09 1994
Received: by cheltenham.cs.arizona.edu; Mon, 30 May 1994 13:24:08 MST
From: Jan Peter de Ruiter <janpeter@mpi.nl>
Message-Id: <9405301307.AA02134@mpix10.mpi.kun.nl>
Subject: icon binaries in HP-UX
To: icon-group@cs.arizona.edu
Date: Mon, 30 May 94 14:08:31 METDST
Cc: janpeter@mpi.kun.nl
Mailer: Elm [revision: 70.85]
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Hi everybody,

I just got a new HP workstation (HP 716/60) so I ftp-ed the 
HP binaries for Icon 8.10. However, when I run iconx I get 
this message:

/lib/dld.sl: Can't open shared library: /usr/lib/libX11.sl
/lib/dld.sl: No such file or directory
core dumped

These files are somewhere else, on my machine.

Does anyone know if there's an environment var or something
that I can set so I can run iconx without recompiling all 
sources?

Thanks in advance for any help

Jan 

Jan Peter de Ruiter
-------------------
Max Planck Institute for Psycholinguistics
Nijmegen
The Netherlands


From icon-group-sender  Mon May 30 17:22:48 1994
Received: by cheltenham.cs.arizona.edu; Tue, 31 May 1994 09:41:47 MST
To: icon-group@cs.arizona.edu
Subject: Re: Spitbol reference?
Message-Id: <770318568@mse>
Date: Mon, 30 May 94 17:22:48 UTC
From: whm%mse@uunet.uu.net (William H. Mitchell)
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

    Michael Glass writes:

    Let's not critize Mr. Holman.  There is a wonderful typographical error
    in an example program at the end of the 2nd edition of the Snobol book
    in which the "*" was omitted from a comment.  The result is that an
    English sentence (sans punctuation) is mixed in with the program source.

    Even with a random English sentence added, there are no errors and
    the program works as it was designed.

There is a story, perhaps apocryphal, of a CS student at North Carolina State
University who, as a matter of style, *never* used the SNOBOL4 comment
indicator -- his comments were simply pattern matches that failed.

While we're down memory lane -- is there anybody out there who used Ratsno
on a regular basis?  That was a one day project of Dave Hanson's to
retarget Ratfor from FORTRAN to SNOBOL4.  I came across it early in my
junior year as an undergraduate and used it for the balance of my
undergraduate work when I had a choice of language.  I never converted any
of my peers to it, but I had a great time with it.



From icon-group-sender  Tue May 31 09:51:03 1994
Received: by cheltenham.cs.arizona.edu; Tue, 31 May 1994 13:45:00 MST
Message-Id: <9405311651.AA25281@hpclpax.cup.hp.com>
To: Jan Peter de Ruiter <janpeter@mpi.nl>
Cc: icon-group@cs.arizona.edu
Subject: Re: icon binaries in HP-UX 
Date: Tue, 31 May 1994 09:51:03 -0700
From: Cary Coutant <cary@hpclpax.cup.hp.com>
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

> I just got a new HP workstation (HP 716/60) so I ftp-ed the 
> HP binaries for Icon 8.10. However, when I run iconx I get 
> this message:
> 
> /lib/dld.sl: Can't open shared library: /usr/lib/libX11.sl
> /lib/dld.sl: No such file or directory

Check out the chatr(1) manual page.  You can set the SHLIB_PATH
environment variable to point to /usr/lib/X11R5, and use
"chatr +s enable" on the iconx executable.

Cary Coutant
Hewlett-Packard
California Language Lab


From icon-group-sender  Tue May 31 12:49:00 1994
Received: by cheltenham.cs.arizona.edu; Tue, 31 May 1994 13:47:04 MST
Date: Tue, 31 May 1994 12:49:00 -0500 (CDT)
From: Gustavo Cavazos <gcavazos@fermat.rzs.itesm.mx>
Subject: sys/socket.h, netinet/in.h
To: icon <icon-group@cs.arizona.edu>
Message-Id: <Pine.3.89.9405311241.B56585-0100000@fermat.rzs.itesm.mx>
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; charset=US-ASCII
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

How does one uses the  sys/socket.h, netinet/in.h libraries with icon.
Does icon implements its own?

+Gus
===============                                     =========
Gustavo Cavazos                                     ITESM-CEM
gcavazos@fermat.rzs.itesm.mx          
gcavazos@nostromo.cem.itesm.mx                        "Moo"
gcavazos@itesmvf1.rzs.itesm.mx                 



From icon-group-sender  Thu Jun  2 17:34:14 1994
Received: by cheltenham.cs.arizona.edu; Thu, 2 Jun 1994 10:49:07 MST
Date: Thu, 2 Jun 1994 17:34:14 +0100
Message-Id: <199406021634.RAA01396@aux.hdata.no>
X-Sender: jon@aux.hdata.no
Mime-Version: 1.0
Content-Type: text/plain; charset="us-ascii"
To: icon-group@cs.arizona.edu
From: Jon.Kleiser@hdata.no (Jon Kleiser)
Subject: Icon for Macintosh?
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

The Icon FAQ of 03/04/94 mentions that there is an Icon implementation for
the Apple Macintosh. Can anybody tell me where I can find such stuff? Is it
commercial? I couldn't see it at cs.arizona.edu. (I've also tried a few
archie searches.)

Sincerely,

Jon Kleiser                         Oslo, Norway




From icon-group-sender  Thu Jun  2 11:06:30 1994
Received: by cheltenham.cs.arizona.edu; Thu, 2 Jun 1994 12:07:04 MST
Date: Thu, 2 Jun 1994 11:06:30 MST
From: "Cliff Hathaway" <cliff>
Message-Id: <199406021806.AA26885@cheltenham.cs.arizona.edu>
To: Jon.Kleiser@hdata.no
Subject: Re:  Icon for Macintosh?
Cc: icon-group
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

> To: icon-group@cs.arizona.edu
> From: Jon.Kleiser@hdata.no (Jon Kleiser)
> Subject: Icon for Macintosh?
> 
> The Icon FAQ of 03/04/94 mentions that there is an Icon implementation for
> the Apple Macintosh. Can anybody tell me where I can find such stuff? Is it
> commercial? I couldn't see it at cs.arizona.edu. (I've also tried a few
> archie searches.)
> 
> Sincerely,
> 
> Jon Kleiser                         Oslo, Norway
> 

Look in /icon/packages/macintosh at cs.arizona.edu.  Here's the READ.ME file
for that directory:


This directory contains Icon for the Macintosh:

	mep1.hqx	ProIcon executables and support files (see note below)
	mep2.hqx

	mem.hqx		Icon executables for the Macintosh (MPW), Version 8.10
	met.hqx		Icon executables for the Macintosh (stand-alone),
			   Version 8.0

	msm-1.hqx	Icon source code for the Macintosh (MPW), Version 8.8
	msm-2.hqx 
	mst.hqx 	Icon source code for the Macintosh (stand-alone),
			   Version 8.0

ProIcon, formerly a commercial product, is no longer marketed and has
been placed in the public domain.  The ProIcon disk images in this directory
contain all the executable files and support material but they do not
include documentation on how to run ProIcon.  The 367-page ProIcon manual
is available for sale from the Icon Project.  The cost is $30, including
shipping to addresses in the United States, Canada, and Mexico.  There is
an additional $25 charge for shipping to other countries.

The supply of the manual is limited.  If you are seriously interested in
using ProIcon, you should order the manual promptly.



From icon-group-sender  Thu Jun  2 14:04:33 1994
Received: by cheltenham.cs.arizona.edu; Thu, 2 Jun 1994 15:47:45 MST
Date: Thu, 2 Jun 1994 14:04:33 -0500 (CDT)
From: Ronan_Collis <Ronan_Collis@mbnet.mb.ca>
Subject: Re: Icon for Macintosh?
To: Jon Kleiser <Jon.Kleiser@hdata.no>
Cc: icon-group@cs.arizona.edu
In-Reply-To: <199406021634.RAA01396@aux.hdata.no>
Message-Id: <Pine.3.05.9406021428.A20991-a100000@access.mbnet.mb.ca>
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; charset=US-ASCII
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

What you are looking for is ProIcon. It is now available at the university
of Arizona as public domain software (you pay for the diskets and copying
and also for the manual and mailing, but that is all). Please contact
Cliff Hathaway <cliff@cs.arizona.edu> RC 
On Thu, 2 Jun
1994, Jon Kleiser wrote:

> The Icon FAQ of 03/04/94 mentions that there is an Icon implementation for
> the Apple Macintosh. Can anybody tell me where I can find such stuff? Is it
> commercial? I couldn't see it at cs.arizona.edu. (I've also tried a few
> archie searches.)
> 
> Sincerely,
> 
> Jon Kleiser                         Oslo, Norway
> 
> 
> 





From icon-group-sender  Thu Jun  2 14:15:20 1994
Received: by cheltenham.cs.arizona.edu; Thu, 2 Jun 1994 15:48:57 MST
Date: Thu, 2 Jun 94 14:15:20 PDT
From: eric@star-semi.com (Eric Armstrong)
Message-Id: <9406022115.AA26472@star-semi.com>
To: icon-group@cs.arizona.edu
Subject: email system??
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

QUESTION 1 (of 2)
-----------------
Have a wild idea in mind:
	. Find sources for a basic email system
	  --preferably one that includes some kind of command processor,
	    like ftp mail
	. Customize it using Icon
	. Modify it to track bug status, log software changes, and describe
	  new features.

Our situation, basically is:
	. we're a small company in a growth spurt
	. we need to start tracking things like these in a methodical way
	. we can't afford a lot of overhead (huge database system with 10
	  administrators)
	. we are distributed, with people working on both coasts (so a 
	  central database-oriented approach is not feasible

The basic idea is to send an email to a cataloging system that understands
some simple commands, can attach messages to different topical "threads", and
allow retreiving as-yet-unread messages -- basically a NEWS kind of application,
now that I think of it.

QUESTION 2 (of 2)
-----------------
Since any existing program that fills the bill is likely to have been written
in C, and since Icon is so very good at sensible string manipulation and
pattern matching, can anyone give me tips on C-to-Icon translation?  (I figure
to do the "smart stuff" at the highest levels in Icon, and call all the low
level nitty-gritty stuff in C.


Can anyone point me to something that will get me started down the right path?
Thanks!


From icon-group-sender  Thu Jun  2 19:28:35 1994
Received: by cheltenham.cs.arizona.edu; Thu, 2 Jun 1994 18:00:38 MST
Date: Thu, 02 Jun 1994 19:28:35 -0400 (EDT)
From: Olivier Lefevre <LEFEVRE@ACFcluster.NYU.EDU>
Subject: Mac Icon
To: icon-group@cs.arizona.edu
Message-Id: <01HD2TGBB9EEN625Q2@ACFcluster.NYU.EDU>
X-Vms-To: IN%"icon-group@cs.arizona.edu"
X-Vms-Cc: LEFEVRE
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; CHARSET=US-ASCII
Content-Transfer-Encoding: 7BIT
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Just as an aside, that means that ProIcon is forever frozen at 8.0 level, right?

Olivier Lefevre, Postdoctoral Fellow

Dept. of Molecular Immunology, Hosp. for Joint Diseases, NYU Medical School, 
New York City, NY & IBM T.J.Watson Research Center, Yorktown Heights, NY



From icon-group-sender  Thu Jun  2 18:04:05 1994
Received: by cheltenham.cs.arizona.edu; Fri, 3 Jun 1994 09:24:32 MST
Date: Thu, 2 Jun 1994 18:04:05 MST
From: "Ralph Griswold" <ralph>
Message-Id: <199406030104.AA09635@cheltenham.cs.arizona.edu>
To: LEFEVRE@ACFcluster.NYU.EDU
Subject: Re:  Mac Icon
Cc: icon-group
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Yes, ProIcon is forever frozen at 8.0.  (That's not all that bad considering
the extras ProIcon offers.)   The source code is proprietary and unavailable.
    
Ralph E. Griswold			ralph@cs.arizona.edu
Department of Computer Science 		 uunet!arizona!ralph
The University of Arizona		602-621-6609 (voice)
Tucson, AZ 85721			602-621-4246   (fax)


From icon-group-sender  Fri Jun  3 09:20:05 1994
Received: by cheltenham.cs.arizona.edu; Fri, 3 Jun 1994 09:27:17 MST
Date: Fri, 03 Jun 1994 09:20:05 -0600 (CST)
From: Chris Tenaglia - 257-8765 <TENAGLIA@MIS.MCW.EDU>
Subject: Re: email system??
To: icon-group@cs.arizona.edu
Message-Id: <01HD3MG181UQ8WWJM2@mis.mcw.edu>
Organization: Medical College of Wisconsin (Milwaukee, WI)
X-Vms-To: IN%"icon-group@cs.arizona.edu"
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; CHARSET=US-ASCII
Content-Transfer-Encoding: 7BIT
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

> From:	IN%"eric@star-semi.com"  2-JUN-1994 17:54:32.04
> To:	IN%"icon-group@cs.arizona.edu"
> Subj:	email system??

> QUESTION 1 (of 2)
> -----------------
> ...
> QUESTION 2 (of 2)
> -----------------
> ...

I've  done  an  icon  email  thing.  It works, but it's so complicated I
wouldn't  want  to  share it because it relies on so many components. It
was  a  great  exercize to get to know all the pieces of email. It's not
just a MAIL.EXE.  It's enough work just for me to support it for myself.
But here is my experience and a couple pointers.

I  wrote  it  kind  of  in the unlikely event that someday my management
would equip me with a laptop on business trips (instead of the satellite
pager).  The  local office runs on a VMS VAX with VMS MAIL. We also have
add-ons  that  extend that email to internet as well. I load this laptop
with  some  software and a modem. Then at convenient times I'd dial back
and download my mailbag. Then I could go through my email off-line at my
leisure  and  formulate  replies,  forwards, and new messages. Later I'd
reconnect  and  a  delivery program in the PC would upload the stuff and
instruct the VAX to deliver everything.

I  use  icon for the user interface (mail user agent) in the PC. It also
takes  the  giant  appended  email  file  and  splits it into individual
messages  for  later reading. It also has to know formulate replies from
the  headers. It's also a good idea to use index files to speed lookups.
I  use  an old IBM XT so speed has to be in the software rather than the
hardware.  I  use  a  DOS  env  var  to  choose  a  favorite editor/word
processor.  I  use  ZIP  to compress the mailbags on both ends to reduce
file  transfer  time.  I use MS-kermit scripts to do the communications,
and  VMS/DCL  batch language to deliver the mail. It took a couple weeks
of  evenings to kludge it all together. I have a partially finished unix
version  too,  but  work  has  kind  of stopped there. I think there are
commercial  packages  that  can  do all this too, but sometimes labor is
cheaper, and the exersize is worth the effort.

If you don't already have mail server hosts, then you will also have fun
writing the mail backend (mail handling system). I'm not that ambitious.
Good luck.

Chris Tenaglia (System Manager) |  "The past explained,     
Medical College of Wisconsin    |   the future fortold, 
8701 W. Watertown Plank Rd.     |   the present largely appologized for."
Milwaukee, WI 53226             |   Organon to The Doctor
(414)257-8765                   |     
tenaglia@mis.mcw.edu



From icon-group-sender  Fri Jun  3 00:40:01 1994
Received: by cheltenham.cs.arizona.edu; Tue, 7 Jun 1994 08:23:30 MST
To: rcm!uunet!cs.arizona.edu!icon-group@uunet.uu.net
Subject: Re: email system??
Message-Id: <770604001@mse>
Date: Fri, 03 Jun 94 00:40:01 UTC
From: whm@mse (William H. Mitchell)
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Eric -- take a look at GNATS, a GNU bug tracking system.  It's e-mail based
and is very much like what you described.

     /------------------------------\         /----------------\
    /      William H. Mitchell       \       / 7120 E. Kiva Way \
   /  Mitchell Software Engineering   \o----/ Tucson, AZ, 85715  \
   \ Consulting/Development/Training  /     \    602-577-6431    /
    \   OO Methods/C++/Icon/UNIX     /       \    whm@mse.com   /
     \------------------------------/         \----------------/



From icon-group-sender  Tue Jun  7 16:31:18 1994
Received: by cheltenham.cs.arizona.edu; Tue, 7 Jun 1994 18:13:57 MST
Date: Tue, 7 Jun 94 16:31:18 PDT
From: eric@star-semi.com (Eric Armstrong)
Message-Id: <9406072331.AA07354@star-semi.com>
To: icon-group@cs.arizona.edu
Subject: library of file operations
Cc: icon-project@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Have been toying around with icon for a little bit now, and must say that
I am mostly loving it.  My most recent effort was a little program to 
add positive and negative numbers at the beginning of a line.  Fun to program,
and quite simple, compared to what would be required in other languages.

Since I work on a Sun system, and have a 486 system at home, I see the
need for a library of system-independent file functions.  For example, I
would like to see:
	a. given a path, return size
	b. given a path, return date & time of last modification
	c.   "   "   "      "   creation date & time
	d. given a name, return path (search current dir, then search path)
	e. generate file names in a directory (may already be in prog library)
	f. identify type of file (directory, file, link)
	g. file attributes (this is hard: permissions-structures differ a lot)

In some cases, systems without the requisite functionality could return an
appropriate value (ex1: if no concept of path, the function path(name) would
return name.  ex2: if no modification time, return &null.)  In other cases,
lowest-common denominator may be the only possiblity -- for example, only 
"owner" permissions, since not all systems have permissions for group & world.

Although a function for any one system would not be so hard, making a function
that worked across all systems would be tough.  Anyone have any ideas on this
issue, or have some libraries that would solve dos/unix part of the problem?

Thanks.

p.s. regarding last request on a way to handle bugs.  Am currently evaluating
     a GNU-based system, GNATs, that comes with a good recommendation.  The
     other interesting recommendation was Lotus NOTES.  Both are reported to
     substantially fill the requirements I specified.




From icon-group-sender  Wed Jun  8 00:56:51 1994
Received: by cheltenham.cs.arizona.edu; Wed, 8 Jun 1994 06:43:59 MST
Via: uk.ac.edinburgh.festival; Wed, 8 Jun 1994 08:56:26 +0100
Date: 08 Jun 94 08:56:18 BST
From: R J Hare <rjhare@festival.ed.ac.uk>
Subject: Dedicated databases
To: icon-group@cs.arizona.edu
Organisation: Edinburgh University Computing Service
Message-Id: <9406080856.aa21126@uk.ac.ed.festival>
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

I have a need (well, several other people do, actually) for a
dedicated database for cataloguing books, records, CDs and tapes. I would
like to tackle this as a small project in Icon. Does anyone have any
suggestions as to the 'best' way to do this? I have my own ideas (for
example, books might be delt with as a list of tables, each table having
fields such as book["author"], book["title"], etc., but I would welcome
suggestions from other Icon programmers...

Thanks

Roger Hare.


From icon-group-sender  Wed Jun  8 11:21:31 1994
Received: by cheltenham.cs.arizona.edu; Wed, 8 Jun 1994 06:44:38 MST
Date: 8 Jun 94 11:21:31 GMT
From: agate!howland.reston.ans.net!pipex!uknet!EU.net!sunic!trane.uninett.no!nac.no!ifi.uio.no!si.sintef.no!si.sintef.no!Michael.O.Sullivan@ucbvax.Berkeley.EDU  (Michael OSullivan)
Organization: SINTEF
Subject: Examples of ICON with Mosaic??
Message-Id: <Michael.O.Sullivan.134.009688F7@si.sintef.no>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


	Hi,

	I am using Mosaic for windows, and running the httpd server for windows.
	I want to use ICON to parse strings passed from Mosaic to the server.
 	( someone told me ICON is good at this sort of thing )
	Anyway what I need are examples of this string parsing from Mosaic and also 
	how ICON displays HTML format documents.

	Can anyone help me!

	Thanks in Advance,

	Michael.


From icon-group-sender  Wed Jun  8 07:55:43 1994
Received: by cheltenham.cs.arizona.edu; Wed, 8 Jun 1994 09:04:36 MST
Via: uk.ac.edinburgh.festival; Wed, 8 Jun 1994 14:50:51 +0100
Date: 08 Jun 94 14:50:45 BST
From: R J Hare <rjhare@festival.ed.ac.uk>
Subject: Catalogue (again...)
To: icon-group@cs.arizona.edu
Organisation: Edinburgh University Computing Service
Message-Id: <9406081450.aa29975@uk.ac.ed.festival>
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Earlier today I posted a request concerning dedicated database programs for
cataloguing books, etc.

At least one person has been good enough to reply, but our mail system, in a
moment of madness seems to have cast this message into the outer darkness...

I'd be grateful if you could repost - sorry for the hassles...

Many thanks.

Roger Hare.


From icon-group-sender  Wed Jun  8 10:44:56 1994
Received: by cheltenham.cs.arizona.edu; Wed, 8 Jun 1994 09:05:21 MST
From: Bill Mee <bill_mee@wiltel.com>
Message-Id: <9406081544.AA12420@atg.wiltel.com>
Date: Wed, 8 Jun 94 10:44:56 -0500
To: Icon-group@cs.arizona.edu
Subject: 486 NeXTStep version of Icon?
Status: R
Errors-To: icon-group-errors@cs.arizona.edu



Icon Users,

Does anyone know what needs to be done to get a running 

version of Iconc running under NeXTStep on an Intel-486
machine.  I tried choosing the next configuation but
during the compile phase I got the message, "no such 

386 instruction 'moveml'." I added '#define NoCoexper'
to config/unix/next/define.h but I received the same
message. I tried choosing the i386_linux (BSD flavor of
unix) to no avail.  If anyone has done this before,
please let me know.

Bill Mee (bill_mee@wiltel.com) 


From icon-group-sender  Wed Jun  8 15:37:49 1994
Received: by cheltenham.cs.arizona.edu; Wed, 8 Jun 1994 16:05:38 MST
Date: 8 Jun 94 15:37:49 GMT
From: agate!howland.reston.ans.net!swrinde!news.uh.edu!mtecv2.mty.itesm.mx!fermat!gcavazos@ucbvax.Berkeley.EDU  (Gustavo Cavazos)
Organization: ITESM, Campus Monterrey
Subject: Expert Shells in Icon
Message-Id: <2t4okd$2g51@mtecv2.mty.itesm.mx>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Are there any expert shells in Icon out there, i woul like to have a look
at one.

Saludos,
+Gus
===============                                     =========
Gustavo Cavazos                                     ITESM-CEM
gcavazos@fermat.rzs.itesm.mx          
gcavazos@nostromo.cem.itesm.mx                        "Moo"
gcavazos@itesmvf1.rzs.itesm.mx                 


From icon-group-sender  Thu Jun  9 12:19:07 1994
Received: by cheltenham.cs.arizona.edu; Thu, 9 Jun 1994 07:51:05 MST
From: LARSSON@ntcclu.ntc.nokia.com
Date: Thu, 9 Jun 1994 12:19:07 +0400 (EET-DST)
To: icon-group@cs.arizona.edu
Cc: LARSSON@ntcclu.ntc.nokia.com
Message-Id: <940609121907.26601057@ntcclu.ntc.nokia.com>
Subject: RE:Dedicated database in Icon
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Apropos Roger Hare's question on database programming, I recall
there is an example in the book "Icon programming for humanists" by
Alan Corre' (name hopefully not misspelled), which may be elaborated
upon.

Perhaps more realistically, chapter 4 of "The AWK programming language"
by Aho, Kernighan and Weinberger (Addison-Wesley 1988, ISBN 0-201-07981-X)
describes a relational database system written entirely in AWK, with
report generation, form letters and query language. Would their model
be useful, at least to get you started?

It would be interesting to hear more about this project.

Arne 
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
Arne Larsson			Nokia Telecommunications
Translator			Transmission Systems, Customer Services
larsson@ntc02.tele.nokia.fi	P.O. Box 12, SF-02611 Espoo, Finland
larsson@ntcclu.ntc.nokia.com	Phone +358 0 5117476, Fax +358 0 51044287
Arne.Larsson@ntc.nokia.com
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*



From icon-group-sender  Thu Jun  9 04:21:54 1994
Received: by cheltenham.cs.arizona.edu; Thu, 9 Jun 1994 08:10:20 MST
Date: Thu, 09 Jun 94 13:23:01 MET
From: Michael.O.Sullivan@si.sintef.no
Message-Id: <9405097711.AA771193381@ccmail-smtp.si.sintef.no>
To: icon-group@cs.arizona.edu
Subject: 
Status: RO
Errors-To: icon-group-errors@cs.arizona.edu


     
     Hi,
     
        I am a complete newbie to the world of ICON and need some help.
        
        I want to write a ICON script which will parse a string sent from 
        MOSAIC and then display appropiate stuff in HTML format.
        I've heard ICON can do this quite well but I haven't a clue how to 
        do it.
        Has anyone got any examples or pointers to info.
     
        Thanks.
     
     
     Michael.
     
        p.s. I'm running Win Mosaic and the httpd server for windows
                - if that makes a difference.
     


From icon-group-sender  Fri Jun 10 23:28:26 1994
Received: by cheltenham.cs.arizona.edu; Sun, 12 Jun 1994 13:57:39 MST
Date: Sat Jun 11 11:29:23 1994 (GMT + 0530)
From: rajiv@parcom.ernet.in (Rajiv Deshpande)
Message-Id: <9406110559.AA01829@parcom>
Organisation: <Centre for Development of Advanced Computing, Pune, INDIA>
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


Hello,


	 I have joined this users group recently, and also new to ICON
Programming, I would like to more about it.

I hope you will help me, I wiil be having douts.

I would be also thankfull if anybody could send the the compiler for
the ICON. Because we don't have the FTP facility. And I am very much
interested to do programming.

I hope you will help me.


Rajiv Deshpande

Office Address :

Research Associate
Center for Development of Advanced Computing (C-DAC)

e-mail : rajiv@parcom.ernet.in

Residence Address :


c/o Mr. R. D. Deshpande
F-Civil C.M.E. Dapodi
Pune 411 031
Maharashtra ( INDIA ).





From icon-group-sender  Sat Jun 11 01:15:37 1994
Received: by cheltenham.cs.arizona.edu; Sun, 12 Jun 1994 14:14:29 MST
Via: uk.ac.edinburgh.festival; Sat, 11 Jun 1994 09:15:04 +0100
Date: 11 Jun 94 09:14:58 BST
From: R J Hare <rjhare@festival.ed.ac.uk>
Subject: Databases
To: icon-group@cs.arizona.edu
Organisation: Edinburgh University Computing Service
Message-Id: <9406110914.aa19146@uk.ac.ed.festival>
Status: RO
Errors-To: icon-group-errors@cs.arizona.edu

Thanks to all who reponded to my query about databases.

Suggestions covered a wide range of options and included:

Use a flat file database
Use Shoebox (or some other proprietary db)
Use BiBTeX (I actually already use Scribe for my works db of papers)
Use Awk (example in the Awk book)
Use the Icon db progams in ipl
Use the example in Alan Corres' book

I also had a look at:

Programming Tools (K & R)
Algorithms in Snobol 4 (Gimpel)
String & List Processing in Snobol 4 (Griswold)

In the end, for various reasons to do with portability, simplicity, cost,
compute-literacy of the end-users (well, some of them - probably including
me!), and, finally, the fact that I like programming in Icon, I will be going
for a combination of the first and last options, ie: a flat file database
using the db program in Corres' book as a starting point.

This means that I can store the database as a simple text file with lines of
the form:

author|initials|title|publisher|date|isbn|price|date_of_entry

and read such records into whatever Icon structure is necessary for the task
in hand. For example to add records, I don't even need to read the db in, I
just open the file in "a" mode. When I want to sort the file, I just call in
the system sort. I only really need to read in the whole shootn' match when I
want to do a search or report.

This approach will get me on the air asap, but allows for more sophisticated
programming as I have new ideas - all that is necessary is that I maintain the
format of the flat db file (which I can't see any reason to change - all the
information I want about my book collection is there).

I haven't yet given much thought to how to modify this to cope with
discs/tapes/cds which have pieces by different composers on them.

If anyone is interested, let me know and I will keep them informed about this
(and I stress) simple project.

Roger Hare.


From icon-group-sender  Mon Jun 13 14:47:23 1994
Received: by cheltenham.cs.arizona.edu; Mon, 13 Jun 1994 15:01:02 MST
Date: Mon, 13 Jun 1994 14:47:23 -0700 (PDT)
From: Chris Rines <CHRISR@wmcv01.hosp.gov.bc.ca>
Subject: Text Formatting Languages
To: icon-group@cs.arizona.edu
Message-Id: <01HDHWVL70HECV8HLN@VENUS.GOV.BC.CA>
X-Vms-To: intnet::"icon-group@cs.arizona.edu"
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; CHARSET=US-ASCII
Content-Transfer-Encoding: 7BIT
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


Hi All,

I was wondering if anyone had an example of a text formatting language
done in Icon.  I'd like to build a program to take one definition file
(say RTF) and change it into another (say HTML).

ANY pointers or comments always appreciated,

Chris Rines

Work : chrisr%wmcv01@venus.gov.bc.ca
Home : crines@epaus.island.net




From icon-group-sender  Mon Jun 13 16:33:38 1994
Received: by cheltenham.cs.arizona.edu; Mon, 13 Jun 1994 18:31:06 MST
Date: Mon, 13 Jun 1994 16:33:38 -0700 (PDT)
From: Chris Rines <CHRISR@wmcv01.hosp.gov.bc.ca>
Subject: Hypertext Like Programs
To: icon-group@cs.arizona.edu
Message-Id: <01HDI0LIGLLECVC40V@VENUS.GOV.BC.CA>
X-Vms-To: intnet::"icon-group@cs.arizona.edu"
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; CHARSET=US-ASCII
Content-Transfer-Encoding: 7BIT
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


Hi All,

Has anyone put together a hypertext like system with Icon.  I'm looking
for examples of something similair to Microsoft Help.

Any Help Would Be Great,

Chris


Work : chrisr%wmcv01@venus.gov.bc.ca
Home : crines@epaus.island.net



From icon-group-sender  Wed Jun 15 04:24:26 1994
Received: by cheltenham.cs.arizona.edu; Wed, 15 Jun 1994 08:34:12 MST
Date: 15 Jun 94 04:24:26 GMT
From: news.delphi.com!usenet@uunet.uu.net
Organization: Delphi (info@delphi.com email, 800-695-4005 voice)
Subject: Coexpression Question
Message-Id: <Js+OHX6.cbarilleaux@delphi.com>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Hi! I'm trying to learn Icon, but have reached a road block in my studies.
I wanted to write a "spinner" program, which would use the /,\,-,and |
characters to produces a spinning inmage, by displaying one, using \b
to delete it, then displaying the next. having just finished the chapter
of _The Icon Programming Language_ on co-expressions, so, I thoughtI could
use them. The code looks like this:
 
procedure main()
    spin:=create("\b-"|"\b\\"|"\b|"|"\b/")
    writes(" ")
    every 1 to 50 do {
        writes(@spin)|spin:=^spin
    }
    write("\n")
end
 
However, I try running it, and I get the follwing error messages:
 
C:\PRG\ICON\WORK>iconx spinfoo
-
Run-time error 111
File spinfoo.icn; Line 5
variable expected
offending value: "\b-"
Trace back:
   main()
   {"\b-" := co-expression_3(0)} from line 5 in spinfoo.icn
 
I ahve tried to figure out just what is meant by this. I have figured out a
work-around, but I suspect that alternation like I used can work.
 
Any advice?
Thanks in advance
--
__________________________________________________________________
Charles Barilleaux                        CBARILLEAUX@DELPHI.COM
First Federal Savings & Loan              Lake Charles, Louisiana
PGP Public Key Available Upon Request


From icon-group-sender  Wed Jun  1 05:10:05 1994
Received: by cheltenham.cs.arizona.edu; Wed, 15 Jun 1994 08:35:25 MST
Date: 1 Jun 94 05:10:05 GMT
From: cis.ohio-state.edu!math.ohio-state.edu!howland.reston.ans.net!wupost!waikato!auckland.ac.nz!collberg.cs.aukuni.ac.nz@ucbvax.Berkeley.EDU  (Christian Collberg)
Organization: University of Auckland
Subject: URGENT: travels.icn won't work?
Message-Id: <2sh57d$a4q@ccu2.auckland.ac.nz>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


When I run travels I get the following error message:

> travels

Run-time error 209
File optwindw.icn; Line 131
invalid second argument to open
offending value: "x"
Trace back:
   main(list_1 = [])
   optwindow(table_1(7),list_3 = ["travels","x","cursor=off",...,"height=520","fg=black","bg=
white"]) from line 168 in travels.icn
   function open ! list_3 = ["travels","x","cursor=off",...,"height=520","fg=black","bg=white
"] from line 131 in optwindw.icn


I would appreciate any help. 

Thanks!

Christian
--
Christian Collberg
Dept. of Computer Science, Univ. of Auckland, Private Bag 92019, Auckland, New Zealand.
email: c_collberg@cs.aukuni.ac.nz | phone: +64-9-373-7599 x8784 | fax: +64-9-373-7453


From icon-group-sender  Wed Jun 15 10:20:37 1994
Received: by cheltenham.cs.arizona.edu; Wed, 15 Jun 1994 12:47:02 MST
Date: Wed, 15 Jun 94 10:20:37 PDT
From: eric@star-semi.com (Eric Armstrong)
Message-Id: <9406151720.AA23031@star-semi.com>
To: icon-group@cs.arizona.edu
Subject: Re: Coexpression Question
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Realized after I sent off this reply that I'm always interested in the
answers others receive to their queries.  Don't know how everyone else
feels, or what internet etiquette is, but I would just as soon see replies
to such questions posted to the group.  They're pretty educational.
(On the other hand, if such a practice goes against the grain, let me know!)

----- Begin Included Message -----

>From eric Wed Jun 15 10:15:48 1994
To: news.delphi.com!usenet@uunet.uu.net
Subject: Re: Coexpression Question
Content-Length: 2057

Hey!  I figured it out!  (I'm pretty new, myself.)
The problem is that the expression is grouping as
	(writes(@spin) | spin ) := ^spin

The writes returns the last value it wrote ("\b-"), which is then used
as the left side of the assignment.

Moral: Always use parentheses in any complex expression that involves 
assignment!

Thanks for the code, by the way.  Can't wait to try it!  

> From icon-group-sender@cs.arizona.edu Wed Jun 15 08:43:54 1994
> Date: 15 Jun 94 04:24:26 GMT
> From: news.delphi.com!usenet@uunet.uu.net
> Organization: Delphi (info@delphi.com email, 800-695-4005 voice)
> Subject: Coexpression Question
> Sender: icon-group-request@cs.arizona.edu
> To: icon-group@cs.arizona.edu
> Content-Length: 1247
> 
> Hi! I'm trying to learn Icon, but have reached a road block in my studies.
> I wanted to write a "spinner" program, which would use the /,\,-,and |
> characters to produces a spinning inmage, by displaying one, using \b
> to delete it, then displaying the next. having just finished the chapter
> of _The Icon Programming Language_ on co-expressions, so, I thoughtI could
> use them. The code looks like this:
>  
> procedure main()
>     spin:=create("\b-"|"\b\\"|"\b|"|"\b/")
>     writes(" ")
>     every 1 to 50 do {
>         writes(@spin)|spin:=^spin
>     }
>     write("\n")
> end
>  
> However, I try running it, and I get the follwing error messages:
>  
> C:\PRG\ICON\WORK>iconx spinfoo
> -
> Run-time error 111
> File spinfoo.icn; Line 5
> variable expected
> offending value: "\b-"
> Trace back:
>    main()
>    {"\b-" := co-expression_3(0)} from line 5 in spinfoo.icn
>  
> I ahve tried to figure out just what is meant by this. I have figured out a
> work-around, but I suspect that alternation like I used can work.
>  
> Any advice?
> Thanks in advance
> --
> __________________________________________________________________
> Charles Barilleaux                        CBARILLEAUX@DELPHI.COM
> First Federal Savings & Loan              Lake Charles, Louisiana
> PGP Public Key Available Upon Request
> 
> 


----- End Included Message -----



From icon-group-sender  Thu Jun 16 09:04:51 1994
Received: by cheltenham.cs.arizona.edu; Thu, 16 Jun 1994 09:36:34 MST
Date: Thu, 16 Jun 1994 09:04:51 -0400
From: Mark.Otto@census.gov (Mark Otto (SRD))
Message-Id: <199406161304.JAA16166@info.census.gov>
To: icon-group@cs.arizona.edu
Subject: Another Spin
Content-Length: 419
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Not to take the fun out of writing coexpressions,
but here is a simpler version of spin I got to
work on a SUN4.  Use ^c to stop the program.

procedure main()
 writes(" ")
 every writes(!|["\b-","\b\\","\b|","\b/"])
end



 Mark Otto
 Census Bureau, Rm 3000-4 (SRD), Washington, DC  20233-4200
 motto@census.gov (at the smtp gateway) or otto@asgard.umd.edu
 home: 301-431-1838, office: 301-763-3957, fax: 301-763-2633


From icon-group-sender  Thu Jun 16 10:17:20 1994
Received: by cheltenham.cs.arizona.edu; Thu, 16 Jun 1994 12:22:34 MST
Date: Thu, 16 Jun 1994 10:17:20 +0700
From: swampler@noao.edu
Message-Id: <9406161717.AA18280@orpheus.gemini.edu>
Subject: Re: Another Spin
To: Mark.Otto@census.gov
Cc: icon-group@cs.arizona.edu
Content-Length: 767
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


>>Not to take the fun out of writing coexpressions,
>>but here is a simpler version of spin I got to
>>work on a SUN4.  Use ^c to stop the program.
>>
>>procedure main()
>> writes(" ")
>> every writes(!|["\b-","\b\\","\b|","\b/"])
>>end
>>

How about:

   procedure main()
      every writes(|!"-\b\\=b|\b/\b")
   end

but to neatly 'spin' any sequence:

   procedure main(args)
      spin_word := args[1] | "-\\|/"

      every writes( weave (spin_word, "\b") )
   end

   procedure weave(s1,s2)
      e1 := create |!s1		# infinite loop of chars from s1
      e2 := create |!s2		# infinite loop of chars from s2
      suspend @!(e1 | e2)	# this expression interleaves result sequences
   end

      
--
Steve Wampler
swampler@gemini.edu
Gemini Project (under AURA)


From icon-group-sender  Thu Jun 16 12:27:04 1994
Received: by cheltenham.cs.arizona.edu; Thu, 16 Jun 1994 15:11:29 MST
Date: Thu, 16 Jun 94 12:27:04 PDT
From: eric@star-semi.com (Eric Armstrong)
Message-Id: <9406161927.AA07961@star-semi.com>
To: icon-group@cs.arizona.edu
Subject: booleans, enumerations, globals
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

I am just beginning to come to grips with the wonderful expressive power
of Icon's expression evaluation, so I'm learning to combine expressions in
ways that implement algorithmns succinctly.  But some parts of my code are
beginning to look pretty ugly.  I'm wondering what idioms you guys use to:

	a. Do a simple boolean test, like
		if a=true	-or-   if a=false

	   At the moment, I'm doing a horrible global definition of true
	   and false, and initializing them at the beginning of the main
	   routine.  Incredibly ugly.  Immediately begins to obscure an
	   otherwise comprehensible algorithm.

	b. Create something like a Pascal enumeration type
	   Days of the week, for example.  I create a list of strings:
	   ["Mon", "Tue", ...] but then I index it by a number (weekday[2]).
	   How would it be possible to index it as weekday[Tue]?

	c. initialize globals
	   The "initial" clause is really excellent in procedures.  Its primary
	   value is that it lets me put initial values in the same place that
	   the variables are used, instead of miles away in some initialization
	   routine.  But every time I need a global, I wind up doing that 
	   same old initialization schtick.  (More than I would like to, as
	   a result of issues #1 and #2.)

Hopefully, there are some idomatic themes that will alleviate these problems.
I look forward to your replies.


From icon-group-sender  Thu Jun 16 21:43:30 1994
Received: by cheltenham.cs.arizona.edu; Fri, 17 Jun 1994 08:06:39 MST
Date: Thu, 16 Jun 1994 21:43:30 MST
From: "Clinton L. Jeffery" <cjeffery>
Message-Id: <199406170443.AA15757@cheltenham.cs.arizona.edu>
To: eric@star-semi.com
Cc: icon-group@cs.arizona.edu
In-Reply-To: Eric Armstrong's message of Thu, 16 Jun 94 12:27:04 PDT <9406161927.AA07961@star-semi.com>
Subject: Re: booleans, enumerations, globals
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

   [Eric writes:]
   I'm wondering what idioms you guys use to:

	   a. Do a simple boolean test, like
		   if a=true	-or-   if a=false

As in LISP, use of the null value is common for this sort of value.
		if \a then ... # if a is not null <==> if a is true
		if /a then ... # if a is null <==> if a is false
Note that most Icon-ers avoid "boolean variables" entirely when they can.

	   b. Create something like a Pascal enumeration type
	      Days of the week, for example.  I create a list of strings:
	      ["Mon", "Tue", ...] but then I index it by a number (weekday[2]).
	      How would it be possible to index it as weekday[Tue]?

Two options come to mind, both dependent upon recent additions to Icon.
I am not sure if they are both in 8.10; I think at least option #1 is.

Option #1 is to $define each value in your enumeration:
$define Mon 1
$define Tue 2

Option #2 is to define a record type
record week(Mon,Tue,Wed,Thu,Fri,Sat,Sun)

then if weekday := week() you can say weekday.Mon or weekday["Mon"]

	   c. initialize globals

There is no help for this and it is a deficiency in the language.
How much is fixing it worth?  :-)

Clint Jeffery, jeffery@ringer.cs.utsa.edu, cjeffery@cs.arizona.edu
U. of Texas at San Antonio


From icon-group-sender  Mon Jun 20 08:33:57 1994
Received: by cheltenham.cs.arizona.edu; Mon, 20 Jun 1994 09:03:10 MST
Date: Mon, 20 Jun 94 08:33:57 PDT
From: eric@star-semi.com (Eric Armstrong)
Message-Id: <9406201533.AA27908@star-semi.com>
To: icon-group@cs.arizona.edu
Subject: education, please
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

This keeps tripping me up:

The following expression succeeds:
	s ?:= { tab(many(" ")); tab(0) }   # "   xxx" => "xxx"

But this one fails:
	s ?:= { tab(many(" ")) & tab(0) }  # "   xxx" => "   "


Which is different than what I expect.  (In my head, the first tab succeeds,
so then the second is evaluated, and that is the result of the expression.
But that's not what happens.  What is wrong with my head?)

Question 2:
   After reading about tab and move for the umpteenth time, I still don't
   see the difference between them.  Is there one?

Appreciation in advance for your patience, tolerance and/or replies.


From icon-group-sender  Mon Jun 20 09:34:17 1994
Received: by cheltenham.cs.arizona.edu; Mon, 20 Jun 1994 12:14:22 MST
Date: Mon, 20 Jun 94 09:34:17 PDT
From: eric@star-semi.com (Eric Armstrong)
Message-Id: <9406201634.AA28443@star-semi.com>
To: icon-group@cs.arizona.edu
Subject: anti-ugly contest
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Help stamp out ugly icon code!

I'm getting better.  My first ugly version of the following routine,
produced after much trial and error, required two (count 'em!) extra
variables.  After some inspection, I managed to reduce it to:

	procedure squeeze(s)	
	   # Squeze out excess blanks from inside a string
	   s2 := ""
	   s ? {
	     while s2 ||:= tab(upto(" ")+1) do tab(many(" "))
	     s2 ||:= tab(0)
	     }
	   return s2
	end

That cut the number of extra variables down to one (s2).
Question: Is there an even more elegant way to do this that requires
no extra variables?


From icon-group-sender  Mon Jun 20 18:36:24 1994
Received: by cheltenham.cs.arizona.edu; Mon, 20 Jun 1994 16:40:48 MST
From: "Art Eschenlauer" <eschen@molbio.cbs.umn.edu>
Message-Id: <9406202336.AA16363@molbio.cbs.umn.edu>
Subject: IClip version 0.2 alpha announcement
To: icon-group@cs.arizona.edu (icon-group@cs.arizona.edu)
Date: Mon, 20 Jun 1994 18:36:24 -0500 (CDT)
Cc: eschen@molbio.cbs.umn.edu (Art Eschenlauer)
X-Mailer: ELM [version 2.4 PL23]
Mime-Version: 1.0
Content-Type: text/plain; charset=ISO-8859-1
Content-Transfer-Encoding: 8bit
Content-Length: 3931      
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Now available at cs.arizona.edu in /icon/iclip

(1) Version 0.2 alpha of the IClip package (IClip0.2a.cpt.hqx)

and

(2) An enhanced version of the iconx interpreter from the standalone Macintosh
version of Icon 8.0 (iconx-update.cpt.hqx) to replace the (buggy) iconx
that I supplied and was incorporated into mse.hqx about a year ago.
To write your own filters for IClip you will need mse.hqx (and I recommend
iconx-update.cpt.hqx as well...)

Enjoy.


What is IClip? That is the subject of the rest of this message:

IClip by Art Eschenlauer (eschen@molbio.cbs.umn.edu)

- Description

IClip is a Macintosh application that "filters" text data on the Clipboard. 
The user copies text data onto the Clipboard from within any application, 
executes an IClip filter, and pastes the resulting text where it is needed. 

IClip does not support styled text. Bold, italic, underlining, superscripting 
and subscripting information will be lost, although this information should not 
interfere with the operation of IClip. IClip is intended for System 7.

IClip filters can be programmed using the Macintosh standalone implementation 
of the Icon programming language, version 8.0. IClip filters are Icon programs 
that are slightly modified after translation. Text data on the Clipboard serves 
as the standard input to the IClip filter, and, when execution is completed, 
the standard output is copied to the Clipboard as text data, in place of the 
input data. (All other IClip operations, including file I/O, work exactly as 
they do for iconx.) Thus, filters can be designed and tested using iconx and 
subsequently converted to IClip-filter format. (Since the Icon interpreter is 
part of the IClip application, iconx is NOT required in addition to IClip in 
order to execute IClip filters.)

IClip is not intended to be a "full-blown" Macintosh implementation of Icon. 
Instead, its purpose is to make Icon's text-processing and computation power 
available for Clipboard-filtering tasks.

- An example

Consider a simple Icon program, 'reverse.icn', that reverses the lines of an 
input file:

    procedure main()
        every writes( reverse( read() ) )
    end

This is translated using the command

    icont reverse

producing the iconx document 'reverse'.  If you run 'reverse' and type

    Able Was I Ere I Saw Elba^D

the computer would reply

    ablE waS I erE I saW elbA

To convert 'reverse' from an iconx document to an IClip filter-document, 
drag-and-drop it onto the 'Icon to IClip' program's icon. Now, if you are using 
a word processor (or whatever) and you copy

    Able Was I Ere I Saw Elba

onto the clipboard and run 'reverse'

    ablE waS I erE I saW elbA

is placed onto the clipboard in its place. For convenience (under System 7), 
the 'reverse' IClip filter-document can be put into the Apple Menu Items folder 
and invoked simply by selecting 'reverse' off of the Apple menu.

++++++++++   NOTICE - GRATIS EXPERIMENTAL SOFTWARE   ++++++++++

THIS IS EXPERIMENTAL SOFTWARE THAT IS PROVIDED "AS IS" FOR YOUR USE, GRATIS. 
NO  WARRANTY OR REPRESENTATION WHATSOEVER, EITHER EXPRESS OR IMPLIED, IS GIVEN 
WITH RESPECT TO THIS SOFTWARE, ITS QUALITY, PERFORMANCE, MERCHANTABILITY, OR 
FITNESS FOR A PARTICULAR PURPOSE. IF YOU CHOOSE TO USE IT, YOU ASSUME ALL RISKS 
AS TO ITS QUALITY AND PERFORMANCE, INCLUDING (BUT NOT LIMITED TO) LOST TIME, 
DATA, MONEY, AND USE OF, OR DAMAGE TO, YOUR COMPUTER, YOUR BRAIN, ETC.. NO ONE 
SHALL IN ANY EVENT BE HELD LIABLE  FOR ANY DAMAGE OR LOSS THAT MAY BE CAUSED 
BY, OR MAY BE ASSOCIATED WITH, THIS SOFTWARE.

Translation: you didn't pay (or shouldn't have paid) for this EXPERIMENTAL 
software, so it's up to you to cover any damages. While I have tested this 
software (somewhat) and have no malicious intent in providing this software, 
excrement transpires, and it's up to you to wipe it up. YOU MAY NOT USE THIS 
SOFTWARE IF YOU DO NOT AGREE WITH THE ABOVE.



From icon-group-sender  Mon Jun 20 16:37:31 1994
Received: by cheltenham.cs.arizona.edu; Mon, 20 Jun 1994 16:41:15 MST
From: Nevin Liber <nevin@caslon>
Message-Id: <199406202337.QAA24228@caslon.CS.Arizona.EDU>
Subject: Re: education, please
To: icon-group@cs.arizona.edu (Icon Group)
Date: Mon, 20 Jun 1994 16:37:31 -0700 (MST)
X-Mailer: ELM [version 2.4 PL23]
Content-Type: text
Content-Length: 770       
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Eric Armstrong proudly drove the following message along the Information SuperHypeway(TM) at breakneck speeds:

> Question 2:
>    After reading about tab and move for the umpteenth time, I still don't
>    see the difference between them.  Is there one?

Yes.  tab() goes to an absolute position, while move() goes a relative
amount from the current position (during string scanning, this value is
found in &pos).

Suppose you had the following due to previous string scanning:

&subject:	"Nothing up my sleeve, Rocky"
&pos:		9

tab(12) would return "up "
move(12) would return "up my sleeve"
-- 
	Nevin ":-)" Liber	nevin@cs.arizona.edu	(602) 293-2799
	                 	                    	 +++ (520) after 3/95
	                 	             office:	(602) 621-1685


From icon-group-sender  Tue Jun 21 11:27:52 1994
Received: by cheltenham.cs.arizona.edu; Tue, 21 Jun 1994 06:40:56 MST
Message-Id: <m0qG32b-000BzQC@bootes.cus.cam.ac.uk>
X-Sender: jdg1002@pop.cus.cam.ac.uk
Mime-Version: 1.0
Content-Type: text/plain; charset="us-ascii"
Date: Tue, 21 Jun 1994 11:27:52 +0100
To: icon-group@cs.arizona.edu
From: Jason Grossman <Jason.Grossman@ucs.cam.ac.uk>
Subject: Re: anti-ugly contest
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

>Help stamp out ugly icon code!
>
>I'm getting better.  My first ugly version of the following routine,
>produced after much trial and error, required two (count 'em!) extra
>variables.  After some inspection, I managed to reduce it to:
>
>        procedure squeeze(s)
>           # Squeze out excess blanks from inside a string
>           s2 := ""
>           s ? {
>             while s2 ||:= tab(upto(" ")+1) do tab(many(" "))
>             s2 ||:= tab(0)
>             }
>           return s2
>        end
>
>That cut the number of extra variables down to one (s2).
>Question: Is there an even more elegant way to do this that requires
>no extra variables?


I do it using a replace procedure, so I could say

procedure squeeze (s)

        s := replace (" ", "", s)

end

and replace is defined by

procedure replace (a, b, s)

        /s := \&subject  # in case we're doing pattern matching
        while (s [find (a, s)+:*a] := b)
        return s

end


Is this inefficient? (Be lenient. I'm a beginner.)

Jason




From icon-group-sender  Fri Jun 24 09:18:04 1994
Received: by cheltenham.cs.arizona.edu; Fri, 24 Jun 1994 12:35:25 MST
Via: uk.ac.edinburgh.festival; Fri, 24 Jun 1994 16:37:42 +0100
Date: 24 Jun 94 16:37:20 BST
From: R J Hare <rjhare@festival.ed.ac.uk>
Subject: edit-compile-go environment
To: icon-group@cs.arizona.edu
Organisation: Edinburgh University Computing Service
Message-Id: <9406241637.aa17254@uk.ac.ed.festival>
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

I'm currently writing the notes for our new 1 week Fortran 90 course for
postgrads and members of staff. So what? you say, what's that got to do with
Icon?

Well, I'd like if possible to build an integrated 'environment' which allows
the users to edit, compile or execute a file from within a single X window,
possibly by clicking on buttons within the window. (Naturally!) I'd like to
build this using (X-)Icon, but I don't have a feel for this sort of thing at
all. Does anyone have any suggestions as to how to tackle this?

In an ideal world, the user would be able to select an editor an hard-wire it
into his version of the environment, and would also be able to select/deselect
different compiler options, but I'll be settling for a simple compile and for
using xedit or ue in the first instance.

Any suggestions gratefully received...

Thanks.

Roger Hare.


From icon-group-sender  Wed Jun 29 01:16:32 1994
Received: by cheltenham.cs.arizona.edu; Wed, 29 Jun 1994 07:55:15 MST
Date: 29 Jun 94 01:16:32 GMT
From: agate!howland.reston.ans.net!europa.eng.gtefsd.com!sundog.tiac.net!news3.sprintlink.net!news.sprintlink.net!deathstar.cris.com!starcore.cris.com!not-for-mail@ucbvax.Berkeley.EDU  (BobR)
Organization: Concentric Research Corporation
Subject: Help-v8.10 Installation
Message-Id: <2uqi1g$kc5@starcore.cris.com>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

I tried installing V.8.10 Icon (Interpreter/Compiler) on a newly 
installed Linux V1.2.0 system and ran into difficulty running the 
_make Configure_

Has anyone installed Icon on Linux ?

Please let me know. I can supply further details concerning my 
particular problem.

Thanks in advance

Bob Randall
 
... Do not believe in miracles DD rely on them. 
___ Blue Wave/QWK v2.12
    


From icon-group-sender  Wed Jun 29 03:49:24 1994
Received: by cheltenham.cs.arizona.edu; Wed, 29 Jun 1994 07:56:11 MST
Date: 29 Jun 94 03:49:24 GMT
From: agate!darkstar.UCSC.EDU!news.hal.COM!olivea!news.bu.edu!csa!budd@ucbvax.Berkeley.EDU  (Phil Budne)
Organization: Computer Science Department, Boston University, Boston, MA, USA
Subject: Second beta release of SNOBOL4 for Un*x
Message-Id: <2uqr04$9gl@news.bu.edu>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

The second beta version of my port of "The Macro Implementation of
SNOBOL4 for Un*x", a port of the orginal SNOBOL4 language system to
systems with C compilers is now available.  I have fixed many
problems, improved performance and added man features since the beta1
release in February.

In the spirit of the SNOBOL and ICON projects, the source code is
available without copyright restrictions.

The files are available by anonymous ftp from;
	cs.arizona.edu: /snobol4/budne
	alpha.gnu.ai.mit.edu: /budne/snobol

Here is the README file available from those locations;
================================================================

beta2.tar.Z

	Second beta (0.91) release of "The Macro Implementation of
	SNOBOL4 for Un*x"

	See README.beta2 for more info

README.beta2
	README file from beta2.tar.Z

rebus.tar.Z
	Rebus (an Icon like front end for SNOBOL4) implementation.
	Includes documentation and source.

	Ported BACK to Un*x (from Catspaw DOS port).  Better
	integrated with above SNOBOL4 (it may depend on Catspaw
	SNOBOL4/SPITBOL features) than beta1 release.

vanilla.tar.gz
	(compressed with GNU zip (gzip))

	Catspaw "Vanilla SNOBOL4"; converted from
	cs.arizona.edu:/snobol4/vanilla.arc.  Includes DOS/PC SNOBOL4
	port, sample programs, extensive SNOBOL4 documentation.

	NOTE: Catspaw considers this to be a copyrighted collection.
	Mark Emmer gave his permission to redistribute it so long as
	the collection is UNMODIFIED (no files added, modified or
	removed).

WIPS.rtf.Z

	Mac MS-Word "Interchange" (Rich Text Format) file with the
	foils I used at the June 1994 Usenix WIPS (Work In Progress
	Session).


From icon-group-sender  Wed Jun 29 11:42:18 1994
Received: by cheltenham.cs.arizona.edu; Wed, 29 Jun 1994 12:26:40 MST
Date: Wed, 29 Jun 94 11:42:18 CDT
From: jeffery@runner.jpl.utsa.edu (Clinton L. Jeffery)
Message-Id: <9406291642.AA06186@runner.utsa.edu>
To: icon-group@cs.arizona.edu
In-Reply-To: <2uqi1g$kc5@starcore.cris.com> (agate!howland.reston.ans.net!europa.eng.gtefsd.com!sundog.tiac.net!news3.sprintlink.net!news.sprintlink.net!deathstar.cris.com!starcore.cris.com!not-for-mail@ucbvax.Berkeley.EDU)
Subject: Re: Help-v8.10 Installation
Content-Length: 540
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


Bob Randall asks:
>	Has anyone installed Icon on Linux ?

[I would've sent this reply by e-mail, but no decipherable address was given]

Yes, I run Icon on Linux.  If there are configuration problems I'll be
happy to help you with them.  The configuration supplied with Version 8.10
was for a much older version of Linux, and things have been moved around.
I'll try to make sure an updated configuration gets into Icon 9.0,
coming soon!

Clint Jeffery
jeffery@ringer.cs.utsa.edu, cjeffery@cs.arizona.edu
University of Texas at San Antonio


From icon-group-sender  Wed Jun 29 11:15:41 1994
Received: by cheltenham.cs.arizona.edu; Wed, 29 Jun 1994 12:28:21 MST
Date: Wed, 29 Jun 1994 11:15:41 -0700 (PDT)
From: Bill Hogan <bhogan@crl.com>
Subject: Re: Help-v8.10 Installation
To: BobR <not-for-mail@starcore.cris.com>
Cc: icon-group@cs.arizona.edu
In-Reply-To: <2uqi1g$kc5@starcore.cris.com>
Message-Id: <Pine.3.87.9406291141.A29772-0100000@crl.crl.com>
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; charset=US-ASCII
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


On 29 Jun 1994, BobR wrote:

> I tried installing V.8.10 Icon (Interpreter/Compiler) on a newly 
> installed Linux V1.2.0 system and ran into difficulty running the 
> _make Configure_
> 
> Has anyone installed Icon on Linux ?
> 
> Please let me know. I can supply further details concerning my 
> particular problem.
> 

  Hi Bob,

   According to my notes, here is the only change I had to make: 

bedlam:[*root*]/fuji2/icon/config/unix/Config # diff Makefile Makefile.save
---------------------------cut here ----------------------------------------
62c62
<               ed -s ../../../bin/icon_vt <../Config/dequote.ed
---
>               ed - ../../../bin/icon_vt <../Config/dequote.ed
--------------------------cut here ----------------------------------------

  (See also 'man patch'.)

  Good luck!

  Bill Hogan
{echo "Subject: get bhogan@crl.com" | mail pgp-public-keys@pgp.mit.edu}




From icon-group-sender  Wed Jun 29 23:04:45 1994
Received: by cheltenham.cs.arizona.edu; Thu, 30 Jun 1994 08:29:13 MST
From: Nevin Liber <nevin@caslon>
Message-Id: <199406300604.XAA09222@caslon.CS.Arizona.EDU>
Subject: DaysTil.icn
To: icon-group@cs.arizona.edu (Icon Group)
Date: Wed, 29 Jun 1994 23:04:45 -0700 (MST)
X-Mailer: ELM [version 2.4 PL23]
Content-Type: text
Content-Length: 5930      
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Here is a little program I just wrote to calculate the number of days
from the current date until the date specified on the command line.  Enjoy!
-- 
	Nevin ":-)" Liber	nevin@cs.arizona.edu	(602) 293-2799
	                 	                    	 +++ (520) after 3/95
	                 	             office:	(602) 621-1685
		Only 44 more shopping days 'til my birthday!!

############################################################################
#
#	File:     DaysTil.icn
#
#	Subject:  Program to calculate the number of days until a given date
#
#	Author:   Nevin ":-)" Liber  nevin@cs.arizona.edu  (602) 293-2799
#
#	Date:     June 29, 1994
#
###########################################################################
#
#   Usage:    DaysTil sMonth iDay
#
#   Returns:
#       0   number of days written on &output
#       1   Usage message on &errout (bad parameters)
#
#   Revision History:
#       <1> njl  6/29/94 9:50 PM        First written
#
#   This program calculates the number of days between the current date
#   and the date specified on the command line, and writes this number to
#   &output.  This is useful if you want to know how many days it is
#   until a birthday, wedding day, etc.
#
#   The date on the command line can be specified in a variety of ways.
#   For instance, if you wanted to know how many days it is until
#   August 12 (my birthday), you could specify it as "August 12", "Aug 12",
#   "12 August", or "12 aUGuS", among others.  The match is case
#   insensitive, and the arguments will be accepted as long as exactly
#   one of them is an integer, and if there are exactly two arguments.
#
###########################################################################



############################################################################
#
#   NumberOfDays(sMonth, iDay, iYear) : iNumberOfDays
#
#   NumberOfDays() returns the number of days into iYear that sMonth/iDay
#   occurs.  For instance, NumberOfDays("February", 28) returns 59, since
#   it is the 59th day into any year.  Leap years from 1901 until 2099
#   are taken into account.  It fails if any parameters are bad.
#
#   Defaults:
#       sMonth  current month
#       iDay    current day of the current month
#       iYear   current year
#
############################################################################

procedure NumberOfDays(sMonth, iDay, iYear)

	static	LMonths
	static	LDays
	static	sThisMonth
	static	iThisDay
	static	iThisYear
	local	iDays
	local	i

	initial {	
		LMonths := [
			"january",
			"february",
			"march",
			"april",
			"may",
			"june",
			"july",
			"august",
			"september",
			"october",
			"november",
			"december"
		]

		LDays := [
			31,
			28,
			31,
			30,
			31,
			30,
			31,
			31,
			30,
			31,
			30
		]

		&dateline ? {
			&pos := find(" ") + 1
			sThisMonth := tab(find(" "))
			&pos +:= 1
			iThisDay := integer(tab(find(",")))
			&pos +:= 2
			iThisYear := integer(move(4))
		}
	}

	/sMonth := sThisMonth
	/iDay := iThisDay
	/iYear := iThisYear

	sMonth := string(sMonth) | fail
	iDay := integer(iDay) | fail
	iYear := integer(iYear) | fail

	if 0 ~= iYear % 4 then {
		LDays[2] := 28
	} else {
		LDays[2] := 29
	}

	iDays := iDay
	every i := 1 to *LMonths do {
		if CaselessMatch(sMonth, LMonths[i]) then {
			return iDays
		}
		iDays +:= LDays[i]
	}

end


############################################################################
#
#   CaselessMatch(s1, s2, i1, i2) : i3  caseless match of initial string
#
#	CaselessMatch(s1, s2, i1, i2) produces i1 + *s1 if
#   map(s1) == map(s2[i1+:*s1]) but fails otherwise.
#
#   This is the same as the built-in function match(), except the
#   comparisons are done without regard to case.
#
#   Defaults:
#       s2      &subject
#       i1      &pos if s2 is defaulted, otherwise 1
#       i2      0
#
#   Errors:
#       101     i1 or i2 not integer
#       103     s1 or s2 not string
#
############################################################################

procedure CaselessMatch(s1, s2, i1, i2)

	s1 := map(string(s1))
	/i1 := (/s2 & &pos)
	s2 := map(string(s2) | (/s2 & &subject))

	return match(s1, s2, i1, i2)
	

end


############################################################################
#
#   Usage(fErrout, iStatus)     write usage message to fErrout and exit
#
#   Usage(fErrout, iStatus) writes the usage message to file fErrout
#   and exits with exit status code iStatus
#
#   Defaults:
#       fErrout  &errout
#       iStatus  1
#
############################################################################

procedure Usage(fErrout, iStatus)

	/fErrout := &errout
	iStatus := (integer(iStatus) | 1)

	write(fErrout, "Usage: DaysTil sMonth iDay")
	exit(iStatus)

end


############################################################################
#
#   main(LArguments)
#
#	main(LArguments) checks to make sure there are two arguments, exactly
#   one of which is an integer.  If so, it tries to calculate the number
#   of days between the current date and the date specified, taking into
#   account if the specified date occurs after today's date only in the
#   following year.  On a parameter error, it writes the usage message
#   to &errout and exits with status 1.  Otherwise, it writes the number
#   of days to &output and exits with status 0.
#
############################################################################

procedure main(LArguments)

	local	sArgument
	local	sMonth
	local	iDay
	local	iToday
	local	iNumberOfDays


	if 2 ~= *LArguments then {
		Usage()
	}

	every sArgument := !LArguments do {
		(iDay := integer(sArgument)) | (sMonth := sArgument)
	}

	if /iDay | /sMonth then {
		Usage()
	}
	
	iToday := NumberOfDays()
	iNumberOfDays := NumberOfDays(sMonth, iDay) | Usage()
	if iNumberOfDays < iToday then {
		iNumberOfDays := NumberOfDays("december", 31) + NumberOfDays(sMonth, iDay, integer(&date[1+:4]) + 1)
	}
	
	write(iNumberOfDays - iToday)

end


From icon-group-sender  Thu Jun 30 10:20:08 1994
Received: by cheltenham.cs.arizona.edu; Thu, 30 Jun 1994 08:29:39 MST
Message-Id: <m0qJIGr-000BzQC@bootes.cus.cam.ac.uk>
X-Sender: jdg1002@pop.cus.cam.ac.uk
Mime-Version: 1.0
Content-Type: text/plain; charset="us-ascii"
Date: Thu, 30 Jun 1994 10:20:08 +0100
To: icon-group@cs.arizona.edu
From: Jason Grossman <Jason.Grossman@ucs.cam.ac.uk>
Subject: ProIcon
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Icon is fabulous, and ProIcon is the only good Macintosh port, I think.

I'd be very grateful for an explanation of Ralph Griswold's statement that
ProIcon is unmaintainable. Wasn't the source owned by Catspaw? Is there a
reason why the source can't now be public domain?

I only ask out of academic interest. If there's a reason, and I'm sure
there is, then I'm not complaining!

Thanks.

Jason Grossman
Computer Laboratory
University of Cambridge




From icon-group-sender  Thu Jun 30 08:35:35 1994
Received: by cheltenham.cs.arizona.edu; Thu, 30 Jun 1994 09:28:58 MST
Date: Thu, 30 Jun 1994 08:35:35 MST
From: "Ralph Griswold" <ralph>
Message-Id: <199406301535.AA14835@cheltenham.cs.arizona.edu>
To: Jason.Grossman@ucs.cam.ac.uk
Subject: Re:  ProIcon
Cc: icon-group
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Yes, Catspaw has the ProIcon source, as does the Bright Forest Company.

The problem is that the source contains components that are proprietary,
including some still in use in other Catspaw products.  In addition, there
proprietary components whose present owners are unknown.

I do not foresee any resolution of these problems, especially the latter.
Just because a company that has rights to a product no longer exists,
it does not mean that someone else did not buy them.  Tracing such ownership
is almost impossible.
    
Ralph E. Griswold			ralph@cs.arizona.edu
Department of Computer Science 		 uunet!arizona!ralph
The University of Arizona		602-621-6609 (voice)
Tucson, AZ 85721			602-621-4246   (fax)


From icon-group-sender  Sat Jul  2 22:30:42 1994
Received: by cheltenham.cs.arizona.edu; Sun, 3 Jul 1994 17:24:12 MST
Date: 2 Jul 94 22:30:42 GMT
From: agate!howland.reston.ans.net!europa.eng.gtefsd.com!news.umbc.edu!haven.umd.edu!umd5.umd.edu!usenet@ucbvax.Berkeley.EDU  (Rodney Price)
Organization: University of Maryland, College Park
Subject: Icon installation on NeXT 3.2
Message-Id: <2v4pqi$a16@umd5.umd.edu>
Sender: icon-group-request@cs.arizona.edu
To: icon-group@cs.arizona.edu
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


I just installed the binaries for the Icon compiler available on
cs.arizona.edu, and everything seems to work fine, except for a
few warning messages every time I compile.  For example,

iconc totex.icn
Translating to C:
totex.icn:
No errors; no warnings
Compiling and linking C code:
In file included from /usr/local/lib/icon/rt.h:5663, from totex.h:8, from  
totex.c:7:
/NextDeveloper/Headers/ansi/string.h:41: warning: conflicting types for  
built-in function `memcpy'
/NextDeveloper/Headers/ansi/string.h:43: warning: conflicting types for  
built-in function `strcpy'
/NextDeveloper/Headers/ansi/string.h:47: warning: conflicting types for  
built-in function `memcmp'
/NextDeveloper/Headers/ansi/string.h:48: warning: conflicting types for  
built-in function `strcmp'
/NextDeveloper/Headers/ansi/string.h:68: warning: conflicting types for  
built-in function `strlen'

The binaries from cs.arizona.edu are evidently built on a NeXTSTEP 2.1
system, and mine is NeXTSTEP 3.2, so perhaps the header files have 
changed.  The generated code seems to work fine, however.

How do I fix this?

Thanks,

Rod Price
rprice@reunion.umd.edu


From icon-group-sender  Sun Jul  3 19:57:20 1994
Received: by cheltenham.cs.arizona.edu; Mon, 4 Jul 1994 10:50:58 MST
Date: Sun, 3 Jul 94 19:57:20 CDT
From: jeffery@runner.jpl.utsa.edu (Clinton L. Jeffery)
Message-Id: <9407040057.AA15563@runner.utsa.edu>
To: rprice@reunion.umd.edu
Cc: icon-group@cs.arizona.edu
In-Reply-To: <2v4pqi$a16@umd5.umd.edu> (agate!howland.reston.ans.net!europa.eng.gtefsd.com!news.umbc.edu!haven.umd.edu!umd5.umd.edu!usenet@ucbvax.Berkeley.EDU)
Subject: Re: Icon installation on NeXT 3.2
Content-Length: 577
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


   [Rod Price gets warning messages when he runs Icon compiler binaries
   for Next 2.1 on his Next 3.2 platform, and asks:]

   How do I fix this?

These are a first guess at your options:

(1) Use the Icon interpreter instead of the Icon compiler.  Not to be glib,
but the interpreter compiles way faster, and its executables run only a
moderate amount slower (~3 times), than the Icon compiler.

(2) Get the Icon sources and build Icon from scratch on your platform.

Clint Jeffery
jeffery@ringer.cs.utsa.edu, cjeffery@cs.arizona.edu
The University of Texas at San Antonio


From icon-group-sender  Mon Jul 25 10:09:59 1994
Received: by cheltenham.cs.arizona.edu; Mon, 25 Jul 1994 12:24:12 MST
Date: Mon, 25 Jul 1994 10:09:59 MST
From: "Ralph Griswold" <ralph>
Message-Id: <199407251709.AA08574@cheltenham.cs.arizona.edu>
To: icon-group
Subject: Version 9 of Icon
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

			Version 9 of Icon

   Version 9 of Icon now is available for UNIX and MS-DOS.  The
UNIX implementation supports graphics facilities under the X Window
System.

   Implementations for other platforms are in progress and will
be announced when they are ready.

   The major changes in Version 9, and the ones that are
responsible for the new major version number, are in its graphics
facilities.

   There are many improvements in this area, including a portable
font naming system, facilities for drawing color images, and
support for the GIF image file format. We've also changed the
names of the graphics functions, dropping the initial X in anticipation
of other Version 9 implementations that will support graphics without
X. There also are new and changed functions.  Aids to convert
Version 8.10 graphics programs to 9.0 are provided.

   There are other new features in Version 9 like being able to add
many elements to a list at one time. There's also support for
dynamically loading C functions on some UNIX platforms.

   There are several significant improvements to the implementation
of Version 9.

   The Icon linker now eliminates declarations (notably procedures)
that are not referenced in a program. This may substantially reduce
the size of icode files, especially when packages of library procedures
are linked but not all the procedures in them are used.

   The UNIX implementation now uses shell headers to make icode
files executable. This substantially reduces the sizes of icode
files on many platforms.

   The MS-DOS linker now creates .exe files, so that it is no
longer necessary to run iconx. (It still is necessary to have
icon.exe on PATH, but that's transparent when you're running
Icon programs.)

   There's a new version of the Icon program library to go along
with Version 9. It has many additions and improvements, and the
graphics portion has been updated to Version 9. The library also
includes an improved interface builder for platforms that support Icon's
graphic facilities.

   Version 9 is available via anonymous FTP to cs.arizona.edu;
cd /icon and get READ.ME for navigation information.

   Version 9 also is available on magnetic media.  Address inquiries
to icon-order@cs.arizona.edu.


From icon-group-sender  Wed Jul 27 15:15:38 1994
Received: by cheltenham.cs.arizona.edu; Wed, 27 Jul 1994 15:18:54 MST
Date: Wed, 27 Jul 1994 15:15:38 MST
From: "Ralph Griswold" <ralph>
Message-Id: <199407272215.AA27049@cheltenham.cs.arizona.edu>
To: icon-group
Subject: Version 9 Icon for VMS
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

			Version 9 of Icon

   Version 9 of Icon now is available for VMS.  This implementation
supports graphics facilities under the X Window System.

   VMS Icon is available by FTP from cs.arizona.edu and on magnetic tape.
See the previous message on Version 9 of Icon for information or send
e-mail to icon-project@cs.arizona.edu.


From icon-group-sender  Mon Aug  1 09:17:30 1994
Received: by cheltenham.cs.arizona.edu; Mon, 1 Aug 1994 09:05:09 MST
To: icon-group-l@cs.arizona.edu
Date: 1 Aug 1994 09:17:30 -0400
From: nmw@ios.com (Nick Williams)
Message-Id: <31isla$rop@ios.com>
Organization: Internet Online Services
Sender: icon-group-request@cs.arizona.edu
References: <775255847snz@wildcard.demon.co.uk>, <1994Jul28.024918.24655@cs.rit.edu>, <31akl6$lta@kaa.heidelbg.ibm.com>
Subject: Re: What other experimental languages connect to a windowing system? (was: Why is TCL successful ?)
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

In article <31akl6$lta@kaa.heidelbg.ibm.com>,
Wolfgang Lux <lux@rio.heidelbg.ibm.com> wrote:
>In article <1994Jul28.024918.24655@cs.rit.edu>, nmw1638@cs.rit.edu (Nicolas M Williams) writes:
>|> Icon ... is
>|> also a very functional language, about the only lisp-like features it
>|> is missing are lambda expressions, quote and and a simple syntax
>|> (although all expressions except for assingments can be expressed in a
>|> form that is very similar to lisp's s-expressions).
>Sorry, but I thought lambda was one of the very functional parts of
>lisp. Should it be true that Icon has no way of representing anonymous
>functions?

All expressions in Icon produce results (i.e. there is no such thing as
a void typed functions as in C or CL). It also has apply/funcall like
expressions. Pointer semantics abound and there is no way to pass
pointers-to-pointers to functions (i.e. no quote function). All of which
makes Icon a heck of a lot more of a strict functional language than is
CL, though it does have variable assignment expressions, as well as
destructive functions and though it does not have lambda expressions. It
does have a feature that comes close to lambda expressions and which its
authors call "co-expressions;" these co-expressions are co-routines that
can be created more or less dynamically from regular Icon expressions.
Perhaps you should take a look at the introduction to Icon that can be
found in cs.arizona.edu:/icon/doc/tr-90.6.doc (also tr-90.6.ps.Z). Its
quite short...

>Wolfgang
>-- 

>Wolfgang Lux
>WZH Heidelberg, IBM Germany             IBM IP-Net: lux@rio.heidelbg.ibm.com
>+49-6221-59-4546			VNET:       LUX at HEIDELBG
>+49-6221-59-3300 (fax)			EARN:       LUX at DHDIBMIP


Nick


From icon-group-sender  Fri Aug  5 13:42:28 1994
Received: by cheltenham.cs.arizona.edu; Fri, 5 Aug 1994 15:00:32 MST
To: icon-group-l@cs.arizona.edu
Date: 5 Aug 1994 13:42:28 -0700
From: dave@cs.arizona.edu (Dave Schaumann)
Message-Id: <31u87k$84c@baskerville.CS.Arizona.EDU>
Organization: University of Arizona CS Department, Tucson AZ
Sender: icon-group-request@cs.arizona.edu
Subject: isatty equivalent in Icon?
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


Is there a function equivalent to C's "isatty()" in Icon?  (ie,
a way to tell whether &input (or another file) is connected to
a teletype-like device)

Thanks,
-Dave


From icon-group-sender  Mon Aug  8 04:23:24 1994
Received: by cheltenham.cs.arizona.edu; Mon, 8 Aug 1994 08:55:34 MST
To: icon-group-l@cs.arizona.edu
Date: Mon, 8 Aug 94 04:23:24 -0500
From: Will Mengarini <mengarini@delphi.com>
Message-Id: <5MxTM8s.mengarini@delphi.com>
Organization: Delphi (info@delphi.com email, 800-695-4005 voice)
Sender: icon-group-request@cs.arizona.edu
References: <31u87k$84c@baskerville.CS.Arizona.EDU>
Subject: Re: isatty equivalent in Icon?
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Dave Schaumann <dave@CS.Arizona.EDU> writes:
 
>Is there a function equivalent to C's "isatty()" in Icon?  (ie,
>a way to tell whether &input (or another file) is connected to
>a teletype-like device)
 
I have a version of isatty() for MS-DOS only.
This kind of thing is likely to require nonportable implementation;
what operating system are you using?


From icon-group-sender  Mon Aug  8 12:25:28 1994
Received: by cheltenham.cs.arizona.edu; Mon, 8 Aug 1994 18:21:43 MST
To: icon-group-l@cs.arizona.edu
Date: 8 Aug 1994 12:25:28 -0700
From: dave@cs.arizona.edu (Dave Schaumann)
Message-Id: <3260r8$gtd@baskerville.CS.Arizona.EDU>
Organization: University of Arizona CS Department, Tucson AZ
Sender: icon-group-request@cs.arizona.edu
References: <31u87k$84c@baskerville.CS.Arizona.EDU>, <5MxTM8s.mengarini@delphi.com>
Subject: Re: isatty equivalent in Icon?
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

In article <5MxTM8s.mengarini@delphi.com>,
Will Mengarini  <mengarini@delphi.com> wrote:
>Dave Schaumann <dave@CS.Arizona.EDU> writes:
> 
>>Is there a function equivalent to C's "isatty()" in Icon?  (ie,
>>a way to tell whether &input (or another file) is connected to
>>a teletype-like device)
> 
>I have a version of isatty() for MS-DOS only.
>This kind of thing is likely to require nonportable implementation;
>what operating system are you using?

I'm presently working on a Un*x box (Solaris to be specific).
But I would like the solution to be reasonably portable.

-Dave



From icon-group-sender  Mon Aug  8 19:32:34 1994
Received: by cheltenham.cs.arizona.edu; Mon, 8 Aug 1994 18:21:50 MST
To: icon-group-l@cs.arizona.edu
Date: Mon, 8 Aug 1994 19:32:34 GMT
From: soder@inmic.se (Hakan Soderstrom)
Message-Id: <1994Aug8.193234.28645@sics.se>
Organization: Swedish Institute of Microelectronics, Kista
Sender: icon-group-request@cs.arizona.edu
Subject: Announce: itweak 2.2
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

I am happy to announce the availability of release 2.2 of

	itweak -- an interactive Icon debugger


WHAT IS ITWEAK?

'itweak' is an interactive debugging utility for the Icon programming
language. It is based on tweaking ucode files (.u1, .u2). Your program
is linked with a debugging run-time and off you go. You code, I tweak,
that's the simple idea.

The 'itweak' system provides you with many of the facilities you would
expect from an interactive debugger, including the ability to evaluate
a wide range of Icon expressions.


PREREQUISITES

 'itweak' requires Icon 8.10 or higher. It is completely written in
Icon, and should be as portable as Icon itself.


NICE THINGS

The package comes with reasonable documentation and with a demo.
There is on-line help.

I also can't help mentioning that 'itweak' addresses a problem
mentioned in the Icon Analyst, Number 25, which happened to drop into
my mailbox the other day. The last article ("Local Identifiers")
describes how one may wipe out Icon functions. 'itweak' has a command
('info globals') which (among other things) checks if any of the
function identifiers has lost its initial value.


CATCHES

This is the first itweak release beyond the author's immediate
neighborhood. It has only been tested under Unix (SunOS 4.1.3).


ARCHIVE

The itweak distribution can be obtained by anonymous FTP from
the Icon Project FTP server as

	cs.arizona.edu:/icon/contrib/itweak-2.2.tar.Z

The size is 116 kb. Unfortunately I don't have the bandwidth for
E-mail distribution.


SUPPORT?

Send bug reports, improvements, comments etc. to the address below.
There is no external funding for 'itweak', so I can't promise anything
except that I am also interested in making 'itweak' better.


Enjoy.

	Hakan

The preferred E-mail address is the one below.

----------------------------------------------------------------
Hakan Soderstrom                    | hs@soderstrom.se
Soderstrom Programvaruverkstad AB   | Voice: +46 (8) 722 7320
Bandhagsvagen 51                    | Fax:   +46 (8) 817980
S-122 42 Enskede, SWEDEN            |


From icon-group-sender  Tue Aug  9 09:46:06 1994
Received: by cheltenham.cs.arizona.edu; Tue, 9 Aug 1994 16:08:33 MST
Date: Tue, 9 Aug 1994 09:46:06 -0600 (CST)
From: Gustavo Cavazos <gcavazos@fermat.rzs.itesm.mx>
Subject: Handling files...
To: Group Icon Project <icon-group@cs.arizona.edu>,
        icon-group-l@cs.arizona.edu
Message-Id: <Pine.3.89.9408090908.C29968-0100000@fermat.rzs.itesm.mx>
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; charset=US-ASCII
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

How does one write a record to file? Is this possible?
form example:
   record x(type1,type2,type3)

   data1:=x("string1",2.3,"hello")
   write(file,data1)

If not, is there any way to write a table or to that matter any other 
data structure to a file, instead of writing item, by item.	

Saludos,
+Gus
===============                                     =========
Gustavo Cavazos                                     ITESM-CEM
gcavazos@fermat.rzs.itesm.mx          
gcavazos@itesmvf1.rzs.itesm.mx                        "   "



From icon-group-sender  Thu Aug 11 03:29:00 1994
Received: by cheltenham.cs.arizona.edu; Thu, 11 Aug 1994 05:34:44 MST
To: icon-group-l@cs.arizona.edu
Date: 11 Aug 1994 03:29:00 GMT
From: hinoue@us.itd.umich.edu (Hajime Inoue)
Message-Id: <32c5tt$bb5@lastactionhero.rs.itd.umich.edu>
Organization: University of Michigan ITD/User Services
Sender: icon-group-request@cs.arizona.edu
Subject: snobol to icon converter?
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

I'm looking for a snobol to icon converter.  Has anyone heard of one or 
know where I can get it?

--
------------------------------------------------------
*  Hajime (Jim) Inoue	*  University of Michigan    *
*  hinoue@umich.edu	*  ITD Temp Consultant       *
------------------------------------------------------



From icon-group-sender  Thu Aug 11 16:48:33 1994
Received: by cheltenham.cs.arizona.edu; Thu, 11 Aug 1994 11:52:06 MST
To: icon-group-l@cs.arizona.edu
Date: Thu, 11 Aug 1994 16:48:33 GMT
From: joshi@mercury.ncat.edu
Message-Id: <1994Aug11.164833.17157@mercury.ncat.edu>
Organization: North Carolina Agricultural and Technical State University
Sender: icon-group-request@cs.arizona.edu
Subject: A Query !!
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Hi All,
	Was wondering if anyone knew, when the Win vers of icon will be
out.
Just a thought

regards
Sunit.


From icon-group-sender  Mon Aug  1 09:17:30 1994
Received: by cheltenham.cs.arizona.edu; Mon, 15 Aug 1994 05:40:55 MST
To: icon-group-l@cs.arizona.edu
Date: 1 Aug 1994 09:17:30 -0400
From: nmw@ios.com (Nick Williams)
Message-Id: <31isla$rop@ios.com>
Organization: Internet Online Services
Sender: icon-group-request@cs.arizona.edu
References: <775255847snz@wildcard.demon.co.uk>, <1994Jul28.024918.24655@cs.rit.edu>, <31akl6$lta@kaa.heidelbg.ibm.com>
Subject: Re: What other experimental languages connect to a windowing system? (was: Why is TCL successful ?)
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

In article <31akl6$lta@kaa.heidelbg.ibm.com>,
Wolfgang Lux <lux@rio.heidelbg.ibm.com> wrote:
>In article <1994Jul28.024918.24655@cs.rit.edu>, nmw1638@cs.rit.edu (Nicolas M Williams) writes:
>|> Icon ... is
>|> also a very functional language, about the only lisp-like features it
>|> is missing are lambda expressions, quote and and a simple syntax
>|> (although all expressions except for assingments can be expressed in a
>|> form that is very similar to lisp's s-expressions).
>Sorry, but I thought lambda was one of the very functional parts of
>lisp. Should it be true that Icon has no way of representing anonymous
>functions?

All expressions in Icon produce results (i.e. there is no such thing as
a void typed functions as in C or CL). It also has apply/funcall like
expressions. Pointer semantics abound and there is no way to pass
pointers-to-pointers to functions (i.e. no quote function). All of which
makes Icon a heck of a lot more of a strict functional language than is
CL, though it does have variable assignment expressions, as well as
destructive functions and though it does not have lambda expressions. It
does have a feature that comes close to lambda expressions and which its
authors call "co-expressions;" these co-expressions are co-routines that
can be created more or less dynamically from regular Icon expressions.
Perhaps you should take a look at the introduction to Icon that can be
found in cs.arizona.edu:/icon/doc/tr-90.6.doc (also tr-90.6.ps.Z). Its
quite short...

>Wolfgang
>-- 

>Wolfgang Lux
>WZH Heidelberg, IBM Germany             IBM IP-Net: lux@rio.heidelbg.ibm.com
>+49-6221-59-4546			VNET:       LUX at HEIDELBG
>+49-6221-59-3300 (fax)			EARN:       LUX at DHDIBMIP


Nick


From icon-group-sender  Mon Aug 15 10:55:27 1994
Received: by cheltenham.cs.arizona.edu; Mon, 15 Aug 1994 14:00:29 MST
To: icon-group-l@cs.arizona.edu
Date: Mon, 15 Aug 94 10:13:34 CEST
From: Guido Milanese <MC1194@mclink.it>
Message-Id: <776938414.MC1194@mclink.it>
Organization: MC-link - Italian Dial-Up Online Service
Sender: icon-group-request@cs.arizona.edu
Subject: Snobol - Icon
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


H.J. Inoue is looking for a Snobol-Icon translation
software. I do not know if this is useful information, but
I would like to point out that Catspaw Inc. produces a
preprocessor (Icon-like) called Rebus. It is very cheap
($ 15); I own it, but being a Spitbol programmer I never
use it. However, Rebus looks interesting at least for
studying.

---------------------------
Guido Milanese
Universita' Cattolica           Internet: mc1194@mclink.it
Ist. di Filologia Classica         smail: Largo Gemelli 1
+39.2.72342-750    Fax -740               I-20123 Milano MI


From icon-group-sender  Mon Aug 15 15:55:47 1994
Received: by cheltenham.cs.arizona.edu; Mon, 15 Aug 1994 14:01:26 MST
To: icon-group-l@cs.arizona.edu
Date: 15 Aug 1994 15:55:47 GMT
From: espie@basilic.ens.fr (Marc Espie)
Message-Id: <32o363$lo6@nef.ens.fr>
Organization: Ecole Normale Superieure, PARIS, France
Sender: icon-group-request@cs.arizona.edu
References: <MBERGER.94Aug11084252@mbsdev24.lehman.com>, <1994Aug13.213550.26432@netlabs.com>
Subject: Re: Generators
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

In article <1994Aug13.213550.26432@netlabs.com>,
Larry Wall <lwall@netlabs.com> wrote:
>In article <MBERGER.94Aug11084252@mbsdev24.lehman.com> mberger@mbsdev24.lehman.com (Micha Berger) writes:
>: Icon has a concept of generator. It's been a while since I last used Icon,
>: but here's the basic concept in an ad-hoc Perl-like syntax.
>: 
>: Generators are functions/operators that return a sequence of values. For
>: example, index(/re/, $string) could return the first location of /re/ in
>: $string, followed by the second, followed by the third...
>
>More specifically, generators can, on demand, return the next answer in a
>sequence of potential answers.
>
>: There are two ways this is used. The first is that if an expression "fails", it
>: can be reevaluated using the next value: e.g.
>: 	$loc = index(/re/, $string) > 32;
>: will set $loc to a location greater than 32, or, undef.
>
>Just out of curiosity, what prevents it from returning the *next*
>location greater than 32 the next time you evaluate it?  Is there an
>implicit cut operation?

Implicit ? no... explicit, yes, and it's not a dirty concept like in Prolog
for instance, but perfectly clean, based upon syntactic entities.

In that particular case, instantiation does cut the backtracking. In icon,
you write:
loc := 32 < find(s1, s2)
because:
- <, when it succeeds, returns the expression on the LEFT, not the right
(which is reasonable, since it allows for 0 < i < 10)
- := is the normal instantiation operator. There also exists a reversible
one (<-) which you use VERY rarely.
- the backtracking would be cut at the end of the expression anyway. EVERY
expression is closed for backtracking. And there are other control points where
backtracking can not occur.

>
>: The other is an "every" iterator:
>: 	every(index(/re/, $string)) {
>: 	    ...
>: 	}
>: 
>: (One neat little feature, it meant that || could be read to mean "concatenate
>: two sequences" and still retain its current functionality.)
>
>Well, yes, depending on what's demanded by the context.  Perl has a
>simpler demand structure than Icon, and people still complain about it.
>
>: I was wondering if there is some easy way to get similar functionality out of
>: Perl.
>
>Yes and no.  There are a few operators in Perl that behave like
>generators in scalar context, such as <> and m//g.  And it's easy
>enough to write functions that remember their state and return the
>"next" thing.  But the state is explicit, and doesn't differentiate who
>called the function (unless you're really sneaky).  And lists in Perl
>are always completely constructed before they are passed on to the next
>processing element.

In Icon, you differentiate the other way. The implicit state differentiates
where the function was called. If you want an expression that can be resumed
elsewhere, you encapsulate it into a coexpression. Here is the classic 
`build identifiers on the fly' in Icon.
procedure newid
	i := 0
	repeat
		{
		i +:= 1
		suspend "a"||i
		}
end

called thus:
gen := create newid()
id:= @gen
each time you wish for a new id.


and that way, you can avoid constructing some lists on the fly, which is
*sometimes* a win.

>
>I basically don't like languages that try to help you by keeping track
>of a lot of implicit state.  I don't think most ordinary folks like
>them either.  Regular expressions are already dangerously close to the
>limits of mortal endurance, which is why the use of them in Perl is
>rigidly circumscribed.  I'm somewhat allergic to the rampant uncertainty
>engendered by pervasive implicit backtracking.  (I have similar feelings
>about the way shells do pervasive string interpolation.)  Perl is very
>much a what-you-see-is-what-it-does language.  When you're fighting with
>one of the good ol' boys, just stand up straight and start boxing...

There is no pervasive implicit backtracking in Icon, it's very well-bounded
and works just like an ordinary sequential language, except where you NEED
backtracking.

I'd contend Icon is almost in the same league as Perl. After all, you don't
see behind the scene garbage-collecting in Perl either.

>
>Like all forms of abstraction, generators are a mixed blessing.
>Icon's popularity stems directly from its abstraction facilities.
>Unfortunately, so does its *lack* of popularity.

I don't know, it seems to me that nobody is particularly pushing Icon these
days... and it tends to be a lot bigger than perl, and a trifle slower and 
not to be aimed at the same goals... not the same concision as far as work
on regular expressions go, but much more powerful for many other problems
dealing with string analysis (Icon doesn't have regular expressions...)
>
>That's just my $.02 worth (multiplied, of course, by however many more
>subsribers there are to comp.lang.perl than to comp.lang.icon).
>
>Larry

I've taken upon myself to crosspost this to comp.lang.icon where lots of nice
guys will be able to give a better analysis of all this than me.

Oh, and by the way, I use regularly Icon AND Perl, not for quite the same
problems, obviously.


-- 
[nosave]<http://acacia.ens.fr:8080/home/espie/index.html>
`Ayuka no koto... suki dayo.' (KOR, Ano Hi ni kaeritai)
`鮎川 のことー好きだよ。' (あの日に帰りたい)
	Marc Espie (Marc.Espie@ens.fr)


From icon-group-sender  Mon Aug 15 14:30:52 1994
Received: by cheltenham.cs.arizona.edu; Mon, 15 Aug 1994 15:31:07 MST
Date: Mon, 15 Aug 1994 14:30:52 +0700
From: swampler@noao.edu
Message-Id: <9408152130.AA22645@orpheus.gemini.edu>
Subject: Re: Generators
To: icon-group@cs.arizona.edu
Content-Length: 1261
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

espie@ens.fr wrote:


>>In Icon, you differentiate the other way. The implicit state differentiates
>>where the function was called. If you want an expression that can be resumed
>>elsewhere, you encapsulate it into a coexpression. Here is the classic 
>>`build identifiers on the fly' in Icon.
>>procedure newid
>>	i := 0
>>	repeat
>>		{
>>		i +:= 1
>>		suspend "a"||i
>>		}
>>end
>>
>>called thus:
>>gen := create newid()
>>id:= @gen
>>each time you wish for a new id.

Just to extend Mark's explanation a bit - there is no requirement that the
expression 'encapsulated' by a coexpression consist of just a function call,
one may capture *any* Icon expression.  So an alternative 'build identifiers
on the fly' implementation is simply:

	gen := create "a"||seq()

since seq() is a function whose default behavior matches that
provided by the counter in Mark's newid() procedure.  If gen is a global
variable, then @gen will produce the next 'id' whenever and wherever it
is invoked.

More on 'seq()' - it produces an infinite sequence of results on demand: 

{1,2,3...}

though you can provide arguments to set both the initial value and the step
size, so 

	seq(2,2) produces {2,4,6,8,...}


--
Steve Wampler
swampler@gemini.edu
Gemini Project (under AURA)


From icon-group-sender  Tue Aug 16 12:49:03 1994
Received: by cheltenham.cs.arizona.edu; Tue, 16 Aug 1994 07:32:35 MST
To: icon-group-l@cs.arizona.edu
Date: Tue, 16 Aug 1994 12:49:03 GMT
From: jsampson@cix.compulink.co.uk ("John Sampson")
Message-Id: <CuMoxs.5I5@cix.compulink.co.uk>
Organization: Sole Trader
Sender: icon-group-request@cs.arizona.edu
References: <1994Aug8.193234.28645@sics.se>
Subject: Re: Announce: itweak 2.2
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

For MSDOS users, what is the best way to install this? Presumably one has 
to emulate some UNIX procedure on the .tar.Z file.


From icon-group-sender  Tue Aug 16 07:37:14 1994
Received: by cheltenham.cs.arizona.edu; Tue, 16 Aug 1994 08:32:10 MST
Date: Tue, 16 Aug 1994 07:37:14 MST
From: "Ralph Griswold" <ralph>
Message-Id: <199408161437.AA10331@cheltenham.cs.arizona.edu>
To: icon-group
Subject: itweak
Cc: FTP
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

I've put itweak.lzh in /icon/contrib in our FTP area.
    
Ralph E. Griswold			ralph@cs.arizona.edu
Department of Computer Science 		 uunet!arizona!ralph
The University of Arizona		602-621-6609 (voice)
Tucson, AZ 85721			602-621-4246   (fax)



From icon-group-sender  Wed Aug 17 05:43:34 1994
Received: by cheltenham.cs.arizona.edu; Wed, 17 Aug 1994 05:56:56 MST
To: icon-group-l@cs.arizona.edu
Date: 17 Aug 1994 05:43:34 GMT
From: dalemeans@delphi.com (Dale Means)
Message-Id: <9408170142591.dalemeans.DLITE@delphi.com>
Organization: Delphi Internet Services Corporation
Sender: icon-group-request@cs.arizona.edu
Subject: How in the world..
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

does one start using icon?.  I downloaded every icon.exe in icon\bin
directory, but can't get even one of them to load a file.  I got all of the
ipd.doc files applicable to ms-dos in the doc directory (ipd255.doc and
several others missing, I don't think I can read the .ps files).  When I run
one of the icon.exe, I get instructions in an unknown tongue.  I have no
idea of what all those switches mean.  I copied the icon pgm listed in
tr90-6.doc, but I can't get even one of the icon.exe pgms to touch it.

Is there a doc file somewhere that tells how to get started? What files do I
need for ms-dos?

Any help will be much appreciated.

Dale
 



From icon-group-sender  Wed Aug 17 15:26:23 1994
Received: by cheltenham.cs.arizona.edu; Wed, 17 Aug 1994 14:40:02 MST
Date: Wed, 17 Aug 94 15:26:23 CDT
From: jeffery@runner.jpl.utsa.edu (Clinton L. Jeffery)
Message-Id: <9408172026.AA23401@runner.utsa.edu>
To: joshi@mercury.ncat.edu
Cc: icon-group@cs.arizona.edu
In-Reply-To: <1994Aug11.164833.17157@mercury.ncat.edu> (joshi@mercury.ncat.edu)
Subject: Re: A Query !!
Content-Length: 539
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


   joshi@mercury.ncat.edu asks:
>   Was wondering if anyone knew, when the Win vers of icon will be out.

Top secret test versions will be leaked to select masochists and people
who have bribed me sometime in late September.  The official release will
occur when the software is stable.  I suspect that the 32-bit version
will lead the 16-bit version by a few months, since development is being
done under NT first and then ported.

Clint Jeffery
cjeffery@cs.arizona.edu, jeffery@ringer.cs.utsa.edu
The University of Texas at San Antonio


From icon-group-sender  Wed Aug 17 20:16:04 1994
Received: by cheltenham.cs.arizona.edu; Wed, 17 Aug 1994 14:40:22 MST
To: icon-group-l@cs.arizona.edu
Date: Wed, 17 Aug 1994 20:16:04 GMT
From: jsampson@cix.compulink.co.uk ("John Sampson")
Message-Id: <Cup4As.7z4@cix.compulink.co.uk>
Organization: Sole Trader
Sender: icon-group-request@cs.arizona.edu
References: <CuMoxs.5I5@cix.compulink.co.uk>
Subject: Re: Announce: itweak 2.2
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Answering my own ignorant question, Z means a compressed file according 
to Z, tar means the files are strung together and untarring cuts them 
apart properly.


From icon-group-sender  Thu Aug 18 16:03:41 1994
Received: by cheltenham.cs.arizona.edu; Thu, 18 Aug 1994 15:44:41 MST
Date: Thu, 18 Aug 1994 16:03:41 -0400 (EDT)
From: John Kohl <kohl@nova.umd.edu>
Subject: Graphic Icon on PCs?
To: icon-group@cs.arizona.edu
In-Reply-To: <9408172026.AA23401@runner.utsa.edu>
Message-Id: <Pine.3.88.9408181610.A19192-0100000@nova>
Mime-Version: 1.0
Content-Type: TEXT/PLAIN; charset=US-ASCII
Status: R
Errors-To: icon-group-errors@cs.arizona.edu


	Does the graphics version of Icon work on X-servers on PCs?

				John Kohl
				Univ. Md., University College
				kohl@nova.umd.edu


From icon-group-sender  Thu Aug 18 18:43:10 1994
Received: by cheltenham.cs.arizona.edu; Thu, 18 Aug 1994 15:44:24 MST
To: icon-group-l@cs.arizona.edu
Date: 18 Aug 1994 18:43:10 GMT
From: mslamm@pluto.mscc.huji.ac.il (Zvi Lamm)
Message-Id: <330a3u$3vq@shum.cc.huji.ac.il>
Organization: The Hebrew Univ. of Jerusalem, Computation Center.
Sender: icon-group-request@cs.arizona.edu
Subject: Simple syntax? A definition?
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

Following the recent thread on perl vs. Icon, and posts about UNIX
*tools* I started thinking on how one can define what are the good
qualities a synatx should have.
It appears to me that what counts is simplicity. A simple syntax would be
one that can easaly be built (NOT parsed) by programs (so that the
language can be used as a tool interface). It would also be easy for
humans (that's us!) to learn and use.

Does anyone have suggestions on how to define this in a more mathematical
or precise way? I thought about YACC clauses/sentence. But I am not sure
it's enough because the YACC approach narrows you down to LALR.

I thought one criterion can be PROXIMITY - that is that semantically
related elements should be near each other.  Any others?

Ehud Lamm == mslamm@pluto.mscc.huji.ac.il           "My home is not a page!"


From icon-group-sender  Thu Aug 18 20:49:19 1994
Received: by cheltenham.cs.arizona.edu; Thu, 18 Aug 1994 15:45:14 MST
To: icon-group-l@cs.arizona.edu
Date: 18 Aug 1994 20:49:19 GMT
From: silber@orfeo.eng.sun.com (Eric Silber)
Message-Id: <330hgf$g14@engnews2.Eng.Sun.COM>
Organization: Sun
Sender: icon-group-request@cs.arizona.edu
References: <330a3u$3vq@shum.cc.huji.ac.il>
Subject: an *nary response  Re: Simple syntax? A definition?
Status: R
Errors-To: icon-group-errors@cs.arizona.edu

In article <330a3u$3vq@shum.cc.huji.ac.il> mslamm@pluto.cc.huji.ac.il (Zvi Lamm) writes:
>Following the recent thread on perl vs. Icon, and posts about UNIX
>*tools* I started thinking on how one can define what are the good
>qualities a synatx should have.
>It appears to me that what counts is simplicity. A simple syntax would be
>one that can easaly be built (NOT parsed) by programs (so that the
>language can be used as a tool interface). It would also be easy for
>humans (that's us!) to learn and use.

 There is a trade off to be considered.
 I am learning perl5 now for 2 reasons:
 1) it is functionally far superior to all the other shells and default
    filter tools
 2) Once mastered, it allows for concise specification of data strucutures
    and procedures.

 The problem is that to achieve the mastery required for 2) , you
 have to become not merely intimate with perl syntax, but *more* than
 intimate!  It's an *nary requirement: you need to learn
 perl-arcanery, perl-chicanery and some other *(star-caneries) !

 However, once one gets there (I hope I can get there before xmas!),
 one can write concise and powerful algorithms.
 
 If one wants the kind of syntactic simplicity which you are 
 describing (and I also appreciate the strong points of that),
 then you want something like 'scheme' , I think.
 But then you have to spit out a lot of car's and cdr's in order to 
 get <>  !