Commits

BarryFSmith committed 607a662

removed path argument to XXXInitializePackage() and XXXRegister()

Comments (0)

Files changed (110)

include/petsc-private/threadcommimpl.h

 extern PetscThreadComm PETSC_THREAD_COMM_WORLD;
 
 /* register thread communicator models */
-PETSC_EXTERN PetscErrorCode PetscThreadCommRegister(const char[],const char[],const char[],PetscErrorCode(*)(PetscThreadComm));
-PETSC_EXTERN PetscErrorCode PetscThreadCommRegisterAll(const char path[]);
+PETSC_EXTERN PetscErrorCode PetscThreadCommRegister(const char[],const char[],PetscErrorCode(*)(PetscThreadComm));
+PETSC_EXTERN PetscErrorCode PetscThreadCommRegisterAll(void);
 
 #undef __FUNCT__
 #define __FUNCT__

include/petscao.h

 /* Logging support */
 PETSC_EXTERN PetscClassId AO_CLASSID;
 
-PETSC_EXTERN PetscErrorCode AOInitializePackage(const char[]);
+PETSC_EXTERN PetscErrorCode AOInitializePackage(void);
 
 PETSC_EXTERN PetscErrorCode AOCreate(MPI_Comm,AO*);
 PETSC_EXTERN PetscErrorCode AOSetIS(AO,IS,IS);
 PETSC_EXTERN PetscErrorCode AOSetType(AO, AOType);
 PETSC_EXTERN PetscErrorCode AOGetType(AO, AOType *);
 
-PETSC_EXTERN PetscErrorCode AORegister(const char [], const char [], const char [], PetscErrorCode (*)(AO));
-PETSC_EXTERN PetscErrorCode AORegisterAll(const char []);
+PETSC_EXTERN PetscErrorCode AORegister(const char [], const char [], PetscErrorCode (*)(AO));
+PETSC_EXTERN PetscErrorCode AORegisterAll(void);
 PETSC_EXTERN PetscErrorCode AORegisterDestroy(void);
 
 PETSC_EXTERN PetscErrorCode AOPetscToApplication(AO,PetscInt,PetscInt[]);

include/petsccharacteristic.h

 #include <petscvec.h>
 #include <petscdmdatypes.h>
 
-PETSC_EXTERN PetscErrorCode CharacteristicInitializePackage(const char[]);
+PETSC_EXTERN PetscErrorCode CharacteristicInitializePackage(void);
 
 /*S
      Characteristic - Abstract PETSc object that manages method of characteristics solves
 
 PETSC_EXTERN PetscBool         CharacteristicRegisterAllCalled;
 PETSC_EXTERN PetscFunctionList CharacteristicList;
-PETSC_EXTERN PetscErrorCode CharacteristicRegisterAll(const char[]);
+PETSC_EXTERN PetscErrorCode CharacteristicRegisterAll(void);
 PETSC_EXTERN PetscErrorCode CharacteristicRegisterDestroy(void);
 
-PETSC_EXTERN PetscErrorCode CharacteristicRegister(const char[],const char[],const char[],PetscErrorCode (*)(Characteristic));
+PETSC_EXTERN PetscErrorCode CharacteristicRegister(const char[],const char[],PetscErrorCode (*)(Characteristic));
 
 #endif /*__PETSCCHARACTERISTICS_H*/

include/petscdm.h

 #include <petscmat.h>
 #include <petscdmtypes.h>
 
-PETSC_EXTERN PetscErrorCode DMInitializePackage(const char[]);
+PETSC_EXTERN PetscErrorCode DMInitializePackage(void);
 
 PETSC_EXTERN PetscClassId DM_CLASSID;
 
 PETSC_EXTERN PetscErrorCode DMCreate(MPI_Comm,DM*);
 PETSC_EXTERN PetscErrorCode DMSetType(DM, DMType);
 PETSC_EXTERN PetscErrorCode DMGetType(DM, DMType *);
-PETSC_EXTERN PetscErrorCode DMRegister(const char[],const char[],const char[],PetscErrorCode (*)(DM));
-PETSC_EXTERN PetscErrorCode DMRegisterAll(const char []);
+PETSC_EXTERN PetscErrorCode DMRegister(const char[],const char[],PetscErrorCode (*)(DM));
+PETSC_EXTERN PetscErrorCode DMRegisterAll(void);
 PETSC_EXTERN PetscErrorCode DMRegisterDestroy(void);
 
 PETSC_EXTERN PetscErrorCode DMView(DM,PetscViewer);

include/petscdraw.h

 #define PETSC_DRAW_TIKZ       "tikz"
 
 PETSC_EXTERN PetscFunctionList PetscDrawList;
-PETSC_EXTERN PetscErrorCode PetscDrawRegisterAll(const char[]);
-PETSC_EXTERN PetscErrorCode PetscDrawInitializePackage(const char[]);
+PETSC_EXTERN PetscErrorCode PetscDrawRegisterAll(void);
+PETSC_EXTERN PetscErrorCode PetscDrawInitializePackage(void);
 PETSC_EXTERN PetscErrorCode PetscDrawRegisterDestroy(void);
 
-PETSC_EXTERN PetscErrorCode PetscDrawRegister(const char*,const char*,const char*,PetscErrorCode(*)(PetscDraw));
+PETSC_EXTERN PetscErrorCode PetscDrawRegister(const char[],const char[],PetscErrorCode(*)(PetscDraw));
 
 PETSC_EXTERN PetscErrorCode PetscDrawGetType(PetscDraw,PetscDrawType*);
 PETSC_EXTERN PetscErrorCode PetscDrawSetType(PetscDraw,PetscDrawType);

include/petscis.h

 #define IS_FILE_CLASSID 1211218
 PETSC_EXTERN PetscClassId IS_CLASSID;
 
-PETSC_EXTERN PetscErrorCode ISInitializePackage(const char[]);
+PETSC_EXTERN PetscErrorCode ISInitializePackage(void);
 
 /*S
      IS - Abstract PETSc object that allows indexing.
 PETSC_EXTERN PetscBool         ISRegisterAllCalled;
 PETSC_EXTERN PetscErrorCode ISSetType(IS, ISType);
 PETSC_EXTERN PetscErrorCode ISGetType(IS, ISType *);
-PETSC_EXTERN PetscErrorCode ISRegister(const char[],const char[],const char[],PetscErrorCode (*)(IS));
-PETSC_EXTERN PetscErrorCode ISRegisterAll(const char []);
+PETSC_EXTERN PetscErrorCode ISRegister(const char[],const char[],PetscErrorCode (*)(IS));
+PETSC_EXTERN PetscErrorCode ISRegisterAll(void);
 PETSC_EXTERN PetscErrorCode ISRegisterDestroy(void);
 PETSC_EXTERN PetscErrorCode ISCreate(MPI_Comm,IS*);
 

include/petscksp.h

 #define __PETSCKSP_H
 #include <petscpc.h>
 
-PETSC_EXTERN PetscErrorCode KSPInitializePackage(const char[]);
+PETSC_EXTERN PetscErrorCode KSPInitializePackage(void);
 
 /*S
      KSP - Abstract PETSc object that manages all Krylov methods
 
 PETSC_EXTERN PetscFunctionList KSPList;
 PETSC_EXTERN PetscBool         KSPRegisterAllCalled;
-PETSC_EXTERN PetscErrorCode KSPRegisterAll(const char[]);
+PETSC_EXTERN PetscErrorCode KSPRegisterAll(void);
 PETSC_EXTERN PetscErrorCode KSPRegisterDestroy(void);
-PETSC_EXTERN PetscErrorCode KSPRegister(const char[],const char[],const char[],PetscErrorCode (*)(KSP));
-PETSC_EXTERN PetscErrorCode KSPMatRegisterAll(const char[]);
+PETSC_EXTERN PetscErrorCode KSPRegister(const char[],const char[],PetscErrorCode (*)(KSP));
+PETSC_EXTERN PetscErrorCode KSPMatRegisterAll(void);
 
 PETSC_EXTERN PetscErrorCode KSPGetType(KSP,KSPType *);
 PETSC_EXTERN PetscErrorCode KSPSetPCSide(KSP,PCSide);

include/petscmat.h

 E*/
 typedef enum {MAT_DO_NOT_GET_VALUES,MAT_GET_VALUES} MatGetSubMatrixOption;
 
-PETSC_EXTERN PetscErrorCode MatInitializePackage(const char[]);
+PETSC_EXTERN PetscErrorCode MatInitializePackage(void);
 
 PETSC_EXTERN PetscErrorCode MatCreate(MPI_Comm,Mat*);
 PETSC_EXTERN PetscErrorCode MatSetSizes(Mat,PetscInt,PetscInt,PetscInt,PetscInt);
 PETSC_EXTERN PetscErrorCode MatSetType(Mat,MatType);
 PETSC_EXTERN PetscErrorCode MatSetFromOptions(Mat);
 PETSC_EXTERN PetscErrorCode MatViewFromOptions(Mat,const char[]);
-PETSC_EXTERN PetscErrorCode MatRegisterAll(const char[]);
-PETSC_EXTERN PetscErrorCode MatRegister(const char[],const char[],const char[],PetscErrorCode(*)(Mat));
+PETSC_EXTERN PetscErrorCode MatRegisterAll(void);
+PETSC_EXTERN PetscErrorCode MatRegister(const char[],const char[],PetscErrorCode(*)(Mat));
 PETSC_EXTERN PetscErrorCode MatRegisterBaseName(const char[],const char[],const char[]);
 PETSC_EXTERN PetscErrorCode MatSetOptionsPrefix(Mat,const char[]);
 PETSC_EXTERN PetscErrorCode MatAppendOptionsPrefix(Mat,const char[]);
 
 PETSC_EXTERN PetscErrorCode MatGetOrdering(Mat,MatOrderingType,IS*,IS*);
 PETSC_EXTERN PetscErrorCode MatGetOrderingList(PetscFunctionList*);
-PETSC_EXTERN PetscErrorCode MatOrderingRegister(const char[],const char[],const char[],PetscErrorCode(*)(Mat,MatOrderingType,IS*,IS*));
+PETSC_EXTERN PetscErrorCode MatOrderingRegister(const char[],const char[],PetscErrorCode(*)(Mat,MatOrderingType,IS*,IS*));
 
 PETSC_EXTERN PetscErrorCode MatOrderingRegisterDestroy(void);
-PETSC_EXTERN PetscErrorCode MatOrderingRegisterAll(const char[]);
+PETSC_EXTERN PetscErrorCode MatOrderingRegisterAll(void);
 PETSC_EXTERN PetscBool         MatOrderingRegisterAllCalled;
 PETSC_EXTERN PetscFunctionList MatOrderingList;
 
 #define MATCOLORINGID      "id"
 
 PETSC_EXTERN PetscErrorCode MatGetColoring(Mat,MatColoringType,ISColoring*);
-PETSC_EXTERN PetscErrorCode MatColoringRegister(const char[],const char[],const char[],PetscErrorCode(*)(Mat,MatColoringType,ISColoring *));
+PETSC_EXTERN PetscErrorCode MatColoringRegister(const char[],const char[],PetscErrorCode(*)(Mat,MatColoringType,ISColoring *));
 
 PETSC_EXTERN PetscBool MatColoringRegisterAllCalled;
 
-PETSC_EXTERN PetscErrorCode MatColoringRegisterAll(const char[]);
+PETSC_EXTERN PetscErrorCode MatColoringRegisterAll(void);
 PETSC_EXTERN PetscErrorCode MatColoringRegisterDestroy(void);
 PETSC_EXTERN PetscErrorCode MatColoringPatch(Mat,PetscInt,PetscInt,ISColoringValue[],ISColoring*);
 
 PETSC_EXTERN PetscErrorCode MatPartitioningApply(MatPartitioning,IS*);
 PETSC_EXTERN PetscErrorCode MatPartitioningDestroy(MatPartitioning*);
 
-PETSC_EXTERN PetscErrorCode MatPartitioningRegister(const char[],const char[],const char[],PetscErrorCode (*)(MatPartitioning));
+PETSC_EXTERN PetscErrorCode MatPartitioningRegister(const char[],const char[],PetscErrorCode (*)(MatPartitioning));
 
 PETSC_EXTERN PetscBool MatPartitioningRegisterAllCalled;
 
-PETSC_EXTERN PetscErrorCode MatPartitioningRegisterAll(const char[]);
+PETSC_EXTERN PetscErrorCode MatPartitioningRegisterAll(void);
 PETSC_EXTERN PetscErrorCode MatPartitioningRegisterDestroy(void);
 
 PETSC_EXTERN PetscErrorCode MatPartitioningView(MatPartitioning,PetscViewer);
 PETSC_EXTERN PetscErrorCode MatCoarsenApply(MatCoarsen);
 PETSC_EXTERN PetscErrorCode MatCoarsenDestroy(MatCoarsen*);
 
