Why does Wikipedia keep begging for foreign fonts?

Lostgallifreyan wrote:
"Harry Vaderchi" wrote in
newsp.wcrs7jxz1r0rdn@dell3100:

On Sat, 14 Apr 2012 12:02:57 +0100, J. P. Gilliver (John)
wrote:

In message , Bill in Co
writes:
J. P. Gilliver (John) wrote:
[]
efficiency). Wasn't DOS 3.3 the last one mostly coded in assembler?

I don't know, but perhaps someone here does.
But even later than when DOS 3.3 came out, I think several windows
applications were also coded in Assembler, too. But somewhere along
the
line, I'm pretty sure that went out the window (except, perhaps, for
some
critical speed subroutines). Coding in assembler is just too
tedious. :-)
(that said, I really admire those who could do it well, and get it
right)


I'm still blown away by a little .com file I have that simulates an open
fire - flames - on the screen. It's all of 453 bytes. I don't remember
where I got it.

here?
http://thestarman.pcministry.com/asm/fire/Fire.html

There's a nicer one, it starts low, and grows a bit, it looks fairly
realistic too. It might be what John Gilliver has. I remember it, there's
also a watery one, and various keygens have some amazing coding, long
mandala-like audio that never seems to loop, complete withj graphics, all
coming out of a few tens of KB at most.

Even C can be effective and small though. I'm workign on porting a DX7
editor
I made in wxLua. When compiled by TCC, and UPX'ed, it weighs just 22 KB.
It's
nearly complete, puts up a tabcontrol with four pages full of DIY
spincontrols, (wxLua provides them natively, the API doesn't, you have to
combine two controls to make them). The editor can detect voice and bank
files, allows auditioning of a voice in a bank, or another bank, prior to
saving, and has edit and recall buffers, and a compare more with muting,
and
a config system, a 424x240 pixel bitmap plus several small bitmaps for a
toolbar, and an internal data copying system. it will also have MIDI
capability built in, but I haven't added that yet because although I
figured
out how, first, the orginal I'm porting from didn't and I want to get the
port right first, and it's already a lot more capable than that was (a 28K
wxLua script) It's the kind of tool that mostly comes in a program a few
hundred K in size, if not more. I got it small because the C language and
use
of the Win32 API to bypass all the bloated MFC or .NET or other controls
and
class libraries lets me add only the code I need most. I chose to write my
own common functions, including string and file functions, which also
helps.
It's been a long steep climb but from hating C, I have come to love it,
there's an elegance to pointer arithmetic and dereferencing that makes
people
normally used to array handling feel like they are suddenly able to walk
through walls and go anywhere so long as they don't get lost trying.

I don't know if I'll take to ASM but I have had a look at it, using DOS's
Debug.exe, same as used for that Fire page Harry linked to (I saved that
too,
for looking at some time if I get the urge). One thing I did see last
month
was that ASM and Win32 API calls can be directly combined in ways that can
make very small and powerful tools. I think Martin Pesch's MP3DirectCut
and 1by1 tools might be built that way. I suspect that if I learn more
about
compiling I might get C to make files almost as small as ASM, because one
thing I aim for is to write C code so it works as close as I know how, to
the
way the CPU does it. The compiler can help but it works better if it
doesn't
have to try to rewrite everything we send to it too much. I'm not taking
it
to extremes, no matter how obsessive I get though, because ASM is
extremely
dependent on specific hardware, especially the CPU itself, and C isn't, or
ideally, should not be.

But I don't think you can ever get C (or any other language) almost as small
as assembler. One instruction in C, I would bet, easily compiles to 100 or
more assembly language instructions in most cases. (I'm not just talking
about incrementing a variable (or the like) in C here - I'm being a lot more
general. :-)

Hmmm, well maybe Forth might be one exception. But I don't know much about
Forth, however, so that's just a guess.

"Bill in Co" wrote in
m:

