← Back to branch summary

~ubuntu-branches/debian/sid/libembperl-perl/sid

« back to all changes in this revision

Viewing changes to epcmd2.c

  • Committer: Bazaar Package Importer
  • Author(s): Angus Lees
  • Date: 2004-02-15 14:23:39 UTC
  • Revision ID: james.westby@ubuntu.com-20040215142339-n21gqf7mx9tmyb8d
Tags: upstream-2.0b10
Import upstream version 2.0b10

Show diffs side-by-side

added added

removed removed

Lines of Context:
epcmd2.c
 
1
/*###################################################################################
 
2
#
 
3
#   Embperl - Copyright (c) 1997-2004 Gerald Richter / ECOS
 
4
#
 
5
#   You may distribute under the terms of either the GNU General Public
 
6
#   License or the Artistic License, as specified in the Perl README file.
 
7
#
 
8
#   THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
 
9
#   IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 
10
#   WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 
11
#
 
12
#   $Id: epcmd2.c,v 1.11 2004/01/23 06:50:54 richter Exp $
 
13
#
 
14
###################################################################################*/
 
15
 
 
16
 
 
17
#include "ep.h"
 
18
#include "epmacro.h"
 
19
 
 
20
/* ---------------------------------------------------------------------------- */
 
21
/*                                                                              */
 
22
/* Split values in from %fdat                                                   */
 
23
/*                                                                              */
 
24
/* ---------------------------------------------------------------------------- */
 
25
 
 
26
 
 
27
SV * SplitFdat     (/*i/o*/ register req * r,
 
28
                           /*in*/  SV ** ppSVfdat,
 
29
                           /*out*/ SV ** ppSVerg,
 
30
                           /*in*/  char * pName,
 
31
                           /*in*/  STRLEN nlen)
 
32
 
 
33
    {
 
34
    epTHX_
 
35
    STRLEN dlen ;
 
36
    char * pData ;
 
37
    char * s ;
 
38
    char * p ;
 
39
    
 
40
    if (ppSVerg && *ppSVerg && SvTYPE (*ppSVerg))
 
41
        {
 
42
        return *ppSVerg ;
 
43
        }
 
44
 
 
45
    pData = SvPV (*ppSVfdat, dlen) ;
 
46
    s = pData ;
 
47
 
 
48
    if ((p = strchr (s, r -> Config.cMultFieldSep)))
 
49
        { /* Multiple values -> put them into a hash */
 
50
        HV * pHV = newHV () ;
 
51
        int l ;
 
52
 
 
53
        while (p)
 
54
            {
 
55
            hv_store (pHV, s, p - s, &sv_undef, 0) ;
 
56
            s = p + 1 ;
 
57
            p = strchr (s, r -> Config.cMultFieldSep) ;
 
58
            }
 
59
 
 
60
        l = dlen - (s - pData) ;
 
61
        if (l > 0)
 
62
            hv_store (pHV, s, l, &sv_undef, 0) ;
 
63
        hv_store (r -> pThread -> pFormSplitHash, (char *)pName, nlen, (SV *)pHV, 0) ;
 
64
        if (r -> Component.Config.bDebug & dbgInput)
 
65
            lprintf (r -> pApp,  "[%d]INPU: <mult values>\n", r -> pThread -> nPid) ; 
 
66
        return (SV *)pHV;
 
67
        }
 
68
    else
 
69
        {
 
70
        SvREFCNT_inc (*ppSVfdat) ;
 
71
        hv_store (r -> pThread -> pFormSplitHash, (char *)pName, nlen, *ppSVfdat, 0) ;
 
72
        if (r -> Component.Config.bDebug & dbgInput)
 
73
            lprintf (r -> pApp,  "[%d]INPU: value = %s\n", r -> pThread -> nPid, SvPV(*ppSVfdat, na)) ; 
 
74
        return *ppSVfdat ;
 
75
        }
 
76
    }    
 
77
 
 
78
/* ---------------------------------------------------------------------------- */
 
79
/*                                                                              */
 
80
/* SetRemove Attribute on html tag ...                                          */
 
81
/*                                                                              */
 
82
/* ---------------------------------------------------------------------------- */
 
