8bitfiles.net/archives/archives.tar/archives/genie-commodore-file-library/Information/C.TUTOR.2.SFX/lesson10

Text File | 1991-03-07 | 7.7 KB | 387 lines

├ ╠ANGUAGE ╘UTORIAL
-------------------
╨ART 10 OF 11


╬╧╘┼: ╙╒┬╙╘╔╘╒╘╔╧╬╙ ╞╧╥ ╙╨┼├╔┴╠ ├
╠┴╬╟╒┴╟┼ ├╚┴╥┴├╘┼╥╙:

╠┼╞╘ ├╒╥╠┘ ┬╥┴├╦┼╘:   █
╥╔╟╚╘ ├╒╥╠┘ ┬╥┴├╦┼╘:  ▌
┬┴├╦ ╙╠┴╙╚:           \
╘╔╠─┼:                »
╓┼╥╘╔├┴╠ ┬┴╥:         ▀
╒╬─┼╥╙├╧╥┼:           ñ


╘HE ├ ╨╥┼╨╥╧├┼╙╙╧╥ -

┬┼╟╔╬
  ─┼├╠┴╥┼_┴╬_╔╬╘┼╟┼╥ X;
  ╠┼╘ X=0;
  ┴╙_╠╧╬╟_┴╙ ( X ╔╙_╠┼╙╙_╘╚┴╬ 5 ) ─╧
  ╠┼╘ X ╔╬├╥┼┴╙┼_┬┘ 1;
  ╨╥╔╬╘_X;
  ╘╚┼╬_╙╘╧╨
┼╬─

╫OULDN'T IT BE NICE IF WE COULD WRITE
THE ABOVE PROGRAM AND HAVE IT TURN
ITSELF INTO THE FOLLOWING PROGRAM
AUTOMATICALLY?

MAIN()
█
  INT X;
  X = 0;
  WHILE(X < 5)
  X += 1;
  PRINTF("%D",X);
▌



╘HIS WOULD REQUIRE THE FOLLOWING
DEFINITIONS:

DEFINE  ┬┼╟╔╬
TO MEAN MAIN() █

DEFINE  ─┼├╠┴╥┼_┴╬_╔╬╘┼╟┼╥
TO MEAN INT

DEFINE  ╠┼╘
TO MEAN (NOTHING!)

DEFINE  ┴╙_╠╧╬╟_┴╙
TO MEAN WHILE

DEFINE  ╔╙_╠┼╙╙_╘╚┴╬
TO MEAN <

DEFINE  ─╧
TO MEAN

DEFINE  ╔╬├╥┼┴╙┼_┬┘
TO MEAN +=

DEFINE  ╨╥╔╬╘_X
TO MEAN PRINTF("%D",X)

DEFINE  ╘╚┼╬_╙╘╧╨
TO MEAN

DEFINE  ┼╬─
TO MEAN ▌

╧NE FASCINATING ASPECT OF THE ├
LANGUAGE IS ITS ABILITY TO PERFORM
REPLACEMENTS OF ┬┼╟╔╬  BY MAIN()  ,
AND ╠┼╘ BY NOTHING (A "NULL STRING")
AND ┼╬─ BY , ETC. ETC.

┬EFORE THE ├-COMPILER GOES TO WORK ON
YOUR PROGRAM, A ├-PREPROCESSOR WILL
MAKE THE APPROPRIATE REPLACEMENTS ...
AND (═┴╟╔├!) THE COMPILER GETS A
NORMAL, STANDARD, ├ PROGRAM TO
COMPILE.

╘O TELL THE PREPROCESSOR THAT YOU
HAVE REDEFINED CERTAIN ├-PHRASES, YOU
NEED ONLY BEGIN YOUR PROGRAM WITH
THESE #DEFINITIONS.


╘O #DEFINE ╘╚╔╙ AS ╘╚┴╘ -

#DEFINE  ┬┼╟╔╬   MAIN() █
#DEFINE  ─┼├╠┴╥┼_┴╬_╔╬╘┼╟┼╥  INT
#DEFINE  ╠┼╘
#DEFINE  ┴╙_╠╧╬╟_┴╙  WHILE
#DEFINE  ╔╙_╠┼╙╙_╘╚┴╬  <
#DEFINE  ╔╬├╥┼┴╙┼_┬┘   +=
#DEFINE  ╨╥╔╬╘_X   PRINTF("%D",X)
#DEFINE  ╘╚┼╬_╙╘╧╨
#DEFINE  ┼╬─ ▌

