Executing External Programs/es: what changed

Revision 3 to 4. 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	257		![](/wiki-images/6/6e/TProcess_Options.PNG)
258	258
259	259		A falta de explicar que hace cada opción.
260	260
261	261		[Referencia TProcess](http://lazarus-ccr.sourceforge.net/docs/fcl/process/tprocess.html).
262	262
263	263		### Ejemplo de conversación con el proceso aspell
264	264
265	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:
266	266
267	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.
268	268
269	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.
270	270
271	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.
272	272
273	273		### Reemplazar operadores de Shell como "\\|", "\<" y "\>"
274	274
275	275		A veces queremos ejecutar una orden compleja que envía (entuba) sus datos a otra orden o a un archivo. Algo como
276	276
277		-	~~` ShellExecute('primeraorden.exe \| segundaorden.exe');`~~
	277	+	```text
	278	+	ShellExecute('primeraorden.exe \| segundaorden.exe');
	279	+	```
278	280
279	281		o
280	282
281		-	~~` ShellExecute('dir > salida.txt');`~~
	283	+	```text
	284	+	ShellExecute('dir > salida.txt');
	285	+	```
282	286
283	287		Esto no funciona con TProcess. p.e.:
284	288
285		-	~~` // esto no funciona`\~~
286		-	~~` Process.CommandLine := 'primeraorden.exe \| segundaorden.exe'; `\~~
287		-	~~` Process.Execute;`~~
	289	+	``` pascal
	290	+	// esto no funciona
	291	+	Process.CommandLine := 'primeraorden.exe \| segundaorden.exe';
	292	+	Process.Execute;
	293	+	```
288	294
289	295		#### ¿Por qué utilizar operadores especiales para redirigir la salida no funciona?
290	296
291	297		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]].
292	298
293	299		### Cómo redirigir la salida con TProcess
294	300
295	301		Podemos redirigir la salidad de un comando a otro comando utilizando una instancia de TProcess para cada commando.
296	302
297	303		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]]
298	304
299	305		``` pascal
300	306		program Proyecto1;
301	307
302	308		uses
303	309		Classes, sysutils, process;
304	310
305	311		var
306	312		PrimerProceso,
307	313		SegundoProceso: TProcess;
308	314		Buffer: array[0..127] of char;
309	315		ContadorLectura: Integer;
310	316		TamanyoLectura: Integer;
311	317		begin
312	318		PrimerProceso := TProcess.Create(nil);
313	319		SegundoProceso := TProcess.Create(nil);
314	320
315	321		PrimerProceso.Options := [poUsePipes];
316	322		SegundoProceso.Options := [poUsePipes,poStderrToOutPut];
317	323
318	324		PrimerProceso.CommandLine := 'pwd';
319	325		SegundoProceso.CommandLine := 'grep '+ DirectorySeparator+ ' -';
320	326		// esto sería lo mismo que "pwd \| grep / -"
321	327
322	328		PrimerProceso.Execute;
323	329		SegundoProceso.Execute;
324	330
325	331		while PrimerProceso.Running or (PrimerProceso.Output.NumBytesAvailable > 0) do
326	332		begin
327	333		if PrimerProceso.Output.NumBytesAvailable > 0 then
328	334		begin
329	335		// asegurate de que no lees más datos que los asignados
330	336		// en el buffer
331	337		TamanyoLectura := PrimerProceso.Output.NumBytesAvailable;
332	338		if TamanyoLectura > SizeOf(Buffer) then
333	339		TamanyoLectura := SizeOf(Buffer);
334	340		// ahora leemos la salida en el buffer
335	341		ContadorLectura := PrimerProceso.Output.Read(Buffer[0], TamanyoLectura);
336	342		// y escribimos el buffer en el segundo proceso
337	343		SegundoProceso.Input.Write(Buffer[0], ContadorLectura);
338	344
339	345		// Si SegundoProceso escribe muchos datos en la salida a continuación,
340	346		// debes leer los datos aquí para evitar un punto muerto
341	347		// ver el ejemplo anterior "Lectura de muchos datos de salida"
342	348		end;
343	349		end;
344	350		// Cerrar la entrad de SegundoProceso
345	351		// y finaliza el procesamiento de datos
346	352		SegundoProceso.CloseInput;
347	353
348	354		// y esperar a que finalice
349	355		// ten cuidado con que comando se ejecuta porque no puede terminar cuando
350	356		// la entrada está cerrada y la siguiente línea será un bucle sin fin
351	357		while SegundoProceso.Running do
352	358		Sleep(1);
353	359		// ¡eso es todo! el resto del programa es sólo un ejemplo
354	360		// es poco "útil"
355	361
356	362		// vamos a reutilizar el buffer para la salida del SegundoProceso
357	363		// a la salida estándar de este programa
358	364		WriteLn('Comienza la salida de Grep:');
359	365		TamanyoLectura := SegundoProceso.Output.NumBytesAvailable;
360	366		if TamanyoLectura > SizeOf(Buffer) then
361	367		TamanyoLectura := SizeOf(Buffer);
362	368		if TamanyoLectura > 0 then
363	369		begin
364	370		ContadorLectura := SegundoProceso.Output.Read(Buffer, TamanyoLectura);
365	371		WriteLn(Copy(Buffer,0, ContadorLectura));
366	372		end
367	373		else
368	374		WriteLn('grep NO encontró lo que se buscaba. ', SegundoProceso.ExitStatus);
369	375		WriteLn('Termina la salida de Grep:');
370	376
371	377		// Liberamos los objetos TProcess
372	378		PrimerProceso.Free;
373	379		SegundoProceso.Free;
374	380		end.
375	381		```
376	382
377	383		Eso es todo. Ahora podemos redirigir la salida de un programa a otro.
378	384
379	385		#### Notas
380	386
381	387		Este ejemplo puede parecer exagerado, ya que es posible ejecutar "complicados" comandos shell con TProcess como:
382	388
383		-	~~` Process.Commandline := 'sh -c "pwd \| grep / -"';`~~
	389	+	``` pascal
	390	+	Process.Commandline := 'sh -c "pwd \| grep / -"';
	391	+	```