83
 
 
84
 
 
85
 
 
86
static void embperlCmd_SetRemove (/*i/o*/ register req * r,
 
87
                             /*in*/ tDomTree *      pDomTree,
 
88
                             /*in*/ tNode           xNode,
 
89
                             /*in*/ tRepeatLevel    nRepeatLevel,
 
90
                             /*in*/ const char *    pName,
 
91
                             /*in*/ int             nNameLen,
 
92
                             /*in*/ const char *    pVal,
 
93
                             /*in*/ int             nValLen,
 
94
                             /*in*/ const char *    sAttrName, 
 
95
                             /*in*/ int             nAttrLen,
 
96
                             /*in*/ int             bSetInSource) 
 
97
 
 
98
    {
 
99
    epTHX_
 
100
    int     bEqual = 0 ;
 
101
    SV **   ppSV = hv_fetch(r -> pThread -> pFormHash, (char *)pName, nNameLen, 0) ;  
 
102
    tNodeData * pNode = Node_selfLevel (r -> pApp, pDomTree, xNode, nRepeatLevel) ;
 
103
    SV *    pInputHashValue = NULL ;
 
104
 
 
105
    if (ppSV)
 
106
        {
 
107
        SV **   ppSVerg = hv_fetch(r -> pThread -> pFormSplitHash, (char *)pName, nNameLen, 0) ;  
 
108
        SV *    pSV = SplitFdat (r, ppSV, ppSVerg, (char *)pName, nNameLen) ;
 
109
 
 
110
        if (SvTYPE (pSV) == SVt_PVHV)
 
111
            { /* -> Hash -> check if key exists */
 
112
            nValLen = TransHtml (r, (char *)pVal, nValLen) ;
 
113
            if (hv_exists ((HV *)pSV, (char *)pVal, nValLen))
 
114
                {
 
115
                bEqual = 1 ;
 
116
                pInputHashValue = newSVpv ((nValLen?((char *)pVal):""), nValLen) ;
 
117
                }
 
118
            }
 
119
        else
 
120
            {
 
121
            STRLEN   dlen ;
 
122
            char * pData = SvPV (pSV, dlen) ;
 
123
            nValLen = TransHtml (r, (char *)pVal, nValLen) ;
 
124
            if ((int)dlen == nValLen && strncmp (pVal, pData, dlen) == 0)
 
125
                {
 
126
                bEqual = 1 ;
 
127
                pInputHashValue = newSVsv(pSV) ; 
 
128
                }
 
129
            }
 
130
 
 
131
        if (bEqual)
 
132
            {
 
133
            Element_selfSetAttribut (r -> pApp, pDomTree, pNode, nRepeatLevel, sAttrName, nAttrLen, NULL, 0) ;
 
134
            if (r -> Component.Config.bDebug & dbgInput)
 
135
                lprintf (r -> pApp,  "[%d]INPU: Set Attribut: Name: '%*.*s' Value: '%*.*s' Attribute: '%*.*s' nRepeatLevel=%d\n", r -> pThread -> nPid, nNameLen, nNameLen, pName, nValLen, nValLen, pVal, nAttrLen, nAttrLen, sAttrName, nRepeatLevel) ; 
 
136
            }
 
137
        else
 
138
            {
 
139
            Element_selfRemoveAttribut (r -> pApp, pDomTree, pNode, nRepeatLevel, sAttrName, nAttrLen) ;
 
140
            if (r -> Component.Config.bDebug & dbgInput)
 
141
                lprintf (r -> pApp,  "[%d]INPU: Remove Attribut: Name: '%*.*s' Value: '%*.*s' Attribute: '%*.*s' nRepeatLevel=%d\n", r -> pThread -> nPid, nNameLen, nNameLen, pName, nValLen, nValLen, pVal, nAttrLen, nAttrLen, sAttrName, nRepeatLevel ) ; 
 
142
            }
 
143
        }
 
144
    else
 
145
        {
 
146
        if (Element_selfGetAttribut (r -> pApp, pDomTree, pNode, sAttrName, nAttrLen))
 
147
            {
 
148
            hv_store (r -> pThread -> pInputHash, (char *)pName, nNameLen, newSVpv ((nValLen?((char *)pVal):""), nValLen), 0) ;
 
149
            if (r -> Component.Config.bDebug & dbgInput)
 
150
                lprintf (r -> pApp,  "[%d]INPU: Has already Attribut: Name: '%*.*s' Value: '%*.*s' Attribute: '%*.*s' nRepeatLevel=%d\n", r -> pThread -> nPid, nNameLen, nNameLen, pName, nValLen, nValLen, pVal, nAttrLen, nAttrLen, sAttrName, nRepeatLevel ) ; 
 
151
            }
 
152
        else
 
153
            {
 
154
            if (r -> Component.Config.bDebug & dbgInput)
 
155
                lprintf (r -> pApp,  "[%d]INPU: No value in %%fdat for Attribut: Name: '%*.*s' Value: '%*.*s' Attribute: '%*.*s' nRepeatLevel=%d\n", r -> pThread -> nPid, nNameLen, nNameLen, pName, nValLen, nValLen, pVal, nAttrLen, nAttrLen, sAttrName, nRepeatLevel ) ; 
 
156
            }
 
157
 
 
158
        }
 
159
 
 
160
    if (pInputHashValue)
 
161
        hv_store (r -> pThread -> pInputHash, (char *)pName, nNameLen, pInputHashValue, 0) ; 
 
162
    else
 
163
        {
 
164
        if (!hv_exists (r -> pThread -> pInputHash, (char *)pName, nNameLen))
 
165
            hv_store (r -> pThread -> pInputHash, (char *)pName, nNameLen, newSVpv ("", 0), 0) ; 
 
166
        }
 
167
 
 
168
    }
 
