← Back to branch summary

~ubuntu-branches/ubuntu/saucy/apr-util/saucy-proposed

« back to all changes in this revision

Viewing changes to hooks/apr_hooks.c

  • Committer: Package Import Robot
  • Author(s): Stefan Fritsch
  • Date: 2013-05-05 15:43:34 UTC
  • mfrom: (1.3.4)
  • Revision ID: package-import@ubuntu.com-20130505154334-ljd2tn8515nf96mo
Tags: 1.5.2-1
http://bugs.debian.org/699327
* New upstream release.
* Ship find_apu.m4 in libaprutil1-dev. Closes: #699327

Show diffs side-by-side

added added

removed removed

Lines of Context:
hooks/apr_hooks.c
30
30
#include "apr_want.h"
31
31
 
32
32
#if 0
33
 
#define apr_palloc(pool,size)   malloc(size)
 
33
#define apr_palloc(pool,size)   malloc(size)
34
34
#endif
35
35
 
36
36
APU_DECLARE_DATA apr_pool_t *apr_hook_global_pool = NULL;
84
84
{
85
85
    TSort *pData=apr_palloc(p,nItems*sizeof *pData);
86
86
    int n;
87
 
    
 
87
 
88
88
    qsort(pItems,nItems,sizeof *pItems,crude_order);
89
89
    for(n=0 ; n < nItems ; ++n) {
90
 
        pData[n].nPredecessors=0;
91
 
        pData[n].ppPredecessors=apr_pcalloc(p,nItems*sizeof *pData[n].ppPredecessors);
92
 
        pData[n].pNext=NULL;
93
 
        pData[n].pData=&pItems[n];
 
90
        pData[n].nPredecessors=0;
 
91
        pData[n].ppPredecessors=apr_pcalloc(p,nItems*sizeof *pData[n].ppPredecessors);
 
92
        pData[n].pNext=NULL;
 
93
        pData[n].pData=&pItems[n];
94
94
    }
95
95
 
96
96
    for(n=0 ; n < nItems ; ++n) {
97
 
        int i,k;
98
 
 
99
 
        for(i=0 ; pItems[n].aszPredecessors && pItems[n].aszPredecessors[i] ; ++i)
100
 
            for(k=0 ; k < nItems ; ++k)
101
 
                if(!strcmp(pItems[k].szName,pItems[n].aszPredecessors[i])) {
102
 
                    int l;
103
 
 
104
 
                    for(l=0 ; l < pData[n].nPredecessors ; ++l)
105
 
                        if(pData[n].ppPredecessors[l] == &pData[k])
106
 
                            goto got_it;
107
 
                    pData[n].ppPredecessors[pData[n].nPredecessors]=&pData[k];
108
 
                    ++pData[n].nPredecessors;
109
 
                got_it:
110
 
                    break;
111
 
                }
112
 
        for(i=0 ; pItems[n].aszSuccessors && pItems[n].aszSuccessors[i] ; ++i)
113
 
            for(k=0 ; k < nItems ; ++k)
114
 
                if(!strcmp(pItems[k].szName,pItems[n].aszSuccessors[i])) {
115
 
                    int l;
116
 
 
117
 
                    for(l=0 ; l < pData[k].nPredecessors ; ++l)
118
 
                        if(pData[k].ppPredecessors[l] == &pData[n])
119
 
                            goto got_it2;
120
 
                    pData[k].ppPredecessors[pData[k].nPredecessors]=&pData[n];
121
 
                    ++pData[k].nPredecessors;
122
 
                got_it2:
123
 
                    break;
124
 
                }
 
97
        int i,k;
 
98
 
 
99
        for(i=0 ; pItems[n].aszPredecessors && pItems[n].aszPredecessors[i] ; ++i)
 
100
            for(k=0 ; k < nItems ; ++k)
 
101
                if(!strcmp(pItems[k].szName,pItems[n].aszPredecessors[i])) {
 
102
                    int l;
 
103
 
 
104
                    for(l=0 ; l < pData[n].nPredecessors ; ++l)
 
105
                        if(pData[n].ppPredecessors[l] == &pData[k])
 
106
                            goto got_it;
 
107
                    pData[n].ppPredecessors[pData[n].nPredecessors]=&pData[k];
 
108
                    ++pData[n].nPredecessors;
 
109
                got_it:
 
110
                    break;
 
111
                }
 
112
        for(i=0 ; pItems[n].aszSuccessors && pItems[n].aszSuccessors[i] ; ++i)
 
113
            for(k=0 ; k < nItems ; ++k)
 
114
                if(!strcmp(pItems[k].szName,pItems[n].aszSuccessors[i])) {
 
115
                    int l;
 
116
 
 
117
                    for(l=0 ; l < pData[k].nPredecessors ; ++l)
 
118
                        if(pData[k].ppPredecessors[l] == &pData[n])
 
119
                            goto got_it2;
 
120
                    pData[k].ppPredecessors[pData[k].nPredecessors]=&pData[n];
 
121
                    ++pData[k].nPredecessors;
 
122
                got_it2:
 
123
                    break;
 
124
                }
125
125
    }
126
126
 
127
127
    return pData;
143
143
    TSort *pTail=NULL;
144
144
 
145
145
    for(nTotal=0 ; nTotal < nItems ; ++nTotal) {
146
 
        int n,i,k;
 
146
        int n,i,k;
147
147
 
148
 
        for(n=0 ; ; ++n) {
149
 
            if(n == nItems)
150
 
                assert(0);      /* we have a loop... */
151
 
            if(!pData[n].pNext) {
152
 
                if(pData[n].nPredecessors) {
153
 
                    for(k=0 ; ; ++k) {
154
 
                        assert(k < nItems);
155
 
                        if(pData[n].ppPredecessors[k])
156
 
                            break;
157
 
                    }
158
 
                    for(i=0 ; ; ++i) {
159
 
                        assert(i < nItems);
160
 
                        if(&pData[i] == pData[n].ppPredecessors[k]) {
161
 
                            n=i-1;
162
 
                            break;
163
 
                        }
164
 
                    }
165
 
                } else
166
 
                    break;
167
 
            }
168
 
        }
169
 
        if(pTail)
170
 
            pTail->pNext=&pData[n];
171
 
        else
172
 
            pHead=&pData[n];
173
 
        pTail=&pData[n];
174
 
        pTail->pNext=pTail;     /* fudge it so it looks linked */
175
 
        for(i=0 ; i < nItems ; ++i)
176
 
            for(k=0 ; k < nItems ; ++k)
177
 
                if(pData[i].ppPredecessors[k] == &pData[n]) {
178
 
                    --pData[i].nPredecessors;
179
 
                    pData[i].ppPredecessors[k]=NULL;
180
 
                    break;
181
 
                }
 
148
        for(n=0 ; ; ++n) {
 
149
            if(n == nItems)
 
150
                assert(0);      /* we have a loop... */
 
151
            if(!pData[n].pNext) {
 
152
                if(pData[n].nPredecessors) {
 
153
                    for(k=0 ; ; ++k) {
 
154
                        assert(k < nItems);
 
155
                        if(pData[n].ppPredecessors[k])
 
156
                            break;
 
157
                    }
 
158
                    for(i=0 ; ; ++i) {
 
159
                        assert(i < nItems);
 
160
                        if(&pData[i] == pData[n].ppPredecessors[k]) {
 
161
                            n=i-1;
 
162
                            break;
 
163
                        }
 
164
                    }
 
165
                } else
 
166
                    break;
 
167
            }
 
168
        }
 
169
        if(pTail)
 
170
            pTail->pNext=&pData[n];
 
171
        else
 
172
            pHead=&pData[n];
 
173
        pTail=&pData[n];
 
174
        pTail->pNext=pTail;     /* fudge it so it looks linked */
 
175
        for(i=0 ; i < nItems ; ++i)
 
176
            for(k=0 ; k < nItems ; ++k)
 
177
                if(pData[i].ppPredecessors[k] == &pData[n]) {
 
178
                    --pData[i].nPredecessors;
 
179
                    pData[i].ppPredecessors[k]=NULL;
 
180
                    break;
 
181
                }
182
182
    }
183
183
    pTail->pNext=NULL;  /* unfudge the tail */
184
184
    return pHead;
185
185
}
186
186
 
