static ATermList applyImports(SDF_ImportList imports, PT_ParseTree pt)
{
ATermList result = ATempty;
while (!SDF_isImportListEmpty(imports)) {
SDF_Import import = SDF_getImportListHead(imports);
if (SDF_hasImportRenamings(import)) {
SDF_Renamings renamings = SDF_getImportRenamings(import);
result = ATinsert(result,
ATBpack(
PT_ParseTreeToTerm(applyRenamings(renamings, pt))));
}
else {
result = ATinsert(result, ATBpack(PT_ParseTreeToTerm(pt)));
}
if (SDF_hasImportListTail(imports)) {
imports = SDF_getImportListTail(imports);
}
else {
break;
}
}
return result;
}
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;
}
static ATerm parse(const unsigned char *inputString, unsigned int inputStringLength, const char *inputPath, const char *parseTableName){
PT_ParseTree parseTree;
InputString sglrInputString;
ERR_resetErrorManager();
sglrInputString = IS_allocateString(inputPath, inputString, inputStringLength);
if(inputString == NULL){
return ERR_SummaryToTerm(ERR_getManagerSummary());
}
if(!SGLR_isParseTableLoaded(parseTableName)){
if(SG_AddParseTable(parseTableName) == NULL){
return ERR_SummaryToTerm(ERR_getManagerSummary());
}
}
parseTree = SGLR_parse(sglrInputString, parseTableName);
if(parseTree == NULL){
return ERR_SummaryToTerm(ERR_getManagerSummary());
}
return PT_ParseTreeToTerm(parseTree);
}
ATerm normalize_and_generate_table(const char *name, PT_ParseTree sdf2term) {
ATerm pt = NULL;
PT_Tree ksdf;
if (PGEN_getStatsFlag) { STATS_Timer(); }
if (PGEN_getGenerationModeFlag()) {
ksdf = PT_getParseTreeTree(sdf2term);
} else {
ksdf = normalizeGrammar(name, sdf2term);
}
PGEN_STATS_setCount(PGEN_STATS_normalizationTime, STATS_Timer());
if (PGEN_getNormalizationModeFlag()) {
return PT_ParseTreeToTerm(PT_makeValidParseTreeFromTree(ksdf));
}
if (ksdf) {
pt = sdf_generate_table(ksdf);
}
PGEN_STATS_setCount(PGEN_STATS_generationTime, STATS_Timer());
return (ATerm)pt;
}
ATerm pretty_print(int cid, ATerm input)
{
PT_ParseTree parsetree = NULL;
BOX_Start box = NULL;
PT_Tree result = NULL;
ERR_resetErrorManager();
parsetree = PT_ParseTreeFromTerm(ATBunpack(input));
if (parsetree != NULL) {
box = pandora(parsetree);
}
if (box != NULL) {
result = toText(PT_ParseTreeFromTerm(BOX_StartToTerm(box)));
}
if (result != NULL) {
PT_ParseTree presult = PT_makeValidParseTreeFromTree(result);
ATerm value = ATBpack(PT_ParseTreeToTerm(presult));
return ATmake("snd-value(pretty-printed(<term>))", value);
}
else {
ERR_Summary summary = ERR_getManagerSummary();
return ATmake("snd-value(pretty-print-error(<term>))", summary);
}
}
static ATerm addEqsSyntax(const char *name, ATerm term)
{
PT_ParseTree parseTree = PT_ParseTreeFromTerm(term);
PT_Tree ptApplied = addEqsSyntaxFunction(name, parseTree);
ATerm reduct = innermost(ptApplied);
PT_Tree asfix = toasfix(reduct);
return PT_ParseTreeToTerm(PT_makeValidParseTreeFromTree(asfix));
}
ATerm STRSGLR_anno_position_info(ATerm pt_term, ATerm path_term)
{
PT_ParseTree pt;
const char* path;
if(!AT_isString(path_term)) {
return NULL;
}
path = AT_getString(path_term);
pt = PT_ParseTreeFromTerm(pt_term);
pt = PT_addParseTreePosInfoSome(path, pt, -1, ATfalse, ATfalse);
return PT_ParseTreeToTerm(pt);
}
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;
char *input="-";
char *output="-";
char *argument = NULL;
ATbool minimizeSort = ATfalse;
ATbool maximizeSort = ATfalse;
ATerm inputTerm = NULL;
ATerm outputTerm = NULL;
PT_ParseTree inputTree = NULL;
PT_ParseTree outputTree = NULL;
while ((c = getopt(argc, argv, myarguments)) != -1) {
switch (c) {
case 'i':
input=optarg;
break;
case 'n':
minimizeSort = ATtrue;
argument = optarg;
break;
case 'N':
maximizeSort = ATtrue;
argument = optarg;
break;
case 'o':
output=optarg;
break;
case 'V':
version();
return 0;
case 'h':
usage();
return 0;
default:
usage();
return 1;
}
}
ATinit(argc, argv, &bottomOfStack);
PT_initMEPTApi();
inputTerm = ATreadFromNamedFile(input);
inputTree = PT_ParseTreeFromTerm(inputTerm);
if (inputTerm != NULL) {
/* The tool will always execute one filter at a time, such that the user
* can implement his own scheduling by repeatedly using this tool.
* Please do not change this behavior.
*/
if (XOR(minimizeSort, maximizeSort) && argument != NULL) {
PT_Symbol sort = PT_makeSymbolCf(PT_makeSymbolSort(argument));
outputTree = minmax(inputTree, sort, minimizeSort);
}
else {
usage();
return 1;
}
if (outputTree != NULL) {
outputTree = flattenAgain(outputTree);
outputTerm = PT_ParseTreeToTerm(outputTree);
ATwriteToNamedTextFile(outputTerm, output);
}
else {
fprintf(stderr, "%s: filtering failed unexpectedly\n", myname);
return 1;
}
}
else {
fprintf(stderr,"%s: could not open file %s\n", myname, input);
return 1;
}
return 0;
}