/*

This file is part of the SyncTeX package.

License:

--------

*/

#include "synctex_parser.h"

/* These are the possible extensions of the synctex file */

const char * synctex_suffix = ".synctex";

const char * synctex_suffix_gz = ".gz";

/* each synctex node has a class */

typedef struct __synctex_class_t _synctex_class_t;

typedef _synctex_class_t * synctex_class_t;

/* This macro is some kind of objc_msg_send.

* It takes care of sending the proper message if possible.

*/

(*((((NODE)->class))->SELECTOR))(NODE);\

}

/* Parent getter and setter

*/

# define SYNCTEX_PARENT(NODE) SYNCTEX_GET(NODE,parent)

SYNCTEX_GETTER(NODE,parent)[0]=NEW_PARENT;\

}

/* Child getter and setter

*/

# define SYNCTEX_CHILD(NODE) SYNCTEX_GET(NODE,child)

SYNCTEX_GETTER(NODE,child)[0]=NEW_CHILD;\

SYNCTEX_GETTER(NEW_CHILD,parent)[0]=NODE;\

}

/* Sibling getter and setter

*/

# define SYNCTEX_SIBLING(NODE) SYNCTEX_GET(NODE,sibling)

SYNCTEX_GETTER(NODE,sibling)[0]=NEW_SIBLING;\

SYNCTEX_GETTER(NEW_SIBLING,parent)[0]=SYNCTEX_GETTER(NODE,parent)[0];\

}\

}

* Friends are used mainly in forward synchronization aka from source to output.

*/

# define SYNCTEX_FRIEND(NODE) SYNCTEX_GET(NODE,friend)

SYNCTEX_GETTER(NODE,friend)[0]=NEW_FRIEND;\

}

* Navigation starts with the deeper boxes.

*/

# define SYNCTEX_NEXT_HORIZ_BOX(NODE) SYNCTEX_GET(NODE,next_box)

SYNCTEX_GETTER(NODE,next_box)[0]=NEXT_BOX;\

}

* This destructor is for all nodes with children.

*/

void _synctex_free_node(synctex_node_t node) {

(*((node->class)->sibling))(node);

SYNCTEX_FREE(SYNCTEX_SIBLING(node));

SYNCTEX_FREE(SYNCTEX_CHILD(node));

* This destructor is for nodes with no child.

*/

void _synctex_free_leaf(synctex_node_t node) {

SYNCTEX_FREE(SYNCTEX_SIBLING(node));

free(node);

}

/* sheet node creator */

synctex_node_t _synctex_new_sheet(synctex_scanner_t scanner) {

synctex_node_t node = _synctex_malloc(sizeof(synctex_sheet_t));

node->class = scanner?scanner->class+synctex_node_type_sheet:(synctex_class_t)&synctex_class_sheet;

}

return node;

/* vertical box node creator */

synctex_node_t _synctex_new_vbox(synctex_scanner_t scanner) {

synctex_node_t node = _synctex_malloc(sizeof(synctex_vert_box_node_t));

node->class = scanner?scanner->class+synctex_node_type_vbox:(synctex_class_t)&synctex_class_vbox;

}

return node;

/* horizontal box node creator */

synctex_node_t _synctex_new_hbox(synctex_scanner_t scanner) {

synctex_node_t node = _synctex_malloc(sizeof(synctex_horiz_box_node_t));

node->class = scanner?scanner->class+synctex_node_type_hbox:(synctex_class_t)&synctex_class_hbox;

}

return node;

/* vertical void box node creator */

synctex_node_t _synctex_new_void_vbox(synctex_scanner_t scanner) {

synctex_node_t node = _synctex_malloc(sizeof(synctex_void_box_node_t));

node->class = scanner?scanner->class+synctex_node_type_void_vbox:(synctex_class_t)&synctex_class_void_vbox;

}

return node;

/* horizontal void box node creator */

synctex_node_t _synctex_new_void_hbox(synctex_scanner_t scanner) {

synctex_node_t node = _synctex_malloc(sizeof(synctex_void_box_node_t));

node->class = scanner?scanner->class+synctex_node_type_void_hbox:(synctex_class_t)&synctex_class_void_hbox;

}

return node;

synctex_node_t _synctex_new_math(synctex_scanner_t scanner) {

synctex_node_t node = _synctex_malloc(sizeof(synctex_medium_node_t));

node->class = scanner?scanner->class+synctex_node_type_math:(synctex_class_t)&synctex_class_math;

}

return node;

synctex_node_t _synctex_new_kern(synctex_scanner_t scanner) {

synctex_node_t node = _synctex_malloc(sizeof(synctex_medium_node_t));

node->class = scanner?scanner->class+synctex_node_type_kern:(synctex_class_t)&synctex_class_kern;

}

return node;

};

synctex_node_t _synctex_new_glue(synctex_scanner_t scanner) {

synctex_node_t node = _synctex_malloc(sizeof(synctex_medium_node_t));

node->class = scanner?scanner->class+synctex_node_type_glue:(synctex_class_t)&synctex_class_glue;

}

return node;

synctex_node_t _synctex_new_boundary(synctex_scanner_t scanner) {

synctex_node_t node = _synctex_malloc(sizeof(synctex_small_node_t));

node->class = scanner?scanner->class+synctex_node_type_boundary:(synctex_class_t)&synctex_class_boundary;

}

return node;

synctex_node_t _synctex_new_input(synctex_scanner_t scanner) {

synctex_node_t node = _synctex_malloc(sizeof(synctex_input_t));

node->class = scanner?scanner->class+synctex_node_type_input:(synctex_class_t)&synctex_class_input;

}

return node;

}

void _synctex_free_input(synctex_node_t node){

SYNCTEX_FREE(SYNCTEX_SIBLING(node));

free(SYNCTEX_NAME(node));

free(node);

return SYNCTEX_SIBLING(node);

}

synctex_node_t synctex_node_next(synctex_node_t node) {

return SYNCTEX_CHILD(node);

}

sibling:

return SYNCTEX_SIBLING(node);

}

return NULL;

}

goto sibling;

/* Public node accessor: the type */

synctex_node_type_t synctex_node_type(synctex_node_t node) {

return (((node)->class))->type;

}

return synctex_node_type_error;

}

void _synctex_log_sheet(synctex_node_t sheet) {

printf("%s:%i\n",synctex_node_isa(sheet),SYNCTEX_PAGE(sheet));

printf("SELF:%p",(void *)sheet);

printf(" SYNCTEX_PARENT:%p",(void *)SYNCTEX_PARENT(sheet));

}

void _synctex_display_sheet(synctex_node_t sheet) {

printf("....{%i\n",SYNCTEX_PAGE(sheet));

SYNCTEX_DISPLAY(SYNCTEX_CHILD(sheet));

printf("....}\n");

# define SYNCTEX_FILE (scanner->file)

/* Actually, the minimum buffer size is driven by integer and float parsing.

*/

# define SYNCTEX_BUFFER_MIN_SIZE 16

# define SYNCTEX_BUFFER_SIZE 32768

synctex_status_t _synctex_setup_visible_box(synctex_node_t box);

synctex_status_t _synctex_horiz_box_setup_visible(synctex_node_t node,int h, int v);

synctex_status_t _synctex_scan_sheet(synctex_scanner_t scanner, synctex_node_t parent);

synctex_status_t _synctex_scan_content(synctex_scanner_t scanner);

int synctex_scanner_pre_x_offset(synctex_scanner_t scanner);

int synctex_scanner_pre_y_offset(synctex_scanner_t scanner);

* when there was an error reading the synctex file. */

synctex_status_t _synctex_buffer_get_available_size(synctex_scanner_t scanner, size_t * size_ptr) {

size_t available = 0;

return SYNCTEX_STATUS_BAD_ARGUMENT;

}

# define size (* size_ptr)

size = SYNCTEX_BUFFER_SIZE;

}

available = SYNCTEX_END - SYNCTEX_CUR; /* available is the number of unparsed chars in the buffer */

/* There are already sufficiently many characters in the buffer */

size = available;

return SYNCTEX_STATUS_OK;

}

/* Copy the remaining part of the buffer to the beginning,

* then read the next part of the file */

int already_read = 0;

memmove(SYNCTEX_START, SYNCTEX_CUR, available);

}

SYNCTEX_CUR = SYNCTEX_START + available; /* the next character after the move, will change. */

/* Fill the buffer up to its end */

