mirrors/phobos
1
0
Fork 0
mirror of https://github.com/dlang/phobos.git synced 2025-04-30 15:10:46 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #3768 from CyberShadow/pull-20151024-051829

Browse source 
HTML fixes
This commit is contained in:
Walter Bright 2015-10-24 15:05:00 -07:00
commit cf22992cbb
19 changed files with 269 additions and 267 deletions
Download patch file Download diff file Expand all files Collapse all files

6
etc/c/curl.d
View file

@ -713,8 +713,8 @@ enum CURLOPTTYPE_FUNCTIONPOINT = 20000;
/// ditto /// ditto
enum CURLOPTTYPE_OFF_T = 30000; enum CURLOPTTYPE_OFF_T = 30000;
/** name is uppercase CURLOPT_<name>, /** name is uppercase CURLOPT_$(LT)name$(GT),
type is one of the defined CURLOPTTYPE_<type> type is one of the defined CURLOPTTYPE_$(LT)type$(GT)
number is unique identifier */ number is unique identifier */
/** The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */ /** The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */
@ -1155,7 +1155,7 @@ enum CurlOption {
opensocketdata = 10164, /// ditto opensocketdata = 10164, /// ditto
/** POST volatile input fields. */ /** POST volatile input fields. */
copypostfields, copypostfields,
/** set transfer mode (;type=<a|i>) when doing FTP via an HTTP proxy */ /** set transfer mode (;type=$(LT)a|i$(GT)) when doing FTP via an HTTP proxy */
proxy_transfer_mode = 166, proxy_transfer_mode = 166,
/** Callback function for seeking in the input stream */ /** Callback function for seeking in the input stream */
seekfunction = 20167, seekfunction = 20167,

2
etc/c/sqlite3.d
View file

@ -1858,7 +1858,7 @@ enum
** Register a geometry callback named zGeom that can be used as part of an ** Register a geometry callback named zGeom that can be used as part of an
** R-Tree geometry query as follows: ** R-Tree geometry query as follows:
** **
** SELECT ... FROM <rtree> WHERE <rtree col> MATCH $zGeom(... params ...) ** SELECT ... FROM $(LT)rtree$(GT) WHERE $(LT)rtree col$(GT) MATCH $zGeom(... params ...)
*/ */
int sqlite3_rtree_geometry_callback( int sqlite3_rtree_geometry_callback(
sqlite3 *db, sqlite3 *db,

14
std/datetime.d
View file

@ -28047,9 +28047,9 @@ private:
Note: Note:
Unless your system's local time zone deals with leap seconds (which is Unless your system's local time zone deals with leap seconds (which is
highly unlikely), then the only way to get a time zone which highly unlikely), then the only way to get a time zone which
takes leap seconds into account is to use $(LREF PosixTimeZone) with a takes leap seconds into account is to use $(D PosixTimeZone) with a
time zone whose name starts with "right/". Those time zone files do time zone whose name starts with "right/". Those time zone files do
include leap seconds, and $(LREF PosixTimeZone) will take them into account include leap seconds, and $(D PosixTimeZone) will take them into account
(though posix systems which use a "right/" time zone as their local time (though posix systems which use a "right/" time zone as their local time
zone will $(I not) take leap seconds into account even though they're zone will $(I not) take leap seconds into account even though they're
in the file). in the file).
@ -28872,17 +28872,17 @@ version(StdDdoc)
occur (especially for historical dates). Also, the TZ Database files occur (especially for historical dates). Also, the TZ Database files
include far more time zones than Windows does. So, for accurate include far more time zones than Windows does. So, for accurate
time zone information, use the TZ Database files with time zone information, use the TZ Database files with
$(LREF PosixTimeZone) rather than $(LREF WindowsTimeZone). However, because $(LREF PosixTimeZone) rather than $(D WindowsTimeZone). However, because
$(LREF WindowsTimeZone) uses Windows system calls to deal with the time, $(D WindowsTimeZone) uses Windows system calls to deal with the time,
it's far more likely to match the behavior of other Windows programs. it's far more likely to match the behavior of other Windows programs.
Be aware of the differences when selecting a method. Be aware of the differences when selecting a method.
$(LREF WindowsTimeZone) does not exist on Posix systems. $(D WindowsTimeZone) does not exist on Posix systems.
To get a $(LREF WindowsTimeZone), either call To get a $(D WindowsTimeZone), either call
$(D WindowsTimeZone.getTimeZone) or call $(D TimeZone.getTimeZone) $(D WindowsTimeZone.getTimeZone) or call $(D TimeZone.getTimeZone)
(which will give a $(LREF PosixTimeZone) on Posix systems and a (which will give a $(LREF PosixTimeZone) on Posix systems and a
$(LREF WindowsTimeZone) on Windows systems). $(D WindowsTimeZone) on Windows systems).
See_Also: See_Also:
$(WEB www.iana.org/time-zones, Home of the TZ Database files) $(WEB www.iana.org/time-zones, Home of the TZ Database files)

6
std/experimental/allocator/building_blocks/package.d
View file

@ -283,10 +283,10 @@ Macros:
MYREF = $(LINK2 std_experimental_allocator_building_blocks_$2.html, $1)&nbsp; MYREF = $(LINK2 std_experimental_allocator_building_blocks_$2.html, $1)&nbsp;
MYREF2 = $(LINK2 std_experimental_allocator_building_blocks_$2.html#$1, $1)&nbsp; MYREF2 = $(LINK2 std_experimental_allocator_building_blocks_$2.html#$1, $1)&nbsp;
MYREF3 = $(LINK2 std_experimental_allocator_$2.html#$1, $1)&nbsp; MYREF3 = $(LINK2 std_experimental_allocator_$2.html#$1, $1)&nbsp;
TDC = $(T td nowrap, $(D $1)$+) TDC = $(TDNW $(D $1)$+)
TDC2 = $(T td nowrap, $(D $(MYREF2 $1,$+))$(BR)$(SMALL TDC2 = $(TDNW $(D $(MYREF2 $1,$+))$(BR)$(SMALL
$(D std.experimental.allocator.building_blocks.$2))) $(D std.experimental.allocator.building_blocks.$2)))
TDC3 = $(T td nowrap, $(D $(MYREF3 $1,$+))$(BR)$(SMALL TDC3 = $(TDNW $(D $(MYREF3 $1,$+))$(BR)$(SMALL
$(D std.experimental.allocator.$2))) $(D std.experimental.allocator.$2)))
RES = $(I result) RES = $(I result)
POST = $(BR)$(SMALL $(I Post:) $(BLUE $(D $0))) POST = $(BR)$(SMALL $(I Post:) $(BLUE $(D $0)))

282
std/format.d
View file

@ -218,68 +218,68 @@ $(I FormatChar):
$(TR $(TD $(B ' ')) $(TD numeric) $(TD Prefix positive $(TR $(TD $(B ' ')) $(TD numeric) $(TD Prefix positive
numbers in a signed conversion with a space.))) numbers in a signed conversion with a space.)))
<dl> $(DL
<dt>$(I Width) $(DT $(I Width))
<dd> $(DD
Specifies the minimum field width. Specifies the minimum field width.
If the width is a $(B *), an additional argument of type $(B int), If the width is a $(B *), an additional argument of type $(B int),
preceding the actual argument, is taken as the width. preceding the actual argument, is taken as the width.
If the width is negative, it is as if the $(B -) was given If the width is negative, it is as if the $(B -) was given
as a $(I Flags) character. as a $(I Flags) character.)
<dt>$(I Precision) $(DT $(I Precision))
<dd> Gives the precision for numeric conversions. $(DD Gives the precision for numeric conversions.
If the precision is a $(B *), an additional argument of type $(B int), If the precision is a $(B *), an additional argument of type $(B int),
preceding the actual argument, is taken as the precision. preceding the actual argument, is taken as the precision.
If it is negative, it is as if there was no $(I Precision) specifier. If it is negative, it is as if there was no $(I Precision) specifier.)
<dt>$(I FormatChar) $(DT $(I FormatChar))
<dd> $(DD
<dl> $(DL
<dt>$(B 's') $(DT $(B 's'))
<dd>The corresponding argument is formatted in a manner consistent $(DD The corresponding argument is formatted in a manner consistent
with its type: with its type:
<dl> $(DL
<dt>$(B bool) $(DT $(B bool))
<dd>The result is <tt>'true'</tt> or <tt>'false'</tt>. $(DD The result is $(D "true") or $(D "false").)
<dt>integral types $(DT integral types)
<dd>The $(B %d) format is used. $(DD The $(B %d) format is used.)
<dt>floating point types $(DT floating point types)
<dd>The $(B %g) format is used. $(DD The $(B %g) format is used.)
<dt>string types $(DT string types)
<dd>The result is the string converted to UTF-8. $(DD The result is the string converted to UTF-8.
A $(I Precision) specifies the maximum number of characters A $(I Precision) specifies the maximum number of characters
to use in the result. to use in the result.)
<dt>structs $(DT structs)
<dd>If the struct defines a $(B toString()) method the result is $(DD If the struct defines a $(B toString()) method the result is
the string returned from this function. Otherwise the result is the string returned from this function. Otherwise the result is
StructName(field<sub>0</sub>, field<sub>1</sub>, ...) where StructName(field<sub>0</sub>, field<sub>1</sub>, ...) where
field<sub>n</sub> is the nth element formatted with the default field<sub>n</sub> is the nth element formatted with the default
format. format.)
<dt>classes derived from $(B Object) $(DT classes derived from $(B Object))
<dd>The result is the string returned from the class instance's $(DD The result is the string returned from the class instance's
$(B .toString()) method. $(B .toString()) method.
A $(I Precision) specifies the maximum number of characters A $(I Precision) specifies the maximum number of characters
to use in the result. to use in the result.)
<dt>unions $(DT unions)
<dd>If the union defines a $(B toString()) method the result is $(DD If the union defines a $(B toString()) method the result is
the string returned from this function. Otherwise the result is the string returned from this function. Otherwise the result is
the name of the union, without its contents. the name of the union, without its contents.)
<dt>non-string static and dynamic arrays $(DT non-string static and dynamic arrays)
<dd>The result is [s<sub>0</sub>, s<sub>1</sub>, ...] $(DD The result is [s<sub>0</sub>, s<sub>1</sub>, ...]
where s<sub>n</sub> is the nth element where s<sub>n</sub> is the nth element
formatted with the default format. formatted with the default format.)
<dt>associative arrays $(DT associative arrays)
<dd>The result is the equivalent of what the initializer $(DD The result is the equivalent of what the initializer
would look like for the contents of the associative array, would look like for the contents of the associative array,
e.g.: ["red" : 10, "blue" : 20]. e.g.: ["red" : 10, "blue" : 20].)
</dl> ))
<dt>$(B 'c') $(DT $(B 'c'))
<dd>The corresponding argument must be a character type. $(DD The corresponding argument must be a character type.)
<dt>$(B 'b','d','o','x','X') $(DT $(B 'b','d','o','x','X'))
<dd> The corresponding argument must be an integral type $(DD The corresponding argument must be an integral type
and is formatted as an integer. If the argument is a signed type and is formatted as an integer. If the argument is a signed type
and the $(I FormatChar) is $(B d) it is converted to and the $(I FormatChar) is $(B d) it is converted to
a signed string of characters, otherwise it is treated as a signed string of characters, otherwise it is treated as
@ -291,26 +291,26 @@ $(I FormatChar):
If there are fewer resulting digits than the $(I Precision), If there are fewer resulting digits than the $(I Precision),
leading zeros are used as necessary. leading zeros are used as necessary.
If the $(I Precision) is 0 and the number is 0, no digits If the $(I Precision) is 0 and the number is 0, no digits
result. result.)
<dt>$(B 'e','E') $(DT $(B 'e','E'))
<dd> A floating point number is formatted as one digit before $(DD A floating point number is formatted as one digit before
the decimal point, $(I Precision) digits after, the $(I FormatChar), the decimal point, $(I Precision) digits after, the $(I FormatChar),
&plusmn;, followed by at least a two digit exponent: &plusmn;, followed by at least a two digit exponent:
$(I d.dddddd)e$(I &plusmn;dd). $(I d.dddddd)e$(I &plusmn;dd).
If there is no $(I Precision), six If there is no $(I Precision), six
digits are generated after the decimal point. digits are generated after the decimal point.
If the $(I Precision) is 0, no decimal point is generated. If the $(I Precision) is 0, no decimal point is generated.)
<dt>$(B 'f','F') $(DT $(B 'f','F'))
<dd> A floating point number is formatted in decimal notation. $(DD A floating point number is formatted in decimal notation.
The $(I Precision) specifies the number of digits generated The $(I Precision) specifies the number of digits generated
after the decimal point. It defaults to six. At least one digit after the decimal point. It defaults to six. At least one digit
is generated before the decimal point. If the $(I Precision) is generated before the decimal point. If the $(I Precision)
is zero, no decimal point is generated. is zero, no decimal point is generated.)
<dt>$(B 'g','G') $(DT $(B 'g','G'))
<dd> A floating point number is formatted in either $(B e) or $(DD A floating point number is formatted in either $(B e) or
$(B f) format for $(B g); $(B E) or $(B F) format for $(B f) format for $(B g); $(B E) or $(B F) format for
$(B G). $(B G).
The $(B f) format is used if the exponent for an $(B e) format The $(B f) format is used if the exponent for an $(B e) format
@ -318,10 +318,10 @@ $(I FormatChar):
The $(I Precision) specifies the number of significant The $(I Precision) specifies the number of significant
digits, and defaults to six. digits, and defaults to six.
Trailing zeros are elided after the decimal point, if the fractional Trailing zeros are elided after the decimal point, if the fractional
part is zero then no decimal point is generated. part is zero then no decimal point is generated.)
<dt>$(B 'a','A') $(DT $(B 'a','A'))
<dd> A floating point number is formatted in hexadecimal $(DD A floating point number is formatted in hexadecimal
exponential notation 0x$(I h.hhhhhh)p$(I &plusmn;d). exponential notation 0x$(I h.hhhhhh)p$(I &plusmn;d).
There is one hexadecimal digit before the decimal point, and as There is one hexadecimal digit before the decimal point, and as
many after as specified by the $(I Precision). many after as specified by the $(I Precision).
@ -333,9 +333,9 @@ $(I FormatChar):
$(I h.hhhhhh)*2<sup>$(I &plusmn;d)</sup>. $(I h.hhhhhh)*2<sup>$(I &plusmn;d)</sup>.
The exponent for zero is zero. The exponent for zero is zero.
The hexadecimal digits, x and p are in upper case if the The hexadecimal digits, x and p are in upper case if the
$(I FormatChar) is upper case. $(I FormatChar) is upper case.)
</dl> ))
</dl> )
Floating point NaN's are formatted as $(B nan) if the Floating point NaN's are formatted as $(B nan) if the
$(I FormatChar) is lower case, or $(B NAN) if upper. $(I FormatChar) is lower case, or $(B NAN) if upper.
@ -376,10 +376,10 @@ $(I FormatChar):
} }
------------------------- -------------------------
The output is: The output is:
<pre class=console> $(CONSOLE
My items are 1 2 3. My items are 1 2 3.
My items are 1, 2, 3. My items are 1, 2, 3.
</pre> )
The trailing end of the sub-format string following the specifier for each The trailing end of the sub-format string following the specifier for each
item is interpreted as the array delimiter, and is therefore omitted item is interpreted as the array delimiter, and is therefore omitted
@ -395,9 +395,9 @@ My items are 1, 2, 3.
} }
------------------------- -------------------------
which gives the output: which gives the output:
<pre class=console> $(CONSOLE
My items are -1-, -2-, -3-. My items are -1-, -2-, -3-.
</pre> )
These compound format specifiers may be nested in the case of a nested These compound format specifiers may be nested in the case of a nested
array argument: array argument:
@ -419,7 +419,7 @@ My items are -1-, -2-, -3-.
} }
------------------------- -------------------------
The output is: The output is:
<pre class=console> $(CONSOLE
1 2 3 1 2 3
4 5 6 4 5 6
7 8 9 7 8 9
@ -431,7 +431,7 @@ My items are -1-, -2-, -3-.
[[1 2 3] [[1 2 3]
[4 5 6] [4 5 6]
[7 8 9]] [7 8 9]]
</pre> )
Inside a compound format specifier, strings and characters are escaped Inside a compound format specifier, strings and characters are escaped
automatically. To avoid this behavior, add $(B '-') flag to automatically. To avoid this behavior, add $(B '-') flag to
@ -447,11 +447,11 @@ My items are -1-, -2-, -3-.
} }
------------------------- -------------------------
which gives the output: which gives the output:
<pre class=console> $(CONSOLE
My friends are ["John", "Nancy"]. My friends are ["John", "Nancy"].
My friends are "John", "Nancy". My friends are "John", "Nancy".
My friends are John, Nancy. My friends are John, Nancy.
</pre> )
*/ */
uint formattedWrite(Writer, Char, A...)(Writer w, in Char[] fmt, A args) uint formattedWrite(Writer, Char, A...)(Writer w, in Char[] fmt, A args)
{ {
@ -1254,10 +1254,10 @@ unittest
import std.array : appender; import std.array : appender;
auto a = appender!(string)(); auto a = appender!(string)();
auto f = FormatSpec!char("%-(%s%"); auto f = FormatSpec!char("%-(%s%"); // %)")
assertThrown(f.writeUpToNextSpec(a)); assertThrown(f.writeUpToNextSpec(a));
f = FormatSpec!char("%(%-"); f = FormatSpec!char("%(%-"); // %)")
assertThrown(f.writeUpToNextSpec(a)); assertThrown(f.writeUpToNextSpec(a));
} }
@ -5088,7 +5088,7 @@ private TypeInfo primitiveTypeInfo(Mangle m)
* A $(I format specification) starts with a '%' character, * A $(I format specification) starts with a '%' character,
* and has the following grammar: * and has the following grammar:
<pre> $(CONSOLE
$(I FormatSpecification): $(I FormatSpecification):
$(B '%%') $(B '%%')
$(B '%') $(I Flags) $(I Width) $(I Precision) $(I FormatChar) $(B '%') $(I Flags) $(I Width) $(I Precision) $(I FormatChar)
@ -5143,88 +5143,88 @@ $(I FormatChar):
$(B 'G') $(B 'G')
$(B 'a') $(B 'a')
$(B 'A') $(B 'A')
</pre> )
<dl> $(DL
<dt>$(I Flags) $(DT $(I Flags))
<dl> $(DL
<dt>$(B '-') $(DT $(B '-'))
<dd> $(DD
Left justify the result in the field. Left justify the result in the field.
It overrides any $(B 0) flag. It overrides any $(B 0) flag.)
<dt>$(B '+') $(DT $(B '+'))
<dd>Prefix positive numbers in a signed conversion with a $(B +). $(DD Prefix positive numbers in a signed conversion with a $(B +).
It overrides any $(I space) flag. It overrides any $(I space) flag.)
<dt>$(B '#') $(DT $(B '#'))
<dd>Use alternative formatting: $(DD Use alternative formatting:
<dl> $(DL
<dt>For $(B 'o'): $(DT For $(B 'o'):)
<dd> Add to precision as necessary so that the first digit $(DD Add to precision as necessary so that the first digit
of the octal formatting is a '0', even if both the argument of the octal formatting is a '0', even if both the argument
and the $(I Precision) are zero. and the $(I Precision) are zero.)
<dt> For $(B 'x') ($(B 'X')): $(DT For $(B 'x') ($(B 'X')):)
<dd> If non-zero, prefix result with $(B 0x) ($(B 0X)). $(DD If non-zero, prefix result with $(B 0x) ($(B 0X)).)
<dt> For floating point formatting: $(DT For floating point formatting:)
<dd> Always insert the decimal point. $(DD Always insert the decimal point.)
<dt> For $(B 'g') ($(B 'G')): $(DT For $(B 'g') ($(B 'G')):)
<dd> Do not elide trailing zeros. $(DD Do not elide trailing zeros.)
</dl> ))
<dt>$(B '0') $(DT $(B '0'))
<dd> For integer and floating point formatting when not nan or $(DD For integer and floating point formatting when not nan or
infinity, use leading zeros infinity, use leading zeros
to pad rather than spaces. to pad rather than spaces.
Ignore if there's a $(I Precision). Ignore if there's a $(I Precision).)
<dt>$(B ' ') $(DT $(B ' '))
<dd>Prefix positive numbers in a signed conversion with a space. $(DD Prefix positive numbers in a signed conversion with a space.)
</dl> )
<dt>$(I Width) $(DT $(I Width))
<dd> $(DD
Specifies the minimum field width. Specifies the minimum field width.
If the width is a $(B *), the next argument, which must be If the width is a $(B *), the next argument, which must be
of type $(B int), is taken as the width. of type $(B int), is taken as the width.
If the width is negative, it is as if the $(B -) was given If the width is negative, it is as if the $(B -) was given
as a $(I Flags) character. as a $(I Flags) character.)
<dt>$(I Precision) $(DT $(I Precision))
<dd> Gives the precision for numeric conversions. $(DD Gives the precision for numeric conversions.
If the precision is a $(B *), the next argument, which must be If the precision is a $(B *), the next argument, which must be
of type $(B int), is taken as the precision. If it is negative, of type $(B int), is taken as the precision. If it is negative,
it is as if there was no $(I Precision). it is as if there was no $(I Precision).)
<dt>$(I FormatChar) $(DT $(I FormatChar))
<dd> $(DD
<dl> $(DL
<dt>$(B 's') $(DT $(B 's'))
<dd>The corresponding argument is formatted in a manner consistent $(DD The corresponding argument is formatted in a manner consistent
with its type: with its type:
<dl> $(DL
<dt>$(B bool) $(DT $(B bool))
<dd>The result is <tt>'true'</tt> or <tt>'false'</tt>. $(DD The result is <tt>'true'</tt> or <tt>'false'</tt>.)
<dt>integral types $(DT integral types)
<dd>The $(B %d) format is used. $(DD The $(B %d) format is used.)
<dt>floating point types $(DT floating point types)
<dd>The $(B %g) format is used. $(DD The $(B %g) format is used.)
<dt>string types $(DT string types)
<dd>The result is the string converted to UTF-8. $(DD The result is the string converted to UTF-8.)
A $(I Precision) specifies the maximum number of characters A $(I Precision) specifies the maximum number of characters
to use in the result. to use in the result.
<dt>classes derived from $(B Object) $(DT classes derived from $(B Object))
<dd>The result is the string returned from the class instance's $(DD The result is the string returned from the class instance's
$(B .toString()) method. $(B .toString()) method.
A $(I Precision) specifies the maximum number of characters A $(I Precision) specifies the maximum number of characters
to use in the result. to use in the result.)
<dt>non-string static and dynamic arrays $(DT non-string static and dynamic arrays)
<dd>The result is [s<sub>0</sub>, s<sub>1</sub>, ...] $(DD The result is [s<sub>0</sub>, s<sub>1</sub>, ...]
where s<sub>k</sub> is the kth element where s<sub>k</sub> is the kth element
formatted with the default format. formatted with the default format.)
</dl> ))
<dt>$(B 'b','d','o','x','X') $(DT $(B 'b','d','o','x','X'))
<dd> The corresponding argument must be an integral type $(DD The corresponding argument must be an integral type
and is formatted as an integer. If the argument is a signed type and is formatted as an integer. If the argument is a signed type
and the $(I FormatChar) is $(B d) it is converted to and the $(I FormatChar) is $(B d) it is converted to
a signed string of characters, otherwise it is treated as a signed string of characters, otherwise it is treated as
@ -5236,25 +5236,25 @@ $(I FormatChar):
If there are fewer resulting digits than the $(I Precision), If there are fewer resulting digits than the $(I Precision),
leading zeros are used as necessary. leading zeros are used as necessary.
If the $(I Precision) is 0 and the number is 0, no digits If the $(I Precision) is 0 and the number is 0, no digits
result. result.)
<dt>$(B 'e','E') $(DT $(B 'e','E'))
<dd> A floating point number is formatted as one digit before $(DD A floating point number is formatted as one digit before
the decimal point, $(I Precision) digits after, the $(I FormatChar), the decimal point, $(I Precision) digits after, the $(I FormatChar),
&plusmn;, followed by at least a two digit exponent: $(I d.dddddd)e$(I &plusmn;dd). &plusmn;, followed by at least a two digit exponent: $(I d.dddddd)e$(I &plusmn;dd).
If there is no $(I Precision), six If there is no $(I Precision), six
digits are generated after the decimal point. digits are generated after the decimal point.
If the $(I Precision) is 0, no decimal point is generated. If the $(I Precision) is 0, no decimal point is generated.)
<dt>$(B 'f','F') $(DT $(B 'f','F'))
<dd> A floating point number is formatted in decimal notation. $(DD A floating point number is formatted in decimal notation.
The $(I Precision) specifies the number of digits generated The $(I Precision) specifies the number of digits generated
after the decimal point. It defaults to six. At least one digit after the decimal point. It defaults to six. At least one digit
is generated before the decimal point. If the $(I Precision) is generated before the decimal point. If the $(I Precision)
is zero, no decimal point is generated. is zero, no decimal point is generated.)
<dt>$(B 'g','G') $(DT $(B 'g','G'))
<dd> A floating point number is formatted in either $(B e) or $(DD A floating point number is formatted in either $(B e) or
$(B f) format for $(B g); $(B E) or $(B F) format for $(B f) format for $(B g); $(B E) or $(B F) format for
$(B G). $(B G).
The $(B f) format is used if the exponent for an $(B e) format The $(B f) format is used if the exponent for an $(B e) format
@ -5262,10 +5262,10 @@ $(I FormatChar):
The $(I Precision) specifies the number of significant The $(I Precision) specifies the number of significant
digits, and defaults to six. digits, and defaults to six.
Trailing zeros are elided after the decimal point, if the fractional Trailing zeros are elided after the decimal point, if the fractional
part is zero then no decimal point is generated. part is zero then no decimal point is generated.)
<dt>$(B 'a','A') $(DT $(B 'a','A'))
<dd> A floating point number is formatted in hexadecimal $(DD A floating point number is formatted in hexadecimal
exponential notation 0x$(I h.hhhhhh)p$(I &plusmn;d). exponential notation 0x$(I h.hhhhhh)p$(I &plusmn;d).
There is one hexadecimal digit before the decimal point, and as There is one hexadecimal digit before the decimal point, and as
many after as specified by the $(I Precision). many after as specified by the $(I Precision).
@ -5277,15 +5277,15 @@ $(I FormatChar):
$(I h.hhhhhh)*2<sup>$(I &plusmn;d)</sup>. $(I h.hhhhhh)*2<sup>$(I &plusmn;d)</sup>.
The exponent for zero is zero. The exponent for zero is zero.
The hexadecimal digits, x and p are in upper case if the The hexadecimal digits, x and p are in upper case if the
$(I FormatChar) is upper case. $(I FormatChar) is upper case.)
</dl> )
Floating point NaN's are formatted as $(B nan) if the Floating point NaN's are formatted as $(B nan) if the
$(I FormatChar) is lower case, or $(B NAN) if upper. $(I FormatChar) is lower case, or $(B NAN) if upper.
Floating point infinities are formatted as $(B inf) or Floating point infinities are formatted as $(B inf) or
$(B infinity) if the $(B infinity) if the
$(I FormatChar) is lower case, or $(B INF) or $(B INFINITY) if upper. $(I FormatChar) is lower case, or $(B INF) or $(B INFINITY) if upper.
</dl> ))
Example: Example:

2
std/internal/math/errorfunction.d
View file

@ -16,7 +16,7 @@
* POWER = $1<sup>$2</sup> * POWER = $1<sup>$2</sup>
* BIGSUM = $(BIG &Sigma; <sup>$2</sup><sub>$(SMALL $1)</sub>) * BIGSUM = $(BIG &Sigma; <sup>$2</sup><sub>$(SMALL $1)</sub>)
* CHOOSE = $(BIG &#40;) <sup>$(SMALL $1)</sup><sub>$(SMALL $2)</sub> $(BIG &#41;) * CHOOSE = $(BIG &#40;) <sup>$(SMALL $1)</sup><sub>$(SMALL $2)</sub> $(BIG &#41;)
* TABLE_SV = <table border=1 cellpadding=4 cellspacing=0> * TABLE_SV = <table border="1" cellpadding="4" cellspacing="0">
* <caption>Special Values</caption> * <caption>Special Values</caption>
* $0</table> * $0</table>
* SVH = $(TR $(TH $1) $(TH $2)) * SVH = $(TR $(TH $1) $(TH $2))

2
std/internal/math/gammafunction.d
View file

@ -8,7 +8,7 @@
* *
* *
Macros: Macros:
* TABLE_SV = <table border=1 cellpadding=4 cellspacing=0> * TABLE_SV = <table border="1" cellpadding="4" cellspacing="0">
* <caption>Special Values</caption> * <caption>Special Values</caption>
* $0</table> * $0</table>
* SVH = $(TR $(TH $1) $(TH $2)) * SVH = $(TR $(TH $1) $(TH $2))

4
std/math.d
View file

@ -80,7 +80,7 @@ $(TR $(TDNW Hardware Control) $(TD
* Macros: * Macros:
* WIKI = Phobos/StdMath * WIKI = Phobos/StdMath
* *
* TABLE_SV = <table border=1 cellpadding=4 cellspacing=0> * TABLE_SV = <table border="1" cellpadding="4" cellspacing="0">
* <caption>Special Values</caption> * <caption>Special Values</caption>
* $0</table> * $0</table>
* SVH = $(TR $(TH $1) $(TH $2)) * SVH = $(TR $(TH $1) $(TH $2))
@ -110,7 +110,7 @@ $(TR $(TDNW Hardware Control) $(TD
* Copyright: Copyright Digital Mars 2000 - 2011. * Copyright: Copyright Digital Mars 2000 - 2011.
* D implementations of tan, atan, atan2, exp, expm1, exp2, log, log10, log1p, * D implementations of tan, atan, atan2, exp, expm1, exp2, log, log10, log1p,
* log2, floor, ceil and lrint functions are based on the CEPHES math library, * log2, floor, ceil and lrint functions are based on the CEPHES math library,
* which is Copyright (C) 2001 Stephen L. Moshier <steve@moshier.net> * which is Copyright (C) 2001 Stephen L. Moshier $(LT)steve@moshier.net$(GT)
* and are incorporated herein by permission of the author. The author * and are incorporated herein by permission of the author. The author
* reserves the right to distribute this material elsewhere under different * reserves the right to distribute this material elsewhere under different
* copying permissions. These modifications are distributed here under * copying permissions. These modifications are distributed here under

2
std/mathspecial.d
View file

@ -22,7 +22,7 @@
* Macros: * Macros:
* WIKI = Phobos/StdMathSpecial * WIKI = Phobos/StdMathSpecial
* *
* TABLE_SV = <table border=1 cellpadding=4 cellspacing=0> * TABLE_SV = <table border="1" cellpadding="4" cellspacing="0">
* <caption>Special Values</caption> * <caption>Special Values</caption>
* $0</table> * $0</table>
* SVH = $(TR $(TH $1) $(TH $2)) * SVH = $(TR $(TH $1) $(TH $2))

2
std/net/curl.d
View file

@ -3063,7 +3063,7 @@ struct HTTP
} }
} }
/** <a name="HTTP.Method"/ >The standard HTTP methods : /** <a name="HTTP.Method"/>The standard HTTP methods :
* $(WEB www.w3.org/Protocols/rfc2616/rfc2616-sec5.html#sec5.1.1, _RFC2616 Section 5.1.1) * $(WEB www.w3.org/Protocols/rfc2616/rfc2616-sec5.html#sec5.1.1, _RFC2616 Section 5.1.1)
*/ */
enum Method enum Method

2
std/net/isemail.d
View file

@ -1,7 +1,7 @@
/** /**
* Validates an email address according to RFCs 5321, 5322 and others. * Validates an email address according to RFCs 5321, 5322 and others.
* *
* Authors: Dominic Sayers <dominic@sayers.cc>, Jacob Carlborg * Authors: Dominic Sayers $(LT)dominic@sayers.cc$(GT), Jacob Carlborg
* Copyright: Dominic Sayers, Jacob Carlborg 2008-. * Copyright: Dominic Sayers, Jacob Carlborg 2008-.
* Test schema documentation: Copyright © 2011, Daniel Marschall * Test schema documentation: Copyright © 2011, Daniel Marschall
* License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost Software License 1.0) * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost Software License 1.0)

4
std/outbuffer.d
View file

@ -329,7 +329,7 @@ class OutBuffer
* args = arguments to be formatted * args = arguments to be formatted
* *
* See_Also: * See_Also:
* $(XREF stdio, writef); * $(XREF stdio, _writef);
* $(XREF format, formattedWrite); * $(XREF format, formattedWrite);
*/ */
void writef(Char, A...)(in Char[] fmt, A args) void writef(Char, A...)(in Char[] fmt, A args)
@ -355,7 +355,7 @@ class OutBuffer
* args = arguments to be formatted * args = arguments to be formatted
* *
* See_Also: * See_Also:
* $(XREF stdio, writefln); * $(XREF stdio, _writefln);
* $(XREF format, formattedWrite); * $(XREF format, formattedWrite);
*/ */
void writefln(Char, A...)(in Char[] fmt, A args) void writefln(Char, A...)(in Char[] fmt, A args)

2
std/random.d
View file

@ -32,7 +32,7 @@ distribution in various ways. So far the uniform distribution for
integers and real numbers have been implemented. integers and real numbers have been implemented.
Upgrading: Upgrading:
$(WEB digitalmars.com/d/1.0/phobos/std_random.html#rand Phobos D1 $(D rand())) can $(WEB digitalmars.com/d/1.0/phobos/std_random.html#rand, Phobos D1 $(D rand())) can
be replaced with $(D uniform!uint()). be replaced with $(D uniform!uint()).
Source: $(PHOBOSSRC std/_random.d) Source: $(PHOBOSSRC std/_random.d)

2
std/range/package.d
View file

@ -11,7 +11,7 @@ files, incoming network data, etc.
For more detailed information about the conceptual aspect of ranges and the For more detailed information about the conceptual aspect of ranges and the
motivation behind them, see Andrei Alexandrescu's article motivation behind them, see Andrei Alexandrescu's article
$(LINK2 http://www.informit.com/articles/printerfriendly.aspx?p=1407357&rll=1, $(LINK2 http://www.informit.com/articles/printerfriendly.aspx?p=1407357$(AMP)rll=1,
$(I On Iteration)). $(I On Iteration)).
Submodules: Submodules:

27
std/regex/package.d
View file

@ -2,7 +2,7 @@
$(LUCKY Regular expressions) are a commonly used method of pattern matching $(LUCKY Regular expressions) are a commonly used method of pattern matching
on strings, with $(I regex) being a catchy word for a pattern in this domain on strings, with $(I regex) being a catchy word for a pattern in this domain
specific language. Typical problems usually solved by regular expressions specific language. Typical problems usually solved by regular expressions
include validation of user input and the ubiquitous find & replace include validation of user input and the ubiquitous find $(AMP) replace
in text processing utilities. in text processing utilities.
$(SECTION Synopsis) $(SECTION Synopsis)
@ -117,21 +117,21 @@
$(REG_ROW +?, Matches previous character/subexpression 1 or more times. $(REG_ROW +?, Matches previous character/subexpression 1 or more times.
Lazy version - stops as early as possible.) Lazy version - stops as early as possible.)
$(REG_ROW {n}, Matches previous character/subexpression exactly n times. ) $(REG_ROW {n}, Matches previous character/subexpression exactly n times. )
$(REG_ROW {n&#44}, Matches previous character/subexpression n times or more. $(REG_ROW {n$(COMMA)}, Matches previous character/subexpression n times or more.
Greedy version - tries as many times as possible. ) Greedy version - tries as many times as possible. )
$(REG_ROW {n&#44}?, Matches previous character/subexpression n times or more. $(REG_ROW {n$(COMMA)}?, Matches previous character/subexpression n times or more.
Lazy version - stops as early as possible.) Lazy version - stops as early as possible.)
$(REG_ROW {n&#44m}, Matches previous character/subexpression n to m times. $(REG_ROW {n$(COMMA)m}, Matches previous character/subexpression n to m times.
Greedy version - tries as many times as possible, but no more than m times. ) Greedy version - tries as many times as possible, but no more than m times. )
$(REG_ROW {n&#44m}?, Matches previous character/subexpression n to m times. $(REG_ROW {n$(COMMA)m}?, Matches previous character/subexpression n to m times.
Lazy version - stops as early as possible, but no less then n times.) Lazy version - stops as early as possible, but no less then n times.)
$(REG_TITLE Other, Subexpressions & alternations ) $(REG_TITLE Other, Subexpressions $(AMP) alternations )
$(REG_ROW (regex), Matches subexpression regex, $(REG_ROW (regex), Matches subexpression regex,
saving matched portion of text for later retrieval. ) saving matched portion of text for later retrieval. )
$(REG_ROW (?:regex), Matches subexpression regex, $(REG_ROW (?:regex), Matches subexpression regex,
$(U not) saving matched portion of text. Useful to speed up matching. ) $(U not) saving matched portion of text. Useful to speed up matching. )
$(REG_ROW A|B, Matches subexpression A, or failing that, matches B. ) $(REG_ROW A|B, Matches subexpression A, or failing that, matches B. )
$(REG_ROW (?P&lt;name&gt;regex), Matches named subexpression $(REG_ROW (?P$(LT)name$(GT)regex), Matches named subexpression
regex labeling it with name 'name'. regex labeling it with name 'name'.
When referring to a matched portion of text, When referring to a matched portion of text,
names work like aliases in addition to direct numbers. names work like aliases in addition to direct numbers.
@ -164,8 +164,9 @@
$(REG_TITLE Pattern element, Semantics ) $(REG_TITLE Pattern element, Semantics )
$(REG_ROW Any atom, Has the same meaning as outside of a character class.) $(REG_ROW Any atom, Has the same meaning as outside of a character class.)
$(REG_ROW a-z, Includes characters a, b, c, ..., z. ) $(REG_ROW a-z, Includes characters a, b, c, ..., z. )
$(REG_ROW [a||b]&#44 [a--b]&#44 [a~~b]&#44 [a&&b], Where a, b are arbitrary classes, $(REG_ROW [a||b]$(COMMA) [a--b]$(COMMA) [a~~b]$(COMMA) [a$(AMP)$(AMP)b],
means union, set difference, symmetric set difference, and intersection respectively. Where a, b are arbitrary classes, means union, set difference,
symmetric set difference, and intersection respectively.
$(I Any sequence of character class elements implicitly forms a union.) ) $(I Any sequence of character class elements implicitly forms a union.) )
) )
@ -209,13 +210,13 @@
The format string can reference parts of match using the following notation. The format string can reference parts of match using the following notation.
$(REG_TABLE $(REG_TABLE
$(REG_TITLE Format specifier, Replaced by ) $(REG_TITLE Format specifier, Replaced by )
$(REG_ROW $&amp;, the whole match. ) $(REG_ROW $$(AMP), the whole match. )
$(REG_ROW $(DOLLAR)$(BACKTICK), part of input $(I preceding) the match. ) $(REG_ROW $(DOLLAR)$(BACKTICK), part of input $(I preceding) the match. )
$(REG_ROW $', part of input $(I following) the match. ) $(REG_ROW $', part of input $(I following) the match. )
$(REG_ROW $$, '$' character. ) $(REG_ROW $$, '$' character. )
$(REG_ROW \c &#44 where c is any character, the character c itself. ) $(REG_ROW \c $(COMMA) where c is any character, the character c itself. )
$(REG_ROW \\, '\' character. ) $(REG_ROW \\, '\' character. )
$(REG_ROW &#36;1 .. &#36;99, submatch number 1 to 99 respectively. ) $(REG_ROW $(DOLLAR)1 .. $(DOLLAR)99, submatch number 1 to 99 respectively. )
) )
$(SECTION Slicing and zero memory allocations orientation) $(SECTION Slicing and zero memory allocations orientation)
@ -237,7 +238,7 @@
API and utility constructs are modeled after the original $(D std.regex) API and utility constructs are modeled after the original $(D std.regex)
by Walter Bright and Andrei Alexandrescu. by Walter Bright and Andrei Alexandrescu.
Source: $(PHOBOSSRC std/regex/_package.d) Source: $(PHOBOSSRC std/_regex/_package.d)
Macros: Macros:
REG_ROW = $(TR $(TD $(I $1 )) $(TD $+) ) REG_ROW = $(TR $(TD $(I $1 )) $(TD $+) )

169
std/stdint.d
View file

@ -17,103 +17,104 @@
The aliases are: The aliases are:
<table border=1 cellspacing=0 cellpadding=5> $(ATABLE $(TR
<th>Exact Alias $(TH Exact Alias)
<th>Description $(TH Description)
<th>At Least Alias $(TH At Least Alias)
<th>Description $(TH Description)
<th>Fast Alias $(TH Fast Alias)
<th>Description $(TH Description)
<tr> )$(TR
<td>int8_t $(TD int8_t)
<td>exactly 8 bits signed $(TD exactly 8 bits signed)
<td>int_least8_t $(TD int_least8_t)
<td>at least 8 bits signed $(TD at least 8 bits signed)
<td>int_fast8_t $(TD int_fast8_t)
<td>fast 8 bits signed $(TD fast 8 bits signed)
<tr> )$(TR
<td>uint8_t $(TD uint8_t)
<td>exactly 8 bits unsigned $(TD exactly 8 bits unsigned)
<td>uint_least8_t $(TD uint_least8_t)
<td>at least 8 bits unsigned $(TD at least 8 bits unsigned)
<td>uint_fast8_t $(TD uint_fast8_t)
<td>fast 8 bits unsigned $(TD fast 8 bits unsigned)
<tr> )$(TR
<td>int16_t $(TD int16_t)
<td>exactly 16 bits signed $(TD exactly 16 bits signed)
<td>int_least16_t $(TD int_least16_t)
<td>at least 16 bits signed $(TD at least 16 bits signed)
<td>int_fast16_t $(TD int_fast16_t)
<td>fast 16 bits signed $(TD fast 16 bits signed)
<tr> )$(TR
<td>uint16_t $(TD uint16_t)
<td>exactly 16 bits unsigned $(TD exactly 16 bits unsigned)
<td>uint_least16_t $(TD uint_least16_t)
<td>at least 16 bits unsigned $(TD at least 16 bits unsigned)
<td>uint_fast16_t $(TD uint_fast16_t)
<td>fast 16 bits unsigned $(TD fast 16 bits unsigned)
<tr> )$(TR
<td>int32_t $(TD int32_t)
<td>exactly 32 bits signed $(TD exactly 32 bits signed)
<td>int_least32_t $(TD int_least32_t)
<td>at least 32 bits signed $(TD at least 32 bits signed)
<td>int_fast32_t $(TD int_fast32_t)
<td>fast 32 bits signed $(TD fast 32 bits signed)
<tr> )$(TR
<td>uint32_t $(TD uint32_t)
<td>exactly 32 bits unsigned $(TD exactly 32 bits unsigned)
<td>uint_least32_t $(TD uint_least32_t)
<td>at least 32 bits unsigned $(TD at least 32 bits unsigned)
<td>uint_fast32_t $(TD uint_fast32_t)
<td>fast 32 bits unsigned $(TD fast 32 bits unsigned)
<tr> )$(TR
<td>int64_t $(TD int64_t)
<td>exactly 64 bits signed $(TD exactly 64 bits signed)
<td>int_least64_t $(TD int_least64_t)
<td>at least 64 bits signed $(TD at least 64 bits signed)
<td>int_fast64_t $(TD int_fast64_t)
<td>fast 64 bits signed $(TD fast 64 bits signed)
<tr> )$(TR
<td>uint64_t $(TD uint64_t)
<td>exactly 64 bits unsigned $(TD exactly 64 bits unsigned)
<td>uint_least64_t $(TD uint_least64_t)
<td>at least 64 bits unsigned $(TD at least 64 bits unsigned)
<td>uint_fast64_t $(TD uint_fast64_t)
<td>fast 64 bits unsigned $(TD fast 64 bits unsigned)
</table> ))
The ptr aliases are integral types guaranteed to be large enough The ptr aliases are integral types guaranteed to be large enough
to hold a pointer without losing bits: to hold a pointer without losing bits:
<table border=1 cellspacing=0 cellpadding=5> $(ATABLE $(TR
<th>Alias $(TH Alias)
<th>Description $(TH Description)
<tr> )$(TR
<td>intptr_t $(TD intptr_t)
<td>signed integral type large enough to hold a pointer $(TD signed integral type large enough to hold a pointer)
<tr> )$(TR
<td>uintptr_t $(TD uintptr_t)
<td>unsigned integral type large enough to hold a pointer $(TD unsigned integral type large enough to hold a pointer)
</table> ))
The max aliases are the largest integral types: The max aliases are the largest integral types:
<table border=1 cellspacing=0 cellpadding=5> $(ATABLE $(TR
<th>Alias $(TH Alias)
<th>Description $(TH Description)
<tr> )$(TR
<td>intmax_t $(TD intmax_t)
<td>the largest signed integral type $(TD the largest signed integral type)
<tr> )$(TR
<td>uintmax_t $(TD uintmax_t)
<td>the largest unsigned integral type $(TD the largest unsigned integral type)
</table> ))
* Macros: * Macros:
* WIKI=Phobos/StdStdint * WIKI=Phobos/StdStdint
* ATABLE=<table border="1" cellspacing="0" cellpadding="5">$0</table>
* *
* Copyright: Copyright Digital Mars 2000 - 2009. * Copyright: Copyright Digital Mars 2000 - 2009.
* License: $(WEB www.boost.org/LICENSE_1_0.txt, Boost License 1.0). * License: $(WEB www.boost.org/LICENSE_1_0.txt, Boost License 1.0).

4
std/stdio.d
View file

@ -330,12 +330,12 @@ void main(string[] args)
// underlying $(D FILE*) is closed. // underlying $(D FILE*) is closed.
} }
---- ----
<pre class=console> $(CONSOLE
% rdmd test.d Jimmy % rdmd test.d Jimmy
% cat test.txt % cat test.txt
Hello, Jimmy! Hello, Jimmy!
% __ % __
</pre> )
*/ */
struct File struct File
{ {

2
std/traits.d
View file

@ -2207,7 +2207,7 @@ unittest
} }
/** /**
* Alternate name for $(LREF FieldTypeTuple), kept for legacy compatibility. * Alternate name for $(LREF Fields), kept for legacy compatibility.
*/ */
alias FieldTypeTuple = Fields; alias FieldTypeTuple = Fields;

2
std/zlib.d
View file

@ -1,7 +1,7 @@
// Written in the D programming language. // Written in the D programming language.
/** /**
* Compress/decompress data using the $(WEB www.zlib.net, zlib library). * Compress/decompress data using the $(WEB www._zlib.net, _zlib library).
* *
* References: * References:
* $(WEB en.wikipedia.org/wiki/Zlib, Wikipedia) * $(WEB en.wikipedia.org/wiki/Zlib, Wikipedia)