DE19622365B4 - Method for a converter for implementing source code - Google Patents

Abstract

Method for a converter for converting source code of a high-level language such as C / C ++, Fortran or Java into a bit stream for a transmission, wherein a receiver-side reconstruction provides a syntactically and logically equivalent program code, characterized
That an abstract tree generated by means of parsing is coded in a bit-efficient manner, the reserved speech words, but also the special characters and operations being assigned fixed bit sequences which require substantially fewer bits than the direct representation of the reserved speech words and operators / special characters in the computer,
That short bit sequences are allocated to reserved or special-language words for the purpose of determining the converter
That by means of lexical analysis the symbols are assigned short bit sequences,
That constants are also converted into bit sequences on the basis of the lexical analysis,
That statements such as declaration, function call, arithmetic instruction, etc., keywords are assigned as short bit sequences,
- that the structure of a particular subtree is specified, if this ...

Description

The The invention relates to a method for a converter for the implementation of source code according to the preamble of the patent claim 1 specified type.

converter from program code to a bitstream for the translation of source code are known in principle. For example, in the ISO / IEC expert group MPEG in developing standard MPEG-4 source code or program code with transfer be on the receiving end to generate the decoder. Also in other areas where program code transfer must be and a transparent transfer is not required is, that is the transferred one Code must be compiled before use in the decoder and no further processing of the code on the receiver side can take place such a converter can be used.

The known converter of program code in a bit stream for transmission however, have the disadvantage that they are not bit efficient.

One generic converter for the conversion of source code is from the article of TZAY Y, YOUNG, PHILIPS S. LIU, "Overhead Storage Considerations and Multilinker Method for Data File Compression ", IEEE Transact. On Software Engineering, from SE-6, no. 4, July 1980, p. 340-347. Here is a translator for translating source code of a high-level language, such as C / C ++, Fortran, or Java into a bit stream for a transmission, being a receiver-side Reconstruction a sysntaktisch and logically equivalent program code supplies.

Of the Invention is therefore the object of a converter for Implementation of source code to improve a source code, that is written in a high-level language, so converted into a bit string is that on the one hand as possible small amount of bit is required and the other after a transmission a syntactically and logically equivalent program code is created.

These Task is achieved by the characterizing features of claim 1 solved in conjunction with its generic features.

Further Features and embodiments will become apparent from the dependent claims.

To The invention provides a method for a converter for implementation source code of a high-level language such as C / C ++, Fortran or Java into a bitstream for a transmission provided. A receiver side Reconstruction provides a syntactically and logically equivalent Program code. This is an abstract generated by syntax analysis Tree coded in a bit-efficient manner, using the reserved speech words, but also the special characters and operations are assigned fixed bit sequences, which require much less bits as the direct representation of the reserved speech words and operators / special characters in the calculator. In addition, reserved for the determination of the converter or special short words associated with specific speech words. through lexical analysis, the symbols are assigned short bit sequences. Due to lexical analysis, constants also become bit sequences implemented. Statements like declaration, function call, arithmetic Instruction u. s. w., become keywords assigned as short bit strings. The structure of a respective subtree is specified if this structure is not unique with the keyword is fixed. Keywords and bit strings are uniquely combined. For symbols, the outside must be known becomes the assignment of the symbol to the internally used bit string with transfer. Only more common occurring combinations are assigned their own bit sequences, and the program to be implemented consists of several modules and function names, Class names and method names associated with short bit strings be so for all symbols above a uniform table takes place an assignment of bit sequences.

By these measures becomes a direct bit efficient converter of program code into one Bitstream for the transfer created. The receiver side Reconstruction provides a syntactically and logically equivalent Program code.

To the abstract tree generated by the parsing becomes bit-efficient Encoded with the reserved speech words, but also the Special characters and operators are assigned fixed bit sequences, which require much less bits as the direct representation of the reserved speech words and operators / special characters in the calculator. It can frequently occurring combinations own bit sequences are assigned.