169
 
 
170
/* ---------------------------------------------------------------------------- */
 
171
/*                                                                              */
 
172
/* input checkbox/radio html tag ...                                            */
 
173
/*                                                                              */
 
174
/* ---------------------------------------------------------------------------- */
 
175
 
 
176
 
 
177
 
 
178
void embperlCmd_InputCheck (/*i/o*/ register req *     r,
 
179
                            /*in*/ tDomTree *       pDomTree,
 
180
                            /*in*/ tNode            xNode,
 
181
                            /*in*/ tRepeatLevel     nRepeatLevel,
 
182
                            /*in*/ const char *     pName,
 
183
                            /*in*/ int              nNameLen,
 
184
                            /*in*/ const char *     pVal,
 
185
                            /*in*/ int              nValLen, 
 
186
                            /*in*/ int              bSetInSource) 
 
187
 
 
188
    {
 
189
    embperlCmd_SetRemove (r, pDomTree, xNode, nRepeatLevel, pName, nNameLen, pVal, nValLen, "checked", 7, bSetInSource) ;
 
190
    }
 
191
 
 
192
 
 
193
/* ---------------------------------------------------------------------------- */
 
194
/*                                                                              */
 
195
/* option html tag ...                                                          */
 
196
/*                                                                              */
 
197
/* ---------------------------------------------------------------------------- */
 
198
 
 
199
 
 
200
void embperlCmd_Option (/*i/o*/ register req *  r,
 
201
                        /*in*/ tDomTree *       pDomTree,
 
202
                        /*in*/ tNode            xNode,
 
203
                        /*in*/ tRepeatLevel     nRepeatLevel,
 
204
                        /*in*/ const char *     pName,
 
205
                        /*in*/ int              nNameLen,
 
206
                        /*in*/ const char *     pVal,
 
207
                        /*in*/ int              nValLen,
 
208
                        /*in*/ int              bSetInSource) 
 
209
                         
 
210
 
 
211
    {
 
212
    embperlCmd_SetRemove (r, pDomTree, xNode, nRepeatLevel, pName, nNameLen, pVal, nValLen, "selected", 8, bSetInSource) ;
 
213
    }
 
214
 
 
215
 
 
216
 
 
217
 
 
218
 
 
219
/* ---------------------------------------------------------------------------- */
 
220
/*                                                                              */
 
221
/* hidden command ...                                                           */
 
222
/*                                                                              */
 
223
/* ---------------------------------------------------------------------------- */
 
