| # A-A-P recipe for building Vim |
| # |
| # There are no user choices in here! |
| # Put configure arguments in the file config.arg. |
| # Later there will be a config.txt file that contains examples and |
| # explanations. |
| # |
| # Optional arguments: |
| # PREFIX=dir Overrules the install directory. |
| # Can be specified when installing only. |
| # Example: aap install PREFIX=$HOME |
| # |
| @if os.name != "posix": |
| :error Sorry, this recipe only works for Unix-like systems. |
| |
| # Skip the configure stuff when "link.sh" is executing this recipe recursively |
| # to build pathdef.c or not building something and auto/config.aap does exist. |
| @if ((_no.TARGETARG != "pathdef" and has_build_target()) |
| @ or not os.path.exists("auto/config.aap")): |
| |
| # |
| # A U T O C O N F |
| # |
| |
| # Run autoconf when configure.in has been changed since it was last run. |
| # This is skipped when the signatures in "mysign" are up-to-date. When |
| # there is no autoconf program skip this (the signature is often the only |
| # thing that's outdated) |
| auto/configure {signfile = mysign} : configure.in |
| @if not program_path("autoconf"): |
| :print Can't find autoconf, using existing configure script. |
| @else: |
| # Move configure aside, autoconf would overwrite it |
| :move {exist} configure configure.save |
| :sys autoconf |
| :cat configure | :eval re.sub('\\./config.log', 'auto/config.log', stdin) | :eval re.sub('>config.log', '>auto/config.log', stdin) >! auto/configure |
| :chmod 755 auto/configure |
| :move configure.save configure |
| :del {force} auto/config.cache auto/config.status |
| |
| # Change the configure script to produce config.aap instead of config.mk. |
| auto/configure.aap : auto/configure |
| :print Adjusting auto/configure for A-A-P. |
| :cat auto/configure | :eval re.sub("config.mk", "config.aap", stdin) |
| >! auto/configure.aap |
| :chmod 755 auto/configure.aap |
| |
| # The configure script uses the directory where it's located, use a link. |
| configure.aap: {buildcheck=} |
| :symlink {f} auto/configure.aap configure.aap |
| |
| # Dependency: run configure.aap to update config.h and config.aap in the |
| # "auto" directory. |
| # NOTE: we can only build for one architecture, because -MM doesn't work |
| # when building for both. |
| config {virtual} auto/config.h auto/config.aap : |
| auto/configure.aap configure.aap |
| config.arg config.h.in config.aap.in |
| # Use "uname -a" to detect the architecture of the system. |
| @ok, uname = redir_system('uname -a', 0) |
| @if string.find(uname, "i386") >= 0: |
| @ arch = "i386" |
| @else: |
| @ arch = "ppc" |
| :print Building for $arch system |
| config_args = `file2string("config.arg")` |
| :sys CONFIG_STATUS=auto/config.status |
| ./configure.aap $config_args |
| --with-mac-arch=$arch |
| --cache-file=auto/config.cache |
| |
| # Configure arguments: create an empty "config.arg" file when it's missing |
| config.arg: |
| :touch {exist} config.arg |
| |
| # "auto/config.aap" contains a lot of settings, such as the name of the |
| # executable "Target". |
| # First update it, forcefully if the "reconfig" target was used. |
| @if _no.TARGETARG != "comment" and _no.TARGETARG != "make": |
| @if "reconfig" in var2list(_no.TARGETARG): |
| :del {force} auto/config.cache auto/config.status |
| :update {force} auto/config.aap |
| @else: |
| :update auto/config.aap |
| |
| # Include the recipe that autoconf generated. |
| :include auto/config.aap |
| |
| # Unfortunately "-M" doesn't work when building for two architectures. Switch |
| # back to PPC only. |
| @if string.find(_no.CPPFLAGS, "-arch i386 -arch ppc") >= 0: |
| CPPFLAGS = `string.replace(_no.CPPFLAGS, "-arch i386 -arch ppc", "-arch ppc")` |
| |
| # A "PREFIX=dir" argument overrules the value of $prefix |
| # But don't use the default "/usr/local". |
| @if _no.get("PREFIX") and _no.get("PREFIX") != '/usr/local': |
| prefix = $PREFIX |
| |
| # Don't want "~/" in prefix. |
| prefix = `os.path.expanduser(prefix)` |
| |
| # For Mac. |
| APPDIR = $(VIMNAME).app |
| |
| ### Names of the programs and targets |
| VIMTARGET = $VIMNAME$EXESUF |
| EXTARGET = $EXNAME$LNKSUF |
| VIEWTARGET = $VIEWNAME$LNKSUF |
| GVIMNAME = g$VIMNAME |
| GVIMTARGET = $GVIMNAME$LNKSUF |
| GVIEWNAME = g$VIEWNAME |
| GVIEWTARGET = $GVIEWNAME$LNKSUF |
| RVIMNAME = r$VIMNAME |
| RVIMTARGET = $RVIMNAME$LNKSUF |
| RVIEWNAME = r$VIEWNAME |
| RVIEWTARGET = $RVIEWNAME$LNKSUF |
| RGVIMNAME = r$GVIMNAME |
| RGVIMTARGET = $RGVIMNAME$LNKSUF |
| RGVIEWNAME = r$GVIEWNAME |
| RGVIEWTARGET = $RGVIEWNAME$LNKSUF |
| VIMDIFFNAME = $(VIMNAME)diff |
| GVIMDIFFNAME = g$VIMDIFFNAME |
| VIMDIFFTARGET = $VIMDIFFNAME$LNKSUF |
| GVIMDIFFTARGET = $GVIMDIFFNAME$LNKSUF |
| EVIMNAME = e$VIMNAME |
| EVIMTARGET = $EVIMNAME$LNKSUF |
| EVIEWNAME = e$VIEWNAME |
| EVIEWTARGET = $EVIEWNAME$LNKSUF |
| |
| # |
| # G U I variant |
| # |
| # The GUI is selected by configure, a lot of other things depend on it. |
| # |
| :variant GUI |
| GTK |
| GUI_SRC = gui.c gui_gtk.c gui_gtk_x11.c pty.c gui_beval.c |
| gui_gtk_f.c |
| GUI_OBJ = |
| GUI_DEFS = -DFEAT_GUI_GTK $NARROW_PROTO |
| GUI_IPATH = $GUI_INC_LOC |
| GUI_LIBS_DIR = $GUI_LIB_LOC |
| GUI_LIBS1 = |
| GUI_LIBS2 = $GTK_LIBNAME |
| GUI_INSTALL = install_normal |
| GUI_TARGETS = installglinks |
| GUI_MAN_TARGETS = yes |
| GUI_TESTTARGET = gui |
| GUI_BUNDLE = |
| GUI_TESTARG = |
| MOTIF |
| GUI_SRC = gui.c gui_motif.c gui_x11.c pty.c gui_beval.c |
| gui_xmdlg.c gui_xmebw.c |
| GUI_OBJ = |
| GUI_DEFS = -DFEAT_GUI_MOTIF $NARROW_PROTO |
| GUI_IPATH = $GUI_INC_LOC |
| GUI_LIBS_DIR = $GUI_LIB_LOC |
| GUI_LIBS1 = |
| GUI_LIBS2 = $MOTIF_LIBNAME -lXt |
| GUI_INSTALL = install_normal |
| GUI_TARGETS = installglinks |
| GUI_MAN_TARGETS = yes |
| GUI_TESTTARGET = gui |
| GUI_BUNDLE = |
| GUI_TESTARG = |
| ATHENA |
| # XAW_LIB et al. can be overruled to use Xaw3d widgets |
| XAW_LIB ?= -lXaw |
| GUI_SRC = gui.c gui_athena.c gui_x11.c pty.c gui_beval.c \ |
| gui_at_sb.c gui_at_fs.c |
| GUI_OBJ = |
| GUI_DEFS = -DFEAT_GUI_ATHENA $NARROW_PROTO |
| GUI_IPATH = $GUI_INC_LOC |
| GUI_LIBS_DIR = $GUI_LIB_LOC |
| GUI_LIBS1 = $XAW_LIB |
| GUI_LIBS2 = -lXt |
| GUI_INSTALL = install_normal |
| GUI_TARGETS = installglinks |
| GUI_MAN_TARGETS = yes |
| GUI_TESTTARGET = gui |
| GUI_BUNDLE = |
| GUI_TESTARG = |
| NEXTAW |
| # XAW_LIB et al. can be overruled to use Xaw3d widgets |
| XAW_LIB ?= -lXaw |
| GUI_SRC = gui.c gui_athena.c gui_x11.c pty.c gui_beval.c |
| gui_at_fs.c |
| GUI_OBJ = |
| GUI_DEFS = -DFEAT_GUI_ATHENA -DFEAT_GUI_NEXTAW $NARROW_PROTO |
| GUI_IPATH = $GUI_INC_LOC |
| GUI_LIBS_DIR = $GUI_LIB_LOC |
| GUI_LIBS1 = $NEXTAW_LIB |
| GUI_LIBS2 = -lXt |
| GUI_INSTALL = install_normal |
| GUI_TARGETS = installglinks |
| GUI_MAN_TARGETS = yes |
| GUI_TESTTARGET = gui |
| GUI_BUNDLE = |
| GUI_TESTARG = |
| CARBONGUI |
| GUI_SRC = gui.c gui_mac.c pty.c |
| GUI_OBJ = |
| GUI_DEFS = -DFEAT_GUI_MAC -fno-common -fpascal-strings \ |
| -Wall -Wno-unknown-pragmas -mdynamic-no-pic -pipe |
| GUI_IPATH = $GUI_INC_LOC |
| GUI_LIBS_DIR = $GUI_LIB_LOC |
| GUI_LIBS1 = -framework Carbon |
| GUI_LIBS2 = |
| GUI_INSTALL = install_macosx |
| GUI_TARGETS = installglinks |
| GUI_MAN_TARGETS = yes |
| GUI_TESTTARGET = gui |
| GUI_BUNDLE = gui_bundle |
| GUI_TESTARG = VIMPROG=../$(APPDIR)/Contents/MacOS/$(VIMTARGET) |
| PHOTONGUI |
| GUI_SRC = gui.c gui_photon.c pty.c |
| GUI_OBJ = |
| GUI_DEFS = -DFEAT_GUI_PHOTON |
| GUI_IPATH = |
| GUI_LIBS_DIR = |
| GUI_LIBS1 = -lph -lphexlib |
| GUI_LIBS2 = |
| GUI_INSTALL = install_normal |
| GUI_TARGETS = installglinks |
| GUI_MAN_TARGETS = yes |
| GUI_TESTTARGET = gui |
| GUI_BUNDLE = |
| GUI_TESTARG = |
| * |
| GUI_SRC = |
| GUI_OBJ = |
| GUI_DEFS = |
| GUI_IPATH = |
| GUI_LIBS_DIR = |
| GUI_LIBS1 = |
| GUI_LIBS2 = |
| GUI_INSTALL = install_normal |
| GUI_TARGETS = |
| GUI_MAN_TARGETS = |
| GUI_TESTTARGET = |
| GUI_BUNDLE = |
| GUI_TESTARG = |
| |
| |
| PRE_DEFS = -Iproto -I. $DEFS $GUI_DEFS $GUI_IPATH $CPPFLAGS $?(EXTRA_IPATHS) |
| POST_DEFS = $X_CFLAGS $LUA_CFLAGS $MZSCHEME_CFLAGS $PERL_CFLAGS $PYTHON_CFLAGS $TCL_CFLAGS $RUBY_CFLAGS $?(EXTRA_DEFS) |
| CFLAGS = $PRE_DEFS $CONF_CFLAGS $?(PROFILE_CFLAGS) $POST_DEFS |
| CPPFLAGS = |
| |
| ALL_LIB_DIRS = $GUI_LIBS_DIR $X_LIBS_DIR |
| LDFLAGS = $ALL_LIB_DIRS $CONF_LDFLAGS |
| LIBS = $GUI_LIBS1 $GUI_X_LIBS $GUI_LIBS2 $X_PRE_LIBS $X_LIBS $X_EXTRA_LIBS $CONF_LIBS $?(EXTRA_LIBS) $LUA_LIBS $MZSCHEME_LIBS $PERL_LIBS $PYTHON_LIBS $TCL_LIBS $RUBY_LIBS $?(PROFILE_LIBS) |
| |
| Target = $VIMNAME |
| |
| # reconfig target also builds Vim (reconfiguration is handled above). |
| reconfig {virtual}: $Target |
| |
| distclean: clean |
| :del {force} auto/config.h auto/config.aap |
| :del {force} auto/config.cache auto/config.status |
| |
| |
| # Execute the test scripts. Run these after compiling Vim, before installing. |
| # |
| # This will produce a lot of garbage on your screen, including a few error |
| # messages. Don't worry about that. |
| # If there is a real error, there will be a difference between "test.out" and |
| # a "test99.ok" file. |
| # If everything is alright, the final message will be "ALL DONE". If not you |
| # get "TEST FAILURE". |
| # |
| test check: |
| VimProg = ../$Target |
| :execute testdir/main.aap $GUI_TESTTARGET $GUI_TESTARG |
| |
| testclean {virtual}: |
| :del {force} testdir/*.out testdir/test.log |
| |
| # When no fetch target exists we are not a child of the ../main.aap recipe, |
| # Use ../main.aap to do the fetching. |
| # --- If you get an error here for wrong number of arguments, you need to |
| # update to a newer version of A-A-P. |
| @if not has_target("fetch"): |
| fetch: |
| :execute ../main.aap fetch |
| |
| |
| # All the source files that need to be compiled. |
| # Some are optional and depend on configure. |
| # "version.c" is missing, it's always compiled (see below). |
| Source = |
| blowfish.c |
| buffer.c |
| charset.c |
| diff.c |
| digraph.c |
| edit.c |
| eval.c |
| ex_cmds.c |
| ex_cmds2.c |
| ex_docmd.c |
| ex_eval.c |
| ex_getln.c |
| fileio.c |
| fold.c |
| getchar.c |
| hardcopy.c |
| hashtab.c |
| if_cscope.c |
| if_xcmdsrv.c |
| main.c |
| mark.c |
| memfile.c |
| memline.c |
| menu.c |
| message.c |
| misc1.c |
| misc2.c |
| move.c |
| mbyte.c |
| normal.c |
| ops.c |
| option.c |
| os_unix.c |
| auto/pathdef.c |
| popupmnu.c |
| quickfix.c |
| regexp.c |
| screen.c |
| search.c |
| sha256.c |
| spell.c |
| syntax.c |
| tag.c |
| term.c |
| ui.c |
| undo.c |
| window.c |
| $OS_EXTRA_SRC |
| $GUI_SRC |
| $HANGULIN_SRC |
| $LUA_SRC |
| $MZSCHEME_SRC |
| $PERL_SRC |
| $NETBEANS_SRC |
| $PYTHON_SRC |
| $TCL_SRC |
| $RUBY_SRC |
| $WORKSHOP_SRC |
| |
| Objects = |
| $GUI_OBJ |
| |
| # TODO: make is still used for subdirectories, need to write a recipe. |
| MAKE ?= make |
| |
| all: $Target $GUI_BUNDLE |
| |
| # This dependency is required to build auto/osdef.h before automatic |
| # dependencies are generated. |
| $Source version.c : auto/osdef.h |
| |
| # Need to mention that the target also depends on version.c, since it's not |
| # included in $Source |
| $Target : version.c |
| |
| # Some sources are to be found in the "auto" directory. |
| SRCPATH += auto |
| |
| # When building Vim always compile version.c to get the timestamp. |
| :filetype |
| declare my_prog |
| :attr {filetype = my_prog} $Target |
| |
| :program $Target : $Source $Objects |
| |
| :action build my_prog object |
| version_obj = `src2obj("version.c")` |
| :do compile {target = $version_obj} version.c |
| #:do build {target = $target {filetype = program}} $source $version_obj |
| link_sed = $BDIR/link.sed |
| @if os.path.exists(link_sed): |
| :move {force} $link_sed auto/link.sed |
| @else: |
| :del {force} auto/link.sed |
| :update link2.sh |
| :sys LINK="$?(PURIFY) $?(SHRPENV) $CC $LDFLAGS \ |
| -o $target $source $version_obj $LIBS" \ |
| MAKE="aap" sh ./link2.sh |
| :copy {force} auto/link.sed $BDIR/link.sed |
| |
| # "link.sh" must be modified for A-A-P |
| link2.sh : link.sh |
| :print Adjusting $-source for A-A-P. |
| :cat $source | :eval re.sub("objects/pathdef.o", "pathdef", stdin) |
| >! $target |
| |
| xxd/xxd$EXESUF: xxd/xxd.c |
| :sys cd xxd; CC="$CC" CFLAGS="$CPPFLAGS $CFLAGS" \ |
| $MAKE -f Makefile |
| |
| # Build the language specific files if they were unpacked. |
| # Generate the converted .mo files separately, it's no problem if this fails. |
| languages {virtual}: |
| @if _no.MAKEMO: |
| :sys cd $PODIR; CC="$CC" $MAKE prefix=$DESTDIR$prefix |
| @try: |
| :sys cd $PODIR; CC="$CC" $MAKE prefix=$DESTDIR$prefix converted |
| @except: |
| :print Generated converted language files failed, continuing |
| |
| # Update the *.po files for changes in the sources. Only run manually. |
| update-po {virtual}: |
| cd $PODIR; CC="$CC" $MAKE prefix=$DESTDIR$prefix update-po |
| |
| auto/if_perl.c: if_perl.xs |
| :sys $PERL -e 'unless ( $$] >= 5.005 ) { for (qw(na defgv errgv)) { print "#define PL_$$_ $$_\n" }}' > $target |
| :sys $PERL $PERLLIB/ExtUtils/xsubpp -prototypes -typemap \ |
| $PERLLIB/ExtUtils/typemap if_perl.xs >> $target |
| |
| auto/osdef.h: auto/config.h osdef.sh osdef1.h.in osdef2.h.in |
| :sys CC="$CC $CFLAGS" srcdir=$srcdir sh $srcdir/osdef.sh |
| |
| pathdef {virtual} : $BDIR/auto/pathdef$OBJSUF |
| |
| auto/pathdef.c: auto/config.aap |
| :print Creating $target |
| :print >! $target /* pathdef.c */ |
| :print >> $target /* This file is automatically created by main.aap */ |
| :print >> $target /* DO NOT EDIT! Change main.aap only. */ |
| :print >> $target $#include "vim.h" |
| :print >> $target char_u *default_vim_dir = (char_u *)"$VIMRCLOC"; |
| :print >> $target char_u *default_vimruntime_dir = (char_u *)"$?VIMRUNTIMEDIR"; |
| v = $CC -c -I$srcdir $CFLAGS |
| @v = string.replace(v, '"', '\\"') |
| :print >> $target char_u *all_cflags = (char_u *)"$v"; |
| linkcmd = $CC $LDFLAGS -o $VIMTARGET $LIBS |
| link_sed = $BDIR/link.sed |
| @if os.path.exists(link_sed): |
| # filter $linkcmd through $BDIR/link.sed |
| :print $linkcmd | :syseval sed -f $link_sed | :eval re.sub("\n", "", stdin) | :assign linkcmd |
| @linkcmd = string.replace(linkcmd, '"', '\\"') |
| :print >> $target char_u *all_lflags = (char_u *)"$linkcmd"; |
| @if _no.get("COMPILEDBY"): |
| who = $COMPILEDBY |
| where = |
| @else: |
| :syseval whoami | :eval re.sub("\n", "", stdin) | :assign who |
| |
| :syseval hostname | :eval re.sub("\n", "", stdin) | :assign where |
| @who = string.replace(who, '"', '\\"') |
| @where = string.replace(where, '"', '\\"') |
| :print >> $target char_u *compiled_user = (char_u *)"$who"; |
| :print >> $target char_u *compiled_sys = (char_u *)"$where"; |
| |
| |
| ### Names of the tools that are also made |
| TOOLS = xxd/xxd$EXESUF |
| |
| # Root of the installation tree. Empty for a normal install, set to an |
| # existing path to install into a special place (for generating a package). |
| DESTDIR ?= |
| |
| ### Location of man pages under $MANTOPDIR |
| MAN1DIR = /man1 |
| |
| ### Location of Vim files (should not need to be changed, and |
| ### some things might not work when they are changed!) |
| VIMDIR = /vim |
| @r = re.compile('.*VIM_VERSION_NODOT\\s*"(vim\\d\\d[^"]*)".*', re.S) |
| VIMRTDIR = /`r.match(open("version.h").read()).group(1)` |
| HELPSUBDIR = /doc |
| COLSUBDIR = /colors |
| SYNSUBDIR = /syntax |
| INDSUBDIR = /indent |
| AUTOSUBDIR = /autoload |
| PLUGSUBDIR = /plugin |
| FTPLUGSUBDIR = /ftplugin |
| LANGSUBDIR = /lang |
| COMPSUBDIR = /compiler |
| KMAPSUBDIR = /keymap |
| MACROSUBDIR = /macros |
| TOOLSSUBDIR = /tools |
| TUTORSUBDIR = /tutor |
| SPELLSUBDIR = /spell |
| PRINTSUBDIR = /print |
| PODIR = po |
| |
| ### VIMLOC common root of the Vim files (all versions) |
| ### VIMRTLOC common root of the runtime Vim files (this version) |
| ### VIMRCLOC compiled-in location for global [g]vimrc files (all versions) |
| ### VIMRUNTIMEDIR compiled-in location for runtime files (optional) |
| ### HELPSUBLOC location for help files |
| ### COLSUBLOC location for colorscheme files |
| ### SYNSUBLOC location for syntax files |
| ### INDSUBLOC location for indent files |
| ### AUTOSUBLOC location for standard autoload files |
| ### PLUGSUBLOC location for standard plugin files |
| ### FTPLUGSUBLOC location for ftplugin files |
| ### LANGSUBLOC location for language files |
| ### COMPSUBLOC location for compiler files |
| ### KMAPSUBLOC location for keymap files |
| ### MACROSUBLOC location for macro files |
| ### TOOLSSUBLOC location for tools files |
| ### TUTORSUBLOC location for tutor files |
| ### PRINTSUBLOC location for print files |
| ### SCRIPTLOC location for script files (menu.vim, bugreport.vim, ..) |
| ### You can override these if you want to install them somewhere else. |
| ### Edit feature.h for compile-time settings. |
| VIMLOC = $DATADIR$VIMDIR |
| @if not _no.get("VIMRTLOC"): |
| VIMRTLOC = $DATADIR$VIMDIR$VIMRTDIR |
| VIMRCLOC = $VIMLOC |
| HELPSUBLOC = $VIMRTLOC$HELPSUBDIR |
| COLSUBLOC = $VIMRTLOC$COLSUBDIR |
| SYNSUBLOC = $VIMRTLOC$SYNSUBDIR |
| INDSUBLOC = $VIMRTLOC$INDSUBDIR |
| AUTOSUBLOC = $VIMRTLOC$AUTOSUBDIR |
| PLUGSUBLOC = $VIMRTLOC$PLUGSUBDIR |
| FTPLUGSUBLOC = $VIMRTLOC$FTPLUGSUBDIR |
| LANGSUBLOC = $VIMRTLOC$LANGSUBDIR |
| COMPSUBLOC = $VIMRTLOC$COMPSUBDIR |
| KMAPSUBLOC = $VIMRTLOC$KMAPSUBDIR |
| MACROSUBLOC = $VIMRTLOC$MACROSUBDIR |
| TOOLSSUBLOC = $VIMRTLOC$TOOLSSUBDIR |
| TUTORSUBLOC = $VIMRTLOC$TUTORSUBDIR |
| SPELLSUBLOC = $VIMRTLOC$SPELLSUBDIR |
| PRINTSUBLOC = $VIMRTLOC$PRINTSUBDIR |
| SCRIPTLOC = $VIMRTLOC |
| |
| ### Only set VIMRUNTIMEDIR when VIMRTLOC is set to a different location and |
| ### the runtime directory is not below it. |
| #VIMRUNTIMEDIR = $VIMRTLOC |
| |
| ### Name of the evim file target. |
| EVIM_FILE = $DESTDIR$SCRIPTLOC/evim.vim |
| MSWIN_FILE = $DESTDIR$SCRIPTLOC/mswin.vim |
| |
| ### Name of the menu file target. |
| SYS_MENU_FILE = $DESTDIR$SCRIPTLOC/menu.vim |
| SYS_SYNMENU_FILE = $DESTDIR$SCRIPTLOC/synmenu.vim |
| SYS_DELMENU_FILE = $DESTDIR$SCRIPTLOC/delmenu.vim |
| |
| ### Name of the bugreport file target. |
| SYS_BUGR_FILE = $DESTDIR$SCRIPTLOC/bugreport.vim |
| |
| ### Name of the file type detection file target. |
| SYS_FILETYPE_FILE = $DESTDIR$SCRIPTLOC/filetype.vim |
| |
| ### Name of the file type detection file target. |
| SYS_FTOFF_FILE = $DESTDIR$SCRIPTLOC/ftoff.vim |
| |
| ### Name of the file type detection script file target. |
| SYS_SCRIPTS_FILE = $DESTDIR$SCRIPTLOC/scripts.vim |
| |
| ### Name of the ftplugin-on file target. |
| SYS_FTPLUGIN_FILE = $DESTDIR$SCRIPTLOC/ftplugin.vim |
| |
| ### Name of the ftplugin-off file target. |
| SYS_FTPLUGOF_FILE = $DESTDIR$SCRIPTLOC/ftplugof.vim |
| |
| ### Name of the indent-on file target. |
| SYS_INDENT_FILE = $DESTDIR$SCRIPTLOC/indent.vim |
| |
| ### Name of the indent-off file target. |
| SYS_INDOFF_FILE = $DESTDIR$SCRIPTLOC/indoff.vim |
| |
| ### Name of the option window script file target. |
| SYS_OPTWIN_FILE = $DESTDIR$SCRIPTLOC/optwin.vim |
| |
| ### Permissions for binaries |
| BINMOD = 755 |
| |
| ### Permissions for man page |
| MANMOD = 644 |
| |
| ### Permissions for help files |
| HELPMOD = 644 |
| |
| ### Permissions for Perl and shell scripts |
| SCRIPTMOD = 755 |
| |
| ### Permission for Vim script files (menu.vim, bugreport.vim, ..) |
| VIMSCRIPTMOD = 644 |
| |
| ### Permissions for all directories that are created |
| DIRMOD = 755 |
| |
| ### Permissions for all other files that are created |
| FILEMOD = 644 |
| |
| # Where to copy the man and help files from |
| HELPSOURCE = ../runtime/doc |
| |
| # Where to copy the script files from (menu, bugreport) |
| SCRIPTSOURCE = ../runtime |
| |
| # Where to copy the colorscheme files from |
| COLSOURCE = ../runtime/colors |
| |
| # Where to copy the syntax files from |
| SYNSOURCE = ../runtime/syntax |
| |
| # Where to copy the indent files from |
| INDSOURCE = ../runtime/indent |
| |
| # Where to copy the standard plugin files from |
| AUTOSOURCE = ../runtime/autoload |
| |
| # Where to copy the standard plugin files from |
| PLUGSOURCE = ../runtime/plugin |
| |
| # Where to copy the ftplugin files from |
| FTPLUGSOURCE = ../runtime/ftplugin |
| |
| # Where to copy the macro files from |
| MACROSOURCE = ../runtime/macros |
| |
| # Where to copy the tools files from |
| TOOLSSOURCE = ../runtime/tools |
| |
| # Where to copy the tutor files from |
| TUTORSOURCE = ../runtime/tutor |
| |
| # Where to copy the spell files from |
| SPELLSOURCE = ../runtime/spell |
| |
| # Where to look for language specific files |
| LANGSOURCE = ../runtime/lang |
| |
| # Where to look for compiler files |
| COMPSOURCE = ../runtime/compiler |
| |
| # Where to look for keymap files |
| KMAPSOURCE = ../runtime/keymap |
| |
| # Where to look for print resource files |
| PRINTSOURCE = ../runtime/print |
| |
| # abbreviations |
| DEST_BIN = $DESTDIR$BINDIR |
| DEST_VIM = $DESTDIR$VIMLOC |
| DEST_RT = $DESTDIR$VIMRTLOC |
| DEST_HELP = $DESTDIR$HELPSUBLOC |
| DEST_COL = $DESTDIR$COLSUBLOC |
| DEST_SYN = $DESTDIR$SYNSUBLOC |
| DEST_IND = $DESTDIR$INDSUBLOC |
| DEST_AUTO = $DESTDIR$AUTOSUBLOC |
| DEST_PLUG = $DESTDIR$PLUGSUBLOC |
| DEST_FTP = $DESTDIR$FTPLUGSUBLOC |
| DEST_LANG = $DESTDIR$LANGSUBLOC |
| DEST_COMP = $DESTDIR$COMPSUBLOC |
| DEST_KMAP = $DESTDIR$KMAPSUBLOC |
| DEST_MACRO = $DESTDIR$MACROSUBLOC |
| DEST_TOOLS = $DESTDIR$TOOLSSUBLOC |
| DEST_TUTOR = $DESTDIR$TUTORSUBLOC |
| DEST_SPELL = $DESTDIR$SPELLSUBLOC |
| DEST_SCRIPT = $DESTDIR$SCRIPTLOC |
| DEST_PRINT = $DESTDIR$PRINTSUBLOC |
| DEST_MAN_TOP = $DESTDIR$?(MANDIR) |
| |
| # We assume that the ".../man/xx/man1/" directory is for latin1 manual pages. |
| # Some systems use UTF-8, but these should find the ".../man/xx.UTF-8/man1/" |
| # directory first. |
| # FreeBSD uses ".../man/xx.ISO8859-1/man1" for latin1, use that one too. |
| DEST_MAN = $(DEST_MAN_TOP)$(MAN1DIR) |
| DEST_MAN_FR = $(DEST_MAN_TOP)/fr$(MAN1DIR) |
| DEST_MAN_FR_I = $(DEST_MAN_TOP)/fr.ISO8859-1$(MAN1DIR) |
| DEST_MAN_FR_U = $(DEST_MAN_TOP)/fr.UTF-8$(MAN1DIR) |
| DEST_MAN_IT = $(DEST_MAN_TOP)/it$(MAN1DIR) |
| DEST_MAN_IT_I = $(DEST_MAN_TOP)/it.ISO8859-1$(MAN1DIR) |
| DEST_MAN_IT_U = $(DEST_MAN_TOP)/it.UTF-8$(MAN1DIR) |
| DEST_MAN_PL = $(DEST_MAN_TOP)/pl.ISO8859-2$(MAN1DIR) |
| DEST_MAN_PL_U = $(DEST_MAN_TOP)/pl.UTF-8$(MAN1DIR) |
| DEST_MAN_RU = $(DEST_MAN_TOP)/ru.KOI8-R$(MAN1DIR) |
| DEST_MAN_RU_U = $(DEST_MAN_TOP)/ru.UTF-8$(MAN1DIR) |
| |
| # These are directories, create them when needed. |
| :attr {directory = $DIRMOD} $DEST_BIN $DEST_VIM $DEST_RT $DEST_HELP $DEST_COL |
| $DEST_SYN $DEST_IND $DEST_AUTO $DEST_AUTO/xml $DEST_PLUG |
| $DEST_FTP $DEST_LANG |
| $DEST_COMP $DEST_KMAP $DEST_MACRO $DEST_TOOLS $DEST_TUTOR |
| $DEST_SCRIPT $DEST_PRINT $DEST_MAN $DEST_SPELL |
| $DEST_MAN_FR $DEST_MAN_FR_I $DEST_MAN_FR_U $DEST_MAN_IT |
| $DEST_MAN_IT_I $DEST_MAN_IT_U |
| $DEST_MAN_PL $DEST_MAN_PL_U |
| $DEST_MAN_RU $DEST_MAN_RU_U |
| |
| # |
| # I N S T A L L |
| # |
| install: $GUI_INSTALL |
| |
| install_normal: |
| @if not os.path.isdir(_no.DEST_BIN): |
| @try: |
| :mkdir $DEST_BIN |
| @except: |
| @ pass |
| @if os.access(_no.DEST_BIN, os.W_OK): |
| # Bin directory is writable, install directly. |
| :update installvim installtools $INSTALL_LANGS install-icons |
| @else: |
| # Bin directory is not writable, need to become root. |
| :print The destination directory "$DEST_BIN" is not writable. |
| :print If this is the wrong directory, use PREFIX to specify another one. |
| :print Otherwise, type the root password to continue installing. |
| :asroot $AAP install |
| |
| installvim {virtual}: installvimbin installtutorbin \ |
| installruntime installlinks installmanlinks |
| |
| installvimbin {virtual}{force}: $Target $DEST_BIN |
| exe = $DEST_BIN/$VIMTARGET |
| @if os.path.exists(exe): |
| # Move the old executable aside and delete it. Any other method |
| # may cause a crash if the executable is currently being used. |
| :move {force} $exe $(exe).rm |
| :del {force} $(exe).rm |
| :copy $VIMTARGET $DEST_BIN |
| :do strip $exe |
| :chmod $BINMOD $DEST_BIN/$VIMTARGET |
| # may create a link to the new executable from /usr/bin/vi |
| @if _no.get("LINKIT"): |
| :sys $LINKIT |
| |
| # Long list of arguments for the shell script that installs the manual pages |
| # for one language. |
| INSTALLMANARGS = $(VIMLOC) $(SCRIPTLOC) $(VIMRCLOC) $(HELPSOURCE) $(MANMOD) \ |
| $(VIMNAME) $(VIMDIFFNAME) $(EVIMNAME) |
| |
| # Install most of the runtime files |
| installruntime {virtual}: installrtbase installmacros installtutor installspell |
| |
| # install the help files; first adjust the contents for the location |
| installrtbase {virtual}{force}: $HELPSOURCE/vim.1 $DEST_VIM |
| $DEST_RT $DEST_HELP $DEST_COL $DEST_SYN $DEST_IND |
| $DEST_FTP $DEST_AUTO $DEST_AUTO/xml $DEST_PLUG $DEST_TUTOR |
| $DEST_COMP $DEST_SPELL $DEST_PRINT |
| :chmod 755 installman.sh |
| :sys ./installman.sh install $(DEST_MAN) "" $(INSTALLMANARGS) |
| |
| :cd $HELPSOURCE |
| @try: |
| XTRA = `glob.glob("*.??x")` `glob.glob("tags-??")` |
| @except: |
| XTRA = # It's OK if there are no matches. |
| :copy *.txt tags $XTRA $DEST_HELP |
| :cd - |
| :cd $DEST_HELP |
| :chmod $HELPMOD *.txt tags $XTRA |
| :cd - |
| :copy $HELPSOURCE/*.pl $DEST_HELP |
| :chmod $SCRIPTMOD $DEST_HELP/*.pl |
| # install the menu files |
| :copy $SCRIPTSOURCE/menu.vim $SYS_MENU_FILE |
| :chmod $VIMSCRIPTMOD $SYS_MENU_FILE |
| :copy $SCRIPTSOURCE/synmenu.vim $SYS_SYNMENU_FILE |
| :chmod $VIMSCRIPTMOD $SYS_SYNMENU_FILE |
| :copy $SCRIPTSOURCE/delmenu.vim $SYS_DELMENU_FILE |
| :chmod $VIMSCRIPTMOD $SYS_DELMENU_FILE |
| # install the evim file |
| :copy $SCRIPTSOURCE/mswin.vim $MSWIN_FILE |
| :chmod $VIMSCRIPTMOD $MSWIN_FILE |
| :copy $SCRIPTSOURCE/evim.vim $EVIM_FILE |
| :chmod $VIMSCRIPTMOD $EVIM_FILE |
| # install the bugreport file |
| :copy $SCRIPTSOURCE/bugreport.vim $SYS_BUGR_FILE |
| :chmod $VIMSCRIPTMOD $SYS_BUGR_FILE |
| # install the example vimrc files |
| :copy $SCRIPTSOURCE/vimrc_example.vim $DEST_SCRIPT |
| :chmod $VIMSCRIPTMOD $DEST_SCRIPT/vimrc_example.vim |
| :copy $SCRIPTSOURCE/gvimrc_example.vim $DEST_SCRIPT |
| :chmod $VIMSCRIPTMOD $DEST_SCRIPT/gvimrc_example.vim |
| # install the file type detection files |
| :copy $SCRIPTSOURCE/filetype.vim $SYS_FILETYPE_FILE |
| :chmod $VIMSCRIPTMOD $SYS_FILETYPE_FILE |
| :copy $SCRIPTSOURCE/ftoff.vim $SYS_FTOFF_FILE |
| :chmod $VIMSCRIPTMOD $SYS_FTOFF_FILE |
| :copy $SCRIPTSOURCE/scripts.vim $SYS_SCRIPTS_FILE |
| :chmod $VIMSCRIPTMOD $SYS_SCRIPTS_FILE |
| :copy $SCRIPTSOURCE/ftplugin.vim $SYS_FTPLUGIN_FILE |
| :chmod $VIMSCRIPTMOD $SYS_FTPLUGIN_FILE |
| :copy $SCRIPTSOURCE/ftplugof.vim $SYS_FTPLUGOF_FILE |
| :chmod $VIMSCRIPTMOD $SYS_FTPLUGOF_FILE |
| :copy $SCRIPTSOURCE/indent.vim $SYS_INDENT_FILE |
| :chmod $VIMSCRIPTMOD $SYS_INDENT_FILE |
| :copy $SCRIPTSOURCE/indoff.vim $SYS_INDOFF_FILE |
| :chmod $VIMSCRIPTMOD $SYS_INDOFF_FILE |
| :copy $SCRIPTSOURCE/optwin.vim $SYS_OPTWIN_FILE |
| :chmod $VIMSCRIPTMOD $SYS_OPTWIN_FILE |
| # install the print resource files |
| :copy $PRINTSOURCE/*.ps $DEST_PRINT |
| :chmod $FILEMOD $DEST_PRINT/*.ps |
| # install the colorscheme files |
| :copy $COLSOURCE/*.vim $COLSOURCE/README.txt $DEST_COL |
| :chmod $HELPMOD $DEST_COL/*.vim $DEST_COL/README.txt |
| # install the syntax files |
| :copy $SYNSOURCE/*.vim $SYNSOURCE/README.txt $DEST_SYN |
| :chmod $HELPMOD $DEST_SYN/*.vim $DEST_SYN/README.txt |
| # install the indent files |
| :copy $INDSOURCE/*.vim $INDSOURCE/README.txt $DEST_IND |
| :chmod $HELPMOD $DEST_IND/*.vim |
| # install the standard autoload files |
| :copy $AUTOSOURCE/*.vim $AUTOSOURCE/README.txt $DEST_AUTO |
| :chmod $HELPMOD $DEST_AUTO/*.vim $DEST_AUTO/README.txt |
| :copy $AUTOSOURCE/xml/*.vim $DEST_AUTO/xml |
| :chmod $HELPMOD $DEST_AUTO/xml/*.vim |
| # install the standard plugin files |
| :copy $PLUGSOURCE/*.vim $PLUGSOURCE/README.txt $DEST_PLUG |
| :chmod $HELPMOD $DEST_PLUG/*.vim $DEST_PLUG/README.txt |
| # install the ftplugin files |
| :copy $FTPLUGSOURCE/*.vim $FTPLUGSOURCE/README.txt $DEST_FTP |
| :chmod $HELPMOD $DEST_FTP/*.vim $DEST_FTP/README.txt |
| # install the compiler files |
| :copy $COMPSOURCE/*.vim $COMPSOURCE/README.txt $DEST_COMP |
| :chmod $HELPMOD $DEST_COMP/*.vim $DEST_COMP/README.txt |
| |
| installmacros {virtual}{force}: $MACROSOURCE $DEST_VIM $DEST_RT $DEST_MACRO |
| :copy {recursive}{force} $MACROSOURCE/* $DEST_MACRO |
| # Delete any CVS and AAPDIR directories. |
| # Use the ":tree" command if possible. It was added later, fall back |
| # to using "find" when it doesn't work. |
| @try: |
| :tree $DEST_MACRO {dirname = CVS} |
| :del {recursive} $name |
| :tree $DEST_MACRO {dirname = AAPDIR} |
| :del {recursive} $name |
| :tree $DEST_MACRO {dirname = .*} |
| :chmod $DIRMOD $name |
| :tree $DEST_MACRO {filename = .*} |
| :chmod $FILEMOD $name |
| @except: |
| @ ok, cvsdirs = redir_system('find %s -name CVS -print' % _no.DEST_MACRO) |
| @ if ok and cvsdirs: |
| :del {recursive} $cvsdirs |
| :sys chmod $DIRMOD ``find $DEST_MACRO -type d -print`` |
| :sys chmod $FILEMOD ``find $DEST_MACRO -type f -print`` |
| :chmod $SCRIPTMOD $DEST_MACRO/less.sh |
| |
| # install the tutor files |
| installtutorbin {virtual}{force}: $DEST_VIM |
| :copy vimtutor $DEST_BIN/$(VIMNAME)tutor |
| :chmod $SCRIPTMOD $DEST_BIN/$(VIMNAME)tutor |
| |
| installtutor {virtual}{force}: $DEST_RT $DEST_TUTOR |
| :copy $TUTORSOURCE/tutor* $TUTORSOURCE/README* $DEST_TUTOR |
| :chmod $HELPMOD $DEST_TUTOR/* |
| |
| # Install the spell files, if they exist. This assumes at least the English |
| # spell file is there. |
| installspell {virtual}: $(DEST_VIM) $(DEST_RT) $(DEST_SPELL) |
| enspl = $(SPELLSOURCE)/en.latin1.spl |
| @if os.path.exists(enspl): |
| :copy $(SPELLSOURCE)/*.spl $(SPELLSOURCE)/*.vim $(DEST_SPELL) |
| :chmod $(HELPMOD) $(DEST_SPELL)/*.spl $(DEST_SPELL)/*.vim |
| @try: |
| :copy $(SPELLSOURCE)/*.sug $(DEST_SPELL) |
| :chmod $(HELPMOD) $(DEST_SPELL)/*.sug |
| @except: |
| @ pass |
| |
| # install helper program xxd |
| installtools {virtual}{force}: $TOOLS $DEST_BIN $DEST_MAN \ |
| $TOOLSSOURCE $DEST_VIM $DEST_RT $DEST_TOOLS \ |
| $INSTALL_TOOL_LANGS |
| xxd = $DEST_BIN/xxd$EXESUF |
| @if os.path.exists(xxd): |
| :move {force} $xxd $(xxd).rm |
| :del $(xxd).rm |
| :copy xxd/xxd$EXESUF $DEST_BIN |
| :do strip $DEST_BIN/xxd$EXESUF |
| :chmod $BINMOD $DEST_BIN/xxd$EXESUF |
| :chmod 755 installman.sh |
| :sys ./installman.sh xxd $(DEST_MAN) "" $(INSTALLMANARGS) |
| # |
| # install the runtime tools |
| @try: |
| @ if aap_has(":tree"): |
| # New method: copy everything and delete CVS and AAPDIR dirs |
| :copy {recursive} $TOOLSSOURCE/* $DEST_TOOLS |
| :tree $DEST_TOOLS {dirname = CVS} |
| :delete {recursive} $name |
| :tree $DEST_TOOLS {dirname = AAPDIR} |
| :delete {recursive} $name |
| @except: |
| # Old method: copy only specific files and directories. |
| :copy {recursive} $TOOLSSOURCE/README.txt $TOOLSSOURCE/[a-z]* $DEST_TOOLS |
| :chmod $FILEMOD $DEST_TOOLS/* |
| # replace the path in some tools |
| :progsearch perlpath perl |
| @if perlpath: |
| :cat $TOOLSSOURCE/efm_perl.pl | |
| :eval re.sub("/usr/bin/perl", perlpath, stdin) |
| >! $DEST_TOOLS/efm_perl.pl |
| @else: |
| :copy $TOOLSSOURCE/efm_perl.pl $DEST_TOOLS |
| |
| :progsearch awkpath nawk gawk awk |
| @if awkpath: |
| :cat $TOOLSSOURCE/mve.awk | |
| :eval re.sub("/usr/bin/nawk", awkpath, stdin) |
| >! $DEST_TOOLS/mve.awk |
| @else: |
| :copy $TOOLSSOURCE/mve.awk $DEST_TOOLS |
| |
| :sys chmod $SCRIPTMOD ``grep -l "^#!" $DEST_TOOLS/*`` |
| |
| # install the language specific files for tools, if they were unpacked |
| install-tool-languages: |
| :chmod 755 installman.sh |
| :sys ./installman.sh xxd $(DEST_MAN_FR) "-fr" $(INSTALLMANARGS) |
| :sys ./installman.sh xxd $(DEST_MAN_FR_I) "-fr" $(INSTALLMANARGS) |
| :sys ./installman.sh xxd $(DEST_MAN_FR_U) "-fr.UTF-8" $(INSTALLMANARGS) |
| :sys ./installman.sh xxd $(DEST_MAN_IT) "-it" $(INSTALLMANARGS) |
| :sys ./installman.sh xxd $(DEST_MAN_IT_I) "-it" $(INSTALLMANARGS) |
| :sys ./installman.sh xxd $(DEST_MAN_IT_U) "-it.UTF-8" $(INSTALLMANARGS) |
| :sys ./installman.sh xxd $(DEST_MAN_PL) "-pl" $(INSTALLMANARGS) |
| :sys ./installman.sh xxd $(DEST_MAN_PL_U) "-pl.UTF-8" $(INSTALLMANARGS) |
| :sys ./installman.sh xxd $(DEST_MAN_RU) "-ru" $(INSTALLMANARGS) |
| :sys ./installman.sh xxd $(DEST_MAN_RU_U) "-ru.UTF-8" $(INSTALLMANARGS) |
| |
| # install the language specific files, if they were unpacked |
| install-languages {virtual}{force}: languages $DEST_LANG $DEST_KMAP |
| :chmod 755 installman.sh |
| :sys ./installman.sh install $(DEST_MAN_FR) "-fr" $(INSTALLMANARGS) |
| :sys ./installman.sh install $(DEST_MAN_FR_I) "-fr" $(INSTALLMANARGS) |
| :sys ./installman.sh install $(DEST_MAN_FR_U) "-fr.UTF-8" $(INSTALLMANARGS) |
| :sys ./installman.sh install $(DEST_MAN_IT) "-it" $(INSTALLMANARGS) |
| :sys ./installman.sh install $(DEST_MAN_IT_I) "-it" $(INSTALLMANARGS) |
| :sys ./installman.sh install $(DEST_MAN_IT_U) "-it.UTF-8" $(INSTALLMANARGS) |
| :sys ./installman.sh install $(DEST_MAN_PL) "-pl" $(INSTALLMANARGS) |
| :sys ./installman.sh install $(DEST_MAN_PL_U) "-pl.UTF-8" $(INSTALLMANARGS) |
| :sys ./installman.sh install $(DEST_MAN_RU) "-ru" $(INSTALLMANARGS) |
| :sys ./installman.sh install $(DEST_MAN_RU_U) "-ru.UTF-8" $(INSTALLMANARGS) |
| :chmod 755 installml.sh |
| :sys ./installml.sh install "$(GUI_MAN_TARGETS)" \ |
| $(DEST_MAN_FR) $(INSTALLMLARGS) |
| :sys ./installml.sh install "$(GUI_MAN_TARGETS)" \ |
| $(DEST_MAN_FR_I) $(INSTALLMLARGS) |
| :sys ./installml.sh install "$(GUI_MAN_TARGETS)" \ |
| $(DEST_MAN_FR_U) $(INSTALLMLARGS) |
| :sys ./installml.sh install "$(GUI_MAN_TARGETS)" \ |
| $(DEST_MAN_IT) $(INSTALLMLARGS) |
| :sys ./installml.sh install "$(GUI_MAN_TARGETS)" \ |
| $(DEST_MAN_IT_I) $(INSTALLMLARGS) |
| :sys ./installml.sh install "$(GUI_MAN_TARGETS)" \ |
| $(DEST_MAN_IT_U) $(INSTALLMLARGS) |
| :sys ./installml.sh install "$(GUI_MAN_TARGETS)" \ |
| $(DEST_MAN_PL) $(INSTALLMLARGS) |
| :sys ./installml.sh install "$(GUI_MAN_TARGETS)" \ |
| $(DEST_MAN_PL_U) $(INSTALLMLARGS) |
| :sys ./installml.sh install "$(GUI_MAN_TARGETS)" \ |
| $(DEST_MAN_RU) $(INSTALLMLARGS) |
| :sys ./installml.sh install "$(GUI_MAN_TARGETS)" \ |
| $(DEST_MAN_RU_U) $(INSTALLMLARGS) |
| |
| @if _no.MAKEMO: |
| :sys cd $PODIR; $MAKE prefix=$DESTDIR$prefix \ |
| LOCALEDIR=$DEST_LANG INSTALL_DATA=cp FILEMOD=$FILEMOD install |
| @if os.path.exists(_no.LANGSOURCE): |
| :print installing language files |
| :copy $LANGSOURCE/README.txt $LANGSOURCE/*.vim $DEST_LANG |
| :chmod $FILEMOD $DEST_LANG/*.vim |
| @if os.path.exists(_no.KMAPSOURCE): |
| :copy $KMAPSOURCE/README.txt $KMAPSOURCE/*.vim $DEST_KMAP |
| :chmod $FILEMOD $DEST_KMAP/*.vim |
| |
| # install the icons for KDE, if the directory exists and the icon doesn't. |
| ICON48PATH = $DESTDIR$DATADIR/icons/hicolor/48x48/apps |
| ICON32PATH = $DESTDIR$DATADIR/icons/locolor/32x32/apps |
| ICON16PATH = $DESTDIR$DATADIR/icons/locolor/16x16/apps |
| KDEPATH = $HOME/.kde/share/icons |
| install-icons {virtual}: |
| gp = $ICON48PATH/gvim.png |
| @if os.path.isdir(_no.ICON48PATH) and not os.path.exists(gp): |
| :copy $SCRIPTSOURCE/vim48x48.png $gp |
| gp = $ICON32PATH/gvim.png |
| @if os.path.isdir(_no.ICON32PATH) and not os.path.exists(gp): |
| :copy $SCRIPTSOURCE/vim32x32.png $gp |
| gp = $ICON16PATH/gvim.png |
| @if os.path.isdir(_no.ICON16PATH) and not os.path.exists(gp): |
| :copy $SCRIPTSOURCE/vim16x16.png $gp |
| |
| |
| $HELPSOURCE/vim.1 $MACROSOURCE $TOOLSSOURCE: |
| @if not os.path.exists(_no.TOOLSSOURCE): |
| :print Runtime files not found. |
| :error You need to unpack the runtime archive before running "make install". |
| |
| # create links from various names to vim. This is only done when the links |
| # (or executables with the same name) don't exist yet. |
| installlinks {virtual}: $GUI_TARGETS \ |
| $DEST_BIN/$EXTARGET \ |
| $DEST_BIN/$VIEWTARGET \ |
| $DEST_BIN/$RVIMTARGET \ |
| $DEST_BIN/$RVIEWTARGET \ |
| $INSTALLVIMDIFF |
| |
| installglinks {virtual}: $DEST_BIN/$GVIMTARGET \ |
| $DEST_BIN/$GVIEWTARGET \ |
| $DEST_BIN/$RGVIMTARGET \ |
| $DEST_BIN/$RGVIEWTARGET \ |
| $DEST_BIN/$EVIMTARGET \ |
| $DEST_BIN/$EVIEWTARGET \ |
| $INSTALLGVIMDIFF |
| |
| installvimdiff {virtual}: $DEST_BIN/$VIMDIFFTARGET |
| installgvimdiff {virtual}: $DEST_BIN/$GVIMDIFFTARGET |
| |
| # These dependencies use an empty buildcheck so that they are only done when |
| # the target doesn't exist. |
| $DEST_BIN/$EXTARGET: {buildcheck = } |
| :sys cd $DEST_BIN; ln -s $VIMTARGET $EXTARGET |
| |
| $DEST_BIN/$VIEWTARGET: {buildcheck = } |
| :sys cd $DEST_BIN; ln -s $VIMTARGET $VIEWTARGET |
| |
| $DEST_BIN/$GVIMTARGET: {buildcheck = } |
| :sys cd $DEST_BIN; ln -s $VIMTARGET $GVIMTARGET |
| |
| $DEST_BIN/$GVIEWTARGET: {buildcheck = } |
| :sys cd $DEST_BIN; ln -s $VIMTARGET $GVIEWTARGET |
| |
| $DEST_BIN/$RVIMTARGET: {buildcheck = } |
| :sys cd $DEST_BIN; ln -s $VIMTARGET $RVIMTARGET |
| |
| $DEST_BIN/$RVIEWTARGET: {buildcheck = } |
| :sys cd $DEST_BIN; ln -s $VIMTARGET $RVIEWTARGET |
| |
| $DEST_BIN/$RGVIMTARGET: {buildcheck = } |
| :sys cd $DEST_BIN; ln -s $VIMTARGET $RGVIMTARGET |
| |
| $DEST_BIN/$RGVIEWTARGET: {buildcheck = } |
| :sys cd $DEST_BIN; ln -s $VIMTARGET $RGVIEWTARGET |
| |
| $DEST_BIN/$VIMDIFFTARGET: {buildcheck = } |
| :sys cd $DEST_BIN; ln -s $VIMTARGET $VIMDIFFTARGET |
| |
| $DEST_BIN/$GVIMDIFFTARGET: {buildcheck = } |
| :sys cd $DEST_BIN; ln -s $VIMTARGET $GVIMDIFFTARGET |
| |
| $DEST_BIN/$EVIMTARGET: {buildcheck = } |
| :sys cd $DEST_BIN; ln -s $VIMTARGET $EVIMTARGET |
| |
| $DEST_BIN/$EVIEWTARGET: {buildcheck = } |
| :sys cd $DEST_BIN; ln -s $VIMTARGET $EVIEWTARGET |
| |
| # create links for the manual pages with various names to vim. This is only |
| # done when the links (or manpages with the same name) don't exist yet. |
| INSTALLMLARGS = $(VIMNAME) $(VIMDIFFNAME) $(EVIMNAME) \ |
| $(EXNAME) $(VIEWNAME) $(RVIMNAME) $(RVIEWNAME) \ |
| $(GVIMNAME) $(GVIEWNAME) $(RGVIMNAME) $(RGVIEWNAME) \ |
| $(GVIMDIFFNAME) $(EVIEWNAME) |
| |
| installmanlinks {virtual}: |
| :chmod 755 installml.sh |
| :sys ./installml.sh install "$(GUI_MAN_TARGETS)" \ |
| $(DEST_MAN) $(INSTALLMLARGS) |
| |
| # |
| # U N I N S T A L L |
| # |
| uninstall {virtual}{force}: uninstall_runtime |
| :del {force} $DEST_BIN/$VIMTARGET |
| :del {force} $DEST_BIN/vimtutor |
| :del {force} $DEST_BIN/$EXTARGET $DEST_BIN/$VIEWTARGET |
| :del {force} $DEST_BIN/$GVIMTARGET $DEST_BIN/$GVIEWTARGET |
| :del {force} $DEST_BIN/$RVIMTARGET $DEST_BIN/$RVIEWTARGET |
| :del {force} $DEST_BIN/$RGVIMTARGET $DEST_BIN/$RGVIEWTARGET |
| :del {force} $DEST_BIN/$VIMDIFFTARGET $DEST_BIN/$GVIMDIFFTARGET |
| :del {force} $DEST_BIN/$EVIMTARGET $DEST_BIN/$EVIEWTARGET |
| :del {force} $DEST_BIN/xxd$EXESUF |
| |
| # Note: "deldir" will fail if any files were added after "make install", that |
| # is intentionally: Keep files the user added. |
| uninstall_runtime {virtual}{force}: |
| :chmod 755 installman.sh |
| :sys ./installman.sh uninstall $(DEST_MAN) "" $(INSTALLMANARGS) |
| :sys ./installman.sh uninstall $(DEST_MAN_FR) "" $(INSTALLMANARGS) |
| :sys ./installman.sh uninstall $(DEST_MAN_FR_I) "" $(INSTALLMANARGS) |
| :sys ./installman.sh uninstall $(DEST_MAN_FR_U) "" $(INSTALLMANARGS) |
| :sys ./installman.sh uninstall $(DEST_MAN_IT) "" $(INSTALLMANARGS) |
| :sys ./installman.sh uninstall $(DEST_MAN_IT_I) "" $(INSTALLMANARGS) |
| :sys ./installman.sh uninstall $(DEST_MAN_IT_U) "" $(INSTALLMANARGS) |
| :sys ./installman.sh uninstall $(DEST_MAN_PL) "" $(INSTALLMANARGS) |
| :sys ./installman.sh uninstall $(DEST_MAN_PL_U) "" $(INSTALLMANARGS) |
| :sys ./installman.sh uninstall $(DEST_MAN_RU) "" $(INSTALLMANARGS) |
| :sys ./installman.sh uninstall $(DEST_MAN_RU_U) "" $(INSTALLMANARGS) |
| :chmod 755 installml.sh |
| :sys ./installml.sh uninstall "$(GUI_MAN_TARGETS)" \ |
| $(DEST_MAN) $(INSTALLMLARGS) |
| :sys ./installml.sh uninstall "$(GUI_MAN_TARGETS)" \ |
| $(DEST_MAN_FR) $(INSTALLMLARGS) |
| :sys ./installml.sh uninstall "$(GUI_MAN_TARGETS)" \ |
| $(DEST_MAN_FR_I) $(INSTALLMLARGS) |
| :sys ./installml.sh uninstall "$(GUI_MAN_TARGETS)" \ |
| $(DEST_MAN_FR_U) $(INSTALLMLARGS) |
| :sys ./installml.sh uninstall "$(GUI_MAN_TARGETS)" \ |
| $(DEST_MAN_IT) $(INSTALLMLARGS) |
| :sys ./installml.sh uninstall "$(GUI_MAN_TARGETS)" \ |
| $(DEST_MAN_IT_I) $(INSTALLMLARGS) |
| :sys ./installml.sh uninstall "$(GUI_MAN_TARGETS)" \ |
| $(DEST_MAN_IT_U) $(INSTALLMLARGS) |
| :sys ./installml.sh uninstall "$(GUI_MAN_TARGETS)" \ |
| $(DEST_MAN_PL) $(INSTALLMLARGS) |
| :sys ./installml.sh uninstall "$(GUI_MAN_TARGETS)" \ |
| $(DEST_MAN_PL_U) $(INSTALLMLARGS) |
| :sys ./installml.sh uninstall "$(GUI_MAN_TARGETS)" \ |
| $(DEST_MAN_RU) $(INSTALLMLARGS) |
| :sys ./installml.sh uninstall "$(GUI_MAN_TARGETS)" \ |
| $(DEST_MAN_RU_U) $(INSTALLMLARGS) |
| :del {force} $DEST_MAN/xxd.1 |
| :del {force} $(DEST_MAN_FR)/xxd.1 $(DEST_MAN_FR_I)/xxd.1 $(DEST_MAN_FR_U)/xxd.1 |
| :del {force} $(DEST_MAN_IT)/xxd.1 $(DEST_MAN_IT_I)/xxd.1 $(DEST_MAN_IT_U)/xxd.1 |
| :del {force} $(DEST_MAN_PL)/xxd.1 $(DEST_MAN_PL_U)/xxd.1 |
| :del {force} $(DEST_MAN_RU)/xxd.1 $(DEST_MAN_RU_U)/xxd.1 |
| |
| :del {force} $DEST_HELP/*.txt $DEST_HELP/tags $DEST_HELP/*.pl |
| :del {force} $SYS_MENU_FILE $SYS_SYNMENU_FILE $SYS_DELMENU_FILE |
| :del {force} $SYS_BUGR_FILE $EVIM_FILE $MSWIN_FILE |
| :del {force} $DEST_SCRIPT/gvimrc_example.vim $DEST_SCRIPT/vimrc_example.vim |
| :del {force} $SYS_FILETYPE_FILE $SYS_FTOFF_FILE $SYS_SCRIPTS_FILE |
| :del {force} $SYS_INDOFF_FILE $SYS_INDENT_FILE |
| :del {force} $SYS_FTPLUGOF_FILE $SYS_FTPLUGIN_FILE |
| :del {force} $SYS_OPTWIN_FILE |
| :del {force} $DEST_COL/*.vim $DEST_COL/README.txt |
| :del {force} $DEST_SYN/*.vim $DEST_SYN/README.txt |
| :del {force} $DEST_IND/*.vim $DEST_IND/README.txt |
| :del {force} $DEST_PRINT/*.ps |
| :del {force}{recursive} $DEST_MACRO |
| :del {force}{recursive} $DEST_TUTOR |
| :del {force}{recursive} $DEST_SPELL |
| :del {force}{recursive} $DEST_TOOLS |
| :del {force}{recursive} $DEST_LANG |
| :del {force}{recursive} $DEST_KMAP |
| :del {force}{recursive} $DEST_COMP |
| :deldir {force} $DEST_HELP $DEST_COL $DEST_SYN $DEST_IND |
| :del {force}{recursive} $DEST_FTP/*.vim $DEST_FTP/README.txt |
| :del {force} $DEST_AUTO/*.vim $DEST_AUTO/README.txt $DEST_AUTO/xml/*.vim |
| :del {force} $DEST_PLUG/*.vim $DEST_PLUG/README.txt |
| :deldir {force} $DEST_FTP $DEST_AUTO/xml $DEST_AUTO $DEST_PLUG $DEST_PRINT $DEST_RT |
| # This will fail when other Vim versions are installed, no worries. |
| @try: |
| :deldir $DEST_VIM |
| @except: |
| :print Cannot delete $DEST_VIM |
| |
| ############################################################################### |
| ### MacOS X installation |
| ### |
| ### This installs a runnable Vim.app in $(prefix) |
| |
| REZ = /Developer/Tools/Rez |
| RESDIR = $(APPDIR)/Contents/Resources |
| @r = re.compile('.*VIM_VERSION_SHORT\\s*"(\\d[^"]*)".*', re.S) |
| VERSION = /`r.match(open("version.h").read()).group(1)` |
| |
| ### Common flags |
| M4FLAGSX = $?(M4FLAGS) -DAPP_EXE=$(VIMNAME) -DAPP_NAME=$(VIMNAME) \ |
| -DAPP_VER=$(VERSION) |
| |
| # Resources used for the Mac are in one directory. |
| RSRC_DIR = os_mac_rsrc |
| |
| :attr {directory = $DIRMOD} $RESDIR |
| |
| install_macosx {virtual}: gui_bundle |
| # Remove the link to the runtime dir, don't want to copy all of that. |
| :delete {force} $(RESDIR)/vim/runtime |
| :copy {r} $APPDIR $DESTDIR$prefix |
| :tree $DESTDIR$prefix {dirname = AAPDIR} |
| :delete {recursive} $name |
| # Install the runtime files. Recursive! |
| :mkdir {r}{f} $DESTDIR$prefix/$RESDIR/vim/runtime |
| # :mkdir $(DESTDIR)$(prefix)/$(APPDIR)/bin |
| :execute main.aap PREFIX=$DESTDIR$prefix/$RESDIR/vim VIMRTLOC=$DESTDIR$prefix/$RESDIR/vim/runtime installruntime |
| # Put the link back. |
| :symlink `os.getcwd()`/../runtime $RESDIR/vim/runtime |
| # TODO: Create the vimtutor application. |
| |
| gui_bundle {virtual}: $(RESDIR) bundle-dir bundle-executable bundle-info \ |
| bundle-resource bundle-language |
| |
| bundle-dir {virtual}: $(APPDIR)/Contents $(VIMTARGET) |
| # Make a link to the runtime directory, so that we can try out the executable |
| # without installing it. |
| :mkdir {r}{f} $(RESDIR)/vim |
| :symlink {quiet} `os.getcwd()`/../runtime $(RESDIR)/vim/runtime |
| |
| bundle-executable {virtual}: $(VIMTARGET) |
| :mkdir {r}{f} $(APPDIR)/Contents/MacOS |
| :copy $(VIMTARGET) $(APPDIR)/Contents/MacOS/$(VIMTARGET) |
| |
| bundle-info {virtual}: bundle-dir |
| :print Creating PkgInfo |
| :print "APPLVIM!" >! $(APPDIR)/Contents/PkgInfo |
| :print Creating Info.plist |
| :sys m4 $(M4FLAGSX) infplist.xml > $(APPDIR)/Contents/Info.plist |
| |
| bundle-resource {virtual}: bundle-dir bundle-rsrc |
| :copy {force} $(RSRC_DIR)/*.icns $(RESDIR) |
| |
| ### Classic resources |
| # Resource fork (in the form of a .rsrc file) for Classic Vim (Mac OS 9) |
| # This file is also required for OS X Vim. |
| bundle-rsrc {virtual}: os_mac.rsr.hqx |
| :print Creating resource fork |
| :sys python dehqx.py $source |
| :del {force} gui_mac.rsrc |
| :move gui_mac.rsrc.rsrcfork $(RESDIR)/$(VIMNAME).rsrc |
| |
| # po/Make_osx.pl says something about generating a Mac message file |
| # for Ukrainian. Would somebody using Mac OS X in Ukrainian |
| # *really* be upset that Carbon Vim was not localised in |
| # Ukrainian? |
| # |
| #bundle-language: bundle-dir po/Make_osx.pl |
| # cd po && perl Make_osx.pl --outdir ../$(RESDIR) $(MULTILANG) |
| bundle-language {virtual}: bundle-dir |
| |
| $(APPDIR)/Contents: |
| :mkdir {r} $(APPDIR)/Contents/MacOS |
| :mkdir {r} $(RESDIR)/English.lproj |
| |
| |
| # vim: sts=4 sw=4 : |
