Open PROMOL: An Experimental Language for Target Program Modification

Size: px

Start display at page:

Download "Open PROMOL: An Experimental Language for Target Program Modification"

Darlene Cummings
6 years ago
Views:

1 Open PROMOL: An Experimental Language for Target Program Modification Vytautas Štuikys, Robertas Damaševičius, Giedrius Ziberkas Software Engineering Department, Kaunas University of Technology Studentų 50, LT-3031, Kaunas, Lithuania mailto: Abstract We present a short description of the capabilities of the experimental scripting language Open PROMOL. It has been developed aiming: 1) to deliver flexible means for representing wide range modifications of a target program, and 2) to support white-box reuse for well-understood domains, such as hardware design. We describe the syntax and semantics of the basic constructs of the language. We demonstrate the applicability of the language to perform modifications by widening, narrowing and isolating functionality in VHDL. Keywords Program modification, scripting language, VHDL models, component customization, design parameterization. 1. Introduction We present an experimental scripting language Open PROMOL, the Program Modification Language. It has been developed aiming: (a) to specify modifications of the components (or their parts) given in a target language (TL); (b) to specify gluing of the TL components (or their parts) into a target system; and (c) to use it for designing generic components and building generating systems. Originally the language wasn t dedicated to a particular domain, and was designed as a TL-independent one. This means that the language itself doesn t extend the functionality of a given TL. Its intention is only to express concisely the preprogrammed modifications of the TL code in a single specification. Of course, this may be done at some extent using the given TL only, e.g. in VHDL [1]. However, by introducing an external specific language, we can enhance the abstraction level significantly and express modifications more precisely, widely and flexibly, at the same time avoiding the overgeneralization of a target program. We motivate the need of the new textual scripting language by the following reasons: 1) To support white-box reuse for well-understood domains. 2) To deliver flexible means for representing wide range modifications. 3) To support the multi-language paradigm in system designs [2]. A great variety of scripting languages exists now, each with its own intention and specific capabilities. It s not our intention to provide a detailed analysis of the domain here. Some results can be found in [3-5]. Our approach has some similarities with Bassett s frame commands [6]. 2. Main concepts implemented in the language The proposed language implements the modification and scripting concepts. According to Ousterhout [3], the main idea of scripting is that an application developer is provided with a collection of useful components, and he (she) only has to write a small amount of wiring code in order to establish connections between components. It can take various forms, depending on the nature and granularity of the components, the framework of a domain problem, and the composition model.

2 Components themselves are highly parameterized domain entities such as gates, adders, multipliers, etc., which are generalized with PROMOL functions. The purpose of these functions is to perform the necessary modifications of the TL code during the generation process in order to receive a concrete instance of the component tailored to the specific needs of the developer. The combination of modification and scripting concepts (see Fig. 1) leads to the creation of parameterized systems [7], i.e., heavily parameterized architectures adaptable in terms of power, performance and size requirements. a) b) Gluing (scripting) a piece of target program a function of the scripting Modification Scripting Generic Component Instance Fig. 1. The interpretation of modification and scripting concepts at a lower- (a) and higher-level (b) 3. Basic features of the syntax and semantics Open PROMOL is a functional language and consists of an open set of external functions. The context of their usage is a prescribed specification. All modifications in the specification are represented as a specific composition of external functions with the TL code to be modified [8, 9]. Functions are called external because they represent a higher level of programming and have parameters, whose values are defined externally. A PROMOL function has the format as 1, argument 2,, argument n ] ; here n > 0. The denotes the beginning of the function, and the square brackets [] enclose the argument list of the function. We summarize a basic set of functions, their syntax and semantics in Tables 1 and 2, respectively. Each function has a list of arguments and returns a value, which is always a string of the TL. Arguments are either a constant, a parameter implicitly declared in the interface of a specification, an expression, or a composition of external functions and TL strings. A constant may be either a numeric literal of the language or a string literal written in a TL. A string might be either a part of a statement or the entire construct of the TL program to be generated. The functional programming paradigm allows us to achieve a great deal of flexibility, since a TL string may be transformed gradually by several functions, until it reaches its final form. The nested functions enable to achieve a deep and flexible external modification of the TL code to be processed. Open PROMOL is a string-oriented language. Everything (e.g., numbers, enumerated type variables, etc.) is a string. Because a particular type is recognized from the context, there are no attributes for the explicit declaration of the type. A value of the string type may be interpreted as a decimal number, a binary number or a string of text depending upon the context of the usage.

