Rosetta Stone: what changed

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

Old	New		Line
1	1		## Introduction
2	2
3	3		Often, people new to a programming language/library have trouble mapping the things they know how to do in other environments to the new environments.
4	4
5	5		It can be handy to have a sort of "Rosetta stone" that roughly translates tasks from one environment/language into another.
6	6
7	7		## Programming languages
8	8
9	9		If you have experience in other programming languages (such as C++, Visual Basic), there are some Rosetta stone web pages that might help you. As the Free Pascal/Lazarus syntax and library is fairly consistent with Delphi's, sites that "translate" to Delphi are also a valuable resource.
10	10
11	11		Some useful pages:
12	12
13	13		- [<http://mc-computing.com/Languages/>](http://mc-computing.com/Languages/) This page has some explanation of the concepts involved
14	14		- [<http://rosettacode.org/wiki/Category:Pascal>](http://rosettacode.org/wiki/Category:Pascal) A huge number of languages, even esoteric, and tasks, make this site special
15	15		- [[Pascal for C users]]
16	16		- [[Pascal for CSharp users]]
17	17		- [[Pascal for Java users]]
18	18
19	19		## Operating systems
20	20
21	21		If you know how to do something in an operating system, chances are you can do the same using FPC/Lazarus.
22	22
23	23		The table below gives a rough mapping of some tasks:
24	24
25	25		Windows/DOS
26	26
27	27		Unix/Linux
28	28
29	29		Description
30	30
31	31		FreePascal/Lazarus
32	32
33	33		assoc
34	34
35	35		Show/edit file associations
36	36
37	37		See [[FileAssociation]]
38	38
39	39		copy
40	40
41	41		cp
42	42
43	43		Copy file
44	44
45	45		Lazarus [[CopyFile\|fileutil.copyfile]]; roll your own with filestreams, see e.g. [[File Handling In Pascal\|File_Handling_In_Pascal#FileCopy]]
46	46
47	47		date /t
48	48
49	49		date
50	50
51	51		Show current date
52	52
53	53		sysutils.now (date/time); sysutils.date (date); sysutils.time (time)
54	54
55	55		del, erase
56	56
57	57		rm, rm -f
58	58
59	59		Delete file
60	60
61	61		sysutils.deletefile, erase
62	62
63	63		deltree, rmdir /s
64	64
65	65		rm -r,rm -rf
66	66
67	67		Remove directories with subdirectories
68	68
69	69		Lazarus fileutil.deletedirectory
70	70
71	71		dir
72	72
73	73		ls
74	74
75	75		Find files in a directory
76	76
77	77		Lazarus [[FindAllFiles]]
78	78
79	79		diskpart list volume
80	80
81	81		mount
82	82
83	83		Show partitions/volumes/drives on a computer
84	84
85	85		Windows: see [[Windows Programming Tips\|Windows_Programming_Tips#Listing_all_available_drives]]
86	86
87	87		Linux: see [[Linux Programming Tips\|Linux_Programming_Tips#Get_the_list_of_mounted_partitions]]
88	88
89	89		Unix: you'll have to parse some files (e.g. /etc/mtab) yourself, depending on Unix flavour; see [Forum post](http://lazarus.freepascal.org/index.php/topic,15943.msg86569.html#msg86569)
90	90
91	91		find
92	92
93	93		grep
94	94
95	95		Search for a text/string
96	96
97	97		Several options, including the pos, ansipos functions. Regular expression support is provided by the [[RegEx packages]].
98	98
99	99		ldifde
100	100
101	101		ldapsearch
102	102
103	103		Search through Active Directory/LDAP
104	104
105	105		Use [[Synapse]] ldapsend unit to work with LDAP queries; see e.g. [example code on Leonardo Ramé's blog](http://leonardorame.blogspot.com/2007_02_01_archive.html)
106	106
107	107		md5sum
108	108
109	109		md5sum
110	110
111	111		Calculate hash of file contents
112	112
113	113		You can use the MDFile function in the md5 FPC unit.
114	114
115	115		mkdir
116	116
117	117		mkdir
118	118
119	119		Create directory
120	120
121	121		mkdir; forcedirectories (creates entire path, if necessary)
122	122
123	123		move
124	124
125	125		mv
126	126
127	127		Move file to another directory
128	128
129	129		Within partition/disk: sysutils.renamefile; otherwise copy and delete original
130	130
131	131		rename, ren
132	132
133	133		mv
134	134
135	135		Rename file
136	136
137	137		sysutils.renamefile (can also "move" a file between directories, but only on same partition/disk
138	138
139	139		sc query \<servicename\>
140	140
141	141		service --status-all
142	142
143	143		Show status for service
144	144
145	145		See [[ServiceManager]]
146	146
147	147		?
148	148
149	149		sed -i 's\\|Delphi\\|FreePascal\\|g' readme.txt
150	150
151	151		Search and replace text in file.
152	152
153	153		See example code below.
154	154
155	155		shutdown
156	156
157	157		shutdown
158	158
159	159		Shut down computer
160	160
161	161		Windows: see [forum post](http://forum.lazarus.freepascal.org/index.php/topic,16258.msg87992.html#msg87992)
162	162
163	163		tasklist
164	164
165	165		ps
166	166
167	167		List or find processes
168	168
169	169		Windows: [[Windows Programming Tips\|Windows_Programming_Tips#Showing.2Ffinding_processes]]
170	170
171	171		?
172	172
173	173		touch
174	174
175	175		Create a new empty file
176	176
177	177		sysutils.filecreate(filename)
178	178
179	179		?
180	180
181	181		touch
182	182
183	183		Modify file time
184	184
185	185		See [[Create a new file date/de]]
186	186
187	187		?
188	188
189	189		uname
190	190
191	191		Get kernel/system info
192	192
193	193		See uname function below.
194	194
195	195		wget, curl
196	196
197	197		wget, curl
198	198
199	199		Download file from HTTP/FTP
200	200
201	201		Multiple options, e.g. use synapse httpsend or ftpsend units: [[Synapse\|Synapse#Downloading_files]]
202	202
203	203		?
204	204
205	205		which
206	206
207	207		Search for executable in path
208	208
209	209		Lazarus fileutil.FindDefaultExecutablePath; see also the example below.
210	210
211	211		?
212	212
213	213		whoami
214	214
215	215		Find out username
216	216
217	217		See UserName function below. On Windows: you can check if you're Administrator: winutils.iswindowsadmin(). On *nix: fpgeteuid shows you the effective userid (0 for root).
218	218
219	219		## Emulating uname
220	220
221	221		Works on Linux, probably FreeBSD:
222	222
223	223		``` pascal
224	224		program uname;
225	225
226	226		uses baseunix;
227	227
228	228		var KernelName: UtsName;
229	229
230	230		begin
231	231		fpuname(KernelName);
232	232		writeln(kernelname.sysname);
233	233		writeln(kernelname.nodename);
234	234		writeln(kernelname.release);
235	235		writeln(kernelname.version);
236	236		writeln(kernelname.machine);
237	237		writeln(kernelname.domain);
238	238		end.
239	239		```
240	240
241	241		Sample output:
242	242
243		-	~~`Linux`\~~
244		-	~~`mydebianmachine`\~~
245		-	~~`3.12-1-amd64`\~~
246		-	~~`#1 SMP Debian 3.12.6-2 (2013-12-29)`\~~
247		-	~~`x86_64`\~~
248		-	~~`(none)`~~
	243	+	```text
	244	+	Linux
	245	+	mydebianmachine
	246	+	3.12-1-amd64
	247	+	#1 SMP Debian 3.12.6-2 (2013-12-29)
	248	+	x86_64
	249	+	(none)
	250	+	```
249	251
250	252		## Emulating which
251	253
252	254		Although Lazarus has FindDefaultExecutablePath, it has some flaws. Use e.g. this code:
253	255
254	256		``` pascal
255	257		function Which(Executable: string): string;
256	258		var
257	259		Output: string;
258	260		begin
259	261		{$IFDEF UNIX}
260	262		// Note: we're using external which because
261	263		// FindDefaultExecutablePath
262	264		// doesn't check if the user has execute permission
263	265		// on the found file.
264	266		ExecuteCommand('which '+Executable,Output,false);
265	267		// Remove trailing LF(s) and other control codes:
266	268		while (length(output)>0) and (ord(output[length(output)])<$20) do
267	269		delete(output,length(output),1);
268	270		{$ELSE}
269	271		Output:=FindDefaultExecutablePath(Executable);
270	272		{$ENDIF UNIX}
271	273		// Extra check:
272	274		if (Output<>'') and fileexists(Output) then
273	275		begin
274	276		result:=Output;
275	277		end
276	278		else
277	279		begin
278	280		result:=''; //command failed
279	281		end;
280	282		end;
281	283		```
282	284
283	285		## Emulating whoami
284	286
285	287		... or getting the current user's operating system username. Returns a UTF8 string.
286	288
287	289		``` pascal
288	290		uses
289	291		{$IFDEF UNIX}
290	292		{$IF (DEFINED(LINUX)) OR (DEFINED(FREEBSD))}
291	293		,users //not available on OSX
292	294		{$ENDIF}
293	295		,baseunix //for fpgetuid
294	296		.... //other unix stuff
295	297		{$ENDIF}
296	298		{$IFDEF MSWINDOWS}
297	299		,windows
298	300		{$ENDIF}
299	301		,lazutf8
300	302
301	303		function UserName: string;
302	304		// Get Operating System user name
303	305		{$IFDEF WINDOWS}
304	306		const
305	307		MaxLen = 256;
306	308		var
307	309		Len: DWORD;
308	310		WS: WideString;
309	311		Res: windows.BOOL;
310	312		{$ENDIF}
311	313		begin
312	314		Result := '';
313	315		{$IFDEF WINDOWS}
314	316		Len := MaxLen;
315	317		{$IFNDEF WINCE}
316	318		// Check for Win98..WinME:
317	319		if Win32MajorVersion <= 4 then
318	320		begin
319	321		SetLength(Result,MaxLen);
320	322		Res := Windows.GetUserName(@Result[1], Len);
321	323		if Res then
322	324		begin
323	325		SetLength(Result,Len-1);
324	326		Result := SysToUtf8(Result);
325	327		end
326	328		else
327	329		SetLength(Result,0);
328	330		end
329	331		else
330	332		{$ENDIF NOT WINCE}
331	333		begin
332	334		SetLength(WS, MaxLen-1);
333	335		Res := Windows.GetUserNameW(@WS[1], Len);
334	336		if Res then
335	337		begin
336	338		SetLength(WS, Len - 1);
337	339		Result := Utf16ToUtf8(WS);
338	340		end
339	341		else
340	342		SetLength(Result,0);
341	343		end;
342	344		{$ENDIF WINDOWS}
343	345		{$IFDEF UNIX}
344	346		{$IF (DEFINED(LINUX)) OR (DEFINED(FREEBSD))}
345	347		Result := SysToUtf8(GetUserName(fpgetuid));
346	348		{$ENDIF}
347	349		if Result = '' then
348	350		Result := GetEnvironmentVariableUTF8('USER'); //fallback or other unixes which export $USER and don't support GetUserName
349	351		{$ENDIF}
350	352		end;
351	353		```
352	354
353	355		## Finding all occurrences of some bytes in a file
354	356
355	357		A sort of grep. From forum post by KpjComp: [1](http://lazarus.freepascal.org/index.php/topic,16574.msg90287.html#msg90287)
356	358
357	359		The block search class:
358	360
359	361		``` pascal
360	362		unit block_search;
361	363
362	364		{$mode objfpc}{$H+}
363	365
364	366		interface
365	367
366	368		uses
367	369		Classes, SysUtils, fgl;
368	370
369	371		type
370	372
371	373		{ TBlockSearch }
372	374		TBlockSearchResults = specialize TFPGList<int64>;
373	375
374	376		TBlockSearch = class
375	377		private
376	378		src:TStream;
377	379		fresults:TBlockSearchResults;
378	380		block:array of byte;
379	381		public
380	382		procedure SearchFor(a:array of byte);
381	383		constructor Create(_Src:TStream; blocksize:integer = 1024*1024);
382	384		destructor Destroy; override;
383	385		property Results:TBlockSearchResults read fResults;
384	386		end;
385	387
386	388		implementation
387	389
388	390		{ TBlockSearch }
389	391
390	392		procedure TBlockSearch.SearchFor(a: array of byte);
391	393		var
392	394		readsize:integer;
393	395		fPos:Int64;
394	396		fifoBuff:array of byte;
395	397		fifoSt,fifoEn,searchLen,lpbyte:integer;
396	398
397	399		//
398	400		procedure CheckPos;
399	401		var
400	402		l,p:integer;
401	403		begin
402	404		p := fifoST;
403	405		for l := 0 to pred(SearchLen) do
404	406		begin
405	407		if a[l] <> fifoBuff[p] then exit;
406	408		//p := (p+1) mod SearchLen, the if seems quicker
407	409		inc(p); if p >= SearchLen then p := 0;
408	410		end;
409	411		fresults.Add(fpos-searchLen);
410	412		end;
411	413		//
412	414		begin
413	415		fresults.clear;
414	416		src.Position:=0;
415	417		readsize := src.Read(block[0],Length(block));
416	418		searchLen := length(a);
417	419		if searchLen > length(block) then
418	420		raise Exception.Create('Search term larger than blocksize');
419	421		if readsize < searchLen then exit;
420	422		setlength(fifoBuff,searchLen);
421	423		move(block[0],fifoBuff[0],searchLen);
422	424		fPos:=0;
423	425		fifoSt:=0;
424	426		fifoEn:=SearchLen-1;
425	427		CheckPos;
426	428		while readsize > 0 do
427	429		begin
428	430		for lpByte := 0 to pred(readsize) do
429	431		begin
430	432		inc(fifoSt); if fifoSt>=SearchLen then fifoST := 0;
431	433		inc(fifoEn); if fifoEn>=SearchLen then fifoEn := 0;
432	434		fifoBuff[fifoEn] := block[lpByte];
433	435		inc(fPos);
434	436		CheckPos;
435	437		end;
436	438		readsize := src.Read(block[0],Length(block));
437	439		end;
438	440		end;
439	441
440	442		constructor TBlockSearch.Create(_Src: TStream; blocksize: integer);
441	443		begin
442	444		inherited Create;
443	445		setlength(block,blocksize);
444	446		src := _src;
445	447		fresults := TBlockSearchResults.Create;
446	448		end;
447	449
448	450		destructor TBlockSearch.Destroy;
449	451		begin
450	452		freeAndNil(fresults);
451	453		inherited Destroy;
452	454		end;
453	455
454	456		end.
455	457		```
456	458
457	459		Example of usage:
458	460
459	461		``` pascal
460	462		var
461	463		bs:TBlockSearch;
462	464		..
463	465		..
464	466		bs := TBlockSearch.Create(SourceFile);
465	467		try
466	468		bs.SearchFor(WhatIAmSearchingFor);
467	469		for i := 0 to bs.results.count-1 do
468	470		begin
469	471		// Example: we need to do something at an offset after the result
470	472		SourceFile.Position := bs.Results.Items[i] + 5;
471	473		SourceFile.ReadBuffer(RecordToParse, SizeOf(RecordToParse));
472	474		// And now I work on the data in the second packed record of arrays and output to memo or whatever
473	475		end;
474	476		finally
475	477		bs.free;
476	478		end;
477	479		```
478	480
479	481		## Search and replace in a file
480	482
481	483		This will search and replace by loading the entire file into the stringlist in memory and replacing there, then saving the stringlist again. While fine for small files, performance will likely suffer for large files.
482	484
483	485		``` pascal
484	486		procedure FindAndReplace(SearchFor, ReplaceWith, FileName: string);
485	487		var
486	488		FileContents: TStringList;
487	489		begin
488	490		FileContents:=TStringList.Create;
489	491		try
490	492		FileContents.LoadFromFile(FileName);
491	493		FileContents.Text:=StringReplace(FileContents.Text, SearchFor, ReplaceWith, [rfReplaceAll,rfIgnoreCase]);
492	494		FileContents.SaveToFile(FileName);
493	495		finally
494	496		FileContents.Free;
495	497		end;
496	498		end;
497	499		```
498	500
499	501		---
500	502		From the Free Pascal wiki, page "Rosetta Stone", as it stood on 2021-11-23 after a change by Trev, 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).
501	503		Category: Code
502	504		Category: Code Snippets
503	505		Category: FPC
504	506		Category: Lazarus
505	507		Category: Rosetta Stone
506	508		Category: Tutorials

Back to history