synctex_parser_utils.h File Reference

#include <stdlib.h>

Include dependency graph for synctex_parser_utils.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	synctex_bool_t   int
#define	synctex_YES   -1
#define	synctex_ADD_QUOTES   -1
#define	synctex_COMPRESS   -1
#define	synctex_NO   0
#define	synctex_DONT_ADD_QUOTES   0
#define	synctex_DONT_COMPRESS   0
#define	SYNCTEX_CASE_SENSITIVE_PATH   1
#define	SYNCTEX_IS_PATH_SEPARATOR(c)   ('/' == c)
#define	SYNCTEX_IS_DOT(c)   ('.' == c)
#define	SYNCTEX_ARE_PATH_CHARACTERS_EQUAL(left, right)   (left != right)

Typedefs
typedef unsigned int	synctex_io_mode_t

Enumerations
enum	synctex_io_mode_masks_t { synctex_io_append_mask = 1, synctex_io_gz_mask = synctex_io_append_mask<<1 }
enum	synctex_compress_mode_t { synctex_compress_mode_none = 0, synctex_compress_mode_gz = 1 }

Functions
void *	_synctex_malloc (size_t size)
int	_synctex_error (const char *reason,...)
void	_synctex_strip_last_path_extension (char *string)
synctex_bool_t	_synctex_is_equivalent_file_name (const char *lhs, const char *rhs)
synctex_bool_t	_synctex_path_is_absolute (const char *name)
const char *	_synctex_last_path_component (const char *name)
const char *	_synctex_base_name (const char *path)
int	_synctex_copy_with_quoting_last_path_component (const char *src, char **dest_ref, size_t size)
int	_synctex_get_name (const char *output, const char *build_directory, char **synctex_name_ref, synctex_io_mode_t *io_mode_ref)
const char *	_synctex_get_io_mode_name (synctex_io_mode_t io_mode)
synctex_bool_t	synctex_ignore_leading_dot_slash_in_path (const char **name)

Variables
const char *	synctex_suffix
const char *	synctex_suffix_gz

Macro Definition Documentation

#define synctex_ADD_QUOTES   -1

Definition at line 49 of file synctex_parser_utils.h.

#define SYNCTEX_ARE_PATH_CHARACTERS_EQUAL	(		left,
			right
	)		(left != right)

Definition at line 79 of file synctex_parser_utils.h.

#define synctex_bool_t   int

Definition at line 47 of file synctex_parser_utils.h.

#define SYNCTEX_CASE_SENSITIVE_PATH   1

Definition at line 68 of file synctex_parser_utils.h.

#define synctex_COMPRESS   -1

Definition at line 50 of file synctex_parser_utils.h.

#define synctex_DONT_ADD_QUOTES   0

Definition at line 52 of file synctex_parser_utils.h.

#define synctex_DONT_COMPRESS   0

Definition at line 53 of file synctex_parser_utils.h.

#define SYNCTEX_IS_DOT

(

c)

('.' == c)

Definition at line 75 of file synctex_parser_utils.h.

#define SYNCTEX_IS_PATH_SEPARATOR

(

c)

('/' == c)

Definition at line 69 of file synctex_parser_utils.h.

#define synctex_NO   0

Definition at line 51 of file synctex_parser_utils.h.

#define synctex_YES   -1

Definition at line 48 of file synctex_parser_utils.h.

Typedef Documentation

typedef unsigned int synctex_io_mode_t

Definition at line 129 of file synctex_parser_utils.h.

Enumeration Type Documentation

enum synctex_compress_mode_t

Enumerator
synctex_compress_mode_none
synctex_compress_mode_gz

Definition at line 136 of file synctex_parser_utils.h.

             {
    synctex_compress_mode_none = 0,
    synctex_compress_mode_gz = 1
} synctex_compress_mode_t;

enum synctex_io_mode_masks_t

Enumerator
synctex_io_append_mask
synctex_io_gz_mask

Definition at line 131 of file synctex_parser_utils.h.

             {
    synctex_io_append_mask = 1,
    synctex_io_gz_mask = synctex_io_append_mask<<1
} synctex_io_mode_masks_t;

Function Documentation

const char* _synctex_base_name

(

const char *

path)

