HDTenEightyP/NetNews huggingface dataset:
From: jos@and.nl (Jos Horsmeier)
Newsgroups: comp.lang.c
Subject: Re: Ragged arrays of type long?
Date: 17 Aug 92 15:04:39 GMT
Organization: AND Software BV Rotterdam

In article <1992Aug15.052649.20308@CS.ORST.EDU> warninm@xanth.CS.ORST.EDU (Michael Warning) writes:
|Is it possible to create a ragged array of type long?  My references goes on
|for two pages about how neat ragged arrays of strings are, but says nothing
|about any other data type.
|
|For example:
|
|	static char   *try1[] = {"abc",
|				 "wxyz"};
|
|This works fine, but:
|
|	static long   *try2[] = {{1, 2, 3},
|				 {5, 6, 7, 8}};
|				
|This causes the various flavors of MS-C that i've tried to come up with a 
|'Different levels of indirection' error. [ ... ]

It is a bit tricky I must admit. It seems that the standard made a bit
of an exception to the rule (but they didn't). Let me try to explain:

pointer types and arithmetic types are both called `scalar' types.
Arithmetic types are split up in `floating point' types and `integer'
types. Somewhere in the standard it reads:

3.5.7 Initialization

The initializer for a scalar shall be a single expression, optionally
enclosed in braces. [ ... ]

Every element of your try2 array is a scalar type object, i.e. a pointer
to a long. So, every element can be initialized with just one initializer.
A string literal is considered _one_ initializer. Just take a look at
this, maybe it clarifies things a bit:

char *p = "abc";

is perfectly legal, but

char *p = { 'a', 'b', 'c', '\0' };

is not. It only works for an agregate type (an array.) 

The (ugly) trick you can do here is: introduce separate arrays,
one for every row of the try2 array. Something like this would do it:

static long try2_row0[] = { 1, 2, 3 };
static long try2_row1[] = { 5, 6, 7, 8 };

Defining those arrays without an explicit dimension causes the comiler
to allocate just enough memory for those array, i.e. 7 slots. Hook 
them all together like this:

static long *try2[] = { try2_row0, try2_row1 };

And presto: there's your `ragged' array.

I hope this helps a bit,

kind regards,

Jos aka jos@and.l
Newsgroups: comp.lang.c
From: pedersen@seas.smu.edu (Ted Pedersen)
Subject: Knight's tour
Organization: SMU School Of Engineering and Applied Science
Date: Wed, 12 Aug 1992 16:08:27 GMT

Anyone out there have any nice Knight's Tour code (or know where it can
be readily obtained)?  

(Note : the Knight's Tour is a problem where you try and make a knight  
 visit all of the squares of a chess board (without repitition) and having 
 your knight return to it's original starting point. I don't think I said
 it very well but I hope the idea is sort of clear for those who haven't
 heard of the problem.)

Actually what would be a dream come true is if there is an ftp site or a book
that has programs that solve some of the classical chess problems (n - queens
and knights tour are good examples of that). Hope someone can help. Thanks.   
Newsgroups: comp.lang.c
From: sasghm@theseus.unx.sas.com (Gary Merrill)
Subject: Re: Pointer/address reluctance
Originator: sasghm@theseus.unx.sas.com
Date: Mon, 17 Aug 1992 18:08:57 GMT
Organization: SAS Institute Inc.


In article <l8ojbqINN900@exodus.Eng.Sun.COM>, linden@positive.Eng.Sun.COM (Peter van der Linden) writes:

|> And I find it implausible in the extreme that "an address 
|> constant is not an address".   Does this mean that a case
|> would be made that an integer constant is not an integer?

Of course an integer constant is not an integer.  An integer constant
is an expression in the programming language -- it is a *linguistic*
entity (note that it is defined in the "syntax" portion of the
standard, for example).  An integer is a mathematical object (the
nature of which I will not get into here).  The integer constant
*denotes* ("stands for", if you like) the integer.  What we are
talking about here is simply the difference between a numeral and
a number.  Consider, for example the following:

	An address constant in C begins with an ampersand.
        [true]

but

	An address begins with an ampersand.
        [ridiculous]


|> We have an "address-of" operator, rather than a "pointed-to" operator.
|> It appears that addresses are in the standard however informally.
|> I suspect that people are distinguishing between "pointer"
|> and "address" out of a misguided desire to over-generalize.

