int main(int argc, char *argv[])
{ FILE *fpOut=NULL;
int traceLevel;
ATerm bottom;
ATinit(argc,argv,&bottom);
switch(parseArgs(argc, argv,&fpOut,&traceLevel)) {
case ERR_ARGS:
doHelp(argv[0]);
exit(EXIT_ERR_ARGS);
break;
case ERR_FILE:
exit(EXIT_ERR_FILE);
break;
case CMD_HELP:
doHelp(argv[0]);
exit(EXIT_OK);
break;
case CMD_VERSION:
doVersion(argv[0]);
exit(EXIT_OK);
case CMD_CONVERT:
exit(doConvert(fpOut, traceLevel));
break;
default:
exit(EXIT_OK);
}
} /* main */
int main(int argc, char *argv[])
{
ATerm tree;
ATinit(argc, argv, &tree);
ATprotect((ATerm*)&imported);
ATprotect(&parse_tree);
ATprotect((ATerm*)&includes);
process_options(argc, argv);
imported = ATmakeList0();
yydebug = 0;
open_dependencies(input_file);
tree = parse_file(input_file);
/* Open output file */
if (output_file == NULL)
outfile = stdout;
else
outfile = fopen(output_file, "w");
if(binary_output)
ATwriteToBinaryFile(tree, outfile);
else
ATwriteToTextFile(tree, outfile);
/* print_dependencies(input_file, imported); */
exit(0);
}
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);
}
}
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);
}
int main (int argc, char* argv[])
{
printf ("Building ATerm bottom; \n");
ATerm bottom;
printf ("Building the ROSE AST \n");
SgProject* project = frontend(argc,argv);
printf ("Calling ATinit \n");
ATinit(argc, argv, &bottom);
printf ("Calling convertNodeToAterm \n");
ATerm term = convertNodeToAterm(project /*.get_file(0).get_root()*/);
printf ("DONE: Calling convertNodeToAterm \n");
ROSE_ASSERT (term);
#if 0
// DQ (3/23/2013): This was already commented out...
AST_FILE_IO::startUp(sageProject);
std::string astBlob = AST_FILE_IO::writeASTToString();
term = ATsetAnnotation(term, ATmake("ast"), ATmake("<blob>", astBlob.length(), astBlob.data()));
#endif
#if 0
// DQ (3/23/2013): commented out while debugging.
ATwriteToBinaryFile(term, stdout);
#endif
return 0;
}
int main (int argc, char* argv[])
{
printf ("Building ATerm bottom; \n");
ATerm bottom;
printf ("Building the ROSE AST \n");
SgProject* project = frontend(argc,argv);
printf ("Calling ATinit \n");
ATinit(argc, argv, &bottom);
printf ("Calling convertNodeToAterm \n");
ATerm term = convertNodeToAterm(project /*.get_file(0).get_root()*/);
printf ("DONE: Calling convertNodeToAterm \n");
ROSE_ASSERT (term != NULL);
#if 0
// DQ (3/23/2013): This was already commented out...
AST_FILE_IO::startUp(sageProject);
std::string astBlob = AST_FILE_IO::writeASTToString();
term = ATsetAnnotation(term, ATmake("ast"), ATmake("<blob>", astBlob.length(), astBlob.data()));
#endif
#if 0
// DQ (3/23/2013): commented out while debugging.
// This can be usefull for piping output to other Stratego and Aterm tools/phases.
ATwriteToBinaryFile(term, stdout);
#endif
// Open a file for writing...
FILE* f = fopen("atermFile.aterm","w");
// Write the aterm to the file.
ATbool status = ATwriteToTextFile(term,f);
ROSE_ASSERT(status == ATtrue);
// Close the file.
fclose(f);
#if 0
// Testing the ATerm file I/O.
// Open a file for writing...
FILE* file = fopen("atermFile.aterm","r");
printf ("Read aterm file \n");
// Write the aterm to the file.
ATerm term2 = ATreadFromTextFile(file);
ROSE_ASSERT(term2 != NULL);
printf ("Closing file after reading aterm \n");
// Close the file.
fclose(file);
#endif
return 0;
}
int main(int argc, char *argv[])
{
ATerm bottomOfStack;
ATinit(argc, argv, &bottomOfStack);
foo();
return 0;
}
int main(int argc, char *argv[])
{
ATerm syntax = NULL, extended = NULL;
char *moduleName = "Main";
char *input = "-";
char *output = "-";
int cid;
int c, toolbus_mode = 0;
ATerm bottomOfStack;
name = argv[0];
/* Check whether we're a ToolBus process */
for(c=1; !toolbus_mode && c<argc; c++) {
toolbus_mode = !strcmp(argv[c], "-TB_TOOL_NAME");
}
ATinit(argc, argv, &bottomOfStack);
SDF_initSDFMEApi();
ASC_initRunTime(INITIAL_TABLE_SIZE);
register_Add_Eqs_Syntax();
resolve_Add_Eqs_Syntax();
init_Add_Eqs_Syntax();
if(toolbus_mode) {
#ifndef WIN32 /* Code with Toolbus calls, non Windows */
ATBinit(argc, argv, &bottomOfStack); /* Initialize the Aterm library */
cid = ATBconnect(NULL, NULL, -1, addeqssyntax_handler);
ATBeventloop();
#else
ATwarning("addeqssyntax: Toolbus cannot be used in Windows.\n");
#endif
}
else {
while ((c = getopt(argc, argv, myarguments)) != -1) {
switch (c) {
case 'm': moduleName=optarg; break;
case 'v': run_verbose = ATtrue; break;
case 'i': input=optarg; break;
case 'o': output=optarg; break;
case 'V': version(); exit(0); break;
case 'h':
default: usage(); exit(0); break;
}
}
argc -= optind;
argv += optind;
syntax = ATreadFromNamedFile(input);
extended = addEqsSyntax(moduleName, syntax);
ATwriteToNamedBinaryFile(extended, output);
}
return 0;
}
int main(int argc, char *argv[])
{
ATerm bottomOfStack;
ATerm t1 = NULL, t2 = NULL;
int i;
int result = 0;
ATinit(argc, argv, &bottomOfStack);
PT_initMEPTApi();
if (argc < 3 || argc > 7) {
usage(argv[0]);
}
for (i=1; i < argc; i++) {
if (strcmp(argv[i], "-h") == 0) {
usage(argv[0]);
}
else if (strcmp(argv[i], "-V") == 0) {
fprintf(stderr, "%s v%s\n", argv[0], version);
}
else if (strcmp(argv[i], "-l") == 0) {
modLayout = !modLayout;
}
else {
if (t1 == NULL) {
t1 = ATreadFromNamedFile(argv[i]);
if (t1 == NULL) {
ATerror("Failed to read from %s\n", argv[i]);
}
}
else if (t2 == NULL) {
t2 = ATreadFromNamedFile(argv[i]);
if (t2 == NULL) {
ATerror("Failed to read from %s\n", argv[i]);
}
}
else {
usage(argv[0]);
}
}
}
result = PT_compareTree(PT_getParseTreeTop(PT_ParseTreeFromTerm(t1)),
PT_getParseTreeTop(PT_ParseTreeFromTerm(t2)),
modLayout);
if (result < 0) {
return -1;
}
if (result > 0) {
return 1;
}
return 0;
}
int main(int argc, char *argv[])
{
ATerm bottomOfStack;
ATinit(argc, argv, &bottomOfStack);
PT_initMEPTApi();
SDF_initSDFMEApi();
return testPT2SDF();
}
int main(int argc, char **argv) {
ATerm bos;
AIL_ByteCode bc = NULL; FILE *f;
ABF abf; int n, i;
ATinit(argc, argv, &bos);
f = fopen(argv[1], "r");
bc = AIL_readFromFile(f);
AN2_disassemble(stdout, bc);
return 0;
}
JNIEXPORT void JNICALL Java_sglr_SGLRInvoker_initialize(JNIEnv* env, jobject method){
if(!initialized){
ATerm x;
ATinit(0, NULL, &x);
SGLR_initialize();
A2Pinitialize();
parseTreeSpec = generateParseTreeSpec();
initialized = 1;
}
}
int main(int argc, char **argv)
{
int c;
ATerm bottomOfStack;
PT_ParseTree tree, flatTree;
/* Configuration items */
char *input="-";
char *output="-";
ATbool bafmode=ATtrue;
ATbool verbose=ATfalse;
ATbool proceed=ATtrue;
extern char *optarg;
extern int optind;
/* Commandline mode */
while ((c = getopt(argc, argv, myarguments)) != -1) {
switch (c) {
case 'b': bafmode = ATtrue; break;
case 'i': input=optarg; break;
case 'o': output=optarg; break;
case 't': bafmode = ATfalse; break;
case 'v': verbose = ATtrue; break;
case 'V': version(); proceed=ATfalse; break;
case 'h':
default: usage(); proceed=ATfalse; break;
}
}
argc -= optind;
argv += optind;
ATinit(argc, argv, &bottomOfStack);
PT_initMEPTApi();
PT_initAsFix2Api();
if(proceed) {
tree = PT_ParseTreeFromTerm(ATreadFromNamedFile(input));
flatTree = flattenPT(tree);
if(!flatTree) {
ATerror("%s: conversion failed.", myname);
}
if(bafmode) {
ATwriteToNamedBinaryFile(PT_ParseTreeToTerm(flatTree), output);
}
else {
ATwriteToNamedTextFile(PT_ParseTreeToTerm(flatTree), output);
}
}
return 0;
}
int main(int argc, char *argv[])
{
ATerm bottomOfStack;
ATinit(argc, argv, &bottomOfStack);
initRolodexApi();
testRolodex();
return 0;
}
int main(int argc, char *argv[])
{
ATerm bottomOfStack;
ATinit(argc, argv, &bottomOfStack);
PT_initMEPTApi();
init_terms_dict();
testCompare();
return 0;
}
int main(int argc, char *argv[]) {
ATerm bottomOfStack;
ATinit(argc, argv, &bottomOfStack);
CC_init();
test_chars();
test_sets();
return 0;
}
int main (int argc, char **argv)
{
int c;
ATerm bottomOfStack;
PT_ParseTree parsetree;
ATerm ambiguities;
ATbool atermformat = ATfalse;
char *input_file_name = "-";
char *output_file_name = "-";
while ((c = getopt(argc, argv, myarguments)) != EOF)
switch (c) {
case 'a': atermformat = ATtrue; break;
case 'h': usage(); exit(0);
case 'i': input_file_name = optarg; break;
case 'o': output_file_name = optarg; break;
case 'V': fprintf(stderr, "%s %s\n", myname, myversion);
exit(0);
default : usage(); exit(1);
}
ATinit(argc, argv, &bottomOfStack); /* Initialize Aterm library */
PT_initMEPTApi();
parsetree = PT_ParseTreeFromTerm(ATreadFromNamedFile(input_file_name));
if(parsetree == NULL) {
ATerror("%s: could not read term from input file %s\n",
myname, input_file_name);
}
ambiguities = PT_reportParseTreeAmbiguities(parsetree);
if(!atermformat) {
FILE *fp = NULL;
if(!strcmp(output_file_name, "") || !strcmp(output_file_name,"-")) {
fp = stdout;
} else if(!(fp = fopen(output_file_name, "wb"))) {
ATerror("%s: could not open %s for output.\n", myname, output_file_name);
return 1;
}
prettyPrint(ambiguities,fp);
fclose(fp);
} else {
ATwriteToNamedTextFile(ambiguities, output_file_name);
}
return 0;
}
int main(int argc, char *argv[])
{
ATerm aBottom;
ATermBBTree aTree;
ATinit(argc, argv, &aBottom);
ATbbtreeInit();
aTree = makeTree(dataValues);
/*ATftreeToDot(stdout, aTree);*/
test_walk(aTree, sortedDataValues);
return 0;
}
int main(int argc, char *argv[])
{
ATermList numbers, primes;
ATerm bottomOfStack;
int i, max = 100;
for(i=1; i<argc; i++)
if(strcmp(argv[i], "-max") == 0)
max = atoi(argv[++i]);
ATinit(argc, argv, &bottomOfStack);
numbers = generate_numbers(max);
primes = filter_non_primes(numbers);
ATprintf("primes up to %d: %, l\n", max, primes);
return 0;
}
int main(int argc, char **argv) {
int i;
ATerm bos;
ATermList list;
ATinit(argc,argv,&bos);
list = ATempty;
for (i = 1; i < argc; i++) {
FILE *f = fopen(argv[i], "r");
ATwarning("Adding %s.\n", argv[i]);
if (!f) ATabort("Error opening file %s.\n", argv[i]);
list = ATconcat(list,(ATermList)ATreadFromTextFile(f));
fclose(f);
}
ATwriteToTextFile((ATerm)list,stdout);
return 0;
}
int main(int argc, char *argv[]) {
FILE *in;
ATinit(argc,argv,(ATerm*) &argc);
ATsetWarningHandler(WarningHandler);
ATsetErrorHandler(ErrorHandler);
if (argc>1) {
if (!strcmp(argv[1],"-help")) {
help(); exit(0);
}
if (!strcmp(argv[1],"-help-mcrl")) {
help(); MCRLhelp(); exit(0);
}
if (!strcmp(argv[1],"-version")) {
version(); exit(0);
}
}
in = Stategraph(argc, argv);
exit(0);
}
int main(int argc, char *argv[]) {
int result = 0;
ATerm bottomOfStack;
char* atargs[6];
int useToolbus = 0;
int i = 0;
atargs[0] = argv[0];
atargs[1] = "-at-termtable";
atargs[2] = "18";
atargs[3] = "-at-afuntable";
atargs[4] = "15";
atargs[5] = "-at-silent";
/*atargs[5] = "-at-verbose";*/
/* The main options haven't been set yet so we can't check if we're doing the
* stats. */
SGLR_STATS_initialMRSS = STATS_ResidentSetSize();
ATinit(6, atargs, &bottomOfStack);
/* Set to debug ATerms.*/
/*ATsetChecking(ATtrue);*/
SGLR_initialize();
SGLR_STATS_setCount(SGLR_STATS_initialMemAllocated, STATS_Allocated());
for (i=1; !useToolbus && i < argc; i++) {
useToolbus = !strcmp(argv[i], "-TB_TOOL_NAME");
}
if (useToolbus) {
runTool(&bottomOfStack, argc, argv);
}
else {
result = runCommandLineTool(argc, argv);
}
SGLR_STATS_setCount(SGLR_STATS_endMRSS, STATS_ResidentSetSize());
return result;
}
int main(int argc, char *argv[])
{
ATerm bottomOfStack;
ATerm data[20];
ATinit(argc, argv, &bottomOfStack);
initBuiltinsApi();
/* Note that there is still a bug in ApiGen,
* If all of these constructors were in the same sort,
* wrong code would have been generated. This needs
* to be fixed!
*/
data[0] = (ATerm) makeDIinteger(1);
assert(data[0] && ATisEqual(data[0], ATparse("int([1])")));
data[1] = (ATerm) makeDDdouble(1.0);
assert(data[1] && ATisEqual(data[1], ATparse("double(1.0)")));
data[2] = (ATerm) makeDSstring("one");
assert(data[2] && ATisEqual(data[2], ATparse("str(\"one\")")));
data[3] = (ATerm) makeDTrm(ATparse("one"));
assert(data[3] && ATisEqual(data[3], ATparse("term(one)")));
data[4] = (ATerm) makeDLst((ATermList) ATparse("[one]"));
assert(data[4] && ATisEqual(data[4], ATparse("list([one])")));
data[5] = (ATerm) makeLexicalDefault("hello");
assert(data[5] && ATisEqual(data[5], ATparse("string([104,101,108,108,111])")));
assert(strcmp(getLexicalString((Lexical) data[5]), "hello") == 0);
data[6] = (ATerm) makeCharacterDefault('A');
assert(data[6] && ATisEqual(data[6], ATparse("character(65)")));
assert(getCharacterCh((Character) data[6]) == 'A' );
return 0;
}
int main(int argc, char *argv[]) {
int i, j = 0;
ATbool result = ATfalse;
int absCounter;
char **newargv = (char**) calloc(argc + 1, sizeof(char*));
parseCommandLine(argc, argv);
if (!newargv) ATerror("Cannot allocate array argv");
newargv[j++] = argv[0];
ATinit(argc, argv, (ATerm*) &argc);
ATsetWarningHandler(WarningHandler);
ATsetErrorHandler(ErrorHandler);
if (!MCRLinitRW(j, newargv)) exit(-1);
fprintf(stderr, "Number of Summands (input): %d\n",
ATgetLength(MCRLgetListOfSummands()));
if(prevAbstraction()){
P("The Specification has been abstracted before.");
exit(0);
}
initAbsInt();
abstractParsAndVars();
specAbstraction();
abstractSummands();
fprintf(stderr, "Number of Summands (output): %d\n",
ATgetLength(MCRLgetListOfSummands()));
printResults();
MCRLoutput();
if (!result) exit(EXIT_FAILURE); else exit(EXIT_SUCCESS);
}
int main (int argc, char *argv[])
{
int c; /* option character */
ATerm bottomOfStack;
ATerm tree;
Graph graph;
char *input_file_name = "-";
char *output_file_name = "-";
ATbool characters = ATfalse;
ATbool productions = ATfalse;
ATbool layout = ATfalse;
ATbool literals = ATtrue;
ATbool binary = ATtrue;
ATbool sharing = ATfalse;
#ifndef WITHOUT_TOOLBUS
ATbool use_toolbus = ATfalse;
int i;
for (i=1; !use_toolbus && i < argc; i++) {
use_toolbus = !strcmp(argv[i], "-TB_TOOL_NAME");
}
if (use_toolbus) {
int cid;
ATBinit(argc, argv, &bottomOfStack);
PT_initMEPTApi();
initGraphApi();
cid = ATBconnect(NULL, NULL, -1, graph_converter_handler);
ATBeventloop();
}
else
#endif
{
while ((c = getopt(argc, argv, myarguments)) != EOF)
switch (c) {
case 'b': binary = ATtrue; break;
case 'c': characters = ATtrue; break;
case 'h': usage(); exit(0);
case 'i': input_file_name = optarg; break;
case 'l': layout = ATtrue; break;
case 'm': literals = ATfalse; break;
case 'o': output_file_name = optarg; break;
case 'p': productions = ATtrue; break;
case 't': binary = ATfalse; break;
case 's': sharing = ATtrue; break;
case 'V': fprintf(stderr, "%s %s\n", myname, myversion);
exit(0);
default : usage(); exit(1);
}
ATinit(argc, argv, &bottomOfStack);
PT_initMEPTApi();
initGraphApi();
tree = ATreadFromNamedFile(input_file_name);
if(tree == NULL) {
ATerror("%s: could not read term from input file %s\n",
myname, input_file_name);
}
graph = PT_printAnyToGraph(tree, characters, productions,
layout, literals, sharing);
if (!strcmp(output_file_name,"-")) {
if (binary) {
ATwriteToBinaryFile(GraphToTerm(graph), stdout);
}
else {
ATwriteToTextFile(GraphToTerm(graph), stdout);
}
}
else {
if (binary) {
ATwriteToNamedBinaryFile(GraphToTerm(graph), output_file_name);
}
else {
ATwriteToNamedTextFile(GraphToTerm(graph), output_file_name);
}
}
}
return 0;
}
int main(int argc, char *argv[])
{
double duration;
struct tms start, end;
ATerm in_term, out_term;
ATinit(argc, argv, &in_term);
ATprotectArray(term_stack, TSIZE);
ATprotectArray(environment, ESIZE);
process_options(argc, argv);
/* Open input file */
if (input_file == NULL)
infile = stdin;
else
infile = fopen(input_file, "r");
/* Push term to be reduced on term stack */
if ((in_term = ATreadFromFile(infile)) == NULL) {
ATfprintf(stderr, "not a valid term\n");
exit(1);
}
in_term = /*list_to_consnil*/(in_term);
debugs(ATfprintf(stderr, "in_term (b) = %t\n", in_term));
/* Execute the strategy */
times(&start);
out_term = doit(in_term);
times(&end);
duration = ((double)(end.tms_utime - start.tms_utime))/((double)CLK_TCK);
if(out_term != NULL)
{
/* Open output file */
if (output_file == NULL)
outfile = stdout;
else
outfile = fopen(output_file, "w");
/* ATfprintf(stdout, "%t\n", out_term); */
if(binary_output)
ATwriteToBinaryFile(/*consnil_to_list*/(out_term), outfile);
else
ATwriteToTextFile(/*consnil_to_list*/(out_term), outfile);
}
print_profile(duration);
if (!failed)
{
ATfprintf(stderr, " rewriting succeeded\n");
exit(0);
}
else
{
ATfprintf(stderr, " rewriting failed\n");
exit(1);
}
}
int
main (int argc, char **argv)
{
int c; /* option character */
ATerm bottomOfStack;
char *inputs[MAX_MODULES] = { "-" };
int nInputs = 0;
char *output = "-";
ATbool module = ATfalse;
ATermList list;
ASF_ASFConditionalEquationList alleqs;
int i;
if(argc == 1) { /* no arguments */
usage();
exit(1);
}
while ((c = getopt(argc, argv, myarguments)) != EOF) {
switch (c) {
case 'h':
usage();
exit(0);
case 'm':
module = ATtrue;
break;
case 'o':
output = strdup(optarg);
break;
case 'V': fprintf(stderr, "%s %s\n", myname, myversion);
exit(0);
default:
usage();
exit(1);
}
}
/* The optind variable indicates where getopt has stopped */
for(i = optind; i < argc; i++) {
if (nInputs < MAX_MODULES) {
inputs[nInputs++] = strdup(argv[i]);
} else {
ATerror("Maximum number of %d modules exceeded.\n", MAX_MODULES);
exit(1);
}
}
if (nInputs == 0) {
nInputs = 1;
inputs[0] = strdup("-");
}
ATinit(argc, argv, &bottomOfStack);
PT_initMEPTApi();
ASF_initASFMEApi();
list = ATempty;
for (--nInputs; nInputs >= 0; nInputs--) {
ATerm p = ATreadFromNamedFile(inputs[nInputs]);
if (p == NULL) {
ATwarning("concat-asf: Unable to read anything from %s\n",
inputs[nInputs]);
}
else {
list = ATinsert(list, p);
}
free(inputs[nInputs]);
}
alleqs = ASF_makeASFConditionalEquationListEmpty();
for(;!ATisEmpty(list); list = ATgetNext(list)) {
ATerm head = ATgetFirst(list);
ASF_ASFConditionalEquationList list;
if (ATgetType(head) == AT_LIST) {
list = ASF_ASFConditionalEquationListFromTerm(head);
}
else {
ASF_ASFModule module = ASF_getStartTopASFModule(ASF_StartFromTerm(head));
list = ASF_getASFModuleEquationList(module);
}
ATwarning("Adding %d equations\n", ASF_getASFConditionalEquationListLength(list));
alleqs = ASF_unionASFConditionalEquationList(alleqs, ASF_makeLayoutNewline(), list);
}
if (module) {
ASF_OptLayout l = ASF_makeLayoutNewline();
ASF_ASFSection sec = ASF_makeASFSectionEquations(l, alleqs);
ASF_ASFModule mod = ASF_makeASFModuleDefault(ASF_makeASFSectionListSingle(sec));
/*PT_ParseTree pt = PT_makeValidParseTreeFromTree((PT_Tree) mod);*/
ATwriteToNamedBinaryFile((ATerm) mod, output);
}
else {
ATwriteToNamedBinaryFile(ASF_ASFConditionalEquationListToTerm(alleqs),
output);
}
return 0;
}
int main(int argc, char *argv[])
{
int i;
ATerm bottomOfStack;
char *dict_name = NULL;
ATerm dict;
ATermList terms, afuns;
static char code_buf[BUFSIZ];
static char file_buf[BUFSIZ];
for (i=1; i<argc; i++) {
if (strcmp(argv[i], "-h") == 0) {
usage(argv[0], 0);
}
else if (strcmp(argv[i], "-no-date") == 0) {
opt_gen_date = 0;
}
else if (strcmp(argv[i], "-dict") == 0) {
dict_name = argv[++i];
}
else if (strcmp(argv[i], "-code-prefix") == 0) {
code_prefix = argv[++i];
}
else if (strcmp(argv[i], "-file-prefix") == 0) {
file_prefix = argv[++i];
}
}
if (dict_name == NULL) {
usage(argv[0], 1);
}
/*{{{ Build code prefix */
if (code_prefix == NULL) {
char *ptr = strrchr(dict_name, '/');
int index = 0;
if (!ptr) {
ptr = dict_name;
}
else {
ptr++; /* skip '/' itself */
}
for(; *ptr; ptr++) {
if (!isalnum((int)*ptr)) {
code_buf[index++] = '_';
} else {
code_buf[index++] = *ptr;
}
}
code_buf[index++] = '\0';
code_prefix = code_buf;
}
/*}}} */
/*{{{ Build file prefix */
if (file_prefix == NULL) {
char *ptr = strrchr(dict_name, '/');
int index = 0;
if (!ptr) {
ptr = dict_name;
}
else {
ptr++; /* skip '/' itself */
}
for(; *ptr; ptr++) {
if (!isalnum((int)*ptr) && *ptr != '-') {
file_buf[index++] = '_';
} else {
file_buf[index++] = *ptr;
}
}
file_buf[index++] = '\0';
file_prefix = file_buf;
}
/*}}} */
ATinit(argc, argv, &bottomOfStack);
dict = ATreadFromNamedFile(dict_name);
if (!dict) {
fprintf(stderr, "could not read dictionary from file: %s\n", dict_name);
exit(1);
}
if (!ATmatch(dict, "[afuns([<list>]),terms([<list>])]", &afuns, &terms)) {
usage(argv[0], 1);
}
generateCode(terms, afuns);
return 0;
}
int asc_support_main(ATerm *bottomOfStack, int argc, char *argv[], void (*register_all)(), void (*resolve_all)(), void (*init_all)(), unsigned const char* tableBaf, size_t tableSize, ATbool parseInput, ATBhandler handler) {
PT_ParseTree pt = NULL;
PT_Tree asfix;
PT_Tree trm;
PT_ParseTree rpt = NULL;
ATerm reduct;
const char *outputFilename;
int numberOfInputs;
ATinit(argc, argv, bottomOfStack);
initApis();
register_all();
resolve_all();
init_all();
initParsetable(tableBaf, tableSize);
SGLR_initialize();
OPT_initialize();
ASC_initializeDefaultOptions();
/* Check whether we're a ToolBus process */
if (toolbusMode(argc, argv)) {
ATBinit(argc, argv, bottomOfStack);
ATBconnect(NULL, NULL, -1, asf_toolbus_handler);
ATBeventloop();
}
else {
handleOptions(argc, argv, parseInput);
numberOfInputs = ASC_getNumberOfParseTrees();
outputFilename = ASC_getOutputFilename();
if (!streq(ASC_getPrefixFunction(),"")) {
pt = applyFunction((const char*) ASC_getPrefixFunction(),
(const char*) ASC_getResultNonTermName(), numberOfInputs, inputs);
}
else {
if (numberOfInputs == 0) {
pt = parsetreeFromFile("-", parseInput);
}
else if (numberOfInputs == 1) {
pt = inputs[0];
}
else if (numberOfInputs != 1) {
ATerror("Can only process one argument if no -f and -r option "
"are supplied.\n"
"Did a -s argument eat up your -f or -r option?\n");
return 1;
}
}
if (PT_isValidParseTree(pt)) {
trm = PT_getParseTreeTop(pt);
if (ASC_getVerboseFlag()) { ATfprintf(stderr,"Reducing ...\n"); }
reduct = innermost(trm);
if (ASC_getVerboseFlag()) { ATfprintf(stderr,"Reducing finished.\n"); }
if (ASC_getStatsFlag()) { printStats(); }
if (ASC_getOutputFlag()) {
asfix = toasfix(reduct);
rpt = PT_makeParseTreeTop(asfix, 0);
if (parseInput) {
FILE *fp = NULL;
if (!strcmp(outputFilename, "-")) {
fp = stdout;
}
else {
fp = fopen(outputFilename, "wb");
}
if (fp != NULL) {
PT_yieldParseTreeToFile(rpt, fp, ATfalse);
}
else {
ATerror("asc-main: unable to open %s for writing\n", outputFilename);
}
}
else {
if (ASC_getBafmodeFlag()) {
ATwriteToNamedBinaryFile(PT_ParseTreeToTerm(rpt),outputFilename);
}
else {
ATwriteToNamedTextFile(PT_ParseTreeToTerm(rpt),outputFilename);
}
}
}
}
}
return 0;
}
int main (int argc, char *argv[])
{
int c;
ATerm bottomOfStack;
ATerm input = NULL;
ATerm output = NULL;
ATbool textual = ATfalse;
char *input_file_name = "-";
char *output_file_name = "-";
int i;
ATbool use_toolbus = ATfalse;
ATinit(argc, argv, &bottomOfStack);
RS_initRStoreApi();
PRS_initParsedRStoreApi();
for (i=1; !use_toolbus && i < argc; i++) {
use_toolbus = !strcmp(argv[i], "-TB_TOOL_NAME");
}
if (use_toolbus) {
int cid;
ATBinit(argc, argv, &bottomOfStack);
cid = ATBconnect(NULL, NULL, -1, lower_rstore_handler);
ATBeventloop();
}
else {
while ((c = getopt(argc, argv, myarguments)) != EOF)
switch (c) {
case 'h': usage(); exit(0);
case 'i': input_file_name = optarg; break;
case 'o': output_file_name = optarg; break;
case 't': textual = ATtrue; break;
case 'V': fprintf(stderr, "%s %s\n", myname, myversion);
exit(0);
default : usage(); exit(1);
}
input = ATreadFromNamedFile(input_file_name);
if(input == NULL) {
ATerror("%s: could not read term from input file %s\n",
myname, input_file_name);
return 1;
}
if (PRS_isValidRStore((PRS_RStoreFromTerm(input)))) {
output = (ATerm) RS_lowerRStore(PRS_RStoreFromTerm(input));
}
else if (PRS_isValidStart(PRS_StartFromTerm(input))) {
PRS_RStore tmp = PRS_getStartTopRStore(PRS_StartFromTerm(input));
output = (ATerm) RS_lowerRStore(tmp);
}
if(output != NULL) {
if (textual) {
ATwriteToNamedTextFile(output, output_file_name);
}
else {
ATwriteToNamedSAFFile(output, output_file_name);
}
}
else {
ATwarning("%s: something went wrong\n", myname);
return 1;
}
}
return 0;
}
