unit ujournal;

interface
           procedure trait;
implementation
const	nregle		= 200;
	nlibelle	= 2000;
	nvariable	= 20;

type	tstring = string;
	ptstring = tstring;
	tetou = (et,ou);

	regle	= record
		nom_regle	: ptstring;
		premier		: integer;
		etou		: tetou;
		nombre		: integer;
		end;

	libelle	= record
		generation	: ptstring;
		suivant		: integer;
		suite		: integer;
		end;

	variable = record
		nom_variable	: tstring;
		lib_variable	: integer;
		end;


var	fini	: boolean;
	ccar,ccor	: char;
	boucle	: boolean;
	nbcar		: integer;
	phrase	: tstring;
	mot	: tstring;
	nb_regle: integer;
	nb_libelle: integer;
	nb_variable: integer;
	regles	: array[1..nregle] of regle;
	libelles: array[1..nlibelle] of libelle;
	variables: array[1..nvariable] of variable;

	last_libelle : integer;
	
	scenario: text;
	
function chercher_regle(mot:tstring) : integer;
var	q,n	: integer;
begin
q := 0;
n := 0;
while q < nb_regle do
	begin
	q := q + 1;
	if mot = regles[q].nom_regle
	then	begin
		n := q;
		q := nb_regle;
		end;
	end;
chercher_regle := n;
end;

function chercher_variable(mot:tstring) : integer;
var	q,n	: integer;
begin
q := 0;
n := 0;
while q < nb_variable do
	begin
	q := q + 1;
	if mot = variables[q].nom_variable
	then	begin
		n := q;
		q := nb_variable;
		end;
	end;
chercher_variable := n;
end;


procedure lire_scenarios;
var	q , l		: integer;
	ouet		: tetou;
	num_regle	: integer;
	prec_libelle	: integer;
	fin_regle	: boolean;
	err		: integer;
	car		: char;

procedure lire_phrase;
begin
if eof(scenario)
then	phrase := '*'
else	begin
	read(scenario,phrase);
	readln(scenario);
	if (phrase <> '') and (phrase[1] = chr(9))
	then	phrase := copy(phrase , 2 , length(phrase)-1);
	end;
end;

procedure verifier;
var	goon	: boolean;
	i,l	: integer;
	phr	: tstring;
	mot	: tstring;
begin
phr := phrase;
goon := true;
while goon do
	begin
	i := pos('<' , phr);
	if i=0
	then	i := pos('[' , phr);
	if i = 0
	then	goon:=false
	else	begin
		l:=length(phrase);
		phr := copy(phr,i+1,l-i+1);
		i := pos('>' , phr);
		if i = 0
		then	i := pos(']' , phr);
		if i <> 0
		then	begin
			mot:=copy(phr,1,i-1);
			if (mot <> '') and (pos('[si ',mot)=0)
			and not (mot[1] in ['0'..'9'])
			then	begin
				l:=length(phr);
				phr:= copy(phr,i+1,l-i);
				i:=chercher_regle(mot);
				if i=0
				then	begin
					writeln(output,'la regle ',mot,
						' n''est pas d‚finie');
					err := err + 1;
					end;
				end;
			end;
		end;
	end;
end;

procedure lire_libelle;
var	asuivre	: boolean;
	q	: integer;
begin
lire_phrase;
if (phrase <> '') and (phrase[1] = '*')
then	fin_regle := true
else	begin
	q := pos('>=' , phrase);
	if q <> length(phrase)-1
	then	q := pos('>:=' , phrase);
	if q <> 0
	then	begin
		writeln(output,'la regle précédent ',phrase,
			' est mal termiée');
		err := err + 1;
		end;
	nb_libelle := nb_libelle + 1;
	if prec_libelle = 0
	then	regles[num_regle].premier := nb_libelle
	else	libelles[prec_libelle].suivant := nb_libelle;
	prec_libelle := nb_libelle;
	regles[num_regle].nombre := regles[num_regle].nombre + 1;
	l := length(phrase);
	libelles[nb_libelle].suivant := 0;
	(* getmem(libelles[nb_libelle].generation, l + 2);     *)
	if phrase[l] = '<'
	then	begin
		phrase[l] := ' ';
		libelles[nb_libelle].generation := phrase;
		asuivre := true;
		while asuivre do
			begin
			lire_phrase;
			l := length(phrase);
			if (l>=1) and (phrase[1] = chr(9))
			then	phrase := copy(phrase , 2 , l-1);
			libelles[nb_libelle].suite := nb_libelle + 1;
			nb_libelle := nb_libelle + 1;
			l := length(phrase);
			(* getmem(libelles[nb_libelle].generation, l + 2);           *)
			if phrase[l] = '<'
			then	begin
				phrase[l] := ' ';
				asuivre := true;
				end
			else	asuivre := false;
			libelles[nb_libelle].suite := 0;
			libelles[nb_libelle].suivant := 0;
			libelles[nb_libelle].generation := phrase;
			end;
		end
	else	begin
		libelles[nb_libelle].generation := phrase;
		libelles[nb_libelle].suite := 0;
		libelles[nb_libelle].suivant := 0;
		end;
	end;