already_read = gzread(SYNCTEX_FILE,(void *)SYNCTEX_CUR,SYNCTEX_BUFFER_SIZE - available);

/* We assume that 0<already_read<=SYNCTEX_BUFFER_SIZE - available, such that

* SYNCTEX_CUR + already_read = SYNCTEX_START + available + already_read <= SYNCTEX_START + SYNCTEX_BUFFER_SIZE */

SYNCTEX_END = SYNCTEX_CUR + already_read;

SYNCTEX_CUR = SYNCTEX_START;

size = SYNCTEX_END - SYNCTEX_CUR; /* == old available + already_read*/

return SYNCTEX_STATUS_OK; /* May be available is less than size, the caller will have to test. */

int errnum = 0;

const char * error_string = gzerror(SYNCTEX_FILE, &errnum);

/* There is an error in zlib caused by the file system */

_synctex_error("gzread error from the file system (%i)",errno);

_synctex_error("gzread error (%i:%i,%s)",already_read,errnum,error_string);

}

}

/* We cannot enlarge the buffer because the end of the file was reached. */

size = available;

return SYNCTEX_STATUS_EOF;

synctex_status_t _synctex_next_line(synctex_scanner_t scanner) {

synctex_status_t status = SYNCTEX_STATUS_OK;

size_t available = 0;

return SYNCTEX_STATUS_BAD_ARGUMENT;

}

infinite_loop:

while(SYNCTEX_CUR<SYNCTEX_END) {

++SYNCTEX_CUR;

available = 1;

return _synctex_buffer_get_available_size(scanner, &available);

* will read another bunch of synctex file. Little by little, we advance to the end of the file. */

available = 1;

status = _synctex_buffer_get_available_size(scanner, &available);

return status;

}

goto infinite_loop;

size_t remaining_len = 0; /* the number of remaining characters of the_string that should match */

size_t available = 0;

synctex_status_t status = 0;

return SYNCTEX_STATUS_BAD_ARGUMENT;

}

remaining_len = strlen(the_string); /* All the_string should match */

return SYNCTEX_STATUS_BAD_ARGUMENT;

}

/* How many characters available in the buffer? */

available = remaining_len;

status = _synctex_buffer_get_available_size(scanner,&available);

return status;

}

/* Maybe we have less characters than expected because the buffer is too small. */

/* The buffer is sufficiently big to hold the expected number of characters. */

return SYNCTEX_STATUS_NOT_OK;

}

return_OK:

/* Advance SYNCTEX_CUR to the next character after the_string. */

SYNCTEX_CUR += remaining_len;

return SYNCTEX_STATUS_OK;

/* No need to goo further, this is not the expected string in the buffer. */

return SYNCTEX_STATUS_NOT_OK;

/* The buffer was too small to contain remaining_len characters.

* We have to cut the string into pieces. */

z_off_t offset = 0L;

remaining_len -= available;

tested_len += available;

SYNCTEX_CUR += available; /* We validate the tested characters. */

/* Nothing left to test, we have found the given string, we return the length. */

return tested_len;

}

* We will definitely have to recover the previous state in case we do not find the expected string. */

available = remaining_len;

status = _synctex_buffer_get_available_size(scanner,&available);

return status; /* This is an error, no need to go further. */

}

/* Missing characters: recover the initial state of the file and return. */

return_NOT_OK:

/* This is a critical error, we could not recover the previous state. */

_synctex_error("can't seek file");

return SYNCTEX_STATUS_ERROR;

SYNCTEX_CUR = SYNCTEX_END;

return SYNCTEX_STATUS_NOT_OK;

}

/* We'll have to loop one more time. */

/* This is not the expected string, recover the previous state and return. */

goto return_NOT_OK;

}

remaining_len -= available;

tested_len += available;

SYNCTEX_CUR += available; /* We validate the tested characters. */

/* Nothing left to test, we have found the given string. */

return SYNCTEX_STATUS_OK;

}

goto more_characters;

}

/* This is the last step. */

/* This is not the expected string, recover the previous state and return. */

goto return_NOT_OK;

}

int result = 0;

size_t available = 0;

synctex_status_t status = 0;

return SYNCTEX_STATUS_BAD_ARGUMENT;

}

available = SYNCTEX_BUFFER_MIN_SIZE;

status = _synctex_buffer_get_available_size(scanner, &available);

return status;/* Forward error. */

}

return SYNCTEX_STATUS_EOF;/* it is the end of file. */

}

ptr = SYNCTEX_CUR;

++ptr;

--available;

return SYNCTEX_STATUS_NOT_OK;/* It is not possible to scan an int */

}

}

result = (int)strtol(ptr, &end, 10);

SYNCTEX_CUR = end;

* value_ref = result;

}

return SYNCTEX_STATUS_OK;/* Successfully scanned an int */

size_t len = 0;/* The number of bytes to copy */

size_t available = 0;

synctex_status_t status = 0;

return SYNCTEX_STATUS_BAD_ARGUMENT;

}

/* The buffer must at least contain one character: the '\n' end of line marker */

available = 1;

status = _synctex_buffer_get_available_size(scanner,&available);

return status;

}

return SYNCTEX_STATUS_EOF;

}

}

* value_ref = NULL;/* Initialize, it will be realloc'ed */

/* We scan all the characters up to the next '\n' */

next_character:

/* OK, we found where to stop */

len = end - SYNCTEX_CUR;

/* But we have reached the limit: we do not have current_size+len+1>UINT_MAX.

* We return the missing amount of memory.

* This will never occur in practice. */

/* We have current_size+len+1<=UINT_MAX

* or equivalently new_size<UINT_MAX,

* where we have assumed that len<UINT_MAX */

(* value_ref)[new_size]='\0'; /* Terminate the string */

SYNCTEX_CUR += len;/* Advance to the terminating '\n' */

return SYNCTEX_STATUS_OK;

} else {

/* end == SYNCTEX_END */

len = SYNCTEX_END - SYNCTEX_CUR;

/* We have reached the limit. */

_synctex_error("limit reached (missing %i).",current_size-(UINT_MAX-len-1));

return SYNCTEX_STATUS_ERROR;

}

new_size = current_size+len;

(* value_ref)[new_size]='\0'; /* Terminate the string */

SYNCTEX_CUR = SYNCTEX_END;/* Advance the cursor to the end of the bufer */

return SYNCTEX_STATUS_OK;

synctex_status_t status = 0;

size_t available = 0;

synctex_node_t input = NULL;

return SYNCTEX_STATUS_BAD_ARGUMENT;

}

status = _synctex_match_string(scanner,"Input:");

return status;

}

/* Create a node */

input = _synctex_new_input(scanner);

_synctex_error("could not create an input node.");

return SYNCTEX_STATUS_ERROR;

}

/* Decode the synctag */

status = _synctex_decode_int(scanner,&(SYNCTEX_TAG(input)));

_synctex_error("bad format of input node.");

SYNCTEX_FREE(input);

return status;

/* The next character is a field separator, we expect one character in the buffer. */

available = 1;

status = _synctex_buffer_get_available_size(scanner, &available);

return status;

}

return SYNCTEX_STATUS_EOF;

}

/* We can now safely advance to the next character, stepping over the field separator. */

--available;

/* Then we scan the file name */

status = _synctex_decode_string(scanner,&(SYNCTEX_NAME(input)));

SYNCTEX_FREE(input);

return status;

}

*/

synctex_status_t _synctex_scan_named(synctex_scanner_t scanner,const char * name,void * value_ref,synctex_decoder_t decoder) {

synctex_status_t status = 0;

return SYNCTEX_STATUS_BAD_ARGUMENT;

}

not_found:

status = _synctex_match_string(scanner,name);

return status;

status = _synctex_next_line(scanner);

return status;

}

goto not_found;

*/

synctex_status_t _synctex_scan_preamble(synctex_scanner_t scanner) {

synctex_status_t status = 0;

return SYNCTEX_STATUS_BAD_ARGUMENT;

}

status = _synctex_scan_named(scanner,"SyncTeX Version:",&(scanner->version),(synctex_decoder_t)&_synctex_decode_int);

return status;

}

status = _synctex_next_line(scanner);

return status;

}

/* Read all the input records */

do {

status = _synctex_scan_input(scanner);

return status;

}

} while(status == SYNCTEX_STATUS_OK);

/* the loop exits when status == SYNCTEX_STATUS_NOT_OK */

/* Now read all the required settings. */

status = _synctex_scan_named(scanner,"Output:",&(scanner->output_fmt),(synctex_decoder_t)&_synctex_decode_string);