Definition at line 166 of file synctex_parser_utils.c.

                                                  {
    const char * ptr = path;
    do {
        if (synctex_ignore_leading_dot_slash_in_path(&ptr)) {
            return ptr;
        }
        do {
            if (!*(++ptr)) {
                return path;
            }
        } while (!SYNCTEX_IS_PATH_SEPARATOR(*ptr));
    } while (*(++ptr));
    return path;
}

Here is the caller graph for this function:

int _synctex_copy_with_quoting_last_path_component	(	const char *	src,
		char **	dest_ref,
		size_t	size
	)

Definition at line 241 of file synctex_parser_utils.c.

                                                                                                    {
  const char * lpc;
  if(src && dest_ref) {
#       define dest (*dest_ref)
        dest = NULL;    /*  Default behavior: no change and sucess. */
        lpc = _synctex_last_path_component(src);
        if(strlen(lpc)) {
            if(strchr(lpc,' ') && lpc[0]!='"' && lpc[strlen(lpc)-1]!='"') {
                /*  We are in the situation where adding the quotes is allowed. */
                /*  Time to add the quotes. */
                /*  Consistency test: we must have dest+size>dest+strlen(dest)+2
                 *  or equivalently: strlen(dest)+2<size (see below) */
                if(strlen(src)<size) {
                    if((dest = (char *)malloc(size+2))) {
                        char * dpc = dest + (lpc-src);  /*  dpc is the last path component of dest. */
                        if(dest != strncpy(dest,src,size)) {
                            _synctex_error("!  _synctex_copy_with_quoting_last_path_component: Copy problem");
                            free(dest);
                            dest = NULL;/*  Don't forget to reinitialize. */
                            return -2;
                        }
                        memmove(dpc+1,dpc,strlen(dpc)+1);   /*  Also move the null terminating character. */
                        dpc[0]='"';
                        dpc[strlen(dpc)+1]='\0';/*  Consistency test */
                        dpc[strlen(dpc)]='"';
                        return 0;   /*  Success. */
                    }
                    return -1;  /*  Memory allocation error.    */
                }
                _synctex_error("!  _synctex_copy_with_quoting_last_path_component: Internal inconsistency");
                return -3;
            }
            return 0;   /*  Success. */
        }
        return 0;   /*  No last path component. */
#       undef dest
    }
    return 1; /*  Bad parameter, this value is subject to changes. */
}

Here is the caller graph for this function:

int _synctex_error	(	const char *	reason,
			...
	)

Definition at line 81 of file synctex_parser_utils.c.

                                            {
    va_list arg;
    int result;
    va_start (arg, reason);
#   ifdef SYNCTEX_RECENT_WINDOWS
    {/* This code is contributed by William Blum.
        As it does not work on some older computers,
        the _WIN32 conditional here is replaced with a SYNCTEX_RECENT_WINDOWS one.
        According to http://msdn.microsoft.com/en-us/library/aa363362(VS.85).aspx
        Minimum supported client    Windows 2000 Professional
        Minimum supported server    Windows 2000 Server
        People running Windows 2K standard edition will not have OutputDebugStringA.
        JL.*/
        char *buff;
        size_t len;
        OutputDebugStringA("SyncTeX ERROR: ");
        len = _vscprintf(reason, arg) + 1;
        buff = (char*)malloc( len * sizeof(char) );
        result = vsprintf(buff, reason, arg) +strlen("SyncTeX ERROR: ");
        OutputDebugStringA(buff);
        OutputDebugStringA("\n");
        free(buff);
    }
#   else
    result = fprintf(stderr,"SyncTeX ERROR: ");
    result += vfprintf(stderr, reason, arg);
    result += fprintf(stderr,"\n");
#   endif
    va_end (arg);
    return result;
}

Here is the caller graph for this function:

const char* _synctex_get_io_mode_name

(

synctex_io_mode_t

io_mode)

Definition at line 497 of file synctex_parser_utils.c.

                                                                  {
    static const char * synctex_io_modes[4] = {"r","rb","a","ab"}; 
    unsigned index = ((io_mode & synctex_io_gz_mask)?1:0) + ((io_mode & synctex_io_append_mask)?2:0);// bug pointed out by Jose Alliste
    return synctex_io_modes[index];
}

