HDTenEightyP/NetNews huggingface dataset:
From: amorgan@Xenon.Stanford.EDU (Crunchy Frog)
Subject: Re: Numeric to ASCII / REREAD
Organization: Computer Science Department, Stanford University.
Date: Thu, 9 Apr 1992 01:16:40 GMT

In article <1992Apr8.182404.1@ualr.edu> 
  rdbrown@ualr.edu (Robert D. Brown) writes:
>After one day I've received a bazillion messages to use sprintf()
>to make the conversion I requested (the opposites of atoi, atol, and
>atof).
>
>Now, one of two things are happening. Either I don't understand the
>answer, or those who took the time to reply didn't understand the
>question.
>
>Case 1 (I don't understand the answer):
>     How can I use sprintf() to take a floating point variable and
>convert it to a char * variable?

main()
{
  float wombat = 3.7;
  char  result[40];

  sprintf (result,"%f",wombat);

  printf("The float %f is now a string %s\n",wombat,result);
}

Will produce

The float 3.7 is now a string 3.7

Isn't that what you want?

.. deleted ..

>This is _not_ a FAQ question, for those of you who evoked it.

Maybe you mean something else, but this is an FAQ.

>For those of you who didn't evoke the FAQ thanks for the help
>but it's not quite what I was looking for.
>
>--Robert

C Frog
From: barmar@think.com (Barry Margolin)
Newsgroups: comp.lang.c
Subject: Re: a+++b
Date: 14 Apr 1992 23:39:49 GMT
Organization: Thinking Machines Corporation, Cambridge MA, USA
NNTP-Posting-Host: telecaster.think.com

In article <1992Apr14.171841.15394@lmpsbbs.mot.com> bhv@areaplg2.corp.mot.com (Bronis Vidugiris) writes:
>I'm curious about what is supposed to happen when the title expression
>is evaulated.
>
>Reading K&R suggests that since ++ is right associative, and has a
>higher precedence than +, the 'correct' answer is
>
>a + (++b)

Sorry, no.  Associativity and precedence control how an expression is
evaluated *after* it has been tokenized.  So you start with

	a+++b

and then tokenize it (using the "longest possible token" rule) into

	a ++ + b

Then you disambiguate it (if necessary) using associativity and/or
precedence, resulting in

	( a ++ ) + b
-- 
Barry Margolin
System Manager, Thinking Machines Corp.

barmar@think.com          {uunet,harvard}!think!barmar
Organization: Middle East Technical University - Computer Center
Date: Tuesday, 7 Apr 1992 18:00:41 TUR
From: <E63618@TRMETU.BITNET>
Newsgroups: comp.lang.c
Subject: help| to make a library in tc

dear fellow readers,

I have beendoing some programming in tc for past few months. Now with
a bulk of some useful modules in hand , i tried to make a library of own by
linking all the object modules using ''TLIB'' function provided by Turbo c.
But, unfortunately i was unable to access those modules in my application
programs. So, i would appreciate any sort of help and suggestions given.
Thanking in advance.

Imran
from
M.E.T.U Turkey
From: karl@ima.isc.com (Karl Heuer)
Newsgroups: comp.lang.c
Subject: Re: using #define
Date: 17 Apr 92 18:43:57 GMT
Organization: Interactive Systems, Cambridge, MA 02138-5302

In article <2372@isgtec.isgtec.com> robert@isgtec.com (Robert Osborne) writes:
>    #define FILE(x) sprintf(malloc(30), "FILE.F%d", x)

On most implementations (including all ANSI C implementations), sprintf()
returns an int, rather than the pointer in its first argument.

Karl W. Z. Heuer (karl@ima.isc.com or uunet!ima!karl), The Walking Lint
Xref: sparky comp.lang.c:7395 gnu.gcc.help:1049
From: djones@megatest.UUCP (Dave Jones)
Newsgroups: comp.lang.c,gnu.gcc.help
Subject: Re: hashing out the primes
Date: 9 Apr 92 02:27:07 GMT
Organization: Megatest Corporation, San Jose, Ca

From article <1992Apr1.051232.11540@swsrv1.cirr.com>, by sballew@swsrv1.cirr.com (Sammy Ballew):

> To paraphrase Knuth (Vol 3, 1973), pg 508-509
>     The division method is particularly easy, use the remainder modulo M:
> 
> 	h(k) = K mod M
> 
>     ...some values of M are much better than others.  If M is an even number,
>     h(K) will be even when K is even and odd when K is odd.

... et cetera. Of course this must be the source of the common practice
of sizing hash-tables by prime numbers. Knuth. But, if I remember my Knuth
correctly -- (I can't find a copy just now ) -- it only adds evidence for
my contention that the practice is often rote.

Isn't the K in the formula above supposed to be a number directly
corresponding to the key? -- either the key itself, or a fixed sampling
of characters or bits from the key? The further discussion which you
included, but I omit here, would seem to indicate that. Certainly if
such a simple hash function (the identity-function in effect) is used,
you better mix things up somehow. But the example that gave rise to this
discussion, the gnu loader, uses a hash-function that does a CRC-like
tapped shift-and-or on the bytes. That completely invalidates every rationale
quoted. There may be an argument that primes reduce collisions when used
in conjunction with shift-and-or hash functions, but if so I suspect it
must be a much, much more involved bit of algebra. I remain even
un-convinceder. :-)
Newsgroups: comp.lang.c
From: amorgan@Xenon.Stanford.EDU (Crunchy Frog)
Subject: Re: numeric to ascii
Organization: Computer Science Department, Stanford University.
Date: Wed, 8 Apr 1992 02:26:45 GMT

In article <1992Apr7.202202.1@ualr.edu> 
  rdbrown@ualr.edu (Robert D. Brown) writes:
>What is the opposite of atof(), atoi(), and atol()?

sprintf()

C Frog
From: ag129@cl.cam.ac.uk (Alasdair Grant)
Newsgroups: comp.lang.c
Subject: Re: string representation (was: SPAM SPAM SPAM SPAM)
Date: 14 Apr 92 12:05:56 GMT
Reply-To: ag129@cl.cam.ac.uk (Alasdair Grant)
Organization: U of Cambridge Comp Lab, UK

In article <1992Apr13.225124.22651@vaxeline.ftp.com> dwh@vaxeline.ftp.com (David W. Hamaker) writes:
>In article <1992Apr13.024026.24553@ima.isc.com> karl@ima.isc.com (Karl Heuer) writes:
>>In article <BEAR.92Apr9175715@godzilla.harlqn.co.uk> bear@harlqn.co.uk (Andy Edwards) writes:
>>>[C-style strings should be scrapped because operations like strlen()
>>>are O(N), but would be O(1) if you used a counted string.]
>
>>Use whatever model best suits your need.  In most of my applications,
>>maintaining the length information would be unnecessary overhead.

But only O(1) overhead.  I can live with a program that runs twice as slow,
but not one that runs 100 times as slow.  Besides, a good compiler will be
able to optimise out the maintaining of a string length, especially if these
strings were defined such that length could only be returned via strlen()
and that attempts to access the length field via pointers gave undefined 
results.

>By the way, MY favorite string format idea is a count byte, followed by
>some string bytes, repeated as long as the current count byte has a
>value of 255.  This distributes the count information along the way.  It
>takes the same space as C-style strings for string lengths through 254
>(by FAR the majority).  It has a reasonable amount of overhead for longer
>strings.  It doesn't have a maximum string length.  It allows strings to

But strings still have to be contiguous in memory, and it is still necessary
to read a lot of bytes to find out the length (which affects both processor
cache and virtual memory).  "Append" operations will need some tricky
renormalisation of the second half of the string.  Personally, I favour a
linked-list approach.  But the real point is that the programmer should not
have to know how strings are stored; the compiler should be free to use the
fancy techniques used in languages like Snobol, Icon and Rexx, and to 
generate code for expressions like
  a = a || substr(b || right(c,len(d)),index(s,"a"))
in whichever way it chooses.

Alastair Grant, University of Cambridge                "I demand an AE15"
From: shyatt@PFC.Forestry.CA (ARIAKAS)
Newsgroups: comp.lang.c
Subject: Random Numbers
Date: 14 Apr 92 16:48:53 GMT
Reply-To: shyatt@PFC.Forestry.CA
Organization: Forestry Canada (Pacific Forestry Centre)

Hi, I am writing a program in Turbo C++ which needs to generate random numbers
but the random functions for IBM computers arn't true random. Is there a good
algorithm or package that will simutale true random numbers?
 
Steve Hyatt

  STEVE HYATT                       Title: Coop Student - Computer Science
  Forestry Canada                   Phone: (604) 363-0600
  Victoria, B.C.                    Internet: SHYATT@A1.PFC.Forestry.CA
Newsgroups: comp.lang.c
From: karl@ima.isc.com (Karl Heuer)
Subject: Re: CFront
Organization: Interactive Systems, Cambridge, MA 02138-5302
Date: Thu, 16 Apr 1992 23:13:21 GMT

In article <22719@dog.ee.lbl.gov> torek@horse.ee.lbl.gov (Chris Torek) writes:
>In article <1992Apr15.023754.7579@wyvern.twuug.com>
>alpha@wyvern.twuug.com (Joe Wright) writes:
>>I have seen much here (comp.lang.c) advising use of C++ for
>>certain things because "you can't do that in C".  Isn't it
>>that CFront takes C++ and outputs C?  Could one just code some
>>little trick in C++, run it through CFront and see what it looks
>>like in C?  Why not?
>
>Cfront emits unreadable, unmaintainable, and machine-dependent C code...

I think you missed the point, Chris.  It's true that cfront code is not
intended to be read by humans (though it can be post-processed; check out
the "cback" tool from NewCode Technology, Ltd.)  But cfront is merely an
existence proof for the theorem that anything doable in C++ is also doable
in C.

Or, more properly, anything doable in C++ can be emulated in C.  You may
have to use explicit pointers to represent references; use add(x,y) instead
of x+y for user-defined types; use different names for abs() and labs() and
fabs(); and write your C code carefully instead of depending on the C++
compiler to either flag it as questionable or silently turn it into what you
meant.  If you consider these and similar restrictions to be inconsequential,
then you can do the job in C.

Karl W. Z. Heuer (karl@ima.isc.com or uunet!ima!karl), The Walking Lint
From: maupb@warwick.ac.uk (RouE)
Newsgroups: comp.lang.c
Subject: Implementing sets
Date: 6 Apr 92 23:10:54 GMT
Organization: Computing Services, Warwick University, UK


I haven't programmed in C for a while, and I'm just completing a program
I left half-finished about a year ago. I've lent my 'C Complete Reference'
to a friend, and won't be able to get it back for a while. I know this is
totally basic, but could someone e-mail me just outlining the basics about
defining a set in C.

Thanks,

Jason
-- 
                       Jason L Saunders [ RouE ]      
                     email: maupb@csv.warwick.ac.uk
snail: Warwick Business School, University of Warwick, Coventry CV4 7AL, UK
Newsgroups: comp.lang.c
From: mitchell@mdd.comm.mot.com (Bill Mitchell)
Subject: Re: C code decoding!
Bcc:  mitchell
Reply-To: mitchell@mdd.comm.mot.com (Bill Mitchell)
Organization: Motorola, Mobile Data Division - Seattle, WA
Date: Mon, 6 Apr 1992 14:00:29 GMT

in comp.lang.c, cyberman@toz.buffalo.ny.us (Cyberman) said:

>
>SK>#include <stdio.h>
>SK>#define TWENTYNINE 29
>SK>long ll,L1,l0,h_1,q,h1,h;
>
>SK>main()
>SK>        {
>SK>        for(putchar(putchar((h=7)*10+2)+TWENTYNINE);
>SK>           l0?putchar(l0) :!h_1;
>SK>           putchar(ll),L1==2?ll=' ':0){
>SK>           L1++==0?(ll=l0=54<<1):ll=='l'&&L1<3?(ll+=1L |1L<<1L,l0=0)
>SK>           :L1==sizeof L1&&ll==' ' ?(ll=19+h1): (q-=h1);
>SK>           L1==5?ll-=8:q&&&
>SK>           h_1;L1==sizeof ll+2?
>SK>           (ll+=3):1L;ll==(h<<4)+2
>SK>           &&L1!=6?(ll=ll-6):(h1=100L);L1!=1L<<3?q--
>SK>           :(h_1=ll=h1);
>
>SK>        }
>SK>        printf("%s\n",0);
>SK>        }
>
>That looks like an obvuscated C programers contest entry to me!
>

I think it originated in an article titled "UN*X" in the 1986 April Fool
issue of Computer Language magazine.  This program was printed on page 64
of the 4/86 issue.

-- 
mitchell@mdd.comm.mot.com (Bill Mitchell)
From: eriksea@carson.u.washington.edu (Erik Seaberg)
Newsgroups: comp.lang.c
Subject: Re: impossible in C ? -macro
Keywords: macro declaration return
Date: 9 Apr 92 04:35:49 GMT
Article-I.D.: u.1992Apr9.043549.2435
Organization: Systems, C&C, UW.  Department of Computer Sigh.

perseant@milton.u.washington.edu (Dis Pater) writes:
>holen@xilinx.com (Victor A. Holen ) writes:
>>>Is it possible to have a macro that declares local variables
>>                      I ment LOCAL TO MACRO (SCOPE WITHIN MACRO ONLY)

>No.  On one of the preprocessor passes, macros are expanded.  So, if
>they declare variables, those variable declarations will appear iin
>the body of the program.

Which is okay if you use a simple macro-as-statement trick.  This
worked for me, and I think it's portable:

	#define FOO \
	do { \
		int x = 1; \
		printf("%d\n", x); \
	} while (0)
	
	main() {
		int x = 0;
		FOO;
		printf("%d\n", x);
		return 0;
	}

do { ... } while (0) gives you a macro with a compound statement,
which can declare local variables.  As a bonus, you can forget it's
a macro and use a semicolon after it.  You just have to watch for
"aliasing" problems if the macro has a parameter that could take
on the same name as a local variable you declare.  And remember
the backslashes.

But it's a mediocre substitute for inlined functions.
-- 
This does not represent the views of Advanced Systems Technologies,
Computing and Communications, or the University of Washington.  But
I can hope.                 Erik Seaberg <eriksea@u.washington.edu>
  "If I want to see the sun rise, I'll put it on my background."
Newsgroups: comp.lang.c,comp.os.msdos.programmer,comp.lang.c++
From: chojnows@osiris (Brian Chojnowski)
Subject: Re: Borland Turbo C++ and memory problem at startup
Organization: University of Illinois at Urbana
Date: Tue, 7 Apr 1992 19:33:58 GMT

Did you try running DPMINST after setting your emm386.sys ???? ram    ?

Xref: sparky comp.lang.c:7609 comp.sys.mac.programmer:8246
From: haney@moonshine.llnl.gov (Scott W. Haney)
Newsgroups: comp.lang.c,comp.sys.mac.programmer
Subject: Re: Problem De-allocating Memory in variable sized arrays
Date: 14 Apr 92 22:11:59 GMT
Followup-To: comp.lang.c

karl@ima.isc.com (Karl Heuer) writes:

>In article <1992Apr14.091829.1@tesla.njit.edu> erh0362@tesla.njit.edu writes:
>>>In <1992Apr1.222646.10433@coe.montana.edu> umsfjban@bill.oscs.montana.edu (Jeff Banfield) writes:
>>>[Can you fake a 1-based array using C++ classes?]

>Possibly, but I would avoid it if at all possible.

Why avoid it? One can easily (well, relatively easily) construct portable, 
vectorizable matrix and vector classes using C++.  
I've done it as have a number of other people (see the recent discussion on 
comp.lang.c++).  There is no kludging involved and it it is much easier to 
deal with 1-based arrays stored by columns since most of the scientific
world still is based on Fortran.

