migma.pl

Migma intends to help teachers to get several different multiple-choice exams based on the user?s or

get_out_name(['-o',Name|_],_,Name).

get_out_name(['--o',Name|_],_,Name).

get_out_name([_|As],Default,Name):-
	%write('dbg get_out_name std'), nl,
	get_out_name(As,Default,Name).

find_name(L,Name):-
	last(L,Name).

get_name_ext(Complete,Name,Ext):-
	atom_chars(Complete,Lcomp),
	get_name_ext2(Lcomp,Lname,Lext),
	atom_chars(Name,Lname),
	atom_chars(Ext,Lext). % nl,write(Name),nl,write(Ext).

get_name_ext2(L,Lname,L2):-
	get_name_ext2(L,[],Lnamex,L2),
	reverse(Lnamex,Lname).

get_name_ext2([],Lname,Lname,[]).

get_name_ext2([.|B],Lname,Lname,B).

get_name_ext2([A|B],S,R,L2):-
	append([A],S,S2),
	get_name_ext2(B,S2,R,L2).
	
read_alt(L):-
	initiate,
	%argument_list(L),
	find_name(L,Name),
	io(Name,L2),
	read_ans_sheet(L2,Lg),
	ans_sheet(Answer_sheet),
	treats(Lg,Answer_sheet,0,0),
	getN(L,N),
	number_atom(NN,N),
	extern_alt(NN,L).

read_quest(L):-
	initiate,
	%argument_list(L),
	find_name(L,Name),
	io(Name,L2),
	read_ans_sheet(L2,Lg),
	ans_sheet(Answer_sheet),
	treats(Lg,Answer_sheet,0,0),
	getN(L,N),
	number_atom(NN,N),
	extern_que(NN,L).
	
read_all(L):-
	initiate, 
	%argument_list(L),
	find_name(L,Name),
	io(Name,L2),
	read_ans_sheet(L2,Lg),
	ans_sheet(Answer_sheet),
	%write('dbg - vou para o treats'), nl,
	treats(Lg,Answer_sheet,0,0),
	%write('dbg - vou para o mix_alt'), nl, 
	getN(L,N),
	number_atom(NN,N),
	%nl,nl,write(NN),nl,nl,
	extern_all(NN,L).

test_type(N,number):-
	number(N).

test_type(N,atom):-
	atom(N).

extern_alt(0,_).

extern_alt(N,L):- 
	T is N-1,
	%write('dbg extern alt'), write(N),nl,
	mix_alt,
	!,
	save_all(N),
	save_adt(N),
	retractall(q2(_,_,_,_)),
	extern_alt(T,L).

extern_que(0,_).

extern_que(N,L):- 
	T is N-1,
	%write('dbg extern que'), write(N),nl,
	mix_alt,
	mix_quest,
	!,
	save_all(N),
	save_adt(N),
	retractall(q2(_,_,_,_)),
	extern_que(T,L).

extern_all(0,_).

extern_all(N,L):- 
	T is N-1,
	%write('dbg extern all'), write(N),nl,
	mix_alt,
	mix_quest,
	!,
	save_all(N),
	save_adt(N),
	retractall(q2(_,_,_,_)),
	extern_all(T,L).

read_ans_sheet([A,B,C,D,E,F,G|Gs],V):-
	[A] == "\\",
	[B] == "i",			 
	[C] == "n",
	[D] == "i",
	[E] == "g",
	[F] == "a",
	[G] == "b",
	%write('dbg read_ans_sheet \\inians_sheet'), nl,
	read_as(Gs,R,V),
	asserta(ans_sheet(R)),
	asserta(ans_sheet_fix(R)).
	
read_ans_sheet([_|B],V):-
	%write('dbg read_ans_sheet std'), nl,
	read_ans_sheet(B,V).	

read_as(L,R,V):-
	%mostrador(L),
	read_as(L,[],Rx,V),
	reverse(Rx,R). %,nl,nl, write(R),nl,nl.

read_as([A,B,C,D,E,F,G|Gs],R,R,Gs):-
   	[A] == "\\",
	[B] == "f",			 
	[C] == "i",
	[D] == "m",
	[E] == "g",
	[F] == "a",
	[G] == "b".