Here is the caller graph for this function:

int _synctex_get_name	(	const char *	output,
		const char *	build_directory,
		char **	synctex_name_ref,
		synctex_io_mode_t *	io_mode_ref
	)

Definition at line 334 of file synctex_parser_utils.c.

{
    if(output && synctex_name_ref && io_mode_ref) {
        /*  If output is already absolute, we just have to manage the quotes and the compress mode */
        size_t size = 0;
        char * synctex_name = NULL;
        synctex_io_mode_t io_mode = *io_mode_ref;
        const char * base_name = _synctex_last_path_component(output); /*  do not free, output is the owner. base name of output*/
        /*  Do we have a real base name ? */
        if(strlen(base_name)>0) {
            /*  Yes, we do. */
            const char * temp = NULL;
            char * core_name = NULL; /*  base name of output without path extension. */
            char * dir_name = NULL; /*  dir name of output */
            char * quoted_core_name = NULL;
            char * basic_name = NULL;
            char * gz_name = NULL;
            char * quoted_name = NULL;
            char * quoted_gz_name = NULL;
            char * build_name = NULL;
            char * build_gz_name = NULL;
            char * build_quoted_name = NULL;
            char * build_quoted_gz_name = NULL;
            struct stat buf;
            time_t the_time = 0;
            /*  Create core_name: let temp point to the dot before the path extension of base_name;
             *  We start form the \0 terminating character and scan the string upward until we find a dot.
             *  The leading dot is not accepted. */
            if((temp = strrchr(base_name,'.')) && (size = temp - base_name)>0) {
                /*  There is a dot and it is not at the leading position    */
                if(NULL == (core_name = (char *)malloc(size+1))) {
                    _synctex_error("!  _synctex_get_name: Memory problem 1");
                    return -1;
                }
                if(core_name != strncpy(core_name,base_name,size)) {
                    _synctex_error("!  _synctex_get_name: Copy problem 1");
                    free(core_name);
                    dir_name = NULL;
                    return -2;
                }
                core_name[size] = '\0';
            } else {
                /*  There is no path extension,
                 *  Just make a copy of base_name */
                core_name = _synctex_merge_strings(base_name);
            }
            /*  core_name is properly set up, owned by "self". */
            /*  creating dir_name. */
            size = strlen(output)-strlen(base_name);
            if(size>0) {
                /*  output contains more than one path component */
                if(NULL == (dir_name = (char *)malloc(size+1))) {
                    _synctex_error("!  _synctex_get_name: Memory problem");
                    free(core_name);
                    dir_name = NULL;
                    return -1;
                }
                if(dir_name != strncpy(dir_name,output,size)) {
                    _synctex_error("!  _synctex_get_name: Copy problem");
                    free(dir_name);
                    dir_name = NULL;
                    free(core_name);
                    dir_name = NULL;
                    return -2;
                }
                dir_name[size] = '\0';
            }
            /*  dir_name is properly set up. It ends with a path separator, if non void. */
            /*  creating quoted_core_name. */
            if(strchr(core_name,' ')) {
                quoted_core_name = _synctex_merge_strings("\"",core_name,"\"");
            }
            /*  quoted_core_name is properly set up. */
            if(dir_name &&strlen(dir_name)>0) {
                basic_name = _synctex_merge_strings(dir_name,core_name,synctex_suffix,NULL);
                if(quoted_core_name && strlen(quoted_core_name)>0) {
                    quoted_name = _synctex_merge_strings(dir_name,quoted_core_name,synctex_suffix,NULL);
                }
            } else {
                basic_name = _synctex_merge_strings(core_name,synctex_suffix,NULL);
                if(quoted_core_name && strlen(quoted_core_name)>0) {
                    quoted_name = _synctex_merge_strings(quoted_core_name,synctex_suffix,NULL);
                }
            }
            if(!_synctex_path_is_absolute(output) && build_directory && (size = strlen(build_directory))) {
                temp = build_directory + size - 1;
                if(_synctex_path_is_absolute(temp)) {
                    build_name = _synctex_merge_strings(build_directory,basic_name,NULL);
                    if(quoted_core_name && strlen(quoted_core_name)>0) {
                        build_quoted_name = _synctex_merge_strings(build_directory,quoted_name,NULL);
                    }
                } else {
                    build_name = _synctex_merge_strings(build_directory,"/",basic_name,NULL);
                    if(quoted_core_name && strlen(quoted_core_name)>0) {
                        build_quoted_name = _synctex_merge_strings(build_directory,"/",quoted_name,NULL);
                    }
                }
            }
            if(basic_name) {
                gz_name = _synctex_merge_strings(basic_name,synctex_suffix_gz,NULL);
            }
            if(quoted_name) {
                quoted_gz_name = _synctex_merge_strings(quoted_name,synctex_suffix_gz,NULL);
            }
            if(build_name) {
                build_gz_name = _synctex_merge_strings(build_name,synctex_suffix_gz,NULL);
            }
            if(build_quoted_name) {
                build_quoted_gz_name = _synctex_merge_strings(build_quoted_name,synctex_suffix_gz,NULL);
            }
            /*  All the others names are properly set up... */
            /*  retain the most recently modified file */
#           define TEST(FILENAME,COMPRESS_MODE) \
            if(FILENAME) {\
                if (stat(FILENAME, &buf)) { \
                    free(FILENAME);\
                    FILENAME = NULL;\
                } else if (buf.st_mtime>the_time) { \
                    the_time=buf.st_mtime; \
                    synctex_name = FILENAME; \
                    if (COMPRESS_MODE) { \
                        io_mode |= synctex_io_gz_mask; \
                    } else { \
                        io_mode &= ~synctex_io_gz_mask; \
                    } \
                } \
            }
            TEST(basic_name,synctex_DONT_COMPRESS);
            TEST(gz_name,synctex_COMPRESS);
            TEST(quoted_name,synctex_DONT_COMPRESS);
            TEST(quoted_gz_name,synctex_COMPRESS);
            TEST(build_name,synctex_DONT_COMPRESS);
            TEST(build_gz_name,synctex_COMPRESS);
            TEST(build_quoted_name,synctex_DONT_COMPRESS);
            TEST(build_quoted_gz_name,synctex_COMPRESS);
#           undef TEST
            /*  Free all the intermediate filenames, except the one that will be used as returned value. */
#           define CLEAN_AND_REMOVE(FILENAME) \
            if(FILENAME && (FILENAME!=synctex_name)) {\
                remove(FILENAME);\
                printf("synctex tool info: %s removed\n",FILENAME);\
                free(FILENAME);\
                FILENAME = NULL;\
            }
            CLEAN_AND_REMOVE(basic_name);
            CLEAN_AND_REMOVE(gz_name);
            CLEAN_AND_REMOVE(quoted_name);
            CLEAN_AND_REMOVE(quoted_gz_name);
            CLEAN_AND_REMOVE(build_name);
            CLEAN_AND_REMOVE(build_gz_name);
            CLEAN_AND_REMOVE(build_quoted_name);
            CLEAN_AND_REMOVE(build_quoted_gz_name);
#           undef CLEAN_AND_REMOVE
            /* set up the returned values */
            * synctex_name_ref = synctex_name;
            * io_mode_ref = io_mode;
            return 0;
        }
        return -1;/*  bad argument */
    }
    return -2;
}

