Commits

BarryFSmith committed 1c84c29

removed XXXRegisterDynamic() but kept the APIs for everything else underneath the same
phase I of the update to handling registering function pointers

  • Participants
  • Parent commits 9d3f82b

Comments (0)

Files changed (71)

include/petsc-private/threadcommimpl.h

 /* register thread communicator models */
 PETSC_EXTERN PetscErrorCode PetscThreadCommRegister(const char[],const char[],const char[],PetscErrorCode(*)(PetscThreadComm));
 PETSC_EXTERN PetscErrorCode PetscThreadCommRegisterAll(const char path[]);
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define PetscThreadCommRegisterDynamic(a,b,c,d) PetscThreadCommRegister(a,b,c,0)
-#else
-#define PetscThreadCommRegisterDynamic(a,b,c,d) PetscThreadCommRegister(a,b,c,d)
-#endif
 
 #undef __FUNCT__
 #define __FUNCT__

include/petscao.h

 PETSC_EXTERN PetscErrorCode AORegisterAll(const char []);
 PETSC_EXTERN PetscErrorCode AORegisterDestroy(void);
 
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define AORegisterDynamic(a,b,c,d) AORegister(a,b,c,0)
-#else
-#define AORegisterDynamic(a,b,c,d) AORegister(a,b,c,d)
-#endif
-
 PETSC_EXTERN PetscErrorCode AOPetscToApplication(AO,PetscInt,PetscInt[]);
 PETSC_EXTERN PetscErrorCode AOApplicationToPetsc(AO,PetscInt,PetscInt[]);
 PETSC_EXTERN PetscErrorCode AOPetscToApplicationIS(AO,IS);

include/petsccharacteristic.h

 
 PETSC_EXTERN PetscErrorCode CharacteristicRegister(const char[],const char[],const char[],PetscErrorCode (*)(Characteristic));
 
-/*MC
-   CharacteristicRegisterDynamic - Adds a solver to the method of characteristics package.
-
-   Synopsis:
-   #include "petsccharacteristic.h"
-   PetscErrorCode CharacteristicRegisterDynamic(const char *name_solver,const char *path,const char *name_create,PetscErrorCode (*routine_create)(Characteristic))
-
-   Not Collective
-
-   Input Parameters:
-+  name_solver - name of a new user-defined solver
-.  path - path (either absolute or relative) the library containing this solver
-.  name_create - name of routine to create method context
--  routine_create - routine to create method context
-
-   Notes:
-   CharacteristicRegisterDynamic() may be called multiple times to add several user-defined solvers.
-
-   If dynamic libraries are used, then the fourth input argument (routine_create)
-   is ignored.
-
-   Sample usage:
-.vb
-   CharacteristicRegisterDynamic("my_solver",/home/username/my_lib/lib/libO/solaris/mylib.a,
-               "MySolverCreate",MySolverCreate);
-.ve
-
-   Then, your solver can be chosen with the procedural interface via
-$     CharacteristicSetType(ksp,"my_solver")
-   or at runtime via the option
-$     -characteristic_type my_solver
-
-   Level: advanced
-
-   Notes: Environmental variables such as ${PETSC_ARCH}, ${PETSC_DIR}, ${PETSC_LIB_DIR},
-          and others of the form ${any_environmental_variable} occuring in pathname will be
-          replaced with appropriate values.
-         If your function is not being put into a shared library then use CharacteristicRegister() instead
-
-.keywords: Characteristic, register
-
-.seealso: CharacteristicRegisterAll(), CharacteristicRegisterDestroy()
-
-M*/
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define CharacteristicRegisterDynamic(a,b,c,d) CharacteristicRegister(a,b,c,0)
-#else
-#define CharacteristicRegisterDynamic(a,b,c,d) CharacteristicRegister(a,b,c,d)
-#endif
-
 #endif /*__PETSCCHARACTERISTICS_H*/

include/petscdm.h

 PETSC_EXTERN PetscErrorCode DMRegisterAll(const char []);
 PETSC_EXTERN PetscErrorCode DMRegisterDestroy(void);
 
-
-/*MC
-  DMRegisterDynamic - Adds a new DM component implementation
-
-  Synopsis:
-  #include "petscdm.h"
-  PetscErrorCode DMRegisterDynamic(const char *name,const char *path,const char *func_name, PetscErrorCode (*create_func)(DM))
-
-  Not Collective
-
-  Input Parameters:
-+ name        - The name of a new user-defined creation routine
-. path        - The path (either absolute or relative) of the library containing this routine
-. func_name   - The name of routine to create method context
-- create_func - The creation routine itself
-
-  Notes:
-  DMRegisterDynamic() may be called multiple times to add several user-defined DMs
-
-  If dynamic libraries are used, then the fourth input argument (routine_create) is ignored.
-
-  Sample usage:
-.vb
-    DMRegisterDynamic("my_da","/home/username/my_lib/lib/libO/solaris/libmy.a", "MyDMCreate", MyDMCreate);
-.ve
-
-  Then, your DM type can be chosen with the procedural interface via
-.vb
-    DMCreate(MPI_Comm, DM *);
-    DMSetType(DM,"my_da_name");
-.ve
-   or at runtime via the option
-.vb
-    -da_type my_da_name
-.ve
-
-  Notes: $PETSC_ARCH occuring in pathname will be replaced with appropriate values.
-         If your function is not being put into a shared library then use DMRegister() instead
-
-  Level: advanced
-
-.keywords: DM, register
-.seealso: DMRegisterAll(), DMRegisterDestroy(), DMRegister()
-M*/
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define DMRegisterDynamic(a,b,c,d) DMRegister(a,b,c,0)
-#else
-#define DMRegisterDynamic(a,b,c,d) DMRegister(a,b,c,d)
-#endif
-
 PETSC_EXTERN PetscErrorCode DMView(DM,PetscViewer);
 PETSC_EXTERN PetscErrorCode DMLoad(DM,PetscViewer);
 PETSC_EXTERN PetscErrorCode DMDestroy(DM*);

include/petscdraw.h

 
 PETSC_EXTERN PetscErrorCode PetscDrawRegister(const char*,const char*,const char*,PetscErrorCode(*)(PetscDraw));
 
-/*MC
-   PetscDrawRegisterDynamic - Adds a method to the graphics package.
-
-   Synopsis:
-   #include "petscdraw.h"
-   PetscErrorCode PetscDrawRegisterDynamic(const char *name_solver,const char *path,const char *name_create,PetscErrorCode (*routine_create)(PetscDraw))
-
-   Not Collective
-
-   Input Parameters:
-+  name_solver - name of a new user-defined solver
-.  path - path (either absolute or relative) the library containing this solver
-.  name_create - name of routine to create method context
--  routine_create - routine to create method context
-
-   Level: developer
-
-   Notes:
-   PetscDrawRegisterDynamic() may be called multiple times to add several user-defined solvers.
-
-   If dynamic libraries are used, then the fourth input argument (routine_create)
-   is ignored.
-
-   Sample usage:
-.vb
-   PetscDrawRegisterDynamic("my_draw_type",/home/username/my_lib/lib/libO/solaris/mylib.a,
-               "MyDrawCreate",MyDrawCreate);
-.ve
-
-   Then, your solver can be chosen with the procedural interface via
-$     PetscDrawSetType(ksp,"my_draw_type")
-   or at runtime via the option
-$     -draw_type my_draw_type
-
-   Concepts: graphics^registering new draw classes
-   Concepts: PetscDraw^registering new draw classes
-
-.seealso: PetscDrawRegisterAll(), PetscDrawRegisterDestroy()
-M*/
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define PetscDrawRegisterDynamic(a,b,c,d) PetscDrawRegister(a,b,c,0)
-#else
-#define PetscDrawRegisterDynamic(a,b,c,d) PetscDrawRegister(a,b,c,d)
-#endif
-
 PETSC_EXTERN PetscErrorCode PetscDrawGetType(PetscDraw,PetscDrawType*);
 PETSC_EXTERN PetscErrorCode PetscDrawSetType(PetscDraw,PetscDrawType);
 PETSC_EXTERN PetscErrorCode PetscDrawCreate(MPI_Comm,const char[],const char[],int,int,int,int,PetscDraw*);

include/petscis.h

 PETSC_EXTERN PetscErrorCode ISRegisterDestroy(void);
 PETSC_EXTERN PetscErrorCode ISCreate(MPI_Comm,IS*);
 
-/*MC
-  ISRegisterDynamic - Adds a new index set implementation
-
-  Synopsis:
-  #include "petscis.h"
-  PetscErrorCode ISRegisterDynamic(const char *name, const char *path, const char *func_name, PetscErrorCode (*create_func)(IS))
-
-  Not Collective
-
-  Input Parameters:
-+ name        - The name of a new user-defined creation routine
-. path        - The path (either absolute or relative) of the library containing this routine
-. func_name   - The name of routine to create method context
-- create_func - The creation routine itself
-
-  Notes:
-  ISRegisterDynamic() may be called multiple times to add several user-defined vectors
-
-  If dynamic libraries are used, then the fourth input argument (routine_create) is ignored.
-
-  Sample usage:
-.vb
-    ISRegisterDynamic("my_is_name","/home/username/my_lib/lib/libO/solaris/libmy.a", "MyISCreate", MyISCreate);
-.ve
-
-  Then, your vector type can be chosen with the procedural interface via
-.vb
-    ISCreate(MPI_Comm, IS *);
-    ISSetType(IS,"my_is_name");
-.ve
-   or at runtime via the option
-.vb
-    -is_type my_is_name
-.ve
-
-  Notes: $PETSC_ARCH occuring in pathname will be replaced with appropriate values.
-         If your function is not being put into a shared library then use ISRegister() instead
-
-  This is no ISSetFromOptions() and the current implementations do not have a way to dynamically determine type, so
-  dynamic registration of custom IS types will be of limited use to users.
-
-  Level: developer
-
-.keywords: IS, register
-.seealso: ISRegisterAll(), ISRegisterDestroy(), ISRegister()
-M*/
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define ISRegisterDynamic(a,b,c,d) ISRegister(a,b,c,0)
-#else
-#define ISRegisterDynamic(a,b,c,d) ISRegister(a,b,c,d)
-#endif
-
 /*
     Default index set data structures that PETSc provides.
 */

include/petscksp.h

 PETSC_EXTERN PetscErrorCode KSPRegister(const char[],const char[],const char[],PetscErrorCode (*)(KSP));
 PETSC_EXTERN PetscErrorCode KSPMatRegisterAll(const char[]);
 
