From: arne@vajhoej.dk   
      
   On 1/3/2025 1:17 PM, Dan Cross wrote:   
   > In article <67781447$0$711$14726298@news.sunsite.dk>,   
   > Arne Vajhøj   wrote:   
   >> On 1/3/2025 10:11 AM, Dan Cross wrote:   
   >>> `readln` and `fgets` are not similar in that `readln` strips the   
   >>> line ending sequence, and `fgets` does not.   
   >>   
   >> Close enough for the purpose of this article.   
   >   
   > Perhaps.  I may be worth an asterisk, as often C programmers   
   > will want to write:   
   >   
   >      while ((s = fgets(s, len, fp)) != NULL) {   
   >          char *nl = strchr(s, '\n');   
   >          if (nl != NULL)   
   >              *nl = '\0';   
   >      }   
   >   
   > Which is a bit more cumbersome than the Pascal equivalent.  When   
   > carriage returns get mixed in, it gets even nastier, so much so   
   > that one may just write a helper function to deal with it.   
      
   I think you are right. I have added a note.   
      
   >>> `f = fopen,fnm "r");` is an obvious typo.   
   >>> `while not eof(f)) do` is an obvious typo.   
   >>   
   >> Fixed.   
   >   
   > Fixed, but the comparison to C is slightly wrong:   
   >   
   > `while not(eof(f)) do` is not exactly the same as   
   > `while(!feof(f))`.  In particular, while in VSI Pascal `EOF(f)`   
   > will be true on the first iteration of the loop if `f` is empty,   
   > the same is not true for `feof` from stdio: in order for `feof`   
   > to be true, stdio must observe the end-of-file condition of `f`   
   > via some input operation.  This leads to awkward code sequences   
   > like this:   
   >   
   >      ch = fgetc(fp);   
   >      while (!feof(fp)) {   
   >          /*   
   >           * Do something with `ch`   
   >           * ...   
   >           */   
   >          ch = fgetc(fp);   
   >      }   
      
   C feof is a crap function.   
      
   I think I will drop feof completely and add fgetc   
   not returning EOF. I already have fgets not returning NULL.   
      
   >>> The structure you present at the end as "equivalent" of a   
   >>> varying character array is not correct.  `integer16` is a signed   
   >>> type, with a maximum value of 32,767.  The length field for a   
   >>> `varying [n] of char` is an integer subrange type with word   
   >>> representation.  That is, `length` is unsigned 0..max, where max   
   >>> is <= 65,535.   
   >>   
   >> Ooops.   
   >>   
   >> You are right.   
   >>   
   >> I was sure that the limit was 32K but it is 64K.   
   >>   
   >> Fixed.   
   >>   
   >> And also fixed in the description of VARYING further up.   
   >   
   > You should seriously mention the STRING type, though.   
      
   I think VARYING OF CHAR is what is used most in VMS Pascal.   
      
   > Also, it's a bit of a bummer that you didn't mention nested   
   > functions/procedures, which are among the cooler aspects of the   
   > language:   
   >   
   > $ type foo.pas   
   > (* foo *)   
   > program foo(output);   
   > procedure hello;   
   >      procedure world(var who: String);   
   >          function punct: char;   
   >          begin   
   >              punct := '!'   
   >          end;   
   >      begin   
   >          who := 'World' + punct   
   >      end;   
   > var   
   >      who: String (10);   
   > begin   
   >      world(who);   
   >      writeln('Hello, ', who)   
   > end;   
   > begin   
   >      hello   
   > end.   
      
   There is already an example. fac is inside testfac.   
      
   I will add a note about it.   
      
   Arne   
      
   --- SoupGate-DOS v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)