But I don't think you can ever get C (or any other language) almost as
small as assembler. One instruction in C, I would bet, easily compiles
to 100 or more assembly language instructions in most cases. (I'm not
just talking about incrementing a variable (or the like) in C here - I'm
being a lot more general. :-)



Ok, but the comparison is still fair. A doubling, a multiplying by a hundred
even, it's not a lot when you're comparing with methods that take millions
more instructions to get similar things done. Besides, C can be closer than
you're suggesting, because you work TO the nature of the machine, not against
it. You don't have to, but to some extent it compels that because it's easier
anyway. Simple example: passing a struct is what many might do for a complex
data system. I try not to do this. Instead, I'll create the space, then use
pointers to determine what I do, in place. It wasn't hard to learn that bit,
other than manage some of the finer points of syntax, especially the awkward
pointer-to-pointer bits. As C can't pass a string, but only a pointer to an
array of characters, the basics are there already. Most of things like Lua,
MFC, wxWidgets, and all others be they great or bloated and annoying, aim to
give a coder the ability to throw data around. But as a guy I built a wall
for said, "building houses is basically moving stuff around, all the time".
The more we can move directly to where it must go, the easier it is, and it's
easy to make inelegant wasteful moves. I'm sure this is true even in ASM.

In message ,
Lostgallifreyan writes:
"Harry Vaderchi" wrote in newsp.wcrs7jxz1r0rdn@dell3100:
[]
http://thestarman.pcministry.com/asm/fire/Fire.html

There's a nicer one, it starts low, and grows a bit, it looks fairly
realistic too. It might be what John Gilliver has. I remember it, there's

Sounds like a good description. The one the above code produces is
sufficiently similar that I suspect it's come from the same mind.
[]
Even C can be effective and small though. I'm workign on porting a DX7 editor
[]
hundred K in size, if not more. I got it small because the C language and use
of the Win32 API to bypass all the bloated MFC or .NET or other controls and
class libraries lets me add only the code I need most. I chose to write my
own common functions, including string and file functions, which also helps.

There's a certain satisfaction in such things, isn't there!

It's been a long steep climb but from hating C, I have come to love it,
there's an elegance to pointer arithmetic and dereferencing that makes people
normally used to array handling feel like they are suddenly able to walk

Yes, C is very elegant. It's a pity that some of its priests are so
puritanical (if you want to really wind them up, mention use of the
"goto" command - which _is_ part of the language), but it is very
pleasing to write in. It's _close_ to assembler, especially if the
compiler options are optimised.

through walls and go anywhere so long as they don't get lost trying.

