1 versit.h |
1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.symbianfoundation.org/legal/licencesv10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // |
|
15 |
|
16 #ifndef __VERSIT_H__ |
|
17 #define __VERSIT_H__ |
|
18 |
|
19 // System includes |
|
20 #include <e32base.h> |
|
21 #include <badesca.h> |
|
22 #include <s32file.h> |
|
23 |
|
24 // User includes |
|
25 #include <vuid.h> |
|
26 #include <vtoken.h> |
|
27 #include <vprop.h> |
|
28 #include <versittls.h> |
|
29 |
|
30 // Classes referenced |
|
31 class RFile; |
|
32 class TVersitDateTime; |
|
33 class MVersitObserver; |
|
34 class MVersitPlugIn; |
|
35 |
|
36 // Panic enumeration |
|
37 /** Versit panic numbers. The Versit panic numbers have a category of "Versit-Parser". |
|
38 @internalComponent |
|
39 @released |
|
40 */ |
|
41 enum TVersitParserPanic |
|
42 { |
|
43 ECurrentTokenNotFound, //Unused |
|
44 EUnicodeUtilsNotFound, //Unused |
|
45 ENoPropertyValue, //Unused |
|
46 /** A CWeekDayArray contains an invalid value (not between EMonday |
|
47 and ESunday inclusive). */ |
|
48 ENoWeekdayFound, |
|
49 /** The number of a week within a month is invalid. */ |
|
50 EWeekNoOverTen, |
|
51 /** The repeat type for a recurrence rule property value is not one of the values |
|
52 specified in CVersitRecurrence::TType. */ |
|
53 ENoRecognizedRepeatType, |
|
54 EVersitPanicEscapedTextAlreadyExists, //Unused |
|
55 /** 8-bit encoding is proposed as the default for a parser but may not be appropriate. */ |
|
56 EVersitPanicCannotSetEightBitEncoding, |
|
57 /** 8-bit encoding is encountered or proposed where it is not expected. */ |
|
58 EVersitPanicUnexpectedEightBitEncoding, |
|
59 /** A parser was not specified when externalising a property. */ |
|
60 EVersitPanicNeedToSpecifyParser, |
|
61 /** The additional storage slot for the given property has already been used */ |
|
62 EVersitPanicAdditionalStorageSlotAlreadyInUse, |
|
63 /** Attempting to assign a NULL value to an additional storage slot */ |
|
64 EVersitPanicNullValueAssignedToAdditionalStorageSlot, |
|
65 // |
|
66 EVersitPanicLast |
|
67 }; |
|
68 |
|
69 /** |
|
70 Used as key into additional storage within tls object, for CVersitTLSContainer |
|
71 Value should not conflict with genuine compiler generated pointer values |
|
72 */ |
|
73 const static TInt* const KTLSVars = reinterpret_cast<TInt*>(1); |
|
74 |
|
75 GLREF_C void DestroyHBufC(TAny* aHBufC); |
|
76 IMPORT_C void Panic(TVersitParserPanic aPanic); |
|
77 |
|
78 |
|
79 /** Extension mechanism for CLineReader |
|
80 This is an internal class and is only for use by CLineReader |
|
81 @internalComponent |
|
82 @released |
|
83 */ |
|
84 class CLineReaderExtension : public CBase |
|
85 { |
|
86 friend class CLineReader; |
|
87 private: |
|
88 CLineReaderExtension(); |
|
89 static CLineReaderExtension* NewL(); |
|
90 private: |
|
91 TUint8 iBuf[1024]; |
|
92 TInt iOffset; |
|
93 TInt iSize; |
|
94 }; |
|
95 |
|
96 class CLineReader : public CBase |
|
97 /** Line reader for a vCalendar or vCard parser. |
|
98 |
|
99 Reads in a line at a time for the parser. |
|
100 |
|
101 Also allows the first character of the next line to be checked to see if it |
|
102 is a space, which can indicate that the line is wrapped. This enables the |
|
103 reading of multi-line property values. |
|
104 |
|
105 Used by CVersitParser to internalise streams. |
|
106 @publishedAll |
|
107 @released |
|
108 */ |
|
109 { |
|
110 public: |
|
111 /** Defines the initial line size of, and the size of expansions to, the buffer |
|
112 which stores the line being read. */ |
|
113 enum |
|
114 { |
|
115 /** The initial size of the buffer (pointed to by iBuf). */ |
|
116 EInitialLineSize=96, |
|
117 /** The size by which the buffer (pointed to by iBuf) |
|
118 is expanded when it has run out of room. */ |
|
119 EExpandSize=16, |
|
120 }; |
|
121 /** Defines values which describe the content of a line that has been read. |
|
122 |
|
123 This is the return value from the function ReadLine(). */ |
|
124 enum |
|
125 { |
|
126 /** The line has content (not white space). */ |
|
127 ELineHasContent=0, |
|
128 /** The line has white space only. */ |
|
129 ELineIsWhiteSpace=1, //Doesn't include next case |
|
130 /** The line has no content, and so is just a carriage return and line |
|
131 feed ("/r/n"). */ |
|
132 ELineIsCRLFOnly=2, |
|
133 }; |
|
134 public: |
|
135 IMPORT_C static CLineReader* NewL(RReadStream& aStream); |
|
136 IMPORT_C ~CLineReader(); |
|
137 IMPORT_C virtual TBool ReadLineL(TInt aPos,TInt& aErr); |
|
138 IMPORT_C TBool AppendLineIfSpaceNextL(); |
|
139 IMPORT_C TBool IsSpaceNextL(); |
|
140 IMPORT_C TInt AppendSpaceL(); |
|
141 inline void SetPlugIn(MVersitPlugIn* aPlugIn); |
|
142 inline void SetSkipWhiteSpaceAtStart(TBool aDoSkip); |
|
143 protected: |
|
144 inline CLineReader(RReadStream& aStream) :iReadStream(&aStream), iBufPtr(NULL,0), iFirstCharNextLine(-1) {} |
|
145 IMPORT_C void ConstructL(); |
|
146 IMPORT_C void ExpandBufferL(TInt aCurrentSize); |
|
147 IMPORT_C TUint8 ReadChar(TInt& aErr); |
|
148 private: |
|
149 IMPORT_C virtual void Reserved(); |
|
150 public: |
|
151 /** A pointer to an RReadStream object, the ReadUint8L() function of which is used |
|
152 to read single characters from the stream. |
|
153 |
|
154 This is passed into the NewL() function upon construction. */ |
|
155 RReadStream* iReadStream; |
|
156 /** A pointer to a buffer which stores data read from the stream. |
|
157 |
|
158 Its size on construction is EInitialLineSize, and it is expanded by EExpandSize |
|
159 when necessary. |
|
160 |
|
161 A copy of this value should not be stored, since the buffer location may change |
|
162 if the buffer is expanded. |
|
163 |
|
164 Data in the buffer is not lost when the buffer is expanded, but is copied |
|
165 to the new location. */ |
|
166 TPtr8 iBufPtr; |
|
167 protected: |
|
168 HBufC8* iLineBuf; |
|
169 TInt iFirstCharNextLine; |
|
170 private: |
|
171 MVersitPlugIn* iPlugIn; |
|
172 TBool iSkipWhiteSpaceAtStart; |
|
173 CLineReaderExtension* iExtension; |
|
174 }; |
|
175 |
|
176 class CVersitParser : public CBase |
|
177 /** A generic Versit parser. |
|
178 |
|
179 Provides generic functions which implement behaviour common to both vCalendar |
|
180 and vCard parsers. For instance: |
|
181 |
|
182 - InternalizeL() and ExternalizeL() functions, for writing and reading |
|
183 data from a stream or file. |
|
184 |
|
185 - adding/retrieving properties and sub-entities to/from an existing entity. |
|
186 |
|
187 - encoding and character set conversion capabilities. |
|
188 |
|
189 Although this is not an abstract class, in practice you would create and use |
|
190 objects of a derived class instead (CParserVCal or CParserVCard), as these |
|
191 provide additional functionality needed for parsing vCalendars and vCards. |
|
192 |
|
193 Note: a flag used in the class constructor indicates whether the entity needs |
|
194 a version property. The version property will be inserted at the start of |
|
195 the array of properties for the entity, and specifies the version of the vCard/vCalendar |
|
196 specification used by the data of this particular vCard/vCalendar. The versions |
|
197 that are currently supported are vCard v2.1 and vCalendar v1.0. |
|
198 |
|
199 A typical vCard looks like this: |
|
200 |
|
201 BEGIN VCARD |
|
202 |
|
203 VERSION 2.1 ... |
|
204 |
|
205 END VCARD |
|
206 |
|
207 Note: if you are sequentially creating and destroying multiple |
|
208 parsers, a major performance improvement may be achieved |
|
209 by using thread local storage to store an instance of CVersitUnicodeUtils |
|
210 which persists and can be used by all of the parsers. |
|
211 |
|
212 See CVersitTlsData for more details. |
|
213 @publishedAll |
|
214 @released |
|
215 */ |
|
216 { |
|
217 friend class CParserProperty; |
|
218 public: |
|
219 IMPORT_C CVersitParser(TUint aFlags); |
|
220 IMPORT_C void ConstructL(); |
|
221 IMPORT_C ~CVersitParser(); |
|
222 IMPORT_C void InternalizeL(RFile& aInputFile,TInt& aBytesThroughFile); |
|
223 IMPORT_C virtual void InternalizeL(RReadStream& aStream); |
|
224 IMPORT_C virtual void InternalizeL(HBufC* aEntityName,CLineReader* aLineReader); |
|
225 IMPORT_C void ExternalizeL(RFile& aOutputFile); |
|
226 IMPORT_C virtual void ExternalizeL(RWriteStream& aStream); |
|
227 IMPORT_C void AddEntityL(CVersitParser* aEntity); |
|
228 IMPORT_C void AddPropertyL(CParserProperty* aProperty,TBool aInternalizing=EFalse); |
|
229 IMPORT_C CArrayPtr<CVersitParser>* EntityL(const TDesC& aEntityName,TBool aTakeOwnership=ETrue); |
|
230 IMPORT_C CArrayPtr<CVersitParser>* ArrayOfEntities(TBool aTakeOwnership=ETrue); |
|
231 IMPORT_C CArrayPtr<CParserProperty>* PropertyL(const TDesC8& aPropertyName,const TUid& aPropertyUid,TBool aTakeOwnership=ETrue) const; |
|
232 IMPORT_C CArrayPtr<CParserProperty>* ArrayOfProperties(TBool aTakeOwnership=ETrue); |
|
233 IMPORT_C virtual void ConvertAllPropertyDateTimesToMachineLocalL(const TTimeIntervalSeconds& aIncrement,const CVersitDaylight* aDaylight); |
|
234 IMPORT_C void AdjustAllPropertyDateTimesToMachineLocalL(); |
|
235 IMPORT_C static TBool IsValidParameterValue(TInt& aPos,const TDesC& aParamValue); |
|
236 IMPORT_C void SetEntityNameL(const TDesC& aEntityName); |
|
237 IMPORT_C TPtrC EntityName() const; |
|
238 IMPORT_C static TBool IsValidLabel(const TDesC& aLabel, TInt& aPos); |
|
239 IMPORT_C static TInt Val(const TDesC& aString, TInt& aNumber); |
|
240 IMPORT_C void SetCharacterConverter(Versit::TEncodingAndCharset& encodingAndCharset); |
|
241 |
|
242 // |
|
243 // Set/Get the default settings for the [en|de]coding process |
|
244 // |
|
245 IMPORT_C Versit::TVersitEncoding DefaultEncoding() const; |
|
246 IMPORT_C void SetDefaultEncoding(const Versit::TVersitEncoding aEncoding); |
|
247 IMPORT_C Versit::TVersitCharSet DefaultCharSet() const; |
|
248 IMPORT_C TUint DefaultCharSetId() const; |
|
249 IMPORT_C void SetDefaultCharSet(const Versit::TVersitCharSet aCharSet); |
|
250 IMPORT_C void SetDefaultCharSetId(TUint aCharSetId); |
|
251 IMPORT_C void SetAutoDetect(TBool aOn,const CArrayFix<CCnvCharacterSetConverter::SCharacterSet>* aAutoDetectCharSets=NULL); |
|
252 |
|
253 // |
|
254 // Set/Get Observers and PlugIn's |
|
255 // |
|
256 inline void SetObserver(MVersitObserver* aObserver); |
|
257 inline MVersitObserver* Observer(); |
|
258 inline void SetPlugIn(MVersitPlugIn* aPlugIn); |
|
259 inline MVersitPlugIn* PlugIn(); |
|
260 |
|
261 public: |
|
262 |
|
263 IMPORT_C TInt LoadBinaryValuesFromFilesL(); |
|
264 IMPORT_C TInt LoadBinaryValuesFromFilesL(RFs& aFileSession); |
|
265 IMPORT_C TInt SaveBinaryValuesToFilesL(TInt aSizeThreshold,const TDesC& aPath); |
|
266 IMPORT_C TInt SaveBinaryValuesToFilesL(TInt aSizeThreshold,const TDesC& aPath,RFs& aFileSession); |
|
267 public: |
|
268 /** White space character codes: used while analysing the syntax of the received |
|
269 data and while externalising data. |
|
270 @publishedAll |
|
271 @released |
|
272 */ |
|
273 enum TCharCodes |
|
274 { |
|
275 /** ' ' */ |
|
276 ESpace = ' ', |
|
277 /** 9 */ |
|
278 EHTab = 9, |
|
279 /** 10 */ |
|
280 ELineFeed = 10, |
|
281 /** 13 */ |
|
282 ECarriageReturn = 13 |
|
283 }; |
|
284 /** Flags that can be specified on construction. |
|
285 @publishedAll |
|
286 @released |
|
287 */ |
|
288 enum TVersitParserFlags |
|
289 { |
|
290 /** This entity does not need a version property. */ |
|
291 ENoVersionProperty = 0, |
|
292 /** This entity should have a version property. */ |
|
293 ESupportsVersion = 0x01, |
|
294 //Gaps since other flags have been used in past |
|
295 EImportSyncML = 0x1000, //Importing from a SyncML server |
|
296 /** Indicates whether the parser should use auto-detection of character sets when |
|
297 one has not been explicitly specified. */ |
|
298 EUseAutoDetection = 0x4000, |
|
299 //versit Internal use only |
|
300 /** The current property has specified a character set. */ |
|
301 ECharSetIdentified = 0x8000, |
|
302 /** If the charset is not explicitly specified, the default charset will be used instead of US-ASCII as required |
|
303 by the Versit specification . */ |
|
304 EUseDefaultCharSetForAllProperties = 0x2000 |
|
305 }; |
|
306 |
|
307 // |
|
308 // Unicode support conversion functions |
|
309 // |
|
310 IMPORT_C static TInt ConvertFromUnicodeToISOL(TDes8& aIso, const TDesC16& aUnicode, CCnvCharacterSetConverter* aConverter); |
|
311 IMPORT_C TVersitDateTime* DecodeDateTimeL(TDes& aToken) const; |
|
312 |
|
313 protected: |
|
314 IMPORT_C TInt ConvertToUnicodeFromISOL(TDes16& aUnicode, const TDesC8& aIso, TUint aCharacterSet); |
|
315 |
|
316 // |
|
317 // Parsing high level functions |
|
318 // |
|
319 IMPORT_C void ParsePropertiesL(); |
|
320 IMPORT_C void ParseBeginL(); |
|
321 IMPORT_C void ParseEndL(); |
|
322 void ParseEndL(HBufC16& aEntityName); |
|
323 IMPORT_C TBool ParseEntityL(); |
|
324 IMPORT_C virtual void ParsePropertyL(); |
|
325 IMPORT_C CArrayPtr<CParserParam>* ReadLineAndDecodeParamsLC(TInt& aValueStart,TInt& aNameLen); |
|
326 IMPORT_C void MakePropertyL(TPtr8& aPropName,TInt aValueStart); |
|
327 IMPORT_C CArrayPtr<CParserParam>* GetPropertyParamsLC(TPtr8 aParams); |
|
328 IMPORT_C void ParseParamL(CArrayPtr<CParserParam>* aArray,TPtr8 aParam); |
|
329 IMPORT_C void AnalysesEncodingCharset(CArrayPtr<CParserParam>* aArrayOfParams); |
|
330 IMPORT_C void ReadMultiLineValueL(TPtr8& aValue,TInt aValueStart,TBool aBinaryData); |
|
331 inline TPtr8& BufPtr(); |
|
332 |
|
333 // |
|
334 // Append standard versit tokens to streams |
|
335 // |
|
336 IMPORT_C void AppendBeginL(); |
|
337 IMPORT_C void AppendEndL(); |
|
338 void AppendEntityNameL(); |
|
339 IMPORT_C void DoAddPropertyL(CParserProperty* aProperty); |
|
340 |
|
341 // |
|
342 // Dispatcher functions to create entities/properties based upon a Versit identifying Uid |
|
343 // |
|
344 IMPORT_C virtual CVersitParser* MakeEntityL(TInt aEntityUid,HBufC* aEntityName); |
|
345 CParserPropertyValueHBufC* MakeDefaultPropertyValueL(HBufC16*& aValue); |
|
346 IMPORT_C virtual CParserPropertyValue* MakePropertyValueL(const TUid& aPropertyUid,HBufC16*& aValue); |
|
347 IMPORT_C HBufC* DecodePropertyValueL(const TDesC8& aValue); |
|
348 IMPORT_C void DecodePropertyValueL(const TDesC8& aValue,const TUid& aEncodingUid); |
|
349 HBufC* ConvertToUnicodeL(const TDesC8& aValue); |
|
350 IMPORT_C CDesCArray* MakePropertyValueCDesCArrayL(TPtr16 aStringValue); |
|
351 IMPORT_C CArrayPtr<TVersitDateTime>* MakePropertyValueMultiDateTimeL(TPtr16 aDateTimeGroup); |
|
352 IMPORT_C CVersitDaylight* MakePropertyValueDaylightL(TPtr16 aDaylightValue); |
|
353 IMPORT_C TBool FindFirstField(TPtr16& aField,TPtr16& aRemaining, TBool aTrimSpace=ETrue); |
|
354 IMPORT_C void FindRemainingField(TPtr16& aField,TPtr16& aRemaining); |
|
355 |
|
356 // |
|
357 // Helper methods to decode versit dates, times, and time periods |
|
358 // |
|
359 IMPORT_C TTimeIntervalSeconds DecodeTimeZoneL(const TDesC& aToken) const; |
|
360 IMPORT_C TTime* DecodeTimePeriodL(const TDesC& aToken) const; |
|
361 IMPORT_C TInt GetNumberL(const TDesC& aToken,TInt& aNumChars) const; |
|
362 |
|
363 public: |
|
364 IMPORT_C virtual TUid RecognizeToken(const TDesC8& aToken) const; |
|
365 IMPORT_C virtual TInt RecognizeEntityName() const; |
|
366 // |
|
367 // Cleanup support methods |
|
368 // |
|
369 IMPORT_C static void ResetAndDestroyArrayOfParams(TAny* aObject); |
|
370 IMPORT_C static void ResetAndDestroyArrayOfProperties(TAny* aObject); |
|
371 IMPORT_C static void ResetAndDestroyArrayOfEntities(TAny* aObject); |
|
372 IMPORT_C static void ResetAndDestroyArrayOfDateTimes(TAny* aObject); |
|
373 |
|
374 inline void SetFlags(TUint aFlags); |
|
375 |
|
376 |
|
377 |
|
378 protected: |
|
379 // |
|
380 // Enquiry functions |
|
381 // |
|
382 static TBool IsPunctuationToken(TUint aChar); |
|
383 inline TBool SupportsVersion() const; |
|
384 inline void SetSupportsVersion(); |
|
385 inline void ClearSupportsVersion(); |
|
386 |
|
387 // |
|
388 // Set the settings for the [en|de]coding of the current property |
|
389 // |
|
390 IMPORT_C void RestoreLineCodingDetailsToDefault(); |
|
391 IMPORT_C void SetLineEncoding(Versit::TVersitEncoding aLineEncoding); |
|
392 IMPORT_C void SetLineEncoding(TUint aVersitEncodingUid); |
|
393 IMPORT_C void SetLineCharacterSet(Versit::TVersitCharSet aLineCharSet); |
|
394 IMPORT_C void SetLineCharacterSetId(TUint aLineCharSetId); |
|
395 IMPORT_C void SetLineCoding(Versit::TVersitCharSet aLineCharSet, Versit::TVersitEncoding aLineEncoding); |
|
396 |
|
397 // |
|
398 // Return the settings for the current property |
|
399 // |
|
400 IMPORT_C Versit::TVersitEncoding LineEncoding() const; |
|
401 IMPORT_C Versit::TVersitCharSet LineCharSet() const; |
|
402 IMPORT_C TUint LineEncodingId() const; |
|
403 IMPORT_C TUint LineCharSetId() const; |
|
404 |
|
405 inline CVersitUnicodeUtils& UnicodeUtils(); |
|
406 |
|
407 public: |
|
408 // |
|
409 // Static utility functions to aid with the Unicode conversion process |
|
410 // |
|
411 static TUint MapVersitCharsetToCharConvCharset(Versit::TVersitCharSet aVersitSet); |
|
412 static TUint MapVersitEncodingToConArcUid(Versit::TVersitEncoding aVersitEncoding); |
|
413 |
|
414 private: |
|
415 void SetLineCharsetDetailsToDefault(); |
|
416 void SetLineEncodingDetailsToDefault(); |
|
417 |
|
418 private: //To fix TimeZone SyncML bug |
|
419 void ConvertAllUTCDateTimesToMachineLocalL(const TTimeIntervalSeconds& aIncrement,const CVersitDaylight* aDaylight); |
|
420 void ConvertUTCDateTimeToMachineLocal(TVersitDateTime* aDateTime,const TTimeIntervalSeconds& aIncrement,const CVersitDaylight* aDaylight); |
|
421 //void AddTimeZonePropertyL(); |
|
422 |
|
423 protected: |
|
424 struct TParserCodingDetails |
|
425 { |
|
426 Versit::TVersitEncoding iEncoding; |
|
427 TUint iEncodingUid; |
|
428 Versit::TVersitCharSet iCharSet; |
|
429 TUint iCharSetUid; |
|
430 }; |
|
431 |
|
432 protected: |
|
433 // Default settings & internal flags |
|
434 TInt iFlags; |
|
435 TParserCodingDetails iDefaultCodingDetails; |
|
436 TParserCodingDetails iCurrentPropertyCodingDetails; |
|
437 TBuf<KVersitMaxVersionLength> iDefaultVersion; |
|
438 const CArrayFix<CCnvCharacterSetConverter::SCharacterSet>* iAutoDetectCharSets; |
|
439 |
|
440 // Member data relating to the current item being parsed |
|
441 HBufC* iEntityName; |
|
442 CArrayPtr<CVersitParser>* iArrayOfEntities; |
|
443 CArrayPtr<CParserProperty>* iArrayOfProperties; |
|
444 CParserProperty* iCurrentProperty; |
|
445 CLineReader* iOwnedLineReader; |
|
446 CLineReader* iLineReader; |
|
447 HBufC8* iDecodedValue; |
|
448 CBufSeg* iLargeDataBuf; |
|
449 |
|
450 // In memory buffers |
|
451 RWriteStream* iWriteStream; |
|
452 |
|
453 // General utility class |
|
454 CVersitTlsData* iStaticUtils; |
|
455 |
|
456 // Plug-in classes |
|
457 MVersitObserver* iObserver; |
|
458 MVersitPlugIn* iPlugIn; |
|
459 |
|
460 private: |
|
461 void DoInternalizeL(); |
|
462 IMPORT_C virtual void Reserved1(); |
|
463 IMPORT_C virtual void Reserved2(); |
|
464 private: |
|
465 TInt iParseBegin; |
|
466 TInt iReserved2; |
|
467 }; |
|
468 |
|
469 NONSHARABLE_CLASS( CVersitTLSContainer ): public CBase |
|
470 /** |
|
471 Wrapper class for static variables to be stored in TLS |
|
472 @internalComponent |
|
473 @released |
|
474 */ |
|
475 { |
|
476 public: |
|
477 static CVersitTLSContainer *NewLC(const TInt aSize); |
|
478 ~CVersitTLSContainer(); |
|
479 public: |
|
480 HBufC * iShiftJisEscape;//Store shift-jis escape charcter, as generated by relevant charconv plugin |
|
481 }; |
|
482 |
|
483 #include <versit.inl> |
|
484 |
|
485 #endif |