-PETSC_EXTERN PetscErrorCode MatCoarsenRegister(const char[],const char[],const char[],PetscErrorCode (*)(MatCoarsen));
+PETSC_EXTERN PetscErrorCode MatCoarsenRegister(const char[],const char[],PetscErrorCode (*)(MatCoarsen));
 
 PETSC_EXTERN PetscBool MatCoarsenRegisterAllCalled;
 
-PETSC_EXTERN PetscErrorCode MatCoarsenRegisterAll(const char[]);
+PETSC_EXTERN PetscErrorCode MatCoarsenRegisterAll(void);
 PETSC_EXTERN PetscErrorCode MatCoarsenRegisterDestroy(void);
 
 PETSC_EXTERN PetscErrorCode MatCoarsenView(MatCoarsen,PetscViewer);
 #define MATMFFD_WP  "wp"
 
 PETSC_EXTERN PetscErrorCode MatMFFDSetType(Mat,MatMFFDType);
-PETSC_EXTERN PetscErrorCode MatMFFDRegister(const char[],const char[],const char[],PetscErrorCode (*)(MatMFFD));
+PETSC_EXTERN PetscErrorCode MatMFFDRegister(const char[],const char[],PetscErrorCode (*)(MatMFFD));
 
-PETSC_EXTERN PetscErrorCode MatMFFDRegisterAll(const char[]);
+PETSC_EXTERN PetscErrorCode MatMFFDRegisterAll(void);
 PETSC_EXTERN PetscErrorCode MatMFFDRegisterDestroy(void);
 PETSC_EXTERN PetscErrorCode MatMFFDDSSetUmin(Mat,PetscReal);
 PETSC_EXTERN PetscErrorCode MatMFFDWPSetComputeNormU(Mat,PetscBool );
 #endif
 
 #if defined(PETSC_HAVE_ELEMENTAL)
-PETSC_EXTERN PetscErrorCode PetscElementalInitializePackage(const char*);
+PETSC_EXTERN PetscErrorCode PetscElementalInitializePackage(void);
 PETSC_EXTERN PetscErrorCode PetscElementalFinalizePackage(void);
 #endif
 

include/petscpc.h

 #include <petscmat.h>
 #include <petscdmtypes.h>
 
-PETSC_EXTERN PetscErrorCode PCInitializePackage(const char[]);
+PETSC_EXTERN PetscErrorCode PCInitializePackage(void);
 
 /*
     PCList contains the list of preconditioners currently registered
 PETSC_EXTERN PetscErrorCode PCGetUseAmat(PC,PetscBool*);
 
 PETSC_EXTERN PetscErrorCode PCRegisterDestroy(void);
-PETSC_EXTERN PetscErrorCode PCRegisterAll(const char[]);
+PETSC_EXTERN PetscErrorCode PCRegisterAll(void);
 PETSC_EXTERN PetscBool PCRegisterAllCalled;
 
-PETSC_EXTERN PetscErrorCode PCRegister(const char[],const char[],const char[],PetscErrorCode(*)(PC));
+PETSC_EXTERN PetscErrorCode PCRegister(const char[],const char[],PetscErrorCode(*)(PC));
 
 PETSC_EXTERN PetscErrorCode PCReset(PC);
 PETSC_EXTERN PetscErrorCode PCDestroy(PC*);

include/petscpf.h

 PETSC_EXTERN PetscErrorCode PFApplyVec(PF,Vec,Vec);
 
 PETSC_EXTERN PetscErrorCode PFRegisterDestroy(void);
-PETSC_EXTERN PetscErrorCode PFRegisterAll(const char[]);
-PETSC_EXTERN PetscErrorCode PFInitializePackage(const char[]);
+PETSC_EXTERN PetscErrorCode PFRegisterAll(void);
+PETSC_EXTERN PetscErrorCode PFInitializePackage(void);
 PETSC_EXTERN PetscBool PFRegisterAllCalled;
 
-PETSC_EXTERN PetscErrorCode PFRegister(const char[],const char[],const char[],PetscErrorCode (*)(PF,void*));
+PETSC_EXTERN PetscErrorCode PFRegister(const char[],const char[],PetscErrorCode (*)(PF,void*));
 
 PETSC_EXTERN PetscErrorCode PFDestroy(PF*);
 PETSC_EXTERN PetscErrorCode PFSetFromOptions(PF);

include/petscsf.h

 
 PETSC_EXTERN PetscFunctionList PetscSFunctionList;
 PETSC_EXTERN PetscErrorCode PetscSFRegisterDestroy(void);
-PETSC_EXTERN PetscErrorCode PetscSFRegisterAll(const char[]);
-PETSC_EXTERN PetscErrorCode PetscSFRegister(const char[],const char[],const char[],PetscErrorCode (*)(PetscSF));
+PETSC_EXTERN PetscErrorCode PetscSFRegisterAll(void);
+PETSC_EXTERN PetscErrorCode PetscSFRegister(const char[],const char[],PetscErrorCode (*)(PetscSF));
 
-PETSC_EXTERN PetscErrorCode PetscSFInitializePackage(const char*);
+PETSC_EXTERN PetscErrorCode PetscSFInitializePackage(void);
 PETSC_EXTERN PetscErrorCode PetscSFFinalizePackage(void);
 PETSC_EXTERN PetscErrorCode PetscSFCreate(MPI_Comm comm,PetscSF*);
 PETSC_EXTERN PetscErrorCode PetscSFDestroy(PetscSF*);

include/petscsnes.h

 PETSC_EXTERN PetscClassId SNES_CLASSID;
 PETSC_EXTERN PetscClassId DMSNES_CLASSID;
 
-PETSC_EXTERN PetscErrorCode SNESInitializePackage(const char[]);
+PETSC_EXTERN PetscErrorCode SNESInitializePackage(void);
 
 PETSC_EXTERN PetscErrorCode SNESCreate(MPI_Comm,SNES*);
 PETSC_EXTERN PetscErrorCode SNESReset(SNES);
 PETSC_EXTERN PetscErrorCode SNESSetUpdate(SNES, PetscErrorCode (*)(SNES, PetscInt));
 
 PETSC_EXTERN PetscErrorCode SNESRegisterDestroy(void);
-PETSC_EXTERN PetscErrorCode SNESRegisterAll(const char[]);
+PETSC_EXTERN PetscErrorCode SNESRegisterAll(void);
 
-PETSC_EXTERN PetscErrorCode SNESRegister(const char[],const char[],const char[],PetscErrorCode (*)(SNES));
+PETSC_EXTERN PetscErrorCode SNESRegister(const char[],const char[],PetscErrorCode (*)(SNES));
 
 PETSC_EXTERN PetscErrorCode SNESGetKSP(SNES,KSP*);
 PETSC_EXTERN PetscErrorCode SNESSetKSP(SNES,KSP);
 PETSC_EXTERN PetscErrorCode SNESLineSearchBTGetAlpha(SNESLineSearch, PetscReal*);
 
 /*register line search types */
-PETSC_EXTERN PetscErrorCode SNESLineSearchRegister(const char[],const char[],const char[],PetscErrorCode(*)(SNESLineSearch));
-PETSC_EXTERN PetscErrorCode SNESLineSearchRegisterAll(const char path[]);
+PETSC_EXTERN PetscErrorCode SNESLineSearchRegister(const char[],const char[],PetscErrorCode(*)(SNESLineSearch));
+PETSC_EXTERN PetscErrorCode SNESLineSearchRegisterAll(void);
 PETSC_EXTERN PetscErrorCode SNESLineSearchRegisterDestroy(void);
 
 /* Routines for VI solver */
 PETSC_EXTERN PetscErrorCode SNESMSRegister(SNESMSType,PetscInt,PetscInt,PetscReal,const PetscReal[],const PetscReal[],const PetscReal[]);
 PETSC_EXTERN PetscErrorCode SNESMSSetType(SNES,SNESMSType);
 PETSC_EXTERN PetscErrorCode SNESMSFinalizePackage(void);
-PETSC_EXTERN PetscErrorCode SNESMSInitializePackage(const char path[]);
+PETSC_EXTERN PetscErrorCode SNESMSInitializePackage(void);
 PETSC_EXTERN PetscErrorCode SNESMSRegisterDestroy(void);
 PETSC_EXTERN PetscErrorCode SNESMSRegisterAll(void);
 

include/petscsys.h

 PETSC_EXTERN PetscErrorCode PetscFreeArguments(char **);
 
 PETSC_EXTERN PetscErrorCode PetscEnd(void);
-PETSC_EXTERN PetscErrorCode PetscSysInitializePackage(const char[]);
+PETSC_EXTERN PetscErrorCode PetscSysInitializePackage(void);
 
 PETSC_EXTERN MPI_Comm PETSC_COMM_LOCAL_WORLD;
 PETSC_EXTERN PetscErrorCode PetscHMPIMerge(PetscMPIInt,PetscErrorCode (*)(void*),void*);
 /* Logging support */
 PETSC_EXTERN PetscClassId PETSC_RANDOM_CLASSID;
 
