# -*- makefile -*-

ifndef CONTIKI
  ${error CONTIKI not defined! You must specify where Contiki resides}
endif

# Enable Werror by default. To disable from command line, use make WERROR=0.
# Setting this option is also important for tests on Cooja motes to check for warnings.
WERROR ?= 1

include $(CONTIKI)/Makefile.identify-target

ifeq ($(DEFINES),)
  -include Makefile.$(TARGET).defines
  ifneq ($(DEFINES),)
    ${info using saved defines '$(DEFINES)'}
  endif
endif

ifndef HOST_OS
  ifeq ($(OS),Windows_NT)
  ## TODO: detect more specific Windows set-ups,
  ## e.g. CygWin, MingW, VisualC, Watcom, Interix
    HOST_OS := Windows
  else
    HOST_OS := $(shell uname)
  endif
endif

#More debug information when running in CI
ifdef CI
  ifeq ($(CI),true)
    V = 1
  endif
endif

OBJECTDIR = obj_$(TARGET)

LOWERCASE = -abcdefghijklmnopqrstuvwxyz/
UPPERCASE = _ABCDEFGHIJKLMNOPQRSTUVWXYZ_
TARGET_UPPERCASE := ${strip ${shell echo $(TARGET) | sed y!$(LOWERCASE)!$(UPPERCASE)!}}
CFLAGS += -DCONTIKI=1 -DCONTIKI_TARGET_$(TARGET_UPPERCASE)=1
ifneq ($(BOARD),)
TARGET_BOARD_UPPERCASE := ${strip ${shell echo $(BOARD) | sed y!$(LOWERCASE)!$(UPPERCASE)!}}
CFLAGS += -DCONTIKI_BOARD_$(TARGET_BOARD_UPPERCASE)=1
endif

MODULES += os os/sys os/dev os/lib os/services

# Automatically include project-conf.h if found
ifneq ("$(wildcard project-conf.h)","")
CFLAGS += -DPROJECT_CONF_PATH=\"project-conf.h\"
endif

MODULES += os os/net os/net/mac os/storage

oname = ${patsubst %.c,%.o,${patsubst %.S,%.o,$(1)}}

CONTIKI_OBJECTFILES = ${addprefix $(OBJECTDIR)/,${call oname, $(CONTIKI_SOURCEFILES)}}
PROJECT_OBJECTFILES = ${addprefix $(OBJECTDIR)/,${call oname, $(PROJECT_SOURCEFILES)}}

# Provide way to create $(OBJECTDIR) if it has been removed by make clean
$(OBJECTDIR):
	mkdir $@

uniq = $(if $1,$(firstword $1) $(call uniq,$(filter-out $(firstword $1),$1)))

### Include target makefile (TODO Unsafe?)

target_makefile := $(wildcard $(CONTIKI)/arch/platform/$(TARGET)/Makefile.$(TARGET) ${foreach TDIR, $(TARGETDIRS), $(TDIR)/$(TARGET)/Makefile.$(TARGET)})

# Check if the target makefile exists, and create the object directory if necessary.
ifeq ($(strip $(target_makefile)),)
  ${error The target platform "$(TARGET)" does not exist (maybe it was misspelled?)}
else
  ifneq (1, ${words $(target_makefile)})
    ${error More than one TARGET Makefile found: $(target_makefile)}
  endif
  include $(target_makefile)
endif

# Configure MAC layer

# The different options
MAKE_MAC_NULLMAC = 0
MAKE_MAC_CSMA = 1
MAKE_MAC_TSCH = 2
MAKE_MAC_OTHER = 3

# Make CSMA the default MAC
MAKE_MAC ?= MAKE_MAC_CSMA

ifeq ($(MAKE_MAC),MAKE_MAC_NULLMAC)
  MODULES+=os/net/mac/nullmac
  CFLAGS += -DMAC_CONF_WITH_NULLMAC=1
endif

ifeq ($(MAKE_MAC),MAKE_MAC_CSMA)
  MODULES += os/net/mac/csma
  CFLAGS += -DMAC_CONF_WITH_CSMA=1