224
 
 
225
 
 
226
int embperlCmd_Hidden   (/*i/o*/ register req *     r,
 
227
                         /*in*/ tDomTree *          pDomTree,
 
228
                         /*in*/ tNode               xNode,
 
229
                         /*in*/ tRepeatLevel        nRepeatLevel,
 
230
                         /*in*/ const char *        sArg)
 
231
 
 
232
    {
 
233
    epTHX_
 
234
    char *  pKey ;
 
235
    SV *    psv ;
 
236
    SV * *  ppsv ;
 
237
    HV *    pAddHash = r -> pThread -> pFormHash ;
 
238
    HV *    pSubHash = r -> pThread -> pInputHash ;
 
239
    AV *    pSort    = NULL ;
 
240
    HE *    pEntry ;
 
241
    I32     l ;
 
242
    char *  sArgs ;
 
243
    char *  sVarName ;
 
244
    char    sVar[512] ;
 
245
    int     nMax ;
 
246
    STRLEN  nKey ;
 
247
    tNodeData * pNode ;
 
248
    tNodeData * pNewNode ;
 
249
 
 
250
 
 
251
    EPENTRY (CmdHidden) ;
 
252
 
 
253
    pNode = Node_selfCondCloneNode (r -> pApp, pDomTree, Node_selfLevel (r -> pApp, pDomTree, xNode, nRepeatLevel), nRepeatLevel) ;
 
254
 
 
255
    pNewNode = pNode ;
 
256
 
 
257
    sArgs = _ep_strdup (r, sArg) ;
 
258
    if (sArgs && *sArgs != '\0')
 
259
        {            
 
260
        strncpy (sVar, r -> Component.sEvalPackage, sizeof (sVar) - 5) ;
 
261
        sVar[r -> Component.nEvalPackage] = ':' ;
 
262
        sVar[r -> Component.nEvalPackage+1] = ':' ;
 
263
        sVar[sizeof(sVar) - 1] = '\0' ;
 
264
        nMax = sizeof(sVar) - r -> Component.nEvalPackage - 3 ;
 
265
        
 
266
        if ((sVarName = strtok (sArgs, ", \t\n")))
 
267
            {
 
268
            if (*sVarName == '%')
 
269
                sVarName++ ;
 
270
        
 
271
            strncpy (sVar + r -> Component.nEvalPackage + 2, sVarName, nMax) ;
 
272
            
 
273
            if ((pAddHash = perl_get_hv ((char *)sVar, FALSE)) == NULL)
 
274
                {
 
275
                strncpy (r -> errdat1, sVar, sizeof (r -> errdat1) - 1) ;
 
276
                _free (r, sArgs) ;
 
277
                return rcHashError ;
 
278
                }
 
279
 
 
280
            if ((sVarName = strtok (NULL, ", \t\n")))
 
281
                {
 
282
                if (*sVarName == '%')
 
283
                    sVarName++ ;
 
284
        
 
285
                strncpy (sVar + r -> Component.nEvalPackage + 2, sVarName, nMax) ;
 
286
        
 
287
                if ((pSubHash = perl_get_hv ((char *)sVar, FALSE)) == NULL)
 
288
                    {
 
289
                    strncpy (r -> errdat1, sVar, sizeof (r -> errdat1) - 1) ;
 
290
                    _free (r, sArgs) ;
 
291
                    return rcHashError ;
 
292
                    }
 
293
 
 
294
                if ((sVarName = strtok (NULL, ", \t\n")))
 
295
                    {
 
296
                    if (*sVarName == '@')
 
297
                        sVarName++ ;
 
298
        
 
299
                    strncpy (sVar + r -> Component.nEvalPackage + 2, sVarName, nMax) ;
 
300
        
 
301
                    if ((pSort = perl_get_av ((char *)sVar, FALSE)) == NULL)
 
302
                        {
 
303
                        strncpy (r -> errdat1, sVar, sizeof (r -> errdat1) - 1) ;
 
304
                        _free (r, sArgs) ;
 
305
                        return rcArrayError ;
 
306
                        }
 
307
                    }
 
308
                }
 
309
            }
 
310
        }
 
311
    else
 
312
        pSort = r -> pThread -> pFormArray ;
 
313
 
 
314
 
 
315
    /* oputc (r, '\n') ; */
 
316
    if (pSort)
 
317
        {
 
318
        int n = AvFILL (pSort) + 1 ;
 
319
        int i ;
 
320
 
 
321
        for (i = 0; i < n; i++)
 
322
            {
 
323
            ppsv = av_fetch (pSort, i, 0) ;
 
324
            if (ppsv && (pKey = SvPV(*ppsv, nKey)) && !hv_exists (pSubHash, pKey, nKey))
 
325
                {
 
326
                STRLEN lppsv ;
 
327
                ppsv = hv_fetch (pAddHash, pKey, nKey, 0) ;
 
328
                
 
329
               if (ppsv && (!(r -> Component.Config.bOptions & optNoHiddenEmptyValue) || *SvPV (*ppsv, lppsv)))
 
330
                    {
 
331
                    char * s ;
 
332
                    STRLEN     l ;
 
333
                    SV * sEscapedText ;
 
334
                    tNode xInputNode = Node_appendChild (r -> pApp, pDomTree, pNewNode -> xNdx, nRepeatLevel, ntypTag, 0, "input", 5, 0, 0, NULL) ;
 
335
                    tNode xAttr      = Node_appendChild (r -> pApp, pDomTree, xInputNode, nRepeatLevel, ntypAttr, 0, "type", 4, 0, 0, NULL) ;
 
336
                                       Node_appendChild (r -> pApp, pDomTree, xAttr, nRepeatLevel, ntypAttrValue, 0, "hidden", 6, 0, 0, NULL) ;
 
337
                    
 
338
                          xAttr      = Node_appendChild (r -> pApp, pDomTree, xInputNode, nRepeatLevel, ntypAttr, 0, "name", 4, 0, 0, NULL) ;
 
339
                                       Node_appendChild (r -> pApp, pDomTree, xAttr, nRepeatLevel, ntypAttrValue, 0, pKey, nKey, 0, 0, NULL) ;
 
340
                          xAttr      = Node_appendChild (r -> pApp, pDomTree, xInputNode, nRepeatLevel, ntypAttr, 0, "value", 5, 0, 0, NULL) ;
 
341
 
 
342
                    s = SvPV (*ppsv, l) ;                         
 
343
                    sEscapedText = Escape (r, s, l, r -> Component.nCurrEscMode, NULL, '\0') ;
 
344
                    s = SV2String (sEscapedText, l) ;
 
345
                          
 
346
                          Node_appendChild (r -> pApp, pDomTree, xAttr, nRepeatLevel, ntypAttrValue, 0, s, l, 0, 0, NULL) ;
 
347
                    }
 
348
                }
 
349
            }
 
350
        }
 
351
    else
 
352
        {
 
353
        hv_iterinit (pAddHash) ;
 
354
        while ((pEntry = hv_iternext (pAddHash)))
 
355
            {
 
356
            STRLEN nKey ;
 
357
            pKey = hv_iterkey (pEntry, &l) ;
 
358
            nKey = strlen (pKey) ;
 
359
            if (!hv_exists (pSubHash, pKey, nKey))
 
360
                {
 
361
                STRLEN lpsv ;
 
362
                psv = hv_iterval (pAddHash, pEntry) ;
 
363
 
 
364
                if (!(r -> Component.Config.bOptions & optNoHiddenEmptyValue) || *SvPV (psv, lpsv)) 
 
365
                    {
 
366
                    char * s ;
 
367
                    STRLEN     l ;
 
368
                    SV * sEscapedText ;
 
369
                    tNode xInputNode = Node_appendChild (r -> pApp, pDomTree, pNewNode -> xNdx, nRepeatLevel, ntypTag, 0, "input", 5, 0, 0, NULL) ;
 
370
                    tNode xAttr      = Node_appendChild (r -> pApp, pDomTree, xInputNode, nRepeatLevel, ntypAttr, 0, "type", 4, 0, 0, NULL) ;
 
371
                                       Node_appendChild (r -> pApp, pDomTree, xAttr, nRepeatLevel, ntypAttrValue, 0, "hidden", 6, 0, 0, NULL) ;
 
372
                    
 
373
                          xAttr      = Node_appendChild (r -> pApp, pDomTree, xInputNode, nRepeatLevel, ntypAttr, 0, "name", 4, 0, 0, NULL) ;
 
374
                                       Node_appendChild (r -> pApp, pDomTree, xAttr, nRepeatLevel, ntypAttrValue, 0, pKey, nKey, 0, 0, NULL) ;
 
375
                          xAttr      = Node_appendChild (r -> pApp, pDomTree, xInputNode, nRepeatLevel, ntypAttr, 0, "value", 5, 0, 0, NULL) ;
 
376
 
 
377
                    s = SvPV (psv, l) ;                   
 
378
                    sEscapedText = Escape (r, s, l, r -> Component.nCurrEscMode, NULL, '\0') ;
 
379
                    s = SV2String (sEscapedText, l) ;
 
380
                          
 
381
                          Node_appendChild (r -> pApp, pDomTree, xAttr, nRepeatLevel, ntypAttrValue, 0, s, l, 0, 0, NULL) ;
 
382
                    }
 
383
                }
 
384
            }
 
385
        }
 
386
 
 
387
    if (sArgs)
 
388
        _free (r, sArgs) ;
 
389
 
 
390
    return ok ;
 
391
    }
 