end;


begin		(* code de lire_scenarios *)
nb_regle := 0;
nb_libelle := 0;

err := 0;
assign(scenario , 'journal.txt');
(*$i-*) reset(scenario); (*$i+*)
if ioresult <> 0
then	begin
	writeln(output,'ou as tu mis le fichier journal.txt ?');
	read(car); readln;
	halt;
	end;

while not eof(scenario) do
	begin
	lire_phrase;

	ouet := ou;
	q := pos('>=' , phrase);
	if q <> length(phrase)-1
	then	begin
		q := pos('>:=' , phrase);
		if q <> 0
		then	ouet := et;
		end;
	if q <> 0
	then	begin
		mot := copy(phrase,2,q-2);
		q := chercher_regle(mot);
		if q <> 0
		then	begin
			writeln(output,'la regle ', mot , ' est déja définie');
			end
		else	begin
			nb_regle := nb_regle + 1;
			l:=length(mot);
			(* getmem(regles[nb_regle].nom_regle,l+2);   *)
			regles[nb_regle].nom_regle := mot;
			regles[nb_regle].premier := 0;
			regles[nb_regle].etou := ouet;
			regles[nb_regle].nombre := 0;
			end;
		end;
	end;
close(scenario);
writeln(output,'        frappez fin');
read(car); readln;

assign(scenario , 'journal.txt');
reset(scenario);
num_regle := 0;
while not eof(scenario) do
	begin
	lire_phrase;
	q := pos('>=' , phrase);
	if q <> length(phrase)-1
	then	q := pos('>:=' , phrase);
	if q <> 0
	then	begin
		mot := copy(phrase,2,q-2);
		num_regle := num_regle + 1;
		prec_libelle := 0;
		fin_regle := false;
		while not fin_regle do
			begin
			if eof(scenario)
			then	fin_regle := true
			else	lire_libelle;
			end;
		end;
	end;
close(scenario);
for q:=1 to nb_libelle do
	begin
	phrase := libelles[q].generation;
	verifier;
	end;

if err <> 0
then	begin
	write(output,'        frappez return');
	read(car); readln;
	end;
end;

procedure inventer(mot : tstring);
var	num_regle: integer;
	phrase	: tstring;
	i	: integer;
	num	: integer;
	num_lib	: integer;

procedure editer_libelle(nu_lib : integer);
var	goon	: integer;
	phrase	: tstring;
	i	: integer;
	car	: char;

procedure scan(stop : char);
var	car	: char;
begin
mot := '';
i:= i + 1;
car := phrase[i];
while car <> stop do
	begin
	mot := mot + car;
	if i = length(phrase)
	then	begin
		car := stop;
		writeln(output,'le ',stop,' manque dans ',phrase);
		end
	else	begin
		i := i+1;
		car := phrase[i];
		end;
	end;
end;

procedure putcar(car : char);
begin
if car = chr(9)
then	write(output,'        ')
else	begin
	if (car = ' ') and (nbcar>=70)
	then	begin
				nbcar:=0;
				writeln(output);
				end
	else	begin
        write(output,car);
        nbcar:=nbcar+1;
        end;
	end;
end;

procedure traiter_car;
var	j,l,q	: integer;
	nu_var	: integer;
	nu_regle: integer;
	cond	: boolean;
	val_var	: tstring;
	mo	: tstring;
	val	: tstring;
	cor	: char;