return status;

}

status = _synctex_next_line(scanner);

return status;

}

status = _synctex_scan_named(scanner,"Magnification:",&(scanner->pre_magnification),(synctex_decoder_t)&_synctex_decode_int);

return status;

}

status = _synctex_next_line(scanner);

return status;

}

status = _synctex_scan_named(scanner,"Unit:",&(scanner->pre_unit),(synctex_decoder_t)&_synctex_decode_int);

return status;

}

status = _synctex_next_line(scanner);

return status;

}

status = _synctex_scan_named(scanner,"X Offset:",&(scanner->pre_x_offset),(synctex_decoder_t)&_synctex_decode_int);

return status;

}

status = _synctex_next_line(scanner);

return status;

}

status = _synctex_scan_named(scanner,"Y Offset:",&(scanner->pre_y_offset),(synctex_decoder_t)&_synctex_decode_int);

return status;

}

return _synctex_next_line(scanner);

char * loc = setlocale(LC_NUMERIC, NULL);

#endif

size_t available = 0;

return SYNCTEX_STATUS_BAD_ARGUMENT;

}

available = SYNCTEX_BUFFER_MIN_SIZE;

status = _synctex_buffer_get_available_size(scanner, &available);

_synctex_error("problem with float.");

return status;

}

#ifdef HAVE_SETLOCALE

setlocale(LC_NUMERIC, loc);

#endif

_synctex_error("a float was expected.");

return SYNCTEX_STATUS_ERROR;

}

SYNCTEX_CUR = endptr;

f *= 72.27f*65536;

report_unit_error:

_synctex_error("problem with unit.");

return status;

f *= 72.27f*65536/2.54f;

goto report_unit_error;

f *= 72.27f*65536/25.4f;

goto report_unit_error;

f *= 65536.0f;

goto report_unit_error;

f *= 72.27f/72*65536.0f;

goto report_unit_error;

f *= 12.0*65536.0f;

goto report_unit_error;

f *= 1.0f;

goto report_unit_error;

f *= 1238.0f/1157*65536.0f;

goto report_unit_error;

f *= 14856.0f/1157*65536;

goto report_unit_error;

f *= 685.0f/642*65536;

goto report_unit_error;

f *= 1370.0f/107*65536;

goto report_unit_error;

}

*value_ref = f;

#ifdef HAVE_SETLOCALE

char * loc = setlocale(LC_NUMERIC, NULL);

#endif

return SYNCTEX_STATUS_BAD_ARGUMENT;

}

/* Scan the file until a post scriptum line is found */

post_scriptum_not_found:

status = _synctex_match_string(scanner,"Post scriptum:");

return status;

}

status = _synctex_next_line(scanner);

return status;

return SYNCTEX_STATUS_OK;/* The EOF is found, we have properly scanned the file */

}

goto post_scriptum_not_found;

/* We found the name, advance to the next line. */

next_line:

status = _synctex_next_line(scanner);

return status;

return SYNCTEX_STATUS_OK;/* The EOF is found, we have properly scanned the file */

}

/* Scanning the information */

status = _synctex_match_string(scanner,"Magnification:");

#ifdef HAVE_SETLOCALE

setlocale(LC_NUMERIC, "C");

#endif

#ifdef HAVE_SETLOCALE

setlocale(LC_NUMERIC, loc);

#endif

_synctex_error("bad magnification in the post scriptum, a float was expected.");

return SYNCTEX_STATUS_ERROR;

}

_synctex_error("bad magnification in the post scriptum, a positive float was expected.");

return SYNCTEX_STATUS_ERROR;

}

SYNCTEX_CUR = endptr;

goto next_line;

}

report_record_problem:

_synctex_error("Problem reading the Post Scriptum records");

return status; /* echo the error. */

}

status = _synctex_match_string(scanner,"X Offset:");

status = _synctex_scan_float_and_dimension(scanner, &(scanner->x_offset));

_synctex_error("problem with X offset in the Post Scriptum.");

return status;

}

goto next_line;

goto report_record_problem;

}

status = _synctex_match_string(scanner,"Y Offset:");

status = _synctex_scan_float_and_dimension(scanner, &(scanner->y_offset));

_synctex_error("problem with Y offset in the Post Scriptum.");

return status;

}

goto next_line;

goto report_record_problem;

}

goto next_line;

*/

int _synctex_scan_postamble(synctex_scanner_t scanner) {

int status = 0;

return SYNCTEX_STATUS_BAD_ARGUMENT;

}

status = _synctex_match_string(scanner,"Postamble:");

return status;

}

count_again:

status = _synctex_next_line(scanner);

return status;

}

status = _synctex_scan_named(scanner,"Count:",&(scanner->count),(synctex_decoder_t)&_synctex_decode_int);

return status; /* forward the error */

status = _synctex_next_line(scanner); /* Advance one more line */

return status;

}

goto count_again;

* At creation time, the visible size is set to the values of the real size.

*/

synctex_status_t _synctex_setup_visible_box(synctex_node_t box) {

switch(box->class->type) {

case synctex_node_type_hbox:

SYNCTEX_HORIZ_V(box) = SYNCTEX_HORIZ(box);

SYNCTEX_VERT_V(box) = SYNCTEX_VERT(box);

SYNCTEX_WIDTH_V(box) = SYNCTEX_WIDTH(box);

# pragma unused(v)

# endif

int itsBtm, itsTop;

return SYNCTEX_STATUS_BAD_ARGUMENT;

}

itsBtm = SYNCTEX_HORIZ_V(node);

itsTop = SYNCTEX_HORIZ_V(node)-SYNCTEX_WIDTH_V(node);

SYNCTEX_HORIZ_V(node) = h;

SYNCTEX_WIDTH_V(node) = SYNCTEX_HORIZ_V(node) - itsTop;

SYNCTEX_WIDTH_V(node) = SYNCTEX_HORIZ_V(node) - h;

}

} else {

itsBtm = SYNCTEX_HORIZ_V(node);

itsTop = SYNCTEX_HORIZ_V(node)+SYNCTEX_WIDTH_V(node);

SYNCTEX_HORIZ_V(node) = h;

SYNCTEX_WIDTH_V(node) = itsTop - SYNCTEX_HORIZ_V(node);

SYNCTEX_WIDTH_V(node) = h - SYNCTEX_HORIZ_V(node);

}

}

return SYNCTEX_STATUS_OK;

}

/* Used when parsing the synctex file.

* The sheet argument is a newly created sheet node that will hold the contents.

* Something is returned in case of error.

synctex_info_t * info = NULL;

synctex_status_t status = 0;

size_t available = 0;

return SYNCTEX_STATUS_BAD_ARGUMENT;

}

/* We MUST start with a box, so at this level, the unique possibility is '[', '(' or "}". */

prepare_loop:

scan_vbox:

++SYNCTEX_CUR;

# define SYNCTEX_DECODE_FAILED(WHAT) \

(_synctex_decode_int(scanner,&(info[WHAT].INT))<SYNCTEX_STATUS_OK)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_LINE_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_HORIZ_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_VERT_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_DEPTH_IDX)

|| _synctex_next_line(scanner)<SYNCTEX_STATUS_OK) {

_synctex_error("Bad vbox record.");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

SYNCTEX_SET_CHILD(parent,child);

_synctex_error("Can't create vbox record.");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

scan_hbox:

++SYNCTEX_CUR;

|| SYNCTEX_DECODE_FAILED(SYNCTEX_LINE_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_HORIZ_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_VERT_IDX)

_synctex_error("Can't create hbox record.");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

scan_teehs:

++SYNCTEX_CUR;

|| _synctex_next_line(scanner)<SYNCTEX_STATUS_OK) {

_synctex_error("Unexpected end of sheet.");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

SYNCTEX_RETURN(SYNCTEX_STATUS_OK);

scan_anchor:

++SYNCTEX_CUR;

_synctex_error("Missing anchor.");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

} else {

/* _synctex_error("Ignored record %c\n",*SYNCTEX_CUR); */

++SYNCTEX_CUR;

_synctex_error("Unexpected end.");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

} else {

available = 1;

status = _synctex_buffer_get_available_size(scanner,&available);

_synctex_error("Uncomplete sheet(0)");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

} else {

/* The child loop means that we go do one level, when we just created a box node,

* the next node created is a child of this box. */

child_loop:

goto scan_vbox;

scan_xobv:

++SYNCTEX_CUR;

#define SYNCTEX_UPDATE_BOX_FRIEND(NODE)\

friend_index = ((SYNCTEX_INFO(NODE))[SYNCTEX_TAG_IDX].INT+(SYNCTEX_INFO(NODE))[SYNCTEX_LINE_IDX].INT)%(scanner->number_of_lists);\

SYNCTEX_SET_FRIEND(NODE,(scanner->lists_of_friends)[friend_index]);\

(scanner->lists_of_friends)[friend_index] = NODE;

/* only void boxes are friends */

SYNCTEX_UPDATE_BOX_FRIEND(parent);

}

