root/trunk/m2/m2_linux.r

REBOL [
    Title: "m2 Linux-g++ template"
]


linux: func [blk] [do blk]
unix:  func [blk] [do blk]

eol: "^/" 

dist_files: function [] [str obj] [
    str: make string! 64

    obj: []
    foreach t m2/targets [ append obj t/objdir ]
    obj: intersect obj obj   ; Removes duplicates.
    append str obj

    foreach t m2/targets [ append str t/dist ]
    str
]

generate_makefile: does [
    foreach t m2/targets [
        ;probe t

        ; make_obj_rule must be called before we write DIST_FILES since
        ; it finds the header dependencies.
        t/built_obj_rule: t/make_obj_rule
    ]

    emit do_tags copy gnu_header

    emit "^/#------ Target settings"
    foreach t m2/targets [ emit "^/^/" t/macro_text ]

    emit [ {^/ARCHIVE = } m2/project_version {^/DIST_FILES = \^/} ]
    if not empty? m2/distribution_files [
        emit expand_list_gnu/part m2/distribution_files
    ]
    emit expand_list_gnu m2/header_files_used

    emit "^/^/#------ Build rules^/^/all:"
    foreach t m2/targets [ emit [ " " t/output_file ] ]
    emit eol

    foreach t m2/targets [ emit " " t/rule_text ]

    emit [ "^/^/" do_tags copy gnu_other_rules ]

    foreach t m2/targets [ emit t/clean ]

    emit "^/^/#------ Compile rules^/^/"
    foreach t m2/targets [
        emit t/built_obj_rule
        if t/cfg/qt [ emit t/moc_rule ]
    ]

    emit "^/#EOF^/"
]


qt-includes: context [
   gui:     does [ include_from {$(QTDIR)/include/QtGui} ]
   network: does [ include_from {$(QTDIR)/include/QtNetwork} ]
   opengl:  does [ include_from {$(QTDIR)/include/QtOpenGL} ]
   xml:     does [ include_from {$(QTDIR)/include/QtXml} ]
   svg:     does [ include_from {$(QTDIR)/include/QtSvg} ]
   sql:     does [ include_from {$(QTDIR)/include/QtSql} ]
   support: does [ include_from {$(QTDIR)/include/Qt3Support}
                   cxxflags {-DQT3_SUPPORT} ]
]

qt-libraries: context [
   core:    { QtCore}
   gui:     { QtGui}
   network: { QtNetwork}
   opengl:  { QtOpenGL}
   xml:     { QtXml}
   svg:     { QtSvg}
   sql:     { QtSql}
   support: { Qt3Support}
]

qt-debug-libraries: context [
   core:    { QtCore_debug}
   gui:     { QtGui_debug}
   network: { QtNetwork_debug}
   opengl:  { QtOpenGL_debug}
   xml:     { QtXml}
   xml:     { QtXml_debug}
   svg:     { QtSvg_debug}
   sql:     { QtSql_debug}
   support: { Qt3Support_debug}
]


