xmlcontenthandler.java

jwap 协议 udp 可以用于手机通讯

		}
	}

	private void createTagToken(String elementName, boolean hasAttributes) {
		// create token for current element
		byte tokenValue = tokenRepository.getTagToken(elementName);
		TagToken currentTagToken = new TagToken(elementName, tokenValue);
		// store on tokenArray
		tokens.addElement(currentTagToken);
		// push the current token on stack
		parentTrace.push(currentTagToken);

		// apply bit mask for tag with attributes
		if (hasAttributes) {
			byte currentTokenValue = (byte) (currentTagToken.getValue() | attributeBitMask);
			currentTagToken.setValue(currentTokenValue);
		}

	}

	private void createAttributeTags(String localName, Attributes atts) {
		// process attributes name and prefix..
		for (int i = 0; i < atts.getLength(); i++) {
		//	System.out.println("&&" +atts.getURI(i));
			if (atts.getURI(i).length() <= 0) {
				String attributeName = atts.getLocalName(i);
				String attributeValue = atts.getValue(i);
				String prefix = getAttributePrefix(attributeName, attributeValue);
				byte attributeTokenValue = tokenRepository.getAttributeNameToken(attributeName, prefix);
				AttributeNameToken attrNameToken = new AttributeNameToken(attributeName, attributeTokenValue);
				// store on tokens vector
				tokens.addElement(attrNameToken);
				// do the same for remaining attribute value ....
				String remainingAttrValue = attributeValue.substring(prefix.length()).trim();
				if (remainingAttrValue.length() > 0)
					processAttributeValue(remainingAttrValue);
			}

		}
		tokens.addElement(new TagToken("END attribute" + localName, GlobalTokens.END));
	}

	private String getAttributePrefix(String attributeName, String attributeValue) {
		Vector prefixes = tokenRepository.getAttributePrefixes(attributeName);
		if(prefixes == null) return "";
		Iterator iterator = prefixes.iterator();
		int maxMatchSize = 0;
		String maxMatchedPrefix = "";
		while (iterator.hasNext()) {
			String prefix = (String) iterator.next();
			if (attributeValue.startsWith(prefix) && maxMatchSize < prefix.length()) {
				maxMatchedPrefix = prefix;
				maxMatchSize = prefix.length();
			}
		}
		return maxMatchedPrefix;
	}

	private void processAttributeValue(String attributeValue) {
		String maxMatchedValue = getMatchedPattern(attributeValue);
		if (maxMatchedValue.length() == 0) {
			writeInlineString(attributeValue);
			return;
		}
		int matchStartIdx = maxMatchedValue.length() > 0 ? attributeValue.indexOf(maxMatchedValue) : 0;
		int matchEndIdx = matchStartIdx + maxMatchedValue.length();
		if (matchStartIdx != 0) {
			String startOfAttrValue = attributeValue.substring(0, matchStartIdx);
			writeInlineString(startOfAttrValue);
		}
		byte tokenValue = tokenRepository.getAttributeValueToken(maxMatchedValue);
		AttributeValueToken token = new AttributeValueToken("attvalue", tokenValue);
		tokens.addElement(token);
		if (matchEndIdx != 0) {
			String endOfAttrValue = attributeValue.substring(matchEndIdx);
			writeInlineString(endOfAttrValue);
		}

	}

	private String getMatchedPattern(String attributeValue) {
		String maxMatchedValue = "";
		int maxMatchSize = 0;
		Enumeration enum1 = tokenRepository.getAttributeValues().keys();
		while (enum1.hasMoreElements()) {
			String predefinedValue = (String) enum1.nextElement();
			boolean exists = attributeValue.indexOf(predefinedValue) != -1 ? true : false;
			if (exists && maxMatchSize < predefinedValue.length()) {
				maxMatchedValue = predefinedValue;
				maxMatchSize = predefinedValue.length();
			}
		}
		return maxMatchedValue.trim();
	}

	private void writeInlineString(String inlineString) {
		writeInlineStringToken(GlobalTokens.STR_ISTR_I);
		for (int j = 0; j < inlineString.length(); j++)
			writeInlineStringToken((byte) inlineString.charAt(j));
		writeInlineStringToken((byte) 00);

	}

	private void writeInlineStringToken(byte value) {
		Token stringToken = new Token("STR_INLINE", value);
		tokens.addElement(stringToken);
	}

	/**
	 * @see org.xml.sax.ContentHandler#startPrefixMapping(String, String)
	 */
	public void startPrefixMapping(String prefix, String uri) throws SAXException {
		//System.out.println("startPrefixMapping" + prefix + uri);
		String urnString = uri;
		TokenRepository.switchCodepage(urnString.toLowerCase());
		switchCodepage = true;
		Token switchCodePageToken = new Token("SWITCH_CODEPAGE", (byte)0);
		tokens.addElement(switchCodePageToken);
		Token codePageToken = new Token("CODEPAGENO", TokenRepository.getCurrentCodepage());
		tokens.addElement(codePageToken);
		super.startPrefixMapping(prefix, uri);
	}

	/**
	 * @see org.xml.sax.DTDHandler#unparsedEntityDecl(String, String, String, String)
	 */
	public void unparsedEntityDecl(String name, String publicId, String systemId, String notationName) throws SAXException {
		//System.out.println("unparsedEntityDecl");
		super.unparsedEntityDecl(name, publicId, systemId, notationName);
	}

	/**
	 * @see org.xml.sax.ErrorHandler#warning(SAXParseException)
	 */
	public void warning(SAXParseException exception) throws SAXException {
		//System.out.println("warning");
		exception.printStackTrace();
		super.warning(exception);
	}

	/**
	 * @see org.xml.sax.ext.LexicalHandler#comment(char[], int, int)
	 */
	public void comment(char[] ch, int start, int length) throws SAXException {
		//System.out.println("comment");
	}

	/**
	 * @see org.xml.sax.ext.LexicalHandler#endCDATA()
	 */
	public void endCDATA() throws SAXException {
		//System.out.println("endCDATA");
	}

	/**
	 * @see org.xml.sax.ext.LexicalHandler#endDTD()
	 */
	public void endDTD() throws SAXException {
		//System.out.println("endDTD");
	}

	/**
	 * @see org.xml.sax.ext.LexicalHandler#endEntity(String)
	 */
	public void endEntity(String name) throws SAXException {
		//System.out.println("endEntity");
	}

	/**
	 * @see org.xml.sax.ext.LexicalHandler#startCDATA()
	 */
	public void startCDATA() throws SAXException {
		//System.out.println("START CDATA");
	}

	/**
	 * @see org.xml.sax.ext.LexicalHandler#startDTD(String, String, String)
	 */
	public void startDTD(String name, String publicId, String systemId) throws SAXException {
		//System.out.println("START DTD");
		addPublicIdToken(publicId);
		byte charsetMIB = (byte) TransTable.getTable("charsets").str2code(encoding).byteValue();
		Token charset = new Token("charset", charsetMIB); // to do ...if charset is multiple byte..
		tokens.addElement(charset);
		Token strtbl = new Token("strtble", (byte) 00); // to do ...currently no strings are stored in string table while encoding..
		tokens.addElement(strtbl);
	}

	/**
	 * @param publicId
	 */
	private void addPublicIdToken(String publicId) {
		String publicidValue = PublicIdentifiers.getInstance().getPublicIdentifierValueHex(publicId);
		tokenRepository = TokenRepository.getInstance(publicidValue);
//		Token publicid = new Token("publicid", Byte.parseByte(publicidValue,16));
		byte[] multipleBytes = getMultipleBytes(Integer.valueOf(publicidValue,16).intValue());
		for (int i = 0; i < multipleBytes.length; i++) {
			if (multipleBytes[i] != 0) {
				Token publicIdToken = new Token("publicid", multipleBytes[i]);
				tokens.addElement(publicIdToken);
			}
		}
		publicIdTokenAdded = true;
	}

	private byte[] getMultipleBytes(int intValue) {
		byte[] multipleBytes = new byte[4];
		multipleBytes[0] = (byte) (intValue >>> 24);
		multipleBytes[1] = (byte) (intValue >>> 16);
		multipleBytes[2] = (byte) (intValue >>> 8);
		multipleBytes[3] = (byte) intValue; // cast implies & 0xff
		return multipleBytes;
	}

	/**
	 * WBXML-6. Conversion of all XML parsed entities into string or entity tokens (Mandatory feature)
	 * @see org.xml.sax.ext.LexicalHandler#startEntity(String)
	 */
	public void startEntity(String name) throws SAXException {
		//System.out.println("START entity" + name);
	}

	/**
	 * Returns the tokens.
	 * @return iterator
	 * */
	public Iterator getTokens() {
		return tokens.iterator();
	}

}