static void initTables(void) {
var_tab = ATtableCreate(TABLESIZE,75);
if (!var_tab) ATerror("Table is not allocated");
par_tab = ATtableCreate(TABLESIZE,75);
if (!par_tab) ATerror("Table is not allocated");
}
/**
* Creates an input string from the given buffer.
*
* \param path the path to where the input string was read from
* (data is copied to private area).
* \param buf the buffer containing the input string
* (pointer is taken from the caller, and released during
* IS_destroyInputString()).
* \param length the length of the input string, excluding the end-of-string
* symbol.
* \sa IS_destroyInputString.
*
* \return the newly created input string.
*/
InputString IS_allocateString(const char *path, const unsigned char *buf, int length) {
char *pathName = strdup(path);
InputString tmp;
if (buf == NULL) {
ATerror("Cannot strdup() input string.");
return NULL;
}
if (path == NULL) {
ATerror("Cannot strdup() input string.path name");
return NULL;
}
tmp = (InputString) malloc(sizeof(struct _InputString));
if (tmp == NULL) {
ATerror("Cannot allocate memory for InputString");
return NULL;
}
tmp->path = pathName;
tmp->buffer = buf;
tmp->length = length;
tmp->index = -1;
tmp->linesRead = 1;
tmp->columnsRead = 0;
return tmp;
}
static PT_ParseTree parsetreeFromTextFile(const char *filename) {
PT_ParseTree parseResult = NULL;
InputString inputString;
FLT_setInjectionCountFlag(ATfalse);
FLT_setPreferenceCountFlag(ATfalse);
if (loadParseTable()) {
inputString = IS_createInputStringFromFile(filename);
parseResult = SGLR_parse(inputString, getParseTableID());
}
else {
ATerror("asc-main: parse table not loaded.");
}
if (parseResult != NULL) {
return parseResult;
}
else {
ATerror("asc-main: unknown error while parsing %s\n", filename);
exit(1);
}
return NULL;
}
void RWsetArguments(int *argc, char ***argv) {
int i, j=0;
char **newargv = (char**) calloc(*argc + 3, sizeof(char*));
if (!newargv) ATerror("Cannot allocate array argv");
newargv[j++] = (*argv) [0];
for(i=1; i<*argc; i++) {
if (!strcmp((*argv)[i],"-alt")) {
if ((++i)<*argc && strncmp((*argv)[i],"-",1))
{
char *code = (*argv)[i];
if (!strcmp(code,"innermost")) {
tasks = &JITTYtasks;
newargv[j++]="-innermost";
ATwarning("-alt innermost is obsolete; please use -alt jitty -innermost instead");
}
else if (!strcmp(code,"strictleft")) {
tasks = &JITTYtasks;
newargv[j++]="-strictleft";
ATwarning("-alt strictleft is obsolete; please use -alt jitty instead");
}
else if (!strcmp(code,"jitty")) {
tasks = &JITTYtasks;
}
else if (!strcmp(code,"no")) {
tasks = &SUBStasks;
}
#ifdef DYNLINK
else if (!strcmp(code,"rww")) tasks = &RWWtasks;
else if (!strcmp(code,"rw")) {
tasks = &RWtasks;
}
#endif
else if (!strcmp(code,"rww"))
ATwarning("Compiling rewriter is not available");
else
ATerror("Unknown rewriter or strategy");
continue;
}
ATerror("Option %s needs argument.\n",(*argv)[i-1]);
}
if (!strcmp((*argv)[i],"-case")) {
#ifdef DYNLINK
if (!tasks) tasks = &RWWtasks;
#endif
caseFlag = ATtrue;
#ifdef DYNLINK
if (tasks != &RWWtasks && tasks != &RWtasks) continue;
#else
continue;
#endif
}
j=MCRLcopyOption(newargv, *argv, *argc, i, j);
}
if (!tasks) {
tasks = &JITTYtasks;
}
*argc = j;
*argv = newargv;
tasks->RWsetArguments(argc, argv);
}
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)
{
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;
}
static FILE *openLog(const char *fnam) {
FILE *log = NULL;
if (!fnam || !strcmp(fnam, "")) {
ATerror("Cannot create logfile without a filename\n", fnam);
}
if (!(log = fopen(fnam, "wb"))) {
ATerror("Cannot create logfile %s\n", fnam);
}
return log;
}
/* 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 */
}
static int SDFCharacterToInt(SDF_Character sdfCharacter)
{
int result;
if (SDF_isCharacterNumeric(sdfCharacter)) {
SDF_NumChar sdfNumChar = SDF_getCharacterNumChar(sdfCharacter);
char *numchar = PT_yieldTreeToString((PT_Tree) sdfNumChar, ATfalse);
result = atoi(numchar+1); /* remove leading backslash */
}
else if (SDF_isCharacterShort(sdfCharacter)) {
SDF_ShortChar sdfShortChar = SDF_getCharacterShortChar(sdfCharacter);
char *numchar = PT_yieldTreeToString((PT_Tree) sdfShortChar, ATfalse);
if (numchar[0] != '\\') {
result = (int) numchar[0];
}
else {
result = (int) numchar[1]; /* skip backslash */
}
}
else {
ATerror("SDFCharacterToInt: unable to convert %s\n",
PT_yieldTreeToString((PT_Tree) sdfCharacter, ATfalse));
result = -1;
}
return result;
}
static PT_CharRanges SDFCharRangesToPtCharRanges(SDF_CharRanges sdfCharRanges)
{
PT_CharRanges result = PT_makeCharRangesEmpty();
if (SDF_isCharRangesDefault(sdfCharRanges)) {
SDF_CharRange sdfCharRange = SDF_getCharRangesCharRange(sdfCharRanges);
PT_CharRange ptCharRange = SDFCharRangeToPtCharRange(sdfCharRange);
result = PT_makeCharRangesMany(ptCharRange, result);
}
else if (SDF_isCharRangesConc(sdfCharRanges)) {
SDF_CharRanges sdfLeft = SDF_getCharRangesLeft(sdfCharRanges);
SDF_CharRanges sdfRight = SDF_getCharRangesRight(sdfCharRanges);
PT_CharRanges ptLeft = SDFCharRangesToPtCharRanges(sdfLeft);
PT_CharRanges ptRight = SDFCharRangesToPtCharRanges(sdfRight);
return PT_concatCharRanges(ptLeft, ptRight);
}
else {
ATerror("SDFCharRangesToPtCharRanges: unable to convert %s\n",
PT_yieldTreeToString((PT_Tree) sdfCharRanges, ATfalse));
result = NULL;
}
return result;
}
static int TB_Init(Tcl_Interp *interp)
{
global_interp = interp;
BUF = (char *)malloc(bufsize);
if(!BUF)
ATerror("Not enough space to allocate text buffer!\n");
Tcl_CreateCommand(interp, "TBsend", Tcl_TBsend, (ClientData)NULL, (Tcl_CmdDeleteProc *)NULL);
Tcl_CreateCommand(interp, "TBstring", Tcl_TBstring, NULL, NULL);
Tcl_CreateCommand(interp, "bgerror", Tcl_bgerror, NULL, NULL);
if(use_toolbus) {
/*TB_connect(cid);*/
/*toolbus_file = Tcl_GetFile((ClientData)TB_getSocket(cid), TCL_UNIX_FD);*/
Tcl_CreateFileHandler(cid, TCL_READABLE, tcl_toolbus_handler, NULL);
}
if(Tcl_EvalFile(interp, LIBDIR "/tcltk.tcl") != TCL_OK) {
interp->result = "Cannot load file " LIBDIR "/tcltk.tcl";
return TCL_ERROR;
}
Tcl_SetVar(interp, "TB_LIBDIR", LIBDIR, TCL_GLOBAL_ONLY);
return !TCL_ERROR;
}
static char* escape(const char* str, const char* escaped_chars, QuotedOption quoted)
{
int i,j,e;
int len = strlen(str);
char *escaped = (char*) malloc(2 * len * sizeof(char) + (quoted ? 2 : 0) + 1);
if (escaped == NULL) {
ATerror("escape: could not allocate enough memory for escaping:\n%s\n",str);
return NULL;
}
i = 0;
j = 0;
if (quoted == QUOTED) {
escaped[j++] = '\"';
}
for (; i < len; i++, j++) {
for (e = 0; escaped_chars[e]; e++) {
if (str[i] == escaped_chars[e]) {
escaped[j++] = '\\';
}
}
escaped[j] = str[i];
}
if (quoted == QUOTED) {
escaped[j++] = '\"';
}
escaped[j] = '\0';
return escaped;
}
void addTable(const char *name, const char * valueType)
{
int i;
if (!TS_tableExists(name)) {
for (i = 0; i < MAX_NR_OF_TABLES; i++) {
if (tableStore[i].name == NULL) {
tableStore[i].name = strdup(name);
tableStore[i].valueType = strdup(valueType);
tableStore[i].table = T_createTable();
return;
}
}
}
else {
if (!streq(tableStore[TS_findTable(name)].valueType, valueType)) {
ATabort("Table %s already exists with different value type than %s\n",
name, valueType);
}
return;
}
ATerror("addTable: table store exhausted.\n");
}
ERR_Error PERR_lowerError(PERR_Error pError)
{
PERR_StrCon pDescription = PERR_getErrorDescription(pError);
PERR_SubjectList pSubjects = PERR_getErrorList(pError);
char *description = strdup(PERR_lowerStrCon(pDescription));
ERR_SubjectList subjects = PERR_lowerSubjects(pSubjects);
ERR_Error error;
if (PERR_isErrorInfo(pError)) {
error = ERR_makeErrorInfo(description, subjects);
}
else if (PERR_isErrorWarning(pError)) {
error = ERR_makeErrorWarning(description, subjects);
}
else if (PERR_isErrorError(pError)) {
error = ERR_makeErrorError(description, subjects);
}
else if (PERR_isErrorFatal(pError)) {
error = ERR_makeErrorFatal(description, subjects);
}
else {
ATerror("unknown error type: %t\n", pError);
error = NULL;
}
free(description);
return error;
}
void init_first() {
max_first_sets = 512;
first_sets = (CC_Class **)calloc(max_first_sets, sizeof(CC_Class *));
if (!first_sets) {
ATerror("out of memory in CC_init (2) %d\n", max_first_sets);
}
}
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 SG_initMarks(void)
{
marks = ATindexedSetCreate(INITIAL_TABLE_SIZE, LOAD_PERCENTAGE);
if (marks == NULL) {
ATerror("SG_initMarks: unable to allocate table for marking.");
}
}
void CAESAR_INIT_GRAPH(void) {
int argc;
char **argv;
char *FILENAME;
char *OPTIONS;
char *token;
ATinitialize(0,NULL);
ATsetWarningHandler(WarningHandler);
ATsetErrorHandler(ErrorHandler);
/* ATwarning ("Executing CAESAR_INIT_GRAPH"); */
FILENAME = getenv ("OPEN_CAESAR_FILE");
if (FILENAME == NULL)
CAESAR_ERROR ("undefined environment variable $OPEN_CAESAR_FILE");
OPTIONS = getenv ("MCRL_OPTIONS");
if (OPTIONS == NULL)
CAESAR_ERROR ("undefined environment variable $MCRL_OPTIONS");
#define MAX_OPTIONS 100
argv = (char**)calloc(MAX_OPTIONS,sizeof(char*));
argc = 0;
argv[argc] = "mcrl_open";
// ATwarning ("%d -> \"%s\"\n", argc, argv [argc]);
argc ++;
/* skip leading white spaces */
while (*OPTIONS == ' ') OPTIONS++;
token = strtok (OPTIONS, " ");
while (1) {
if (token == NULL) break;
argv [argc] = token;
// ATwarning ("%d -> \"%s\"\n", argc, argv [argc]);
argc ++;
token = strtok ((char *) NULL, " ");
}
argv [argc] = FILENAME;
// ATwarning ("%d -> \"%s\"\n", argc, argv [argc]);
argc ++;
MCRLsetArguments(&argc, &argv);
RWsetArguments(&argc,&argv);
if (!MCRLinitialize())
ATerror("%s cannot be opened\n",FILENAME);
ATwarning("Opened %s",FILENAME);
RWinitialize(MCRLgetAdt());
LTSsetArguments(&argc,&argv);
LTSinitialize(wrap_call_back);
Label_set = ATindexedSetCreate(1024,75);
/* ATwarning ("Leaving CAESAR_INIT_GRAPH"); */
}
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 PT_ParseTree parsetreeFromATermFile(const char *filename) {
ATerm term = NULL;
term = ATreadFromNamedFile(filename);
if (term != NULL && ATmatch(term, "parsetree(<term>,<int>)", NULL, NULL)) {
return PT_ParseTreeFromTerm(term);
}
ATerror("asc-main: can not read parse tree from file %s\n", filename);
return NULL;
}
ATerm hello_handler(int conn, ATerm inp) /* Handle input from ToolBus */
{ ATerm arg, isig, osig;
if(ATmatch(inp, "rec-eval(get-text)"))
return ATmake("snd-value(text(\"Hello World, my first ToolBus tool in C!\n\"))");
if(ATmatch(inp, "rec-terminate(<term>)", &arg))
exit(0);
if(ATmatch(inp, "rec-do(signature(<term>,<term>))", &isig, &osig)){
return NULL; /* we don't do a signature check */
}
ATerror("hello: wrong input %t received\n", inp);
return NULL;
}
ATerm printer_handler(int conn, ATerm e)
{
char *text;
ATerm arg;
if(ATmatch(e, "rec-do(print-text(<str>))", &text)){
ATprintf("%s", text);
return NULL;
} else
if(ATmatch(e, "rec-terminate(<term>)", &arg)){
exit(0);
} else {
ATerror("printer: wrong event received: %t\n", e);
return NULL;
}
}
static PT_Tree addBoxToTextFunction(PT_ParseTree parseTree)
{
PT_Tree newTree = NULL;
if (PT_isValidParseTree(parseTree))
{
PT_Tree ptBox = PT_getParseTreeTree(parseTree);
newTree = PT_applyFunctionToTree("box2text", "Text", 1, ptBox);
}
else
{
ATerror("addBoxToTextFunction: not a proper parse tree: %t\n",
(ATerm) parseTree);
return (PT_Tree) NULL;
}
return newTree;
}
static void DisabledEdges(ATermList gs) {
ATermList smds = MCRLgetListOfSummands(),
pars = MCRLgetListOfPars();
int false_cnt = 0, true_cnt = 0, n = ATgetLength(smds);
static int k = 1;
SubstituteInPars(pars, gs);
for (;!ATisEmpty(smds);smds=ATgetNext(smds)) {
ATerm smd = ATgetFirst(smds),
c = ATgetArgument((ATermAppl) smd,4),
cw = NULL;
if (!ATisEmpty((ATermList) ATgetArgument((ATermAppl) smd, 0)))
ATerror("Flag -extra is used while sum variables occur");
cw = RWrewrite(c);
if (
ATisEqual(cw, MCRLterm_false)) false_cnt++;
if (
ATisEqual(cw, MCRLterm_true)) true_cnt++;
}
fprintf(stdout, "Summand %d N = %d disabled %d enabled %d\n",
k++, n, false_cnt, true_cnt);
}
CC_Class *get_first_set(PT_Symbol symbol, ATbool create) {
long index;
int old_size;
/* Associate a unique integer with a symbol. */
index = internSymbol(symbol);
if (index >= max_first_sets) {
old_size = max_first_sets;
max_first_sets *= 2;
first_sets = (CC_Class **)realloc(first_sets, max_first_sets*sizeof(CC_Class *));
if (!first_sets) {
ATerror("out of memory in get_first_set %d\n", max_first_sets);
}
memset(&first_sets[old_size], 0, old_size*sizeof(CC_Class *));
}
if (create && first_sets[index] == NULL) {
first_sets[index] = CC_makeClassEmpty();
}
return first_sets[index];
}
static PT_CharRanges SDFCharClassToPtCharRanges(SDF_CharClass sdfCharClass)
{
PT_CharRanges result;
if (SDF_isCharClassSimpleCharclass(sdfCharClass)) {
SDF_OptCharRanges sdfOCR = SDF_getCharClassOptCharRanges(sdfCharClass);
if (SDF_isOptCharRangesAbsent(sdfOCR)) {
result = PT_makeCharRangesEmpty();
}
else {
SDF_CharRanges sdfCharRanges = SDF_getOptCharRangesCharRanges(sdfOCR);
result = SDFCharRangesToPtCharRanges(sdfCharRanges);
}
}
else {
ATerror("SDFCharClassToPtCharRanges: unable to convert characterclass: %s\n",
PT_yieldTreeToString((PT_Tree) sdfCharClass, ATfalse));
result = NULL;
}
return result;
}
static PT_Tree addEqsSyntaxFunction(const char *name, PT_ParseTree parseTree)
{
SDF_ModuleName sdfModuleName = SDF_makeModuleName(name);
PT_Tree ptModuleName = PT_TreeFromTerm(SDF_ModuleNameToTerm(sdfModuleName));
PT_Tree newTree = NULL;
if (PT_isValidParseTree(parseTree)) {
PT_Tree ptSyntax = PT_getParseTreeTree(parseTree);
newTree = PT_applyFunctionToTree("add-equation-module",
"SDF",
2,
ptModuleName,
ptSyntax);
}
else {
ATerror("add_eqs_syntax: not a proper parse tree: %t\n", (ATerm) parseTree);
return (PT_Tree) NULL;
}
return newTree;
}
/* Event handler for tool 'sdfchecker' */
ATerm sdfchecker_handler(int conn, ATerm term)
{
ATerm in, out;
/* We need some temporary variables during matching */
ATerm t0;
if(ATmatch(term, "rec-eval(check-sdf(<term>))", &t0)) {
return check_sdf(conn, 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 = sdfchecker_checker(conn, in);
if(!ATmatch(result, "[]"))
ATfprintf(stderr, "warning: not in input signature:\n\t%\n\tl\n", result);
return NULL;
}
ATerror("tool sdfchecker cannot handle term %t", term);
return NULL; /* Silence the compiler */
}
