DE19622365A1 - Translator for transmitting source code for high level language, e.g. C, C++, Java, Fortran - Google Patents

Abstract

The device translates the source code into a bit stream for transmission. The receiver reconstruction end provides a syntactical and logic equivalent program code. An abstract tree generated by syntax analysis is encoded in a bit efficient manner. The translator set bit streams are allocated to reserved or special spoken words. Short bit streams are allocated to the symbols by lexical analysis. On the basis of the analysis even constants are translated into bit streams. Instructions, e.g. a declaration, a function call up, arithmetic instructions and key words are allocated to short bit streams. The structure of a partial tree is provided if this structure is not unequivocally set to the key word. The key words and bit streams are combined in an unambiguous manner. For symbols which must be recognised externally the allocation of the symbol is transmitted to the internally used bit streams.

Description

The invention relates to a converter for the transmission of Source code according to the preamble of claim 1.

Converter of program code into a bit stream for the Transfer are generally known. For example, must at the in the ISO / IEC expert group MPEG in the Development of the standard MPEG-4 source code or Program code to be transmitted to the recipient to generate the decoder. Also in other areas, in which program code must be transmitted and a transparent transmission is not required, that is the transmitted code compiles in the decoder before use and no further processing of the code Such a converter can take place at the receiving end to be used.

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

The invention is therefore based on the object Converter for the transmission of source code to that effect improve that a source program that in a High-level language is written, converted into a bit sequence on the one hand, the smallest possible bit quantity is required and secondly after a transfer Syntactically and logically equivalent program code arises.

The solution according to the invention is in the characterizing part of Characterized claim 1.  

Further features and configurations result from the claims subsequent to claim 1.

These measures make it more direct bit efficient Converter of program code into a bit stream for the Transmission created. Reconstruction on the receiver side provides a syntactically and logically equivalent Program code.

To do this, the abstract tree generated by the syntax analysis encoded in a bit-efficient manner, with the reserved Language words, but also the special characters and operators fixed bit sequences are assigned, which are much less Bits need as the direct representation of the reserved Language words and operators / special characters in the computer. Here combinations that occur more frequently can have their own bit sequences be assigned.

If a program consists of several modules, the Function names, class names and method names as well short bit sequences assigned; the length of the bit string depends depends on the number of names. So much for these original names must be known to the recipient, for example not the entire packet is transmitted, this table must be included be transmitted. Otherwise, this is not necessary new names can be assigned to the corresponding bit sequences will. Are the original names already at the recipient known and the corresponding modules already exist, see above this table is also required.

The global variables, structures and instances similar principles applied. They are here too Original names are usually not required for the recipient, see above that on the transfer of an assignment of original names bit sequences can be dispensed with. Otherwise, this must Assignment are transferred in tabular form, at least for  those original names whose knowledge is in the recipient is required.

For local variables, structures and instances, this is Transfer of assignment not necessary when Other names can be selected for recipients.

The assigned bit strings should be as short as possible being held. For this purpose, codes of constant length is used, i.e. all variable names are the same Assigned longer to the bit sequence, the length n of the Bit sequence can be calculated simply by forming the Logarithm to base 2 of the corresponding number and Rounding to the next larger whole number. Then it has to either the length of the bit string or the number of Variable names are also transferred. When using Codes of variable length must be used for optimal allocation the frequency of occurrence must be determined beforehand. Of the The code used must then be known on the sender and receiver side be.

The representation of constants and strings can either consist of strings, where Character strings shown in ASCII form (with 7 or 8 bits) will. If the constants are numbers, then is in the preferred implementation for reasons of efficiency did not use the ASCII representation. Integers are in this implementation with the The n * (7 + 1) bit method described below encodes the numbers can process any size. Numbers in Floating point display with single or double Accuracy is represented as 2 integers, where the integers are either mantissa and exponent or interpreted as pre-decimal and post-decimal values.  

These bit sequences are selected in this way and make sense syntactically combined so that a clear and decodable Bitstream arises, which is the reconstruction of a syntactic and logically equivalent programs allowed.

The invention is now based on one in the drawings illustrated embodiment described in more detail.

The following is shown in the drawing:

Fig. 1 phases or steps of program translation;

Fig. 2 is a simplified example of a generated by the syntax analysis tree abstract and

Fig. 3 steps to determine the converter.

The following is an example of compression given. Here the compressed bit stream is essentially there from fixed length code symbols. The example relates to the high level C / C ++ programming language and does not describe the full range of languages, but can easily be changed to the full Scope to be expanded.

