int paren(char **p, int n, int l, int r) {
if (l == 0 && r != 0) {
int i;
for (i = r; i != 0; i--) {
p[0][2 * n - l - i] = ')';
}
r = 0;
}
if (r == 0) {
p[0][2 * n - l - r] = '\0';
return 1;
}
int c = 0, ret, i;
if (l != 0) {
ret = paren(p, n, l - 1, r);
for (i = 0; i != ret; i++) {
p[i][2 * n - l - r] = '(';
}
c += ret;
}
if (r > l) {
ret = paren(p + c, n, l, r - 1);
for (i = 0; i != ret; i++) {
p[c + i][2 * n - l - r] = ')';
}
c += ret;
}
return c;
}
bool paren ( const char exp[], int lo, int hi ) { //检查表达式exp[lo, hi]是否括号匹配（递归版）
/*DSA*/displaySubstring ( exp, lo, hi );
trim ( exp, lo, hi ); if ( lo > hi ) return true; //清除不含括号的前缀、后缀
if ( exp[lo] != '(' ) return false; //首字符非左括号，则必不匹配
if ( exp[hi] != ')' ) return false; //末字符非右括号，则必不匹配
int mi = divide ( exp, lo, hi ); //确定适当的切分点
if ( mi > hi ) return false; //切分点不合法，意味着局部以至整体不匹配
return paren ( exp, lo + 1, mi - 1 ) && paren ( exp, mi + 1, hi ); //分别检查左、右子表达式
}
format congr_rule::pp(formatter const & fmt) const {
format r;
r += format("#") + format(length(m_metas));
format r1;
for (expr const & h : m_congr_hyps) {
r1 += space() + paren(fmt(mlocal_type(h)));
}
r += group(r1);
r += space() + format(":") + space();
format r2 = paren(fmt(m_lhs));
r2 += space() + format("↦") + space() + paren(fmt(m_rhs));
r += group(r2);
return r;
}
static format pp_child(level const & l, bool unicode, unsigned indent) {
if (is_explicit(l) || is_param(l) || is_meta(l) || is_global(l)) {
return pp(l, unicode, indent);
} else {
return paren(pp(l, unicode, indent));
}
}
string ltest::stripParentheses(string original)
{
string strippedWord = original;
string paren(" (");
if (strippedWord.find(paren) != string::npos)
strippedWord.erase(strippedWord.begin() + strippedWord.find(paren), \
strippedWord.end());
return strippedWord;
}
// Parse a primary expression.
//
// primary-expression ::=
// integer-literal
// | '(' expression ')'
Expr const*
Parser::primary()
{
if (Token tok = match_if(integer_tok))
return on_int(tok);
if (lookahead() == lparen_tok)
return paren();
error(ts_.location(), "expected primary-expression");
throw Parse_error("primary");
}
format pp_simp_extensions_for_head(priority_queue<simp_ext_record, simp_ext_record_cmp> const & q) {
format fmt;
q.for_each([&](simp_ext_record const & r) {
fmt += format(r.m_ext_name);
unsigned prio = *q.get_prio(r);
if (prio != LEAN_DEFAULT_PRIORITY)
fmt += space() + paren(format(prio));
fmt += line();
});
return fmt;
}
// primary: identifier
// identifier '=' expr
// '\' identifier '.' expr
// '(' expr ')'
Expr const*
Parser::primary()
{
if (lookahead() == identifier_tok) {
if (lookahead(1) == equal_tok)
return def();
else
return id();
}
if (lookahead() == backslash_tok)
return abs();
if (lookahead() == lparen_tok)
return paren();
error(ts_.location(), "expected primary-expression");
throw Parse_error("primary");
}
/*!
* \brief Calcule la littérale résultante de l'expression
*/
Litterale* LitteraleExpression::eval() {
Interpreteur& inter=Interpreteur::getInstance();
FactoryLitterale& fl=FactoryLitterale::getInstance();
FactoryOperateur& fo=FactoryOperateur::getInstance();
string s(exp);
regex e;
smatch m;
// Traitement des opérateurs unaires s'appliquant à l'expression
regex opUnaire("([A-Z](?:[A-Z]|[0-9])*)\\(([^,\\(\\)]+)\\)");
while (std::regex_search (s,m,opUnaire)) {
cout<<m[0]<<" "<<m[1]<<" "<<m[2]<<endl;
// m[1] l'opérateur et m[2] l'argument
if(inter.isOperateur(m[1])) {
Litterale* l1 = fl.newLitteraleExpression(m[2])->eval();
Operateur* op= inter.toOperateur(m[1]);
return op->applyUnaire(l1);
}
}
// Traitement des opérateurs binaires s'appliquant à l'expression
regex opBinaire("([A-Z](?:[A-Z]|[0-9])*)\\(([^,\\(]+),([^,\\(\\)]+)\\)");
while (std::regex_search (s,m,opBinaire)) {
//cout<<m[0]<<" "<<m[1]<<" "<<m[2]<<" "<<m[3]<<endl;
// m[1] l'opérateur et m[2] l'argument 1 et m[2] l'argument 2
if(inter.isOperateur(m[1])) {
Litterale* l1 = fl.newLitteraleExpression(m[2])->eval();
Litterale* l2 = fl.newLitteraleExpression(m[3])->eval();
Operateur* op= inter.toOperateur(m[1]);
return op->applyBinaire(l1,l2);
}
}
// Remplacement des variables par leur contenu
regex atome("((?:[[:upper:]]{1})(?:[[:upper:]]|[[:digit:]])*)");
while (regex_search(s,m,atome)) {
LitteraleAtome* var = LitteraleAtome::getVar(m[1]);
if(var) {
Litterale* c = var->getValeur();
s.replace(s.find(m[0]), m[0].length(), c->toString());
}
}
// Traitement des groupes parenthésés
// Le but est de ne se retrouver qu'avec
// une suite d'opérations arithmétiques sans parenthèses
regex paren("\\(([^\\(]*?)\\)");
while (regex_search(s,m,paren)) {
//cout<<m[0]<<" va être remplcé par "<<m[1]<<endl;
Litterale* c = fl.newLitteraleExpression(m[1])->eval();
//cout<<"av. "<<s<<endl;
s.replace(s.find(m[0]), m[0].length(), c->toString());
//cout<<"apr. "<<s<<endl;
}
// Traitement des + et -
regex somme("([^\\+]*[1-9])([\\+-])(.+)");
if (regex_search(s,m,somme)) {
//cout<<m[1]<<" "<<m[2]<<" "<<m[3]<<endl;
// Conversion en littérale des deux cotés
Litterale* l1=fl.newLitteraleExpression(m[1])->eval(); // On converti en littérale la partie gauche
Litterale* l2=fl.newLitteraleExpression(m[3])->eval(); // On converti en littérale la partie droite
// Création de l'opérateur
OperateurNumerique* op=fo.newOperateurNumerique(m[2]);
// Application du résultat
Litterale* l3=op->applyBinaire(l1, l2);
return l3;
}
// Traitement des * et /
regex produit("([^\\+]*[1-9])([\\*/])(.+)");
if (regex_search(s,m,produit)) {
//cout<<m[1]<<" "<<m[2]<<" "<<m[3]<<endl;
// Conversion en littérale des deux cotés
Litterale* l1=fl.newLitteraleExpression(m[1])->eval(); // On converti en littérale la partie gauche
Litterale* l2=fl.newLitteraleExpression(m[3])->eval(); // On converti en littérale la partie droite
// Création de l'opérateur
OperateurNumerique* op=fo.newOperateurNumerique(m[2]);
// Application du résultat
Litterale* l3=op->applyBinaire(l1, l2);
return l3;
}
// On vérifie que ce n'est pas tout simplement une littérale
if(inter.isLitterale(s)) {
return inter.toLitterale(s);
}
return nullptr;
}
op_star id|base comma r_int id|irq comma r_void (paren op_star id|handler )paren (paren r_int comma r_void op_star comma r_struct id|pt_regs op_star )paren comma r_int r_int id|flags comma r_const r_char op_star id|devname comma
void
FoldingEngine<SEQ>::
stochastic_fold(const std::string& name, const SEQ& seq, uint num_samples,
const std::vector<float>& gamma, uint max_clusters, std::ostream& out,
const std::string& p_outname, float th)
{
std::vector<BPvecPtr> bpv;
stochastic_fold(seq, num_samples, bpv);
if (max_clusters>=2)
{
// calculate the distance matrix
typedef boost::multi_array<double, 2> DMatrix;
DMatrix dmatrix(boost::extents[bpv.size()][bpv.size()]);
for (uint i=0; i!=bpv.size(); ++i)
for (uint j=i; j!=bpv.size(); ++j)
dmatrix[i][j]=dmatrix[j][i]=hamming_distance(*bpv[i], *bpv[j]);
// hierarchical clustering by DIANA
HCLUST::Diana<DMatrix> diana(dmatrix);
diana.build(max_clusters);
uint opt_n = diana.optimal_size();
std::vector<uint> res;
std::vector<uint> num;
diana.get_clusters(opt_n, res, num);
// sort by size of clusters
std::vector<uint> s(num.size(), 0);
std::vector<uint> idx(num.size());
for (uint i=0; i!=num.size(); ++i)
{
idx[i]=i;
if (i!=0) s[i]=s[i-1]+num[i-1];
}
std::sort(idx.begin(), idx.end(), cmp_by_size(num));
// centroid estimation for each cluster
for (uint i=0; i!=idx.size(); ++i)
{
std::vector<BPvecPtr> v(num[idx[i]]);
for (uint j=0; j!=v.size(); ++j) v[j] = bpv[res[s[idx[i]]+j]];
CountBP< std::vector<BPvecPtr> > count_bp(v, seq.size());
inside_traverse(0, seq.size()-1, count_bp);
char buf[100];
sprintf(buf, "%3.1f%%", static_cast<float>(num[idx[i]])/bpv.size()*100);
out << ">" << name << " (" << i+1 << " of " << num.size() << ", size="
<< buf << ")" << std::endl
<< get_seq(seq) << std::endl;
std::vector<float>::const_iterator g;
for (g=gamma.begin(); g!=gamma.end(); ++g) {
std::string paren(seq.size(), '.');
Centroid::execute(count_bp.table, paren, *g);
out << paren << " (g=" << *g << ",th=" << (1.0/(1.0+*g));
#ifdef HAVE_LIBRNA
out << ",e=" << calc_energy(seq, paren);
#endif
out << ")" << std::endl;
}
if (!p_outname.empty())
{
char buf[1024];
snprintf(buf, sizeof(buf), "%s-%d", p_outname.c_str(), i);
count_bp.table.save(buf, get_seq(seq), th);
}
}
}
else
{
CountBP< std::vector<BPvecPtr> > count_bp(bpv, seq.size());
inside_traverse(0, seq.size()-1, count_bp);
std::string paren(seq.size(), '.');
std::vector<float>::const_iterator g;
out << ">" << name << std::endl
<< get_seq(seq) << std::endl;
for (g=gamma.begin(); g!=gamma.end(); ++g)
{
std::fill(paren.begin(), paren.end(), '.');
Centroid::execute(count_bp.table, paren, *g);
out << paren << " (g=" << *g << ",th=" << (1.0/(1.0+*g));
#ifdef HAVE_LIBRNA
out << ",e=" << calc_energy(seq, paren);
#endif
out << ")" << std::endl;
}
if (!p_outname.empty())
{
char buf[1024];
snprintf(buf, sizeof(buf), "%s-1", p_outname.c_str());
count_bp.table.save(buf, get_seq(seq), th);
}
}
}
int
yyparse(void)
{
struct
{
YYSTYPE yyv;
int yys;
} yys[YYMAXDEPTH], *yyp, *yypt;
short *yyxi;
int yyj, yym, yystate, yyn, yyg;
YYSTYPE save1, save2;
int save3, save4;
long yychar;
save1 = yylval;
save2 = yyval;
save3 = yynerrs;
save4 = yyerrflag;
yystate = 0;
yychar = -1;
yynerrs = 0;
yyerrflag = 0;
yyp = &yys[-1];
goto yystack;
ret0:
yyn = 0;
goto ret;
ret1:
yyn = 1;
goto ret;
ret:
yylval = save1;
yyval = save2;
yynerrs = save3;
yyerrflag = save4;
return yyn;
yystack:
/* put a state and value onto the stack */
if(yydebug >= 4)
printf("char %s in %s", yytokname(yychar), yystatname(yystate));
yyp++;
if(yyp >= &yys[YYMAXDEPTH]) {
yyerror("yacc stack overflow");
goto ret1;
}
yyp->yys = yystate;
yyp->yyv = yyval;
yynewstate:
yyn = yypact[yystate];
if(yyn <= YYFLAG)
goto yydefault; /* simple state */
if(yychar < 0)
yychar = yylex1();
yyn += yychar;
if(yyn < 0 || yyn >= YYLAST)
goto yydefault;
yyn = yyact[yyn];
if(yychk[yyn] == yychar) { /* valid shift */
yychar = -1;
yyval = yylval;
yystate = yyn;
if(yyerrflag > 0)
yyerrflag--;
goto yystack;
}
yydefault:
/* default state action */
yyn = yydef[yystate];
if(yyn == -2) {
if(yychar < 0)
yychar = yylex1();
/* look through exception table */
for(yyxi=yyexca;; yyxi+=2)
if(yyxi[0] == -1 && yyxi[1] == yystate)
break;
for(yyxi += 2;; yyxi += 2) {
yyn = yyxi[0];
if(yyn < 0 || yyn == yychar)
break;
}
yyn = yyxi[1];
if(yyn < 0)
goto ret0;
}
if(yyn == 0) {
/* error ... attempt to resume parsing */
switch(yyerrflag) {
case 0: /* brand new error */
yyerror("syntax error");
if(yydebug >= 1) {
printf("%s", yystatname(yystate));
printf("saw %s\n", yytokname(yychar));
}
yyerrlab:
yynerrs++;
case 1:
case 2: /* incompletely recovered error ... try again */
yyerrflag = 3;
/* find a state where "error" is a legal shift action */
while(yyp >= yys) {
yyn = yypact[yyp->yys] + YYERRCODE;
if(yyn >= 0 && yyn < YYLAST) {
yystate = yyact[yyn]; /* simulate a shift of "error" */
if(yychk[yystate] == YYERRCODE)
goto yystack;
}
/* the current yyp has no shift onn "error", pop stack */
if(yydebug >= 2)
printf("error recovery pops state %d, uncovers %d\n",
yyp->yys, (yyp-1)->yys );
yyp--;
}
/* there is no state on the stack with an error shift ... abort */
goto ret1;
case 3: /* no shift yet; clobber input char */
if(yydebug >= YYEOFCODE)
printf("error recovery discards %s\n", yytokname(yychar));
if(yychar == YYEOFCODE)
goto ret1;
yychar = -1;
goto yynewstate; /* try again in the same state */
}
}
/* reduction by production yyn */
if(yydebug >= 2)
printf("reduce %d in:\n\t%s", yyn, yystatname(yystate));
yypt = yyp;
yyp -= yyr2[yyn];
yyval = (yyp+1)->yyv;
yym = yyn;
/* consult goto table to find next state */
yyn = yyr1[yyn];
yyg = yypgo[yyn];
yyj = yyg + yyp->yys + 1;
if(yyj >= YYLAST || yychk[yystate=yyact[yyj]] != -yyn)
yystate = yyact[yyg];
switch(yym) {
case 1:
#line 24 "/sys/src/cmd/eqn/eqn.y"
{ putout(yypt[-0].yyv); } break;
case 2:
#line 25 "/sys/src/cmd/eqn/eqn.y"
{ ERROR "syntax error" WARNING; } break;
case 3:
#line 26 "/sys/src/cmd/eqn/eqn.y"
{ eqnreg = 0; } break;
case 5:
#line 30 "/sys/src/cmd/eqn/eqn.y"
{ eqnbox(yypt[-1].yyv, yypt[-0].yyv, 0); } break;
case 6:
#line 31 "/sys/src/cmd/eqn/eqn.y"
{ eqnbox(yypt[-1].yyv, yypt[-0].yyv, 1); } break;
case 7:
#line 32 "/sys/src/cmd/eqn/eqn.y"
{ lineup(0); } break;
case 8:
#line 35 "/sys/src/cmd/eqn/eqn.y"
{ yyval = yypt[-0].yyv; lineup(1); } break;
case 9:
#line 38 "/sys/src/cmd/eqn/eqn.y"
{ yyval = yypt[-0].yyv; } break;
case 10:
#line 39 "/sys/src/cmd/eqn/eqn.y"
{ yyval = 0; } break;
case 11:
#line 42 "/sys/src/cmd/eqn/eqn.y"
{ yyval = yypt[-0].yyv; } break;
case 12:
#line 43 "/sys/src/cmd/eqn/eqn.y"
{ yyval = 0; } break;
case 13:
#line 46 "/sys/src/cmd/eqn/eqn.y"
{ yyval = yypt[-1].yyv; } break;
case 14:
#line 47 "/sys/src/cmd/eqn/eqn.y"
{ text(QTEXT, (char *) yypt[-0].yyv); } break;
case 15:
#line 48 "/sys/src/cmd/eqn/eqn.y"
{ text(CONTIG, (char *) yypt[-0].yyv); } break;
case 16:
#line 49 "/sys/src/cmd/eqn/eqn.y"
{ text(SPACE, (char *) 0); } break;
case 17:
#line 50 "/sys/src/cmd/eqn/eqn.y"
{ text(THIN, (char *) 0); } break;
case 18:
#line 51 "/sys/src/cmd/eqn/eqn.y"
{ text(TAB, (char *) 0); } break;
case 19:
#line 52 "/sys/src/cmd/eqn/eqn.y"
{ funny(SUM); } break;
case 20:
#line 53 "/sys/src/cmd/eqn/eqn.y"
{ funny(PROD); } break;
case 21:
#line 54 "/sys/src/cmd/eqn/eqn.y"
{ funny(UNION); } break;
case 22:
#line 55 "/sys/src/cmd/eqn/eqn.y"
{ funny(INTER); } break;
case 23:
#line 56 "/sys/src/cmd/eqn/eqn.y"
{ boverb(yypt[-2].yyv, yypt[-0].yyv); } break;
case 24:
#line 57 "/sys/src/cmd/eqn/eqn.y"
{ mark(yypt[-0].yyv); } break;
case 25:
#line 58 "/sys/src/cmd/eqn/eqn.y"
{ size(yypt[-1].yyv, yypt[-0].yyv); } break;
case 26:
#line 59 "/sys/src/cmd/eqn/eqn.y"
{ font(yypt[-1].yyv, yypt[-0].yyv); } break;
case 27:
#line 60 "/sys/src/cmd/eqn/eqn.y"
{ fatbox(yypt[-0].yyv); } break;
case 28:
#line 61 "/sys/src/cmd/eqn/eqn.y"
{ sqrt(yypt[-0].yyv); } break;
case 29:
#line 62 "/sys/src/cmd/eqn/eqn.y"
{ps -= deltaps;} break;
case 30:
#line 62 "/sys/src/cmd/eqn/eqn.y"
{ subsup(yypt[-4].yyv, yypt[-1].yyv, yypt[-0].yyv); } break;
case 31:
#line 63 "/sys/src/cmd/eqn/eqn.y"
{ps -= deltaps;} break;
case 32:
#line 63 "/sys/src/cmd/eqn/eqn.y"
{ subsup(yypt[-3].yyv, 0, yypt[-0].yyv); } break;
case 33:
#line 64 "/sys/src/cmd/eqn/eqn.y"
{ps -= deltaps;} break;
case 34:
#line 64 "/sys/src/cmd/eqn/eqn.y"
{ integral(yypt[-4].yyv, yypt[-1].yyv, yypt[-0].yyv); } break;
case 35:
#line 65 "/sys/src/cmd/eqn/eqn.y"
{ps -= deltaps;} break;
case 36:
#line 65 "/sys/src/cmd/eqn/eqn.y"
{ integral(yypt[-3].yyv, 0, yypt[-0].yyv); } break;
case 37:
#line 66 "/sys/src/cmd/eqn/eqn.y"
{ integral(yypt[-0].yyv, 0, 0); } break;
case 38:
#line 67 "/sys/src/cmd/eqn/eqn.y"
{ps -= deltaps;} break;
case 39:
#line 67 "/sys/src/cmd/eqn/eqn.y"
{ fromto(yypt[-4].yyv, yypt[-1].yyv, yypt[-0].yyv); } break;
case 40:
#line 68 "/sys/src/cmd/eqn/eqn.y"
{ps -= deltaps;} break;
case 41:
#line 68 "/sys/src/cmd/eqn/eqn.y"
{ fromto(yypt[-3].yyv, 0, yypt[-0].yyv); } break;
case 42:
#line 69 "/sys/src/cmd/eqn/eqn.y"
{ paren(yypt[-2].yyv, yypt[-1].yyv, yypt[-0].yyv); } break;
case 43:
#line 70 "/sys/src/cmd/eqn/eqn.y"
{ paren(yypt[-1].yyv, yypt[-0].yyv, 0); } break;
case 44:
#line 71 "/sys/src/cmd/eqn/eqn.y"
{ diacrit(yypt[-1].yyv, yypt[-0].yyv); } break;
case 45:
#line 72 "/sys/src/cmd/eqn/eqn.y"
{ move(FWD, yypt[-1].yyv, yypt[-0].yyv); } break;
case 46:
#line 73 "/sys/src/cmd/eqn/eqn.y"
{ move(UP, yypt[-1].yyv, yypt[-0].yyv); } break;
case 47:
#line 74 "/sys/src/cmd/eqn/eqn.y"
{ move(BACK, yypt[-1].yyv, yypt[-0].yyv); } break;
case 48:
#line 75 "/sys/src/cmd/eqn/eqn.y"
{ move(DOWN, yypt[-1].yyv, yypt[-0].yyv); } break;
case 49:
#line 76 "/sys/src/cmd/eqn/eqn.y"
{ pile(yypt[-0].yyv); ct = yypt[-0].yyv; } break;
case 50:
#line 77 "/sys/src/cmd/eqn/eqn.y"
{yyval=ct;} break;
case 51:
#line 77 "/sys/src/cmd/eqn/eqn.y"
{ matrix(yypt[-3].yyv); ct = yypt[-3].yyv; } break;
case 52:
#line 80 "/sys/src/cmd/eqn/eqn.y"
{ setintegral(); } break;
case 53:
#line 83 "/sys/src/cmd/eqn/eqn.y"
{ yyval = atoi((char *) yypt[-1].yyv); } break;
case 54:
#line 84 "/sys/src/cmd/eqn/eqn.y"
{ yyval = atoi((char *) yypt[-1].yyv); } break;
case 55:
#line 85 "/sys/src/cmd/eqn/eqn.y"
{ yyval = atoi((char *) yypt[-1].yyv); } break;
case 56:
#line 86 "/sys/src/cmd/eqn/eqn.y"
{ yyval = atoi((char *) yypt[-1].yyv); } break;
case 57:
#line 88 "/sys/src/cmd/eqn/eqn.y"
{ yyval = HAT; } break;
case 58:
#line 89 "/sys/src/cmd/eqn/eqn.y"
{ yyval = VEC; } break;
case 59:
#line 90 "/sys/src/cmd/eqn/eqn.y"
{ yyval = DYAD; } break;
case 60:
#line 91 "/sys/src/cmd/eqn/eqn.y"
{ yyval = BAR; } break;
case 61:
#line 92 "/sys/src/cmd/eqn/eqn.y"
{ yyval = LOWBAR; } break;
case 62:
#line 93 "/sys/src/cmd/eqn/eqn.y"
{ yyval = HIGHBAR; } break;
case 63:
#line 94 "/sys/src/cmd/eqn/eqn.y"
{ yyval = UNDER; } break;
case 64:
#line 95 "/sys/src/cmd/eqn/eqn.y"
{ yyval = DOT; } break;
case 65:
#line 96 "/sys/src/cmd/eqn/eqn.y"
{ yyval = TILDE; } break;
case 66:
#line 97 "/sys/src/cmd/eqn/eqn.y"
{ yyval = UTILDE; } break;
case 67:
#line 98 "/sys/src/cmd/eqn/eqn.y"
{ yyval = DOTDOT; } break;
case 68:
#line 101 "/sys/src/cmd/eqn/eqn.y"
{ yyval = ((char *)yypt[-0].yyv)[0]; } break;
case 69:
#line 102 "/sys/src/cmd/eqn/eqn.y"
{ yyval = '{'; } break;
case 70:
#line 105 "/sys/src/cmd/eqn/eqn.y"
{ yyval = ((char *)yypt[-0].yyv)[0]; } break;
case 71:
#line 106 "/sys/src/cmd/eqn/eqn.y"
{ yyval = '}'; } break;
case 74:
#line 113 "/sys/src/cmd/eqn/eqn.y"
{ column(yypt[-3].yyv, DEFGAP); } break;
case 75:
#line 114 "/sys/src/cmd/eqn/eqn.y"
{yyval=atoi((char*)yypt[-0].yyv);} break;
case 76:
#line 114 "/sys/src/cmd/eqn/eqn.y"
{ column(yypt[-5].yyv, yypt[-3].yyv); } break;
case 77:
#line 117 "/sys/src/cmd/eqn/eqn.y"
{ yyval = startcol(LCOL); } break;
case 78:
#line 118 "/sys/src/cmd/eqn/eqn.y"
{ yyval = startcol(CCOL); } break;
case 79:
#line 119 "/sys/src/cmd/eqn/eqn.y"
{ yyval = startcol(RCOL); } break;
case 80:
#line 120 "/sys/src/cmd/eqn/eqn.y"
{ yyval = startcol(COL); } break;
case 81:
#line 123 "/sys/src/cmd/eqn/eqn.y"
{ lp[ct++] = yypt[-0].yyv; } break;
case 82:
#line 124 "/sys/src/cmd/eqn/eqn.y"
{ lp[ct++] = yypt[-0].yyv; } break;
case 83:
#line 127 "/sys/src/cmd/eqn/eqn.y"
{ yyval = ps; setsize((char *) yypt[-0].yyv); } break;
case 84:
#line 130 "/sys/src/cmd/eqn/eqn.y"
{ static char R[]="R"; setfont(R); } break;
case 85:
#line 131 "/sys/src/cmd/eqn/eqn.y"
{ static char I[]="I"; setfont(I); } break;
case 86:
#line 132 "/sys/src/cmd/eqn/eqn.y"
{ static char B[]="B"; setfont(B); } break;
case 87:
#line 133 "/sys/src/cmd/eqn/eqn.y"
{ setfont((char *)yypt[-0].yyv); } break;
}
goto yystack; /* stack new state and value */
}
// static
NamedType* NamedType::CreateFromArchive(TypeArchive& ar, uint32 id, TypeLib* typelib, StringIn qname)
{
//ASSERT(typelib->m_loaded);
/*
if (!typelib->m_loaded)
{
typelib->m_loaded = true;
char fullname[260];
_makepath(fullname, "C:", "\\mmstudio\\Win32\\bin\\debug", typelib->m_typeinfo_filename->c_str(), "typeinfo");
IO::FileByteStream file(new StringA(fullname), IO::FileMode_Read);
TypeArchive ar2(TypeArchive::Mode_Load, &file);
ar2.m_pGlobalNamespace = ar.m_pGlobalNamespace;
ar2.m_bSortedDecls = ar.m_bSortedDecls;
ar2.m_typestuff = ar.m_typestuff;
ar2 >> ar2.m_typelib;
uint ntypelibs;
ar2 >> ntypelibs;
for (uint i = 0; i < ntypelibs; i++)
{
TypeLib* typelib;
ar2 >> typelib;
}
Namespace* pNamespace;
ar2 >> pNamespace;
uint ntypes;
ar2 >> ntypes;
for (i = 0; i < ntypes; i++)
{
NamedType* type;
ar2 >> type;
typelib->m_alltypes.insert(map<StringA*, NamedType*, Ref_Less<StringA> >::value_type(type->m_qname, type));
}
}
*/
// map<StringA*, NamedType*, Ref_Less<StringA> >::iterator it = typelib->m_typesByName.find(qname);
NamedType* pobj = typelib->FindNamedType(qname);
if (pobj == NULL)
{
/*
char buffer[1024];
sprintf_s(buffer, "'%S' imports '%S', but couldn't find type '%s'\n", ar.m_typelib->m_typeinfo_filename->c_str(), typelib->m_typeinfo_filename->c_str(), qname->c_str());
// throw std::exception(buffer);
printf(buffer);
*/
DebugTrace(__FILE__ << paren(__LINE__) << " : TODO; FIX BUG HERE\n");
// ASSERT(0);
ar.m_typeLoad.push_back(NULL);
return NULL;
}
else
{
// ar.m_objectmapLoad.insert(map<uint32, TypeSerializable*>::value_type(id, pobj));
if (ar.m_typeLoad.size() < id+1) ar.m_typeLoad.resize(id+1);
ar.m_typeLoad[id] = pobj;
// ASSERT(ar.m_typeLoad.size() == id);
return pobj;
}
}
int main() {
paren("(1,(2,3),(4,(5,6),7))");
return 0;
}
