softMain.cpp File Reference

#include <iostream>
#include <string>
#include <list>
#include <stdexcept>
#include <epicsGetopt.h>
#include "registryFunction.h"
#include "epicsThread.h"
#include "epicsExit.h"
#include "epicsStdio.h"
#include "epicsString.h"
#include "dbStaticLib.h"
#include "subRecord.h"
#include "dbAccess.h"
#include "asDbLib.h"
#include "iocInit.h"
#include "iocsh.h"
#include "osiFileName.h"
#include "epicsInstallDir.h"

Include dependency graph for softMain.cpp:

Go to the source code of this file.

Macros
#define	EPICS_BASE   "/"
#define	DBD_BASE   "dbd" OSI_PATH_SEPARATOR "softIoc.dbd"
#define	EXIT_BASE   "db" OSI_PATH_SEPARATOR "softIocExit.db"
#define	DBD_FILE_REL   ".." OSI_PATH_SEPARATOR ".." OSI_PATH_SEPARATOR DBD_BASE
#define	EXIT_FILE_REL   ".." OSI_PATH_SEPARATOR ".." OSI_PATH_SEPARATOR EXIT_BASE
#define	DBD_FILE   EPICS_BASE OSI_PATH_SEPARATOR DBD_BASE
#define	EXIT_FILE   EPICS_BASE OSI_PATH_SEPARATOR EXIT_BASE

Functions
int	softIoc_registerRecordDeviceDriver (struct dbBase *pdbbase)
int	main (int argc, char *argv[])

Macro Definition Documentation

#define DBD_BASE   "dbd" OSI_PATH_SEPARATOR "softIoc.dbd"

Definition at line 40 of file softMain.cpp.

#define DBD_FILE   EPICS_BASE OSI_PATH_SEPARATOR DBD_BASE

Definition at line 44 of file softMain.cpp.

#define DBD_FILE_REL   ".." OSI_PATH_SEPARATOR ".." OSI_PATH_SEPARATOR DBD_BASE

Definition at line 42 of file softMain.cpp.

#define EPICS_BASE   "/"

Definition at line 36 of file softMain.cpp.

#define EXIT_BASE   "db" OSI_PATH_SEPARATOR "softIocExit.db"

Definition at line 41 of file softMain.cpp.

#define EXIT_FILE   EPICS_BASE OSI_PATH_SEPARATOR EXIT_BASE

Definition at line 45 of file softMain.cpp.

#define EXIT_FILE_REL   ".." OSI_PATH_SEPARATOR ".." OSI_PATH_SEPARATOR EXIT_BASE

Definition at line 43 of file softMain.cpp.

Function Documentation

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 116 of file softMain.cpp.

{
    try {
        std::string dbd_file(DBD_FILE),
                    exit_file(EXIT_FILE),
                    macros, // scratch space for macros (may be given more than once)
                    xmacro;
        bool interactive = true;
        bool loadedDb = false;

        // attempt to compute relative paths
        {
            std::string prefix;
            char *cprefix = epicsGetExecDir();
            if(cprefix) {
                try {
                    prefix = cprefix;
                    free(cprefix);
                } catch(...) {
                    free(cprefix);
                    throw;
                }
            }

            dbd_file = prefix + DBD_FILE_REL;
            exit_file = prefix + EXIT_FILE_REL;
        }

        int opt;

        while ((opt = getopt(argc, argv, "ha:D:d:m:Ssx:")) != -1) {
            switch (opt) {
            case 'h':               /* Print usage */
                usage(argv[0], dbd_file);
                epicsExit(0);
                return 0;
            default:
                usage(argv[0], dbd_file);
                std::cerr<<"Unknown argument: -"<<char(opt)<<"\n";
                epicsExit(2);
                return 2;
            case 'a':
                lazy_dbd(dbd_file);
                if (!macros.empty()) {
                    if(asSetSubstitutions(macros.c_str()))
                        throw std::bad_alloc();
                    std::cout<<"asSetSubstitutions(\""<<macros<<"\")\n";
                }
                if(asSetFilename(optarg))
                    throw std::bad_alloc();
                std::cout<<"asSetFilename(\""<<optarg<<"\")\n";
                break;
            case 'D':
                if(lazy_dbd_loaded) {
                    throw std::runtime_error("-D specified too late.  softIoc.dbd already loaded.\n");
                }
                dbd_file = optarg;
                break;
            case 'd':
                lazy_dbd(dbd_file);
                errIf(dbLoadRecords(optarg, macros.c_str()),
                      std::string("Failed to load: ")+optarg);
                std::cout<<"dbLoadRecords(\""<<optarg<<"\"";
                if(!macros.empty())
                    std::cout<<", \""<<macros<<"\"";
                std::cout<<")\n";
                loadedDb = true;
                break;
            case 'm':
                macros = optarg;
                break;
            case 'S':
                interactive = false;
                break;
            case 's':
                break; // historical
            case 'x':
                lazy_dbd(dbd_file);
                xmacro  = "IOC=";
                xmacro += optarg;
                errIf(dbLoadRecords(exit_file.c_str(), xmacro.c_str()),
                      std::string("Failed to load: ")+exit_file);
                loadedDb = true;
                break;
            }
        }

        lazy_dbd(dbd_file);

        if(optind<argc)  {
            // run script
            // ignore any extra positional args (historical)

            std::cout<<"# Begin "<<argv[optind]<<"\n";
            errIf(iocsh(argv[optind]),
                        std::string("Error in ")+argv[optind]);
            std::cout<<"# End "<<argv[optind]<<"\n";

            epicsThreadSleep(0.2);
            loadedDb = true;    /* Give it the benefit of the doubt... */
        }

        if (loadedDb) {
            std::cout<<"iocInit()\n";
            iocInit();
            epicsThreadSleep(0.2);
        }

        if(interactive) {
            std::cout.flush();
            std::cerr.flush();
            if(iocsh(NULL)) {
                epicsExit(1);
                return 1;
            }

        } else {
            if (loadedDb) {
                epicsThreadExitMain();

            } else {
                usage(argv[0], dbd_file);
                std::cerr<<"Nothing to do!\n";
                epicsExit(1);
                return 1;
            }
        }

        epicsExit(0);
        return 0;

    }catch(std::exception& e){
        std::cerr<<"Error: "<<e.what()<<"\n";
        epicsExit(2);
        return 2;
    }
}

int softIoc_registerRecordDeviceDriver

(

struct dbBase *

pdbbase

)