Changeset 7d95bce9 for doc/theses/mike_brooks_MMath/background.tex

Timestamp:

Nov 4, 2024, 12:21:11 PM (9 days ago)

Author:

Michael Brooks <mlbrooks@…>

Branches:

master

Children:

97ac01d3

Parents:

c3e41cda

Message:

Thesis, background, array: clarify C laxed inner dimension checking

File:

• doc/theses/mike_brooks_MMath/background.tex (modified) (1 diff)

doc/theses/mike_brooks_MMath/background.tex

@@ -685 +685 @@
 Here, the distance between the first and second elements of each array depends on the inner dimension size.
 
-The last observation is a fact of the callee's perspective.
-There is little type-system checking, in the caller's perspective, that what is being passed, matches.
-\PAB{I do not understand}
-\begin{cfa}
-void f( float [][10] );
-int n = 100;
-float a[100], b[n];
-f(&a); // reject
-f(&b); // accept
-
+This significance of an inner dimension's length is a fact of the callee's perspective.
+In the caller's perspective, the type sytem is quite lax.
+Here, there is (some, but) little checking that what is being passed, matches.
+% void f( float [][10] );
+% int n = 100;
+% float a[100], b[n];
+% f(&a); // reject
+% f(&b); // accept
+\begin{cfa}
 void foo() {
         void f( float [][10] );
         int n = 100;
         float a[100], b[3][12], c[n], d[n][n];
-        f( a );    // reject
-        f( b );    // reject
-        f( c );    // reject
-        f( d );    // accept
-        f( &a );   // reject
-        f( &b );   // reject
-        f( &c );   // accept
-        f( &d );   // reject
+        f( a );
+        f( b );    $\C{// reject: inner dimension 12 for 10}$
+        f( c );
+        f( @d@ );  $\C{// accept with inner dimension n for 10}$
+        f( &a );   $\C{// reject: inner dimension 100 for 10}$
+        f( &b );
+        f( @&c@ ); $\C{// accept with inner dimension n for 10}$
+        f( &d );
 }
 \end{cfa}
-This size is therefore, a callee's assumption.
+The cases without comments are rejections, but simply because the array ranks do not match; in the commented cases, the ranks match and the rules being discussed apply.
+The cases @f(b)@ and @f(&a)@ show where some length checking occurs.
+But this checking misses the cases @f(d)@ and @f(&c)@, allowing the calls with mismatched lengths, actually 100 for 10.
+The C checking rule avoids false alarms, at the expense of safety, by allowing any combinations that involve dynamic values.
+Ultimately, an inner dimension's size is a callee's \emph{assumption} because the type system uses declaration details in the callee's perspective that it does not enforce in the caller's perspective.
 
 Finally, to handle higher-dimensional VLAs, C repurposed the @*@ \emph{within} the dimension in a declaration to mean that the callee has make an assumption about the size, but no (unchecked, possibly wrong) information about this assumption is included for the caller-programmer's benefit/over-confidence.