Update documentation that was pointing to deprecated or removed function.

doc/extending/ctype.txt

@@ -515,31 +515,43 @@ You can implement c_code for this op. You register it like this:
 
 .. code-block:: python
 
-   theano.compile.function_module.register_DeepCopyOp_c_code(YOUR_TYPE_CLASS, THE_C_CODE)
+   theano.compile.ops.register_deep_copy_op_c_code(YOUR_TYPE_CLASS, THE_C_CODE, version=())
 
 In your C code, you should use %(iname)s and %(oname)s to represent
 the C variable names of the DeepCopyOp input and output
-respectively. See an example for the type ``CudaNdarrayType`` (GPU array)
-in the file `theano/sandbox/cuda/type.py`.
+respectively. See an example for the type ``CudaNdarrayType`` (GPU
+array) in the file `theano/sandbox/cuda/type.py`. The version
+parameter is what is returned by DeepCopyOp.c_code_cache_version(). By
+default, it will recompile the c code for each process.
 
-Output Guard
-============
+ViewOp
+======
 
-We have an internal Op called OutputGuard. It is used for some
+We have an internal Op called ViewOp. It is used for some
 verification of inplace/view Ops. Its C implementation increments and
 decrements Python reference counts, and thus only works with Python
 objects. If your new type represents Python objects, you should tell
-OutputGuard to generate C code when working with this type, as
+ViewOp to generate C code when working with this type, as
 otherwise it will use Python code instead. This is achieved by
 calling:
 
 .. code-block:: python
 
-   theano.compile.mode.register_OutputGuard_c_code(YOUR_TYPE_CLASS)
+   theano.compile.ops.register_view_op_c_code(YOUR_TYPE_CLASS, THE_C_CODE, version=())
 
-Note that you should not call ``register_OutputGuard_c_code`` with your
-new type if this type is not associated to Python objects in the C code,
-as otherwise the reference count mechanism will crash. For instance,
-the ``Double`` type described here is associated to ``double`` objects
-in the C code, and consequently this type should not be registered in
-OutputGuard.
+The version parameter is what is returned by
+DeepCopyOp.c_code_cache_version(). By default, it will recompile the c
+code for each process.
+
+.. note::
+
+   This is an old note. I'm note sure if it is still true or
+   not. register_OutputGuard_c_code have already been replaced with
+   register_view_op_c_code. We need to check what happen in that case.
+
+   Note that you should not call ``register_OutputGuard_c_code`` with
+   your new type if this type is not associated to Python objects in
+   the C code, as otherwise the reference count mechanism will
+   crash. For instance, the ``Double`` type described here is
+   associated to ``double`` objects in the C code, and consequently
+   this type should not be registered in OutputGuard.

theano/compile/mode.py

@@ -388,7 +388,7 @@ def register_mode(name, mode):
 def register_OutputGuard_c_code(type):
     """Deprecated function calling register_view_op_c_code"""
     warnings.warn("register_OutputGuard_c_code(type) is deprecated, "
-            "theano.compile.register_view_op_c_code(type, code) instead.",
+            "theano.compile.register_view_op_c_code(type, code, version=()) instead.",
             stacklevel=2)
     register_view_op_c_code(
             type,