Consistent OPcache casing

This seems to be the official casing. https://www.php.net/manual/en/book.opcache.php

It's the same one used for php -v.

Author: iluuu1994

Book/php5/build_system/building_extensions.rst

@@ -25,7 +25,7 @@ As an example, consider a PHP build compiled using this configure line::
                            --enable-debug --enable-maintainer-zts \
                            --enable-opcache --with-gmp=shared
 
-In this case both the opcache extension and GMP extension are compiled into shared objects located in the ``modules/``
+In this case both the OPcache extension and GMP extension are compiled into shared objects located in the ``modules/``
 directory. You can load both either by changing the ``extension_dir`` or by passing absolute paths::
 
     ~/php-src> sapi/cli/php -dzend_extension=`pwd`/modules/opcache.so \
@@ -51,7 +51,7 @@ everything else. The reason is simply that building external extensions as share
 intrusive), as you will see in a moment. Another benefit is that you can update the extension without rebuilding PHP.
 
 .. [#] We'll explain the difference between a "normal" extension and a Zend extension later in the book. For now it
-       suffices to know that Zend extensions are more "low level" (e.g. opcache or xdebug) and hook into the workings of
+       suffices to know that Zend extensions are more "low level" (e.g. OPcache or Xdebug) and hook into the workings of
        the Zend Engine itself.
 
 Installing extensions from PECL
@@ -216,12 +216,12 @@ The ``--re`` switch lists all ini settings, constants, functions and classes add
     }
 
 The ``--re`` switch only works for normal extensions, Zend extensions use ``--rz`` instead. You can try this on
-opcache::
+OPcache::
 
     ~/myphp/bin> ./php -dzend_extension=opcache.so --rz "Zend OPcache"
     Zend Extension [ Zend OPcache 7.0.3-dev Copyright (c) 1999-2013 by Zend Technologies <http://www.zend.com/> ]
 
-As you can see, this doesn't display any useful information. The reason is that opcache registers both a normal
+As you can see, this doesn't display any useful information. The reason is that OPcache registers both a normal
 extension and a Zend extension, where the former contains all ini settings, constants and functions. So in this
 particular case you still need to use ``--re``. Other Zend extensions make their information available via ``--rz``
 though.

Book/php5/build_system/building_php.rst

@@ -35,7 +35,7 @@ safety, which is very helpful during development.
 
 Another issue is that nearly all distributions apply additional patches to PHP. In some cases these patches only
 contain minor changes related to configuration, but some distributions make use of highly intrusive patches like
-Suhosin. Some of these patches are known to introduce incompatibilities with low-level extensions like opcache.
+Suhosin. Some of these patches are known to introduce incompatibilities with low-level extensions like OPcache.
 
 PHP only provides support for the software as provided on `php.net`_ and not for the distribution-modified versions. If
 you want to report bugs, submit patches or make use of our help channels for extension-writing, you should always work
@@ -212,12 +212,12 @@ your PHP binary contains using the ``-m`` option. For a default PHP 5.5 build th
     xmlwriter
 
 If you now wanted to stop compiling the CGI SAPI, as well as the tokenizer and sqlite3 extensions and instead enable
-opcache and gmp, the corresponding configure command would be::
+OPcache and gmp, the corresponding configure command would be::
 
     ~/php-src> ./configure --disable-cgi --disable-tokenizer --without-sqlite3 \
                            --enable-opcache --with-gmp
 
-By default most extensions will be compiled statically, i.e. they will be part of the resulting binary. Only the opcache
+By default most extensions will be compiled statically, i.e. they will be part of the resulting binary. Only the OPcache
 extension is shared by default, i.e. it will generate an ``opcache.so`` shared object in the ``modules/`` directory. You
 can compile other extensions into shared objects as well by writing ``--enable-NAME=shared`` or ``--with-NAME=shared``
 (but not all extensions support this). We'll talk about how to make use of shared extensions in the next section.

Book/php7/build_system/building_extensions.rst

@@ -24,7 +24,7 @@ As an example, consider a PHP build compiled using this configure line::
                            --enable-debug --enable-maintainer-zts \
                            --enable-opcache --with-gmp=shared
 
-In this case both the opcache extension and GMP extension are compiled into shared objects located in the ``modules/``
+In this case both the OPcache extension and GMP extension are compiled into shared objects located in the ``modules/``
 directory. You can load both either by changing the ``extension_dir`` or by passing absolute paths::
 
     ~/php-src> sapi/cli/php -dzend_extension=`pwd`/modules/opcache.so \
@@ -218,12 +218,12 @@ The ``--re`` switch lists all ini settings, constants, functions and classes add
     }
 
 The ``--re`` switch only works for normal extensions, Zend extensions use ``--rz`` instead. You can try this on
