root/trunk/m2/m2

#!/usr/bin/rebol -qs

REBOL [
        RCS: {$Id: m2,v 1.16 2005/06/21 05:07:06 karl Exp $}
    Title: "m2"
    Version: 0.4.0
    Rights: "Copyright (C) 2001-2006 Karl Robillard"
    Author: "Karl Robillard"
        Date: 27-May-2001
        Home: http://wsrebol.sf.net/
    Purpose: {Generates project makefiles.}
        History: [
                0.0.1 [27-May-2001 "Version 2 of rmake."]
        ]
        TODO: {
                * Remove files outside the build directory from dist rule.
                * Add Qt moc files to sources but not to distribution rule.
        }

        Template-notes: {
        These words are defined in the template file:
                generate_makefile

                exe_target
                lib_target
                shlib_target
                rule_target

                makerule_cxx
                makerule_asm
                makerule_c
        }

        ; NOTE: Symbolic links don't work!
]


verbose: false

debug_include: false
idprint: func [ blk ] [ if debug_include [ print blk ] ]

; Saving system/script/path before any change-dir.
start_dir: copy system/script/path


m2: context [

        ;--------------------------------------
        ; These are constant for each makefile.

        makefile: %Makefile
        project_name: "project"
        project_ver: none
        default_block: none

        project_version: func [{Returns string with name and version}] [
                either none? project_ver [
                        project_name
                ][
                        rejoin [ project_name "-" project_ver ]
                ]
        ]

        ct: none
        targets: []
    output_buf: make string! 1024

        ; This contains file! block! pairs.  The block contains the files
        ; included in the file.
        include_dict: []

        distribution_files: []


        ;--------------------------------------
        ; These can be changed for each target.

        configuration: context [
                release: debug: warn: false
                opengl: qt: qt-static: x11: false
        ]

        target_env: context [
                name: none
                uc_name: none
                output_file: none
                link_cxx: false

                objdir: "" 
                output_dir: "" 
                obj_ext: ".o"
                cxx_ext: ".cpp"
                defines: []

                include_paths: []
                link_paths: []
                link_libs: []

                header_files: []
                source_files: []
                object_files: []

                moc_files: []
                srcmoc_files: []

                menv_cflags: {}
                menv_cxxflags: {}
                menv_lflags: {}

                cfg: none ;make configuration []
        
                configure: none
                macro_text: none
                rule_text: none

                rule_makeobj: func [cc flags obj src] [
                        ; Default to GNU
                        rejoin [ "^(tab)$(" cc ") -c $(" uc_name flags ") -o " obj 
                                         " $(" uc_name "_INCPATH) " src ]
                ]
                makerule_cxx: func [obj src] [ link_cxx: true
                                                                           rule_makeobj "CXX" "_CXXFLAGS" obj src ]
                makerule_asm: func [obj src] [ rule_makeobj "AS" "_ASFLAGS" obj src ]
                makerule_c:   func [obj src] [ rule_makeobj "CC" "_CFLAGS" obj src ]

                file_rules: [
                        ".cpp" makerule_cxx
                        ".cxx" makerule_cxx
                        ".cc"  makerule_cxx
                        ".s"   makerule_asm
                        ".c"   makerule_c
                ]

                make_obj_rule: func [
                        {Builds rules which make object files.
                         Dependencies are automatically generated by recursively searching
             in sources and included files.
                         Called from the template.}
                        /local str src srcfile dependencies inc common rule
                ][
                        str: make string! 512
                        src: source_files
                        foreach obj object_files [
                                append str rejoin [ obj ": " src/1 ]

                                srcfile: to-file src/1

                                either exists? srcfile [
                                        dependencies: select m2/include_dict srcfile
                                ][
                                        print [ "make_obj_rule: Warning -" srcfile "not found" ]
                                        dependencies: []
                                ]

                                either none? dependencies [
                                        append str "^/"
                                ][
                                        either empty? dependencies [
                                                append str "^/"
                                        ][
                                                append str " \^/"
                                                foreach dep dependencies [
                                                        inc: select m2/include_dict dep
                                                        if none? inc [
                                                          m2/append_include_dict dependencies include_paths
                                                          inc: select m2/include_dict dep
                                                        ]
                                                        common: intersect dependencies inc
                                                        append dependencies difference inc common
                                                ]

                                                append str expand_list_gnu sort dependencies
                                        ]
                                ]

                                ; Explicitly state rule
                                foreach [ext r] file_rules [
                                        ;print [ext get r]
                                        if find src/1 ext [
                                                append str rejoin [ do r obj src/1 "^/^/" ]
                                                break
                                        ]
                                ]

                                src: next src

                                append header_files dependencies
                        ]

                        header_files: sort intersect header_files header_files

                        str
                ]

                moc_rule: func [ /local str src ] [
                        str: make string! 0
                        src: srcmoc_files
                        foreach file moc_files [
                                append str rejoin [ src/1 ": " file ]
                                append str rejoin [ "^/^(tab)$(MOC) " file " -o " src/1 "^/^/" ]

                                src: next src
                        ]
                        str
                ]
        ]

        ;--------------------------------------

        static_lib_targets: []

        local_libs: func [
                ; Returns string of libraries from libs which are built by this
                ; project file.
                libs
                /local l str
        ][
                str: make string! 0
                foreach [base path] static_lib_targets [
                        if l: find libs base [
                                append str rejoin [#" " path]
                                ;probe first l
                        ]
                ]
                str
        ]


        header_files_used: func [
                ; Returns a block containing all header files used in the project.
                /local blk
        ][
                blk: copy [] 
                foreach [ f b ] include_dict [
                        append blk b
                ]
                sort intersect blk blk
        ]


        append_include_dict: func [
                "Returns a block all files included from files"
                files paths /local headers blk ]
        [
                headers: copy []

                ; Should make include_dict a hash?
                forall files [
                        if none? (select include_dict files/1) [
                                blk: included_files files/1 paths
                                append headers blk

                                append include_dict files/1
                                append/only include_dict blk
                        ]
                ]

                sort intersect headers headers
        ]

        add_target: function [target blk] [] [
                ct: target
                append targets ct

                do default_block
                do blk

                if (length? ct/objdir) > 0 [
                        if not exists? ct/objdir [
                                make-dir ct/objdir
                        ]
                ]

                ct/configure
                ct/object_files: make_file_list ct/source_files ct/objdir ct/obj_ext

                ct/header_files: append_include_dict ct/source_files ct/include_paths
                ;probe include_dict
                ;probe ct/header_files

                if ct/cfg/qt [
                        add_moc_files ct ct/header_files

                        ; Uncomment this to search cpp files for Q_OBJECT.
                        ;add_moc_files source_files

                        append ct/object_files
                                make_file_list ct/srcmoc_files ct/objdir ct/obj_ext

                        append ct/source_files ct/srcmoc_files
                ]
        ]

        build_makefile: func [ projfile template ] [
                do template
                do projfile
                clear output_buf
                write makefile generate_makefile
        ]
]


;------------------------------------------------------------------
; Used in template file.


emit: func [data] [append m2/output_buf reduce data]


;------------------------------------------------------------------
; Used in project file.


project:  func [str] [ m2/project_name: str ]
version:  func [str] [ m2/project_ver: str ]
default:  func [blk] [ m2/default_block: blk ]
objdir:   func [dir] [ m2/ct/objdir: dir ]
into:     func [dir] [ m2/ct/output_dir: verify_slash dir ]

cflags:   func [str [string!]] [ add_flags m2/ct/menv_cflags str ]
cxxflags: func [str [string!]] [ add_flags m2/ct/menv_cxxflags str ]
lflags:   func [str [string!]] [ add_flags m2/ct/menv_lflags str ]

linux:
macx:
sun:
unix:
win32:    func [blk [block!]] []        ; skip block by default

opengl:   func [{Using OpenGL libraries.}]     [ m2/ct/cfg/opengl: true ]
qt3:      func [{Using Troll Tech's Qt 3.}]    [ m2/ct/cfg/qt: 3 ]
qt:       func [{Using Troll Tech's Qt 4.} libs [block!]] [ m2/ct/cfg/qt: libs ]
qt-static: does [m2/ct/cfg/qt-static: true]
x11:      func [{Using X11 libraries.}]        [ m2/ct/cfg/x11: true ]

debug:    func [{Building debug version.}]     [ m2/ct/cfg/debug: true ]
release:  func [{Optimize for release build.}] [ m2/ct/cfg/release: true ]
warn:     func [{Enable compiler warnings.}]   [ m2/ct/cfg/warn: true ]

define:   func [str [string!]] [ append m2/ct/defines parse str none ]

include_from: func [list [string! block! file!]] [
        if string? list [
                list: parse list none
        ]
        ; TODO: Run conv_slash on each item.
        append m2/ct/include_paths reduce list
]

libs: func [list [string! block! file!]] [
        either string? list [
                append m2/ct/link_libs parse list none
        ][
                append m2/ct/link_libs list
        ]
]

libs_from: func [dir list] [
        append m2/ct/link_paths dir
        libs list
]

dist: func [arg [block!]] [
        append m2/distribution_files arg
]

sources: func [arg [block!]] [
        append m2/ct/source_files arg
]

sources_from: func [path files [block!]] [
        ;include_from path
        verify_slash path
        forall files [
                append m2/ct/source_files join path files/1
        ]
]


exe: func [{Builds executable rule.} basename blk ]
[
        m2/add_target (make exe_target [
                        name: basename
                        uc_name: uppercase copy basename
                        cfg: make m2/configuration []
                ]) blk
]


lib: func [{Builds static library rule.} basename blk ]
[
        m2/add_target (make lib_target [
                        name: basename
                        uc_name: uppercase copy basename
                        cfg: make m2/configuration []
                ]) blk

        append m2/static_lib_targets reduce [basename m2/ct/output_file]
]

shlib: func [{Builds shared library rule.} basename blk ]
[
        m2/add_target (make shlib_target [
                        name: basename
                        uc_name: uppercase copy basename
                        cfg: make m2/configuration []
                ]) blk
]


rule:  func [{Builds generic make rule.} basename blk ]
[
        m2/add_target (make rule_target [
                        name: basename
                        uc_name: uppercase copy basename
                        cfg: make m2/configuration []
                ]) blk
]


gnu_string: func [
        {Returns string of items each with a prefix.}
        prefix [string!]
        items [block!]
        /local str
][
        str: make string! 64
    forall items [
        append str either (find items/1 " ") [
                rejoin [ { } prefix {"} items/1 {"} ]
        ][
                rejoin [ { } prefix items/1 ]
        ]
    ]
        remove str
]


comment {
makesub_gnu: func [
        {Make subdirectory rule suitable for GNU make.}
        rulename dirs /local dir ]
[
        append make_subdirs rejoin [ ".PHONY: " rulename "^/" rulename ":^/" ]
        foreach dir dirs [
                append make_subdirs rejoin [ "^(tab)make -C " dir "^/" ] 
        ]

        append make_subdirs rejoin [ "^/" ".PHONY: " rulename "clean^/"
                                 rulename "clean:^/" ]
        foreach dir dirs [
                append make_subdirs rejoin [ "^(tab)make -C " dir " clean^/" ] 
        ]
]
}


;------------------------------------------------------------------
; Private


;unix-platforms: [ 4 6 7 8 9 10 11 12 19 22 23 ]
;unix:    if find unix-platforms system/version/4
;windows: if system/version/4 = 3


add_flags: func [ flags str ] [
    either empty? flags [
        append flags trim/lines str
    ][
        append flags join " " (trim/lines str)
    ]
]


strip_ext: func [ file /local lastdot ] [
    lastdot: find/last file "."
    if lastdot [
        remove/part lastdot (tail file)
    ]
    return file
]


verify_slash: func [path [file! url!] /local lp] [
    lp: last path
    if all [
        lp <> #"/"
        lp <> #"\"
    ][
        append path #"/"
    ]
    path
]


make_file_list: func [
        "Copy a block of files with changed path and extension"
        src [block!]
        dir
        extension
][
        obj: copy/deep src
        either empty? dir [
                forall obj [
                        strip_ext obj/1
                        append obj/1 extension
                ]
        ][
                forall obj [
                        file: second split-path obj/1
                        obj/1: rejoin [ verify_slash dir strip_ext file extension ]
                ]
        ]
        return head obj
]


find_include_file: func [
        {Checks if a file exists in the current directory or any set of paths.}
        file [file!]
        paths [block!]
        /local path full
][
        idprint [ " " file ]

    if exists? file [ return file ]

    forall paths [
        path: to-file paths/1
        verify_slash path
        full: join path file

                idprint [ "   " full ]

        if exists? full [ return full ]
    ]
    none
]


included_files: func [
    {Returns a block of the files which are included in a C/C++ file.
         Addes   #include "file.h"
         Ignores #include <file.h>
         Ignores #include MACRO}
    file [file!]   "File to check for #include statements"
    paths [block!] "Paths to check for included files"
    /local blk header ifile
][
    blk: copy []

        if not exists? file [
                print [ "included_files: " file "not found" ]
                return blk
        ]

    foreach line read/lines file [

        ; BUG: #include can be commented or defined out but will still be
        ; included here.  This causes errors when windows-only code includes
                ; files with paths (using backslash) and we are compiling on a
                ; non-windows system.

        if find/case line "#include" [
            if find/any line {"*"} [
                parse line [thru {"} copy header to {"}]
                append blk to-file header
            ]
        ]
    ]

    blk: intersect blk blk   ; Removes duplicates.

        if debug_include [ print ["Finding include files for" file] probe blk ]

        forall blk [
                ifile: find_include_file blk/1 paths
                either none? ifile [
                        print rejoin ["included_files: " blk/1 " (from " file
                          ") not found!"]
                        remove blk
                        blk: back blk
                ][
                        blk/1: ifile
                ]
        ]
        blk: head blk
]


do_tags: func [
    {Replace each tag in a string with the value of the tag.
     Individual '<' and '>' are allowed, but they cannot be used
     between other < > pairs. }
    str [string!]
    /local begin exp
][
    begin: none
    forall str [
        if str/1 = #"<" [
            begin: str
        ]
        if str/1 = #">" [
            if not none? begin [
                exp: copy/part (next begin) str
                change/part begin (do exp) (next str)

                ; Must continue from start of tag because it may have been
                ; replaced with "".  If we don't continue from begin we will
                ; miss any closely following '<' or '>'.
                str: begin

                begin: none
            ]
        ]
    ]

    comment {
    ; This parse rule causes nearby tags to be missed.
    parse str [
        any [
            to "<" begin: thru ">" ending:
            (exp: copy/part (next begin) (back ending)
             change/part begin (do exp) ending)
        ]
    ]
    }

    head str
]


; Nothing by default.
conv_slash: func [ file ] [ file ]


expand_list_gnu: func [
    {Returns a string with each file on a seperate line.}
    files [block!]
        /part "Do not erase trailing space and slash"
    /local x
][
    str: make string! 64
    foreach file files [
        append str rejoin [ {^(tab)} conv_slash file { \^/} ]
    ]

        if not part [
                x: find/last str " "
                if x [
                        remove/part x 2
                ]
        ]
    return str
]


add_moc_files: function [ ct files [block!] ][ blk found ]
[
    blk: make block! 0

    foreach file files [
        if find/case read file "Q_OBJECT" [
            append ct/moc_files file

            set [ path file ] split-path file

                        ; MOC bug - specifying "./" on output file creates bad include
                        ; statements.
                        if path = %"./" [ path: %"" ]

            append ct/srcmoc_files join path
                                ["moc_" (strip_ext file) ct/cxx_ext]
        ]
    ]

    return blk
]


;------------------------------------------------------------------


project_file: %project.r

; Assuming template resides with m2 by defualt.
template_file: join start_dir %m2_template.r


change-dir system/script/parent/path
if string? system/script/args [
    args: parse system/script/args none
    forall args [
                switch/default args/1 [
                        "-t" [
                                args: next args
                                template_file: to-file args/1
                        ]
                        "-o" [
                                args: next args
                                m2/makefile: to-file args/1
                        ]
                ][
                        project_file: to-file args/1
                ]
        ]
]

;print [ project_file template_file m2/makefile ]

if not exists? template_file [
        print [ "Template" template_file "not found." ]
        quit
]

either exists? project_file [
        m2/build_makefile project_file template_file
][
        print [ project_file "does not exist; Please specify project file." ]
]

;probe m2/header_files_used

quit


;EOF