root/trunk/m2/m2_visualc.r

REBOL [
    Title: "m2 Visual-C++ template"
]


win32: func [blk] [do blk]

console: does [ m2/ct/cfg_console: true ]

conv_slash: func [ file ] [ replace/all file "/" "\" ]

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 ] ;KR

    emit do_tags copy nmake_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 nmake_other_rules ]

    foreach t m2/targets [ emit t/clean ]

    emit "^/^/#------ Compile rules^/^/"
    foreach t m2/targets [
        emit t/make_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:    { QtCore4}
   gui:     { QtGui4}
   network: { QtNetwork4}
   opengl:  { QtOpenGL4}
   xml:     { QtXml4}
   svg:     { QtSvg4}
   sql:     { QtSql4}
   support: { Qt3Support4}
   main:    { qtmain}
]

qt-debug-libraries: context [
   core:    { QtCored4}
   gui:     { QtGuid4}
   network: { QtNetworkd4}
   opengl:  { QtOpenGLd4}
   xml:     { QtXmld4}
   xml:     { QtXmld4}
   svg:     { QtSvgd4}
   sql:     { QtSqld4}
   support: { Qt3Supportd4}
   main:    { qtmaind}
]


exe_target: make m2/target_env
[
    obj_macro: none
    cfg_console: false

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

        ; Most of libc gives warnings in VC8.
        cflags {-D_CRT_SECURE_NO_WARNINGS}

        cflags {/nologo}
        cxxflags {/EHsc}
        lflags {/nologo /incremental:no}

        either cfg_console [
            lflags {/subsystem:console}
        ][
            lflags {/subsystem:windows}
        ]

        either cfg/warn [
            cflags {-W3}
        ][
            cflags {-W0}
        ]

        if cfg/debug [
            cflags {/MDd}
            cflags {-Zi -DDEBUG}
            lflags {/DEBUG}
        ]

        if cfg/release [
            cflags {/MD}
            cflags {-O1 -DNDEBUG}
        ]

        if cfg/opengl [
            libs {opengl32 glu32}
        ]

        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 lm}
        ]
    ]

    configure: does [
        output_file: rejoin [ conv_slash output_dir name ".exe" ]
        do config
        ;libs {user32}    ; gdi32
        if cfg/qt [
            either cfg/qt = 3 [
                ;libs_from {$(QTDIR)\lib} {qt}
                ;libs_from {$(QTDIR)\lib} {qt-mt331 qtmain}
                libs_from {$(QTDIR)\lib} {qt-mt qtmain}

                ; If Qt statically compiled must link with more libs.
                libs {ole32 comdlg32 winspool advapi32 imm32 ws2_32 shell32}
            ][
                append qt4-libs: copy cfg/qt [core main]
                
                libs_from %"$(QTDIR)/lib" 
                    rejoin bind qt4-libs either cfg/debug
                            [in qt-debug-libraries 'gui]
                            [in qt-libraries 'gui]

                libs {comdlg32 winspool advapi32 shell32 ole32}
            ]
        ]
    ]

    lib_string: func [
        items [block!]
        /local str
    ][
        str: make string! 64
        forall items [
        append str either (find items/1 " ") [
            rejoin [ { "} items/1 {.lib"} ]
        ][
            rejoin [ { } items/1 {.lib} ]
        ]
        ]
        remove str
    ]

    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 "/libpath:" link_paths " "
                              lib_string link_libs eol
        ]

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

    clean: does [ rejoin [ "^(tab)-@del " output_file " " obj_macro eol ] ]

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

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

    rule_makeobj: func [cc flags obj src] [
        rejoin [ "^(tab)$(" cc ") /c $(" uc_name flags ") /Fo" obj 
                 " $(" uc_name "_INCPATH) " src ]
    ]
]


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

    rule_text: function [] []
    [
        emit [
            eol output_file ": " obj_macro
            "^/^(tab)lib /nologo /out:$@ " obj_macro " $(" uc_name
            "_LIBS) $(" uc_name "_LFLAGS)^/"
        ]
    ]
]


shlib_target: make exe_target [
    configure: does [
        output_file: rejoin [ conv_slash output_dir name ".dll" ]
        do config
        ;cflags {-MT}
        lflags {/DLL}
    ]
]


nmake_header:
{#----------------------------------------------------------------------------
# Makefile for NMAKE
# Generated by m2 at <now>
# Project: <m2/project_name>
#----------------------------------------------------------------------------


#------ Compiler and tools

CC       = cl.exe
CXX      = cl.exe
LINK     = link.exe
TAR      = tar.exe -cf
ZIP      = zip.exe -r -9
MOC      = $(QTDIR)\bin\moc.exe

}


nmake_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)$(ZIP) $(ARCHIVE).tar

.PHONY: clean
clean:
}


;EOF