public inbox for gcc-prs@sourceware.org
help / color / mirror / Atom feed
* Re: c/4014: gcc reports internal erro when compiling file bafio.c
@ 2001-12-07 17:32 rodrigc
  0 siblings, 0 replies; 4+ messages in thread
From: rodrigc @ 2001-12-07 17:32 UTC (permalink / raw)
  To: gcc-bugs, gcc-gnats, gcc-prs, nobody, rodrigc, visser

Synopsis: gcc reports internal erro when compiling file bafio.c

State-Changed-From-To: open->analyzed
State-Changed-By: rodrigc
State-Changed-When: Fri Dec  7 17:32:56 2001
State-Changed-Why:
    Reproduced in gcc 3.0.3.
    The compiler segfaults here:
    Program received signal SIGSEGV, Segmentation fault.
    0x082933cd in make_reorder_chain_1 (bb=0x841a1d0, prev=0x841a110)
        at bb-reorder.c:416
    416           next = (taken ? e_taken : e_fall)->dest;
    
    
    
    
    In gcc 3.1, the compiler does not segfault but produces
    these compilation errors:
    bafio.c: In function `ATwriteToNamedBinaryFile':
    bafio.c:1215: parse error before "u"
    bafio.c:1216: parse error before ')' token
    bafio.c:1216: `cons' undeclared (first use in this function)
    bafio.c:1216: (Each undeclared identifier is reported only once
    bafio.c:1216: for each function it appears in.)
    bafio.c:1216: parse error before '!' token
    bafio.c:1217: syntax error before '!' token
    bafio.c:1218: `__result' undeclared (first use in this function)

http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&pr=4014&database=gcc


^ permalink raw reply	[flat|nested] 4+ messages in thread

* Re: c/4014: gcc reports internal erro when compiling file bafio.c
@ 2002-03-06 19:54 rodrigc
  0 siblings, 0 replies; 4+ messages in thread
From: rodrigc @ 2002-03-06 19:54 UTC (permalink / raw)
  To: gcc-bugs, gcc-prs, nobody, rodrigc, otto, reichelt, visser

Synopsis: gcc reports internal erro when compiling file bafio.c

State-Changed-From-To: analyzed->closed
State-Changed-By: rodrigc
State-Changed-When: Wed Mar  6 19:54:55 2002
State-Changed-Why:
    ICE reproduced with gcc 3.0.4.
    
    With gcc version 3.1 20020302 (prerelease),
    there are compilation errors:
    
    bafio.c: In function `ATwriteToNamedBinaryFile':
    bafio.c:1215: parse error before "u"
    bafio.c:1216: parse error before ')' token
    bafio.c:1216: `cons' undeclared (first use in this function)
    bafio.c:1216: (Each undeclared identifier is reported only once
    bafio.c:1216: for each function it appears in.)
    bafio.c:1216: parse error before '!' token
    bafio.c:1217: syntax error before '!' token
    bafio.c:1218: `__result' undeclared (first use in this function)
    

http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gcc&pr=4014


^ permalink raw reply	[flat|nested] 4+ messages in thread

* Re: c/4014: gcc reports internal erro when compiling file bafio.c
@ 2001-12-07 17:36 rodrigc
  0 siblings, 0 replies; 4+ messages in thread
From: rodrigc @ 2001-12-07 17:36 UTC (permalink / raw)
  To: nobody; +Cc: gcc-prs

The following reply was made to PR c/4014; it has been noted by GNATS.

From: rodrigc@gcc.gnu.org
To: gcc-bugs@gcc.gnu.org, gcc-gnats@gcc.gnu.org, gcc-prs@gcc.gnu.org,
  nobody@gcc.gnu.org, rodrigc@gcc.gnu.org, visser@cs.uu.nl
Cc:  
Subject: Re: c/4014: gcc reports internal erro when compiling file bafio.c
Date: 8 Dec 2001 01:32:56 -0000

 Synopsis: gcc reports internal erro when compiling file bafio.c
 
 State-Changed-From-To: open->analyzed
 State-Changed-By: rodrigc
 State-Changed-When: Fri Dec  7 17:32:56 2001
 State-Changed-Why:
     Reproduced in gcc 3.0.3.
     The compiler segfaults here:
     Program received signal SIGSEGV, Segmentation fault.
     0x082933cd in make_reorder_chain_1 (bb=0x841a1d0, prev=0x841a110)
         at bb-reorder.c:416
     416           next = (taken ? e_taken : e_fall)->dest;
     
     
     
     
     In gcc 3.1, the compiler does not segfault but produces
     these compilation errors:
     bafio.c: In function `ATwriteToNamedBinaryFile':
     bafio.c:1215: parse error before "u"
     bafio.c:1216: parse error before ')' token
     bafio.c:1216: `cons' undeclared (first use in this function)
     bafio.c:1216: (Each undeclared identifier is reported only once
     bafio.c:1216: for each function it appears in.)
     bafio.c:1216: parse error before '!' token
     bafio.c:1217: syntax error before '!' token
     bafio.c:1218: `__result' undeclared (first use in this function)
 
 http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&pr=4014&database=gcc


^ permalink raw reply	[flat|nested] 4+ messages in thread

* c/4014: gcc reports internal erro when compiling file bafio.c
@ 2001-08-13  4:16 visser
  0 siblings, 0 replies; 4+ messages in thread
From: visser @ 2001-08-13  4:16 UTC (permalink / raw)
  To: gcc-gnats

>Number:         4014
>Category:       c
>Synopsis:       gcc reports internal erro when compiling file bafio.c
>Confidential:   no
>Severity:       critical
>Priority:       medium
>Responsible:    unassigned
>State:          open
>Class:          ice-on-legal-code
>Submitter-Id:   net
>Arrival-Date:   Mon Aug 13 04:16:03 PDT 2001
>Closed-Date:
>Last-Modified:
>Originator:     Eelco Visser
>Release:        3.0
>Organization:
Utrecht University
>Environment:
System: Linux node11794.a2000.nl 2.2.17-8 #1 Fri Nov 17 16:22:25 EST 2000 i686 unknown
Architecture: i686

	
host: i686-pc-linux-gnu
build: i686-pc-linux-gnu
target: i686-pc-linux-gnu
configured with: ../gcc-3.0/configure --prefix=/usr/local
>Description:
	gcc chokes when compiling the file bafio.c

gcc    -Wall -O4    -DPACKAGE=\"aterm\" -DVERSION=\"1.5.3\" -DHAVE_STRDUP=1 -DHAVE_LIBDL=1 -DHAVE_LRAND48=1 -DHAVE_SRAND48=1  -I. -I.  -DNDEBUG       -save-temps -c bafio.c -o bafio-gcc.o
bafio.c: In function `write_baf':
bafio.c:1149: Internal error: Segmentation fault
Please submit a full bug report,
with preprocessed source if appropriate.
See <URL: http://www.gnu.org/software/gcc/bugs.html > for instructions.
gmake: *** [bafio-gcc.o] Error 1     


>How-To-Repeat:

command:

gcc    -Wall -O4    -DPACKAGE=\"aterm\" -DVERSION=\"1.5.3\" -DHAVE_STRDUP=1 -DHAVE_LIBDL=1 -DHAVE_LRAND48=1 -DHAVE_SRAND48=1  -I. -I.  -DNDEBUG       -save-temps -c bafio.c -o bafio-gcc.o

file (bafio.i):
	
# 3 "bafio.c"
# 1 "/usr/include/stdio.h" 1 3
# 27 "/usr/include/stdio.h" 3
# 1 "/usr/include/features.h" 1 3
# 283 "/usr/include/features.h" 3
# 1 "/usr/include/sys/cdefs.h" 1 3
# 284 "/usr/include/features.h" 2 3
# 311 "/usr/include/features.h" 3
# 1 "/usr/include/gnu/stubs.h" 1 3
# 312 "/usr/include/features.h" 2 3
# 28 "/usr/include/stdio.h" 2 3





# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/stddef.h" 1 3
# 199 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/stddef.h" 3
typedef unsigned int size_t;
# 34 "/usr/include/stdio.h" 2 3




# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/stdarg.h" 1 3
# 43 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/stdarg.h" 3
typedef __builtin_va_list __gnuc_va_list;
# 39 "/usr/include/stdio.h" 2 3

# 1 "/usr/include/bits/types.h" 1 3
# 26 "/usr/include/bits/types.h" 3
# 1 "/usr/include/features.h" 1 3
# 27 "/usr/include/bits/types.h" 2 3


# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/stddef.h" 1 3
# 30 "/usr/include/bits/types.h" 2 3


typedef unsigned char __u_char;
typedef unsigned short __u_short;
typedef unsigned int __u_int;
typedef unsigned long __u_long;

__extension__ typedef unsigned long long int __u_quad_t;
__extension__ typedef long long int __quad_t;
# 49 "/usr/include/bits/types.h" 3
typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;

__extension__ typedef signed long long int __int64_t;
__extension__ typedef unsigned long long int __uint64_t;

typedef __quad_t *__qaddr_t;

typedef __u_quad_t __dev_t;
typedef __u_int __uid_t;
typedef __u_int __gid_t;
typedef __u_long __ino_t;
typedef __u_int __mode_t;
typedef __u_int __nlink_t;
typedef long int __off_t;
typedef __quad_t __loff_t;
typedef int __pid_t;
typedef int __ssize_t;
typedef __u_long __rlim_t;
typedef __u_quad_t __rlim64_t;
typedef __u_int __id_t;

typedef struct
  {
    int __val[2];
  } __fsid_t;


typedef int __daddr_t;
typedef char *__caddr_t;
typedef long int __time_t;
typedef unsigned int __useconds_t;
typedef long int __suseconds_t;
typedef long int __swblk_t;

typedef long int __clock_t;


typedef int __clockid_t;


typedef int __timer_t;



typedef unsigned long int __fd_mask;
# 109 "/usr/include/bits/types.h" 3
typedef struct
  {






    __fd_mask __fds_bits[1024 / (8 * sizeof (__fd_mask))];


  } __fd_set;


typedef int __key_t;


typedef unsigned short int __ipc_pid_t;



typedef long int __blksize_t;




typedef long int __blkcnt_t;
typedef __quad_t __blkcnt64_t;


typedef __u_long __fsblkcnt_t;
typedef __u_quad_t __fsblkcnt64_t;


typedef __u_long __fsfilcnt_t;
typedef __u_quad_t __fsfilcnt64_t;


typedef __u_quad_t __ino64_t;


typedef __loff_t __off64_t;


typedef long int __t_scalar_t;
typedef unsigned long int __t_uscalar_t;


typedef int __intptr_t;


typedef unsigned int __socklen_t;




# 1 "/usr/include/bits/pthreadtypes.h" 1 3
# 23 "/usr/include/bits/pthreadtypes.h" 3
# 1 "/usr/include/bits/sched.h" 1 3
# 68 "/usr/include/bits/sched.h" 3
struct __sched_param
  {
    int sched_priority;
  };
# 24 "/usr/include/bits/pthreadtypes.h" 2 3


struct _pthread_fastlock
{
  long int __status;
  int __spinlock;

};



typedef struct _pthread_descr_struct *_pthread_descr;





typedef struct
{
  int __detachstate;
  int __schedpolicy;
  struct __sched_param __schedparam;
  int __inheritsched;
  int __scope;
  size_t __guardsize;
  int __stackaddr_set;
  void *__stackaddr;
  size_t __stacksize;
} pthread_attr_t;



typedef struct
{
  struct _pthread_fastlock __c_lock;
  _pthread_descr __c_waiting;
} pthread_cond_t;



typedef struct
{
  int __dummy;
} pthread_condattr_t;


typedef unsigned int pthread_key_t;





typedef struct
{
  int __m_reserved;
  int __m_count;
  _pthread_descr __m_owner;
  int __m_kind;
  struct _pthread_fastlock __m_lock;
} pthread_mutex_t;



typedef struct
{
  int __mutexkind;
} pthread_mutexattr_t;



typedef int pthread_once_t;
# 140 "/usr/include/bits/pthreadtypes.h" 3
typedef unsigned long int pthread_t;
# 166 "/usr/include/bits/types.h" 2 3
# 41 "/usr/include/stdio.h" 2 3
# 49 "/usr/include/stdio.h" 3
typedef struct _IO_FILE FILE;
# 59 "/usr/include/stdio.h" 3
typedef struct _IO_FILE __FILE;
# 69 "/usr/include/stdio.h" 3
# 1 "/usr/include/libio.h" 1 3
# 30 "/usr/include/libio.h" 3
# 1 "/usr/include/_G_config.h" 1 3
# 9 "/usr/include/_G_config.h" 3
# 1 "/usr/include/bits/types.h" 1 3
# 10 "/usr/include/_G_config.h" 2 3




# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/stddef.h" 1 3
# 287 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/stddef.h" 3
typedef long int wchar_t;
# 312 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/stddef.h" 3
typedef unsigned int wint_t;
# 15 "/usr/include/_G_config.h" 2 3
# 24 "/usr/include/_G_config.h" 3
# 1 "/usr/include/wchar.h" 1 3
# 45 "/usr/include/wchar.h" 3
# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/stddef.h" 1 3
# 46 "/usr/include/wchar.h" 2 3

# 1 "/usr/include/bits/wchar.h" 1 3
# 48 "/usr/include/wchar.h" 2 3
# 64 "/usr/include/wchar.h" 3
typedef struct
{
  int __count;
  union
  {
    wint_t __wch;
    char __wchb[4];
  } __value;
} __mbstate_t;
# 25 "/usr/include/_G_config.h" 2 3