begin
case car of
	'<' :	begin
		scan('>');
		if (pos('var ',mot) = 1)
		or (mot[1] in ['0'..'9'])
		then	begin
			nu_var := chercher_variable(mot);
			if nu_var = 0
			then	writeln(output,'la variable ',
					mot, ' n''est pas d‚finie')
			else	begin
				editer_libelle(variables[nu_var].lib_variable);
				end;
			end
		else	begin
			nu_regle := chercher_regle(mot);
			if nu_regle = 0
			then	writeln(output,'la regle ',mot ,
					' n''est pas d‚finie')
			else	begin
				inventer(mot);
				end;
			end;
		end;
	'[' :	begin
		scan(']');
		if pos('si ',mot) = 1
		then	begin
			cond := false;
			l := length(mot);
			mot := copy(mot , 4 , l-3);
			q := pos('=' , mot);
			if q = 0
			then	q := pos('#' , mot);
			if q = 0
			then	begin
				if pos('non ',mot) <> 0
				then	begin
					l:=length(mot);
					mot := copy(mot,5,l-4);
					q:=0;
					end
				else	q:=1;
				nu_var := chercher_variable(mot);
				if nu_var <> 0
				then	cond := true;
				if q=0
				then	cond := not cond;
				end
			else	begin
				mo := copy(mot,1,q-1);
				val := copy(mot,q+1,l-q);
				nu_var := chercher_variable(mo);
				if nu_var <> 0
				then	begin
		val_var := libelles[variables[nu_var].lib_variable].generation;
					if mot[q]='='
					then	begin
						if val_var = val
						then	cond := true;
						end
					else	begin
						if val_var <> val
						then	cond := true;
						end;
					end;
				end;
			if not cond
			then	i := 1000;
			end
		else	begin
			if random(2) = 1
			then	begin
				if mot = ''
				then	i := 1000
				else	begin
					inventer(mot);
					end;
				end;
			end;
		end;
	'=' :	begin
		scan('=');
		nu_var := chercher_variable(mot);
		if nu_var = 0
		then	begin
			nb_variable := nb_variable + 1;
			nu_var := nb_variable;
			variables[nu_var].nom_variable := mot;
			end;
		variables[nu_var].lib_variable := last_libelle;
		end;
	'&' :	begin
				writeln(output);
				nbcar:=0;
				end;
	'æ' :	begin
		nbcar:=0;
		writeln(output);
		writeln(output);
		writeln(output,'          frappez return');
		read(car); readln;
		end;
	else	begin
		putcar(car);
		end;
	end;
end;


begin			(* debut de editer_libelle *)
goon := nu_lib;
while goon <> 0 do
	begin
	phrase := libelles[goon].generation;
	i := 0;
	while i < length(phrase) do
		begin
		i := i + 1;
		car := phrase[i];
		traiter_car;
		end;
	goon := libelles[goon].suite;
	end;
end;

begin		(* début de inventer *)
num_regle := chercher_regle(mot);
if num_regle = 0
then	writeln(output,'la regle ', mot, ' n''est pas définie')
else	begin
	with regles[num_regle] do
		begin
		if etou = ou
		then	begin
			if nombre = 1
			then	num := 1
			else	num := random(nombre) + 1;
			num_lib := premier;
			for i := 1 to num-1 do
				num_lib := libelles[num_lib].suivant;
			last_libelle := num_lib;
			editer_libelle(num_lib);
			end
		else	begin
			num_lib := premier;
			for i := 1 to nombre do
				begin
				last_libelle := num_lib;
				editer_libelle(num_lib);
				num_lib := libelles[num_lib].suivant;
				end;
			end;
		end;
	end;
end;

procedure generer(mot : tstring);
begin
nb_variable := 0;
inventer(mot);
end;

procedure trait;
var car : char;

        begin
        writeln('bonjour');
        lire_scenarios;
        writeln('coucou');
        read(car);readln;
				randomize;
        car:='a';
        writeln;
        writeln('choisir :');
        while (car <>'0') do
          begin
          writeln(output , '     1   un conte');
					writeln(output , '     2   un poème');
					writeln(output , '     3   une pièce de théatre');
					writeln(output , '     4   un proverbe');
					writeln(output , '     5   un titre de journal');
					writeln(output , '     6   une histoire quelconque');
					writeln(output , '     0   fin');
          read(car);readln;
          nbcar:=0;
          case car of
						'0','à'	: begin
                    car:='0';
										end;
						'1','&'	: generer('conte');
						'2','é'	: generer('poème');
						'3','"'	: generer('pièce');
						'4','''': generer('proverbe');
						'5','('	: generer('journal');
						'6','-'	: generer('histoire');
						else	boucle := true;
						end;
          writeln;
          end;
        end;
end.