read_as([A|Gs],S,R,V):-
	[A] == "a",
	append([1],S,S2),
	read_as(Gs,S2,R,V).

read_as([A|Gs],S,R,V):-
	[A] == "b",
	append([2],S,S2),
	read_as(Gs,S2,R,V).

read_as([A|Gs],S,R,V):-
	[A] == "c",
	append([3],S,S2),
	read_as(Gs,S2,R,V).

read_as([A|Gs],S,R,V):-
	[A] == "d",
	append([4],S,S2),
	read_as(Gs,S2,R,V).

read_as([A|Gs],S,R,V):-
	[A] == "e",
	append([5],S,S2),
	read_as(Gs,S2,R,V).

read_as([_|Gs],S,R,V):-
	read_as(Gs,S,R,V).	

mostrador([]).

mostrador([A|B]):-
	atom_codes(X,[A]),
	write(X),
	mostrador(B).

treats([],_,_,_).

treats(L1,[G|Gs],Nq,Nalt):-
	Tq is Nq+1,
	T1 is Nalt+1,
	T2 is Nalt+2,
	T3 is Nalt+3,
	T4 is Nalt+4,
	T5 is Nalt+5,
	%write('dbg treats main'), nl,
	read_quest(L1,Tq,G,Nalt,L2),
	%write('dbg treats 1'), nl,	
	read_alternat(L2,T1,[],RF1,L3),
	%write('dbg treats 2'), nl,	
	read_alternat(L3,T2,[],RF2,L4),
	%write('dbg treats 3'), nl,	
	read_alternat(L4,T3,[],RF3,L5),
	%write('dbg treats 4'), nl,	
	read_alternat(L5,T4,[],RF4,L6),
	%write('dbg treats 5'), nl,	
	read_alternat(L6,T5,[],RF5,L7),
	%write('dbg treats 6'), nl, mostrador(L7),
	q(Q,Lq,Lf,C),
	append(RF1,RF2,F1),
	append(RF3,RF4,F2),
	append(Lf,RF5,F3),
	append(F1,F2,F4),
	append(F3,F4,Rfinal),
	%write('dbg rfinal= '), atom_codes(Rf, Rfinal), write(Rf), nl,	
	retract(q(Q,Lq,Lf,C)),
	assertz(q(Q,Lq,Rfinal,C)),
	!,
	treats(L7,Gs,Tq,T5).

read_quest(L1,N,G,Nalt,L2):-
	%write('dbg read_quest'), nl,
	sel_openq(L1,T),!,
	treats_quest(T,N,G,Nalt,L2).

read_alternat(L,N,SF,RF,Lx):-
	%write('dbg read_alternat'), nl,
	treats_altern(L,N,SF,RF,Lx).

sel_openq([],[]).

sel_openq([A,B,C,D|Xs],Xs):- %seletor: leitura de questao
	[A] == "\\",
	[B] == "q",			 
	[C] == "u",
	[D] == "e".

sel_openq([_|Xs],R):-
	%write('dbg sel_openq std '),nl,% atom_codes(AA,[A]), write(AA), nl,
	sel_openq(Xs,R).

treats_quest(T,N,G,Nalt,L2):-
	treats_quest(T,[],Rx,G,Nalt,L2),
	reverse(Rx,R),
	!,
	atom_codes(L1,R),
	asserta(question(N,L1)),
	A1 is Nalt+1,
	A2 is Nalt+2,
	A3 is Nalt+3,
	A4 is Nalt+4,
	A5 is Nalt+5,
	conv_ans_sheet(Nalt,G,Gn),
	asserta(q(N,[A1,A2,A3,A4,A5],[],Gn)). 

conv_ans_sheet(Nalt,1,R):-
	R is Nalt+1.

conv_ans_sheet(Nalt,2,R):-
	R is Nalt+2.

conv_ans_sheet(Nalt,3,R):-
	R is Nalt+3.

conv_ans_sheet(Nalt,4,R):-
	R is Nalt+4.

conv_ans_sheet(Nalt,5,R):-
	R is Nalt+5.

treats_quest([A,B,C,D,E|X],R,R,_,_,X):- % transicao questao-alternativa
	[A] == "\\",
	[B] == "i",			 
	[C] == "t",
	[D] == "e",
	[E] == "m".
	
