diff --git a/openide.filesystems/apichanges.xml b/openide.filesystems/apichanges.xml
--- a/openide.filesystems/apichanges.xml
+++ b/openide.filesystems/apichanges.xml
@@ -46,6 +46,21 @@
         <apidef name="filesystems">Filesystems API</apidef>
     </apidefs>
     <changes>
+        <change id="DeclarativeMIMEResolvers">
+            <api name="filesystems"/>
+            <summary>Added new elements to MIME resolver DTD</summary>
+            <version major="7" minor="16"/>
+            <date day="10" month="11" year="2008"/>
+            <author login="jskrivanek"/>
+            <compatibility addition="yes"/>
+            <description>
+                <p>
+                    It is now possible to write declarive MIME resolvers checking
+                    file names (element name) and file content (element pattern).
+                </p>
+            </description>
+            <issue number="142760"/>
+        </change>
         <change id="LayerGeneratingProcessor">
             <api name="filesystems"/>
             <summary>Support for annotation processors generating XML layer fragments</summary>
diff --git a/openide.filesystems/nbproject/project.properties b/openide.filesystems/nbproject/project.properties
--- a/openide.filesystems/nbproject/project.properties
+++ b/openide.filesystems/nbproject/project.properties
@@ -44,4 +44,4 @@
 javadoc.main.page=org/openide/filesystems/doc-files/api.html
 javadoc.arch=${basedir}/arch.xml
 javadoc.apichanges=${basedir}/apichanges.xml
-spec.version.base=7.15.0
+spec.version.base=7.16.0
diff --git a/openide.filesystems/src/org/netbeans/modules/openide/filesystems/declmime/MIMEResolverImpl.java b/openide.filesystems/src/org/netbeans/modules/openide/filesystems/declmime/MIMEResolverImpl.java
--- a/openide.filesystems/src/org/netbeans/modules/openide/filesystems/declmime/MIMEResolverImpl.java
+++ b/openide.filesystems/src/org/netbeans/modules/openide/filesystems/declmime/MIMEResolverImpl.java
@@ -46,7 +46,9 @@
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import org.openide.filesystems.FileChangeAdapter;
@@ -73,6 +75,11 @@
         
     private static final boolean CASE_INSENSITIVE =
         Utilities.isWindows() || Utilities.getOperatingSystem() == Utilities.OS_VMS;