-opcache::
+OPcache::
 
     ~/myphp/bin> ./php -dzend_extension=opcache --rz "Zend OPcache"
     Zend Extension [ Zend OPcache 7.0.3-dev Copyright (c) 1999-2013 by Zend Technologies <http://www.zend.com/> ]
 
-As you can see, this doesn't display any useful information. The reason is that opcache registers both a normal
+As you can see, this doesn't display any useful information. The reason is that OPcache registers both a normal
 extension and a Zend extension, where the former contains all ini settings, constants and functions. So in this
 particular case you still need to use ``--re``. Other Zend extensions make their information available via ``--rz``
 though.

Book/php7/build_system/building_php.rst

@@ -35,7 +35,7 @@ thread safety, which may be helpful to ensure your extension builds in a thread-
 
 Another issue is that nearly all distributions apply additional patches to PHP. In some cases these patches only
 contain minor changes related to configuration, but some distributions make use of highly intrusive patches like
-Suhosin. Some of these patches are known to introduce incompatibilities with low-level extensions like opcache.
+Suhosin. Some of these patches are known to introduce incompatibilities with low-level extensions like OPcache.
 
 PHP only provides support for the software as provided on `php.net`_ and not for the distribution-modified versions. If
 you want to report bugs, submit patches or make use of our help channels for extension-writing, you should always work
@@ -223,12 +223,12 @@ your PHP binary contains using the ``-m`` option. For a default PHP 7.0 build th
     xmlwriter
 
 If you now wanted to stop compiling the CGI SAPI, as well as the *tokenizer* and *sqlite3* extensions and instead enable
-*opcache* and *gmp*, the corresponding configure command would be::
+*OPcache* and *gmp*, the corresponding configure command would be::
 
     ~/php-src> ./configure --disable-cgi --disable-tokenizer --without-sqlite3 \
                            --enable-opcache --with-gmp
 
-By default most extensions will be compiled statically, i.e. they will be part of the resulting binary. Only the opcache
+By default most extensions will be compiled statically, i.e. they will be part of the resulting binary. Only the OPcache
 extension is shared by default, i.e. it will generate an ``opcache.so`` shared object in the ``modules/`` directory. You
 can compile other extensions into shared objects as well by writing ``--enable-NAME=shared`` or ``--with-NAME=shared``
 (but not all extensions support this). We'll talk about how to make use of shared extensions in the next section.

Book/php7/extensions_design/hooks.rst

@@ -123,7 +123,7 @@ Modifying the Abstract Syntax Tree (AST)
 ****************************************
 
 When PHP 7 compiles PHP code it converts it into an abstract syntax tree (AST)
-before finally generating Opcodes that are persisted in Opcache. The
+before finally generating Opcodes that are persisted in OPcache. The
 ``zend_ast_process hook`` is called for every compiled script and allows you to
 modify the AST after it is parsed and created.
 
@@ -148,13 +148,13 @@ and the result is a ``zend_op_array``.::
     zend_op_array *my_extension_compile_file(zend_file_handle *file_handle, int type);
 
 There are two extensions in PHP core that implement this hook: dtrace and
-opcache.
+OPcache.
 
 - If you start the PHP script with the environment variable ``USE_ZEND_DTRACE``
   and compiled PHP with dtrace support, then ``dtrace_compile_file`` is used
   from ``Zend/zend_dtrace.c``.
 
-- Opcache stores op arrays in shared memory for better performance, so that
+- OPcache stores op arrays in shared memory for better performance, so that
   whenever a script is compiled its final op array is served from a cache and
   not re-compiled. You can find this implementation in
   ``ext/opcache/ZendAccelerator.c``.
@@ -170,12 +170,12 @@ and all PHP scripts compiled after the replacement will be handled by your
 implementation of the hook.
 
 It is very important to always call the original function pointer, otherwise
-PHP cannot compile scripts anymore and Opcache will not work anymore.
+PHP cannot compile scripts anymore and OPcache will not work anymore.
 
 The extension overwriting order here is also important as you need to be aware
-whether you want to register your hook before or after Opcache, because Opcache
+whether you want to register your hook before or after OPcache, because OPcache
 does not call the original function pointer if it finds an opcode array entry
-in its shared memory cache. Opcache registers their hook as a post startup
+in its shared memory cache. OPcache registers their hook as a post startup
 hook, which runs after the minit phase for extensions, so by default your hook
 will not be called anymore when the script gets cached.
 

Book/php7/extensions_design/zend_extensions.rst

@@ -103,7 +103,7 @@ Why need a Zend extension ?
 Let us warn you : until you have **very advanced** knowledge on PHP internal's Vritual Machine, and until you need to
 hook deep into it, you shouldn't need a Zend extension, but a PHP extension will be enough.
 
-Today's most commonly known Zend extensions into PHP's world are OPCache, XDebug, phpdbg and Blackfire. But you know
+Today's most commonly known Zend extensions into PHP's world are OPcache, Xdebug, phpdbg and Blackfire. But you know
 dozens of PHP extensions next to that don't you ?! That's a clear sign that :
 
 * You should not need a Zend extension for a very big part of your problematics
@@ -215,7 +215,7 @@ In *practice*, what we can say about it is that :
   Until some distributions (FreeBSD hear us) change that ...
 
 * Zend extensions are triggered **before** PHP extensions when a request shows in. That means they got a chance to modify
-  the engine about the current request to come, so that PHP extensions use that modified context. OPCache uses such a
+  the engine about the current request to come, so that PHP extensions use that modified context. OPcache uses such a
   trick so that it can perform its complex tasks before any extension had a chance to prevent it to.
 
 * Same for request shutdown : Zend extensions can assume every PHP extension has shut down the request.
@@ -301,7 +301,7 @@ That's all for now. Let's fill-in those empty-body functions now::
 
 Like said before, ``message_handler()`` is a special hook that Zend extensions may declare to be noticed when another
 Zend extension get loaded. But be careful of the order. You must register our "pib" Zend extension first, then
-another Zend extension (like OPCache) after that, as the ``message_handler()`` is only called when a Zend extension is
+another Zend extension (like OPcache) after that, as the ``message_handler()`` is only called when a Zend extension is
 loaded you obviously need to be loaded before to declare it. Chicken and egg.
 
 Then we'll start to dive into the engine, with our ``op_array_handler`` hook::
@@ -479,10 +479,10 @@ How is that possible ? And what for ?.
 Well there are several answers to such a question :
 
 * To :doc:`register new PHP functions <php_functions>`, a PHP extension is better than a Zend extension, as it already
-  knows how to do and has been designed for that specific purpose first. That would be pity not to use it. OPCache
+  knows how to do and has been designed for that specific purpose first. That would be pity not to use it. OPcache
   does that.
 * If you need to register about all the hooks in the full lifecycle, you'll obviously need both sides
-* If you need to master the order Zend extensions are loaded, f.e to get loaded after OPCache, you will need to be
+* If you need to master the order Zend extensions are loaded, f.e to get loaded after OPcache, you will need to be
   hybrid
 
 The trick is simple, choose between :
@@ -656,7 +656,7 @@ Our PHP extension is effectively called "pib" and shows up, and our Zend extensi
 "pib-zend-extension" and shows up as well. We chose two different names for both parts, we could have chosen the same
 name.
 
-.. note:: OPCache and Xdebug use such an hybrid model, they are Zend extensions, but they need to publish PHP
+.. note:: OPcache and Xdebug use such an hybrid model, they are Zend extensions, but they need to publish PHP
           functions and thus they are also PHP extensions to do so.
 
 Hybrid PHP extension master, Zend extension slave

Book/php7/internal_types/strings/zend_strings.rst

@@ -250,9 +250,9 @@ Interned strings
 ----------------
 
 Just a quick word here about `interned strings <https://en.wikipedia.org/wiki/String_interning>`_. You could 
-need such a concept in extension development. Interned strings also interact with OPCache extension.
+need such a concept in extension development. Interned strings also interact with OPcache extension.
 
-Interned strings are deduplicated strings. When used with OPCache, they also get reused from request to request.
+Interned strings are deduplicated strings. When used with OPcache, they also get reused from request to request.
 
 Say you want to create the string "foo". What you tend to do is simply create a new string "foo"::
 
@@ -322,25 +322,25 @@ This process is in fact a little bit more complex than this. If you make use of
 :doc:`request processing <../../extensions_design/php_lifecycle>`, that string will be interned for sure.
 However, if you make use of an interned string as PHP is treating a request, then this string will only get interned for 
 the current request, and will get cleared after that.
-All this is valid if you don't use the OPCache extension, something you shouldn't do : use it.
+All this is valid if you don't use the OPcache extension, something you shouldn't do : use it.
 
-When using the OPCache extension, if you make use of an interned string out of a 
+When using the OPcache extension, if you make use of an interned string out of a 
 :doc:`request processing <../../extensions_design/php_lifecycle>`, that string will be 
 interned for sure and will also be shared to every PHP process or thread that will be spawned by you parallelism layer.
-Also, if you make use of an interned string as PHP is treating a request, this string will also get interned by OPCache 
+Also, if you make use of an interned string as PHP is treating a request, this string will also get interned by OPcache 
 itself, and shared to every PHP process or thread that will be spawned by you parallelism layer.
 
-Interned strings mechanisms are then changed when OPCache extension fires in. OPCache not only allows to intern strings 
+Interned strings mechanisms are then changed when OPcache extension fires in. OPcache not only allows to intern strings 
 that come from a request, but it also allows to share them to every PHP process of the same pool. This is done using 
-shared memory. When saving an interned string, OPCache will also add the ``IS_STR_PERMANENT`` flag to its GC info. 
+shared memory. When saving an interned string, OPcache will also add the ``IS_STR_PERMANENT`` flag to its GC info. 
 That flag means the memory allocation used for the structure (``zend_string`` here) is permanent, it could be a shared 
 read-only memory segment.
 
 Interned strings save memory, because the same string is never stored more than once in memory. But it could waste some
 CPU time as it often needs to lookup the interned strings store, even if that process is well optimized yet.
 As an extension designer, here are global rules:
 
-* If OPCache is used (it should be), and if you need to create read-only strings : use an interned string.
+* If OPcache is used (it should be), and if you need to create read-only strings : use an interned string.
 * If you need a string you know for sure PHP will have interned (a well-known-PHP-string, f.e "php" or "str_replace"),
   use an interned string.
 * If the string is not read-only and could/should be altered after its been created, do not use an interned string.

Book/php7/zend_engine.rst

@@ -3,7 +3,7 @@ Zend engine
 
 The Zend engine is a set of components that make PHP what it is. The most important Zend engine component is the
 *Zend Virtual Machine*, which is composed of the *Zend Compiler* and the *Zend Executor* components. We could also add
-the OPCache zend extension in such category. Those three components are the heart of PHP (or the brain, you choose),
+the OPcache zend extension in such category. Those three components are the heart of PHP (or the brain, you choose),
 they are critical and they are the most complex parts of all the PHP source code. In the current chapter, we'll try to
 open them and detail them.
 

Book/php7/zend_engine/zend_opcache.rst

@@ -1,2 +1,2 @@
-Zend OPCache
+Zend OPcache
 ============

Book/php7/zvals/memory_management.rst

@@ -60,7 +60,7 @@ until (at least) the end of the request.
 
 There are a number of reasons why immutable strings and arrays exist:
 
-  * Any structures stored in opcache shared memory are immutable, because they are shared across multiple processes.
+  * Any structures stored in OPcache shared memory are immutable, because they are shared across multiple processes.
     You can set the ``opcache.protect_memory=1`` ini setting in order to enforce this through ``mprotect()``. This will
     make most immutability violations result in crashes rather than misbehavior.
   * The empty array is declared ``const`` and as such typically allocated in a read-only segment. Attempting to modify