OS/2 Shareware BBS: 10 Tools/10-Tools.zip/ICONPL8.ZIP/IDOL.PAK

Text File | 1990-03-23 | 142KB | 4,650 lines

##########
Makefile
#
# Sample makefile for compiling Idol
#
idol: idol.iol unix.u1 idolboot
    idolboot idol unix.u1

idolboot: idolboot.icn unix.u1
    icont -Sr1000 -SF30 -Si1000 idolboot unix.u1
    idolboot -install

unix.u1: unix.icn
    icont -c unix
##########
README
This is the Idol public distribution directory.
Read idol.man and idol.doc for details on running Idol.

The Idol source is idol.iol; the Idol booting kit is idolboot.icn.
In addition to these two files, there is a system-specific Icon file
which must be linked in to produce an Idol executable: so far there
are files amiga.icn, mpw.icn, msdos.icn, os2.icn, unix.icn, and vms.icn.

BUILDING IDOL

If you are running MS-DOS, the file install.bat contains the sequence
of commands necessary to build Idol.  This sequence consists of:

(1) Compile idolboot with a line such as
    icont -Sr1000 -SF30 -Si1000 idolboot msdos

(2) Install an Idol environment directory with a line such as
    iconx idolboot -install
For MS-DOS, this generates a batch file named idolt.bat which
you would then execute to create the environment directory.
For other systems, idolboot creates the directory itself.

(3) Translate Idol from its idol.iol source file with a line such as
    iconx idolboot idol msdos.icn
(Again, on MS-DOS, this generates a batch file named idolt.bat
which you should then execute.)

This makes a good initial test of the system's operation.

In addition there are several other files with extension .iol; these
are unfinished fragments of Idol source code for your perusal.
Contributions are of course welcome!

Note that Idol is still a work in progress, and this must be
considered a test distribution.  Support for non-UNIX systems is
minimally tested; feel free to add code to support your system
and send it in.

The -strict flag not only generates paranoid code for public field
access, it generates extra warning messages when inherited fields
are named in a subclass.

Mail [e-mail] (or uunet!arizona!cjeffery)
when you have questions or bug fixes for Idol.
##########
amiga.icn
#
# %W% %G%
# OS-specific code for Amiga Idol
#
global lnkopt,cd,md,env,sysok

procedure mysystem(s)
  if \loud then write(s)
  return system(s)
end

procedure filename(s)
  s[9:0] := ""
  return s
end
procedure writesublink(s)
  writelink(env||"/"||s)
end
procedure envpath(filename)
  return env||"/"||filename
end
#
# Installation.
# Uses hierarchical filesystem on some systems (see initialize)
#
procedure install(args)
  write("Installing idol environment in ",env)
  if env ~== "" then mysystem(md||env)
  fout := envopen("i_object.icn","w")
  write(fout,"record idol_object(__state,__methods)")
  close(fout)
  fout := &null
  cdicont(["i_object"])
end

procedure makeexe(args,i)
  exe := args[i]
  if icont(lnkopt||exe) = \sysok then {
      mysystem("delete "||exe||".icn")
      if \exec then {
    write("Executing:")
    exe := "iconx "||exe
    every i := exec+1 to *args do exe ||:= " "||args[i]
    mysystem(exe)
      }
  }
end
#
# system-dependent compilation of idolfile.icn
#   (in the idol subdirectory, if there is one)
#
procedure cdicont(idolfiles)
  if comp = -2 then return  # -t --> don't call icont at all
  args := " -c"
  rms  := ""
  every ifile := !idolfiles do args ||:= " " || ifile
  every ifile := !idolfiles do rms  ||:= " " || ifile || ".icn"

  mysystem("cd idolcode.env")
  if icont(args) = \sysok
  then every ifile := !idolfiles do mysystem("delete "||ifile||".icn")
  mysystem("cd /")
end
procedure sysinitialize()
  lnkopt := " -Sr500 -SF30 -Si1000 "
  cd := "cd "
  md := "makedir "
  env := "idolcode.env"
  sysok := 0
end
##########
bi_test.iol
#
# Tests for the various builtins
#
procedure main()

  x := Table(1)
  write("\nTesting class ",x$class())
  x$setElement("world","hello")
  write(x$getElement("world"))
  write(x$getElement("hello"))

  x := Deque()
  write("\nTesting class ",x$class())
  x$push("hello")
  x$push("world")
  write("My deque is size ",$*x)
  every write("give me a ",$!x)
  write("A random element is ",$?x)
  write("getting ",x$get()," popping ",x$pop())

  x := List(["Tucson", "Pima", 85721])
  write("\nTesting class ",x$class())
  every write("give me a ",$!x)

end
##########
buffer.iol
    class buffer(public filename,text,index)
      # read a buffer in from a file
      method read()
        f := open(self.filename,"r") | fail
        self$erase()
        every put(self.text,!f)
        close(f)
        return
      end
      # write a buffer out to a file
      method write()
        f := open(self.filename,"w") | fail
        every write(f,!self.text)
        close(f)
      end
      # insert a line at the current index
      method insert(s)
        if self.index = 1 then {
          push(self.text,s)
        } else if self.index > *self.text then {
          put(self.text,s)
        } else {
          self.text := self.text[1:self.index]|||[s]|||self.text[self.index:0]
        }
        self.index +:= 1
        return
      end
      # delete a line at the current index
      method delete()
        if self.index > *self.text then fail
        rv := self.text[self.index]
    if self.index=1 then pull(self.text)
    else if self.index = *self.text then pop(self.text)
    else self.text := self.text[1:self.index]|||self.text[self.index+1:0]
        return rv
      end
      # move the current index to an arbitrary line
      method goto(l)
        if (0 <= l) & (l <= self.index+1) then return self.index := l
      end
      # return the current line and advance the current index
      method forward()
        if self.index > *self.text then fail
        rv := self.text[self.index]
        self.index +:= 1
        return rv
      end
      # place the buffer's text into a contiguously allocated list
      method linearize()
        tmp := list(*self.text)
        every i := 1 to *tmp do tmp[i] := self.text[i]
        self.text := tmp
      end
      method erase()
        self.text     := [ ]
        self.index    := 1
      end
    initially
      if \ (self.filename) then {
        if not self$read() then self$erase()
      } else {
        self.filename := "*scratch*"
        self.erase()
      }
    end


class buftable : buffer()
  method read()
    self$buffer.read()
    tmp := table()
    every line := !self.text do
      line ? { tmp[tab(many(&ucase++&lcase))] := line | fail }
    self.text := tmp
    return
  end
  method lookup(s)
    return self.text[s]
  end
end


class bibliography : buftable()
end


class spellChecker : buftable(parentSpellChecker)
  method spell(s)
    return \ (self.text[s]) | (\ (self.parentSpellChecker))$spell(s)
  end
end


class dictentry(word,pos,etymology,definition)
  method decode(s) # decode a dictionary entry into its components
    s ? {
      self.word       := tab(upto(';'))
      move(1)
      self.pos        := tab(upto(';'))
      move(1)
      self.etymology  := tab(upto(';'))
      move(1)
      self.definition := tab(0)
    }
  end
  method encode()  # encode a dictionary entry into a string
    return self.word||";"||self.pos||";"||self.etymology||";"||self.definition
  end
initially
  if /self.pos then {
    # constructor was called with a single string argument
    self$decode(self.word)
  }
end

class dictionary : buftable()
  method read()
    self$buffer.read()
    tmp := table()
    every line := !self.text do
      line ? { tmp[tab(many(&ucase++&lcase))] := dictentry(line) | fail }
    self.text := tmp
  end
  method write()
    f := open(b.filename,"w") | fail
    every write(f,(!self.text)$encode())
    close(f)
  end
end
##########
buftest.iol
# buffer classes' tests

procedure main(args)
  if *args=0 then stop("usage: buftest cp file1 file2")
  every i := 1 to *args do {
      case args[i] of {
      "cp": {
          cp(args)
      }
      }
  }
end
procedure cp(args)
  b1 := buffer(args[2])
  b2 := buffer(args[3])
  b2$erase()
  while s:=b1$forward() do b2$insert(s)
  b2$write()
end
##########
builtins.iol
# %W% %G%
#
# Builtin Icon objects, roughly corresponding to the language builtins.
#
# Taxonomy of builtin types:
#
#                   __Object___
#                           _-'           `-_
#             _-'                  `-_
#          Collection            Atom_
#         /    |    \                      _'     `-.
#    Stack    Queue    Vector           _-'        Number
#           \   /      /  |  \          _-'            /      \
#        Deque     /      |   \          _'     Integer           Real
#               \    /    |    \     /
#        List    Table    String
#
#

#
# this is the Smalltalk-style ideal root of an inheritance hierarchy.
# add your favorite methods here.
#
class Object()
  method class()
    return image(self)[8:find("_",image(self))]
  end
end

class Collection : Object (theCollection)
  method size()
    return *self.theCollection
  end
  method foreach()
    suspend !self.theCollection
  end
  method random()
    return ?self.theCollection
  end
end

class Vector : Collection()
  method getElement(i)
    return self.theCollection[i]
  end
  method setElement(i,v)
    return self.theCollection[i] := v
  end
end

class Table : Vector(initialvalue,theCollection)
initially
  self.theCollection := table(self.initialvalue)
end

#
# The field theCollection is explicitly named so that subclasses of Stack
# and Queue use these automatic initializations.  The / operator is used
# to reduce the number of throw-away list allocations for subclasses which
# >don't< inherit theCollection from Stack or Queue (e.g. class List).
# It also allows initialization by constructor.  If one wanted to
# guarantee that all Stacks start out empty but still allow class List
# to be explicitly intitialized, one could remove the / here, and name
# theCollection in class List, causing its initially section to override
# the superclass with respect to the field theCollection.  I choose here
# to maximize code sharing rather than protecting my Stack class.
#
# When allowing initialization by constructor one might consider
# checking the type of the input to guarantee it conforms to the
# type expected by the class.
#
class Stack : Collection(theCollection)
  method push(value)
    push(self.theCollection,value)
  end
  method pop()
    return pop(self.theCollection)
  end
initially
  /self.theCollection := []
end

class Queue : Collection(theCollection)
  method get()
    return get(self.theCollection)
  end
  method put(value)
    put(self.theCollection,value)
  end
initially
  /self.theCollection := []
end

class Deque : Queue : Stack()
end

#
# List inherits Queue's theCollection initialization, because Queue is the
# first class on List's (transitively closed) superclass list to name
# theCollection explicitly
#
class List : Deque : Vector()
  method concat(l)
    return List(self.theCollection ||| l)
  end
end

class Atom : Object(public val)
  method asString()
    return string(self.val)
  end
  method asInteger()
    return integer(self.val)
  end
  method asReal()
    return real(self.val)
  end
end

class Number : Atom ()
  method plus(n)
    return self.val + n$val()
  end
  method minus(n)
    return self.val - n$val()
  end
  method times(n)
    return self.val * n$val()
  end
  method divide(n)
    return self.val / n$val()
  end
end

class Integer : Number()
initially
  if not (self.val := integer(self.val)) then
    stop("can't make Integer from ",image(self.val))
end

class Real : Number()
initially
  if not (self.val := real(self.val)) then
    stop("can't make Real from ",image(self.val))
end

class String : Vector : Atom()
  method concat(s)
    return self.theCollection || s
  end
end
##########
fraction.iol
class fraction(n,d)
  method n()
    return self.n
  end
  method d()
    return self.d
  end
  method times(f)
    return fraction(self.n * f$n(), self.d * f$d())
  end
  method asString()
    return self.n||"/"||self.d
  end
  method asReal()
    return real(self.n) / self.d
  end
initially
  if self.d=0 then stop("fraction: denominator=0")