-/*MC
-   KSPRegisterDynamic - Adds a method to the Krylov subspace solver package.
-
-   Synopsis:
-   #include "petscksp.h"
-   PetscErrorCode KSPRegisterDynamic(const char *name_solver,const char *path,const char *name_create,PetscErrorCode (*routine_create)(KSP))
-
-   Not Collective
-
-   Input Parameters:
-+  name_solver - name of a new user-defined solver
-.  path - path (either absolute or relative) the library containing this solver
-.  name_create - name of routine to create method context
--  routine_create - routine to create method context
-
-   Notes:
-   KSPRegisterDynamic() may be called multiple times to add several user-defined solvers.
-
-   If dynamic libraries are used, then the fourth input argument (routine_create)
-   is ignored.
-
-   Sample usage:
-.vb
-   KSPRegisterDynamic("my_solver",/home/username/my_lib/lib/libO/solaris/mylib.a,
-               "MySolverCreate",MySolverCreate);
-.ve
-
-   Then, your solver can be chosen with the procedural interface via
-$     KSPSetType(ksp,"my_solver")
-   or at runtime via the option
-$     -ksp_type my_solver
-
-   Level: advanced
-
-   Notes: Environmental variables such as ${PETSC_ARCH}, ${PETSC_DIR}, ${PETSC_LIB_DIR},
-          and others of the form ${any_environmental_variable} occuring in pathname will be
-          replaced with appropriate values.
-         If your function is not being put into a shared library then use KSPRegister() instead
-
-.keywords: KSP, register
-
-.seealso: KSPRegisterAll(), KSPRegisterDestroy()
-
-M*/
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define KSPRegisterDynamic(a,b,c,d) KSPRegister(a,b,c,0)
-#else
-#define KSPRegisterDynamic(a,b,c,d) KSPRegister(a,b,c,d)
-#endif
-
 PETSC_EXTERN PetscErrorCode KSPGetType(KSP,KSPType *);
 PETSC_EXTERN PetscErrorCode KSPSetPCSide(KSP,PCSide);
 PETSC_EXTERN PetscErrorCode KSPGetPCSide(KSP,PCSide*);

include/petscmat.h

 PETSC_EXTERN PetscErrorCode MatAppendOptionsPrefix(Mat,const char[]);
 PETSC_EXTERN PetscErrorCode MatGetOptionsPrefix(Mat,const char*[]);
 
-/*MC
-   MatRegisterDynamic - Adds a new matrix type
-
-   Synopsis:
-   #include "petscmat.h"
-   PetscErrorCode MatRegisterDynamic(const char *name,const char *path,const char *name_create,PetscErrorCode (*routine_create)(Mat))
-
-   Not Collective
-
-   Input Parameters:
-+  name - name of a new user-defined matrix type
-.  path - path (either absolute or relative) the library containing this solver
-.  name_create - name of routine to create method context
--  routine_create - routine to create method context
-
-   Notes:
-   MatRegisterDynamic() may be called multiple times to add several user-defined solvers.
-
-   If dynamic libraries are used, then the fourth input argument (routine_create)
-   is ignored.
-
-   Sample usage:
-.vb
-   MatRegisterDynamic("my_mat",/home/username/my_lib/lib/libO/solaris/mylib.a,
-               "MyMatCreate",MyMatCreate);
-.ve
-
-   Then, your solver can be chosen with the procedural interface via
-$     MatSetType(Mat,"my_mat")
-   or at runtime via the option
-$     -mat_type my_mat
-
-   Level: advanced
-
-   Notes: ${PETSC_ARCH} occuring in pathname will be replaced with appropriate values.
-         If your function is not being put into a shared library then use VecRegister() instead
-
-.keywords: Mat, register
-
-.seealso: MatRegisterAll(), MatRegisterDestroy()
-
-M*/
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define MatRegisterDynamic(a,b,c,d) MatRegister(a,b,c,0)
-#else
-#define MatRegisterDynamic(a,b,c,d) MatRegister(a,b,c,d)
-#endif
-
 PETSC_EXTERN PetscBool         MatRegisterAllCalled;
 PETSC_EXTERN PetscFunctionList MatList;
 PETSC_EXTERN PetscFunctionList MatColoringList;
 PETSC_EXTERN PetscErrorCode MatGetOrderingList(PetscFunctionList*);
 PETSC_EXTERN PetscErrorCode MatOrderingRegister(const char[],const char[],const char[],PetscErrorCode(*)(Mat,MatOrderingType,IS*,IS*));
 
-/*MC
-   MatOrderingRegisterDynamic - Adds a new sparse matrix ordering to the matrix package.
-
-   Synopsis:
-   #include "petscmat.h"
-   PetscErrorCode MatOrderingRegisterDynamic(const char *name_ordering,const char *path,const char *name_create,PetscErrorCode (*routine_create)(MatOrdering))
-
-   Not Collective
-
-   Input Parameters:
-+  sname - name of ordering (for example MATORDERINGND)
-.  path - location of library where creation routine is
-.  name - name of function that creates the ordering type,a string
--  function - function pointer that creates the ordering
-
-   Level: developer
-
-   If dynamic libraries are used, then the fourth input argument (function)
-   is ignored.
-
-   Sample usage:
-.vb
-   MatOrderingRegisterDynamic("my_order",/home/username/my_lib/lib/libO/solaris/mylib.a,
-               "MyOrder",MyOrder);
-.ve
-
-   Then, your partitioner can be chosen with the procedural interface via
-$     MatOrderingSetType(part,"my_order)
-   or at runtime via the option
-$     -pc_factor_mat_ordering_type my_order
-
-   ${PETSC_ARCH} occuring in pathname will be replaced with appropriate values.
-
-.keywords: matrix, ordering, register
-
-.seealso: MatOrderingRegisterDestroy(), MatOrderingRegisterAll()
-M*/
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define MatOrderingRegisterDynamic(a,b,c,d) MatOrderingRegister(a,b,c,0)
-#else
-#define MatOrderingRegisterDynamic(a,b,c,d) MatOrderingRegister(a,b,c,d)
-#endif
-
 PETSC_EXTERN PetscErrorCode MatOrderingRegisterDestroy(void);
 PETSC_EXTERN PetscErrorCode MatOrderingRegisterAll(const char[]);
 PETSC_EXTERN PetscBool         MatOrderingRegisterAllCalled;
 PETSC_EXTERN PetscErrorCode MatGetColoring(Mat,MatColoringType,ISColoring*);
 PETSC_EXTERN PetscErrorCode MatColoringRegister(const char[],const char[],const char[],PetscErrorCode(*)(Mat,MatColoringType,ISColoring *));
 
-/*MC
-   MatColoringRegisterDynamic - Adds a new sparse matrix coloring to the
-                               matrix package.
-
-   Synopsis:
-   #include "petscmat.h"
-   PetscErrorCode MatColoringRegisterDynamic(const char *name_coloring,const char *path,const char *name_create,PetscErrorCode (*routine_create)(MatColoring))
-
-   Not Collective
-
-   Input Parameters:
-+  sname - name of Coloring (for example MATCOLORINGSL)
-.  path - location of library where creation routine is
-.  name - name of function that creates the Coloring type, a string
--  function - function pointer that creates the coloring
-
-   Level: developer
-
-   If dynamic libraries are used, then the fourth input argument (function)
-   is ignored.
-
-   Sample usage:
-.vb
-   MatColoringRegisterDynamic("my_color",/home/username/my_lib/lib/libO/solaris/mylib.a,
-               "MyColor",MyColor);
-.ve
-
-   Then, your partitioner can be chosen with the procedural interface via
-$     MatColoringSetType(part,"my_color")
-   or at runtime via the option
-$     -mat_coloring_type my_color
-
-   $PETSC_ARCH occuring in pathname will be replaced with appropriate values.
-
-.keywords: matrix, Coloring, register
-
-.seealso: MatColoringRegisterDestroy(), MatColoringRegisterAll()
-M*/
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define MatColoringRegisterDynamic(a,b,c,d) MatColoringRegister(a,b,c,0)
-#else
-#define MatColoringRegisterDynamic(a,b,c,d) MatColoringRegister(a,b,c,d)
-#endif
-
 PETSC_EXTERN PetscBool MatColoringRegisterAllCalled;
 
 PETSC_EXTERN PetscErrorCode MatColoringRegisterAll(const char[]);
 
 PETSC_EXTERN PetscErrorCode MatPartitioningRegister(const char[],const char[],const char[],PetscErrorCode (*)(MatPartitioning));
 
-/*MC
-   MatPartitioningRegisterDynamic - Adds a new sparse matrix partitioning to the
-   matrix package.
-
-   Synopsis:
-   #include "petscmat.h"
-   PetscErrorCode MatPartitioningRegisterDynamic(const char *name_partitioning,const char *path,const char *name_create,PetscErrorCode (*routine_create)(MatPartitioning))
-
-   Not Collective
-
-   Input Parameters:
-+  sname - name of partitioning (for example MATPARTITIONINGCURRENT) or parmetis
-.  path - location of library where creation routine is
-.  name - name of function that creates the partitioning type, a string
--  function - function pointer that creates the partitioning type
-
-   Level: developer
-
-   If dynamic libraries are used, then the fourth input argument (function)
-   is ignored.
-
-   Sample usage:
-.vb
-   MatPartitioningRegisterDynamic("my_part",/home/username/my_lib/lib/libO/solaris/mylib.a,
-               "MyPartCreate",MyPartCreate);
-.ve
-
-   Then, your partitioner can be chosen with the procedural interface via
-$     MatPartitioningSetType(part,"my_part")
-   or at runtime via the option
-$     -mat_partitioning_type my_part
-
-   $PETSC_ARCH occuring in pathname will be replaced with appropriate values.
-
-.keywords: matrix, partitioning, register
-
-.seealso: MatPartitioningRegisterDestroy(), MatPartitioningRegisterAll()
-M*/
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define MatPartitioningRegisterDynamic(a,b,c,d) MatPartitioningRegister(a,b,c,0)
-#else
-#define MatPartitioningRegisterDynamic(a,b,c,d) MatPartitioningRegister(a,b,c,d)
-#endif
-
 PETSC_EXTERN PetscBool MatPartitioningRegisterAllCalled;
 
 PETSC_EXTERN PetscErrorCode MatPartitioningRegisterAll(const char[]);
 
 PETSC_EXTERN PetscErrorCode MatCoarsenRegister(const char[],const char[],const char[],PetscErrorCode (*)(MatCoarsen));
 
-/*MC
-   MatCoarsenRegisterDynamic - Adds a new sparse matrix coarsen to the
-   matrix package.
-
-   Synopsis:
-   #include "petscmat.h"
-   PetscErrorCode MatCoarsenRegisterDynamic(const char *name_coarsen,const char *path,const char *name_create,PetscErrorCode (*routine_create)(MatCoarsen))
-
-   Not Collective
-
-   Input Parameters:
-+  sname - name of coarsen (for example MATCOARSENMIS)
-.  path - location of library where creation routine is
-.  name - name of function that creates the coarsen type, a string
--  function - function pointer that creates the coarsen type
-
-   Level: developer
-
-   If dynamic libraries are used, then the fourth input argument (function)
-   is ignored.
-
-   Sample usage:
-.vb
-   MatCoarsenRegisterDynamic("my_agg",/home/username/my_lib/lib/libO/solaris/mylib.a,
-               "MyAggCreate",MyAggCreate);
-.ve
-
-   Then, your aggregator can be chosen with the procedural interface via
-$     MatCoarsenSetType(agg,"my_agg")
-   or at runtime via the option
-$     -mat_coarsen_type my_agg
-
-   $PETSC_ARCH occuring in pathname will be replaced with appropriate values.
-
-.keywords: matrix, coarsen, register
-
-.seealso: MatCoarsenRegisterDestroy(), MatCoarsenRegisterAll()
-M*/
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define MatCoarsenRegisterDynamic(a,b,c,d) MatCoarsenRegister(a,b,c,0)
-#else
-#define MatCoarsenRegisterDynamic(a,b,c,d) MatCoarsenRegister(a,b,c,d)
-#endif
-
 PETSC_EXTERN PetscBool MatCoarsenRegisterAllCalled;
 
 PETSC_EXTERN PetscErrorCode MatCoarsenRegisterAll(const char[]);
 PETSC_EXTERN PetscErrorCode MatMFFDSetType(Mat,MatMFFDType);
 PETSC_EXTERN PetscErrorCode MatMFFDRegister(const char[],const char[],const char[],PetscErrorCode (*)(MatMFFD));
 
