1083 lines
34 KiB
Plaintext
1083 lines
34 KiB
Plaintext
|
/*
|
||
|
|
----
|
||
|
|
This file is part of SECONDO.
|
||
|
|
|
||
|
|
Copyright (C) 2004-2007,
|
||
|
|
University in Hagen,
|
||
|
|
Faculty of Mathematics and Computer Science,
|
||
|
|
Database Systems for New Applications.
|
||
|
|
|
||
|
|
SECONDO is free software; you can redistribute it and/or modify
|
||
|
|
it under the terms of the GNU General Public License as published by
|
||
|
|
the Free Software Foundation; either version 2 of the License, or
|
||
|
|
(at your option) any later version.
|
||
|
|
|
||
|
|
SECONDO is distributed in the hope that it will be useful,
|
||
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
|
GNU General Public License for more details.
|
||
|
|
|
||
|
|
You should have received a copy of the GNU General Public License
|
||
|
|
along with SECONDO; if not, write to the Free Software
|
||
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||
|
|
----
|
||
|
|
|
||
|
|
//[_] [\_]
|
||
|
|
|
||
|
|
*/
|
||
|
|
|
||
|
|
%{
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.0 Includes
|
||
|
|
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <iostream>
|
||
|
|
#include <sstream>
|
||
|
|
#include <vector>
|
||
|
|
#include <iostream>
|
||
|
|
#include <fstream>
|
||
|
|
#include <set>
|
||
|
|
#include <cstdlib>
|
||
|
|
using namespace std;
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.1 Some external defined variables
|
||
|
|
|
||
|
|
*/
|
||
|
|
extern int yylineno;
|
||
|
|
extern int yylex();
|
||
|
|
extern FILE* yyin;
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.2 Files for writing the rules
|
||
|
|
|
||
|
|
There are four files for writing entries.
|
||
|
|
|
||
|
|
*/
|
||
|
|
ofstream* lexrules;
|
||
|
|
ofstream* yaccrules1;
|
||
|
|
ofstream* yaccrules2;
|
||
|
|
ofstream* tokens;
|
||
|
|
int tokenslength; // length of the current tokens line
|
||
|
|
int maxtokenslength = 70;
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.3 A set containing tokens for simple postfix operators
|
||
|
|
|
||
|
|
Postfix operators need a special treatment because the different
|
||
|
|
length of the valuelist. For each different number of arguments before the
|
||
|
|
operator, a new rule must be inserted and a new token is created. The tokennames
|
||
|
|
build the content for this set. By looking in the set for already contained
|
||
|
|
tokens, we can decide whether a rule for this operator already exists.
|
||
|
|
|
||
|
|
*/
|
||
|
|
set<string> simplepostfixtokens;
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.4 Recognition of used Operators
|
||
|
|
|
||
|
|
The next two sets collects the names of already used operators as well as
|
||
|
|
the operatorname together with its pattern. Therewith it is possible
|
||
|
|
to ignore operators already transformed as well as operators with the
|
||
|
|
same name but different patterns.
|
||
|
|
|
||
|
|
*/
|
||
|
|
set<string> operatornames;
|
||
|
|
set<string> opnamesWithPattern;
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.5 Some variables for statistical informations
|
||
|
|
|
||
|
|
*/
|
||
|
|
int processedSpecifications; // number of processed specifications
|
||
|
|
|
||
|
|
|
||
|
|
void removeFiles();
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.4 The error function
|
||
|
|
|
||
|
|
This function will be called by the parser in case of an error.
|
||
|
|
The function writes an error message as well as the line number
|
||
|
|
which has caused the error to the standard error output.
|
||
|
|
|
||
|
|
*/
|
||
|
|
void yyerror( const char* s )
|
||
|
|
{
|
||
|
|
cerr << endl << s << endl << endl;
|
||
|
|
cerr << "error at line " << yylineno << endl;
|
||
|
|
removeFiles();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.5 The translation
|
||
|
|
|
||
|
|
This structur collects all information needed to construct the
|
||
|
|
appropriate translation rules.
|
||
|
|
|
||
|
|
*/
|
||
|
|
struct trans{
|
||
|
|
ostringstream* token;
|
||
|
|
ostringstream* opname;
|
||
|
|
ostringstream* pattern;
|
||
|
|
string alias;
|
||
|
|
vector<string>* arguments1; // arguments before the operator
|
||
|
|
vector<string>* arguments2; // arguments after the operator
|
||
|
|
vector<string>* implicitNames;
|
||
|
|
vector<string>* implicitTypes;
|
||
|
|
vector<int>* sublistlengths;
|
||
|
|
char bracket1; // open bracket after the operator
|
||
|
|
char bracket2; // close bracket after the operator
|
||
|
|
bool isSimple;
|
||
|
|
bool hasfunctions;
|
||
|
|
bool isPostfix; // postfix notation needs a special treatment
|
||
|
|
bool bufferForced;
|
||
|
|
} currenttranslation;
|
||
|
|
|
||
|
|
|
||
|
|
ostream& operator<<(ostream& o, const struct trans& t){
|
||
|
|
return o << "[" << t.token->str() << ", "
|
||
|
|
<< t.opname->str() << ", "
|
||
|
|
<< t.pattern->str() << ", "
|
||
|
|
<< t.alias << ", "
|
||
|
|
<< t.isPostfix << ", "
|
||
|
|
<< t.bufferForced << "]";
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.7 ~removeFiles~
|
||
|
|
|
||
|
|
Removes all output files.
|
||
|
|
|
||
|
|
*/
|
||
|
|
void removeFiles(){
|
||
|
|
if(lexrules != NULL){
|
||
|
|
lexrules->close();
|
||
|
|
lexrules=0;
|
||
|
|
}
|
||
|
|
if(yaccrules1 != NULL){
|
||
|
|
yaccrules1->close();
|
||
|
|
yaccrules1=0;
|
||
|
|
}
|
||
|
|
if(yaccrules2 != NULL){
|
||
|
|
yaccrules2->close();
|
||
|
|
yaccrules2=0;
|
||
|
|
}
|
||
|
|
if(tokens != NULL){
|
||
|
|
tokens->close();
|
||
|
|
tokens=0;
|
||
|
|
}
|
||
|
|
remove("lexrules");
|
||
|
|
remove("yaccrules1");
|
||
|
|
remove("yaccrules2");
|
||
|
|
remove("tokens");
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.6 The init function
|
||
|
|
|
||
|
|
This function creates all needed variables and sets them to
|
||
|
|
defined values.
|
||
|
|
|
||
|
|
*/
|
||
|
|
bool init(){
|
||
|
|
// set the translation to be empty
|
||
|
|
currenttranslation.token = new ostringstream();
|
||
|
|
currenttranslation.opname = new ostringstream();
|
||
|
|
currenttranslation.arguments1 = new vector<string>;
|
||
|
|
currenttranslation.arguments2 = new vector<string>;
|
||
|
|
currenttranslation.implicitNames = new vector<string>;
|
||
|
|
currenttranslation.implicitTypes = new vector<string>;
|
||
|
|
currenttranslation.sublistlengths = new vector<int>;
|
||
|
|
currenttranslation.pattern = new ostringstream();
|
||
|
|
currenttranslation.hasfunctions = false;
|
||
|
|
currenttranslation.isSimple = true;
|
||
|
|
currenttranslation.isPostfix = false;
|
||
|
|
currenttranslation.bufferForced = false;
|
||
|
|
// initialize outputfiles
|
||
|
|
lexrules = new ofstream("lexrules");
|
||
|
|
if(lexrules==NULL)
|
||
|
|
return false;
|
||
|
|
yaccrules1 = new ofstream("yaccrules1");
|
||
|
|
if(yaccrules1==NULL)
|
||
|
|
return false;
|
||
|
|
yaccrules2 = new ofstream("yaccrules2");
|
||
|
|
if(yaccrules2==NULL)
|
||
|
|
return false;
|
||
|
|
tokens = new ofstream("tokens");
|
||
|
|
tokenslength=0; // nothing written to tokens
|
||
|
|
if(tokens==NULL)
|
||
|
|
return false;
|
||
|
|
processedSpecifications=0;
|
||
|
|
|
||
|
|
// we need the "=" operator undepending on any algebras
|
||
|
|
// so it is defined fix in
|
||
|
|
// the parser. But we have to ignore it and we have to detect
|
||
|
|
// specification
|
||
|
|
// different to a standard infix operator
|
||
|
|
operatornames.insert("=");
|
||
|
|
opnamesWithPattern.insert("= _infixop_");
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.6 PrintStatistics
|
||
|
|
|
||
|
|
This function prints out some statistical information
|
||
|
|
to the standard output.
|
||
|
|
|
||
|
|
*/
|
||
|
|
void printStatistics(){
|
||
|
|
cout << " different operators " << operatornames.size() << endl;
|
||
|
|
cout << " processed specification " << processedSpecifications << endl;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.6 Finalize
|
||
|
|
|
||
|
|
This function closes all open files.
|
||
|
|
|
||
|
|
*/
|
||
|
|
bool finalize(){
|
||
|
|
(*lexrules) << endl;
|
||
|
|
lexrules->close();
|
||
|
|
(*yaccrules1) << "\n ;\n\n";
|
||
|
|
yaccrules1->close();
|
||
|
|
(*yaccrules2) << endl;
|
||
|
|
yaccrules2->close();
|
||
|
|
(*tokens) << endl << endl;
|
||
|
|
tokens->close();
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.8 reset
|
||
|
|
|
||
|
|
The reset function sets all value in the current translation
|
||
|
|
to the initial values.
|
||
|
|
|
||
|
|
*/
|
||
|
|
void reset(){
|
||
|
|
currenttranslation.opname->str("");
|
||
|
|
currenttranslation.token->str("");
|
||
|
|
currenttranslation.pattern->str("");
|
||
|
|
currenttranslation.hasfunctions = false;
|
||
|
|
currenttranslation.isSimple = true;
|
||
|
|
currenttranslation.isPostfix=false;
|
||
|
|
currenttranslation.bufferForced = false;
|
||
|
|
currenttranslation.arguments1->clear();
|
||
|
|
currenttranslation.arguments2->clear();
|
||
|
|
currenttranslation.implicitNames->clear();
|
||
|
|
currenttranslation.implicitTypes->clear();
|
||
|
|
currenttranslation.sublistlengths->clear();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.9 printtranslation
|
||
|
|
|
||
|
|
1.9.1 Print a simple non postfix translation
|
||
|
|
|
||
|
|
This function is very easy because all non-postfix
|
||
|
|
(infix, prefix) operators
|
||
|
|
can't have any function symbols. All infix and prefix
|
||
|
|
operators can be handled with standard definitions already
|
||
|
|
defined in the Parser. The only thing to do is to write a
|
||
|
|
appropriate rule in the lex specification.
|
||
|
|
|
||
|
|
*/
|
||
|
|
void print_simple_nonpostfix(){
|
||
|
|
const string opname = currenttranslation.opname->str();
|
||
|
|
string token = currenttranslation.token->str();
|
||
|
|
if(token=="ZZPREFIXOP" && !currenttranslation.bufferForced) return;
|
||
|
|
|
||
|
|
if(currenttranslation.bufferForced){
|
||
|
|
token += "_BUF";
|
||
|
|
}
|
||
|
|
(*lexrules) << "\"" << opname << "\" ";
|
||
|
|
(*lexrules) << " { yylval=NestedText::Atom(yytext,yyleng); return ";
|
||
|
|
(*lexrules) << token << ";}" << endl;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.9.2 print[_]simple[_]postfix
|
||
|
|
|
||
|
|
This function prints out a postfix function.
|
||
|
|
For each different number of arguments (before the operator),
|
||
|
|
a new rule must be created. A generic rule can't be written
|
||
|
|
because occuring conflicts in the resulting parser.
|
||
|
|
|
||
|
|
*/
|
||
|
|
void print_simple_postfix(){
|
||
|
|
const string opname = currenttranslation.opname->str();
|
||
|
|
string token = currenttranslation.token->str();
|
||
|
|
|
||
|
|
int size2=currenttranslation.arguments2->size();
|
||
|
|
if(size2>0){
|
||
|
|
token = token + "_a";
|
||
|
|
}
|
||
|
|
|
||
|
|
if(currenttranslation.bufferForced){
|
||
|
|
token += "_autobuffer";
|
||
|
|
}
|
||
|
|
|
||
|
|
if(simplepostfixtokens.find(token)==simplepostfixtokens.end()){
|
||
|
|
/*
|
||
|
|
The rule is not created in this case, we make entries in the
|
||
|
|
files rules and yaccrules1.
|
||
|
|
*/
|
||
|
|
simplepostfixtokens.insert(token);
|
||
|
|
// write token
|
||
|
|
int len = token.size();
|
||
|
|
if(tokenslength + len > maxtokenslength){
|
||
|
|
(*tokens) << endl;
|
||
|
|
tokenslength = 0;
|
||
|
|
}
|
||
|
|
tokenslength += len;
|
||
|
|
|
||
|
|
(*tokens) << token << " ";
|
||
|
|
// write rule
|
||
|
|
(*yaccrules1) << endl << "/*" << endl
|
||
|
|
<< "~token~" << endl
|
||
|
|
<< endl << "*/" << endl;
|
||
|
|
|
||
|
|
(*yaccrules1) << "\n | " ;
|
||
|
|
int size = currenttranslation.arguments1->size();
|
||
|
|
for(int i=0;i<size;i++){
|
||
|
|
string arg = (*currenttranslation.arguments1)[i];
|
||
|
|
(*yaccrules1) << arg << " " << endl;
|
||
|
|
}
|
||
|
|
(*yaccrules1) << token ;
|
||
|
|
if(size2!=0){
|
||
|
|
(*yaccrules1) << "'[' simplearguments ']'\n" ;
|
||
|
|
}
|
||
|
|
/* write the translation */
|
||
|
|
string space = "NestedText::AtomC(\" \")";
|
||
|
|
(*yaccrules1) << " { $$ =" << endl;
|
||
|
|
(*yaccrules1) << " NestedText::Concat( " << endl;
|
||
|
|
if(currenttranslation.bufferForced) {
|
||
|
|
(*yaccrules1) << " (USE_AUTO_BUFFER? NestedText::AtomC(\"( ! (\")"
|
||
|
|
" : NestedText::AtomC(\"(\")) ," << endl;
|
||
|
|
} else {
|
||
|
|
(*yaccrules1) << " NestedText::AtomC(\"(\")," << endl;
|
||
|
|
}
|
||
|
|
(*yaccrules1) << " NestedText::Concat( $"
|
||
|
|
<< (size+1)
|
||
|
|
<< "," << endl;
|
||
|
|
// write the arguments before the operator
|
||
|
|
for(int i=0; i<size;i++){
|
||
|
|
(*yaccrules1) << " NestedText::Concat(" << space << "," << endl;
|
||
|
|
(*yaccrules1) << " NestedText::Concat( $" << (i+1) << ","
|
||
|
|
<< endl;
|
||
|
|
}
|
||
|
|
if(size2>0){
|
||
|
|
(*yaccrules1) << " NestedText::Concat(NestedText::AtomC(\" \"),"
|
||
|
|
<< endl;
|
||
|
|
(*yaccrules1) << " NestedText::Concat( $" << (size+3) << ","
|
||
|
|
<< endl;
|
||
|
|
}
|
||
|
|
if(currenttranslation.bufferForced){
|
||
|
|
(*yaccrules1) << " (USE_AUTO_BUFFER? NestedText::AtomC(\"))\")";
|
||
|
|
(*yaccrules1) << " : NestedText::AtomC(\")\"))";
|
||
|
|
}else{
|
||
|
|
(*yaccrules1) << " NestedText::AtomC(\")\")";
|
||
|
|
}
|
||
|
|
for(int i=0;i< size;i++){
|
||
|
|
(*yaccrules1) << "))";
|
||
|
|
}
|
||
|
|
if(size2>0){
|
||
|
|
(*yaccrules1) << "))";
|
||
|
|
}
|
||
|
|
(*yaccrules1) << "));";
|
||
|
|
(*yaccrules1) << " }\n";
|
||
|
|
}
|
||
|
|
// write the rule for lex
|
||
|
|
(*lexrules) << "\"" << opname << "\" ";
|
||
|
|
(*lexrules) << " { yylval=NestedText::Atom(yytext,yyleng); return ";
|
||
|
|
(*lexrules) << token << ";}" << endl;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.9.3 print[_]complex[_]postfix[_]without implicit parameters
|
||
|
|
|
||
|
|
This function is called when a postfix operator including 'fun' or
|
||
|
|
'funlist' is be found and the implicit parameter list is empty.
|
||
|
|
|
||
|
|
*/
|
||
|
|
|
||
|
|
void print_complex_postfix_without_implicit_parameters(){
|
||
|
|
const string opname = currenttranslation.opname->str();
|
||
|
|
/* Found an operator with function arguments */
|
||
|
|
// define a new token from the alias
|
||
|
|
string newtoken = currenttranslation.alias;
|
||
|
|
newtoken = "ZZ"+newtoken;
|
||
|
|
|
||
|
|
int len = newtoken.size()+1;
|
||
|
|
if(tokenslength+len > maxtokenslength){
|
||
|
|
tokenslength = 0;
|
||
|
|
(*tokens) << endl;
|
||
|
|
}
|
||
|
|
tokenslength += len;
|
||
|
|
|
||
|
|
// write it into the tokens file
|
||
|
|
(*tokens) << newtoken << " ";
|
||
|
|
// write a lexrule
|
||
|
|
(*lexrules) << "\"" << opname << "\" ";
|
||
|
|
(*lexrules) << " { yylval=NestedText::Atom(yytext,yyleng); return ";
|
||
|
|
(*lexrules) << newtoken << ";}" << endl;
|
||
|
|
|
||
|
|
// write the pattern for this function
|
||
|
|
(*yaccrules1) << endl << "/*" << endl
|
||
|
|
<< "~token~" << endl
|
||
|
|
<< endl << "*/" << endl;
|
||
|
|
|
||
|
|
|
||
|
|
(*yaccrules1) << "\n | ";
|
||
|
|
int size1 = currenttranslation.arguments1->size();
|
||
|
|
// write the leading (simple) arguments
|
||
|
|
for(int i=0;i<size1;i++)
|
||
|
|
(*yaccrules1) << ((*currenttranslation.arguments1)[i])
|
||
|
|
<< " " << endl;
|
||
|
|
|
||
|
|
|
||
|
|
(*yaccrules1) << newtoken << "'[' ";
|
||
|
|
int size2 = currenttranslation.arguments2->size();
|
||
|
|
|
||
|
|
// position of this argument in the pattern
|
||
|
|
int positions[currenttranslation.arguments2->size()];
|
||
|
|
int separators = 0; // number of ';'
|
||
|
|
// = length of the first sublist
|
||
|
|
int nextseparator = (*currenttranslation.sublistlengths)[0];
|
||
|
|
|
||
|
|
for(int i=0;i<size2;i++){
|
||
|
|
if(i==nextseparator){ // end of this sublist
|
||
|
|
// write separator into the pattern
|
||
|
|
(*yaccrules1) << " ';' " << endl;
|
||
|
|
separators++;
|
||
|
|
nextseparator = i+(*currenttranslation.sublistlengths)[separators];
|
||
|
|
}
|
||
|
|
positions[i] = size1+3+ i*2;
|
||
|
|
string arg =((*currenttranslation.arguments2)[i]);
|
||
|
|
if(arg=="funlist")
|
||
|
|
arg = "list";
|
||
|
|
(*yaccrules1) << arg << endl;
|
||
|
|
if(i!=nextseparator-1)
|
||
|
|
(*yaccrules1) << "',' " << endl << " ";
|
||
|
|
}
|
||
|
|
(*yaccrules1) << " ']'" << endl;
|
||
|
|
// write the translation
|
||
|
|
|
||
|
|
|
||
|
|
string space = "NestedText::AtomC(\" \")";
|
||
|
|
(*yaccrules1) << " { $$ =";
|
||
|
|
(*yaccrules1) << " NestedText::Concat( " << endl;
|
||
|
|
if(currenttranslation.bufferForced){
|
||
|
|
(*yaccrules1) << " (USE_AUTO_BUFFER?NestedText::AtomC(\"( ! (\")"
|
||
|
|
" :NestedText::AtomC(\"(\"))," << endl;
|
||
|
|
} else {
|
||
|
|
(*yaccrules1) << " NestedText::AtomC(\"(\")," << endl;
|
||
|
|
}
|
||
|
|
(*yaccrules1) << " NestedText::Concat( $"
|
||
|
|
<< (size1+1)
|
||
|
|
<< "," << endl; // operatortoken
|
||
|
|
for(int i=0; i<size1;i++){ // arguments before operator
|
||
|
|
(*yaccrules1) << " NestedText::Concat(" << space << "," << endl;
|
||
|
|
(*yaccrules1) << " NestedText::Concat( $" << (i+1) << "," << endl;
|
||
|
|
}
|
||
|
|
for(int i=0; i<size2; i++){
|
||
|
|
(*yaccrules1) << " NestedText::Concat(" << space << "," << endl;
|
||
|
|
(*yaccrules1) << " NestedText::Concat( $" << positions[i] << ",";
|
||
|
|
}
|
||
|
|
if(currenttranslation.bufferForced){
|
||
|
|
(*yaccrules1) << " (USE_AUTO_BUFFER?NestedText::AtomC(\"))\")"
|
||
|
|
" :NestedText::AtomC(\")\")))";
|
||
|
|
} else {
|
||
|
|
(*yaccrules1) << " NestedText::AtomC(\")\"))";
|
||
|
|
}
|
||
|
|
for(int i=0;i< size1+size2;i++){
|
||
|
|
(*yaccrules1) << "))";
|
||
|
|
}
|
||
|
|
(*yaccrules1) << ");";
|
||
|
|
(*yaccrules1) << " }\n";
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.9.4 print[_]complex[_]postfix
|
||
|
|
|
||
|
|
This function handles postfix operators including functions
|
||
|
|
and implicit parameters. We build a new token as well as one
|
||
|
|
or two new yacc rules to handle such operators.
|
||
|
|
|
||
|
|
*/
|
||
|
|
void print_complex_postfix(){
|
||
|
|
string token = "ZZ" + currenttranslation.alias;
|
||
|
|
string opname = currenttranslation.opname->str();
|
||
|
|
// write to the tokens file
|
||
|
|
int len = token.size()+1;
|
||
|
|
if(tokenslength+len>maxtokenslength){
|
||
|
|
tokenslength = 0;
|
||
|
|
(*tokens) << endl;
|
||
|
|
}
|
||
|
|
tokenslength += len;
|
||
|
|
(*tokens) << token << " ";
|
||
|
|
// write rule for lex
|
||
|
|
(*lexrules) << "\"" << opname << "\" ";
|
||
|
|
(*lexrules) << " { yylval=NestedText::Atom(yytext,yyleng); return ";
|
||
|
|
(*lexrules) << token << ";}" << endl;
|
||
|
|
|
||
|
|
|
||
|
|
// build the string for functions from the implicit parameters
|
||
|
|
int sizei = currenttranslation.implicitNames->size();
|
||
|
|
if(sizei>9){
|
||
|
|
cerr << " Error: too many implicit parameters at line "
|
||
|
|
<< yylineno << endl;
|
||
|
|
cerr << " allowed numbe is 9, found " << sizei << " ones " << endl;
|
||
|
|
cerr << " The operator is " << opname << endl;
|
||
|
|
removeFiles();
|
||
|
|
exit(1);
|
||
|
|
}
|
||
|
|
|
||
|
|
string funname = currenttranslation.alias+"_fun";
|
||
|
|
string funlistname = funname+"list";
|
||
|
|
// write the rule for yacc
|
||
|
|
(*yaccrules1) << endl << "/*" << endl
|
||
|
|
<< "~token~" << endl
|
||
|
|
<< endl << "*/" << endl;
|
||
|
|
|
||
|
|
(*yaccrules1) << "\n | ";
|
||
|
|
// write leading arguments
|
||
|
|
int size1 = currenttranslation.arguments1->size();
|
||
|
|
for(int i=0;i<size1;i++){
|
||
|
|
(*yaccrules1) << (*currenttranslation.arguments1)[i] << " " << endl;
|
||
|
|
}
|
||
|
|
// write the operatortoken
|
||
|
|
(*yaccrules1) << token << " ";
|
||
|
|
// write the argumentlist, count the separators
|
||
|
|
bool fun_used = false;
|
||
|
|
bool funlist_used = false;
|
||
|
|
|
||
|
|
int separators = 0;
|
||
|
|
int positions[currenttranslation.arguments2->size()];
|
||
|
|
int nextseparator = (*currenttranslation.sublistlengths)[separators];
|
||
|
|
(*yaccrules1) << "'[' ";
|
||
|
|
int size2 = currenttranslation.arguments2->size();
|
||
|
|
|
||
|
|
for(int i=0;i<size2;i++){
|
||
|
|
if(i==nextseparator) { // end of a sublist
|
||
|
|
(*yaccrules1) << "';' " << endl;
|
||
|
|
separators++;
|
||
|
|
nextseparator=i+(*currenttranslation.sublistlengths)[separators];
|
||
|
|
}
|
||
|
|
positions[i] = size1 + 3 + 2*i;
|
||
|
|
string arg = (*currenttranslation.arguments2)[i];
|
||
|
|
if(arg == "fun"){
|
||
|
|
fun_used = true;
|
||
|
|
arg = funname;
|
||
|
|
} else if(arg == "funlist"){
|
||
|
|
funlist_used=true;
|
||
|
|
arg = funlistname;
|
||
|
|
}
|
||
|
|
(*yaccrules1) << arg << endl;
|
||
|
|
if( (i+1) != nextseparator)
|
||
|
|
(*yaccrules1) << "',' " << endl;
|
||
|
|
}
|
||
|
|
(*yaccrules1) << " ']' \n ";
|
||
|
|
// write the translation scheme
|
||
|
|
string space = "NestedText::AtomC(\" \")";
|
||
|
|
(*yaccrules1) << " { $$ =";
|
||
|
|
(*yaccrules1) << " NestedText::Concat( " << endl;
|
||
|
|
if(currenttranslation.bufferForced){
|
||
|
|
(*yaccrules1) << " (USE_AUTO_BUFFER?NestedText::AtomC(\"( ! (\")"
|
||
|
|
" :NestedText::AtomC(\"(\")),"
|
||
|
|
<< endl;
|
||
|
|
} else {
|
||
|
|
(*yaccrules1) << " NestedText::AtomC(\"(\")," << endl;
|
||
|
|
}
|
||
|
|
(*yaccrules1) << " NestedText::Concat( $" << (size1+1) << "," << endl;
|
||
|
|
for(int i=0; i<size1;i++){ // arguments before operator
|
||
|
|
(*yaccrules1) << " NestedText::Concat(" << space << "," << endl;
|
||
|
|
(*yaccrules1) << " NestedText::Concat( $" << (i+1) << "," << endl;
|
||
|
|
}
|
||
|
|
for(int i=0; i<size2; i++){
|
||
|
|
(*yaccrules1) << " NestedText::Concat(" << space << "," << endl;
|
||
|
|
(*yaccrules1) << " NestedText::Concat( $" << positions[i] << ","
|
||
|
|
<< endl;
|
||
|
|
}
|
||
|
|
if(currenttranslation.bufferForced){
|
||
|
|
(*yaccrules1) << " (USE_AUTO_BUFFER?NestedText::AtomC(\"))\")"
|
||
|
|
" :NestedText::AtomC(\")\")))"
|
||
|
|
<< endl;
|
||
|
|
} else {
|
||
|
|
(*yaccrules1) << " NestedText::AtomC(\")\"))" << endl;
|
||
|
|
}
|
||
|
|
for(int i=0;i< size1+size2;i++){
|
||
|
|
(*yaccrules1) << "))";
|
||
|
|
}
|
||
|
|
(*yaccrules1) << ");";
|
||
|
|
(*yaccrules1) << " }\n";
|
||
|
|
|
||
|
|
if(funlist_used) { // without a function list wo
|
||
|
|
// don't allow naming of functions
|
||
|
|
// print the rule for the function to yaccrules 2
|
||
|
|
(*yaccrules2) << endl << "/*" << endl
|
||
|
|
<< "~Function~" << endl
|
||
|
|
<< endl << "*/" << endl;
|
||
|
|
// case 1 a named function
|
||
|
|
(*yaccrules2) << funname << ": naming "<< funname << "_1" << endl;
|
||
|
|
(*yaccrules2) << " ";
|
||
|
|
if(currenttranslation.bufferForced){
|
||
|
|
(*yaccrules2) << "{$$ = NestedText::Concat( "
|
||
|
|
<< " (USE_AUTO_BUFFER?NestedText::AtomC(\"( ! (\")"
|
||
|
|
<< " :NestedText::AtomC(\"(\")), ";
|
||
|
|
} else {
|
||
|
|
(*yaccrules2) << "{$$ = NestedText::Concat(NestedText::AtomC(\"(\"), ";
|
||
|
|
}
|
||
|
|
(*yaccrules2) << endl;
|
||
|
|
(*yaccrules2) << " NestedText::Concat($1, " << endl;
|
||
|
|
(*yaccrules2) << " "
|
||
|
|
<< "NestedText::Concat(NestedText::AtomC(\" \"),"
|
||
|
|
<< endl;
|
||
|
|
(*yaccrules2) << " NestedText::Concat($2, " << endl;
|
||
|
|
if(currenttranslation.bufferForced){
|
||
|
|
(*yaccrules2) << " (USE_AUTO_BUFFER?NestedText::AtomC(\"))\")"
|
||
|
|
<< " :NestedText::AtomC(\")\"))"
|
||
|
|
<< " ))));} " << endl;
|
||
|
|
} else {
|
||
|
|
(*yaccrules2) << " NestedText::AtomC(\")\") ))));} " << endl;
|
||
|
|
}
|
||
|
|
// case 2: a named function with default value
|
||
|
|
(*yaccrules2) << " | naming "<< funname << "_1 ZZDEFAULTSEP valueexpr" << endl;
|
||
|
|
(*yaccrules2) << " ";
|
||
|
|
if(currenttranslation.bufferForced){
|
||
|
|
(*yaccrules2) << "{$$ = NestedText::Concat( "
|
||
|
|
<< " (USE_AUTO_BUFFER?NestedText::AtomC(\"( ! (\")"
|
||
|
|
<< " :NestedText::AtomC(\"(\")), ";
|
||
|
|
} else {
|
||
|
|
(*yaccrules2) << "{$$ = NestedText::Concat(NestedText::AtomC(\"(\"), ";
|
||
|
|
}
|
||
|
|
(*yaccrules2) << endl;
|
||
|
|
(*yaccrules2) << " NestedText::Concat($1, " << endl;
|
||
|
|
(*yaccrules2) << " "
|
||
|
|
<< "NestedText::Concat(NestedText::AtomC(\" \"),"
|
||
|
|
<< endl;
|
||
|
|
(*yaccrules2) << " NestedText::Concat($2, " << endl;
|
||
|
|
(*yaccrules2) << " NestedText::Concat(NestedText::AtomC(\" \"),";
|
||
|
|
(*yaccrules2) << " NestedText::Concat( $4 ,";
|
||
|
|
|
||
|
|
|
||
|
|
if(currenttranslation.bufferForced){
|
||
|
|
(*yaccrules2) << " (USE_AUTO_BUFFER?NestedText::AtomC(\"))\")"
|
||
|
|
<< " :NestedText::AtomC(\")\"))"
|
||
|
|
<< " ))))));} " << endl;
|
||
|
|
} else {
|
||
|
|
(*yaccrules2) << " NestedText::AtomC(\")\") ))))));} " << endl;
|
||
|
|
}
|
||
|
|
// case 3: unnamed function
|
||
|
|
(*yaccrules2) << " | " << funname << "_1 {$$ = $1;} " << endl;
|
||
|
|
// case 4: unnamed function with default value
|
||
|
|
(*yaccrules2) << " | " << funname << "_1 ZZDEFAULTSEP valueexpr " << endl;
|
||
|
|
(*yaccrules2) << " {$$ = NestedText::Concat($1, NestedText::Concat(NestedText::AtomC(\" \"), $3));";
|
||
|
|
(*yaccrules2) << " } " << endl;
|
||
|
|
(*yaccrules2) << " ; " << endl;
|
||
|
|
}
|
||
|
|
|
||
|
|
string extension = funlist_used? "_1":"";
|
||
|
|
|
||
|
|
// write the real function scheme
|
||
|
|
(*yaccrules2) << endl << "/*" << endl
|
||
|
|
<< "~function~" << endl
|
||
|
|
<< endl << "*/" << endl;
|
||
|
|
(*yaccrules2) << funname << extension << " : { " << endl;
|
||
|
|
(*yaccrules2) << " pair<int,string> p; " << endl;
|
||
|
|
for(int i=0;i<sizei;i++){ // put own variables on stack
|
||
|
|
(*yaccrules2) << " paramno++; " << endl;
|
||
|
|
(*yaccrules2) << " strcpy(paramname,\"";
|
||
|
|
(*yaccrules2) << (*currenttranslation.implicitNames)[i] << "\");"
|
||
|
|
<< endl;
|
||
|
|
(*yaccrules2) << " sprintf(params[" << (i+1) <<"]"
|
||
|
|
<< ", \"%s_%d\",paramname,paramno);"
|
||
|
|
<< endl;
|
||
|
|
(*yaccrules2) << " p = pair<int,string>("<< (i+1) << ", params[" << (i+1) << "]);" << endl;
|
||
|
|
(*yaccrules2) << " paramstack.push(p);" << endl;
|
||
|
|
}
|
||
|
|
(*yaccrules2) << " }" << endl;
|
||
|
|
(*yaccrules2) << " valueexpr" << endl;
|
||
|
|
(*yaccrules2) << " { " << endl;
|
||
|
|
(*yaccrules2) << " pair<int,string> p; " << endl;
|
||
|
|
for(int i=sizei;i>0;i--){ // remove own variables from stack
|
||
|
|
(*yaccrules2) << " p = paramstack.top(); " << endl;
|
||
|
|
(*yaccrules2) << " strcpy(params[p.first],p.second.c_str());" << endl;
|
||
|
|
(*yaccrules2) << " paramstack.pop();" << endl;
|
||
|
|
}
|
||
|
|
|
||
|
|
(*yaccrules2) << " "
|
||
|
|
<< "$$ = NestedText::Concat( NestedText::AtomC(\"(fun \"),"
|
||
|
|
<< endl;
|
||
|
|
for(int i=0; i< sizei ; i++){
|
||
|
|
(*yaccrules2) << " NestedText::Concat( NestedText::AtomC(\"(\"),"
|
||
|
|
<< endl;
|
||
|
|
(*yaccrules2) << " NestedText::Concat( NestedText::AtomC(params["
|
||
|
|
<< (i+1) << "]),"
|
||
|
|
<< endl;
|
||
|
|
(*yaccrules2) << " NestedText::Concat( NestedText::AtomC(\"";
|
||
|
|
(*yaccrules2) << " " << ((*currenttranslation.implicitTypes)[i])
|
||
|
|
<< "\")," << endl;
|
||
|
|
(*yaccrules2) << " NestedText::Concat(NestedText::AtomC(\")\"),"
|
||
|
|
<< endl;
|
||
|
|
}
|
||
|
|
(*yaccrules2) << " "
|
||
|
|
<< "NestedText::Concat( $2, NestedText::AtomC(\")\")))";
|
||
|
|
for(int i=0;i<sizei;i++){
|
||
|
|
(*yaccrules2) << " ))))";
|
||
|
|
}
|
||
|
|
(*yaccrules2) << ";" << endl;
|
||
|
|
// delete values of all parameters or restore the old values
|
||
|
|
(*yaccrules2) << " cleanVariables("<<sizei<<"); " << endl;
|
||
|
|
(*yaccrules2) << " restoreVariables(); " << endl;
|
||
|
|
(*yaccrules2) << " }" << endl;
|
||
|
|
(*yaccrules2) << " | function { $$ = $1; } " << endl;
|
||
|
|
(*yaccrules2) << " ;\n";
|
||
|
|
|
||
|
|
if(funlist_used) {
|
||
|
|
// rule for making bracket around the funlist
|
||
|
|
(*yaccrules2) << endl << "/*" << endl
|
||
|
|
<< "~funlist~" << endl
|
||
|
|
<< endl << "*/" << endl;
|
||
|
|
(*yaccrules2) << funlistname << ": " << funlistname << "_1 " << endl;
|
||
|
|
(*yaccrules2) << " "
|
||
|
|
<< "{ $$=NestedText::Concat(NestedText::AtomC(\"( \"),"
|
||
|
|
<< endl;
|
||
|
|
(*yaccrules2) << " NestedText::Concat($1, " << endl;
|
||
|
|
(*yaccrules2) << " NestedText::AtomC(\" ) \")));"
|
||
|
|
<< endl;
|
||
|
|
(*yaccrules2) << " } " << endl;
|
||
|
|
(*yaccrules2) << " ; " << endl;
|
||
|
|
// the funlist itself
|
||
|
|
(*yaccrules2) << endl << "/*" << endl
|
||
|
|
<< "~funlist~" << endl
|
||
|
|
<< endl << "*/" << endl;
|
||
|
|
(*yaccrules2) << funlistname << "_1 : "<< funname << "{$$ = $1;}"
|
||
|
|
<< endl; // one elem list
|
||
|
|
(*yaccrules2) << " | " << funlistname << "_1 ',' "
|
||
|
|
<< funname << endl; // composite list
|
||
|
|
(*yaccrules2) << " { $$ = NestedText::Concat($1," << endl;
|
||
|
|
(*yaccrules2) << " "
|
||
|
|
<< "NestedText::Concat(NestedText::AtomC(\" \"), $3));"
|
||
|
|
<< endl;
|
||
|
|
(*yaccrules2) << " }" << endl;
|
||
|
|
(*yaccrules2) << " ; \n";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
|
||
|
|
This function creates rules for les and yacc from the information stored in the
|
||
|
|
current translation. The rules are stored in the appropriate files.
|
||
|
|
|
||
|
|
*/
|
||
|
|
|
||
|
|
void printtranslation(){
|
||
|
|
const string opname = currenttranslation.opname->str();
|
||
|
|
const string token = currenttranslation.token->str();
|
||
|
|
|
||
|
|
if(currenttranslation.isSimple && ! currenttranslation.isPostfix){
|
||
|
|
print_simple_nonpostfix();
|
||
|
|
} else if(currenttranslation.isSimple){
|
||
|
|
print_simple_postfix();
|
||
|
|
}
|
||
|
|
else{
|
||
|
|
int implicitNamesSize = currenttranslation.implicitNames->size();
|
||
|
|
int implicitTypesSize = currenttranslation.implicitTypes->size();
|
||
|
|
if(implicitNamesSize!=implicitTypesSize){
|
||
|
|
cerr << " error in line " << yylineno << endl;
|
||
|
|
cerr << ("Different sizes for implicit names and types ");
|
||
|
|
cerr << " Names : ";
|
||
|
|
for(int i=0;i<implicitNamesSize;i++)
|
||
|
|
cerr << ((*currenttranslation.implicitNames)[i]) << endl;
|
||
|
|
cerr << " Types : ";
|
||
|
|
for(int i=0;i<implicitTypesSize;i++)
|
||
|
|
cerr << ((*currenttranslation.implicitTypes)[i]) << endl;
|
||
|
|
finalize();
|
||
|
|
removeFiles();
|
||
|
|
exit(1);
|
||
|
|
}
|
||
|
|
if(implicitNamesSize==0){ // without implicite parameters
|
||
|
|
print_complex_postfix_without_implicit_parameters();
|
||
|
|
} else{ // operator with implicit parameters
|
||
|
|
print_complex_postfix();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
%}
|
||
|
|
|
||
|
|
%union{
|
||
|
|
const char* text;
|
||
|
|
int len;
|
||
|
|
}
|
||
|
|
|
||
|
|
%token ZZOPERATOR ZZPATTERN ZZFUN ZZOP ZZINFIXOP ZZLIST
|
||
|
|
ZZIMPLICIT ZZPARAMETER ZZPARAMETERS ZZTYPE ZZTYPES ZZFUNLIST
|
||
|
|
ZZCOMMENT ZZFORCEBUFFER
|
||
|
|
|
||
|
|
%token<text> ZZIDENTIFIER ZZSYMBOL ZZALIAS
|
||
|
|
|
||
|
|
%type<text> name
|
||
|
|
%type<len> argscomma simpleargscomma simpleargsblank
|
||
|
|
|
||
|
|
%%
|
||
|
|
|
||
|
|
specfile : specs
|
||
|
|
|
|
||
|
|
;
|
||
|
|
|
||
|
|
specs : spec
|
||
|
|
| ZZCOMMENT
|
||
|
|
| specs spec
|
||
|
|
| specs ZZCOMMENT
|
||
|
|
;
|
||
|
|
|
||
|
|
spec : ZZOPERATOR name ZZALIAS ZZIDENTIFIER ZZPATTERN pattern implicit bufferforced
|
||
|
|
{ processedSpecifications++;
|
||
|
|
(*currenttranslation.opname) << $2;
|
||
|
|
currenttranslation.alias = $4;
|
||
|
|
// check for new operator
|
||
|
|
string op = string($2);
|
||
|
|
string opWithPattern= op+" " +
|
||
|
|
currenttranslation.pattern->str();
|
||
|
|
if(currenttranslation.bufferForced ){
|
||
|
|
opWithPattern +="!!";
|
||
|
|
}
|
||
|
|
if(operatornames.find(op)==operatornames.end()){
|
||
|
|
operatornames.insert(op);
|
||
|
|
opnamesWithPattern.insert(opWithPattern);
|
||
|
|
printtranslation(); // print out the current translation
|
||
|
|
} else{
|
||
|
|
// operator already exists check for different pattern
|
||
|
|
if(opnamesWithPattern.find(opWithPattern)==
|
||
|
|
opnamesWithPattern.end()){
|
||
|
|
cerr << " Conflicting definition of operator "
|
||
|
|
<< op << endl;
|
||
|
|
cerr << " Line in spec file is " << yylineno << endl;
|
||
|
|
removeFiles();
|
||
|
|
exit(1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
reset(); // make clean
|
||
|
|
}
|
||
|
|
;
|
||
|
|
|
||
|
|
name : ZZIDENTIFIER
|
||
|
|
{ $$ = $1; }
|
||
|
|
| ZZSYMBOL
|
||
|
|
{ $$ = $1; }
|
||
|
|
;
|
||
|
|
|
||
|
|
|
||
|
|
pattern : prefix
|
||
|
|
| infix
|
||
|
|
| postfix{
|
||
|
|
currenttranslation.isPostfix=true;
|
||
|
|
}
|
||
|
|
;
|
||
|
|
|
||
|
|
infix : '_' ZZINFIXOP '_'
|
||
|
|
{ currenttranslation.isSimple=true;
|
||
|
|
(*currenttranslation.token) << "ZZINFIXOP";
|
||
|
|
(*currenttranslation.pattern) << "_infixop_";
|
||
|
|
}
|
||
|
|
;
|
||
|
|
|
||
|
|
prefix : ZZOP '('simpleargscomma')'
|
||
|
|
{ currenttranslation.isSimple = true;
|
||
|
|
(*currenttranslation.token) << "ZZPREFIXOP";
|
||
|
|
(*currenttranslation.pattern) << "op(_";
|
||
|
|
for(int i=1;i<$3;i++){
|
||
|
|
(*currenttranslation.pattern) << ",_";
|
||
|
|
}
|
||
|
|
(*currenttranslation.pattern) << ")";
|
||
|
|
}
|
||
|
|
| ZZOP '(' ')'
|
||
|
|
{ currenttranslation.isSimple = true;
|
||
|
|
(*currenttranslation.token) << "ZZPREFIXOP";
|
||
|
|
(*currenttranslation.pattern) << "op(";
|
||
|
|
(*currenttranslation.pattern) << ")";
|
||
|
|
}
|
||
|
|
|
||
|
|
;
|
||
|
|
|
||
|
|
postfix : simpleargsblank ZZOP
|
||
|
|
{ currenttranslation.isSimple=true;
|
||
|
|
(*currenttranslation.token) << "ZZPOSTFIXOP"
|
||
|
|
<< (currenttranslation.arguments1->size());
|
||
|
|
for(int i=0;i<$1;i++){
|
||
|
|
(*currenttranslation.pattern) << "_";
|
||
|
|
}
|
||
|
|
(*currenttranslation.pattern) << "op";
|
||
|
|
}
|
||
|
|
| simpleargsblank ZZOP '[' arguments ']'
|
||
|
|
{ (*currenttranslation.token) << "ZZPOSTFIXOP"
|
||
|
|
<< (currenttranslation.arguments1->size());
|
||
|
|
for(int i=0;i<$1;i++){
|
||
|
|
(*currenttranslation.pattern) << "_";
|
||
|
|
}
|
||
|
|
(*currenttranslation.pattern) << "op[";
|
||
|
|
int lists = 0;
|
||
|
|
int nextlist = (*currenttranslation.sublistlengths)[0];
|
||
|
|
int size = currenttranslation.arguments2->size();
|
||
|
|
(*currenttranslation.pattern) <<
|
||
|
|
(*currenttranslation.arguments2)[0];
|
||
|
|
for(int i=1;i< size;i++){
|
||
|
|
if(i==nextlist){
|
||
|
|
lists++;
|
||
|
|
nextlist=(*currenttranslation.sublistlengths)[lists];
|
||
|
|
(*currenttranslation.pattern ) << ";" << endl;
|
||
|
|
}else{
|
||
|
|
(*currenttranslation.pattern) << "," << endl;
|
||
|
|
}
|
||
|
|
(*currenttranslation.pattern)
|
||
|
|
<< (*currenttranslation.arguments2)[i];
|
||
|
|
}
|
||
|
|
(*currenttranslation.pattern) << "]";
|
||
|
|
}
|
||
|
|
;
|
||
|
|
|
||
|
|
|
||
|
|
simpleargscomma : '_'
|
||
|
|
{$$ = 1; }
|
||
|
|
| simpleargscomma ',' '_'
|
||
|
|
{$$ = $1 + 1;}
|
||
|
|
;
|
||
|
|
|
||
|
|
simpleargsblank : '_'
|
||
|
|
{ currenttranslation.arguments1->push_back("valueexpr");
|
||
|
|
$$ = 1;
|
||
|
|
}
|
||
|
|
| simpleargsblank '_'
|
||
|
|
{ currenttranslation.arguments1->push_back("valueexpr");
|
||
|
|
$$ = $1 + 1;
|
||
|
|
}
|
||
|
|
;
|
||
|
|
|
||
|
|
arguments : sublist
|
||
|
|
| arguments ';' sublist
|
||
|
|
;
|
||
|
|
|
||
|
|
sublist : argscomma
|
||
|
|
{ currenttranslation.sublistlengths->push_back($1);
|
||
|
|
}
|
||
|
|
| ZZLIST
|
||
|
|
{ currenttranslation.arguments2->push_back("list");
|
||
|
|
currenttranslation.isSimple = false;
|
||
|
|
currenttranslation.sublistlengths->push_back(1);
|
||
|
|
}
|
||
|
|
| ZZFUNLIST{
|
||
|
|
currenttranslation.arguments2->push_back("funlist");
|
||
|
|
currenttranslation.isSimple = false;
|
||
|
|
currenttranslation.sublistlengths->push_back(1);
|
||
|
|
}
|
||
|
|
;
|
||
|
|
|
||
|
|
argscomma : arg
|
||
|
|
{ $$ = 1; }
|
||
|
|
| argscomma ',' arg
|
||
|
|
{ $$ = $1 + 1; }
|
||
|
|
;
|
||
|
|
|
||
|
|
arg : '_'
|
||
|
|
{ currenttranslation.arguments2->push_back("valueexpr");
|
||
|
|
}
|
||
|
|
| ZZFUN
|
||
|
|
{ currenttranslation.arguments2->push_back("fun");
|
||
|
|
currenttranslation.isSimple=false;
|
||
|
|
}
|
||
|
|
;
|
||
|
|
|
||
|
|
implicit : ZZIMPLICIT rest
|
||
|
|
{ (*currenttranslation.pattern) << "implicit ";
|
||
|
|
int size = currenttranslation.implicitNames->size();
|
||
|
|
for(int i=0;i<size;i++){
|
||
|
|
(*currenttranslation.pattern)
|
||
|
|
<< (*currenttranslation.implicitNames)[i] << " ";
|
||
|
|
}
|
||
|
|
(*currenttranslation.pattern) << "types ";
|
||
|
|
size = currenttranslation.implicitTypes->size();
|
||
|
|
for(int i=0;i<size;i++){
|
||
|
|
(*currenttranslation.pattern)
|
||
|
|
<< (*currenttranslation.implicitTypes)[i] << " ";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
|
||
|
|
;
|
||
|
|
|
||
|
|
rest : ZZPARAMETER parameterlist ZZTYPE typelist
|
||
|
|
| ZZPARAMETERS parameterlist ZZTYPES typelist
|
||
|
|
;
|
||
|
|
|
||
|
|
bufferforced : ZZFORCEBUFFER
|
||
|
|
{ currenttranslation.bufferForced=true;
|
||
|
|
}
|
||
|
|
|{ currenttranslation.bufferForced=false;
|
||
|
|
}
|
||
|
|
;
|
||
|
|
|
||
|
|
parameterlist : ZZIDENTIFIER
|
||
|
|
{ currenttranslation.implicitNames->push_back(string($1));
|
||
|
|
}
|
||
|
|
| parameterlist ',' ZZIDENTIFIER
|
||
|
|
{ currenttranslation.implicitNames->push_back(string($3));
|
||
|
|
}
|
||
|
|
;
|
||
|
|
typelist : ZZIDENTIFIER
|
||
|
|
{ currenttranslation.implicitTypes->push_back(string($1));
|
||
|
|
}
|
||
|
|
| typelist ',' ZZIDENTIFIER
|
||
|
|
{ currenttranslation.implicitTypes->push_back(string($3));
|
||
|
|
}
|
||
|
|
;
|
||
|
|
%%
|
||
|
|
|
||
|
|
|
||
|
|
int main(int argc, char** argv) {
|
||
|
|
FILE* ifile;
|
||
|
|
if(argc > 1){
|
||
|
|
ifile = fopen(argv[1], "r");
|
||
|
|
if (ifile == NULL) {
|
||
|
|
fprintf(stderr,"ERROR: cannot open file %s\n",argv[1]);
|
||
|
|
fprintf(stderr,"%s",argv[1]);
|
||
|
|
fprintf(stderr,"\n");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
yyin = ifile;
|
||
|
|
}
|
||
|
|
if(!init()){
|
||
|
|
cerr << "Error in initialization " << endl;
|
||
|
|
removeFiles();
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
if(yyparse()!=0){
|
||
|
|
cerr << " Error in parsing specification" << endl;
|
||
|
|
removeFiles();
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
printStatistics();
|
||
|
|
if(!finalize()){
|
||
|
|
cerr << "Error in finalization " << endl;
|
||
|
|
removeFiles();
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|