3.1

3.2

3.3

3.4

3.5

3.6

4.1  Pretty printing

Pretty printing is the systematic formatting of source code according to predefined rules to enhance readability, maintainability, and consistency.

The practice of pretty printing is common in programming languages and software development. It involves organizing code into a structured format that is easy to read and understand. This includes consistent indentation, line breaks, and spacing, as well as the use of meaningful names for variables, functions, and other constructs. Pretty printing also helps identify syntax errors and improve the overall quality of the code.

Pretty printing is particularly important in the context of data modeling and schema definition languages like EXPRESS. In these languages, the structure and semantics of the data models are defined through a series of declarations, expressions, and statements. A well-formatted schema makes it easier for developers, data architects, and other stakeholders to understand the relationships between different entities, types, and attributes. It also aids in the maintenance and evolution of the schema over time, as changes can be made more easily when the code is organized and readable.

4.2  EXPRESS pretty printing

In the context of the EXPRESS language, pretty printing refers to the formatting of EXPRESS schemas, entities, types, functions, rules, and other declarations to ensure that they are presented in a consistent and readable manner. This is particularly important for human readers who need to understand the structure and semantics of the data models defined in EXPRESS.

This document is developed based on EXPRESS formatting rules described in the following references:

EXPRESS pretty printing involves the formatting of its various constructs, covered by the three basic groups of objects:

5.1  General

In a pretty printing process, parameters are used to control the formatting of the output. These parameters can include settings for indentation, line length, and other formatting options. The parameters are typically specified in a configuration file or as command-line arguments when invoking the pretty printer.

5.2  Pretty printing parameters

This following parameters are used to control the formatting of the output in the context of EXPRESS pretty printing.

6.1  General

This clause describes the layout of each declaration: FILE header, SCHEMA, interface, CONSTANT, TYPE, ENTITY, SUBTYPE_CONSTRAINT, FUNCTION, RULE, and PROCEDURE.

6.2  Preamble

The preamble is printed as follows:

(* This is a comment 1 *)
(* This is a multi-line comment
     2 *)
(*
This is a multi-line comment 3

*)

(* {pretty-printer} version: {version}
   Format parameters: {format-parameters}
*)

6.3  SCHEMA

The SCHEMA element is printed as follows:

SCHEMA schema_name;

USE FROM schema2;

TYPE type1;
END_TYPE;

ENTITY entity1;
END_ENTITY;

END_SCHEMA;

6.4  Interfaces

USE FROM or REFERENCE FROM statements are used to specify the interface between schemas.

Interfaces are printed as follows:

SCHEMA schema3 '{iso standard 10303 part(nn) version(yy) object(1)
geometric_model_schema(3)}';
USE FROM schema1  -- ISO 10303-42 schema1 version 10
  (entity1,
   entity2,
   entity3);
USE FROM schema2  -- ISO 10303-41 schema2 version 16
  (entity1,
   entity2,
   entity3,
   entity4);
USE FROM schema3; -- ISO 10303-43 schema3 version 5
...
END_SCHEMA; -- schema3

6.5  CONSTANT

A constant declaration is printed as follows:

CONSTANT
  schema_prefix         : STRING       := 'MATH_FUNCTIONS_SCHEMA.';
  the_integers          : e_space      := mk_e_space(es_integers);
  the_reals             : e_space      := mk_e_space(es_reals);
  the_numbers           : e_space      := mk_e_space(es_numbers);
  the_logicals          : e_space      := mk_e_space(es_logicals);
  the_booleans          : e_space      := mk_e_space(es_booleans);
  the_strings           : e_space      := mk_e_space(es_strings);
  the_binarys           : e_space      := mk_e_space(es_binarys);
  the_maths_spaces      : e_space      := mk_e_space(es_maths_spaces);
  the_generics          : e_space      := mk_e_space(es_generics);
  the_empty_space       : finite_space := mk_finite_space([]);
  the_nonnegative_reals : real_interval_from_min
                                       := make_real_interval_from_min(0.0, closed);
  the_zero_one_interval : finite_real_interval
                                       := make_finite_real_interval(0.0, closed, 1.0, closed);
  the_zero_pi_interval  : finite_real_interval
                                       := make_finite_real_interval(0.0, closed, pi, closed);
  the_neg1_one_interval : finite_real_interval
                                       := make_finite_real_interval(-1.0, closed, 1.0, closed);
END_CONSTANT;

6.6  TYPE

A type declaration is printed as follows:

TYPE type1 = STRING;
WHERE
  WR1: <expression>;