child = parent;

parent = SYNCTEX_PARENT(child);

} else {

}

_synctex_error("Uncomplete sheet.");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

goto sibling_loop;

goto scan_hbox;

scan_xobh:

++SYNCTEX_CUR;

/* Only boxes with no children are friends,

* boxes with children are indirectly friends through one of their descendants. */

SYNCTEX_UPDATE_BOX_FRIEND(parent);

child = parent;

parent = SYNCTEX_PARENT(child);

} else {

}

_synctex_error("Uncomplete sheet.");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

goto sibling_loop;

++SYNCTEX_CUR;

&& NULL != (info = SYNCTEX_INFO(child))) {

|| SYNCTEX_DECODE_FAILED(SYNCTEX_LINE_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_HORIZ_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_VERT_IDX)

_synctex_error("Can't create vbox record.");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

++SYNCTEX_CUR;

&& NULL != (info = SYNCTEX_INFO(child))) {

|| SYNCTEX_DECODE_FAILED(SYNCTEX_LINE_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_HORIZ_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_VERT_IDX)

_synctex_error("Can't create void hbox record.");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

++SYNCTEX_CUR;

&& NULL != (info = SYNCTEX_INFO(child))) {

|| SYNCTEX_DECODE_FAILED(SYNCTEX_LINE_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_HORIZ_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_VERT_IDX)

_synctex_error("Can't create kern record.");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

++SYNCTEX_CUR;

&& NULL != (info = SYNCTEX_INFO(child))) {

|| SYNCTEX_DECODE_FAILED(SYNCTEX_LINE_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_HORIZ_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_VERT_IDX)

_synctex_error("Can't create glue record.");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

++SYNCTEX_CUR;

&& NULL != (info = SYNCTEX_INFO(child))) {

|| SYNCTEX_DECODE_FAILED(SYNCTEX_LINE_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_HORIZ_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_VERT_IDX)

_synctex_error("Can't create math record.");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

++SYNCTEX_CUR;

&& NULL != (info = SYNCTEX_INFO(child))) {

|| SYNCTEX_DECODE_FAILED(SYNCTEX_LINE_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_HORIZ_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_VERT_IDX)

_synctex_error("Can't create math record.");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

goto scan_teehs;

goto scan_anchor;

} else {

/* _synctex_error("Ignored record %c\n",*SYNCTEX_CUR); */

++SYNCTEX_CUR;

_synctex_error("Unexpected end.");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

} else {

available = 1;

status = _synctex_buffer_get_available_size(scanner,&available);

_synctex_error("Uncomplete sheet(0)");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

} else {

/* The vertical loop means that we are on the same level, for example when we just ended a box.

* If a node is created now, it will be a sibling of the current node, sharing the same parent. */

sibling_loop:

++SYNCTEX_CUR;

&& NULL != (info = SYNCTEX_INFO(sibling))) {

|| SYNCTEX_DECODE_FAILED(SYNCTEX_LINE_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_HORIZ_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_VERT_IDX)

_synctex_error("Can't create vbox record (2).");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

goto scan_xobv;

++SYNCTEX_CUR;

NULL != (info = SYNCTEX_INFO(sibling))) {

|| SYNCTEX_DECODE_FAILED(SYNCTEX_LINE_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_HORIZ_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_VERT_IDX)

_synctex_error("Can't create hbox record (2).");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

goto scan_xobh;

++SYNCTEX_CUR;

NULL != (info = SYNCTEX_INFO(sibling))) {

|| SYNCTEX_DECODE_FAILED(SYNCTEX_LINE_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_HORIZ_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_VERT_IDX)

_synctex_error("can't create void vbox record (2).");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

++SYNCTEX_CUR;

NULL != (info = SYNCTEX_INFO(sibling))) {

|| SYNCTEX_DECODE_FAILED(SYNCTEX_LINE_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_HORIZ_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_VERT_IDX)

_synctex_error("can't create void hbox record (2).");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

++SYNCTEX_CUR;

&& NULL != (info = SYNCTEX_INFO(sibling))) {

|| SYNCTEX_DECODE_FAILED(SYNCTEX_LINE_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_HORIZ_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_VERT_IDX)

_synctex_error("Can't create kern record (2).");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

++SYNCTEX_CUR;

&& NULL != (info = SYNCTEX_INFO(sibling))) {

|| SYNCTEX_DECODE_FAILED(SYNCTEX_LINE_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_HORIZ_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_VERT_IDX)

_synctex_error("Can't create glue record (2).");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

++SYNCTEX_CUR;

&& NULL != (info = SYNCTEX_INFO(sibling))) {

|| SYNCTEX_DECODE_FAILED(SYNCTEX_LINE_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_HORIZ_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_VERT_IDX)

_synctex_error("Can't create math record (2).");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

++SYNCTEX_CUR;

&& NULL != (info = SYNCTEX_INFO(sibling))) {

|| SYNCTEX_DECODE_FAILED(SYNCTEX_LINE_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_HORIZ_IDX)

|| SYNCTEX_DECODE_FAILED(SYNCTEX_VERT_IDX)

_synctex_error("Can't create boundary record (2).");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

goto scan_teehs;

++SYNCTEX_CUR;

_synctex_error("Missing anchor (2).");

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

} else {

++SYNCTEX_CUR;

/* _synctex_error("Ignored record %c(2)\n",*SYNCTEX_CUR); */

SYNCTEX_RETURN(SYNCTEX_STATUS_ERROR);

}

goto sibling_loop;

} else {

available = 1;

status = _synctex_buffer_get_available_size(scanner,&available);

goto sibling_loop;

} else {

_synctex_error("Uncomplete sheet(2)");

synctex_status_t _synctex_scan_content(synctex_scanner_t scanner) {

synctex_node_t sheet = NULL;

synctex_status_t status = 0;

return SYNCTEX_STATUS_BAD_ARGUMENT;

}

/* set up the lists of friends */

scanner->number_of_lists = 1024;

scanner->lists_of_friends = (synctex_node_t *)_synctex_malloc(scanner->number_of_lists*sizeof(synctex_node_t));

_synctex_error("malloc:2");

return SYNCTEX_STATUS_ERROR;

}

/* Find where this section starts */

content_not_found:

status = _synctex_match_string(scanner,"Content:");

return status;

}

_synctex_error("Uncomplete Content.");

return SYNCTEX_STATUS_ERROR;

}

goto content_not_found;

}

next_sheet:

status = _synctex_scan_postamble(scanner);

_synctex_error("Bad content.");

return status;

}

status = _synctex_next_line(scanner);

_synctex_error("Bad content.");

return status;

}

/* Create a new sheet node */

sheet = _synctex_new_sheet(scanner);

status = _synctex_decode_int(scanner,&(SYNCTEX_PAGE(sheet)));

_synctex_error("Missing sheet number.");

bail:

SYNCTEX_FREE(sheet);

return SYNCTEX_STATUS_ERROR;

}

status = _synctex_next_line(scanner);

_synctex_error("Uncomplete file.");

goto bail;

}

status = _synctex_scan_sheet(scanner,sheet);

_synctex_error("Bad sheet content.");

goto bail;

}

/* Now read the list of Inputs between 2 sheets. */

do {

status = _synctex_scan_input(scanner);

_synctex_error("Bad input section.");

goto bail;

}

gzFile file = NULL;

char * synctex = NULL;

synctex_scanner_t scanner = NULL;

/* Here we assume that int are smaller than void * */

_synctex_error("INTERNAL INCONSISTENCY: int's are unexpectedly bigger than pointers, bailing out.");

return NULL;

}

/* We ensure that SYNCTEX_BUFFER_SIZE < UINT_MAX, I don't know if it makes sense... */

_synctex_error("SyncTeX BUG: Internal inconsistency, bad SYNCTEX_BUFFER_SIZE (1)");

return NULL;

}

/* for integers: */