┬┼╟╔╬
  ─┼├╠┴╥┼_┴╬_╔╬╘┼╟┼╥ X;
  ╠┼╘ X=0;
  ┴╙_╠╧╬╟_┴╙ ( X ╔╙_╠┼╙╙_╘╚┴╬ 5 ) ─╧
  ╨╥╔╬╘_X;
  ╘╚┼╬_╙╘╧╨
┼╬─

╔F THE ABOVE PROGRAM IS WRITTEN AND
COMPILED, THE PREPROCESSOR WILL MAKE
ALL REPLACEMENTS INDICATED BY THE
VARIOUS #DEFINE STATEMENTS! ╘HE
#DEFINE STATEMENTS ARE INSTRUCTIONS
TO THE PREPROCESSOR. ╫E'VE ACTUALLY
SEEN SUCH INSTRUCTIONS BEFORE!

╥EMEMBER #INCLUDE <STDIO.H>  ??

╘╚┴╘ WAS ALSO AN INSTRUCTION TO THE
PREPROCESSOR .. TO REPLACE THE
PHRASE, #INCLUDE <STDIO.H> BY THE
LIBRARY OF STANDARD INPUT/OUTPUT
ROUTINES. ( ...WHICH EXPLAINS WHY A
COMPILED PROGRAM IS OFTEN VERY MUCH
LARGER THAN THE PROGRAM WE WRITE WITH
OUR FAVOURITE TEXT-EDITOR ...IT
CONTAINS THE I/O LIBRARY OF
FUNCTIONS!)

#INCLUDE <STDIO.H>
#INCLUDE <MATH.H>

╙INCE ├ IS SUPPOSED TO BE A ╨╧╥╘┴┬╠┼
LANGUAGE (WRITE A ├ PROGRAM ON YOUR
FAVOURITE TEXT-EDITOR AND COMPILE IF
FOR ┴╬┘ COMPUTER FOR WHICH YOU HAVE A
COMPILER), THE STANDARD IPUT/OUTPUT
ROUTINES ARE SYSTEM DEPENDENT ... AND
NOT, STRICTLY SPEAKING, PART OF THE
LANGUAGE! ╙OMEBODY HAS WRITTEN THE
FUNCTIONS IN STDIO.H WITH A SPECIFIC
COMPUTER IN MIND ...WHICH REMINDS ME
...THE LIBRARY OF ═┴╘╚ FUNCTIONS
(SUCH AS SIN()) IS ╬╧╘ IN STDIO.H.
╔F YOU USE THEM, BE SURE TO
#INCLUDE <MATH.H>.


═ORE #DEFINITIONS -

╔N THE PREVIOUS EXAMPLE WE USED:

#DEFINE  ╨╥╔╬╘_X   PRINTF("%D",X)

WHICH MEANT THAT, TO PRINT Y OR PRINT
A ETC. WE WOULD NEED MORE
#DEFINITIONS (LIKE ╨╥╔╬╘_Y AND
╨╥╔╬╘_A).

┬╒╘, ├ IS VERY SMART. ┘OU CAN INCLUDE
A ╓┴╥╔┴┬╠┼ IN THE #DEFINITION (WITHIN
PARENTHESES!), FOR EXAMPLE:

#DEFINE  ╨╥╔╬╘(X) PRINTF("%D",X)

...AND NOW USE ╨╥╔╬╘(Y) OR ╨╥╔╬╘(A)
ETC AND THE PREPROCESSOR WOULD MAKE
THE SUBSTITUTIONS TO Y OR A.

╫E WANT TO WRITE THE STUFF IN
├┴╨╔╘┴╠╙ BUT HAVE THE ├-COMPILER GET
THE PROPER ├ PROGRAM:

┬┼╟╔╬  MAIN() █
╠┼╘ X=0;  INT X=0;
╔╞ (X ╠┼╙╙ 10) ─╧  WHILE (X<10)
╨╥╔╬╘(X);  PRINTF(" %D ",X);
╨╥╔╬╘(╙╤╒┴╥┼(X));  PRINTF("%D",X*X);
╬┼╫╠╔╬┼;  PRINTF("\N");
╔╬├╥┼┴╙┼(X);  X+=1;
┼╬─╔╞
╙╘╧╨ ▌

