基于Warren抽象机的Prolog实现技术的研究

本文介绍了基于WAM的Prolog实现技术的研究结果。首先论述了新的Prolog执行模型WAM-PLUS。该模型由扩充了的WAM和非逻辑成分执行机制NLEM构成。它能支持Prolog动态代码,并能实现一致的动态代码语义。文中还介绍了Prolog编译策略和Prolog编译器的设计,描述了一种顺序推理机的系统结构。     

Kernel Prolog 数据库访问扩展及B/S结构改造

研究了基于Kemel Prolog的解释器原型,扩展了Kemel Prolog,使之能够连接Microsoft SQL Server数据库并进行相应的数据库操作,将Kernel Prolog单机版改造成为B／S结构运行的版本,并使两个版本可以同时运行和修改,使Prolog解释／编译器具备数据库访问功能,对推广Prolog应用很有意义。     

西文DOS下彩色汉字显示方法的研究

本文在回顾Turbo Prolog语言的发展及局限的基础上,介绍了在西文环境下,利用Turbo Prolog语言,通过直接访问国标中文16×16和24×24点阵字库,在图形方式下显示各种不同大小及颜色的彩色汉字的一种方法.从而,能够在西文状态下,方便地作出具有彩色汉字说明或标注的图形及友好的人—机界面,解决西文Turbo Prolog和中西文Turbo Prolog语言在西文状态下不能显示彩色汉字的不足,并给出了部分源程序清单.     

绿色编译优化策略:研究综述

随着人类活动对环境影响的日益增大,各种高能耗、低资源利用率、高污染电子设备的大量应用,给环境带来了严峻的挑战.如何减少对环境的破坏已经成为人们不可忽视的一个重要问题.编译器既是必不可少的基础软件,又是研制软件的重要工具,目前很多编译优化的研究已经从传统单纯的性能优化逐渐转变为对能耗、资源利用率等绿色需求相关优化的研究.根据现有的绿色需求相关定义以及编译器的主要特点,提出了绿色编译器的定义及其主要目标.针对各种面向绿色需求的新型体系结构,分别从总线、存储系统和处理器这三个组成计算机的重要部件出发,分析了现有编译器在软件运行过程中的相关优化方法及其可能的改进方案.最后,分析了编译器在提高软件测试效率,减少绿色指标软件开发过程中开销的相关方法,为以后绿色编译优化的研究奠定了基础.     

AI与Prolog

Prolog是一种人工智能语言,它在AI和知识库的实现技术中具有十分重要的作用。本文介绍了Prolog的工作原理．并通过实例分析了Prolog语言的特点。利用Prolog的逻辑描述能力和推理能力,使得解决复杂的、非结构化的问题变得简单了。     

试析C#编程语言的特点及功能

如今,从C#编程语言的发展前景分析,其可能在多个操作系统平台中编写各种实现,而从现实应用情况来看,大多数操作人员及编译器供应商已经将C#作为创建编译器版本的标准.本文从工作实践出发,主要对C#编程语言的特点及功能进行了探讨分析.     

模糊Prolog系统

模糊Prolog系统将不确定性引入到传统的Prolog系统中,对现实应用具有很大的意义。文中首先介绍了模糊系统和Prolog系统,然后讨论了实现模糊Prolog系统的两种方法,并给出了一些典型的模糊Prolog模型。最后重点讨论了在Prolog系统中实现模糊集合的几种方法,因而对于不同的应用要求可以选择不同类型的模糊Prolog系统。     

知识库系统和语言的演变

引言 Prolog作为一个良好的Al语言已经得到广泛接受,市场上已经有多种Prolog产品(包括Prolog机).但是,Prolog不能有效地管理持久数据且“每次一个元组”的求值方式不适用于数据密集型应用(如:CAx、CIMS、专家系统、……)。另一方面,数据库管理系统(DBMs)能够有效安全地管理大容量数据.但不能处理递归,而递归是上述基于知识系统的基本能力。因此,研制同时具有Prolog和DBMS能力的新型数据系统就成为必要。     

