;-----------------------------------------------------------------------
; Modulo de Input Output
;
; 1. Leitura de STR e INT
;     lerstr : prompt -> string nao vazia e incluindo
;     lerint : prompt -> inteiro
;     lerany : prompt -> any      (* str entre "",inteiros, Sexp *)
;     lersetstr : prompt -> set of STR (* terminar com "." *)
;     lerset : prompt -> set of ANY    (* terminar com "." *)
;     lerfixdomff : ANY-set -> ffanyany
;
; 3. Escolha interactiva de um elemento dum SET, LIST, FF:
;     pickone : (ANY-set | ANY-list | ANY-> ANY) -> ANY
;     ppickone : (ANY-set | ANY-list | ANY-> ANY) x prompt -> ANY
;     pickmany : (ANY-set | ANY-list | ANY-> ANY) -> ANY-set
;
; 4. Menu que associa opcoes a expressoes, menus, funcoes ou valores
;    Inteiros
;          menu: tmenu -> ANY   (resultado duma funcao, resultado do
;                                calculo de uma expressao, Inteiro ou
;                                resultado da exec. dum menu )
;          run : tmenu ->       (executa menu ate' escolher opcao 0)
;
;TYPE
;   tmenu =  titger : STR                /*     titulo do menu     */
;            opcoes_list : opcoes-list;  /*     lista das opcoes   */
;   opcoes =  titopc : STR               /*     tilulo da opcao    */
;             accao_op : taccao;  
;   taccao =  tmenu | SYM |INT | _exp;
;   _exp = ANY;
;ENDTYPE
;
;Exemplo de menu: 
;M <- tmenu("Menu geral",            /* accao = calculo de expressao */
;           <opcoes("conteudo deste menu",'(pp(M))),
;            opcoes("invocacao deste menu",'(menu(M)))>);
;            
;-----------------------------------------------------------------------

FUNC lerstr(str:STR ,(stdout)): STR 
STATE  ppn(str)
RETURN let( a=fgets())
       in if(a=="\n") then _l(fgets())
                      else _l(a);
_l(y)=let( z=strlen(y))
     in substr(y,1,sub(z,1));

FUNC lerint(str:STR ,(stdout)): INT
STATE  ppn(str)
RETURN let( a=read())
       in if(type(a)=='INT) 
          then a
          else lerint(str);

lersetstr(str)=do(ppn(str),
                   let(a=lerstr("?- ")) 
                   in if (a == ".")
                      then {}
                      else {a} U lersetstr(" "));

metoo
(def FIM '.)
endmetoo

lerset(str)=do(ppn(str),
                   let(a=read()) 
                   in if (a == FIM )
                      then {}
                      else {a} U lerset("? "));

FUNC pickone(m1:ANY-set):ANY
RETURN
    let( m=if(is-(ANY-set)(m1)  -> < x | x <- m1 >,
              is-(ANY-seq)(m1) -> m1 ,
              is-(ANY->ANY)(m1)   -> < [x -> m1[x]] | x <- dom(m1) >),
         a1=do(
            princ("\n--------------------------------------------------\n\t"),
            { princ (x," ",el(x,m),"\n\t") | x <- inds(m) },
            _b<- if(length(m)==0 -> 0 ,
                    else -> leropcao("\nqual destes? ")),
            while(( _b > length(m))||(_b<0),_b <-leropcao("qual destes ? ")),
            princ("\n--------------------------------------------------\n")))
    in if(_b==0) then NIL
                 else el(_b,m);

FUNC pickmany(m1:ANY-set):ANY-set
RETURN
    let( m=if('SET == type(m1)  -> < x | x <- m1 >,
              'LIST == type(m1) -> m1 ,
              'FF == type(m1)   -> < [x -> m1[x]] | x <- dom(m1) >),
         a1=do(
            princ("\n--------------------------------------------------\n\t"),
            { princ (x," ",el(x,m),"\n\t") | x <- inds(m) }))
    in { el(b,m) | b<- lerset("\nquais destes (. para terminar)\n ? ")};

FUNC ppickone(m1:ANY-set,s:STR):ANY
RETURN
    let( m=if(is-(ANY-set)(m1)  -> < x | x <- m1 >,
              is-(ANY-seq)(m1) -> m1 ,
              is-(ANY->ANY)(m1)   -> < [x -> m1[x]] | x <- dom(m1) >),
         a1=do(
            princ("\n--------------------------------------------------\n\t"),
            { princ (x," ",el(x,m),"\n\t") | x <- inds(m) },
            _b<- if(length(m)==0 -> 0 ,
                    else -> leropcao(strcat("\n",s))),
            while(( _b > length(m))||(_b<0),_b <-leropcao(strcat("\n",s))),
            princ("\n--------------------------------------------------\n")))
    in if(_b==0) then NIL
                 else el(_b,m);

lerany(p)=do(ppn(p),read());

FUNC lerfixdomff(e:ANY-set):ffanyany
RETURNS [ x -> lerany(x) | x <- e ];

/*-----------------------------------------------------------------*/
/* Menus  */
;          pickone 
;          menu
;          run 

leropcao (x)=let(a=lerstr(x))
            in if(a=="\e\n") then 0
                             else atoi(a);

TYPE
   tmenu =  titger : STR                /*     titulo do menu     */
            opcoes_list : opcoes-list;  /*     lista das opcoes   */
   opcoes =  titopc : STR               /*     tilulo da opcao    */
             accao_op : taccao;  
   taccao =  tmenu | SYM |INT | _exp;
   _exp = ANY;
ENDTYPE

FUNC menu(m:tmenu):SYM
RETURN
    let( m1=opcoes_list(m),
         a1=do(
            princ("\n--------------------------------------------------"),
            princ("\n\t",titger(m),"\n\n\t"),
            { princ(x," ",titopc(el(x,m1)),"\n\t") | x <- inds(m1) },
            _b<- leropcao("\nqual a opcao? "),
            while(( _b > length(m1))||(_b<0),_b <-leropcao("qual a opcao? ")),
            princ("\n--------------------------------------------------\n")),
         acc= if( 0 != _b) then accao_op(el(_b,m1))
                              else _b )
    in if(
            'SYM == type(acc)   -> (eval(acc))() ,
            is-tmenu(acc) -> menu(acc),
            'LIST == type(acc)  -> eval(acc),
            'INT == type(acc)   -> acc )
       otherwise acc;

FUNC run (m:tmenu)
STATE while(let(x=menu(m))
            in if(x != 0) then do(pp(x),true)
                          else false);

_EDITOR <- "vi ";
_MORE <- "more < ";

FUNC vi(f)
STATE sh(strcat(_EDITOR, f))
returns nload(f);

;vcamila
metoo
( def vi. lambda ( ) (vi FILENAME))
( def cat. lambda ( ) (cat FILENAME))
( def test lambda ( )
  ( progn
    ( def _l1 ( lerstr "\".\" to end\n ? " ))
    ( while
      ( nequal _l1 "." )
      ( let
          ( ( f1 (fopen "_tmp1" "w"))
            ( x19 ( fputs _l1 f1)) 
            ( x20 (fclose f1))
            ( x ( sh  "seca _tmp1  _tmp" )))
         (if (equal x 0) 
             (let ( ( f ( fopen "_tmp" "r" ))
                    ( x1 ( pp ( m2read f ))))
                  ( fclose f ))
             (princ "error, try again ...\n")
         )
      )
      ( def _l1 ( lerstr "? " ))
    )
  )
)
endmetoo

FUNC nload(f:str)
state sh(strcat("seca ",f," _tmp"))
returns  load("_tmp");

sig()=pp(_ops);

types()={x | x <- oblist : type(eval(x)) == 'TYPE };

cat(f)= sh (strcat(_MORE,f));

FUNC help(simb)
pre is-SYM(simb) ->  " use: (help 'func) "
returns sh( strcat(_EDITOR ,"-R \"+/N :  ", symstr(simb) , "/\"  " ,HelpDir,
"nyag.hlp"));

func edit(s:SYM) 
pre is-SYM(s) ->  " use: (edit 'object) "
returns let(f=fopen("_tmp1","w"),
             l1=fputs(strcat(symstr(s), " <- "), f),
             l2=nwrite(f,eval(s)),
             l3=fputs(" ;\n",f),
             l4=fclose(f))
         in vi("_tmp1");

stsave(filename,State)=
    let(f=fopen(filename,"w"),
        l1= m2write(f,State))
    in fclose(f);

stload(filename)=
    let(f=fopen(filename,"r"),
        l1= m2read(f),
        l2= fclose(f))
    in l1;
;---------------------
HelpDir <- strcat("INCLUDEDIR","/") ;