Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > comp.lang.c++ > #79175 > unrolled thread

Text editor project in C

Started byjacobnavia <jacob@jacob.remcomp.fr>
First post2021-04-22 18:58 +0200
Last post2021-04-26 18:04 +0200
Articles 16 on this page of 96 — 27 participants

Back to article view | Back to comp.lang.c++


Contents

  Text editor project in C jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-22 18:58 +0200
    Re: Text editor project in C Bonita Montero <Bonita.Montero@gmail.com> - 2021-04-22 19:05 +0200
    Re: Text editor project in C wij <wyniijj@gmail.com> - 2021-04-22 12:41 -0700
      Re: Text editor project in C Juha Nieminen <nospam@thanks.invalid> - 2021-04-23 07:38 +0000
        Re: Text editor project in C wij <wyniijj@gmail.com> - 2021-04-23 05:12 -0700
          Re: Text editor project in C red floyd <myob@its.invalid> - 2021-04-23 09:24 -0700
          Re: Text editor project in C James Kuyper <jameskuyper@alumni.caltech.edu> - 2021-04-23 16:59 -0400
            Re: Text editor project in C wij <wyniijj@gmail.com> - 2021-04-23 21:43 -0700
              Re: Text editor project in C Ian Collins <ian-news@hotmail.com> - 2021-04-24 17:05 +1200
                Re: Text editor project in C wij <wyniijj@gmail.com> - 2021-04-24 00:50 -0700
                  Re: Text editor project in C "daniel...@gmail.com" <danielaparker@gmail.com> - 2021-04-24 08:50 -0700
                    Re: Text editor project in C wij <wyniijj@gmail.com> - 2021-04-24 10:41 -0700
                Re: Text editor project in C Öö Tiib <ootiib@hot.ee> - 2021-04-25 06:19 -0700
                  Re: Text editor project in C wij <wyniijj@gmail.com> - 2021-04-25 10:23 -0700
                    Re: Text editor project in C Öö Tiib <ootiib@hot.ee> - 2021-04-25 12:46 -0700
                      Re: Text editor project in C wij <wyniijj@gmail.com> - 2021-04-25 20:34 -0700
                        Re: Text editor project in C Öö Tiib <ootiib@hot.ee> - 2021-04-28 09:57 -0700
                          Re: Text editor project in C wij <wyniijj@gmail.com> - 2021-04-29 10:56 -0700
                  Re: Text editor project in C jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-27 18:31 +0200
                    Re: Text editor project in C David Brown <david.brown@hesbynett.no> - 2021-04-28 09:01 +0200
                      Re: Text editor project in C Manfred <noname@add.invalid> - 2021-04-28 14:54 +0200
                        Re: Text editor project in C Juha Nieminen <nospam@thanks.invalid> - 2021-04-29 04:47 +0000
                          Re: Text editor project in C Paavo Helde <myfirstname@osa.pri.ee> - 2021-04-29 11:42 +0300
                            Re: Text editor project in C Christian Gollwitzer <auriocus@gmx.de> - 2021-04-29 23:04 +0200
    Re: Text editor project in C Juha Nieminen <nospam@thanks.invalid> - 2021-04-23 07:55 +0000
      Re: Text editor project in C jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-23 11:25 +0200
        Re: Text editor project in C "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-23 12:45 -0700
          Re: Text editor project in C jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-23 22:29 +0200
            Re: Text editor project in C "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-23 13:34 -0700
              Re: Text editor project in C "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-23 13:37 -0700
              Re: Text editor project in C jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-23 22:40 +0200
                Re: Text editor project in C "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-23 13:51 -0700
                  Re: Text editor project in C "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-23 13:55 -0700
                  Re: Text editor project in C jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-23 23:02 +0200
                    Re: Text editor project in C "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-23 14:13 -0700
                      Re: Text editor project in C "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-23 15:39 -0700
                      Re: Text editor project in C Bart <bc@freeuk.com> - 2021-04-24 01:20 +0100
                        Re: Text editor project in C "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-23 17:43 -0700
                      Re: Text editor project in C kegs@provalid.com (Kent Dickey) - 2021-04-25 00:04 -0500
                        Re: Text editor project in C "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-24 22:29 -0700
                        Re: Text editor project in C "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-24 23:05 -0700
                        Re: Text editor project in C Paavo Helde <myfirstname@osa.pri.ee> - 2021-04-25 10:57 +0300
                          Re: Text editor project in C "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-25 01:18 -0700
                            Re: Text editor project in C Paavo Helde <myfirstname@osa.pri.ee> - 2021-04-25 11:28 +0300
                            Re: Text editor project in C James Kuyper <jameskuyper@alumni.caltech.edu> - 2021-04-25 15:02 -0400
                              Re: Text editor project in C "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-26 01:25 -0700
                              Re: Text editor project in C "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-26 01:26 -0700
                    Re: Text editor project in C "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-23 14:15 -0700
              Re: Text editor project in C scott@slp53.sl.home (Scott Lurndal) - 2021-04-23 22:25 +0000
                Re: Text editor project in C "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-23 15:31 -0700
            Re: Text editor project in C "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-23 13:38 -0700
              Re: Text editor project in C scott@slp53.sl.home (Scott Lurndal) - 2021-04-23 22:27 +0000
                Re: Text editor project in C "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-23 15:34 -0700
                  Re: Text editor project in C scott@slp53.sl.home (Scott Lurndal) - 2021-04-24 16:33 +0000
                    Re: Text editor project in C "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-24 22:59 -0700
            Re: Text editor project in C Juha Nieminen <nospam@thanks.invalid> - 2021-04-26 05:22 +0000
              Re: Text editor project in C jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-26 10:00 +0200
                Re: Text editor project in C Juha Nieminen <nospam@thanks.invalid> - 2021-04-26 09:57 +0000
                  Re: Text editor project in C Robert Latest <boblatest@yahoo.com> - 2021-04-26 10:41 +0000
                  Re: Text editor project in C jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-26 13:20 +0200
                    Re: Text editor project in C Juha Nieminen <nospam@thanks.invalid> - 2021-04-26 13:17 +0000
                      Re: Text editor project in C jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-26 19:53 +0200
                        Re: Text editor project in C David Brown <david.brown@hesbynett.no> - 2021-04-26 20:34 +0200
                          Re: Text editor project in C jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-26 22:49 +0200
                            Re: Text editor project in C David Brown <david.brown@hesbynett.no> - 2021-04-27 10:59 +0200
                    Re: Text editor project in C Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-26 22:04 +0100
                      Re: Text editor project in C Eli the Bearded <*@eli.users.panix.com> - 2021-04-26 22:19 +0000
                        Re: Text editor project in C Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2021-04-26 16:07 -0700
                        Re: Text editor project in C Joe Pfeiffer <pfeiffer@cs.nmsu.edu> - 2021-04-26 17:08 -0600
                          Re: Text editor project in C Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2021-04-26 16:57 -0700
                            Re: Text editor project in C Joe Pfeiffer <pfeiffer@cs.nmsu.edu> - 2021-04-26 21:42 -0600
                        Re: Text editor project in C Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-27 00:46 +0000
                        Re: Text editor project in C Juha Nieminen <nospam@thanks.invalid> - 2021-04-27 04:51 +0000
                          Re: Text editor project in C Joe Pfeiffer <pfeiffer@cs.nmsu.edu> - 2021-04-27 10:03 -0600
                            Re: Text editor project in C Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2021-04-27 09:20 -0700
                            Re: Text editor project in C scott@slp53.sl.home (Scott Lurndal) - 2021-04-27 16:34 +0000
                              Re: Text editor project in C Joe Pfeiffer <pfeiffer@cs.nmsu.edu> - 2021-04-27 10:55 -0600
                                Re: Text editor project in C Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-27 17:13 +0000
                                Re: Text editor project in C Lew Pitcher <lew.pitcher@digitalfreehold.ca> - 2021-04-27 17:28 +0000
                                  Re: Text editor project in C Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2021-04-27 13:33 -0700
                                Re: Text editor project in C scott@slp53.sl.home (Scott Lurndal) - 2021-04-27 19:27 +0000
                              Re: Text editor project in C Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-27 17:11 +0000
                        Re: Text editor project in C scott@slp53.sl.home (Scott Lurndal) - 2021-04-27 14:28 +0000
                          Re: Text editor project in C Juha Nieminen <nospam@thanks.invalid> - 2021-04-27 15:11 +0000
                Re: Text editor project in C Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-26 21:37 +0100
                  Re: Text editor project in C jacobnavia <jacob@jacob.remcomp.fr> - 2021-04-26 22:48 +0200
                  Re: Text editor project in C scott@slp53.sl.home (Scott Lurndal) - 2021-04-26 21:53 +0000
                    Re: Text editor project in C Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-27 01:34 +0100
              Re: Text editor project in C Guillaume <message@bottle.org> - 2021-04-26 18:48 +0200
              Re: Text editor project in C James Kuyper <jameskuyper@alumni.caltech.edu> - 2021-04-26 13:54 -0400
      Re: Text editor project in C Jorgen Grahn <grahn+nntp@snipabacken.se> - 2021-04-23 20:00 +0000
        Re: Text editor project in C Juha Nieminen <nospam@thanks.invalid> - 2021-04-26 05:29 +0000
    Re: Text editor project in C om@iki.fi (Otto J. Makela) - 2021-04-23 19:25 +0300
    Re: Text editor project in C wij <wyniijj@gmail.com> - 2021-04-24 10:55 -0700
      Re: Text editor project in C Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2021-04-24 14:21 -0700
    Re: Text editor project in C Bonita Montero <Bonita.Montero@gmail.com> - 2021-04-26 18:04 +0200

