स्विचिंग .c / .h बफ़र्स

8

मैं आम तौर पर 2 खिड़कियों के साथ काम करता हूं, खड़ी विभाजन।

जिस समस्या को मैं हल करना चाहूंगा, वह है: आसानी से हेडर से आगे-पीछे कूदना <-> कार्यान्वयन फ़ाइल

मैं जाँच कर रहा हूँ, भाग्य के बिना, ऐसा करने के 2 तरीके:

वर्तमान विंडो में वैकल्पिक फ़ाइल खोलें : ऐसा करने के कई तरीके हैं, हालाँकि, मुझे कोई ऐसा तरीका नहीं मिल रहा है, जो मुझे याद हो जहाँ मैं पिछली फ़ाइल में था (यानी हेडर पर कूदता हूँ, वापस कूदता हूँ, लेकिन उसी स्थान पर नहीं था जहाँ मैं था )।
अन्य विंडो में वैकल्पिक फ़ाइल खोलें : यह अच्छी तरह से परिभाषित है, क्योंकि मैं केवल 2 खिड़कियों के साथ काम करता हूं, हालांकि मुझे ऐसा करने के लिए विम-ज्ञान की कमी है।

vim-windows

— Zach
स्रोत

1

1 अंक के संकेत के लिए, :h line()(जेनेरिक समाधान) का अंत देखें : "यह ऑटोकॉमैंड फाइल खोलने के ठीक बाद अंतिम ज्ञात स्थिति में जाता है, यदि" "चिह्न सेट है:: au BufReadPost" यदि लाइन (") \ "")> 1 && लाइन ("'\" ") <= लाइन (" $ ") | exe "normal! g` \" "| endif

— VanLaser

क्या आप जम्प लिस्ट और / या क्रॉस-फाइल मार्क्स का उपयोग नहीं कर सकते हैं?

— फ्रूगेलमोनकी

इसी तरह की पोस्ट: Vim में .h और .cpp फ़ाइलों को समान नाम से कैसे स्विच करें?

— पीटर रिंकेर

2

शायद आप A.vim

— क्रिश्चियन

5

पूरा करने में तीन मुख्य चरण हैं जो आप पूछ रहे हैं:

वैकल्पिक फ़ाइल का नाम प्राप्त करना
उस फ़ाइल को वर्तमान विंडो में या इच्छानुसार किसी अन्य विंडो में खोलना
उस फ़ाइल के भीतर कर्सर स्थिति को बहाल करना

वैकल्पिक फ़ाइल नाम खोजने के लिए आप "रूट" और "एक्सटेंशन" में वर्तमान फ़ाइल नाम को तोड़ना चाहते हैं। ऐसा करने का एक सरल तरीका है:

let parts = split(expand("%:p"), "[.]");
let root = parts[0]
let extension = parts[1]

यदि आप जानते हैं कि आप केवल कभी-कभी .hऔर .cppफ़ाइलों के बीच स्विच कर रहे हैं , तो आप एक्सटेंशन को एक से दूसरे में आसानी से बदल सकते हैं:

if extension == "h"
  let extension = "cpp"
else
  let extension = "h"
endif

वैकल्पिक रूप से, संभावित रूप से मान्य वैकल्पिक एक्सटेंशन के लिए एक शब्दकोश मैपिंग ज्ञात एक्सटेंशन बनाएं । या वर्तमान फ़ाइल के लिए सभी संभव विकल्प globpath()प्राप्त करने के लिए उपयोग करें :

let alternates = globpath(expand("%:h"), root . ".*")

और पहले वाले को चुनें, या जो भी हो। मैं globpathदृष्टिकोण पसंद करता हूं , कुछ अतिरिक्त स्मार्ट के साथ मैं बाद में वर्णन करूंगा। एक बार जब आप लक्ष्य एक्सटेंशन चुन लेते हैं, तो पूर्ण लक्ष्य पथ बनाएं:

let target = root . "." . alternates[whicheverAlternateExtensionYouWant]

अब आप वर्तमान विंडो में वैकल्पिक फ़ाइल खोल सकते हैं:

execute "edit " . target

या winnr()"अन्य विंडो" नंबर प्राप्त करने के लिए उपयोग करें ( winnr("#")वह विंडो जो <C-W>pकूद जाएगी, या आप इसे हार्ड-कोड कर सकते हैं यदि आप जानते हैं कि यह आपके सेटअप के लिए हमेशा एक ही रहेगा) और कुछ ऐसा करें:

let window = winnr("#")
execute window . "wincmd w"
execute "edit " . target

यह आपको वैकल्पिक फ़ाइलों को खोलने के लिए वास्तव में मूल समाधान देता है । उपरोक्त दृष्टिकोण के साथ कुछ कमियां हैं, क्योंकि मैंने इसे सीधा होने के लिए लिखा है और यह थोड़ा-सा बंद है। मैंने एक प्लगइन लिखा है जो वैकल्पिक रूप से फ़ाइल स्विचिंग करता है "जिस तरह से मैं चाहता था," (सभी उपलब्ध globpath()परिणामों के माध्यम से साइकिल चलाना )। यह ऊपर की सादगी के साथ कुछ समस्याओं को संबोधित करता है, यदि आप अधिक खोज करने में रुचि रखते हैं, तो आप इसके कार्यान्वयन की जांच कर सकते हैं।

अंत में, "कर्सर स्थिति बहाल करें" बिंदु। मैंने इसे अंतिम बार तब से सहेजा है जब यह वैकल्पिक स्विचिंग चीज़ के लिए ऑर्थोगोनल है (मेरा प्लगइन इसे उदाहरण के लिए नहीं संभालता है), लेकिन आप इसे अपने फ़ंक्शन में डाल सकते हैं यदि आप अपना रोल करने जा रहे हैं। :help line()एक ऑटोकॉमैंड होता है जो कर्सर की स्थिति को बहाल करने के लिए उपयोगी होता है जहां यह तब था जब फ़ाइल को अंतिम बार खोला गया था:

:au BufReadPost * if line("'\"") > 1 && line("'\"") <= line("$") | exe "normal! g`\"" | endif

मैं बस यही, या बहुत कुछ इसी तरह से, मेरे .vimrcव्यवहार में हर समय व्यवहार को पसंद करता हूं। आप आसानी से कोड को कहीं और रख सकते हैं।

2

आप अपनी फ़ाइल में निम्न कॉन्फ़िगरेशन के साथ vim-fswitch प्लगइन का उपयोग कर सकते हैं .vimrc:

au! BufEnter *.cpp,*.cc,*.c let b:fswitchdst = 'h,hpp'    | let b:fswitchlocs = 'reg:/src/include/,../include,./'
au! BufEnter *.h,*.hpp      let b:fswitchdst = 'cpp,cc,c' | let b:fswitchlocs = 'reg:/include/src/,../src,./'

nmap <silent> <Leader>s :FSHere<cr>

यदि आप टाइप <Leader>(जो \डिफ़ॉल्ट रूप से) के बाद sएक में .hppया .hफ़ाइल, अगर उससे मिलते-जुलते प्लगइन की जाँच करेगा .cpp, .ccया .cफ़ाइल मौजूद है:

वर्तमान फ़ाइल के पथ द्वारा प्रतिस्थापित includeकरकेsrc
srcवर्तमान फ़ाइल के ऊपर फ़ोल्डर में देख कर
वर्तमान फ़ाइल के फ़ोल्डर में देख कर

ऐसे और भी विकल्प हैं जिनका उपयोग करके आप अपनी परियोजना को बेहतर ढंग से प्रलेखन में फिट कर सकते हैं । यह आपको कुछ मिनट लगेगा लेकिन एक बार जब आप इसे सही कर लेंगे तो आपको इसे पसंद करना चाहिए। मुझे व्यक्तिगत रूप से यह बहुत लचीला और एक्स्टेंसिबल लगता है, साथ ही यह कई तरह की फाइलों (.m, .h, .inl आदि ...) के लिए भी काम करता है।

— XPac27
स्रोत

1

अपने में .vimrc

" =====[ Remap to change windows quickly ]=============================
:nnoremap <silent> <C-H> :wincmd h<CR>
:nnoremap <silent> <C-J> :wincmd j<CR>
:nnoremap <silent> <C-K> :wincmd k<CR>
:nnoremap <silent> <C-L> :wincmd l<CR>

यह आपको घर की पंक्ति से केवल Ctrl और VIM दिशा कुंजियों का उपयोग करके जल्दी से खिड़कियों के बीच स्थानांतरित करने की अनुमति देता है। इस awesomeness, क्या आपके पास किसी भी विंडो पर जाने का एक सामान्य तरीका है, जिसमें क्विकफ़िक्स विंडो भी शामिल है।

हेडर और स्रोत के बीच जल्दी से स्विच करने के लिए मैं vim-scripts/a.vimयहां पाया गया उपयोग करता हूं : https://github.com/vim-scripts/a.vim , :Aकमांड टॉगल का उपयोग करें ।

साइड नोट => यदि आप tmux का उपयोग करते हैं, तो आप vg या nvim विंडो और टर्मिनल टर्मिनल के बीच कूदने के लिए https://github.com/christoomey/vim-tmux-navigator का उपयोग कर सकते हैं ।

— user1135541
स्रोत

1

मैं सिर्फ अपना सुपर क्विक एंड डर्टी वर्जन शेयर करूंगा ...

मेरी मैपिंग सेट करें; alt-o एक ही विंडो में संबंधित फ़ाइल खोलता है, alt-shift-o एक विभाजन में खुलता है ...

nnoremap <A-o> :call EditRelatedFile()<CR>
nnoremap <A-O> :call SplitRelatedFile()<CR>

फिर मेरे पास एक फ़ंक्शन है जो संबंधित फ़ाइलों की सूची प्राप्त करता है। मेरा मतलब है कि इसे अंतिम के बजाय पहले डॉट पर फ़ाइल नाम को काट देना है लेकिन पाठक के लिए यह अभी भी एक अभ्यास है।

function! GetRelatedFileList()
    " This function may be overloaded in a site-specific vimrc.
    let l:thisPath = expand("%:p:r") . '.*'
    let l:files = glob(l:thisPath)

    return split(l:files, '[\r\n]\+')
endfunction

मेरा .vimrc सेटअप कभी-कभी प्रति ग्राहक विशेष होता है; कुछ के पास स्रोत है और अलग-अलग फ़ोल्डर पदानुक्रम में शामिल हैं, कुछ उन्हें एक साथ हैं। डिफ़ॉल्ट रूप से मुझे लगता है कि वे सभी पास हैं, लेकिन अगर मुझे शिकार करने की आवश्यकता है तो मैं इस तरह एक प्रतिस्थापन कार्य प्रदान करूंगा।

" Override the basic GetRelatedFileList coming from vimrc.
function! GetRelatedFileList()
    let l:thisDir = expand("%:p:h:t")
    if (l:thisDir ==? "src") || (l:thisDir ==? "include")
        let l:thisPath = expand("%:p:h:h")
        let l:searchPaths = l:thisPath.'/include,' . l:thisPath.'/src'
        let l:thisBase = expand("%:t:r") . '.*'
        let l:files = globpath(l:searchPaths, l:thisBase)
    else
        let l:thisPath = expand("%:p:r") . '.*'
        let l:files = glob(l:thisPath)
    endif

    return split(l:files, '[\r\n]\+')
endfunction

फिर मैं वर्तमान बफर की फ़ाइल को खोजने के लिए फ़ाइलों की उस सूची को देखता हूं और सूची में अगले एक पर जाता हूं। यह अक्सर एक .cpp / .h जोड़ी की तरह सरल नहीं होता है, अक्सर मेरे पास अन्य चीजें होती हैं जिन पर विचार करने की आवश्यकता होती है।

function! GetNextRelatedFile()
    let l:fileList = GetRelatedFileList()

    let l:thisFile = expand("%:p")
    let l:index = index(l:fileList, l:thisFile) + 1

    if l:index >= len(l:fileList)
        let l:index = 0
    endif

    return l:fileList[l:index]
endfunction

और फिर अंत में दो कार्य जो वर्तमान विंडो में खुलते हैं या एक विभाजन करते हैं ...

function! EditRelatedFile()
    let l:file = GetNextRelatedFile()
    execute "edit" l:file
endfunction

मेरा बंटवारा संस्करण हमेशा नीचे विभाजन में .cpp और .c फ़ाइलें डालता है, अन्यथा विभाजित डिफ़ॉल्ट (जो मेरे मामले में ऊपर है)।

function! SplitRelatedFile()
    let l:file = GetNextRelatedFile()
    let l:ext = fnamemodify(l:file, ":e")
    if (l:ext ==? "cpp") || (l:ext ==? "c")
        execute "below split" l:file
    else
        execute "split" l:file
    endif
endfunction

— पानी का छींटा-टॉम-बैंग
स्रोत