How to use

getStartOffset

method

in

de.pdark.decentxml.Token

/** The start offset of the node in the XML source or -1 */
public int getStartOffset ()
{
  return token == null ? -1 : token.getStartOffset ();
}

public int getStartOffset ()
{
  return startToken == null ? -1 : startToken.getStartOffset ();
}

public Location (Token token)
{
  this (token.getSource (), token.getStartOffset ());
}

  public String getPrefixWhiteSpace ()
  {
    int pos = getStartOffset ();
    int N = getEndOffset ();
    while (pos < N)
    {
      char c = source.charAt (pos);
      if (!Character.isWhitespace (c))
        break;
      pos ++;
    }
    return pos == 0 ? "" : source.substring (getStartOffset (), pos);
  }
}

public XMLParseException setToken (Token token)
{
  this.token = token;
  if (token != null)
  {
    setSource (token.getSource (), token.getStartOffset ());
  }
  return this;
}

@Override
public String toString ()
{
  return "Token (" + getType () + ", " + getStartOffset () + ":" + getEndOffset () + ", " + getEscapedText () + ")";
}

protected void parseDocTypeText (Token token)
{
  token.setType (Type.TEXT);
  pos --;
  while (pos < source.length () && getCharValidator ().isNameChar (source.charAt (pos)))
    pos ++;
  
  String s = source.substring (token.getStartOffset (), pos);
  if (s.length () == 0)
    throw new XMLParseException ("Expected some text"+lookAheadForErrorMessage ("but found", token.getStartOffset (), 20), token);
  
  // TODO How about "<!DOCTYPE SYSTEM ..."?
  if ("SYSTEM".equals (s))
    token.setType (Type.DOCTYPE_SYSTEM);
  else if ("PUBLIC".equals (s))
    token.setType (Type.DOCTYPE_PUBLIC);
  else if ("NDATA".equals (s))
    token.setType (Type.DOCTYPE_NDATA);
}

/** Return the string of text which this token represents in the XMLSource
 *
 * @return the text or <code>null</code> if there is no source
 */
public String getText ()
{
  return getSource() == null ? null : getSource().substring (getStartOffset(), getEndOffset());
}

/**
 * Fetch the next token and make sure it's {@code expected}. If not, create an
 * {@link XMLParseException} using the {@code errorMessage}
 */
protected Token expect (XMLTokenizer tokenizer, Token startToken, Type expected, String errorMessage)
{
  Token token = tokenizer.next ();
  //System.out.println (token);
  if (token == null || token.getType () != expected)
  {
    if (token == null)
      token = startToken;
    throw new XMLParseException (errorMessage + tokenizer.lookAheadForErrorMessage ("but found", token.getStartOffset (), 20) + " (" + token + ")", token);
  }
  return token;
}

protected void parseEntity (Token token)
{
  token.setType (Type.ENTITY);
  
  char c;
  if (pos < source.length ())
  {
    c = source.charAt (pos);
    if (c == '#')
      pos ++;
  }
  
  while (pos < source.length ())
  {
    c = source.charAt (pos);
    if (c == ';')
      break;
    
    if (!charValidator.isNameChar (c))
      throw new XMLParseException ("Illegal character in entity: ["+c+"] ("+Integer.toHexString (c)+")", source, pos);
    
    pos ++;
  }
  
  expect (';');
  
  verifyEntity (token.getStartOffset (), pos);
}

if (pos == token.getStartOffset())
  throw new XMLParseException("Expected attribute name", source, pos);
  pos++;
  if (pos >= source.length()) {
    int i = Math.min(20, source.length() - token.getStartOffset());
    throw new XMLParseException("Missing end quote (" + endChar + ") of attribute: "
        + lookAheadForErrorMessage(null, token.getStartOffset(), i), token);

if (pos == token.getStartOffset())
  throw new XMLParseException("Expected attribute name", source, pos);
  pos++;
  if (pos >= source.length()) {
    int i = Math.min(20, source.length() - token.getStartOffset());
    throw new XMLParseException("Missing end quote (" + endChar + ") of attribute: "
      + lookAheadForErrorMessage(null, token.getStartOffset(), i), token);

if (pos == token.getStartOffset())
  throw new XMLParseException ("Expected attribute name", source, pos);
  if (pos >= source.length ())
    int i = Math.min (20, source.length () - token.getStartOffset ());
    throw new XMLParseException ("Missing end quote ("+endChar+") of attribute: "
        +lookAheadForErrorMessage (null, token.getStartOffset (), i), token);

protected Token parseAttListTypeGroup (XMLTokenizer tokenizer, Token token, DocTypeAttributeList attList)
{
  attList.addNode (toNode (token));
  Token startGroup = token;
  int subLevel = 0;
  
  while ((token = tokenizer.next ()) != null)
  {
    attList.addNode (toNode (token));
    
    if (token.getType () == Type.DOCTYPE_END_GROUP)
    {
      if (subLevel == 0)
        break;
      subLevel --;
    }
    else if (token.getType () == Type.DOCTYPE_BEGIN_GROUP)
    {
      subLevel ++;
    }
  }
  
  if (token == null)
    throw new XMLParseException ("Expected end of group"+tokenizer.lookAheadForErrorMessage ("but found", startGroup.getStartOffset (), 20), startGroup);
  return token;
}

  throw new XMLParseException ("Unexpected token "+token+" while parsing attributes of element "+parent.getName (), token); //@COBEX
if (!Character.isWhitespace (token.getSource ().charAt (token.getStartOffset ())))
  throw new XMLParseException ("Expected whitespace between attributes of element a but found "+token, token);

protected void parseDocTypeSubElement (XMLTokenizer tokenizer, Token startToken,
    DocType docType)
{
  Token token = startToken;
  token = expect (tokenizer, token, Type.DTD_WHITESPACE, "Expected whitespace after '<!ELEMENT'");
  token = expect (tokenizer, token, Type.TEXT, "Expected element name");
  String name = token.getText ();
  
  token = expect (tokenizer, token, Type.DTD_WHITESPACE, "Expected whitespace after element name");
  Token beforeContent = token;
  
  while ((token = tokenizer.next ()) != null)
  {
    //System.out.println ("parseDocTypeSubElement "+token);
    if (token.getType() == Type.DOCTYPE_END)
      break;
    
    // TODO Check EMPTY, ANY, #PCDATA, (|), ?, *, +
  }
  if (token == null)
    throw new XMLParseException ("Unexpected EOF while parsing element content", tokenizer.getSource (), tokenizer.getOffset ());
  
  String content = tokenizer.getSource ().substring (beforeContent.getEndOffset (), token.getStartOffset ());
  startToken.setEndOffset (token.getEndOffset ());
  DocTypeElement element = new DocTypeElement (startToken, name, content);
  docType.add (element);
}

XMLTokenizer dtdTokenizer = createDTDTokenizer (tokenizer.getSource (), token.getStartOffset ());

throw new XMLParseException ("Expected '>' after entity declaration"+tokenizer.lookAheadForErrorMessage ("but found", token.getStartOffset (), 20), tokenizer.getSource (), tokenizer.getOffset ());

  throw new XMLParseException ("Unexpected EOF while parsing notation declaration", tokenizer.getSource (), tokenizer.getOffset ());
if (token.getType () != Type.DOCTYPE_END)
  throw new XMLParseException ("Expected '>' after notation declaration"+tokenizer.lookAheadForErrorMessage ("but found", token.getStartOffset (), 20), tokenizer.getSource (), tokenizer.getOffset ());