Page 5 of 5 — ← Prev page 1 2 3 4 [5]


#79339

Fromscott@slp53.sl.home (Scott Lurndal)
Date2021-04-27 19:27 +0000
Message-ID<jAZhI.77586$Y87.17799@fx08.iad>
In reply to#79335
Joe Pfeiffer <pfeiffer@cs.nmsu.edu> writes:
>scott@slp53.sl.home (Scott Lurndal) writes:
>
>> Joe Pfeiffer <pfeiffer@cs.nmsu.edu> writes:
>>>Juha Nieminen <nospam@thanks.invalid> writes:
>>>
>>>> However, the undetermined size of basic types (especially before
>>>> standardization) makes it more likely for C programs, especially ones
>>>> written back then, to be non-portable. Sure, even back when K&R first
>>>> "soft-standardized" the C language you shouldn't have assumed a certain
>>>> size for any basic type.
>>>
>>>Everybody "knew" longs were 32 bits, shorts and ints were both 16 bits,
>>>chars were 8 bits and we coded under that assumption.  Lots and lots of
>>>code broke when we moved from 16 bit to 32 bit machines and the size of
>>>an int changed as a result.
>>>
>>
>> And, unfortunately, the types often were not abstracted behind
>> a typedef.  The process identifer, group identifier and user
>> identifers were all 16-bit as well.  This made for a painful
>> conversion to 32-bit PID/GID/UID in SVR4 (accompanied by abstract
>> types pid_t, gid_t, uid_t which, when used correctly, mean that
>> applications only needed a simple recompile to handle a change in width).
>
>There were no typedefs back then (at least I don't remember them that
>far back, and they don't appear in either Ritchie's reference manual nor
>Kernighan's tutorial).

At the time of the SVR4 conversion in 1989, typedef was part of the
language, and pid_t, gid_t, and uid_t were used subsequently for
those purposes respectively.  In addition, all API's were modified
to use those abstract types both in SVR4 and via the SVID into
POSIX.

[toc] | [prev] | [next] | [standalone]


#79336

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-04-27 17:11 +0000
Message-ID<20210427101045.155@kylheku.com>
In reply to#79334
On 2021-04-27, Scott Lurndal <scott@slp53.sl.home> wrote:
> Joe Pfeiffer <pfeiffer@cs.nmsu.edu> writes:
>>Juha Nieminen <nospam@thanks.invalid> writes:
>>
>>> However, the undetermined size of basic types (especially before
>>> standardization) makes it more likely for C programs, especially ones
>>> written back then, to be non-portable. Sure, even back when K&R first
>>> "soft-standardized" the C language you shouldn't have assumed a certain
>>> size for any basic type.
>>
>>Everybody "knew" longs were 32 bits, shorts and ints were both 16 bits,
>>chars were 8 bits and we coded under that assumption.  Lots and lots of
>>code broke when we moved from 16 bit to 32 bit machines and the size of
>>an int changed as a result.
>>
>
> And, unfortunately, the types often were not abstracted behind
> a typedef.

Equally unfortunately, types were often abstracted behind bad typedefs.

:)


-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal

[toc] | [prev] | [next] | [standalone]


#79328

Fromscott@slp53.sl.home (Scott Lurndal)
Date2021-04-27 14:28 +0000
Message-ID<CcVhI.13133$od.6566@fx15.iad>
In reply to#79309
Eli the Bearded <*@eli.users.panix.com> writes:
>In comp.lang.c, Ben Bacarisse  <ben.usenet@bsb.me.uk> wrote:
>> There was no C code 50 years ago.  This is a bit of a quibble since
>> there was C code we'd just about recognise in about 1973 or 4, but some
>> of it would fool even gcc today.  The biggest change was the great =<op>
>> to <op>= switch.  This silently changed the meaning of a lot of code.
>
>Maybe five years ago I tried to compile some C code I found in buried
>in a tar file on a dusty ftp server[*]. The READ_ME implied it was last
>touched in June of 1980, the filename agreed with the year.
>
>Things I found tricky about the code:
>
>1. It predated printf being called that. I think it was just using
>   print(). And that used "-lS" in the Makefile.

printf was printf from day one.   Sounds like 'print' was provided
by an implementation library that wasn't included with the tar file you resurrected.

>
>2. Prototypes? Who needs em? ("#include <stdio.h>"? What, why?)

Prototypes were not used at the time, argument types were
'flexible', the programmer was expected to do the right thing.