+
+    // notification limit in bytes for reading file content. It should not exceed 4192 (4kB) because it is read in one disk touch.
+    private static final int READ_LIMIT = 4000;
+    private static Set<String> readLimitReported = new HashSet<String>();
+
     
     public static MIMEResolver forDescriptor(FileObject fo) {
         return new Impl(fo);
@@ -166,6 +173,10 @@
             for (int i = smell.length-1; i>=0; i--) {
                 String s = smell[i].resolve(fo);
                 if (s != null) {
+                    if (s.equals(FileElement.EXIT_MIME_TYPE)) {
+                        // if file matches conditions and exit element is present, do not continue in loop and return null
+                        return null;
+                    }
                     if (ERR.isLoggable(Level.FINE)) ERR.fine("MIMEResolverImpl.findMIMEType(" + fo + ")=" + s);  // NOI18N
                     return s;
                 }
@@ -212,8 +223,9 @@
         }
         
         /** For debug purposes. */
+        @Override
         public String toString() {
-            return "MIMEResolverImpl.Impl[" + data + ", " + smell + "]";  // NOI18N
+            return "MIMEResolverImpl.Impl[" + data.getPath() + "]";  // NOI18N
         }
 
 
@@ -236,6 +248,10 @@
         // references active resolver component
         private MIMEComponent component = null;        
         private String componentDelimiter = null;
+        // holds level of pattern element
+        private int patternLevel = 0;
+        // used to prohibit more pattern elements on the same level
+        Set<Integer> patternLevelSet;
 
 
         DescParser(FileObject fo) {
@@ -247,6 +263,7 @@
         private static final short IN_FILE = 2;
         private static final short IN_RESOLVER = 3;
         private static final short IN_COMPONENT = 4;
+        private static final short IN_PATTERN = 5;
 
         // second state dimension
         private static final short IN_EXIT = INIT + 1;
@@ -259,13 +276,19 @@
         private static final String RESOLVER = "resolver"; // NOI18N
         private static final String FATTR = "fattr"; // NOI18N
         private static final String NAME = "name"; // NOI18N
+        private static final String PATTERN = "pattern"; // NOI18N
+        private static final String VALUE = "value"; // NOI18N
+        private static final String RANGE = "range"; // NOI18N
+        private static final String IGNORE_CASE = "ignorecase"; // NOI18N
+        private static final String SUBSTRING = "substring"; // NOI18N
         private static final String MAGIC = "magic"; // NOI18N
         private static final String HEX = "hex"; // NOI18N
         private static final String MASK = "mask"; // NOI18N
-        private static final String VALUE = "text"; // NOI18N
+        private static final String TEXT = "text"; // NOI18N
         private static final String EXIT = "exit"; // NOI18N
         private static final String XML_RULE_COMPONENT = "xml-rule";  // NOI18N
 
+        @Override
         public void startElement(String namespaceURI, String localName, String qName, Attributes atts) throws SAXException {
 
             String s;
@@ -337,14 +360,57 @@
                     } else if (FATTR.equals(qName)) {
 
                         s = atts.getValue(NAME); if (s == null) error();
-                        String val = atts.getValue(VALUE);
+                        String val = atts.getValue(TEXT);
                         template[0].fileCheck.addAttr(s, val);                        
+
+                    } else if (PATTERN.equals(qName)) {
+
+                        s = atts.getValue(VALUE); if (s == null) error();
+                        int range = Integer.valueOf(atts.getValue(RANGE));
+                        assert range <= READ_LIMIT || !readLimitReported.add(fo.getPath()): "MIME resolver " + fo.getPath() + " should not exceed " + READ_LIMIT + " bytes limit for files content check.";  //NOI18N
+                        boolean ignoreCase = Type.FilePattern.DEFAULT_IGNORE_CASE;
+                        String ignoreCaseAttr = atts.getValue(IGNORE_CASE);
+                        if (ignoreCaseAttr != null) {
+                            ignoreCase = Boolean.valueOf(ignoreCaseAttr);
+                        }
+                        if (file_state == IN_PATTERN) {
+                            if (patternLevelSet == null) {
+                                patternLevelSet = new HashSet<Integer>();
+                            }
+                            if (!patternLevelSet.add(patternLevel)) {
+                                error("Second pattern element on the same level not allowed");  //NOI18N
+                            }
+                            template[0].fileCheck.addInnerPattern(s, range, ignoreCase);
+                        } else {
+                            template[0].fileCheck.addPattern(s, range, ignoreCase);
+                            file_state = IN_PATTERN;
+                        }
+                        patternLevel++;
+                        break;
+
+                    } else if (NAME.equals(qName)) {
+
+                        s = atts.getValue(NAME); if (s == null) error();
+                        String substringAttr = atts.getValue(SUBSTRING);
+                        boolean substring = Type.FileName.DEFAULT_SUBSTRING;
+                        if (substringAttr != null) {
+                            substring = Boolean.valueOf(substringAttr);
+                        }
+                        boolean ignoreCase = Type.FileName.DEFAULT_IGNORE_CASE;
+                        String ignoreCaseAttr = atts.getValue(IGNORE_CASE);
+                        if (ignoreCaseAttr != null) {
+                            ignoreCase = Boolean.valueOf(ignoreCaseAttr);
+                        }
+                        template[0].fileCheck.addName(s, substring, ignoreCase);
+                        break;
 
                     } else if (RESOLVER.equals(qName)) {
 
                         if (template[0].fileCheck.exts == null 
                             && template[0].fileCheck.mimes == null 
-                            && template[0].fileCheck.fatts == null 
+                            && template[0].fileCheck.fatts == null
+                            && template[0].fileCheck.patterns == null
+                            && template[0].fileCheck.names == null
                             && template[0].fileCheck.magic == null) {
                                 error();  // at least one must be specified
                         }
@@ -357,7 +423,7 @@
                         break;
 
                     } else if (EXIT.equals(qName)) {
-                        
+                        template[0].fileCheck.setExit();
                         file_state = IN_EXIT;
                         break;
                         
@@ -387,7 +453,7 @@
                     
                     component.startElement(namespaceURI, localName, qName, atts);                    
                     break;
-                    
+
                 default:
 
             }
@@ -402,12 +468,19 @@
             state = IN_COMPONENT;            
         }
         
+        @Override
         public void endElement(String namespaceURI, String localName, String qName) throws SAXException {
             switch (state) {
                 case IN_FILE:
                     if (FILE.equals(qName)) {
                         state = IN_ROOT;
                         file_state = INIT;
+                    }
+                    if (PATTERN.equals(qName)) {
+                        if (--patternLevel == 0) {
+                            patternLevelSet = null;
+                            file_state = INIT;
+                        }
                     }
                     break;       
                     
@@ -427,6 +500,7 @@
             }
         }
 
+        @Override
         public void characters(char[] data, int offset, int len) throws SAXException {
             if (state == IN_COMPONENT) component.characters(data, offset, len);
         }
@@ -444,6 +518,8 @@
         private Type fileCheck = new Type();
         private String mime = null;
         private MIMEComponent rule = null;
+        // unique string to mark exit condition
+        private static final String EXIT_MIME_TYPE = "mime-type-to-exit";  //NOI18N
 
         private String[] getExtensions() {
             return fileCheck.exts;
@@ -453,6 +529,10 @@
             return mime;
         }
         
+        private boolean isExit() {
+            return fileCheck.exit;
+        }
+
         private void setMIME(String mime) {
             if ("null".equals(mime)) return;  // NOI18N
             this.mime = mime;
@@ -462,9 +542,15 @@
                         
             try {
                 if (fileCheck.accept(file)) {
-                    if (mime == null) return null;                    
-                    if (rule == null) return mime;                    
-                    if (rule.acceptFileObject(file)) return mime;
+                    if (rule != null && !rule.acceptFileObject(file)) {
+                        return null;
+                    }
+                    if (isExit() || mime == null) {
+                        // all matched but exit element was found or mime attribute of resolver element is null => escape this resolver
+                        return EXIT_MIME_TYPE;
+                    }
+                    // all matched
+                    return mime;
                 }
             } catch (IOException io) {
                 Logger.getLogger(MIMEResolverImpl.class.getName()).log(Level.INFO, null, io);
@@ -475,6 +561,7 @@
         /**
          * For debug puroses only.
          */
+        @Override
         public String toString() {
             StringBuffer buf = new StringBuffer();
             buf.append("FileElement(");
@@ -497,16 +584,177 @@
     private static class Type {
         Type() {}
         private String[] exts;
+        private static final String EMPTY_EXTENSION = "";  //NOI18N
         private String[] mimes;
         private String[] fatts;
+        private List<FilePattern> patterns;
+        private FilePattern lastAddedPattern = null;
+        private List<FileName> names;
         private String[] vals;   // contains null or value of attribute at the same index
         private byte[]   magic;
         private byte[]   mask;
+        private boolean exit = false;
 
-        
+        /** Used to search in the file for given pattern in given range. If there is an inner
+         * pattern element, it is used only if outer is fulfilled. Searching starts
+         * always from the beginning of the file. For example:
+         * <p>
+         * Pattern &lt;?php in first 255 bytes
+         * <pre>
+         *      &lt;pattern value="&lt;?php" range="255"/&gt;
+         * </pre>
+         * </p>
+         * <p>
+         * Pattern &lt;HTML&gt;> or &lt;html&gt; in first 255 bytes and pattern &lt;?php in first 4000 bytes.
+         * <pre>
+         *      &lt;pattern value="&lt;HTML&gt;" range="255" ignorecase="true"&gt;
+         *          &lt;pattern value="&lt;?php" range="4000"/&gt;
+         *      &lt;/pattern&gt;
+         * </pre>
+         * </p>
+         */
+        private class FilePattern {
+            // case sensitive by default
+            private static final boolean DEFAULT_IGNORE_CASE = false;
+            private final String value;
+            private final int range;
+            private final boolean ignoreCase;
+            private FilePattern inner;
+            private int pointer = 0;
+            private final byte[] bytes;
+            private final int valueLength;
+
+            public FilePattern(String value, int range, boolean ignoreCase) {
+                this.value = value;
+                this.valueLength = value.length();
+                if (ignoreCase) {
+                    this.bytes = value.toLowerCase().getBytes();
+                } else {
+                    this.bytes = value.getBytes();
+                }
+                this.range = range;
+                this.ignoreCase = ignoreCase;
+            }
+
+            public void setInner(FilePattern inner) {
+                this.inner = inner;
+            }
+
+            private boolean match(byte b) {
+                if (pointer < valueLength) {
+                    if (b == bytes[pointer]) {
+                        pointer++;
+                    } else {
+                        pointer = 0;
+                        return false;
+                    }
+                }
+                return pointer >= valueLength;
+            }
+
+            /** Read from given file and compare byte-by-byte if pattern
+             * appers in given range.
+             */
+            public boolean match(FileObject fo) throws IOException {
+                pointer = 0;
+                InputStream is = null;
+                boolean matched = false;
+                try {
+                    is = fo.getInputStream();  // it is CachedInputStream, so you can call getInputStream and read more times without performance penalty
+                    byte[] byteRange = new byte[range];
+                    int read = is.read(byteRange);
+                    for (int i = 0; i < read; i++) {
+                        byte b = byteRange[i];
+                        if (ignoreCase) {
+                            b = (byte) Character.toLowerCase(b);
+                        }
+                        if (match(b)) {
+                            matched = true;
+                            break;
+                        }
+                    }
+                } finally {
+                    try {
+                        if (is != null) {
+                            is.close();
+                        }
+                    } catch (IOException ioe) {
+                        // already closed
+                    }
+                }
+                if (matched) {
+                    if (inner == null) {
+                        return true;
+                    } else {
+                        return inner.match(fo);
+                    }
+                }
+                return false;
+            }
+
+            @Override
+            public String toString() {
+                return "[" + value + ", " + range + ", " + ignoreCase + (inner != null ? ", " + inner : "") + "]";
+            }
+        }
+
+        /** Used to compare filename with given name.
+         * For example:
+         * <p>
+         * Filename matches makefile, Makefile, MaKeFiLe, mymakefile, gnumakefile, makefile1, ....
+         * <pre>
+         *      &lt;name name="makefile" substring="true"/&gt;
+         * </pre>
+         * </p>
+         * <p>
+         * Filename exactly matches rakefile or Rakefile.
+         * <pre>
+         *      &lt;name name="rakefile" ignorecase="false"/&gt;
+         *      &lt;name name="Rakefile" ignorecase="false"/&gt;
+         * </pre>
+         * </p>
+         */
+        private class FileName {
+
+            // case insensitive by default
+            private static final boolean DEFAULT_IGNORE_CASE = true;
+            private static final boolean DEFAULT_SUBSTRING = false;
+            private final String name;
+            private final boolean substring;
+            private final boolean ignoreCase;
+
+            public FileName(String name, boolean substring, boolean ignoreCase) {
+                if (ignoreCase) {
+                    this.name = name.toLowerCase();
+                } else {
+                    this.name = name;
+                }
+                this.substring = substring;
+                this.ignoreCase = ignoreCase;
+            }
+
+            public boolean match(FileObject fo) {
+                String nameAndExt = fo.getNameExt();
+                if (ignoreCase) {
+                    nameAndExt = nameAndExt.toLowerCase();
+                }
+                if (substring) {
+                    return nameAndExt.indexOf(name) != -1;
+                } else {
+                    return nameAndExt.equals(name);
+                }
+            }
+
+            @Override
+            public String toString() {
+                return "[" + name + ", " + substring + ", " + ignoreCase + "]";
+            }
+        }
+
         /**
          * For debug purposes only.
          */
+        @Override
         public String toString() {
             int i = 0;
             StringBuffer buf = new StringBuffer();
@@ -529,6 +777,20 @@
                 buf.append("file-attributes:");
                 for (i = 0; i<fatts.length; i++)
                     buf.append(fatts[i]).append("='").append(vals[i]).append("', ");
+            }
+
+            if (patterns != null) {
+                buf.append("patterns:");
+                for (FilePattern pattern : patterns) {
+                    buf.append(pattern.toString()).append(", ");
+                }
+            }
+
+            if (names != null) {
+                buf.append("names:");
+                for (FileName name : names) {
+                    buf.append(name.toString()).append(", ");
+                }
             }
 
             if (magic != null) {
@@ -557,6 +819,27 @@
             vals = Util.addString(vals, value);
         }
 
+        private void addPattern(String value, int range, boolean ignoreCase) {
+            if (patterns == null) {
+                patterns = new ArrayList<FilePattern>();
+            }
+            lastAddedPattern = new FilePattern(value, range, ignoreCase);
+            patterns.add(lastAddedPattern);
+        }
+
+        private void addInnerPattern(String value, int range, boolean ignoreCase) {
+            FilePattern inner = new FilePattern(value, range, ignoreCase);
+            lastAddedPattern.setInner(inner);
+            lastAddedPattern = inner;
+        }
+
+        private void addName(String name, boolean substring, boolean ignoreCase) {
+            if (names == null) {
+                names = new ArrayList<FileName>();
+            }
+            names.add(new FileName(name, substring, ignoreCase));
+        }
+
         private boolean setMagic(byte[] magic, byte[] mask) {
             if (magic == null) return true;
             if (mask != null && magic.length != mask.length) return false;            
@@ -570,15 +853,34 @@
             return true;
         }
 
+        private void setExit() {
+            exit = true;
+        }
+
         @SuppressWarnings("deprecation")
         private static String getMIMEType(String extension) {
             return FileUtil.getMIMEType(extension);
         }
+
+        /** #26521, 114976 - ignore not readable and windows' locked files. */
+        private static void handleIOException(FileObject fo, IOException ioe) throws IOException {
+            if (fo.canRead()) {
+                if (!Utilities.isWindows() || !(ioe instanceof FileNotFoundException) || !fo.isValid() || fo.getName().toLowerCase().indexOf("ntuser") == -1) {//NOI18N
+                    throw ioe;
+                }
+            }
+        }
+
         private boolean accept(FileObject fo) throws IOException {
             // check for resource extension
             if (exts != null) {
-                if (fo.getExt() == null) return false;
-                if (!Util.contains(exts, fo.getExt(), CASE_INSENSITIVE)) return false;
+                String ext = fo.getExt();
+                if (ext == null) {
+                    ext = EMPTY_EXTENSION;
+                }
+                if (!Util.contains(exts, ext, CASE_INSENSITIVE)) {
+                    return false;
+                }
             }
             
             // check for resource mime type
@@ -613,63 +915,36 @@
             if (magic != null) {
                 byte[] header = new byte[magic.length];
 
-//                System.err.println("FO" + fo);
-                
-//                String m = mask == null ? "" : " mask " + XMLUtil.toHex(mask, 0, mask.length);
-//                System.err.println("Magic test " + XMLUtil.toHex(magic, 0, magic.length) + m);
-                
                 // fetch header
 
                 InputStream in = null;
-                boolean unexpectedEnd = false;
                 try {
                     in = fo.getInputStream();
-                    for (int i = 0; i<magic.length; ) {
-                        try {
-                            int read = in.read(header, i, magic.length-i);
-                            if (read < 0) unexpectedEnd = true;
-                            i += read;
-                        } catch (IOException ex) {
-                            unexpectedEnd = true;
-                            break;
-                        }
-                        if (unexpectedEnd) break;
+                    int read = in.read(header);
+                    if (read < 0) {
+                        return false;
                     }
                 } catch (IOException openex) {
-                    unexpectedEnd = true;
-                    boolean isBug114976 = false;
-                    if (Utilities.isWindows() && fo.canRead()  && (openex instanceof FileNotFoundException)) {
-                        if (fo.isValid() && fo.getName().toLowerCase().indexOf("ntuser") != -1) {//NOI18N
-                            isBug114976 = true;
-                        }
-                    }
-                    
-                    if (fo.canRead() == true && !isBug114976) {
-                        throw openex;
-                    } else {
-                        // #26521  silently do not recognize it
-                    }
+                    handleIOException(fo, openex);
+                    return false;
                 } finally {
                     try {
-                        if (in != null) in.close();
+                        if (in != null) {
+                            in.close();
+                        }
                     } catch (IOException ioe) {
                         // already closed
                     }
                 }
 
+                // compare it
 
-//                System.err.println("Header " + XMLUtil.toHex(header, 0, header.length));
-                
-                // compare it
-                
-                if ( unexpectedEnd ) {
-                    return false;
-                } else {
-                    for (int i=0  ; i<magic.length; i++) {
-                        if (mask != null) header[i] &= mask[i];
-                        if (magic[i] != header[i]) {
-                            return false;
-                        }
+                for (int i = 0; i < magic.length; i++) {
+                    if (mask != null) {
+                        header[i] &= mask[i];
+                    }
+                    if (magic[i] != header[i]) {
+                        return false;
                     }
                 }
             }
@@ -684,10 +959,44 @@
                     }
                 }
             }
-            
+
+            // check for patterns in file
+            if (patterns != null) {
+                try {
+                    boolean matched = false;
+                    for (FilePattern pattern : patterns) {
+                        if(pattern.match(fo)) {
+                            // at least one pattern matched => escape loop, otherwise continue
+                            matched = true;
+                            break;
+                        }
+                    }
+                    if (!matched) {
+                        return false;
+                    }
+                } catch (IOException ioe) {
+                    handleIOException(fo, ioe);
+                    return false;
+                }
+            }
+
+            // check file name
+            if (names != null) {
+                boolean matched = false;
+                for (FileName name : names) {
+                    if(name.match(fo)) {
+                        // at least one matched => escape loop, otherwise continue
+                        matched = true;
+                        break;
+                    }
+                }
+                if (!matched) {
+                    return false;
+                }
+            }
+
             // all templates matched
             return true;
         }
-        
     }
 }
diff --git a/openide.filesystems/src/org/netbeans/modules/openide/filesystems/declmime/resolver.dtd b/openide.filesystems/src/org/netbeans/modules/openide/filesystems/declmime/resolver.dtd
--- a/openide.filesystems/src/org/netbeans/modules/openide/filesystems/declmime/resolver.dtd
+++ b/openide.filesystems/src/org/netbeans/modules/openide/filesystems/declmime/resolver.dtd
@@ -27,7 +27,7 @@
 Contributor(s):
 
 The Original Software is NetBeans. The Initial Developer of the Original
-Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
+Software is Sun Microsystems, Inc. Portions Copyright 1997-2008 Sun
 Microsystems, Inc. All Rights Reserved.
 
 If you wish your version of this file to be governed by only the CDDL
@@ -85,10 +85,11 @@
   so there is a danger of recursion if these call <code>this.getMIMEType()</code>.
   </p>
 -->
-<!ELEMENT file ((ext | mime | magic | fattr)+, (resolver | exit)) >
+<!ELEMENT file ((ext | mime | magic | fattr | pattern | name)+, (resolver | exit)) >
 
 <!---
-  Tests resource extension for full equality.
+  Tests resource extension for full equality. If name attribute is empty string
+  (name=""), it matches all files without extension.
 -->
 <!ELEMENT ext EMPTY>
 <!ATTLIST ext name CDATA #REQUIRED>
@@ -123,6 +124,58 @@
 <!ATTLIST fattr text CDATA #REQUIRED>
 
 <!---
+  Search in the file for given pattern in given range. If there is an inner
+  pattern element, it is used only if outer is fulfilled. Searching starts
+  always from the beginning of the file. For example:
+  <p>
+  Pattern &lt;?php in first 255 bytes
+  <pre>
+    &lt;pattern value="&lt;?php" range="255"/&gt;
+  </pre>
+  </p>
+  <p>
+  Pattern &lt;HTML&gt; or &lt;html&gt; in first 255 bytes and pattern &lt;?php in first 4000 bytes.
+  <pre>
+    &lt;pattern value="&lt;HTML&gt;" range="255" ignorecase="true"&gt;
+        &lt;pattern value="&lt;?php" range="4000"/&gt;
+    &lt;/pattern&gt;
+  </pre>
+  </p>
+-->
+<!ELEMENT pattern (pattern?) >
+<!-- Pattern to search for. It doesn't support wildcards or regular expressions. -->
+<!ATTLIST pattern value CDATA #REQUIRED>
+<!-- Range in bytes from beginning of the file. -->
+<!ATTLIST pattern range CDATA #REQUIRED>
+<!-- Whether search is case sensitive. By default it is case sensitive, i.e. ignorecase=false. -->
+<!ATTLIST pattern ignorecase CDATA #IMPLIED>
+
+<!---
+  Compare filename with given name.
+  For example:
+  <p>
+  Filename matches makefile, Makefile, MaKeFiLe, mymakefile, gnumakefile, makefile1, ....
+  <pre>
+    &lt;name name="makefile" substring="true"/&gt;
+  </pre>
+  </p>
+  <p>
+  Filename exactly matches rakefile or Rakefile.
+  <pre>
+    &lt;name name="rakefile" ignorecase="false"/&gt;
+    &lt;name name="Rakefile" ignorecase="false"/&gt;
+  </pre>
+  </p>
+-->
+<!ELEMENT name EMPTY>
+<!-- Filename to search for. It doesn't support wildcards or regular expressions. -->
+<!ATTLIST name name CDATA #REQUIRED>
+<!-- Whether to search for substring or exact match. Default is exact match, i.e. substring=false. -->
+<!ATTLIST name substring CDATA #IMPLIED>
+<!-- Whether search is case sensitive. By default it is case insensitive, i.e. ignorecase=true. -->
+<!ATTLIST name ignorecase CDATA #IMPLIED>
+
+<!---
   You may apply additional rules based on resource content.
   The <code>mime</code> element value is returned. Use the reserved value of <code>null</code>
   to indicate you are not interested in such files (same as <samp>&lt;exit/&gt;</samp>).
@@ -130,8 +183,22 @@
 <!ELEMENT resolver %components;>
 <!ATTLIST resolver mime CDATA #REQUIRED>
 
-<!--- 
+<!---
   Declares that this file is not recognized by this resolver. 
   A shortcut for <samp>&lt;resolver mime="null"/&gt;</samp>.
+  For example:
+  <p>
+  Do not resolve *.txt files and do time consuming magic recognition only for not-txt files.
+  <pre>
+    &lt;file&gt;
+      &lt;ext name="txt"/&gt;
+      &lt;exit/&gt;
+    &lt;/file&gt;
+    &lt;file&gt;
+      &lt;magic hex="0a0001" mask="FF00FF"/&gt;
+      &lt;resolver mime="text/plain"/&gt;
+    &lt;/file&gt;
+  </pre>
+  </p>
 -->
 <!ELEMENT exit EMPTY>
diff --git a/openide.filesystems/src/org/openide/filesystems/MIMESupport.java b/openide.filesystems/src/org/openide/filesystems/MIMESupport.java
--- a/openide.filesystems/src/org/openide/filesystems/MIMESupport.java
+++ b/openide.filesystems/src/org/openide/filesystems/MIMESupport.java
@@ -662,21 +662,21 @@
 
        private boolean ensureBufferLength(int newLen) throws IOException {
            if (!eof && newLen > len) {
-                byte[] tmpBuffer = new byte[len + newLen];
+                byte[] tmpBuffer = new byte[newLen];
                 if (len > 0) {
                     System.arraycopy(buffer, 0, tmpBuffer, 0, len);
                 }
-                int readLen = inputStream.read(tmpBuffer, len, newLen);
+                int readLen = inputStream.read(tmpBuffer, len, newLen - len);
                 if ((readLen > 0)) {
                     buffer = tmpBuffer;
-                    len += readLen;                                    
+                    len += readLen;
                 } else {
                     eof = true;
                 }
            }
            return len >= newLen;
         }
-        
+
         @Override
         public int read(byte[] b, int off, int blen) throws IOException {
             ensureBufferLength(pos + blen);
@@ -688,7 +688,7 @@
             }
             return retval;
         }
-        
+
 
         public int read() throws IOException {
             int retval = -1;
@@ -699,7 +699,7 @@
             }
             return retval;
         }
-        
+
         void cacheToStart() {
             pos = 0;
             eof = false;
diff --git a/openide.filesystems/src/org/openide/filesystems/doc-files/HOWTO-MIME.html b/openide.filesystems/src/org/openide/filesystems/doc-files/HOWTO-MIME.html
--- a/openide.filesystems/src/org/openide/filesystems/doc-files/HOWTO-MIME.html
+++ b/openide.filesystems/src/org/openide/filesystems/doc-files/HOWTO-MIME.html
@@ -105,7 +105,7 @@
 
 <H2>Declarative MIME Type Resolvers</H2>
 
-<p>To solve both of the above problems a developer can use a
+<p>To solve both of the above problems a developer should use a
 declarative MIME type resolver. The semantics of the MIME resolution
 may be specified in a simple manner and an implementation is available
 that will interpret the declaration as efficiently as possible.</p>
@@ -186,8 +186,6 @@
                   <font class="variable-name">url</font>=<font class="string">"mime-resolver.xml"</font>&gt;
                 &lt;<font class="function-name">attr</font> <font class="variable-name">name</font>=<font class="string">"SystemFileSystem.localizingBundle"</font>
                       <font class="variable-name">stringvalue</font>=<font class="string">"org.nb.modules.ant.Bundle"</font>/&gt;
-                &lt;<font class="function-name">attr</font> <font class="variable-name">name</font>=<font class="string">"SystemFileSystem.icon"</font>
-                      <font class="variable-name">urlvalue</font>=<font class="string">"nbresloc:/org/nb/modules/ant/resolver-icon.gif"</font>/&gt;
                 &lt;<font class="function-name">attr</font> <font class="variable-name">name</font>=<font class="string">"position"</font> <font class="variable-name">intvalue</font>=<font class="string">"1234"</font>/&gt;
             &lt;/<font class="function-name">file</font>&gt;
         &lt;/<font class="function-name">folder</font>&gt;
@@ -197,17 +195,14 @@
 
 <p>The resolver is registered as
 <samp>Services/MIMEResolver/org-nb-modules-ant-mime-resolver.xml</samp>.
-It is given a pleasant display name and icon since the user may see
-the resolver presented in NetBeans settings. The bundle file
+It is given a pleasant display name since the user may see
+the resolver presented under XML Layer node. The bundle file
 <samp>org/nb/modules/ant/Bundle.properties</samp> would contain a
 matching key:</p>
 
 <pre>
 <font class="variable-name">Services/MIMEResolver/org-nb-modules-ant-mime-resolver.xml</font>=<font class="string">Ant project files</font>
 </pre>
-
-<p>and <samp>org/nb/modules/ant/resolver-icon.gif</samp> should hold a
-suitable icon.</p>
 
 <p>
     Note that an <a href="http://deadlock.netbeans.org/hudson/job/nbms-and-javadoc/lastSuccessfulBuild/artifact/nbbuild/build/generated/layers.txt">open position</a>
@@ -217,31 +212,6 @@
     over more generic resolvers.
 </p>
 
-<h2>Using the MIME Resolver</h2>
-
-<p>Now whenever matching files are encountered, they will be treated
-as having the MIME type <code>text/x-ant+xml</code> (in this example).
-The data loader should be made to be sensitive to the resolved MIME
-type; this is most easily accomplished when subclassing
-<code>UniFileLoader</code>:</p>
-
-<pre>
-<font class="keyword">protected</font> <font class="type">void</font> <font class="function-name">initialize</font>() {
-    <font class="keyword">super</font>.initialize();
-    getExtensions().addMimeType(<font class="string">"text/x-ant+xml"</font>);
-}
-</pre>
-
-<p>Note that in this case <code>JEditorPane</code> will probably not
-recognize such files as being a variant of <code>text/xml</code> (the
-<code>text/*+xml</code> syntax is a pending standard), so you should
-remember when using a <code>DataEditorSupport</code> or similar to
-explicitly set the editor MIME type to <code>text/xml</code> (the
-default is taken from the file MIME type). In the future it is planned
-for editor supports to check an OpenIDE-specific type registry which
-would automatically associate a general XML editor kit with MIME types
-matching <code>text/*+xml</code> unless an exact match was found.</p>
-
 <h2>Links</h2>
 <a href="http://www.ietf.org/rfc/rfc3023.txt">RFC 3023: XML Media Types</a>
 
diff --git a/openide.filesystems/src/org/openide/filesystems/doc-files/resolverDocumentation.html b/openide.filesystems/src/org/openide/filesystems/doc-files/resolverDocumentation.html
--- a/openide.filesystems/src/org/openide/filesystems/doc-files/resolverDocumentation.html
+++ b/openide.filesystems/src/org/openide/filesystems/doc-files/resolverDocumentation.html
@@ -42,50 +42,54 @@
   -->
 
 <html>
-<head><title>DTD grammar documentation</title></head>
+<head>
+<title>DTD Grammar Documentation</title>
+<meta http-equiv="Content-Type" content="text/xhtml; charset=UTF-8" />
+</head>
 
-<!-- Generated on Aug 29, 2001 by Forte XML module. -->
+<!-- Generated on 10.11.2008 by NetBeans XML module. -->
 <body>
+
 <hr />
 <h2>Element Index</h2>
-<ul><li><a href="#MIME-resolver">MIME-resolver</a></li>
-<li><a href="#attr">attr</a></li>
-<li><a href="#doctype">doctype</a></li>
-<li><a href="#element">element</a></li>
-<li><a href="#exit">exit</a></li>
-<li><a href="#ext">ext</a></li>
-<li><a href="#fattr">fattr</a></li>
-<li><a href="#file">file</a></li>
-<li><a href="#magic">magic</a></li>
-<li><a href="#mime">mime</a></li>
-<li><a href="#ns">ns</a></li>
-<li><a href="#pi">pi</a></li>
-<li><a href="#public-id">public-id</a></li>
-<li><a href="#resolver">resolver</a></li>
-<li><a href="#xml-rule">xml-rule</a></li>
+<ul><li><tt><a href="#MIME-resolver">MIME-resolver</a></tt></li>
+<li><tt><a href="#attr">attr</a></tt></li>
+<li><tt><a href="#doctype">doctype</a></tt></li>
+<li><tt><a href="#element">element</a></tt></li>
+<li><tt><a href="#exit">exit</a></tt></li>
+<li><tt><a href="#ext">ext</a></tt></li>
+<li><tt><a href="#fattr">fattr</a></tt></li>
+<li><tt><a href="#file">file</a></tt></li>
+<li><tt><a href="#magic">magic</a></tt></li>
+<li><tt><a href="#mime">mime</a></tt></li>
+<li><tt><a href="#name">name</a></tt></li>
+<li><tt><a href="#ns">ns</a></tt></li>
+<li><tt><a href="#pattern">pattern</a></tt></li>
+<li><tt><a href="#pi">pi</a></tt></li>
+<li><tt><a href="#public-id">public-id</a></tt></li>
+<li><tt><a href="#resolver">resolver</a></tt></li>
+<li><tt><a href="#xml-rule">xml-rule</a></tt></li>
 </ul>
+
 <hr />
 <h2>Element Details</h2>
 
-<a name="MIME-resolver"></a>
 
 <hr />
-<h2>MIME-resolver</h2>
-<p>MIME resolver description root element.
+<h2><a name="MIME-resolver"></a>MIME-resolver</h2>
+<div>MIME resolver description root element.
   <p>
   <samp>PUBLIC "-//NetBeans//DTD MIME Resolver 1.0//EN"</samp>
-  </p></p>
+  </p></div>
 <p><b>Element Content Model</b></p>
-(<a href="#file">file</a>)+
+<p><tt>(<a href="#file">file</a>)+</tt></p>
 <p><b>Referenced by</b></p>
+<p><tt></tt></p>
 
-
-
-<a name="xml-rule"></a>
 
 <hr />
-<h2>xml-rule</h2>
-<p>MIME component checking XML resource header, permitting matches against
+<h2><a name="xml-rule"></a>xml-rule</h2>
+<div>MIME component checking XML resource header, permitting matches against
   XML constructs: processing instructions, document type declarations, and root element (start tag).
   <p>
   <samp>PUBLIC "-//NetBeans//DTD MIME Resolver XML Rules 1.0//EN"</samp>
@@ -98,235 +102,281 @@
   <dd>Using: PIs and DOCTYPE public IDs.</dd>
   <dt>NS-constrained documents</dt>
   <dd>Using: PIs and root element namespaces.</dd>
-  </dl></p>
+  </dl></div>
 <p><b>Element Content Model</b></p>
-(<a href="#pi">pi</a>*, <a href="#doctype">doctype</a>?, <a href="#element">element</a>?)
+<p><tt>(<a href="#pi">pi</a>*, <a href="#doctype">doctype</a>?, <a href="#element">element</a>?)</tt></p>
 <p><b>Referenced by</b></p>
-<a href="#resolver">resolver</a>
+<p><tt><a href="#resolver">resolver</a></tt></p>
 
-
-<a name="pi"></a>
 
 <hr />
-<h2>pi</h2>
-<p>Processing instructions can be tested on target and pseudo-attributes.
+<h2><a name="pi"></a>pi</h2>
+<div>Processing instructions can be tested on target and pseudo-attributes.
   <p>
   It should be used for in-band tagging that is specified by some
   accepted specification. For NetBeans-specific tagging of third party standards it is
   recommended to use out-of-band tagging such as <code>FileObject</code> attributes.
-  </p></p>
+  </p></div>
 <p><b>Declared Attributes</b></p>
-<ul><tt><li>#REQUIRED CDATA target</li>
-</tt></ul>
+<ul><li><tt>#REQUIRED CDATA target</tt></li>
+</ul>
 <p><b>Element Content Model</b></p>
-(<a href="#attr">attr</a>*)
+<p><tt>(<a href="#attr">attr</a>*)</tt></p>
 <p><b>Referenced by</b></p>
-<a href="#xml-rule">xml-rule</a>
+<p><tt><a href="#xml-rule">xml-rule</a></tt></p>
 
-
-<a name="doctype"></a>
 
 <hr />
-<h2>doctype</h2>
-<p>Match one of the DOCTYPE's public IDs.
-  Use of <code>public-id</code> subelements is mutually exclusive with the attribute.</p>
+<h2><a name="doctype"></a>doctype</h2>
+<div>Match one of the DOCTYPE's public IDs.
+  Use of <code>public-id</code> subelements is mutually exclusive with the attribute.</div>
 <p><b>Declared Attributes</b></p>
-<ul><tt><li>#IMPLIED CDATA public-id</li>
-</tt></ul>
+<ul><li><tt>#IMPLIED CDATA public-id</tt></li>
+</ul>
 <p><b>Element Content Model</b></p>
-(<a href="#public-id">public-id</a>*)
+<p><tt>(<a href="#public-id">public-id</a>*)</tt></p>
 <p><b>Referenced by</b></p>
-<a href="#xml-rule">xml-rule</a>
+<p><tt><a href="#xml-rule">xml-rule</a></tt></p>
 
-
-<a name="public-id"></a>
 
 <hr />
-<h2>public-id</h2>
-<p>A public ID is checked for an exact match.</p>
+<h2><a name="public-id"></a>public-id</h2>
+<div>A public ID is checked for an exact match.</div>
 <p><b>Declared Attributes</b></p>
-<ul><tt><li>#REQUIRED CDATA id</li>
-</tt></ul>
+<ul><li><tt>#REQUIRED CDATA id</tt></li>
+</ul>
 <p><b>Element Content Model</b></p>
-EMPTY
+<p><tt>EMPTY</tt></p>
 <p><b>Referenced by</b></p>
-<a href="#doctype">doctype</a>
+<p><tt><a href="#doctype">doctype</a></tt></p>
 
-
-<a name="element"></a>
 
 <hr />
-<h2>element</h2>
-<p>Matches a root element by specified name, attributes or namespace.
+<h2><a name="element"></a>element</h2>
+<div>Matches a root element by specified name, attributes or namespace.
   <p>
-  The namespace <code>ns</code> attribute or the presence of any <code>ns</code> subelements 
+  The namespace <code>ns</code> attribute or the presence of any <code>ns</code> subelements
   implies that the <code>name</code> attribute represents a local element name,
   otherwise the <code>name</code> attribute represents a full element name ("QName").
   One of the namespaces must match.
-  </p></p>
+  </p></div>
 <p><b>Declared Attributes</b></p>
-<ul><tt><li>#IMPLIED CDATA ns</li>
-<li>#IMPLIED CDATA name</li>
-</tt></ul>
+<ul><li><tt>#IMPLIED CDATA ns</tt></li>
+<li><tt>#IMPLIED CDATA name</tt></li>
+</ul>
 <p><b>Element Content Model</b></p>
-(<a href="#ns">ns</a>*, <a href="#attr">attr</a>*)
+<p><tt>(<a href="#ns">ns</a>*, <a href="#attr">attr</a>*)</tt></p>
 <p><b>Referenced by</b></p>
-<a href="#xml-rule">xml-rule</a>
+<p><tt><a href="#xml-rule">xml-rule</a></tt></p>
 
-
-<a name="ns"></a>
 
 <hr />
-<h2>ns</h2>
-<p>Test namespace equality (exact match).</p>
+<h2><a name="ns"></a>ns</h2>
+<div>Test namespace equality (exact match).</div>
 <p><b>Declared Attributes</b></p>
-<ul><tt><li>#REQUIRED CDATA ns</li>
-</tt></ul>
+<ul><li><tt>#REQUIRED CDATA ns</tt></li>
+</ul>
 <p><b>Element Content Model</b></p>
-EMPTY
+<p><tt>EMPTY</tt></p>
 <p><b>Referenced by</b></p>
-<a href="#element">element</a>
+<p><tt><a href="#element">element</a></tt></p>
 
-
-<a name="attr"></a>
 
 <hr />
-<h2>attr</h2>
-<p>Element attribute template, also used for pseudo-attributes in processing instructions.
+<h2><a name="attr"></a>attr</h2>
+<div>Element attribute template, also used for pseudo-attributes in processing instructions.
   <p>
   The <code>name</code> attribute contains the full attribute name (QName).
   This is inteded to be used for documents that cannot be indentified by public ID nor
   root element namespace.
   </p>
   If <code>text</code> is specified then the attribute's normalized text must
-  exactly match the specified text, otherwise the attribute just needs to be present.</p>
+  exactly match the specified text, otherwise the attribute just needs to be present.</div>
 <p><b>Declared Attributes</b></p>
-<ul><tt><li>#REQUIRED CDATA name</li>
-<li>#IMPLIED CDATA text</li>
-</tt></ul>
+<ul><li><tt>#REQUIRED CDATA name</tt></li>
+<li><tt>#IMPLIED CDATA text</tt></li>
+</ul>
 <p><b>Element Content Model</b></p>
-EMPTY
+<p><tt>EMPTY</tt></p>
 <p><b>Referenced by</b></p>
-<a href="#pi">pi</a>, <a href="#element">element</a>
+<p><tt><a href="#pi">pi</a>, <a href="#element">element</a></tt></p>
 
-
-<a name="file"></a>
 
 <hr />
-<h2>file</h2>
-<p>A file (resource) represents the MIME resolver input.
+<h2><a name="file"></a>file</h2>
+<div>A file (resource) represents the MIME resolver input.
   The resource is tested on attributes obtained from lower layers (OS) such
   as extension, header bytes and wrapping <code>FileObject</code> attributes.
   Some of them must match to proceed to the <code>resolver</code> element.
   <p>
-  Implementation Note: 
-  Lower level MIME type is obtained by <code>FileUtil.getMIMEType()</code>. It may not be 
+  Implementation Note:
+  Lower level MIME type is obtained by <code>FileUtil.getMIMEType()</code>. It may not be
   retrieved by a call to <code>FileObject.getMIMEType</code> to avoid recursion. A better way
   to determine MIME type as assigned by the OS may be introduced in the future.
   </p>
   <p>
-  Implementation Note: 
+  Implementation Note:
   All other tests are performed by calling appropriate methods on <code>FileObject</code>
   so there is a danger of recursion if these call <code>this.getMIMEType()</code>.
-  </p></p>
+  </p></div>
 <p><b>Element Content Model</b></p>
-((<a href="#ext">ext</a>&nbsp;| <a href="#mime">mime</a>&nbsp;| <a href="#magic">magic</a>&nbsp;| <a href="#fattr">fattr</a>)+, (<a href="#resolver">resolver</a>&nbsp;| <a href="#exit">exit</a>))
+<p><tt>((<a href="#ext">ext</a>&nbsp;| <a href="#mime">mime</a>&nbsp;| <a href="#magic">magic</a>&nbsp;| <a href="#fattr">fattr</a>&nbsp;| <a href="#pattern">pattern</a>&nbsp;| <a href="#name">name</a>)+, (<a href="#resolver">resolver</a>&nbsp;| <a href="#exit">exit</a>))</tt></p>
 <p><b>Referenced by</b></p>
-<a href="#MIME-resolver">MIME-resolver</a>
+<p><tt><a href="#MIME-resolver">MIME-resolver</a></tt></p>
 
-
-<a name="ext"></a>
 
 <hr />
-<h2>ext</h2>
-<p>Tests resource extension for full equality.</p>
+<h2><a name="ext"></a>ext</h2>
+<div>Tests resource extension for full equality. If name attribute is empty string
+  (name=""), it matches all files without extension.</div>
 <p><b>Declared Attributes</b></p>
-<ul><tt><li>#REQUIRED CDATA name</li>
-</tt></ul>
+<ul><li><tt>#REQUIRED CDATA name</tt></li>
+</ul>
 <p><b>Element Content Model</b></p>
-EMPTY
+<p><tt>EMPTY</tt></p>
 <p><b>Referenced by</b></p>
-<a href="#file">file</a>
+<p><tt><a href="#file">file</a></tt></p>
 
-
-<a name="mime"></a>
 
 <hr />
-<h2>mime</h2>
-<p>Tests resource MIME type for equality (RFC2045) or suffix equality if it 
-  starts with '+' (RFC 3023).</p>
+<h2><a name="mime"></a>mime</h2>
+<div>Tests resource MIME type for equality (RFC2045) or suffix equality if it
+  starts with '+' (RFC 3023).</div>
 <p><b>Declared Attributes</b></p>
-<ul><tt><li>#REQUIRED CDATA name</li>
-</tt></ul>
+<ul><li><tt>#REQUIRED CDATA name</tt></li>
+</ul>
 <p><b>Element Content Model</b></p>
-EMPTY
+<p><tt>EMPTY</tt></p>
 <p><b>Referenced by</b></p>
-<a href="#file">file</a>
+<p><tt><a href="#file">file</a></tt></p>
 
-
-<a name="magic"></a>
 
 <hr />
-<h2>magic</h2>
-<p>Look at initial bytes of the file and test for a complete match of masked
+<h2><a name="magic"></a>magic</h2>
+<div>Look at initial bytes of the file and test for a complete match of masked
   bits. The default mask is the hexadecimal byte <samp>FF</samp> repeated as
   many times as the <code>hex</code> attribute is long.
-  E.g. <samp>&lt;magic hex="0a0001" mask="FF00FF"/&gt;</samp></p>
+  E.g. <samp>&lt;magic hex="0a0001" mask="FF00FF"/&gt;</samp></div>
 <p><b>Declared Attributes</b></p>
-<ul><tt><li>#REQUIRED CDATA hex</li>
-<li>#IMPLIED CDATA mask</li>
-</tt></ul>
+<ul><li><tt>#REQUIRED CDATA hex</tt></li>
+<li><tt>#IMPLIED CDATA mask</tt></li>
+</ul>
 <p><b>Element Content Model</b></p>
-EMPTY
+<p><tt>EMPTY</tt></p>
 <p><b>Referenced by</b></p>
-<a href="#file">file</a>
+<p><tt><a href="#file">file</a></tt></p>
 
-
-<a name="fattr"></a>
 
 <hr />
-<h2>fattr</h2>
-<p>Test on <code>FileObject</code> attributes. Matching attributes are converted
+<h2><a name="fattr"></a>fattr</h2>
+<div>Test on <code>FileObject</code> attributes. Matching attributes are converted
   to strings via <code>Object.toString()</code> and compared to the <code>text</code>
   attribute.
   <p>
   <code>FileObject</code> attributes can be used for out-of-band tagging of standard documents.
-  </p></p>
+  </p></div>
 <p><b>Declared Attributes</b></p>
-<ul><tt><li>#REQUIRED CDATA name</li>
-<li>#REQUIRED CDATA text</li>
-</tt></ul>
+<ul><li><tt>#REQUIRED CDATA name</tt></li>
+<li><tt>#REQUIRED CDATA text</tt></li>
+</ul>
 <p><b>Element Content Model</b></p>
-EMPTY
+<p><tt>EMPTY</tt></p>
 <p><b>Referenced by</b></p>
-<a href="#file">file</a>
+<p><tt><a href="#file">file</a></tt></p>
 
-
-<a name="resolver"></a>
 
 <hr />
-<h2>resolver</h2>
-<p>You may apply additional rules based on resource content.
-  The <code>mime</code> element value is returned. Use the reserved value of <code>null</code>
-  to indicate you are not interested in such files (same as <samp>&lt;exit/&gt;</samp>).</p>
+<h2><a name="pattern"></a>pattern</h2>
+<div>Search in the file for given pattern in given range. If there is an inner
+  pattern element, it is used only if outer is fulfilled. Searching starts
+  always from the beginning of the file. For example:
+  <p>
+  Pattern &lt;?php in first 255 bytes
+  <pre>
+    &lt;pattern value="&lt;?php" range="255"/&gt;
+  </pre>
+  </p>
+  <p>
+  Pattern &lt;HTML&gt; or &lt;html&gt; in first 255 bytes and pattern &lt;?php in first 4000 bytes.
+  <pre>
+    &lt;pattern value="&lt;HTML&gt;" range="255" ignorecase="true"&gt;
+        &lt;pattern value="&lt;?php" range="4000"/&gt;
+    &lt;/pattern&gt;
+  </pre>
+  </p></div>
 <p><b>Declared Attributes</b></p>
-<ul><tt><li>#REQUIRED CDATA mime</li>
-</tt></ul>
+<ul><li><tt>#REQUIRED CDATA value</tt></li>
+<li><tt>#REQUIRED CDATA range</tt></li>
+<li><tt>#IMPLIED CDATA ignorecase</tt></li>
+</ul>
 <p><b>Element Content Model</b></p>
-(<a href="#xml-rule">xml-rule</a>)?
+<p><tt>(<a href="#pattern">pattern</a>?)</tt></p>
 <p><b>Referenced by</b></p>
-<a href="#file">file</a>
+<p><tt><a href="#file">file</a>, <a href="#pattern">pattern</a></tt></p>
 
-
-<a name="exit"></a>
 
 <hr />
-<h2>exit</h2>
-<p>Declares that this file is not recognized by this resolver. 
-  A shortcut for <samp>&lt;resolver mime="null"/&gt;</samp>.</p>
+<h2><a name="name"></a>name</h2>
+<div>Compare filename with given name.
+  For example:
+  <p>
+  Filename matches makefile, Makefile, MaKeFiLe, mymakefile, gnumakefile, makefile1, ....
+  <pre>
+    &lt;name name="makefile" substring="true"/&gt;
+  </pre>
+  </p>
+  <p>
+  Filename exactly matches rakefile or Rakefile.
+  <pre>
+    &lt;name name="rakefile" ignorecase="false"/&gt;
+    &lt;name name="Rakefile" ignorecase="false"/&gt;
+  </pre>
+  </p></div>
+<p><b>Declared Attributes</b></p>
+<ul><li><tt>#REQUIRED CDATA name</tt></li>
+<li><tt>#IMPLIED CDATA substring</tt></li>
+<li><tt>#IMPLIED CDATA ignorecase</tt></li>
+</ul>
 <p><b>Element Content Model</b></p>
-EMPTY
+<p><tt>EMPTY</tt></p>
 <p><b>Referenced by</b></p>
-<a href="#file">file</a>
+<p><tt><a href="#file">file</a></tt></p>
 
+
+<hr />
+<h2><a name="resolver"></a>resolver</h2>
+<div>You may apply additional rules based on resource content.
+  The <code>mime</code> element value is returned. Use the reserved value of <code>null</code>
+  to indicate you are not interested in such files (same as <samp>&lt;exit/&gt;</samp>).</div>
+<p><b>Declared Attributes</b></p>
+<ul><li><tt>#REQUIRED CDATA mime</tt></li>
+</ul>
+<p><b>Element Content Model</b></p>
+<p><tt>(<a href="#xml-rule">xml-rule</a>)?</tt></p>
+<p><b>Referenced by</b></p>
+<p><tt><a href="#file">file</a></tt></p>
+
+
+<hr />
+<h2><a name="exit"></a>exit</h2>
+<div>Declares that this file is not recognized by this resolver.
+  A shortcut for <samp>&lt;resolver mime="null"/&gt;</samp>.
+  For example:
+  <p>
+  Do not resolve *.txt files and do time consuming magic recognition only for not-txt files.
+  <pre>
+    &lt;file&gt;
+      &lt;ext name="txt"/&gt;
+      &lt;exit/&gt;
+    &lt;/file&gt;
+    &lt;file&gt;
+      &lt;magic hex="0a0001" mask="FF00FF"/&gt;
+      &lt;resolver mime="text/plain"/&gt;
+    &lt;/file&gt;
+  </pre>
+  </p></div>
+<p><b>Element Content Model</b></p>
+<p><tt>EMPTY</tt></p>
+<p><b>Referenced by</b></p>
+<p><tt><a href="#file">file</a></tt></p>
 </body></html>
\ No newline at end of file
diff --git a/openide.filesystems/test/unit/src/org/netbeans/modules/openide/filesystems/declmime/MIMEResolverImplTest.java b/openide.filesystems/test/unit/src/org/netbeans/modules/openide/filesystems/declmime/MIMEResolverImplTest.java
--- a/openide.filesystems/test/unit/src/org/netbeans/modules/openide/filesystems/declmime/MIMEResolverImplTest.java
+++ b/openide.filesystems/test/unit/src/org/netbeans/modules/openide/filesystems/declmime/MIMEResolverImplTest.java
@@ -44,7 +44,13 @@
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.logging.Handler;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+import junit.framework.Test;
 import org.netbeans.junit.NbTestCase;
+import org.netbeans.junit.NbTestSuite;
 import org.openide.filesystems.FileObject;
 import org.openide.filesystems.FileSystem;
 import org.openide.filesystems.FileUtil;
@@ -54,21 +60,31 @@
 public class MIMEResolverImplTest extends NbTestCase {
     List<MIMEResolver> resolvers;
     FileObject root;
+    FileObject resolversRoot;
            
     public MIMEResolverImplTest(String testName) {
         super(testName);
     }
-    
+
+    public static Test suite() {
+        Test suite = null;
+        //suite = new MIMEResolverImplTest("testPatternElement");
+        if (suite == null) {
+            suite = new NbTestSuite(MIMEResolverImplTest.class);
+        }
+        return suite;
+    }
+
     @SuppressWarnings("deprecation")
     @Override
     protected void setUp() throws Exception {
         URL u = this.getClass().getResource ("code-fs.xml");        
         FileSystem fs = new XMLFileSystem(u);
         
-        FileObject coderoot = fs.getRoot().getFileObject("root");
-        coderoot.refresh();
+        resolversRoot = fs.getRoot().getFileObject("root");
+        resolversRoot.refresh();
         
-        FileObject fos[] = coderoot.getChildren();
+        FileObject fos[] = resolversRoot.getChildren();
         resolvers = new ArrayList<MIMEResolver>();
         for (int i = 0; i<fos.length; i++) {
             resolvers.add(createResolver(fos[i]));
@@ -94,7 +110,7 @@
         }
         return null;
     }
-    
+
     public void testMultithreading() throws Exception {
         
         Object tl1 = new Object();
@@ -192,4 +208,100 @@
         assertEquals("illegal-encoding.xml recognized as a XML file", "text/x-springconfig+xml", resolve(root.getFileObject("illegal-encoding", "xml")));
     }
 
+    /** Test possible cascading of pattern elements. */
+    public void testPatternElementValidity() {
+        MIMEResolver declarativeResolver = MIMEResolverImpl.forDescriptor(resolversRoot.getFileObject("pattern-resolver-valid.xml"));
+        final AtomicBoolean failed = new AtomicBoolean(false);
+        Handler handler = new Handler() {
+
+            @Override
+            public void publish(LogRecord record) {
+                if (record.getThrown().getMessage().startsWith("Second pattern element on the same level not allowed")) {
+                    failed.set(true);
+                }
+            }
+
+            @Override
+            public void flush() {
+            }
+
+            @Override
+            public void close() throws SecurityException {
+            }
+        };
+        Logger.getLogger(DefaultParser.class.getName()).addHandler(handler);
+        declarativeResolver.findMIMEType(root.getFileObject("empty.dtd"));
+        assertFalse("Pattern elements in patternValid.xml not parsed.", failed.get());
+
+        failed.set(false);
+        declarativeResolver = MIMEResolverImpl.forDescriptor(resolversRoot.getFileObject("pattern-resolver-invalid1.xml"));
+        declarativeResolver.findMIMEType(root.getFileObject("empty.dtd"));
+        assertTrue("Pattern elements in patternInvalid1.xml should not be parsed.", failed.get());
+
+        failed.set(false);
+        declarativeResolver = MIMEResolverImpl.forDescriptor(resolversRoot.getFileObject("pattern-resolver-invalid2.xml"));
+        declarativeResolver.findMIMEType(root.getFileObject("empty.dtd"));
+        assertTrue("Pattern elements in patternInvalid2.xml should not be parsed.", failed.get());
+    }
+
+    private void assertMimeType(MIMEResolver resolver, String expectedMimeType, String... filenames) {
+        for (String filename : filenames) {
+            String mimeType = resolver.findMIMEType(root.getFileObject(filename));
+            assertEquals("File " + filename + " not properly resolved by " + resolver +".", expectedMimeType, mimeType);
+        }
+    }
+
+    /** Test pattern element in declarative MIME resolver. */
+    public void testPatternElement() {
+        MIMEResolver resolver = MIMEResolverImpl.forDescriptor(resolversRoot.getFileObject("php-resolver1.xml"));
+        assertMimeType(resolver, "text/x-php5", "php.txt");
+        assertMimeType(resolver, null, "not-php.txt");
+        assertMimeType(resolver, "text/x-php5", "html-php.txt");
+
+        resolver = MIMEResolverImpl.forDescriptor(resolversRoot.getFileObject("php-resolver2.xml"));
+        assertMimeType(resolver, null, "php.txt");
+        assertMimeType(resolver, "text/x-php5", "html-php.txt");
+
+        resolver = MIMEResolverImpl.forDescriptor(resolversRoot.getFileObject("php-resolver3.xml"));
+        assertMimeType(resolver, null, "php.txt");
+        assertMimeType(resolver, null, "html-php.txt");
+    }
+
+    /** Test name element in declarative MIME resolver. */
+    public void testNameElement() {
+        MIMEResolver resolver = MIMEResolverImpl.forDescriptor(resolversRoot.getFileObject("makefile-resolver.xml"));
+        assertMimeType(resolver, "text/x-make", "makefile", "Makefile", "MaKeFiLe", "mymakefile", "gnumakefile", "makefile1", "makefileRakefile", "makefile.Rakefile");
+
+        assertMimeType(resolver, null, "empty.dtd", "rakefile", "Rakefile");
+
+        resolver = MIMEResolverImpl.forDescriptor(resolversRoot.getFileObject("rakefile-resolver.xml"));
+        assertMimeType(resolver, "text/x-ruby", "rakefile", "Rakefile");
+        assertMimeType(resolver, null, "empty.dtd", "makefile", "makefileRakefile", "makefile.Rakefile");
+    }
+
+    /** Test ruby declarative MIME resolver. */
+    public void testRubyResolver() {
+        MIMEResolver resolver = MIMEResolverImpl.forDescriptor(resolversRoot.getFileObject("ruby-resolver.xml"));
+        assertMimeType(resolver, "text/x-ruby", "ruby.cgi");
+    }
+
+    /** Test empty extension MIME resolver. */
+    public void testEmptyExtensionResolver() {
+        MIMEResolver resolver = MIMEResolverImpl.forDescriptor(resolversRoot.getFileObject("empty-extension-resolver.xml"));
+        assertMimeType(resolver, "empty/extension", "empty-extension");
+        assertMimeType(resolver, null, "empty.dtd");
+    }
+
+    /** Test cpp declarative MIME resolver. */
+    public void testCppResolver() {
+        MIMEResolver resolver = MIMEResolverImpl.forDescriptor(resolversRoot.getFileObject("cpp-resolver.xml"));
+        assertMimeType(resolver, "text/x-c++", "cpp");
+        assertMimeType(resolver, null, "cpp.not");
+    }
+
+    /** Test exit element in MIME resolver. */
+    public void testExitResolver() {
+        MIMEResolver resolver = MIMEResolverImpl.forDescriptor(resolversRoot.getFileObject("exit-resolver.xml"));
+        assertMimeType(resolver, null, "php.txt");
+    }
 }
diff --git a/openide.filesystems/test/unit/src/org/netbeans/modules/openide/filesystems/declmime/code-fs.xml b/openide.filesystems/test/unit/src/org/netbeans/modules/openide/filesystems/declmime/code-fs.xml
--- a/openide.filesystems/test/unit/src/org/netbeans/modules/openide/filesystems/declmime/code-fs.xml
+++ b/openide.filesystems/test/unit/src/org/netbeans/modules/openide/filesystems/declmime/code-fs.xml
@@ -100,5 +100,167 @@
 ]]>
 	</file>
 