Each high-level language program consists of different ones different parts and types of instructions. Every part or instruction type begins with a in this implementation corresponding "start code", the length of which depends on the number of required start codes. An example of the The most important types of instruction are given in Table 1. For the description of the full range of languages additional start codes required.  

Table 1

Start codes for program parts or instructions

The following are examples of some of these Program parts or instructions given.

Representation of integers

The following way of representing integers is in used in this implementation: The sign is over 1 Bit signals the amount in the dual number system changed. This representation is cut into pieces of length 7 Bit divided. The number of pieces gives that for the Transfer required number of bytes. The still free bit of the byte is signaled as to whether for the Representation of further bits follow (n * (7 + 1) bit representation).

The "include" part

Are files known to the compiler by the "include" - Instruction inserted, so each of these known files a code symbol can be assigned. An example of this is there Table 2.

Table 2

Code words for known files

The part with "include" statements has in this Realization following form:

#include <fstream.h <
#include <string.h <
#include <iostream.h <
#include <ctype.h <
#include <stdio.h <
#include <stdlib.h <,

it can then be represented by the following bit sequence, in which the binary assignment for "#include" comes first, then a bit indicates whether the compiler knows files or own files. The number of files known to the compiler to be inserted then follows, and then the codes for the individual files. Since no negative numbers can occur, there is no signaling for the sign. This results in the following bit sequence:
00010 0 0000110 (0) 0110 0001 0010 0011 0100 0101

Definition of global / local variables

The reserved language words for elementary data types are again represented by codes. An example this is given in Table 3.

Table 3

Reserved language words for elementary data types

A syntactically meaningful coding can be similar here as in the "include" part: First comes the  Start code, then the number of data type definitions. In In this case, the right part of the table 3 Language words specified in addition to those on the left Language words specified on the side of the table occur. With the simple rule that first the codes for the Language words on the right-hand side can be transmitted Uniqueness in the bit stream can be achieved. This means, that according to the codes for "unsigned", "const", "static", "singed", "*" and "[·]" always a code for one of the Words "int", "char", "short", "long", "float", "double", "void" is expected. For fields also "[·]" occur after the code for the variable names are still a corresponding number of integer values is expected. The Reconstruction is clear.

The variables can simply be numbered, those for the amount of bits required for coding can either be from the number the variable - if it is also transferred - be calculated, or it must also be transferred.

Table 4

Number of bits required to represent the variable name or the 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 recipient side, this can then be reconstructed to:
char * v0;
char * v1 [1000];
int v2 [10] [10];
with different names for the variables. Of course, these names must be used consistently in the decoder.

Start of the "main" program

The consequence: "main () {" can be done simply by the start code are reproduced. The corresponding code for "end of program "is then converted into"}; "in the decoder Passing arguments need appropriate extensions occur.

Instance building

C ++ is created in the same way as the definition the basic elementary types. Any necessary Transfer of the assignment of original class names to Representation in a bit sequence takes place before the instantiation instead of.  

example

Class name * kl_instanz;
apart from 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 are required for the class name and 4 bits for an instance.

Definition of methods

Was between elementary data types, structures and Classes differed, that is, for each type created their own bit allocation tables - as in this one Realization -, so after the start code Signaling take place, what a data type for the Return is provided, otherwise this can No signaling. The data type for the Return parameters can then be specified accordingly will. As in this implementation, become the code words for structures and classes started with a "0" (analog as in Table 3 the code words for elementary data types), so can the additional data types of the right Side of Table 3 are used, the uniqueness is then guaranteed. The code for the follows Class name, the code for the name of the method and a another bit for signaling whether this method with Parameters is called. If so, then the number follow and the parameters can be analogous to the definition of the Variables / structures / instances are coded. Here is of course to make sure that either the one used Is large enough to include internal parameters and To be able to present arguments with it, or it becomes a appropriate signaling used.  

Call a method

If there is no assignment at the same time, so the start code will come first, then the bits for the Class instance. The subsequent "·" or "→" can be transmitted with a signaling bit. It follows then the bit string for the method. In general it is Number of arguments not known, so one follows Signaling whether and if so, how many arguments available. These are then also in bit sequences implemented. Have variables, structures, instances and Methods / functions no uniform bit sequence assignment, so must - if the definition of the function / method does not is known and therefore the data type is not known to the decoder is known - in each case, for example, by 2 bits be signaled which type it is respective argument.

Instructions for execution