END_TYPE; -- type1

TYPE enum_type1 = ENUMERATION OF (on, off, whatever);
END_TYPE; -- enum_type1

TYPE enum_type2 = ENUMERATION OF
  (val1,
   val2,
   val3,
   val4);
END_TYPE; -- enum_type2

TYPE sel_type1 = SELECT (ent1, ent2, ent3);
END_TYPE; -- sel_type1

TYPE sel_type2 = SELECT
  (entity1,
   entity2,
   entity3,
   type4,
   entity5);
END_TYPE; -- sel_type2

6.7  ENTITY

An entity declaration is printed as follows:

ENTITY entity1
  SUPERTYPE OF (entity2 ANDOR entity3)
  SUBTYPE OF (entity5);
  attr1 : type1;
  attr2 : type2;
DERIVE
  der1 : type1 := <expression>;
INVERSE
  inv1 : entity1 FOR attr3;
  inv2 : BAG OF entity2 FOR attr4;
  inv3 : BAG [1:4] OF entity3 FOR entity2.attr3;
UNIQUE
  UR1: attr1;
  UR2: attr1, attr2;
WHERE
  WR1: <expression>;
  WR2: <expression>;
END_ENTITY;

6.8  SUBTYPE_CONSTRAINT

A subtype constraint declaration is printed as follows:

SUBTYPE_CONSTRAINT entity1_sub_con FOR entity1;
  ABSTRACT SUPERTYPE;
  TOTAL_OVER (entity3, entity4, entity5);
  ONEOF(entity3, entity4, entity5);
END_SUBTYPE_CONSTRAINT;

6.9  FUNCTION

A function declaration is printed as follows:

FUNCTION fun_name (a : INTEGER;
                   b : STRING;
                   c : REAL) : STRING;
  ENTITY fun_sub_ent;
    name : STRING;
  END_ENTITY;

  CONSTANT
    ...
  END_CONSTANT;

  LOCAL
    inst : fun_sub_ent;
  END_LOCAL;
  inst := fun_sub_ent(b);
END_FUNCTION;

6.10  RULE

RULE rule_id FOR (entity_ref,
                  entity_ref);
  ENTITY rule_sub_ent;
    name : STRING;
  END_ENTITY;

  CONSTANT
    my_pi : REAL := 3.1415926;
  END_CONSTANT;
  LOCAL
    my_ent: rule_sub_ent;
  END_LOCAL;
  inst := rule_sub_ent('what');
WHERE
  WR1: expression;
  ...
END_RULE;

6.11  PROCEDURE

A procedure declaration is printed as follows:

PROCEDURE proc_id (formal_parameter;
                   formal_parameter);
  declarations
  CONSTANT
    my_pi : REAL := 3.1415926;
  END_CONSTANT;
  LOCAL
    my_inst : proc_sub_ent;
  END_LOCAL;
  my_inst := proc_sub_ent(23.0)
END_PROCEDURE;

7.1  General

Expressions are the basic building blocks of the EXPRESS language. They are used to represent values, perform calculations, and define logical relationships.

The basic formatting rules for expressions are as follows:

7.2  Unary MINUS expression

Write a hyphen (’-’) followed by either a parenthetical expression, a literal value, or a qualifiable factor. There is no space between the hyphen and the following item.

-42
-(42 * 5 / 3)

7.3  NOT expression

Write the NOT keyword, followed by either a parenthetical expression, a literal value, or a qualifiable factor. There is no space between the keyword and the following item.

NOT(x + 5)
NOT y

7.4  Parenthetical expression

Write a left parenthesis, followed by the expression, followed by a right parenthesis. If the expression spans multiple lines, then each subsequent line is aligned so that its first non-white space character is in the column immediately following the left parenthesis that began the Parenthetical Expression.

(5+3)

(42 DIV 5 * 64 *
 23 + 15)

7.5  Unary PLUS expression

Write a plus sign (’+’) followed by either a parenthetical expression, a literal value, or a qualifiable factor. There is no space between the plus sign and the following item.

+42
+(12 / 3)

7.6  Equal expression

Write an expression followed by an equal sign (’=’) followed by an expression. There will be at least one space before and after the equal sign.

x = y + 15

7.7  Exponent expression

Write an expression followed by a double asterisk (’**’) followed by an expression. There will be no space before or after the double asterisk symbol.

x**2

7.8  Greater than expression

Write an expression followed by a greater than symbol (’>’) followed by an expression. There will be at least one space before and after the greater than symbol.

