static long init_record(mbbiRecord *prec, int pass) { struct mbbidset *pdset; long status; if (pass==0) return(0); if (prec->siml.type == CONSTANT) { recGblInitConstantLink(&prec->siml,DBF_USHORT,&prec->simm); } if (prec->siol.type == CONSTANT) { recGblInitConstantLink(&prec->siol,DBF_USHORT,&prec->sval); } if(!(pdset = (struct mbbidset *)(prec->dset))) { recGblRecordError(S_dev_noDSET,(void *)prec,"mbbi: init_record"); return(S_dev_noDSET); } /* must have read_mbbi function defined */ if( (pdset->number < 5) || (pdset->read_mbbi == NULL) ) { recGblRecordError(S_dev_missingSup,(void *)prec,"mbbi: init_record"); return(S_dev_missingSup); } /* initialize mask*/ prec->mask = (1 << prec->nobt) - 1; if( pdset->init_record ) { if((status=(*pdset->init_record)(prec))) return(status); } init_common(prec); prec->mlst = prec->val; prec->lalm = prec->val; prec->oraw = prec->rval; return(0); }
static long init_record(longoutRecord *prec, int pass) { struct longoutdset *pdset; long status=0; if (pass==0) return(0); if (prec->siml.type == CONSTANT) { recGblInitConstantLink(&prec->siml,DBF_USHORT,&prec->simm); } if(!(pdset = (struct longoutdset *)(prec->dset))) { recGblRecordError(S_dev_noDSET,(void *)prec,"longout: init_record"); return(S_dev_noDSET); } /* must have write_longout functions defined */ if( (pdset->number < 5) || (pdset->write_longout == NULL) ) { recGblRecordError(S_dev_missingSup,(void *)prec,"longout: init_record"); return(S_dev_missingSup); } if (prec->dol.type == CONSTANT) { if(recGblInitConstantLink(&prec->dol,DBF_LONG,&prec->val)) prec->udf=FALSE; } if( pdset->init_record ) { if((status=(*pdset->init_record)(prec))) return(status); } prec->mlst = prec->val; prec->alst = prec->val; prec->lalm = prec->val; return(0); }
static long init_record(boRecord *prec,int pass) { struct bodset *pdset; long status=0; myCallback *pcallback; if (pass==0) return(0); /* bo.siml must be a CONSTANT or a PV_LINK or a DB_LINK */ if (prec->siml.type == CONSTANT) { recGblInitConstantLink(&prec->siml,DBF_USHORT,&prec->simm); } if(!(pdset = (struct bodset *)(prec->dset))) { recGblRecordError(S_dev_noDSET,(void *)prec,"bo: init_record"); return(S_dev_noDSET); } /* must have write_bo functions defined */ if( (pdset->number < 5) || (pdset->write_bo == NULL) ) { recGblRecordError(S_dev_missingSup,(void *)prec,"bo: init_record"); return(S_dev_missingSup); } /* get the initial value */ if (prec->dol.type == CONSTANT) { unsigned short ival = 0; if(recGblInitConstantLink(&prec->dol,DBF_USHORT,&ival)) { if (ival == 0) prec->val = 0; else prec->val = 1; prec->udf = FALSE; } } pcallback = (myCallback *)(calloc(1,sizeof(myCallback))); prec->rpvt = (void *)pcallback; callbackSetCallback(myCallbackFunc,&pcallback->callback); callbackSetUser(pcallback,&pcallback->callback); pcallback->precord = (struct dbCommon *)prec; if( pdset->init_record ) { status=(*pdset->init_record)(prec); if(status==0) { if(prec->rval==0) prec->val = 0; else prec->val = 1; prec->udf = FALSE; } else if (status==2) status=0; } prec->mlst = prec->val; /* convert val to rval */ if ( prec->mask != 0 ) { if(prec->val==0) prec->rval = 0; else prec->rval = prec->mask; } else prec->rval = (epicsUInt32)prec->val; prec->mlst = prec->val; prec->lalm = prec->val; prec->oraw = prec->rval; prec->orbv = prec->rbv; return(status); }
static long init_record(stringinRecord *prec, int pass) { STATIC_ASSERT(sizeof(prec->oval)==sizeof(prec->val)); struct stringindset *pdset; long status; if (pass==0) return(0); if (prec->siml.type == CONSTANT) { recGblInitConstantLink(&prec->siml,DBF_USHORT,&prec->simm); } /* stringin.siol must be a CONSTANT or a PV_LINK or a DB_LINK */ if (prec->siol.type == CONSTANT) { recGblInitConstantLink(&prec->siol,DBF_STRING,prec->sval); } if(!(pdset = (struct stringindset *)(prec->dset))) { recGblRecordError(S_dev_noDSET,(void *)prec,"stringin: init_record"); return(S_dev_noDSET); } /* must have read_stringin function defined */ if( (pdset->number < 5) || (pdset->read_stringin == NULL) ) { recGblRecordError(S_dev_missingSup,(void *)prec,"stringin: init_record"); return(S_dev_missingSup); } if( pdset->init_record ) { if((status=(*pdset->init_record)(prec))) return(status); } strcpy(prec->oval,prec->val); return(0); }
static long init_record(stringoutRecord *prec, int pass) { STATIC_ASSERT(sizeof(prec->oval)==sizeof(prec->val)); struct stringoutdset *pdset; long status=0; if (pass==0) return(0); if (prec->siml.type == CONSTANT) { recGblInitConstantLink(&prec->siml,DBF_USHORT,&prec->simm); } if(!(pdset = (struct stringoutdset *)(prec->dset))) { recGblRecordError(S_dev_noDSET,(void *)prec,"stringout: init_record"); return(S_dev_noDSET); } /* must have write_stringout functions defined */ if( (pdset->number < 5) || (pdset->write_stringout == NULL) ) { recGblRecordError(S_dev_missingSup,(void *)prec,"stringout: init_record"); return(S_dev_missingSup); } /* get the initial value dol is a constant*/ if (prec->dol.type == CONSTANT){ if(recGblInitConstantLink(&prec->dol,DBF_STRING,prec->val)) prec->udf=FALSE; } if( pdset->init_record ) { if((status=(*pdset->init_record)(prec))) return(status); } strcpy(prec->oval,prec->val); return(0); }
static long init_record(epidRecord *pepid, int pass) { struct epidDSET *pdset; int status; if (pass==0) return(0); /* initialize the setpoint for constant setpoint */ if (pepid->stpl.type == CONSTANT) { if(recGblInitConstantLink(&pepid->stpl,DBF_DOUBLE,&pepid->val)) pepid->udf = FALSE; } /* must have dset defined */ if (!(pdset = (struct epidDSET *)(pepid->dset))) { recGblRecordError(S_dev_noDSET,(void *)pepid,"epid: init_record1"); return(S_dev_noDSET); } /* must have do_pid function defined */ if ( (pdset->number < 5) || (pdset->do_pid == NULL) ) { recGblRecordError(S_dev_missingSup,(void *)pepid,"epid: init_record2"); printf("%ld %p\n",pdset->number, pdset->do_pid); return(S_dev_missingSup); } if (pdset->init_record) { if ((status=(*pdset->init_record)(pepid))) return(status); } return(0); }
static long init_record(fanoutRecord *prec, int pass) { if (pass==0) return(0); recGblInitConstantLink(&prec->sell,DBF_USHORT,&prec->seln); return(0); }
static long init_record(struct ifstatRecord *pifstat) { char *dopts = NULL; #if 1 if (!ifstat_get_driver("proc", &driver)) { printf("Get Driver Error!!\n"); return -1; } #endif if (driver.open_driver != NULL && !driver.open_driver(&driver, dopts)) { printf("Open Driver Error!!\n"); return -1; }; ifs.flags = 0; ifs.first = NULL; ifstat_add_interface(&ifs, pifstat->nic, 0); if(recGblInitConstantLink(&pifstat->inp,DBF_DOUBLE,&pifstat->val)) pifstat->udf = FALSE; pifstat->dpvt = &driver; return(0); }
static long dsetInit_devAiSyncSoft(aiRecord *pai) { dsetLog(3, __FILE__ "[%d] -> %s(%s)\n", __LINE__, __func__, pai->name); /* ai.inp must be a CONSTANT or a PV_LINK or a DB_LINK or a CA_LINK*/ switch (pai->inp.type) { case (CONSTANT) : if(recGblInitConstantLink(&pai->inp,DBF_DOUBLE,&pai->val)) pai->udf = FALSE; break; case (PV_LINK) : case (DB_LINK) : case (CA_LINK) : break; default : recGblRecordError(S_db_badField, (void *)pai, "DMC2183_devAiSyncSoft (init_record) Illegal INP field"); return(S_db_badField); } /* Make sure record processing routine does not perform any conversion*/ pai->linr = 0; dsetLog(3, __FILE__ "[%d] <- %s\n", __LINE__, __func__); return(SUCCESS); }
static long init_record(aiRecord *pao) { struct prngState* priv; unsigned long start; priv=malloc(sizeof(struct prngState)); if(!priv){ recGblRecordError(S_db_noMemory, (void*)pao, "devAoTimebase failed to allocate private struct"); return S_db_noMemory; } /* New */ callbackSetCallback(prng_cb,&priv->cb); callbackSetPriority(priorityLow,&priv->cb); callbackSetUser(pao,&priv->cb); priv->cb.timer=NULL; recGblInitConstantLink(&pao->inp,DBF_ULONG,&start); priv->seed=start; pao->dpvt=priv; return 0; }
static long dsetInit_devSiSyncSoft(stringinRecord *pstringin) { #ifdef DEBUG1 printf( __FILE__ "[%d] -> %s(%s)\n", __LINE__, __func__, pstringin->name); #endif /* stringin.inp must be a CONSTANT or a PV_LINK or a DB_LINK or a CA_LINK*/ switch (pstringin->inp.type) { case (CONSTANT) : if(recGblInitConstantLink(&pstringin->inp,DBF_STRING,pstringin->val)) pstringin->udf = FALSE; break; case (PV_LINK) : case (DB_LINK) : case (CA_LINK) : break; default : recGblRecordError(S_db_badField,(void *)pstringin, "devSiSoft (init_record) Illegal INP field"); return(S_db_badField); } #ifdef DEBUG1 printf( __FILE__ "[%d] <- %s\n", __LINE__, __func__); #endif return(SUCCESS); }
static long init_record(void *precord,int pass) { aiRecord *prec = (aiRecord *)precord; aidset *pdset; double eoff = prec->eoff, eslo = prec->eslo; if (pass==0) return(0); /* ai.siml must be a CONSTANT or a PV_LINK or a DB_LINK */ if (prec->siml.type == CONSTANT) { recGblInitConstantLink(&prec->siml,DBF_USHORT,&prec->simm); } /* ai.siol must be a CONSTANT or a PV_LINK or a DB_LINK */ if (prec->siol.type == CONSTANT) { recGblInitConstantLink(&prec->siol,DBF_DOUBLE,&prec->sval); } if(!(pdset = (aidset *)(prec->dset))) { recGblRecordError(S_dev_noDSET,(void *)prec,"ai: init_record"); return(S_dev_noDSET); } /* must have read_ai function defined */ if( (pdset->number < 6) || (pdset->read_ai == NULL) ) { recGblRecordError(S_dev_missingSup,(void *)prec,"ai: init_record"); return(S_dev_missingSup); } prec->init = TRUE; /*The following is for old device support that doesnt know about eoff*/ if ((prec->eslo==1.0) && (prec->eoff==0.0)) { prec->eoff = prec->egul; } if( pdset->init_record ) { long status=(*pdset->init_record)(prec); if (prec->linr == menuConvertSLOPE) { prec->eoff = eoff; prec->eslo = eslo; } return (status); } prec->mlst = prec->val; prec->alst = prec->val; prec->lalm = prec->val; prec->oraw = prec->rval; return(0); }
/***************************************************************************** * * Initialize a sequence record. * * Allocate the callback request structure (tacked on dpvt.) * Initialize watch-dog ID * Initialize SELN based on the link-type of SELL * If SELL is a CA_LINK, inform CA about it * For each constant input link, fill in the DOV field * ******************************************************************************/ static long init_record(seqRecord *prec, int pass) { int index; linkDesc *plink; callbackSeq *pcallbackSeq; if (pass==0) return(0); if (seqRecDebug > 5) printf("init_record(%s) entered\n", prec->name); /* Allocate a callback structure for use in processing */ pcallbackSeq = (callbackSeq *)calloc(1,sizeof(callbackSeq)); pcallbackSeq->pseqRecord = prec; callbackSetCallback(processCallback,&pcallbackSeq->callback); callbackSetUser(pcallbackSeq,&pcallbackSeq->callback); callbackSetPriority(prec->prio,&pcallbackSeq->callback); prec->dpvt = (void *)pcallbackSeq; /* Get link selection if sell is a constant and nonzero */ if (prec->sell.type==CONSTANT) { if (seqRecDebug > 5) printf("init_record(%s) SELL is a constant\n", prec->name); recGblInitConstantLink(&prec->sell,DBF_USHORT,&prec->seln); } /* Copy over ALL the input link constants here */ plink = (linkDesc *)(&(prec->dly1)); index = 0; while (index < NUM_LINKS) { if (plink->dol.type == CONSTANT) recGblInitConstantLink(&plink->dol,DBF_DOUBLE,&plink->dov); index++; plink++; } return(0); }
static long init_record(eventRecord *prec, int pass) { struct eventdset *pdset; long status=0; if (pass==0) return(0); if (prec->siml.type == CONSTANT) { recGblInitConstantLink(&prec->siml,DBF_USHORT,&prec->simm); } if (prec->siol.type == CONSTANT) { recGblInitConstantLink(&prec->siol,DBF_USHORT,&prec->sval); } if( (pdset=(struct eventdset *)(prec->dset)) && (pdset->init_record) ) status=(*pdset->init_record)(prec); return(status); }
static long dsetInit_devMbbiSyncSoft(mbbiRecord *pmbbi) { dsetLog(3, __FILE__ "[%d] -> %s(%s)\n", __LINE__, __func__, pmbbi->name); if (pmbbi->inp.type == CONSTANT) { if (recGblInitConstantLink(&pmbbi->inp,DBF_ENUM,&pmbbi->val)) pmbbi->udf = FALSE; } dsetLog(3, __FILE__ "[%d] <- %s\n", __LINE__, __func__); return(SUCCESS); }
static long init_record(selRecord *prec, int pass) { struct link *plink; int i; double *pvalue; if (pass==0) return(0); /* get seln initial value if nvl is a constant*/ if (prec->nvl.type == CONSTANT ) { recGblInitConstantLink(&prec->nvl,DBF_USHORT,&prec->seln); } plink = &prec->inpa; pvalue = &prec->a; for(i=0; i<SEL_MAX; i++, plink++, pvalue++) { *pvalue = epicsNAN; if (plink->type==CONSTANT) { recGblInitConstantLink(plink,DBF_DOUBLE,pvalue); } } return(0); }
static long init_record(struct cvtRecord *pcvt, int pass) { void *sub; if (pass == 0) { /* set new conversion parameters equal to to configured ones */ pcvt->nmet = pcvt->meth; strncpy(pcvt->nbdi, pcvt->bdir, BDIR_SIZE); strncpy(pcvt->ntdi, pcvt->tdir, TDIR_SIZE); strncpy(pcvt->nspe, pcvt->spec, SPEC_SIZE); return 0; } /* initialize input links */ if (pcvt->inpx.type == CONSTANT) { recGblInitConstantLink(&pcvt->inpx, DBF_DOUBLE, &pcvt->x); } if (pcvt->inpy.type == CONSTANT) { recGblInitConstantLink(&pcvt->inpy, DBF_DOUBLE, &pcvt->y); } if (pcvt->iaml.type == CONSTANT) { recGblInitConstantLink(&pcvt->iaml, DBF_UCHAR, &pcvt->iaom); } if (pcvt->iavl.type == CONSTANT) { recGblInitConstantLink(&pcvt->iavl, DBF_DOUBLE, &pcvt->iaov); } /* try to initialize conversion as specified */ if (initConversion(pcvt->name, pcvt->nbdi, pcvt->ntdi, pcvt->nmet, pcvt->nspe, &sub)) { pcvt->ista = menuCvtInitStateError; pcvt->drty |= DRTY_ISTA; return -1; } pcvt->csub = sub; return 0; }
static long init_record(biRecord *prec) { /* INP must be CONSTANT, PV_LINK, DB_LINK or CA_LINK*/ switch (prec->inp.type) { case CONSTANT: recGblInitConstantLink(&prec->inp, DBF_ULONG, &prec->rval); break; case PV_LINK: case DB_LINK: case CA_LINK: break; default: recGblRecordError(S_db_badField, (void *)prec, "devBiSoftRaw (init_record) Illegal INP field"); return S_db_badField; } return 0; }
static long init_record(subRecord *prec, int pass) { SUBFUNCPTR psubroutine; long status = 0; struct link *plink; int i; double *pvalue; if (pass==0) return(0); plink = &prec->inpa; pvalue = &prec->a; for (i = 0; i < INP_ARG_MAX; i++, plink++, pvalue++) { if (plink->type == CONSTANT) { recGblInitConstantLink(plink, DBF_DOUBLE, pvalue); } } if (prec->inam[0]) { /* convert the initialization subroutine name */ psubroutine = (SUBFUNCPTR)registryFunctionFind(prec->inam); if (psubroutine == 0) { recGblRecordError(S_db_BadSub, (void *)prec, "recSub(init_record)"); return S_db_BadSub; } /* invoke the initialization subroutine */ status = (*psubroutine)(prec); } if (prec->snam[0] == 0) { epicsPrintf("%s.SNAM is empty\n", prec->name); prec->pact = TRUE; return 0; } prec->sadr = (SUBFUNCPTR)registryFunctionFind(prec->snam); if (prec->sadr == NULL) { recGblRecordError(S_db_BadSub, (void *)prec, "recSub(init_record)"); return S_db_BadSub; } prec->mlst = prec->val; prec->alst = prec->val; prec->lalm = prec->val; return 0; }
static long init_record(stringinRecord *prec) { /* INP must be CONSTANT or PN_LINK */ switch (prec->inp.type) { case CONSTANT: if (recGblInitConstantLink(&prec->inp, DBR_STRING, &prec->val)) prec->udf = FALSE; break; case PN_LINK: /* Handled by add_record */ break; default: recGblRecordError(S_db_badField, (void *)prec, "devSiSoftCallback (init_record) Illegal INP field"); prec->pact = TRUE; return S_db_badField; } return 0; }
static long init_record(aiRecord *pao) { struct prngState* priv; unsigned long start; priv=malloc(sizeof(struct prngState)); if(!priv){ recGblRecordError(S_db_noMemory, (void*)pao, "devAoTimebase failed to allocate private struct"); return S_db_noMemory; } recGblInitConstantLink(&pao->inp,DBF_ULONG,&start); priv->seed=start; pao->dpvt=priv; return 0; }
static long init_record(histogramRecord *prec) { /* histogram.svl must be a CONSTANT or a PV_LINK or a DB_LINK or a CA_LINK*/ switch (prec->svl.type) { case (CONSTANT) : if(recGblInitConstantLink(&prec->svl,DBF_DOUBLE,&prec->sgnl)) prec->udf = FALSE; break; case (PV_LINK) : case (DB_LINK) : case (CA_LINK) : break; default : recGblRecordError(S_db_badField,(void *)prec, "devHistogramSoft (init_record) Illegal SVL field"); return(S_db_badField); } return 0; }
static long init_record(eventRecord *prec) { /* INP must be CONSTANT, PV_LINK, DB_LINK or CA_LINK*/ switch (prec->inp.type) { case CONSTANT: if (recGblInitConstantLink(&prec->inp, DBF_STRING, &prec->val)) prec->udf = FALSE; break; case PV_LINK: case DB_LINK: case CA_LINK: break; default: recGblRecordError(S_db_badField, (void *)prec, "devEventSoft (init_record) Illegal INP field"); return S_db_badField; } return 0; }
static long init_record(struct histogramRecord *prec) { CALLBACK *pcallback; /* histogram.svl must be a CONSTANT*/ switch (prec->svl.type) { case (CONSTANT) : pcallback = (CALLBACK *)(calloc(1,sizeof(CALLBACK))); prec->dpvt = (void *)pcallback; if(recGblInitConstantLink(&prec->svl,DBF_DOUBLE,&prec->sgnl)) prec->udf = FALSE; break; default : recGblRecordError(S_db_badField,(void *)prec, "devHistogramTestAsyn (init_record) Illegal SVL field"); prec->pact=TRUE; return(S_db_badField); } return(0); }
static long init_record(mbbiDirectRecord *prec) { /* INP must be CONSTANT, PV_LINK, DB_LINK or CA_LINK*/ switch (prec->inp.type) { case CONSTANT: recGblInitConstantLink(&prec->inp, DBF_ULONG, &prec->rval); break; case PV_LINK: case DB_LINK: case CA_LINK: break; default: recGblRecordError(S_db_badField, (void *)prec, "devMbbiDirectSoftRaw (init_record) Illegal INP field"); return S_db_badField; } /*to preserve old functionality*/ if (prec->nobt == 0) prec->mask = 0xffffffff; prec->mask <<= prec->shft; return 0; }
static long init_record(struct RECORDTYPE *precord, int pass) { RECORDTYPE *self = (RECORDTYPE *)precord; long status; DBLINK *plink; if (pass == 0){ if(self->nelm <= 0) self->nelm=1; if(self->nelm == 1) { self->nord = 1; } else { self->nord = 0; } self->bptr = (double *)calloc(self->nelm, sizeof(double)); if (self->bptr == NULL ){ self->pact=TRUE; /* errlogPrintf("aRaw:(array select) cannot allocate buffer area.");*/ self->nord = 0; if (self->bptr != NULL) free(self->bptr); return (-1); } return(0); } /* AveDev Record is a pure soft record */ plink = &(self->inp); if(plink->type == CONSTANT){ self->bptr = (double *) calloc(1,sizeof(double)); self->nord = 1; recGblInitConstantLink(plink, DBF_DOUBLE, self->bptr); } else{ status=dbGetNelements(plink, (signed long *)&self->nord); if (self->nord> self->nelm){ self->nord = self->nelm; } } return(0); }
static long init_record(waveformRecord *prec, int pass) { struct wfdset *pdset; if (pass==0) { if (prec->nelm <= 0) prec->nelm = 1; if (prec->ftvl > DBF_ENUM) prec->ftvl = DBF_UCHAR; prec->bptr = callocMustSucceed(prec->nelm, dbValueSize(prec->ftvl), "waveform calloc failed"); if (prec->nelm == 1) { prec->nord = 1; } else { prec->nord = 0; } return 0; } /* wf.siml must be a CONSTANT or a PV_LINK or a DB_LINK */ if (prec->siml.type == CONSTANT) { recGblInitConstantLink(&prec->siml,DBF_USHORT,&prec->simm); } /* must have dset defined */ if (!(pdset = (struct wfdset *)(prec->dset))) { recGblRecordError(S_dev_noDSET,(void *)prec,"wf: init_record"); return S_dev_noDSET; } /* must have read_wf function defined */ if ((pdset->number < 5) || (pdset->read_wf == NULL)) { recGblRecordError(S_dev_missingSup,(void *)prec,"wf: init_record"); return S_dev_missingSup; } if (! pdset->init_record) return 0; return (*pdset->init_record)(prec); }
static long dsetInit_devBiSyncSoft(biRecord *pbi) { dsetLog(3, __FILE__ "[%d] -> %s(%s)\n", __LINE__, __func__, pbi->name); switch (pbi->inp.type) { case (CONSTANT) : if(recGblInitConstantLink(&pbi->inp,DBF_ENUM,&pbi->val)) pbi->udf = FALSE; break; case (DB_LINK) : case (PV_LINK) : case (CA_LINK) : break; default : recGblRecordError(S_db_badField,(void *)pbi, "SNOVA_devBiSyncSoft (init_record) Illegal INP field"); return(S_db_badField); } dsetLog(3, __FILE__ "[%d] <- %s\n", __LINE__, __func__); return(SUCCESS); }
long snmp_Init(void *precord) { snmpRecord *psnmp = (snmpRecord *)precord; /* psnmp->dpvt = (SNMP_INFO*)gsnmpInfo; */ printf("snmpInit()****** Message: %s, version: %s, ip: %s, name: %s, authpass: %s, privpass: %s\n",snmpinfo->msg, snmpinfo->version, snmpinfo->hostaddr, snmpinfo->username, snmpinfo->authpass, snmpinfo->privpass); if(recGblInitConstantLink(&psnmp->inp,DBF_DOUBLE,&psnmp->val)) psnmp->udf = FALSE; devSNMPPvt *pdev = (devSNMPPvt *)malloc(sizeof (devSNMPPvt)); if(pdev == NULL) return -1; pdev->mutexId = epicsMutexCreate(); scanIoInit(&pdev->ioScanPvt); psnmp->dpvt = pdev; pdev->prec = (dbCommon*)precord; ellAdd(&devSNMPList, &(((devSNMPPvt*)psnmp->dpvt)->devSNMPNode)); initialize(psnmp); return(0); }
static long init_record(aSubRecord *prec, int pass) { GENFUNCPTR pfunc; long status; int i; status = 0; if (pass == 0) { /* Allocate memory for arrays */ initFields(&prec->fta, &prec->noa, &prec->nea, Ifldnames, &prec->a, NULL); initFields(&prec->ftva, &prec->nova, &prec->neva, Ofldnames, &prec->vala, &prec->ovla); return 0; } /* Initialize the Subroutine Name Link */ switch (prec->subl.type) { case CONSTANT: recGblInitConstantLink(&prec->subl, DBF_STRING, prec->snam); break; case PV_LINK: case DB_LINK: case CA_LINK: break; default: recGblRecordError(S_db_badField, (void *)prec, "aSubRecord(init_record) Bad SUBL link type"); return S_db_badField; } /* Initialize Input Links */ for (i = 0; i < NUM_ARGS; i++) { struct link *plink = &(&prec->inpa)[i]; switch (plink->type) { case CONSTANT: if ((&prec->noa)[i] < 2) { if (recGblInitConstantLink(plink, (&prec->fta)[i], (&prec->a)[i])) { prec->udf = FALSE; } else prec->udf = TRUE; } break; case PV_LINK: case CA_LINK: case DB_LINK: break; default: recGblRecordError(S_db_badField, (void *)prec, "aSubRecord(init_record) Illegal INPUT LINK"); status = S_db_badField; break; } } if (status) return status; /* Initialize Output Links */ for (i = 0; i < NUM_ARGS; i++) { switch ((&prec->outa)[i].type) { case CONSTANT: case PV_LINK: case CA_LINK: case DB_LINK: break; default: recGblRecordError(S_db_badField, (void *)prec, "aSubRecord(init_record) Illegal OUTPUT LINK"); status = S_db_badField; } } if (status) return status; /* Call the user initialization routine if there is one */ if (prec->inam[0] != 0) { pfunc = (GENFUNCPTR)registryFunctionFind(prec->inam); if (pfunc) { pfunc(prec); } else { recGblRecordError(S_db_BadSub, (void *)prec, "aSubRecord::init_record - INAM subr not found"); return S_db_BadSub; } } if (prec->lflg == aSubLFLG_IGNORE && prec->snam[0] != 0) { pfunc = (GENFUNCPTR)registryFunctionFind(prec->snam); if (pfunc) prec->sadr = pfunc; else { recGblRecordError(S_db_BadSub, (void *)prec, "aSubRecord::init_record - SNAM subr not found"); return S_db_BadSub; } } strcpy(prec->onam, prec->snam); prec->oval = prec->val; return 0; }