392
 
 
393
 
 
394
 
 
395
 
 
396
/* ---------------------------------------------------------------------------- */
 
397
/*                                                                              */
 
398
/* ouput data inside a url                                                      */
 
399
/*                                                                              */
 
400
/* ---------------------------------------------------------------------------- */
 
401
 
 
402
 
 
403
SV * Node_replaceChildWithUrlDATA (/*in*/ tReq *        r,
 
404
                                   /*in*/ tIndex        xDomTree, 
 
405
                                          tIndex        xOldChild, 
 
406
                                   /*in*/ tRepeatLevel  nRepeatLevel,
 
407
                                          SV *          sText)
 
408
    
 
409
    {
 
410
    epTHX_
 
411
    STRLEN l ;
 
412
    char * s ;
 
413
    AV *   pAV ;    
 
414
    HV *   pHV ;    
 
415
    tDomTree * pDomTree = DomTree_self(xDomTree) ;
 
416
 
 
417
    if (SvTYPE(sText) == SVt_RV && SvTYPE((pAV = (AV *)SvRV(sText))) == SVt_PVAV)
 
418
        { /* Array reference inside URL */
 
419
        SV ** ppSV ;
 
420
        int i ;
 
421
        int f = AvFILL(pAV)  ;
 
422
        tNode xNode ;
 
423
 
 
424
        xOldChild = Node_replaceChildWithCDATA (r -> pApp, DomTree_self(xDomTree), xOldChild, nRepeatLevel, "", 0, 4, 0) ;
 
425
 
 
426
        for (i = 0; i <= f; i++)
 
427
            {
 
428
            ppSV = av_fetch (pAV, i, 0) ;
 
429
            if (ppSV && *ppSV)
 
430
                {
 
431
                s = SV2String (*ppSV, l) ;
 
432
                xNode = Node_appendChild (r -> pApp, pDomTree, xOldChild, nRepeatLevel, (tNodeType)((r -> Component.nCurrEscMode & 3)?ntypTextHTML:ntypCDATA), 0, s, l, 0, 0, NULL) ;
 
433
                if (r -> Component.nCurrEscMode & 2) 
 
434
                    Node_selfLevel (r -> pApp, pDomTree, xNode, nRepeatLevel) -> bFlags |= nflgEscUrl ;
 
435
                }
 
436
            if ((i & 1) == 0)
 
437
                Node_appendChild (r -> pApp, pDomTree, xOldChild, nRepeatLevel, ntypCDATA, 0, "=", 1, 0, 0, NULL) ;
 
438
            else if (i < f)
 
439
                Node_appendChild (r -> pApp, pDomTree, xOldChild, nRepeatLevel, ntypCDATA, 0, "&amp;", 5, 0, 0, NULL) ;
 
440
            }
 
441
    
 
442
        }
 
443
 
 
444
    else if (SvTYPE(sText) == SVt_RV && SvTYPE((pHV = (HV *)SvRV(sText))) == SVt_PVHV)
 
445
        { /* Hash reference inside URL */
 
446
        HE *        pEntry ;
 
447
        char *      pKey ;
 
448
        SV *        pSVValue ;
 
449
        tNode       xNode ;
 
450
        int         i = 0 ;
 
451
        I32         l32 ;
 
452
 
 
453
        lprintf (r -> pApp, "xOldChild=%d, rl=%d\n", xOldChild, nRepeatLevel) ;
 
454
        xOldChild = Node_replaceChildWithCDATA (r -> pApp, DomTree_self(xDomTree), xOldChild, nRepeatLevel, "", 0, 4, 0) ;
 
455
        lprintf (r -> pApp, "a xOldChild=%d, rl=%d\n", xOldChild, nRepeatLevel) ;
 
456
 
 
457
        hv_iterinit (pHV) ;
 
458
        while ((pEntry = hv_iternext (pHV)))
 
459
            {
 
460
            if (i++ > 0)
 
461
                Node_appendChild (r -> pApp, pDomTree, xOldChild, nRepeatLevel, ntypCDATA, 0, "&amp;", 5, 0, 0, NULL) ;
 
462
            pKey     = hv_iterkey (pEntry, &l32) ;
 
463
            xNode = Node_appendChild (r -> pApp, pDomTree, xOldChild, nRepeatLevel, (tNodeType)((r -> Component.nCurrEscMode & 3)?ntypTextHTML:ntypCDATA), 0, pKey, l32, 0, 0, NULL) ;
 
464
            if (r -> Component.nCurrEscMode & 2) 
 
465
                Node_self (pDomTree, xNode) -> bFlags |= nflgEscUrl ;
 
466
 
 
467
            Node_appendChild (r -> pApp, pDomTree, xOldChild, nRepeatLevel, ntypCDATA, 0, "=", 1, 0, 0, NULL) ;
 
468
 
 
469
            pSVValue = hv_iterval (pHV , pEntry) ;
 
470
            if (pSVValue)
 
471
                {
 
472
                s = SV2String (pSVValue, l) ;
 
473
                xNode = Node_appendChild (r -> pApp, pDomTree, xOldChild, nRepeatLevel, (tNodeType)((r -> Component.nCurrEscMode & 3)?ntypTextHTML:ntypCDATA), 0, s, l, 0, 0, NULL) ;
 
474
                if (r -> Component.nCurrEscMode & 2) 
 
475
                    Node_selfLevel (r -> pApp, pDomTree, xNode, nRepeatLevel) -> bFlags |= nflgEscUrl ;
 
476
                }
 
477
            }
 
478
        }
 
479
    else
 
480
        {
 
481
        char * s = SV2String (sText, l) ;
 
482
        Node_replaceChildWithCDATA (r -> pApp, DomTree_self(xDomTree), xOldChild, nRepeatLevel, s, l, (r -> Component.nCurrEscMode & 3) == 3?2 + (r -> Component.nCurrEscMode & 4):r -> Component.nCurrEscMode, 0) ;
 
483
        }
 
484
 
 
485
    r -> Component.nCurrEscMode = r -> Component.Config.nEscMode ;
 
486
    r -> Component.bEscModeSet = -1 ;
 
487
    /* SvREFCNT_inc (sText) ; */
 
488
    /* ST(0) = sText ;*/
 
489
    /* XSRETURN(1) ; */
 
490
    return sText ;
 
491
    }
 
