vahagn/scripts
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Using cf5-compile from github.com/vishap/cf5-compile

Browse Source
This commit is contained in:
Vahagn Khachatryan
2017-02-05 12:36:43 +00:00
parent 40af9cf335
commit 4aeb996064
3 changed files with 51 additions and 585 deletions
Download Patch File Download Diff File Expand all files Collapse all files

312
vim/plugin/cf5-compile.vim
View File

@@ -1,312 +0,0 @@
" Copyright (c) 2014 Vahagn Khachatryan
"
" Permission is hereby granted, free of charge, to any person obtaining a copy
" of this software and associated documentation files (the "Software"), to deal
" in the Software without restriction, including without limitation the rights
" to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
" copies of the Software, and to permit persons to whom the Software is
" furnished to do so, subject to the following conditions:
"
" The above copyright notice and this permission notice shall be included in
" all copies or substantial portions of the Software.
"
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
" IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
" FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
" AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
" LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
" OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
" THE SOFTWARE.
"
" Name: cf5-compile.vim
" Version: 1.0.1
" Authors: Vahagn Khachatryan <vahagn DOT khachatryan AT gmail DOT com>
"
" Licence: http://www.opensource.org/licenses/mit-license.php
" The MIT License
"
" Summary: Vim plugin to compile the edited files and run it.
"
" Description:
" Functions to compile/link and run a single c/cpp/java/..etc
" file based programs. It's irreplaceable for small tests or
" experiments.
"
" How To Use
" --------------
" Put this file into vim plugin directory. For linux users should
" be $HOME/.vim/plugin.
" In your .vimrc file add
"
" map <silent> <C-F5> :call CF5Compile(1)<CR>
" map <silent> <F5> :call CF5Compile(0)<CR>
"
" This will allow Ctrl-F5 to "compile and run" and F5 to only
" "compile" the file. Please, note that "filetype" is used to
" define the compiler/interpreter used.
"
" The value of the following variables are used while compiling
" a file:
" g:argv - command line arguments to pass to program.
" g:pyflags - flags to pass to python interpreter.
" g:cppflags - flags to pass to c++ compiler.
" g:wcppflags - flags to pass to (windows) compiler.
" g:lcppflags - flags to pass to (linux) compiler.
" g:ldflags - flags to pass to linker.
" g:ldlibpath - paths to add to PATH or LD_LIBRARY_PATH.
"
" I personally use this script with let-modeline.vim. The last
" allows to define some of compiler options right in the file. For
" example I have the following header in some of my cpp files:
" /*
" VIM: let g:lcppflags="-std=c++11 -O2 -pthread"
" VIM: let g:wcppflags="/O2 /EHsc /DWIN32"
" VIM: let g:cppflags=g:Iboost.g:Itbb
" VIM: let g:ldflags=g:Lboost.g:Ltbb.g:tbbmalloc.g:tbbmproxy
" VIM: let g:ldlibpath=g:Bboost.g:Btbb
" VIM: let g:argv=""
" */
"
" You might also consider using independence.vim or localvimrc.vim
" in order to configure the plugin for a particular directory.
"
" Enjoy.
"
if exists('g:loaded_cf5_compiler')
finish
endif
let g:loaded_cf5_compiler = 1
"
" Init global variables with default values.
"
let g:argv=""
let g:flags=""
let g:pyflags=""
let g:cppflags=""
let g:wcppflags="/O2 /EHsc /DWIN32"
let g:lcppflags="-O2"
let g:ldflags=""
let g:wldflags=""
let g:ldlibpath=""
"
" This is an experimental option.
" =0 - no output window opened.
" =1 - output window opened.
"
let g:cf5output=0
"
" Microsoft Visual C++
"
function! s:CompileMSVC(run) "{{{2
let exename=expand("%:p:r:s,$,.exe,")
let srcname=expand("%")
" compile it
let ccline="cl ".g:cppflags." ".g:wcppflags." ".srcname." /Fe".exename." /link ".g:ldflags. " ".g:wldflags
echo ccline
let cout = system( ccline )
if v:shell_error
echo cout
return
endif
echo cout
" run it
if a:run==1
let en = "set PATH=\"".g:ldlibpath."%PATH%\""
let cmdline=exename." ".g:argv
let cont = [ en, cmdline ]
let tf = tempname()
let tf = fnamemodify( tf, ":p:r")
let tf = tf.".bat"
call writefile( cont, tf )
let eout = system( tf )
echo eout
call delete( tf )
endif
endfunction
"
" GCC
"
function! s:CompileGCC(run) "{{{2
let exename=expand("%:p:r:s,$,.exe,")
let srcname=expand("%")
" compile it
let ccline="g++ ".g:cppflags." ".g:lcppflags." ".g:ldflags." ".srcname." -o".exename
call s:appendOutput(ccline)
let cout = system( ccline )
if v:shell_error
call s:appendOutput(cout)
return
endif
call s:appendOutput(cout)
" run it
if a:run == 1
let $LD_LIBRARY_PATH="LD_LIBRARY_PATH=".g:ldlibpath.":".$LD_LIBRARY_PATH
let cmdline=exename." ".g:argv
call s:appendOutput(cmdline)
let eout = system( cmdline )
call s:appendOutput(eout)
endif
endfunction
function! s:CompileJava(run) "{{{2
" compile it
let cmd = "javac " . g:javaflags . " " . expand("%")
echo cmd
let cout = system( cmd )
echo cout
if v:shell_error
return
endif
" run it
"let classpath=expand("%:p:r")
let exename=expand("%:r")
let cmd = "java " . exename . " " . g:argv
echo cmd
let eout = system( cmd )
echo eout
endfunction
function! s:InterpretPython(run)
" Interpret it
let cmd = "python " . g:pyflags . " " . expand("%") . ' ' . g:argv
echo cmd
let cout = system( cmd )
echo cout
if v:shell_error
return
endif
endfunction
function! s:InterpretMatlab(run)
" Interpret it
let cmd = "octave " . g:flags . " " . expand("%") . ' ' . g:argv
echo cmd
let cout = system( cmd )
echo cout
if v:shell_error
return
endif
endfunction
function! s:Compile(run)
if &filetype=="c" || &filetype=="cpp"
if has("win32") || has("win64")
call s:CompileMSVC(a:run)
else
call s:CompileGCC(a:run)
endif
endif
if &filetype=="python"
call s:InterpretPython(a:run)
endif
if &filetype=="java"
call s:CompileJava(a:run)
endif
if &filetype=="matlab"
call s:InterpretMatlab(a:run)
endif
endfunction
"
" Output Window {{{1
"
" Create output window. {{{2
"
function! s:getOutputWindow()
if !exists("w:outputwin")
let w:outputwin=tempname().'_output'
endif
let obuff = w:outputwin
let winnr = bufwinnr('^'.obuff.'$')
if (winnr < 0)
execute "below 10new ".obuff
setlocal buftype=nofile bufhidden=wipe nobuflisted noswapfile nowrap
" setlocal nomodifiable
let winnr = bufwinnr('^'.obuff.'$')
endif
return winnr
endfunction
"
" Append text to output window. {{{2
"
function! s:appendOutput( text )
if exists("g:cf5output") && (g:cf5output==1)
let cwinnr = winnr()
let owinnr = s:getOutputWindow()
" setlocal modifiable
execute owinnr . 'wincmd w'
execute 'normal! Go'.a:text
" setlocal nomodifiable
execute cwinnr.'wincmd w'
else
echo a:text
endif
endfunction
"
" Clear text from output window. {{{2
"
function! s:clearOutputWindow()
if exists("g:cf5output") && (g:cf5output==1)
let cwinnr = winnr()
let owinnr = s:getOutputWindow()
" setlocal modifiable
execute owinnr . 'wincmd w'
execute 'normal ggdG'
" setlocal nomodifiable
execute cwinnr . 'wincmd w'
endif
endfunction
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
" Public interface.
""
"
" Load compile instructions and call window or linux compiler. {{{1
"
function! CF5Compile(run)
"
" Interpreters and compilers don't work with buffers, but ratter they run
" on files. So, make sure that the file is updated.
"
if &modified == 1
echo "The buffer is not saved. First save it."
return
endif
"
" Set source specific compiler options.
" let-modeline.vim should be loaded for FirstModeLine.
"
if exists('*FirstModeLine')
call FirstModeLine()
endif
"
" Clear output window
"
call s:clearOutputWindow()
"
" Compile.
"
call s:Compile(a:run)
endfunction
"
" Load compile instructions and call window or linux compiler.
"
function! CF5CompileAndRun()
call CF5Compile(1)
endfunction
"
" Load compile instructions and call window or linux compiler.
"
function! CF5CompileOnly()
call CF5Compile(0)
endfunction