A maze of little twisty passages, all alike?
[]
--
J. P. Gilliver. UMRA: 1960/1985 MB++G.5AL-IS-P--Ch++(p)Ar@T0H+Sh0!:`)DNAf

782.55 - The Number of The Beast (including VAT)

"J. P. Gilliver (John)" wrote in
:

In message ,
Lostgallifreyan writes:
"Harry Vaderchi" wrote in
newsp.wcrs7jxz1r0rdn@dell3100:
[]
http://thestarman.pcministry.com/asm/fire/Fire.html

There's a nicer one, it starts low, and grows a bit, it looks fairly
realistic too. It might be what John Gilliver has. I remember it,
there's

Sounds like a good description. The one the above code produces is
sufficiently similar that I suspect it's come from the same mind.


I think it could be. When I ran it in a DOS window it slowed down, and looked
more like the one I remember.I guess he used an early draft to illustrate the
ASM and Debug.

Even C can be effective and small though. I'm workign on porting a DX7
editor
[]
hundred K in size, if not more. I got it small because the C language
and use of the Win32 API to bypass all the bloated MFC or .NET or other
controls and class libraries lets me add only the code I need most. I
chose to write my own common functions, including string and file
functions, which also helps.

There's a certain satisfaction in such things, isn't there!


Definitely. I was warned against writing my own, so early in the game, but I
decided to look to the best, I was looking at the overflow problem and came
across OpenBSD's 'strlcpy' and 'strlcat'. I looked at two things, the basic
intent, to terminate strings always, and at their method of iterating
pointers. The rest I ignored, because I wanted to do it my way. It was
more compact, and it ran as fast as theirs, and it behaved the same way in
all aspects (returned values, etc), except one that I haven't fixed yet, mine
handles negative numbers with no overflow, but that's not really proper
behaviour, it should be an UNsigned value, so mine can address 2GB, not the
full 4GB it ought to address. Given how much I'm saying, I might as well
share the main function. This can copy if you do *S=0; where S is some string
to copy to, and it will concat into it if there's any room. Better yet, it
can handle MULTIPLE inputs, making C string handling as easy as Lua's
strings, almost...

size_t Str_C(size_t L,char *O,size_t N,...){ //Length of,Output,Number
of,Inputs...
va_list V; va_start(V,N); int I=1; char *o=O-1,*i,*p=O+L; while(*++o);
if(Lo-O)L=o-O;
while(N--){i=va_arg(V,char*); while((*o++=*i++)&&op)I++; o--; i--;
while(*i++)I++;} *o=0; va_end(V); return I+L-1;
}
//beware wordwarp.

It looks more like Perl than C, i.e. unreadable to many, but I like it... I
have my own ideas about coding style, but they are consistent and they work
for me.

It's been a long steep climb but from hating C, I have come to love it,
there's an elegance to pointer arithmetic and dereferencing that makes
people normally used to array handling feel like they are suddenly able
to walk

Yes, C is very elegant. It's a pity that some of its priests are so
puritanical (if you want to really wind them up, mention use of the
"goto" command - which _is_ part of the language), but it is very
pleasing to write in. It's _close_ to assembler, especially if the
compiler options are optimised.


That's what I've read, enough time to accept it and aim to make it so when
possible. I won't agonise over which works best, pre or post increment
though, I pick that to suit intent, not CPU prejudice. I haven't used a
Goto, but I will if it ever makes sense to do it. In DOS batch files we have
to, and I used Goto labels in Psion's OPL often enough. In a language with no
for loops, where everything if if or while, a goto can be a useful extra
structural control.

I found some ASM and Win32 API code. Some time I want to look at that, as a
basic test to see how big an EXE is if made from C or ASM, because I suspect
that for a basic demonstration, most of the code might be the required
WinMain() and window procedure and message loop stuff, and there might be
very little difference. Just compling a small EXE in TCC shows some empty
space anyway, I think they add half a K every time they need a bit more, so
if the program's GUI window code takes a K and a half (seems about right so
far), then a fair bit of own-code can be added almost imperceptibly, be it in
C or ASM. I haven't yet looked at the habits of ASM compilers though, they
may differ.

through walls and go anywhere so long as they don't get lost trying.

A maze of little twisty passages, all alike?


Worse. Ever been lost in a fog? I mean, really lost? It feels like the
world vanished, with not even the voice of Rod Serling hanging on the absent
breeze like the comforting smile of a Cheshire cat. Ok, I overdid that, but I
tried to get the idea across that if you know where the pointer points, all
is like a firm track through a swamp, but if not, the track vanishes, along
with the swamp, and the world with it. No wonder a machine usually crashes
outright when that happens. it really IS the end of its little world, more
often than not.

Lostgallifreyan wrote in
:

This can copy if you do *S=0; where S is some string
to copy to, and it will concat into it if there's any room. Better yet, it
can handle MULTIPLE inputs, making C string handling as easy as Lua's
strings, almost...

size_t Str_C(size_t L,char *O,size_t N,...){ //Length of,Output,Number
of,Inputs...
va_list V; va_start(V,N); int I=1; char *o=O-1,*i,*p=O+L; while(*++o);
if(Lo-O)L=o-O;
while(N--){i=va_arg(V,char*); while((*o++=*i++)&&op)I++; o--; i--;
while(*i++)I++;} *o=0; va_end(V); return I+L-1;
}
//beware wordwarp.


Before anyone murmur's "snprintf", I'll say "speed, guaranteed termination,
and no unneeded timeconsuming zerofill, and a few less function names that
security profilers will shout at me for and tell me I shouldn't be using."

On Sun, 15 Apr 2012 22:57:41 +0100, J. P. Gilliver (John)
wrote:

In message ,
Lostgallifreyan writes:
"Harry Vaderchi" wrote in
newsp.wcrs7jxz1r0rdn@dell3100:
[]
http://thestarman.pcministry.com/asm/fire/Fire.html

There's a nicer one, it starts low, and grows a bit, it looks fairly
realistic too. It might be what John Gilliver has. I remember it,
there's

where?

Sounds like a good description. The one the above code produces is
sufficiently similar that I suspect it's come from the same mind.
[]


through walls and go anywhere so long as they don't get lost trying.

A maze of little twisty passages, all alike?
[]

"Plugh"

--
[dash dash space newline 4line sig]

Albi CNU

In message ,
Lostgallifreyan writes:
"J. P. Gilliver (John)" wrote in
:
[]
full 4GB it ought to address. Given how much I'm saying, I might as well
share the main function. This can copy if you do *S=0; where S is some string
to copy to, and it will concat into it if there's any room. Better yet, it
can handle MULTIPLE inputs, making C string handling as easy as Lua's
strings, almost...

size_t Str_C(size_t L,char *O,size_t N,...){ //Length of,Output,Number
of,Inputs...
va_list V; va_start(V,N); int I=1; char *o=O-1,*i,*p=O+L; while(*++o);
if(Lo-O)L=o-O;
while(N--){i=va_arg(V,char*); while((*o++=*i++)&&op)I++; o--; i--;
while(*i++)I++;} *o=0; va_end(V); return I+L-1;
}
//beware wordwarp.

It looks more like Perl than C, i.e. unreadable to many, but I like it... I
have my own ideas about coding style, but they are consistent and they work
for me.

OK - it's certainly impenetrable to me! (But then I've not really done
much C for about 30 years!) Mind you, having a variable o is a bit
sadistic ... (-:

I take it that "0-1" and "0+L" are ways of forcing your compiler to do
something.
[]
Yes, C is very elegant. It's a pity that some of its priests are so
puritanical (if you want to really wind them up, mention use of the
"goto" command - which _is_ part of the language), but it is very
pleasing to write in. It's _close_ to assembler, especially if the
compiler options are optimised.


That's what I've read, enough time to accept it and aim to make it so when
possible. I won't agonise over which works best, pre or post increment
though, I pick that to suit intent, not CPU prejudice. I haven't used a
Goto, but I will if it ever makes sense to do it. In DOS batch files we have
to, and I used Goto labels in Psion's OPL often enough. In a language with no
for loops, where everything if if or while, a goto can be a useful extra
structural control.

It has its place in C - a good example is in error handling; sure, that
- like everything else - can be done without, using proper {}, but there
at least the GOTO (I can't remember the capitalization of the keyword)
does make for more readable code.
[]
A maze of little twisty passages, all alike?


Worse. Ever been lost in a fog? I mean, really lost? It feels like the

Ah, Harry Vaderchi (GROAN!) got the reference:

http://en.wikipedia.org/wiki/Colossa...tle_pass ages
[]
--
J. P. Gilliver. UMRA: 1960/1985 MB++G.5AL-IS-P--Ch++(p)Ar@T0H+Sh0!:`)DNAf

