arpfilter.java

semantic web framework

        A_PARSETYPE,
        A_TYPE,
    };
    
   
    private void warning(int id,String s)  {
        try {
          getErrorHandler().warning(new ParseException(id,s));
        }
        catch (SAXException e) {
            throw new WrappedException(e);
        }
    }
    // a bit excessive in length!
    static private int defaultErrorMode[] = new int[400];
    static {
        for (int i=0; i<defaultErrorMode.length; i++)
            defaultErrorMode[i] = i/100;
    }
    private int errorMode[] = (int[])defaultErrorMode.clone();
    void setDefaultErrorMode() {
        errorMode = (int[])defaultErrorMode.clone();
    }
    void setLaxErrorMode() {
        setDefaultErrorMode();
        for (int i=100;i<200;i++)
            setErrorMode(i,EM_IGNORE);
        setErrorMode(WARN_MINOR_INTERNAL_ERROR,EM_WARNING);
    }
    void setStrictErrorMode() {
        setStrictErrorMode(EM_IGNORE);
    }
    
    void setStrictErrorMode(int nonErrorMode) {
        setDefaultErrorMode();
        for (int i=1;i<100;i++)
            setErrorMode(i,nonErrorMode);
        for (int i=100;i<200;i++)
            setErrorMode(i,EM_ERROR);
        int warning = EM_WARNING;
        int error = EM_ERROR;
        switch(nonErrorMode) {
            case EM_ERROR:
                warning = EM_ERROR;
                break;
            case EM_FATAL:
                warning = error = EM_FATAL;
                break;
        }
       // setErrorMode(IGN_XMLBASE_USED,warning);
       // setErrorMode(IGN_XMLBASE_SIGNIFICANT,error);
        setErrorMode(WARN_MINOR_INTERNAL_ERROR,warning);
        setErrorMode(WARN_MINOR_INTERNAL_ERROR,warning);
        setErrorMode(WARN_DEPRECATED_XMLLANG,warning);
 //       setErrorMode(WARN_EMPTY_ABOUT_EACH,nonErrorMode);
        setErrorMode(WARN_UNKNOWN_PARSETYPE,warning);
        setErrorMode(WARN_BAD_XML,nonErrorMode);
        setErrorMode(WARN_PROCESSING_INSTRUCTION_IN_RDF,nonErrorMode);
        setErrorMode(WARN_LEGAL_REUSE_OF_ID,nonErrorMode);
        setErrorMode(WARN_RDF_NN_AS_TYPE,nonErrorMode);
        setErrorMode(WARN_UNKNOWN_RDF_ELEMENT,warning);
        setErrorMode(WARN_UNKNOWN_RDF_ATTRIBUTE,warning);
        setErrorMode(WARN_UNKNOWN_XML_ATTRIBUTE,nonErrorMode);
        setErrorMode(WARN_QNAME_AS_ID,warning);
        setErrorMode(WARN_BAD_XML,error);
    }
    int setErrorMode( int errno, int mode ) {
        int old = errorMode[errno];
        switch ( mode ) {
            case EM_WARNING:
            case EM_IGNORE:
                if ( errno >= 100 * EM_ERROR 
                  && errno != ERR_NOT_WHITESPACE ) 
                    break;
            case EM_ERROR:
            case EM_FATAL:
                switch ( errno ) {
                    case ERR_UNABLE_TO_RECOVER:
                        break;
                    default:
                   errorMode[errno] = mode;
                }
        }
        return old;
    }
    void parseWarning(int id,Location where,String s) throws ParseException {
        int mode = errorMode[id];
        if ( mode == EM_IGNORE )
            return;
        ParseException pe = new ParseException(id,where,s);
        if ( mode == EM_FATAL ) {
            pe.setFatal(true);
            mode = EM_ERROR;
        }
        if ( mode == EM_ERROR ) 
            throw pe;
        
        try {
            getErrorHandler().warning(pe);
            return;
        }
        catch (ParseException rethrown) {
            if ( rethrown == pe )
               throw rethrown;
            throw new WrappedException(pe);
        }
        catch (SAXException e) {
            throw new WrappedException(e);
        }
    }
    void parseWarning(Warn w) throws ParseException {
        parseWarning(w.number,w.location,w.msg);
    }
    private void putWarning(int no,Location where,String msg) {
        pipe.putNextToken(new Warn(no,where,msg));
    }
    
    void setUserData(String nodeId,Object v) {
    	nodeIdUserData.put(nodeId,v);
    }
        
    Object getUserData(String nodeId) {
    	return nodeIdUserData.get(nodeId);
    }
    public void setDocumentLocator (Locator locator)
    {
        this.locator = locator;
        super.setDocumentLocator(locator);
    }
    
    private void doSpecialAtt(int ix,int attName, String ns,BitSet attsDone, Attributes atts, Location where) 
     throws SAXException
    {
        
        attsDone.set(ix);
        
        if ( attName == A_XMLSPACE )
            return;
        
        pipe.putNextToken(new ARPQname(attName,where,ns,null,atts.getQName(ix)));
        String val = atts.getValue(ix);
        
        if ( attName == A_PARSETYPE ) {
            if ( val.equals("Resource") ) {
                pipe.putNextToken(new StrToken(AV_RESOURCE,where,val));
            } else if ( val.equals("Collection") ) {
                pipe.putNextToken(new StrToken(AV_COLLECTION,where,val));
            } else if ( val.equals("daml:collection") && errorMode[WARN_IN_STRICT_MODE]!=EM_ERROR ) {
                pipe.putNextToken(new StrToken(AV_DAMLCOLLECTION,where,val));
            } else {
                pipe.putNextToken(new StrToken(AV_LITERAL,where,val));
                if ( !val.equals("Literal") ) {
                    putWarning(WARN_UNKNOWN_PARSETYPE,where,"Unknown parseType: " + val);
                }
            }  
        } else  {
            pipe.putNextToken(new StrToken(AV_STRING,where,val));
        }

        if ( attName == A_DATATYPE )
           putWarning(WARN_NOT_SUPPORTED,where,"RDF datatyping not supported in Jena1, Literal treated as untyped.");
    }
    public void startElement (String uri, String localName, String rawName, Attributes atts)  throws SAXException {
        Location where = new Location(locator);
        putElementQname(uri,localName,rawName,where);
        BitSet attsDone = new BitSet();
        
        for (int i=0; i<atts.getLength(); i++) {              
                String qn = atts.getQName(i);
                String prefix;
                if (qn.startsWith("xmlns")) {
                	  prefix = "";
                	if (qn.equals("xmlns")) {
                	} else if (qn.charAt(5)==':') {
                		prefix = atts.getLocalName(i);
                	} else {
                		continue;
                	}
                	
                attsDone.set(i);
                pipe.putNextToken(
                new StrToken(A_XMLNS,where,prefix)
                );
                pipe.putNextToken(
                new StrToken(AV_STRING,where,atts.getValue(i))
                );
              }
        }
        for (int i=0;i<specialAtts.length;i++) {
            int ix = atts.getIndex(specialNameSpaces[i],specialAtts[i]);
            if ( ix != -1) {
                doSpecialAtt(ix,specialAttValues[i],specialNameSpaces[i],attsDone,atts,where);
            }
            if ( specialNameSpaces[i]==rdfns ) {
                ix = atts.getIndex("",specialAtts[i]);
                if ( ix != -1) {
                    putWarning(WARN_UNQUALIFIED_RDF_ATTRIBUTE,where,"Unqualified use of rdf:"+atts.getLocalName(ix)+ " has been deprecated.");
                    doSpecialAtt(ix,specialAttValues[i],"",attsDone,atts,where);
                }
            }
        }
        for (int i=0; i<atts.getLength(); i++) {
            if ( !attsDone.get(i) ) {
                String ns = atts.getURI(i);
                String qn = atts.getQName(i);
                if ( qn.length()>=3 && qn.substring(0,3).toLowerCase().equals("xml") ) {
                    putWarning(WARN_UNKNOWN_XML_ATTRIBUTE,where,"XML attribute: " +atts.getQName(i)+" is not known and is being discarded.");
                    continue;
                }
                if ( ns.equals("") ) {
                    putWarning(WARN_UNQUALIFIED_ATTRIBUTE,where,"Attribute: " +atts.getLocalName(i)+". Unqualified use is deprecated. Assuming namespace: " + uri);
                    ns = uri;
                }
                putAttributeQname( ns, atts.getLocalName(i), qn,  where );
                pipe.putNextToken(
                new StrToken(AV_STRING,where,atts.getValue(i))
                );
            }
        }
    }
  
    public void endElement (String uri, String localName, String rawName)
    throws SAXException
    { Location loc = new Location(locator);
        pipe.putNextToken(new Token(E_END,loc));
    }
    public void characters (char ch[], int start, int length)
    throws SAXException
    { Location loc = new Location(locator);
            pipe.putNextToken(
            new StrToken( CD_STRING, loc, new String(ch,start,length) ) );
    }
    public void ignorableWhitespace (char ch[], int start, int length)
    throws SAXException
    {   // Never called.
        characters(ch,start,length);
    }
    private boolean isMemberProperty(String name) {
        if ( name.startsWith("_") ) {
            String number = name.substring(1);
            if (number.startsWith("-") || number.startsWith("0"))
                return false;
            try {
                Integer.parseInt(number);
                return true;
            }
            catch (NumberFormatException e) {
                try {
                    // It might be > Integer.MAX_VALUE
                    new java.math.BigInteger(number);
                    return true;
                }
                catch (NumberFormatException ee) {
                    return false;
                }
            }
        }
        return false;
    }
    private boolean isKnownRDFProperty(String name) {
        return knownRDFProperties.contains(name);
    }
    private void putElementQname(String uri, String localName, String q,Location where) 
    throws SAXException
    {  Token warn = null;
        if ( uri.equals(rdfns) ) {
            Integer val = (Integer)rdfnames.get(localName);
            if ( val == null ) {
                if ( isMemberProperty(localName) ) {
        pipe.putNextToken( new ARPQname(E_RDF_N,where,uri,localName, q) );
                   return;
                } else if ( !(knownRDFTypes.contains(localName)
                       ||isKnownRDFProperty(localName)) ) {
                  if ( knownBadRDFNames.contains(localName) ) 
                     warn = new Warn(ERR_BAD_RDF_ELEMENT,where,"Creating statement(s) for syntactic RDF element: '<rdf:"+localName+"'.");
                 else
                    warn = new Warn(WARN_UNKNOWN_RDF_ELEMENT,where,"Creating statement(s) for unknown RDF element: '<rdf:"+localName+"'.");
               }
            } else {
                pipe.putNextToken(new ARPQname(val.intValue(),where,uri,localName,q));
                return;
            }
        } 
        pipe.putNextToken( new ARPQname(E_OTHER,where,uri,localName, q) );
        if ( warn != null )
            pipe.putNextToken( warn );
    }
    
    private void putAttributeQname( String ns, String local, String q, Location where) 
    throws SAXException
    {
        if ( ns.equals(rdfns) ) {
            if ( isMemberProperty(local) ) {
        pipe.putNextToken( new ARPQname(A_RDF_N,where,ns,local,q) );
               return;
            } else if ( !isKnownRDFProperty(local) ) {
            	    if ( knownBadRDFNames.contains(local) ) 
            putWarning(ERR_BAD_RDF_ATTRIBUTE,where,"Creating statement for inappropriate RDF property: 'rdf:"+local+"'.");
              else
            putWarning(WARN_UNKNOWN_RDF_ATTRIBUTE,where,"Creating statement for unknown RDF property: 'rdf:"+local+"'.");
            }
        }
        pipe.putNextToken( new ARPQname(A_OTHER,where,ns,local,q) );
    }
    
    public void endEntity(java.lang.String str) {
    }
    
    public void endDTD()  {
    }
    
    public void startDTD(String str, String str1, String str2)  {
    }
    
    public void endCDATA()  {
    }
    
    public void startCDATA()  {
    }
    
    public void comment(char[] ch, int start, int length)  {
        Location where = new Location(locator);
        pipe.putNextToken( new StrToken(COMMENT,
          where, new String(ch,start,length) ) );
    }
    
    public void startEntity(java.lang.String str) {
    }
    public void processingInstruction(String target,
                                  String data)
                           throws SAXException {
        Location where = new Location(locator);
        pipe.putNextToken( new StrToken(PROCESSING_INSTRUCTION,
          where, (data==null?target:target+" "+data) ) );
   //     pipe.putNextToken( new ARPQname(E_RDF_N,where,uri,localName, q) );
    }
    
    public Location currentLocation() {
	return pipe.getLastToken().location;
    }
}