typedef struct
{
  __off_t __pos;
  __mbstate_t __state;
} _G_fpos_t;
typedef struct
{
  __off64_t __pos;
  __mbstate_t __state;
} _G_fpos64_t;
# 44 "/usr/include/_G_config.h" 3
# 1 "/usr/include/gconv.h" 1 3
# 26 "/usr/include/gconv.h" 3
# 1 "/usr/include/features.h" 1 3
# 27 "/usr/include/gconv.h" 2 3

# 1 "/usr/include/wchar.h" 1 3
# 45 "/usr/include/wchar.h" 3
# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/stddef.h" 1 3
# 46 "/usr/include/wchar.h" 2 3

# 1 "/usr/include/bits/wchar.h" 1 3
# 48 "/usr/include/wchar.h" 2 3
# 29 "/usr/include/gconv.h" 2 3

# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/stddef.h" 1 3
# 31 "/usr/include/gconv.h" 2 3





enum
{
  __GCONV_OK = 0,
  __GCONV_NOCONV,
  __GCONV_NODB,
  __GCONV_NOMEM,

  __GCONV_EMPTY_INPUT,
  __GCONV_FULL_OUTPUT,
  __GCONV_ILLEGAL_INPUT,
  __GCONV_INCOMPLETE_INPUT,

  __GCONV_ILLEGAL_DESCRIPTOR,
  __GCONV_INTERNAL_ERROR
};



enum
{
  __GCONV_IS_LAST = 0x0001,
  __GCONV_IGNORE_ERRORS = 0x0002
};



struct __gconv_step;
struct __gconv_step_data;
struct __gconv_loaded_object;
struct __gconv_trans_data;



typedef int (*__gconv_fct) (struct __gconv_step *, struct __gconv_step_data *,
                            __const unsigned char **, __const unsigned char *,
                            unsigned char **, size_t *, int, int);


typedef int (*__gconv_init_fct) (struct __gconv_step *);
typedef void (*__gconv_end_fct) (struct __gconv_step *);



typedef int (*__gconv_trans_fct) (struct __gconv_step *,
                                  struct __gconv_step_data *, void *,
                                  __const unsigned char *,
                                  __const unsigned char **,
                                  __const unsigned char *, unsigned char **,
                                  size_t *);


typedef int (*__gconv_trans_context_fct) (void *, __const unsigned char *,
                                          __const unsigned char *,
                                          unsigned char *, unsigned char *);


typedef int (*__gconv_trans_query_fct) (__const char *, __const char ***,
                                        size_t *);


typedef int (*__gconv_trans_init_fct) (void **, const char *);
typedef void (*__gconv_trans_end_fct) (void *);

struct __gconv_trans_data
{

  __gconv_trans_fct __trans_fct;
  __gconv_trans_context_fct __trans_context_fct;
  __gconv_trans_end_fct __trans_end_fct;
  void *__data;
  struct __gconv_trans_data *__next;
};



struct __gconv_step
{
  struct __gconv_loaded_object *__shlib_handle;
  __const char *__modname;

  int __counter;

  __const char *__from_name;
  __const char *__to_name;

  __gconv_fct __fct;
  __gconv_init_fct __init_fct;
  __gconv_end_fct __end_fct;



  int __min_needed_from;
  int __max_needed_from;
  int __min_needed_to;
  int __max_needed_to;


  int __stateful;

  void *__data;
};



struct __gconv_step_data
{
  unsigned char *__outbuf;
  unsigned char *__outbufend;



  int __flags;



  int __invocation_counter;



  int __internal_use;

  __mbstate_t *__statep;
  __mbstate_t __state;



  struct __gconv_trans_data *__trans;
};



typedef struct __gconv_info
{
  size_t __nsteps;
  struct __gconv_step *__steps;
  __extension__ struct __gconv_step_data __data[0];
} *__gconv_t;
# 45 "/usr/include/_G_config.h" 2 3
typedef union
{
  struct __gconv_info __cd;
  struct
  {
    struct __gconv_info __cd;
    struct __gconv_step_data __data;
  } __combined;
} _G_iconv_t;

typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));
# 31 "/usr/include/libio.h" 2 3
# 51 "/usr/include/libio.h" 3
# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/stdarg.h" 1 3
# 52 "/usr/include/libio.h" 2 3
# 158 "/usr/include/libio.h" 3
struct _IO_jump_t; struct _IO_FILE;
# 168 "/usr/include/libio.h" 3
typedef void _IO_lock_t;





struct _IO_marker {
  struct _IO_marker *_next;
  struct _IO_FILE *_sbuf;



  int _pos;
# 191 "/usr/include/libio.h" 3
};


enum __codecvt_result
{
  __codecvt_ok,
  __codecvt_partial,
  __codecvt_error,
  __codecvt_noconv
};
# 263 "/usr/include/libio.h" 3
struct _IO_FILE {
  int _flags;




  char* _IO_read_ptr;
  char* _IO_read_end;
  char* _IO_read_base;
  char* _IO_write_base;
  char* _IO_write_ptr;
  char* _IO_write_end;
  char* _IO_buf_base;
  char* _IO_buf_end;

  char *_IO_save_base;
  char *_IO_backup_base;
  char *_IO_save_end;

  struct _IO_marker *_markers;

  struct _IO_FILE *_chain;

  int _fileno;
  int _blksize;
  __off_t _old_offset;



  unsigned short _cur_column;
  signed char _vtable_offset;
  char _shortbuf[1];



  _IO_lock_t *_lock;
# 307 "/usr/include/libio.h" 3
  __off64_t _offset;





  void *__pad1;
  void *__pad2;

  int _mode;

  char _unused2[15 * sizeof (int) - 2 * sizeof (void *)];

};


typedef struct _IO_FILE _IO_FILE;


struct _IO_FILE_plus;

extern struct _IO_FILE_plus _IO_2_1_stdin_;
extern struct _IO_FILE_plus _IO_2_1_stdout_;
extern struct _IO_FILE_plus _IO_2_1_stderr_;
# 346 "/usr/include/libio.h" 3
typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);







typedef __ssize_t __io_write_fn (void *__cookie, __const char *__buf,
                                 size_t __n);







typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);


typedef int __io_close_fn (void *__cookie);
# 398 "/usr/include/libio.h" 3
extern int __underflow (_IO_FILE *) ;
extern int __uflow (_IO_FILE *) ;
extern int __overflow (_IO_FILE *, int) ;
extern wint_t __wunderflow (_IO_FILE *) ;
extern wint_t __wuflow (_IO_FILE *) ;
extern wint_t __woverflow (_IO_FILE *, wint_t) ;
# 428 "/usr/include/libio.h" 3
extern int _IO_getc (_IO_FILE *__fp) ;
extern int _IO_putc (int __c, _IO_FILE *__fp) ;
extern int _IO_feof (_IO_FILE *__fp) ;
extern int _IO_ferror (_IO_FILE *__fp) ;

extern int _IO_peekc_locked (_IO_FILE *__fp) ;





extern void _IO_flockfile (_IO_FILE *) ;
extern void _IO_funlockfile (_IO_FILE *) ;
extern int _IO_ftrylockfile (_IO_FILE *) ;
# 458 "/usr/include/libio.h" 3
extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
                        __gnuc_va_list, int *__restrict) ;
extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
                         __gnuc_va_list) ;
extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t) ;
extern size_t _IO_sgetn (_IO_FILE *, void *, size_t) ;

extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int) ;
extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int) ;

extern void _IO_free_backup_area (_IO_FILE *) ;
# 70 "/usr/include/stdio.h" 2 3



typedef _G_fpos_t fpos_t;
# 122 "/usr/include/stdio.h" 3
# 1 "/usr/include/bits/stdio_lim.h" 1 3
# 123 "/usr/include/stdio.h" 2 3



extern FILE *stdin;
extern FILE *stdout;
extern FILE *stderr;






extern int remove (__const char *__filename) ;

extern int rename (__const char *__old, __const char *__new) ;




extern FILE *tmpfile (void) ;
# 154 "/usr/include/stdio.h" 3
extern char *tmpnam (char *__s) ;




extern char *tmpnam_r (char *__s) ;
# 171 "/usr/include/stdio.h" 3
extern char *tempnam (__const char *__dir, __const char *__pfx)
             __attribute__ ((__malloc__));




extern int fclose (FILE *__stream) ;

extern int fflush (FILE *__stream) ;



extern int fflush_unlocked (FILE *__stream) ;
# 194 "/usr/include/stdio.h" 3
extern FILE *fopen (__const char *__restrict __filename,
                    __const char *__restrict __modes) ;

extern FILE *freopen (__const char *__restrict __filename,
                      __const char *__restrict __modes,
                      FILE *__restrict __stream) ;
# 224 "/usr/include/stdio.h" 3
extern FILE *fdopen (int __fd, __const char *__modes) ;
# 247 "/usr/include/stdio.h" 3
extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) ;



extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
                    int __modes, size_t __n) ;




extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
                       size_t __size) ;


extern void setlinebuf (FILE *__stream) ;




extern int fprintf (FILE *__restrict __stream,
                    __const char *__restrict __format, ...) ;

extern int printf (__const char *__restrict __format, ...) ;

extern int sprintf (char *__restrict __s,
                    __const char *__restrict __format, ...) ;


extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format,
                     __gnuc_va_list __arg) ;

extern int vprintf (__const char *__restrict __format, __gnuc_va_list __arg)
            ;

extern int vsprintf (char *__restrict __s, __const char *__restrict __format,
                     __gnuc_va_list __arg) ;



extern int snprintf (char *__restrict __s, size_t __maxlen,
                     __const char *__restrict __format, ...)
             __attribute__ ((__format__ (__printf__, 3, 4)));

extern int __vsnprintf (char *__restrict __s, size_t __maxlen,
                        __const char *__restrict __format, __gnuc_va_list __arg)
             __attribute__ ((__format__ (__printf__, 3, 0)));
extern int vsnprintf (char *__restrict __s, size_t __maxlen,
                      __const char *__restrict __format, __gnuc_va_list __arg)
             __attribute__ ((__format__ (__printf__, 3, 0)));
# 321 "/usr/include/stdio.h" 3
extern int fscanf (FILE *__restrict __stream,
                   __const char *__restrict __format, ...) ;

extern int scanf (__const char *__restrict __format, ...) ;

extern int sscanf (__const char *__restrict __s,
                   __const char *__restrict __format, ...) ;
# 347 "/usr/include/stdio.h" 3
extern int fgetc (FILE *__stream) ;
extern int getc (FILE *__stream) ;


extern int getchar (void) ;







extern int getc_unlocked (FILE *__stream) ;
extern int getchar_unlocked (void) ;




extern int fgetc_unlocked (FILE *__stream) ;




extern int fputc (int __c, FILE *__stream) ;
extern int putc (int __c, FILE *__stream) ;


extern int putchar (int __c) ;







extern int fputc_unlocked (int __c, FILE *__stream) ;




extern int putc_unlocked (int __c, FILE *__stream) ;
extern int putchar_unlocked (int __c) ;





extern int getw (FILE *__stream) ;


extern int putw (int __w, FILE *__stream) ;




extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
            ;
# 413 "/usr/include/stdio.h" 3
extern char *gets (char *__s) ;
# 437 "/usr/include/stdio.h" 3
extern int fputs (__const char *__restrict __s, FILE *__restrict __stream)
            ;
# 447 "/usr/include/stdio.h" 3
extern int puts (__const char *__s) ;



extern int ungetc (int __c, FILE *__stream) ;



extern size_t fread (void *__restrict __ptr, size_t __size,
                     size_t __n, FILE *__restrict __stream) ;

extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
                      size_t __n, FILE *__restrict __s) ;



extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
                              size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size,
                               size_t __n, FILE *__restrict __stream) ;




extern int fseek (FILE *__stream, long int __off, int __whence) ;

extern long int ftell (FILE *__stream) ;

extern void rewind (FILE *__stream) ;
# 485 "/usr/include/stdio.h" 3
typedef __off_t off_t;
# 507 "/usr/include/stdio.h" 3
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos)
            ;

extern int fsetpos (FILE *__stream, __const fpos_t *__pos) ;
# 543 "/usr/include/stdio.h" 3
extern void clearerr (FILE *__stream) ;

extern int feof (FILE *__stream) ;

extern int ferror (FILE *__stream) ;



extern void clearerr_unlocked (FILE *__stream) ;
extern int feof_unlocked (FILE *__stream) ;
extern int ferror_unlocked (FILE *__stream) ;




extern void perror (__const char *__s) ;




extern int sys_nerr;
extern __const char *__const sys_errlist[];
# 574 "/usr/include/stdio.h" 3
extern int fileno (FILE *__stream) ;




extern int fileno_unlocked (FILE *__stream) ;






extern FILE *popen (__const char *__command, __const char *__modes) ;


extern int pclose (FILE *__stream) ;





extern char *ctermid (char *__s) ;
# 621 "/usr/include/stdio.h" 3
extern void flockfile (FILE *__stream) ;



extern int ftrylockfile (FILE *__stream) ;


extern void funlockfile (FILE *__stream) ;
# 642 "/usr/include/stdio.h" 3
# 1 "/usr/include/bits/stdio.h" 1 3
# 32 "/usr/include/bits/stdio.h" 3
extern __inline int
vprintf (__const char *__restrict __fmt, __gnuc_va_list __arg)
{
  return vfprintf (stdout, __fmt, __arg);
}


extern __inline int
getchar (void)
{
  return _IO_getc (stdin);
}




