Summary

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

	File:     emptygen.icn

	Subject:  Procedures for meta-translation code generation

	Author:   Ralph E. Griswold

	Date:     December 5, 1995

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

   This file is in the public domain.

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

  This program is designed to be linked with the output of the meta-
  translator.  As given here, they produce an identity translation.
  Modifications can be made to effect different translations.

  The procedures here are just wrappers.  This file is a skeleton that
  can be used as a basis for code-generation procedures.

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

  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-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)

 procedure argument (parameter)

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(es)

 procedure body

Break(e)

 break e

Case(e, clist)

 case e of { caselist }

Cclause(e1, e2)

 e1 : e2

Clist(cclause1, cclause2)

 cclause1 ; cclause2

Clit(c)

 'c'

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(e, f)

 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(i)

 i

Initial(e)

 initial e

Invocable(ss)

 invocable s1, s2, ... (problem)

Invoke(e, es)

 e(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(e, es)

 e{e1, e2, ... }

Proc(n, vs)

 procedure n(v1, v2, ...)

Record(n, fs)

 record n(f1, f2, ...)

Repalt(e)

 |e

Repeat(e)

 repeat e

Return(e)

 return e

Rlit(r)

 r

Scan(e1, e2)

 e1 ? e2

Section(op, e1, e2, e3)

 e1[e2 op  e3]

Slit(s)

 "s"

Static(vs)

 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(v)

 v

While(e)

 while e

WhileDo(e1, e2)

 while e1 do e2

main()