सी ++, सीएससीओपी, सीटीएजी, और विम: इस

Question

से प्राप्त कक्षाओं को ढूंढना कुछ परतों के साथ बड़े कोड बेस में एक आधार से प्राप्त सभी कक्षाओं को खोजने के लिए कमांड लाइन से कमांड लाइन में है कक्षा? grep एक विकल्प है लेकिन धीमा हो सकता है क्योंकि grep अनुक्रमणिका नहीं है।

Answer 1

न तो cscope है और न ही ctags हमें सीधे विरासत से निपटने के लिए अनुमति देते हैं, लेकिन यह कि सीमा के आस-काम करने के लिए क्योंकि व्युत्पन्न वर्ग भी इंडेक्स किए गए अपेक्षाकृत आसान है।

cscope

cscope में, "सी प्रतीक" Foobar की तलाश में आम तौर पर मूल वर्ग और कक्षाओं यह से इनहेरिट सूचीबद्ध करता है। चूंकि खोज डेटाबेस के खिलाफ की जाती है, इसलिए यह बिजली तेज है।

वैकल्पिक रूप से, आप :.*Foobar की तरह एक पैटर्न के साथ cscope के egrep खोज क्षमताओं का उपयोग केवलFoobar से इनहेरिट कक्षाएं सूची सकता है।

तो, भले ही हमारे पास समर्पित नहीं है "इस वर्ग से उत्तराधिकारी वर्ग खोजें" कमांड, हम बिना किसी प्रयास किए काम पूरा कर सकते हैं।

ctags

ctags आप --fields=+i साथ विरासत जानकारी शामिल कर सकते है, कि जानकारी विम में सीधे इस्तेमाल नहीं किया जा सकता। inherits फ़ील्ड विम द्वारा पार्स किया गया है, हालांकि, taglist() का उपयोग करके त्वरित और गंदा समाधान बनाना संभव हो सकता है।

पावती, एजी

उन दो कार्यक्रमों और अधिक या कम ग्रेप तरह काम करते हैं, लेकिन वे स्रोत कोड में खोज की ओर लक्षित कर रहे हैं ताकि वे वास्तव में ग्रेप तुलना में तेजी से कर रहे हैं।

मेरी विम config में, :grep कर्सर के तहत वर्ग से प्राप्त की तरह लग रहे हैं वर्गों के लिए खोज, डिफ़ॉल्ट grep इसलिए की ag कार्यक्रम चलाने के लिए बजाय सेट है:

:grep :.*<C-r><C-w><CR> 

यहाँ प्रासंगिक लाइनें हैं मेरे ~/.vimrc से:

if executable("ag") 
    set grepprg=ag\ --nogroup\ --nocolor\ --ignore-case\ --column 
    set grepformat=%f:%l:%c:%m,%f:%l:%m 
endif 

Answer 2

lh-cpp में, मैं :Children कमांड को परिभाषित करता हूं। यह एक ctags डेटाबेस पर निर्भर करता है, और इसके परिणामस्वरूप, यह काफी सीमित है।

इसमें दो वैकल्पिक पैरामीटर लगते हैं: नामस्थान जहां से देखना है (मुझे इससे बचने का कोई तरीका नहीं मिला है), और मूल वर्ग ->:Children [!] {namespace} {parent-class} का नाम।

कमांड जितना संभव हो उतना जानकारी कैश करने की कोशिश करता है। इसलिए, जब ctags डेटाबेस में प्रासंगिक जानकारी बदलती है, तो कैश को अद्यतन किया जाना चाहिए। यह आदेश पीटने द्वारा किया जाता है ->:Children!

Answer 3

मुझे नहीं लगता कि विम सभी बच्चों की कक्षाओं को सूचीबद्ध करने का सही टूल है। इसके बजाए, हम स्रोत कोड के लिए दस्तावेज़ उत्पन्न करने के लिए बेहतर ढंग से डॉक्सिजन का उपयोग करेंगे।हालांकि डॉक्सिजन को कुछ समय की आवश्यकता है, हम सभी वर्गों के लिए दस्तावेज़/आरेखों का उपयोग कर सकते हैं, जो स्पष्ट और तेज़ है।

Answer 4

यदि आप उत्तराधिकारी जानकारी (see the --fields option) का उपयोग करके एक्स्ट्यूबरेंट सीटीएजी के साथ अपनी टैग फाइलें बनाते हैं, तो निम्न स्क्रिप्ट काम करेगी। यह :Inherits कमांड जोड़ता है जो या तो कक्षा का नाम लेता है (उदा। :Inherits Foo) या नियमित अभिव्यक्ति।