end
##########
idol.1
.TH IDOL 1 "26 February 1990"
.UC 4
.SH NAME
idol \- Icon-Derived Object Language
.SH SYNOPSIS
.B idol
.B \-install
.br
.B idol
[
.B option...
]
mainfile otherfiles
[
.B \-x
arguments
]
.SH DESCRIPTION
.PP
.I Idol
is an object-oriented preprocessor for Version 7.5+ Icon.
It is a front-end for
.I icont(1)
; typically one invokes idol on
a source file (extension .iol) which is translated into an
Icon source file (extension .icn) which is translated into a
file suitable for interpretation by the Icon interpreter.
Each directory containing Idol source files should be initialized
by
.B idol
.B \-install
prior to translating any user sources.
Producing an executable is skipped when the first file on the
list contains only classes.
.PP
The
.B \-c
option suppresses the linking phase normally done by
.I Icont.
.PP
The
.B \-t
option suppresses
.B all
translation by
.I Icont;
it is useful on systems for which Icon does not support the
.br
.B system\(\)
function.
.PP
The
.B \-s
option suppresses removal of
.B \.icn
files after translation by
.I Icont;
normally they are deleted after a successful translation.
.PP
The
.B \-quiet
option suppresses most Idol-specific console messages.
.PP
The
.B \-install
option installs the Idol
.B environment
.br
in the current directory.
.PP
The
.B \-strict
option causes
.I Idol
to generate code which is paranoid about ensuring encapsulation.
.PP
The
.B \-version
option causes
.I Idol
to print out its version and date of creation, and then exit.
.PP
The second and following files on the command line may include
extensions
.B \.icn
,
.B \.u1
, and
.B \.cl\.
The first two Idol treats as
Icon source code which should be translated and linked into the
resulting executable.  Files with extension
.B \.cl
are treated as class names which are linked into the resulting executable.
.PP
.SH AUTHOR
.PP
Clinton Jeffery, [e-mail]
.PP
.SH FILES
.PP
.nf
idol                          The Idol translator itself.
.br
prog.iol                      Idol source files
.br
prog.icn                      Icon code (non-classes) from prog.iol
.br
idolcode.env/i_object.*       Icon code for the Idol object type
.br
idolcode.env/classname.icn    Icon files generated for each class
.br
idolcode.env/classname.u[12]  Translated class files
.br
idolcode.env/classname        Class specification/interface
.fi
.SH SEE ALSO
.PP
.br
"Programming in Idol: An Object Primer"
.br
(U of Arizona Dept of CS Technical Report #90-10)
.br
serves as a user's guide and reference manual for Idol
##########
idol.bat
iconx idol %1 %2 %3 %4 %5 %6 %7 %8 %9
idolt
##########
idol.com
$ ! VMS Idol invocation script for simple compiles
$ iconx idol "-t" 'P1' 'P2' 'P3' 'P4' 'P5' 'P6' 'P7' 'P8' 'P9'
$ icont "-Sr1000" "-Sg500" "-SF30" 'P1'
##########
idol.doc



                Programming in Idol: An Object Primer

                          Clinton L. Jeffery

                           March 14, 1990

Idol is an object-oriented extension and environment for the
Icon programming language.  This document describes Idol in two parts.
The first part presents Idol's object-oriented programming concepts
as an integral tool with which a programmer maps a good program
design into a good implementation.  As such, it serves as
of "user's guide" for Idol's extensions to Icon.  Idol's
object-oriented programming facilities are viewed within the
broader framework of structured programming and modular design
in general.  Idol's precise syntax and semantics are detailed in the
second part, "An Icon-Derived Object Language", which serves as a
reference manual.





             Object-Oriented Programming After a Fashion

Object-oriented programming means different things to different people.
In Idol, object-oriented programming centers around encapsulation,
inheritance, and polymorphism.  These key ideas are shared by most
object-oriented languages as well as many languages that are not
considered object-oriented.  This paper introduces these ideas and
illustrates their use in actual code.  Idol is relevant in this
discussion because programming concepts are more than mental
exercises; they are mathematical notations by which programmers share
their knowledge.

Object-oriented programming can be done in Smalltalk, C++, or
assembler language for that matter, but this does not mean these
programming notations are equally desirable.  Assembler languages
are not portable.  For most programmers, Smalltalk uses an alien
notation; Smalltalk programs also share the flaw that they do not
work well in environments such as UNIX and DOS that consist of
interacting programs written in many languages.  C++ has neither of
these flaws, but the same low-level machine-oriented character
that makes it efficient also makes C++ less than ideal as an
algorithmic notation usable by nonexperts.

Idol owes most of its desirable traits to its foundation, the Icon
programming language, developed at the University of Arizona
[Griswold83].  In fact, Idol presents objects simply as a tool
to aid in the writing of Icon programs. Idol integrates a concise,
robust notation for object-oriented programming into a language
considerably more advanced than C or Pascal.  Icon already uses a
powerful notation for expressing a general class of algorithms. The
purpose of Idol is to enhance that notation, not to get in the way.


                             Key Concepts

This section describes the general concepts that Idol supplies
to authors of large Icon programs.  The following section provides
programming examples that employ these tools.  The reader is
encouraged to refer back to this section when clarification in
the examples section is needed.

The single overriding reason for object-oriented programming
is the large program.  Simple programs can be easily written in
any notation.  Somewhere between the 1,000-line mark and the
10,000-line mark most programmers can no longer keep track of their
entire program at once.  By using a very high-level programming language,
less lines of code are required; a programmer can write perhaps ten
times as large a program and still be able to keep track of things.
As programmers are required to write larger and larger programs,
the benefit provided by very-high level languages does not keep up
with program complexity.  This obstacle has been labelled the
"software crisis", and object-oriented programming addresses this
crisis.  In short, the goals of object-oriented programming are to
reduce the amount of coding required to write very large programs and
to allow code to be understood independently of the context of the
surrounding program.  The techniques employed to achieve these goals
are discussed below.


                            Encapsulation

The primary concept advocated by object-oriented programming is the
principle of encapsulation.  Encapsulation is the isolation, in the
source code that a programmer writes, of a data representation and the code
that manipulates the data representation.  In some sense, encapsulation
is an assertion that no other routines in the program have "side-effects"
with respect to the data structure in question.  It is easier to reason
about encapsulated data because all of the source code that could affect
that data is immediately present with its definition.

Encapsulation does for data structures what the procedure does for
algorithms: it draws a line of demarcation in the program text, the
outside of which is (or can be, or ought to be) irrelevant to the inside.
We call an encapsulated data structure an object. Just as a set of
named variables called parameters comprise the only interface between a
procedure and the code that uses it, a set of named procedures called
methods comprise the only interface between an object and the code that
uses it.

This textual definition of encapsulation as a property of program
source code accounts for the fact that good programmers can write
encapsulated data structures in any language.  The problem is not
capability, but verification.  In order to verify encapsulation some
object-oriented languages, like C++, define an elaborate mechanism by
which a programmer can govern the visibility of each data structure.
Like Smalltalk, Idol instead attempts to simplify verification by
preventing violations of encapsulation entirely.


                             Inheritance

In large programs, the same or nearly the same data structures are
used over and over again for a myriad of different purposes.  Similarly,
variations on the same algorithms are employed by structure after
structure.  In order to minimize redundancy, techniques are needed to
support code sharing for both data structures and algorithms.
Code is shared by related data structures by a programming concept
called inheritance.

The basic premise of inheritance is simple: if I need to write code
for a new data structure which is similar to one that's already
written, I can specify the new structure by giving the differences
between it and the old structure, instead of copying and then modifying
the old structure's code.  Obviously there are times when the
inheritance mechanism is not useful: if the two data structures are
more different than they are similar, or if they are simple enough
that inheritance would only confuse things, for example.

Inheritance addresses a variety of common programming problems found
at different conceptual levels.  The most obvious software engineering
problem it solves might be termed enhancement.  During the
development of a program, its data structures may require extension
via new state variables or new operations or both; inheritance is
especially useful when both the original structure and the extension
are used by the application.  Inheritance also supports
simplification, or the reduction of a data structure's state variables
or operations.  Simplification is analogous to argument culling after
the fashion of the lambda calculus; it captures a logical relation
between structures rather than a common situation in software
development.  In general, inheritance may be used in source code to
describe any sort of relational hyponymy, or special-casing; in Idol
the collection of all inheritance relations defines a directed (not
necessarily acyclic) graph.


                             Polymorphism

From the perspective of the writer of related data structures,
inheritance provides a convenient method for code sharing, but
what about the code that uses objects?  Since objects are
encapsulated, that code is not dependent upon the internals of
the object at all, and it makes no difference to the client code
whether the object in questions belongs to the original class or the
inheriting class.

In fact, we can make a stronger statement.  Due to encapsulation,
two different executions of some code that uses objects to implement
a particular algorithm may operate on different objects that are
not related by inheritance at all.  Such code may effectively
be shared by any objects that happen to implement the operations
that the code invokes.  This facility is called polymorphism, and
such algorithms are called generic.  This feature is found in
non-object oriented languages; in object-oriented languages it is
a natural extension of encapsulation.


                          Object Programming

The concepts introduced above are used in many programming languages
in one form or another.  The following text presents these concepts
in the context of actual Idol code.  This serves a dual purpose:
it should clarify the object model adopted by Idol as well as
provide an initial impression of these concepts' utility in coding.
In order to motivate the constructs provided by Idol, our example
begins by contrasting conventional Icon code with Idol code which
implements the same behavior.  The semantics of the Idol code given
here is defined by the Idol reference manual, included later in this
document in the section entitled, "An Icon-Derived Object Language".

                            Before Objects

In order to place Idol objects in their proper context, the first
example is taken from from regular Icon.  Suppose I am writing some
text-processing application such as a text editor.  Such applications
need to be able to process Icon structures holding the contents of
various text files.  I might begin with a simple structure like the
following:

record buffer(filename,text,index)

where filename is a string, text is a list of strings
corresponding to lines in the file, and index is a marker for
the current line at which the buffer is being processed.  Icon record
declarations are global; in principle, if the above declaration needs
to be changed, the entire program must be rechecked.  A devotee of
structured programming would no doubt write Icon procedures to read
the buffer in from a file, write it out to a file, examine, insert
and delete individual lines, etc.  These procedures, along with the
record declaration given above, can be kept in a separate source file
(buffer.icn) and understood independently of the program(s) in
which they are used.  Here is one such procedure:


# read a buffer in from a file
procedure read_buffer(b)
  f := open(b.filename) | fail
  b.text := [ ]
  b.position := 1
  every put(b.text,!f)
  close(f)
  return b
end

There is nothing wrong with this example; in fact its similarity to the
object-oriented example that follows demonstrates that a good, modular
design is the primary effect encouraged by object-oriented programming.
Using a separate source file to contain a record type and those
procedures which operate on that type allows an Icon programmer to
maintain a voluntary encapsulation of that type.

                            After Objects

Here is the same buffer abstraction coded in Idol.  This example
lays the groundwork for some more substantial techniques to follow.

class buffer(public filename,text,index)
  # read a buffer in from a file
  method read()
    f := open(self.filename) | fail
    self$erase()
    every put(self.text,!f)
    close(f)
    return
  end
  # write a buffer out to a file
  method write()
    f := open(self.filename,"w") | fail
    every write(f,!self.text)
    close(f)
  end
  # insert a line at the current index
  method insert(s)
    if self.index = 1 then {
      push(self.text,s)
    } else if self.index > *self.text then {
      put(self.text,s)
    } else {
      self.text := self.text[1:self.index]|||[s]|||self.text[self.index:0]
    }
    self.index +:= 1
    return
  end
  # delete a line at the current index
  method delete()
    if self.index > *self.text then fail
    rv := self.text[self.index]
    if self.index=1 then pull(self.text)
    else if self.index = *self.text then pop(self.text)
    else self.text := self.text[1:self.index]|||self.text[self.index+1:0]
    return rv
  end
  # move the current index to an arbitrary line
  method goto(l)
    if (0 <= l) & (l <= self.index+1) then return self.index := l
  end
  # return the current line and advance the current index
  method forward()
    if self.index > *self.text then fail
    rv := self.text[self.index]
    self.index +:= 1
    return rv
  end
  method erase()
    self.text     := [ ]
    self.index    := 1
  end
initially
  if \ (self.filename) then {
    if not self$read() then self$erase()
  } else {
    self.filename := "*scratch*"
    self$erase()
  }
end


This first example is not complex enough to illustrate the full
object-oriented style, but its a start.  Pertaining to the
general concepts introduced above, we can make the following
initial observations:

Polymorphism. A separate name space for each class's methods
makes for shorter names.  The same method name can be used in each
class that implements a given operation.  This notation is more
concise than is possible with standard Icon procedures.  More
importantly it allows algorithms to operate correctly upon objects of
any class which implements the operations required by the algorithm.
Constructors.  A section of code is executed automatically when
the constructor is called, allowing initialization of fields to values
other than &null.  Of course, this could be simulated in Icon
by writing a procedure that had the same effect; the value of the
constructor is that it is automatic; the programmer is freed from the
responsibility of remembering to call this code everywhere objects are
created in the client program(s).  This tighter coupling of memory
allocation and its corresponding initialization removes one more
source of program errors, especially on multiprogrammer projects.


These two observations share a common theme: the net effect is that
each piece of data is made responsible for its own behavior in the
system. Although this first example dealt with simple line-oriented
text files, the same methodology applies to more abstract entities
such as the components of a compiler's grammar (This example
is taken from the Idol translator itself, which provides another
extended example of polymorphism and inheritance.).

Idol's code sharing facilities are illustrated if we extend the above
example.  Suppose the application is more than just a text editor---
it includes word-associative databases such as a dictionary,
bibliography, spell-checker, thesaurus, etc.  These various databases
can be represented internally using Icon tables.  The table entries
for the databases vary, but the databases all use string keyword
lookup.  As external data, the databases can be stored in text files,
one entry per line, with the keyword at the beginning.  The format
of the rest of the line varies from database to database.

Although all these types of data are different, the code used to
read the data files can be shared, as well as the initial construction
of the tables.  In fact, since we are storing our data one entry per
line in text files, we can use the code already written for buffers
to do the file i/o itself.


class buftable : buffer()
  method read()
    self$buffer.read()
    tmp := table()
    every line := !self.text do
      line ? { tmp[tab(many(&letters))] := line | fail }
    self.text := tmp
    return
  end
  method lookup(s)
    return self.text[s]
  end
end


This concise example shows how little must be written to achieve
data structures with vastly different behavioral characteristics,
by building on code that is already written.  The superclass
read() operation is one important step of the subclass
read() operation; this technique is common enough to have a
name: it is called method combination in the literature. It
allows one to view the subclass as a transformation of the
superclass.  The buftable class is given in its entirety, but
our code sharing example is not complete: what about the data
structures required to support the databases themselves?  They are all
variants of the buftable class, and a set of possible
implementations is given below.  Note that the formats presented are
designed to illustrate code sharing; clearly, an actual application
might make different choices.

                            Bibliographies

Bibliographies might consist of a keyword followed by an uninterpreted
string of information.  This imposes no additional structure on the
data beyond that imposed by the buftable class.  An example
keyword would be Jeffery90.


class bibliography : buftable()
end



                            Spell-checkers

The database for a spell-checker is presumably just a list of words,
one per line; the minimal structure required by the buftable
class given above.  Some classes exist to introduce new terminology
rather than define a new data structure.  In this case we introduce
a lookup operation which may fail, for use in tests.  In addition,
since many spell-checking systems allow user definable dictionaries
in addition to their central database, we allow spellChecker
objects to chain together for the purpose of looking up words.


class spellChecker : buftable(parentSpellChecker)
  method spell(s)
    return \ (self.text[s]) | (\ (self.parentSpellChecker))$spell(s)
  end
end



                             Dictionaries

Dictionaries are slightly more involved.  Each entry might consist of a
part of speech, an etymology, and an arbitrary string of uninterpreted
text comprising a definition for that entry, separated by semicolons.
Since each such entry is itself a structure, a sensible decomposition
of the dictionary structure consists of two classes: one that manages
the table and external file i/o, and one that handles the manipulation
of dictionary entries, including their decoding and encoding as
strings.


class dictionaryentry(word,pos,etymology,definition)
  method decode(s) # decode a dictionary entry into its components
    s ? {
      self.word       := tab(upto(';'))
      move(1)
      self.pos        := tab(upto(';'))
      move(1)
      self.etymology  := tab(upto(';'))
      move(1)
      self.definition := tab(0)
    }
  end
  method encode()  # encode a dictionary entry into a string
    return self.word||";"||self.pos||";"||self.etymology||";"||self.definition
  end
initially
  if /self.pos then {
    # constructor was called with a single string argument
    self$decode(self.word)
  }
end

class dictionary : buftable()
  method read()
    self$buffer.read()
    tmp := table()
    every line := !self.text do
      line ? { tmp[tab(many(&letters))] := dictionaryentry(line) | fail }
    self.text := tmp
  end
  method write()
    f := open(b.filename,"w") | fail
    every write(f,(!self.text)$encode())
    close(f)
  end
end


                               Thesauri

Although an oversimplification, one might conceive of a thesauri as a
list of entries, each of which consists of a comma-separated list of
synonyms followed by a comma-separated list of antonyms, with a
semicolon separating the two lists.  Since the code for such a
structure is nearly identical to that given for dictionaries above,
we omit it here (but one might reasonably capture a generalization
regarding entries organized as fields separated by semicolons).


               Objects and Icon Programming Techniques

In examining any addition to a language as large as Icon, a
significant question is how that addition relates to the rest of the
language. In particular, how does object-oriented programming fit into
the suite of advanced techniques used regularly by Icon programmers?
Previous sections of this document expound objects as an
organizational tool, analogous but more effective than the use of
separate compilation to achieve program modularity.  Object-oriented
programming goes considerably beyond that viewpoint.

Whether viewed dynamically or statically, the primary effect achieved
by object-oriented programming is the subdivision of program data in
parallel with the code.  Icon already provides a variety of tools that
achieve related effects:

Local and Static Variables in Icon procedures are the simplest
imaginable parallel association of data and code.  We do not discuss
them further, although they are by no means insignificant.
Records allow a simple form of user-defined types. They provide
a useful abstraction, but keeping records associated with the right
pieces of code is still the job of the programmer.
String Scanning creates scanning environments.  These are very
useful, but not very general: not all problems can be cast as
string operations.
Co-expressions save a program state for later evaluation.  This
powerful facility has a sweeping range of uses, but unfortunately it
is a relatively expensive mechanism that is frequently misused to
achieve a simple effect.


Objects and classes, if they are successful, allow a significant
generalization of the techniques developed around the above
language mechanisms.  Objects do not replace these language
mechanisms, but in many cases presented below they provide an
attractive alternative means of achieving similar effects.

                         Objects and records

Objects are simply records whose field accesses are voluntarily
limited to a certain set of procedures.

                  Objects and scanning environments

String scanning in Icon is another example of associating a piece of
data with the code that operates on it.  In an Icon scanning
expression of the form e1 ? e2, the result of evaluating
e1 is used implicitly in e2 via a variety of scanning
functions.  In effect, the scanning operation defines a scope in which
state variables &subject and &pos are redefined.
[Walker86] proposes an extension to Icon allowing
programmer-defined scanning environments. The extension involves a new
record data type augmented by sections of code to be executed upon
entry, resumption, and exit of the scanning environment.  The Icon
scanning operator was modified to take advantage of the new facility
when its first argument was of the new environment data type.

While objects cannot emulate Icon string scanning syntactically, they
generalize the concept of the programmer-defined scanning environment.
Classes in the Idol standard library include a wide variety of
scanning environments in addition to conventional strings.  The
variation is not limited to the type of data scanned; it also includes
the form and function of the scanning operations.  The form of
scanning operations available are defined by the state variables they
access; in the case of Icon's built-in string scanning, a single
string and a single integer index into that string.

There is no reason that a scanning environment cannot maintain a more
complex state, such as an input string, an output string, and a pair
of indices and directions for each string.  Rather than illustrate
the use of objects to construct scanning environments with such an
abstract model, a concrete example is presented below.

                            List scanning

List scanning is a straightforward adaptation of string scanning to
the list data type.  It consists of a library class named
ListScan that implements the basic scanning operations, and
various user classes that include the scanning expressions.  This
format is required due to Idol's inability to redefine the semantics
of the ? operator or to emulate its syntax in any reasonable
way.  The state maintained during a list scan consists of
Subject and Pos,  analogous to &subject and
&pos, respectively.

ListScan defines analogies to the basic scanning functions of
Icon, e.g. tab, upto, many, any, etc.  These
functions are used in methods  of a ListScan client class, which
in turn defines itself as a subclass of ListScan.  A client such as:

class PreNum : ListScan()
  method scan()
    mypos := self.Pos
    suspend self$tab(self$upto(numeric))
    self.Pos := mypos
  end
end

may be used in an expression such as

(PreNum(["Tucson", "Pima", 15.0, [ ], "3"]))$scan()

producing the result ["Tucson", "Pima"].  The conventional Icon
string scanning analogy would be: "abc123" ? tab(upto(&digits)),
which produces the result "abc".  Note that ListScan
methods frequently take list-element predicates as arguments where
their string scanning counterparts take csets.  In the above example,
the predicate numeric supplied to upto is an Icon
function, but predicates may also be arbitrary user-defined procedures.

The part of the Idol library ListScan class required to
understand the previous example is presented below.  This code is
representative of user-defined scanning classes allowing pattern
matching over arbitrary data structures in Idol.  Although
user-defined scanning is more general than Icon's built-in scanning
facilities, the scanning methods given below are always
activated in the context of a specific environment.  Icon string
scanning functions can be supplied an explicit environment using
additional arguments to the function.


class ListScan(Subject,Pos)
  method tab(i)
    if i<0 then i := *self.Subject+1-i
    if i<0 | i>*self.Subject+1 then fail
    origPos := self.Pos
    self.Pos := i
    suspend self.Subject[origPos:i]
    self.Pos := origPos
  end
  method upto(predicate)
    origPos := self.Pos
    every i := self.Pos to *(self.Subject) do {
      if predicate(self.Subject[i]) then suspend i
    }
    self.Pos := origPos
  end