Consists a program of several modules, so the function name, Class names and method names also associated with short bit strings; the length the bit string depends from the number of names. As far as these original names known to the recipient have to be because, for example, not the entire package is transmitted, this must be Transfer table with become. Otherwise, this is not required, the corresponding Bit sequences can new names are assigned. Are the original names already at the receiver? known and the corresponding modules already exists, so is this table is also required.

at the global variables, structures and instances are similar Applied principles. Again, the original name at the receiver usually not required, so that on the transfer of an assignment from original names to bit sequences can be dispensed with. Otherwise This assignment must be transferred in tabular form, at least for those Original names whose knowledge is required in the consignee.

at local variables, structures and instances is the transmission the assignment is not required, other names can be selected for the recipient.

The Assigned bit strings should be kept as short as possible. Become for codes constant length used, that is all variable names are assigned the same length of the bit sequence, so can the length n the bit sequence can be easily calculated by forming the logarithm to base 2 of the corresponding number and rounding to the next larger whole Number. It must then either the length of the bit sequence or the number the variable name with transferred become. When using variable length codes must beforehand for optimal allocation the frequency the occurrence are determined. The code used must then be sender- and be known at the receiving end.

The Representation of constants and strings can be either uniform over strings where strings are represented in ASCII form (with 7 or 8 bits) become. If the constants are numbers then they will turn out efficiency, not in the preferred implementation to the ASCII representation resorted. Integer numbers are used in this realization with the below coded n * (7 + 1) -bit method, the numbers of any Process size can. Numbers in floating-point representation with single or double Accuracy is represented as two integers, where the integer numbers either as a mantissa and exponent or as an integer and decimal value are interpreted.

These Bit sequences are selected in this way and syntactically meaningfully combined so that a unique and decodable Bitstream arises, which is the reconstruction of a syntactic and logically equivalent program allowed.

The Invention will now be described with reference to an illustrated in the drawings embodiment described in more detail.

It demonstrate:

1 Phases or steps of program translation;

2 a simplified example of an abstract tree generated by the parsing and

3 Steps to determine the converter.

in the Following is an example of given a compression. Here is the compressed bitstream essentially of code symbols of fixed length. The example refers to the programming language C / C ++ and does not describe the full Language scope, but can easily be expanded to the full extent become.

Each high-level language program consists of several different parts and types of instructions. Each part or instruction type begins in this implementation with a corresponding "start code", the length of which depends on the number of start codes required. An example of the most essential types of statements is given in Table 1. For the description of the full language scope further start codes are needed. #include 00010 #define 00011 Definition of global variables 00100 Definition of local variables 00101 Definition of a method 00111 Calling a method (of a class) 01001 Calling a method with assignment 01010 Instantiating a class 01000 Start of the "main" program 01011 End of the "main" program or class 01100 execute statement 01,101 "while" statement 01110 "end of while" 01111 "for" statement 10000 "end of for" 10001 "if" statement 10010 "else" statement 10011 "end of if" 10100 Definition of a class 10101 Calling a function or a module 10110 Table 1 Start codes for program parts or instructions

in the following are examples of given some of these program parts or instructions.

Representation of integer numbers

The The following type of representation of integers is in this realization used: The sign is over 1 bit signals that the amount has been converted to the dual number system. This presentation will be in pieces the length divided by 7 bits. The number of pieces gives the for the transfer needed Number of bytes. The still free bit of the byte will be signaled occupied, whether for the display is followed by further bits (n * (7 + 1) -bit representation).

The "include" part

If files known to the compiler are inserted by the "include" statement, then each of these known files can be assigned a code symbol. An example of this is given in Table 2. <Fstream.h> 1000 <String.h> 1001 <Iostream.h> 1010 <CTYPE.H> 1011 <Stdio.h> 1100 <Stdlib.h> 1101 Table 2 Codewords for known files

