Changeset 0111dc7 for doc/rob_thesis/ctordtor.tex

Timestamp:

Apr 13, 2017, 8:29:38 PM (6 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

1a16e9d

Parents:

c87eb50

Message:

penultimate thesis draft

File:

• doc/rob_thesis/ctordtor.tex (modified) (6 diffs)

doc/rob_thesis/ctordtor.tex

@@ -291 +291 @@
 struct X *_tmp_ctor;
 struct X *x = ?{}(  // construct result of malloc
-  _tmp_ctor=malloc_T(sizeof(struct X), _Alignof(struct X)), // store result of malloc
+  _tmp_ctor=malloc_T( // store result of malloc
+    sizeof(struct X),
+    _Alignof(struct X)
+  ),
   1.5
 ), _tmp_ctor; // produce constructed result of malloc
@@ -500 +503 @@
   S s0, s1 = { 0 }, s2 = { 0, 2 }, s3 = s2;  // okay
   {
-    void ?{}(S * s, int i) { s->x = i*2; } // locally hide autogen constructors
+    void ?{}(S * s, int i) { s->x = i*2; } // locally hide autogen ctors
     S s4;  // error, no default constructor
     S s5 = { 3 };  // okay, local constructor
@@ -577 +580 @@
 As a result, it was decided that any attempt to resolve designated function calls with C's function prototype rules would be brittle, and thus it is not sensible to allow designations in constructor calls.
 
+\begin{sloppypar}
 In addition, constructor calls do not support unnamed nesting.
 \begin{cfacode}
@@ -594 +598 @@
 That is, in the previous example the line marked as an error could mean construct using @?{}(A *, B)@ or with @?{}(A *, C)@, since the inner initializer @{ 10 }@ could be taken as an intermediate object of type @B@ or @C@.
 In practice, however, there could be many objects that can be constructed from a given @int@ (or, indeed, any arbitrary parameter list), and thus a complete solution to this problem would require fully exploring all possibilities.
+\end{sloppypar}
 
 More precisely, constructor calls cannot have a nesting depth greater than the number of array dimensions in the type of the initialized object, plus one.
@@ -877 +882 @@
 This means that in general, function signatures would have to be rewritten, and in a select few cases the signatures would not be rewritten.
 \begin{cfacode}
-__attribute__((manageable)) struct A { ... };   // can declare constructors
-__attribute__((unmanageable)) struct B { ... }; // cannot declare constructors
-struct C { ... };                               // can declare constructors
+__attribute__((manageable)) struct A { ... };   // can declare ctors
+__attribute__((unmanageable)) struct B { ... }; // cannot declare ctors
+struct C { ... };                               // can declare ctors
 
 A f();  // rewritten void f(A *);
@@ -889 +894 @@
 Furthermore, no restrictions would need to be placed on whether objects can be constructed.
 \begin{cfacode}
-__attribute__((identifiable)) struct A { ... };  // can declare constructors
-struct B { ... };                                // can declare constructors
+__attribute__((identifiable)) struct A { ... };  // can declare ctors
+struct B { ... };                                // can declare ctors
 
 A f();  // rewritten void f(A *);