+        <file name="pattern-resolver-valid.xml"><![CDATA[<?xml version="1.0"?>
+            <MIME-resolver>
+                <file>
+                    <pattern value="valid1" range="255"/>
+                    <pattern value="valid2" range="255">
+                        <pattern value="inner1" range="255" ignorecase="true"/>
+                    </pattern>
+                    <pattern value="valid3" range="255">
+                        <pattern value="inner1" range="255" ignorecase="true">
+                            <pattern value="inner2" range="4000"/>
+                        </pattern>
+                    </pattern>
+                    <resolver mime="text/x-php5"/>
+                </file>
+            </MIME-resolver>]]>
+        </file>
+        <file name="pattern-resolver-invalid1.xml"><![CDATA[<?xml version="1.0"?>
+            <MIME-resolver>
+                <file>
+                    <pattern value="invalid1" range="255" ignorecase="true">
+                        <pattern value="inner1" range="4000"/>
+                        <pattern value="inner2" range="4000"/>
+                    </pattern>
+                    <pattern value="invalid2" range="255" ignorecase="true">
+                        <pattern value="inner1" range="4000">
+                            <pattern value="inner2" range="4000"/>
+                            <pattern value="inner3" range="4000"/>
+                        </pattern>
+                    </pattern>
+                    <resolver mime="text/x-php5"/>
+                </file>
+            </MIME-resolver>]]>
+        </file>
+        <file name="pattern-resolver-invalid2.xml"><![CDATA[<?xml version="1.0"?>
+            <MIME-resolver>
+                <file>
+                    <pattern value="invalid2" range="255" ignorecase="true">
+                        <pattern value="inner1" range="4000">
+                            <pattern value="inner2" range="4000"/>
+                            <pattern value="inner3" range="4000"/>
+                        </pattern>
+                    </pattern>
+                    <resolver mime="text/x-php5"/>
+                </file>
+            </MIME-resolver>]]>
+        </file>
+        <file name="php-resolver1.xml"><![CDATA[<?xml version="1.0"?>
+            <MIME-resolver>
+                <file>
+                    <!-- Pattern <?php in first 100 bytes -->
+                    <pattern value="&lt;?php" range="100"/>
+                    <!-- Pattern <HTML> or <html> in first 100 bytes and pattern <?php in first 500 bytes. -->
+                    <pattern value="&lt;HTML&gt;" range="100" ignorecase="true">
+                        <pattern value="&lt;?php" range="500"/>
+                    </pattern>
+                    <resolver mime="text/x-php5"/>
+                </file>
+            </MIME-resolver>]]>
+        </file>
+        <file name="php-resolver2.xml"><![CDATA[<?xml version="1.0"?>
+            <MIME-resolver>
+                <file>
+                    <!-- Pattern <html> in first 500 bytes and pattern <?php in first 500 bytes. -->
+                    <pattern value="&lt;html&gt;" range="500">
+                        <pattern value="&lt;?php" range="500"/>
+                    </pattern>
+                    <resolver mime="text/x-php5"/>
+                </file>
+            </MIME-resolver>]]>
+        </file>
+        <file name="php-resolver3.xml"><![CDATA[<?xml version="1.0"?>
+            <MIME-resolver>
+                <file>
+                    <!-- Pattern <!doctype html in first 100 bytes and pattern <?php in first 500 bytes. -->
+                    <pattern value="&lt;!doctype html" range="100">
+                        <pattern value="&lt;?php" range="500"/>
+                    </pattern>
+                    <!-- Pattern <HTML> in first 100 bytes and pattern <?php in first 500 bytes. -->
+                    <pattern value="&lt;HTML&gt;" range="100">
+                        <pattern value="&lt;?php" range="500"/>
+                    </pattern>
+                    <!-- Pattern <html> in first 100 bytes and pattern <?php in first 500 bytes and pattern Define in first 500 bytes. -->
+                    <pattern value="&lt;html&gt;" range="100">
+                        <pattern value="&lt;?php" range="500">
+                            <pattern value="Define" range="500"/>
+                        </pattern>
+                    </pattern>
+                    <resolver mime="text/x-php5"/>
+                </file>
+            </MIME-resolver>]]>
+        </file>
+        <file name="ruby-resolver.xml"><![CDATA[<?xml version="1.0"?>
+            <MIME-resolver>
+                <file>
+                    <ext name=""/>
+                    <ext name="cgi"/>
+                    <!-- Pattern #! in first 2 bytes and pattern ruby in first 80 bytes.
+                         Should match for example #!/usr/bin/ruby but it can mistakenly
+                         match if ruby is in the middle of path.
+                    -->
+                    <pattern value="#!" range="2">
+                        <pattern value="ruby" range="80"/>
+                    </pattern>
+                    <resolver mime="text/x-ruby"/>
+                </file>
+            </MIME-resolver>]]>
+        </file>
+        <file name="makefile-resolver.xml"><![CDATA[<?xml version="1.0"?>
+            <MIME-resolver>
+                <file>
+                    <!-- Filename matches makefile, Makefile, MaKeFiLe, mymakefile, gnumakefile, makefile1, .... -->
+                    <name name="makefile" substring="true" ignorecase="true"/>
+                    <resolver mime="text/x-make"/>
+                </file>
+            </MIME-resolver>]]>
+        </file>
+        <file name="rakefile-resolver.xml"><![CDATA[<?xml version="1.0"?>
+            <MIME-resolver>
+                <file>
+                    <!-- Filename matches exactly rakefile and Rakefile. -->
+                    <name name="rakefile" ignorecase="false"/>
+                    <name name="Rakefile" ignorecase="false"/>
+                    <resolver mime="text/x-ruby"/>
+                </file>
+            </MIME-resolver>]]>
+        </file>
+        <file name="empty-extension-resolver.xml"><![CDATA[<?xml version="1.0"?>
+            <MIME-resolver>
+                <file>
+                    <ext name=""/>
+                    <resolver mime="empty/extension"/>
+                </file>
+            </MIME-resolver>]]>
+        </file>
+        <file name="cpp-resolver.xml"><![CDATA[<?xml version="1.0"?>
+            <MIME-resolver>
+                <file>
+                    <ext name=""/>
+                    <!-- Pattern // in first 2 bytes and pattern -*- C++ -*- in first 80 bytes. -->
+                    <pattern value="//" range="2">
+                        <pattern value="-*- C++ -*-" range="80"/>
+                    </pattern>
+                    <!-- Pattern #include in first 80 bytes. -->
+                    <pattern value="#include" range="80"/>
+                    <resolver mime="text/x-c++"/>
+                </file>
+            </MIME-resolver>]]>
+        </file>
+        <file name="exit-resolver.xml"><![CDATA[<?xml version="1.0"?>
+            <MIME-resolver>
+                <file>
+                    <!-- Do not resolve *.txt files. -->
+                    <ext name="txt"/>
+                    <exit/>
+                </file>
+                <file>
+                    <!-- Use this only for other than *.txt files. -->
+                    <ext name="txt"/>
+                    <resolver mime="text/plain"/>
+                </file>
+            </MIME-resolver>]]>
+        </file>
     </folder>
 </filesystem>