Scott
--
-------------------------------------------------------------------------
Scott W. Haney        || Lawrence Livermore N'Lab || The above views are 
haney@random.llnl.gov || P.O. Box 808;  L-644     || mine and not neces-
(510) 423-6308        || Livermore, CA  94550     || sarily LLNL's.
From: matias@ecs.umass.edu
Newsgroups: comp.lang.c
Subject: How do you access your mouse on using c/c++?
Date: 12 Apr 92 03:23:30 GMT


	If any one out there could answer this, I would greatly apreciate it.

How do you go abouts accesing your mouse using turbo c or turbo c++.
I know in Basic, there is a Mouse function, however don't know of any 
for c.

	John.

	matias@ecs.umass.edu
From: dwh@vaxeline.ftp.com (David W. Hamaker)
Newsgroups: comp.lang.c
Subject: Re: string representation (was: SPAM SPAM SPAM SPAM)
Summary: The C compiler/language likes NUL-terminated strings.
Date: 13 Apr 92 22:51:24 GMT
Article-I.D.: vaxeline.1992Apr13.225124.22651
Organization: FTP Software, Inc., Wakefield, MA

In article <1992Apr13.024026.24553@ima.isc.com> karl@ima.isc.com (Karl Heuer) writes:
>In article <BEAR.92Apr9175715@godzilla.harlqn.co.uk> bear@harlqn.co.uk (Andy Edwards) writes:
>>[C-style strings should be scrapped because operations like strlen()
>>are O(N), but would be O(1) if you used a counted string.]

