Home Page
Site Map
Login/out
Message Board
Download(c) 2005-2025 XLOG Technologies AG
/**
* Warranty & Liability
* To the extent permitted by applicable law and unless explicitly
* otherwise agreed upon, XLOG Technologies AG makes no warranties
* regarding the provided information. XLOG Technologies AG assumes
* no liability that any problems might be solved with the information
* provided by XLOG Technologies AG.
*
* Rights & License
* All industrial property rights regarding the information - copyright
* and patent rights in particular - are the sole property of XLOG
* Technologies AG. If the company was not the originator of some
* excerpts, XLOG Technologies AG has at least obtained the right to
* reproduce, change and translate the information.
*
* Reproduction is restricted to the whole unaltered document. Reproduction
* of the information is only allowed for non-commercial uses. Selling,
* giving away or letting of the execution of the library is prohibited.
* The library can be distributed as part of your applications and libraries
* for execution provided this comment remains unchanged.
*
* Restrictions
* Only to be distributed with programs that add significant and primary
* functionality to the library. Not to be distributed with additional
* software intended to replace any components of the library.
*
* Trademarks
* Jekejeke is a registered trademark of XLOG Technologies AG.
*/
/***************************************************************/
/* Bootstrapped */
/***************************************************************/
/**
* S \= T: [ISO 8.2.3]
* The built-in succeeds when the Prolog terms S and T do not unify,
* otherwise the built-in fails.
*/
X \= Y :- X = Y, !, fail.
_ \= _.
/**
* \+ A: [ISO 8.15.1]
* The predicate succeeds when A fails.
*/
% \+(+Goal)
\+ A :- A, !, fail.
\+ _.
/**
* once(A): [ISO 8.15.2]
* The predicate succeeds once if A succeeds.
* Otherwise the predicate fails.
*/
% once(+Goal)
once(A) :- A, !.
/**
* repeat: [ISO 8.15.3]
* The predicate succeeds repeatedly indefinitely.
*/
% repeat
repeat.
repeat :- repeat.
/**
* findall(T, G, L): [ISO 8.10.1]
* The predicate succeeds in L with all T such that G succeeds.
*/
% findall(+Term, +Goal, -List)
findall(Template, Goal, List) :-
sys_find_init(State),
(Goal, sys_find_next(Template, State), fail; true),
sys_find_fini(State, List).
% sys_find_init(-State)
sys_find_init(X) :-
X = v(_,_),
C = [-|_],
change_arg(1, X, C),
change_arg(2, X, C).
% sys_find_next(+Term, +State)
sys_find_next(T, X) :-
C = [_|_],
copy_term(T, H),
change_arg(1, C, H),
arg(1, X, J),
change_arg(2, J, C),
change_arg(1, X, C).
% sys_find_fini(+State, -Term)
sys_find_fini(v(C,D), L) :-
change_arg(2, C, []),
arg(2, D, L).
/********************************************************************/
/* catch/3 and throw/1 */
/********************************************************************/
/**
* catch(G, E, F): [ISO 7.8.9]
* The built-in succeeds whenever G succeeds. If
* there was a non-urgent exception that unifies with E, the
* built-in further succeeds whenever F succeeds.
*/
% catch(+Goal, -Error, +Goal)
catch(A, Pattern, B) :-
sys_trap(A, Error, sys_error_handler(Error, Pattern, B)).
% sys_error_handler(+Error, +Goal)
sys_error_handler(Error, _, _) :-
sys_chain_head(Error, error(system_error(_),_)), sys_raise(Error).
sys_error_handler(Error, Pattern, B) :-
sys_chain_head(Error, Pattern), !, B.
sys_error_handler(Error, _, _) :-
sys_raise(Error).
% sys_chain_head(+Error, -Error)
sys_chain_head(cause(E, _), F) :- !, E = F.
sys_chain_head(E, E).
/**
* throw(E): [ISO 7.8.9]
* The predicate possibly fills the stack trace and then
* raises the exception E.
*/
% throw(+Term)
throw(B) :-
sys_fill_stack(B),
sys_raise(B).
% sys_fill_stack(+Term)
sys_fill_stack(Error) :-
var(Error), throw(error(instantiation_error, _)).
sys_fill_stack(error(_,Trace)) :- var(Trace), !,
sys_fetch_stack(Trace).
sys_fill_stack(warning(_,Trace)) :- var(Trace), !,
sys_fetch_stack(Trace).
sys_fill_stack(_).
% sys_fetch_stack(-List)
sys_fetch_stack(Trace) :-
os_task_current(Task),
findall(sys_including(F, S), sys_including(F, Task, S), Trace).
/********************************************************************/
/* ignore/1 and chain/2 */
/********************************************************************/
/**
* ignore(A):
* The predicate succeeds once if A succeeds.
* Otherwise the predicate succeeds.
*/
% ignore(Goal)
ignore(X) :- X, !.
ignore(_).
/**
* chain(A, B):
* The predicate succeeds whenever A and B succeed. If A throws
* an exception, then B is called once and an exception is chained.
*/
% chain(+Goal, +Goal)
chain(A, B) :-
sys_trap(A, E, sys_chain_error(E, B)), B.
% sys_chain_error(+Error, +Goal)
sys_chain_error(E, B) :-
sys_trap(B, F, sys_chain_raise(E, F)), sys_raise(E).
sys_chain_error(E, _) :-
sys_raise(E).
% sys_chain_raise(+Error, +Error)
sys_chain_raise(E, B) :-
sys_chain_concat(E, B, C), sys_raise(C).
% sys_chain_concat(+Error, +Error, -Error)
sys_chain_concat(cause(E, F), B, cause(E, C)) :- !, sys_chain_concat(F, B, C).
sys_chain_concat(E, B, cause(E, B)).
/********************************************************************/
/* once_cleanup/2 and setup_once_cleanup/3 */
/********************************************************************/
/**
* once_cleanup(G, C):
* setup_once_cleanup(S, G, C):
* The predicate succeeds once if G succeeds. The clean-up C is called
* when G fails, succeeds or throws an exception. The ternary predicate
* permits an initial shielded call of a setup S.
*/
% once_cleanup(+Goal, +Goal)
once_cleanup(G, C) :-
current_prolog_flag(async_mode, on), !,
shield(sys_once_cleanup(unshield(G), C)).
once_cleanup(G, C) :-
sys_once_cleanup(G, C).
% setup_once_cleanup(+Goal, +Goal, +Goal)
setup_once_cleanup(S, G, C) :-
current_prolog_flag(async_mode, on), !,
shield(sys_setup_once_cleanup(S, unshield(G), C)).
setup_once_cleanup(S, G, C) :-
sys_setup_once_cleanup(S, G, C).
% sys_setup_once_cleanup(+Goal, +Goal, +Goal)
sys_setup_once_cleanup(S, G, C) :-
S,
sys_once_cleanup(G, C).
% sys_once_cleanup(+Goal, +Goal)
sys_once_cleanup(G, C) :-
chain(G, ignore(C)), !.
sys_once_cleanup(_, C) :-
ignore(C), fail.
/****************************************************************/
/* Error Printing */
/****************************************************************/
% sys_print_error(+Error)
sys_print_error(Error) :-
current_error(Stream),
sys_print_error(Error, Stream).
% sys_print_error(+Error, +Stream)
sys_print_error(Error, Stream) :- var(Error), !,
sys_print_message('exception_unknown', Stream),
writeq(Stream, Error),
nl(Stream).
sys_print_error(cause(Primary, Secondary), Stream) :- !,
sys_print_error(Primary, Stream),
sys_print_error(Secondary, Stream).
sys_print_error(error(Message, Trace), Stream) :- !,
sys_print_message('exception_error', Stream),
sys_print_message(Message, Stream), nl(Stream),
sys_print_trace(Trace, Stream).
sys_print_error(warning(Message, Trace), Stream) :- !,
sys_print_message('exception_warning', Stream),
sys_print_message(Message, Stream), nl(Stream),
sys_print_trace(Trace, Stream).
sys_print_error(Error, Stream) :-
sys_print_message('exception_unknown', Stream),
writeq(Stream, Error),
nl(Stream).
% sys_print_trace(+List, +Stream)
sys_print_trace(Trace, Stream) :- var(Trace), !,
sys_print_message('exception_context', Stream),
writeq(Stream, Trace),
nl(Stream).
sys_print_trace([Frame|Trace], Stream) :- !,
sys_print_frame(Frame, Stream),
sys_print_trace(Trace, Stream).
sys_print_trace([], _) :- !.
sys_print_trace(Trace, Stream) :-
sys_print_message('exception_context', Stream),
writeq(Stream, Trace),
nl(Stream).
% sys_print_frame(+Term, +Stream)
sys_print_frame(sys_including(File, Include), Stream) :- atom(File), !,
file_base_name(File, Name),
ir_object_current(Include, 'lineno', Line),
sys_print_message(file_line(Name, Line), Stream), nl(Stream).
sys_print_frame(Frame, Stream) :-
sys_print_message(Frame, Stream), nl(Stream).
/****************************************************************/
/* Message Printing */
/****************************************************************/
% sys_print_message(+Term)
sys_print_message(Message) :-
current_error(Stream),
sys_print_message(Message, Stream).
% sys_print_message(+Term, +Stream)
sys_print_message(Message, Stream) :-
current_prolog_flag(sys_locale, Locale),
sys_print_message(Message, Stream, Locale).
% sys_print_message(+Term, +Stream, +Atom)
sys_print_message(Message, Stream, Locale) :- var(Message), !,
sys_print_message('exception_template', Stream, Locale),
writeq(Stream, Message).
sys_print_message(Message, Stream, Locale) :- Message =.. [Fun|Args],
atom(Fun),
get_string(Fun, Locale, Template), !,
sys_polate(Stream, Template, Args).
sys_print_message(Message, Stream, Locale) :- Message =.. [Fun, Type|Args],
atom(Fun), atom(Type),
atom_join([Fun,'.',Type], Key),
get_string(Key, Locale, Template), !,
sys_polate(Stream, Template, Args).
sys_print_message(Message, Stream, Locale) :- Message =.. [Fun, Type1, Type2|Args],
atom(Fun), atom(Type1), atom(Type2),
atom_join([Fun,'.',Type1,'.',Type2], Key),
get_string(Key, Locale, Template), !,
sys_polate(Stream, Template, Args).
sys_print_message(Message, Stream, Locale) :-
sys_print_message('exception_template', Stream, Locale),
writeq(Stream, Message).
/****************************************************************/
/* Type Checks */
/****************************************************************/
% sys_check_atom(+Term)
sys_check_atom(V) :- var(V),
throw(error(instantiation_error,_)).
sys_check_atom(A) :- atom(A), !.
sys_check_atom(A) :-
throw(error(type_error(atom,A),_)).
% sys_check_integer(+Term)
sys_check_integer(V) :- var(V),
throw(error(instantiation_error,_)).
sys_check_integer(I) :- integer(I), !.
sys_check_integer(I) :-
throw(error(type_error(integer,I),_)).
/***************************************************************/
/* Callback and Task */
/***************************************************************/
/**
* call_later(G, D):
* The built-in schedules the goal G to be executed after D milliseconds.
*/
% call_later(+Goal, +Integer)
call_later(Goal, Delay) :-
sys_frost_horn((:- Goal), Native),
os_call_later(Native, Delay, _).
/**
* create_task(G):
* The built-in schedules the goal G to be executed. The goal is
* run with auto-yield enabled and promises are accepted.
*/
% create_task(+Goal)
create_task(Goal) :-
sys_frost_horn((:- Goal), Native),
os_task_create(Native, _).
/**
* time_out(G, D):
* The predicate succeeds once if G succeeds. If the goal
* has not terminated after D milliseconds a time limit
* system error is signalled to the goal.
*/
% time_out(+Goal, +Integer)
time_out(Goal, Delay) :-
current_prolog_flag(allow_yield, on), !,
os_task_current(Task),
sys_frost_horn((:- sys_timeout(Task)), Native),
setup_once_cleanup(
os_call_later(Native, Delay, Timer),
Goal,
os_call_cancel(Timer)).
time_out(_, _) :-
throw(error(system_error(illegal_yield),_)).
% sys_timeout
sys_timeout(Task) :-
os_task_abort(Task, system_error(timelimit_exceeded)).
/***************************************************************/
/* Lists */
/***************************************************************/
/**
* member(E, L): [PTP 1]
* The predicate succeeds for every member E of the list L.
*/
% member(-Term, +List)
member(X, [Y|Z]) :- sys_member(Z, X, Y).
% Gertjan van Noord trick
% sys_member(+List, +Term, -Term)
sys_member(_, X, X).
sys_member([Y|Z], X, _) :- sys_member(Z, X, Y).
/**
* select(E, L, R): [PTP 5]
* The predicate succeeds for every member E of the L with remainder list R.
*/
% select(-Term, +List, -List)
select(X, [Y|Z], T) :- sys_select(Z, X, Y, T).
% Gertjan van Noord trick
% sys_select(+List, +Term, -Term, -List)
sys_select(Y, X, X, Y).
sys_select([Y|Z], X, W, [W|T]) :- sys_select(Z, X, Y, T).
/**
* reverse(L, R):
* The predicate succeeds in R with the reverse of L.
*/
% reverse(+List, -List)
reverse(X, Y) :- sys_reverse(X, [], Y).
% sys_reverse(+List, +List, -List)
sys_reverse([], X, X).
sys_reverse([X|Y], Z, T) :- sys_reverse(Y, [X|Z], T).
/**
* append(L, R, S): [PTP 2]
* The predicate succeeds whenever S unifies with
* the concatenation of L and R.
*/
% append(+List, +List, -List)
append([], X, X).
append([X|Y], Z, [X|T]) :- append(Y, Z, T).
/**
* length(L, N): [PTP 3]
* The predicate succeeds with N being the length of the list L.
*/
% length(+List, -Integer)
length(L, N) :- var(N), !, sys_length(L, 0, N).
length(L, N) :- sys_check_integer(N), N >= 0, sys_length(N, L).
% sys_length(+List, +Integer, -Integer)
sys_length([], N, N).
sys_length([_|Y], N, M) :- H is N+1, sys_length(Y, H, M).
% sys_length(+Integer, -List)
sys_length(0, R) :- !, R = [].
sys_length(N, [_|Y]) :- M is N-1, sys_length(M, Y).
/***************************************************************/
/* Miscellaneous */
/***************************************************************/
/**
* number_codes(A, B): [ISO 8.16.8]
* If A is a variable, then the predicate succeeds in A with the
* number from the Prolog list B. Otherwise the predicate succeeds
* in B with the Prolog list for the number A.
*/
% number_codes(+-Number, -+List)
number_codes(Number, Codes) :- ground(Codes), !,
atom_codes(Atom, Codes),
atom_number(Atom, Number).
number_codes(Number, Codes) :-
atom_number(Atom, Number),
atom_codes(Atom, Codes).
/**
* between(L, H, X): [PTP 4]
* The predicate succeeds for every integer X between L and H.
*/
% between(+Integer, +Integer, -Integer)
between(Lo, Hi, X) :- var(X), !,
sys_check_integer(Lo),
sys_check_integer(Hi),
Lo =< Hi,
sys_between(Lo, Hi, X).
between(Lo, Hi, X) :-
sys_check_integer(Lo),
sys_check_integer(Hi),
sys_check_integer(X),
Lo =< X, X =< Hi.
% sys_between(+Integer, +Integer, -Integer)
sys_between(Lo, Lo, R) :- !, Lo = R.
sys_between(Lo, _, Lo).
sys_between(Lo, Hi, X) :- Lo2 is Lo+1, sys_between(Lo2, Hi, X).
/****************************************************************/
/* Multilingual Strings */
/****************************************************************/
/**
* get_string(K, V):
* get_string(K, L, V):
* The predicate succeeds in V with the value for the key K. The
* ternary predicate allows overriding the current locale by L.
*/
% get_string(+Atom, -Atom)
get_string(Key, Value) :-
current_prolog_flag(sys_locale, Locale),
get_string(Key, Locale, Value).
% get_string(+Atom, +Atom, -Atom)
get_string(Key, Locale, Value) :-
sys_locale_ancestor(Locale, Parent),
strings(Key, Parent, Res), !,
Value = Res.
% sys_locale_ancestor(+Atom, -Atom)
sys_locale_ancestor(L, L).
sys_locale_ancestor(L, M) :-
last_sub_atom(L, P, _, _, '_'),
sub_atom(L, 0, P, _, M).
sys_locale_ancestor(L, '') :- L \== ''.
/*************************************************************/
/* Unattended Queries */
/*************************************************************/
% sys_expand_include(+Clause, +Map, +Map, -Clause)
sys_expand_include(V, _, _, _) :- var(V),
throw(error(instantiation_error,_)).
sys_expand_include(?-(Query), Map, _, Clause2) :- !,
Clause2 = (:- sys_query_unattended(Query, Map)).
sys_expand_include(Clause, Map, Map2, Clause2) :-
sys_multiton_keys(Map, Map2, Keys),
sys_multiton_check(Keys),
sys_singleton_keys(Map2, Keys2),
sys_singleton_check(Keys2),
expand_term(Clause, Clause2).
% sys_query_unattended(+Goal, +Map)
sys_query_unattended(Query, Map) :-
'$MARK'(X), Query, '$MARK'(Y),
sys_answer_show(Map),
(X == Y -> !, sys_answer_period;
put_atom(';'), nl, fail).
sys_query_unattended(_, _) :-
put_atom('fail'), sys_answer_period.
% sys_answer_period
sys_answer_period :-
current_output(Stream),
sys_answer_period(Stream).
% sys_answer_period(+Stream)
sys_answer_period(Stream) :-
sys_safe_atom(Stream, '.', 0),
nl(Stream).
/****************************************************************/
/* Variable Checks */
/****************************************************************/
% sys_multiton_keys(+Map, +Map, -List)
sys_multiton_keys([N=_|L], M, R) :- \+ sys_marked_at(N, 0, [23]), !,
sys_multiton_keys(L, M, R).
sys_multiton_keys([N=_|L], M, R) :- \+ sys_marked_at(N, 1, [1,3,23]), !,
sys_multiton_keys(L, M, R).
sys_multiton_keys([N=_|L], M, R) :- member(N=_, M), !,
sys_multiton_keys(L, M, R).
sys_multiton_keys([N=_|L], M, [N|R]) :-
sys_multiton_keys(L, M, R).
sys_multiton_keys([], _, []).
% sys_multiton_check(+List)
sys_multiton_check([Key|Keys]) :-
Error = warning(syntax_error(multiton_var,[Key|Keys]), _),
sys_fill_stack(Error),
sys_print_error(Error).
sys_multiton_check([]).
% sys_singleton_keys(+Map, -List)
sys_singleton_keys([N=_|L], R) :- sys_marked_at(N, 0, [23]), !,
sys_singleton_keys(L, R).
sys_singleton_keys([N=_|L], [N|R]) :-
sys_singleton_keys(L, R).
sys_singleton_keys([], []).
% sys_singleton_check(+List)
sys_singleton_check([Key|Keys]) :-
Error = warning(syntax_error(singleton_var,[Key|Keys]), _),
sys_fill_stack(Error),
sys_print_error(Error).
sys_singleton_check([]).
% sys_marked_at(+Atom, +Integer, +List)
sys_marked_at(N, J, L) :-
sub_atom(N, J, 1, _, H),
char_code(H, C),
code_category(C, T),
member(T, L), !.
/***************************************************************/
/* DCG Transform */
/***************************************************************/
/**
* expand_term(C, D):
* The predicate succeeds in D with the expansion of the term C.
*/
% expand_term(+Clause, -Clause)
expand_term(Clause, Clause2) :- term_expansion(Clause, Clause2), !.
expand_term(Clause, Clause).
% +Phrase --> +Phrase
(_ --> _) :-
throw(error(existence_error(body,(-->)/2),_)).
/**
* term_expansion(C, D):
* This predicate can be used to define custom term conversion rules.
*/
% term_expansion(+Clause, -Clause)
:- multifile term_expansion/2.
term_expansion(X, _) :- var(X), !, fail.
term_expansion((X --> _), _) :- var(X),
throw(error(instantiation_error,_)).
term_expansion((X, Y --> Z), (A :- C, B)) :- !,
sys_phrase_expansion(X, 0, 0, I, O, A),
sys_phrase_expansion(Z, 1, 0, I, H, C),
sys_phrase_expansion(Y, 0, 0, O, H, B).
term_expansion((X --> Y), (A :- B)) :- !,
sys_phrase_expansion(X, 0, 0, I, O, A),
sys_phrase_expansion(Y, 1, 0, I, O, B).
% sys_phrase_expansion(+DCG, +Integer, +Integer, +Term, +Term, -Goal)
sys_phrase_expansion(X, _, _, _, _, _) :- var(X),
throw(error(instantiation_error,_)).
sys_phrase_expansion((X, Y), F, G, I, O, (A, B)) :- !,
sys_phrase_expansion(X, F, 1, I, H, A),
sys_phrase_expansion(Y, 0, G, H, O, B).
sys_phrase_expansion((X; Y), _, _, I, O, (A; B)) :- !,
sys_phrase_expansion(X, 0, 0, I, O, A),
sys_phrase_expansion(Y, 0, 0, I, O, B).
sys_phrase_expansion((X -> Y), F, G, I, O, (A -> B)) :- !,
sys_phrase_expansion(X, F, 1, I, H, A),
sys_phrase_expansion(Y, 0, G, H, O, B).
sys_phrase_expansion([], 0, _, I, O, I = O) :- !.
sys_phrase_expansion([], 1, _, I, O, true) :- !, I = O.
sys_phrase_expansion([X|L], 0, _, I, O, I = [X|R]) :- !,
sys_list_expansion(L, O, R).
sys_phrase_expansion([X|L], 1, _, I, O, true) :- !, I = [X|R],
sys_list_expansion(L, O, R).
sys_phrase_expansion(!, _, 0, I, O, (!, I = O)) :- !.
sys_phrase_expansion(!, _, 1, I, O, !) :- !, I = O.
sys_phrase_expansion({A}, _, 0, I, O, (A, I = O)) :- !.
sys_phrase_expansion({A}, _, 1, I, O, A) :- !, I = O.
sys_phrase_expansion((\+ X), _, 0, I, O, (\+ A, I = O)) :- !,
sys_phrase_expansion(X, 0, 0, I, _, A).
sys_phrase_expansion((\+ X), _, 1, I, O, (\+ A)) :- !, I = O,
sys_phrase_expansion(X, 0, 0, I, _, A).
sys_phrase_expansion(X, _, _, I, O, A) :- callable(X), !,
X =.. [F|L],
append(L, [I, O], R),
A =.. [F|R].
sys_phrase_expansion(X, _, _, _, _, _) :-
throw(error(type_error(callable,X),_)).
% sys_list_expansion(+List, +Term, -List)
sys_list_expansion(X, _, _) :- var(X),
throw(error(instantiation_error,_)).
sys_list_expansion([], Y, Y) :- !.
sys_list_expansion([X|L], Y, [X|R]) :- !,
sys_list_expansion(L, Y, R).
sys_list_expansion(X, _, _) :-
throw(error(type_error(list,X),_)).
/****************************************************************/
/* Other Texts */
/****************************************************************/
/**
* strings(K, L, V):
* The predicate succeeds in the key K, the value V and the locale L.
* The predicate can be extended by libraries and applications.
*/
% strings(+Atom, +Atom, -Atom)
:- multifile strings/3.
strings('exception_unknown', de, 'Unbekannte Ausnahme: ').
strings('exception_error', de, 'Fehler: ').
strings('exception_warning', de, 'Warnung: ').
strings('exception_context', de, '\tKontext unbekannt: ').
strings('exception_template', de, 'Vorlage unbekannt: ').
strings('file_line', de, '\t$ auf $').
strings('exception_unknown', '', 'Unknown exception: ').
strings('exception_error', '', 'Error: ').
strings('exception_warning', '', 'Warning: ').
strings('exception_context', '', '\tUnknown context: ').
strings('exception_template', '', 'Unknown template: ').
strings('file_line', '', '\t$ at $').
/****************************************************************/
/* Error Texts */
/****************************************************************/
strings('instantiation_error', de, 'Argument sollte keine Variable sein.').
strings('domain_error.read_option', de, 'Argument sollte eine Leseoption sein, gefunden $.').
strings('domain_error.io_mode', de, 'Argument sollte ein Eingabe-/Ausgabemodus sein (read oder write), gefunden $.').
strings('domain_error.write_option', de, 'Argument sollte eine Schreiboption sein, gefunden $.').
strings('domain_error.open_option', de, 'Argument sollte Option zum öffnen sein, gefunden $.').
strings('type_error.character_code', de, 'Unerlaubter Kodepunkt $, nicht zwischen 0 und 0x10FFFF.').
strings('existence_error.source_sink', de, 'Datei $ nicht gefunden.').
strings('existence_error.module', de, 'Modul $ nicht gefunden.').
strings('permission_error.open.source_sink', de, 'Kann Datei $ nicht öffnen.').
strings('resource_error.socket_timeout', de, 'Ein-/Ausgabeauszeit.').
strings('resource_error.port_error', de, 'Fehler bei Verwendung eines Port.').
strings('resource_error.remote_error', de, 'Fehler von Entfernt erhalten.').
strings('resource_error.io_exception', de, 'Datei nicht erstellt oder nicht zugreifbar.').
strings('system_error.timelimit_exceeded', de, 'Ausführung abgebrochen da Zeitfrist abgelaufen.').
strings('system_error.stack_overflow', de, 'Ausführung wegen Stapelüberlauf abgebrochen.').
strings('system_error.out_of_memory', de, 'Ausführung wegen aufgebrauchtem Speicherplatz abgebrochen.').
strings('instantiation_error', '', 'Argument should not be a variable.').
strings('domain_error.read_option', '', 'Argument should be a read option, found $.').
strings('domain_error.io_mode', '', 'Argument should be an input/output mode (read or write), found $.').
strings('domain_error.write_option', '', 'Argument should be a write option, found $.').
strings('domain_error.open_option', '', 'Argument should be an open option, found $.').
strings('type_error.character_code', '', 'Illegal code point $, not between 0 and 0x10FFFF.').
strings('existence_error.source_sink', '', 'File $ not found.').
strings('existence_error.module', '', 'Module $ not found.').
strings('permission_error.open.source_sink', '', 'Cannot open file $.').
strings('resource_error.socket_timeout', '', 'Input/output timeout.').
strings('resource_error.port_error', '', 'Error using a port.').
strings('resource_error.remote_error', '', 'Got error from remote.').
strings('resource_error.io_exception', '', 'File not created or not accessible.').
strings('system_error.timelimit_exceeded', '', 'Execution aborted since time limit exceeded.').
strings('system_error.stack_overflow', '', 'Execution aborted because of stack overflow.').
strings('system_error.out_of_memory', '', 'Execution aborted because out of memory.').