(file) Return to thHandlers.c CVS log (file) (dir) Up to [HallC] / Analyzer / CTP

  1 saw   1.1 /*-----------------------------------------------------------------------------
  2            * Copyright (c) 1993 Southeastern Universities Research Association,
  3            *                    Continuous Electron Beam Accelerator Facility
  4            *
  5            * This software was developed under a United States Government license
  6            * described in the NOTICE file included as part of this distribution.
  7            *
  8            * Stephen A. Wood, 12000 Jefferson Ave., Newport News, VA 23606
  9            * Email: saw@cebaf.gov  Tel: (804) 249-7367  Fax: (804) 249-5800
 10            *-----------------------------------------------------------------------------
 11            * 
 12            * Description:
 13            *  Special test and histogram handlers for RPC services.
 14            *	
 15            * Author:  Stephen Wood, CEBAF Hall C
 16            *
 17            * Revision History:
 18            *   $Log: thHandlers.c,v $
 19 saw   1.2  *   Revision 1.7  1999/08/25 13:16:06  saw
 20            *   *** empty log message ***
 21            *
 22            *   Revision 1.6  1999/07/07 13:43:58  saw
 23            *   Move thTestRHandler() into thTestParse.c
 24            *
 25            *   Revision 1.5  1996/08/01 01:31:56  saw
 26            *   Have thRHandler return a status
 27 saw   1.1  *
 28            *	  Revision 1.4  1995/01/09  15:41:11  saw
 29            *	  Change "linux" ifdef's to NOHBOOK.
 30            *
 31            *	  Revision 1.3  1994/10/16  21:42:21  saw
 32            *	  Change an include file name from daVarServ.h daVarHandlers.h
 33            *
 34            *	  Revision 1.2  1993/08/12  14:57:39  saw
 35            *	  Add #include <rpc/rpc.h>
 36            *
 37            *	  Revision 1.1  1993/05/10  21:06:46  saw
 38            *	  Initial revision
 39            *
 40            */
 41           #include <string.h>
 42           #include <rpc/rpc.h>
 43           
 44           #include "daVar.h"
 45           #include "daVarRpc.h"
 46           #include "daVarHandlers.h"
 47           #include "th.h"
 48 saw   1.1 #include "thInternal.h"
 49           
 50           #ifndef NOHBOOK
 51           #include "hbook.h"
 52           #endif
 53           
 54           int thLastIdRhandled;
 55           
 56           daVarStatus thWHandler(char *name,daVarStruct *varclass,any *setval)
 57           /* The write handler used by block.test, block.hist and block.parm */
 58           {
 59             daVarStruct *varp;
 60             char *attribute;
 61             daVarStatus status;
 62             int index;
 63           
 64             status = daVarAttributeFind(name, varclass, &varp, &attribute, &index);
 65             if(status == S_SUCCESS) {
 66               status = daVarRegWatr(varp, attribute, index, setval);
 67               if(strcasecmp(attribute,DAVAR_TITLE) == 0 && status == S_SUCCESS){
 68                 status = ((daVarStatus (*)()) varclass->opaque)(varp);
 69 saw   1.1     }
 70             }
 71             return(status);
 72           }
 73           daVarStatus thRHandler(char *name, daVarStruct *varclass, any *retval)
 74           /* The default Read handler */
 75           {
 76             daVarStruct *varp;
 77             char *attribute;
 78             daVarStatus status;
 79             int index;
 80           
 81             status = daVarAttributeFind(name, varclass, &varp, &attribute, &index);
 82             status = daVarRegRatr(varp, attribute, index, retval);
 83             /* scaler attribute a synonym for the value which holds the block counter */
 84             if(status == S_SUCCESS) {
 85               if(strcasecmp(attribute,DAVAR_RATR) == 0){
 86                 retval->any_u.s = realloc(retval->any_u.s,strlen(retval->any_u.s)
 87           				+strlen(TH_SCALER) + 2);
 88                 strcat(retval->any_u.s,TH_SCALER);
 89                 strcat(retval->any_u.s,"\n");
 90 saw   1.1     }
 91             } else {
 92               if(strcasecmp(attribute,TH_SCALER) == 0){
 93                 retval->valtype = DAVARINT_RPC;
 94                 retval->any_u.i.i_len = 1;
 95                 retval->any_u.i.i_val = (int *) malloc(sizeof(int));
 96                 retval->any_u.i.i_val[0] = ((DAINT *)varp->varptr)[0];
 97               }
 98             }
 99             return(status);
100           }
101           
102           #ifndef NOHBOOK
103           void thHistZeroLastId()
104           {
105             thLastIdRhandled = 9999999;
106             return;
107           }
108           void thHistRHandler(char *name, daVarStruct *varclass, any *retval)
109 saw   1.2      /* Read Handler for Histograms */
110 saw   1.1 {
111             daVarStruct *varp;
112             char *attribute;
113             daVarStatus status;
114             int index;
115             static int NX,NY,NWT,LOC ; static float XMI,XMA,YMI,YMA;
116           /*  thHistOpaque *hopq;*/
117           
118             status = daVarAttributeFind(name, varclass, &varp, &attribute, &index);
119             status = daVarRegRatr(varp, attribute, index, retval);
120             if(status == S_SUCCESS) {
121               if(strcasecmp(attribute,DAVAR_RATR) == 0){
122                 retval->any_u.s = realloc(retval->any_u.s,strlen(retval->any_u.s)
123           				+ strlen(TH_ND) + strlen(TH_NX) 
124           				+ strlen(TH_NY) + strlen(TH_XMI)
125           				+ strlen(TH_XMA) + strlen(TH_YMI)
126           				+ strlen(TH_YMA) + strlen(TH_CONTEN) + 9);
127                 strcat(retval->any_u.s,TH_ND); strcat(retval->any_u.s,"\n");
128                 strcat(retval->any_u.s,TH_NX); strcat(retval->any_u.s,"\n");
129                 strcat(retval->any_u.s,TH_NY); strcat(retval->any_u.s,"\n");
130                 strcat(retval->any_u.s,TH_XMI); strcat(retval->any_u.s,"\n");
131 saw   1.1       strcat(retval->any_u.s,TH_XMA); strcat(retval->any_u.s,"\n");
132                 strcat(retval->any_u.s,TH_YMI); strcat(retval->any_u.s,"\n");
133                 strcat(retval->any_u.s,TH_YMA); strcat(retval->any_u.s,"\n");
134                 strcat(retval->any_u.s,TH_CONTEN); strcat(retval->any_u.s,"\n");
135               }
136             } else {
137               char chtitle[80];
138               
139               retval->valtype = DAVARERROR_RPC;
140               retval->any_u.error = S_DAVAR_UNKATTR;
141               if(thLastIdRhandled != *((DAINT *) varp->varptr)) {
142                 thLastIdRhandled = *((DAINT *) varp->varptr);
143                 HGIVE(*((DAINT *) varp->varptr),chtitle,NX,XMI,XMA,NY,YMI,YMA
144           	    ,NWT,LOC);
145               }
146               if(strcasecmp(attribute,TH_ND) == 0){
147                 retval->valtype = DAVARINT_RPC;
148                 retval->any_u.i.i_len = 1;
149                 retval->any_u.i.i_val = (int *) malloc(varp->size*sizeof(int));
150                 retval->any_u.i.i_val[0] = (NY == 0 ? 1 : 2);
151               } else if(strcasecmp(attribute,TH_NX) == 0){
152 saw   1.1       retval->valtype = DAVARINT_RPC;
153                 retval->any_u.i.i_len = 1;
154                 retval->any_u.i.i_val = (int *) malloc(varp->size*sizeof(int));
155                 retval->any_u.i.i_val[0] = NX;
156               } else if(strcasecmp(attribute,TH_NY) == 0){
157                 retval->valtype = DAVARINT_RPC;
158                 retval->any_u.i.i_len = 1;
159                 retval->any_u.i.i_val = (int *) malloc(varp->size*sizeof(int));
160                 retval->any_u.i.i_val[0] = NY;
161               } else if(strcasecmp(attribute,TH_XMI) == 0){
162                 retval->valtype = DAVARFLOAT_RPC;
163                 retval->any_u.r.r_len = 1;
164                 retval->any_u.r.r_val = (float *) malloc(varp->size*sizeof(float));
165                 retval->any_u.r.r_val[0] = XMI;
166               } else if(strcasecmp(attribute,TH_XMA) == 0){
167                 retval->valtype = DAVARFLOAT_RPC;
168                 retval->any_u.r.r_len = 1;
169                 retval->any_u.r.r_val = (float *) malloc(varp->size*sizeof(float));
170                 retval->any_u.r.r_val[0] = XMA;
171               } else if(strcasecmp(attribute,TH_YMI) == 0){
172                 retval->valtype = DAVARFLOAT_RPC;
173 saw   1.1       retval->any_u.r.r_len = 1;
174                 retval->any_u.r.r_val = (float *) malloc(varp->size*sizeof(float));
175                 retval->any_u.r.r_val[0] = YMI;
176               } else if(strcasecmp(attribute,TH_YMA) == 0){
177                 retval->valtype = DAVARFLOAT_RPC;
178                 retval->any_u.r.r_len = 1;
179                 retval->any_u.r.r_val = (float *) malloc(varp->size*sizeof(float));
180                 retval->any_u.r.r_val[0] = YMA;
181               } else if(strcasecmp(attribute,TH_CONTEN) == 0){
182                 int size;
183                 retval->valtype = DAVARFLOAT_RPC;
184                 size = NX;
185                 if(NY != 0) size *= NY;
186                 retval->any_u.r.r_len = size;
187                 retval->any_u.r.r_val = (float *)malloc(size*sizeof(float));
188                 HUNPAK(thLastIdRhandled,retval->any_u.r.r_val,"HIST",(int) 1);
189               }
190             }
191             return;
192 saw   1.2 }
193           #endif
194           #ifdef ROOTTREE
195           void thTreeRHandler(char *name, daVarStruct *varclass, any *retval)
196           /* The default Read handler */
197           {
198             return(thRHandler(name, varclass, retval));
199 saw   1.1 }
200           #endif

Analyzer/Replay: Mark Jones, Documents: Stephen Wood
Powered by
ViewCVS 0.9.2-cvsgraph-1.4.0