187
187
static apr_array_header_t *sort_hook(apr_array_header_t *pHooks,
188
 
                                     const char *szName)
 
188
                                     const char *szName)
189
189
{
190
190
    apr_pool_t *p;
191
191
    TSort *pSort;
197
197
    pSort=tsort(pSort,pHooks->nelts);
198
198
    pNew=apr_array_make(apr_hook_global_pool,pHooks->nelts,sizeof(TSortData));
199
199
    if(apr_hook_debug_enabled)
200
 
        printf("Sorting %s:",szName);
 
200
        printf("Sorting %s:",szName);
201
201
    for(n=0 ; pSort ; pSort=pSort->pNext,++n) {
202
 
        TSortData *pHook;
203
 
        assert(n < pHooks->nelts);
204
 
        pHook=apr_array_push(pNew);
205
 
        memcpy(pHook,pSort->pData,sizeof *pHook);
206
 
        if(apr_hook_debug_enabled)
207
 
            printf(" %s",pHook->szName);
 
202
        TSortData *pHook;
 
203
        assert(n < pHooks->nelts);
 
204
        pHook=apr_array_push(pNew);
 
205
        memcpy(pHook,pSort->pData,sizeof *pHook);
 
206
        if(apr_hook_debug_enabled)
 
207
            printf(" %s",pHook->szName);
208
208
    }
209
209
    if(apr_hook_debug_enabled)
210
 
        fputc('\n',stdout);
 
210
        fputc('\n',stdout);
 
211
 
 
212
    /* destroy the pool - the sorted hooks were already copied */
 
213
    apr_pool_destroy(p);
 
214
 
211
215
    return pNew;
212
216
}
213
217
 
