← Back to branch summary

~ubuntu-branches/ubuntu/raring/wxwidgets2.8/raring

« back to all changes in this revision

Viewing changes to src/expat/xmlwf/xmlfile.c

  • Committer: Package Import Robot
  • Author(s): Stéphane Graber
  • Date: 2012-01-07 13:59:25 UTC
  • mfrom: (1.1.9) (5.1.10 sid)
  • Revision ID: package-import@ubuntu.com-20120107135925-2601miy9ullcon9j
Tags: 2.8.12.1-6ubuntu1
https://launchpad.net/bugs/632984
* Resync from Debian, changes that were kept:
  - debian/rules: re-enable mediactrl. This allows libwx_gtk2u_media-2.8 to be
    built, as this is required by some applications (LP: #632984)
  - debian/control: Build-dep on libxt-dev for mediactrl.
  - Patches
    + fix-bashism-in-example
* Add conflict on python-wxgtk2.8 (<< 2.8.12.1-6ubuntu1~) to python-wxversion
  to guarantee upgrade ordering when moving from pycentral to dh_python2.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/expat/xmlwf/xmlfile.c
1
 
/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
2
 
   See the file COPYING for copying permission.
3
 
*/
4
 
 
5
 
#include <stdio.h>
6
 
#include <stdlib.h>
7
 
#include <stddef.h>
8
 
#include <string.h>
9
 
#include <fcntl.h>
10
 
#ifdef COMPILED_FROM_DSP
11
 
#include "winconfig.h"
12
 
#else
13
 
#include "expat_config.h"
14
 
#endif
15
 
#include "expat.h"
16
 
#include "xmlfile.h"
17
 
#include "xmltchar.h"
18
 
#include "filemap.h"
19
 
 
20
 
#ifdef _MSC_VER
21
 
#include <io.h>
22
 
#endif
23
 
 
24
 
#ifdef HAVE_UNISTD_H
25
 
#include <unistd.h>
26
 
#endif
27
 
 
28
 
#ifndef O_BINARY
29
 
#ifdef _O_BINARY
30
 
#define O_BINARY _O_BINARY
31
 
#else
32
 
#define O_BINARY 0
33
 
#endif
34
 
#endif
35
 
 
36
 
#ifdef _DEBUG
37
 
#define READ_SIZE 16
38
 
#else
39
 
#define READ_SIZE (1024*8)
40
 
#endif
41
 
 
42
 
 
43
 
typedef struct {
44
 
  XML_Parser parser;
45
 
  int *retPtr;
46
 
} PROCESS_ARGS;
47
 
 
48
 
static void
49
 
reportError(XML_Parser parser, const XML_Char *filename)
50
 
{
51
 
  int code = XML_GetErrorCode(parser);
52
 
  const XML_Char *message = XML_ErrorString(code);
53
 
  if (message)
54
 
    ftprintf(stdout, T("%s:%d:%d: %s\n"),
55
 
             filename,
56
 
             XML_GetErrorLineNumber(parser),
57
 
             XML_GetErrorColumnNumber(parser),
58
 
             message);
59
 
  else
60
 
    ftprintf(stderr, T("%s: (unknown message %d)\n"), filename, code);
61
 
}
62
 
 
63
 
static void
64
 
processFile(const void *data, size_t size,
65
 
            const XML_Char *filename, void *args)
66
 
{
67
 
  XML_Parser parser = ((PROCESS_ARGS *)args)->parser;
68
 
  int *retPtr = ((PROCESS_ARGS *)args)->retPtr;
69
 
  if (XML_Parse(parser, data, size, 1) == XML_STATUS_ERROR) {
70
 
    reportError(parser, filename);
71
 
    *retPtr = 0;
72
 
  }
73
 
  else
74
 
    *retPtr = 1;
75
 
}
76
 
 
77
 
#ifdef WIN32
78
 
 
79
 
static int
80
 
isAsciiLetter(XML_Char c)
81
 
{
82
 
  return (T('a') <= c && c <= T('z')) || (T('A') <= c && c <= T('Z'));
83
 
}
84
 
 
85
 
#endif /* WIN32 */
86
 
 
87
 
static const XML_Char *
88
 
resolveSystemId(const XML_Char *base, const XML_Char *systemId,
89
 
                XML_Char **toFree)
90
 
{
91
 
  XML_Char *s;
92
 
  *toFree = 0;
93
 
  if (!base
94
 
      || *systemId == T('/')
95
 
#ifdef WIN32
96
 
      || *systemId == T('\\')
97
 
      || (isAsciiLetter(systemId[0]) && systemId[1] == T(':'))
98
 
#endif
99
 
     )
100
 
    return systemId;
101
 
  *toFree = (XML_Char *)malloc((tcslen(base) + tcslen(systemId) + 2)
102
 
                               * sizeof(XML_Char));
103
 
  if (!*toFree)
104
 
    return systemId;
105
 
  tcscpy(*toFree, base);
106
 
  s = *toFree;
107
 
  if (tcsrchr(s, T('/')))
108
 
    s = tcsrchr(s, T('/')) + 1;
109
 
#ifdef WIN32
110
 
  if (tcsrchr(s, T('\\')))
111
 
    s = tcsrchr(s, T('\\')) + 1;
112
 
#endif
113
 
  tcscpy(s, systemId);
114
 
  return *toFree;
115
 
}
116
 
 
117
 
static int
118
 
externalEntityRefFilemap(XML_Parser parser,
119
 
                         const XML_Char *context,
120
 
                         const XML_Char *base,
121
 
                         const XML_Char *systemId,
122
 
                         const XML_Char *publicId)
123
 
{
124
 
  int result;
125
 
  XML_Char *s;
126
 
  const XML_Char *filename;
127
 
  XML_Parser entParser = XML_ExternalEntityParserCreate(parser, context, 0);
128
 
  PROCESS_ARGS args;
129
 
  args.retPtr = &result;
130
 
  args.parser = entParser;
131
 
  filename = resolveSystemId(base, systemId, &s);
132
 
  XML_SetBase(entParser, filename);
133
 
  if (!filemap(filename, processFile, &args))
134
 
    result = 0;
135
 
  free(s);
136
 
  XML_ParserFree(entParser);
137
 
  return result;
138
 
}
139
 
 
140
 
static int
141
 
processStream(const XML_Char *filename, XML_Parser parser)
142
 
{
143
 
  /* passing NULL for filename means read intput from stdin */
144
 
  int fd = 0;   /* 0 is the fileno for stdin */
145
 
 
146
 
  if (filename != NULL) {
147
 
    fd = topen(filename, O_BINARY|O_RDONLY);
148
 
    if (fd < 0) {
149
 
      tperror(filename);
150
 
      return 0;
151
 
    }
152
 
  }
153
 
  for (;;) {
154
 
    int nread;
155
 
    char *buf = XML_GetBuffer(parser, READ_SIZE);
156
 
    if (!buf) {
157
 
      if (filename != NULL)
158
 
        close(fd);
159
 
      ftprintf(stderr, T("%s: out of memory\n"),
160
 
               filename != NULL ? filename : "xmlwf");
161
 
      return 0;
162
 
    }
163
 
    nread = read(fd, buf, READ_SIZE);
164
 
    if (nread < 0) {
165
 
      tperror(filename != NULL ? filename : "STDIN");
166
 
      if (filename != NULL)
167
 
        close(fd);
168
 
      return 0;
169
 
    }
170
 
    if (XML_ParseBuffer(parser, nread, nread == 0) == XML_STATUS_ERROR) {
171
 
      reportError(parser, filename != NULL ? filename : "STDIN");
172
 
      if (filename != NULL)
173
 
        close(fd);
174
 
      return 0;
175
 
    }
176
 
    if (nread == 0) {
177
 
      if (filename != NULL)
178
 
        close(fd);
179
 
      break;;
180
 
    }
181
 
  }
182
 
  return 1;
183
 
}
184
 
 
185
 
static int
186
 
externalEntityRefStream(XML_Parser parser,
187
 
                        const XML_Char *context,
188
 
                        const XML_Char *base,
189
 
                        const XML_Char *systemId,
190
 
                        const XML_Char *publicId)
191
 
{
192
 
  XML_Char *s;
193
 
  const XML_Char *filename;
194
 
  int ret;
195
 
  XML_Parser entParser = XML_ExternalEntityParserCreate(parser, context, 0);
196
 
  filename = resolveSystemId(base, systemId, &s);
197
 
  XML_SetBase(entParser, filename);
198
 
  ret = processStream(filename, entParser);
199
 
  free(s);
200
 
  XML_ParserFree(entParser);
201
 
  return ret;
202
 
}
203
 
 
204
 
int
205
 
XML_ProcessFile(XML_Parser parser,
206
 
                const XML_Char *filename,
207
 
                unsigned flags)
208
 
{
209
 
  int result;
210
 
 
211
 
  if (!XML_SetBase(parser, filename)) {
212
 
    ftprintf(stderr, T("%s: out of memory"), filename);
213
 
    exit(1);
214
 
  }
215
 
 
216
 
  if (flags & XML_EXTERNAL_ENTITIES)
217
 
      XML_SetExternalEntityRefHandler(parser,
218
 
                                      (flags & XML_MAP_FILE)
219
 
                                      ? externalEntityRefFilemap
220
 
                                      : externalEntityRefStream);
221
 
  if (flags & XML_MAP_FILE) {
222
 
    PROCESS_ARGS args;
223
 
    args.retPtr = &result;
224
 
    args.parser = parser;
225
 
    if (!filemap(filename, processFile, &args))
226
 
      result = 0;
227
 
  }
228
 
  else
229
 
    result = processStream(filename, parser);
230
 
  return result;
231
 
}