ATerm SSL_fdcopy(ATerm fdinA, ATerm fdoutA)
{
int fdin, fdout;
int n;
char buf[SSL_COPY_BUFSIZE];
if(ATgetType(fdinA) != AT_INT || ATgetType(fdinA) != AT_INT)
_fail(fdinA);
fdin = ATgetInt((ATermInt)fdinA);
fdout = ATgetInt((ATermInt)fdoutA);
while( (n = read(fdin, buf, SSL_COPY_BUFSIZE)) > 0 )
if(write(fdout, buf, n) != n)
{
ATfprintf(stderr, "SSL_fdcopy: write error\n");
_fail((ATerm) ATempty);
}
if(n < 0)
{
ATfprintf(stderr, "SSL_fdcopy: read error\n");
_fail((ATerm) ATempty);
}
return (ATerm) ATempty;
}
ATerm parse_file(char *name)
{
ATermList decls;
int res;
if(name == NULL) {
yyin = stdin;
fprintf(stderr, "parsing stdin ...");
} else {
yyin = find_file(name);
/* add file to list of dependencies */
ATfprintf(dep_file, "%s ", file_name);
yylineno = 0;
if(!yyin) {
fprintf(stderr, "no such file: %s\n", name);
exit(1);
}
if(!silent)
fprintf(stderr, "parsing %s ...", file_name);
}
if((res = parse()) == 0) {
if(!silent)
ATfprintf(stderr, " succeeded\n", parse_tree);
if(ATmatch(parse_tree, "Specification([<list>])", &decls))
{
return ATmake("Specification([<list>])",
get_imports(decls));
}
else
return parse_tree;
} else {
ATfprintf(stderr, " parsing %s failed\n\n", name);
exit(1);
}
}
ATerm parse_file(char *name)
{
ATermList decls;
int res;
if(name == NULL) {
yyin = stdin;
fprintf(stderr, "parsing stdin ...");
} else {
yyin = fopen(name, "r");
sprintf(file_name, "%s", name);
/* yyin = find_file(name); */
/* add file to list of dependencies */
/* ATfprintf(dep_file, "%s ", file_name); */
yylineno = 0;
if(!yyin) {
fprintf(stderr, "no such file: %s\n", name);
exit(1);
}
if(!silent)
fprintf(stderr, "parsing %s ...", file_name);
}
if((res = parse()) == 0) {
if(!silent)
ATfprintf(stderr, " succeeded\n", parse_tree);
return parse_tree;
} else {
ATfprintf(stderr, " parsing %s failed\n\n", name);
exit(1);
}
}
ATermList get_imports(ATermList decls)
{
ATerm decl, mod, spec;
ATermList mods, new_decls;
new_decls = ATmakeList0();
while(!ATisEmpty(decls)) {
decl = ATgetFirst(decls);
decls = ATgetNext(decls);
if(ATmatch(decl, "Imports([<list>])", &mods)) {
while(!ATisEmpty(mods)) {
mod = ATgetFirst(mods);
mods = ATgetNext(mods);
if(ATindexOf(imported, mod, 0) == -1)
{
if(!silent)
ATfprintf(stderr, " importing: %t\n", mod);
imported = ATinsert(imported, mod);
sprintf(file_name, "%s.r", t_string(mod));
spec = parse_file(file_name);
new_decls = ATconcat(spec_decls(spec), new_decls);
}
else
{
if(!silent)
ATfprintf(stderr, " importing: %t (done)\n", mod);
}
}
} else {
new_decls = ATinsert(new_decls, decl);
}
}
return new_decls;
}
int main (int argc, char * argv [])
{
ATerm out_term;
ATermList in_term;
int i;
ATinit(argc, argv, &(out_term));
init_constructors();
in_term = ATempty;
for ( i = (argc - 1) ; (i >= 0) ; i-- )
{
in_term = ATinsert(in_term, (ATerm) ATmakeAppl0(ATmakeSymbol(argv[i], 0, ATtrue)));
}
SRTS_stratego_initialize();
memset(__tracing_table, 0, (sizeof(unsigned short) * TRACING_TABLE_SIZE));
__tracing_table_counter = 0;
register_strategies();
out_term = main_0_0(NULL, (ATerm) in_term);
if((out_term != NULL))
{
ATfprintf(stdout, "%t\n", out_term);
exit(0);
}
else
{
ATfprintf(stderr, "%s: rewriting failed, trace:\n", argv[0]);
for ( i = 0 ; (__tracing_table[i] && (i < TRACING_TABLE_SIZE)) ; i++ )
ATfprintf(stderr, "\t%s\n", __tracing_table[i]);
exit(1);
}
}
static void init_module_constant_terms(void)
{
ATfprintf(stderr, "init_constant_terms (bar.c)()\n");
ATprotect(&(term_p_0));
term_p_0 = (ATerm) ATmakeAppl(ATmakeSymbol("a", 0, ATtrue));
ATfprintf(stderr, "init_constant_terms (bar.c) end()\n");
}
void print_profile(double duration)
{
int counter;
if(show_stats > 0)
{
ATfprintf(stderr, "\n statistics :");
if(duration != 0)
ATfprintf(stderr,
" %.2f seconds, %d steps, %.2f steps/sec\n",
(double)duration, rule_counter, ((double) rule_counter)/duration);
else
ATfprintf(stderr,
" %.2f seconds, %d steps\n",
duration, rule_counter);
}
if(show_stats > 1)
{
ATfprintf(stderr, " counts per rule :\n");
for(counter = 0; counter < cur_rule_counter; counter++)
{
ATfprintf(stderr, "%17s : %6d\n", rule_counters[counter].name,
rule_counters[counter].count);
}
}
}
void SG_Usage(FILE *stream, ATbool long_message)
{
const char usage[] = "Usage:\n\t%s\t-p file [-2?bcdhlmnPtvV] "
"[-f[adeirp]] [-i file] [-o file] \\"
"\n\t\t[-s sort]\n";
ATfprintf(stream, usage, program_name);
if(long_message) {
ATfprintf(stream,
"Parameters:\n"
"\t-2 : use AsFix2 output format [%s]\n"
"\t-A : ambiguities are treated as errors [%s]\n"
"\t-b : output AsFix in binary format (BAF) [%s]\n"
"\t-c : toggle cycle detection [%s]\n"
"\t-d : toggle debug mode [%s]\n"
"\t-f[adeipr] : toggle filtering, or specific filter [%s]\n"
"\t a : associativity [%s]\n"
"\t d : direct eagerness [%s]\n"
"\t e : eagerness [%s]\n"
"\t i : injection count [%s]\n"
"\t p : priority [%s]\n"
"\t r : reject [%s]\n"
"\t-h, -? : display usage information\n"
"\t-i file : input from |file| [%s]\n"
"\t-l : toggle statistics logging [%s]\n"
"\t-m : use AsFix2ME output format [%s]\n"
"\t-n : toggle parse tree creation [%s]\n"
"\t-o file : output to |file| [%s]\n"
"\t-p file : use parse table |file| (required) [%s]\n"
"\t-s symbol : define start symbol [%s]\n"
"\t-t : output AsFix in textual format [%s]\n"
"\t-v : toggle verbose mode [%s]\n"
"\t-V : reveal program version (i.e. %s)\n",
DEFAULTMODE(!asfix2meflag),
DEFAULTMODE(ambiguityerrorflag),
DEFAULTMODE(binaryflag),
DEFAULTMODE(cycleflag),
DEFAULTMODE(debugflag),
DEFAULTMODE(filterflag),
DEFAULTMODE(filter_associativityflag),
DEFAULTMODE(filter_directeagernessflag),
DEFAULTMODE(filter_eagernessflag),
DEFAULTMODE(filter_injectioncountflag),
DEFAULTMODE(filter_priorityflag),
DEFAULTMODE(filter_rejectflag),
input_file_name,
DEFAULTMODE(statisticsflag),
DEFAULTMODE(asfix2meflag),
DEFAULTMODE(outputflag),
output_file_name,
parse_table_name?parse_table_name:"unspecified",
start_symbol ? start_symbol:"any",
DEFAULTMODE(!binaryflag),
DEFAULTMODE(verboseflag),
VERSION
);
}
}
void DumpOneAction(FILE *out, parse_table *pt, int s)
{
actions val;
int c, nxt = 0;
for(c = 0; c <= SG_CHAR_CLASS_EOF; c++) {
if((val = SG_LookupAction(pt, SG_SETSTATE(s), c)) && !ATisEmpty(val)) {
if(!nxt++)
ATfprintf(out,"%d", s);
ATfprintf(out,"\t%d\t%t\n", c, val);
}
}
}
static void generateHeader(FILE *file, ATermList terms, ATermList afuns)
{
if (opt_gen_date) {
time_t now = time(NULL);
fprintf(file, "/*\n * Generated at %s", ctime(&now));
fprintf(file, " */\n\n");
}
fprintf(file, "#ifndef __%s_H\n", code_prefix);
fprintf(file, "#define __%s_H\n\n", code_prefix);
fprintf(file, "#include <aterm2.h>\n\n");
fprintf(file, "#include <assert.h>\n\n");
while (!ATisEmpty(afuns)) {
ATerm afun, alias, pair = ATgetFirst(afuns);
afuns = ATgetNext(afuns);
if (!ATmatch(pair, "[<term>,<term>]", &alias, &afun)) {
ATfprintf(stderr, "malformed [alias,afun] pair: %t\n", pair);
exit(1);
}
checkAlias(alias);
checkAFun(afun);
ATfprintf(file, "extern AFun %t;\n", alias);
}
fprintf(file, "\n");
while (!ATisEmpty(terms)) {
ATerm term, alias, pair = ATgetFirst(terms);
terms = ATgetNext(terms);
if (!ATmatch(pair, "[<term>,<term>]", &alias, &term)) {
ATfprintf(stderr, "malformed [alias,term] pair: %t\n", pair);
exit(1);
}
checkAlias(alias);
ATfprintf(file, "extern ATerm %t;\n", alias);
}
fprintf(file, "\nextern void init_%s();\n", code_prefix);
fprintf(file, "\n#endif /* __%s_H */\n", code_prefix);
}
/* Event handler for tool 'batch' */
ATerm batch_handler(int conn, ATerm term)
{
ATerm in, out;
/* We need some temporary variables during matching */
int i0;
char *s0;
ATerm t0;
if(ATmatch(term, "rec-eval(fromFile)")) {
return fromFile(conn);
}
if(ATmatch(term, "rec-do(toFile(<str>,<int>))", &s0, &i0)) {
toFile(conn, s0, i0);
return NULL;
}
if(ATmatch(term, "rec-terminate(<term>)", &t0)) {
rec_terminate(conn, t0);
return NULL;
}
if(ATmatch(term, "rec-do(signature(<term>,<term>))", &in, &out)) {
ATerm result = batch_checker(conn, in);
if(!ATmatch(result, "[]"))
ATfprintf(stderr, "warning: not in input signature:\n\t%\n\tl\n", result);
return NULL;
}
ATerror("tool batch cannot handle term %t", term);
return NULL; /* Silence the compiler */
}
/* Event handler for tool 'toolSdf2Sig' */
ATerm toolSdf2Sig_handler(int conn, ATerm term)
{
ATerm in, out;
/* We need some temporary variables during matching */
char *s0, *s1;
ATerm t0;
if(ATmatch(term, "rec-eval(rewrite(<term>))", &t0)) {
return rewrite(conn, t0);
}
if(ATmatch(term, "rec-eval(apply-rewrite(<str>,<str>,<term>))", &s0, &s1, &t0)) {
return apply_rewrite(conn, s0, s1, t0);
}
if(ATmatch(term, "rec-terminate(<term>)", &t0)) {
rec_terminate(conn, t0);
return NULL;
}
if(ATmatch(term, "rec-do(signature(<term>,<term>))", &in, &out)) {
ATerm result = toolSdf2Sig_checker(conn, in);
if(!ATmatch(result, "[]"))
ATfprintf(stderr, "warning: not in input signature:\n\t%\n\tl\n", result);
return NULL;
}
ATerror("tool toolSdf2Sig cannot handle term %t", term);
return NULL; /* Silence the compiler */
}
/* Event handler for tool 'restorebrackets' */
ATerm restorebrackets_handler(int conn, ATerm term)
{
ATerm in, out;
/* We need some temporary variables during matching */
ATerm t0, t1;
if(ATmatch(term, "rec-eval(restore-brackets(<term>,<term>))", &t0, &t1)) {
return restore_brackets(conn, t0, t1);
}
if(ATmatch(term, "rec-terminate(<term>)", &t0)) {
rec_terminate(conn, t0);
return NULL;
}
if(ATmatch(term, "rec-eval(add-brackets(<term>,<term>))", &t0, &t1)) {
return add_brackets(conn, t0, t1);
}
if(ATmatch(term, "rec-do(signature(<term>,<term>))", &in, &out)) {
ATerm result = restorebrackets_checker(conn, in);
if(!ATmatch(result, "[]"))
ATfprintf(stderr, "warning: not in input signature:\n\t%\n\tl\n", result);
return NULL;
}
ATerror("tool restorebrackets cannot handle term %t", term);
return NULL; /* Silence the compiler */
}
ATerm bar_1_0(StrSL sl, StrCL s, ATerm t)
{
ATfprintf(stderr, "bar_1_0(%t)\n", t);
t = cl_fun(s)(cl_sl(s),t);
t = (ATerm)ATmakeAppl2(sym__2, term_p_0, t);
return(t);
}
void CAESAR_PRINT_STATE_HEADER(CAESAR_TYPE_FILE fp) {
ATerm l = (ATerm)MCRLgetListOfPars();
ATerm v,s;
while (ATmatch(l,"[v(<term>,<term>),<list>]",
&v,&s,&l))
ATfprintf(fp,"%t:%s \n",MCRLprint(v),ATgetName(ATgetSymbol(s)));
}
int main(int argc, char *argv[])
{
ATerm in_term, out_term;
int i;
/* ATfprintf(stderr, "This is %s\n", argv[0]); */
ATinit(argc, argv, &in_term);
ATprotectArray(term_stack, TSIZE);
ATprotectArray(environment, ESIZE);
in_term = ATmake("Nil");
for(i = argc - 1; i >= 0; i--)
{
/* ATfprintf(stderr, " %s", argv[i]); */
in_term = App2("Cons", ATmakeString(argv[i]), in_term);
}
/* ATfprintf(stderr, "\n", argv[i]); */
out_term = doit(in_term);
ATfprintf(stderr, "**** rewriting terminated abnormally\n");
exit(3);
}
static
void unexpected(ATerm tree, int n, char *str)
{
ATfprintf(stderr,
"The %dth argument was expected to be %s\n%a\n", n, str, ATgetAFun(tree));
exit(1);
}
static void checkAFun(ATerm afun)
{
if (ATgetType(afun) != AT_APPL) {
ATfprintf(stderr, "wrong afun spec: %t\n", afun);
exit(1);
}
}
int ACC_try() {
#ifdef DEBUG
ATfprintf(stderr, "Trying.\n");
#endif
// return localSetChoicePoint();
return setChoicePoint();
}
void usage(void)
{
ATfprintf(stderr,
"usage:\n"
" %s [-silent] [-i file] [-o file] [-b] [-stats] [-help|-h]\n",
program_name);
exit(1);
}
static void prettyPrint(ATerm t, FILE *fp)
{
ATermList ambs;
int count;
int i;
if (ATmatch(t, "ambiguities(<int>,[<list>])",&count,&ambs)) {
if (count == 0) {
ATfprintf(fp,"No ambiguities\n");
}
else {
ATfprintf(fp, "%d ambiguity cluster%s:\n\n",count,count > 1 ? "s" : "");
for(i = 1;!ATisEmpty(ambs); ambs = ATgetNext(ambs), i++) {
ATerm amb = ATgetFirst(ambs);
ATermList productions;
ATerm line, col, offset;
if(ATmatch(amb,"ambiguity("
" position(character(0),"
" line(<term>),"
" col(<term>),"
" char(<term>)),"
" productions([<list>]))",
&line,
&col,
&offset,
&productions)) {
ATfprintf(fp,"[%d/%d] at (%t:%t):\n", i, count, line, col);
for(;!ATisEmpty(productions); productions = ATgetNext(productions)) {
char *str = deslash(ATgetFirst(productions));
ATfprintf(fp," %s\n", str);
free(str);
}
ATfprintf(fp,"\n");
} else {
ATerror("%s: Unexpected term: %t\n",myname,t);
}
}
}
} else {
ATerror("%s: Unexpected term: %t\n", myname,t);
return;
}
}
void ACC_throw_failure() {
#ifdef DEBUG
ATfprintf(stderr, "Throwing failure\n");
#endif
thrown = AN2_FAILURE;
//localFail();
fail();
}
void ACC_throw_exception(AN2Data data) {
#ifdef DEBUG
ATfprintf(stderr, "Throwing exception\n");
#endif
thrown = AN2_EXCEPTION;
ACC_set_raised_data(data);
// localFail();
fail();
}
static void char2buf(char c)
{
if(offset >= bufsize)
ATfprintf(stderr, "Buffer overflow, ignoring %c\n", c);
else {
BUF[offset++] = c;
BUF[offset] = '\0';
}
}
AN2Data ACC_catch_exception() {
#ifdef DEBUG
ATfprintf(stderr, "Catching exception\n");
#endif
if (thrown == AN2_EXCEPTION)
return ACC_get_raised_data();
//localFail();
fail();
}
/*
* This handler is invoked by the toolbus module whenever an event is received
* from the toolbus.
*/
ATerm toolbus_handler( int tb_conn, ATerm input )
{
ATerm rv = NULL; /* return value, gets sent back to the toolbus */
ATerm myterm; /* general purpose */
ATerm myterm2; /* general purpose */
char html_buf[HTML_BUF_SIZE];
char *html_text;
ATfprintf( stderr, "mod_toolbus: toolbus_handler(): received: %t\n",
input );
fflush( stderr );
/*
* match input from toolbus
*/
/* toolbus asked for a signature check */
if(ATmatch(input, "rec-do(signature(<term>,<term>))", &myterm, &myterm2))
{
ATfprintf( stderr, "mod_toolbus: toolbus_handler(): signature check\n" );
fflush( stderr );
rv = NULL; /* we don't do a signature check */
}
/* receive ack of an event we sent (that's how we initiated our session) */
else if( ATmatch( input, "rec-ack-event(<term>)", &myterm ) )
{
ATfprintf( stderr, "mod_toolbus: toolbus_handler(): rec-ack-event: %t\n",
myterm );
fflush( stderr );
rv = NULL;
}
/* toolbus asked us to display an HTML page encoded as an ATerm */
else if( ATmatch( input, "rec-do(reply-html(<term>))", &myterm ) )
{
ATfprintf(stderr, "mod_toolbus: toolbus_handler(): rec-do(reply-html())\n" );
ATparseHTML( myterm, html_buf, HTML_BUF_SIZE );
ap_rprintf( global_http_req, html_buf );
global_is_tb_session_done ++; /* after this we're done */
rv = NULL;
}
else if( ATmatch( input, "rec-do(reply-text(<str>))", &html_text ) )
{
ATfprintf(stderr, "mod_toolbus: toolbus_handler(): rec-do(reply-text())\n" );
ap_rprintf( global_http_req, html_text );
global_is_tb_session_done ++; /* after this we're done */
rv = NULL;
}
else /* default response */
{
global_is_tb_session_done ++;
ATfprintf( stderr, "mod_toolbus: toolbus_handler(): event: default\n" );
fflush( stderr );
rv = NULL;
}
ATfprintf( stderr, "mod_toolbus: toolbus_handler(): leaving...\n" );
fflush( stderr );
return rv;
}
ATerm SSL_getPlaceholder(ATerm t) {
int type = ATgetType(t);
if(type != AT_PLACEHOLDER) {
ATfprintf(stderr, "[error] SSL_getPlaceholder: not a placeholder: %t \n", t);
_fail(t);
} else {
ATermPlaceholder ph = (ATermPlaceholder) t;
ATerm result = ATgetPlaceholder(ph);
return result;
}
}
AN2Data ACC_catch_failure() {
#ifdef DEBUG
ATfprintf(stderr, "Catching failure\n");
#endif
if (thrown == AN2_FAILURE)
/* This is strange: without returning anything I get a segmentation
* fault in the choice point library (_memcpy_by8). */
return NULL;
//localFail();
fail();
}
void HFdump(struct HFnode *tree, int d){
int i;
if(tree!=NULL){
if (tree->low==NULL && tree->high==NULL){
if (tree->term==NULL)
ATfprintf(stderr," (%d) Term NULL\n", tree->frequency);
else
ATfprintf(stderr," (%d) Term %t\n", tree->frequency, tree->term);
} else {
fprintf(stderr," (%ld)\n", tree->frequency);
for(i=0;i<d;i++)fprintf(stderr," ");
fprintf(stderr,"0");
HFdump(tree->low,d+1);
for(i=0;i<d;i++)fprintf(stderr," ");
fprintf(stderr,"1");
HFdump(tree->high,d+1);
}
}
}
ATerm SSL_read_term_from_string(ATerm str_term) {
if(!ATisString(str_term)) return NULL;
const char* str = AT_getString(str_term);
ATerm result = ATreadFromString(str);
if(result == NULL) {
ATfprintf(stderr, "not a valid term\n");
_fail(str_term);
}
return result;
}
