Index: grammalecte-cli.py
==================================================================
--- grammalecte-cli.py
+++ grammalecte-cli.py
@@ -188,11 +188,19 @@
                         for lSugg in oSpellChecker.suggest(sWord):
                             echo(" | ".join(lSugg))
             elif sText.startswith(">"):
                 oSpellChecker.drawPath(sText[1:].strip())
             elif sText.startswith("="):
-                for sRes in oSpellChecker.select(sText[1:].strip()):
+                sSearch = sText[1:].strip()
+                if "=" in sSearch:
+                    nCut = sSearch.find("=")
+                    sFlexPattern = sSearch[0:nCut]
+                    sTagsPattern = sSearch[nCut+1:]
+                else:
+                    sFlexPattern = sSearch
+                    sTagsPattern = ""
+                for sRes in oSpellChecker.select(sFlexPattern, sTagsPattern):
                     echo(sRes)
             elif sText.startswith("/+ "):
                 oGrammarChecker.gce.setOptions({ opt:True  for opt in sText[3:].strip().split()  if opt in oGrammarChecker.gce.getOptions() })
                 echo("done")
             elif sText.startswith("/- "):

Index: graphspell-js/ibdawg.js
==================================================================
--- graphspell-js/ibdawg.js
+++ graphspell-js/ibdawg.js
@@ -416,38 +416,40 @@
 
     // morph (sWord) {
     //     is defined in constructor
     // }
     