synctex_bool_t _synctex_is_equivalent_file_name	(	const char *	lhs,
		const char *	rhs
	)

Definition at line 182 of file synctex_parser_utils.c.

                                                                                  {
    /*  Remove the leading regex '(\./+)*' in both rhs and lhs */
    synctex_ignore_leading_dot_slash_in_path(&lhs);
    synctex_ignore_leading_dot_slash_in_path(&rhs);
next_character:
    if (SYNCTEX_IS_PATH_SEPARATOR(*lhs)) {/*  lhs points to a path separator */
        if (!SYNCTEX_IS_PATH_SEPARATOR(*rhs)) {/*  but not rhs */
            return synctex_NO;
        }
        ++lhs;
        ++rhs;
        synctex_ignore_leading_dot_slash_in_path(&lhs);
        synctex_ignore_leading_dot_slash_in_path(&rhs);
        goto next_character;
    } else if (SYNCTEX_IS_PATH_SEPARATOR(*rhs)) {/*  rhs points to a path separator but not lhs */
        return synctex_NO;
    } else if (SYNCTEX_ARE_PATH_CHARACTERS_EQUAL(*lhs,*rhs)){/*  uppercase do not match */
        return synctex_NO;
    } else if (!*lhs) {/*  lhs is at the end of the string */
        return *rhs ? synctex_NO : synctex_YES;
    } else if(!*rhs) {/*  rhs is at the end of the string but not lhs */
        return synctex_NO;
    }
    ++lhs;
    ++rhs;
    goto next_character;
}