treats_quest([A|B],S,R,G,Nalt,X):-
	%write('dbg treats_quest std'), nl,
	append([A],S,S2),
	treats_quest(B,S2,R,G,Nalt,X).

treats_altern([],_,RF,RF,[]).

treats_altern(L,N,SF,RF,Lx):-
	treats_altern(L,[],Rx,SF,RF,N,Lx),
	reverse(Rx,R),
	atom_codes(R2,R),
	assertz(answer(N,R2)).

treats_altern([],R,R,RF,RF,_,[]).

treats_altern([A,B,C,D,E|X],R,R,SF,RF,N,X):- % alternative-fix transition 
	[A] == "\\",
	[B] == "f",			 
	[C] == "i",
	[D] == "x",
	[E] == "o",
	%write('dbg treatsalternat fixo'), nl,
	N1 is N+1,
	append([N1],SF,RF).

treats_altern([A,B,C,D|X],R,R,RF,RF,_,[A,B,C,D|X]):- % alternative or fix - question transition
	[A] == "\\",
	[B] == "q",			 
	[C] == "u",
	[D] == "e".
	%write('dbg treatsalternat que'), nl.

treats_altern([A,B,C,D,E|X],R,R,RF,RF,_,X):- % alternative-alternative transition
	[A] == "\\",
	[B] == "i",			 
	[C] == "t",
	[D] == "e",
	[E] == "m".
	%write('dbg treatsalternat item'), nl.

treats_altern([A|B],S,R,SF,RF,N,L):-
	!,
	%write('dbg treatsalternat std'), nl,
	append([A],S,S2),
%	nl,nl,mostrador(S2),nl,nl,
	treats_altern(B,S2,R,SF,RF,N,L).

convertion(a,1).

convertion(b,2).

convertion(c,3).

convertion(d,4).

convertion(e,5).

name_prepare(Name,Ext,Name):-
	atom_chars(Ext,[]).

name_prepare(Name,Ext,R):-
	atom_concat(Name,'.',T),
	atom_concat(T,Ext,R).

convert_q_to_q2:-
	findall((A,B,C,D),(q(A,B,C,D), assertz(q2(A,B,C,D))),_).

flattening(Lx,Ly):-
	flattening(Lx,[],Ly).

flattening([X|Xs],Lt,Ly):-
	flattening(Xs,Lt,Ly1),
	flattening(X,Ly1,Ly).

flattening(X,Xs,[X|Xs]):-
	nonvar(X),
	X \= [].

flattening([],Xs,Xs).

save_correct([],_).

save_correct([A|As],Adt):-
	write(Adt,A),
	nl(Adt),
	save_correct(As,Adt).

save_all(N):-
	number(N),
	number_atom(N,NN),
	findall((Nq,Tq,C), q2(Nq,Tq,_,C),L1),
	%nl,nl,nl,nl,listing(q2),nl,nl,nl,nl,
	sort(L1,Lq),
	get_out_name(FileName,FileExt),
	atom_concat(FileName,NN,NameNum),
	name_prepare(NameNum,FileExt,Name),
	%write(FN),nl,
	assertz(outfiles(Name)),
	open(Name,write,P),
%	write('Name='), write(Name),nl,write('P='),write(P),nl,
	%write('dbg save'), nl,
	save_ans_sheet(Lq,P),!,
        test_tex(P,Lq),
	%write('Lqsall='),write(Lq),nl,
	close(P).

test_tex(P,Lq):-
        argument_list(L),
        \+ member('-nolatex',L),
        \+ member('--nolatex',L),
	%write('dbg test_tex'), nl,
	write(P,'\\begin{enumerate}'),
	nl(P),
	save_tex(Lq,P),
	write(P,'\\end{enumerate}'),
	nl(P).

test_tex(P,Lq):-
        save_no_tex(Lq,P).

save_tex([],_).

save_tex([(Q1,_,_)|Qs], P):-
	filt(Q1,Q),
	q2(Q,Lq,_,_),
	%write('Q='),write(Q),write(' Lq2='),write(Lq),nl,
	save_tex(Q,Lq,P),
	%write('dbg save_tex std'), nl,	
	save_tex(Qs,P).