-PETSC_EXTERN PetscErrorCode PetscRandomInitializePackage(const char[]);
+PETSC_EXTERN PetscErrorCode PetscRandomInitializePackage(void);
 
 /*S
      PetscRandom - Abstract PETSc object that manages generating random numbers
 PETSC_EXTERN PetscFunctionList PetscRandomList;
 PETSC_EXTERN PetscBool         PetscRandomRegisterAllCalled;
 
-PETSC_EXTERN PetscErrorCode PetscRandomRegisterAll(const char []);
-PETSC_EXTERN PetscErrorCode PetscRandomRegister(const char[],const char[],const char[],PetscErrorCode (*)(PetscRandom));
+PETSC_EXTERN PetscErrorCode PetscRandomRegisterAll(void);
+PETSC_EXTERN PetscErrorCode PetscRandomRegister(const char[],const char[],PetscErrorCode (*)(PetscRandom));
 PETSC_EXTERN PetscErrorCode PetscRandomRegisterDestroy(void);
 PETSC_EXTERN PetscErrorCode PetscRandomSetType(PetscRandom, PetscRandomType);
 PETSC_EXTERN PetscErrorCode PetscRandomSetFromOptions(PetscRandom);

include/petscthreadcomm.h

 
 PETSC_EXTERN PetscErrorCode PetscGetNCores(PetscInt*);
 PETSC_EXTERN PetscErrorCode PetscCommGetThreadComm(MPI_Comm,PetscThreadComm*);
-PETSC_EXTERN PetscErrorCode PetscThreadCommInitializePackage(const char *path);
+PETSC_EXTERN PetscErrorCode PetscThreadCommInitializePackage(void);
 PETSC_EXTERN PetscErrorCode PetscThreadCommFinalizePackage(void);
 PETSC_EXTERN PetscErrorCode PetscThreadCommInitialize(void);
 PETSC_EXTERN PetscErrorCode PetscThreadCommGetNThreads(MPI_Comm,PetscInt*);

include/petscts.h

 PETSC_EXTERN PetscClassId TS_CLASSID;
 PETSC_EXTERN PetscClassId DMTS_CLASSID;
 
-PETSC_EXTERN PetscErrorCode TSInitializePackage(const char[]);
+PETSC_EXTERN PetscErrorCode TSInitializePackage(void);
 
 PETSC_EXTERN PetscErrorCode TSCreate(MPI_Comm,TS*);
 PETSC_EXTERN PetscErrorCode TSDestroy(TS*);
 PETSC_EXTERN PetscBool         TSRegisterAllCalled;
 PETSC_EXTERN PetscErrorCode TSGetType(TS,TSType*);
 PETSC_EXTERN PetscErrorCode TSSetType(TS,TSType);
-PETSC_EXTERN PetscErrorCode TSRegister(const char[], const char[], const char[], PetscErrorCode (*)(TS));
-PETSC_EXTERN PetscErrorCode TSRegisterAll(const char[]);
+PETSC_EXTERN PetscErrorCode TSRegister(const char[], const char[], PetscErrorCode (*)(TS));
+PETSC_EXTERN PetscErrorCode TSRegisterAll(void);
 PETSC_EXTERN PetscErrorCode TSRegisterDestroy(void);
 
 PETSC_EXTERN PetscErrorCode TSGetSNES(TS,SNES*);
 #define TSADAPTCFL   "cfl"
 
 PETSC_EXTERN PetscErrorCode TSGetTSAdapt(TS,TSAdapt*);
-PETSC_EXTERN PetscErrorCode TSAdaptRegister(const char[],const char[],const char[],PetscErrorCode (*)(TSAdapt));
-PETSC_EXTERN PetscErrorCode TSAdaptRegisterAll(const char[]);
+PETSC_EXTERN PetscErrorCode TSAdaptRegister(const char[],const char[],PetscErrorCode (*)(TSAdapt));
+PETSC_EXTERN PetscErrorCode TSAdaptRegisterAll(void);
 PETSC_EXTERN PetscErrorCode TSAdaptRegisterDestroy(void);
-PETSC_EXTERN PetscErrorCode TSAdaptInitializePackage(const char[]);
+PETSC_EXTERN PetscErrorCode TSAdaptInitializePackage(void);
 PETSC_EXTERN PetscErrorCode TSAdaptFinalizePackage(void);
 PETSC_EXTERN PetscErrorCode TSAdaptCreate(MPI_Comm,TSAdapt*);
 PETSC_EXTERN PetscErrorCode TSAdaptSetType(TSAdapt,TSAdaptType);
 #define TSGLADAPT_SIZE "size"
 #define TSGLADAPT_BOTH "both"
 
-PETSC_EXTERN PetscErrorCode TSGLAdaptRegister(const char[],const char[],const char[],PetscErrorCode (*)(TSGLAdapt));
-PETSC_EXTERN PetscErrorCode TSGLAdaptRegisterAll(const char[]);
+PETSC_EXTERN PetscErrorCode TSGLAdaptRegister(const char[],const char[],PetscErrorCode (*)(TSGLAdapt));
+PETSC_EXTERN PetscErrorCode TSGLAdaptRegisterAll(void);
 PETSC_EXTERN PetscErrorCode TSGLAdaptRegisterDestroy(void);
-PETSC_EXTERN PetscErrorCode TSGLAdaptInitializePackage(const char[]);
+PETSC_EXTERN PetscErrorCode TSGLAdaptInitializePackage(void);
 PETSC_EXTERN PetscErrorCode TSGLAdaptFinalizePackage(void);
 PETSC_EXTERN PetscErrorCode TSGLAdaptCreate(MPI_Comm,TSGLAdapt*);
 PETSC_EXTERN PetscErrorCode TSGLAdaptSetType(TSGLAdapt,TSGLAdaptType);
 #define TSGLACCEPT_ALWAYS "always"
 
 PETSC_EXTERN_TYPEDEF typedef PetscErrorCode (*TSGLAcceptFunction)(TS,PetscReal,PetscReal,const PetscReal[],PetscBool *);
-PETSC_EXTERN PetscErrorCode TSGLAcceptRegister(const char[],const char[],const char[],TSGLAcceptFunction);
+PETSC_EXTERN PetscErrorCode TSGLAcceptRegister(const char[],const char[],TSGLAcceptFunction);
 
 /*J
   TSGLType - family of time integration method within the General Linear class
 typedef const char* TSGLType;
 #define TSGL_IRKS   "irks"
 
-PETSC_EXTERN PetscErrorCode TSGLRegister(const char[],const char[],const char[],PetscErrorCode(*)(TS));
-PETSC_EXTERN PetscErrorCode TSGLRegisterAll(const char[]);
+PETSC_EXTERN PetscErrorCode TSGLRegister(const char[],const char[],PetscErrorCode(*)(TS));
+PETSC_EXTERN PetscErrorCode TSGLRegisterAll(void);
 PETSC_EXTERN PetscErrorCode TSGLRegisterDestroy(void);
-PETSC_EXTERN PetscErrorCode TSGLInitializePackage(const char[]);
+PETSC_EXTERN PetscErrorCode TSGLInitializePackage(void);
 PETSC_EXTERN PetscErrorCode TSGLFinalizePackage(void);
 PETSC_EXTERN PetscErrorCode TSGLSetType(TS,TSGLType);
 PETSC_EXTERN PetscErrorCode TSGLGetAdapt(TS,TSGLAdapt*);
 PETSC_EXTERN PetscErrorCode TSARKIMEXSetFullyImplicit(TS,PetscBool);
 PETSC_EXTERN PetscErrorCode TSARKIMEXRegister(TSARKIMEXType,PetscInt,PetscInt,const PetscReal[],const PetscReal[],const PetscReal[],const PetscReal[],const PetscReal[],const PetscReal[],const PetscReal[],const PetscReal[],PetscInt,const PetscReal[],const PetscReal[]);
 PETSC_EXTERN PetscErrorCode TSARKIMEXFinalizePackage(void);
-PETSC_EXTERN PetscErrorCode TSARKIMEXInitializePackage(const char path[]);
+PETSC_EXTERN PetscErrorCode TSARKIMEXInitializePackage(void);
 PETSC_EXTERN PetscErrorCode TSARKIMEXRegisterDestroy(void);
 PETSC_EXTERN PetscErrorCode TSARKIMEXRegisterAll(void);
 
 PETSC_EXTERN PetscErrorCode TSRosWRegister(TSRosWType,PetscInt,PetscInt,const PetscReal[],const PetscReal[],const PetscReal[],const PetscReal[],PetscInt,const PetscReal[]);
 PETSC_EXTERN PetscErrorCode TSRosWRegisterRos4(TSRosWType,PetscReal,PetscReal,PetscReal,PetscReal,PetscReal);
 PETSC_EXTERN PetscErrorCode TSRosWFinalizePackage(void);
-PETSC_EXTERN PetscErrorCode TSRosWInitializePackage(const char path[]);
+PETSC_EXTERN PetscErrorCode TSRosWInitializePackage(void);
 PETSC_EXTERN PetscErrorCode TSRosWRegisterDestroy(void);
 PETSC_EXTERN PetscErrorCode TSRosWRegisterAll(void);
 

include/petscvec.h

 PETSC_EXTERN PetscClassId VEC_SCATTER_CLASSID;
 
 
-PETSC_EXTERN PetscErrorCode VecInitializePackage(const char[]);
+PETSC_EXTERN PetscErrorCode VecInitializePackage(void);
 PETSC_EXTERN PetscErrorCode VecFinalizePackage(void);
 
 PETSC_EXTERN PetscErrorCode VecCreate(MPI_Comm,Vec*);
 PETSC_EXTERN PetscBool         VecRegisterAllCalled;
 PETSC_EXTERN PetscErrorCode VecSetType(Vec, VecType);
 PETSC_EXTERN PetscErrorCode VecGetType(Vec, VecType *);
-PETSC_EXTERN PetscErrorCode VecRegister(const char[],const char[],const char[],PetscErrorCode (*)(Vec));
-PETSC_EXTERN PetscErrorCode VecRegisterAll(const char []);
+PETSC_EXTERN PetscErrorCode VecRegister(const char[],const char[],PetscErrorCode (*)(Vec));
+PETSC_EXTERN PetscErrorCode VecRegisterAll(void);
 PETSC_EXTERN PetscErrorCode VecRegisterDestroy(void);
 
 PETSC_EXTERN PetscErrorCode VecScatterCreate(Vec,IS,Vec,IS,VecScatter *);

include/petscviewer.h

 #define PETSCVIEWERAMS          "ams"
 
 PETSC_EXTERN PetscFunctionList PetscViewerList;
-PETSC_EXTERN PetscErrorCode PetscViewerRegisterAll(const char *);
+PETSC_EXTERN PetscErrorCode PetscViewerRegisterAll(void);
 PETSC_EXTERN PetscErrorCode PetscViewerRegisterDestroy(void);
-PETSC_EXTERN PetscErrorCode PetscViewerInitializePackage(const char[]);
+PETSC_EXTERN PetscErrorCode PetscViewerInitializePackage(void);
 
-PETSC_EXTERN PetscErrorCode PetscViewerRegister(const char*,const char*,const char*,PetscErrorCode (*)(PetscViewer));
+PETSC_EXTERN PetscErrorCode PetscViewerRegister(const char[],const char[],PetscErrorCode (*)(PetscViewer));
 
 PETSC_EXTERN PetscErrorCode PetscViewerCreate(MPI_Comm,PetscViewer*);
 PETSC_EXTERN PetscErrorCode PetscViewerSetFromOptions(PetscViewer);
 PETSC_EXTERN PetscErrorCode PetscViewerVUPrintDeferred(PetscViewer, const char [], ...);
 PETSC_EXTERN PetscErrorCode PetscViewerVUFlushDeferred(PetscViewer);
 
-PETSC_EXTERN PetscErrorCode PetscViewerMathematicaInitializePackage(const char[]);
+PETSC_EXTERN PetscErrorCode PetscViewerMathematicaInitializePackage(void);
 PETSC_EXTERN PetscErrorCode PetscViewerMathematicaFinalizePackage(void);
 PETSC_EXTERN PetscErrorCode PetscViewerMathematicaGetName(PetscViewer, const char **);
 PETSC_EXTERN PetscErrorCode PetscViewerMathematicaSetName(PetscViewer, const char []);

src/dm/impls/da/fdda.c

 
   PetscFunctionBegin;
 #if !defined(PETSC_USE_DYNAMIC_LIBRARIES)
-  ierr = MatInitializePackage(NULL);CHKERRQ(ierr);
+  ierr = MatInitializePackage();CHKERRQ(ierr);
 #endif
   if (!mtype) mtype = MATAIJ;
   ierr = PetscStrcpy((char*)ttype,mtype);CHKERRQ(ierr);

src/dm/impls/mesh/mesh.c

 
   PetscFunctionBegin;
 #if !defined(PETSC_USE_DYNAMIC_LIBRARIES)
-  ierr = MatInitializePackage(NULL);CHKERRQ(ierr);
+  ierr = MatInitializePackage();CHKERRQ(ierr);
 #endif
   if (!mtype) mtype = MATAIJ;
   if (mesh->useNewImpl) {
 
   PetscFunctionBegin;
 #if !defined(PETSC_USE_DYNAMIC_LIBRARIES)
-  ierr = MatInitializePackage(NULL);CHKERRQ(ierr);
+  ierr = MatInitializePackage();CHKERRQ(ierr);
 #endif
   if (!mtype) mtype = MATAIJ;
   ierr = DMMeshGetMesh(dm, m);CHKERRQ(ierr);

src/dm/impls/plex/plex.c

 
   PetscFunctionBegin;
 #if !defined(PETSC_USE_DYNAMIC_LIBRARIES)
-  ierr = MatInitializePackage(NULL);CHKERRQ(ierr);
+  ierr = MatInitializePackage();CHKERRQ(ierr);
 #endif
   if (!mtype) mtype = MATAIJ;
   ierr = DMGetDefaultSection(dm, &section);CHKERRQ(ierr);

src/dm/interface/dlregisdmdm.c

   from PetscDLLibraryRegister() when using dynamic libraries, and on the first call to AOCreate()
   or DMDACreate() when using static libraries.
 
-  Input Parameter:
-  path - The dynamic library path, or NULL
-
   Level: developer
 
 .keywords: AO, initialize, package
 .seealso: PetscInitialize()
 @*/
