Free berkeley yacc software for linux

Berkeley Yacc (byacc) is generally conceded to be the best yacc variant available. In contrast to bison, it is written to avoid dependencies upon a particular compiler.
Byacc was written around 1990 by Robert Corbett who is the original author of bison. Originally written in K&R C, I have modified it to conform to ANSI C, and made other improvements.
Enhancements:
- configure.in: add AC_ARG_PROGRAM to make --program-prefix, etc., work.
- makefile.in: first cut of script to support --program-prefix
- configure.in: reorder AC_INIT/AC_CONFIG_HEADER to make this "work" with autoconf 2.52
- makefile.in: modify so DESTDIR works
- makefile.in: use EXEEXT and OBJEXT
- configure.in: use CF_PROG_EXT generate a config.h
- defs.h: make this use the generated config.h
- skeleton.c: add a forward-reference for yyparse()
- aclocal.m4: add CF_CHECK_CACHE, needed for CF_PROG_EXT
- yacc.1: remove the discussion of TMPDIR since it is obsolete
- skeleton.c: fix a couple of minor compiler-warnings in the skeleton
- defs.h: remove action_file_name, etc., since we use tmpfile() now.
- main.c: use tmpfile() for opening the working files. This quiets an idiot-warning advertising the use of mkstemp().
- output.c: Do not close temporary-files here, since they are opened with tmpfile(). Just rewind them, and theyre ready to read back the data stored in them.
- test/grammar.output, test/grammar.tab.c, test/grammar.tab.h: RCS_BASE
- makefile.in: turn on "make check" rule
- test/calc.output, test/run_test.sh, test/calc.tab.h: RCS_BASE
- test/ftp.tab.c: yyparse() is now yyparse(void)
- test/calc.tab.c: RCS_BASE
- test/error.tab.c: yyparse() is now yyparse(void)
- test/README: RCS_BASE
- yacc.1: various typography fixes prompted by Debian #100947
- aclocal.m4, makefile.in, configure.in: RCS_BASE
- README: updated to note that this is not the original

Unified Parallel C, in short UPC, is an extension of the C programming language designed for high performance computing on large-scale parallel machines.

The language provides a uniform programming model for both shared and distributed memory hardware.

The programmer is presented with a single shared, partitioned address space, where variables may be directly read and written by any processor, but each variable is physically associated with a single processor.

UPC uses a Single Program Multiple Data (SPMD) model of computation in which the amount of parallelism is fixed at program startup time, typically with a single thread of execution per processor.

Whats New in This Release:

- Add initial native support for the Cray XT3 via new portals network
- Implement the GASP 1.5 performance instrumentation interface, supporting the
Parallel Performance Wizard (PPW) and other third-party profiling tools.
- Add bupc_ticks_to_ns() - finer granularity timer query
- Add the Berkeley implementations of the UPC collectives and UPC-IO to GCCUPC+UPCR
- Add most of the Berkeley UPC library extensions to GCCUPC+UPCR
- Add upcdecl command-line tool (also online at: http://upc.lbl.gov/upcdecl)
- Add support for alloca() and stdarg.h
- Performance improvements to the BUPC semaphore library for signalling store
- Add bupc_thread_distance() - runtime thread layout query for hierarchical systems
- Add a remote fetch-and-add UPC library extension (initially just for 64-bit ints)
- Allow configure-time tuning of bit distribution in packed pointer-to-shared rep
- Fix the following notable bugs in 2.2.2 (see http://upc-bugs.lbl.gov for details):
- bug525: optimizer crashes on Tru64/CompaqC for libgasnet
- bug1229: More robust preprocessing on Compaq C
- bug1389: ansi-aliasing violations on small local put/get copies
- bug1531: improved lock fairness to remote lock requests
- bug1594: timer inaccuracies on Cray X1E
- bug1645: preprocess-time failure Backslash found where operator expected
- bug1657: PACKAGE_* symbols exposed to UPC code on GCCUPC+UPCR
- bug1683: improve upcrun handling of -shared-heap-max
- bug 1743: More robust behavior when backend C compiler changes
- Improved SRV-based DNS failover for upcc HTTP translation
- Add gzip compression to HTTP netcompile, for faster compiles over slow links
- Improved robustness for SSH netcompile to handle stray output from dotfiles
- Numerous misc minor bug fixes

Berkeley Yacc is an LALR(1) parser generator. Berkeley Yacc has been made as compatible as possible with AT&T Yacc. Berkeley Yacc can accept any input specification that conforms to the AT&T Yacc documentation. Specifications that take advantage of undocumented features of AT&T Yacc will probably be rejected.

Berkeley Yacc is distributed with no warranty whatever. The code is certain to contain errors. Neither the author nor any contributor takes responsibility for any consequences of its use.

Berkeley Yacc is in the public domain. The data structures and algorithms used in Berkeley Yacc are all either taken from documents available to the general public or are inventions of the author. Anyone may freely distribute
source or binary forms of Berkeley Yacc whether unchanged or modified. Distributers may charge whatever fees they can obtain for Berkeley Yacc. Programs generated by Berkeley Yacc may be distributed freely.

Delphi Yacc & Lex is a parser generator toolset for Delphi and Kylix, based on Turbo Pascal Lex and Yacc version 4.1.

The primary goal of Delphi Yacc & Lex is to clean up the code, and improve compatibility and maintainability.

The project started because the original Turbo Pascal Lex and Yacc did not compile well in Delphi 5+ or Kylix, the sourcecode was messy, and the last release or activity dates back to early 2000.

Video::TeletextDB is Perl extension to manage a telextext database.

SYNOPSIS

use Video::TeletextDB;

$tele_db = Video::TeletextDB->new(%options);
# Possible options are:
# cache_dir => $directory
# mkpath => $boolean
# umask => $mask
# creat => $boolean
# RW => $boolean
# page_versions => $number
# channel => $string
# stale_period => $seconds
# expire_period => $seconds

$access = $tele_db->access(%options);
# Possible options are:
# umask => $mask
# creat => $boolean
# RW => $boolean
# page_versions => $number
# channel => $string
# stale_period => $seconds
# expire_period => $seconds

$cache_dir = $tele_db->cache_dir;
$channel = $tele_db->channel;
$old_channel = $tele_db->channel($new_channel);
@channels = $tele_db->channels;
$nr_channels = $tele_db->channels;
$boolean = $tele_db->has_channel(?$channel?);
$db_file = $tele_db->db_file;
$lock_file = $tele_db->lock_file;
$tele_db->lock;
$page_versions= $tele_db->page_versions;
$umask = $tele_db->umask;
$old_umask = $tele_db->umask($new_umask);
$RW = $tele_db->RW;
$old_RW = $tele_db->RW($new_RW);
$stale_period = $tele_db->stale_period;
$old_stale_period = $tele_db->stale_period($new_stale_period);
$expire_period = $tele_db->expire_period;
$old_expire_period = $tele_db->expire_period($new_expire_period);
$user_data = $tele_db->user_data;
$old_user_data= $tele_db->user_data($new_user_data);

$tele_db->delete(%options);

The idea behind a teletext database is to separate the process of collecting teletext pages from the process of presentation. This makes programs both shorter (you dont have to implement the side yourre not interested in) and more flexible (you can read teletext pages long after the collector stopped running and you dont have to be tuned in to the channel you want to read).

In fact, the simple script TeleCollect coming with this package will be good enough for most teletext collection purposes, so that you can concentrate on the page processing.

This modules provides you with methods to both store and retrieve pages into a database and some rudimentary support to manage a set of databases (typically one for each channel). The pages will be stored in raw form so that a client can decide for itself how to handle things like transmission errors (there are of suggested methods provided in the module though, so you dont have to reinvent the wheel every time).

It (currently) use a Berkeley DB with an external lockfile for the actual storage. It only uses the version 1.85 features, so it should work almost everywhere. There will be one database and lockfile for each channel and all channel databases and locks will normally be collected in one directory.

Bogofilter is a Bayesian spam filter. In its normal mode of operation, it takes an email message or other text on standard input, does a statistical check against lists of `good` and `bad` words, and returns a status code indicating whether or not the message is spam.

Bogofilter is designed with fast algorithms, uses the Berkeley DB for fast startup and lookups, coded directly in C, and tuned for speed, so it can be used for production by sites that process a lot of mail.

Bogofilter is run by an MDA script to classify an incoming message as spam or ham (using wordlists stored by BerkeleyDB). Bogofilter provides processing for plain text and html.

Bogofilter supports multi-part mime message with decoding of base64, quoted-printable, and uuencoded text and ignores attachments, such as images.

Bogofilter is written in C. Supported platforms: Linux, FreeBSD, Solaris, OS X, HP-UX, AIX, RISC OS, SunOS, OS/2 …

LLgen is a LL parser in the style of yacc.
The Amsterdam Compiler Kit is fast, lightweight and retargetable compiler suite and toolchain written by Andrew Tanenbaum and Ceriel Jacobs, and was Minix native toolchain.
The ACK was originally closed-source software (that allowed binaries to be distributed for Minix as a special case), but in April 2003 it was released under a BSD open source license.
The ACK achieves maximum portability by using an intermediate byte-code language called EM. Each language front-end produces EM object files, which are then processed through a number of generic optimisers before being translated by a back-end into native machine code.
Unlike gccs intermediate language, EM is a real programming language and could be implemented in hardware; a number of the language front-ends have libraries implemented in EM assembly.
EM is a relatively high-level stack-based machine, and one of the tools supplied with ACK is an interpreter capable of executing EM binaries directly, with a high degree of safety checking. See the em document referenced below for more information.
ACK comes with a generic linker and librarian capable of manipulating files in the ACKs own a.out-based format; it will work on files containing EM code as well as native machine code. (You can not, however, link EM code to native machine code without translating the EM binary first.)
Enhancements:
- LLgen was previously part of the Amsterdam Compiler Kit, but has been split out into a standalone component.
- This version has been updated from its original 1991 vintage source and has a completely rewritten, much more streamlined build system.

Heirloom Development Tools package provides yacc, lex, m4, make, and SCCS as portable derivatives of the utilities released by Sun as part of OpenSolaris. The OpenSolaris utilities were in turn derived from the original Unix versions, and are assumed be conforming implementations of the POSIX standard.

Software developed on original Unix systems has quite often used internals of yacc and lex. The tools in this package provide a convenient way to make such software compile on free Unix platforms such as Linux or BSD. In particular, they serve as a stable base for compiling other components of the Heirloom Project.