exe_target: make m2/target_env
[
    ; built_obj_rule exists only to hold the output make_obj_rule
    built_obj_rule: none

    obj_macro: none

    config:
    [
        obj_macro: rejoin [ "$(" uc_name "_OBJECTS)" ]

        cflags {-pipe}

        if cfg/warn [
            cflags {-Wall -W}
        ]

        if cfg/debug [
            cflags {-g -DDEBUG}
        ]

        if cfg/release [
            cflags {-O3 -DNDEBUG}
        ]

        if cfg/opengl [
            libs {GL GLU}
            ;libs_from %/usr/X11R6/lib {glut Xi}
            ;libs {glut Xi Xmu}
        ]

        if cfg/qt [
            either cfg/qt = 3 [
                include_from {$(QTDIR)/include}
            ][
                include_from {$(QTDIR)/include}
                include_from {$(QTDIR)/include/QtCore}
                do bind cfg/qt in qt-includes 'gui
            ]
            if cfg/release [
                cxxflags {-DQT_NO_DEBUG}
            ]
        ]

        if cfg/x11 [
            include_from {/usr/X11R6/include}
            libs_from %/usr/X11R6/lib {Xext X11 m}
        ]
    ]

    configure: does [
        output_file: rejoin [ output_dir name ]
        do config
        if cfg/qt [
            either cfg/qt = 3 [
                libs_from %"$(QTDIR)/lib" {qt-mt}

                ; Linking statically requires more libs.
                ;libs_from %"$(QTDIR)/lib" {qt}
                ;libs_from %/usr/X11R6/lib {SM Xft X11}
                ;libs {freetype dl}
            ][
                append qt4-libs: copy cfg/qt 'core
                
                libs_from %"$(QTDIR)/lib" 
                    rejoin bind qt4-libs either cfg/debug
                            [in qt-debug-libraries 'gui]
                            [in qt-libraries 'gui]
            ]
        ]
    ]

    macro_text: func []
    [
        emit [
            uc_name "_CFLAGS   = " menv_cflags " " gnu_string "-D" defines eol
            uc_name "_CXXFLAGS = $(" uc_name "_CFLAGS) " menv_cxxflags eol
            uc_name "_INCPATH  = " gnu_string "-I" include_paths eol
            uc_name "_LFLAGS   = " menv_lflags eol
            uc_name "_LIBS     = " gnu_string "-L" link_paths " "
                              gnu_string "-l" link_libs eol
        ]

        ;if cfg/qt [
        ;    emit [
        ;        uc_name "_SRCMOC  = " expand_list_gnu srcmoc_files eol
        ;        uc_name "_OBJMOC  = " expand_list_gnu objmoc_files eol
        ;    ]
        ;]

        emit [
            ;uc_name "_HEADERS  = " expand_list_gnu header_files eol
            uc_name "_SOURCES  = " expand_list_gnu source_files eol
            uc_name "_OBJECTS  = " expand_list_gnu object_files eol
        ]
    ]

    clean: does [ rejoin [ "^(tab)-rm -f " output_file " " obj_macro eol ] ]
    ; TODO: if cfg/qt [ "rm -f $(_SRCMOC)" ]

    dist: func [] [
        rejoin [" $(" uc_name "_SOURCES)" ]
    ]

    rule_text: func []
    [
        emit [ eol output_file ": " obj_macro m2/local_libs link_libs
            {^/^(tab)$(}
                either link_cxx ["LINK_CXX"]["LINK"]
                {) -o $@ $(} uc_name {_LFLAGS) } obj_macro
            { $(} uc_name {_LIBS)} eol
        ]
    ]
]


lib_target: make exe_target [
    configure: does [
        output_file: rejoin [ output_dir "lib" name ".a" ]
        do config
    ]

    rule_text: func []
    [
        emit [eol output_file ": " obj_macro]
        emit either empty? link_libs [[
            "^/^-ar rc $@ " obj_macro " $(" uc_name "_LFLAGS)"
        ]] [[
            ; Concatenate other libraries.
            "^/^-ld -Ur -o " objdir name "lib.o $^^ $(" uc_name
                "_LIBS) $(" uc_name "_LFLAGS)"
            "^/^-ar rc $@ " objdir name "lib.o"
        ]]
        emit "^/^-ranlib $@^/"
        if cfg/release [
            emit "^-strip -d $@^/"
        ]
    ]
]


shlib_target: make exe_target [
    configure: does [
        output_file: rejoin [ output_dir "lib" name ".so" ]
        do config
        cflags {-fPIC}
        lflags {-shared}
    ]
]


gnu_header:
{#----------------------------------------------------------------------------
# Makefile for GNU make
# Generated by m2 at <now>
# Project: <m2/project_name>
#----------------------------------------------------------------------------


#------ Compiler and tools

CC       = gcc
CXX      = g++
LINK     = gcc
LINK_CXX = g++
TAR      = tar -cf
GZIP     = gzip -9f
MOC      = $(QTDIR)/bin/moc

}
;#------ Project-wide settings


gnu_other_rules:
{<m2/makefile>: <project_file>
^(tab)m2 <project_file>

.PHONY: dist
dist:
^(tab)$(TAR) $(ARCHIVE).tar --exclude CVS --exclude .svn --exclude *.o <project_file> <dist_files> $(DIST_FILES)
^(tab)mkdir /tmp/$(ARCHIVE)
^(tab)tar -C /tmp/$(ARCHIVE) -xf $(ARCHIVE).tar
^(tab)tar -C /tmp -cf $(ARCHIVE).tar $(ARCHIVE)
^(tab)rm -rf /tmp/$(ARCHIVE)
^(tab)$(GZIP) $(ARCHIVE).tar

.PHONY: clean
clean:
^(tab)-rm -f core
}


;EOF