384	392
385	393		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.
386	394
387	395		### Redirigir entrada y salida bajo root
388	396
389	397		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''''.
390	398
391	399		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.
392	400
393	401		"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)
394	402
395	403		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.
396	404
397	405		``` pascal
398	406		program rootls;
399	407
400	408		{ Demonstrates using TProcess, redirecting stdout/stderr to our stdout/stderr,
401	409		calling sudo on Linux/macOS, and supplying input on stdin}
402	410		{$mode objfpc}{$H+}
403	411
404	412		uses
405	413		Classes,
406	414		Math, {for min}
407	415		Process;
408	416
409	417		procedure RunsLsRoot;
410	418		var
411	419		Proc: TProcess;
412	420		CharBuffer: array [0..511] of char;
413	421		ReadCount: integer;
414	422		ExitCode: integer;
415	423		SudoPassword: string;
416	424		begin
417	425		WriteLn('Please enter the sudo password:');
418	426		Readln(SudoPassword);
419	427		ExitCode := -1; //Start out with failure, let's see later if it works
420	428		Proc := TProcess.Create(nil); //Create a new process
421	429		try
422	430		Proc.Options := [poUsePipes, poStderrToOutPut]; //Use pipes to redirect program stdin,stdout,stderr
423	431		Proc.CommandLine := 'sudo -S ls /root'; //Run ls /root as root using sudo
424	432		// -S causes sudo to read the password from stdin.
425	433		Proc.Execute; //start it. sudo will now probably ask for a password
426	434
427	435		// write the password to stdin of the sudo program:
428	436		SudoPassword := SudoPassword + LineEnding;
429	437		Proc.Input.Write(SudoPassword[1], Length(SudoPassword));
430	438		SudoPassword := '%*'; //short string, hope this will scramble memory a bit; note: using PChars is more fool-proof
431	439		SudoPassword := ''; // and make the program a bit safer from snooping?!?
432	440
433	441		// main loop to read output from stdout and stderr of sudo
434	442		while Proc.Running or (Proc.Output.NumBytesAvailable > 0) or
435	443		(Proc.Stderr.NumBytesAvailable > 0) do
436	444		begin
437	445		// read stdout and write to our stdout
438	446		while Proc.Output.NumBytesAvailable > 0 do
439	447		begin
440	448		ReadCount := Min(512, Proc.Output.NumBytesAvailable); //Read up to buffer, not more
441	449		Proc.Output.Read(CharBuffer, ReadCount);
442	450		Write(StdOut, Copy(CharBuffer, 0, ReadCount));
443	451		end;
444	452		// read stderr and write to our stderr
445	453		while Proc.Stderr.NumBytesAvailable > 0 do
446	454		begin
447	455		ReadCount := Min(512, Proc.Stderr.NumBytesAvailable); //Read up to buffer, not more
448	456		Proc.Stderr.Read(CharBuffer, ReadCount);
449	457		Write(StdErr, Copy(CharBuffer, 0, ReadCount));
450	458		end;
451	459		end;
452	460		ExitCode := Proc.ExitStatus;
453	461		finally
454	462		Proc.Free;
455	463		Halt(ExitCode);
456	464		end;
457	465		end;
458	466
459	467		begin
460	468		RunsLsRoot;
461	469		end.
462	470		```
463	471
464	472		Otras cuestiones:
465	473
466	474		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.
467	475
468	476		### Parámetros que contienen espacios (Reemplazar comillas del interprete)
469	477
470	478		En el interprete de Linux, es posible escribir los argumentos entrecomillados así:
471	479
472		-	~~` gdb --batch --eval-command="info symbol 0x0000DDDD" miprograma`~~
	480	+	```text
	481	+	gdb --batch --eval-command="info symbol 0x0000DDDD" miprograma
	482	+	```
473	483
474	484		Y GDB recibirá 3 argumentos (además del primer argumento que es la ruta completa al ejecutable):
475	485
476		-	~~` #--batch`\~~
477		-	~~` #--eval-command=info symbol 0x0000DDDD`\~~
478		-	~~` #la ruta completa a miprograma`~~
	486	+	```text
	487	+	#--batch
	488	+	#--eval-command=info symbol 0x0000DDDD
	489	+	#la ruta completa a miprograma
	490	+	```
479	491
480	492		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í:
481	493
482		-	~~` TProcess.CommandLine := '/usr/bin/gdb --batch "--eval-command=info symbol 0x0000DDDD" /midirectorio/yo/miprograma';`~~
	494	+	``` pascal
	495	+	TProcess.CommandLine := '/usr/bin/gdb --batch "--eval-command=info symbol 0x0000DDDD" /midirectorio/yo/miprograma';
	496	+	```
483	497
484	498		Y también recuerda pasar sólo rutas completas.
485	499
486	500		Véase también la discusión al respecto: <http://bugs.freepascal.org/view.php?id=14446>
487	501
488	502		## Alternativas
489	503
490	504		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
491	505
492	506		### Abrir una página web en el navegador web predeterminado
493	507
494	508		Algo así sería más fácil:
495	509
496	510		``` pascal
497	511		uses LCLIntf;
498	512		...
499	513		OpenURL(URL);
500	514		```
501	515
502	516		Sin embargo, puedes utilizar algo como esto:
503	517
504	518		``` pascal
505	519		uses Process, LCLIntf;
506	520
507	521		procedure OpenWebPage(URL: string);
508	522		// Apparently you need to pass your URL inside ", like "www.lazarus.freepascal.org"
509	523		var
510	524		Browser, Params: string;
511	525		begin
512	526		FindDefaultBrowser(Browser, Params);
513	527		with TProcess.Create(nil) do
514	528		try
515	529		Executable := Browser;
516	530		Params:=Format(Params, [URL]);
517	531		Params:=copy(Params,2,length(Params)-2); // elimina "", la nueva versión de TProcess.Parameters los hace por sí mismo
518	532		Parameters.Add(Params);
519	533		Options := [poNoConsole];
520	534		Execute;
521	535		finally
522	536		Free;
523	537		end;
524	538		end;
525	539		```
526	540
527	541		## Ver también
528	542
529	543		- [[TXMLPropStorage/es\|TXMLPropStorage]]
530	544		- [[Webbrowser]]
531	545
532	546		---
533	547		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).
534	548		Category: Castellano
535	549		Category: Español

Back to history