-
Notifications
You must be signed in to change notification settings - Fork 28
/
Copy pathhtmlgen.patch
12763 lines (11873 loc) · 533 KB
/
htmlgen.patch
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
From 7c956d9da18d79fe1ec537169949cf5ffeba5441 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <[email protected]>
Date: Wed, 5 Dec 2018 01:09:09 +0100
Subject: [PATCH 01/13] Use \range where appropriate.
---
source/algorithms.tex | 6 +++---
source/strings.tex | 8 ++++----
2 files changed, 7 insertions(+), 7 deletions(-)
diff --git a/source/algorithms.tex b/source/algorithms.tex
index cea87802..b23120d4 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -7565,7 +7565,7 @@ The elements \tcode{e} of \range{first}{last}
are partitioned with respect to the expressions
\tcode{bool(invoke(comp, invoke(proj, e), value))} and
\tcode{!bool(invoke(comp, value, invoke(proj, e)))}.
-Also, for all elements \tcode{e} of \tcode{[first, last)},
+Also, for all elements \tcode{e} of \range{first}{last},
\tcode{bool(comp(e, value))} implies \tcode{!bool(comp(\brk{}value, e))}
for the overloads in namespace \tcode{std}.
@@ -7632,7 +7632,7 @@ The elements \tcode{e} of \range{first}{last}
are partitioned with respect to the expressions
\tcode{bool(invoke(comp, invoke(proj, e), value))} and
\tcode{!bool(invoke(comp, value, invoke(proj, e)))}.
-Also, for all elements \tcode{e} of \tcode{[first, last)},
+Also, for all elements \tcode{e} of \range{first}{last},
\tcode{bool(comp(e, value))} implies \tcode{!bool(comp(\brk{}value, e))}
for the overloads in namespace \tcode{std}.
@@ -10818,7 +10818,7 @@ move assigns from \tcode{val} to \tcode{acc}.
\pnum
For the overloads with an \tcode{ExecutionPolicy} and a non-empty range,
performs \tcode{*result = *first}.
-Then, for every \tcode{d} in \tcode{[1, last - first - 1]},
+Then, for every \tcode{d} in \crange{1}{last - first - 1},
performs \tcode{*(result + d) = binary_op(*(first + d), *(first + (d - 1)))}.
\pnum
diff --git a/source/strings.tex b/source/strings.tex
index 48e2bee8..fde8e62c 100644
--- a/source/strings.tex
+++ b/source/strings.tex
@@ -152,19 +152,19 @@ the smallest \tcode{i} such that \tcode{X::eq(p[i],charT())} is \tcode{true}. &
the smallest \tcode{q} in \tcode{[p,p+n)} such that
\tcode{X::eq(*q,c)} is \tcode{true}, \tcode{nullptr} otherwise. & linear \\ \rowsep
\tcode{X::move(s,p,n)} & \tcode{X::char_type*} &
-for each \tcode{i} in \tcode{[0,n)}, performs \tcode{X::assign(s[i],p[i])}.
-Copies correctly even where the ranges \tcode{[p,p+n)} and \tcode{[s,s+n)} overlap.\br \returns \tcode{s}. & linear \\ \rowsep
+for each \tcode{i} in \range{0}{n}, performs \tcode{X::assign(s[i],p[i])}.
+Copies correctly even where the ranges \range{p}{p+n} and \range{s}{s+n} overlap.\br \returns \tcode{s}. & linear \\ \rowsep
\tcode{X::copy(s,p,n)} & \tcode{X::char_type*} &
\expects
The ranges \range{p}{p+n} and \range{s}{s+n} do not overlap.\par
\returns
\tcode{s}.\br
for each \tcode{i} in
-\tcode{[0,n)}, performs \tcode{X::assign(s[i],p[i])}. & linear \\ \rowsep
+\range{0}{n}, performs \tcode{X::assign(s[i],p[i])}. & linear \\ \rowsep
\tcode{X::assign(r,d)} & (not used) &
assigns \tcode{r=d}. & constant \\ \rowsep
\tcode{X::assign\-(s,n,c)} & \tcode{X::char_type*} &
-for each \tcode{i} in \tcode{[0,n)}, performs
+for each \tcode{i} in \range{0}{n}, performs
\tcode{X::assign(s[i],c)}.\br
\returns
\tcode{s}. & linear \\ \rowsep
--
2.43.0
From 0f9c1c77edea1f2248f2faed5f0620ae55e2128d Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <[email protected]>
Date: Sat, 7 Jan 2017 01:59:05 +0100
Subject: [PATCH 02/13] [rand.req.eng] Omit superfluous dollar-math wrapping
inside \bigoh. [rejected upstream: 1340]
---
source/numerics.tex | 14 +++++++-------
1 file changed, 7 insertions(+), 7 deletions(-)
diff --git a/source/numerics.tex b/source/numerics.tex
index b91b8a06..cdd0c5d4 100644
--- a/source/numerics.tex
+++ b/source/numerics.tex
@@ -1937,19 +1937,19 @@ according to \ref{strings} and \ref{input.output}.
with the same initial state
as all other default-constructed engines
of type \tcode{E}.
- & \bigoh{$\text{size of state}$}
+ & \bigoh{\text{size of state}}
\\ \rowsep
\tcode{E(x)}
&
& Creates an engine
that compares equal to \tcode{x}.
- & \bigoh{$\text{size of state}$}
+ & \bigoh{\text{size of state}}
\\ \rowsep
\tcode{E(s)}%
&
& Creates an engine
with initial state determined by \tcode{s}.
- & \bigoh{$\text{size of state}$}
+ & \bigoh{\text{size of state}}
\\ \rowsep
\tcode{E(q)}%
\begin{footnote}
@@ -2024,12 +2024,12 @@ according to \ref{strings} and \ref{input.output}.
returns \tcode{true}
if $S_x = S_y$;
else returns \tcode{false}.
- & \bigoh{$\text{size of state}$}
+ & \bigoh{\text{size of state}}
\\ \rowsep
\tcode{x != y}%
& \tcode{bool}
& \tcode{!(x == y)}.
- & \bigoh{$\text{size of state}$}
+ & \bigoh{\text{size of state}}
\\ \rowsep
\tcode{os << x}%
& reference to the type of \tcode{os}
@@ -2044,7 +2044,7 @@ according to \ref{strings} and \ref{input.output}.
by one or more space characters.
\ensures The \tcode{os.}\textit{fmtflags} and fill character are unchanged.
- & \bigoh{$\text{size of state}$}
+ & \bigoh{\text{size of state}}
\\ \rowsep
\tcode{is >> v}%
& reference to the type of \tcode{is}
@@ -2074,7 +2074,7 @@ according to \ref{strings} and \ref{input.output}.
were respectively the same as those of \tcode{is}.
\ensures The \tcode{is.}\textit{fmtflags} are unchanged.
- & \bigoh{$\text{size of state}$}
+ & \bigoh{\text{size of state}}
\\
\end{libreqtab4d}
--
2.43.0
From 8872d61bba00a1be2b37fc80112bcda70a47a410 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <[email protected]>
Date: Mon, 23 Jan 2017 06:58:26 +0100
Subject: [PATCH 03/13] Reduce excessive indentation of comments. Helps layout
on smaller (e.g. half-screen) window sizes.
---
source/basic.tex | 26 +++++++++++++-------------
source/expressions.tex | 2 +-
2 files changed, 14 insertions(+), 14 deletions(-)
diff --git a/source/basic.tex b/source/basic.tex
index c1873fb0..b340a553 100644
--- a/source/basic.tex
+++ b/source/basic.tex
@@ -284,7 +284,7 @@ Given
#include <string>
struct C {
- std::string s; // \tcode{std::string} is the standard library class\iref{string.classes}
+ std::string s; // \tcode{std::string} is the standard library class\iref{string.classes}
};
int main() {
@@ -2496,23 +2496,23 @@ namespace AB {
void h()
{
- AB::g(); // \tcode{g} is declared directly in \tcode{AB}, therefore \tcode{S} is $\{ \tcode{AB::g()} \}$ and \tcode{AB::g()} is chosen
+ AB::g(); // \tcode{g} is declared directly in \tcode{AB}, therefore \tcode{S} is $\{ \tcode{AB::g()} \}$ and \tcode{AB::g()} is chosen
- AB::f(1); // \tcode{f} is not declared directly in \tcode{AB} so the rules are applied recursively to \tcode{A} and \tcode{B};
- // namespace \tcode{Y} is not searched and \tcode{Y::f(float)} is not considered;
- // \tcode{S} is $\{ \tcode{A::f(int)}, \tcode{B::f(char)} \}$ and overload resolution chooses \tcode{A::f(int)}
+ AB::f(1); // \tcode{f} is not declared directly in \tcode{AB} so the rules are applied recursively to \tcode{A} and \tcode{B};
+ // namespace \tcode{Y} is not searched and \tcode{Y::f(float)} is not considered;
+ // \tcode{S} is $\{ \tcode{A::f(int)}, \tcode{B::f(char)} \}$ and overload resolution chooses \tcode{A::f(int)}
- AB::f('c'); // as above but resolution chooses \tcode{B::f(char)}
+ AB::f('c'); // as above but resolution chooses \tcode{B::f(char)}
- AB::x++; // \tcode{x} is not declared directly in \tcode{AB}, and is not declared in \tcode{A} or \tcode{B}, so the rules
- // are applied recursively to \tcode{Y} and \tcode{Z}, \tcode{S} is $\{ \}$ so the program is ill-formed
+ AB::x++; // \tcode{x} is not declared directly in \tcode{AB}, and is not declared in \tcode{A} or \tcode{B}, so the rules
+ // are applied recursively to \tcode{Y} and \tcode{Z}, \tcode{S} is $\{ \}$ so the program is ill-formed
- AB::i++; // \tcode{i} is not declared directly in \tcode{AB} so the rules are applied recursively to \tcode{A} and \tcode{B},
- // \tcode{S} is $\{ \tcode{A::i}, \tcode{B::i} \}$ so the use is ambiguous and the program is ill-formed
+ AB::i++; // \tcode{i} is not declared directly in \tcode{AB} so the rules are applied recursively to \tcode{A} and \tcode{B},
+ // \tcode{S} is $\{ \tcode{A::i}, \tcode{B::i} \}$ so the use is ambiguous and the program is ill-formed
- AB::h(16.8); // \tcode{h} is not declared directly in \tcode{AB} and not declared directly in \tcode{A} or \tcode{B} so the rules
- // are applied recursively to \tcode{Y} and \tcode{Z}, \tcode{S} is $\{ \tcode{Y::h(int)}, \tcode{Z::h(double)} \}$ and
- // overload resolution chooses \tcode{Z::h(double)}
+ AB::h(16.8); // \tcode{h} is not declared directly in \tcode{AB} and not declared directly in \tcode{A} or \tcode{B} so the rules
+ // are applied recursively to \tcode{Y} and \tcode{Z}, \tcode{S} is $\{ \tcode{Y::h(int)}, \tcode{Z::h(double)} \}$ and
+ // overload resolution chooses \tcode{Z::h(double)}
}
\end{codeblock}
\end{example}
diff --git a/source/expressions.tex b/source/expressions.tex
index 9589921d..6a3d71e9 100644
--- a/source/expressions.tex
+++ b/source/expressions.tex
@@ -2601,7 +2601,7 @@ struct s2 {
}
auto g() {
return [] {
- return [*this] { }; // error: \tcode{*this} not captured by outer \grammarterm{lambda-expression}
+ return [*this] { }; // error: \tcode{*this} not captured by outer \grammarterm{lambda-expression}
}();
}
};
--
2.43.0
From b409f5f8ffe44e3377d9b61dd8433074e32f6cc7 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <[email protected]>
Date: Wed, 1 Feb 2017 03:24:29 +0100
Subject: [PATCH 04/13] Use new link macros.
---
source/algorithms.tex | 4 +-
source/basic.tex | 115 ++++++++--------
source/classes.tex | 24 ++--
source/compatibility.tex | 4 +-
source/concepts.tex | 12 +-
source/containers.tex | 50 +++----
source/declarations.tex | 69 +++++-----
source/diagnostics.tex | 6 +-
source/exceptions.tex | 44 +++---
source/expressions.tex | 279 ++++++++++++++++++++-------------------
source/future.tex | 10 +-
source/intro.tex | 19 +--
source/iostreams.tex | 74 +++++------
source/iterators.tex | 8 +-
source/lex.tex | 10 +-
source/lib-intro.tex | 73 +++++-----
source/limits.tex | 2 +-
source/numerics.tex | 60 ++++-----
source/overloading.tex | 68 +++++-----
source/preprocessor.tex | 14 +-
source/statements.tex | 30 ++---
source/strings.tex | 8 +-
source/support.tex | 107 +++++++--------
source/templates.tex | 129 +++++++++---------
source/threads.tex | 45 +++----
source/time.tex | 10 +-
source/utilities.tex | 20 +--
27 files changed, 640 insertions(+), 654 deletions(-)
diff --git a/source/algorithms.tex b/source/algorithms.tex
index b23120d4..4aa754a4 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -5,7 +5,7 @@
\pnum
This Clause describes components that \Cpp{} programs may use to perform
-algorithmic operations on containers\iref{containers} and other sequences.
+algorithmic operations on \link{containers}{containers} and other sequences.
\pnum
The following subclauses describe components for
@@ -8106,7 +8106,7 @@ In either case, twice as many projections as comparisons.
\pnum
\remarks
-Stable\iref{algorithm.stable}.
+\link{Stable}{algorithm.stable}.
\end{itemdescr}
\begin{itemdecl}
diff --git a/source/basic.tex b/source/basic.tex
index b340a553..5c594c75 100644
--- a/source/basic.tex
+++ b/source/basic.tex
@@ -97,8 +97,8 @@ an object. The variable's name, if any, denotes the reference or object.
\pnum
A \defnadj{local}{entity} is a variable with
-automatic storage duration\iref{basic.stc.auto},
-a structured binding\iref{dcl.struct.bind}
+\link{automatic storage duration}{basic.stc.auto},
+a \link{structured binding}{dcl.struct.bind}
whose corresponding variable is such an entity,
or the \tcode{*\keyword{this}} object\iref{expr.prim.this}.
@@ -128,7 +128,7 @@ the same literal suffix identifier.
\indextext{linkage}%
A name used in more than one translation unit can potentially
refer to the same entity in these translation units depending on the
-linkage\iref{basic.link} of the name specified in each
+\link{linkage}{basic.link} of the name specified in each
translation unit.
\rSec1[basic.def]{Declarations and definitions}
@@ -137,7 +137,7 @@ translation unit.
\indextext{declaration!definition versus}%
\indextext{declaration}%
\indextext{declaration!name}%
-A declaration\iref{dcl.dcl} may (re)introduce
+A \link{declaration}{dcl.dcl} may (re)introduce
one or more names and/or entities into a translation
unit.
If so, the
@@ -150,7 +150,7 @@ A declaration may also have effects including:
\item a static assertion\iref{dcl.pre},
\item controlling template instantiation\iref{temp.explicit},
\item guiding template argument deduction for constructors\iref{temp.deduct.guide},
-\item use of attributes\iref{dcl.attr}, and
+\item use of \link{attributes}{dcl.attr}, and
\item nothing (in the case of an \grammarterm{empty-declaration}).
\end{itemize}
@@ -234,7 +234,7 @@ that defines a function, a class, a variable, or a static data member,
\item it is
an explicit instantiation declaration\iref{temp.explicit}, or
\item it is
-an explicit specialization\iref{temp.expl.spec} whose
+an \link{explicit specialization}{temp.expl.spec} whose
\grammarterm{declaration} is not a definition.
\end{itemize}
A declaration is said to be a \defn{definition} of each entity that it defines.
@@ -276,7 +276,7 @@ In some circumstances, \Cpp{} implementations implicitly define the
default constructor\iref{class.default.ctor},
copy constructor, move constructor\iref{class.copy.ctor},
copy assignment operator, move assignment operator\iref{class.copy.assign},
-or destructor\iref{class.dtor} member functions.
+or \link{destructor}{class.dtor} member functions.
\end{note}
\begin{example}
Given
@@ -360,7 +360,7 @@ defined as follows:
\item If $E$ is an
\grammarterm{id-expression}\iref{expr.prim.id}, the set
contains only $E$.
-\item If $E$ is a subscripting operation\iref{expr.sub} with
+\item If $E$ is a \link{subscripting}{expr.sub} operation with
an array operand, the set contains the potential results of that operand.
\item If $E$ is a class member access
expression\iref{expr.ref} of the form
@@ -370,16 +370,15 @@ the set contains the potential results of $E_1$.
\item If $E$ is a class member access expression
naming a static data member,
the set contains the \grammarterm{id-expression} designating the data member.
-\item If $E$ is a pointer-to-member
-expression\iref{expr.mptr.oper} of the form
+\item If $E$ is a \link{pointer-to-member expression}{expr.mptr.oper} of the form
$E_1$ \tcode{.*} $E_2$,
the set contains the potential results of $E_1$.
\item If $E$ has the form \tcode{($E_1$)}, the set contains the
potential results of $E_1$.
-\item If $E$ is a glvalue conditional
-expression\iref{expr.cond}, the set is the union of the sets of
+\item If $E$ is a glvalue \link{conditional expression}{expr.cond},
+the set is the union of the sets of
potential results of the second and third operands.
-\item If $E$ is a comma expression\iref{expr.comma}, the set
+\item If $E$ is a \link{comma expression}{expr.comma}, the set
contains the potential results of the right operand.
\item Otherwise, the set is empty.
\end{itemize}
@@ -529,8 +528,8 @@ implicitly-defined
copy assignment or move assignment function for another class as specified
in~\ref{class.copy.assign}.
A constructor for a class is odr-used as specified
-in~\ref{dcl.init}. A destructor for a class is odr-used if it is potentially
-invoked\iref{class.dtor}.
+in~\ref{dcl.init}. A destructor for a class is odr-used if it is
+\deflink{potentially invoked}{class.dtor}.
\pnum
A local entity\iref{basic.pre}
@@ -601,7 +600,7 @@ void h() {
\pnum
Every program shall contain at least one definition of every
function or variable that is odr-used in that program
-outside of a discarded statement\iref{stmt.if}; no diagnostic required.
+outside of a \deflink{discarded statement}{stmt.if}; no diagnostic required.
The definition can appear explicitly in the program, it can be found in
the standard or a user-defined library, or (when appropriate) it is
implicitly defined (see~\ref{class.default.ctor}, \ref{class.copy.ctor},
@@ -649,9 +648,9 @@ The rules for declarations and expressions
describe in which contexts complete class types are required. A class
type \tcode{T} must be complete if
\begin{itemize}
-\item an object of type \tcode{T} is defined\iref{basic.def}, or
-\item a non-static class data member of type \tcode{T} is
-declared\iref{class.mem}, or
+\item an object of type \tcode{T} is \link{defined}{basic.def}, or
+\item a non-static class \deflink{data member}{class.mem} of
+type \tcode{T} is declared, or
\item \tcode{T} is used as the allocated type or array element type in a
\grammarterm{new-expression}\iref{expr.new}, or
\item an lvalue-to-rvalue conversion is applied to
@@ -671,10 +670,10 @@ a \keyword{static_cast}\iref{expr.static.cast}, or
\keyword{sizeof} operator\iref{expr.sizeof} is applied to an operand of
type \tcode{T}, or
\item a function with a return type or argument type of type \tcode{T}
-is defined\iref{basic.def} or called\iref{expr.call}, or
+is defined\iref{basic.def} or \link{called}{expr.call}, or
\item a class with a base class of type \tcode{T} is
defined\iref{class.derived}, or
-\item an lvalue of type \tcode{T} is assigned to\iref{expr.ass}, or
+\item an lvalue of type \tcode{T} is \link{assigned to}{expr.ass}, or
\item the type \tcode{T} is the subject of an
\keyword{alignof} expression\iref{expr.alignof}, or
\item an \grammarterm{exception-declaration} has type \tcode{T}, reference to
@@ -717,7 +716,7 @@ template specialization\iref{temp.over}, except that a name can refer to
a non-volatile const object with internal or no linkage if the object
\begin{itemize}
\item has the same literal type in all definitions of \tcode{D},
-\item is initialized with a constant expression\iref{expr.const},
+\item is initialized with a \link{constant expression}{expr.const},
\item is not odr-used in any definition of \tcode{D}, and
\item has the same value in all definitions of \tcode{D},
\end{itemize}
@@ -2691,7 +2690,7 @@ only namespace names are considered.%
\pnum
\indextext{program}%
-A \defn{program} consists of one or more translation units\iref{lex.separate}
+A \defn{program} consists of one or more \deflinkx{translation units}{translation unit}{lex.separate}
linked together. A translation unit consists
of a sequence of declarations.
@@ -2724,7 +2723,7 @@ are attached to the same module.
\indextext{linkage!\idxcode{inline} and}%
\indextext{\idxcode{inline}!linkage of}%
The name of an entity
-that belongs to a namespace scope\iref{basic.scope.namespace}
+that belongs to a \link{namespace scope}{basic.scope.namespace}
has internal linkage if it is the name of
\begin{itemize}
\item
@@ -2765,7 +2764,7 @@ typedef declaration in which the class has the typedef name for linkage
purposes\iref{dcl.typedef}; or
\item
\indextext{enumeration!linkage of}%
-a named enumeration\iref{dcl.enum}, or an unnamed enumeration defined
+a named \link{enumeration}{dcl.enum}, or an unnamed enumeration defined
in a typedef declaration in which the enumeration has the typedef name
for linkage purposes\iref{dcl.typedef}; or
\item an unnamed enumeration
@@ -2841,7 +2840,7 @@ the declaration at line \#3 still redeclares \#1 and receives internal linkage.
\pnum
\indextext{linkage!no}%
Names not covered by these rules have no linkage. Moreover, except as
-noted, a name declared at block scope\iref{basic.scope.block} has no
+noted, a name declared at \deflinkx{block scope}{scope!block}{basic.scope.block} has no
linkage.
\pnum
@@ -3163,8 +3162,8 @@ features of the language, such as references and virtual functions, might
involve additional memory locations that are not accessible to programs but are
managed by the implementation.
\end{note}
-Two or more threads of
-execution\iref{intro.multithread} can access separate memory
+Two or more \deflinkx{threads of
+execution}{thread of execution}{intro.multithread} can access separate memory
locations without interfering with each other.
\pnum
@@ -3208,15 +3207,15 @@ bit-fields \tcode{b} and \tcode{c} cannot be concurrently modified, but
The constructs in a \Cpp{} program create, destroy, refer to, access, and
manipulate objects.
An \defn{object} is created
-by a definition\iref{basic.def},
+by a \link{definition}{basic.def},
by a \grammarterm{new-expression}\iref{expr.new},
by an operation that implicitly creates objects (see below),
-when implicitly changing the active member of a union\iref{class.union},
+when implicitly changing the active member of a \link{union}{class.union},
or
when a temporary object is created\iref{conv.rval,class.temporary}.
An object occupies a region of storage
in its period of construction\iref{class.cdtor},
-throughout its lifetime\iref{basic.life},
+throughout its \link{lifetime}{basic.life},
and
in its period of destruction\iref{class.cdtor}.
\begin{note}
@@ -3346,7 +3345,7 @@ A \defn{potentially-overlapping subobject} is either:
\begin{itemize}
\item a base class subobject, or
\item a non-static data member
-declared with the \tcode{no_unique_address} attribute\iref{dcl.attr.nouniqueaddr}.
+declared with the \link{\tcode{no_unique_address}}{dcl.attr.nouniqueaddr} attribute.
\end{itemize}
\pnum
@@ -3367,7 +3366,7 @@ Otherwise, the circumstances under which the object has zero size
are \impldef{which non-standard-layout objects
containing no data are considered empty}.
\indextext{most derived object!bit-field}%
-Unless it is a bit-field\iref{class.bit},
+Unless it is a \link{bit-field}{class.bit},
an object with nonzero size
shall occupy one or more bytes of storage,
including every byte that is occupied in full or in part
@@ -3932,16 +3931,16 @@ the result of the evaluation is the value so produced but is not erroneous:
is produced by the evaluation of:
\begin{itemize}
\item
- the second or third operand of a conditional expression\iref{expr.cond},
+ the second or third operand of a \link{conditional expression}{expr.cond},
\item
- the right operand of a comma expression\iref{expr.comma},
+ the right operand of a \link{comma expression}{expr.comma},
\item
the operand of a cast or conversion\iref{conv.integral,
expr.type.conv,expr.static.cast,expr.cast}
to an unsigned ordinary character type
or \tcode{std::byte} type\iref{cstddef.syn}, or
\item
- a discarded-value expression\iref{expr.context},
+ a \deflink{discarded-value expression}{expr.context},
\end{itemize}
then the result of the operation is an indeterminate value or
that erroneous value, respectively.
@@ -4132,8 +4131,8 @@ specified in~\ref{class.copy.elision}.
\indextext{storage duration!dynamic|(}
\pnum
-Objects can be created dynamically during program
-execution\iref{intro.execution}, using
+Objects can be created dynamically during \link{program
+execution}{intro.execution}, using
\indextext{\idxcode{new}}%
\grammarterm{new-expression}{s}\iref{expr.new}, and destroyed using
\indextext{\idxcode{delete}}%
@@ -4302,19 +4301,19 @@ that would match a handler\iref{except.handle} of type
\tcode{std::bad_alloc}\iref{bad.alloc}.
\pnum
-A global allocation function is only called as the result of a new
-expression\iref{expr.new}, or called directly using the function call
-syntax\iref{expr.call}, or called indirectly to allocate storage for
+A global allocation function is only called as the result of a \link{new
+expression}{expr.new}, or called directly using the \link{function call}{expr.call}
+syntax, or called indirectly to allocate storage for
a coroutine state\iref{dcl.fct.def.coroutine},
or called indirectly through calls to the
functions in the \Cpp{} standard library.
\begin{note}
In particular, a
global allocation function is not called to allocate storage for objects
-with static storage duration\iref{basic.stc.static}, for objects or references
-with thread storage duration\iref{basic.stc.thread}, for objects of
-type \tcode{std::type_info}\iref{expr.typeid}, or for an
-exception object\iref{except.throw}.
+with \link{static storage duration}{basic.stc.static}, for objects or references
+with \link{thread storage duration}{basic.stc.thread}, for objects of
+type \link{\tcode{std::type_info}}{expr.typeid}, or for an
+\link{exception object}{except.throw}.
\end{note}
\rSec4[basic.stc.dynamic.deallocation]{Deallocation functions}
@@ -4778,9 +4777,9 @@ shall be destroyed before
impose requirements on implementations regarding the representation
of types.
There are two kinds of types: fundamental types and compound types.
-Types describe objects\iref{intro.object},
-references\iref{dcl.ref},
-or functions\iref{dcl.fct}.
+Types describe \link{objects}{intro.object},
+\link{references}{dcl.ref},
+or \link{functions}{dcl.fct}.
\end{note}
\pnum
@@ -4954,7 +4953,7 @@ Arithmetic types\iref{basic.fundamental}, enumeration types,
pointer types, pointer-to-member types\iref{basic.compound},
\tcode{std::nullptr_t},
and
-cv-qualified\iref{basic.type.qualifier} versions of these
+\link{cv-qualified}{basic.type.qualifier} versions of these
types are collectively called
\defnadjx{scalar}{types}{type}.
\label{term.trivially.copyable.type}%
@@ -4979,7 +4978,7 @@ A type is a \defnadj{literal}{type} if it is:
\item a scalar type; or
\item a reference type; or
\item an array of literal type; or
-\item a possibly cv-qualified class type\iref{class} that
+\item a possibly cv-qualified \link{class type}{class} that
has all of the following properties:
\begin{itemize}
\item it has a constexpr destructor\iref{dcl.constexpr},
@@ -5013,8 +5012,8 @@ will be usable in a constant expression.
Two types \cvqual{cv1} \tcode{T1} and \cvqual{cv2} \tcode{T2} are
\defnadjx{layout-compatible}{types}{type}
if \tcode{T1} and \tcode{T2} are the same type,
-layout-compatible enumerations\iref{dcl.enum}, or
-layout-compatible standard-layout class types\iref{class.mem}.
+\deflinkx{layout-compatible enumerations}{layout-compatible!enumeration}{dcl.enum}, or
+\deflinkx{layout-compatible standard-layout class types}{layout-compatible!class}{class.mem}.
\rSec2[basic.fundamental]{Fundamental types}
@@ -5462,7 +5461,7 @@ ordinary pointers to objects or functions.
which identify members of a given
type within objects of a given class, \ref{dcl.mptr}.
Pointers to data members and pointers to member functions are collectively
-called \term{pointer-to-member} types.
+called \defn{pointer-to-member} types.
\end{itemize}
\pnum
@@ -5540,7 +5539,7 @@ layout-compatible types shall
have the same value representation and alignment
requirements\iref{basic.align}.
\begin{note}
-Pointers to over-aligned types\iref{basic.align} have no special
+Pointers to \deflinkx{over-aligned types}{type!over-aligned}{basic.align} have no special
representation, but their range of valid values is restricted by the extended
alignment requirement.
\end{note}
@@ -5855,8 +5854,8 @@ the definition of the usual arithmetic conversions\iref{expr.arith.conv}.
\indextext{program execution|(}
\pnum
-An instance of each object with automatic storage
-duration\iref{basic.stc.auto} is associated with each entry into its
+An instance of each object with \link{automatic storage
+duration}{basic.stc.auto} is associated with each entry into its
block. Such an object exists and retains its last-stored value during
the execution of the block and while the block is suspended (by a call
of a function, suspension of a coroutine\iref{expr.await}, or receipt of a signal).
@@ -5901,7 +5900,7 @@ if $E$ is a \grammarterm{lambda-expression}\iref{expr.prim.lambda},
the initialization of the entities captured by copy and
the constituent expressions of the \grammarterm{initializer} of the \grammarterm{init-capture}{s},
\item
-if $E$ is a function call\iref{expr.call} or implicitly invokes a function,
+if $E$ is a \link{function call}{expr.call} or implicitly invokes a function,
the constituent expressions of each default argument\iref{dcl.fct.default}
used in the call, or
\item
@@ -5932,7 +5931,7 @@ are not subexpressions of a nested unevaluated operand\iref{term.unevaluated.ope
A \defn{full-expression} is
\begin{itemize}
\item
-an unevaluated operand\iref{expr.context},
+an \deflink{unevaluated operand}{expr.context},
\item
a \grammarterm{constant-expression}\iref{expr.const},
\item
diff --git a/source/classes.tex b/source/classes.tex
index 18838fd6..02b6e630 100644
--- a/source/classes.tex
+++ b/source/classes.tex
@@ -178,10 +178,10 @@ A class \tcode{S} is a \defnadj{standard-layout}{class} if it:
\item has no non-static data members of type non-standard-layout class
(or array of such types) or reference,
-\item has no virtual functions\iref{class.virtual} and no
-virtual base classes\iref{class.mi},
+\item has no \link{virtual functions}{class.virtual} and no
+\link{virtual base classes}{class.mi},
-\item has the same access control\iref{class.access}
+\item has the same \link{access control}{class.access}
for all non-static data members,
\item has no non-standard-layout base classes,
@@ -556,7 +556,7 @@ if it is
\end{itemize}
For any other \grammarterm{member-declaration},
each declared entity
-that is not an unnamed bit-field\iref{class.bit}
+that is not an \deflinkx{unnamed bit-field}{bit-field!unnamed}{class.bit}
is a member of the class,
and each such \grammarterm{member-declaration}
shall either
@@ -571,7 +571,7 @@ Nested types are classes\iref{class.name,class.nest} and
enumerations\iref{dcl.enum} declared in the class and arbitrary types
declared as members by use of a typedef declaration\iref{dcl.typedef}
or \grammarterm{alias-declaration}.
-The enumerators of an unscoped enumeration\iref{dcl.enum} defined in the class
+The enumerators of an \link{unscoped enumeration}{dcl.enum} defined in the class
are members of the class.
\pnum
@@ -586,7 +586,7 @@ Any other data member or member function is a \defnadj{non-static}{member}
\defnadj{non-static}{member function}\iref{class.mfct.non.static}, respectively).
\begin{note}
A non-static data member of non-reference
-type is a member subobject of a class object\iref{intro.object}.
+type is a \deflink{member subobject}{intro.object} of a class object.
\end{note}
\pnum
@@ -705,9 +705,9 @@ shall contain a \grammarterm{type-specifier} that is not a \grammarterm{cv-quali
The
\grammarterm{member-declarator-list} can be omitted only after a
\grammarterm{class-specifier} or an \grammarterm{enum-specifier} or in a
-friend declaration\iref{class.friend}. A
+\link{friend declaration}{class.friend}. A
\grammarterm{pure-specifier} shall be used only in the declaration of a
-virtual function\iref{class.virtual}
+\link{virtual function}{class.virtual}
that is not a friend declaration.
\pnum
@@ -810,7 +810,7 @@ unscoped enumeration type; and
\pnum
In addition, if class \tcode{T} has a user-declared
-constructor\iref{class.ctor}, every non-static data member of class
+\link{constructor}{class.ctor}, every non-static data member of class
\tcode{T} shall have a name different from \tcode{T}.
\pnum
@@ -860,7 +860,7 @@ non-static data members (in any order) have layout-compatible
types\iref{term.layout.compatible.type}.
\pnum
-In a standard-layout union with an active member\iref{class.union}
+In a standard-layout union with an \deflinkx{active member}{active!union member}{class.union}
of struct type \tcode{T1}, it is permitted to read a non-static
data member \tcode{m} of another union member of struct type \tcode{T2}
provided \tcode{m} is part of the common initial sequence of \tcode{T1} and \tcode{T2};
@@ -2134,7 +2134,7 @@ by a \grammarterm{new-expression}\iref{expr.new}; the context of the invocation
An array of class type contains several subobjects for each of which
the destructor is invoked.
\end{note}
-A destructor can also be invoked explicitly. A destructor is \term{potentially invoked}
+A destructor can also be invoked explicitly. A destructor is \defn{potentially invoked}
if it is invoked or as specified in~\ref{expr.new},
\ref{stmt.return}, \ref{dcl.init.aggr},
\ref{class.base.init}, and~\ref{except.throw}.
@@ -6215,7 +6215,7 @@ associated with a \grammarterm{try-block} (if there is one),
the copy-initialization of the exception object can be omitted by
constructing $o$ directly into the exception object;
-\item in a coroutine\iref{dcl.fct.def.coroutine}, a copy of a coroutine parameter
+\item in a \link{coroutine}{dcl.fct.def.coroutine}, a copy of a coroutine parameter
can be omitted and references to that copy replaced with references to the
corresponding parameter if the meaning of the program will be unchanged except for
the execution of a constructor and destructor for the parameter copy object;
diff --git a/source/compatibility.tex b/source/compatibility.tex
index 23ba5e4f..83948563 100644
--- a/source/compatibility.tex
+++ b/source/compatibility.tex
@@ -1899,8 +1899,8 @@ deallocation functions\iref{expr.new}.
A conditional expression with a throw expression as its second or third
operand keeps the type and value category of the other operand.
\rationale
-Formerly mandated conversions (lvalue-to-rvalue\iref{conv.lval},
-array-to-pointer\iref{conv.array}, and function-to-pointer\iref{conv.func}
+Formerly mandated conversions (\link{lvalue-to-rvalue}{conv.lval},
+\link{array-to-pointer}{conv.array}, and \link{function-to-pointer}{conv.func}
standard conversions), especially the creation of the temporary due to
lvalue-to-rvalue conversion, were considered gratuitous and surprising.
\effect
diff --git a/source/concepts.tex b/source/concepts.tex
index 4d848e8f..6bd0435e 100644
--- a/source/concepts.tex
+++ b/source/concepts.tex
@@ -300,7 +300,7 @@ classifications, and fundamental type properties.
\begin{itemdecl}
template<class T, class U>
- concept @\defexposconcept{same-as-impl}@ = is_same_v<T, U>; // \expos
+ concept @\defexposconcept{same-as-impl}@ = @\libglobalref{is_same_v}@<T, U>; // \expos
template<class T, class U>
concept @\deflibconcept{same_as}@ = @\exposconcept{same-as-impl}@<T, U> && @\exposconcept{same-as-impl}@<U, T>;
@@ -493,13 +493,13 @@ Users can customize the behavior of \libconcept{common_with} by specializing the
\begin{itemdecl}
template<class T>
- concept @\deflibconcept{integral}@ = is_integral_v<T>;
+ concept @\deflibconcept{integral}@ = @\libglobalref{is_integral_v}@<T>;
template<class T>
- concept @\deflibconcept{signed_integral}@ = @\libconcept{integral}@<T> && is_signed_v<T>;
+ concept @\deflibconcept{signed_integral}@ = @\libconcept{integral}@<T> && @\libglobalref{is_signed_v}@<T>;
template<class T>
concept @\deflibconcept{unsigned_integral}@ = @\libconcept{integral}@<T> && !@\libconcept{signed_integral}@<T>;
template<class T>
- concept @\deflibconcept{floating_point}@ = is_floating_point_v<T>;
+ concept @\deflibconcept{floating_point}@ = @\libglobalref{is_floating_point_v}@<T>;
\end{itemdecl}
\begin{itemdescr}
@@ -748,7 +748,7 @@ types.
\begin{itemdecl}
template<class T>
- concept @\deflibconcept{destructible}@ = is_nothrow_destructible_v<T>;
+ concept @\deflibconcept{destructible}@ = @\libglobalref{is_nothrow_destructible_v}@<T>;
\end{itemdecl}
\begin{itemdescr}
@@ -768,7 +768,7 @@ variable of a given type with a particular set of argument types.
\begin{itemdecl}
template<class T, class... Args>
- concept @\deflibconcept{constructible_from}@ = @\libconcept{destructible}@<T> && is_constructible_v<T, Args...>;
+ concept @\deflibconcept{constructible_from}@ = @\libconcept{destructible}@<T> && @\libglobalref{is_constructible_v}@<T, Args...>;
\end{itemdecl}
\rSec2[concept.default.init]{Concept \cname{default_initializable}}
diff --git a/source/containers.tex b/source/containers.tex
index 6f72fc06..6de14bf9 100644
--- a/source/containers.tex
+++ b/source/containers.tex
@@ -6054,14 +6054,14 @@ namespace std {
\indextext{\idxcode{array}!contiguous storage}%
The header \libheader{array} defines a class template for storing fixed-size
sequences of objects.
-An \tcode{array} is a contiguous container\iref{container.reqmts}.
+An \tcode{array} is a \deflinkx{contiguous container}{container!contiguous}{container.reqmts}.
An instance of \tcode{array<T, N>} stores \tcode{N} elements of type \tcode{T},
so that \tcode{size() == N} is an invariant.
\pnum
\indextext{\idxcode{array}!initialization}%
\indextext{\idxcode{array}!as aggregate}%
-An \tcode{array} is an aggregate\iref{dcl.init.aggr} that can be
+An \tcode{array} is an \deflink{aggregate}{dcl.init.aggr} that can be
list-initialized with up
to \tcode{N} elements whose types are convertible to \tcode{T}.
@@ -6072,8 +6072,8 @@ of a container\iref{container.reqmts} and
of a reversible container\iref{container.rev.reqmts},
except that a default
constructed \tcode{array} object is not empty if $\tcode{N} > 0$.
-An \tcode{array} meets some of the requirements of a sequence
-container\iref{sequence.reqmts}.
+An \tcode{array} meets some of the requirements of a
+\link{sequence container}{sequence.reqmts}.
Descriptions are provided here
only for operations on \tcode{array} that are not described in
one of these tables and
@@ -6083,13 +6083,13 @@ for operations where there is additional semantic information.
\tcode{array<T, N>} is a structural type\iref{term.structural.type} if
\tcode{T} is a structural type.
Two values \tcode{a1} and \tcode{a2} of type \tcode{array<T, N>}
-are template-argument-equivalent\iref{temp.type} if and only if
+are \deflink{template-argument-equivalent}{temp.type} if and only if
each pair of corresponding elements in \tcode{a1} and \tcode{a2}
are template-argument-equivalent.
\pnum
The types \tcode{iterator} and \tcode{const_iterator} meet
-the constexpr iterator requirements\iref{iterator.requirements.general}.
+the \deflinkx{constexpr iterator}{iterator!constexpr}{iterator.requirements.general} requirements.
\indexlibraryglobal{array}%
\indexlibrarymember{array}{begin}%
@@ -6412,7 +6412,7 @@ namespace std {
A
\indexlibraryglobal{deque}%
\tcode{deque}
-is a sequence container that supports random access iterators\iref{random.access.iterators}.
+is a sequence container that supports \link{random access iterators}{random.access.iterators}.
In addition, it supports constant time insert and erase operations at the beginning or the end;
insert and erase in the middle take linear time.
That is, a deque is especially optimized for pushing and popping elements at the beginning and end.
@@ -7063,7 +7063,7 @@ namespace std {
\pnum
An incomplete type \tcode{T} may be used when instantiating \tcode{forward_list}
if the allocator meets the
-allocator completeness requirements\iref{allocator.requirements.completeness}.
+\link{allocator completeness requirements}{allocator.requirements.completeness}.
\tcode{T} shall be complete before any member of the resulting specialization
of \tcode{forward_list} is referenced.
@@ -7646,7 +7646,7 @@ predicate.
\pnum
\remarks
-Stable\iref{algorithm.stable}.
+\link{Stable}{algorithm.stable}.
\end{itemdescr}
\indexlibrarymember{unique}{forward_list}%
@@ -7751,7 +7751,7 @@ Approximately $N \log N$ comparisons, where $N$ is \tcode{distance(begin(), end(
\pnum
\remarks
-Stable\iref{algorithm.stable}.
+\link{Stable}{algorithm.stable}.
\end{itemdescr}
\indexlibrarymember{reverse}{forward_list}%
@@ -7845,7 +7845,7 @@ A
is a sequence container that supports
bidirectional iterators and allows constant time insert and erase
operations anywhere within the sequence, with storage management handled
-automatically. Unlike vectors\iref{vector} and deques\iref{deque},
+automatically. Unlike \link{vectors}{vector} and \link{deques}{deque},
fast random access to list elements is not supported, but many
algorithms only need sequential access anyway.
@@ -8014,7 +8014,7 @@ namespace std {
\pnum
An incomplete type \tcode{T} may be used when instantiating \tcode{list}
if the allocator meets the
-allocator completeness requirements\iref{allocator.requirements.completeness}.
+\link{allocator completeness requirements}{allocator.requirements.completeness}.
\tcode{T} shall be complete before any member of the resulting specialization
of \tcode{list} is referenced.
@@ -8427,7 +8427,7 @@ applications of the corresponding predicate.
\pnum
\remarks
-Stable\iref{algorithm.stable}.
+\link{Stable}{algorithm.stable}.
\end{itemdescr}
\indexlibrarymember{unique}{list}%
@@ -8551,7 +8551,7 @@ comparisons, where
\pnum
\remarks
-Stable\iref{algorithm.stable}.
+\link{Stable}{algorithm.stable}.
\end{itemdescr}
\rSec3[list.erasure]{Erasure}
@@ -8656,7 +8656,7 @@ of an allocator-aware container\iref{container.alloc.reqmts},
of a sequence container, including most of the optional sequence container
requirements\iref{sequence.reqmts},
and, for an element type other than \tcode{bool},
-of a contiguous container\iref{container.reqmts}.
+of a \deflinkx{contiguous container}{container!contiguous}{container.reqmts}.
The exceptions are the
\tcode{push_front}, \tcode{prepend_range}, \tcode{pop_front}, and \tcode{emplace_front} member functions, which are not
provided. Descriptions are provided here only for operations on \tcode{vector}
@@ -8794,7 +8794,7 @@ namespace std {
\pnum
An incomplete type \tcode{T} may be used when instantiating \tcode{vector}
if the allocator meets the
-allocator completeness requirements\iref{allocator.requirements.completeness}.
+\link{allocator completeness requirements}{allocator.requirements.completeness}.
\tcode{T} shall be complete before any member of the resulting specialization
of \tcode{vector} is referenced.
@@ -9362,7 +9362,7 @@ Unless described below, all operations have the same requirements and
semantics as the primary \tcode{vector} template, except that operations
dealing with the \tcode{bool} value type map to bit values in the
container storage and
-\tcode{allocator_traits::construct}\iref{allocator.traits.members}
+\libmemberrefx{allocator_traits::construct}{allocator_traits}{construct}
is not used to construct these values.
\pnum
@@ -14428,9 +14428,9 @@ and
can be used to instantiate
\tcode{queue}.
In particular,
-\tcode{list}\iref{list}
+\link{\tcode{list}}{list}
and
-\tcode{deque}\iref{deque}
+\link{\tcode{deque}}{deque}
can be used.
\begin{codeblock}
@@ -14785,15 +14785,15 @@ and
can be used to instantiate
\tcode{priority_queue}.
In particular,
-\tcode{vector}\iref{vector}
+\link{\tcode{vector}}{vector}
and
-\tcode{deque}\iref{deque}
+\link{\tcode{deque}}{deque}
can be used.
Instantiating
\tcode{priority_queue}
also involves supplying a function or function object for making
priority comparisons; the library assumes that the function or function
-object defines a strict weak ordering\iref{alg.sorting}.
+object defines a \link{strict weak ordering}{alg.sorting}.
\begin{codeblock}
namespace std {
@@ -15332,10 +15332,10 @@ and
can be used to instantiate
\tcode{stack}.
In particular,
-\tcode{vector}\iref{vector},
-\tcode{list}\iref{list}
+\link{\tcode{vector}}{vector},
+\link{\tcode{list}}{list}
and