attach_console_x

Author: TeamSPoon

prolog/metta_lang/metta_interp.pl

@@ -781,6 +781,8 @@
 % This directive allows the predicate `original_user_output/1` to be modified during runtime.
 :- dynamic(original_user_output/1).
 
+
+
 %!  original_user_output(-X) is nondet.
 %
 %   Retrieves the stream associated with the standard output (file descriptor 1).
@@ -793,6 +795,8 @@
 %   @example
 %     ?- original_user_output(Stream).
 %     Stream = <stream>.
+
+original_user_output(X) :- thread_self(Id), thread_util:has_console(Id, _, X, _),!.
 original_user_output(X) :- stream_property(X, file_no(1)).
 
 %!  original_user_error(-X) is nondet.
@@ -807,6 +811,7 @@
 %   @example
 %     ?- original_user_error(Stream).
 %     Stream = <stream>.
+original_user_error(X) :- thread_self(Id), thread_util:has_console(Id, _, _, X),!.
 original_user_error(X) :- stream_property(X, file_no(2)).
 
 % Ensure that the original output stream is set if not already defined.
@@ -2343,6 +2348,7 @@
 :- ensure_loaded(metta_convert).
 :- ensure_loaded(metta_types).
 :- ensure_loaded(metta_space).
+:- ensure_loaded(metta_threads).
 :- ensure_loaded(metta_eval).
 :- nb_setval(self_space, '&top').
 

prolog/metta_lang/metta_repl.pl

@@ -296,9 +296,9 @@
 set_metta_prompt:-
     with_output_to(atom(P), write_metta_prompt),
     %prompt1(P),
-    prompt(_, P).
-
+    metta_prompt(_, P).
 
+metta_prompt(G,S):- once(nb_current('$metta_prompt',G);prompt(G,G)),nb_setval('$metta_prompt',S),prompt(_,S).
 
 %! repl4 is det.
 %   Executes the REPL logic by reading the input, processing expressions, and handling directives or commands.
@@ -575,8 +575,8 @@
 % Read the next line of input, accumulate it, and continue processing.
 repl_read_next(Accumulated, Expr) :-
     if_t(flag(need_prompt,1,0),(format('~N'),set_metta_prompt)),
-        % On windows we need to output the prompt again
-    (is_win64-> (ttyflush,prompt(P, P),write(P), ttyflush) ; true),
+        % On windows we need to output the prompt again ; and now on linux since the prompt we are settign is ''
+    maybe_write_prompt_now,
     % Read a line from the current input stream.
     read_line_to_string(current_input, Line),
     % switch prompts after the first line is read
@@ -592,10 +592,15 @@
     % Concatenate the accumulated input with the new line using a space between them.
     symbolics_to_string([Accumulated, "\n", Line], NewAccumulated), !,
     % Continue reading and processing the new accumulated input.
-    format(atom(T),'| ~t',[]),prompt(_,T),
+    format(atom(T),'| ~t',[]),metta_prompt(_,T),
     repl_read_next(NewAccumulated, Expr).
 
 
+maybe_write_prompt_now:- is_win64,!,metta_prompt(P, P),write_prompt_now(P).
+maybe_write_prompt_now:- thread_self(main),!.
+maybe_write_prompt_now:- metta_prompt(P, P),write_prompt_now(P),prompt(_, '').
+
+write_prompt_now(P):- flush_output(current_output), ttyflush, write(P), ttyflush, flush_output(current_output).
 
 % if stream error is not recoverable restart_reading
 check_unbalanced_parens(SE):- var(SE),!. % no error

prolog/metta_lang/metta_server.pl

@@ -215,9 +215,9 @@
             % Open the socket as a stream
             tcp_open_socket(RemoteFd, Stream),
             % Generate a unique symbol for the thread alias
-            nb_setval(self_space,MSpace),
+           (nb_setval(self_space,MSpace),
             % Handle the connection by processing incoming goals
-            ignore(handle_vspace_peer(Stream)),
+            ignore(handle_vspace_peer(Stream))),
             % Ensure the stream is closed when done
             catch(close(Stream),_,true)
             ),

prolog/metta_lang/metta_threads.pl

@@ -816,10 +816,14 @@
 
 mc_unit(repl_x):- repl_x.
 