The part with include statements has the following form in this realization:
#include <fstream.h>
#include <string.h>
#include <iostream.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>,
so it can then be represented by the following bit sequence, in which first the binary assignment for "#include" comes, then is marked by a bit, whether it is the compiler known files or their own files. This is followed by the number of files known to the compiler, and then the codes for each file. Since no negative numbers can occur, the signaling for the sign is omitted here. This results in the following bit sequence:
00010 0 0000110 (0) 0110 0001 0010 0011 0100 0101

Definition of global / local variables

The reserved speech words for elementary data types are again represented by codes. An example of this is given in Table 3. int 0001 const 1001 char 0010 static 1010 short 0011 signed 1011 long 0100 unsigned 1100 float 0101 * 1101 stand-in 0110 [] 1110 void 0111 Table 3 Reserved language words for elementary data types

A Syntactically meaningful coding can take place here similar to the "include" part: First comes the start code, then the number of data type definitions. In this case, the right part may be as shown in Table 3 Speech words in addition to the words on the left side of the table occur. With the simple rule that first the codes for the speech words transferred to the right side uniqueness in the bitstream can be achieved. This means that after the codes for "unsigned", "const", "static", "singed", "*" and "[.]" always another code for one of the speech words "int", "char", "short", "long", "float", "double", "void" is expected. at Fields will also occur after "[.]" the code for the Variable names will still have a corresponding number of integer values expected. The reconstruction is clear.

The variables can simply be numbered, the amount of bits required for the coding can either be calculated from the number of variables - if they are also transmitted - or they must be transferred as well. Number of variables Number of bits required for representation in the bit stream 2 1 4 2 8th 3 16 4 32 5 ... ... Table 4 Number of bits required to display the variable name or instance name.

example

• char * element;
• char * buffer [1000];
• int matrix [10] [10];
• then gives the following bitstream:
• 00100 (start code) 0000011 (0) (number of variables)
• 1101 ("*") 0010 ("char") 00 (zeroth variable)
• 1101 ("*") 1110 ("[]") 0010 ("char") 01 (first variable)
• 0000111 (1) 1101000 (0) (field size) 1110 ("[]") 1110
• ("[]") 0001 ("int") 10 (second variable)
• 000110 (0) (field size)
• 000110 (0) (field size)

On the receiver side, this can then be reconstructed to:
char * v 0;
char * v1 [1000];
int v2 [10] [10];
with different names for the variables. Of course, in the decoder these names have to be used in a consistent way.

Beginning of the "main" program

The Episode: "main () {" can simply through the start code will be played. The corresponding code for "end of program" will then be in the decoder implemented in "};". At handover of arguments appropriate extensions take place.

instantiation

The Instance formation of C ++ is analogous to the definition of elementary Basic types. Any necessary transmission of the assignment of Original class name for representation in a bit sequence takes place before Instantiation takes place.

example

• Class name * kl_instance; results, except for the start code and the number of instances to be formed, 1101 (*) 001 (Bit sequence for the class name) 0000 (instance number 0), assuming that 3 bits for the class name and 4 bits for an instance is required.

Definition of methods

Has been distinguished between elementary data types, structures and classes, this means were for each type creates its own bitmap tables, as in This realization, so must after the start code signaling done, what for a data type for the return is provided, otherwise this signaling can be omitted. The data type for the return parameter can then be specified accordingly. Become like this Realization, the code words for Structures and classes started with a "0" (analogous as in Table 3, the code words for elementary data types), so can also the additional ones Data types of the right side of Table 3 are used, the uniqueness is then guaranteed. Below is the code for the class name, the code for the name of the method and another bit to signal if this method is called with parameters. If so, then the number can follow and the parameters can be analog be coded to define the variables / structures / instances. This is natural make sure that either the amount of bits used is large enough is to represent class internal parameters and arguments with it to be able to or a corresponding signaling is used.

Calling a method