>
>3. No need to declare ints, eg:
>       main(argc, argv)
>       char **argv;
>       {
>
>4. Structs are implicitly unions:
>       struct  plot {
>           char    p_x;
>           char    p_y;
>       } p_plot[LIM_PLOTS];

Now this isn't a union.  p_x and p_y occupy unique memory
locations.

But member names (MoS - Member of Structure) were top-level
symbol table names, so any member from any struct could be
used with any other struct, so:
a
>
>       /* ... */
>
>       struct        {
>             int     p_xy;           /* used to set/transfer entire plot */
>       };

p_xy has offset zero from the start of the structure; when software
uses p_xy  (e.g. structpointer->p_xy) it has offset zero which allows
16-bit accesses to the two 8-bit fields in the p_plot struct.

>
>5. Implicit in above: seems like there is the expectation that
>   sizeof(int) == 2.

Yes, for that particular application, it was assumed that
sizeof(int) == 2 * sizeof(char).  Which was the case on the
PDP-11.

[toc] | [prev] | [next] | [standalone]


#79330

FromJuha Nieminen <nospam@thanks.invalid>
Date2021-04-27 15:11 +0000
Message-ID<s699j2$jaq$1@gioia.aioe.org>
In reply to#79328
In comp.lang.c++ Scott Lurndal <scott@slp53.sl.home> wrote:
>>2. Prototypes? Who needs em? ("#include <stdio.h>"? What, why?)
> 
> Prototypes were not used at the time, argument types were
> 'flexible', the programmer was expected to do the right thing.

I love the example given in the original 1978 The C Programming
Language, which demonstrates how non-int-returning standard
library functions ought to be used:

    FILE *fopen(), *in;
    in = fopen("name", "r");

Apparently back in those days <stdio.h> couldn't be expected
to declare the fopen function.

[toc] | [prev] | [next] | [standalone]


#79303

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-04-26 21:37 +0100
Message-ID<87czughjez.fsf@bsb.me.uk>
In reply to#79268
jacobnavia <jacob@jacob.remcomp.fr> writes:

> Since you spoke of a simple editor project in C, I showed you one
> written 50 years ago of just 1700 lines. It compiles and runs 50 years
> later. Please show me a complex program in C++ from 2000 that compiles
> unmodified and runs today.

The posted code can't be 50 years old.  ed is 50 years old, but the
original was not written in C (there was no C in 1971).

The version posted uses void and function prototypes so it dates from
the time C was first being standardised.  A comment says it has been
slightly modified.  It would be nice to know if that was necessary to
get it to compile, and if so, what the modification was.

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#79304

Fromjacobnavia <jacob@jacob.remcomp.fr>
Date2021-04-26 22:48 +0200
Message-ID<s678uc$dbt$1@dont-email.me>
In reply to#79303
Le 26/04/2021 à 22:37, Ben Bacarisse a écrit :
> jacobnavia <jacob@jacob.remcomp.fr> writes:
> 
>> Since you spoke of a simple editor project in C, I showed you one
>> written 50 years ago of just 1700 lines. It compiles and runs 50 years
>> later. Please show me a complex program in C++ from 2000 that compiles
>> unmodified and runs today.
> 
> The posted code can't be 50 years old.  ed is 50 years old, but the
> original was not written in C (there was no C in 1971).
> 

OK, granted

> The version posted uses void and function prototypes so it dates from
> the time C was first being standardised.  A comment says it has been
> slightly modified.  It would be nice to know if that was necessary to
> get it to compile, and if so, what the modification was.
> 

I modifiedit to get rid of warnings of gcc, by changing char * into 
unsigned char *. Not a big deal. You can download the original from  the 
URL I included

[toc] | [prev] | [next] | [standalone]


#79308

Fromscott@slp53.sl.home (Scott Lurndal)
Date2021-04-26 21:53 +0000
Message-ID<gDGhI.32856$D16.32548@fx40.iad>
In reply to#79303
Ben Bacarisse <ben.usenet@bsb.me.uk> writes:
>jacobnavia <jacob@jacob.remcomp.fr> writes:
>
>> Since you spoke of a simple editor project in C, I showed you one
>> written 50 years ago of just 1700 lines. It compiles and runs 50 years
>> later. Please show me a complex program in C++ from 2000 that compiles
>> unmodified and runs today.
>
>The posted code can't be 50 years old.  ed is 50 years old, but the
>original was not written in C (there was no C in 1971).

ed first appeared in V2.  ed2.s and ed3.s

https://minnie.tuhs.org/cgi-bin/utree.pl?file=V2/cmd/ed2.s

ed.c first appeared in V6 (1975).

https://minnie.tuhs.org/cgi-bin/utree.pl?file=V6/usr/source/s1/ed.c

[toc] | [prev] | [next] | [standalone]


#79313

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-04-27 01:34 +0100
Message-ID<87mttkftua.fsf@bsb.me.uk>
In reply to#79308
scott@slp53.sl.home (Scott Lurndal) writes:

> Ben Bacarisse <ben.usenet@bsb.me.uk> writes:
>>jacobnavia <jacob@jacob.remcomp.fr> writes:
>>
>>> Since you spoke of a simple editor project in C, I showed you one
>>> written 50 years ago of just 1700 lines. It compiles and runs 50 years
>>> later. Please show me a complex program in C++ from 2000 that compiles
>>> unmodified and runs today.
>>
>>The posted code can't be 50 years old.  ed is 50 years old, but the
>>original was not written in C (there was no C in 1971).
>
> ed first appeared in V2.  ed2.s and ed3.s

Oh.  I found a man page dated 1971 in V1 Unix.

> https://minnie.tuhs.org/cgi-bin/utree.pl?file=V2/cmd/ed2.s
>
> ed.c first appeared in V6 (1975).

Yup.  ed.c can't predate C!

> https://minnie.tuhs.org/cgi-bin/utree.pl?file=V6/usr/source/s1/ed.c

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#79298

FromGuillaume <message@bottle.org>
Date2021-04-26 18:48 +0200
Message-ID<s66qtf$506$1@gioia.aioe.org>
In reply to#79264
Le 26/04/2021 à 07:22, Juha Nieminen a écrit :
> In comp.lang.c++ jacobnavia <jacob@jacob.remcomp.fr> wrote:
>> The malloc allocates the working area of the editor. It is not freed
>> because it will be always needed; it is realloc'ed when needed, and
>> freed by the OS when the program terminates. This is abvious for anyone
>> reading C.
> 
> The main point is that malloc()'ing something and not free()'ing it is
> bad practice. Not only does it teach you bad habits, it teaches other
> people reading the code this same bad habit.
Whereas I personally agree with this, I reckon there are different ways 
of seeing it, some in favor of actually doing exactly what they did.

If you assume that all malloc'ed memory will be reclaimed when the 
program terminates, then not explicitely freeing it in this case (where 
you would be free it just before the program terminates anyway) actually 
makes sense and shows you know what you're doing. One can even argue 
that useless statements are just code pollution.

Now regarding the above assumption, whereas it's reasonable on any 
"decent" OS, including the one(s) the authors were targetting at the 
time they wrote this piece of code, I could not find any explicit 
mention of this in the C standard regarding memory allocation - unless 
of course I missed it, which means the hosted environment is not 
required to reclaim allocated memory upon program termination. It's 
implementation-defined, thus the quoted program is, by definition, 
non-portable. Which is one good reason to claim it's bad practice indeed.

As to another reason why I would not do this: code reusability. I tend 
to write code so that it can be reused. The way it's implemented in the 
quoted program, it's just not reusable if you wanted to make a "text 
editor" component out of it and reuse it in a completely different program.

[toc] | [prev] | [next] | [standalone]


#79300

FromJames Kuyper <jameskuyper@alumni.caltech.edu>
Date2021-04-26 13:54 -0400
Message-ID<s66uor$bg2$1@dont-email.me>
In reply to#79264
On 4/26/21 1:22 AM, Juha Nieminen wrote:
...
> The main point is that malloc()'ing something and not free()'ing it is
> bad practice. Not only does it teach you bad habits, it teaches other
> people reading the code this same bad habit. This is especially
> egregious in code that's being used for didactic purposes out there,
> for thousands and thousands of students to see.

There's a fundamental problem with arguments of that type: if the person
you're arguing with doesn't already accept that it is a bad practice,
he's not going to have any problems with teaching others to adopt it. If
he does accept that it's a bad practice, he'll stop using it for that
reason alone, and will then automatically become a good example for
others to follow. So bringing up the effects on other people doesn't
actually do anything useful for your argument.

[toc] | [prev] | [next] | [standalone]


#79211

FromJorgen Grahn <grahn+nntp@snipabacken.se>
Date2021-04-23 20:00 +0000
Message-ID<slrns869qd.2ptb.grahn+nntp@frailea.sa.invalid>
In reply to#79190
["Followup-To:" header set to comp.lang.c.]

On Fri, 2021-04-23, Juha Nieminen wrote:
> In comp.lang.c++ jacobnavia <jacob@jacob.remcomp.fr> wrote:
>> Attached is the source code for the 10th edition of Unix of the "ed" 
>> text editor, published by Brian Kernighan for his CS classes at 
>> Princeton in 2001.
>
> Maybe it has significant historic value, but as a C program I don't think
> it's that great.
>
> It's quite hard to decipher (especially since it follows the typical
> 70's and 80's C style of using very short cryptic names everywhere),

IMO, longer names without any other improvements, aren't an
improvement.  The global 'int pflag' here, for example, would suck no
matter how you rename it.  If it's changed to an enum, and wrapped and
documented in a struct EditorState[1], it doesn't need to be renamed.

(But I have a maths background, and like short names.)

/Jorgen

[1] I may misremember the code -- I only took a brief look.

-- 
  // Jorgen Grahn <grahn@  Oo  o.   .     .
\X/     snipabacken.se>   O  o   .

[toc] | [prev] | [next] | [standalone]


#79265

FromJuha Nieminen <nospam@thanks.invalid>
Date2021-04-26 05:29 +0000
Message-ID<s65j3m$9dc$1@gioia.aioe.org>
In reply to#79211
In comp.lang.c++ Jorgen Grahn <grahn+nntp@snipabacken.se> wrote:
> ["Followup-To:" header set to comp.lang.c.]
> 
> On Fri, 2021-04-23, Juha Nieminen wrote:
>> In comp.lang.c++ jacobnavia <jacob@jacob.remcomp.fr> wrote:
>>> Attached is the source code for the 10th edition of Unix of the "ed" 
>>> text editor, published by Brian Kernighan for his CS classes at 
>>> Princeton in 2001.
>>
>> Maybe it has significant historic value, but as a C program I don't think
>> it's that great.
>>
>> It's quite hard to decipher (especially since it follows the typical
>> 70's and 80's C style of using very short cryptic names everywhere),
> 
> IMO, longer names without any other improvements, aren't an
> improvement.  The global 'int pflag' here, for example, would suck no
> matter how you rename it.  If it's changed to an enum, and wrapped and
> documented in a struct EditorState[1], it doesn't need to be renamed.

I don't agree. Code becomes more readable when cryptic and non-descript
names are changed to names that make the code more self-documenting,
even without any other changes.

As an example, suppose you see a line of code like this:

    convert(a, b);

Well, that doesn't say much. We have absolutely no way of knowing what
it does. But suppose the function were renamed to:

    convert_string_to_wstring(a, b);

Ah, now we are talking. Now it actually says what it's doing.
There's of course still the minor problem that we don't know which
parameter is the string, and which one is the wstring. But we can also
rename the variables:

    convert_string_to_wstring(dest, src);

And suddenly, a line of code that told us absolutely nothing, now
tells us everything.

(The above example is actually based on actual production code I have seen.)

[toc] | [prev] | [next] | [standalone]


#79201

Fromom@iki.fi (Otto J. Makela)
Date2021-04-23 19:25 +0300
Message-ID<87tunx3r3p.fsf@tigger.extechop.net>
In reply to#79175
jacobnavia <jacob@jacob.remcomp.fr> wrote:

> Attached is the source code for the 10th edition of Unix of the "ed"
> text editor, published by Brian Kernighan for his CS classes at 
> Princeton in 2001.

I like that it indeed does compile, but the fact that there are hardly
any comments, nor do the variable names really explain what is going on
hardly makes this a shining example of recommendable coding practices.

-- 
   /* * * Otto J. Makela <om@iki.fi> * * * * * * * * * */
  /* Phone: +358 40 765 5772, ICBM: N 60 10' E 24 55' */
 /* Mail: Mechelininkatu 26 B 27,  FI-00100 Helsinki */
/* * * Computers Rule 01001111 01001011 * * * * * * */

[toc] | [prev] | [next] | [standalone]


#79244