extern __inline int
getc_unlocked (FILE *__fp)
{
  return ((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
}


extern __inline int
getchar_unlocked (void)
{
  return ((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
}




extern __inline int
putchar (int __c)
{
  return _IO_putc (__c, stdout);
}




extern __inline int
fputc_unlocked (int __c, FILE *__stream)
{
  return (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}





extern __inline int
putc_unlocked (int __c, FILE *__stream)
{
  return (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}


extern __inline int
putchar_unlocked (int __c)
{
  return (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
}
# 110 "/usr/include/bits/stdio.h" 3
extern __inline int
feof_unlocked (FILE *__stream)
{
  return (((__stream)->_flags & 0x10) != 0);
}


extern __inline int
ferror_unlocked (FILE *__stream)
{
  return (((__stream)->_flags & 0x20) != 0);
}
# 643 "/usr/include/stdio.h" 2 3
# 4 "bafio.c" 2
# 1 "/usr/include/stdlib.h" 1 3
# 25 "/usr/include/stdlib.h" 3
# 1 "/usr/include/features.h" 1 3
# 26 "/usr/include/stdlib.h" 2 3







# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/stddef.h" 1 3
# 34 "/usr/include/stdlib.h" 2 3
# 94 "/usr/include/stdlib.h" 3
typedef struct
  {
    int quot;
    int rem;
  } div_t;



typedef struct
  {
    long int quot;
    long int rem;
  } ldiv_t;
# 133 "/usr/include/stdlib.h" 3
extern size_t __ctype_get_mb_cur_max (void) ;



extern double atof (__const char *__nptr) __attribute__ ((__pure__));

extern int atoi (__const char *__nptr) __attribute__ ((__pure__));

extern long int atol (__const char *__nptr) __attribute__ ((__pure__));



__extension__ extern long long int atoll (__const char *__nptr)
             __attribute__ ((__pure__));



extern double strtod (__const char *__restrict __nptr,
                      char **__restrict __endptr) ;
# 163 "/usr/include/stdlib.h" 3
extern long int strtol (__const char *__restrict __nptr,
                        char **__restrict __endptr, int __base) ;

extern unsigned long int strtoul (__const char *__restrict __nptr,
                                  char **__restrict __endptr, int __base)
            ;



__extension__
extern long long int strtoq (__const char *__restrict __nptr,
                             char **__restrict __endptr, int __base) ;

__extension__
extern unsigned long long int strtouq (__const char *__restrict __nptr,
                                       char **__restrict __endptr, int __base)
            ;






__extension__
extern long long int strtoll (__const char *__restrict __nptr,
                              char **__restrict __endptr, int __base) ;

__extension__
extern unsigned long long int strtoull (__const char *__restrict __nptr,
                                        char **__restrict __endptr, int __base)
            ;
# 250 "/usr/include/stdlib.h" 3
extern double __strtod_internal (__const char *__restrict __nptr,
                                 char **__restrict __endptr, int __group)
            ;
extern float __strtof_internal (__const char *__restrict __nptr,
                                char **__restrict __endptr, int __group)
            ;
extern long double __strtold_internal (__const char *__restrict __nptr,
                                       char **__restrict __endptr,
                                       int __group) ;

extern long int __strtol_internal (__const char *__restrict __nptr,
                                   char **__restrict __endptr,
                                   int __base, int __group) ;



extern unsigned long int __strtoul_internal (__const char *__restrict __nptr,
                                             char **__restrict __endptr,
                                             int __base, int __group) ;




__extension__
extern long long int __strtoll_internal (__const char *__restrict __nptr,
                                         char **__restrict __endptr,
                                         int __base, int __group) ;



__extension__
extern unsigned long long int __strtoull_internal (__const char *
                                                   __restrict __nptr,
                                                   char **__restrict __endptr,
                                                   int __base, int __group)
            ;
# 294 "/usr/include/stdlib.h" 3
extern __inline double
strtod (__const char *__restrict __nptr, char **__restrict __endptr)
{
  return __strtod_internal (__nptr, __endptr, 0);
}
extern __inline long int
strtol (__const char *__restrict __nptr, char **__restrict __endptr,
        int __base)
{
  return __strtol_internal (__nptr, __endptr, __base, 0);
}
extern __inline unsigned long int
strtoul (__const char *__restrict __nptr, char **__restrict __endptr,
         int __base)
{
  return __strtoul_internal (__nptr, __endptr, __base, 0);
}
# 326 "/usr/include/stdlib.h" 3
__extension__ extern __inline long long int
strtoq (__const char *__restrict __nptr, char **__restrict __endptr,
        int __base)
{
  return __strtoll_internal (__nptr, __endptr, __base, 0);
}
__extension__ extern __inline unsigned long long int
strtouq (__const char *__restrict __nptr, char **__restrict __endptr,
         int __base)
{
  return __strtoull_internal (__nptr, __endptr, __base, 0);
}



__extension__ extern __inline long long int
strtoll (__const char *__restrict __nptr, char **__restrict __endptr,
         int __base)
{
  return __strtoll_internal (__nptr, __endptr, __base, 0);
}
__extension__ extern __inline unsigned long long int
strtoull (__const char * __restrict __nptr, char **__restrict __endptr,
          int __base)
{
  return __strtoull_internal (__nptr, __endptr, __base, 0);
}


extern __inline double
atof (__const char *__nptr)
{
  return strtod (__nptr, (char **) ((void *)0));
}
extern __inline int
atoi (__const char *__nptr)
{
  return (int) strtol (__nptr, (char **) ((void *)0), 10);
}
extern __inline long int
atol (__const char *__nptr)
{
  return strtol (__nptr, (char **) ((void *)0), 10);
}


__extension__ extern __inline long long int
atoll (__const char *__nptr)
{
  return strtoll (__nptr, (char **) ((void *)0), 10);
}
# 385 "/usr/include/stdlib.h" 3
extern char *l64a (long int __n) ;


extern long int a64l (__const char *__s) __attribute__ ((__pure__));


# 1 "/usr/include/sys/types.h" 1 3
# 26 "/usr/include/sys/types.h" 3
# 1 "/usr/include/features.h" 1 3
# 27 "/usr/include/sys/types.h" 2 3



# 1 "/usr/include/bits/types.h" 1 3
# 31 "/usr/include/sys/types.h" 2 3


typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;


typedef __loff_t loff_t;



typedef __ino_t ino_t;
# 58 "/usr/include/sys/types.h" 3
typedef __dev_t dev_t;




typedef __gid_t gid_t;




typedef __mode_t mode_t;




typedef __nlink_t nlink_t;




typedef __uid_t uid_t;
# 96 "/usr/include/sys/types.h" 3
typedef __pid_t pid_t;




typedef __id_t id_t;




typedef __ssize_t ssize_t;




typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;



typedef __key_t key_t;
# 126 "/usr/include/sys/types.h" 3
# 1 "/usr/include/time.h" 1 3
# 67 "/usr/include/time.h" 3
# 1 "/usr/include/bits/types.h" 1 3
# 68 "/usr/include/time.h" 2 3


typedef __time_t time_t;
# 79 "/usr/include/time.h" 3
# 1 "/usr/include/bits/types.h" 1 3
# 80 "/usr/include/time.h" 2 3


typedef __clockid_t clockid_t;
# 91 "/usr/include/time.h" 3
# 1 "/usr/include/bits/types.h" 1 3
# 92 "/usr/include/time.h" 2 3


typedef __timer_t timer_t;
# 127 "/usr/include/sys/types.h" 2 3
# 140 "/usr/include/sys/types.h" 3
# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/stddef.h" 1 3
# 141 "/usr/include/sys/types.h" 2 3



typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
# 184 "/usr/include/sys/types.h" 3
typedef int int8_t __attribute__ ((__mode__ (__QI__)));
typedef int int16_t __attribute__ ((__mode__ (__HI__)));
typedef int int32_t __attribute__ ((__mode__ (__SI__)));
typedef int int64_t __attribute__ ((__mode__ (__DI__)));


typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));

typedef int register_t __attribute__ ((__mode__ (__word__)));
# 206 "/usr/include/sys/types.h" 3
# 1 "/usr/include/endian.h" 1 3
# 22 "/usr/include/endian.h" 3
# 1 "/usr/include/features.h" 1 3
# 23 "/usr/include/endian.h" 2 3
# 37 "/usr/include/endian.h" 3
# 1 "/usr/include/bits/endian.h" 1 3
# 38 "/usr/include/endian.h" 2 3
# 207 "/usr/include/sys/types.h" 2 3


# 1 "/usr/include/sys/select.h" 1 3
# 25 "/usr/include/sys/select.h" 3
# 1 "/usr/include/features.h" 1 3
# 26 "/usr/include/sys/select.h" 2 3


# 1 "/usr/include/bits/types.h" 1 3
# 29 "/usr/include/sys/select.h" 2 3


# 1 "/usr/include/bits/select.h" 1 3
# 32 "/usr/include/sys/select.h" 2 3


# 1 "/usr/include/bits/sigset.h" 1 3
# 23 "/usr/include/bits/sigset.h" 3
typedef int __sig_atomic_t;




typedef struct
  {
    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
  } __sigset_t;
# 35 "/usr/include/sys/select.h" 2 3



# 1 "/usr/include/time.h" 1 3
# 106 "/usr/include/time.h" 3
struct timespec
  {
    long int tv_sec;
    long int tv_nsec;
  };
# 39 "/usr/include/sys/select.h" 2 3







struct timeval;

typedef __fd_mask fd_mask;


typedef __fd_set fd_set;
# 74 "/usr/include/sys/select.h" 3
extern int select (int __nfds, __fd_set *__restrict __readfds,
                   __fd_set *__restrict __writefds,
                   __fd_set *__restrict __exceptfds,
                   struct timeval *__restrict __timeout) ;
# 210 "/usr/include/sys/types.h" 2 3


# 1 "/usr/include/sys/sysmacros.h" 1 3
# 213 "/usr/include/sys/types.h" 2 3
# 224 "/usr/include/sys/types.h" 3
typedef __blkcnt_t blkcnt_t;



typedef __fsblkcnt_t fsblkcnt_t;



typedef __fsfilcnt_t fsfilcnt_t;
# 392 "/usr/include/stdlib.h" 2 3






extern int32_t random (void) ;


extern void srandom (unsigned int __seed) ;





extern char *initstate (unsigned int __seed, char *__statebuf,
                        size_t __statelen) ;



extern char *setstate (char *__statebuf) ;







struct random_data
  {
    int32_t *fptr;
    int32_t *rptr;
    int32_t *state;
    int rand_type;
    int rand_deg;
    int rand_sep;
    int32_t *end_ptr;
  };

extern int random_r (struct random_data *__restrict __buf,
                     int32_t *__restrict __result) ;

extern int srandom_r (unsigned int __seed, struct random_data *__buf) ;

extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
                        size_t __statelen,
                        struct random_data *__restrict __buf) ;

extern int setstate_r (char *__restrict __statebuf,
                       struct random_data *__restrict __buf) ;





extern int rand (void) ;

extern void srand (unsigned int __seed) ;



extern int rand_r (unsigned int *__seed) ;







extern double drand48 (void) ;
extern double erand48 (unsigned short int __xsubi[3]) ;


extern long int lrand48 (void) ;
extern long int nrand48 (unsigned short int __xsubi[3]) ;


extern long int mrand48 (void) ;
extern long int jrand48 (unsigned short int __xsubi[3]) ;


extern void srand48 (long int __seedval) ;
extern unsigned short int *seed48 (unsigned short int __seed16v[3]) ;
extern void lcong48 (unsigned short int __param[7]) ;


struct drand48_data
  {
    unsigned short int x[3];
    unsigned short int a[3];
    unsigned short int c;
    unsigned short int old_x[3];
    int init;
  };



extern int drand48_r (struct drand48_data *__restrict __buffer,
                      double *__restrict __result) ;
extern int erand48_r (unsigned short int __xsubi[3],
                      struct drand48_data *__restrict __buffer,
                      double *__restrict __result) ;


extern int lrand48_r (struct drand48_data *__restrict __buffer,
                      long int *__restrict __result) ;
extern int nrand48_r (unsigned short int __xsubi[3],
                      struct drand48_data *__restrict __buffer,
                      long int *__restrict __result) ;


extern int mrand48_r (struct drand48_data *__restrict __buffer,
                      long int *__restrict __result) ;
extern int jrand48_r (unsigned short int __xsubi[3],
                      struct drand48_data *__restrict __buffer,
                      long int *__restrict __result) ;


extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
            ;

extern int seed48_r (unsigned short int __seed16v[3],
                     struct drand48_data *__buffer) ;

extern int lcong48_r (unsigned short int __param[7],
                      struct drand48_data *__buffer) ;
# 526 "/usr/include/stdlib.h" 3
extern void *malloc (size_t __size) __attribute__ ((__malloc__));

extern void *calloc (size_t __nmemb, size_t __size)
             __attribute__ ((__malloc__));





extern void *realloc (void *__ptr, size_t __size) __attribute__ ((__malloc__));

extern void free (void *__ptr) ;



extern void cfree (void *__ptr) ;



# 1 "/usr/include/alloca.h" 1 3
# 22 "/usr/include/alloca.h" 3
# 1 "/usr/include/features.h" 1 3
# 23 "/usr/include/alloca.h" 2 3


# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/stddef.h" 1 3
# 26 "/usr/include/alloca.h" 2 3







extern void *alloca (size_t __size) ;
# 546 "/usr/include/stdlib.h" 2 3




extern void *valloc (size_t __size) __attribute__ ((__malloc__));
# 560 "/usr/include/stdlib.h" 3
extern void abort (void) __attribute__ ((__noreturn__));



extern int atexit (void (*__func) (void)) ;




extern int __on_exit (void (*__func) (int __status, void *__arg), void *__arg)
            ;
extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
            ;





extern void exit (int __status) __attribute__ ((__noreturn__));
# 588 "/usr/include/stdlib.h" 3
extern char *getenv (__const char *__name) ;



extern char *__secure_getenv (__const char *__name) ;





extern int putenv (char *__string) ;





extern int setenv (__const char *__name, __const char *__value, int __replace)
            ;


extern void unsetenv (__const char *__name) ;






extern int clearenv (void) ;
# 624 "/usr/include/stdlib.h" 3
extern char *mktemp (char *__template) ;







extern int mkstemp (char *__template) ;
# 651 "/usr/include/stdlib.h" 3
extern char *mkdtemp (char *__template) ;




extern int system (__const char *__command) ;
# 673 "/usr/include/stdlib.h" 3
extern char *realpath (__const char *__restrict __name,
                       char *__restrict __resolved) ;






typedef int (*__compar_fn_t) (__const void *, __const void *);
# 690 "/usr/include/stdlib.h" 3
extern void *bsearch (__const void *__key, __const void *__base,
                      size_t __nmemb, size_t __size, __compar_fn_t __compar);



extern void qsort (void *__base, size_t __nmemb, size_t __size,
                   __compar_fn_t __compar);



extern int abs (int __x) __attribute__ ((__const__));
extern long int labs (long int __x) __attribute__ ((__const__));
# 711 "/usr/include/stdlib.h" 3
extern div_t div (int __numer, int __denom)
             __attribute__ ((__const__));
extern ldiv_t ldiv (long int __numer, long int __denom)
             __attribute__ ((__const__));
# 729 "/usr/include/stdlib.h" 3
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
                   int *__restrict __sign) ;




extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
                   int *__restrict __sign) ;




extern char *gcvt (double __value, int __ndigit, char *__buf) ;


extern char *qecvt (long double __value, int __ndigit,
                    int *__restrict __decpt, int *__restrict __sign) ;
extern char *qfcvt (long double __value, int __ndigit,
                    int *__restrict __decpt, int *__restrict __sign) ;
extern char *qgcvt (long double __value, int __ndigit, char *__buf) ;





extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
                   int *__restrict __sign, char *__restrict __buf,
                   size_t __len) ;
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
                   int *__restrict __sign, char *__restrict __buf,
                   size_t __len) ;