222
226
} HookSortEntry;
223
227
 
224
228
APU_DECLARE(void) apr_hook_sort_register(const char *szHookName,
225
 
                                        apr_array_header_t **paHooks)
 
229
                                        apr_array_header_t **paHooks)
226
230
{
227
231
#ifdef NETWARE
228
232
    get_apd
246
250
    if (!s_aHooksToSort) {
247
251
        s_aHooksToSort = apr_array_make(apr_hook_global_pool, 1, sizeof(HookSortEntry));
248
252
    }
249
 
        
 
253
 
250
254
    for(n=0 ; n < s_aHooksToSort->nelts ; ++n) {
251
 
        HookSortEntry *pEntry=&((HookSortEntry *)s_aHooksToSort->elts)[n];
252
 
        *pEntry->paHooks=sort_hook(*pEntry->paHooks,pEntry->szHookName);
 
255
        HookSortEntry *pEntry=&((HookSortEntry *)s_aHooksToSort->elts)[n];
 
256
        *pEntry->paHooks=sort_hook(*pEntry->paHooks,pEntry->szHookName);
253
257
    }
254
258
}
255
259
 
263
267
#ifdef NETWARE
264
268
    get_apd
265
269
#endif
266
 
    int n;    
 
270
    int n;
267
271
 
268
272
    if (!s_aHooksToSort) {
269
273
        return;
280
284
 
281
285
APU_DECLARE(void) apr_hook_debug_show(const char *szName,
282
286
                                      const char * const *aszPre,
283
 
                                      const char * const *aszSucc)
 
287
                                      const char * const *aszSucc)
284
288
{
285
289
    int nFirst;
286
290
 
287
291
    printf("  Hooked %s",szName);
288
292
    if(aszPre) {
289
 
        fputs(" pre(",stdout);
290
 
        nFirst=1;
291
 
        while(*aszPre) {
292
 
            if(!nFirst)
293
 
                fputc(',',stdout);
294
 
            nFirst=0;
295
 
            fputs(*aszPre,stdout);
296
 
            ++aszPre;
297
 
        }
298
 
        fputc(')',stdout);
 
293
        fputs(" pre(",stdout);
 
294
        nFirst=1;
 
295
        while(*aszPre) {
 
296
            if(!nFirst)
 
297
                fputc(',',stdout);
 
298
            nFirst=0;
 
299
            fputs(*aszPre,stdout);
 
300
            ++aszPre;
 
301
        }
 
302
        fputc(')',stdout);
299
303
    }
300
304
    if(aszSucc) {
301
 
        fputs(" succ(",stdout);
302
 
        nFirst=1;
303
 
        while(*aszSucc) {
304
 
            if(!nFirst)
305
 
                fputc(',',stdout);
306
 
            nFirst=0;
307
 
            fputs(*aszSucc,stdout);
308
 
            ++aszSucc;
309
 
        }
310
 
        fputc(')',stdout);
 
305
        fputs(" succ(",stdout);
 
306
        nFirst=1;
 
307
        while(*aszSucc) {
 
308
            if(!nFirst)
 
309
                fputc(',',stdout);
 
310
            nFirst=0;
 
311
            fputs(*aszSucc,stdout);
 
312
            ++aszSucc;
 
313
        }
 
314
        fputc(')',stdout);
311
315
    }
312
316
    fputc('\n',stdout);
313
317
}
324
328
    apr_array_header_t **ppArray;