Fromwij <wyniijj@gmail.com>
Date2021-04-24 10:55 -0700
Message-ID<0bd2f6c0-0a8f-4072-9034-e3182fd7e707n@googlegroups.com>
In reply to#79175
On Friday, 23 April 2021 at 00:58:41 UTC+8, jacobnavia wrote:
> Recently, somebody started a thread about how C wasn't a simple 
> language. The excuse was a text editor project for a beginner. 
> 
> Attached is the source code for the 10th edition of Unix of the "ed" 
> text editor, published by Brian Kernighan for his CS classes at 
> Princeton in 2001. 
> 
> Maybe C is not a simple language but one of its incredible strengths is 
> its stability. This code is around 40 (yes FORTY) years old and you can 
> compile it without any trouble today and it will work in any UNIX system. 
> 
> ----------------------------------------------------------------cut here 
> /* This file contains the source for the 10th Edition Unix version of 
> ed, which is 
> 1700 lines long. It dates from about 1989, but is typical of Unix 
> code from the 
> mid 1970's: terse, tight, efficient, and largely uncommented 
> This is a slightly modified version that compiles without any 
> warnings under gcc in 2021 
> See https://www.cs.princeton.edu/courses/archive/spring01/cs333/ed.c 
> Compile with gcc -O2 -o ed -Wall -Wno-parentheses ed.c 
> */ 
> #include <signal.h> 
> #include <stdlib.h> 
> #include <setjmp.h> 
> #include <stdio.h> 
> #include <unistd.h> 
> #include <fcntl.h> 
> #include <wait.h> 
> #include <string.h> 
> #define BLKSIZE 4096 /* make BLKSIZE and LBSIZE 512 for smaller machines */ 
> #define NBLK 2047 
> #define FNSIZE 128 
> #define LBSIZE 4096 
> #define ESIZE 256 
> #define GBSIZE 256 
> #define NBRA 5 
> #define KSIZE 9 
> #define CBRA 1 
> #define CCHR 2 
> #define CDOT 4 
> #define CCL 6 
> #define NCCL 8 
> #define CDOL 10 
> #define CEOF 11 
> #define CKET 12 
> #define CBACK 14 
> #define CCIRC 15 
> #define STAR 01 
> static unsigned char Q[] = ""; 
> static unsigned char T[] = "TMP"; 
> #define READ 0 
> #define WRITE 1 
> static int peekc; 
> static int lastc; 
> static unsigned char savedfile[FNSIZE]; 
> static unsigned char file[FNSIZE]; 
> static unsigned char linebuf[LBSIZE]; 
> static unsigned char rhsbuf[LBSIZE/2]; 
> static unsigned char expbuf[ESIZE+4]; 
> static int given; 
> static unsigned int *addr1, *addr2; 
> static unsigned int *dot, *dol, *zero; 
> static unsigned char genbuf[LBSIZE]; 
> static long count; 
> static unsigned char *nextip; 
> static unsigned char *linebp; 
> static int ninbuf; 
> static int io; 
> static int pflag; 
> static int vflag = 1; 
> static int oflag; 
> static int listf; 
> static int listn; 
> static int col; 
> static unsigned char *globp; 
> static int tfile = -1; 
> static int tline; 
> static char tfname[50]; 
> static unsigned char *loc1; 
> static unsigned char *loc2; 
> static unsigned char ibuff[BLKSIZE]; 
> static int iblock = -1; 
> static unsigned char obuff[BLKSIZE]; 
> static int oblock = -1; 
> static int ichanged; 
> static int nleft; 
> static char WRERR[] = "WRITE ERROR"; 
> static int names[26]; 
> static int anymarks; 
> static unsigned char *braslist[NBRA]; 
> static unsigned char *braelist[NBRA]; 
> static int nbra; 
> static int subnewa; 
> static int subolda; 
> static int fchange; 
> static int wrapp; 
> static unsigned nlall = 128; 
> static char tmpXXXXX[50] = "/tmp/eXXXXXX"; 
> 
> static unsigned char *getblock(unsigned int atl, int iof); 
> static unsigned char *GetLine(unsigned int tl); 
> static unsigned char *place(unsigned char *sp,unsigned char *l1,unsigned 
> char *l2); 
> static void add(int i); 
> static int advance(unsigned char *lp, unsigned char *ep); 
> static int append(int (*f)(void), unsigned int *a); 
> static int backref(int i,unsigned char *lp); 
> static void blkio(int b, unsigned char *buf, int iof); 
> static void callunix(void); 
> static int cclass(unsigned char *set, int c, int af); 
> static void commands(void); 
> static void compile(int eof); 
> static int compsub(void); 
> static void dosub(void); 
> static void error(unsigned char *s); 
> static int execute(unsigned int *addr); 
> static void exfile(void); 
> static void filename(int comm); 
> static void gdelete(void); 
> static int getchr(void); 
> static int getcopy(void); 
> static int getfile(void); 
> static int getnum(void); 
> static int getsub(void); 
> static int gettty(void); 
> static int gety(void); 
> static void global(int k); 
> static void init(void); 
> static unsigned int *address(void); 
> static void join(void); 
> static void move(int cflag); 
> static void newline(void); 
> static void nonzero(void); 
> static void onhup(int n); 
> static void onintr(int n); 
> static void print(void); 
> static void putchr(int ac); 
> static void putd(void); 
> static void putfile(void); 
> static int putline(void); 
> static void quit(int n); 
> static void rdelete(unsigned int *ad1, unsigned int *ad2); 
> static void reverse(unsigned int *a1, unsigned int *a2); 
> static void setwide(void); 
> static void setnoaddr(void); 
> static void squeeze(int i); 
> static void substitute(int inglob); 
> static jmp_buf savej; 
> typedef void (*SIG_TYP)(int); 
> static SIG_TYP oldhup; 
> static SIG_TYP oldquit; 
> /* these two are not in ansi, but we need them */ 
> #define SIGHUP 1 /* hangup */ 
> #define SIGQUIT 3 /* quit (ASCII FS) */ 
> 
> int main(int argc, char *argv[]) 
> { 
> unsigned char *p1, *p2; 
> SIG_TYP oldintr; 
> 
> oldquit = signal(SIGQUIT, SIG_IGN); 
> oldhup = signal(SIGHUP, SIG_IGN); 
> oldintr = signal(SIGINT, SIG_IGN); 
> if (signal(SIGTERM, SIG_IGN) == SIG_DFL) 
> signal(SIGTERM, quit); 
> argv++; 
> while (argc > 1 && **argv=='-') { 
> switch((*argv)[1]) { 
> 
> case '\0': 
> vflag = 0; 
> break; 
> 
> case 'q': 
> signal(SIGQUIT, SIG_DFL); 
> vflag = 1; 
> break; 
> 
> case 'o': 
> oflag = 1; 
> break; 
> } 
> argv++; 
> argc--; 
> } 
> if (oflag) { 
> p1 = (unsigned char *)"/dev/stdout"; 
> p2 = savedfile; 
> while (*p2++ = *p1++) 
> ; 
> } 
> if (argc>1) { 
> p1 = (unsigned char *)*argv; 
> p2 = savedfile; 
> while (*p2++ = *p1++) 
> if (p2 >= &savedfile[sizeof(savedfile)]) 
> p2--; 
> globp = (unsigned char *)"r"; 
> } 
> zero = (unsigned *)malloc(nlall*sizeof(unsigned)); 
> strcpy(tfname,tmpXXXXX); 
> mkstemp(tfname); 
> 
> init(); 
> if (oldintr!=SIG_IGN) 
> signal(SIGINT, onintr); 
> if (oldhup!=SIG_IGN) 
> signal(SIGHUP, onhup); 
> setjmp(savej); 
> commands(); 
> quit(0); 
> return 0; 
> } 
> static void commands(void) 
> { 
> unsigned int *a1; 
> int c; 
> int temp; 
> unsigned char lastsep; 
> 
> for (;;) { 
> if (pflag) { 
> pflag = 0; 
> addr1 = addr2 = dot; 
> print(); 
> } 
> c = '\n'; 
> for (addr1 = 0;;) { 
> lastsep = c; 
> a1 = address(); 
> c = getchr(); 
> if (c!=',' && c!=';') 
> break; 
> if (lastsep==',') 
> error(Q); 
> if (a1==0) { 
> a1 = zero+1; 
> if (a1>dol) 
> a1--; 
> } 
> addr1 = a1; 
> if (c==';') 
> dot = a1; 
> } 
> if (lastsep!='\n' && a1==0) 
> a1 = dol; 
> if ((addr2=a1)==0) { 
> given = 0; 
> addr2 = dot; 
> } 
> else 
> given = 1; 
> if (addr1==0) 
> addr1 = addr2; 
> switch(c) { 
> case 'a': 
> add(0); 
> continue; 
> case 'c': 
> nonzero(); 
> newline(); 
> rdelete(addr1, addr2); 
> append(gettty, addr1-1); 
> continue; 
> case 'd': 
> nonzero(); 
> newline(); 
> rdelete(addr1, addr2); 
> continue; 
> case 'E': 
> fchange = 0; 
> c = 'e'; 
> case 'e': 
> setnoaddr(); 
> if (vflag && fchange) { 
> fchange = 0; 
> error(Q); 
> } 
> filename(c); 
> init(); 
> addr2 = zero; 
> goto caseread; 
> case 'f': 
> setnoaddr(); 
> filename(c); 
> puts((const char *)savedfile); 
> continue; 
> case 'g': 
> global(1); 
> continue; 
> case 'i': 
> add(-1); 
> continue; 
> case 'j': 
> if (!given) 
> addr2++; 
> newline(); 
> join(); 
> continue; 
> case 'k': 
> nonzero(); 
> if ((c = getchr()) < 'a' || c > 'z') 
> error(Q); 
> newline(); 
> names[c-'a'] = *addr2 & ~01; 
> anymarks |= 01; 
> continue; 
> case 'm': 
> move(0); 
> continue; 
> case 'n': 
> listn++; 
> newline(); 
> print(); 
> continue; 
> case '\n': 
> if (a1==0) { 
> a1 = dot+1; 
> addr2 = a1; 
> addr1 = a1; 
> } 
> if (lastsep==';') 
> addr1 = a1; 
> print(); 
> continue; 
> case 'l': 
> listf++; 
> case 'p': 
> case 'P': 
> newline(); 
> print(); 
> continue; 
> case 'Q': 
> fchange = 0; 
> case 'q': 
> setnoaddr(); 
> newline(); 
> quit(0); 
> case 'r': 
> filename(c); 
> caseread: 
> if ((io = open((const char *)file, 0)) < 0) { 
> lastc = '\n'; 
> error(file); 
> } 
> setwide(); 
> squeeze(0); 
> ninbuf = 0; 
> c = zero != dol; 
> append(getfile, addr2); 
> exfile(); 
> fchange = c; 
> continue; 
> case 's': 
> nonzero(); 
> substitute(globp!=0); 
> continue; 
> case 't': 
> move(1); 
> continue; 
> case 'u': 
> nonzero(); 
> newline(); 
> if ((*addr2&~01) != subnewa) 
> error(Q); 
> *addr2 = subolda; 
> dot = addr2; 
> continue; 
> case 'v': 
> global(0); 
> continue; 
> case 'W': 
> wrapp++; 
> case 'w': 
> setwide(); 
> squeeze(dol>zero); 
> if ((temp = getchr()) != 'q' && temp != 'Q') { 
> peekc = temp; 
> temp = 0; 
> } 
> filename(c); 
> if(!wrapp || 
> ((io = open((const char *)file,1)) == -1) || 
> ((lseek(io, 0L, 2)) == -1)) 
> if ((io = creat((const char *)file, 0666)) < 0) 
> error(file); 
> wrapp = 0; 
> if (dol > zero) 
> putfile(); 
> exfile(); 
> if (addr1<=zero+1 && addr2==dol) 
> fchange = 0; 
> if (temp == 'Q') 
> fchange = 0; 
> if (temp) 
> quit(0); 
> continue; 
> case '=': 
> setwide(); 
> squeeze(0); 
> newline(); 
> count = addr2 - zero; 
> putd(); 
> putchr('\n'); 
> continue; 
> case '!': 
> callunix(); 
> continue; 
> case EOF: 
> return; 
> } 
> error(Q); 
> } 
> } 
> static void print(void) 
> { 
> unsigned int *a1; 
> 
> nonzero(); 
> a1 = addr1; 
> do { 
> if (listn) { 
> count = a1-zero; 
> putd(); 
> putchr('\t'); 
> } 
> puts((const char *)GetLine(*a1++)); 
> } while (a1 <= addr2); 
> dot = addr2; 
> listf = 0; 
> listn = 0; 
> pflag = 0; 
> } 
> static unsigned int * address(void) 
> { 
> int sign; 
> unsigned int *a, *b; 
> int opcnt, nextopand; 
> int c; 
> 
> nextopand = -1; 
> sign = 1; 
> opcnt = 0; 
> a = dot; 
> do { 
> do c = getchr(); while (c==' ' || c=='\t'); 
> if ('0'<=c && c<='9') { 
> peekc = c; 
> if (!opcnt) a = zero; 
> a += sign*getnum(); 
> } else switch (c) { 
> case '$': 
> a = dol; 
> /* fall through */ 
> case '.': 
> if (opcnt) error(Q); 
> break; 
> case '\'': 
> c = getchr(); 
> if (opcnt || c<'a' || 'z'<c) error(Q); 
> a = zero; 
> do a++; while (a<=dol && names[c-'a']!=(*a&~01)); 
> break; 
> case '?': 
> sign = -sign; 
> /* fall through */ 
> case '/': 
> compile(c); 
> b = a; 
> for (;;) { 
> a += sign; 
> if (a<=zero) a = dol; 
> if (a>dol) a = zero; 
> if (execute(a)) break; 
> if (a==b) error(Q); 
> } 
> break; 
> default: 
> if (nextopand == opcnt) { 
> a += sign; 
> if (a<zero || dol<a) 
> continue; /* error(Q); */ 
> } 
> if (c!='+' && c!='-' && c!='^') { 
> peekc = c; 
> if (opcnt==0) a = 0; 
> return (a); 
> } 
> sign = 1; 
> if (c!='+') sign = -sign; 
> nextopand = ++opcnt; 
> continue; 
> } 
> sign = 1; 
> opcnt++; 
> } while (zero<=a && a<=dol); 
> error(Q); 
> /*NOTREACHED*/ 
> return 0; 
> } 
> static int getnum(void) 
> { 
> int r, c; 
> 
> r = 0; 
> while ((c=getchr())>='0' && c<='9') 
> r = r*10 + c - '0'; 
> peekc = c; 
> return (r); 
> } 
> static void setwide(void) 
> { 
> if (!given) { 
> addr1 = zero + (dol>zero); 
> addr2 = dol; 
> } 
> } 
> static void setnoaddr(void) 
> { 
> if (given) error(Q); 
> } 
> static void nonzero(void) 
> { 
> squeeze(1); 
> } 
> static void squeeze(int i) 
> { 
> if (addr1<zero+i || addr2>dol || addr1>addr2) 
> error(Q); 
> } 
> static void newline(void) 
> { 
> int c; 
> 
> if ((c = getchr()) == '\n' || c == EOF) return; 
> if (c=='p' || c=='l' || c=='n') { 
> pflag++; 
> if (c=='l') listf++; 
> else if (c=='n') listn++; 
> if ((c=getchr())=='\n') return; 
> } 
> error(Q); 
> } 
> static void filename(int comm) 
> { 
> unsigned char *p1, *p2; 
> int c; 
> 
> count = 0; 
> c = getchr(); 
> if (c=='\n' || c==EOF) { 
> p1 = savedfile; 
> if (*p1==0 && comm!='f') error(Q); 
> p2 = file; 
> while (*p2++ = *p1++) 
> ; 
> return; 
> } 
> if (c!=' ') 
> error(Q); 
> while ((c = getchr()) == ' ') 
> ; 
> if (c=='\n') error(Q); 
> p1 = file; 
> do { 
> if (p1 >= &file[sizeof(file)-1] || c==' ' || c==EOF) error(Q); 
> *p1++ = c; 
> } while ((c = getchr()) != '\n'); 
> *p1++ = 0; 
> if (savedfile[0]==0 || comm=='e' || comm=='f') { 
> p1 = savedfile; 
> p2 = file; 
> while (*p1++ = *p2++) 
> ; 
> } 
> } 
> static void exfile(void) 
> { 
> close(io); 
> io = -1; 
> if (vflag) { 
> putd(); 
> putchr('\n'); 
> } 
> } 
> static void onintr(int n) 
> { 
> signal(SIGINT, onintr); 
> putchr('\n'); 
> lastc = '\n'; 
> error(Q); 
> } 
> static void onhup(int n) 
> { 
> signal(SIGINT, SIG_IGN); 
> signal(SIGHUP, SIG_IGN); 
> if (dol > zero) { 
> addr1 = zero+1; 
> addr2 = dol; 
> io = creat("ed.hup", 0600); 
> if (io > 0) 
> putfile(); 
> } 
> fchange = 0; 
> quit(0); 
> } 
> static void error(unsigned char *s) 
> { 
> int c; 
> 
> wrapp = 0; 
> listf = 0; 
> listn = 0; 
> putchr('?'); 
> puts((const char *)s); 
> count = 0; 
> lseek(0, (long)0, 2); 
> pflag = 0; 
> if (globp) 
> lastc = '\n'; 
> globp = 0; 
> peekc = lastc; 
> if(lastc) 
> while ((c = getchr()) != '\n' && c != EOF) 
> ; 
> if (io > 0) { 
> close(io); 
> io = -1; 
> } 
> longjmp(savej, 1); 
> } 
> static int getchr(void) 
> { 
> char c; 
> if (lastc=peekc) { 
> peekc = 0; 
> return(lastc); 
> } 
> if (globp) { 
> if ((lastc = *globp++) != 0) 
> return(lastc); 
> globp = 0; 
> return(EOF); 
> } 
> if (read(0, &c, 1) <= 0) 
> return(lastc = EOF); 
> lastc = c&0177; 
> return(lastc); 
> } 
> static int gettty(void) 
> { 
> int rc; 
> 
> if (rc = gety()) 
> return(rc); 
> if (linebuf[0]=='.' && linebuf[1]==0) 
> return(EOF); 
> return(0); 
> } 
> static int gety(void) 
> { 
> int c; 
> unsigned char *gf; 
> unsigned char *p; 
> 
> p = linebuf; 
> gf = globp; 
> while ((c = getchr()) != '\n') { 
> if (c==EOF) { 
> if (gf) 
> peekc = c; 
> return(c); 
> } 
> if ((c &= 0177) == 0) 
> continue; 
> *p++ = c; 
> if (p >= &linebuf[LBSIZE-2]) 
> error(Q); 
> } 
> 
> *p++ = 0; 
> return(0); 
> } 
> static int getfile(void) 
> { 
> int c; 
> unsigned char *lp, *fp; 
> 
> lp = linebuf; 
> fp = nextip; 
> do { 
> if (--ninbuf < 0) { 
> if ((ninbuf = read(io, genbuf, LBSIZE)-1) < 0) 
> if (lp>linebuf) { 
> puts("'\\n' appended"); 
> *genbuf = '\n'; 
> } 
> else return(EOF); 
> fp = genbuf; 
> while(fp < &genbuf[ninbuf]) { 
> if (*fp++ & 0200) 
> break; 
> } 
> fp = genbuf; 
> } 
> c = *fp++; 
> if (c=='\0') 
> continue; 
> if (c&0200 || lp >= &linebuf[LBSIZE]) { 
> lastc = '\n'; 
> error(Q); 
> } 
> *lp++ = c; 
> count++; 
> } while (c != '\n'); 
> *--lp = 0; 
> nextip = fp; 
> return(0); 
> } 
> static void putfile(void) 
> { 
> unsigned int *a1; 
> int n; 
> unsigned char *fp, *lp; 
> int nib; 
> 
> nib = BLKSIZE; 
> fp = genbuf; 
> a1 = addr1; 
> do { 
> lp = GetLine(*a1++); 
> for (;;) { 
> if (--nib < 0) { 
> n = fp-genbuf; 
> if(write(io, genbuf, n) != n) { 
> puts((const char *)WRERR); 
> error(Q); 
> } 
> nib = BLKSIZE-1; 
> fp = genbuf; 
> } 
> count++; 
> if ((*fp++ = *lp++) == 0) { 
> fp[-1] = '\n'; 
> break; 
> } 
> } 
> } while (a1 <= addr2); 
> n = fp-genbuf; 
> if(write(io, genbuf, n) != n) { 
> puts((const char *)WRERR); 
> error(Q); 
> } 
> } 
> static int append(int (*f)(void), unsigned int *a) 
> { 
> unsigned int *a1, *a2, *rdot; 
> int nline, tl; 
> 
> nline = 0; 
> dot = a; 
> while ((*f)() == 0) { 
> if ((dol-zero)+1 >= nlall) { 
> unsigned *ozero = zero; 
> 
> nlall += 1024; 
> if ((zero = (unsigned *)realloc((unsigned char *)zero, 
> nlall*sizeof(unsigned)))==NULL) { 
> error((unsigned char *)"MEM?"); 
> onhup(0); 
> } 
> dot += zero - ozero; 
> dol += zero - ozero; 
> } 
> tl = putline(); 
> nline++; 
> a1 = ++dol; 
> a2 = a1+1; 
> rdot = ++dot; 
> while (a1 > rdot) 
> *--a2 = *--a1; 
> *rdot = tl; 
> } 
> return(nline); 
> } 
> static void add(int i) 
> { 
> if (i && (given || dol>zero)) { 
> addr1--; 
> addr2--; 
> } 
> squeeze(0); 
> newline(); 
> append(gettty, addr2); 
> } 
> static void callunix(void) 
> { 
> SIG_TYP savint; 
> int pid, rpid; 
> int retcode; 
> 
> setnoaddr(); 
> if ((pid = fork()) == 0) { 
> signal(SIGHUP, oldhup); 
> signal(SIGQUIT, oldquit); 
> execl("/bin/sh", "sh", "-t", NULL); 
> exit(0100); 
> } 
> savint = signal(SIGINT, SIG_IGN); 
> while ((rpid = wait(&retcode)) != pid && rpid != -1) 
> ; 
> signal(SIGINT, savint); 
> if (vflag) { 
> puts("!"); 
> } 
> } 
> static void quit(int n) 
> { 
> if (vflag && fchange && dol!=zero) { 
> fchange = 0; 
> error(Q); 
> } 
> unlink(tfname); 
> exit(0); 
> } 
> static void rdelete(unsigned int *ad1, unsigned int *ad2) 
> { 
> unsigned int *a1, *a2, *a3; 
> 
> a1 = ad1; 
> a2 = ad2+1; 
> a3 = dol; 
> dol -= a2 - a1; 
> do { 
> *a1++ = *a2++; 
> } while (a2 <= a3); 
> a1 = ad1; 
> if (a1 > dol) 
> a1 = dol; 
> dot = a1; 
> fchange = 1; 
> } 
> static void gdelete(void) 
> { 
> unsigned int *a1, *a2, *a3; 
> 
> a3 = dol; 
> for (a1=zero; (*a1&01)==0; a1++) 
> if (a1>=a3) 
> return; 
> for (a2=a1+1; a2<=a3;) { 
> if (*a2&01) { 
> a2++; 
> dot = a1; 
> } else 
> *a1++ = *a2++; 
> } 
> dol = a1-1; 
> if (dot>dol) 
> dot = dol; 
> fchange = 1; 
> } 
> static unsigned char *GetLine(unsigned int tl) 
> { 
> unsigned char *bp, *lp; 
> int nl; 
> 
> lp = linebuf; 
> bp = getblock(tl, READ); 
> nl = nleft; 
> tl &= ~((BLKSIZE/2)-1); 
> while (*lp++ = *bp++) 
> if (--nl == 0) { 
> bp = getblock(tl+=(BLKSIZE/2), READ); 
> nl = nleft; 
> } 
> return(linebuf); 
> } 
> static int putline(void) 
> { 
> unsigned char *bp, *lp; 
> int nl; 
> unsigned int tl; 
> 
> fchange = 1; 
> lp = linebuf; 
> tl = tline; 
> bp = getblock(tl, WRITE); 
> nl = nleft; 
> tl &= ~((BLKSIZE/2)-1); 
> while (*bp = *lp++) { 
> if (*bp++ == '\n') { 
> *--bp = 0; 
> linebp = lp; 
> break; 
> } 
> if (--nl == 0) { 
> bp = getblock(tl+=(BLKSIZE/2), WRITE); 
> nl = nleft; 
> } 
> } 
> nl = tline; 
> tline += (((lp-linebuf)+03)>>1)&077776; 
> return(nl); 
> } 
> static unsigned char * getblock(unsigned int atl, int iof) 
> { 
> int bno, off; 
> 
> bno = (atl/(BLKSIZE/2)); 
> off = (atl<<1) & (BLKSIZE-1) & ~03; 
> if (bno >= NBLK) { 
> lastc = '\n'; 
> error(T); 
> } 
> nleft = BLKSIZE - off; 
> if (bno==iblock) { 
> ichanged |= iof; 
> return(ibuff+off); 
> } 
> if (bno==oblock) 
> return(obuff+off); 
> if (iof==READ) { 
> if (ichanged) 
> blkio(iblock, ibuff, iof); 
> ichanged = 0; 
> iblock = bno; 
> blkio(bno, ibuff, iof); 
> return(ibuff+off); 
> } 
> if (oblock>=0) 
> blkio(oblock, obuff, iof); 
> oblock = bno; 
> return(obuff+off); 
> } 
> static void blkio(int b, unsigned char *buf, int iof) 
> { 
> lseek(tfile, (long)b*BLKSIZE, 0); 
> if (iof == READ) { 
> if (read(tfile, buf, BLKSIZE) != BLKSIZE) { 
> error(T); 
> } 
> } 
> else { 
> if (write(tfile, buf, BLKSIZE) != BLKSIZE) { 
> error(T); 
> } 
> } 
> } 
> static void init(void) 
> { 
> int *markp; 
> 
> close(tfile); 
> tline = 2; 
> for (markp = names; markp < &names[26]; ) 
> *markp++ = 0; 
> subnewa = 0; 
> anymarks = 0; 
> iblock = -1; 
> oblock = -1; 
> ichanged = 0; 
> close(creat(tfname, 0600)); 
> tfile = open(tfname, 2); 
> dot = dol = zero; 
> } 
> static void global(int k) 
> { 
> unsigned char *gp; 
> int c; 
> unsigned int *a1; 
> unsigned char globuf[GBSIZE]; 
> 
> if (globp) 
> error(Q); 
> setwide(); 
> squeeze(dol>zero); 
> if ((c=getchr())=='\n') 
> error(Q); 
> compile(c); 
> gp = globuf; 
> while ((c = getchr()) != '\n') { 
> if (c==EOF) 
> error(Q); 
> if (c=='\\') { 
> c = getchr(); 
> if (c!='\n') 
> *gp++ = '\\'; 
> } 
> *gp++ = c; 
> if (gp >= &globuf[GBSIZE-2]) 
> error(Q); 
> } 
> if (gp == globuf) 
> *gp++ = 'p'; 
> *gp++ = '\n'; 
> *gp++ = 0; 
> for (a1=zero; a1<=dol; a1++) { 
> *a1 &= ~01; 
> if (a1>=addr1 && a1<=addr2 && execute(a1)==k) 
> *a1 |= 01; 
> } 
> /* 
> * Special case: g/.../d (avoid n^2 algorithm) 
> */ 
> if (globuf[0]=='d' && globuf[1]=='\n' && globuf[2]=='\0') { 
> gdelete(); 
> return; 
> } 
> for (a1=zero; a1<=dol; a1++) { 
> if (*a1 & 01) { 
> *a1 &= ~01; 
> dot = a1; 
> globp = globuf; 
> commands(); 
> a1 = zero; 
> } 
> } 
> } 
> static void join(void) 
> { 
> unsigned char *gp, *lp; 
> unsigned int *a1; 
> 
> nonzero(); 
> gp = genbuf; 
> for (a1=addr1; a1<=addr2; a1++) { 
> lp = GetLine(*a1); 
> while (*gp = *lp++) 
> if (gp++ >= &genbuf[LBSIZE-2]) 
> error(Q); 
> } 
> lp = linebuf; 
> gp = genbuf; 
> while (*lp++ = *gp++) 
> ; 
> *addr1 = putline(); 
> if (addr1<addr2) 
> rdelete(addr1+1, addr2); 
> dot = addr1; 
> } 
> static void substitute(int inglob) 
> { 
> int *mp, nl; 
> unsigned int *a1; 
> int gsubf; 
> int n; 
> 
> n = getnum(); /* OK even if n==0 */ 
> gsubf = compsub(); 
> for (a1 = addr1; a1 <= addr2; a1++) { 
> if (execute(a1)){ 
> unsigned *ozero; 
> int m = n; 
> do { 
> int span = loc2-loc1; 
> if (--m <= 0) { 
> dosub(); 
> if (!gsubf) 
> break; 
> if (span==0) { /* null RE match */ 
> if (*loc2=='\0') 
> break; 
> loc2++; 
> } 
> } 
> } while (execute((unsigned *)0)); 
> if (m <= 0) { 
> inglob |= 01; 
> subnewa = putline(); 
> *a1 &= ~01; 
> if (anymarks) { 
> for (mp = names; mp < &names[26]; mp++) 
> if (*mp == *a1) 
> *mp = subnewa; 
> } 
> subolda = *a1; 
> *a1 = subnewa; 
> ozero = zero; 
> nl = append(getsub, a1); 
> nl += zero-ozero; 
> a1 += nl; 
> addr2 += nl; 
> } 
> } 
> } 
> if (inglob==0) 
> error(Q); 
> } 
> static int compsub(void) 
> { 
> int seof, c; 
> unsigned char *p; 
> 
> if ((seof = getchr()) == '\n' || seof == ' ') 
> error(Q); 
> compile(seof); 
> p = rhsbuf; 
> for (;;) { 
> c = getchr(); 
> if (c=='\\') 
> c = getchr() | 0200; 
> if (c=='\n') { 
> if (globp && globp[0]) /* last '\n' does not count */ 
> c |= 0200; 
> else { 
> peekc = c; 
> pflag++; 
> break; 
> } 
> } 
> if (c==seof) 
> break; 
> *p++ = c; 
> if (p >= &rhsbuf[LBSIZE/2]) 
> error(Q); 
> } 
> *p++ = 0; 
> if ((peekc = getchr()) == 'g') { 
> peekc = 0; 
> newline(); 
> return(1); 
> } 
> newline(); 
> return(0); 
> } 
> static int getsub(void) 
> { 
> unsigned char *p1, *p2; 
> 
> p1 = linebuf; 
> if ((p2 = linebp) == 0) 
> return(EOF); 
> while (*p1++ = *p2++) 
> ; 
> linebp = 0; 
> return(0); 
> } 
> static void dosub(void) 
> { 
> unsigned char *lp, *sp, *rp; 
> int c; 
> 
> lp = linebuf; 
> sp = genbuf; 
> rp = rhsbuf; 
> while (lp < loc1) 
> *sp++ = *lp++; 
> while (c = *rp++&0377) { 
> if (c=='&') { 
> sp = place(sp, loc1, loc2); 
> continue; 
> } else if (c&0200 && (c &= 0177) >='1' && c < nbra+'1') { 
> sp = place(sp, braslist[c-'1'], braelist[c-'1']); 
> continue; 
> } 
> *sp++ = c&0177; 
> if (sp >= &genbuf[LBSIZE]) 
> error(Q); 
> } 
> lp = loc2; 
> loc2 = sp - genbuf + linebuf; 
> while (*sp++ = *lp++) 
> if (sp >= &genbuf[LBSIZE]) 
> error(Q); 
> lp = linebuf; 
> sp = genbuf; 
> while (*lp++ = *sp++) 
> ; 
> } 
> static unsigned char * place(unsigned char *sp, unsigned char 
> *l1,unsigned char *l2) 
> { 
> 
> while (l1 < l2) { 
> *sp++ = *l1++; 
> if (sp >= &genbuf[LBSIZE]) 
> error(Q); 
> } 
> return(sp); 
> } 
> static void move(int cflag) 
> { 
> unsigned int *adt, *ad1, *ad2; 
> 
> nonzero(); 
> if ((adt = address())==0) /* address() guarantees addr is in range */ 
> error(Q); 
> newline(); 
> if (cflag) { 
> unsigned int *ozero; 
> int delta; 
> 
> ad1 = dol; 
> ozero = zero; 
> append(getcopy, ad1++); 
> ad2 = dol; 
> delta = zero - ozero; 
> ad1 += delta; 
> adt += delta; 
> } else { 
> ad2 = addr2; 
> for (ad1 = addr1; ad1 <= ad2;) 
> *ad1++ &= ~01; 
> ad1 = addr1; 
> } 
> ad2++; 
> if (adt<ad1) { 
> dot = adt + (ad2-ad1); 
> if ((++adt)==ad1) 
> return; 
> reverse(adt, ad1); 
> reverse(ad1, ad2); 
> reverse(adt, ad2); 
> } else if (adt >= ad2) { 
> dot = adt++; 
> reverse(ad1, ad2); 
> reverse(ad2, adt); 
> reverse(ad1, adt); 
> } else 
> error(Q); 
> fchange = 1; 
> } 
> static void reverse(unsigned int *a1, unsigned int *a2) 
> { 
> int t; 
> 
> for (;;) { 
> t = *--a2; 
> if (a2 <= a1) 
> return; 
> *a2 = *a1; 
> *a1++ = t; 
> } 
> } 
> static int getcopy(void) 
> { 
> if (addr1 > addr2) 
> return(EOF); 
> GetLine(*addr1++); 
> return(0); 
> } 
> static void compile(int eof) 
> { 
> int c; 
> unsigned char *ep; 
> unsigned char *lastep; 
> unsigned char bracket[NBRA], *bracketp; 
> int cclcnt; 
> 
> ep = expbuf; 
> bracketp = bracket; 
> if ((c = getchr()) == '\n') { 
> peekc = c; 
> c = eof; 
> } 
> if (c == eof) { 
> if (*ep==0) 
> error(Q); 
> return; 
> } 
> nbra = 0; 
> if (c=='^') { 
> c = getchr(); 
> *ep++ = CCIRC; 
> } 
> peekc = c; 
> lastep = 0; 
> for (;;) { 
> if (ep >= &expbuf[ESIZE]) 
> goto cerror; 
> c = getchr(); 
> if (c == '\n') { 
> peekc = c; 
> c = eof; 
> } 
> if (c==eof) { 
> if (bracketp != bracket) 
> goto cerror; 
> *ep++ = CEOF; 
> return; 
> } 
> if (c!='*') 
> lastep = ep; 
> switch (c) { 
> 
> case '\\': 
> if ((c = getchr())=='(') { 
> if (nbra >= NBRA) 
> goto cerror; 
> *bracketp++ = nbra; 
> *ep++ = CBRA; 
> *ep++ = nbra++; 
> continue; 
> } 
> if (c == ')') { 
> if (bracketp <= bracket) 
> goto cerror; 
> *ep++ = CKET; 
> *ep++ = *--bracketp; 
> continue; 
> } 
> if (c>='1' && c<'1'+NBRA) { 
> *ep++ = CBACK; 
> *ep++ = c-'1'; 
> continue; 
> } 
> *ep++ = CCHR; 
> if (c=='\n') 
> goto cerror; 
> *ep++ = c; 
> continue; 
> 
> case '.': 
> *ep++ = CDOT; 
> continue; 
> 
> case '\n': 
> goto cerror; 
> 
> case '*': 
> if (lastep==0 || *lastep==CBRA || *lastep==CKET) 
> goto defchar; 
> *lastep |= STAR; 
> continue; 
> 
> case '$': 
> if ((peekc=getchr()) != eof && peekc!='\n') 
> goto defchar; 
> *ep++ = CDOL; 
> continue; 
> 
> case '[': 
> *ep++ = CCL; 
> *ep++ = 0; 
> cclcnt = 1; 
> if ((c=getchr()) == '^') { 
> c = getchr(); 
> ep[-2] = NCCL; 
> } 
> do { 
> if (c=='\n') 
> goto cerror; 
> if (c=='-' && ep[-1]!=0) { 
> if ((c=getchr())==']') { 
> *ep++ = '-'; 
> cclcnt++; 
> break; 
> } 
> while (ep[-1]<c) { 
> *ep = ep[-1]+1; 
> ep++; 
> cclcnt++; 
> if (ep>=&expbuf[ESIZE]) 
> goto cerror; 
> } 
> } 
> *ep++ = c; 
> cclcnt++; 
> if (ep >= &expbuf[ESIZE]) 
> goto cerror; 
> } while ((c = getchr()) != ']'); 
> lastep[1] = cclcnt; 
> continue; 
> 
> defchar: 
> default: 
> *ep++ = CCHR; 
> *ep++ = c; 
> } 
> } 
> cerror: 
> expbuf[0] = 0; 
> nbra = 0; 
> error(Q); 
> } 
> static int execute(unsigned int *addr) 
> { 
> unsigned char *p1, *p2; 
> int c; 
> 
> for (c=0; c<NBRA; c++) { 
> braslist[c] = 0; 
> braelist[c] = 0; 
> } 
> p2 = expbuf; 
> if (addr == (unsigned *)0) { 
> if (*p2==CCIRC) 
> return(0); 
> p1 = loc2; 
> } else if (addr==zero) 
> return(0); 
> else 
> p1 = GetLine(*addr); 
> if (*p2==CCIRC) { 
> loc1 = p1; 
> return(advance(p1, p2+1)); 
> } 
> /* fast check for first character */ 
> if (*p2==CCHR) { 
> c = p2[1]; 
> do { 
> if (*p1!=c) 
> continue; 
> if (advance(p1, p2)) { 
> loc1 = p1; 
> return(1); 
> } 
> } while (*p1++); 
> return(0); 
> } 
> /* regular algorithm */ 
> do { 
> if (advance(p1, p2)) { 
> loc1 = p1; 
> return(1); 
> } 
> } while (*p1++); 
> return(0); 
> } 
> static int advance(unsigned char *lp,unsigned char *ep) 
> { 
> unsigned char *curlp; 
> int i; 
> 
> for (;;) switch (*ep++) { 
> 
> case CCHR: 
> if (*ep++ == *lp++) 
> continue; 
> return(0); 
> 
> case CDOT: 
> if (*lp++) 
> continue; 
> return(0); 
> 
> case CDOL: 
> if (*lp==0) 
> continue; 
> return(0); 
> 
> case CEOF: 
> loc2 = lp; 
> return(1); 
> 
> case CCL: 
> if (cclass(ep, *lp++, 1)) { 
> ep += *ep; 
> continue; 
> } 
> return(0); 
> 
> case NCCL: 
> if (cclass(ep, *lp++, 0)) { 
> ep += *ep; 
> continue; 
> } 
> return(0); 
> 
> case CBRA: 
> braslist[*ep++] = lp; 
> continue; 
> 
> case CKET: 
> braelist[*ep++] = lp; 
> continue; 
> 
> case CBACK: 
> if (braelist[i = *ep++]==0) 
> error(Q); 
> if (backref(i, lp)) { 
> lp += braelist[i] - braslist[i]; 
> continue; 
> } 
> return(0); 
> 
> case CBACK|STAR: 
> if (braelist[i = *ep++] == 0) 
> error(Q); 
> curlp = lp; 
> while (backref(i, lp)) 
> lp += braelist[i] - braslist[i]; 
> while (lp >= curlp) { 
> if (advance(lp, ep)) 
> return(1); 
> lp -= braelist[i] - braslist[i]; 
> } 
> continue; 
> 
> case CDOT|STAR: 
> curlp = lp; 
> while (*lp++) 
> ; 
> goto star; 
> 
> case CCHR|STAR: 
> curlp = lp; 
> while (*lp++ == *ep) 
> ; 
> ep++; 
> goto star; 
> 
> case CCL|STAR: 
> case NCCL|STAR: 
> curlp = lp; 
> while (cclass(ep, *lp++, ep[-1]==(CCL|STAR))) 
> ; 
> ep += *ep; 
> goto star; 
> 
> star: 
> do { 
> lp--; 
> if (advance(lp, ep)) 
> return(1); 
> } while (lp > curlp); 
> return(0); 
> 
> default: 
> error(Q); 
> } 
> } 
> static int backref(int i,unsigned char *lp) 
> { 
> unsigned char *bp; 
> 
> bp = braslist[i]; 
> while (*bp++ == *lp++) 
> if (bp >= braelist[i]) 
> return(1); 
> return(0); 
> } 
> static int cclass(unsigned char *set, int c, int af) 
> { 
> int n; 
> 
> if (c==0) 
> return(0); 
> n = *set++; 
> while (--n) 
> if (*set++ == c) 
> return(af); 
> return(!af); 
> } 
> static void putd(void) 
> { 
> int r; 
> 
> r = count%10; 
> count /= 10; 
> if (count) 
> putd(); 
> putchr(r + '0'); 
> } 
> static unsigned char line[70]; 
> static unsigned char *linp = line; 
> static void putchr(int ac) 
> { 
> unsigned char *lp; 
> int c; 
> 
> lp = linp; 
> c = ac; 
> if (listf) { 
> if (c=='\n') { 
> if (linp!=line && linp[-1]==' ') { 
> *lp++ = '\\'; 
> *lp++ = 'n'; 
> } 
> } else { 
> if (col > (72-4-2)) { 
> col = 8; 
> *lp++ = '\\'; 
> *lp++ = '\n'; 
> *lp++ = '\t'; 
> } 
> col++; 
> if (c=='\b' || c=='\t' || c=='\\') { 
> *lp++ = '\\'; 
> if (c=='\b') 
> c = 'b'; 
> else if (c=='\t') 
> c = 't'; 
> col++; 
> } else if (c<' ' || c=='\177') { 
> *lp++ = '\\'; 
> *lp++ = (c>>6) +'0'; 
> *lp++ = ((c>>3)&07)+'0'; 
> c = ( c &07)+'0'; 
> col += 3; 
> } 
> } 
> } 
> *lp++ = c; 
> if(c == '\n' || lp >= &line[64]) { 
> linp = line; 
> write(oflag?2:1, line, lp-line); 
> return; 
> } 
> linp = lp; 
> }