extern int qecvt_r (long double __value, int __ndigit,
                    int *__restrict __decpt, int *__restrict __sign,
                    char *__restrict __buf, size_t __len) ;
extern int qfcvt_r (long double __value, int __ndigit,
                    int *__restrict __decpt, int *__restrict __sign,
                    char *__restrict __buf, size_t __len) ;






extern int mblen (__const char *__s, size_t __n) ;


extern int mbtowc (wchar_t *__restrict __pwc,
                   __const char *__restrict __s, size_t __n) ;


extern int wctomb (char *__s, wchar_t __wchar) ;



extern size_t mbstowcs (wchar_t *__restrict __pwcs,
                        __const char *__restrict __s, size_t __n) ;

extern size_t wcstombs (char *__restrict __s,
                        __const wchar_t *__restrict __pwcs, size_t __n)
            ;







extern int rpmatch (__const char *__response) ;
# 851 "/usr/include/stdlib.h" 3
extern int getloadavg (double __loadavg[], int __nelem) ;
# 5 "bafio.c" 2
# 1 "/usr/include/assert.h" 1 3
# 35 "/usr/include/assert.h" 3
# 1 "/usr/include/features.h" 1 3
# 36 "/usr/include/assert.h" 2 3
# 6 "bafio.c" 2






# 1 "_aterm.h" 1



# 1 "aterm2.h" 1
# 14 "aterm2.h"
# 1 "aterm1.h" 1
# 9 "aterm1.h"
# 1 "/usr/include/stdio.h" 1 3
# 10 "aterm1.h" 2
# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/stdarg.h" 1 3
# 110 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/stdarg.h" 3
typedef __gnuc_va_list va_list;
# 11 "aterm1.h" 2
# 1 "encoding.h" 1
# 97 "encoding.h"
typedef unsigned int header_type;
# 12 "aterm1.h" 2
# 1 "abool.h" 1



typedef enum { ATfalse=0, ATtrue } ATbool;
# 13 "aterm1.h" 2
# 24 "aterm1.h"
typedef struct _ATerm
{
        header_type header;
        struct _ATerm *next;
} *ATerm;
# 38 "aterm1.h"
ATerm ATmake(const char *pattern, ...);
ATbool ATmatch(ATerm t, const char *pattern, ...);

ATerm ATmakeTerm(ATerm pat, ...);
ATbool ATmatchTerm(ATerm t, ATerm pat, ...);
ATerm ATvmake(const char *pat);
ATerm ATvmakeTerm(ATerm pat);
void AT_vmakeSetArgs(va_list *args);
ATbool ATvmatch(ATerm t, const char *pat);
ATbool ATvmatchTerm(ATerm t, ATerm pat);

ATerm ATreadFromTextFile(FILE *file);
ATerm ATreadFromSharedTextFile(FILE *f);
ATerm ATreadFromBinaryFile(FILE *file);
ATerm ATreadFromFile(FILE *file);
ATerm ATreadFromNamedFile(const char *name);
ATerm ATreadFromString(const char *string);
ATerm ATreadFromSharedString(char *s, int size);
ATerm ATreadFromBinaryString(char *s, int size);
# 75 "aterm1.h"
ATbool ATwriteToTextFile(ATerm t, FILE *file);
long ATwriteToSharedTextFile(ATerm t, FILE *f);
ATbool ATwriteToBinaryFile(ATerm t, FILE *file);
ATbool ATwriteToNamedTextFile(ATerm t, const char *name);
ATbool ATwriteToNamedBinaryFile(ATerm t, const char *name);
char *ATwriteToString(ATerm t);
char *ATwriteToSharedString(ATerm t, int *len);
char *ATwriteToBinaryString(ATerm t, int *len);
ATerm ATsetAnnotation(ATerm t, ATerm label, ATerm anno);
ATerm ATgetAnnotation(ATerm t, ATerm label);
ATerm ATremoveAnnotation(ATerm t, ATerm label);

void ATprotect(ATerm *atp);
void ATunprotect(ATerm *atp);
void ATprotectArray(ATerm *start, int size);
void ATunprotectArray(ATerm *start);







void ATinit(int argc, char *argv[], ATerm *bottomOfStack);
void ATinitialize(int argc, char *argv[]);
void ATsetWarningHandler(void (*handler)(const char *format, va_list args));
void ATsetErrorHandler(void (*handler)(const char *format, va_list args));
void ATsetAbortHandler(void (*handler)(const char *format, va_list args));
void ATwarning(const char *format, ...);
void ATerror(const char *format, ...);
void ATabort(const char *format, ...);
int ATprintf(const char *format, ...);
int ATfprintf(FILE *stream, const char *format, ...);
int ATvfprintf(FILE *stream, const char *format, va_list args);
# 15 "aterm2.h" 2
# 1 "afun.h" 1



# 1 "atypes.h" 1



# 1 "abool.h" 1
# 5 "atypes.h" 2

typedef unsigned int ShortHashNumber;







typedef int MachineWord;
typedef unsigned int HashNumber;
# 5 "afun.h" 2
# 1 "encoding.h" 1
# 6 "afun.h" 2
# 17 "afun.h"
typedef MachineWord AFun;


typedef struct _SymEntry
{
  header_type header;
  struct _SymEntry *next;
  AFun id;
  char *name;
  int count;
  int index;
} *SymEntry;
# 39 "afun.h"
struct _ATerm;
extern struct _ATerm **at_lookup_table_alias;
extern SymEntry *at_lookup_table;

unsigned int AT_symbolTableSize();
void AT_initSymbol(int argc, char *argv[]);
int AT_printSymbol(AFun sym, FILE *f);
ATbool AT_isValidSymbol(AFun sym);

ATbool AT_isMarkedSymbol(AFun sym);
void AT_freeSymbol(SymEntry sym);
void AT_markProtectedSymbols();
unsigned int AT_hashSymbol(char *name, int arity);
ATbool AT_findSymbol(char *name, int arity, ATbool quoted);
# 16 "aterm2.h" 2
# 1 "abool.h" 1
# 17 "aterm2.h" 2





typedef struct
{
        header_type header;
        ATerm next;
        int value;
} *ATermInt;

typedef struct
{
        header_type header;
        ATerm next;
        double value;
} *ATermReal;

typedef struct
{
        header_type header;
        ATerm next;
} *ATermAppl;

typedef struct _ATermList
{
        header_type header;
        ATerm next;
        ATerm head;
        struct _ATermList *tail;
} *ATermList;

typedef struct
{
        header_type header;
        ATerm next;
        ATerm ph_type;
} *ATermPlaceholder;

typedef struct
{
        header_type header;
        ATerm next;
        void *data;
} *ATermBlob;

struct _ATermTable;

typedef struct _ATermTable *ATermIndexedSet;
typedef struct _ATermTable *ATermTable;
# 76 "aterm2.h"
ATermInt ATmakeInt(int value);




ATermReal ATmakeReal(double value);




ATermAppl ATmakeAppl(AFun sym, ...);
ATermAppl ATmakeAppl0(AFun sym);
ATermAppl ATmakeAppl1(AFun sym, ATerm arg0);
ATermAppl ATmakeAppl2(AFun sym, ATerm arg0, ATerm arg1);
ATermAppl ATmakeAppl3(AFun sym, ATerm arg0, ATerm arg1, ATerm arg2);
ATermAppl ATmakeAppl4(AFun sym, ATerm arg0, ATerm arg1, ATerm arg2,
                       ATerm arg3);
ATermAppl ATmakeAppl5(AFun sym, ATerm arg0, ATerm arg1, ATerm arg2,
                       ATerm arg4, ATerm arg5);
ATermAppl ATmakeAppl6(AFun sym, ATerm arg0, ATerm arg1, ATerm arg2,
                       ATerm arg4, ATerm arg5, ATerm arg6);







ATermAppl ATsetArgument(ATermAppl appl, ATerm arg, int n);


ATermList ATgetArguments(ATermAppl appl);
ATermAppl ATmakeApplList(AFun sym, ATermList args);
ATermAppl ATmakeApplArray(AFun sym, ATerm args[]);


extern ATermList ATempty;

ATermList ATmakeList(int n, ...);




ATermList ATmakeList1(ATerm el0);
# 142 "aterm2.h"
ATermList ATgetTail(ATermList list, int start);
ATermList ATreplaceTail(ATermList list, ATermList newtail, int start);
ATermList ATgetPrefix(ATermList list);
ATerm ATgetLast(ATermList list);
ATermList ATgetSlice(ATermList list, int start, int end);
ATermList ATinsert(ATermList list, ATerm el);
ATermList ATinsertAt(ATermList list, ATerm el, int index);
ATermList ATappend(ATermList list, ATerm el);
ATermList ATconcat(ATermList list1, ATermList list2);
int ATindexOf(ATermList list, ATerm el, int start);
int ATlastIndexOf(ATermList list, ATerm el, int start);
ATerm ATelementAt(ATermList list, int index);
ATermList ATremoveElement(ATermList list, ATerm el);
ATermList ATremoveElementAt(ATermList list, int idx);
ATermList ATremoveAll(ATermList list, ATerm el);
ATermList ATreplace(ATermList list, ATerm el, int idx);
ATermList ATreverse(ATermList list);
ATerm ATdictCreate();
ATerm ATdictGet(ATerm dict, ATerm key);
ATerm ATdictPut(ATerm dict, ATerm key, ATerm value);
ATerm ATdictRemove(ATerm dict, ATerm key);

ATermTable ATtableCreate(long initial_size, int max_load_pct);
void ATtableDestroy(ATermTable table);
void ATtableReset(ATermTable table);
void ATtablePut(ATermTable table, ATerm key, ATerm value);
ATerm ATtableGet(ATermTable table, ATerm key);
void ATtableRemove(ATermTable table, ATerm key);
ATermList ATtableKeys(ATermTable table);
ATermList ATtableValues(ATermTable table);

ATermIndexedSet
           ATindexedSetCreate(long initial_size, int max_load_pct);
void ATindexedSetDestroy(ATermIndexedSet set);
void ATindexedSetReset(ATermIndexedSet set);
long ATindexedSetPut(ATermIndexedSet set, ATerm elem, ATbool *isnew);
long ATindexedSetGetIndex(ATermIndexedSet set, ATerm elem);
void ATindexedSetRemove(ATermIndexedSet set, ATerm elem);
ATermList ATindexedSetElements(ATermIndexedSet set);
ATerm ATindexedSetGetElem(ATermIndexedSet set, long index);


ATermList ATfilter(ATermList list, ATbool (*predicate)(ATerm));


ATermPlaceholder ATmakePlaceholder(ATerm type);




ATermBlob ATmakeBlob(int size, void *data);





void ATregisterBlobDestructor(ATbool (*destructor)(ATermBlob));
void ATunregisterBlobDestructor(ATbool (*destructor)(ATermBlob));

AFun ATmakeAFun(char *name, int arity, ATbool quoted);
# 211 "aterm2.h"
void ATprotectAFun(AFun sym);

void ATunprotectAFun(AFun sym);


ATerm AT_getAnnotations(ATerm t);
ATerm AT_setAnnotations(ATerm t, ATerm annos);
ATerm AT_removeAnnotations(ATerm t);
ATerm ATremoveAllAnnotations(ATerm t);




