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