diff --git a/src/as/asCa.c b/src/as/asCa.c index 8df3cb94a..a03cb15cd 100644 --- a/src/as/asCa.c +++ b/src/as/asCa.c @@ -1,42 +1,63 @@ /* share/src/as/asCa.c */ /* share/src/as $Id$ */ -/* - * Author: Marty Kraimer - * Date: 10-15-93 - * - * Experimental Physics and Industrial Control System (EPICS) - * - * Copyright 1991, the Regents of the University of California, - * and the University of Chicago Board of Governors. - * - * This software was produced under U.S. Government contracts: - * (W-7405-ENG-36) at the Los Alamos National Laboratory, - * and (W-31-109-ENG-38) at Argonne National Laboratory. - * - * Initial development by: - * The Controls and Automation Group (AT-8) - * Ground Test Accelerator - * Accelerator Technology Division - * Los Alamos National Laboratory - * - * Co-developed with - * The Controls and Computing Group - * Accelerator Systems Division - * Advanced Photon Source - * Argonne National Laboratory +/* Author: Marty Kraimer Date: 10-15-93 */ +/***************************************************************** + COPYRIGHT NOTIFICATION +***************************************************************** + +THE FOLLOWING IS A NOTICE OF COPYRIGHT, AVAILABILITY OF THE CODE, +AND DISCLAIMER WHICH MUST BE INCLUDED IN THE PROLOGUE OF THE CODE +AND IN ALL SOURCE LISTINGS OF THE CODE. + +(C) COPYRIGHT 1993 UNIVERSITY OF CHICAGO + +Argonne National Laboratory (ANL), with facilities in the States of +Illinois and Idaho, is owned by the United States Government, and +operated by the University of Chicago under provision of a contract +with the Department of Energy. + +Portions of this material resulted from work developed under a U.S. +Government contract and are subject to the following license: For +a period of five years from March 30, 1993, the Government is +granted for itself and others acting on its behalf a paid-up, +nonexclusive, irrevocable worldwide license in this computer +software to reproduce, prepare derivative works, and perform +publicly and display publicly. With the approval of DOE, this +period may be renewed for two additional five year periods. +Following the expiration of this period or periods, the Government +is granted for itself and others acting on its behalf, a paid-up, +nonexclusive, irrevocable worldwide license in this computer +software to reproduce, prepare derivative works, distribute copies +to the public, perform publicly and display publicly, and to permit +others to do so. + +***************************************************************** + DISCLAIMER +***************************************************************** + +NEITHER THE UNITED STATES GOVERNMENT NOR ANY AGENCY THEREOF, NOR +THE UNIVERSITY OF CHICAGO, NOR ANY OF THEIR EMPLOYEES OR OFFICERS, +MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR ASSUMES ANY LEGAL +LIABILITY OR RESPONSIBILITY FOR THE ACCURACY, COMPLETENESS, OR +USEFULNESS OF ANY INFORMATION, APPARATUS, PRODUCT, OR PROCESS +DISCLOSED, OR REPRESENTS THAT ITS USE WOULD NOT INFRINGE PRIVATELY +OWNED RIGHTS. + +***************************************************************** +LICENSING INQUIRIES MAY BE DIRECTED TO THE INDUSTRIAL TECHNOLOGY +DEVELOPMENT CENTER AT ARGONNE NATIONAL LABORATORY (708-252-2000). * * Modification Log: * ----------------- * .01 03-22-94 mrk Initial Implementation */ +#include +#include #include #include #include #include -#ifdef vxWorks -#include -#endif #include #include #include @@ -44,38 +65,35 @@ #include #include #include +#include -static ASBASE *pasbase=NULL; -static int taskid; +static int taskid=0; +static int caInitializing=FALSE; +extern ASBASE *pasbase; typedef struct { struct dbr_sts_double rtndata; - chid mychid; - evid myevid; - int gotEvent; + chid chid; + evid evid; } CAPVT; void connectCallback(struct connection_handler_args cha) { - chid chid=cha.chid; + chid chid = cha.chid; ASGINP *pasginp = (ASGINP *)ca_puser(chid); - ASG *pasg = (ASG *)pasginp->pasg;; - int inpOk=TRUE; + ASG *pasg = (ASG *)pasginp->pasg; CAPVT *pcapvt; enum channel_state state; pasginp = (ASGINP *)ellFirst(&pasg->inpList); - while(pasginp) { - pcapvt = pasginp->capvt; - if(ca_state(pcapvt->chid)!=cs_conn) { - inpOk = FALSE; - pcapvt->gotEvent = FALSE; + pcapvt = pasginp->capvt; + if(ca_state(pcapvt->chid)!=cs_conn) { + pasg->inpBad |= (1<inpIndex); + if(!caInitializing) { + FASTLOCK(&asLock); + asComputeAsg(pasg); + FASTUNLOCK(&asLock); } - pasginp = (ASGINP *)ellNext((ELLNODE *)pasginp); - } - if(!inpOk && pasg->inpOk) { - pasg->inpOk = FALSE; - asComputeAsg(pasg); } } @@ -83,64 +101,83 @@ void eventCallback(struct event_handler_args eha) { ASGINP *pasginp = (ASGINP *)eha.usr; CAPVT *pcapvt = (CAPVT *)pasginp->capvt; - ASG *pasg = (ASG *)pasginp->pasg;; + ASG *pasg = (ASG *)pasginp->pasg; int inpOk=TRUE; enum channel_state state; struct dbr_sts_double *pdata = eha.dbr; pcapvt->rtndata = *pdata; /*structure copy*/ - pcapvt->gotEvent = TRUE; - pasg->pavalue[pasginp->inpIndex] = pdata->value; - pasginp = (ASGINP *)ellFirst(&pasg->inpList); - while(pasginp) { - pcapvt = pasginp->capvt; - if(ca_state(pcapvt->chid)!=cs_conn) { - inpOk = FALSE; - pcapvt->gotEvent = FALSE; - } - pasginp = (ASGINP *)ellNext((ELLNODE *)pasginp); + if(pdata->severity==INVALID_ALARM) { + pasg->inpBad |= (1<inpIndex); + } else { + pasg->inpBad &= ~((1<inpIndex)); + pasg->pavalue[pasginp->inpIndex] = pdata->value; } - if(!inpOk && pasg->inpOk) { - pasg->inpOk = FALSE; + if(!caInitializing) { + FASTLOCK(&asLock); asComputeAsg(pasg); + FASTUNLOCK(&asLock); } } -static asCaInit( +static void asCaTask(void) +{ ASG *pasg; ASGINP *pasginp; - CAINP *pcapvt; + CAPVT *pcapvt; SEVCHK(ca_task_initialize(),"ca_task_initialize"); + caInitializing = TRUE; pasg = (ASG *)ellFirst(&pasbase->asgList); while(pasg) { - pasg->inpOk = FALSE; pasginp = (ASGINP *)ellFirst(&pasg->inpList); while(pasginp) { + pasg->inpBad |= (1<inpIndex); pcapvt = pasginp->capvt = asCalloc(1,sizeof(CAPVT)); SEVCHK(ca_build_and_connect(pasginp->inp,TYPENOTCONN,0, - &pcapvt->mychid,0,connectCallback,pasginp), + &pcapvt->chid,0,connectCallback,pasginp), "ca_build_and_connect"); - SEVCHK(ca_add_event(DBR_STATUS_DOUBLE,pcapvt->mychid, - eventCallback,pasginp,&pcapvt->myevid), + SEVCHK(ca_add_event(DBR_STS_DOUBLE,pcapvt->chid, + eventCallback,pasginp,&pcapvt->evid), "ca_add_event"); pasginp = (ASGINP *)ellNext((ELLNODE *)pasginp); } pasg = (ASG *)ellNext((ELLNODE *)pasg); } + caInitializing = FALSE; SEVCHK(ca_pend_event(0.0),"ca_pend_event"); + exit(-1); } -void asCaStart(ASBASE *ptemp) +void asCaStart(void) { - pasbase = ptemp; - taskid = taskSpawn("asCa",CA_CLIENT_PRI,VX_FP_TASK,CA_CLIENT_STACK, - (FUNCPTR)asCaInit,0,0,0,0,0,0,0,0,0,0); + taskid = taskSpawn("asCa",CA_CLIENT_PRI-1,VX_FP_TASK,CA_CLIENT_STACK, + (FUNCPTR)asCaTask,0,0,0,0,0,0,0,0,0,0); + if(taskid==ERROR) errMessage(0,"asCaStart: taskSpawn Failure\n"); } -static asCaStop(void) +void asCaStop(void) { - taskDelete(taskid); - + ASG *pasg; + ASGINP *pasginp; + CAPVT *pcapvt; + STATUS status; + + if(taskid==0 || taskid==ERROR) return; + status = taskDelete(taskid); + if(status!=OK) errMessage(0,"asCaStop: taskDelete Failure\n"); + while(taskIdVerify(taskid)==OK) { + taskDelay(5); + } + pasg = (ASG *)ellFirst(&pasbase->asgList); + while(pasg) { + pasginp = (ASGINP *)ellFirst(&pasg->inpList); + while(pasginp) { + free(pasginp->capvt); + pasginp = (ASGINP *)ellNext((ELLNODE *)pasginp); + } + pasg = (ASG *)ellNext((ELLNODE *)pasg); + } +} diff --git a/src/as/asDbLib.c b/src/as/asDbLib.c index 3c71a50ef..24ced5abe 100644 --- a/src/as/asDbLib.c +++ b/src/as/asDbLib.c @@ -1,34 +1,59 @@ -/* share/src/as/dbAsLib.c */ +/* share/src/as/asDbLib.c */ /* share/src/as $Id$ */ -/* - * Author: Marty Kraimer - * Date: 02-11-94 - * - * Experimental Physics and Industrial Control System (EPICS) - * - * Copyright 1991, the Regents of the University of California, - * and the University of Chicago Board of Governors. - * - * This software was produced under U.S. Government contracts: - * (W-7405-ENG-36) at the Los Alamos National Laboratory, - * and (W-31-109-ENG-38) at Argonne National Laboratory. - * - * Initial development by: - * The Controls and Automation Group (AT-8) - * Ground Test Accelerator - * Accelerator Technology Division - * Los Alamos National Laboratory - * - * Co-developed with - * The Controls and Computing Group - * Accelerator Systems Division - * Advanced Photon Source - * Argonne National Laboratory +/* Author: Marty Kraimer Date: 02-11-94*/ +/***************************************************************** + COPYRIGHT NOTIFICATION +***************************************************************** + +THE FOLLOWING IS A NOTICE OF COPYRIGHT, AVAILABILITY OF THE CODE, +AND DISCLAIMER WHICH MUST BE INCLUDED IN THE PROLOGUE OF THE CODE +AND IN ALL SOURCE LISTINGS OF THE CODE. + +(C) COPYRIGHT 1993 UNIVERSITY OF CHICAGO + +Argonne National Laboratory (ANL), with facilities in the States of +Illinois and Idaho, is owned by the United States Government, and +operated by the University of Chicago under provision of a contract +with the Department of Energy. + +Portions of this material resulted from work developed under a U.S. +Government contract and are subject to the following license: For +a period of five years from March 30, 1993, the Government is +granted for itself and others acting on its behalf a paid-up, +nonexclusive, irrevocable worldwide license in this computer +software to reproduce, prepare derivative works, and perform +publicly and display publicly. With the approval of DOE, this +period may be renewed for two additional five year periods. +Following the expiration of this period or periods, the Government +is granted for itself and others acting on its behalf, a paid-up, +nonexclusive, irrevocable worldwide license in this computer +software to reproduce, prepare derivative works, distribute copies +to the public, perform publicly and display publicly, and to permit +others to do so. + +***************************************************************** + DISCLAIMER +***************************************************************** + +NEITHER THE UNITED STATES GOVERNMENT NOR ANY AGENCY THEREOF, NOR +THE UNIVERSITY OF CHICAGO, NOR ANY OF THEIR EMPLOYEES OR OFFICERS, +MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR ASSUMES ANY LEGAL +LIABILITY OR RESPONSIBILITY FOR THE ACCURACY, COMPLETENESS, OR +USEFULNESS OF ANY INFORMATION, APPARATUS, PRODUCT, OR PROCESS +DISCLOSED, OR REPRESENTS THAT ITS USE WOULD NOT INFRINGE PRIVATELY +OWNED RIGHTS. + +***************************************************************** +LICENSING INQUIRIES MAY BE DIRECTED TO THE INDUSTRIAL TECHNOLOGY +DEVELOPMENT CENTER AT ARGONNE NATIONAL LABORATORY (708-252-2000). * * Modification Log: * ----------------- * .01 02-11-94 mrk Initial Implementation */ + +#include +#include #include #include #include @@ -38,19 +63,26 @@ #include #include #include +#include +#include +#include extern struct dbBase *pdbBase; static FILE *stream; #define BUF_SIZE 100 -static char *my_buffer; -static char *my_buffer_ptr=NULL; +static char *my_buffer; +static char *my_buffer_ptr=NULL; +static char *pacf=NULL; +FAST_LOCK asLock; +int asLockInit=TRUE; +static int initTaskId=0; static int my_yyinput(char *buf, int max_size) { int l,n; - if(!my_buffer_ptr || *my_buffer_ptr==0) { + if(*my_buffer_ptr==0) { if(fgets(my_buffer,BUF_SIZE,stream)==NULL) return(0); my_buffer_ptr = my_buffer; } @@ -87,38 +119,92 @@ static long asDbAddRecords(void) return(0); } -int asInit(char *filename) +int asSetFilename(char *acf) +{ + if(asLockInit) { + FASTLOCKINIT(&asLock); + asLockInit = FALSE; + } + FASTLOCK(&asLock); + if(pacf) free ((void *)pacf); + pacf = calloc(1,strlen(acf)+1); + if(!pacf) { + errMessage(0,"asSetFilename calloc failure"); + FASTUNLOCK(&asLock); + return(-1); + } + strcpy(pacf,acf); + FASTUNLOCK(&asLock); + return(0); +} + +static void asInitTask(void) { long status; - my_buffer = malloc(BUF_SIZE); + if(asLockInit) { + FASTLOCKINIT(&asLock); + asLockInit = FALSE; + } + FASTLOCK(&asLock); + asCaStop(); + my_buffer = calloc(1,BUF_SIZE); + my_buffer_ptr = my_buffer; if(!my_buffer) { errMessage(0,"asInit malloc failure"); - return(-1); + FASTUNLOCK(&asLock); + return; } - stream = fopen(filename,"r"); + stream = fopen(pacf,"r"); if(!stream) { errMessage(0,"asInit failure"); - return(-1); + FASTUNLOCK(&asLock); + return; } status = asInitialize(my_yyinput); if(fclose(stream)==EOF) errMessage(0,"asInit fclose failure"); free((void *)my_buffer); asDbAddRecords(); + asCaStart(); + taskDelay(60); + asComputeAllAsg(); + FASTUNLOCK(&asLock); + initTaskId = 0; + status = taskDelete(taskIdSelf()); + if(status!=OK) errMessage(0,"asInitTask: taskDelete Failure"); +} + +int asInit(void) +{ + long status; + + if(!pacf) return(0); + if(initTaskId) { + errMessage(-1,"asInit: asInitTask already active"); + return(-1); + } + initTaskId = taskSpawn("asInitTask",CA_CLIENT_PRI-1,VX_FP_TASK,CA_CLIENT_STACK, + (FUNCPTR)asInitTask,0,0,0,0,0,0,0,0,0,0); + if(initTaskId==ERROR) { + errMessage(0,"asInit: taskSpawn Error"); + initTaskId = 0; + } return(0); } -void static myMemberCallback(ASMEMBERPVT memPvt) +/*Interface to subroutine record*/ +long asSubInit(struct subRecord *precord,int pass) { - struct dbCommon *precord; - - precord = asGetMemberPvt(memPvt); - if(precord) printf(" Record:%s",precord->name); + return(0); } -int asdbdump(void) +long asSubProcess(struct subRecord *precord) { - asDump(myMemberCallback,NULL); + if(precord->val!=1.0) return(0); + asInit(); + db_post_events(precord,&precord->val,DBE_VALUE); + precord->val=0.0; + db_post_events(precord,&precord->val,DBE_VALUE); return(0); } @@ -165,3 +251,50 @@ int astac(char *pname,char *user,char *location) } return(0); } + +static char *asAccessName[] = {"NONE","READ","WRITE"}; +void static myMemberCallback(ASMEMBERPVT memPvt) +{ + struct dbCommon *precord; + + precord = asGetMemberPvt(memPvt); + if(precord) printf(" Record:%s",precord->name); +} + +int asdbdump(void) +{ + FASTLOCK(&asLock); + asDump(myMemberCallback,NULL,1); + FASTUNLOCK(&asLock); + return(0); +} + +int aspuag(char *uagname) +{ + + FASTLOCK(&asLock); + asDumpUag(uagname); + FASTUNLOCK(&asLock); + return(0); +} + +int asplag(char *lagname) +{ + FASTLOCK(&asLock); + asDumpLag(lagname); + FASTUNLOCK(&asLock); +} + +int asplev(char *asgname) +{ + FASTLOCK(&asLock); + asDumpLev(asgname); + FASTUNLOCK(&asLock); +} + +int aspmem(char *asgname,int clients) +{ + FASTLOCK(&asLock); + asDumpMem(asgname,myMemberCallback,clients); + FASTUNLOCK(&asLock); +} diff --git a/src/as/asLib.y b/src/as/asLib.y index 2de90abf5..c34a6fd51 100644 --- a/src/as/asLib.y +++ b/src/as/asLib.y @@ -1,5 +1,6 @@ %{ static int yyerror(); +static int yy_start; static int myParse(); #include "asLibRoutines.c" static int line_num=1; @@ -225,8 +226,9 @@ static int myParse(ASINPUTFUNCPTR inputfunction) my_yyinput = &inputfunction; if (!FirstFlag) { line_num=1; + yyreset(NULL); yyrestart(NULL); - FirstFlag = 0; } + FirstFlag = 0; return(yyparse()); } diff --git a/src/as/asLibRoutines.c b/src/as/asLibRoutines.c index 6564ac87e..2973bc9b9 100644 --- a/src/as/asLibRoutines.c +++ b/src/as/asLibRoutines.c @@ -1,34 +1,57 @@ /* share/src/as/asLibRoutines.c */ /* share/src/as $Id$ */ -/* - * Author: Marty Kraimer - * Date: 10-15-93 - * - * Experimental Physics and Industrial Control System (EPICS) - * - * Copyright 1991, the Regents of the University of California, - * and the University of Chicago Board of Governors. - * - * This software was produced under U.S. Government contracts: - * (W-7405-ENG-36) at the Los Alamos National Laboratory, - * and (W-31-109-ENG-38) at Argonne National Laboratory. - * - * Initial development by: - * The Controls and Automation Group (AT-8) - * Ground Test Accelerator - * Accelerator Technology Division - * Los Alamos National Laboratory - * - * Co-developed with - * The Controls and Computing Group - * Accelerator Systems Division - * Advanced Photon Source - * Argonne National Laboratory +/* Author: Marty Kraimer Date: 10-15-93 */ +/***************************************************************** + COPYRIGHT NOTIFICATION +***************************************************************** + +THE FOLLOWING IS A NOTICE OF COPYRIGHT, AVAILABILITY OF THE CODE, +AND DISCLAIMER WHICH MUST BE INCLUDED IN THE PROLOGUE OF THE CODE +AND IN ALL SOURCE LISTINGS OF THE CODE. + +(C) COPYRIGHT 1993 UNIVERSITY OF CHICAGO + +Argonne National Laboratory (ANL), with facilities in the States of +Illinois and Idaho, is owned by the United States Government, and +operated by the University of Chicago under provision of a contract +with the Department of Energy. + +Portions of this material resulted from work developed under a U.S. +Government contract and are subject to the following license: For +a period of five years from March 30, 1993, the Government is +granted for itself and others acting on its behalf a paid-up, +nonexclusive, irrevocable worldwide license in this computer +software to reproduce, prepare derivative works, and perform +publicly and display publicly. With the approval of DOE, this +period may be renewed for two additional five year periods. +Following the expiration of this period or periods, the Government +is granted for itself and others acting on its behalf, a paid-up, +nonexclusive, irrevocable worldwide license in this computer +software to reproduce, prepare derivative works, distribute copies +to the public, perform publicly and display publicly, and to permit +others to do so. + +***************************************************************** + DISCLAIMER +***************************************************************** + +NEITHER THE UNITED STATES GOVERNMENT NOR ANY AGENCY THEREOF, NOR +THE UNIVERSITY OF CHICAGO, NOR ANY OF THEIR EMPLOYEES OR OFFICERS, +MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR ASSUMES ANY LEGAL +LIABILITY OR RESPONSIBILITY FOR THE ACCURACY, COMPLETENESS, OR +USEFULNESS OF ANY INFORMATION, APPARATUS, PRODUCT, OR PROCESS +DISCLOSED, OR REPRESENTS THAT ITS USE WOULD NOT INFRINGE PRIVATELY +OWNED RIGHTS. + +***************************************************************** +LICENSING INQUIRIES MAY BE DIRECTED TO THE INDUSTRIAL TECHNOLOGY +DEVELOPMENT CENTER AT ARGONNE NATIONAL LABORATORY (708-252-2000). * * Modification Log: * ----------------- * .01 10-15-93 mrk Initial Implementation */ + #include #include #include @@ -39,6 +62,10 @@ #include #endif +/*Declare storage for Global Variables */ +ASBASE *pasbase=NULL; +static int asActive = FALSE; + /*Forward declarations for Non ANSI routines*/ long calcPerform(double *parg,double *presult,char *post); long postfix(char *pinfix, char *ppostfix,short *perror); @@ -46,11 +73,8 @@ long postfix(char *pinfix, char *ppostfix,short *perror); #define RPCL_LEN 184 #define DEFAULT "DEFAULT" -static ASBASE *pasbase=NULL; -int asActive = FALSE; /*private routines */ -void * asCalloc(size_t nobj,size_t size); static void asFreeAll(ASBASE *pasbase); static UAG *asUagAdd(char *uagName); static long asUagAddUser(UAG *puag,char *user); @@ -62,18 +86,14 @@ static ASGLEVEL *asAsgAddLevel(ASG *pasg,asAccessRights access,int level); static long asAsgLevelUagAdd(ASGLEVEL *pasglevel,char *name); static long asAsgLevelLagAdd(ASGLEVEL *pasglevel,char *name); static long asAsgLevelCalc(ASGLEVEL *pasglevel,char *calc); -static void asCaStart(void); -static void asCaStop(void); long asInitialize(ASINPUTFUNCPTR inputfunction) { ASG *pasg; long status; - ASBASE *pasbaseold = pasbase; + ASBASE *pasbaseold; - if(pasbaseold) { - asCaStop(); - } + pasbaseold = pasbase; pasbase = asCalloc(1,sizeof(ASBASE)); ellInit(&pasbase->uagList); ellInit(&pasbase->lagList); @@ -82,7 +102,7 @@ long asInitialize(ASINPUTFUNCPTR inputfunction) status = myParse(inputfunction); if(status) { status = S_asLib_badConfig; - asFreeAll(pasbase); + /*Not safe to call asFreeAll */ pasbase = pasbaseold; return(status); } @@ -110,7 +130,6 @@ long asInitialize(ASINPUTFUNCPTR inputfunction) } asFreeAll(pasbaseold); } - asCaStart(); return(0); } @@ -118,7 +137,6 @@ long asAddMember(ASMEMBERPVT *pasMemberPvt,char *asgName) { ASGMEMBER *pasgmember; ASG *pgroup; - ASGCLIENT *pclient; long status; if(!asActive) return(0); @@ -146,14 +164,6 @@ long asAddMember(ASMEMBERPVT *pasMemberPvt,char *asgName) got_it: pasgmember->pasg = pgroup; ellAdd(&pgroup->memberList,(ELLNODE *)pasgmember); - pclient = (ASGCLIENT *)ellFirst(&pasgmember->clientList); - while(pclient) { - status = asCompute(pclient); - if(status) { - errMessage(status,"asAddMember"); - } - pclient = (ASGCLIENT *)ellNext((ELLNODE *)pclient); - } return(0); } @@ -178,17 +188,35 @@ long asRemoveMember(ASMEMBERPVT *asMemberPvt) long asChangeGroup(ASMEMBERPVT *asMemberPvt,char *newAsgName) { ASGMEMBER *pasgmember; + ASGCLIENT *pclient; long status; if(!asActive) return(0); +#ifdef vxWorks + FASTLOCK(&asLock); +#endif pasgmember = *asMemberPvt; if(pasgmember->pasg) { ellDelete(&pasgmember->pasg->memberList,(ELLNODE *)pasgmember); } else { errMessage(-1,"Logic error in asChangeGroup"); +#ifdef vxWorks + FASTUNLOCK(&asLock); +#endif exit(-1); } status = asAddMember(asMemberPvt,newAsgName); + pclient = (ASGCLIENT *)ellFirst(&pasgmember->clientList); + while(pclient) { + status = asCompute(pclient); + if(status) { + errMessage(status,"asAddMember"); + } + pclient = (ASGCLIENT *)ellNext((ELLNODE *)pclient); + } +#ifdef vxWorks + FASTUNLOCK(&asLock); +#endif return(status); } @@ -222,12 +250,14 @@ long asAddClient(ASCLIENTPVT *pasClientPvt,ASMEMBERPVT asMemberPvt, pasclient->level = asl; pasclient->user = user; pasclient->location = location; - status = asCompute(pasclient); - if(status) return(status); - if(!asCheckGet(pasclient)) { - return(S_asLib_noAccess); - } +#ifdef vxWorks + FASTLOCK(&asLock); +#endif ellAdd(&pasmember->clientList,(ELLNODE *)pasclient); + status = asCompute(pasclient); +#ifdef vxWorks + FASTUNLOCK(&asLock); +#endif return(status); } @@ -240,10 +270,16 @@ long asChangeClient(ASCLIENTPVT asClientPvt,int asl,char *user,char *location) pasclient->level = asl; pasclient->user = user; pasclient->location = location; +#ifdef vxWorks + FASTLOCK(&asLock); +#endif status = asCompute(pasclient); +#ifdef vxWorks + FASTUNLOCK(&asLock); +#endif return(status); } - + long asRemoveClient(ASCLIENTPVT *asClientPvt) { ASGCLIENT *pasgClient = *asClientPvt; @@ -251,12 +287,21 @@ long asRemoveClient(ASCLIENTPVT *asClientPvt) if(!asActive) return(0); if(!pasgClient) return(0); +#ifdef vxWorks + FASTLOCK(&asLock); +#endif pasgMember = pasgClient->pasgMember; if(!pasgMember) { errMessage(-1,"asRemoveClient: No ASGMEMBER"); +#ifdef vxWorks + FASTUNLOCK(&asLock); +#endif return(-1); } ellDelete(&pasgMember->clientList,(ELLNODE *)pasgClient); +#ifdef vxWorks + FASTUNLOCK(&asLock); +#endif free((void *)pasgClient); *asClientPvt = NULL; return(0); @@ -278,6 +323,35 @@ void asPutClientPvt(ASCLIENTPVT asClientPvt,void *userPvt) if(!pasclient) return; pasclient->userPvt = userPvt; } + +long asComputeAllAsg(void) +{ + ASG *pasg; + + pasg = (ASG *)ellFirst(&pasbase->asgList); + while(pasg) { + asComputeAsg(pasg); + pasg = (ASG *)ellNext((ELLNODE *)pasg); + } + return(0); +} + +long asComputeAsg(ASG *pasg) +{ + ASGMEMBER *pasgmember; + ASGCLIENT *pasgclient; + + if(!asActive) return(0); + pasgmember = (ASGMEMBER *)ellFirst(&pasg->memberList); + while(pasgmember) { + pasgclient = (ASGCLIENT *)ellFirst(&pasgmember->clientList); + while(pasgclient) { + asCompute((ASCLIENTPVT)pasgclient); + pasgclient = (ASGCLIENT *)ellNext((ELLNODE *)pasgclient); + } + pasgmember = (ASGMEMBER *)ellNext((ELLNODE *)pasgmember); + } +} long asCompute(ASCLIENTPVT asClientPvt) { @@ -290,61 +364,77 @@ long asCompute(ASCLIENTPVT asClientPvt) long status; if(!pasg) return(0); - pasglevel = (ASGLEVEL *)ellFirst(&pasg->levelList); - while(pasglevel) { - if(access == asWRITE) break; - if(access>=pasglevel->access) goto next_level; - if(pasgClient->level > pasglevel->level) goto next_level; - /*if uagList is empty then no need to check uag*/ - if(ellCount(&pasglevel->uagList)>0){ - ASGUAG *pasguag; - UAG *puag; - UAGNAME *puagname; + while(TRUE) { + pasglevel = (ASGLEVEL *)ellFirst(&pasg->levelList); + while(pasglevel) { + if(access == asWRITE) break; + if(access>=pasglevel->access) goto next_level; + if(pasgClient->level > pasglevel->level) goto next_level; + /*if uagList is empty then no need to check uag*/ + if(ellCount(&pasglevel->uagList)>0){ + ASGUAG *pasguag; + UAG *puag; + UAGNAME *puagname; - pasguag = (ASGUAG *)ellFirst(&pasglevel->uagList); - while(pasguag) { - if(puag = pasguag->puag) { - puagname = (UAGNAME *)ellFirst(&puag->list); - while(puagname) { - if(strcmp(pasgClient->user,puagname->user)==0) - goto check_lag; - puagname = (UAGNAME *)ellNext((ELLNODE *)puagname); + pasguag = (ASGUAG *)ellFirst(&pasglevel->uagList); + while(pasguag) { + if(puag = pasguag->puag) { + puagname = (UAGNAME *)ellFirst(&puag->list); + while(puagname) { + if(strcmp(pasgClient->user,puagname->user)==0) + goto check_lag; + puagname = (UAGNAME *)ellNext((ELLNODE *)puagname); + } } + pasguag = (ASGUAG *)ellNext((ELLNODE *)pasguag); } - pasguag = (ASGUAG *)ellNext((ELLNODE *)pasguag); + goto next_level; } - goto next_level; - } check_lag: - /*if lagList is empty then no need to check lag*/ - if(ellCount(&pasglevel->lagList)>0) { - ASGLAG *pasglag; - LAG *plag; - LAGNAME *plagname; + /*if lagList is empty then no need to check lag*/ + if(ellCount(&pasglevel->lagList)>0) { + ASGLAG *pasglag; + LAG *plag; + LAGNAME *plagname; - pasglag = (ASGLAG *)ellFirst(&pasglevel->lagList); - while(pasglag) { - if(plag = pasglag->plag) { - plagname = (LAGNAME *)ellFirst(&plag->list); - while(plagname) { - if(strcmp(pasgClient->location,plagname->location)==0) - goto check_calc; - plagname = (LAGNAME *)ellNext((ELLNODE *)plagname); + pasglag = (ASGLAG *)ellFirst(&pasglevel->lagList); + while(pasglag) { + if(plag = pasglag->plag) { + plagname = (LAGNAME *)ellFirst(&plag->list); + while(plagname) { + if(strcmp(pasgClient->location,plagname->location)==0) + goto check_calc; + plagname = (LAGNAME *)ellNext((ELLNODE *)plagname); + } } + pasglag = (ASGLAG *)ellNext((ELLNODE *)pasglag); } - pasglag = (ASGLAG *)ellNext((ELLNODE *)pasglag); + goto next_level; } - goto next_level; - } check_calc: - if(!pasglevel->calc) { - access = pasglevel->access; - goto next_level; - } - status = calcPerform(pasg->pavalue,&result,pasglevel->rpcl); - if(!status && result==1e0) access = pasglevel->access; + if(!pasglevel->calc) { + access = pasglevel->access; + goto next_level; + } else {/*If any INP used in calc is bad NO_ACCESS*/ + if(pasg->inpBad & pasglevel->inpUsed) goto next_level; + } + status = calcPerform(pasg->pavalue,&result,pasglevel->rpcl); + if(!status && result==1e0) access = pasglevel->access; next_level: - pasglevel = (ASGLEVEL *)ellNext((ELLNODE *)pasglevel); + pasglevel = (ASGLEVEL *)ellNext((ELLNODE *)pasglevel); + } + /*Also check DEFAULT*/ + if(access == asWRITE) break; + if(strcmp(pasg->name,DEFAULT)==0) break; + pasg = (ASG *)ellFirst(&pasbase->asgList); + while(pasg) { + if(strcmp(pasg->name,DEFAULT)==0) goto again; + pasg = (ASG *)ellNext((ELLNODE *)pasg); + } + errMessage(-1,"Logic Error in asCompute"); + break; +again: + continue; } pasgClient->access = access; return(0); @@ -353,7 +443,8 @@ next_level: static char *asAccessName[] = {"NONE","READ","WRITE"}; int asDump( void (*memcallback)(struct asgMember *), - void (*clientcallback)(struct asgClient *)) + void (*clientcallback)(struct asgClient *), + int verbose) { UAG *puag; UAGNAME *puagname; @@ -410,7 +501,16 @@ int asDump( print_end_brace = FALSE; } while(pasginp) { - printf("\tINP%c(%s)\n",(pasginp->inpIndex + 'A'),pasginp->inp); + int bad; + double value; + + printf("\tINP%c(%s)",(pasginp->inpIndex + 'A'),pasginp->inp); + if(verbose) { + value = pasg->pavalue[pasginp->inpIndex]; + bad = (pasg->inpBad & (1<inpIndex)) ? 1 : 0; + printf(" Bad=%d value=%f",bad,value); + } + printf("\n"); pasginp = (ASGINP *)ellNext((ELLNODE *)pasginp); } while(pasglevel) { @@ -469,7 +569,176 @@ int asDump( } return(0); } + +int asDumpUag(char *uagname) +{ + UAG *puag; + UAGNAME *puagname; + if(!asActive) return(0); + puag = (UAG *)ellFirst(&pasbase->uagList); + if(!puag) printf("No UAGs\n"); + while(puag) { + if(uagname && strcmp(uagname,puag->name)!=0) { + puag = (UAG *)ellNext((ELLNODE *)puag); + continue; + } + printf("UAG(%s)",puag->name); + puagname = (UAGNAME *)ellFirst(&puag->list); + if(puagname) printf(" {"); else printf("\n"); + while(puagname) { + printf("%s",puagname->user); + puagname = (UAGNAME *)ellNext((ELLNODE *)puagname); + if(puagname) printf(","); else printf("}\n"); + } + puag = (UAG *)ellNext((ELLNODE *)puag); + } + return(0); +} + +int asDumpLag(char *lagname) +{ + LAG *plag; + LAGNAME *plagname; + + if(!asActive) return(0); + plag = (LAG *)ellFirst(&pasbase->lagList); + if(!plag) printf("No LAGs\n"); + while(plag) { + if(lagname && strcmp(lagname,plag->name)!=0) { + plag = (LAG *)ellNext((ELLNODE *)plag); + continue; + } + printf("LAG(%s)",plag->name); + plagname = (LAGNAME *)ellFirst(&plag->list); + if(plagname) printf(" {"); else printf("\n"); + while(plagname) { + printf("%s",plagname->location); + plagname = (LAGNAME *)ellNext((ELLNODE *)plagname); + if(plagname) printf(","); else printf("}\n"); + } + plag = (LAG *)ellNext((ELLNODE *)plag); + } + return(0); +} + +int asDumpLev(char *asgname) +{ + ASG *pasg; + ASGINP *pasginp; + ASGLEVEL *pasglevel; + ASGLAG *pasglag; + ASGUAG *pasguag; + + if(!asActive) return(0); + pasg = (ASG *)ellFirst(&pasbase->asgList); + if(!pasg) printf("No ASGs\n"); + while(pasg) { + int print_end_brace; + + if(asgname && strcmp(asgname,pasg->name)!=0) { + pasg = (ASG *)ellNext((ELLNODE *)pasg); + continue; + } + printf("ASG(%s)",pasg->name); + pasginp = (ASGINP *)ellFirst(&pasg->inpList); + pasglevel = (ASGLEVEL *)ellFirst(&pasg->levelList); + if(pasginp || pasglevel) { + printf(" {\n"); + print_end_brace = TRUE; + } else { + printf("\n"); + print_end_brace = FALSE; + } + while(pasginp) { + int bad; + double value; + + printf("\tINP%c(%s)",(pasginp->inpIndex + 'A'),pasginp->inp); + value = pasg->pavalue[pasginp->inpIndex]; + bad = (pasg->inpBad & (1<inpIndex)) ? 1 : 0; + printf(" Bad=%d value=%f",bad,value); + printf("\n"); + pasginp = (ASGINP *)ellNext((ELLNODE *)pasginp); + } + while(pasglevel) { + int print_end_brace; + + printf("\tLEVEL(%d,%s)", + pasglevel->level,asAccessName[pasglevel->access]); + pasguag = (ASGUAG *)ellFirst(&pasglevel->uagList); + pasglag = (ASGLAG *)ellFirst(&pasglevel->lagList); + if(pasguag || pasglag || pasglevel->calc) { + printf(" {\n"); + print_end_brace = TRUE; + } else { + printf("\n"); + print_end_brace = FALSE; + } + if(pasguag) printf("\t\tUAG("); + while(pasguag) { + printf("%s",pasguag->puag->name); + pasguag = (ASGUAG *)ellNext((ELLNODE *)pasguag); + if(pasguag) printf(","); else printf(")\n"); + } + pasglag = (ASGLAG *)ellFirst(&pasglevel->lagList); + if(pasglag) printf("\t\tLAG("); + while(pasglag) { + printf("%s",pasglag->plag->name); + pasglag = (ASGLAG *)ellNext((ELLNODE *)pasglag); + if(pasglag) printf(","); else printf(")\n"); + } + if(pasglevel->calc) printf("\t\tCALC(\"%s\")\n",pasglevel->calc); + if(print_end_brace) printf("\t}\n"); + pasglevel = (ASGLEVEL *)ellNext((ELLNODE *)pasglevel); + } + if(print_end_brace) printf("}\n"); + pasg = (ASG *)ellNext((ELLNODE *)pasg); + } + return(0); +} + +int asDumpMem(char *asgname,void (*memcallback)(ASMEMBERPVT),int clients) +{ + ASG *pasg; + ASGINP *pasginp; + ASGMEMBER *pasgmember; + ASGCLIENT *pasgclient; + + if(!asActive) return(0); + pasg = (ASG *)ellFirst(&pasbase->asgList); + if(!pasg) printf("No ASGs\n"); + while(pasg) { + + if(asgname && strcmp(asgname,pasg->name)!=0) { + pasg = (ASG *)ellNext((ELLNODE *)pasg); + continue; + } + printf("ASG(%s)\n",pasg->name); + pasgmember = (ASGMEMBER *)ellFirst(&pasg->memberList); + if(pasgmember) printf("\tMEMBERLIST\n"); + while(pasgmember) { + if(strlen(pasgmember->asgName)==0) + printf("\t\t"); + else + printf("\t\t%s",pasgmember->asgName); + if(memcallback) memcallback(pasgmember); + printf("\n"); + pasgclient = (ASGCLIENT *)ellFirst(&pasgmember->clientList); + if(!clients) pasgclient = NULL; + while(pasgclient) { + printf("\t\t\t %s %s %d %d", + pasgclient->user,pasgclient->location, + pasgclient->level,pasgclient->access); + printf("\n"); + pasgclient = (ASGCLIENT *)ellNext((ELLNODE *)pasgclient); + } + pasgmember = (ASGMEMBER *)ellNext((ELLNODE *)pasgmember); + } + pasg = (ASG *)ellNext((ELLNODE *)pasg); + } + return(0); +} /*Start of private routines*/ void * asCalloc(size_t nobj,size_t size) @@ -565,14 +834,16 @@ static void asFreeAll(ASBASE *pasbase) free((void *)pasg); pasg = pnext; } + free((void *)pasbase); } static UAG *asUagAdd(char *uagName) { - UAG *pprev; - UAG *pnext; - UAG *puag; - int cmpvalue; + UAG *pprev; + UAG *pnext; + UAG *puag; + int cmpvalue; + ASBASE *pbase = (ASBASE *)pasbase; /*Insert in alphabetic order*/ pnext = (UAG *)ellFirst(&pasbase->uagList); @@ -590,10 +861,10 @@ static UAG *asUagAdd(char *uagName) puag->name = (char *)(puag+1); strcpy(puag->name,uagName); if(pnext==NULL) { /*Add to end of list*/ - ellAdd(&pasbase->uagList,(ELLNODE *)puag); + ellAdd(&pbase->uagList,(ELLNODE *)puag); } else { pprev = (UAG *)ellPrevious((ELLNODE *)pnext); - ellInsert(&pasbase->uagList,(ELLNODE *)pprev,(ELLNODE *)puag); + ellInsert(&pbase->uagList,(ELLNODE *)pprev,(ELLNODE *)puag); } return(puag); } @@ -612,10 +883,11 @@ static long asUagAddUser(UAG *puag,char *user) static LAG *asLagAdd(char *lagName) { - LAG *pprev; - LAG *pnext; - LAG *plag; - int cmpvalue; + LAG *pprev; + LAG *pnext; + LAG *plag; + int cmpvalue; + ASBASE *pbase = (ASBASE *)pasbase; /*Insert in alphabetic order*/ pnext = (LAG *)ellFirst(&pasbase->lagList); @@ -633,10 +905,10 @@ static LAG *asLagAdd(char *lagName) plag->name = (char *)(plag+1); strcpy(plag->name,lagName); if(pnext==NULL) { /*Add to end of list*/ - ellAdd(&pasbase->lagList,(ELLNODE *)plag); + ellAdd(&pbase->lagList,(ELLNODE *)plag); } else { pprev = (LAG *)ellPrevious((ELLNODE *)pnext); - ellInsert(&pasbase->lagList,(ELLNODE *)pprev,(ELLNODE *)plag); + ellInsert(&pbase->lagList,(ELLNODE *)pprev,(ELLNODE *)plag); } return(plag); } @@ -655,10 +927,11 @@ static long asLagAddLocation(LAG *plag,char *location) static ASG *asAsgAdd(char *asgName) { - ASG *pprev; - ASG *pnext; - ASG *pasg; - int cmpvalue; + ASG *pprev; + ASG *pnext; + ASG *pasg; + int cmpvalue; + ASBASE *pbase = (ASBASE *)pasbase; /*Insert in alphabetic order*/ pnext = (ASG *)ellFirst(&pasbase->asgList); @@ -683,10 +956,10 @@ static ASG *asAsgAdd(char *asgName) pasg->name = (char *)(pasg+1); strcpy(pasg->name,asgName); if(pnext==NULL) { /*Add to end of list*/ - ellAdd(&pasbase->asgList,(ELLNODE *)pasg); + ellAdd(&pbase->asgList,(ELLNODE *)pasg); } else { pprev = (ASG *)ellPrevious((ELLNODE *)pnext); - ellInsert(&pasbase->asgList,(ELLNODE *)pprev,(ELLNODE *)pasg); + ellInsert(&pbase->asgList,(ELLNODE *)pprev,(ELLNODE *)pasg); } return(pasg); } @@ -772,14 +1045,12 @@ static long asAsgLevelCalc(ASGLEVEL *pasglevel,char *calc) pasglevel->calc = NULL; pasglevel->rpcl = NULL; status = S_asLib_badCalc; + } else { + int i; + + for(i=0; iinpUsed |= (1<=\$] static ASINPUTFUNCPTR *my_yyinput; #undef YY_INPUT #define YY_INPUT(b,r,ms) (r=(*my_yyinput)(b,ms)) + +yyreset() +{ + line_num=1; + BEGIN INITIAL; + return(0); +} + %} %% diff --git a/src/as/ascheck.c b/src/as/ascheck.c index 68e6d1759..4cd6038ab 100644 --- a/src/as/ascheck.c +++ b/src/as/ascheck.c @@ -1,5 +1,6 @@ /* share/src/as/ascheck.c */ /* share/src/as $Id$ */ +/* Author: Marty Kraimer Date: 03-24-94 */ /***************************************************************** COPYRIGHT NOTIFICATION *****************************************************************