-/*MC
-   MatMFFDRegisterDynamic - Adds a method to the MatMFFD registry.
-
-   Synopsis:
-   #include "petscmat.h"
-   PetscErrorCode MatMFFDRegisterDynamic(const char *name_solver,const char *path,const char *name_create,PetscErrorCode (*routine_create)(MatMFFD))
-
-   Not Collective
-
-   Input Parameters:
-+  name_solver - name of a new user-defined compute-h module
-.  path - path (either absolute or relative) the library containing this solver
-.  name_create - name of routine to create method context
--  routine_create - routine to create method context
-
-   Level: developer
-
-   Notes:
-   MatMFFDRegisterDynamic() may be called multiple times to add several user-defined solvers.
-
-   If dynamic libraries are used, then the fourth input argument (routine_create)
-   is ignored.
-
-   Sample usage:
-.vb
-   MatMFFDRegisterDynamic("my_h",/home/username/my_lib/lib/libO/solaris/mylib.a,
-               "MyHCreate",MyHCreate);
-.ve
-
-   Then, your solver can be chosen with the procedural interface via
-$     MatMFFDSetType(mfctx,"my_h")
-   or at runtime via the option
-$     -snes_mf_type my_h
-
-.keywords: MatMFFD, register
-
-.seealso: MatMFFDRegisterAll(), MatMFFDRegisterDestroy()
-M*/
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define MatMFFDRegisterDynamic(a,b,c,d) MatMFFDRegister(a,b,c,0)
-#else
-#define MatMFFDRegisterDynamic(a,b,c,d) MatMFFDRegister(a,b,c,d)
-#endif
-
 PETSC_EXTERN PetscErrorCode MatMFFDRegisterAll(const char[]);
 PETSC_EXTERN PetscErrorCode MatMFFDRegisterDestroy(void);
 PETSC_EXTERN PetscErrorCode MatMFFDDSSetUmin(Mat,PetscReal);

include/petscpc.h

 
 /*
     PCList contains the list of preconditioners currently registered
-   These are added with the PCRegisterDynamic() macro
+   These are added with the PCRegister() macro
 */
 PETSC_EXTERN PetscFunctionList PCList;
 
 
 PETSC_EXTERN PetscErrorCode PCRegister(const char[],const char[],const char[],PetscErrorCode(*)(PC));
 
-/*MC
-   PCRegisterDynamic - Adds a method to the preconditioner package.
-
-   Synopsis:
-    #include "petscpc.h"
-   PetscErrorCode PCRegisterDynamic(const char *name_solver,const char *path,const char *name_create,PetscErrorCode (*routine_create)(PC))
-
-   Not collective
-
-   Input Parameters:
-+  name_solver - name of a new user-defined solver
-.  path - path (either absolute or relative) the library containing this solver
-.  name_create - name of routine to create method context
--  routine_create - routine to create method context
-
-   Notes:
-   PCRegisterDynamic() may be called multiple times to add several user-defined preconditioners.
-
-   If dynamic libraries are used, then the fourth input argument (routine_create)
-   is ignored.
-
-   Sample usage:
-.vb
-   PCRegisterDynamic("my_solver","/home/username/my_lib/lib/libO/solaris/mylib",
-              "MySolverCreate",MySolverCreate);
-.ve
-
-   Then, your solver can be chosen with the procedural interface via
-$     PCSetType(pc,"my_solver")
-   or at runtime via the option
-$     -pc_type my_solver
-
-   Level: advanced
-
-   Notes: ${PETSC_ARCH}, ${PETSC_DIR}, ${PETSC_LIB_DIR},  or ${any environmental variable}
-           occuring in pathname will be replaced with appropriate values.
-         If your function is not being put into a shared library then use PCRegister() instead
-
-.keywords: PC, register
-
-.seealso: PCRegisterAll(), PCRegisterDestroy()
-M*/
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define PCRegisterDynamic(a,b,c,d) PCRegister(a,b,c,0)
-#else
-#define PCRegisterDynamic(a,b,c,d) PCRegister(a,b,c,d)
-#endif
-
 PETSC_EXTERN PetscErrorCode PCReset(PC);
 PETSC_EXTERN PetscErrorCode PCDestroy(PC*);
 PETSC_EXTERN PetscErrorCode PCSetFromOptions(PC);

include/petscpf.h

 
 /*
     PFunctionList contains the list of preconditioners currently registered
-   These are added with the PFRegisterDynamic() macro
+   These are added with the PFRegister() macro
 */
 PETSC_EXTERN PetscFunctionList PFunctionList;
 
 PETSC_EXTERN PetscBool PFRegisterAllCalled;
 
 PETSC_EXTERN PetscErrorCode PFRegister(const char[],const char[],const char[],PetscErrorCode (*)(PF,void*));
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define PFRegisterDynamic(a,b,c,d) PFRegister(a,b,c,0)
-#else
-#define PFRegisterDynamic(a,b,c,d) PFRegister(a,b,c,d)
-#endif
 
 PETSC_EXTERN PetscErrorCode PFDestroy(PF*);
 PETSC_EXTERN PetscErrorCode PFSetFromOptions(PF);

include/petscsf.h

 PETSC_EXTERN PetscErrorCode PetscSFRegisterAll(const char[]);
 PETSC_EXTERN PetscErrorCode PetscSFRegister(const char[],const char[],const char[],PetscErrorCode (*)(PetscSF));
 
-/*MC
-   PetscSFRegisterDynamic - Adds an implementation of the PetscSF communication protocol.
-
-   Synopsis:
-    #include "petscsf.h"
-   PetscErrorCode PetscSFRegisterDynamic(const char *name_method,const char *path,const char *name_create,PetscErrorCode (*routine_create)(PetscSF))
-
-   Not collective
-
-   Input Parameters:
-+  name_impl - name of a new user-defined implementation
-.  path - path (either absolute or relative) the library containing this solver
-.  name_create - name of routine to create method context
--  routine_create - routine to create method context
-
-   Notes:
-   PetscSFRegisterDynamic() may be called multiple times to add several user-defined implementations.
-
-   If dynamic libraries are used, then the fourth input argument (routine_create)
-   is ignored.
-
-   Environmental variables such as ${PETSC_ARCH}, ${PETSC_DIR}, ${PETSC_LIB_DIR},
-   and others of the form ${any_environmental_variable} occuring in pathname will be
-   replaced with appropriate values.
-
-   Sample usage:
-.vb
-   PetscSFRegisterDynamic("my_impl",/home/username/my_lib/lib/libg/solaris/mylib.a,
-                "MyImplCreate",MyImplCreate);
-.ve
-
-   Then, this implementation can be chosen with the procedural interface via
-$     PetscSFSetType(sf,"my_impl")
-   or at runtime via the option
-$     -snes_type my_solver
-
-   Level: advanced
-
-    Note: If your function is not being put into a shared library then use PetscSFRegister() instead
-
-.keywords: PetscSF, register
-
-.seealso: PetscSFRegisterAll(), PetscSFRegisterDestroy()
-M*/
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define PetscSFRegisterDynamic(a,b,c,d) PetscSFRegister(a,b,c,0)
-#else
-#define PetscSFRegisterDynamic(a,b,c,d) PetscSFRegister(a,b,c,d)
-#endif
-
 PETSC_EXTERN PetscErrorCode PetscSFInitializePackage(const char*);
 PETSC_EXTERN PetscErrorCode PetscSFFinalizePackage(void);
 PETSC_EXTERN PetscErrorCode PetscSFCreate(MPI_Comm comm,PetscSF*);

include/petscsnes.h

 
 PETSC_EXTERN PetscErrorCode SNESRegister(const char[],const char[],const char[],PetscErrorCode (*)(SNES));
 
-/*MC
-   SNESRegisterDynamic - Adds a method to the nonlinear solver package.
-
-   Synopsis:
-    #include "petscsnes.h"
-   PetscErrorCode SNESRegisterDynamic(const char *name_solver,const char *path,const char *name_create,PetscErrorCode (*routine_create)(SNES))
-
-   Not collective
-
-   Input Parameters:
-+  name_solver - name of a new user-defined solver
-.  path - path (either absolute or relative) the library containing this solver
-.  name_create - name of routine to create method context
--  routine_create - routine to create method context
-
-   Notes:
-   SNESRegisterDynamic() may be called multiple times to add several user-defined solvers.
-
-   If dynamic libraries are used, then the fourth input argument (routine_create)
-   is ignored.
-
-   Environmental variables such as ${PETSC_ARCH}, ${PETSC_DIR}, ${PETSC_LIB_DIR},
-   and others of the form ${any_environmental_variable} occuring in pathname will be
-   replaced with appropriate values.
-
-   Sample usage:
-.vb
-   SNESRegisterDynamic("my_solver",/home/username/my_lib/lib/libg/solaris/mylib.a,
-                "MySolverCreate",MySolverCreate);
-.ve
-
-   Then, your solver can be chosen with the procedural interface via
-$     SNESSetType(snes,"my_solver")
-   or at runtime via the option
-$     -snes_type my_solver
-
-   Level: advanced
-
-    Note: If your function is not being put into a shared library then use SNESRegister() instead
-
-.keywords: SNES, nonlinear, register
-
-.seealso: SNESRegisterAll(), SNESRegisterDestroy()
-M*/
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define SNESRegisterDynamic(a,b,c,d) SNESRegister(a,b,c,0)
-#else
-#define SNESRegisterDynamic(a,b,c,d) SNESRegister(a,b,c,d)
-#endif
-
 PETSC_EXTERN PetscErrorCode SNESGetKSP(SNES,KSP*);
 PETSC_EXTERN PetscErrorCode SNESSetKSP(SNES,KSP);
 PETSC_EXTERN PetscErrorCode SNESGetSolution(SNES,Vec*);
 PETSC_EXTERN PetscErrorCode SNESLineSearchRegisterAll(const char path[]);
 PETSC_EXTERN PetscErrorCode SNESLineSearchRegisterDestroy(void);
 
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define SNESLineSearchRegisterDynamic(a,b,c,d) SNESLineSearchRegister(a,b,c,0)
-#else
-#define SNESLineSearchRegisterDynamic(a,b,c,d) SNESLineSearchRegister(a,b,c,d)
-#endif
-
 /* Routines for VI solver */
 PETSC_EXTERN PetscErrorCode SNESVISetVariableBounds(SNES,Vec,Vec);
 PETSC_EXTERN PetscErrorCode SNESVISetComputeVariableBounds(SNES, PetscErrorCode (*)(SNES,Vec,Vec));

include/petscsys.h

 PETSC_EXTERN PetscErrorCode PetscObjectPrintClassNamePrefixType(PetscObject,PetscViewer,const char[]);
 PETSC_EXTERN PetscErrorCode PetscObjectView(PetscObject,PetscViewer);
 
