char *skip_token(char *ptr)
{
ptr = skip_white(ptr);
ptr = skip_not_white(ptr);
ptr = skip_white(ptr);
return (ptr);
}
static void parse_comment( char* in, M3u_Playlist::info_t& info, bool first )
{
in = skip_white( in + 1 );
const char* field = in;
while ( *in && *in != ':' )
in++;
if ( *in == ':' )
{
const char* text = skip_white( in + 1 );
if ( *text )
{
*in = 0;
if ( !strcmp( "Composer", field ) ) info.composer = text;
else if ( !strcmp( "Engineer", field ) ) info.engineer = text;
else if ( !strcmp( "Ripping" , field ) ) info.ripping = text;
else if ( !strcmp( "Tagging" , field ) ) info.tagging = text;
else
text = 0;
if ( text )
return;
*in = ':';
}
}
if ( first )
info.title = field;
}
static void
read_lisp_symbol (FILE *infile, char *buffer)
{
char c;
char *fillp = buffer;
skip_white (infile);
while (1)
{
c = getc (infile);
if (c == '\\')
*(++fillp) = getc (infile);
else if (c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '(' || c == ')')
{
ungetc (c, infile);
*fillp = 0;
break;
}
else
*fillp++ = c;
}
if (! buffer[0])
fprintf (stderr, "## expected a symbol, got '%c'\n", c);
skip_white (infile);
}
static int parse_mask(lbind_Enum *et, const char *s, int *penum, lua_State *L) {
*penum = 0;
while (*s != '\0') {
const char *e;
int inversion = 0;
lbind_EnumItem *item;
s = skip_white(s);
if (*s == '~') {
inversion = 1;
s = skip_white(s+1);
}
if (*s == '\0') break;
e = skip_ident(s);
if (e == s || (item = lbind_findenum(et, s, e-s)) == NULL) {
if (L == NULL) return 0;
if (e == s)
return luaL_error(L, "unexpected token '%c' in %s", *s, et->name);
else {
lua_pushlstring(L, s, e-s);
return luaL_error(L, "unexpected mask '%s' in %s", lua_tostring(L, -1), et->name);
}
}
s = e;
if (inversion)
*penum &= ~item->value;
else
*penum |= item->value;
}
return 1;
}
pdf_obj *parse_pdf_array (char **start, char *end)
{
pdf_obj *result, *tmp1;
#ifdef MEM_DEBUG
MEM_START
#endif
skip_white(start, end);
if (*((*start)++) != '[')
return NULL;
result = pdf_new_array ();
skip_white(start, end);
while (*start < end &&
**start != ']') {
if ((tmp1 = parse_pdf_object (start, end)) == NULL) {
pdf_release_obj (result);
return NULL;
};
pdf_add_array (result, tmp1);
skip_white(start, end);
}
if (*start >= end) {
pdf_release_obj (result);
fprintf (stderr, "\nArray ended prematurely\n");
return NULL;
}
(*start)++;
#ifdef MEM_DEBUG
MEM_END
#endif
return result;
}
char *
jump_etc(char *op)
{ char *p = op;
/* try to get the type separated from the name */
p = skip_white(p); /* initial white space */
if (strncmp(p, "enum", strlen("enum")) == 0) /* special case: a two-part typename */
{ p += strlen("enum")+1;
p = skip_white(p);
}
p = skip_nonwhite(p); /* type name */
p = skip_white(p); /* white space */
while (*p == '*') p++; /* decorations */
p = skip_white(p); /* white space */
if (*p == '\0')
fatal("c_state format (%s)", op);
if (strchr(p, '[')
&& !strchr(p, '{'))
{ non_fatal("array initialization error, c_state (%s)", p);
return (char *) 0;
}
return p;
}
NODE*
parse_any(SCANNER *s, int mode) {
NODE *x = NULL;
int c;
skip_white(s);
if (s_eof(s)) return raise(s, "unexpected end of file");
c = s_peek(s);
if (c == '(') {
s_getc(s);
x = parse_paren(s, mode);
if (x == NULL) return NULL;
if (s_eof(s)) {
return raise(s, "unexpected end of file");
}
skip_white(s);
if (s_getc(s) != ')') {
return invalid_token(s);
}
} else if (c == '\'')
x = parse_quote(s);
else if (c == '`')
return parse_bquote(s);
else if (c == '"')
x = parse_string(s);
else if (isalnum((int)c) || strchr(SYMBOL_CHARS, c))
x = parse_primitive(s);
else
return invalid_token(s);
return x;
}
// Get next token.
static parse_ptr get_token(parse_ptr src, token_info & token, const char * path, int & line)
{
src = skip_white(src, path, line);
switch (*src) {
case '{': case '}': case ',':
// Simple token
token.type = *src; token.line = line;
++src;
break;
case '"':
// String constant
token.type = '"'; token.line = line;
token.value = "";
do {
for (++src; *src != '"'; ++src) {
char c = *src;
if (!c || c == '\n' || (c == '\\' && !src[1])) {
pout("%s(%d): Missing terminating '\"'\n", path, line);
token.type = '?'; token.line = line;
return src;
}
if (c == '\\') {
c = *++src;
switch (c) {
case 'n' : c = '\n'; break;
case '\n': ++line; break;
case '\\': case '"': break;
default:
pout("%s(%d): Unknown escape sequence '\\%c'\n", path, line, c);
token.type = '?'; token.line = line;
continue;
}
}
token.value += c;
}
// Lookahead to detect string constant concatentation
src = skip_white(++src, path, line);
} while (*src == '"');
break;
case 0:
// EOF
token.type = 0; token.line = line;
break;
default:
pout("%s(%d): Syntax error, invalid char '%c'\n", path, line, *src);
token.type = '?'; token.line = line;
while (*src && *src != '\n')
++src;
break;
}
return src;
}
// Parse next letter/number pair.
// Returns the remaining line or NULL if end reached.
static const char *gcodep_parse_pair_with_linenumber(int line_num,
const char *line,
char *letter, float *value,
FILE *err_stream) {
// TODO: error callback when we have errors with messages.
if (line == NULL)
return NULL;
line = skip_white(line);
if (*line == '\0' || *line == ';' || *line == '%')
return NULL;
if (*line == '(') { // Comment between words; e.g. G0(move) X1(this axis)
while (*line && *line != ')')
line++;
line = skip_white(line + 1);
if (*line == '\0') return NULL;
}
*letter = toupper(*line++);
if (*line == '\0') {
fprintf(err_stream ? err_stream : stderr,
"// Line %d G-Code Syntax Error: expected value after '%c'\n",
line_num, *letter);
return NULL;
}
// If this line has a checksum, we ignore it. In fact, the line is done.
if (*letter == '*')
return NULL;
while (*line && isspace(*line))
line++;
// Parsing with strtof() can be problematic if the line does
// not contain spaces, and strof() sees the sequence 0X... as it treats that
// as hex value. E.g. G0X1. Unlikely, but let's do a nasty workaround:
char *repair_x = (*(line+1) == 'x' || *(line+1) == 'X') ? (char*)line+1 : NULL;
if (repair_x) *repair_x = '\0'; // pretend that is the end of number.
char *endptr;
*value = strtof(line, &endptr);
if (repair_x) *repair_x = 'X'; // Put the 'X' back.
if (line == endptr) {
fprintf(err_stream ? err_stream : stderr, "// Line %d G-Code Syntax Error:"
" Letter '%c' is not followed by a number `%s`.\n",
line_num, *letter, line);
return NULL;
}
line = endptr;
line = skip_white(line); // Makes the line better to deal with.
return line; // We parsed something; return whatever is remaining.
}
char *
has_ident(const char *name,
char *first,
char *last)
{
char *base;
char *s, *t, *d, c;
name = leaf_of(name);
s = first;
while ((t = base = strchr(s, '$')) != 0 && (t < last)) {
t++;
if ((s = exact(skip_camel(t), "Id")) != 0
|| (s = exact(t, "Header")) != 0) {
if (*s == '$') {
return base;
} else if ((*s == ':')
&& is_inline(t, '$')) {
/* RCS identifier can have pathname prepended */
s = skip_white(s + 1);
d = skip_text(s);
c = *d;
*d = EOS;
while (is_inline(s, '/'))
s++;
*d = c;
if ((s = same_name(s, name)) != 0
&& (s = exact(s, ",v")) != 0
&& isspace(*s))
return base;
}
}
s = t;
}
s = first;
while ((t = base = strchr(s, '@')) != 0 && (t < last)) {
t++;
if ((s = exact(t, "(#)")) != NULL) {
t = s;
/* some versions of SCCS don't do module-name */
if ((s = same_name(t, name)) != NULL)
return base;
t = skip_text(t); /* module-name, if any */
t = skip_white(t);
if ((s = same_name(t, name)) != NULL)
return base;
}
s = t;
}
return 0;
}
NODE*
parse_paren(SCANNER *s, int mode) {
NODE *head, *node, *x;
skip_white(s);
if (s_eof(s)) return raise(s, "unexpected end of file");
head = node = new_node();
node->t = NODE_CELL;
while (!s_eof(s) && s_peek(s) != ')') {
NODE *child;
char q = s_peek(s) == ',';
if (q) s_getc(s);
child = parse_any(s, PARSE_ANY);
if (child == NULL) return NULL;
if ((mode & PARSE_BQUOTE) != 0 && !q) {
NODE *r = new_node();
r->t = NODE_QUOTE;
r->car = child;
child = r;
}
if (child->t == NODE_IDENT && !strcmp(".", child->s)) {
if (!head->car) {
free_node(child);
return raise(s, "illegal dot operation");
}
free_node(child);
child = parse_any(s, PARSE_ANY);
if (child == NULL) return NULL;
node->cdr = child;
break;
} else {
if (head->car) {
x = new_node();
x->t = NODE_CELL;
node->cdr = x;
node = x;
}
node->car = child;
}
skip_white(s);
}
if (!head->car && !head->cdr)
head->t = NODE_NIL;
return head;
}
pdf_obj *parse_pdf_dict (char **start, char *end)
{
pdf_obj *result, *tmp1, *tmp2;
char *save = *start;
skip_white(start, end);
if (*((*start)++) != '<' ||
*((*start)++) != '<') {
*start = save;
dump (*start, end);
return NULL;
}
result = pdf_new_dict ();
skip_white(start, end);
while (*start < end &&
**start != '>') {
if ((tmp1 = parse_pdf_name (start, end)) == NULL) {
pdf_release_obj (result);
{
*start = save;
dump (*start, end);
return NULL;
}
};
if ((tmp2 = parse_pdf_object (start, end)) == NULL) {
pdf_release_obj (result);
pdf_release_obj (tmp1);
{
*start = save;
dump (*start, end);
return NULL;
}
}
pdf_add_dict (result, tmp1, tmp2);
skip_white(start, end);
}
if (*start >= end) {
pdf_release_obj (result);
*start = save;
dump (*start, end);
return NULL;
}
if (*((*start)++) == '>' &&
*((*start)++) == '>') {
return result;
} else {
pdf_release_obj (result);
fprintf (stderr, "\nDictionary object ended prematurely\n");
*start = save;
dump (*start, end);
return NULL;
}
}
void
proc_parse_config(const char *token, char *cptr)
{
char tmpname[STRMAX];
struct myproc **procp = &procwatch;
/*
* don't allow two entries with the same name
*/
copy_nword(cptr, tmpname, sizeof(tmpname));
if (get_proc_by_name(tmpname) != NULL) {
config_perror("Already have an entry for this process.");
return;
}
/*
* skip past used ones
*/
while (*procp != NULL)
procp = &((*procp)->next);
(*procp) = (struct myproc *) calloc(1, sizeof(struct myproc));
if (*procp == NULL)
return; /* memory alloc error */
numprocs++;
/*
* not blank and not a comment
*/
copy_nword(cptr, (*procp)->name, sizeof((*procp)->name));
cptr = skip_not_white(cptr);
if ((cptr = skip_white(cptr))) {
(*procp)->max = atoi(cptr);
cptr = skip_not_white(cptr);
if ((cptr = skip_white(cptr)))
(*procp)->min = atoi(cptr);
else
(*procp)->min = 0;
} else {
/* Default to asssume that we require at least one
* such process to be running, but no upper limit */
(*procp)->max = 0;
(*procp)->min = 1;
/* This frees "proc <procname> 0 0" to monitor
* processes that should _not_ be running. */
}
#ifdef NETSNMP_PROCFIXCMD
sprintf((*procp)->fixcmd, NETSNMP_PROCFIXCMD, (*procp)->name);
#endif
DEBUGMSGTL(("ucd-snmp/proc", "Read: %s (%d) (%d)\n",
(*procp)->name, (*procp)->max, (*procp)->min));
}
static void parse_fmtargs(parse_info *info, int *wide, int *count) {
skip_white(info->fmt);
parse_optint(&info->fmt, wide);
skip_white(info->fmt);
if (*info->fmt == '*') {
++info->fmt;
skip_white(info->fmt);
parse_optint(&info->fmt, count);
}
else if (*info->fmt == '$') {
++info->fmt;
*count = -1;
}
skip_white(info->fmt);
}
static int parse_html_tag (char **start, char *end)
{
int result = -1;
char *token = NULL;
int closing = 0;
skip_white(start, end);
if (*start < end) {
if (**start == '/') {
(*start)++;
closing = 1;
}
if (*start < end && (token = parse_ident (start, end))) {
downcase (token);
{
int i;
for (i=0; i<sizeof(tags)/sizeof(tags[0]); i++) {
if (!strcmp (token, tags[i])) {
result = i;
if (closing)
result += sizeof(tags)/sizeof(tags[0]);
}
break;
}
if (i>=sizeof(tags)/sizeof(tags[0]))
result = -1;
}
RELEASE (token);
}
}
return result;
}
/**
* @internal
* parse mode: save everything
*/
void
_pm_save_everything(FILE *f, netsnmp_container *cin, int flags)
{
char line[STRINGMAX], *ptr;
size_t len;
netsnmp_assert(NULL != f);
netsnmp_assert(NULL != cin);
while (fgets(line, sizeof(line), f) != NULL) {
ptr = line;
len = strlen(line) - 1;
if (line[len] == '\n')
line[len] = 0;
/*
* save blank line or comment?
*/
if (flags & PM_FLAG_SKIP_WHITESPACE) {
if (NULL == (ptr = skip_white(ptr)))
continue;
}
ptr = strdup(line);
if (NULL == ptr) {
snmp_log(LOG_ERR,"malloc failed\n");
break;
}
CONTAINER_INSERT(cin,ptr);
}
}
Bool
str_to_bool(
char *ptr,
Bool def_val
)
{
if (!ptr || !*ptr) return def_val;
skip_white(ptr);
switch (*ptr) { /* true/false , 1/0 , yes/no , on/off */
case '1':
case 'T': case 't':
case 'Y': case 'y':
def_val = True; break;
case '0':
case 'F': case 'f':
case 'N': case 'n':
def_val = False; break;
case 'O': case 'o':
if (ptr[1] == 'N' || ptr[1] == 'n')
def_val = True;
else if (ptr[1] == 'F' || ptr[1] == 'f')
def_val = False;
break;
}
return def_val;
}
/* Read a single double in ascii (not locale) encoding.
*
* Return the char that caused failure on fail (EOF or \n).
*/
static int
read_ascii_double( FILE *fp, const char whitemap[256], double *out )
{
int ch;
char buf[256];
char *p;
*out = 0.0;
ch = skip_white( fp, whitemap );
if( ch == EOF ||
ch == '\n' )
return( ch );
fetch_nonwhite( fp, whitemap, buf, 256 );
/* The str we fetched must contain at least 1 digit. This helps stop
* us trying to convert "MATLAB" (for example) to a number and
* getting zero.
*/
for( p = buf; *p; p++ )
if( isdigit( *p ) )
break;
if( !*p )
return( *buf );
*out = g_ascii_strtod( buf, NULL );
return( 0 );
}
static char* parse_name( char* in )
{
char* out = in;
while ( 1 )
{
int c = *in;
if ( !c ) break;
in++;
if ( c == ',' ) // commas in string
{
char* p = skip_white( in );
if ( *p == ',' || *p == '-' || from_dec( *p ) <= 9 )
{
in = p;
break;
}
}
if ( c == '\\' ) // \ prefix for special characters
{
c = *in;
if ( !c ) break;
in++;
}
*out++ = (char) c;
}
*out = 0; // terminate string
return in;
}
float factor() {
float value;
float sign = 1.0;
if (*look == '-') {
sign = -1;
}
if (*look == '(') {
match('(');
value = expression();
match(')');
return value;
}
else if (is_alpha(*look)) {
switch (*look) {
case 'x': {
value = env.x;
} break;
case 'y': {
value = env.y;
} break;
}
get_char();
skip_white();
}
else {
value = get_num();
}
return sign*value;
}
void
se_read_conf(const char *word, char *cptr)
{
int major, minor;
int value;
char *cp, *cp2;
char e_name[BUFSIZ];
char e_enum[ BUFSIZ];
if (!cptr || *cptr=='\0')
return;
/*
* Extract the first token
* (which should be the name of the list)
*/
cp = copy_nword(cptr, e_name, sizeof(e_name));
cp = skip_white(cp);
if (!cp || *cp=='\0')
return;
/*
* Add each remaining enumeration to the list,
* using the appropriate style interface
*/
if (sscanf(e_name, "%d:%d", &major, &minor) == 2) {
/*
* Numeric major/minor style
*/
while (1) {
cp = copy_nword(cp, e_enum, sizeof(e_enum));
if (sscanf(e_enum, "%d:", &value) != 1) {
break;
}
cp2 = e_enum;
while (*(cp2++) != ':')
;
se_add_pair(major, minor, strdup(cp2), value);
if (!cp)
break;
}
} else {
/*
* Named enumeration
*/
while (1) {
cp = copy_nword(cp, e_enum, sizeof(e_enum));
if (sscanf(e_enum, "%d:", &value) != 1) {
break;
}
cp2 = e_enum;
while (*(cp2++) != ':')
;
se_add_pair_to_slist(e_name, strdup(cp2), value);
if (!cp)
break;
}
}
}
char *copy_word(char *from, char *to)
{
char quote;
if ( (*from == '\"') || (*from =='\'') ){
quote = *(from++);
while ( (*from != quote) && (*from != 0) ) {
if ((*from == '\\') && (*(from+1) != 0)) {
*to++ = *(from+1);
from = from +2;
}
else *to++ = *from++;
}
if (*from == 0) {
DEBUGMSGTL(("read_config_copy_word",
"no end quote found in config string\n"));
} else from++;
}
else {
while (*from != 0 && !isspace(*from)) {
if ((*from == '\\') && (*(from+1) != 0)) {
*to++ = *(from+1);
from = from +2;
}
else *to++ = *from++;
}
}
*to = 0;
from = skip_white(from);
return(from);
} /* copy_word */
int read_tag_line(
FILE *fp,
char **tagp,
char **valp
)
{
char *lp, *lp2;
while (fgets(lp = tag_linebuf, BUFSIZ, fp)) {
tag_line_num++;
skip_white(lp); /* lp = trim_line(lp); */
if (!*lp || *lp == '\n' || is_comment_char(*lp))
continue;
if (!(lp2 = strchr(lp, TAG_END_CHAR))) {
continue;
}
*lp2++ = 0;
lp2 = trim_line(lp2);
*tagp = lp;
*valp = *lp2 ? lp2 : 0;
return tag_line_num;
}
*tagp = *valp = 0;
return (ferror(fp)) ? -1 : 0;
}
char *parse_number (char **start, char *end)
{
char *number, *save;
#ifdef MEM_DEBUG
MEM_START
#endif
skip_white(start, end);
save = *start;
if (*start < end && (**start == '+' || **start == '-')) {
*start += 1;
}
while (*start < end &&
isdigit(**start))
(*start)++;
if (*start < end && **start == '.') {
(*start)++;
while (*start < end &&
isdigit(**start))
(*start)++;
}
if (*start > save) {
number = NEW ((*start-save)+1, char);
memcpy (number, save, (*start-save));
number[*start-save] = 0;
return number;
}
void
loadave_parse_config(const char *token, char *cptr)
{
int i;
if (strcmp(token, "pload") == 0) {
if (laConfigSet < 0) {
snmp_log(LOG_WARNING,
"ignoring attempted override of read-only load\n");
return;
} else {
laConfigSet++;
}
} else {
if (laConfigSet > 0) {
snmp_log(LOG_WARNING,
"ignoring attempted override of read-only load\n");
/*
* Fall through and copy in this value.
*/
}
laConfigSet = -1;
}
for (i = 0; i <= 2; i++) {
if (cptr != NULL)
maxload[i] = atof(cptr);
else
maxload[i] = maxload[i - 1];
cptr = skip_not_white(cptr);
cptr = skip_white(cptr);
}
}
void
proc_parse_config(const char *token, char *cptr)
{
char tmpname[STRMAX];
struct myproc **procp = &procwatch;
/*
* don't allow two entries with the same name
*/
copy_nword(cptr, tmpname, sizeof(tmpname));
if (get_proc_by_name(tmpname) != NULL) {
config_perror("Already have an entry for this process.");
return;
}
/*
* skip past used ones
*/
while (*procp != NULL)
procp = &((*procp)->next);
(*procp) = (struct myproc *) calloc(1, sizeof(struct myproc));
if (*procp == NULL)
return; /* memory alloc error */
numprocs++;
/*
* not blank and not a comment
*/
copy_nword(cptr, (*procp)->name, sizeof((*procp)->name));
cptr = skip_not_white(cptr);
if ((cptr = skip_white(cptr))) {
(*procp)->max = atoi(cptr);
cptr = skip_not_white(cptr);
if ((cptr = skip_white(cptr)))
(*procp)->min = atoi(cptr);
else
(*procp)->min = 0;
} else {
(*procp)->max = 0;
(*procp)->min = 0;
}
#ifdef NETSNMP_PROCFIXCMD
sprintf((*procp)->fixcmd, NETSNMP_PROCFIXCMD, (*procp)->name);
#endif
DEBUGMSGTL(("ucd-snmp/proc", "Read: %s (%d) (%d)\n",
(*procp)->name, (*procp)->max, (*procp)->min));
}
/* Read a single item. Syntax is:
*
* element :
* whitespace* item whitespace* [EOF|EOL|separator]
*
* item :
* double |
* "anything" |
* empty
*
* the anything in quotes can contain " escaped with \
*
* Return the char that caused failure on fail (EOF or \n).
*/
static int
read_double( FILE *fp, const char whitemap[256], const char sepmap[256],
int lineno, int colno, double *out )
{
int ch;
/* The fscanf() may change this ... but all other cases need a zero.
*/
*out = 0;
ch = skip_white( fp, whitemap );
if( ch == EOF ||
ch == '\n' )
return( ch );
if( ch == '"' ) {
(void) fgetc( fp );
(void) skip_to_quote( fp );
ch = fgetc( fp );
}
else if( !sepmap[ch] &&
fscanf( fp, "%lf", out ) != 1 ) {
/* Only a warning, since (for example) exported spreadsheets
* will often have text or date fields.
*/
vips_warn( "csv2vips",
_( "error parsing number, line %d, column %d" ),
lineno, colno );
/* Step over the bad data to the next separator.
*/
ch = skip_to_sep( fp, sepmap );
}
/* Don't need to check result, we have read a field successfully.
*/
ch = skip_white( fp, whitemap );
/* If it's a separator, we have to step over it.
*/
if( ch != EOF &&
sepmap[ch] )
(void) fgetc( fp );
return( 0 );
}
char get_name() {
if (!is_alpha(*look))
expected("name");
char ret = *look;
get_char();
skip_white();
return ret;
}
void parse_crap (char **start, char *end)
{
skip_white(start, end);
if (*start != end) {
fprintf (stderr, "\nCrap left over after object!!\n");
dump(*start, end);
}
}
static int
trim_opening_comment(
BFile file,
long *funcOffPtr,
long *funcLenPtr,
long protoOff
)
{
#define funcOff (*funcOffPtr)
#define funcLen (*funcLenPtr)
long startOff = bfile_get_off(file);
long newCommentOff = -1;
long commentOff = -1;
long funcLenDiff = 0;
long newFuncOff = 0;
COMMENT_TYPE commentType;
BOOL done = FALSE;
bfile_set_off(file, funcOff);
bfile_forward(file);
while (!done)
{
commentType = find_comment_start(file, &newCommentOff);
if ( (commentType == COMMENT_UNDEF)
|| (newCommentOff >= protoOff) )
{
done = TRUE;
}
else
{
commentOff = newCommentOff;
skip_comment(file, commentType);
}
}
if (commentOff > 0)
{
funcLenDiff = (funcOff - commentOff);
funcOff = commentOff;
funcLen += funcLenDiff;
}
/*
* trim white space
*/
bfile_set_off(file, funcOff);
skip_white(file);
newFuncOff = bfile_get_off(file);
funcLenDiff = (funcOff - newFuncOff);
funcOff = newFuncOff;
funcLen += funcLenDiff;
bfile_set_off(file, startOff);
return 0;
#undef funcOff
#undef funcLen
}
