{
;--------------------------------------
;
; aldap 2
;
; pascal 1
;
; michael pollak [0826037]
;
;--------------------------------------
}



program queue;

{ head }
	(* deklariere den datentyp, speichert dummydaten flugnummer und destination *)
type listnr = ^list;
     list  = record
                flightnr: string;
                dest:  string;
                next: listnr;
         	end;



{ unterprogramme }

{ zum einlesen neuer elemente }
	{ die read_string funktion nimmt eine frage als eingabewert an, stellt die frage und gibt die eingegebene antwort als string zurück. }
	(* precon.: message ist eine fragestellung. *)
	(* postcon.: gibt die eingegebene antwort als string zurück and das aufrufende programm. *)
function read_string(message: string): string;
var s: string;
begin
	write(message);
	readln(s);
	read_string := s;
end;
	
	
	{ die do_add funktion ist eine hilfsfunktion, um sie rekursiv aufrufen zu können und einen datensatz an das ende einer liste einzufügen. }
	(* precon.: flight ist der neu generierte datensatz der von add an do_add übergeben wird, start gibt an wo begonnen wird die liste zu durchlaufen *)
	(* postcon.: der neue datensatz wurde am ende der liste eingefügt. *)	
procedure do_add(var start, flight: listnr);
begin
	if start = nil then
	begin
		start := flight;
		flight^.next := nil;
	end	
	else
		(* rekursiver aufruf der selben funktion *)
	    do_add(start^.next, flight);
end;


	{ die add funktion nimmt neue datensätze auf. neuen datensatz anlegen, zuerst wird die hilfsfkt. read_string aufgerufen, um die daten einzulesen, dann mit der hilfsfkt. do_add einreihen. }
	(* precon.: keine, muss nur aufgerufen werden mit dem parameter start. *)
	(* postcon.: wenn alle unterfunktionen abgearbeitet sind ist ein datensatz mehr in der liste... *)
procedure add(var start: listnr);
var flight: listnr;
begin
  	writeln('--- add ---');
  	
  	new(flight); (* generiert einen neuen datensatz *)
	flight^.flightnr := read_string('flightnumber = '); (* liest flugnummer ein *)
	flight^.dest := read_string('destination = '); (* zusatzinfo ziel einlesen *)
	do_add(start, flight); (* ins unterprogramm do_add übergeben, um ans ende einzureihen. *)
	
	writeln('--- /add ---');
	writeln();
end;



	{ zum ausgeben vorhandener elemente (debug) }	
	(* precon.: keine, muss wieder nur aufgerufen werden mit start *)
	(* postcon.: gibt die flug-liste am screen aus. *)
procedure show(start: listnr);
var i: integer;
begin
	writeln('--- show ---');
	
	i := 0;
	while (start <> nil) do
	begin
	 	writeln(start^.flightnr, ', ', start^.dest);	
	    i := i+1;
	    start := start^.next;
	end;
	writeln(i, ' in the queue.');
	
	writeln('--- /show ---');
	writeln();
end;
	


	{ zum löschen der verworfenen elemente }
	(* precon.: keine, muss wieder nur aufgerufen werden mit start *)
	(* postcon.: löscht das erste element aus der liste, damit das älteste. *)
procedure depart(var start: listnr);
var h1: listnr;
begin		
	writeln('--- depart ---');
	
	if (start <> nil) then
	begin
		writeln('flight nr ',start^.flightnr,' is gone.');
		h1 := start;
	    start := start^.next;
	    dispose(h1);   
	end
	else 
		writeln('0 ... feierabend.');
	
	writeln('--- /depart ---');
	writeln();
end;


{ main }
	(* im hauptprogramm sollen nur grundsätzliche aufrufe erfolgen, den rest in unterprogramme auslagern. *)

var start: listnr;
    answer: char;

begin    
start := nil;
repeat
	(* menüstruktur wird wiederholt, nach jeder eingabe angezeigt. *) 
  	writeln();
  	writeln('queue');
    writeln('--------');
    writeln('a add');
    writeln('d depart');
    writeln('s show');
    writeln('x quit');
    writeln('--------');
    writeln();
    readln(answer);
    case answer of
      'a': add(start); 
      'd': depart(start);
      's': show(start);
      'x': writeln('danke');
      otherwise writeln('bitte mach eine gültige eingabe.');
    end;

until (answer = 'x');

end. 


{ that's it i guess. }