在Win32汇编语言环境下开发网络通讯功能

采用Win32汇编语言实现了一个基于TCP／IP协议的网络通信功能。程序开发及运行结果表明,与传统汇编相比,在Windows操作系统下的Win32汇编具有高级语言的优点,能够以最灵活的方式调用系统封装函数,软件开发效率大为提高;与高级语言相比,Win32汇编应用程序占用内存资源少,运行速度快,保留了传统汇编的优点。     

An algol-like assembly language for a small computer

In a classic paper¹ Wirth describes a language which combines the readability of ALGOL 60 with the flexibility and degree of control of a conventional assembly language. This paper gives an outline of a similar language for a small 16-bit computer—the Honeywell DDP-516. Implementing the compiler in its own language by recoding an ALGOL version of the compiler has shown that the language is suitable for large systems. With the compiler written in a high-level language, many enhancements have been possible even though these were not envisaged in the original coding This use of the language clearly demonstrated that a high-level assembly language can be a very effective tool for a small machine as well as for computers like the 360 series.     

FOXBASE与其他语言的混合编程综述

ＦＯＸＢＡＳＥ、汇编及各种高级语言各有所长，如采用ＦＯＸＢＡＳＥ与其他语言混合编程就可以兼得双方之长，继承优秀软件成果，充分利用软硬件资源。本文综述了ＦＯＸＢＡＳＥ与高级语言、汇编语言的混合编程技术，以及它们之间的数据通讯方法。阐明了高级语言程序、宏汇编程序如何调用ＦＯＸＢＡＳＥ程序；ＦＯＸＢＡＳＥ又如何调用宏汇编和Ｃ语言程序；ＦＯＸＢＡＳＥ和高级语言在文本文件和桥的基础上如何互相通讯；高级语言如     

汇编语言在当今软件设计领域中能否生存

汇编语言是一门低级程序设计语言,它主要的功能是直接对硬件进行控制.虽然它是一门面向机器的语言,在可读性和移植性方面不及高级程序设计语言好,但用它所编写出来的程序能够在各种控制芯片上直接执行,具有效率高、反应快的特点,这是其它高级程序设计语言所无法超越的,所以汇编语言在当今软件设计领域中是无法被其它高级程序设计语言所替代的.     

Heap-Bounded Assembly Language

We present a first-order linearly typed assembly language, HBAL, that allows the safe reuse of heap space for elements of different types. Linear typing ensures the single pointer property, disallowing aliasing but allowing safe, in-place-update compilation of programming languages. We prove that HBAL is sound for a low-level untyped model of the machine, using a satisfiability relation that captures when a location correctly models a value of some type. This interpretation is closer to the machine than previous abstract machines used for typed assembly language models, and we separate typing of the store from an untyped operational semantics of programs, as would be required for proof-carrying code. Our ultimate aim is to design a family of assembly languages that have high-level typing features for expressing resource-bound constraints. We want to link the assembly-level with high-level languages expressing similar constraints, to provide end-to-end guarantees and a viable framework for proof-carrying code. HBAL is a first exemplifying step in this direction. It is designed as a target low-level language for Hofmann's LFPL language. Programs written in LFPL run in a bounded amount of heap space, and this property carries over when they are compiled to HBAL: the resulting program does not allocate store or assume an external garbage collector. Following LFPL, we include a special diamond resource type that stands for a unit of heap space of uncommitted type.     

The construct of a high-level computer language for programmable assembly

In recent years, considerable effort has been devoted to developing and extending programming languages for manipulation of computer-controlled robotic arms for various tasks. The present trend is to develop high-level languages that simplify the programming task so that they can be used by a less well-trained person with ease and speed. In this article, the information required for assembly is examined and a construct of a new computer language is proposed. An example of a computer program using the proposed language for assembling a pencil sharpener is given. This program is compared with similar program written in another language currently being developed and extended.     

Interfacing Indigolog and OAA: A Toolkit for Advanced Multiagent Applications

In this paper, we describe an interface library IG-OAAlib that supports the development of Open Agent Architecture (OAA) agents using the INDIGOLOG agent programming language. OAA is a multi-agent infrastructure that supports facilitated communication. INDIGOLOG is a high-level agent programming language based on logic that supports planning and allows complex agent behaviors to be specified. Full-fledged INDIGOLOG agents written using our interface library can be both reactive and proactive, thus overcoming one of the limitations of PROLOG-based agents in the OAA framework. The interface hides all of the low-level procedures that are used to communicate with the OAA system, as well as OAA initialization, thereby leaving the INDIGOLOG programmer free to concentrate on the functionality of the agent. A multi-robot mail delivery application developed using the library is presented.     

一个经过证明的类型化汇编语言的类型检查器

编程语言类型系统的类型安全性可以保证程序运行时满足基本安全属性,包括控制流安全, 内存安全等.类型化编程语言都需要一个类型检查器来检查程序的良类型性,因此编程语言的具体实现是否能保证类型安全性,还依赖类型检查器的可靠性.本文给出一种类型化汇编语言,然后给出相应的类型检查器,并证明了此类型检查器的可靠性,从而保证经过类型检查的汇编程序的安全性.文本的所有工作,包括类型化汇编语言、类型检查器以及相关定理证明,均已在证明辅助工具Coq中实现.本文方法也可用于证明类型化高级语言的类型检查器的可靠性.     

A concurrent abstract interpreter

