오베론 (프로그래밍 언어)

3. 특징

오베론은 "가능한 한 단순하게 만들되, 더 단순하게 만들지는 말라"라는 알베르트 아인슈타인의 좌우명을 염두에 두고 설계되었다. 주요 지침은 기본적이고 필수적인 기능에 집중하고 일시적인 문제는 생략하는 것이었다. 또 다른 요인은 C++, 에이다와 같은 언어의 복잡성 증가를 인식한 것이었다. 이와 대조적으로 오베론은 언어를 확장하기 위해 라이브러리 개념의 사용을 강조한다.^[8]

오베론 언어의 특징은 다음과 같다:^[9]

• 대소문자를 구분하며, 키워드는 대문자를 사용한다.
• 타입 테스트를 통한 타입 확장
• 모듈과 개별 컴파일
• 문자열 연산
• 안전하지 않은 코드 격리
• 시스템 프로그래밍 지원

4. 객체 지향

오베론은 레코드 타입 확장을 통해 추상화와 이질적인 구조 구축을 지원한다. 초기 오베론은 언어 자체에 동적 디스패치 메커니즘이 없었지만, 메서드 스위트(Method suite)와 메시지 처리기(Message handler) 같은 프로그래밍 기법을 통해 객체 지향 프로그래밍의 유연성을 제공한다.^[1]

4. 1. 메서드 스위트

4. 2. 메시지 처리기

5. 구현 및 변형

오베론은 배우기 쉽고, 구현이 간단하며, 매우 효율적인 언어를 목표로 설계되었다. 오베론 컴파일러는 작고 빠르면서도 상업용 컴파일러에 필적하는 코드 품질을 제공하는 것으로 평가받았다.^[8]
오베론-2오베론의 최초 명세에는 몇 가지 변경 사항이 있었다. 예를 들어, 객체 지향 프로그래밍(OOP) 기능이 추가되었고, `FOR` 루프가 부활했다. 그 결과물이 오베론-2이다. IBM PC 호환급 하드웨어에서 직접 부팅할 수 있는 운영체제를 포함하는 네이티브 오베론이라는 릴리스가 있다. 또한 취리히 연방 공과대학교(ETHZ)에서 약간의 .NET 관련 확장이 추가된 오베론의 .NET 구현도 개발되었다. 1993년, ETHZ의 대학 스핀오프 회사가 오베론-L이라는 오베론-2 방언을 시장에 내놓았고, 1997년에 컴포넌트 파스칼로 이름이 변경되었다.

ETH에서 개발한 오베론-2 컴파일러는 마이크로소프트 윈도우, 리눅스, 솔라리스, 클래식 Mac OS용 버전을 포함한다. Atari TOS 및 AmigaOS를 포함한 다른 운영 체제에 대한 다른 소스에서 제공되는 구현이 존재한다.

영국 맨체스터 대학교의 스티븐 J. 베반이 제작한 오베론-2 렉스 스캐너와 Yacc 파서가 있으며, 이는 뫼센뵈크와 비르트의 레퍼런스를 기반으로 한다. 버전은 1.4이다.

오베론-2에서 추가되거나 변경된 주요 기능은 다음과 같다.

• 프로시저를 레코드형(혹은 포인터형)에 바인딩할 수 있다. 객체 지향적 용어로 인스턴스 메서드와 같다.
• 익스포트된 변수나 레코드의 필드에 대해 참조만 접근을 제한할 수 있다.
• Oberon에서는 정식 파라미터형으로만 선언 가능했지만, Oberon-2에서는 포인터 기반의 형으로 선언할 수 있다.
• Pascal이나 Modula-2에 있던 FOR 문은 Oberon에서는 구현되지 않았지만 Oberon-2에서 부활했다.