-/*MC
-   PetscObjectComposeFunctionDynamic - Associates a function with a given PETSc object.
-
-    Synopsis:
-    #include "petscsys.h"
-    PetscErrorCode PetscObjectComposeFunctionDynamic(PetscObject obj,const char name[],const char fname[],void *ptr)
-
-   Logically Collective on PetscObject
-
-   Input Parameters:
-+  obj - the PETSc object; this must be cast with a (PetscObject), for example,
-         PetscObjectCompose((PetscObject)mat,...);
-.  name - name associated with the child function
-.  fname - name of the function
--  ptr - function pointer (or NULL if using dynamic libraries)
-
-   Level: advanced
-
-
-   Notes:
-   To remove a registered routine, pass in a NULL rname and fnc().
-
-   PetscObjectComposeFunctionDynamic() can be used with any PETSc object (such as
-   Mat, Vec, KSP, SNES, etc.) or any user-provided object.
-
-   The composed function must be wrapped in a EXTERN_C_BEGIN/END for this to
-   work in C++/complex with dynamic link libraries (./configure options --with-shared-libraries --with-dynamic-loading)
-   enabled.
-
-   Concepts: objects^composing functions
-   Concepts: composing functions
-   Concepts: functions^querying
-   Concepts: objects^querying
-   Concepts: querying objects
-
-.seealso: PetscObjectQueryFunction()
-M*/
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,0)
-#else
-#define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,d)
-#endif
-
 PETSC_EXTERN PetscErrorCode PetscObjectQueryFunction(PetscObject,const char[],void (**)(void));
 PETSC_EXTERN PetscErrorCode PetscObjectSetOptionsPrefix(PetscObject,const char[]);
 PETSC_EXTERN PetscErrorCode PetscObjectAppendOptionsPrefix(PetscObject,const char[]);
 PETSC_EXTERN PetscErrorCode PetscFunctionListDestroy(PetscFunctionList*);
 PETSC_EXTERN PetscErrorCode PetscFunctionListFind(MPI_Comm,PetscFunctionList,const char[],PetscBool,void (**)(void));
 PETSC_EXTERN PetscErrorCode PetscFunctionListPrintTypes(MPI_Comm,FILE*,const char[],const char[],const char[],const char[],PetscFunctionList,const char[]);
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define    PetscFunctionListAddDynamic(mc,a,b,p,c) PetscFunctionListAdd(mc,a,b,p,0)
-#else
-#define    PetscFunctionListAddDynamic(mc,a,b,p,c) PetscFunctionListAdd(mc,a,b,p,(void (*)(void))c)
-#endif
 PETSC_EXTERN PetscErrorCode PetscFunctionListDuplicate(PetscFunctionList,PetscFunctionList *);
 PETSC_EXTERN PetscErrorCode PetscFunctionListView(PetscFunctionList,PetscViewer);
 PETSC_EXTERN PetscErrorCode PetscFunctionListConcat(const char [],const char [],char []);
 PETSC_EXTERN PetscErrorCode PetscRandomViewFromOptions(PetscRandom,const char[]);
 PETSC_EXTERN PetscErrorCode PetscRandomView(PetscRandom,PetscViewer);
 
-/*MC
-  PetscRandomRegisterDynamic - Adds a new PetscRandom component implementation
-
-  Synopsis:
-    #include "petscsys.h"
-  PetscErrorCode PetscRandomRegisterDynamic(const char *name, const char *path, const char *func_name, PetscErrorCode (*create_func)(PetscRandom))
-
-  Not Collective
-
-  Input Parameters:
-+ name        - The name of a new user-defined creation routine
-. path        - The path (either absolute or relative) of the library containing this routine
-. func_name   - The name of routine to create method context
-- create_func - The creation routine itself
-
-  Notes:
-  PetscRandomRegisterDynamic() may be called multiple times to add several user-defined randome number generators
-
-  If dynamic libraries are used, then the fourth input argument (routine_create) is ignored.
-
-  Sample usage:
-.vb
-    PetscRandomRegisterDynamic("my_rand","/home/username/my_lib/lib/libO/solaris/libmy.a", "MyPetscRandomtorCreate", MyPetscRandomtorCreate);
-.ve
-
-  Then, your random type can be chosen with the procedural interface via
-.vb
-    PetscRandomCreate(MPI_Comm, PetscRandom *);
-    PetscRandomSetType(PetscRandom,"my_random_name");
-.ve
-   or at runtime via the option
-.vb
-    -random_type my_random_name
-.ve
-
-  Notes: $PETSC_ARCH occuring in pathname will be replaced with appropriate values.
-
-         For an example of the code needed to interface your own random number generator see
-         src/sys/random/impls/rand/rand.c
-
-  Level: advanced
-
-.keywords: PetscRandom, register
-.seealso: PetscRandomRegisterAll(), PetscRandomRegisterDestroy(), PetscRandomRegister()
-M*/
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define PetscRandomRegisterDynamic(a,b,c,d) PetscRandomRegister(a,b,c,0)
-#else
-#define PetscRandomRegisterDynamic(a,b,c,d) PetscRandomRegister(a,b,c,d)
-#endif
-
 PETSC_EXTERN PetscErrorCode PetscRandomCreate(MPI_Comm,PetscRandom*);
 PETSC_EXTERN PetscErrorCode PetscRandomGetValue(PetscRandom,PetscScalar*);
 PETSC_EXTERN PetscErrorCode PetscRandomGetValueReal(PetscRandom,PetscReal*);

include/petscts.h

 PETSC_EXTERN PetscErrorCode TSRegisterAll(const char[]);
 PETSC_EXTERN PetscErrorCode TSRegisterDestroy(void);
 
-/*MC
-  TSRegisterDynamic - Adds a creation method to the TS package.
-
-  Synopsis:
-  #include "petscts.h"
-  PetscErrorCode TSRegisterDynamic(const char *name, const char *path, const char *func_name, PetscErrorCode (*create_func)(TS))
-
-  Not Collective
-
-  Input Parameters:
-+ name        - The name of a new user-defined creation routine
-. path        - The path (either absolute or relative) of the library containing this routine
-. func_name   - The name of the creation routine
-- create_func - The creation routine itself
-
-  Notes:
-  TSRegisterDynamic() may be called multiple times to add several user-defined tses.
-
-  If dynamic libraries are used, then the fourth input argument (create_func) is ignored.
-
-  Sample usage:
-.vb
-  TSRegisterDynamic("my_ts", "/home/username/my_lib/lib/libO/solaris/libmy.a", "MyTSCreate", MyTSCreate);
-.ve
-
-  Then, your ts type can be chosen with the procedural interface via
-.vb
-    TS ts;
-    TSCreate(MPI_Comm, &ts);
-    TSSetType(ts, "my_ts")
-.ve
-  or at runtime via the option
-.vb
-    -ts_type my_ts
-.ve
-
-  Notes: $PETSC_ARCH occuring in pathname will be replaced with appropriate values.
-        If your function is not being put into a shared library then use TSRegister() instead
-
-  Level: advanced
-
-.keywords: TS, register
-.seealso: TSRegisterAll(), TSRegisterDestroy()
-M*/
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define TSRegisterDynamic(a,b,c,d) TSRegister(a,b,c,0)
-#else
-#define TSRegisterDynamic(a,b,c,d) TSRegister(a,b,c,d)
-#endif
-
 PETSC_EXTERN PetscErrorCode TSGetSNES(TS,SNES*);
 PETSC_EXTERN PetscErrorCode TSSetSNES(TS,SNES);
 PETSC_EXTERN PetscErrorCode TSGetKSP(TS,KSP*);
 #define TSADAPTNONE  "none"
 #define TSADAPTCFL   "cfl"
 
-/*MC
-   TSAdaptRegisterDynamic - adds a TSAdapt implementation
-
-   Synopsis:
-   #include "petscts.h"
-   PetscErrorCode TSAdaptRegisterDynamic(const char *name_scheme,const char *path,const char *name_create,PetscErrorCode (*routine_create)(TS))
-
-   Not Collective
-
-   Input Parameters:
-+  name_scheme - name of user-defined adaptivity scheme
-.  path - path (either absolute or relative) the library containing this scheme
-.  name_create - name of routine to create method context
--  routine_create - routine to create method context
-
-   Notes:
-   TSAdaptRegisterDynamic() may be called multiple times to add several user-defined families.
-
-   If dynamic libraries are used, then the fourth input argument (routine_create)
-   is ignored.
-
-   Sample usage:
-.vb
-   TSAdaptRegisterDynamic("my_scheme",/home/username/my_lib/lib/libO/solaris/mylib.a,
-                            "MySchemeCreate",MySchemeCreate);
-.ve
-
-   Then, your scheme can be chosen with the procedural interface via
-$     TSAdaptSetType(ts,"my_scheme")
-   or at runtime via the option
-$     -ts_adapt_type my_scheme
-
-   Level: advanced
-
-   Notes: Environmental variables such as ${PETSC_ARCH}, ${PETSC_DIR}, ${PETSC_LIB_DIR},
-          and others of the form ${any_environmental_variable} occuring in pathname will be
-          replaced with appropriate values.
-
-.keywords: TSAdapt, register
-
-.seealso: TSAdaptRegisterAll()
-M*/
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#  define TSAdaptRegisterDynamic(a,b,c,d)  TSAdaptRegister(a,b,c,0)
-#else
-#  define TSAdaptRegisterDynamic(a,b,c,d)  TSAdaptRegister(a,b,c,d)
-#endif
-
 PETSC_EXTERN PetscErrorCode TSGetTSAdapt(TS,TSAdapt*);
 PETSC_EXTERN PetscErrorCode TSAdaptRegister(const char[],const char[],const char[],PetscErrorCode (*)(TSAdapt));
 PETSC_EXTERN PetscErrorCode TSAdaptRegisterAll(const char[]);
 #define TSGLADAPT_SIZE "size"
 #define TSGLADAPT_BOTH "both"
 
-/*MC
-   TSGLAdaptRegisterDynamic - adds a TSGLAdapt implementation
-
-   Synopsis:
-   #include "petscts.h"
-   PetscErrorCode TSGLAdaptRegisterDynamic(const char *name_scheme,const char *path,const char *name_create,PetscErrorCode (*routine_create)(TS))
-
-   Not Collective
-
-   Input Parameters:
-+  name_scheme - name of user-defined adaptivity scheme
-.  path - path (either absolute or relative) the library containing this scheme
-.  name_create - name of routine to create method context
--  routine_create - routine to create method context
-
-   Notes:
-   TSGLAdaptRegisterDynamic() may be called multiple times to add several user-defined families.
-
-   If dynamic libraries are used, then the fourth input argument (routine_create)
-   is ignored.
-
-   Sample usage:
-.vb
-   TSGLAdaptRegisterDynamic("my_scheme",/home/username/my_lib/lib/libO/solaris/mylib.a,
-                            "MySchemeCreate",MySchemeCreate);
-.ve
-
-   Then, your scheme can be chosen with the procedural interface via
-$     TSGLAdaptSetType(ts,"my_scheme")
-   or at runtime via the option
-$     -ts_adapt_type my_scheme
-
-   Level: advanced
-
-   Notes: Environmental variables such as ${PETSC_ARCH}, ${PETSC_DIR}, ${PETSC_LIB_DIR},
-          and others of the form ${any_environmental_variable} occuring in pathname will be
-          replaced with appropriate values.
-
-.keywords: TSGLAdapt, register
-
-.seealso: TSGLAdaptRegisterAll()
-M*/
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#  define TSGLAdaptRegisterDynamic(a,b,c,d)  TSGLAdaptRegister(a,b,c,0)
-#else
-#  define TSGLAdaptRegisterDynamic(a,b,c,d)  TSGLAdaptRegister(a,b,c,d)
-#endif
-
 PETSC_EXTERN PetscErrorCode TSGLAdaptRegister(const char[],const char[],const char[],PetscErrorCode (*)(TSGLAdapt));
 PETSC_EXTERN PetscErrorCode TSGLAdaptRegisterAll(const char[]);
 PETSC_EXTERN PetscErrorCode TSGLAdaptRegisterDestroy(void);
 PETSC_EXTERN_TYPEDEF typedef PetscErrorCode (*TSGLAcceptFunction)(TS,PetscReal,PetscReal,const PetscReal[],PetscBool *);
 PETSC_EXTERN PetscErrorCode TSGLAcceptRegister(const char[],const char[],const char[],TSGLAcceptFunction);
 