initially
  /(self.Subject) := [ ]
  /(self.Pos) := 1
end



                      Objects and co-expressions

Objects cannot come close to providing the power of co-expressions,
but they do provide a more efficient means of achieving well-known
computations such as parallel expression evaluation that have been
promoted as uses for co-expressions.  In particular, a co-expression
is able to capture implicitly the state of a generator for later
evaluation; the programmer is saved the trouble of explicitly coding
what can be internally and automatically performed by Icon's
expression mechanism.  While objects cannot capture a generator state
implicitly, the use of library objects mitigates the cost of
explicitly encoding the computation to be performed, as an
alternative to the use of co-expressions.  The use of objects also is
a significant alternative for implementations of Icon in which
co-expressions are not available or memory is limited.

                         Parallel evaluation

In [Griswold87], co-expressions are used to obtain the results
from several generators in parallel:

decimal   := create(0 to 255)
hex       := create(!"0123456789ABCDEF" || !"0123456789ABCDEF")
octal     := create((0 to 3) || (0 to 7) || (0 to 7))
character := create(image(!&cset))
while write(right(@decimal,3)," ",@hex," ",@octal," ",@character)


For the Idol programmer, one alternative to using co-expressions would
be to link in the following code from the Idol standard library:

procedure sequence(bounds[ ])
  return Sequence(bounds)
end

class Sequence(bounds,indices)
  method max(i)
    elem := self.bounds[i]
    return (type(elem)== "integer",elem) | *elem-1
  end
  method elem(i)
    elem := self.bounds[i]
    return (type(elem)== "integer",self.indices[i]) | elem[self.indices[i]+1]
  end
  method activate()
    top := *(self.indices)
    if self.indices[1] > self$max(1) then fail
    s := ""
    every i := 1 to top do {
      s ||:= self$elem(i)
    }
    repeat {
       self.indices[top] +:= 1
       if top=1 | (self.indices[top] <= self$max(top)) then break
       self.indices[top] := 0
       top -:= 1
    }
    return s
  end
initially
  / (self.indices) := list(*self.bounds,0)
end


On the one hand, the above library code is neither terse nor general
compared with co-expressions. This class does, however, allow the
parallel evaluation problem described previously to be coded as:

decimal   := sequence(255)
hex       := sequence("0123456789ABCDEF","0123456789ABCDEF")
octal     := sequence(3,7,7)
character := sequence(string(&cset))
while write(right($@decimal,3)," ",$@hex," ",$@octal," ",image($@character))


$@ is the unary Idol meta-operator that invokes the
activate() operation. Since the sequence class is already
written and available, its use is an attractive alternative to
co-expressions in many settings.  For example, a general class of
label generators (another use of co-expressions cited in
[Griswold87]) is defined by the following library class:

class labelgen : Sequence(prefix,postfix)
  method activate()
    return self.prefix||self$Sequence.activate()||self.postfix
  end
initially
  /(self.prefix) := ""
  /(self.postfix) := ""
  /(self.bounds)  := [50000]
end

After creation of a label generator object (e.g.
label := labelgen("L",":")), each resulting label is obtained
via $@label. The sequence defined by this example is

        L0:
        L1:
        ...
        L50000:


                              Conclusion

Idol presents object programming as a collection of tools to reduce
the complexity of large Icon programs.  These tools are encapsulation,
inheritance, and polymorphism.  Since a primary goal of Idol is to
promote code sharing and reuse, a variety of specific programming
problems have elegant solutions available in the Idol class library.


                   An Icon-Derived Object Language

This section serves as the language reference manual for Idol.  Idol
is a preprocessor for Icon which implements a means of associating a
piece of data with the procedures which manipulate it.  The primary
benefits to the programmer are thus organizational.  The Icon
programmer may view Idol as providing an augmented record type in
which field accesses are made not directly on the records' fields, but
rather through a set of procedures associated with the type.


                               Classes

Since Idol implements ideas found commonly in object-oriented
programming languages, its terminology is taken from that domain.  The
augmented record type is called a "class".  The syntax of a class is:


class foo(field1,field2,field3,...)
   # procedures to access
   # class foo objects

[code to initialize class foo objects]
end


In order to emphasize the difference between ordinary Icon procedures
and the procedures which manipulate class objects, these procedures
are called "methods" (the term is again borrowed from the
object-oriented community).  Nevertheless, the syntax of a method is
that of a procedure:


method bar(param1,param2,param3,...)

   # Icon code which may access
   # fields of a class foo object
end


Since execution of a class method is always associated with a given
object of that class, the method has access to an implicit variable
called self which is a record containing fields whose names are
those given in the class declaration.  References to the self variable
look just like normal record references; they use the dot (.)
operator.  In addition to methods, classes may also contain regular
Icon procedure, global, and record declarations; such declarations
have the standard semantics and exist in the global Icon name space.


                               Objects

Like records, instances of a class type are created with a constructor
function whose name is that of the class.  Instances of a class are
called objects, and their fields may be initialized explicitly in the
constructor in exactly the same way as for records.  For example,
after defining a class foo(x,y) one may write:


procedure main()

  f := foo(1,2)
end


The fields of an object need not be initialized by the class
constructor.  For many objects it is more logical to initialize their
fields to some standard value.  In this case, the class declaration
may include an "initially" section after its methods are defined and
before its end.

This section begins with a line containing the word "initially" and
then contains lines which are executed whenever an object of that
class is constructed.  These lines may reference and assign to the
class fields as if they were normal record fields for the object being
constructed.  The "record" being constructed is named self;
more on self later.

For example, suppose one wished to implement an enhanced table type
which permitted sequential access to elements in the order they were
inserted into the table.  This can be implemented by a combination of
a list and a table, both of which would initialized to the appropriate
empty structure:


class taque(l,t) # pronouned `taco'

  # methods to manipulate taques,
  # e.g. insert, lookup, foreach...

initially
  self.l := [ ]
  self.t := table()
end


And in such a case one can create objects without including arguments
to the class constructor:


procedure main()

  mytaque := taque()
end


In the absence of an initially section, missing arguments to a
constructor default to the null value.  Together with an initially
section, the class declaration looks rather like a procedure that
constructs objects of that class.  Note that one may write classes
with some fields that are initialized explicitly by the constructor
and other fields are initialized automatically in the initially
section.  In this case one must either declare the automatically
initialized fields after those that are initialized in the
constructor, or insert &null in the positions of the
automatically initialized fields in the constructor.



                          Object Invocation

Once one has created an object with a class constructor, one
manipulates the object by invoking methods defined by its class.
Since objects are both procedures and data, object invocation is
similar to both a procedure call and a record access.  The dollar
($) operator invokes one of an object's methods.  It used
similarly to the dot (.) operator used to access record fields.
Using the taque example:


procedure main()
  mytaque := taque()
  mytaque$insert("greetings","hello")
  mytaque$insert(123)
  every write(mytaque$foreach())
  if \(mytaque$lookup("hello"))
    then write(", world")
end


Note that direct access to an object's fields using the usual dot (.)
operator is not possible outside of a method of the appropriate class.
Attempts to reference mystack.l in procedure main() would result in
a runtime error (invalid field name).  Within a class method, the
implicit variable self allows access to the object's fields in
the usual manner.  The taque insert method is thus:


  method insert(x,key)
    /key := x
    put(self.l,x)
    self.t[key] := x
  end


The self variable is both a record and an object.  It allows field
access just like a record, as well as method invocation like any other
object.  Thus class methods can use self to invoke other class methods
without any special syntax.



                             Inheritance

In many cases, two classes of objects are very similar.  In
particular, many classes can be thought of simply as enhancements of
some class that has already been defined.  Enhancements might take the
form of added fields, added methods, or both.  In other cases a class
is just a special case of another class.  For example, if one had
defined a class fraction(numerator, denominator), one might want to
define a class inverses(denominator) whose behavior was identical to
that of a fraction, but whose numerator was always 1.

Idol supports both of these ideas with the concept of inheritance.
When the definition of a class is best expressed in terms of the
definition of another class or classes, we call that class a subclass
of the other classes.  This corresponds to the logical relation of
hyponymy. It means an object of the subclass can be manipulated just
as if it were an object of one of its defining classes.  In practical
terms it means that similar objects can share the code that
manipulates their fields. The syntax of a subclass is


class foo : superclasses (fields...)

# methods
[optional initially section]
end



                         Multiple Inheritance

There are times when a new class might best be described as a
combination of two or more classes.  Idol classes may have more than
one superclass, separated by colons in the class declaration.  This is
called multiple inheritance.

Subclasses define a record type consisting of all the fieldnames found
in the class itself and in all its superclasses.  The subclass has
associated methods consisting of those in its own body, those in the
first superclass which were not defined in the subclass, those in the
second superclass not defined in the subclass or the first superclass,
and so on.  Fields are initialized either by the constructor or by the
initially section of the first class of the class:superclass list in
which the field is defined.  For example, to define a class of
inverses in terms of a class fraction(numerator,denominator) one
would write:


class inverse : fraction (denominator)
initially
  self.numerator := 1
end


Objects of class inverse can be manipulated using all the methods
defined in class fraction; the code is actually shared by both classes
at runtime.

Viewing inheritance as the addition of fieldnames and methods of
superclasses not already defined in the subclass is the opposite of
the more traditional object-oriented view that a subclass starts with
an instance of the superclass and augments or overrides portions of
the definition with code in the subclass body.  Idol's viewpoint adds
quite a bit of leverage, such as the ability to define classes which
are subclasses of each other.  This feature is described further below.


                    Invoking Superclass Operations

When a subclass defines a method of the same name as a method defined
in the superclass, invocations on subclass objects always result in
the subclass' version of the method.  This can be overridden by
explicitly including the superclass name in the invocation:

object$superclass.method(parameters)

This facility allows the subclass method to do any additional work
required for added fields before or after calling an appropriate
superclass method to achieve inherited behavior.  The result is
frequently a chain of inherited method invocations.



                            Public Fields


As noted above, there is a strong correspondence between records and
classes.  Both define new types which extend Icon's built in
repertoire.  For simple jobs, records are slightly faster as well as
more convenient: the user can directly read and write a record's
fields by name.

Classes, on the other hand, promote the re-use of code and reduce the
complexity required to understand or maintain large, involved
structures.  They should be used especially when manipulating
composite structures ontaining mixes of structures as elements, e.g.
lists containing tables, sets, and lists in various positions.

Sometimes it would be really nice to access fields in an object
directly, as with records.  An example from the Idol program itself is
the name field associated with methods and classes---it is a
string which is intended to be read outside the object.  One can
always implement a method which returns (or assigns, for that matter)
a field value, but this gets tedious.  Idol currently supports
read-only access to fields via the public keyword.  If
public precedes a fieldname in a class declaration, Idol
automatically generates a method of the same name which dereferences
and returns the field.  For example, the declaration

class sinner(pharisee,public publican)

generates code equivalent to the following class method in addition
to any explicitly defined methods:

  method publican()
    return .(self.publican)
  end


This feature, despite its utility and the best of intentions, makes it
possible to subvert object encapsulation: it should not be
used with fields whose values are structures, since the structure
could then be modified from the outside.  When invoked with the
-strict option, Idol generates code for public methods which
checks for a scalar type at runtime before returning the field.



                Superclass Cycles and Type Equivalence

In many situations, there are several ways to represent the same
abstract type.  Two-dimensional points might be represented by
Cartesian coordinates x and y, or equivalently by radial coordinates
expressed as degree d and radian r.  If one were implementing classes
corresponding to these types there is no reason why one of them should
be considered a subclass of the other.  The types are truly
interchangeable and equivalent.

In Idol, expressing this
equivalence is simple and direct.  In defining classes Cartesian
and Radian we may declare them to be superclasses of each other:

class Cartesian : Radian (x,y)
# code which manipulates objects using cartesian coordinates
end

class Radian : Cartesian (d,r)
# code which manipulates objects using radian coordinates
end

These superclass declarations make the two types equivalent names for
the same type of object; after inheritance, instances of both classes
will have fields x,y,d, and r, and support the same set of operations.

Equivalent types each have their own constructor given by their class
name; although they export the same set of operations, the actual
procedures invoked by the different instances may be different.  For
example, if both classes define an implementation of a method
print, the method invoked by a given instance depends on
which constructor was used when the object was created.

If a class inherits any methods from one of its equivalent
classes, it is responsible for initializing the state of all
the fields used by those methods in its own constructor, and
maintaining the state of the inherited fields when its methods make
state changes to its own fields.  In the geometric example given
above, in order for class Radian to use any methods inherited
from class Cartesian, it must at least initialize x and y explicity
in its constructor from calculations on its d and r parameters.
In general, this added responsibility is minimized in those classes
which treat an object's state as a value rather than a structure.

The utility of equivalent types expressed by superclass cycles remains
to be seen.  At the least, they provide a convenient way to write
several alternative constructors for the same class of objects.
Perhaps more importantly, their presence in Idol causes us to question
the almost religious dogmatism that the superclass graph must always
be acyclic.



                              Miscellany

Idol supports some shorthand for convenient object invocation.  In
particular, if a class defines methods named size, foreach, random,
or activate, these methods can be invoked by a modified version of
the usual Icon operator:


$*x is equivalent to x$size()
$?x is equivalent to x$random()
$!x is equivalent to x$foreach()
$@x is equivalent to x$activate()


Other operators may be added to this list.  If x is an identifier
it may be used directly; if it is a more complex expression (such as a
function call) it should be parenthesized, e.g.
$*(complex_expression()).
Parentheses are also required in the case of invoking an object
returned from an invocation, e.g.

  (classes$lookup("theClass"))$name()

These requirements are artifacts of the first implementation and are
subject to change.

The Idol preprocessor is written in Idol and does not actually parse
the language it purports to implement.  In particular, the
preprocessor is line-oriented and class and method declarations, the
initially keyword, and the class and method end keyword need to be on
a line by themselves.  Similarly, both the object being invoked and
its method and parameters must be on the same line for invocations.

The Idol preprocessor reserves certain names for internal use.  In
particular, __state and __methods are not legal class
field names.  Similarly, the name idol_object is reserved in the
global name space, and may not be used as a global variable, procedure,
or record name. Finally, for each class foo amongst the user's
code, the names foo, foo___state, foo___methods,
foo__oprec are reserved, as are the names foo__bar
corresponding to each method bar in class foo. These
details are artifacts of the current implementation and are subject
to change.

Subclass constructors can be confusing, especially when multiple
inheritance brings in various fields from different superclasses.
One significant problem for users of the subclass is that the
parameters expected in the constructor may not be obvious if they
are inherited from a superclass.  On the other side of the spectrum,
superclasses which automatically initialize their fields can be
less than useful if the subclass might need to override the
default initialization value--the subclass must then explicitly
name the field in order to make its initially section have
precedence over the superclass.

The first of the two problems given above can be solved by naming
fields explicitly in a subclass when initialization by constructor.
This achieves clarity at the expense of changing the inheritance
behavior, since the subclass no longer inherits the superclass
automatic initialization for that field if there is one.  The latter
of the two problems can generally be solved by using the / operator
in automatic field initializations unless the initialization should
never be overridden.

While it is occasionally convenient to redeclare an inherited field
in a subclass, accidentally doing so and then using that field to store an
unrelated value would be disastrous.  Although Idol offers no proper
solution to this problem, the -strict option causes the generation
of warning messages for each redefined field name noting the relevant
sub- and superclasses.



                             Running Idol

Idol requires Version 7.5 or higher of Icon.  It runs best on UNIX
systems.  It has not been ported to all the various micros and
operating systems on which Icon 7.5 runs.  In particular, if your
version of Icon does not support the system() function, or your
machine does not have adequate memory available, Idol will not be
able to invoke icont to complete its translation and linking.
Since Idol is untested on many systems, you may have to make small
changes to the source code in order to port it to a new system.

                            Getting a Copy

Idol is in the public domain.  It is available on the Icon BBS and by
anonymous ftp from cs.arizona.edu.  Idol is also distributed with
the program library for Version 8 of Icon and is available by mail in
this way.  Interested parties may contact the author
([e-mail]):


         Department of Computer Science
         University of Arizona
         Tucson, AZ 85721


                     Creating an Idol executable

Idol is typically distributed in both Idol and Icon source forms.
Creating an Idol executable requires a running version of Icon and a
copy of idolboot.icn, the Icon source for Idol.  A second Icon
source file contains the operating-system dependent portion of Idol;
for example, unix.icn (see the Idol README file for the name of
your system file if you are not on a UNIX system; you may have to
write your own, but it is not difficult).  Using icont, compile
idolboot.icn and unix.icn into an executable file (named
idolboot, or  idolboot.icx). As a final step, rename this
executable to idol (or idol.icx).


                Installing the Idol Library Mechanism

