Executing External Programs/es: what changed

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

Back to history