Use proper terminology for macros ("macros", not "tokens")

README.md

     If you want to really build "serious" "big" stuff from hundreds of
     source files, MKit is probably not for you.  Nobody has ever tried
     to use it that way.  What MKit understands as "building" is just
-    replacing tokens in files.  (Some extensibility will  be added in
+    replacing macros in files.  (Some extensibility will  be added in
     future but scaling to huge things is not a priority for now.)
 
  *  Become a complete solution for building all your RPMs and DEBs.
     `make debstuff` under your belt).  You can use `utils/mkit/stub` script
     for that.
 
- *  Add tokens inside some of your scripts to include stuff known
+ *  Add macros inside some of your scripts to include stuff known
     only at install time (versions, paths...) so that your application
     can report --version as accurately as possible.
 
     and see how MKit handles versioning.
 
 MKit uses SemVer so version reflected in tarbal naming, packaging
-files and tokens contains enough data to track it back to actual commit.
+files and macros contains enough data to track it back to actual commit.
 This way you can safely distribute packages immediately to your testers
 and/or CI systems.

src/include/build.sh

     #
     local ftype=$1      # file/builder type
     case $ftype in
-        MKIT_COMMON)    __expand_tokens "tokens" ;;
-        rpmstuff)       __expand_tokens "tokens" "rpmstuff:tokens" ;;
-        debstuff)       __expand_tokens "tokens" "debstuff:tokens" ;;
+        MKIT_COMMON)    __expand_macros "macros" ;;
+        rpmstuff)       __expand_macros "macros" "rpmstuff:macros" ;;
+        debstuff)       __expand_macros "macros" "debstuff:macros" ;;
         *)              die "unknown file type: $ftype" ;;
     esac
 }
 
-__expand_tokens() {
+__expand_macros() {
     #
-    # Read stdin, expanding tokens from sections $@
+    # Read stdin, expanding macros from sections $@
     #
     local script        # sed script cache
-    local section       # each section to expand tokens from
-    local varname       # each token name
-    local varvalue      # each token value
+    local section       # each section to expand macros from
+    local varname       # each macro name
+    local varvalue      # each macro value
     script=$(mktemp --tmpdir mkit-tmp.XXXXXXXXXX)
     {
         for section in "$@"; do
         echo "s|__MKIT_PROJ_VERSION__|$(__cached semver | __qfs)|g;"
         echo "s|__MKIT_SELF_VERSION__|$MKIT_VERSION|g;"
     } >> "$script"
-    sed -f "$script" || die "__expand_tokens failed"
+    sed -f "$script" || die "__expand_macros failed"
     rm "$script"
 }
 
 
 _mkit_data() {
     #
-    # Build sampler showing all token values
+    # Build sampler showing all macro values
     #
-    local token
+    local macro
     local section
     local sections
     sections=()
-    ini lskeys tokens | grep -q . && sections=(tokens)
-    sections+=( $(ini lssect | grep ':tokens$') )
+    ini lskeys macros | grep -q . && sections=(macros)
+    sections+=( $(ini lssect | grep ':macros$') )
     {
         echo "(builtin):"
         echo "  x_MKIT_PROJ_NAME__ => '__MKIT_PROJ_NAME__'"
         echo "  x_MKIT_SELF_VERSION__ => '__MKIT_SELF_VERSION__'"
         for section in "${sections[@]}"; do
             echo "$section:"
-            for token in $(ini lskeys "$section"); do
-                echo "  x${token:1} => '$token'"
+            for macro in $(ini lskeys "$section"); do
+                echo "  x${macro:1} => '$macro'"
             done
         done
     } \
-      | __expand_tokens "MKIT_BUILTIN" "${sections[@]}" \
+      | __expand_macros "MKIT_BUILTIN" "${sections[@]}" \
       | sed '/^  x/ s|x|_|'
 }
 

src/include/vars.sh.skel

 #
 # Package name
 #
-# Used as base for tarball and in some default tokens.
+# Used as base for tarball and in some default macros.
 #
 MKIT_PROJ_PKGNAME=""
 

src/stub

                 remake_section dist
                 remake_section ENV
                 remake_section roots
-                remake_section tokens
+                remake_section macros
                 remake_section modes
                 remake_section files
             else
                     echo "doc = [ENV:PREFIX]/share/doc/$PackageName"
                 } | reformat_section
                 echo ""
-                echo "[tokens]"
+                echo "[macros]"
                 {
                     echo "__${PackageName^^}_FOO__ = Barr.."
                 } | reformat_section
             echo "    machine should be uder 'src'."
             echo ""
             echo "    Note that during build time, files named ending with"
-            echo "    '.skel' are subject to token expansion, see mkit.ini"
+            echo "    '.skel' are subject to macro expansion, see mkit.ini"
             echo "    section below for details."
             echo ""
             echo " *  *notes* directory - here you shall store notes"
             echo " *  *packaging* directory contains templates that enable"
             echo "    MKit create raw stuffs used to create DEB or RPM"
             echo "    packages.  Similar to '.skel' files in 'src', all files"
-            echo "    here are automatically considered for token expansion,"
+            echo "    here are automatically considered for macro expansion,"
             echo "    no matter how they are named (see mkit.ini section"
             echo "    below)."
             echo ""
             echo "    \`[modes]\` section is your friend.  Permissions here"
             echo "    should be in UNIX octal format."
             echo ""
-            echo " 5. Next, \`[tokens]\` section allows you to define own"
+            echo " 5. Next, \`[macros]\` section allows you to define own"
             echo "    placeholders that will be replaced when your scripts are"
             echo "    built.  Each file in 'src' directory that is named with"
             echo "    '.skel' suffix, and each file from 'packaging' directory"
-            echo "    (no matter its name), can contain one or more of tokens"
-            echo "    defined here, plus range of tokens automatically defined"
-            echo "    by MKit.  During build, these tokens are replaced with"
+            echo "    (no matter its name), can contain one or more of macros"
+            echo "    defined here, plus range of macros automatically defined"
+            echo "    by MKit.  During build, these macros are replaced with"
             echo "    their actual values."
             echo ""
             echo " 6. Less interesting, but important section is \`[dist]\`,"