For each directory in which Idol source is kept, the Idol preprocessor
normally uses a subdirectory to store its generated code on systems
which support a hierarchical file system.  On systems without a
hierarchy, it stores generated code in the source directory.  Before
actually running Idol on any source files you should install the
Idol libraries.  This is done by invoking the command

idol -install

(some systems use "iconx idol -install").  Follow any
directions given at this point; on most systems installation is
entirely automatic.


                      Translating Idol Programs

The syntax for invoking idol is normally

idol file1[.iol] [files...]

(on some systems you may have to say "iconx idol" where it
says "idol" above).  The Idol translator creates a separate
Icon file for each class in the Idol source files you give it.  On
most systems it calls icont automatically to create ucode for these
files.  If the first file on the command line has any normal Icon code
in it (in addition to any class definitions it may contain), Idol
attempts to link it to any classes it may need and create an executable.

The file extension defaults to .iol.  Idol also accepts
extensions .icn, .u1, and .cl.  The first two refer
to Icon source or already translated code for which Idol generates
link statements in the main (initial) Idol source file.  Idol treats
arguments with the extension .cl as class names and generates
link statements for that class and its superclasses.

                              References



[Gris83]
Griswold, R.E. and Griswold, M.T.
The Icon Programming Language.
Prentice-Hall, Englewood Cliffs, New Jersey, 1983.

[Gris87]
Griswold, R.E.
Programming in Icon; Part I---Programming with
  Co-Expressions.
Technical Report 87-6, Department of Computer Science, University of
  Arizona, June 1987.

[Walk86]
Walker, K.
Dynamic Environments---A Generalization of Icon String
  Scanning.
Technical Report 86-7, Department of Computer Science, University of
  Arizona, March 1986.


##########
idol.iol
# @(#)idol.iol    6.30 (3/14/90)
#
# Idol: Icon-derived object language, version 6.30
#
# SYNOPSIS:
#
#   idol -install
#   idol prog[.iol] ... [-x args ]
#   prog
#
# FILES:
#
#   ./prog.iol                       : source file
#   ./prog.icn                     : Icon code for non-classes in prog.iol
#   ./idolcode.env/i_object.*      : Icon code for the universal object type
#   ./idolcode.env/classname.icn   : Icon files are generated for each class
#   ./idolcode.env/classname.u[12] : translated class files
#   ./idolcode.env/classname       : class specification/interface
#
# SEE ALSO:
#
#   "Programming in Idol: An Object Primer"
#   (U of Arizona Dept of CS Technical Report #90-10)
#   serves as user's guide and reference manual for Idol
#
### Global variables
#
# FILES  : fin = input (.iol) file, fout = output (.icn) file
# CSETS  : alpha = identifier characters, nonalpha = everything else
#          alphadot = identifiers + '.'
#          white = whitespace, nonwhite = everything else
# TAQUES : classes in this module
# FLAGS  : comp if we should try to make an executable from args[1]
#          strict if we should generate paranoic encapsulation protection
#          loud if Idol should generate extra console messages
#          exec if we should run the result after translation
# LISTS  : links = names of external icon code to link to
#          imports = names of external classes to import
#          compiles = names of classes which need to be compiled
#
global fin,fout,fName,fLine,alpha,alphadot,white,nonwhite,nonalpha
global classes,comp,exec,strict,links,imports,loud,compiles

#
# initialize global variables
#
procedure initialize()
  loud     := 1
  comp     := 0
  alpha    := &ucase ++ &lcase ++ '_' ++ &digits
  nonalpha := &cset -- alpha
  alphadot := alpha ++ '.'
  white    := ' \t\014'
  nonwhite := &cset -- white
  classes  := taque()
  links    := []
  imports  := []
  compiles := []
  sysinitialize()
end

procedure main(args)
    initialize()
    if *args = 0 then write("usage: idol files...")
    else {
      every i := 1 to *args do {
    if \exec then next            # after -x, args are for execution
    if args[i][1] == "-" then {
      case map(args[i]) of {
        "-c"   : {
        sysok := &null
        if comp = 0 then comp := -1        # don't make exe
        }
        "-install": return install(args[1:i+1])
        "-quiet"  : loud := &null
        "-strict" : strict := 1
        "-s"      : sysok := &null
        "-t"      : comp := -2                      # don't translate
        "-version": return write("Idol version 6.30 of 3/14/90") & 0
        "-x"      : exec := i
      }
        }
        else if args[i][find(".cl",args[i]):0] := "" then push(imports,args[i])
    else if args[i][find(".icn",args[i]):0] := "" then {
      push(links,args[i])
      icont(" -c "||args[i])
    }
    else if args[i][find(".u1",args[i]):0] := "" then push(links,args[i])
    else if (args[i][find(".iol",args[i]):0] := "") |
        tryopen(args[i]||".iol","r") then {
      /exe := i
      args[i][find(".iol",args[i]):0] := ""
      /fout := sysopen(args[i]||".icn","w")
      readinput(args[i]||".iol",1)
        } else {
          #
          # let's go out and look for an appropriate .icn, .u1 or class file!
          #
      if tryopen(args[i]||".icn","r") then {
        push(links,args[i])
        icont(" -c "||args[i])
      }
      else if tryopen(args[i]||".u1") then push(links,args[i])
      else if tryenvopen(args[i]) then push(imports,args[i])
    }
      }
      gencode()
      close(\fout)
      if comp = 1 then makeexe(args,exe)
    }
end

#
# gencode first generates specifications for all defined classes
# It then imports those classes' specifications which it needs to
# compute inheritance.  Finally, it writes out all classes' .icn files.
#
procedure gencode()
  if \loud then write("Class import/export:")
  #
  # export specifications for each class
  #
  every cl := classes$foreach_t() do cl$writespec()
  #
  # import class specifications, transitively
  #
  repeat {
    added := 0
    every super:= ((classes$foreach_t())$foreachsuper() | !imports) do{
      if /classes$lookup(super) then {
    added := 1
    fname := filename(super)
    readinput(envpath(fname),2)
    if /classes$lookup(super) then halt("can't import class '",super,"'")
    writesublink(fname)
      }
    }
    if added = 0 then break
  }
  #
  # compute the transitive closure of the superclass graph
  #
  every (classes$foreach_t())$transitive_closure()
  #
  # generate output
  #
  if \loud then write("Generating code:")
  writesublink("i_object")
  every s := !links do writelink(s)
  write(fout)
  every out := $!classes do {
    name := filename(out$name())
    out$write()
    put(compiles,name)
    writesublink(name)
  }
  if *compiles>0 then cdicont(compiles)
end

#
# a class defining objects resulting from parsing lines of the form
# tag name ( field1 , field2, ... )
# If the constructor is given an argument, it is passed to self$read
#
class declaration(public name,fields,tag)
  #
  # parse a declaration string into its components
  #
  method read(decl)
    decl ? {
      # get my tag
      tab(many(white))
      if not (self.tag := =("procedure"|"class"|"method"|"record")) then
    halt("declaration/read can't parse decl ",decl)
      tab(many(white))
      # get my name
      if not (self.name := tab(many(alpha))) then
    halt("declaration/read can't parse decl ",decl)
      # get my fields
      if not tab(find("(")+1) then
      halt("declaration/read can't parse decl ",decl)
      tab(many(white))
      self.fields := classFields()
      if not (self.fields$parse(tab(find(")")))) then
    halt("declaration/read can't parse decl ",decl)
    }
  end

  #
  # write a declaration; at the moment, only used by records
  #
  method write(f)
     write(f,self$String())
  end
  #
  # convert self to a string
  #
  method String()
    return self.tag || " " || self.name || "(" || self.fields$String() || ")"
  end
initially
  if \self.name then self$read(self.name)
end

#
# class body manages a list of strings holding the code for
# procedures/methods/classes
#
class body(fn,ln,text)
  method read()
    self.fn    := fName
    self.ln    := fLine
    self.text  := []
    while line := readln() do {
      put(self.text, line)
      line ? { tab(many(white)); if ="end" & &pos > *line then return }
    }
    halt("body/read: eof inside a procedure/method definition")
  end
  method write(f)
    if \self.ln then write(f,"#line ",self.ln," \"",self.fn,"\"")
    every write(f,$!self)
  end
  method delete()
    return pull(self.text)
  end
  method size()
    return (*\ (self.text)) | 0
  end
  method foreach()
    if t := \self.text then suspend !self.text
  end
end

#
# a class defining operations on classes
#
class class : declaration (supers,methods,text,imethods,ifields,glob)
  # imethods and ifields are all lists of these:
  record classident(class,ident)

  method read(line,phase)
    self$declaration.read(line)
    self.supers := idTaque(":")
    self.supers$parse(line[find(":",line)+1:find("(",line)] | "")
    self.methods:= taque()
    self.text   := body()
    while line  := readln() do {
      line ? {
    tab(many(white))
    if ="initially" then {
        self.text$read()
        if phase=2 then return
        self.text$delete()    # "end" appended manually during writing after
                # generation of the appropriate return value
        return
    } else if ="method" then {
        decl := method(self.name)
        decl$read(line,phase)
        self.methods$insert(decl,decl$name())
    } else if ="end" then {
        # "end" is tossed here. see "initially" above
        return
    } else if ="procedure" then {
        decl := Procedure("")
        decl$read(line,phase)
        /self.glob := []
        put(self.glob,decl)
    } else if ="global" then {
        /self.glob := []
        put(self.glob,Global(line))
    } else if ="record" then {
        /self.glob := []
        put(self.glob,declaration(line))
    } else if upto(nonwhite) then {
        halt("class/read expected declaration on: ",line)
    }
      }
    }
    halt("class/read syntax error: eof inside a class definition")
  end

  #
  # Miscellaneous methods on classes
  #
  method has_initially()
    return $*self.text > 0
  end
  method ispublic(fieldname)
    if self.fields$ispublic(fieldname) then return fieldname
  end
  method foreachmethod()
    suspend $!self.methods
  end
  method foreachsuper()
    suspend $!self.supers
  end
  method foreachfield()
    suspend $!self.fields
  end
  method transitive_closure()
    count := $*self.supers
    while count > 0 do {
    added := taque()
    every sc := $!self.supers do {
      if /(super := classes$lookup(sc)) then
        halt("class/transitive_closure: couldn't find superclass ",sc)
      every supersuper := super$foreachsuper() do {
        if / self.supers$lookup(supersuper) &
         /added$lookup(supersuper) then {
          added$insert(supersuper)
        }
      }
    }
    count := $*added
    every self.supers$insert($!added)
    }
  end
  #
  # write the class declaration: if s is "class" write as a spec
  # otherwise, write as a constructor
  #
  method writedecl(f,s)
    writes(f, s," ",self.name)
    if s=="class" & ( *(supers := self.supers$String()) > 0 ) then
        writes(f," : ",supers)
    writes(f,"(")
    rv := self.fields$String(s)
    if *rv > 0 then rv ||:= ","
    if s~=="class" & \self.ifields then        # inherited fields
      every l := !self.ifields do rv ||:= l.ident || ","
    writes(f,rv[1:-1])
    write(f,,")")
  end
  method writespec(f) # write the specification of a class
    f := envopen(filename(self.name),"w")
    self$writedecl(f,"class")
    every ($!self.methods)$writedecl(f,"method")
    if self$has_initially() then write(f,"initially")
    write(f,"end")
    close(f)
  end

  #
  # write out the Icon code for this class' explicit methods
  # and its "nested global" declarations (procedures, records, etc.)
  #
  method writemethods()
    f:= envopen(filename(self.name)||".icn","w")
    every ($!self.methods)$write(f,self.name)

    if \self.glob & *self.glob>0 then {
    write(f,"#\n# globals declared within the class\n#")
    every i := 1 to *self.glob do (self.glob[i])$write(f,"")
    }
    close(f)
  end

  #
  # write - write an Icon implementation of a class to file f
  #
  method write()
    f:= envopen(filename(self.name)||".icn","a")
    #
    # must have done inheritance computation to write things out
    #
    if /self.ifields then self$resolve()

    #
    # write a record containing the state variables
    #
    writes(f,"record ",self.name,"_state(__state,__methods") # reserved fields
    rv := ","
    rv ||:= self.fields$idTaque.String()             # my fields
    if rv[-1] ~== "," then rv ||:= ","
    every s := (!self.ifields).ident do rv ||:= s || "," # inherited fields
    write(f,rv[1:-1],")")

    #
    # write a record containing the methods
    #
    writes(f,"record ",self.name,"_methods(")
    rv := ""

    every s := ((($!self.methods)$name())    |    # my explicit methods
        self.fields$foreachpublic()    |    # my implicit methods
        (!self.imethods).ident        |    # my inherited methods
        $!self.supers)                # super.method fields
    do rv ||:= s || ","

    if *rv>0 then rv[-1] := ""            # trim trailling ,
    write(f,rv,")")

    #
    # write a global containing this classes' operation record
    # along with declarations for all superclasses op records
    #
    writes(f,"global ",self.name,"__oprec")
    every writes(f,", ", $!self.supers,"__oprec")
    write(f)

    #
    # write the constructor procedure.
    # This is a long involved process starting with writing the declaration.
    #
    self$writedecl(f,"procedure")
    write(f,"local self,clone")

    #
    # initialize operation records for this and superclasses
    #
    write(f,"initial {\n",
        "  if /",self.name,"__oprec then ",self.name,"initialize()")
    if $*self.supers > 0 then
    every (super <- $!self.supers) ~== self.name do
        write(f,"  if /",super,"__oprec then ",super,"initialize()\n",
            "  ",self.name,"__oprec.",super," := ", super,"__oprec")
    write(f,"  }")

    #
    # create self, initialize from constructor parameters
    #
    writes(f,"  self := ",self.name,"_state(&null,",self.name,"__oprec")
    every writes(f,",",$!self.fields)
    if \self.ifields then every writes(f,",",(!self.ifields).ident)
    write(f,")\n  self.__state := self")

    #
    # call my own initially section, if any
    #
    if $*self.text > 0 then write(f,"  ",self.name,"initially(self)")

    #
    # call superclasses' initially sections
    #
    if $*self.supers > 0 then {
    every (super <- $!self.supers) ~== self.name do {
        if (classes$lookup(super))$has_initially() then {
        if /madeclone := 1 then {
            write(f,"  clone := ",self.name,"_state()\n",
            "  clone.__state := clone\n",
            "  clone.__methods := ",self.name,"__oprec")
        }
        write(f,"  # inherited initialization from class ",super)
        write(f,"    every i := 2 to *self do clone[i] := self[i]\n",
            "    ",super,"initially(clone)")
        every l := !self.ifields do {
            if l.class == super then
            write(f,"    self.",l.ident," := clone.",l.ident)
        }
        }
    }
    }

    #
    # return the pair that comprises the object:
    # a pointer to the instance (__mystate), and
    # a pointer to the class operation record
    #
    write(f,"  return idol_object(self,",self.name,"__oprec)\n",
        "end\n")

    #
    # write out class initializer procedure to initialize my operation record
    #
    write(f,"procedure ",self.name,"initialize()")
    writes(f,"  initial ",self.name,"__oprec := ",self.name,"_methods")
    rv := "("
    every s := ($!self.methods)$name() do {        # explicit methods
      if *rv>1 then rv ||:= ","
      rv ||:= self.name||s
    }
    every me := self.fields$foreachpublic() do {    # implicit methods
      if *rv>1 then rv ||:= ","            # (for public fields)
      rv ||:= self.name||me
    }
    every l := !self.imethods do {            # inherited methods
      if *rv>1 then rv ||:= ","
      rv ||:= l.class||l.ident
    }
    write(f,rv,")\n","end")
    #
    # write out initially procedure, if any
    #
    if self$has_initially() then {
    write(f,"procedure ",self.name,"initially(self)")
    self.text$write(f)
    write(f,"end")
    }

    #
    # write out implicit methods for public fields
    #
    every me := self.fields$foreachpublic() do {
      write(f,"procedure ",self.name,me,"(self)")
      if \strict then {
    write(f,"  if type(self.",me,") == ",
        "(\"list\"|\"table\"|\"set\"|\"record\") then\n",
        "    runerr(501,\"idol: scalar type expected\")")
    }
      write(f,"  return .(self.",me,")")
      write(f,"end")
      write(f)
    }

    close(f)

  end

  #
  # resolve -- primary inheritance resolution utility
  #
  method resolve()
    #
    # these are lists of [class , ident] records
    #
    self.imethods := []
    self.ifields := []
    ipublics := []
    addedfields := table()
    addedmethods := table()
    every sc := $!self.supers do {
    if /(superclass := classes$lookup(sc)) then
        halt("class/resolve: couldn't find superclass ",sc)
    every superclassfield := superclass$foreachfield() do {
        if /self.fields$lookup(superclassfield) &
           /addedfields[superclassfield] then {
        addedfields[superclassfield] := superclassfield
        put ( self.ifields , classident(sc,superclassfield) )
        if superclass$ispublic(superclassfield) then
            put( ipublics, classident(sc,superclassfield) )
        } else if \strict then {
        warn("class/resolve: '",sc,"' field '",superclassfield,
             "' is redeclared in subclass ",self.name)
        }
    }
    every superclassmethod := (superclass$foreachmethod())$name() do {
        if /self.methods$lookup(superclassmethod) &
           /addedmethods[superclassmethod] then {
        addedmethods[superclassmethod] := superclassmethod
        put ( self.imethods, classident(sc,superclassmethod) )
        }
    }
    every public := (!ipublics) do {
        if public.class == sc then
        put (self.imethods, classident(sc,public.ident))
    }
    }
  end