-    * select (sPattern="") {
-        // generator: returns all entries which morphology fits <sPattern>
-        let zPattern = null;
-        if (sPattern !== "") {
-            try {
-                zPattern = new RegExp(sPattern);
-            }
-            catch (e) {
-                console.log("Error in regex pattern");
-                console.log(e.message);
-            }
-        }
-        yield* this._select1(zPattern, 0, "");
+    * select (sFlexPattern="", sTagsPattern="") {
+        // generator: returns all entries which flexion fits <sFlexPattern> and morphology fits <sTagsPattern>
+        let zFlexPattern = null;
+        let zTagsPattern = null;
+        try {
+            zFlexPattern = (sFlexPattern !== "") ? new RegExp(sFlexPattern) : null;
+            zTagsPattern = (sTagsPattern !== "") ? new RegExp(sTagsPattern) : null;
+        }
+        catch (e) {
+            console.log("Error in regex pattern");
+            console.log(e.message);
+        }
+        yield* this._select1(zFlexPattern, zTagsPattern, 0, "");
     }
 
     // VERSION 1
 
-    * _select1 (zPattern, iAddr, sWord) {
+    * _select1 (zFlexPattern, zTagsPattern, iAddr, sWord) {
         // recursive generator
         for (let [nVal, jAddr] of this._getArcs1(iAddr)) {
             if (nVal <= this.nChar) {
                 // simple character
-                yield* this._select1(zPattern, jAddr, sWord + this.lArcVal[nVal]);
+                yield* this._select1(zFlexPattern, zTagsPattern, jAddr, sWord + this.lArcVal[nVal]);
             } else {
-                let sEntry = sWord + "\t" + this.funcStemming(sWord, this.lArcVal[nVal]);
-                for (let [nMorphVal, _] of this._getArcs1(jAddr)) {
-                    if (!zPattern || zPattern.test(this.lArcVal[nMorphVal])) {
-                        yield sEntry + "\t" + this.lArcVal[nMorphVal];
+                if (!zFlexPattern || zFlexPattern.test(sWord)) {
+                    let sEntry = sWord + "\t" + this.funcStemming(sWord, this.lArcVal[nVal]);
+                    for (let [nMorphVal, _] of this._getArcs1(jAddr)) {
+                        if (!zTagsPattern || zTagsPattern.test(this.lArcVal[nMorphVal])) {
+                            yield sEntry + "\t" + this.lArcVal[nMorphVal];
+                        }
                     }
                 }
             }
         }
     }            

Index: graphspell-js/spellchecker.js
==================================================================
--- graphspell-js/spellchecker.js
+++ graphspell-js/spellchecker.js
@@ -230,23 +230,23 @@
         if (this.bPersonalDic) {
             yield this.oPersonalDic.suggest(sWord, nSuggLimit);
         }
     }
 
-    * select (sPattern="") {
-        // generator: returns all entries which morphology fits <sPattern>
-        yield* this.oMainDic.select(sPattern)
+    * select (sFlexPattern="", sTagsPattern="") {
+        // generator: returns all entries which flexion fits <sFlexPattern> and morphology fits <sTagsPattern>
+        yield* this.oMainDic.select(sFlexPattern, sTagsPattern)
         if (this.bExtendedDic) {
-            yield* this.oExtendedDic.select(sPattern);
+            yield* this.oExtendedDic.select(sFlexPattern, sTagsPattern);
         }
         if (this.bCommunityDic) {
-            yield* this.oCommunityDic.select(sPattern);
+            yield* this.oCommunityDic.select(sFlexPattern, sTagsPattern);
         }
         if (this.bPersonalDic) {
-            yield* this.oPersonalDic.select(sPattern);
+            yield* this.oPersonalDic.select(sFlexPattern, sTagsPattern);
         }
     }
 }
 
 if (typeof(exports) !== 'undefined') {
     exports.SpellChecker = SpellChecker;
 }

Index: graphspell/ibdawg.py
==================================================================
--- graphspell/ibdawg.py
+++ graphspell/ibdawg.py
@@ -407,36 +407,40 @@
             return
         if iPos >= 0:
             print("\n   "+ " " * iPos + "|")
             self.drawPath(sWord[1:], iNextNodeAddr)
 
-    def select (self, sPattern=""):
-        "generator: returns all entries which morphology fits <sPattern>"
-        zPattern = None
-        if sPattern:
-            try:
-                zPattern = re.compile(sPattern)
-            except:
-                print("# Error in regex pattern")
-                traceback.print_exc()
-        yield from self._select1(zPattern, 0, "")
+    def select (self, sFlexPattern="", sTagsPattern=""):
+        "generator: returns all entries which flexion fits <sFlexPattern> and morphology fits <sTagsPattern>"
+        zFlexPattern = None
+        zTagsPattern = None
+        try:
+            if sFlexPattern:
+                zFlexPattern = re.compile(sFlexPattern)
+            if sTagsPattern:
+                zTagsPattern = re.compile(sTagsPattern)
+        except:
+            print("# Error in regex pattern")
+            traceback.print_exc()
+        yield from self._select1(zFlexPattern, zTagsPattern, 0, "")
 
     # def morph (self, sWord):
     #     is defined in __init__
 
     # VERSION 1
-    def _select1 (self, zPattern, iAddr, sWord):
+    def _select1 (self, zFlexPattern, zTagsPattern, iAddr, sWord):
         # recursive generator
         for nVal, jAddr in self._getArcs1(iAddr):
             if nVal <= self.nChar:
                 # simple character
-                yield from self._select1(zPattern, jAddr, sWord + self.lArcVal[nVal])
+                yield from self._select1(zFlexPattern, zTagsPattern, jAddr, sWord + self.lArcVal[nVal])
             else:
-                sEntry = sWord + "\t" + self.funcStemming(sWord, self.lArcVal[nVal])
-                for nMorphVal, _ in self._getArcs1(jAddr):
-                    if not zPattern or zPattern.search(self.lArcVal[nMorphVal]):
-                        yield sEntry + "\t" + self.lArcVal[nMorphVal]
+                if not zFlexPattern or zFlexPattern.search(sWord):
+                    sEntry = sWord + "\t" + self.funcStemming(sWord, self.lArcVal[nVal])
+                    for nMorphVal, _ in self._getArcs1(jAddr):
+                        if not zTagsPattern or zTagsPattern.search(self.lArcVal[nMorphVal]):
+                            yield sEntry + "\t" + self.lArcVal[nMorphVal]
 
     def _morph1 (self, sWord):
         "returns morphologies of <sWord>"
         iAddr = 0
         for c in sWord:

Index: graphspell/spellchecker.py
==================================================================
--- graphspell/spellchecker.py
+++ graphspell/spellchecker.py
@@ -191,19 +191,19 @@
         if self.bCommunityDic:
             yield self.oCommunityDic.suggest(sWord, nSuggLimit)
         if self.bPersonalDic:
             yield self.oPersonalDic.suggest(sWord, nSuggLimit)
 
-    def select (self, sPattern=""):
-        "generator: returns all entries which morphology fits <sPattern>"
-        yield from self.oMainDic.select(sPattern)
+    def select (self, sFlexPattern="", sTagsPattern=""):
+        "generator: returns all entries which flexion fits <sFlexPattern> and morphology fits <sTagsPattern>"
+        yield from self.oMainDic.select(sFlexPattern, sTagsPattern)
         if self.bExtendedDic:
-            yield from self.oExtendedDic.select(sPattern)
+            yield from self.oExtendedDic.select(sFlexPattern, sTagsPattern)
         if self.bCommunityDic:
-            yield from self.oCommunityDic.select(sPattern)
+            yield from self.oCommunityDic.select(sFlexPattern, sTagsPattern)
         if self.bPersonalDic:
-            yield from self.oPersonalDic.select(sPattern)
+            yield from self.oPersonalDic.select(sFlexPattern, sTagsPattern)
 
     def drawPath (self, sWord):
         self.oMainDic.drawPath(sWord)
         if self.bExtendedDic:
             print("-----")