vector<Tokenizer::Token> Tokenizer::getTokensUntilNextLine(bool from_start)
{
// Reset to start of line if needed
if (from_start)
{
resetToLineStart();
readNext(&token_current_);
readNext(&token_next_);
}
vector<Token> tokens;
while (!atEnd())
{
tokens.push_back(token_current_);
if (token_next_.line_no > token_current_.line_no)
{
adv();
break;
}
adv();
}
return tokens;
}
void play()
{
nodelay(stdscr,1);
int last=clock(),t=0;
draw();
while (1)
{
if (level[PLROW][px]==tree)
{
die();
}
switch (getch())
{
case '4':
case KEY_LEFT:
case ',':
last=clock();
if (level[PLROW][px] == snow) level[PLROW][px]=ltrail;
px--;
adv();
break;
case'6':
case KEY_RIGHT:
case'.':
last=clock();
if (level[PLROW][px] == snow) level[PLROW][px]=rtrail;
px++;
adv();
break;
case'5':
case' ':
case KEY_DOWN:
last=clock();
if (level[PLROW][px] == snow) level[PLROW][px]=dtrail;
adv();
break;
case'q':
case'Q':
again();
break;
default:
break;
}
t=clock()-last;
if (t>=magicNumber)
{
if (level[PLROW][px] == snow) level[PLROW][px]=dtrail;
adv();
last=clock();
}
}
}
/*********************************************************
* ~RunReduce destructor returns the state of the worker *
* to what is expected by the master after a reduce is *
* finished. *
* ******************************************************/
RunReduce::~RunReduce() {
try {
saga::url fileurl(outputPrefix_ + "/mapFile-reduced");
saga::advert::entry adv(workerDir_.open(saga::url("./output"), saga::advert::ReadWrite | saga::advert::Create));
adv.store_string(fileurl.get_string());
}
catch(saga::exception const& e) {
throw;
}
}
bool Tokenizer::advIfNC(const string& check, size_t inc)
{
if (S_CMPNOCASE(token_current_.text, check))
{
adv(inc);
return true;
}
return false;
}
bool Tokenizer::advIf(char check, size_t inc)
{
if (token_current_ == check)
{
adv(inc);
return true;
}
return false;
}
// ----------------------------------------------------------------------------
// Tokenizer::skipSection
//
// Advances tokens until [end] is found. Can also handle nesting if [begin] is
// specified. If [allow_quoted] is true, section delimiters will count even if
// within a quoted string.
//
// Relies on the current token being *within* the section to be skipped, and
// will exit on the token after the end of the section.
// ----------------------------------------------------------------------------
void Tokenizer::skipSection(const char* begin, const char* end, bool allow_quoted)
{
int depth = 1;
while (depth > 0 && !atEnd())
{
if (token_current_.quoted_string && !allow_quoted)
{
adv();
continue;
}
if (token_current_ == begin)
depth++;
if (token_current_ == end)
depth--;
adv();
}
}
void pop_ws(void)
{
/* Step 1: toss top of wait stack - return if at end */
reset_start(wsc);
if (end_adv(wsc))
return;
delete(wsc);
adv(wsc);
/* Step 2: continue popping items that are no longer valid
or the wait stack is empty */
while( !end_adv(wsc) ) {
if (test_valid(wsc.cont, wsc.cursor_position))
return;
delete(wsc);
adv(wsc);
}
}
VectorHashTable<Parms>::FindIterator
::FindIterator(const HashTable * ht, const key_type & k)
: vector(&ht->vector())
, parms(&ht->parms())
, key(k)
, i(ht->hash1(k))
, hash2(ht->hash2(k))
{
if (!parms->is_nonexistent((*vector)[i])
&& !parms->equal(parms->key((*vector)[i]), key))
adv();
}
bool Tokenizer::advIfNext(char check, size_t inc)
{
if (!token_next_.valid)
return false;
if (token_next_ == check)
{
adv(inc);
return true;
}
return false;
}
// ----------------------------------------------------------------------------
// Tokenizer::advIfNextNC
//
// Advances [inc] tokens if the next token matches [check] (Case-Insensitive)
// ----------------------------------------------------------------------------
bool Tokenizer::advIfNextNC(const char* check, size_t inc)
{
if (!token_next_.valid)
return false;
if (S_CMPNOCASE(token_next_.text, check))
{
adv(inc);
return true;
}
return false;
}
vector<Tokenizer::Token> Tokenizer::getTokensUntilNC(const char* end)
{
vector<Token> tokens;
while (!atEnd())
{
tokens.push_back(token_current_);
adv();
if (token_current_ == end)
break;
}
return tokens;
}
void Tokenizer::advToEndOfLine()
{
// Ignore if we're on the last token already
if (!token_next_.valid)
return;
// Ignore if the next token is on the next line
if (token_next_.line_no > token_current_.line_no)
return;
// Otherwise skip until the next token is on the next line
// (or we reach the last token)
while (token_next_.pos_start > token_current_.pos_start &&
token_next_.line_no <= token_current_.line_no)
adv();
}
adouble func_eval(adouble *x){
adouble fad=0;
advector adv(NUM_IND);
adv[x[0]]=x[0];
adv[x[1]]=x[1];
adv[x[2]]=x[2];
condassign(adv[x[3]],x[0]-x[1],x[0],(adouble)adv[x[1]]);
condassign(adv[x[4]],x[2]-x[1],(adouble)adv[x[2]],(adouble)adv[x[3]]);
condassign(adv[x[5]],x[3]-x[2],x[5]);
adv[x[0]]+=cosh((adouble)adv[x[0]]);
adv[x[1]]-=0.2;
adv[x[1]-x[0]]=exp((adouble)adv[x[5]]);
fad+=adv[0]*adv[1]*adv[2]*adv[3]*adv[4]*adv[5];
// adv[x[0]]=adv[x[1]];
// fad=adv[x[0]]+adv[x[2]];
return fad;
}
// TODO Processors cannot output zeros because an empty string is all 1s
// the fix is to allow effects to take the GrGLSLExpr4 directly
void GrGLProgramBuilder::emitAndInstallProc(const GrFragmentProcessor& fp,
int index,
const GrGLSLExpr4& input,
GrGLSLExpr4* output) {
// Program builders have a bit of state we need to clear with each effect
AutoStageAdvance adv(this);
this->nameExpression(output, "output");
// Enclose custom code in a block to avoid namespace conflicts
SkString openBrace;
openBrace.printf("{ // Stage %d, %s\n", fStageIndex, fp.name());
fFS.codeAppend(openBrace.c_str());
this->emitAndInstallProc(fp, index, output->c_str(), input.isOnes() ? nullptr : input.c_str());
fFS.codeAppend("}");
}
void GrGLProgramBuilder::emitAndInstallProc(const GrPrimitiveProcessor& proc,
GrGLSLExpr4* outputColor,
GrGLSLExpr4* outputCoverage) {
// Program builders have a bit of state we need to clear with each effect
AutoStageAdvance adv(this);
this->nameExpression(outputColor, "outputColor");
this->nameExpression(outputCoverage, "outputCoverage");
// Enclose custom code in a block to avoid namespace conflicts
SkString openBrace;
openBrace.printf("{ // Stage %d, %s\n", fStageIndex, proc.name());
fFS.codeAppend(openBrace.c_str());
this->emitAndInstallProc(proc, outputColor->c_str(), outputCoverage->c_str());
fFS.codeAppend("}");
}
/*********************************************************
* RunReduce constructor sets the state of the worker and*
* retreives input files from the advert database posted *
* by the master. *
* ******************************************************/
RunReduce::RunReduce(saga::advert::directory workerDir, saga::advert::directory reduceInputDir,
std::string outputPrefix) {
int mode = saga::advert::ReadWrite;
workerDir_ = workerDir;
reduceInputDir_ = reduceInputDir;
outputPrefix_ = outputPrefix;
try {
std::vector<saga::url> entries = reduceInputDir_.list("*");
std::vector<saga::url>::const_iterator entriesIT = entries.begin();
while(entriesIT != entries.end()) {
saga::advert::entry adv(reduceInputDir_.open(*entriesIT, mode));
files_.push_back(adv.retrieve_string());
entriesIT++;
}
}
catch(saga::exception const & e) {
throw;
}
}
void GrGLProgramBuilder::emitAndInstallXferProc(const GrXferProcessor& xp,
const GrGLSLExpr4& colorIn,
const GrGLSLExpr4& coverageIn) {
// Program builders have a bit of state we need to clear with each effect
AutoStageAdvance adv(this);
SkASSERT(!fXferProcessor);
fXferProcessor = new GrGLInstalledXferProc;
fXferProcessor->fGLProc.reset(xp.createGLSLInstance());
// Enable dual source secondary output if we have one
if (xp.hasSecondaryOutput()) {
fFS.enableSecondaryOutput();
}
if (this->glslCaps()->mustDeclareFragmentShaderOutput()) {
fFS.enableCustomOutput();
}
SkString openBrace;
openBrace.printf("{ // Xfer Processor: %s\n", xp.name());
fFS.codeAppend(openBrace.c_str());
SkSTArray<4, GrGLSLTextureSampler> samplers(xp.numTextures());
this->emitSamplers(xp, &samplers, fXferProcessor);
GrGLSLXferProcessor::EmitArgs args(this,
&fFS,
this->glslCaps(),
xp, colorIn.c_str(),
coverageIn.c_str(),
fFS.getPrimaryColorOutputName(),
fFS.getSecondaryColorOutputName(),
samplers);
fXferProcessor->fGLProc->emitCode(args);
// We have to check that effects and the code they emit are consistent, ie if an effect
// asks for dst color, then the emit code needs to follow suit
verify(xp);
fFS.codeAppend("}");
}
void TeaBot::engage() {
if (Broodwar->enemy()->getUnits().empty()) {
state = ADV;
adv();
return;
}
map<Unit*,int> attacked;
set<Unit*> units = Broodwar->self()->getUnits();
set<Unit*> enemies = Broodwar->enemy()->getUnits();
double x2, y2;
findCentre(enemies, x2, y2);
forUnitSet (enemy, enemies) {
Unit *target = (*enemy)->getOrderTarget();
if (target && target->exists())
if (target->getPlayer() == Broodwar->self())
if (attacked.find(target) != attacked.end())
++attacked[target];
else
attacked[target] = 1;
}
int main()
{
task_scheduler_init init;
string nameFile = "";
cout<<"Ingrese el nombre del archivo"<<endl;
cin>>nameFile;
Adverbio adv(nameFile);
adv.loadAdverbs();
adv.openFile();
cout<<"Se leyeron: "<<adv.getNumLines()-1<<"\t lineas."<<endl;
adv.start();
adv.giveValues(dFile1,list1,nAdverbios1);
Average avg;
parallel_for( blocked_range<int>( 1, list1.size() ), avg );
imprimeNAdverbios();
//adv.countAdverbs();
//adv.getNAdverbios();
return 0;
}
void serialize()
{
// create a small test file
int mode = saga::advert::Create | saga::advert::ReadWrite;
saga::advert::entry adv1 (saga::url("/test.adv"), mode);
std::string url1(adv1.get_url().get_string());
// serialize logical_file
std::string data1(saga::adaptors::serialize(adv1));
adv1.close();
// re-create a saga::logical_file
saga::advert::entry adv2 (saga::adaptors::deserialize(data1));
BOOST_CHECK_EQUAL(url1, adv2.get_url().get_string());
std::string data2(saga::adaptors::serialize(adv2));
BOOST_CHECK_EQUAL(data1, data2);
adv2.close();
saga::advert::directory adv(saga::url("/"), mode);
adv.remove("test.adv");
}
void GrGLSLProgramBuilder::emitAndInstallPrimProc(const GrPrimitiveProcessor& proc,
GrGLSLExpr4* outputColor,
GrGLSLExpr4* outputCoverage) {
// Program builders have a bit of state we need to clear with each effect
AutoStageAdvance adv(this);
this->nameExpression(outputColor, "outputColor");
this->nameExpression(outputCoverage, "outputCoverage");
// Enclose custom code in a block to avoid namespace conflicts
SkString openBrace;
openBrace.printf("{ // Stage %d, %s\n", fStageIndex, proc.name());
fFS.codeAppend(openBrace.c_str());
fVS.codeAppendf("// Primitive Processor %s\n", proc.name());
SkASSERT(!fGeometryProcessor);
fGeometryProcessor = proc.createGLSLInstance(*this->glslCaps());
SkSTArray<4, SamplerHandle> texSamplers(proc.numTextures());
SkSTArray<2, SamplerHandle> bufferSamplers(proc.numBuffers());
this->emitSamplers(proc, &texSamplers, &bufferSamplers);
GrGLSLGeometryProcessor::EmitArgs args(&fVS,
&fFS,
this->varyingHandler(),
this->uniformHandler(),
this->glslCaps(),
proc,
outputColor->c_str(),
outputCoverage->c_str(),
texSamplers.begin(),
bufferSamplers.begin(),
fCoordTransforms,
&fOutCoords);
fGeometryProcessor->emitCode(args);
// We have to check that effects and the code they emit are consistent, ie if an effect
// asks for dst color, then the emit code needs to follow suit
SkDEBUGCODE(verify(proc);)
unsigned int calc(double sample,uint64* state)
{
int v;
uint64 sample_int=sample*((double)(UINT64(1)<<53));
uint32 x1=sample_int>>27;
uint32 x2=sample_int & ((1<<27)-1);
uint32 out;
if ((sample>=1.0) || (sample<0.0))
{
// Error - bad input
return 1;
}
for (v=0;v<(1<<22);v++)
{
*state=adv((((uint64)x1)<<22)|v);
out=((*state)>>(48-27))&((1<<27)-1);
if (out==x2)
{
return 0;
}
}
// Could not find PRNG internal state
return 2;
}
HT_Iterator(Node * * t0) : t(t0) {adv();}
/** @return number of skipped (invalid) documents */
unsigned compactExtent(const char *ns, NamespaceDetails *d, const DiskLoc ext, int n,
const scoped_array<IndexSpec> &indexSpecs,
scoped_array<SortPhaseOne>& phase1, int nidx, bool validate,
double pf, int pb)
{
log() << "compact extent #" << n << endl;
unsigned oldObjSize = 0; // we'll report what the old padding was
unsigned oldObjSizeWithPadding = 0;
Extent *e = ext.ext();
e->assertOk();
assert( e->validates() );
unsigned skipped = 0;
{
// the next/prev pointers within the extent might not be in order so we first page the whole thing in
// sequentially
log() << "compact paging in len=" << e->length/1000000.0 << "MB" << endl;
Timer t;
MAdvise adv(e, e->length, MAdvise::Sequential);
const char *p = (const char *) e;
for( int i = 0; i < e->length; i += 4096 ) {
faux += p[i];
}
int ms = t.millis();
if( ms > 1000 )
log() << "compact end paging in " << ms << "ms " << e->length/1000000.0/ms << "MB/sec" << endl;
}
{
log() << "compact copying records" << endl;
unsigned totalSize = 0;
int nrecs = 0;
DiskLoc L = e->firstRecord;
if( !L.isNull() ) {
while( 1 ) {
Record *recOld = L.rec();
L = recOld->nextInExtent(L);
nrecs++;
BSONObj objOld(recOld);
if( !validate || objOld.valid() ) {
unsigned sz = objOld.objsize();
oldObjSize += sz;
oldObjSizeWithPadding += recOld->netLength();
unsigned lenWHdr = sz + Record::HeaderSize;
unsigned lenWPadding = lenWHdr;
{
lenWPadding = static_cast<unsigned>(pf*lenWPadding);
lenWPadding += pb;
lenWPadding = lenWPadding & quantizeMask(lenWPadding);
if( lenWPadding < lenWHdr || lenWPadding > BSONObjMaxUserSize / 2 ) {
lenWPadding = lenWHdr;
}
}
totalSize += lenWPadding;
DiskLoc loc = allocateSpaceForANewRecord(ns, d, lenWPadding, false);
uassert(14024, "compact error out of space during compaction", !loc.isNull());
Record *recNew = loc.rec();
recNew = (Record *) getDur().writingPtr(recNew, lenWHdr);
addRecordToRecListInExtent(recNew, loc);
memcpy(recNew->data, objOld.objdata(), sz);
{
// extract keys for all indexes we will be rebuilding
for( int x = 0; x < nidx; x++ ) {
phase1[x].addKeys(indexSpecs[x], objOld, loc);
}
}
}
else {
if( ++skipped <= 10 )
log() << "compact skipping invalid object" << endl;
}
if( L.isNull() ) {
// we just did the very last record from the old extent. it's still pointed to
// by the old extent ext, but that will be fixed below after this loop
break;
}
// remove the old records (orphan them) periodically so our commit block doesn't get too large
bool stopping = false;
RARELY stopping = *killCurrentOp.checkForInterruptNoAssert() != 0;
if( stopping || getDur().aCommitIsNeeded() ) {
e->firstRecord.writing() = L;
Record *r = L.rec();
getDur().writingInt(r->prevOfs) = DiskLoc::NullOfs;
getDur().commitIfNeeded();
killCurrentOp.checkForInterrupt(false);
}
}
} // if !L.isNull()
assert( d->firstExtent == ext );
assert( d->lastExtent != ext );
DiskLoc newFirst = e->xnext;
d->firstExtent.writing() = newFirst;
newFirst.ext()->xprev.writing().Null();
getDur().writing(e)->markEmpty();
freeExtents(ext,ext);
getDur().commitIfNeeded();
{
double op = 1.0;
if( oldObjSize )
op = static_cast<double>(oldObjSizeWithPadding)/oldObjSize;
log() << "compact " << nrecs << " documents " << totalSize/1000000.0 << "MB"
<< " oldPadding: " << op << ' ' << static_cast<unsigned>(op*100.0)/100
<< endl;
}
}
return skipped;
}
VL_EXPORT
void
vl_mser_ell_fit (VlMserFilt* f)
{
/* shortcuts */
int nel = f-> nel ;
int dof = f-> dof ;
int *dims = f-> dims ;
int ndims = f-> ndims ;
int *subs = f-> subs ;
int njoins = f-> njoins ;
vl_uint *joins = f-> joins ;
VlMserReg *r = f-> r ;
vl_uint *mer = f-> mer ;
int nmer = f-> nmer ;
vl_mser_acc *acc = f-> acc ;
vl_mser_acc *ell = f-> ell ;
int d, index, i, j ;
/* already fit ? */
if (f->nell == f->nmer) return ;
/* make room */
if (f->rell < f->nmer) {
if (f->ell) vl_free (f->ell) ;
f->ell = vl_malloc (sizeof(float) * f->nmer * f->dof) ;
f->rell = f-> nmer ;
}
if (f->acc == 0) {
f->acc = vl_malloc (sizeof(float) * f->nel) ;
}
acc = f-> acc ;
ell = f-> ell ;
/* -----------------------------------------------------------------
* Integrate moments
* -------------------------------------------------------------- */
/* for each dof */
for(d = 0 ; d < f->dof ; ++d) {
/* start from the upper-left pixel (0,0,...,0) */
memset (subs, 0, sizeof(int) * ndims) ;
/* step 1: fill acc pretending that each region has only one pixel */
if(d < ndims) {
/* 1-order ................................................... */
for(index = 0 ; index < nel ; ++ index) {
acc [index] = subs [d] ;
adv(ndims, dims, subs) ;
}
}
else {
/* 2-order ................................................... */
/* map the dof d to a second order moment E[x_i x_j] */
i = d - ndims ;
j = 0 ;
while(i > j) {
i -= j + 1 ;
j ++ ;
}
/* initialize acc with x_i * x_j */
for(index = 0 ; index < nel ; ++ index){
acc [index] = subs [i] * subs [j] ;
adv(ndims, dims, subs) ;
}
}
/* step 2: integrate */
for(i = 0 ; i < njoins ; ++i) {
vl_uint index = joins [i] ;
vl_uint parent = r [index] .parent ;
acc [parent] += acc [index] ;
}
/* step 3: save back to ellpises */
for(i = 0 ; i < nmer ; ++i) {
vl_uint idx = mer [i] ;
ell [d + dof*i] = acc [idx] ;
}
} /* next dof */
/* -----------------------------------------------------------------
* Compute central moments
* -------------------------------------------------------------- */
for(index = 0 ; index < nmer ; ++index) {
float *pt = ell + index * dof ;
vl_uint idx = mer [index] ;
float area = r [idx] .area ;
for(d = 0 ; d < dof ; ++d) {
pt [d] /= area ;
if(d >= ndims) {
/* remove squared mean from moment to get variance */
i = d - ndims ;
j = 0 ;
while(i > j) {
i -= j + 1 ;
j ++ ;
}
pt [d] -= pt [i] * pt [j] ;
}
}
}
/* save back */
f-> nell = nmer ;
}
void inc() {n = &(*n)->next; if (*n == 0) {++t; adv();}}
QVariantMap L2tpWidget::setting() const
{
NetworkManager::VpnSetting setting;
setting.setServiceType(QLatin1String(NM_DBUS_SERVICE_L2TP));
NMStringMap data;
if (!m_tmpAdvancedSetting.isNull()) {
data = m_tmpAdvancedSetting->data();
} else {
// retrieve the settings if the dialog has not been opened
QScopedPointer<L2tpAdvancedWidget> adv(new L2tpAdvancedWidget(m_setting, Q_NULLPTR));
data = adv->setting();
}
if (!m_tmpPppSetting.isNull()) {
data.unite(m_tmpPppSetting->data());
} else {
// retrieve the settings if the dialog has not been opened
QScopedPointer<L2tpPPPWidget> ppp(new L2tpPPPWidget(m_setting, Q_NULLPTR));
data.unite(ppp->setting());
}
NMStringMap secrets;
if (!m_ui->gateway->text().isEmpty()) {
data.insert(NM_L2TP_KEY_GATEWAY, m_ui->gateway->text());
}
if (m_ui->cbUseCertificate->isChecked()) {
data.insert(NM_L2TP_KEY_USE_CERT, "yes");
if (!m_ui->urCACertificate->text().isEmpty()) {
data.insert(NM_L2TP_KEY_CERT_CA, m_ui->urCACertificate->text());
}
if (!m_ui->urCertificate->text().isEmpty()) {
data.insert(NM_L2TP_KEY_CERT_PUB, m_ui->urCertificate->text());
}
if (!m_ui->urPrivateKey->text().isEmpty()) {
data.insert(NM_L2TP_KEY_CERT_KEY, m_ui->urPrivateKey->text());
}
data.insert(NM_L2TP_KEY_PASSWORD"-flags", QString::number(NetworkManager::Setting::NotRequired));
} else {
if (!m_ui->username->text().isEmpty()) {
data.insert(NM_L2TP_KEY_USER, m_ui->username->text());
}
if (m_ui->password->isEnabled() && !m_ui->password->text().isEmpty()) {
secrets.insert(NM_L2TP_KEY_PASSWORD, m_ui->password->text());
}
switch (m_ui->password->passwordOption()) {
case PasswordField::StoreForAllUsers:
data.insert(NM_L2TP_KEY_PASSWORD"-flags", QString::number(NetworkManager::Setting::None));
break;
case PasswordField::StoreForUser:
data.insert(NM_L2TP_KEY_PASSWORD"-flags", QString::number(NetworkManager::Setting::AgentOwned));
break;
default:
data.insert(NM_L2TP_KEY_PASSWORD"-flags", QString::number(NetworkManager::Setting::NotSaved));
};
if (!m_ui->domain->text().isEmpty()) {
data.insert(NM_L2TP_KEY_DOMAIN, m_ui->domain->text());
}
}
setting.setData(data);
setting.setSecrets(secrets);
return setting.toMap();
}
void inc() {n = n->next; if (n == 0) {++t; adv();}}
static textconfig text_configure(paragraph *source) {
textconfig ret;
paragraph *p;
int n;
/*
* Non-negotiables.
*/
ret.bullet.next = NULL;
ret.bullet.alt = NULL;
ret.bullet.type = word_Normal;
ret.atitle.just_numbers = FALSE; /* ignored */
ret.atitle.number_at_all = TRUE; /* ignored */
/*
* Defaults.
*/
ret.indent = 7;
ret.indent_code = 2;
ret.listindentbefore = 1;
ret.listindentafter = 3;
ret.width = 68;
ret.atitle.align = CENTRE;
ret.atitle.underline = L"\x2550\0=\0\0";
ret.achapter.align = LEFT;
ret.achapter.just_numbers = FALSE;
ret.achapter.number_at_all = TRUE;
ret.achapter.number_suffix = L": ";
ret.achapter.underline = L"\x203E\0-\0\0";
ret.nasect = 1;
ret.asect = snewn(ret.nasect, alignstruct);
ret.asect[0].align = LEFTPLUS;
ret.asect[0].just_numbers = TRUE;
ret.asect[0].number_at_all = TRUE;
ret.asect[0].number_suffix = L" ";
ret.asect[0].underline = L"\0";
ret.include_version_id = TRUE;
ret.indent_preambles = FALSE;
ret.bullet.text = L"\x2022\0-\0\0";
ret.rule = L"\x2500\0-\0\0";
ret.filename = dupstr("output.txt");
ret.startemph = L"_\0_\0\0";
ret.endemph = uadv(ret.startemph);
ret.startstrong = L"*\0*\0\0";
ret.endstrong = uadv(ret.startstrong);
ret.listsuffix = L".";
ret.charset = CS_ASCII;
/*
* Default quote characters are Unicode matched single quotes,
* falling back to the TeXlike `'.
*/
ret.lquote = L"\x2018\0\x2019\0`\0'\0\0";
ret.rquote = uadv(ret.lquote);
/*
* Two-pass configuration so that we can pick up global config
* (e.g. `quotes') before having it overridden by specific
* config (`text-quotes'), irrespective of the order in which
* they occur.
*/
for (p = source; p; p = p->next) {
if (p->type == para_Config) {
if (!ustricmp(p->keyword, L"quotes")) {
if (*uadv(p->keyword) && *uadv(uadv(p->keyword))) {
ret.lquote = uadv(p->keyword);
ret.rquote = uadv(ret.lquote);
}
}
}
}
for (p = source; p; p = p->next) {
if (p->type == para_Config) {
if (!ustricmp(p->keyword, L"text-indent")) {
ret.indent = utoi(uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-charset")) {
ret.charset = charset_from_ustr(&p->fpos, uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-filename")) {
sfree(ret.filename);
ret.filename = dupstr(adv(p->origkeyword));
} else if (!ustricmp(p->keyword, L"text-indent-code")) {
ret.indent_code = utoi(uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-width")) {
ret.width = utoi(uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-list-indent")) {
ret.listindentbefore = utoi(uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-listitem-indent")) {
ret.listindentafter = utoi(uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-chapter-align")) {
ret.achapter.align = utoalign(uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-chapter-underline")) {
ret.achapter.underline = uadv(p->keyword);
} else if (!ustricmp(p->keyword, L"text-chapter-numeric")) {
ret.achapter.just_numbers = utob(uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-chapter-shownumber")) {
ret.achapter.number_at_all = utob(uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-chapter-suffix")) {
ret.achapter.number_suffix = uadv(p->keyword);
} else if (!ustricmp(p->keyword, L"text-section-align")) {
wchar_t *q = uadv(p->keyword);
int n = 0;
if (uisdigit(*q)) {
n = utoi(q);
q = uadv(q);
}
if (n >= ret.nasect) {
int i;
ret.asect = sresize(ret.asect, n+1, alignstruct);
for (i = ret.nasect; i <= n; i++)
ret.asect[i] = ret.asect[ret.nasect-1];
ret.nasect = n+1;
}
ret.asect[n].align = utoalign(q);
} else if (!ustricmp(p->keyword, L"text-section-underline")) {
wchar_t *q = uadv(p->keyword);
int n = 0;
if (uisdigit(*q)) {
n = utoi(q);
q = uadv(q);
}
if (n >= ret.nasect) {
int i;
ret.asect = sresize(ret.asect, n+1, alignstruct);
for (i = ret.nasect; i <= n; i++)
ret.asect[i] = ret.asect[ret.nasect-1];
ret.nasect = n+1;
}
ret.asect[n].underline = q;
} else if (!ustricmp(p->keyword, L"text-section-numeric")) {
wchar_t *q = uadv(p->keyword);
int n = 0;
if (uisdigit(*q)) {
n = utoi(q);
q = uadv(q);
}
if (n >= ret.nasect) {
int i;
ret.asect = sresize(ret.asect, n+1, alignstruct);
for (i = ret.nasect; i <= n; i++)
ret.asect[i] = ret.asect[ret.nasect-1];
ret.nasect = n+1;
}
ret.asect[n].just_numbers = utob(q);
} else if (!ustricmp(p->keyword, L"text-section-shownumber")) {
wchar_t *q = uadv(p->keyword);
int n = 0;
if (uisdigit(*q)) {
n = utoi(q);
q = uadv(q);
}
if (n >= ret.nasect) {
int i;
ret.asect = sresize(ret.asect, n+1, alignstruct);
for (i = ret.nasect; i <= n; i++)
ret.asect[i] = ret.asect[ret.nasect-1];
ret.nasect = n+1;
}
ret.asect[n].number_at_all = utob(q);
} else if (!ustricmp(p->keyword, L"text-section-suffix")) {
wchar_t *q = uadv(p->keyword);
int n = 0;
if (uisdigit(*q)) {
n = utoi(q);
q = uadv(q);
}
if (n >= ret.nasect) {
int i;
ret.asect = sresize(ret.asect, n+1, alignstruct);
for (i = ret.nasect; i <= n; i++) {
ret.asect[i] = ret.asect[ret.nasect-1];
}
ret.nasect = n+1;
}
ret.asect[n].number_suffix = q;
} else if (!ustricmp(p->keyword, L"text-title-align")) {
ret.atitle.align = utoalign(uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-title-underline")) {
ret.atitle.underline = uadv(p->keyword);
} else if (!ustricmp(p->keyword, L"text-versionid")) {
ret.include_version_id = utob(uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-indent-preamble")) {
ret.indent_preambles = utob(uadv(p->keyword));
} else if (!ustricmp(p->keyword, L"text-bullet")) {
ret.bullet.text = uadv(p->keyword);
} else if (!ustricmp(p->keyword, L"text-rule")) {
ret.rule = uadv(p->keyword);
} else if (!ustricmp(p->keyword, L"text-list-suffix")) {
ret.listsuffix = uadv(p->keyword);
} else if (!ustricmp(p->keyword, L"text-emphasis")) {
if (*uadv(p->keyword) && *uadv(uadv(p->keyword))) {
ret.startemph = uadv(p->keyword);
ret.endemph = uadv(ret.startemph);
}
} else if (!ustricmp(p->keyword, L"text-strong")) {
if (*uadv(p->keyword) && *uadv(uadv(p->keyword))) {
ret.startstrong = uadv(p->keyword);
ret.endstrong = uadv(ret.startstrong);
}
} else if (!ustricmp(p->keyword, L"text-quotes")) {
if (*uadv(p->keyword) && *uadv(uadv(p->keyword))) {
ret.lquote = uadv(p->keyword);
ret.rquote = uadv(ret.lquote);
}
}
}
}
/*
* Now process fallbacks on quote characters, underlines, the
* rule character, the emphasis characters, and bullets.
*/
while (*uadv(ret.rquote) && *uadv(uadv(ret.rquote)) &&
(!cvt_ok(ret.charset, ret.lquote) ||
!cvt_ok(ret.charset, ret.rquote))) {
ret.lquote = uadv(ret.rquote);
ret.rquote = uadv(ret.lquote);
}
while (*uadv(ret.endemph) && *uadv(uadv(ret.endemph)) &&
(!cvt_ok(ret.charset, ret.startemph) ||
!cvt_ok(ret.charset, ret.endemph))) {
ret.startemph = uadv(ret.endemph);
ret.endemph = uadv(ret.startemph);
}
while (*uadv(ret.endstrong) && *uadv(uadv(ret.endstrong)) &&
(!cvt_ok(ret.charset, ret.startstrong) ||
!cvt_ok(ret.charset, ret.endstrong))) {
ret.startstrong = uadv(ret.endstrong);
ret.endstrong = uadv(ret.startstrong);
}
while (*ret.atitle.underline && *uadv(ret.atitle.underline) &&
!cvt_ok(ret.charset, ret.atitle.underline))
ret.atitle.underline = uadv(ret.atitle.underline);
while (*ret.achapter.underline && *uadv(ret.achapter.underline) &&
!cvt_ok(ret.charset, ret.achapter.underline))
ret.achapter.underline = uadv(ret.achapter.underline);
for (n = 0; n < ret.nasect; n++) {
while (*ret.asect[n].underline && *uadv(ret.asect[n].underline) &&
!cvt_ok(ret.charset, ret.asect[n].underline))
ret.asect[n].underline = uadv(ret.asect[n].underline);
}
while (*ret.bullet.text && *uadv(ret.bullet.text) &&
!cvt_ok(ret.charset, ret.bullet.text))
ret.bullet.text = uadv(ret.bullet.text);
while (*ret.rule && *uadv(ret.rule) &&
!cvt_ok(ret.charset, ret.rule))
ret.rule = uadv(ret.rule);
return ret;
}
HT_ConstIterator(Node * * t0) : t(t0) {adv();}