用Prolog写Prolog

本文介绍一个用Prolog书写的Prolog系统,简称为PiPs。该系统是一个按照解释方式实现的语言处理系统的雏型。全文共分两大部分。前一部分介绍了PiPs本身的结构:首先介绍建立PiPs所需的Prolog谓词,接着介绍PiPs的处理概要,用户接口,执行系统,对应谓词。后一部分,通过四个例子介绍了如何使用PiPs来扩充Prolog的功能。     

模糊Prolog系统

模糊Prolog系统将不确定性引入到传统的Prolog系统中，对现实应用具有很大的意义。文中首先介绍了模糊系统和Prolog系统，然后讨论了实现模糊Prolog系统的两种方法，并给出了一些典型的模糊Prolog模型。最后重点讨论了在Prolog系统中实现模糊集合的几种方法，因而对于不同的应用要求可以选择不同类型的模糊Prolog系统。     

QD-Janus: A sequential implementation of Janus in Prolog

Janus is a language designed for distributed constraint programming. This paper describes QD-Janus, a sequential implementation of Janus in Prolog. The compiler uses a number of novel analyses and optimizations to improve the performance of the system. The choice of Prolog as the target language for a compiler, although unusual, is motivated by the following: (i) the semantic gap between Janus and Prolog is much smaller than that between Janus and, say, C or machine language—this simplifies the compilation process significantly, and makes it possible to develop a system with reasonable performance fairly quickly; (ii) recent progress in Prolog implementation techniques, and the development of Prolog systems whose speeds are comparable to those of imperative languages, indicates that the translation to Prolog need not entail a significant performance loss compared to native code compilers; and (iii) compilation to Prolog can benefit immediately from a significant body of work on, and implementations of, parallel Prolog systems. Our experience indicates that translation of logic programming languages to Prolog, accompanied by the development of good program analysis and optimization tools, is an effective way to quickly develop flexible and portable implementations with good performance and low cost.     

High-performance logic programming with the Aquarius Prologcompiler

Aquarius Prolog, a high performance compiler designed and built to test the hypothesis that Prolog can be implemented as efficiently as an imperative language by compiling the more powerful features of logic programming only where they are needed, and then only in the simplest form, is described. The authors begin with some background on logic programming and then discuss the Prolog language in more detail. They present an overview of their compiler, giving its structure and the principles underlying its high performance. They compare their system with two popular high-performance commercial systems and with two implementations of C and conclude with an overview of ways to extend this work     

Logic programming and compiler writing

The concept of ‘logic programming’, and its practical application in the programming language Prolog, are explained from first principles. The ideas are illustrated by describing in detail one sizable Prolog program which implements a simple compiler. The advantages and practicability of using Prolog for ‘real’ compiler implementation are discussed.     

Issues in Ada compiler technology

The key technical issues involved in producing high-quality Ada compilers and related support tools are discussed. These include real-time issues, programming tools and environments, and code optimization. Also addressed are some important problems that compiler designers face, for example, determining which deficiencies of existing Ada systems can be attributed to the language and which are simply hard-to-implement features or unresolved issued in Ada compiler technology     

Modelling of space-efficient one-pass translation using attribute grammars

Automatic production of one-pass compilers from attribute grammars is considered. An examination of a one-pass grammar for the programming language Euclid shows that the present definition of one-pass grammars is too general: the space behaviour of the produced compilers differs from that found in conventional hand-written compilers. A new class of attribute grammars is defined. The class models naturally the use of space in a hand-written compiler. This implies that the compiler produced automatically on the basis of the grammar uses space in the same way as a practical hand-written recursive descent compiler. Furthermore, a graphical notation is introduced as a design tool for obtaining grammars in the proposed class.     

A prolog constraint handling rules compiler and runtime system

