Rev 11104 | Rev 13573 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 11104 | Rev 12246 | ||
---|---|---|---|
Line 49... | Line 49... | ||
49 | "version", |
49 | "version", |
50 | }; |
50 | }; |
51 | int exportvarcnt=(sizeof(exportvars)/sizeof(exportvars[0])); |
51 | int exportvarcnt=(sizeof(exportvars)/sizeof(exportvars[0])); |
52 | 52 | ||
53 | struct vartab { |
53 | struct vartab { |
54 |
|
54 | char *name, *val; |
55 |
|
55 | unsigned short int vlen; |
56 |
|
56 | char tag,lvl; |
57 | } fastvartab[128], mainvartab[VARNUM_LIMIT]; |
57 | } fastvartab[128], mainvartab[VARNUM_LIMIT]; |
58 | 58 | ||
59 | /* int vlenmin[]={0,1,20,45,100,200,400,800,1500,3000,6000}; */ |
59 | /* int vlenmin[]={0,1,20,45,100,200,400,800,1500,3000,6000}; */ |
60 | int vlenmax[]={1,32,64,128, 256,512,1024,2048, 4096,8192,MAX_LINELEN+1}; |
60 | int vlenmax[]={1,32,64,128, 256,512,1024,2048, 4096,8192,MAX_LINELEN+1}; |
61 | int freelim[]={1,500,500,300, 200,150,100,80, 60,50,30}; |
61 | int freelim[]={1,500,500,300, 200,150,100,80, 60,50,30}; |
Line 68... | Line 68... | ||
68 | int mainvarcnt=0; |
68 | int mainvarcnt=0; |
69 | void add_hack(char *name); |
69 | void add_hack(char *name); |
70 | 70 | ||
71 | void get_var_privileges(void) |
71 | void get_var_privileges(void) |
72 | { |
72 | { |
73 |
|
73 | int sav=untrust; |
74 |
|
74 | untrust=0; |
75 |
|
75 | var_readable=getvar("wims_readable"); |
76 |
|
76 | var_writable=getvar("wims_writable"); |
77 |
|
77 | var_nr=getvar("wims_nr"); |
78 |
|
78 | var_nw=getvar("wims_nw"); |
79 |
|
79 | var_pfx=getvar("wims_prefix"); |
80 |
|
80 | untrust=sav; |
81 | } |
81 | } |
82 | 82 | ||
83 | /* Returns 1 if rights OK. Else 0. */ |
83 | /* Returns 1 if rights OK. Else 0. */ |
84 | int var_checkright(char *name, char *allow, char *deny, char *prefix) |
84 | int var_checkright(char *name, char *allow, char *deny, char *prefix) |
85 | { |
85 | { |
86 |
|
86 | if(strcmp(name,"wims_read_parm")==0) return 1; |
87 |
|
87 | if(allow!=NULL && allow[0]!=0 && wordchr(allow,name)!=NULL) return 1; |
88 |
|
88 | if(deny!=NULL && deny[0]!=0 && wordchr(deny,name)!=NULL) return 0; |
89 |
|
89 | if(prefix!=NULL && prefix[0]!=0) { |
90 |
|
90 | char *p, buf[MAX_NAMELEN+1]; |
91 |
|
91 | for(p=name; *p!=0 && *p!='_'; p++); |
92 |
|
92 | if(*p!='_' || p-name>=MAX_NAMELEN) return 0; |
93 |
|
93 | memmove(buf,name,p-name); buf[p-name]=0; |
94 |
|
94 | if(wordchr(prefix,buf)==NULL) return 0; |
95 |
|
95 | } |
96 |
|
96 | return 1; |
97 | } |
97 | } |
98 | 98 | ||
99 | /* initialisation */ |
99 | /* initialisation */ |
100 | void var_init(void) |
100 | void var_init(void) |
101 | { |
101 | { |
102 |
|
102 | int i,j; |
103 |
|
103 | memset(freevars,0,sizeof(freevars)); |
104 |
|
104 | _varbufcurr=0; |
105 |
|
105 | _varbuf[0]=xmalloc(VARBUF_LEN); |
106 |
|
106 | _varnamebuf=xmalloc(VARNAME_LEN); |
107 |
|
107 | _varptr=_varbuf[0]; _varnameptr=_varnamebuf; |
108 |
|
108 | for(i=j=0;i<lvlno;i++) {freevstart[i]=j; j+=freelim[i];} |
109 |
|
109 | if(j!=freevtot) internal_error("var.c: wrong count freevtot!"); |
110 | } |
110 | } |
- | 111 | ||
- | 112 | void exportall(void) |
|
- | 113 | { |
|
- | 114 | int i, j, tag; char buf[MAX_NAMELEN+17]; |
|
- | 115 | char *p, *p1, *p2; |
|
- | 116 | char *noexpword[1024]; |
|
- | 117 | int noexplen[1024]; |
|
- | 118 | int noexpcnt; |
|
111 | 119 | ||
112 | void exportall(void) |
- | |
113 | { |
- | |
114 | int i, j, tag; char buf[MAX_NAMELEN+17]; |
- | |
115 | char *p, *p1, *p2; |
- | |
116 | char *noexpword[1024]; |
- | |
117 | int noexplen[1024]; |
- | |
118 | int noexpcnt; |
- | |
119 | - | ||
120 |
|
120 | noexpcnt=0; |
121 |
|
121 | p=getvar("wims_noexport"); if(p==NULL) p=""; |
122 |
|
122 | for(p1=find_word_start(p),noexpcnt=0; |
123 | *p1 && noexpcnt<1024; |
123 | *p1 && noexpcnt<1024; |
124 | p1=find_word_start(p2)) { |
124 | p1=find_word_start(p2)) { |
125 |
|
125 | p2=find_word_end(p1); |
126 |
|
126 | noexpword[noexpcnt]=p1; noexplen[noexpcnt]=p2-p1; |
127 |
|
127 | noexpcnt++; |
128 |
|
128 | } |
129 |
|
129 | for(i=0;i<mainvarcnt;i++) { |
130 |
|
130 | tag=mainvartab[i].tag; |
131 |
|
131 | if((tag&vb_dirty)==0 || (tag&vb_noexport)!=0) continue; |
132 |
|
132 | p=mainvartab[i].name; |
133 |
|
133 | for(j=0;j<noexpcnt;j++) if(strncmp(p,noexpword[j],noexplen[j])==0) { |
134 |
|
134 | mainvartab[i].tag|=vb_noexport; |
135 |
|
135 | goto lend; |
136 |
|
136 | } |
137 |
|
137 | if(mainvartab[i].tag&vb_hacked) { |
138 |
|
138 | add_hack(p); mainvartab[i].tag&=~vb_hacked; |
139 |
|
139 | } |
140 |
|
140 | snprintf(buf,sizeof(buf),"%s%s",var_prefix,p); |
141 |
|
141 | setenv(buf,mainvartab[i].val,1); |
142 |
|
142 | mainvartab[i].tag&=~vb_dirty; |
143 | lend: ; |
143 | lend: ; |
144 |
|
144 | } |
145 | } |
145 | } |
146 | 146 | ||
147 | char *vaskbuf(int lvl) |
147 | char *vaskbuf(int lvl) |
148 | { |
148 | { |
149 |
|
149 | char *p; |
150 |
|
150 | if(lvl>=lvlno) { /* should never occur */ |
151 |
|
151 | module_error("Internal_variable_length_overflow"); return NULL; |
- | 152 | } |
|
- | 153 | if(freevars[lvl]>0) { |
|
- | 154 | freevars[lvl]--; freevcnt--; |
|
- | 155 | return freevbuf[freevstart[lvl]+freevars[lvl]]; |
|
- | 156 | } |
|
- | 157 | if(_varptr+vlenmax[lvl]>=_varbuf[_varbufcurr]+VARBUF_LEN) { |
|
- | 158 | if(_varbufcurr>=VARBUF_NUM) { |
|
- | 159 | module_error("variable_buffer_overflow"); return NULL; |
|
152 | } |
160 | } |
153 | if(freevars[lvl]>0) { |
- | |
154 | freevars[lvl]--; freevcnt--; |
- | |
155 | return freevbuf[freevstart[lvl]+freevars[lvl]]; |
- | |
156 | } |
- | |
157 | if(_varptr+vlenmax[lvl]>=_varbuf[_varbufcurr]+VARBUF_LEN) { |
- | |
158 | if(_varbufcurr>=VARBUF_NUM) { |
- | |
159 | module_error("variable_buffer_overflow"); return NULL; |
- | |
160 | } |
- | |
161 |
|
161 | _varbufcurr++; _varptr=_varbuf[_varbufcurr]=xmalloc(VARBUF_LEN); |
162 |
|
162 | } |
163 |
|
163 | bufvcnt++; |
164 |
|
164 | p=_varptr; _varptr+=vlenmax[lvl]; return p; |
165 | } |
165 | } |
166 | 166 | ||
167 | /* returns 1 if free succeeded. */ |
167 | /* returns 1 if free succeeded. */ |
168 | int vfreebuf(int lvl, char *p) |
168 | int vfreebuf(int lvl, char *p) |
169 | { |
169 | { |
170 |
|
170 | if(p>=_varptr) return 0; |
171 |
|
171 | if(p+vlenmax[lvl]==_varptr) {_varptr=p; bufvcnt--;return 1;} |
172 |
|
172 | if(lvl<=0 || lvl>=lvlno || freevars[lvl]>=freelim[lvl]) return 0; |
173 |
|
173 | freevcnt++; |
174 |
|
174 | freevbuf[freevstart[lvl]+freevars[lvl]]=p; freevars[lvl]++; return 1; |
175 | } |
175 | } |
176 | 176 | ||
177 | int _char_int(char *vn) |
177 | int _char_int(char *vn) |
178 | { |
178 | { |
179 |
|
179 | int t; char v; |
180 |
|
180 | v=vn[0]; if(vn[1]) t=64; else t=0; |
181 |
|
181 | if(v>='0' && v<='9') return v-'0'+t; |
- | 182 | else { |
|
- | 183 | if(v>='A' && v<='Z') return v-'A'+10+t; |
|
182 | else { |
184 | else { |
183 | if(v>='A' && v<='Z') return v-'A'+10+t; |
- | |
184 | else { |
- | |
185 |
|
185 | if(v>='a' && v<='z') return v-'a'+10+26+t; |
186 |
|
186 | else return -1; |
187 |
|
187 | } |
188 |
|
188 | } |
189 | } |
189 | } |
190 | 190 | ||
191 | int var_ins(char *name,int inspoint) |
191 | int var_ins(char *name,int inspoint) |
192 | { |
192 | { |
193 |
|
193 | int i, nlen, tag; |
194 |
|
194 | if(mainvarcnt>=VARNUM_LIMIT) { |
195 |
|
195 | module_error("too_many_variable_names"); return -1; |
196 |
|
196 | } |
197 |
|
197 | for(nlen=0;nlen<=MAX_NAMELEN && (myisalnum(name[nlen]) || name[nlen]=='_');nlen++); |
198 |
|
198 | if(nlen<=1 || nlen>MAX_NAMELEN || name[nlen]!=0) return -1; |
199 |
|
199 | if(_varnameptr+nlen+1>_varnamebuf+VARNAME_LEN) { |
200 |
|
200 | module_error("variable_name_buffer_overflow"); return -1; |
201 |
|
201 | } |
202 |
|
202 | tag=0; |
203 |
|
203 | if(search_list(ro_name,RO_NAME_NO,sizeof(ro_name[0]),name)>=0) |
204 |
|
204 | tag|=vb_ro; |
205 |
|
205 | if(nlen<=2 || strncmp(name,mathfont_prefix,strlen(mathfont_prefix))==0 || |
206 |
|
206 | name[nlen-1]=='_') |
- | 207 | tag|=vb_noexport; |
|
- | 208 | if(var_noexport) tag|=vb_noexport; |
|
- | 209 | if(name[0]=='w' && strncmp(name,wims_prefix,wpflen)==0) { |
|
- | 210 | if(search_list(exportvars,exportvarcnt,sizeof(exportvars[0]),name+wpflen)<0) |
|
207 | tag|=vb_noexport; |
211 | tag|=vb_noexport; |
208 | if(var_noexport) tag|=vb_noexport; |
- | |
209 | if(name[0]=='w' && strncmp(name,wims_prefix,wpflen)==0) { |
- | |
210 | if(search_list(exportvars,exportvarcnt,sizeof(exportvars[0]),name+wpflen)<0) |
- | |
211 | tag|=vb_noexport; |
- | |
212 |
|
212 | if(strncmp(name+wpflen,"priv_",strlen("priv_"))==0 || |
213 | search_list(internal_name,INTERNAL_NAME_NO,sizeof(internal_name[0]),name+wpflen)>=0) |
213 | search_list(internal_name,INTERNAL_NAME_NO,sizeof(internal_name[0]),name+wpflen)>=0) |
214 |
|
214 | tag|=vb_internal; |
215 |
|
215 | } |
216 |
|
216 | i=inspoint; if(i>mainvarcnt) i=mainvarcnt; if(i<0) i=0; |
217 |
|
217 | memmove(mainvartab+i+1,mainvartab+i,(mainvarcnt-i)*sizeof(mainvartab[0])); |
218 |
|
218 | mainvarcnt++; nlen++; |
219 |
|
219 | memmove(_varnameptr,name,nlen); |
220 |
|
220 | mainvartab[i].name=_varnameptr; _varnameptr+=nlen; |
221 |
|
221 | mainvartab[i].val=NULL; mainvartab[i].vlen=0; |
222 |
|
222 | mainvartab[i].tag=tag; |
223 |
|
223 | mainvartab[i].lvl=0; return i; |
224 | } |
224 | } |
225 | 225 | ||
226 | char *fast_getvar(char *vname) |
226 | char *fast_getvar(char *vname) |
227 | { |
227 | { |
228 |
|
228 | int n; |
229 | 229 | ||
230 |
|
230 | n=_char_int(vname); if(n<0) return ""; |
231 |
|
231 | if(fastvartab[n].tag&vb_hacked) { |
232 |
|
232 | add_hack(vname); fastvartab[n].tag&=~vb_hacked; |
233 |
|
233 | } |
234 |
|
234 | getvar_len=fastvartab[n].vlen; |
235 |
|
235 | return fastvartab[n].val; |
236 | } |
236 | } |
237 | 237 | ||
238 | int _setvar_(struct vartab *vtb, char *vval) |
238 | int _setvar_(struct vartab *vtb, char *vval) |
239 | { |
239 | { |
240 |
|
240 | int l,lvl; |
241 |
|
241 | char *p; |
242 |
|
242 | if(vval) l=strlen(vval); else l=0; |
243 |
|
243 | if(l>MAX_LINELEN) return 1; |
244 |
|
244 | lvl=vtb->lvl; |
245 |
|
245 | if(l==0) { |
246 |
|
246 | if(lvl>0) { |
247 |
|
247 | vfreebuf(lvl,vtb->val); vtb->tag|=vb_dirty; |
248 |
|
248 | if(var_hacking) vtb->tag|=vb_hacked; else vtb->tag&=~vb_hacked; |
249 |
|
249 | vtb->lvl=0; vtb->vlen=0; |
250 | } |
- | |
251 | if(vval) vtb->val=""; else vtb->val=NULL; |
- | |
252 | return 0; |
- | |
253 | } |
- | |
254 | if(l>=vlenmax[lvl]) { |
- | |
255 | vfreebuf(lvl,vtb->val); |
- | |
256 | do lvl++; while(l>=vlenmax[lvl]); |
- | |
257 | vtb->lvl=lvl; |
- | |
258 | vtb->val=p=vaskbuf(lvl); |
- | |
259 | } |
250 | } |
- | 251 | if(vval) vtb->val=""; else vtb->val=NULL; |
|
- | 252 | return 0; |
|
- | 253 | } |
|
- | 254 | if(l>=vlenmax[lvl]) { |
|
- | 255 | vfreebuf(lvl,vtb->val); |
|
- | 256 | do lvl++; while(l>=vlenmax[lvl]); |
|
- | 257 | vtb->lvl=lvl; |
|
- | 258 | vtb->val=p=vaskbuf(lvl); |
|
- | 259 | } |
|
260 |
|
260 | else p=vtb->val; |
261 |
|
261 | vtb->vlen=l; vtb->tag|=vb_dirty; |
262 |
|
262 | if(var_hacking) vtb->tag|=vb_hacked; else vtb->tag&=~vb_hacked; |
263 |
|
263 | memmove(p,vval,++l); return 0; |
264 | } |
264 | } |
265 | 265 | ||
266 | int fast_setvar(char *vname, char *vval) |
266 | int fast_setvar(char *vname, char *vval) |
267 | { |
267 | { |
268 |
|
268 | int n; |
269 | 269 | ||
270 |
|
270 | n=_char_int(vname); if(n<0) return 1; |
271 |
|
271 | return _setvar_(fastvartab+n,vval); |
272 | } |
272 | } |
273 | 273 | ||
274 | /* internal constant */ |
274 | /* internal constant */ |
275 | int setvar_force=0; |
275 | int setvar_force=0; |
276 | 276 | ||
277 | /* Set a user variable. Now it no longer uses environment. |
277 | /* Set a user variable. Now it no longer uses environment. |
278 | * Returns 0 if OK. */ |
278 | * Returns 0 if OK. */ |
279 | int setvar(char *vname, char *vvalue) |
279 | int setvar(char *vname, char *vvalue) |
280 | { |
280 | { |
281 |
|
281 | int i,overwrite,tag; |
282 | 282 | ||
283 |
|
283 | if(vname[0]==0) return 1; |
284 |
|
284 | if((vname[1]==0 || (vname[1]=='_' && vname[2]==0))) |
285 |
|
285 | return fast_setvar(vname,vvalue); |
286 |
|
286 | i=search_list(mainvartab,mainvarcnt,sizeof(mainvartab[0]),vname); |
287 |
|
287 | if(i<0) i=var_ins(vname,~i); |
288 |
|
288 | if(i<0) return 1; /* error */ |
289 |
|
289 | overwrite=1; tag=mainvartab[i].tag; |
290 |
|
290 | if(setvar_force==0 && confset==0) { |
291 | /* user file has no right to modify wims variables. */ |
291 | /* user file has no right to modify wims variables. */ |
292 |
|
292 | if((untrust&6)!=0) { |
293 |
|
293 | if(var_checkright(vname,var_writable,var_nw,var_pfx)==0) |
294 |
|
294 | return 1; |
295 |
|
295 | if(strncmp(vname,wims_prefix,wpflen)==0 && |
296 |
|
296 | strcmp(vname,"wims_read_parm")!=0) return 1; |
297 |
|
297 | } |
298 |
|
298 | if((tag&vb_ro)!=0) overwrite=0; |
299 |
|
299 | else if((tag&vb_internal)!=0 && !trusted_module()) return 1; |
300 |
|
300 | } |
301 |
|
301 | if(!overwrite && mainvartab[i].val!=NULL) return 1; |
302 |
|
302 | _setvar_(mainvartab+i,vvalue); |
303 |
|
303 | if(vname[0]=='w') { |
304 |
|
304 | if(strcmp(vname,"wims_print_precision")==0) { |
305 |
|
305 | int a=atoi(vvalue); |
306 |
|
306 | if(a>0 && a<100) print_precision=a; |
307 |
|
307 | } |
308 |
|
308 | if(strcmp(vname,"wims_backslash_insmath")==0) { |
309 |
|
309 | if(strcasecmp(vvalue,"yes")==0) backslash_insmath=1; |
310 |
|
310 | else backslash_insmath=0; |
311 |
|
311 | } |
312 |
|
312 | } |
313 |
|
313 | if (trace_file && wordchr(tmp_debug_var,vname)) { |
314 |
|
314 | fprintf(trace_file,"\n%s='%s'\n",vname,vvalue); |
315 |
|
315 | } |
316 |
|
316 | return 0; |
317 | } |
317 | } |
318 | 318 | ||
319 | int force_setvar(char *vname,char *vvalue) |
319 | int force_setvar(char *vname,char *vvalue) |
320 | { |
320 | { |
321 |
|
321 | int i; |
322 |
|
322 | setvar_force=1; i=setvar(vname,vvalue); setvar_force=0; return i; |
323 | } |
323 | } |
324 | 324 | ||
325 | void unsetvar(char *vname) |
325 | void unsetvar(char *vname) |
326 | { |
326 | { |
327 |
|
327 | int i; |
328 |
|
328 | if(vname[0]!=0 && (vname[1]==0 || (vname[1]=='_' && vname[2]==0))) { |
329 |
|
329 | fast_setvar(vname,NULL); return; |
330 |
|
330 | } |
331 |
|
331 | i=search_list(mainvartab,mainvarcnt,sizeof(mainvartab[0]),vname); |
332 |
|
332 | if(i>=0) _setvar_(mainvartab+i,NULL); |
333 | } |
333 | } |
334 | 334 | ||
335 | /* Get a variable's value. */ |
335 | /* Get a variable's value. */ |
336 | char *_getvar(char *vname) |
336 | char *_getvar(char *vname) |
337 | { |
337 | { |
338 |
|
338 | char *val; |
339 |
|
339 | int i; |
340 | 340 | ||
341 |
|
341 | if((untrust&4)!=0 || vname[0]==0) return ""; /* called from !readdef */ |
342 |
|
342 | if(vname[1]==0 || (vname[1]=='_' && vname[2]==0)) return fast_getvar(vname); |
343 |
|
343 | if((untrust&6)!=0) { |
344 |
|
344 | if(var_checkright(vname,var_readable,var_nr,var_pfx)==0) |
345 |
|
345 | return ""; |
346 |
|
346 | } |
347 |
|
347 | i=search_list(mainvartab,mainvarcnt,sizeof(mainvartab[0]),vname); |
348 |
|
348 | if(i<0) val=NULL; else { |
349 |
|
349 | if(mainvartab[i].tag&vb_hacked) { |
350 |
|
350 | add_hack(vname); mainvartab[i].tag&=~vb_hacked; |
351 |
|
351 | } |
352 |
|
352 | val=mainvartab[i].val; getvar_len=mainvartab[i].vlen; |
353 |
|
353 | } |
354 |
|
354 | if(vname[0]=='w' && strcmp(vname,"wims_incremental")==0) { |
355 |
|
355 | static char buf[32]; |
356 |
|
356 | if(val==NULL) i=0; |
357 |
|
357 | else i=atoi(val)+1; |
358 |
|
358 | mystrncpy(buf,int2str(i),sizeof(buf)); |
359 |
|
359 | force_setvar(vname,buf); getvar_len=strlen(buf); val=buf; |
360 |
|
360 | } |
361 |
|
361 | return val; |
362 | } |
362 | } |
363 | 363 | ||
364 | char *getvar(char *vname) |
364 | char *getvar(char *vname) |
365 | { |
365 | { |
366 |
|
366 | char *val; |
367 |
|
367 | getvar_len=0; val=_getvar(vname); |
368 |
|
368 | if(val==NULL && memcmp(vname,mathfont_prefix,strlen(mathfont_prefix))==0) {// mathfont_prefix m_ is add |
369 |
|
369 | val=mathfont(vname); |
370 |
|
370 | if(val) getvar_len=strlen(val); else getvar_len=0; |
371 |
|
371 | } |
372 |
|
372 | return val; |
373 | } |
373 | } |
374 | 374 | ||
375 | /* Search variables with numeric subscripts, from beg to end. |
375 | /* Search variables with numeric subscripts, from beg to end. |
376 | * Store result to pbuf. Returns number of variables found. |
376 | * Store result to pbuf. Returns number of variables found. |
377 | */ |
377 | */ |
378 | int varsuite(char *stem, int beg, int end, char *pbuf[], int pbuflen) |
378 | int varsuite(char *stem, int beg, int end, char *pbuf[], int pbuflen) |
379 | { |
379 | { |
380 |
|
380 | int i,t,l,v; |
381 |
|
381 | i=search_list(mainvartab,mainvarcnt,sizeof(mainvartab[0]),stem); |
382 |
|
382 | if(i<0) i=~i; |
383 |
|
383 | for(t=0,l=strlen(stem);i<mainvarcnt && t<pbuflen;i++){ |
384 |
|
384 | if(strncmp(mainvartab[i].name,stem,l)!=0) break; |
385 |
|
385 | v=atoi(mainvartab[i].name+l); if(v<beg || v>end) continue; |
386 |
|
386 | if(mainvartab[i].val==NULL || mainvartab[i].val[0]==0) continue; |
387 |
|
387 | pbuf[t++]=mainvartab[i].name; |
388 |
|
388 | } |
389 |
|
389 | return t; |
390 | } |
390 | } |
391 | 391 | ||
392 | /* output debug information */ |
392 | /* output debug information */ |
393 | void debug_output(void) |
393 | void debug_output(void) |
394 | { |
394 | { |
395 |
|
395 | long int endmtime2, time1; |
396 |
|
396 | struct timeval tv; |
397 |
|
397 | struct rusage us; |
398 | 398 | ||
399 |
|
399 | if(noout || robot_access || strcasecmp(tmp_debug,"yes")!=0 || |
400 |
|
400 | checkhost(manager_site)<1) return; |
401 |
|
401 | if(instex_cnt>0) instex_flush(); |
402 |
|
402 | if(gettimeofday(&tv,NULL)) endmtime2=0; |
403 |
|
403 | else endmtime2=((tv.tv_sec%1000)*1000000+tv.tv_usec); |
404 |
|
404 | endmtime2=(endmtime2-startmtime2)/100; |
405 |
|
405 | time1=0; |
406 |
|
406 | if(getrusage(RUSAGE_SELF,&us)==0) { |
407 |
|
407 | time1+=us.ru_utime.tv_sec*1000+us.ru_utime.tv_usec/1000; |
408 |
|
408 | time1+=us.ru_stime.tv_sec*1000+us.ru_stime.tv_usec/1000; |
409 |
|
409 | } |
410 |
|
410 | if(getrusage(RUSAGE_CHILDREN,&us)==0) { |
411 |
|
411 | time1+=us.ru_utime.tv_sec*1000+us.ru_utime.tv_usec/1000; |
412 |
|
412 | time1+=us.ru_stime.tv_sec*1000+us.ru_stime.tv_usec/1000; |
413 |
|
413 | } |
414 |
|
414 | snprintf(tmplbuf,sizeof(tmplbuf),"%d,%d,%d,%.4f,%.2f,%d,%d,%d", |
415 |
|
415 | (int)(_varptr-_varbuf[_varbufcurr])+_varbufcurr*VARBUF_LEN, |
416 |
|
416 | bufvcnt-freevcnt,freevcnt, |
417 |
|
417 | (double) endmtime2/10000, (double) time1/1000, |
418 |
|
418 | mcachecnt,mfilecnt,execnt); |
419 |
|
419 | setvar("wims_debug_info",tmplbuf); |
420 |
|
420 | lastout_file=-1; phtml_put_base("debug.phtml",0); |
421 | } |
421 | } |
422 | 422 | ||
423 | /* Add to list of hacked variables */ |
423 | /* Add to list of hacked variables */ |
424 | void add_hack(char *name) |
424 | void add_hack(char *name) |
425 | { |
425 | { |
426 |
|
426 | char buf[MAX_LINELEN+1]; |
427 |
|
427 | char *p; |
428 |
|
428 | p=getvar("wims_hacked_variables"); if(p==NULL) buf[0]=0; |
429 |
|
429 | else snprintf(buf,sizeof(buf),"%s",p); |
430 |
|
430 | p=buf+strlen(buf); |
431 |
|
431 | if(p-buf >= sizeof(buf)-strlen(name)-4) return; /* too long */ |
432 |
|
432 | if(p>buf) snprintf(p,sizeof(buf)-(p-buf),", %s",name); |
433 |
|
433 | else snprintf(buf,sizeof(buf),"%s",name); |
434 |
|
434 | setvar("wims_hacked_variables",buf); |
435 | } |
435 | } |
436 | - |