Backup of today's work. Still awaiting a couple more editorial inputs.
[dwarf-doc.git] / dwarf5 / latexdoc / typeentries.tex
index 7b70c13..4cc52a2 100644 (file)
@@ -313,6 +313,7 @@ with a \DWATpicturestringDEFN{} attribute whose value is a
 null\dash terminated string containing the target\dash dependent picture
 string associated with the type.
 
+\needlines{4}
 If the edited base type entry describes an edited numeric
 data type, the edited type entry has a \DWATdigitcount{} and a
 \DWATdecimalscale{} attribute.\addtoindexx{decimal scale attribute}
@@ -395,17 +396,66 @@ in different languages. A type modifier is represented in
 DWARF by a debugging information entry with one of the tags
 given in Table \refersec{tab:typemodifiertags}.
 
+\begin{table}[h]
+\caption{Type modifier tags}
+\label{tab:typemodifiertags}
+\centering
+\begin{tabular}{l|P{9cm}}
+\hline
+Name&Meaning\\ \hline
+\DWTAGatomictypeTARG{} & 
+    atomic qualified type 
+    (for example, in C) 
+    \addtoindexx{atomic qualified type entry} \addtoindexx{C} \\
+\DWTAGconsttypeTARG{} &  
+    const qualified type 
+    (for example in C, C++)
+    \addtoindexx{const qualified type entry} \addtoindexx{C} \addtoindexx{C++} \\
+\DWTAGimmutabletypeTARG &
+    immutable type 
+    (for example, in \addtoindex{D})
+    \addtoindexx{immutable type} \\
+\DWTAGpackedtypeTARG & 
+    packed type\addtoindexx{packed type entry} 
+    (for example in Ada, Pascal)
+    \addtoindexx{packed qualified type entry} \addtoindexx{Ada} \addtoindexx{Pascal} \\
+\DWTAGpointertypeTARG{} & 
+    pointer to an object of the type being modified 
+    \addtoindexx{pointer qualified type entry} \\
+\DWTAGreferencetypeTARG & 
+    reference to (lvalue of) an object of the type \mbox{being} modified 
+    \addtoindexx{reference type entry}
+    \addtoindexx{reference qualified type entry} \\
+\DWTAGrestricttypeTARG &  
+    restrict qualified type
+    \addtoindexx{restricted type entry}
+    \addtoindexx{restrict qualified type} \addtoindexx{C} \\
+\DWTAGrvaluereferencetypeTARG{} &
+    rvalue reference to an object of the type \mbox{being} modified  
+    (for example, in \addtoindex{C++}) 
+    \addtoindexx{rvalue reference type entry}
+    \addtoindexx{restricted type entry}
+    \addtoindexx{rvalue reference qualified type entry} \\
+\DWTAGsharedtypeTARG &
+    shared qualified type 
+    (for example, in \addtoindex{UPC}) 
+    \addtoindexx{shared qualified type entry} \\
+\DWTAGvolatiletypeTARG & 
+    volatile qualified type 
+    (for example, in \addtoindex{C}, \addtoindex{C++}) 
+    \addtoindexx{volatile qualified type entry} \\
+\hline
+\end{tabular}
+\end{table}
+
 If a name has been given to the modified type in the source
 program, then the corresponding modified type entry has
-a \DWATname{} attribute 
-\addtoindexx{name attribute}
-whose value is a null\dash terminated
-string containing the modified type name. 
+a \DWATname{} attribute\addtoindexx{name attribute}
+whose value is a null-terminated string containing
+the name of the modified type. 
 
-Each of the type modifier entries has 
-\addtoindexx{type attribute}
-a 
-\DWATtype{} attribute,
+Each of the type modifier entries has a 
+\DWATtype{} attribute\addtoindexx{type attribute},
 whose value is a \livelink{chap:classreference}{reference} 
 to a debugging information entry
 describing a base type, a user-defined type or another type
@@ -456,68 +506,20 @@ source
 \addtoindexx{parameter|see{formal parameter entry}}
 presentation.
 
-\begin{table}[ht]
-\caption{Type modifier tags}
-\label{tab:typemodifiertags}
-\centering
-\begin{tabular}{l|P{9cm}}
-\hline
-Name&Meaning\\ \hline
-\DWTAGatomictypeTARG{} & 
-    atomic qualified type 
-    (for example, in C) 
-    \addtoindexx{atomic qualified type entry} \addtoindexx{C} \\
-\DWTAGconsttypeTARG{} &  
-    const qualified type 
-    (for example in C, C++)
-    \addtoindexx{const qualified type entry} \addtoindexx{C} \addtoindexx{C++} \\
-\DWTAGimmutabletypeTARG &
-    immutable type 
-    (for example, in \addtoindex{D})
-    \addtoindexx{immutable type} \\
-\DWTAGpackedtypeTARG & 
-    packed type\addtoindexx{packed type entry} 
-    (for example in Ada, Pascal)
-    \addtoindexx{packed qualified type entry} \addtoindexx{Ada} \addtoindexx{Pascal} \\
-\DWTAGpointertypeTARG{} & 
-    pointer to an object of the type being modified 
-    \addtoindexx{pointer qualified type entry} \\
-\DWTAGreferencetypeTARG & 
-    reference to (lvalue of) an object of the type \mbox{being} modified 
-    \addtoindexx{reference type entry}
-    \addtoindexx{reference qualified type entry} \\
-\DWTAGrestricttypeTARG &  
-    restrict qualified type
-    \addtoindexx{restricted type entry}
-    \addtoindexx{restrict qualified type} \addtoindexx{C} \\
-\DWTAGrvaluereferencetypeTARG{} &
-    rvalue reference to an object of the type \mbox{being} modified  
-    (for example, in \addtoindex{C++}) 
-    \addtoindexx{rvalue reference type entry}
-    \addtoindexx{restricted type entry}
-    \addtoindexx{rvalue reference qualified type entry} \\
-\DWTAGsharedtypeTARG &
-    shared qualified type 
-    (for example, in \addtoindex{UPC}) 
-    \addtoindexx{shared qualified type entry} \\
-\DWTAGvolatiletypeTARG & 
-    volatile qualified type 
-    (for example, in \addtoindex{C}, \addtoindex{C++}) 
-    \addtoindexx{volatile qualified type entry} \\
-\hline
-\end{tabular}
-\end{table}
+\bb
+Examples of modified types are shown in Figure \refersec{fig:typemidifierexamples}.
+\eb
 
