| blob | e9370853d3130814f148739a8d7cee53bb4fa11c |
1 @c -----------------------------------------------------------------------------
2 @c File : stringproc.de.texi
3 @c License : GNU General Public License (GPL)
4 @c Language : German
5 @c Original : stringproc.texi
6 @c
7 @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA
8 @c -----------------------------------------------------------------------------
10 @menu
11 * Einf@"uhrung in die Verarbeitung von Zeichenketten::
12 * Ein- und Ausgabe::
13 * Schriftzeichen::
14 * Verarbeitung von Zeichenketten::
15 * Oktette und Werkzeuge f@"ur die Kryptographie::
16 @end menu
18 @c -----------------------------------------------------------------------------
19 @node Einf@"uhrung in die Verarbeitung von Zeichenketten, Ein- und Ausgabe, stringproc, stringproc
20 @section Einf@"uhrung in die Verarbeitung von Zeichenketten
21 @c -----------------------------------------------------------------------------
23 Das Paket @code{stringproc} enth@"alt Funktionen f@"ur die Verarbeitung von
24 Zeichen und Zeichenketten, was Formatierung, Zeichenkodierung und
25 die Behandlung von Datenstr@"omen mit einschlie@ss{}t.
26 Abgerundet wird dieses Paket durch Werkzeuge f@"ur die Kryptographie, wie z.B.
27 Base64 und Hashfunktionen.
29 Das Paket kann explizit durch @code{load("stringproc")} geladen werden oder
30 automatisch durch die Verwendung einer der enthaltenden Funktionen.
32 Fragen und Fehlerberichte senden Sie bitte direkt an den Autor,
33 dessen e-Mail-Adresse durch den folgenden Befehl ausgegeben wird.
35 @code{printf(true, "~@{~a~@}@@gmail.com", split(sdowncase("Volker van Nek")))$}
38 Eine Zeichenkette wird durch die Eingabe von z.B. @code{"Text"} erzeugt.
39 Ist die Optionsvariable @code{stringdisp} auf @code{false} gesetzt, was
40 standardm@"a@ss{}ig der Fall ist, werden die (doppelten) Anf@"uhrungszeichen
41 nicht mit ausgegeben. @ref{stringp} ist ein Test, ob ein Objekt eine
42 Zeichenkette ist.
44 @example
45 (%i1) str: "Text";
46 (%o1) Text
47 (%i2) stringp(str);
48 (%o2) true
49 @end example
51 Schriftzeichen werden in Maxima durch Zeichenketten der L@"ange 1 dargestellt.
52 @ref{charp} ist hier der entsprechende Test.
54 @example
55 (%i1) char: "e";
56 (%o1) e
57 (%i2) charp(char);
58 (%o2) true
59 @end example
61 Positionsindizes in Zeichenketten sind in Maxima genau so wie in Listen
62 1-indiziert, wodurch die folgende @"Ubereinstimmung entsteht.
64 @example
65 (%i1) is(charat("Lisp",1) = charlist("Lisp")[1]);
66 (%o1) true
67 @end example
69 Eine Zeichenkette kann Ausdr@"ucke enthalten, die Maxima versteht.
70 Diese k@"onnen mit @ref{parse_string} heraus gel@"ost werden.
72 @example
73 (%i1) map(parse_string, ["42" ,"sqrt(2)", "%pi"]);
74 (%o1) [42, sqrt(2), %pi]
75 (%i2) map('float, %);
76 (%o2) [42.0, 1.414213562373095, 3.141592653589793]
77 @end example
79 Zeichenketten k@"onnen als Schriftzeichen und bin@"ar als Oktette verarbeitet werden.
80 @ref{string_to_octets} bzw. @ref{octets_to_string} dienen hierbei zur Umrechnung.
81 Die verwendbaren Kodierungen sind dabei von der Plattform, der Anwendung und vom
82 unter Maxima liegenden Lisp abh@"angig.
83 (Folgend Maxima in GNU/Linux, kompiliert mit SBCL.)
85 @example
86 (%i1) obase: 16.$
87 (%i2) string_to_octets("$@pounds{}@euro{}", "cp1252");
88 (%o2) [24, 0A3, 80]
89 (%i3) string_to_octets("$@pounds{}@euro{}", "utf-8");
90 (%o3) [24, 0C2, 0A3, 0E2, 82, 0AC]
91 @end example
93 Dem entsprechend k@"onnen Zeichenketten an Datenstr@"ome f@"ur Schriftzeichen und
94 als Oktette an bin@"are Str@"ome weiter gegeben werden. Das folgende Beispiel
95 zeigt das Schreiben und Lesen von Schriftzeichen in bzw. aus einer Datei.
97 @ref{openw} gibt dabei einen Ausgabestrom in eine Datei zur@"uck,
98 mit @ref{printf} wird formatiert in diesen Strom geschrieben und
99 mit z.B. @ref{close} werden die im Strom enthaltenden Zeichen in die Datei
100 geschrieben.
102 @example
103 (%i1) s: openw("file.txt");
104 (%o1) #<output stream file.txt>
105 (%i2) printf(s, "~%~d ~f ~a ~a ~f ~e ~a~%",
106 42, 1.234, sqrt(2), %pi, 1.0e-2, 1.0e-2, 1.0b-2)$
107 (%i3) close(s)$
108 @end example
110 @ref{openr} gibt folgend einen Eingabestrom aus der obigen Datei zur@"uck und
111 @ref{readline} die gelesene Zeile als Zeichenkette.
112 Mit z.B. @ref{split} oder @ref{tokens} kann die Zeichenkette anschlie@ss{}end
113 in seine Bestandteile zerlegt werden.
114 @ref{parse_string} verwandelt diese dann in auswertbare Ausdr@"ucke.
116 @example
117 (%i4) s: openr("file.txt");
118 (%o4) #<input stream file.txt>
119 (%i5) readline(s);
120 (%o5) 42 1.234 sqrt(2) %pi 0.01 1.0E-2 1.0b-2
121 (%i6) map(parse_string, split(%));
122 (%o6) [42, 1.234, sqrt(2), %pi, 0.01, 0.01, 1.0b-2]
123 (%i7) close(s)$
124 @end example
126 @c -----------------------------------------------------------------------------
127 @node Ein- und Ausgabe, Schriftzeichen, Einf@"uhrung in die Verarbeitung von Zeichenketten, stringproc
128 @section Ein- und Ausgabe
129 @c -----------------------------------------------------------------------------
131 Beispiel: Formatiertes Schreiben in eine Datei mit anschlie@ss{}endem Lesen.
133 @example
134 (%i1) s: openw("file.txt");
135 (%o1) #<output stream file.txt>
136 (%i2) control:
137 "~2tAn atom: ~20t~a~%~2tand a list: ~20t~@{~r ~@}~%~2t\
138 and an integer: ~20t~d~%"$
139 (%i3) printf(s, control, 'true,[1,2,3],42)$
140 (%o3) false
141 (%i4) close(s);
142 (%o4) true
143 (%i5) s: openr("file.txt");
144 (%o5) #<input stream file.txt>
145 (%i6) while stringp(tmp:readline(s)) do print(tmp)$
146 An atom: true
147 and a list: one two three
148 and an integer: 42
149 (%i7) close(s)$
150 @end example
152 Beispiel: Lesen aus einer bin@"aren Datei. Siehe @ref{readbyte}.
154 @c -----------------------------------------------------------------------------
155 @anchor{close}
156 @deffn {Funktion} close (@var{stream})
158 Schlie@ss{}t den Datenstrom @var{stream} und gibt @code{true} zur@"uck,
159 wenn @var{stream} noch ge@"offnet war.
161 @end deffn
163 @c -----------------------------------------------------------------------------
164 @anchor{flength}
165 @deffn {Funktion} flength (@var{stream})
167 @var{stream} muss ein ge@"offneter Datenstrom in eine oder aus einer Datei sein.
168 @code{flength} gibt dann die Anzahl der Bytes zur@"uck, die sich momentan in
169 dieser Datei befinden.
171 Beispiel: Siehe @ref{writebyte} .
172 @end deffn
174 @c -----------------------------------------------------------------------------
175 @anchor{flush_output}
176 @deffn {Funktion} flush_output (@var{stream})
178 Leert den Inhalt des Dateiausgabestroms @var{stream} in die Datei.
180 Beispiel: Siehe @ref{writebyte} .
182 @end deffn
184 @c -----------------------------------------------------------------------------
185 @anchor{fposition}
186 @deffn {Function} fposition (@var{stream})
187 @deffnx {Function} fposition (@var{stream}, @var{pos})
189 Ohne das optionale Argument @var{pos} gibt @code{fposition} die aktuelle Position
190 in dem Datenstrom @var{stream} zur@"uck.
191 Wird @var{pos} verwendet, legt @code{fposition} diesen Wert als aktuelle Position
192 in @var{stream} fest. @var{pos} muss eine positive Zahl sein.
194 Die Positionen in Datenstr@"omen sind wie in Zeichenketten und Listen 1-indiziert,
195 d.h. das erste Element in @var{stream} hat die Position 1.
197 @end deffn
199 @c -----------------------------------------------------------------------------
200 @anchor{freshline}
201 @deffn {Function} freshline ()
202 @deffnx {Function} freshline (@var{stream})
204 Schreibt einen Zeilenumbruch in den Standardausgabestrom, falls die aktuelle
205 Ausgabeposition nicht gerade der Anfang einer Zeile ist und gibt @code{true}
206 zur@"uck. Bei der Verwendung des optionalen Arguments @var{stream} wird der
207 Umbruch in diesen Datenstrom geschrieben.
209 Es gibt Situationen, in denen @code{freshline()} nicht wie erwartet funktioniert.
211 Siehe auch @ref{newline}.
213 @end deffn
215 @c -----------------------------------------------------------------------------
216 @anchor{get_output_stream_string}
217 @deffn {Funktion} get_output_stream_string (@var{stream})
219 Gibt Schriftzeichen, die aktuell in dem ge@"offneten Datenstrom @var{stream}
220 enthalten sind, in einer Zeichenkette zur@"uck. Die zur@"uck gegebenen
221 Zeichen werden dabei aus dem Datenstrom entfernt. @var{stream} muss durch
222 @code{make_string_output_stream} erzeugt worden sein.
224 Beispiel: Siehe @ref{make_string_output_stream} .
225 @end deffn
227 @c -----------------------------------------------------------------------------
228 @anchor{make_string_input_stream}
229 @deffn {Funktion} make_string_input_stream (@var{string})
230 @deffnx {Funktion} make_string_input_stream (@var{string}, @var{start})
231 @deffnx {Funktion} make_string_input_stream (@var{string}, @var{start}, @var{end})
233 Gibt einen Datenstrom zur@"uck, der Teile der Zeichenkette @var{string}
234 und ein Dateiende enth@"alt.
235 Ohne optionale Argumente enth@"alt der Strom die gesamte Zeichenkette
236 und ist vor dem ersten Zeichen positioniert. Mit den optionalen Argumenten
237 @var{start} und @var{end} l@"asst sich der Abschnitt der Zeichenkette festlegen,
238 den der Datenstrom enth@"alt. Das erste Zeichen befindet sich dabei an der
239 Position 1.
241 @example
242 (%i1) istream : make_string_input_stream("text", 1, 4);
243 (%o1) #<string-input stream from "text">
244 (%i2) (while (c : readchar(istream)) # false do sprint(c), newline())$
245 t e x
246 (%i3) close(istream)$
247 @end example
248 @end deffn
250 @c -----------------------------------------------------------------------------
251 @anchor{make_string_output_stream}
252 @deffn {Funktion} make_string_output_stream ()
254 Gibt einen Datenstrom zur@"uck, der Schriftzeichen aufnehmen kann. Die aktuell
255 im Strom enthaltenden Zeichen k@"onnen mit @ref{get_output_stream_string}
256 entnommen werden.
258 @example
259 (%i1) ostream : make_string_output_stream();
260 (%o1) #<string-output stream 09622ea0>
261 (%i2) printf(ostream, "foo")$
263 (%i3) printf(ostream, "bar")$
265 (%i4) string : get_output_stream_string(ostream);
266 (%o4) foobar
267 (%i5) printf(ostream, "baz")$
269 (%i6) string : get_output_stream_string(ostream);
270 (%o6) baz
271 (%i7) close(ostream)$
272 @end example
273 @end deffn
275 @c -----------------------------------------------------------------------------
276 @anchor{newline}
277 @deffn {Funktion} newline ()
278 @deffnx {Funktion} newline (@var{stream})
280 Schreibt einen Zeilenumbruch in den Standardausgabestrom und gibt @code{false}
281 zur@"uck. Bei der Verwendung des optionalen Arguments @var{stream} wird der
282 Umbruch in diesen Datenstrom geschrieben.
283 Es gibt Situationen, in denen @code{newline()} nicht wie erwartet funktioniert.
285 Beispiel: Siehe @ref{sprint}.
287 @end deffn
289 @c -----------------------------------------------------------------------------
290 @anchor{opena}
291 @deffn {Funktion} opena (@var{file})
293 Gibt einen Dateiausgabestrom f@"ur Schriftzeichen zur@"uck.
294 Sollte die Textdatei @var{file} nicht existieren, wird sie erzeugt.
295 Wird eine bereits vorhandene Datei ge@"offnet, werden alle Ausgaben in die
296 Datei am Ende hinzugef@"ugt.
298 @ref{Functions and Variables for binary input and output, , opena_binary}
299 ist die entsprechende Funktion f@"ur die Ausgabe in eine Bin@"ardatei.
300 @end deffn
302 @c -----------------------------------------------------------------------------
303 @anchor{openr}
304 @deffn {Funktion} openr (@var{file})
306 Gibt einen Dateieingabestrom f@"ur Schriftzeichen aus einer Textdatei zur@"uck.
307 Voraussetzung ist, dass die Datei @var{file} bereits existiert.
309 @ref{Functions and Variables for binary input and output, , openr_binary}
310 ist die entsprechende Funktion f@"ur die Eingabe aus einer Bin@"ardatei.
311 @end deffn
313 @c -----------------------------------------------------------------------------
314 @anchor{openw}
315 @deffn {Funktion} openw (@var{file})
317 Gibt einen Dateiausgabestrom f@"ur Schriftzeichen zur@"uck.
318 Sollte die Textdatei @var{file} nicht existieren, wird sie erzeugt.
319 Wird eine bereits vorhandene Datei ge@"offnet, wird sie destruktiv ver@"andert.
321 @ref{Functions and Variables for binary input and output, , openw_binary}
322 ist die entsprechende Funktion f@"ur die Ausgabe in eine Bin@"ardatei.
323 @end deffn
325 @c -----------------------------------------------------------------------------
326 @anchor{printf}
327 @deffn {Function} printf (@var{dest}, @var{string})
328 @deffnx {Function} printf (@var{dest}, @var{string}, @var{expr_1}, @dots{}, @var{expr_n})
330 Erzeugt eine formatierte Ausgabe. Der Zielparameter @var{dest} gibt an, wo die
331 Ausgabe erfolgen soll. M@"oglich sind hier ein Ausgabestrom oder die globalen
332 Variablen @code{true} und @code{false}. @code{true} bewirkt eine Ausgabe im Terminal.
333 Der R@"uckgabewert von @code{printf} ist in diesem Fall @code{false}.
334 @code{false} als Zielparameter bewirkt die Ausgabe im R@"uckgabewert.
336 Die Zeichen des Kontrollparameters @var{string} werden der Reihe nach ausgegeben,
337 wobei jedoch eine Tilde eine Direktive einleitet. Die Direktiven verwenden
338 dann im Allgemeinen die nachstehenden Parameter @var{expr_1}, @dots{}, @var{expr_n},
339 um die Ausgabe zu erzeugen. Das Zeichen nach der Tilde gibt dabei an,
340 welche Art der Formatierung gew@"unscht ist.
342 @code{printf} stellt die Common Lisp Funktion @code{format} in Maxima zur Verf@"ugung.
343 Das folgende Beispiel zeigt die grunds@"atzliche Beziehung zwischen diesen
344 beiden Funktionen.
346 @example
347 (%i1) printf(true, "R~dD~d~%", 2, 2);
348 R2D2
349 (%o1) false
350 (%i2) :lisp (format t "R~dD~d~%" 2 2)
351 R2D2
352 NIL
353 @end example
355 Die folgende Beschreibung und die Beispiele beschr@"anken sich auf eine grobe
356 Skizze der Verwendungsm@"oglichkeiten von @code{printf}.
357 Die Lisp Funktion @code{format} ist in vielen Referenzb@"uchern ausf@"uhrlich
358 beschrieben. Eine hilfreiche Quelle ist z.B. das frei verf@"ugbare Online-Manual
359 "Common Lisp the Language" von Guy L. Steele. Siehe dort das Kapitel 22.3.3.
361 @example
362 ~% new line
363 ~& fresh line
364 ~t tab
365 ~$ monetary
366 ~d decimal integer
367 ~b binary integer
368 ~o octal integer
369 ~x hexadecimal integer
370 ~br base-b integer
371 ~r spell an integer
372 ~p plural
373 ~f floating point
374 ~e scientific notation
375 ~g ~f or ~e, depending upon magnitude
376 ~h bigfloat
377 ~a uses Maxima function string
378 ~s like ~a, but output enclosed in "double quotes"
379 ~~ ~
380 ~< justification, ~> terminates
381 ~( case conversion, ~) terminates
382 ~[ selection, ~] terminates
383 ~@{ iteration, ~@} terminates
384 @end example
386 Die Direktive ~h f@"ur Gleitkommazahlen mit beliebiger Genauigkeit
387 entspricht nicht dem Lisp-Standard und wird daher unten n@"aher beschrieben.
389 Die Direktive ~* wird nicht unterst@"utzt.
391 Ist @var{dest} ein Datenstrom oder @code{true}, gibt @code{printf}
392 @code{false} zur@"uck. Andernfalls ist der R@"uckgabewert eine Zeichenkette.
394 @example
395 (%i1) printf( false, "~a ~a ~4f ~a ~@@r",
396 "String",sym,bound,sqrt(12),144), bound = 1.234;
397 (%o1) String sym 1.23 2*sqrt(3) CXLIV
398 (%i2) printf( false,"~@{~a ~@}",["one",2,"THREE"] );
399 (%o2) one 2 THREE
400 (%i3) printf( true,"~@{~@{~9,1f ~@}~%~@}",mat ),
401 mat = args(matrix([1.1,2,3.33],[4,5,6],[7,8.88,9]))$
402 1.1 2.0 3.3
403 4.0 5.0 6.0
404 7.0 8.9 9.0
405 (%i4) control: "~:(~r~) bird~p ~[is~;are~] singing."$
406 (%i5) printf( false, control, n,n, if n = 1 then 1 else 2 ), n = 2;
407 (%o5) Two birds are singing.
408 @end example
410 Die Direktive ~h wurde f@"ur Gleitkommazahlen mit beliebiger Genauigkeit
411 eingef@"uhrt.
413 @example
414 ~w,d,e,x,o,p@@H
415 w : width
416 d : decimal digits behind floating point
417 e : minimal exponent digits
418 x : preferred exponent
419 o : overflow character
420 p : padding character
421 @@ : display sign for positive numbers
422 @end example
424 @example
425 (%i1) fpprec : 1000$
426 (%i2) printf(true, "|~h|~%", 2.b0^-64)$
427 |0.0000000000000000000542101086242752217003726400434970855712890625|
428 (%i3) fpprec : 26$
429 (%i4) printf(true, "|~h|~%", sqrt(2))$
430 |1.4142135623730950488016887|
431 (%i5) fpprec : 24$
432 (%i6) printf(true, "|~h|~%", sqrt(2))$
433 |1.41421356237309504880169|
434 (%i7) printf(true, "|~28h|~%", sqrt(2))$
435 | 1.41421356237309504880169|
436 (%i8) printf(true, "|~28,,,,,'*h|~%", sqrt(2))$
437 |***1.41421356237309504880169|
438 (%i9) printf(true, "|~,18h|~%", sqrt(2))$
439 |1.414213562373095049|
440 (%i10) printf(true, "|~,,,-3h|~%", sqrt(2))$
441 |1414.21356237309504880169b-3|
442 (%i11) printf(true, "|~,,2,-3h|~%", sqrt(2))$
443 |1414.21356237309504880169b-03|
444 (%i12) printf(true, "|~20h|~%", sqrt(2))$
445 |1.41421356237309504880169|
446 (%i13) printf(true, "|~20,,,,'+h|~%", sqrt(2))$
447 |++++++++++++++++++++|
448 @end example
450 @end deffn
452 @c -----------------------------------------------------------------------------
453 @anchor{readbyte}
454 @deffn {Funktion} readbyte (@var{stream})
456 Entfernt das erste Byte aus dem bin@"aren Eingabestrom @var{stream} und gibt es
457 zur@"uck.
458 Ist das Ende der Datei (EOF) erreicht, wird @code{false} zur@"uck gegeben.
460 Beispiel: Die ersten 16 Byte aus einer mit AES in OpenSSL verschl@"usselten
461 Datei werden gelesen und ausgewertet.
463 @example
464 (%i1) ibase: obase: 16.$
466 (%i2) in: openr_binary("msg.bin");
467 (%o2) #<input stream msg.bin>
468 (%i3) (L:[], thru 16. do push(readbyte(in), L), L:reverse(L));
469 (%o3) [53, 61, 6C, 74, 65, 64, 5F, 5F, 88, 56, 0DE, 8A, 74, 0FD, 0AD, 0F0]
470 (%i4) close(in);
471 (%o4) true
472 (%i5) map(ascii, rest(L,-8));
473 (%o5) [S, a, l, t, e, d, _, _]
474 (%i6) salt: octets_to_number(rest(L,8));
475 (%o6) 8856de8a74fdadf0
476 @end example
478 @end deffn
480 @c -----------------------------------------------------------------------------
481 @anchor{readchar}
482 @deffn {Funktion} readchar (@var{stream})
484 Entfernt und gibt das erste Schriftzeichen in @var{stream} zur@"uck.
485 Falls das Ende des Streams erreicht sein sollte, gibt @code{readchar}
486 @code{false} zur@"uck.
488 Beispiel: Siehe @ref{make_string_input_stream}.
489 @end deffn
491 @c -----------------------------------------------------------------------------
492 @anchor{readline}
493 @deffn {Function} readline (@var{stream})
495 Gibt die Zeichenkette zur@"uck, die s@"amtliche Zeichen von der
496 aktuellen Position in @var{stream} bis zum Ende der Zeile enth@"alt
497 oder @code{false}, falls das Ende der Datei erreicht wurde.
499 @end deffn
501 @c -----------------------------------------------------------------------------
502 @anchor{sprint}
503 @deffn {Funktion} sprint (@var{expr_1}, @dots{}, @var{expr_n})
505 Wertet ihre Argumente der Reihe nach von links nach rechts aus und gibt sie dann
506 auf einer Linie aus. Zeilenbegrenzungen werden dabei au@ss{}er Acht gelassen.
507 An die ausgegebenen Ausdr@"ucke wird jeweils rechts ein Leerzeichen angef@"ugt.
509 Beispiel: Sequentielle Ausgabe mit @code{sprint}.
510 Zeilenumbr@"uche werden hier mit @code{newline()} erzeugt.
512 @example
513 (%i1) for n:0 thru 19 do sprint(fib(n))$
514 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181
515 (%i2) for n:0 thru 22 do (
516 sprint(fib(n)),
517 if mod(n,10) = 9 then newline() )$
518 0 1 1 2 3 5 8 13 21 34
519 55 89 144 233 377 610 987 1597 2584 4181
520 6765 10946 17711
521 @end example
523 @end deffn
525 @c -----------------------------------------------------------------------------
526 @anchor{writebyte}
527 @deffn {Funktion} writebyte (@var{byte}, @var{stream})
529 Schreibt das Byte @var{byte} in den bin@"aren Ausgabestrom @var{stream}.
530 @code{writebyte} gibt @code{byte} zur@"uck.
532 Beispiel: Es werden Bytes in eine Bin@"ardatei geschrieben.
533 In diesem Beispiel entsprechen s@"amtliche Bytes druckbaren Zeichen,
534 die mit Hilfe von @code{printfile} ausgegeben werden k@"onnen.
535 Die Bytes verbleiben so lange im Datenstrom, bis die Funktionen @code{flush_output}
536 oder @code{close} aufgerufen werden.
538 @example
539 (%i1) ibase: obase: 16.$
541 (%i2) bytes: string_to_octets("GNU/Linux");
542 (%o2) [47, 4E, 55, 2F, 4C, 69, 6E, 75, 78]
543 (%i3) out: openw_binary("test.bin");
544 (%o3) #<output stream test.bin>
545 (%i4) for i thru 3 do writebyte(bytes[i], out);
546 (%o4) done
547 (%i5) printfile("test.bin")$
549 (%i6) flength(out);
550 (%o6) 0
551 (%i7) flush_output(out);
552 (%o7) true
553 (%i8) flength(out);
554 (%o8) 3
555 (%i9) printfile("test.bin")$
556 GNU
557 (%i0A) for b in rest(bytes,3) do writebyte(b, out);
558 (%o0A) done
559 (%i0B) close(out);
560 (%o0B) true
561 (%i0C) printfile("test.bin")$
562 GNU/Linux
563 @end example
565 @end deffn
567 @c -----------------------------------------------------------------------------
568 @node Schriftzeichen, Verarbeitung von Zeichenketten, Ein- und Ausgabe, stringproc
569 @section Schriftzeichen
570 @c -----------------------------------------------------------------------------
572 In Maxima sind Schriftzeichen Zeichenketten der L@"ange 1.
574 @c -----------------------------------------------------------------------------
575 @anchor{adjust_external_format}
576 @deffn {Function} adjust_external_format ()
578 Gibt Informationen zum aktuellen externen Format des Lisp Lesers aus
579 und in dem Fall, dass die Kodierung des externen Formats nicht mit der
580 Kodierung der Anwendung, in der Maxima l@"auft, @"ubereinstimmt,
581 versucht @code{adjust_external_format}, die Kodierung anzupassen
582 oder gibt entsprechende Hilfen oder Anleitungen aus.
583 @code{adjust_external_format} gibt @code{true} zur@"uck, wenn das externe
584 Format ge@"andert wurde und @code{false}, wenn nicht.
586 Funktionen wie @ref{cint}, @ref{unicode}, @ref{octets_to_string}
587 und @ref{string_to_octets} ben@"otigen UTF-8 als das externe Format
588 des Lisp Lesers, um @"uber dem vollst@"andigen Bereich der Unicode-Zeichen
589 korrekt arbeiten zu k@"onnen.
591 Beispiele (Maxima in Windows, M@"arz 2016):
592 Die Verwendung von @code{adjust_external_format} in dem Fall, dass das
593 externe Format nicht mit der Kodierung der Anwendung, in der Maxima l@"auft,
594 @"ubereinstimmt.
596 1. Maxima in der Kommandozeile
598 F@"ur die Sitzung in einem Terminal wird empfohlen, ein mit SBCL kompiliertes
599 Maxima zu verwenden. Unicode wird hier standardm@"a@ss{}ig unterst@"utzt
600 und ein Aufruf von @code{adjust_external_format} ist nicht notwendig.
602 Falls Maxima mit CLISP oder GCL kompiliert wurde, wird empfohlen,
603 die Kodierung des Terminals von CP850 in CP1252 abzu@"andern.
604 @code{adjust_external_format} gibt eine entsprechende Hilfe aus.
606 CCL liest UTF-8, obwohl der Input vom Terminal standardm@"a@ss{}ig in CP850
607 kodiert ist. CP1252 wird jedoch von CCL nicht unterst@"utzt.
608 @code{adjust_external_format} gibt deshalb eine Anleitung aus,
609 wie die Kodierung des Terminals und die des externen Formats beide
610 auf ISO-8859-1 abge@"andert werden k@"onnen.
612 2. wxMaxima
614 In wxMaxima liest SBCL standardm@"a@ss{}ig CP1252.
615 Der Input von der Anwendung (wxMaxima) ist jedoch UTF-8-kodiert.
616 Hier ist eine Anpassung erforderlich.
618 Ein Aufruf von @code{adjust_external_format} und ein Neustart von Maxima
619 @"andern das standardm@"a@ss{}ige externe Format auf UTF-8.
621 @example
622 (%i1)adjust_external_format();
623 The line
624 (setf sb-impl::*default-external-format* :utf-8)
625 has been appended to the init file
626 C:/Users/Username/.sbclrc
627 Please restart Maxima to set the external format to UTF-8.
628 (%i1) false
629 @end example
631 Maxima wird neu gestartet.
633 @example
634 (%i1) adjust_external_format();
635 The external format is currently UTF-8
636 and has not been changed.
637 (%i1) false
638 @end example
640 @end deffn
642 @c -----------------------------------------------------------------------------
643 @anchor{alphacharp}
644 @deffn {Function} alphacharp (@var{char})
646 Gibt @code{true} zur@"uck, falls @var{char} ein Buchstabe eines Alphabets ist.
648 Um ein Nicht-US-ASCII-Zeichen als Buchstaben eines Alphabets erkennen zu k@"onnen,
649 muss das unter Maxima liegende Lisp Unicode voll unterst@"utzen.
650 So wird z.B. ein Umlaut mit SBCL in GNU/Linux als Buchstabe erkannt,
651 mit GCL jedoch nicht.
652 (In Windows muss ein mit SBCL kompiliertes Maxima auf UTF-8 umgestellt worden sein.
653 Siehe hierzu @ref{adjust_external_format}.)
655 Beispiele:
657 Das unter Maxima liegende Lisp (SBCL, GNU/Linux) kann das eingegebene Zeichen
658 in ein Lisp-Schriftzeichen umwandeln und untersuchen.
660 @example
661 (%i1) alphacharp("@"u");
662 (%o1) true
663 @end example
665 Mit GCL ist dies nicht m@"oglich. Es kommt zu einem Fehlerabbruch.
667 @example
668 (%i1) alphacharp("u");
669 (%o1) true
670 (%i2) alphacharp("@"u");
672 package stringproc: @"u cannot be converted into a Lisp character.
673 -- an error.
674 @end example
676 @end deffn
678 @c -----------------------------------------------------------------------------
679 @anchor{alphanumericp}
680 @deffn {Function} alphanumericp (@var{char})
682 Gibt @code{true} zur@"uck, falls @var{char} ein Buchstabe eines Alphabets
683 oder ein Zahlzeichen ist
684 (als Zahlzeichen werden hier nur entprechende US-ASCII-Zeichen betrachtet).
686 Hinweis: Siehe Bemerkungen zu @ref{alphacharp}.
688 @end deffn
690 @c -----------------------------------------------------------------------------
691 @anchor{ascii}
692 @deffn {Funktion} ascii (@var{int})
694 Gibt das US-ASCII-Zeichen zur@"uck, das der Ganzzahl @var{int} entspricht.
695 @var{int} muss dabei kleiner als @code{128} sein.
697 Siehe @ref{unicode} f@"ur die Umwandlung von Codepunkten gr@"o@ss{}er @code{127}.
699 Beispiele:
701 @example
702 (%i1) for n from 0 thru 127 do (
703 ch: ascii(n),
704 if alphacharp(ch) then sprint(ch),
705 if n = 96 then newline() )$
706 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
707 a b c d e f g h i j k l m n o p q r s t u v w x y z
708 @end example
710 @end deffn
712 @c -----------------------------------------------------------------------------
713 @anchor{cequal}
714 @deffn {Function} cequal (@var{char_1}, @var{char_2})
716 Gibt @code{true} zur@"uck, falls @var{char_1} und @var{char_2} ein
717 und das selbe Schriftzeichen sind.
719 @end deffn
721 @c -----------------------------------------------------------------------------
722 @anchor{cequalignore}
723 @deffn {Function} cequalignore (@var{char_1}, @var{char_2})
725 Arbeitet wie @ref{cequal}, ignoriert jedoch die Gro@ss{}- und Kleinschreibung,
726 was f@"ur Nicht-US-ASCII-Zeichen nur m@"oglich ist, wenn das unter Maxima liegende
727 Lisp einen Buchstaben auch als Buchstaben eines Alphabets erkennen kann.
728 Siehe hierzu die Bemerkungen zu @ref{alphacharp}.
730 @end deffn
732 @c -----------------------------------------------------------------------------
733 @anchor{cgreaterp}
734 @deffn {Function} cgreaterp (@var{char_1}, @var{char_2})
736 Gibt @code{true} zur@"uck, wenn der Codepunkt des Zeichens @var{char_1}
737 gr@"o@ss{}er ist als der des Zeichens @var{char_2}.
739 @end deffn
741 @c -----------------------------------------------------------------------------
742 @anchor{cgreaterpignore}
743 @deffn {Funktion} cgreaterpignore (@var{char_1}, @var{char_2})
745 Arbeitet wie @ref{cgreaterp}, ignoriert jedoch die Gro@ss{}- und Kleinschreibung,
746 was f@"ur Nicht-US-ASCII-Zeichen nur m@"oglich ist, wenn das unter Maxima liegende
747 Lisp einen Buchstaben auch als Buchstaben eines Alphabets erkennen kann.
748 Siehe hierzu die Bemerkungen zu @ref{alphacharp}.
750 @end deffn
752 @c -----------------------------------------------------------------------------
753 @anchor{charp}
754 @deffn {Funktion} charp (@var{obj})
756 Gibt @code{true} zur@"uck, wenn @var{obj} ein Schriftzeichen ist.
758 Beispiel: Siehe Einf@"uhrung.
760 @end deffn
762 @c -----------------------------------------------------------------------------
763 @anchor{cint}
764 @deffn {Funktion} cint (@var{char})
766 Gibt den Unicode Codepunkt des Arguments @var{char} zur@"uck, das ein
767 Schriftzeichen sein muss, d.h. eine Zeichenkette der L@"ange @code{1}.
769 Beispiele: Der hexadedimale Codepunkt von Schriftzeichen
770 (Maxima kompiliert mit SBCL in GNU/Linux).
772 @example
773 (%i1) obase: 16.$
774 (%i2) map(cint, ["$","@pounds{}","@euro{}"]);
775 (%o2) [24, 0A3, 20AC]
776 @end example
778 Warnung: In Windows ist es nicht m@"oglich, Schriftzeichen,
779 die Codepunkten gr@"o@ss{}er 16 Bit entsprechen, in wxMaxima einzugeben,
780 wenn Maxima mit SBCL kompiliert wurde und das aktuelle externe Format nicht UTF-8 ist.
781 Siehe @ref{adjust_external_format} f@"ur weitere Informationen.
783 @c Command @U not supported by texinfo 5.
784 @c @example
785 @c (%i3) cint("@U{1d538}");
786 @c (%o3) 1D538
787 @c @end example
789 CMUCL verarbeitet solche Zeichen nicht als ein einziges Zeichen und @code{cint}
790 gibt dann @code{false} zur@"uck.
791 Als Ausweg kann hier die Umwandlung von Schriftzeichen in Codepunkte @"uber
792 UTF-8-Oktette dienen: @*
793 @code{utf8_to_unicode(string_to_octets(character));}
795 @c Command @U not supported by texinfo 5.
796 @c @example
797 @c (%i4) utf8_to_unicode(string_to_octets("@U{1d538}"));
798 @c (%o4) 1D538
799 @c @end example
801 Siehe @ref{utf8_to_unicode}, @ref{string_to_octets}.
803 @end deffn
805 @c -----------------------------------------------------------------------------
806 @anchor{clessp}
807 @deffn {Function} clessp (@var{char_1}, @var{char_2})
809 Gibt @code{true} zur@"uck, wenn der Codepunkt des Zeichens @var{char_1}
810 kleiner ist als der des Zeichens @var{char_2}.
812 @end deffn
814 @c -----------------------------------------------------------------------------
815 @anchor{clesspignore}
816 @deffn {Funktion} clesspignore (@var{char_1}, @var{char_2})
818 Arbeitet wie @ref{clessp}, ignoriert jedoch die Gro@ss{}- und Kleinschreibung,
819 was f@"ur Nicht-US-ASCII-Zeichen nur m@"oglich ist, wenn das unter Maxima liegende
820 Lisp einen Buchstaben auch als Buchstaben eines Alphabets erkennen kann.
821 Siehe hierzu die Bemerkungen zu @ref{alphacharp}.
823 @end deffn
825 @c -----------------------------------------------------------------------------
826 @anchor{constituent}
827 @deffn {Funktion} constituent (@var{char})
829 Gibt @code{true} zur@"uck, wenn @var{char} ein graphisches Schriftzeichen,
830 aber kein Leerzeichen ist.
831 Ein graphisches Schriftzeichen ist ein Leerzeichen oder ein Zeichen, das man sehen kann.
832 (@code{constituent} wurde definiert von Paul Graham.
833 Siehe Paul Graham, ANSI Common Lisp, 1996, Seite 67.)
835 Beispiel:
837 @example
838 (%i1) for n from 0 thru 255 do (
839 tmp: ascii(n), if constituent(tmp) then sprint(tmp) )$
840 ! " # % ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @@ A B
841 C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c
842 d e f g h i j k l m n o p q r s t u v w x y z @{ | @} ~
843 @end example
845 Hinweis: Siehe Bemerkungen zu @ref{alphacharp}.
847 @end deffn
849 @c -----------------------------------------------------------------------------
850 @c @anchor{cunlisp}
851 @c @deffn {Function} cunlisp (@var{lisp_char})
852 @c
853 @c Converts a Lisp character into a Maxima character.
854 @c (You won't need it.)
855 @c @end deffn
857 @c -----------------------------------------------------------------------------
858 @anchor{digitcharp}
859 @deffn {Funktion} digitcharp (@var{char})
861 Gibt @code{true} zur@"uck, wenn @var{char} ein Zahlzeichen ist,
862 wobei als Zahlzeichen hier nur entsprechende US-ASCII-Zeichen betrachtet werden.
864 @end deffn
866 @c -----------------------------------------------------------------------------
867 @c @anchor{lcharp}
868 @c @deffn {Function} lcharp (@var{obj})
869 @c
870 @c Returns @code{true} if @var{obj} is a Lisp character.
871 @c (You won't need it.)
872 @c @end deffn
874 @c -----------------------------------------------------------------------------
875 @anchor{lowercasep}
876 @deffn {Funktion} lowercasep (@var{char})
878 Gibt @code{true} zur@"uck, wenn @var{char} ein Kleinbuchstabe ist.
880 Hinweis: Siehe Bemerkungen zu @ref{alphacharp}.
882 @end deffn
884 @c -----------------------------------------------------------------------------
885 @anchor{newline_variable}
886 @defvr {Variable} newline
888 Das Steuerzeichen f@"ur den Zeilenvorschub (ASCII-Zeichen 10).
890 @end defvr
892 @c -----------------------------------------------------------------------------
893 @anchor{space}
894 @defvr {Variable} space
896 Das Leerzeichen.
898 @end defvr
900 @c -----------------------------------------------------------------------------
901 @anchor{tab}
902 @defvr {Variable} tab
904 Das Tabulatorzeichen.
906 @end defvr
908 @c -----------------------------------------------------------------------------
909 @anchor{unicode}
910 @deffn {Funktion} unicode (@var{arg})
912 Gibt das durch @var{arg} definierte Schriftzeichen zur@"uck.
913 @var{arg} kann ein Unicode Codepunkt oder auch eine Zeichenkette mit einem Namen sein,
914 falls das unter Maxima liegende Lisp Unicode vollst@"andig unterst@"utzt.
916 Beispiel: Durch hexadezimale Codepunkte definierte Schriftzeichen
917 (Maxima kompiliert mit SBCL in GNU/Linux).
919 @example
920 (%i1) ibase: 16.$
921 (%i2) map(unicode, [24, 0A3, 20AC]);
922 (%o2) [$, @pounds{}, @euro{}]
923 @end example
925 Warnung: In wxMaxima in Windows ist es nicht m@"oglich,
926 Codepunkte gr@"o@ss{}er 16 Bit in Schriftzeichen umzuwandeln,
927 wenn Maxima mit SBCL kompiliert wurde
928 und das aktuelle externe Format nicht UTF-8 ist.
929 Siehe @ref{adjust_external_format} f@"ur weitere Informationen.
931 @c Command @U not supported by texinfo 5.
932 @c @example
933 @c (%i3) unicode(1D538);
934 @c (%o3) @U{1d538}
935 @c @end example
937 CMUCL verarbeitet keine Codepunkte gr@"o@ss{}er 16 Bit.
938 @code{unicode} gibt dann @code{false} zur@"uck.
939 Als Ausweg kann hier die Umwandlung der Codepunkte in Schriftzeichen @"uber
940 UTF-8-Oktette dienen:
942 @code{octets_to_string(unicode_to_utf8(code_point));}
944 @c Command @U not supported by texinfo 5.
945 @c @example
946 @c (%i4) octets_to_string(unicode_to_utf8(1D538));
947 @c (%o4) @U{1d538}
948 @c @end example
950 Siehe @ref{octets_to_string}, @ref{unicode_to_utf8}.
952 Falls das unter Maxima liegende Lisp Unicode vollst@"andig unterst@"utzt,
953 kann ein Schriftzeichen durch seinen Namen angegeben werden.
955 Das folgende Beispiel ist mit ECL, CLISP und SBCL m@"oglich, wobei mit SBCL in
956 wxMaxima in Windows das externe Format auf UTF-8 gesetzt werden muss.
957 @code{unicode(name)} wird auch von CMUCL unterst@"utzt, jedoch wieder beschr@"ankt
958 auf 16-Bit-Zeichen.
960 Die Zeichenkette als Argument f@"ur @code{unicode} muss prinzipiell die sein,
961 die @code{printf} mit der Spezifikation "~@@c" zur@"uck gibt,
962 jedoch, wie unten gezeigt, ohne den Pr@"afix "#\".
963 Unterstriche k@"onnen durch Leerzeichen und Gro@ss{}- durch Kleinbuchstaben
964 ersetzt werden.
966 Beispiel (fortgesetzt): Ein Schriftzeichen ist durch seinen Namen gegeben
967 (Maxima kompiliert mit SBCL in GNU/Linux).
969 @example
970 (%i3) printf(false, "~@@c", unicode(0DF));
971 (%o3) #\LATIN_SMALL_LETTER_SHARP_S
972 (%i4) unicode("LATIN_SMALL_LETTER_SHARP_S");
973 (%o4) @ss{}
974 (%i5) unicode("Latin small letter sharp S");
975 (%o5) @ss{}
976 @end example
978 @end deffn
980 @c -----------------------------------------------------------------------------
981 @anchor{unicode_to_utf8}
982 @deffn {Funktion} unicode_to_utf8 (@var{code_point})
984 Gibt eine Liste mit UTF-8-Code zur@"uck, der dem Unicode @var{code_point} entspricht.
986 Beispiel: Umwandlung von Unicode Codepunkten in UTF-8 und umgekehrt.
988 @example
989 (%i1) ibase: obase: 16.$
990 (%i2) map(cint, ["$","@pounds{}","@euro{}"]);
991 (%o2) [24, 0A3, 20AC]
992 (%i3) map(unicode_to_utf8, %);
993 (%o3) [[24], [0C2, 0A3], [0E2, 82, 0AC]]
994 (%i4) map(utf8_to_unicode, %);
995 (%o4) [24, 0A3, 20AC]
996 @end example
998 @end deffn
1000 @c -----------------------------------------------------------------------------
1001 @anchor{uppercasep}
1002 @deffn {Funktion} uppercasep (@var{char})
1004 Gibt @code{true} zur@"uck, wenn @var{char} ein Gro@ss{}buchstabe ist.
1006 Hinweis: Siehe Bemerkungen zu @ref{alphacharp}.
1008 @end deffn
1010 @c -----------------------------------------------------------------------------
1011 @anchor{us_ascii_only}
1012 @defvr {Variable} us_ascii_only
1014 Diese Optionsvariable beeinflusst Maxima, wenn die Zeichenkodierung der
1015 Anwendung, in der Maxima l@"auft, UTF-8 ist, das externe Format des Lisp Readers
1016 jedoch nicht.
1018 In GNU/Linux trifft dies zu, wenn Maxima mit GCL kompiliert wurde und
1019 in Windows in wxMaxima in GCL- und SBCL-Versionen.
1020 Es wird empfohlen, in der SBCL-Version das externe Format in UTF-8 abzu@"andern.
1021 Eine Festlegung von @code{us_ascii_only} wird damit unn@"otig.
1022 Siehe @ref{adjust_external_format} f@"ur Details.
1024 @code{us_ascii_only} ist standardm@"a@ss{}ig @code{false}.
1025 Maxima analysiert dann (d.h. in der oben beschriebenen Situation) selbst die UTF-8-Kodierung.
1027 Wurde @code{us_ascii_only} auf @code{true} gesetzt, wird angenommen, dass alle
1028 Zeichenketten, die als Argumente f@"ur Funktionen des Pakets @code{stringproc}
1029 verwendet werden, nur ausschlie@ss{}lich US-ASCII-Zeichen enthalten.
1030 Durch diese Vereinbarung wird die UTF-8-Analyse des Inputs @"uberfl@"ussig
1031 und Zeichenketten k@"onnen effizienter verarbeitet werden.
1033 @end defvr
1035 @c -----------------------------------------------------------------------------
1036 @anchor{utf8_to_unicode}
1037 @deffn {Function} utf8_to_unicode (@var{list})
1039 Gibt den Unicode Codepunkt zur@"uck, der der Liste @var{list} entspricht,
1040 die die UTF-8-Kodierung eines einzelnen Schriftzeichens enthalten muss.
1042 Beispiel: Siehe @ref{unicode_to_utf8}.
1044 @end deffn
1046 @c -----------------------------------------------------------------------------
1047 @node Verarbeitung von Zeichenketten, Oktette und Werkzeuge f@"ur die Kryptographie, Schriftzeichen, stringproc
1048 @section Verarbeitung von Zeichenketten
1049 @c -----------------------------------------------------------------------------
1051 Positionsindizes in Strings sind in Maxima genau so wie Listen 1-indiziert.
1052 Siehe hierzu das Beispiel in @ref{charat}.
1054 @c -----------------------------------------------------------------------------
1055 @anchor{charat}
1056 @deffn {Funktion} charat (@var{string}, @var{n})
1058 Gibt das @var{n}-te Schriftzeichen in @var{string} zur@"uck.
1059 Das erste Zeichen in @var{string} erh@"alt man mit @var{n} = 1.
1061 Beispiel:
1063 @example
1064 (%i1) charat("Lisp",1);
1065 (%o1) L
1066 (%i2) charlist("Lisp")[1];
1067 (%o2) L
1068 @end example
1069 @end deffn
1071 @c -----------------------------------------------------------------------------
1072 @anchor{charlist}
1073 @deffn {Funktion} charlist (@var{string})
1075 Gibt eine Liste mit allen Schriftzeichen in @var{string} zur@"uck.
1077 Beispiel:
1079 @example
1080 (%i1) charlist("Lisp");
1081 (%o1) [L, i, s, p]
1082 @end example
1083 @end deffn
1085 @c -----------------------------------------------------------------------------
1086 @anchor{eval_string}
1087 @deffn {Function} eval_string (@var{str})
1089 Parse the string @var{str} as a Maxima expression and evaluate it. The string
1090 @var{str} may or may not have a terminator (dollar sign @code{$} or semicolon
1091 @code{;}). Only the first expression is parsed and evaluated, if there is more
1092 than one.
1094 Complain if @var{str} is not a string.
1096 See also @ref{parse_string}.
1098 Examples:
1100 @example
1101 (%i1) eval_string ("foo: 42; bar: foo^2 + baz");
1102 (%o1) 42
1103 (%i2) eval_string ("(foo: 42, bar: foo^2 + baz)");
1104 (%o2) baz + 1764
1105 @end example
1106 @end deffn
1108 @c -----------------------------------------------------------------------------
1109 @anchor{parse_string}
1110 @deffn {Function} parse_string (@var{str})
1112 Parse the string @var{str} as a Maxima expression (do not evaluate it). The
1113 string @var{str} may or may not have a terminator (dollar sign @code{$} or
1114 semicolon @code{;}). Only the first expression is parsed, if there is more
1115 than one.
1117 Complain if @var{str} is not a string.
1119 See also @ref{eval_string}.
1121 Examples:
1123 @example
1124 (%i1) parse_string ("foo: 42; bar: foo^2 + baz");
1125 (%o1) foo : 42
1126 (%i2) parse_string ("(foo: 42, bar: foo^2 + baz)");
1127 2
1128 (%o2) (foo : 42, bar : foo + baz)
1129 @end example
1130 @end deffn
1132 @c -----------------------------------------------------------------------------
1133 @anchor{scopy}
1134 @deffn {Funktion} scopy (@var{string})
1136 Gibt eine Kopie der Zeichenkette @var{string} als neue Zeichenkette zur@"uck.
1138 @end deffn
1140 @c -----------------------------------------------------------------------------
1141 @anchor{sdowncase}
1142 @deffn {Funktion} sdowncase (@var{string})
1143 @deffnx {Funktion} sdowncase (@var{string}, @var{start})
1144 @deffnx {Funktion} sdowncase (@var{string}, @var{start}, @var{end})
1146 Arbeitet wie @ref{supcase}, jedoch werden Gro@ss{}- in Kleinbuchstaben umgewandelt.
1148 @end deffn
1150 @c -----------------------------------------------------------------------------
1151 @anchor{sequal}
1152 @deffn {Funktion} sequal (@var{string_1}, @var{string_2})
1154 Gibt @code{true} zur@"uck, wenn @var{string_1} und @var{string_2} die selbe
1155 Zeichensequenz enthalten.
1157 @end deffn
1159 @c -----------------------------------------------------------------------------
1160 @anchor{sequalignore}
1161 @deffn {Funktion} sequalignore (@var{string_1}, @var{string_2})
1163 Arbeitet wie @ref{sequal}, ignoriert jedoch die Gro@ss{}- und Kleinschreibung,
1164 was f@"ur Nicht-US-ASCII-Zeichen nur m@"oglich ist, wenn das unter Maxima liegende
1165 Lisp einen Buchstaben auch als Buchstaben eines Alphabets erkennen kann.
1166 Siehe hierzu die Bemerkungen zu @ref{alphacharp}.
1168 @end deffn
1170 @c -----------------------------------------------------------------------------
1171 @anchor{sexplode}
1172 @deffn {Funktion} sexplode (@var{string})
1174 @code{sexplode} ist ein Alias f@"ur die Funktion @ref{charlist}.
1176 @end deffn
1178 @c -----------------------------------------------------------------------------
1179 @anchor{simplode}
1180 @deffn {Function} simplode (@var{list})
1181 @deffnx {Function} simplode (@var{list}, @var{delim})
1183 @code{simplode} takes a list of expressions and concatenates them into a string.
1184 If no delimiter @var{delim} is specified, @code{simplode} uses no delimiter.
1185 @var{delim} can be any string.
1187 Examples:
1189 @example
1190 (%i1) simplode(["xx[",3,"]:",expand((x+y)^3)]);
1191 (%o1) xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
1192 (%i2) simplode( sexplode("stars")," * " );
1193 (%o2) s * t * a * r * s
1194 (%i3) simplode( ["One","more","coffee."]," " );
1195 (%o3) One more coffee.
1196 @end example
1197 @end deffn
1199 @c -----------------------------------------------------------------------------
1200 @anchor{sinsert}
1201 @deffn {Function} sinsert (@var{seq}, @var{string}, @var{pos})
1203 Returns a string that is a concatenation of @code{substring (@var{string},
1204 1, @var{pos} - 1)}, the string @var{seq} and @code{substring (@var{string},
1205 @var{pos})}. Note that the first character in @var{string} is in position 1.
1207 Examples:
1209 @example
1210 (%i1) s: "A submarine."$
1211 (%i2) concat( substring(s,1,3),"yellow ",substring(s,3) );
1212 (%o2) A yellow submarine.
1213 (%i3) sinsert("hollow ",s,3);
1214 (%o3) A hollow submarine.
1215 @end example
1216 @end deffn
1218 @c -----------------------------------------------------------------------------
1219 @anchor{sinvertcase}
1220 @deffn {Function} sinvertcase (@var{string})
1221 @deffnx {Function} sinvertcase (@var{string}, @var{start})
1222 @deffnx {Function} sinvertcase (@var{string}, @var{start}, @var{end})
1224 Returns @var{string} except that each character from position @var{start} to
1225 @var{end} is inverted. If @var{end} is not given, all characters from
1226 @var{start} to the end of @var{string} are replaced.
1228 Examples:
1230 @example
1231 (%i1) sinvertcase("sInvertCase");
1232 (%o1) SiNVERTcASE
1233 @end example
1234 @end deffn
1236 @c -----------------------------------------------------------------------------
1237 @anchor{slength}
1238 @deffn {Funktion} slength (@var{string})
1240 Gibt die Anzahl der Zeichen in der Zeichenkette @var{string} zur@"uck.
1241 @end deffn
1243 @c -----------------------------------------------------------------------------
1244 @anchor{smake}
1245 @deffn {Funktion} smake (@var{num}, @var{char})
1247 Gibt eine neue Zeichenkette mit @var{num} Zeichen @var{char} zur@"uck.
1249 Beispiel:
1251 @example
1252 (%i1) smake(3,"w");
1253 (%o1) www
1254 @end example
1255 @end deffn
1257 @c -----------------------------------------------------------------------------
1258 @anchor{smismatch}
1259 @deffn {Function} smismatch (@var{string_1}, @var{string_2})
1260 @deffnx {Function} smismatch (@var{string_1}, @var{string_2}, @var{test})
1262 Returns the position of the first character of @var{string_1} at which
1263 @var{string_1} and @var{string_2} differ or @code{false}. Default test function
1264 for matching is @ref{sequal}. If @code{smismatch} should ignore case, use
1265 @ref{sequalignore} as test.
1267 Example:
1269 @example
1270 (%i1) smismatch("seven","seventh");
1271 (%o1) 6
1272 @end example
1273 @end deffn
1275 @c -----------------------------------------------------------------------------
1276 @anchor{split}
1277 @deffn {Function} split (@var{string})
1278 @deffnx {Function} split (@var{string}, @var{delim})
1279 @deffnx {Function} split (@var{string}, @var{delim}, @var{multiple})
1281 Returns the list of all tokens in @var{string}.
1282 Each token is an unparsed string.
1283 @code{split} uses @var{delim} as delimiter.
1284 If @var{delim} is not given, the space character is the default delimiter.
1285 @var{multiple} is a boolean variable with @code{true} by default.
1286 Multiple delimiters are read as one.
1287 This is useful if tabs are saved as multiple space characters.
1288 If @var{multiple} is set to @code{false}, each delimiter is noted.
1290 Examples:
1292 @example
1293 (%i1) split("1.2 2.3 3.4 4.5");
1294 (%o1) [1.2, 2.3, 3.4, 4.5]
1295 (%i2) split("first;;third;fourth",";",false);
1296 (%o2) [first, , third, fourth]
1297 @end example
1298 @end deffn
1300 @c -----------------------------------------------------------------------------
1301 @anchor{sposition}
1302 @deffn {Function} sposition (@var{char}, @var{string})
1304 Returns the position of the first character in @var{string} which matches
1305 @var{char}. The first character in @var{string} is in position 1.
1306 For matching characters ignoring case see @ref{ssearch}.
1307 @end deffn
1309 @c -----------------------------------------------------------------------------
1310 @anchor{sremove}
1311 @deffn {Function} sremove (@var{seq}, @var{string})
1312 @deffnx {Function} sremove (@var{seq}, @var{string}, @var{test})
1313 @deffnx {Function} sremove (@var{seq}, @var{string}, @var{test}, @var{start})
1314 @deffnx {Function} sremove (@var{seq}, @var{string}, @var{test}, @var{start}, @var{end})
1316 Returns a string like @var{string} but without all substrings matching
1317 @var{seq}. Default test function for matching is @ref{sequal}.
1318 If @code{sremove} should ignore case while searching for @var{seq},
1319 use @ref{sequalignore} as test. Use @var{start} and @var{end} to limit searching.
1320 Note that the first character in @var{string} is in position 1.
1322 Examples:
1324 @example
1325 (%i1) sremove("n't","I don't like coffee.");
1326 (%o1) I do like coffee.
1327 (%i2) sremove ("DO ",%,'sequalignore);
1328 (%o2) I like coffee.
1329 @end example
1330 @end deffn
1332 @c -----------------------------------------------------------------------------
1333 @anchor{sremovefirst}
1334 @deffn {Function} sremovefirst (@var{seq}, @var{string})
1335 @deffnx {Function} sremovefirst (@var{seq}, @var{string}, @var{test})
1336 @deffnx {Function} sremovefirst (@var{seq}, @var{string}, @var{test}, @var{start})
1337 @deffnx {Function} sremovefirst (@var{seq}, @var{string}, @var{test}, @var{start}, @var{end})
1339 Like @code{sremove} except that only the first substring that matches @code{seq}
1340 is removed.
1341 @end deffn
1343 @c -----------------------------------------------------------------------------
1344 @anchor{sreverse}
1345 @deffn {Funktion} sreverse (@var{string})
1347 Gibt eine Zeichenkette mit allen Zeichen von @var{string} in umgekehrter
1348 Reihenfolge zur@"uck.
1350 @end deffn
1352 @c -----------------------------------------------------------------------------
1353 @anchor{ssearch}
1354 @deffn {Function} ssearch (@var{seq}, @var{string})
1355 @deffnx {Function} ssearch (@var{seq}, @var{string}, @var{test})
1356 @deffnx {Function} ssearch (@var{seq}, @var{string}, @var{test}, @var{start})
1357 @deffnx {Function} ssearch (@var{seq}, @var{string}, @var{test}, @var{start}, @var{end})
1359 Returns the position of the first substring of @var{string} that matches the
1360 string @var{seq}. Default test function for matching is @ref{sequal}.
1361 If @code{ssearch} should ignore case, use @ref{sequalignore} as test.
1362 Use @var{start} and @var{end} to limit searching. Note that the first character in
1363 @var{string} is in position 1.
1365 @example
1366 (%i1) ssearch("~s","~@{~S ~@}~%",'sequalignore);
1367 (%o1) 4
1368 @end example
1370 @end deffn
1372 @c -----------------------------------------------------------------------------
1373 @anchor{ssort}
1374 @deffn {Function} ssort (@var{string})
1375 @deffnx {Function} ssort (@var{string}, @var{test})
1377 Returns a string that contains all characters from @var{string} in an order such
1378 there are no two successive characters @var{c} and @var{d} such that
1379 @code{test (@var{c}, @var{d})} is @code{false} and @code{test (@var{d},
1380 @var{c})} is @code{true}. Default test function for sorting is
1381 @ref{clessp}. The set of test functions is
1382 @code{@{@ref{clessp}, @ref{clesspignore}, @ref{cgreaterp}, @ref{cgreaterpignore}, @ref{cequal}, @ref{cequalignore}@}}.
1384 @example
1385 (%i1) ssort("I don't like Mondays.");
1386 (%o1) '.IMaddeiklnnoosty
1387 (%i2) ssort("I don't like Mondays.",'cgreaterpignore);
1388 (%o2) ytsoonnMlkIiedda.'
1389 @end example
1390 @end deffn
1392 @c -----------------------------------------------------------------------------
1393 @anchor{ssubst}
1394 @deffn {Function} ssubst (@var{new}, @var{old}, @var{string})
1395 @deffnx {Function} ssubst (@var{new}, @var{old}, @var{string}, @var{test})
1396 @deffnx {Function} ssubst (@var{new}, @var{old}, @var{string}, @var{test}, @var{start})
1397 @deffnx {Function} ssubst (@var{new}, @var{old}, @var{string}, @var{test}, @var{start}, @var{end})
1399 Returns a string like @var{string} except that all substrings matching @var{old}
1400 are replaced by @var{new}. @var{old} and @var{new} need not to be of the same
1401 length. Default test function for matching is @ref{sequal}. If
1402 @code{ssubst} should ignore case while searching for old, use
1403 @ref{sequalignore} as test. Use @var{start} and @var{end} to limit searching.
1404 Note that the first character in @var{string} is in position 1.
1406 @example
1407 (%i1) ssubst("like","hate","I hate Thai food. I hate green tea.");
1408 (%o1) I like Thai food. I like green tea.
1409 (%i2) ssubst("Indian","thai",%,'sequalignore,8,12);
1410 (%o2) I like Indian food. I like green tea.
1411 @end example
1412 @end deffn
1414 @c -----------------------------------------------------------------------------
1415 @anchor{ssubstfirst}
1416 @deffn {Function} ssubstfirst (@var{new}, @var{old}, @var{string})
1417 @deffnx {Function} ssubstfirst (@var{new}, @var{old}, @var{string}, @var{test})
1418 @deffnx {Function} ssubstfirst (@var{new}, @var{old}, @var{string}, @var{test}, @var{start})
1419 @deffnx {Function} ssubstfirst (@var{new}, @var{old}, @var{string}, @var{test}, @var{start}, @var{end})
1421 Like @ref{subst} except that only the first substring that matches @var{old}
1422 is replaced.
1423 @end deffn
1425 @c -----------------------------------------------------------------------------
1426 @anchor{strim}
1427 @deffn {Function} strim (@var{seq},@var{string})
1429 Returns a string like @var{string}, but with all characters that appear in
1430 @var{seq} removed from both ends.
1432 @example
1433 (%i1) "/* comment */"$
1434 (%i2) strim(" /*",%);
1435 (%o2) comment
1436 (%i3) slength(%);
1437 (%o3) 7
1438 @end example
1439 @end deffn
1441 @c -----------------------------------------------------------------------------
1442 @anchor{striml}
1443 @deffn {Function} striml (@var{seq}, @var{string})
1445 Like @ref{strim} except that only the left end of @var{string} is trimmed.
1446 @end deffn
1448 @c -----------------------------------------------------------------------------
1449 @anchor{strimr}
1450 @deffn {Function} strimr (@var{seq}, @var{string})
1452 Like @ref{strim} except that only the right end of string is trimmed.
1453 @end deffn
1455 @c -----------------------------------------------------------------------------
1456 @anchor{stringp}
1457 @deffn {Funktion} stringp (@var{obj})
1459 Gibt @code{true} zur@"uck, wenn @var{obj} eine Zeichenkette ist.
1461 Beispiel: Siehe Einf@"uhrung.
1463 @end deffn
1465 @c -----------------------------------------------------------------------------
1466 @anchor{substring}
1467 @deffn {Function} substring (@var{string}, @var{start})
1468 @deffnx {Function} substring (@var{string}, @var{start}, @var{end})
1470 Returns the substring of @var{string} beginning at position @var{start} and
1471 ending at position @var{end}. The character at position @var{end} is not
1472 included. If @var{end} is not given, the substring contains the rest of the
1473 string. Note that the first character in @var{string} is in position 1.
1475 @example
1476 (%i1) substring("substring",4);
1477 (%o1) string
1478 (%i2) substring(%,4,6);
1479 (%o2) in
1480 @end example
1482 @end deffn
1484 @c -----------------------------------------------------------------------------
1485 @anchor{supcase}
1486 @deffn {Function} supcase (@var{string})
1487 @deffnx {Function} supcase (@var{string}, @var{start})
1488 @deffnx {Function} supcase (@var{string}, @var{start}, @var{end})
1490 Returns @var{string} except that lowercase characters from position @var{start}
1491 to @var{end} are replaced by the corresponding uppercase ones. If @var{end} is
1492 not given, all lowercase characters from @var{start} to the end of @var{string}
1493 are replaced.
1495 @example
1496 (%i1) supcase("english",1,2);
1497 (%o1) English
1498 @end example
1500 @end deffn
1502 @c -----------------------------------------------------------------------------
1503 @anchor{tokens}
1504 @deffn {Function} tokens (@var{string})
1505 @deffnx {Function} tokens (@var{string}, @var{test})
1507 Returns a list of tokens, which have been extracted from @var{string}.
1508 The tokens are substrings whose characters satisfy a certain test function.
1509 If @var{test} is not given, @var{constituent} is used as the default test.
1510 @code{@{constituent, alphacharp, digitcharp, lowercasep, uppercasep, charp, characterp, alphanumericp@}} is the set of test functions.
1511 (The Lisp-version of @code{tokens} is written by Paul Graham. ANSI Common Lisp, 1996, page 67.)
1513 @example
1514 (%i1) tokens("24 October 2005");
1515 (%o1) [24, October, 2005]
1516 (%i2) tokens("05-10-24",'digitcharp);
1517 (%o2) [05, 10, 24]
1518 (%i3) map(parse_string,%);
1519 (%o3) [5, 10, 24]
1520 @end example
1522 @end deffn
1524 @c -----------------------------------------------------------------------------
1525 @node Oktette und Werkzeuge f@"ur die Kryptographie, , Verarbeitung von Zeichenketten, stringproc
1526 @section Oktette und Werkzeuge f@"ur die Kryptographie
1527 @c -----------------------------------------------------------------------------
1529 @c -----------------------------------------------------------------------------
1530 @anchor{base64}
1531 @deffn {Funktion} base64 (@var{arg})
1533 Gibt eine Base64-Darstellung von @var{arg} zur@"uck.
1534 Das Argument @var{arg} kann eine Zeichenkette, eine nicht-negative Ganzzahl
1535 oder eine Liste von Oktetten sein.
1537 Beispiel:
1539 @example
1540 (%i1) base64: base64("foo bar baz");
1541 (%o1) Zm9vIGJhciBiYXo=
1542 (%i2) string: base64_decode(base64);
1543 (%o2) foo bar baz
1544 (%i3) obase: 16.$
1545 (%i4) integer: base64_decode(base64, 'number);
1546 (%o4) 666f6f206261722062617a
1547 (%i5) octets: base64_decode(base64, 'list);
1548 (%o5) [66, 6F, 6F, 20, 62, 61, 72, 20, 62, 61, 7A]
1549 (%i6) ibase: 16.$
1550 (%i7) base64(octets);
1551 (%o7) Zm9vIGJhciBiYXo=
1552 @end example
1554 Sind in @var{arg} Umlaute oder Eszett enthalten (bzw. Oktette gr@"o@ss{}er
1555 als 127), ist das Ergebnis von der verwendeten Plattform abh@"angig.
1556 Es wird aber durch eine Anwendung von @ref{base64_decode} in jedem Fall
1557 wieder in die urspr@"ungliche Zeichenkette zur@"uck verwandelt.
1559 @end deffn
1561 @c -----------------------------------------------------------------------------
1562 @anchor{base64_decode}
1563 @deffn {Funktion} base64_decode (@var{base64-string})
1564 @deffnx {Funktion} base64_decode (@var{base64-string}, @var{return-type})
1566 Dekodiert die Base64-kodierte Zeichenkette @var{base64-string} standardm@"a@ss{}ig
1567 wieder zur@"uck in die urspr@"ungliche Zeichenkette.
1569 Das optionale Argument @var{return-type} erlaubt es @code{base64_decode},
1570 alternativ hierzu auch die entsprechende Ganzzahl oder Liste von Oktetten
1571 zur@"uck zu geben.
1572 @var{return-type} kann @code{string}, @code{number} oder @code{list} sein.
1574 Beispiel: Siehe @ref{base64}.
1575 @end deffn
1577 @c -----------------------------------------------------------------------------
1578 @anchor{crc24sum}
1579 @deffn {Funktion} crc24sum (@var{octets})
1580 @deffnx {Funktion} crc24sum (@var{octets}, @var{return-type})
1582 Gibt standardm@"a@ss{}ig die @code{CRC24}-Pr@"ufsumme einer Oktett-Liste als
1583 Zeichenkette zur@"uck.
1585 Das optionale Argument @var{return-type} erlaubt es @code{crc24sum},
1586 alternativ hierzu auch die entsprechende Ganzzahl oder Liste von Oktetten
1587 zur@"uck zu geben.
1588 @var{return-type} kann @code{string}, @code{number} oder @code{list} sein.
1590 Beispiel:
1591 @example
1592 -----BEGIN PGP SIGNATURE-----
1593 Version: GnuPG v2.0.22 (GNU/Linux)
1595 iQEcBAEBAgAGBQJVdCTzAAoJEG/1Mgf2DWAqCSYH/AhVFwhu1D89C3/QFcgVvZTM
1596 wnOYzBUURJAL/cT+IngkLEpp3hEbREcugWp+Tm6aw3R4CdJ7G3FLxExBH/5KnDHi
1597 rBQu+I7+3ySK2hpryQ6Wx5J9uZSa4YmfsNteR8up0zGkaulJeWkS4pjiRM+auWVe
1598 vajlKZCIK52P080DG7Q2dpshh4fgTeNwqCuCiBhQ73t8g1IaLdhDN6EzJVjGIzam
1599 /spqT/sTo6sw8yDOJjvU+Qvn6/mSMjC/YxjhRMaQt9EMrR1AZ4ukBF5uG1S7mXOH
1600 WdiwkSPZ3gnIBhM9SuC076gLWZUNs6NqTeE3UzMjDAFhH3jYk1T7mysCvdtIkms=
1601 =WmeC
1602 -----END PGP SIGNATURE-----
1603 @end example
1605 @example
1606 (%i1) ibase : obase : 16.$
1607 (%i2) sig64 : sconcat(
1608 "iQEcBAEBAgAGBQJVdCTzAAoJEG/1Mgf2DWAqCSYH/AhVFwhu1D89C3/QFcgVvZTM",
1609 "wnOYzBUURJAL/cT+IngkLEpp3hEbREcugWp+Tm6aw3R4CdJ7G3FLxExBH/5KnDHi",
1610 "rBQu+I7+3ySK2hpryQ6Wx5J9uZSa4YmfsNteR8up0zGkaulJeWkS4pjiRM+auWVe",
1611 "vajlKZCIK52P080DG7Q2dpshh4fgTeNwqCuCiBhQ73t8g1IaLdhDN6EzJVjGIzam",
1612 "/spqT/sTo6sw8yDOJjvU+Qvn6/mSMjC/YxjhRMaQt9EMrR1AZ4ukBF5uG1S7mXOH",
1613 "WdiwkSPZ3gnIBhM9SuC076gLWZUNs6NqTeE3UzMjDAFhH3jYk1T7mysCvdtIkms=" )$
1614 (%i3) octets: base64_decode(sig64, 'list)$
1615 (%i4) crc24: crc24sum(octets, 'list);
1616 (%o4) [5A, 67, 82]
1617 (%i5) base64(crc24);
1618 (%o5) WmeC
1619 @end example
1621 @end deffn
1623 @c -----------------------------------------------------------------------------
1624 @anchor{md5sum}
1625 @deffn {Funktion} md5sum (@var{arg})
1626 @deffnx {Funktion} md5sum (@var{arg}, @var{return-type})
1628 Gibt die @code{md5}-Pr@"ufsumme einer Zeichenkette, einer nicht-negativen Ganzzahl
1629 oder einer Liste von Oktetten zur@"uck. Der standardm@"a@ss{}ige R@"uckgabewert
1630 ist eine Zeichenkette mit 32 hexadezimalen Zeichen.
1632 Das optionale Argument @var{return-type} erlaubt es @code{md5sum},
1633 alternativ hierzu auch die entsprechende Ganzzahl oder Liste von Oktetten
1634 zur@"uck zu geben.
1635 @var{return-type} kann @code{string}, @code{number} oder @code{list} sein.
1638 Beispiel:
1640 @example
1641 (%i1) ibase: obase: 16.$
1642 (%i2) msg: "foo bar baz"$
1643 (%i3) string: md5sum(msg);
1644 (%o3) ab07acbb1e496801937adfa772424bf7
1645 (%i4) integer: md5sum(msg, 'number);
1646 (%o4) 0ab07acbb1e496801937adfa772424bf7
1647 (%i5) octets: md5sum(msg, 'list);
1648 (%o5) [0AB,7,0AC,0BB,1E,49,68,1,93,7A,0DF,0A7,72,42,4B,0F7]
1649 (%i6) sdowncase( printf(false, "~@{~2,'0x~^:~@}", octets) );
1650 (%o6) ab:07:ac:bb:1e:49:68:01:93:7a:df:a7:72:42:4b:f7
1651 @end example
1653 Sind in @var{arg} Umlaute oder andere Nicht-US-ASCII-Zeichen enthalten (bzw. Oktette
1654 gr@"o@ss{}er als 127), ist das Ergebnis von der verwendeten Plattform abh@"angig.
1656 @end deffn
1658 @c -----------------------------------------------------------------------------
1659 @anchor{mgf1_sha1}
1660 @deffn {Funktion} mgf1_sha1 (@var{seed}, @var{len})
1661 @deffnx {Funktion} mgf1_sha1 (@var{seed}, @var{len}, @var{return-type})
1663 Gibt eine Pseudozufallszahl variabler L@"ange zur@"uck.
1664 Standardm@"a@ss{}ig ist dies eine Zahl mit einer L@"ange von @var{len} Oktetten.
1666 Das optionale Argument @var{return-type} erlaubt es @code{mgf1_sha1},
1667 alternativ hierzu die Liste mit den @var{len} entsprechenden Oktetten
1668 zur@"uck zu geben.
1669 @var{return-type} kann @code{number} oder @code{list} sein.
1671 Die Berechnung des R@"uckgabewerts wird in der @code{RFC 3447}
1672 im Anhang @code{B.2.1 MGF1} beschrieben.
1673 Verwendet wird dabei @code{SHA1} als Hashfunktion, d.h. die Zuf@"alligkeit der
1674 berechneten Zahl beruht auf der Zuf@"alligkeit von @code{SHA1}-Hashwerten.
1676 Beispiel:
1678 @example
1679 (%i1) ibase: obase: 16.$
1680 (%i2) number: mgf1_sha1(4711., 8);
1681 (%o2) 0e0252e5a2a42fea1
1682 (%i3) octets: mgf1_sha1(4711., 8, 'list);
1683 (%o3) [0E0,25,2E,5A,2A,42,0FE,0A1]
1684 @end example
1686 @end deffn
1688 @c -----------------------------------------------------------------------------
1689 @anchor{number_to_octets}
1690 @deffn {Funktion} number_to_octets (@var{number})
1692 Gibt eine Oktett-Darstellung der nicht-negativen Ganzzahl @var{number} in Form
1693 einer Liste zur@"uck.
1695 Beispiel:
1697 @example
1698 (%i1) ibase : obase : 16.$
1699 (%i2) octets: [0ca,0fe,0ba,0be]$
1700 (%i3) number: octets_to_number(octets);
1701 (%o3) 0cafebabe
1702 (%i4) number_to_octets(number);
1703 (%o4) [0CA, 0FE, 0BA, 0BE]
1704 @end example
1706 @end deffn
1708 @c -----------------------------------------------------------------------------
1709 @anchor{octets_to_number}
1710 @deffn {Funktion} octets_to_number (@var{octets})
1712 F@"ugt die in der Liste @var{octets} enthaltenden Oktette zu einer Zahl zusammen
1713 und gibt diese zur@"uck.
1715 Beispiel: Siehe @ref{number_to_octets}.
1717 @end deffn
1719 @c -----------------------------------------------------------------------------
1720 @anchor{octets_to_oid}
1721 @deffn {Funktion} octets_to_oid (@var{octets})
1723 Berechnet eine Objektkennung (OID) aus einer Liste von Oktetten.
1725 Beispiel: RSA encryption OID
1727 @example
1728 (%i1) ibase : obase : 16.$
1729 (%i2) oid: octets_to_oid([2A,86,48,86,0F7,0D,1,1,1]);
1730 (%o2) 1.2.840.113549.1.1.1
1731 (%i3) oid_to_octets(oid);
1732 (%o3) [2A, 86, 48, 86, 0F7, 0D, 1, 1, 1]
1733 @end example
1735 @end deffn
1737 @c -----------------------------------------------------------------------------
1738 @anchor{octets_to_string}
1739 @deffn {Funktion} octets_to_string (@var{octets})
1740 @deffnx {Funktion} octets_to_string (@var{octets}, @var{encoding})
1742 Dekodiert den aktuellen Systemstandards entsprechend die Liste @var{octets}
1743 in eine Zeichenkette.
1744 Bei der Dekodierung von Oktetten, die nicht ausschlie@ss{}lich US-ASCII-Zeichen
1745 entsprechen, ist das Ergebnis abh@"angig von der Plattform, der Anwendung und vom
1746 unter Maxima liegenden Lisp.
1748 Beispiel: Die Verwendung des Systemstandards
1749 (Maxima kompiliert mit GCL, das keine Format-Definition verwendet und die
1750 vom GNU/Linux Terminal kodierten UTF-8-Oktette unge@"andert an Maxima weitergibt).
1752 @example
1753 (%i1) octets: string_to_octets("abc");
1754 (%o1) [61, 62, 63]
1755 (%i2) octets_to_string(octets);
1756 (%o2) abc
1757 (%i3) ibase: obase: 16.$
1758 (%i4) unicode(20AC);
1759 (%o4) @euro{}
1760 (%i5) octets: string_to_octets(%);
1761 (%o5) [0E2, 82, 0AC]
1762 (%i6) octets_to_string(octets);
1763 (%o6) @euro{}
1764 (%i7) utf8_to_unicode(octets);
1765 (%o7) 20AC
1766 @end example
1768 In dem Fall, dass UTF-8 das externe Format des Lisp Readers ist, kann das
1769 optionale Argument @var{encoding} genutzt werden, um f@"ur die Oktett-String-Umwandlung
1770 eine gewünschte Kodierung auszuw@"ahlen.
1771 Siehe @ref{adjust_external_format}, falls es notwendig sein sollte, hierf@"ur das
1772 externe Format zu @"andern.
1774 Die Namen einiger unterst@"utzter Kodierungen
1775 (weitere siehe das entsprechende Lisp Manual): @*
1776 CCL, CLISP, SBCL: @code{utf-8, ucs-2be, ucs-4be, iso-8859-1, cp1252, cp850} @*
1777 CMUCL: @code{utf-8, utf-16-be, utf-32-be, iso8859-1, cp1252} @*
1778 ECL: @code{utf-8, ucs-2be, ucs-4be, iso-8859-1, windows-cp1252, dos-cp850}
1780 Beispiel (fortgesetzt): Die Verwendung des optionalen Arguments
1781 (Maxima kompiliert mit SBCL, GNU/Linux Terminal).
1783 @example
1784 (%i8) string_to_octets("@euro{}", "ucs-2be");
1785 (%o8) [20, 0AC]
1786 @end example
1788 @end deffn
1790 @c -----------------------------------------------------------------------------
1791 @anchor{oid_to_octets}
1792 @deffn {Funktion} oid_to_octets (@var{oid-string})
1794 Verwandelt eine Objektkennung (OID) in eine Liste von Oktetten.
1796 Beispiel: Siehe @ref{octets_to_oid}.
1798 @end deffn
1800 @c -----------------------------------------------------------------------------
1801 @anchor{sha1sum}
1802 @deffn {Funktion} sha1sum (@var{arg})
1803 @deffnx {Funktion} sha1sum (@var{arg}, @var{return-type})
1805 Gibt den @code{SHA1}-Fingerabdruck einer Zeichenkette, einer nicht-negativen Ganzzahl
1806 oder einer Liste von Oktetten zur@"uck. Der standardm@"a@ss{}ige R@"uckgabewert
1807 ist eine Zeichenkette mit 40 hexadezimalen Zeichen.
1809 Das optionale Argument @var{return-type} erlaubt es @code{sha1sum},
1810 alternativ hierzu auch die entsprechende Ganzzahl oder Liste von Oktetten
1811 zur@"uck zu geben.
1812 @var{return-type} kann @code{string}, @code{number} oder @code{list} sein.
1814 Beispiel:
1816 @example
1817 (%i1) ibase: obase: 16.$
1818 (%i2) msg: "foo bar baz"$
1819 (%i3) string: sha1sum(msg);
1820 (%o3) c7567e8b39e2428e38bf9c9226ac68de4c67dc39
1821 (%i4) integer: sha1sum(msg, 'number);
1822 (%o4) 0c7567e8b39e2428e38bf9c9226ac68de4c67dc39
1823 (%i5) octets: sha1sum(msg, 'list);
1824 (%o5) [0C7,56,7E,8B,39,0E2,42,8E,38,0BF,9C,92,26,0AC,68,0DE,4C,67,0DC,39]
1825 (%i6) sdowncase( printf(false, "~@{~2,'0x~^:~@}", octets) );
1826 (%o6) c7:56:7e:8b:39:e2:42:8e:38:bf:9c:92:26:ac:68:de:4c:67:dc:39
1827 @end example
1829 Sind in @var{arg} Umlaute oder andere Nicht-US-ASCII-Zeichen enthalten (bzw. Oktette
1830 gr@"o@ss{}er als 127), ist der @code{SHA1}-Fingerabdruck von der verwendeten
1831 Plattform abh@"angig.
1833 @end deffn
1835 @c -----------------------------------------------------------------------------
1836 @anchor{sha256sum}
1837 @deffn {Funktion} sha256sum (@var{arg})
1838 @deffnx {Funktion} sha256sum (@var{arg}, @var{return-type})
1840 Gibt den @code{SHA256}-Fingerabdruck einer Zeichenkette, einer nicht-negativen
1841 Ganzzahl oder einer Liste von Oktetten zur@"uck. Der standardm@"a@ss{}ige
1842 R@"uckgabewert ist eine Zeichenkette mit 64 hexadezimalen Zeichen.
1844 Das optionale Argument @var{return-type} erlaubt es @code{sha256sum},
1845 alternativ hierzu auch die entsprechende Ganzzahl oder Liste von Oktetten
1846 zur@"uck zu geben (siehe @ref{sha1sum}).
1848 Beispiel:
1850 @example
1851 (%i1) string: sha256sum("foo bar baz");
1852 (%o1) dbd318c1c462aee872f41109a4dfd3048871a03dedd0fe0e757ced57dad6f2d7
1853 @end example
1855 Sind in @var{arg} Umlaute oder andere Nicht-US-ASCII-Zeichen enthalten (bzw. Oktette
1856 gr@"o@ss{}er als 127), ist der @code{SHA256}-Fingerabdruck von der verwendeten
1857 Plattform abh@"angig.
1859 @end deffn
1861 @c -----------------------------------------------------------------------------
1862 @anchor{string_to_octets}
1863 @deffn {Funktion} string_to_octets (@var{string})
1864 @deffnx {Funktion} string_to_octets (@var{string}, @var{encoding})
1866 Kodiert den aktuellen Systemstandards entsprechend die Zeichenkette @var{string}
1867 in eine Liste von Oktetten.
1868 Bei der Kodierung von Zeichenketten, die nicht ausschlie@ss{}lich US-ASCII-Zeichen
1869 enthalten, ist das Ergebnis abh@"angig von der Plattform, der Anwendung und vom
1870 unter Maxima liegenden Lisp.
1872 In dem Fall, dass UTF-8 das externe Format des Lisp Readers ist, kann das
1873 optionale Argument @var{encoding} genutzt werden, um f@"ur die String-Oktett-Umwandlung
1874 eine gewünschte Kodierung auszuw@"ahlen.
1875 Siehe @ref{adjust_external_format}, falls es notwendig sein sollte, hierf@"ur das
1876 externe Format zu @"andern.
1878 Siehe @ref{octets_to_string} f@"ur Beispiele und zus@"atzliche Informationen.
1880 @end deffn
1883 @c --- End of file stringproc.de.texi ------------------------------------------