save_tex(Q,[A1,A2,A3,A4,A5],P):-
	question(Q,TQ),
	answer(A1,T1),
	answer(A2,T2),
	answer(A3,T3),
	answer(A4,T4),
	answer(A5,T5),
	write(P, '\\item'),
	write(P, TQ),
	write(P, '\\begin{enumerate}'),
	nl(P),
	write(P, '   \\item'),
	write(P, T1),
	write(P, '   \\item'),
	write(P, T2),
	write(P, '   \\item'),
	write(P, T3),
	write(P, '   \\item'),
	write(P, T4),
	write(P, '   \\item'),
	write(P, T5),
	write(P, '\\end{enumerate}'),
	nl(P),
	nl(P).

save_no_tex([],_).

save_no_tex([(Q1,_,_)|Qs], P):-
	filt(Q1,Q),
	q2(Q,Lq,_,_),	
	save_no_tex(Q,Lq,P),
	%write('dbg save_no_tex std'), nl,
	save_no_tex(Qs,P).

save_no_tex(Q,[A1,A2,A3,A4,A5],P):-
	question(Q,TQ),
	filt(Q1,Q),
	answer(A1,T1),
	answer(A2,T2),
	answer(A3,T3),
	answer(A4,T4),
	answer(A5,T5),
	write(P, Q1),
	write(P, '-'),
	write(P, TQ),
	write(P, 'a) '),
	write(P, T1),
	write(P, 'b) '),
	write(P, T2),
	write(P, 'c) '),
	write(P, T3),
	write(P, 'd) '),
	write(P, T4),
	write(P, 'e) '),
	write(P, T5),
	nl(P), 
        nl(P).

save_ans_sheet(L,P):-
	ans_sheet(_),
%	write(P, '%answer_sheet= '),
	write(P, '%\\inigab '),
	%write('dbg save_ans_sheet std'), nl,
	save_ans_sheet1(L,P),
	write(P, ' \\fimgab'),
	nl(P).

save_ans_sheet1(L,P):-
	save_ans_sheet1(L,0,[],Rx,P),
	reverse(Rx,R),
	asserta(ans_sheet_fix(R)).

save_ans_sheet1([],_,R,R,_).

save_ans_sheet1([(Q1,_,_)|Qs],N,S,R,P):-
	T is N+1,
	filt(Q1,Q),
	q2(Q,Lista,_,C),
	write(P,T),
	nth(I,Lista,C), 
	convertion(Letra,I),
	write(P,Letra),
	write(P,' '),
	append([I],S,S2),
	save_ans_sheet1(Qs,T,S2,R,P).

filt_creation([],[]).

filt_creation([A|As],[B|Bs]):-
	asserta(filt(A,B)),
	filt_creation(As,Bs).

mix_quest:-
	findall(Q,q2(Q,_,_,_),L1),
	sort(L1,L2),
	%write('dbg mix_quest0'), nl,
	%newlist(L2,L3),
	min_list(L2,L2min),
	max_list(L2,L2max),
	rnd_list(L2min,L2max,L3),
	retractall(filt(_,_)),
	filt_creation(L2,L3).

mix_quest([],_,G,G).

mix_quest([Q|Qs],N,S,G):-
	T is N+1,
	q(Q,_,_,C),
	append(S,[(N,C)],S2),
	%write('dbg mix_quest std'), nl,
	mix_quest(Qs,T,S2,G).

mix_alt:-
	argument_list(AL),
	\+ member('-q',AL),
	\+ member('--q',AL),
	findall((Q,L,C),q(Q,L,_,C),L1),
	sort(L1,L2),
	%write('L1alt='),write(L1),nl,
	%write('dbg mix_alt0a'), nl,
	mix_alt(L2).

mix_alt:-
	findall((Q,L,Fixo,C),q(Q,L,Fixo,C),L1),
	sort(L1,L2),
	%write('dbg mix_alt0b'), nl,
	mix_alt2(L2).

mix_alt2([]).

mix_alt2([(Name,L,Fixo,C)|Rest]):-
	assertz(q2(Name,L,Fixo,C)),