tools/Makefile/Makefile-tutorial.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Makefile Tutorial"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://makefiletutorial.com/"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Environment: WSL"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Makefile is a way of automating software building procedure and other complex tasks with dependencies.\n",
    "- The make utility is a software tool for managing and maintaining\n",
    "computer programs consisting many component files. The make utility\n",
    "automatically determines which pieces of a large program need to be\n",
    "recompiled, and issues commands to recompile them. \n",
    "- Makefile contains: dependency rules, macros and suffix(or implicit)\n",
    "rules. "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Install"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# input password for sudo\n",
    "import getpass\n",
    "mypw = getpass.getpass()\n",
    "with open(\"mypw\", \"w\") as file:\n",
    "    file.write(mypw)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading package lists... Done \n",
      "Building dependency tree... Done\n",
      "Reading state information... Done\n",
      "make is already the newest version (4.3-4.1build1).\n",
      "0 upgraded, 0 newly installed, 0 to remove and 49 not upgraded.\n"
     ]
    }
   ],
   "source": [
    "#!sudo apt install make # for terminal\n",
    "!sudo -S apt install make < mypw"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GNU Make 4.3\n",
      "Built for x86_64-pc-linux-gnu\n",
      "Copyright (C) 1988-2020 Free Software Foundation, Inc.\n",
      "License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\n",
      "This is free software: you are free to change and redistribute it.\n",
      "There is NO WARRANTY, to the extent permitted by law.\n"
     ]
    }
   ],
   "source": [
    "# check version\n",
    "\n",
    "!make -version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/usr/bin/make\n"
     ]
    }
   ],
   "source": [
    "# check build-essential\n",
    "!ls /usr/bin/make"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overview"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A simple makefile consists of \"rules\" with the following shape:\n",
    "\n",
    "```\n",
    "target ... : dependencies ...\n",
    "        command\n",
    "        ...\n",
    "        ...\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- A `target` is usually the name of a file that is generated by a program; examples of targets are executable or object files. A target can also be the name of an action to carry out, such as `clean'\n",
    "- A `dependency` is a file that is used as input to create the target. A target often depends on several files.\n",
    "- A `command` is an action that make carries out. A rule may have more than one command, each on its own line. Please note: you need to put a tab character at the beginning of every command line!\n",
    "- A `rule` explains how and when to remake certain files which are the targets of the particular rule. make carries out the commands on the dependencies to create or update the target.\n",
    "- We split each long line into two lines using backslash-newline\n",
    "- To use this makefile to create the executable file called `edit', type:"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A Simple Makefile"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. echo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting Makefile\n"
     ]
    }
   ],
   "source": [
    "%%writefile Makefile\n",
    "\n",
    "hello:\n",
    "\techo \"Hello, World 1\"\n",
    "\techo \"This line will always print, \\\n",
    "\t\tbecause the file hello does not exist.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "echo \"Hello, World 1\"\n",
      "Hello, World 1\n",
      "echo \"This line will always print, \\\n",
      "\tbecause the file hello does not exist.\"\n",
      "This line will always print, \tbecause the file hello does not exist.\n"
     ]
    }
   ],
   "source": [
    "!make"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We have one target called hello\n",
    "- This target has two commands\n",
    "- This target has no prerequisites"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Run c file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing blah.c\n"
     ]
    }
   ],
   "source": [
    "%%writefile blah.c\n",
    "int main() { return 0; }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting Makefile\n"
     ]
    }
   ],
   "source": [
    "%%writefile Makefile\n",
    "blah:\n",
    "\tcc blah.c -o blah"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "make: 'blah' is up to date.\n"
     ]
    }
   ],
   "source": [
    "!make"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The first time you run this, blah will be created. The second time, you'll see make: 'blah' is up to date. That's because the blah file already exists. \n",
    "\n",
    "- But there's a problem: if we modify blah.c and then run make, nothing gets recompiled."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting Makefile\n"
     ]
    }
   ],
   "source": [
    "%%writefile Makefile\n",
    "blah: blah.c\n",
    "\tcc blah.c -o blah"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cc blah.c -o blah\n"
     ]
    }
   ],
   "source": [
    "!make"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The first target is selected, because the first target is the default target\n",
    "- This has a prerequisite of blah.c\n",
    "- Make decides if it should run the blah target. It will only run if blah doesn't exist, or blah.c is newer than blah"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Simple piepline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting Makefile\n"
     ]
    }
   ],
   "source": [
    "%%writefile Makefile\n",
    "blah: blah.o\n",
    "\tcc blah.o -o blah # Runs third\n",
    "\n",
    "blah.o: blah.c\n",
    "\tcc -c blah.c -o blah.o # Runs second\n",
    "\n",
    "# Typically blah.c would already exist, but I want to limit any additional required files\n",
    "blah.c:\n",
    "\techo \"int main() { return 0; }\" > blah.c # Runs first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "make: 'blah' is up to date.\n"
     ]
    }
   ],
   "source": [
    "!make"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "!mkdir img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "!makefile2dot | dot -Tpng > img/diagram3.png"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/diagram3.png\">"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Make selects the target blah, because the first target is the default target\n",
    "- blah requires blah.o, so make searches for the blah.o target\n",
    "- blah.o requires blah.c, so make searches for the blah.c target\n",
    "- blah.c has no dependencies, so the echo command is run\n",
    "- The cc -c command is then run, because all of the blah.o dependencies are finished\n",
    "- The top cc command is run, because all the blah dependencies are finished"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting Makefile\n"
     ]
    }
   ],
   "source": [
    "%%writefile Makefile\n",
    "\n",
    "some_file: other_file\n",
    "\techo \"This will always run, and runs second\"\n",
    "\ttouch some_file\n",
    "\n",
    "other_file:\n",
    "\techo \"This will always run, and runs first\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "echo \"This will always run, and runs first\"\n",
      "This will always run, and runs first\n",
      "echo \"This will always run, and runs second\"\n",
      "This will always run, and runs second\n",
      "touch some_file\n"
     ]
    }
   ],
   "source": [
    "!make"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- It will always run both targets, because some_file depends on other_file, which is never created."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Make clean"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`clean` is often used as a target that removes the output of other targets, but it is not a special word in Make. You can run `make` and `make clean` on this to create and delete some_file."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "clean is doing two new things here:\n",
    "- It's a target that is not first (the default), and not a prerequisite. That means it'll never run unless you explicitly call make clean\n",
    "- It's not intended to be a filename. If you happen to have a file named clean, this target won't run, which is not what we want. See `.PHONY` later in this tutorial on how to fix this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting Makefile\n"
     ]
    }
   ],
   "source": [
    "%%writefile Makefile\n",
    "some_file: \n",
    "\ttouch some_file\n",
    "\n",
    "clean:\n",
    "\trm -f some_file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "touch some_file\n"
     ]
    }
   ],
   "source": [
    "!make"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rm -f some_file\n"
     ]
    }
   ],
   "source": [
    "!make clean"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Variable"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables can only be strings. You'll typically want to use `:=`, but `=` also works. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting Makefile\n"
     ]
    }
   ],
   "source": [
    "%%writefile Makefile\n",
    "\n",
    "files := file1 file2\n",
    "some_file: $(files)\n",
    "\techo \"Look at this variable: \" $(files)\n",
    "\ttouch some_file\n",
    "\n",
    "file1:\n",
    "\ttouch file1\n",
    "file2:\n",
    "\ttouch file2\n",
    "\n",
    "clean:\n",
    "\trm -f file1 file2 some_file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "touch file1\n",
      "touch file2\n",
      "echo \"Look at this variable: \" file1 file2\n",
      "Look at this variable:  file1 file2\n",
      "touch some_file\n"
     ]
    }
   ],
   "source": [
    "!make"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rm -f file1 file2 some_file\n"
     ]
    }
   ],
   "source": [
    "!make clean"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. Reference"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reference variables using either `${}` or `$()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting Makefile\n"
     ]
    }
   ],
   "source": [
    "%%writefile Makefile\n",
    "\n",
    "x := dude\n",
    "\n",
    "all:\n",
    "\techo $(x)\n",
    "\techo ${x}\n",
    "\n",
    "\t# Bad practice, but works\n",
    "\techo $x "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "echo dude\n",
      "dude\n",
      "echo dude\n",
      "dude\n",
      "# Bad practice, but works\n",
      "echo dude \n",
      "dude\n"
     ]
    }
   ],
   "source": [
    "!make"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. String Variable"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Single or double quotes have no meaning to Make. They are simply characters that are assigned to the variable. Quotes are useful to shell/bash, though, and you need them in commands like `printf`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting Makefile\n"
     ]
    }
   ],
   "source": [
    "%%writefile Makefile\n",
    "\n",
    "a := one two # a is assigned to the string \"one two\"\n",
    "b := 'one two' # Not recommended. b is assigned to the string \"'one two'\"\n",
    "all:\n",
    "\tprintf '$a'\n",
    "\tprintf $b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "printf 'one two '\n",
      "one two printf 'one two' \n",
      "one two"
     ]
    }
   ],
   "source": [
    "!make"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. The all target"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Making multiple targets and you want all of them to run? Make an `all` target. Since this is the first rule listed, it will run by default if make is called without specifying a target."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting Makefile\n"
     ]
    }
   ],
   "source": [
    "%%writefile Makefile\n",
    "\n",
    "all: one two three\n",
    "\n",
    "one:\n",
    "\ttouch one\n",
    "two:\n",
    "\ttouch two\n",
    "three:\n",
    "\ttouch three\n",
    "\n",
    "clean:\n",
    "\trm -f one two three"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "touch one\n",
      "touch two\n",
      "touch three\n"
     ]
    }
   ],
   "source": [
    "!make"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9. Multiple targets"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When there are multiple targets for a rule, the commands will be run for each target. `$@` is an automatic variable that contains the target name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting Makefile\n"
     ]
    }
   ],
   "source": [
    "%%writefile Makefile\n",
    "\n",
    "all: f1.o f2.o\n",
    "\n",
    "f1.o f2.o:\n",
    "\techo $@\n",
    "# Equivalent to:\n",
    "# f1.o:\n",
    "#\t echo f1.o\n",
    "# f2.o:\n",
    "#\t echo f2.o"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "echo f1.o\n",
      "f1.o\n",
      "echo f2.o\n",
      "f2.o\n"
     ]
    }
   ],
   "source": [
    "!make"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10. Wildcards"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Both `*` and `%` are called wildcards in Make, but they mean entirely different things. `*` searches your filesystem for matching filenames. I suggest that you always wrap it in the `wildcard` function, because otherwise you may fall into a common pitfall"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting Makefile\n"
     ]
    }
   ],
   "source": [
    "%%writefile Makefile\n",
    "\n",
    "# Print out file information about every .c file\n",
    "print: $(wildcard *.c)\n",
    "\tls  $?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ls  blah.c helloworld.c\n",
      "blah.c\thelloworld.c\n"
     ]
    }
   ],
   "source": [
    "!make"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `*` may be used in the target, prerequisites, or in the `wildcard` function.\n",
    "\n",
    "- Danger: `*` may not be directly used in a variable definitions\n",
    "\n",
    "- Danger: When `*` matches no files, it is left as it is (unless run in the `wildcard` function)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting Makefile\n"
     ]
    }
   ],
   "source": [
    "%%writefile Makefile\n",
    "\n",
    "thing_wrong := *.o # Don't do this! '*' will not get expanded\n",
    "thing_right := $(wildcard *.o)\n",
    "\n",
    "all: one two three four\n",
    "\n",
    "# Fails, because $(thing_wrong) is the string \"*.o\"\n",
    "one: $(thing_wrong)\n",
    "\n",
    "# Stays as *.o if there are no files that match this pattern :(\n",
    "two: *.o \n",
    "\n",
    "# Works as you would expect! In this case, it does nothing.\n",
    "three: $(thing_right)\n",
    "\n",
    "# Same as rule three\n",
    "four: $(wildcard *.o)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "make: Nothing to be done for 'all'.\n"
     ]
    }
   ],
   "source": [
    "!make"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11. % Wildcard"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`%` is really useful, but is somewhat confusing because of the variety of situations it can be used in.\n",
    "\n",
    "- When used in \"matching\" mode, it matches one or more characters in a string. This match is called the stem.\n",
    "- When used in \"replacing\" mode, it takes the stem that was matched and replaces that in a string.\n",
    "- `%` is most often used in rule definitions and in some specific functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting Makefile\n"
     ]
    }
   ],
   "source": [
    "%%writefile Makefile\n",
    "\n",
    "hey: one two\n",
    "\t# Outputs \"hey\", since this is the target name\n",
    "\techo $@\n",
    "\n",
    "\t# Outputs all prerequisites newer than the target\n",
    "\techo $?\n",
    "\n",
    "\t# Outputs all prerequisites\n",
    "\techo $^\n",
    "\n",
    "\ttouch hey\n",
    "\n",
    "one:\n",
    "\ttouch one\n",
    "\n",
    "two:\n",
    "\ttouch two\n",
    "\n",
    "clean:\n",
    "\trm -f hey one two"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# Outputs \"hey\", since this is the target name\n",
      "echo hey\n",
      "hey\n",
      "# Outputs all prerequisites newer than the target\n",
      "echo one two\n",
      "one two\n",
      "# Outputs all prerequisites\n",
      "echo one two\n",
      "one two\n",
      "touch hey\n"
     ]
    }
   ],
   "source": [
    "!make"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 12. Automatic Variables"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- These variables have values computed afresh for each rule that is executed, based on the target and prerequisites of the rule. \n",
    "\n",
    "- It is used when you are writing a pattern rule to compile a ‘.c’ file into a ‘.o’ file: how do you write the ‘cc’ command. You cannot write the name in the recipe, because the name is different each time the implicit rule is applied."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - `$@` for the object file name  (The file name of the target of the rule)\n",
    " - `$%` The target member name, when the target is an archive member. \n",
    " - `$<` for the source file name\n",
    " - `$?` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting Makefile\n"
     ]
    }
   ],
   "source": [
    "%%writefile Makefile\n",
    "\n",
    "onecopy:\n",
    "\tcp one $@"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cp one onecopy\n"
     ]
    }
   ],
   "source": [
    "!make"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting Makefile\n"
     ]
    }
   ],
   "source": [
    "%%writefile Makefile\n",
    "\n",
    "hello:\n",
    "\techo \"Hello, World 1\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/jingwora/Makefile-tutorial\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tsinfer",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "3e7889d32685d7bd3545250573ca1b788d42bef239306b18b2f0ba00d19c6c1a"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}