← Back to branch summary

~ubuntu-branches/ubuntu/raring/qtwebkit-source/raring-proposed

« back to all changes in this revision

Viewing changes to Source/WebCore/icu/unicode/ucnv_cb.h

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2013-02-18 14:24:18 UTC
  • Revision ID: package-import@ubuntu.com-20130218142418-eon0jmjg3nj438uy
Tags: upstream-2.3
Import upstream version 2.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
Source/WebCore/icu/unicode/ucnv_cb.h
 
1
/*
 
2
**********************************************************************
 
3
*   Copyright (C) 2000-2004, International Business Machines
 
4
*   Corporation and others.  All Rights Reserved.
 
5
**********************************************************************
 
6
 *  ucnv_cb.h:
 
7
 *  External APIs for the ICU's codeset conversion library
 
8
 *  Helena Shih
 
9
 * 
 
10
 * Modification History:
 
11
 *
 
12
 *   Date        Name        Description
 
13
 */
 
14
 
 
15
/**
 
16
 * \file 
 
17
 * \brief C UConverter functions to aid the writers of callbacks
 
18
 *
 
19
 * <h2> Callback API for UConverter </h2>
 
20
 * 
 
21
 * These functions are provided here for the convenience of the callback
 
22
 * writer. If you are just looking for callback functions to use, please
 
23
 * see ucnv_err.h.  DO NOT call these functions directly when you are 
 
24
 * working with converters, unless your code has been called as a callback
 
25
 * via ucnv_setFromUCallback or ucnv_setToUCallback !!
 
26
 * 
 
27
 * A note about error codes and overflow.  Unlike other ICU functions,
 
28
 * these functions do not expect the error status to be U_ZERO_ERROR.
 
29
 * Callbacks must be much more careful about their error codes.
 
30
 * The error codes used here are in/out parameters, which should be passed
 
31
 * back in the callback's error parameter.
 
32
 * 
 
33
 * For example, if you call ucnv_cbfromUWriteBytes to write data out 
 
34
 * to the output codepage, it may return U_BUFFER_OVERFLOW_ERROR if 
 
35
 * the data did not fit in the target. But this isn't a failing error, 
 
36
 * in fact, ucnv_cbfromUWriteBytes may be called AGAIN with the error
 
37
 * status still U_BUFFER_OVERFLOW_ERROR to attempt to write further bytes,
 
38
 * which will also go into the internal overflow buffers.
 
39
 * 
 
40
 * Concerning offsets, the 'offset' parameters here are relative to the start
 
41
 * of SOURCE.  For example, Suppose the string "ABCD" was being converted 
 
42
 * from Unicode into a codepage which doesn't have a mapping for 'B'.
 
43
 * 'A' will be written out correctly, but
 
44
 * The FromU Callback will be called on an unassigned character for 'B'.
 
45
 * At this point, this is the state of the world:
 
46
 *    Target:    A [..]     [points after A]
 
47
 *    Source:  A B [C] D    [points to C - B has been consumed]
 
48
 *             0 1  2  3 
 
49
 *    codePoint = "B"       [the unassigned codepoint] 
 
50
 * 
 
51
 * Now, suppose a callback wants to write the substitution character '?' to
 
52
 * the target. It calls ucnv_cbFromUWriteBytes() to write the ?. 
 
53
 * It should pass ZERO as the offset, because the offset as far as the 
 
54
 * callback is concerned is relative to the SOURCE pointer [which points 
 
55
 * before 'C'.]  If the callback goes into the args and consumes 'C' also,
 
56
 * it would call FromUWriteBytes with an offset of 1 (and advance the source
 
57
 * pointer).
 
58
 *
 
59
 */
 
60
 
 
61
#ifndef UCNV_CB_H
 
62
#define UCNV_CB_H
 
63
 
 
64
#include "unicode/utypes.h"
 
65
 
 
66
#if !UCONFIG_NO_CONVERSION
 
67
 
 
68
#include "unicode/ucnv.h"
 
69
#include "unicode/ucnv_err.h"
 