Here is the caller graph for this function:

const char* _synctex_last_path_component

(

const char *

name)

Definition at line 225 of file synctex_parser_utils.c.

                                                             {
    const char * c = name+strlen(name);
    if(c>name) {
        if(!SYNCTEX_IS_PATH_SEPARATOR(*c)) {
            do {
                --c;
                if(SYNCTEX_IS_PATH_SEPARATOR(*c)) {
                    return c+1;
                }
            } while(c>name);
        }
        return c;/* the last path component is the void string*/
    }
    return c;
}

Here is the caller graph for this function:

void* _synctex_malloc

(

size_t

size)

Definition at line 72 of file synctex_parser_utils.c.

                                   {
    void * ptr = malloc(size);
    if(ptr) {
/*  There used to be a switch to use bzero because it is more secure. JL */
        memset(ptr,0, size);
    }
    return (void *)ptr;
}

Here is the caller graph for this function:

synctex_bool_t _synctex_path_is_absolute

(

const char *

name)

Definition at line 210 of file synctex_parser_utils.c.

                                                            {
    if(!strlen(name)) {
        return synctex_NO;
    }
#   if defined(SYNCTEX_WINDOWS) || defined(SYNCTEX_OS2)
    if(strlen(name)>2) {
        return (name[1]==':' && SYNCTEX_IS_PATH_SEPARATOR(name[2]))?synctex_YES:synctex_NO;
    }
    return synctex_NO;
#   else
    return SYNCTEX_IS_PATH_SEPARATOR(name[0])?synctex_YES:synctex_NO;
#   endif
}

Here is the caller graph for this function:

void _synctex_strip_last_path_extension

(

char *

string)

Definition at line 114 of file synctex_parser_utils.c.

                                                       {
    if(NULL != string){
        char * last_component = NULL;
        char * last_extension = NULL;
        char * next = NULL;
        /*  first we find the last path component */
        if(NULL == (last_component = strstr(string,"/"))){
            last_component = string;
        } else {
            ++last_component;
            while((next = strstr(last_component,"/"))){
                last_component = next+1;
            }
        }
#       if defined(SYNCTEX_WINDOWS) || defined(SYNCTEX_OS2)
        /*  On Windows, the '\' is also a path separator. */
        while((next = strstr(last_component,"\\"))){
            last_component = next+1;
        }
#       endif
        /*  then we find the last path extension */
        if((last_extension = strstr(last_component,"."))){
            ++last_extension;
            while((next = strstr(last_extension,"."))){
                last_extension = next+1;
            }
            --last_extension;/*  back to the "." */
            if(last_extension>last_component){/*  filter out paths like ....my/dir/.hidden"*/
                last_extension[0] = '\0';
            }
        }
    }
}

Here is the caller graph for this function:

synctex_bool_t synctex_ignore_leading_dot_slash_in_path

(

const char **

name)

Definition at line 148 of file synctex_parser_utils.c.

{
    if (SYNCTEX_IS_DOT((*name_ref)[0]) && SYNCTEX_IS_PATH_SEPARATOR((*name_ref)[1])) {
        do {
            (*name_ref) += 2;
            while (SYNCTEX_IS_PATH_SEPARATOR((*name_ref)[1])) {
                ++(*name_ref);
            }
        } while(SYNCTEX_IS_DOT((*name_ref)[0]) && SYNCTEX_IS_PATH_SEPARATOR((*name_ref)[1]));
        return synctex_YES;
    }
    return synctex_NO;
}

Here is the caller graph for this function:

Variable Documentation

const char* synctex_suffix

Definition at line 98 of file synctex_parser.c.

const char* synctex_suffix_gz

Definition at line 99 of file synctex_parser.c.