-\needlines{6}
+\begin{figure}[t]
 \textit{As examples of how type modifiers are ordered, consider the following
 \addtoindex{C} declarations:}
 \par % Needed to end paragraph before listing so that it gets a line number
 \begin{nlnlisting}
-   const unsigned char * volatile p;
+    const unsigned char * volatile p;
 \end{nlnlisting}
 
 \textit{This represents a volatile pointer to a constant
-character. It is encoded in DWARF as:}
+character. It is encoded in DWARF as}
 \par % Needed to end paragraph before listing so that it gets a line number
 \nolinenumbers
 \begin{dwflisting}
@@ -530,16 +532,12 @@ character. It is encoded in DWARF as:}
 \end{alltt}
 \end{dwflisting}
 
-\condlinenumbers
 \textit{On the other hand}
-\par % Needed to end paragraph before listing so that it gets a line number
 \begin{nlnlisting}                        
-   volatile unsigned char * const restrict p;
+    volatile unsigned char * const restrict p;
 \end{nlnlisting}
 \textit{represents a restricted constant
-pointer to a volatile character. This is encoded as:}
-\par % Needed to end paragraph before listing so that it gets a line number
-\nolinenumbers
+pointer to a volatile character. This is encoded as}
 \begin{dwflisting}
 \begin{alltt}
         \DWTAGvariable(p) -->
@@ -551,7 +549,10 @@ pointer to a volatile character. This is encoded as:}
 \end{alltt}
 \end{dwflisting}
 
-\condlinenumbers
+\caption{Type modifier examples}
+\label{fig:typemidifierexamples}
+\end{figure}
+
 \section{Typedef Entries}
 \label{chap:typedefentries}
 A named type that is defined in terms of another type
@@ -573,6 +574,7 @@ the debugging information entry for a typedef represents
 a declaration of the type that is not also a definition,
 it does not contain a type attribute.
 
+\needlines{4}
 \textit{Depending on the language, a named type that is defined in
 terms of another type may be called a type alias, a subtype,
 a constrained type and other terms. A type name declared with
@@ -659,7 +661,6 @@ amount of storage needed to hold an instance of the array type.
 compile time, this value can usually be computed by multiplying
 the number of array elements by the size of each element.}
 
-
 Each array dimension is described by a debugging information
 entry with either the 
 \addtoindexx{subrange type entry!as array dimension}
@@ -719,6 +720,7 @@ coarray type in the source, then the corresponding coarray type
 entry has a \DWATname{} attribute whose value is a null-terminated 
 string containing the array type name.
 
+\needlines{4}
 A coarray entry has one or more \DWTAGsubrangetype{} child entries,
 one for each codimension. It also has a \DWATtype{} attribute 
 describing the type of each element of the coarray.
@@ -775,6 +777,7 @@ in the following discussion, statements about
 \addtoindex{C++} classes may
 be understood to apply to \addtoindex{C++} structures as well.}
 
+\needlines{6}
 \subsection{Structure, Union and Class Type Entries}
 \label{chap:structureunionandclasstypeentries}
 Structure, union, and class types are represented by debugging
@@ -1209,6 +1212,26 @@ of storage needed to hold the value of the data member.
 see Appendix \refersec{app:pascalexample} and 
 \refersec{app:ccppbitfieldexamples}.}
 
+\bb
+\subsection{Member Variable Entries}
+\label{chap:membervariableentries}
+
+A member variable (\doublequote{static data member} in 
+\addtoindex{C++}) is represented by a
+debugging information entry with the tag \DWTAGvariable.
+
+The member variable entry
+may contain the same attributes and follows the same rules
+as non-member global variable entries
+(see Section \refersec{chap:dataobjectentries}).
+
+A member variable entry may have a
+\hyperlink{chap:DWATaccessibilityattribute}{\DWATaccessibilityNAME}
+\addtoindexx{accessibility attribute}
+attribute. If no accessibility attribute is present, private
+access is assumed for an entry of a class and public access
+is assumed for an entry of a structure, union or interface.
+\eb
 
 \subsection{Member Function Entries}
 \label{chap:memberfunctionentries}