I just looked into the code deeper, quite tricky and old fassion. 
No good for beginners, except several recurrsive method.

[toc] | [prev] | [next] | [standalone]


#79245

FromKeith Thompson <Keith.S.Thompson+u@gmail.com>
Date2021-04-24 14:21 -0700
Message-ID<87r1izbcq8.fsf@nosuchdomain.example.com>
In reply to#79244
wij <wyniijj@gmail.com> writes:
> On Friday, 23 April 2021 at 00:58:41 UTC+8, jacobnavia wrote:
>> Recently, somebody started a thread about how C wasn't a simple 
>> language. The excuse was a text editor project for a beginner. 
>> 
>> Attached is the source code for the 10th edition of Unix of the "ed" 
>> text editor, published by Brian Kernighan for his CS classes at 
>> Princeton in 2001. 
>> 
[1596 lines deleted]
>
> I just looked into the code deeper, quite tricky and old fassion. 
> No good for beginners, except several recurrsive method.

Again, *please* don't quote the entire article when you post a followup.
Just quote enough so that readers can understand the context.  Nobody
reading your followup wants to read that entire block of text -- so
don't include it in your post.

-- 
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for Philips Healthcare
void Void(void) { Void(); } /* The recursive call of the void */

[toc] | [prev] | [next] | [standalone]


#79297

FromBonita Montero <Bonita.Montero@gmail.com>
Date2021-04-26 18:04 +0200
Message-ID<s66o9k$a0e$1@dont-email.me>
In reply to#79175
Use C++ - much less code, more maintainable and more readable code
if you use it properly. Sth. like malloc() f.e. is really disgusting
when compared to using a vector<>.

[toc] | [prev] | [standalone]


Page 5 of 5 — ← Prev page 1 2 3 4 [5]

Back to top | Article view | comp.lang.c++


csiph-web