If an assignment does not take place at the same time, then the start code will come first, then the bits for the class instance. The subsequent "." or "->" can be transmitted with a signaling bit. It then follows the bit sequence for the method. In general, the number of arguments is not known, so there is a signaling, if and if so, how many arguments exist. These are then also converted into bit sequences. If variables, structures, instances and methods / functions do not have a uniform bit sequence assignment, then, if the definition of the function / method is not known and the data type is not known to the decoder, it must be signaled by, for example, 2 bits by which Type, which is the respective argument.

execution instructions

Most execution statements are quite short, and often the sequence of variables / structures / instances (v), special characters / operators (o), and constants / strings (c) is often present, so it makes sense to have one for common ones own code to use. It can also special instructions such as "variable ++;" or "variable = 0;" get your own code. A brief example of such assignment is given in the following table. Before the constants / strings are encoded, a signaling is set indicating what they are about. vovov 00001 ov 00010 vo 00010 vov 00100 vovovo 00101 voc 00110 vovoc 00111 vp 01000 var ++ vz 01001 var = 0 vi 01010 var = integer empty 00000 escape 11111 escapedg 11110 var [...] = ... Table 7 Example of the assignment of some frequent sequences of variables / structures / instances (v), special characters / operators (o) and constants / strings to bit sequences

The code specified in the following table for the special character ";" only occurs in conjunction with "escape". If the sequence of variables / structures / instances (v), special characters / operators (o) and constants / strings (c) is known, the special character ";" not mandatory. + 00001 ++ 00101 - 00010 - 00110 * 00011 + = 01000 / 00100 - = 01000 ! 01010 && 01001 < 01111 ! = 01011 > 10001 or 01,101 [ 10010 << 01,101 ] 10011 >> 01110 = 10100 <= 10101 & 11001 > = 10110 ( 11010 * = 10111 ) 11011 & = 11000 ; 11111 (( 11100 )) 11101 ] = 11110 Table 8 Example for the assignment of special characters to bit sequences

In the following example, the start code is not listed, four bits are needed for the representation of variables. The distinction between variables, structures, instances and methods / function calls is done here with a 2-bit flag. i ++; 01000 (vp) 01 (variable follows) 0010 (second variable) loop = 0 01001 (vz) 0011 (third variable) buffer [i] = '2'; 0011 (vovoc) 01 (variable follows) 0001 (first variable) 10010 (special character: [) 01 (variable follows) 0010 (second variable) 11110 (special character:] =) 00000110 (3 byte ASCII follow) '2' (in ASCII transfer) buf = buffer [i]; 00101 (vovovo) 01 (variable follows) 0100 (fourth variable) 10100 (special character: =) 01 (variable follows) 0001 (first variable) 10010 (special character: [) 01 (variable follows) 0010 (second variable) 10011 (special character: ])

To assign bit strings to more complex statements whose order is not listed in the above table, escape can be used with a modified syntax structure, the structure of which is best shown in the following example. Through appropriate signaling is always specified what to expect next:
Variable / Structure / Instance
Special characters / Operator
Function / method call

In cases in which this signaling is not sufficient, followed by a second Signaling.

example

The instruction buffer [i] = ((i + k) / (buf-1)) && buffer [k]; Then, apart from the start code, the following bit sequence can be assigned:
11111 (escape) 01 (variable / structure / instance follows) 01 (variable follows) 0001 (first variable) 10 (special character / operator follows) 10010 (special character: [) 01 (variable / structure / instance follows) 01 (variable follows) 0010 (second variable) 10 (special character / operator follows) 11110 (special character:] =) 10 (special character / operator follows) 11111 (code for command end), etc.

The Use of "escape" required in generally a larger amount of bits as if one of the predefined sequences of variables / structures / instances (v) special characters / operators (o) and constants / strings (c) used becomes.

Control statements ("for", "while", "if", "else") "for":
After the language word "for" become 3 expressions, separated by ";" expected in brackets, where commas are allowed in these expressions. After the start code for the "for" instruction, three execution instructions follow directly, which of course can also be empty. On the receiver side, the corresponding syntax is restored with "for (..; ..; ..) {".