-/*MC
-   TSGLAcceptRegisterDynamic - adds a TSGL acceptance scheme
-
-   Synopsis:
-   #include "petscts.h"
-   PetscErrorCode TSGLAcceptRegisterDynamic(const char *name_scheme,const char *path,const char *name_create,PetscErrorCode (*routine_create)(TS))
-
-   Not Collective
-
-   Input Parameters:
-+  name_scheme - name of user-defined acceptance scheme
-.  path - path (either absolute or relative) the library containing this scheme
-.  name_create - name of routine to create method context
--  routine_create - routine to create method context
-
-   Notes:
-   TSGLAcceptRegisterDynamic() may be called multiple times to add several user-defined families.
-
-   If dynamic libraries are used, then the fourth input argument (routine_create)
-   is ignored.
-
-   Sample usage:
-.vb
-   TSGLAcceptRegisterDynamic("my_scheme",/home/username/my_lib/lib/libO/solaris/mylib.a,
-                             "MySchemeCreate",MySchemeCreate);
-.ve
-
-   Then, your scheme can be chosen with the procedural interface via
-$     TSGLSetAcceptType(ts,"my_scheme")
-   or at runtime via the option
-$     -ts_gl_accept_type my_scheme
-
-   Level: advanced
-
-   Notes: Environmental variables such as ${PETSC_ARCH}, ${PETSC_DIR}, ${PETSC_LIB_DIR},
-          and others of the form ${any_environmental_variable} occuring in pathname will be
-          replaced with appropriate values.
-
-.keywords: TSGL, TSGLAcceptType, register
-
-.seealso: TSGLRegisterAll()
-M*/
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#  define TSGLAcceptRegisterDynamic(a,b,c,d) TSGLAcceptRegister(a,b,c,0)
-#else
-#  define TSGLAcceptRegisterDynamic(a,b,c,d) TSGLAcceptRegister(a,b,c,d)
-#endif
-
 /*J
   TSGLType - family of time integration method within the General Linear class
 
 typedef const char* TSGLType;
 #define TSGL_IRKS   "irks"
 
-/*MC
-   TSGLRegisterDynamic - adds a TSGL implementation
-
-   Synopsis:
-   #include "petscts.h"
-   PetscErrorCode TSGLRegisterDynamic(const char *name_scheme,const char *path,const char *name_create,PetscErrorCode (*routine_create)(TS))
-
-   Not Collective
-
-   Input Parameters:
-+  name_scheme - name of user-defined general linear scheme
-.  path - path (either absolute or relative) the library containing this scheme
-.  name_create - name of routine to create method context
--  routine_create - routine to create method context
-
-   Notes:
-   TSGLRegisterDynamic() may be called multiple times to add several user-defined families.
-
-   If dynamic libraries are used, then the fourth input argument (routine_create)
-   is ignored.
-
-   Sample usage:
-.vb
-   TSGLRegisterDynamic("my_scheme",/home/username/my_lib/lib/libO/solaris/mylib.a,
-                       "MySchemeCreate",MySchemeCreate);
-.ve
-
-   Then, your scheme can be chosen with the procedural interface via
-$     TSGLSetType(ts,"my_scheme")
-   or at runtime via the option
-$     -ts_gl_type my_scheme
-
-   Level: advanced
-
-   Notes: Environmental variables such as ${PETSC_ARCH}, ${PETSC_DIR}, ${PETSC_LIB_DIR},
-          and others of the form ${any_environmental_variable} occuring in pathname will be
-          replaced with appropriate values.
-
-.keywords: TSGL, register
-
-.seealso: TSGLRegisterAll()
-M*/
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#  define TSGLRegisterDynamic(a,b,c,d)       TSGLRegister(a,b,c,0)
-#else
-#  define TSGLRegisterDynamic(a,b,c,d)       TSGLRegister(a,b,c,d)
-#endif
-
 PETSC_EXTERN PetscErrorCode TSGLRegister(const char[],const char[],const char[],PetscErrorCode(*)(TS));
 PETSC_EXTERN PetscErrorCode TSGLRegisterAll(const char[]);
 PETSC_EXTERN PetscErrorCode TSGLRegisterDestroy(void);

include/petscvec.h

 PETSC_EXTERN PetscErrorCode VecRegisterAll(const char []);
 PETSC_EXTERN PetscErrorCode VecRegisterDestroy(void);
 
-/*MC
-  VecRegisterDynamic - Adds a new vector component implementation
-
-  Synopsis:
-  #include "petscvec.h"
-  PetscErrorCode VecRegisterDynamic(const char *name, const char *path, const char *func_name, PetscErrorCode (*create_func)(Vec))
-
-  Not Collective
-
-  Input Parameters:
-+ name        - The name of a new user-defined creation routine
-. path        - The path (either absolute or relative) of the library containing this routine
-. func_name   - The name of routine to create method context
-- create_func - The creation routine itself
-
-  Notes:
-  VecRegisterDynamic() may be called multiple times to add several user-defined vectors
-
-  If dynamic libraries are used, then the fourth input argument (routine_create) is ignored.
-
-  Sample usage:
-.vb
-    VecRegisterDynamic("my_vec","/home/username/my_lib/lib/libO/solaris/libmy.a", "MyVectorCreate", MyVectorCreate);
-.ve
-
-  Then, your vector type can be chosen with the procedural interface via
-.vb
-    VecCreate(MPI_Comm, Vec *);
-    VecSetType(Vec,"my_vector_name");
-.ve
-   or at runtime via the option
-.vb
-    -vec_type my_vector_name
-.ve
-
-  Notes: $PETSC_ARCH occuring in pathname will be replaced with appropriate values.
-         If your function is not being put into a shared library then use VecRegister() instead
-
-  Level: advanced
-
-.keywords: Vec, register
-.seealso: VecRegisterAll(), VecRegisterDestroy(), VecRegister()
-M*/
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define VecRegisterDynamic(a,b,c,d) VecRegister(a,b,c,0)
-#else
-#define VecRegisterDynamic(a,b,c,d) VecRegister(a,b,c,d)
-#endif
-
-
 PETSC_EXTERN PetscErrorCode VecScatterCreate(Vec,IS,Vec,IS,VecScatter *);
 PETSC_EXTERN PetscErrorCode VecScatterCreateEmpty(MPI_Comm,VecScatter *);
 PETSC_EXTERN PetscErrorCode VecScatterCreateLocal(VecScatter,PetscInt,const PetscInt[],const PetscInt[],const PetscInt[],PetscInt,const PetscInt[],const PetscInt[],const PetscInt[],PetscInt);

include/petscviewer.h

 
 PETSC_EXTERN PetscErrorCode PetscViewerRegister(const char*,const char*,const char*,PetscErrorCode (*)(PetscViewer));
 
-/*MC
-   PetscViewerRegisterDynamic - Adds a viewer
-
-   Synopsis
-   #include "petscviewer.h"
-   PetscErrorCode PetscViewerRegisterDynamic(const char *name_solver,const char *path,const char *name_create,PetscErrorCode (*routine_create)(PetscViewer))
-
-   Not Collective
-
-   Input Parameters:
-+  name_solver - name of a new user-defined viewer
-.  path - path (either absolute or relative) the library containing this viewer
-.  name_create - name of routine to create method context
--  routine_create - routine to create method context
-
-   Level: developer
-
-   Notes:
-   PetscViewerRegisterDynamic() may be called multiple times to add several user-defined viewers.
-
-   If dynamic libraries are used, then the fourth input argument (routine_create)
-   is ignored.
-
-   Sample usage:
-.vb
-   PetscViewerRegisterDynamic("my_viewer_type",/home/username/my_lib/lib/libO/solaris/mylib.a,
-               "MyViewerCreate",MyViewerCreate);
-.ve
-
-   Then, your solver can be chosen with the procedural interface via
-$     PetscViewerSetType(viewer,"my_viewer_type")
-   or at runtime via the option
-$     -viewer_type my_viewer_type
-
-  Concepts: registering^Viewers
-
-.seealso: PetscViewerRegisterAll(), PetscViewerRegisterDestroy()
-M*/
-#if defined(PETSC_USE_DYNAMIC_LIBRARIES)
-#define PetscViewerRegisterDynamic(a,b,c,d) PetscViewerRegister(a,b,c,0)
-#else
-#define PetscViewerRegisterDynamic(a,b,c,d) PetscViewerRegister(a,b,c,d)
-#endif
-
 PETSC_EXTERN PetscErrorCode PetscViewerCreate(MPI_Comm,PetscViewer*);
 PETSC_EXTERN PetscErrorCode PetscViewerSetFromOptions(PetscViewer);
 PETSC_EXTERN PetscErrorCode PetscViewerASCIIOpenWithFILE(MPI_Comm,FILE*,PetscViewer*);

src/dm/interface/dlregisdmdm.c

 #endif
 
 #if defined(PETSC_HAVE_HYPRE)
-  ierr = MatRegisterDynamic(MATHYPRESTRUCT,    path,"MatCreate_HYPREStruct", MatCreate_HYPREStruct);CHKERRQ(ierr);
+  ierr = MatRegister(MATHYPRESTRUCT,    path,"MatCreate_HYPREStruct", MatCreate_HYPREStruct);CHKERRQ(ierr);
 #endif
 
   /* Register Constructors */