_synctex_error("SyncTeX BUG: Internal inconsistency, bad SYNCTEX_BUFFER_SIZE (2)");

return NULL;

}

/* now open the synctex file */

return NULL;

}

}

scanner = (synctex_scanner_t)_synctex_malloc(sizeof(_synctex_scanner_t));

_synctex_error("SyncTeX: malloc problem");

free(synctex);

gzclose(file);

return NULL;

}

/* make a private copy of output for the scanner */

_synctex_error("! synctex_scanner_new_with_output_file: Memory problem (2), scanner's output is not reliable.");

_synctex_error("! synctex_scanner_new_with_output_file: Copy problem, scanner's output is not reliable.");

}

scanner->synctex = synctex;/* Now the scanner owns synctex */

return parse? synctex_scanner_parse(scanner):scanner;

}

/* This functions opens the file at the "output" given location.

* In TeXLive 2008, the synctex file created with pdftex did contain unexpected quotes.

* This function will remove them if possible.

* 0 on success, non 0 on error. */

size_t size = 0;

/* now create the synctex file name */

size = strlen(output)+strlen(synctex_suffix)+strlen(synctex_suffix_gz)+1;

synctex_name = (char *)malloc(size);

_synctex_error("! __synctex_open: Memory problem (1)\n");

return 1;

}

* including the terminating character. size is free now. */

_synctex_error("! __synctex_open: Copy problem\n");

return_on_error:

free(synctex_name);

return 2;

}

/* remove the last path extension if any */

_synctex_strip_last_path_extension(synctex_name);

goto return_on_error;

}

/* now insert quotes. */

char * quoted = NULL;

/* There was an error or quoting does not make sense: */

goto return_on_error;

}

synctex_name = quoted;

}

_synctex_error("! __synctex_open: Concatenation problem (can't add suffix '%s')\n",synctex_suffix);

goto return_on_error;

}

}

/* Could not open this file */

_synctex_error("SyncTeX: could not open %s, error %i\n",synctex_name,errno);

goto return_on_error;

}

_synctex_error("! __synctex_open: Concatenation problem (can't add suffix '%s')\n",synctex_suffix_gz);

goto return_on_error;

}

}

/* Could not open this file */

_synctex_error("SyncTeX: could not open %s, error %i\n",synctex_name,errno);

}

goto return_on_error;

}

/* At this point, the file is properly open.

* If we are in the add_quotes mode, we change the file name by removing the quotes. */

gzclose(the_file);

_synctex_error("SyncTeX: could not open again %s, error %i\n",synctex_name,errno);

}

goto return_on_error;

}

} else {

/* Could not open this file */

}

goto return_on_error;

}

/* The quote free file name should replace the old one:*/

free(synctex_name);

}

}

return 0;

}

return 3; /* Bad parameter. */

}

/* Opens the ouput file, taking into account the eventual build_directory.

* 0 on success, non 0 on error. */

# define synctex_name (*synctex_name_ref)

# define the_file (*file_ref)

char * build_output;

size_t size;

synctex_bool_t is_absolute;

build_output = NULL;

lpc = _synctex_last_path_component(output);

is_absolute = _synctex_path_is_absolute(build_directory);

size += strlen(output);

}

build_output[0] = '\0';

} else {

return -4;

}

build_output[lpc-output]='\0';

}

/* Append a path separator if necessary. */

return -2;

}

}

/* Append the last path component of the output. */

return -3;

}

}

}

return -1;

/* The scanner destructor

*/

void synctex_scanner_free(synctex_scanner_t scanner) {

return;

}

gzclose(SYNCTEX_FILE);

SYNCTEX_FILE = NULL;

}

/* Where the synctex scanner parses the contents of the file. */

synctex_scanner_t synctex_scanner_parse(synctex_scanner_t scanner) {

synctex_status_t status = 0;

return scanner;

}

scanner->flags.has_parsed=1;

scanner->class[synctex_node_type_boundary] = synctex_class_boundary;

(scanner->class[synctex_node_type_boundary]).scanner = scanner;

SYNCTEX_START = (char *)malloc(SYNCTEX_BUFFER_SIZE+1); /* one more character for null termination */

_synctex_error("SyncTeX: malloc error");

synctex_scanner_free(scanner);

return NULL;

*SYNCTEX_END = '\0';

SYNCTEX_CUR = SYNCTEX_END;

status = _synctex_scan_preamble(scanner);

_synctex_error("SyncTeX Error: Bad preamble\n");

bailey:

synctex_scanner_free(scanner);

return NULL;

}

status = _synctex_scan_content(scanner);

_synctex_error("SyncTeX Error: Bad content\n");

goto bailey;

}

/* Final tuning: set the default values for various parameters */

/* 1 pre_unit = (scanner->pre_unit)/65536 pt = (scanner->pre_unit)/65781.76 bp

* 1 pt = 65536 sp */

scanner->pre_unit = 8192;

}

scanner->pre_magnification = 1000;

}

/* no post magnification */

scanner->unit = scanner->pre_unit / 65781.76;/* 65781.76 or 65536.0*/

} else {

scanner->unit *= scanner->pre_unit / 65781.76;

}

scanner->unit *= scanner->pre_magnification / 1000.0;

/* no post offset */

scanner->x_offset = scanner->pre_x_offset * (scanner->pre_unit / 65781.76);

scanner->y_offset = scanner->pre_y_offset * (scanner->pre_unit / 65781.76);

return scanner?scanner->unit:1;

}

void synctex_scanner_display(synctex_scanner_t scanner) {

return;

}

printf("The scanner:\noutput:%s\noutput_fmt:%s\nversion:%i\n",scanner->output,scanner->output_fmt,scanner->version);

scanner->count,scanner->unit,scanner->x_offset,scanner->y_offset);

printf("The input:\n");

SYNCTEX_DISPLAY(scanner->input);

printf("The sheets:\n");

SYNCTEX_DISPLAY(scanner->sheet);

printf("The friends:\n");

int i = scanner->number_of_lists;

synctex_node_t node;

while(i--) {

/* Public*/

const char * synctex_scanner_get_name(synctex_scanner_t scanner,int tag) {

synctex_node_t input = NULL;

return NULL;

}

input = scanner->input;

do {

return (SYNCTEX_NAME(input));

}

} while((input = SYNCTEX_SIBLING(input)) != NULL);

int _synctex_scanner_get_tag(synctex_scanner_t scanner,const char * name);

int _synctex_scanner_get_tag(synctex_scanner_t scanner,const char * name) {

synctex_node_t input = NULL;

return 0;

}

input = scanner->input;

do {

return SYNCTEX_TAG(input);

}

} while((input = SYNCTEX_SIBLING(input)) != NULL);

int synctex_scanner_get_tag(synctex_scanner_t scanner,const char * name) {

size_t char_index = strlen(name);

/* the name is not void */

char_index -= 1;

/* the last character of name is not a path separator */

int result = _synctex_scanner_get_tag(scanner,name);

return result;

} else {

/* the given name was not the one known by TeX

}

/* Find the last path separator before relative */

while(relative > name) {

break;

}

relative -= 1;

}

return result;

}

/* No tag found for the given absolute name,

* Try each relative path starting from the shortest one */

while(0<char_index) {

char_index -= 1;

&& (result = _synctex_scanner_get_tag(scanner,name+char_index+1))) {

return result;

}

# pragma mark Public node attributes

# endif

int synctex_node_h(synctex_node_t node){

return 0;

}

return SYNCTEX_HORIZ(node);

}

int synctex_node_v(synctex_node_t node){

return 0;

}

return SYNCTEX_VERT(node);

}

int synctex_node_width(synctex_node_t node){

return 0;

}

return SYNCTEX_WIDTH(node);

}

int synctex_node_box_h(synctex_node_t node){

return 0;

}

result:

return SYNCTEX_HORIZ(node);

}

goto result;

}

return 0;

}

int synctex_node_box_v(synctex_node_t node){

return 0;

}

result:

return SYNCTEX_VERT(node);

}

goto result;

}

return 0;

}

int synctex_node_box_width(synctex_node_t node){

return 0;

}

result:

return SYNCTEX_WIDTH(node);

}

goto result;

}

return 0;

}

int synctex_node_box_height(synctex_node_t node){

return 0;

}

result:

return SYNCTEX_HEIGHT(node);

}

goto result;

}

return 0;

}

int synctex_node_box_depth(synctex_node_t node){

return 0;

}

result:

return SYNCTEX_DEPTH(node);

}

goto result;

}

return 0;

# pragma mark Public node visible attributes

# endif

float synctex_node_visible_h(synctex_node_t node){

return 0;

}

return SYNCTEX_HORIZ(node)*node->class->scanner->unit+node->class->scanner->x_offset;

}

float synctex_node_visible_v(synctex_node_t node){

return 0;

}

return SYNCTEX_VERT(node)*node->class->scanner->unit+node->class->scanner->y_offset;

}

float synctex_node_visible_width(synctex_node_t node){

return 0;

}

return SYNCTEX_WIDTH(node)*node->class->scanner->unit;

}

float synctex_node_box_visible_h(synctex_node_t node){

return 0;

}

switch(node->class->type) {

result:

return SYNCTEX_HORIZ_V(node)*node->class->scanner->unit+node->class->scanner->x_offset;

}

goto result;

}

return 0;

}

float synctex_node_box_visible_v(synctex_node_t node){

return 0;

}

switch(node->class->type) {

result:

return SYNCTEX_VERT_V(node)*node->class->scanner->unit+node->class->scanner->y_offset;

}

goto result;

}

return 0;

}

float synctex_node_box_visible_width(synctex_node_t node){

return 0;

}

switch(node->class->type) {

result:

return SYNCTEX_WIDTH_V(node)*node->class->scanner->unit;

}

goto result;

}

return 0;

}

float synctex_node_box_visible_height(synctex_node_t node){

return 0;

}

switch(node->class->type) {

result:

return SYNCTEX_HEIGHT_V(node)*node->class->scanner->unit;

}

goto result;

}

return 0;

}

float synctex_node_box_visible_depth(synctex_node_t node){

return 0;

}

switch(node->class->type) {

result:

return SYNCTEX_DEPTH_V(node)*node->class->scanner->unit;

}

goto result;

}

return 0;

int synctex_node_page(synctex_node_t node){

synctex_node_t parent = NULL;

return -1;

}

parent = SYNCTEX_PARENT(node);

node = parent;

parent = SYNCTEX_PARENT(node);

}

return SYNCTEX_PAGE(node);

}

return -1;

# endif

synctex_node_t synctex_sheet_content(synctex_scanner_t scanner,int page) {

synctex_node_t sheet = scanner->sheet;

while(sheet) {

return SYNCTEX_CHILD(sheet);

}

sheet = SYNCTEX_SIBLING(sheet);

int friend_index = 0;

int max_line = 0;

synctex_node_t node = NULL;

printf("SyncTeX Warning: No tag for %s\n",name);

return -1;

}

while(line<max_line) {

/* This loop will only be performed once for advanced viewers */

friend_index = (tag+line)%(scanner->number_of_lists);

do {

&& (tag == SYNCTEX_TAG(node))

&& (line == SYNCTEX_LINE(node))) {

size += 16;

SYNCTEX_END = realloc(SYNCTEX_START,size*sizeof(synctex_node_t *));

SYNCTEX_CUR += SYNCTEX_END - SYNCTEX_START;

SYNCTEX_CUR += sizeof(synctex_node_t);

}

} while((node = SYNCTEX_FRIEND(node)));

/* We did not find any matching boundary, retry with glue or kern */

node = (scanner->lists_of_friends)[friend_index];/* no need to test it again, already done */

do {

&& (tag == SYNCTEX_TAG(node))

&& (line == SYNCTEX_LINE(node))) {

size += 16;

SYNCTEX_END = realloc(SYNCTEX_START,size*sizeof(synctex_node_t *));

SYNCTEX_CUR += SYNCTEX_END - SYNCTEX_START;

SYNCTEX_CUR += sizeof(synctex_node_t);

}

} while((node = SYNCTEX_FRIEND(node)));

/* We did not find any matching glue or kern, retry with boxes */

node = (scanner->lists_of_friends)[friend_index];/* no need to test it again, already done */

do {

&& (line == SYNCTEX_LINE(node))) {

size += 16;

SYNCTEX_END = realloc(SYNCTEX_START,size*sizeof(synctex_node_t *));

SYNCTEX_CUR += SYNCTEX_END - SYNCTEX_START;

}

SYNCTEX_END = SYNCTEX_CUR;

/* Now reverse the order to have nodes in display order, and keep just a few nodes */

{

synctex_node_t * start_ref = (synctex_node_t *)SYNCTEX_START;

synctex_node_t * end_ref = (synctex_node_t *)SYNCTEX_END;

end_ref = (synctex_node_t *)SYNCTEX_START;

next_end:

end_ref += 1; /* we allways have start_ref<= end_ref*/

node = *end_ref;

while((node = SYNCTEX_PARENT(node))) {

goto next_end;

}

}

goto next_end;

}

start_ref += 1;

SYNCTEX_CUR = NULL;

}

# if defined(__SYNCTEX_STRONG_DISPLAY_QUERY__)

break;

}

synctex_node_t synctex_next_result(synctex_scanner_t scanner) {

SYNCTEX_CUR = SYNCTEX_START;

} else {

SYNCTEX_CUR+=sizeof(synctex_node_t);

}

return *(synctex_node_t*)SYNCTEX_CUR;

} else {

return NULL;

synctex_node_set_t bestNodes = {NULL,NULL}; /* holds the best node */

synctex_distances_t bestDistances = {INT_MAX,INT_MAX}; /* holds the best distances for the best node */

synctex_node_t bestContainer = NULL; /* placeholder */

return 0;

}

/* Convert the given point to scanner integer coordinates */

while((sheet) && SYNCTEX_PAGE(sheet) != page) {

sheet = SYNCTEX_SIBLING(sheet);

}

return -1;

}

/* Now sheet points to the sheet node with proper page number */

* Then we try with the visible box dimensions.

* We try to find a non void box containing the hit point.

* We browse all the horizontal boxes until we find one containing the hit point. */

do {

/* Maybe the hitPoint belongs to a contained vertical box. */

end:

/* This trick is for catching overlapping boxes */

do {

node = _synctex_smallest_container(other_node,node);

}

} while((other_node = SYNCTEX_NEXT_HORIZ_BOX(other_node)));

}

/* node is the smallest horizontal box that contains hitPoint. */

node = bestContainer;

}

_synctex_eq_get_closest_children_in_box(hitPoint,node,&bestNodes,&bestDistances,synctex_YES);

|| (SYNCTEX_LINE(bestNodes.right)!=SYNCTEX_LINE(bestNodes.left))

|| (SYNCTEX_COLUMN(bestNodes.right)!=SYNCTEX_COLUMN(bestNodes.left))) {

((synctex_node_t *)SYNCTEX_START)[0] = bestNodes.right;

((synctex_node_t *)SYNCTEX_START)[1] = bestNodes.left;

} else {

}

/* both nodes have the same input coordinates

* We choose the one closest to the hit point */

bestNodes.left = bestNodes.right;

}

bestNodes.right = NULL;

bestNodes.left = bestNodes.right;

bestNodes.left = node;

}

* (synctex_node_t *)SYNCTEX_START = bestNodes.left;

SYNCTEX_END = SYNCTEX_START + sizeof(synctex_node_t);

SYNCTEX_CUR = NULL;

*/

}

/* We are not lucky */

goto end;

}

return 0;

* if node is to the left of the hit point, this distance is negative.*/

int _synctex_point_h_distance(synctex_point_t hitPoint, synctex_node_t node, synctex_bool_t visible);

