CHILL (CCITT High Level Language) is a general procedural programming language which is mainly used in the field of telecommunications. As a general programming language it is by no means limited to this field. A number of CHILL programming environments are also implemented in CHILL. Some more details, especially about the early history of CHILL, can be found in a paper by K. Rekdal.
The current official definition of CHILL is the standard:
ITU-T Recommendation Z.200 (11/99) ( pdf , info ) / ISO/IEC 9496:1998(E)
Informally, this version is also called CHILL2000. The paper CHILL2000 by J.F.H.Winkler gives a tutorial overview and describes the new language elements of CHILL2000.
There was a GNU CHILL compiler publicly available (up to 2.95.3). It was based on Z.200 (11/1988), an earlier version of the language.
A newer version of the language has been implemented at ETRI.
The previous version of the standard had been released in 1996. The new topics of CHILL96 were:
object-oriented programming
Object-Orientation: Modes (types) for Simple, Sequential Stacks 1 /* The examples show the application of object-orientation to the well known stack data structure. Two different implementations of stack modes with identical interfaces are 2 realized(Example 30). Based on these modes extended modes with an additional 3 operation (e.g. Top; Example 31) or with other properties (e.g. mutual exclusive 4 access to stacks (Example 32)) are realized. */ 5 6 SYNMODE StackMode1 = MODULE SPEC /* --------------- Definition of the interface */ 7 GRANT ElementMode, Push, Pop; /* Simple, sequential stack */ 8 NEWMODE ElementMode = STRUCT (a INT, b BOOL); 9 Push: PROC(Elem ElementMode IN) EXCEPTIONS(Overflow) END Push; 10 Pop: PROC( ) RETURNS(ElementMode) EXCEPTIONS(Underflow) END Pop; 11 SYN Length = 10_000; 12 DCL StackData ARRAY (1:Length) ElementMode, /* Array implementation */ 13 TopOfStack RANGE(0:Length) INIT := 0; /* of the stack */ 14 END StackMode1; 15 16 SYNMODE StackMode1 = MODULE BODY /* ------------------ Definition of the body */ 17 Push: PROC(Elem ElementMode IN) EXCEPTIONS(Overflow) 18 IF TopOfStack = Length THEN 19 CAUSE Overflow; 20 ELSE 21 TopOfStack +:= 1; 22 StackData(TopOfStack) := Elem; 23 FI; 24 END Push; 25 Pop: PROC( ) RETURNS(ElementMode) EXCEPTIONS(Underflow) 26 IF TopOfStack = 0 THEN 27 CAUSE Underflow; 28 ELSE 29 RESULT(StackData(TopOfStack)); 30 TopOfStack -:= 1; 31 FI; 32 END Pop; 33 END StackMode1; 34 35 MainProgram1: MODULE 36 SEIZE StackMode1; 37 DCL Stack1 StackMode1; 38 DCL Elem1 StackMode1!ElementMode; 39 Elem1 := [10, TRUE]; 40 Stack1.Push(Elem1); 41 Stack1.Push( [20, FALSE] ); 42 END MainProgram1; 43 44 SYNMODE StackMode2 = MODULE SPEC /* -------------- Definition of the interface */ 45 GRANT ElementMode, Push, Pop; /* Same interface as StackMode1 */ 46 NEWMODE ElementMode = STRUCT (a INT, b BOOL); 47 Push: PROC(Elem ElementMode IN) EXCEPTIONS(Overflow) END Push; 48 Pop: PROC( ) RETURNS(ElementMode) EXCEPTIONS(Underflow) END Pop; 49 50 NEWMODE ListElem = STRUCT(next REF ListElem, /* List implementation */ 51 info ElementMode); /* of the stack */ 52 DCL Stack REF ListElem INIT := NULL; 53 END StackMode2; 54 55 SYNMODE StackMode2 = MODULE BODY /* ---------------- Definition of the body */ 56 Push: PROC(Elem ElementMode IN) EXCEPTIONS(Overflow) 57 Stack := ALLOCATE (ListElem, [Stack, Elem]) 58 ON (ALLOCATEFAIL) : CAUSE Overflow; END; 59 END Push; 60 Pop: PROC( ) RETURNS(ElementMode) EXCEPTIONS(Underflow) 61 DCL Temp REF ListElem; 62 IF Stack = NULL THEN 63 CAUSE Underflow; 64 ELSE 65 RESULT (Stack->.info); 66 Temp := Stack; 67 Stack := Stack->.next; 68 TERMINATE (Temp); 69 FI; 70 END Pop; 71 END StackMode2; 72 73 MainProgram2: MODULE /* ---------------- Essentially the same as MainProgram1 */ 74 SEIZE StackMode2; 75 DCL Stack1 StackMode2; 76 DCL Elem1 StackMode2!ElementMode; 77 Elem1 := [10, TRUE]; 78 Stack1.Push(Elem1); 79 Stack1.Push( [20, FALSE] ); 80 END MainProgram2; ===================================================================================== 31. Object-Orientation: Mode Extension: Simple, Sequential Stack with Operation “Top” 1 2 SYNMODE StackWithTopMode2 = MODULE SPEC /* BASED_ON indicates */ 3 BASED_ON StackMode2 /* mode derivation or */ 4 GRANT Top; /* inheritance */ 5 Top: PROC( ) RETURNS (ElementMode) /* Top is an additional operation */ 6 EXCEPTIONS (EmptyStack) END Top; 7 END StackWithTopMode2 ; 8 9 SYNMODE StackWithTopMode2 = MODULE BODY BASED_ON StackMode2 10 Top: PROC( ) RETURNS (ElementMode) EXCEPTIONS (EmptyStack) 11 IF Stack = NULL THEN 12 CAUSE EmptyStack; 13 ELSE 14 RETURN (Stack->.info); 15 FI; 16 END Top; 17 END StackWithTopMode2 ; 18 19 MainProgram3: MODULE /* --------------------- Very similar to MainProgram2 */ 20 SEIZE StackWithTopMode2; 21 DCL Stack1 StackWithTopMode2; 22 DCL Elem1 StackWithTopMode2!ElementMode; 23 Elem1 := [10, TRUE]; 24 Stack1.Push(Elem1); 25 Stack1.Push( [20, FALSE] ); 26 Elem1 := Stack1.Top( ); 27 END MainProgram3; ===================================================================================== 32. Object-Orientation: Modes for Stacks with Access Synchronization 1 /* Based on the mode StackWithTopMode2 defined in example 31 the mode 2 RegionStackWithTopMode1 is defined whose objects behave like regions: 3 at any point in time at most one of the public procedures may be in execution. 4 Apart from this the behavior is essentially the same as for StackWithTopMode2: 5 erroneous use of an object causes an exception. The second mode 6 RegionStackWithTopMode2 uses the CHILL event mechanism to deal with 7 erroneous use of a stack object. */ 8 9 SYNMODE RegionStackWithTopMode1 = REGION SPEC BASED_ON StackWithTopMode2 10 /* Just put the base mode into a “region envelope” */ 11 /* In case of an erroneous use same behaviour as StackWithTopMode2: cause an exception */ 12 END RegionStackWithTopMode1 ; 13 14 SYNMODE RegionStackWithTopMode1 = REGION BODY BASED_ON StackWithTopMode2 15 END RegionStackWithTopMode1 ; 16 17 MainProgram4: MODULE 18 SEIZE RegionStackWithTopMode1; 19 DCL Stack1 RegionStackWithTopMode1; 20 Producer: PROCESS ( ) ; 21 DCL Elem1 RegionStackWithTopMode1!ElementMode; 22 DO FOR EVER 23 /* compute Elem1 */ 24 Stack1.Push(Elem1); 25 OD; 26 END Producer; 27 Consumer: PROCESS ( ) ; 28 DCL Elem1 RegionStackWithTopMode1!ElementMode; 29 DO FOR EVER 30 Elem1 := Stack1.Pop ( ); 31 /* process Elem1 */ 32 OD; 33 END Consumer; 34 START Producer ( ); 35 START Consumer ( ); 36 END MainProgram4; 37 38 SYNMODE RegionStackWithTopMode2 = REGION SPEC BASED_ON StackWithTopMode2 39 /* In case of an erroneous use different behaviour as StackWithTopMode2: 40 use the event mechanism */ 41 GRANT Push, Pop, Top; 42 Push: PROC(Elem ElementMode IN) REIMPLEMENT END Push; 43 Pop: PROC( ) RETURNS (ElementMode) REIMPLEMENT END Pop; 44 Top: PROC( ) RETURNS (ElementMode) REIMPLEMENT END Top; 45 DCL NotEmpty, NotFull EVENT; 46 END RegionStackWithTopMode2 ; 47 48 SYNMODE RegionStackWithTopMode2 = REGION BODY BASED_ON StackWithTopMode2 49 Push: PROC(Elem ElementMode IN) REIMPLEMENT 50 PushLoop: DO 51 BEGIN 52 StackWithTopMode2!Push(Elem); 53 EXIT PushLoop; 54 END 55 ON (Overflow): DELAY NotFull; END; 56 OD PushLoop; 57 CONTINUE NotEmpty; 58 END Push; 59 Pop: PROC( ) RETURNS(ElementMode) REIMPLEMENT 60 PopLoop: DO 61 BEGIN 62 RESULT StackWithTopMode2!Pop( ); 63 EXIT PopLoop; 64 END 65 ON (Underflow): DELAY NotEmpty; END; 66 OD PopLoop; 67 CONTINUE NotFull; 68 END Pop; 69 Top: PROC( ) RETURNS (ElementMode) REIMPLEMENT 70 TopLoop: DO 71 BEGIN 72 RESULT StackWithTopMode2!Top( ); 73 EXIT TopLoop; 74 END 75 ON (EmptyStack): DELAY NotEmpty; END; 76 OD TopLoop; 77 CONTINUE NotFull; 78 END Top; 79 END RegionStackWithTopMode2 ; 80 81 MainProgram5: MODULE /* ---------------- Essentially the same as MainProgram4 */ 82 SEIZE RegionStackWithTopMode2; 83 DCL Stack1 RegionStackWithTopMode2; 84 Producer: PROCESS ( ) ; 85 DCL Elem1 RegionStackWithTopMode2!ElementMode; 86 DO FOR EVER 87 /* compute Elem1 */ 88 Stack1.Push(Elem1); 89 OD; 90 END Producer; 91 Consumer: PROCESS ( ) ; 92 DCL Elem1 RegionStackWithTopMode2!ElementMode; 93 DO FOR EVER 94 Elem1 := Stack1.Pop (Elem1); 95 /* process Elem1 */ 96 OD; 97 END Consumer; 98 START Producer ( ); 99 START Consumer ( ); 100 END MainProgram5;
Z.200 (11/1999)
International Telecommunication Union, ITU-T Recommendation Z-200 (11/1999), CHILL - The ITU-T Programming Language. Geneva, 2001
This is the official specification of CHILL
Rek 1993
Rekdal, Kristen: CHILL - the international standard language for telecommunications programming.
Telektronikk 1993, 2/3, pp. 5..10
Overview of the early history and use of CHILL in the telecom industry.
Win 2000
Winkler, Juergen F.H.: CHILL 2000. Telektronikk 2000, 4, pp. 70..77
Tutorial on CHILL, especially on the object-oriented features of CHILL2000.
CHL 1997
Lee, DongGill; Lee, JoonKyung; Choi, Wan; Lee, Byung Sun; Han, Chimoon:
A New Integrated Software Development Environment Based on SDL, MSC, and CHILL for Large-scale Switching Systems.
ETRI Journal 18,4 (1997) 265..286
Pal 1991
Palma, Antonio (ed.):
CHILL, CCITT high level language: proceedings of the 5th CHILL Conference, Rio de Janeiro, Brazil, 19-22 March 1990.
North-Holland, 1991. 978-0444889041.
PLW 1982
Branquart,P.; Louis, G.; Wodon, P.: An Analytical Description of CHILL, the CCITT High Level Language.
LNCS 128, Springer, Berlin etc., 1982. 978-3540111962.