static bool findKey(Tree pl, Tree key, Tree& val)
{
if(isNil(pl))
return false;
if(left(hd(pl)) == key)
{
val = right(hd(pl));
return true;
}
if(isBefore(left(hd(pl)), key))
return findKey(tl(pl), key, val);
return false;
}
void
hyperplot(unsigned int N, unsigned int K, unsigned int n)
{
std::default_random_engine re; // the default engine
__gnu_cxx::hypergeometric_distribution<> hd(N, K, n);
auto gen = std::bind(hd, re);
auto num = hd.max() - hd.min() + 1;
histogram<std::size_t> bin(num, hd.min(), hd.max() + 1);
const std::size_t per = 1000;
//for (std::size_t i = 0; i < 1000 * per; ++i)
// std::cout << gen() << '\n';
for (std::size_t i = 0; i < 200 * per; ++i)
bin << gen() + 0.5;
for (std::size_t i = 1; i <= bin.size(); ++i)
{
std::cout << bin.value(i) << '\t';
for (std::size_t j = 0; j < bin[i]; j += per)
std::cout << '*';
std::cout << '\n';
}
}
static bool printlist (Tree l, FILE* out)
{
if (isList(l)) {
char sep = '(';
do {
fputc(sep, out); sep = ',';
print(hd(l));
l = tl(l);
} while (isList(l));
if (! isNil(l)) {
fprintf(out, " . ");
print(l, out);
}
fputc(')', out);
return true;
} else if (isNil(l)) {
fprintf(out, "nil");
return true;
} else {
return false;
}
}
// {{{ getexpire: Secondary key extractor for metadata
static int
getexpire (DB *sdb, const DBT *pkey, const DBT *pdata, DBT *skey)
{
u_int32_t *expire = (u_int32_t *) malloc(sizeof(u_int32_t));
// this flag should mean that berkeley db will free this memory when it's
// done with it.
skey->flags = DB_DBT_APPMALLOC;
skey->data = expire;
skey->size = sizeof (*expire);
if (pkey->size != sha1::hashsize)
{
*expire = 0;
return 0;
}
adb_metadata_t md;
if (!buf2xdr (md, pdata->data, pdata->size)) {
hexdump hd (pdata->data, pdata->size);
warn << "getexpire: unable to unmarshal pdata.\n" << hd << "\n";
return -1;
}
// Ensure big-endian for proper BDB sorting.
*expire = htonl (md.expiration);
return 0;
}
void CloudBox::loadPressureGridFromFile(std::string path){
TiXmlDocument doc(path.c_str());
if (!doc.LoadFile()) {std::cout << "Impossible to load " << path << std::endl; return;}
TiXmlHandle hd(&doc);
// We get the arts element
TiXmlElement * arts = hd.FirstChildElement().Element();
if (!arts){
std::cerr << "Impossible to find the arts tag." << std::endl;
return;
}
// We get the SingleScatteringData element
TiXmlElement * vector = arts->FirstChildElement();
if(!vector) {
std::cerr << "Impossible to find the pressure vector." << std::endl;
return;
}
vector->QueryIntAttribute("nelem", &m_pressureGridSize);
if (m_pressureGrid) {std::cout << "delete of pressureGrid" << std::endl; delete[] m_pressureGrid;}
m_pressureGrid = new Numeric[m_pressureGridSize];
std::stringstream ss;
ss << vector->GetText();
for (int i = 0; i < m_pressureGridSize; ++i){
ss >> m_pressureGrid[i];
}
}
void CloudBox::loadAltitudeGridFromFile(std::string path){
TiXmlDocument doc(path.c_str());
if (!doc.LoadFile()) {std::cout << "Impossible to load " << path << std::endl; return;}
TiXmlHandle hd(&doc);
// We get the arts element
TiXmlElement * arts = hd.FirstChildElement().Element();
if (!arts){
std::cerr << "Impossible to find the arts tag." << std::endl;
return;
}
// We get the SingleScatteringData element
TiXmlElement * vector = arts->FirstChildElement();
if(!vector) {
std::cerr << "Impossible to find the altitude vector." << std::endl;
return;
}
int nelem;
vector->QueryIntAttribute("npages", &nelem);
if (nelem != m_pressureGridSize){std::cerr << "Altitude data not coherent with pressure data." << std::endl; return;}
if (m_altitudeGrid) {delete[] m_altitudeGrid;}
m_altitudeGrid = new Numeric[m_pressureGridSize];
std::stringstream ss;
ss << vector->GetText();
for (int i = 0; i < m_pressureGridSize; ++i){
ss >> m_altitudeGrid[i];
}
updateBoundariesLayerId();
}
static Void local drawClassRelations(HDC hDC)
{
Class cls;
for(cls=CLASSMIN; cls<classMax(); cls++) {
List supers;
for(supers=cclass(cls).supers; nonNull(supers); supers=tl(supers)) {
Class parent = getHead(hd(supers));
if (isClass(parent)) {
if (parent == cls) { /* child of itself - draw an arc */
Class source = findClassInNodes(cls);
Arc(hDC, Nodes[source].Pos.right-5, Nodes[source].Pos.bottom-5,
Nodes[source].Pos.right+15, Nodes[source].Pos.bottom+20,
Nodes[source].Pos.right-5, Nodes[source].Pos.bottom-5,
Nodes[source].Pos.right-4, Nodes[source].Pos.bottom-4);
} else { /* Join the two classes with a line */
Class source = findClassInNodes(parent);
Class target = findClassInNodes(cls);
INT sx = Nodes[source].Pos.right + 4;
INT sy = Nodes[source].Pos.top
+ (Nodes[source].Pos.bottom - Nodes[source].Pos.top)/2;
INT tx = Nodes[target].Pos.left - 4;
INT ty = Nodes[target].Pos.top
+ (Nodes[target].Pos.bottom - Nodes[target].Pos.top)/2;
MoveToEx(hDC, sx, sy,NULL);
LineTo(hDC, tx, ty);
}
}
}
}
}
STATIC int LBA_to_CHS(ULONG LBA_address, struct CHS *chs, const ddt * pddt)
{
/* we need the defbpb values since those are taken from the
BIOS, not from some random boot sector, except when
we're dealing with a floppy */
const bpb *pbpb = hd(pddt->ddt_descflags) ? &pddt->ddt_defbpb : &pddt->ddt_bpb;
unsigned hs = pbpb->bpb_nsecs * pbpb->bpb_nheads;
unsigned hsrem = (unsigned)(LBA_address % hs);
LBA_address /= hs;
if (LBA_address > 1023ul)
{
#ifdef DEBUG
printf("LBA-Transfer error : cylinder %lu > 1023\n", LBA_address);
#else
put_string("LBA-Transfer error : cylinder > 1023\n");
#endif
return 1;
}
chs->Cylinder = (UWORD)LBA_address;
chs->Head = hsrem / pbpb->bpb_nsecs;
chs->Sector = hsrem % pbpb->bpb_nsecs + 1;
return 0;
}
void VectorCompiler::compileMultiSignal (Tree L)
{
//contextor recursivness(0);
L = prepare(L); // optimize, share and annotate expression
for (int i = 0; i < fClass->inputs(); i++) {
fClass->addZone3(subst("$1* input$0 = &input[$0][index];", T(i), xfloat()));
}
for (int i = 0; i < fClass->outputs(); i++) {
fClass->addZone3(subst("$1* output$0 = &output[$0][index];", T(i), xfloat()));
}
fClass->addSharedDecl("fullcount");
fClass->addSharedDecl("input");
fClass->addSharedDecl("output");
for (int i = 0; isList(L); L = tl(L), i++) {
Tree sig = hd(L);
fClass->openLoop("count");
fClass->addExecCode(subst("output$0[i] = $2$1;", T(i), CS(sig), xcast()));
fClass->closeLoop(sig);
}
generateUserInterfaceTree(prepareUserInterfaceTree(fUIRoot));
generateMacroInterfaceTree("", prepareUserInterfaceTree(fUIRoot));
if (fDescription) {
fDescription->ui(prepareUserInterfaceTree(fUIRoot));
}
}
Tree buildBoxAbstr (Tree largs, Tree body)
{
if (isNil(largs)) {
return body;
} else {
return buildBoxAbstr(tl(largs), boxAbstr(hd(largs), body));
}
}
// 'default' has been consumed, hd() is the identifier 'xml'
Stmt* Parser::defaultXmlNamespaceStatement()
{
uint32_t pos = position();
if(hd() != T_Identifier || identValue() != compiler->SYM_xml)
goto failure;
eat(T_Identifier);
if(hd() != T_Namespace)
goto failure;
eat(T_Namespace);
eat(T_Assign);
setUsesDefaultXmlNamespace();
return ALLOC(DefaultXmlNamespaceStmt, (pos, commaExpression(0)));
failure:
compiler->syntaxError(pos, SYNTAXERR_EXPECT_DXNS);
/*NOTREACHED*/
return NULL;
}
// FIXME: don't discard the qualifier in namespace definitions
void Parser::namespaceDefinition(int flags, Qualifier* /*qual*/)
{
uint32_t pos = position();
if (!(flags & (SFLAG_Function|SFLAG_Toplevel))) // no classes yet...
compiler->syntaxError(pos, SYNTAXERR_KWD_NOT_ALLOWED, "namespace");
eat(T_Identifier);
Str * name = identifier();
if (match(T_Assign)) {
if (hd() == T_Identifier || hd() == T_StringLiteral)
addNamespaceBinding(name, primaryExpression());
else
compiler->syntaxError(pos, SYNTAXERR_ILLEGAL_NAMESPACE);
}
else
addNamespaceBinding(name, NULL);
semicolon();
}
// FIXME: don't discard the qualifier in namespace definitions
void Parser::namespaceDefinition(int flags, Qualifier* /*qual*/)
{
uint32_t pos = position();
if (!(flags & (SFLAG_Function|SFLAG_Toplevel))) // no classes yet...
compiler->syntaxError(pos, "'namespace' definition not allowed here");
eat(T_Identifier);
Str * name = identifier();
if (match(T_Assign)) {
if (hd() == T_Identifier || hd() == T_StringLiteral)
addNamespaceBinding(name, primaryExpression());
else
compiler->syntaxError(pos, "Illegal 'namespace' definition");
}
else
addNamespaceBinding(name, NULL);
semicolon();
}
/**
* Iterate generateMacroInterfaceTree on a list of user interface elements
*/
void Compiler::generateMacroInterfaceElements(const string& pathname, Tree elements)
{
while(!isNil(elements))
{
generateMacroInterfaceTree(pathname, right(hd(elements)));
elements = tl(elements);
}
}
Tree buildBoxAppl (Tree fun, Tree revarglist)
{
if (isNil(revarglist)) {
return fun;
} else {
return boxAppl(buildBoxAppl(fun, tl(revarglist)), hd(revarglist));
}
}
/**
* Iterate generateUserInterfaceTree on a list of user interface elements
*/
void Compiler::generateUserInterfaceElements(Tree elements)
{
while(!isNil(elements))
{
generateUserInterfaceTree(right(hd(elements)));
elements = tl(elements);
}
}
int sum(const list L) {
if (L == nil) return 0;
else {
const int X = hd(L);
const list T = tl(L);
return X + sum(T);
}
}
void RegionList::insert_before_head(HeapRegion* r) {
assert(well_formed(), "Inv");
set_next(r, hd());
_hd = r;
_sz++;
if (tl() == NULL) _tl = r;
assert(well_formed(), "Inv");
}
// crée une chaine de dossiers correspondant à path et contenant in fine elem
Tree makeSubFolderChain(Tree path, Tree elem)
{
if (isNil(path)) {
return elem;
} else {
return putFolder(uiFolder(hd(path)), makeSubFolderChain(tl(path),elem));
}
}
B assoc (A a, list<std::pair<A, B>> l) {
if (empty (l))
throw not_found ();
std::pair<A, B> p=hd (l);
if (p.first == a)
return p.second;
return assoc (a, tl (l));
}
// makeBoxAbstr(largs,body) => \(lnames).(body)
static Tree makeBoxAbstr (Tree largs, Tree body)
{
if (isNil(largs)) {
return body;
} else {
return boxAbstr(hd(largs), makeBoxAbstr(tl(largs),body));
}
}
Seq<CaseClause*>* Parser::caseElements()
{
SeqBuilder<CaseClause*> cases(allocator);
bool hasDefault = false;
CaseClause* last = NULL;
for (;;) {
switch (hd ()) {
case T_RightBrace:
return cases.get();
case T_Default: {
if (hd2() != T_Colon)
goto just_a_statement; // default xml namespace
eat(T_Default);
eat(T_Colon);
if (hasDefault)
compiler->syntaxError(position(), SYNTAXERR_DUPLICATE_DEFAULT);
hasDefault = true;
cases.addAtEnd(last = ALLOC(CaseClause, (0, NULL)));
break;
}
case T_Case: {
eat(T_Case);
uint32_t pos = position();
Expr* expr = commaExpression(0);
eat(T_Colon);
cases.addAtEnd(last = ALLOC(CaseClause, (pos, expr)));
}
/*FALLTHROUGH*/
just_a_statement:
default: {
if (last == NULL)
compiler->syntaxError(position(), SYNTAXERR_EXPECT_CASE_OR_DEFAULT);
AvmAssert(last->stmts == NULL);
SeqBuilder<Stmt*> stmts(allocator);
while (hd() != T_RightBrace && hd() != T_Case && hd() != T_Default)
stmts.addAtEnd(statement());
last->stmts = stmts.get();
break;
}
}
}
}
/**
* Remove fake root folder if not needed (that is if the UI
* is completely enclosed in one folder)
*/
Tree Compiler::prepareUserInterfaceTree(Tree t)
{
Tree root, elems;
if (isUiFolder(t, root, elems) && isList(elems) && isNil(tl(elems)) ) {
Tree folder = right(hd(elems));
return (isUiFolder(folder)) ? folder : t;
}
return t;
}
/**
* Evaluates each pattern of the list
*/
static Tree evalPatternList(Tree patterns, Tree env)
{
if (isNil(patterns)) {
return gGlobal->nil;
} else {
return cons(evalPattern(hd(patterns), env),
evalPatternList(tl(patterns), env));
}
}
Tree list2set (Tree l)
{
Tree s = gGlobal->nil;
while (isList(l)) {
s = addElement(hd(l),s);
l = tl(l);
}
return s;
}
Tree nth (Tree l, int i)
{
while (isList(l)) {
if (i == 0) return hd(l);
l = tl(l);
i--;
}
return gGlobal->nil;
}
STATIC WORD blk_Media(rqptr rp, ddt * pddt)
{
UNREFERENCED_PARAMETER(rp);
if (hd(pddt->ddt_descflags))
return S_BUSY | S_DONE; /* Hard Drive */
else
return S_DONE; /* Floppy */
}
static inline int Initflags_val(value initflags)
{
int result = 0;
while(is_not_nil(initflags)){
result |= initflags_table[Int_val(hd(initflags))];
initflags = tl(initflags);
}
return result;
}
// defines each symbol si of lnames as => "si = RECURSIVEBODY : select(n,i);"
static Tree makeRecProjectionsList(int n, int i, Tree lnames, Tree ldef)
{
if (i==n) {
return ldef;
} else {
Tree sel = boxSeq(gGlobal->LETRECBODY, makeSelector(n,i));
return cons(cons(hd(lnames), sel), makeRecProjectionsList(n, i+1, tl(lnames), ldef));
}
}
// def2exp transforms a list of definition (name.expression) into a list of expressions
static Tree def2exp(Tree ldef)
{
if (isNil(ldef)) {
return gGlobal->nil;
} else {
Tree def = hd(ldef);
return cons(tl(def), def2exp(tl(ldef)));
}
}