int _synctex_point_h_distance(synctex_point_t hitPoint, synctex_node_t node, synctex_bool_t visible) {

int min,med,max;

switch(node->class->type) {

/* The distance between a point and a box is special.

min = visible?SYNCTEX_HORIZ_V(node):SYNCTEX_HORIZ(node);

max = min + (visible?SYNCTEX_ABS_WIDTH_V(node):SYNCTEX_ABS_WIDTH(node));

/* We allways have min <= max */

return min - hitPoint.h; /* regions 1+4+7, result is > 0 */

} else if (hitPoint.h>max) {

return max - hitPoint.h; /* regions 3+6+9, result is < 0 */

min = SYNCTEX_HORIZ(node);

max = min + SYNCTEX_ABS_WIDTH(node);

/* We allways have min <= max */

return min - hitPoint.h; /* regions 1+4+7, result is > 0 */

} else if (hitPoint.h>max) {

return max - hitPoint.h; /* regions 3+6+9, result is < 0 */

* in general, there is no text material in the kern,

* this is why we compute the offset relative to the closest edge of the kern.*/

max = SYNCTEX_WIDTH(node);

min = SYNCTEX_HORIZ(node);

max = min - max;

} else {

* It means that the best choice should be made according to the situation that occurs

* most frequently.

*/

return min - hitPoint.h + 1; /* penalty to ensure other nodes are chosen first in case of overlapping ones */

} else if (hitPoint.h>max) {

return max - hitPoint.h - 1; /* same kind of penalty */

# ifdef __DARWIN_UNIX03

# pragma unused(visible)

# endif

int min,max;

switch(node->class->type) {

/* The distance between a point and a box is special.

max = min + SYNCTEX_ABS_DEPTH_V(node);

min -= SYNCTEX_ABS_HEIGHT_V(node);

/* We allways have min <= max */

return min - hitPoint.v; /* regions 1+2+3, result is > 0 */

} else if (hitPoint.v>max) {

return max - hitPoint.v; /* regions 7+8+9, result is < 0 */

max = min + SYNCTEX_ABS_DEPTH(node);

min -= SYNCTEX_ABS_HEIGHT(node);

/* We allways have min <= max */

return min - hitPoint.v; /* regions 1+2+3, result is > 0 */

} else if (hitPoint.v>max) {

return max - hitPoint.v; /* regions 7+8+9, result is < 0 */

SYNCTEX_INLINE static synctex_node_t _synctex_smallest_container(synctex_node_t node, synctex_node_t other_node) {

float height, other_height;

return node;

}

return other_node;

}

height = SYNCTEX_ABS_DEPTH(node) + SYNCTEX_ABS_HEIGHT(node);

other_height = SYNCTEX_ABS_DEPTH(other_node) + SYNCTEX_ABS_HEIGHT(other_node);

return node;

}

return other_node;

}

return node;

}

synctex_bool_t _synctex_point_in_box(synctex_point_t hitPoint, synctex_node_t node, synctex_bool_t visible) {

&& 0 == _synctex_point_v_distance(hitPoint,node,visible)) {

return synctex_YES;

}

# pragma unused(visible)

# endif

int result = INT_MAX; /* when the distance is meaning less (sheet, input...) */

int minH,maxH,minV,maxV;

switch(node->class->type) {

/* The distance between a point and a box is special.

maxV = minV + SYNCTEX_ABS_DEPTH(node);

minV -= SYNCTEX_ABS_HEIGHT(node);

/* In what region is the point hitPoint=(H,V) ? */

/* This is region 1. The distance to the box is the L1 distance PA. */

result = minV - hitPoint.v + minH - hitPoint.h;/* Integer overflow? probability epsilon */

/* This is region 2. The distance to the box is the geometrical distance to the top edge. */

result = minV - hitPoint.v;

} else {

/* This is region 3. The distance to the box is the L1 distance PB. */

result = minV - hitPoint.v + hitPoint.h - maxH;

}

/* This is region 4. The distance to the box is the geometrical distance to the left edge. */

result = minH - hitPoint.h;

/* This is region 4. We are inside the box. */

result = 0;

} else {

result = hitPoint.h - maxH;

}

} else {

/* This is region 7. The distance to the box is the L1 distance PC. */

result = hitPoint.v - maxV + minH - hitPoint.h;

/* This is region 8. The distance to the box is the geometrical distance to the top edge. */

result = hitPoint.v - maxV;

} else {

break;

case synctex_node_type_kern:

maxH = SYNCTEX_WIDTH(node);

minH = SYNCTEX_HORIZ(node);

maxH = minH - maxH;

} else {

minH += maxH;

}

minV = SYNCTEX_VERT(node);

result = hitPoint.v - minV + minH - hitPoint.h;

} else {

result = minV - hitPoint.v + minH - hitPoint.h;

}

} else if (hitPoint.h>maxH) {

result = hitPoint.v - minV + hitPoint.h - maxH;

} else {

result = minV - hitPoint.v + hitPoint.h - maxH;

}

result = hitPoint.v - minV;

} else {

result = minV - hitPoint.v;

case synctex_node_type_math:

minH = SYNCTEX_HORIZ(node);

minV = SYNCTEX_VERT(node);

result = hitPoint.v - minV + minH - hitPoint.h;

} else {

result = minV - hitPoint.v + minH - hitPoint.h;

}

result = hitPoint.v - minV + hitPoint.h - minH;

} else {

result = minV - hitPoint.v + hitPoint.h - minH;

}

static synctex_node_t _synctex_eq_deepest_container(synctex_point_t hitPoint,synctex_node_t node, synctex_bool_t visible) {

synctex_node_t result = NULL;

synctex_node_t child = NULL;

switch(node->class->type) {

case synctex_node_type_vbox:

case synctex_node_type_hbox:

/* test the deep nodes first */

do {

return result;

}

} while((child = SYNCTEX_SIBLING(child)));

}

/* is the hit point inside the box? */

/* for vboxes we try to use some node inside.

* Walk through the list of siblings until we find the closest one.

* Only consider siblings with children. */

int bestDistance = INT_MAX;

do {

int distance = _synctex_node_distance_to_point(hitPoint,child,visible);

bestDistance = distance;

node = child;

}

SYNCTEX_INLINE static int __synctex_eq_get_closest_children_in_hbox(synctex_point_t hitPoint, synctex_node_t node, synctex_node_set_t* bestNodesRef,synctex_distances_t* bestDistancesRef, synctex_bool_t visible);

SYNCTEX_INLINE static int __synctex_eq_get_closest_children_in_hbox(synctex_point_t hitPoint, synctex_node_t node, synctex_node_set_t* bestNodesRef,synctex_distances_t* bestDistancesRef, synctex_bool_t visible) {

int result = 0;

do {

int off7 = _synctex_point_h_distance(hitPoint,node,visible);

/* node is to the right of the hit point.

* We compare node and the previously recorded one, through the recorded distance.

* If the nodes have the same tag, prefer the one with the smallest line number,

* if the nodes also have the same line number, prefer the one with the smallest column. */

bestDistancesRef->right = off7;

bestNodesRef->right = node;

result |= SYNCTEX_MASK_RIGHT;

&& (SYNCTEX_LINE(bestNodesRef->right) > SYNCTEX_LINE(node)

|| (SYNCTEX_LINE(bestNodesRef->right) == SYNCTEX_LINE(node)

&& SYNCTEX_COLUMN(bestNodesRef->right) > SYNCTEX_COLUMN(node)))) {

result |= SYNCTEX_MASK_RIGHT;

}

}

/* hitPoint is inside node. */

bestDistancesRef->left = bestDistancesRef->right = 0;

bestNodesRef->left = node;

result |= SYNCTEX_MASK_LEFT;

} else { /* here off7 < 0, hitPoint is to the right of node */

off7 = -off7;

bestDistancesRef->left = off7;

bestNodesRef->left = node;

result |= SYNCTEX_MASK_LEFT;

&& (SYNCTEX_LINE(bestNodesRef->left) > SYNCTEX_LINE(node)

|| (SYNCTEX_LINE(bestNodesRef->left) == SYNCTEX_LINE(node)

&& SYNCTEX_COLUMN(bestNodesRef->left) > SYNCTEX_COLUMN(node)))) {

}

}

} while((node = SYNCTEX_SIBLING(node)));

/* the left node is new, try to narrow the result */

bestNodesRef->left = node;

}

bestNodesRef->left = node;

}

}

/* the right node is new, try to narrow the result */

bestNodesRef->right = node;

}

bestNodesRef->right = node;

}

}

SYNCTEX_INLINE static int __synctex_eq_get_closest_children_in_vbox(synctex_point_t hitPoint, synctex_node_t node, synctex_node_set_t* bestNodesRef,synctex_distances_t* bestDistancesRef,synctex_bool_t visible);

SYNCTEX_INLINE static int __synctex_eq_get_closest_children_in_vbox(synctex_point_t hitPoint, synctex_node_t node, synctex_node_set_t* bestNodesRef,synctex_distances_t* bestDistancesRef,synctex_bool_t visible) {

int result = 0;

do {

int off7 = _synctex_point_v_distance(hitPoint,node,visible);/* this is what makes the difference with the h version above */

/* node is to the top of the hit point (below because TeX is oriented from top to bottom.

* We compare node and the previously recorded one, through the recorded distance.

* If the nodes have the same tag, prefer the one with the smallest line number,

* if the nodes also have the same line number, prefer the one with the smallest column. */

bestDistancesRef->right = off7;

bestNodesRef->right = node;

result |= SYNCTEX_MASK_RIGHT;

&& (SYNCTEX_LINE(bestNodesRef->right) > SYNCTEX_LINE(node)

|| (SYNCTEX_LINE(bestNodesRef->right) == SYNCTEX_LINE(node)

&& SYNCTEX_COLUMN(bestNodesRef->right) > SYNCTEX_COLUMN(node)))) {

result |= SYNCTEX_MASK_RIGHT;

}

}

