int startIndex = -1;

						// 2003-02-21 new replace algorithme by tbee (tbee@tbee.org) 

                            int endIndex = -1;

						// because it wasn't able to replace something like "@aaa;@bbb;"

outer:                      while (true) {

                                startIndex = line.indexOf(startToken, endIndex + etLength);

						// is there a startToken

                                if (startIndex < 0 ||

						// and there is still stuff following the startToken

                                    startIndex + stLength >= line.length()) {

						int startIndex = line.indexOf(startToken);

                                    break;

						while ( startIndex >= 0 && (startIndex+startToken.length()) <= line.length() )

                                }

						{

                                endIndex = line.indexOf(endToken, startIndex + stLength);

							// the new value, this needs to be here 

                                if (endIndex < 0) {

							// because it is required to calculate the next position to search from 

                                    break;

							// at the end of the loop

                                }

				            String replace = null;

                                String matches = line.substring(startIndex + stLength,

                                                                endIndex);

							// we found a starttoken, is there an endtoken following?

                                //If there is a white space or = or :, then

							// start at token+tokenlength because start and end token may be indentical

                                //it isn't to be treated as a valid key.

							int endIndex = line.indexOf(endToken, startIndex + startToken.length());

                                for (int k = 0; k < matches.length(); k++) {

							if (endIndex < 0) startIndex += 1;

                                    char c = matches.charAt(k);

							else

                                    if (c == ':' ||

							{

                                        c == '=' ||

								// grab the token

                                        Character.isSpaceChar(c)) {

								String token = line.substring(startIndex + startToken.length(), endIndex);

                                        endIndex = endIndex - 1;

                                        continue outer;

				                // If there is a white space or = or :, then

                                    }

				                // it isn't to be treated as a valid key.

                                }

				                boolean validToken = true;

                                String replace = null;

				                for (int k = 0; k < token.length() && validToken; k++) 

                                replace = (String) resourceMap.get(matches);

				                {

                                    //If the key hasn't been loaded into resourceMap,

				                    char c = token.charAt(k);

                                    //use the key itself as the value also.

				                    if ( c == ':' 

                                if (replace == null) {

				                      || c == '=' 

                                    log("Warning: The key: " + matches

				                      || Character.isSpaceChar(c)

                                        + " hasn't been defined.",

				                       ) 

                                        Project.MSG_DEBUG);

				                    {

                                    replace = matches;

				                    	validToken = false;

                                }

				                    }

                                line = line.substring(0, startIndex)

				                }

                                    + replace

				                if (!validToken) startIndex += 1;

                                    + line.substring(endIndex + etLength);

				                else

                                endIndex = startIndex + replace.length() + etLength;

				                {

                                if (endIndex + etLength >= line.length()) {

				                	// find the replace string

                                    break;

				                	if (resourceMap.containsKey(token)) replace = (String)resourceMap.get(token);

                                }

				                	else                                replace = token;

                            }

				                    // generate the new line

				                    line = line.substring(0, startIndex)

				                         + replace

				                         + line.substring(endIndex + endToken.length());

									// set start position for next search

									startIndex += replace.length();

				                }                				

							}

							// find next starttoken

							startIndex = line.indexOf(startToken, startIndex);			

						}