|
0
|
1 /* |
|
|
2 * Copyright (C) 2004-2012 George Yunaev gyunaev@ulduzsoft.com |
|
|
3 * |
|
|
4 * This library is free software; you can redistribute it and/or modify it |
|
|
5 * under the terms of the GNU Lesser General Public License as published by |
|
|
6 * the Free Software Foundation; either version 3 of the License, or (at your |
|
|
7 * option) any later version. |
|
|
8 * |
|
|
9 * This library is distributed in the hope that it will be useful, but WITHOUT |
|
|
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
|
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public |
|
|
12 * License for more details. |
|
|
13 */ |
|
|
14 |
|
|
15 #include <ctype.h> |
|
|
16 |
|
|
17 #define LIBIRC_COLORPARSER_BOLD (1<<1) |
|
|
18 #define LIBIRC_COLORPARSER_UNDERLINE (1<<2) |
|
|
19 #define LIBIRC_COLORPARSER_REVERSE (1<<3) |
|
|
20 #define LIBIRC_COLORPARSER_COLOR (1<<4) |
|
|
21 |
|
|
22 #define LIBIRC_COLORPARSER_MAXCOLORS 15 |
|
|
23 |
|
|
24 |
|
|
25 static const char * color_replacement_table[] = |
|
|
26 { |
|
|
27 "WHITE", |
|
|
28 "BLACK", |
|
|
29 "DARKBLUE", |
|
|
30 "DARKGREEN", |
|
|
31 "RED", |
|
|
32 "BROWN", |
|
|
33 "PURPLE", |
|
|
34 "OLIVE", |
|
|
35 "YELLOW", |
|
|
36 "GREEN", |
|
|
37 "TEAL", |
|
|
38 "CYAN", |
|
|
39 "BLUE", |
|
|
40 "MAGENTA", |
|
|
41 "DARKGRAY", |
|
|
42 "LIGHTGRAY", |
|
|
43 0 |
|
|
44 }; |
|
|
45 |
|
|
46 |
|
|
47 static inline void libirc_colorparser_addorcat (char ** destline, unsigned int * destlen, const char * str) |
|
|
48 { |
|
|
49 unsigned int len = strlen(str); |
|
|
50 |
|
|
51 if ( *destline ) |
|
|
52 { |
|
|
53 strcpy (*destline, str); |
|
|
54 *destline += len; |
|
|
55 } |
|
|
56 else |
|
|
57 *destlen += len; |
|
|
58 } |
|
|
59 |
|
|
60 |
|
|
61 static void libirc_colorparser_applymask (unsigned int * mask, |
|
|
62 char ** destline, unsigned int * destlen, |
|
|
63 unsigned int bitmask, const char * start, const char * end) |
|
|
64 { |
|
|
65 if ( (*mask & bitmask) != 0 ) |
|
|
66 { |
|
|
67 *mask &= ~bitmask; |
|
|
68 libirc_colorparser_addorcat (destline, destlen, end); |
|
|
69 } |
|
|
70 else |
|
|
71 { |
|
|
72 *mask |= bitmask; |
|
|
73 libirc_colorparser_addorcat (destline, destlen, start); |
|
|
74 } |
|
|
75 } |
|
|
76 |
|
|
77 |
|
|
78 static void libirc_colorparser_applycolor (unsigned int * mask, |
|
|
79 char ** destline, unsigned int * destlen, |
|
|
80 unsigned int colorid, unsigned int bgcolorid) |
|
|
81 { |
|
|
82 const char * end = "[/COLOR]"; |
|
|
83 char startbuf[64]; |
|
|
84 |
|
|
85 if ( bgcolorid != 0 ) |
|
|
86 sprintf (startbuf, "[COLOR=%s/%s]", color_replacement_table[colorid], color_replacement_table[bgcolorid]); |
|
|
87 else |
|
|
88 sprintf (startbuf, "[COLOR=%s]", color_replacement_table[colorid]); |
|
|
89 |
|
|
90 if ( (*mask & LIBIRC_COLORPARSER_COLOR) != 0 ) |
|
|
91 libirc_colorparser_addorcat (destline, destlen, end); |
|
|
92 |
|
|
93 *mask |= LIBIRC_COLORPARSER_COLOR; |
|
|
94 libirc_colorparser_addorcat (destline, destlen, startbuf); |
|
|
95 } |
|
|
96 |
|
|
97 |
|
|
98 static void libirc_colorparser_closetags (unsigned int * mask, |
|
|
99 char ** destline, unsigned int * destlen) |
|
|
100 { |
|
|
101 if ( *mask & LIBIRC_COLORPARSER_BOLD ) |
|
|
102 libirc_colorparser_applymask (mask, destline, destlen, LIBIRC_COLORPARSER_BOLD, 0, "[/B]"); |
|
|
103 |
|
|
104 if ( *mask & LIBIRC_COLORPARSER_UNDERLINE ) |
|
|
105 libirc_colorparser_applymask (mask, destline, destlen, LIBIRC_COLORPARSER_UNDERLINE, 0, "[/U]"); |
|
|
106 |
|
|
107 if ( *mask & LIBIRC_COLORPARSER_REVERSE ) |
|
|
108 libirc_colorparser_applymask (mask, destline, destlen, LIBIRC_COLORPARSER_REVERSE, 0, "[/I]"); |
|
|
109 |
|
|
110 if ( *mask & LIBIRC_COLORPARSER_COLOR ) |
|
|
111 libirc_colorparser_applymask (mask, destline, destlen, LIBIRC_COLORPARSER_COLOR, 0, "[/COLOR]"); |
|
|
112 } |
|
|
113 |
|
|
114 |
|
|
115 |
|
|
116 /* |
|
|
117 * IRC to [code] color conversion. Or strip. |
|
|
118 */ |
|
|
119 static char * libirc_colorparser_irc2code (const char * source, int strip) |
|
|
120 { |
|
|
121 unsigned int mask = 0, destlen = 0; |
|
|
122 char * destline = 0, *d = 0; |
|
|
123 const char *p; |
|
|
124 int current_bg = 0; |
|
|
125 |
|
|
126 /* |
|
|
127 * There will be two passes. First pass calculates the total length of |
|
|
128 * the destination string. The second pass allocates memory for the string, |
|
|
129 * and fills it. |
|
|
130 */ |
|
|
131 while ( destline == 0 ) // destline will be set after the 2nd pass |
|
|
132 { |
|
|
133 if ( destlen > 0 ) |
|
|
134 { |
|
|
135 // This is the 2nd pass; allocate memory. |
|
|
136 if ( (destline = malloc (destlen)) == 0 ) |
|
|
137 return 0; |
|
|
138 |
|
|
139 d = destline; |
|
|
140 } |
|
|
141 |
|
|
142 for ( p = source; *p; p++ ) |
|
|
143 { |
|
|
144 switch (*p) |
|
|
145 { |
|
|
146 case 0x02: // bold |
|
|
147 if ( strip ) |
|
|
148 continue; |
|
|
149 |
|
|
150 libirc_colorparser_applymask (&mask, &d, &destlen, LIBIRC_COLORPARSER_BOLD, "[B]", "[/B]"); |
|
|
151 break; |
|
|
152 |
|
|
153 case 0x1F: // underline |
|
|
154 if ( strip ) |
|
|
155 continue; |
|
|
156 |
|
|
157 libirc_colorparser_applymask (&mask, &d, &destlen, LIBIRC_COLORPARSER_UNDERLINE, "[U]", "[/U]"); |
|
|
158 break; |
|
|
159 |
|
|
160 case 0x16: // reverse |
|
|
161 if ( strip ) |
|
|
162 continue; |
|
|
163 |
|
|
164 libirc_colorparser_applymask (&mask, &d, &destlen, LIBIRC_COLORPARSER_REVERSE, "[I]", "[/I]"); |
|
|
165 break; |
|
|
166 |
|
|
167 case 0x0F: // reset colors |
|
|
168 if ( strip ) |
|
|
169 continue; |
|
|
170 |
|
|
171 libirc_colorparser_closetags (&mask, &d, &destlen); |
|
|
172 break; |
|
|
173 |
|
|
174 case 0x03: // set color |
|
|
175 if ( isdigit (p[1]) ) |
|
|
176 { |
|
|
177 // Parse |
|
|
178 int bgcolor = -1, color = p[1] - 0x30; |
|
|
179 p++; |
|
|
180 |
|
|
181 if ( isdigit (p[1]) ) |
|
|
182 { |
|
|
183 color = color * 10 + (p[1] - 0x30); |
|
|
184 p++; |
|
|
185 } |
|
|
186 |
|
|
187 // If there is a comma, search for the following |
|
|
188 // background color |
|
|
189 if ( p[1] == ',' && isdigit (p[2]) ) |
|
|
190 { |
|
|
191 bgcolor = p[2] - 0x30; |
|
|
192 p += 2; |
|
|
193 |
|
|
194 if ( isdigit (p[1]) ) |
|
|
195 { |
|
|
196 bgcolor = bgcolor * 10 + (p[1] - 0x30); |
|
|
197 p++; |
|
|
198 } |
|
|
199 } |
|
|
200 |
|
|
201 // Check for range |
|
|
202 if ( color <= LIBIRC_COLORPARSER_MAXCOLORS |
|
|
203 && bgcolor <= LIBIRC_COLORPARSER_MAXCOLORS ) |
|
|
204 { |
|
|
205 if ( strip ) |
|
|
206 continue; |
|
|
207 |
|
|
208 if ( bgcolor != -1 ) |
|
|
209 current_bg = bgcolor; |
|
|
210 |
|
|
211 libirc_colorparser_applycolor (&mask, &d, &destlen, color, current_bg); |
|
|
212 } |
|
|
213 } |
|
|
214 break; |
|
|
215 |
|
|
216 default: |
|
|
217 if ( destline ) |
|
|
218 *d++ = *p; |
|
|
219 else |
|
|
220 destlen++; |
|
|
221 break; |
|
|
222 } |
|
|
223 } |
|
|
224 |
|
|
225 // Close all the opened tags |
|
|
226 libirc_colorparser_closetags (&mask, &d, &destlen); |
|
|
227 destlen++; // for 0-terminator |
|
|
228 } |
|
|
229 |
|
|
230 *d = '\0'; |
|
|
231 return destline; |
|
|
232 } |
|
|
233 |
|
|
234 |
|
|
235 static int libirc_colorparser_colorlookup (const char * color) |
|
|
236 { |
|
|
237 int i; |
|
|
238 for ( i = 0; color_replacement_table[i]; i++ ) |
|
|
239 if ( !strcmp (color, color_replacement_table[i]) ) |
|
|
240 return i; |
|
|
241 |
|
|
242 return -1; |
|
|
243 } |
|
|
244 |
|
|
245 |
|
|
246 /* |
|
|
247 * [code] to IRC color conversion. |
|
|
248 */ |
|
|
249 char * irc_color_convert_to_mirc (const char * source) |
|
|
250 { |
|
|
251 unsigned int destlen = 0; |
|
|
252 char * destline = 0, *d = 0; |
|
|
253 const char *p1, *p2, *cur; |
|
|
254 |
|
|
255 /* |
|
|
256 * There will be two passes. First pass calculates the total length of |
|
|
257 * the destination string. The second pass allocates memory for the string, |
|
|
258 * and fills it. |
|
|
259 */ |
|
|
260 while ( destline == 0 ) // destline will be set after the 2nd pass |
|
|
261 { |
|
|
262 if ( destlen > 0 ) |
|
|
263 { |
|
|
264 // This is the 2nd pass; allocate memory. |
|
|
265 if ( (destline = malloc (destlen)) == 0 ) |
|
|
266 return 0; |
|
|
267 |
|
|
268 d = destline; |
|
|
269 } |
|
|
270 |
|
|
271 cur = source; |
|
|
272 while ( (p1 = strchr (cur, '[')) != 0 ) |
|
|
273 { |
|
|
274 const char * replacedval = 0; |
|
|
275 p2 = 0; |
|
|
276 |
|
|
277 // Check if the closing bracket is available after p1 |
|
|
278 // and the tag length is suitable |
|
|
279 if ( p1[1] != '\0' |
|
|
280 && (p2 = strchr (p1, ']')) != 0 |
|
|
281 && (p2 - p1) > 1 |
|
|
282 && (p2 - p1) < 31 ) |
|
|
283 { |
|
|
284 // Get the tag |
|
|
285 char tagbuf[32]; |
|
|
286 int taglen = p2 - p1 - 1; |
|
|
287 |
|
|
288 memcpy (tagbuf, p1 + 1, taglen); |
|
|
289 tagbuf[taglen] = '\0'; |
|
|
290 |
|
|
291 if ( !strcmp (tagbuf, "/COLOR") ) |
|
|
292 replacedval = "\x0F"; |
|
|
293 else if ( strstr (tagbuf, "COLOR=") == tagbuf ) |
|
|
294 { |
|
|
295 int color, bgcolor = -2; |
|
|
296 char * bcol; |
|
|
297 |
|
|
298 bcol = strchr (tagbuf + 6, '/'); |
|
|
299 |
|
|
300 if ( bcol ) |
|
|
301 { |
|
|
302 *bcol++ = '\0'; |
|
|
303 bgcolor = libirc_colorparser_colorlookup (bcol); |
|
|
304 } |
|
|
305 |
|
|
306 color = libirc_colorparser_colorlookup (tagbuf + 6); |
|
|
307 |
|
|
308 if ( color != -1 && bgcolor == -2 ) |
|
|
309 { |
|
|
310 sprintf (tagbuf, "\x03%02d", color); |
|
|
311 replacedval = tagbuf; |
|
|
312 } |
|
|
313 else if ( color != -1 && bgcolor >= 0 ) |
|
|
314 { |
|
|
315 sprintf (tagbuf, "\x03%02d,%02d", color, bgcolor); |
|
|
316 replacedval = tagbuf; |
|
|
317 } |
|
|
318 } |
|
|
319 else if ( !strcmp (tagbuf, "B") || !strcmp (tagbuf, "/B") ) |
|
|
320 replacedval = "\x02"; |
|
|
321 else if ( !strcmp (tagbuf, "U") || !strcmp (tagbuf, "/U") ) |
|
|
322 replacedval = "\x1F"; |
|
|
323 else if ( !strcmp (tagbuf, "I") || !strcmp (tagbuf, "/I") ) |
|
|
324 replacedval = "\x16"; |
|
|
325 } |
|
|
326 |
|
|
327 if ( replacedval ) |
|
|
328 { |
|
|
329 // add a part before the tag |
|
|
330 int partlen = p1 - cur; |
|
|
331 |
|
|
332 if ( destline ) |
|
|
333 { |
|
|
334 memcpy (d, cur, partlen); |
|
|
335 d += partlen; |
|
|
336 } |
|
|
337 else |
|
|
338 destlen += partlen; |
|
|
339 |
|
|
340 // Add the replacement |
|
|
341 libirc_colorparser_addorcat (&d, &destlen, replacedval); |
|
|
342 |
|
|
343 // And move the pointer |
|
|
344 cur = p2 + 1; |
|
|
345 } |
|
|
346 else |
|
|
347 { |
|
|
348 // add a whole part before the end tag |
|
|
349 int partlen; |
|
|
350 |
|
|
351 if ( !p2 ) |
|
|
352 p2 = cur + strlen(cur); |
|
|
353 |
|
|
354 partlen = p2 - cur + 1; |
|
|
355 |
|
|
356 if ( destline ) |
|
|
357 { |
|
|
358 memcpy (d, cur, partlen); |
|
|
359 d += partlen; |
|
|
360 } |
|
|
361 else |
|
|
362 destlen += partlen; |
|
|
363 |
|
|
364 // And move the pointer |
|
|
365 cur = p2 + 1; |
|
|
366 } |
|
|
367 } |
|
|
368 |
|
|
369 // Add the rest of string |
|
|
370 libirc_colorparser_addorcat (&d, &destlen, cur); |
|
|
371 destlen++; // for 0-terminator |
|
|
372 } |
|
|
373 |
|
|
374 *d = '\0'; |
|
|
375 return destline; |
|
|
376 } |
|
|
377 |
|
|
378 |
|
|
379 char * irc_color_strip_from_mirc (const char * message) |
|
|
380 { |
|
|
381 return libirc_colorparser_irc2code (message, 1); |
|
|
382 } |
|
|
383 |
|
|
384 |
|
|
385 char * irc_color_convert_from_mirc (const char * message) |
|
|
386 { |
|
|
387 return libirc_colorparser_irc2code (message, 0); |
|
|
388 } |