70
 
 
71
/**
 
72
 * ONLY used by FromU callback functions.
 
73
 * Writes out the specified byte output bytes to the target byte buffer or to converter internal buffers.
 
74
 *
 
75
 * @param args callback fromUnicode arguments
 
76
 * @param source source bytes to write
 
77
 * @param length length of bytes to write
 
78
 * @param offsetIndex the relative offset index from callback.
 
79
 * @param err error status. If <TT>U_BUFFER_OVERFLOW</TT> is returned, then U_BUFFER_OVERFLOW <STRONG>must</STRONG> 
 
80
 * be returned to the user, because it means that not all data could be written into the target buffer, and some is 
 
81
 * in the converter error buffer.
 
82
 * @see ucnv_cbFromUWriteSub
 
83
 * @stable ICU 2.0
 
84
 */
 
85
U_STABLE void U_EXPORT2
 
86
ucnv_cbFromUWriteBytes (UConverterFromUnicodeArgs *args,
 
87
                        const char* source,
 
88
                        int32_t length,
 
89
                        int32_t offsetIndex,
 
90
                        UErrorCode * err);
 
91
 
 
92
/**
 
93
 * ONLY used by FromU callback functions.  
 
94
 * This function will write out the correct substitution character sequence 
 
95
 * to the target.
 
96
 *
 
97
 * @param args callback fromUnicode arguments
 
98
 * @param offsetIndex the relative offset index from the current source pointer to be used
 
99
 * @param err error status. If <TT>U_BUFFER_OVERFLOW</TT> is returned, then U_BUFFER_OVERFLOW <STRONG>must</STRONG> 
 
100
 * be returned to the user, because it means that not all data could be written into the target buffer, and some is 
 
101
 * in the converter error buffer.
 
102
 * @see ucnv_cbFromUWriteBytes
 
103
 * @stable ICU 2.0
 
104
 */
 
105
U_STABLE void U_EXPORT2 
 
106
ucnv_cbFromUWriteSub (UConverterFromUnicodeArgs *args,
 
107
                      int32_t offsetIndex,
 
108
                      UErrorCode * err);
 
109
 
 
110
/**
 
111
 * ONLY used by fromU callback functions.  
 
112
 * This function will write out the error character(s) to the target UChar buffer.
 
113
 *
 
114
 * @param args callback fromUnicode arguments
 
115
 * @param source pointer to pointer to first UChar to write [on exit: 1 after last UChar processed]
 
116
 * @param sourceLimit pointer after last UChar to write
 
117
 * @param offsetIndex the relative offset index from callback which will be set
 
118
 * @param err error status <TT>U_BUFFER_OVERFLOW</TT>
 
119
 * @see ucnv_cbToUWriteSub
 
120
 * @stable ICU 2.0
 
121
 */
 
122
U_STABLE void U_EXPORT2 ucnv_cbFromUWriteUChars(UConverterFromUnicodeArgs *args,
 
123
                             const UChar** source,
 
124
                             const UChar*  sourceLimit,
 
125
                             int32_t offsetIndex,
 
126
                             UErrorCode * err);
 
127
 
 
128
/**
 
129
 * ONLY used by ToU callback functions.
 
130
 *  This function will write out the specified characters to the target 
 
131
 * UChar buffer.
 
132
 *
 
133
 * @param args callback toUnicode arguments
 
134
 * @param source source string to write
 
135
 * @param length the length of source string
 
136
 * @param offsetIndex the relative offset index which will be written.
 
137
 * @param err error status <TT>U_BUFFER_OVERFLOW</TT>
 
138
 * @see ucnv_cbToUWriteSub
 
139
 * @stable ICU 2.0
 
140
 */
 
141
U_STABLE void U_EXPORT2 ucnv_cbToUWriteUChars (UConverterToUnicodeArgs *args,
 
142
                                             const UChar* source,
 
143
                                             int32_t length,
 
144
                                             int32_t offsetIndex,
 
145
                                             UErrorCode * err);
 
146
 
 
147
/**
 
148
 * ONLY used by ToU  callback functions.  
 
149
 * This function will write out the Unicode substitution character (U+FFFD).
 
150
 *
 
151
 * @param args callback fromUnicode arguments
 
152
 * @param offsetIndex the relative offset index from callback.
 
153
 * @param err error status <TT>U_BUFFER_OVERFLOW</TT>
 
154
 * @see ucnv_cbToUWriteUChars
 
155
 * @stable ICU 2.0
 
156
 */
 
157
U_STABLE void U_EXPORT2 ucnv_cbToUWriteSub (UConverterToUnicodeArgs *args,
 
158
                       int32_t offsetIndex,
 
159
                       UErrorCode * err);
 
160
#endif
 
161
 
 
162
#endif