endif

ifeq ($(MAKE_MAC),MAKE_MAC_TSCH)
  MODULES += os/net/mac/tsch
  CFLAGS += -DMAC_CONF_WITH_TSCH=1
endif

ifeq ($(MAKE_MAC),MAKE_MAC_OTHER)
  CFLAGS += -DMAC_CONF_WITH_OTHER=1
endif

# Configure Network layer

MAKE_NET_NULLNET = 0
MAKE_NET_IPV6 = 1
MAKE_NET_OTHER = 2

# Make IPv6 the default stack
MAKE_NET ?= MAKE_NET_IPV6

ifeq ($(MAKE_NET),MAKE_NET_NULLNET)
  CFLAGS += -DNETSTACK_CONF_WITH_NULLNET=1
endif

ifeq ($(MAKE_NET),MAKE_NET_IPV6)
  CFLAGS += -DNETSTACK_CONF_WITH_IPV6=1
  MODULES += os/net/ipv6
else
  CFLAGS += -DNETSTACK_CONF_WITH_NULLNET=1
  MODULES += os/net/nullnet
endif

ifeq ($(MAKE_NET),MAKE_NET_OTHER)
  CFLAGS += -DNETSTACK_CONF_WITH_OTHER=1
endif

ifeq ($(WITH_IP64),1)
  MODULES += os/services/ip64
endif

# Configure Routing protocol
MAKE_ROUTING_NONE = 0
MAKE_ROUTING_RPL_CLASSIC = 1
MAKE_ROUTING_RPL_LITE = 2

# Default routing protocol: RPL for IPv6, None otherwise
ifeq ($(MAKE_NET),MAKE_NET_IPV6)
MAKE_ROUTING ?= MAKE_ROUTING_RPL_LITE
else
MAKE_ROUTING ?= MAKE_ROUTING_NONE
endif

ifeq ($(MAKE_ROUTING),MAKE_ROUTING_RPL_CLASSIC)
  CFLAGS += -DUIP_CONF_IPV6_RPL=1
  CFLAGS += -DUIP_CONF_IPV6_RPL_CLASSIC=1
  MODULES += os/net/rpl-classic
else ifeq ($(MAKE_ROUTING),MAKE_ROUTING_RPL_LITE)
  CFLAGS += -DUIP_CONF_IPV6_RPL=1
  CFLAGS += -DUIP_CONF_IPV6_RPL_LITE=1
  MODULES += os/net/rpl-lite
else
  CFLAGS += -DUIP_CONF_IPV6_RPL=0
endif