end

#
# a class defining operations on methods and procedures
#
class method : declaration (class,text)
  method read(line,phase)
    self$declaration.read(line)
    self.text := body()
    if phase = 1 then
      self.text$read()
  end
  method writedecl(f,s)
    decl := self$String()
    if s == "method" then decl[1:upto(white,decl)] := "method"
    else {
    decl[1:upto(white,decl)] := "procedure"
    decl[upto(white,decl)] ||:= self.class
    if *self.class ~= 0 then {
        i := find("(",decl)
        decl[i] ||:= "self" || (((decl[i+1] ~== ")"), ",") | "")
    }
    }
    write(f,decl)
  end
  method write(f)
    if self.name ~== "initially" then
    self$writedecl(f,"procedure")
    self.text$write(f)
    self.text := &null            # after writing out text, forget it!
  end
end

#
# A class for ordinary Icon global declarations
#
class Global(s)
  method write(f)
    write(f,self.s)
  end
end

#
# a class corresponding to an Icon table, with special treatment of empties
#
class Table(t)
  method size()
    return (* \ self.t) | 0
  end
  method insert(x,key)
    /self.t := table()
    /key := x
    if / (self.t[key]) := x then return
  end
  method lookup(key)
    if t := \self.t then return t[key]
    return
  end
  method foreach()
    if t := \self.t then every suspend !self.t
  end
end

#
# tabular queues (taques):
# a class defining objects which maintain synchronized list and table reps
# Well, what is really provided are loosely-coordinated list/tables
#
class taque : Table (l)
  method insert(x,key)
    /self.l := []
    if self$Table.insert(x,key) then put(self.l,x)
  end
  method foreach()
    if l := \self.l then every suspend !self.l
  end
  method insert_t(x,key)
    self$Table.insert(x,key)
  end
  method foreach_t()
    suspend self$Table.foreach()
  end
end

#
# support for taques found as lists of ids separated by punctuation
# constructor called with (separation char, source string)
#
class idTaque : taque(punc)
  method parse(s)
    s ? {
      tab(many(white))
      while name := tab(find(self.punc)) do {
    self$insert(trim(name))
    move(1)
    tab(many(white))
      }
      if any(nonwhite) then self$insert(trim(tab(0)))
    }
    return
  end
  method String()
    if /self.l then return ""
    out := ""
    every id := !self.l do out ||:= id||self.punc
    return out[1:-1]
  end
end

#
# parameter lists in which the final argument may have a trailing []
#
class argList : idTaque(public varg)
  method insert(s)
    if \self.varg then halt("variable arg must be final")
    if i := find("[",s) then {
      if not (j := find("]",s)) then halt("variable arg expected ]")
      s[i : j+1] := ""
      self.varg := s := trim(s)
    }
    self$idTaque.insert(s)
  end
  method String()
    return self$idTaque.String() || ((\self.varg & "[]") | "")
  end
initially
  self.punc := ","
end

#
# Idol class field lists in which fields may be preceded by a "public" keyword
#
class classFields : argList(publics)
  method String(s)
    if *(rv := self$argList.String()) = 0 then return ""
    if /s | (s ~== "class") then return rv
    if self$ispublic(self.l[1]) then rv := "public "||rv
    every field:=self$foreachpublic() do rv[find(","||field,rv)] ||:= "public "
    return rv
  end
  method foreachpublic()
    if \self.publics then every suspend !self.publics
  end
  method ispublic(s)
    if \self.publics then every suspend !self.publics == s
  end
  method insert(s)
    s ? {
      if ="public" & tab(many(white)) then {
    s := tab(0)
    /self.publics := []
    put(self.publics,s)
      }
    }
    self$argList.insert(s)
  end
initially
  self.punc := ","
end

#
# tell whether the character following s is within a quote or not
#
procedure notquote(s)
  quotes := 0
  outs := ""
  # this is a bug for people who write code like \"hello"...
  s ? {
    while outs ||:= tab(find("\\")+1) do { move(1) }
    outs ||:= tab(0)
  }
  s := outs
  outs := ""
  s ? {
    while outs ||:= tab(find("\""|"'")+1) do {
    quotes +:= 1
    if tab(find(outs[-1])) then {
        quotes +:= 1
        move(1)
    }
    }
  }
  if quotes % 2 = 0 then return
end

#
# filter the input translating $ references
# (also eats comments and trims lines)
#
procedure readln()
    count := 0
    if line := read(fin) then {
    fLine +:= 1
    line[ 1(x<-find("#",line),notquote(line[1:x])) : 0] := ""
    line := trim(line)
    while ((x := find("$",line)) & notquote(line[1:x])) do {
        z := line[x+1:0] ||" "         # " " is for bal()
        if find(line[x+1],"!*@?") then { # Invocation operators $! $* $@ $?
        z ? {
            move(1)
            tab(many(white))
            if not (id := tab(many(alphadot))) then {
              if not match("(") then halt("readline can't parse ",line)
              if not (id := tab(&pos<bal())) then
              halt("readline: cant bal ",&subject)
            }
            case line[x+1] of {
            "@": Op := "activate"
            "*": Op := "size"
            "!": Op := "foreach"
            "?": Op := "random"
            default: halt("readline: unknown operator $",line[x+1])
            }
            count +:= 1
            line[x:0] :=
            "(__self"||count||" := "||id||").__methods."||
            Op||"(__self"||count||".__state)"||tab(0)
        }
        } else {
        reverse(line[1:x])||" " ? {
            tab(many(white))
            if not (id := reverse(tab(many(alphadot)))) then {
              if not match(")") then halt("readline: can't parse")
              if not (id := reverse(tab(&pos<bal(&cset,')','('))))
            then halt("readline: can't bal ",&subject)
            }
            nummatched := &pos-1
        }
        if not (lp := find("(",z)) then halt("readline: expected '('")
        if z[lp+1] ~== ")" then c:="," else c:=""
        count +:= 1
        line[x-nummatched : x+lp+1] :=
          "(__self"||count||" := "||id||").__methods."||
            z[1:lp+1]||"__self"||count||".__state"||c
        }
    }
    return line


    } else fail
end

#
# procedure to read a single Idol source file
#
procedure readinput(name,phase)
    if \loud then write("\t",name)
    fName := name
    fLine := 0
    fin   := sysopen(name,"r")
    while line := readln() do {
    line ? {
        tab(many(white))
        if ="class" then {
        decl := class()
        decl$read(line,phase)
        if phase=1 then {
            decl$writemethods()
            classes$insert(decl,decl$name())
        } else classes$insert_t(decl,decl$name())
        }
        else if ="procedure" then {
        if comp = 0 then comp := 1
        decl := method("")
        decl$read(line,phase)
        decl$write(fout,"")
        }
        else if ="record" then {
        if comp = 0 then comp := 1
        decl := declaration(line)
        decl$write(fout,"")
        }
        else if ="global" then {
        if comp = 0 then comp := 1
        decl := Global(line)
        decl$write(fout,"")
        }
        else if ="method" then {
        halt("readinput: method outside class")
        }
    }
    }
    close(fin)
end

#
# error/warning/message handling
#
procedure halt(args[])
  errsrc()
  every writes(&errout,!args)
  stop()
end

procedure warn(args[])
  errsrc()
  every writes(&errout,!args)
  write(&errout)
end

procedure errsrc()
  writes(&errout,"\"",\fName,"\", line ",\fLine,": Idol/")
end
#
# System-independent, but system related routines
#
procedure tryopen(file,mode)
  if f := open(file,mode) then return close(f)
end
procedure tryenvopen(file,mode)
  return tryopen(envpath(file),mode)
end
procedure sysopen(file,mode)
  if not (f := open(file,mode)) then
      halt("Couldn't open file ",file," for mode ",mode)
  return f
end
procedure envopen(file,mode)
  return sysopen(envpath(file),mode)
end
procedure writelink(s)
  write(fout,"link \"",s,"\"")
end
procedure icont(argstr,prefix)
static s
initial { s := (getenv("ICONT")|"icont") }
  return mysystem(\prefix||s||argstr | s||argstr)
end
##########
idol.man
NAME
    idol - Icon-Derived Object Language

SYNOPSIS
    idol -install
    idol [ option ... ] mainfile otherfiles... [-x arguments]

DESCRIPTION
    Idol is an object-oriented preprocessor for Version 7.5+ Icon.
    It is a front-end for icont(1); typically one invokes idol on
    a source file (extension .iol) which is translated into an
    Icon source file (extension .icn) which is translated into a
    file suitable for interpretation by the Icon interpreter.
    Each directory containing Idol source files should be initialized
    by "idol -install" prior to translating any user sources.
    Producing an executable is skipped when the first file on the
    list contains only classes.

    The following options are recognized by idol:

    -c       Suppress the linking phase
    -t       Suppress all translation by icont
    -s       Suppress removal of .icn files after translation by icont
    -quiet   Suppress most Idol-specific console messages
    -install Install the Idol environment in the current directory
    -strict  Generate code which is paranoid about ensuring encapsulation
    -version Print out the version of Idol and its date of creation

    The second and following files on the command line may include
    extensions .icn, .u1, and .cl.  The first two Idol treats as
    Icon source code which should be translated and linked into the
    resulting executable.  Files with extension .cl are treated as
    class names which are linked into the resulting executable.
    If no extension is given, Idol attempts to find the desired
    source file by appending .iol, .icn, .u1, or .cl in that order.

FILES

   ./prog.iol                     : source file
   ./prog.icn                     : code generated for non-classes in prog.iol
   ./idolcode.env/i_object.*      : Icon code for the universal object type
   ./idolcode.env/classname.icn   : Icon files are generated for each class
   ./idolcode.env/classname.u[12] : translated class files
   ./idolcode.env/classname       : class specification/interface