-PetscErrorCode  DMInitializePackage(const char path[])
+PetscErrorCode  DMInitializePackage(void)
 {
   char           logList[256];
   char           *className;
 #endif
 
 #if defined(PETSC_HAVE_HYPRE)
-  ierr = MatRegister(MATHYPRESTRUCT,    path,"MatCreate_HYPREStruct", MatCreate_HYPREStruct);CHKERRQ(ierr);
+  ierr = MatRegister(MATHYPRESTRUCT,"MatCreate_HYPREStruct", MatCreate_HYPREStruct);CHKERRQ(ierr);
 #endif
 
   /* Register Constructors */
-  ierr = DMRegisterAll(path);CHKERRQ(ierr);
+  ierr = DMRegisterAll();CHKERRQ(ierr);
   /* Register Events */
   ierr = PetscLogEventRegister("DMConvert",              DM_CLASSID,&DM_Convert);CHKERRQ(ierr);
   ierr = PetscLogEventRegister("DMGlobalToLocal",        DM_CLASSID,&DM_GlobalToLocal);CHKERRQ(ierr);
   This one registers all the mesh generators and partitioners that are in
   the basic DM library.
 
-  Input Parameter:
-  path - library path
 */
-PETSC_EXTERN PetscErrorCode PetscDLLibraryRegister_petscdm(const char path[])
+PETSC_EXTERN PetscErrorCode PetscDLLibraryRegister_petscdm(void)
 {
   PetscErrorCode ierr;
 
   PetscFunctionBegin;
-  ierr = AOInitializePackage(path);CHKERRQ(ierr);
-  ierr = DMInitializePackage(path);CHKERRQ(ierr);
+  ierr = AOInitializePackage();CHKERRQ(ierr);
+  ierr = DMInitializePackage();CHKERRQ(ierr);
   PetscFunctionReturn(0);
 }
 

src/dm/interface/dm.c

   PetscValidPointer(dm,2);
   *dm = NULL;
 #if !defined(PETSC_USE_DYNAMIC_LIBRARIES)
-  ierr = VecInitializePackage(NULL);CHKERRQ(ierr);
-  ierr = MatInitializePackage(NULL);CHKERRQ(ierr);
-  ierr = DMInitializePackage(NULL);CHKERRQ(ierr);
+  ierr = VecInitializePackage();CHKERRQ(ierr);
+  ierr = MatInitializePackage();CHKERRQ(ierr);
+  ierr = DMInitializePackage();CHKERRQ(ierr);
 #endif
 
   ierr = PetscHeaderCreate(v, _p_DM, struct _DMOps, DM_CLASSID, "DM", "Distribution Manager", "DM", comm, DMDestroy, DMView);CHKERRQ(ierr);
   PetscFunctionBegin;
   PetscValidHeaderSpecific(dm,DM_CLASSID,1);
 #if !defined(PETSC_USE_DYNAMIC_LIBRARIES)
-  ierr = MatInitializePackage(NULL);CHKERRQ(ierr);
+  ierr = MatInitializePackage();CHKERRQ(ierr);
 #endif
   PetscValidHeaderSpecific(dm,DM_CLASSID,1);
   PetscValidPointer(mat,3);
   ierr = PetscObjectTypeCompare((PetscObject) dm, method, &match);CHKERRQ(ierr);
   if (match) PetscFunctionReturn(0);
 
-  if (!DMRegisterAllCalled) {ierr = DMRegisterAll(NULL);CHKERRQ(ierr);}
+  if (!DMRegisterAllCalled) {ierr = DMRegisterAll();CHKERRQ(ierr);}
   ierr = PetscFunctionListFind(PetscObjectComm((PetscObject)dm), DMList, method,PETSC_TRUE,(void (**)(void)) &r);CHKERRQ(ierr);
   if (!r) SETERRQ1(PetscObjectComm((PetscObject)dm),PETSC_ERR_ARG_UNKNOWN_TYPE, "Unknown DM type: %s", method);
 
   PetscValidHeaderSpecific(dm, DM_CLASSID,1);
   PetscValidCharPointer(type,2);
   if (!DMRegisterAllCalled) {
-    ierr = DMRegisterAll(NULL);CHKERRQ(ierr);
+    ierr = DMRegisterAll();CHKERRQ(ierr);
   }
   *type = ((PetscObject)dm)->type_name;
   PetscFunctionReturn(0);
 .seealso: DMRegisterAll(), DMRegisterDestroy(), DMRegister()
 
 @*/
-PetscErrorCode  DMRegister(const char sname[], const char path[], const char name[], PetscErrorCode (*function)(DM))
+PetscErrorCode  DMRegister(const char sname[], const char name[], PetscErrorCode (*function)(DM))
 {
-  char           fullname[PETSC_MAX_PATH_LEN];
   PetscErrorCode ierr;
 
   PetscFunctionBegin;
-  ierr = PetscStrcpy(fullname, path);CHKERRQ(ierr);
-  ierr = PetscStrcat(fullname, ":");CHKERRQ(ierr);
-  ierr = PetscStrcat(fullname, name);CHKERRQ(ierr);
-  ierr = PetscFunctionListAdd(PETSC_COMM_WORLD,&DMList, sname, fullname, (void (*)(void))function);CHKERRQ(ierr);
+  ierr = PetscFunctionListAdd(PETSC_COMM_WORLD,&DMList, sname, name, (void (*)(void))function);CHKERRQ(ierr);
   PetscFunctionReturn(0);
 }
 
 #undef __FUNCT__
 #define __FUNCT__ "DMRegisterDestroy"
 /*@C
-   DMRegisterDestroy - Frees the list of DM methods that were registered by DMRegister()/DMRegister().
+   DMRegisterDestroy - Frees the list of DM methods that were registered by DMRegister().
 
    Not Collective
 
    Level: advanced
 
 .keywords: DM, register, destroy
-.seealso: DMRegister(), DMRegisterAll(), DMRegister()
+.seealso: DMRegister(), DMRegisterAll()
 @*/
 PetscErrorCode  DMRegisterDestroy(void)
 {

src/dm/interface/dmregall.c

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

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

   /*
        First register a new PC type with the command PCRegister()
   */
-  ierr = PCRegister("ourjacobi",0,"PCCreate_Jacobi",PCCreate_Jacobi);CHKERRQ(ierr);
+  ierr = PCRegister("ourjacobi","PCCreate_Jacobi",PCCreate_Jacobi);CHKERRQ(ierr);
 
   /*
      Set the PC type to be the new method

src/ksp/ksp/interface/dlregisksp.c

   from PetscDLLibraryRegister() when using dynamic libraries, and on the first call to PCCreate()
   when using static libraries.
 
-  Input Parameter:
-  path - The dynamic library path, or NULL
-
   Level: developer
 
 .keywords: PC, initialize, package
 .seealso: PetscInitialize()
 @*/
-PetscErrorCode  PCInitializePackage(const char path[])
+PetscErrorCode  PCInitializePackage(void)
 {
   char           logList[256];
   char           *className;
   /* Register Classes */
   ierr = PetscClassIdRegister("Preconditioner",&PC_CLASSID);CHKERRQ(ierr);
   /* Register Constructors */
-  ierr = PCRegisterAll(path);CHKERRQ(ierr);
+  ierr = PCRegisterAll();CHKERRQ(ierr);
   /* Register Events */
   ierr = PetscLogEventRegister("PCSetUp",          PC_CLASSID,&PC_SetUp);CHKERRQ(ierr);
   ierr = PetscLogEventRegister("PCSetUpOnBlocks",  PC_CLASSID,&PC_SetUpOnBlocks);CHKERRQ(ierr);
   from PetscDLLibraryRegister() when using dynamic libraries, and on the first call to KSPCreate()
   when using static libraries.
 
-  Input Parameter:
-  path - The dynamic library path, or NULL
-
   Level: developer
 
 .keywords: KSP, initialize, package
 .seealso: PetscInitialize()
 @*/
-PetscErrorCode  KSPInitializePackage(const char path[])
+PetscErrorCode  KSPInitializePackage(void)
 {
   char           logList[256];
   char           *className;
   ierr = PetscClassIdRegister("Krylov Solver",&KSP_CLASSID);CHKERRQ(ierr);
   ierr = PetscClassIdRegister("DMKSP interface",&DMKSP_CLASSID);CHKERRQ(ierr);
   /* Register Constructors */
-  ierr = KSPRegisterAll(path);CHKERRQ(ierr);
+  ierr = KSPRegisterAll();CHKERRQ(ierr);
   /* Register matrix implementations packaged in KSP */
-  ierr = KSPMatRegisterAll(path);CHKERRQ(ierr);
+  ierr = KSPMatRegisterAll();CHKERRQ(ierr);
   /* Register Events */
   ierr = PetscLogEventRegister("KSPGMRESOrthog",   KSP_CLASSID,&KSP_GMRESOrthogonalization);CHKERRQ(ierr);
   ierr = PetscLogEventRegister("KSPSetUp",         KSP_CLASSID,&KSP_SetUp);CHKERRQ(ierr);
   This one registers all the KSP and PC methods that are in the basic PETSc libpetscksp
   library.
 
-  Input Parameter:
-  path - library path
  */
-PETSC_EXTERN PetscErrorCode PetscDLLibraryRegister_petscksp(const char path[])
+PETSC_EXTERN PetscErrorCode PetscDLLibraryRegister_petscksp(void)
 {
   PetscErrorCode ierr;
 
   PetscFunctionBegin;
-  ierr = PCInitializePackage(path);CHKERRQ(ierr);
-  ierr = KSPInitializePackage(path);CHKERRQ(ierr);
+  ierr = PCInitializePackage();CHKERRQ(ierr);
+  ierr = KSPInitializePackage();CHKERRQ(ierr);
   PetscFunctionReturn(0);
 }
 

src/ksp/ksp/interface/dmksp.c

 
   PetscFunctionBegin;
 #if !defined(PETSC_USE_DYNAMIC_LIBRARIES)
-  ierr = KSPInitializePackage(NULL);CHKERRQ(ierr);
+  ierr = KSPInitializePackage();CHKERRQ(ierr);
 #endif
   ierr = PetscHeaderCreate(*kdm, _p_DMKSP, struct _DMKSPOps, DMKSP_CLASSID, "DMKSP", "DMKSP", "DMKSP", comm, DMKSPDestroy, NULL);CHKERRQ(ierr);
   ierr = PetscMemzero((*kdm)->ops, sizeof(struct _DMKSPOps));CHKERRQ(ierr);

src/ksp/ksp/interface/itcl.c

   if (!ksp->pc) {ierr = KSPGetPC(ksp,&ksp->pc);CHKERRQ(ierr);}
   ierr = PCSetFromOptions(ksp->pc);CHKERRQ(ierr);
 
-  if (!KSPRegisterAllCalled) {ierr = KSPRegisterAll(NULL);CHKERRQ(ierr);}
+  if (!KSPRegisterAllCalled) {ierr = KSPRegisterAll();CHKERRQ(ierr);}
   ierr = PetscObjectOptionsBegin((PetscObject)ksp);CHKERRQ(ierr);
   ierr = PetscOptionsList("-ksp_type","Krylov method","KSPSetType",KSPList,(char*)(((PetscObject)ksp)->type_name ? ((PetscObject)ksp)->type_name : KSPGMRES),type,256,&flg);CHKERRQ(ierr);
   if (flg) {

src/ksp/ksp/interface/itcreate.c

   PetscValidPointer(inksp,2);
   *inksp = 0;
 #if !defined(PETSC_USE_DYNAMIC_LIBRARIES)
-  ierr = KSPInitializePackage(NULL);CHKERRQ(ierr);
+  ierr = KSPInitializePackage();CHKERRQ(ierr);
 #endif
 
   ierr = PetscHeaderCreate(ksp,_p_KSP,struct _KSPOps,KSP_CLASSID,"KSP","Krylov Method","KSP",comm,KSPDestroy,KSPView);CHKERRQ(ierr);
 .seealso: KSPRegisterAll(), KSPRegisterDestroy()
 
 @*/
-PetscErrorCode  KSPRegister(const char sname[],const char path[],const char name[],PetscErrorCode (*function)(KSP))
+PetscErrorCode  KSPRegister(const char sname[],const char name[],PetscErrorCode (*function)(KSP))
 {
   PetscErrorCode ierr;
-  char           fullname[PETSC_MAX_PATH_LEN];
 
   PetscFunctionBegin;
-  ierr = PetscFunctionListConcat(path,name,fullname);CHKERRQ(ierr);
-  ierr = PetscFunctionListAdd(PETSC_COMM_WORLD,&KSPList,sname,fullname,(void (*)(void))function);CHKERRQ(ierr);
+  ierr = PetscFunctionListAdd(PETSC_COMM_WORLD,&KSPList,sname,name,(void (*)(void))function);CHKERRQ(ierr);
   PetscFunctionReturn(0);
 }
 

src/ksp/ksp/interface/itregis.c

 
 .seealso:  KSPRegisterDestroy()
 @*/
-PetscErrorCode  KSPRegisterAll(const char path[])
+PetscErrorCode  KSPRegisterAll(void)
 {
   PetscErrorCode ierr;
 
   PetscFunctionBegin;
   KSPRegisterAllCalled = PETSC_TRUE;
 
-  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);
+  ierr = KSPRegister(KSPCG,         "KSPCreate_CG",        KSPCreate_CG);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPGROPPCG,    "KSPCreate_GROPPCG",   KSPCreate_GROPPCG);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPPIPECG,     "KSPCreate_PIPECG",    KSPCreate_PIPECG);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPCGNE,       "KSPCreate_CGNE",      KSPCreate_CGNE);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPNASH,       "KSPCreate_NASH",      KSPCreate_NASH);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPSTCG,       "KSPCreate_STCG",      KSPCreate_STCG);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPGLTR,       "KSPCreate_GLTR",      KSPCreate_GLTR);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPRICHARDSON, "KSPCreate_Richardson",KSPCreate_Richardson);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPCHEBYSHEV,  "KSPCreate_Chebyshev", KSPCreate_Chebyshev);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPGMRES,      "KSPCreate_GMRES",     KSPCreate_GMRES);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPTCQMR,      "KSPCreate_TCQMR",     KSPCreate_TCQMR);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPBCGS,       "KSPCreate_BCGS",      KSPCreate_BCGS);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPIBCGS,      "KSPCreate_IBCGS",     KSPCreate_IBCGS);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPFBCGS,      "KSPCreate_FBCGS",     KSPCreate_FBCGS);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPFBCGSR,     "KSPCreate_FBCGSR",    KSPCreate_FBCGSR);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPBCGSL,      "KSPCreate_BCGSL",     KSPCreate_BCGSL);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPCGS,        "KSPCreate_CGS",       KSPCreate_CGS);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPTFQMR,      "KSPCreate_TFQMR",     KSPCreate_TFQMR);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPCR,         "KSPCreate_CR",        KSPCreate_CR);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPPIPECR,     "KSPCreate_PIPECR",    KSPCreate_PIPECR);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPLSQR,       "KSPCreate_LSQR",      KSPCreate_LSQR);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPPREONLY,    "KSPCreate_PREONLY",   KSPCreate_PREONLY);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPQCG,        "KSPCreate_QCG",       KSPCreate_QCG);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPBICG,       "KSPCreate_BiCG",      KSPCreate_BiCG);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPFGMRES,     "KSPCreate_FGMRES",    KSPCreate_FGMRES);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPMINRES,     "KSPCreate_MINRES",    KSPCreate_MINRES);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPSYMMLQ,     "KSPCreate_SYMMLQ",    KSPCreate_SYMMLQ);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPLGMRES,     "KSPCreate_LGMRES",    KSPCreate_LGMRES);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPLCD,        "KSPCreate_LCD",       KSPCreate_LCD);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPGCR,        "KSPCreate_GCR",       KSPCreate_GCR);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPPGMRES,     "KSPCreate_PGMRES",    KSPCreate_PGMRES);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPSPECEST,    "KSPCreate_SpecEst",  KSPCreate_SpecEst);CHKERRQ(ierr);
 #if !defined(PETSC_USE_COMPLEX)
