From e69db9954057b6df99e8e666b199e499aec12007 Mon Sep 17 00:00:00 2001
From: Tom Ryder <tom@sanctum.geek.nz>
Date: Fri, 2 Jun 2017 22:52:40 +1200
Subject: Implemented an idea

Slightly cleverer parsing for mi5
---
 IDEAS.markdown   |  2 --
 bin/mi5.awk      | 54 ++++++++++++++++++++++++++++++++++++------------------
 man/man1/mi5.1df | 34 ++++++++++++++++++++--------------
 3 files changed, 56 insertions(+), 34 deletions(-)

diff --git a/IDEAS.markdown b/IDEAS.markdown
index 61f1049d..3b0f1c75 100644
--- a/IDEAS.markdown
+++ b/IDEAS.markdown
@@ -12,5 +12,3 @@ Ideas
     processes and mkfifo(1).
 *   Write something like hcat(1df) or tcat(1df) that includes filename headings
     for each concatenated file.
-*   mi5(1df) could be made to handle comment delimiters and $1 $2 expansions
-    without too much pain (substr/index counting)
diff --git a/bin/mi5.awk b/bin/mi5.awk
index 46bbbb25..1ddc5a2f 100644
--- a/bin/mi5.awk
+++ b/bin/mi5.awk
@@ -16,33 +16,51 @@ NF == 1 && $1 == "%>" && mac {
     next
 }
 
-# If processing macros, strip leading and trailing whitespace and skip blank
-# lines
-mac {
+# If in a block, print each line with any content on it after stripping leading
+# and trailing whitespace
+mac && NF {
     sub(/^ */, "")
     sub(/ *$/, "")
-}
-mac && !NF { next }
-
-# Inlines
-mac {
     print $0 "dnl"
 }
+
+# If not in a block, look for inlines to process
 !mac {
 
-    # Don't let apostrophes close the comment
-    gsub(/'/, "''`")
+    # We'll empty one variable into another
+    src = $0
+    dst = ""
+
+    # As long as there's a pair of opening and closing tags
+    while (src ~ /<%.*%>/) {
 
-    # Replace m5 opener with m4 closer
-    gsub(/<% */, "'")
+        # Read up to opening tag into seg, shift from src
+        ind = index(src, "<%")
+        seg = substr(src, 1, ind - 1)
+        src = substr(src, ind)
 
-    # Replace m5 closer with m4 opener
-    gsub(/ *%>/, "`")
+        # Escape quote closer and add to dst
+        gsub(/'/, "''`", seg)
+        dst = dst seg
 
-    print
+        # Read up to closing tag into seg, shift from src
+        ind = index(src, "%>")
+        seg = substr(src, 1, ind + 1)
+        src = substr(src, ind + 2)
+
+        # Translate tags to quote open and close and add to dst
+        sub(/^<% */ , "'", seg)
+        sub(/ *%>$/ , "`", seg)
+        dst = dst seg
+    }
+
+    # Escape quote closers in whatever's left
+    gsub(/'/, "''`", src)
+
+    # Tack that onto the end, and print it
+    dst = dst src
+    print dst
 }
 
 # Print an m4 closer and newline deleter as the last bytes
-END {
-    print "'dnl"
-}
+END { print "'dnl" }
diff --git a/man/man1/mi5.1df b/man/man1/mi5.1df
index 7782ebce..04f964c1 100644
--- a/man/man1/mi5.1df
+++ b/man/man1/mi5.1df
@@ -20,21 +20,23 @@ and predictable for its author, who wants badly to like m4 but doesn't. It's
 primarily intended for situations where the majority of a file is simple static
 text, and only a few simple macros need to be defined and expanded, which
 covers almost every usage case for the author. It's written to work with any
-POSIX m4.
+POSIX awk and to generate output for any POSIX m4.
 .P
 mi5 inverts m4's usual approach by approaching most of the file as if it were
 part of an m4 quote, with <% and %> as the delimiters to specify markers in
-which macro expansion should occur. This makes m4 work in a way reminiscent of
-templating libraries or languages like PHP.
+which macro expansion should occur. This is therefore a way to shoehorn m4 into
+working in a way reminiscent of templating libraries or languages like PHP.
 .P
 Macros can be expanded as blocks:
 .P
     <%
-    define(`FOO', `bar')
-    define(`BAZ', include(`include/quux.inc')
-    ?>
+
+        define(`FOO', `bar')
+        define(`BAZ', include(`include/quux.inc')
+
+    %>
 .P
-For this format, "dnl" macros to delete newlines for each declaration are
+For this format, `dnl' macros to delete newlines for each declaration are
 inserted for you. Blank lines are skipped, and leading and trailing spaces are
 ignored. The above code therefore produces no actual output, as it only has two
 define calls.
@@ -44,15 +46,19 @@ For inline expansion, the syntax is similar, but the behaviour slightly differen
     The value of the FOO macro is <% FOO %>.
 .P
 Spaces immediately after the opening delimiter and before the closing delimiter
-are ignored, but spaces produced within the macro are preserved.
+are ignored, but spaces produced within the macro are preserved. `dnl` macros
+are not inserted for inline blocks.
 .P
-Ideally, you do macro definition in an mi5 block at the top of your file, and
-very simple macro expansion in an mi5 inline.
+Ideally, you do your complex macro definition in a block at the top of your
+file, and your simple macro expansion of those results in an inline.
 .SH CAVEATS
-Only very simple macro expansions work in inline calls at the moment. This can
-be fixed by the author tokenizing the line properly, which he'll do Real Soon
-Now (TM). Specifically, quote delimiters do not work.
+The <% delimiters %> are hardcoded for now.
+.P
+Inline expansions cannot span multiple lines. Use blocks for that.
+.P
+Doesn't cope at all with `changequote'. If you need that, you should probably
+write raw m4.
 .SH SEE ALSO
-bp(1df), xargs(1)
+m4(1)
 .SH AUTHOR
 Tom Ryder <tom@sanctum.geek.nz>
-- 
cgit v1.2.3