3 No. Function name Table 1. The description of the basic set of PROMOL functions No. of arguments Argument Meaning of argument Type of argument Actions performed by the 1 function 2 1 Expression Expression, function, Parameter value substitution, string of text expression calculation 2* Precision Decimal number 3 1 Condition Logical expression If-selection 2 Then branch Function, string of text 3* Else branch Function, string of text >2 1 Selector Arithmetic expression Case-selection >2 Branches Function, string of text 4 1 Loop parameter Loop parameter name For-loop 2 Initial value Arithmetic expression 3 Final value Arithmetic expression 4 Loop body Function, string of text 5 1 Number of substrings Arithmetic expression String generation 2 Separator Function, string of text 3* Substring Function, string of text 4* Initial index Arithmetic expression 5* Step Arithmetic expression 2 1 Parameter name Parameter name Value assignment 2 Assigned value Function, string of text 2 1 Number of repetitions Arithmetic expression Repetition of text 2 Script to be repeated Function, string of text >0 >0 External module names Module name External module declaration >1 1 External module name Module name External module instantiation >2* Parameter values Expression, function, string of text Table 2. Syntax and semantics of the PROMOL functions (subset) No. Function Examples of the usage Parameter value The returned value name V n ]; n := 2 V := 2; X: bit@if[ n>1, {_vector (0 ]; n := 4 X: bit_vector (0 to 3); Y n, {B1}, {B2}, {B3} ]; n := 2 Y <= i, 0, n-1, {L(@sub[i]) } ] n := 5 L(0) L(1) L(2) L(3) L(4) Y n, { AND }, {X}, 0 ]; n := 3 Y <= X0 AND X1 AND f, {NOT} ] f := NOT <null> X n, {@sub[sym]} ] ; n := 4; sym := 0 X <= gate ] gate, {AND}, n ] n := 2 2-input AND gate instance 4. Main capabilities of the language The language and its processor EREBUS implements the following capabilities: Generalization. In many cases, we can merge similar components into a single generalized (or generic) specification through the usage of the functions. Abstraction. We introduce two separate levels of abstraction: a higher level is referred to as the component (specification) interface, where specification parameters are defined, and a lower level is called the component implementation (specification body). Parameterization. Parameterization is a simple and understandable model for combining and customizing components. They are not constrained to a particular type (as, e.g., in C++ templates [10]), but can take string values of any length and content. The language implements two parameterization models: the conditional (the assignment of a value to a parameter depends on a condition), and the hierarchical ones (through deep nesting and the usage of external modules, which can form the tree-type structures). Separation of concerns. We clearly separate the abstractions of the scripting language from a given TL, the interface of the generalized specification from its implementation, and the development of a specification from its usage. 1 Optional arguments are shown with an asterisk *.

4 Composition. A particular set of the external functions used in the specification implements an internal composition in a natural way via the concatenation of strings. The usage of external modules allows a more sophisticated composition. Generation. There are specific functions for generating strings of a particular structure. Extension. The language is an open set of external functions, which are independent. Hence, the new ones (if needed) can be introduced easily. Modification. The language performs modifications of a target program using usual abstractions of structural programming (i.e., if, for, case, etc.). Independence from a TL. Open PROMOL treats TL program as a simple text without any particular meaning, and uses lexical mechanisms independent of any TL syntax and the usage context to perform the necessary modifications. Rapid prototyping. The language processor implements this feature through generation of either a selected instance or all instances prescribed by the generalized specification. Documenting. The user-oriented questions in the interface and comments in the specification body allow expressing the explanations in the natural language. 5. Case study: VHDL code modification via widening, narrowing & isolation Sametinger [11] has described four general methods for generalizing components. We have adopted some of them for the modification of VHDL code with Open PROMOL. The first example (Fig. 2, a) implements modifications by narrowing functionality with respect to the second example (Fig. 2, b). The latter one illustrates the modification by widening functionality. The generated instances are given in Fig. 2, c & d, respectively. "Select a function" {AND,OR,XOR,NOR,NAND,XNOR} f:=and; "Enter the number of inputs" {2..16} this is the promol a text between symbols is the gate1 is the name of the specification the specification implements any gate function (except NOT) -- this is an instance of GATE_@sub[f]_@sub[num] ENTITY GATE_@sub[f]_@sub[num] IS PORT (@gen[num, {, }, {X}, 1] : IN BIT; END GATE_@sub[f]_@sub[num]; ARCHITECTURE BEH OF GATE_@sub[f]_@sub[num] IS Y }, {X}, "Select a function" {AND,OR,XOR,NOR,NAND,XNOR,NOT} f:=and; [f neq {NOT}] "Enter the number of inputs" {2..16} this specification uses the external module the specification represents modifiication widening functionality with NOT the second question appears only when the condition is neq {NOT}, {@macro[gate1, f, num] }, { -- this is an instance of GATE_@sub[f] ENTITY GATE_@sub[f] IS PORT (X1 : IN BIT; END GATE_@sub[f]; ARCHITECTURE BEH OF GATE_@sub[f] IS Y <= NOT X1; }] -- this is an instance of GATE_OR_4 ENTITY GATE_OR_4 IS PORT (X1, X2, X3, X4 : IN BIT; END GATE_OR_4; ARCHITECTURE BEH OF GATE_OR_4 IS Y <= X1 OR X2 OR X3 OR X4; a) c) -- this is an instance of GATE_NOT ENTITY GATE_NOT IS PORT (X1 : IN BIT; END GATE_NOT; ARCHITECTURE BEH OF GATE_NOT IS Y <= NOT X1; b) d) Fig. 2. The modifications by narrowing (a), widening (b), (c) & (d)- their instances, respectively

