Line data Source code
1 : /******************************************************************************
2 : *
3 : * Project: DXF Translator
4 : * Purpose: Implements low level DXF reading with caching and parsing of
5 : * of the code/value pairs.
6 : * Author: Frank Warmerdam, warmerdam@pobox.com
7 : *
8 : ******************************************************************************
9 : * Copyright (c) 2009, Frank Warmerdam <warmerdam@pobox.com>
10 : *
11 : * SPDX-License-Identifier: MIT
12 : ****************************************************************************/
13 :
14 : #include "ogr_dxf.h"
15 : #include "cpl_conv.h"
16 : #include "cpl_string.h"
17 : #include "cpl_csv.h"
18 :
19 : /************************************************************************/
20 : /* OGRDXFReader() */
21 : /************************************************************************/
22 :
23 356 : OGRDXFReader::OGRDXFReader()
24 : : fp(nullptr), iSrcBufferOffset(0), nSrcBufferBytes(0),
25 356 : iSrcBufferFileOffset(0), achSrcBuffer{}, nLastValueSize(0), nLineNumber(0)
26 : {
27 356 : }
28 :
29 : /************************************************************************/
30 : /* ~OGRDXFReader() */
31 : /************************************************************************/
32 :
33 356 : OGRDXFReader::~OGRDXFReader()
34 :
35 : {
36 356 : }
37 :
38 : /************************************************************************/
39 : /* Initialize() */
40 : /************************************************************************/
41 :
42 356 : void OGRDXFReader::Initialize(VSILFILE *fpIn)
43 :
44 : {
45 356 : fp = fpIn;
46 356 : }
47 :
48 : /************************************************************************/
49 : /* ResetReadPointer() */
50 : /************************************************************************/
51 :
52 242 : void OGRDXFReader::ResetReadPointer(unsigned int iNewOffset,
53 : int nNewLineNumber /* = 0 */)
54 :
55 : {
56 242 : nSrcBufferBytes = 0;
57 242 : iSrcBufferOffset = 0;
58 242 : iSrcBufferFileOffset = iNewOffset;
59 242 : nLastValueSize = 0;
60 242 : nLineNumber = nNewLineNumber;
61 :
62 242 : VSIFSeekL(fp, iNewOffset, SEEK_SET);
63 242 : }
64 :
65 : /************************************************************************/
66 : /* LoadDiskChunk() */
67 : /* */
68 : /* Load another block (512 bytes) of input from the source */
69 : /* file. */
70 : /************************************************************************/
71 :
72 20762 : void OGRDXFReader::LoadDiskChunk()
73 :
74 : {
75 20762 : if (nSrcBufferBytes - iSrcBufferOffset > 511)
76 0 : return;
77 :
78 20762 : if (iSrcBufferOffset > 0)
79 : {
80 20112 : CPLAssert(nSrcBufferBytes <= 1024);
81 20112 : CPLAssert(iSrcBufferOffset <= nSrcBufferBytes);
82 :
83 20112 : memmove(achSrcBuffer, achSrcBuffer + iSrcBufferOffset,
84 20112 : nSrcBufferBytes - iSrcBufferOffset);
85 20112 : iSrcBufferFileOffset += iSrcBufferOffset;
86 20112 : nSrcBufferBytes -= iSrcBufferOffset;
87 20112 : iSrcBufferOffset = 0;
88 : }
89 :
90 20762 : nSrcBufferBytes +=
91 20762 : static_cast<int>(VSIFReadL(achSrcBuffer + nSrcBufferBytes, 1, 512, fp));
92 20762 : achSrcBuffer[nSrcBufferBytes] = '\0';
93 :
94 20762 : CPLAssert(nSrcBufferBytes <= 1024);
95 20762 : CPLAssert(iSrcBufferOffset <= nSrcBufferBytes);
96 : }
97 :
98 : /************************************************************************/
99 : /* ReadValue() */
100 : /* */
101 : /* Read one type code and value line pair from the DXF file. */
102 : /************************************************************************/
103 :
104 195119 : int OGRDXFReader::ReadValueRaw(char *pszValueBuf, int nValueBufSize)
105 :
106 : {
107 : /* -------------------------------------------------------------------- */
108 : /* Make sure we have lots of data in our buffer for one value. */
109 : /* -------------------------------------------------------------------- */
110 195119 : if (nSrcBufferBytes - iSrcBufferOffset < 512)
111 20759 : LoadDiskChunk();
112 :
113 : /* -------------------------------------------------------------------- */
114 : /* Capture the value code, and skip past it. */
115 : /* -------------------------------------------------------------------- */
116 195119 : unsigned int iStartSrcBufferOffset = iSrcBufferOffset;
117 195119 : int nValueCode = atoi(achSrcBuffer + iSrcBufferOffset);
118 :
119 195119 : nLineNumber++;
120 :
121 : // proceed to newline.
122 1957380 : while (achSrcBuffer[iSrcBufferOffset] != '\n' &&
123 780087 : achSrcBuffer[iSrcBufferOffset] != '\r' &&
124 585198 : achSrcBuffer[iSrcBufferOffset] != '\0')
125 584968 : iSrcBufferOffset++;
126 :
127 195119 : if (achSrcBuffer[iSrcBufferOffset] == '\0')
128 230 : return -1;
129 :
130 : // skip past newline. CR, CRLF, or LFCR
131 194889 : if ((achSrcBuffer[iSrcBufferOffset] == '\r' &&
132 7131 : achSrcBuffer[iSrcBufferOffset + 1] == '\n') ||
133 187774 : (achSrcBuffer[iSrcBufferOffset] == '\n' &&
134 187758 : achSrcBuffer[iSrcBufferOffset + 1] == '\r'))
135 7116 : iSrcBufferOffset += 2;
136 : else
137 187773 : iSrcBufferOffset += 1;
138 :
139 194889 : if (achSrcBuffer[iSrcBufferOffset] == '\0')
140 0 : return -1;
141 :
142 : /* -------------------------------------------------------------------- */
143 : /* Capture the value string. */
144 : /* -------------------------------------------------------------------- */
145 194889 : unsigned int iEOL = iSrcBufferOffset;
146 389778 : CPLString osValue;
147 :
148 194889 : nLineNumber++;
149 :
150 : // proceed to newline.
151 1496170 : while (achSrcBuffer[iEOL] != '\n' && achSrcBuffer[iEOL] != '\r' &&
152 1301280 : achSrcBuffer[iEOL] != '\0')
153 1301280 : iEOL++;
154 :
155 194889 : bool bLongLine = false;
156 194891 : while (achSrcBuffer[iEOL] == '\0' ||
157 194888 : (achSrcBuffer[iEOL] == '\r' && achSrcBuffer[iEOL + 1] == '\0'))
158 : {
159 : // The line is longer than the buffer (or the line ending is split at
160 : // end of buffer). Let's copy what we have so far into our string, and
161 : // read more
162 3 : const auto nValueLength = osValue.length();
163 :
164 3 : if (nValueLength + iEOL - iSrcBufferOffset > 1048576)
165 : {
166 0 : CPLError(CE_Failure, CPLE_AppDefined, "Line %d is too long",
167 : nLineNumber);
168 0 : return -1;
169 : }
170 :
171 3 : osValue.resize(nValueLength + iEOL - iSrcBufferOffset, '\0');
172 3 : std::copy(achSrcBuffer + iSrcBufferOffset, achSrcBuffer + iEOL,
173 3 : osValue.begin() + nValueLength);
174 :
175 3 : iSrcBufferOffset = iEOL;
176 3 : LoadDiskChunk();
177 3 : iEOL = iSrcBufferOffset;
178 3 : bLongLine = true;
179 :
180 : // Have we prematurely reached the end of the file?
181 3 : if (achSrcBuffer[iEOL] == '\0')
182 1 : return -1;
183 :
184 : // Proceed to newline again
185 437 : while (achSrcBuffer[iEOL] != '\n' && achSrcBuffer[iEOL] != '\r' &&
186 435 : achSrcBuffer[iEOL] != '\0')
187 435 : iEOL++;
188 : }
189 :
190 194888 : size_t nValueBufLen = 0;
191 :
192 : // If this was an extremely long line, copy from osValue into the buffer
193 194888 : if (!osValue.empty())
194 : {
195 2 : strncpy(pszValueBuf, osValue.c_str(), nValueBufSize - 1);
196 2 : pszValueBuf[nValueBufSize - 1] = '\0';
197 :
198 2 : nValueBufLen = strlen(pszValueBuf);
199 :
200 2 : if (static_cast<int>(osValue.length()) > nValueBufSize - 1)
201 : {
202 2 : CPLDebug("DXF", "Long line truncated to %d characters.\n%s...",
203 : nValueBufSize - 1, pszValueBuf);
204 : }
205 : }
206 :
207 : // Copy the last (normally, the only) section of this line into the buffer
208 194888 : if (static_cast<int>(iEOL - iSrcBufferOffset) >
209 194888 : nValueBufSize - static_cast<int>(nValueBufLen) - 1)
210 : {
211 2 : strncpy(pszValueBuf + nValueBufLen, achSrcBuffer + iSrcBufferOffset,
212 2 : nValueBufSize - static_cast<int>(nValueBufLen) - 1);
213 2 : pszValueBuf[nValueBufSize - 1] = '\0';
214 :
215 2 : CPLDebug("DXF", "Long line truncated to %d characters.\n%s...",
216 : nValueBufSize - 1, pszValueBuf);
217 : }
218 : else
219 : {
220 194886 : strncpy(pszValueBuf + nValueBufLen, achSrcBuffer + iSrcBufferOffset,
221 194886 : iEOL - iSrcBufferOffset);
222 194886 : pszValueBuf[nValueBufLen + iEOL - iSrcBufferOffset] = '\0';
223 : }
224 :
225 194888 : iSrcBufferOffset = iEOL;
226 :
227 : // skip past newline. CR, CRLF, or LFCR
228 194888 : if ((achSrcBuffer[iSrcBufferOffset] == '\r' &&
229 7127 : achSrcBuffer[iSrcBufferOffset + 1] == '\n') ||
230 187773 : (achSrcBuffer[iSrcBufferOffset] == '\n' &&
231 187761 : achSrcBuffer[iSrcBufferOffset + 1] == '\r'))
232 7115 : iSrcBufferOffset += 2;
233 : else
234 187773 : iSrcBufferOffset += 1;
235 :
236 : /* -------------------------------------------------------------------- */
237 : /* Record how big this value was, so it can be unread safely. */
238 : /* -------------------------------------------------------------------- */
239 194888 : if (bLongLine)
240 2 : nLastValueSize = 0;
241 : else
242 : {
243 194886 : nLastValueSize = iSrcBufferOffset - iStartSrcBufferOffset;
244 194886 : CPLAssert(nLastValueSize > 0);
245 : }
246 :
247 194888 : return nValueCode;
248 : }
249 :
250 195119 : int OGRDXFReader::ReadValue(char *pszValueBuf, int nValueBufSize)
251 : {
252 : int nValueCode;
253 : while (true)
254 : {
255 195119 : nValueCode = ReadValueRaw(pszValueBuf, nValueBufSize);
256 195119 : if (nValueCode == 999)
257 : {
258 : // Skip comments
259 13 : continue;
260 : }
261 195106 : break;
262 : }
263 195106 : return nValueCode;
264 : }
265 :
266 : /************************************************************************/
267 : /* UnreadValue() */
268 : /* */
269 : /* Unread the last value read, accomplished by resetting the */
270 : /* read pointer. */
271 : /************************************************************************/
272 :
273 2339 : void OGRDXFReader::UnreadValue()
274 :
275 : {
276 2339 : if (nLastValueSize == 0)
277 : {
278 1 : CPLError(CE_Failure, CPLE_AppDefined,
279 : "Cannot UnreadValue(), likely due to a previous long line");
280 1 : return;
281 : }
282 2338 : CPLAssert(iSrcBufferOffset >= nLastValueSize);
283 2338 : CPLAssert(nLastValueSize > 0);
284 :
285 2338 : iSrcBufferOffset -= nLastValueSize;
286 2338 : nLineNumber -= 2;
287 2338 : nLastValueSize = 0;
288 : }
|