• 취리히 연방 공과대학교에서는 Windows, Linux, Solaris, Mac OS X용 Oberon-2 컴파일러를 구현 및 유지보수하고 있다.
• 맨체스터 대학교의 스티븐 J. 베반(Stephen J. Bevan)이 개발한 Oberon-2를 지원하는 Lex(를 사용한) 어휘 분석기와 Yacc(를 사용한) 구문 분석기가 있다. 현재 버전은 1.4이다.
• [https://www.fim.uni-linz.ac.at/pow/Pow.htm Programmer's Open Workbench](POW!)는 에디터, 링커, Oneron-2 컴파일러를 갖춘 단순한 통합 개발 환경이다. Windows 상에서 실행 파일을 생성한다. 전체 소스 코드도 제공되며, 컴파일러 자체가 Oberon-2로 작성되었다.
• [http://www.uni-vologda.ac.ru/JOB/ Java to Oberon Compiler](JOB)는 러시아 볼로다 대학교(University of Vologda)에서 개발한 Oberon-2 컴파일러이다. 생성하는 코드는 Java 클래스 파일(바이트코드)이다. Java 호환 전용 클래스가 제공되지만, 전체적인 계층 구조는 Oberon의 것이다.
• [http://sourceforge.net/projects/ooc Optimizing Oberon-2 Compiler]는 일단 C로 변환한 후, gcc를 사용하여 객체를 생성한다.

• 명시적인 숫자 변환 함수(`FLOOR`, `FLT` 등)를 사용해야 한다.
• `WITH`, `LOOP`, `EXIT` 구문이 생략되었다.
• `WHILE` 구문이 확장되었다.
• `CASE` 구문에서 타입 확장 테스트를 할 수 있다.
• `RETURN` 구문은 함수 끝에만 연결될 수 있다.
• 가져온 변수와 구조화된 값 매개변수는 읽기 전용이다.
• `COPY` 없이 배열 할당이 가능하다.

5. 1. 오베론

5. 2. 오베론-2

• 취리히 연방 공과대학교에서는 Windows, Linux, Solaris, Mac OS X용 Oberon-2 컴파일러를 구현 및 유지보수하고 있다.
• 맨체스터 대학교의 스티븐 J. 베반(Stephen J. Bevan)이 개발한 Oberon-2를 지원하는 Lex(를 사용한) 어휘 분석기와 Yacc(를 사용한) 구문 분석기가 있다. 현재 버전은 1.4이다.
• Programmer's Open Workbench(POW!)는 에디터, 링커, Oneron-2 컴파일러를 갖춘 단순한 통합 개발 환경이다. Windows 상에서 실행 파일을 생성한다. 전체 소스 코드도 제공되며, 컴파일러 자체가 Oberon-2로 작성되었다.
• Java to Oberon Compiler(JOB)는 러시아 볼로다 대학교(University of Vologda)에서 개발한 Oberon-2 컴파일러이다. 생성하는 코드는 Java 클래스 파일(바이트코드)이다. Java 호환 전용 클래스가 제공되지만, 전체적인 계층 구조는 Oberon의 것이다.
• Optimizing Oberon-2 Compiler는 일단 C로 변환한 후, gcc를 사용하여 객체를 생성한다.

5. 3. 오베론-07

• 명시적인 숫자 변환 함수(`FLOOR`, `FLT` 등)를 사용해야 한다.
• `WITH`, `LOOP`, `EXIT` 구문이 생략되었다.
• `WHILE` 구문이 확장되었다.
• `CASE` 구문에서 타입 확장 테스트를 할 수 있다.
• `RETURN` 구문은 함수 끝에만 연결될 수 있다.
• 가져온 변수와 구조화된 값 매개변수는 읽기 전용이다.
• `COPY` 없이 배열 할당이 가능하다.

5. 4. 액티브 오베론 (Active Oberon)

5. 5. 관련 언어

6. 문법 (오베론-2)

ALGOL - 파스칼 - Modula-2 - 오베론 - Component Pascal 계열의 언어는 문법을 단순화해왔다고 할 수 있다. 오베론-2는 EBNF를 사용하여 아래와 같이 33개의 구문 생성 규칙으로 나타낼 수 있다.^[1]

```ebnf

Module = MODULE ident ";" [ImportList] DeclSeq [BEGIN StatementSeq] END ident ".".

ImportList = IMPORT [ident ":="] ident {"," [ident ":="] ident} ";".

DeclSeq = { CONST {ConstDecl ";" } | TYPE {TypeDecl ";"} | VAR {VarDecl ";"}} {ProcDecl ";" | ForwardDecl ";"}.

ConstDecl = IdentDef "=" ConstExpr.

TypeDecl = IdentDef "=" Type.

VarDecl = IdentList ":" Type.

ProcDecl = PROCEDURE [Receiver] IdentDef [FormalPars] ";" DeclSeq [BEGIN StatementSeq] END ident.

ForwardDecl = PROCEDURE "^" [Receiver] IdentDef [FormalPars].

FormalPars = "(" [FPSection {";" FPSection}] ")" [":" Qualident].

FPSection = [VAR] ident {"," ident} ":" Type.

Receiver = "(" [VAR] ident ":" ident ")".

Type = Qualident

| ARRAY [ConstExpr {"," ConstExpr}] OF Type

| RECORD ["("Qualident")"] FieldList {";" FieldList} END

| POINTER TO Type

| PROCEDURE [FormalPars].

FieldList = [IdentList ":" Type].

StatementSeq = Statement {";" Statement}.

Statement = [ Designator ":=" Expr

| Designator ["(" [ExprList] ")"]

| IF Expr THEN StatementSeq {ELSIF Expr THEN StatementSeq} [ELSE StatementSeq] END

| CASE Expr OF Case {"|" Case} [ELSE StatementSeq] END

| WHILE Expr DO StatementSeq END

| REPEAT StatementSeq UNTIL Expr

| FOR ident ":=" Expr TO Expr [BY ConstExpr] DO StatementSeq END

| LOOP StatementSeq END

| WITH Guard DO StatementSeq {"|" Guard DO StatementSeq} [ELSE StatementSeq] END

| EXIT

| RETURN [Expr]

].

Case = [CaseLabels {"," CaseLabels} ":" StatementSeq].

CaseLabels = ConstExpr [".." ConstExpr].

Guard = Qualident ":" Qualident.

ConstExpr = Expr.

Expr = SimpleExpr [Relation SimpleExpr].

SimpleExpr = ["+" | "-"] Term {AddOp Term}.

Term = Factor {MulOp Factor}.

Factor = Designator ["(" [ExprList] ")"] | number | character | string | NIL | Set | "(" Expr ")" | " ~ " Factor.

Set = "{" [Element {"," Element}] "}".

Element = Expr [".." Expr].

Relation = "=" | "#" | "<" | "<=" | ">" | ">=" | IN | IS.

AddOp = "+" | "-" | OR.

MulOp = " * " | "/" | DIV | MOD | "&".

Designator = Qualident {"." ident | "[" ExprList "]" | " ^ " | "(" Qualident ")"}.

ExprList = Expr {"," Expr}.

IdentList = IdentDef {"," IdentDef}.

Qualident = [ident "."] ident.

IdentDef = ident [" * " | "-"].

7. 코드 예시 (오베론-2)

다음은 오베론-2로 작성된 간단한 리스트 클래스를 구현한 코드이다.

```oberon2

MODULE ListClass;

TYPE List* = POINTER TO ListNode;

ListNode = RECORD

value : INTEGER;

next : List;

END;

PROCEDURE ( l : List ) Add* ( v : INTEGER );

BEGIN

(* ... *)

END Add;

PROCEDURE ( l : List ) AddLast*( v : INTEGER );

BEGIN

(* ... *)

END AddLast;

PROCEDURE ( l : List ) AddAt* ( i : INTEGER; v : INTEGER );

BEGIN

(* ... *)

END AddAt;

PROCEDURE ( l : List ) Remove*;

BEGIN

(* ... *)

END Remove;

PROCEDURE ( l : List ) RemoveLast*;

BEGIN

(* ... *)

END RemoveLast;

PROCEDURE ( l : List ) RemoveAt* ( i : INTEGER );

BEGIN

(* ... *)

END RemoveAt;

END ListClass.

8. 실행 시 타입 검사 (오베론-2)

오베론-2는 객체의 타입에 대해 런타임(실행 시)에 동적 검사를 수행하는 여러 기능을 갖추고 있다. 예를 들어, `Bird` 객체의 인스턴스로 `Duck`과 `Cuckoo`가 있을 때, 오베론-2에서는 런타임에 객체의 실제 타입에 따라 처리가 가능하다.

타입 검사 방법에는 "타입 바인딩 시스템"을 사용하는 전통적인 방법, `WITH` 문을 사용하는 방법, 그리고 `IS` 연산자를 사용하는 방법이 있다.

`WITH` 문을 사용하면 변수의 동적인 파생 타입을 직접 검사할 수 있다. 타입 바인딩 시스템이나 `WITH` 문을 사용하면 파생 타입을 특정하여 해당 파생 타입에 적절한 타입 바인딩 프로시저나 타입 바인딩 변수를 사용할 수 있다.

오베론-2의 `WITH` 문은 파스칼(Pascal) 또는 모듈라-2(Modula-2)의 `WITH` 문과는 관련이 없다.
타입 바인딩 예시```oberon2

MODULE Birds;

TYPE Bird* = RECORD

sound* : ARRAY 10 OF CHAR;

END;

END Birds.

(*-------------------------------------*)

MODULE Ducks;

IMPORT Birds;

TYPE Duck* = RECORD(Birds.Bird) END;

PROCEDURE makeSound*( VAR bird: Duck );

BEGIN COPY("Quack!", bird.sound); END makeSound;

END Ducks.

(*-------------------------------------*)

MODULE Cuckoos;

IMPORT Birds;

TYPE Cuckoo* = RECORD(Birds.Bird) END;

PROCEDURE makeSound*( VAR bird: Cuckoo );

BEGIN COPY("Cuckoo!", bird.sound); END makeSound;

END Cuckoos.

```
`WITH` 문 예시```oberon2

MODULE Test;

IMPORT Out, Birds, Cuckoos, Ducks;

TYPE SomeBird* = RECORD ( Birds.Bird ) END;

VAR sb : SomeBird;

VAR c : Cuckoos.Cuckoo;

VAR d : Ducks.Duck;

PROCEDURE setSound*( VAR bird : Birds.Bird );

BEGIN

WITH bird : Cuckoos.Cuckoo DO

bird.sound := "Cuckoo!";

| bird : Ducks.Duck DO

bird.sound := "Quack!";

ELSE

bird.sound := "Tweet!";

END;

END setSound;

PROCEDURE MakeSound* ( VAR b : Birds.Bird );

BEGIN

Out.Ln;

Out.String( b.sound );

Out.Ln;

END MakeSound;

BEGIN

setSound(c);

setSound(d);

setSound(sb);

MakeSound(c);

MakeSound(d);

MakeSound(sb);

END Test.

```
`POINTER` 예시```oberon2

MODULE PointerBirds;

IMPORT Out;

TYPE BirdRec* = RECORD sound* : ARRAY 10 OF CHAR; END;

DuckRec* = RECORD(BirdRec) END;

CuckooRec* = RECORD(BirdRec) END;

TYPE Bird = POINTER TO BirdRec;

Cuckoo = POINTER TO CuckooRec;

Duck = POINTER TO DuckRec;

VAR pb : Bird;

pc : Cuckoo;

pd : Duck;

PROCEDURE makeDuckSound*( bird : Duck );

BEGIN COPY("Quack!", bird.sound) END makeDuckSound;

PROCEDURE makeCuckooSound*( bird : Cuckoo );

BEGIN COPY("Cuckoo!", bird.sound) END makeCuckooSound;

PROCEDURE makeSound*( bird : Bird );

BEGIN

WITH bird : Cuckoo DO makeCuckooSound(bird);

| bird : Duck DO makeDuckSound(bird)

ELSE

COPY("Tweet!", bird.sound);

END;

END makeSound;

BEGIN

NEW(pc);

NEW(pd);

makeCuckooSound( pc );

makeDuckSound( pd );

Out.Ln;Out.String( pc^.sound );Out.Ln;

Out.Ln;Out.String( pd^.sound );Out.Ln;

makeSound( pc );

makeSound( pd );

Out.Ln;Out.String( pc^.sound );Out.Ln;

Out.Ln;Out.String( pd^.sound );Out.Ln;

(* -------------------------------------- *)

(* Pass dynamic type to procedure *)

pb := pd;

makeDuckSound( pb(Duck) );

Out.Ln;Out.String( pb^.sound );Out.Ln;

pb := pc;

makeCuckooSound( pb(Cuckoo) );

Out.Ln;Out.String( pb^.sound );Out.Ln;

(* -------------------------------------- *)

makeSound(pb);

Out.Ln;Out.String( pb^.sound );Out.Ln;

pb := pd;

makeSound(pb);

Out.Ln;Out.String( pb^.sound );Out.Ln;

(* -------------------------------------- *)

NEW(pb);

makeSound(pb);

Out.Ln;Out.String( pb^.sound );Out.Ln;

END PointerBirds.

```

`IS` 연산자는 등호(`=`)나 부등호(`>`)와 같은 우선순위의 관계 연산자이며, 동적 타입 검사를 수행한다. 하지만 `IS` 연산자는 앞서 설명한 타입 바인딩이나 `WITH` 문과는 달리, 감지한 파생 타입에 따라 처리를 분기할 수는 없다.

참조

_[1] 보고서 From Modula to Oberon and the programming language Oberon https://doi.org/10.3[...] Wiley
_[2] 논문 The Programming Language Oberon 1988-07
_[3] 논문 From Modula to Oberon 1988-07
_[4] 논문 Type Extensions 1988-04
_[5] 간행물 Modula's Children, Part II: Oberon https://archive.org/[...]
_[6] 웹사이트 Project Oberon https://people.inf.e[...] 1987–2021
_[7] 웹사이트 Oberon Change Log https://www.inf.ethz[...] ETH Zurich 2021-01-16
_[8] 웹사이트 Compiler Construction: The Art of Niklaus Wirth ftp://ftp.ssw.uni-li[...] Johannes Kepler University
_[9] 웹사이트 Project Oberon http://www.projectob[...] 1987–2021
_[10] 웹사이트 Oxford Oberon-2 compiler http://spivey.oriel.[...] 2021-01-17
_[11] 웹사이트 Vishap Oberon Compiler https://github.com/v[...] 2021-01-17
_[12] 웹사이트 Ofront https://github.com/j[...] 2021-01-17
_[13] 보고서 The Programming Language Oberon-07 https://people.inf.e[...] 2021-01-17
_[14] 문서 Springer, Berlin Heidelberg 2006
_[15] 웹사이트 Proposal for Module Contexts http://www.ocp.inf.e[...]
_[16] PhD The active object system design and multiprocessor implementation http://e-collection.[...] Swiss Federal Institute of Technology, Zürich (ETH Zurich) 2002
_[17] 보고서 On Certain Basic Properties of Component-Oriented Programming Languages http://oberon2005.ob[...] University of California, Irvine 2021-01-18
_[18] 논문 Supporting software composition at the programming language level Elsevier B.V. 2005-04
_[19] 서적 Proceedings: Fifth International Workshop on Object-Oriented Real-Time Dependable Systems Institute of Electrical and Electronics Engineers (IEEE) 1999-11-20
_[20] 서적 Proceedings CONPAR 90: VAPP IV Conference, Diss Nr. 10277 ETH Zurich 1993
_[21] 보고서 From Modula to Oberon and the programming language Oberon https://doi.org/10.3[...] Wiley
_[22] 논문 The Programming Language Oberon https://archive.org/[...] 1988-07
_[23] 보고서 From Modula to Oberon 1988-07
_[24] 논문 Type Extensions 1988-04
_[25] 웹인용 Oberon Change Log https://www.inf.ethz[...] ETH Zurich 2021-01-16