x > y

7.9  Greater than equal expression

Write an expression followed by a greater than or equal symbol (’>=’) followed by an expression. There will be at least one space before and after the greater than or equal symbol.

x >= y

7.10  IN expression

Write an expression followed by the IN keyword followed by an expression. There will be at least one space before and after the IN keyword.

'this' IN ['some', 'that', 'this', 'other']

7.11  Instance equal expression

Write an expression followed by the instance equal symbol (’:=:’) followed by an expression. There will be at least one space before and after the instance equal symbol.

x :=: y

7.12  Less than expression

Write an expression followed by the less than symbol (’’) followed by an expression. There will be at least one space before and after the less than symbol.

x < y

7.13  Less than or equal expression

Write an expression followed by the less than or equal symbol (’⇐’) followed by an expression. There will be at least one space before and after the less than or equal symbol.

x <= y

7.14  LIKE expression

Write an expression followed by the LIKE keyword followed by an expression. There will be at least one space before and after the LIKE keyword.

x LIKE y

7.15  Not equal expression

Write an expression followed by the not equal symbol (’>’) followed by an expression. There will be at least one space before and after the not equal symbol.

x <> y

7.16  Not instance equal expression

Write an expression followed by the not instance equal symbol (’:>:’) followed by an expression. There will be at least one space before and after the not instance equal symbol.

x :<>: y

7.17  Multiply expression

This expression object can have more than two elements.

Write each expression separated by the multiply symbol (’*’). There will be at least one space before and after the multiply symbol.

If all of the elements can’t fit on one line then as many lines as necessary are used. Each line contains as many elements as possible with line breaks occurring just after the multiply symbol and the subsequent lines aligned with the first expression element on the line above.

x * y * z

x * y *
z * q

7.18  Addition expression

This expression object can have more than two elements.

Write each expression separated by the addition symbol (’+’). There will be at least one space before and after the addition symbol.

If all of the elements can’t fit on one line then as many lines as necessary are used. Each line contains as many elements as possible with line breaks occurring just after the addition symbol and the subsequent lines aligned with the first expression element on the line above.

x + y + z

x + y +
z + q

7.19  Subtraction expression

This expression object can have more than two elements.

Write each expression separated by the subtraction symbol (’-’). There will be at least one space before and after the subtraction symbol.

If all of the elements can’t fit on one line then as many lines as necessary are used. Each line contains as many elements as possible with line breaks occurring just after the subtraction symbol and the subsequent lines aligned with the first expression element on the line above.

x - y - z

x - y -
z - q

7.20  Division expression

This expression object can have more than two elements.

Write each expression separated by the division symbol (’/’). There will be at least one space before and after the division symbol.

If all of the elements can’t fit on one line then as many lines as necessary are used. Each line contains as many elements as possible with line breaks occurring just after the division symbol and the subsequent lines aligned with the first expression element on the line above.

x / y / z

x / y /
z / q

7.21  AND expression

This expression object can have more than two elements.

Write each expression separated by the AND keyword. There will be at least one space before and after the AND keyword.

If all of the elements can’t fit on one line then as many lines as necessary are used. Each line contains as many elements as possible with line breaks occurring just after the AND keyword and the subsequent lines aligned with the first expression element on the line above.

x AND y AND z

x AND y AND
z AND q

7.22  Compose expression

This expression object can have more than two elements.

Write each expression separated by the compose symbol (’||’). There will be at least one space before and after the compose symbol.

If all of the elements can’t fit on one line then as many lines as necessary are used. Each line contains as many elements as possible with line breaks occurring just after the compose symbol and the subsequent lines aligned with the first expression element on the line above.

x || y || z

x || y ||
z || q

7.23  DIV expression

This expression object can have more than two elements.

Write each expression separated by the DIV keyword. There will be at least one space before and after the DIV keyword.

If all of the elements can’t fit on one line then as many lines as necessary are used. Each line contains as many elements as possible with line breaks occurring just after the DIV keyword and the subsequent lines aligned with the first expression element on the line above.

x DIV y DIV z

x DIV y DIV
z DIV q

7.24  MOD expression

This expression object can have more than two elements.

Write each expression separated by the MOD keyword. There will be at least one space before and after the MOD keyword.

If all of the elements can’t fit on one line then as many lines as necessary are used. Each line contains as many elements as possible with line breaks occurring just after the MOD keyword and the subsequent lines aligned with the first expression element on the line above.

x MOD y MOD z

x MOD y MOD
z MOD q