No.  Rather it is out of a desire to provide as precise a semantics
as possible while not imposing arbitrary constraints on implementing
the language on possible future architectures.

-- 
Gary H. Merrill  [Principal Systems Developer, C Compiler Development]
SAS Institute Inc. / SAS Campus Dr. / Cary, NC  27513 / (919) 677-8000
sasghm@theseus.unx.sas.com ... !mcnc!sas!sasghm
Newsgroups: comp.lang.c
From: scott@megadata.mega.oz.au (Scott Humphreys)
Subject: Summary: Is "...", instead of ",..." legal ?
Keywords: variable arguments
Organization: Megadata P/L, North Ryde, Sydney, Aust.
Date: Tue, 18 Aug 1992 01:29:12 GMT

Thanks to all that e-mailed me about this question:
> In various books describing the expansion to ANSI-C,
> one of the differences is described as the inclusion
> of the ",..." operator for function prototypes
> [ meaning that a variable number of arguments follow-
>   e.g. int printf (const char *, ...);  ]
> 
> My question is: is this legal : int foo (...);

No - it isn't legal, although gcc 2.2.2 has
extended its language to support (ignore ?) it.
The only 'bug' is that I cannot find it in the 'info gcc'
file as an extension of the language.

Thanks for your time.
-- 
Dad to Jill (6), Hugh (3), Rhett (1), ? (find out in Dec).
email:  scott@megadata.mega.oz.au |        /\          _/_ _/_ 
fax:    (Int'l +61) (02) 887-4847 |       /  )  _. ____/   /   
voice:  (Int'l +61) (02) 805-0899 |      /__/__(__(_) (___<__  
Newsgroups: comp.lang.c
From: atbowler@thinkage.on.ca (Alan Bowler)
Subject: Re: sort routines
Organization: /etc/organization
Date: Fri, 14 Aug 1992 23:55:56 GMT

Actually, if you find yourself wanting to sort a linked list it
may be time to ask yourself if you chose the right data structure
in the first place.  Often (not always) you will find that you
should have picked a ordered tree instead.  
Xref: sparky comp.lang.c:12255 comp.programming:2292
From: dave@cs.arizona.edu (Dave Schaumann)
Newsgroups: comp.lang.c,comp.programming
Subject: Re: A LITTLE BRAINTEASER...
Date: 13 Aug 92 03:00:19 GMT
Reply-To: dave@cs.arizona.edu (Dave Schaumann)
Followup-To: comp.lang.c
Organization: University of Arizona

In article <aet.713608023@munagin>, aet@mullian (bert thompson) writes:
>i have a small problem that's been bugging for a while now.
>
>here's a program that reverses input from the keyboard:
>
>main()
>	char ch = getchar();
        ^^^^
Should be `int'

>	if (ch == EOF)
>		;
>	else {
>		main();
>		putchar(ch);
>	}
>}
>
>the interesting thing about the program is that it uses no data structures
>(structs, arrays, pointers, etc..), to do its thing. everything is thrown
>on the stack.

But the stack /is/ a data structure!  Just because push is defined as
procedure call and pop is defined as procedure return doesn't make it
any less of a data structure than if you had programmed an explicit
stack.

In fact, the I/O streams you are also relying on can be considered a
queue.  Using a stack as temporary storage, you can easily reverse
any queue:

  queue_t queue ;
  stack_t stack ;

  ...

  stack.make_empty() ;
  while( !queue.empty() )
    stack.push( queue.get() ) ;

  while( !stack.empty() )
    queue.put( stack.pop() ) ;

Writing this as a recursive subroutine (which uses an implicit stack), you get

void reverse_queue( queue_t queue ) {

  data_t data ;

  if( !queue.empty() ) {
    data = queue.get() ;
    reverse_queue( queue ) ;
    queue.put( data ) ;
    }
  }

-- 
Dave Schaumann			dave@cs.arizona.edu
Xref: sparky comp.lang.c:12511 comp.programming:2378
From: gm@germal.bs.open.de (Gerald Malitz)
Newsgroups: comp.lang.c,comp.programming
Subject: Re: A LITTLE BRAINTEASER...
Date: 17 Aug 92 13:33:12 GMT
X-Newsreader: Arn V1.00 beta rel2

In article <josef.713800013@uranium>, Josef Moellers writes:

> In <Bswt31.7zC@research.canon.oz.au> andy@research.canon.oz.au (Andy Newman) writes:
> 
> >aet@mullian.ee.mu.OZ.AU (bert thompson) writes:
[...]
> >>	char ch = getchar();
> >        ^^^^^^^
> >	NOT AGAIN!
[...]
> >So how may machines does this work on? Want to run it on something
> >without memory protection and let the little sucker recurse and
> >recurse...
> 
> It'll run perfectly on systems that have signed characters!

	No, it won't.

> EOF usually is -1, so '\377' will expand to -1.

	'\377' may appear at any place within a file.  So (ch == EOF)
may be TRUE long before you reach EndOfFile.

	regards, Gerald.
From: u8705957@cs.uow.edu.au (Hitesh Sanghvi)
Newsgroups: comp.lang.c
Subject: POWER OF LARGE NUMBERS
Date: 12 Aug 92 13:51:06 GMT
Organization: Dept of Computer Science, Wollongong University, Australia

Hello there;

	Does any one know how to raise power of possibly 100 digits 

to possibly 100 digits. Any algorithm or code will be appriciated.

Example

(1234367463746464647464...up to 100 digit)**(647254627463048736...up to 100 digit)
From: jfw@ksr.com (John F. Woods)
Newsgroups: comp.lang.c
Subject: Re: Memory alignment of struct elements
Date: 14 Aug 92 17:15:30 GMT
Article-I.D.: ksr.14806

udalski@astro.Princeton.EDU (Andrzej Udalski) writes:
>I am writing the software for a big database and the space is very
>important. If I try to use a 
>struct { char ch ; float f }
>the compiler (both in SunOS 4.0.1 and Interactive SYSVR3) allocates
>8 bytes for it, starting the "f" element at fifth byte of the structure.
>This makes both reading and writing such records from/to a binary database 
>file (consisting of 5-byte-long records) very inconvinient, requiring
>a declaration of character array of 5 bytes and using "memcpy()". Is there 
>a way to force the compiler to align the struct elements following their 
>true length?

It is possible that the architecture of the machine you are running on forbids
addressing multiple-byte quantities on non-aligned boundaries (I'm pretty
sure the SPARC forbids it).  You're almost certain to take a serious
performance penalty if it is permitted at all.  If the database has not
already been constructed, pad things to four-byte boundaries to make your life
easier, or (better yet) design your software to assume it is necessary to
unpack the on-disk structures into internal variables, as you're already doing.
Making that assumption will make it easier to change the internal layout (to
go from one machine to another, for example, or to change the internal float
to double precision).  In the modern world, where computer centers change
processor architectures frequently, writing in-core data directly out to disk
is asking for trouble.
Newsgroups: comp.lang.c
From: alpha@wyvern.twuug.com (Joe Wright)
Subject: Re: Computer terms, etc
Organization: Box 68621, Virginia Beach, 23455
X-Newsreader: Tin 1.1 PL4
Date: Mon, 17 Aug 1992 03:22:16 GMT

scotth@felix.filenet.com (Scott Hopson) writes:
: In article <1992Aug13.192456.19127@Synopsys.Com> jerry@synopsys.com (Jerry Huth) writes:
: >
: >Scott Hopson (scotth@filenet.com) says:
: >>> > and what is the diff. between  *foo[] and **foo?
: >>> *foo[] is a pointer to an array
: >
: >No, it's an array of pointers, because [] has higher precedence than *.
: 
: Sorry, it was 2:00 AM when I wrote that, I guess I forgot to put
: "of pointers" on the end.
: 
: 
: *foo[] is a pointer to an array [of pointers]
: 
: 
: thanks for the correction.
: 
: -- 
: Scott Hopson   (scotth@filenet.com)

Sorry if I'm beating a dead horse but...

	char *foo[] = {"abc", "def"};
	char **bar;

foo is an array of pointer to char.  bar is a pointer to a pointer to char.

	bar = foo;

This works only because the compiler dereferences foo as &foo[0] to create
a pointer value.  This does not make foo a pointer (although bar is).

The only place that *a[] and **a can be used interchangeably is in the
declaration of formal parameters in functions.  This because parameters
are passed by value to functions and a would be dereferenced to &a[0],
a pointer and placed in an automatic variable for the function.

	fun(foo);

fun(a) char *a[]; {}

The value passed to fun() is &foo[0] and is placed in a as foo is called.
For this reason **a is legal and would give the char pointed to by the
pointer in a.  To avoid confusion,

fun(a) char **a; {}

is much preferred.  I'm not confused.  Really I'm not.

main(argc, argv) char **argv; {}

is preferred for the same reason.  *argv[] is really an array of pointers
and ++argv; would have no meaning.  Actually argv is passed to main as
&argv[0] and placed in a variable on the stack.  Hence the second
declaration is clearer and more correct.  Now ++argv clearly increments
the pointer variable on the stack, not the array.  Clear? 

-- 
Joe Wright  alpha@wyvern.twuug.com
From: daavid@bohra.cpg.oz.au (Daavid Turnbull)
Newsgroups: comp.lang.c
Subject: Re: qsort problem....
Date: 14 Aug 92 13:33:20 GMT
Organization: Computer Power Software

In article <1992Aug10.184635.11618@tin.monsanto.com> bcschu@skws02.monsanto.com (Brett Schultz) writes:
> Hello, for some reason I am having a problem with a qsort system call.  
>
> Here is a test program similar to what I am trying to do:
>
> #include <stdio.h>
> #include <stdlib.h>
> typedef struct my_float {
>     float f;
> }my_float;

/*
**	first add the correct prototype
*/
int qs_compare(const	void *a,const	void *b)
>
>
>
> main()
> {
>   my_float mf[5];
>   int i;
>   
>   mf[0].f = .5444;
>   mf[1].f = .345;
>   mf[2].f = .976;
>   mf[3].f = .764;
>   mf[4].f = .45345;
>
>   for(i=0; i < 5; ++i)
>     printf("mf[%d] = %f\n",i,mf[i].f);
>
>   printf("\n");
>
>   /*qsort((void *) mf, 5, sizeof(my_float), qs_compare);*/
>
>   for(i=0; i < 5; ++i)
>     printf("mf[%d].f = %f\n",i,mf[i].f);
> }
>
/*
**	Then make the function match the prototype (both qsort()'s and itself)
*/
> int qs_compare(const	void *a_,const	void *b_)
> {
	/*
	**	assign the passed args to variables of the correct type
	*/
	myfloat *a = (myfloat) a_;
	myfloat *b = (myfloat) b_;

>    if (a->f < b->f)
>       return (-1);
>    else if (a->f == b->f)
>       return (0);
>    else
>       return (1);
>  }
>
> I want to sort an array of structures by a float in the structure.
>
> This is not compiling.  Here are the errors:
>
[... unusually informative list of errors for this pretty common problem
deleted...]
>
> Brett
This at first feels like a clumbsy solution but you get passed that.
The thing that pisses me off is that the most readable version of
the solution, (IMHO the one I have presented) creates two extra variables,
which are a complete waste of data.

> I want to sort an array of structures by a float in the structure.

A clever compiler might optimise this out.

The other solution which is probably more efficient and is perfectly
readable in this instance where the sort routine is short defines
your sort function :

int qs_compare(const	void *a,  const	void *b)
{
    if ((my_double *a)->f < (my_double *b)->f)
       return (-1);
    else if ((my_double *a)->f == (my_double *b)->f)
       return (0);
    else
       return (1);
}

Thats ansi for you,

daavid
-- 
	Daavid Turnbull
	daavid@bohra.cpg.oz   +61 3 823 0222    (fax) +61 3 824 8068
	uunet!munnari!bohra.cpg.oz!daavid
	CP Software Export Pty Ltd                   ACN 006 640 133
Newsgroups: comp.lang.c
From: steve@taumet.com (Steve Clamage)
Subject: Re: How many malloc's can I use?
Organization: TauMetric Corporation
Date: Tue, 18 Aug 1992 20:44:33 GMT

fjh@munta.cs.mu.OZ.AU (Fergus James HENDERSON) writes:

>elias@proxxi.se (Elias M}rtensson (proxxi)) writes:

>>Does ANSI C specify the maximum number of malloc calls that can safely
>>be made? ...
>>And does ANSI C specify that largest block of memory that can be
>>malloc'ed?

>I am fairly sure that the following would be a ANSI-conforming implementation
>for malloc:

>void *malloc(size_t size) {
>	errno = E_THIS_SYSTEM_DOESNT_HAVE_DYNAMIC_ALLOCATION;
>	return 0;
>}

>In other words, I fairly ANSI does not make any guarantees as to the amount
>of memory that can be allocated with malloc. The only constraint is that if
>for whatever reason it cannot allocate the desired amount, it must return
>a null pointer after setting errno to an appropriate value.

Almost right.  malloc and friends are allowed to set errno but are not
required to do so.

To answer the original question directly, there is nothing in the
ANSI/ISO standard as to the number of malloc calls or the size of a
malloc call which must succeed.  As Fergus points out, a system may
conform to the Standard without being able to allocate heap memory at all.

The main reason for this is that there is very little a Standard could
say on the subject without making otherwise reasonable implementations
invalid, or resorting to machine-specific discussions.

Suppose the requirement were that one call of size 1 must succeed.  Now
suppose that you have a program running on a system with quotas on
memory usage, and the code + static data + stack space just uses up the
quota.  Any request for more memory will fail (including the next
nested function call).  The "quota" mentioned here might be an
arbitrary decision of the system administrator.  It might be the
amount of memory on the computer.  It might be some combination of
ingredients very hard to characterize, including interactions with
other processes on the system.
-- 

Steve Clamage, TauMetric Corp, steve@taumet.com
Vice Chair, ANSI C++ Committee, X3J16
Newsgroups: comp.lang.c
From: quanstro@mari.StOlaf.edu (goon)
Subject: Re: POWER OF LARGE NUMBERS
Organization: St. Olaf College, Northfield, MN USA
	<thompson.713734408@daphne.socsci.umn.edu>
	<1992Aug16.052157.1991@organpipe.uug.arizona.edu>
Date: 16 Aug 92 13:22:45

In article <1992Aug16.052157.1991@organpipe.uug.arizona.edu> dave@cs.arizona.edu (Dave Schaumann) writes:

   In article <thompson.713734408@daphne.socsci.umn.edu>, thompson@atlas (T. Scott Thompson) writes:
   >u8705957@cs.uow.edu.au (Hitesh Sanghvi) writes:
   >
   >>	Does any one know how to raise power of possibly 100 digits 
   >>to possibly 100 digits. Any algorithm or code will be appriciated.
   >
   >Is there any hope of solving this?

   Only if you're willing to give up most of the significant digits.
   But it's certainly within the bounds of imagination to have a
   program that could do something like

     google_t a, b ;

     a = make_google( 10, make_int(100) ) ;
     b = google_mult( a, a ) ;

   At this point, the value of `b' could be expressed as

     make_google( 10, make_google( 10, make_int(10) ) ) ;

   Of course, using C++ would make certain aspects of this easier...


You just contradicted yourself. It is possible. It just takes more
memory and more programming (you can't expect the hardware to handle
this sort of case). Check out the man page for mp (a set of arbitrary
precision arith. functions) if you are on a UNIX system. There is also
a GNU version of these functins.
From: folsom@bigmax.UUCP (Al Folsom)
Newsgroups: comp.lang.c
Subject: Indian Hill Style Guide
Keywords: Style
Date: 13 Aug 92 15:40:35 GMT
Organization: Fischer & Porter Co., Warminster, PA.

The FAQ list gives several sites from which to obtain the 
Indian Hill Style Guide via anonymous ftp.

I do not have anonymous ftp capability.  Does anyone know of 
an alternative mechanism for obtaining this document, preferably
in electronic form?

Thanks - Al F.

+-------------------------------------------------------------------+
| Al Folsom                 | Object Oriented Programming?  We've   |
| Fischer & Porter Co.      | been doing that for years...          |
| ...uunet!bigmax!folsom    |                                       |
| also folsom@decus.org     | When the customer objects to the way  |
| KY3T@WA3TSW (Ham)         | it works, we go program some more!    |
+-------------------------------------------------------------------+

Newsgroups: comp.lang.c
From: s1110238@giaeb.cc.monash.edu.au (Lee Hollingworth)
Subject: Re: AVL tree code
Organization: Monash University, Melb., Australia.
Date: Fri, 14 Aug 1992 12:35:53 GMT

If I e-mailed you my AVLtree code or you copied it from this newsgroup,
please note that there is a bug in the compare macro in the avltree.h
file... :-(

I suggest you delete this macro from the avltree.h file and add the
following function to the top of your avltree.c file;

int compare(int a, int b)
{
    return a == b ? 0 : a > b ? 1 : -1;
}

If anyone wants a copy of the modified code please e-mail me...

Lee Hollingworth
s1110238@giaeb.cc.monash.edu.au
Newsgroups: comp.lang.c
From: jutta@opal.cs.tu-berlin.de (Jutta Degener)
Subject: Re: Memory alignment of struct elements
Organization: Techn. University of Berlin, Germany
Date: Mon, 17 Aug 1992 19:24:44 GMT

adam@microware.com (Adam Goldberg) says he's been forced to do things like:
> typedef struct PARM {
>  char MemIn[4], MemIType, MemISize[2];
>  char MemOut[4],MemOType, MemOSize[2];
> };
>
> Then on each usage of, say 'MemOut', I've got to:
>
>   (char *)(p->MemOut)
>
> Ugly.

Ugly?  Wrong!  (One more point for the identity of truth and beauty.)

P->MemOut, when used in a value context like this, turns from an
`array [4] of char' into the address of the array's first element,
&array[0], a `pointer to char'.  From a type system viewpoint you
do not need the cast.

What you actually want is not `p->MemOut', but `the value of the
bytes in p->MemOut, were they the bytes of the memory representation
of a properly aligned pointer to char'.  The only portable way to get
this is something along the lines of

	char * cp;
	*(char **)memcpy((char *)&cp, p->MemOut, sizeof(cp));

Of course you are free to inline the memcpy.  (So is the compiler.)

This kind of interface could be a job for a code-generator with a
C-like specification language, similar to those that exist for RPC.
A generated assembler (or nonportable C) routine could encode and
decode the routine's parameters and results and call your C function
in between.

--Jutta
Newsgroups: comp.lang.c
From: jes@grendel.demon.co.uk (Jim Segrave)
Distribution: world
Subject: Re: Using ANSI.SYS codes from C?  (Turbo)
X-Mailer: cppnews $Revision: 1.14 $
Organization: None
Date: Wed, 19 Aug 1992 21:55:53 +0000


In article <1992Aug19.135137.1507@tac.fi> tiok_ks@tac.fi writes:

> In article <1992Aug18.111356@shovel.Prime.COM>
> tim@shovel.Prime.COM (Tim Cantin) writes:
> > esc[xm		set color x where colors are:
> > 		foreground:	background:
> > 		30 black	40 black
> > 		^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^___darn, I can't remember them!
> > 						it's the same as the resistor
> > 						code table if you know that! :)~
> 
> > p.s.
> > 	If anyone knows those color codes, feel free to post them! *grin*
> 
> I don't think it's the same... Resistors have 10 different colours,
> order of which I'm not sure of, but according to the Programmer's PC
> Sourcebook there are only 8 ANSI colours:
> 
> text	bkgr.	colour
> ----	-----	------
> 30	40	black
> 31	41	red
> 32	42	green
> 33	43	yellow
> 34	44	blue
> 35	45	magenta
> 36	46	cyan
> 37	47	white
> 
> --------------------------------
> Kimmo Surakka     tiok_ks@tac.fi
> 

And for resistors:
0 - black
1 - brown !!
2 - red
3 - orange
4 - yellow
5 - green
6 - blue
7 - violet
8 - grey
9 - white
Not quite the same... 
--
Jim Segrave (Segrave Software Services)     jes@grendel.demon.co.uk

Newsgroups: comp.lang.c
From: aep@world.std.com (Andrew E Page)
Subject: Sun Sparc2   acc vs gcc
Organization: The World Public Access UNIX, Brookline, MA
Date: Wed, 12 Aug 1992 18:29:50 GMT

   Does anyone have opinions on this?  Particularly

in the area of optimization and register usage?

DoD# 0581   1990 Suzuki VX800   MSF Intro Class Aug 1990


-- 
Andrew E. Page CTO(Warrior Poet)|   Decision and Effort The Archer and Arrow
DSP Ironworks                   |     The difference between what we are
Macintosh and DSP Technology    |           and what we want to be.
Newsgroups: comp.lang.c,comp.programming