src/dm/interface/dm.c

 #undef __FUNCT__
 #define __FUNCT__ "DMRegister"
 /*@C
-  DMRegister - See DMRegisterDynamic()
+  DMRegister -  Adds a new DM component implementation
+
+  Not Collective
+
+  Input Parameters:
++ name        - The name of a new user-defined creation routine
+. func_name   - The name of routine to create method context
+- create_func - The creation routine itself
+
+  Notes:
+  DMRegister() may be called multiple times to add several user-defined DMs
+
+
+  Sample usage:
+.vb
+    DMRegister("my_da","MyDMCreate", MyDMCreate);
+.ve
+
+  Then, your DM type can be chosen with the procedural interface via
+.vb
+    DMCreate(MPI_Comm, DM *);
+    DMSetType(DM,"my_da");
+.ve
+   or at runtime via the option
+.vb
+    -da_type my_da
+.ve
 
   Level: advanced
+
+.keywords: DM, register
+.seealso: DMRegisterAll(), DMRegisterDestroy(), DMRegister()
+
 @*/
 PetscErrorCode  DMRegister(const char sname[], const char path[], const char name[], PetscErrorCode (*function)(DM))
 {
 #undef __FUNCT__
 #define __FUNCT__ "DMRegisterDestroy"
 /*@C
-   DMRegisterDestroy - Frees the list of DM methods that were registered by DMRegister()/DMRegisterDynamic().
+   DMRegisterDestroy - Frees the list of DM methods that were registered by DMRegister()/DMRegister().
 
    Not Collective
 
    Level: advanced
 
 .keywords: DM, register, destroy
-.seealso: DMRegister(), DMRegisterAll(), DMRegisterDynamic()
+.seealso: DMRegister(), DMRegisterAll(), DMRegister()
 @*/
 PetscErrorCode  DMRegisterDestroy(void)
 {

src/dm/interface/dmregall.c

   Level: advanced
 
 .keywords: DM, register, all
-.seealso:  DMRegister(), DMRegisterDestroy(), DMRegisterDynamic()
+.seealso:  DMRegister(), DMRegisterDestroy(), DMRegister()
 @*/
 PetscErrorCode  DMRegisterAll(const char path[])
 {
   PetscFunctionBegin;
   DMRegisterAllCalled = PETSC_TRUE;
 
-  ierr = DMRegisterDynamic(DMDA,        path, "DMCreate_DA",        DMCreate_DA);CHKERRQ(ierr);
-  ierr = DMRegisterDynamic(DMCOMPOSITE, path, "DMCreate_Composite", DMCreate_Composite);CHKERRQ(ierr);
-  ierr = DMRegisterDynamic(DMSLICED,    path, "DMCreate_Sliced",    DMCreate_Sliced);CHKERRQ(ierr);
-  ierr = DMRegisterDynamic(DMSHELL,     path, "DMCreate_Shell",     DMCreate_Shell);CHKERRQ(ierr);
-  ierr = DMRegisterDynamic(DMADDA,      path, "DMCreate_ADDA",      DMCreate_ADDA);CHKERRQ(ierr);
-  ierr = DMRegisterDynamic(DMREDUNDANT, path, "DMCreate_Redundant", DMCreate_Redundant);CHKERRQ(ierr);
-  ierr = DMRegisterDynamic(DMPLEX,      path, "DMCreate_Plex",      DMCreate_Plex);CHKERRQ(ierr);
-  ierr = DMRegisterDynamic(DMPATCH,     path, "DMCreate_Patch",     DMCreate_Patch);CHKERRQ(ierr);
+  ierr = DMRegister(DMDA,        path, "DMCreate_DA",        DMCreate_DA);CHKERRQ(ierr);
+  ierr = DMRegister(DMCOMPOSITE, path, "DMCreate_Composite", DMCreate_Composite);CHKERRQ(ierr);
+  ierr = DMRegister(DMSLICED,    path, "DMCreate_Sliced",    DMCreate_Sliced);CHKERRQ(ierr);
+  ierr = DMRegister(DMSHELL,     path, "DMCreate_Shell",     DMCreate_Shell);CHKERRQ(ierr);
+  ierr = DMRegister(DMADDA,      path, "DMCreate_ADDA",      DMCreate_ADDA);CHKERRQ(ierr);
+  ierr = DMRegister(DMREDUNDANT, path, "DMCreate_Redundant", DMCreate_Redundant);CHKERRQ(ierr);
+  ierr = DMRegister(DMPLEX,      path, "DMCreate_Plex",      DMCreate_Plex);CHKERRQ(ierr);
+  ierr = DMRegister(DMPATCH,     path, "DMCreate_Patch",     DMCreate_Patch);CHKERRQ(ierr);
 #if defined(PETSC_HAVE_SIEVE)
-  ierr = DMRegisterDynamic(DMMESH,      path, "DMCreate_Mesh",      DMCreate_Mesh);CHKERRQ(ierr);
-  ierr = DMRegisterDynamic(DMCARTESIAN, path, "DMCreate_Cartesian", DMCreate_Cartesian);CHKERRQ(ierr);
+  ierr = DMRegister(DMMESH,      path, "DMCreate_Mesh",      DMCreate_Mesh);CHKERRQ(ierr);
+  ierr = DMRegister(DMCARTESIAN, path, "DMCreate_Cartesian", DMCreate_Cartesian);CHKERRQ(ierr);
 #endif
   PetscFunctionReturn(0);
 }

src/ksp/ksp/examples/tutorials/ex12.c

    Demonstrates registering a new preconditioner (PC) type.
 
    To register a PC type whose code is linked into the executable,
-   use PCRegister(). To register a PC type in a dynamic library use PCRegisterDynamic()
+   use PCRegister(). To register a PC type in a dynamic library use PCRegister()
 
    Also provide the prototype for your PCCreate_XXX() function. In
    this example we use the PETSc implementation of the Jacobi method,
    See the file src/ksp/pc/impls/jacobi/jacobi.c for details on how to
    write a new PC component.
 
-   See the manual page PCRegisterDynamic() for details on how to register a method.
+   See the manual page PCRegister() for details on how to register a method.
 */
 
 /*

src/ksp/ksp/interface/itcreate.c

 #define __FUNCT__ "KSPRegisterDestroy"
 /*@
    KSPRegisterDestroy - Frees the list of KSP methods that were
-   registered by KSPRegisterDynamic().
+   registered by KSPRegister().
 
    Not Collective
 
 
 .keywords: KSP, register, destroy
 
-.seealso: KSPRegisterDynamic(), KSPRegisterAll()
+.seealso: KSPRegister(), KSPRegisterAll()
 @*/
 PetscErrorCode  KSPRegisterDestroy(void)
 {
 #undef __FUNCT__
 #define __FUNCT__ "KSPRegister"
 /*@C
-  KSPRegister - See KSPRegisterDynamic()
+  KSPRegister -  Adds a method to the Krylov subspace solver package.
+
+   Not Collective
+
+   Input Parameters:
++  name_solver - name of a new user-defined solver
+.  name_create - name of routine to create method context
+-  routine_create - routine to create method context
+
+   Notes:
+   KSPRegister() may be called multiple times to add several user-defined solvers.
+
+   Sample usage:
+.vb
+   KSPRegister("my_solver","MySolverCreate",MySolverCreate);
+.ve
+
+   Then, your solver can be chosen with the procedural interface via
+$     KSPSetType(ksp,"my_solver")
+   or at runtime via the option
+$     -ksp_type my_solver
+
+   Level: advanced
+
+.keywords: KSP, register
+
+.seealso: KSPRegisterAll(), KSPRegisterDestroy()
 
-  Level: advanced
 @*/
 PetscErrorCode  KSPRegister(const char sname[],const char path[],const char name[],PetscErrorCode (*function)(KSP))
 {

src/ksp/ksp/interface/itregis.c

   PetscFunctionBegin;
   KSPRegisterAllCalled = PETSC_TRUE;
 
-  ierr = KSPRegisterDynamic(KSPCG,         path,"KSPCreate_CG",        KSPCreate_CG);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPGROPPCG,    path,"KSPCreate_GROPPCG",   KSPCreate_GROPPCG);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPPIPECG,     path,"KSPCreate_PIPECG",    KSPCreate_PIPECG);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPCGNE,       path,"KSPCreate_CGNE",      KSPCreate_CGNE);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPNASH,       path,"KSPCreate_NASH",      KSPCreate_NASH);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPSTCG,       path,"KSPCreate_STCG",      KSPCreate_STCG);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPGLTR,       path,"KSPCreate_GLTR",      KSPCreate_GLTR);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPRICHARDSON, path,"KSPCreate_Richardson",KSPCreate_Richardson);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPCHEBYSHEV,  path,"KSPCreate_Chebyshev", KSPCreate_Chebyshev);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPGMRES,      path,"KSPCreate_GMRES",     KSPCreate_GMRES);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPTCQMR,      path,"KSPCreate_TCQMR",     KSPCreate_TCQMR);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPBCGS,       path,"KSPCreate_BCGS",      KSPCreate_BCGS);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPIBCGS,      path,"KSPCreate_IBCGS",     KSPCreate_IBCGS);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPFBCGS,      path,"KSPCreate_FBCGS",     KSPCreate_FBCGS);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPFBCGSR,     path,"KSPCreate_FBCGSR",    KSPCreate_FBCGSR);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPBCGSL,      path,"KSPCreate_BCGSL",     KSPCreate_BCGSL);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPCGS,        path,"KSPCreate_CGS",       KSPCreate_CGS);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPTFQMR,      path,"KSPCreate_TFQMR",     KSPCreate_TFQMR);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPCR,         path,"KSPCreate_CR",        KSPCreate_CR);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPPIPECR,     path,"KSPCreate_PIPECR",    KSPCreate_PIPECR);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPLSQR,       path,"KSPCreate_LSQR",      KSPCreate_LSQR);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPPREONLY,    path,"KSPCreate_PREONLY",   KSPCreate_PREONLY);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPQCG,        path,"KSPCreate_QCG",       KSPCreate_QCG);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPBICG,       path,"KSPCreate_BiCG",      KSPCreate_BiCG);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPFGMRES,     path,"KSPCreate_FGMRES",    KSPCreate_FGMRES);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPMINRES,     path,"KSPCreate_MINRES",    KSPCreate_MINRES);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPSYMMLQ,     path,"KSPCreate_SYMMLQ",    KSPCreate_SYMMLQ);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPLGMRES,     path,"KSPCreate_LGMRES",    KSPCreate_LGMRES);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPLCD,        path,"KSPCreate_LCD",       KSPCreate_LCD);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPGCR,        path,"KSPCreate_GCR",       KSPCreate_GCR);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPPGMRES,     path,"KSPCreate_PGMRES",    KSPCreate_PGMRES);CHKERRQ(ierr);
-  ierr = KSPRegisterDynamic(KSPSPECEST,    path,"KSPCreate_SpecEst",  KSPCreate_SpecEst);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPCG,         path,"KSPCreate_CG",        KSPCreate_CG);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPGROPPCG,    path,"KSPCreate_GROPPCG",   KSPCreate_GROPPCG);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPPIPECG,     path,"KSPCreate_PIPECG",    KSPCreate_PIPECG);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPCGNE,       path,"KSPCreate_CGNE",      KSPCreate_CGNE);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPNASH,       path,"KSPCreate_NASH",      KSPCreate_NASH);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPSTCG,       path,"KSPCreate_STCG",      KSPCreate_STCG);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPGLTR,       path,"KSPCreate_GLTR",      KSPCreate_GLTR);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPRICHARDSON, path,"KSPCreate_Richardson",KSPCreate_Richardson);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPCHEBYSHEV,  path,"KSPCreate_Chebyshev", KSPCreate_Chebyshev);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPGMRES,      path,"KSPCreate_GMRES",     KSPCreate_GMRES);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPTCQMR,      path,"KSPCreate_TCQMR",     KSPCreate_TCQMR);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPBCGS,       path,"KSPCreate_BCGS",      KSPCreate_BCGS);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPIBCGS,      path,"KSPCreate_IBCGS",     KSPCreate_IBCGS);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPFBCGS,      path,"KSPCreate_FBCGS",     KSPCreate_FBCGS);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPFBCGSR,     path,"KSPCreate_FBCGSR",    KSPCreate_FBCGSR);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPBCGSL,      path,"KSPCreate_BCGSL",     KSPCreate_BCGSL);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPCGS,        path,"KSPCreate_CGS",       KSPCreate_CGS);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPTFQMR,      path,"KSPCreate_TFQMR",     KSPCreate_TFQMR);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPCR,         path,"KSPCreate_CR",        KSPCreate_CR);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPPIPECR,     path,"KSPCreate_PIPECR",    KSPCreate_PIPECR);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPLSQR,       path,"KSPCreate_LSQR",      KSPCreate_LSQR);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPPREONLY,    path,"KSPCreate_PREONLY",   KSPCreate_PREONLY);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPQCG,        path,"KSPCreate_QCG",       KSPCreate_QCG);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPBICG,       path,"KSPCreate_BiCG",      KSPCreate_BiCG);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPFGMRES,     path,"KSPCreate_FGMRES",    KSPCreate_FGMRES);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPMINRES,     path,"KSPCreate_MINRES",    KSPCreate_MINRES);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPSYMMLQ,     path,"KSPCreate_SYMMLQ",    KSPCreate_SYMMLQ);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPLGMRES,     path,"KSPCreate_LGMRES",    KSPCreate_LGMRES);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPLCD,        path,"KSPCreate_LCD",       KSPCreate_LCD);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPGCR,        path,"KSPCreate_GCR",       KSPCreate_GCR);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPPGMRES,     path,"KSPCreate_PGMRES",    KSPCreate_PGMRES);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPSPECEST,    path,"KSPCreate_SpecEst",  KSPCreate_SpecEst);CHKERRQ(ierr);
 #if !defined(PETSC_USE_COMPLEX)
