Executing External Programs/es: what changed

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

Old	New		Line
1	1		## Introducción
2	2
3	3		Hay varias formas de ejecutar programas externos, pero nos centraremos en una, TProcess.
4	4
5	5		Si en Delphi utilizabas siempre ShellExecute y/o WinExec, puedes empezar a usar TProcess como alternativa en FPC/Lazarus (es válido también si estás ejecutando Lazarus en Linux, porque TProcess es multiplataforma).
6	6
7	7		Nota: FPC/Lazarus puede utilizar ShellExecute y/o WinExec, pero sólo en Win32. Si tu programa está enfocado a varias plataformas, utiliza TProcess, ¡es mejor!.
8	8
9	9		Aquí tenemos las diferentes maneras disponibles sobre como ejecutar un programa/proceso/mandato externo en RTL, FCL y LCL.
10	10
11	11		\| Metodo \| Librería \| Plataformas \| Línea simple \| Características \|
12	12		\|----\|----\|----\|----\|----\|
13	13		\| [[Executing External Programs\|ExecuteProcess]] \| RTL \| Plataforma Cruzada \| Si \| Muy limitado, synchronous \|
14	14		\| [[Executing External Programs\|ShellExecute]] \| WinAPI \| MS Windows only \| Yes \| Muchos. Permite iniciar programas con permisos de elevación/admin. \|
15	15		\| [[Executing External Programs\|fpsystem, fpexecve]] \| Unix \| Unix solamente \| \| \|
16	16		\| [[Executing External Programs/es\|TProcess]] \| FCL \| Plataforma cruzada \| No \| Completas \|
17	17		\| [[Executing External Programs\|RunCommand]] \| FCL \| Plataforma cruzada, Requiere FPC 2.6.2+ \| Si \| Cubre el uso común de TProcess \|
18	18		\| [[Executing External Programs\|OpenDocument]] \| LCL \| Plataforma cruzada \| si \| Solo para abrir documentos. El documento debe abrirse con la aplicación asociada al tipo de documento. \|
19	19
20	20		## TProcess
21	21
22	22		Puedes utilizar TProcess para ejecutar programas externos. Algunas de sus ventajas son:
23	23
24	24		- Independiente de la plataforma
25	25		- Capaz de leer desde la entrada estándar (stdout) y de escribir en la salida estándar (stdin).
26	26
27	27		Nota: TProcess no es un terminal de shell! No puedes ejecutar directamente secuencias de comandos o reorientar la salida usando operadores como "\\|", "\>", "\<", "&", etc. Es posible obtener los mismos resultados con TProcess utilizando Pascal, mira algunos ejemplos más abajo..
28	28
29	29		Importante: Debes especificar la ruta completa al ejecutable. Por ejemplo "/bin/cp " en lugar de "cp". Si el programa está en la ruta estándar, puedes utilizar la función FindDefaultExecutablePath de la unidad FileUtil de la LCL.
30	30
31	31		### Un ejemplo sencillo
32	32
33	33		``` pascal
34	34		// Este es un programa de demostración que enseña como lanzar
35	35		// un programa externo.
36	36		program lanzarprograma;
37	37
38	38		uses
39	39		Classes, SysUtils, Process;
40	40
41	41		// Definición de "UnProceso" como una variable
42	42		// de tipo "TProcess"
43	43		var
44	44		UnProceso: TProcess;
45	45
46	46		begin
47	47		// Ahora creamos UnProceso.
48	48		UnProceso := TProcess.Create(nil);
49	49
50	50		// Asignamos a UnProceso la orden que debe ejecutar.
51	51		// Vamos a lanzar el compilador de FreePascal
52	52		UnProceso.CommandLine := 'ppc386 -h';
53	53
54	54		// Definimos una opción de comportamiento de 'TProccess'
55	55		// La opción poWaitOnExit hará que nuestro programa
56	56		// se detenga hasta que termine el programa lanzado
57	57		UnProceso.Options := UnProceso.Options + [poWaitOnExit];
58	58
59	59		// Lanzamos la ejecución de 'ppc386 -h'.
60	60		UnProceso.Execute;
61	61
62	62		// Nuestro programa espera hasta que 'ppc386' finaliza.
63	63		UnProceso.Free;
64	64		end.
65	65		```
66	66
67	67		¡Eso es todo! Acabas de aprender cómo se ejecuta un programa externo desde dentro de tu propio programa.
68	68
69	69		### Un ejemplo mejorado
70	70
71	71		De acuerdo, pero ¿cómo leo la salida que produce un programa que he ejecutado?
72	72
73	73		Bien, vamos a ampliar un poco nuestro ejemplo mediante lo siguiente:
74	74
75	75		``` pascal
76	76		program lanzarprograma2;
77	77
78	78		uses
79	79		Classes, SysUtils, Process;
80	80
81	81		// Definición de "UnProceso" como una variable de tipo "TProcess"
82	82		// También añadimos un TStringList para almacenar los datos
83	83		// leídos desde la salida del programa.
84	84		var
85	85		UnProceso: TProcess;
86	86		UnaLista: TStringList;
87	87
88	88		// Aquí comienza a ejecutarse nuestro programa.
89	89		begin
90	90
91	91		// Creamos el objeto TStringList.
92	92		UnaLista := TStringList.Create;
93	93
94	94		// Ahora creamos UnProceso.
95	95		UnProceso := TProcess.Create(nil);
96	96
97	97		// Asignamos a UnProceso la orden que debe ejecutar.
98	98		// Vamos a lanzazar el compilador de FreePascal
99	99		// (CommandLine está Obsoleto)
100	100		UnProceso.CommandLine := 'ppc386 -h';
101	101
102	102		// Definimos una opción de comportamiento de 'TProccess'
103	103		// La opción poWaitOnExit hará que nuestro programa
104	104		// se detenga hasta que termine el programa lanzado
105	105		// con la opción poUsePipes advertimos que vamos a utilizar tuberías de Entrada/Salida
106	106		// para que se capture la salida y así poder recuperar su contenido desde nuestro programa
107	107
108	108		UnProceso.Options := UnProceso.Options + [poWaitOnExit, poUsePipes];
109	109
110	110		// Lanzamos la ejecución de 'ppc386 -h'.
111	111		UnProceso.Execute;
112	112
113	113		// Nuestro programa se detiene hasta que 'ppc386' finaliza.
114	114
115	115		// Ahora leemos la salida del programa que acabamos de ejecutar
116	116		// dentro de TStringList.
117	117		UnaLista.LoadFromStream(UnProceso.Output);
118	118
119	119		// Guardamos la salida en un archivo.
120	120		UnaLista.SaveToFile('salida.txt');
121	121
122	122		// Ahora que hemos guardado el archivo podemos liberar la memoria
123	123		// TStringList y TProcess.
124	124		UnaLista.Free;
125	125		UnProceso.Free;
126	126		end.
127	127		```
128	128
129	129		### Lectura de muchos datos de salida
130	130
131	131		En el ejemplo anterior esperamos a que el programa termine. En ese momento leemos lo que el programa ha escrito en la salida. Pero si el programa escribe muchos datos, la tubería se llena y será necesario leerlos para vaciarla, pero el programa llamante no leerá hasta que el programa llamado haya terminado. Nos encontraremos ante un típico bloqueo de la muerte.
132	132
133	133		El siguiente ejemplo, por tanto, no utiliza poWaitOnExit, sino que va leyendo la salida mientras el programa llamado se está ejecutando. La salida se almacena en una memoria intermedia, que se utilizará más tarde para leer en un TStringList, por ejemplo.
134	134
135	135		``` pascal
136	136		program procoutlarge;
137	137		{ Copyright (c) 2004 by Marc Weustink
138	138
139	139		Este ejemplo se ha creado con la esperanza de que resulte útil,
140	140		pero SIN NINGUNA GARANTÍA; ni tan siquiera la garantía implícita de
141	141		COMERCIALIZACIÓN o ADECUACIÓN A UN OBJETIVO PARTICULAR.
142	142		}
143	143
144	144		uses
145	145		Classes, Process, SysUtils;
146	146
147	147		const
148	148		READ_BYTES = 2048;
149	149
150	150		var
151	151		S: TStringList;
152	152		M: TMemoryStream;
153	153		P: TProcess;
154	154		n: LongInt;
155	155		BytesRead: LongInt;
156	156
157	157		begin
158	158		// No podemos utilizar poWaitOnExit porque no
159	159		// conocemos el tamaño de la salida. En Linux el tamaño
160	160		// de la salida de la tubería es de 2 kB. Si los datos de salida son más
161	161		// necesitamos leerlos. Esto no es posible, ya que estamos
162	162		// esperando. Así que aquí nos encontramos en un punto muerto.
163	163		//
164	164		// Se utiliza un Memorystream temporal para almacenar la salida
165	165
166	166		M := TMemoryStream.Create;
167	167		BytesRead := 0;
168	168
169	169		P := TProcess.Create(nil);
170	170		P.CommandLine := 'ppc386 -va bogus.pp';
171	171		P.Options := [poUsePipes];
172	172		WriteLn('-- ejecutando --');
173	173		P.Execute;
174	174		while P.Running do
175	175		begin
176	176		// nos aseguramos de tener espacio
177	177		M.SetSize(BytesRead + READ_BYTES);
178	178
179	179		// intentamos leerlo
180	180		n := P.Output.Read((M.Memory + BytesRead)^, READ_BYTES);
181	181		if n > 0
182	182		then begin
183	183		Inc(BytesRead, n);
184	184		Write('.')
185	185		end
186	186		else begin
187	187		// sin datos, esperamos 100 milisegundos
188	188		Sleep(100);
189	189		end;
190	190		end;
191	191		// leemos la última parte
192	192		repeat
193	193		// nos aseguramos de tener espacio
194	194		M.SetSize(BytesRead + READ_BYTES);
195	195		// intentamos leerlo
196	196		n := P.Output.Read((M.Memory + BytesRead)^, READ_BYTES);
197	197		if n > 0
198	198		then begin
199	199		Inc(BytesRead, n);
200	200		Write('.');
201	201		end;
202	202		until n <= 0;
203	203		if BytesRead > 0 then WriteLn;
204	204		M.SetSize(BytesRead);
205	205		WriteLn('-- ejecutado --');
206	206
207	207		S := TStringList.Create;
208	208		S.LoadFromStream(M);
209	209		WriteLn('-- total de líneas = ', S.Count, ' --');
210	210		for n := 0 to S.Count - 1 do
211	211		begin
212	212		WriteLn('\| ', S[n]);
213	213		end;
214	214		WriteLn('-- fin --');
215	215		S.Free;
216	216		P.Free;
217	217		M.Free;
218	218		end.
219	219		```
220	220
221	221		### Uso de entrada y salida de un TProcess
222	222
223	223		Véase el ejemplo processdemo en [Lazarus-CCR SVN](https://lazarus-ccr.svn.sourceforge.net/svnroot/lazarus-ccr/examples/process)
224	224
225	225		### Notas sobre la utilización de TProcess
226	226
227	227		Si estas creando un programa que funciones en diversas plataformas, puedes cambiar el programa a ejecutar de acuerdo con el sistema operativo, mediante las directivas {\$IFDEF} y {\$ENDIF}.
228	228
229	229		Ejemplo:
230	230
231	231		``` pascal
232	232		{...}
233	233		unProceso:TProcess.Create(nil)
234	234		{$IFDEF WIN32}
235	235		unProceso.CommandLine := 'calc.exe'; //calculadora de Windows
236	236		{$ENDIF}
237	237		{$IFDEF LINUX}
238	238		unProceso.CommandLine := 'kcalc'; //calculadora de KDE o bien xcalc si no tienes KDE
239	239		{$ENDIF}
240	240		unProceso.Execute; //también puedes utilizar unProceso.Active:=True
241	241		{...}
242	242		```
243	243
244	244		En cuanto a TProcess tomando como referencia las propiedades del componente visual tiene las siguientes opciones (po=process options):
245	245
246	246		- poDebugOnlyThisProcess.
247	247		- poDebugProcess.
248	248		- poDefaultErrorMode
249	249		- poNewConsole.
250	250		- poNewProcessGroup.
251	251		- poNoConsole.
252	252		- poRunSuspended.
253	253		- poStderrToOutPut.
254	254		- poUsePipes: utilizado para interconectar procesos.
255	255		- poWaitOnExit: esperar a que finalice el programa.
256	256
257		-	~~<figure>~~
258	257		<img src="TProcess_Options.PNG" title="TProcess_Options.PNG" width="300" />
259		-	~~<figcaption>TProcess_Options.PNG</figcaption>~~
260		-	~~</figure>~~
261	258
262	259		A falta de explicar que hace cada opción.
263	260
264	261		[Referencia TProcess](http://lazarus-ccr.sourceforge.net/docs/fcl/process/tprocess.html).
265	262
266	263		### Ejemplo de conversación con el proceso aspell
267	264
268	265		Dentro del código fuente [pasdoc](http://pasdoc.sourceforge.net/) puedes encontrar dos unidades que realizan corrección ortográfica conversando con un proceso aspell a través de tuberías:
269	266
270	267		- [PasDoc_ProcessLineTalk.pas unit](http://cvs.sourceforge.net/viewcvs.py/checkout/pasdoc/pasdoc/source/component/PasDoc_ProcessLineTalk.pas) ejecuta la clase TProcessLineTalk, descendiente de TProcess, que se puede utilizar fácilmente para comunicar con cualquier proceso línea a línea.
271	268
272	269		- [PasDoc_Aspell.pas units](http://cvs.sourceforge.net/viewcvs.py/checkout/pasdoc/pasdoc/source/component/PasDoc_Aspell.pas) ejecuta la clase TAspellProcess, que realiza corrección ortográfica utilizando la instancia fundamental TProcessLineTalk para ejecutar aspell y comunicarse con el proceso aspell que se está ejecutando.
273	270
274	271		Ambas unidades son bastante independientes del resto de fuentes de pasdoc, así que pueden servir como ejemplos reales de la utilización de TProcess para ejecutar y comunicarse a través de tuberías con otros programas.
275	272
276	273		### Reemplazar operadores de Shell como "\\|", "\<" y "\>"
277	274
278	275		A veces queremos ejecutar una orden compleja que envía (entuba) sus datos a otra orden o a un archivo. Algo como
279	276
280	277		` ShellExecute('primeraorden.exe \| segundaorden.exe');`
281	278
282	279		o
283	280
284	281		` ShellExecute('dir > salida.txt');`
285	282
286	283		Esto no funciona con TProcess. p.e.:
287	284
288	285		` // esto no funciona`\
289	286		` Process.CommandLine := 'primeraorden.exe \| segundaorden.exe'; `\
290	287		` Process.Execute;`
291	288
292	289		#### ¿Por qué utilizar operadores especiales para redirigir la salida no funciona?
293	290
294	291		TProcess es justamente, eso, un proceso, no es un entorno de shell. No es dos procesos, únicamente es un proceso. Es posible, no obstante, redirigir la salida de la manera que queremos. Ver [[Executing External Programs/es\|más adelante, la siguiente sección]].
295	292
296	293		### Cómo redirigir la salida con TProcess
297	294
298	295		Podemos redirigir la salidad de un comando a otro comando utilizando una instancia de TProcess para cada commando.
299	296
300	297		Este es un ejemplo que explica cómo redirigir la salida de un proceso a otro. Para redirigir la salida de un proceso a un archivo o flujo ver el ejemplo [[Executing External Programs/es\|Lectura de muchos datos de salida]]
301	298
302	299		``` pascal
303	300		program Proyecto1;
304	301
305	302		uses
306	303		Classes, sysutils, process;
307	304
308	305		var
309	306		PrimerProceso,
310	307		SegundoProceso: TProcess;
311	308		Buffer: array[0..127] of char;
312	309		ContadorLectura: Integer;
313	310		TamanyoLectura: Integer;
314	311		begin
315	312		PrimerProceso := TProcess.Create(nil);
316	313		SegundoProceso := TProcess.Create(nil);
317	314
318	315		PrimerProceso.Options := [poUsePipes];
319	316		SegundoProceso.Options := [poUsePipes,poStderrToOutPut];
320	317
321	318		PrimerProceso.CommandLine := 'pwd';
322	319		SegundoProceso.CommandLine := 'grep '+ DirectorySeparator+ ' -';
323	320		// esto sería lo mismo que "pwd \| grep / -"
324	321
325	322		PrimerProceso.Execute;
326	323		SegundoProceso.Execute;
327	324
328	325		while PrimerProceso.Running or (PrimerProceso.Output.NumBytesAvailable > 0) do
329	326		begin
330	327		if PrimerProceso.Output.NumBytesAvailable > 0 then
331	328		begin
332	329		// asegurate de que no lees más datos que los asignados
333	330		// en el buffer
334	331		TamanyoLectura := PrimerProceso.Output.NumBytesAvailable;
335	332		if TamanyoLectura > SizeOf(Buffer) then
336	333		TamanyoLectura := SizeOf(Buffer);
337	334		// ahora leemos la salida en el buffer
338	335		ContadorLectura := PrimerProceso.Output.Read(Buffer[0], TamanyoLectura);
339	336		// y escribimos el buffer en el segundo proceso
340	337		SegundoProceso.Input.Write(Buffer[0], ContadorLectura);
341	338
342	339		// Si SegundoProceso escribe muchos datos en la salida a continuación,
343	340		// debes leer los datos aquí para evitar un punto muerto
344	341		// ver el ejemplo anterior "Lectura de muchos datos de salida"
345	342		end;
346	343		end;
347	344		// Cerrar la entrad de SegundoProceso
348	345		// y finaliza el procesamiento de datos
349	346		SegundoProceso.CloseInput;
350	347
351	348		// y esperar a que finalice
352	349		// ten cuidado con que comando se ejecuta porque no puede terminar cuando
353	350		// la entrada está cerrada y la siguiente línea será un bucle sin fin
354	351		while SegundoProceso.Running do
355	352		Sleep(1);
356	353		// ¡eso es todo! el resto del programa es sólo un ejemplo
357	354		// es poco "útil"
358	355
359	356		// vamos a reutilizar el buffer para la salida del SegundoProceso
360	357		// a la salida estándar de este programa
361	358		WriteLn('Comienza la salida de Grep:');
362	359		TamanyoLectura := SegundoProceso.Output.NumBytesAvailable;
363	360		if TamanyoLectura > SizeOf(Buffer) then
364	361		TamanyoLectura := SizeOf(Buffer);
365	362		if TamanyoLectura > 0 then
366	363		begin
367	364		ContadorLectura := SegundoProceso.Output.Read(Buffer, TamanyoLectura);
368	365		WriteLn(Copy(Buffer,0, ContadorLectura));
369	366		end
370	367		else
371	368		WriteLn('grep NO encontró lo que se buscaba. ', SegundoProceso.ExitStatus);
372	369		WriteLn('Termina la salida de Grep:');
373	370
374	371		// Liberamos los objetos TProcess
375	372		PrimerProceso.Free;
376	373		SegundoProceso.Free;
377	374		end.
378	375		```
379	376
380	377		Eso es todo. Ahora podemos redirigir la salida de un programa a otro.
381	378
382	379		#### Notas
383	380
384	381		Este ejemplo puede parecer exagerado, ya que es posible ejecutar "complicados" comandos shell con TProcess como:
385	382
386	383		` Process.Commandline := 'sh -c "pwd \| grep / -"';`
387	384
388	385		Pero el ejemplo es más multiplataforma, ya que no necesita ninguna modificación para ejecutarse en Windows o Linux, etc. sh puede o no existir en su plataforma y, en general sólo disponible en plataformas *nix. También tenemos más flexibilidad en nuestro ejemplo ya que se puede leer y escribir desde/a la entrada, salida y salida de error estándar de cada proceso individual, lo que podría ser muy ventajoso para tu proyecto.
389	386
390	387		### Redirigir entrada y salida bajo root
391	388
392	389		Un problema común en Unix (macOS) y Linux surge cuando se desea ejecutar algún programa en la cuenta de root (o, en otra cuenta de usuario). Un ejemplo sería ejecutar el comando ping''''.
393	390
394	391		Si puedes usar sudo para esto, se puede adaptar el ejemplo siguiente, una adaptación de uno publicado por andyman en el foro ([1](http://lazarus.freepascal.org/index.php/topic,14479.0.html)). Este ejemplo ejecuta la orden `ls` en el `/root`, pero por supuesto puede ser adaptada.
395	392
396	393		"Una forma mejor'' de hacerlo es usar el paquete PolicyKit, que debería estar disponible en todos los Linux recientes. [ver el hilo del foro para más detalles.](http://lazarus.freepascal.org/index.php/topic,14479.0.html)
397	394
398	395		Gran parte de este código es similar al ejemplo anterior, pero también se muestra cómo redirigir los flujos stdout y stderr del proceso llamado a los flujos stdout y stderr de nuestro propio código.
399	396
400	397		``` pascal
401	398		program rootls;
402	399
403	400		{ Demonstrates using TProcess, redirecting stdout/stderr to our stdout/stderr,
404	401		calling sudo on Linux/macOS, and supplying input on stdin}
405	402		{$mode objfpc}{$H+}
406	403
407	404		uses
408	405		Classes,
409	406		Math, {for min}
410	407		Process;
411	408
412	409		procedure RunsLsRoot;
413	410		var
414	411		Proc: TProcess;
415	412		CharBuffer: array [0..511] of char;
416	413		ReadCount: integer;
417	414		ExitCode: integer;
418	415		SudoPassword: string;
419	416		begin
420	417		WriteLn('Please enter the sudo password:');
421	418		Readln(SudoPassword);
422	419		ExitCode := -1; //Start out with failure, let's see later if it works
423	420		Proc := TProcess.Create(nil); //Create a new process
424	421		try
425	422		Proc.Options := [poUsePipes, poStderrToOutPut]; //Use pipes to redirect program stdin,stdout,stderr
426	423		Proc.CommandLine := 'sudo -S ls /root'; //Run ls /root as root using sudo
427	424		// -S causes sudo to read the password from stdin.
428	425		Proc.Execute; //start it. sudo will now probably ask for a password
429	426
430	427		// write the password to stdin of the sudo program:
431	428		SudoPassword := SudoPassword + LineEnding;
432	429		Proc.Input.Write(SudoPassword[1], Length(SudoPassword));
433	430		SudoPassword := '%*'; //short string, hope this will scramble memory a bit; note: using PChars is more fool-proof
434	431		SudoPassword := ''; // and make the program a bit safer from snooping?!?
435	432
436	433		// main loop to read output from stdout and stderr of sudo
437	434		while Proc.Running or (Proc.Output.NumBytesAvailable > 0) or
438	435		(Proc.Stderr.NumBytesAvailable > 0) do
439	436		begin
440	437		// read stdout and write to our stdout
441	438		while Proc.Output.NumBytesAvailable > 0 do
442	439		begin
443	440		ReadCount := Min(512, Proc.Output.NumBytesAvailable); //Read up to buffer, not more
444	441		Proc.Output.Read(CharBuffer, ReadCount);
445	442		Write(StdOut, Copy(CharBuffer, 0, ReadCount));
446	443		end;
447	444		// read stderr and write to our stderr
448	445		while Proc.Stderr.NumBytesAvailable > 0 do
449	446		begin
450	447		ReadCount := Min(512, Proc.Stderr.NumBytesAvailable); //Read up to buffer, not more
451	448		Proc.Stderr.Read(CharBuffer, ReadCount);
452	449		Write(StdErr, Copy(CharBuffer, 0, ReadCount));
453	450		end;
454	451		end;
455	452		ExitCode := Proc.ExitStatus;
456	453		finally
457	454		Proc.Free;
458	455		Halt(ExitCode);
459	456		end;
460	457		end;
461	458
462	459		begin
463	460		RunsLsRoot;
464	461		end.
465	462		```
466	463
467	464		Otras cuestiones:
468	465
469	466		Sería, sin duda, aconsejable ver si realmente sudo pide una contraseña. Esto se puede comprobar consistetemente estableciendo la variable de entorno SUDO_PROMPT a algo que tener en cuenta mientras la lectura de la salida estándar de *TProcess* para evitar el problema de que el sistema es diferente para diferentes idiomas. Configurar una variable de entorno hace que los valores predeterminados (heredados de nuestro proceso) se borren, así que tenemos que copiar el entorno de nuestro programa, si es necesario.
470	467
471	468		### Parámetros que contienen espacios (Reemplazar comillas del interprete)
472	469
473	470		En el interprete de Linux, es posible escribir los argumentos entrecomillados así:
474	471
475	472		` gdb --batch --eval-command="info symbol 0x0000DDDD" miprograma`
476	473
477	474		Y GDB recibirá 3 argumentos (además del primer argumento que es la ruta completa al ejecutable):
478	475
479	476		` #--batch`\
480	477		` #--eval-command=info symbol 0x0000DDDD`\
481	478		` #la ruta completa a miprograma`
482	479
483	480		TProcess además pasa los parámetros que contengan espacios, pero utiliza un estilo diferente de entrecomillado. En lugar de sólo entrecomillar parte del parámetro, entrecomilla todo él. Tal que así:
484	481
485	482		` TProcess.CommandLine := '/usr/bin/gdb --batch "--eval-command=info symbol 0x0000DDDD" /midirectorio/yo/miprograma';`
486	483
487	484		Y también recuerda pasar sólo rutas completas.
488	485
489	486		Véase también la discusión al respecto: <http://bugs.freepascal.org/view.php?id=14446>
490	487
491	488		## Alternativas
492	489
493	490		A veces, no es necesario llamar explícitamente a un programa externo para obtener la funcionalidad que necesitas. A continuación se presentan algunos ejemplos
494	491
495	492		### Abrir una página web en el navegador web predeterminado
496	493
497	494		Algo así sería más fácil:
498	495
499	496		``` pascal
500	497		uses LCLIntf;
501	498		...
502	499		OpenURL(URL);
503	500		```
504	501
505	502		Sin embargo, puedes utilizar algo como esto:
506	503
507	504		``` pascal
508	505		uses Process, LCLIntf;
509	506
510	507		procedure OpenWebPage(URL: string);
511	508		// Apparently you need to pass your URL inside ", like "www.lazarus.freepascal.org"
512	509		var
513	510		Browser, Params: string;
514	511		begin
515	512		FindDefaultBrowser(Browser, Params);
516	513		with TProcess.Create(nil) do
517	514		try
518	515		Executable := Browser;
519	516		Params:=Format(Params, [URL]);
520	517		Params:=copy(Params,2,length(Params)-2); // elimina "", la nueva versión de TProcess.Parameters los hace por sí mismo
521	518		Parameters.Add(Params);
522	519		Options := [poNoConsole];
523	520		Execute;
524	521		finally
525	522		Free;
526	523		end;
527	524		end;
528	525		```
529	526
530	527		## Ver también
531	528
532	529		- [[TXMLPropStorage/es\|TXMLPropStorage]]
533	530		- [[Webbrowser]]
534	531
535	532		---
536	533		From the Free Pascal wiki, page "Executing External Programs/es", as it stood on 2020-08-26 after a change by Iskraelectrica, 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).
537	534		Category: Castellano
538	535		Category: Español

Back to history