-  ierr = KSPRegister(KSPDGMRES,     path,"KSPCreate_DGMRES", KSPCreate_DGMRES);CHKERRQ(ierr);
+  ierr = KSPRegister(KSPDGMRES,     "KSPCreate_DGMRES", KSPCreate_DGMRES);CHKERRQ(ierr);
 #endif
   PetscFunctionReturn(0);
 }

src/ksp/ksp/utils/schurm.c

 
 .seealso: MatRegisterAll(), MatRegisterDestroy(), KSPInitializePackage()
 @*/
-PetscErrorCode KSPMatRegisterAll(const char path[])
+PetscErrorCode KSPMatRegisterAll()
 {
   PetscErrorCode ierr;
 
   PetscFunctionBegin;
   if (KSPMatRegisterAllCalled) PetscFunctionReturn(0);
   KSPMatRegisterAllCalled = PETSC_TRUE;
-  ierr = MatRegister(MATSCHURCOMPLEMENT,path,"MatCreate_SchurComplement",MatCreate_SchurComplement);CHKERRQ(ierr);
+  ierr = MatRegister(MATSCHURCOMPLEMENT,"MatCreate_SchurComplement",MatCreate_SchurComplement);CHKERRQ(ierr);
   PetscFunctionReturn(0);
 }

src/ksp/pc/impls/factor/factimpl.c

   PetscEnum         etmp;
 
   PetscFunctionBegin;
