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