492
 
 
493
 
 
494
 
 
495
 
 
496
/* ---------------------------------------------------------------------------- */
 
497
/*                                                                              */
 
498
/* AddSessionIdToLink                                                           */
 
499
/*                                                                              */
 
500
/* ---------------------------------------------------------------------------- */
 
501
 
 
502
 
 
503
int embperlCmd_AddSessionIdToLink  (/*i/o*/ register req *     r,
 
504
                                    /*in*/ tDomTree *       pDomTree,
 
505
                                    /*in*/ tNode                    xNode,
 
506
                                    /*in*/ tRepeatLevel     nRepeatLevel,
 
507
                                    /*in*/ char *            sAttrName)
 
508
 
 
509
    {
 
510
    tNodeData * pNode ;
 
511
    tAttrData * pAttr ;
 
512
    int         nAttrLen ;
 
513
    char      * pAttrString = NULL ;
 
514
    char      * pAttrValue ;
 
515
    int         l ;
 
516
    int         sl ;
 
517
 
 
518
    if (!r -> sSessionID)
 
519
        return ok ;
 
520
 
 
521
    pNode = Node_self(pDomTree,xNode) ;
 
522
    nAttrLen = strlen (sAttrName) ;
 
523
    pAttr = Element_selfGetAttribut (r -> pApp, pDomTree, pNode, sAttrName, nAttrLen) ;
 
524
 
 
525
    pAttrValue = Attr_selfValue (r -> pApp, pDomTree, pAttr, nRepeatLevel, &pAttrString) ;
 
526
 
 
527
    sl = strlen (r -> sSessionID) ;
 
528
    if (!pAttrString)
 
529
        {
 
530
        l = strlen (pAttrValue) ;
 
531
        StringNew (r -> pApp, &pAttrString, l + 10 + sl) ;
 
532
        StringAdd (r -> pApp, &pAttrString, pAttrValue, l) ;
 
533
        
 
534
        }
 
535
    
 
536
    if (strchr(pAttrValue, '?'))
 
537
        {
 
538
        StringAdd (r -> pApp, &pAttrString, "&", 1) ;
 
539
        }
 
540
    else
 
541
        {
 
542
        StringAdd (r -> pApp, &pAttrString, "?", 1) ;
 
543
        }
 
544
    StringAdd (r -> pApp, &pAttrString, r -> sSessionID, sl) ;
 
545
 
 
546
    Element_selfSetAttribut (r -> pApp, pDomTree, pNode, nRepeatLevel, sAttrName, nAttrLen, pAttrString, ArrayGetSize (r -> pApp, pAttrString)) ;
 
547
 
 
548
    return ok ;
 
549
    }
 
