An object addressing mechanism for statically typed languages with multiple inheritance

RCH Connor; Alan Dearle; Ronald Morrison; AL Brown

doi:10.1145/74878.74906

An object addressing mechanism for statically typed languages with multiple inheritance

RCH Connor, Alan Dearle, Ronald Morrison, AL Brown

School of Computer Science

Research output: Chapter in Book/Report/Conference proceeding › Conference contribution

Abstract

In this paper we are concerned with addressing techniques for statically typed languages with multiple inheritance. The addressing techniques are responsible for the efficient implementation of record field selection. In object-oriented languages, this record selection is equivalent to the access of methods. Thus, the efficiency of these techniques greatly affects the overall performance of an object-oriented language. We will demonstrate that addresses, in such systems, cannot always be calculated statically and show how symbol tables have been used as address maps at run time. The essence of the paper is a new addressing technique that can statically calculate either the address of a field or the address of the address of the field. This technique is powerful enough to support an efficient implementation of multiple inheritance with implicit subtyping as described by Cardelli.

Original language	English
Title of host publication	Proceedings of the 1989 ACM OOPSLA Conference on Object-oriented Programming (OOPSLA'89)
Editors	Richard L. Wexelblat
Place of Publication	New York
Publisher	ACM
Pages	279-285
DOIs	https://doi.org/10.1145/74878.74906
Publication status	Published - Oct 1989
Event	OOPSLA Conference on Object-orientated Programming (OOPSLA'89) - New Orleans, United States Duration: 2 Oct 1989 → 6 Oct 1989

Publication series

Name	ACM SIGPLAN Notices
Publisher	ACM
Number	10
Volume	24
ISSN (Print)	0362-1340
ISSN (Electronic)	1558-1160

Conference

Conference	OOPSLA Conference on Object-orientated Programming (OOPSLA'89)
Abbreviated title	OOPSLA
Country/Territory	United States
City	New Orleans
Period	2/10/89 → 6/10/89

Access to Document

10.1145/74878.74906

CDM+89
Copyright © 1989 ACM. This work has been made available online in accordance with publisher policies or with permission. Permission for further reuse of this content should be sought from the publisher or the rights holder. This is the author created accepted manuscript following peer review and may differ slightly from the final published version. The final published version of this work is available at https://doi.org/10.1145/74878.74906
Other version, 46.2 KB

Cite this

@inproceedings{c9aa3902a85a458c9c7afb630e5e3d6a,

title = "An object addressing mechanism for statically typed languages with multiple inheritance",

abstract = "In this paper we are concerned with addressing techniques for statically typed languages with multiple inheritance. The addressing techniques are responsible for the efficient implementation of record field selection. In object-oriented languages, this record selection is equivalent to the access of methods. Thus, the efficiency of these techniques greatly affects the overall performance of an object-oriented language. We will demonstrate that addresses, in such systems, cannot always be calculated statically and show how symbol tables have been used as address maps at run time. The essence of the paper is a new addressing technique that can statically calculate either the address of a field or the address of the address of the field. This technique is powerful enough to support an efficient implementation of multiple inheritance with implicit subtyping as described by Cardelli.",

author = "RCH Connor and Alan Dearle and Ronald Morrison and AL Brown",

year = "1989",

month = oct,

doi = "10.1145/74878.74906",

language = "English",

series = "ACM SIGPLAN Notices",

publisher = "ACM",

number = "10",

pages = "279--285",

editor = "Wexelblat, {Richard L.}",

booktitle = "Proceedings of the 1989 ACM OOPSLA Conference on Object-oriented Programming (OOPSLA'89)",

address = "United States",

note = "OOPSLA Conference on Object-orientated Programming (OOPSLA'89), OOPSLA ; Conference date: 02-10-1989 Through 06-10-1989",

}

Connor, RCH, Dearle, A , Morrison, R & Brown, AL 1989, An object addressing mechanism for statically typed languages with multiple inheritance. in RL Wexelblat (ed.), Proceedings of the 1989 ACM OOPSLA Conference on Object-oriented Programming (OOPSLA'89). ACM SIGPLAN Notices, no. 10, vol. 24, ACM, New York, pp. 279-285, OOPSLA Conference on Object-orientated Programming (OOPSLA'89), New Orleans, Louisiana, United States, 2/10/89. https://doi.org/10.1145/74878.74906

An object addressing mechanism for statically typed languages with multiple inheritance. / Connor, RCH; Dearle, Alan ; Morrison, Ronald et al.
Proceedings of the 1989 ACM OOPSLA Conference on Object-oriented Programming (OOPSLA'89). ed. / Richard L. Wexelblat. New York: ACM, 1989. p. 279-285 (ACM SIGPLAN Notices; Vol. 24, No. 10).

Research output: Chapter in Book/Report/Conference proceeding › Conference contribution

TY - GEN

T1 - An object addressing mechanism for statically typed languages with multiple inheritance

AU - Connor, RCH

AU - Dearle, Alan

AU - Morrison, Ronald

AU - Brown, AL

PY - 1989/10

Y1 - 1989/10

N2 - In this paper we are concerned with addressing techniques for statically typed languages with multiple inheritance. The addressing techniques are responsible for the efficient implementation of record field selection. In object-oriented languages, this record selection is equivalent to the access of methods. Thus, the efficiency of these techniques greatly affects the overall performance of an object-oriented language. We will demonstrate that addresses, in such systems, cannot always be calculated statically and show how symbol tables have been used as address maps at run time. The essence of the paper is a new addressing technique that can statically calculate either the address of a field or the address of the address of the field. This technique is powerful enough to support an efficient implementation of multiple inheritance with implicit subtyping as described by Cardelli.

AB - In this paper we are concerned with addressing techniques for statically typed languages with multiple inheritance. The addressing techniques are responsible for the efficient implementation of record field selection. In object-oriented languages, this record selection is equivalent to the access of methods. Thus, the efficiency of these techniques greatly affects the overall performance of an object-oriented language. We will demonstrate that addresses, in such systems, cannot always be calculated statically and show how symbol tables have been used as address maps at run time. The essence of the paper is a new addressing technique that can statically calculate either the address of a field or the address of the address of the field. This technique is powerful enough to support an efficient implementation of multiple inheritance with implicit subtyping as described by Cardelli.

UR - https://archive.cs.st-andrews.ac.uk/papers/download/CDM+89.pdf

U2 - 10.1145/74878.74906

DO - 10.1145/74878.74906

M3 - Conference contribution

T3 - ACM SIGPLAN Notices

SP - 279

EP - 285

BT - Proceedings of the 1989 ACM OOPSLA Conference on Object-oriented Programming (OOPSLA'89)

A2 - Wexelblat, Richard L.

PB - ACM

CY - New York

T2 - OOPSLA Conference on Object-orientated Programming (OOPSLA'89)

Y2 - 2 October 1989 through 6 October 1989

ER -

An object addressing mechanism for statically typed languages with multiple inheritance

Abstract

Publication series

Conference

Access to Document

Other files and links

Fingerprint

Cite this