Abstract interpretation [6] has been long regarded as a promising optimization and analysis technique for high-level languages. In this article, we describe an implementation of aconcurrent abstract interpreter. The interpreter evaluates programs written in an expressive parallel language that supports dynamic process creation, first-class locations, list data structures and higher-order procedures. Synchronization in the input language is mediated via first-class shared locations. The analysis computes intra- and inter-threadcontrol anddataflow information. The interpreter is implemented on top of Sting [12], a multi-threaded dialect of Scheme that serves as a high-level operating system for modern programming languages.     

Nautilus, a Concurrent Diagrammatic Specification and Programming Language

Nautilus is a high-level specification and programming language having abstraction mechanisms not commonly found in other programming languages inspired by its semantic domain (a categorial model named Nonsequential Automata). It constitutes an elegant solution for concurrency and non-determinism as well as for synchronization of concurrent systems. The role as specification language highlights the diagrammatic syntax (it was originally text based).The diagrammatic syntax for Nautilus allows complete programs to be written using symbols and graphical diagrams. The graphical notation was elaborated in order to be able to express all the structures in the language, yet trying to improve the visualization of written programs. A brief comparison with UML is included. To support Nautilus as a programming language, a mapping to Java is constructed, setting the basis for an execution environment of Nautilus specifications.     

A mechanically verified language implementation

This paper briefly describes a programming language, its implementation on a microprocessor via a compiler and link-assembler, and the mechanically checked proof of the correctness of the implementation. The programming language, called Piton, is a high-level assembly language designed for verified applications and as the target language for high-level language compilers. It provides executeonly programs, recursive subroutine call and return, stack based parameter passing, local variables, global variables and arrays, a user-visible stack for intermediate results, and seven abstract data types including integers, data addresses, program addresses and subroutine names. Piton is formally specified by an interpreter written for it in the computational logic of Boyer and Moore. Piton has been implemented on the FM8502, a general purpose microprocessor whose gate-level design has been mechanically proved to implement its machine code interpreter. The FM8502 implementation of Piton is via a function in the Boyer-Moore logic which maps a Piton initial state into an FM8502 binary core image. The compiler and link-assembler are both defined as functions in the logic. The implementation requires approximately 36K bytes and 1400 lines of prettyprinted source code in the Pure Lisp-like syntax of the logic. The implementation has been mechanically proved correct. In particular, if a Piton state can be run to completion without error, then the final values of all the global data structures can be ascertained from an inspection of an FM8502 core image obtained by running the core image produced by the compiler and link-assembler. Thus, verified Piton programs running on FM8502 can be thought of as having been verified down to the gate level.This work was supported in part by the Defense Advanced Research Projects Agency under DARPA Orders 6082 and 9151, contract MDA904-87-C-H009.     

Executing continuation semantics: A comparison

Several authors have suggested translating denotational semantics into prototype interpreters written in high-level programming languages to provide evaluation tools for language designers. These implementations have generally been understandable when restricted to direct denotational semantics. This paper considers using two declarative programming languages, Prolog and Standard ML, to implement an interpreter that follows the continuation semantics of a small imperative programming language, called Gull. Each of the two declarative languages presents certain difficulties related to evaluation strategies and expressiveness. The implementations are compared in terms of their ease of use for prototyping, their resemblance to the denotational definitions, and their efficiency.     

A tale of assembly

The author takes us back to the days when assembly language programming was still a large part of the computing scene with a story of how the user group Share influenced IBM on assembly languages just when the company had decided to concentrate on the new high-level languages     

TD-LTE系统中秩指示的编码及DSP实现

秩指示RI是3GPP LTE系统中一种重要的MIMO反馈信息.3GPP协议给出了RI的编码方法,是一种简单的线性分组码.采用TI TMS320C6455定点DSP,编程实现协议规定的编码,方法为循环查表法,采用的编程语言为汇编,仿真平台为CCS3.3.该方案算法简单、耗时少,已应用于TD-LTE无线综合测试仪表的开发中...     

SLAN-4?A Software Specification and Design Language

SLAN-4 (``Software Language-4') was developed to meet the need for a formal tool for specifying and designing large software systems. It provides language constructs for algebraic and axiomatic specifications and also pseudocode constructs for the design step. A major design goal was to ease subsequent refinements of a (given) specification. The design can start with a very informal specification, which can be implemented later using lower level concepts. This paper gives an overview of the SLAN-4 syntax and semantics. It concentrates on the most important aspects of: ? abstract data types, ? algebraic specification of abstract data types, and ? axiomatic specification of modules. Because the pseudocode part of SLAN-4 consists mainly of control structures similar to those in modern high-level programming languages, this element of the language is not separately described. The paper includes an example of how to use SLAN-4, and also the experiences gained in using the language to formally specify a real-world software product of about 18 000 lines of code written in an IBM internal high-level language.     

The MCEF code for nuclear evaporation and fission calculations

We present an object oriented algorithm, written in the Java programming language, which performs a Monte Carlo calculation of the evaporation-fission process taking place inside an excited nucleus. We show that this nuclear physics problem is very suited for the object oriented programming by constructing two simple objects: one that handles all nuclear properties and another that takes care of the nuclear reaction. The MCEF code was used to calculate important results for nuclear reactions, and here we show examples of possible uses for this code.     

Knowledge-based program analysis

Automatic program analysis is regarded here as both the mechanized process of understanding high-level concepts from program text and the use of those concepts to guide program maintenance. A knowledge-based program analysis tool called PAT, which realizes this concept, is described. PAT uses an object-oriented framework to represent programming concepts and a heuristic-based concept-recognition mechanism to derive high-level functional concepts from the source code. As an example, a segment of a much larger program written in a Pascal-like language is analyzed using PAT