SEE ALSO

   "Programming in Idol: An Object Primer"
   (U of Arizona Dept of CS Technical Report #90-10)
   serves as user's guide and reference manual for Idol
##########
idolboot.icn
global fin,fout,fName,fLine,alpha,alphadot,white,nonwhite,nonalpha
global classes,comp,exec,strict,links,imports,loud,compiles
procedure initialize()
#line 47 "idol.iol"
  loud     := 1
  comp     := 0
  alpha    := &ucase ++ &lcase ++ '_' ++ &digits
  nonalpha := &cset -- alpha
  alphadot := alpha ++ '.'
  white    := ' \t\014'
  nonwhite := &cset -- white
  classes  := taque()
  links    := []
  imports  := []
  compiles := []
  sysinitialize()
end
procedure main(args)
#line 62 "idol.iol"
    initialize()
    if *args = 0 then write("usage: idol files...")
    else {
      every i := 1 to *args do {
    if \exec then next
    if args[i][1] == "-" then {
      case map(args[i]) of {
        "-c"   : {
        sysok := &null
        if comp = 0 then comp := -1
        }
        "-install": return install(args[1:i+1])
        "-quiet"  : loud := &null
        "-strict" : strict := 1
        "-s"      : sysok := &null
        "-t"      : comp := -2
        "-version": return write("Idol version 6.30 of 3/14/90") & 0
        "-x"      : exec := i
      }
        }
        else if args[i][find(".cl",args[i]):0] := "" then push(imports,args[i])
    else if args[i][find(".icn",args[i]):0] := "" then {
      push(links,args[i])
      icont(" -c "||args[i])
    }
    else if args[i][find(".u1",args[i]):0] := "" then push(links,args[i])
    else if (args[i][find(".iol",args[i]):0] := "") |
        tryopen(args[i]||".iol","r") then {
      /exe := i
      args[i][find(".iol",args[i]):0] := ""
      /fout := sysopen(args[i]||".icn","w")
      readinput(args[i]||".iol",1)
        } else {



      if tryopen(args[i]||".icn","r") then {
        push(links,args[i])
        icont(" -c "||args[i])
      }
      else if tryopen(args[i]||".u1") then push(links,args[i])
      else if tryenvopen(args[i]) then push(imports,args[i])
    }
      }
      gencode()
      close(\fout)
      if comp = 1 then makeexe(args,exe)
    }
end
procedure gencode()
#line 118 "idol.iol"
  if \loud then write("Class import/export:")



  every cl := (__self1 := classes).__methods.foreach_t(__self1.__state) do (__self2 := cl).__methods.writespec(__self2.__state)



  repeat {
    added := 0
    every super:= ((__self2 := ((__self1 := classes).__methods.foreach_t(__self1.__state))).__methods.foreachsuper(__self2.__state) | !imports) do{
      if /(__self1 := classes).__methods.lookup(__self1.__state,super) then {
    added := 1
    fname := filename(super)
    readinput(envpath(fname),2)
    if /(__self1 := classes).__methods.lookup(__self1.__state,super) then halt("can't import class '",super,"'")
    writesublink(fname)
      }
    }
    if added = 0 then break
  }



  every (__self2 := ((__self1 := classes).__methods.foreach_t(__self1.__state))).__methods.transitive_closure(__self2.__state)



  if \loud then write("Generating code:")
  writesublink("i_object")
  every s := !links do writelink(s)
  write(fout)
  every out := (__self1 := classes).__methods.foreach(__self1.__state) do {
    name := filename((__self1 := out).__methods.name(__self1.__state))
    (__self1 := out).__methods.write(__self1.__state)
    put(compiles,name)
    writesublink(name)
  }
  if *compiles>0 then cdicont(compiles)
end
procedure notquote(s)
#line 713 "idol.iol"
  quotes := 0
  outs := ""

  s ? {
    while outs ||:= tab(find("\\")+1) do { move(1) }
    outs ||:= tab(0)
  }
  s := outs
  outs := ""
  s ? {
    while outs ||:= tab(find("\""|"'")+1) do {
    quotes +:= 1
    if tab(find(outs[-1])) then {
        quotes +:= 1
        move(1)
    }
    }
  }
  if quotes % 2 = 0 then return
end
procedure readln()
#line 739 "idol.iol"
    count := 0
    if line := read(fin) then {
    fLine +:= 1
    line[ 1(x<-find("#",line),notquote(line[1:x])) : 0] := ""
    line := trim(line)
    while ((x := find("$",line)) & notquote(line[1:x])) do {
        z := line[x+1:0] ||" "
        if find(line[x+1],"!*@?") then {
        z ? {
            move(1)
            tab(many(white))
            if not (id := tab(many(alphadot))) then {
              if not match("(") then halt("readline can't parse ",line)
              if not (id := tab(&pos<bal())) then
              halt("readline: cant bal ",&subject)
            }
            case line[x+1] of {
            "@": Op := "activate"
            "*": Op := "size"
            "!": Op := "foreach"
            "?": Op := "random"
            default: halt("readline: unknown operator $",line[x+1])
            }
            count +:= 1
            line[x:0] :=
            "(__self"||count||" := "||id||").__methods."||
            Op||"(__self"||count||".__state)"||tab(0)
        }
        } else {
        reverse(line[1:x])||" " ? {
            tab(many(white))
            if not (id := reverse(tab(many(alphadot)))) then {
              if not match(")") then halt("readline: can't parse")
              if not (id := reverse(tab(&pos<bal(&cset,')','('))))
            then halt("readline: can't bal ",&subject)
            }
            nummatched := &pos-1
        }
        if not (lp := find("(",z)) then halt("readline: expected '('")
        if z[lp+1] ~== ")" then c:="," else c:=""
        count +:= 1
        line[x-nummatched : x+lp+1] :=
          "(__self"||count||" := "||id||").__methods."||
            z[1:lp+1]||"__self"||count||".__state"||c
        }
    }
    return line


    } else fail
end
procedure readinput(name,phase)
#line 795 "idol.iol"
    if \loud then write("\t",name)
    fName := name
    fLine := 0
    fin   := sysopen(name,"r")
    while line := readln() do {
    line ? {
        tab(many(white))
        if ="class" then {
        decl := class()
        (__self1 := decl).__methods.read(__self1.__state,line,phase)
        if phase=1 then {
            (__self1 := decl).__methods.writemethods(__self1.__state)
            (__self1 := classes).__methods.insert(__self1.__state,decl,(__self2 := decl).__methods.name(__self2.__state))
        } else (__self1 := classes).__methods.insert_t(__self1.__state,decl,(__self2 := decl).__methods.name(__self2.__state))
        }
        else if ="procedure" then {
        if comp = 0 then comp := 1
        decl := method("")
        (__self1 := decl).__methods.read(__self1.__state,line,phase)
        (__self1 := decl).__methods.write(__self1.__state,fout,"")
        }
        else if ="record" then {
        if comp = 0 then comp := 1
        decl := declaration(line)
        (__self1 := decl).__methods.write(__self1.__state,fout,"")
        }
        else if ="global" then {
        if comp = 0 then comp := 1
        decl := Global(line)
        (__self1 := decl).__methods.write(__self1.__state,fout,"")
        }
        else if ="method" then {
        halt("readinput: method outside class")
        }
    }
    }
    close(fin)
end
procedure halt(args[])
#line 838 "idol.iol"
  errsrc()
  every writes(&errout,!args)
  stop()
end
procedure warn(args[])
#line 844 "idol.iol"
  errsrc()
  every writes(&errout,!args)
  write(&errout)
end
procedure errsrc()
#line 850 "idol.iol"
  writes(&errout,"\"",\fName,"\", line ",\fLine,": Idol/")
end
procedure tryopen(file,mode)
#line 856 "idol.iol"
  if f := open(file,mode) then return close(f)
end
procedure tryenvopen(file,mode)
#line 859 "idol.iol"
  return tryopen(envpath(file),mode)
end
procedure sysopen(file,mode)
#line 862 "idol.iol"
  if not (f := open(file,mode)) then
      halt("Couldn't open file ",file," for mode ",mode)
  return f
end
procedure envopen(file,mode)
#line 867 "idol.iol"
  return sysopen(envpath(file),mode)
end
procedure writelink(s)
#line 870 "idol.iol"
  write(fout,"link \"",s,"\"")
end
procedure icont(argstr,prefix)
#line 873 "idol.iol"
static s
initial { s := (getenv("ICONT")|"icont") }
  return mysystem(\prefix||s||argstr | s||argstr)
end
record idol_object(__state,__methods)

procedure declarationread(self,decl)
#line 169 "idol.iol"
    decl ? {

      tab(many(white))
      if not (self.tag := =("procedure"|"class"|"method"|"record")) then
    halt("declaration/read can't parse decl ",decl)
      tab(many(white))

      if not (self.name := tab(many(alpha))) then
    halt("declaration/read can't parse decl ",decl)

      if not tab(find("(")+1) then
      halt("declaration/read can't parse decl ",decl)
      tab(many(white))
      self.fields := classFields()
      if not ((__self1 := self.fields).__methods.parse(__self1.__state,tab(find(")")))) then
    halt("declaration/read can't parse decl ",decl)
    }
  end
procedure declarationwrite(self,f)
#line 192 "idol.iol"
     write(f,(__self1 := self).__methods.String(__self1.__state))
  end
procedure declarationString(self)
#line 198 "idol.iol"
    return self.tag || " " || self.name || "(" || (__self1 := self.fields).__methods.String(__self1.__state) || ")"
  end
record declaration_state(__state,__methods,name,fields,tag)
record declaration_methods(read,write,String,name)
global declaration__oprec
procedure declaration(name,fields,tag)
local self,clone
initial {
  if /declaration__oprec then declarationinitialize()
  }
  self := declaration_state(&null,declaration__oprec,name,fields,tag)
  self.__state := self
  declarationinitially(self)
  return idol_object(self,declaration__oprec)
end

procedure declarationinitialize()
  initial declaration__oprec := declaration_methods(declarationread,declarationwrite,declarationString,declarationname)
end
procedure declarationinitially(self)
#line 201 "idol.iol"
  if \self.name then (__self1 := self).__methods.read(__self1.__state,self.name)
end
procedure declarationname(self)
  return .(self.name)
end

procedure bodyread(self)
#line 210 "idol.iol"
    self.fn    := fName
    self.ln    := fLine
    self.text  := []
    while line := readln() do {
      put(self.text, line)
      line ? { tab(many(white)); if ="end" & &pos > *line then return }
    }
    halt("body/read: eof inside a procedure/method definition")
  end
procedure bodywrite(self,f)
#line 220 "idol.iol"
    if \self.ln then write(f,"#line ",self.ln," \"",self.fn,"\"")
    every write(f,(__self1 := self).__methods.foreach(__self1.__state))
  end
procedure bodydelete(self)
#line 224 "idol.iol"
    return pull(self.text)
  end
procedure bodysize(self)
#line 227 "idol.iol"
    return (*\ (self.text)) | 0
  end
procedure bodyforeach(self)
#line 230 "idol.iol"
    if t := \self.text then suspend !self.text
  end
record body_state(__state,__methods,fn,ln,text)
record body_methods(read,write,delete,size,foreach)
global body__oprec
procedure body(fn,ln,text)
local self,clone
initial {
  if /body__oprec then bodyinitialize()
  }
  self := body_state(&null,body__oprec,fn,ln,text)
  self.__state := self
  return idol_object(self,body__oprec)
end

procedure bodyinitialize()
  initial body__oprec := body_methods(bodyread,bodywrite,bodydelete,bodysize,bodyforeach)
end
procedure classread(self,line,phase)
#line 242 "idol.iol"
    (__self1 := self).__methods.declaration.read(__self1.__state,line)
    self.supers := idTaque(":")
    (__self1 := self.supers).__methods.parse(__self1.__state,line[find(":",line)+1:find("(",line)] | "")
    self.methods:= taque()
    self.text   := body()
    while line  := readln() do {
      line ? {
    tab(many(white))
    if ="initially" then {
        (__self1 := self.text).__methods.read(__self1.__state)
        if phase=2 then return
        (__self1 := self.text).__methods.delete(__self1.__state)

        return
    } else if ="method" then {
        decl := method(self.name)
        (__self1 := decl).__methods.read(__self1.__state,line,phase)
        (__self1 := self.methods).__methods.insert(__self1.__state,decl,(__self2 := decl).__methods.name(__self2.__state))
    } else if ="end" then {

        return
    } else if ="procedure" then {
        decl := Procedure("")
        (__self1 := decl).__methods.read(__self1.__state,line,phase)
        /self.glob := []
        put(self.glob,decl)
    } else if ="global" then {
        /self.glob := []
        put(self.glob,Global(line))
    } else if ="record" then {
        /self.glob := []
        put(self.glob,declaration(line))
    } else if upto(nonwhite) then {
        halt("class/read expected declaration on: ",line)
    }
      }
    }
    halt("class/read syntax error: eof inside a class definition")
  end
procedure classhas_initially(self)
#line 286 "idol.iol"
    return (__self1 := self.text).__methods.size(__self1.__state) > 0
  end
procedure classispublic(self,fieldname)
#line 289 "idol.iol"
    if (__self1 := self.fields).__methods.ispublic(__self1.__state,fieldname) then return fieldname
  end
procedure classforeachmethod(self)
#line 292 "idol.iol"
    suspend (__self1 := self.methods).__methods.foreach(__self1.__state)
  end
procedure classforeachsuper(self)
#line 295 "idol.iol"
    suspend (__self1 := self.supers).__methods.foreach(__self1.__state)
  end
procedure classforeachfield(self)
#line 298 "idol.iol"
    suspend (__self1 := self.fields).__methods.foreach(__self1.__state)
  end
procedure classtransitive_closure(self)
#line 301 "idol.iol"
    count := (__self1 := self.supers).__methods.size(__self1.__state)
    while count > 0 do {
    added := taque()
    every sc := (__self1 := self.supers).__methods.foreach(__self1.__state) do {
      if /(super := (__self1 := classes).__methods.lookup(__self1.__state,sc)) then
        halt("class/transitive_closure: couldn't find superclass ",sc)
      every supersuper := (__self1 := super).__methods.foreachsuper(__self1.__state) do {
        if / (__self1 := self.supers).__methods.lookup(__self1.__state,supersuper) &
         /(__self1 := added).__methods.lookup(__self1.__state,supersuper) then {
          (__self1 := added).__methods.insert(__self1.__state,supersuper)
        }
      }
    }
    count := (__self1 := added).__methods.size(__self1.__state)
    every (__self1 := self.supers).__methods.insert(__self1.__state,(__self2 := added).__methods.foreach(__self2.__state))
    }
  end
procedure classwritedecl(self,f,s)
#line 323 "idol.iol"
    writes(f, s," ",self.name)
    if s=="class" & ( *(supers := (__self1 := self.supers).__methods.String(__self1.__state)) > 0 ) then
        writes(f," : ",supers)
    writes(f,"(")
    rv := (__self1 := self.fields).__methods.String(__self1.__state,s)
    if *rv > 0 then rv ||:= ","
    if s~=="class" & \self.ifields then
      every l := !self.ifields do rv ||:= l.ident || ","
    writes(f,rv[1:-1])
    write(f,,")")
  end
procedure classwritespec(self,f)
#line 335 "idol.iol"
    f := envopen(filename(self.name),"w")
    (__self1 := self).__methods.writedecl(__self1.__state,f,"class")
    every (__self2 := ((__self1 := self.methods).__methods.foreach(__self1.__state))).__methods.writedecl(__self2.__state,f,"method")
    if (__self1 := self).__methods.has_initially(__self1.__state) then write(f,"initially")
    write(f,"end")
    close(f)
  end
procedure classwritemethods(self)
#line 348 "idol.iol"
    f:= envopen(filename(self.name)||".icn","w")
    every (__self2 := ((__self1 := self.methods).__methods.foreach(__self1.__state))).__methods.write(__self2.__state,f,self.name)

    if \self.glob & *self.glob>0 then {
    write(f,"#\n# globals declared within the class\n#")
    every i := 1 to *self.glob do (__self1 := (self.glob[i])).__methods.write(__self1.__state,f,"")
    }
    close(f)
  end
procedure classwrite(self)
#line 362 "idol.iol"
    f:= envopen(filename(self.name)||".icn","a")



    if /self.ifields then (__self1 := self).__methods.resolve(__self1.__state)




    writes(f,"record ",self.name,"_state(__state,__methods")
    rv := ","
    rv ||:= (__self1 := self.fields).__methods.idTaque.String(__self1.__state)
    if rv[-1] ~== "," then rv ||:= ","
    every s := (!self.ifields).ident do rv ||:= s || ","
    write(f,rv[1:-1],")")




    writes(f,"record ",self.name,"_methods(")
    rv := ""

    every s := (((__self2 := ((__self1 := self.methods).__methods.foreach(__self1.__state))).__methods.name(__self2.__state))    |
        (__self1 := self.fields).__methods.foreachpublic(__self1.__state)    |
        (!self.imethods).ident        |
        (__self1 := self.supers).__methods.foreach(__self1.__state))
    do rv ||:= s || ","

    if *rv>0 then rv[-1] := ""
    write(f,rv,")")





    writes(f,"global ",self.name,"__oprec")
    every writes(f,", ", (__self1 := self.supers).__methods.foreach(__self1.__state),"__oprec")
    write(f)





    (__self1 := self).__methods.writedecl(__self1.__state,f,"procedure")
    write(f,"local self,clone")




    write(f,"initial {\n",
        "  if /",self.name,"__oprec then ",self.name,"initialize()")
    if (__self1 := self.supers).__methods.size(__self1.__state) > 0 then
    every (super <- (__self1 := self.supers).__methods.foreach(__self1.__state)) ~== self.name do
        write(f,"  if /",super,"__oprec then ",super,"initialize()\n",
            "  ",self.name,"__oprec.",super," := ", super,"__oprec")
    write(f,"  }")




    writes(f,"  self := ",self.name,"_state(&null,",self.name,"__oprec")
    every writes(f,",",(__self1 := self.fields).__methods.foreach(__self1.__state))
    if \self.ifields then every writes(f,",",(!self.ifields).ident)
    write(f,")\n  self.__state := self")




    if (__self1 := self.text).__methods.size(__self1.__state) > 0 then write(f,"  ",self.name,"initially(self)")




    if (__self1 := self.supers).__methods.size(__self1.__state) > 0 then {
    every (super <- (__self1 := self.supers).__methods.foreach(__self1.__state)) ~== self.name do {
        if (__self2 := ((__self1 := classes).__methods.lookup(__self1.__state,super))).__methods.has_initially(__self2.__state) then {
        if /madeclone := 1 then {
            write(f,"  clone := ",self.name,"_state()\n",
            "  clone.__state := clone\n",
            "  clone.__methods := ",self.name,"__oprec")
        }
        write(f,"  # inherited initialization from class ",super)
        write(f,"    every i := 2 to *self do clone[i] := self[i]\n",
            "    ",super,"initially(clone)")
        every l := !self.ifields do {
            if l.class == super then
            write(f,"    self.",l.ident," := clone.",l.ident)
        }
        }
    }
    }






    write(f,"  return idol_object(self,",self.name,"__oprec)\n",
        "end\n")




    write(f,"procedure ",self.name,"initialize()")
    writes(f,"  initial ",self.name,"__oprec := ",self.name,"_methods")
    rv := "("
    every s := (__self2 := ((__self1 := self.methods).__methods.foreach(__self1.__state))).__methods.name(__self2.__state) do {
      if *rv>1 then rv ||:= ","
      rv ||:= self.name||s
    }
    every me := (__self1 := self.fields).__methods.foreachpublic(__self1.__state) do {
      if *rv>1 then rv ||:= ","
      rv ||:= self.name||me
    }
    every l := !self.imethods do {
      if *rv>1 then rv ||:= ","
      rv ||:= l.class||l.ident
    }
    write(f,rv,")\n","end")



    if (__self1 := self).__methods.has_initially(__self1.__state) then {
    write(f,"procedure ",self.name,"initially(self)")
    (__self1 := self.text).__methods.write(__self1.__state,f)
    write(f,"end")
    }




    every me := (__self1 := self.fields).__methods.foreachpublic(__self1.__state) do {
      write(f,"procedure ",self.name,me,"(self)")
      if \strict then {
    write(f,"  if type(self.",me,") == ",
        "(\"list\"|\"table\"|\"set\"|\"record\") then\n",
        "    runerr(501,\"idol: scalar type expected\")")
    }
      write(f,"  return .(self.",me,")")
      write(f,"end")
      write(f)
    }

    close(f)

  end
procedure classresolve(self)
#line 513 "idol.iol"



    self.imethods := []
    self.ifields := []
    ipublics := []
    addedfields := table()
    addedmethods := table()
    every sc := (__self1 := self.supers).__methods.foreach(__self1.__state) do {
    if /(superclass := (__self1 := classes).__methods.lookup(__self1.__state,sc)) then
        halt("class/resolve: couldn't find superclass ",sc)
    every superclassfield := (__self1 := superclass).__methods.foreachfield(__self1.__state) do {
        if /(__self1 := self.fields).__methods.lookup(__self1.__state,superclassfield) &
           /addedfields[superclassfield] then {
        addedfields[superclassfield] := superclassfield
        put ( self.ifields , classident(sc,superclassfield) )
        if (__self1 := superclass).__methods.ispublic(__self1.__state,superclassfield) then
            put( ipublics, classident(sc,superclassfield) )
        } else if \strict then {
        warn("class/resolve: '",sc,"' field '",superclassfield,
             "' is redeclared in subclass ",self.name)
        }
    }
    every superclassmethod := (__self2 := ((__self1 := superclass).__methods.foreachmethod(__self1.__state))).__methods.name(__self2.__state) do {
        if /(__self1 := self.methods).__methods.lookup(__self1.__state,superclassmethod) &
           /addedmethods[superclassmethod] then {
        addedmethods[superclassmethod] := superclassmethod
        put ( self.imethods, classident(sc,superclassmethod) )
        }
    }
    every public := (!ipublics) do {
        if public.class == sc then
        put (self.imethods, classident(sc,public.ident))
    }
    }
  end
#
# globals declared within the class
#
record classident(class,ident)
record class_state(__state,__methods,supers,methods,text,imethods,ifields,glob,name,fields,tag)
record class_methods(read,has_initially,ispublic,foreachmethod,foreachsuper,foreachfield,transitive_closure,writedecl,writespec,writemethods,write,resolve,String,name,declaration)
global class__oprec, declaration__oprec
procedure class(supers,methods,text,imethods,ifields,glob,name,fields,tag)
local self,clone
initial {
  if /class__oprec then classinitialize()
  if /declaration__oprec then declarationinitialize()
  class__oprec.declaration := declaration__oprec
  }
  self := class_state(&null,class__oprec,supers,methods,text,imethods,ifields,glob,name,fields,tag)
  self.__state := self
  clone := class_state()
  clone.__state := clone
  clone.__methods := class__oprec
  # inherited initialization from class declaration
    every i := 2 to *self do clone[i] := self[i]
    declarationinitially(clone)
    self.name := clone.name
    self.fields := clone.fields
    self.tag := clone.tag
  return idol_object(self,class__oprec)
end

procedure classinitialize()
  initial class__oprec := class_methods(classread,classhas_initially,classispublic,classforeachmethod,classforeachsuper,classforeachfield,classtransitive_closure,classwritedecl,classwritespec,classwritemethods,classwrite,classresolve,declarationString,declarationname)
end
procedure methodread(self,line,phase)
#line 556 "idol.iol"
    (__self1 := self).__methods.declaration.read(__self1.__state,line)
    self.text := body()
    if phase = 1 then
      (__self1 := self.text).__methods.read(__self1.__state)
  end
procedure methodwritedecl(self,f,s)
#line 562 "idol.iol"
    decl := (__self1 := self).__methods.String(__self1.__state)
    if s == "method" then decl[1:upto(white,decl)] := "method"
    else {
    decl[1:upto(white,decl)] := "procedure"
    decl[upto(white,decl)] ||:= self.class
    if *self.class ~= 0 then {
        i := find("(",decl)
        decl[i] ||:= "self" || (((decl[i+1] ~== ")"), ",") | "")
    }
    }
    write(f,decl)
  end
procedure methodwrite(self,f)
#line 575 "idol.iol"
    if self.name ~== "initially" then
    (__self1 := self).__methods.writedecl(__self1.__state,f,"procedure")
    (__self1 := self.text).__methods.write(__self1.__state,f)
    self.text := &null
  end
record method_state(__state,__methods,class,text,name,fields,tag)
record method_methods(read,writedecl,write,String,name,declaration)
global method__oprec, declaration__oprec
procedure method(class,text,name,fields,tag)
local self,clone
initial {
  if /method__oprec then methodinitialize()
  if /declaration__oprec then declarationinitialize()
  method__oprec.declaration := declaration__oprec
  }
  self := method_state(&null,method__oprec,class,text,name,fields,tag)
  self.__state := self
  clone := method_state()
  clone.__state := clone
  clone.__methods := method__oprec
  # inherited initialization from class declaration
    every i := 2 to *self do clone[i] := self[i]
    declarationinitially(clone)
    self.name := clone.name
    self.fields := clone.fields
    self.tag := clone.tag
  return idol_object(self,method__oprec)
end

procedure methodinitialize()
  initial method__oprec := method_methods(methodread,methodwritedecl,methodwrite,declarationString,declarationname)
end
procedure Globalwrite(self,f)
#line 587 "idol.iol"
    write(f,self.s)
  end
record Global_state(__state,__methods,s)
record Global_methods(write)
global Global__oprec
procedure Global(s)
local self,clone
initial {
  if /Global__oprec then Globalinitialize()
  }
  self := Global_state(&null,Global__oprec,s)
  self.__state := self
  return idol_object(self,Global__oprec)
end

procedure Globalinitialize()
  initial Global__oprec := Global_methods(Globalwrite)
end
procedure Tablesize(self)
#line 596 "idol.iol"
    return (* \ self.t) | 0
  end
procedure Tableinsert(self,x,key)
#line 599 "idol.iol"
    /self.t := table()
    /key := x
    if / (self.t[key]) := x then return
  end
procedure Tablelookup(self,key)
#line 604 "idol.iol"
    if t := \self.t then return t[key]
    return
  end
procedure Tableforeach(self)
#line 608 "idol.iol"
    if t := \self.t then every suspend !self.t
  end
record Table_state(__state,__methods,t)
record Table_methods(size,insert,lookup,foreach)
global Table__oprec
procedure Table(t)
local self,clone
initial {
  if /Table__oprec then Tableinitialize()
  }
  self := Table_state(&null,Table__oprec,t)
  self.__state := self
  return idol_object(self,Table__oprec)
end

procedure Tableinitialize()
  initial Table__oprec := Table_methods(Tablesize,Tableinsert,Tablelookup,Tableforeach)
end
procedure taqueinsert(self,x,key)
#line 619 "idol.iol"
    /self.l := []
    if (__self1 := self).__methods.Table.insert(__self1.__state,x,key) then put(self.l,x)
  end
procedure taqueforeach(self)
#line 623 "idol.iol"
    if l := \self.l then every suspend !self.l
  end
procedure taqueinsert_t(self,x,key)
#line 626 "idol.iol"
    (__self1 := self).__methods.Table.insert(__self1.__state,x,key)
  end
procedure taqueforeach_t(self)
#line 629 "idol.iol"
    suspend (__self1 := self).__methods.Table.foreach(__self1.__state)
  end
record taque_state(__state,__methods,l,t)
record taque_methods(insert,foreach,insert_t,foreach_t,size,lookup,Table)
global taque__oprec, Table__oprec
procedure taque(l,t)
local self,clone
initial {
  if /taque__oprec then taqueinitialize()
  if /Table__oprec then Tableinitialize()
  taque__oprec.Table := Table__oprec
  }
  self := taque_state(&null,taque__oprec,l,t)
  self.__state := self
  return idol_object(self,taque__oprec)
end

procedure taqueinitialize()
  initial taque__oprec := taque_methods(taqueinsert,taqueforeach,taqueinsert_t,taqueforeach_t,Tablesize,Tablelookup)
end
procedure idTaqueparse(self,s)
#line 639 "idol.iol"
    s ? {
      tab(many(white))
      while name := tab(find(self.punc)) do {
    (__self1 := self).__methods.insert(__self1.__state,trim(name))
    move(1)
    tab(many(white))
      }
      if any(nonwhite) then (__self1 := self).__methods.insert(__self1.__state,trim(tab(0)))
    }
    return
  end
procedure idTaqueString(self)
#line 651 "idol.iol"
    if /self.l then return ""
    out := ""
    every id := !self.l do out ||:= id||self.punc
    return out[1:-1]
  end
record idTaque_state(__state,__methods,punc,l,t)
record idTaque_methods(parse,String,insert,foreach,insert_t,foreach_t,size,lookup,taque,Table)
global idTaque__oprec, taque__oprec, Table__oprec
procedure idTaque(punc,l,t)
local self,clone
initial {
  if /idTaque__oprec then idTaqueinitialize()
  if /taque__oprec then taqueinitialize()
  idTaque__oprec.taque := taque__oprec
  if /Table__oprec then Tableinitialize()
  idTaque__oprec.Table := Table__oprec
  }
  self := idTaque_state(&null,idTaque__oprec,punc,l,t)
  self.__state := self
  return idol_object(self,idTaque__oprec)
end

procedure idTaqueinitialize()
  initial idTaque__oprec := idTaque_methods(idTaqueparse,idTaqueString,taqueinsert,taqueforeach,taqueinsert_t,taqueforeach_t,Tablesize,Tablelookup)
end
procedure argListinsert(self,s)
#line 663 "idol.iol"
    if \self.varg then halt("variable arg must be final")
    if i := find("[",s) then {
      if not (j := find("]",s)) then halt("variable arg expected ]")
      s[i : j+1] := ""
      self.varg := s := trim(s)
    }
    (__self1 := self).__methods.idTaque.insert(__self1.__state,s)
  end
procedure argListString(self)
#line 672 "idol.iol"
    return (__self1 := self).__methods.idTaque.String(__self1.__state) || ((\self.varg & "[]") | "")
  end
record argList_state(__state,__methods,varg,punc,l,t)
record argList_methods(insert,String,varg,parse,foreach,insert_t,foreach_t,size,lookup,idTaque,taque,Table)
global argList__oprec, idTaque__oprec, taque__oprec, Table__oprec
procedure argList(varg,punc,l,t)
local self,clone
initial {
  if /argList__oprec then argListinitialize()
  if /idTaque__oprec then idTaqueinitialize()
  argList__oprec.idTaque := idTaque__oprec
  if /taque__oprec then taqueinitialize()
  argList__oprec.taque := taque__oprec
  if /Table__oprec then Tableinitialize()
  argList__oprec.Table := Table__oprec
  }
  self := argList_state(&null,argList__oprec,varg,punc,l,t)
  self.__state := self
  argListinitially(self)
  return idol_object(self,argList__oprec)
end

procedure argListinitialize()
  initial argList__oprec := argList_methods(argListinsert,argListString,argListvarg,idTaqueparse,taqueforeach,taqueinsert_t,taqueforeach_t,Tablesize,Tablelookup)
end
procedure argListinitially(self)
#line 675 "idol.iol"
  self.punc := ","
end
procedure argListvarg(self)
  return .(self.varg)
end

procedure classFieldsString(self,s)
#line 683 "idol.iol"
    if *(rv := (__self1 := self).__methods.argList.String(__self1.__state)) = 0 then return ""
    if /s | (s ~== "class") then return rv
    if (__self1 := self).__methods.ispublic(__self1.__state,self.l[1]) then rv := "public "||rv
    every field:=(__self1 := self).__methods.foreachpublic(__self1.__state) do rv[find(","||field,rv)] ||:= "public "
    return rv
  end
procedure classFieldsforeachpublic(self)
#line 690 "idol.iol"
    if \self.publics then every suspend !self.publics
  end
procedure classFieldsispublic(self,s)
#line 693 "idol.iol"
    if \self.publics then every suspend !self.publics == s
  end
procedure classFieldsinsert(self,s)
#line 696 "idol.iol"
    s ? {
      if ="public" & tab(many(white)) then {
    s := tab(0)
    /self.publics := []
    put(self.publics,s)
      }
    }
    (__self1 := self).__methods.argList.insert(__self1.__state,s)
  end
record classFields_state(__state,__methods,publics,varg,punc,l,t)
record classFields_methods(String,foreachpublic,ispublic,insert,varg,parse,foreach,insert_t,foreach_t,size,lookup,argList,idTaque,taque,Table)
global classFields__oprec, argList__oprec, idTaque__oprec, taque__oprec, Table__oprec
procedure classFields(publics,varg,punc,l,t)
local self,clone
initial {
  if /classFields__oprec then classFieldsinitialize()
  if /argList__oprec then argListinitialize()
  classFields__oprec.argList := argList__oprec
  if /idTaque__oprec then idTaqueinitialize()
  classFields__oprec.idTaque := idTaque__oprec
  if /taque__oprec then taqueinitialize()
  classFields__oprec.taque := taque__oprec
  if /Table__oprec then Tableinitialize()
  classFields__oprec.Table := Table__oprec
  }
  self := classFields_state(&null,classFields__oprec,publics,varg,punc,l,t)
  self.__state := self
  classFieldsinitially(self)
  clone := classFields_state()
  clone.__state := clone
  clone.__methods := classFields__oprec
  # inherited initialization from class argList
    every i := 2 to *self do clone[i] := self[i]
    argListinitially(clone)
    self.varg := clone.varg
  return idol_object(self,classFields__oprec)
end

procedure classFieldsinitialize()
  initial classFields__oprec := classFields_methods(classFieldsString,classFieldsforeachpublic,classFieldsispublic,classFieldsinsert,argListvarg,idTaqueparse,taqueforeach,taqueinsert_t,taqueforeach_t,Tablesize,Tablelookup)
end
procedure classFieldsinitially(self)
#line 706 "idol.iol"
  self.punc := ","
end
##########
install.bat
rem msdos Idol installation
rem This compiles Idol in order to to test the system
icont -Sr1000 -SF30 -Si1000 idolboot msdos
mkdir idolcode.env
iconx idolboot -t -install
chdir idolcode.env
icont -c i_object
chdir ..
iconx idolboot idol msdos.icn
idolt
##########
inverse.iol
class inverse:fraction(d)
initially
  self.n := 1
end

procedure main()
  x := inverse(2)
  y := fraction(3,4)
  z := x$times(y)
  write("The decimal equivalent of ",z$asString(),
    " is ",trim(z$asReal(),'0'))
end
##########
itags.iol
# itags - an Icon/Idol tag generator by Nick Kline
# hacks (such as this header comment) by Clint Jeffery
# last edit: 12/13/89
#
# the output is a sorted list of lines of the form
# identifier  owning_scope  category_type  filename  lineno(:length)
#
# owning scope is the name of the class or procedure or record in which
# the tag is defined.
# category type is the kind of tag; one of:
# (global,procedure,record,class,method,param,obj_field,rec_field)
#
procedure main(args)
local line, lineno, fout, i, fin, notvar, objects, actual_file, outlines

initial {
    fout := open("ITAGS", "w") | stop("can't open ITAGS for writing");
    outlines := [[0,0,0,0,0,0]]
    i := 1
    notid := &cset -- &ucase -- &digits -- &lcase -- '_'
}

if(*args=0) then
    stop("usage: itags file1 [file2 ...]")

while i <= *args do {
    fin := open(args[i],"r") |
    stop("could not open file ",args[i]," exiting")
    lineno := 1
    objects := program( args[i] )

    while line := read(fin) do {
    line[upto('#',line):0] := ""
    line ? {
        tab(many(' '))

        if =("global") then {
        if(any(notid)) then
            every objects$addvar( getword(), lineno )
        }

        if =("procedure")  then
          if(any(notid)) then {
            objects$addproc( getword(), lineno )
            objects$myline(tab(0),lineno)
        }


        if =("class") then
        if any(notid) then {
            objects$addclass( getword(), lineno )
            objects$myline(tab(0),lineno)
        }


        if =("method") then {
        if any(notid) then {
            objects$addmethod( getword(), lineno )
            objects$myline(tab(0),lineno)
        }
        }

        if =("local") then {
        if any(notid) then
            every objects$addvar( getword(), lineno )
        }

        if =("static") then {
        if any(notid) then
            every objects$addstat( getword(), lineno )
        }

        if =("record") then {
        if any(notid) then {
            objects$addrec( getword(), lineno )
            objects$myline(tab(0),lineno)
            objects$endline( lineno)
        }
        }
        if =("end") then
        objects$endline(lineno)
    }
    lineno +:= 1
    }
    objects$drawthyself(outlines)
    i +:= 1
}
# now process all the resulting lines
every i := 2 to *outlines do {
    outlines[i] := (
    left(outlines[i][1],outlines[1][1]+1) ||
    left(outlines[i][2],outlines[1][2]+1) ||
    left(outlines[i][3],outlines[1][3]+1) ||
    left(outlines[i][4],outlines[1][4]+1) ||
    left(outlines[i][5],outlines[1][5]) ||
    (if \outlines[i][6] then ":"||outlines[i][6] else ""))
}
outlines := outlines[2:0]
outlines := sort(outlines)
every write(fout,!outlines)
end

class functions(name, lineno,vars,lastline, parent, params,stat,paramtype)

method drawthyself(outfile)
local k
    every k := !self.vars do
      emit(outfile, k[1], self.name, "local", self.parent$myfile(),k[2])
    every k := !self.params do
      emit(outfile, k[1], self.name, self.paramtype, self.parent$myfile(),k[2])
    every k := !self.stat do
      emit(outfile, k[1], self.name, "static", self.parent$myfile(),k[2])
end

method myline(line,lineno)
local word
static ids,  letters
initial {
    ids := &lcase ++ &ucase ++ &digits ++ '_'
    letters := &ucase ++ &lcase
}

line ? while tab(upto(letters)) do  {
    word := tab(many(ids))
    self.params|||:= [[word,lineno]]
}

end

method addstat(varname, lineno)
    self.stat|||:=[[varname, lineno]]
    return
end

method addvar(varname, lineno)
    self.vars|||:=[[varname, lineno]]
    return
end

method endline( lineno )
   self.lastline := lineno
end

method resetcontext()
    self.parent$resetcontext()
end

initially
    self.vars := []
    self.params := []
    self.stat := []
end # end of class functions


class proc : functions(name,lineno, parent,paramtype)

method drawthyself(outfile)
    emit(outfile,self.name, "*" , "procedure", self.parent$myfile(),self.lineno, self.lastline-self.lineno+1)
    self$functions.drawthyself(outfile)
end
initially
 self.paramtype := "param"
end # of class proc

class rec : functions(name, lineno, parent, line, paramtype)

method drawthyself(outfile)
    emit(outfile,self.name, "*", "record", self.parent$myfile(),
     self.lineno)
    self$functions.drawthyself(outfile)
end
initially
  paramtype := "rec_field"
end # class record



class program(public myfile, vars, proc, records, classes, curcontext, contextsave,globals)

method endline( lineno )
    self.curcontext$endline( lineno )
    self.curcontext := pop(self.contextsave)
end

method myline( line,lineno)
    self.curcontext$myline( line,lineno)
end

method drawthyself(outfile)
    every k := !self.globals do
    emit(outfile,k[1], "*", "global", self.myfile,k[2])
    every (!self.proc)$drawthyself(outfile)
    every (!self.records)$drawthyself(outfile)
    every (!self.classes)$drawthyself(outfile)
end

method addmethod(name, lineno)
    push(self.contextsave,self.curcontext)
    self.curcontext := self.curcontext$addmethod(name,lineno)
    return
end

method addstat(varname, lineno)
    self.curcontext$addstat(varname, lineno)
end

method addvar(varname, lineno)
    if self.curcontext === self
    then  self.globals|||:= [[varname,lineno]]
    else self.curcontext$addvar(varname,lineno)
    return
end

method addproc(procname, lineno)
    push(self.contextsave, self.curcontext)
    self.curcontext := proc(procname, lineno, self)
    self.proc|||:= [self.curcontext]
    return
end

method addrec(recname, lineno)
    push(self.contextsave, self.curcontext)
    self.curcontext := rec(recname, lineno,self)
    self.records|||:=[self.curcontext]
    return
end

method addclass(classname, lineno)
    push(self.contextsave, self.curcontext)
    self.curcontext := class_(classname, lineno, self)
    self.classes|||:=[self.curcontext]
    return
end

method resetcontext()
    self.curcontext := pop(self.contextsave)
end

initially
 self.globals := []
 self.proc := []
 self.records := []
 self.classes := []
 self.curcontext := self
 self.contextsave := []
end  # end of class program



class class_ : functions (public name, lineno, parent, meth,paramtype)

method myfile()
    return self.parent$myfile()
end

method addmethod(methname, lineno)
    self.meth|||:= [methods(methname, lineno, self)]
    return (self.meth[-1])
end

method drawthyself(outfile)
    emit(outfile,self.name, "*" , "class", self.parent$myfile(),self.lineno, self.lastline-self.lineno+1)
    every (!self.meth)$drawthyself(outfile)
    self$functions.drawthyself(outfile)
end

initially
    self.meth := []
    self.paramtype := "obj_field"
end #end of class_

class methods: functions(name, lineno, parent,paramtype)
method drawthyself(outfile)
        emit(outfile,self.name, self.parent$name() , "method", self.parent$myfile(),self.lineno, self.lastline-self.lineno+1)
    self$functions.drawthyself(outfile)
end
initially
    self.paramtype := "param"
end #end of members    class

procedure emit(outlist,ident, scope, type, filename, line, length)
    outlist[1][1] := outlist[1][1] < *ident
    outlist[1][2] := outlist[1][2] < *scope
    outlist[1][3] := outlist[1][3] < *type
    outlist[1][4] := outlist[1][4] < *filename
    outlist[1][5] := outlist[1][5] < *line
    outlist[1][6] := outlist[1][6] < *\length
    put( outlist, [ident,scope,type,filename,line,length] )
end


procedure getword()
    local word
    static ids,letts
    initial {
    ids := &ucase ++ &lcase ++ &digits ++ '_'
    letts := &ucase ++ &lcase
    }

    while tab(upto(letts)) do {
    word := tab(many(ids))
    suspend word
    }

end
##########
labelgen.iol
class labelgen : Sequence(prefix,postfix)
  method activate()
    return self.prefix||self$Sequence.activate()||self.postfix
  end
initially
  /(self.prefix) := ""
  /(self.postfix) := ""
  /(self.bounds)  := [50000]
end
##########
lbltest.iol
procedure main()
 label := labelgen("L",":")
  every i := 1 to 10 do write($@label)
end
##########
main.iol
procedure main()
  mydeque := Deque()
  mydeque$push("hello")
  mydeque$push("world")
  write("My deque is size ",mydeque$size())
  every write("give me a ",mydeque$foreach())
  write("A random element is ",mydeque$random())
  write("getting ",mydeque$get()," popping ",mydeque$pop())
end
##########
mpw.icn
#
# @(#)mpw.icn    1.2 3/13/90
# OS-specific code for Macintosh MPW
# Adapted from unix.icn by Charles Lakos
#
global lnkopt,env,sysok

procedure mysystem(s)
  if \loud then write(s)
  return system(s)
end

procedure filename(s)
  return s
end
procedure writesublink(s)
  writelink(env||"_"||s)
end
procedure envpath(filename)
  return env||"_"||filename
end
#
# Installation.
# Uses hierarchical filesystem on some systems (see initialize)
#
procedure install(args)
  write("Installing idol environment with prefix ",env)
  fout := envopen("i_object.icn","w")
  write(fout,"record idol_object(__state,__methods)")
  close(fout)
  fout := &null
  cdicont(["i_object"])
end

procedure makeexe(args,i)
  exe := args[i]
  if icont(lnkopt||exe) = \sysok then {
      mysystem("delete "||exe||".icn")
      if \exec then {
    write("Executing:")
    every i := exec+1 to *args do exe ||:= " "||args[i]
    mysystem(exe)
      }
  }
end
#
# system-dependent compilation of idolfile.icn
#   (in the idol subdirectory, if there is one)
#
procedure cdicont(idolfiles)
  args := " -c"
  rms  := ""
  every ifile := !idolfiles do args ||:= " " || envpath(ifile)
  every ifile := !idolfiles do rms  ||:= " " || envpath(ifile) || ".icn"

  if comp = -2 then return  # -t --> don't translate at all
  if icont(args,"") = \sysok
  then mysystem("delete "||rms)
end
procedure sysinitialize()
  lnkopt := " -Sr500 -SF30 -Si1000 "
  env:= "C"
  sysok := 0
  loud := &null
  write(&errout)
  write(&errout, "*** Select and run the following commands ***")
  write(&errout)
end

procedure system(s)
  write(&errout,s)
  return sysok
end
##########
msdos.icn
#
# @(#)msdos.icn    1.3 3/13/90
# OS-specific code for MS-DOS Idol
#
# For systems which cannot run icont from within an Icon program,
# the approach is for Idol to generate a script/batch file to do this.
#
global lnkopt,cd,md,env,sysok,batfile

procedure mysystem(s)
  if /batfile then batfile := open("idolt.bat","w")
  if \loud then write(s)
  write(batfile,s)
  return sysok # system(s) # MS-DOS Icon is generally too big to use system()
end

procedure filename(s)
  s[9:0] := ""
  return s
end
procedure writesublink(s)
  writelink(env||"\\\\"||s)
end
procedure envpath(filename)
  return env||"\\"||filename
end
#
# Installation.
# Uses hierarchical filesystem on some systems (see initialize)
#
procedure install(args)
  write("Installing idol environment in ",env)
  if env ~== "" then mysystem(md||env)
  if fout := envopen("i_object.icn","w") then {
    write(fout,"record idol_object(__state,__methods)")
    close(fout)
  } else {
    if not (fout := open("i_object.icn","w")) then stop("can't open i_object")
    write(fout,"record idol_object(__state,__methods)")
    close(fout)
    mysystem("copy i_object.icn "||env)
    mysystem("del i_object.icn")
  }
  fout := &null
  cdicont(["i_object"])
end

procedure makeexe(args,i)
  exe := args[i]
  if icont(lnkopt||exe) = \sysok then {
      if \exec then {
    write("Executing:")
    exe := "iconx "||exe
    every i := exec+1 to *args do exe ||:= " "||args[i]
    mysystem(exe)
      }
  }
end
#
# system-dependent compilation of idolfile.icn
#   (in the idol subdirectory, if there is one)
#
procedure cdicont(idolfiles)
  if comp = -2 then return  # -t --> don't call icont at all
  args := " -c"
  rms  := ""
  every ifile := !idolfiles do args ||:= " " || ifile
  every ifile := !idolfiles do rms  ||:= " " || ifile || ".icn"

  mysystem("cd idolcode.env")
  icont(args)
  mysystem("cd ..")
end
procedure sysinitialize()
  lnkopt := " -Sr500 -SF30 -Si1000 "
  cd := "cd "
  md := "mkdir "
  env := "idolcode.env"
  sysok := 0
end
##########
os2.icn
#
# @(#)os2.icn    1.3 3/13/90
# OS-specific code for OS/2 Idol
# Adapted from msdos.icn by cheyenne wills
#
global lnkopt,cd,md,env,sysok

procedure mysystem(s)
  if \loud then write(s)
  return system(s)
end

procedure filename(s)
  s[9:0] := ""
  return s
end
procedure writesublink(s)
  writelink(env||"\\\\"||s)
end
procedure envpath(filename)
  return env||"\\"||filename
end
#
# Installation.
# Uses hierarchical filesystem on some systems (see initialize)
#
procedure install(args)
  write("Installing idol environment in ",env)
  if env ~== "" then mysystem(md||env)
  fout := envopen("i_object.icn","w")
  write(fout,"record idol_object(__state,__methods)")
  close(fout)
  fout := &null
  cdicont(["i_object"])
end

procedure makeexe(args,i)
  exe := args[i]
  if icont(lnkopt||exe) = \sysok then {
      mysystem((if find("UNIX",&features) then "rm " else "del ")||exe||".icn")
      if \exec then {
    write("Executing:")
    if not find("UNIX",&features) then exe := "iconx "||exe
    every i := exec+1 to *args do exe ||:= " "||args[i]
    mysystem(exe)
      }
  }
end
#
# system-dependent compilation of idolfile.icn
#   (in the idol subdirectory, if there is one)
#
procedure cdicont(idolfiles)
initial { s := (getenv("ICONT")|"icont") }

  if comp = -2 then return  # -t --> don't call icont at all
  args := " -c"
  rms  := ""
  every ifile := !idolfiles do args ||:= " " || ifile
  every ifile := !idolfiles do rms  ||:= " " || ifile || ".icn"
  cdcmd := open("idolenv.cmd","w")
  write(cdcmd,"@echo off")
  write(cdcmd,"cd idolcode.env")
  write(cdcmd,s,args)
  write(cdcmd,"if errorlevel 1 goto xit")
  every ifile := !idolfiles do
    write(cdcmd,"del ",ifile,".icn")
  write(cdcmd,":xit")
  write(cdcmd,"cd ..")
  close(cdcmd)
  mysystem("idolenv.cmd")
  mysystem("del idolenv.cmd")
end
procedure sysinitialize()
  lnkopt := " -Sr500 -SF30 -Si1000 "
  cd := "cd "
  md := "mkdir "
  env := "idolcode.env"
  sysok := 0
end
##########
point.iol
class Cartesian : Radian (x,y)
initially
  if /(self.r) then {
    self.r := sqrt(self.x^2+self.y^2)
    self.d := 0 # this should really be some awful mess
  }
end
class Radian : Cartesian(d,r)
initially
  if /(self.x) then {
    self.x := 0
    self.y := 0
  }
end
##########
seqtest.iol
procedure main()
  decimal   := sequence(255)
  hex       := sequence("0123456789ABCDEF","0123456789ABCDEF")
  octal     := sequence(3,7,7)
  character := sequence(string(&cset))
  while write(right($@decimal,3)," ",$@hex," ",$@octal," ",image($@character))
end
##########
sequence.iol
procedure sequence(bounds[ ])
  return Sequence(bounds)
end

class Sequence(bounds,indices)
  method max(i)
    elem := self.bounds[i]
    return (type(elem)== "integer",elem) | *elem-1
  end
  method elem(i)
    elem := self.bounds[i]
    return (type(elem)== "integer",self.indices[i]) | elem[self.indices[i]+1]
  end
  method activate()
    top := *(self.indices)
    if self.indices[1] > self$max(1) then fail
    s := ""
    every i := 1 to top do {
      s ||:= self$elem(i)
    }
    repeat {
       self.indices[top] +:= 1
       if top=1 | (self.indices[top] <= self$max(top)) then break
       self.indices[top] := 0
       top -:= 1
    }
    return s
  end
initially
  / (self.indices) := list(*self.bounds,0)
end
##########
systems.doc
This file contains system-dependent notes on Idol.  Compiling idolboot
for your system now requires a command of the form
    icont -Sr1000 -SF30 -Si1000 idolboot system
where system is the name of your system (so far unix, msdos, os2, or vms).

UNIX

If you are running UNIX, count yourself lucky!

MSDOS
Due to memory limitations, Idol for MS-DOS Icon does not use the system()
function.  Instead, it generates a batch file, idolt.bat, containing the
sequence of commands required to finish the translation and linking of
the output into executable icode.  The batch file idol.bat runs idol
and then calls idolt for you; it should suffice in ordinary situations.
It is invoked as described in the man page and reference manual, e.g.
    C> idol idol msdos
The file install.bat performs the initial bootstrap translation of idol.
Note that the translation scripts cannot automatically remove .icn files,
so you may have to remove them manually if your disk space is precious.

VMS

Idol compiles and runs under VMS Icon version 7.0, but its a little
klunky; idol may fail to execute icont, or icont may fail to execute
ilink (under version 7.0).  Unfortunately I do not have access
to a VMS machine running a current version of Icon.  Note that there
are two DCL scripts in the distribution: vms.com is used by Idol
internally, while idol.com is a convenience script if icont fails
on your system when invoked from inside Idol.  Remember
when specifying options to either idol or icont one must put quotes
around the argument in order for VMS to leave it alone!

OS/2

Cheyenne Wills has provided us all with an OS/2 system file!
Although problems should be reported to me, the credit is all his.

MPW

Charles Lakos has provided a system file for Icon running under the
Macintosh Programmer's Workshop.  Icon source for class X is generated
as C_X.icn.  After the Idol translation phase, the commands  for the
Icon translation have been written to the MPW Worksheet.  They can
simply be selected and run.  Thanks Charles!

AMIGA

Idol runs fairly comfortably on Version 8 of Amiga Icon (it won't work
with Version 7.5 of Amiga Icon).  Version 8 of Amiga Icon isn't
available at this writing, but probably will be by the time you read this.


OTHERS

Porting idol consists of writing a new system.icn file for your system.
Take a look at unix.icn, vms.icn, os2.icn, mpw.icn, and msdos.icn.
##########
unix.icn
#
# @(#)unix.icn    1.3 3/13/90
# OS-specific code for UNIX Idol
#
global lnkopt,env,sysok

procedure mysystem(s)
  if \loud then write(s)
  return system(s)
end

procedure filename(s)
  s[9:0] := ""
  return s
end
procedure writesublink(s)
  writelink(env||"/"||s)
end
procedure envpath(filename)
  return env||"/"||filename
end
#
# Installation.
# Uses hierarchical filesystem on some systems (see initialize)
#
procedure install(args)
  write("Installing idol environment in ",env)
  if env ~== "" then mysystem("mkdir "||env)
  fout := envopen("i_object.icn","w")
  write(fout,"record idol_object(__state,__methods)")
  close(fout)
  fout := &null
  cdicont(["i_object"])
end

procedure makeexe(args,i)
  exe := args[i]
  if icont(lnkopt||exe) = \sysok then {
      mysystem("rm "||exe||".icn")
      if \exec then {
    write("Executing:")
    every i := exec+1 to *args do exe ||:= " "||args[i]
    mysystem(exe)
      }
  }
end
#
# system-dependent compilation of idolfile.icn
#   (in the idol subdirectory, if there is one)
#
procedure cdicont(idolfiles)
  args := " -c"
  rms  := ""
  every ifile := !idolfiles do args ||:= " " || ifile
  every ifile := !idolfiles do rms  ||:= " " || ifile || ".icn"

  if comp = -2 then return  # -t --> don't translate at all
  if icont(args,"cd idolcode.env; ") = \sysok
  then mysystem("cd idolcode.env; rm "||rms)
end
procedure sysinitialize()
  lnkopt := " -Sr500 -SF30 -Si1000 "
  env:= "idolcode.env"
  sysok := 0
end
##########
vms.com
$ ! A script used internally by Idol on VMS
$ set default [.idolenv]
$ icont -c 'P1'
$ set default [-]
##########
vms.icn
#
# @(#)vms.icn    1.4 3/13/90
# OS-specific code for VMS Idol
#
global lnkopt,cd,md,env,sysok

procedure mysystem(s)
  if \loud then write(s)
  return system(s)
end

procedure filename(s)
  s[9:0] := ""
  return s
end
procedure writesublink(s)
  writelink(env||s)
end
procedure envpath(filename)
  return env||filename
end
#
# Installation.
# Uses hierarchical filesystem on some systems (see initialize)
#
procedure install(args)
  write("Installing idol environment in ",env)
  if env ~== "" then mysystem(md||env)
  fout := envopen("i_object.icn","w")
  write(fout,"record idol_object(__state,__methods)")
  close(fout)
  fout := &null
  cdicont(["i_object"])
end

procedure makeexe(args,i)
  exe := args[i]
  if icont(lnkopt||exe) = \sysok then {
      mysystem("del "||exe||".icn")
      if \exec then {
    write("Executing:")
    exe := "iconx "||exe
    every i := exec+1 to *args do exe ||:= " "||args[i]
    mysystem(exe)
      }
  }
end
#
# system-dependent compilation of idolfile.icn
#   (in the idol subdirectory, if there is one)
#
procedure cdicont(idolfiles)
  if comp = -2 then return  # -t --> don't icont at all
  args := " -c"
  rms  := ""
  every ifile := !idolfiles do args ||:= " " || ifile
  every ifile := !idolfiles do rms  ||:= " " || ifile || ".icn"

  every ifile := !idolfiles do mysystem("@vms "||ifile||".icn")
end

procedure sysinitialize()
    lnkopt := " \"-Sr500\" \"-Si1000\" \"-SF30\" \"-Sg500\" "
    cd    := "set default "
    md    := "create/dir "
    env   := "[.idolenv]"
    sysok    := 1
end
##########
warntest.iol
# This is a test of the emergency broadcasting system.
# This is only a test.

class a ( field )
end

class b : a ( field )
end