The most recent and advanced implementation of constraint handling rules (CHR) is introduced in a logic programming language. The Prolog implementation consists of a runtime system and a compiler. The runtime system utilizes attributed variables for the realization of the constraint store with efficient retrieval and update mechanisms. Rules describing the interactions between constraints are compiled into Prolog clauses by a compiler, the core of which comprises a small number of compact code generating templates in the form of definite clause grammar rules.     

Visual language implementation through standard compiler–compiler techniques

We present a technique for implementing visual language compilers through standard compiler generation platforms. The technique exploits eXtended Positional Grammars (XPGs, for short) for modeling the visual languages in a natural way, and uses a set of mapping rules to translate an XPG specification into a translation schema. This lets us generate visual language parsers through standard compiler–compiler techniques and tools like YACC. The generated parser accepts exactly the same set of visual sentences derivable through the application of XPG productions. The technique represents an important achievement, since it enables us to perform visual language compiler construction through standard compiler–compilers rather than specific compiler generation tools. This makes our approach particularly appealing, since compiler–compilers are widely used and rely on a well-founded theory. Moreover, the approach provides the basis for the unification of traditional textual language technologies and visual language compiler technologies.     

Testing syntax and semantic coverage of Java language compilers

Software testing is a critical and important stage of the application software development life-cycle. Testing is a verification activity that affects the overall software quality. The verification of critical and dependable computer software such as real-time safety-critical software systems consumes about 50% of the project time. In this work, we consider testing compilers. Since a compiler is a highly usable software, an increased emphasis on reliability requires a careful testing before releasing the compiler. In compiler testing, the compiler implementation is verified to conform to the specified language syntax and semantic available in the standard language documentation. In this work, an algorithm is designed and a tool is developed to automate the generation of test cases to check the language syntax. In addition, we propose a heuristic approach to cover language semantics. Since Java is a relatively new programming language, we concentrate on testing the adherence of new Java compilers to the language syntax and semantics.     

Machine independent AND and OR parallel execution of logicprograms. II. Compiled execution

For pt.I. see ibid., p. 170-80. In pt.I, we presented a binding environment for the AND and OR parallel execution of logic programs. This environment was instrumental in rendering a compiler for the AND and OR parallel execution of logic programs machine independent. In this paper, we describe a compiler based on the Reduce-OR process model (ROPM) for the parallel execution of Prolog programs, and provide performance of the compiler on five parallel machines: the Encore Multimax, the Sequent Symmetry, the NCUBE 2, the Intel i860 hypercube and a network of Sun workstations. The compiler is part of a machine independent parallel Prolog development system built on top of a run time environment for parallel programming called the Chare kernel, and runs unchanged on these multiprocessors. In keeping with the objectives behind the ROPM, the compiler supports both on and independent AND parallelism in Prolog programs and is suitable for execution on both shared and nonshared memory machines. We discuss the performance of the Prolog compiler in some detail and describe how grain size can be used to deliver performance that is within 10% of the underlying sequential Prolog compiler on one processor, and scale linearly with increasing number of processors on problems exhibiting sufficient parallelism. The loose coupling between parallel and sequential components makes it possible to use the best available sequential compiler as the sequential component of our compiler     

An optimizing compiler for the icon programming language

Compiling code for the Icon programming language presents several challenges, particularly in dealing with types and goal-directed expression evaluation. In order to produce optimized code, it is necessary for the compiler to know much more about operations than is necessary for the compilation of most programming languages. This paper describes the organization of the Icon compiler and the way it acquires and maintains information about operations. The Icon compiler generates C code, which makes it portable to a wide variety of platforms and also allows the use of existing C compilers for performing routine optimizations on the final code. A specially designed implementation language, which is a superset of C, is used for writing Icon's run-time system. This language allows the inclusion of information about the abstract semantics of Icon operations and their type-checking and conversion requirements. A translator converts code written in the run-time language to C code to provide an object library for linking with the code produced by the Icon compiler. The translation process also automatically produces a database that contains the information the Icon compiler needs to generate and optimize code. This approach allows easy extension of Icon's computational repertoire, alternate computational extensions, and cross compilation.