Switch to waf build system, first attempt

.gitignore

@@ -4,3 +4,4 @@ build
 tags
 .gdbinit
 popcorn.log
+.waf-*

Makefile

@@ -1,243 +0,0 @@
-ARCH           ?= x86_64
-
-include src/arch/$(ARCH)/config.mk
-
-BUILD_D        := build
-KERN_D         := src/kernel
-ARCH_D         := src/arch/$(ARCH)
-VERSION        ?= $(shell git describe --dirty --always)
-GITSHA         ?= $(shell git rev-parse --short HEAD)
-
-KERNEL_FILENAME:= popcorn.elf
-KERNEL_FONT    := assets/fonts/tamsyn8x16r.psf
-
-MODULES        := kutil
-
-
-EFI_DIR        := external/gnu-efi
-EFI_DATA       := $(EFI_DIR)/gnuefi
-EFI_LDS        := $(EFI_DATA)/elf_$(ARCH)_efi.lds
-EFI_ARCH_DIR   := $(EFI_DIR)/$(ARCH)
-EFI_ARCH_DATA  := $(EFI_ARCH_DIR)/gnuefi
-EFI_CRT_OBJ    := $(EFI_ARCH_DATA)/crt0-efi-$(ARCH).o
-EFI_LIB        := $(EFI_ARCH_DIR)/lib/libefi.a
-EFI_INCLUDES   := $(EFI_DIR)/inc
-
-DEPENDFLAGS    := -MMD
-
-INCLUDES       := -I $(ARCH_D)
-INCLUDES       += -I src/modules
-INCLUDES       += -I src/include
-INCLUDES       += -isystem $(EFI_INCLUDES)
-INCLUDES       += -isystem $(EFI_INCLUDES)/$(ARCH)
-INCLUDES       += -isystem $(EFI_INCLUDES)/protocol
-
-BASEFLAGS      := -ggdb -nostdlib
-BASEFLAGS      += -ffreestanding -nodefaultlibs
-BASEFLAGS      += -fno-builtin -fomit-frame-pointer
-BASEFLAGS      += -mno-red-zone -fno-stack-protector 
-
-ifdef CPU
-BASEFLAGS      += -mcpu=$(CPU)
-endif
-
-# Removed Flags:: -Wcast-align
-WARNFLAGS      += -Wformat=2 -Winit-self -Wfloat-equal -Winline 
-WARNFLAGS      += -Winvalid-pch -Wmissing-format-attribute
-WARNFLAGS      += -Wmissing-include-dirs -Wswitch -Wundef
-WARNFLAGS      += -Wdisabled-optimization -Wpointer-arith
-
-WARNFLAGS      += -Wno-attributes -Wno-sign-compare -Wno-multichar
-WARNFLAGS      += -Wno-div-by-zero -Wno-endif-labels -Wno-pragmas
-WARNFLAGS      += -Wno-format-extra-args -Wno-unused-result
-WARNFLAGS      += -Wno-deprecated-declarations -Wno-unused-function
-
-ASFLAGS        ?=
-ASFLAGS        += -p $(BUILD_D)/versions.s
-
-CFLAGS         := $(INCLUDES) $(DEPENDFLAGS) $(BASEFLAGS) $(WARNFLAGS)
-CFLAGS         += -DGIT_VERSION="\"$(VERSION)\""
-CFLAGS         += -std=c11 -mcmodel=large
-
-CXXFLAGS       := $(INCLUDES) $(DEPENDFLAGS) $(BASEFLAGS) $(WARNFLAGS)
-CXXFLAGS       += -DGIT_VERSION="\"$(VERSION)\""
-CXXFLAGS       += -std=c++14 -mcmodel=large
-CXXFLAGS       += -fno-exceptions -fno-rtti
-
-BOOT_CFLAGS    := $(INCLUDES) $(DEPENDFLAGS) $(BASEFLAGS) $(WARNFLAGS)
-BOOT_CFLAGS    += -std=c11 -I src/boot -fPIC -fshort-wchar
-BOOT_CFLAGS    += -DKERNEL_FILENAME="L\"$(KERNEL_FILENAME)\""
-BOOT_CFLAGS    += -DGIT_VERSION_WIDE="L\"$(VERSION)\""
-BOOT_CFLAGS    += -DGNU_EFI_USE_MS_ABI -DHAVE_USE_MS_ABI
-BOOT_CFLAGS    += -DEFI_DEBUG=0 -DEFI_DEBUG_CLEAR_MEMORY=0
-#BOOT_CFLAGS   += -DEFI_FUNCTION_WRAPPER
-
-ifdef MAX_HRES
-BOOT_CFLAGS    += -DMAX_HRES=$(MAX_HRES)
-endif
-
-LDFLAGS        := -L $(BUILD_D) -g
-LDFLAGS        += -nostdlib -znocombreloc -Bsymbolic -nostartfiles 
-
-BOOT_LDFLAGS   := $(LDFLAGS) -shared
-BOOT_LDFLAGS   += -L $(EFI_ARCH_DIR)/lib -L $(EFI_ARCH_DIR)/gnuefi
-
-AS             ?= $(CROSS)nasm
-AR             ?= $(CROSS)ar
-CC             ?= $(CROSS)gcc
-CXX            ?= $(CROSS)g++
-LD             ?= $(CROSS)ld
-OBJC           := $(CROSS)objcopy
-OBJD           := $(CROSS)objdump
-
-INIT_DEP       := $(BUILD_D)/.builddir
-
-BOOT_SRCS      := $(wildcard src/boot/*.c)
-BOBJS          += $(patsubst src/boot/%,$(BUILD_D)/boot/%,$(patsubst %,%.o,$(BOOT_SRCS)))
-
-KERN_SRCS      := $(wildcard $(KERN_D)/*.s)
-KERN_SRCS      += $(wildcard $(KERN_D)/*.c)
-KERN_SRCS      += $(wildcard $(KERN_D)/*.cpp)
-KERN_SRCS      += $(wildcard $(ARCH_D)/*.s)
-KERN_SRCS      += $(wildcard $(ARCH_D)/*.c)
-
-KERN_OBJS      := $(patsubst src/%, $(BUILD_D)/%, $(patsubst %,%.o,$(KERN_SRCS)))
-
-MOD_TARGETS    :=
-
-PARTED         ?= /sbin/parted
-QEMU           ?= qemu-system-x86_64
-GDBPORT        ?= 27006
-CPUS           ?= 1
-OVMF           ?= assets/ovmf/x64/OVMF.fd 
-
-QEMUOPTS       := -drive if=pflash,format=raw,file=$(BUILD_D)/flash.img
-QEMUOPTS       += -drive if=floppy,format=raw,file=$(BUILD_D)/floppy.img
-QEMUOPTS       += -smp $(CPUS) -m 512
-QEMUOPTS       += -d mmu,guest_errors,int -D popcorn.log 
-QEMUOPTS       += -no-reboot
-QEMUOPTS       += -cpu Broadwell
-QEMUOPTS       += $(QEMUEXTRA)
-
-
-all: $(BUILD_D)/floppy.img
-init: $(INIT_DEP)
-
-$(INIT_DEP):
-	mkdir -p $(BUILD_D) $(patsubst %,$(BUILD_D)/d.%,$(MODULES))
-	mkdir -p $(BUILD_D)/boot
-	mkdir -p $(patsubst src/%,$(BUILD_D)/%,$(ARCH_D))
-	mkdir -p $(patsubst src/%,$(BUILD_D)/%,$(KERN_D))
-	touch $(INIT_DEP)
-
-clean:
-	rm -rf $(BUILD_D)/* $(BUILD_D)/.version $(BUILD_D)/.builddir
-
-vars:
-	@echo "KERN_SRCS: " $(KERN_SRCS)
-	@echo "KERN_OBJS: " $(KERN_OBJS)
-
-dist-clean: clean
-	make -C external/gnu-efi clean
-
-.PHONY: all clean dist-clean init vars
-
-$(BUILD_D)/.version:
-	echo '$(VERSION)' | cmp -s - $@ || echo '$(VERSION)' > $@
-
-$(BUILD_D)/versions.s:
-	./scripts/parse_version.py "$(VERSION)" "$(GITSHA)" > $@
-
--include x $(patsubst %,src/modules/%/module.mk,$(MODULES))
--include x $(shell find $(BUILD_D) -type f -name '*.d')
-
-$(EFI_LIB):
-	make -C external/gnu-efi all
-
-$(BUILD_D)/boot.elf: $(BOBJS) $(EFI_LIB)
-	$(LD) $(BOOT_LDFLAGS) -T $(EFI_LDS) -o $@ \
-		$(EFI_CRT_OBJ) $(BOBJS) -lefi -lgnuefi
-
-$(BUILD_D)/boot.efi: $(BUILD_D)/boot.elf
-	$(OBJC) -j .text -j .sdata -j .data -j .dynamic \
-	-j .dynsym  -j .rel -j .rela -j .reloc \
-	--target=efi-app-$(ARCH) $^ $@
-
-$(BUILD_D)/boot.debug.efi: $(BUILD_D)/boot.elf
-	$(OBJC) -j .text -j .sdata -j .data -j .dynamic \
-	-j .dynsym  -j .rel -j .rela -j .reloc \
-	-j .debug_info -j .debug_abbrev -j .debug_loc -j .debug_str \
-	-j .debug_aranges -j .debug_line -j .debug_macinfo \
-	--target=efi-app-$(ARCH) $^ $@
-
-$(BUILD_D)/boot.dump: $(BUILD_D)/boot.efi
-	$(OBJD) -D -S $< > $@
-
-$(BUILD_D)/boot/%.s.o: src/boot/%.s $(BUILD_D)/versions.s $(INIT_DEP)
-	$(AS) $(ASFLAGS) -i src/boot/ -o $@ $<
-
-$(BUILD_D)/boot/%.c.o: src/boot/%.c $(INIT_DEP)
-	$(CC) $(BOOT_CFLAGS) -c -o $@ $<
-
-$(BUILD_D)/kernel.elf: $(KERN_OBJS) $(MOD_TARGETS) $(ARCH_D)/kernel.ld
-	$(LD) $(LDFLAGS) -u _header -T $(ARCH_D)/kernel.ld -o $@ $(KERN_OBJS) $(patsubst %,-l%,$(MODULES))
-	$(OBJC) --only-keep-debug $@ $@.sym
-	$(OBJD) -D -S $@ > $@.dump
-
-$(BUILD_D)/%.s.o: src/%.s $(BUILD_D)/versions.s $(INIT_DEP)
-	$(AS) $(ASFLAGS) -i $(ARCH_D)/ -i $(KERN_D)/ -o $@ $<
-
-$(BUILD_D)/%.c.o: src/%.c $(INIT_DEP)
-	$(CC) $(CFLAGS) -c -o $@ $<
-
-$(BUILD_D)/%.cpp.o: src/%.cpp $(INIT_DEP)
-	$(CXX) $(CXXFLAGS) -c -o $@ $<
-
-$(BUILD_D)/flash.img: $(OVMF)
-	cp $^ $@
-
-$(BUILD_D)/screenfont.psf: $(KERNEL_FONT)
-	cp $^ $@
-
-$(BUILD_D)/fs.img: $(BUILD_D)/boot.efi $(BUILD_D)/kernel.elf $(BUILD_D)/screenfont.psf
-	$(eval TEMPFILE := $(shell mktemp --suffix=.img))
-	dd if=/dev/zero of=$@.tmp bs=512 count=93750
-	$(PARTED) $@.tmp -s -a minimal mklabel gpt
-	$(PARTED) $@.tmp -s -a minimal mkpart EFI FAT16 2048s 93716s
-	$(PARTED) $@.tmp -s -a minimal toggle 1 boot
-	dd if=/dev/zero of=$(TEMPFILE) bs=512 count=91669
-	mformat -i $(TEMPFILE) -h 32 -t 32 -n 64 -c 1
-	mmd -i $(TEMPFILE) ::/EFI
-	mmd -i $(TEMPFILE) ::/EFI/BOOT
-	mcopy -i $(TEMPFILE) $(BUILD_D)/boot.efi ::/EFI/BOOT/BOOTX64.efi
-	mcopy -i $(TEMPFILE) $(BUILD_D)/kernel.elf ::$(KERNEL_FILENAME)
-	mcopy -i $(TEMPFILE) $(BUILD_D)/screenfont.psf ::screenfont.psf
-	mlabel -i $(TEMPFILE) ::Popcorn_OS
-	dd if=$(TEMPFILE) of=$@.tmp bs=512 count=91669 seek=2048 conv=notrunc
-	rm $(TEMPFILE)
-	mv $@.tmp $@
-
-$(BUILD_D)/floppy.img: $(BUILD_D)/boot.efi $(BUILD_D)/kernel.elf $(BUILD_D)/screenfont.psf
-	cp assets/floppy.img $@
-	mcopy -i $@ $(BUILD_D)/boot.efi ::/EFI/BOOT/BOOTX64.efi
-	mcopy -i $@ $(BUILD_D)/kernel.elf ::$(KERNEL_FILENAME)
-	mcopy -i $@ $(BUILD_D)/screenfont.psf ::screenfont.psf
-
-$(BUILD_D)/fs.iso: $(BUILD_D)/floppy.img
-	mkdir -p $(BUILD_D)/iso
-	cp $< $(BUILD_D)/iso/
-	xorrisofs --efi-boot floppy.img -o $@ $(BUILD_D)/iso
-
-qemu: $(BUILD_D)/floppy.img $(BUILD_D)/flash.img
-	-rm popcorn.log
-	"$(QEMU)" $(QEMUOPTS) -nographic
-
-qemu-window: $(BUILD_D)/floppy.img $(BUILD_D)/flash.img
-	-rm popcorn.log
-	"$(QEMU)" $(QEMUOPTS)
-
-qemu-gdb: $(BUILD_D)/floppy.img $(BUILD_D)/boot.debug.efi $(BUILD_D)/flash.img $(BUILD_D)/kernel.elf
-	-rm popcorn.log
-	"$(QEMU)" $(QEMUOPTS) -s -nographic
-
-# vim: ft=make ts=4

make.bat

@@ -1,6 +0,0 @@
-@echo off
-if exist C:\Windows\Sysnative\bash.exe (
-	C:\Windows\Sysnative\bash.exe -c "make %*"
-) else (
-	C:\Windows\System32\bash.exe -c "make %*"
-)

modules.mk

@@ -1,35 +0,0 @@
-ifeq "$(MOD_NAME)" ""
-include "you must specify a MOD_NAME"
-endif
-
-ifndef SOURCES
-	SOURCES := $(wildcard src/modules/$(MOD_NAME)/*.c)
-	SOURCES += $(wildcard src/modules/$(MOD_NAME)/*.cpp)
-	SOURCES += $(wildcard src/modules/$(MOD_NAME)/*.s)
-endif
-
-ifeq "$(SOURCES)" ""
-include "you must specify a SOURCES list"
-endif
-
-MOD_SRC_D	:= src/modules/$(MOD_NAME)
-MOD_BUILD_D	:= $(BUILD_D)/d.$(MOD_NAME)
-MOD_LIBNAME	:= $(BUILD_D)/lib$(MOD_NAME).a
-MOD_TARGETS	+= $(MOD_LIBNAME)
-
-OBJS_$(MOD_NAME) := $(patsubst %,build/d.%.o,$(patsubst src/modules/%,%,$(SOURCES)))
-
-$(MOD_LIBNAME): $(OBJS_$(MOD_NAME))
-	$(AR) cr $@ $(OBJS_$(MOD_NAME))
-
-$(MOD_BUILD_D)/%.c.o: $(MOD_SRC_D)/%.c $(INIT_DEP)
-	$(CC) $(CFLAGS) -c -o $@ $<
-
-$(MOD_BUILD_D)/%.cpp.o: $(MOD_SRC_D)/%.cpp $(INIT_DEP)
-	$(CXX) $(CXXFLAGS) -c -o $@ $<
-
-$(MOD_BUILD_D)/%.s.o: $(MOD_SRC_D)/%.s $(BUILD_D)/versions.s $(INIT_DEP)
-	$(AS) $(ASFLAGS) -i $(MOD_SRC_D)/ -o $@ $<
-
-DEPS += $(patsubst %.o,%.d,$(OBJS_$(MOD_NAME)))
-

qemu.bat

@@ -1,3 +0,0 @@
-call make.bat
-del popcorn.log
-qemu-system-x86_64.exe -bios .\assets\ovmf\x64\OVMF.fd -hda .\build\fs.img -m 512 -vga cirrus -d guest_errors,int,mmu -D popcorn.log -no-reboot

scripts/parse_version.py

@@ -1,36 +0,0 @@
-#!/usr/bin/env python3
-#
-# parse_version.py - Create a NASM version definition file given
-# version inputs. Usage:
-#
-#     parse_version.py <git-describe version> <git short sha>
-
-
-def split_version(version_string):
-    major, minor, patch_dirty = version_string.split(".")
-    patch_dirty = patch_dirty.split("-")
-
-    return major, minor, patch_dirty[0], len(patch_dirty) > 1
-
-
-def make_nasm(major, minor, patch, dirty, sha):
-    if dirty:
-        dirty = "1"
-    else:
-        dirty = "0"
-
-    lines = [
-        "%define VERSION_MAJOR  {}".format(major),
-        "%define VERSION_MINOR  {}".format(minor),
-        "%define VERSION_PATCH  {}".format(patch),
-        "%define VERSION_GITSHA 0x{}{}".format(dirty, sha),
-    ]
-    return "\n".join(lines)
-
-
-if __name__ == "__main__":
-    import sys
-    if len(sys.argv) != 3:
-        print("Usage: {} <desc version> <git sha>".format(sys.argv[0]), file=sys.stderr)
-        sys.exit(1)
-    print(make_nasm(*split_version(sys.argv[1]), sys.argv[2]))

src/boot/wscript

@@ -0,0 +1,70 @@
+
+def configure(ctx):
+    from os.path import join
+
+    efi_dir = join(ctx.env.EXTERNAL, "gnu-efi")
+    ctx.env.EFI_DIR = efi_dir
+
+    efi_inc = join(efi_dir, "inc")
+    efi_arch = join(efi_dir, ctx.env.POPCORN_ARCH)
+
+    crt0_name = 'crt0-efi-{}.o'.format(ctx.env.POPCORN_ARCH)
+    crt0_path = join(efi_arch, "gnuefi", crt0_name)
+
+    lds_name = 'elf_{}_efi.lds'.format(ctx.env.POPCORN_ARCH)
+    lds_path = join(efi_dir, "gnuefi", lds_name)
+
+    ctx.env.append_value('INCLUDES_EFI', [
+        efi_inc,
+        join(efi_inc, "protocol"),
+        join(efi_inc, ctx.env.POPCORN_ARCH),
+    ])
+    ctx.env.append_value('DEFINES_EFI', [
+        'KERNEL_FILENAME=L"{}"'.format(ctx.env.KERNEL_FILENAME),
+        'GNU_EFI_USE_MS_ABI',
+        'HAVE_USE_MS_ABI',
+        'EFI_DEBUG=0',
+        'EFI_DEBUG_CLEAR_MEMORY=0',
+    ])
+    ctx.env.append_value('CFLAGS_EFI', ['-fPIC', '-fshort-wchar', '-Wa,--no-warn'])
+    ctx.env.append_value('STLIB_EFI', ['efi', 'gnuefi'])
+    ctx.env.append_value('STLIBPATH_EFI', [join(efi_arch, "lib"), join(efi_arch, "gnuefi")])
+    ctx.env.append_value('LINKFLAGS_EFI', [
+        '-shared',
+        '-T', lds_path,
+        crt0_path,
+    ])
+    ctx.env.append_value('SECTIONS_EFI', [
+        "-j .text",
+        "-j .sdata",
+        "-j .data",
+        "-j .dynamic",
+        "-j .dynsym",
+        "-j .rel",
+        "-j .rela",
+        "-j .reloc",
+    ])
+
+def build(bld):
+    bld(rule = "make -C ${EFI_DIR}")
+    bld.add_group()
+
+    import os
+    sources = [f for f in os.listdir(str(bld.path))
+                if f.endswith('.c')
+                or f.endswith('.s')]
+
+    bld.program(
+        source      = sources,
+        target      = "boot.elf",
+        use         = 'EFI gnu-ef',
+    )
+
+    bld(
+        rule = "${objcopy} ${SECTIONS_EFI} --target=efi-app-${POPCORN_ARCH} ${SRC} ${TGT}",
+        source = "boot.elf",
+        target = "boot.efi",
+    )
+
+
+# vim: ft=python et sw=4

src/kernel/wscript

@@ -0,0 +1,22 @@
+
+def configure(ctx):
+    pass
+
+def build(bld):
+    from os.path import join
+
+    sources = bld.path.ant_glob("**/*.cpp")
+    sources += bld.path.ant_glob("**/*.s")
+
+    lds = join(bld.env.ARCH_D, 'kernel.ld')
+
+    bld.program(
+        source = sources,
+        name = 'kernel',
+        includes = '.',
+        target = bld.env.KERNEL_FILENAME,
+        use = 'kutil',
+        linkflags = "-T {}".format(lds),
+    )
+
+# vim: ft=python et

src/modules/kutil/module.mk

@@ -1,2 +0,0 @@
-MOD_NAME := kutil
-include modules.mk

src/modules/kutil/wscript

@@ -0,0 +1,14 @@
+
+def configure(ctx):
+    pass
+
+def build(bld):
+    sources = bld.path.ant_glob("**/*.cpp")
+
+    bld.stlib(
+        source = sources,
+        name = 'kutil',
+        target = 'kutil',
+    )
+
+# vim: ft=python et

wscript

@@ -0,0 +1,224 @@
+top = '.'
+out = 'build'
+
+
+def options(opt):
+    opt.load("nasm gcc g++")
+
+    opt.add_option(
+            '--arch',
+            action='store',
+            default='x86_64',
+            help='Target architecture')
+
+    opt.add_option('--kernel_filename',
+            action='store',
+            default='popcorn.elf',
+            help='Kernel filename on disk')
+
+    opt.add_option('--font',
+            action='store',
+            default='tamsyn8x16r.psf',
+            help='Font for the console')
+
+
+def configure(ctx):
+    import os
+    import subprocess
+    from os.path import join, exists
+
+    ctx.find_program("ld", var="LINK_CC")
+    ctx.env.LINK_CXX = ctx.env.LINK_CC
+
+    ctx.load("nasm gcc g++")
+    ctx.find_program("objcopy", var="objcopy")
+    ctx.find_program("objdump", var="objdump")
+    ctx.find_program("mcopy", var="mcopy")
+
+    # Override the gcc/g++ tools setting these assuming LD is gcc/g++
+    ctx.env.SHLIB_MARKER = '-Bdynamic'
+    ctx.env.STLIB_MARKER = '-Bstatic'
+    ctx.env.LINKFLAGS_cstlib = ['-Bstatic']
+
+    version = subprocess.check_output("git describe --always", shell=True).strip()
+    git_sha = subprocess.check_output("git rev-parse --short HEAD", shell=True).strip()
+
+    major, minor, patch_dirty = version.split(".")
+    dirty = 'dirty' in patch_dirty
+    patch = patch_dirty.split('-')[0]
+
+    ctx.env.POPCORN_ARCH = ctx.options.arch
+    ctx.env.KERNEL_FILENAME = ctx.options.kernel_filename
+    ctx.env.FONT_NAME = ctx.options.font
+
+    ctx.env.EXTERNAL = join(ctx.path.abspath(), "external")
+
+    baseflags = [
+        '-nostdlib',
+        '-ffreestanding',
+        '-nodefaultlibs',
+        '-fno-builtin',
+        '-fomit-frame-pointer',
+        '-mno-red-zone',
+    ]
+
+    warnflags = ['-W{}'.format(opt) for opt in [
+        'format=2',
+        'init-self',
+        'float-equal',
+        'inline',
+        'missing-format-attribute',
+        'missing-include-dirs',
+        'switch',
+        'undef',
+        'disabled-optimization',
+        'pointer-arith',
+        'no-attributes',
+        'no-sign-compare',
+        'no-multichar',
+        'no-div-by-zero',
+        'no-endif-labels',
+        'no-pragmas',
+        'no-format-extra-args',
+        'no-unused-result',
+        'no-deprecated-declarations',
+        'no-unused-function',
+
+        'error'
+    ]]
+
+    ctx.env.append_value('DEFINES', [
+        'GIT_VERSION="{}"'.format(version),
+        'GIT_VERSION_WIDE=L"{}"'.format(version),
+        "VERSION_MAJOR={}".format(major),
+        "VERSION_MINOR={}".format(minor),
+        "VERSION_PATCH={}".format(patch),
+        "VERSION_GITSHA=0x{}{}".format({True:1}.get(dirty, 0), git_sha),
+    ])
+
+    ctx.env.append_value('CFLAGS', baseflags)
+    ctx.env.append_value('CFLAGS', warnflags)
+    ctx.env.append_value('CFLAGS', ['-ggdb', '-std=c11'])
+
+    ctx.env.append_value('CXXFLAGS', baseflags)
+    ctx.env.append_value('CXXFLAGS', warnflags)
+    ctx.env.append_value('CXXFLAGS', [
+        '-ggdb',
+        '-std=c++14',
+        '-fno-exceptions',
+        '-fno-rtti',
+    ])
+
+    ctx.env.append_value('ASFLAGS', ['-felf64'])
+
+    ctx.env.append_value('INCLUDES', [
+        join(ctx.path.abspath(), "src", "include"),
+        join(ctx.path.abspath(), "src", "modules"),
+    ])
+
+    ctx.env.append_value('LINKFLAGS', [
+        '-g',
+        '-nostdlib',
+        '-znocombreloc',
+        '-Bsymbolic',
+        '-nostartfiles',
+    ])
+
+    ctx.env.ARCH_D = join(str(ctx.path), "src", "arch",
+            ctx.env.POPCORN_ARCH)
+
+    env = ctx.env
+    ctx.setenv('boot', env=env)
+    ctx.recurse(join("src", "boot"))
+
+    ctx.setenv('kernel', env=env)
+    ctx.env.append_value('CFLAGS', ['-mcmodel=large'])
+    ctx.env.append_value('CXXFLAGS', ['-mcmodel=large'])
+
+    mod_root = join("src", "modules")
+    for module in os.listdir(mod_root):
+        mod_path = join(mod_root, module)
+        if exists(join(mod_path, "wscript")):
+            ctx.env.append_value('MODULES', mod_path)
+            ctx.recurse(mod_path)
+
+    ctx.recurse(join("src", "kernel"))
+
+
+def build(bld):
+    from os.path import join
+
+    bld.env = bld.all_envs['boot']
+    bld.recurse(join("src", "boot"))
+
+    bld.env = bld.all_envs['kernel']
+    for mod_path in bld.env.MODULES:
+        bld.recurse(mod_path)
+
+    bld.recurse(join("src", "kernel"))
+
+    src = bld.path
+    out = bld.root.make_node(bld.out_dir)
+    kernel_name = bld.env.KERNEL_FILENAME
+
+    boot = out.make_node(join("efi", "boot", "bootx64.efi"))
+    kernel = out.make_node(kernel_name)
+    font = out.make_node("screenfont.psf")
+
+    bld(
+        source = out.make_node(join("src", "boot", "boot.efi")),
+        target = boot,
+        rule = "mkdir -p $(dirname ${TGT}) && cp ${SRC} ${TGT}"
+    )
+
+    bld(
+        source = out.make_node(join("src", "kernel", kernel_name)),
+        target = kernel,
+        rule = "mkdir -p $(dirname ${TGT}) && cp ${SRC} ${TGT}"
+    )
+
+    bld(
+        source = src.make_node(join("assets", "fonts", bld.env.FONT_NAME)),
+        target = font,
+        rule = "mkdir -p $(dirname ${TGT}) && cp ${SRC} ${TGT}"
+    )
+
+    bld(
+        source = src.make_node(join("assets", "floppy.img")),
+        target = out.make_node("popcorn.img"),
+        rule = "cp ${SRC} ${TGT}",
+    )
+
+    bld(
+        source = src.make_node(join("assets", "ovmf", "x64", "OVMF.fd")),
+        target = out.make_node("flash.img"),
+        rule = "cp ${SRC} ${TGT}",
+    )
+
+    for node in (boot, kernel, font):
+        bld.add_group()
+        bld(source = node, rule = "${mcopy} -i popcorn.img ${SRC} ::${SRC}")
+
+
+def qemu(ctx):
+    import subprocess
+    subprocess.call("rm popcorn.log", shell=True)
+    subprocess.call([
+        'qemu-system-x86_64',
+        '-drive', 'if=pflash,format=raw,file={}/flash.img'.format(out),
+        '-drive', 'if=floppy,format=raw,file={}/popcorn.img'.format(out),
+        '-smp', '1',
+        '-m', '512',
+        '-d', 'mmu,int,guest_errors',
+        '-D', 'popcorn.log',
+        '-cpu', 'Broadwell',
+        '-no-reboot',
+        '-nographic',
+    ])
+
+
+def listen(ctx):
+    subprocess.call("nc -l -p 5555", shell=True)
+
+
+# vim: ft=python et