Re: another C-like language? was Compilers :)

On 07/01/2023 11:14, marb...@yahoo.co.uk wrote:
>> [If you're doing a one-pass compiler, it's easier if all the declarations are at the
>> beginning so you can generate the code to set up the stack frame and do initializations.
>> I agree that on modern computers it's not a big deal, but remember that early C compilers
>> ran in 24K bytes and I don't mean meagabytes. -John]
>
> Presumably such a compiler would have to create 2 stack frames for
> `char *foo="foo"; puts(foo); { char *bar="bar"; puts(bar); }`


No. The compiler could treat this as though you had written :


char *foo = "foo";
char *bar_nested_scope_1;


puts(foo);
{
bar_nested_scope_1 = "bar";
puts(bar);
}


In other words, it can combine all the variables declared in nested
scope and act as though they were all defined at the start of the
function. It would have to take care of naming, as nested block scopes
could have identifiers that shadow outer scope names. And it may or may
not choose to allow overlapping of variables that have independent
lifetimes.


It only gets complicated when you have variable length arrays, which
would allow the declaration of an array whose size is not known at the
start of the function. But if you are supporting VLA's, you'll already
have support for more sophisticated mixes of variables and code.


> [In a mutant version of C with nested scopes, I suppose so, but when C compilers
> ran in 24K bytes, it didn't. -John]


I don't have my copy of K&R handy, or a pre-K&R Unix C manuals, but I
expect someone will correct me if I'm wrong :-) As far as I know, the C
described in "The C Programming Language" in 1978, when 24 KB was still
a big deal, supported declarations at the start of any compound
statement block. That is, nested scopes. It's possible that pre-K&R C
compilers were more limited.
[I actually used that 24K C compiler in about 1975 and I am reasonably sure
it did not let you put declarations other than in the outer block. There's
a 1978 edition of K&R at archive.org and by then it did let you put
declarations in any block. It's a little harder than what you say because
declarations in non-overlapping blocks should overlay each other, e.g.:


foo() {
    int a:
    ...
    {
          int b[100];
          somefunc(b);
    }
    {
          float c[100];
          otherfunc(c);
    }
}


you want b and c to use the same storage. It's not hard, but it's a little
more than promoting and renaming. -John]

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