...CAN YOU SEE WHAT #DEFINITIONS ARE
NECESSARY ???

╘HESE #DEFINITIONS:
#DEFINE  ┬┼╟╔╬ MAIN() █
#DEFINE  ╠┼╘   INT
#DEFINE  ╔╞  WHILE
#DEFINE  ╠┼╙╙  <
#DEFINE  ─╧
#DEFINE  ╨╥╔╬╘(X)  PRINTF(" %D ",X)
#DEFINE  ╙╤╒┴╥┼(X) X*X
#DEFINE  ╬┼╫╠╔╬┼   PRINTF("\N")
#DEFINE  ╔╬├╥┼┴╙┼(X)   X+=1
#DEFINE  ┼╬─╔╞
#DEFINE  ╙╘╧╨ ▌

╫E WOULD HAVE ALL THOSE #DEFINITIONS
IN A SEPARATE FILE (ON DISK) CALLED,
SAY, NEWDEFS.C SO THAT ANYONE COULD
AUTOMATICALLY USE THE #DEFINITIONS
BY PLACING THE FOLLOWING AT THE
START OF THEIR PROGRAM:

#INCLUDE <NEWDEFS.C>

╘HE PREPROCESSOR WOULD #INCLUDE ALL
THOSE #DEFINITIONS AT THE BEGINNING
OF EVERY PROGRAM, THEN MAKE ALL THE
APPROPRIATE SUBSTITUTIONS AND
REPLACEMENTS ...

╫E HAVE WRITTEN THE #DEFINITIONS
USING ├┴╨╔╘┴╠╙ TO REPLACE ├-PHRASES.

╘HAT'S NOT NECESSARY, BUT ┴─╓╔╙┴┬╠┼!
( THEN IT'S OBVIOUS WHICH PARTS OF
YOUR PROGRAM ARE ╚╧═┼-═┴─┼ AND WHICH
ARE "REAL ├") ...AND BESIDES, IT IS
THE ACCEPTED PRACTICE AMONG REAL
├ PROGRAMMERS.

╬OT ONLY DO #DEFINITIONS ALLOW US TO
WRITE ├ IN A PERSONAL DIALECT, BUT
THEY ALSO ALLOW US TO QUICKLY CHANGE
CERTAIN ├-PHRASES.

╬OTES FROM THE AUTHOR -

╧N THE ├64 ╔ CAN CLEAR THE
SCREEN BY USING:

#DEFINE  ├╠┼┴╥  PRINTF("%C",0X093);
/* WHERE 0X093 IS THE VALUE OF THE
   'CLEAR SCREEN' CHARACTER */

...THEN ╔ CAN USE ├╠┼┴╥;  WHEREVER ╔
NEED IT, IN MY PROGRAM TO CLEAR THE
SCREEN.


╘YPEDEFINITIONS -

┘OU BEGIN YOUR PROGRAM WITH:

#DEFINE ╙┴═  INT

AND IT WILL BE PREPROCESSED, AND EVERY
OCCURRENCE OF ╙┴═ WILL BE REPLACED BY
INT  ...AS IN ╙┴═ X=0; WHICH GETS
PASSED ON TO THE COMPILER (BY THE
PREPROCESSOR) AS INT X=0;

╘HIS "REPLACEMENT" BY THE
PREPROCESSOR HOLDS FOR ANYTHING,
NOT JUST ─┴╘┴ ╘┘╨┼╙. ╙O, FOR EXAMPLE
YOU COULD WRITE:

#DEFINE  ╬EW╠INE╨LEASE  PRINTF("\N")

...WHICH ALLOWS YOU TO USE
╬EW╠INE╨LEASE; IN PLACE OF
PRINTF("\N");

┬╒╘, THERE IS A "SPECIAL" FEATURE FOR
─┴╘┴ ╘┘╨┼╙, CALLED TYPEDEF.

╔F YOU PLACE THE FOLLOWING AT THE
BEGINNING OF YOUR PROGRAM:

