shithub: scc

--- a/README

+++ b/README

@@ -1,4 +1,4 @@

-Derivations from standard C

+Deviations from standard C

 ===========================

 This compiler aims to be fully compatible with the C99 standard, but

 it will have some differences:

@@ -6,7 +6,7 @@

 - Type qualifiers are accepted but ignored.

   -----------------------------------------

-Type qualifers make the type system ugly, and their uselessness add

+Type qualifiers make the type system ugly, and their uselessness adds

 unnecessary complexity to the compiler (and increased compilation time):

 	- const: The definition of const is not clear in the standard.

 	  If a const value is modified the behaviour is undefined

@@ -22,15 +22,15 @@

 	  or variables whose values are modified asynchronously. This can

 	  be achieved with special pragma values though.

 	  In the first case, it generates a lot of problems with modern

-	  processors and multithreading, where not holding the value in a

+	  processors and multithreading, when not holding the value in a

 	  register is not good enough (an explicit memory barrier is needed).

 	  In the second case, this is non-portable code by definition

 	  (depending on the register mapped), so it is better to deal with

 	  it using another solution (compiler extensions or direct

-	  assembler).

+	  assembly).

-	- restrict: This qualifer can only be applied to pointers to

-	  mark that the pointed object has no other alias. This qualifer

+	- restrict: This qualifier can only be applied to pointers to

+	  mark that the pointed object has no other alias. This qualifier

 	  was introduced to be able to fix some performance problems in

 	  numerical algorithms, where FORTRAN could achieve a better

 	  performance (and in fact even with this specifier FORTRAN has a

@@ -46,7 +46,7 @@

 int f(int (int));

-Accepting function types in typenames (or abstract declarators) makes the

+Accepting function types in type names (or abstract declarators) makes the

 grammar ambiguous because it is impossible to differentiate between:

         (int (f))  -> function returning int with one parameter of type f

@@ -76,7 +76,7 @@

 C89 allows the definition of variables with incomplete type that

 have external linkage and file scope. The type of the variable

 is the composition of all the definitions find in the file. The exact

-rules are a bit complex (3.7.2), and SCC ignores  them at this moment

+rules are a bit complex (3.7.2) so SCC ignores them at this moment

 and it does not allow any definition of variables with incomplete type.

 If you don't believe me try this code: