Prime Ddoc pages with SPEC_HEADERNAV_TOC

wilzbach · wilzbach · commit ff7eca887aa6 · 2018-01-08T06:20:21.000+01:00
diff --git a/spec/abi.dd b/spec/abi.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Application Binary Interface,
 
+$(SPEC_HEADERNAV_TOC)
+
 	$(P A D implementation that conforms to the D ABI (Application Binary
 	Interface)
 	will be able to generate libraries, DLL's, etc., that can interoperate
diff --git a/spec/arrays.dd b/spec/arrays.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Arrays,
 
+$(SPEC_HEADERNAV_TOC)
+
 $(H2 $(LNAME2 array-kinds, Kinds))
 
     $(P There are four kinds of arrays:)
diff --git a/spec/attribute.dd b/spec/attribute.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Attributes,
 
+$(SPEC_HEADERNAV_TOC)
+
 $(GRAMMAR
 $(GNAME AttributeSpecifier):
     $(GLINK Attribute) $(D :)
diff --git a/spec/betterc.dd b/spec/betterc.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Better C,
 
+$(SPEC_HEADERNAV_TOC)
+
 `-betterC` is a command-line flag for `dmd`,
 which restricts the compiler's support of certain runtime features.
 Notably, D programs or libraries compiled with `betterC` aren't linked with Druntime.
diff --git a/spec/class.dd b/spec/class.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Classes,
 
+$(SPEC_HEADERNAV_TOC)
+
         $(P The object-oriented features of D all come from classes. The class
         hierarchy
         has as its root the class Object. Object defines a minimum level of functionality
diff --git a/spec/const3.dd b/spec/const3.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(D_S Type Qualifiers,
 
+$(SPEC_HEADERNAV_TOC)
+
 	$(P Type qualifiers modify a type by applying a $(GLINK2 declaration, TypeCtor).
 	$(I TypeCtor)s are: $(D const), $(D immutable),	$(D shared), and $(D inout).
 	Each applies transitively to all subtypes.
diff --git a/spec/contracts.dd b/spec/contracts.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Contract Programming,
 
+$(SPEC_HEADERNAV_TOC)
+
 	$(P Contracts are a breakthrough technique to reduce the programming effort
 	for large projects. Contracts are the concept of preconditions, postconditions,
 	errors, and invariants.
diff --git a/spec/cpp_interface.dd b/spec/cpp_interface.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Interfacing to C++,
 
+$(SPEC_HEADERNAV_TOC)
+
     $(P This document specifies how to interface with C++ directly.)
 
     $(P It is also possible to indirectly interface with C++ code, either
diff --git a/spec/ddoc.dd b/spec/ddoc.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Embedded Documentation,
 
+$(SPEC_HEADERNAV_TOC)
+
 $(P
 The D programming language enables embedding both contracts and test
 code along side the actual code, which helps to keep them all
diff --git a/spec/declaration.dd b/spec/declaration.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Declarations,
 
+$(SPEC_HEADERNAV_TOC)
+
 $(GRAMMAR
 $(GNAME Declaration):
     $(GLINK2 function, FuncDeclaration)
diff --git a/spec/entity.dd b/spec/entity.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Named Character Entities,
 
+$(SPEC_HEADERNAV_TOC)
+
 $(GRAMMAR
 $(GNAME NamedCharacterEntity):
     $(CODE_AMP) $(GLINK2 lex, Identifier) $(D ;)
diff --git a/spec/enum.dd b/spec/enum.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Enums,
 
+$(SPEC_HEADERNAV_TOC)
+
 $(GRAMMAR
 $(GNAME EnumDeclaration):
     $(D enum) $(I Identifier) $(GLINK EnumBody)
diff --git a/spec/errors.dd b/spec/errors.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Error Handling,
 
+$(SPEC_HEADERNAV_TOC)
+
 $(BLOCKQUOTE_BY Julius C'ster,
 I came, I coded, I crashed.
 )
diff --git a/spec/expression.dd b/spec/expression.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Expressions,
 
+$(SPEC_HEADERNAV_TOC)
+
     $(P C and C++ programmers will find the D expressions very familiar,
         with a few interesting additions.
     )
diff --git a/spec/float.dd b/spec/float.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Floating Point,
 
+$(SPEC_HEADERNAV_TOC)
+
 $(H2 $(LNAME2 fp_intermediate_values, Floating Point Intermediate Values))
 
 	$(P On many computers, greater
diff --git a/spec/garbage.dd b/spec/garbage.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Garbage Collection,
 
+$(SPEC_HEADERNAV_TOC)
+
 	$(P D is a systems programming language with support for garbage collection.
 	Usually it is not necessary
 	to free memory explicitly. Just allocate as needed, and the garbage collector will
diff --git a/spec/grammar.dd b/spec/grammar.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Grammar,
 
+$(SPEC_HEADERNAV_TOC)
+
 $(H2 Lexical Syntax)
 
     $(P Refer to the page for $(LINK2 lex.html, lexical syntax).)
diff --git a/spec/hash-map.dd b/spec/hash-map.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Associative Arrays,
 
+$(SPEC_HEADERNAV_TOC)
+
         $(P Associative arrays have an index that is not necessarily an integer,
         and can be sparsely populated. The index for an associative array
         is called the $(I key), and its type is called the $(I KeyType).)
diff --git a/spec/iasm.dd b/spec/iasm.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S D x86 Inline Assembler,
 
+$(SPEC_HEADERNAV_TOC)
+
     $(HTMLTAG3 a,
       href="http://digitalmars.com/gift/index.html" title="Gift Shop" target="_top",
       $(HTMLTAG3V img, src="../images/d5.gif" border="0" align="right" alt="Some Assembly Required" width="284" height="186")
diff --git a/spec/interface.dd b/spec/interface.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Interfaces,
 
+$(SPEC_HEADERNAV_TOC)
+
 $(GRAMMAR
 $(GNAME InterfaceDeclaration):
     $(D interface) $(I Identifier) $(D ;)
diff --git a/spec/interfaceToC.dd b/spec/interfaceToC.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Interfacing to C,
 
+$(SPEC_HEADERNAV_TOC)
+
 	$(P D is designed to fit comfortably with a C compiler for the target
 	system. D makes up for not having its own VM by relying on the
 	target environment's C runtime library. It would be senseless to
diff --git a/spec/lex.dd b/spec/lex.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Lexical,
 
+$(SPEC_HEADERNAV_TOC)
+
 $(P The lexical analysis is independent of the syntax parsing and the semantic
 analysis. The lexical analyzer splits the source text up into tokens. The
 lexical grammar describes the syntax of those tokens. The grammar is designed to
diff --git a/spec/memory-safe-d.dd b/spec/memory-safe-d.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Memory Safety,
 
+$(SPEC_HEADERNAV_TOC)
+
     $(HTMLTAG3 img, src="$(ROOT_DIR)images/dman-rain.jpg" align="right" alt="D-Man in rain" height="200")
 
 	$(P $(I Memory Safety) for a program is defined as it being
diff --git a/spec/module.dd b/spec/module.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Modules,
 
+$(SPEC_HEADERNAV_TOC)
+
 $(GRAMMAR
 $(GNAME Module):
     $(GLINK ModuleDeclaration) $(GLINK DeclDefs)
diff --git a/spec/objc_interface.dd b/spec/objc_interface.dd
@@ -1,6 +1,9 @@
 Ddoc
 
 $(SPEC_S Interfacing to Objective-C,
+
+$(SPEC_HEADERNAV_TOC)
+
     $(P
         D has limited support for interfacing with Objective-C. It supports
         external classes and calling instance methods. It is only available on
diff --git a/spec/operatoroverloading.dd b/spec/operatoroverloading.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Operator Overloading,
 
+$(SPEC_HEADERNAV_TOC)
+
 	$(P Operator overloading is accomplished by rewriting operators whose
 	operands are class or struct objects into calls to specially named
 	member functions. No additional syntax is used.
diff --git a/spec/portability.dd b/spec/portability.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Portability Guide,
 
+$(SPEC_HEADERNAV_TOC)
+
 	$(P It's good software engineering practice to minimize gratuitous
 	portability problems in the code.
 	Techniques to minimize potential portability problems are:
diff --git a/spec/pragma.dd b/spec/pragma.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Pragmas,
 
+$(SPEC_HEADERNAV_TOC)
+
 $(GRAMMAR
 $(GNAME Pragma):
     $(D pragma) $(D $(LPAREN)) $(I Identifier) $(D $(RPAREN))
diff --git a/spec/property.dd b/spec/property.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Properties,
 
+$(SPEC_HEADERNAV_TOC)
+
 	$(P Every type and expression has properties that can be queried:)
 
 $(TABLE2 Property Examples,
diff --git a/spec/simd.dd b/spec/simd.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Vector Extensions,
 
+$(SPEC_HEADERNAV_TOC)
+
 	$(P Modern CPUs often support specialized vector types and vector
 	operations, sometimes called "media instructions".
 	Vector types are a fixed array of floating or integer types, and
diff --git a/spec/statement.dd b/spec/statement.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Statements,
 
+$(SPEC_HEADERNAV_TOC)
+
 C and C++ programmers will find the D statements very familiar, with a few
 interesting additions.
 
diff --git a/spec/struct.dd b/spec/struct.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Structs and Unions,
 
+$(SPEC_HEADERNAV_TOC)
+
          $(P Whereas classes are reference types, structs are value types.
              Any C struct can be exactly represented as a D struct, except non-static
              $(RELATIVE_LINK2 nested, function-nested D structs) which access the context of
diff --git a/spec/template-mixin.dd b/spec/template-mixin.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Template Mixins,
 
+$(SPEC_HEADERNAV_TOC)
+
         $(P A $(I TemplateMixin) takes an arbitrary set of declarations from
         the body of a $(I TemplateDeclaration) and inserts them
         into the current context.)
diff --git a/spec/template.dd b/spec/template.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Templates,
 
+$(SPEC_HEADERNAV_TOC)
+
 $(BLOCKQUOTE_BY Richard Deyman,
 I think that I can safely say that nobody understands C++ template mechanics.)
 
diff --git a/spec/traits.dd b/spec/traits.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Traits,
 
+$(SPEC_HEADERNAV_TOC)
+
 	$(P Traits are extensions to the language to enable
 	programs, at compile time, to get at information
 	internal to the compiler. This is also known as
diff --git a/spec/type.dd b/spec/type.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Types,
 
+$(SPEC_HEADERNAV_TOC)
+
 $(H2 $(LEGACY_LNAME2 Basic Data Types, basic-data-types, Basic Data Types))
 
     $(TABLE_3COLS Basic Data Types,
diff --git a/spec/unittest.dd b/spec/unittest.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Unit Tests,
 
+$(SPEC_HEADERNAV_TOC)
+
 $(GRAMMAR
 $(GNAME UnitTest):
     $(D unittest) $(GLINK2 statement, BlockStatement)
diff --git a/spec/version.dd b/spec/version.dd
@@ -2,6 +2,8 @@ Ddoc
 
 $(SPEC_S Conditional Compilation,
 
+$(SPEC_HEADERNAV_TOC)
+
 	$(P $(I Conditional compilation) is the process of selecting which
 	code to compile and which code to not compile.
 	(In C and C++, conditional compilation is done with the preprocessor
