fixes #2559

compiler/syntaxes.nim

@@ -92,10 +92,15 @@ proc parsePipe(filename: string, inputStream: PLLStream): PNode =
     var line = newStringOfCap(80)
     discard llStreamReadLine(s, line)
     var i = utf8Bom(line)
+    var linenumber = 1
     if containsShebang(line, i):
       discard llStreamReadLine(s, line)
       i = 0
-    if line[i] == '#' and line[i+1] == '!':
+      inc linenumber
+    if line[i] == '#' and line[i+1] in {'?', '!'}:
+      if line[i+1] == '!':
+        message(newLineInfo(filename, linenumber, 1),
+                warnDeprecated, "use '#?' instead; '#!'")
       inc(i, 2)
       while line[i] in Whitespace: inc(i)
       var q: TParser

doc/filelist.txt

@@ -4,12 +4,12 @@ Short description of Nim's modules
 ==============  ==========================================================
 Module          Description
 ==============  ==========================================================
-nim          main module: parses the command line and calls
+nim             main module: parses the command line and calls
                 ``main.MainCommand``
 main            implements the top-level command dispatching
 nimconf         implements the config file reader
 syntaxes        dispatcher for the different parsers and filters
-filter_tmpl     standard template filter (``#! stdtempl``)
+filter_tmpl     standard template filter (``#? stdtempl``)
 lexbase         buffer handling of the lexical analyser
 lexer           lexical analyser
 parser          Nim's parser

doc/filters.txt

@@ -8,9 +8,9 @@ A `Source Code Filter` transforms the input character stream to an in-memory
 output stream before parsing. A filter can be used to provide templating
 systems or preprocessors.
 
-To use a filter for a source file the *shebang* notation is used::
+To use a filter for a source file the ``#?`` notation is used::
 
-  #! stdtmpl(subsChar = '$', metaChar = '#')
+  #? stdtmpl(subsChar = '$', metaChar = '#')
   #proc generateXML(name, age: string): string =
   #  result = ""
   <xml>
@@ -20,7 +20,8 @@ To use a filter for a source file the *shebang* notation is used::
 
 As the example shows, passing arguments to a filter can be done
 just like an ordinary procedure call with named or positional arguments. The
-available parameters depend on the invoked filter.
+available parameters depend on the invoked filter. Before version 0.12.0 of
+the language ``#!`` was used instead of ``#?``.
 
 
 Pipe operator
@@ -28,7 +29,7 @@ Pipe operator
 
 Filters can be combined with the ``|`` pipe operator::
 
-  #! strip(startswith="<") | stdtmpl
+  #? strip(startswith="<") | stdtmpl
   #proc generateXML(name, age: string): string =
   #  result = ""
   <xml>
@@ -104,7 +105,7 @@ Parameters and their defaults:
 
 Example::
 
-  #! stdtmpl | standard
+  #? stdtmpl | standard
   #proc generateHTMLPage(title, currentTab, content: string,
   #                      tabs: openArray[string]): string =
   #  result = ""
@@ -172,7 +173,7 @@ produces ``$``.
 The template engine is quite flexible. It is easy to produce a procedure that
 writes the template code directly to a file::
 
-  #! stdtmpl(emit="f.write") | standard
+  #? stdtmpl(emit="f.write") | standard
   #proc writeHTMLPage(f: File, title, currentTab, content: string,
   #                   tabs: openArray[string]) =
   <head><title>$title</title></head>

doc/manual/syntax.txt

@@ -68,13 +68,13 @@ Strong spaces
 -------------
 
 The number of spaces preceding a non-keyword operator affects precedence
-if the experimental parser directive ``#!strongSpaces`` is used. Indentation
+if the experimental parser directive ``#?strongSpaces`` is used. Indentation
 is not used to determine the number of spaces. If 2 or more operators have the
 same number of preceding spaces the precedence table applies, so ``1 + 3 * 4``
 is still parsed as ``1 + (3 * 4)``, but ``1+3 * 4`` is parsed as ``(1+3) * 4``:
 
 .. code-block:: nim
-  #! strongSpaces
+  #? strongSpaces
   if foo+4 * 4 == 8  and  b&c | 9  ++
       bar:
     echo ""
@@ -86,7 +86,7 @@ Furthermore whether an operator is used a prefix operator is affected by the
 number of spaces:
 
 .. code-block:: nim
-  #! strongSpaces
+  #? strongSpaces
   echo $foo
   # is parsed as
   echo($foo)
@@ -95,7 +95,7 @@ This also affects whether ``[]``, ``{}``, ``()`` are parsed as constructors
 or as accessors:
 
 .. code-block:: nim
-  #! strongSpaces
+  #? strongSpaces
   echo (1,2)
   # is parsed as
   echo((1,2))

tools/website.tmpl

@@ -1,5 +1,5 @@
-#! stdtmpl | standard
-#proc generateHTMLPage(c: var TConfigData, currentTab, content, rss: string): string = 
+#? stdtmpl | standard
+#proc generateHTMLPage(c: var TConfigData, currentTab, content, rss: string): string =
 #  result = ""
 <!DOCTYPE html>
 <html>
@@ -23,7 +23,7 @@
       # if t != "index" and t != "community" and t != "news":
       #   let name = c.tabs[i].key
       #   if currentTab == t:
-            <a class="active" 
+            <a class="active"
       #   else:
             <a
       #   end if
@@ -104,7 +104,7 @@ p.greet() <span class="cmt"># or greet(p)</span>
 <span class="cmt"># declare a C procedure..</span>
 <span class="kwd">proc</span> <span class="def">unsafeScanf</span>(f: <span class="typ">File</span>, s: <span class="typ">cstring</span>)
 <span class="tab">  </span>{.varargs,
-<span class="tab">    </span>importc: <span class="val">"fscanf"</span>, 
+<span class="tab">    </span>importc: <span class="val">"fscanf"</span>,
 <span class="tab end">    </span>header: <span class="val">"&lt;stdio.h&gt;"</span>.}
 
 <span class="cmt"># ..and use it...</span>
@@ -191,7 +191,7 @@ runForever()
 				</div>
 			</div>
 		</footer>
-  
+
 #  if currentTab == "index":
   <script src="assets/index.js"></script>
 # end if

web/news.txt

@@ -71,6 +71,8 @@ News
     are likely to break as well.
   - Base methods now need to be annotated with the ``base`` pragma. This makes
     multi methods less error-prone to use with the effect system.
+  - Nim's parser directive ``#!`` is now ``#?`` in order to produce no conflicts
+    with Unix's ``#!``.
 
 
   Library Additions