550
 
 
551
 
 
552
/* ---------------------------------------------------------------------------- */
 
553
/*                                                                              */
 
554
/* AddSessionIdToHidden                                                         */
 
555
/*                                                                              */
 
556
/* ---------------------------------------------------------------------------- */
 
557
 
 
558
 
 
559
int embperlCmd_AddSessionIdToHidden(/*i/o*/ register req *     r,
 
560
                                    /*in*/ tDomTree *       pDomTree,
 
561
                                    /*in*/ tNode                    xNode,
 
562
                                    /*in*/ tRepeatLevel     nRepeatLevel)
 
563
 
 
564
    {
 
565
    char * sid = r -> sSessionID ;
 
566
    tNodeData * pNode ;
 
567
 
 
568
    pNode = Node_self(pDomTree,xNode) ;
 
569
    if (sid)
 
570
        {
 
571
        char * val = strchr (sid, '=') ;
 
572
        if (val)
 
573
            {
 
574
            tNode xInputNode = Node_appendChild (r -> pApp, pDomTree, pNode -> xNdx,  nRepeatLevel, ntypTag, 0, "input", 5, 0, 0, NULL) ;
 
575
            tNode xAttr      = Node_appendChild (r -> pApp, pDomTree, xInputNode, nRepeatLevel, ntypAttr, 0, "type", 4, 0, 0, NULL) ;
 
576
                               Node_appendChild (r -> pApp, pDomTree, xAttr, nRepeatLevel, ntypAttrValue, 0, "hidden", 6, 0, 0, NULL) ;
 
577
    
 
578
                  xAttr      = Node_appendChild (r -> pApp, pDomTree, xInputNode, nRepeatLevel, ntypAttr, 0, "name", 4, 0, 0, NULL) ;
 
579
                               Node_appendChild (r -> pApp, pDomTree, xAttr, nRepeatLevel, ntypAttrValue, 0, sid, val - sid, 0, 0, NULL) ;
 
580
                  xAttr      = Node_appendChild (r -> pApp, pDomTree, xInputNode, nRepeatLevel, ntypAttr, 0, "value", 5, 0, 0, NULL) ;
 
581
                               Node_appendChild (r -> pApp, pDomTree, xAttr, nRepeatLevel, ntypAttrValue, 0, val+1, strlen(val+1), 0, 0, NULL) ;
 
582
            }
 
583
        }
 
584
    
 
585
    return ok ;
 
586
    }