Radio 4 is one of the reasons being British is good. It's not a subset of
Britain - it's almost as if Britain is a subset of Radio 4. - Stephen Fry, in
Radio Times, 7-13 June, 2003.

In message op.wcvdg2x91r0rdn@dell3100, Harry Vaderchi
writes:
On Sun, 15 Apr 2012 22:57:41 +0100, J. P. Gilliver (John)
wrote:

In message ,
Lostgallifreyan writes:
"Harry Vaderchi" wrote in
newsp.wcrs7jxz1r0rdn@dell3100:
[]
http://thestarman.pcministry.com/asm/fire/Fire.html

There's a nicer one, it starts low, and grows a bit, it looks fairly
realistic too. It might be what John Gilliver has. I remember it,
there's

where?

If anyone finds it, please sha I'd like to be able to give credit
where due. The file I have - flame.com, 453 bytes - is dated about 1995
IIRR, but that's probably when I downloaded it; I have the feeling it's
older than that. Unfortunately, not least because of the meaning the
word "flame" has gained in newsgroups, it's impossible to search for.

Sounds like a good description. The one the above code produces is
sufficiently similar that I suspect it's come from the same mind.
[]


through walls and go anywhere so long as they don't get lost trying.

A maze of little twisty passages, all alike?
[]

"Plugh"

