10595 lines
314 KiB
Plaintext
10595 lines
314 KiB
Plaintext
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
GDIJKSTRA_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" GD"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
MINPATHCOST2_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" GD"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
GBIDIJKSTRA_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" GD"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
MTMINPATHCOSTS2_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" GD"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
D_SEND_SHUFFLE_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DSHUFFLE_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" DRELATION"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DSHUFFLE2_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" DRELATION"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DSHUFFLE1_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" DRELATION"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DLOOP_OLD_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"element");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" DELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DLOOPA_OLD_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"first");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"second");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" DELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" DELEMENT2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DTIE_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"first");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"second");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" DELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" DELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PARTITIONDMAP_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" PDTS"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DMAPPDMAP_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" DPD4"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
FDISTRIBUTE2TES_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DISTRIBUTE2TES_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
OPTICSF_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"argument1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"argument2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" AGGRTYPE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" AGGRTYPE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
OPTICSTF_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"argument1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"argument2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
FILTERV_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TVS2T"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
FILTERNP_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
EXTENDV_fun: naming EXTENDV_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming EXTENDV_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| EXTENDV_fun_1 {$$ = $1;}
|
|
| EXTENDV_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
EXTENDV_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TVS2T"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
EXTENDV_funlist: EXTENDV_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
EXTENDV_funlist_1 : EXTENDV_fun{$$ = $1;}
|
|
| EXTENDV_funlist_1 ',' EXTENDV_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
PROJECTEXTENDV_fun: naming PROJECTEXTENDV_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming PROJECTEXTENDV_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| PROJECTEXTENDV_fun_1 {$$ = $1;}
|
|
| PROJECTEXTENDV_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PROJECTEXTENDV_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TVS2T"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
PROJECTEXTENDV_funlist: PROJECTEXTENDV_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
PROJECTEXTENDV_funlist_1 : PROJECTEXTENDV_fun{$$ = $1;}
|
|
| PROJECTEXTENDV_funlist_1 ',' PROJECTEXTENDV_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
EXTENDNP_fun: naming EXTENDNP_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming EXTENDNP_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| EXTENDNP_fun_1 {$$ = $1;}
|
|
| EXTENDNP_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
EXTENDNP_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
EXTENDNP_funlist: EXTENDNP_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
EXTENDNP_funlist_1 : EXTENDNP_fun{$$ = $1;}
|
|
| EXTENDNP_funlist_1 ',' EXTENDNP_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
PROJECTEXTENDNP_fun: naming PROJECTEXTENDNP_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming PROJECTEXTENDNP_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| PROJECTEXTENDNP_fun_1 {$$ = $1;}
|
|
| PROJECTEXTENDNP_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PROJECTEXTENDNP_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
PROJECTEXTENDNP_funlist: PROJECTEXTENDNP_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
PROJECTEXTENDNP_funlist_1 : PROJECTEXTENDNP_fun{$$ = $1;}
|
|
| PROJECTEXTENDNP_funlist_1 ',' PROJECTEXTENDNP_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
APPLYPREDICATE_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"blockentry");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" BLOCKENTRY"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
FILTER_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
CFILTER_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
CAND_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"block");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ANY"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
COR_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"block");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ANY"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
WITHIN_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"const1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ANY"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
WITHIN2_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"const1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"const2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ANY"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ANY2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
WHILEDO_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"const1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ANY"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
FUNSEQ1_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARGEF1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
FUNSEQ2_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARGEF1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARGEF2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
FUNSEQ3_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem3");
|
|
sprintf(params[3], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(3, params[3]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARGEF1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARGEF2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[3]),
|
|
NestedText::Concat( NestedText::AtomC(" ARGEF3"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) ))));
|
|
cleanVariables(3);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
FUNSEQ4_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem3");
|
|
sprintf(params[3], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(3, params[3]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem4");
|
|
sprintf(params[4], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(4, params[4]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARGEF1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARGEF2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[3]),
|
|
NestedText::Concat( NestedText::AtomC(" ARGEF3"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[4]),
|
|
NestedText::Concat( NestedText::AtomC(" ARGEF4"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) ))));
|
|
cleanVariables(4);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
FUNSEQ5_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem3");
|
|
sprintf(params[3], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(3, params[3]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem4");
|
|
sprintf(params[4], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(4, params[4]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem5");
|
|
sprintf(params[5], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(5, params[5]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARGEF1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARGEF2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[3]),
|
|
NestedText::Concat( NestedText::AtomC(" ARGEF3"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[4]),
|
|
NestedText::Concat( NestedText::AtomC(" ARGEF4"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[5]),
|
|
NestedText::Concat( NestedText::AtomC(" ARGEF5"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) ))));
|
|
cleanVariables(5);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
FUNSEQ6_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem3");
|
|
sprintf(params[3], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(3, params[3]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem4");
|
|
sprintf(params[4], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(4, params[4]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem5");
|
|
sprintf(params[5], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(5, params[5]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem6");
|
|
sprintf(params[6], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(6, params[6]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARGEF1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARGEF2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[3]),
|
|
NestedText::Concat( NestedText::AtomC(" ARGEF3"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[4]),
|
|
NestedText::Concat( NestedText::AtomC(" ARGEF4"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[5]),
|
|
NestedText::Concat( NestedText::AtomC(" ARGEF5"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[6]),
|
|
NestedText::Concat( NestedText::AtomC(" ARGEF6"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) )))) ))));
|
|
cleanVariables(6);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DDISTRIBUTE4_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
FDISTRIBUTE7_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DLOOP_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"darrayelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DLOOP2_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" DARRAYELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" DARRAYELEM2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DMAP_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"dmapelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"dmapslotno");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" int"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PDMAP_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"dmapelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"dmapslotno");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" int"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DMAP2n_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"dmapslotno");
|
|
sprintf(params[3], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(3, params[3]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[3]),
|
|
NestedText::Concat( NestedText::AtomC(" int"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) ))));
|
|
cleanVariables(3);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DMAP2_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"dmslotno");
|
|
sprintf(params[3], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(3, params[3]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[3]),
|
|
NestedText::Concat( NestedText::AtomC(" int"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) ))));
|
|
cleanVariables(3);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DMAP3_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem3");
|
|
sprintf(params[3], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(3, params[3]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"dmslotno");
|
|
sprintf(params[4], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(4, params[4]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[3]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[4]),
|
|
NestedText::Concat( NestedText::AtomC(" int"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) ))));
|
|
cleanVariables(4);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DMAP4_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem3");
|
|
sprintf(params[3], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(3, params[3]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem4");
|
|
sprintf(params[4], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(4, params[4]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"dmslotno");
|
|
sprintf(params[5], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(5, params[5]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[3]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[4]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG4"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[5]),
|
|
NestedText::Concat( NestedText::AtomC(" int"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) ))));
|
|
cleanVariables(5);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DMAP5_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem3");
|
|
sprintf(params[3], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(3, params[3]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem4");
|
|
sprintf(params[4], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(4, params[4]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem5i");
|
|
sprintf(params[5], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(5, params[5]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"dmslotno");
|
|
sprintf(params[6], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(6, params[6]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[3]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[4]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG4"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[5]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG5"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[6]),
|
|
NestedText::Concat( NestedText::AtomC(" int"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) )))) ))));
|
|
cleanVariables(6);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DMAP6_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem3");
|
|
sprintf(params[3], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(3, params[3]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem4");
|
|
sprintf(params[4], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(4, params[4]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem5");
|
|
sprintf(params[5], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(5, params[5]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem6");
|
|
sprintf(params[6], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(6, params[6]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"dmslotno");
|
|
sprintf(params[7], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(7, params[7]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[3]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[4]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG4"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[5]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG5"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[6]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG6"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[7]),
|
|
NestedText::Concat( NestedText::AtomC(" int"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) )))) )))) ))));
|
|
cleanVariables(7);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DMAP7_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem3");
|
|
sprintf(params[3], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(3, params[3]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem4");
|
|
sprintf(params[4], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(4, params[4]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem5");
|
|
sprintf(params[5], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(5, params[5]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem6");
|
|
sprintf(params[6], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(6, params[6]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem7");
|
|
sprintf(params[7], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(7, params[7]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"dmslotno");
|
|
sprintf(params[8], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(8, params[8]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[3]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[4]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG4"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[5]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG5"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[6]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG6"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[7]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG7"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[8]),
|
|
NestedText::Concat( NestedText::AtomC(" int"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) )))) )))) )))) ))));
|
|
cleanVariables(8);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DMAP8_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem3");
|
|
sprintf(params[3], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(3, params[3]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem4");
|
|
sprintf(params[4], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(4, params[4]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem5");
|
|
sprintf(params[5], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(5, params[5]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem6");
|
|
sprintf(params[6], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(6, params[6]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem7");
|
|
sprintf(params[7], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(7, params[7]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem8");
|
|
sprintf(params[8], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(8, params[8]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"dmslotno");
|
|
sprintf(params[9], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(9, params[9]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[3]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[4]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG4"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[5]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG5"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[6]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG6"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[7]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG7"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[8]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG8"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[9]),
|
|
NestedText::Concat( NestedText::AtomC(" int"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) )))) )))) )))) )))) ))));
|
|
cleanVariables(9);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PDMAP2_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"dmslotno");
|
|
sprintf(params[3], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(3, params[3]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[3]),
|
|
NestedText::Concat( NestedText::AtomC(" int"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) ))));
|
|
cleanVariables(3);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PDMAP3_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem3");
|
|
sprintf(params[3], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(3, params[3]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"dmslotno");
|
|
sprintf(params[4], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(4, params[4]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[3]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG4"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[4]),
|
|
NestedText::Concat( NestedText::AtomC(" int"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) ))));
|
|
cleanVariables(4);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PDMAP4_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem3");
|
|
sprintf(params[3], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(3, params[3]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem4i");
|
|
sprintf(params[4], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(4, params[4]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"dmslotno");
|
|
sprintf(params[5], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(5, params[5]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[3]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG4"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[4]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG5"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[5]),
|
|
NestedText::Concat( NestedText::AtomC(" int"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) ))));
|
|
cleanVariables(5);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PDMAP5_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem3");
|
|
sprintf(params[3], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(3, params[3]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem4");
|
|
sprintf(params[4], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(4, params[4]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem5i");
|
|
sprintf(params[5], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(5, params[5]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"dmslotno");
|
|
sprintf(params[6], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(6, params[6]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[3]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG4"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[4]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG5"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[5]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG6"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[6]),
|
|
NestedText::Concat( NestedText::AtomC(" int"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) )))) ))));
|
|
cleanVariables(6);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PDMAP6_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem3");
|
|
sprintf(params[3], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(3, params[3]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem4");
|
|
sprintf(params[4], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(4, params[4]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem5");
|
|
sprintf(params[5], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(5, params[5]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem6");
|
|
sprintf(params[6], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(6, params[6]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"dmslotno");
|
|
sprintf(params[7], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(7, params[7]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[3]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG4"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[4]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG5"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[5]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG6"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[6]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG7"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[7]),
|
|
NestedText::Concat( NestedText::AtomC(" int"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) )))) )))) ))));
|
|
cleanVariables(7);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PDMAP7_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem3");
|
|
sprintf(params[3], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(3, params[3]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem4");
|
|
sprintf(params[4], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(4, params[4]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem5");
|
|
sprintf(params[5], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(5, params[5]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem6");
|
|
sprintf(params[6], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(6, params[6]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem7");
|
|
sprintf(params[7], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(7, params[7]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"dmslotno");
|
|
sprintf(params[8], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(8, params[8]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[3]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG4"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[4]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG5"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[5]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG6"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[6]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG7"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[7]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG8"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[8]),
|
|
NestedText::Concat( NestedText::AtomC(" int"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) )))) )))) )))) ))));
|
|
cleanVariables(8);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PDMAP8_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem3");
|
|
sprintf(params[3], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(3, params[3]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem4");
|
|
sprintf(params[4], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(4, params[4]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem5");
|
|
sprintf(params[5], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(5, params[5]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem6");
|
|
sprintf(params[6], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(6, params[6]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem7");
|
|
sprintf(params[7], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(7, params[7]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem8");
|
|
sprintf(params[8], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(8, params[8]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"dmslotno");
|
|
sprintf(params[9], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(9, params[9]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG3"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[3]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG4"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[4]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG5"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[5]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG6"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[6]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG7"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[7]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG8"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[8]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYFUNARG9"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[9]),
|
|
NestedText::Concat( NestedText::AtomC(" int"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) )))) )))) )))) )))) ))));
|
|
cleanVariables(9);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DFDISTRIBUTE4_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PARTITION_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" SUBSUBTYPE1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PARTITIONF_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" FFR"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" FFR"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
AREDUCE_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" AREDUCEARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
AREDUCE2_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" AREDUCEARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" AREDUCEARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
AREDUCE2F_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" AREDUCEARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" AREDUCEARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DPRODUCT_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" DPRODUCTARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" DPRODUCTARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DDISTRIBUTE_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DFDISTRIBUTE_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PARTITION8LOCAL_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PARTITIONF8_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" P8TM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
LOOPJOINREL_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
CONSTGRAPH_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
CONSTGRAPHPOINTS_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
EXISTS_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
FORALL_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PARAJOIN_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"stream1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"stream2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPSTREAM2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPSTREAM3"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
HADOOPJOIN_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"stream1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"stream2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ANY"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ANY2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
MUPDATE_fun: naming MUPDATE_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming MUPDATE_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| MUPDATE_fun_1 {$$ = $1;}
|
|
| MUPDATE_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
MUPDATE_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" MTUPLE2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
MUPDATE_funlist: MUPDATE_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
MUPDATE_funlist_1 : MUPDATE_fun{$$ = $1;}
|
|
| MUPDATE_funlist_1 ',' MUPDATE_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
MUPDATESAVE_fun: naming MUPDATESAVE_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming MUPDATESAVE_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| MUPDATESAVE_fun_1 {$$ = $1;}
|
|
| MUPDATESAVE_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
MUPDATESAVE_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" MTUPLE2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
MUPDATESAVE_funlist: MUPDATESAVE_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
MUPDATESAVE_funlist_1 : MUPDATESAVE_fun{$$ = $1;}
|
|
| MUPDATESAVE_funlist_1 ',' MUPDATESAVE_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
MUPDATEBYID_fun: naming MUPDATEBYID_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming MUPDATEBYID_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| MUPDATEBYID_fun_1 {$$ = $1;}
|
|
| MUPDATEBYID_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
MUPDATEBYID_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" MTUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
MUPDATEBYID_funlist: MUPDATEBYID_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
MUPDATEBYID_funlist_1 : MUPDATEBYID_fun{$$ = $1;}
|
|
| MUPDATEBYID_funlist_1 ',' MUPDATEBYID_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
MUPDATEDIRECT2_fun: naming MUPDATEDIRECT2_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming MUPDATEDIRECT2_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| MUPDATEDIRECT2_fun_1 {$$ = $1;}
|
|
| MUPDATEDIRECT2_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
MUPDATEDIRECT2_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"tuple2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" MTUPLE2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
MUPDATEDIRECT2_funlist: MUPDATEDIRECT2_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
MUPDATEDIRECT2_funlist_1 : MUPDATEDIRECT2_fun{$$ = $1;}
|
|
| MUPDATEDIRECT2_funlist_1 ',' MUPDATEDIRECT2_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
MOSHORTESTPATHD_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" MTUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
MOSHORTESTPATHA_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" MTUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
MGSHORTESTPATHD_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" MTUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
MGSHORTESTPATHA_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" MTUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
MPQREORDER_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" MTUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
MPQREORDERUPDATE_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" MTUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
CREATEMGRAPH2_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
CREATEMGRAPH2FLOB_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
MG2INSERTORIG_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
MEMGROUPBY_fun: naming MEMGROUPBY_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming MEMGROUPBY_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| MEMGROUPBY_fun_1 {$$ = $1;}
|
|
| MEMGROUPBY_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
MEMGROUPBY_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"mgroup");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" MGROUP"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
MEMGROUPBY_funlist: MEMGROUPBY_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
MEMGROUPBY_funlist_1 : MEMGROUPBY_fun{$$ = $1;}
|
|
| MEMGROUPBY_funlist_1 ',' MEMGROUPBY_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PUSE_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"element");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" PSTREAM1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
PJOIN2_fun: naming PJOIN2_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming PJOIN2_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| PJOIN2_fun_1 {$$ = $1;}
|
|
| PJOIN2_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PJOIN2_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"left");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"right");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" PSTREAM1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" PSTREAM2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
PJOIN2_funlist: PJOIN2_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
PJOIN2_funlist_1 : PJOIN2_fun{$$ = $1;}
|
|
| PJOIN2_funlist_1 ',' PJOIN2_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
PJOIN1_fun: naming PJOIN1_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming PJOIN1_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| PJOIN1_fun_1 {$$ = $1;}
|
|
| PJOIN1_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PJOIN1_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"left");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"right");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" PSTREAM1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ANY2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
PJOIN1_funlist: PJOIN1_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
PJOIN1_funlist_1 : PJOIN1_fun{$$ = $1;}
|
|
| PJOIN1_funlist_1 ',' PJOIN1_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
SORTARRAY_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"element");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
TIE_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"first");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"second");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
CUMULATE_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"first");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"second");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
LOOP_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"element");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
LOOPA_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"first");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"second");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
LOOPB_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"first");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"second");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
LOOPSWITCH_fun: naming LOOPSWITCH_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming LOOPSWITCH_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| LOOPSWITCH_fun_1 {$$ = $1;}
|
|
| LOOPSWITCH_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
LOOPSWITCH_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"element");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
LOOPSWITCH_funlist: LOOPSWITCH_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
LOOPSWITCH_funlist_1 : LOOPSWITCH_fun{$$ = $1;}
|
|
| LOOPSWITCH_funlist_1 ',' LOOPSWITCH_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
LOOPSWITCHA_fun: naming LOOPSWITCHA_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming LOOPSWITCHA_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| LOOPSWITCHA_fun_1 {$$ = $1;}
|
|
| LOOPSWITCHA_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
LOOPSWITCHA_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"first");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"second");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
LOOPSWITCHA_funlist: LOOPSWITCHA_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
LOOPSWITCHA_funlist_1 : LOOPSWITCHA_fun{$$ = $1;}
|
|
| LOOPSWITCHA_funlist_1 ',' LOOPSWITCHA_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
LOOPSWITCHB_fun: naming LOOPSWITCHB_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming LOOPSWITCHB_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| LOOPSWITCHB_fun_1 {$$ = $1;}
|
|
| LOOPSWITCHB_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
LOOPSWITCHB_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"first");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"second");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
LOOPSWITCHB_funlist: LOOPSWITCHB_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
LOOPSWITCHB_funlist_1 : LOOPSWITCHB_fun{$$ = $1;}
|
|
| LOOPSWITCHB_funlist_1 ',' LOOPSWITCHB_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
LOOPSELECT_fun: naming LOOPSELECT_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming LOOPSELECT_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| LOOPSELECT_fun_1 {$$ = $1;}
|
|
| LOOPSELECT_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
LOOPSELECT_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"element");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
LOOPSELECT_funlist: LOOPSELECT_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
LOOPSELECT_funlist_1 : LOOPSELECT_fun{$$ = $1;}
|
|
| LOOPSELECT_funlist_1 ',' LOOPSELECT_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
LOOPSELECTA_fun: naming LOOPSELECTA_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming LOOPSELECTA_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| LOOPSELECTA_fun_1 {$$ = $1;}
|
|
| LOOPSELECTA_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
LOOPSELECTA_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"first");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"second");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
LOOPSELECTA_funlist: LOOPSELECTA_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
LOOPSELECTA_funlist_1 : LOOPSELECTA_fun{$$ = $1;}
|
|
| LOOPSELECTA_funlist_1 ',' LOOPSELECTA_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
LOOPSELECTB_fun: naming LOOPSELECTB_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming LOOPSELECTB_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| LOOPSELECTB_fun_1 {$$ = $1;}
|
|
| LOOPSELECTB_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
LOOPSELECTB_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"first");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"second");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
LOOPSELECTB_funlist: LOOPSELECTB_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
LOOPSELECTB_funlist_1 : LOOPSELECTB_fun{$$ = $1;}
|
|
| LOOPSELECTB_funlist_1 ',' LOOPSELECTB_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PARTJOIN_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"first");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"second");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
PARTJOINSWITCH_fun: naming PARTJOINSWITCH_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming PARTJOINSWITCH_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| PARTJOINSWITCH_fun_1 {$$ = $1;}
|
|
| PARTJOINSWITCH_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PARTJOINSWITCH_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"first");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"second");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
PARTJOINSWITCH_funlist: PARTJOINSWITCH_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
PARTJOINSWITCH_funlist_1 : PARTJOINSWITCH_fun{$$ = $1;}
|
|
| PARTJOINSWITCH_funlist_1 ',' PARTJOINSWITCH_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
PARTJOINSELECT_fun: naming PARTJOINSELECT_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming PARTJOINSELECT_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| PARTJOINSELECT_fun_1 {$$ = $1;}
|
|
| PARTJOINSELECT_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PARTJOINSELECT_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"first");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"second");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
PARTJOINSELECT_funlist: PARTJOINSELECT_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
PARTJOINSELECT_funlist_1 : PARTJOINSELECT_fun{$$ = $1;}
|
|
| PARTJOINSELECT_funlist_1 ',' PARTJOINSELECT_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
EXTEND_fun: naming EXTEND_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming EXTEND_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| EXTEND_fun_1 {$$ = $1;}
|
|
| EXTEND_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
EXTEND_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
EXTEND_funlist: EXTEND_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
EXTEND_funlist_1 : EXTEND_fun{$$ = $1;}
|
|
| EXTEND_funlist_1 ',' EXTEND_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PARAJOIN2_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"stream1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"stream2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ANY"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ANY2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DRELFILTER_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" DRELFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
DRELEXTEND_fun: naming DRELEXTEND_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming DRELEXTEND_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| DRELEXTEND_fun_1 {$$ = $1;}
|
|
| DRELEXTEND_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DRELEXTEND_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" DRELFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
DRELEXTEND_funlist: DRELEXTEND_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
DRELEXTEND_funlist_1 : DRELEXTEND_fun{$$ = $1;}
|
|
| DRELEXTEND_funlist_1 ',' DRELEXTEND_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
DRELPROJECTEXTEND_fun: naming DRELPROJECTEXTEND_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming DRELPROJECTEXTEND_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| DRELPROJECTEXTEND_fun_1 {$$ = $1;}
|
|
| DRELPROJECTEXTEND_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DRELPROJECTEXTEND_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" DRELFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
DRELPROJECTEXTEND_funlist: DRELPROJECTEXTEND_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
DRELPROJECTEXTEND_funlist_1 : DRELPROJECTEXTEND_fun{$$ = $1;}
|
|
| DRELPROJECTEXTEND_funlist_1 ',' DRELPROJECTEXTEND_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
DRELLGROUPBY_fun: naming DRELLGROUPBY_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming DRELLGROUPBY_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| DRELLGROUPBY_fun_1 {$$ = $1;}
|
|
| DRELLGROUPBY_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DRELLGROUPBY_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" DRELRELFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
DRELLGROUPBY_funlist: DRELLGROUPBY_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
DRELLGROUPBY_funlist_1 : DRELLGROUPBY_fun{$$ = $1;}
|
|
| DRELLGROUPBY_funlist_1 ',' DRELLGROUPBY_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
DRELGROUPBY_fun: naming DRELGROUPBY_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming DRELGROUPBY_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| DRELGROUPBY_fun_1 {$$ = $1;}
|
|
| DRELGROUPBY_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DRELGROUPBY_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" DRELRELFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
DRELGROUPBY_funlist: DRELGROUPBY_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
DRELGROUPBY_funlist_1 : DRELGROUPBY_fun{$$ = $1;}
|
|
| DRELGROUPBY_funlist_1 ',' DRELGROUPBY_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
DRELUPDATE_fun: naming DRELUPDATE_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming DRELUPDATE_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| DRELUPDATE_fun_1 {$$ = $1;}
|
|
| DRELUPDATE_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DRELUPDATE_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" DRELFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
DRELUPDATE_funlist: DRELUPDATE_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
DRELUPDATE_funlist_1 : DRELUPDATE_fun{$$ = $1;}
|
|
| DRELUPDATE_funlist_1 ',' DRELUPDATE_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
DRELUPDATEBYID_fun: naming DRELUPDATEBYID_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming DRELUPDATEBYID_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| DRELUPDATEBYID_fun_1 {$$ = $1;}
|
|
| DRELUPDATEBYID_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DRELUPDATEBYID_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" SUBSUBTYPE1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" DRELFUNARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
DRELUPDATEBYID_funlist: DRELUPDATEBYID_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
DRELUPDATEBYID_funlist_1 : DRELUPDATEBYID_fun{$$ = $1;}
|
|
| DRELUPDATEBYID_funlist_1 ',' DRELUPDATEBYID_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DRELFILTERADDID_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" DRELFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DRELFILTERDELETE_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" DRELFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
DRELFILTERUPDATE_fun: naming DRELFILTERUPDATE_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming DRELFILTERUPDATE_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| DRELFILTERUPDATE_fun_1 {$$ = $1;}
|
|
| DRELFILTERUPDATE_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DRELFILTERUPDATE_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" DRELFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
DRELFILTERUPDATE_funlist: DRELFILTERUPDATE_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
DRELFILTERUPDATE_funlist_1 : DRELFILTERUPDATE_fun{$$ = $1;}
|
|
| DRELFILTERUPDATE_funlist_1 ',' DRELFILTERUPDATE_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DBSCANF_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"argument1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"argument2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" AGGRTYPE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" AGGRTYPE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DBSCANTF_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"streamelem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PFILTERS_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
PEXTEND_fun: naming PEXTEND_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming PEXTEND_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| PEXTEND_fun_1 {$$ = $1;}
|
|
| PEXTEND_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PEXTEND_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
PEXTEND_funlist: PEXTEND_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
PEXTEND_funlist_1 : PEXTEND_fun{$$ = $1;}
|
|
| PEXTEND_funlist_1 ',' PEXTEND_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
PEXTENDSTREAM_fun: naming PEXTENDSTREAM_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming PEXTENDSTREAM_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| PEXTENDSTREAM_fun_1 {$$ = $1;}
|
|
| PEXTENDSTREAM_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PEXTENDSTREAM_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
PEXTENDSTREAM_funlist: PEXTENDSTREAM_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
PEXTENDSTREAM_funlist_1 : PEXTENDSTREAM_fun{$$ = $1;}
|
|
| PEXTENDSTREAM_funlist_1 ',' PEXTENDSTREAM_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PLOOPSEL_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PLOOPJOIN_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PAGGREGATE_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"arg1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"arg2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" PAGGRT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" PAGGRT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PAGGREGATEB_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"arg1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"arg2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" PAGGRT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" PAGGRT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
AGGREGATES_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"streamelem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
USE_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
USE2_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"streamelem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
TS_fun: naming TS_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming TS_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| TS_fun_1 {$$ = $1;}
|
|
| TS_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
TS_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
TS_funlist: TS_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
TS_funlist_1 : TS_fun{$$ = $1;}
|
|
| TS_funlist_1 ',' TS_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
AS_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
streamfun_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
prog_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
SYNC_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
SideEffect_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"countelem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"streamelem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" int"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
OSHORTESTPATHD_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
OSHORTESTPATHA_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
READ2_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" DBSARG"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
READ3_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" DBRARG"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
RDERIVE_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" RELARG"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
READ3_1_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" DBRARG"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" DBIARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
READ3_2_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem3");
|
|
sprintf(params[3], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(3, params[3]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" DBRARG"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" DBIARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[3]),
|
|
NestedText::Concat( NestedText::AtomC(" DBIARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) ))));
|
|
cleanVariables(3);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
FILTERX_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
UPDATESEARCH_fun: naming UPDATESEARCH_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming UPDATESEARCH_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| UPDATESEARCH_fun_1 {$$ = $1;}
|
|
| UPDATESEARCH_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
UPDATESEARCH_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
UPDATESEARCH_funlist: UPDATESEARCH_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
UPDATESEARCH_funlist_1 : UPDATESEARCH_fun{$$ = $1;}
|
|
| UPDATESEARCH_funlist_1 ',' UPDATESEARCH_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
UPDATEDIRECT_fun: naming UPDATEDIRECT_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming UPDATEDIRECT_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| UPDATEDIRECT_fun_1 {$$ = $1;}
|
|
| UPDATEDIRECT_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
UPDATEDIRECT_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
UPDATEDIRECT_funlist: UPDATEDIRECT_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
UPDATEDIRECT_funlist_1 : UPDATEDIRECT_fun{$$ = $1;}
|
|
| UPDATEDIRECT_funlist_1 ',' UPDATEDIRECT_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
UPDATEDIRECT2_fun: naming UPDATEDIRECT2_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming UPDATEDIRECT2_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| UPDATEDIRECT2_fun_1 {$$ = $1;}
|
|
| UPDATEDIRECT2_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
UPDATEDIRECT2_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"tuple2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
UPDATEDIRECT2_funlist: UPDATEDIRECT2_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
UPDATEDIRECT2_funlist_1 : UPDATEDIRECT2_fun{$$ = $1;}
|
|
| UPDATEDIRECT2_funlist_1 ',' UPDATEDIRECT2_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
UPDATEBYID2_fun: naming UPDATEBYID2_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming UPDATEBYID2_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| UPDATEBYID2_fun_1 {$$ = $1;}
|
|
| UPDATEBYID2_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
UPDATEBYID2_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"tuple2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
UPDATEBYID2_funlist: UPDATEBYID2_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
UPDATEBYID2_funlist_1 : UPDATEBYID2_fun{$$ = $1;}
|
|
| UPDATEBYID2_funlist_1 ',' UPDATEBYID2_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
UPDATESEARCHSAVE_fun: naming UPDATESEARCHSAVE_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming UPDATESEARCHSAVE_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| UPDATESEARCHSAVE_fun_1 {$$ = $1;}
|
|
| UPDATESEARCHSAVE_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
UPDATESEARCHSAVE_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
UPDATESEARCHSAVE_funlist: UPDATESEARCHSAVE_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
UPDATESEARCHSAVE_funlist_1 : UPDATESEARCHSAVE_fun{$$ = $1;}
|
|
| UPDATESEARCHSAVE_funlist_1 ',' UPDATESEARCHSAVE_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
UPDATEDIRECTSAVE_fun: naming UPDATEDIRECTSAVE_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming UPDATEDIRECTSAVE_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| UPDATEDIRECTSAVE_fun_1 {$$ = $1;}
|
|
| UPDATEDIRECTSAVE_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
UPDATEDIRECTSAVE_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
UPDATEDIRECTSAVE_funlist: UPDATEDIRECTSAVE_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
UPDATEDIRECTSAVE_funlist_1 : UPDATEDIRECTSAVE_fun{$$ = $1;}
|
|
| UPDATEDIRECTSAVE_funlist_1 ',' UPDATEDIRECTSAVE_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
UPDATEBYID_fun: naming UPDATEBYID_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming UPDATEBYID_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| UPDATEBYID_fun_1 {$$ = $1;}
|
|
| UPDATEBYID_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
UPDATEBYID_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
UPDATEBYID_funlist: UPDATEBYID_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
UPDATEBYID_funlist_1 : UPDATEBYID_fun{$$ = $1;}
|
|
| UPDATEBYID_funlist_1 ',' UPDATEBYID_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
FILTERINSERT_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
CPROJECTEXTEND_fun: naming CPROJECTEXTEND_fun_1
|
|
{$$ = NestedText::Concat( (USE_AUTO_BUFFER?NestedText::AtomC("( ! (") :NestedText::AtomC("(")),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
(USE_AUTO_BUFFER?NestedText::AtomC("))") :NestedText::AtomC(")")) ))));}
|
|
| naming CPROJECTEXTEND_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat( (USE_AUTO_BUFFER?NestedText::AtomC("( ! (") :NestedText::AtomC("(")),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , (USE_AUTO_BUFFER?NestedText::AtomC("))") :NestedText::AtomC(")")) ))))));}
|
|
| CPROJECTEXTEND_fun_1 {$$ = $1;}
|
|
| CPROJECTEXTEND_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
CPROJECTEXTEND_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
CPROJECTEXTEND_funlist: CPROJECTEXTEND_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
CPROJECTEXTEND_funlist_1 : CPROJECTEXTEND_fun{$$ = $1;}
|
|
| CPROJECTEXTEND_funlist_1 ',' CPROJECTEXTEND_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
MAP_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"element");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" CELL1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
MAP2_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" CELL1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" CELL2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
MATCHGRID_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"element");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" CELLS"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
REPLACEELEM_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
GROUPBY2_fun: naming GROUPBY2_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming GROUPBY2_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| GROUPBY2_fun_1 {$$ = $1;}
|
|
| GROUPBY2_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
GROUPBY2_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
GROUPBY2_funlist: GROUPBY2_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
GROUPBY2_funlist_1 : GROUPBY2_fun{$$ = $1;}
|
|
| GROUPBY2_funlist_1 ',' GROUPBY2_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
HADOOPMAP_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"lobject1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TPARA"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
HADOOPREDUCE_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"lobject1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TPARA"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
HADOOPREDUCE2_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"lobject1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"lobject2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TPARA"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" TPARA2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
HADOOPMAP2_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"lobject1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"lobject2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TPARA"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" TPARA2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
GPATTERN_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
CROSSPATTERN_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
MTHREADEDFILTER_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
CANCEL_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
PROJECTEXTEND_fun: naming PROJECTEXTEND_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming PROJECTEXTEND_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| PROJECTEXTEND_fun_1 {$$ = $1;}
|
|
| PROJECTEXTEND_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PROJECTEXTEND_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
PROJECTEXTEND_funlist: PROJECTEXTEND_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
PROJECTEXTEND_funlist_1 : PROJECTEXTEND_fun{$$ = $1;}
|
|
| PROJECTEXTEND_funlist_1 ',' PROJECTEXTEND_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
EXTENDSTREAM_fun: naming EXTENDSTREAM_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming EXTENDSTREAM_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| EXTENDSTREAM_fun_1 {$$ = $1;}
|
|
| EXTENDSTREAM_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
EXTENDSTREAM_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
EXTENDSTREAM_funlist: EXTENDSTREAM_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
EXTENDSTREAM_funlist_1 : EXTENDSTREAM_fun{$$ = $1;}
|
|
| EXTENDSTREAM_funlist_1 ',' EXTENDSTREAM_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
PROJECTEXTENDSTREAM_fun: naming PROJECTEXTENDSTREAM_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming PROJECTEXTENDSTREAM_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| PROJECTEXTENDSTREAM_fun_1 {$$ = $1;}
|
|
| PROJECTEXTENDSTREAM_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PROJECTEXTENDSTREAM_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
PROJECTEXTENDSTREAM_funlist: PROJECTEXTENDSTREAM_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
PROJECTEXTENDSTREAM_funlist_1 : PROJECTEXTENDSTREAM_fun{$$ = $1;}
|
|
| PROJECTEXTENDSTREAM_funlist_1 ',' PROJECTEXTENDSTREAM_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
GROUPBY_fun: naming GROUPBY_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming GROUPBY_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| GROUPBY_fun_1 {$$ = $1;}
|
|
| GROUPBY_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
GROUPBY_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"group");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" GROUP"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
GROUPBY_funlist: GROUPBY_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
GROUPBY_funlist_1 : GROUPBY_fun{$$ = $1;}
|
|
| GROUPBY_funlist_1 ',' GROUPBY_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
SLIDINGWINDOW_fun: naming SLIDINGWINDOW_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming SLIDINGWINDOW_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| SLIDINGWINDOW_fun_1 {$$ = $1;}
|
|
| SLIDINGWINDOW_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
SLIDINGWINDOW_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"group");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" GROUP"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
SLIDINGWINDOW_funlist: SLIDINGWINDOW_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
SLIDINGWINDOW_funlist_1 : SLIDINGWINDOW_fun{$$ = $1;}
|
|
| SLIDINGWINDOW_funlist_1 ',' SLIDINGWINDOW_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
LOOPJOIN_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
LOOPSEL_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
AGGREGATE_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"argument1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"argument2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" AGGRTYPE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" AGGRTYPE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
AGGREGATEB_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"argument1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"argument2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" AGGRTYPE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" AGGRTYPE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
SYMMJOIN_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"lefttuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"righttuple");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
SYMMOUTERJOIN_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"lefttuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"righttuple");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
SYMMPRODUCTEXTEND_fun: naming SYMMPRODUCTEXTEND_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming SYMMPRODUCTEXTEND_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| SYMMPRODUCTEXTEND_fun_1 {$$ = $1;}
|
|
| SYMMPRODUCTEXTEND_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
SYMMPRODUCTEXTEND_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"lefttuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"righttuple");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
SYMMPRODUCTEXTEND_funlist: SYMMPRODUCTEXTEND_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
SYMMPRODUCTEXTEND_funlist_1 : SYMMPRODUCTEXTEND_fun{$$ = $1;}
|
|
| SYMMPRODUCTEXTEND_funlist_1 ',' SYMMPRODUCTEXTEND_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
EXTEND_LAST_fun: naming EXTEND_LAST_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming EXTEND_LAST_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| EXTEND_LAST_fun_1 {$$ = $1;}
|
|
| EXTEND_LAST_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
EXTEND_LAST_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"currenttuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"lasttuple");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
EXTEND_LAST_funlist: EXTEND_LAST_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
EXTEND_LAST_funlist_1 : EXTEND_LAST_fun{$$ = $1;}
|
|
| EXTEND_LAST_funlist_1 ',' EXTEND_LAST_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
EXTEND_NEXT_fun: naming EXTEND_NEXT_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming EXTEND_NEXT_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| EXTEND_NEXT_fun_1 {$$ = $1;}
|
|
| EXTEND_NEXT_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
EXTEND_NEXT_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"currenttuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"lasttuple");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
EXTEND_NEXT_funlist: EXTEND_NEXT_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
EXTEND_NEXT_funlist_1 : EXTEND_NEXT_fun{$$ = $1;}
|
|
| EXTEND_NEXT_funlist_1 ',' EXTEND_NEXT_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
REPLACEATTR_fun: naming REPLACEATTR_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming REPLACEATTR_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| REPLACEATTR_fun_1 {$$ = $1;}
|
|
| REPLACEATTR_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
REPLACEATTR_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
REPLACEATTR_funlist: REPLACEATTR_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
REPLACEATTR_funlist_1 : REPLACEATTR_fun{$$ = $1;}
|
|
| REPLACEATTR_funlist_1 ',' REPLACEATTR_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PFILTER_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"currenttuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"lasttuple");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
EXTENDX_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
ADDMODCOUNTER_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"value");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" int"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
USEHISTOGRAM_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"element");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
USEHISTOGRAM2_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"element1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"element2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ELEMENT"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DMAPS_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"dmapelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DMAPS2_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DMAPS3_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem3");
|
|
sprintf(params[3], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(3, params[3]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[3]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG3"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) ))));
|
|
cleanVariables(3);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DMAPS4_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem3");
|
|
sprintf(params[3], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(3, params[3]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem4");
|
|
sprintf(params[4], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(4, params[4]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[3]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG3"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[4]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG4"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) ))));
|
|
cleanVariables(4);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DMAPS5_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem3");
|
|
sprintf(params[3], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(3, params[3]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem4");
|
|
sprintf(params[4], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(4, params[4]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem5");
|
|
sprintf(params[5], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(5, params[5]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[3]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG3"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[4]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG4"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[5]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG5"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) )))) )))) )))) ))));
|
|
cleanVariables(5);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DPRODUCTS_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"elem2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARG1"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNFSARG2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PARTITIONFS_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"arg1");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"arg2");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARGPARTITIONF"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" ARRAYORTASKSFUNARGPARTITIONF"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
DBSCAN_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
REGISTERFORSTREAM_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"elem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TTYPE3"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
PREDCOUNTS_fun: naming PREDCOUNTS_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming PREDCOUNTS_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| PREDCOUNTS_fun_1 {$$ = $1;}
|
|
| PREDCOUNTS_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
PREDCOUNTS_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
PREDCOUNTS_funlist: PREDCOUNTS_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
PREDCOUNTS_funlist_1 : PREDCOUNTS_fun{$$ = $1;}
|
|
| PREDCOUNTS_funlist_1 ',' PREDCOUNTS_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
STPATTERNEXTEND_fun: naming STPATTERNEXTEND_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming STPATTERNEXTEND_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| STPATTERNEXTEND_fun_1 {$$ = $1;}
|
|
| STPATTERNEXTEND_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
STPATTERNEXTEND_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
STPATTERNEXTEND_funlist: STPATTERNEXTEND_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
STPATTERNEXTEND_funlist_1 : STPATTERNEXTEND_fun{$$ = $1;}
|
|
| STPATTERNEXTEND_funlist_1 ',' STPATTERNEXTEND_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
STPATTERNEXTEND2_fun: naming STPATTERNEXTEND2_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming STPATTERNEXTEND2_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| STPATTERNEXTEND2_fun_1 {$$ = $1;}
|
|
| STPATTERNEXTEND2_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
STPATTERNEXTEND2_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
STPATTERNEXTEND2_funlist: STPATTERNEXTEND2_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
STPATTERNEXTEND2_funlist_1 : STPATTERNEXTEND2_fun{$$ = $1;}
|
|
| STPATTERNEXTEND2_funlist_1 ',' STPATTERNEXTEND2_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
STPATTERNEXEXTEND_fun: naming STPATTERNEXEXTEND_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming STPATTERNEXEXTEND_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| STPATTERNEXEXTEND_fun_1 {$$ = $1;}
|
|
| STPATTERNEXEXTEND_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
STPATTERNEXEXTEND_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
STPATTERNEXEXTEND_funlist: STPATTERNEXEXTEND_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
STPATTERNEXEXTEND_funlist_1 : STPATTERNEXEXTEND_fun{$$ = $1;}
|
|
| STPATTERNEXEXTEND_funlist_1 ',' STPATTERNEXEXTEND_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
STPATTERNEXEXTEND2_fun: naming STPATTERNEXEXTEND2_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming STPATTERNEXEXTEND2_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| STPATTERNEXEXTEND2_fun_1 {$$ = $1;}
|
|
| STPATTERNEXEXTEND2_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
STPATTERNEXEXTEND2_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
STPATTERNEXEXTEND2_funlist: STPATTERNEXEXTEND2_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
STPATTERNEXEXTEND2_funlist_1 : STPATTERNEXEXTEND2_fun{$$ = $1;}
|
|
| STPATTERNEXEXTEND2_funlist_1 ',' STPATTERNEXEXTEND2_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
STPATTERNEXTENDSTREAM_fun: naming STPATTERNEXTENDSTREAM_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming STPATTERNEXTENDSTREAM_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| STPATTERNEXTENDSTREAM_fun_1 {$$ = $1;}
|
|
| STPATTERNEXTENDSTREAM_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
STPATTERNEXTENDSTREAM_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
STPATTERNEXTENDSTREAM_funlist: STPATTERNEXTENDSTREAM_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
STPATTERNEXTENDSTREAM_funlist_1 : STPATTERNEXTENDSTREAM_fun{$$ = $1;}
|
|
| STPATTERNEXTENDSTREAM_funlist_1 ',' STPATTERNEXTENDSTREAM_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
STPATTERNEXTENDSTREAM2_fun: naming STPATTERNEXTENDSTREAM2_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming STPATTERNEXTENDSTREAM2_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| STPATTERNEXTENDSTREAM2_fun_1 {$$ = $1;}
|
|
| STPATTERNEXTENDSTREAM2_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
STPATTERNEXTENDSTREAM2_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
STPATTERNEXTENDSTREAM2_funlist: STPATTERNEXTENDSTREAM2_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
STPATTERNEXTENDSTREAM2_funlist_1 : STPATTERNEXTENDSTREAM2_fun{$$ = $1;}
|
|
| STPATTERNEXTENDSTREAM2_funlist_1 ',' STPATTERNEXTENDSTREAM2_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
STPATTERNEXEXTENDSTREAM_fun: naming STPATTERNEXEXTENDSTREAM_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming STPATTERNEXEXTENDSTREAM_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| STPATTERNEXEXTENDSTREAM_fun_1 {$$ = $1;}
|
|
| STPATTERNEXEXTENDSTREAM_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
STPATTERNEXEXTENDSTREAM_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
STPATTERNEXEXTENDSTREAM_funlist: STPATTERNEXEXTENDSTREAM_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
STPATTERNEXEXTENDSTREAM_funlist_1 : STPATTERNEXEXTENDSTREAM_fun{$$ = $1;}
|
|
| STPATTERNEXEXTENDSTREAM_funlist_1 ',' STPATTERNEXEXTENDSTREAM_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~Function~
|
|
|
|
*/
|
|
STPATTERNEXEXTENDSTREAM2_fun: naming STPATTERNEXEXTENDSTREAM2_fun_1
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::AtomC(")") ))));}
|
|
| naming STPATTERNEXEXTENDSTREAM2_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat(NestedText::AtomC("("),
|
|
NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "),
|
|
NestedText::Concat($2,
|
|
NestedText::Concat(NestedText::AtomC(" "), NestedText::Concat( $4 , NestedText::AtomC(")") ))))));}
|
|
| STPATTERNEXEXTENDSTREAM2_fun_1 {$$ = $1;}
|
|
| STPATTERNEXEXTENDSTREAM2_fun_1 ZZDEFAULTSEP valueexpr
|
|
{$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(" "), $3)); }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
STPATTERNEXEXTENDSTREAM2_fun_1 : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"streamelem");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" STREAMELEM"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
STPATTERNEXEXTENDSTREAM2_funlist: STPATTERNEXEXTENDSTREAM2_funlist_1
|
|
{ $$=NestedText::Concat(NestedText::AtomC("( "),
|
|
NestedText::Concat($1,
|
|
NestedText::AtomC(" ) ")));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~funlist~
|
|
|
|
*/
|
|
STPATTERNEXEXTENDSTREAM2_funlist_1 : STPATTERNEXEXTENDSTREAM2_fun{$$ = $1;}
|
|
| STPATTERNEXEXTENDSTREAM2_funlist_1 ',' STPATTERNEXEXTENDSTREAM2_fun
|
|
{ $$ = NestedText::Concat($1,
|
|
NestedText::Concat(NestedText::AtomC(" "), $3));
|
|
}
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
REDUCE_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"tuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) ))));
|
|
cleanVariables(1);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
TSMOTIFBFFUN_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"lefttuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"righttuple");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|
|
/*
|
|
~function~
|
|
|
|
*/
|
|
TSDISTANCEFUN_fun : {
|
|
pair<int,string> p;
|
|
paramno++;
|
|
strcpy(paramname,"lefttuple");
|
|
sprintf(params[1], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(1, params[1]);
|
|
paramstack.push(p);
|
|
paramno++;
|
|
strcpy(paramname,"righttuple");
|
|
sprintf(params[2], "%s_%d",paramname,paramno);
|
|
p = pair<int,string>(2, params[2]);
|
|
paramstack.push(p);
|
|
}
|
|
valueexpr
|
|
{
|
|
pair<int,string> p;
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
p = paramstack.top();
|
|
strcpy(params[p.first],p.second.c_str());
|
|
paramstack.pop();
|
|
$$ = NestedText::Concat( NestedText::AtomC("(fun "),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[1]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( NestedText::AtomC("("),
|
|
NestedText::Concat( NestedText::AtomC(params[2]),
|
|
NestedText::Concat( NestedText::AtomC(" TUPLE2"),
|
|
NestedText::Concat(NestedText::AtomC(")"),
|
|
NestedText::Concat( $2, NestedText::AtomC(")"))) )))) ))));
|
|
cleanVariables(2);
|
|
restoreVariables();
|
|
}
|
|
| function { $$ = $1; }
|
|
;
|
|
|