void bfcode(struct symtab **sp, int cnt) { int i, off; NODE *p, *q; struct symtab *sym; /* Process the first six arguments. */ for (i=0; i < cnt && i < 6; i++) { sym = sp[i]; q = block(REG, NIL, NIL, sym->stype, sym->sdf, sym->sap); q->n_rval = RETREG_PRE(sym->stype) + i; p = tempnode(0, sym->stype, sym->sdf, sym->sap); sym->soffset = regno(p); sym->sflags |= STNODE; p = buildtree(ASSIGN, p, q); ecomp(p); } /* Process the remaining arguments. */ for (off = V9RESERVE; i < cnt; i++) { sym = sp[i]; p = tempnode(0, sym->stype, sym->sdf, sym->sap); off = ALIGN(off, (tlen(p) - 1)); sym->soffset = off * SZCHAR; off += tlen(p); p = buildtree(ASSIGN, p, nametree(sym)); sym->soffset = regno(p->n_left); sym->sflags |= STNODE; ecomp(p); } }
// Generate Transactions // void gen_rules(TransPar &par) { StringSet *lits; StringSetIter *patterns; Transaction *trans; poisson_distribution<LINT> tlen(par.tlen - 1); ofstream data_fp; ofstream pat_fp; data_fp.open(data_file, ios::trunc); pat_fp.open(pat_file, ios::trunc); lits = new StringSet(par.nitems, par.lits); // Reset random seed generator before generating transactions if (par.seed < 0) generator.seed(par.seed); par.write(pat_fp); lits->display(pat_fp); patterns = new StringSetIter(*lits); for (LINT i = 0; i < par.ntrans; i ++) { trans = mk_tran(*patterns, tlen(generator) + 1); if (par.ascii) trans->write_asc(data_fp); else trans->write(data_fp); delete trans; } data_fp.close(); pat_fp.close(); }
/* * The first six 64-bit arguments are saved in the registers O0 to O5, * which become I0 to I5 after the "save" instruction moves the register * window. Arguments 7 and up must be saved on the stack to %sp+BIAS+176. * * For a pretty picture, see Figure 3-16 in the SPARC Compliance Def 2.4. */ static NODE * moveargs(NODE *p, int *regp, int *stacksize) { NODE *r, *q; if (p->n_op == CM) { p->n_left = moveargs(p->n_left, regp, stacksize); r = p->n_right; } else { r = p; } /* XXX more than six FP args can and should be passed in registers. */ if (*regp > 5 && r->n_op != STARG) { /* We are storing the stack offset in n_rval. */ r = block(FUNARG, r, NIL, r->n_type, r->n_df, r->n_ap); /* Make sure we are appropriately aligned. */ *stacksize = ALIGN(*stacksize, (tlen(r) - 1)); r->n_rval = *stacksize; *stacksize += tlen(r); } else if (r->n_op == STARG) cerror("op STARG in moveargs"); else { q = block(REG, NIL, NIL, r->n_type, r->n_df, r->n_ap); /* * The first six non-FP arguments go in the registers O0 - O5. * Float arguments are stored in %fp1, %fp3, ..., %fp29, %fp31. * Double arguments are stored in %fp0, %fp2, ..., %fp28, %fp30. * A non-fp argument still increments register, eg. * test(int a, int b, float b) * takes %o0, %o1, %fp5. */ if (q->n_type == FLOAT) q->n_rval = F0 + (*regp++ * 2) + 1; else if (q->n_type == DOUBLE) q->n_rval = D0 + *regp++; else if (q->n_type == LDOUBLE) cerror("long double support incomplete"); else q->n_rval = O0 + (*regp)++; r = buildtree(ASSIGN, q, r); } if (p->n_op == CM) { p->n_right = r; return p; } return r; }
// Generate Transactions and Taxonomy // void gen_taxrules(TaxPar &par) { Taxonomy *tax; StringSet *lits; StringSetIter *patterns; Transaction *trans; poisson_distribution<LINT> tlen(par.tlen - 1); ofstream data_fp; ofstream pat_fp; ofstream tax_fp; data_fp.open(data_file, ios::trunc); pat_fp.open(pat_file, ios::trunc); tax_fp.open(tax_file, ios::trunc); if (data_fp.fail() || pat_fp.fail() || tax_fp.fail()) { cerr << "Error opening output file" << endl; exit(1); } // generate taxonomy and write it to file tax = new Taxonomy(par.nitems, par.nroots, par.fanout, par.depth_ratio); if (par.ascii) tax->write_asc(tax_fp); else tax->write(tax_fp); lits = new StringSet(par.nitems, par.lits, tax); par.write(pat_fp); lits->display(pat_fp); patterns = new StringSetIter(*lits); for (LINT i = 0; i < par.ntrans; i ++) { trans = mk_tran(*patterns, tlen(generator) + 1, tax); if (par.ascii) trans->write_asc(data_fp); else trans->write(data_fp); delete trans; delete trans; } data_fp.close(); pat_fp.close(); tax_fp.close(); }
CDoubleZeroString::operator const char*() { delete[] m_buf; m_buf = NULL; // calculate the required buffer length size_t tlen(0); if(m_ar.GetSize()>0) { int i; for(i=0;i<m_ar.GetSize();i++) tlen+= (m_ar[i].GetLength() + 1); // add 1 for the normal zeroterm. } else tlen=1; tlen++; // for the double zeroterminator m_buf = new char[tlen]; ASSERT(m_buf!=NULL); ZeroMemory(m_buf, tlen); char* p = m_buf; int i; for(i=0;i<m_ar.GetSize();i++) { strcpy(p, m_ar[i]); p+= (m_ar[i].GetLength() + 1); } return m_buf; }