MODULEDIRS = $(MODULES_REL) ${wildcard ${addprefix $(CONTIKI)/, $(MODULES)}}
UNIQUEMODULES = $(call uniq,$(MODULEDIRS))
MODULES_SOURCES = ${foreach d, $(MODULEDIRS), ${subst ${d}/,,${wildcard $(d)/*.c}}}
CONTIKI_SOURCEFILES += $(MODULES_SOURCES)

# Include module-specific makefiles
MODULES_INCLUDES = ${wildcard ${foreach d, $(MODULEDIRS), $(d)/Makefile.${notdir $(d)}}}
include $(MODULES_INCLUDES)

# C-include module-specific macros using -imacros
MODULES_IMACROS = ${wildcard ${foreach d, $(MODULEDIRS), $(d)/module-macros.h}}
ifneq ($(MODULES_IMACROS),)
  CFLAGS += ${foreach d, $(MODULES_IMACROS), -imacros $(d)}
endif

### Verbosity control. Use  make V=1  to get verbose builds.

ifeq ($(V),1)
  TRACE_CC =
  TRACE_LD =
  TRACE_AR =
  TRACE_AS =
  Q=
else
  TRACE_CC = @echo "  CC       " $<
  TRACE_LD = @echo "  LD       " $@
  TRACE_AR = @echo "  AR       " $@
  TRACE_AS = @echo "  AS       " $<
  Q=@
endif

### Forward comma-separated list of arbitrary defines to the compiler

COMMA := ,
CFLAGS += ${addprefix -D,${subst $(COMMA), ,$(DEFINES)}}

### Setup directory search path for source and header files

CONTIKI_TARGET_DIRS_CONCAT = ${addprefix ${dir $(target_makefile)}, \
                               $(CONTIKI_TARGET_DIRS)}
CONTIKI_CPU_DIRS_CONCAT    = ${addprefix $(CONTIKI_CPU)/, \
                               $(CONTIKI_CPU_DIRS)}
CONTIKI_ARCH_DIRS    = ${addprefix $(CONTIKI)/, arch}

SOURCEDIRS = . $(PROJECTDIRS) $(CONTIKI_TARGET_DIRS_CONCAT) $(CONTIKI_ARCH_DIRS) \
             $(CONTIKI_CPU_DIRS_CONCAT) $(CONTIKIDIRS) $(MODULEDIRS) $(EXTERNALDIRS) ${dir $(target_makefile)}

vpath %.c $(SOURCEDIRS)
vpath %.S $(SOURCEDIRS)

CFLAGS += ${addprefix -I,$(SOURCEDIRS) $(CONTIKI)}

### Check for a git repo and pass version if found
### git.exe in Windows cmd shells may require no stderr redirection
ifndef RELSTR
RELSTR:=${shell git --git-dir ${CONTIKI}/.git describe --tags --always --dirty}
endif

ifneq ($(RELSTR),)
CFLAGS += -DCONTIKI_VERSION_STRING=\"Contiki-NG-$(RELSTR)\"
else
CFLAGS += -DCONTIKI_VERSION_STRING=\"Contiki-NG\"
endif

### Automatic dependency generation

ifneq ($(MAKECMDGOALS),clean)
-include ${addprefix $(OBJECTDIR)/,$(CONTIKI_SOURCEFILES:.c=.d) \
                                   $(PROJECT_SOURCEFILES:.c=.d)}
endif

### See http://make.paulandlesley.org/autodep.html#advanced

define FINALIZE_DEPENDENCY
cp $(@:.o=.d) $(@:.o=.$$$$); \
sed -e 's/#.*//' -e 's/^[^:]*: *//' -e 's/ *\\$$//' \
    -e '/^$$/ d' -e 's/$$/ :/' < $(@:.o=.$$$$) >> $(@:.o=.d); \
rm -f $(@:.o=.$$$$)
endef

clean:
	-rm -f *~ *core core *.srec \
	*.lst *.map \
	*.cprg *.bin *.data contiki*.a *.firmware core-labels.S *.ihex *.ini \
	rm -rf $(CLEAN)
	-rm -rf $(OBJECTDIR)

distclean: clean
	-rm -f ${addsuffix .$(TARGET),$(CONTIKI_PROJECT)}

-include $(CONTIKI)/arch/platform/$(TARGET)/Makefile.customrules-$(TARGET)

ifndef CUSTOM_RULE_C_TO_OBJECTDIR_O
$(OBJECTDIR)/%.o: %.c | $(OBJECTDIR)
	$(TRACE_CC)
	$(Q)$(CC) $(CFLAGS) -MMD -c $< -o $@
	@$(FINALIZE_DEPENDENCY)
endif

ifndef CUSTOM_RULE_S_TO_OBJECTDIR_O
$(OBJECTDIR)/%.o: %.S | $(OBJECTDIR)
	$(TRACE_AS)
	$(Q)$(AS) $(ASFLAGS) -o $@ $<
endif

ifndef CUSTOM_RULE_C_TO_OBJECTDIR_S
$(OBJECTDIR)/%.s: %.c | $(OBJECTDIR)
	$(TRACE_CC)
	$(Q)$(CC) $(CFLAGS) -S $< -o $@
endif

ifndef CUSTOM_RULE_C_TO_OBJECTDIR_E
$(OBJECTDIR)/%.e: %.c | $(OBJECTDIR)
	$(TRACE_CC)
	$(Q)$(CC) $(CFLAGS) -E $< -o $@
endif

ifndef CUSTOM_RULE_C_TO_O
%.o: %.c
	$(TRACE_CC)
	$(Q)$(CC) $(CFLAGS) -c $< -o $@
endif

ifndef CUSTOM_RULE_C_TO_S
%.s: %.c
	$(TRACE_CC)
	$(Q)$(CC) $(CFLAGS) -S $< -o $@
endif

ifndef CUSTOM_RULE_C_TO_E
%.e: %.c
	$(TRACE_CC)
	$(Q)$(CC) $(CFLAGS) -E $< -o $@
endif

ifndef AROPTS
  AROPTS = rcf
endif

ifndef CUSTOM_RULE_ALLOBJS_TO_TARGETLIB
contiki-$(TARGET).a: $(CONTIKI_OBJECTFILES)
	$(TRACE_AR)
	$(Q)$(AR) $(AROPTS) $@ $^
endif

ifndef LD
  LD = $(CC)
endif

ifndef CUSTOM_RULE_LINK
%.$(TARGET): %.o $(PROJECT_OBJECTFILES) $(PROJECT_LIBRARIES) contiki-$(TARGET).a
	$(TRACE_LD)
	$(Q)$(LD) $(LDFLAGS) $(TARGET_STARTFILES) ${filter-out %.a,$^} \
	    ${filter %.a,$^} $(TARGET_LIBFILES) -o $@
endif

%.ramprof: %.$(TARGET)
	$(NM) -S -td --size-sort $< | grep -i " [abdrw] " | cut -d' ' -f2,4

%.flashprof: %.$(TARGET)
	$(NM) -S -td --size-sort $< | grep -i " [t] " | cut -d' ' -f2,4

usage:
	@echo "make MAKETARGETS... [TARGET=(TARGET)] [BOARD=(BOARD)] [savetarget] [targets]"

targets:
	@ls $(CONTIKI)/arch/platform $(TARGETDIRS)

boards:
ifdef BOARD
	@echo "$(BOARDS) (current: $(BOARD))"
else
	@echo "Platform has no boards"
endif

savetarget:
	-@rm -f Makefile.target
	@echo "saving Makefile.target"
	@echo >Makefile.target "TARGET = $(TARGET)"
ifneq ($(BOARD),)
	@echo >>Makefile.target "BOARD = $(BOARD)"
endif

savedefines:
	-@rm -f Makefile.$(TARGET).defines
	@echo "saving Makefile.$(TARGET).defines"
	@echo >Makefile.$(TARGET).defines "DEFINES = $(DEFINES)"

viewconf:
	@echo "----------------- Make variables: --------------"
	@echo "##### \"TARGET\": ________________________________ $(TARGET)"
	@echo "##### \"BOARD\": _________________________________ $(BOARD)"
	@echo "##### \"MAKE_MAC\": ______________________________ $(MAKE_MAC)"
	@echo "##### \"MAKE_NET\": ______________________________ $(MAKE_NET)"
	@echo "##### \"MAKE_ROUTING\": __________________________ $(MAKE_ROUTING)"
	@echo "----------------- C variables: -----------------"
	$(Q)$(CC) $(CFLAGS) -E $(CONTIKI)/tools/viewconf.c | grep \#\#\#\#\#
	@echo "------------------------------------------------"
	@echo "'==' Means the flag is set to a given a value"
	@echo "'->' Means the flag is unset, but will default to a given value"
	@echo "'><' Means the flag is unset and has no default value"
	@echo "To view more Make variables, edit $(CONTIKI)/Makefile.include, rule 'viewconf'"
	@echo "To view more C variables, edit $(CONTIKI)/tools/viewconf.c"

# Don't treat %.$(TARGET) as an intermediate file because it is
# in fact the primary target.
.PRECIOUS: %.$(TARGET)

# Cancel the predefined implict rule for compiling and linking
# a single C source into a binary to force GNU make to consider
# the match-anything rule below instead.
%: %.c

# Match-anything pattern rule to allow the project makefiles to
# abstract from the actual binary name. It needs to contain some
# command in order to be a rule, not just a prerequisite.
%: %.$(TARGET)
	@