7.25  OR expression

This expression object can have more than two elements.

Write each expression separated by the OR keyword. There will be at least one space before and after the OR keyword.

If all of the elements can’t fit on one line then as many lines as necessary are used. Each line contains as many elements as possible with line breaks occurring just after the OR keyword and the subsequent lines aligned with the first expression element on the line above.

x OR y OR z

x OR y OR
z OR q

7.26  XOR expression

This expression object can have more than two elements.

Write each expression separated by the XOR keyword. There will be at least one space before and after the XOR keyword.

If all of the elements can’t fit on one line then as many lines as necessary are used. Each line contains as many elements as possible with line breaks occurring just after the XOR keyword and the subsequent lines aligned with the first expression element on the line above.

x XOR y XOR z

x XOR y XOR
z XOR q

7.27  Aggregate initializer expression

This is a sequence of expressions each separated by a comma and enclosed in square brackets.

Each expression is written with a comma separating any two adjacent expressions. At least one space is written after the comma with no space before the comma. The first expression starts just after the left square bracket and the right square bracket occurs just after the last expression.

If the aggregate initializer expression can’t fit on one line then line breaks are placed just after the comma. Each element is written to a separate line aligned with the expression above it.

[42, x + y, 'this', .that.]

[15,
 a + very + long + expression,
 'this string',
 .enum_val.]

7.28  Call function expression

Write the name of the FUNCTION. If there are any parameters to the function, then the parameter expressions are enclosed in parentheses and separated by commas.

If there are parameters then the left parenthesis is written just after the function name with no space separating it from the function name. Each expression is written with a comma separating any two adjacent expressions. There will be at least one space after the comma and no space before the comma.

If more than one line is needed then the expressions are written one to a line with the line break occurring just after the comma. Each expression is aligned with the expression above it. The first expression starts just after the left parenthesis and the right parenthesis is written just after the final expression.

fun1(42, .t., 'this')

fun1(42,
     .t.,
     'this')

7.29  ENTITY constructor expression

Write the name of the ENTITY to be constructed.

If there are values needed to initialize any attributes, then the list of expressions is written just after the entity name and enclosed in parentheses and separated by commas.

This list begins with a left parenthesis just after the ENTITY name with no space between the parenthesis and the entity name. Each expression is written with a comma separating them. There is at least one space after the comma and no space before the comma. The right parenthesis follows immediately after the last expression.

If all of the expressions won’t fit on one line then each expression is placed on its own line with line breaks occurring just after the comma. The first expression occurs just after the left parenthesis and on the same line. Each subsequent expression is aligned with the one above it.

entity1('this', 42, (1,2,4,6), .enum_val1.)

entity1('this',
        42,
        (1,2,4,6),
        .enum_val1.)

7.30  Enumeration reference expression

If the name of the TYPE declaration is provided, write the name of the TYPE declaration followed by a period (’.’).

Write the enumeration value.

enum1

type1.enum2

7.31  Interval expression

Write an open curly brace {. Write the low value expression. Write the first operator. Write the item value expression. Write the second operator. Write the hi value expression. Write a close curly brace }.

If the expression can’t fit on one line, then write the low value expression on the line with the left curly brace followed by the first operator. Write the item value expression on the next line followed by the second operator. The item value expression will be aligned with the low value expression on the line above. Finally, on the next line write the hi value expression followed by the right curly brace. The hi value expression will be aligned with the item value expression on the line above.

{1 < x < 10}

{1 <
 x <
 10}

7.32  Qualifiable factor expression

This qualifiable-factor object contains both the factor and the qualifiers.

Write the factor. For each qualifier, write the qualifier.

If they need more than one line, put as many qualified on each line as possible and align each subsequent line with the first qualifier on the line above.

var1\ENTITY1.attr1[23]

var1\ENTITY1
    .attr1[23]

7.33  QUERY expression

Write the QUERY keyword followed by an open parenthesis.

Next write the query variable id followed by the <* symbol.

Next write the source expression followed by the | symbol.

Next write the query expression followed by the close parenthesis.

If the query expression can’t fit on one line then put line breaks just after the <* and | symbols. The source expression will be aligned with the query variable id. The query expression will be aligned with the source expression.

QUERY(var1 <* [1,2,3,4,5] | var1 < 3)

QUERY(var1 <*
      [1,2,3,4,5] |
      var1 < 3)

8.1  General

Statements are the executable parts of an EXPRESS schema. They are instructions that perform actions, control flow, and manipulate data. The statements are typically used within procedures, functions, and other control structures to define the behavior of the schema.

