Index: compile_rules_graph.py
==================================================================
--- compile_rules_graph.py
+++ compile_rules_graph.py
@@ -358,11 +358,11 @@
         elif sFuncName.startswith("g_m_"): # message
             sParams = "lToken, nTokenOffset"
         elif sFuncName.startswith("_g_s_"): # suggestion
             sParams = "lToken, nTokenOffset"
         elif sFuncName.startswith("_g_p_"): # preprocessor
-            sParams = "lToken"
+            sParams = "lToken, nTokenOffset"
         elif sFuncName.startswith("_g_d_"): # disambiguator
             sParams = "lToken, nTokenOffset"
         else:
             print("# Unknown function type in [" + sFuncName + "]")
             continue

Index: gc_core/py/lang_core/gc_engine.py
==================================================================
--- gc_core/py/lang_core/gc_engine.py
+++ gc_core/py/lang_core/gc_engine.py
@@ -771,11 +771,11 @@
                                         if bDebug:
                                             print("ERROR:", sRuleId, dError[nErrorStart])
                             elif cActionType == "~":
                                 # text processor
                                 nEndToken = (nTokenOffset + eAct[1])  if eAct[1]  else nLastToken
-                                self._tagAndPrepareTokenForRewriting(sWhat, nTokenOffset + eAct[0], nEndToken, bDebug)
+                                self._tagAndPrepareTokenForRewriting(sWhat, nTokenOffset + eAct[0], nEndToken, nTokenOffset, bDebug)
                                 if bDebug:
                                     print("RW:", sRuleId)
                                 bChange = True
                             elif cActionType == "=":
                                 # disambiguation
@@ -786,11 +786,11 @@
                                 # we do nothing, this test is just a condition to apply all following actions
                                 if bDebug:
                                     print(">>>", sRuleId)
                                 pass
                             elif cActionType == "/":
-                                # tags
+                                # sentence tags
                                 nTokenTag = nTokenOffset + eAct[0]
                                 if sWhat not in self.dTags:
                                     self.dTags[sWhat] = (nTokenTag, nTokenTag)
                                 elif nTokenTag > self.dTags[sWhat][1]:
                                     self.dTags[sWhat] = (self.dTags[sWhat][0], nTokenTag)
@@ -890,11 +890,11 @@
         for m in re.finditer(r"\\([0-9]+)", sMsg):
             sMsg = sMsg.replace(m.group(0), self.lToken[int(m.group(1))+nTokenOffset]["sValue"])
         #print(">", sMsg)
         return sMsg
 
-    def _tagAndPrepareTokenForRewriting (self, sWhat, nTokenRewriteStart, nTokenRewriteEnd, bUppercase=True, bDebug=False):
+    def _tagAndPrepareTokenForRewriting (self, sWhat, nTokenRewriteStart, nTokenRewriteEnd, nTokenOffset, bUppercase=True, bDebug=False):
         "text processor: rewrite tokens between <nTokenRewriteStart> and <nTokenRewriteEnd> position"
         if bDebug:
             print("REWRITING:", nTokenRewriteStart, nTokenRewriteEnd)
         if sWhat == "*":
             # purge text
@@ -920,18 +920,20 @@
             else:
                 for i in range(nTokenRewriteStart, nTokenRewriteEnd+1):
                     self.lToken[i]["sNewValue"] = "_"
         else:
             if sWhat.startswith("="):
-                sWhat = globals()[sWhat[1:]](self.lToken)
+                sWhat = globals()[sWhat[1:]](self.lToken, nTokenOffset)
             bUppercase = bUppercase and self.lToken[nTokenRewriteStart]["sValue"][0:1].isupper()
             if nTokenRewriteEnd - nTokenRewriteStart == 0:
+                # one token
                 sWhat = sWhat + " " * (len(self.lToken[nTokenRewriteStart]["sValue"])-len(sWhat))
                 if bUppercase:
                     sWhat = sWhat[0:1].upper() + sWhat[1:]
                 self.lToken[nTokenRewriteStart]["sNewValue"] = sWhat
             else:
+                # several tokens
                 lTokenValue = sWhat.split("|")
                 if len(lTokenValue) != (nTokenRewriteEnd - nTokenRewriteStart + 1):
                     print("Error. Text processor: number of replacements != number of tokens.")
                     return
                 for i, sValue in zip(range(nTokenRewriteStart, nTokenRewriteEnd+1), lTokenValue):