^^

'interpreters' section (16/1)

/main/afnix/afnix

Compiler and run-time for the AFNIX programming language

AFNIX is a multi-threaded functional programming language with dynamic symbol bindings that support the object oriented paradigm. The language features a state of the art runtime engine. The distribution is available with several clients and a rich set of modules that are designed to be platform independent.


A+ programming language run-time environment

A+ is a powerful and efficient programming language. It is freely available under the GNU General Public License. It embodies a rich set of functions and operators, a modern graphical user interface with many widgets and automatic synchronization of widgets and variables, asynchronous execution of functions associated with variables and events, dynamic loading of user compiled subroutines, and many other features. Execution is by a rather efficient interpreter. A+ was created at Morgan Stanley. Primarily used in a computationally-intensive business environment, many critical applications written in A+ have withstood the demands of real world developers over many years. Written in an interpreted language, A+ applications tend to be portable. . This package contains the binaries and libraries needed to run A+ programs. The A+ development environment is provided by the aplus-fsf-dev package.


Highly configurable client/server TLSv1.2 library (Lua binding)

The axTLS embedded SSL project is a highly configurable client/server TLSv1.2 library designed for platforms with small memory requirements, and is suited to embedded projects. It comes with a small HTTP/HTTPS server and additional test tools. . This package contains the Lua binding.

/main/brandy/brandy

BBC BASIC V interpreter

Brandy is an interpreter for BBC Basic. It is source code compatible with the BASIC V interpreter in RISC OS and runs under a number of different operating systems. . Note that it is not possible to make operating system calls from within a program except under RISC OS.


Bywater BASIC Interpreter

The Bywater BASIC Interpreter (bwBASIC) implements a large superset of the ANSI Standard for Minimal BASIC (X3.60-1978) and a significant subset of the ANSI Standard for Full BASIC (X3.113-1987) in C. It also offers shell programming facilities as an extension of BASIC. bwBASIC seeks to be as portable as possible.

/main/cduce/cduce

programming language adapted to the manipulation of XML data

CDuce is a modern programming language adapted to the manipulation of XML documents. . Some of CDuce's peculiar features: - XML objects can be manipulated as first-class citizen values: elements, sequences, tags, characters and strings, attribute sets; sequences of XML elements can be specified by regular expressions, which also apply to characters strings; - functions themselves are first-class values, they can be manipulated, stored in data structure, returned by a function,...; - a powerful pattern matching operation can perform complex extractions from sequences of XML elements; - a rich type algebra, with recursive types and arbitrary boolean combinations (union, intersection, complement) allows precise definitions of data structures and XML types; general purpose types and types constructors are taken seriously (products, extensible records, arbitrary precision integers with interval constraints, Unicode characters); - polymorphism through a natural notion of subtyping, and overloaded functions with dynamic dispatch; - an highly-effective type-driven compilation schema. . CDuce is fast, functional, type-safe, and conforms to basic standards: Unicode, XML, DTD, Namespaces are fully supported, partial support of XML Schema validation is in alpha testing (and undocumented) while queries are being implemented.


Useful Extensions for the CGI Module

CGI::Extratags adds several useful methods to the CGI class, such as producing HTML code for a link to an email address or producing HTML code for a table row with the arguments as cell contents.


Tcl interfaces for adns, cdb, crypto, etc.

Tcl bindings for: * adns (resolver library) * cdb (constant database) plus journalling writable database * crypto: the nettle cryptographic library * hbytes: bytestrings with hex as string representation but efficient * dgram: datagram sockets * tuntap: tun/tap interfaces * maskmap: address masks and maps To make sensible use of these you will need a version of Tcl installed (this package is compatible with at least Tcl 8.0 to 8.4 inclusive). To use the adns and nettle bindings you need to have the appropriate libraries installed too.


Perl module implementing CipherSaber encryption

The Crypt::CipherSaber module implements CipherSaber encryption, described at http://ciphersaber.gurus.com. It is simple, fairly speedy, and relatively secure algorithm based on RC4. . Encryption and decryption are done based on a secret key, which must be shared with all intended recipients of a message.

/main/cjs/cjs

Mozilla-based javascript bindings for the GNOME platform

Makes it possible for applications to use all of GNOME's platform libraries using the Javascript language. It's mainly based on the Mozilla javascript engine and the GObject introspection framework. . This package is the frozen version of gjs that the cinnamon desktop currently uses. . This package contains the interactive console application.

/main/clasp/clasp

conflict-driven nogood learning answer set solver

clasp is an answer set solver for (extended) normal logic programs. It combines the high-level modeling capacities of answer set programming (ASP) with state-of-the-art techniques from the area of Boolean constraint solving. The primary clasp algorithm relies on conflict-driven nogood learning, a technique that proved very successful for satisfiability checking (SAT). Unlike other learning ASP solvers, clasp does not rely on legacy software, such as a SAT solver or any other existing ASP solver. Rather, clasp has been genuinely developed for answer set solving based on conflict-driven nogood learning. clasp can be applied as an ASP solver (on LPARSE output format), as a SAT solver (on simplified DIMACS/CNF format), or as a PB solver (on OPB format).

/main/clif/clif

C language interpreter

Clif, a C-like Interpreter Framework, is and open-ended system for fast development of programs with C syntax. The program is compiled and if syntactically correct, code is immediately generated. The code is generated for a virtual machine. The virtual machine is a part of the framework.

/main/clips/clips

"C" Language Integrated Production System

CLIPS is an OPS-like forward chaining production system written in ANSI C by NASA. The CLIPS inference engine includes truth maintenance, dynamic rule addition, and customizable conflict resolution strategies. . CLIPS, including the runtime version, is easily embeddable in other applications. CLIPS includes an object-oriented language called COOL (CLIPS Object-Oriented Language) which is directly integrated with the inference engine.


CLIPS common files and examples

CLIPS is an OPS-like forward chaining production system written in ANSI C by NASA. The CLIPS inference engine includes truth maintenance, dynamic rule addition, and customizable conflict resolution strategies. . This package installs the common files for the program. It currently includes several examples of CLIPS programs that can be used to learn the language and test its interfaces.

/main/clod/lua-clod

Configuration Language Organised (by) Dots

Clod is a configuration language written in Lua which implements a simple dotted key/value pair system which tries to keep programmatic edits in-line with what humans would do in a similar situation.

/main/coala/coala

translates action languages into answer set programs

The coala tool translates an action language into a logic program under the answer set semantics. After being grounded by lparse or gringo, the logic program can be solved by an answer set solver such as clasp. At the moment coala is able to translate the action language AL, B, C, a subset of C+ and the action language CTAID. The type of input language can be specified with a command line option.


CORBA scripting with Tcl

Combat is a CORBA Object Request Broker that allows the implementation of CORBA clients and servers in the Tcl programming language. . On the client side, Combat is not only useful to easily test-drive existing CORBA servers, including the ability for rapid prototyping or to interactively interface with servers from a console, but makes Tcl an exciting language for distributed programming. Also, Tk allows to quickly develop attractive user interfaces accessing CORBA services. Server-side scripting using [incr Tcl] classes also offers a wide range of possibilities. . Combat is compatible with the CORBA 3.0 specification including the IIOP protocol, and has been tested to interoperate with a wide range of open-source and commercial ORBs, including MICO, TAO and ORBexpress. . Combat is written in pure Tcl, allowing it to run on all platforms supported by Tcl, which is a much wider range than supported by any other ORB.

/main/critcl/critcl

compiled runtime in Tcl

Critcl takes a snippet of C, generates Tcl interface, sends it to the compiler, and then dynamically links the code. Checksums are used to only recompile when needed, so the build overhead really applies only once.


Berkeley v5.3 Database Libraries for Tcl [module]

This package provides a Tcl module suitable for accessing Berkeley v5.3 databases from within Tcl programs.

/main/depqbf/depqbf

solver for quantified boolean formulae

DepQBF is a search-based solver for quantified boolean formulae (QBF) in prenex conjunctive normal form. It is based on the DPLL algorithm for QBF, called QDPLL, with conflict-driven clause and solution-driven cube learning. By analyzing the syntactic structure of a formula, DepQBF tries to identify independent variables. In general, information on independent variables can be represented in the formal framework of dependency schemes. DepQBF computes the so-called "standard dependency scheme" of a given formula. In addition to other benefits, information on independent variables often increases the freedom for decision making and clause learning.

/main/dh-lua/lua-any

helper script for shebang lines in Lua scripts

Some Lua script do actually work with many, but not all, Lua versions in the Debian archive. This package contains the lua-any interpreter to be used in the shebang lines of such scripts. lua-any reads metadata stored in comments in the Lua script and selects an appropriate Lua interpreter.

/main/dh-lua/dh-lua

helper tools for maintaining Lua-related packages

This package contains the Debian policy for the Debian packages relative to the Lua scripting language, as well as some tools to help build them.


debhelper add-on to simplify Perl 6 package building

dh-perl6 provides a debhelper add-on called 'perl6'. This simplifies common steps of Perl 6 package building, like postinst and postrm scripts and communicating module dependencies to the rakudo install helpers.


Python client library for DICT (RFC2229) protocol

This is a new library for interacting with Dict servers. It defines three classes -- Connection, Database, and Definition. It supports all common Dict server requests, including definitions, matching, and getting information about available databases, capabilities, etc. You can use it to communicate to a local or remote dictd database. The homepage for this package (includes docs) is at gopher://quux.org/1/devel/dictclient.


Python library for generating dictd dictionaries

This library is useful if you want to write Python programs that generate dictd dictionaries.


embeddable Javascript engine

Duktape is an embeddable Javascript engine, with a focus on portability and compact footprint. . Duktape is easy to integrate into a C/C++ project: add duktape.c, duktape.h, and duk_config.h to your build, and use the Duktape API to call Ecmascript functions from C code and vice versa. . The main features are - Embeddable, portable, compact: can run on platforms with 256kB flash and 64kB system RAM - Ecmascript E5/E5.1 compliant, some features borrowed from Ecmascript E6 - Khronos/ES6 TypedArray and Node.js Buffer bindings - Built-in debugger - Built-in regular expression engine - Built-in Unicode support - Minimal platform dependencies - Combined reference counting and mark-and-sweep garbage collection with finalization - Custom features like coroutines, built-in logging framework, and built-in CommonJS-based module loading framework - Property virtualization using a subset of Ecmascript E6 Proxy object - Bytecode dump/load for caching compiled functions . This package contains a commandline duk interpreter


elektra configuration store, Lua bindings

Elektra provides a universal and secure framework to store configuration parameters in a hierarchical key-value pair mechanism, instead of each program using its own text configuration files. This allows any program to read and save its configuration with a consistent API, and allows them to be aware of other applications' configurations, permitting easy application integration. While architecturally similar to other OS registries, Elektra does not have most of the problems found in those implementations. . This package contains the Lua bindings.


functional meta-programming aware language

Elixir is a functional meta-programming aware language intended primarily for developing distributed, fault-tolerant and scalable systems. Elixir source code is compiled to bytecode for the Erlang Virtual Machine (EVM), and can use Erlang libraries transparently.

/main/elk/elk

scheme interpreter

Elk is an implementation of the Scheme programming language, designed specifically as an embeddable, reusable extension language subsystem for applications written in C or C++. . This package contains the Elk Scheme interpreter, as well as several plugins shipped with Elk. They provide hooks for Unix system calls, the X Window System, as well as the X Athena Widgets and the Motif toolkits. Example scripts on how to use these plugins are provided in the elkdoc package.

/main/elza/elza

Script language for automating HTTP requests

Elza is a set of perl scripts which can be used as an interpreter for automating requests on web pages. It can extract dynamic URLs from a page, handle forms, cookies, HTTP authentication, redirects / refreshes, etc.