5 The third example below demonstrates a modification by isolating functionality. For simplicity, we present it without the explicit VHDL context. Suppose, we need to include in several different places of a higher level design the slightly different components (fragments), which are given in the isolated files a1, a2, a3, a4. This might be represented in the PROMOL specification as k, {@macro[a1]}, {@macro[a2]}, {@macro[a3]}, {@macro[a4]} ]; where a1, a2, a3, a4 are file names; k is a parameter for the customization of a particular context of the usage. 6. Current status of the language and future development We use the language and its processor as an experimental tool for describing modification in several domains (program specialization, generation), including VHDL. Users are postgraduate students in computer science. Over more than two years, the current version of the language processor have passed through intensive experiments by more than 150 users. The future work relates to the development of the distributed version using the web-based technology. 7. Conclusions Open PROMOL is a functional scripting language aiming to describe the wide range of textual modifications of a target program. It uses lexical mechanisms independent of any target language syntax to perform the necessary modifications via the external functions. PROMOL specification is a higher level description, which manipulates with a program as data. Although there are no restrictions on the language usage, however, it suits best for wellunderstood domains, in which a great similarity of designs and a great deal of the repeatedly used look-alike models exist. Domain of hardware design with the great variety of its design languages is just the case. External functions combined together with the abstractions of a given HDL extend the modification capabilities flexibly. The language can be used to support design reuse through parameterization. References [1] R. Zimmermann, VHDL Library of Arithmetic Units, Forum of Design Languages (FDL 98), Lausanne, September [2] A. A. Jerraya, and R. Ernst, Multi-language System Design, DATE'99, Münich, Germany, March [3] J. K. Ousterhout, Scripting: Higher Level Programming for the 21 st Century, IEEE Computer 31(3), pp , March [4] J. G. Schneider, and O. Nierstrasz, Components, Scripts and Glue. In L. Barroca, J. Hall, and P. Hall (Eds.), Software Architectures Advances and Applications, pp Springer, [5] J.-G. Schneider, Components, Scripts, and Glue: A conceptual framework for software composition, Ph.D. thesis, University of Bern, Institute of Computer Science and Applied Mathematics, October [6] P.G. Bassett, Framing Software Reuse: Lessons from the Real World. Prentice Hall, Inc., [7] T. Givargis, and F. Vahid, Parameterized System Design, Proceedings CODES 2000, pp , [8] V. Štuikys, and R. Damaševičius, Scripting Language Open PROMOL and its Processor, Informatica, Vol. 11, No. 1, pp , [9] V. Štuikys, G. Ziberkas, R. Damaševičius, and G. Majauskas, Two Approaches for Developing Generic Components in VHDL, Proceedings DATE 2001, p IEEE Computer Society Press, [10] T. L. Veldhuizen, Using C++ template meta-programs, C++ Report 7(4), pp , [11] J. Sametinger, Software Engineering with Reusable Components, Springer, 1997.

Soft IP Design Framework Using Metaprogramming Techniques

Soft IP Design Framework Using Metaprogramming Techniques Vytautas Stuikys, Robertas Giedrius Ziberkas, and Giedrius Majauskas Kaunas University o/technology. Software Engineering Department Studentu 50.