Editorial change: replace quotation marks by italics

Author: gusthoff

content/booklets/adacore-technologies-for-railway-software/chapters/technology.rst

@@ -175,7 +175,7 @@ Data Flow Analysis (D.10)
 The GNAT Pro toolchain can be configured to detect uninitialized variables
 at run-time through the use of the pragma :ada:`Initialize_Scalars`.
 With this pragma, all scalars are automatically initialized to either an
-out-of-range value (if there is one) or to an "unusual" value (either
+out-of-range value (if there is one) or to an *unusual* value (either
 the largest or smallest).
 This significantly improves detection at test time.
 
@@ -637,7 +637,7 @@ of :ada:`X` and :ada:`Y`. Again, SPARK will analyze the code to check that
 the variable relationships specified are correct.
 
 In this example, an actual variable is used to define data flow.
-It's also possible to create an "abstract" state, implemented by a set of
+It's also possible to create an *abstract* state, implemented by a set of
 variables. Generally speaking, although these notations and verifications
 are quite useful on the lower levels of the architecture, they may not be
 that pertinent at higher levels. SPARK is flexible with regard to where
@@ -785,7 +785,7 @@ Here is an example:
     end Counters;
 
 As a variation on this example, Ada supports encapsulation through
-"getter" and "setter" subprograms.
+*getter* and *setter* subprograms.
 Rather than directly manipulating a global variable declared in a
 package specification, the program can be structured to enforce
 accesses through a procedural interface:
@@ -965,8 +965,8 @@ levels of coupling, through the notions of *child packages* and
 *private packages* as described below.
 In addition, the GNAT Pro technology provides the notion of a *project*,
 which defines a group of packages, possibly with a defined interface.
-These constructs can be used to define a tool-supported notion of "component"
-or "module" at the software level.
+These constructs can be used to define a tool-supported notion of *component*
+or *module* at the software level.
 
 .. index:: Ada language; Coupling between modules
 
@@ -1025,7 +1025,7 @@ GNATmetric has built-in support for retrieving these numbers.
 .. index:: Project (GNAT Pro); GPR files
 
 At a coarser granularity, packages can be grouped together into a
-GNAT Project file ("GPR"), with a clear interface.
+GNAT Project file (*GPR*), with a clear interface.
 An application architecture can be defined as a combination of project files.
 
 Collections of subprograms shall be built providing several level of modules

content/booklets/adacore-technologies-for-railway-software/chapters/tools.rst

@@ -76,8 +76,8 @@ Ada is multi-faceted. From one perspective it is a classical stack-based
 general-purpose language, not tied to any specific development methodology.
 It has a simple syntax, structured control statements, flexible data
 composition facilities, strong type checking, traditional features for code
-modularization ("subprograms"), and a mechanism for detecting and responding
-to exceptional run-time conditions ("exception handling").
+modularization (*subprograms*), and a mechanism for detecting and responding
+to exceptional run-time conditions (*exception handling*).
 But it also includes much more:
 
 .. index:: single: Ada language; Scalar ranges
@@ -163,10 +163,10 @@ Programming in the large
 ^^^^^^^^^^^^^^^^^^^^^^^^
 
 The original Ada 83 design introduced the package construct,
-a feature that supports encapsulation ("information hiding") and
+a feature that supports encapsulation (*information hiding*) and
 modularization, and which allows the developer to control the
 namespace that is accessible within a given compilation unit. Ada 95
-introduced the concept of "child units," adding considerable flexibility
+introduced the concept of *child units*, adding considerable flexibility
 and easing the design of very large systems.
 Ada 2005 extended the language's modularization facilities by allowing
 certain kinds of mutual references between package specifications,
@@ -180,7 +180,7 @@ Generic Templates
 A key to reusable components is a mechanism for parameterizing modules
 with respect to data types and other program entities, for example a
 stack package for an arbitrary element type. Ada meets this requirement
-through a facility known as "generics"; since the parameterization is done
+through a facility known as *generics*; since the parameterization is done
 at compile time, run-time performance is not penalized.
 
 .. index:: single: Ada language; Object-Oriented Programming (OOP)
@@ -199,10 +199,10 @@ performance.
 However, large real-time systems often have components such as GUIs that do
 not have real-time constraints and that could be most effectively developed
 using OOP features. In part for this reason, Ada 95 supplies comprehensive
-support for OOP, through its "tagged type" facility: classes, polymorphism,
+support for OOP, through its *tagged type* facility: classes, polymorphism,
 inheritance, and dynamic binding. Ada 95 does not require automatic garbage
 collection but rather supplies definitional features allowing the developer
-to supply type-specific storage reclamation operations ("finalization").
+to supply type-specific storage reclamation operations (*finalization*).
 Ada 2005 brought additional OOP features including Java-like interfaces and
 traditional :ada:`obj.op(...)` operation invocation notation.
 
@@ -217,10 +217,10 @@ Concurrent Programming
 ^^^^^^^^^^^^^^^^^^^^^^
 
 Ada supplies a structured, high-level facility for concurrency. The unit of
-concurrency is a program entity known as a "task". Tasks can communicate
+concurrency is a program entity known as a *task*. Tasks can communicate
 implicitly via shared data or explicitly via a synchronous control mechanism
 known as the rendezvous. A shared data item can be defined abstractly as a
-"protected object" (a feature introduced in Ada 95), with operations executed
+*protected object* (a feature introduced in Ada 95), with operations executed
 under mutual exclusion when invoked from multiple tasks.
 Protected objects provide the functionality of semaphores and condition
 variables but more clearly and reliably (e.g., avoiding subtle race
@@ -237,7 +237,7 @@ multi-core architectures were introduced in Ada 2012.
 Systems Programming
 ^^^^^^^^^^^^^^^^^^^
 
-Both in the "core" language and the Systems Programming Annex, Ada supplies
+Both in the *core* language and the Systems Programming Annex, Ada supplies
 the necessary features for hardware-specific processing.
 For example, the programmer can specify the bit layout for fields in a record,
 define alignment and size properties, place data at specific machine
@@ -412,7 +412,7 @@ is compiled.
 
 In addition, the language supports mathematical proof and can thus provide
 high confidence that the software meets a range of assurance requirements:
-from the absence of run-time errors ("AORTE"), to the enforcement of safety
+from the absence of run-time errors (*AORTE*), to the enforcement of safety
 or security properties, to compliance with a formal specification of the
 program's required behavior.
 
@@ -446,7 +446,7 @@ automated tools.
 Hybrid Verification
 ~~~~~~~~~~~~~~~~~~~
 
-SPARK supports "hybrid verification", which combines testing and
+SPARK supports *hybrid verification*, which combines testing and
 formal proofs.
 As an example, an existing project in Ada and C can adopt SPARK to implement
 new functionality for critical components. The SPARK units can be analyzed
@@ -496,7 +496,7 @@ GNAT Pro Assurance is a specialized version of the GNAT Pro development
 environment, available for any of the products in the GNAT Pro family:
 GNAT Pro for Ada, GNAT Pro for C, GNAT Pro for C++, and GNAT Pro for Rust.
 It is targeted to projects
-requiring customized support, including bug fixes and "known problems"
+requiring customized support, including bug fixes and *known problems*
 analyses, on a specific version of the toolchain. This service is
 especially suitable for applications with long maintenance cycles or
 certification requirements, since critical updates to the compiler or
@@ -853,7 +853,7 @@ GNATtest
 The GNATtest tool helps create and maintain a complete unit testing
 infrastructure for complex projects. It captures
 the simple idea that each public subprogram (these are known as
-"visible" subprograms in Ada) should have at least one corresponding
+*visible* subprograms in Ada) should have at least one corresponding
 unit test. GNATtest takes a project file as input, and produces two outputs:
 
 * The complete harnessing code for executing all the unit tests under
@@ -1049,7 +1049,7 @@ appearance to be customized in the editor.
 
 GNAT Studio is intuitive to new users thanks to its menu-driven interface
 with extensive online help (including documentation on all the
-menu selections) and "tool tips". The Project Wizard makes it simple to get
+menu selections) and *tool tips*. The Project Wizard makes it simple to get
 started, supplying default values for almost all of the project properties.
 For experienced users, it offers the necessary level of control for
 advanced purposes; e.g., the ability to run command scripts. Anything that