Honestly, I think you're in denial. The main reason FPC is attractive to some programmers is the existence of Lazarus, not because of the features/abilities of the Pascal language. That is supported by the _fact_ that GNU Pascal is dead. If there had been a Lazarus like environment for GNU Pascal, it _might_ still be alive (FPC is).
Maybe. But I think if the major use case for e.g. Fortran (Math) or Cobol (Banks) would disappear, the same would happen.
The major "use case" of FORTRAN and COBOL are not about to disappear anytime soon. Business applications are needed and so are heavy computational applications. There is no major "use case" (as you put it) for Pascal. The only reason it still has some life is because applications such as Delphi and Lazarus allow some people with very little programming knowledge to write simple programs. Without that crutch Pascal would be gone (as GNU Pascal has already demonstrated.)
As said, I don't believe that. Those languages are just there because they got lucky long ago, and it simply takes a long time to erode. There is nothing to learn there, except getting a niche for yourself.
Unix wasn't written with "luck". It was written in/with C. Also, a language, in this case C, that has roughly 16% of the programmers' mindshare is hardly a "niche" language. Object Pascal at roughly 2% is a niche and one it wouldn't have if it weren't because of the RAD environments that depend on it.
But creating such a niche is more chance than planning, and can't be achieved by merely copying others.
Some luck is involved but, COBOL is a good example of a language whose existence is due to planning and, it was quite effective. As far as the copying you mention, just about every language copies from other languages. The syntax may vary significantly but the programming concepts built into the language, don't.
You make it to tooling centric. It is not about tooling configuration, but about major usecase.
Not for Pascal. It's very likely that the reason Pascal still has a little bit of life is because of the tools that use it, specifically, Delphi and Lazarus. Without them, it's quite likely that it would be shrink-wrapped in a coffin.
For Pascal RAD languages are the main use case, sure.
Pascal isn't a RAD language, not even close but, it has degraded into one which is why I compare it to Clarion and other such environment languages. Pascal's "main use case" is being a language to teach programming and, other choices, such as C are now preferred by most educational institutions.
But the main use cases of Fortran and Cobol have been eroding for decades.
There is some truth to that. COBOL applications area has eroded because of the availability of relational database systems which include very flexible and powerful languages (PL/SQL comes to mind) but, those RDBMs do great when using the database but, far from great when it comes to providing the capabilities of a full fledged programming language.
(I come from organic chemistry, and even in my time, +/- 2000 many computational groups were migrating to C++ for computational work). The fact that you can still write fortran with VI doesn't really save them from that.
IMO, choosing C++ over FORTRAN for computationally intensive programs borders on insanity. The FORTRAN code will be a lot clearer, easier to understand, easier to maintain and much less prone to contain bugs than whatever can be produced in C++ to accomplish the same goal. That said, it is true that C++ has managed to erode some of FORTRAN's territory but, not much.
You are trying to make something out of nothing.
I'm simply trying to show that Pascal has none of the functional advantages other programming languages such as C, FORTRAN and COBOL among others have. Pascal has no clear useful purpose anymore and that is one of the reasons there is no standards body interested in improving it. You may call that "nothing" but without that "nothing", Pascal's future is rather uncertain.
If two out of three of (LLVM,GCC,VS) die, you have probably also a significant drop. Even more so if the rumours are true that VS will change to LLVM. (which I still find a bit odd)
That's like saying that if someone dried the Atlantic ocean there wouldn't be any water in it. In the rather extreme example you offered above, a new C compiler would be written rather quickly. If Pascal disappeared (both FPC and Lazarus) the implementation of a new Pascal compiler is far from certain.
Cutting out the most major players always hurts. For any language.
Cutting out all the "major players" could happen to Pascal but, rather unlikely to happen to C, COBOL and/or Fortran for instance.
If two out of the three major implementations of the C language were to disappear, the most likely result is that a replacement implementation would appear shortly thereafter. That cannot be said about Pascal.
That depends. If they disappear, the related multinationals will probably ALSO migrate to something different (like Rust), severely eroding C's dominance in system programming.
The problem with the obvious fallacy you stated above is that, all that C code isn't going to migrate itself to Rust overnight. Even a company with very large resources that is interested in migrating to Rust will take a very long time to get there and keep depending on C.
It has been eroding and retreating on its old system programming niche for decades now. Application level C has been going only down since 2000, with C++ and C#/Java picking up most of the slack. Even GNU migrated several major codebases (GCC,GDB) to C++.
I've never thought of C as being particularly well suited as an application's programming language. It's about time it would start losing influence in that area. It is losing some terrain in that area because, now there are finally some halfway decent alternatives (though Pascal was a good one but, it was eclipsed by all the shiny razzle-dazzle of RAD environments.)
I think that is a gross oversimplification. If only because those other languages often just tied you to one or two database products.
It's not an oversimplification. It's the same problem as 4GL language have. Pascal got tied to RAD environments, namely Delphi and Lazarus. It lost its self standing, just like a 4GL has no standing without the database(s) they act upon.
Both Windows and Mac OS originally had large portions in Pascal. So this is simply not true.
The Windows version that included Pascal code couldn't be considered an O/S, it could barely show some data in tiled windows. The Mac OS was a _joke_ until Apple finally decided to write something that could legitimately be called an O/S by using the BSD code base. A good portion of the Lisa OS was written in Pascal and the Lisa OS was well known to have some rather significant deficiencies (though, to be fair, a great number of them were not related to its being written in Pascal but, it contributed to showing Pascal as falling short of the mark when it comes to writing an O/S.)
It is just the same inertia, that large bodies of code long ago don't disappear overnight. Sure some maintenance and expansion is done, but IMHO you make that to be much more than it is worth, and deflect criticism on those conclusions with simplistic "but it is still more than Pascal" jabs. Pointless.
Not pointless at all. You are desperately trying to evade the fact that without Delphi and Lazarus (environments for RAD), the Pascal language would probably be dead by now. Unlike Pascal, neither COBOL nor FORTRAN depend on an environment to keep them alive, they stand on their own merits, Pascal did at one time but, not anymore and, that is a very significant problem.
The inertia is what kept the alternatives away, not the features.
We definitely disagree. In spite of the fact that I strongly dislike C, I still use it because there are times when the combination of features it offers makes getting the job done easier in C than in Pascal (and that is _very_ annoying because there is _no_ good reason for Pascal to be missing those features, it is because of people like _you_ who refuse to improve the language.)
The one thing all these discussions have in common is, they lead nowhere and don't produce any desirable results. That may be another reason why there hasn't been a Pascal standard in so many years.
In a software project that involves an important investment in terms of resources, the choice of the programming language and the development environment must ensure a reasonable degree of certainty about the future.
Quite true and, institutions which use C, COBOL or FORTRAN don't have to worry about that. Institutions which use Pascal definitely do.