C Object System: a framework that brings C to the level of other high level programming languages and beyond
C C++ Objective-C Shell Other
Switch branches/tags
Nothing to show
Clone or download


#  C Object System
#  Copyright 2007+ Laurent Deniau <laurent.deniau at gmail dot com>

The motivation to develop the C Object System (COS) on top of the C language may
not be obvious. While many new languages appear each year with new syntax and
little new concepts, I prefer to try to lift C up to the level of other high
level languages. C is portable, efficient, widely available and standardised.
This is probably why it is also the reference for other languages when memory
and speed efficiency matter and why most languages have a Foreign Function
Interface to C. Still, many virtual machines, interpreters, compilers or
operating systems are written in C. If one often blame C to be a low level
language similar to a super assembler, it should be worthwhile to raise C to the
level of the other high level Object Oriented languages and beyond. This is the
aim of COS, itself entirely written in ISO C.

COS uses the C99 preprocessor to parse its DSL (Domain Specific Language)
embedded in C files and to generate pure C89 code on-the-fly during the
translation phases of C compilers, using its advanced framework of C99 macros.
The design and the DSL of COS are strongly inspired by Objective-C and CLOS
(Common Lisp Object System), one of the most flexible object model ever
developed, and to some lesser extend by Cecil, Dylan, Haskell, Python, Slate and
SmallTalk. Contrary to CLOS, COS enforces strong encapsulation and separation of
concerns through its open object model, which allows to use and to extend COS
components (e.g. classes) defined in shared libraries without having the source
code (see papers).

The core of COS is only 7,000 SLOC and fulfils very well the five principles it
aims: simplicity, flexibility, extensibility, efficiency and portability. It is
available on GitHub and described in DLS'09 and OOPSLA'09 papers, and a
presentation available in the doc directory. It tries to keep minimal the
available concepts for the sake of simplicity and flexibility: uniform object
model, open classes, metaclasses, property metaclasses, generics, multimethods,
delegation, ownership, properties, exceptions, contracts and closures.

COS design is tuned to provide efficient portable implementation of these
concepts, especially for its two key features: dynamic message dispatch
supporting multimethods (i.e. many receivers) as well as generic message
forwarding (i.e. delegation without limitations). COS message dispatch is
x1.7-x2.3 slower than indirect function call (called through pointers) and about
x1.2-x1.5 faster than Objective-C message dispatch. COS message forwarding is as
fast as message dispatch and about x40-x80 faster than Objective-C message
forwarding, which has strong limitations on the returned values. On top of these
two efficient concepts, it is easy to implement high order messages, class-
predicate dispatch, multiple inheritance, dynamic inheritance, dynamic classes,
adaptive object model, reflection and advanced memory management (some of them
are described in the papers).

COS achieves the principles of simplicity, flexibility and extensibility as well
as existing mainstream scripting languages (e.g. PHP, Python, Ruby, Lua,
SmallTalk) while keeping the efficiency and the portability in the range of C.
It can be used as both a dynamically or a statically typed programming language
(see fast sorting of heterogeneous Array for an example of mixed use). COS is
also designed for parallelisation, and it is compliant with TLS (Thread Local
Storage), OpenMP and POSIX threads. Its minimal requirement is a C99
preprocessor and a C89 compiler.

Project information:

  - web site : http://github.com/CObjectSystem
  - license  : http://www.apache.org/licenses/LICENSE-2.0
  - contact  : laurent.deniau at gmail dot com


paper and presentation can be found in

or after installation to

or on arXiv.org

Wiki on CLOS:

Makefile examples:

# distrib

# library

# program

# tests (program with auto-run)

Debugging makefiles:

make [target] SHOW=yes

# debug flags
SHOW will show the commands run

Code examples:


Supported platforms:

note: platforms name are detected using the posix command "uname -s"

the list of supported platforms are in the directory

or after installation to

porting on Unixes/Posix compliant platform should be straightforward
porting on Windows requires some Posix-like environment (e.g. Mingw, Cygwin)

Tested platforms:

# Systems & Architectures
Linux Ubuntu from 8.04 to 12.04 on i386 and x86_64 multicore
Mac OSX from Leopard to El Capitan on x86_64 multicore
Windows from 7 to 10 on x86_64 multicore using MSys2 (mingw64)

# Compilers
gcc from 3.2.3 to 4.8.5

Other available platforms (untested):
SunOS + gcc
FreeBSD + gcc