void notify_except_rlevel
(
dbref loc,
dbref player,
dbref exception,
const UTF8 *msg,
int xflags
)
{
if ( loc != exception
&& IsReal(loc, player))
{
notify_check(loc, player, msg,
(MSG_ME_ALL | MSG_F_UP | MSG_S_INSIDE | MSG_NBR_EXITS_A| xflags));
}
dbref first;
DOLIST(first, Contents(loc))
{
if ( first != exception
&& IsReal(first, player))
{
notify_check(first, player, msg,
(MSG_ME | MSG_F_DOWN | MSG_S_OUTSIDE | xflags));
}
}
}
void notify_except2_rlevel2
(
dbref loc,
dbref player,
dbref exc1,
dbref exc2,
const UTF8 *msg
)
{
if ( loc != exc1
&& loc != exc2
&& IsReal(loc, player))
{
notify_check(loc, player, msg,
(MSG_ME_ALL | MSG_F_UP | MSG_S_INSIDE | MSG_NBR_EXITS_A));
}
dbref first;
DOLIST(first, Contents(loc))
{
if ( first != exc1
&& first != exc2
&& IsReal(first, player)
&& IsReal(first, exc2))
{
notify_check(first, player, msg,
(MSG_ME | MSG_F_DOWN | MSG_S_OUTSIDE));
}
}
}
Maybe<Real> NewtonPolySolve::FindSmallestPositiveRoot(const RPolynomial& p, const Real /*lastSmallestPositive*/) {
if (NumberOfSignChanges(p) == 0)
return Maybe<Real>();
const CPolynomial q(p);
//{
// bool converged;
// RPolynomial t = RPolynomial::MakeT();
// Scalar x = NextRoot(q, Scalar(lastSmallestPositive), &converged);
// if (converged && IsReal(x) && x.real() > 0 && NumberOfSignChanges(p.EvaluateAt(t + x.real() + .1)) == 0)
// return x.real();
// /*if (converged && )
// return x;*/
//}
const ScalarList roots = FindRoots(q);
Maybe<Real> result;
for (int i = 0 ; i < (int)roots.size() ; i++) {
if (IsReal(roots[i]) && roots[i].real() > 0) {
if (result.IsValid()) {
result = std::min(result.Get(), roots[i].real());
} else {
result = roots[i].real();
}
}
}
return result;
}
bool BoolFun(void)
{ bool ok = true;
CppAD::AD<Complex> x = Complex(1., 0.);
CppAD::AD<Complex> y = Complex(1., 1.);
ok &= IsReal(x);
ok &= ! AbsGeq(x, y);
return ok;
}
bool Json::operator == (const Json& other) const {
if (this == &other) return true;
if (IsNull()) return other.IsNull();
if (other.IsNull()) return false;
if (value_->type() != other.value_->type()) return false;
if (IsInteger()) return integer() == other.integer();
if (IsUInteger()) return uinteger() == other.uinteger();
if (IsReal()) return real() == other.real();
if (IsString()) return string() == other.string();
if (IsArray()) return array() == other.array();
if (IsObject()) return object() == other.object();
return false;
}
String NumericEdit::ValueAsString( double v ) const
{
v = Range( v, lowerBound, upperBound );
if ( IsReal() )
{
if ( IsScientificNotationEnabled() )
if ( sciTriggerExp < 0 || v != 0 && (Abs( v ) > Pow10I<double>()( +sciTriggerExp ) ||
Abs( v ) < Pow10I<double>()( -sciTriggerExp )) )
return String().Format( "%.*e", precision, v );
return String().Format( "%.*f", ActualPrecision( precision, v ), v );
}
return String().Format( "%.0f", v );
}
String NumericEdit::ValueAsString( double v ) const
{
v = Range( v, m_lowerBound, m_upperBound );
if ( IsReal() )
{
if ( m_scientific )
if ( m_sciTriggerExp < 0 || v != 0 && (Abs( v ) > Pow10I<double>()( +m_sciTriggerExp ) ||
Abs( v ) < Pow10I<double>()( -m_sciTriggerExp )) )
return String().Format( "%.*le", int( m_precision ), v );
return String().Format( "%.*lf", PrecisionForValue( int( m_precision ), v ), v );
}
return String().Format( "%.0lf", v );
}
static int
parse_MSF(FILE *fp, AINFO *ainfo)
{
char buffer[LINEBUFLEN];
char *sptr;
int nseq;
/* Get first dividing line. MSF format specifies ints after MSF: and Check:
* but we don't make sure of this
*/
do {
if (fgets(buffer, LINEBUFLEN, fp) == NULL) { squid_errno = SQERR_FORMAT; return 0; }
} while (strstr(buffer, " MSF: ") == NULL ||
strstr(buffer, " Check: ") == NULL ||
strstr(buffer, " ..") == NULL);
/* Get names, weights from header
*/
nseq = 0;
/*CONSTCOND*/
while (1)
{
if (fgets(buffer, LINEBUFLEN, fp) == NULL) { squid_errno = SQERR_FORMAT; return 0; }
if (is_blankline(buffer)) continue;
if (strncmp(buffer, "//", 2) == 0) break;
sptr = strtok(buffer, WHITESPACE);
if (sptr == NULL || strcmp(sptr, "Name:") != 0 || strstr(sptr+5, "Weight:") != 0)
{ squid_errno = SQERR_FORMAT; return 0; }
if ((sptr = strtok(NULL, WHITESPACE)) == NULL) {squid_errno=SQERR_FORMAT; return 0; }
SetSeqinfoString(&(ainfo->sqinfo[nseq]), sptr, SQINFO_NAME);
while (sptr != NULL && strcmp(sptr, "Weight:") != 0) sptr = strtok(NULL, WHITESPACE);
if ((sptr = strtok(NULL, WHITESPACE)) == NULL) {squid_errno=SQERR_FORMAT; return 0; }
if (! IsReal(sptr)) { squid_errno = SQERR_FORMAT; return 0; }
ainfo->wgt[nseq] = atof(sptr);
nseq++;
}
if (nseq != ainfo->nseq) { squid_errno = SQERR_FORMAT; return 0; }
return 1;
}
static void promote_match(dbref what, int confidence)
{
#ifdef REALITY_LVLS
// Check is the object is visible.
//
if ( Good_obj(what)
&& (confidence & CON_LOCAL)
&& !IsReal(md.player, what)
&& what != Location(md.player))
{
return;
}
#endif // REALITY_LVLS
// Check for type and locks, if requested.
//
if (md.pref_type != NOTYPE)
{
if ( Good_obj(what)
&& Typeof(what) == md.pref_type)
{
confidence |= CON_TYPE;
}
}
if (md.check_keys)
{
MSTATE save_md;
save_match_state(&save_md);
if ( Good_obj(what)
&& could_doit(md.player, what, A_LOCK))
{
confidence |= CON_LOCK;
}
restore_match_state(&save_md);
}
// If nothing matched, take it.
//
if (md.count == 0)
{
md.match = what;
md.confidence = confidence;
md.count = 1;
return;
}
// If confidence is lower, ignore.
//
if (confidence < md.confidence)
{
return;
}
// If confidence is higher, replace.
//
if (confidence > md.confidence)
{
md.match = what;
md.confidence = confidence;
md.count = 1;
return;
}
// Equal confidence, pick randomly.
//
md.count++;
if (RandomINT32(1,md.count) == 1)
{
md.match = what;
}
return;
}
bool Json::IsNumber() const {
if (IsInteger() || IsUInteger() || IsReal()) return true;
return false;
}
bool ProcessParameter::ScientificNotation() const
{
if ( !IsReal() )
return false;
return (*API->Process->GetParameterScientificNotation)( m_data->handle ) != api_false;
}
int ProcessParameter::Precision() const
{
if ( !IsReal() )
return 0;
return (*API->Process->GetParameterPrecision)( m_data->handle );
}
EXPR *FindBasic( EXPR *def )
{
unsigned int i ;
EXPR *expr, *E1, *E2 ;
if( IsReal(def) )
{
expr = new UNIT ;
U(expr)->Ehead = String( "Ordinate" ) ;
ListAppend( expr, def->Copy() ) ;
return expr ;
}
if( IsLabel( def ) )
{
for( i = 0 ; i < U(UnitList)->used ; i++ )
{
if( U(UN(i))->Ehead == def )
{
expr = UN(i)->Copy() ;
delete U(expr)->Eeval ;
U(expr)->Eeval = NULL_EXPR ;
return expr ;
}
}
IOerror( IO_ERR, "FindBasic", "%s is an undefined unit", LabelValue(def) ) ;
return garbageunit() ;
}
if( !IsOper(def) )
{
IOerror( IO_FATAL, "FindBasic", "unexpected in units definition" ) ;
return garbageunit() ;
}
if( D(def)->oper == OPER_MINUS )
{
expr = FindBasic( D(def)->Eleft ) ;
if( U(expr)->used > 1 )
{
IOerror( IO_ERR, "FindBasic", "illegal negation of unit" ) ;
return garbageunit() ;
}
E1 = OP3( "u-", U(expr)->list[0], NULL_EXPR ) ;
delete U(expr)->list[0] ;
U(expr)->list[0] = E1 ;
return expr ;
}
E1 = FindBasic( D(def)->Eleft ) ;
E2 = FindBasic( D(def)->Eright ) ;
switch( D(def)->oper )
{
case OPER_MULTIPLY:
expr = UnitOP3( "*", "+", E1, E2 ) ;
break ;
case OPER_DIVIDE:
expr = UnitOP3( "/", "-", E1, E2 ) ;
break ;
case OPER_POW:
expr = UnitOP3( "^", "*", E1, E2 ) ;
break ;
default:
IOerror( IO_ERR, "FindBasic", "unexpected operator in unit" ) ;
expr = garbageunit() ;
break ;
}
delete E1 ;
delete E2 ;
return expr ;
}
/* ---------------------------------------------------------------------------
* did_it_rlevel: Have player do something to/with thing, watching the
* attributes. 'what' is actually ignored, the desclist match being used
* instead.
*/
void did_it_rlevel
(
dbref player,
dbref thing,
int what,
const UTF8 *def,
int owhat,
const UTF8 *odef,
int awhat,
int ctrl_flags,
const UTF8 *args[],
int nargs
)
{
if (MuxAlarm.bAlarmed)
{
return;
}
UTF8 *d, *buff, *act, *charges, *bp;
dbref aowner;
int num, aflags;
int i;
bool found_a_desc;
reg_ref **preserve = NULL;
bool need_pres = false;
// Message to player.
//
if (0 < what)
{
// Get description list.
//
DESC_INFO *desclist = desclist_match(player, thing);
found_a_desc = false;
for (i = 0; i < desclist->n; i++)
{
// Ok, if it's A_DESC, we need to check against A_IDESC.
//
if ( A_IDESC == what
&& A_DESC == desclist->descs[i])
{
d = atr_pget(thing, A_IDESC, &aowner, &aflags);
}
else
{
d = atr_pget(thing, desclist->descs[i], &aowner, &aflags);
}
if ('\0' != d[0])
{
// No need for the 'def' message.
//
found_a_desc = true;
if (!need_pres)
{
need_pres = true;
preserve = PushRegisters(MAX_GLOBAL_REGS);
save_global_regs(preserve);
}
buff = bp = alloc_lbuf("did_it.1");
mux_exec(d, LBUF_SIZE-1, buff, &bp, thing, thing, player,
AttrTrace(aflags, EV_EVAL|EV_FIGNORE|EV_TOP),
args, nargs);
*bp = '\0';
if ( A_HTDESC == desclist->descs[i]
&& Html(player))
{
safe_str(T("\r\n"), buff, &bp);
*bp = '\0';
notify_html(player, buff);
}
else
{
notify(player, buff);
}
free_lbuf(buff);
}
free_lbuf(d);
}
if (!found_a_desc)
{
// No desc found... try the default desc (again).
// A_DESC or A_HTDESC... the worst case we look for it twice.
//
d = atr_pget(thing, what, &aowner, &aflags);
if ('\0' != d[0])
{
// No need for the 'def' message
//
found_a_desc = true;
if (!need_pres)
{
need_pres = true;
preserve = PushRegisters(MAX_GLOBAL_REGS);
save_global_regs(preserve);
}
buff = bp = alloc_lbuf("did_it.1");
mux_exec(d, LBUF_SIZE-1, buff, &bp, thing, thing, player,
AttrTrace(aflags, EV_EVAL|EV_FIGNORE|EV_TOP),
args, nargs);
*bp = '\0';
if ( A_HTDESC == what
&& Html(player))
{
safe_str(T("\r\n"), buff, &bp);
*bp = '\0';
notify_html(player, buff);
}
else
{
notify(player, buff);
}
free_lbuf(buff);
}
else if (def)
{
notify(player, def);
}
free_lbuf(d);
}
}
else if ( what < 0
&& def)
{
notify(player, def);
}
if (isPlayer(thing))
{
d = atr_pget(mudconf.master_room, get_atr(T("ASSET_DESC")), &aowner, &aflags);
if (*d)
{
if (!need_pres)
{
need_pres = true;
preserve = PushRegisters(MAX_GLOBAL_REGS);
save_global_regs(preserve);
}
buff = bp = alloc_lbuf("did_it.1");
mux_exec(d, LBUF_SIZE-1, buff, &bp, thing, thing, player,
AttrTrace(aflags, EV_EVAL|EV_FIGNORE|EV_TOP),
args, nargs);
*bp = '\0';
notify(player, buff);
free_lbuf(buff);
}
free_lbuf(d);
}
// Message to neighbors.
//
dbref loc;
if ( 0 < owhat
&& Has_location(player)
&& Good_obj(loc = Location(player)))
{
d = atr_pget(thing, owhat, &aowner, &aflags);
if (*d)
{
if (!need_pres)
{
need_pres = true;
preserve = PushRegisters(MAX_GLOBAL_REGS);
save_global_regs(preserve);
}
buff = bp = alloc_lbuf("did_it.2");
mux_exec(d, LBUF_SIZE-1, buff, &bp, thing, thing, player,
AttrTrace(aflags, EV_EVAL|EV_FIGNORE|EV_TOP),
args, nargs);
*bp = '\0';
if (*buff)
{
if (aflags & AF_NONAME)
{
notify_except2_rlevel2(loc, player, player, thing, buff);
}
else
{
notify_except2_rlevel2(loc, player, player, thing,
tprintf(T("%s %s"), Name(player), buff));
}
}
free_lbuf(buff);
}
else if (odef)
{
if (ctrl_flags & VERB_NONAME)
{
notify_except2_rlevel2(loc, player, player, thing, odef);
}
else
{
notify_except2_rlevel2(loc, player, player, thing,
tprintf(T("%s %s"), Name(player), odef));
}
}
free_lbuf(d);
}
else if ( owhat < 0
&& odef
&& Has_location(player)
&& Good_obj(loc = Location(player)))
{
if (ctrl_flags & VERB_NONAME)
{
notify_except2_rlevel2(loc, player, player, thing, odef);
}
else
{
notify_except2_rlevel2(loc, player, player, thing,
tprintf(T("%s %s"), Name(player), odef));
}
}
// If we preserved the state of the global registers, restore them.
//
if (need_pres)
{
restore_global_regs(preserve);
PopRegisters(preserve, MAX_GLOBAL_REGS);
}
// Do the action attribute.
//
if ( awhat > 0
&& IsReal(thing, player))
{
act = atr_pget(thing, awhat, &aowner, &aflags);
if (*act != '\0')
{
charges = atr_pget(thing, A_CHARGES, &aowner, &aflags);
if (*charges)
{
num = mux_atol(charges);
if (num > 0)
{
buff = alloc_sbuf("did_it.charges");
mux_ltoa(num-1, buff);
atr_add_raw(thing, A_CHARGES, buff);
free_sbuf(buff);
}
else
{
buff = atr_pget(thing, A_RUNOUT, &aowner, &aflags);
if (*buff != '\0')
{
free_lbuf(act);
act = buff;
}
else
{
free_lbuf(act);
free_lbuf(buff);
free_lbuf(charges);
return;
}
}
}
free_lbuf(charges);
CLinearTimeAbsolute lta;
wait_que(thing, player, player, AttrTrace(aflags, 0), false, lta,
NOTHING, 0,
act,
nargs, args,
mudstate.global_regs);
}
free_lbuf(act);
}
}
/* Function: ReadSELEX()
* Date: SRE, Sun Jun 6 18:24:09 1999 [St. Louis]
*
* Purpose: Parse an alignment read from an open SELEX format
* alignment file. (SELEX is a single alignment format).
* Return the alignment, or NULL if we've already read the
* alignment or there's no alignment data in the file.
*
* Limitations: SELEX is the only remaining multipass parser for
* alignment files. It cannot read from gzip or from stdin.
* It Die()'s here if you try. The reason for this
* that SELEX allows space characters as gaps, so we don't
* know the borders of an alignment block until we've seen
* the whole block. I could rewrite to allow single-pass
* parsing (by storing the whole block in memory) but
* since SELEX is now legacy, why bother.
*
* Note that the interface is totally kludged: fastest
* possible adaptation of old ReadSELEX() to the new
* MSA interface.
*
* Args: afp - open alignment file
*
* Returns: MSA * - an alignment object
* caller responsible for an MSAFree()
* NULL if no alignment data.
*/
MSA *
ReadSELEX(MSAFILE *afp)
{
MSA *msa; /* RETURN: mult seq alignment */
FILE *fp; /* ptr to opened seqfile */
char **aseqs; /* aligned seqs */
int num = 0; /* number of seqs read */
char buffer[LINEBUFLEN]; /* input buffer for lines */
char bufcpy[LINEBUFLEN]; /* strtok'able copy of buffer */
struct block_struc { /** alignment data for a block: */
int lcol; /* furthest left aligned sym */
int rcol; /* furthest right aligned sym */
} *blocks = NULL;
int blocknum; /* number of blocks in file */
char *nptr; /* ptr to start of name on line */
char *sptr; /* ptr into sequence on line */
int currnum; /* num. seqs in given block */
int currblock; /* index for blocks */
int i; /* loop counter */
int seqidx; /* counter for seqs */
int alen; /* length of alignment */
int warn_names; /* becomes TRUE if names don't match between blocks */
int headnum; /* seqidx in per-sequence header info */
int currlen;
int count;
int have_cs = 0;
int have_rf = 0;
AINFO base_ainfo, *ainfo; /* hack: used to be passed ptr to AINFO */
/* Convert from MSA interface to what old ReadSELEX() did:
* - copy our open fp, rather than opening file
* - verify that we're not reading a gzip or stdin
*/
if (feof(afp->f)) return NULL;
if (afp->do_gzip || afp->do_stdin)
Die("Can't read a SELEX format alignment from a pipe, stdin, or gzip'ed file");
fp = afp->f;
ainfo = &base_ainfo;
/***************************************************
* First pass across file.
* Count seqs, get names, determine column info
* Determine what sorts of info are active in this file.
***************************************************/
InitAinfo(ainfo);
/* get first line of the block
* (non-comment, non-blank) */
do
{
if (fgets(buffer, LINEBUFLEN, fp) == NULL)
{ squid_errno = SQERR_NODATA; return 0; }
strcpy(bufcpy, buffer);
if (*buffer == '#')
{
if (strncmp(buffer, "#=CS", 4) == 0) have_cs = 1;
else if (strncmp(buffer, "#=RF", 4) == 0) have_rf = 1;
}
}
while ((nptr = strtok(bufcpy, WHITESPACE)) == NULL ||
(strchr(commentsyms, *nptr) != NULL));
blocknum = 0;
warn_names = FALSE;
while (!feof(fp))
{
/* allocate for info about this block. */
if (blocknum == 0)
blocks = (struct block_struc *) MallocOrDie (sizeof(struct block_struc));
else
blocks = (struct block_struc *) ReallocOrDie (blocks, (blocknum+1) * sizeof(struct block_struc));
blocks[blocknum].lcol = LINEBUFLEN+1;
blocks[blocknum].rcol = -1;
currnum = 0;
while (nptr != NULL) /* becomes NULL when this block ends. */
{
/* First block only: save names */
if (blocknum == 0)
{
if (currnum == 0)
ainfo->sqinfo = (SQINFO *) MallocOrDie (sizeof(SQINFO));
else
ainfo->sqinfo = (SQINFO *) ReallocOrDie (ainfo->sqinfo, (currnum + 1) * sizeof(SQINFO));
ainfo->sqinfo[currnum].flags = 0;
SetSeqinfoString(&(ainfo->sqinfo[currnum]), nptr, SQINFO_NAME);
}
else /* in each additional block: check names */
{
if (strcmp(ainfo->sqinfo[currnum].name, nptr) != 0)
warn_names = TRUE;
}
currnum++;
/* check rcol, lcol */
if ((sptr = strtok(NULL, WHITESPACE)) != NULL)
{
/* is this the furthest left we've
seen word 2 in this block? */
if (sptr - bufcpy < blocks[blocknum].lcol)
blocks[blocknum].lcol = sptr - bufcpy;
/* look for right side in buffer */
for (sptr = buffer + strlen(buffer) - 1;
strchr(WHITESPACE, *sptr) != NULL;
sptr --)
/* do nothing */ ;
if (sptr - buffer > blocks[blocknum].rcol)
blocks[blocknum].rcol = sptr - buffer;
}
/* get the next line; blank line means end of block */
do
{
if (fgets(buffer, LINEBUFLEN, fp) == NULL)
{ nptr = NULL; break; }
strcpy(bufcpy, buffer);
if (strncmp(buffer, "#=SS", 4) == 0) ainfo->sqinfo[currnum-1].flags |= SQINFO_SS;
else if (strncmp(buffer, "#=SA", 4) == 0) ainfo->sqinfo[currnum-1].flags |= SQINFO_SA;
else if (strncmp(buffer, "#=CS", 4) == 0) have_cs = 1;
else if (strncmp(buffer, "#=RF", 4) == 0) have_rf = 1;
if ((nptr = strtok(bufcpy, WHITESPACE)) == NULL)
break;
} while (strchr(commentsyms, *nptr) != NULL);
}
/* check that number of sequences matches expected */
if (blocknum == 0)
num = currnum;
else if (currnum != num)
Die("Parse error in ReadSELEX()");
blocknum++;
/* get first line of next block
* (non-comment, non-blank) */
do
{
if (fgets(buffer, LINEBUFLEN, fp) == NULL) { nptr = NULL; break; }
strcpy(bufcpy, buffer);
}
while ((nptr = strtok(bufcpy, WHITESPACE)) == NULL ||
(strchr(commentsyms, *nptr) != NULL));
}
/***************************************************
* Get ready for second pass:
* figure out the length of the alignment
* malloc space
* rewind the file
***************************************************/
alen = 0;
for (currblock = 0; currblock < blocknum; currblock++)
alen += blocks[currblock].rcol - blocks[currblock].lcol + 1;
rewind(fp);
/* allocations. we can't use AllocateAlignment because of
* the way we already used ainfo->sqinfo.
*/
aseqs = (char **) MallocOrDie (num * sizeof(char *));
if (have_cs)
ainfo->cs = (char *) MallocOrDie ((alen+1) * sizeof(char));
if (have_rf)
ainfo->rf = (char *) MallocOrDie ((alen+1) * sizeof(char));
for (i = 0; i < num; i++)
{
aseqs[i] = (char *) MallocOrDie ((alen+1) * sizeof(char));
if (ainfo->sqinfo[i].flags & SQINFO_SS)
ainfo->sqinfo[i].ss = (char *) MallocOrDie ((alen+1) * sizeof(char));
if (ainfo->sqinfo[i].flags & SQINFO_SA)
ainfo->sqinfo[i].sa = (char *) MallocOrDie ((alen+1) * sizeof(char));
}
ainfo->alen = alen;
ainfo->nseq = num;
ainfo->wgt = (float *) MallocOrDie (sizeof(float) * num);
FSet(ainfo->wgt, num, 1.0);
/***************************************************
* Second pass across file. Parse header; assemble sequences
***************************************************/
/* We've now made a complete first pass over the file. We know how
* many blocks it contains, we know the number of seqs in the first
* block, and we know every block has the same number of blocks;
* so we can be a bit more cavalier about error-checking as we
* make the second pass.
*/
/* Look for header
*/
headnum = 0;
for (;;)
{
if (fgets(buffer, LINEBUFLEN, fp) == NULL)
Die("Parse error in ReadSELEX()");
strcpy(bufcpy, buffer);
if ((nptr = strtok(bufcpy, WHITESPACE)) == NULL) continue; /* skip blank lines */
if (strcmp(nptr, "#=AU") == 0 && (sptr = strtok(NULL, "\n")) != NULL)
ainfo->au = Strdup(sptr);
else if (strcmp(nptr, "#=ID") == 0 && (sptr = strtok(NULL, "\n")) != NULL)
ainfo->name = Strdup(sptr);
else if (strcmp(nptr, "#=AC") == 0 && (sptr = strtok(NULL, "\n")) != NULL)
ainfo->acc = Strdup(sptr);
else if (strcmp(nptr, "#=DE") == 0 && (sptr = strtok(NULL, "\n")) != NULL)
ainfo->desc = Strdup(sptr);
else if (strcmp(nptr, "#=GA") == 0)
{
if ((sptr = strtok(NULL, WHITESPACE)) == NULL)
Die("Parse error in #=GA line in ReadSELEX()");
ainfo->ga1 = atof(sptr);
if ((sptr = strtok(NULL, WHITESPACE)) == NULL)
Die("Parse error in #=GA line in ReadSELEX()");
ainfo->ga2 = atof(sptr);
ainfo->flags |= AINFO_GA;
}
else if (strcmp(nptr, "#=TC") == 0)
{
if ((sptr = strtok(NULL, WHITESPACE)) == NULL)
Die("Parse error in #=TC line in ReadSELEX()");
ainfo->tc1 = atof(sptr);
if ((sptr = strtok(NULL, WHITESPACE)) == NULL)
Die("Parse error in #=TC line in ReadSELEX()");
ainfo->tc2 = atof(sptr);
ainfo->flags |= AINFO_TC;
}
else if (strcmp(nptr, "#=NC") == 0)
{
if ((sptr = strtok(NULL, WHITESPACE)) == NULL)
Die("Parse error in #=NC line in ReadSELEX()");
ainfo->nc1 = atof(sptr);
if ((sptr = strtok(NULL, WHITESPACE)) == NULL)
Die("Parse error in #=NC line in ReadSELEX()");
ainfo->nc2 = atof(sptr);
ainfo->flags |= AINFO_NC;
}
else if (strcmp(nptr, "#=SQ") == 0) /* per-sequence header info */
{
/* first field is the name */
if ((sptr = strtok(NULL, WHITESPACE)) == NULL)
Die("Parse error in #=SQ line in ReadSELEX()");
if (strcmp(sptr, ainfo->sqinfo[headnum].name) != 0) warn_names = TRUE;
/* second field is the weight */
if ((sptr = strtok(NULL, WHITESPACE)) == NULL)
Die("Parse error in #=SQ line in ReadSELEX()");
if (!IsReal(sptr))
Die("Parse error in #=SQ line in ReadSELEX(): weight is not a number");
ainfo->wgt[headnum] = atof(sptr);
/* third field is database source id */
if ((sptr = strtok(NULL, WHITESPACE)) == NULL)
Die("Parse error in #=SQ line in ReadSELEX(): incomplete line");
SetSeqinfoString(&(ainfo->sqinfo[headnum]), sptr, SQINFO_ID);
/* fourth field is database accession number */
if ((sptr = strtok(NULL, WHITESPACE)) == NULL)
Die("Parse error in #=SQ line in ReadSELEX(): incomplete line");
SetSeqinfoString(&(ainfo->sqinfo[headnum]), sptr, SQINFO_ACC);
/* fifth field is start..stop::olen */
if ((sptr = strtok(NULL, ".:")) == NULL)
Die("Parse error in #=SQ line in ReadSELEX(): incomplete line");
SetSeqinfoString(&(ainfo->sqinfo[headnum]), sptr, SQINFO_START);
if ((sptr = strtok(NULL, ".:")) == NULL)
Die("Parse error in #=SQ line in ReadSELEX(): incomplete line");
SetSeqinfoString(&(ainfo->sqinfo[headnum]), sptr, SQINFO_STOP);
if ((sptr = strtok(NULL, ":\t ")) == NULL)
Die("Parse error in #=SQ line in ReadSELEX(): incomplete line");
SetSeqinfoString(&(ainfo->sqinfo[headnum]), sptr, SQINFO_OLEN);
/* rest of line is optional description */
if ((sptr = strtok(NULL, "\n")) != NULL)
SetSeqinfoString(&(ainfo->sqinfo[headnum]), sptr, SQINFO_DESC);
headnum++;
}
else if (strcmp(nptr, "#=CS") == 0) break;
else if (strcmp(nptr, "#=RF") == 0) break;
else if (strchr(commentsyms, *nptr) == NULL) break; /* non-comment, non-header */
}
currlen = 0;
for (currblock = 0 ; currblock < blocknum; currblock++)
{
/* parse the block */
seqidx = 0;
while (nptr != NULL)
{
/* Consensus structure */
if (strcmp(nptr, "#=CS") == 0)
{
if (! copy_alignment_line(ainfo->cs, currlen, strlen(nptr)-1,
buffer, blocks[currblock].lcol, blocks[currblock].rcol, (char) '.'))
Die("Parse error in #=CS line in ReadSELEX()");
}
/* Reference coordinates */
else if (strcmp(nptr, "#=RF") == 0)
{
if (! copy_alignment_line(ainfo->rf, currlen, strlen(nptr)-1,
buffer, blocks[currblock].lcol, blocks[currblock].rcol, (char) '.'))
Die("Parse error in #=RF line in ReadSELEX()");
}
/* Individual secondary structure */
else if (strcmp(nptr, "#=SS") == 0)
{
if (! copy_alignment_line(ainfo->sqinfo[seqidx-1].ss, currlen, strlen(nptr)-1,
buffer, blocks[currblock].lcol,
blocks[currblock].rcol, (char) '.'))
Die("Parse error in #=SS line in ReadSELEX()");
}
/* Side chain % surface accessibility code */
else if (strcmp(nptr, "#=SA") == 0)
{
if (! copy_alignment_line(ainfo->sqinfo[seqidx-1].sa, currlen, strlen(nptr)-1,
buffer, blocks[currblock].lcol,
blocks[currblock].rcol, (char) '.'))
Die("Parse error in #=SA line in ReadSELEX()");
}
/* Aligned sequence; avoid unparsed machine comments */
else if (strncmp(nptr, "#=", 2) != 0)
{
if (! copy_alignment_line(aseqs[seqidx], currlen, strlen(nptr)-1,
buffer, blocks[currblock].lcol, blocks[currblock].rcol, (char) '.'))
Die("Parse error in alignment line in ReadSELEX()");
seqidx++;
}
/* get next line */
for (;;)
{
nptr = NULL;
if (fgets(buffer, LINEBUFLEN, fp) == NULL) break; /* EOF */
strcpy(bufcpy, buffer);
if ((nptr = strtok(bufcpy, WHITESPACE)) == NULL) break; /* blank */
if (strncmp(buffer, "#=", 2) == 0) break; /* machine comment */
if (strchr(commentsyms, *nptr) == NULL) break; /* data */
}
} /* end of a block */
currlen += blocks[currblock].rcol - blocks[currblock].lcol + 1;
/* get line 1 of next block */
for (;;)
{
if (fgets(buffer, LINEBUFLEN, fp) == NULL) break; /* no data */
strcpy(bufcpy, buffer);
if ((nptr = strtok(bufcpy, WHITESPACE)) == NULL) continue; /* blank */
if (strncmp(buffer, "#=", 2) == 0) break; /* machine comment */
if (strchr(commentsyms, *nptr) == NULL) break; /* non-comment */
}
} /* end of the file */
/* Lengths in sqinfo are for raw sequence (ungapped),
* and SS, SA are 0..rlen-1 not 0..alen-1.
* Only the seqs with structures come out of here with lengths set.
*/
for (seqidx = 0; seqidx < num; seqidx++)
{
int apos, rpos;
/* secondary structures */
if (ainfo->sqinfo[seqidx].flags & SQINFO_SS)
{
for (apos = rpos = 0; apos < alen; apos++)
if (! isgap(aseqs[seqidx][apos]))
{
ainfo->sqinfo[seqidx].ss[rpos] = ainfo->sqinfo[seqidx].ss[apos];
rpos++;
}
ainfo->sqinfo[seqidx].ss[rpos] = '\0';
}
/* Surface accessibility */
if (ainfo->sqinfo[seqidx].flags & SQINFO_SA)
{
for (apos = rpos = 0; apos < alen; apos++)
if (! isgap(aseqs[seqidx][apos]))
{
ainfo->sqinfo[seqidx].sa[rpos] = ainfo->sqinfo[seqidx].sa[apos];
rpos++;
}
ainfo->sqinfo[seqidx].sa[rpos] = '\0';
}
}
/* NULL-terminate all the strings */
if (ainfo->rf != NULL) ainfo->rf[alen] = '\0';
if (ainfo->cs != NULL) ainfo->cs[alen] = '\0';
for (seqidx = 0; seqidx < num; seqidx++)
aseqs[seqidx][alen] = '\0';
/* find raw sequence lengths for sqinfo */
for (seqidx = 0; seqidx < num; seqidx++)
{
count = 0;
for (sptr = aseqs[seqidx]; *sptr != '\0'; sptr++)
if (!isgap(*sptr)) count++;
ainfo->sqinfo[seqidx].len = count;
ainfo->sqinfo[seqidx].flags |= SQINFO_LEN;
}
/***************************************************
* Garbage collection and return
***************************************************/
free(blocks);
if (warn_names)
Warn("sequences may be in different orders in blocks of %s?", afp->fname);
/* Convert back to MSA structure. (Wasteful kludge.)
*/
msa = MSAFromAINFO(aseqs, ainfo);
MSAVerifyParse(msa);
FreeAlignment(aseqs, ainfo);
return msa;
}
/* Function: ParsePAMFile()
*
* Purpose: Given a pointer to an open file containing a PAM matrix,
* parse the file and allocate and fill a 2D array of
* floats containing the matrix. The PAM file is
* assumed to be in the format that NCBI distributes
* with BLAST. BLOSUM matrices also work fine, as
* produced by Henikoff's program "MATBLAS".
*
* Parses both old format and new format BLAST matrices.
* Old format just had rows of integers.
* New format includes a leading character on each row.
*
* The PAM matrix is a 27x27 matrix, 0=A..25=Z,26=*.
* Note that it's not a 20x20 matrix as you might expect;
* this is for speed of indexing as well as the ability
* to deal with ambiguous characters.
*
* Args: fp - open PAM file
* ret_pam - RETURN: pam matrix, integers
* ret_scale - RETURN: scale factor for converting
* to real Sij. For instance, PAM120 is
* given in units of ln(2)/2. This may
* be passed as NULL if the caller
* doesn't care.
*
* Returns: 1 on success; 0 on failure and sets squid_errno to
* indicate the cause. ret_pam is allocated here and
* must be freed by the caller (use FreePAM).
*/
int
ParsePAMFile(FILE *fp, int ***ret_pam, float *ret_scale)
{
int **pam;
char buffer[512]; /* input buffer from fp */
int order[27]; /* order of fields, obtained from header */
int nsymbols; /* total number of symbols in matrix */
char *sptr;
int idx;
int row, col;
float scale;
int gotscale = FALSE;
if (fp == NULL) { squid_errno = SQERR_NODATA; return 0; }
/* Look at the first non-blank, non-comment line in the file.
* It gives single-letter codes in the order the PAM matrix
* is arrayed in the file.
*/
do {
if (fgets(buffer, 512, fp) == NULL)
{ squid_errno = SQERR_NODATA; return 0; }
/* Get the scale factor from the header.
* For BLOSUM files, we assume the line looks like:
* BLOSUM Clustered Scoring Matrix in 1/2 Bit Units
* and we assume that the fraction is always 1/x;
*
* For PAM files, we assume the line looks like:
* PAM 120 substitution matrix, scale = ln(2)/2 = 0.346574
* and we assume that the number following the final '=' is our scale
*/
if (strstr(buffer, "BLOSUM Clustered Scoring Matrix") != NULL &&
(sptr = strchr(buffer, '/')) != NULL)
{
sptr++;
if (! isdigit(*sptr)) { squid_errno = SQERR_FORMAT; return 0; }
scale = (float) (log(2.0) / atof(sptr));
gotscale = TRUE;
}
else if (strstr(buffer, "substitution matrix,") != NULL)
{
while ((sptr = strrchr(buffer, '=')) != NULL) {
sptr += 2;
if (IsReal(sptr)) {
scale = atof(sptr);
gotscale = TRUE;
break;
}
}
}
} while ((sptr = strtok(buffer, " \t\n")) == NULL || *sptr == '#');
idx = 0;
do {
order[idx] = (int) *sptr - (int) 'A';
if (order[idx] < 0 || order[idx] > 25) order[idx] = 26;
idx++;
} while ((sptr = strtok(NULL, " \t\n")) != NULL);
nsymbols = idx;
/* Allocate a pam matrix. For speed of indexing, we use
* a 27x27 matrix so we can do lookups using the ASCII codes
* of amino acid single-letter representations, plus one
* extra field to deal with the "*" (terminators).
*/
if ((pam = (int **) calloc (27, sizeof(int *))) == NULL)
Die("calloc failed");
for (idx = 0; idx < 27; idx++)
if ((pam[idx] = (int *) calloc (27, sizeof(int))) == NULL)
Die("calloc failed");
/* Parse the rest of the file.
*/
for (row = 0; row < nsymbols; row++)
{
if (fgets(buffer, 512, fp) == NULL)
{ squid_errno = SQERR_NODATA; return 0; }
if ((sptr = strtok(buffer, " \t\n")) == NULL)
{ squid_errno = SQERR_NODATA; return 0; }
for (col = 0; col < nsymbols; col++)
{
if (sptr == NULL) { squid_errno = SQERR_NODATA; return 0; }
/* Watch out for new BLAST format, with leading characters
*/
if (*sptr == '*' || isalpha((int) *sptr))
col--; /* hack hack */
else
pam [order[row]] [order[col]] = atoi(sptr);
sptr = strtok(NULL, " \t\n");
}
}
/* Return
*/
if (ret_scale != NULL)
{
if (gotscale) *ret_scale = scale;
else
{
Warn("Failed to parse PAM matrix scale factor. Defaulting to ln(2)/2!");
*ret_scale = log(2.0) / 2.0;
}
}
*ret_pam = pam;
return 1;
}
/* Function: Getopt()
*
* Purpose: Portable command line option parsing with abbreviated
* option switches. Replaces UNIX getopt(). Using UNIX getopt()
* hinders portability to non-UNIX platforms, and getopt()
* is also limited to single letter options.
*
* Getopt() implements a superset of UNIX getopt().
* All of getopt()'s single-character switch behavior
* is emulated, and "--" by itself terminates the options.
* Additionally, Getopt() provides extended switches
* like "--youroptionhere", and Getopt() type checks
* arguments.
*
* Extended options must start with "--", as in "--option1".
* Normal options must start with "-", as in "-o".
* Normal options may be concatenated, as in "-a -b" == "-ab".
*
* See bottom of this .c file after #fdef GETOPT_TESTDRIVER
* for an example of calling Getopt().
*
* Args: argc - from main(). number of elems in argv.
* argv - from main(). argv[0] is the name of the command.
* opt - array of opt_s structures, defining option switches
* nopts - number of switches in opt
* usage - a (possibly long) string to print if usage error.
* ret_optind - RETURN: the index in argv[] of the next
* valid command-line token.
* ret_optname- RETURN: ptr to the name of option switch
* seen, or NULL if no option was seen.
* ret_optarg - RETURN: ptr to the optional argument, if any;
* NULL if option takes no argument.
*
* Return: 1 if a valid option was parsed.
* 0 if no option was found, and command-line parsing is complete.
* Die()'s here if an error is detected.
*/
int
Getopt(int argc, char **argv, struct opt_s *opt, int nopts, char *usage,
int *ret_optind, char **ret_optname, char **ret_optarg)
{
int i;
int arglen;
int nmatch;
static int optindex = 1; /* init to 1 on first call */
static char *optptr = NULL; /* ptr to next valid switch */
int opti=0;
/* Check to see if we've run out of options.
* A '-' by itself is an argument (e.g. "read from stdin")
* not an option.
*/
if (optindex >= argc || argv[optindex][0] != '-' || strcmp(argv[optindex], "-") == 0)
{
*ret_optind = optindex;
*ret_optarg = NULL;
*ret_optname = NULL;
return 0;
}
/* Check to see if we're being told that this is the end
* of the options with the special "--" flag.
*/
if (strcmp(argv[optindex], "--") == 0)
{
optindex++;
*ret_optind = optindex;
*ret_optname = NULL;
*ret_optarg = NULL;
return 0;
}
/* We have a real option. Find which one it is.
* We handle single letter switches "-o" separately
* from full switches "--option", based on the "-" vs. "--"
* prefix -- single letter switches can be concatenated
* as long as they don't have arguments.
*/
/* full option */
if (optptr == NULL && strncmp(argv[optindex], "--", 2) == 0)
{
/* Use optptr to parse argument in options of form "--foo=666"
*/
if ((optptr = strchr(argv[optindex], '=')) != NULL)
{ *optptr = '\0'; optptr++; }
arglen = strlen(argv[optindex]);
nmatch = 0;
for (i = 0; i < nopts; i++)
if (opt[i].single == FALSE &&
strncmp(opt[i].name, argv[optindex], arglen) == 0)
{
nmatch++;
opti = i;
if (arglen == strlen(opt[i].name)) break; /* exact match, stop now */
}
if (nmatch > 1 && arglen != strlen(opt[i].name))
Die("Option \"%s\" is ambiguous; please be more specific.\n%s",
argv[optindex], usage);
if (nmatch == 0)
Die("No such option \"%s\".\n%s", argv[optindex], usage);
*ret_optname = opt[opti].name;
/* Set the argument, if there is one
*/
if (opt[opti].argtype != sqdARG_NONE)
{
if (optptr != NULL)
{ /* --foo=666 style */
*ret_optarg = optptr;
optptr = NULL;
optindex++;
}
else if (optindex+1 >= argc)
Die("Option %s requires an argument\n%s", opt[opti].name, usage);
else /* "--foo 666" style */
{
*ret_optarg = argv[optindex+1];
optindex+=2;
}
}
else /* sqdARG_NONE */
{
if (optptr != NULL)
Die("Option %s does not take an argument\n%s", opt[opti].name, usage);
*ret_optarg = NULL;
optindex++;
}
}
else /* else, a single letter option "-o" */
{
/* find the option */
if (optptr == NULL)
optptr = argv[optindex]+1;
for (opti = -1, i = 0; i < nopts; i++)
if (opt[i].single == TRUE && *optptr == opt[i].name[1])
{ opti = i; break; }
if (opti == -1)
Die("No such option \"%c\".\n%s", *optptr, usage);
*ret_optname = opt[opti].name;
/* set the argument, if there is one */
if (opt[opti].argtype != sqdARG_NONE)
{
if (*(optptr+1) != '\0') /* attached argument */
{
*ret_optarg = optptr+1;
optindex++;
}
else if (optindex+1 < argc) /* unattached argument */
{
*ret_optarg = argv[optindex+1];
optindex+=2;
}
else Die("Option %s requires an argument\n%s", opt[opti].name, usage);
optptr = NULL; /* can't concatenate after an argument */
}
else /* sqdARG_NONE */
{
*ret_optarg = NULL;
if (*(optptr+1) != '\0') /* concatenation */
optptr++;
else
{
optindex++; /* move to next field */
optptr = NULL;
}
}
}
/* Type check the argument, if there is one
*/
if (opt[opti].argtype != sqdARG_NONE)
{
if (opt[opti].argtype == sqdARG_INT && ! IsInt(*ret_optarg))
Die("Option %s requires an integer argument\n%s",
opt[opti].name, usage);
else if (opt[opti].argtype == sqdARG_FLOAT && ! IsReal(*ret_optarg))
Die("Option %s requires a numerical argument\n%s",
opt[opti].name, usage);
else if (opt[opti].argtype == sqdARG_CHAR && strlen(*ret_optarg) != 1)
Die("Option %s requires a single-character argument\n%s",
opt[opti].name, usage);
/* sqdARG_STRING is always ok, no type check necessary */
}
*ret_optind = optindex;
return 1;
}