Summary

###########################################################################

	File:     eventgen.icn

	Subject:  Procedures for meta-variant code generation

	Author:   Ralph E. Griswold

	Date:     May 23, 1996

###########################################################################

   This file is in the public domain.

###########################################################################

  This program is designed to be linked with the output of the meta-variant
  translator.

  It is designed to insert event-reporting code in Icon programs.

###########################################################################

  Bug:  The invocable declaration is not handled properly.  "invocable all"
        will get by, but some other forms produce syntax errors.  The
        problem is in the meta-variant translator itself, not in this
	 program.

###########################################################################

  Links:  strings

###########################################################################

This file is part of the (main) package.

Alt(e1, e2)

 e1 | e2

Apply(e1, e2)

 e1 ! e2

Arg(e)

Asgnop(op, e1, e2)

 e1 op e2

Augscan(e1, e2)

 e1 ?:= e2

Bamper(e1, e2)

 e1 & e2

Binop(op, e1, e2)

 e1 op e2

Body(s)

 procedure body

Break(e)

 break e

Case(e, clist)

 case e of { caselist }

Cclause(e1, e2)

 e1 : e2

Clist(e1, e2)

 e1 ; e2 in case list

Clit(e)

 's'

Compound(es)

 { e1; e2; ... }

Create(e)

 create e

Default(e)

 default: e

End()

 end

Every(e)

 every e

EveryDo(e1, e2)

 every e1 do e2

Fail()

 fail

Field(e1, e2)

 e . f

Global(vs)

 global v1, v2, ...

If(e1, e2)

 if e1 then e2

IfElse(e1, e2, e3)

 if e1 then e2 else e3

Ilit(e)

 i

Initial(s)

 initial e

Invocable(es)

 invocable ... (problem)

Invoke(e0, es)

 e0(e1, e2, ...)

Key(s)

 &s

Limit(e1, e2)

 e1 \ e2

Link(vs)

 link "v1, v2, ..."

List(es)

 [e1, e2, ... ]

Local(vs)

 local v1, v2, ...

Next()

 next

Not(e)

 not e

Null()

 &null

Paren(es)

 (e1, e2, ... )

Pdco(e0, es)

 e0{e1, e2, ... }

Proc(s, es)

 procedure s(v1, v2, ...)

Record(s, es)

 record s(v1, v2, ...)

Repalt(e)

 |e

Repeat(e)

 repeat e

Return(e)

 return e

Rlit(e)

Scan(e1, e2)

 e1 ? e2

Section(op, e1, e2, e3)

 e1[e2 op  e3]

Slit(s)

 "s"

Static(ev)

 static v1, v2, ..

Subscript(e1, e2)

 e1[e2]

Suspend(e)

 suspend e

SuspendDo(e1, e2)

 suspend e1 do e2

To(e1, e2)

 e1 to e2

ToBy(e1, e2, e3)

 e1 to e2 by e3

Unop(op, e)

 op e

Until(e)

 until e

UntilDo(e1, e2)

 until e1 do e2

Var(s)

 v

While(e)

 while e

WhileDo(e1, e2)

 while e1 do e2

main()