Most instructions are short, and often is the sequence of variables / structures / instances (v), Special characters / operators (o) and constants / strings (c) common, so it makes sense for frequent occurring sequences of this kind have their own code use. Special instructions such as Example "variable ++;" or "variable = 0;" an own Get code. A brief example of one Assignment is given in the following table. Before the Coding the constants / strings becomes signaling set, which indicates what it is in the following.  

Table 7

Example of the assignment of some common sequences of variables / structures / instances (v), special characters / operators (o) and constants / strings to bit sequences

The code for the specified in the following table Special character ";" occurs only in connection with "escape". Is the sequence of variables / structures / instances (v), Special characters / operators (o) and constants / strings (c) known, the special character ";" not mandatory.  

Table 8

Example of the assignment of special characters to bit sequences

In the following example, the start code is not included listed, four bits are for the representation of Variables needed. The distinction between variables, Structures, instances and methods / function calls happens here with a 2-bit flag.

In order to assign bit sequences to more complex instructions, the order of which is not included in the table above, "escape" can be used with a modified syntax structure, the structure of which is probably best shown in the following example. Appropriate signaling always indicates what to expect next:
Variable / structure / instance
Special characters / operator
Function / method call
In cases where this signaling is not sufficient, a second signaling follows.

example

The instruction

buffer [i] = ((i + k) / (buf-1)) &[k];

apart from the start code, the following bit sequence can then 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" generally requires one greater amount of bits than if one of the predefined sequences of variables / structures / instances (v) Special characters / operators (o) and constants / strings (c) is used.

Control instructions ("for", "while", "if", "else") "for"

After the word "for" 3 expressions are separated by ";" expected in parentheses, being in these expressions commas are also allowed. After the start code for the "for" - Instruction directly follow 3 execution instructions that can of course also be empty. On the receiving end then the corresponding syntax with "for (..;..;..) {′ ′ restored. For the end of the loop there is also a transfer the corresponding "start code". In between can any instructions are given.

In the following example, "k" is the 14th variable and "element" 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"

The difference to the "for" statement is only in the number of expressions in parentheses that So syntax can be done analogously.

"if"

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

Claims (9)

1. Converter for the transmission of source code, in particular a high-level language such as C / C ++, Fortran or Java, into a bit stream for the transmission, the reconstruction on the receiver side providing a syntactically and logically equivalent program code, characterized in that
that an abstract tree generated by means of syntax analysis is coded in a bit-efficient manner and
that short bit sequences are assigned to reserved or special language words to determine the converter,
that short bit sequences are assigned to the symbols by means of lexical analysis,
that based on the lexical analysis, constants are also converted into bit sequences,
statements such as declaration, function call, arithmetic statement etc., keywords are assigned as short bit sequences,
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 uniquely combined and
that for symbols that must be known to the outside world, the assignment of the symbol to the internally used bit sequence is also transmitted. 2. The method according to claim 1, characterized featured, that when using variable length codes for the Symbols, for example at Huffmann or Entropy coding, the frequency of each symbol is determined and a corresponding assignment to Bit sequences of the smallest possible length occur and / or for the reserved language words (inclusive Special characters and operators) the frequency of each reserved language word is determined and a appropriate assignment to bit sequences if possible short length. 3. The method according to claim 1, characterized featured, that when using fixed length codes for the symbols corresponding bit sequences are assigned to them, where the length of the bit string depends on the number of Depends on symbols and the length or number with is transmitted and / or for the reserved Language words (including special characters and operators) these are assigned fixed bit sequences that require significantly fewer bits than the direct one Presentation. 4. The method according to claim 2 or 3, characterized featured, that for all symbols via a uniform table bit sequences are assigned. 5. The method according to claim 2 or 3, characterized featured,  that for each type of symbol such as variable name, Function name, class name, instance its own Symbol table is created and thus the assignment separated from bit sequences and that in not in clear cases the symbol type is also transferred. 6. The method according to claim 2 or 3, characterized featured, that more common combinations own Bit sequences can be assigned. 7. The method according to claim 1, characterized featured, that the assignment of original symbol names to the Bit sequences are then additionally transmitted if these must be known to the recipient. 8. The method according to claim 3, characterized featured, that when using fixed length codes, the length of the Bit sequence is calculated by forming the logarithm to base 2 from the corresponding number and rounding to the next larger integer, then either the length of the bit string or the number of variable Name is transferred with. 9. The method according to any one of claims 1 to 8, characterized in
that constants and strings are displayed uniformly using character strings, the character strings being represented in ASCII form and
that integers are encoded using the n * (7 + 1) bit method, where numbers in single-point or double-precision floating-point representation are represented as two integers and the integers are interpreted either as a mantissa and exponent or as a pre-and post-decimal value.