>Use whatever model best suits your need.  In most of my applications,
>maintaining the length information would be unnecessary overhead.

IMHO, the main issue is the language/compiler bias for C-style strings,
which is manifest only in "string constants."  When something is put in
double quotes, a C-style string is the result.  I'd love for the compiler
to be able to generate my "favorite string format of the week" for the
stuff I put in double quotes.  If my "ultimate string package" ends up
munging string constants into my format at run time, it wipes out some of
my vaunted efficiency gains.

I can imagine a preprocessor directive (#strings...#endstr) that could be
used in my "mystrings.h" header that would allow a function written in C
to be put off to the side for the compiler to compile and then call when
compiling the rest of the program.  I don't know if this is a quality idea,
but it is a thought.

By the way, MY favorite string format idea is a count byte, followed by
some string bytes, repeated as long as the current count byte has a
value of 255.  This distributes the count information along the way.  It
takes the same space as C-style strings for string lengths through 254
(by FAR the majority).  It has a reasonable amount of overhead for longer
strings.  It doesn't have a maximum string length.  It allows strings to
contain NUL chars.  It lets your string code take advantage of hardware
instructions that take a byte count, handling long strings in 1/4 K chunks.

The tightest/fastest string move you could do on the PDP-11 was with
C-style strings.

-Dave Hamaker
 dwh@ftp.com
From: jfw@ksr.com (John F. Woods)
Newsgroups: comp.lang.c
Subject: Re: Are 'polymorphic' structs portable?
Date: 15 Apr 92 13:39:59 EDT

bateman@hamel.epm.ornl.gov (Ken Bateman) writes:
>To all you portability gurus out there:
>I want to have a linked list of structures of different types.  So:
>	typedef enum { 
>		typeA, typeB 
>	} element_type;
>	typedef struct _generic_elem {
>		element_type type;
>		struct _generic_elem *next;
>	} generic_elem;
>	typedef struct _typeA_elem {
>		element_type type;
>		generic_elem *next;
>		char *typeA_string;
>	} typeA_elem;
>	typedef struct _typeB_elem {
>		element_type type;
>		generic_elem *next;
>		struct bar this_bar;
>		int any_old_int;
>	} typeB_elem;
>Can I safely assume that the offset of the 'type' and 'next' elements
>is always constant for all compilers?  i.e.:
>	union {
>		generic_elem g;
>		typeA_elem A;
>		typeB_elem B;
>	} foo;

ANSI C guarantees that the address of the first element is the same as the
address of the structure, but I don't think the guarantee extends as far
as you want.  The safest approach would be to bundle the type info into the
_generic_elem structure, which is almost what you had; try:

	typedef struct _typeA_elem {
		generic_elem generic;
	#define a_type generic.type
	#define a_next generic.next
		char *typeA_string;
	} typeA_elem;

	typedef struct _typeB_elem {
		generic_elem generic;
	#define b_type generic.type
	#define b_next generic.next
		struct bar this_bar;
		int any_old_int;
	} typeB_elem;

That said, it would be an oddball compiler indeed that padded items differently
when they appear in the same order, I think.
From: seamans@hrmis.csb (James R. Seamans)
Newsgroups: comp.lang.c
Subject: Re: C Structures
Date: 17 Apr 92 12:45:06 GMT
Reply-To: seamans@hrmis.csb
Organization: National Library of Medicine

In article 703484920@ultrix.ramapo.edu, smclewin@ultrix.ramapo.edu (Scooter McLune) writes:
>aali@dcs.qmw.ac.uk (ALI) writes:
>
>
>>I have a structure thus:
>
>>struct this { 	int x;
>>				int y;
>>			};
>>			
>>I want to declare an array called temp of type struct this ie:
>>struct this temp[10];
>
>>However, I want to declare temp in my main() procedure. This is 
>>because the size of the array is figured out from a file which
>>contains z number of elements.The file is read by a procedure called in 
>>the main() procedure. So my final declaration in my main() procedure is 
>>supposed to be:
>
>>struct this temp[z];
>
>>where z is an int.
>>	However, it doesn`t work! Can anybody suggest how to do this
>>and if I can put my definition of my structure into a header
>>file?
>
>>Thanks,
>
>>Al.
>
>You are right about this not working.  The space for a declaration
>such as
>
>int temp[10] 
>
>is set aside at compile time, not run time as you need to do it.  So
>far as I can see, you have two choices (three if you count giving up :) )
>
>Use the realloc() to dynamically size your array of structures as you need
>
>Declare an array of structures of a size beyond the max you ever think
>it will hit, and only use parts of it as you need to.
>
>
>Solution 1 is nicer, but more difficult to implement
>Solution 2 is quick, dirty and wasteful.  enjoy.
>
>
>SMM


Am I missing something here or what?


One way to implement this is to malloc the array with the size z


	main(){

		struct this *temp
		.
		.
		.
		get z from somewhere...

		temp = (this*)malloc(z * sizeof(this));


	}

my $.02


---
Jim Seamans        seamans@nlm.nih.gov
National Library of Medicine - National Institutes of Health
Bldg 38A RM 712 8600 Rockville Pike Bethesda, MD   20894
(voice) 301 496-4441   (fax) 301 402-0118
Xref: sparky comp.lang.c:7381 comp.unix.misc:1995 comp.unix.programmer:2285 comp.benchmarks:686
From: eisenhof@zax.teraida.UUCP (Karl Eisenhofer)
Newsgroups: comp.lang.c
Subject: Re: using #define
Date: 16 Apr 92 18:56:39 GMT
Organization: Teradyne, Inc. Boston MA

In article <1992Apr13.212232.2709@acsu.buffalo.edu> v101q4ct@ubvmsb.cc.buffalo.edu (Brendon M McNamara) writes:
>How can I do this:
>
>#define FILE(n)   "FILE.F"(somehow stick n in here)
>
>func() {
>    int x;
>    for (x=0;x<10;x++) printf("\n%s",FILE(x));
>}
>
>to create the following output:
>
>FILE.F0
...
>FILE.F9

ANSI C has a definite way to do this: the "stringize" operator.

#define FILE(n) "FILE.F" #n

The # character converts the symbol to a string and in ANSI C, two
strings next to each other are concatenated by the compiler.

(i.e. "this and " "that" is the same is "this and that")

Non-ANSI C compilers may be implementation dependant, but the
Sun C compiler will accept this notation:

#define FILE(n) "FILE.F" "n"

Karl



-- 
Karl Eisenhofer  SPIKE  eisenhofer@maven.dnet.teradyne.com
"Searchlight casting for faults in the clouds of delusion"
Newsgroups: comp.lang.c,comp.os.msdos.programmer,comp.lang.c++
From: joec@fid.morgan.com (Joe Collins)
Subject: Fixed- Borland Turbo C++ and memory problem at startup
Organization: None
Date: Tue, 7 Apr 1992 20:37:37 GMT

In article <1992Apr7.193358.28239@ux1.cso.uiuc.edu> chojnows@osiris (Brian Chojnowski) writes:
>Did you try running DPMINST after setting your emm386.sys ???? ram    ?
>
Yes, and that didn't help....

I did solve it by tweaking my config.sys. Below is the version that
worked on my 386 25Mhz, 4meg RAM - your mileage may vary, i.e. you may need
to change parameters on the EMM386.SYS line. The below change
allows me to run TURBO C++ V3.0 from the DOS 5.0 command line or under
WINDOWS 3.0.

Regards
Joe
joec@morgan.com

-------------------config.sys----------------------------
rem -- Manages uses of extended memory. This MUST be first
device=C:\DOS\HIMEM.SYS
rem -- copies BIOS from slower ROM to faster RAM and executes it there
device=C:\star\util\fastbios.sys
rem -- provides access to expanded memory for those pgms which need it
rem -- [allocates 1m to expanded memory and forces 1536k for extended memory]
device=C:\windows\EMM386.sys 1024 l=1536
rem -- activates the mouse when not in windows
device=c:\utils\misc\mouse.sys
rem -- tell MSDOS 5.0 to load DOS into extended memory (between 640k and 1m)
DOS=HIGH
rem -- Upto 30 files open at one time
FILES=30
rem -- increases how often dos will check for Cntrl-Break
BREAK=ON
rem -- smaller number (25) ok if smartdrive being used
BUFFERS=25
rem -- allows file sharing and file locking
install=c:\dos\share.exe /f:2048 /l:20
rem -- Makes permanent and sets enviroment to 256 bytes (actually a default)
SHELL=C:\DOS\COMMAND.COM /P/E:2048
rem -- Use new MSDOS 5.0 version of smartdrv.sys instead of WINDOWS 3.0 vers
device=C:\DOS\smartdrv.sys 2048 512
rem -- You know why ...
lastdrive=d
--------------------------end of config.sys-------------------

Newsgroups: comp.lang.c