+
+can_open_console_x:- getenv('DISPLAY', _),
+    absolute_file_name(path(xterm), _XTerm, [access(execute)]).
+
 repl_x :-
     repl_x(_).
 
-repl_x(Title) :- can_open_console, !,
+repl_x(Title) :- can_open_console_x, !,
     thread_self(Me),
     thread_create(thread_run_repl_x(Me, Title),
                   _Id,
@@ -833,20 +837,70 @@
     ->  fail
     ).
 repl_x(Title) :-
+    print_message(error, cannot_attach_console_x(Title)),
+    fail.
+
+
+thread_has_console_x :- current_prolog_flag(break_level, _), !.
+thread_has_console_x :- thread_self(Id), thread_has_console_x(Id), !.
+thread_has_console_x(main) :- !.
+thread_has_console_x(Id) :- thread_util:has_console(Id, _, _, _).
+
+console_title_x(Thread, Title) :-
+    current_prolog_flag(console_menu_version, qt), !, human_x_id(Thread, Id),
+    format(atom(Title), 'Thread ~w', [Id]).
+console_title_x(Thread, Title) :-
+    current_prolog_flag(system_thread_id, SysId), human_x_id(Thread, Id), format(atom(Title),
+    'MeTTa Thread ~w (~d) X-REPL', [Id, SysId]).
+
+human_x_id(Thread, Id) :- atom(Thread), !, Id=Thread.
+human_x_id(Thread, Id) :- thread_property(Th, alias(Id)), (Th==Thread; Thread==Id), !.
+human_x_id(Thread, Id) :- thread_property(Th, id(Id)), (Th==Thread; Thread==Id), !.
+human_x_id(Thread, Id) :- format(atom(Id),'~q',[Thread]), !.
+
+
+attach_console_x :- attach_console_x(_).
+
+attach_console_x(_) :- thread_has_console_x, !.
+attach_console_x(Title) :- can_open_console_x, !,
+    thread_self(Id),
+    (   var(Title)
+    ->  console_title_x(Id, Title)
+    ;   true
+    ),
+    thread_util:open_console(Title, In, Out, Err),
+    assert(thread_util:has_console(Id, In, Out, Err)),
+    set_stream(In, alias(user_input)),
+    set_stream(Out, alias(user_output)),
+    set_stream(Err, alias(user_error)),
+    set_stream(In, alias(current_input)),
+    set_stream(Out, alias(current_output)),
+    thread_util:enable_line_editing(In, Out, Err),
+    thread_at_exit(detach_console_x(Id)).
+attach_console_x(Title) :-
     print_message(error, cannot_attach_console(Title)),
     fail.
 
+detach_console_x(Id) :-
+    (   retract(thread_util:has_console(Id, In, Out, Err))
+    ->  thread_util:disable_line_editing(In, Out, Err),
+        close(In, [force(true)]),
+        close(Out, [force(true)]),
+        close(Err, [force(true)])
+    ;   true
+    ).
+
 
 thread_run_repl_x :-
     set_prolog_flag(query_debug_settings, debug(false, false)),
-    attach_console(_Title),
+    attach_console_x(_Title),
     print_message(banner, thread_welcome),
-    prolog.
+    repl.
 
 thread_run_repl_x(Creator, Title) :-
     set_prolog_flag(query_debug_settings, debug(false, false)),
     Error=error(Formal, _),
-    (   catch(attach_console(Title), Error, true)
+    (   catch(attach_console_x(Title), Error, true)
     ->  (   var(Formal)
         ->  thread_send_message(Creator, title(Title)),
             print_message(banner, thread_welcome),

prolog/metta_lang/metta_transpiled_header.pl

@@ -90,11 +90,9 @@
 :- dynamic(metta_atom_asserted_last/2).
 :- multifile(metta_atom_asserted_last/2).
 
-
-%:- initialization(maybe_load_history, now).
-
-    %:- ensure_loaded(library(metta_lang/metta_interp)).
+:- time(ensure_loaded(library(metta_lang/metta_interp))).
 :- ensure_loaded(library(metta_rt)). % avoids starting the REPL
+:- initialization(maybe_load_history, now).
 :- setup_library_calls.
 :- dynamic(top_call/0).
 :- multifile(top_call/0).