In general, this is delegated to your coding style, although it is possible to build a custom compiler that leaves out certain features that you mention, like exceptions, floating point support, C style PChar handling and many more.
The compiler has many conditional defines that - by advanced users - can be used to achieve several of your concerns to be eliminated from accepted syntax. (Look at e.g. the HAS_FEATURE_XXX defines in the compiler sources)
There are also some features in Freepascal that can't be omitted because they are essential to the language, one of which is implicit heap management. But because of the way native pascal types work - very strongly typed - this is much less of an issue.
By rebuilding the compiler and the rtl with some features omitted you can come a long way, but not quite as ADA can.
I did some experiments stripping down the compiler in the past to look what is possible. (A good guidance are some of the embedded platforms.)
So: in general the answer is NO, unless you build the compiler with custom defines and make it drop support.
In my experiments I was never able to completely eliminate pointer support in the language - it is necessary in the compiler itself, though, just like in Adacompilers -, but that may very well be my own limitation.
But drop exception support and drop FPU support is actually not that difficult and the compiler has defines (not public defines after build) for that. It is compiler build space, not user space.
A lot of the concerns are simply not applicable when only Pascal types are used. Hence NIST qualifies Pascal as a safe language.
Actually, mentioned experiments were geared towards eliminating C style language pollution.
Whereas some of your concerns focus on heap management, actually stack management it technically far more dangerous.
And it is there that Pascal shines.
Note that adapting the compiler as such is not enough: you have to build an RTL that only supports the features of your custom build.
[edit]To a certain extend, some "features" can be dropped by macro's.
All said: you know that Ada compilers for exceptionally critical applications are also always custom builds. (The NATO compilers for example)
That is because such critical code should not be left to the use of conditionals by the programmer: you can't allow a stock compiler.
If you see Adacompiler sources, this is actually encouraged.
Finally: some compiler modes are inheritedly safer than others, like both ISO modes.
But these require a mind set that is not common to most current Pascal programmers.
Recent
