Should compilers follow the defined language standard?

Question

Why do some compilers violate the defined language standard?

I don't understand, in ISO/IEC 10206:1990 Extended Pascal standard on 6.8.3.2 Arithmetic operators section, Page 86.

It says that,

A term of the form i mod j shall be an error if j is zero or negative ; otherwise, the value of i mod j shall be that value of (i-(k*j)) for integral k such that 0 < = i mod j < j.

But, when I try in free pascal compiler 3.0,

writeln(-5 mod 3);

It produces a negative number "-2" instead of "1", and

writeln(5 mod -3);

Should be error according to the standard,
but what I found is not.

---

For example, if there is a question

"In C++, why does the -5 % 3 produce -2 instead of 1, isn't it modulo operator?"

I should answer

That's because in C++14 standard on Page 124, 5.6 Multiplicative operators, no. 4
It says that "(a/b)*b + a%b is equal to a"
Therefore, it is not a modulo operator, it is a remainder operator

But If there is a question,

"In Pascal, why does the -5 mod 3 produce -2 instead of 1, isn't it modulo operator?"

Should the answer be like this?

In general, it depends on the compilers that you are using, because according to the ISO/IEC 10206:1990 Extended Pascal standard, it should be 1, while on a modern compilers like fpc or gpc,
it produces -2

What would be the most appropriate answer to the modulo operator question above?

Answer 1

The point is : what does "error" means in that particular standard. It might be explained in some introduction or glossary. Perhaps it is close to undefined behavior (and the implementation can do whatever is simpler for it). The standard that you are mentioning says:

3.2 Error

A violation by a program of the requirements of this International Standard that a processor is permitted to leave undetected.

^{(the italics emphasis is mine, so the behavior you are observing is conformant to the specification)}

Some programming languages specifications mention undefined behavior or unspecified behavior. The (conforming) implementation is then allowed to do whatever is suitable (for undefined behavior it can be really bad things, read Lattner's blog What every C programmer should know about undefined behavior)

Should the compilers follow the the defined language standard?

Some compilers explicitly have (and document) extensions to the languages they are implementing. GCC has useful extensions to C, notably labels as values (with computed gotos) and statements exprs, and both are also supported by Clang/LLVM.

^{(I guess that the reasons why such commonly provided extensions have not been pushed into the standards is for social or economical reasons, not technical ones; contributing to a standard is quite expensive)}

Answer 2

Pascal has a long history of non-compliant implementations. This is probably because the peak of the language's popularity occurred between the first standardized version (ANSI Pascal, 1983) and the more recent 'extended' pascal you site (1990) -- during this time period Borland Turbo Pascal was created and became the de facto standard for most Pascal implementations. Borland never really bothered with compliance with the earlier standard; if they felt there was a better way of doing something, they went ahead and did it. Therefore, there is a long list of deviations between Turbo Pascal and the ANSI standard.

The Extended Pascal standard was based on the ANSI standard, but a large proportion of modern Pascal implementations (including Free Pascal) are explicitly designed to be compatible with Turbo Pascal, so deviate from the standard in similar ways.

If you're looking for a more standard compliant compiler, I believe the GNU Pascal Compiler is closer to the standard behaviour (or at least it was when I used it in the mid-90s).

Answer 3

Extended Pascal is hardly implemented by anybody, and is newer than the defacto standards (read: Turbo Pascal) actually implement.

Those compilers chose compatibility with the implementation dialects they implemented (Turbo Pascal 1983) before the standard was formed(1985, 1990 extended pascal). Admittedly, Turbo Pascal, and Delphi are quite often just implementations retrodeclared as compatibility standard.

Partially also because there was no real driving force to adapt the standards, and the standards were not very pragmatic somewhat removed from the major every day dialects used in production. (e.g. why not adopt the Turbo Pascal unitsystem syntax instead of using the more M2 like "module") syntax?

Turbo Pascal was one of the major compilers of the dos era, and the standards ignoring that fact didn't help.

C/C++ is an exception there, because Unix API and software being implemented in it (though even there non Unix C/C++ compilers like BCB and MSVC and embedded C compilers were notoriously slow in adopting the newer standards like e.g. C99. Moreover, Unix apps were much more likely to be distributed in source than in other markets) In reality, few languages have a large number of compilers competing in the same market. And it is exactly that what the C/C++ standards tried to harmonize.