A r t i c l e s

Note: This Wiki is
outdated, personal views
may have changed.
L505 A.I. bot is dead
long live THX 1138

M a i n P a g e

D i r e c t o r y

FreePascal Compiler Macros

First, the word "macro" is quite an overused term. More specifically, freepascal
offers compiler macros. Or pre-processing. Compiler macros are basically something
that goes in and replaces all instances of a with b.
Let's pretend your name was long and you were sick of typing Larsabulu Olsonabolgus
out every time you had to spell your name. With a macro, you could use the shortform

However, generally this can make code unmaintainable in the long term, if you use too
many macros. That's why Pascal didn't offer it in the first place.. But, macros can
be useful.. and they are not just a toy. They could be useful in situations where
you are creating a new language for example, or a shortform syntax.. or say you are
developing something like a regex language. This is very powerful when you think
of situations where it could be useful.

Example 1: ----------- Some C++ or C programmers will gloat about how they can create Pascal in their C compiler by using some defined macros - by replacing { with begin and } with end. In FreePascal, you can do the following: program Project1; {$mode objfpc}{$H+} {$define b:= begin } //let's define some macros {$define e:= end } {$define proc:= procedure } var iLoc:integer; proc testing1; b for iLoc:= 1 to 6 do writeln('test'); e; b testing1; e. Output: test test test test test test So yes, macros not only apply to your code inside your statements, but also the syntax like begin, end, procedure, etc.
Example 2: ----------- program Project1; {$mode objfpc}{$H+} {$define Z:= begin } {$define X:= end } {$define Y:= procedure } {$define A:= for } {$define B:= to } {$define C:= do } {$define D:= writeln } {$define E:= var } {$define F:= := } {$define G:= : } {$define H:= ; } {$define I:= . } {$define J:= integer } {$define K:= iLoc } {$define L:= testing1 } e k g j h Y l h Z a k f 1 b 6 c d('test') h X h Z l h X I Output: test test test test test test
So how does a Pascal programmer make his program look like C code? Well, I haven't figured out that yet, and I care not to spend too much time doing that.. but basically the initial problem is that { is for comments in Pascal and {$define {:= begin } //this works {$define }:= end } //this doesn't work {$define ":= ' } //this doesn't work So, I'm not too sure how you'd do it.. maybe it's not possible yet. But I really don't care, I am more interested in other things, because I find parenthesis is hard to see on my screen. So I wouldn't use that anyway. A new Pascal short-syntax language, maybe could be a useful example of macros. Macros can help when you just want to throw together some ideas for a new language. Other uses will be for those people who really do complain about the verbosity of Pascal.. You can always use b in place of begin, and e in place of end, if you really are that worried (as in example 1). I think it allows you to think up and experiment with possible short form languages for the future.. without you ever having any knowledge of YACC or tokens, or advanced language parsing. It let's you quickly use an existing compiler that is already working, with a new syntax. Another idea would be small Pascal-scripts who are compiled on the fly with PPC386 or FPC. Imagine having something like microsoft's VBA available in your applications. Just ship the Pascal compiler with your applications, and you could have a huge power available to you. If you used a shortform Pascal syntax with a DEFINE file, and included this define file in every script that people compiled you wouldn't need to write a new compiler or interpreter. Just ship the Pascal compiler with your application.. and set up the compiler to use a DEFINE file, invisible to your users. In Example 1, that is a very small and short "script" that a user could write, like a VBA macro. I know that you are thinking "yah, but what's the point?". Remember, there ARE situations like VBA or regexes where shortform is GOOD. We're not changing the Pascal language.. we're just offering a shortform syntax for those situations where it is actually useful (in Excel, it is useful.. in regexes, it is useful.. in Application development and Application design.. it is not useful. You just have to separate useful from useless). Make all the DEFINE's invisible to the user, and now the user has a very short and fast syntax that he could use to compile mini programs. These mini programs could interact with your software application like a VBA. They could either be an on the fly SO or DLL, or an on the fly Exe/ELF. Think about all the work you would have to do to make your own compiler for your mini-scripting language.. OR you could just reuse the freepascal compiler! --L505
Taken from a mailing I sent to the freepascal newsgroups: "You could actually make something useful out of this, if the defines were thought out properly, and the situation fit the need. There are those situations where regex's come handy because they are quick and dirty, and they work in real time environments when you just don't have time to write a real search and replace algorithm. In text editors for example, or in web applications.. people do in fact use regexes. Non-programmers do to. In Excel spreadsheet, people use a shortform language basically... because who has time to write an entire program, just to get data out of Cell A1 and Cell A2? In Excel, =A1&A2 is basically just a shortform for the programming language behind the scenes, if you think about it We might even be able to turn the whole Pascal language into one regex-like looking thing, or Excel-like looking thing, as just purely an OPTION for those times when you need quick syntax. So people could write PascalEx's or PasExcels instead of regexes. Particularly if some standards were set. We can't have each person writing their own define macros.. but if we had some standards.. and some standard Define files which people could download... Don't laugh at it all though..... I use regexes, and they are useful.. I'm serious about this. It's just a matter of figuring out -where- this situation could be most useful. Someone found a useful situation for regexes, and they work. Someone found a useful situation for Excel language, and it worked. But surely there are other situations.. Sometimes I find that regexes limit me in some ways or that regex's are not the answer for some problems... or that regexes are way too slow. Maybe there is an opportunity in those particular cases. Or maybe a solution which has nothing to do with search and replace. Remember, someone might have laughed at regexes too, when they were first thought up. Another idea would be to allow users to make Rapid plugins for your application. Using a shortform syntax, users would be more inclined to write a DLL or .SO plugin for your applications (think like total commander plug-ins). I know larger plugins for applications require time and thinking. so the syntax is really not an issue. But for those situations where you are writing a small plug in for the application, something like a regex syntax might be useful. Remember, in Excel, no one wants to write an entire begin/end program just to get A1 Cell data into B2 Cell data. Since the Pascal compiler is so fast, you could pretty much pretend you were writing a script for your program.. then have the program save your so called script. (think like Microsoft's VBA). Instead of using Java or something, or VBA, you'd just compile your so called "scripts" with the Pascal compiler.. on the fly. Once they were compiled, they'd be "saved" as a "recordable macro script" (think like VBA scripts)."

Note: This Wiki is outdated, personal views may have changed.

This wiki contains info on life, health, humans, nature, programming, database, fads, paradigms, poems, principles, theories.

Articles may contain statements which some may find helpful and encouraging, or even discouraging.

Beware, I believe in the Grand Justice system.
_ _ _