unsigned char *ATchecksum(ATerm t);
ATbool ATdiff(ATerm t1, ATerm t2, ATerm *templ, ATerm *diffs);

void ATsetChecking(ATbool on);
ATbool ATgetChecking(void);

int ATcalcUniqueSubterms(ATerm t);
int ATcalcUniqueSymbols(ATerm t);
# 5 "_aterm.h" 2

typedef struct ProtEntry
{
        struct ProtEntry *next;
        ATerm *start;
        int size;
} ProtEntry;




extern ATbool silent;
extern ProtEntry **at_prot_table;
extern int at_prot_table_size;

void AT_markTerm(ATerm t);
void AT_unmarkTerm(ATerm t);
void AT_unmarkIfAllMarked(ATerm t);
int AT_calcTextSize(ATerm t);
int AT_calcCoreSize(ATerm t);
int AT_calcSubterms(ATerm t);
int AT_calcUniqueSubterms(ATerm t);
int AT_calcUniqueSymbols(ATerm t);
int AT_calcTermDepth(ATerm t);
void AT_writeToStringBuffer(ATerm t, char *buffer);
void AT_assertUnmarked(ATerm t);
void AT_assertMarked(ATerm t);
int AT_calcAllocatedSize();
# 13 "bafio.c" 2
# 1 "aterm2.h" 1
# 14 "bafio.c" 2
# 1 "memory.h" 1



# 1 "aterm2.h" 1
# 5 "memory.h" 2
# 18 "memory.h"
typedef struct Block
{
  int size;
  struct Block *next_by_size;
  struct Block *next_before;
  struct Block *next_after;
  header_type data[(1<<16)];
} Block;

typedef struct BlockBucket
{
  struct Block *first_before;
  struct Block *first_after;
} BlockBucket;

extern Block *at_blocks[(256 +3)];
extern int at_nrblocks[(256 +3)];
extern ATerm at_freelist[(256 +3)];
extern BlockBucket block_table[4099];

void AT_initMemory(int argc, char *argv[]);
void AT_cleanupMemory();
HashNumber AT_hashnumber(ATerm t);
ATerm AT_allocate(int size);
void AT_freeTerm(int size, ATerm t);
void AT_collect(int size);
ATbool AT_isValidTerm(ATerm term);
void AT_validateFreeList(int size);
int AT_inAnyFreeList(ATerm t);
void AT_printAllTerms(FILE *file);
void AT_printAllAFunCounts(FILE *file);
# 15 "bafio.c" 2
# 1 "afun.h" 1
# 16 "bafio.c" 2
# 1 "util.h" 1



# 1 "/usr/include/string.h" 1 3
# 26 "/usr/include/string.h" 3
# 1 "/usr/include/features.h" 1 3
# 27 "/usr/include/string.h" 2 3






# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/stddef.h" 1 3
# 34 "/usr/include/string.h" 2 3



extern void *memcpy (void *__restrict __dest,
                     __const void *__restrict __src, size_t __n) ;


extern void *memmove (void *__dest, __const void *__src, size_t __n)
            ;





extern void *memccpy (void *__restrict __dest, __const void *__restrict __src,
                      int __c, size_t __n)
            ;




extern void *memset (void *__s, int __c, size_t __n) ;


extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
             __attribute__ ((__pure__));


extern void *memchr (__const void *__s, int __c, size_t __n)
              __attribute__ ((__pure__));
# 77 "/usr/include/string.h" 3
extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
            ;

extern char *strncpy (char *__restrict __dest,
                      __const char *__restrict __src, size_t __n) ;


extern char *strcat (char *__restrict __dest, __const char *__restrict __src)
            ;

extern char *strncat (char *__restrict __dest, __const char *__restrict __src,
                      size_t __n) ;


extern int strcmp (__const char *__s1, __const char *__s2)
             __attribute__ ((__pure__));

extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
             __attribute__ ((__pure__));


extern int strcoll (__const char *__s1, __const char *__s2)
             __attribute__ ((__pure__));

extern size_t strxfrm (char *__restrict __dest,
                       __const char *__restrict __src, size_t __n) ;
# 120 "/usr/include/string.h" 3
extern char *strdup (__const char *__s) __attribute__ ((__malloc__));
# 155 "/usr/include/string.h" 3
extern char *strchr (__const char *__s, int __c) __attribute__ ((__pure__));

extern char *strrchr (__const char *__s, int __c) __attribute__ ((__pure__));
# 167 "/usr/include/string.h" 3
extern size_t strcspn (__const char *__s, __const char *__reject)
             __attribute__ ((__pure__));


extern size_t strspn (__const char *__s, __const char *__accept)
             __attribute__ ((__pure__));

extern char *strpbrk (__const char *__s, __const char *__accept)
             __attribute__ ((__pure__));

extern char *strstr (__const char *__haystack, __const char *__needle)
             __attribute__ ((__pure__));
# 187 "/usr/include/string.h" 3
extern char *strtok (char *__restrict __s, __const char *__restrict __delim)
            ;



extern char *__strtok_r (char *__restrict __s,
                         __const char *__restrict __delim,
                         char **__restrict __save_ptr) ;

extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim,
                       char **__restrict __save_ptr) ;
# 218 "/usr/include/string.h" 3
extern size_t strlen (__const char *__s) __attribute__ ((__pure__));
# 229 "/usr/include/string.h" 3
extern char *strerror (int __errnum) ;



extern char *__strerror_r (int __errnum, char *__buf, size_t __buflen) ;
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) ;




extern void __bzero (void *__s, size_t __n) ;



extern void bcopy (__const void *__src, void *__dest, size_t __n) ;


extern void bzero (void *__s, size_t __n) ;


extern int bcmp (__const void *__s1, __const void *__s2, size_t __n)
             __attribute__ ((__pure__));


extern char *index (__const char *__s, int __c) __attribute__ ((__pure__));


extern char *rindex (__const char *__s, int __c) __attribute__ ((__pure__));



extern int __ffs (int __i) __attribute__ ((const));
extern int ffs (int __i) __attribute__ ((const));
# 274 "/usr/include/string.h" 3
extern int strcasecmp (__const char *__s1, __const char *__s2)
             __attribute__ ((__pure__));


extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
             __attribute__ ((__pure__));
# 296 "/usr/include/string.h" 3
extern char *strsep (char **__restrict __stringp,
                     __const char *__restrict __delim) ;
# 358 "/usr/include/string.h" 3
# 1 "/usr/include/bits/string.h" 1 3
# 359 "/usr/include/string.h" 2 3


# 1 "/usr/include/bits/string2.h" 1 3
# 52 "/usr/include/bits/string2.h" 3
# 1 "/usr/include/endian.h" 1 3
# 53 "/usr/include/bits/string2.h" 2 3
# 1 "/usr/include/bits/types.h" 1 3
# 54 "/usr/include/bits/string2.h" 2 3
# 371 "/usr/include/bits/string2.h" 3
extern void *__rawmemchr (const void *__s, int __c);
# 395 "/usr/include/bits/string2.h" 3
extern __inline char *__strcpy_small (char *, __uint16_t, __uint16_t,
                                      __uint32_t, __uint32_t, size_t);
extern __inline char *
__strcpy_small (char *__dest,
                __uint16_t __src0_2, __uint16_t __src4_2,
                __uint32_t __src0_4, __uint32_t __src4_4,
                size_t __srclen)
{
  union {
    __uint32_t __ui;
    __uint16_t __usi;
    unsigned char __uc;
  } *__u = (void *) __dest;
  switch ((unsigned int) __srclen)
    {
    case 1:
      __u->__uc = '\0';
      break;
    case 2:
      __u->__usi = __src0_2;
      break;
    case 3:
      __u->__usi = __src0_2;
      __u = __extension__ ((void *) __u + 2);
      __u->__uc = '\0';
      break;
    case 4:
      __u->__ui = __src0_4;
      break;
    case 5:
      __u->__ui = __src0_4;
      __u = __extension__ ((void *) __u + 4);
      __u->__uc = '\0';
      break;
    case 6:
      __u->__ui = __src0_4;
      __u = __extension__ ((void *) __u + 4);
      __u->__usi = __src4_2;
      break;
    case 7:
      __u->__ui = __src0_4;
      __u = __extension__ ((void *) __u + 4);
      __u->__usi = __src4_2;
      __u = __extension__ ((void *) __u + 2);
      __u->__uc = '\0';
      break;
    case 8:
      __u->__ui = __src0_4;
      __u = __extension__ ((void *) __u + 4);
      __u->__ui = __src4_4;
      break;
    }
  return __dest;
}
# 873 "/usr/include/bits/string2.h" 3
extern __inline size_t __strcspn_c1 (__const char *__s, char __reject);
extern __inline size_t
__strcspn_c1 (__const char *__s, char __reject)
{
  register size_t __result = 0;
  while (__s[__result] != '\0' && __s[__result] != __reject)
    ++__result;
  return __result;
}

extern __inline size_t __strcspn_c2 (__const char *__s, char __reject1,
                                     char __reject2);
extern __inline size_t
__strcspn_c2 (__const char *__s, char __reject1, char __reject2)
{
  register size_t __result = 0;
  while (__s[__result] != '\0' && __s[__result] != __reject1
         && __s[__result] != __reject2)
    ++__result;
  return __result;
}

extern __inline size_t __strcspn_c3 (__const char *__s, char __reject1,
                                     char __reject2, char __reject3);
extern __inline size_t
__strcspn_c3 (__const char *__s, char __reject1, char __reject2,
              char __reject3)
{
  register size_t __result = 0;
  while (__s[__result] != '\0' && __s[__result] != __reject1
         && __s[__result] != __reject2 && __s[__result] != __reject3)
    ++__result;
  return __result;
}
# 928 "/usr/include/bits/string2.h" 3
extern __inline size_t __strspn_c1 (__const char *__s, char __accept);
extern __inline size_t
__strspn_c1 (__const char *__s, char __accept)
{
  register size_t __result = 0;

  while (__s[__result] == __accept)
    ++__result;
  return __result;
}

extern __inline size_t __strspn_c2 (__const char *__s, char __accept1,
                                    char __accept2);
extern __inline size_t
__strspn_c2 (__const char *__s, char __accept1, char __accept2)
{
  register size_t __result = 0;

  while (__s[__result] == __accept1 || __s[__result] == __accept2)
    ++__result;
  return __result;
}

extern __inline size_t __strspn_c3 (__const char *__s, char __accept1,
                                    char __accept2, char __accept3);
extern __inline size_t
__strspn_c3 (__const char *__s, char __accept1, char __accept2, char __accept3)
{
  register size_t __result = 0;

  while (__s[__result] == __accept1 || __s[__result] == __accept2
         || __s[__result] == __accept3)
    ++__result;
  return __result;
}
# 983 "/usr/include/bits/string2.h" 3
extern __inline char *__strpbrk_c2 (__const char *__s, char __accept1,
                                     char __accept2);
extern __inline char *
__strpbrk_c2 (__const char *__s, char __accept1, char __accept2)
{

  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2)
    ++__s;
  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
}

extern __inline char *__strpbrk_c3 (__const char *__s, char __accept1,
                                     char __accept2, char __accept3);
extern __inline char *
__strpbrk_c3 (__const char *__s, char __accept1, char __accept2,
              char __accept3)
{

  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2
         && *__s != __accept3)
    ++__s;
  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
}
# 1045 "/usr/include/bits/string2.h" 3
extern __inline char *__strtok_r_1c (char *__s, char __sep, char **__nextp);
extern __inline char *
__strtok_r_1c (char *__s, char __sep, char **__nextp)
{
  char *__result;
  if (__s == ((void *)0))
    __s = *__nextp;
  while (*__s == __sep)
    ++__s;
  if (*__s == '\0')
    __result = ((void *)0);
  else
    {
      __result = __s;
      while (*__s != '\0' && *__s != __sep)
        ++__s;
      if (*__s == '\0')
        *__nextp = __s;
      else
        {
          *__s = '\0';
          *__nextp = __s + 1;
        }
    }
  return __result;
}
# 1095 "/usr/include/bits/string2.h" 3
extern __inline char *__strsep_1c (char **__s, char __reject);
extern __inline char *
__strsep_1c (char **__s, char __reject)
{
  register char *__retval = *__s;
  if (__retval == ((void *)0))
    return *__s = ((void *)0);
  if (*__retval == __reject)
    *(*__s)++ = '\0';
  else
    if ((*__s = (__extension__ (__builtin_constant_p (__reject) && (__reject) == '\0' ? (char *) __rawmemchr (__retval, __reject) : strchr (__retval, __reject)))) != ((void *)0))
      *(*__s)++ = '\0';
    else
      *__s = ((void *)0);
  return __retval;
}

extern __inline char *__strsep_2c (char **__s, char __reject1, char __reject2);
extern __inline char *
__strsep_2c (char **__s, char __reject1, char __reject2)
{
  register char *__retval = *__s;
  if (__retval == ((void *)0))
    return *__s = ((void *)0);
  if (*__retval == __reject1 || *__retval == __reject2)
    *(*__s)++ = '\0';
  else
    {
      register char *__cp = __retval;
      while (*__cp != '\0' && *__cp != __reject1 && *__cp != __reject2)
        ++__cp;
      if (*__cp != '\0')
        {
          *__s = __cp;
          *(*__s)++ = '\0';
        }
      else
        *__s = ((void *)0);
    }
  return __retval;
}

extern __inline char *__strsep_3c (char **__s, char __reject1, char __reject2,
                                   char __reject3);
extern __inline char *
__strsep_3c (char **__s, char __reject1, char __reject2, char __reject3)
{
  register char *__retval = *__s;
  if (__retval == ((void *)0))
    return *__s = ((void *)0);
  if (*__retval == __reject1 || *__retval == __reject2
      || *__retval == __reject3)
    *(*__s)++ = '\0';
  else
    {
      register char *__cp = __retval;
      while (*__cp != '\0' && *__cp != __reject1 && *__cp != __reject2
             && *__cp != __reject3)
        ++__cp;
      if (*__cp != '\0')
        {
          *__s = __cp;
          *(*__s)++ = '\0';
        }
      else
        *__s = ((void *)0);
    }
  return __retval;
}

extern __inline char *__strsep_g (char **__s, __const char *__reject);
extern __inline char *
__strsep_g (char **__s, __const char *__reject)
{
  register char *__retval = *__s;
  if (__retval == ((void *)0))
    return ((void *)0);
  if ((*__s = __extension__ ({ char __a0, __a1, __a2; (__builtin_constant_p (__reject) && ((size_t)(const void *)((__reject) + 1) - (size_t)(const void *)(__reject) == 1) ? ((__a0 = ((__const char *) (__reject))[0], __a0 == '\0') ? ((void) (__retval), ((void *)0)) : ((__a1 = ((__const char *) (__reject))[1], __a1 == '\0') ? (__extension__ (__builtin_constant_p (__a0) && (__a0) == '\0' ? (char *) __rawmemchr (__retval, __a0) : strchr (__retval, __a0))) : ((__a2 = ((__const char *) (__reject))[2], __a2 == '\0') ? __strpbrk_c2 (__retval, __a0, __a1) : (((__const char *) (__reject))[3] == '\0' ? __strpbrk_c3 (__retval, __a0, __a1, __a2) : strpbrk (__retval, __reject))))) : strpbrk (__retval, __reject)); })) != ((void *)0))
    *(*__s)++ = '\0';
  return __retval;
}
# 1188 "/usr/include/bits/string2.h" 3
# 1 "/usr/include/stdlib.h" 1 3
# 1189 "/usr/include/bits/string2.h" 2 3




extern char *__strdup (__const char *__string) __attribute__ ((__malloc__));
# 1212 "/usr/include/bits/string2.h" 3
extern char *__strndup (__const char *__string, size_t __n)
             __attribute__ ((__malloc__));
# 362 "/usr/include/string.h" 2 3
# 5 "util.h" 2
# 17 "bafio.c" 2
# 1 "byteio.h" 1



# 1 "/usr/include/stdio.h" 1 3
# 5 "byteio.h" 2







typedef struct
{
  int type;
  union {
    FILE *file_data;
    struct {
      char *buf;
      int max_size;
      int cur_size;
    } string_data;
  } u;
} byte_writer;

typedef struct
{
  int type;
  long bytes_read;
  union {
    FILE *file_data;
    struct {
      char *buf;
      int index;
      int size;
    } string_data;
  } u;
} byte_reader;

int write_byte(int byte, byte_writer *writer);
int write_bytes(const char *buf, int count, byte_writer *writer);
int read_byte(byte_reader *reader);
int read_bytes(char *buf, int count, byte_reader *reader);
void init_file_reader(byte_reader *reader, FILE *file);
void init_string_reader(byte_reader *reader, char *buf, int max_size);
# 18 "bafio.c" 2
# 54 "bafio.c"
typedef struct _trm_bucket
{
  struct _trm_bucket *next;
  ATerm t;
} trm_bucket;

typedef struct _top_symbol
{
  struct _top_symbol *next;
  AFun s;

  int index;
  int count;

  int code_width;
  int code;
} top_symbol;

typedef struct
{
  int nr_symbols;
  top_symbol *symbols;

  int toptable_size;
  top_symbol **toptable;
} top_symbols;

typedef struct _sym_entry
{
  AFun id;
  int arity;

  int nr_terms;
  trm_bucket *terms;

  top_symbols *top_symbols;

  int termtable_size;
  trm_bucket **termtable;

  int term_width;

  int cur_index;
  int nr_times_top;

  struct _sym_entry *next_topsym;
} sym_entry;

typedef struct
{
  AFun sym;
  int arity;
  int nr_terms;
  int term_width;
  ATerm *terms;
  int *nr_topsyms;
  int *sym_width;
  int **topsyms;
} sym_read_entry;




char bafio_id[] = "$Id: bafio.c,v 1.38 2001/03/05 12:10:03 jong Exp $";

static int nr_unique_symbols = -1;
static sym_read_entry *read_symbols;
static sym_entry *sym_entries = ((void *)0);
static sym_entry *first_topsym = ((void *)0);

static char *text_buffer = ((void *)0);
static int text_buffer_size = 0;

static unsigned char bit_buffer = '\0';
static int bits_in_buffer = 0;
# 138 "bafio.c"
void AT_initBafIO(int argc, char *argv[])
{
}





void
AT_getBafVersion(int *major, int *minor)
{
  *major = 0x0300 >> 8;
  *minor = 0x0300 & 0xff;
}





static
int
writeIntToBuf(unsigned int val, unsigned char *buf)
{
  if (val < (1 << 7))
    {
      buf[0] = (unsigned char) val;
      return 1;
    }

  if (val < (1 << 14))
    {
      buf[0] = (val >> 8) | 0x80;
      buf[1] = (val >> 0) & 0xff;
      return 2;
    }

  if (val < (1 << 21))
    {
      buf[0] = (val >> 16) | 0xc0;
      buf[1] = (val >> 8) & 0xff;
      buf[2] = (val >> 0) & 0xff;
      return 3;
    }

  if (val < (1 << 28))
    {
      buf[0] = (val >> 24) | 0xe0;
      buf[1] = (val >> 16) & 0xff;
      buf[2] = (val >> 8) & 0xff;
      buf[3] = (val >> 0) & 0xff;
      return 4;
    }

  buf[0] = 0xf0;
  buf[1] = (val >> 24) & 0xff;
  buf[2] = (val >> 16) & 0xff;
  buf[3] = (val >> 8) & 0xff;
  buf[4] = (val >> 0) & 0xff;
  return 5;
}





static
int
writeBits(unsigned int val, int nr_bits, byte_writer *writer)
{
  int cur_bit;

  for (cur_bit=0; cur_bit<nr_bits; cur_bit++) {
    bit_buffer <<= 1;
    bit_buffer |= (val & 0x01);
    val >>= 1;
    if (++bits_in_buffer == 8) {
      if (write_byte((int)bit_buffer, writer) == -1)
        return -1;
      bits_in_buffer = 0;
      bit_buffer = '\0';
    }
  }


  return 0;
}




static
int
flushBitsToWriter(byte_writer *writer)
{
  int result = 0;
  if(bits_in_buffer > 0) {
    int left = 8-bits_in_buffer;
    bit_buffer <<= left;
    result = (write_byte((int)bit_buffer, writer) == (-1)) ? -1 : 0;
    bits_in_buffer = 0;
    bit_buffer = '\0';
  }

  return result;
}




static
int
readBits(unsigned int *val, int nr_bits, byte_reader *reader)
{
  int cur_bit, mask = 1;

  *val = 0;
  for (cur_bit=0; cur_bit<nr_bits; cur_bit++) {
    if (bits_in_buffer == 0) {
      int val = read_byte(reader);
      if (val == (-1))
        return -1;
      bit_buffer = (char) val;
      bits_in_buffer = 8;
    }
    *val |= (bit_buffer & 0x80 ? mask : 0);
    mask <<= 1;
    bit_buffer <<= 1;
    bits_in_buffer--;
  }


  return 0;
}




static
int
flushBitsFromReader(byte_reader *reader)
{
  bits_in_buffer = 0;
  return 0;
}




static
int
writeInt(unsigned int val, byte_writer *writer)
{
  int nr_items;
  unsigned char buf[8];

  nr_items = writeIntToBuf(val, buf);
  if(write_bytes((char *)buf, nr_items, writer) != nr_items)
    return -1;


  return 0;
}




static
int
readInt(unsigned int *val, byte_reader *reader)
{
  int buf[8];


  if ( (buf[0] = read_byte(reader)) == (-1) )
    return (-1);


  if ( (buf[0] & 0x80) == 0 )
    {
      *val = buf[0];
      return 1;
    }


  if ( (buf[1] = read_byte(reader)) == (-1) )
    return (-1);


  if ( (buf[0] & 0x40) == 0 )
    {
      *val = buf[1] + ((buf[0] & ~0xc0) << 8);
      return 2;
    }


  if ( (buf[2] = read_byte(reader)) == (-1) )
    return (-1);


  if ( (buf[0] & 0x20) == 0 )
    {
      *val = buf[2] + (buf[1] << 8) + ((buf[0] & ~0xe0) << 16);
      return 3;
    }


  if ( (buf[3] = read_byte(reader)) == (-1) )
    return (-1);


  if ( (buf[0] & 0x10) == 0 )
    {
      *val = buf[3] + (buf[2] << 8) + (buf[1] << 16) +
        ((buf[0] & ~0xf0) << 24);
      return 4;
    }


  if ( (buf[4] = read_byte(reader)) == (-1) )
    return (-1);


  *val = buf[4] + (buf[3] << 8) + (buf[2] << 16) + (buf[1] << 24);
  return 5;
}




static
int
writeString(const char *str, int len, byte_writer *writer)
{

  if (writeInt(len, writer) < 0)
    return -1;


  if (write_bytes(str, len, writer) != len)
    return -1;


  return 0;
}




static
int
readString(byte_reader *reader)
{
  unsigned int len;


  if (readInt(&len, reader) < 0)
    return -1;


  if (text_buffer_size < (len+1))
    {
      text_buffer_size = len*1.5;
      text_buffer = (char *) realloc(text_buffer, text_buffer_size);
      if(!text_buffer)
        ATerror("out of memory in readString (%d)\n", text_buffer_size);
    }


  if (read_bytes(text_buffer, len, reader) != len)
    return -1;


  return len;
}
# 421 "bafio.c"
static ATbool write_symbol(AFun sym, byte_writer *writer)
{
  char *name = (at_lookup_table[(sym)]->name);
  if(writeString(name, strlen(name), writer) < 0)
    return ATfalse;

  if(writeInt(((at_lookup_table_alias[(sym)]->header) >> 8), writer) < 0)
    return ATfalse;

  if(writeInt((((at_lookup_table_alias[(sym)]->header) & (1<<0)) ? ATtrue : ATfalse), writer) < 0)
    return ATfalse;

  return ATtrue;
}




void
AT_print_sym_entries()
{
  int cur_sym, cur_arg;

  for(cur_sym=0; cur_sym<nr_unique_symbols; cur_sym++) {
    sym_entry *cur_entry = &sym_entries[cur_sym];
    ATfprintf(stderr, "symbol %y: #=%d, width: %d\n",
              cur_entry->id, cur_entry->nr_terms, cur_entry->term_width);
# 457 "bafio.c"
    ATfprintf(stderr, "  arity: %d\n", cur_entry->arity);
    for (cur_arg=0; cur_arg<cur_entry->arity; cur_arg++) {
      int sym;
      top_symbols *tss = &cur_entry->top_symbols[cur_arg];
      ATfprintf(stderr, "    %d symbols: ", tss->nr_symbols);
      for (sym=0; sym<tss->nr_symbols; sym++) {
        top_symbol *ts = &tss->symbols[sym];
        ATfprintf(stderr, "%y: #=%d, width: %d, ",
                  sym_entries[ts->index].id, ts->count, ts->code_width);
      }
      ATfprintf(stderr, "\n");
    }
  }
}
# 480 "bafio.c"
static sym_entry *get_top_symbol(ATerm t, ATbool anno_done)
{
  AFun sym;

  if (((t->header) & (1<<0)) && !anno_done)
    sym = 6;
  else {
    switch (((((t)->header) & ((1<<5) | (1<<6) | (1<<7))) >> 5)) {
    case 2:
      sym = 0;
      break;
    case 3:
      sym = 1;
      break;
    case 6:
      sym = 2;
      break;
    case 5:
      sym = 3;
      break;
    case 4:
      sym = (((ATbool)(((ATermList)t) == ATempty)) ? 5 : 4);
      break;
    case 1:
      sym = ((((ATermAppl)t)->header) >> 8);
      break;
    default:
      ATabort("get_top_symbol: illegal term (%n)\n", t);
      sym = -1;
      break;
    }
  }

  return &sym_entries[at_lookup_table[sym]->index];
}





static int bit_width(int val)
{
  int nr_bits = 0;

  if (val <= 1)
    return 0;

  while (val) {
    val>>=1;
    nr_bits++;
  }

  return nr_bits;
}
# 543 "bafio.c"
void gather_top_symbols(sym_entry *cur_entry, int cur_arg,
                        int total_top_symbols)
{
  int index;
  unsigned int hnr;
  top_symbols *tss;
  sym_entry *top_entry;

  tss = &cur_entry->top_symbols[cur_arg];
  tss->nr_symbols = total_top_symbols;
  tss->symbols = (top_symbol *) calloc(total_top_symbols,
                                       sizeof(top_symbol));
  if (!tss->symbols)
    ATerror("build_arg_tables: out of memory (top_symbols: %d)\n",
            total_top_symbols);
  tss->toptable_size = (total_top_symbols*5)/4;
  tss->toptable = (top_symbol **) calloc(tss->toptable_size,
                                         sizeof(top_symbol *));
  if (!tss->toptable)
    ATerror("build_arg_tables: out of memory (table_size: %d)\n",
            tss->toptable_size);

  index = 0;
  for(top_entry=first_topsym; top_entry; top_entry=top_entry->next_topsym) {


    top_symbol *ts;
    ts = &cur_entry->top_symbols[cur_arg].symbols[index];
    ts->index = top_entry-sym_entries;
    ts->count = top_entry->nr_times_top;
    ts->code_width = bit_width(total_top_symbols);
    ts->code = index;
    ts->s = top_entry->id;

    hnr = ts->s % tss->toptable_size;
    ts->next = tss->toptable[hnr];
    tss->toptable[hnr] = ts;

    top_entry->nr_times_top = 0;
    index++;
  }
}

static void build_arg_tables()
{
  int cur_sym, cur_arg, cur_trm;
  sym_entry *topsym;

  for(cur_sym=0; cur_sym<nr_unique_symbols; cur_sym++) {
    sym_entry *cur_entry = &sym_entries[cur_sym];
    int arity = cur_entry->arity;

    ((void) 0);

    if(arity == 0)
      cur_entry->top_symbols = ((void *)0);
    else {
      cur_entry->top_symbols = (top_symbols *)calloc(arity,
                                                     sizeof(top_symbols));
      if(!cur_entry->top_symbols)
        ATerror("build_arg_tables: out of memory (arity: %d)\n", arity);
    }

    for(cur_arg=0; cur_arg<arity; cur_arg++) {
      int total_top_symbols = 0;
      first_topsym = ((void *)0);
      for(cur_trm=0; cur_trm<cur_entry->nr_terms; cur_trm++) {
        ATerm term = cur_entry->terms[cur_trm].t;
        ATerm arg = ((void *)0);
        if (sym_entries[cur_sym].id == 6) {
          ((void) 0);
          if (cur_arg == 0)
            arg = term;
          else
            arg = AT_getAnnotations(term);
        } else {
          switch(((((term)->header) & ((1<<5) | (1<<6) | (1<<7))) >> 5)) {
          case 4:
            {
              ATermList list = (ATermList)term;
              ((void) 0);
              ((void) 0);
              if (cur_arg == 0)
                arg = ((list)->head);
              else
                arg = (ATerm)((list)->tail);
            }
            break;
          case 5:
            ((void) 0);
            arg = (((ATermPlaceholder)term)->ph_type);
            break;
          case 1:
            arg = (*((ATerm *)((ATermAppl)term) + 2 + (cur_arg)));
            break;
          default:
            ATerror("build_arg_tables: illegal term\n");
            break;
          }
        }
        topsym = get_top_symbol(arg, sym_entries[cur_sym].id ==
                                6 ? ATtrue : ATfalse);
        if (!topsym->nr_times_top++) {
          total_top_symbols++;
          topsym->next_topsym = first_topsym;
          first_topsym = topsym;
        }
      }

      gather_top_symbols(cur_entry, cur_arg, total_top_symbols);
    }
  }
}







static void add_term(sym_entry *entry, ATerm t)
{
  unsigned int hnr = AT_hashnumber(t) % entry->termtable_size;
  entry->terms[entry->cur_index].t = t;
  entry->terms[entry->cur_index].next = entry->termtable[hnr];
  entry->termtable[hnr] = &entry->terms[entry->cur_index];
  entry->cur_index++;
}
# 679 "bafio.c"
static void collect_terms(ATerm t)
{
  AFun sym = -1;
  ATerm annos;
  sym_entry *entry;

  if (!(((t->header) & (1<<1)) ? ATtrue : ATfalse)) {
    switch(((((t)->header) & ((1<<5) | (1<<6) | (1<<7))) >> 5)) {
    case 2:
      sym = 0;
      break;
    case 3:
      sym = 1;
      break;
    case 6:
      sym = 2;
      break;
    case 5:
      sym = 3;
      collect_terms((((ATermPlaceholder)t)->ph_type));
      break;
    case 4:
      {
        ATermList list = (ATermList)t;
        if(((ATbool)((list) == ATempty))) {
          sym = 5;
        } else {
          sym = 4;
          collect_terms(((list)->head));
          collect_terms((ATerm)((list)->tail));
        }
      }
      break;
    case 1:
      {
        ATermAppl appl = (ATermAppl)t;
        int cur_arity, cur_arg;

        sym = (((appl)->header) >> 8);
        cur_arity = ((at_lookup_table_alias[(sym)]->header) >> 8);
        for(cur_arg=0; cur_arg<cur_arity; cur_arg++)
          collect_terms((*((ATerm *)(appl) + 2 + (cur_arg))));
      }
      break;
    default:
      ATerror("collect_terms: illegal term\n");
      break;
    }
    entry = &sym_entries[at_lookup_table[sym]->index];



    ((void) 0);
    add_term(entry, t);


    annos = AT_getAnnotations(t);
    if (annos) {
      entry = &sym_entries[at_lookup_table[6]->index];
      ((void) 0);
      collect_terms((ATerm)annos);
      add_term(entry, t);
    }

    ((t->header) |= (1<<1));
  }
}
# 754 "bafio.c"
static ATbool write_symbols(byte_writer *writer)
{
  int sym_idx, arg_idx, top_idx;

  for(sym_idx=0; sym_idx<nr_unique_symbols; sym_idx++) {
    sym_entry *cur_sym = &sym_entries[sym_idx];
    if (!write_symbol(cur_sym->id, writer))
      return ATfalse;
    if (writeInt(cur_sym->nr_terms, writer) < 0)
      return ATfalse;

    for(arg_idx=0; arg_idx<cur_sym->arity; arg_idx++) {
      int nr_symbols = cur_sym->top_symbols[arg_idx].nr_symbols;
      if(writeInt(nr_symbols, writer)<0)
        return ATfalse;
      for(top_idx=0; top_idx<nr_symbols; top_idx++) {
        top_symbol *ts = &cur_sym->top_symbols[arg_idx].symbols[top_idx];
        if (writeInt(ts->index, writer)<0)
          return ATfalse;




      }
    }
  }

  return ATtrue;
}
# 791 "bafio.c"
static int find_term(sym_entry *entry, ATerm t)
{
  unsigned int hnr = AT_hashnumber(t) % entry->termtable_size;
  trm_bucket *cur = entry->termtable[hnr];

  ((void) 0);
  while (cur->t != t) {
    cur = cur->next;
    ((void) 0);
  }

  return cur - entry->terms;
}
# 812 "bafio.c"
static top_symbol *find_top_symbol(top_symbols *syms, AFun sym)
{
  unsigned int hnr = sym % syms->toptable_size;
  top_symbol *cur = syms->toptable[hnr];

  ((void) 0);
  while (cur->s != sym) {
    cur = cur->next;
    ((void) 0);
  }

  return cur;
}
# 834 "bafio.c"
static ATbool write_term(ATerm, byte_writer *, ATbool);

static ATbool write_arg(sym_entry *trm_sym, ATerm arg, int arg_idx,
                        byte_writer *writer, ATbool anno_done)
{
  top_symbol *ts;
  sym_entry *arg_sym;
  int arg_trm_idx;
  AFun sym;

  sym = get_top_symbol(arg, anno_done)->id;
  ts = find_top_symbol(&trm_sym->top_symbols[arg_idx], sym);


  if(writeBits(ts->code, ts->code_width, writer)<0)
    return ATfalse;

  arg_sym = &sym_entries[ts->index];

  arg_trm_idx = find_term(arg_sym, arg);


  if (writeBits(arg_trm_idx, arg_sym->term_width, writer)<0) {
ATfprintf(stderr, "writeBits in write_arg failed for %t\n", arg);
    return ATfalse;
  }



  if (arg_trm_idx >= arg_sym->cur_index &&
     !write_term(arg, writer, anno_done)) {
fprintf(stderr, "write_term in write_arg failed\n");
    return ATfalse;
  }

  return ATtrue;
}
# 879 "bafio.c"
static ATbool write_term(ATerm t, byte_writer *writer, ATbool anno_done)
{
  int arg_idx;
  sym_entry *trm_sym = ((void *)0);
  ATerm annos;

  annos = AT_getAnnotations(t);


  if(!anno_done && annos) {


    trm_sym = &sym_entries[at_lookup_table[6]->index];
    if(!write_arg(trm_sym, t, 0, writer, ATtrue)) {
      return ATfalse;
    }
    if(!write_arg(trm_sym, annos, 1, writer, ATfalse)) {
      return ATfalse;
    }
  } else {
    switch(((((t)->header) & ((1<<5) | (1<<6) | (1<<7))) >> 5)) {
    case 2:
      if(writeBits((((ATermInt)t)->value), 32, writer) < 0) {
        return ATfalse;
      }






      trm_sym = &sym_entries[at_lookup_table[0]->index];
      break;
    case 3:
      {
        static char buf[64];
        sprintf(buf, "%.15e", (((ATermReal)t)->value));
        if (flushBitsToWriter(writer)<0)
          return ATfalse;
        if (writeString(buf, strlen(buf), writer) < 0)
          return ATfalse;
        trm_sym = &sym_entries[at_lookup_table[1]->index];
      }
      break;
    case 6:
      {
        ATermBlob blob = (ATermBlob)t;
        if (flushBitsToWriter(writer)<0)
          return ATfalse;
        if (writeString(((blob)->data), ((int)(((blob)->header) >> 8)), writer)<0)
          return ATfalse;
        trm_sym = &sym_entries[at_lookup_table[2]->index];
      }
      break;
    case 5:
      {
        ATerm type = (((ATermPlaceholder)t)->ph_type);
        trm_sym = &sym_entries[at_lookup_table[3]->index];
        if(!write_arg(trm_sym, type, 0, writer, ATfalse))
          return ATfalse;
      }
      break;
    case 4:
      {
        ATermList list = (ATermList)t;
        if (((ATbool)((list) == ATempty)))
          trm_sym = &sym_entries[at_lookup_table[5]->index];
        else {
          trm_sym = &sym_entries[at_lookup_table[4]->index];
          if(!write_arg(trm_sym, ((list)->head), 0, writer, ATfalse)) {
            return ATfalse;
          }
          if(!write_arg(trm_sym, (ATerm)((list)->tail), 1, writer, ATfalse)) {
            return ATfalse;
          }
        }
      }
      break;
    case 1:
      {
        int arity;
        AFun sym = (((t)->header) >> 8);
        trm_sym = &sym_entries[at_lookup_table[sym]->index];
        ((void) 0);
        arity = ((at_lookup_table_alias[(sym)]->header) >> 8);
        for (arg_idx=0; arg_idx<arity; arg_idx++) {
          ATerm cur_arg = (*((ATerm *)((ATermAppl)t) + 2 + (arg_idx)));
          if(!write_arg(trm_sym, cur_arg, arg_idx, writer, ATfalse)) {
            return ATfalse;
          }
        }
      }
      break;
    default:
      ATerror("write_term: illegal term\n");
      break;
    }
  }
  if(trm_sym->terms[trm_sym->cur_index].t != t) {
    ATerror("terms out of sync at pos %d of sym %y, "
            "term in table was %d, expected %t\n", trm_sym->cur_index,
            trm_sym->id, trm_sym->terms[trm_sym->cur_index].t, t);
  }
  trm_sym->cur_index++;



  return ATtrue;
}
# 997 "bafio.c"
static void free_write_space()
{
  int i, j;

  for(i=0; i<nr_unique_symbols; i++) {
    sym_entry *entry = &sym_entries[i];

    free(entry->terms);
    entry->terms = ((void *)0);
    free(entry->termtable);
    entry->termtable = ((void *)0);

    for(j=0; j<entry->arity; j++) {
      top_symbols *topsyms = &entry->top_symbols[j];
      if(topsyms->symbols) {
        free(topsyms->symbols);
        topsyms->symbols = ((void *)0);
      }
      if(topsyms->toptable) {
        free(topsyms->toptable);
        topsyms->toptable = ((void *)0);
      }

    }

    if(entry->top_symbols) {
      free(entry->top_symbols);
      entry->top_symbols = ((void *)0);
    }
  }
  free(sym_entries);

  sym_entries = ((void *)0);
}




ATbool
write_baf(ATerm t, byte_writer *writer)
{
  int nr_unique_terms = 0;
  int nr_symbols = AT_symbolTableSize();
  int lcv, cur;
  int nr_bits;
  AFun sym;


  bit_buffer = '\0';
  bits_in_buffer = 0;

  for(lcv=0; lcv<nr_symbols; lcv++) {
    if(!(((MachineWord)(at_lookup_table[lcv]) & 1) == 1))
      at_lookup_table[lcv]->count = 0;
  }
  nr_unique_symbols = AT_calcUniqueSymbols(t);

  sym_entries = (sym_entry *) calloc(nr_unique_symbols, sizeof(sym_entry));
  if(!sym_entries)
    ATerror("write_baf: out of memory (%d unique symbols!\n",
            nr_unique_symbols);

  nr_bits = bit_width(nr_unique_symbols);



  for(lcv=cur=0; lcv<nr_symbols; lcv++) {
    SymEntry entry = at_lookup_table[lcv];
    if(!(((MachineWord)(entry) & 1) == 1) && entry->count>0) {
      ((void) 0);
      nr_unique_terms += entry->count;

      sym_entries[cur].term_width = bit_width(entry->count);
      sym_entries[cur].id = lcv;
      sym_entries[cur].arity = ((at_lookup_table_alias[(lcv)]->header) >> 8);
      sym_entries[cur].nr_terms = entry->count;
      sym_entries[cur].terms = (trm_bucket *) calloc(entry->count,
                                                     sizeof(trm_bucket));
      if (!sym_entries[cur].terms)
        ATerror("write_baf: out of memory (sym: %d, terms: %d)\n",
                lcv, entry->count);
      sym_entries[cur].termtable_size = (entry->count*5)/4;
      sym_entries[cur].termtable =
        (trm_bucket **) calloc(sym_entries[cur].termtable_size,
                               sizeof(trm_bucket *));
      if (!sym_entries[cur].termtable)
        ATerror("write_baf: out of memory (termtable_size: %d\n",
                sym_entries[cur].termtable_size);

      entry->index = cur;
      entry->count = 0;

      cur++;
    }
  }

  ((void) 0);







  collect_terms(t);
  AT_unmarkIfAllMarked(t);


  for(lcv=0; lcv < nr_unique_symbols; lcv++)
    sym_entries[lcv].cur_index = 0;

  build_arg_tables();




  if(writeInt(0, writer) < 0)
    return ATfalse;

  if(writeInt(0xbaf, writer) < 0)
    return ATfalse;

  if(writeInt(0x0300, writer) < 0)
    return ATfalse;

  if(writeInt(nr_unique_symbols, writer) < 0)
    return ATfalse;

  if(writeInt(nr_unique_terms, writer) < 0)
    return ATfalse;



  if(!write_symbols(writer)) {
    return ATfalse;
  }


  sym = get_top_symbol(t, ATfalse)->id;
  if(writeInt(get_top_symbol(t, ATfalse)-sym_entries, writer) < 0)
    return ATfalse;

  if (!write_term(t, writer, ATfalse)) {
    return ATfalse;
  }

  if (flushBitsToWriter(writer)<0)
    return ATfalse;

  free_write_space();

  return ATtrue;
}





char *ATwriteToBinaryString(ATerm t, int *len)
{
  static byte_writer writer;
  static ATbool initialized = ATfalse;

  if (!initialized) {
    writer.type = 1;
    writer.u.string_data.buf = (char *)calloc(8192, 1);
    writer.u.string_data.max_size = 8192;
    initialized = ATtrue;
  }
  writer.u.string_data.cur_size = 0;

  if (!write_baf(t, &writer)) {
    return ((void *)0);
  }

  if (len != ((void *)0)) {
    *len = writer.u.string_data.cur_size;
  }

  return writer.u.string_data.buf;
}




ATbool ATwriteToBinaryFile(ATerm t, FILE *file)
{
  static byte_writer writer;
  static ATbool initialized = ATfalse;

  if (!initialized) {
    writer.type = 0;
    initialized = ATtrue;
  }
  writer.u.file_data = file;







  return write_baf(t, &writer);
}
# 1210 "bafio.c"
ATbool ATwriteToNamedBinaryFile(ATerm t, const char *name)
{
  FILE *f;
  ATbool result;

  if(!__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (name) && __builtin_constant_p ("-") && (__s1_len = strlen (name), __s2_len = strlen ("-"), (!((size_t)(const void *)((name) + 1) - (size_t)(const void *)(name) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("-") + 1) - (size_t)(const void *)("-") == 1) || __s2_len >= 4)) ? memcmp ((__const char *) (name), (__const char *) ("-"), (__s1_len < __s2_len ? __s1_len : __s2_len) + 1) : (__builtin_constant_p (name) && ((size_t)(const void *)((name) + 1) - (size_t)(const void *)(name) == 1) && (__s1_len = strlen (name), __s1_len < 4) ? (__builtin_constant_p ("-") && ((size_t)(const void *)(("-") + 1) - (size_t)(const void *)("-") == 1) ? (__extension__ ({ register int __result = (((__const unsigned char *) (__const char *) (name))[0] - ((__const unsigned char *) (__const char *)("-"))[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (name))[1] - ((__const u!
nsigned char *) (__const char *) ("-"))[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (name))[2] - ((__const unsigned char *) (__const char *) ("-"))[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (name))[3] - ((__const unsigned char *) (__const char *) ("-"))[3]); } } __result; })) : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) ("-"); register int __result = (((__const unsigned char *) (__const char *) (name))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (name))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (name))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (name))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("-") && ((size_t)(cons!
t void *)(("-") + 1) - (size_t)(const void *)("-") == 1) && (__s2_len = strlen ("-"), __s2_len < 4) ? (__builtin_constant_p (name) && ((size_t)(const void *)((name) + 1) - (size_t)(const void *)(name) == 1) ? (__extension__ ({ register int __result = (((__const unsigned char *) (__const char *) (name))[0] - ((__const unsigned char *) (__const char *)("-"))[0]); if (__s2_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (name))[1] - ((__const unsigned char *) (__const char *) ("-"))[1]); if (__s2_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (name))[2] - ((__const unsigned char *) (__const char *) ("-"))[2]); if (__s2_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (name))[3] - ((__const unsigned char *) (__const char *) ("-"))[3]); } } __result; })) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (name); register int __result !
= __s1[0] - ((__const unsigned char *) (__const char *) ("-"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) ("-"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) ("-"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) ("-"))[3]); } } __result; }))) : strcmp (name, "-")))); }))
    return ATwriteToBinaryFile(t, stdout);

  if(!(f = fopen(name, "w"))) {
    return ATfalse;
  }

  result = ATwriteToBinaryFile(t, f);
  fclose(f);

  return result;
}
# 1236 "bafio.c"
AFun read_symbol(byte_reader *reader)
{
  unsigned int arity, quoted;
  int len;

  if((len = readString(reader)) < 0)
    return -1;

  text_buffer[len] = '\0';

  if(readInt(&arity, reader) < 0)
    return -1;

  if(readInt(&quoted, reader) < 0)
    return -1;

  return ATmakeAFun(text_buffer, arity, quoted ? ATtrue : ATfalse);
}
# 1263 "bafio.c"
ATbool read_all_symbols(byte_reader *reader)
{
  unsigned int val;
  int i, j, k, arity;

  for(i=0; i<nr_unique_symbols; i++) {


    AFun sym = read_symbol(reader);
    if(sym < 0)
      ATerror("read_symbols: error reading symbol, giving up.\n");

    read_symbols[i].sym = sym;
    ATprotectAFun(sym);
    arity = ((at_lookup_table_alias[(sym)]->header) >> 8);
    read_symbols[i].arity = arity;




    if(readInt(&val, reader) < 0)
      return ATfalse;
    read_symbols[i].nr_terms = val;
    read_symbols[i].term_width = bit_width(val);
    if(val == 0)
      read_symbols[i].terms = ((void *)0);
    else
      read_symbols[i].terms = (ATerm *)calloc(val, sizeof(ATerm));
    if(!read_symbols[i].terms)
      ATerror("read_symbols: could not allocate space for %d terms.\n", val);
    ATprotectArray(read_symbols[i].terms, val);





    if(arity == 0) {
      read_symbols[i].nr_topsyms = ((void *)0);
      read_symbols[i].sym_width = ((void *)0);
      read_symbols[i].topsyms = ((void *)0);
    } else {
      read_symbols[i].nr_topsyms = (int *)calloc(arity, sizeof(int));
      if(!read_symbols[i].nr_topsyms)
        ATerror("read_all_symbols: out of memory trying to allocate "
                "space for %d arguments.\n", arity);

      read_symbols[i].sym_width = (int *)calloc(arity, sizeof(int));
      if(!read_symbols[i].sym_width)
        ATerror("read_all_symbols: out of memory trying to allocate "
                "space for %d arguments .\n", arity);

      read_symbols[i].topsyms = (int **)calloc(arity, sizeof(int *));
      if(!read_symbols[i].topsyms)
        ATerror("read_all_symbols: out of memory trying to allocate "
                "space for %d arguments.\n", arity);
    }



    for(j=0; j<read_symbols[i].arity; j++) {
      if(readInt(&val, reader) < 0)
        return ATfalse;

      read_symbols[i].nr_topsyms[j] = val;
      read_symbols[i].sym_width[j] = bit_width(val);
      read_symbols[i].topsyms[j] = (int *)calloc(val, sizeof(int));
      if(!read_symbols[i].topsyms[j])
        ATerror("read_symbols: could not allocate space for %d top symbols.\n",
                val);

      for(k=0; k<read_symbols[i].nr_topsyms[j]; k++) {
        if(readInt(&val, reader) < 0)
          return ATfalse;
        read_symbols[i].topsyms[j][k] = val;
      }
    }







  }

  return ATtrue;
}




ATerm read_term(sym_read_entry *sym, byte_reader *reader)
{
  unsigned int val;
  int i, arity = sym->arity;
  sym_read_entry *arg_sym;
  ATerm inline_args[6];
  ATerm *args = inline_args;
  ATerm result;

  if(arity > 6) {
    args = calloc(arity, sizeof(ATerm));
    ATprotectArray(args, arity);
    if(!args)
      ATerror("could not allocate space for %d arguments.\n", arity);
  }


  for(i=0; i<arity; i++) {

    if(readBits(&val, sym->sym_width[i], reader) < 0)
      return ((void *)0);
    arg_sym = &read_symbols[sym->topsyms[i][val]];





    if(readBits(&val, arg_sym->term_width, reader) < 0)
      return ((void *)0);

    if(!arg_sym->terms[val]) {
      arg_sym->terms[val] = read_term(arg_sym, reader);
      if(!arg_sym->terms[val])
        return ((void *)0);


    }

    args[i] = arg_sym->terms[val];
  }

  switch(sym->sym) {
  case 0:


    if(readBits(&val, 32, reader) < 0)
      return ((void *)0);

    result = (ATerm)ATmakeInt((int)val);


    break;
  case 1:


    {
      double real;
      int len;

      if(flushBitsFromReader(reader) < 0)
        return ((void *)0);
      if((len = readString(reader)) < 0)
        return ((void *)0);

      text_buffer[len] = '\0';

      sscanf(text_buffer, "%lf", &real);
      result = (ATerm)ATmakeReal(real);
    }


    break;
  case 2:


    {
      int len;
      char *data;

      if(flushBitsFromReader(reader) < 0)
        return ((void *)0);
      if((len = readString(reader)) < 0)
        return ((void *)0);

      data = malloc(len);
      if(!data)
        ATerror("could not allocate space for blob of size %d\n", len);

      result = (ATerm)ATmakeBlob(len, data);
    }


    break;
  case 3:
    result = (ATerm)ATmakePlaceholder(args[0]);
    break;
  case 4:
    result = (ATerm)ATinsert((ATermList)args[1], args[0]);
    break;
  case 5:
    result = (ATerm)ATempty;
    break;
  case 6:
    result = AT_setAnnotations(args[0], args[1]);
    break;
  default:

    result = (ATerm)ATmakeApplArray(sym->sym, args);
# 1470 "bafio.c"
  }

  if(arity > 6) {
    ATunprotectArray(args);
    free(args);
  }

  return result;
}
# 1488 "bafio.c"
static void free_read_space()
{
  int i, j;

  for(i=0; i<nr_unique_symbols; i++) {
    sym_read_entry *entry = &read_symbols[i];

    ATunprotectArray(entry->terms);
    if(entry->terms)
      free(entry->terms);
    if(entry->nr_topsyms)
      free(entry->nr_topsyms);
    if(entry->sym_width)
      free(entry->sym_width);

    for(j=0; j<entry->arity; j++)
      free(entry->topsyms[j]);
    if(entry->topsyms)
      free(entry->topsyms);
  }
  free(read_symbols);
}
# 1519 "bafio.c"
ATerm read_baf(byte_reader *reader)
{
  unsigned int val, nr_unique_terms;
  ATerm result = ((void *)0);


  bit_buffer = '\0';
  bits_in_buffer = 0;



  if(readInt(&val, reader) < 0)
    return ((void *)0);

  if(val == 0) {
    if(readInt(&val, reader) < 0)
      return ((void *)0);
  }

  if(val != 0xbaf) {
    fprintf(stderr, "read_baf: input is not in BAF!\n");
    return ((void *)0);
  }

  if(readInt(&val, reader) < 0)
    return ((void *)0);

  if(val != 0x0300) {
    fprintf(stderr, "read_baf: wrong BAF version, giving up!\n");
    return ((void *)0);
  }

  if(readInt(&val, reader) < 0)
    return ((void *)0);
  nr_unique_symbols = val;

  if(readInt(&nr_unique_terms, reader) < 0)
    return ((void *)0);

  if(!silent)
    fprintf(stderr, "reading %d unique symbols and %d unique terms.\n",
            nr_unique_symbols, nr_unique_terms);




  read_symbols = (sym_read_entry *)calloc(nr_unique_symbols,
                                          sizeof(sym_read_entry));
  if(!read_symbols)
    ATerror("read_baf: out of memory when allocating %d syms.\n",
            nr_unique_symbols);



  if(!read_all_symbols(reader))
    return ((void *)0);

  if(readInt(&val, reader) < 0)
    return ((void *)0);

  result = read_term(&read_symbols[val], reader);

  free_read_space();

  return result;
}





ATerm ATreadFromBinaryString(char *s, int size)
{
  byte_reader reader;

  init_string_reader(&reader, s, size);

  return read_baf(&reader);
}




ATerm ATreadFromBinaryFile(FILE *file)
{
  byte_reader reader;

  init_file_reader(&reader, file);
# 1615 "bafio.c"
  return read_baf(&reader);
}
>Fix:
	
>Release-Note:
>Audit-Trail:
>Unformatted:


^ permalink raw reply	[flat|nested] 4+ messages in thread

end of thread, other threads:[~2002-03-07  3:54 UTC | newest]

Thread overview: 4+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2001-12-07 17:32 c/4014: gcc reports internal erro when compiling file bafio.c rodrigc
  -- strict thread matches above, loose matches on Subject: below --
2002-03-06 19:54 rodrigc
2001-12-07 17:36 rodrigc
2001-08-13  4:16 visser

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).