mirrors/neovim
1
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-09-28 05:58:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Removes 'proto' dir

Browse Source 
See #137 for the issue.

Every header in the proto directory was:

* Given include guards in the form

    #ifndef NEOVIM_FILENAME_H
    #define NEOVIM_FILENAME_H
        ...
    #endif /* NEOVIM_FILENAM_H */

* Renamed from *.pro -> *.h
* Moved from src/proto/ to src/

This would have caused conficts with some existing headers in src/;
rather than merge these conflicts now (which is a whole other can of
worms involving multiple and conditional inclusion), any header in src/
with a conflicting name was renamed from *.h -> *_defs.h (which may or
may not actually describe its purpose, the change is purely a
namespacing issue).

Once all of these changes were made a script was developed to determine
what #includes needed to be added to each source file to describe its
dependencies and allow it to compile; because the script is so short
and I'll just list it here:

    #! /bin/bash

    cd $(dirname $0)

    # Scrapes `make` output for provided error messages and outputs #includes
    # needed to resolve them.
    #   $1 : part of the clang error message between filename and identifier
    list_missing_includes() {
        for file_missing_pair in $(CC=clang make 2>&1 >/dev/null | sed -n "s/\/\(.*\.[hc]\).*$1.*'\(.*\)'.*/\1:\2/p"); do
            fields=(${file_missing_pair//:/ })
            source_file=${fields[0]}
            missing_func=${fields[1]}
            # Try to find the declaration of the missing function.
            echo $(basename $source_file) \
                \#include \"$(grep -r "\b$missing_func __ARGS" | sed -n "s/.*\/\(.*\)\:.*/\1/p")\"
        # Remove duplicates
        done | sort | uniq
    }

    echo "Finding missing function prototypes..."
    list_missing_includes "implicit declaration of function"
    echo "Finding missing identifier declarations..."
    list_missing_includes "use of undeclared identifier"

Each list of required headers was added by hand in the following format:

    #include "vim.h"
    #include "*_defs.h"
    #include "filename.h"
    /* All other includes in same module here, in alphabetical order. */
    /* All includes from other modules (e.g. "os/*.h") here in alphabetical
     * order. */
This commit is contained in:
scott-linder
2014-02-25 15:41:16 -05:00
committed by Thiago de Arruda
parent 82e0636e78
commit 0ef90c13b7
119 changed files with 4197 additions and 3181 deletions
Download Patch File Download Diff File Expand all files Collapse all files

179
src/regexp.h
View File

@@ -1,152 +1,27 @@
/* vi:set ts=8 sts=4 sw=4:
*
* NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE
*
* This is NOT the original regular expression code as written by Henry
* Spencer. This code has been modified specifically for use with Vim, and
* should not be used apart from compiling Vim. If you want a good regular
* expression library, get the original code.
*
* NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE
*/
#ifndef _REGEXP_H
#define _REGEXP_H
/*
* The number of sub-matches is limited to 10.
* The first one (index 0) is the whole match, referenced with "\0".
* The second one (index 1) is the first sub-match, referenced with "\1".
* This goes up to the tenth (index 9), referenced with "\9".
*/
#define NSUBEXP 10
/*
* In the NFA engine: how many braces are allowed.
* TODO(RE): Use dynamic memory allocation instead of static, like here
*/
#define NFA_MAX_BRACES 20
typedef struct regengine regengine_T;
/*
* Structure returned by vim_regcomp() to pass on to vim_regexec().
* This is the general structure. For the actual matcher, two specific
* structures are used. See code below.
*/
typedef struct regprog {
regengine_T *engine;
unsigned regflags;
} regprog_T;
/*
* Structure used by the back track matcher.
* These fields are only to be used in regexp.c!
* See regexp.c for an explanation.
*/
typedef struct {
/* These two members implement regprog_T */
regengine_T *engine;
unsigned regflags;
int regstart;
char_u reganch;
char_u *regmust;
int regmlen;
char_u reghasz;
char_u program[1]; /* actually longer.. */
} bt_regprog_T;
/*
* Structure representing a NFA state.
* A NFA state may have no outgoing edge, when it is a NFA_MATCH state.
*/
typedef struct nfa_state nfa_state_T;
struct nfa_state {
int c;
nfa_state_T *out;
nfa_state_T *out1;
int id;
int lastlist[2]; /* 0: normal, 1: recursive */
int val;
};
/*
* Structure used by the NFA matcher.
*/
typedef struct {
/* These two members implement regprog_T */
regengine_T *engine;
unsigned regflags;
nfa_state_T *start; /* points into state[] */
int reganch; /* pattern starts with ^ */
int regstart; /* char at start of pattern */
char_u *match_text; /* plain text to match with */
int has_zend; /* pattern contains \ze */
int has_backref; /* pattern contains \1 .. \9 */
int reghasz;
#ifdef DEBUG
char_u *pattern;
#endif
int nsubexp; /* number of () */
int nstate;
nfa_state_T state[1]; /* actually longer.. */
} nfa_regprog_T;
/*
* Structure to be used for single-line matching.
* Sub-match "no" starts at "startp[no]" and ends just before "endp[no]".
* When there is no match, the pointer is NULL.
*/
typedef struct {
regprog_T *regprog;
char_u *startp[NSUBEXP];
char_u *endp[NSUBEXP];
int rm_ic;
} regmatch_T;
/*
* Structure to be used for multi-line matching.
* Sub-match "no" starts in line "startpos[no].lnum" column "startpos[no].col"
* and ends in line "endpos[no].lnum" just before column "endpos[no].col".
* The line numbers are relative to the first line, thus startpos[0].lnum is
* always 0.
* When there is no match, the line number is -1.
*/
typedef struct {
regprog_T *regprog;
lpos_T startpos[NSUBEXP];
lpos_T endpos[NSUBEXP];
int rmm_ic;
colnr_T rmm_maxcol; /* when not zero: maximum column */
} regmmatch_T;
/*
* Structure used to store external references: "\z\(\)" to "\z\1".
* Use a reference count to avoid the need to copy this around. When it goes
* from 1 to zero the matches need to be freed.
*/
typedef struct {
short refcnt;
char_u *matches[NSUBEXP];
} reg_extmatch_T;
struct regengine {
regprog_T *(*regcomp)(char_u*, int);
void (*regfree)(regprog_T *);
int (*regexec)(regmatch_T*, char_u*, colnr_T);
#if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) \
|| defined(FIND_REPLACE_DIALOG) || defined(PROTO)
int (*regexec_nl)(regmatch_T*, char_u*, colnr_T);
#endif
long (*regexec_multi)(regmmatch_T*, win_T*, buf_T*, linenr_T, colnr_T,
proftime_T*);
#ifdef DEBUG
char_u *expr;
#endif
};
#endif /* _REGEXP_H */
#ifndef NEOVIM_REGEXP_H
#define NEOVIM_REGEXP_H
/* regexp.c */
int re_multiline __ARGS((regprog_T *prog));
int re_lookbehind __ARGS((regprog_T *prog));
char_u *skip_regexp __ARGS((char_u *startp, int dirc, int magic, char_u **newp));
int vim_regcomp_had_eol __ARGS((void));
void free_regexp_stuff __ARGS((void));
reg_extmatch_T *ref_extmatch __ARGS((reg_extmatch_T *em));
void unref_extmatch __ARGS((reg_extmatch_T *em));
char_u *regtilde __ARGS((char_u *source, int magic));
int vim_regsub __ARGS((regmatch_T *rmp, char_u *source, char_u *dest, int copy,
int magic,
int backslash));
int vim_regsub_multi __ARGS((regmmatch_T *rmp, linenr_T lnum, char_u *source,
char_u *dest, int copy, int magic,
int backslash));
char_u *reg_submatch __ARGS((int no));
regprog_T *vim_regcomp __ARGS((char_u *expr_arg, int re_flags));
void vim_regfree __ARGS((regprog_T *prog));
int vim_regexec __ARGS((regmatch_T *rmp, char_u *line, colnr_T col));
int vim_regexec_nl __ARGS((regmatch_T *rmp, char_u *line, colnr_T col));
long vim_regexec_multi __ARGS((regmmatch_T *rmp, win_T *win, buf_T *buf,
linenr_T lnum, colnr_T col,
proftime_T *tm));
/* vim: set ft=c : */
#endif /* NEOVIM_REGEXP_H */