:tag कमांड की तरह, आप इंगित करते हैं कि आप इसे '\' चरित्र से पहले एक रेगेक्स के साथ खोज चाहते हैं, उदा। :Inherits \Foo.*।

परिणाम विंडो का स्थान सूची, में डाल दिया जाता है, जो आप के साथ ब्राउज़ :ll, :lne, :lp, आदि विम स्क्रिप्ट टैग सूची जो है मैं क्या पसंद करते हैं संशोधित करने के लिए अनुमति देने के लिए प्रतीत नहीं होता।

यदि आप सोच रहे हैं कि मैं taglist() का उपयोग क्यों नहीं करता, तो ऐसा इसलिए है क्योंकि taglist() बड़ी टैग फ़ाइलों पर अविश्वसनीय रूप से धीमा है। मूल पोस्ट में taglist() का उपयोग करके एक संस्करण था, यदि आप उत्सुक हैं तो आप संपादन इतिहास ब्राउज़ कर सकते हैं।

" Parse an Exuberant Ctags record using the same format as taglist() 
" 
" Throws CtagsParseErr if there is a general problem parsing the record 
function! ParseCtagsRec(record, tag_dir) 
    let tag = {} 

    " Parse the standard fields 
    let sep_pos = stridx(a:record, "\t") 
    if sep_pos < 1 
     throw 'CtagsParseErr' 
    endif 
    let tag['name'] = a:record[:sep_pos - 1] 
    let tail = a:record[sep_pos + 1:] 
    let sep_pos = stridx(tail, "\t") 
    if sep_pos < 1 
     throw 'CtagsParseErr' 
    endif 
    " '/' will work as a path separator on most OS's, but there 
    " should really be an OS independent way to build paths. 
    let tag['filename'] = a:tag_dir.'/'.tail[:sep_pos - 1] 
    let tail = tail[sep_pos + 1:] 
    let sep_pos = stridx(tail, ";\"\t") 
    if sep_pos < 1 
     throw 'CtagsParseErr' 
    endif 
    let tag['cmd'] = tail[:sep_pos - 1] 

    " Parse the Exuberant Ctags extension fields 
    let extensions = tail[sep_pos + 3:] 
    for extension in split(extensions, '\t') 
     let sep_pos = stridx(extension, ':') 
     if sep_pos < 1 
      if has_key(tag, 'kind') 
       throw 'CtagsParseErr' 
      endif 
      let tag['kind'] = extension 
     else 
      let tag[extension[:sep_pos - 1]] = extension[sep_pos + 1:] 
     endif 
    endfor 

    return tag 
endfunction 

" Find all classes derived from a given class, or a regex (preceded by a '/') 
" The results are placed in the current windows location list. 
function! Inherits(cls_or_regex) 
    if a:cls_or_regex[0] == '/' 
     let regex = a:cls_or_regex[1:] 
    else 
     let regex = '\<'.a:cls_or_regex.'\>$' 
    endif 
    let loc_list = [] 
    let tfiles = tagfiles() 
    let tag_count = 0 
    let found_count = 0 
    for file in tfiles 
     let tag_dir = fnamemodify(file, ':p:h') 
     try 
      for line in readfile(file) 
       let tag_count += 1 
       if tag_count % 10000 == 0 
        echo tag_count 'tags scanned,' found_count 'matching classes found. Still searching...' 
        redraw 
       endif 
       if line[0] == '!' 
        continue 
       endif 

       let tag = ParseCtagsRec(line, tag_dir) 

       if has_key(tag, 'inherits') 
        let baselist = split(tag['inherits'], ',\s*') 
        for base in baselist 
         if match(base, regex) != -1 
          let location = {} 
          let location['filename'] = tag['filename'] 

          let cmd = tag['cmd'] 
          if cmd[0] == '/' || cmd[0] == '?' 
           let location['pattern'] = cmd[1:-2] 
          else 
           let location['lnum'] = str2nr(cmd) 
          endif 

          call add(loc_list, location) 
          let found_count += 1 
         endif 
        endfor 
       endif 
      endfor 
     catch /^OptionErr$/ 
      echo 'Parsing error: Failed to parse an option.' 
      return 
     catch /^CtagsParseErr$/ 
      echo 'Parsing error: Tags files does not appear to be an Exuberant Ctags file.' 
      return 
     catch 
      echo 'Could not read tag file:' file 
      return 
     endtry 
    endfor 
    call setloclist(0, loc_list) 
    echo tag_count 'tags scanned,' found_count 'matching classes found.' 
endfunction 

command! -nargs=1 -complete=tag Inherits call Inherits('<args>')