For the end The loop is also transmitted a corresponding "start code". In between, any Instructions are given.

In the following example, "k" is the 14th variable and "element" is the 1st variable. The instruction for (k = 0; k <element; k ++) { can then give the following bit sequence:
10000 (start code)
first expression:
01001 (vz) 01 (variable follows) 1110 (14th variable)
second expression:
00100 (vov) 01 (variable follows) 1110 (14th variable) 01111 (special character: <) 01 (variable follows) 0001 (1st variable)
third expression:
01000 (vp) 01 (variable follows) 1110 (14th variable)

"While"

Of the There is a difference to the "for" statement exclusively in the number of terms following in parentheses, the Syntax can be done analogously.

"If"

Analogous expected to "while" statement the "if" statement is also an expression, the syntax is analogous to "while". The start code for the end the "if" loop is then implemented in the decoder in "};", the code for the "else" statement is in receiver implemented again in "} else {", so that no code has to be given before the "else" statement, which gives the end of the "if" statement. The "elseif" statement must also generate "}", but otherwise expects also an expression.

Claims (7)

Method for a converter for converting source code of a high-level language such as C / C ++, Fortran or Java into a bit stream for a transmission, wherein a receiver-side reconstruction provides a syntactically and logically equivalent program code, characterized in that - an abstract tree generated by parsing is coded in a bit-efficient manner, wherein the reserved speech words, but also the special characters and operations fixed bit sequences are assigned, which require much fewer bits than the direct representation of the reserved speech words and Operato ren / special characters in the computer, - that are assigned to the converter reserved or special-language words short bit sequences, - that the symbols short bit sequences are assigned by lexical analysis, - that also constants are converted into bit sequences due to the lexical analysis, - that statements such as declaration, function call, arithmetic statement etc, keywords are assigned as short bit strings, - that the structure of a respective subtree is specified, if this structure is not clearly defined with the keyword, - that keywords and bit strings are combined in a unique way, - that for symbols which must be known to the outside, the assignment of the symbol to the internally used bit sequence is transmitted with, - that only frequently occurring combinations own bit sequences are assigned, and - that the program to be implemented consists of several modules and Funktionsn names, class names and method names the short bit sequences are assigned, so that for all symbols via a uniform table, an assignment of bit sequences. Method according to claim 1, characterized that when using variable length codes for the symbols, for example in Huffmann or entropy coding, determines the frequency of each symbol and a corresponding assignment to bit sequences as possible short length done and / or for the reserved speech words, including special characters and operators, the frequency each reserved speech word is determined and a corresponding one Assignment to bit sequences possible short length he follows. Method according to claim 1, characterized that when using fixed length codes for the symbols be assigned to these corresponding bit sequences, the length of the Bit sequence depends on the number of symbols and the length or transfer the number with will and / or for reserved speech words (including special characters and operators) these fixed bit sequences are assigned to the much less Need bits as the direct representation. Method according to claim 2 or 3, characterized that for each type of symbol, such as variable name, function name, class name, Instance creates its own symbol table and thus the assignment separated from bit sequences and that in unclear cases the Transmit symbol type with becomes. Method according to claim 1, characterized then the assignment of original symbol names to the bit strings additionally transmitted will, if this at the receiver must be known. Method according to claim 3, characterized that when using fixed length codes the Length of Bit sequence is calculated by forming the logarithm to the base 2 from the corresponding number and rounding to the next larger whole Number, in which case either the length the bit sequence or the number of variable names with becomes. Method according to one of the preceding claims, characterized characterized in that the representation of constants and strings uniform over Strings, with the strings represented in ASCII form and that integers are coded with the n * (7 + 1) bit method be, where numbers in floating point representation with simple or double precision than two integers and the integer numbers either as a mantissa and exponent or as Pre-comma and post-comma values are interpreted.