bestDistancesRef->left = bestDistancesRef->right = 0;

bestNodesRef->left = node;

bestNodesRef->right = NULL;

result |= SYNCTEX_MASK_LEFT;

} else { /* here off7 < 0 */

off7 = -off7;

bestDistancesRef->left = off7;

bestNodesRef->left = node;

result |= SYNCTEX_MASK_LEFT;

&& (SYNCTEX_LINE(bestNodesRef->left) > SYNCTEX_LINE(node)

|| (SYNCTEX_LINE(bestNodesRef->left) == SYNCTEX_LINE(node)

&& SYNCTEX_COLUMN(bestNodesRef->left) > SYNCTEX_COLUMN(node)))) {

}

}

} while((node = SYNCTEX_SIBLING(node)));

/* the left node is new, try to narrow the result */

bestNodesRef->left = node;

}

bestNodesRef->left = node;

}

}

/* the right node is new, try to narrow the result */

bestNodesRef->right = node;

}

bestNodesRef->right = node;

}

}

return result;

}

SYNCTEX_INLINE static int _synctex_eq_get_closest_children_in_box(synctex_point_t hitPoint, synctex_node_t node, synctex_node_set_t* bestNodesRef,synctex_distances_t* bestDistancesRef,synctex_bool_t visible) {

switch(node->class->type) {

case synctex_node_type_hbox:

return __synctex_eq_get_closest_children_in_hbox(hitPoint, node, bestNodesRef, bestDistancesRef,visible);

SYNCTEX_INLINE static synctex_node_t __synctex_eq_closest_child(synctex_point_t hitPoint, synctex_node_t node,int* distanceRef, synctex_bool_t visible);

SYNCTEX_INLINE static synctex_node_t __synctex_eq_closest_child(synctex_point_t hitPoint, synctex_node_t node,int* distanceRef, synctex_bool_t visible) {

synctex_node_t best_node = NULL;

do {

int distance = _synctex_node_distance_to_point(hitPoint,node,visible);

synctex_node_t candidate = NULL;

*distanceRef = distance;

best_node = node;

}

switch(node->class->type) {

case synctex_node_type_vbox:

case synctex_node_type_hbox:

best_node = candidate;

}

}

return best_node;

}

SYNCTEX_INLINE static synctex_node_t _synctex_eq_closest_child(synctex_point_t hitPoint,synctex_node_t node, synctex_bool_t visible) {

switch(node->class->type) {

case synctex_node_type_hbox:

case synctex_node_type_vbox:

{

int best_distance = INT_MAX;

synctex_node_t best_node = __synctex_eq_closest_child(hitPoint,node,&best_distance,visible);

synctex_node_t child = NULL;

switch(best_node->class->type) {

case synctex_node_type_vbox:

case synctex_node_type_hbox:

best_distance = _synctex_node_distance_to_point(hitPoint,child,visible);

while((child = SYNCTEX_SIBLING(child))) {

int distance = _synctex_node_distance_to_point(hitPoint,child,visible);

best_distance = distance;

best_node = child;

}

synctex_updater_t synctex_updater_new_with_output_file(const char * output, const char * build_directory) {

synctex_updater_t updater = NULL;

char * synctex = NULL;

updater = (synctex_updater_t)_synctex_malloc(sizeof(synctex_updater_t));

_synctex_error("! synctex_updater_new_with_file: malloc problem");

return NULL;

}

return_on_error:

free(updater);

return NULL;

}

gzclose(SYNCTEX_FILE);

SYNCTEX_FILE = NULL;

no_write_error:

_synctex_error("! synctex_updater_new_with_file: Can't append to %s",synctex);

free(synctex);

}

updater->fprintf = (synctex_fprintf_t)(&fprintf);

} else {

goto no_write_error;

}

updater->fprintf = (synctex_fprintf_t)(&gzprintf);

void synctex_updater_append_magnification(synctex_updater_t updater, char * magnification){

return;

}

updater->length += SYNCTEX_fprintf(SYNCTEX_FILE,"Magnification:%s\n",magnification);

}

}

void synctex_updater_append_x_offset(synctex_updater_t updater, char * x_offset){

return;

}

updater->length += SYNCTEX_fprintf(SYNCTEX_FILE,"X Offset:%s\n",x_offset);

}

}

void synctex_updater_append_y_offset(synctex_updater_t updater, char * y_offset){

return;

}

updater->length += SYNCTEX_fprintf(SYNCTEX_FILE,"Y Offset:%s\n",y_offset);

}

}

void synctex_updater_free(synctex_updater_t updater){

return;

}

SYNCTEX_fprintf(SYNCTEX_FILE,"!%i\n",updater->length);

}

if (SYNCTEX_NO_GZ) {

/*

This file is part of the SyncTeX package.

See synctex_parser_readme.txt for more details

License:

* It is the directory where all the auxiliary stuff is created.

* Sometimes, the synctex output file and the pdf, dvi or xdv files are not created in the same directory.

* This is the case in MikTeX (I will include this into TeX Live).

* It can be either absolute or relative to the directory of the output pdf (dvi or xdv) file.

* If no synctex file is found in the same directory as the output file, then we try to find one in the build directory.

* Please note that this new "build_directory" is provided as a convenient argument but should not be used.

/*

This file is part of the SyncTeX package.

See synctex_parser_readme.txt for more details

License:

}

}

/* Compare two file names, windows is sometimes case insensitive... */

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

# if SYNCTEX_WINDOWS

/* On Windows, filename should be compared case insensitive.

* The characters '/' and '\' are both valid path separators.

* There is a list of possible filenames from which we return the most recent one and try to remove all the others.

* With two runs of pdftex or xetex we are sure the the synctex file is really the most appropriate.

*/

{

/* If output is already absolute, we just have to manage the quotes and the compress mode */

size_t size = 0;

/* Do we have a real base name ? */

/* Yes, we do. */

const char * temp = NULL;

struct stat buf;

* We start form the \0 terminating character and scan the string upward until we find a dot.

_synctex_error("! _synctex_get_name: Memory problem 1");

return -1;

}

_synctex_error("! _synctex_get_name: Copy problem 1");

return -2;

}

} else {

/* There is no path extension,

}

if(size>0) {

/* output contains more than one path component */

_synctex_error("! _synctex_get_name: Memory problem");

return -1;

}

_synctex_error("! _synctex_get_name: Copy problem");

return -2;

}

}

}

}

} else {

}

}

if(!_synctex_path_is_absolute(output) && build_directory && (size = strlen(build_directory))) {

temp = build_directory + size - 1;

if(_synctex_path_is_absolute(temp)) {

}

} else {

}

}

}

}

}

}

}

/* All the others names are properly set up... */

/* retain the most recently modified file */

if (stat(FILENAME, &buf)) { \

free(FILENAME);\

FILENAME = NULL;\

} \

}

# undef TEST

/* Free all the intermediate filenames, except the one that will be used as returned value. */

# define CLEAN_AND_REMOVE(FILENAME) \

free(FILENAME);\

FILENAME = NULL;\

}

# undef CLEAN_AND_REMOVE

return 0;

}

return -1;/* bad argument */

}

return -2;

}

/*

This file is part of the SyncTeX package.

See synctex_parser_readme.txt for more details

License:

# define synctex_bool_t int

# define synctex_YES -1

# define synctex_NO 0

#ifndef __SYNCTEX_PARSER_UTILS__

# define __SYNCTEX_PARSER_UTILS__

# else

# define SYNCTEX_IS_PATH_SEPARATOR(c) ('/' == c)

# endif

/* This custom malloc functions initializes to 0 the newly allocated memory.

* There is no bzero function on windows. */

void *_synctex_malloc(size_t size);

extern const char * synctex_suffix;

extern const char * synctex_suffix_gz;

typedef enum {

typedef enum {

synctex_compress_mode_none = 0,

synctex_compress_mode_gz = 1

} synctex_compress_mode_t;

#ifdef __cplusplus

}

#endif