-  ierr = KSPRegisterDynamic(KSPDGMRES,     path,"KSPCreate_DGMRES", KSPCreate_DGMRES);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPDGMRES,     path,"KSPCreate_DGMRES", KSPCreate_DGMRES);CHKERRQ(ierr);
 #endif
   PetscFunctionReturn(0);
 }

src/ksp/ksp/utils/schurm.c

   PetscFunctionBegin;
   if (KSPMatRegisterAllCalled) PetscFunctionReturn(0);
   KSPMatRegisterAllCalled = PETSC_TRUE;
-  ierr = MatRegisterDynamic(MATSCHURCOMPLEMENT,path,"MatCreate_SchurComplement",MatCreate_SchurComplement);CHKERRQ(ierr);
+  ierr = MatRegister(MATSCHURCOMPLEMENT,path,"MatCreate_SchurComplement",MatCreate_SchurComplement);CHKERRQ(ierr);
   PetscFunctionReturn(0);
 }

src/ksp/pc/interface/pcregis.c

 
 .keywords: PC, register, all
 
-.seealso: PCRegisterDynamic(), PCRegisterDestroy()
+.seealso: PCRegister(), PCRegisterDestroy()
 @*/
 PetscErrorCode  PCRegisterAll(const char path[])
 {
   PetscFunctionBegin;
   PCRegisterAllCalled = PETSC_TRUE;
 
-  ierr = PCRegisterDynamic(PCNONE         ,path,"PCCreate_None",PCCreate_None);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCJACOBI       ,path,"PCCreate_Jacobi",PCCreate_Jacobi);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCPBJACOBI     ,path,"PCCreate_PBJacobi",PCCreate_PBJacobi);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCBJACOBI      ,path,"PCCreate_BJacobi",PCCreate_BJacobi);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCSOR          ,path,"PCCreate_SOR",PCCreate_SOR);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCLU           ,path,"PCCreate_LU",PCCreate_LU);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCSHELL        ,path,"PCCreate_Shell",PCCreate_Shell);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCMG           ,path,"PCCreate_MG",PCCreate_MG);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCEISENSTAT    ,path,"PCCreate_Eisenstat",PCCreate_Eisenstat);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCILU          ,path,"PCCreate_ILU",PCCreate_ILU);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCICC          ,path,"PCCreate_ICC",PCCreate_ICC);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCCHOLESKY     ,path,"PCCreate_Cholesky",PCCreate_Cholesky);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCASM          ,path,"PCCreate_ASM",PCCreate_ASM);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCGASM         ,path,"PCCreate_GASM",PCCreate_GASM);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCKSP          ,path,"PCCreate_KSP",PCCreate_KSP);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCCOMPOSITE    ,path,"PCCreate_Composite",PCCreate_Composite);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCREDUNDANT    ,path,"PCCreate_Redundant",PCCreate_Redundant);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCNN           ,path,"PCCreate_NN",PCCreate_NN);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCMAT          ,path,"PCCreate_Mat",PCCreate_Mat);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCFIELDSPLIT   ,path,"PCCreate_FieldSplit",PCCreate_FieldSplit);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCGALERKIN     ,path,"PCCreate_Galerkin",PCCreate_Galerkin);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCEXOTIC       ,path,"PCCreate_Exotic",PCCreate_Exotic);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCHMPI         ,path,"PCCreate_HMPI",PCCreate_HMPI);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCASA          ,path,"PCCreate_ASA",PCCreate_ASA);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCCP           ,path,"PCCreate_CP",PCCreate_CP);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCLSC          ,path,"PCCreate_LSC",PCCreate_LSC);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCREDISTRIBUTE ,path,"PCCreate_Redistribute",PCCreate_Redistribute);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCSVD          ,path,"PCCreate_SVD",PCCreate_SVD);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCGAMG         ,path,"PCCreate_GAMG",PCCreate_GAMG);CHKERRQ(ierr);
+  ierr = PCRegister(PCNONE         ,path,"PCCreate_None",PCCreate_None);CHKERRQ(ierr);
+  ierr = PCRegister(PCJACOBI       ,path,"PCCreate_Jacobi",PCCreate_Jacobi);CHKERRQ(ierr);
+  ierr = PCRegister(PCPBJACOBI     ,path,"PCCreate_PBJacobi",PCCreate_PBJacobi);CHKERRQ(ierr);
+  ierr = PCRegister(PCBJACOBI      ,path,"PCCreate_BJacobi",PCCreate_BJacobi);CHKERRQ(ierr);
+  ierr = PCRegister(PCSOR          ,path,"PCCreate_SOR",PCCreate_SOR);CHKERRQ(ierr);
+  ierr = PCRegister(PCLU           ,path,"PCCreate_LU",PCCreate_LU);CHKERRQ(ierr);
+  ierr = PCRegister(PCSHELL        ,path,"PCCreate_Shell",PCCreate_Shell);CHKERRQ(ierr);
+  ierr = PCRegister(PCMG           ,path,"PCCreate_MG",PCCreate_MG);CHKERRQ(ierr);
+  ierr = PCRegister(PCEISENSTAT    ,path,"PCCreate_Eisenstat",PCCreate_Eisenstat);CHKERRQ(ierr);
+  ierr = PCRegister(PCILU          ,path,"PCCreate_ILU",PCCreate_ILU);CHKERRQ(ierr);
+  ierr = PCRegister(PCICC          ,path,"PCCreate_ICC",PCCreate_ICC);CHKERRQ(ierr);
+  ierr = PCRegister(PCCHOLESKY     ,path,"PCCreate_Cholesky",PCCreate_Cholesky);CHKERRQ(ierr);
+  ierr = PCRegister(PCASM          ,path,"PCCreate_ASM",PCCreate_ASM);CHKERRQ(ierr);
+  ierr = PCRegister(PCGASM         ,path,"PCCreate_GASM",PCCreate_GASM);CHKERRQ(ierr);
+  ierr = PCRegister(PCKSP          ,path,"PCCreate_KSP",PCCreate_KSP);CHKERRQ(ierr);
+  ierr = PCRegister(PCCOMPOSITE    ,path,"PCCreate_Composite",PCCreate_Composite);CHKERRQ(ierr);
+  ierr = PCRegister(PCREDUNDANT    ,path,"PCCreate_Redundant",PCCreate_Redundant);CHKERRQ(ierr);
+  ierr = PCRegister(PCNN           ,path,"PCCreate_NN",PCCreate_NN);CHKERRQ(ierr);
+  ierr = PCRegister(PCMAT          ,path,"PCCreate_Mat",PCCreate_Mat);CHKERRQ(ierr);
+  ierr = PCRegister(PCFIELDSPLIT   ,path,"PCCreate_FieldSplit",PCCreate_FieldSplit);CHKERRQ(ierr);
+  ierr = PCRegister(PCGALERKIN     ,path,"PCCreate_Galerkin",PCCreate_Galerkin);CHKERRQ(ierr);
+  ierr = PCRegister(PCEXOTIC       ,path,"PCCreate_Exotic",PCCreate_Exotic);CHKERRQ(ierr);
+  ierr = PCRegister(PCHMPI         ,path,"PCCreate_HMPI",PCCreate_HMPI);CHKERRQ(ierr);
+  ierr = PCRegister(PCASA          ,path,"PCCreate_ASA",PCCreate_ASA);CHKERRQ(ierr);
+  ierr = PCRegister(PCCP           ,path,"PCCreate_CP",PCCreate_CP);CHKERRQ(ierr);
+  ierr = PCRegister(PCLSC          ,path,"PCCreate_LSC",PCCreate_LSC);CHKERRQ(ierr);
+  ierr = PCRegister(PCREDISTRIBUTE ,path,"PCCreate_Redistribute",PCCreate_Redistribute);CHKERRQ(ierr);
+  ierr = PCRegister(PCSVD          ,path,"PCCreate_SVD",PCCreate_SVD);CHKERRQ(ierr);
+  ierr = PCRegister(PCGAMG         ,path,"PCCreate_GAMG",PCCreate_GAMG);CHKERRQ(ierr);
 #if defined(PETSC_HAVE_BOOST) && defined(PETSC_CLANGUAGE_CXX)
-  ierr = PCRegisterDynamic(PCSUPPORTGRAPH ,path,"PCCreate_SupportGraph",PCCreate_SupportGraph);CHKERRQ(ierr);
+  ierr = PCRegister(PCSUPPORTGRAPH ,path,"PCCreate_SupportGraph",PCCreate_SupportGraph);CHKERRQ(ierr);
 #endif
 #if defined(PETSC_HAVE_ML)
-  ierr = PCRegisterDynamic(PCML           ,path,"PCCreate_ML",PCCreate_ML);CHKERRQ(ierr);
+  ierr = PCRegister(PCML           ,path,"PCCreate_ML",PCCreate_ML);CHKERRQ(ierr);
 #endif
 #if defined(PETSC_HAVE_SPAI)
-  ierr = PCRegisterDynamic(PCSPAI         ,path,"PCCreate_SPAI",PCCreate_SPAI);CHKERRQ(ierr);
+  ierr = PCRegister(PCSPAI         ,path,"PCCreate_SPAI",PCCreate_SPAI);CHKERRQ(ierr);
 #endif
 #if defined(PETSC_HAVE_HYPRE)
