Code size as a function of source size

Hi,


I would like to pose a very simple question, for which nevertheless I
could not find an answer through google:


      Of what general type is the dependence of the size of compiled code
to the size of the respective source code?


      Or to put it "mathematically", what function f(s) approximates the
points (s, o(s)) best, where s is the size of the source code (say in
bytes and normalized by removing commentaries and not using uncommonly
long identifiers or amounts of white space) and o(s) is the size of
the corresponding object code (without any libraries linked in). It
seems natural to assume a linear dependence, but maybe the point-cloud
(s,o(s)) introduced above falls into several sub-clouds, each having
its own characteristic function?


    The reason I am asking is, that I wrote a little Lisp compiler for a
CPU that I developed and doing some comparisons as indicated above, it
seemed to be a linear relationship with o(s) approx. 1.75 * s.
      Now I would of course like to do some comparisons with other
compilers (not necessary only Lisp compilers) for other architectures,
but I could not find any figures tabulated on the net. Does anyone have
some pointers?


Thanks in advance for all answers


J|rgen


--
J|rgen Bvhm www.aviduratas.de

Return to the comp.compilers page.
Search the comp.compilers archives again.