size_t read_pgm_header_int(std::istream &ifile)
{
char c;
size_t x = 0;
bool has_number = false;
while(ifile){
ifile.read(&c,1);
if (c==' ' || c=='\t' || c=='\r' || c=='\n'){
if (has_number)
break;
else
continue;
}
if (c >= '0' && c <= '9'){
has_number=true;
x = x*10 + (size_t)(c - '0');
continue;
}
if (c == '#'){
skip_to_eol(ifile);
continue;
}
throw std::logic_error( "unexpected character in PGM file");
}
return x;
}
inline static bool is_function( char* cur, bool& isAMacro )
{
isAMacro = false;
int tmpLnNo;
store_line_no( tmpLnNo );
// NOTE:: comments and quoted strings are not checked here
// first,check for "single-line hanginging macros" like:
// ___UNICODE
//
char* eol = cur;
skip_to_eol( eol );
skip_token( cur );
get_next_token( cur );
if ( cur > eol )
{
isAMacro = true;
restore_line_no( tmpLnNo );
return true;
}
// it's not a macro, go to the begining of arg. list
do
{
// if bracket found, it's a function or a begining
// of some macro
if ( *cur == '(' )
{
restore_line_no( tmpLnNo );
return true;
}
// end of statement found without any brackets in it
// - it cannot be a function
if ( *cur == ';' )
{
restore_line_no( tmpLnNo );
return false;
}
++cur;
} while( cur < _gSrcEnd);
isAMacro = 1;
restore_line_no( tmpLnNo );
return false;
}
static int
parse_config(gnc_t gnc, void *closure)
{
int c;
char *token;
c = gnc(closure);
if(c < 2)
return -1;
while(c >= 0) {
c = skip_whitespace(c, gnc, closure);
if(c == '\n' || c == '#') {
c = skip_to_eol(c, gnc, closure);
continue;
}
if(c < 0)
break;
c = getword(c, &token, gnc, closure);
if(c < -1)
return -1;
if(strcmp(token, "in") == 0) {
struct filter *filter;
filter = parse_filter(gnc, closure);
if(filter == NULL)
return -1;
add_filter(filter, &input_filters);
} else if(strcmp(token, "out") == 0) {
struct filter *filter;
filter = parse_filter(gnc, closure);
if(filter == NULL)
return -1;
add_filter(filter, &output_filters);
} else if(strcmp(token, "redistribute") == 0) {
struct filter *filter;
filter = parse_filter(gnc, closure);
if(filter == NULL)
return -1;
add_filter(filter, &redistribute_filters);
} else if(strcmp(token, "interface") == 0) {
struct network_conf *nconf;
nconf = parse_nconf(gnc, closure);
if(nconf == NULL)
return -1;
add_nconf(nconf, &network_confs);
} else {
return -1;
}
free(token);
}
return 1;
}
void do_model (FILE* f, FILE* f_out_m, int& nm)
{
nm = 0;
skip_to_eol (f);
bool nt_found = false;
for (int lnum = 1;; lnum++)
{
char* line;
fgets_no_control_m (&line, f);
if (feof(f)) break;
char** words;
int n_words;
split_by_delimiter (line, &words, &n_words, "\t");
if (n_words >= 1) trim (words[1]);
if (n_words >= 2) trim (words[1]);
if (strequal (words[1], "Number of Trials"))
{
nt_found = true;
if (n_words == 1)
{
fprintf (f_out_m, "1\t%d\t%s\n", lnum, "no value given");
++nm;
}
else
{
int v;
bool ok;
atoi(words[2], &v, &ok);
if (!ok || (ok && v < 0))
{
fprintf (f_out_m, "1\t%d\t%s\n",
lnum, "value must be a positive integer");
++nm;
}
}
}
}
if (!nt_found)
{
fprintf (f_out_m, "1\t0\t%s\n", "'Number of Trials' not defined");
++nm;
}
}
static int
skip_eol(int c, gnc_t gnc, void *closure)
{
c = skip_whitespace(c, gnc, closure);
if(c == '\n' || c == '#') {
c = skip_to_eol(c, gnc, closure);
return c;
} else if(c == -1) {
return -1;
} else {
return -2;
}
}
static inline void skip_preprocessor_dir( wxChar*& cur )
{
do
{
skip_to_eol(cur);
if ( *(cur-1) != _T('\\') )
break;
if ( cur < _gSrcEnd )
skip_eol( cur );
else
break;
} while(1);
}
static int
get_token(FILE *cfile)
{
int c, ttok;
static char tb[2];
int l, p;
do {
l = line;
p = lpos;
c = get_char(cfile);
if (isascii(c) && isspace(c))
continue;
if (c == '#') {
skip_to_eol(cfile);
continue;
}
if (c == '"') {
lexline = l;
lexchar = p;
ttok = read_string(cfile);
break;
}
if ((isascii(c) && isdigit(c)) || c == '-') {
lexline = l;
lexchar = p;
ttok = read_number(c, cfile);
break;
} else if (isascii(c) && isalpha(c)) {
lexline = l;
lexchar = p;
ttok = read_num_or_name(c, cfile);
break;
} else {
lexline = l;
lexchar = p;
tb[0] = c;
tb[1] = 0;
tval = tb;
ttok = c;
break;
}
} while (1);
return (ttok);
}
static int readline (FILE *fp, Buffer_Type *b) /*{{{*/
{
if (-1 == init_buf (b))
return -1;
b->len = 0;
for (;;)
{
int ch = getc (fp);
switch (ch)
{
case COMMENT_CHAR:
b->buf[b->len] = 0;
if (-1 == skip_to_eol (fp))
return -1;
return b->len ? 0 : COMMENT_CHAR;
case '\n':
b->buf[b->len] = 0;
return 0;
case EOF:
b->buf[b->len] = 0;
return -1;
default:
b->buf[b->len++] = ch;
break;
}
if (b->len == b->bufsize)
{
unsigned int new_size = b->bufsize * 2 * sizeof(char);
char *tmp;
if (NULL == (tmp = (char *) ISIS_REALLOC (b->buf, new_size)))
return -1;
b->buf = tmp;
b->bufsize *= 2;
}
}
}
int main(int argc, char *argv[])
{
struct token_s *token;
FILE *fp;
STRBUF *sb;
struct token_s **tokens=NULL;
size_t ntokens=0;
struct node_s root_node;
int lno=1, cno=0;
struct token_s end_token={NULL, 0, TT_END, 0, 0, NULL, 0, 0};
const char *testmodule=NULL, *testcode=NULL;
size_t parsed;
if (argc>1 && !strcmp(argv[1], "-t")) {
if (argc>2) testmodule=argv[2];
if (argc>3) testcode=argv[3];
test(testmodule, testcode);
return EXIT_SUCCESS;
}
sb=sballoc(1024);
if (argc>1) fp=fopen(argv[1], "r");
else fp=stdin;
if (!fp) {
fprintf(stderr, "ERROR: Can\'t open file %s for reading\n", argv[1]);
return EXIT_FAILURE;
}
while ((token=gettoken(fp, sb, &lno, &cno))) {
/* TODO: Handle TT_UNKNOWN as error in the future */
if (token->type==TT_PREPROCESSOR) {
skip_to_eol(fp, sb, &lno, &cno);
continue;
}
if (!istobeignored(token) && token->type!=TT_NULL) {
//(void)puts(" Added");
tokens=(struct token_s **)realloc(tokens, ++ntokens * sizeof *tokens);
tokens[ntokens-1]=token;
}
}
tokens=(struct token_s **)realloc(tokens, ++ntokens * sizeof *tokens);
tokens[ntokens-1]=&end_token;
memset(&root_node, 0, sizeof root_node);
root_node.type=NT_ROOT;
parsed=parse(&root_node, tokens);
//printf(" ====== Nodes (JSON)\n");
print_node_json(&root_node, 0);
putchar('\n');
/*(void)getchar();*/
(void)sbfree(sb);
printf("tokens=%d, parsed=%d\n", (int)ntokens-1, (int)parsed);
return (ntokens-1u)==parsed ? EXIT_SUCCESS : EXIT_FAILURE;
}
spFile* CJSourceParser::Parse( char* start, char* end )
{
// set up state variables
mCurVis = SP_VIS_PRIVATE;
spFile* pTopCtx = new spFile();
mpCurCtx = pTopCtx;
mIsVirtual = 0;
mIsTemplate = 0;
mNestingLevel = 0;
m_cur = start;
mpStart = start;
mpEnd = end;
_gSrcEnd = mpEnd; // let all the C-functions "smell" the end of file
_gSrcStart = start;
_gLineNo = 0;
clear_commets_queue();
// main parsing loop
do
{
if ( !get_next_token( m_cur ) )
// end of source reached
return pTopCtx;
if ( memcmp( m_cur, "ScriptSection( const string&",
strlen( "ScriptSection( const string&" )
) == 0
)
{
// int o = 0;
// ++o;
}
switch (*m_cur)
{
case '#' :
{
AddMacroNode( m_cur );
continue;
}
case ':' :
{
skip_token( m_cur );
continue;
}
case ';' :
{
skip_token( m_cur );
continue;
}
case ')' :
{
skip_token( m_cur );
continue;
}
case '=' :
{
skip_token( m_cur );
continue;
}
default: break;
}
// 'const' is a part of the return type, not a keyword here
if ( strncmp(m_cur, "const", 5) != 0 && is_keyword( m_cur ) )
{
// parses, token, if token identifies
// the container context (e.g. class/namespace)
// the corresponding context object is created
// and set as current context
ParseKeyword( m_cur );
continue;
}
if ( *m_cur >= _T('0') && *m_cur <= _T('9') )
{
skip_token( m_cur );
continue;
}
if ( *m_cur == _T('}') )
{
if ( mCurCtxType != SP_CTX_CLASS )
{
// FOR NOW:: disable the below assertion
// DBG:: unexpected closing-bracket found
//ASSERT(0);
skip_token( m_cur ); // just skip it
continue;
}
if ( mpCurCtx->GetType() == SP_CTX_CLASS )
{
int curOfs = ( (m_cur+1) - _gSrcStart );
mpCurCtx->mContextLength = ( curOfs - mpCurCtx->mSrcOffset );
}
--mNestingLevel;
// terminate operation/class/namespace context
// TBD:: check if it's really this type of context
wxASSERT( mpCurCtx );
mpCurCtx = mpCurCtx->GetOutterContext();
wxASSERT( mpCurCtx );
if ( mNestingLevel == 0 )
{
mCurCtxType = SP_CTX_FILE;
// not-nested class delclaration finished,
// rest template flag in any case
mIsTemplate = 0;
}
skip_token( m_cur );
continue;
}
bool isAMacro = false;
if ( is_function( m_cur, isAMacro ) )
{
if ( isAMacro )
{
skip_token( m_cur );
continue;
}
char* savedPos = m_cur;
int tmpLnNo;
store_line_no( tmpLnNo );
wxUnusedVar( tmpLnNo );
isAMacro = false;
if ( !ParseNameAndRetVal( m_cur, isAMacro ) )
{
if ( !isAMacro )
{
m_cur = savedPos;
SkipFunction( m_cur );
}
continue;
}
if ( !ParseArguments( m_cur ) )
{
// failure while parsing arguments,
// remove enclosing operation context
spContext* pFailed = mpCurCtx;
mpCurCtx = mpCurCtx->GetOutterContext();
mpCurCtx->RemoveChild( pFailed );
skip_to_eol( m_cur );
//m_cur = savedPos;
}
else
{
// otherwise, successfully close operation context:
clear_commets_queue();
SkipFunctionBody( m_cur );
mpCurCtx = mpCurCtx->GetOutterContext();
// DBG::
wxASSERT( mpCurCtx );
}
}
else // otherwise it's declaration of a variable;
{
// now, the cursor point to the end of statement (';' token)
if ( mCurCtxType != SP_CTX_CLASS )
{
// non-class members are ignored
skip_token( m_cur ); // skip the end of statement
continue;
}
ParseMemberVar( m_cur );
}
} while( 1 );
}
int main(int argc, const char *argv[])
{
#define MAXINCDIR 1024
#define MAXFILE 16384
const char *incdirlist[MAXINCDIR];
char *filelist[MAXFILE];
int nincdir, nfiles;
DIR *dirp;
struct dirent *ent;
/* This code used to append dependencies to the makefiles.
Now it generates dependencies on STDOUT and does not
mess with the makefiles at all. However, the old stuff
is left in here just in case. To recover the old version
recompile with -DAPPENDMAKEFILE */
#ifdef ADDPENDMAKEFILE
/* Figure out the name of the makefile */
if (access("makefile",R_OK|W_OK) == 0)
makefile = "makefile";
else if (access("Makefile",R_OK|W_OK) == 0)
makefile = "Makefile";
else {
fprintf(stderr,"dependencies: makefile/Makefile not found\n");
exit(1);
}
/* Make a backup copy */
copy_file(makefile, backup);
/* Reopen the makefile as standard output, copy the backup
over it truncating before the magic line. Write the magic
line and then do the dependency analysis */
if (!freopen(makefile, "w", stdout)) {
perror("dependencies: failed reopening stdout");
exit(1);
}
copy_truncate_makefile(backup);
#endif
/* Extract list of include paths */
nincdir = 1; incdirlist[0] = ".";
while (argc > 1) {
argc--;
if (strncmp("-I",argv[argc],2) == 0) {
if (nincdir >= MAXINCDIR) {
fprintf(stderr,"dependencies: too many include directories\n");
restore_and_error_exit();
}
incdirlist[nincdir++] = argv[argc]+2;
}
else {
fprintf(stderr,"usage: dependencies [-Idir] [-Idir] ...\n");
restore_and_error_exit();
}
}
/* Generate list of .F or .c files in the current directory
... don't acutually need to store the list but it is convenient */
if (!(dirp = opendir("."))) {
perror("dependencies: failed to open current directory");
restore_and_error_exit();
}
nfiles = 0;
while ((ent = readdir(dirp))) {
char *name = ent->d_name;
int len = strlen(name);
if ( (strncmp(".c",name+len-2,2) == 0) ||
(strncmp(".F",name+len-2,2) == 0)) {
if (nfiles >= MAXFILE) {
fprintf(stderr,"dependencies: too many files\n");
restore_and_error_exit();
}
filelist[nfiles++] = strdup(name);
}
}
(void) closedir(dirp);
/* Loop thru files */
while (nfiles--) {
char *name = filelist[nfiles];
char *objname = strdup(name);
FILE *file;
int i;
#define MAXINCFILE 8192
char *incfiles[MAXINCFILE];
int nincfile;
int prev;
objname[strlen(objname)-1] = 'o';
/* Form sorted list of unique include files */
/* printf("%d\t%s\n",nfiles,name); */
if (!(file = fopen(name,"r"))) {
fprintf(stderr,"dependencies: failed to open %s : ",name);
perror(" ");
restore_and_error_exit();
}
nincfile = 0;
while ((i = getc(file)) != EOF) {
char *tmp;
/************************************************************************\
Original code:
if (i == '#')
if ((tmp = include_directive(file))) {
if (nincfile >= MAXINCFILE) {
fprintf(stderr,"dependencies: too many includes\n");
restore_and_error_exit();
}
incfiles[nincfile++] = tmp;
}
else
skip_to_eol(file);
\***********************************************************************/
/* makeing sure that # is the first character takes care of fortran comments
but it does not take care of c style comments or includes that are dependent
upon cpp flags. The latter is the difficult one.
*/
if (i == '#')
{
if ((tmp = include_directive(file))) {
if (nincfile >= MAXINCFILE) {
fprintf(stderr,"dependencies: too many includes\n");
restore_and_error_exit();
}
incfiles[nincfile++] = tmp;
}
}
/* else *\
removed this "else" because
include_directive stops after
the second '"' and not the end
of the line. Therefore all
lines parsed must go to EOL.
\* */
skip_to_eol(file);
}
fclose(file);
if (nincfile == 0) /* If no included files skip this file */
continue;
printf("$(LIBRARY_PATH)(%s):\t",objname);
qsort(incfiles, nincfile, sizeof(char *), compar);
prev = 0; /* Remove and free duplicates */
for (i=1; i<nincfile; i++) {
if (strcmp(incfiles[i],incfiles[prev]) == 0) {
free(incfiles[i]);
incfiles[i] = 0; /* For paranoia */
}
else
incfiles[++prev] = incfiles[i];
}
nincfile = prev + 1;
/* Loop thru the include files figuring out where each is */
while (nincfile--) {
char *incname = incfiles[nincfile];
char path[256];
for (i=0; i<nincdir; i++) {
(void) sprintf(path, "%s/%s", incdirlist[i], incname);
if (access(path, R_OK) == 0) {
break;
}
path[0] = 0;
}
if (!path[0]) {
(void) sprintf(path, "$(INCDIR)/%s", incname);
}
/* Skip mpif.h header since it is an external header. */
if (0 != strcmp(incname, "mpif.h")) {
printf("%s ",path);
}
free(incname);
}
printf("\n");
free(objname);
}
return 0;
}
int main()
{
/*
__xdata uint8_t *xp;
__sfr *sp;
*/
init_serial_1();
printf("Started\n");
while(1) {
do {
char c;
skip_white();
c = getchar();
if (c == 'r') {
__data uint8_t *p;
uint16_t l;
p = (__data uint8_t*)get_hex();
if (skip_space()) break;
l = get_hex();
while(l > 0) {
printf(" %02x", *p);
p++;
l--;
}
} else if (c == 'i') {
uint8_t p;
uint8_t v = 0;
if (skip_space()) break;
p = get_hex();
switch(p) {
case 0:
v = P0;
break;
case 1:
v = P1;
break;
case 2:
v = P2;
break;
case 3:
v = P3;
break;
case 4:
v = P4;
break;
case 5:
v = P5;
break;
case 6:
v = P6;
break;
case 7:
v = P7;
break;
case 8:
v = P8;
break;
}
printf(" %02x", v);
} else if (c == 'o') {
uint8_t p;
uint8_t v = 0;
if (skip_space()) break;
p = get_hex();
if (skip_space()) break;
v = get_hex();
switch(p) {
case 0:
P0 = v;
break;
case 1:
P1 = v;
break;
case 2:
P2 = v;
break;
case 3:
P3 = v;
break;
case 4:
P4 = v;
break;
case 5:
P5 = v;
break;
case 6:
P6 = v;
break;
}
} else if (c == 'R') {
__xdata uint8_t *p;
uint16_t l;
p = (__xdata uint8_t*)get_hex();
if (skip_space()) break;
l = get_hex();
while(l > 0) {
printf(" %02x", *p);
p++;
l--;
}
} else if (c == 'W') {
__xdata uint8_t *p;
uint8_t v;
p = (__xdata uint8_t*)get_hex();
while(1) {
if (skip_space()) break;
v = get_hex();
*p++ = v;
}
} else if (c == 'c') { /* Call a subroutine */
uint16_t a;
a = get_hex();
((GenericCall)a)();
}
} while(0);
skip_to_eol();
putchar('\n');
putchar('>');
}
}
static struct network_conf *
parse_nconf(gnc_t gnc, void *closure)
{
int c;
char *token;
struct network_conf *nconf;
nconf = calloc(1, sizeof(struct network_conf));
if(nconf == NULL)
goto error;
c = gnc(closure);
if(c < -1)
goto error;
c = skip_whitespace(c, gnc, closure);
if(c < -1 || c == '\n' || c == '#')
goto error;
c = getstring(c, &token, gnc, closure);
if(c < -1 || token == NULL)
goto error;
nconf->ifname = token;
while(c >= 0 && c != '\n') {
c = skip_whitespace(c, gnc, closure);
if(c == '\n' || c == '#') {
c = skip_to_eol(c, gnc, closure);
break;
}
c = getword(c, &token, gnc, closure);
if(c < -1)
goto error;
if(strcmp(token, "rxcost") == 0) {
int cost;
c = getint(c, &cost, gnc, closure);
if(c < -1 || cost <= 0 || cost > 0xFFFF)
goto error;
nconf->cost = cost;
} else if(strcmp(token, "hello-interval") == 0) {
int interval;
c = getmsec(c, &interval, gnc, closure);
if(c < -1 || interval <= 0 || interval > 10 * 0xFFFF)
goto error;
nconf->hello_interval = interval;
} else if(strcmp(token, "update-interval") == 0) {
int interval;
c = getmsec(c, &interval, gnc, closure);
if(c < -1 || interval <= 0 || interval > 10 * 0xFFFF)
goto error;
nconf->update_interval = interval;
} else if(strcmp(token, "wired") == 0) {
int v;
c = getbool(c, &v, gnc, closure);
if(c < -1)
goto error;
nconf->wired = v;
} else if(strcmp(token, "link-quality") == 0) {
int v;
c = getbool(c, &v, gnc, closure);
if(c < -1)
goto error;
nconf->lq = v;
} else if(strcmp(token, "split-horizon") == 0) {
int v;
c = getbool(c, &v, gnc, closure);
if(c < -1)
goto error;
nconf->split_horizon = v;
} else {
goto error;
}
free(token);
}
return nconf;
error:
free(nconf);
return NULL;
}
static struct filter *
parse_filter(gnc_t gnc, void *closure)
{
int c;
char *token;
struct filter *filter;
filter = calloc(1, sizeof(struct filter));
if(filter == NULL)
goto error;
filter->plen_le = 128;
c = gnc(closure);
if(c < -1)
goto error;
while(c >= 0 && c != '\n') {
c = skip_whitespace(c, gnc, closure);
if(c == '\n' || c == '#') {
c = skip_to_eol(c, gnc, closure);
break;
}
c = getword(c, &token, gnc, closure);
if(c < -1)
goto error;
if(strcmp(token, "ip") == 0) {
c = getnet(c, &filter->prefix, &filter->plen, &filter->af,
gnc, closure);
if(c < -1)
goto error;
} else if(strcmp(token, "eq") == 0) {
int p;
c = getint(c, &p, gnc, closure);
if(c < -1)
goto error;
filter->plen_ge = MAX(filter->plen_ge, p);
filter->plen_le = MIN(filter->plen_le, p);
} else if(strcmp(token, "le") == 0) {
int p;
c = getint(c, &p, gnc, closure);
if(c < -1)
goto error;
filter->plen_le = MIN(filter->plen_le, p);
} else if(strcmp(token, "ge") == 0) {
int p;
c = getint(c, &p, gnc, closure);
if(c < -1)
goto error;
filter->plen_ge = MAX(filter->plen_ge, p);
} else if(strcmp(token, "neigh") == 0) {
unsigned char *neigh;
c = getip(c, &neigh, NULL, gnc, closure);
if(c < -1)
goto error;
filter->neigh = neigh;
} else if(strcmp(token, "id") == 0) {
unsigned char *id;
c = getid(c, &id, gnc, closure);
if(c < -1)
goto error;
filter->id = id;
} else if(strcmp(token, "proto") == 0) {
int proto;
c = getint(c, &proto, gnc, closure);
if(c < -1)
goto error;
filter->proto = proto;
} else if(strcmp(token, "local") == 0) {
filter->proto = RTPROT_BABEL_LOCAL;
} else if(strcmp(token, "if") == 0) {
char *interface;
c = getstring(c, &interface, gnc, closure);
if(c < -1)
goto error;
filter->ifname = interface;
filter->ifindex = if_nametoindex(interface);
} else if(strcmp(token, "allow") == 0) {
filter->result = 0;
} else if(strcmp(token, "deny") == 0) {
filter->result = INFINITY;
} else if(strcmp(token, "metric") == 0) {
int metric;
c = getint(c, &metric, gnc, closure);
if(c < -1) goto error;
if(metric <= 0 || metric > INFINITY)
goto error;
filter->result = metric;
} else {
goto error;
}
free(token);
}
if(filter->af == 0) {
if(filter->plen_le < 128 || filter->plen_ge > 0)
filter->af = AF_INET6;
} else if(filter->af == AF_INET) {
filter->plen_le += 96;
filter->plen_ge += 96;
}
return filter;
error:
free(filter);
return NULL;
}
/**
* Read a keyword skipping bind comments; spaces, specials, restkeywords.
* The file is split into the following tokens:
* * special characters, on their own, rdlen=1, { } doublequote ;
* * whitespace becomes a single ' ' or tab. Newlines become spaces.
* * other words ('keywords')
* * comments are skipped if desired
* / / C++ style comment to end of line
* # to end of line
* / * C style comment * /
* @param in: file to read from.
* @param buf: buffer, what is read is stored after current buffer position.
* Space is left in the buffer to write a terminating 0.
* @param line: line number is increased per line, for error reports.
* @param comments: if 0, comments are not possible and become text.
* if 1, comments are skipped entirely.
* In BIND files, this is when reading quoted strings, for example
* " base 64 text with / / in there "
* @return the number of character written to the buffer.
* 0 on end of file.
*/
static int
readkeyword_bindfile(FILE* in, ldns_buffer* buf, int* line, int comments)
{
int c;
int numdone = 0;
while((c = getc(in)) != EOF ) {
if(comments && c == '#') { /* # blabla */
skip_to_eol(in);
(*line)++;
continue;
} else if(comments && c=='/' && numdone>0 && /* /_/ bla*/
ldns_buffer_read_u8_at(buf,
ldns_buffer_position(buf)-1) == '/') {
ldns_buffer_skip(buf, -1);
numdone--;
skip_to_eol(in);
(*line)++;
continue;
} else if(comments && c=='*' && numdone>0 && /* /_* bla *_/ */
ldns_buffer_read_u8_at(buf,
ldns_buffer_position(buf)-1) == '/') {
ldns_buffer_skip(buf, -1);
numdone--;
/* skip to end of comment */
while(c != EOF && (c=getc(in)) != EOF ) {
if(c == '*') {
if((c=getc(in)) == '/')
break;
}
if(c == '\n')
(*line)++;
}
continue;
}
/* not a comment, complete the keyword */
if(numdone > 0) {
/* check same type */
if(isspace(c)) {
ungetc(c, in);
return numdone;
}
if(is_bind_special(c)) {
ungetc(c, in);
return numdone;
}
}
if(c == '\n') {
c = ' ';
(*line)++;
}
/* space for 1 char + 0 string terminator */
if(ldns_buffer_remaining(buf) < 2) {
fatal_exit("trusted-keys, %d, string too long", *line);
}
ldns_buffer_write_u8(buf, (uint8_t)c);
numdone++;
if(isspace(c)) {
/* collate whitespace into ' ' */
while((c = getc(in)) != EOF ) {
if(c == '\n')
(*line)++;
if(!isspace(c)) {
ungetc(c, in);
break;
}
}
return numdone;
}
if(is_bind_special(c))
return numdone;
}
return numdone;
}
static int
parse_config(gnc_t gnc, void *closure)
{
int c;
char *token;
c = gnc(closure);
if(c < 2)
return -1;
while(c >= 0) {
c = skip_whitespace(c, gnc, closure);
if(c == '\n' || c == '#') {
c = skip_to_eol(c, gnc, closure);
continue;
}
if(c < 0)
break;
c = getword(c, &token, gnc, closure);
if(c < -1)
return -1;
if(strcmp(token, "mode") == 0) {
char *mtoken;
c = getword(c, &mtoken, gnc, closure);
if(c < -1)
return -1;
if(strcmp(mtoken, "server") == 0) {
#ifndef NO_SERVER
client_config = 0;
if(!server_config)
server_config = calloc(1, sizeof(struct server_config));
if(!server_config)
return -1;
#else
return -1;
#endif
} else if(strcmp(mtoken, "client") == 0) {
if(server_config)
return -1;
client_config = 1;
} else if(strcmp(mtoken, "forwarder") == 0) {
if(server_config)
return -1;
client_config = 0;
} else {
return -1;
}
free(mtoken);
c = skip_eol(c, gnc, closure);
if(c < -1)
return -1;
} else if(strcmp(token, "lease-dir") == 0) {
char *dir;
if(!server_config)
return -1;
c = getstring(c, &dir, gnc, closure);
if(c < -1)
return -1;
if(dir[0] != '/')
return -1;
server_config->lease_dir = dir;
c = skip_eol(c, gnc, closure);
if(c < -1)
return -1;
} else if(strcmp(token, "prefix") == 0) {
char *ptoken;
struct prefix_list *prefix;
if(!server_config)
return -1;
c = getword(c, &ptoken, gnc, closure);
if(c < -1)
return -1;
prefix = parse_prefix(ptoken, PREFIX);
if(prefix == NULL || prefix->n != 1)
return -1;
if(prefix_list_v4(prefix)) {
unsigned const char zeroes[4] = {0};
unsigned mask, first, last;
if(memcmp(server_config->lease_first, zeroes, 4) != 0)
return -1;
mask = 0xFFFFFFFF << (128 - prefix->l[0].plen);
first =
(prefix->l[0].p[12] << 24 |
prefix->l[0].p[13] << 16 |
prefix->l[0].p[14] << 8 |
prefix->l[0].p[15] ) & mask;
last = first | (~ mask);
first = htonl(first + 1);
last = htonl(last - 1);
memcpy(server_config->lease_first, &first, 4);
memcpy(server_config->lease_last, &last, 4);
free(prefix);
} else {
server_config->ipv6_prefix =
cat_prefix_list(server_config->ipv6_prefix,
prefix);
}
free(ptoken);
c = skip_eol(c, gnc, closure);
if(c < -1)
return -1;
} else if(strcmp(token, "name-server") == 0 ||
strcmp(token, "ntp-server") == 0) {
char *ptoken;
struct prefix_list *prefix;
if(!server_config)
return -1;
c = getword(c, &ptoken, gnc, closure);
if(c < -1)
return -1;
prefix = parse_prefix(ptoken, ADDRESS);
if(prefix == NULL)
return -1;
if(strcmp(token, "name-server") == 0)
server_config->name_server =
cat_prefix_list(server_config->name_server,
prefix);
else
server_config->ntp_server =
cat_prefix_list(server_config->ntp_server,
prefix);
free(ptoken);
} else {
return -1;
}
free(token);
}
return 1;
}
void CJSourceParser::AddMacroNode( wxChar*& cur )
{
wxChar* start = cur;
int lineNo = get_line_no();
skip_preprocessor_dir( cur );
int tmpLnNo;
store_line_no( tmpLnNo );
if ( !mMacrosOn ) return;
spPreprocessorLine* pPL = new spPreprocessorLine();
pPL->mSrcLineNo = lineNo;
AttachComments( *pPL, cur );
get_string_between( start, cur, &pPL->m_Line );
++start; // skip '#'
get_next_token( start );
pPL->mDefType = SP_PREP_DEF_OTHER;
// if we found a definition or redefinition,
// determine the type exactly and assign
// a name to the context
if ( *start == _T('d') )
{
if ( cmp_tokens_fast( start, _T("define"), 6 ) )
{
char* tok = start+6;
get_next_token( tok );
pPL->m_Name = get_token_str( tok );
skip_token( tok );
get_next_token( tok);
if ( tok > cur )
pPL->mDefType = SP_PREP_DEF_DEFINE_SYMBOL;
else
pPL->mDefType = SP_PREP_DEF_REDEFINE_SYMBOL;
}
}
else if ( *start == _T('i') )
{
if ( cmp_tokens_fast( start, _T("include"), 7 ) )
{
pPL->mDefType = SP_PREP_DEF_INCLUDE_FILE;
}
else if ( *++start == _T('f') )
{
// either "#if" or "#ifdef"
cur = start;
skip_token( cur );
get_next_token( cur );
wxString condition = get_token_str( cur );
// currently, everything except '0' is true
if ( condition == _T("0") ) {
// skip until the following else or enif
while ( cur < _gSrcEnd ) {
skip_to_eol( cur );
skip_eol( cur );
get_next_token( cur );
if ( *cur++ == _T('#') && *cur == _T('e') )
break;
}
}
// TODO parse the condition...
}
}
else if ( cmp_tokens_fast( start, _T("else"), 4 ) )
{
// skip until "#endif"
while ( cur < _gSrcEnd ) {
skip_to_eol( cur );
skip_eol( cur );
get_next_token( cur );
if ( *cur++ == _T('#') && cmp_tokens_fast( cur, "endif", 5 ) )
break;
}
}
mpCurCtx->AddMember( pPL );
skip_to_eol( cur );
skip_eol( cur );
restore_line_no( tmpLnNo );
clear_commets_queue();
}
static enum rules_token
lex(struct scanner *s, union lvalue *val)
{
skip_more_whitespace_and_comments:
/* Skip spaces. */
while (is_space(peek(s)))
if (next(s) == '\n')
return TOK_END_OF_LINE;
/* Skip comments. */
if (chr(s, '#')) {
skip_to_eol(s);
goto skip_more_whitespace_and_comments;
}
/* See if we're done. */
if (eof(s)) return TOK_END_OF_FILE;
/* New token. */
s->token_line = s->line;
s->token_column = s->column;
s->buf_pos = 0;
/* LHS Keysym. */
if (chr(s, '<')) {
while (peek(s) != '>' && !eol(s))
buf_append(s, next(s));
if (!chr(s, '>')) {
scanner_err(s, "unterminated keysym literal");
return TOK_ERROR;
}
if (!buf_append(s, '\0')) {
scanner_err(s, "keysym literal is too long");
return TOK_ERROR;
}
val->string.str = s->buf;
val->string.len = s->buf_pos;
return TOK_LHS_KEYSYM;
}
/* Colon. */
if (chr(s, ':'))
return TOK_COLON;
if (chr(s, '!'))
return TOK_BANG;
if (chr(s, '~'))
return TOK_TILDE;
/* String literal. */
if (chr(s, '\"')) {
while (!eof(s) && !eol(s) && peek(s) != '\"') {
if (chr(s, '\\')) {
uint8_t o;
if (chr(s, '\\')) {
buf_append(s, '\\');
}
else if (chr(s, '"')) {
buf_append(s, '"');
}
else if (chr(s, 'x') || chr(s, 'X')) {
if (hex(s, &o))
buf_append(s, (char) o);
else
scanner_warn(s, "illegal hexadecimal escape sequence in string literal");
}
else if (oct(s, &o)) {
buf_append(s, (char) o);
}
else {
scanner_warn(s, "unknown escape sequence (%c) in string literal", peek(s));
/* Ignore. */
}
} else {
buf_append(s, next(s));
}
}
if (!chr(s, '\"')) {
scanner_err(s, "unterminated string literal");
return TOK_ERROR;
}
if (!buf_append(s, '\0')) {
scanner_err(s, "string literal is too long");
return TOK_ERROR;
}
if (!is_valid_utf8(s->buf, s->buf_pos - 1)) {
scanner_err(s, "string literal is not a valid UTF-8 string");
return TOK_ERROR;
}
val->string.str = s->buf;
val->string.len = s->buf_pos;
return TOK_STRING;
}
/* Identifier or include. */
if (is_alpha(peek(s)) || peek(s) == '_') {
s->buf_pos = 0;
while (is_alnum(peek(s)) || peek(s) == '_')
buf_append(s, next(s));
if (!buf_append(s, '\0')) {
scanner_err(s, "identifier is too long");
return TOK_ERROR;
}
if (streq(s->buf, "include"))
return TOK_INCLUDE;
val->string.str = s->buf;
val->string.len = s->buf_pos;
return TOK_IDENT;
}
/* Discard rest of line. */
skip_to_eol(s);
scanner_err(s, "unrecognized token");
return TOK_ERROR;
}
static inline void skip_comments( char*& cur )
{
++cur; // skip '/' token
if ( *cur != '/' && *cur != '*' ) return;
// first, store position of the comment into the queue
// (which further will be attached to the next context
// found)
if ( cur-1 != _gLastSuppresedComment )
{
if ( _gCQSize == MAX_CQ_ENTRIES )
{
size_t i = MAX_CQ_ENTRIES-1;
while( i != 0 )
{
_gCommentsQueue[i-1] = _gCommentsQueue[i];
--i;
}
--_gCQSize ;
}
_gCommentsQueue[_gCQSize++] = cur-1;
}
// if signle-line comment, skip it now
if ( *cur == '/' )
{
skip_to_eol( cur );
skip_eol( cur );
return;
}
size_t level = 1;
// check for multiline comment (handle nested multiline comments!)
int line_len = 0;
++cur;
++cur;
do
{
// TBD:: check eof cond.
// detect and remove vertical columns of '*''s
while ( *cur != '/' && cur < _gSrcEnd )
{
switch (*cur)
{
case '*' :
{
if ( *(cur+1) != '/' )
{
if ( line_len == 1 )
*cur = ' ';
}
break;
}
case 13 : line_len = 0; break;
case 10 : { line_len = 0; ++_gLineNo; } break;
default : ++line_len;
}
++cur;
}
if ( cur >= _gSrcEnd ) return;
++cur;
if ( *(cur-2) == '*' )
{
--level;
if ( level == 0 )
break;
}
else
if ( *cur == '*' )
{
++cur;
++cur;
++level;
}
} while(1);
}
SEXP insnp_new(const SEXP Filenames, const SEXP Sample_id, const SEXP Snp_id,
const SEXP Diploid, const SEXP Fields,
const SEXP Codes, const SEXP Threshold, const SEXP Lower,
const SEXP Sep, const SEXP Comment, const SEXP Skip,
const SEXP Simplify, const SEXP Verbose,
const SEXP In_order, const SEXP Every){
/* Process arguments */
if (TYPEOF(Verbose)!=LGLSXP)
error("Argument type error: Verbose");
if (length(Verbose)>1)
warning("Only first element of argument used: Verbose");
int verbose = *INTEGER(Verbose);
if (TYPEOF(In_order)!=LGLSXP)
error("Argument type error: In_order");
if (length(In_order)>1)
warning("Only first element of argument used: In_order");
int in_order = *INTEGER(In_order);
if (TYPEOF(Filenames)!=STRSXP)
error("Argument type error: Filenames");
int Nfile = length(Filenames);
int Nsample=0;
if (TYPEOF(Sample_id)==STRSXP)
Nsample = length(Sample_id);
else if (TYPEOF(Sample_id)!=NILSXP)
error("Argument type error: Sample_id");
int Nsnp=0;
if (TYPEOF(Snp_id)==STRSXP)
Nsnp = length(Snp_id);
else if (TYPEOF(Snp_id)!=NILSXP)
error("Argument type error: Snp_id");
/* file is 1 = sample, 2 = snp, 0 = irrelevant */
int file_is = 0;
if (!Nsample) {
if (Nsnp) {
Nsample = Nfile;
Rprintf("Each file is assumed to concern a single sample\n");
Rprintf("(Sample IDs are assumed to be included in filenames)\n");
file_is = 1;
}
else
error("No sample or SNP IDs specified");
}
else if (!Nsnp) {
Nsnp = Nfile;
Rprintf("Each file is assumed to concern a single SNP\n");
Rprintf("(SNP IDs are assumed to be included in filenames)\n");
file_is = 2;
}
/* If not in order, set up hash tables */
index_db sample_index = NULL;
index_db snp_index = NULL;
if (!in_order) {
if (file_is != 1)
sample_index = create_name_index(Sample_id);
if (file_is != 2)
snp_index = create_name_index(Snp_id);
}
int *diploid=NULL;
if (TYPEOF(Diploid)==LGLSXP) {
if (length(Diploid)!=Nsample)
error("Argument length error: diploid argument");
diploid = LOGICAL(Diploid);
}
else if (TYPEOF(Diploid)!=NILSXP)
error("Argument type error: diploid argument");
if (TYPEOF(Fields)!=INTSXP)
error("Argument type error: Fields");
int *fields = INTEGER(Fields);
int fsamp=0, fsnp=0, fgt=0, fa1=0, fa2=0, fconf=0;
SEXP Fnames = getAttrib(Fields, R_NamesSymbol);
if (TYPEOF(Fnames)==NILSXP)
error("Argument error: Fields argument has no names");
int fmax = 0;
int Nfield = length(Fields);
for (int i=0; i<Nfield; i++) {
const char *fname = CHAR(STRING_ELT(Fnames, i));
int fi = fields[i];
if (!strcmp(fname, "sample"))
fsamp = fi;
else if (!strcmp(fname, "snp"))
fsnp = fi;
else if (!strcmp(fname, "genotype"))
fgt = fi;
else if (!strcmp(fname, "allele1"))
fa1 = fi;
else if (!strcmp(fname, "allele2"))
fa2 = fi;
else if (!strcmp(fname, "confidence"))
fconf = fi;
else
error("Unrecognized input field name: %s", fname);
if (fi>fmax)
fmax = fi;
}
if (verbose) {
Rprintf("Reading one call per input line\n");
if (fsamp) {
Rprintf(" Sample id is in field %d", fsamp);
if (file_is==1)
Rprintf(" (ignored)\n");
else
Rprintf("\n");
}
if (fsnp) {
Rprintf(" SNP id is in field %d", fsnp);
if (file_is==2)
Rprintf(" (ignored)\n");
else
Rprintf("\n");
}
if (fgt)
Rprintf(" Genotype is in field %d\n", fgt);
if (fa1)
Rprintf(" Allele 1 is in field %d\n", fa1);
if (fa2)
Rprintf(" Allele 2 is in field %d\n", fa2);
if (fconf)
Rprintf(" Confidence score is in field %d\n", fconf);
}
if (file_is==1)
fsamp = 0;
else if (file_is==2)
fsnp = 0;
/* Allele or genotype coding? */
int gcoding;
if (fgt) {
if (fa1 || fa2)
error("Coding must be by genotype OR allele, not both");
gcoding = 1;
}
else {
if (!(fa1 && fa2))
error("No genotype or allele field(s) specified");
if (!(fa1 && fa2))
error("Field positions for both alleles must be specified");
gcoding = 0;
}
int nuc = 0;
if (TYPEOF(Codes)!=STRSXP)
error("Argument type error: Codes");
if (length(Codes)==1) {
SEXP Code = STRING_ELT(Codes, 0);
const char *code = CHAR(Code);
if (!strcmp(code, "nucleotide"))
nuc = 1;
else
error("Unrecognized coding: %s", code);
}
else {
int ncode = length(Codes);
if (gcoding) {
if (diploid) {
if (ncode!=5) {
if (ncode==3)
warning("Genotype coding for X: haploid genotypes are assumed to be coded as homozygous");
else
error("Genotype coding for X.snp: three or five genotype codes must be specified");
}
}
else {
if (ncode!=3)
error("Genotype coding: three genotype codes must be specified");
}
}
else {
if (ncode!=2)
error("Allele coding: two allele codes must be specified");
}
}
if (TYPEOF(Threshold)==NILSXP && !fconf)
error("Argument type error: no threshold argument");
if (TYPEOF(Threshold)!=REALSXP)
error("Argument type error: Threshold");
double threshold = *REAL(Threshold);
if (fconf && threshold==NA_REAL)
error("Confidence score is read but no threshold is set");
if (TYPEOF(Lower)!=LGLSXP)
error("Argument type error: Lower");
if (length(Lower)>1)
warning("Only first element of argument used: Lower");
int lower = *INTEGER(Lower);
char sep = ' ';
if (TYPEOF(Sep)==STRSXP) {
if (length(Sep)>1)
warning("Only first element of argument used: Sep");
const char *c = CHAR(STRING_ELT(Sep, 0));
if (strlen(c)>1)
warning("Only first character used: Sep");
sep = c[0];
}
else if (TYPEOF(Sep)!=NILSXP)
error("Argument type error: Sep");
char comment = (char) 0;
if (TYPEOF(Comment)==STRSXP) {
if (length(Sep)>1)
warning("Only first element of argument used: Comment");
const char *c = CHAR(STRING_ELT(Comment, 0));
if (strlen(c)>1)
warning("Only first character used: Comment");
comment = c[0];
}
else if (TYPEOF(Comment)!=NILSXP)
error("Argument type error: Comment");
int skip = 0;
if (TYPEOF(Skip)==INTSXP) {
if (length(Skip)>1)
warning("Only first element used: Skip");
skip = INTEGER(Skip)[0];
}
else if (TYPEOF(Skip)!=NILSXP)
error("Argument type error: Skip");
if (TYPEOF(Simplify)!=LGLSXP)
error("Argument type error: Simplify");
if (length(Simplify)>2)
error("Argument length error: Simplify");
int *simplify = INTEGER(Simplify);
if (length(Simplify)==1)
simplify[1] = simplify[0];
int every=0;
if (TYPEOF(Every)==INTSXP) {
if (length(Every)>1)
warning("Only first element used: Every");
every = INTEGER(Every)[0];
}
else if (TYPEOF(Every)!=NILSXP)
error("Argument type error: Every");
/* Create output object and initialise to zero */
if (verbose) {
if (diploid)
Rprintf("Reading XSnpMatrix with %d rows and %d columns\n",
Nsample, Nsnp);
else
Rprintf("Reading SnpMatrix with %d rows and %d columns\n",
Nsample, Nsnp);
}
SEXP Result, Dimnames, Package, Class;
PROTECT(Result = allocMatrix(RAWSXP, Nsample, Nsnp));
PROTECT(Dimnames = allocVector(VECSXP, 2));
if (simplify[0]) {
SET_VECTOR_ELT(Dimnames, 0,
simplify_names(file_is==1? Filenames: Sample_id));
}
else {
SET_VECTOR_ELT(Dimnames, 0,
duplicate(file_is==1? Filenames: Sample_id));
}
if (simplify[1]) {
SET_VECTOR_ELT(Dimnames, 1,
simplify_names(file_is==2? Filenames: Snp_id));
}
else {
SET_VECTOR_ELT(Dimnames, 1,
duplicate(file_is==2? Filenames: Snp_id));
}
setAttrib(Result, R_DimNamesSymbol, Dimnames);
/* Class */
PROTECT(Class = allocVector(STRSXP, 1));
if (diploid) {
R_do_slot_assign(Result, mkString("diploid"), Diploid);
SET_STRING_ELT(Class, 0, mkChar("XSnpMatrix"));
}
else {
SET_STRING_ELT(Class, 0, mkChar("SnpMatrix"));
}
PROTECT(Package = allocVector(STRSXP, 1));
SET_STRING_ELT(Package, 0, mkChar("snpStats"));
setAttrib(Class, install("package"), Package);
classgets(Result, Class);
SET_S4_OBJECT(Result);
unsigned char *result = RAW(Result);
memset(result, 0x00, Nsample*Nsnp);
/* Read in data */
char field[MAX_FLD];
int Naccept = 0, Nreject = 0, Nocall = 0, Nskipped = 0, Nxerror = 0;
int i_this = 0, j_this = 0;
const char *this_sample=NULL, *this_snp=NULL;
if (fsamp) {
this_sample = CHAR(STRING_ELT(Sample_id, 0));
}
if (fsnp) {
this_snp = CHAR(STRING_ELT(Snp_id, 0));
}
if (verbose) {
Rprintf(" Cumulative totals\n");
Rprintf(" -----------------------------------\n");
Rprintf(" File Line Accepted Rejected No call Skipped File name\n");
}
/* slowest varying 0 = don't know, 1 = sample, 2 = snp */
int slowest = file_is, last=Nsample*Nsnp-1;
int advance = 0, finished=0;
for (int f=0; f<Nfile; f++) {
/* Open input file */
const char *filename = CHAR(STRING_ELT(Filenames, f));
if (verbose) {
int lfn = strlen(filename);
if (lfn > 20) {
Rprintf("%59s...%-17s\r", "", filename+lfn-17);
}
else
Rprintf("%59s%-20s\r", "", filename);
}
gzFile infile = gzopen(filename, "rb");
if (!infile) {
warning("Failure to open input file: %s", filename);
continue;
}
int fterm = 2, line = 0, found_in_file = 0;
/* Skip any header lines */
for (int i=0; i<skip; i++) {
line++;
if (skip_to_eol(infile)==3)
error("End-of-file reached on line %d", line);
}
Nskipped += skip;
/* Read data lines */
while (fterm!=3) {
/* Read a line */
line++;
if (verbose && every && !(line % every))
Rprintf("%8d %8d %10d %8d %8d %8d\r",
f+1, line, Naccept, Nreject, Nocall, Nskipped);
int genotype=0, allele1=0, allele2=0;
/* wanted is coded as:
1 if this call is to be accepted
0 if it is not wanted (or a comment line)
-1 if rejected due to insufficient confidence
-2 coded as no-call
*/
int wanted = 1;
char sampid[MAX_FLD], snpid[MAX_FLD];
char gtype1[MAX_FLD], gtype2[MAX_FLD];
char cscore[MAX_FLD];
sampid[0] = snpid[0] = cscore[0] = (char) 0;
for (int r=1; (r<=fmax); r++) {
fterm = next_field(infile, sep, comment, '_', field, MAX_FLD);
if (!fterm)
error("Field overflow: line %d, field %d", line, r);
if ((fterm>1) && (r<fmax)) {
if (r==1) {
if(!field[0]) {
/* Empty line or comment line */
wanted = 0;
if (fterm==2) {
Nskipped++;
continue;
}
else
break;
}
}
error("Incomplete line: %d (last field read: %d = %s)",
line, r, field);
}
/* Save fields */
if (r==fsamp) {
strncpy(sampid, field, MAX_FLD-1);
}
else if (r==fsnp) {
strncpy(snpid, field, MAX_FLD-1);
}
else if (r==fconf) {
strncpy(cscore, field, MAX_FLD-1);
}
else if (r==fgt)
strncpy(gtype1, field, MAX_FLD-1);
else if (r==fa1)
strncpy(gtype1, field, MAX_FLD-1);
else if (r==fa2)
strncpy(gtype2, field, MAX_FLD-1);
else {
/* skip field */
}
} /* Matches: for (int r=1; (r<=fmax); r++) { */
if (!wanted)
continue;
/* Discard any further fields */
if (fterm<2) {
fterm = skip_to_eol(infile);
}
/* Find next target and check matches */
int match_sample, match_snp;
if (in_order) {
/* Advance to next target read */
if (advance) {
/*
If unknown, determine sort order by seeing which indicator
has changed
*/
if (!slowest) {
if (strcmp(this_sample, sampid))
slowest = 2; /* sample fastest, SNP slowest */
else if (strcmp(this_snp, snpid))
slowest = 1; /* SNP fastest, sample slowest */
else
error("Error in input file sort order");
}
/* Now advance fastest varying indicator */
if (slowest==1) {
j_this++;
if (j_this==Nsnp) {
j_this = 0;
if (fsamp) {
i_this++;
if (i_this==Nsample) {
finished = 1;
break;
}
else
this_sample = CHAR(STRING_ELT(Sample_id, i_this));
}
}
this_snp = CHAR(STRING_ELT(Snp_id, j_this));
}
else {
i_this++;
if (i_this==Nsample) {
i_this = 0;
if (fsnp) {
j_this++;
if (j_this==Nsnp) {
finished = 1;
break;
}
else
this_snp = CHAR(STRING_ELT(Snp_id, j_this));
}
}
this_sample = CHAR(STRING_ELT(Sample_id, i_this));
}
}
/* Does current line match current target? */
match_sample = file_is==1 || !strcmp(this_sample, sampid);
match_snp = file_is==2 || !strcmp(this_snp, snpid);
}
else { /* Not in order */
if (file_is!=1) {
if (this_sample && strcmp(this_sample, sampid))
i_this = index_lookup(sample_index, sampid);
if (i_this >= 0) {
this_sample = CHAR(STRING_ELT(Sample_id, i_this));
match_sample = 1;
}
else {
this_sample = NULL;
match_sample = 0;
}
}
else {
match_sample = 1;
i_this = f;
}
if (file_is!=2) {
if (this_snp && strcmp(this_snp, snpid))
j_this = index_lookup(snp_index, snpid);
if (j_this >= 0) {
this_snp = CHAR(STRING_ELT(Snp_id, j_this));
match_snp = 1;
}
else {
this_snp = NULL;
match_snp = 0;
}
}
else {
match_snp = 1;
j_this = f;
}
}
if (match_sample && match_snp) {
/* Next target read found in file(s) */
found_in_file++;
int ij_this = j_this*Nsample + i_this;
finished = (ij_this==last);
/* Check confidence score */
if (fconf) {
double conf;
if (sscanf(cscore, "%lf", &conf)!=1)
error("Failure to read confidence score: line %d", line);
if ((lower && conf<threshold) || (!lower && conf>threshold)) {
wanted = -1;
Nreject++;
if (finished)
break;
else
advance = 1;
continue;
}
}
/* Decode genotype */
int which;
if (gcoding) {
if (nuc) {
switch (strlen(gtype1)) {
case 0:
allele1 = allele2 = 0;
break;
case 1:
allele1 = allele2 = nucleotide(gtype1[0]);
break;
case 2:
allele1 = nucleotide(gtype1[0]);
allele2 = nucleotide(gtype1[1]);
break;
default:
error("Nucleotide coded genotype should be 2 character string: line %d", line);
}
}
else {
which = str_inlist(Codes, gtype1);
if (!which)
genotype = 0;
else if (which>3)
genotype = 2*which - 7;
else
genotype = which;
}
}
else {
if (nuc) {
allele1 = nucleotide(gtype1[0]);
allele2 = nucleotide(gtype2[0]);
}
else {
allele1 = str_inlist(Codes, gtype1);
allele2 = str_inlist(Codes, gtype2);
}
}
/* Successful read, store genotype in result[i_this, j_this] */
if (nuc || !gcoding) {
if (allele2 < allele1) {
genotype = allele2;
allele2 = allele1;
allele1 = genotype;
}
if (allele1 && allele2)
genotype = allele1 + (allele2*(allele2-1))/2;
else
genotype = 0;
}
if (genotype) {
if (diploid && !diploid[i_this] && (genotype==2))
Nxerror++;
else {
Naccept++;
result[ij_this] = (unsigned char) genotype;
}
}
else {
wanted = -2;
Nocall++;
}
/* Flag need to advance to next target */
advance = 1;
} /* matches if (match_sample && match_snp) { */
else {
Nskipped++;
/* Flag no advance to next target */
advance = 0;
}
if (finished)
break;
} /* matches: while (fterm!=3) { */
if (file_is==1)
i_this++;
if (file_is==2)
j_this++;
if (verbose) {
Rprintf("%8d %8d %10d %8d %8d %8d\r", f+1, line, Naccept, Nreject, Nocall, Nskipped);
}
if(!found_in_file)
warning("No calls found in file %s", filename);
gzclose(infile);
if (finished)
break;
}
/* Warnings */
if (in_order && !finished)
warning("End of data reached before search completed");
if (Nxerror)
warning("%d haploid genotypes were coded as heterozygous; set to NA", Nxerror);
if (Nskipped)
warning("%d lines of input file(s) were skipped", Nskipped);
/* Report */
if (verbose)
Rprintf("\n");
Rprintf("%d genotypes successfully read\n", Naccept);
if (Nreject)
Rprintf("%d genotypes were rejected due to low confidence\n", Nreject);
if (Nocall)
Rprintf("%d genotypes were not called\n", Nocall);
if (Nsample*Nsnp > Naccept+Nxerror+Nreject+Nocall)
Rprintf("%d genotypes could not be found on input file(s)\n",
Nsample*Nsnp - Naccept - Nreject - Nxerror-Nocall);
if (nuc) {
if (verbose)
Rprintf("Recasting and checking nucleotide coding\n");
int none_snps = recode_snp(result, Nsample, Nsnp);
if (none_snps) {
Rprintf("%d polymorphisms were not SNPs and have been set to NA ",
none_snps);
Rprintf("(see warnings for details)\n");
}
}
UNPROTECT(4);
/* Destroy hash indexes */
if (sample_index)
index_destroy(sample_index);
if (snp_index)
index_destroy(snp_index);
return Result;
}
static enum rules_token
lex(struct scanner *s, union lvalue *val)
{
skip_more_whitespace_and_comments:
/* Skip spaces. */
while (chr(s, ' ') || chr(s, '\t'));
/* Skip comments. */
if (lit(s, "//")) {
skip_to_eol(s);
}
/* New line. */
if (eol(s)) {
while (eol(s)) next(s);
return TOK_END_OF_LINE;
}
/* Escaped line continuation. */
if (chr(s, '\\')) {
if (!eol(s)) {
scanner_err(s, "illegal new line escape; must appear at end of line");
return TOK_ERROR;
}
next(s);
goto skip_more_whitespace_and_comments;
}
/* See if we're done. */
if (eof(s)) return TOK_END_OF_FILE;
/* New token. */
s->token_line = s->line;
s->token_column = s->column;
/* Operators and punctuation. */
if (chr(s, '!')) return TOK_BANG;
if (chr(s, '=')) return TOK_EQUALS;
if (chr(s, '*')) return TOK_STAR;
/* Group name. */
if (chr(s, '$')) {
val->string.start = s->s + s->pos;
val->string.len = 0;
while (is_ident(peek(s))) {
next(s);
val->string.len++;
}
if (val->string.len == 0) {
scanner_err(s, "unexpected character after \'$\'; expected name");
return TOK_ERROR;
}
return TOK_GROUP_NAME;
}
/* Identifier. */
if (is_ident(peek(s))) {
val->string.start = s->s + s->pos;
val->string.len = 0;
while (is_ident(peek(s))) {
next(s);
val->string.len++;
}
return TOK_IDENTIFIER;
}
scanner_err(s, "unrecognized token");
return TOK_ERROR;
}