-  ierr = PCRegisterDynamic(PCHYPRE        ,path,"PCCreate_HYPRE",PCCreate_HYPRE);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCPFMG         ,path,"PCCreate_PFMG",PCCreate_PFMG);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCSYSPFMG      ,path,"PCCreate_SysPFMG",PCCreate_SysPFMG);CHKERRQ(ierr);
+  ierr = PCRegister(PCHYPRE        ,path,"PCCreate_HYPRE",PCCreate_HYPRE);CHKERRQ(ierr);
+  ierr = PCRegister(PCPFMG         ,path,"PCCreate_PFMG",PCCreate_PFMG);CHKERRQ(ierr);
+  ierr = PCRegister(PCSYSPFMG      ,path,"PCCreate_SysPFMG",PCCreate_SysPFMG);CHKERRQ(ierr);
 #endif
 #if !defined(PETSC_USE_COMPLEX)
-  ierr = PCRegisterDynamic(PCTFS          ,path,"PCCreate_TFS",PCCreate_TFS);CHKERRQ(ierr);
+  ierr = PCRegister(PCTFS          ,path,"PCCreate_TFS",PCCreate_TFS);CHKERRQ(ierr);
 #endif
 #if defined(PETSC_HAVE_CUSP_SMOOTHED_AGGREGATION) && defined(PETSC_HAVE_CUSP)
-  ierr = PCRegisterDynamic(PCSACUSP       ,path,"PCCreate_SACUSP",PCCreate_SACUSP);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCAINVCUSP     ,path,"PCCreate_AINVCUSP",PCCreate_AINVCUSP);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCBICGSTABCUSP ,path,"PCCreate_BiCGStabCUSP",PCCreate_BiCGStabCUSP);CHKERRQ(ierr);
-  ierr = PCRegisterDynamic(PCSACUSPPOLY   ,path,"PCCreate_SACUSPPoly",PCCreate_SACUSPPoly);CHKERRQ(ierr);
+  ierr = PCRegister(PCSACUSP       ,path,"PCCreate_SACUSP",PCCreate_SACUSP);CHKERRQ(ierr);
+  ierr = PCRegister(PCAINVCUSP     ,path,"PCCreate_AINVCUSP",PCCreate_AINVCUSP);CHKERRQ(ierr);
+  ierr = PCRegister(PCBICGSTABCUSP ,path,"PCCreate_BiCGStabCUSP",PCCreate_BiCGStabCUSP);CHKERRQ(ierr);
+  ierr = PCRegister(PCSACUSPPOLY   ,path,"PCCreate_SACUSPPoly",PCCreate_SACUSPPoly);CHKERRQ(ierr);
 #endif
 #if defined(PETSC_HAVE_PARMS)
-  ierr = PCRegisterDynamic(PCPARMS        ,path,"PCCreate_PARMS",PCCreate_PARMS);CHKERRQ(ierr);
+  ierr = PCRegister(PCPARMS        ,path,"PCCreate_PARMS",PCCreate_PARMS);CHKERRQ(ierr);
 #endif
 #if defined(PETSC_HAVE_PCBDDC)
-  ierr = PCRegisterDynamic(PCBDDC         ,path,"PCCreate_BDDC",PCCreate_BDDC);CHKERRQ(ierr);
+  ierr = PCRegister(PCBDDC         ,path,"PCCreate_BDDC",PCCreate_BDDC);CHKERRQ(ierr);
 #endif
   PetscFunctionReturn(0);
 }

src/ksp/pc/interface/pcset.c

 #define __FUNCT__ "PCRegisterDestroy"
 /*@
    PCRegisterDestroy - Frees the list of preconditioners that were
-   registered by PCRegisterDynamic().
+   registered by PCRegister().
 
    Not Collective
 

src/ksp/pc/interface/precon.c

 #undef __FUNCT__
 #define __FUNCT__ "PCRegister"
 /*@C
-  PCRegister - See PCRegisterDynamic()
+  PCRegister -  Adds a method to the preconditioner package.
 
-  Level: advanced
+   Not collective
+
+   Input Parameters:
++  name_solver - name of a new user-defined solver
+.  name_create - name of routine to create method context
+-  routine_create - routine to create method context
+
+   Notes:
+   PCRegister() may be called multiple times to add several user-defined preconditioners.
+
+   Sample usage:
+.vb
+   PCRegister("my_solver", "MySolverCreate",MySolverCreate);
+.ve
+
+   Then, your solver can be chosen with the procedural interface via
+$     PCSetType(pc,"my_solver")
+   or at runtime via the option
+$     -pc_type my_solver
+
+   Level: advanced
+
+.keywords: PC, register
+
+.seealso: PCRegisterAll(), PCRegisterDestroy()
 @*/
 PetscErrorCode  PCRegister(const char sname[],const char path[],const char name[],PetscErrorCode (*function)(PC))
 {

src/mat/coarsen/coarsen.c

 
 #undef __FUNCT__
 #define __FUNCT__ "MatCoarsenRegister"
+/*@C
+   MatCoarsenRegister - Adds a new sparse matrix coarsen to the  matrix package.
+
+   Not Collective
+
+   Input Parameters:
++  sname - name of coarsen (for example MATCOARSENMIS)
+.  name - name of function that creates the coarsen type, a string
+-  function - function pointer that creates the coarsen type
+
+   Level: developer
+
+   Sample usage:
+.vb
+   MatCoarsenRegister("my_agg","MyAggCreate",MyAggCreate);
+.ve
+
+   Then, your aggregator can be chosen with the procedural interface via
+$     MatCoarsenSetType(agg,"my_agg")
+   or at runtime via the option
+$     -mat_coarsen_type my_agg
+
+.keywords: matrix, coarsen, register
+
+.seealso: MatCoarsenRegisterDestroy(), MatCoarsenRegisterAll()
+@*/
 PetscErrorCode  MatCoarsenRegister(const char sname[],const char path[],const char name[],PetscErrorCode (*function)(MatCoarsen))
 {
   PetscErrorCode ierr;
 
 .keywords: matrix, register, destroy
 
-.seealso: MatCoarsenRegisterDynamic(), MatCoarsenRegisterAll()
+.seealso: MatCoarsenRegister(), MatCoarsenRegisterAll()
 @*/
 PetscErrorCode  MatCoarsenRegisterDestroy(void)
 {
 
    Level: beginner
 
-   The user can define additional coarsens; see MatCoarsenRegisterDynamic().
+   The user can define additional coarsens; see MatCoarsenRegister().
 
 .keywords: matrix, get, coarsen
 
-.seealso:  MatCoarsenRegisterDynamic(), MatCoarsenCreate(),
+.seealso:  MatCoarsenRegister(), MatCoarsenCreate(),
            MatCoarsenDestroy(), MatCoarsenSetAdjacency(), ISCoarsenToNumbering(),
            ISCoarsenCount()
 @*/

src/mat/coarsen/scoarsen.c

 
   Adding new methods:
   To add a new method to the registry. Copy this routine and
-  modify it to incorporate a call to MatCoarsenRegisterDynamic() for
+  modify it to incorporate a call to MatCoarsenRegister() for
   the new method, after the current list.
 
   Restricting the choices: To prevent all of the methods from being
 
  .keywords: matrix, Coarsen, register, all
 
- .seealso: MatCoarsenRegisterDynamic(), MatCoarsenRegisterDestroy()
+ .seealso: MatCoarsenRegister(), MatCoarsenRegisterDestroy()
  @*/
 PetscErrorCode  MatCoarsenRegisterAll(const char path[])
 {
   PetscFunctionBegin;
   MatCoarsenRegisterAllCalled = PETSC_TRUE;
 
-  ierr = MatCoarsenRegisterDynamic(MATCOARSENMIS,path,"MatCoarsenCreate_MIS",MatCoarsenCreate_MIS);CHKERRQ(ierr);
-  ierr = MatCoarsenRegisterDynamic(MATCOARSENHEM,path,"MatCoarsenCreate_HEM",MatCoarsenCreate_HEM);CHKERRQ(ierr);
+  ierr = MatCoarsenRegister(MATCOARSENMIS,path,"MatCoarsenCreate_MIS",MatCoarsenCreate_MIS);CHKERRQ(ierr);
+  ierr = MatCoarsenRegister(MATCOARSENHEM,path,"MatCoarsenCreate_HEM",MatCoarsenCreate_HEM);CHKERRQ(ierr);
   PetscFunctionReturn(0);
 }
 

src/mat/color/color.c

 
 #undef __FUNCT__
 #define __FUNCT__ "MatColoringRegister"
+/*@C
+   MatColoringRegister - Adds a new sparse matrix coloring to the  matrix package.
+
+   Not Collective
+
+   Input Parameters:
++  sname - name of Coloring (for example MATCOLORINGSL)
+.  name - name of function that creates the Coloring type, a string
+-  function - function pointer that creates the coloring
+
+   Level: developer
+
+   Sample usage:
+.vb
+   MatColoringRegister("my_color","MyColor",MyColor);
+.ve
+
+   Then, your partitioner can be chosen with the procedural interface via
+$     MatColoringSetType(part,"my_color")
+   or at runtime via the option
+$     -mat_coloring_type my_color
+
+.keywords: matrix, Coloring, register
+
+.seealso: MatColoringRegisterDestroy(), MatColoringRegisterAll()
+@*/
 PetscErrorCode  MatColoringRegister(const char sname[],const char path[],const char name[],PetscErrorCode (*function)(Mat,MatColoringType,ISColoring*))
 {
   PetscErrorCode ierr;
 
 .keywords: matrix, register, destroy
 
-.seealso: MatColoringRegisterDynamic(), MatColoringRegisterAll()
+.seealso: MatColoringRegister(), MatColoringRegisterAll()
 @*/
 PetscErrorCode  MatColoringRegisterDestroy(void)
 {
 $    A suitable coloring for efficient Jacobian computation is a division of the columns so that two columns of the same color do not share any common rows.
 $         This corresponds to C(A^{T} A).  This is what MatGetColoring() computes.
 
-   The user can define additional colorings; see MatColoringRegisterDynamic().
+   The user can define additional colorings; see MatColoringRegister().
 
    For parallel matrices currently converts to sequential matrix and uses the sequential coloring
    on that.
 
 .keywords: matrix, get, coloring
 
-.seealso:  MatGetColoringTypeFromOptions(), MatColoringRegisterDynamic(), MatFDColoringCreate(),
+.seealso:  MatGetColoringTypeFromOptions(), MatColoringRegister(), MatFDColoringCreate(),
            SNESComputeJacobianDefaultColor()
 @*/
 PetscErrorCode  MatGetColoring(Mat mat,MatColoringType type,ISColoring *iscoloring)

src/mat/color/scolor.c

 
   Adding new methods:
   To add a new method to the registry. Copy this routine and
-  modify it to incorporate a call to MatColoringRegisterDynamic() for
+  modify it to incorporate a call to MatColoringRegister() for
   the new method, after the current list.
 
   Restricting the choices: To prevent all of the methods from being
 
 .keywords: matrix, coloring, register, all
 
-.seealso: MatColoringRegisterDynamic(), MatColoringRegisterDestroy()
+.seealso: MatColoringRegister(), MatColoringRegisterDestroy()
 @*/
 PetscErrorCode MatColoringRegisterAll(const char path[])
 {
   PetscFunctionBegin;