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;
}
int intCompare(const ATerm aVal1, const ATerm aVal2)
{
int x, y;
x = ATgetInt((ATermInt)aVal1); y = ATgetInt((ATermInt)aVal2);
if(x < y) return -1;
if(x > y) return 1;
return 0;
}
ATermInt ATR_average(ATSet set) {
int sum = ATgetInt(ATR_sum(set));
int count = ATgetInt(ATR_cardinality(set));
int avg = 0;
if (count > 0) {
avg = sum/count;
}
return ATmakeInt(avg);
}
static void writeInteger(A2PWriter writer, ATermInt integer){
int intValue = ATgetInt(integer);
writeByteToBuffer(writer->buffer, PDB_INTEGER_HEADER);
printInteger(writer->buffer, intValue);
}
/* For all non-terminals which are to the right of the dot in |item|, add
* that non-terminal's items to the set of |items| if they do not already
* exist. Note that only items that do not cause a priority conflict are
* added to the predicted items. */
static ATermList predict(Item item, ATermList items) {
int prodnr;
PT_Symbol dotsymbol;
ATermList prods;
if (IT_isValidItem(item)) {
dotsymbol = (PT_Symbol)IT_getDotSymbol(item);
if (!PT_isSymbolEmpty(dotsymbol)) {
prods = PGEN_getProductionNumbersOfRhsNonTerminal(dotsymbol);
if (prods) {
while (!ATisEmpty(prods)) {
/*ATwarning("prods = %t\n", prods);*/
prodnr = ATgetInt((ATermInt)ATgetFirst(prods));
prods = ATgetNext(prods);
if (!PGEN_isPriorityConflict(item, prodnr)) {
Item newitem = IT_createItem(prodnr);
items = ATinsert(items, IT_ItemToTerm(newitem));
}
}
}
}
}
return items;
}
ATerm SSL_setenv(ATerm name, ATerm value, ATerm overwrite)
{
if(!t_is_string(name)) _fail(name);
if(!t_is_string(value)) _fail(value);
if(!ATisInt(overwrite)) _fail(overwrite);
setenv(ATgetName(ATgetSymbol(name)), ATgetName(ATgetSymbol(value)), ATgetInt((ATermInt)overwrite));
return (ATerm)ATempty;
}
ATRelation ATR_transitiveClosure(ATRelation relation) {
int i;
ATRelation cursor = relation;
ATRelation closure = relation;
for (i = 0; i < ATgetInt(ATR_cardinality(relation)) - 1; i++) {
cursor = ATR_compose(cursor, relation);
closure = ATR_union(closure, cursor);
}
return closure;
}
ATermInt ATR_sum(ATSet set) {
ATIterator iter = ATR_getIterator(set);
int n = 0;
while (!ATR_isEmpty(iter)) {
ATerm head = ATR_getHead(iter);
check_type_is_int_else_abort(head, "ATR_sum");
n += ATgetInt(((ATermInt)head));
iter = ATR_getTail(iter);
}
return ATmakeInt(n);
}
ATermInt ATR_max(ATSet set) {
ATIterator iter = ATR_getIterator(set);
int max = 0;
int n = 0;
while (!ATR_isEmpty(iter)) {
ATerm head = ATR_getHead(iter);
check_type_is_int_else_abort(head, "ATR_max");
n = ATgetInt(((ATermInt)head));
max = max > n ? max : n;
iter = ATR_getTail(iter);
}
return ATmakeInt(max);
}
/* The compare function creates a sorted tree, so an in-order walk should
* return the same set of values in increasing order */
void test_walk(ATermBBTree tree, const int *pValues)
{
ATermBBTreeIterator iter;
int i;
iter = ATbbtreeIteratorInit(tree);
while(!ATbbtreeIteratorAtEnd(iter) && *pValues) {
i = ATgetInt((ATermInt)ATbbtreeIteratorValue(iter));
assert(i == *pValues);
iter = ATbbtreeIteratorAdvance(iter); ++pValues;
}
/* they should both end at the same time */
assert(ATbbtreeIteratorAtEnd(iter));
assert(! *pValues);
}
ATermList filter_multiples(int n, ATermList numbers)
{
int i, nr, len = ATgetLength(numbers);
ATerm el;
for(i=0; i<len; i++) {
el = ATelementAt(numbers, i);
nr = ATgetInt((ATermInt)el);
if(nr % n == 0) {
len--;
numbers = ATremoveElementAt(numbers, i);
}
}
return numbers;
}
ATermInt ATR_min(ATSet set) {
ATIterator iter = ATR_getIterator(set);
int min = INT_MAX;
int n = 0;
while (!ATR_isEmpty(iter)) {
ATerm head = ATR_getHead(iter);
check_type_is_int_else_abort(head, "ATR_min");
n = ATgetInt(((ATermInt)head));
min = min < n ? min : n;
iter = ATR_getTail(iter);
}
if (min == INT_MAX) {
min = 0;
}
return ATmakeInt(min);
}
int HFdecodeIndex(BitStream *fp, HFtree *tree, long *index){
Bit bit;
struct HFnode *current;
ATerm term;
current=tree->codes;
while(current!=NULL){
if(current->high==NULL && current->low==NULL){
term=current->term;
if(term==ESCAPE_SEQUENCE){
/* OEPS
HFupdate(tree,current);
*/
if(LZreadInt(fp,&tree->buffer,index)){
term=(ATerm)ATmakeInt(*index);
current=HFadd(tree,term);
HFupdate(tree,current);
return *index!=NO_INT;
} else {
return 0;
}
} else {
HFupdate(tree,current);
*index=ATgetInt((ATermInt)term);
return *index!=NO_INT;
}
} else {
if(BSreadBit(fp, &bit)==1){
if(bit==0){
current = current->low;
} else {
current = current->high;
}
} else {
return 0;
}
}
}
return 1;
}
ATermList filter_non_primes(ATermList numbers)
{
ATermList primes = ATmakeList0();
/* Skip 1, we dont want to filter that! */
numbers = ATgetNext(numbers);
while(!ATisEmpty(numbers)) {
/* The first number must be prime. remove it from numbers. */
ATerm prime = ATgetFirst(numbers);
/* Remove all multiples of n, because they cannot be prime! */
numbers = filter_multiples(ATgetInt((ATermInt)prime), numbers);
/*ATprintf("%d numbers.\n", ATgetLength(numbers));*/
/* Now add n to the list of primes */
primes = ATappend(primes, prime);
}
return (ATermList)ATmake("[1,<list>]", primes);
}
static ATerm substitute_rec(ATerm t, ATermSubst sigma, ATbool *nonempty) {
/* invariants:
- Subst contains pairs (r , r^sigma)
- *nonempty iff Subst is not empty
*/
ATerm s;
if (ATisVariable(t)) {
s=ATstackGet(sigma,ATgetInt((ATermInt)t));
return (s ? s : t);
}
else if (*nonempty && (s=ATtableGet(Subst,t)))
return s;
else {
Symbol sym = ATgetSymbol(t);
int i,n=ATgetArity(sym);
ATerm* args = (ATerm*)alloca(n*sizeof(ATerm));
for (i=0;i<n;i++)
args[i]=substitute_rec(ATgetArgument(t,i),sigma,nonempty);
s = (ATerm)ATmakeApplArray(sym,args);
*nonempty=ATtrue;
ATtablePut(Subst,t,s);
return s;
} }
unsigned int calc_hash(ATerm t)
{
unsigned int hnr = 0;
switch(ATgetType(t)) {
case AT_APPL:
{
ATermAppl appl = (ATermAppl)t;
AFun sym = ATgetAFun(appl);
int i, arity = ATgetArity(sym);
hnr = AT_hashSymbol(ATgetName(sym), arity);
for(i=0; i<arity; i++) {
hnr = hnr * MAGIC_HASH_CONST_APPL + calc_hash(ATgetArgument(appl, i));
}
}
break;
case AT_INT:
hnr = ATgetInt((ATermInt)t);
break;
case AT_LIST:
{
ATermList list = (ATermList)t;
hnr = 123;
while(!ATisEmpty(list)) {
hnr = hnr * MAGIC_HASH_CONST_LIST +
calc_hash(ATgetFirst(list));
list = ATgetNext(list);
}
}
break;
}
return hnr;
}
static char unfold_solution(ATermSubst sigma) {
/* - makes assigned, solution and equivalence empty
- doesn't alter equivalence, except shortening find paths
- returns 1: unifiable; sigma contains solution (except when NULL)
- returns 0: not unifiable; sigma is empty
Note: unfolding is also needed if sigma=NULL to detect loops.
*/
int i;
ATerm t;
char unifiable=1;
static char first_call=1;
if (first_call) {
first_call = 0;
loop_detection=ATindexedSetCreate(64,50);
solution = ATtableCreate(64,50);
}
assert(ATisEmpty(ATtableKeys(solution)));
for (i=ATstackDepth(assigned)-1;i>=0;i--) {
ATerm x = ATstackPop(assigned);
assert(ATisEmpty(ATindexedSetElements(loop_detection)));
t = unfold_rec(find(x));
if (t && sigma)
ATstackSet(sigma,ATgetInt((ATermInt)x),t);
else {
unifiable=0;
break;
} }
ATtableReset(solution);
ATtableReset(equivalence);
if (unifiable)
return ATtrue;
else {
ATstackReset(assigned);
if (sigma) ATstackReset(sigma);
return ATfalse;
} }
static void term2buf(ATerm t)
{
ATerm annos = AT_getAnnotations(t);
if(annos != NULL) {
char2buf('{');
}
switch(ATgetType(t)) {
case AT_INT:
wprintf("%d", ATgetInt((ATermInt)t));
break;
case AT_REAL:
wprintf("%f", ATgetReal((ATermReal)t));
break;
case AT_APPL:
{
int cur_arg, arity;
ATermAppl appl = (ATermAppl)t;
AFun sym = ATgetSymbol(appl);
if(ATisQuoted(sym))
qstr2buf(ATgetName(sym));
else
str2buf(ATgetName(sym));
arity = ATgetArity(sym);
if(arity > 0) {
char2buf('(');
for(cur_arg=0; cur_arg<arity; cur_arg++) {
term2buf(ATgetArgument(appl, cur_arg));
if(cur_arg < (arity-1))
char2buf(',');
}
char2buf(')');
}
}
break;
case AT_LIST:
{
ATermList l = (ATermList)t;
char2buf('{');
while(!ATisEmpty(l)) {
ATerm el = ATgetFirst(l);
l = ATgetNext(l);
term2buf(el);
if(!ATisEmpty(l))
char2buf(' ');
}
char2buf('}');
}
break;
case AT_PLACEHOLDER:
{
char2buf('<');
term2buf(ATgetPlaceholder((ATermPlaceholder)t));
char2buf('>');
}
break;
case AT_BLOB:
ATerror("blobs are not supported by tcltk-adapter!\n");
default:
ATabort("illegal term type!\n");
}
if(annos != NULL) {
char2buf(' ');
term2buf(annos);
char2buf('}');
}
}
int SG_Batch (int argc, char **argv)
{
ATerm parse_tree;
parse_tree = SGparseFileUsingTable(program_name,
parse_table_name,
start_symbol,
input_file_name,
output_file_name);
if (!SG_OUTPUT) {
return 0;
}
if (!parse_tree) {
ATwarning("%s: error in %s: unexpected error\n",
program_name, input_file_name);
return 2;
}
if (SGisParseError(parse_tree)) {
ATermList errlist;
ATerm errcode;
AFun err;
int c, line, col;
errlist = (ATermList) ATgetArgument((ATermAppl) parse_tree, 0);
errcode = ATgetArgument((ATermAppl) parse_tree, 1);
c = ATgetInt((ATermInt) ATgetArgument(ATelementAt(errlist, 0), 0));
line = ATgetInt((ATermInt) ATgetArgument(ATelementAt(errlist, 1), 0));
col = ATgetInt((ATermInt) ATgetArgument(ATelementAt(errlist, 2), 0));
err = ATgetAFun(errcode);
if (err == SG_EOF_Error_AFun) {
ATwarning("%s: error in %s, line %d, col %d: end of file unexpected\n",
program_name, input_file_name, line, col);
}
else if (err == SG_Plain_Error_AFun) {
if (isprint(c)) {
ATwarning("%s: error in %s, line %d, col %d: character `%c' (\\x%2.2x)"
" unexpected\n",
program_name, input_file_name, line, col, c, c);
}
else {
ATwarning("%s: error in %s, line %d, col %d: character \\x%2.2x"
" unexpected\n",
program_name, input_file_name, line, col, c);
}
}
else if (err == SG_Cycle_Error_AFun) {
ATwarning("%s: error in %s, line %d, col %d: cycle detected, productions: %t\n",
program_name,
input_file_name,
line,
col,
ATgetArgument(errcode, 0));
}
else if (err == SG_Amb_Error_AFun) {
int ambiescount = ATgetInt((ATermInt) ATgetArgument(errcode,0));
ATwarning("%s: error in %s, line %d, col %d: cannot represent %d ambiguit%s\n",
program_name,
input_file_name,
line,
col,
ambiescount,
(ambiescount > 1) ? "ies" : "y" );
}
else if (err == SG_Too_Many_Ambiguities_Error_AFun) {
ATwarning("%s: error in %s, line %d, col %d: too many ambiguities\n",
program_name, input_file_name, line, col);
}
else {
ATwarning("%s: error in %s, line %d, col %d: unknown error\n",
program_name, input_file_name, line, col);
}
return 1;
}
else if(!SGisParseTree(parse_tree)) {
ATwarning("%s: error: neither parse tree nor parse error for %s\n",
program_name, input_file_name);
return 1;
}
IF_VERBOSE(
int nrambs;
char *sort;
nrambs = SGnrAmb(SG_NR_ASK);
sort = SGsort(SG_GET, NULL);
ATwarning("%s: %s parsed %s as sort %s, with %d ambiguit%s\n",
program_name, parse_table_name, input_file_name,
sort ? sort : "[undetermined]",
nrambs, (nrambs==1)?"y":"ies");
);
