fix single quote bug. get rid of obselete quick hack. requires DB conversion script...
[mir.git] / source / mir / misc / StringUtil.java
1 /*
2  * put your module comment here
3  */
4
5
6 package  mir.misc;
7
8 import  java.io.*;
9 import  java.lang.*;
10 import  java.util.*;
11 import  gnu.regexp.*;
12
13 /**
14  * Statische Hilfsmethoden zur Stringbehandlung
15  *
16  * @version 29.6.99
17  * @author RK
18  */
19 public final class StringUtil {
20
21         private static RE   re_newline2br, re_brbr2p, re_mail, re_url, re_tags;
22
23         private StringUtil() { }  // this avoids contruction
24
25         static {
26                 try {
27                         //precompile regex
28                         re_newline2br = new RE("(\r?\n){1}");
29                         re_brbr2p     = new RE("(<br>\r?\n<br>){1,}");
30                         re_mail       = new RE("([a-zA-Z0-9_.-]+)@([a-zA-Z0-9_-]+).([a-zA-Z0-9_.-]+)");
31                         re_url        = new RE("((https://)|(http://)|(ftp://)){1}([a-zA-Z0-9_-]+).([a-zA-Z0-9_.:-]+)/?([^ \t\r\n<>\\)\\]]+[^ \t\r\n.,<>\\)\\]])");
32                         re_tags       = new RE("<[^>]*>",RE.REG_ICASE);
33                 }
34                 catch (REException e){
35                         System.err.println("FATAL: StringUtil: could not precompile REGEX: "+e.toString());
36                 }
37         }
38
39
40         /**
41          * Wandelt Datum in einen 8-ziffrigen String um (yyyymmdd)
42          * @param theDate
43          * @return 8-ziffriger String (yyyymmdd)
44          */
45
46         public static final String date2webdbDate (GregorianCalendar theDate) {
47                 StringBuffer webdbDate = new StringBuffer();
48                 webdbDate.append(String.valueOf(theDate.get(Calendar.YEAR)));
49                 webdbDate.append(pad2(theDate.get(Calendar.MONTH) + 1));
50                 webdbDate.append(pad2(theDate.get(Calendar.DATE)));
51                 return  webdbDate.toString();
52         }
53
54         /**
55          * Wandelt Calendar in einen 12-ziffrigen String um (yyyymmddhhmm)
56          * @param theDate
57          * @return 12-ziffriger String (yyyymmdd)
58          */
59
60         public static final String date2webdbDateTime (GregorianCalendar theDate) {
61                 StringBuffer webdbDate = new StringBuffer();
62                 webdbDate.append(String.valueOf(theDate.get(Calendar.YEAR)));
63                 webdbDate.append(pad2(theDate.get(Calendar.MONTH) + 1));
64                 webdbDate.append(pad2(theDate.get(Calendar.DATE)));
65                 webdbDate.append(pad2(theDate.get(Calendar.HOUR)));
66                 webdbDate.append(pad2(theDate.get(Calendar.MINUTE)));
67                 return  webdbDate.toString();
68         }
69
70         /**
71          * wandelt Calendar in dd.mm.yyyy / hh.mm um
72          * @param theDate
73          * @return String mit (dd.mm.yyyy / hh.mm um)
74          */
75         public static String date2readableDateTime (GregorianCalendar theDate) {
76                 String readable = "";
77                 int hour;
78                 readable += pad2(theDate.get(Calendar.DATE));
79                 readable += "." + pad2(theDate.get(Calendar.MONTH) + 1);
80                 readable += "." + String.valueOf(theDate.get(Calendar.YEAR));
81                 hour = theDate.get(Calendar.HOUR);
82                 if (theDate.get(Calendar.AM_PM) == Calendar.PM)
83                         hour += 12;
84                 readable += " / " + pad2(hour);
85                 readable += ":" + pad2(theDate.get(Calendar.MINUTE));
86                 return  readable;
87         }
88
89         /**
90          * wandelt eine Datum in einen 8-buchstabigen String, der durch <code>/</code>
91          * getrennt ist.
92          *
93          * @param webdbDate
94          * @return String mit <code>/yyyy/mm/dd</code>
95          */
96         public static final String webdbDate2path (String webdbDate) {
97                 StringBuffer path = new StringBuffer();
98                 path.append("/").append(webdbDate.substring(0, 4));
99                 path.append("/").append(webdbDate.substring(4, 6));
100                 path.append("/");
101                 //who did this?
102                 //path.append("/").append(webdbDate.substring(6, 8));
103                 return  path.toString();
104         }
105
106         /**
107          * wandelt Calendar in dd.mm.yyyy um
108          *
109          * @param theDate
110          * @return String mit  <code>dd.mm.yyyy</code>
111          */
112         public static final String webdbDate2readableDate (String webdbDate) {
113                 String date = "";
114                 date += webdbDate.substring(6, 8);
115                 date += "." + webdbDate.substring(4, 6);
116                 date += "." + webdbDate.substring(0, 4);
117                 return  date;
118         }
119
120
121         /**
122          * converts string from format: yyyy-mm-dd__hh:mm:ss.d
123          * to dd.mm.yyyy hh:mm
124          */
125         public static String dateToReadableDate(String date) {
126                 StringBuffer returnDate = new StringBuffer();
127                 if (date!=null) {
128
129                         returnDate.append(date.substring(8,10)).append('.');
130                         returnDate.append(date.substring(5,7)).append('.');
131                         returnDate.append(date.substring(0,4)).append(' ');
132                         returnDate.append(date.substring(11,16));
133                 }
134                 return returnDate.toString();
135         }
136
137         /**
138          * converts string from format: yyyy-mm-dd__hh:mm:ss.d
139          * to yyyy
140          */
141         public static String dateToYear (String date) {
142                 StringBuffer returnDate = new StringBuffer();
143                 if (date!=null) {
144
145                         returnDate.append(date.substring(0,4));
146                 }
147                 return returnDate.toString();
148         }
149
150         /**
151          * converts string from format: yyyy-mm-dd__hh:mm:ss.d
152          * to [m]m
153          */
154         public static String dateToMonth (String date) {
155                 StringBuffer returnDate = new StringBuffer();
156                 if (date!=null) {
157                         if (!date.substring(5,6).equalsIgnoreCase("0")) returnDate.append(date.substring(5,7));
158                         else returnDate.append(date.substring(6,7));
159                 }
160                 return returnDate.toString();
161         }
162
163         /**
164          * converts string from format: yyyy-mm-dd__hh:mm:ss.d
165          * to [d]d
166          */
167         public static String dateToDayOfMonth (String date) {
168                 StringBuffer returnDate = new StringBuffer();
169                 if (date!=null) {
170                         if (!date.substring(8,9).equalsIgnoreCase("0")) returnDate.append(date.substring(8,10));
171                         else returnDate.append(date.substring(9,10));
172                 }
173                 return returnDate.toString();
174         }
175
176         /**
177          * converts string from format: yyyy-mm-dd__hh:mm:ss.d
178          * to hh:mm
179          */
180         public static String dateToTime (String date) {
181                 StringBuffer returnDate = new StringBuffer();
182                 if (date!=null) {
183                         returnDate.append(date.substring(11,16));
184                 }
185                 return returnDate.toString();
186         }
187
188     /**
189      * Splits the provided CSV text into a list. stolen wholesale from 
190      * from Jakarta Turbine StrinUtils.java -mh
191      *
192      * @param text      The CSV list of values to split apart.
193      * @param separator The separator character.
194      * @return          The list of values.
195      */
196     public static String[] split(String text, String separator)
197     {
198         StringTokenizer st = new StringTokenizer(text, separator);
199         String[] values = new String[st.countTokens()];
200         int pos = 0;
201         while (st.hasMoreTokens())
202         {
203             values[pos++] = st.nextToken();
204         }
205         return values;
206     }
207
208     /**
209      * Joins the elements of the provided array into a single string
210      * containing a list of CSV elements. Stolen wholesale from Jakarta
211      * Turbine StringUtils.java. -mh
212      *
213      * @param list      The list of values to join together.
214      * @param separator The separator character.
215      * @return          The CSV text.
216      */
217     public static String join(String[] list, String separator)
218     {
219         StringBuffer csv = new StringBuffer();
220         for (int i = 0; i < list.length; i++)
221         {
222             if (i > 0)
223             {
224                 csv.append(separator);
225             }
226             csv.append(list[i]);
227         }
228         return csv.toString();
229     }
230
231
232         /**
233          * schließt einen String in Anführungsszeichen ein, falls er Leerzeichen o.ä. enthält
234          *
235          * @return gequoteter String
236          */
237          public static String quoteIfNecessary(String s) {
238                 for (int i = 0; i < s.length(); i++)
239                         if (!(Character.isLetterOrDigit(s.charAt(i)) || s.charAt(i) == '.'))
240                                 return quote(s, '"');
241                 return s;
242         }
243
244          /**
245          * schließt <code>s</code> in <code>'</code> ein und setzt Backslashes vor
246          * "gefährliche" Zeichen innerhalb des Strings
247          * Quotes special SQL-characters in <code>s</code>
248          *
249          * @return geqoteter String
250          */
251         public static String quote(String s)
252         {
253                 String s2 = quote(s, '\'');
254                 s2 = quote(s2, '\"');
255                 return s2;
256         }
257
258         /**
259          * schließt <code>s</code> in <code>'</code> ein und setzt Backslashes vor
260          * "gefährliche" Zeichen innerhalb des Strings
261          *
262          * @param s String, der gequoted werden soll
263          * @param quoteChar zu quotendes Zeichen
264          * @return gequoteter String
265          */
266         public static String quote(String s, char quoteChar)
267         {
268                 StringBuffer buf = new StringBuffer(s.length());
269                 int pos = 0;
270                 while (pos < s.length()) {
271                         int i = s.indexOf(quoteChar, pos);
272                         if (i < 0) i = s.length();
273                         buf.append(s.substring(pos, i));
274                         pos = i;
275                         if (pos < s.length()) {
276                                 buf.append('\\');
277                                 buf.append(quoteChar);
278                                 pos++;
279                         }
280                 }
281                 return buf.toString();
282         }
283
284         /**
285          * replaces dangerous characters in <code>s</code>
286          *
287          */
288
289         public static String unquote(String s)
290         {
291                 char quoteChar='\'';
292                 StringBuffer buf = new StringBuffer(s.length());
293                 int pos = 0;
294                 String searchString = "\\"+quoteChar;
295                 while (pos < s.length()) {
296                         int i = s.indexOf(searchString, pos);
297                         if (i < 0) i = s.length();
298                         buf.append(s.substring(pos, i));
299                         pos = i+1;
300                 }
301                 return buf.toString();
302         }
303
304         /**
305          * Wandelet String in byte[] um.
306          * @param s
307          * @return byte[] des String
308          */
309
310         public static byte[] stringToBytes(String s) {
311                 String crlf = System.getProperty("line.separator");
312                 if (!crlf.equals("\n"))
313                         s = replace(s, "\n", crlf);
314                 // byte[] buf = new byte[s.length()];
315                 byte[] buf = s.getBytes();
316                 return buf;
317         }
318
319                 /**
320          * Ersetzt in String <code>s</code> das <code>pattern</code> durch <code>substitute</code>
321          * @param s
322          * @param pattern
323          * @param substitute
324          * @return String mit den Ersetzungen
325          */
326         public static String replace(String s, String pattern, String substitute) {
327                 int i = 0, pLen = pattern.length(), sLen = substitute.length();
328                 StringBuffer buf = new StringBuffer(s.length());
329                 while (true) {
330                         int j = s.indexOf(pattern, i);
331                         if (j < 0) {
332                                 buf.append(s.substring(i));
333                                 break;
334                         } else {
335                                 buf.append(s.substring(i, j));
336                                 buf.append(substitute);
337                                 i = j+pLen;
338                         }
339                 }
340                 return buf.toString();
341         }
342
343         /**
344          * Ersetzt in String <code>s</code> das Regexp <code>pattern</code> durch <code>substitute</code>
345          * @param s
346          * @param pattern
347          * @param substitute
348          * @return String mit den Ersetzungen
349          */
350         public static String regexpReplace(String haystack, String pattern, String substitute) {
351                 try {
352                         RE regex = new RE(pattern);
353                         return regex.substituteAll(haystack,substitute);
354                 } catch(REException ex){
355                         return null;
356                 }
357         }
358
359
360
361
362         /**
363          * Fügt einen Separator an den Pfad an
364          * @param path
365          * @return Pfad mit Separator am Ende
366          */
367         public static final String addSeparator (String path) {
368                 return  path.length() == 0 || path.endsWith(File.separator) ? path : path
369                                 + File.separatorChar;
370         }
371
372         /**
373          * Fügt ein <code>/</code> ans ende des Strings and
374          * @param path
375          * @return Pfad mit <code>/</code> am Ende
376          */
377         public static final String addSlash (String path) {
378                 return  path.length() == 0 || path.endsWith("/") ? path : path + '/';
379         }
380
381         /**
382          * Löscht <code>/</code> am Ende des Strings, falls vorhanden
383          * @param path
384          * @return String ohne <code>/</code> am Ende
385          */
386         public static final String removeSlash (String path) {
387                 return  path.length() > 1 && path.endsWith("/") ? path.substring(0, path.length()
388                                 - 1) : path;
389         }
390
391         /**
392          * Checks to see if the path is absolute by looking for a leading file
393          * separater
394          * @param path
395          * @return
396          */
397         public static boolean isAbsolutePath (String path) {
398                 return  path.startsWith(File.separator);
399         }
400
401         /**
402          * Löscht Slash am Anfang des Strings
403          * @param path
404          * @return
405          */
406         public static String removeFirstSlash (String path) {
407                 return  path.startsWith("/") ? path.substring(1) : path;
408         }
409
410         /**
411          * formatiert eine Zahl (0-99) zweistellig (z.B. 5 -> 05)
412          * @return zwistellige Zahl
413          */
414         public static String pad2 (int number) {
415                 return  number < 10 ? "0" + number : String.valueOf(number);
416         }
417
418         /**
419          * formatiert eine Zahl (0-999) dreistellig (z.B. 7 -> 007)
420          *
421          * @return 3-stellige Zahl
422          */
423         public static String pad3 (int number) {
424                 return  number < 10 ? "00" + number : number < 100 ? "0" + number : String.valueOf(number);
425         }
426
427         /**
428          * Konvertiert Unix-Linefeeds in Win-Linefeeds
429          * @param s
430          * @return Konvertierter String
431          */
432         public static String unixLineFeedsToWin(String s) {
433                 int i = -1;
434                 while (true) {
435                         i = s.indexOf('\n', i+1);
436                         if (i < 0) break;
437                         if ((i == 0 || s.charAt(i-1) != '\r') &&
438                                 (i == s.length()-1 || s.charAt(i+1) != '\r')) {
439                                 s = s.substring(0, i)+'\r'+s.substring(i);
440                                 i++;
441                         }
442                 }
443                 return s;
444         }
445
446
447         /**
448          * verwandelt einen String in eine gültige Url, konvertiert Sonderzeichen
449          * und Spaces werden zu Underscores
450          *
451          * @return gültige Url
452          */
453         public static String convert2url(String s) {
454                 s = toLowerCase(s);
455                 StringBuffer buf = new StringBuffer();
456                 for(int i = 0; i < s.length(); i++ ) {
457                                 switch( s.charAt( i ) ) {
458                                 case 'ö':
459                         buf.append( "oe" ); break;
460                                 case 'ä':
461                         buf.append( "ae" ); break;
462                                 case 'ü':
463                         buf.append( "ue" ); break;
464                                 case 'ã':
465                         buf.append( "a" ); break;
466                                 case '´':
467                                 case '.':
468                         buf.append( "_" ); break;
469                                 case ' ':
470                         if( buf.charAt( buf.length() - 1 ) != '_' ) {
471                                         buf.append( "_" );
472                         }
473                         break;
474                                 default:
475                         buf.append( s.charAt( i ) );
476                                 }
477                 }
478                 return buf.toString();
479         }
480
481         /**
482          * wandelt Sonderzeichen in Quotes um
483          *
484          * @return Kovertierter String
485          */
486         public static String encodeHtml(String s) {
487                 StringBuffer buf = new StringBuffer();
488                 for(int i=0;i < s.length(); i++ ) {
489
490                         /** @todo looks inefficient, to ask for index of every char, in
491                          *  case of failure it runs to the end.*/
492                         if (s.charAt(i)=='&') {
493                                 // convert html to xml-parsable representation
494                                 if( s.indexOf( "&ouml;", i ) == i ) {
495                                         buf.append( "&#246;" ); i += 5;
496                                         continue;
497                                 }
498                                 if( s.indexOf( "&auml;", i ) == i ) {
499                                         buf.append( "&#228;" ); i += 5;
500                                         continue;
501                                 }
502                                 if( s.indexOf( "&uuml;", i ) == i ) {
503                                         buf.append( "&#252;" ); i += 5;
504                                         continue;
505                                 }
506                                 if( s.indexOf( "&Ouml;", i ) == i ) {
507                                         buf.append( "&#214;" ); i += 5;
508                                         continue;
509                                 }
510                                 if( s.indexOf( "&Auml;", i ) == i ) {
511                                         buf.append( "&#196;" ); i += 5;
512                                         continue;
513                                 }
514                                 if( s.indexOf( "&Uuml;", i ) == i ) {
515                                         buf.append( "&#220;" ); i += 5;
516                                         continue;
517                                 }
518                                 if( s.indexOf( "&szlig;", i ) == i ) {
519                                         buf.append( "&#223;" ); i += 6;
520                                         continue;
521                                 }
522
523                                 /** @todo should only escape outside of tags */
524
525                                 if( s.indexOf( "&quot;", i ) == i ) {
526                                         buf.append( "&#223;" ); i += 5;
527                                         continue;
528                                 }
529                                 if( s.indexOf( "&ndash;", i ) == i ) {
530                                         buf.append( "&#8211;" ); i += 6;
531                                         continue;
532                                 }
533                                 if( s.indexOf( "&mdash;", i ) == i ) {
534                                         buf.append( "&#8212;" ); i += 6;
535                                         continue;
536                                 }
537                                 if( s.indexOf( "&ldquo;", i ) == i ) {
538                                         buf.append( "&#8220;" ); i += 6;
539                                         continue;
540                                 }
541                                 if( s.indexOf( "&rdquo;", i ) == i ) {
542                                         buf.append( "&#8221;" ); i += 6;
543                                         continue;
544                                 }
545                                 if( s.indexOf( "&bdquo;", i ) == i ) {
546                                         buf.append( "&#8222;" ); i += 6;
547                                         continue;
548                                 }
549
550                                 //looks pretty stupid
551                                 if( s.indexOf( "&lt;", i ) == i ) {
552                                         buf.append( "&lt;" ); i += 3;
553                                         continue;
554                                 }
555                                 if( s.indexOf( "&gt;", i ) == i ) {
556                                         buf.append( "&gt;" ); i += 3;
557                                         continue;
558                                 }
559                                 if( s.indexOf( "&acute;", i ) == i ) {
560                                         buf.append( "&acute;" ); i += 6;
561                                         continue;
562                                 }
563                                 if( s.indexOf( "&nbsp;", i ) == i ) {
564                                         buf.append( "&nbsp;" ); i += 5;
565                                         continue;
566                                 }
567                                 //has to be the last
568                                 //if( s.indexOf( "&", i ) == i ) {
569                                 //  buf.append( "&#38;" ); i += 0;
570                                 //  continue;
571                                 //}
572                         }
573                         // convert umlauts an other special charakters
574                         switch( s.charAt(i) ) {
575                                 case 'ö': buf.append( "&#246;" ); break;
576                                 case 'ä': buf.append( "&#228;" ); break;
577                                 case 'ü': buf.append( "&#252;" ); break;
578                                 case 'Ö': buf.append( "&#214;" ); break;
579                                 case 'Ä': buf.append( "&#196;" ); break;
580                                 case 'Ü': buf.append( "&#220;" ); break;
581                                 case 'ß': buf.append( "&#223;" ); break;
582                                 case 'é': buf.append( "&#233;" ); break;
583                                 case 'è': buf.append( "&#232;" ); break;
584                                 case 'á': buf.append( "&#225;" ); break;
585                                 case 'à': buf.append( "&#224;" ); break;
586                                 case 'â': buf.append( "&#226;" ); break;
587                                 case 'ã': buf.append( "&#227;" ); break;
588                                 case '¬': buf.append( "&#172;" ); break;
589                                 case '¹': buf.append( "&#185;" ); break;
590                                 case '²': buf.append( "&#178;" ); break;
591                                 case '³': buf.append( "&#179;" ); break;
592                                 case '¼': buf.append( "&#188;" ); break;
593                                 case '½': buf.append( "&#189;" ); break;
594                                 case '¾': buf.append( "&#190;" ); break;
595                                 case '¶': buf.append( "&#182;" ); break;
596                                 case 'æ': buf.append( "&#230;" ); break;
597                                 case 'ð': buf.append( "&#240;" ); break;
598                                 case '|': buf.append( "&#166;" ); break;
599                                 case '·': buf.append( "&#183;" ); break;
600                                 case '°': buf.append( "&#176;" ); break;
601                                 case '§': buf.append( "&#167;" ); break;
602                                 case 'ø': buf.append( "&#248;" ); break;
603                                 case 'ç': buf.append( "&#231;" ); break;
604                                 case '¤': buf.append( "&#164;" ); break;
605                                 case 'ª': buf.append( "&#170;" ); break;
606                                 case 'Ç': buf.append( "&#199;" ); break;
607                                 case 'Ã': buf.append( "&#195;" ); break;
608                                 case 'Â': buf.append( "&#194;" ); break;
609                                 case 'Æ': buf.append( "&#198;" ); break;
610                                 case '©': buf.append( "&#169;" ); break;
611                                 case '®': buf.append( "&#174;" ); break;
612                                 case '¥': buf.append( "&#165;" ); break;
613                                 case 'Þ': buf.append( "&#254;" ); break;
614                                 case '¯': buf.append( "&#175;" ); break;
615                                 case 'Ð': buf.append( "&#208;" ); break;
616                                 case 'º': buf.append( "&#186;" ); break;
617                                 case '¡': buf.append( "&#161;" ); break;
618                                 case '£': buf.append( "&#163;" ); break;
619                                 case '±': buf.append( "&#177;" ); break;
620                                 case '¿': buf.append( "&#191;" ); break;
621                                 case 'Ø': buf.append( "&#216;" ); break;
622                                 case 'Á': buf.append( "&#192;" ); break;
623                                 case 'À': buf.append( "&#193;" ); break;
624                                 case 'É': buf.append( "&#200;" ); break;
625                                 case 'È': buf.append( "&#201;" ); break;
626                                 case 'ù': buf.append( "&#250;" ); break;
627                                 case 'ñ': buf.append( "&#241;" ); break;
628                                 case 'Ñ': buf.append( "&#209;" ); break;
629                                 case 'µ': buf.append( "&#181;" ); break;
630                                 case 'Í': buf.append( "&#204;" ); break;
631                                 case 'Ì': buf.append( "&#205;" ); break;
632                                 case 'í': buf.append( "&#236;" ); break;
633                                 case 'ì': buf.append( "&#237;" ); break;
634                                 case 'î': buf.append( "&#238;" ); break;
635                                 case 'Î': buf.append( "&#206;" ); break;
636                                 case 'ó': buf.append( "&#243;" ); break;
637                                 case 'Ó': buf.append( "&#210;" ); break;
638                                 case 'ò': buf.append( "&#206;" ); break;
639                                 case 'Ò': buf.append( "&#211;" ); break;
640                                 case 'ô': buf.append( "&#244;" ); break;
641                                 case 'Ô': buf.append( "&#212;" ); break;
642                                 case 'õ': buf.append( "&#245;" ); break;
643                                 case 'Õ': buf.append( "&#213;" ); break;
644                                 case 'ý': buf.append( "&#253;" ); break;
645                                 case 'Ý': buf.append( "&#221;" ); break;
646                                 case 'û': buf.append( "&#251;" ); break;
647                                 case 'Û': buf.append( "&#219;" ); break;
648                                 case 'ú': buf.append( "&#249;" ); break;
649                                 case 'Ú': buf.append( "&#217;" ); break;
650                                 case 'Ù': buf.append( "&#218;" ); break;
651                                 case 'Ê': buf.append( "&#202;" ); break;
652                                 case 'ê': buf.append( "&#234;" ); break;
653                                 case 'å': buf.append( "&#229;" ); break;
654                                 case 'Å': buf.append( "&#197;" ); break;
655                                 case 'ë': buf.append( "&#235;" ); break;
656                                 case 'Ë': buf.append( "&#203;" ); break;
657                                 case 'ÿ': buf.append( "&#255;" ); break;
658                                 case 'ï': buf.append( "&#239;" ); break;
659                                 case 'Ï': buf.append( "&#207;" ); break;
660                                 case '«': buf.append( "&#171;" ); break;
661                                 case '»': buf.append( "&#187;" ); break;
662                                 case '\'': buf.append( "&acute;" ); break;
663                                 case '\"': buf.append( "&quot;" ); break;
664                                 //case '\u8211': buf.append( "&#8211;" ); break;
665                                 //case '\u8212': buf.append( "&#8212;" ); break;
666                                 //case '\u8220': buf.append( "&#8220;" ); break;
667                                 //case '\u8221': buf.append( "&#8221;" ); break;
668                                 //case '\u8222': buf.append( "&#8222;" ); break;
669                                 //case '\"': buf.append( "&#34;" ); break;
670                                 default: buf.append( s.charAt(i) );
671                         }
672
673                 }
674                 return buf.toString();
675         }
676
677
678         public static String decodeHTMLinTags(String s){
679                 StringBuffer buffer = new StringBuffer();
680                 boolean start = false;
681                 boolean stop = false;
682                 int startIndex = 0;
683                 int stopIndex = 0;
684                 int temp = 0;
685
686                 for(int i=0;i<s.length();i++){
687                         if(s.charAt(i)=='<'){
688                                 start = true;
689                                 startIndex = i;
690                         } else if(s.charAt(i)=='>'){
691                                 stop = true;
692                                 stopIndex = i;
693
694                                 if(start && stop){
695                                         buffer.append(s.substring(temp,startIndex));
696                                         buffer.append(replaceQuot(s.substring(startIndex,stopIndex+1)));
697                                         i= temp= stopIndex+1;
698                                         start= stop= false;
699                                 }
700                         }
701                 }
702                 if(stopIndex>0){
703                         buffer.append(s.substring(stopIndex+1));
704                         return buffer.toString();
705                 } else {
706                         return s;
707                 }
708         }
709
710         public static String replaceQuot(String s) {
711                 StringBuffer buffer = new StringBuffer();
712                 for(int j = 0; j < s.length();j++){
713                         if(s.charAt(j)=='&'){
714                                 if(s.indexOf( "&quot;",j) == j) {
715                                         buffer.append( "\"" );
716                                         j += 5;
717                                 }//if
718                         } else {
719                                 buffer.append(s.charAt(j));
720                         }//else
721                 }//for
722                 return buffer.toString();
723         }
724
725         /** wandelt Quotes in Sonderzeichen um
726          */
727         /**
728         public static String decodeHtml(String s) {
729                 StringBuffer buf = new StringBuffer();
730                 for(int i=0;i < s.length(); i++ ) {
731                         if( s.indexOf( "&ouml;", i ) == i ) {
732                                 buf.append( "ö" ); i += 5;
733                                 continue;
734                         }
735                         if( s.indexOf( "&auml;", i ) == i ) {
736                                 buf.append( "ä" ); i += 5;
737                                 continue;
738                         }
739                         if( s.indexOf( "&uuml;", i ) == i ) {
740                                 buf.append( "ü" ); i += 5;
741                                 continue;
742                         }
743                         if( s.indexOf( "&Ouml;", i ) == i ) {
744                                 buf.append( "Ö" ); i += 5;
745                                 continue;
746                         }
747                         if( s.indexOf( "&Auml;", i ) == i ) {
748                                 buf.append( "Ä" ); i += 5;
749                                 continue;
750                         }
751                         if( s.indexOf( "&Uuml;", i ) == i ) {
752                                 buf.append( "Ü" ); i += 5;
753                                 continue;
754                         }
755                         if( s.indexOf( "&szlig;", i ) == i ) {
756                                 buf.append( "ß" ); i += 6;
757                                 continue;
758                         }
759                         if( s.indexOf( "&quot;", i ) == i ) {
760                                 buf.append( "\"" ); i += 5;
761                                 continue;
762                         }
763                         buf.append( s.charAt(i) );
764                 }
765                 return buf.toString();
766         }
767          */
768
769         /**
770          * schnellere Variante der String.toLowerCase()-Routine
771          *
772          * @return String in Kleinbuchsten
773          */
774         public static String toLowerCase(String s) {
775                 int l = s.length();
776                 char[] a = new char[l];
777                 for (int i = 0; i < l; i++)
778                         a[i] = Character.toLowerCase(s.charAt(i));
779                 return new String(a);
780         }
781
782                 /**
783          * Findet <code>element</code> im String-Array <code>array</code>
784          * @param array
785          * @param element
786          * @return Fundstelle als int oder -1
787          */
788         public static int indexOf(String[] array, String element) {
789                 if (array != null)
790                         for (int i = 0; i < array.length; i++)
791                                 if (array[i].equals(element))
792                                         return i;
793                 return -1;
794         }
795
796         /**
797          * Testet auf Vorkommen von <code>element</code> in <code>array</code>
798          * @param array String-Array
799          * @param element
800          * @return true wenn <code>element</code> vorkommt, sonst false
801          */
802         public static boolean contains(String[] array, String element) {
803                 return indexOf(array, element) >= 0;
804         }
805
806                 /**
807          * Ermittelt CRC-Prüfsumme von String <code>s</code>
808          * @param s
809          * @return CRC-Prüfsumme
810          */
811         public static int getCRC(String s) {
812                 int h = 0;
813                 char val[] = s.toCharArray();
814                 int len = val.length;
815
816                 for (int i = 0 ; i < len; i++) {
817                         h &= 0x7fffffff;
818                         h = (((h >> 30) | (h << 1)) ^ (val[i]+i));
819                 }
820
821                 return (h << 8) | (len & 0xff);
822         }
823
824                 /**
825          * Liefert Default-Wert def zurück, wenn String <code>s</code>
826          * kein Integer ist.
827          *
828          * @param s
829          * @param def
830          * @return geparster int aus s oder def
831          */
832         public static int parseInt(String s, int def) {
833                 if (s == null) return def;
834                 try {
835                         return Integer.parseInt(s);
836                 } catch (NumberFormatException e) {
837                         return def;
838                 }
839         }
840
841         /**
842          * Liefert Defaultwert def zurück, wenn s nicht zu einem float geparsed werden kann.
843          * @param s
844          * @param def
845          * @return geparster float oder def
846          */
847         public static float parseFloat(String s, float def) {
848                 if (s == null) return def;
849                 try {
850                         return new Float(s).floatValue();
851                 } catch (NumberFormatException e) {
852                         return def;
853                 }
854         }
855
856                 /**
857          * Findet Ende eines Satzes in String <code>text</code>
858          * @param text
859          * @param startIndex
860          * @return index des Satzendes, oder -1
861          */
862         public static int findEndOfSentence(String text, int startIndex) {
863                  while (true) {
864                          int i = text.indexOf('.', startIndex);
865                          if (i < 0) return -1;
866                          if (i > 0 && !Character.isDigit(text.charAt(i-1)) &&
867                                         (i+1 >= text.length()
868                                         || text.charAt(i+1) == ' '
869                                         || text.charAt(i+1) == '\n'
870                                         || text.charAt(i+1) == '\t'))
871                                         return i+1;
872                          startIndex = i+1;
873                  }
874         }
875
876                 /**
877          * Findet Wortende in String <code>text</code> ab <code>startIndex</code>
878          * @param text
879          * @param startIndex
880          * @return Index des Wortendes, oder -1
881          */
882         public static int findEndOfWord(String text, int startIndex) {
883                 int i = text.indexOf(' ', startIndex),
884                         j = text.indexOf('\n', startIndex);
885                 if (i < 0) i = text.length();
886                 if (j < 0) j = text.length();
887                 return Math.min(i, j);
888         }
889
890
891         /**
892          *  convertNewline2P ist eine regex-routine zum umwandeln von 2 oder mehr newlines (\n)
893          *  in den html-tag <p>
894          *  nur sinnvoll, wenn text nicht im html-format eingegeben
895          */
896         public static String convertNewline2P(String haystack) {
897                         return re_brbr2p.substituteAll(haystack,"\n</p><p>");
898         }
899
900         /**
901          *  convertNewline2Break ist eine regex-routine zum umwandeln von 1 newline (\n)
902          *  in den html-tag <br>
903          *  nur sinnvoll, wenn text nicht im html-format eingegeben
904          */
905         public static String convertNewline2Break(String haystack) {
906                 return re_newline2br.substituteAll(haystack,"$0<br />");
907         }
908
909         /**
910          *  createMailLinks wandelt text im email-adressenformat
911          *  in einen klickbaren link um
912          *  nur sinnvoll, wenn text nicht im html-format eingegeben
913          */
914         public static String createMailLinks(String haystack) {
915                         return re_mail.substituteAll(haystack,"<a href=\"mailto:$0\">$0</a>");
916         }
917
918
919         /**
920          *  createMailLinks wandelt text im email-adressenformat
921          *  in einen klickbaren link um
922          *  nur sinnvoll, wenn text nicht im html-format eingegeben
923          */
924         public static String createMailLinks(String haystack, String imageRoot, String mailImage) {
925                 return re_mail.substituteAll(haystack,"<img src=\""+imageRoot+"/"+mailImage+"\" border=\"0\"/>&#160;<a href=\"mailto:$0\">$0</a>");
926         }
927
928
929         /**
930          *  createURLLinks wandelt text im url-format
931          *  in einen klickbaren link um
932          *  nur sinnvoll, wenn text nicht im html-format eingegeben
933          */
934         public static String createURLLinks(String haystack) {
935                 return re_url.substituteAll(haystack,"<a href=\"$0\">$0</a>");
936         }
937
938         /**
939          * this routine takes text in url format and makes
940          * a clickaeble "<href>" link removing any "illegal" html tags
941          * @param haystack, the url
942          * @param title, the href link text
943          * @param imagRoot, the place to find icons
944          * @param extImage, the url of the icon to show next to the link
945          * @return a String containing the url
946          */
947         public static String createURLLinks(String haystack, String title, String imageRoot,String extImage) {
948                 if (title == null) {
949                         return re_url.substituteAll(haystack,"<img src=\""+imageRoot+"/"+extImage+"\" border=\"0\"/>&#160;<a href=\"$0\">$0</a>");
950                 } else {
951                         title = removeHTMLTags(title);
952                         return re_url.substituteAll(haystack,"<img src=\""+imageRoot+"/"+extImage+"\" border=\"0\"/>&#160;<a href=\"$0\">"+title+"</a>");
953                 }
954         }
955
956         /**
957          * this routine takes text in url format and makes
958          * a clickaeble "<href>" link removing any "illegal" html tags
959          * @param haystack, the url
960          * @param imageRoot, the place to find icons
961          * @param extImage, the url of the icon to show next to the link
962          * @param intImage, unused
963          * @return a String containing the url
964          */
965         public static String createURLLinks(String haystack, String title, String imageRoot,String extImage,String intImage) {
966                 return createURLLinks(haystack, title, imageRoot, extImage);
967         }
968
969          /**
970          *  deleteForbiddenTags
971          *  this method deletes all <script>, <body> and <head>-tags
972          */
973         public static final String deleteForbiddenTags(String haystack) {
974                 try {
975                         RE regex = new RE("<[ \t\r\n](.*?)script(.*?)/script(.*?)>",RE.REG_ICASE);
976                         haystack = regex.substituteAll(haystack,"");
977                         regex = new RE("<head>(.*?)</head>");
978                         haystack = regex.substituteAll(haystack,"");
979                         regex = new RE("<[ \t\r\n/]*body(.*?)>");
980                         haystack = regex.substituteAll(haystack,"");
981                         return haystack;
982                 } catch(REException ex){
983                         return null;
984                 }
985         }
986
987         /**
988          * this method deletes all html tags
989          */
990         public static final String removeHTMLTags(String haystack){
991                         return re_tags.substituteAll(haystack,"");
992         }
993
994
995         /**
996          * this method deletes all but the approved tags html tags
997          * it also deletes approved tags which contain malicious-looking attributes and doesn't work at all
998          */
999         public static String approveHTMLTags(String haystack){
1000                 try {
1001                         String approvedTags="a|img|h1|h2|h3|h4|h5|h6|br|b|i|strong|p";
1002                         String badAttributes="onAbort|onBlur|onChange|onClick|onDblClick|onDragDrop|onError|onFocus|onKeyDown|onKeyPress|onKeyUp|onLoad|onMouseDown|onMouseMove|onMouseOut|onMouseOver|onMouseUp|onMove|onReset|onResize|onSelect|onSubmit|onUnload";
1003                         String approvedProtocols="rtsp|http|ftp|https|freenet|mailto";
1004
1005                         // kill all the bad tags that have attributes
1006                         String s = "<\\s*/?\\s*(?!(("+approvedTags+")\\s))\\w+\\s[^>]*>";
1007                         RE regex = new RE(s,RE.REG_ICASE);
1008                         haystack = regex.substituteAll(haystack,"");
1009
1010                         // kill all the bad tags that are attributeless
1011                         regex = new RE("<\\s*/?\\s*(?!(("+approvedTags+")\\s*>))\\w+\\s*>",RE.REG_ICASE);
1012                         haystack = regex.substituteAll(haystack,"");
1013
1014                         // kill all the tags which have a javascript attribute like onLoad
1015                         regex = new RE("<[^>]*("+badAttributes+")[^>]*>",RE.REG_ICASE);
1016                         haystack = regex.substituteAll(haystack,"");
1017
1018                         // kill all the tags which include a url to an unacceptable protocol
1019                         regex = new RE("<\\s*a\\s+[^>]*href=(?!(\'|\")?("+approvedProtocols+"))[^>]*>",RE.REG_ICASE);
1020                         haystack = regex.substituteAll(haystack,"");
1021
1022                         return haystack;
1023                 } catch(REException ex){
1024                         ex.printStackTrace();
1025                         return null;
1026                 }
1027         }
1028
1029
1030         /**
1031          *  createHTML ruft alle regex-methoden zum unwandeln eines nicht
1032          *  htmlcodierten string auf und returnt einen htmlcodierten String
1033          */
1034         public static String createHTML(String content){
1035                 content=convertNewline2Break(content);
1036                 content=convertNewline2P(content);
1037                 content=createMailLinks(content);
1038                 content=createURLLinks(content);
1039                 return content;
1040         }
1041
1042
1043         /**
1044          *  createHTML ruft alle regex-methoden zum unwandeln eines nicht
1045          *  htmlcodierten string auf und returnt einen htmlcodierten String
1046          */
1047         public static String createHTML(String content,String producerDocRoot,String mailImage,String extImage,String intImage){
1048                 content=convertNewline2Break(content);
1049                 content=convertNewline2P(content);
1050                 content=createMailLinks(content,producerDocRoot,mailImage);
1051                 content=createURLLinks(content,null,producerDocRoot,extImage,intImage);
1052                 return content;
1053         }
1054
1055 }
1056