Executing External Programs/pl: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1		-	~~<div style="font-size:1.88em;margin:0.75em 0;">~~
2		-
3	1		Wykonywanie programów zewnętrznych
4		-
5		-	~~</div>~~
6	2
7	3		## Przegląd: Porównanie
8	4
9	5		Istnieją różne sposoby dostępne w bibliotekach RTL, FCL i LCL dotyczące wykonywania zewnętrznego polecenia/procesu/programu.
10	6
11	7		\| Metoda \| Biblioteka \| Platformy \| Pojedyncza linia \| Cechy \|
12	8		\|----\|----\|----\|----\|----\|
13	9		\| [[Executing External Programs/pl\|ExecuteProcess]] \| RTL \| Wieloplatformowy \| Tak \| Bardzo ograniczone, synchroniczne. \|
14	10		\| [[Executing External Programs/pl\|ShellExecute]] \| WinAPI \| Tylko MS Windows \| Tak \| Wiele. Może uruchamiać programy z podwyższonymi uprawnieniami administratora. \|
15	11		\| [[Executing External Programs/pl\|fpsystem, fpexecve]] \| Unix \| Tylko Unix \| \| \|
16	12		\| [[Executing External Programs/pl\|TProcess]] \| FCL \| Wieloplatformowy \| Nie \| Pełny. \|
17	13		\| [[Executing External Programs/pl\|RunCommand]] \| FCL \| Wieloplatformowy Wymaga FPC 2.6.2+ \| Tak \| Obejmuje typowe użycie TProcess. \|
18	14		\| [[Executing External Programs/pl\|OpenDocument]] \| LCL \| Wieloplatformowy \| Tak \| Tylko otwarty dokument. Dokument otworzy się z aplikacją powiązaną z podanym typem dokumentu. \|
19	15
20	16		## (Proces.)RunCommand
21	17
22	18		- Odnośnik do [RunCommand](http://www.freepascal.org/docs-html/fcl/process/runcommand.html)
23	19		- Odnośnik do [RunCommandInDir](http://www.freepascal.org/docs-html/fcl/process/runcommandindir.html)
24	20
25	21		W FPC 2.6.2 niektóre funkcje pomocnicze dla TProcess zostały dodane do modułu process w oparciu o wrappery (funkcje lub klasy opakowujące) używane w projekcie [[Projects using Lazarus\|fpcup]]. Te funkcje są przeznaczone do użytku podstawowego i pośredniego, i mogą przechwytywać dane wyjściowe do pojedynczego ciągu string i w pełni obsługiwać duże dane wyjściowe.
26	22
27	23		Prosty przykład to:
28	24
29	25		``` pascal
30	26		program project1;
31	27
32	28		{$mode objfpc}{$H+}
33	29
34	30		uses
35	31		Process;
36	32
37	33		var
38	34		s : ansistring;
39	35
40	36		begin
41	37
42	38		if RunCommand('/bin/bash',['-c','echo $PATH'],s) then
43	39		writeln(s);
44	40
45	41		end.
46	42		```
47	43
48	44		Zauważ jednak, że nie wszystkie „wbudowane” polecenia powłoki (np. aliasy) działają, ponieważ aliasy domyślnie nie są rozwijane w powłokach nieinteraktywnych, a .bashrc nie jest odczytywany przez powłoki nieinteraktywne, chyba że ustawisz zmienną środowiskową BASH_ENV. tak więc poniższy przykąłd nie daje żadnych danych wyjściowych:
49	45
50	46		``` pascal
51	47		program project2;
52	48
53	49		{$mode objfpc}{$H+}
54	50
55	51		uses
56	52		Process;
57	53
58	54		var
59	55		s : ansistring;
60	56
61	57		begin
62	58
63	59		if RunCommand('/bin/bash',['-c','alias'],s) then
64	60		writeln(s);
65	61
66	62		end.
67	63		```
68	64
69	65		Przeciążony wariant RunCommand zwraca kod wyjścia programu. RunCommandInDir uruchamia polecenie w innym katalogu (ustawia p.CurrentDirectory):
70	66
71	67		``` pascal
72	68		function RunCommandIndir(const curdir:string;const exename:string;const commands:array of string;var outputstring:string; var exitstatus:integer): integer;
73	69		function RunCommandIndir(const curdir:string;const exename:string;const commands:array of string;var outputstring:string): boolean;
74	70		function RunCommand(const exename:string;const commands:array of string;var outputstring:string): boolean;
75	71		```
76	72
77	73		W FPC 3.2.0+ RunCommand otrzymał dodatkowe warianty, które pozwalają nadpisać TProcessOptions i WindowOptions.
78	74
79	75		### Rozszerzenia RunCommand
80	76
81	77		W FPC 3.2.0+ implementacja RunCommand została uogólniona i ponownie zintegrowana z TProcess, aby umożliwić szybszą budowę własnych wariantów. Jako przykład wariant RunCommand z limitem czasu:
82	78
83	79		``` pascal
84	80
85	81		{$mode delphi}
86	82		uses classes, sysutils, process, dateutils;
87	83		type
88	84		{ TProcessTimeout }
89	85		TProcessTimeout = class(TProcess)
90	86		public
91	87		timeoutperiod: TTime;
92	88		timedout : boolean;
93	89		started : TDateTime;
94	90		procedure LocalnIdleSleep(Sender,Context : TObject;status:TRunCommandEventCode;const message:string);
95	91		end;
96	92
97	93		procedure TProcessTimeout.LocalnIdleSleep(Sender,Context : TObject;status:TRunCommandEventCode;const message:string);
98	94		begin
99	95		if status=RunCommandIdle then
100	96		begin
101	97		if (now-started)>timeoutperiod then
102	98		begin
103	99		timedout:=true;
104	100		Terminate(255);
105	101		exit;
106	102		end;
107	103		sleep(RunCommandSleepTime);
108	104		end;
109	105		end;
110	106
111	107		function RunCommandTimeout(const exename:TProcessString;const commands:array of TProcessString;out outputstring:string; Options : TProcessOptions = [];SWOptions:TShowWindowOptions=swoNone;timeout:integer=60):boolean;
112	108		Var
113	109		p : TProcessTimeout;
114	110		i,
115	111		exitstatus : integer;
116	112		ErrorString : String;
117	113		begin
118	114		p:=TProcessTimeout.create(nil);
119	115		p.OnRunCommandEvent:=p.LocalnIdleSleep;
120	116		p.timeoutperiod:=timeout/SecsPerDay;
121	117		if Options<>[] then
122	118		P.Options:=Options - [poRunSuspended,poWaitOnExit];
123	119		p.options:=p.options+[poRunIdle]; // potrzebne do uruchomienia zdarzenia RUNIDLE. Zobacz Zmiany Użytkownika dla wersji 3.2.0
124	120
125	121		P.ShowWindow:=SwOptions;
126	122		p.Executable:=exename;
127	123		if high(commands)>=0 then
128	124		for i:=low(commands) to high(commands) do
129	125		p.Parameters.add(commands[i]);
130	126		p.timedout:=false;
131	127		p.started:=now;
132	128		try
133	129		// główna pętla wariantów runcommand(), pierwotnie oparta na scenariuszu "dużego wyjścia" na wiki, ale stale rozwijana przez 5 lat.
134	130		result:=p.RunCommandLoop(outputstring,errorstring,exitstatus)=0;
135	131		if p.timedout then
136	132		result:=false;
137	133		finally
138	134		p.free;
139	135		end;
140	136		if exitstatus<>0 then result:=false;
141	137		end;
142	138
143	139		// przykładowe zastosowanie:
144	140
145	141		var
146	142		s : string;
147	143		begin
148	144		for s in FileList do
149	145		begin
150	146		if not RunCommandTimeout('someexe',['-v',s,'--output','dest\'+s],err,[],swoNone,60) then
151	147		begin
152	148		// nie udało się uruchomić lub upłynął limit czasu. np. movefile() do "wadliwego" katalogu.
153	149		end
154	150		else
155	151		begin
156	152		// ok, plik przeniesiony do "dobrego" katalogu.
157	153		end;
158	154		end;
159	155		end;
160	156		```
161	157
162	158		## SysUtils.ExecuteProcess
163	159
164	160		(Wieloplatformowy)\
165	161		Pomimo wielu ograniczeń, najprostszym sposobem uruchomienia programu (modalnego, bez potoków lub jakiejkolwiek formy sterowania) jest po prostu użycie:
166	162
167	163		``` pascal
168	164		SysUtils.ExecuteProcess(UTF8ToSys('/full/path/to/binary'), '', []);
169	165		```
170	166
171	167		Proces wywołujący działa synchronicznie: „zawiesza się” do momentu zakończenia działania zewnętrznego programu — ale może to być przydatne, jeśli wymagasz od użytkownika wykonania czegoś przed kontynuowaniem pracy w aplikacji. Aby uzyskać bardziej wszechstronne podejście, zapoznaj się z sekcją dotyczącą preferowanego międzyplatformowego RunCommand lub innej funkcjonalności TProcess, lub jeśli chcesz obsługiwać tylko system Windows, możesz użyć ShellExecute.
172	168
173	169		- Odniesienie do [ExecuteProcess](http://www.freepascal.org/docs-html/rtl/sysutils/executeprocess.html)
174	170
175	171		## MS Windows: CreateProcess, ShellExecute i WinExec
176	172
177	173		> Note: Chociaż FPC/Lazarus obsługuje CreateProcess, ShellExecute i/lub WinExec, ta obsługa jest dostępna tylko w Win32/64. Jeśli Twój program jest wieloplatformowy, rozważ użycie RunCommand lub TProcess.
178	174
179	175		> Note: WinExec to 16-bitowe wywołanie, które od lat jest przestarzałe w interfejsie API systemu Windows. W ostatnich wersjach FPC generuje ostrzeżenie.
180	176
181	177		ShellExecute to standardowa funkcja systemu MS Windows (ShellApi.h) z dobrą \[<http://msdn.microsoft.com/en-us/library/windows/desktop/bb762153(v=vs.85>).aspx dokumentacją na MSDN\] (zwróć uwagę na ich komentarze na temat inicjalizacji COM, jeśli odkryjesz, że ta jest niewiarygodna).
182	178
183	179		``` pascal
184	180		uses ..., ShellApi;
185	181
186	182		// Proste jednowierszowe (ignorowanie zwracanych błędów):
187	183		if ShellExecute(0,nil, PChar('"C:\my dir\prog.exe"'),PChar('"C:\somepath\some_doc.ext"'),nil,1) =0 then;
188	184
189	185		// Wykonaj plik wsadowy:
190	186		if ShellExecute(0,nil, PChar('cmd'),PChar('/c mybatch.bat'),nil,1) =0 then;
191	187
192	188		// Otwórz okno poleceń w danym folderze:
193	189		if ShellExecute(0,nil, PChar('cmd'),PChar('/k cd \path'),nil,1) =0 then;
194	190
195	191		// Otwórz adres URL strony internetowej w domyślnej przeglądarce za pomocą polecenia „start” (poprzez ukryte okno cmd):
196	192		if ShellExecute(0,nil, PChar('cmd'),PChar('/c start www.lazarus.freepascal.org/'),nil,0) =0 then;
197	193
198	194		// lub przydatna procedura:
199	195		procedure RunShellExecute(const prog,params:string);
200	196		begin
201	197		// parametry: ( Uchwyt, nil/'open'/'edit'/'find'/'explore'/'print', // 'open' nie zawsze jest potrzebny
202	198		// path+prog, parametry, folder roboczy,
203	199		// okno command 0=ukryte / 1=SW_SHOWNORMAL / 3=maks / 7=min) // dla stałych SW_ : uses ... Windows ...
204	200		if ShellExecute(0,'open',PChar(prog),PChar(params),PChar(extractfilepath(prog)),1) >32 then; //sukces
205	201		// zwracane wartości 0..32 są błędami
206	202		end;
207	203		```
208	204
209	205		Istnieje również ShellExecuteExW jako wersja WideChar, a ShellExecuteExA to wersja AnsiChar.
210	206
211	207		Opcja fMask może również używać SEE_MASK_DOENVSUBST lub SEE_MASK_FLAG_NO_UI lub SEE_MASK_NOCLOSEPROCESS itp.
212	208
213	209		Jeśli w Delphi używałeś ShellExecute do dokumentów takich jak dokumenty Word lub adresy URL, spójrz na funkcje open* (OpenURL itp.) w module lclintf (zobacz sekcję [Zobacz także](https://wiki.lazarus.freepascal.org/Executing_External_Programs/pl#Zobacz_także) na dole tej strony).
214	210
215	211		### Używanie ShellExecuteEx do podnoszenia uprawnień administratora
216	212
217	213		Jeśli potrzebujesz uruchomić zewnętrzny program z podwyższonymi uprawnieniami administratora, możesz użyć metody runas z alternatywną funkcją ShellExecuteEx:
218	214
219	215		``` pascal
220	216		uses ShellApi, ...;
221	217
222	218		function RunAsAdmin(const Handle: Hwnd; const Path, Params: string): Boolean;
223	219		var
224	220		sei: TShellExecuteInfoA;
225	221		begin
226	222		FillChar(sei, SizeOf(sei), 0);
227	223		sei.cbSize := SizeOf(sei);
228	224		sei.Wnd := Handle;
229	225		sei.fMask := SEE_MASK_FLAG_DDEWAIT or SEE_MASK_FLAG_NO_UI;
230	226		sei.lpVerb := 'runas';
231	227		sei.lpFile := PAnsiChar(Path);
232	228		sei.lpParameters := PAnsiChar(Params);
233	229		sei.nShow := SW_SHOWNORMAL;
234	230		Result := ShellExecuteExA(@sei);
235	231		end;
236	232
237	233		procedure TFormMain.RunAddOrRemoveApplication;
238	234		begin
239	235		// Przykład, który używa podwyższonego uprawnienia dla rundll, aby otworzyć Panel sterowania do programów i funkcji
240	236		RunAsAdmin(FormMain.Handle, 'rundll32.exe shell32.dll,Control_RunDLL appwiz.cpl', '');
241	237		end;
242	238		```
243	239
244	240		## Unix fpsystem, fpexecve i shell
245	241
246	242		Te funkcje są zależne od platformy.
247	243
248	244		- Odniesienie do [fpsystem](http://www.freepascal.org/docs-html/rtl/unix/fpsystem.html)
249	245		- Odniesienie do [fpexecve](http://www.freepascal.org/docs-html/rtl/baseunix/fpexecve.html)
250	246
251	247		Linux.Shell/Unix.Shell był odpowiednikiem fpsystem w wersji 1.0.x ze słabo zdefiniowaną obsługą błędów i po dekadzie deprecjacji został ostatecznie usunięty. Prawie we wszystkich przypadkach może być zastąpiony przez fpsystem, który obsługuje więcej standardów POSIX, takich jak obsługa błędów.
252	248
253	249		## TProcess
254	250
255	251		Możesz użyć TProcess do uruchamiania zewnętrznych programów. Niektóre z korzyści płynących z używania TProcess to:
256	252
257	253		- Jest niezależny od platformy.
258	254		- Potrafi czytać ze standardowego wyjścia i zapisywać na standardowe wejście.
259	255		- Możliwe jest oczekiwanie na zakończenie polecenia lub pozwolenie na jego działanie podczas działania programu.
260	256
261	257		Ważne informacje:
262	258
263	259		- TProcess nie jest terminalem/powłoką! Nie możesz bezpośrednio wykonywać skryptów lub przekierowywać wyjścia za pomocą operatorów takich jak „\\|”, „\>”, „\<”, „&” itp. Możliwe jest uzyskanie tych samych wyników za pomocą TProcess i za pomocą pascala - kilka przykładów poniżej.
264	260		- Przypuszczalnie w systemie Linux/Unix: musisz podać pełną ścieżkę do pliku wykonywalnego. Na przykład „/bin/cp” zamiast „cp”. Jeśli program znajduje się w standardowej PATH, możesz użyć funkcji [[doc:lcl/fileutil/finddefaultexecutablepath.html\|FindDefaultExecutablePath]] z modułu [[doc:lcl/fileutil/index.html\|FileUtil]] biblioteki LCL.
265	261		- W systemie Windows, jeśli polecenie znajduje się w ścieżce, nie musisz określać pełnej ścieżki.
266	262		- Odnośnik do [[doc:fcl/process/tprocess.html\|TProcess]]
267	263
268	264		### Najprostszy przykład
269	265
270	266		Wiele typowych przypadków zostało przygotowanych w funkcjach [[Executing External Programs/pl\|RunCommand]]. Zanim zaczniesz kopiować i wklejać poniższe przykłady, najpierw je sprawdź.
271	267
272	268		### Prosty przykład
273	269
274	270		Ten przykład (który nie powinien być używany w środowisku produkcyjnym, patrz [[Executing External Programs/pl\|Czytanie dużych ilości danych wyjściowych]] lub, lepiej, [[Executing External Programs/pl\|RunCommand]]) pokazuje tylko, jak uruchomić zewnętrzny program, nic więcej:
275	271
276	272		``` pascal
277	273		// Jest to program demonstracyjny, który
278	274		// pokazuje, jak uruchomić zewnętrzny program.
279	275		program launchprogram;
280	276
281	277		// Tutaj dołączamy moduły zawierające przydatne
282	278		// funkcje i procedury, których będziemy potrzebować.
283	279		uses
284	280		Classes, SysUtils, Process;
285	281
286	282		// Definiuje zmienną "AProcess" jako zmienną typu "TProcess"
287	283		var
288	284		AProcess: TProcess;
289	285
290	286		// Tu zaczyna działać nasz program
291	287		begin
292	288		// Teraz utworzymy obiekt TProcess i przypiszemy go
293	289		// do zmiennej AProcess.
294	290		AProcess := TProcess.Create(nil);
295	291
296	292		// Powiedz nowemu AProcess, jakie jest polecenie do wykonania.
297	293		// Użyjmy kompilatora Free Pascal (dokładniej wersji x64)
298	294		// Lecz jeśli używasz kompilatora 32-bit zmień ppcx64 na ppc386
299	295		AProcess.Executable:= 'ppcx64';
300	296
301	297		// Przekaż opcję -h razem z ppcx64, więc faktycznie wykonywane
302	298		// jest polecenie 'ppcx64 -h':
303	299		AProcess.Parameters.Add('-h');
304	300
305	301		// Zdefiniujemy opcję działającą, w czasie wykonywania programu.
306	302		// Ta opcja sprawi, że nasz program nie będzie kontynuowany,
307	303		// dopóki program zewnętrzy, który uruchomimy, nie przestanie działać.
308	304		// /------------\
309	305		AProcess.Options := AProcess.Options + [poWaitOnExit];
310	306
311	307		// Teraz pozwól AProcess uruchomić program zewnętrzny
312	308		AProcess.Execute;
313	309
314	310		// Poniższy kod nie wykona się, dopóki ppcx64 nie przestanie działać.
315	311		AProcess.Free;
316	312		end.
317	313		```
318	314
319	315		Otóż to! Właśnie nauczyłeś się uruchamiać zewnętrzny program z wnętrza własnego programu.
320	316
321	317		### Ulepszony przykład (ale jeszcze niepoprawny)
322	318
323	319		Wszystko fajnie, ale jak odczytać dane wyjściowe uruchomionego programu?
324	320
325	321		Cóż, rozszerzmy nieco nasz przykład, jak poniżej: Ten przykład jest prosty, więc możesz się z niego uczyć. Jednak nie używaj tego przykładu w kodzie produkcyjnym, ale użyj kodu z [[Executing External Programs/pl\|Czytanie dużych ilości danych wyjściowych]].
326	322
327	323		``` pascal
328	324		// To jest
329	325		// WADLIWY
330	326		// program demonstracyjny, który pokazuje,
331	327		// jak uruchomić zewnętrzny program
332	328		// i odczytać z jego dane wyjściowe.
333	329		program launchprogram;
334	330
335	331		// Tutaj dołączamy moduły zawierające przydatne
336	332		// funkcje i procedury, których będziemy potrzebować.
337	333		uses
338	334		Classes, SysUtils, Process;
339	335
340	336		// Definiuje zmienną "AProcess" jako zmienną typu "TProcess"
341	337		// Teraz także dodajemy TStringList do przechowywania danych
342	338		// odczytanych z wyjścia programu.
343	339		var
344	340		AProcess: TProcess;
345	341		AStringList: TStringList;
346	342
347	343		// Tu zaczyna działać nasz program
348	344		begin
349	345		// Teraz utworzymy obiekt TProcess i przypiszemy go
350	346		// do zmiennej AProcess.
351	347		AProcess := TProcess.Create(nil);
352	348
353	349		// Powiedz nowemu AProcess, jakie jest polecenie do wykonania.
354	350		AProcess.Executable := '/usr/bin/ppcx64';
355	351		AProcess.Parameters.Add('-h');
356	352
357	353		// Zdefiniujemy opcję działającą, w czasie wykonywania programu.
358	354		// Ta opcja sprawi, że nasz program nie będzie kontynuowany,
359	355		// dopóki program zewnętrzy, który uruchomimy, nie przestanie działać.
360	356		// Dodatkowo teraz powiemy mu, że chcemy odczytać dane wyjściowe.
361	357		// /------------\|-----------\
362	358		AProcess.Options := AProcess.Options + [poWaitOnExit, poUsePipes];
363	359
364	360		// Teraz, gdy AProcess wie, jaki jest wiersz poleceń, można go uruchomić.
365	361		AProcess.Execute;
366	362
367	363		// Po zakończeniu AProcess zostanie wykonana reszta programu.
368	364
369	365		// Teraz odczytaj wynik działania programu, za pomocą TStringList.
370	366		AStringList := TStringList.Create;
371	367		AStringList.LoadFromStream(AProcess.Output);
372	368
373	369		// Zapisz dane wyjściowe do pliku i zwolnij obiekt AStringList.
374	370		AStringList.SaveToFile('output.txt');
375	371		AStringList.Free;
376	372
377	373		// Teraz, gdy dane wyjściowe z procesu są przetworzone, także można je zwolnić.
378	374		AProcess.Free;
379	375		end.
380	376		```
381	377
382	378		### Czytanie dużych ilości danych wyjściowych
383	379
384	380		W poprzednim przykładzie czekaliśmy, aż program się zakończy. Następnie czytaliśmy, co program zapisał na swoim wyjściu.
385	381
386	382		Załóżmy, że program zapisuje dużo danych na wyjściu. Następnie potok wyjściowy zapełnia się i wywoływany program czeka, aż potok zostanie odczytany.
387	383
388	384		Ale program wywołujący nie czyta z niego, dopóki wywoływany program się nie zakończy. Następuje impas.
389	385
390	386		Poniższy przykład nie używa zatem poWaitOnExit, ale odczytuje dane wyjściowe, gdy program jest nadal uruchomiony. Dane wyjściowe są przechowywane w strumieniu pamięci, który można później wykorzystać do odczytania danych wyjściowych do TStringList.
391	387
392	388		Jeśli chcesz odczytać dane wyjściowe z procesu zewnętrznego i nie możesz użyć RunCommand, jest to kod, który powinien być podstawą do użytku produkcyjnego. Jeśli używasz FPC 3.2.0+, parametryzowalna forma tej pętli jest dostępna jako metoda RunCommandLoop w TProcess. Zdarzenie OnRunCommandEvent można podłączyć, aby dalej modyfikować zachowanie.
393	389
394	390		``` pascal
395	391		program LargeOutputDemo;
396	392
397	393		{$mode objfpc}{$H+}
398	394
399	395		uses
400	396		Classes, SysUtils, Process; // Process to moduł, który zawiera TProcess
401	397
402	398		const
403	399		BUF_SIZE = 2048; // Rozmiar bufora do odczytu danych wyjściowych w porcjach
404	400
405	401		var
406	402		AProcess : TProcess;
407	403		OutputStream : TStream;
408	404		BytesRead : longint;
409	405		Buffer : array[1..BUF_SIZE] of byte;
410	406
411	407		begin
412	408		// Skonfiguruj proces; jako przykład używane jest rekurencyjne przeszukiwanie
413	409		// katalogów, ponieważ zwykle skutkuje to dużą ilością danych.
414	410		AProcess := TProcess.Create(nil);
415	411
416	412		// Polecenia dla Windows i *nix są różne, stąd dyrektywy $IFDEF
417	413		{$IFDEF Windows}
418	414		// W systemie Windows polecenie dir nie może być użyte bezpośrednio, ponieważ jest to
419	415		// wbudowane polecenie powłoki. Dlatego potrzebny jest cmd.exe i dodatkowe parametry.
420	416		AProcess.Executable := 'c:\windows\system32\cmd.exe';
421	417		AProcess.Parameters.Add('/c');
422	418		AProcess.Parameters.Add('dir /s c:\windows');
423	419		{$ENDIF Windows}
424	420
425	421		{$IFDEF Unix}
426	422		AProcess.Executable := '/bin/ls';
427	423
428	424		{$IFDEF Darwin}
429	425		AProcess.Parameters.Add('-recursive');
430	426		AProcess.Parameters.Add('-all');
431	427		{$ENDIF Darwin}
432	428
433	429		{$IFDEF Linux}
434	430		AProcess.Parameters.Add('--recursive');
435	431		AProcess.Parameters.Add('--all');
436	432		{$ENDIF Linux}
437	433
438	434		{$IFDEF FreeBSD}
439	435		AProcess.Parameters.Add('-R');
440	436		AProcess.Parameters.Add('-a');
441	437		{$ENDIF FreeBSD}
442	438
443	439		AProcess.Parameters.Add('-l');
444	440		{$ENDIF Unix}
445	441
446	442		// Aby można było przechwycić dane wyjściowe, należy użyć opcji procesu poUsePipes.
447	443		// Nie można użyć opcji procesu poWaitOnExit, ponieważ zablokuje to program główny,
448	444		// uniemożliwiając mu odczytanie danych wyjściowych procesu zewnętrznego.
449	445		AProcess.Options := [poUsePipes];
450	446
451	447		// Uruchom proces (uruchom polecenie dir dla Windows lub ls dla Linux/Unix)
452	448		AProcess.Execute;
453	449
454	450		// Utwórz obiekt strumienia, w którym będą przechowywane wygenerowane dane wyjściowe.
455	451		// Może to być również strumień plikowy do bezpośredniego zapisywania danych wyjściowych na dysku.
456	452		OutputStream := TMemoryStream.Create;
457	453
458	454		// Wszystkie wygenerowane dane wyjściowe z AProcess są odczytywane w pętli,
459	455		// dopóki nie będzie dostępnych więcej danych
460	456		repeat
461	457		// Pobierz nowe dane z procesu do maksymalnego rozmiaru buforu, który został przydzielony.
462	458		// Zauważ, że wszystkie wywołania Read(...) będą blokowane z wyjątkiem ostatniego, które zwraca 0 (zero).
463	459		BytesRead := AProcess.Output.Read(Buffer, BUF_SIZE);
464	460
465	461		// Bajty, które zostały odczytane, dodaj do strumienia w celu późniejszego wykorzystania
466	462		OutputStream.Write(Buffer, BytesRead)
467	463
468	464		until BytesRead = 0; // Zakończ pętlę, jeśli nie ma więcej danych
469	465
470	466		// Proces się zakończył, więc można go posprzątać
471	467		AProcess.Free;
472	468
473	469		// Teraz, gdy wszystkie dane zostały odczytane, można z nich korzystać;
474	470		// na przykład po to, by zapisać je do pliku na dysku
475	471		with TFileStream.Create('output.txt', fmCreate) do
476	472		begin
477	473		OutputStream.Position := 0; // Wymagane, aby upewnić się, że wszystkie dane będą kopiowane od początku
478	474		CopyFrom(OutputStream, OutputStream.Size);
479	475		Free
480	476		end;
481	477
482	478		// Lub dane mogą być wyświetlane na ekranie
483	479		with TStringList.Create do
484	480		begin
485	481		OutputStream.Position := 0; // Wymagane, aby upewnić się, że wszystkie dane będą kopiowane od początku
486	482		LoadFromStream(OutputStream);
487	483		writeln(Text);
488	484		writeln('--- Liczba linii = ', Count, '----');
489	485		Free
490	486		end;
491	487
492	488		// Sprzątanie
493	489		OutputStream.Free;
494	490		end.
495	491		```
496	492
497	493		Zauważ, że powyższe można również osiągnąć za pomocą RunCommand:
498	494
499	495		``` pascal
500	496		var s: string;
501	497		...
502	498		RunCommand('c:\windows\system32\cmd.exe', ['/c', 'dir /s c:\windows'], s);
503	499		```
504	500
505	501		### Korzystanie z wejścia i wyjścia TProcess
506	502
507	503		Zobacz przykładowe demo procesu w [Lazarus-CCR SVN](https://sourceforge.net/p/lazarus-ccr/svn/HEAD/tree/examples/process).
508	504
509	505		### Wskazówki dotyczące korzystania z TProcess
510	506
511	507		Podczas tworzenia programu wieloplatformowego nazwę pliku wykonywalnego specyficzną dla systemu operacyjnego można ustawić za pomocą dyrektyw „{\$IFDEF}” i „{\$ENDIF}”. Przykład:
512	508
513	509		``` pascal
514	510		{...}
515	511		AProcess := TProcess.Create(nil)
516	512
517	513		{$IFDEF WIN32}
518	514		AProcess.Executable := 'calc.exe';
519	515		{$ENDIF}
520	516
521	517		{$IFDEF LINUX}
522	518		AProcess.Executable := FindDefaultExecutablePath('kcalc');
523	519		{$ENDIF}
524	520
525	521		AProcess.Execute;
526	522		{...}
527	523		```
528	524
529	525		### macOS pokazuje pakiet aplikacji na pierwszym planie
530	526
531	527		Możesz uruchomić pakiet aplikacji przez TProcess, uruchamiając plik wykonywalny w pakiecie. Na przykład:
532	528
533	529		``` pascal
534	530		AProcess.Executable:='/Applications/iCal.app/Contents/MacOS/iCal';
535	531		```
536	532
537	533		Spowoduje to uruchomienie Kalendarza, ale okno będzie znajdować się za bieżącą aplikacją. Aby uzyskać aplikację na pierwszym planie, możesz użyć narzędzia open z parametrem -n:
538	534
539	535		``` pascal
540	536		AProcess.Executable:='/usr/bin/open';
541	537		AProcess.Parameters.Add('-n');
542	538		AProcess.Parameters.Add('-a'); // opcjonalny: określa aplikację do użycia; przeszukuje tylko katalogi aplikacji
543	539		AProcess.Parameters.Add('-W'); // opcjonalnie: open czeka, aż aplikacje, które otwiera (lub były już otwarte) zostaną zamknięte
544	540		AProcess.Parameters.Add('Pages.app'); // dołączenie .app jest opcjonalne
545	541		```
546	542
547	543		Jeśli Twoja aplikacja potrzebuje parametrów, możesz przekazać wraz z open parametr --args, po którym wszystkie dalsze parametry są przekazywane do aplikacji:
548	544
549	545		``` pascal
550	546		AProcess.Parameters.Add('--args');
551	547		AProcess.Parameters.Add('argument1');
552	548		AProcess.Parameters.Add('argument2');
553	549		```
554	550
555	551		Zobacz także: [[macOS Open Sesame\|macOS polecenie open]].
556	552
557	553		### Uruchom oddzielny program
558	554
559	555		Normalnie program uruchomiony przez twoją aplikację jest procesem potomnym i zostaje zabity, gdy twoja aplikacja zostanie zabita. Jeśli chcesz uruchomić samodzielny program, który nadal będzie działał, możesz użyć:
560	556
561	557		``` pascal
562	558		var
563	559		Process: TProcess;
564	560		I: Integer;
565	561		begin
566	562		Process := TProcess.Create(nil);
567	563		try
568	564		Process.InheritHandles := False;
569	565		Process.Options := [];
570	566		Process.ShowWindow := swoShow;
571	567
572	568		// Skopiuj domyślne zmienne środowiskowe, w tym zmienną DISPLAY, aby aplikacja GUI działała
573	569		for I := 1 to GetEnvironmentVariableCount do
574	570		Process.Environment.Add(GetEnvironmentString(I));
575	571
576	572		Process.Executable := '/usr/bin/gedit';
577	573		Process.Execute;
578	574		finally
579	575		Process.Free;
580	576		end;
581	577		end;
582	578		```
583	579
584	580		### Przykład „rozmowy” z procesem aspell
585	581
586	582		Wewnątrz kodu źródłowego [pasdoc](https://github.com/pasdoc/pasdoc/wiki) można znaleźć dwa moduły, które sprawdzają pisownię poprzez „rozmawianie” przez potoki z uruchomionym procesem aspell:
587	583
588	584		- [Moduł PasDoc_ProcessLineTalk.pas](https://github.com/pasdoc/pasdoc/blob/master/source/component/PasDoc_ProcessLineTalk.pas) implementuje klasę TProcessLineTalk, potomka TProcess, która może być z łatwością używana do komunikacji z dowolnym procesem linia po linii.
589	585
590	586		- [Moduł PasDoc_Aspell.pas](https://github.com/pasdoc/pasdoc/blob/master/source/component/PasDoc_Aspell.pas) implementuje klasę TAspellProcess, która sprawdza pisownię za pomocą bazowej instancji TProcessLineTalk do wykonania aspell i komunikacji z uruchomionym procesem aspell.
591	587
592	588		Obydwa moduły są raczej niezależne od pozostałych źródeł pasdoc, więc mogą służyć jako rzeczywiste przykłady użycia TProcess do uruchamiania i komunikacji przez potoki z innym programem.
593	589
594	590		### Zastępowanie operatorów powłoki, takich jak „\\| \< \>”
595	591
596	592		Czasami chcesz uruchomić bardziej skomplikowane polecenie, które przesyła dane do innego polecenia lub do pliku. Coś podobnego do
597	593
598	594		``` pascal
599	595		ShellExecute('firstcommand.exe \| secondcommand.exe');
600	596		```
601	597
602	598		lub
603	599
604	600		``` pascal
605	601		ShellExecute('dir > output.txt');
606	602		```
607	603
608	604		Wykonanie tego za pomocą TProcess nie zadziała. tj:
609	605
610	606		``` pascal
611	607		// to nie zadziała!
612	608		Process.CommandLine := 'firstcommand.exe \| secondcommand.exe';
613	609		Process.Execute;
614	610		```
615	611
616	612		#### Dlaczego używanie specjalnych operatorów do przekierowywania wyjścia nie działa?
617	613
618	614		TProcess nie jest środowiskiem powłoki, tylko procesem. To nie dwa procesy, to tylko jeden. Możliwe jest jednak przekierowanie danych wyjściowych dokładnie tak, jak chcesz. Zobacz [[Executing External Programs/pl\|następną sekcję]].
619	615
620	616		### Jak przekierować wyjście za pomocą TProcess
621	617
622	618		Możesz przekierować dane wyjściowe polecenia do innego polecenia, używając osobnej instancji TProcess dla każdego polecenia.
623	619
624	620		Oto przykład, który wyjaśnia, jak przekierować dane wyjściowe jednego procesu do drugiego. Aby przekierować wyjście procesu do pliku/strumienia, zobacz przykład [[Executing External Programs/pl\|Czytanie dużych ilości danych wyjściowych]].
625	621
626	622		Możesz nie tylko przekierować „normalne” wyjście (znane również jako stdout), ale możesz także przekierować wyjście błędu (stderr), jeśli określisz opcję poStderrToOutPut, jak to widać w opcjach drugiego procesu.
627	623
628	624		``` pascal
629	625		program Project1;
630	626
631	627		uses
632	628		Classes, sysutils, process;
633	629
634	630		var
635	631		FirstProcess,
636	632		SecondProcess: TProcess;
637	633		Buffer: array[0..127] of char;
638	634		ReadCount: Integer;
639	635		ReadSize: Integer;
640	636		begin
641	637		FirstProcess := TProcess.Create(nil);
642	638		SecondProcess := TProcess.Create(nil);
643	639
644	640		FirstProcess.Options := [poUsePipes];
645	641		FirstProcess.Executable := 'pwd';
646	642
647	643		SecondProcess.Options := [poUsePipes,poStderrToOutPut];
648	644		SecondProcess.Executable := 'grep';
649	645		SecondProcess.Parameters.Add(DirectorySeparator+ ' -');
650	646		// byłoby to to samo co "pwd \| grep / -"
651	647
652	648		FirstProcess.Execute;
653	649		SecondProcess.Execute;
654	650
655	651		while FirstProcess.Running or (FirstProcess.Output.NumBytesAvailable > 0) do
656	652		begin
657	653		if FirstProcess.Output.NumBytesAvailable > 0 then
658	654		begin
659	655		// upewnij się, że nie czytamy więcej danych niż przydzieliliśmy w buforze
660	656		ReadSize := FirstProcess.Output.NumBytesAvailable;
661	657		if ReadSize > SizeOf(Buffer) then
662	658		ReadSize := SizeOf(Buffer);
663	659		// teraz wczytaj dane wyjściowe do bufora
664	660		ReadCount := FirstProcess.Output.Read(Buffer[0], ReadSize);
665	661		// i zapisz bufor do drugiego procesu
666	662		SecondProcess.Input.Write(Buffer[0], ReadCount);
667	663
668	664		// jeśli SecondProcess zapisuje dużo danych do swojego wyjścia,
669	665		// powinniśmy odczytać te dane tutaj, aby zapobiec zakleszczeniu,
670	666		// patrz poprzedni przykład "Czytanie dużych ilości danych wyjściowych"
671	667		end;
672	668		end;
673	669		// Zamknij dane wejściowe w SecondProcess,
674	670		// aby zakończyć przetwarzanie swoich danych
675	671		SecondProcess.CloseInput;
676	672
677	673		// i poczekaj, aż się zakończy, lecz uważaj, jakie polecenie uruchamiasz,
678	674		// ponieważ może się ono nie zakończyć, gdy jego dane wejściowe są zamknięte,
679	675		// to następująca linia może zapętlić się w nieskończoność
680	676		while SecondProcess.Running do
681	677		Sleep(1);
682	678		// Gotowe! Reszta programu jest tylko po to, aby przykład był bardziej 'użyteczny'
683	679
684	680		// użyjemy ponownie Buffer, aby wyprowadzić wyjście SecondProcess do tego programu stdout
685	681		WriteLn('Rozpoczęcie wyjścia grep:');
686	682		ReadSize := SecondProcess.Output.NumBytesAvailable;
687	683		if ReadSize > SizeOf(Buffer) then
688	684		ReadSize := SizeOf(Buffer);
689	685		if ReadSize > 0 then
690	686		begin
691	687		ReadCount := SecondProcess.Output.Read(Buffer, ReadSize);
692	688		WriteLn(Copy(Buffer,0, ReadCount));
693	689		end
694	690		else
695	691		WriteLn('grep nie znalazł tego, czego szukaliśmy. ', SecondProcess.ExitStatus);
696	692		WriteLn('Zakończenie wyjścia grep:');
697	693
698	694		// zwolnij obiekty naszych procesów
699	695		FirstProcess.Free;
700	696		SecondProcess.Free;
701	697		end.
702	698		```
703	699
704	700		W ten sposób możesz przekierować dane wyjściowe z jednego programu do drugiego.
705	701
706	702		#### Uwagi
707	703
708	704		Ten przykład może wydawać się przesadny, ponieważ możliwe jest uruchamianie „skomplikowanych” poleceń przy użyciu powłoki przy pomocy TProcess, takich jak:
709	705
710	706		``` pascal
711	707		Process.Commandline := 'sh -c "pwd \| grep / -"';
712	708		```
713	709
714	710		Ale nasz przykład jest bardziej wieloplatformowy, ponieważ nie wymaga modyfikacji, aby działać w systemie Windows lub Linux itp. Polecenie „sh” może, ale nie musi istnieć na twojej platformie i jest ogólnie dostępny tylko na platformach *nix. W naszym przykładzie mamy również większą elastyczność, ponieważ możesz czytać i zapisywać z/do wejścia, wyjścia i stderr każdego procesu z osobna, co może być bardzo korzystne dla twojego projektu.
715	711
716	712		### Przekierowywanie wejścia i wyjścia oraz działanie z rootem
717	713
718	714		Częstym problemem w systemach Unix (FreeBSD, macOS) i Linux jest to, że chcesz uruchomić jakiś program na koncie root (lub, bardziej ogólnie, na innym koncie użytkownika). Przykładem może być uruchomienie polecenia ping.
719	715
720	716		Jeśli możesz użyć do tego sudo, możesz dostosować następujący przykład zaadaptowany z postu opublikowanego przez andymana na forum ([1](http://lazarus.freepascal.org/index.php/topic,14479.0.html)). Ten przykład uruchamia polecenie `ls` w katalogu `/root`, ale oczywiście można go dostosować.
721	717
722	718		Lepszym sposobem na to jest użycie pakietu policykit, który powinien być dostępny we wszystkich najnowszych Linuksach. [Zobacz wątek na forum, aby uzyskać szczegółowe informacje.](http://lazarus.freepascal.org/index.php/topic,14479.0.html)
723	719
724	720		Duże części tego kodu są podobne do wcześniejszego przykładu, ale pokazuje również, jak przekierować stdout i stderr procesu wywoływanego oddzielnie na stdout i stderr naszego własnego kodu.
725	721
726	722		``` pascal
727	723		program rootls;
728	724
729	725		{ Demonstracja użycia TProcess, przekierowania stdout/stderr do naszego stdout/stderr,
730	726		wywoływania sudo w systemach FreeBSD/Linux/macOS i dostarczania danych wejściowych na stdin}
731	727		{$mode objfpc}{$H+}
732	728
733	729		uses
734	730		Classes,
735	731		Math, {for min}
736	732		Process;
737	733
738	734		procedure RunsLsRoot;
739	735		var
740	736		Proc: TProcess;
741	737		CharBuffer: array [0..511] of char;
742	738		ReadCount: integer;
743	739		ExitCode: integer;
744	740		SudoPassword: string;
745	741		begin
746	742		WriteLn('Please enter the sudo password:');
747	743		Readln(SudoPassword);
748	744		ExitCode := -1; //Zacznij od porażki, zobaczmy później, czy to zadziała
749	745		Proc := TProcess.Create(nil); //Utwórz nowy proces
750	746		try
751	747		Proc.Options := [poUsePipes, poStderrToOutPut]; //Użyj potoków, aby przekierować stdin,stdout,stderr
752	748		Proc.CommandLine := 'sudo -S ls /root'; //Uruchom ls /root jako root za pomocą sudo
753	749		// -S powoduje, że sudo odczytuje hasło z stdin.
754	750		Proc.Execute; //Uruchom to. sudo prawdopodobnie poprosi teraz o hasło
755	751
756	752		// wpisz hasło do stdin programu sudo:
757	753		SudoPassword := SudoPassword + LineEnding;
758	754		Proc.Input.Write(SudoPassword[1], Length(SudoPassword));
759	755		SudoPassword := '%*'; // krótki string, mam nadzieję, że trochę pomiesza pamięć; uwaga: używanie PChars jest bardziej niezawodne
760	756		SudoPassword := ''; // i sprawić, by program był nieco bezpieczniejszy przed węszeniem?!?
761	757
762	758		// główna pętla do odczytu wyjścia z stdout i stderr dla sudo
763	759		while Proc.Running or (Proc.Output.NumBytesAvailable > 0) or
764	760		(Proc.Stderr.NumBytesAvailable > 0) do
765	761		begin
766	762		// odczytaj stdout i zapisz do naszego stdout
767	763		while Proc.Output.NumBytesAvailable > 0 do
768	764		begin
769	765		ReadCount := Min(512, Proc.Output.NumBytesAvailable); //Czytaj do bufora, nie więcej
770	766		Proc.Output.Read(CharBuffer, ReadCount);
771	767		Write(StdOut, Copy(CharBuffer, 0, ReadCount));
772	768		end;
773	769		// odczytaj stderr i zapisz do naszego stderr
774	770		while Proc.Stderr.NumBytesAvailable > 0 do
775	771		begin
776	772		ReadCount := Min(512, Proc.Stderr.NumBytesAvailable); //Czytaj do bufora, nie więcej
777	773		Proc.Stderr.Read(CharBuffer, ReadCount);
778	774		Write(StdErr, Copy(CharBuffer, 0, ReadCount));
779	775		end;
780	776		end;
781	777		ExitCode := Proc.ExitStatus;
782	778		finally
783	779		Proc.Free;
784	780		Halt(ExitCode);
785	781		end;
786	782		end;
787	783
788	784		begin
789	785		RunsLsRoot;
790	786		end.
791	787		```
792	788
793	789		Inne przemyślenia: Bez wątpienia wskazane byłoby sprawdzenie, czy sudo rzeczywiście pyta o hasło. Można to konsekwentnie sprawdzać, ustawiając zmienną środowiskową SUDO_PROMPT na coś, na co zwracamy uwagę podczas czytania stdout TProcess, unikając problemu związanego z różnymi znakami zachęty dla różnych lokalizacji. Ustawienie zmiennej środowiskowej powoduje wyczyszczenie wartości domyślnych (odziedziczonych z naszego procesu), więc w razie potrzeby musimy skopiować środowisko z naszego programu.
794	790
795	791		### Używanie fdisk z sudo w systemie Linux
796	792
797	793		Poniższy przykład pokazuje, jak uruchomić fdisk na komputerze z systemem Linux za pomocą polecenia sudo, aby uzyskać uprawnienia roota. Uwaga: jest to tylko przykład i nie obejmuje dużej ilości danych na wyjściu.
798	794
799	795		``` pascal
800	796		program getpartitioninfo;
801	797		{Pierwotnie napisany przez użytkownika forum Lazarus wjackon153. Prosimy o kontakt w przypadku pytań, uwag itp.
802	798		Zmodyfikowan z fragmentu kodu Lazarusa na program FPC dla ułatwienia zrozumienia/zwięzłości przez BigChimp}
803	799
804	800		Uses
805	801		Classes, SysUtils, FileUtil, Process;
806	802
807	803		var
808	804		hprocess: TProcess;
809	805		sPass: String;
810	806		OutputLines: TStringList;
811	807
812	808		begin
813	809		sPass := 'yoursudopasswordhere'; // Musisz to zmienić na własne hasło sudo
814	810		OutputLines:=TStringList.Create; //dla pewności warto zamknąć to w bloku try...finally...end
815	811		// OutputLines został utworzony ... To samo dla hProcess.
816	812
817	813		// Poniższy przykład otworzy fdisk w tle i da nam informacje o partycjach
818	814		// Ponieważ fdisk wymaga podwyższonych uprawnień, musimy przekazać
819	815		// nasze hasło jako parametr do sudo za pomocą opcji -S, więc proces
820	816		// poczeka, aż nasz program wyśle nasze hasło do aplikacji sudo
821	817
822	818		hProcess := TProcess.Create(nil);
823	819		// W systemach Linux/Unix/FreeBSD/macOS musimy podać pełną ścieżkę do naszego pliku wykonywalnego:
824	820		hProcess.Executable := '/bin/sh';
825	821		// Teraz dodajemy wszystkie parametry w wierszu poleceń:
826	822		hprocess.Parameters.Add('-c');
827	823		// Tutaj przesyłamy potokiem hasło do polecenia sudo, które następnie wykonuje fdisk -l:
828	824		hprocess.Parameters.add('echo ' + sPass + ' \| sudo -S fdisk -l');
829	825		// Uruchom asynchronicznie (poczekaj na zakończenie procesu) i użyj potoków, abyśmy mogli odczytać potok wyjściowy
830	826		hProcess.Options := hProcess.Options + [poWaitOnExit, poUsePipes];
831	827		// Teraz wykonaj:
832	828		hProcess.Execute;
833	829
834	830		// hProcess powinien teraz uruchomić zewnętrzny plik wykonywalny (ponieważ używamy poWaitOnExit).
835	831		// Teraz możesz przetworzyć wyjście procesu (standardowe wyjście i standardowy błąd), np.:
836	832		OutputLines.Add('stdout:');
837	833		OutputLines.LoadFromStream(hprocess.Output);
838	834		OutputLines.Add('stderr:');
839	835		OutputLines.LoadFromStream(hProcess.Stderr);
840	836		// Pokaż dane wyjściowe na ekranie:
841	837		writeln(OutputLines.Text);
842	838
843	839		// Wyczyść, aby uniknąć wycieków pamięci:
844	840		hProcess.Free;
845	841		OutputLines.Free;
846	842
847	843		//Poniżej znajduje się kilka przykładów, jak widać, możemy przekazywać niedozwolone znaki, tak jak robimy to z terminala
848	844		//Nawet jeśli przeczytałeś gdzie indziej, że nie możesz upewnić się tą metodą, to możesz :)
849	845
850	846		//hprocess.Parameters.Add('ping -c 1 www.google.com');
851	847		//hprocess.Parameters.Add('ifconfig wlan0 \| grep ' + QuotedStr('inet addr:') + ' \| cut -d: -f2');
852	848
853	849		//Użycie QuotedStr() nie jest wymagane, chociaż zapewnia czystszy kod;
854	850		//możesz użyć podwójnego cudzysłowu i mieć ten sam efekt.
855	851
856	852		//hprocess.Parameters.Add('glxinfo \| grep direct');
857	853
858	854		// Ta metoda może być również używana do instalowania aplikacji z repozytorium:
859	855
860	856		//hprocess.Parameters.add('echo ' + sPass + ' \| sudo -S apt-get install -y pkg-name');
861	857
862	858		end.
863	859		```
864	860
865	861		### Parametry zawierające spacje (Zastępowanie cudzysłowów powłoki)
866	862
867	863		W powłoce Linuksa możliwe jest pisanie cytowanych argumentów w następujący sposób:
868	864
869	865		`gdb --batch --eval-command="info symbol 0x0000DDDD" myprogram`
870	866
871	867		Polecenie GDB otrzyma 3 argumenty (oprócz pierwszego argumentu, który jest pełną ścieżką do pliku wykonywalnego):
872	868
873	869		1. --batch
874	870		2. --eval-command=info symbol 0x0000DDDD
875	871		3. pełna ścieżka do myprogram
876	872
877	873		Najlepszym rozwiązaniem, aby uniknąć skomplikowanego cytowania, jest przejście na TProcess.Parameters.Add zamiast ustawiania wiersza poleceń dla nietrywialnych przypadków, np.
878	874
879	875		` AProcess.Executable:='/usr/bin/gdb';`\
880	876		` AProcess.Parameters.Add('--batch');`\
881	877		` AProcess.Parameters.Add('--eval-command=info symbol 0x0000DDDD'); // zwróć tutaj uwagę na brak cytowania`\
882	878		` AProcess.Parameters.Add('/home/me/myprogram');`
883	879
884	880		Pamiętaj też, aby używać tylko pełne ścieżki.
885	881
886	882		TProcess.Commandline obsługuje jednak tylko podstawowe cytowanie parametrów z cudzysłowami. Ujmij w apostrofy cały parametr zawierający spacje z podwójnymi cudzysłowami. Jak poniżej:
887	883
888	884		`AProcess.CommandLine := '/usr/bin/gdb --batch "--eval-command=info symbol 0x0000DDDD" /home/me/myprogram';`
889	885
890	886		Właściwość .CommandLine jest [przestarzała](http://bugs.freepascal.org/view.php?id=14446), a raporty o błędach do obsługi bardziej skomplikowanych przypadków cytowania nie będą akceptowane.
891	887
892	888		## Alternatywy LCLIntf
893	889
894	890		Czasami nie trzeba jawnie wywoływać zewnętrznego programu, aby uzyskać potrzebną funkcjonalność. Zamiast otwierać aplikację i określać dokument, który ma być z nią powiązany, po prostu poproś system operacyjny o otwarcie dokumentu i pozwól mu użyć domyślnej aplikacji powiązanej z tym typem pliku. Poniżej kilka przykładów.
895	891
896	892		### Otwieranie dokumentu w domyślnej aplikacji
897	893
898	894		W niektórych sytuacjach musisz otworzyć jakiś dokument/plik przy użyciu domyślnej aplikacji z nim powiązanej, zamiast uruchamiać konkretny program. To zależy od działającego systemu operacyjnego. Lazarus zapewnia niezależną od platformy procedurę OpenDocument, która zajmie się tym za Ciebie. Twoja aplikacja będzie nadal działać, nie czekając na zamknięcie procesu tworzenia dokumentu.
899	895
900	896		``` pascal
901	897		uses LCLIntf;
902	898		...
903	899		OpenDocument('manual.pdf');
904	900		...
905	901		```
906	902
907	903		- [[opendocument\|Dokumentacja OpenDocument]]
908	904
909	905		### Otwieranie strony web w domyślnej przeglądarce internetowej
910	906
911	907		Aby to zrobić, po prostu przekaż wymagany adres URL. Przedrostek protokołu <http://> wydaje się w pewnych okolicznościach opcjonalny. Ponadto przekazanie nazwy pliku wydaje się dawać takie same wyniki jak OpenDocument()
912	908
913	909		``` pascal
914	910		uses LCLIntf;
915	911		...
916	912		OpenURL('www.lazarus.freepascal.org/');
917	913		```
918	914
919	915		Zobacz także:
920	916
921	917		- [[OpenURL\|Odnośnik do OpenURL]]
922	918
923	919		Lub możesz użyć TProcess w taki sposób:
924	920
925	921		``` pascal
926	922		uses Process;
927	923
928	924		procedure OpenWebPage(URL: string);
929	925		// Możliwe, że musisz podać swój adres URL w cudzysłowiu np. "www.lazarus.freepascal.org"
930	926		var
931	927		Browser, Params: string;
932	928		begin
933	929		FindDefaultBrowser(Browser, Params);
934	930		with TProcess.Create(nil) do
935	931		try
936	932		Executable := Browser;
937	933		Params:=Format(Params, [URL]);
938	934		Params:=copy(Params,2,length(Params)-2); // usuń znaki "", nowa wersja TProcess.Parameters robi to sama
939	935		Parameters.Add(Params);
940	936		Options := [poNoConsole];
941	937		Execute;
942	938		finally
943	939		Free;
944	940		end;
945	941		end;
946	942		```
947	943
948	944		## Zobacz także
949	945
950	946		- [dokumentacja TProcess](http://lazarus-ccr.sourceforge.net/docs/fcl/process/tprocess.html)
951	947		- [[opendocument\|OpenDocument]]
952	948		- [[OpenURL]]
953	949		- [[TProcessUTF8]]
954	950		- [[TXMLPropStorage]]
955	951		- [[Webbrowser]]
956	952
957	953		---
958	954		From the Free Pascal wiki, page "Executing External Programs/pl", as it stood on 2023-11-03 after a change by Slawek, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history