-  if (!MatOrderingRegisterAllCalled) {ierr = MatOrderingRegisterAll(NULL);CHKERRQ(ierr);}
+  if (!MatOrderingRegisterAllCalled) {ierr = MatOrderingRegisterAll();CHKERRQ(ierr);}
   ierr = PetscOptionsBool("-pc_factor_in_place","Form factored matrix in the same memory as the matrix","PCFactorSetUseInPlace",flg,&flg,NULL);CHKERRQ(ierr);
   if (flg) {
     ierr = PCFactorSetUseInPlace(pc);CHKERRQ(ierr);

src/ksp/pc/interface/pcregis.c

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

src/ksp/pc/interface/pcset.c

   PetscFunctionBegin;
   PetscValidHeaderSpecific(pc,PC_CLASSID,1);
 
-  if (!PCRegisterAllCalled) {ierr = PCRegisterAll(NULL);CHKERRQ(ierr);}
+  if (!PCRegisterAllCalled) {ierr = PCRegisterAll();CHKERRQ(ierr);}
   ierr = PetscObjectOptionsBegin((PetscObject)pc);CHKERRQ(ierr);
   if (!((PetscObject)pc)->type_name) {
     ierr = PCGetDefaultType_Private(pc,&def);CHKERRQ(ierr);

src/ksp/pc/interface/precon.c

   PetscValidPointer(newpc,1);
   *newpc = 0;
 #if !defined(PETSC_USE_DYNAMIC_LIBRARIES)
-  ierr = PCInitializePackage(NULL);CHKERRQ(ierr);
+  ierr = PCInitializePackage();CHKERRQ(ierr);
 #endif
 
   ierr = PetscHeaderCreate(pc,_p_PC,struct _PCOps,PC_CLASSID,"PC","Preconditioner","PC",comm,PCDestroy,PCView);CHKERRQ(ierr);
 
 .seealso: PCRegisterAll(), PCRegisterDestroy()
 @*/
-PetscErrorCode  PCRegister(const char sname[],const char path[],const char name[],PetscErrorCode (*function)(PC))
+PetscErrorCode  PCRegister(const char sname[],const char name[],PetscErrorCode (*function)(PC))
 {
   PetscErrorCode ierr;
-  char           fullname[PETSC_MAX_PATH_LEN];
 
   PetscFunctionBegin;
-  ierr = PetscFunctionListConcat(path,name,fullname);CHKERRQ(ierr);
-  ierr = PetscFunctionListAdd(PETSC_COMM_WORLD,&PCList,sname,fullname,(void (*)(void))function);CHKERRQ(ierr);
+  ierr = PetscFunctionListAdd(PETSC_COMM_WORLD,&PCList,sname,name,(void (*)(void))function);CHKERRQ(ierr);
   PetscFunctionReturn(0);
 }
 

src/mat/coarsen/coarsen.c

 
 .seealso: MatCoarsenRegisterDestroy(), MatCoarsenRegisterAll()
 @*/
-PetscErrorCode  MatCoarsenRegister(const char sname[],const char path[],const char name[],PetscErrorCode (*function)(MatCoarsen))
+PetscErrorCode  MatCoarsenRegister(const char sname[],const char name[],PetscErrorCode (*function)(MatCoarsen))
 {
   PetscErrorCode ierr;
-  char           fullname[PETSC_MAX_PATH_LEN];
 
   PetscFunctionBegin;
-  ierr = PetscFunctionListConcat(path,name,fullname);CHKERRQ(ierr);
-  ierr = PetscFunctionListAdd(PETSC_COMM_WORLD,&MatCoarsenList,sname,fullname,(void (*)(void))function);CHKERRQ(ierr);
+  ierr = PetscFunctionListAdd(PETSC_COMM_WORLD,&MatCoarsenList,sname,name,(void (*)(void))function);CHKERRQ(ierr);
   PetscFunctionReturn(0);
 }
 
   *newcrs = 0;
 
 #if !defined(PETSC_USE_DYNAMIC_LIBRARIES)
-  ierr = MatInitializePackage(NULL);CHKERRQ(ierr);
+  ierr = MatInitializePackage();CHKERRQ(ierr);
 #endif
   ierr = PetscHeaderCreate(agg, _p_MatCoarsen, struct _MatCoarsenOps, MAT_COARSEN_CLASSID,"MatCoarsen","Matrix/graph coarsen",
                            "MatCoarsen", comm, MatCoarsenDestroy, MatCoarsenView);CHKERRQ(ierr);

src/mat/coarsen/scoarsen.c

 
  .seealso: MatCoarsenRegister(), MatCoarsenRegisterDestroy()
  @*/
-PetscErrorCode  MatCoarsenRegisterAll(const char path[])
+PetscErrorCode  MatCoarsenRegisterAll(void)
 {
   PetscErrorCode ierr;
 
   PetscFunctionBegin;
   MatCoarsenRegisterAllCalled = PETSC_TRUE;
 
-  ierr = MatCoarsenRegister(MATCOARSENMIS,path,"MatCoarsenCreate_MIS",MatCoarsenCreate_MIS);CHKERRQ(ierr);
-  ierr = MatCoarsenRegister(MATCOARSENHEM,path,"MatCoarsenCreate_HEM",MatCoarsenCreate_HEM);CHKERRQ(ierr);
+  ierr = MatCoarsenRegister(MATCOARSENMIS,"MatCoarsenCreate_MIS",MatCoarsenCreate_MIS);CHKERRQ(ierr);
+  ierr = MatCoarsenRegister(MATCOARSENHEM,"MatCoarsenCreate_HEM",MatCoarsenCreate_HEM);CHKERRQ(ierr);
   PetscFunctionReturn(0);
 }
 

src/mat/color/color.c

 
 .seealso: MatColoringRegisterDestroy(), MatColoringRegisterAll()
 @*/
-PetscErrorCode  MatColoringRegister(const char sname[],const char path[],const char name[],PetscErrorCode (*function)(Mat,MatColoringType,ISColoring*))
+PetscErrorCode  MatColoringRegister(const char sname[],const char name[],PetscErrorCode (*function)(Mat,MatColoringType,ISColoring*))
 {
   PetscErrorCode ierr;
-  char           fullname[PETSC_MAX_PATH_LEN];
 
   PetscFunctionBegin;
-  ierr = PetscFunctionListConcat(path,name,fullname);CHKERRQ(ierr);
-  ierr = PetscFunctionListAdd(PETSC_COMM_WORLD,&MatColoringList,sname,fullname,(void (*)(void))function);CHKERRQ(ierr);
+  ierr = PetscFunctionListAdd(PETSC_COMM_WORLD,&MatColoringList,sname,name,(void (*)(void))function);CHKERRQ(ierr);
   PetscFunctionReturn(0);
 }
 
   if (mat->factortype) SETERRQ(PetscObjectComm((PetscObject)mat),PETSC_ERR_ARG_WRONGSTATE,"Not for factored matrix");
 
   /* look for type on command line */
-  if (!MatColoringRegisterAllCalled) {ierr = MatColoringRegisterAll(NULL);CHKERRQ(ierr);}
+  if (!MatColoringRegisterAllCalled) {ierr = MatColoringRegisterAll();CHKERRQ(ierr);}
   ierr = PetscOptionsGetString(((PetscObject)mat)->prefix,"-mat_coloring_type",tname,256,&flag);CHKERRQ(ierr);
   if (flag) type = tname;
 

src/mat/color/scolor.c

 
 .seealso: MatColoringRegister(), MatColoringRegisterDestroy()
 @*/
-PetscErrorCode MatColoringRegisterAll(const char path[])
+PetscErrorCode MatColoringRegisterAll(void)
 {
   PetscErrorCode ierr;
 
   PetscFunctionBegin;
   MatColoringRegisterAllCalled = PETSC_TRUE;
 
-  ierr = MatColoringRegister(MATCOLORINGNATURAL,path,"MatGetColoring_Natural",   MatGetColoring_Natural);CHKERRQ(ierr);
-  ierr = MatColoringRegister(MATCOLORINGSL,     path,"MatGetColoring_SL_Minpack",MatGetColoring_SL_Minpack);CHKERRQ(ierr);
-  ierr = MatColoringRegister(MATCOLORINGLF,     path,"MatGetColoring_LF_Minpack",MatGetColoring_LF_Minpack);CHKERRQ(ierr);
-  ierr = MatColoringRegister(MATCOLORINGID,     path,"MatGetColoring_ID_Minpack",MatGetColoring_ID_Minpack);CHKERRQ(ierr);
+  ierr = MatColoringRegister(MATCOLORINGNATURAL,"MatGetColoring_Natural",   MatGetColoring_Natural);CHKERRQ(ierr);
+  ierr = MatColoringRegister(MATCOLORINGSL,     "MatGetColoring_SL_Minpack",MatGetColoring_SL_Minpack);CHKERRQ(ierr);
+  ierr = MatColoringRegister(MATCOLORINGLF,     "MatGetColoring_LF_Minpack",MatGetColoring_LF_Minpack);CHKERRQ(ierr);
+  ierr = MatColoringRegister(MATCOLORINGID,     "MatGetColoring_ID_Minpack",MatGetColoring_ID_Minpack);CHKERRQ(ierr);
   PetscFunctionReturn(0);
 }
 

src/mat/impls/aij/mpi/clique/clique.cxx

 
 #undef __FUNCT__
 #define __FUNCT__ "PetscCliqueInitializePackage"
-PetscErrorCode PetscCliqueInitializePackage(const char *path)
+PetscErrorCode PetscCliqueInitializePackage(void)
 {
   PetscErrorCode ierr;
 
   PetscErrorCode ierr;
 
   PetscFunctionBegin;
-  ierr = PetscCliqueInitializePackage(NULL);CHKERRQ(ierr);
+  ierr = PetscCliqueInitializePackage();CHKERRQ(ierr);
   ierr = MatCreate(PetscObjectComm((PetscObject)A),&B);CHKERRQ(ierr);
   ierr = MatSetSizes(B,A->rmap->n,A->cmap->n,PETSC_DETERMINE,PETSC_DETERMINE);CHKERRQ(ierr);
   ierr = MatSetType(B,((PetscObject)A)->type_name);CHKERRQ(ierr);

src/mat/impls/elemental/matelem.cxx

 
    Logically Collective
 
-   Input Arguments:
-.  path - the dynamic library path or NULL
-
    Level: developer
 
 .seealso: MATELEMENTAL, PetscElementalFinalizePackage()
 @*/
-PetscErrorCode PetscElementalInitializePackage(const char *path)
+PetscErrorCode PetscElementalInitializePackage(void)
 {
   PetscErrorCode ierr;
 
   PetscInt           optv1,optv2;
 
   PetscFunctionBegin;
-  ierr = PetscElementalInitializePackage(NULL);CHKERRQ(ierr);
+  ierr = PetscElementalInitializePackage();CHKERRQ(ierr);
   ierr = PetscMemcpy(A->ops,&MatOps_Values,sizeof(struct _MatOps));CHKERRQ(ierr);
   A->insertmode = NOT_SET_VALUES;
 

src/mat/impls/mffd/mffd.c

   from PetscDLLibraryRegister() when using dynamic libraries, and on the first call to MatCreate_MFFD()
   when using static libraries.
 
-  Input Parameter:
-. path - The dynamic library path, or NULL
-
   Level: developer
 
 .keywords: Vec, initialize, package
 .seealso: PetscInitialize()
 @*/
-PetscErrorCode  MatMFFDInitializePackage(const char path[])
+PetscErrorCode  MatMFFDInitializePackage(void)
 {
   char           logList[256];
   char           *className;
   /* Register Classes */
   ierr = PetscClassIdRegister("MatMFFD",&MATMFFD_CLASSID);CHKERRQ(ierr);
   /* Register Constructors */
-  ierr = MatMFFDRegisterAll(path);CHKERRQ(ierr);
+  ierr = MatMFFDRegisterAll();CHKERRQ(ierr);
   /* Register Events */
   ierr = PetscLogEventRegister("MatMult MF",          MATMFFD_CLASSID,&MATMFFD_Mult);CHKERRQ(ierr);
 
 
 .seealso: MatMFFDRegisterAll(), MatMFFDRegisterDestroy()
  @*/
-PetscErrorCode  MatMFFDRegister(const char sname[],const char path[],const char name[],PetscErrorCode (*function)(MatMFFD))
+PetscErrorCode  MatMFFDRegister(const char sname[],const char name[],PetscErrorCode (*function)(MatMFFD))
 {
   PetscErrorCode ierr;
-  char           fullname[PETSC_MAX_PATH_LEN];
 
   PetscFunctionBegin;
-  ierr = PetscFunctionListConcat(path,name,fullname);CHKERRQ(ierr);
-  ierr = PetscFunctionListAdd(PETSC_COMM_WORLD,&MatMFFDList,sname,fullname,(void (*)(void))function);CHKERRQ(ierr);
+  ierr = PetscFunctionListAdd(PETSC_COMM_WORLD,&MatMFFDList,sname,name,(void (*)(void))function);CHKERRQ(ierr);
   PetscFunctionReturn(0);
 }
 
 
   PetscFunctionBegin;
 #if !defined(PETSC_USE_DYNAMIC_LIBRARIES)
-  ierr = MatMFFDInitializePackage(NULL);CHKERRQ(ierr);
+  ierr = MatMFFDInitializePackage();CHKERRQ(ierr);
 #endif
 
   ierr = PetscHeaderCreate(mfctx,_p_MatMFFD,struct _MFOps,MATMFFD_CLASSID,"MatMFFD","Matrix-free Finite Differencing","Mat",PetscObjectComm((PetscObject)A),MatDestroy_MFFD,MatView_MFFD);CHKERRQ(ierr);

src/mat/impls/mffd/mfregis.c

 .seealso:  MatMFFDRegisterDestroy(), MatMFFDRegisterDynamic), MatCreateMFFD(),
            MatMFFDSetType()
 @*/
-PetscErrorCode  MatMFFDRegisterAll(const char *path)
+PetscErrorCode  MatMFFDRegisterAll(void)
 {
   PetscErrorCode ierr;
 
   PetscFunctionBegin;
   MatMFFDRegisterAllCalled = PETSC_TRUE;
 
-  ierr = MatMFFDRegister(MATMFFD_DS,path,"MatCreateMFFD_DS",MatCreateMFFD_DS);CHKERRQ(ierr);
-  ierr = MatMFFDRegister(MATMFFD_WP,path,"MatCreateMFFD_WP",MatCreateMFFD_WP);CHKERRQ(ierr);
+  ierr = MatMFFDRegister(MATMFFD_DS,"MatCreateMFFD_DS",MatCreateMFFD_DS);CHKERRQ(ierr);
+  ierr = MatMFFDRegister(MATMFFD_WP,"MatCreateMFFD_WP",MatCreateMFFD_WP);CHKERRQ(ierr);
   PetscFunctionReturn(0);
 }
 

src/mat/interface/dlregismat.c

 const char *const MPChacoLocalTypes[] = {"","KERNIGHAN","NONE","MPChacoLocalType","MP_CHACO_",0};
 const char *const MPChacoEigenTypes[] = {"LANCZOS","RQI","MPChacoEigenType","MP_CHACO_",0};
 
-extern PetscErrorCode  MatMFFDInitializePackage(const char[]);
+extern PetscErrorCode  MatMFFDInitializePackage(void);
 static PetscBool MatPackageInitialized = PETSC_FALSE;
 #undef __FUNCT__
 #define __FUNCT__ "MatFinalizePackage"
   from PetscDLLibraryRegister() when using dynamic libraries, and on the first call to MatCreate()
   when using static libraries.
 
-  Input Parameter:
-  path - The dynamic library path, or NULL
-
   Level: developer
 
 .keywords: Mat, initialize, package
 .seealso: PetscInitialize()
 @*/
-PetscErrorCode  MatInitializePackage(const char path[])
+PetscErrorCode  MatInitializePackage(void)
 {
   char           logList[256];
   char           *className;
   if (MatPackageInitialized) PetscFunctionReturn(0);
   MatPackageInitialized = PETSC_TRUE;
   /* Inialize subpackage */
-  ierr = MatMFFDInitializePackage(path);CHKERRQ(ierr);
+  ierr = MatMFFDInitializePackage();CHKERRQ(ierr);
   /* Register Classes */
   ierr = PetscClassIdRegister("Matrix",&MAT_CLASSID);CHKERRQ(ierr);
   ierr = PetscClassIdRegister("Matrix FD Coloring",&MAT_FDCOLORING_CLASSID);CHKERRQ(ierr);
   ierr = PetscClassIdRegister("Matrix Coarsen",&MAT_COARSEN_CLASSID);CHKERRQ(ierr);
   ierr = PetscClassIdRegister("Matrix Null Space",&MAT_NULLSPACE_CLASSID);CHKERRQ(ierr);
   /* Register Constructors */
-  ierr = MatRegisterAll(path);CHKERRQ(ierr);
-  ierr = MatOrderingRegisterAll(path);CHKERRQ(ierr);
-  ierr = MatColoringRegisterAll(path);CHKERRQ(ierr);
-  ierr = MatPartitioningRegisterAll(path);CHKERRQ(ierr);
-  ierr = MatCoarsenRegisterAll(path);CHKERRQ(ierr);
+  ierr = MatRegisterAll();CHKERRQ(ierr);
+  ierr = MatOrderingRegisterAll();CHKERRQ(ierr);
+  ierr = MatColoringRegisterAll();CHKERRQ(ierr);
+  ierr = MatPartitioningRegisterAll();CHKERRQ(ierr);
+  ierr = MatCoarsenRegisterAll();CHKERRQ(ierr);
   /* Register Events */
   ierr = PetscLogEventRegister("MatMult",          MAT_CLASSID,&MAT_Mult);CHKERRQ(ierr);
   ierr = PetscLogEventRegister("MatMults",         MAT_CLASSID,&MAT_Mults);CHKERRQ(ierr);
 
   This one registers all the matrix methods that are in the basic PETSc Matrix library.
 
-  Input Parameter:
-  path - library path
  */
-PETSC_EXTERN PetscErrorCode PetscDLLibraryRegister_petscmat(const char path[])
+PETSC_EXTERN PetscErrorCode PetscDLLibraryRegister_petscmat(void)
 {
   PetscErrorCode ierr;
 
   PetscFunctionBegin;
-  ierr = MatInitializePackage(path);CHKERRQ(ierr);
+  ierr = MatInitializePackage();CHKERRQ(ierr);
   PetscFunctionReturn(0);
 }
 

src/mat/interface/matnull.c

 
   *SP = NULL;
 #if !defined(PETSC_USE_DYNAMIC_LIBRARIES)
-  ierr = MatInitializePackage(NULL);CHKERRQ(ierr);
+  ierr = MatInitializePackage();CHKERRQ(ierr);
 #endif
 
   ierr = PetscHeaderCreate(sp,_p_MatNullSpace,int,MAT_NULLSPACE_CLASSID,"MatNullSpace","Null space","Mat",comm,MatNullSpaceDestroy,MatNullSpaceView);CHKERRQ(ierr);

src/mat/interface/matreg.c

 #define __FUNCT__ "MatRegisterDestroy"
 /*@C
    MatRegisterDestroy - Frees the list of matrix types that were
-   registered by MatRegister()/MatRegister().
+   registered by MatRegister().
 
    Not Collective
 
 
 .keywords: Mat, register, destroy
 
-.seealso: MatRegister(), MatRegisterAll(), MatRegister()
+.seealso: MatRegister(), MatRegisterAll()
 @*/
 PetscErrorCode  MatRegisterDestroy(void)
 {
 
   Level: advanced
 @*/
-PetscErrorCode  MatRegister(const char sname[],const char path[],const char name[],PetscErrorCode (*function)(Mat))
+PetscErrorCode  MatRegister(const char sname[],const char name[],PetscErrorCode (*function)(Mat))
 {
   PetscErrorCode ierr;
-  char           fullname[PETSC_MAX_PATH_LEN];
 
   PetscFunctionBegin;
-  ierr = PetscFunctionListConcat(path,name,fullname);CHKERRQ(ierr);
-  ierr = PetscFunctionListAdd(PETSC_COMM_WORLD,&MatList,sname,fullname,(void (*)(void))function);CHKERRQ(ierr);
+  ierr = PetscFunctionListAdd(PETSC_COMM_WORLD,&MatList,sname,name,(void (*)(void))function);CHKERRQ(ierr);
   PetscFunctionReturn(0);
 }
 

src/mat/interface/matregis.c

 
 .seealso:  MatRegisterDestroy()
 @*/
-PetscErrorCode  MatRegisterAll(const char path[])
+PetscErrorCode  MatRegisterAll(void)
 {
   PetscErrorCode ierr;
 
   PetscFunctionBegin;
   MatRegisterAllCalled = PETSC_TRUE;
 
-  ierr = MatRegister(MATMFFD,           path,"MatCreate_MFFD",    MatCreate_MFFD);CHKERRQ(ierr);
+  ierr = MatRegister(MATMFFD,           "MatCreate_MFFD",    MatCreate_MFFD);CHKERRQ(ierr);
 
-  ierr = MatRegister(MATMPIMAIJ,        path,"MatCreate_MAIJ",    MatCreate_MAIJ);CHKERRQ(ierr);
-  ierr = MatRegister(MATSEQMAIJ,        path,"MatCreate_MAIJ",    MatCreate_MAIJ);CHKERRQ(ierr);
-  ierr = MatRegister(MATMAIJ,           path,"MatCreate_MAIJ",    MatCreate_MAIJ);CHKERRQ(ierr);
+  ierr = MatRegister(MATMPIMAIJ,        "MatCreate_MAIJ",    MatCreate_MAIJ);CHKERRQ(ierr);
+  ierr = MatRegister(MATSEQMAIJ,        "MatCreate_MAIJ",    MatCreate_MAIJ);CHKERRQ(ierr);
+  ierr = MatRegister(MATMAIJ,           "MatCreate_MAIJ",    MatCreate_MAIJ);CHKERRQ(ierr);
 
-  ierr = MatRegister(MATIS,             path,"MatCreate_IS",      MatCreate_IS);CHKERRQ(ierr);
-  ierr = MatRegister(MATSHELL,          path,"MatCreate_Shell",   MatCreate_Shell);CHKERRQ(ierr);
-  ierr = MatRegister(MATCOMPOSITE,      path,"MatCreate_Composite",   MatCreate_Composite);CHKERRQ(ierr);
+  ierr = MatRegister(MATIS,             "MatCreate_IS",      MatCreate_IS);CHKERRQ(ierr);
+  ierr = MatRegister(MATSHELL,          "MatCreate_Shell",   MatCreate_Shell);CHKERRQ(ierr);
+  ierr = MatRegister(MATCOMPOSITE,      "MatCreate_Composite",   MatCreate_Composite);CHKERRQ(ierr);
 
   ierr = MatRegisterBaseName(MATAIJ,MATSEQAIJ,MATMPIAIJ);CHKERRQ(ierr);
-  ierr = MatRegister(MATMPIAIJ,         path,"MatCreate_MPIAIJ",      MatCreate_MPIAIJ);CHKERRQ(ierr);
-  ierr = MatRegister(MATSEQAIJ,         path,"MatCreate_SeqAIJ",      MatCreate_SeqAIJ);CHKERRQ(ierr);
+  ierr = MatRegister(MATMPIAIJ,         "MatCreate_MPIAIJ",      MatCreate_MPIAIJ);CHKERRQ(ierr);
+  ierr = MatRegister(MATSEQAIJ,         "MatCreate_SeqAIJ",      MatCreate_SeqAIJ);CHKERRQ(ierr);
 
   ierr = MatRegisterBaseName(MATAIJPERM,MATSEQAIJPERM,MATMPIAIJPERM);CHKERRQ(ierr);
-  ierr = MatRegister(MATMPIAIJPERM,     path,"MatCreate_MPIAIJPERM", MatCreate_MPIAIJPERM);CHKERRQ(ierr);
-  ierr = MatRegister(MATSEQAIJPERM,     path,"MatCreate_SeqAIJPERM", MatCreate_SeqAIJPERM);CHKERRQ(ierr);
+  ierr = MatRegister(MATMPIAIJPERM,     "MatCreate_MPIAIJPERM", MatCreate_MPIAIJPERM);CHKERRQ(ierr);
+  ierr = MatRegister(MATSEQAIJPERM,     "MatCreate_SeqAIJPERM", MatCreate_SeqAIJPERM);CHKERRQ(ierr);
 
   ierr = MatRegisterBaseName(MATAIJCRL,MATSEQAIJCRL,MATMPIAIJCRL);CHKERRQ(ierr);
-  ierr = MatRegister(MATSEQAIJCRL,      path,"MatCreate_SeqAIJCRL",  MatCreate_SeqAIJCRL);CHKERRQ(ierr);
-  ierr = MatRegister(MATMPIAIJCRL,      path,"MatCreate_MPIAIJCRL",  MatCreate_MPIAIJCRL);CHKERRQ(ierr);
+  ierr = MatRegister(MATSEQAIJCRL,      "MatCreate_SeqAIJCRL",  MatCreate_SeqAIJCRL);CHKERRQ(ierr);
+  ierr = MatRegister(MATMPIAIJCRL,      "MatCreate_MPIAIJCRL",  MatCreate_MPIAIJCRL);CHKERRQ(ierr);
 
   ierr = MatRegisterBaseName(MATBAIJ,MATSEQBAIJ,MATMPIBAIJ);CHKERRQ(ierr);
-  ierr = MatRegister(MATMPIBAIJ,        path,"MatCreate_MPIBAIJ",    MatCreate_MPIBAIJ);CHKERRQ(ierr);
-  ierr = MatRegister(MATSEQBAIJ,        path,"MatCreate_SeqBAIJ",    MatCreate_SeqBAIJ);CHKERRQ(ierr);
+  ierr = MatRegister(MATMPIBAIJ,        "MatCreate_MPIBAIJ",    MatCreate_MPIBAIJ);CHKERRQ(ierr);
+  ierr = MatRegister(MATSEQBAIJ,        "MatCreate_SeqBAIJ",    MatCreate_SeqBAIJ);CHKERRQ(ierr);
 
   ierr = MatRegisterBaseName(MATSBAIJ,MATSEQSBAIJ,MATMPISBAIJ);CHKERRQ(ierr);
-  ierr = MatRegister(MATMPISBAIJ,       path,"MatCreate_MPISBAIJ",  MatCreate_MPISBAIJ);CHKERRQ(ierr);
-  ierr = MatRegister(MATSEQSBAIJ,       path,"MatCreate_SeqSBAIJ",  MatCreate_SeqSBAIJ);CHKERRQ(ierr);
+  ierr = MatRegister(MATMPISBAIJ,       "MatCreate_MPISBAIJ",  MatCreate_MPISBAIJ);CHKERRQ(ierr);
+  ierr = MatRegister(MATSEQSBAIJ,       "MatCreate_SeqSBAIJ",  MatCreate_SeqSBAIJ);CHKERRQ(ierr);
 
   ierr = MatRegisterBaseName(MATBSTRM,MATSEQBSTRM,MATMPIBSTRM);CHKERRQ(ierr);
-  ierr = MatRegister(MATMPIBSTRM,        path,"MatCreate_MPIBSTRM",    MatCreate_MPIBSTRM);CHKERRQ(ierr);
-  ierr = MatRegister(MATSEQBSTRM,        path,"MatCreate_SeqBSTRM",    MatCreate_SeqBSTRM);CHKERRQ(ierr);
+  ierr = MatRegister(MATMPIBSTRM,        "MatCreate_MPIBSTRM",    MatCreate_MPIBSTRM);CHKERRQ(ierr);
+  ierr = MatRegister(MATSEQBSTRM,        "MatCreate_SeqBSTRM",    MatCreate_SeqBSTRM);CHKERRQ(ierr);
 
   ierr = MatRegisterBaseName(MATSBSTRM,MATSEQSBSTRM,MATMPISBSTRM);CHKERRQ(ierr);
-  ierr = MatRegister(MATMPISBSTRM,       path,"MatCreate_MPISBSTRM",  MatCreate_MPISBSTRM);CHKERRQ(ierr);
-  ierr = MatRegister(MATSEQSBSTRM,       path,"MatCreate_SeqSBSTRM",  MatCreate_SeqSBSTRM);CHKERRQ(ierr);
+  ierr = MatRegister(MATMPISBSTRM,       "MatCreate_MPISBSTRM",  MatCreate_MPISBSTRM);CHKERRQ(ierr);
+  ierr = MatRegister(MATSEQSBSTRM,       "MatCreate_SeqSBSTRM",  MatCreate_SeqSBSTRM);CHKERRQ(ierr);
 
   ierr = MatRegisterBaseName(MATDENSE,MATSEQDENSE,MATMPIDENSE);CHKERRQ(ierr);
-  ierr = MatRegister(MATMPIDENSE,       path,"MatCreate_MPIDense",  MatCreate_MPIDense);CHKERRQ(ierr);
-  ierr = MatRegister(MATSEQDENSE,       path,"MatCreate_SeqDense",  MatCreate_SeqDense);CHKERRQ(ierr);
+  ierr = MatRegister(MATMPIDENSE,       "MatCreate_MPIDense",  MatCreate_MPIDense);CHKERRQ(ierr);
+  ierr = MatRegister(MATSEQDENSE,       "MatCreate_SeqDense",  MatCreate_SeqDense);CHKERRQ(ierr);
 
-  ierr = MatRegister(MATMPIADJ,         path,"MatCreate_MPIAdj",    MatCreate_MPIAdj);CHKERRQ(ierr);
-  ierr = MatRegister(MATSCATTER,        path,"MatCreate_Scatter",   MatCreate_Scatter);CHKERRQ(ierr);
-  ierr = MatRegister(MATBLOCKMAT,       path,"MatCreate_BlockMat",  MatCreate_BlockMat);CHKERRQ(ierr);
-  ierr = MatRegister(MATNEST,           path,"MatCreate_Nest",      MatCreate_Nest);CHKERRQ(ierr);
+  ierr = MatRegister(MATMPIADJ,         "MatCreate_MPIAdj",    MatCreate_MPIAdj);CHKERRQ(ierr);
+  ierr = MatRegister(MATSCATTER,        "MatCreate_Scatter",   MatCreate_Scatter);CHKERRQ(ierr);
+  ierr = MatRegister(MATBLOCKMAT,       "MatCreate_BlockMat",  MatCreate_BlockMat);CHKERRQ(ierr);
+  ierr = MatRegister(MATNEST,           "MatCreate_Nest",      MatCreate_Nest);CHKERRQ(ierr);
 
 
 #if defined PETSC_HAVE_CUSP
   ierr = MatRegisterBaseName(MATAIJCUSP,MATSEQAIJCUSP,MATMPIAIJCUSP);CHKERRQ(ierr);
-  ierr = MatRegister(MATSEQAIJCUSP,     path,"MatCreate_SeqAIJCUSP",  MatCreate_SeqAIJCUSP);CHKERRQ(ierr);
-  ierr = MatRegister(MATMPIAIJCUSP,     path,"MatCreate_MPIAIJCUSP",  MatCreate_MPIAIJCUSP);CHKERRQ(ierr);
+  ierr = MatRegister(MATSEQAIJCUSP,     "MatCreate_SeqAIJCUSP",  MatCreate_SeqAIJCUSP);CHKERRQ(ierr);
+  ierr = MatRegister(MATMPIAIJCUSP,     "MatCreate_MPIAIJCUSP",  MatCreate_MPIAIJCUSP);CHKERRQ(ierr);
 #endif
 
 #if defined PETSC_HAVE_TXPETSCGPU
   ierr = MatRegisterBaseName(MATAIJCUSPARSE,MATSEQAIJCUSPARSE,MATMPIAIJCUSPARSE);CHKERRQ(ierr);
-  ierr = MatRegister(MATSEQAIJCUSPARSE,     path,"MatCreate_SeqAIJCUSPARSE",  MatCreate_SeqAIJCUSPARSE);CHKERRQ(ierr);
-  ierr = MatRegister(MATMPIAIJCUSPARSE,     path,"MatCreate_MPIAIJCUSPARSE",  MatCreate_MPIAIJCUSPARSE);CHKERRQ(ierr);
+  ierr = MatRegister(MATSEQAIJCUSPARSE,     "MatCreate_SeqAIJCUSPARSE",  MatCreate_SeqAIJCUSPARSE);CHKERRQ(ierr);
+  ierr = MatRegister(MATMPIAIJCUSPARSE,     "MatCreate_MPIAIJCUSPARSE",  MatCreate_MPIAIJCUSPARSE);CHKERRQ(ierr);
 #endif
 
 #if defined PETSC_HAVE_FFTW
-  ierr = MatRegister(MATFFTW,           path,"MatCreate_FFTW",        MatCreate_FFTW);CHKERRQ(ierr);
+  ierr = MatRegister(MATFFTW,           "MatCreate_FFTW",        MatCreate_FFTW);CHKERRQ(ierr);
 #endif
 #if defined PETSC_HAVE_ELEMENTAL
-  ierr = MatRegister(MATELEMENTAL,      path,"MatCreate_Elemental",    MatCreate_Elemental);CHKERRQ(ierr);
+  ierr = MatRegister(MATELEMENTAL,      "MatCreate_Elemental",    MatCreate_Elemental);CHKERRQ(ierr);
 #endif
   PetscFunctionReturn(0);
 }

src/mat/order/sorder.c

 
 .seealso: MatOrderingRegisterDestroy(), MatOrderingRegisterAll()
 @*/
-PetscErrorCode  MatOrderingRegister(const char sname[],const char path[],const char name[],PetscErrorCode (*function)(Mat,MatOrderingType,IS*,IS*))
+PetscErrorCode  MatOrderingRegister(const char sname[],const char name[],PetscErrorCode (*function)(Mat,MatOrderingType,IS*,IS*))
 {
   PetscErrorCode ierr;
-  char           fullname[PETSC_MAX_PATH_LEN];
 
   PetscFunctionBegin;
-  ierr = PetscFunctionListConcat(path,name,fullname);CHKERRQ(ierr);
-  ierr = PetscFunctionListAdd(PETSC_COMM_WORLD,&MatOrderingList,sname,fullname,(void (*)(void))function);CHKERRQ(ierr);
+  ierr = PetscFunctionListAdd(PETSC_COMM_WORLD,&MatOrderingList,sname,name,(void (*)(void))function);CHKERRQ(ierr);
   PetscFunctionReturn(0);
 }
 
   ierr = MatGetLocalSize(mat,&mmat,&nmat);CHKERRQ(ierr);
   if (mmat != nmat) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"Must be square matrix, rows %D columns %D",mmat,nmat);
 
-  if (!MatOrderingRegisterAllCalled) {ierr = MatOrderingRegisterAll(NULL);CHKERRQ(ierr);}
+  if (!MatOrderingRegisterAllCalled) {ierr = MatOrderingRegisterAll();CHKERRQ(ierr);}
   ierr = PetscFunctionListFind(PetscObjectComm((PetscObject)mat),MatOrderingList,type,PETSC_TRUE,(void (**)(void)) &r);CHKERRQ(ierr);
   if (!r) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Unknown or unregistered type: %s",type);
 

src/mat/order/sregis.c

 
 .seealso: MatOrderingRegister(), MatOrderingRegisterDestroy()
 @*/
-PetscErrorCode  MatOrderingRegisterAll(const char path[])
+PetscErrorCode  MatOrderingRegisterAll(void)
 {
   PetscErrorCode ierr;
 
   PetscFunctionBegin;
   MatOrderingRegisterAllCalled = PETSC_TRUE;
 
-  ierr = MatOrderingRegister(MATORDERINGNATURAL,  path,"MatGetOrdering_Natural"  ,MatGetOrdering_Natural);CHKERRQ(ierr);
-  ierr = MatOrderingRegister(MATORDERINGND,       path,"MatGetOrdering_ND"       ,MatGetOrdering_ND);CHKERRQ(ierr);
-  ierr = MatOrderingRegister(MATORDERING1WD,      path,"MatGetOrdering_1WD"      ,MatGetOrdering_1WD);CHKERRQ(ierr);
-  ierr = MatOrderingRegister(MATORDERINGRCM,      path,"MatGetOrdering_RCM"      ,MatGetOrdering_RCM);CHKERRQ(ierr);
-  ierr = MatOrderingRegister(MATORDERINGQMD,      path,"MatGetOrdering_QMD"      ,MatGetOrdering_QMD);CHKERRQ(ierr);
-  ierr = MatOrderingRegister(MATORDERINGROWLENGTH,path,"MatGetOrdering_RowLength",MatGetOrdering_RowLength);CHKERRQ(ierr);
+  ierr = MatOrderingRegister(MATORDERINGNATURAL,  "MatGetOrdering_Natural"  ,MatGetOrdering_Natural);CHKERRQ(ierr);
+  ierr = MatOrderingRegister(MATORDERINGND,       "MatGetOrdering_ND"       ,MatGetOrdering_ND);CHKERRQ(ierr);
+  ierr = MatOrderingRegister(MATORDERING1WD,      "MatGetOrdering_1WD"      ,MatGetOrdering_1WD);CHKERRQ(ierr);
+  ierr = MatOrderingRegister(MATORDERINGRCM,      "MatGetOrdering_RCM"      ,MatGetOrdering_RCM);CHKERRQ(ierr);
+  ierr = MatOrderingRegister(MATORDERINGQMD,      "MatGetOrdering_QMD"      ,MatGetOrdering_QMD);CHKERRQ(ierr);
+  ierr = MatOrderingRegister(MATORDERINGROWLENGTH,"MatGetOrdering_RowLength",MatGetOrdering_RowLength);CHKERRQ(ierr);
 #if defined(PETSC_HAVE_UMFPACK)
-  ierr = MatOrderingRegister(MATORDERINGAMD,      path,"MatGetOrdering_AMD",MatGetOrdering_AMD);CHKERRQ(ierr);
+  ierr = MatOrderingRegister(MATORDERINGAMD,      "MatGetOrdering_AMD",MatGetOrdering_AMD);CHKERRQ(ierr);
 #endif
   PetscFunctionReturn(0);
 }

src/mat/partition/partition.c

 
 .seealso: MatPartitioningRegisterDestroy(), MatPartitioningRegisterAll()
 @*/
-PetscErrorCode  MatPartitioningRegister(const char sname[],const char path[],const char name[],PetscErrorCode (*function)(MatPartitioning))
+PetscErrorCode  MatPartitioningRegister(const char sname[],const char name[],PetscErrorCode (*function)(MatPartitioning))
 {
   PetscErrorCode ierr;
-  char           fullname[PETSC_MAX_PATH_LEN];
 
   PetscFunctionBegin;
-  ierr = PetscFunctionListConcat(path,name,fullname);CHKERRQ(ierr);
-  ierr = PetscFunctionListAdd(PETSC_COMM_WORLD,&MatPartitioningList,sname,fullname,(void (*)(void))function);CHKERRQ(ierr);
+  ierr = PetscFunctionListAdd(PETSC_COMM_WORLD,&MatPartitioningList,sname,name,(void (*)(void))function);CHKERRQ(ierr);
   PetscFunctionReturn(0);
 }
 
   *newp = 0;
 
 #if !defined(PETSC_USE_DYNAMIC_LIBRARIES)
-  ierr = MatInitializePackage(NULL);CHKERRQ(ierr);
+  ierr = MatInitializePackage();CHKERRQ(ierr);
 #endif
   ierr = PetscHeaderCreate(part,_p_MatPartitioning,struct _MatPartitioningOps,MAT_PARTITIONING_CLASSID,"MatPartitioning","Matrix/graph partitioning","MatOrderings",comm,MatPartitioningDestroy,MatPartitioningView);CHKERRQ(ierr);
   part->vertex_weights = NULL;

src/mat/partition/spartition.c

 
 .seealso: MatPartitioningRegister(), MatPartitioningRegisterDestroy()
 @*/
-PetscErrorCode  MatPartitioningRegisterAll(const char path[])
+PetscErrorCode  MatPartitioningRegisterAll(void)
 {
   PetscErrorCode ierr;
 
   PetscFunctionBegin;
   MatPartitioningRegisterAllCalled = PETSC_TRUE;
 
-  ierr = MatPartitioningRegister(MATPARTITIONINGCURRENT,path,"MatPartitioningCreate_Current",MatPartitioningCreate_Current);CHKERRQ(ierr);
-  ierr = MatPartitioningRegister("square",path,"MatPartitioningCreate_Square",MatPartitioningCreate_Square);CHKERRQ(ierr);
+  ierr = MatPartitioningRegister(MATPARTITIONINGCURRENT,"MatPartitioningCreate_Current",MatPartitioningCreate_Current);CHKERRQ(ierr);
+  ierr = MatPartitioningRegister("square",               "MatPartitioningCreate_Square",MatPartitioningCreate_Square);CHKERRQ(ierr);
 #if defined(PETSC_HAVE_PARMETIS)
-  ierr = MatPartitioningRegister(MATPARTITIONINGPARMETIS,path,"MatPartitioningCreate_Parmetis",MatPartitioningCreate_Parmetis);CHKERRQ(ierr);
+  ierr = MatPartitioningRegister(MATPARTITIONINGPARMETIS,"MatPartitioningCreate_Parmetis",MatPartitioningCreate_Parmetis);CHKERRQ(ierr);
 #endif
 #if defined(PETSC_HAVE_CHACO)
-  ierr = MatPartitioningRegister(MATPARTITIONINGCHACO,path,"MatPartitioningCreate_Chaco",MatPartitioningCreate_Chaco);CHKERRQ(ierr);
+  ierr = MatPartitioningRegister(MATPARTITIONINGCHACO,   "MatPartitioningCreate_Chaco",MatPartitioningCreate_Chaco);CHKERRQ(ierr);
 #endif
 #if defined(PETSC_HAVE_PARTY)
-  ierr = MatPartitioningRegister(MATPARTITIONINGPARTY,path,"MatPartitioningCreate_Party",MatPartitioningCreate_Party);CHKERRQ(ierr);
+  ierr = MatPartitioningRegister(MATPARTITIONINGPARTY,   "MatPartitioningCreate_Party",MatPartitioningCreate_Party);CHKERRQ(ierr);
 #endif
 #if defined(PETSC_HAVE_PTSCOTCH)
-  ierr = MatPartitioningRegister(MATPARTITIONINGPTSCOTCH,path,"MatPartitioningCreate_PTScotch",MatPartitioningCreate_PTScotch);CHKERRQ(ierr);
+  ierr = MatPartitioningRegister(MATPARTITIONINGPTSCOTCH,"MatPartitioningCreate_PTScotch",MatPartitioningCreate_PTScotch);CHKERRQ(ierr);
 #endif
   PetscFunctionReturn(0);
 }

src/mat/utils/gcreate.c

 
   *A = NULL;
 #if !defined(PETSC_USE_DYNAMIC_LIBRARIES)
-  ierr = MatInitializePackage(NULL);CHKERRQ(ierr);
+  ierr = MatInitializePackage();CHKERRQ(ierr);
 #endif
 
   ierr = PetscHeaderCreate(B,_p_Mat,struct _MatOps,MAT_CLASSID,"Mat","Matrix","Mat",comm,MatDestroy,MatView);CHKERRQ(ierr);

src/snes/impls/ms/ms.c

   from PetscDLLibraryRegister() when using dynamic libraries, and on the first call to SNESCreate_MS()
   when using static libraries.
 
-  Input Parameter:
-  path - The dynamic library path, or NULL
-
   Level: developer
 
 .keywords: SNES, SNESMS, initialize, package
 .seealso: PetscInitialize()
 @*/
-PetscErrorCode SNESMSInitializePackage(const char path[])
+PetscErrorCode SNESMSInitializePackage(void)
 {
   PetscErrorCode ierr;
 
 
   PetscFunctionBegin;
 #if !defined(PETSC_USE_DYNAMIC_LIBRARIES)
-  ierr = SNESMSInitializePackage(NULL);CHKERRQ(ierr);
+  ierr = SNESMSInitializePackage();CHKERRQ(ierr);
 #endif
 
   snes->ops->setup          = SNESSetUp_MS;

src/snes/impls/ncg/snesncg.c

   PetscFunctionBegin;
   ierr = SNESSetWorkVecs(snes,2);CHKERRQ(ierr);
   ierr = SNESSetUpMatrices(snes);CHKERRQ(ierr);
-  ierr = SNESLineSearchRegister(SNESLINESEARCHNCGLINEAR, NULL,"SNESLineSearchCreate_NCGLinear", SNESLineSearchCreate_NCGLinear);CHKERRQ(ierr);
+  ierr = SNESLineSearchRegister(SNESLINESEARCHNCGLINEAR, "SNESLineSearchCreate_NCGLinear", SNESLineSearchCreate_NCGLinear);CHKERRQ(ierr);
   PetscFunctionReturn(0);
 }
 /*

src/snes/interface/dlregissnes.c

   from PetscDLLibraryRegister() when using dynamic libraries, and on the first call to SNESCreate()
   when using static libraries.
 
-  Input Parameter:
-  path - The dynamic library path, or NULL
-
   Level: developer
 
 .keywords: SNES, initialize, package
 .seealso: PetscInitialize()
 @*/
-PetscErrorCode  SNESInitializePackage(const char path[])
+PetscErrorCode  SNESInitializePackage(void)
 {
   char           logList[256];
   char           *className;
   if (SNESPackageInitialized) PetscFunctionReturn(0);
   SNESPackageInitialized = PETSC_TRUE;
   /* Initialize subpackages */
-  ierr = SNESMSInitializePackage(path);CHKERRQ(ierr);
+  ierr = SNESMSInitializePackage();CHKERRQ(ierr);
   /* Register Classes */
   ierr = PetscClassIdRegister("SNES",&SNES_CLASSID);CHKERRQ(ierr);
   ierr = PetscClassIdRegister("SNESLineSearch",&SNESLINESEARCH_CLASSID);CHKERRQ(ierr);
   ierr = PetscClassIdRegister("DMSNES",&DMSNES_CLASSID);CHKERRQ(ierr);
   /* Register Constructors */
-  ierr = SNESRegisterAll(path);CHKERRQ(ierr);
-  ierr = SNESLineSearchRegisterAll(path);CHKERRQ(ierr);
+  ierr = SNESRegisterAll();CHKERRQ(ierr);
+  ierr = SNESLineSearchRegisterAll();CHKERRQ(ierr);
   /* Register Events */
   ierr = PetscLogEventRegister("SNESSolve",            SNES_CLASSID,&SNES_Solve);CHKERRQ(ierr);
   ierr = PetscLogEventRegister("SNESFunctionEval",     SNES_CLASSID,&SNES_FunctionEval);CHKERRQ(ierr);
 
   This registers all of the SNES methods that are in the basic PETSc libpetscsnes library.
 
-  Input Parameter:
-  path - library path
-
  */
-PETSC_EXTERN PetscErrorCode PetscDLLibraryRegister_petscsnes(const char path[])
+PETSC_EXTERN PetscErrorCode PetscDLLibraryRegister_petscsnes(void)
 {
   PetscErrorCode ierr;
 
   PetscFunctionBegin;
-  ierr = SNESInitializePackage(path);CHKERRQ(ierr);
+  ierr = SNESInitializePackage();CHKERRQ(ierr);
   PetscFunctionReturn(0);
 }