(-: - and xyzzy to you too! Showing our age ... I remember playing that
on the university mainframe (Unix) around 1980. (I never actually
finished it - not sure if there was a finish, though I think there was.
I did feed the bird to the snake at one point, which wasn't a good
idea.)

I do also have a screensaver, called flamer.scr - again, can't remember
where I got it, but obviously based on the same code, though it's 26,624
bytes, probably most of which is the necessary screensaver bits.
Googling for "flamer.scr" seems to find lots of mentions of a file of
that name and 26k, though most seem to be torrents about which I know
little.
--
J. P. Gilliver. UMRA: 1960/1985 MB++G.5AL-IS-P--Ch++(p)Ar@T0H+Sh0!:`)DNAf

Radio 4 is one of the reasons being British is good. It's not a subset of
Britain - it's almost as if Britain is a subset of Radio 4. - Stephen Fry, in
Radio Times, 7-13 June, 2003.

"J. P. Gilliver (John)" wrote in
news
size_t Str_C(size_t L,char *O,size_t N,...){ //Length of,Output,Number
of,Inputs...
va_list V; va_start(V,N); int I=1; char *o=O-1,*i,*p=O+L; while(*++o);
if(Lo-O)L=o-O;
while(N--){i=va_arg(V,char*); while((*o++=*i++)&&op)I++; o--; i--;
while(*i++)I++;} *o=0; va_end(V); return I+L-1;
}
//beware wordwarp.

It looks more like Perl than C, i.e. unreadable to many, but I like it... I
have my own ideas about coding style, but they are consistent and they work
for me.

OK - it's certainly impenetrable to me! (But then I've not really done
much C for about 30 years!) Mind you, having a variable o is a bit
sadistic ... (-:

I take it that "0-1" and "0+L" are ways of forcing your compiler to do
something.


Nope, just pointers. In local functions, I like to use O for output, I for
input, L for length, and o and i for iterating pointers based on the base
addresses of their capital-lettered counterparts. In a small self-contained
function, I see no need for long descriptive names, the pattern of the code,
densely written, is less distracting to me. I have my own variable name
conventions, but they do get strecthed a bit once a program gets to around
28K of text. But by then, it's not so much the names that cause confusion,
but the need to manage many functions and the interactions between them.

The file management parts of my DX7 editor have got too complex to work
withotu every fix breaking something else, since I added an audition panel to
allow testing of voice patches before commitng to save, or load to the
editor. I'm going to have to rip out ALL of that part of the progrsam, and
can't handle it at all. So instead of a winter project, finished, it will be
abandoned, and likelty take YEARS. At least a year will pass before I can
approach it again without the ruinous clutter and fatigue that is in my mind
now. I remember it all, until it become a babble of total npoise. At that
point I can't function, it's like a breakdown.

What this does mean is that I might finish X98, because it is a very
different sort of work.

"J. P. Gilliver (John)" wrote in
news
http://en.wikipedia.org/wiki/Colossa...f_twisty_littl
e_passages


Means nothing to me. I can't handle games on computers, except where the
computer IS the game. Which is then very much afoot.. The closest to a game
for the sake of the game, that I ever got into, was the Notpron riddle. I got
to around 27 before I got distracted and lost motivation. Not far, it goes to
over 137 or so now. Maybe a lot more, I haven't seen it for at least a year.