diff --git a/openide.filesystems/test/unit/src/org/netbeans/modules/openide/filesystems/declmime/data-fs.xml b/openide.filesystems/test/unit/src/org/netbeans/modules/openide/filesystems/declmime/data-fs.xml
--- a/openide.filesystems/test/unit/src/org/netbeans/modules/openide/filesystems/declmime/data-fs.xml
+++ b/openide.filesystems/test/unit/src/org/netbeans/modules/openide/filesystems/declmime/data-fs.xml
@@ -37,5 +37,44 @@
         "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
     ]]>
     </file>
+        <file name="php.txt"><![CDATA[
+<?php
+        ]]>
+        </file>
+        <file name="not-php.txt"><![CDATA[
+This is not php file.
+        ]]>
+        </file>
+        <file name="html-php.txt"><![CDATA[
+<!DOCTYPE HTML
+<html>
+0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
+<?php
+define
+        ]]>
+        </file>
+        <file name="ruby.cgi"><![CDATA[
+#!  /usr/bin/ruby
+        ]]>
+        </file>
+        <file name="makefile"/>
+        <file name="Makefile"/>
+        <file name="MaKeFiLe"/>
+        <file name="mymakefile"/>
+        <file name="gnumakefile"/>
+        <file name="makefile1"/>
+        <file name="makefileRakefile"/>
+        <file name="makefile.Rakefile"/>
+        <file name="rakefile"/>
+        <file name="Rakefile"/>
+        <file name="empty-extension"/>
+        <file name="cpp"><![CDATA[
+//    -*- C++ -*-
+        ]]>
+        </file>
+        <file name="cpp.not"><![CDATA[
+//    -*- C++ -*-
+        ]]>
+        </file>
     </folder>
 </filesystem>