\begin{appendix}


\chapter{Schnittstellen des Compilers zur Implementierung dynamischen 
         Typisierung}
\label{Compilerschnittstellen}

\section{Schnittstelle 'TLDynamicImpl'}
\label{TLDynamicImpl}
\begin{xple}
\kw{Interface} \id{TLDynamicImpl}
\kw{import} \id{:TLType :TLIde tlEnv list time tm :Source}
\kw{export}
  \kw{Let} \id{Path} = \kw{Tuple var} \id{oid :String} \kw{end}
  \kw{Let Rec} \id{T} $<$:\kw{Ok} = \kw{Tuple}                (* Laufzeit--Typrepr"asentation *)
    \kw{case} \id{okCase, nokCase} \kw{with}
    \kw{case} \id{baseCase} \kw{with}                         (* Basistyp *)
      \id{name :String}
    \kw{case} \id{ideCase} \kw{with}                           (* Typbezeichner *)
      \id{definition :Signature}                       (* direkte Referenz zur Definition *)
    \kw{case} \id{adtCase} \kw{with}                          (* abstrakter Typbezeichner *)
      \id{definition :Signature}                       (* direkte Referenz zur Definition *)
      \id{path} :\kw{Tuple} \kw{var} \id{oid :String} \kw{end}
    \kw{case} \id{funCase} \kw{with}                         (* Funktionstyp *)
      \id{signatures :list.T(Signature)}
      \id{range :T}
    \kw{case} \id{tupleCase} \kw{with}                        (* Tupeltyp *)
      \id{signatures :list.T(Signature)}
      \id{cases :list.T(Case)}
    \kw{case} \id{recordCase} \kw{with}                      (* Recordtyp *)
      \id{signatures :list.T(Signature)}
    \kw{case} \id{exceptionCase} \kw{with}                  (* Ausnahmetyp *)
      \id{signatures :list.T(Signature)}
    \kw{case} \id{operCase} \kw{with}                        (* Typoperator *)
      \id{signatures :list.T(Signature)}
      \id{range :T}
    \kw{case} \id{arrayCase} \kw{with}                       (* Arraytyp *)
      \id{elementType :T}
    \kw{case} \id{appCase} \kw{with}                         (* Typoperatorapplikation *)
      \id{oper :T}
      \id{arguments :list.T(Signature)}
    \kw{case} \id{recCase} \kw{with}                          (* rekursiver Typ *)
      \id{bindingIndex :Int}
      \id{typeBindings :list.T(Signature)}
    \kw{case} \id{varCase} \kw{with}                          (* Typ einer ver"anderlichen Bindung *)
      \id{type :T}
  \kw{end}

  \kw{and} \id{Signature} $<$:\kw{Ok} = \kw{Tuple}
    \id{ide} :\kw{Tuple} \id{name :String  pos :Source.Position}  \kw{end}
    \kw{var} \id{type :T}
    \kw{case} \id{typeCase, typeEqualCase} \kw{with}  (* T $<$:A  bzw. Let T = A *)
      \id{typeId :time.T}                             (* Zeitstempel *)
    \kw{case} \id{valueCase}
    \kw{case} \id{locationCase}
  \kw{end}

  \kw{and} \id{Case} $<$:\kw{Ok} = \kw{Tuple}
    \id{label :String}
    \id{signatures :list.T(Signature)}             (* zus"atzliche Felder dieser Variante *)
  \kw{end}
  \kw{Let} \id{Value} = \kw{Tuple}                 (* automorphe Werte *)
    \id{value} :\kw{Ok}
    \id{type :T}
  \kw{end}
  \id{makeType(t :T} \kw{var} \id{outEnv :tlEnv.T) :TLType.T}
  (* transformiert t in einen  statischen Typ *)
  
  \id{isSubType(small, big :T  env :tlEnv.T) :Bool}
  
  \id{coerce(A} $<$:\kw{Ok}  \id{d :Value  t :T  exc} :\kw{Exception}  \id{pos :Souerce.Position) :A}
  (* Liefert d.value wenn isSubType(d.type t), ansonsten coerceError *)
  
  \id{isADTRef(ref :String) :Bool}
  (* Liefert true wenn ref einen durch dieses Modul erzeugten ADT repr"asentiert *)

  \id{getPath(ref :String) :String}
  (* Liefert die Pfadkomponente des von diesem Modul erzeugten ref *)
  
\kw{end}
\end{xple}

\newpage

\section{Schnittstelle 'TLDynamic'}
\label{TLDynamic}
\begin{xple}
\kw{Interface} \id{TLDynamic}
\kw{import} \id{:TLValue :TLType tlEnv :TLDynamicImpl dictionary}
\kw{export}
  \kw{Let} \id{Entry} = \kw{Tuple}
    \id{path :TLDynamicImpl.Path}
    \id{value :TLValue.T}
  \kw{end}
  \id{makeTypeRep(type :TLType.T  env :tlEnv.T}
		  \id{pathes :dictionary.T(Entry String)) :TLDynamicImpl.T}
  (* Zur"uckgegebene Pfade m"ussen noch an patchTypeRep "ubergeben werden! *)
  \id{patchTypeRep(A} $<$:\kw{Ok}  \id{paths :Array(TLDynamicImpl.Path)}
	       \id{modules :Array}(\kw{Ok}) \id{t :A) :A}
  (* ersetzt Platzhalter in paths durch die aktuellen Werte aus modules *)
  \id{makeDynType(type :TLType.T env :tlEnv.T) :TLValue.T}
  (* implementiert typeRep\_new *)
  \id{makeDynValue(value :TLValue.T  type :TLType.T  env :TLEnv.T) :TLValue.T}
  (* implementiert dynamic\_new *)
  \id{makeCoerce(dyn :TLValue.T type :TLType.T env :tlEnv.T) :TLValue.T}
  (* implementiert dynamic\_be *)
\kw{end}
\end{xple}

\section{Schnittstelle 'TLDynEnv'}
\label{TLDynEnv}
\begin{xple}
\kw{Interface} \id{TLDynEnv}
\kw{import} \id{:TLIde tlEnv :TLDynamicImpl}
\kw{export}
  \id{error :Exception}
  \id{T} $<$:\kw{Ok}
  (* Eine dynamische Umgebung ist eine geordnete Folge von Typbindungen *)
  \id{dynEnv() :T}
  (* Liefert die globale dynamische Umgebung. Es wird beim Erzeugen eines neuen
     Objektspeichers im Root Vektor abgelegt. Laufzeit--Typrepr"asentation enthalten Referenzen
     auf die Bindungen dieser Umgebung *)
  \id{init(env :tlEnv.T}) :\kw{Ok}
  (* Initialisiert 'theEnv' mit Builtin Typen. Wird nach der Systemerzeugung aufgerufen *)
  \id{initReflectively}() :\kw{Ok}
  (* Initialisiert 'theEnv' mit der dynamischen Umgebung aus dem Root Vektor.
     Liefert Fehlermeldung wenn es nicht gefunden wird. *)
  \id{insert(sig :TLDynaicImpl.Signature}) :\kw{Ok}
  (* F"ugt sig in 'theEnv' ein. Liefert absoluten Index in 'theEnv'.
     Erzeugt Fehlermeldung, wenn sig schon in 'theEnv' vorhanden ist. *)
  \id{get(ide :TLIde.T) :TLDynamicImpl.Signature}
  (* Liefert Signatur mit Schl"ussel 'ide'. Erzeugt Fehlermeldung, wenn nicht gefunden. *)
\kw{end}
\end{xple}


\chapter{Reflektive Schnittstellen}

\section{Schnittstelle 'TypeRep'}
\label{TypeRep}

\begin{xple}
\kw{interface} \id{TypeRep}
\kw{import} \id{list time  :Iter  :Source}
\kw{export}
  \id{error} :\kw{Exception}
  \kw{Let} \id{T} = \kw{dynamic\_T}
  \kw{Let} \id{Ide} = \kw{Tuple} \id{name :String} \id{pos :Source.Position} \kw{end}

  \kw{Let} \id{Signature} = \kw{Tuple}
    \id{ide :Ide}
    \id{type :T}
    \kw{case} \id{typeCase, typeEqualCase} \kw{with}
       \id{typeId :time.T}
    \kw{case} \id{valueCase}
    \kw{case} \id{locationCase}
  \kw{end}

  \kw{Let} \id{Case} = \kw{Tuple}      (* zus"atzliche f"ur diesen case g"ultige Felder*)
    \id{label :String}
    \id{signatures = list.T(Signature)}
  \kw{end}

  \kw{Let} \id{Expansion} = \kw{Tuple}
    \kw{case} \id{okCase, nokCase} \kw{with}
    \kw{case} \id{baseCase} \kw{with}
      \id{ide :Ide}
    \kw{case} \id{ideCase} \kw{with}
      \id{ref :String}
      \id{definition :Signature}
    \kw{case} \id{adtCase} \kw{with}
      \id{ref :String}
      \id{definition :Signature}
      \id{path} :\kw{Tuple} \id{oid :String} \kw{end}
    \kw{case} \id{funCase} \kw{with}
      \id{signatures :list.T(Signature)}
      \id{range :T}
    \kw{case} \id{tupleCase} \kw{with}
      \id{signatures :list.T(Signature)}
      \id{cases :list.T(Case)}
    \kw{case} \id{recordCase} \kw{with}
      \id{signatures :list.T(Signature)}
    \kw{case} \id{exceptionCase} \kw{with}
      \id{signatures :list.T(Signature)}
    \kw{case} \id{operCase} \kw{with}
      \id{signatures :list.T(Signature)}
      \id{range :T}
    \kw{case} \id{arrayCase} \kw{with}
      \id{elementType :T}
    \kw{case} \id{appCase} \kw{with}
      \id{oper :T}
      \id{arguments:list.T(Signature)}
    \kw{case} \id{recCase} \kw{with}
      \id{bindingIndex :Int}
      \id{typeBindings :list.T(Signature)}
      \id{type :T}
      \id{bound :T}
  \kw{end} (* beachte: TLDynamicImpl.T $<$:Expansion *)

  \id{okType, int, real, bool, char, string :T}
  
  \id{isSubType(small, big :T) :Bool}
  (* Liefert true wenn die Laufzeit--Typrepr"asentationen in der Subtypbeziehung
     small $<$:big stehen. *)
     
  \id{inspect(type :T):Expansion}
  (* Liefert detailiertere Beschreibung von 'type' *)
  
  \id{exposed(type :T) :T}
  (* Entfernt definition(s) von 'type' *)
  
  \id{equal(t1, t2 :T) :Bool}
  (* Liefert true wenn t1 und t2 strukturell "aquivalent sind *)
  
  \id{signatures(t :T) :Iter.T(Signature)}
  (* Wenn t ein tuple, record, exception, oper oder function repr"asentiert,
     liefere eine Iteration des Signaturen; ansonsten Fehlermeldung *)
     
  \id{fmt(type :T) :String}
  (* Liefert eine String--Repr"asentation von 'type' *)
  
  \id{fmtShort(type :T) :String}
  (* Liefert eine kurze String--Repr"asentatoion von 'type', e.g. ``Tuple'' ``Int'' etc *)

  \id{isEmptyCases(cases :list.T(Case)) :Bool}
  (* Liefert true wenn 'cases' leer sind *)

  \id{newEmptyCases() :list.T(Case)}
  (* erzeugt leere cases *)

  \id{newArray(type :T) :T}
  \id{newFun(signatures :list.T(Signature)  range :T) :T}
  \id{newTuple(signatures :list.T(Signature)  cases :list.T(Case)) :T}
  \id{newRecord(signatures :list.T(Signature)) :T}
  \id{newException(signatures :list.T(Signature)) :T}
  \id{newOper(signatures :list.T(Signature)  range :T) :T}
  
\kw{end}
\end{xple}

\newpage

\section{Schnittstelle 'Dynamic'}
\label{Dynamic}

\begin{xple}
\kw{interface} \id{dynamic}
\kw{import} \id{list typeRep :TypeRep iter :Iter tm reader writer}
\kw{export}
  \id{error} :\kw{Exception}
  \kw{Let} \id{Type = dynamic\_T}
  \kw{Let} \id{T = DynValue}
  (* Ein automorpher Wert value :T ist ein tuple val :T  type :Type end,
     wobei 'type' eine Laufzeit--Typrepr"asentation von val's Typ ist *)

  \kw{Let} \id{LocationId} \kw{Tuple} \id{base :tm.OID  offset :Int end}
  (* Eine locationId ist die Zelle einer Variablen, bestehend aus einer Basis
     und einem Offset *)
     
  \kw{Let} \id{Binding} = \kw{Tuple}
    \id{name :String}
    \kw{case} \id{typeCase} \kw{with}
      \id{type :Type}
    \kw{case} \id{valueCase} \kw{with}
      \id{value :T}
    \kw{case} \id{locationCase} \kw{with}
      \id{value() :T}
      \id{setValue(:T)} :\kw{Ok}
      id{getId() :LocationId}
  \kw{end}
  
  \kw{Let} \id{Signature = TypeRep.Signature}
  \kw{Let} \id{Case = TypeRep.Case}
  
  \kw{Let} \id{Expansion} = \kw{Tuple}
    \kw{case} \id{okCase}
    \kw{case} \id{boolCase} \kw{with}
      id{val :Bool}
    \kw{case} \id{charCase} \kw{with}
      id{val :Char}
    \kw{case} \id{intCase} \kw{with}
      id{val :Int}
    \kw{case} \id{realCase} \kw{with}
      id{val :Real}
    \kw{case} \id{stringCase} \kw{with}
      id{val :String}
    \kw{case} \id{adtCase} \kw{with}
    \kw{case} \id{funCase} \kw{with}
      \id{signatures :list.T(Signature)}
      \id{range :T}
    \kw{case} \id{tupleCase} \kw{with}
      \id{tag :String}
      \id{fields :list.T(Binding)}
    \kw{case} \id{recordCase} \kw{with}
      \id{fields :list.T(Binding)}
    \kw{case} \id{exception} \kw{with}
      \id{val :String}
      \id{signatures :list.T(Signature)}
    \kw{case} \id{arrayCase} \kw{with}
      \id{type :Type}   (* type is the element type *)
      \id{size :Int}
    \kw{case} \id{appCase} \kw{with}
      \id{oper :Type}
      \id{arguments :list.T(Signature)}
      \id{value :T}
  \kw{end}
  
  \id{typeOf(value :T) :Type}
  (* Liefert Typeattribut von 'value' *)
  
  \id{valueOf(value :T)} :\kw{Ok}
  (* Liefert Wertattribut von 'value' mit der geringst m"oglichen Typinformation *)

  \id{inspect(value :T) :Expansion}
  (* Liefert detailiertere Beschreibung von 'value' *)

  \id{signatures(value :T) :iter.T(Signature)}
  (* Wenn 'value' der Wert einer Funktion oder Ausnahme ist, liefere eine Iteration ihrer
     Signaturen; ansonsten Fehlermeldung *) 

  \id{bindings(value :T) :iter.T(Binding)}
  (* Wenn 'value' der Wert eines Tupels oder Rekords ist, liefere seine Bindungen, ansonsten
     Fehlermeldung *)
     
  \id{functions(value :T) :iter.T(T)}
  (* Liefert eine Iteration aller funktionalen Komponenten eines Wertes. Besonders sinnvoll, wenn
     'value' ein Modul ist *)
     
  \id{getIndexed(value :T  i :Int) :T}
  (* Indizierter Zugriff auf Array *)
  
  \id{setIndexed(value :T  i :Int  newValue :T)} :\kw{Ok}
  (* Indizierter ver"andernder Zugriff auf Array *)
  
  \id{getIndexedId(value :T  i :Int) :LocationId}
  (* Liefer LocationId des i--ten Array--Elements *)
  
  \id{intern(r :reader.T) :T}
  (* Liefert einen automorphen Werten von einem reader *)
  
  \id{extern(w :writer.T  value :T}) :\kw{Ok}
  (* Schreibt einen automorphen Wert in einen Writer *)
  
  \id{newDefault(type :Type) :T}
  (* Erzeugt einen default Wert mit Typ 'type' *)
  
  \id{fmtShort(value :T) :String}
  (* Liefert eine kurze String--Beschreibung eines Wertes, e.g. ``tuple'' ``12'' etc. *)

  \id{newArray(A} $<$:\kw{Ok} \id{arr :Array(A)  type :Type) :T}
  \id{newTuple(fields :list.T(Binding) :T}
  \id{newTupleCase(tag :String  type :Type  fields :list.T(Binding)) :T}
  (* Raise error if tag is not a tag of type 'type' or if 'fields' do not match 'type' *)

  \id{newRecord(fields :list.T(Binding)) :T}
  \id{newException(value :String  signatures :list.T(Signature)) :T}

  \id{areEqualLocationIds(id1, id2 :LocationId) :Bool}
  (* Test, ob id1 und id2 die gleiche Location haben *)

  \id{isWrongTag(tag :String) :Bool}
  (* Test, ob 'tag' ein leerer Tuple Tag ist *)
  
\kw{end}
\end{xple}

\newpage


\section{Schnittstelle 'Closure'}
\label{Closure}

\begin{xple}
\kw{interface} \id{Closure}
\kw{import} \id{:TLClosure list}
\kw{export}
\id{T} $<$:\kw{Ok}
(* Typ der internen Repr"asentation einer Funktion *)

\kw{Let} \id{LocationId = TLClosure.LocationId}
\kw{Let} \id{TypeList = TLClosure.TypeList}
(* Liste der globalen Variablen mit ihren Laufzeit--Typinformationen *)

\kw{Let} \id{DebugInfo = TLClosure.DebugInfo}
(* Liste von Debug Informationen einer Funktion *)

\id{error} :\kw{Exception} \id{reason :String} \kw{end}
\id{coerce(f :dynamic\_T) :T}
(* falls f eine Funktion ist, so wird diese als Wert des Typs T zur"uckgegeben;
   ansonsten wird ein Ausnahmepaket generiert *)

\id{valueInClosure(name :String  value :dynamic\_T  closure :T) :T}
(* f"ugt konstante globale Variable in den Funktionsabschlu"s von 'closure' ein
   und gibt diese Funktion zur"uck *)
   
\id{locationInClosure(name :String  value() :dynamic\_T setValue(:dynamic\_T)} :\kw{Ok}
      \id{getId() :LocationID  closure :T) :T}
(* f"ugt ver"anderliche globale Variable in den Funktionsabschlu"s von 'closure' ein und gibt
   'closure' zur"uck *)
   
\id{getTypeList(debugInfo :DebugInfo) :TypeList}
(* liefert aus einer Liste von Debug Informationen die Liste der globalen Variablen mit ihren
   Laufzeit--Typinformationen *)
   
\id{collectGlobalVariables(typeList :TypeList) :list.T(Dynamics.Binding)}
(* erzeugt aus 'typeList' eine Liste von Bindungen *)

\kw{end}
\end{xple}


\chapter{Ausgew"ahlte Schnittstellen der generischen Daten-- und
Funktionsvisualisierung}

\section{Schnittstelle 'BrowserExchange'}
\label{BrowserExchange}
\begin{xple}
\kw{interface} \id{BrowserExchange}
\kw{import} \id{list  :Environment window clipboard dragServer menu  :Link}
\kw{export}
 \kw{Let} \id{EnableT} = \kw{Fun} \id{(enable :Bool)} $<$:\kw{Ok}
 (* Typ, der die Funtion repr"asentiert, mit dem ein Men"ueintrag aktiviert werden kann *)

 \id{ClipboardT} $<$:\kw{Tuple} \id{cb :clipboard.T} \kw{end}
 \id{DragServerT} $<$:\kw{Tuple} \id{ds :dragServer.T} \kw{end}
 
 \id{theClipboard :ClipboardT}
 (* das Klemmbrett, das von allen Browsern benutzt werden sollte *)
 
 \id{theDragServer :DragServerT}
 (* der DragServer, der von allen Browsern benutzt werden sollte *)
 
 \id{newClipboard() :ClipboardT}
 (* Erzeugung eines neuen Klemmbretts *)
 
 \id{insertEnablePaste(cb :ClipboardT  m :menu.Popup  enablePaste :EnableT) :}\kw{Ok}
 (* enablePaste aktiviert bzw. deaktiviert Men"ueintrag f"ur Paste, falls Klemmbrett
    gef"ullt oder geleert wird *)
    
 \id{deleteEnablePaste(cb :ClipboardT  m :menu.Popup) :}\kw{Ok}
 (* entfernt enablePaste Funktion f"ur m *)
 
 \id{pasteHdl(cb :ClipboardT  insertBindings(bnds :list.T(Environment.Binding))} :\kw{Ok}
   \id{default(data :String)} :\kw{Ok}) :\id{Link.Handler}
   (* Handle, um Bindungen via insertBindings aus cb in das Objekt zu kopieren *)

 \id{copyHdl(cb :Clipboard.T  selectedBindings :} \kw{Fun}() :\id{list.T(Environment.Binding)) :Link.Handler}
 (* Handle, um via selectedBindings erhaltene Bindungen in cb zu kopieren *)
 
 \id{newDragServer() :DragServerT}
 (* erzeugt neuen DragServer *)
 
 \id{initDrag(ds :DragServerT  win :window.T}
   \id{getBindings() :list.T(Environment.Binding))} :\kw{Ok}
 (* initialisiere Drag f"ur win auf ds mit getBindings *)
 
 \id{initDrop(ds :DragServerT  win :window.T}
   \id{setBindings(bnds :list.T(Environment.Binding))) :}\kw{Ok}
 (* initialisiere Drop f"ur win auf ds mit setBindings *)
 
 \id{uninitDrop(win :window.T) :}\kw{Ok}
 (* uninitialisiere Drop f"ur win *)
 
\kw{end}
\end{xple}

\section{Schnittstelle 'Browser'}
\label{Anwendungsschnittstelle}

\begin{xple}
\kw{interface} \id{Browser}
\kw{import} \id{environment :Environment  window listBox  :BrowserUtil}
\kw{export}
  \id{T} $<$:\kw{Ok}
  (* Typ eines Bindungsbrowsers *)
  
  \id{binding(parent :window.T  bnd :Environment.Binding  keepPermanent :Bool) :T}
  (* erzeugt von einer Bindung einen Browser und gibt ihn zur"uck; erzeugtes
     Protokoll wird permanent in Tabelle gespeichert, falls keepPermanent 'true'  *)

  \id{env(parent :window.T  name :String  env :environment.T}
    \id{errorWin :listBox.T  keepPermanent :Bool) :T}
  (* erzeugt einen Browser von einem Environment *)
  
  \id{display(parent :window.T  browser :T  pos :BrowserUtil.Location) :}\kw{Ok}
  (* zeigt einen Browser auf dem Bildschirm an *)
  
  \id{apply(br :T) :Bool}
  (* setzt die visualisierte Bindung mit den Werten der Bildschirmrepr"asentation *)

  \id{refresh(br :T) :}\kw{Ok}
  (* f"ullt die Bildschirminhalte mit dem Wert einer Bindung *)

  \id{unshow(br :T) :}\kw{Ok}
  (* entfernt eine Bildschirmrepr"asentation vom Bildschirm *)

  \id{getValue(br :T) :Environment.Binding}
  (* liefert die Bindung, die durch br visualisiert wird *)

  \id{setValue(br :T  bnd :Environment.Binding) :}\kw{Ok}
  (* ersetzt die durch br visualisierte Bindung durch bnd *)
  
\kw{end}
\end{xple}

\end{appendix}