234
vim/plugin/let-modeline.vim
View File

@@ -1,234 +0,0 @@
" example -> VIM: let b:toto="foo" g:tata=4 g:egal="t=y".&tw
" ===========================================================================
" File: let-modeline.vim {{{1
" Author: Luc Hermitte <EMAIL:hermitte {at} free {dot} fr>
" <URL:http://hermitte.free.fr/vim/>
" URL: http://hermitte.free.fr/vim/ressources/dollar_VIM/plugin/let-modeline.vim
" Version: 1.6
" Last Update: 23rd Mar 2004
"
" Purpose: {{{2
" Defines the function : FirstModeLine() that extends the VIM modeline
" feature to variables. In VIM, it is possible to set options in the
" first and last lines. -> :h modeline
" The function proposed extends it to 'let {var}={val}' affectations.
"
" Exemples Of Useful Aplications: {{{2
" Typical Example: {{{3
" When editing a LaTeX document composed of several files, it is very
" practical to know the name of the main file whichever file is edited --
" TKlatex does this thanks the global variable g:TeXfile. Hence it knows
" that latex should be called on this main file ; aux2tags.vim could also
" be told to compute the associated .aux file.
" Anyway. Defining (through menus or a let command) g:TeXfile each time is
" really boring. It bored me so much that I programmed a first version of
" this script. In every file of one of my projects I added the line :
" % VIM: let g:TeXfile=main.tex
" [main.tex is the name of the main file of the project]
" Thus, I can very simply call LaTeX from within VIM without having to
" wonder which file is the main one nor having to specify g:TeXfile each
" time.
"
" Using Callback Functions: {{{3
" Actually, in order to affect g:TeXfile, I have to call another function.
" Hence, I define a callback function (in my (La)TeX ftplugin) that checks
" whether I want to set g:TeXfile. In that case, the callback function
" calls the right function and return true. Otherwise, it returns false.
" You will find the code of this precise callback function as an example at
" the end of this file.
"
" Tune C Compilations: {{{3
" An easy way to tune the parameters of the compilation of simple programs
" without having to maintain a makefile:
" // VIM: let $CPPFLAGS='-I../../libs':
"
" ---------------------------------------------------------------------------
" Format: {{{2
" On the _first_ line of any file, the extended modeline format is:
" {line} ::= [text]{white}VIM:[white]let{affectations}
" {affectations} ::= {sgl_affect.}
" {affectations} ::= {sgl_affect.}{white}{affectations}
" {sgl_affect.} ::= {variable}[white]=[white]{value}
" {variable} ::= cf. vim variable format ; beware simple
" variables (other than global-, buffer-,
" or window-variables) are not exported.
" Can also be an environment variable -> $VAR.
" {value} ::= string or numeral value : no function
" call allowed.
"
" Options: {{2
" (*) 'modeline' : vim-option that must be set to 1
" (*) 'modelines': vim-option corrsponding to the number of lines
" searched.
" (*) b:ModeLine_CallBack(var,val) : callback function
" Enable to define callback functions when needed. cf. lhlatex.vim
"
" Installation: {{{2
" (*) Drop the file into your $$/plugin/ or $$/macros/ folder.
" (*) Source it from your .vimrc and add the autocommand:
" " Loads FirstModeLine()
" if !exists('*FirstModeLine')
" " :Runtime emules :runtime with VIM 5.x
" Runtime plugin/let-modeline.vim
" endif
" if exists('*FirstModeLine')
" aug ALL
" au!
" " To not interfer with Templates loaders
" au BufNewFile * :let b:this_is_new_buffer=1
" " Modeline interpretation
" au BufEnter * :call FirstModeLine()
" aug END
" endif
"
"
" Remarks: {{{2
" (*) The only way to call a function is through the callback feature.
" Affectation like 'let g:foo="abc".DEF()' are recognized and
" forbiden.
" (*) The modeline is recognized thanks to "VIM" in that *must* be in
" uppercase letters
"
" Changes: {{{2
" v1.6: Support for environment variables.
" vim 6.x only
" Doesn't check into folded lines anymore
" v1.5: Check that the format of the variables and values is correct
" before it tries to set the variables -> no more error messages
" when using 2html.vim.
" v1.4: With Vim 6.x, it doesn't mess anymore with the search history
" v1.3: Parse several lines according to &modelines and &modeline
" v1.2: no-reinclusion mecanism
" v1.1b: extend variable names to accept underscores
"
" Todo: {{{2
" (*) Enforce the patterns and the resulting errors
" (*) Permit to have comments ending characters at the end of the line.
" (*) Simplify the regexps
"
" }}}1
" ===========================================================================
" Definitions: {{{1
if exists("g:loaded_let_modeline") | finish | endif
let g:loaded_let_modeline = 1
" Internal function dedicated to the recognition of function calls {{{2
function! s:FoundFunctionCall(value_str)
let str = substitute(a:value_str, '"[^"]*"', '', 'g')
let str = substitute(str, "'[^']*'", '', 'g')
return match(str, '(.*)') != -1
endfunction
" Internal function dedicated to the parsing of a line {{{2
function! FML_parse_line(mtch)
" call confirm('Find:'.a:mtch, '&ok', 1)
if a:mtch !=""
let mtch = a:mtch
let re_var = '\s\+\([[:alnum:]:_$]\+\)'
" beware the comments ending characters
let re_val = '\(\%(' . "'[^']*'" . '\|"[^"]*"\|[-a-zA-Z0-9:_.&$]\)\+\)$'
let re_other = '^\(.\{-}\)'
let re_sub = re_other . re_var . '\s*=\s*' . re_val
while strlen(mtch) != 0
let vari = substitute( mtch, re_sub, '\2', '' )
let valu = substitute( mtch, re_sub, '\3', '' )
" call confirm('regex: '.re_sub."\nmtch: <<".mtch.">>\nvar: ".vari."\nval: ".valu, '&ok', 1)
if (vari !~ '^[[:alnum:]:_$]\+$') || (valu !~ re_val)
return
endif
" Check : no function !
if s:FoundFunctionCall(valu)
echohl ErrorMsg
echo "Find a function call in the affectation : let " . vari . " = " . valu
echohl None
return
endif
let mtch = substitute( mtch, re_sub, '\1', '' )
""echo vari . " = " . valu . " --- " . mtch . "\n"
" call confirm('vari: '.vari.' = '.valu." --- " . mtch, '&Ok', 1)
if exists("b:ModeLine_CallBack")
exe 'let res = '. b:ModeLine_CallBack . '("'.vari.'","'.valu.'")'
if res == 1 | return | endif
endif
" Else
execute "let " . vari . " = " . valu
endwhile
endif
endfunction
" Internal function dedicated searching the matching lines {{{2
function! s:Do_it_on_range(first, last)
" let modeline_pat = '[vV][iI][mM]\d*:\s*let\s*\zs.*$'
let modeline_pat = '[vV][iI][mM]\d*:\s*let\zs.*$'
if &verbose >= 2 " {{{
echo "\n->"a:first.','.a:last. 'g/'.modeline_pat.
\ '/:call FML_parse_line(matchstr(getline("."),"'.
\ escape(modeline_pat, '\\') .'"))'
endif " }}}
let s:save_fold_enable= &foldenable
set nofoldenable
if exists(':try')
try
silent execute a:first.','.a:last. 'g/'.modeline_pat.
\ '/:call FML_parse_line(matchstr(getline("."),"'.
\ escape(modeline_pat, '\\') .'"))'
" Purge the history for the search pattern just used.
call histdel('search', -1)
finally
let &foldenable = s:save_fold_enable
endtry
else " Older versions of Vim
silent execute a:first.','.a:last. 'g/'.modeline_pat.
\ '/:call FML_parse_line(matchstr(getline("."),"'.
\ escape(modeline_pat, '\\') .'"))'
" Purge the history for the search pattern just used.
call histdel('search', -1)
let &foldenable = s:save_fold_enable
endif
endfunction
" The main function {{{2
function! FirstModeLine()
if !&modeline | return | endif
let pos = line('.') . 'normal! ' . virtcol('.') . '|'
let e1 = 1+&modelines-1
let b2 = line('$') - &modelines+1
" call confirm('e1='.e1."\nb2=".b2, '&ok', 1)
if e1 >= b2
call s:Do_it_on_range(1, line('$'))
else
call s:Do_it_on_range(1, e1)
call s:Do_it_on_range(b2, line('$'))
endif
if !exists('b:this_is_new_buffer')
exe pos
else
unlet b:this_is_new_buffer
endif
" call confirm('fini!', '&ok', 1)
endfunction
" }}}2
" }}}1
" ===========================================================================
" Example of a callback function {{{1
" Version I use in my (La)TeX ftplugin
if 0
let b:ModeLine_CallBack = "TeXModeLine_CallBack"
function! TeXModeLine_CallBack(var,val)
if match(a:var, "g:TeXfile") != -1
" restore quotes around the file name
"let valu = substitute( valu, '^"\=\([[:alnum:].]\+\)"\=$', '"\1"', '' )
call TKSetTeXfileName( 2, a:val )
return 1
else
return 0
endif
endfunction
endif
" }}}1
" ===========================================================================
" vim600: set fdm=marker: