27,890 research outputs found
Algebraic processing of programming languages
AbstractCurrent methodology for compiler construction evolved in small increments over a long period of time. Its heritage is machine-dependent and derived from sequential Von Neumann machines. There is a growing emphasis on increasingly abstract paradigms for new programming languages. At the same time today's high performance distributed/parallel computing facilities depart from Von Neumann machines and provide a much more intricate execution environment. Therefore current methodology is being stretched beyond its intrinsic capacity in order to accommodate these two accelerating trends. We develop an alternative compiler construction methodology whose fundamental principles are: 1.(1) decomposition of programming languages into simpler components2.(2) development of machine independent specification and implementation tools for each language component3.(3) mathematical integration of language component processing algorithms into an algebraic compiler.
This allows the specification and implementation of provably correct (commercial) compilers. This paper is a tutorial dedicated to presenting the infrastructure of an algebraic compiler in a do-it-yourself manner
Phrase parsers from multi-axiom grammars
AbstractMulti-axiom grammars (MAG) are alternatives to single-axiom context free grammars (CFG) and all-axiom algebraic grammars (AG) for programming language specification. Neither phrase recognition nor algebraic mechanisms for language processing are supported by CFGs. AGs support algebraic mechanisms for language processing but specify a smaller class of languages. MAGs avoid these limitations. This paper describes a new parsing algorithm developed on this basis which recognizes any phrase in the language. Moreover, it does so by distributing the parsing task among a collection of smaller parsers which handle well-defined layers of the language in a piping manner. These language-layers are determined by the algebraic properties of the MAGs and are described in the paper. Basic definitions are given for multi-axiom grammar and language as well as for algebraic notions of subgrammar, primitive subgrammar, quotient grammar, and grammar/language layer. Algorithms are described to stratify a programming language into a hierarchy of layers, to construct parsers for each layer analogous to LR construction, and to accomplish the overall task of multi-layered parsing in pipeline fashion based on a tokenization which occurs between the language layers. This pipeline parallel process is a model for high speed, left-to-right language translation
Studies in the design and implementation of programming languages for symbol manipulation
Compared with the development of computing hardware, the
development of programming languages has followed a different course.
Hardware innovations such as the use of transistors and integrated
circuitry have resulted in machines with very substantially improved
capabilities, making older machines and even comparatively modern
machines obsolescent. The programming languages currently in most
widespread use, however, remain those which were already in use as many
as ten years ago, namely HJRTRAN, ALGOL 60, and COBOL. Nevertheless,
considerable improvements can be made to these languages. The reasons
why no improvements were made appear to be primarily twofold. Firstly,
they are regarded as 'standard' languages, which in order to facilitate
transferability of programs, has made them virtually immutable.
Secondly, they can be employed in almost all programming situations
without the need for change.
Instead, very many other languages have been designed and
implemented with particular objectives in view, but which almost
invariably limit their application to a narrow field. Only recently have
attempts been made to unify some of the developments under the cloak of
a single language ( PL/1 and ALGOL 68 ). Data structures are a
particular example of what features have been incorporated. There are
still considerable omissions however. For instance, neither language has
incorporated list processing or symbol manipulation facilities within
its basic framework.
The latter seems to be most surprising. With the increased
capabilities of modern computers and the consequent broadening of their
range of application, techniques involving symbol manipulation are
becoming increasingly important. Natural language processing such as the
analysis of texts for authorship and mechanical translation, and formal
manipulations, such as those involved in mechanical theorem-proving and
algebraic formula manipulation are some obvious applications. The last
mentioned, that of algebraic manipulation of formulae, is one of the
most important applications. Several systems, notably R3RMAC, have been
developed for this purpose. With the advent of multi-access computing
systems a much greater interaction between man and machine is becoming possible, where the advantages of algebraic manipulation and
mathematical assistance packages are felt the greatest. This, further,
demonstrates the need for symbol manipulation facilities to be available
together with normal arithmetic facilities in a programming language,
for not only must the formulae be manipulated but also they must be
evaluated in normal arithmetic terns.
This combination has not completely satisfactorily been acheived in
any languages developed in the past. The present investigation is an
attempt to overcome this deficiency. A language called ASTRA has been
the result. Before discussing the design and implementation of ASTRA,
several existing languages are examined in order to discern the
desirable properties of a language for symbol manipulation. It is the
belief of the present author that the features of ASTRA described herein
represent an advance on previous languages. The methods used in the
ASTRA compiler are also described
Recommended from our members
Software tools for stochastic programming: A Stochastic Programming Integrated Environment (SPInE)
SP models combine the paradigm of dynamic linear programming with
modelling of random parameters, providing optimal decisions which hedge
against future uncertainties. Advances in hardware as well as software
techniques and solution methods have made SP a viable optimisation tool.
We identify a growing need for modelling systems which support the creation
and investigation of SP problems. Our SPInE system integrates a number of
components which include a flexible modelling tool (based on stochastic
extensions of the algebraic modelling languages AMPL and MPL), stochastic
solvers, as well as special purpose scenario generators and database tools.
We introduce an asset/liability management model and illustrate how SPInE
can be used to create and process this model as a multistage SP application
Can Computer Algebra be Liberated from its Algebraic Yoke ?
So far, the scope of computer algebra has been needlessly restricted to exact
algebraic methods. Its possible extension to approximate analytical methods is
discussed. The entangled roles of functional analysis and symbolic programming,
especially the functional and transformational paradigms, are put forward. In
the future, algebraic algorithms could constitute the core of extended symbolic
manipulation systems including primitives for symbolic approximations.Comment: 8 pages, 2-column presentation, 2 figure
A branch-and-bound methodology within algebraic modelling systems
Through the use of application-specific branch-and-bound directives it is possible to find solutions to combinatorial models that would otherwise be difficult or impossible to find by just using generic branch-and-bound techniques within the framework of mathematical programming. {\sc Minto} is an example of a system which offers the possibility to incorporate user-provided directives (written in {\sc C}) to guide the branch-and-bound search. Its main focus, however, remains on mathematical programming models. The aim of this paper is to present a branch-and-bound methodology for particular combinatorial structures to be embedded inside an algebraic modelling language. One advantage is the increased scope of application. Another advantage is that directives are more easily implemented at the modelling level than at the programming level
- …