TYPEDEF  INT   ╔╬├╚┼╙
/* NOTE THE ORDER! */

...YOU MAY SUBSEQUENTLY USE, IN YOUR
PROGRAM:

╔╬├╚┼╙ X, Y, Z;

...AND THE VARIABLES X, Y AND Z WILL
BE REGARDED (BY THE COMPILER) AS INT
VARIABLES.

╚MMMM...

TYPEDEF  INT   ╔╬├╚┼╙

...DOESN'T SEEM LIKE IT'S ANY
DIFFERENT FROM:

#DEFINE  ╔╬├╚┼╙   INT

┬╒╘, HERE IS THE DIFFERENCE.

╥EMEMBER THE CURIOUS WAY WE HAD TO
REFER TO AN ARGUMENT, PASSED TO A
FUNCTION, WHICH WAS ITSELF A
FUNCTION?

FLOAT SOLVE(F,X,ERROR)
FLOAT (*F)();
/* NOTE THE ABOVE CURIOSITY! */
FLOAT X, ERROR;
█

╚ERE, THE ├-PHRASE FLOAT (*F)();,
SAYS THAT F IS A POINTER TO A
FUNCTION, AND THIS FUNCTION RETURNS A
FLOAT.

╬OW, USING TYPEDEF, WE MAY INTRODUCE
A HOME-MADE ─┴╘┴ ╘┘╨┼ CALLED ╨OINTER
TO A ╞UNCTION WHICH RETURNS A ╞LOAT.

TYPEDEF  FLOAT   (*╨╞╞)()
/* NOTE THE ORDER! */

╒SE THE ABOVE TYPEDEF (NEAR THE
BEGINNING OF YOUR PROGRAM) AND
(═┴╟╔├!) THE PHRASE ╨╞╞ IS
INTERPRETED (BY THE COMPILER) AS
MEANING A ╨OINTER TO A ╞UNCTION WHICH
RETURNS A ╞LOAT.

╒SE IT, IN SOLVE(), LIKE SO:

FLOAT SOLVE(F,X,ERROR)
╨╞╞  F;
FLOAT X, ERROR;
█

╬ICE EH?

╙INCE TYPEDEF IS ═╧╥┼ THAN "JUST A
DUMB REPLACEMENT OF CHARACTERS", THE
PREPROCESSOR WON'T TOUCH IT ... BUT
PASSES IT ALONG TO THE COMPILER!

...AND ╘╚┴╘ MAKES IT DIFFERENT FROM A
#DEFINE TOO!

╚ERE ARE SOME MORE EXAMPLES:

TYPEDEF  CHAR  *╙╘╥╔╬╟

╚ERE ╙╘╥╔╬╟ IS A POINTER TO A STRING
AND YOU MAY WRITE ╙╘╥╔╬╟ X; MEANING
THAT X IS A POINTER TO A CHARACTER
STRING.

TYPEDEF  INT   ╓┼├╘╧╥[5]

╚ERE ╓┼├╘╧╥ IS AN ARRAY OF 5 INTS AND
YOU MAY WRITE ╓┼├╘╧╥ X; SO X IS AN
ARRAY OF 5 INTEGERS.

TYPEDEF  INT   ╔╬╘┼╟┼╥

╚ERE ╔╬╘┼╟┼╥ IS AN INT (OF COURSE!),
AND YOU MAY WRITE ╔╬╘┼╟┼╥ X; ... AND,
WHEN YOU COMPILE YOUR ├ PROGRAM FOR A
DIFFERENT COMPUTER WHERE INT ─┴╘┴
╘┘╨┼╙ ARE 4 BYTES LONG (AND YOU WERE
COUNTING ON THEIR BEING ONLY 2 BYTES
LONG!) YOU CHANGE THIS ONE STATEMENT
TO:

TYPEDEF  SHORT ╔╬╘┼╟┼╥
/* MEANING A "SHORT" INTEGER */

...AND ALL YOUR REFERENCES TO ╔╬╘┼╟┼╥
X; AND ╔╬╘┼╟┼╥ Y; ETC. WILL BE
CHANGED THROUGHOUT THE PROGRAM TO
DECLARE "SHORT" VARIABLE TYPES RATHER
THAN INT'S.

[┼ND OF PART 10 OF 11]