public LinkedList<Token> analyse(String whole) {
		/* Each key in both the operand and operator hashmaps
			will be used as a delimiter to split the remaining strings
			in the LinkedList. Then the delimeter itself is inserted
			as a Token between each pair of strings, preserving the 
			original order. */ 

		LinkedList<Token> tokens = new LinkedList<Token>();
		tokens.add(new Token(whole, false));

		// Check for operands (word form)
		// This is done before operators because words like 'six' contain operators ('x')
		Object[] keys = operands.keySet().toArray();	// Go through keys in reverse order so 'sixty' 
		Arrays.sort(keys, Collections.reverseOrder());	// is seen before 'six' and so forth'.
		for (Object key : keys) {
			lex((String)key, tokens);
		}

		// Check for secondary operators (word form)
		/*  If I had more time I would implement this so that more complex string operators could be replaced with
			simpler strings before processing. */
/*
		for (String key: secondaryOperators.keySet()) {
			for (Token tok : tokens) {
				tok.setToken(tok.getToken().replace(key, secondaryOperators.get(key)), false);
			}
		} */

		// Check for operators (word form)

		for (String key : operators.keySet()) {
			lex(key, tokens);
		}

		// Check for operators (symbol form)
		for (char key : operators.values()) {
			lex("" + key, tokens);
		}

		// Check for operands (number form)
		for (int i = 0; i < tokens.size(); i++) {
			Token tok = tokens.get(i);
			if (tok.isTokenized()) {
				continue;
			} else {
				String str = tok.getToken();
				String[] numbers = str.split("[^0-9]", 0); // Extract numbers

				// Remove the old untokenized Token and replace with new Tokens containing tokenized values
				tokens.remove(i);
				for (String s : numbers) {
					if (s.length() > 0) {
						tokens.add(i, new Token(s, true)); // Replace old, unprocessed Token with a tokenized Token
						i++;	// Skip this token next time round
					}
				}
				i--; // To account for the removed token
			}
		}

		// throw RuntimeException if there are any strings left in the 'tokens' LinkedList
		for (Token t : tokens) {
			if (!t.isTokenized()) {
					throw new RuntimeException("Untokenized objects remaining in 'tokens' LinkedList.");
			}
		}

		return tokens;
	}