325
329
 
326
330
    if(!s_phOptionalHooks)
327
 
        return NULL;
 
331
        return NULL;
328
332
    ppArray=apr_hash_get(s_phOptionalHooks,szName,strlen(szName));
329
333
    if(!ppArray)
330
 
        return NULL;
 
334
        return NULL;
331
335
    return *ppArray;
332
336
}
333
337
 
334
338
APU_DECLARE(void) apr_optional_hook_add(const char *szName,void (*pfn)(void),
335
 
                                        const char * const *aszPre,
336
 
                                        const char * const *aszSucc,int nOrder)
 
339
                                        const char * const *aszPre,
 
340
                                        const char * const *aszSucc,int nOrder)
337
341
{
338
342
#ifdef NETWARE
339
343
    get_apd
342
346
    apr_LINK__optional_t *pHook;
343
347
 
344
348
    if(!pArray) {
345
 
        apr_array_header_t **ppArray;
 
349
        apr_array_header_t **ppArray;
346
350
 
347
 
        pArray=apr_array_make(apr_hook_global_pool,1,
348
 
                              sizeof(apr_LINK__optional_t));
349
 
        if(!s_phOptionalHooks)
350
 
            s_phOptionalHooks=apr_hash_make(apr_hook_global_pool);
351
 
        ppArray=apr_palloc(apr_hook_global_pool,sizeof *ppArray);
352
 
        *ppArray=pArray;
353
 
        apr_hash_set(s_phOptionalHooks,szName,strlen(szName),ppArray);
354
 
        apr_hook_sort_register(szName,ppArray);
 
351
        pArray=apr_array_make(apr_hook_global_pool,1,
 
352
                              sizeof(apr_LINK__optional_t));
 
353
        if(!s_phOptionalHooks)
 
354
            s_phOptionalHooks=apr_hash_make(apr_hook_global_pool);
 
355
        ppArray=apr_palloc(apr_hook_global_pool,sizeof *ppArray);
 
356
        *ppArray=pArray;
 
357
        apr_hash_set(s_phOptionalHooks,szName,strlen(szName),ppArray);
 
358
        apr_hook_sort_register(szName,ppArray);
355
359
    }
356
360
    pHook=apr_array_push(pArray);
357
361
    pHook->pFunc=pfn;
360
364
    pHook->nOrder=nOrder;
361
365
    pHook->szName=apr_hook_debug_current;
362
366
    if(apr_hook_debug_enabled)
363
 
        apr_hook_debug_show(szName,aszPre,aszSucc);
 
367
        apr_hook_debug_show(szName,aszPre,aszSucc);
364
368
}
365
369
 
366
370
/* optional function support */
371
375
    get_apd
372
376
#endif
373
377
    if(!s_phOptionalFunctions)
374
 
        return NULL;
 
378
        return NULL;
375
379
    return (void(*)(void))apr_hash_get(s_phOptionalFunctions,szName,strlen(szName));
376
380
}
377
381
 
383
387
    get_apd
384
388
#endif
385
389
    if(!s_phOptionalFunctions)
386
 
        s_phOptionalFunctions=apr_hash_make(apr_hook_global_pool);
 
390
        s_phOptionalFunctions=apr_hash_make(apr_hook_global_pool);
387
391
    apr_hash_set(s_phOptionalFunctions,szName,strlen(szName),(void *)pfn);
388
392
}
389
393
 
395
399
    const char *aszCPost[]={"b",NULL};
396
400
    TSortData t1[]=
397
401
    {
398
 
        { "a",aszAPre,NULL },
399
 
        { "b",NULL,aszBPost },
400
 
        { "c",NULL,aszCPost }
 
402
        { "a",aszAPre,NULL },
 
403
        { "b",NULL,aszBPost },
 
404
        { "c",NULL,aszCPost }
401
405
    };
402
406
    TSort *pResult;
403
407
 
405
409
    pResult=tsort(pResult,3);
406
410
 
407
411
    for( ; pResult ; pResult=pResult->pNext)
408
 
        printf("%s\n",pResult->pData->szName);
 
412
        printf("%s\n",pResult->pData->szName);
409
413
}
410
414
#endif