JOVIAL2CTM Translator

The JOVIAL2C translator converts source code written in JOVIAL to functionally equivalent source code in C taking advantage of some GNU 3.0 extensions of C. The tool has been constructed using the DMS Software Reengineering Toolkit, the JOVIAL Front End, and a customization of the C Front End by GNU extensions for C used by the translator.

The JOVIAL2C translator has been used to modernize sophisticated embedded aircraft software, such as the mission software for the Northrop Grumman B-2.

The JOVIAL2C translator supports:

  • Source language: JOVIAL as defined by MIL-STD-1589C (USAF) or J73.
  • Target language: C with GNU extensions as provided by GCC 3.0.
    We have produced other C dialects for customers.
  • Translation of modules
    • Compool modules are translated to C header files containing compile time conditionals to deal with data initializers
    • Procedure modules are translated to C source files containing translation units
    • Main program modules are translated to C source files containing translation units
  • Translation of basic language features
    • Compool directives are translated to C includes of header files
    • Data items are translated to C declarations
    • Blocks are translated to C structures
    • Tables without dimensions are translated to C structures; tables with dimensions are translated to C arrays of structures
    • Procedures and functions are translated to C functions
    • Statements are translated one-to-one to corresponding C statements
    • Access to data items in blocks and tables is translated to C expressions using structure member access operators . and -> when necessary
    • Operators and predefined functions in formulas are translated to corresponding operators in C expressions or to predefined macros
    • Value-result parameter passing is translated to passing of C pointers with simulation of value-result behavior by the callee
  • Translation of advanced language features
    • Preset values specified for block and table entries are translated to C structure initializers
    • Specified tables without overlapping entries are translated to flat C structures (containing bit field members as necessary) specified tables with overlapping entries are translated to C unions of anonymous structures (containing bit field members as necessary)
    • Overlays are translated to nested anonymous C structures and unions (using a GCC 3.0 extension of C)
  • Translation of comments
    • Comments are preserved during translation with their representation being adapted as necessary
  • Preservation of well-structured macros
    • Well-structured macros in JOVIAL are translated to well-structured macros in C
    • Multiple macros in C may be created for a single macro in JOVIAL if necessary
    • If structure member access operators are added, token concatenation in macros for data items is propagated to token concatenation for the enclosing table or block name if possible.


JOVIAL source code


      %define records%
      TABLE tbl'one'grp W 1;
          ITEM itm'one'A S 3 POS(3,0) = 1;
          ITEM itm'one'B S 3 POS(8,0) = 2;
      TABLE tbl'two'grp W 1;
          ITEM itm'two'A S 3 POS(3,0) = 3;
          ITEM itm'two'B S 3 POS(8,0) = 4;

      %access members of records%
      DEFINE get'A(G) "itm'!G'A";
      DEFINE get'B(G) "itm'!G'B";

      %test procedure%
      PROC test(:param) S;
          ITEM param S;
          ITEM sumA S = get'A(one) + get'A(two);
          ITEM sumB S = get'B(one) + get'B(two);
          test = sumA + param + sumB;
          %perform sumA times%
          FOR I: 1 BY 1 WHILE I<= sumA;
            IF I < sumB;
              sumB = sumB + test(I);
          param = param + sumB;

C source code produced by JOVIAL2C Translator

    #include "jovial.h"
    static struct
             U(3) : 3 _align_to_bit;
             S(3) itm_one_a : 4 _align_to_bit;
             U(1) : 1 _align_to_bit;
             S(3) itm_one_b : 4 _align_to_bit;
             U(4) : 4 _align_to_bit;
           } tbl_one_grp = { .itm_one_a = 1,
                             .itm_one_b = 2 };
    static struct
             U(3) : 3 _align_to_bit;
             S(3) itm_two_a : 4 _align_to_bit;
             U(1) : 1 _align_to_bit;
             S(3) itm_two_b : 4 _align_to_bit;
             U(4) : 4 _align_to_bit;
           } tbl_two_grp = { .itm_two_a = 3,
                             .itm_two_b = 4 };
    /* access members of records */
    #define GET_A(__g__) \
    #define GET_B(__g__) \
    static S test(S *ARG(param));
    /* test procedure */
    static S test(S *ARG(param))
        __typeof__(*ARG(param)) param = *ARG(param);
        __typeof__(test(ARG(param))) RESULT(test);
        _main :
            S suma = GET_A(one) + GET_A(two);
            S sumb = GET_B(one) + GET_B(two);
            RESULT(test) = suma + param + sumb;
            /* perform sumA times */
              __typeof__(1) i;
              for (i = 1; i <= suma; i += 1)
                if (i < sumb)
                  sumb = sumb + test(i);
                  goto _return;
            param = param + sumb;
        _return :
            *ARG(param) = param;
            return RESULT(test);

Semantic Designs can provide cusomized tools and migration support to your organization.

For more information:    Follow us at Twitter: @SemanticDesigns