rebase

Author: andralex

abi.dd

@@ -89,7 +89,7 @@ $(TROW $(I ptrsize)..., $(NBSP), $(ARGS vptr's for any interfaces implemented by
 
 $(TABLE2 Virtual Function Pointer Table Layout,
 $(THEAD size, contents)
-$(TROW $(I ptrsize), pointer to instance of $(V1 ClassInfo)$(V2 TypeInfo))
+$(TROW $(I ptrsize), pointer to instance of TypeInfo)
 $(TROW $(I ptrsize)..., pointers to virtual member functions)
 )
 
@@ -152,12 +152,11 @@ $(SECTION3 Interfaces,
 	that they were declared.
 	This matches the COM object layout used by Windows.
 	)
-    $(V2
-	$(P A C++ interface differs from a regular interface in that
+    	$(P A C++ interface differs from a regular interface in that
 	it matches the layout of a C++ class using single inheritance
 	on the target machine.
 	)
-    )
+
 )
 
 $(SECTION3 Arrays,
@@ -192,10 +191,9 @@ $(SECTION3 Associative Arrays,
 
 	$(P Associative arrays consist of a pointer to an opaque, implementation
 	defined type.
-	$(V1 The current implementation is contained in and defined by
-	 $(PHOBOSSRC internal/aaA.d).)
-	$(V2 The current implementation is contained in and defined by
-	 $(DRUNTIMESRC rt/aaA.d).)
+
+	The current implementation is contained in and defined by
+	 $(DRUNTIMESRC rt/aaA.d).
 	)
 )
 
@@ -454,7 +452,7 @@ $(I TypePointer):
     $(B P) $(I Type)
 
 $(I TypeFunction):
-    $(I CallConvention) $(V2 $(I FuncAttrs) )$(I Arguments) $(I ArgClose) $(I Type)
+    $(I CallConvention) $(I FuncAttrs) $(I Arguments) $(I ArgClose) $(I Type)
 
 $(I CallConvention):
     $(B F)       $(GREEN // D)
@@ -463,7 +461,7 @@ $(I CallConvention):
     $(B V)       $(GREEN // Pascal)
     $(B R)       $(GREEN // C++)
 
-$(V2 $(I FuncAttrs):
+$(I FuncAttrs):
     $(I FuncAttr)
     $(I FuncAttr) $(I FuncAttrs)
 
@@ -493,19 +491,18 @@ $(I FuncAttrTrusted):
 
 $(I FuncAttrSafe):
     $(B Nf)
-)
+
 
 $(I Arguments):
     $(I Argument)
     $(I Argument) $(I Arguments)
 
 $(I Argument:)
-$(V2
     $(I Argument2)
     $(B M) $(I Argument2)     $(GREEN // scope)
 
 $(I Argument2:)
-)    $(I Type)
+    $(I Type)
     $(B J) $(I Type)     $(GREEN // out)
     $(B K) $(I Type)     $(GREEN // ref)
     $(B L) $(I Type)     $(GREEN // lazy)
@@ -660,7 +657,7 @@ $(SECTION4 Return Value,
 
 	$(LI Associative arrays are returned in EAX.)
 
-	$(V2 $(LI References are returned as pointers in EAX.))
+	$(LI References are returned as pointers in EAX.)
 
 	$(LI Delegates are returned with the pointer to the function
 	in EDX and the context pointer in EAX.)

arrays.dd

@@ -49,18 +49,12 @@ int[3] s;
         a template expansion.
         )
 
-$(V1
-        $(P Static arrays are value types, but as in C
-        static arrays are passed to functions by reference
-        and cannot be returned from functions.
-        )
-)
-$(V2
+
         $(P Static arrays are value types. Unlike in C and D version 1,
         static arrays are passed to functions by value.
         Static arrays can also be returned by functions.
         )
-)
+
 
 $(H4 $(LNAME2 dynamic-arrays, Dynamic Arrays))
 
@@ -418,19 +412,12 @@ double matrix[3,3];
 
 $(H3 $(LNAME2 array-length, Array Length))
 
-$(V1
-        $(P Within the [ ] of a static or a dynamic array,
-        the variable $(D length)
-        is implicitly declared and set to the length of the array.
-        The symbol $(D $) can also be so used.
-        )
-)
-$(V2
+
         $(P Within the [ ] of a static or a dynamic array,
         the symbol $(D $)
         represents the length of the array.
         )
-)
+
 
 ---------
 int[4] foo;
@@ -440,21 +427,14 @@ int*   p = &foo[0];
 // These expressions are equivalent:
 bar[]
 bar[0 .. 4]
-$(V1 bar[0 .. length]
-)bar[0 .. $]
+bar[0 .. $]
 bar[0 .. bar.length]
 
-$(V1 p[0 .. length]         // 'length' is not defined, since p is not an array
-bar[0]+length       // 'length' is not defined, out of scope of [ ]
 
-bar[length-1]  // retrieves last element of the array
-)
-$(V2
-p[0 .. $]  // '$' is not defined, since p is not an array
-bar[0]+$   // '$' is not defined, out of scope of [ ]
+p[0 .. $]      // '$' is not defined, since p is not an array
+bar[0]+$            // '$' is not defined, out of scope of [ ]
 
-bar[$-1]   // retrieves last element of the array
-)
+bar[$-1] // retrieves last element of the array
 ---------
 
 $(H3 $(LNAME2 array-properties, Array Properties))
@@ -464,20 +444,19 @@ $(H3 $(LNAME2 array-properties, Array Properties))
     $(TABLE_2COLS Static Array Properties,
         $(THEAD Property, Description)
         $(TROW  $(D .init),
-$(V1 returns the default initializer for the element type.)
-$(V2 Returns an array literal with each element of the literal being the $(D .init) property of the array element type.))
+Returns an array literal with each element of the literal being the $(D .init) property of the array element type.)
         $(TROW $(D .sizeof), Returns the array length multiplied by
         the number of bytes per array element.)
         $(TROW $(D .length), Returns the number of elements in the array.
         This is a fixed quantity for static arrays. It is of type $(D size_t).)
         $(TROW $(D .ptr), Returns a pointer to the first element of the array.)
         $(TROW $(D .dup), Create a dynamic array of the same size and copy the contents of the array into it.)
-        $(TROW $(D .idup), Create a dynamic array of the same size and copy the contents of the array into it.
-        The copy is typed as being immutable. $(I D 2.0 only))
+        $(TROW $(D .idup), Create a dynamic array of the same size and copy the contents of the array into it. The copy is typed as being immutable.)
         $(TROW $(D .reverse), Reverses in place the order of the elements in the array.
         Returns the array.)
         $(TROW $(D .sort), Sorts in place the order of the elements in
-        the array. Returns the array.))
+        the array. Returns the array.)
+        )
 
         $(P Dynamic array properties are:)
 
@@ -508,13 +487,9 @@ $(V2 Returns an array literal with each element of the literal being the $(D .in
         $(P For the $(D .sort) property to work on arrays of
         structs or unions, the struct or union definition must
         define the function:
-$(V1
-        $(D int opCmp(S)) or
-        $(D int opCmp(S*)).
-)
-$(V2
+
         $(D int opCmp(ref const S) const).
-)
+
         The type $(D S) is the type of the struct or union.
         This function will determine the sort ordering.
         )
@@ -562,40 +537,14 @@ array = array[0..7];
 
         $(P To maximize efficiency, the runtime always tries to resize the
         array in place to avoid extra copying.
-        $(V1 It will always do a copy if the new size is larger and the array
-        was not allocated via the new operator or a previous resize operation.)
-        $(V2 It will always do a copy if the new size is larger and the array
+
+        It will always do a copy if the new size is larger and the array
         was not allocated via the new operator or resizing in place would
-        overwrite valid data in the array.)
+        overwrite valid data in the array.
         )
 
-$(V1    $(P This means that if there is an array slice immediately following the
-        array being resized, the resized array could overlap the slice; i.e.:
-        )
 
----------
-char[] a = new char[20];
-char[] b = a[0..10];
-char[] c = a[10..20];
 
-b.length = 15; // always resized in place because it is sliced
-               // from a[] which has enough memory for 15 chars
-b[11] = 'x';   // a[11] and c[1] are also affected
-
-a.length = 1;
-a.length = 20; // no net change to memory layout
-
-c.length = 12; // always does a copy because c[] is not at the
-               // start of a gc allocation block
-c[5] = 'y';    // does not affect contents of a[] or b[]
-
-a.length = 25; // may or may not do a copy
-a[3] = 'z';    // may or may not affect b[3] which still overlaps
-               // the old a[3]
----------
-)
-
-$(V2
         For example:
 
 ---------
@@ -623,12 +572,12 @@ a.length = 25; // This always reallocates because if c extended in place,
                // which will still be true for a.
 a[15] = 'z';   // does not affect c, because either a or c has reallocated.
 ---------
-)
+
 
         $(P To guarantee copying behavior, use the .dup property to ensure
-        a unique array that can be resized. $(V2 Also, one may use the phobos
+        a unique array that can be resized. Also, one may use the phobos
         $(D .capacity) property to determine how many elements can be appended
-        to the array without reallocating.)
+        to the array without reallocating.
         )
 
         $(P These issues also apply to appending arrays with the ~= operator.
@@ -646,7 +595,7 @@ while (1) {
   c = getinput();
   if (!c)
     break;
-  $(V2 ++array.length;)$(V1 array.length = array.length + 1;)
+  ++array.length;
   array[array.length - 1] = c;
 }
 ---------
@@ -663,7 +612,7 @@ for (i = 0; ; i++) {
   if (!c)
     break;
   if (i == array.length)
-    $(V2 array.length *= 2;)$(V1 array.length = array.length * 2;)
+    array.length *= 2;
   array[i] = c;
 }
 array.length = i;
@@ -675,8 +624,8 @@ array.length = i;
         input from the console - it's unlikely to be longer than 80.
         )
 
-        $(V2 $(P Also, you may wish to utilize the phobos $(D reserve)
-        function to pre-allocate array data to use with the append operator.))
+        $(P Also, you may wish to utilize the phobos $(D reserve)
+        function to pre-allocate array data to use with the append operator.)
 
 $(H4 $(LNAME2 func-as-property, Functions as Array Properties))
 
@@ -696,7 +645,7 @@ $(H3 $(LNAME2 bounds, Array Bounds Checking))
 
         $(P It is an error to index an array with an index that is less than
         0 or greater than or equal to the array length. If an index is
-        out of bounds, $(V1 an ArrayBoundsError)$(V2 a RangeError) exception is
+        out of bounds, a RangeError exception is
         raised if detected at runtime, and an error if detected at compile
         time.  A program may not rely on array bounds checking happening, for
         example, the following program is incorrect:
@@ -796,23 +745,7 @@ $(H4 $(LNAME2 strings, Strings))
         String literals are immutable (read only).
         )
 
-$(V1
----------
-char[] str;
-char[] str1 = "abc";
-str[0] = 'b';  // error, "abc" is read only, may crash
----------
-
-        $(P The name $(CODE string) is aliased to $(CODE char[]),
-        so the above declarations could be equivalently written as:
-        )
 
----------
-string str;
-string str1 = "abc";
----------
-)
-$(V2
 ---------
 char[] str1 = "abc";                // error, "abc" is not mutable
 char[] str2 = "abc".dup;            // ok, make mutable copy
@@ -831,7 +764,7 @@ string str3 = "abc";     // ok
 string str4 = str1;      // error, str4 is not mutable
 string str5 = str1.idup; // ok, make immutable copy
 ---------
-)
+
         $(P $(CODE char[]) strings are in UTF-8 format.
         $(CODE wchar[]) strings are in UTF-16 format.
         $(CODE dchar[]) strings are in UTF-32 format.
@@ -882,14 +815,10 @@ str ~= "\0";
         )
 
 ---------
-$(V1
-cast(wchar [])"abc" // this is an array of wchar characters
-"abc"w              // so is this
-)
-$(V2
+
 cast(immutable(wchar) [])"abc" // this is an array of wchar characters
 "abc"w                         // so is this
-)
+
 ---------
 
         $(P String literals that do not have a postfix character and that
@@ -976,8 +905,8 @@ $(H4 $(LNAME2 implicit-conversions, Implicit Conversions))
 
         $(UL
         $(LI $(D T[]))
-        $(V1 $(LI $(D U[])))
-        $(V2 $(LI $(D const(U)[])))
+
+        $(LI $(D const(U)[]))
         $(LI $(D void[]))
         )
 
@@ -986,8 +915,8 @@ $(H4 $(LNAME2 implicit-conversions, Implicit Conversions))
         )
 
         $(UL
-        $(V1 $(LI $(D U[])))
-        $(V2 $(LI $(D const(U)[])))
+
+        $(LI $(D const(U)[]))
         $(LI $(D void[]))
         )