The basic formatting rules for statements are as follows:

8.2  ALIAS statement

Write the keyword ALIAS followed by the variable id followed by the keywordFOR followed by a general reference and set of qualifiers for the thing being aliased. Finish up with a ‘;’ (semicolon) to end it.

ALIAS var_id FOR ent1\attr1;

8.3  Assignment statement

Write a pretty version of the general_ref followed by the assignment keyword ‘:=’ followed by a pretty version of the expression followed by a ‘;’ (semicolon). At least one space should be included before and after the assignment keyword ‘:=’.

Multiple lines will be used depending on the expression itself.

i := 23 * 42 + x;

8.4  Call PROCEDURE statement

Write the name of the procedure.

If there are parameters to be passed to the procedure then write an open parenthesis followed by a list of the parameter expressions each separated by a comma. Finally write a close parenthesis.

Finish up with a semicolon.

If the expressions won’t fit on a single line then place line breaks just after the comma. Each expression will be placed on its own line aligned with the expression on the line above. The first expression is placed on the line with the left parenthesis and just after the parenthesis.

proc_name(42,'this',.T.,.THAT.);

proc_name(42,
          'this',
          .T.,
          .THAT.);

8.5  CASE statement

Write the keyword CASE followed by the expression that is the <selector> followed by the keyword </selector>OF.

Write each of the case actions starting on a separate line indented two characters to the right from the left edge of the CASE keyword.

After the CASE Actions, if there is an otherwise clause, write the keywordOTHERWISE on a separate line, indented two characters to the right of the left edge of the CASE keyword. Follow the OTHERWISE keyword with a colon and the statement that is the otherwise clause. The colon should be right next to the OTHERWISE keyword with one or more spaces after the colon.

Finally, on a new line write the keyword END_CASE aligned with the CASE keyword. Follow the END_CASE keyword with a semicolon.

CASE <selector> OF
  label1: <stmt>
  label2, label3:
    <stmt>
  OTHERWISE: <stmt>
END_CASE;

label1, label2: <stmt>

label3, label4, label5:
  <stmt>

8.6  Compound statement

The compound statement begins with the BEGIN keyword and ends with the END keyword. Each of these keywords should be on its own line and aligned with each other. Following the END keyword there should be a semicolon.

Each of the enclosed statements should be written on a separate line indented two characters to the right of the left edge of the BEGIN keyword.

BEGIN
  a := 42 * i;
  RETURN(a);
END;

8.7  ESCAPE statement

The ESCAPE statement is self contained and consists of just the ESCAPE keyword followed by a semicolon.

ESCAPE;

8.8  IF statement

The IF statement consists of the keyword IF followed by the expression that is the condition. Next follows the THEN keyword and the statements that constitute the then portion. If there is an else part of the if then theELSE keyword is written followed by the else statements. The THEN andELSE keywords each have their own line and are aligned with the IF keyword. The THEN and ELSE statements are indented two characters to the right of the left edge of the associated keyword.

Finally, on a new line, aligned with the IF keyword we write the END_IF keyword followed by a semicolon.

IF <condition>
THEN
  a := 42 * i;
  RETURN(a);
ELSE
  a := x / 15;
  RETURN(a);
END_IF;

8.9  NULL statement

The NULL statement is self contained and consists of only a semicolon.

;

8.10  REPEAT statement

The REPEAT Statement consists of the REPEAT keyword followed by the Increment Controls, followed by any While Controls, followed by any Until Controls, followed by a semicolon, followed by the statements that should be executed during each loop. Finally, there is a END_REPEAT keyword written on its own line aligned with the REPEAT keyword and followed by a semicolon.

The Increment Controls, While Controls, and Until Controls should be indented four characters to the right of the left edge of the REPEAT keyword.

REPEAT i := 0 TO 15 BY 1
    WHILE x > 20
    UNTIL y < 50;
  a := 42 * x / y;
  b := x * i DIV y;
END_REPEAT;

a := 1 TO 5
a := 1 TO 5 BY 0.5

WHILE a < 5

UNTIL x > 50

8.11  RETURN statement

The RETURN statement is fairly simple and consists of the keyword RETURN optionally followed by an open parenthesis, an expression which calculates the value to be returned, a close parenthesis.

Finally, it is terminated with a semicolon.

RETURN;
RETURN(42);

8.12  SKIP statement

The SKIP statement is self contained and consists of the keyword SKIP followed by a semicolon.

SKIP;