--- /dev/null
+\r
+ \r
+ THE IBM PC PROGRAMMER'S GUIDE TO C\r
+ \r
+ \r
+ \r
+ 3rd Edition\r
+ \r
+ \r
+ \r
+ Matthew Probert\r
+\r
+\r
+ \r
+ COPYRIGHT NOTICE\r
+\r
+\r
+This publication remains the property of Matthew Probert. License is\r
+hereby given for this work to be freely distibuted in whole under the\r
+proviso that credit is given to the author. Sections of this work may be\r
+used and distributed without payment under the proviso that credit is\r
+given to both this work and the author. Source code occuring in this work\r
+may be used within commercial and non-commercial applications without\r
+charge and without reference to the author.\r
+\r
+ BIOGRAPHICAL NOTES\r
+\r
+\r
+Matthew Probert is a software consultant working for his own firm,\r
+Servile Software. He has been involved with micro-computer software\r
+design and programming since the age of eighteen and has been involved\r
+with the C programming language for the past ten years.\r
+\r
+His educational background lies in the non-too distinguished honour of\r
+having a nervous break down during his last year of secondary school\r
+which resulted in a lack of formal qualifications. However, Matthew has\r
+made up for it by achieving a complete recovery and has been studying\r
+Psychology with particular attention to behaviourism and conversation\r
+ever since.\r
+\r
+His chequered career spans back twelve years during which time he has\r
+trained people in the design and use of database management applications,\r
+been called upon to design and implement structured methodologies and has\r
+been a "good old fashioned" analyst programmer.\r
+\r
+Matthew Probert is currently researching Artificial Intelligence with\r
+particular reference to the application of natural language processing,\r
+whereby a computer software package may decode written human language and\r
+respond to it in an intelligent manner. He is also monitoring the\r
+progress of facilitated communication amongst autistic and children with\r
+severe learning and challenging behaviour and hopes one day to be able to\r
+develope a computer based mechanism for true and reliable communication\r
+between autistic people and the rest of society.\r
+\r
+\r
+Matthew Probert can be contacted via\r
+ Servile Software\r
+ 5 Longcroft Close\r
+ Basingstoke\r
+ Hampshire\r
+ RG21 8XG\r
+ England\r
+\r
+ Telephone 01256 478576\r
+\r
+ \r
+ PREFACE\r
+\r
+In 1992, an English software house, Servile Software published a paper\r
+entitled "HOW TO C", which sought to introduce computer programmers to\r
+the C programming language. That paper was written by Matthew Probert. A\r
+follow up effort was "HOW TO CMORE", a document that was also published\r
+by Servile Software. Now those two documents have been amalgamated and\r
+thoroughly revamped to create this book. I have included loads of new\r
+source code that can be lifted directly out of the text.\r
+\r
+All the program listings have been typed in to the Turbo C compiler,\r
+compiled and executed successfully before being imported into this\r
+document.\r
+\r
+I hope you enjoy my work, and more I hope that you learn to program in C.\r
+It really is a great language, there can be no other language that gives\r
+the computer the opportunity to live up to the old saying;\r
+\r
+\r
+"To err is human, to make a complete balls up requires a computer!"\r
+\r
+\r
+\r
+Warning!\r
+\r
+This document is the result of over ten years experience as a software\r
+engineer. This document contains professional source code that is not\r
+intended for beginers.\r
+\r
+\r
+ \r
+ INTRODUCTION\r
+\r
+\r
+The major distinguishing features of the C programming language are;\r
+\r
+ ú block-structured flow-control constructs (typical of most high-level\r
+ languages);\r
+ ú freedom to manipulate basic machine objects (eg: bytes) and to refer\r
+ to them using any particular object view desired (typical of assembly-\r
+ languages);\r
+ ú both high-level operations (eg: floating-point arithmetic) and low-\r
+ level operations (which map closely onto machine-language instructions,\r
+ thereby offering the means to code in an optimal, yet portable, manner).\r
+\r
+This book sets out to describe the C programming language, as commonly\r
+found with compilers for the IBM PC, to enable a computer programmer with\r
+no previous knowledge of the C programming language to program in C using\r
+the IBM PC including the ROM facilities provided by the PC and facilities\r
+provided DOS.\r
+\r
+It is assumed that the reader has access to a C compiler, and to the\r
+documentation that accompanies it regarding library functions.\r
+\r
+The example programs were written with Borland's Turbo C, most of the non-\r
+standard facilities provided by Turbo C should be found in later releases\r
+of Microsoft C.\r
+\r
+\r
+\r
+Differences Between the Various Versions of C\r
+\r
+The original C (prior to the definitive book by K&R) defined the\r
+combination assignment operators (eg: +=, *=, etc.) backwards (ie: they\r
+were written =+, =*, etc.). This caused terrible confusion when a\r
+statement such as\r
+\r
+ x=-y;\r
+was compiled - it could have meant\r
+\r
+ x = x - y;\r
+or\r
+\r
+ x = (-y);\r
+Ritchie soon spotted this ambiguity and changed the language to have\r
+these operators written in the now-familiar manner (+=, *=, etc.).\r
+\r
+The major variations, however, are between K&R C and ANSI C. These can\r
+be summarized as follows:\r
+\r
+ ú introduction of function prototypes in declarations; change of\r
+ function definition preamble to match the style of prototypes;\r
+ ú introduction of the ellipsis ("...") to show variable-length\r
+ function argument lists;\r
+ ú introduction of the keyword `void' (for functions not returning a\r
+ value) and the type `void *' for generic pointer variables;\r
+ ú addition of string-merging, token-pasting and stringizing functions\r
+ in the preprocessor;\r
+ ú addition of trigraph translation in the preprocessor;\r
+ ú addition of the `#pragma' directive and formalization of the\r
+ `declared()' pseudofunction in the preprocessor;\r
+ ú introduction of multi-byte strings and characters to support non-\r
+ English languages;\r
+ ú introduction of the `signed' keyword (to complement the `unsigned'\r
+ keyword when used in integer declarations) and the unary plus (`+')\r
+ operator.\r
+\r
+\r
+\r
+C is a medium level language\r
+\r
+The powerful facilities offered by C to allow manipulation of direct\r
+memory addresses and data, even down to the bit level, along with C's\r
+structured approach to programming cause C to be classified as a "medium\r
+level" programming language. It possesses fewer ready made facilities\r
+than a high level language, such as BASIC, but a higher level of\r
+structure than low level Assembler.\r
+\r
+\r
+Key words\r
+\r
+The original C language as described in; "The C programming language", by\r
+Kernighan and Ritchie, provided 27 key words. To those 27 the ANSI\r
+standards committee on C have added five more. This confusingly results\r
+in two standards for the C language. However, the ANSI standard is\r
+quickly taking over from the old K & R standard.\r
+\r
+\r
+The 32 C key words are;\r
+\r
+auto double int struct\r
+break else long switch\r
+case enum register typedef\r
+char extern return union\r
+const float short unsigned\r
+continue for signed void\r
+default goto sizeof volatile\r
+do if static while\r
+\r
+Some C compilers offer additional key words specific to the hardware\r
+environment that they operate on. You should be aware of your own C\r
+compilers additional key words. Most notably on the PC these are;\r
+\r
+\r
+near far huge\r
+\r
+\r
+\r
+Structure\r
+\r
+C programs are written in a structured manner. A collection of code\r
+blocks are created that call each other to comprise the complete program.\r
+As a structured language C provides various looping and testing commands\r
+such as;\r
+\r
+\r
+ do-while, for, while, if\r
+\r
+and the use of jumps, while provided for, are rarely used.\r
+\r
+A C code block is contained within a pair of curly braces "{ }", and may\r
+be a complete procedure, in C terminology called a "function", or a\r
+subset of code within a function. For example the following is a code\r
+block. The statements within the curly braces are only executed upon\r
+satisfaction of the condition that "x < 10";\r
+\r
+\r
+if (x < 10)\r
+{\r
+ a = 1;\r
+ b = 0;\r
+}\r
+\r
+while this, is a complete function code block containing a sub code block\r
+as a do-while loop;\r
+\r
+int GET_X()\r
+{\r
+ int x;\r
+\r
+ do\r
+ {\r
+ printf("\nEnter a number between 0 and 10 ");\r
+ scanf("%d",&x);\r
+ }\r
+ while(x < 0 || x > 10);\r
+ return(x);\r
+}\r
+\r
+Notice how every statement line is terminated in a semicolon, unless that\r
+statement marks the start of a code block, in which case it is followed\r
+by a curly brace. C is a case sensitive but free flow language, spaces\r
+between commands are ignored, and therefore the semicolon delimiter is\r
+required to mark the end of the command line.\r
+\r
+Having a freeflow structure the following commands are recognised as the\r
+same by the C compiler;\r
+\r
+\r
+ x = 0;\r
+ x =0;\r
+ x=0;\r
+\r
+\r
+The general form of a C program is as follows;\r
+\r
+ compiler preprocessor statements\r
+ global data declarations\r
+ \r
+ \r
+ \r
+ \r
+ return-type main(parameter list)\r
+ {\r
+ statements\r
+ }\r
+ \r
+ return-type f1(parameter list)\r
+ {\r
+ statements\r
+ }\r
+ \r
+ return-type f2(parameter list)\r
+ {\r
+ statements\r
+ }\r
+ .\r
+ .\r
+ .\r
+ return-type fn(parameter list)\r
+ {\r
+ statements\r
+ }\r
+ \r
+\r
+\r
+Comments\r
+\r
+C allows comments to be included in the program. A comment line is\r
+defined by being enclosed within "/*" and "*/". Thus the following is a\r
+comment;\r
+\r
+\r
+/* This is a legitimate C comment line */\r
+\r
+\r
+Libraries\r
+\r
+C programs are compiled and combined with library functions provided with\r
+the C compiler. These libraries are of generally standard functions, the\r
+functionality of which are defined in the ANSI standard of the C\r
+language, but are provided by the individual C compiler manufacturers to\r
+be machine dependant. Thus, the standard library function "printf()"\r
+provides the same facilities on a DEC VAX as on an IBM PC, although the\r
+actual machine language code in the library is quite different for each.\r
+The C programmer however, does not need to know about the internals of\r
+the libraries, only that each library function will behave in the same\r
+way on any computer.\r
+\r
+\r
+ \r
+ DATA TYPES\r
+\r
+\r
+There are four basic types of data in the C language; character, integer,\r
+floating point, and valueless that are referred to by the C key words;\r
+\r
+"char", "int", "float" and "void" respectively.\r
+\r
+To the basic data types may be added the type modifiers; signed,\r
+unsigned, long and short to produce further data types. By default data\r
+types are assumed signed, and the signed modifier is rarely used, unless\r
+to overide a compiler switch defaulting a data type to unsigned.\r
+\r
+The size of each data type varies from one hardware platform to another,\r
+but the least range of values that can be held is described in the ANSI\r
+standard as follows;\r
+\r
+\r
+Type Size Range\r
+ \r
+char 8 -127 to 127\r
+unsigned char 8 0 to 255\r
+int 16 -32767 to 32767\r
+unsigned int 16 0 to 65535\r
+long int 32 -2147483647 to\r
+ 2147483647\r
+unsigned long int 32 0 to 4294967295\r
+float 32 Six digit precision\r
+double 64 Ten digit precision\r
+long double 80 Ten digit precision\r
+\r
+\r
+In practice, this means that the data type `char' is particularly\r
+suitable for storing flag type variables, such as status codes, which\r
+have a limited range of values. The `int' data type can be used, but if\r
+the range of values does not exceed 127 (or 255 for an unsigned char),\r
+then each declared variable would be wasting storage space.\r
+\r
+Which real number data type to use: `float', `double' or `long double' is\r
+another tricky question. When numeric accuracy is required, for example\r
+in an accounting application, the instinct would be to use the `long\r
+double', but this requires at least 10 bytes of storage space for each\r
+variable. And real numbers are not as precise as integers anyway, so\r
+perhaps one should use integer data types instead and work around the\r
+problem. The data type `float' is worse than useless since its six digit\r
+precision is too inaccurate to be relied upon. Generally, then, you\r
+should use integer data types where ever possible, but if real numbers\r
+are required use at least a `double'.\r
+\r
+\r
+Declaring a variable\r
+\r
+All variables in a C program must be declared before they can be used.\r
+The general form of a variable definition is;\r
+\r
+\r
+ type name;\r
+\r
+So, for example to declare a variable "x", of data type "int" so that it\r
+may store a value in the range -32767 to 32767, you use the statement;\r
+\r
+\r
+ int x;\r
+\r
+Character strings may be declared, which are in reality arrays of\r
+characters. They are declared as follows;\r
+\r
+\r
+ char name[number_of_elements];\r
+\r
+So, to declare a string thirty characters long, and called `name' you\r
+would use the declaration;\r
+\r
+\r
+ char name[30];\r
+\r
+\r
+Arrays of other data types also may be declared in one, two or more\r
+dimensions in the same way. For example to declare a two dimensional\r
+array of integers;\r
+\r
+\r
+ int x[10][10];\r
+\r
+The elements of this array are then accessed as;\r
+\r
+ x[0][0]\r
+ x[0][1]\r
+ x[n][n]\r
+\r
+There are three levels of access to variable; local, module and global. A\r
+variable declared within a code block is only known to the statements\r
+within that code block. A variable declared outside any function code\r
+blocks but prefixed with the storage modifier "static" is known only to\r
+the statements within that source module. A variable declared outside any\r
+functions and not prefixed with the static storage type modifier may be\r
+accessed by any statement within any source module of the program.\r
+\r
+\r
+For example;\r
+\r
+ int error;\r
+ static int a;\r
+ \r
+ main()\r
+ {\r
+ int x;\r
+ int y;\r
+ \r
+ }\r
+ \r
+ funca()\r
+ {\r
+ /* Test variable 'a' for equality with 0 */\r
+ if (a == 0)\r
+ {\r
+ int b;\r
+ for(b = 0; b < 20; b++)\r
+ printf("\nHello World");\r
+ }\r
+ \r
+ }\r
+ \r
+\r
+In this example the variable `error' is accessible by all source code\r
+modules compiled together to form the finished program. The variable `a'\r
+is accessible by statements in both functions `main()' and `funca()', but\r
+is invisible to any other source module. Variables `x' and `y' are only\r
+accessible by statements within function `main()'. The variable `b' is\r
+only accessible by statements within the code block following the `if'\r
+statement.\r
+\r
+If a second source module wished to access the variable `error' it would\r
+need to declare `error' as an `extern' global variable thus;\r
+\r
+\r
+ extern int error;\r
+ \r
+ funcb()\r
+ {\r
+ }\r
+ \r
+C will quite happily allow you, the programmer, to assign different data\r
+types to each other. For example, you may declare a variable to be of\r
+type `char' in which case a single byte of data will be allocated to\r
+store the variable. To this variable you can attempt to allocate larger\r
+values, for example;\r
+\r
+\r
+ main()\r
+ {\r
+ \r
+ x = 5000;\r
+ \r
+ }\r
+ \r
+In this example the variable `x' can only store a value between -127 and\r
+128, so the figure 5000 will NOT be assigned to the variable `x'. Rather\r
+the value 136 will be assigned!\r
+\r
+\r
+Often you may wish to assign different data types to each other, and to\r
+prevent the compiler from warning you of a possible error you can use a\r
+cast to tell the compiler that you know what you're doing. A cast\r
+statement is a data type in parenthesis preceding a variable or\r
+expression;\r
+\r
+\r
+ main()\r
+ {\r
+ float x;\r
+ int y;\r
+ \r
+ x = 100 / 25;\r
+ \r
+ y = (int)x;\r
+ }\r
+\r
+In this example the (int) cast tells the compiler to convert the value of\r
+the floating point variable x to an integer before assigning it to the\r
+variable y.\r
+\r
+\r
+\r
+Formal parameters\r
+\r
+A C function may receive parameters from a calling function. These\r
+parameters are declared as variables within the parentheses of the\r
+function name, thus;\r
+\r
+\r
+ int MULT(int x, int y)\r
+ {\r
+ /* Return parameter x multiplied by parameter y */\r
+ return(x * y);\r
+ }\r
+ \r
+ main()\r
+ {\r
+ int a;\r
+ int b;\r
+ int c;\r
+ \r
+ a = 5;\r
+ b = 7;\r
+ c = MULT(a,b);\r
+ \r
+ printf("%d multiplied by %d equals %d\n",a,b,c);\r
+ }\r
+ \r
+\r
+Access modifiers\r
+\r
+There are two access modifiers; `const' and `volatile'. A variable\r
+declared to be `const' may not be changed by the program, whereas a\r
+variable declared as type as type `volatile' may be changed by the\r
+program. In addition, declaring a variable to be volatile prevents the C\r
+compiler from allocating the variable to a register, and reduces the\r
+optimization carried out on the variable.\r
+\r
+\r
+\r
+Storage class types\r
+C provides four storage types; `extern', `static', `auto' and `register'.\r
+\r
+The extern storage type is used to allow a source module within a C\r
+program to access a variable declared in another source module.\r
+\r
+Static variables are only accessible within the code block that declared\r
+them, and additionally if the variable is local, rather than global, they\r
+retain their old value between subsequent calls to the code block.\r
+\r
+Register variables are stored within CPU registers where ever possible,\r
+providing the fastest possible access to their values.\r
+\r
+The auto type variable is only used with local variables, and declares\r
+the variable to retain its value locally only. Since this is the default\r
+for local variables the auto storage type is very rarely used.\r
+ \r
+ \r
+ \r
+ OPERATORS\r
+\r
+Operators are tokens that cause a computation to occur when applied to\r
+variables. C provides the following operators;\r
+\r
+\r
+& Address\r
+* Indirection\r
++ Unary plus\r
+- Unary minus\r
+~ Bitwise compliment\r
+! Logical negation\r
+++ As a prefix;\r
+ preincrement\r
+ As a suffix;\r
+ postincrement\r
+-- As a prefix;\r
+ predecrement\r
+ As a suffix;\r
+ postdecrement\r
++ Addition\r
+- Subtraction\r
+* Multiply\r
+/ Divide\r
+% Remainder\r
+<< Shift left\r
+>> Shift right\r
+& Bitwise AND\r
+| Bitwise OR\r
+^ Bitwise XOR\r
+&& Logical AND\r
+|| Logical OR\r
+= Assignment\r
+*= Assign product\r
+/= Assign quotient\r
+%= Assign remainder\r
+ (modulus)\r
++= Assign sum\r
+-= Assign difference\r
+<<= Assign left shift\r
+>>= Assign right shift\r
+&= Assign bitwise AND\r
+|= Assign bitwise OR\r
+^= Assign bitwise XOR\r
+< Less than\r
+> Greater than\r
+<= Less than or equal\r
+ to\r
+>= Greater than or\r
+ equal to\r
+== Equal to\r
+!= Not equal to\r
+. Direct component\r
+ selector\r
+-> Indirect component\r
+ selector\r
+a ? x:y "If a is true then\r
+ x else y"\r
+[] Define arrays\r
+() Parenthesis\r
+ isolate conditions\r
+ and expressions\r
+... Ellipsis are used\r
+ in formal\r
+ parameter lists of\r
+ function\r
+ prototypes to show\r
+ a variable number\r
+ of\r
+ parameters or\r
+ parameters of\r
+ varying types.\r
+\r
+To illustrate some more commonly used operators consider the following\r
+short program;\r
+\r
+\r
+ main()\r
+ {\r
+ int a;\r
+ int b;\r
+ int c;\r
+ a = 5; /* Assign a value of 5 to variable 'a' */\r
+ b = a / 2; /* Assign the value of 'a' divided by two to\r
+ variable 'b' */\r
+ c = b * 2; /* Assign the value of 'b' multiplied by two\r
+ to variable 'c' */\r
+ \r
+ if (a == c) /* Test if 'a' holds the same value as 'c' */\r
+ \r
+ puts("Variable 'a' is an even number");\r
+ else\r
+ puts("Variable 'a' is an odd number");\r
+ }\r
+ \r
+ \r
+Normally when incrementing the value of a variable you would write\r
+something like;\r
+\r
+ x = x + 1\r
+\r
+C provides the incremental operator '++' as well so that you can write;\r
+\r
+ x++\r
+\r
+Similarly you can decrement the value of a variable using '--' as;\r
+\r
+ x--\r
+\r
+All the other mathematical operators may be used the same, so in a C\r
+program you can write in shorthand;\r
+\r
+\r
+NORMAL C\r
+ \r
+x = x + 1 x++\r
+x = x - 1 x--\r
+x = x * 2 x *= 2\r
+x = x / y x /= y\r
+x = x % 5 x %= 5\r
+\r
+and so on.\r
+ \r
+ \r
+ \r
+ FUNCTIONS\r
+\r
+Functions are the source code procedures that comprise a C program. They\r
+follow the general form;\r
+\r
+ return_type function_name(parameter_list)\r
+ {\r
+ statements\r
+ }\r
+\r
+\r
+The return_type specifies the data type that will be returned by the\r
+function; char, int, double, void &c.\r
+\r
+The code within a C function is invisible to any other C function, and\r
+jumps may not be made from one function into the middle of another,\r
+although functions may call other functions. Also, functions cannot be\r
+defined within functions, only within source modules.\r
+\r
+Parameters may be passed to a function either by value, or by reference.\r
+If a parameter is passed by value, then only a copy of the current value\r
+of the parameter is passed to the function. A parameter passed by\r
+reference however, is a pointer to the actual parameter that may then be\r
+changed by the function.\r
+\r
+\r
+The following example passes two parameters by value to a function,\r
+funca(), which attempts to change the value of the variables passed to\r
+it. And then passes the same two parameters by reference to funcb() which\r
+also attempts to modify their values.\r
+\r
+\r
+ #include <stdio.h>\r
+ \r
+ int funca(int x, int y)\r
+ {\r
+ /* This function receives two parameters by value, x and y */\r
+ \r
+ x = x * 2;\r
+ y = y * 2;\r
+ \r
+ printf("\nValue of x in funca() %d value of y in funca()\r
+ %d",x,y);\r
+ \r
+ return(x);\r
+ }\r
+ \r
+ \r
+ int funcb(int *x, int *y)\r
+ {\r
+ /* This function receives two parameters by reference, x and y\r
+ */\r
+ \r
+ *x = *x * 2;\r
+ *y = *y * 2;\r
+ \r
+ printf("\nValue of x in funcb() %d value of y in funcb()\r
+ %d",*x,*y);\r
+ \r
+ return(*x);\r
+ }\r
+ \r
+ main()\r
+ {\r
+ int x;\r
+ int y;\r
+ int z;\r
+ \r
+ x = 5;\r
+ y = 7;\r
+ \r
+ z = funca(x,y);\r
+ z = funcb(&x,&y);\r
+ \r
+ printf("\nValue of x %d value of y %d value of z %d",x,y,z);\r
+ }\r
+ \r
+\r
+Actually funcb() does not change the values of the parameters it\r
+receives. Rather it changes the contents of the memory addresses pointed\r
+to by the received parameters. While funca() receives the values of\r
+variables `x' and `y' from function main(), funcb() receives the memory\r
+addresses of the variables `x' and `y' from function main().\r
+\r
+\r
+\r
+Passing an array to a function\r
+\r
+The following program passes an array to a function, funca(), which\r
+initialises the array elements;\r
+\r
+ #include <stdio.h>\r
+ \r
+ void funca(int x[])\r
+ {\r
+ int n;\r
+ \r
+ for(n = 0; n < 100; n++)\r
+ x[n] = n;\r
+ }\r
+ \r
+ main()\r
+ {\r
+ int array[100];\r
+ int counter;\r
+ \r
+ funca(array);\r
+ \r
+ for(counter = 0; counter < 100; counter++)\r
+ printf("\nValue of element %d is\r
+ %d",counter,array[counter]);\r
+ }\r
+\r
+The parameter of funca() `int x[]' is declared to be an array of any\r
+length. This works because the compiler passes the address of the start\r
+of the array parameter to the function, rather than the value of the\r
+individual elements. This does of course mean that the function can\r
+change the value of the array elements. To prevent a function from\r
+changing the values you can specify the parameter as type `const';\r
+\r
+\r
+ funca(const int x[])\r
+ {\r
+ }\r
+\r
+This will then generate a compiler error at the line that attempts to\r
+write a value to the array. However, specifying a parameter to be const\r
+does not protect the parameter from indirect assignment as the following\r
+program illustrates;\r
+\r
+\r
+ #include <stdio.h>\r
+ \r
+ int funca(const int x[])\r
+ {\r
+ int *ptr;\r
+ int n;\r
+ \r
+ /* This line gives a 'suspicious pointer conversion warning' */\r
+ /* because x is a const pointer, and ptr is not */\r
+ ptr = x;\r
+ \r
+ for(n = 0; n < 100; n++)\r
+ {\r
+ *ptr = n;\r
+ ptr++;\r
+ }\r
+ }\r
+ \r
+ main()\r
+ {\r
+ int array[100];\r
+ int counter;\r
+ \r
+ funca(array);\r
+ \r
+ for(counter = 0; counter < 100; counter++)\r
+ printf("\nValue of element %d is\r
+ %d",counter,array[counter]);\r
+ }\r
+ \r
+\r
+\r
+Passing parameters to main()\r
+\r
+C allows parameters to be passed from the operating system to the program\r
+when it starts executing through two parameters; argc and argv[], as\r
+follows;\r
+\r
+\r
+ #include <stdio.h>\r
+ \r
+ main(int argc, char *argv[])\r
+ {\r
+ int n;\r
+ \r
+ for(n = 0; n < argc; n++)\r
+ printf("\nParameter %d equals %s",n,argv[n]);\r
+ }\r
+ \r
+\r
+Parameter argc holds the number of parameters passed to the program, and\r
+the array argv[] holds the addresses of each parameter passed. argv[0] is\r
+always the program name. This feature may be put to good use in\r
+applications that need to access system files. Consider the following\r
+scenario:\r
+\r
+A simple database application stores its data in a single file called\r
+"data.dat". The application needs to be created so that it may be stored\r
+in any directory on either a floppy diskette or a hard disk, and executed\r
+both from within the host directory and through a DOS search path. To\r
+work correctly the application must always know where to find the data\r
+file; "data.dat". This is solved by assuming that the data file will be\r
+in the same directory as the executable module, a not unreasonable\r
+restriction to place upon the operator. The following code fragment then\r
+illustrates how an application may apply this algorithm into practice to\r
+be always able to locate a desired system file:\r
+\r
+\r
+ #include <string.h>\r
+ \r
+ char system_file_name[160];\r
+ \r
+ void main(int argc,char *argv[])\r
+ {\r
+ char *data_file = "DATA.DAT";\r
+ char *p;\r
+ \r
+ strcpy(system_file_name,argv[0]);\r
+ p = strstr(system_file_name,".EXE");\r
+ if (p == NULL)\r
+ {\r
+ /* The executable is a .COM file */\r
+ p = strstr(system_file_name,".COM");\r
+ }\r
+ \r
+ /* Now back track to the last '\' character in the file name */\r
+ while(*(p - 1) != '\\')\r
+ p--;\r
+ \r
+ strcpy(p,data_file);\r
+ }\r
+\r
+In practice this code creates a string in system_file_name that is\r
+comprised of path\data.dat, so if for example the executable file is\r
+called "test.exe" and resides in the directory \borlandc, then\r
+system_file_name will be assigned with: \borlandc\data.dat\r
+\r
+\r
+\r
+Returning from a function\r
+\r
+The command `return' is used to return immediately from a function. If\r
+the function was declared with a return data type, then return should be\r
+used with a parameter of the same data type.\r
+\r
+\r
+\r
+Function prototypes\r
+\r
+Prototypes for functions allow the C compiler to check that the type of\r
+data being passed to and from functions is correct. This is very\r
+important to prevent data overflowing its allocated storage space into\r
+other variables areas.\r
+\r
+A function prototype is placed at the beginning of the program, after any\r
+preprocessor commands, such as #include <stdio.h>, and before the\r
+declaration of any functions.\r
+ \r
+ THE C PREPROCESSOR\r
+\r
+C allows for commands to the compiler to be included in the source code.\r
+These commands are then called preprocessor commands and are defined by\r
+the ANSI standard to be;\r
+\r
+\r
+ #if\r
+ #ifdef\r
+ #ifndef\r
+ #else\r
+ #elif\r
+ #include\r
+ #define\r
+ #undef\r
+ #line\r
+ #error\r
+ #pragma\r
+\r
+All preprocessor commands start with a hash symbol, "#", and must be on a\r
+line on their own (although comments may follow).\r
+\r
+\r
+\r
+#define\r
+\r
+The #define command specifies an identifier and a string that the\r
+compiler will substitute every time it comes accross the identifier\r
+within that source code module. For example;\r
+\r
+\r
+#define FALSE 0\r
+#define TRUE !FALSE\r
+\r
+The compiler will replace any subsequent occurence of `FALSE' with `0'\r
+and any subsequent occurence of `TRUE' with `!0'. The substitution does\r
+NOT take place if the compiler finds that the identifier is enclosed by\r
+quotation marks, so\r
+\r
+\r
+ printf("TRUE");\r
+\r
+would NOT be replaced, but\r
+\r
+ printf("%d",FALSE);\r
+\r
+would be.\r
+\r
+The #define command also can be used to define macros that may include\r
+parameters. The parameters are best enclosed in parenthesis to ensure\r
+that correct substitution occurs.\r
+\r
+\r
+This example declares a macro `larger()' that accepts two parameters and\r
+returns the larger of the two;\r
+\r
+ #include <stdio.h>\r
+ \r
+ #define larger(a,b) (a > b) ? (a) : (b)\r
+ \r
+ int main()\r
+ {\r
+ printf("\n%d is largest",larger(5,7));\r
+ \r
+ }\r
+\r
+\r
+#error\r
+\r
+The #error command causes the compiler to stop compilation and to display\r
+the text following the #error command. For example;\r
+\r
+\r
+#error REACHED MODULE B\r
+\r
+will cause the compiler to stop compilation and display;\r
+\r
+ REACHED MODULE B\r
+\r
+\r
+\r
+#include\r
+\r
+The #include command tells the compiler to read the contents of another\r
+source file. The name of the source file must be enclosed either by\r
+quotes or by angular brackets thus;\r
+\r
+\r
+ #include "module2.c"\r
+ #include <stdio.h>\r
+\r
+Generally, if the file name is enclosed in angular brackets, then the\r
+compiler will search for the file in a directory defined in the\r
+compiler's setup. Whereas if the file name is enclosed in quotes then the\r
+compiler will look for the file in the current directory.\r
+\r
+\r
+\r
+#if, #else, #elif, #endif\r
+\r
+The #if set of commands provide conditional compilation around the\r
+general form;\r
+\r
+ #if constant_expression\r
+ statements\r
+ #else\r
+ statements\r
+ #endif\r
+\r
+#elif stands for '#else if' and follows the form;\r
+\r
+ #if expression\r
+ statements\r
+ #elif expression\r
+ statements\r
+ #endif\r
+\r
+\r
+\r
+#ifdef, #ifndef\r
+\r
+These two commands stand for '#if defined' and '#if not defined'\r
+respectively and follow the general form;\r
+\r
+ #ifdef macro_name\r
+ statements\r
+ #else\r
+ statements\r
+ #endif\r
+\r
+ #ifndef macro_name\r
+ statements\r
+ #else\r
+ statements\r
+ #endif\r
+\r
+where 'macro_name' is an identifier declared by a #define statement.\r
+\r
+\r
+\r
+#undef\r
+\r
+Undefines a macro previously defined by #define.\r
+\r
+\r
+#line\r
+\r
+Changes the compiler declared global variables __LINE__ and __FILE__. The\r
+general form of #line is;\r
+\r
+ #line number "filename"\r
+\r
+where number is inserted into the variable '__LINE__' and 'filename' is\r
+assigned to '__FILE__'.\r
+\r
+\r
+#pragma\r
+\r
+This command is used to give compiler specific commands to the compiler.\r
+The compiler's manual should give you full details of any valid options\r
+to go with the particular implementation of #pragma that it supports.\r
+ \r
+ PROGRAM CONTROL STATEMENTS\r
+\r
+As with any computer language, C includes statements that test the\r
+outcome of an expression. The outcome of the test is either TRUE or\r
+FALSE. The C language defines a value of TRUE as non-zero, and FALSE as\r
+zero.\r
+\r
+\r
+\r
+Selection statements\r
+\r
+The general purpose selection statement is "if" that follows the general\r
+form;\r
+\r
+ if (expression)\r
+ statement\r
+ else\r
+ statement\r
+\r
+Where "statement" may be a single statement, or a code block enclosed in\r
+curly braces. The "else" is optional. If the result of the expression\r
+equates to TRUE, then the statement(s) following the if() will be\r
+evaluated. Otherwise the statement(s) following the else, if there is\r
+one, will be evaluated.\r
+\r
+\r
+An alternative to the if....else combination is the ?: command that takes\r
+the form;\r
+\r
+\r
+ expression ? true_expression : false_expression\r
+\r
+Where if the expression evaluates to TRUE, then the true_expression will\r
+be evaluated, otherwise the false_expression will be evaluated. Thus we\r
+get;\r
+\r
+\r
+ #include <stdio.h>\r
+ \r
+ main()\r
+ {\r
+ int x;\r
+ \r
+ x = 6;\r
+ \r
+ printf("\nx is an %s number", x % 2 == 0 ? "even" : "odd");\r
+ }\r
+ \r
+C also provides a multiple branch selection statement, switch, which\r
+successively tests a value of an expression against a list of values and\r
+branches program execution to the first match found. The general form of\r
+switch is;\r
+\r
+\r
+ switch (expression)\r
+ {\r
+ case value1 : statements\r
+ break;\r
+ case value2 : statements\r
+ break;\r
+ .\r
+ .\r
+ .\r
+ .\r
+ case valuen : statements\r
+ break;\r
+ default : statements\r
+ }\r
+\r
+The break statement is optional, but if omitted, program execution will\r
+continue down the list.\r
+\r
+ #include <stdio.h>\r
+ \r
+ main()\r
+ {\r
+ int x;\r
+ \r
+ x = 6;\r
+ \r
+ switch(x)\r
+ {\r
+ case 0 : printf("\nx equals zero");\r
+ break;\r
+ case 1 : printf("\nx equals one");\r
+ break;\r
+ case 2 : printf("\nx equals two");\r
+ break;\r
+ case 3 : printf("\nx equals three");\r
+ break;\r
+ default : printf("\nx is larger than three");\r
+ }\r
+ }\r
+\r
+Switch statements may be nested within one another. This is a\r
+particularly useful feature for confusing people who read your source\r
+code!\r
+\r
+\r
+Iteration statements\r
+C provides three looping or iteration statements; for, while, and do-\r
+while. The for loop has the general form;\r
+\r
+\r
+ for(initialization;condition;increment)\r
+\r
+and is useful for counters such as in this example that displays the\r
+entire ascii character set;\r
+\r
+ #include <stdio.h>\r
+ \r
+ main()\r
+ {\r
+ int x;\r
+ \r
+ for(x = 32; x < 128; x++)\r
+ printf("%d\t%c\t",x,x);\r
+ }\r
+ \r
+An infinite for loop is also quite valid;\r
+\r
+ for(;;)\r
+ {\r
+ statements\r
+ }\r
+\r
+Also, C allows empty statements. The following for loop removes leading\r
+spaces from a string;\r
+\r
+ for(; *str == ' '; str++)\r
+ ;\r
+\r
+Notice the lack of an initializer, and the empty statement following the\r
+loop.\r
+\r
+The while loop is somewhat simpler than the for loop and follows the\r
+general form;\r
+\r
+ while (condition)\r
+ statements\r
+\r
+The statement following the condition, or statements enclosed in curly\r
+braces will be executed until the condition is FALSE. If the condition is\r
+false before the loop commences, the loop statements will not be\r
+executed. The do-while loop on the other hand is always executed at least\r
+once. It takes the general form;\r
+\r
+\r
+ do\r
+ {\r
+ statements\r
+ }\r
+ while(condition);\r
+\r
+\r
+Jump statements\r
+\r
+The "return" statement is used to return from a function to the calling\r
+function. Depending upon the declared return data type of the function it\r
+may or may not return a value;\r
+\r
+\r
+ int MULT(int x, int y)\r
+ {\r
+ return(x * y);\r
+ }\r
+\r
+or;\r
+\r
+ void FUNCA()\r
+ {\r
+ printf("\nHello World");\r
+ return;\r
+ }\r
+\r
+The "break" statement is used to break out of a loop or from a switch\r
+statement. In a loop it may be used to terminate the loop prematurely, as\r
+shown here;\r
+\r
+\r
+ #include <stdio.h>\r
+ \r
+ main()\r
+ {\r
+ int x;\r
+ \r
+ for(x = 0; x < 256; x++)\r
+ {\r
+ if (x == 100)\r
+ break;\r
+ \r
+ printf("%d\t",x);\r
+ }\r
+ }\r
+\r
+In contrast to "break" is "continue", which forces the next iteration of\r
+the loop to occur, effectively forcing program control back to the loop\r
+statement.\r
+\r
+\r
+C provides a function for terminating the program prematurely, "exit()".\r
+Exit() may be used with a return value to pass back to the calling\r
+program;\r
+\r
+\r
+ exit(return_value);\r
+\r
+\r
+More About ?:\r
+\r
+\r
+A powerful, but often misunderstood feature of the C programming language\r
+is ?:. This is an operator that acts upon a boolean expression, and\r
+returns one of two values dependant upon the result of the expression;\r
+\r
+\r
+ <boolean expression> ? <value for true> : <value for false>\r
+\r
+It can be used almost anywhere, for example it was used in the binary\r
+search demonstration program;\r
+\r
+ printf("\n%s\n",(result == 0) ? "Not found" : "Located okay");\r
+\r
+Here it passes either "Not found" or "Located okay" to the printf()\r
+function dependant upon the outcome of the boolean expression `result ==\r
+0'. Alternatively it can be used for assigning values to a variable;\r
+\r
+ x = (a == 0) ? (b) : (c);\r
+\r
+Which will assign the value of b to variable x if a is equal to zero,\r
+otherwise it will assign the value of c to variable x.\r
+\r
+This example returns the name of the executing program, without any path\r
+description;\r
+\r
+ #include <stdio.h>\r
+ #include <stddef.h>\r
+ #include <string.h>\r
+ \r
+ char *progname(char *pathname)\r
+ {\r
+ /* Return name of running program */\r
+ unsigned l;\r
+ char *p;\r
+ char *q;\r
+ static char bnbuf[256];\r
+ \r
+ return pathname? p = strrchr (pathname, '\\'),\r
+ q = strrchr (pathname, '.'),\r
+ l = (q == NULL? strchr (pathname, '\0'): q)\r
+ - (p == NULL? p = pathname: ++p),\r
+ strncpy (bnbuf, p, l),\r
+ bnbuf[l] = '\0',\r
+ strlwr (bnbuf)\r
+ : NULL;\r
+ }\r
+ \r
+ void main(int argc, char *argv[])\r
+ {\r
+ printf("\n%s",progname(argv[0]));\r
+ }\r
+ \r
+ \r
+\r
+Continue\r
+\r
+The continue keyword forces control to jump to the test statement of the\r
+innermost loop (while, do...while()). This can be useful for terminating\r
+a loop gracefuly as this program that reads strings from a file until\r
+there are no more illustrates;\r
+\r
+\r
+ #include <stdio.h>\r
+ \r
+ void main()\r
+ {\r
+ FILE *fp;\r
+ char *p;\r
+ char buff[100];\r
+ \r
+ fp = fopen("data.txt","r");\r
+ if (fp == NULL)\r
+ {\r
+ fprintf(stderr,"Unable to open file data.txt");\r
+ exit(0);\r
+ }\r
+ \r
+ do\r
+ {\r
+ p = fgets(buff,100,fp);\r
+ if (p == NULL)\r
+ /* Force exit from loop */\r
+ continue;\r
+ puts(p);\r
+ }\r
+ while(p);\r
+ }\r
+ \r
+With a for() loop however, continue passes control back to the third\r
+parameter!\r
+ \r
+ INPUT AND OUTPUT\r
+\r
+\r
+\r
+Input\r
+Input to a C program may occur from the console, the standard input\r
+device (unless otherwise redirected this is the console), from a file or\r
+from a data port.\r
+\r
+The general input command for reading data from the standard input stream\r
+`stdin' is scanf(). Scanf() scans a series of input fields, one character\r
+at a time. Each field is then formatted according to the appropriate\r
+format specifier passed to the scanf() function as a parameter. This\r
+field is then stored at the ADDRESS passed to scanf() following the\r
+format specifiers list.\r
+\r
+For example, the following program will read a single integer from the\r
+stream stdin;\r
+\r
+\r
+ main()\r
+ {\r
+ int x;\r
+ \r
+ scanf("%d",&x);\r
+ }\r
+\r
+Notice the address operator & prefixing the variable name `x' in the\r
+scanf() parameter list. This is because scanf() stores values at\r
+ADDRESSES rather than assigning values to variables directly.\r
+\r
+The format string is a character string that may contain three types of\r
+data:\r
+\r
+whitespace characters (space, tab and newline), non-whitespace characters\r
+(all ascii characters EXCEPT %) and format specifiers.\r
+\r
+Format specifiers have the general form;\r
+\r
+\r
+ %[*][width][h|l|L]type_character\r
+\r
+After the % sign the format specifier is comprised of:\r
+\r
+ an optional assignment suppression character, *, which suppresses\r
+ assignment of the next input field.\r
+ \r
+ an optional width specifier, width, which declares the maximum number\r
+ of characters to be read.\r
+ \r
+ an optional argument type modifier, h or l or L, where:\r
+ h is a short integer\r
+ l is a long\r
+ L is a long double\r
+\r
+ the data type character that is one of;\r
+\r
+\r
+d Decimal integer\r
+D Decimal long integer\r
+o Octal integer\r
+O Octal long integer\r
+i Decimal, octal or hexadecimal integer\r
+I Decimal, octal or hexadecimal long\r
+ integer\r
+u Decimal unsigned integer\r
+U Decimal unsigned long integer\r
+x Hexadecimal integer\r
+X Hexadecimal long integer\r
+e Floating point\r
+f Floating point\r
+g Floating point\r
+s Character string\r
+c Character\r
+% % is stored\r
+\r
+An example using scanf();\r
+\r
+\r
+ #include <stdio.h>\r
+ \r
+ main()\r
+ {\r
+ char name[30];\r
+ int age;\r
+ \r
+ printf("\nEnter your name and age ");\r
+ scanf("%30s%d",name,&age);\r
+ printf("\n%s %d",name,age);\r
+ }\r
+\r
+Notice the include line, "#include <stdio.h>", this is to tell the\r
+compiler to also read the file stdio.h that contains the function\r
+prototypes for scanf() and printf().\r
+\r
+\r
+If you type in and run this sample program you will see that only one\r
+name can be entered, that is you can't enter;\r
+\r
+\r
+ JOHN SMITH\r
+\r
+because scanf() detects the whitespace between "JOHN" and "SMITH" and\r
+moves on to the next input field, which is age, and attempts to assign\r
+the value "SMITH" to the age field! The limitations of scanf() as an\r
+input function are obvious.\r
+\r
+An alternative input function is gets() that reads a string of characters\r
+from the stream stdin until a newline character is detected. The newline\r
+character is replaced by a null (0 byte) in the target string. This\r
+function has the advantage of allowing whitespace to be read in. The\r
+following program is a modification to the earlier one, using gets()\r
+instead of scanf().\r
+\r
+\r
+ #include <stdio.h>\r
+ #include <stdlib.h>\r
+ #include <string.h>\r
+ \r
+ main()\r
+ {\r
+ char data[80];\r
+ char *p;\r
+ char name[30];\r
+ int age;\r
+ \r
+ printf("\nEnter your name and age ");\r
+ /* Read in a string of data */\r
+ gets(data);\r
+ \r
+ \r
+ /* P is a pointer to the last character in the input string */\r
+ p = &data[strlen(data) - 1];\r
+ \r
+ /* Remove any trailing spaces by replacing them with null bytes\r
+ */\r
+ while(*p == ' '){\r
+ *p = 0;\r
+ p--;\r
+ }\r
+ \r
+ /* Locate last space in the string */\r
+ p = strrchr(data,' ');\r
+ \r
+ /* Read age from string and convert to an integer */\r
+ age = atoi(p);\r
+ \r
+ /* Terminate data string at start of age field */\r
+ *p = 0;\r
+ \r
+ /* Copy data string to name variable */\r
+ strcpy(name,data);\r
+ \r
+ /* Display results */\r
+ printf("\nName is %s age is %d",name,age);\r
+ }\r
+\r
+\r
+Output\r
+The most common output function is printf() that is very similar to\r
+scanf() except that it writes formatted data out to the standard output\r
+stream stdout. Printf() takes a list of output data fields and applies\r
+format specifiers to each and outputs the result. The format specifiers\r
+are the same as for scanf() except that flags may be added to the format\r
+specifiers. These flags include;\r
+\r
+\r
+ - Which left justifies the output padding to the right with spaces.\r
+ + Which causes numbers to be prefixed by their sign\r
+\r
+The width specifier is also slightly different for printf(). In its most\r
+useful form is the precision specifier;\r
+\r
+\r
+ width.precision\r
+\r
+So, to print a floating point number to three decimal places you would\r
+use;\r
+\r
+ printf("%.3f",x);\r
+\r
+And to pad a string with spaces to the right or truncate the string to\r
+twenty characters if it is longer, to form a fixed twenty character\r
+width;\r
+\r
+ printf("%-20.20s",data);\r
+\r
+Special character constants may appear in the printf() parameter list.\r
+These are;\r
+\r
+\n Newline\r
+\r Carriage return\r
+\t Tab\r
+\b Sound the computer's bell\r
+\f Formfeed\r
+\v Vertical tab\r
+\\ Backslash character\r
+\' Single quote\r
+\" Double quote\r
+\? Question mark\r
+\O Octal string\r
+\x Hexadecimal string\r
+\r
+Thus, to display "Hello World", surrounded in quotation marks and\r
+followed by a newline you would use;\r
+\r
+ printf("\"Hello World\"\n");\r
+\r
+The following program shows how a decimal integer may be displayed as a\r
+decimal, hexadecimal or octal integer. The 04 following the % in the\r
+printf() format tells the compiler to pad the displayed figure to a width\r
+of at least four digits padded with leading zeroes if required.\r
+\r
+\r
+ /* A simple decimal to hexadecimal and octal conversion program */\r
+ \r
+ #include <stdio.h>\r
+ \r
+ main()\r
+ {\r
+ int x;\r
+ \r
+ do\r
+ {\r
+ printf("\nEnter a number, or 0 to end ");\r
+ scanf("%d",&x);\r
+ printf("%04d %04X %04o",x,x,x);\r
+ }\r
+ while(x != 0);\r
+ \r
+ }\r
+ \r
+There are associated functions to printf() that you should be aware of.\r
+fprintf() has the prototype;\r
+\r
+ fprintf(FILE *fp,char *format[,argument,...]);\r
+\r
+This variation on printf() simply sends the formatted output to the\r
+specified file stream.\r
+\r
+sprintf() has the function prototype;\r
+\r
+ sprintf(char *s,char *format[,argument,...]);\r
+\r
+and writes the formatted output to a string. You should take care using\r
+sprintf() that the target string has been declared long enough to hold\r
+the result of the sprintf() output. Otherwise other data will be\r
+overwritten in memory.\r
+\r
+An example of using sprintf() to copy multiple data to a string;\r
+\r
+ #include<stdio.h>\r
+ \r
+ int main()\r
+ {\r
+ char buffer[50];\r
+ \r
+ sprintf(buffer,"7 * 5 == %d\n",7 * 5);\r
+ \r
+ puts(buffer);\r
+ }\r
+ \r
+\r
+An alternative to printf() for outputting a simple string to the stream\r
+stdout is puts(). This function sends a string to the stream stdout\r
+followed by a newline character. It is faster than printf(), but far less\r
+flexible. Instead of;\r
+\r
+ printf("Hello World\n");\r
+\r
+You can use;\r
+\r
+ puts("Hello World");\r
+\r
+\r
+\r
+Direct Console I/O\r
+Data may be sent to, and read directly from the console (keyboard and\r
+screen) using the direct console I/O functions. These functions are\r
+prefixed `c'. The direct console I/O equivalent of printf() is then\r
+cprintf(), and the equivalent of puts() is cputs(). Direct console I/O\r
+functions differ from standard I?o functions:\r
+\r
+ 1. They do not make use of the predefined streams, and hence may not be\r
+ redirected\r
+ 2. They are not portable across operating systems (for example you cant\r
+ use direct console I/O functions in a Windows programme).\r
+ 3. They are faster than their standard I/O equivalents\r
+ 4. They may not work with all video modes (especially VESA display\r
+ modes).\r
+ \r
+ \r
+ \r
+ POINTERS\r
+\r
+A pointer is a variable that holds the memory address of an item of data.\r
+Therefore it points to another item. A pointer is declared like an\r
+ordinary variable, but its name is prefixed by `*', thus;\r
+\r
+\r
+ char *p;\r
+\r
+This declares the variable `p' to be a pointer to a character variable.\r
+Pointers are very powerful, and similarly dangerous! If only because a\r
+pointer can be inadvertently set to point to the code segment of a\r
+program and then some value assigned to the address of the pointer!\r
+\r
+The following program illustrates a simple, though fairly useless\r
+application of a pointer;\r
+\r
+\r
+ #include <stdio.h>\r
+ \r
+ main()\r
+ {\r
+ int a;\r
+ int *x;\r
+ \r
+ /* x is a pointer to an integer data type */\r
+ \r
+ a = 100;\r
+ x = &a;\r
+ \r
+ printf("\nVariable 'a' holds the value %d at memory address\r
+ %p",a,x);\r
+ }\r
+\r
+Here is a more useful example of a pointer illustrating how because the\r
+compiler knows the type of data pointed to by the pointer, when the\r
+pointer is incremented it is incremented the correct number of bytes for\r
+the data type. In this case two bytes;\r
+\r
+ #include <stdio.h>\r
+ \r
+ main()\r
+ {\r
+ int n;\r
+ int a[25];\r
+ int *x;\r
+ \r
+ /* x is a pointer to an integer data type */\r
+ \r
+ /* Assign x to point to array element zero */\r
+ x = a;\r
+ \r
+ /* Assign values to the array */\r
+ for(n = 0; n < 25; n++)\r
+ a[n] = n;\r
+ \r
+ \r
+ /* Now print out all array element values */\r
+ for(n = 0; n < 25; n++ , x++)\r
+ printf("\nElement %d holds %d",n,*x);\r
+ }\r
+ \r
+To read or assign a value to the address held by a pointer you use the\r
+indirection operator `*'. Thus in the above example, to print the value\r
+at the memory address pointed to by variable x I have used `*x'.\r
+\r
+Pointers may be incremented and decremented and have other mathematics\r
+applied to them also. For example in the above program to move variable x\r
+along the array one element at a time we put the statement `x++' in the\r
+for loop. We could move x along two elements by saying `x += 2'. Notice\r
+that this doesn't mean "add 2 bytes to the value of x", but rather it\r
+means "add 2 of the pointer's data type size units to the value of x".\r
+\r
+Pointers are used extensively in dynamic memory allocation. When a\r
+program is running it is often necessary to temporarily allocate a block\r
+of data, say a table, in memory. C provides the function malloc() for\r
+this purpose that follows the general form;\r
+\r
+\r
+ any pointer type = malloc(number_of_bytes);\r
+\r
+malloc() actually returns a void pointer type, which means it can be any\r
+type; integer, character, floating point or whatever. This example\r
+allocates a table in memory for 1000 integers;\r
+\r
+ #include <stdio.h>\r
+ #include <stdlib.h>\r
+ \r
+ main()\r
+ {\r
+ int *x;\r
+ int n;\r
+ \r
+ /* x is a pointer to an integer data type */\r
+ \r
+ /* Create a 1000 element table, sizeof() returns the compiler\r
+ */\r
+ /* specific number of bytes used to store an integer */\r
+ \r
+ x = malloc(1000 * sizeof(int));\r
+ \r
+ \r
+ /* Check to see if the memory allocation succeeded */\r
+ if (x == NULL)\r
+ {\r
+ printf("\nUnable to allocate a 1000 element integer\r
+ table");\r
+ exit(0);\r
+ }\r
+ \r
+ /* Assign values to each table element */\r
+ for(n = 0; n < 1000; n++)\r
+ {\r
+ *x = n;\r
+ x++;\r
+ }\r
+ \r
+ /* Return x to the start of the table */\r
+ x -= 1000;\r
+ \r
+ /* Display the values in the table */\r
+ for(n = 0; n < 1000; n++){\r
+ printf("\nElement %d holds a value of %d",n,*x);\r
+ x++;\r
+ }\r
+ /* Deallocate the block of memory now it's no longer required\r
+ */\r
+ free(x);\r
+ }\r
+ \r
+Pointers are also extensively used with character arrays, called strings.\r
+Since all C program strings are terminated by a zero byte we can count\r
+the letters in a string using a pointer;\r
+\r
+ #include <stdio.h>\r
+ #include <string.h>\r
+ \r
+ main()\r
+ {\r
+ char *p;\r
+ char text[100];\r
+ int len;\r
+ \r
+ /* Initialise variable 'text' with some writing */\r
+ strcpy(text,"This is a string of data");\r
+ \r
+ /* Set variable p to the start of variable text */\r
+ p = text;\r
+ \r
+ /* Initialise variable len to zero */\r
+ len = 0;\r
+ \r
+ /* Count the characters in variable text */\r
+ while(*p)\r
+ {\r
+ len++;\r
+ p++;\r
+ }\r
+ \r
+ /* Display the result */\r
+ printf("\nThe string of data has %d characters in it",len);\r
+ }\r
+ \r
+\r
+The 8088/8086 group of CPUs, as used in the IBM PC, divide memory into\r
+64K segments. To address all 1Mb of memory a 20 bit number is used\r
+comprised of an `offset' to and a 64K `segment'. The IBM PC uses special\r
+registers called "segment registers" to record the segments of addresses.\r
+\r
+This leads the C language on the IBM PC to have three new keywords; near,\r
+far and huge.\r
+\r
+near pointers are 16 bits wide and access only data within the current\r
+segment.\r
+\r
+far pointers are comprised of an offset and a segment address allowing\r
+them to access data any where in memory, but arithmetic with far pointers\r
+is fraught with danger! When a value is added or subtracted from a far\r
+pointer it is only actualy the segment part of the pointer that is\r
+affected, thus leading to the situation where a far pointer being\r
+incremented wraps around on its own offset 64K segment.\r
+\r
+huge pointers are a variation on the far pointer that can be successfuly\r
+incremented and decremented through the entire 1Mb range since the\r
+compiler generates code to amend the offset as applicable.\r
+\r
+It will come as no surprise that code using near pointers is executed\r
+faster than code using far pointers, which in turn is faster than code\r
+using huge pointers.\r
+\r
+to give a literal address to a far pointer IBM PC C compilers provide a\r
+macro MK-FP() that has the prototype;\r
+\r
+\r
+ void far *MK_FP(unsigned segment, unsigned offset);\r
+\r
+For example, to create a far pointer to the start of video memory on a\r
+colour IBM PC system you could use;\r
+\r
+ screen = MK_FP(0xB800,0);\r
+\r
+Two coressponding macros provided are;\r
+\r
+FP_SEG() and FP_OFF()\r
+\r
+Which return the segment and offset respectively of a far pointer. The\r
+following example uses FP_SEG() and FP_OFF() to send segment and offset\r
+addresses to a DOS call to create a new directory path;\r
+\r
+\r
+ #include <dos.h>\r
+ \r
+ int makedir(char *path)\r
+ {\r
+ /* Make sub directory, returning non zero on success */\r
+ \r
+ union REGS inreg,outreg;\r
+ struct SREGS segreg;\r
+ \r
+ inreg.h.ah = 0x39;\r
+ segreg.ds = FP_SEG(path);\r
+ inreg.x.dx = FP_OFF(path);\r
+ intdosx(&inreg,&outreg,&segreg);\r
+ \r
+ return(1 - outreg.x.cflag);\r
+ }\r
+ \r
+\r
+Finally, the CPU's segment registers can be read with the function\r
+`segread()'. This is a function unique to C compilers for the the 8086\r
+family of processors. segread() has the function prototype:\r
+\r
+\r
+ void segread(struct SREGS *segp);\r
+\r
+It returns the current values of the segment registers in the SREGS type\r
+structure pointed to by the pointer `segp'. For example:\r
+\r
+ #include <dos.h>\r
+ \r
+ main()\r
+ {\r
+ struct SREGS sregs;\r
+ \r
+ segread(&sregs);\r
+ printf("\nCode segment is currently at %04X, Data segment is at\r
+ %04X",sregs.cs,sregs.ds);\r
+ printf("\nExtra segment is at %04X, Stack segment is at\r
+ %04X",sregs.es,sregs.ss);\r
+ }\r
+ \r
+ STRUCTURES\r
+\r
+\r
+C provides the means to group together variables under one name providing\r
+a convenient means of keeping related information together and providing\r
+a structured approach to data.\r
+\r
+The general form for a structure definition is;\r
+\r
+\r
+ typedef struct\r
+ {\r
+ variable_type variable_name;\r
+ variable_type variable_name;\r
+ }\r
+ structure_name;\r
+\r
+\r
+When accessing data files, with a fixed record structure, the use of a\r
+structure variable becomes essential. The following example shows a\r
+record structure for a very simple name and address file. It declares a\r
+data structure called `data', and comprised of six fields; `name',\r
+`address', `town', `county' , `post' and `telephone'.\r
+\r
+\r
+ typedef struct\r
+ {\r
+ char name[30];\r
+ char address[30];\r
+ char town[30];\r
+ char county[30];\r
+ char post[12];\r
+ char telephone[15];\r
+ }\r
+ data;\r
+\r
+The structure 'data' may then be used in the program as a variable data\r
+type for declaring variables;\r
+\r
+ data record;\r
+\r
+Thus declares a variable called 'record' to be of type 'data'.\r
+\r
+The individual fields of the structure variable are accessed by the\r
+general form;\r
+\r
+ structure_variable.field_name;\r
+\r
+Thus, the name field of the structure variable record is accessed with;\r
+\r
+ record.name\r
+\r
+There is no limit to the number of fields that may comprise a structure,\r
+nor do the fields have to be of the same types, for example;\r
+\r
+\r
+ typedef struct\r
+ {\r
+ char name[30];\r
+ int age;\r
+ char *notes;\r
+ }\r
+ dp;\r
+\r
+Declares a structure 'dp' that is comprised of a character array field,\r
+an integer field and a character pointer field.\r
+\r
+A structure variable may be passed as a parameter by passing the address\r
+of the variable as the parameter with the & operator thus;\r
+\r
+ func(&my_struct)\r
+\r
+\r
+The following is an example program that makes use of a structure to\r
+provide the basic access to the data in a simple name and address file;\r
+\r
+\r
+/* A VERY simple address book written in ANSI C */\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+#include <io.h>\r
+#include <string.h>\r
+#include <fcntl.h>\r
+#include <sys\stat.h>\r
+\r
+/* num_lines is the number of screen display lines */\r
+#define num_lines 25\r
+\r
+\r
+typedef struct\r
+{\r
+ char name[30];\r
+ char address[30];\r
+ char town[30];\r
+ char county[30];\r
+ char post[12];\r
+ char telephone[15];\r
+}\r
+data;\r
+\r
+data record;\r
+int handle;\r
+\r
+\r
+/* Function prototypes */\r
+\r
+void ADD_REC(void);\r
+void CLS(void);\r
+void DISPDATA(void);\r
+void FATAL(char *);\r
+void GETDATA(void);\r
+void MENU(void);\r
+void OPENDATA(void);\r
+int SEARCH(void);\r
+\r
+void CLS()\r
+{\r
+ int n;\r
+\r
+ for(n = 0; n < num_lines; n++)\r
+ puts("");\r
+}\r
+\r
+void FATAL(char *error)\r
+{\r
+ printf("\nFATAL ERROR: %s",error);\r
+ exit(0);\r
+}\r
+\r
+void OPENDATA()\r
+{\r
+ /* Check for existence of data file and if not create it */\r
+ /* otherwise open it for reading/writing at end of file */\r
+\r
+ handle = open("address.dat",O_RDWR|O_APPEND,S_IWRITE);\r
+\r
+ if (handle == -1)\r
+ {\r
+ handle = open("address.dat",O_RDWR|O_CREAT,S_IWRITE);\r
+ if (handle == -1)\r
+ FATAL("Unable to create data file");\r
+ }\r
+}\r
+\r
+void GETDATA()\r
+{\r
+ /* Get address data from operator */\r
+\r
+ CLS();\r
+\r
+ printf("Name ");\r
+ gets(record.name);\r
+ printf("\nAddress ");\r
+ gets(record.address);\r
+ printf("\nTown ");\r
+ gets(record.town);\r
+ printf("\nCounty ");\r
+ gets(record.county);\r
+ printf("\nPost Code ");\r
+ gets(record.post);\r
+ printf("\nTelephone ");\r
+ gets(record.telephone);\r
+}\r
+\r
+void DISPDATA()\r
+{\r
+ /* Display address data */\r
+ char text[5];\r
+\r
+ CLS();\r
+\r
+ printf("Name %s",record.name);\r
+ printf("\nAddress %s",record.address);\r
+ printf("\nTown %s",record.town);\r
+ printf("\nCounty %s",record.county);\r
+ printf("\nPost Code %s",record.post);\r
+ printf("\nTelephone %s\n\n",record.telephone);\r
+\r
+ puts("Press RETURN to continue");\r
+ gets(text);\r
+}\r
+\r
+void ADD_REC()\r
+{\r
+ /* Insert or append a new record to the data file */\r
+ int result;\r
+\r
+ result = write(handle,&record,sizeof(data));\r
+\r
+ if (result == -1)\r
+ FATAL("Unable to write to data file");\r
+}\r
+\r
+int SEARCH()\r
+{\r
+ char text[100];\r
+ int result;\r
+\r
+ printf("Enter data to search for ");\r
+ gets(text);\r
+ if (*text == 0)\r
+ return(-1);\r
+\r
+ /* Locate start of file */\r
+ lseek(handle,0,SEEK_SET);\r
+\r
+ do\r
+ {\r
+ /* Read record into memory */\r
+ result = read(handle,&record,sizeof(data));\r
+ if (result > 0)\r
+ {\r
+ /* Scan record for matching data */\r
+ if (strstr(record.name,text) != NULL)\r
+ return(1);\r
+ if (strstr(record.address,text) != NULL)\r
+ return(1);\r
+ if (strstr(record.town,text) != NULL)\r
+ return(1);\r
+ if (strstr(record.county,text) != NULL)\r
+ return(1);\r
+ if (strstr(record.post,text) != NULL)\r
+ return(1);\r
+ if (strstr(record.telephone,text) != NULL)\r
+ return(1);\r
+ }\r
+ }\r
+ while(result > 0);\r
+ return(0);\r
+}\r
+\r
+void MENU()\r
+{\r
+ int option;\r
+ char text[10];\r
+\r
+ do\r
+ {\r
+ CLS();\r
+ puts("\n\t\t\tSelect Option");\r
+ puts("\n\n\t\t\t1 Add new record");\r
+ puts("\n\n\t\t\t2 Search for data");\r
+ puts("\n\n\t\t\t3 Exit");\r
+ puts("\n\n\n\n\n");\r
+ gets(text);\r
+ option = atoi(text);\r
+\r
+ switch(option)\r
+ {\r
+ case 1 : GETDATA();\r
+ /* Go to end of file to append new record */\r
+ lseek(handle,0,SEEK_END);\r
+ ADD_REC();\r
+ break;\r
+\r
+ case 2 : if (SEARCH())\r
+ DISPDATA();\r
+ else\r
+ {\r
+ puts("NOT FOUND!");\r
+ puts("Press RETURN to continue");\r
+ gets(text);\r
+ }\r
+ break;\r
+\r
+ case 3 : break;\r
+ }\r
+ }\r
+ while(option != 3);\r
+}\r
+\r
+void main()\r
+{\r
+ CLS();\r
+ OPENDATA();\r
+ MENU();\r
+}\r
+\r
+Bit Fields\r
+\r
+C allows the inclusion of variables with a size of less than eight bits\r
+to be included in structures. These variables are known as bit fields,\r
+and may be any declared size from one bit upwards.\r
+\r
+The general form for declaring a bit field is;\r
+\r
+\r
+ type name : number_of_bits;\r
+\r
+\r
+For example, to declare a set of status flags, each occupying one bit;\r
+\r
+typedef struct\r
+{\r
+ unsigned carry : 1;\r
+ unsigned zero : 1;\r
+ unsigned over : 1;\r
+ unsigned parity : 1;\r
+}\r
+df;\r
+\r
+df flags;\r
+\r
+The variable `flags' then occupies only four bits in memory, and yet is\r
+comprised of four variables that may be accessed like any other structure\r
+field.\r
+\r
+\r
+\r
+Uunions\r
+\r
+Another facility provided by C for efficient use of available memory is\r
+the union structure. A union structure is a collection of variables that\r
+all share the same memory storage address. As such only one of the\r
+variables is ever accessible at a time.\r
+\r
+The general form of a union definition is;\r
+\r
+\r
+ union name\r
+ {\r
+ type variable_name;\r
+ type variable_name;\r
+ .\r
+ .\r
+ .\r
+ type variable_name;\r
+ };\r
+\r
+Thus, to declare a union structure for two integer variables;\r
+\r
+ union data\r
+ {\r
+ int vara;\r
+ int varb;\r
+ };\r
+\r
+and to declare a variable of type 'data';\r
+\r
+ data my_var;\r
+\r
+The variable 'my_var' is then comprised of the two variables 'vara' and\r
+'varb' that are accessed like with any form of structure, eg;\r
+\r
+ my_var.vara = 5;\r
+\r
+Assigns a value of 5 to the variable 'vara' of union 'my_var'.\r
+\r
+\r
+Enumerations\r
+\r
+An enumeration assigns ascending integer values to a list of symbols. An\r
+enumeration declaration takes the general form;\r
+\r
+\r
+ enum name { enumeration list } variable_list;\r
+\r
+Thus to define a symbol list of colours, you can say;\r
+\r
+ enum COLOURS\r
+ {\r
+ BLACK,\r
+ BLUE,\r
+ GREEN,\r
+ CYAN,\r
+ RED,\r
+ MAGENTA,\r
+ BROWN,\r
+ LIGHTGRAY,\r
+ DARKGRAY,\r
+ LIGHTBLUE,\r
+ LIGHTGREEN,\r
+ LIGHTCYAN,\r
+ LIGHTRED,\r
+ LIGHTMAGENTA,\r
+ YELLOW,\r
+ WHITE\r
+ };\r
+\r
+Then, the number zero may be referred to by the symbol BLACK, the number\r
+one by the symbol BLUE, the number two by the symbol GREEN and so on.\r
+\r
+The following program illustrates the use of an enumeration list to\r
+symbolise integers;\r
+\r
+ #include <stdio.h>\r
+ \r
+ enum COLOURS\r
+ {\r
+ BLACK,\r
+ BLUE,\r
+ GREEN,\r
+ CYAN,\r
+ RED,\r
+ MAGENTA,\r
+ BROWN,\r
+ LIGHTGRAY,\r
+ DARKGRAY,\r
+ LIGHTBLUE,\r
+ LIGHTGREEN,\r
+ LIGHTCYAN,\r
+ LIGHTRED,\r
+ LIGHTMAGENTA,\r
+ YELLOW,\r
+ WHITE\r
+ };\r
+ \r
+ \r
+ void main()\r
+ {\r
+ int x;\r
+ \r
+ x = RED;\r
+ \r
+ printf("\nVariable 'x' holds %d",x);\r
+ \r
+ }\r
+ \r
+ FILE I/O\r
+\r
+\r
+C provides buffered file streams for file access. Some C platforms, such\r
+as Unix and DOS provide unbuffered file handles as well.\r
+\r
+\r
+\r
+Buffered streams\r
+\r
+Buffered streams are accessed through a variable of type 'file pointer'.\r
+The data type FILE is defined in the header file stdio.h. Thus to declare\r
+a file pointer;\r
+\r
+ #include <stdio.h>\r
+\r
+ FILE *ptr;\r
+\r
+To open a stream C provides the function fopen(), which accepts two\r
+parameters, the name of the file to be opened, and the access mode for\r
+the file to be opened with. The access mode may be any one of;\r
+\r
+\r
+Mode Description\r
+ \r
+r Open for reading\r
+w Create for writing, destroying any\r
+ existing file\r
+a Open for append, creating a new file\r
+ if it doesn't\r
+ exist\r
+r+ Open an existing file for reading\r
+ and writing\r
+w+ Create for reading and writing,\r
+ destroying any\r
+ existing file\r
+a+ Open for append, creating a new file\r
+ if it doesn't exist.\r
+\r
+\r
+Optionaly either `b' or `t' may be appended for binary or text mode. If\r
+neither is appended, then the file stream will be opened in the mode\r
+described by the global variable _fmode. Data read or written from file\r
+streams opened in text mode undergoes conversion, that is the characters\r
+CR and LF are converted to CR LF pairs on writing, and the CR LF pair is\r
+converted to a single LF on reading. File streams opened in binary mode\r
+do not undergo conversion.\r
+\r
+\r
+If fopen() fails to open the file, it returns a value of NULL (defined in\r
+stdio.h) to the file pointer.\r
+\r
+Thus, the following program will create a new file called "data.txt" and\r
+open it for reading and writing;\r
+\r
+ #include <stdio.h>\r
+ \r
+ void main()\r
+ {\r
+ FILE *fp;\r
+ \r
+ fp = fopen("data.txt","w+");\r
+ \r
+ }\r
+\r
+To close a stream C provides the function fclose(), which accepts the\r
+stream's file pointer as a parameter;\r
+\r
+ fclose(fp);\r
+\r
+If an error occurs in closing the file stream, fclose() returns non zero.\r
+\r
+There are four basic functions for receiving and sending data to and from\r
+streams; fgetc(), fputc(), fgets() and fputs().\r
+\r
+fgetc() simply reads a single character from the specified input stream;\r
+\r
+ char fgetc(FILE *fp);\r
+\r
+Its opposite number is fputc(), which simply writes a single character to\r
+the specified input stream;\r
+\r
+ char fputc(char c, FILE *fp);\r
+\r
+fgets() reads a string from the input stream;\r
+\r
+ char *fgets(char s, int numbytes, FILE *fp);\r
+\r
+It stops reading when either numbytes - 1 bytes have been read, or a\r
+newline character is read in. A null terminating byte is appended to the\r
+read string, s. If an error occurs, fgets() returns NULL.\r
+\r
+\r
+fputs() writes a null terminated string to a stream;\r
+\r
+ int fputs(char *s, FILE *fp);\r
+\r
+Excepting fgets(), which returns a NULL pointer if an error occurs, all\r
+the other functions described above return EOF (defined in stdio.h) if an\r
+error occurs during the operation.\r
+\r
+\r
+The following program creates a copy of the file "data.dat" as "data.old"\r
+and illustrates the use of fopen(), fgetc(), fputc() and fclose();\r
+\r
+\r
+ #include <stdio.h>\r
+ \r
+ int main()\r
+ {\r
+ FILE *in;\r
+ FILE *out;\r
+ \r
+ in = fopen("data.dat","r");\r
+ \r
+ if (in == NULL)\r
+ {\r
+ puts("\nUnable to open file data.dat for reading");\r
+ return(0);\r
+ }\r
+ \r
+ out = fopen("data.old","w+");\r
+ \r
+ if (out == NULL)\r
+ {\r
+ puts("\nUnable to create file data.old");\r
+ return(0);\r
+ }\r
+ \r
+ /* Loop reading and writing one byte at a time until end-of-\r
+ file */\r
+ while(!feof(in))\r
+ fputc(fgetc(in),out);\r
+ \r
+ /* Close the file streams */\r
+ fclose(in);\r
+ fclose(out);\r
+ \r
+ return(0);\r
+ }\r
+\r
+Example program using fputs() to copy text from stream stdin (usually\r
+typed in at the keyboard) to a new file called "data.txt".\r
+\r
+ #include <stdio.h>\r
+ \r
+ int main()\r
+ {\r
+ FILE *fp;\r
+ char text[100];\r
+ \r
+ fp = fopen("data.txt","w+");\r
+ \r
+ do\r
+ {\r
+ gets(text);\r
+ fputs(text,fp);\r
+ }\r
+ while(*text);\r
+ \r
+ fclose(fp);\r
+ }\r
+\r
+\r
+Random access using streams\r
+\r
+Random file access for streams is provided for by the fseek() function\r
+that has the following prototype;\r
+\r
+ int fseek(FILE *fp, long numbytes, int fromwhere);\r
+\r
+fseek() repositions a file pointer associated with a stream previously\r
+opened by a call to fopen(). The file pointer is positioned `numbytes'\r
+from the location `fromwhere', which may be the file beginning, the\r
+current file pointer position, or the end of the file, symbolised by the\r
+constants SEEK_SET, SEEK_CUR and SEEK_END respectively. If a call to\r
+fseek() succeeds, a value of zero is returned.\r
+\r
+\r
+Associated with fseek() is ftell(), which reports the current file\r
+pointer position of a stream, and has the following function prototype;\r
+\r
+\r
+ long int ftell(FILE *fp);\r
+\r
+ftell() returns either the position of the file pointer, measured in\r
+bytes from the start of the file, or -1 upon an error occurring.\r
+\r
+\r
+\r
+Handles\r
+\r
+File handles are opened with the open() function that has the prototype;\r
+\r
+ int open(char *filename,int access[,unsigned mode]);\r
+\r
+If open() is successful, the number of the file handle is returned.\r
+Otherwise open() returns -1.\r
+\r
+The access integer is comprised from bitwise oring together of the\r
+symbolic constants declared in fcntl.h. These vary from compiler to\r
+compiler but may be;\r
+\r
+\r
+ O_APPEND If set, the file pointer will be set to the end of\r
+the\r
+ file prior to each write.\r
+ O_CREAT If the file does not exist it is created.\r
+ O_TRUNC Truncates the existing file to a length of zero\r
+bytes.\r
+ O_EXCL Used with O_CREAT\r
+ O_BINARY Opens the file in binary mode\r
+ O_TEXT Opens file in text mode\r
+\r
+The optional mode parameter is comprised by bitwise oring of the symbolic\r
+constants defined in stat.h. These vary from C compiler to C compiler but\r
+may be;\r
+\r
+ S_IWRITE Permission to write\r
+ S_IREAD Permission to read\r
+\r
+\r
+Once a file handle has been assigned with open(), the file may be\r
+accessed with read() and write().\r
+\r
+Read() has the function prototype;\r
+\r
+ int read(int handle, void *buf, unsigned num_bytes);\r
+\r
+It attempts to read 'num_bytes' and returns the number of bytes actually\r
+read from the file handle 'handle', and stores these bytes in the memory\r
+block pointed to by 'buf'.\r
+\r
+Write() is very similar to read() and has the same function prototype and\r
+return values, but writes 'num_bytes' from the memory block pointed to by\r
+'buf'.\r
+\r
+Files opened with open() are closed using close() that has the function\r
+prototype;\r
+\r
+ int close(int handle);\r
+\r
+close() returns zero on success, and -1 if an error occurs trying to\r
+close the handle.\r
+\r
+Random access is provided by lseek(), which is very similar to fseek(),\r
+except that it accepts an integer file handle as the first parameter\r
+rather than a stream FILE pointer.\r
+\r
+This example uses file handles to read data from stdin (usually the\r
+keyboard) and copy the text to a new file called "data.txt".\r
+\r
+ #include <io.h>\r
+ #include <fcntl.h>\r
+ #include <sys\stat.h>\r
+ \r
+ int main()\r
+ {\r
+ int handle;\r
+ char text[100];\r
+ \r
+ handle = open("data.txt",O_RDWR|O_CREAT|O_TRUNC,S_IWRITE);\r
+ \r
+ do\r
+ {\r
+ gets(text);\r
+ write(handle,&text,strlen(text));\r
+ }\r
+ while(*text);\r
+ \r
+ close(handle);\r
+ }\r
+\r
+\r
+\r
+Advanced File I/O\r
+\r
+The ANSI standard on C defines file IO as by way of file streams, and\r
+defines various functions for file access;\r
+\r
+\r
+fopen() has the prototype;\r
+\r
+ FILE *fopen(const char *name,const char *mode);\r
+\r
+fopen() attempts to open a stream to a file name in a specified mode. If\r
+successful a FILE type pointer is returned to the file stream, if the\r
+call fails NULL is returned. The mode string can be one of the following;\r
+\r
+\r
+Mode Description\r
+ r Open for reading only\r
+ w Create for writing, overwriting any existing file with the same\r
+ name.\r
+ a Open for append (writing at end of file) or create the file if\r
+it\r
+ does not exist.\r
+ r+ Open an existing file for reading and writing.\r
+ w+ Create a new file for reading and writing.\r
+ a+ Open for append with read and write access.\r
+\r
+\r
+fclose() is used to close a file stream previously opened by a call to\r
+fopen(). It has the prototype;\r
+\r
+ int fclose(FILE *fp);\r
+\r
+When a call to fclose() is successful, all buffers to the stream are\r
+flushed and a value of zero is returned. If the call fails fclose()\r
+returns EOF.\r
+\r
+Many host computers, and the IBM PC is no exception, use buffered file\r
+access, that is when writing to a file stream the data is stored in\r
+memory and only written to the stream when it exceeds a predefined number\r
+of bytes. A power failure occurring before the data has been written to\r
+the stream will result in the data never being written, so the function\r
+fflush() can be called to force all pending data to be written. fflush()\r
+has the prototype;\r
+\r
+ int fflush(FILE *fp);\r
+\r
+When a call to fflush() is successful, the buffers connected with the\r
+stream are flushed and a value of zero is returned. On failure fflush()\r
+returns EOF.\r
+\r
+The location of the file pointer connected with a stream can be\r
+determined with the function ftell(). ftell() has the prototype;\r
+\r
+\r
+ long int ftell(FILE *fp);\r
+\r
+and returns the offset of the file pointer in bytes from the start of the\r
+file, or -1L if the call fails.\r
+\r
+Similarly, you can move the file pointer to a new position with fseek().\r
+fseek() has the prototype;\r
+\r
+ int fseek(FILE *fp, long offset, int from_what_place);\r
+\r
+fseek() attempts to move the file pointer, 'fp' 'offset' bytes from the\r
+position 'from_what_place'. 'from_what_place' is predefined as one of;\r
+\r
+ SEEK_SET The file's beginning\r
+ SEEK_CUR The file pointer's current position\r
+ SEEK_END End of file\r
+\r
+The offset may be a positive value to move the file pointer on through\r
+the file, or negative to move backwards.\r
+\r
+To move a file pointer quickly back to the start of a file, and clear any\r
+references to errors that have occurred C provides the function rewind()\r
+that has the prototype;\r
+\r
+ void rewind(FILE *fp);\r
+\r
+rewind(fp) is similar to fseek(fp,0L,SEEK_SET) in that they both set the\r
+file pointer to the start of the file, but whereas fseek() clears the EOF\r
+error marker, rewind() clears all error indicators.\r
+\r
+Errors occurring with file functions can be checked with the function\r
+ferror() that has the prototype;\r
+\r
+ int ferror(FILE *fp);\r
+\r
+ferror() returns a nonzero value if an error has occurred on the\r
+specified stream. After checking ferror() and reporting any errors you\r
+should clear the error indicators, and this can be done by a call to\r
+clearerr() that has the prototype;\r
+\r
+ void clearerr(FILE *fp);\r
+\r
+The condition of reaching end of file (EOF) can be tested for with the\r
+predefined macro feof() that has the prototype;\r
+\r
+ int feof(FILE *fp);\r
+\r
+feof() returns a nonzero value if an end of file error indicator was\r
+detected on the specified file stream, and zero if the end of file has\r
+not yet been reached.\r
+\r
+Reading data from a file stream can be achieved using several functions;\r
+A single character can be read with fgetc() that has the prototype;\r
+\r
+\r
+ int fgetc(FILE *fp);\r
+\r
+fgetc() returns either the character read converted to an integer, or EOF\r
+if an error occurred.\r
+\r
+Reading a string of data is achieved with fgets(). fgets() attempts to\r
+read a string terminated by a newline character and of no more than a\r
+specified number of bytes from the file stream. It has the prototype;\r
+\r
+\r
+ char *fgets(char s, int n, FILE *fp);\r
+\r
+A successful call to fgets() results in a string being stored in `s' that\r
+is either terminated by a newline character, or that is `n' - 1\r
+characters long, which ever came first. The newline character is retained\r
+by fgets(), and a null bytes is appended to the string. If the call fails\r
+a NULL pointer is returned.\r
+\r
+\r
+Strings may be written to a stream using fputs() that has the prototype;\r
+\r
+ int fputs(const char *s,FILE *fp);\r
+\r
+fputs() writes all the characters in the string `s' to the stream `fp'\r
+except the null terminating byte. On success, fputs() returns the last\r
+character written, on failure it returns EOF.\r
+\r
+To write a single character to a stream use fputc() that has the\r
+prototype;\r
+\r
+ int fputc(int c,FILE *fp);\r
+\r
+If successful, fputc() returns the character written, otherwise it\r
+returns EOF.\r
+\r
+To read a large block of data, or a record from a stream you can use\r
+fread() that has the prototype;\r
+\r
+ size_t fread(void *ptr,size_t size, size_t n, FILE *fp);\r
+\r
+fread() attempts to read 'n' items, each of length 'size' from the file\r
+stream 'fp' into the block of memory pointed to by 'ptr'. To check the\r
+success or failure status of fread() use ferror().\r
+\r
+The sister function to fread() is fwrite() that has the prototype;\r
+\r
+ size_t fwrite(const void *ptr,size_t size, size_t n,FILE *fp);\r
+\r
+that writes 'n' items each of length 'size' from the memory area pointed\r
+to by 'ptr' to the specified stream 'fp'.\r
+\r
+Formatted input from a stream is achieved with fscanf() that has the\r
+prototype;\r
+\r
+ int fscanf(FILE *fp, const char *format[,address ...]);\r
+\r
+fscanf() returns the number of fields successfully stored, and EOF on end\r
+of file. This short example shows how fscanf() is quite useful for\r
+reading numbers from a stream, but hopeless when it comes to strings!\r
+\r
+ #include <stdio.h>\r
+ \r
+ void main()\r
+ {\r
+ FILE *fp;\r
+ int a;\r
+ int b;\r
+ int c;\r
+ int d;\r
+ int e;\r
+ char text[100];\r
+ \r
+ fp = fopen("data.txt","w+");\r
+ \r
+ if(!fp)\r
+ {\r
+ perror("Unable to create file");\r
+ exit(0);\r
+ }\r
+ \r
+ fprintf(fp,"1 2 3 4 5 \"A line of numbers\"");\r
+ \r
+ fflush(fp);\r
+ \r
+ if (ferror(fp))\r
+ {\r
+ fputs("Error flushing stream",stderr);\r
+ exit(1);\r
+ }\r
+ \r
+ rewind(fp);\r
+ if (ferror(fp))\r
+ {\r
+ fputs("Error rewind stream",stderr);\r
+ exit(1);\r
+ }\r
+ \r
+ fscanf(fp,"%d %d %d %d %d %s",&a,&b,&c,&d,&e,text);\r
+ if (ferror(fp))\r
+ {\r
+ fputs("Error reading from stream",stderr);\r
+ exit(1);\r
+ }\r
+ \r
+ printf("\nfscanf() returned %d %d %d %d %d %s",a,b,c,d,e,text);\r
+ }\r
+ \r
+As you can see from the example, fprintf() can be used to write formatted\r
+data to a stream.\r
+\r
+If you wish to store the position of a file pointer on a stream, and then\r
+later restore it to the same position you can use the functions fgetpos()\r
+and fsetpos(). fgetpos() reads the current location of the file pointer\r
+and has the prototype;\r
+\r
+ int fgetpos(FILE *fp, fpos_t *pos);\r
+\r
+fsetpos() repositions the file pointer and has the prototype;\r
+\r
+ int fsetpos(FILE *fp, const fpos_t *fpos);\r
+\r
+fpos_t is defined in stdio.h.\r
+\r
+These functions are more convenient than doing an ftell() followed by an\r
+fseek().\r
+\r
+An open stream can have a new file associated with it in place of the\r
+existing file by using the function freopen() that has the prototype;\r
+\r
+ FILE *freopen(const char *name,const char *mode,FILE *fp);\r
+\r
+freopen() closes the existing stream and then attempts to reopens it with\r
+the specified file name. This is useful for redirecting the predefined\r
+streams stdin, stdout and stderr to a file or device.\r
+\r
+For example; if you wish to redirect all output intended to stdout\r
+(usually the host computer's display device) to a printer you might use;\r
+\r
+ freopen("LPT1","w",stdout);\r
+\r
+where LPT1 is the name of the printer device (on a PC host, LPT1 is the\r
+name of the parallel port).\r
+\r
+\r
+Predefined I/O Streams\r
+\r
+There are three predefined I/O streams; stdin, stdout, and stderr. The\r
+streams stdin and stdout default to the keyboard and display\r
+respectively, but can be redirected on some hardware platforms, such as\r
+the PC and under UNIX. The stream stderr defaults to the display and is\r
+not usually redirected by the operator. Thus it can be used for the\r
+display of error messages even when program output has been redirected,\r
+such as with;\r
+\r
+ fputs("Error message",stderr);\r
+\r
+The functions printf() and puts(), output data to the stream stdout, and\r
+can therefore be redirected by the operator of the program. scanf() and\r
+gets() accept input from the stream stdin.\r
+\r
+As an example of file i/o with the PC consider the following short\r
+program that does a hex dump of a specified file to the predefined stream\r
+stdout, which may be redirected to a file using;\r
+\r
+ dump filename.ext > target.ext\r
+\r
+ #include <stdio.h>\r
+ #include <fcntl.h>\r
+ #include <io.h>\r
+ #include <string.h>\r
+ \r
+ main(int argc, char *argv[])\r
+ {\r
+ unsigned counter;\r
+ unsigned char v1[20];\r
+ int f1;\r
+ int x;\r
+ int n;\r
+ \r
+ if (argc != 2)\r
+ {\r
+ fputs("\nERROR: Syntax is dump f1\n",stderr);\r
+ return(1);\r
+ }\r
+ \r
+ f1 = open(argv[1],O_RDONLY);\r
+ \r
+ if (f1 == -1)\r
+ {\r
+ fprintf(stderr,"\nERROR: Unable to open %s\n",argv[1]);\r
+ return(1);\r
+ }\r
+ \r
+ fprintf(stdout,"\nDUMP OF FILE %s\n\n",strupr(argv[1]));\r
+ \r
+ counter = 0;\r
+ \r
+ while(1)\r
+ {\r
+ /* Set buffer to zero bytes */\r
+ memset(v1,0,20);\r
+ \r
+ /* Read buffer from file */\r
+ x = _read(f1,&v1,16);\r
+ \r
+ /* x will be 0 on EOF or -1 on error */\r
+ if (x < 1)\r
+ break;\r
+ \r
+ /* Print file offset to stdout */\r
+ fprintf(stdout,"%06d(%05x) ",counter,counter);\r
+ \r
+ counter += 16;\r
+ \r
+ /* print hex values of buffer to stdout */\r
+ for(n = 0; n < 16; n++)\r
+ fprintf(stdout,"%02x ",v1[n]);\r
+ \r
+ /* Print ascii values of buffer to stdout */\r
+ for(n = 0; n < 16; n++)\r
+ {\r
+ if ((v1[n] > 31) && (v1[n] < 128))\r
+ fprintf(stdout,"%c",v1[n]);\r
+ else\r
+ fputs(".",stdout);\r
+ }\r
+ \r
+ /* Finish the line with a new line */\r
+ fputs("\n",stdout);\r
+ }\r
+ \r
+ /* successful termination */\r
+ return(0);\r
+ }\r
+ \r
+ STRINGS\r
+\r
+The C language has one of the most powerful string handling capabilities\r
+of any general purpose computer language.\r
+\r
+A string is a single dimension array of characters terminated by a zero\r
+byte.\r
+\r
+Strings may be initialised in two ways. Either in the source code where\r
+they may be assigned a constant value, as in;\r
+\r
+ int main()\r
+ {\r
+ char *p = "System 5";\r
+ char name[] = "Test Program" ;\r
+ }\r
+\r
+or at run time by the function strcpy() that has the function prototype;\r
+\r
+ char *strcpy(char *destination, char *source);\r
+\r
+strcpy() copies the string pointed to by source into the location pointed\r
+to by destination as in the following example;\r
+\r
+\r
+ #include<stdio.h>\r
+ \r
+ int main()\r
+ {\r
+ char name[50];\r
+ \r
+ strcpy(name,"Servile Software");\r
+ \r
+ printf("\nName equals %s",name);\r
+ }\r
+\r
+C also allows direct access to each individual byte of the string, so the\r
+following is quite permissible;\r
+\r
+ #include<stdio.h>\r
+ \r
+ int main()\r
+ {\r
+ char name[50];\r
+ \r
+ strcpy(name,"Servile Software");\r
+ \r
+ printf("\nName equals %s",name);\r
+ \r
+ /* Replace first byte with lower case 's' */\r
+ name[0] = 's';\r
+ \r
+ printf("\nName equals %s",name);\r
+ }\r
+ \r
+The ANSI standard on the C programming language defines the following\r
+functions for use with strings;\r
+\r
+char *strcat(char *dest, char *source) Appends string source\r
+to the end of string destination.\r
+\r
+char *strchr(char *s, int c) Returns a pointer to the first\r
+occurence of character 'c' within s.\r
+\r
+int strcmp(char *s1, char *s2) Compares strings s1 and s2\r
+returning < 0 if s1 is less than s2\r
+ == 0 if s1 and s2\r
+are the same\r
+ > 0 if s1 is\r
+greater than s2\r
+\r
+int strcoll(char *s1, char *s2) Compares strings s1 and s2\r
+ according to the collating sequence set by\r
+ setlocale() returning < 0 if s1 is less\r
+than s2\r
+ == 0 if s1 and s2 are the\r
+same\r
+ > 0 if s1 is greater than s2\r
+\r
+char *strcpy(char *dest, char *src) Copies string src into\r
+string dest.\r
+\r
+unsigned strcspn(char *s1, char *s2) Returns the length of string\r
+s1 that consists entirely of characters not in\r
+string s2.\r
+\r
+unsigned strlen(char *s) Returns the length of string s.\r
+\r
+char *strncat(char *dest, char *src, unsigned len) Copies at most\r
+'len' characters from string src into string dest.\r
+\r
+int strncmp(char *s1, char *s2, unsigned len) Compares at most 'len'\r
+characters from\r
+ string s1 with string s2 returning < 0\r
+if s1 is less than s2\r
+ == 0 if s1 and s2 are\r
+the same\r
+ > 0 if s1 is greater\r
+than s2\r
+\r
+char *strncpy(char *dest, char *src, unsigned len) Copies 'len'\r
+characters from string src into string dest, truncating or\r
+ padding with zero bytes as required.\r
+\r
+char *strpbrk(char *s1, char *s2) Returns a pointer to the\r
+first character in string s1 that occurs in\r
+ string s2.\r
+\r
+char *strrchr(char *s, int c) Returns a pointer to the last\r
+occurence of 'c' within string s.\r
+\r
+unsigned strspn(char *s1, char *s2) Returns the length of the\r
+initial segment of string s1 that consists\r
+ entirely of characters in string s2.\r
+\r
+char *strstr(char *s1, char *s2) Returns a pointer to the\r
+first occurence of string s2 within string\r
+ s1, or NULL if string s2 is not found in\r
+string s1.\r
+\r
+char *strtok(char *s1, char *s2) Returns a pointer to the\r
+token found in string s1 that is defined by\r
+ delimiters in string s2. Returns NULLif no\r
+tokens are found.\r
+\r
+The ANSI standard also defines various functions for converting strings\r
+into numbers and numbers into strings.\r
+\r
+Some C compilers include functions to convert strings to upper and lower\r
+case, but these functions are not defined in the ANSI standard. However,\r
+the ANSI standard does define the functions; toupper() and tolower() that\r
+return an\r
+\r
+integer parameter converted to upper and lowercase respectively. By using\r
+these functions we can create our own ANSI compatible versions;\r
+\r
+\r
+ #include<stdio.h>\r
+ \r
+ void strupr(char *source)\r
+ {\r
+ char *p;\r
+ \r
+ p = source;\r
+ while(*p)\r
+ {\r
+ *p = toupper(*p);\r
+ p++;\r
+ }\r
+ }\r
+ \r
+ void strlwr(char *source)\r
+ {\r
+ char *p;\r
+ \r
+ p = source;\r
+ while(*p)\r
+ {\r
+ *p = tolower(*p);\r
+ p++;\r
+ }\r
+ }\r
+\r
+\r
+ int main()\r
+ {\r
+ char name[50];\r
+ \r
+ strcpy(name,"Servile Software");\r
+ \r
+ printf("\nName equals %s",name);\r
+ \r
+ strupr(name);\r
+ \r
+ printf("\nName equals %s",name);\r
+ \r
+ strlwr(name);\r
+ \r
+ printf("\nName equals %s",name);\r
+ }\r
+\r
+C does not impose a maximum length that a string may be, unlike other\r
+computer languages. However, some CPUs impose restrictions on the maximum\r
+size a block of memory can be. For example, the 8088 family of CPUs, as\r
+used by the IBM PC, impose a limit of 64K bytes on a segment of memory.\r
+\r
+An example program to reverse all the characters in a string.\r
+\r
+ #include <stdio.h>\r
+ #include <string.h>\r
+ \r
+ char *strrev(char *s)\r
+ {\r
+ /* Reverses the order of all characters in a string except the\r
+ null */\r
+ /* terminating byte */\r
+ \r
+ char *start;\r
+ char *end;\r
+ char tmp;\r
+ \r
+ /* Set pointer 'end' to last character in string */\r
+ end = s + strlen(s) - 1;\r
+ \r
+ /* Preserve pointer to start of string */\r
+ start = s;\r
+ \r
+ /* Swop characters */\r
+ while(end >= s)\r
+ {\r
+ tmp = *end;\r
+ *end = *s;\r
+ *s = tmp;\r
+ end--;\r
+ s++;\r
+ }\r
+ return(start);\r
+ }\r
+ \r
+ \r
+ main()\r
+ {\r
+ char text[100];\r
+ char *p;\r
+ \r
+ strcpy(text,"This is a string of data");\r
+ \r
+ p = strrev(text);\r
+ \r
+ printf("\n%s",p);\r
+ }\r
+ \r
+\r
+Strtok()\r
+\r
+The function strtok() is a very powerful standard C feature for\r
+extracting substrings from within a single string. It is used where the\r
+substrings are separated by known delimiters, such as commas in the\r
+following example;\r
+\r
+ #include <stdio.h>\r
+ #include <string.h>\r
+ \r
+ main()\r
+ {\r
+ char data[50];\r
+ char *p;\r
+ \r
+ strcpy(data,"RED,ORANGE,YELLOW,GREEN,BLUE,INDIGO,VIOLET");\r
+ \r
+ p = strtok(data,",");\r
+ while(p)\r
+ {\r
+ puts(p);\r
+ p = strtok(NULL,",");\r
+ };\r
+ }\r
+ \r
+Or this program can be written with a for() loop thus;\r
+\r
+ #include <stdio.h>\r
+ #include <string.h>\r
+ \r
+ main()\r
+ {\r
+ char data[50];\r
+ char *p;\r
+ \r
+ strcpy(data,"RED,ORANGE,YELLOW,GREEN,BLUE,INDIGO,VIOLET");\r
+ \r
+ for(strtok(data,","); p; p = strtok(NULL,","))\r
+ {\r
+ puts(p);\r
+ };\r
+ }\r
+ \r
+They both compile to the same code but follow different programming\r
+styles.\r
+\r
+Initially, you call strtok() with the name of the string variable to be\r
+parsed, and a second string that contains the known delimiters. Strtok()\r
+then returns a pointer to the start of the first substring and replaces\r
+the first token with a zero delimiter. Subsequent calls to strtok() can\r
+be made in a loop passing NULL as the string to be parsed, and strtok()\r
+will return the subsequent substrings.\r
+\r
+\r
+Since strtok() can accept many delimiter characters in the second\r
+parameter string we can use it as the basis of a simple word counting\r
+program;\r
+\r
+ #include <stdio.h>\r
+ #include <stdlib.h>\r
+ #include <string.h>\r
+ \r
+ void main(int argc, char *argv[])\r
+ {\r
+ FILE *fp;\r
+ char buffer[256];\r
+ char *p;\r
+ long count;\r
+ \r
+ if (argc != 2)\r
+ {\r
+ fputs("\nERROR: Usage is wordcnt <file>\n",stderr);\r
+ exit(0);\r
+ }\r
+ \r
+ /* Open file for reading */\r
+ fp = fopen(argv[1],"r");\r
+ \r
+ /* Check the open was okay */\r
+ if (!fp)\r
+ {\r
+ fputs("\nERROR: Cannot open source file\n",stderr);\r
+ exit(0);\r
+ }\r
+ \r
+ /* Initialise word count */\r
+ count = 0;\r
+ \r
+ do\r
+ {\r
+ /* Read a line of data from the file */\r
+ fgets(buffer,255,fp);\r
+ \r
+ /* check for an error in the read or EOF */\r
+ if (ferror(fp) || feof(fp))\r
+ continue;\r
+ \r
+ /* count words in received line */\r
+ /* Words are defined as separated by the characters */\r
+ /* \t(tab) \n(newline) , ; : . ! ? ( ) - and [space] */\r
+ p = strtok(buffer,"\t\n,;:.!?()- ");\r
+ while(p)\r
+ {\r
+ count++;\r
+ p = strtok(NULL,"\t\n,;:.!?()- ");\r
+ }\r
+ }\r
+ while(!ferror(fp) && !feof(fp));\r
+ \r
+ /* Finished reading. Was it due to an error? */\r
+ if (ferror(fp))\r
+ {\r
+ fputs("\nERROR: Reading source file\n",stderr);\r
+ fclose(fp);\r
+ exit(0);\r
+ }\r
+ \r
+ /* Reading finished due to EOF, quite valid so print count */\r
+ printf("\nFile %s contains %ld words\n",argv[1],count);\r
+ fclose(fp);\r
+ }\r
+ \r
+\r
+\r
+\r
+Converting Numbers To And From Strings\r
+\r
+All C compilers provide a facility for converting numbers to strings.\r
+This being sprintf(). However, as happens sprintf() is a multi-purpose\r
+function that is therefore large and slow. The following function ITOS()\r
+accepts two parameters, the first being a signed integer and the second\r
+being a pointer to a character string. It then copies the integer into\r
+the memory pointed to by the character pointer. As with sprintf() ITOS()\r
+does not check that the target string is long enough to accept the result\r
+of the conversion. You should then ensure that the target string is long\r
+enough.\r
+\r
+Example function for copying a signed integer into a string;\r
+\r
+ void ITOS(long x, char *ptr)\r
+ {\r
+ /* Convert a signed decimal integer to a string */\r
+ \r
+ long pt[9] = { 100000000, 10000000, 1000000, 100000, 10000,\r
+ 1000, 100, 10, 1 };\r
+ int n;\r
+ \r
+ /* Check sign */\r
+ if (x < 0)\r
+ {\r
+ *ptr++ = '-';\r
+ /* Convert x to absolute */\r
+ x = 0 - x;\r
+ }\r
+ \r
+ for(n = 0; n < 9; n++)\r
+ {\r
+ if (x > pt[n])\r
+ {\r
+ *ptr++ = '0' + x / pt[n];\r
+ x %= pt[n];\r
+ }\r
+ }\r
+ return;\r
+ }\r
+ \r
+To convert a string to a floating point number, C provides two functions;\r
+atof() and strtod(). atof() has the prototype;\r
+\r
+ double atof(const char *s);\r
+\r
+strtod has the prototype;\r
+\r
+ double strtod(const char *s,char **endptr);\r
+\r
+Both functions scan the string and convert it as far as they can, until\r
+they come across a character they don't understand. The difference\r
+between the two functions is that if strtod() is passed a character\r
+pointer for parameter `endptr', it sets that pointer to the first\r
+character in the string that terminated the conversion. Because of its\r
+better error reporting, by way of endptr, strtod() is often preferred to\r
+atof().\r
+\r
+To convert a string to an integer use atoi() that has the prototype;\r
+\r
+\r
+ int atoi(const char *s);\r
+\r
+atoi() does not check for an overflow, and the results are undefined!\r
+\r
+atol() is a similar function but returns a long. Alternatively, you can\r
+use strtol() and stroul() instead that have better error checking.\r
+\r
+ \r
+ TEXT HANDLING\r
+\r
+Human languages write information down as `text'. This is comprised of\r
+words, figures and punctuation. The words being made up of upper case and\r
+lower case letters. Processing text with a computer is a commonly\r
+required task, and yet quite a difficult one.\r
+\r
+The ANSI C definitions include string processing functions that are by\r
+their nature sensitive to case. That is the letter `A' is seen as\r
+distinct from the letter `a'. This is the first problem that must be\r
+overcome by the programmer. Fortunately both Borland's Turbo C compilers\r
+and Microsoft's C compilers include case insensitive forms of the string\r
+functions.\r
+\r
+stricmp() for example is the case insensitive form of strcmp(), and\r
+strnicmp() is the case insensitive form of strncmp().\r
+\r
+If you are concerned about writing portable code, then you must restrict\r
+yourself to the ANSI C functions, and write your own case insensitive\r
+functions using the tools provided.\r
+\r
+Here is a simple implementation of a case insensitive version of\r
+strstr(). The function simply makes a copy of the parameter strings,\r
+converts those copies both to upper case and then does a standard\r
+strstr() on the copies. The offset of the target string within the\r
+source string will be the same for the copy as the original, and so it\r
+can be returned relative to the parameter string.\r
+\r
+\r
+ char *stristr(char *s1, char *s2)\r
+ {\r
+ char c1[1000];\r
+ char c2[1000];\r
+ char *p;\r
+ \r
+ strcpy(c1,s1);\r
+ strcpy(c2,s2);\r
+ \r
+ strupr(c1);\r
+ strupr(c2);\r
+ \r
+ p = strstr(c1,c2);\r
+ if (p)\r
+ return s1 + (p - c1);\r
+ return NULL;\r
+ }\r
+ \r
+This function scans a string, s1 looking for the word held in s2. The\r
+word must be a complete word, not simply a character pattern, for the\r
+function to return true. It makes use of the stristr() function described\r
+previously.\r
+\r
+ int word_in(char *s1,char *s2)\r
+ {\r
+ /* return non-zero if s2 occurs as a word in s1 */\r
+ char *p;\r
+ char *q;\r
+ int ok;\r
+ \r
+ ok = 0;\r
+ q = s1;\r
+ \r
+ do\r
+ {\r
+ /* Locate character occurence s2 in s1 */\r
+ p = stristr(q,s2);\r
+ if (p)\r
+ {\r
+ /* Found */\r
+ ok = 1;\r
+ \r
+ if (p > s1)\r
+ {\r
+ /* Check previous character */\r
+ if (*(p - 1) >= 'A' && *(p - 1) <= 'z')\r
+ ok = 0;\r
+ }\r
+ \r
+ /* Move p to end of character set */\r
+ p += strlen(s2);\r
+ if (*p)\r
+ {\r
+ /* Check character following */\r
+ if (*p >= 'A' && *p <= 'z')\r
+ ok = 0;\r
+ }\r
+ }\r
+ q = p;\r
+ }\r
+ while(p && !ok);\r
+ return ok;\r
+ }\r
+\r
+\r
+Some more useful functions for dealing with text are truncstr() that\r
+truncates a string;\r
+\r
+ void truncstr(char *p,int num)\r
+ {\r
+ /* Truncate string by losing last num characters */\r
+ if (num < strlen(p))\r
+ p[strlen(p) - num] = 0;\r
+ }\r
+ \r
+trim() that removes trailing spaces from the end of a string;\r
+\r
+ void trim(char *text)\r
+ {\r
+ /* remove trailing spaces */\r
+ char *p;\r
+ \r
+ p = &text[strlen(text) - 1];\r
+ while(*p == 32 && p >= text)\r
+ *p-- = 0;\r
+ }\r
+ \r
+strlench() that changes the length of a string by adding or deleting\r
+characters;\r
+\r
+ void strlench(char *p,int num)\r
+ {\r
+ /* Change length of string by adding or deleting characters */\r
+ \r
+ if (num > 0)\r
+ memmove(p + num,p,strlen(p) + 1);\r
+ else\r
+ {\r
+ num = 0 - num;\r
+ memmove(p,p + num,strlen(p) + 1);\r
+ }\r
+ }\r
+ \r
+strins() that inserts a string into another string;\r
+\r
+ void strins(char *p, char *q)\r
+ {\r
+ /* Insert string q into p */\r
+ strlench(p,strlen(q));\r
+ strncpy(p,q,strlen(q));\r
+ }\r
+ \r
+strchg() that replaces all occurences of one sub-string with another\r
+within a target string;\r
+\r
+ void strchg(char *data, char *s1, char *s2)\r
+ {\r
+ /* Replace all occurences of s1 with s2 */\r
+ char *p;\r
+ char changed;\r
+ \r
+ do\r
+ {\r
+ changed = 0;\r
+ p = strstr(data,s1);\r
+ if (p)\r
+ {\r
+ /* Delete original string */\r
+ strlench(p,0 - strlen(s1));\r
+ \r
+ /* Insert replacement string */\r
+ strins(p,s2);\r
+ changed = 1;\r
+ }\r
+ }\r
+ while(changed);\r
+ }\r
+ \r
+ TIME\r
+\r
+C provides a function, time(), which reads the computer's system clock to\r
+return the system time as a number of seconds since midnight on January\r
+the first, 1970. However, this value can be converted to a useful string\r
+by the function ctime() as illustrated in the following example;\r
+\r
+ #include <stdio.h>\r
+ #include <time.h>\r
+ \r
+ int main()\r
+ {\r
+ /* Structure to hold time, as defined in time.h */\r
+ time_t t;\r
+ \r
+ /* Get system date and time from computer */\r
+ t = time(NULL);\r
+ printf("Today's date and time: %s\n",ctime(&t));\r
+ }\r
+ \r
+The string returned by ctime() is comprised of seven fields;\r
+\r
+ Day of the week,\r
+ Month of the year,\r
+ Date of the day of the month,\r
+ hour,\r
+ minutes,\r
+ seconds,\r
+ century of the year\r
+\r
+terminated by a newline character and null terminating byte. Since the\r
+fields always occupy the same width, slicing operations can be carried\r
+out on the string with ease. The following program defines a structure\r
+`time' and a function gettime() that extracts the hours, minutes and\r
+seconds of the current time and places them in the structure;\r
+\r
+\r
+ #include <stdio.h>\r
+ #include <time.h>\r
+ \r
+ struct time\r
+ {\r
+ int ti_min; /* Minutes */\r
+ int ti_hour; /* Hours */\r
+ int ti_sec; /* Seconds */\r
+ };\r
+ \r
+ void gettime(struct time *now)\r
+ {\r
+ time_t t;\r
+ char temp[26];\r
+ char *ts;\r
+ \r
+ /* Get system date and time from computer */\r
+ t = time(NULL);\r
+ \r
+ /* Translate dat and time into a string */\r
+ strcpy(temp,ctime(&t));\r
+ \r
+ /* Copy out just time part of string */\r
+ temp[19] = 0;\r
+ ts = &temp[11];\r
+ \r
+ /* Scan time string and copy into time structure */\r
+ sscanf(ts,"%2d:%2d:%2d",&now->ti_hour,&now->ti_min,&now-\r
+ >ti_sec);\r
+ }\r
+ \r
+ int main()\r
+ {\r
+ struct time now;\r
+ \r
+ gettime(&now);\r
+ \r
+ printf("\nThe time is\r
+ %02d:%02d:%02d",now.ti_hour,now.ti_min,now.ti_sec);\r
+ \r
+ }\r
+\r
+The ANSI standard on C does actually provide a function ready made to\r
+convert the value returned by time() into a structure;\r
+\r
+ #include <stdio.h>\r
+ #include <time.h>\r
+ \r
+ int main()\r
+ {\r
+ time_t t;\r
+ struct tm *tb;\r
+ \r
+ /* Get time into t */\r
+ t = time(NULL);\r
+ \r
+ /* Convert time value t into structure pointed to by tb */\r
+ tb = localtime(&t);\r
+ \r
+ printf("\nTime is %02d:%02d:%02d",tb->tm_hour,tb->tm_min,tb-\r
+ >tm_sec);\r
+ }\r
+ \r
+The structure 'tm' is defined in time.h as;\r
+\r
+ struct tm\r
+ {\r
+ int tm_sec;\r
+ int tm_min;\r
+ int tm_hour;\r
+ int tm_mday;\r
+ int tm_mon;\r
+ int tm_year;\r
+ int tm_wday;\r
+ int tm_yday;\r
+ int tm_isdst;\r
+ };\r
+\r
+\r
+Timers\r
+Often a program must determine the date and time from the host computer's\r
+non-volatile RAM. There are several time functions provided by the ANSI\r
+standard on C that allow a program to retrieve, from the host computer,\r
+the current date and time;\r
+\r
+time() returns the number of seconds that have elapsed since midnight on\r
+January the 1st 1970. It has the prototype;\r
+\r
+ time_t time(time_t *timer);\r
+\r
+time() fills in the time_t variable sent as a parameter and returns the\r
+same value. You can call time() with a NULL parameter and just collect\r
+the return value thus;\r
+\r
+ #include <time.h>\r
+ \r
+ void main()\r
+ {\r
+ time_t now;\r
+ \r
+ now = time(NULL);\r
+ }\r
+ \r
+asctime() converts a time block to a twenty six character string of the\r
+format;\r
+\r
+ Wed Oct 14 10:23:45 1992\n\0\r
+\r
+asctime() has the prototype;\r
+\r
+ char *asctime(const struct tm *tblock);\r
+\r
+ctime() converts a time value (as returned by time()) into a twenty six\r
+chracter string of the same format as asctime(). For example;\r
+\r
+ #include <stdio.h>\r
+ #include <time.h>\r
+ \r
+ void main()\r
+ {\r
+ time_t now;\r
+ char date[30];\r
+ \r
+ now = time(NULL);\r
+ strcpy(date,ctime(&now));\r
+ }\r
+ \r
+difftime() returns the difference, in seconds, between two values (as\r
+returned by time()). This can be useful for testing the elapsed time\r
+between two events, the time a function takes to execute, and for\r
+creating consistent delays that are irrelevant of the host computer.\r
+\r
+An example delay program;\r
+\r
+ #include <stdio.h>\r
+ #include <time.h>\r
+ \r
+ \r
+ void DELAY(int period)\r
+ {\r
+ time_t start;\r
+ \r
+ start = time(NULL);\r
+ while(time(NULL) < start + period)\r
+ ;\r
+ }\r
+ \r
+ void main()\r
+ {\r
+ printf("\nStarting delay now....(please wait 5 seconds)");\r
+ \r
+ DELAY(5);\r
+ \r
+ puts("\nOkay, I've finished!");\r
+ }\r
+\r
+gmtime() converts a local time value (as returned by time()) to the GMT\r
+time and stores it in a time block. This function depends upon the global\r
+variable timezone being set.\r
+\r
+\r
+The time block is a predefined structure (declared in time.h) as follows;\r
+\r
+ struct tm\r
+ {\r
+ int tm_sec;\r
+ int tm_min;\r
+ int tm_hour;\r
+ int tm_mday;\r
+ int tm_mon;\r
+ int tm_year;\r
+ int tm_wday;\r
+ int tm_yday;\r
+ int tm_isdst;\r
+ };\r
+\r
+tm_mday records the day of the month, ranging from 1 to 31; tm_wday is\r
+the day of the week with Sunday being represented by 0; the year is\r
+recorded less 1900; tm_isdst is a flag to show whether daylight saving\r
+time is in effect. The actual names of the structure and its elements may\r
+vary from compiler to compiler, but the structure should be the same in\r
+essence.\r
+\r
+mktime() converts a time block to a calendar format. It follows the\r
+prototype;\r
+\r
+ time_t mktime(struct tm *t);\r
+\r
+The following example allows entry of a date, and uses mktime() to\r
+calculate the day of the week appropriate to that date. Only dates from\r
+the first of January 1970 are recognisable by the time functions.\r
+\r
+ #include <stdio.h>\r
+ #include <time.h>\r
+ #include <string.h>\r
+ \r
+ void main()\r
+ {\r
+ struct tm tsruct;\r
+ int okay;\r
+ char data[100];\r
+ char *p;\r
+ char *wday[] = {"Sunday", "Monday", "Tuesday", "Wednesday",\r
+ "Thursday", "Friday", "Saturday" ,\r
+ "prior to 1970, thus not known" };\r
+ do\r
+ {\r
+ okay = 0;\r
+ printf("\nEnter a date as dd/mm/yy ");\r
+ p = fgets(data,8,stdin);\r
+ p = strtok(data,"/");\r
+ \r
+ if (p != NULL)\r
+ tsruct.tm_mday = atoi(p);\r
+ else\r
+ continue;\r
+ \r
+ p = strtok(NULL,"/");\r
+ if (p != NULL)\r
+ tsruct.tm_mon = atoi(p);\r
+ else\r
+ continue;\r
+ \r
+ p = strtok(NULL,"/");\r
+ \r
+ if (p != NULL)\r
+ tsruct.tm_year = atoi(p);\r
+ else\r
+ continue;\r
+ okay = 1;\r
+ }\r
+ while(!okay);\r
+ \r
+ tsruct.tm_hour = 0;\r
+ tsruct.tm_min = 0;\r
+ tsruct.tm_sec = 1;\r
+ tsruct.tm_isdst = -1;\r
+ \r
+ /* Now get day of the week */\r
+ if (mktime(&tsruct) == -1)\r
+ tsruct.tm_wday = 7;\r
+ \r
+ printf("That was %s\n",wday[tsruct.tm_wday]);\r
+ }\r
+ \r
+mktime() also makes the neccessary adjustments for values out of range,\r
+this can be utilised for discovering what the date will be in n number of\r
+days time thus;\r
+\r
+\r
+ #include <stdio.h>\r
+ #include <time.h>\r
+ #include <string.h>\r
+ \r
+ void main()\r
+ {\r
+ struct tm *tsruct;\r
+ time_t today;\r
+ \r
+ today = time(NULL);\r
+ tsruct = localtime(&today);\r
+ \r
+ tsruct->tm_mday += 10;\r
+ mktime(tsruct);\r
+ \r
+ printf("In ten days it will be %02d/%02d/%2d\n", tsruct-\r
+ >tm_mday,tsruct->tm_mon + 1,tsruct->tm_year);\r
+ \r
+ }\r
+ \r
+\r
+This program uses Julian Dates to decide any day of the week since the\r
+1st of October 1582 when the Gregorian calendar was introduced.\r
+\r
+ char *WDAY(int day, int month, int year)\r
+ {\r
+ /* Returns a pointer to a string representing the day of the\r
+ week */\r
+ \r
+ static char *cday[] = { "Saturday","Sunday","Monday","Tuesday",\r
+ "Wednesday","Thursday","Friday" };\r
+ double yy;\r
+ double yt;\r
+ double j;\r
+ int y1;\r
+ int y4;\r
+ int x;\r
+ \r
+ yy = year / 100;\r
+ y1 = (int)(yy);\r
+ yt = year / 400;\r
+ y4 = (int)(yt);\r
+ x = 0;\r
+ \r
+ if (month < 3)\r
+ {\r
+ year--;\r
+ x = 12;\r
+ }\r
+ \r
+ j = day + (int)(365.25*year);\r
+ \r
+ j += (int)(30.6001 * (month + 1 + x)) - y1 + y4;\r
+ \r
+ if (yy == y1 && yt != y4 && month < 3)\r
+ j++;\r
+ \r
+ j = 1 + j - 7 * (int)(j/7);\r
+ \r
+ if (j > 6)\r
+ j -= 7;\r
+ \r
+ return(cday[j]);\r
+ }\r
+ \r
+ \r
+With time() and difftime() we can create a timer for testing the\r
+execution times of functions thus;\r
+\r
+ #include <stdio.h>\r
+ #include <time.h>\r
+ \r
+ main()\r
+ {\r
+ time_t now;\r
+ time_t then;\r
+ double elapsed;\r
+ \r
+ int n;\r
+ \r
+ now = time(NULL);\r
+ \r
+ /* This loop is adjustable for multiple passes */\r
+ for(n = 0; n < 5000; n++)\r
+ /* Call the function to test */\r
+ func();\r
+ \r
+ then = time(NULL);\r
+ \r
+ elapsed = difftime(then,now);\r
+ printf("\nElapsed seconds==%lf\n",elapsed);\r
+ }\r
+ \r
+By way of time() and ctime() the current system date and time can be\r
+retrieved from the host computer thus;\r
+\r
+ #include <stdio.h>\r
+ #include <time.h>\r
+ \r
+ main()\r
+ {\r
+ time_t now;\r
+ char *date;\r
+ int n;\r
+ \r
+ /* Get system time */\r
+ now = time(NULL);\r
+ \r
+ /* Convert system time to a string */\r
+ date = ctime(&now);\r
+ \r
+ /*Display system time */\r
+ printf("\nIt is %s",date);\r
+ }\r
+ \r
+time_t is a type defined in time.h as the type of variable returned by\r
+time(). This type may vary from compiler to compiler, and therefore is\r
+represented by the type "time_t".\r
+ \r
+ HEADER FILES\r
+\r
+Function prototypes for library functions supplied with the C compiler,\r
+and standard macros are declared in header files.\r
+\r
+The ANSI standard on the C programming language lists the following\r
+header files;\r
+\r
+Header file Description\r
+ \r
+assert.h Defines the assert debugging macro\r
+ctype.h Character classification and\r
+ conversion macros\r
+errno.h Constant mnemonics for error codes\r
+float.h Defines implementation specific\r
+ macros for dealing with floating\r
+ point mathematics\r
+limits.h Defines implementation specific\r
+ limits on type values\r
+locale.h Country specific parameters\r
+math.h Prototypes for mathematics functions\r
+setjmp.h Defines typedef and functions for\r
+ setjmp/longjmp\r
+signal.h Constants and declarations for use by\r
+ signal() and raise()\r
+stdarg.h Macros for dealing with argument\r
+ lists\r
+stddef.h Common data types and macros\r
+stdio.h Types and macros required for\r
+ standard I/O\r
+stdlib.h Prototypes of commonly used functions\r
+ and miscellany\r
+string.h String manipulation function\r
+ prototypes\r
+time.h Structures for time conversion\r
+ routines\r
+ \r
+ DEBUGGING\r
+\r
+The ANSI standard on C includes a macro function for debugging called\r
+assert(). This expands to an if() statement, which if it returns true\r
+terminates the program and outputs to the standard error stream a message\r
+comprised of:\r
+\r
+\r
+ Assertion failed: <test>, file <module>, line <line number>\r
+ Abnormal program termination\r
+For example, the following program accidentally assigns a zero value to a\r
+pointer!\r
+\r
+ #include <stdio.h>\r
+ #include <assert.h>\r
+ \r
+ main()\r
+ {\r
+ /* Demonstration of assert */\r
+ \r
+ int *ptr;\r
+ int x;\r
+ \r
+ x = 0;\r
+ \r
+ /* Whoops! error in this line! */\r
+ ptr = x;\r
+ \r
+ assert(ptr != NULL);\r
+ }\r
+ \r
+When run, this program terminates with the message:\r
+\r
+ Assertion failed: ptr != 0, file TEST.C, line 16\r
+ Abnormal program termination\r
+\r
+When a program is running okay, the assert() functions can be removed\r
+from the compiled program by simply adding the line;\r
+\r
+ #define NDEBUG\r
+\r
+before the #include <assert.h> line. Effectively the assert functions are\r
+commented out in the preprocessed source before compilation, this means\r
+that the assert expressions are not evaluated, and thus cannot cause any\r
+side effects.\r
+ \r
+ FLOAT ERRORS\r
+\r
+Floating point numbers are decimal fractions, decimal fractions do not\r
+accurately equate to normal fractions as not every number will divide\r
+precisely by ten. This creates the potential for rounding errors in\r
+calculations that use floating point numbers. The following program\r
+illustrates one such example of rounding error problems;\r
+\r
+\r
+ #include <stdio.h>\r
+ \r
+ void main()\r
+ {\r
+ float number;\r
+ \r
+ for(number = 1; number > 0.4; number -= 0.01)\r
+ printf("\n%f",number);\r
+ }\r
+ \r
+At about 0.47 (depending upon the host computer and compiler) the program\r
+starts to store an inaccurate value for 'number'.\r
+\r
+This problem can be minimised by using longer floating point numbers,\r
+doubles or long doubles that have larger storage space allocated to them.\r
+For really accurate work though, you should use integers and only convert\r
+to a floating point number for display. You also should notice that most\r
+C compilers default floating point numbers to `doubles' and when using\r
+`float' types have to convert the double down to a float!\r
+\r
+\r
+ \r
+ ERROR HANDLING\r
+\r
+When a system error occurs within a program, for example when an attempt\r
+to open a file fails, it is helpful to the program's user to display a\r
+message reporting the failure. Equally it is useful to the program's\r
+developer to know why the error occurred, or at least as much about it as\r
+possible. To this end the ANSI standard on C describes a function,\r
+perror(), which has the prototype;\r
+\r
+\r
+ void perror(const char *s);\r
+\r
+and is used to display an error message. The program's own prefixed error\r
+message is passed to perror() as the string parameter. This error message\r
+is displayed by perror() followed by the host's system error separated by\r
+a colon. The following example illustrates a use for perror();\r
+\r
+\r
+ #include <stdio.h>\r
+ \r
+ void main()\r
+ {\r
+ FILE *fp;\r
+ char fname[] = "none.xyz";\r
+ \r
+ fp = fopen(fname,"r");\r
+ \r
+ if(!fp)\r
+ perror(fname);\r
+ return;\r
+ }\r
+ \r
+If the fopen() operation fails, a message similar to;\r
+\r
+ none.xyz: No such file or directory\r
+\r
+is displayed.\r
+\r
+You should note, perror() sends its output to the predefined stream\r
+`stderr', which is usually the host computer's display unit.\r
+\r
+\r
+perror() finds its message from the host computer via the global variable\r
+'errno' that is set by most, but not all system functions.\r
+\r
+Unpleasant errors might justify the use of abort(). abort() is a function\r
+that terminates the running program with a message;\r
+\r
+ "Abnormal program termination"\r
+\r
+and returns an exit code of 3 to the parent process or operating system.\r
+\r
+\r
+\r
+Critical Error Handling With The IBM PC AND DOS\r
+\r
+The IBM PC DOS operating system provides a user amendable critical error\r
+handling function. This function is usually discovered by attempting to\r
+write to a disk drive that does not have a disk in it, in which case the\r
+familiar;\r
+\r
+ Not ready error writing drive A\r
+ Abort Retry Ignore?\r
+\r
+Message is displayed on the screen. Fine when it occurs from within a DOS\r
+program, not so fine from within your own program!\r
+\r
+The following example program shows how to redirect the DOS critical\r
+error interrupt to your own function;\r
+\r
+\r
+ /* DOS critical error handler test */\r
+ \r
+ #include <stdio.h>\r
+ #include <dos.h>\r
+ \r
+ void interrupt new_int();\r
+ void interrupt (*old_int)();\r
+ \r
+ char status;\r
+ \r
+ main()\r
+ {\r
+ FILE *fp;\r
+ \r
+ old_int = getvect(0x24);\r
+ \r
+ /* Set critical error handler to my function */\r
+ setvect(0x24,new_int);\r
+ \r
+ /* Generate an error by not having a disc in drive A */\r
+ fp = fopen("a:\\data.txt","w+");\r
+ \r
+ /* Display error status returned */\r
+ printf("\nStatus == %d",status);\r
+ \r
+ }\r
+ \r
+ void interrupt new_int()\r
+ {\r
+ /* set global error code */\r
+ status = _DI;\r
+ \r
+ /* ignore error and return */\r
+ _AL = 0;\r
+ }\r
+ \r
+When the DOS critical error interrupt is called, a status message is\r
+passed in the low byte of the DI register. This message is one of;\r
+\r
+Code Meaning\r
+ \r
+00 Write-protect error\r
+01 Unknown unit\r
+02 Drive not ready\r
+03 Unknown command\r
+04 Data error, bad CRC\r
+05 Bad request structure\r
+ length\r
+06 Seek error\r
+07 Unknown media type\r
+08 Sector not found\r
+09 Printer out of paper\r
+0A Write error\r
+0B Read error\r
+0C General failure\r
+\r
+Your critical error interrupt handler can transfer this status message\r
+into a global variable, and then set the result message held in register\r
+AL to one of;\r
+\r
+\r
+Code Action\r
+ \r
+00 Ignore error\r
+01 Retry\r
+02 Terminate program\r
+03 Fail (Available with\r
+ DOS 3.3 and above)\r
+\r
+\r
+If you choose to set AL to 02, terminate program, you should ensure ALL\r
+files are closed first since DOS will terminate the program abruptly,\r
+leaving files open and memory allocated, not a pretty state to be in!\r
+\r
+\r
+The example program shown returns an ignore status from the critical\r
+error interrupt, and leaves the checking of any errors to the program\r
+itself. So, in this example after the call to fopen() we could check the\r
+return value in fp, and if it reveals an error (NULL in this case) we\r
+could then check the global variable status and act accordingly, perhaps\r
+displaying a polite message to the user to put a disk in the floppy drive\r
+and ensure that the door is closed.\r
+\r
+The following is a practical function for checking whether a specified\r
+disc drive can be accessed. It should be used with the earlier critical\r
+error handler and global variable `status'.\r
+\r
+ int DISCOK(int drive)\r
+ {\r
+ /* Checks for whether a disc can be read */\r
+ /* Returns false (zero) on error */\r
+ /* Thus if(!DISCOK(drive)) */\r
+ /* error(); */\r
+ \r
+ unsigned char buffer[25];\r
+ \r
+ /* Assume okay */\r
+ status = 0;\r
+ \r
+ /* If already logged to disc, return okay */\r
+ if ('A' + drive == diry[0])\r
+ return(1);\r
+ \r
+ /* Attempt to read disc */\r
+ memset(buffer,0,20);\r
+ sprintf(buffer,"%c:$$$.$$$",'A'+drive);\r
+ \r
+ _open(buffer,O_RDONLY);\r
+ \r
+ /* Check critical error handler status */\r
+ if (status == 0)\r
+ return(1);\r
+ \r
+ /* Disc cannot be read */\r
+ return(0);\r
+ }\r
+ \r
+ CAST\r
+\r
+\r
+Casting tells the compiler what a data type is, and can be used to change\r
+a data type. For example, consider the following;\r
+\r
+ #include <stdio.h>\r
+ \r
+ void main()\r
+ {\r
+ int x;\r
+ int y;\r
+ \r
+ x = 10;\r
+ y = 3;\r
+ \r
+ printf("\n%lf",x / y);\r
+ }\r
+\r
+The printf() function has been told to expect a double. However, the\r
+compiler sees the variables `x' and `y' as integers, and an error occurs!\r
+To make this example work we must tell the compiler that the result of\r
+the expression x / y is a double, this is done with a cast thus;\r
+\r
+\r
+ #include <stdio.h>\r
+ \r
+ void main()\r
+ {\r
+ int x;\r
+ int y;\r
+ \r
+ x = 10;\r
+ y = 3;\r
+ \r
+ printf("\n%lf",(double)(x / y));\r
+ }\r
+\r
+Notice the data type `double' is enclosed by parenthesis, and so is the\r
+expression to convert. But now, the compiler knows that the result of the\r
+expression is a double, but it still knows that the variables `x' and `y'\r
+are integers and so an integer division will be carried out. We have to\r
+cast the constants thus;\r
+\r
+ #include <stdio.h>\r
+ \r
+ void main()\r
+ {\r
+ int x;\r
+ int y;\r
+ \r
+ x = 10;\r
+ y = 3;\r
+ \r
+ printf("\n%lf",(double)(x) / (double)(y));\r
+ }\r
+\r
+Because both of the constants are doubles, the compiler knows that the\r
+outcome of the expression will also be a double.\r
+\r
+\r
+\r
+ \r
+ THE IMPORTANCE OF PROTOTYPING\r
+\r
+Prototyping a function involves letting the compiler know in advance what\r
+type of values a function will receive and return. For example, lets look\r
+at strtok(). This has the prototype;\r
+\r
+\r
+ char *strtok(char *s1, const char *s2);\r
+\r
+This prototype tells the compiler that strtok() will return a character\r
+pointer, the first received parameter will be a pointer to a character\r
+string, and that string can be changed by strtok(), and the last\r
+parameter will be a pointer to a character string that strtok() cannot\r
+change.\r
+\r
+The compiler knows how much space to allocate for the return parameter,\r
+sizeof(char *), but without a prototype for the function the compiler\r
+will assume that the return value of strtok() is an integer, and will\r
+allocate space for a return type of int, that is sizeof(int). If an\r
+integer and a character pointer occupy the same number of bytes on the\r
+host computer no major problems will occur, but if a character pointer\r
+occupies more space than an integer, then the compiler wont have\r
+allocated enough space for the return value and the return from a call to\r
+strtok() will overwrite some other bit of memory. If, as so often happens\r
+the return value is returned via the stack, the results of confusing the\r
+compiler can be disastrous!\r
+\r
+Thankfully most C compilers will warn the programmer if a call to a\r
+function has been made without a prototype, so that you can add the\r
+required function prototypes.\r
+\r
+Consider the following example that will not compile on most modern C\r
+compilers due to the nasty error in it;\r
+\r
+\r
+ #include <stdio.h>\r
+ \r
+ int FUNCA(int x, int y)\r
+ {\r
+ return(MULT(x,y));\r
+ }\r
+ \r
+ double MULT(double x, double y)\r
+ {\r
+ return(x * y);\r
+ }\r
+ \r
+ \r
+ main()\r
+ {\r
+ printf("\n%d",FUNCA(5,5));\r
+ }\r
+ \r
+When the compiler first encounters the function MULT() it is as a call\r
+from within FUNCA(). In the absence of any prototype for MULT() the\r
+compiler assumes that MULT() returns an integer. When the compiler finds\r
+the definition for function MULT() it sees that a return of type double\r
+has been declared. The compiler then reports an error in the compilation\r
+saying something like;\r
+\r
+\r
+ "Type mismatch in redclaration of function 'MULT'"\r
+\r
+What the compiler is really trying to say is, prototype your functions\r
+before using them! If this example did compile, and was then run it\r
+probably would crash the computer's stack and cause a system hang.\r
+\r
+ \r
+ POINTERS TO FUNCTIONS\r
+\r
+C allows a pointer to point to the address of a function, and this\r
+pointer to be called rather than specifying the function. This is used by\r
+interrupt changing functions and may be used for indexing functions\r
+rather than using switch statements. For example;\r
+\r
+ #include <stdio.h>\r
+ #include <math.h>\r
+ \r
+ double (*fp[7])(double x);\r
+ \r
+ void main()\r
+ {\r
+ double x;\r
+ int p;\r
+ \r
+ fp[0] = sin;\r
+ fp[1] = cos;\r
+ fp[2] = acos;\r
+ fp[3] = asin;\r
+ fp[4] = tan;\r
+ fp[5] = atan;\r
+ fp[6] = ceil;\r
+ \r
+ p = 4;\r
+ \r
+ x = fp[p](1.5);\r
+ printf("\nResult %lf",x);\r
+ }\r
+\r
+This example program defines an array of pointers to functions, (*fp[])()\r
+that are then called dependant upon the value in the indexing variable p.\r
+This program could also be written;\r
+\r
+ #include <stdio.h>\r
+ #include <math.h>\r
+ \r
+ void main()\r
+ {\r
+ double x;\r
+ int p;\r
+ \r
+ p = 4;\r
+ \r
+ switch(p)\r
+ {\r
+ case 0 : x = sin(1.5);\r
+ break;\r
+ case 1 : x = cos(1.5);\r
+ break;\r
+ case 2 : x = acos(1.5);\r
+ break;\r
+ case 3 : x = asin(1.5);\r
+ break;\r
+ case 4 : x = tan(1.5);\r
+ break;\r
+ case 5 : x = atan(1.5);\r
+ break;\r
+ case 6 : x = ceil(1.5);\r
+ break;\r
+ }\r
+ puts("\nResult %lf",x);\r
+ }\r
+\r
+The first example, using pointers to the functions, compiles into much\r
+smaller code and executes faster than the second example.\r
+\r
+The table of pointers to functions is a useful facility when writing\r
+language interpreters, the program compares an entered instruction\r
+against a table of key words that results in an index variable being set\r
+and then the program simply needs to call the function pointer indexed by\r
+the variable, rather than wading through a lengthy switch() statement.\r
+\r
+ \r
+ DANGEROUS PITFALLS\r
+\r
+One of the most dangerous pitfalls can occur with the use of gets(). This\r
+function accepts input from the stream stdin until it receives a newline\r
+character, which it does not pass to the program. All the data it\r
+receives is stored in memory starting at the address of the specified\r
+string, and quite happily overflowing into other variables! This danger\r
+can be avoided by using fgets() that allows a maximum number of\r
+characters to be specified, so you can avoid overflow problems. Notice\r
+though that fgets() does retain the newline character scanf() is another\r
+function best avoided. It accepts input from stdin and stores the\r
+received data at the addresses provided to it. If those addresses are not\r
+really addresses where the data ends up is anybodys guess!\r
+\r
+This example is okay, since scanf() has been told to store the data at\r
+the addresses occupied by the two variables `x' and `y'.\r
+\r
+\r
+ void main()\r
+ {\r
+ int x;\r
+ int y;\r
+ \r
+ scanf("%d%d",&x,&y);\r
+ }\r
+ \r
+But in this example scanf() has been told to store the data at the\r
+addresses suggested by the current values of `x' and `y'! An easy and\r
+common mistake to make, and yet one that can have very peculiar effects.\r
+\r
+\r
+ void main()\r
+ {\r
+ int x;\r
+ int y;\r
+ \r
+ scanf("%d%d",x,y);\r
+ }\r
+ \r
+The answer is, don't use scanf(), use fgets() and parse your string\r
+manually using the standard library functions strtod(), strtol() and\r
+strtoul().\r
+\r
+Here is the basis of a simple input string parser that returns the\r
+individual input fields from an entered string;\r
+\r
+ #include <stdio.h>\r
+ #include <string.h>\r
+ \r
+ void main()\r
+ {\r
+ char input[80];\r
+ char *p;\r
+ \r
+ puts("\nEnter a string ");\r
+ fgets(input,79,stdin);\r
+ \r
+ /* now parse string for input fields */\r
+ puts("The fields entered are:");\r
+ p = strtok(input,", ");\r
+ while(p)\r
+ {\r
+ puts(p);\r
+ p = strtok(NULL,", ");\r
+ }\r
+ }\r
+ \r
+ \r
+ SIZEOF\r
+\r
+A preprocessor instruction, `sizeof', returns the size of an item, be it\r
+a structure, pointer, string or whatever. However! take care when using\r
+`sizeof'. Consider the following program;\r
+\r
+\r
+ #include <stdio.h>\r
+ #include <mem.h>\r
+ \r
+ char string1[80]; char *text = "This is a string of data" ;\r
+ \r
+ void main()\r
+ {\r
+ /* Initialise string1 correctly */\r
+ memset(string1,0,sizeof(string1));\r
+ \r
+ /* Copy some text into string1 ? */\r
+ memcpy(string1,text,sizeof(text));\r
+ \r
+ /* Display string1 */\r
+ printf("\nString 1 = %s\n",string1);\r
+ }\r
+ \r
+What it is meant to do is initialise all 80 elements of string1 to\r
+zeroes, which it does alright, and then copy the constant string `text'\r
+into the variable `string1'. However, variable text is a pointer, and so\r
+the sizeof(text) instruction returns the size of the character pointer\r
+(perhaps two bytes) rather than the length of the string pointed to by\r
+the pointer! If the length of the string pointed to by `text' happened\r
+to be the same as the size of a character pointer then no error would be\r
+noticed.\r
+\r
+ \r
+ INTERRUPTS\r
+\r
+The IBM PC BIOS and DOS contain functions that may be called by a program\r
+by way of the function's interrupt number. The address of the function\r
+assigned to each interrupt is recorded in a table in RAM called the\r
+interrupt vector table. By changing the address of an interrupt vector a\r
+program can effectively disable the original interrupt function and\r
+divert any calls to it to its own function. This was done by the critical\r
+error handler described in the section on error handling.\r
+\r
+Borland's Turbo C provides two library functions for reading and changing\r
+an interrupt vector. These are: setvect() and getvect(). The\r
+corresponding Microsoft C library functions are: _dos_getvect() and\r
+_dos_setvect().\r
+\r
+getvect() has the function prototype;\r
+\r
+ void interrupt(*getvect(int interrupt_no))();\r
+\r
+setvect() has the prototype;\r
+\r
+ void setvect(int interrupt_no, void interrupt(*func)());\r
+\r
+To read and save the address of an existing interrupt a program uses\r
+getvect() thus;\r
+\r
+ /* Declare variable to record old interrupt */\r
+ void interrupt(*old)(void);\r
+ \r
+ main()\r
+ {\r
+ /* get old interrupt vector */\r
+ old = getvect(0x1C);\r
+ .\r
+ .\r
+ .\r
+ }\r
+ \r
+Where 0x1C is the interrupt vector to be retrieved.\r
+\r
+To then set the interrupt vector to a new address, our own function, we\r
+use setvect() thus;\r
+\r
+ void interrupt new(void)\r
+ {\r
+ .\r
+ .\r
+ /* New interrupt function */\r
+ .\r
+ .\r
+ .\r
+ }\r
+ \r
+ main()\r
+ {\r
+ .\r
+ .\r
+ .\r
+ setvect(0x1C,new);\r
+ .\r
+ .\r
+ .\r
+ .\r
+ }\r
+ \r
+There are two important points to note about interrupts;\r
+\r
+First, if the interrupt is called by external events then before changing\r
+the vector you MUST disable the interrupt callers using disable() and\r
+then re-enable the interrupts after the vector has been changed using\r
+enable(). If a call is made to the interrupt while the vector is being\r
+changed ANYTHING could happen!\r
+\r
+Secondly, before your program terminates and returns to DOS you must\r
+reset any changed interrupt vectors! The exception to this is the\r
+critical error handler interrupt vector that is restored automatically by\r
+DOS, so your program needn't bother restoring it.\r
+\r
+This example program hooks the PC clock timer interrupt to provide a\r
+background clock process while the rest of the program continues to run.\r
+If included with your own program that requires a constantly displayed\r
+clock on screen, you need only amend the display coordinates in the call\r
+to puttext(). Sincle the closk display code is called by a hardware\r
+issued interrupt, your program can start the clock and forget it until it\r
+terminates.\r
+\r
+ \r
+ /* Compile in LARGE memory model */\r
+ \r
+ #include <stdio.h>\r
+ #include <dos.h>\r
+ #include <time.h>\r
+ #include <conio.h>\r
+ #include <stdlib.h>\r
+ \r
+ enum { FALSE, TRUE };\r
+ \r
+ #define COLOUR (BLUE << 4) | YELLOW\r
+ \r
+ #define BIOS_TIMER 0x1C\r
+ \r
+ static unsigned installed = FALSE;\r
+ static void interrupt (*old_tick) (void);\r
+ \r
+ static void interrupt tick (void)\r
+ {\r
+ int i;\r
+ struct tm *now;\r
+ time_t this_time;\r
+ char time_buf[9];\r
+ static time_t last_time = 0L;\r
+ static char video_buf[20] =\r
+ {\r
+ ' ', COLOUR, '0', COLOUR, '0', COLOUR, ':', COLOUR, '0',\r
+ COLOUR,\r
+ '0', COLOUR, ':', COLOUR, '0', COLOUR, '0', COLOUR, ' ',\r
+ COLOUR\r
+ };\r
+ \r
+ enable ();\r
+ \r
+ if (time (&this_time) != last_time)\r
+ {\r
+ last_time = this_time;\r
+ \r
+ now = localtime(&this_time);\r
+ \r
+ sprintf(time_buf, "%02d:%02d.%02d",now->tm_hour,now-\r
+ >tm_min,now->tm_sec);\r
+ \r
+ for (i = 0; i < 8; i++)\r
+ {\r
+ video_buf[(i + 1) << 1] = time_buf[i];\r
+ }\r
+ \r
+ puttext (71, 1, 80, 1, video_buf);\r
+ }\r
+ \r
+ old_tick ();\r
+ }\r
+ \r
+ void stop_clock (void)\r
+ {\r
+ if (installed)\r
+ {\r
+ setvect (BIOS_TIMER, old_tick);\r
+ installed = FALSE;\r
+ }\r
+ }\r
+ \r
+ void start_clock (void)\r
+ {\r
+ static unsigned first_time = TRUE;\r
+ \r
+ if (!installed)\r
+ {\r
+ if (first_time)\r
+ {\r
+ atexit (stop_clock);\r
+ first_time = FALSE;\r
+ }\r
+ \r
+ old_tick = getvect (BIOS_TIMER);\r
+ setvect (BIOS_TIMER, tick);\r
+ installed = TRUE;\r
+ }\r
+ }\r
+ \r
+ SIGNAL\r
+\r
+Interrupts raised by the host computer can be trapped and diverted in\r
+several ways. A simple method is to use signal().\r
+\r
+Signal() takes two parameters in the form;\r
+\r
+ void (*signal (int sig, void (*func) (int))) (int);\r
+\r
+The first parameter, `sig' is the signal to be caught. These are often\r
+predefined by the header file `signal.h'.\r
+\r
+The second parameter is a pointer to a function to be called when the\r
+signal is raised. This can either be a user function, or a macro defined\r
+in the header file `signal.h' to do some arbitrary task, such as ignore\r
+the signal for example.\r
+\r
+On a PC platform, it is often useful to disable the `ctrl-break' key\r
+combination that is used to terminate a running program by the user. The\r
+following PC signal() call replaces the predefined signal `SIGINT', which\r
+equates to the ctrl-break interrupt request, with the predefined macro\r
+`SIG-IGN', ignore the request;\r
+\r
+\r
+ signal(SIGINT,SIG_IGN);\r
+\r
+This example catches floating point errors on a PC, and zero divisions!\r
+\r
+ #include <stdio.h>\r
+ #include <signal.h>\r
+ \r
+ void (*old_sig)();\r
+ \r
+ void catch(int sig)\r
+ {\r
+ printf("Catch was called with: %d\n",sig);\r
+ }\r
+ \r
+ \r
+ void main()\r
+ {\r
+ int a;\r
+ int b;\r
+ \r
+ old_sig = signal(SIGFPE,catch);\r
+ \r
+ a = 0;\r
+ b = 10 / a;\r
+ \r
+ /* Restore original handler before exiting! */\r
+ signal(SIGFPE,old_sig);\r
+ }\r
+ \r
+ \r
+ SORTING AND SEARCHING\r
+\r
+The ANSI C standard defines qsort(), a function for sorting a table of\r
+data. The function follows the format;\r
+\r
+ qsort(void *base,size_t elements,size_t width,int (*cmp)(void *,\r
+void *));\r
+\r
+The following short program illustrates the use of qsort() with a\r
+character array.\r
+\r
+ #include <string.h>\r
+ \r
+ main()\r
+ {\r
+ int n;\r
+ char data[10][20];\r
+ \r
+ /* Initialise some arbirary data */\r
+ \r
+ strcpy(data[0],"RED");\r
+ strcpy(data[1],"BLUE");\r
+ strcpy(data[2],"GREEN");\r
+ strcpy(data[3],"YELLOW");\r
+ strcpy(data[4],"INDIGO");\r
+ strcpy(data[5],"BROWN");\r
+ strcpy(data[6],"BLACK");\r
+ strcpy(data[7],"ORANGE");\r
+ strcpy(data[8],"PINK");\r
+ strcpy(data[9],"CYAN");\r
+ \r
+ /* Sort the data table */\r
+ qsort(data[0],10,20,strcmp);\r
+ \r
+ /* Print the data table */\r
+ for(n = 0; n < 10; n++)\r
+ puts(data[n]);\r
+ }\r
+ \r
+\r
+Here is a program that implements the shell sort algorithm (this one is\r
+based on the routine in K & R), which sorts arrays of pointers based upon\r
+the data pointed to by the pointers;\r
+\r
+ #include <stdio.h>\r
+ #include <stdlib.h>\r
+ #include <string.h>\r
+ \r
+ #define LINELEN 80\r
+ #define MAXLINES 2000\r
+ \r
+ char *lines[MAXLINES];\r
+ int lastone;\r
+ \r
+ void SHELL(void);\r
+ \r
+ void SHELL()\r
+ {\r
+ /* SHELL Sort Courtesy of K & R */\r
+ \r
+ int gap;\r
+ int i;\r
+ int j;\r
+ char temp[LINELEN];\r
+ \r
+ for(gap = lastone / 2; gap > 0; gap /= 2)\r
+ for(i = gap; i < lastone; i++)\r
+ for(j = i - gap; j >= 0 && strcmp(lines[j] , lines[j +\r
+ gap]) >\r
+ 0; j -= gap)\r
+ {\r
+ strcpy(temp,lines[j]);\r
+ strcpy(lines[j] , lines[j + gap]);\r
+ strcpy(lines[j + gap] , temp);\r
+ \r
+ }\r
+ }\r
+ \r
+ void main(int argc, char *argv[])\r
+ {\r
+ FILE *fp;\r
+ char buff[100];\r
+ int n;\r
+\r
+ /* Check command line parameter has been given */\r
+ if (argc != 2)\r
+ {\r
+ printf("\nError: Usage is SERVSORT file");\r
+ exit(0);\r
+ }\r
+ \r
+ /* Attempt to open file for updating */\r
+ fp = fopen(argv[1],"r+");\r
+ if (fp == NULL)\r
+ {\r
+ printf("\nError: Unable to open %s",argv[1]);\r
+ exit(0);\r
+ }\r
+ \r
+ /* Initialise element counter to zero */\r
+ lastone = 0;\r
+ \r
+ /* Read file to be sorted */\r
+ while((fgets(buff,100,fp)) != NULL)\r
+ {\r
+ /* Allocate memory block*/\r
+ lines[lastone] = malloc(LINELEN);\r
+ if (lines[lastone] == NULL)\r
+ {\r
+ printf("\nError: Unable to allocate memory");\r
+ fclose(fp);\r
+ exit(0);\r
+ }\r
+ strcpy(lines[lastone],buff);\r
+ lastone++;\r
+ \r
+ if (lastone > MAXLINES)\r
+ {\r
+ printf("\nError: Too many lines in source file");\r
+ exit(0);\r
+ }\r
+ }\r
+ /* Call sort function */\r
+ SHELL();\r
+ \r
+ /* Close file */\r
+ fclose(fp);\r
+ \r
+ /* Reopen file in create mode */\r
+ fp = fopen(argv[1],"w+");\r
+ \r
+ /* Copy sorted data from memory to disk */\r
+ for(n = 0; n < lastone; n++)\r
+ fputs(lines[n],fp);\r
+ \r
+ /* Close file finally */\r
+ fclose(fp);\r
+ \r
+ /* Return to calling program */\r
+ return(1);\r
+ }\r
+ \r
+\r
+If we want to use qsort() with a table of pointers we have to be a bit\r
+more clever than usual.\r
+\r
+This example uses the colours again, but this time they are stored in\r
+main memory and indexed by a table of pointers. Because we have a table\r
+of pointers to sort there are two differences between this program's\r
+qsort() and the previous one;\r
+\r
+First we can't use strcmp() as the qsort() comparison function, secondly\r
+the width of the table being sorted is sizeof(char *), that is the size\r
+of a character pointer.\r
+\r
+Notice the comparison function cmp() that receives two parameters, both\r
+are pointers to a pointer. qsort() sends to this function the values held\r
+in data[], which are in turn pointers to the data. So we need to use this\r
+indirection to locate the data, otherwise we would be comparing the\r
+addresses at which the data is held rather than the data itself!\r
+\r
+ #include <alloc.h>\r
+ #include <string.h>\r
+ \r
+ /* Function prototype for comparison function */\r
+ int (cmp)(char **,char **);\r
+ \r
+ int cmp(char **s1, char **s2)\r
+ {\r
+ /* comparison function using pointers to pointers */\r
+ return(strcmp(*s1,*s2));\r
+ }\r
+ \r
+ main()\r
+ {\r
+ int n;\r
+ char *data[10];\r
+ \r
+ for(n = 0; n < 10; n++)\r
+ data[n] = malloc(20);\r
+ \r
+ strcpy(data[0],"RED");\r
+ strcpy(data[1],"BLUE");\r
+ strcpy(data[2],"GREEN");\r
+ strcpy(data[3],"YELLOW");\r
+ strcpy(data[4],"INDIGO");\r
+ strcpy(data[5],"BROWN");\r
+ strcpy(data[6],"BLACK");\r
+ strcpy(data[7],"ORANGE");\r
+ strcpy(data[8],"PINK");\r
+ strcpy(data[9],"CYAN");\r
+ \r
+ /* The data table is comprised of pointers */\r
+ /* so the call to qsort() must reflect this */\r
+ qsort(data,10,sizeof(char *),cmp);\r
+ \r
+ for(n = 0; n < 10; n++)\r
+ puts(data[n]);\r
+ }\r
+ \r
+The quick sort is a fast sorting algorithm that works by subdividing the\r
+data table into two sub-tables and then subdividing the sub-tables. As it\r
+subdivides the table, so it compares the elements in the table and swaps\r
+them as required.\r
+\r
+The following program implements the quick sort algorithm, which is\r
+usually already used by qsort();\r
+\r
+\r
+ #include <string.h>\r
+ \r
+ #define MAXELE 2000\r
+ \r
+ char data[10][20];\r
+ int lastone;\r
+ \r
+ void QKSORT()\r
+ {\r
+ /* Implementation of QUICKSORT algorithm */\r
+ \r
+ int i;\r
+ int j;\r
+ int l;\r
+ int p;\r
+ int r;\r
+ int s;\r
+ char temp[100];\r
+ static int sl[MAXELE][2];\r
+ \r
+ /* sl[] is an index to the sub-table */\r
+ \r
+ l = 0;\r
+ r = lastone;\r
+ p = 0;\r
+ \r
+ do\r
+ {\r
+ while(l < r)\r
+ {\r
+ i = l;\r
+ j = r;\r
+ s = -1;\r
+ \r
+ while(i < j)\r
+ {\r
+ if (strcmp(data[i],data[j]) > 0)\r
+ {\r
+ strcpy(temp,data[i]);\r
+ strcpy(data[i],data[j]);\r
+ strcpy(data[j],temp);\r
+ s = 0 - s;\r
+ }\r
+ \r
+ if (s == 1)\r
+ i++;\r
+ else\r
+ j--;\r
+ }\r
+ \r
+ if (i + 1 < r)\r
+ {\r
+ p++;\r
+ sl[p][0] = i + 1;\r
+ sl[p][1] = r;\r
+ }\r
+ r = i - 1;\r
+ }\r
+ if (p != 0)\r
+ {\r
+ l = sl[p][0];\r
+ r = sl[p][1];\r
+ p--;\r
+ }\r
+ }\r
+ while(p > 0);\r
+ }\r
+ \r
+ main()\r
+ {\r
+ int n;\r
+ \r
+ /* Initialise arbitrary data */\r
+ strcpy(data[0],"RED");\r
+ strcpy(data[1],"BLUE");\r
+ strcpy(data[2],"GREEN");\r
+ strcpy(data[3],"YELLOW");\r
+ strcpy(data[4],"INDIGO");\r
+ strcpy(data[5],"BROWN");\r
+ strcpy(data[6],"BLACK");\r
+ strcpy(data[7],"ORANGE");\r
+ strcpy(data[8],"PINK");\r
+ strcpy(data[9],"CYAN");\r
+ \r
+ /* Set last element indicator */\r
+ lastone = 9;\r
+ \r
+ /* Call quick sort function */\r
+ QKSORT();\r
+ \r
+ /* Display sorted list */\r
+ for(n = 0; n < 10; n++)\r
+ puts(data[n]);\r
+ \r
+ }\r
+ \r
+A table sorted into ascending order can be searched with bsearch(), this\r
+takes the format;\r
+\r
+ bsearch(key,base,num_elements,width,int (*cmp)(void *, void *));\r
+\r
+bsearch() returns a pointer to the first element in the table that\r
+matches the key, or zero if no match is found.\r
+\r
+Or you can write your own binary search function thus;\r
+\r
+ int BSRCH(char *key, void *data, int numele, int width)\r
+ {\r
+ /* A binary search function returning one if found */\r
+ /* Zero if not found */\r
+ \r
+ int bp;\r
+ int tp;\r
+ int mp;\r
+ int result;\r
+ char *p;\r
+ \r
+ bp = 0;\r
+ tp = numele;\r
+ mp = (tp + bp) / 2;\r
+ \r
+ /* Locate element mp in table by assigning pointer to start */\r
+ /* and incrementing it by width * mp */\r
+ p = data;\r
+ p += width * mp;\r
+ \r
+ while((result = strcmp(p,key)) != 0)\r
+ {\r
+ if (mp >= tp)\r
+ /* Not found! */\r
+ return(0);\r
+ if (result < 0)\r
+ bp = mp + 1;\r
+ else\r
+ tp = mp - 1;\r
+ \r
+ mp = (bp + tp) / 2;\r
+ p = data;\r
+ p += width * mp;\r
+ }\r
+ return(1);\r
+ }\r
+ \r
+ void main()\r
+ {\r
+ int result;\r
+ char data[10][20];\r
+ \r
+ /* Initialise some arbirary data */\r
+ \r
+ strcpy(data[0],"RED");\r
+ strcpy(data[1],"BLUE");\r
+ strcpy(data[2],"GREEN");\r
+ strcpy(data[3],"YELLOW");\r
+ strcpy(data[4],"INDIGO");\r
+ strcpy(data[5],"BROWN");\r
+ strcpy(data[6],"BLACK");\r
+ strcpy(data[7],"ORANGE");\r
+ strcpy(data[8],"PINK");\r
+ strcpy(data[9],"CYAN");\r
+ \r
+ /* Sort the data table */\r
+ qsort(data[0],10,20,strcmp);\r
+ \r
+ result = BSRCH("CYAN",data[0],10,20);\r
+ \r
+ printf("\n%s\n",(result == 0) ? "Not found" : "Located okay");\r
+ }\r
+ \r
+There are other sorting algorithms as well. This program incorporates the\r
+QUICK SORT, BUBBLE SORT, FAST BUBBLE SORT, INSERTION SORT and SHELL SORT\r
+for comparing how each performs on a random 1000 item string list;\r
+\r
+ #include <stdio.h>\r
+ #include <stdlib.h>\r
+ #include <string.h>\r
+ \r
+ char data[1000][4];\r
+ char save[1000][4];\r
+ \r
+ int lastone;\r
+ \r
+ void INITDATA(void);\r
+ void QKSORT(void);\r
+ void SHELL(void);\r
+ void BUBBLE(void);\r
+ void FBUBBLE(void);\r
+ void INSERTION(void);\r
+ void MKDATA(void);\r
+ \r
+ void QKSORT()\r
+ {\r
+ /* Implementation of QUICKSORT algorithm */\r
+ \r
+ int i;\r
+ int j;\r
+ int l;\r
+ int p;\r
+ int r;\r
+ int s;\r
+ char temp[20];\r
+ static int sl[1000][2];\r
+ \r
+ l = 0;\r
+ r = lastone;\r
+ p = 0;\r
+ \r
+ do\r
+ {\r
+ while(l < r)\r
+ {\r
+ i = l;\r
+ j = r;\r
+ s = -1;\r
+ \r
+ while(i < j)\r
+ {\r
+ if (strcmp(data[i],data[j]) > 0)\r
+ {\r
+ strcpy(temp,data[i]);\r
+ strcpy(data[i],data[j]);\r
+ strcpy(data[j],temp);\r
+ s = 0 - s;\r
+ }\r
+ \r
+ if (s == 1)\r
+ i++;\r
+ else\r
+ j--;\r
+ }\r
+ \r
+ if (i + 1 < r)\r
+ {\r
+ p++;\r
+ sl[p][0] = i + 1;\r
+ sl[p][1] = r;\r
+ }\r
+ r = i - 1;\r
+ }\r
+ if (p != 0)\r
+ {\r
+ l = sl[p][0];\r
+ r = sl[p][1];\r
+ p--;\r
+ }\r
+ }\r
+ while(p > 0);\r
+ }\r
+ \r
+ void SHELL()\r
+ {\r
+ /* SHELL Sort Courtesy of K & R */\r
+ \r
+ int gap;\r
+ int i;\r
+ int j;\r
+ char temp[20];\r
+ \r
+ for(gap = lastone / 2; gap > 0; gap /= 2)\r
+ for(i = gap; i < lastone; i++)\r
+ for(j = i - gap; j >= 0 && strcmp(data[j] , data[j + gap])\r
+ > 0;\r
+ j -= gap)\r
+ {\r
+ strcpy(temp,data[j]);\r
+ strcpy(data[j] , data[j + gap]);\r
+ strcpy(data[j + gap] , temp);\r
+ }\r
+ }\r
+ \r
+ void BUBBLE()\r
+ {\r
+ int a;\r
+ int b;\r
+ char temp[20];\r
+ \r
+ for(a = lastone; a >= 0; a--)\r
+ {\r
+ for(b = 0; b < a; b++)\r
+ {\r
+ if(strcmp(data[b],data[b + 1]) > 0)\r
+ {\r
+ strcpy(temp,data[b]);\r
+ strcpy(data[b] , data[b + 1]);\r
+ strcpy(data[b + 1] , temp);\r
+ }\r
+ }\r
+ }\r
+ }\r
+ \r
+ void FBUBBLE()\r
+ {\r
+ /* bubble sort with swap flag*/\r
+ \r
+ int a;\r
+ int b;\r
+ int s;\r
+ char temp[20];\r
+ \r
+ s = 1;\r
+ \r
+ for(a = lastone; a >= 0 && s == 1; a--)\r
+ {\r
+ s = 0;\r
+ for(b = 0; b < a; b++)\r
+ {\r
+ if(strcmp(data[b],data[b + 1]) > 0)\r
+ {\r
+ strcpy(temp,data[b]);\r
+ strcpy(data[b] , data[b + 1]);\r
+ strcpy(data[b + 1] , temp);\r
+ s = 1;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ \r
+ void INSERTION()\r
+ {\r
+ int a;\r
+ int b;\r
+ char temp[20];\r
+ \r
+ for(a = 0; a < lastone; a++)\r
+ {\r
+ b = a;\r
+ strcpy(temp,data[a + 1]);\r
+ while(b >= 0)\r
+ {\r
+ if (strcmp(temp,data[b]) < 0)\r
+ {\r
+ strcpy(data[b+1],data[b]);\r
+ b--;\r
+ }\r
+ else\r
+ break;\r
+ }\r
+ strcpy(data[b+1],temp);\r
+ }\r
+ }\r
+ \r
+ void MKDATA()\r
+ {\r
+ /* Initialise arbitrary data */\r
+ /* Uses random(), which is not ANSI C */\r
+ /* Returns a random number between 0 and n - 1 */\r
+ \r
+ int n;\r
+ for(n = 0; n < 1000; n++)\r
+ sprintf(save[n],"%d",random(1000));\r
+ }\r
+ \r
+ void INITDATA()\r
+ {\r
+ int n;\r
+ \r
+ for(n = 0 ; n < 1000; n++)\r
+ strcpy(data[n],save[n]);\r
+ }\r
+ \r
+ void main()\r
+ {\r
+ MKDATA();\r
+ \r
+ /* Initialise arbitrary data */\r
+ INITDATA();\r
+ \r
+ /* Set last element indicator */\r
+ lastone = 999;\r
+ \r
+ /* Call quick sort function */\r
+ QKSORT();\r
+ \r
+ \r
+ /* Initialise arbitrary data */\r
+ INITDATA();\r
+ \r
+ /* Set last element indicator */\r
+ lastone = 1000;\r
+ \r
+ /* Call shell sort function */\r
+ SHELL();\r
+ \r
+ /* Initialise arbitrary data */\r
+ INITDATA();\r
+ \r
+ /* Set last element indicator */\r
+ lastone = 999;\r
+ \r
+ /* Call bubble sort function */\r
+ BUBBLE();\r
+ \r
+ /* Initialise arbitrary data */\r
+ INITDATA();\r
+ \r
+ /* Set last element indicator */\r
+ lastone = 999;\r
+ \r
+ /* Call bubble sort with swap flag function */\r
+ FBUBBLE();\r
+ \r
+ /* Initialise arbitrary data */\r
+ INITDATA();\r
+ \r
+ /* Set last element indicator */\r
+ lastone = 999;\r
+ \r
+ /* Call insertion sort function */\r
+ INSERTION();\r
+ }\r
+\r
+Here are the profiler results of the above test program run on 1000 and\r
+5000 random items;\r
+\r
+STRING SORT - 1000 RANDOM ITEMS\r
+\r
+FBUBBLE 26.436 sec 41%\r
+|********************************************\r
+BUBBLE 26.315 sec 41%\r
+|*******************************************\r
+INSERTION 10.210 sec 15% |***************\r
+SHELL 0.8050 sec 1% |*\r
+QKSORT 0.3252 sec <1% |\r
+\r
+STRING SORT - 5000 RANDOM ITEMS\r
+\r
+FBUBBLE 563.70 sec 41%\r
+|********************************************\r
+BUBBLE 558.01 sec 41%\r
+|********************************************\r
+INSERTION 220.61 sec 16% |***************\r
+SHELL 5.2531 sec <1% |\r
+QKSORT 0.8379 sec <1% |\r
+\r
+Here is the same test program amended for sorting tables of integers;\r
+\r
+ /* Integer sort test program */\r
+ \r
+ #include <stdio.h>\r
+ #include <stdlib.h>\r
+ \r
+ void INITDATA(void);\r
+ void QKSORT(void);\r
+ void SHELL(void);\r
+ void BUBBLE(void);\r
+ void FBUBBLE(void);\r
+ void INSERTION(void);\r
+ void MKDATA(void);\r
+ \r
+ int data[1000];\r
+ int save[1000];\r
+ \r
+ int lastone;\r
+ \r
+ void QKSORT()\r
+ {\r
+ /* Implementation of QUICKSORT algorithm */\r
+ \r
+ int i;\r
+ int j;\r
+ int l;\r
+ int p;\r
+ int r;\r
+ int s;\r
+ int temp;\r
+ static int sl[1000][2];\r
+ \r
+ l = 0;\r
+ r = lastone;\r
+ p = 0;\r
+ \r
+ do\r
+ {\r
+ while(l < r)\r
+ {\r
+ i = l;\r
+ j = r;\r
+ s = -1;\r
+ \r
+ while(i < j)\r
+ {\r
+ if (data[i] > data[j])\r
+ {\r
+ temp = data[i];\r
+ data[i] = data[j];\r
+ data[j] = temp;\r
+ s = 0 - s;\r
+ }\r
+ \r
+ if (s == 1)\r
+ i++;\r
+ else\r
+ j--;\r
+ }\r
+ \r
+ if (i + 1 < r)\r
+ {\r
+ p++;\r
+ sl[p][0] = i + 1;\r
+ sl[p][1] = r;\r
+ }\r
+ r = i - 1;\r
+ }\r
+ if (p != 0)\r
+ {\r
+ l = sl[p][0];\r
+ r = sl[p][1];\r
+ p--;\r
+ }\r
+ }\r
+ while(p > 0);\r
+ }\r
+ \r
+ void SHELL()\r
+ {\r
+ /* SHELL Sort Courtesy of K & R */\r
+ \r
+ int gap;\r
+ int i;\r
+ int j;\r
+ int temp;\r
+ \r
+ for(gap = lastone / 2; gap > 0; gap /= 2)\r
+ for(i = gap; i < lastone; i++)\r
+ for(j = i - gap; j >= 0 && data[j] > data[j + gap];\r
+ j -= gap)\r
+ {\r
+ temp = data[j];\r
+ data[j] = data[j + gap];\r
+ data[j + gap] = temp;\r
+ }\r
+ }\r
+ \r
+ void BUBBLE()\r
+ {\r
+ int a;\r
+ int b;\r
+ int temp;\r
+ \r
+ for(a = lastone; a >= 0; a--)\r
+ {\r
+ for(b = 0; b < a; b++)\r
+ {\r
+ if(data[b] > data[b + 1])\r
+ {\r
+ temp = data[b];\r
+ data[b] = data[b + 1];\r
+ data[b + 1] = temp;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ \r
+ void FBUBBLE()\r
+ {\r
+ /* bubble sort with swap flag */\r
+ \r
+ int a;\r
+ int b;\r
+ int s;\r
+ int temp;\r
+ \r
+ s = 1;\r
+ \r
+ for(a = lastone; a >= 0 && s == 1; a--)\r
+ {\r
+ s = 0;\r
+ for(b = 0; b < lastone - a; b++)\r
+ {\r
+ if(data[b] > data[b + 1])\r
+ {\r
+ temp = data[b];\r
+ data[b] = data[b + 1];\r
+ data[b + 1] = temp;\r
+ s = 1;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ \r
+ void INSERTION()\r
+ {\r
+ int a;\r
+ int b;\r
+ int temp;\r
+ \r
+ for(a = 0; a < lastone; a++)\r
+ {\r
+ b = a;\r
+ temp = data[a + 1];\r
+ while(b >= 0)\r
+ {\r
+ if (temp < data[b])\r
+ {\r
+ data[b+1] = data[b];\r
+ b--;\r
+ }\r
+ else\r
+ break;\r
+ }\r
+ data[b+1] = temp;\r
+ }\r
+ }\r
+ \r
+ void MKDATA()\r
+ {\r
+ int n;\r
+ \r
+ for(n = 0; n < 1000; n++)\r
+ save[n] = random(1000);\r
+ }\r
+ \r
+ void INITDATA()\r
+ {\r
+ int n;\r
+ \r
+ for(n = 0; n < 1000; n++)\r
+ data[n] = save[n];\r
+ }\r
+ \r
+ void main()\r
+ {\r
+ int n;\r
+ \r
+ /* Create 1000 random elements */\r
+ MKDATA();\r
+ \r
+ /* Initialise arbitrary data */\r
+ INITDATA();\r
+ \r
+ /* Set last element indicator */\r
+ lastone = 999;\r
+ \r
+ /* Call quick sort function */\r
+ QKSORT();\r
+ \r
+ /* Initialise arbitrary data */\r
+ INITDATA();\r
+ \r
+ /* Set last element indicator */\r
+ lastone = 1000;\r
+ \r
+ /* Call shell sort function */\r
+ SHELL();\r
+ \r
+ /* Initialise arbitrary data */\r
+ INITDATA();\r
+ \r
+ /* Set last element indicator */\r
+ lastone = 999;\r
+ \r
+ /* Call bubble sort function */\r
+ BUBBLE();\r
+ \r
+ /* Initialise arbitrary data */\r
+ INITDATA();\r
+ \r
+ /* Set last element indicator */\r
+ lastone = 999;\r
+ \r
+ /* Call bubble sort with swap flag function */\r
+ FBUBBLE();\r
+ \r
+ /* Initialise arbitrary data */\r
+ INITDATA();\r
+ \r
+ /* Set last element indicator */\r
+ lastone = 999;\r
+ \r
+ /* Call insertion sort function */\r
+ INSERTION();\r
+ }\r
+\r
+And here are the profiler results for this program;\r
+\r
+INTEGER SORTS - 1000 RANDOM NUMBERS (0 - 999)\r
+\r
+FBUBBLE 3.7197 sec 41%\r
+|********************************************\r
+BUBBLE 3.5981 sec 39%\r
+|******************************************\r
+INSERTION 1.4258 sec 15% |***************\r
+SHELL 0.1207 sec 1% |*\r
+QKSORT 0.0081 sec <1% |\r
+\r
+INTEGER SORTS - 5000 RANDOM NUMBERS (0 - 999)\r
+\r
+FBUBBLE 92.749 sec 42%\r
+|********************************************\r
+BUBBLE 89.731 sec 41%\r
+|********************************************\r
+INSERTION 35.201 sec 16% |***************\r
+SHELL 0.9838 sec <1% |\r
+QKSORT 0.0420 sec <1% |\r
+\r
+INTEGER SORTS - 5000 RANDOM NUMBERS (0 - 99)\r
+\r
+FBUBBLE 92.594 sec 42% |*****************************************\r
+BUBBLE 89.595 sec 40% |****************************************\r
+INSERTION 35.026 sec 16% |***************\r
+SHELL 0.7563 sec <1% |\r
+QKSORT 0.6018 sec <1% |\r
+\r
+INTEGER SORTS - 5000 RANDOM NUMBERS (0 - 9)\r
+\r
+FBUBBLE 89.003 sec 41%\r
+|*******************************************\r
+BUBBLE 86.921 sec 40%\r
+|*******************************************\r
+INSERTION 31.544 sec 14% |***************\r
+QKSORT 6.0358 sec 2% |**\r
+SHELL 0.5424 sec <1% |\r
+\r
+INTEGER SORTS - 5000 DESCENDING ORDERED NUMBERS\r
+\r
+FBUBBLE 122.99 sec 39%\r
+|******************************************\r
+BUBBLE 117.22 sec 37% |****************************************\r
+INSERTION 70.595 sec 22% |**********************\r
+SHELL 0.6438 sec <1% |\r
+QKSORT 0.0741 sec <1% |\r
+\r
+INTEGER SORTS - 5000 ORDERED NUMBERS\r
+\r
+BUBBLE 62.908 sec 99%\r
+|******************************************\r
+SHELL 0.3971 sec <1% |\r
+INSERTION 0.0510 sec <1% |\r
+QKSORT 0.0382 sec <1% |\r
+FBUBBLE 0.0251 sec <1% |\r
+\r
+INTEGER SORTS - 10000 RANDOM NUMBERS (0 - 999)\r
+\r
+FBUBBLE 371.18 sec 42% |****************************************\r
+BUBBLE 359.06 sec 41% |***************************************\r
+INSERTION 140.88 sec 16% |**************\r
+SHELL 2.0423 sec <1% |\r
+QKSORT 0.6183 sec <1% |\r
+\r
+Theory has it that the performance of a sorting algorithm is dependant\r
+upon;\r
+\r
+ a) the number of items to be sorted and\r
+ b) how unsorted the list is to start with.\r
+\r
+With this in mind it is worth testing the various sorting routines\r
+described here to determine which one will best suit your particular\r
+application. If you examine the above profiler results you will see that:\r
+\r
+ 1) With an already sorted list FBUBBLE() executes fastest\r
+ \r
+ 2) With a random list of small variations between the values SHELL()\r
+ executes fastest\r
+ \r
+ 3) With a random list of large variations between the values\r
+ QKSORT()\r
+ executes the fastest\r
+\r
+What the profiler does not highlight is that when the comparison aspect\r
+of a sort function takes a disproportionately long time to execute in\r
+relation to the rest of the sort function, then the bubble sort with a\r
+swap flag will execute faster than the bubble sort with out a swap flag.\r
+\r
+When considering a sort routine take into consideration memory\r
+constraints and the type of data to be sorted as well as the relative\r
+performances of the sort functions. Generally, the faster a sort\r
+operates, the more memory it requires. Compare the simple bubble sort\r
+with the quick sort, and you will see that the quick sort requires far\r
+more memory than the bubble sort.\r
+\r
+ \r
+ DYNAMIC MEMORY ALLOCATION\r
+\r
+\r
+If a program needs a table of data, but the size of the table is\r
+variable, perhaps for a list of all file names in the current directory,\r
+it is inefficient to waste memory by declaring a data table of the\r
+maximum possible size. Rather it is better to dynamically allocate the\r
+table as required.\r
+\r
+Turbo C allocates RAM as being available for dynamic allocation into an\r
+area called the "heap". The size of the heap varies with memory model.\r
+The tiny memory model defaults to occupy 64K of RAM. The small memory\r
+model allocates upto 64K for the program/code and heap with a far heap\r
+being available within the remainder of conventional memory. The other\r
+memory models make all conventional memory available to the heap. This is\r
+significant when programming in the tiny memory model when you want to\r
+reduce the memory overhead of your program to a minimum. The way to do\r
+this is to reduce the heap to a minimum size. The smallest is 1 byte.\r
+\r
+C provides a function malloc() which allocates a block of free memory of\r
+a specified size and returns a pointer to the start of the block; it also\r
+provides free() which deallocates a block of memory previously allocated\r
+by malloc(). Notice, however, that the IBM PC doesnot properly free\r
+blocks of memory, and contiuous use of malloc() and free() will\r
+fragmentise memory, eventually causing no memory to be available untill\r
+the program terminates.\r
+\r
+This program searches a specified file for a specified string (with case\r
+sensitivity). It uses malloc() to allocate just enough memory for the\r
+file to be read into memory.\r
+\r
+ #include <stdio.h>\r
+ #include <stdlib.h>\r
+ \r
+ char *buffer;\r
+ \r
+ void main(int argc, char *argv[])\r
+ {\r
+ FILE *fp;\r
+ long flen;\r
+ \r
+ /* Check number of parameters */\r
+ if (argc != 3)\r
+ {\r
+ fputs("Usage is sgrep <text> <file spec>",stderr);\r
+ exit(0);\r
+ }\r
+ \r
+ /* Open stream fp to file */\r
+ fp = fopen(argv[2],"r");\r
+ if (!fp)\r
+ {\r
+ perror("Unable to open source file");\r
+ exit(0);\r
+ }\r
+ \r
+ /* Locate file end */\r
+ if(fseek(fp,0L,SEEK_END))\r
+ {\r
+ fputs("Unable to determine file length",stderr);\r
+ fclose(fp);\r
+ exit(0);\r
+ }\r
+ \r
+ /* Determine file length */\r
+ flen = ftell(fp);\r
+ \r
+ /* Check for error */\r
+ if (flen == -1L)\r
+ {\r
+ fputs("Unable to determine file length",stderr);\r
+ fclose(fp);\r
+ exit(0);\r
+ }\r
+ \r
+ /* Set file pointer to start of file */\r
+ rewind(fp);\r
+ \r
+ /* Allocate memory buffer */\r
+ buffer = malloc(flen);\r
+ \r
+ if (!buffer)\r
+ {\r
+ fputs("Unable to allocate memory",stderr);\r
+ fclose(fp);\r
+ exit(0);\r
+ }\r
+ \r
+ /* Read file into buffer */\r
+ fread(buffer,flen,1,fp);\r
+ \r
+ /* Check for read error */\r
+ if(ferror(fp))\r
+ {\r
+ fputs("Unable to read file",stderr);\r
+ \r
+ /* Deallocate memory block */\r
+ free(buffer);\r
+ \r
+ fclose(fp);\r
+ exit(0);\r
+ }\r
+ \r
+ printf("%s %s in %s",argv[1],(strstr(buffer,argv[1])) ? "was\r
+ found" : "was not found",argv[2]);\r
+ \r
+ /* Deallocate memory block before exiting */\r
+ free(buffer);\r
+ fclose(fp);\r
+ }\r
+ \r
+ VARIABLE ARGUMENT LISTS\r
+\r
+\r
+Some functions, such as printf(), accept a variable number and type of\r
+arguments. C provides a mechanism to write your own functions which can\r
+accept a variable argument list. This mechanism is the va_ family defined\r
+in the header file `stdarg.h'.\r
+\r
+There are three macros which allow implementation of variable argument\r
+lists; va_start(), va_arg() and va_end() and a variable type va_list\r
+which defines an array which holds the information required by the\r
+macros.\r
+\r
+va_start() takes two parameters, the first is the va_list variable and\r
+the second is the last fixed parameter sent to the function. va_start()\r
+must be called before attempting to access the variable argument list as\r
+it sets up pointers required by the other macros.\r
+\r
+va_arg() returns the next variable from the argument list. It is called\r
+with two parameters, the first is the va_list variable and the second is\r
+the type of the argument to be extracted. So, if the next variable in the\r
+argument list is an integer, it can be extracted with;\r
+\r
+\r
+ <int> = va_arg(<va_list>,int);\r
+\r
+va_end() is called after extracting all required variables from the\r
+argument list, and simply tidies up the internal stack if appropriate.\r
+va_end() accepts a single parameter, the va_list variable.\r
+\r
+The following simple example program illustrates the basis for a printf()\r
+type implementation where the types of the arguments is not known, but\r
+can be determined from the fixed parameter. This example only caters for\r
+integer, string and character types, but could easily by extended to\r
+cater for other variable types as well by following the method\r
+illustrated;\r
+\r
+ #include <stdarg.h>\r
+ \r
+ char *ITOS(long x, char *ptr)\r
+ {\r
+ /* Convert a signed decimal integer to a string */\r
+ \r
+ long pt[9] = { 100000000, 10000000, 1000000, 100000, 10000,\r
+ 1000, 100, 10, 1 };\r
+ int n;\r
+ \r
+ /* Check sign */\r
+ if (x < 0)\r
+ {\r
+ *ptr++ = '-';\r
+ /* Convert x to absolute */\r
+ x = 0 - x;\r
+ }\r
+ \r
+ for(n = 0; n < 9; n++)\r
+ {\r
+ if (x > pt[n])\r
+ {\r
+ *ptr++ = 48 + x / pt[n];\r
+ x %= pt[n];\r
+ }\r
+ }\r
+ return(ptr);\r
+ }\r
+ \r
+ void varfunc(char *format, ...)\r
+ {\r
+ va_list arg_ptr;\r
+ char output[1000];\r
+ char *ptr;\r
+ int bytes;\r
+ int x;\r
+ char *y;\r
+ char z;\r
+ \r
+ /* Initialise pointer to argument list */\r
+ va_start(arg_ptr, format);\r
+ \r
+ /* loop format string */\r
+ ptr = output;\r
+ bytes = 0;\r
+ while(*format)\r
+ {\r
+ /* locate next argument */\r
+ while(*format != '%')\r
+ {\r
+ *ptr++ = *format++;\r
+ bytes++;\r
+ }\r
+ /* A % has been located */\r
+ format++;\r
+ switch(*format)\r
+ {\r
+ case '%' : *ptr++ = '%';\r
+ break;\r
+ \r
+ case 'd' : /* integer expression follows */\r
+ x = va_arg(arg_ptr,int);\r
+ ptr = ITOS(x,ptr);\r
+ *ptr = 0;\r
+ format++;\r
+ bytes += strlen(output) - bytes;\r
+ break;\r
+ \r
+ case 's' : /* String expression follows */\r
+ y = va_arg(arg_ptr,char *);\r
+ strcat(output,y);\r
+ x = strlen(y);\r
+ format++;\r
+ ptr += x;\r
+ bytes += x;\r
+ break;\r
+ \r
+ case 'c' : /* Char expression follows */\r
+ z = va_arg(arg_ptr,char);\r
+ *ptr++ = z;\r
+ format++;\r
+ bytes++;\r
+ break;\r
+ }\r
+ \r
+ }\r
+ \r
+ /* Clean stack just in case! */\r
+ va_end(arg_ptr);\r
+ \r
+ /* Null terminate output string */\r
+ *ptr = 0;\r
+ \r
+ /* Display what we got */\r
+ printf("\nOUTPUT==%s",output);\r
+ }\r
+ \r
+ void main()\r
+ {\r
+ varfunc("%d %s %c",5,"hello world",49);\r
+ }\r
+ \r
+\r
+A simpler variation is to use vsprintf() rather than implementing our own\r
+variable argument list access. However, it is beneficial to understand\r
+how variable argument lists behave. The following is a simplification of\r
+the same program, but leaving the dirty work to the compiler;\r
+\r
+ #include <stdio.h>\r
+ #include <stdarg.h>\r
+ \r
+ void varfunc(char *format, ...)\r
+ {\r
+ va_list arg_ptr;\r
+ char output[1000];\r
+ \r
+ va_start(arg_ptr, format);\r
+ \r
+ vsprintf(output,format,arg_ptr);\r
+ \r
+ va_end(arg_ptr);\r
+ \r
+ /* Display what we got */\r
+ printf("\nOUTPUT==%s",output);\r
+ }\r
+ \r
+ void main()\r
+ {\r
+ varfunc("%d %s %c",5,"hello world",49);\r
+ }\r
+ \r
+ TRIGONOMETRY FUNCTIONS\r
+\r
+The ANSI standard on C defines a number of trigonometry functions, all of\r
+which accept an angle parameter in radians;\r
+\r
+\r
+FUNCTION PROTOTYPE DESCRIPTION\r
+acos double acos(double x) arc cosine of x\r
+asin double asin(double x) arc sine of x\r
+atan double atan(double x) arc tangent of x\r
+atan2 double atan2(double x, double y) arc tangent of y/x\r
+cos double cos(double x) cosine of x\r
+cosh double cosh(double x) hyperbolic cosine of x\r
+sin double sin(double x) sine of x\r
+sinh double sinh(double x) hyperbolic sine of x\r
+tan double tan(double x) tangent of x\r
+tanh double tanh(double x) hyperbolic tangent of x\r
+\r
+There are 2PI radians in a circle, therefore 1 radian is equal to 360/2PI\r
+degrees or approximately 57 degrees in 1 radian. The calculation of any\r
+of the above functions requires large floating point numbers to be used\r
+which is a very slow process. If you are going to use calls to a trig'\r
+function, it is a good idea to use a lookup table of values rather than\r
+keep on calling the function. This approach is used in the discussion on\r
+circle drawing later in this book.\r
+\r
+ \r
+ ATEXIT\r
+\r
+\r
+When ever a program terminates, it should close any open files (this is\r
+done for you by the C compiler's startup/termination code which it\r
+surrounds your program with), and restore the host computer to some\r
+semblance of order. Within a large program where exit may occur from a\r
+number of locations it is a pain to have to keep on writing calls to the\r
+cleanup routine. Fortunately we don't have to!\r
+\r
+The ANSI standard on C describes a function, atexit(), which registers\r
+the specified function, supplied as a parameter to atexit(), as a\r
+function which is called immediately before terminating the program. This\r
+function is called automatically, so the following program calls\r
+`leave()' whether an error occurs or not;\r
+\r
+ #include <stdio.h>\r
+ \r
+ void leave()\r
+ {\r
+ puts("\nBye Bye!");\r
+ }\r
+ \r
+ void main()\r
+ {\r
+ FILE *fp;\r
+ int a;\r
+ int b;\r
+ int c;\r
+ int d;\r
+ int e;\r
+ char text[100];\r
+ \r
+ atexit(leave);\r
+ \r
+ fp = fopen("data.txt","w");\r
+ \r
+ if(!fp)\r
+ {\r
+ perror("Unable to create file");\r
+ exit(0);\r
+ }\r
+ \r
+ fprintf(fp,"1 2 3 4 5 \"A line of numbers\"");\r
+ \r
+ fflush(fp);\r
+ \r
+ if (ferror(fp))\r
+ {\r
+ fputs("Error flushing stream",stderr);\r
+ exit(1);\r
+ }\r
+ \r
+ rewind(fp);\r
+ if (ferror(fp))\r
+ {\r
+ fputs("Error rewind stream",stderr);\r
+ exit(1);\r
+ }\r
+ \r
+ fscanf(fp,"%d %d %d %d %d %s",&a,&b,&c,&d,&e,text);\r
+ if (ferror(fp))\r
+ {\r
+ /* Unless you noticed the deliberate bug earlier */\r
+ /* The program terminates here */\r
+ fputs("Error reading from stream",stderr);\r
+ exit(1);\r
+ }\r
+ \r
+ printf("\nfscanf() returned %d %d %d %d %d %s",a,b,c,d,e,text);\r
+ }\r
+ \r
+ INCREASING SPEED\r
+\r
+\r
+In order to reduce the time your program spends executing it is essential\r
+to know your host computer. Most computers are very slow at displaying\r
+information on the screen. And the IBM PC is no exception to this. C\r
+offers various functions for displaying data, printf() being one of the\r
+most commonly used and also the slowest. Whenever possible try to use\r
+puts(varname) in place of printf("%s\n",varname). Remembering that puts()\r
+appends a newline to the string sent to the screen.\r
+\r
+When multiplying a variable by a constant which is a factor of 2 many C\r
+compilers will recognise that a left shift is all that is required in the\r
+assembler code to carry out the multiplication rapidly. When multiplying\r
+by other values it is often faster to do a multiple addition instead, so;\r
+\r
+\r
+ 'x * 3' becomes 'x + x + x'\r
+\r
+Don't try this with variable multipliers in a loop because it becomes\r
+very slow! But, where the multiplier is a constant it can be faster.\r
+(Sometimes!) Another way to speed up multiplication and division is with\r
+the shift commands, << and >>.\r
+\r
+The instruction x /= 2 can equally well be written x >>= 1, shift the\r
+bits of x right one place. Many compilers actually convert integer\r
+divisions by 2 into a shift right instruction. You can use the shifts for\r
+multiplying and dividing by 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024 &c.\r
+If you have difficulty understanding the shift commands consider the\r
+binary form of a number;\r
+\r
+\r
+ 01001101 equal to 77\r
+\r
+shifted right one place it becomes;\r
+\r
+ 00100110 equal to 38\r
+\r
+Try to use integers rather than floating point numbers where ever\r
+possible. Sometimes you can use integers where you didn't think you\r
+could! For example, to convert a fraction to a decimal one would normally\r
+say;\r
+\r
+ percentage = x / y * 100\r
+\r
+This requires floating point variables. However, it can also be written\r
+as;\r
+\r
+ z = x * 100;\r
+ percentage = z / y\r
+\r
+Which works fine with integers, so long as you don't mind the percentage\r
+being truncated. eg;\r
+\r
+ 5 / 7 * 100 is equal to 71.43 with floating point\r
+\r
+but with integers;\r
+\r
+ 5 * 100 / 7 is equal to 71\r
+\r
+(Assuming left to right expression evaluation. You may need to force the\r
+multiplication to be done first as with `z = x * 100').\r
+\r
+Here is a test program using this idea;\r
+\r
+ float funca(double x, double y)\r
+ {\r
+ return(x / y * 100);\r
+ }\r
+ \r
+ int funcb(int x,int y)\r
+ {\r
+ return(x * 100 / y);\r
+ }\r
+ \r
+ void main()\r
+ {\r
+ int n;\r
+ double x;\r
+ int y;\r
+ \r
+ for(n = 0; n < 5000; n++)\r
+ {\r
+ x = funca(5,7);\r
+ y = funcb(5,7);\r
+ }\r
+ }\r
+ \r
+And here is the results of the test program fed through a profiler;\r
+\r
+funca 1.9169 sec 96%\r
+|**********************************************\r
+funcb 0.0753 sec 3% |*\r
+\r
+You can clearly see that the floating point function is 25 times slower\r
+than the integer equivalent!\r
+\r
+NB: Although it is normal practice for expressions to be evaluated left\r
+to right, the ANSI standard on C does not specify an order of preference\r
+for expression evaluation, and as such you should check your compiler\r
+manual.\r
+\r
+Another way of increasing speed is to use pointers rather than array\r
+indexing. When you access an array through an index, for example with;\r
+\r
+ x = data[i];\r
+\r
+the compiler has to calculate the offset of data[i] from the beginning of\r
+the array. A slow process. Using pointers can often improve things as the\r
+following two bubble sorts, one with array indexing and one with pointers\r
+illustrates;\r
+\r
+ void BUBBLE()\r
+ {\r
+ /* Bubble sort using array indexing */\r
+ \r
+ int a;\r
+ int b;\r
+ int temp;\r
+ \r
+ for(a = lastone; a >= 0; a--)\r
+ {\r
+ for(b = 0; b < a; b++)\r
+ {\r
+ if(data[b] > data[b + 1])\r
+ {\r
+ temp = data[b];\r
+ data[b] = data[b + 1];\r
+ data[b + 1] = temp;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ \r
+ void PTRBUBBLE()\r
+ {\r
+ /* Bubble sort using pointers */\r
+ \r
+ int temp;\r
+ int *ptr;\r
+ int *ptr2;\r
+ \r
+ for(ptr = &data[lastone]; ptr >= data; ptr--)\r
+ {\r
+ for(ptr2 = data; ptr2 < ptr; ptr2++)\r
+ {\r
+ if(*ptr2 > *(ptr2 + 1))\r
+ {\r
+ temp = *ptr2;\r
+ *ptr2 = *(ptr2 + 1);\r
+ *(ptr2 + 1) = temp;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ \r
+Here are the profiler results for the two versions of the same bubble\r
+sort operating on the same 1000 item, randomly sorted list;\r
+\r
+BUBBLE 3.1307 sec 59% |******************************************\r
+PTRBUBBLE 2.1686 sec 40% |***************************\r
+\r
+\r
+Here is another example of how to initialise an array using first the\r
+common indexing approach, and secondly the pointer approach;\r
+\r
+ /* Index array initialisation */\r
+ int n;\r
+ \r
+ for(n = 0; n < 1000; n++)\r
+ data[n] = random(1000);\r
+ \r
+ \r
+ /* Pointer array initialisation */\r
+ int *n;\r
+ \r
+ for(n = data; n < &data[1000]; n++)\r
+ *n = random(1000);\r
+ \r
+\r
+Needless to say, the pointer approach is faster than the index. The\r
+pointer approach is only really of benefit when an array is going to be\r
+traversed, as in the above examples. In the case of say a binary search\r
+where a different and non-adjacent element is going to be tested each\r
+pass then the pointer approach is no better than using array indexing.\r
+\r
+The exception to this rule of using pointers rather than indexed access,\r
+comes with pointer to pointers. Say your program has declared a table of\r
+static data, such as:\r
+\r
+static char *colours[] = { "Black", "Blue", "Green", "Yellow", "Red",\r
+"White" };\r
+\r
+It is faster to access the table with colours[n] than it is with a\r
+pointer, since each element in the table colours[], is a pointer. If you\r
+need to scan a string table for a value you can use this very fast\r
+approach instead;\r
+\r
+First the table is changed into a single string, with some delimiter\r
+between the elements.\r
+\r
+ static char *colours = "Black/Blue/Green/Yellow/Red/White";\r
+\r
+Then to confirm that a value is held in the table you can use strstr();\r
+\r
+ result = strstr(colours,"Cyan");\r
+\r
+Using in-line assembler code can provide the greatest speed increase.\r
+Care must be taken however not to interfere with the compiled C code. It\r
+is usually safe to write a complete function with in-line assembler code,\r
+but mixing in-line assembler with C code can be hazardous. As a rule of\r
+thumb, get your program working without assembler code, and then if you\r
+want to use in-line assembler, convert small portions of the code at a\r
+time, testing the program at each stage. Video I/O is a very slow process\r
+with C, and usually benefits from in-line assembler, and we have used\r
+this principle quite widely in the example programs which follow later.\r
+\r
+ \r
+ PC GRAPHICS\r
+\r
+When programming graphics you should bear in mind that they are a machine\r
+dependant subject. Code to produce graphics on an IBM PC will not port to\r
+an Amiga, or VAX or any other type of computer.\r
+\r
+\r
+\r
+Introduction To PC Graphics\r
+\r
+The IBM PC and compatible range of computers display information on a\r
+visual display unit (VDU). To enable the computer to send information to\r
+the VDU a component is included within the computer called a "display\r
+card". There are various display cards and VDUs which have been produced\r
+for the IBM PC range of computers; monochrome display adapter (MDA),\r
+colour graphics adapter (CGA), Hercules graphics card (HGC), Enhanced\r
+graphics adapter (EGA), video graphics array (VGA), super video graphics\r
+array (SVGA), memory controller gate array (MCGA), 8514/A and the Txas\r
+Instruments Graphics Architecture (TIGA). For simplicity, this section\r
+will concern itself only with the three more common types of display;\r
+\r
+ CGA, EGA and VGA\r
+\r
+Information about the VGA display is also relevant to the SVGA display\r
+which in simple terms can do the same and more. This section will not\r
+concern itself with monochrome displays since they are of limited use in\r
+graphics work.\r
+\r
+\r
+Display Modes\r
+\r
+When an IBM PC computer is first switched on is set to display 80 columns\r
+by 25 rows of writing. This measurement, 80 x 25 is called the\r
+"resolution". A display mode which is intended for displaying writing is\r
+called a "text" mode. Where as a display mode which is intended for\r
+displaying pictures is called a "graphics" mode.\r
+\r
+If you look closely at the display you will see that each displayed\r
+character is comprised of dots. In reality the entire display is\r
+comprised of dots, called "pixels", which may be set to different\r
+colours. In text display modes these pixels are not very relevant,\r
+however, in graphics display modes each pixel may be selected and set by\r
+a program. The size of the pixels varies with the display resolution. In\r
+80 x 25 text mode the pixels are half the width they are in 40 x 25 text\r
+display mode.\r
+\r
+Depending upon the display card installed in the computer, there are a\r
+number of display modes which may be used;\r
+\r
+\r
+MODE TYPE RESOLUTION COLOURS\r
+ \r
+ 0 Text 40 x 25 4 (CGA), 16 (EGA,\r
+ VGA) Shades of\r
+ grey\r
+ 1 Text 40 x 25 4 (CGA), 16 (EGA,\r
+ VGA)\r
+ 2 Text 80 x 25 4 (CGA), 16 (EGA,\r
+ VGA) Shades of\r
+ grey\r
+ 3 Text 80 x 25 4 (CGA), 16 (EGA,\r
+ VGA)\r
+ 4 Graphics 320 x 200 4\r
+ 5 Graphics 320 x 200 4 (grey on CGA\r
+ and EGA)\r
+ 6 Graphics 640 x 200 2\r
+ 7 Text 80 x 25 Mono (EGA, VGA)\r
+13 Graphics 320 x 200 16 (EGA, VGA)\r
+14 Graphics 640 x 200 16 (EGA, VGA)\r
+15 Graphics 640 x 350 Mono (EGA, VGA)\r
+16 Graphics 640 x 350 16 (EGA, VGA)\r
+17 Graphics 640 x 480 2 (VGA)\r
+18 Graphics 640 x 480 16 (VGA)\r
+19 Graphics 320 x 200 256 (VGA)\r
+\r
+The term resolution in graphics modes refers to the number of pixels\r
+across and down the VDU. The larger the number of pixels, the smaller\r
+each is and the sharper any displayed image appears. As you can see from\r
+the table, the VGA display can produce a higher resolution than the other\r
+display cards, resulting in sharper images being produced.\r
+\r
+\r
+The CGA display card can produce a maximum resolution of 320 x 200\r
+pixels, where as the VGA display card can produce a resolution of 640 x\r
+480 pixels. This is why writing on a VGA VDU looks so much sharper than\r
+the writing displayed on a CGA VDU.\r
+\r
+\r
+\r
+Accessing The Display\r
+\r
+Inside the IBM PC computer is a silicon chip called the BIOS ROM, this\r
+chip contains functions which may be called by an external computer\r
+program to access the display card, which in turn passes the information\r
+on to the VDU. The BIOS display functions are all accessed by generating\r
+interrupt 10 calls, with the number of the appropriate function stored in\r
+the assembly language AH register.\r
+\r
+A programmer interested in creating graphics displays must first be able\r
+to switch the display card to an appropriate graphics mode. This is\r
+achieved by calling the BIOS display function 0, with th number of the\r
+desired display mode from the table stored in the assembly language AL\r
+register thus the following assembly language code segment will switch\r
+the display card to CGA graphics mode 4, assuming that is that the\r
+display card is capable of this mode;\r
+\r
+ mov ah , 00\r
+ mov al , 04\r
+ int 10h\r
+\r
+\r
+A C function for selecting video display modes can be written;\r
+\r
+ #include <dos.h>\r
+ \r
+ void setmode(unsigned char mode)\r
+ {\r
+ /* Sets the video display mode */\r
+ \r
+ union REGS inregs outreg;\r
+ \r
+ inreg.h.ah = 0;\r
+ inreg.h.al = mode;\r
+ int86(0x10,&inreg,&outregs);\r
+ }\r
+ \r
+Any graphics are created by setting different pixels to different\r
+colours, this is termed "plotting", and is achieved by calling BIOS\r
+display function 12 with the pixel's horizontal coordinate in the\r
+assembly language CX register and it's vertical coordinate in the\r
+assembly language DX register and the required colour in the assembly\r
+language AL register thus;\r
+\r
+\r
+ mov ah, 12\r
+ mov al, colour\r
+ mov bh, 0\r
+ mov cx, x_coord\r
+ mov dx, y_coord\r
+ int 10h\r
+\r
+The corresponding C function is;\r
+\r
+ #include <dos.h>\r
+ \r
+ void plot(int x_coord, int y_coord, unsigned char colour)\r
+ {\r
+ /* Sets the colour of a pixel */\r
+ \r
+ union REGS regs;\r
+ \r
+ regs.h.ah = 12;\r
+ regs.h.al = colour;\r
+ regs.h.bh = 0;\r
+ regs.x.cx = x_coord;\r
+ regs.x.dx = y_coord;\r
+ int86(0x10,®s,®s);\r
+ }\r
+\r
+The inverse function of plot is to read the existing colour setting of a\r
+pixel. This is done by calling BIOS ROM display function 13, again with\r
+the pixel's horizontal coordinate in the assembly language CX register\r
+and it's vertical coordinate in the assembly language DX register. This\r
+function then returns the pixel's colour in the assembly language AL\r
+register;\r
+\r
+\r
+ #include <dos.h>\r
+ \r
+ unsigned char get_pixel(int x_coord, int y_coord)\r
+ {\r
+ /* Reads the colour of a pixel */\r
+ \r
+ union REGS inreg, outreg;\r
+ \r
+ inreg.h.ah = 13;\r
+ inreg.h.bh = 0;\r
+ inreg.x.cx = x_coord;\r
+ inreg.x.dx = y_coord;\r
+ int86(0x10,&inreg,&outreg);\r
+ return(outreg.h.al);\r
+ }\r
+\r
+\r
+Colour And The CGA\r
+\r
+The CGA display card can display a maximum of 4 colours simultaneously at\r
+any time. However, the display card can generate a total of 8 colours.\r
+There are two sets of colours, called "palettes". The first palette\r
+contains the colours;\r
+\r
+ background, cyan, magenta and white.\r
+\r
+the second palette contains the colours;\r
+\r
+ background, green, red and yellow.\r
+\r
+Colour 0 is always the same as the background colour.\r
+\r
+The pixels displayed on the VDU take their colours from the currently\r
+active palette, and are continuously being refreshed. So, if the active\r
+palette changes, so to do the colours of the displayed pixels on the VDU.\r
+\r
+Selection of the active CGA palette is achieved by calling the BIOS\r
+display function 11 with the number of the desired palette (either 0 or\r
+1) in the assembly language BH register;\r
+\r
+\r
+ mov ah, 11\r
+ mov bh, palette\r
+ int 10h\r
+\r
+The C function for selecting the CGA palette is;\r
+\r
+ void palette(unsigned char palette)\r
+ {\r
+ union REGS inreg, outreg;\r
+ \r
+ inreg.h.ah = 11;\r
+ inreg.h.bh = palette;\r
+ int86(0x10,&inreg,&outreg);\r
+ }\r
+ \r
+The background colour may be selected independantly from any of the eight\r
+available colours by calling the same BIOS display function with a value\r
+of 0 stored in the assembly language BH register and the desired\r
+background colour in the assembly language BL register;\r
+\r
+\r
+ mov ah, 11\r
+ mov bh, 0\r
+ mov bl, colour\r
+ int 10h\r
+\r
+In C this function can be written;\r
+\r
+ void background(unsigned char colour)\r
+ {\r
+ union REGS inreg, outreg;\r
+ \r
+ inreg.h.ah = 11;\r
+ inreg.h.bh = 0;\r
+ inreg.h.bl = colour;\r
+ int86(0x10,&inreg,&outreg);\r
+ }\r
+ \r
+The background colours available are;\r
+\r
+ 0 Black\r
+ 1 Blue\r
+ 2 Green\r
+ 3 Cyan\r
+ 4 Red\r
+ 5 Magenta\r
+ 6 Yellow\r
+ 7 White\r
+\r
+\r
+Colour And The EGA\r
+\r
+The EGA display card can display a maximum of 16 colours simultaneously\r
+at any time. The colour of all pixels is continuously refreshed by the\r
+display card by reading the colour from the EGA palette. Unlike the CGA\r
+display card, the EGA display card allows you to redefine any or all of\r
+the colours in the palette. Unfortunately only the first 8 colours may be\r
+loaded into other palette colours.\r
+\r
+The colours are;\r
+\r
+ 0 Black\r
+ 1 Blue\r
+ 2 Green\r
+ 3 Cyan\r
+ 4 Red\r
+ 5 Magenta\r
+ 6 Brown\r
+ 7 Light grey\r
+ 8 Dark grey\r
+ 9 Light blue\r
+ 10 Light green\r
+ 11 Light cyan\r
+ 12 Light red\r
+ 13 Light magenta\r
+ 14 Yellow\r
+ 15 White\r
+\r
+Changing a palette colour is achieved by calling the BIOS display\r
+function 16 with a value of 0 in the assembly language AL register, the\r
+colour value (0 to 7) in the assembly language BH register and the number\r
+of the palette colour (0 to 15) in the assembly language BL register\r
+thus;\r
+\r
+\r
+ mov ah,16\r
+ mov al,0\r
+ mov bl,palette\r
+ mov bh,colour\r
+ int 10h\r
+\r
+In C this function may be written;\r
+\r
+ void ega_palette(unsigned char colour, unsigned char palette)\r
+ {\r
+ union REGS inreg,outreg;\r
+ \r
+ inreg.h.ah = 16;\r
+ inreg.h.al = 0;\r
+ inreg.h.bl = palette;\r
+ inreg.h.bh = colour;\r
+ \r
+ int86(0x10,&inreg,&outreg);\r
+ }\r
+\r
+\r
+\r
+Colour And The VGA\r
+\r
+The VGA display card can display a maximum of 256 colours on the VDU at\r
+any one time, these colours are defined by information held in 256\r
+special registers called "DAC" registers. As with the CGA and EGA\r
+displays, the colour of displayed pixels is continuously being refreshed,\r
+and as such any change to a DAC register is immediately visible. Each DAC\r
+register has three component data parts which record the amount of green,\r
+blue and red colours which make up the displayed colour. Each of these\r
+seperate data components can hold a value between 0 and 63 giving the VGA\r
+display card the ability to display 262,144 colours! Although only a\r
+small subset of them can be displayed at any one time.\r
+\r
+Setting the value of a DAC register is achieved by calling the BIOS\r
+display function 16 with a value of 16 stored in the assembly language AL\r
+register, the green value stored in the assembly language CH register,\r
+the blue value stored in the assembly language CL register and the red\r
+value stored in the assembly language DH register and the number of the\r
+DAC register to be set stored in the assembly language BX register;\r
+\r
+\r
+ mov ah,16\r
+ mov al,16\r
+ mov ch,green\r
+ mov cl,blue\r
+ mov dh,red\r
+ mov bx,dac\r
+ int 10h\r
+\r
+\r
+The C function to set a DAC register looks lik this;\r
+\r
+ void set_dac(int dac, unsigned char green, unsigned char blue,\r
+ unsigned char red)\r
+ {\r
+ union REGS regs;\r
+ \r
+ regs.h.ah = 16;\r
+ regs.h.al = 16;\r
+ regs.x.bx = dac;\r
+ regs.h.ch = green;\r
+ regs.h.cl = blue;\r
+ regs.h.dh = red;\r
+ int86(0x10,®s,®s);\r
+ }\r
+ \r
+\r
+\r
+Displaying Text\r
+\r
+The BIOS ROM provides three functions for displaying a single character.\r
+The first function to consider is the one used extensively by DOS for\r
+displaying messages, this is function 14 called "write text in teletype\r
+mode". This function interprets some control characters; bell (ascii 7),\r
+backspace (ascii 8), carriage return (ascii 10) and line feed (ascii 13)\r
+but all other ascii codes are displayed, and the current cursor position\r
+updated accordingly, moving down a row when a character is displayed in\r
+the far right column. To call this function the assembly language\r
+register AL holds the ascii code of the character to be displayed and\r
+assembly language register BL holds the foreground colour for the\r
+character to be displayed in if a graphics mode is active;\r
+\r
+\r
+ mov ah,14\r
+ mov al,character\r
+ mov bh,0\r
+ mov bl,foreground\r
+ int 10h\r
+\r
+\r
+A C function for accessing the write text in teletype mode may be written\r
+like this;\r
+\r
+ #include <dos.h>\r
+ \r
+ void teletype(unsigned char character, unsigned char foreground)\r
+ {\r
+ union REGS inreg, outreg;\r
+ \r
+ inreg.h.ah = 14;\r
+ inreg.h.al = character;\r
+ inreg.h.bh = 0;\r
+ inreg.h.bl = foreground;\r
+ int86(0x10,&inrg,&outreg);\r
+ }\r
+ \r
+The second BIOS ROM display function for displaying a character allows\r
+the foreground and background colours of the displayed character to be\r
+defined. It also allows multiple copies of the character to be displayed\r
+one after another automatically displaying subsequent characters at the\r
+next display position, although the current cursor position is not\r
+changed by this function.\r
+\r
+This function is called "write character and attribute", and is BIOS ROM\r
+display function number 9. It is called with the ascii code of the\r
+character to be displayed in the assembly language AL register, the\r
+display page in assembly language register BH, the foreground colour in\r
+the first four bits of the assembly language register BL and the\r
+background colour in the last four bits of the assembly language register\r
+BL, the number of times the character is to be displayed is stored in the\r
+assembly language CX register thus;\r
+\r
+\r
+ mov ah,9\r
+ mov al,character\r
+ mov bh,0\r
+ mov bl,foreground + 16 * background\r
+ mov cx,number\r
+ int 10h\r
+\r
+And in C;\r
+\r
+ #include <dos.h>\r
+ \r
+ void char_attrib(unsigned char character, unsigned char foreground,\r
+ unsigned char background, int number)\r
+ {\r
+ union REGS inreg,outreg;\r
+ \r
+ inreg.h.ah = 9;\r
+ inreg.h.al = character;\r
+ inreg.h.bh = 0;\r
+ inreg.h.bl = (background << 4) + foreground;\r
+ inreg.x.cx = number;\r
+ int86(0x10,&inreg,&outreg);\r
+ }\r
+\r
+The last BIOS ROM display function for displaying a character retains the\r
+foreground and background colours of the display position.\r
+\r
+This function is called "write character", and is BIOS ROM display\r
+function number 10. It is identical to BIOS ROM display function 9 except\r
+that the colours of the displayed character are those which are prevalent\r
+at the display position, except in graphics modes when the foreground\r
+colour of the character is determined by the value in the assembly\r
+language BL register. Its use is as follows;\r
+\r
+\r
+ mov ah,10\r
+ mov al,character\r
+ mov bh,0\r
+ mov bl,foreground ; For graphics modes ONLY\r
+ mov cx,number\r
+ int 10h\r
+\r
+And in C;\r
+\r
+ #include <dos.h>\r
+ \r
+ void char_attrib(unsigned char character, unsigned char foreground,\r
+ int number)\r
+ {\r
+ union REGS inreg,outreg;\r
+ \r
+ inreg.h.ah = 10;\r
+ inreg.h.al = character;\r
+ inreg.h.bh = 0;\r
+ inreg.h.bl = foreground; /* For graphics modes ONLY */\r
+ inreg.x.cx = number;\r
+ int86(0x10,&inreg,&outreg);\r
+ }\r
+ \r
+\r
+Positioning of the text cursor is provided for by the ROM BIOS display\r
+function number 2. It is called with the row number in the assembly\r
+language register DH and the column number in the assembly language\r
+register DL;\r
+\r
+ mov ah,2\r
+ mov bh,0\r
+ mov dh,row\r
+ mov dl,column\r
+ int 10h\r
+\r
+The corresponding function in C looks like this;\r
+\r
+ #include <dos.h>\r
+ \r
+ void at(unsigned char row, unsigned char column)\r
+ {\r
+ union REGS regs;\r
+ \r
+ regs.h.ah = 2;\r
+ regs.h.bh = 0;\r
+ regs.h.dh = row;\r
+ regs.h.dl = column;\r
+ int86(0x10,®s,®s);\r
+ }\r
+\r
+From these basic functions a more useful replacement for the C language's\r
+"printf()" function can be written which allows data to be displayed at\r
+the current cursor position, previously set by a call to "at()", with\r
+prescribed attributes;\r
+\r
+\r
+ #include <dos.h>\r
+ #include <stdarg.h>\r
+ \r
+ void at(unsigned char row, unsigned char column)\r
+ {\r
+ union REGS regs;\r
+ \r
+ regs.h.ah = 2;\r
+ regs.h.bh = 0;\r
+ regs.h.dh = row;\r
+ regs.h.dl = column;\r
+ int86(0x10,®s,®s);\r
+ }\r
+ \r
+ void xprintf(unsigned char foreground, unsigned char background,\r
+ char *format,...)\r
+ {\r
+ union REGS inreg,outreg;\r
+ \r
+ va_list arg_ptr;\r
+ static char output[1000];\r
+ unsigned char col;\r
+ unsigned char row;\r
+ unsigned char n;\r
+ unsigned char p;\r
+ unsigned char text;\r
+ unsigned char attr;\r
+ \r
+ /* Convert foreground and background colours into a single\r
+ attribute */\r
+ attr = (background << 4) + foreground;\r
+ \r
+ /* Copy data into a single string */\r
+ va_start(arg_ptr, format);\r
+ vsprintf(output, format, arg_ptr);\r
+ \r
+ /* Determine number of display columns */\r
+ inreg.h.ah = 15;\r
+ int86(0x10,&inreg,&outreg);\r
+ n = outreg.h.ah;\r
+ \r
+ /* Determine current cursor position */\r
+ inreg.h.ah = 3;\r
+ inreg.h.bh = 0;\r
+ int86(0x10,&inreg,&outreg);\r
+ row = outreg.h.dh;\r
+ col = outreg.h.dl;\r
+ \r
+ /* Now display data */\r
+ p = 0;\r
+ while (output[p])\r
+ {\r
+ /* Display this character */\r
+ inreg.h.bh = 0;\r
+ inreg.h.bl = attr;\r
+ inreg.x.cx = 01;\r
+ inreg.h.ah = 9;\r
+ inreg.h.al = output[p++];\r
+ int86(0x10,&inreg,&outreg);\r
+ \r
+ /* Update cursor position */\r
+ /* moving down a row if required */\r
+ col++;\r
+ if (col < (n - 1))\r
+ at(row, col);\r
+ else\r
+ {\r
+ col = 0;\r
+ at(++row, col);\r
+ }\r
+ }\r
+ }\r
+ \r
+This function, "xprintf()" illustrates two more functions of the BIOS\r
+ROM. The first is the call to function 15 which returns the number of\r
+text display columns for the currently active display mode.\r
+\r
+The other function illustrated, but not yet discussed, is BIOS ROM\r
+function 3 which returns information about the cursor. The cursor's row\r
+is returned in the assembly language register DH, and it's column in the\r
+assembly language register DL.\r
+\r
+\r
+ \r
+ ADVANCED GRAPHICS ON THE IBM PC\r
+\r
+This section aims to reveal more about the graphics facilities offered by\r
+the IBM PC, in particular topics which are of a more complex nature than\r
+those addressed in the previous section.\r
+\r
+\r
+\r
+Display Pages\r
+\r
+The information for display by the display card is stored in an area of\r
+memory called the "video RAM". The size of the video RAM varies from one\r
+display card to another, and the amount of video RAM required for a\r
+display varies with the selected display mode. Display modes which do not\r
+require all of the video RAM use the remaining video RAM for additional\r
+display pages.\r
+\r
+\r
+MODE PAGES\r
+ 0 8\r
+ 1 8\r
+ 2 4 (CGA) 8 (EGA, VGA)\r
+ 3 4 (CGA) 8 (EGA, VGA)\r
+ 4 1\r
+ 5 1\r
+ 6 1\r
+ 7 8 (EGA, VGA)\r
+13 8 (EGA, VGA)\r
+14 4 (EGA, VGA)\r
+15 2 (EGA, VGA)\r
+16 2 (EGA, VGA)\r
+17 1 (VGA)\r
+18 1 (VGA)\r
+19 1 (VGA)\r
+\r
+Many of the BIOS ROM display functions allow selection of the display\r
+page to be written to, regardless of which page is currently being\r
+displayed.\r
+\r
+The display card continuously updates the VDU from the information in the\r
+active display page. Changing the active display page instantaneously\r
+changes the display.\r
+\r
+This provides the graphics programmer with the means to build a display\r
+on an undisplayed page, and to then change the active display page so\r
+that the viewer does not see the display being drawn.\r
+\r
+Selection of the active display page is achieved by calling BIOS ROM\r
+display function 5 with the number of the required display page stored in\r
+the assembly language register AL;\r
+\r
+ mov ah,5\r
+ mov al,page\r
+ int 10h\r
+\r
+Or, from C this function becomes;\r
+\r
+ #include <dos.h>\r
+ \r
+ void set_page(unsigned char page)\r
+ {\r
+ union REGS inreg, outreg;\r
+ \r
+ inreg.h.ah = 5;\r
+ inreg.h.al = page;\r
+ int86(0x10,&inreg,&outreg);\r
+ }\r
+ \r
+The display page to which BIOS ROM display functions write is decided by\r
+the value stored in the assembly language BH register. The functions for\r
+setting a pixel's colour may be amended thus;\r
+\r
+ mov ah, 12\r
+ mov al, colour\r
+ mov bh, page\r
+ mov cx, x_coord\r
+ mov dx, y_coord\r
+ int 10h\r
+\r
+And the corresponding C function becomes;\r
+\r
+ #include <dos.h>\r
+ \r
+ void plot(int x_coord, int y_coord, unsigned char colour, unsigned\r
+ char page)\r
+ {\r
+ /* Sets the colour of a pixel */\r
+ \r
+ union REGS inreg, outreg;\r
+ \r
+ inreg.h.ah = 12;\r
+ inreg.h.al = colour;\r
+ inreg.h.bh = page;\r
+ inreg.x.cx = x_coord;\r
+ inreg.x.dx = y_coord;\r
+ int86(0x10,&inreg,&outreg);\r
+ }\r
+\r
+The currently active display page can be determined by calling BIOS ROM\r
+display function 15. This function returns the active display page in the\r
+assembly language register BH;\r
+\r
+ mov ah,15\r
+ int 10h\r
+ ; BH now holds active page number\r
+\r
+ \r
+ Advanced Text Routines\r
+\r
+When the IBM PC display is in a text mode a blinking cursor is displayed\r
+at the current cursor position. This cursor is formed of a rectangle\r
+which is one complete character width, but it's top and bottom pixel\r
+lines are definable within the limits of the character height by calling\r
+BIOS ROM display function 1. A CGA display has a character height of 8\r
+pixel lines, an EGA display has a character height of 14 lines and a VGA\r
+display has a character height of 16 lines.\r
+\r
+BIOS ROM function 1 is called with the top pixel line number of the\r
+desired cursor shape in assembly language register CH and the bottom\r
+pixel line number in assembly language register CL;\r
+\r
+\r
+ mov ah,1\r
+ mov ch,top\r
+ mov cl,bottom\r
+ int 10h\r
+\r
+A C function to set the cursor shape may be be written thus;\r
+\r
+ #include <dos.h>\r
+ \r
+ void setcursor(unsigned char top, unsigned char bottom)\r
+ {\r
+ union REGS inreg, outreg;\r
+ \r
+ inreg.h.ch = start;\r
+ inreg.h.cl = end;\r
+ inreg.h.ah = 1;\r
+ int86(0x10, &inreg, &outreg);\r
+ }\r
+ \r
+If the top pixel line is defined as larger than the bottom line, then the\r
+cursor will appear as a pair of parallel rectangles.\r
+\r
+The cursor may be removed from view by calling BIOS ROM display function\r
+1 with a value of 32 in the assembly language CH register.\r
+\r
+The current shape of the cursor can be determined by calling BIOS ROM\r
+function 3, which returns the top pixel line number of the cursor shape\r
+in the assembly language CH register, and the bottom line number in the\r
+assembly language register CL.\r
+\r
+Two functions are provided by the BIOS ROM for scrolling of the currently\r
+active display page. These are function 6, which scrolls the display up\r
+and function 7 which scrolls the display down.\r
+\r
+Both functions accept the same parameters, these being the number of\r
+lines to scroll in the assembly language register AL, the colour\r
+attribute for the resulting blank line in the assembly language BH\r
+register, the top row of the area to be scrolled in the assembly language\r
+CH register, the left column of the area to be scrolled in the assembly\r
+language CL register, the bottom row to be scrolled in the assembly\r
+language DH register and the right most column to be scrolled in the\r
+assembly language DL register.\r
+\r
+If the number of lines being scrolled is greater than the number of lines\r
+in the specified area, then the result is to clear the specified area,\r
+filling it with spaces in the attribute specified in the assembly\r
+language BH register.\r
+\r
+\r
+Scrolling\r
+\r
+A C function to scroll the entire screen down one line can be written\r
+thus;\r
+\r
+ #include <dos.h>\r
+ \r
+ void scroll_down(unsigned char attr)\r
+ {\r
+ union REGS inreg, outreg;\r
+ \r
+ inreg.h.al = 1;\r
+ inreg.h.cl = 0;\r
+ inreg.h.ch = 0;\r
+ inreg.h.dl = 79;\r
+ inreg.h.dh = 24; /* Assuming a 25 line display */\r
+ inreg.h.bh = attr;\r
+ inreg.h.ah = 7;\r
+ int86(0x10, &inreg, &outreg);\r
+ }\r
+\r
+\r
+Clear Screen\r
+A simple clear screen function can be written in C based upon the\r
+"scroll_down()" function simply by changing the value assigned to\r
+inreg.h.al to 0;\r
+\r
+ #include <dos.h>\r
+ \r
+ void cls(unsigned char attr)\r
+ {\r
+ union REGS inreg, outreg;\r
+ \r
+ inreg.h.al = 0;\r
+ inreg.h.cl = 0;\r
+ inreg.h.ch = 0;\r
+ inreg.h.dl = 79;\r
+ inreg.h.dh = 24; /* Assuming a 25 line display */\r
+ inreg.h.bh = attr;\r
+ inreg.h.ah = 7;\r
+ int86(0x10, &inreg, &outreg);\r
+ }\r
+\r
+\r
+\r
+Windowing\r
+Windowing functions need to preserve the display they overwrite, and\r
+restore it when the window is removed from display. The BIOS ROM provides\r
+a display function which enables this to be done.\r
+\r
+Function 8 requires the appropriate display page number to be stored in\r
+assembly language register BH, and then when called it returns the ascii\r
+code of the character at the current cursor position of that display page\r
+in the assembly language AL register, and the display attribute of the\r
+character in the assembly language AH register.\r
+\r
+The following C functions allow an area of the display to be preserved,\r
+and later restored;\r
+\r
+ #include <dos.h>\r
+ \r
+ void at(unsigned char row, unsigned char column, unsigned char page)\r
+ {\r
+ /* Position the cursor */\r
+ \r
+ union REGS inreg,outreg;\r
+ \r
+ inreg.h.ah = 2;\r
+ inreg.h.bh = page;\r
+ inreg.h.dh = row;\r
+ inreg.h.dl = column;\r
+ int86(0x10,&inreg,&outreg);\r
+ }\r
+ \r
+ void get_win(unsigned char left, unsigned char top, unsigned char\r
+ right,unsigned char bottom, unsigned char page, char *buffer)\r
+ {\r
+ /* Read a text window into a variable */\r
+ \r
+ union REGS inreg,outreg;\r
+ \r
+ unsigned char old_left;\r
+ unsigned char old_row;\r
+ unsigned char old_col;\r
+ \r
+ /* save current cursor position */\r
+ inreg.h.ah = 3;\r
+ inreg.h.bh = page;\r
+ int86(0x10,&inreg,&outreg);\r
+ old_row = outreg.h.dh;\r
+ old_col = outreg.h.dl;\r
+ \r
+ while(top <= bottom)\r
+ {\r
+ old_left = left;\r
+ while(left <= right)\r
+ {\r
+ at(top,left,page);\r
+ inreg.h.bh = page;\r
+ inreg.h.ah = 8;\r
+ int86(0x10,&inreg,&outreg);\r
+ *buffer++ = outreg.h.al;\r
+ *buffer++ = outreg.h.ah;\r
+ left++;\r
+ }\r
+ \r
+ left = old_left;\r
+ top++;\r
+ }\r
+ \r
+ /* Restore cursor to original location */\r
+ at(old_row,old_col,page);\r
+ }\r
+ \r
+ void put_win(unsigned char left, unsigned char top, unsigned char\r
+ right, unsigned char bottom, unsigned char page, char\r
+ *buffer)\r
+ {\r
+ /* Display a text window from a variable */\r
+ \r
+ union REGS inreg,outreg;\r
+ \r
+ unsigned char old_left;\r
+ unsigned char chr;\r
+ unsigned char attr;\r
+ unsigned char old_row;\r
+ unsigned char old_col;\r
+ \r
+ /* save current cursor position */\r
+ inreg.h.ah = 3;\r
+ inreg.h.bh = page;\r
+ int86(0x10,&inreg,&outreg);\r
+ old_row = outreg.h.dh;\r
+ old_col = outreg.h.dl;\r
+ \r
+ while(top <= bottom)\r
+ {\r
+ old_left = left;\r
+ while(left <= right)\r
+ {\r
+ at(top,left,page);\r
+ chr = *buffer++;\r
+ attr = *buffer++;\r
+ inreg.h.bh = page;\r
+ inreg.h.ah = 9;\r
+ inreg.h.al = chr;\r
+ inreg.h.bl = attr;\r
+ inreg.x.cx = 1;\r
+ int86(0x10,&inreg,&outreg);\r
+ left++;\r
+ }\r
+ left = old_left;\r
+ top++;\r
+ }\r
+ \r
+ /* Restore cursor to original location */\r
+ at(old_row,old_col,page);\r
+ }\r
+ \r
+ DIRECT VIDEO ACCESS WITH THE IBM PC\r
+\r
+Accessing video RAM directly is much faster than using the BIOS ROM\r
+display functions. There are problems however. Different video modes\r
+arrange their use of video RAM in different ways so a number of functions\r
+are required for plotting using direct video access, where as only one\r
+function is required if use is made of the BIOS ROM display function.\r
+\r
+The following C function will set a pixel in CGA display modes 4 and 5\r
+directly;\r
+\r
+\r
+ void dplot4(int y, int x, int colour)\r
+ {\r
+ /* Direct plotting in modes 4 & 5 ONLY! */\r
+ \r
+ union mask\r
+ {\r
+ char c[2];\r
+ int i;\r
+ }bit_mask;\r
+ \r
+ int index;\r
+ int bit_position;\r
+ \r
+ unsigned char t;\r
+ char xor;\r
+ \r
+ char far *ptr = (char far *) 0xB8000000;\r
+ \r
+ bit_mask.i = 0xFF3F;\r
+ \r
+ if ( y < 0 || y > 319 || x < 0 || x > 199)\r
+ return;\r
+ \r
+ xor = colour & 128;\r
+ \r
+ colour = colour & 127;\r
+ \r
+ bit_position = y % 4;\r
+ \r
+ colour <<= 2 * (3 - bit_position);\r
+ \r
+ bit_mask.i >>= 2 * bit_position;\r
+ \r
+ index = x * 40 + (y / 4);\r
+ \r
+ if (x % 2)\r
+ index += 8152;\r
+ \r
+ \r
+ \r
+ \r
+ if (!xor)\r
+ {\r
+ t = *(ptr + index) & bit_mask.c[0];\r
+ *(ptr + index) = t | colour;\r
+ }\r
+ else\r
+ {\r
+ t = *(ptr + index) | (char)0;\r
+ *(ptr + index) = t ^ colour;\r
+ }\r
+ }\r
+ \r
+\r
+Direct plotting in VGA mode 19 is very much simpler;\r
+\r
+ void dplot19(int x, int y, unsigned char colour)\r
+ {\r
+ /* Direct plot in mode 19 ONLY */\r
+ char far *video;\r
+ \r
+ video = MK_FP(0xA000,0);\r
+ video[x + y * 320] = colour;\r
+}\r
+ \r
+ ADVANCED GRAPHICS TECHNIQUES WITH THE IBM PC\r
+\r
+\r
+\r
+\r
+Increasing Colours\r
+\r
+The EGA display is limited displaying a maximum of 16 colours, however in\r
+high resolution graphics modes (such as mode 16) the small physical size\r
+of the pixels allows blending of adjacent colours to produce additional\r
+shades.\r
+\r
+If a line is drawn straight across a black background display in blue,\r
+and then a subsequent line is drawn beneath it also in blue but only\r
+plotting alternate pixels, the second line will appear in a darker shade\r
+of the same colour.\r
+\r
+The following C program illustrates this idea;\r
+\r
+\r
+ #include <dos.h>\r
+ \r
+ union REGS inreg, outreg;\r
+ \r
+ void setvideo(unsigned char mode)\r
+ {\r
+ /* Sets the video display mode */\r
+ \r
+ inreg.h.al = mode;\r
+ inreg.h.ah = 0;\r
+ int86(0x10, &inreg, &outreg);\r
+ }\r
+ \r
+ void plot(int x, int y, unsigned char colour)\r
+ {\r
+ /* Sets a pixel at the specified coordinates */\r
+ \r
+ inreg.h.al = colour;\r
+ inreg.h.bh = 0;\r
+ inreg.x.cx = x;\r
+ inreg.x.dx = y;\r
+ inreg.h.ah = 0x0C;\r
+ int86(0x10, &inreg, &outreg);\r
+ }\r
+ \r
+ void line(int a, int b, int c, int d, unsigned char colour)\r
+ {\r
+ /* Draws a straight line from (a,b) to (c,d) */\r
+ \r
+ int u;\r
+ int v;\r
+ int d1x;\r
+ int d1y;\r
+ int d2x;\r
+ int d2y;\r
+ int m;\r
+ int n;\r
+ int s;\r
+ int i;\r
+ \r
+ u = c - a;\r
+ v = d - b;\r
+ if (u == 0)\r
+ {\r
+ d1x = 0;\r
+ m = 0;\r
+ }\r
+ else\r
+ {\r
+ m = abs(u);\r
+ if (u < 0)\r
+ d1x = -1;\r
+ else\r
+ if (u > 0)\r
+ d1x = 1;\r
+ }\r
+ if ( v == 0)\r
+ {\r
+ d1y = 0;\r
+ n = 0;\r
+ }\r
+ else\r
+ {\r
+ n = abs(v);\r
+ if (v < 0)\r
+ d1y = -1;\r
+ else\r
+ if (v > 0)\r
+ d1y = 1;\r
+ }\r
+ if (m > n)\r
+ {\r
+ d2x = d1x;\r
+ d2y = 0;\r
+ }\r
+ else\r
+ {\r
+ d2x = 0;\r
+ d2y = d1y;\r
+ m = n;\r
+ n = abs(u);\r
+ }\r
+ s = m / 2;\r
+ \r
+ for (i = 0; i <= m; i++)\r
+ {\r
+ plot(a,b,colour);\r
+ s += n;\r
+ if (s >= m)\r
+ {\r
+ s -= m;\r
+ a += d1x;\r
+ b += d1y;\r
+ }\r
+ else\r
+ {\r
+ a += d2x;\r
+ b += d2y;\r
+ }\r
+ }\r
+ }\r
+ \r
+ void dot_line(int a, int b, int c, int d, int colour)\r
+ {\r
+ /* Draws a dotted straight line from (a,b) to (c,d) */\r
+ \r
+ int u;\r
+ int v;\r
+ int d1x;\r
+ int d1y;\r
+ int d2x;\r
+ int d2y;\r
+ int m;\r
+ int n;\r
+ int s;\r
+ int i;\r
+ \r
+ u = c - a;\r
+ v = d - b;\r
+ if (u == 0)\r
+ {\r
+ d1x = 0;\r
+ m = 0;\r
+ }\r
+ else\r
+ {\r
+ m = abs(u);\r
+ if (u < 0)\r
+ d1x = -2;\r
+ else\r
+ if (u > 0)\r
+ d1x = 2;\r
+ }\r
+ if (v == 0)\r
+ {\r
+ d1y = 0;\r
+ n = 0;\r
+ }\r
+ else\r
+ {\r
+ n = abs(v);\r
+ if (v < 0)\r
+ d1y = -2;\r
+ else\r
+ if (v > 0)\r
+ d1y = 2;\r
+ }\r
+ if (m > n)\r
+ {\r
+ d2x = d1x;\r
+ d2y = 0;\r
+ }\r
+ else\r
+ {\r
+ d2x = 0;\r
+ d2y = d1y;\r
+ m = n;\r
+ n = abs(u);\r
+ }\r
+ s = m / 2;\r
+ \r
+ for (i = 0; i <= m; i+=2)\r
+ {\r
+ plot(a,b,colour);\r
+ s += n;\r
+ if (s >= m)\r
+ {\r
+ s -= m;\r
+ a += d1x;\r
+ b += d1y;\r
+ }\r
+ else\r
+ {\r
+ a += d2x;\r
+ b += d2y;\r
+ }\r
+ }\r
+ }\r
+ \r
+ \r
+ void main(void)\r
+ {\r
+ int n;\r
+ \r
+ /* Display different colour bands */\r
+ \r
+ setvideo(16);\r
+ \r
+ for(n = 1; n < 16; n++)\r
+ {\r
+ line(0,n * 20,639,n * 20,n);\r
+ line(0,1 + n * 20,639,1 + n * 20,n);\r
+ line(0,2 + n * 20,639,2 + n * 20,n);\r
+ \r
+ dot_line(0,4 + n * 20,639,4 + n * 20,n);\r
+ dot_line(1,5 + n * 20,639,5 + n * 20,n);\r
+ dot_line(0,6 + n * 20,639,6 + n * 20,n);\r
+ \r
+ dot_line(0,8 + n * 20,639,8 + n * 20,n);\r
+ dot_line(1,9 + n * 20,639,9 + n * 20,n);\r
+ dot_line(0,10 + n * 20,639,10 + n * 20,n);\r
+ \r
+ dot_line(1,8 + n * 20,639,8 + n * 20,7);\r
+ dot_line(0,9 + n * 20,639,9 + n * 20,7);\r
+ dot_line(1,10 + n * 20,639,10 + n * 20,7);\r
+ \r
+ dot_line(1,12 + n * 20,639,12 + n * 20,n);\r
+ dot_line(0,13 + n * 20,639,13 + n * 20,n);\r
+ dot_line(1,14 + n * 20,639,14 + n * 20,n);\r
+ \r
+ dot_line(0,12 + n * 20,639,12 + n * 20,14);\r
+ dot_line(1,13 + n * 20,639,13 + n * 20,14);\r
+ dot_line(0,14 + n * 20,639,14 + n * 20,14);\r
+ }\r
+ }\r
+\r
+This technique can be put to good use for drawing three dimensional\r
+boxes;\r
+\r
+ void box3d(int xa,int ya, int xb, int yb, int col)\r
+ {\r
+ /* Draws a box for use in 3d histogram graphs etc */\r
+ \r
+ int xc;\r
+ int xd;\r
+ \r
+ int n;\r
+ \r
+ xd = (xb - xa) / 2;\r
+ xc = xa + xd;\r
+ \r
+ /* First draw the solid face */\r
+ for(n = xa; n < xb; n++)\r
+ line(n,ya,n,yb,col);\r
+ \r
+ /* Now "shaded" top and side */\r
+ for(n = 0; n < xd; n++)\r
+ {\r
+ dotline(xa + n,yb - n ,xc + n,yb - n,col);\r
+ dotline(xa + xd + n,yb - n ,xc + xd + n,yb - n,col);\r
+ dotline(xb +n ,ya - n ,xb + n,yb - n,col);\r
+ }\r
+ }\r
+ \r
+\r
+\r
+Displaying Text At Pixel Coordinates\r
+\r
+When using graphics display modes it is useful to be able to display text\r
+not at the fixed character boundaries, but at pixel coordinates. This can\r
+be achieved by implementing a print function which reads the character\r
+definition data from the BIOS ROM and uses it to plot pixels to create\r
+the shapes of the desired text. The following C function, "gr_print()"\r
+illustrates this idea using the ROM CGA (8x8) character set;\r
+\r
+ void gr_print(char *output, int x, int y, unsigned char colour)\r
+ {\r
+ unsigned char far *ptr;\r
+ unsigned char chr;\r
+ unsigned char bmask;\r
+ int i;\r
+ int k;\r
+ int oldy;\r
+ int p;\r
+ int height;\r
+ \r
+ /* The height of the characters in the font being accessed */\r
+ height = 8;\r
+ \r
+ /* Set pointer to start of font definition in the ROM */\r
+ ptr = getfontptr(3);\r
+ \r
+ oldy = y;\r
+ p = 0;\r
+ \r
+ /* Loop output string */\r
+ while(output[p])\r
+ {\r
+ /* Get first character to be displayed */\r
+ chr = output[p];\r
+ \r
+ /* Loop pixel lines in character definition */\r
+ for(i = 0; i < height; i++)\r
+ {\r
+ /* Get pixel line definition from the ROM */\r
+ bmask = *(ptr + (chr * height) + i);\r
+ \r
+ /* Loop pixel columns */\r
+ for (k = 0; k < 8; ++k, bmask <<= 1)\r
+ {\r
+ /* Test for a set bit */\r
+ if(bmask & 128)\r
+ /* Plot a pixel if appropriate */\r
+ plot(x,y,colour);\r
+ else\r
+ plot(x,y,0);\r
+ x++;\r
+ }\r
+ /* Down to next row and left to start of character */\r
+ y++;\r
+ x -= 8;\r
+ }\r
+ /* Next character to be displayed */\r
+ p++;\r
+ \r
+ /* Back to top row of the display position */\r
+ y = oldy;\r
+ \r
+ /* Right to next character display position */\r
+ x += 8;\r
+ }\r
+ }\r
+\r
+The following assembly language support function is required to retrieve\r
+the address of the ROM font by calling the BIOS ROM display function\r
+which will return the address;\r
+\r
+\r
+ ; GET FONT POINTER\r
+ ; Small memory model\r
+ ; compile with tasm /mx\r
+ \r
+ _TEXT segment byte public 'CODE'\r
+ assume cs:_TEXT,ds:NOTHING\r
+ \r
+ _getfontptr proc near\r
+ push bp\r
+ mov bp,sp\r
+ mov ax,1130h\r
+ mov bh, [bp+4] ; Number for font to be retrieved\r
+ int 10h\r
+ mov dx,es\r
+ mov ax,bp\r
+ pop bp\r
+ ret\r
+ _getfontptr endp\r
+ \r
+ _TEXT ends\r
+ \r
+ public _getfontptr\r
+ end\r
+ \r
+The font number supplied to "getfontptr()" can be one of;\r
+\r
+ 2 ROM EGA 8 x 14 font\r
+ 3 ROM CGA 8 x 8 font\r
+ 6 ROM VGA 8 x 16 font\r
+\r
+A Graphics Function Library For Turbo C\r
+\r
+ /* Graphics library for 'Turbo C' (V2.01) */\r
+ \r
+ /* (C)1992 Copyright Servile Software */\r
+ \r
+ #include <stdio.h>\r
+ #include <dos.h>\r
+ #include <stdlib.h>\r
+ #include <stdarg.h>\r
+ #include <string.h>\r
+ #include <math.h>\r
+ \r
+ /* Global variables */\r
+ static unsigned char attribute;\r
+ int _dmode;\r
+ int _lastx;\r
+ int _lasty;\r
+ \r
+ /* Maximum coordinates for graphics screen */\r
+ static int maxx;\r
+ static int maxy;\r
+ \r
+ /* Sprite structure */\r
+ struct SP\r
+ {\r
+ int x;\r
+ int y;\r
+ char data[256];\r
+ char save[256];\r
+ };\r
+ typedef struct SP SPRITE;\r
+ \r
+ \r
+ /* Sine and cosine tables for trig' operations */\r
+ \r
+ static double sintable[360] =\r
+ {0.000000000000000001,0.017452406437283512,\r
+ 0.034899496702500969,0.052335956242943835,\r
+ 0.069756473744125302,0.087155742747658166,\r
+ 0.104528463267653457,0.121869343405147462,\r
+ 0.139173100960065438,0.156434465040230869,\r
+ 0.173648177666930331,0.190808995376544804,\r
+ 0.207911690817759315,0.224951054343864976,\r
+ 0.241921895599667702,0.258819045102520739,\r
+ 0.275637355816999163,0.292371704722736769,\r
+ 0.309016994374947451,0.325568154457156755,\r
+ 0.342020143325668824,0.358367949545300379,\r
+ 0.374606593415912181,0.390731128489273882,\r
+ 0.406736643075800375,0.422618261740699608,\r
+ 0.438371146789077626,0.453990499739547027,\r
+ 0.469471562785891028,0.484809620246337225,\r
+ 0.500000000000000222,0.515038074910054489,\r
+ 0.529919264233205234,0.544639035015027417,\r
+ 0.559192903470747127,0.573576436351046381,\r
+ 0.587785252292473470,0.601815023152048600,\r
+ 0.615661475325658625,0.629320391049837835,\r
+ 0.642787609686539696,0.656059028990507720,\r
+ 0.669130606358858682,0.681998360062498921,\r
+ 0.694658370458997698,0.707106781186548017,\r
+ 0.719339800338651636,0.731353701619170904,\r
+ 0.743144825477394688,0.754709580222772458,\r
+ 0.766044443118978569,0.777145961456971346,\r
+ 0.788010753606722458,0.798635510047293384,\r
+ 0.809016994374947895,0.819152044288992243,\r
+ 0.829037572555042179,0.838670567945424494,\r
+ 0.848048096156426512,0.857167300702112778,\r
+ 0.866025403784439152,0.874619707139396296,\r
+ 0.882947592858927432,0.891006524188368343,\r
+ 0.898794046299167482,0.906307787036650381,\r
+ 0.913545457642601311,0.920504853452440819,\r
+ 0.927183854566787868,0.933580426497202187,\r
+ 0.939692620785908761,0.945518575599317179,\r
+ 0.951056516295153975,0.956304755963035880,\r
+ 0.961261695938319227,0.965925826289068645,\r
+ 0.970295726275996806,0.974370064785235579,\r
+ 0.978147600733805911,0.981627183447664198,\r
+ 0.984807753012208353,0.987688340595137992,\r
+ 0.990268068741570473,0.992546151641322205,\r
+ 0.994521895368273512,0.996194698091745656,\r
+ 0.997564050259824309,0.998629534754573944,\r
+ 0.999390827019095762,0.999847695156391270,\r
+ 1.000000000000000000,0.999847695156391159,\r
+ 0.999390827019095651,0.998629534754573833,\r
+ 0.997564050259824087,0.996194698091745323,\r
+ 0.994521895368273179,0.992546151641321761,\r
+ 0.990268068741570029,0.987688340595137437,\r
+ 0.984807753012207687,0.981627183447663532,\r
+ 0.978147600733805245,0.974370064785234802,\r
+ 0.970295726275996029,0.965925826289067757,\r
+ 0.961261695938318228,0.956304755963034880,\r
+ 0.951056516295152865,0.945518575599316069,\r
+ 0.939692620785907651,0.933580426497200966,\r
+ 0.927183854566786536,0.920504853452439486,\r
+ 0.913545457642599978,0.906307787036649048,\r
+ 0.898794046299166149,0.891006524188367122,\r
+ 0.882947592858926211,0.874619707139395186,\r
+ 0.866025403784438042,0.857167300702111778,\r
+ 0.848048096156425624,0.838670567945423717,\r
+ 0.829037572555041513,0.819152044288991688,\r
+ 0.809016994374947451,0.798635510047293051,\r
+ 0.788010753606722236,0.777145961456971346,\r
+ 0.766044443118978569,0.754709580222772680,\r
+ 0.743144825477395132,0.731353701619171459,\r
+ 0.719339800338652302,0.707106781186548794,\r
+ 0.694658370458998808,0.681998360062500142,\r
+ 0.669130606358860014,0.656059028990509274,\r
+ 0.642787609686541472,0.629320391049839833,\r
+ 0.615661475325660845,0.601815023152051043,\r
+ 0.587785252292476135,0.573576436351049268,\r
+ 0.559192903470750236,0.544639035015030637,\r
+ 0.529919264233208676,0.515038074910058152,\r
+ 0.500000000000004219,0.484809620246341444,\r
+ 0.469471562785895413,0.453990499739551634,\r
+ 0.438371146789082455,0.422618261740704715,\r
+ 0.406736643075805704,0.390731128489279489,\r
+ 0.374606593415918010,0.358367949545306430,\r
+ 0.342020143325675152,0.325568154457163306,\r
+ 0.309016994374954279,0.292371704722743819,\r
+ 0.275637355817006491,0.258819045102528289,\r
+ 0.241921895599675502,0.224951054343872997,\r
+ 0.207911690817767558,0.190808995376553270,\r
+ 0.173648177666939019,0.156434465040239751,\r
+ 0.139173100960074542,0.121869343405156802,\r
+ 0.104528463267663005,0.087155742747667922,\r
+ 0.069756473744135267,0.052335956242954007,\r
+ 0.034899496702511350,0.017452406437294093,\r
+ 0.000000000000010781,-0.017452406437272534,\r
+ -0.034899496702489805,-0.052335956242932476,\r
+ -0.069756473744113756,-0.087155742747646453,\r
+ -0.104528463267641564,-0.121869343405135402,\r
+ -0.139173100960053198,-0.156434465040218462,\r
+ -0.173648177666917786,-0.190808995376532092,\r
+ -0.207911690817746464,-0.224951054343851986,\r
+ -0.241921895599654574,-0.258819045102507472,\r
+ -0.275637355816985785,-0.292371704722723225,\r
+ -0.309016994374933796,-0.325568154457142933,\r
+ -0.342020143325654891,-0.358367949545286335,\r
+ -0.374606593415898026,-0.390731128489259616,\r
+ -0.406736643075785997,-0.422618261740685175,\r
+ -0.438371146789063082,-0.453990499739532427,\r
+ -0.469471562785876373,-0.484809620246322570,\r
+ -0.499999999999985512,-0.515038074910039723,\r
+ -0.529919264233190468,-0.544639035015012540,\r
+ -0.559192903470732361,-0.573576436351031616,\r
+ -0.587785252292458593,-0.601815023152033834,\r
+ -0.615661475325643859,-0.629320391049823069,\r
+ -0.642787609686525041,-0.656059028990493065,\r
+ -0.669130606358844027,-0.681998360062484377,\r
+ -0.694658370458983265,-0.707106781186533584,\r
+ -0.719339800338637314,-0.731353701619156804,\r
+ -0.743144825477380699,-0.754709580222758580,\r
+ -0.766044443118964691,-0.777145961456957690,\r
+ -0.788010753606709025,-0.798635510047280062,\r
+ -0.809016994374934795,-0.819152044288979364,\r
+ -0.829037572555029412,-0.838670567945412060,\r
+ -0.848048096156414188,-0.857167300702100676,\r
+ -0.866025403784427272,-0.874619707139384750,\r
+ -0.882947592858916108,-0.891006524188357352,\r
+ -0.898794046299156713,-0.906307787036639945,\r
+ -0.913545457642591208,-0.920504853452430938,\r
+ -0.927183854566778320,-0.933580426497192972,\r
+ -0.939692620785899990,-0.945518575599308742,\r
+ -0.951056516295145871,-0.956304755963028108,\r
+ -0.961261695938311900,-0.965925826289061651,\r
+ -0.970295726275990256,-0.974370064785229362,\r
+ -0.978147600733800138,-0.981627183447658869,\r
+ -0.984807753012203468,-0.987688340595133552,\r
+ -0.990268068741566587,-0.992546151641318764,\r
+ -0.994521895368270514,-0.996194698091743103,\r
+ -0.997564050259822310,-0.998629534754572390,\r
+ -0.999390827019094763,-0.999847695156390714,\r
+ -1.000000000000000000,-0.999847695156391714,\r
+ -0.999390827019096761,-0.998629534754575388,\r
+ -0.997564050259826307,-0.996194698091748099,\r
+ -0.994521895368276398,-0.992546151641325647,\r
+ -0.990268068741574470,-0.987688340595142433,\r
+ -0.984807753012213349,-0.981627183447669860,\r
+ -0.978147600733812128,-0.974370064785242240,\r
+ -0.970295726276004022,-0.965925826289076417,\r
+ -0.961261695938327665,-0.956304755963044872,\r
+ -0.951056516295163523,-0.945518575599327393,\r
+ -0.939692620785919530,-0.933580426497213511,\r
+ -0.927183854566799748,-0.920504853452453253,\r
+ -0.913545457642614411,-0.906307787036664148,\r
+ -0.898794046299181804,-0.891006524188383331,\r
+ -0.882947592858942976,-0.874619707139412506,\r
+ -0.866025403784455916,-0.857167300702130208,\r
+ -0.848048096156444498,-0.838670567945443146,\r
+ -0.829037572555061497,-0.819152044289012227,\r
+ -0.809016994374968434,-0.798635510047314479,\r
+ -0.788010753606744219,-0.777145961456993772,\r
+ -0.766044443119001550,-0.754709580222796106,\r
+ -0.743144825477418891,-0.731353701619195773,\r
+ -0.719339800338677060,-0.707106781186574107,\r
+ -0.694658370459024455,-0.681998360062526232,\r
+ -0.669130606358886548,-0.656059028990536253,\r
+ -0.642787609686568784,-0.629320391049867478,\r
+ -0.615661475325688934,-0.601815023152079465,\r
+ -0.587785252292504890,-0.573576436351078467,\r
+ -0.559192903470779767,-0.544639035015060502,\r
+ -0.529919264233238985,-0.515038074910088794,\r
+ -0.500000000000035083,-0.484809620246372641,\r
+ -0.469471562785926888,-0.453990499739583386,\r
+ -0.438371146789114541,-0.422618261740737022,\r
+ -0.406736643075838289,-0.390731128489312296,\r
+ -0.374606593415951039,-0.358367949545339737,\r
+ -0.342020143325708625,-0.325568154457197001,\r
+ -0.309016994374988196,-0.292371704722777903,\r
+ -0.275637355817040797,-0.258819045102562761,\r
+ -0.241921895599710085,-0.224951054343907719,\r
+ -0.207911690817802419,-0.190808995376588242,\r
+ -0.173648177666974129,-0.156434465040274973,\r
+ -0.139173100960109847,-0.121869343405192190,\r
+ -0.104528463267698463,-0.087155742747703435,\r
+ -0.069756473744170822,-0.052335956242989604,\r
+ -0.034899496702546981,-0.017452406437329739\r
+ };\r
+\r
+static double costable[360] = {\r
+1.000000000000000000,0.999847695156391270,\r
+ 0.999390827019095762,0.998629534754573833,\r
+ 0.997564050259824198,0.996194698091745545,\r
+ 0.994521895368273290,0.992546151641321983,\r
+ 0.990268068741570362,0.987688340595137770,\r
+ 0.984807753012208020,0.981627183447663976,\r
+ 0.978147600733805689,0.974370064785235246,\r
+ 0.970295726275996473,0.965925826289068312,\r
+ 0.961261695938318894,0.956304755963035436,\r
+ 0.951056516295153531,0.945518575599316735,\r
+ 0.939692620785908317,0.933580426497201743,\r
+ 0.927183854566787313,0.920504853452440264,\r
+ 0.913545457642600867,0.906307787036649826,\r
+ 0.898794046299166927,0.891006524188367788,\r
+ 0.882947592858926766,0.874619707139395630,\r
+ 0.866025403784438486,0.857167300702112112,\r
+ 0.848048096156425846,0.838670567945423828,\r
+ 0.829037572555041513,0.819152044288991576,\r
+ 0.809016994374947229,0.798635510047292607,\r
+ 0.788010753606721681,0.777145961456970569,\r
+ 0.766044443118977680,0.754709580222771681,\r
+ 0.743144825477393911,0.731353701619170127,\r
+ 0.719339800338650748,0.707106781186547129,\r
+ 0.694658370458996810,0.681998360062498032,\r
+ 0.669130606358857682,0.656059028990506721,\r
+ 0.642787609686538697,0.629320391049836836,\r
+ 0.615661475325657626,0.601815023152047601,\r
+ 0.587785252292472471,0.573576436351045382,\r
+ 0.559192903470746128,0.544639035015026307,\r
+ 0.529919264233204124,0.515038074910053378,\r
+ 0.499999999999999112,0.484809620246336115,\r
+ 0.469471562785889862,0.453990499739545861,\r
+ 0.438371146789076460,0.422618261740698442,\r
+ 0.406736643075799154,0.390731128489272661,\r
+ 0.374606593415910960,0.358367949545299158,\r
+ 0.342020143325667547,0.325568154457155479,\r
+ 0.309016994374946230,0.292371704722735493,\r
+ 0.275637355816997887,0.258819045102519463,\r
+ 0.241921895599666398,0.224951054343863643,\r
+ 0.207911690817757955,0.190808995376543389,\r
+ 0.173648177666928888,0.156434465040229398,\r
+ 0.139173100960063939,0.121869343405145950,\r
+ 0.104528463267651903,0.087155742747656584,\r
+ 0.069756473744123679,0.052335956242942190,\r
+ 0.034899496702499304,0.017452406437281822,\r
+ -0.000000000000001715,-0.017452406437285253,\r
+ -0.034899496702502732,-0.052335956242945618,\r
+ -0.069756473744127107,-0.087155742747659998,\r
+ -0.104528463267655317,-0.121869343405149350,\r
+ -0.139173100960067325,-0.156434465040232784,\r
+ -0.173648177666932274,-0.190808995376546747,\r
+ -0.207911690817761285,-0.224951054343866974,\r
+ -0.241921895599669701,-0.258819045102522793,\r
+ -0.275637355817001217,-0.292371704722738768,\r
+ -0.309016994374949450,-0.325568154457158698,\r
+ -0.342020143325670822,-0.358367949545302322,\r
+ -0.374606593415914124,-0.390731128489275825,\r
+ -0.406736643075802318,-0.422618261740701329,\r
+ -0.438371146789079125,-0.453990499739548303,\r
+ -0.469471562785892083,-0.484809620246338169,\r
+ -0.500000000000000999,-0.515038074910054933,\r
+ -0.529919264233205567,-0.544639035015027528,\r
+ -0.559192903470747127,-0.573576436351046159,\r
+ -0.587785252292473026,-0.601815023152048045,\r
+ -0.615661475325657848,-0.629320391049836947,\r
+ -0.642787609686538697,-0.656059028990506499,\r
+ -0.669130606358857238,-0.681998360062497477,\r
+ -0.694658370458996033,-0.707106781186546240,\r
+ -0.719339800338649749,-0.731353701619168906,\r
+ -0.743144825477392579,-0.754709580222770238,\r
+ -0.766044443118976237,-0.777145961456968903,\r
+ -0.788010753606719905,-0.798635510047290720,\r
+ -0.809016994374945231,-0.819152044288989578,\r
+ -0.829037572555039404,-0.838670567945421719,\r
+ -0.848048096156423625,-0.857167300702109891,\r
+ -0.866025403784436265,-0.874619707139393410,\r
+ -0.882947592858924435,-0.891006524188365345,\r
+ -0.898794046299164484,-0.906307787036647494,\r
+ -0.913545457642598424,-0.920504853452437932,\r
+ -0.927183854566784982,-0.933580426497199412,\r
+ -0.939692620785906096,-0.945518575599314515,\r
+ -0.951056516295151311,-0.956304755963033326,\r
+ -0.961261695938316785,-0.965925826289066314,\r
+ -0.970295726275994586,-0.974370064785233358,\r
+ -0.978147600733803912,-0.981627183447662310,\r
+ -0.984807753012206577,-0.987688340595136327,\r
+ -0.990268068741569030,-0.992546151641320873,\r
+ -0.994521895368272291,-0.996194698091744657,\r
+ -0.997564050259823532,-0.998629534754573389,\r
+ -0.999390827019095318,-0.999847695156391048,\r
+ -1.000000000000000000,-0.999847695156391381,\r
+ -0.999390827019096095,-0.998629534754574499,\r
+ -0.997564050259825086,-0.996194698091746544,\r
+ -0.994521895368274622,-0.992546151641323537,\r
+ -0.990268068741572027,-0.987688340595139658,\r
+ -0.984807753012210241,-0.981627183447666418,\r
+ -0.978147600733808353,-0.974370064785238244,\r
+ -0.970295726275999804,-0.965925826289071865,\r
+ -0.961261695938322669,-0.956304755963039654,\r
+ -0.951056516295157972,-0.945518575599321509,\r
+ -0.939692620785913424,-0.933580426497207072,\r
+ -0.927183854566793086,-0.920504853452446370,\r
+ -0.913545457642607195,-0.906307787036656598,\r
+ -0.898794046299173921,-0.891006524188375226,\r
+ -0.882947592858934649,-0.874619707139403846,\r
+ -0.866025403784447034,-0.857167300702120993,\r
+ -0.848048096156435061,-0.838670567945433487,\r
+ -0.829037572555051505,-0.819152044289001902,\r
+ -0.809016994374957998,-0.798635510047303709,\r
+ -0.788010753606733227,-0.777145961456982559,\r
+ -0.766044443118990004,-0.754709580222784449,\r
+ -0.743144825477407012,-0.731353701619183672,\r
+ -0.719339800338664737,-0.707106781186561450,\r
+ -0.694658370459011576,-0.681998360062513242,\r
+ -0.669130606358873337,-0.656059028990522708,\r
+ -0.642787609686555128,-0.629320391049853711,\r
+ -0.615661475325674945,-0.601815023152065254,\r
+ -0.587785252292490457,-0.573576436351063812,\r
+ -0.559192903470765002,-0.544639035015045625,\r
+ -0.529919264233223886,-0.515038074910073473,\r
+ -0.500000000000019651,-0.484809620246357043,\r
+ -0.469471562785911123,-0.453990499739567510,\r
+ -0.438371146789098498,-0.422618261740720869,\r
+ -0.406736643075822024,-0.390731128489295920,\r
+ -0.374606593415934497,-0.358367949545323083,\r
+ -0.342020143325691917,-0.325568154457180181,\r
+ -0.309016994374971266,-0.292371704722760861,\r
+ -0.275637355817023644,-0.258819045102545497,\r
+ -0.241921895599692793,-0.224951054343890372,\r
+ -0.207911690817784989,-0.190808995376570756,\r
+ -0.173648177666956560,-0.156434465040257376,\r
+ -0.139173100960092194,-0.121869343405174496,\r
+ -0.104528463267680741,-0.087155742747685686,\r
+ -0.069756473744153044,-0.052335956242971805,\r
+ -0.034899496702529162,-0.017452406437311916,\r
+ -0.000000000000028605,0.017452406437254715,\r
+ 0.034899496702471985,0.052335956242914670,\r
+ 0.069756473744095979,0.087155742747628689,\r
+ 0.104528463267623842,0.121869343405117708,\r
+ 0.139173100960035545,0.156434465040200865,\r
+ 0.173648177666900216,0.190808995376514606,\r
+ 0.207911690817729033,0.224951054343834611,\r
+ 0.241921895599637282,0.258819045102490264,\r
+ 0.275637355816968632,0.292371704722706127,\r
+ 0.309016994374916809,0.325568154457126058,\r
+ 0.342020143325638126,0.358367949545269682,\r
+ 0.374606593415881484,0.390731128489243240,\r
+ 0.406736643075769733,0.422618261740669021,\r
+ 0.438371146789047095,0.453990499739516551,\r
+ 0.469471562785860608,0.484809620246306972,\r
+ 0.499999999999970080,0.515038074910024402,\r
+ 0.529919264233175369,0.544639035014997663,\r
+ 0.559192903470717484,0.573576436351016961,\r
+ 0.587785252292444271,0.601815023152019624,\r
+ 0.615661475325629759,0.629320391049809191,\r
+ 0.642787609686511385,0.656059028990479520,\r
+ 0.669130606358830815,0.681998360062471387,\r
+ 0.694658370458970387,0.707106781186521038,\r
+ 0.719339800338624991,0.731353701619144592,\r
+ 0.743144825477368709,0.754709580222746812,\r
+ 0.766044443118953255,0.777145961456946477,\r
+ 0.788010753606698033,0.798635510047269292,\r
+ 0.809016994374924359,0.819152044288969150,\r
+ 0.829037572555019531,0.838670567945402290,\r
+ 0.848048096156404752,0.857167300702091572,\r
+ 0.866025403784418391,0.874619707139376090,\r
+ 0.882947592858907782,0.891006524188349247,\r
+ 0.898794046299148941,0.906307787036632395,\r
+ 0.913545457642583991,0.920504853452423943,\r
+ 0.927183854566771659,0.933580426497186644,\r
+ 0.939692620785893884,0.945518575599302968,\r
+ 0.951056516295140320,0.956304755963022890,\r
+ 0.961261695938306904,0.965925826289056988,\r
+ 0.970295726275985926,0.974370064785225365,\r
+ 0.978147600733796474,0.981627183447655538,\r
+ 0.984807753012200360,0.987688340595130776,\r
+ 0.990268068741564034,0.992546151641316543,\r
+ 0.994521895368268627,0.996194698091741548,\r
+ 0.997564050259821089,0.998629534754571502,\r
+ 0.999390827019094097,0.999847695156390381\r
+ \r
+ int dtoi(double x)\r
+ {\r
+ /* Rounds a floating point number to an integer */\r
+ \r
+ int y;\r
+ \r
+ y = x;\r
+ if (y < (x + 0.5))\r
+ y++;\r
+ return(y);\r
+ }\r
+ \r
+ int getmode(int *ncols)\r
+ {\r
+ /* Returns current video mode and number of columns in ncols */\r
+ \r
+ union REGS inreg,outreg;\r
+ \r
+ inreg.h.ah = 0x0F;\r
+ int86(0x10, &inreg, &outreg);\r
+ *ncols = outreg.h.ah;\r
+ return(outreg.h.al);\r
+ }\r
+ \r
+ void setvideo(unsigned char mode)\r
+ {\r
+ /* Sets the video display mode and clears the screen */\r
+ /* (modes above 127 on VGA monitors do not clear the screen) */\r
+ \r
+ asm mov ax , mode;\r
+ asm int 10h;\r
+ \r
+ /* Set global variables */\r
+ switch(mode)\r
+ {\r
+ case 0:\r
+ case 1:\r
+ case 2:\r
+ case 3: break;\r
+ case 4:\r
+ case 9:\r
+ case 13:\r
+ case 19:\r
+ case 5: maxx = 320;\r
+ maxy = 200;\r
+ break;\r
+ case 14:\r
+ case 10:\r
+ case 6: maxx = 640;\r
+ maxy = 200;\r
+ break;\r
+ case 7: maxx = 720;\r
+ maxy = 400;\r
+ break;\r
+ case 8: maxx = 160;\r
+ maxy = 200;\r
+ break;\r
+ case 15:\r
+ case 16: maxx = 640;\r
+ maxy = 350;\r
+ break;\r
+ case 17:\r
+ case 18: maxx = 640;\r
+ maxy = 480;\r
+ break;\r
+ \r
+ }\r
+ _dmode = mode;\r
+ }\r
+ \r
+ void getcursor(int *row, int *col)\r
+ {\r
+ /* Returns the cursor position and size for the currently\r
+ active\r
+ video display page */\r
+ \r
+ union REGS inreg,outreg;\r
+ \r
+ inreg.h.bh = 0;\r
+ inreg.h.ah = 0x03;\r
+ int86(0x10, &inreg, &outreg);\r
+ *row = outreg.h.dh;\r
+ *col = outreg.h.dl;\r
+ }\r
+ \r
+ void setcursor(char status)\r
+ {\r
+ /* Set cursor size, if status is 0x20 the cursor is not\r
+ displayed */\r
+ \r
+ asm mov ah,1\r
+ asm mov ch,status\r
+ asm mov cl,7\r
+ asm int 10h\r
+ }\r
+ \r
+ void at(int row, int col)\r
+ {\r
+ /* Position text cursor on current screen */\r
+ \r
+ asm mov bh , 0;\r
+ asm mov dh , row;\r
+ asm mov dl , col;\r
+ asm mov ah , 02h;\r
+ asm int 10h;\r
+ }\r
+ \r
+ void clsc(unsigned char attrib)\r
+ {\r
+ /* Clear display and fill with new attribute */\r
+ \r
+ asm mov ax , 073dh;\r
+ asm mov bh , attrib;\r
+ asm mov cx , 0;\r
+ asm mov dx , 3c4fh;\r
+ asm int 10h;\r
+ \r
+ /* Now move text cursor to origin (0,0) */\r
+ asm mov bh , 0;\r
+ asm mov dx , 0;\r
+ asm mov ah , 02h;\r
+ asm int 10h;\r
+ }\r
+ \r
+ void clrwindow(int x1, int y1,int x2, int y2, unsigned char attrib)\r
+ {\r
+ /* Clear a text window */\r
+ \r
+ union REGS inreg,outreg;\r
+ \r
+ inreg.h.al = (unsigned char)(y2 - y1 + 1);\r
+ inreg.h.bh = attrib;\r
+ inreg.h.cl = (unsigned char)x1;\r
+ inreg.h.ch = (unsigned char)y1;\r
+ inreg.h.dl = (unsigned char)x2;\r
+ inreg.h.dh = (unsigned char)y2;\r
+ inreg.h.ah = 0x06;\r
+ int86(0x10, &inreg, &outreg);\r
+ }\r
+ \r
+ void scrollsc(void)\r
+ {\r
+ /* Scroll the text screen */\r
+ \r
+ asm mov al,01h;\r
+ asm mov cx,0\r
+ asm mov dx,3c4fh;\r
+ asm mov bh,attribute;\r
+ asm mov ah, 06h;\r
+ asm int 10h;\r
+ }\r
+ \r
+ void winscr(unsigned char left,unsigned char top, unsigned char\r
+ right,unsigned char bottom,\r
+ unsigned char direction, unsigned char numlines)\r
+ {\r
+ /* Scroll a text window */\r
+ \r
+ asm mov al , numlines;\r
+ asm mov cl , left;\r
+ asm mov ch , top;\r
+ asm mov dl , right;\r
+ asm mov dh , bottom;\r
+ asm mov bh , attribute;\r
+ asm mov ah , direction;\r
+ asm int 10h;\r
+ }\r
+ \r
+ unsigned char attr(int foregrnd, int backgrnd)\r
+ {\r
+ /* Convert a colour pair into a single attribute */\r
+ \r
+ return((char)((backgrnd << 4) + foregrnd));\r
+ }\r
+ \r
+ void shadewin(unsigned char left, unsigned char top, unsigned char\r
+ right, unsigned char bottom)\r
+ {\r
+ /* Shade a text window */\r
+ \r
+ int row;\r
+ int col;\r
+ int oldrow;\r
+ int oldcol;\r
+ \r
+ /* Preserve existing coords */\r
+ getcursor(&oldrow,&oldcol);\r
+ \r
+ col = right + 1;\r
+ for (row = top + 1; row <= bottom + 1; row++)\r
+ {\r
+ /* Move to row,col */\r
+ asm mov bh , 0;\r
+ asm mov dh , row;\r
+ asm mov dl , col;\r
+ asm mov ah , 02h;\r
+ asm int 10h;\r
+ /* Get character */\r
+ asm mov ah , 0Fh;\r
+ asm int 10h;\r
+ asm mov ah , 08h;\r
+ asm int 10h;\r
+ \r
+ /* Write in attribute 7 */\r
+ asm mov ah , 09h;\r
+ asm mov bl, 07h;\r
+ asm mov cx, 01h;\r
+ asm int 10h;\r
+ }\r
+ bottom++;\r
+ for (col = left + 1; col <= right + 1; col++)\r
+ {\r
+ /* Move to row,col */\r
+ asm mov bh , 0;\r
+ asm mov dh , bottom;\r
+ asm mov dl , col;\r
+ asm mov ah , 02h;\r
+ asm int 10h;\r
+ \r
+ /* Get character */\r
+ asm mov ah , 0Fh;\r
+ asm int 10h;\r
+ asm mov ah , 08h;\r
+ asm int 10h;\r
+ \r
+ /* Write in attribute 7 */\r
+ asm mov ah , 09h;\r
+ asm mov bl, 07h;\r
+ asm mov cx, 01h;\r
+ asm int 10h;\r
+ }\r
+ \r
+ /* Return to original position */\r
+ /* Move to row,col */\r
+ asm mov bh , 0;\r
+ asm mov dh , oldrow;\r
+ asm mov dl , oldcol;\r
+ asm mov ah , 02h;\r
+ asm int 10h;\r
+ }\r
+ \r
+ void bprintf(char *format, ...)\r
+ {\r
+ /* print text to graphics screen correctly */\r
+ \r
+ va_list arg_ptr;\r
+ char output[1000];\r
+ int c, r, n, p = 0;\r
+ unsigned char text;\r
+ unsigned char page;\r
+ \r
+ va_start(arg_ptr, format);\r
+ vsprintf(output, format, arg_ptr);\r
+ \r
+ if (strcmp(output,"\r\n") == 0)\r
+ fputs(output,stdout);\r
+ \r
+ else\r
+ {\r
+ asm mov ah , 0Fh;\r
+ asm int 10h;\r
+ asm mov page, bh;\r
+ \r
+ getmode(&n);\r
+ getcursor(&r,&c);\r
+ \r
+ while (output[p])\r
+ {\r
+ text = output[p++];\r
+ asm mov bh , page;\r
+ asm mov bl , attribute;\r
+ asm mov cx , 01h;\r
+ asm mov ah , 09h;\r
+ asm mov al , text;\r
+ asm int 10h;\r
+ \r
+ c++;\r
+ if (c < (n-1))\r
+ at( r, c);\r
+ else\r
+ {\r
+ c = 0;\r
+ at(++r,0);\r
+ }\r
+ }\r
+ }\r
+ }\r
+ \r
+ void wrtstr(char *output)\r
+ {\r
+ /* TTY text output. The original screen attributes remain\r
+ unaffected */\r
+ \r
+ int p = 0;\r
+ unsigned char page;\r
+ unsigned char text;\r
+ \r
+ asm mov ah , 0Fh;\r
+ asm int 10h;\r
+ asm mov page, bh;\r
+ \r
+ while (output[p])\r
+ {\r
+ text = output[p++];\r
+ asm mov bh , page;\r
+ asm mov ah , 0Eh;\r
+ asm mov al , text;\r
+ asm int 10h;\r
+ }\r
+ }\r
+ \r
+ void getwin(int left, int top, int right, int bottom, char *buffer)\r
+ {\r
+ /* Read a text window into a variable */\r
+ \r
+ int oldleft;\r
+ unsigned char page;\r
+ \r
+ asm mov ah , 0Fh;\r
+ asm int 10h;\r
+ asm mov page, bh;\r
+ \r
+ while(top <= bottom)\r
+ {\r
+ oldleft = left;\r
+ while(left <= right)\r
+ {\r
+ at(top,left);\r
+ asm mov bh , page;\r
+ asm mov ah , 08h;\r
+ asm int 10h;\r
+ *buffer++ = _AL;\r
+ *buffer++ = _AH;\r
+ left++;\r
+ }\r
+ left = oldleft;\r
+ top++;\r
+ }\r
+ }\r
+ \r
+ void putwin(int left, int top, int right, int bottom,char *buffer)\r
+ {\r
+ /* Display a text window from a variable */\r
+ \r
+ int oldleft;\r
+ unsigned char chr;\r
+ unsigned char attr;\r
+ unsigned char page;\r
+ \r
+ asm mov ah , 0Fh;\r
+ asm int 10h;\r
+ asm mov page, bh;\r
+ \r
+ while(top <= bottom)\r
+ {\r
+ oldleft = left;\r
+ while(left <= right)\r
+ {\r
+ at(top,left);\r
+ chr = *buffer++;\r
+ attr = *buffer++;\r
+ asm mov bh , page;\r
+ asm mov ah , 09h;\r
+ asm mov al, chr;\r
+ asm mov bl, attr;\r
+ asm mov cx,1;\r
+ asm int 10h;\r
+ left++;\r
+ }\r
+ left = oldleft;\r
+ top++;\r
+ }\r
+ }\r
+ \r
+ void setpalette(unsigned char palno)\r
+ {\r
+ /* Sets the video palette */\r
+ \r
+ asm mov bh,01h;\r
+ asm mov bl,palno;\r
+ asm mov ah,0Bh;\r
+ asm int 10h;\r
+ }\r
+ \r
+ void setborder(unsigned char x)\r
+ {\r
+ /* Set border colour */\r
+ \r
+ asm mov bh, x;\r
+ asm mov ax ,1001h;\r
+ asm int 10h;\r
+ }\r
+ \r
+ void setlines(unsigned char x)\r
+ {\r
+ /* Set text display number of lines */\r
+ \r
+ asm mov ah,11h;\r
+ asm mov al,x;\r
+ asm mov bl,0;\r
+ asm int 10h;\r
+ }\r
+ \r
+ void graphbackground(unsigned char colour)\r
+ {\r
+ /* Selects the background colour for a graphics mode */\r
+ \r
+ asm mov bh,0;\r
+ asm mov bl,colour;\r
+ asm mov ah, 0Bh;\r
+ asm int 10h;\r
+ }\r
+ \r
+ void plot(int x, int y, unsigned char colour)\r
+ {\r
+ /* Sets a pixel at the specified coordinates to the specified\r
+ colour.\r
+ The variables _lastx and _lasty are updated. */\r
+ \r
+ unsigned char far *video;\r
+ \r
+ _lastx = x;\r
+ _lasty = y;\r
+ \r
+ if (_dmode == 19)\r
+ {\r
+ video = MK_FP(0xA000,0);\r
+ video[x+y*320] = colour;\r
+ }\r
+ else\r
+ {\r
+ asm mov al , colour;\r
+ asm mov bh , 00;\r
+ asm mov cx , x;\r
+ asm mov dx , y;\r
+ asm mov ah , 0Ch;\r
+ asm int 10h;\r
+ }\r
+ }\r
+ \r
+ int pixset(int x, int y)\r
+ {\r
+ /* Returns the colour of the specified pixel */\r
+ \r
+ asm mov cx ,x;\r
+ asm mov dx ,y;\r
+ asm mov ah ,0Dh;\r
+ asm int 10h;\r
+ return(_AL);\r
+ }\r
+ \r
+ void move(int x, int y)\r
+ {\r
+ /* Sets the value of the variables _lastx and _lasty */\r
+ \r
+ _lastx = x;\r
+ _lasty = y;\r
+ }\r
+ \r
+ void line(int a, int b, int c, int d, int col)\r
+ {\r
+ /* Draws a straight line from (a,b) to (c,d) in colour col */\r
+ \r
+ int u;\r
+ int v;\r
+ int d1x;\r
+ int d1y;\r
+ int d2x;\r
+ int d2y;\r
+ int m;\r
+ int n;\r
+ int s;\r
+ int i;\r
+ \r
+ if (a < 0)\r
+ a = 0;\r
+ else\r
+ if (a > maxx)\r
+ a = maxx;\r
+ \r
+ if (c < 0)\r
+ c = 0;\r
+ else\r
+ if (c > maxx)\r
+ c = maxx;\r
+ \r
+ if (b < 0)\r
+ b = 0;\r
+ else\r
+ if (b > maxy)\r
+ b = maxy;\r
+ \r
+ if (d < 0)\r
+ d = 0;\r
+ else\r
+ if (d > maxy)\r
+ d = maxy;\r
+ \r
+ u = c - a;\r
+ v = d - b;\r
+ \r
+ if (u == 0)\r
+ {\r
+ d1x = 0;\r
+ m = 0;\r
+ }\r
+ else\r
+ {\r
+ m = abs(u);\r
+ if (u < 0)\r
+ d1x = -1;\r
+ else\r
+ if (u > 0)\r
+ d1x = 1;\r
+ }\r
+ if ( v == 0)\r
+ {\r
+ d1y = 0;\r
+ n = 0;\r
+ }\r
+ else\r
+ {\r
+ n = abs(v);\r
+ if (v < 0)\r
+ d1y = -1;\r
+ else\r
+ if (v > 0)\r
+ d1y = 1;\r
+ }\r
+ if (m > n)\r
+ {\r
+ d2x = d1x;\r
+ d2y = 0;\r
+ }\r
+ else\r
+ {\r
+ d2x = 0;\r
+ d2y = d1y;\r
+ m = n;\r
+ n = abs(u);\r
+ }\r
+ s = m / 2;\r
+ \r
+ for (i = 0; i <= m; i++)\r
+ {\r
+ asm mov al , col;\r
+ asm mov bh , 0;\r
+ asm mov ah ,0Ch;\r
+ asm mov cx ,a;\r
+ asm mov dx ,b;\r
+ asm int 10h;\r
+ \r
+ s += n;\r
+ if (s >= m)\r
+ {\r
+ s -= m;\r
+ a += d1x;\r
+ b += d1y;\r
+ }\r
+ else\r
+ {\r
+ a += d2x;\r
+ b += d2y;\r
+ }\r
+ }\r
+ _lastx = a;\r
+ _lasty = b;\r
+ }\r
+ \r
+ void ellipse(int x, int y, int xrad, int yrad,double incline,int\r
+ col)\r
+ {\r
+ /* Draws an ellipse */\r
+ \r
+ int f;\r
+ float a;\r
+ float b;\r
+ float c;\r
+ float d;\r
+ int cols;\r
+ double div;\r
+ \r
+ incline = 1 / sintable[(int)incline];\r
+ \r
+ if (getmode(&cols) == 6)\r
+ div = 2.2;\r
+ else\r
+ div = 1.3;\r
+ \r
+ /* Compensate for pixel shape */\r
+ \r
+ a = x + xrad;\r
+ b = y + sintable[0] * yrad + xrad/incline / div;\r
+ \r
+ for(f = 5; f < 360; f += 5)\r
+ {\r
+ c = x + costable[f] * xrad;\r
+ d = y + sintable[f] * yrad + (costable[f] *\r
+ xrad)/incline/div;\r
+ \r
+ line(a,b,c,d,col);\r
+ \r
+ a = c;\r
+ b = d;\r
+ }\r
+ /* Ensure join */\r
+ line(a,b,x + xrad,y + sintable[0] * yrad + xrad/incline /\r
+ div,col);\r
+ }\r
+ \r
+ void polygon(int x, int y, int rad, int col, int sides, int start)\r
+ {\r
+ /* Draws a regular polygon */\r
+ \r
+ double f;\r
+ double div;\r
+ double a;\r
+ double b;\r
+ double c;\r
+ double d;\r
+ double aa;\r
+ double bb;\r
+ int cols;\r
+ double step;\r
+ \r
+ step = 360 / sides;\r
+ \r
+ if (getmode(&cols) == 6)\r
+ div = 2.2;\r
+ else\r
+ div = 1.3;\r
+ aa = a = x + costable[start] * rad;\r
+ bb = b = y + sintable[start] * rad / div;\r
+ \r
+ for(f = start + step; f < start + 360; f += step)\r
+ {\r
+ c = x + costable[(int)f] * rad;\r
+ d = y + sintable[(int)f] * rad / div;\r
+ line(a,b,c,d,col);\r
+ a = c;\r
+ b = d;\r
+ }\r
+ line(a,b,aa,bb,col);\r
+ }\r
+ \r
+ void arc(int x, int y, int rad, int start, int end,int col)\r
+ {\r
+ /* Draw an arc */\r
+ \r
+ int f;\r
+ float a;\r
+ float b;\r
+ float c;\r
+ float d;\r
+ int cols;\r
+ float div;\r
+ \r
+ if (getmode(&cols) == 6)\r
+ div = 2.2;\r
+ else\r
+ div = 1.3;\r
+ a = x + costable[start] * rad;\r
+ b = y + sintable[start] * rad / div;\r
+ \r
+ for(f = start; f <= end; f ++)\r
+ {\r
+ c = x + costable[f] * rad;\r
+ d = y + sintable[f] * rad / div;\r
+ line(a,b,c,d,col);\r
+ a = c;\r
+ b = d;\r
+ }\r
+ }\r
+ \r
+ void segm(int x, int y, int rad, int start, int end,int col)\r
+ {\r
+ /* Draw a segment of a circle */\r
+ \r
+ int f;\r
+ float a;\r
+ float b;\r
+ float c;\r
+ float d;\r
+ int cols;\r
+ double div;\r
+ \r
+ if (getmode(&cols) == 6)\r
+ div = 2.2;\r
+ else\r
+ div = 1.3;\r
+ a = x + costable[start] * rad;\r
+ b = y + sintable[start] * rad / div;\r
+ \r
+ line(x,y,a,b,col);\r
+ \r
+ for(f = start; f <= end ; f ++)\r
+ {\r
+ c = x + costable[f] * rad;\r
+ d = y + sintable[f] * rad / div;\r
+ line(a,b,c,d,col);\r
+ a = c;\r
+ b = d;\r
+ }\r
+ line(x,y,a,b,col);\r
+ }\r
+ \r
+ void box(int xa,int ya, int xb, int yb, int col)\r
+ {\r
+ /* Draws a box for use in 2d histogram graphs etc */\r
+ \r
+ line(xa,ya,xa,yb,col);\r
+ line(xa,yb,xb,yb,col);\r
+ line(xb,yb,xb,ya,col);\r
+ line(xb,ya,xa,ya,col);\r
+ }\r
+ \r
+ void tri(int xa,int ya, int xb, int yb, int xc, int yc,int col)\r
+ {\r
+ /* Draw a triangle */\r
+ \r
+ line(xa,ya,xb,yb,col);\r
+ line(xb,yb,xc,yc,col);\r
+ line(xc,yc,xa,ya,col);\r
+ }\r
+ \r
+ void fill(int x, int y, int col,int pattern)\r
+ {\r
+ /* Fill a boundered shape using a hatch pattern */\r
+ \r
+ int xa;\r
+ int ya;\r
+ int bn;\r
+ int byn;\r
+ \r
+ int hatch[10][8] = { 255,255,255,255,255,255,255,255,\r
+ 128,64,32,16,8,4,2,1,\r
+ 1,2,4,8,16,32,64,128,\r
+ 1,2,4,8,8,4,2,1,\r
+ 238,238,238,238,238,238,238,238,\r
+ 170,85,170,85,170,85,170,85,\r
+ 192,96,48,24,12,6,3,1,\r
+ 62,62,62,0,227,227,227,0,\r
+ 129,66,36,24,24,36,66,129,\r
+ 146,36,146,36,146,36,146,36\r
+ };\r
+ \r
+ /* Patterns for fill, each integer describes a row of dots */\r
+ \r
+ xa = x;\r
+ ya = y; /* Save Origin */\r
+ \r
+ if(pixset(x,y))\r
+ return;\r
+ \r
+ bn = 1;\r
+ byn = 0;\r
+ \r
+ do\r
+ {\r
+ if (hatch[pattern][byn] != 0)\r
+ {\r
+ /* If blank ignore */\r
+ do\r
+ {\r
+ if ((bn & hatch[pattern][byn]) == bn)\r
+ {\r
+ asm mov al , col;\r
+ asm mov bh , 00;\r
+ asm mov cx , x;\r
+ asm mov dx , y;\r
+ asm mov ah , 0Ch;\r
+ asm int 10h;\r
+ }\r
+ x--;\r
+ bn <<= 1;\r
+ if (bn > 128)\r
+ bn = 1;\r
+ }\r
+ while(!pixset(x,y) && (x > -1));\r
+ \r
+ x = xa + 1;\r
+ bn = 128;\r
+ \r
+ do\r
+ {\r
+ if ((bn & hatch[pattern][byn]) == bn)\r
+ {\r
+ asm mov al , col;\r
+ asm mov bh , 00;\r
+ asm mov cx , x;\r
+ asm mov dx , y;\r
+ asm mov ah , 0Ch;\r
+ asm int 10h;\r
+ }\r
+ x++;\r
+ bn >>=1;\r
+ if (bn <1)\r
+ bn = 128;\r
+ }\r
+ while((!pixset(x,y)) && (x <= maxx));\r
+ }\r
+ x = xa;\r
+ y--;\r
+ bn = 1;\r
+ byn++;\r
+ if (byn > 7)\r
+ byn = 0;\r
+ \r
+ }\r
+ while(!pixset(x,y) && ( y > -1));\r
+ \r
+ /* Now travel downwards */\r
+ \r
+ y = ya + 1;\r
+ \r
+ byn = 7;\r
+ bn = 1;\r
+ do\r
+ {\r
+ /* Travel left */\r
+ if (hatch[pattern][byn] !=0)\r
+ {\r
+ do\r
+ {\r
+ if ( (bn & hatch[pattern][byn]) == bn)\r
+ {\r
+ asm mov al , col;\r
+ asm mov bh , 00;\r
+ asm mov cx , x;\r
+ asm mov dx , y;\r
+ asm mov ah , 0Ch;\r
+ asm int 10h;\r
+ }\r
+ \r
+ x--;\r
+ bn <<= 1;\r
+ if (bn > 128)\r
+ bn = 1;\r
+ }\r
+ while(!pixset(x,y) && (x > -1));\r
+ \r
+ /* Back to x origin */\r
+ x = xa + 1 ;\r
+ bn = 128;\r
+ \r
+ /* Travel right */\r
+ do\r
+ {\r
+ if ((bn & hatch[pattern][byn]) == bn)\r
+ {\r
+ asm mov al , col;\r
+ asm mov bh , 00;\r
+ asm mov cx , x;\r
+ asm mov dx , y;\r
+ asm mov ah , 0Ch;\r
+ asm int 10h;\r
+ }\r
+ x++;\r
+ bn >>=1;\r
+ if (bn <1)\r
+ bn = 128;\r
+ }\r
+ while((!pixset(x,y)) && (x <= maxx));\r
+ }\r
+ x = xa;\r
+ bn = 1;\r
+ y++;\r
+ byn--;\r
+ if (byn < 0)\r
+ byn = 7;\r
+ }\r
+ while((!pixset(x,y)) && (y <= maxy));\r
+ }\r
+ \r
+ void invert(int xa,int ya, int xb, int yb, int col)\r
+ {\r
+ /* Invert a pixel window */\r
+ \r
+ union REGS inreg,outreg;\r
+ \r
+ inreg.h.al = (unsigned char)(128 | col);\r
+ inreg.h.ah = 0x0C;\r
+ for(inreg.x.cx = (unsigned int)xa; inreg.x.cx <= (unsigned\r
+ int)xb; inreg.x.cx++)\r
+ for(inreg.x.dx = (unsigned)ya; inreg.x.dx <= (unsigned)yb;\r
+ inreg.x.dx++)\r
+ int86(0x10, &inreg, &outreg);\r
+ }\r
+ \r
+ void circle(int x_centre , int y_centre, int radius, int colour)\r
+ {\r
+ int x,y,delta;\r
+ int startx,endx,x1,starty,endy,y1;\r
+ int asp_ratio;\r
+ \r
+ if (_dmode == 6)\r
+ asp_ratio = 22;\r
+ else\r
+ asp_ratio = 13;\r
+ \r
+ y = radius;\r
+ delta = 3 - 2 * radius;\r
+ for(x = 0; x < y; )\r
+ {\r
+ starty = y * asp_ratio / 10;\r
+ endy = (y + 1) * asp_ratio / 10;\r
+ startx = x * asp_ratio / 10;\r
+ endx = (x + 1) * asp_ratio / 10;\r
+ for(x1 = startx; x1 < endx; ++x1)\r
+ {\r
+ plot(x1+x_centre,y+y_centre,colour);\r
+ plot(x1+x_centre,y_centre - y,colour);\r
+ plot(x_centre - x1,y_centre - y,colour);\r
+ plot(x_centre - x1,y + y_centre,colour);\r
+ }\r
+ \r
+ for(y1 = starty; y1 < endy; ++y1)\r
+ {\r
+ plot(y1+x_centre,x+y_centre,colour);\r
+ plot(y1+x_centre,y_centre - x,colour);\r
+ plot(x_centre - y1,y_centre - x,colour);\r
+ plot(x_centre - y1,x + y_centre,colour);\r
+ }\r
+ \r
+ if (delta < 0)\r
+ delta += 4 * x + 6;\r
+ else\r
+ {\r
+ delta += 4*(x-y)+10;\r
+ y--;\r
+ }\r
+ x++;\r
+ }\r
+ \r
+ if(y)\r
+ {\r
+ starty = y * asp_ratio / 10;\r
+ endy = (y + 1) * asp_ratio / 10;\r
+ startx = x * asp_ratio / 10;\r
+ endx = (x + 1) * asp_ratio / 10;\r
+ for(x1 = startx; x1 < endx; ++x1)\r
+ {\r
+ plot(x1+x_centre,y+y_centre,colour);\r
+ plot(x1+x_centre,y_centre - y,colour);\r
+ plot(x_centre - x1,y_centre - y,colour);\r
+ plot(x_centre - x1,y + y_centre,colour);\r
+ }\r
+ \r
+ for(y1 = starty; y1 < endy; ++y1)\r
+ {\r
+ plot(y1+x_centre,x+y_centre,colour);\r
+ plot(y1+x_centre,y_centre - x,colour);\r
+ plot(x_centre - y1,y_centre - x,colour);\r
+ plot(x_centre - y1,x + y_centre,colour);\r
+ }\r
+ }\r
+ }\r
+ \r
+ void draw(int x, int y, int colour)\r
+ {\r
+ /* Draws a line from _lastx,_lasty to x,y */\r
+ \r
+ line(_lastx,_lasty,x,y,colour);\r
+ }\r
+ \r
+ void psprite(SPRITE *sprite,int x,int y)\r
+ {\r
+ int origx;\r
+ int origy;\r
+ int z;\r
+ int count;\r
+ int col;\r
+ int pos;\r
+ unsigned char far *video;\r
+ \r
+ if (_dmode == 19)\r
+ {\r
+ /* Super fast direct video write in mode 19 for sprites */\r
+ \r
+ video = MK_FP(0xA000,0);\r
+ \r
+ origx = x;\r
+ origy = y;\r
+ \r
+ if (sprite->x != -1)\r
+ {\r
+ /* This sprite has been displayed before */\r
+ /* replace background */\r
+ /* This must be done first in case the sprite\r
+ overlaps itself */\r
+ x = sprite->x;\r
+ y = sprite->y;\r
+ col = 0;\r
+ pos = x + y * 320;\r
+ for(count = 0; count < 256; count++)\r
+ {\r
+ video[pos] = sprite->save[count];\r
+ col++;\r
+ if (col == 16)\r
+ {\r
+ pos += 305;\r
+ col = 0;\r
+ }\r
+ else\r
+ pos++;\r
+ }\r
+ }\r
+ \r
+ x = origx;\r
+ y = origy;\r
+ col = 0;\r
+ \r
+ pos = x + y * 320;\r
+ \r
+ for(count = 0; count < 256; count++)\r
+ {\r
+ sprite->save[count] = video[pos];\r
+ z = sprite->data[count];\r
+ if (z != 255)\r
+ video[pos] = z;\r
+ \r
+ col++;\r
+ if (col == 16)\r
+ {\r
+ pos += 305;\r
+ col = 0;\r
+ }\r
+ else\r
+ pos++;\r
+ }\r
+ sprite->x = origx;\r
+ sprite->y = origy;\r
+ \r
+ return;\r
+ }\r
+ \r
+ origx = x;\r
+ origy = y;\r
+ \r
+ if (sprite->x != -1)\r
+ {\r
+ /* This sprite has been displayed before */\r
+ /* replace background */\r
+ /* This must be done first in case the sprite overlaps\r
+ itself */\r
+ x = sprite->x;\r
+ y = sprite->y;\r
+ col = 0;\r
+ for(count = 0; count < 256; count++)\r
+ {\r
+ if ((x >= 0) && (y >= 0) && (x < maxx) && (y < maxy))\r
+ {\r
+ z = sprite->save[count];\r
+ asm mov al , z;\r
+ asm mov bh , 00;\r
+ asm mov cx , x;\r
+ asm mov dx , y;\r
+ asm mov ah , 0Ch;\r
+ asm int 10h;\r
+ }\r
+ col++;\r
+ if (col == 16)\r
+ {\r
+ y++;\r
+ x = sprite->x;\r
+ col = 0;\r
+ }\r
+ else\r
+ x++;\r
+ }\r
+ }\r
+ \r
+ x = origx;\r
+ y = origy;\r
+ col = 0;\r
+ \r
+ for(count = 0; count < 256; count++)\r
+ {\r
+ if ((x >= 0) && (y >= 0) && (x < maxx) && (y < maxy))\r
+ {\r
+ asm mov cx , x;\r
+ asm mov dx , y;\r
+ asm mov ah , 0Dh;\r
+ asm int 10h;\r
+ asm mov z ,al;\r
+ sprite->save[count] = z;\r
+ z = sprite->data[count];\r
+ \r
+ if (z != 255)\r
+ {\r
+ asm mov al , z;\r
+ asm mov bh , 0;\r
+ asm mov cx , x;\r
+ asm mov dx , y;\r
+ asm mov ah , 0Ch;\r
+ asm int 10h;\r
+ }\r
+ }\r
+ col++;\r
+ if (col == 16)\r
+ {\r
+ y++;\r
+ x = origx;\r
+ col = 0;\r
+ }\r
+ else\r
+ x++;\r
+ }\r
+ sprite->x = origx;\r
+ sprite->y = origy;\r
+ return;\r
+ }\r
+ \r
+ \r
+\r
+Displaying A PCX File\r
+\r
+The following program is offered as a practical example of graphics with\r
+the IBM PC. It reads a file of the `PCX' format and displays the image on\r
+the screen.\r
+\r
+ \r
+ /* Read a PCX file and display image */\r
+ \r
+ #include <dos.h>\r
+ #include <io.h>\r
+ #include <fcntl.h>\r
+ \r
+ typedef struct\r
+ {\r
+ unsigned char man;\r
+ unsigned char version;\r
+ unsigned char encoding;\r
+ unsigned char bpp;\r
+ int xmin;\r
+ int ymin;\r
+ int xmax;\r
+ int ymax;\r
+ int hdpi;\r
+ int vdpi;\r
+ int colormap[24];\r
+ char reserved;\r
+ unsigned char planes;\r
+ int bpl;\r
+ int palette;\r
+ int hss;\r
+ int vsize;\r
+ char pad[54];\r
+ }\r
+ PCX_HEADER;\r
+ \r
+ PCX_HEADER header;\r
+ \r
+ int x;\r
+ int y;\r
+ \r
+ union REGS inreg,outreg;\r
+ \r
+ void setvideo(unsigned char mode)\r
+ {\r
+ /* Sets the video display mode and clears the screen */\r
+ \r
+ inreg.h.al = mode;\r
+ inreg.h.ah = 0x00;\r
+ int86(0x10, &inreg, &outreg);\r
+ }\r
+ \r
+ void plot(int x, int y, unsigned char colour)\r
+ {\r
+ \r
+ if (x < header.xmax && y < header.ymax)\r
+ {\r
+ \r
+ /* Direct video plot in modes 16 & 18 only! */\r
+ asm mov ax,y;\r
+ asm mov dx,80;\r
+ asm mul dx;\r
+ asm mov bx,x;\r
+ asm mov cl,bl;\r
+ \r
+ asm shr bx,1;\r
+ asm shr bx,1;\r
+ asm shr bx,1;\r
+ asm add bx,ax;\r
+ \r
+ asm and cl,7;\r
+ asm xor cl,7;\r
+ asm mov ah,1;\r
+ asm shl ah,cl;\r
+ \r
+ asm mov dx,3ceh;\r
+ asm mov al,8;\r
+ asm out dx,ax;\r
+ \r
+ asm mov ax,(02h shl 8) + 5;\r
+ asm out dx,ax;\r
+ \r
+ asm mov ax,0A000h;\r
+ asm mov es,ax;\r
+ \r
+ asm mov al,es:[bx];\r
+ asm mov al,byte ptr colour;\r
+ asm mov es:[bx],al;\r
+ \r
+ asm mov ax,(0FFh shl 8 ) + 8;\r
+ asm out dx,ax;\r
+ \r
+ asm mov ax,(00h shl 8) + 5;\r
+ asm out dx,ax;\r
+ }\r
+ }\r
+ \r
+ void DISPLAY(unsigned char data)\r
+ {\r
+ int n;\r
+ int bit;\r
+ \r
+ bit = 32;\r
+ \r
+ for (n = 0; n < 6; n++)\r
+ {\r
+ if (data & bit)\r
+ plot(x,y,1);\r
+ else\r
+ plot(x,y,0);\r
+ bit >>= 1;\r
+ x++;\r
+ }\r
+ }\r
+ \r
+ main(int argc, char *argv[])\r
+ {\r
+ int fp;\r
+ int total_bytes;\r
+ int n;\r
+ unsigned char data;\r
+ int count;\r
+ int scan;\r
+ \r
+ if (argc != 2)\r
+ {\r
+ puts("USAGE IS getpcx <filename>");\r
+ exit(0);\r
+ }\r
+ \r
+ setvideo(16);\r
+ \r
+ x = 0;\r
+ y = 0;\r
+ \r
+ fp = open(argv[1],O_RDONLY|O_BINARY);\r
+ \r
+ _read(fp,&header,128);\r
+ \r
+ total_bytes = header.planes * header.bpl;\r
+ \r
+ for(scan = 0; scan <= header.ymax; scan++)\r
+ {\r
+ x = 0;\r
+ \r
+ /* First scan line */\r
+ \r
+ for(n = 0; n < total_bytes; n++)\r
+ {\r
+ /* Read byte */\r
+ _read(fp,&data,1);\r
+ \r
+ count = data & 192;\r
+ \r
+ if (count == 192)\r
+ {\r
+ count = data & 63;\r
+ n += count - 1;\r
+ _read(fp,&data,1);\r
+ while(count)\r
+ {\r
+ DISPLAY(data);\r
+ count--;\r
+ }\r
+ }\r
+ else\r
+ DISPLAY(data);\r
+ \r
+ }\r
+ x = 0;\r
+ y++;\r
+ }\r
+ }\r
+ \r
+\r
+Drawing Circles\r
+\r
+\r
+What has drawing circles got to do with advanced C programming? Well\r
+quite a lot, it is a task which is often desired by modern programmers,\r
+and it is a task which can be attacked from a number of angles. This\r
+example illustrates some of the ideas already discussed for replacing\r
+floating point numbers with integers, and using lookup tables rather than\r
+repeat calls to maths functions.\r
+\r
+A circle may be drawn by plotting each point on its circumference. The\r
+location of any point is given by;\r
+\r
+\r
+ Xp = Xo + Sine(Angle) * Radius\r
+ Yp = Yo + Cosine(Angle) * Radius\r
+\r
+Where Xp,Yp is the point to be plotted, and Xo,Yo is the centre of the\r
+circle.\r
+\r
+Thus, the simplest way to draw a circle is to calculate Xp and Yp for\r
+each angle between 1 and 360 degrees and to plot these points. There is\r
+however one fundamental error with this. As the radius of the circle\r
+increases, so also does the length of the arc between each angular point.\r
+Thus a circle of sufficient radius will be drawn with a dotted line\r
+rather than a solid line.\r
+\r
+The problem of the distance between the angular points may be tackled in\r
+two ways;\r
+\r
+ 1)The number of points to be plotted can be increased, to say every 30\r
+ minutes.\r
+ 2)A straight line may be drawn between each angular point.\r
+\r
+The simplest circle drawing pseudo-code may then look like this;\r
+\r
+\r
+ FOR angle = 1 TO 360\r
+ PLOT Xo + SINE(angle) * radius, Yo + COSINE(angle) * radius\r
+ NEXT angle\r
+\r
+This code has two major disadvantages;\r
+\r
+ 1) It uses REAL numbers for the sine and cosine figures\r
+ 2) It makes numerous calculations of sine and cosine values\r
+\r
+Both of these disadvantages result in a very slow piece of code. Since a\r
+circle is a regular figure with two axis of symmetry, one in both the X\r
+and Y axis, one only needs to calculate the relative offsets of points in\r
+one quadrant of the circle and then these offsets may be applied to the\r
+other three quadrants to produce a faster piece of code. Faster because\r
+the slow sine and cosine calculations are only done 90 times instead of\r
+360 times;\r
+\r
+\r
+ FOR angle = 1 TO 90\r
+ Xa = SINE(angle) * radius\r
+ Ya = COSINE(angle) * radius\r
+ PLOT Xo + Xa, Yo + Ya\r
+ PLOT Xo + Xa, Yo - Ya\r
+ PLOT Xo - Xa, Yo + Ya\r
+ PLOT Xo - Xa, Yo - Ya\r
+ NEXT angle\r
+\r
+A further enhancement may be made by making use of sine and cosine lookup\r
+tables instead of calculating them. This means calculating the sine and\r
+cosine values for each required angle and storing them in a table. Then,\r
+instead of calculating the values for each angle the circle drawing code\r
+need only retrieve the values from a table;\r
+\r
+\r
+ FOR angle = 1 TO 90\r
+ Xa = SINE[angle] * radius\r
+ Ya = COSINE[angle] * radius\r
+ PLOT Xo + Xa, Yo + Ya\r
+ PLOT Xo + Xa, Yo - Ya\r
+ PLOT Xo - Xa, Yo + Ya\r
+ PLOT Xo - Xa, Yo - Ya\r
+ NEXT angle\r
+\r
+\r
+Most computer languages work in RADIANS rather than DEGREES. There being\r
+approximately 57 degrees in one radian, 2 * PI radians in one circle.\r
+This implies that to calculate sine and cosine values of sufficient\r
+points to draw a reasonable circle using radians one must again use real\r
+numbers, that is numbers which have figures following a decimal point.\r
+Real number arithmetic, also known as floating point arithmetic, is\r
+horrendously slow to calculate. Integer arithmetic on the other hand is\r
+very quick to calculate, but less precise.\r
+\r
+To use integer arithmetic in circle drawing code requires ingenuity. If\r
+one agrees to use sine and cosine lookup tables for degrees, rather than\r
+radians. Then the sine value of an angle of 1 degree is;\r
+\r
+ 0.0175\r
+\r
+Which, truncated to an integer becomes zero! To overcome this the sine\r
+and cosine values held in the table should be multiplied by some factor,\r
+say 10000. Then, the integer value of the sine of an angle of 1 degree\r
+becomes;\r
+\r
+ 175\r
+\r
+If the sine and cosine values have been multiplied by a factor, then when\r
+the calculation of the point's offset is carried out one must remember to\r
+divide the result by the same factor. Thus the calculation becomes;\r
+\r
+ Xa = SINE[angle] * radius / factor\r
+ Ya = COSINE[angle] * radius / factor\r
+\r
+The final obstacle to drawing circles on a computer is the relationship\r
+between the width of the display screen and its height. This ratio\r
+between width and height is known as the "aspect ratio" and varies upon\r
+video display mode. The IBM VGA 256 colour mode for example can display\r
+320 pixels across and 200 up the screen. This equates to an aspect ratio\r
+of 1:1.3. If the circle drawing code ignores the aspect ratio, then the\r
+shape displayed will often be ovalar to a greater or lesser degree due to\r
+the rectangular shape of the display pixels. Thus in order to display a\r
+true circle, the formulae to calculate each point on the circumference\r
+must be amended to calculate a slight ellipse in compensation of the\r
+distorting factor of the display.\r
+\r
+The offset formulae then become;\r
+\r
+ Xa = SINE[angle] * radius / factor\r
+ Ya = COSINE[angle] * radius / (factor * aspect ratio)\r
+\r
+The following short C program illustrates a practical circle drawing code\r
+segment, in a demonstrable form;\r
+\r
+\r
+ /* Circles.c A demonstration circle drawing program for the IBM PC\r
+ */\r
+ \r
+ \r
+ #include <stdlib.h>\r
+ \r
+ int sintable[91] = {0,175,349,523,698,\r
+ 872,1045,1219,1392,\r
+ 1564,1736,1908,2079,\r
+ 2250,2419,2588,2756,\r
+ 2924,3090,3256,3420,\r
+ 3584,3746,3907,4067,\r
+ 4226,4384,4540,4695,\r
+ 4848,5000,5150,5299,\r
+ 5446,5592,5736,5878,\r
+ 6018,6157,6293,6428,\r
+ 6561,6691,6820,6947,\r
+ 7071,7193,7314,7431,\r
+ 7547,7660,7771,7880,\r
+ 7986,8090,8192,8290,\r
+ 8387,8480,8572,8660,\r
+ 8746,8829,8910,8988,\r
+ 9063,9135,9205,9272,\r
+ 9336,9397,9455,9511,\r
+ 9563,9613,9659,9703,\r
+ 9744,9781,9816,9848,\r
+ 9877,9903,9925,9945,\r
+ 9962,9976,9986,9994,\r
+ 9998,10000\r
+ };\r
+ \r
+ int costable[91] = { 10000,9998,9994,9986,9976,\r
+ 9962,9945,9925,9903,\r
+ 9877,9848,9816,9781,\r
+ 9744,9703,9659,9613,\r
+ 9563,9511,9455,9397,\r
+ 9336,9272,9205,9135,\r
+ 9063,8988,8910,8829,\r
+ 8746,8660,8572,8480,\r
+ 8387,8290,8192,8090,\r
+ 7986,7880,7771,7660,\r
+ 7547,7431,7314,7193,\r
+ 7071,6947,6820,6691,\r
+ 6561,6428,6293,6157,\r
+ 6018,5878,5736,5592,\r
+ 5446,5299,5150,5000,\r
+ 4848,4695,4540,4384,\r
+ 4226,4067,3907,3746,\r
+ 3584,3420,3256,3090,\r
+ 2924,2756,2588,2419,\r
+ 2250,2079,1908,1736,\r
+ 1564,1392,1219,1045,\r
+ 872,698,523,349,\r
+ 175,0\r
+ };\r
+ \r
+ void setvideo(unsigned char mode)\r
+ {\r
+ /* Sets the video display mode for an IBM PC */\r
+ \r
+ asm mov al , mode;\r
+ asm mov ah , 00;\r
+ asm int 10h;\r
+ }\r
+ \r
+ void plot(int x, int y, unsigned char colour)\r
+ {\r
+ /* Code for IBM PC BIOS ROM */\r
+ /* Sets a pixel at the specified coordinates to a specified\r
+ colour */\r
+ \r
+ /* Return if out of range */\r
+ if (x < 0 || y < 0 || x > 320 || y > 200)\r
+ return;\r
+ \r
+ asm mov al , colour;\r
+ asm mov bh , 0;\r
+ asm mov cx , x;\r
+ asm mov dx , y;\r
+ asm mov ah, 0Ch;\r
+ asm int 10h;\r
+ }\r
+ \r
+ void Line(int a, int b, int c, int d, int col)\r
+ {\r
+ /* Draws a straight line from point a,b to point c,d in colour\r
+ col */\r
+ \r
+ int u;\r
+ int v;\r
+ int d1x;\r
+ int d1y;\r
+ int d2x;\r
+ int d2y;\r
+ int m;\r
+ int n;\r
+ double s; /* The only real number variable, but it's essential\r
+ */\r
+ int i;\r
+ \r
+ u = c - a;\r
+ v = d - b;\r
+ if (u == 0)\r
+ {\r
+ d1x = 0;\r
+ m = 0;\r
+ }\r
+ else\r
+ {\r
+ m = abs(u);\r
+ if (u < 0)\r
+ d1x = -1;\r
+ else\r
+ if (u > 0)\r
+ d1x = 1;\r
+ }\r
+ \r
+ if ( v == 0)\r
+ {\r
+ d1y = 0;\r
+ n = 0;\r
+ }\r
+ else\r
+ {\r
+ n = abs(v);\r
+ if (v < 0)\r
+ d1y = -1;\r
+ else\r
+ if (v > 0)\r
+ d1y = 1;\r
+ }\r
+ if (m > n)\r
+ {\r
+ d2x = d1x;\r
+ d2y = 0;\r
+ }\r
+ else\r
+ {\r
+ d2x = 0;\r
+ d2y = d1y;\r
+ m = n;\r
+ n = abs(u);\r
+ }\r
+ s = m / 2;\r
+ \r
+ for (i = 0; i <= m; i++)\r
+ {\r
+ plot(a,b,col);\r
+ s += n;\r
+ if (s >= m)\r
+ {\r
+ s -= m;\r
+ a += d1x;\r
+ b += d1y;\r
+ }\r
+ else\r
+ {\r
+ a += d2x;\r
+ b += d2y;\r
+ }\r
+ }\r
+ }\r
+ \r
+ \r
+ void Circle(int x, int y, int rad, int col)\r
+ {\r
+ /* Draws a circle about origin x,y */\r
+ /* With a radius of rad */\r
+ /* The col parameter defines the colour for plotting */\r
+ \r
+ int f;\r
+ long xa;\r
+ long ya;\r
+ int a1;\r
+ int b1;\r
+ int a2;\r
+ int b2;\r
+ int a3;\r
+ int b3;\r
+ int a4;\r
+ int b4;\r
+ \r
+ \r
+ /* Calculate first point in each segment */\r
+ \r
+ a1 = x + ((long)(costable[0]) * (long)(rad) + 5000) / 10000;\r
+ b1 = y + ((long)(sintable[0]) * (long)(rad) + 5000) / 13000;\r
+ \r
+ a2 = x - ((long)(costable[0]) * (long)(rad) + 5000) / 10000;\r
+ b2 = y + ((long)(sintable[0]) * (long)(rad) + 5000) / 13000;\r
+ \r
+ a3 = x - ((long)(costable[0]) * (long)(rad) + 5000) / 10000;\r
+ b3 = y - ((long)(sintable[0]) * (long)(rad) + 5000) / 13000;\r
+ \r
+ a4 = x + ((long)(costable[0]) * (long)(rad) + 5000) / 10000;\r
+ b4 = y - ((long)(sintable[0]) * (long)(rad) + 5000) / 13000;\r
+ \r
+ /* Start loop at second point */\r
+ for(f = 1; f <= 90; f++)\r
+ {\r
+ /* Calculate offset to new point */\r
+ xa = ((long)(costable[f]) * (long)(rad) + 5000) / 10000;\r
+ ya = ((long)(sintable[f]) * (long)(rad) + 5000) / 13000;\r
+ \r
+ /* Draw a line from the previous point to the new point in\r
+ each segment */\r
+ Line(a1,b1,x + xa, y + ya,col);\r
+ Line(a2,b2,x - xa, y + ya,col);\r
+ Line(a3,b3,x - xa, y - ya,col);\r
+ Line(a4,b4,x + xa, y - ya,col);\r
+ \r
+ /* Update the previous point in each segment */\r
+ a1 = x + xa;\r
+ b1 = y + ya;\r
+ a2 = x - xa;\r
+ b2 = y + ya;\r
+ a3 = x - xa;\r
+ b3 = y - ya;\r
+ a4 = x + xa;\r
+ b4 = y - ya;\r
+ }\r
+ }\r
+ \r
+ main()\r
+ {\r
+ int n;\r
+ \r
+ /* Select VGA 256 colour 320 x 200 video mode */\r
+ setvideo(19);\r
+ \r
+ /* Draw some circles */\r
+ for(n = 0; n < 100; n++)\r
+ Circle(160,100,n,n + 20);\r
+ }\r
+ \r
+ \r
+\r
+Vesa Mode\r
+\r
+The VESA BIOS provides a number of new, and exciting video modes not\r
+supported by the standard BIOS. These modes vary from one video card to\r
+another, but most support the following modes:\r
+\r
+Mode Display\r
+ \r
+0x54 Text 16 colours 132 x 43\r
+0x55 Text 16 colours 132 x 25\r
+0x58 Graphics 16 colours 800 x 600\r
+0x5C Graphics 256 colours 800 x 600\r
+0x5D Graphics 16 colours 1024 x 768\r
+0x5F Graphics 256 colours 640 x 480\r
+0x60 Graphics 256 colours 1024 x 768\r
+0x64 Graphics 64k colours 640 x 480\r
+0x65 Graphics 64k colours 800 x 600\r
+0x6A Graphics 16 colours 800 x 600\r
+0x6C Graphics 16 colours 1280 x 1024\r
+0x70 Graphics 16m colours 320 x 200\r
+0x71 Graphics 16m colours 640 x 480\r
+\r
+These modes are in addition to the standard BIOS video modes described\r
+earlier.\r
+\r
+Setting a VESA video mode requires a call to a different BIOS function\r
+than the standard BIOS, as illustrated in the following example which\r
+enables any VESA or standard display mode to be selected from the DOS\r
+command line.\r
+\r
+ #include <dos.h>\r
+ #include <ctype.h>\r
+ \r
+ void setvideo(int mode)\r
+ {\r
+ /* Sets the video display to a VESA or normal mode and clears\r
+ the screen */\r
+ \r
+ union REGS inreg,outreg;\r
+ \r
+ inreg.h.ah = 0x4f;\r
+ inreg.h.al = 0x02;\r
+ inreg.x.bx = mode;\r
+ int86(0x10, &inreg, &outreg);\r
+ }\r
+ \r
+ main(int argc, char *argv[])\r
+ {\r
+ setvideo(atoi(argv[1]));\r
+ }\r
+\r
+\r
+Plotting pixels in a VESA mode graphics display can be acgieved with the\r
+standard BIOS plot functiona call, as illustrated here;\r
+\r
+ \r
+ void plot(int x, int y, unsigned char colour)\r
+ {\r
+ asm mov al , colour;\r
+ asm mov bh , 00;\r
+ asm mov cx , x;\r
+ asm mov dx , y;\r
+ asm mov ah , 0Ch;\r
+ asm int 10h;\r
+ }\r
+\r
+\r
+Or, in a 800 x 600 resolution mode you can use this fast direct video\r
+access plot function;\r
+\r
+ void plot( int x, int y, unsigned char pcolor)\r
+ {\r
+ /*\r
+ Fast 800 x 600 mode (0x58 or 0x102) plotting\r
+ */\r
+ \r
+ asm mov ax,y;\r
+ asm mov dx,800/8;\r
+ asm mul dx;\r
+ asm mov bx,x;\r
+ asm mov cl,bl;\r
+ \r
+ asm shr bx,1;\r
+ asm shr bx,1;\r
+ asm shr bx,1;\r
+ asm add bx,ax;\r
+ \r
+ asm and cl,7;\r
+ asm xor cl,7;\r
+ asm mov ah,1;\r
+ asm shl ah,cl;\r
+ \r
+ asm mov dx,03CEh;\r
+ asm mov al,8;\r
+ asm out dx,ax;\r
+ \r
+ asm mov ax,(02h shl 8) + 5;\r
+ asm out dx,ax;\r
+ \r
+ asm mov ax,0A000h;\r
+ asm mov es,ax;\r
+ \r
+ asm mov al,es:[bx];\r
+ asm mov al,byte ptr pcolor;\r
+ asm mov es:[bx],al;\r
+ \r
+ asm mov ax,(0FFh shl 8 ) + 8;\r
+ asm out dx,ax;\r
+ \r
+ asm mov ax,(00h shl 8) + 5;\r
+ asm out dx,ax;\r
+ }\r
+\r
+There are lots more functions supported by the VESA BIOS, but this will\r
+get you going with the basic operations. Remember though that when using\r
+VESA display modes, that the direct console I/O functions in the C\r
+compiler library may not function correctly.\r
+ \r
+ DIRECTORY SEARCHING WITH THE IBM PC AND DOS\r
+\r
+Amongst the many functions provided by DOS for programmers, are a pair of\r
+functions; "Find first" and "Find next" which are used to search a DOS\r
+directory for a specified file name or names. The first function, "Find\r
+first" is accessed via DOS interrupt 21, function 4E. It takes an ascii\r
+string file specification, which can include wildcards, and the required\r
+attribute for files to match. Upon return the function fills the disk\r
+transfer area (DTA) with details of the located file and returns with the\r
+carry flag clear. If an error occurs, such as no matching files are\r
+located, the function returns with the carry flag set.\r
+\r
+Following a successful call to "Find first", a program can call "Find\r
+next", DOS interrupt 21, function 4F, to locate the next file matching\r
+the specifications provided by the initial call to "Find first". If this\r
+function succeeds, then the DTA is filled in with details of the next\r
+matching file, and the function returns with the carry flag clear.\r
+Otherwise a return is made with the carry flag set.\r
+\r
+Most C compilers for the IBM PC provide non standard library functions\r
+for accessing these two functions. Turbo C provides "findfirst()" and\r
+"findnext()". Making use of the supplied library functions shields the\r
+programmer from the messy task of worrying about the DTA. Microsoft C\r
+programmers should substitue findfirst() with _dos_findfirst() and\r
+findnext() with _dos_findnext().\r
+\r
+The following Turbo C example imitates the DOS directory command, in a\r
+basic form;\r
+\r
+ #include <stdio.h>\r
+ #include <dir.h>\r
+ #include <dos.h>\r
+ \r
+ void main(void)\r
+ {\r
+ /* Display directory listing of current directory */\r
+ \r
+ int done;\r
+ int day;\r
+ int month;\r
+ int year;\r
+ int hour;\r
+ int min;\r
+ char amflag;\r
+ struct ffblk ffblk;\r
+ struct fcb fcb;\r
+ \r
+ /* First display sub directory entries */\r
+ done = findfirst("*.",&ffblk,16);\r
+ \r
+ while (!done)\r
+ {\r
+ year = (ffblk.ff_fdate >> 9) + 80;\r
+ month = (ffblk.ff_fdate >> 5) & 0x0f;\r
+ day = ffblk.ff_fdate & 0x1f;\r
+ hour = (ffblk.ff_ftime >> 11);\r
+ min = (ffblk.ff_ftime >> 5) & 63;\r
+ \r
+ amflag = 'a';\r
+ \r
+ if (hour > 12)\r
+ {\r
+ hour -= 12;\r
+ amflag = 'p';\r
+ }\r
+ \r
+ printf("%-11.11s <DIR> %02d-%02d-%02d %2d:%02d%c\n",\r
+ ffblk.ff_name,day,month,year,hour,min,amflag);\r
+ done = findnext(&ffblk);\r
+ }\r
+ \r
+ /* Now all files except directories */\r
+ done = findfirst("*.*",&ffblk,231);\r
+ \r
+ while (!done)\r
+ {\r
+ year = (ffblk.ff_fdate >> 9) + 80;\r
+ month = (ffblk.ff_fdate >> 5) & 0x0f;\r
+ day = ffblk.ff_fdate & 0x1f;\r
+ hour = (ffblk.ff_ftime >> 11);\r
+ min = (ffblk.ff_ftime >> 5) & 63;\r
+ \r
+ amflag = 'a';\r
+ \r
+ if (hour > 12)\r
+ {\r
+ hour -= 12;\r
+ amflag = 'p';\r
+ }\r
+ \r
+ parsfnm(ffblk.ff_name,&fcb,1);\r
+ \r
+ printf("%-8.8s %-3.3s %8ld %02d-%02d-%02d %2d:%02d%c\n",\r
+ fcb.fcb_name,fcb.fcb_ext,ffblk.ff_fsize,\r
+ day,month,year,hour,min,amflag);\r
+ done = findnext(&ffblk);\r
+ }\r
+ }\r
+ \r
+\r
+The function "parsfnm()" is a Turbo C library command which makes use of\r
+the DOS function for parsing an ascii string containing a file name, into\r
+its component parts. These component parts are then put into a DOS file\r
+control block (fcb), from where they may be easily retrieved for\r
+displaying by printf().\r
+\r
+\r
+The DOS DTA is comprised as follows;\r
+\r
+Offset Length Contents\r
+ \r
+00 15 Reserved\r
+15 Byte Attribute of matched\r
+ file\r
+16 Word File time\r
+18 Word File date\r
+1A 04 File size\r
+1E 0D File name and extension\r
+ as ascii string\r
+\r
+The file time word contains the time at which the file was last written\r
+to disc and is comprised as follows;\r
+\r
+Bits Contents\r
+\r
+ 0 - 4 Seconds divided by 2\r
+ 5 - 10 Minutes\r
+11 - 15 Hours\r
+\r
+The file date word holds the date on which the file was last written to\r
+disc and is comprised of;\r
+\r
+Bits Contents\r
+\r
+ 0 - 4 Day\r
+ 5 - 8 Month\r
+ 9 - 15 Years since 1980\r
+\r
+To extract these details from the DTA requires a little manipulation, as\r
+illustrated in the above example.\r
+\r
+The DTA attribute flag is comprised of the following bits being set or\r
+not;\r
+\r
+Bit Attribute\r
+\r
+0 Read only\r
+1 Hidden\r
+2 System\r
+3 Volume label\r
+4 Directory\r
+5 Archive\r
+ \r
+ ACCESSING EXPANDED MEMORY\r
+\r
+Memory (RAM) in an IBM PC comes in three flavours; Conventional, Expanded\r
+and Extended. Conventional memory is the 640K of RAM which the operating\r
+system DOS can access. This memory is normally used. However, it is often\r
+insufficient for todays RAM hungry systems. Expanded memory is RAM which\r
+is addressed outside of the area of conventional RAM not by DOS but by a\r
+second program called a LIM EMS driver. Access to this device driver is\r
+made through interrupt 67h.\r
+\r
+The main problem with accessing expanded memory is that no matter how\r
+much expanded memory is fitted to the computer, it can only be accessed\r
+through 16K blocks refered to as pages. So for example. If you have 2mB\r
+of expanded RAM fitted to your PC then that is comprised of 128 pages\r
+(128 * 16K = 2mB).\r
+\r
+A program can determine whether a LIM EMS driver is installed by\r
+attempting to open the file `EMMXXXX0' which is guarranteed by the LIM\r
+standard to be present as an IOCTL device when the device driver is\r
+active.\r
+\r
+The following source code illustrates some basic functions for testing\r
+for and accessing expanded memory.\r
+\r
+ /*\r
+ Various functions for using Expanded memory\r
+ */\r
+ \r
+ #include <dos.h>\r
+ #define EMM 0x67\r
+ \r
+ char far *emmbase;\r
+ emmtest()\r
+ {\r
+ /*\r
+ Tests for the presence of expnaded memory by attempting to\r
+ open the file EMMXXXX0.\r
+ */\r
+ \r
+ union REGS regs;\r
+ struct SREGS sregs;\r
+ int error;\r
+ long handle;\r
+ \r
+ /* Attempt to open the file device EMMXXXX0 */\r
+ regs.x.ax = 0x3d00;\r
+ regs.x.dx = (int)"EMMXXXX0";\r
+ sregs.ds = _DS;\r
+ intdosx(®s,®s,&sregs);\r
+ handle = regs.x.ax;\r
+ error = regs.x.cflag;\r
+ \r
+ if (!error)\r
+ {\r
+ regs.h.ah = 0x3e;\r
+ regs.x.bx = handle;\r
+ intdos(®s,®s);\r
+ }\r
+ return error;\r
+ }\r
+ \r
+ emmok()\r
+ {\r
+ /*\r
+ Checks whether the expanded memory manager responds correctly\r
+ */\r
+ \r
+ union REGS regs;\r
+ \r
+ regs.h.ah = 0x40;\r
+ int86(EMM,®s,®s);\r
+ \r
+ if (regs.h.ah)\r
+ return 0;\r
+ \r
+ regs.h.ah = 0x41;\r
+ int86(EMM,®s,®s);\r
+ \r
+ if (regs.h.ah)\r
+ return 0;\r
+ \r
+ emmbase = MK_FP(regs.x.bx,0);\r
+ return 1;\r
+ }\r
+ \r
+ long emmavail()\r
+ {\r
+ /*\r
+ Returns the number of available (free) 16K pages of expanded\r
+ memory\r
+ or -1 if an error occurs.\r
+ */\r
+ \r
+ union REGS regs;\r
+ \r
+ regs.h.ah = 0x42;\r
+ int86(EMM,®s,®s);\r
+ if (!regs.h.ah)\r
+ return regs.x.bx;\r
+ return -1;\r
+ }\r
+ \r
+ long emmalloc(int n)\r
+ {\r
+ /*\r
+ Requests 'n' pages of expanded memory and returns the file\r
+ handle\r
+ assigned to the pages or -1 if there is an error\r
+ */\r
+ \r
+ union REGS regs;\r
+ \r
+ regs.h.ah = 0x43;\r
+ regs.x.bx = n;\r
+ int86(EMM,®s,®s);\r
+ if (regs.h.ah)\r
+ return -1;\r
+ return regs.x.dx;\r
+ }\r
+ \r
+ emmmap(long handle, int phys, int page)\r
+ {\r
+ /*\r
+ Maps a physical page from expanded memory into the page frame\r
+ in the\r
+ conventional memory 16K window so that data can be transfered\r
+ between\r
+ the expanded memory and conventional memory.\r
+ */\r
+ \r
+ union REGS regs;\r
+ \r
+ regs.h.ah = 0x44;\r
+ regs.h.al = page;\r
+ regs.x.bx = phys;\r
+ regs.x.dx = handle;\r
+ int86(EMM,®s,®s);\r
+ return (regs.h.ah == 0);\r
+ }\r
+ \r
+ void emmmove(int page, char *str, int n)\r
+ {\r
+ /*\r
+ Move 'n' bytes from conventional memory to the specified\r
+ expanded memory\r
+ page\r
+ */\r
+ \r
+ char far *ptr;\r
+ \r
+ ptr = emmbase + page * 16384;\r
+ while(n-- > 0)\r
+ *ptr++ = *str++;\r
+ }\r
+ \r
+ void emmget(int page, char *str, int n)\r
+ {\r
+ /*\r
+ Move 'n' bytes from the specified expanded memory page into\r
+ conventional\r
+ memory\r
+ */\r
+ \r
+ char far *ptr;\r
+ \r
+ ptr = emmbase + page * 16384;\r
+ while(n-- > 0)\r
+ *str++ = *ptr++;\r
+ }\r
+ \r
+ emmclose(long handle)\r
+ {\r
+ /*\r
+ Release control of the expanded memory pages allocated to\r
+ 'handle'\r
+ */\r
+ \r
+ union REGS regs;\r
+ \r
+ regs.h.ah = 0x45;\r
+ regs.x.dx = handle;\r
+ int86(EMM,®s,®s);\r
+ return (regs.h.ah == 0);\r
+ }\r
+ \r
+ /*\r
+ Test function for the EMM routines\r
+ */\r
+ \r
+ void main()\r
+ {\r
+ long emmhandle;\r
+ long avail;\r
+ char teststr[80];\r
+ int i;\r
+ \r
+ if(!emmtest())\r
+ {\r
+ printf("Expanded memory is not present\n");\r
+ exit(0);\r
+ }\r
+ \r
+ if(!emmok())\r
+ {\r
+ printf("Expanded memory manager is not present\n");\r
+ exit(0);\r
+ }\r
+ \r
+ avail = emmavail();\r
+ if (avail == -1)\r
+ {\r
+ printf("Expanded memory manager error\n");\r
+ exit(0);\r
+ }\r
+ printf("There are %ld pages available\n",avail);\r
+ \r
+ /* Request 10 pages of expanded memory */\r
+ if((emmhandle = emmalloc(10)) < 0)\r
+ {\r
+ printf("Insufficient pages available\n");\r
+ exit(0);\r
+ }\r
+ \r
+ for (i = 0; i < 10; i++)\r
+ {\r
+ sprintf(teststr,"%02d This is a test string\n",i);\r
+ emmmap(emmhandle,i,0);\r
+ emmmove(0,teststr,strlen(teststr) + 1);\r
+ }\r
+ \r
+ for (i = 0; i < 10; i++)\r
+ {\r
+ emmmap(emmhandle,i,0);\r
+ emmget(0,teststr,strlen(teststr) + 1);\r
+ printf("READING BLOCK %d: %s\n",i,teststr);\r
+ }\r
+ \r
+ emmclose(emmhandle);\r
+ }\r
+ \r
+ ACCESSING EXTENDED MEMORY\r
+\r
+\r
+Extended memory has all but taken over from Expanded Memory now (1996).\r
+It is faster and more useable than expanded memory. As with Expanded\r
+memory, Extended memory cannot be directly accessed through the standard\r
+DOS mode, and so a transfer buffer in conventional or "real-mode" memory\r
+needs to be used. The process to write data to Extended memory then\r
+involves copying the data to the transfer buffer in conventional memory,\r
+and from there copying it to Extended memory.\r
+\r
+Before any use may be made of Extended memory, a program should test to\r
+see if Extended memory is available. The following function, XMS_init(),\r
+tests for the presence of Extended memory, and if available calls another\r
+function, GetXMSEntry() to initialise the program for using Extended\r
+Memory. The function also allocates a conventional memory transfer\r
+buffer.\r
+\r
+\r
+ \r
+ /*\r
+ BLOCKSIZE will be the size of our real-memory buffer that\r
+ we'll swap XMS through (must be a multiple of 1024, since\r
+ XMS is allocated in 1K chunks.)\r
+ */\r
+ \r
+ #ifdef __SMALL__\r
+ #define BLOCKSIZE (16L * 1024L)\r
+ #endif\r
+ \r
+ \r
+ #ifdef __MEDIUM__\r
+ #define BLOCKSIZE (16L * 1024L)\r
+ #endif\r
+ \r
+ \r
+ #ifdef __COMPACT__\r
+ #define BLOCKSIZE (64L * 1024L)\r
+ #endif\r
+ \r
+ #ifdef __LARGE__\r
+ #define BLOCKSIZE (64L * 1024L)\r
+ #endif\r
+ \r
+ \r
+ char XMS_init()\r
+ {\r
+ /*\r
+ returns 0 if XMS present,\r
+ 1 if XMS absent\r
+ 2 if unable to allocate conventional memory transfer\r
+ buffer\r
+ */\r
+ unsigned char status;\r
+ _AX=0x4300;\r
+ geninterrupt(0x2F);\r
+ status = _AL;\r
+ if(status==0x80)\r
+ {\r
+ GetXMSEntry();\r
+ XMSBuf = (char far *) farmalloc(BLOCKSIZE);\r
+ if (XMSBuf == NULL)\r
+ return 2;\r
+ return 0;\r
+ }\r
+ return 1;\r
+ }\r
+ \r
+ void GetXMSEntry(void)\r
+ {\r
+ /*\r
+ GetXMSEntry sets XMSFunc to the XMS Manager entry point\r
+ so we can call it later\r
+ */\r
+ \r
+ _AX=0x4310;\r
+ geninterrupt(0x2F);\r
+ XMSFunc= (void (far *)(void)) MK_FP(_ES,_BX);\r
+ }\r
+\r
+\r
+Once the presence of Extended memory has been confirmed, a program can\r
+find out how much Extended memory is available;\r
+\r
+ void XMSSize(int *kbAvail, int *largestAvail)\r
+ {\r
+ /*\r
+ XMSSize returns the total kilobytes available, and the\r
+ size\r
+ in kilobytes of the largest available block\r
+ */\r
+ \r
+ _AH=8;\r
+ (*XMSFunc)();\r
+ *largestAvail=_DX;\r
+ *kbAvail=_AX;\r
+ }\r
+\r
+\r
+The following function may be called to allocate a block of Extended\r
+memory, like you would allocate a block of conventional memory.\r
+\r
+ char AllocXMS(unsigned long numberBytes)\r
+ {\r
+ /*\r
+ Allocate a block of XMS memory numberBytes long\r
+ Returns 1 on success\r
+ 0 on failure\r
+ */\r
+ \r
+ _DX = (int)(numberBytes / 1024);\r
+ _AH = 9;\r
+ (*XMSFunc)();\r
+ if (_AX==0)\r
+ {\r
+ return 0;\r
+ }\r
+ XMSHandle=_DX;\r
+ return 1;\r
+ }\r
+ \r
+\r
+Allocated Extended memory is not freed by DOS. A program using Extended\r
+memory must release it before terminating. This function frees a block of\r
+extended memory previously allocated by AllocXMS. Note, XMSHandle is a\r
+global variable of type int.\r
+\r
+ void XMS_free(void)\r
+ {\r
+ /*\r
+ Free used XMS\r
+ */\r
+ _DX=XMSHandle;\r
+ _AH=0x0A;\r
+ (*XMSFunc)();\r
+ }\r
+\r
+\r
+Two functions are now given. One for writing data to Extended memory, and\r
+one for reading data from Extended memory into conventional memory.\r
+\r
+ /*\r
+ XMSParms is a structure for copying information to and from\r
+ real-mode memory to XMS memory\r
+ */\r
+ \r
+ struct parmstruct\r
+ {\r
+ /*\r
+ blocklength is the size in bytes of block to copy\r
+ */\r
+ unsigned long blockLength;\r
+ \r
+ /*\r
+ sourceHandle is the XMS handle of source; 0 means that\r
+ sourcePtr will be a 16:16 real-mode pointer, otherwise\r
+ sourcePtr is a 32-bit offset from the beginning of the\r
+ XMS area that sourceHandle points to\r
+ */\r
+ \r
+ unsigned int sourceHandle;\r
+ far void *sourcePtr;\r
+ \r
+ /*\r
+ destHandle is the XMS handle of destination; 0 means that\r
+ destPtr will be a 16:16 real-mode pointer, otherwise\r
+ destPtr is a 32-bit offset from the beginning of the XMS\r
+ area that destHandle points to\r
+ */\r
+ \r
+ unsigned int destHandle;\r
+ far void *destPtr;\r
+ }\r
+ XMSParms;\r
+ \r
+ \r
+ char XMS_write(unsigned long loc, char far *val, unsigned length)\r
+ {\r
+ /*\r
+ Round length up to next even value\r
+ */\r
+ length += length % 2;\r
+ \r
+ XMSParms.sourceHandle=0;\r
+ XMSParms.sourcePtr=val;\r
+ XMSParms.destHandle=XMSHandle;\r
+ XMSParms.destPtr=(void far *) (loc);\r
+ XMSParms.blockLength=length; /* Must be an even number! */\r
+ _SI = FP_OFF(&XMSParms);\r
+ _AH=0x0B;\r
+ (*XMSFunc)();\r
+ if (_AX==0)\r
+ {\r
+ return 0;\r
+ }\r
+ return 1;\r
+ }\r
+ \r
+ \r
+ void *XMS_read(unsigned long loc,unsigned length)\r
+ {\r
+ /*\r
+ Returns pointer to data\r
+ or NULL on error\r
+ */\r
+ \r
+ /*\r
+ Round length up to next even value\r
+ */\r
+ length += length % 2;\r
+ \r
+ XMSParms.sourceHandle=XMSHandle;\r
+ XMSParms.sourcePtr=(void far *) (loc);\r
+ XMSParms.destHandle=0;\r
+ XMSParms.destPtr=XMSBuf;\r
+ XMSParms.blockLength=length; /* Must be an even number */\r
+ _SI=FP_OFF(&XMSParms);\r
+ _AH=0x0B;\r
+ (*XMSFunc)();\r
+ if (_AX==0)\r
+ {\r
+ return NULL;\r
+ }\r
+ return XMSBuf;\r
+ }\r
+ \r
+ \r
+And now putting it all together is a demonstration program.\r
+\r
+ /* A sequential table of variable length records in XMS */\r
+ \r
+ #include <dos.h>\r
+ #include <stdio.h>\r
+ #include <stdlib.h>\r
+ #include <alloc.h>\r
+ #include <string.h>\r
+ \r
+ #define TRUE 1\r
+ #define FALSE 0\r
+ \r
+ /*\r
+ BLOCKSIZE will be the size of our real-memory buffer that\r
+ we'll swap XMS through (must be a multiple of 1024, since\r
+ XMS is allocated in 1K chunks.)\r
+ */\r
+ \r
+ #ifdef __SMALL__\r
+ #define BLOCKSIZE (16L * 1024L)\r
+ #endif\r
+ \r
+ \r
+ #ifdef __MEDIUM__\r
+ #define BLOCKSIZE (16L * 1024L)\r
+ #endif\r
+ \r
+ \r
+ #ifdef __COMPACT__\r
+ #define BLOCKSIZE (64L * 1024L)\r
+ #endif\r
+ \r
+ #ifdef __LARGE__\r
+ #define BLOCKSIZE (64L * 1024L)\r
+ #endif\r
+ \r
+ \r
+ /*\r
+ XMSParms is a structure for copying information to and from\r
+ real-mode memory to XMS memory\r
+ */\r
+ \r
+ struct parmstruct\r
+ {\r
+ /*\r
+ blocklength is the size in bytes of block to copy\r
+ */\r
+ unsigned long blockLength;\r
+ \r
+ /*\r
+ sourceHandle is the XMS handle of source; 0 means that\r
+ sourcePtr will be a 16:16 real-mode pointer, otherwise\r
+ sourcePtr is a 32-bit offset from the beginning of the\r
+ XMS area that sourceHandle points to\r
+ */\r
+ \r
+ unsigned int sourceHandle;\r
+ far void *sourcePtr;\r
+ \r
+ /*\r
+ destHandle is the XMS handle of destination; 0 means that\r
+ destPtr will be a 16:16 real-mode pointer, otherwise\r
+ destPtr is a 32-bit offset from the beginning of the XMS\r
+ area that destHandle points to\r
+ */\r
+ \r
+ unsigned int destHandle;\r
+ far void *destPtr;\r
+ }\r
+ XMSParms;\r
+ \r
+ void far (*XMSFunc) (void); /* Used to call XMS manager\r
+ (himem.sys) */\r
+ char GetBuf(void);\r
+ void GetXMSEntry(void);\r
+ \r
+ char *XMSBuf; /* Conventional memory buffer for transfers */\r
+ \r
+ unsigned int XMSHandle; /* handle to allocated XMS block */\r
+ \r
+ \r
+ char XMS_init()\r
+ {\r
+ /*\r
+ returns 0 if XMS present,\r
+ 1 if XMS absent\r
+ 2 if unable to allocate transfer buffer\r
+ */\r
+ unsigned char status;\r
+ _AX=0x4300;\r
+ geninterrupt(0x2F);\r
+ status = _AL;\r
+ if(status==0x80)\r
+ {\r
+ GetXMSEntry();\r
+ XMSBuf = (char far *) farmalloc(BLOCKSIZE);\r
+ if (XMSBuf == NULL)\r
+ return 2;\r
+ return 0;\r
+ }\r
+ return 1;\r
+ }\r
+ \r
+ void GetXMSEntry(void)\r
+ {\r
+ /*\r
+ GetXMSEntry sets XMSFunc to the XMS Manager entry point\r
+ so we can call it later\r
+ */\r
+ \r
+ _AX=0x4310;\r
+ geninterrupt(0x2F);\r
+ XMSFunc= (void (far *)(void)) MK_FP(_ES,_BX);\r
+ }\r
+ \r
+ \r
+ void XMSSize(int *kbAvail, int *largestAvail)\r
+ {\r
+ /*\r
+ XMSSize returns the total kilobytes available, and the\r
+ size\r
+ in kilobytes of the largest available block\r
+ */\r
+ \r
+ _AH=8;\r
+ (*XMSFunc)();\r
+ *largestAvail=_DX;\r
+ *kbAvail=_AX;\r
+ }\r
+ \r
+ char AllocXMS(unsigned long numberBytes)\r
+ {\r
+ /*\r
+ Allocate a block of XMS memory numberBytes long\r
+ */\r
+ \r
+ _DX = (int)(numberBytes / 1024);\r
+ _AH = 9;\r
+ (*XMSFunc)();\r
+ if (_AX==0)\r
+ {\r
+ return FALSE;\r
+ }\r
+ XMSHandle=_DX;\r
+ return TRUE;\r
+ }\r
+ \r
+ void XMS_free(void)\r
+ {\r
+ /*\r
+ Free used XMS\r
+ */\r
+ _DX=XMSHandle;\r
+ _AH=0x0A;\r
+ (*XMSFunc)();\r
+ }\r
+ \r
+ char XMS_write(unsigned long loc, char far *val, unsigned length)\r
+ {\r
+ /*\r
+ Round length up to next even value\r
+ */\r
+ length += length % 2;\r
+ \r
+ XMSParms.sourceHandle=0;\r
+ XMSParms.sourcePtr=val;\r
+ XMSParms.destHandle=XMSHandle;\r
+ XMSParms.destPtr=(void far *) (loc);\r
+ XMSParms.blockLength=length; /* Must be an even number! */\r
+ _SI = FP_OFF(&XMSParms);\r
+ _AH=0x0B;\r
+ (*XMSFunc)();\r
+ if (_AX==0)\r
+ {\r
+ return FALSE;\r
+ }\r
+ return TRUE;\r
+ }\r
+ \r
+ \r
+ void *XMS_read(unsigned long loc,unsigned length)\r
+ {\r
+ /*\r
+ Returns pointer to data\r
+ or NULL on error\r
+ */\r
+ \r
+ /*\r
+ Round length up to next even value\r
+ */\r
+ length += length % 2;\r
+ \r
+ XMSParms.sourceHandle=XMSHandle;\r
+ XMSParms.sourcePtr=(void far *) (loc);\r
+ XMSParms.destHandle=0;\r
+ XMSParms.destPtr=XMSBuf;\r
+ XMSParms.blockLength=length; /* Must be an even number */\r
+ _SI=FP_OFF(&XMSParms);\r
+ _AH=0x0B;\r
+ (*XMSFunc)();\r
+ if (_AX==0)\r
+ {\r
+ return NULL;\r
+ }\r
+ return XMSBuf;\r
+ }\r
+ \r
+ \r
+ /*\r
+ Demonstration code\r
+ Read various length strings into a single XMS block (EMB)\r
+ and write them out again\r
+ */\r
+ \r
+ int main()\r
+ {\r
+ int kbAvail,largestAvail;\r
+ char buffer[80];\r
+ char *p;\r
+ long pos;\r
+ long end;\r
+ \r
+ if (XMS_init() == 0)\r
+ printf("XMS Available ...\n");\r
+ else\r
+ {\r
+ printf("XMS Not Available\n");\r
+ return(1);\r
+ }\r
+ \r
+ XMSSize(&kbAvail,&largestAvail);\r
+ printf("Kilobytes Available: %d; Largest block:\r
+ %dK\n",kbAvail,largestAvail);\r
+ \r
+ if (!AllocXMS(2000 * 1024L))\r
+ return(1);\r
+ \r
+ \r
+ pos = 0;\r
+ \r
+ do\r
+ {\r
+ p = fgets(buffer,1000,stdin);\r
+ if (p != NULL)\r
+ {\r
+ XMS_write(pos,buffer,strlen(buffer) + 1);\r
+ pos += strlen(buffer) + 1;\r
+ }\r
+ }\r
+ while(p != NULL);\r
+ \r
+ end = pos;\r
+ \r
+ pos = 0;\r
+ \r
+ do\r
+ {\r
+ memcpy(buffer,XMS_read(pos,100),70);\r
+ printf("%s",buffer);\r
+ pos += strlen(buffer) + 1;\r
+ }\r
+ while(pos < end);\r
+ \r
+ /*\r
+ It is VERY important to free any XMS before exiting!\r
+ */\r
+ XMS_free();\r
+ return 0;\r
+ }\r
+\r
+ \r
+ \r
+ \r
+ TSR PROGRAMMING\r
+\r
+\r
+Programs which remain running and resident in memory while other programs\r
+are running are the most exciting line of programming for many PC\r
+developers. This type of program is known as a "Terminate and Stay\r
+Resident" or "TSR" program and they are very difficult to program\r
+sucessfuly.\r
+\r
+The difficulties in programming TSRs comes from the limitations of DOS\r
+which is not a multi-tasking operating system, and does not react well to\r
+re-enterant code. That is it's own functions (interrupts) calling\r
+themselves.\r
+\r
+In theory a TSR is quite simple. It is an ordinary program which\r
+terminates not through the usual DOS terminate function, but through the\r
+DOS "keep" function - interrupt 27h. This function reserves an area of\r
+memory, used by the program so that no other programs will overwrite it.\r
+This in itself is not a very difficult task, excepting that the program\r
+needs to tell DOS how much memory to leave it!\r
+\r
+The problems stem mainly from not being able to use DOS function calls\r
+within the TSR program once it has "gone resident".\r
+\r
+There are a few basic rules which help to clarify the problems\r
+encountered in programming TSRs:\r
+\r
+ 1.Avoid DOS function calls\r
+ 2.Monitor the DOS busy flag, when this flag is nonzero, DOS is\r
+ executing an interrupt 21h function and MUST NOT be disturbed!\r
+ 3.Monitor interrupt 28h. This reveals when DOS is busy waiting for\r
+ console input. At this time you can disturb DOS regardless of the\r
+ DOS busy flag setting.\r
+ 4.Provide some way of checking whether the TSR is already loaded to\r
+ prevent multiple copies occuring in memory.\r
+ 5.Remember that other TSR programs may be chained to interrupts, and\r
+ so you must chain any interrupt vectors that your program needs.\r
+ 6.Your TSR program must use its own stack, and NOT that of the running\r
+ process.\r
+ 7.TSR programs must be compiled in a small memory model with stack\r
+ checking turned off.\r
+ 8.When control passes to your TSR program, it must tell DOS that the\r
+ active process has changed.\r
+\r
+\r
+The following three source code modules describe a complete TSR program.\r
+This is a useful pop-up address book database which can be activated\r
+while any other program is running by pressing the key combination `Alt'\r
+and `.'. If the address book does not respond to the key press, it is\r
+probably because DOS cannot be disturbed, and you should try to pop-it-up\r
+again.\r
+\r
+\r
+ /*\r
+ A practical TSR program (a pop-up address book database)\r
+ Compile in small memory model with stack checking OFF\r
+ */\r
+ \r
+ #include <dos.h>\r
+ #include <stdio.h>\r
+ #include <string.h>\r
+ #include <dir.h>\r
+ \r
+ static union REGS rg;\r
+ \r
+ /*\r
+ Size of the program to remain resident\r
+ experimentation is required to make this as small as possible\r
+ */\r
+ unsigned sizeprogram = 28000/16;\r
+ \r
+ /* Activate with Alt . */\r
+ unsigned scancode = 52; /* . */\r
+ unsigned keymask = 8; /* ALT */\r
+ \r
+ char signature[]= "POPADDR";\r
+ char fpath[40];\r
+ \r
+ /*\r
+ Function prototypes\r
+ */\r
+ \r
+ void curr_cursor(int *x, int *y);\r
+ int resident(char *, void interrupt(*)());\r
+ void resinit(void);\r
+ void terminate(void);\r
+ void restart(void);\r
+ void wait(void);\r
+ void resident_psp(void);\r
+ void exec(void);\r
+ \r
+ /*\r
+ Entry point from DOS\r
+ */\r
+ \r
+ main(int argc, char *argv[])\r
+ {\r
+ void interrupt ifunc();\r
+ int ivec;\r
+ \r
+ /*\r
+ For simplicity, assume the data file is in the root\r
+ directory\r
+ of drive C:\r
+ */\r
+ strcpy(fpath,"C:\\ADDRESS.DAT");\r
+ \r
+ if ((ivec = resident(signature,ifunc)) != 0)\r
+ {\r
+ /* TSR is resident */\r
+ if (argc > 1)\r
+ {\r
+ rg.x.ax = 0;\r
+ if (strcmp(argv[1],"quit") == 0)\r
+ rg.x.ax = 1;\r
+ else if (strcmp(argv[1],"restart") == 0)\r
+ rg.x.ax = 2;\r
+ else if (strcmp(argv[1],"wait") == 0)\r
+ rg.x.ax = 3;\r
+ if (rg.x.ax)\r
+ {\r
+ int86(ivec,&rg,&rg);\r
+ return;\r
+ }\r
+ }\r
+ printf("\nPopup Address Book is already resident");\r
+ }\r
+ else\r
+ {\r
+ /* Initial load of TSR program */\r
+ printf("Popup Address Book Resident.\nPress Alt . To\r
+ Activate....\n");\r
+ resinit();\r
+ }\r
+ }\r
+ \r
+ void interrupt ifunc(bp,di,si,ds,es,dx,cx,bx,ax)\r
+ {\r
+ if(ax == 1)\r
+ terminate();\r
+ else if(ax == 2)\r
+ restart();\r
+ else if(ax == 3)\r
+ wait();\r
+ }\r
+ \r
+ popup()\r
+ {\r
+ int x,y;\r
+ \r
+ curr_cursor(&x,&y);\r
+ \r
+ /* Call the TSR C program here */\r
+ exec();\r
+ cursor(x,y);\r
+ }\r
+ \r
+ /*\r
+ Second source module\r
+ */\r
+ \r
+ #include <dos.h>\r
+ #include <stdio.h>\r
+ \r
+ static union REGS rg;\r
+ static struct SREGS seg;\r
+ static unsigned mcbseg;\r
+ static unsigned dosseg;\r
+ static unsigned dosbusy;\r
+ static unsigned enddos;\r
+ char far *intdta;\r
+ static unsigned intsp;\r
+ static unsigned intss;\r
+ static char far *mydta;\r
+ static unsigned myss;\r
+ static unsigned stack;\r
+ static unsigned ctrl_break;\r
+ static unsigned mypsp;\r
+ static unsigned intpsp;\r
+ static unsigned pids[2];\r
+ static int pidctr = 0;\r
+ static int pp;\r
+ static void interrupt (*oldtimer)();\r
+ static void interrupt (*old28)();\r
+ static void interrupt (*oldkb)();\r
+ static void interrupt (*olddisk)();\r
+ static void interrupt (*oldcrit)();\r
+ \r
+ void interrupt newtimer();\r
+ void interrupt new28();\r
+ void interrupt newkb();\r
+ void interrupt newdisk();\r
+ void interrupt newcrit();\r
+ \r
+ extern unsigned sizeprogram;\r
+ extern unsigned scancode;\r
+ extern unsigned keymask;\r
+ \r
+ static int resoff = 0;\r
+ static int running = 0;\r
+ static int popflg = 0;\r
+ static int diskflag = 0;\r
+ static int kbval;\r
+ static int cflag;\r
+ \r
+ void dores(void);\r
+ void pidaddr(void);\r
+ \r
+ void resinit()\r
+ {\r
+ segread(&seg);\r
+ myss = seg.ss;\r
+ \r
+ rg.h.ah = 0x34;\r
+ intdos(&rg,&rg);\r
+ dosseg = _ES;\r
+ dosbusy = rg.x.bx;\r
+ \r
+ mydta = getdta();\r
+ pidaddr();\r
+ oldtimer = getvect(0x1c);\r
+ old28 = getvect(0x28);\r
+ oldkb = getvect(9);\r
+ olddisk = getvect(0x13);\r
+ \r
+ setvect(0x1c,newtimer);\r
+ setvect(9,newkb);\r
+ setvect(0x28,new28);\r
+ setvect(0x13,newdisk);\r
+ \r
+ stack = (sizeprogram - (seg.ds - seg.cs)) * 16 - 300;\r
+ rg.x.ax = 0x3100;\r
+ rg.x.dx = sizeprogram;\r
+ intdos(&rg,&rg);\r
+ }\r
+ \r
+ void interrupt newdisk(bp,di,si,ds,es,dx,cx,bx,ax,ip,cs,flgs)\r
+ {\r
+ diskflag++;\r
+ (*olddisk)();\r
+ ax = _AX;\r
+ newcrit();\r
+ flgs = cflag;\r
+ --diskflag;\r
+ }\r
+ \r
+ void interrupt newcrit(bp,di,si,ds,es,dx,cx,bx,ax,ip,cs,flgs)\r
+ {\r
+ ax = 0;\r
+ cflag = flgs;\r
+ }\r
+ \r
+ void interrupt newkb()\r
+ {\r
+ if (inportb(0x60) == scancode)\r
+ {\r
+ kbval = peekb(0,0x417);\r
+ if (!resoff && ((kbval & keymask) ^ keymask) == 0)\r
+ {\r
+ kbval = inportb(0x61);\r
+ outportb(0x61,kbval | 0x80);\r
+ outportb(0x61,kbval);\r
+ disable();\r
+ outportb(0x20,0x20);\r
+ enable();\r
+ if (!running)\r
+ popflg = 1;\r
+ return;\r
+ }\r
+ }\r
+ (*oldkb)();\r
+ }\r
+ \r
+ void interrupt newtimer()\r
+ {\r
+ (*oldtimer)();\r
+ if (popflg && peekb(dosseg,dosbusy) == 0)\r
+ if(diskflag == 0)\r
+ {\r
+ outportb(0x20,0x20);\r
+ popflg = 0;\r
+ dores();\r
+ }\r
+ }\r
+ \r
+ void interrupt new28()\r
+ {\r
+ (*old28)();\r
+ if (popflg && peekb(dosseg,dosbusy) != 0)\r
+ {\r
+ popflg = 0;\r
+ dores();\r
+ }\r
+ }\r
+ \r
+ resident_psp()\r
+ {\r
+ intpsp = peek(dosseg,*pids);\r
+ for(pp = 0; pp < pidctr; pp++)\r
+ poke(dosseg,pids[pp],mypsp);\r
+ }\r
+ \r
+ interrupted_psp()\r
+ {\r
+ for(pp = 0; pp < pidctr; pp++)\r
+ poke(dosseg,pids[pp],intpsp);\r
+ }\r
+ \r
+ void dores()\r
+ {\r
+ running = 1;\r
+ disable();\r
+ intsp = _SP;\r
+ intss = _SS;\r
+ _SP = stack;\r
+ _SS = myss;\r
+ enable();\r
+ oldcrit = getvect(0x24);\r
+ setvect(0x24,newcrit);\r
+ rg.x.ax = 0x3300;\r
+ intdos(&rg,&rg);\r
+ ctrl_break = rg.h.dl;\r
+ rg.x.ax = 0x3301;\r
+ rg.h.dl = 0;\r
+ intdos(&rg,&rg);\r
+ intdta = getdta();\r
+ setdta(mydta);\r
+ resident_psp();\r
+ popup();\r
+ interrupted_psp();\r
+ setdta(intdta);\r
+ setvect(0x24,oldcrit);\r
+ rg.x.ax = 0x3301;\r
+ rg.h.dl = ctrl_break;\r
+ intdos(&rg,&rg);\r
+ disable();\r
+ _SP = intsp;\r
+ _SS = intss;\r
+ enable();\r
+ running = 0;\r
+ }\r
+ \r
+ static int avec = 0;\r
+ \r
+ unsigned resident(char *signature,void interrupt(*ifunc)())\r
+ {\r
+ char *sg;\r
+ unsigned df;\r
+ int vec;\r
+ \r
+ segread(&seg);\r
+ df = seg.ds-seg.cs;\r
+ for(vec = 0x60; vec < 0x68; vec++)\r
+ {\r
+ if (getvect(vec) == NULL)\r
+ {\r
+ if (!avec)\r
+ avec = vec;\r
+ continue;\r
+ }\r
+ for(sg = signature; *sg; sg++)\r
+ if (*sg != peekb(peek(0,2+vec*4)+df,(unsigned)sg))\r
+ break;\r
+ if (!*sg)\r
+ return vec;\r
+ }\r
+ if (avec)\r
+ setvect(avec,ifunc);\r
+ return 0;\r
+ }\r
+ \r
+ static void pidaddr()\r
+ {\r
+ unsigned adr = 0;\r
+ \r
+ rg.h.ah = 0x51;\r
+ intdos(&rg,&rg);\r
+ mypsp = rg.x.bx;\r
+ rg.h.ah = 0x52;\r
+ intdos(&rg,&rg);\r
+ enddos = _ES;\r
+ enddos = peek(enddos,rg.x.bx-2);\r
+ while(pidctr < 2 && (unsigned)((dosseg<<4) + adr) < (enddos\r
+ <<4))\r
+ {\r
+ if (peek(dosseg,adr) == mypsp)\r
+ {\r
+ rg.h.ah = 0x50;\r
+ rg.x.bx = mypsp + 1;\r
+ intdos(&rg,&rg);\r
+ if (peek(dosseg,adr) == mypsp + 1)\r
+ pids[pidctr++] = adr;\r
+ rg.h.ah = 0x50;\r
+ rg.x.bx = mypsp;\r
+ intdos(&rg,&rg);\r
+ }\r
+ adr++;\r
+ }\r
+ }\r
+ \r
+ static resterm()\r
+ {\r
+ setvect(0x1c,oldtimer);\r
+ setvect(9,oldkb);\r
+ setvect(0x28,old28);\r
+ setvect(0x13,olddisk);\r
+ setvect(avec,(void interrupt (*)()) 0);\r
+ rg.h.ah = 0x52;\r
+ intdos(&rg,&rg);\r
+ mcbseg = _ES;\r
+ mcbseg = peek(mcbseg,rg.x.bx-2);\r
+ segread(&seg);\r
+ while(peekb(mcbseg,0) == 0x4d)\r
+ {\r
+ if(peek(mcbseg,1) == mypsp)\r
+ {\r
+ rg.h.ah = 0x49;\r
+ seg.es = mcbseg+1;\r
+ intdosx(&rg,&rg,&seg);\r
+ }\r
+ mcbseg += peek(mcbseg,3) + 1;\r
+ }\r
+ }\r
+ \r
+ terminate()\r
+ {\r
+ if (getvect(0x13) == (void interrupt (*)()) newdisk)\r
+ if (getvect(9) == newkb)\r
+ if(getvect(0x28) == new28)\r
+ if(getvect(0x1c) == newtimer)\r
+ {\r
+ resterm();\r
+ return;\r
+ }\r
+ resoff = 1;\r
+ }\r
+ \r
+ restart()\r
+ {\r
+ resoff = 0;\r
+ }\r
+ \r
+ wait()\r
+ {\r
+ resoff = 1;\r
+ }\r
+ \r
+ void cursor(int y, int x)\r
+ {\r
+ rg.x.ax = 0x0200;\r
+ rg.x.bx = 0;\r
+ rg.x.dx = ((y << 8) & 0xff00) + x;\r
+ int86(16,&rg,&rg);\r
+ }\r
+ \r
+ void curr_cursor(int *y, int *x)\r
+ {\r
+ rg.x.ax = 0x0300;\r
+ rg.x.bx = 0;\r
+ int86(16,&rg,&rg);\r
+ *x = rg.h.dl;\r
+ *y = rg.h.dh;\r
+ }\r
+ \r
+ /*\r
+ Third module, the simple pop-up address book\r
+ with mouse support\r
+ */\r
+ \r
+ #include <stdio.h>\r
+ #include <stdlib.h>\r
+ #include <io.h>\r
+ #include <string.h>\r
+ #include <fcntl.h>\r
+ #include <sys\stat.h>\r
+ #include <dos.h>\r
+ #include <conio.h>\r
+ #include <graphics.h>\r
+ #include <bios.h>\r
+ \r
+ /* left cannot be less than 3 */\r
+ #define left 4\r
+ \r
+ /* Data structure for records */\r
+ typedef struct\r
+ {\r
+ char name[31];\r
+ char company[31];\r
+ char address[31];\r
+ char area[31];\r
+ char town[31];\r
+ char county[31];\r
+ char post[13];\r
+ char telephone[16];\r
+ char fax[16];\r
+ }\r
+ data;\r
+ \r
+ extern char fpath[];\r
+ \r
+ static char scr[4000];\r
+ \r
+ static char sbuff[2000];\r
+ char stext[30];\r
+ data rec;\r
+ int handle;\r
+ int recsize;\r
+ union REGS inreg,outreg;\r
+ \r
+ /*\r
+ Function prototypes\r
+ */\r
+ void FATAL(char *);\r
+ void OPENDATA(void);\r
+ void CONTINUE(void);\r
+ void EXPORT_MULTI(void);\r
+ void GETDATA(int);\r
+ int GETOPT(void);\r
+ void DISPDATA(void);\r
+ void ADD_REC(void);\r
+ void PRINT_MULTI(void);\r
+ void SEARCH(void);\r
+ void MENU(void);\r
+ \r
+ int GET_MOUSE(int *buttons)\r
+ {\r
+ inreg.x.ax = 0;\r
+ int86(0x33,&inreg,&outreg);\r
+ *buttons = outreg.x.bx;\r
+ return outreg.x.ax;\r
+ }\r
+ \r
+ void MOUSE_CURSOR(int status)\r
+ {\r
+ /* Status = 0 cursor off */\r
+ /* 1 cursor on */\r
+ \r
+ inreg.x.ax = 2 - status;\r
+ int86(0x33,&inreg,&outreg);\r
+ }\r
+ \r
+ int MOUSE_LOCATION(int *x, int *y)\r
+ {\r
+ inreg.x.ax = 3;\r
+ int86(0x33,&inreg,&outreg);\r
+ \r
+ *x = outreg.x.cx / 8;\r
+ *y = outreg.x.dx / 8;\r
+ \r
+ return outreg.x.bx;\r
+ }\r
+ \r
+ int GETOPT()\r
+ {\r
+ int result;\r
+ int x;\r
+ int y;\r
+ \r
+ do\r
+ {\r
+ do\r
+ {\r
+ result = MOUSE_LOCATION(&x,&y);\r
+ if (result & 1)\r
+ {\r
+ if (x >= 52 && x <= 53 && y >= 7 && y <= 15)\r
+ return y - 7;\r
+ if (x >= 4 && x <= 40 && y >= 7 && y <= 14)\r
+ return y + 10;\r
+ \r
+ if (x >= 4 && x <= 40 && y == 15)\r
+ return y + 10;\r
+ }\r
+ }\r
+ while(!bioskey(1));\r
+ \r
+ result = bioskey(0);\r
+ x = result & 0xff;\r
+ if (x == 0)\r
+ {\r
+ result = result >> 8;\r
+ result -= 60;\r
+ }\r
+ }\r
+ while(result < 0 || result > 8);\r
+ return result;\r
+ }\r
+ \r
+ void setvideo(unsigned char mode)\r
+ {\r
+ /* Sets the video display mode and clears the screen */\r
+ \r
+ inreg.h.al = mode;\r
+ inreg.h.ah = 0x00;\r
+ int86(0x10, &inreg, &outreg);\r
+ }\r
+ \r
+ \r
+ int activepage(void)\r
+ {\r
+ /* Returns the currently selected video display page */\r
+ \r
+ union REGS inreg,outreg;\r
+ \r
+ inreg.h.ah = 0x0F;\r
+ int86(0x10, &inreg, &outreg);\r
+ return(outreg.h.bh);\r
+ }\r
+ \r
+ void print(char *str)\r
+ {\r
+ /*\r
+ Prints characters only directly to the current display page\r
+ starting at the current cursor position. The cursor is not\r
+ advanced.\r
+ This function assumes a colour display card. For use with a\r
+ monochrome display card change 0xB800 to read 0xB000\r
+ */\r
+ \r
+ int page;\r
+ int offset;\r
+ unsigned row;\r
+ unsigned col;\r
+ char far *ptr;\r
+ \r
+ page = activepage();\r
+ curr_cursor(&row,&col);\r
+ \r
+ offset = page * 4000 + row * 160 + col * 2;\r
+ \r
+ ptr = MK_FP(0xB800,offset);\r
+ \r
+ while(*str)\r
+ {\r
+ *ptr++= *str++;\r
+ ptr++;\r
+ }\r
+ }\r
+ \r
+ \r
+ void TRUESHADE(int lef, int top, int right, int bottom)\r
+ {\r
+ int n;\r
+ \r
+ /* True Shading of a screen block */\r
+ \r
+ gettext(lef,top,right,bottom,sbuff);\r
+ for(n = 1; n < 2000; n+= 2)\r
+ sbuff[n] = 7;\r
+ puttext(lef,top,right,bottom,sbuff);\r
+ }\r
+ \r
+ void DBOX(int l, int t, int r, int b)\r
+ {\r
+ /* Draws a double line box around the described area */\r
+ \r
+ int n;\r
+ \r
+ cursor(t,l);\r
+ print("\90");\r
+ for(n = 1; n < r - l; n++)\r
+ {\r
+ cursor(t,l + n);\r
+ print("I");\r
+ }\r
+ cursor(t,r);\r
+ print("¯");\r
+ \r
+ for (n = t + 1; n < b; n++)\r
+ {\r
+ cursor(n,l);\r
+ print("§");\r
+ cursor(n,r);\r
+ print("§");\r
+ }\r
+ cursor(b,l);\r
+ print("E");\r
+ for(n = 1; n < r - l; n++)\r
+ {\r
+ cursor(b,l+n);\r
+ print("I");\r
+ }\r
+ cursor(b,r);\r
+ print("¬");\r
+ }\r
+ \r
+ int INPUT(char *text,unsigned length)\r
+ {\r
+ /* Receive a string from the operator */\r
+ \r
+ unsigned key_pos;\r
+ int key;\r
+ unsigned start_row;\r
+ unsigned start_col;\r
+ unsigned end;\r
+ char temp[80];\r
+ char *p;\r
+ \r
+ curr_cursor(&start_row,&start_col);\r
+ \r
+ key_pos = 0;\r
+ end = strlen(text);\r
+ for(;;)\r
+ {\r
+ key = bioskey(0);\r
+ if ((key & 0xFF) == 0)\r
+ {\r
+ key = key >> 8;\r
+ if (key == 79)\r
+ {\r
+ while(key_pos < end)\r
+ key_pos++;\r
+ cursor(start_row,start_col + key_pos);\r
+ }\r
+ else\r
+ if (key == 71)\r
+ {\r
+ key_pos = 0;\r
+ cursor(start_row,start_col);\r
+ }\r
+ else\r
+ if ((key == 75) && (key_pos > 0))\r
+ {\r
+ key_pos--;\r
+ cursor(start_row,start_col + key_pos);\r
+ }\r
+ else\r
+ if ((key == 77) && (key_pos < end))\r
+ {\r
+ key_pos++;\r
+ cursor(start_row,start_col + key_pos);\r
+ }\r
+ else\r
+ if (key == 83)\r
+ {\r
+ p = text + key_pos;\r
+ while(*(p+1))\r
+ {\r
+ *p = *(p+1);\r
+ p++;\r
+ }\r
+ *p = 32;\r
+ if (end > 0)\r
+ end--;\r
+ cursor(start_row,start_col);\r
+ cprintf(text);\r
+ cprintf(" ");\r
+ if ((key_pos > 0) && (key_pos == end))\r
+ key_pos--;\r
+ cursor(start_row,start_col + key_pos);\r
+ }\r
+ }\r
+ else\r
+ {\r
+ key = key & 0xFF;\r
+ if (key == 13 || key == 27)\r
+ break;\r
+ else\r
+ if ((key == 8) && (key_pos > 0))\r
+ {\r
+ end--;\r
+ key_pos--;\r
+ text[key_pos--] = '\0';\r
+ strcpy(temp,text);\r
+ p = text + key_pos + 2;\r
+ strcat(temp,p);\r
+ strcpy(text,temp);\r
+ cursor(start_row,start_col);\r
+ cprintf("%-*.*s",length,length,text);\r
+ key_pos++;\r
+ cursor(start_row,start_col + key_pos);\r
+ }\r
+ else\r
+ if ((key > 31) && (key_pos < length) &&\r
+ (start_col + key_pos < 80))\r
+ {\r
+ if (key_pos <= end)\r
+ {\r
+ p = text + key_pos;\r
+ memmove(p+1,p,end - key_pos);\r
+ if (end < length)\r
+ end++;\r
+ text[end] = '\0';\r
+ }\r
+ text[key_pos++] = (char)key;\r
+ if (key_pos > end)\r
+ {\r
+ end++;\r
+ text[end] = '\0';\r
+ }\r
+ cursor(start_row,start_col);\r
+ cprintf("%-*.*s",length,length,text);\r
+ cursor(start_row,start_col + key_pos);\r
+ }\r
+ }\r
+ }\r
+ text[end] = '\0';\r
+ return key;\r
+ }\r
+ \r
+ void FATAL(char *error)\r
+ {\r
+ /* A fatal error has occured */\r
+ \r
+ printf("\nFATAL ERROR: %s",error);\r
+ exit(0);\r
+ }\r
+ \r
+ void OPENDATA()\r
+ {\r
+ /* Check for existence of data file and if not create it */\r
+ /* otherwise open it for reading/writing at end of file */\r
+ \r
+ handle = open(fpath,O_RDWR,S_IWRITE);\r
+ \r
+ if (handle == -1)\r
+ {\r
+ handle = open(fpath,O_RDWR|O_CREAT,S_IWRITE);\r
+ if (handle == -1)\r
+ FATAL("Unable to create data file");\r
+ }\r
+ /* Read in first rec */\r
+ read(handle,&rec,recsize);\r
+ }\r
+ \r
+ void CLOSEDATA()\r
+ {\r
+ close(handle);\r
+ }\r
+ \r
+ void GETDATA(int start)\r
+ {\r
+ /* Get address data from operator */\r
+ \r
+ textcolor(BLACK);\r
+ textbackground(GREEN);\r
+ gotoxy(left,8);\r
+ print("Name ");\r
+ gotoxy(left,9);\r
+ print("Company ");\r
+ gotoxy(left,10);\r
+ print("Address ");\r
+ gotoxy(left,11);\r
+ print("Area ");\r
+ gotoxy(left,12);\r
+ print("Town ");\r
+ gotoxy(left,13);\r
+ print("County ");\r
+ gotoxy(left,14);\r
+ print("Post Code ");\r
+ gotoxy(left,15);\r
+ print("Telephone ");\r
+ gotoxy(left,16);\r
+ print("Fax ");\r
+ \r
+ switch(start)\r
+ {\r
+ case 0: gotoxy(left + 10,8);\r
+ if(INPUT(rec.name,30) == 27)\r
+ break;\r
+ case 1: gotoxy(left + 10,9);\r
+ if(INPUT(rec.company,30) == 27)\r
+ break;\r
+ case 2: gotoxy(left + 10,10);\r
+ if(INPUT(rec.address,30) == 27)\r
+ break;\r
+ case 3: gotoxy(left + 10,11);\r
+ if(INPUT(rec.area,30) == 27)\r
+ break;\r
+ case 4: gotoxy(left + 10,12);\r
+ if(INPUT(rec.town,30) == 27)\r
+ break;\r
+ case 5: gotoxy(left + 10,13);\r
+ if(INPUT(rec.county,30) == 27)\r
+ break;\r
+ case 6: gotoxy(left + 10,14);\r
+ if(INPUT(rec.post,12) == 27)\r
+ break;\r
+ case 7: gotoxy(left + 10,15);\r
+ if(INPUT(rec.telephone,15) == 27)\r
+ break;\r
+ case 8: gotoxy(left + 10,16);\r
+ INPUT(rec.fax,15);\r
+ break;\r
+ }\r
+ textcolor(WHITE);\r
+ textbackground(RED);\r
+ gotoxy(left + 23,21);\r
+ print(" ");\r
+ }\r
+ \r
+ void DISPDATA()\r
+ {\r
+ /* Display address data */\r
+ textcolor(BLACK);\r
+ textbackground(GREEN);\r
+ cursor(7,3);\r
+ cprintf("Name %-30.30s",rec.name);\r
+ cursor(8,3);\r
+ cprintf("Company %-30.30s",rec.company);\r
+ cursor(9,3);\r
+ cprintf("Address %-30.30s",rec.address);\r
+ cursor(10,3);\r
+ cprintf("Area %-30.30s",rec.area);\r
+ cursor(11,3);\r
+ cprintf("Town %-30.30s",rec.town);\r
+ cursor(12,3);\r
+ cprintf("County %-30.30s",rec.county);\r
+ cursor(13,3);\r
+ cprintf("Post Code %-30.30s",rec.post);\r
+ cursor(14,3);\r
+ cprintf("Telephone %-30.30s",rec.telephone);\r
+ cursor(15,3);\r
+ cprintf("Fax %-30.30s",rec.fax);\r
+ }\r
+ \r
+ int LOCATE(char *text)\r
+ {\r
+ int result;\r
+ \r
+ do\r
+ {\r
+ /* Read rec into memory */\r
+ result = read(handle,&rec,recsize);\r
+ if (result > 0)\r
+ {\r
+ /* Scan rec for matching data */\r
+ if (strstr(strupr(rec.name),text) != NULL)\r
+ return(1);\r
+ if (strstr(strupr(rec.company),text) != NULL)\r
+ return(1);\r
+ if (strstr(strupr(rec.address),text) != NULL)\r
+ return(1);\r
+ if (strstr(strupr(rec.area),text) != NULL)\r
+ return(1);\r
+ if (strstr(strupr(rec.town),text) != NULL)\r
+ return(1);\r
+ if (strstr(strupr(rec.county),text) != NULL)\r
+ return(1);\r
+ if (strstr(strupr(rec.post),text) != NULL)\r
+ return(1);\r
+ if (strstr(strupr(rec.telephone),text) != NULL)\r
+ return(1);\r
+ if (strstr(strupr(rec.fax),text) != NULL)\r
+ return(1);\r
+ }\r
+ }\r
+ while(result > 0);\r
+ return(0);\r
+ }\r
+ \r
+ void SEARCH()\r
+ {\r
+ int result;\r
+ \r
+ gotoxy(left,21);\r
+ textcolor(WHITE);\r
+ textbackground(RED);\r
+ cprintf("Enter data to search for ");\r
+ strcpy(stext,"");\r
+ INPUT(stext,30);\r
+ if (*stext == 0)\r
+ {\r
+ gotoxy(left,21);\r
+ cprintf("%70c",32);\r
+ return;\r
+ }\r
+ gotoxy(left,21);\r
+ textcolor(WHITE);\r
+ textbackground(RED);\r
+ cprintf("Searching for %s Please Wait....",stext);\r
+ strupr(stext);\r
+ /* Locate start of file */\r
+ lseek(handle,0,SEEK_SET);\r
+ result = LOCATE(stext);\r
+ if (result == 0)\r
+ {\r
+ gotoxy(left,21);\r
+ cprintf("%70c",32);\r
+ gotoxy(left + 27,21);\r
+ cprintf("NO MATCHING RECORDS");\r
+ gotoxy(left + 24,22);\r
+ cprintf("Press RETURN to Continue");\r
+ bioskey(0);\r
+ gotoxy(left,21);\r
+ cprintf("%70c",32);\r
+ gotoxy(left,22);\r
+ cprintf("%70c",32);\r
+ }\r
+ else\r
+ {\r
+ lseek(handle,0 - recsize,SEEK_CUR);\r
+ read(handle,&rec,recsize);\r
+ DISPDATA();\r
+ }\r
+ textcolor(WHITE);\r
+ textbackground(RED);\r
+ gotoxy(left,21);\r
+ cprintf("%70c",32);\r
+ textcolor(BLACK);\r
+ textbackground(GREEN);\r
+ }\r
+ \r
+ void CONTINUE()\r
+ {\r
+ int result;\r
+ long curpos;\r
+ \r
+ curpos = tell(handle) - recsize;\r
+ \r
+ result = LOCATE(stext);\r
+ textcolor(WHITE);\r
+ textbackground(RED);\r
+ if (result == 0)\r
+ {\r
+ gotoxy(left + 24,21);\r
+ cprintf("NO MORE MATCHING RECORDS");\r
+ gotoxy(left + 24,22);\r
+ cprintf("Press RETURN to Continue");\r
+ bioskey(0);\r
+ gotoxy(left,21);\r
+ cprintf("%70c",32);\r
+ gotoxy(left,22);\r
+ cprintf("%70c",32);\r
+ lseek(handle,curpos,SEEK_SET);\r
+ read(handle,&rec,recsize);\r
+ DISPDATA();\r
+ }\r
+ else\r
+ {\r
+ lseek(handle,0 - recsize,SEEK_CUR);\r
+ read(handle,&rec,recsize);\r
+ DISPDATA();\r
+ }\r
+ textcolor(WHITE);\r
+ textbackground(RED);\r
+ gotoxy(left,21);\r
+ cprintf("%70c",32);\r
+ gotoxy(left,22);\r
+ cprintf(" ");\r
+ textcolor(BLACK);\r
+ textbackground(GREEN);\r
+ }\r
+ \r
+ void PRINT_MULTI()\r
+ {\r
+ data buffer;\r
+ char destination[60];\r
+ char text[5];\r
+ int result;\r
+ int ok;\r
+ int ok2;\r
+ int blanks;\r
+ int total_lines;\r
+ char *p;\r
+ FILE *fp;\r
+ \r
+ textcolor(WHITE);\r
+ textbackground(RED);\r
+ gotoxy(left + 23,21);\r
+ cprintf("Enter selection criteria");\r
+ \r
+ /* Clear existing rec details */\r
+ memset(&rec,0,recsize);\r
+ \r
+ DISPDATA();\r
+ GETDATA(0);\r
+ \r
+ textcolor(WHITE);\r
+ textbackground(RED);\r
+ gotoxy(left,21);\r
+ cprintf("Enter report destination PRN");\r
+ strcpy(destination,"PRN");\r
+ gotoxy(left,22);\r
+ cprintf("Enter Address length in lines 18");\r
+ strcpy(text,"18");\r
+ gotoxy(left + 25,21);\r
+ INPUT(destination,40);\r
+ gotoxy(left +30,22);\r
+ INPUT(text,2);\r
+ gotoxy(left,21);\r
+ cprintf("%72c",32);\r
+ gotoxy(left,22);\r
+ cprintf("%72c",32);\r
+ \r
+ total_lines = atoi(text) - 6;\r
+ if (total_lines < 0)\r
+ total_lines = 0;\r
+ \r
+ fp = fopen(destination,"w+");\r
+ if (fp == NULL)\r
+ {\r
+ gotoxy(left,21);\r
+ cprintf("Unable to print to %s",destination);\r
+ gotoxy(left,22);\r
+ cprintf("Press RETURN to Continue");\r
+ bioskey(0);\r
+ gotoxy(left,21);\r
+ cprintf("%78c",32);\r
+ gotoxy(left,22);\r
+ cprintf(" ");\r
+ }\r
+ \r
+ /* Locate start of file */\r
+ lseek(handle,0,SEEK_SET);\r
+ \r
+ do\r
+ {\r
+ /* Read rec into memory */\r
+ result = read(handle,&buffer,recsize);\r
+ if (result > 0)\r
+ {\r
+ ok = 1;\r
+ /* Scan rec for matching data */\r
+ if (*rec.name)\r
+ if (stricmp(buffer.name,rec.name))\r
+ ok = 0;\r
+ if (*rec.company)\r
+ if (stricmp(buffer.company,rec.company))\r
+ ok = 0;\r
+ if (*rec.address)\r
+ if (stricmp(buffer.address,rec.address))\r
+ ok = 0;\r
+ if (*rec.area)\r
+ if (stricmp(buffer.area,rec.area))\r
+ ok = 0;\r
+ if (*rec.town)\r
+ if (stricmp(buffer.town,rec.town))\r
+ ok = 0;\r
+ if (*rec.county)\r
+ if (stricmp(buffer.county,rec.county))\r
+ ok = 0;\r
+ if (*rec.post)\r
+ if (stricmp(buffer.post,rec.post))\r
+ ok = 0;\r
+ if (*rec.telephone)\r
+ if (stricmp(buffer.telephone,rec.telephone))\r
+ ok = 0;\r
+ if (*rec.fax)\r
+ if (stricmp(buffer.fax,rec.fax))\r
+ ok = 0;\r
+ if (ok)\r
+ {\r
+ blanks = total_lines;\r
+ p = buffer.name;\r
+ ok2 = 0;\r
+ while(*p)\r
+ {\r
+ if (*p != 32)\r
+ {\r
+ ok2 = 1;\r
+ break;\r
+ }\r
+ p++;\r
+ }\r
+ if (!ok2)\r
+ blanks++;\r
+ else\r
+ fprintf(fp,"%s\n",buffer.name);\r
+ p = buffer.company;\r
+ ok2 = 0;\r
+ while(*p)\r
+ {\r
+ if (*p != 32)\r
+ {\r
+ ok2 = 1;\r
+ break;\r
+ }\r
+ p++;\r
+ }\r
+ if (!ok2)\r
+ blanks++;\r
+ else\r
+ fprintf(fp,"%s\n",buffer.company);\r
+ p = buffer.address;\r
+ ok2 = 0;\r
+ \r
+ while(*p)\r
+ {\r
+ if (*p != 32)\r
+ {\r
+ ok2 = 1;\r
+ break;\r
+ }\r
+ p++;\r
+ }\r
+ if (!ok2)\r
+ blanks++;\r
+ else\r
+ fprintf(fp,"%s\n",buffer.address);\r
+ p = buffer.area;\r
+ ok2 = 0;\r
+ while(*p)\r
+ {\r
+ if (*p != 32)\r
+ {\r
+ ok2 = 1;\r
+ break;\r
+ }\r
+ p++;\r
+ }\r
+ if (!ok2)\r
+ blanks++;\r
+ else\r
+ fprintf(fp,"%s\n",buffer.area);\r
+ p = buffer.town;\r
+ ok2 = 0;\r
+ while(*p)\r
+ {\r
+ if (*p != 32)\r
+ {\r
+ ok2 = 1;\r
+ break;\r
+ }\r
+ p++;\r
+ }\r
+ if (!ok2)\r
+ blanks++;\r
+ else\r
+ fprintf(fp,"%s\n",buffer.town);\r
+ p = buffer.county;\r
+ ok2 = 0;\r
+ \r
+ while(*p)\r
+ {\r
+ if (*p != 32)\r
+ {\r
+ ok2 = 1;\r
+ break;\r
+ }\r
+ p++;\r
+ }\r
+ if (!ok2)\r
+ blanks++;\r
+ else\r
+ fprintf(fp,"%s\n",buffer.county);\r
+ p = buffer.post;\r
+ ok2 = 0;\r
+ while(*p)\r
+ {\r
+ if (*p != 32)\r
+ {\r
+ ok2 = 1;\r
+ break;\r
+ }\r
+ p++;\r
+ }\r
+ if (!ok2)\r
+ blanks++;\r
+ else\r
+ fprintf(fp,"%s\n",buffer.post);\r
+ while(blanks)\r
+ {\r
+ fprintf(fp,"\n");\r
+ blanks--;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ while(result > 0);\r
+ fclose(fp);\r
+ lseek(handle,0,SEEK_SET);\r
+ read(handle,&rec,recsize);\r
+ DISPDATA();\r
+ }\r
+ \r
+ void EXPORT_MULTI()\r
+ {\r
+ data buffer;\r
+ char destination[60];\r
+ int result;\r
+ int ok;\r
+ FILE *fp;\r
+ \r
+ textcolor(WHITE);\r
+ textbackground(RED);\r
+ gotoxy(left + 23,21);\r
+ cprintf("Enter selection criteria");\r
+ \r
+ /* Clear existing rec details */\r
+ memset(&rec,0,recsize);\r
+ \r
+ DISPDATA();\r
+ GETDATA(0);\r
+ \r
+ textcolor(WHITE);\r
+ textbackground(RED);\r
+ gotoxy(left,21);\r
+ cprintf("Enter export file address.txt");\r
+ strcpy(destination,"address.txt");\r
+ gotoxy(left + 18,21);\r
+ INPUT(destination,59);\r
+ gotoxy(left,21);\r
+ cprintf("%70c",32);\r
+ \r
+ fp = fopen(destination,"w+");\r
+ if (fp == NULL)\r
+ {\r
+ gotoxy(left,21);\r
+ cprintf("Unable to print to %s",destination);\r
+ gotoxy(left,22);\r
+ cprintf("Press RETURN to Continue");\r
+ bioskey(0);\r
+ gotoxy(left,21);\r
+ cprintf("%78c",32);\r
+ gotoxy(left,22);\r
+ cprintf(" ");\r
+ }\r
+ /* Locate start of file */\r
+ lseek(handle,0,SEEK_SET);\r
+ \r
+ do\r
+ {\r
+ /* Read rec into memory */\r
+ result = read(handle,&buffer,recsize);\r
+ if (result > 0)\r
+ {\r
+ ok = 1;\r
+ /* Scan rec for matching data */\r
+ if (*rec.name)\r
+ if (stricmp(buffer.name,rec.name))\r
+ ok = 0;\r
+ if (*rec.company)\r
+ if (stricmp(buffer.company,rec.company))\r
+ ok = 0;\r
+ if (*rec.address)\r
+ if (stricmp(buffer.address,rec.address))\r
+ ok = 0;\r
+ if (*rec.area)\r
+ if (stricmp(buffer.area,rec.area))\r
+ ok = 0;\r
+ if (*rec.town)\r
+ if (stricmp(buffer.town,rec.town))\r
+ ok = 0;\r
+ if (*rec.county)\r
+ if (stricmp(buffer.county,rec.county))\r
+ ok = 0;\r
+ if (*rec.post)\r
+ if (stricmp(buffer.post,rec.post))\r
+ ok = 0;\r
+ if (*rec.telephone)\r
+ if (stricmp(buffer.telephone,rec.telephone))\r
+ ok = 0;\r
+ if (*rec.fax)\r
+ if (stricmp(buffer.fax,rec.fax))\r
+ ok = 0;\r
+ if (ok)\r
+ {\r
+ fprintf(fp,"\"%s\",",buffer.name);\r
+ fprintf(fp,"\"%s\",",buffer.company);\r
+ fprintf(fp,"\"%s\",",buffer.address);\r
+ fprintf(fp,"\"%s\",",buffer.area);\r
+ fprintf(fp,"\"%s\",",buffer.town);\r
+ fprintf(fp,"\"%s\",",buffer.county);\r
+ fprintf(fp,"\"%s\",",buffer.post);\r
+ fprintf(fp,"\"%s\",",buffer.telephone);\r
+ fprintf(fp,"\"%s\"\n",buffer.fax);\r
+ \r
+ }\r
+ }\r
+ }\r
+ \r
+ while(result > 0);\r
+ fclose(fp);\r
+ lseek(handle,0,SEEK_SET);\r
+ read(handle,&rec,recsize);\r
+ DISPDATA();\r
+ }\r
+ \r
+ void MENU()\r
+ {\r
+ int option;\r
+ long result;\r
+ long end;\r
+ int new;\r
+ \r
+ do\r
+ {\r
+ cursor(21,26);\r
+ print("Select option (F2 - F10)");\r
+ cursor(7,52);\r
+ print("F2 Next record");\r
+ cursor(8,52);\r
+ print("F3 Previous record");\r
+ cursor(9,52);\r
+ print("F4 Amend record");\r
+ cursor(10,52);\r
+ print("F5 Add new record");\r
+ cursor(11,52);\r
+ print("F6 Search");\r
+ cursor(12,52);\r
+ print("F7 Continue search");\r
+ cursor(13,52);\r
+ print("F8 Print address labels");\r
+ cursor(14,52);\r
+ print("F9 Export records");\r
+ cursor(15,52);\r
+ print("F10 Exit");\r
+ MOUSE_CURSOR(1);\r
+ option = GETOPT();\r
+ MOUSE_CURSOR(0);\r
+ \r
+ switch(option)\r
+ {\r
+ case 0 : /* Next rec */\r
+ result = read(handle,&rec,recsize);\r
+ if (!result)\r
+ {\r
+ lseek(handle,0,SEEK_SET);\r
+ result = read(handle,&rec,recsize);\r
+ }\r
+ DISPDATA();\r
+ break;\r
+ \r
+ case 1 : /* Previous rec */\r
+ result = lseek(handle,0 - recsize * 2,SEEK_CUR);\r
+ if (result <= -1)\r
+ lseek(handle,0 - recsize,SEEK_END);\r
+ result = read(handle,&rec,recsize);\r
+ DISPDATA();\r
+ break;\r
+\r
+ case 3 : /* Add rec */\r
+ lseek(handle,0,SEEK_END);\r
+ memset(&rec,0,recsize);\r
+ DISPDATA();\r
+ \r
+ case 2 : /* Amend current rec */\r
+ new = 1;\r
+ if (*rec.name)\r
+ new = 0;\r
+ else\r
+ if (*rec.company)\r
+ new = 0;\r
+ else\r
+ if (*rec.address)\r
+ new = 0;\r
+ else\r
+ if (*rec.area)\r
+ new = 0;\r
+ else\r
+ if (*rec.town)\r
+ new = 0;\r
+ else\r
+ if (*rec.county)\r
+ new = 0;\r
+ else\r
+ if (*rec.post)\r
+ new = 0;\r
+ else\r
+ if (*rec.telephone)\r
+ new = 0;\r
+ else\r
+ if (*rec.fax)\r
+ new = 0;\r
+ result = tell(handle);\r
+ lseek(handle,0,SEEK_END);\r
+ end = tell(handle);\r
+ \r
+ /* Back to original position */\r
+ lseek(handle,result,SEEK_SET);\r
+ \r
+ /* If not at end of file, && !new rewind one\r
+rec */\r
+ if (result != end || ! new)\r
+ result = lseek(handle,0 -\r
+recsize,SEEK_CUR);\r
+ result = tell(handle);\r
+ gotoxy(left + 22,21);\r
+ print(" Enter address details ");\r
+ GETDATA(0);\r
+ if (*rec.name || *rec.company)\r
+ result = write(handle,&rec,recsize);\r
+ break;\r
+\r
+ case 4 : /* Search */\r
+ gotoxy(left + 22,21);\r
+ print(" ");\r
+ SEARCH();\r
+ break;\r
+ \r
+ case 5 : /* Continue */\r
+ gotoxy(left + 22,21);\r
+ print(" ");\r
+ CONTINUE();\r
+ break;\r
+ \r
+ case 6 : /* Print */\r
+ gotoxy(left + 22,21);\r
+ print(" ");\r
+ PRINT_MULTI();\r
+ break;\r
+\r
+ case 7 : /* Export */\r
+ gotoxy(left + 22,21);\r
+ print(" ");\r
+ EXPORT_MULTI();\r
+ break;\r
+ \r
+ case 8 : /* Exit */\r
+ break;\r
+ \r
+ default: /* Amend current rec */\r
+ new = 1;\r
+ if (*rec.name)\r
+ new = 0;\r
+ else\r
+ if (*rec.company)\r
+ new = 0;\r
+ else\r
+ if (*rec.address)\r
+ new = 0;\r
+ else\r
+ if (*rec.area)\r
+ new = 0;\r
+ else\r
+ if (*rec.town)\r
+ new = 0;\r
+ else\r
+ if (*rec.county)\r
+ new = 0;\r
+ else\r
+ if (*rec.post)\r
+ new = 0;\r
+ else\r
+ if (*rec.telephone)\r
+ new = 0;\r
+ else\r
+ if (*rec.fax)\r
+ new = 0;\r
+ result = tell(handle);\r
+ lseek(handle,0,SEEK_END);\r
+ end = tell(handle);\r
+\r
+ /* Back to original position */\r
+ lseek(handle,result,SEEK_SET);\r
+\r
+ /* If not at end of file, && !new rewind one\r
+rec */\r
+ if (result != end || ! new)\r
+ result = lseek(handle,0 -\r
+recsize,SEEK_CUR);\r
+ result = tell(handle);\r
+ gotoxy(left + 22,21);\r
+ print(" Enter address details ");\r
+ GETDATA(option - 17);\r
+ if (*rec.name || *rec.company)\r
+ result = write(handle,&rec,recsize);\r
+ option = -1;\r
+ break;\r
+\r
+ }\r
+ }\r
+ \r
+ while(option != 8);\r
+ }\r
+ \r
+ void exec()\r
+ {\r
+ gettext(1,1,80,25,scr);\r
+ setvideo(3);\r
+ textbackground(WHITE);\r
+ textcolor(BLACK);\r
+ clrscr();\r
+ recsize = sizeof(data);\r
+ \r
+ OPENDATA();\r
+ \r
+ TRUESHADE(left,3,79,5);\r
+ window(left - 2,2 ,78, 4);\r
+ textcolor(YELLOW);\r
+ textbackground(MAGENTA);\r
+ clrscr();\r
+ DBOX(left - 3, 1, 77, 3);\r
+ gotoxy(3,2);\r
+ print("Servile Software PC ADDRESS BOOK 5.2\r
+ (c) 1994");\r
+ \r
+ TRUESHADE(left,8,left + 43,18);\r
+ window(left - 2,7 , left + 42, 17);\r
+ textcolor(BLACK);\r
+ textbackground(GREEN);\r
+ clrscr();\r
+ DBOX(left - 3, 6, left + 41, 16);\r
+ \r
+ TRUESHADE(left + 48,8,79,18);\r
+ window(left + 46, 7 , 78, 17);\r
+ textbackground(BLUE);\r
+ textcolor(YELLOW);\r
+ clrscr();\r
+ DBOX(left + 45,6,77,16);\r
+ \r
+ TRUESHADE(left ,21,79,24);\r
+ window(left - 2, 20 , 78, 23);\r
+ textbackground(RED);\r
+ textcolor(WHITE);\r
+ clrscr();\r
+ DBOX(left - 3,19,77,22);\r
+ \r
+ window(1,1,80,25);\r
+ textcolor(BLACK);\r
+ textbackground(GREEN);\r
+ DISPDATA();\r
+ \r
+ MENU();\r
+ \r
+ CLOSEDATA();\r
+ puttext(1,1,80,25,scr);\r
+ return;\r
+ }\r
+ \r
+ \r
+ INTERFACING C WITH CLIPPER\r
+\r
+The Clipper programming language is a popular xBase environment for the\r
+PC. However, it lacks many of the facilities available to programmers of\r
+other languages, and it is quite slow compared to C. Because of this\r
+there are a large number of third party add-on libraries available for\r
+Clipper which provide the facilities lacked.\r
+\r
+As a programmer you probably want to write your own library for Clipper,\r
+or perhaps individual functions to cater for circumstances which Clipper\r
+cannot handle, such as high resolution graphics.\r
+\r
+Throughout this section, Clipper refers to the Summer `87 Clipper\r
+compiler, although initial tests show that the functions described here\r
+work perfectly well with the new Clipper 5 compiler also, we are not in a\r
+position to guarrantee success!\r
+\r
+\r
+COMPILING AND LINKING\r
+The Clipper extend functions allow user defined functions to be written\r
+in C, linked with and used by the Clipper application. The first\r
+problem a programmer must address when writing functions in C to link\r
+with a Clipper application is that of the C compiler's run time\r
+libraries.\r
+\r
+If one is writing functions with Microsoft C, then most of the required\r
+run time library functions will be found in the Clipper.lib and\r
+Extend.lib libraries which are part of Clipper.\r
+\r
+If, however, one is using a different C compiler, such as Borland's\r
+Turbo C then the run time library routines must be supplied on the link\r
+line.\r
+\r
+All C functions must be compiled using the large memory model the\r
+following line is used with Microsoft C\r
+\r
+\r
+ cl /c /AL /Zl /Oalt /FPa /Gs <program.c>\r
+\r
+and this compile line may be used with Turbo C\r
+\r
+ tcc -c -ml <program>\r
+\r
+simply substitute <program> for the program name to be compiled.\r
+\r
+Having compiled a C function it must be linked in with the application.\r
+If the C function was compiled with Microsoft C then the link line will\r
+look a little like this;\r
+\r
+\r
+ LINK /SE:500 /NOE program.obj cfunc.obj,,,Clipper Extend\r
+\r
+If the C function was linked with another C compiler you will also need\r
+to link in the C run time libraries, for example to link in the Turbo C\r
+large memory mode library use the following link line;\r
+\r
+\r
+ LINK /SE:500 /NOE program.obj cfunc.obj,,,Clipper Extend cl\r
+\r
+If one is using a number of separately compiled C functions it is a good\r
+idea to collect them in a library. If you are using Microsoft C then\r
+you can simply create the library by using Microsoft Lib.exe with\r
+the following command line;\r
+\r
+\r
+ LIB mylib +prog1 +prog2, NUL, NUL\r
+\r
+This tells the librarian to add prog1.obj and prog2.obj to a library\r
+called mylib.lib, creating it if it does not exist. The NUL\r
+parameter is for supressing the listing file.\r
+\r
+\r
+If you have been using another C compiler you should copy the C large\r
+memory model run time library before adding your functions to it for\r
+example;\r
+\r
+\r
+ COPY C:\TURBOC\LIB\cl.lib mylib.lib\r
+ LIB mylib +prog1 +prog2, NUL, NUL\r
+\r
+Then when you link your Clipper application you will use a link line\r
+similar to;\r
+\r
+ LINK /SE:500 /NOE myprog,,,Clipper Extend Mylib\r
+\r
+Often when linking C functions with Clipper applications link errors\r
+will occur such as those shown below;\r
+\r
+ \r
+ Microsoft (R) Overlay Linker Version 3.65\r
+ Copyright (C) Microsoft Corp 1983-1988. All rights reserved.\r
+ \r
+ \r
+ LINK : error L2029: Unresolved externals:\r
+ \r
+ \r
+ FIWRQQ in file(s):\r
+ M:SLIB.LIB(TEST)\r
+ FIDRQQ in file(s):\r
+ M:SLIB.LIB(TEST)\r
+ \r
+ There were 2 errors detected\r
+ \r
+\r
+Example Link Errors\r
+\r
+The errors shown here are `Unresolved externals', that is they\r
+are references to functions which are not found in any of the object\r
+modules or libraries specified on the link line. These occur because\r
+the C compilers often scatter functions and variables through a number\r
+of libraries. In tracking these functions down use may be made of\r
+the Microsoft librarian list file option. If you run Lib.Exe on the\r
+Turbo C `emu.lib' library file and specify a listing file as follows;\r
+\r
+\r
+ LIB emu,emu.lst\r
+\r
+The librarian will create an ascii file which contains the names of\r
+each object module contained in the specified library file, and the names\r
+of each function and public variable declared in each object module, as\r
+shown in this listing of Borland's EMU.LIB library.\r
+\r
+\r
+ e086_Entry........EMU086 e086_Shortcut.....EMU086\r
+ e087_Entry........EMU087 e087_Shortcut.....EMU087\r
+ FIARQQ............EMUINIT FICRQQ............EMUINIT\r
+ FIDRQQ............EMUINIT FIERQQ............EMUINIT\r
+ FISRQQ............EMUINIT FIWRQQ............EMUINIT\r
+ FJARQQ............EMUINIT FJCRQQ............EMUINIT\r
+ FJSRQQ............EMUINIT __EMURESET........EMUINIT\r
+ \r
+ \r
+ EMUINIT Offset: 00000010H Code and data size: 1a2H\r
+ FIARQQ FICRQQ FIDRQQ FIERQQ\r
+ FISRQQ FIWRQQ FJARQQ FJCRQQ\r
+ FJSRQQ __EMURESET\r
+ \r
+ EMU086 Offset: 00000470H Code and data size: 2630H\r
+ e086_Entry e086_Shortcut\r
+ \r
+ EMU087 Offset: 00003200H Code and data size: 417H\r
+ e087_Entry e087_Shortcut\r
+ \r
+\r
+\r
+Receiving Parameters\r
+\r
+Clipper provides six different functions for receiving parameters in a C\r
+function. These functions are;\r
+\r
+\r
+ Receive a string char * _parc(int,[int])\r
+ Receive a Date string char * _pards(int,[int])\r
+ Receive a logical int _parl(int,[int])\r
+ Receive an integer int _parni(int,[int])\r
+ Receive a long long _parnl(int,[int])\r
+ Receive a double double _parnd(int,[int])\r
+\r
+\r
+\r
+To illustrate simple parameter receiving in a C function I offer\r
+the following simple C function which receives two numeric parameters\r
+from the calling Clipper program, and uses these two numeric\r
+parameters to set the size of the cursor.\r
+\r
+\r
+ #include <nandef.h> /* Clipper header files */\r
+ #include <extend.h>\r
+ #include <dos.h> /* Header file to define REGS */\r
+ \r
+ CLIPPER s_curset()\r
+ {\r
+ /* Demonstration function to set cursor shape */\r
+ \r
+ union REGS inreg,outreg;\r
+ \r
+ inreg.h.ah = 0x01;\r
+ inreg.h.ch = _parni(1); /* Get integer parameter 1 */\r
+ inreg.h.cl = _parni(2); /* Get integer parameter 2 */\r
+ int86(0x10,&inreg,&outreg);\r
+ _ret(); /* Return to Clipper */\r
+ }\r
+\r
+Clipper provides four more functions for dealing with received\r
+parameters;\r
+\r
+_parclen(int,[int]) which returns the length of a string including\r
+imbedded `\0's, _parcsiz(int[int]) which returns the length of a\r
+character string passed by reference from Clipper, _parinfa(int,[int])\r
+which returns the type of a specified array element or the length of\r
+an array, and finally _parinfo(int) whic returns the type of a\r
+parameter.\r
+\r
+The following example function uses _parinfa() to determine both the\r
+length of an array passed from a Clipper program, and the type of each\r
+element in the array. The function then returns to Clipper an integer\r
+representing the number of defined elements in the array.\r
+\r
+\r
+\r
+ #include <nandef.h>\r
+ #include <extend.h>\r
+ \r
+ CLIPPER s_alen()\r
+ {\r
+ int total;\r
+ int n;\r
+ int defined;\r
+ int type;\r
+ \r
+ /* Return the number of defined elements in an array */\r
+ /* From Clipper use defined = s_alen(arr) */\r
+ \r
+ total = _parinfa(1,0); /* Get declared number of elements in\r
+ array */\r
+ \r
+ defined = 0;\r
+ \r
+ for (n = 1; n <= total; n++){\r
+ type = _parinfa(1,n); /* Get array parameter type */\r
+ if (type)\r
+ defined++;\r
+ }\r
+ _retni(defined); /* Return an integer to Clipper\r
+ */\r
+ }\r
+ \r
+\r
+This function goes one step further to return the mean average of\r
+all numeric values in an array. Notice the use of _parnd() to\r
+retrieve the numeric values as doubles. You may find that because of\r
+the floating point arithmetic in this function that it will only\r
+work if compiled with Microsoft C.\r
+\r
+\r
+ #include <nandef.h>\r
+ #include <extend.h>\r
+ \r
+ CLIPPER s_aave()\r
+ {\r
+ int total;\r
+ int defined;\r
+ int n;\r
+ int type;\r
+ double sum;\r
+ \r
+ /* Return the mean average value of numbers in array */\r
+ /* From Clipper use mean = s_aave(arr)\r
+ \r
+ \r
+ total = _parinfa(1,0); /* Get declared number of\r
+ elements */\r
+ \r
+ defined = 0;\r
+ \r
+ for (n = 1; n <= total; n++){ /* Determine number of defined\r
+ */\r
+ type = _parinfa(1,n); /* elements */\r
+ if (type == 2)\r
+ defined++;\r
+ }\r
+ \r
+ sum = 0;\r
+ \r
+ for (n = 1; n <= total; n++){\r
+ type = _parinfa(1,n);\r
+ if (type == 2) /* Only sum numeric values\r
+ */\r
+ sum += _parnd(1,n);\r
+ }\r
+ _retnd(sum / defined); /* Return a double to\r
+ Clipper */\r
+ }\r
+ \r
+ \r
+\r
+Returning Values\r
+\r
+The Clipper manual lists seven functions for returning from a\r
+function written in another language. These return functions for C are as\r
+follows;\r
+\r
+ character _retc(char *)\r
+ date _retds(char *)\r
+ logical _retl(int)\r
+ numeric (int) _retni(int)\r
+ numeric (long) _retnl(long)\r
+ numeric (double) _retnd(double)\r
+ nothing _ret(void)\r
+\r
+Omitted from the Clipper manual is the information that you may\r
+return different types of value back from a function! For example, you\r
+may wish to return a character string under normal circumstances, fine\r
+use _retc(). On error occurences however you can return a logical using\r
+_retl(). The Clipper program will assign the received value to the\r
+receiving variable in the correct manner.\r
+\r
+The following simple C function returns a random number. Notice the use\r
+of integers which limits the range of the function to +-32767. For\r
+larger values you should use longs instead of integers.\r
+\r
+\r
+ #include <nandef.h>\r
+ #include <extend.h>\r
+ #include <dos.h>\r
+ \r
+ CLIPPER s_random()\r
+ {\r
+ /* Returns a random number between 0 and param1 - 1 */\r
+ /* From Clipper use x = s_random(param1) */\r
+ \r
+ int param1;\r
+ int x;\r
+ \r
+ param1 = _parni(1);\r
+ \r
+ x = rand() % param1;\r
+ _retni(x);\r
+ }\r
+ \r
+\r
+This function receives a string from Clipper, and passes back an upper\r
+case copy of the string, leaving the original unchanged. The maximum\r
+length of the string which can be processed is determined by the size\r
+of target[], here set to 5000 characters.\r
+\r
+\r
+ #include <nandef.h>\r
+ #include <extend.h>\r
+ \r
+ CLIPPER s_upper()\r
+ {\r
+ /* Returns an upper case copy of string */\r
+ /* From Clipper use ? s_upper("this is a string")\r
+ \r
+ char *p;\r
+ char *q;\r
+ char *string;\r
+ char target[5000];\r
+ int n;\r
+ \r
+ string = _parc(1);\r
+ \r
+ p = string;\r
+ q = target;\r
+ \r
+ while(*string){\r
+ *q++ = toupper(*string);\r
+ string++;\r
+ }\r
+ *q = '\0';\r
+ string = p;\r
+ _retc(target);\r
+ }\r
+ \r
+ \r
+This function may be used to change the current DOS directory. If it\r
+is successful it returns .T. to the calling Clipper program,\r
+otherwise it returns .F.\r
+\r
+ #include <nandef.h>\r
+ #include <extend.h>\r
+ #include <dos.h>\r
+ \r
+ CLIPPER s_chdir()\r
+ {\r
+ /* Attempts to change the current DOS directory */\r
+ /* From Clipper use result = s_chdir(path) */\r
+ \r
+ union REGS inreg,outreg;\r
+ struct SREGS segreg;\r
+ \r
+ char *path;\r
+ int x;\r
+ \r
+ path = _parc(1); /* Retrieve string from Clipper\r
+ */\r
+ \r
+ inreg.h.ah = 0x3b;\r
+ segreg.ds = FP_SEG(path);\r
+ inreg.x.dx = FP_OFF(path);\r
+ intdosx(&inreg,&outreg,&segreg);\r
+ \r
+ x = outreg.x.ax;\r
+ \r
+ if (x == 3)\r
+ _retl(0); /* Return logical .F. back to Clipper */\r
+ else\r
+ _retl(1); /* Return logical .T. back to Clipper */\r
+ }\r
+ \r
+\r
+\r
+Avoiding Unresolved Externals\r
+\r
+As we have already seen, a common problem plaguing the programmer\r
+interfacing C functions with Clipper programs is Unresolved Externals.\r
+\r
+The following example C function called s_print() will not link\r
+with Clipper.\r
+\r
+ #include <nandef.h>\r
+ #include <extend.h>\r
+ #include <stdio.h>\r
+ \r
+ CLIPPER s_print()\r
+ {\r
+ char *x;\r
+ \r
+ x = _parc(1);\r
+ \r
+ printf("\nI received %s from Clipper.\n",x);\r
+ \r
+ _ret();\r
+ }\r
+ \r
+\r
+The linker gives you the following reply;\r
+\r
+ Microsoft (R) Overlay Linker Version 3.65\r
+ Copyright (C) Microsoft Corp 1983-1988. All rights reserved.\r
+ \r
+ M:SLIB.LIB(IOERROR) : error L2025: __doserrno : symbol defined more\r
+ than once\r
+ pos: 16C6F Record type: 53C6\r
+ \r
+ LINK : error L2029: Unresolved externals:\r
+ \r
+ \r
+\r
+ __RealCvtVector in file(s):\r
+ M:SLIB.LIB(REALCVT)\r
+ _abort in file(s):\r
+ M:SLIB.LIB(CVTFAK)\r
+ \r
+ There were 3 errors detected\r
+ \r
+\r
+The error L2025 `symbol defined more than once' can in this case be\r
+ignored. However, the unresolved externals `RealCvtVector' and\r
+`abort' cannot be ignored. These two functions are referenced by the\r
+function printf() which has been included in the C function. The\r
+answer is to use as few of the compiler's run time library functions\r
+as possible, use ROM calls instead with INT86() and INTDOSX() etc.\r
+\r
+\r
+Adding High Resolution Graphics To Clipper With C\r
+\r
+The most annoying omission from Clipper, in my opinion, is the lack of\r
+high resolution graphics facilities. The following functions, written in\r
+Turbo C, provide high resolution graphics to Clipper.\r
+\r
+First we require a means to change the video display mode to a high\r
+resolution graphics mode, and back to text mode. The IBM PC BIOS provides\r
+the means for this and can be called from C as follows;\r
+\r
+\r
+\r
+\r
+ /* Servile Software Library For Clipper */\r
+ \r
+ #include <nandef.h>\r
+ #include <extend.h>\r
+ #include <dos.h>\r
+ \r
+ CLIPPER s_smode()\r
+ {\r
+ /* Set Video Mode */\r
+ /* From Clipper use s_smode(mode) */\r
+ \r
+ union REGS inreg,outreg;\r
+ \r
+ inreg.h.al = _parni(1);\r
+ inreg.h.ah = 0x00;\r
+ int86 (0x10, &inreg, &outreg);\r
+ \r
+ \r
+ /* 1 40x25 colour text\r
+ 2 40x25 bw text\r
+ 3 80x25 colour text\r
+ 4 320x200 4 colour graphics\r
+ 5 320x200 4 colour graphics colour burst off\r
+ 6 640x200 2 colour graphics\r
+ etc\r
+ */\r
+ _ret();\r
+ }\r
+\r
+Having set the computer into graphics mode, how about setting pixels to a\r
+specified colour?\r
+\r
+ \r
+ /* Servile Software Library For Clipper */\r
+ \r
+ #include <nandef.h>\r
+ #include <extend.h>\r
+ #include <dos.h>\r
+ \r
+ CLIPPER s_plot()\r
+ {\r
+ \r
+ union REGS inreg,outreg;\r
+ \r
+ /* Sets a pixel at the specified coordinates to the specified\r
+ colour. */\r
+ \r
+ inreg.h.bh = 0x00;\r
+ inreg.x.cx = _parni(1);\r
+ inreg.x.dx = _parni(2);\r
+ inreg.h.al = _parni(3);\r
+ inreg.h.ah = 0x0C;\r
+ int86(0x10, &inreg, &outreg);\r
+ }\r
+ \r
+Line drawing and circles are handled by these two functions;\r
+\r
+ \r
+ /* Servile Software Library For Clipper */\r
+ \r
+ #include <nandef.h>\r
+ #include <extend.h>\r
+ #include <dos.h>\r
+ \r
+ CLIPPER s_line()\r
+ {\r
+ \r
+ union REGS inreg,outreg;\r
+ \r
+ /* Draws a straight line from (a,b) to (c,d) in colour col */\r
+ \r
+ int a;\r
+ int b;\r
+ int c;\r
+ int d;\r
+ int col;\r
+ int u;\r
+ int v;\r
+ int d1x;\r
+ int d1y;\r
+ int d2x;\r
+ int d2y;\r
+ int m;\r
+ int n;\r
+ int s;\r
+ int i;\r
+ \r
+ a = _parni(1);\r
+ b = _parni(2);\r
+ c = _parni(3);\r
+ d = _parni(4);\r
+ col = _parni(5);\r
+ \r
+ u = c - a;\r
+ v = d - b;\r
+ if (u == 0)\r
+ {\r
+ d1x = 0;\r
+ m = 0;\r
+ }\r
+ else\r
+ {\r
+ m = abs(u);\r
+ if (u < 0)\r
+ d1x = -1;\r
+ else\r
+ if (u > 0)\r
+ d1x = 1;\r
+ }\r
+ if ( v == 0)\r
+ {\r
+ d1y = 0;\r
+ n = 0;\r
+ }\r
+ else\r
+ {\r
+ n = abs(v);\r
+ if (v < 0)\r
+ d1y = -1;\r
+ else\r
+ if (v > 0)\r
+ d1y = 1;\r
+ }\r
+ if (m > n)\r
+ {\r
+ d2x = d1x;\r
+ d2y = 0;\r
+ }\r
+ else\r
+ {\r
+ d2x = 0;\r
+ d2y = d1y;\r
+ m = n;\r
+ n = abs(u);\r
+ }\r
+ s = (m / 2);\r
+ \r
+ inreg.h.al = (unsigned char)col;\r
+ inreg.h.bh = 0x00;\r
+ inreg.h.ah = 0x0C;\r
+ for (i = 0; i <= m; i++)\r
+ {\r
+ inreg.x.cx = (unsigned int)(a);\r
+ inreg.x.dx = (unsigned int)(b);\r
+ int86(0x10, &inreg, &outreg);\r
+ s += n;\r
+ if (s >= m)\r
+ {\r
+ s -= m;\r
+ a += d1x;\r
+ b += d1y;\r
+ }\r
+ else\r
+ {\r
+ a += d2x;\r
+ b += d2y;\r
+ }\r
+ }\r
+ }\r
+ \r
+ \r
+\r
+This circle drawing function uses in-line assembler to speed up the\r
+drawing process. It can easily be replaced with inreg and outreg\r
+parameters as in the other functions, or the other functions can be\r
+changed to in-line assembler. Both methods are shown to illustrate\r
+different ways of achieving the same result.\r
+\r
+\r
+ /* Servile Software Library For Clipper */\r
+ \r
+ #include <nandef.h>\r
+ #include <extend.h>\r
+ #include <dos.h>\r
+ \r
+ \r
+ void plot(int x, int y, unsigned char colour)\r
+ {\r
+ asm mov al , colour;\r
+ asm mov bh , 00;\r
+ asm mov cx , x;\r
+ asm mov dx , y;\r
+ asm mov ah , 0Ch;\r
+ asm int 10h;\r
+ }\r
+ \r
+ int getmode()\r
+ {\r
+ /* Returns current video mode and number of columns in ncols\r
+ */\r
+ \r
+ asm mov ah , 0Fh;\r
+ asm int 10h;\r
+ return(_AL);\r
+ }\r
+ \r
+ \r
+ CLIPPER s_circle()\r
+ {\r
+ int x_centre;\r
+ int y_centre;\r
+ int radius;\r
+ int colour;\r
+ int x,y,delta;\r
+ int startx,endx,x1,starty,endy,y1;\r
+ int asp_ratio;\r
+ \r
+ x_centre = _parni(1);\r
+ y_centre = _parni(2);\r
+ radius = _parni(3);\r
+ colour = _parni(4);\r
+ \r
+ \r
+ \r
+ \r
+ if (getmode() == 6)\r
+ asp_ratio = 22;\r
+ else\r
+ asp_ratio = 13;\r
+ \r
+ y = radius;\r
+ delta = 3 - 2 * radius;\r
+ \r
+ for(x = 0; x < y; )\r
+ {\r
+ starty = y * asp_ratio / 10;\r
+ endy = (y + 1) * asp_ratio / 10;\r
+ startx = x * asp_ratio / 10;\r
+ endx = (x + 1) * asp_ratio / 10;\r
+ \r
+ for(x1 = startx; x1 < endx; ++x1)\r
+ {\r
+ plot(x1+x_centre,y+y_centre,colour);\r
+ plot(x1+x_centre,y_centre - y,colour);\r
+ plot(x_centre - x1,y_centre - y,colour);\r
+ plot(x_centre - x1,y + y_centre,colour);\r
+ }\r
+ \r
+ for(y1 = starty; y1 < endy; ++y1)\r
+ {\r
+ plot(y1+x_centre,x+y_centre,colour);\r
+ plot(y1+x_centre,y_centre - x,colour);\r
+ plot(x_centre - y1,y_centre - x,colour);\r
+ plot(x_centre - y1,x + y_centre,colour);\r
+ }\r
+ \r
+ if (delta < 0)\r
+ delta += 4 * x + 6;\r
+ else\r
+ {\r
+ delta += 4*(x-y)+10;\r
+ y--;\r
+ }\r
+ x++;\r
+ }\r
+ \r
+ \r
+ \r
+ \r
+ if(y)\r
+ {\r
+ starty = y * asp_ratio / 10;\r
+ endy = (y + 1) * asp_ratio / 10;\r
+ startx = x * asp_ratio / 10;\r
+ endx = (x + 1) * asp_ratio / 10;\r
+ for(x1 = startx; x1 < endx; ++x1)\r
+ {\r
+ plot(x1+x_centre,y+y_centre,colour);\r
+ plot(x1+x_centre,y_centre - y,colour);\r
+ plot(x_centre - x1,y_centre - y,colour);\r
+ plot(x_centre - x1,y + y_centre,colour);\r
+ }\r
+ \r
+ for(y1 = starty; y1 < endy; ++y1)\r
+ {\r
+ plot(y1+x_centre,x+y_centre,colour);\r
+ plot(y1+x_centre,y_centre - x,colour);\r
+ plot(x_centre - y1,y_centre - x,colour);\r
+ plot(x_centre - y1,x + y_centre,colour);\r
+ }\r
+ }\r
+ }\r
+ \r
+\r
+The Clipper facilities for displaying text on the screen, @....SAY and ?\r
+do not work when the monitor is in graphics mode. You then need the\r
+following function to allow text to be displayed in a graphics mode;\r
+\r
+ \r
+ /* Servile Software Library For Clipper */\r
+ \r
+ #include <nandef.h>\r
+ #include <extend.h>\r
+ #include <dos.h>\r
+ \r
+ int sgetmode(int *ncols)\r
+ {\r
+ /* Returns current video mode and number of columns in ncols\r
+ */\r
+ \r
+ union REGS inreg,outreg;\r
+ \r
+ inreg.h.ah = 0x0F;\r
+ int86(0x10, &inreg, &outreg);\r
+ *ncols = outreg.h.ah;\r
+ return(outreg.h.al);\r
+ }\r
+ \r
+ void at(int row, int col)\r
+ {\r
+ asm mov bh , 0;\r
+ asm mov dh , row;\r
+ asm mov dl , col;\r
+ asm mov ah , 02h;\r
+ asm int 10h;\r
+ }\r
+ \r
+ \r
+ \r
+ \r
+ CLIPPER s_say()\r
+ {\r
+ char *output;\r
+ int p = 0;\r
+ unsigned char page;\r
+ unsigned char text;\r
+ int n;\r
+ int r;\r
+ int c;\r
+ int attribute;\r
+ \r
+ output = _parc(1);\r
+ r = _parni(2);\r
+ c = _parni(3);\r
+ attribute = _parni(4);\r
+ \r
+ asm mov ah , 0Fh;\r
+ asm int 10h;\r
+ asm mov page, bh;\r
+ \r
+ sgetmode(&n);\r
+ \r
+ at(r,c);\r
+ \r
+ while (output[p])\r
+ {\r
+ text = output[p++];\r
+ asm mov bh , page;\r
+ asm mov bl , attribute;\r
+ asm mov cx , 01h;\r
+ asm mov ah , 09h;\r
+ asm mov al , text;\r
+ asm int 10h;\r
+ c++;\r
+ if (c < (n-1))\r
+ at( r, c);\r
+ else\r
+ {\r
+ c = 0;\r
+ at(++r,0);\r
+ }\r
+ }\r
+ }\r
+ \r
+\r
+\r
+\r
+When drawing graphs, it is often required to fill in areas of the graph\r
+in different patterns. This is a graphics function to fill boundered\r
+shapes with a specified hatching pattern providing a means to achieve\r
+more usable graphs;\r
+\r
+\r
+ \r
+ /* Servile Software Library For Clipper */\r
+ \r
+ #include <nandef.h>\r
+ #include <extend.h>\r
+ #include <dos.h>\r
+ \r
+ int pixset(int x, int y)\r
+ {\r
+ /* Returns the colour of the specified pixel */\r
+ \r
+ asm mov cx ,x;\r
+ asm mov dx ,y;\r
+ asm mov ah ,0Dh;\r
+ asm int 10h;\r
+ return(_AL);\r
+ }\r
+ \r
+ CLIPPER s_fill()\r
+ {\r
+ /* Fill a boundered shape using a hatch pattern */\r
+ \r
+ int mode;\r
+ int xa;\r
+ int ya;\r
+ int bn;\r
+ int byn;\r
+ int x;\r
+ int y;\r
+ int col;\r
+ int pattern;\r
+ int maxx;\r
+ int maxy;\r
+ int hatch[10][8] = { 255,255,255,255,255,255,255,255,\r
+ 128,64,32,16,8,4,2,1,\r
+ 1,2,4,8,16,32,64,128,\r
+ 1,2,4,8,8,4,2,1,\r
+ 238,238,238,238,238,238,238,238,\r
+ 170,85,170,85,170,85,170,85,\r
+ 192,96,48,24,12,6,3,1,\r
+ 62,62,62,0,227,227,227,0,\r
+ 129,66,36,24,24,36,66,129,\r
+ 146,36,146,36,146,36,146,36};\r
+ \r
+ /* Patterns for fill, each integer describes a row of dots */\r
+ \r
+ \r
+ \r
+ \r
+ x = _parni(1);\r
+ y = _parni(2);\r
+ col = _parni(3);\r
+ pattern = _parni(4);\r
+ \r
+ mode = getmode();\r
+ \r
+ switch(mode)\r
+ {\r
+ case 0:\r
+ case 1:\r
+ case 2:\r
+ case 3: break;\r
+ case 4:\r
+ case 9:\r
+ case 13:\r
+ case 19:\r
+ case 5: maxx = 320;\r
+ maxy = 200;\r
+ break;\r
+ case 14:\r
+ case 10:\r
+ case 6: maxx = 640;\r
+ maxy = 200;\r
+ break;\r
+ case 7: maxx = 720;\r
+ maxy = 400;\r
+ break;\r
+ case 8: maxx = 160;\r
+ maxy = 200;\r
+ break;\r
+ case 15:\r
+ case 16: maxx = 640;\r
+ maxy = 350;\r
+ break;\r
+ case 17:\r
+ case 18: maxx = 640;\r
+ maxy = 480;\r
+ break;\r
+ \r
+ }\r
+ \r
+ xa = x;\r
+ ya = y; /* Save Origin */\r
+ \r
+ if(pixset(x,y))\r
+ return;\r
+ \r
+ bn = 1;\r
+ byn = 0;\r
+ \r
+ \r
+ \r
+ \r
+ do\r
+ {\r
+ if (hatch[pattern][byn] != 0)\r
+ { /* If blank ignore */\r
+ do\r
+ {\r
+ if ((bn & hatch[pattern][byn]) == bn)\r
+ {\r
+ asm mov al , col;\r
+ asm mov bh , 00;\r
+ asm mov cx , x;\r
+ asm mov dx , y;\r
+ asm mov ah , 0Ch;\r
+ asm int 10h;\r
+ }\r
+ x--;\r
+ bn <<= 1;\r
+ if (bn > 128)\r
+ bn = 1;\r
+ }\r
+ while(!pixset(x,y) && (x > -1));\r
+ \r
+ x = xa + 1;\r
+ bn = 128;\r
+ \r
+ do\r
+ {\r
+ if ((bn & hatch[pattern][byn]) == bn)\r
+ {\r
+ asm mov al , col;\r
+ asm mov bh , 00;\r
+ asm mov cx , x;\r
+ asm mov dx , y;\r
+ asm mov ah , 0Ch;\r
+ asm int 10h;\r
+ }\r
+ x++;\r
+ bn >>=1;\r
+ if (bn <1)\r
+ bn = 128;\r
+ }\r
+ while((!pixset(x,y)) && (x <= maxx));\r
+ }\r
+ x = xa;\r
+ y--;\r
+ bn = 1;\r
+ byn++;\r
+ if (byn > 7)\r
+ byn = 0;\r
+ \r
+ \r
+ \r
+ \r
+ }\r
+ while(!pixset(x,y) && ( y > -1));\r
+ \r
+ /* Now travel downwards */\r
+ \r
+ y = ya + 1;\r
+ \r
+ byn = 7;\r
+ bn = 1;\r
+ do\r
+ {\r
+ /* Travel left */\r
+ if (hatch[pattern][byn] !=0)\r
+ {\r
+ do\r
+ {\r
+ if ((bn & hatch[pattern][byn]) == bn)\r
+ {\r
+ asm mov al , col;\r
+ asm mov bh , 00;\r
+ asm mov cx , x;\r
+ asm mov dx , y;\r
+ asm mov ah , 0Ch;\r
+ asm int 10h;\r
+ }\r
+ x--;\r
+ bn <<= 1;\r
+ if (bn > 128)\r
+ bn = 1;\r
+ }\r
+ while(!pixset(x,y) && (x > -1));\r
+ \r
+ /* Back to x origin */\r
+ x = xa + 1 ;\r
+ bn = 128;\r
+ \r
+ /* Travel right */\r
+ do\r
+ {\r
+ if ((bn & hatch[pattern][byn]) == bn)\r
+ {\r
+ asm mov al , col;\r
+ asm mov bh , 00;\r
+ asm mov cx , x;\r
+ asm mov dx , y;\r
+ asm mov ah , 0Ch;\r
+ asm int 10h;\r
+ }\r
+ x++;\r
+ bn >>=1;\r
+ \r
+ \r
+ \r
+ \r
+ if (bn <1)\r
+ bn = 128;\r
+ }\r
+ while((!pixset(x,y)) && (x <= maxx));\r
+ }\r
+ x = xa;\r
+ bn = 1;\r
+ y++;\r
+ byn--;\r
+ if (byn < 0)\r
+ byn = 7;\r
+ }\r
+ while((!pixset(x,y)) && (y <= maxy));\r
+ }\r
+ \r
+ \r
+ \r
+ \r
+ SPELL - AN EXAMPLE PROGRAM\r
+\r
+It has been said that example programs provide a good way of learning a\r
+new computer language. On that basis the following simple program is\r
+offered as an example of making use of the dynamic memory allocation\r
+provided by DOS.\r
+\r
+This is a spell checker for ASCII (text) documents, written in, and\r
+making use of Borland's Turbo C text graphics facilities for displaying\r
+windows of text.\r
+\r
+\r
+ /* Spell checker for ascii documents */\r
+ /* Compile with -mc (compact memory model) and unsigned characters\r
+ */\r
+ \r
+ \r
+ #include <stdio.h>\r
+ #include <conio.h>\r
+ #include <fcntl.h>\r
+ #include <io.h>\r
+ #include <dos.h>\r
+ #include <string.h>\r
+ #include <alloc.h>\r
+ #include <ctype.h>\r
+ #include <stdlib.h>\r
+ #include <bios.h>\r
+ #include <dir.h>\r
+ #include <stat.h>\r
+ \r
+ #define ON 0x06\r
+ #define OFF 0x20\r
+ #define MAXIMUM 15000\r
+ #define WORDLEN 20\r
+ #define LEFTMARGIN 1\r
+ \r
+ union REGS inreg,outreg;\r
+ \r
+ char *dicname;\r
+ char *dic[MAXIMUM]; /* Array of text lines */\r
+ char word[31];\r
+ char comp[31];\r
+ char fname[160];\r
+ int lastelem;\r
+ char changed;\r
+ char *ignore[100];\r
+ int lastign;\r
+ int insert;\r
+ int n;\r
+ int bp;\r
+ int mp;\r
+ int tp;\r
+ int result;\r
+ \r
+ \r
+ \r
+ \r
+ char *text;\r
+ char *textsav;\r
+ \r
+ void AT(int, int);\r
+ void BANNER(void);\r
+ int COMPARE(void);\r
+ void CORRECT(void);\r
+ void FATAL(char *);\r
+ void FILERR(char *);\r
+ void GETDIC(void);\r
+ void IGNORE(void);\r
+ void INSERT(void);\r
+ int MATCHSTR(char *, char *);\r
+ void SPELL(void);\r
+ void UPDATE(void);\r
+ \r
+ void CURSOR(char status)\r
+ {\r
+ /* Toggle cursor display on and off */\r
+ \r
+ union REGS inreg,outreg;\r
+ \r
+ inreg.h.ah = 1;\r
+ inreg.h.ch = (unsigned char)status;\r
+ inreg.h.cl = 7;\r
+ int86(0x10,&inreg,&outreg);\r
+ }\r
+ \r
+ void DISPLAY(char *text)\r
+ {\r
+ /* Display 'text' expanding tabs and newline characters */\r
+ \r
+ while(*text)\r
+ {\r
+ switch(*text)\r
+ {\r
+ case '\n': cputs("\r\n");\r
+ break;\r
+ case '\t': cputs(" ");\r
+ break;\r
+ default: putch(*text);\r
+ }\r
+ text++;\r
+ }\r
+ }\r
+ \r
+ \r
+ \r
+ \r
+ void GETDIC()\r
+ {\r
+ /* Read dictionary into memory */\r
+ \r
+ FILE *fp;\r
+ char *p;\r
+ int poscr;\r
+ int handle;\r
+ \r
+ window(1,22,80,24);\r
+ clrscr();\r
+ gotoxy(28,2);\r
+ cprintf("Reading Dictionary....");\r
+ \r
+ changed = 0;\r
+ lastelem = 0;\r
+ \r
+ dicname = searchpath("spell.dic");\r
+ handle = open(dicname,O_RDWR);\r
+ if (handle < 0)\r
+ FILERR("spell.dic");\r
+ \r
+ fp = fdopen(handle,"r");\r
+ if (fp == NULL)\r
+ FILERR("spell.dic");\r
+ \r
+ do\r
+ {\r
+ dic[lastelem] = calloc(WORDLEN,1);\r
+ if (dic[lastelem])\r
+ {\r
+ p = fgets(dic[lastelem],79,fp);\r
+ /* Remove carriage return from end of text line */\r
+ poscr = (int)strlen(dic[lastelem]) - 1;\r
+ if (dic[lastelem][poscr] == '\n')\r
+ dic[lastelem][poscr] = 0;\r
+ }\r
+ else\r
+ FATAL("Unable To Allocate Memory");\r
+ }\r
+ while((p != NULL) && (lastelem++ < MAXIMUM));\r
+ \r
+ lastelem--;\r
+ \r
+ fclose(fp);\r
+ }\r
+ \r
+ \r
+ \r
+ \r
+ void UPDATE()\r
+ {\r
+ FILE *fp;\r
+ int n;\r
+ \r
+ if (changed)\r
+ {\r
+ window(1,22,80,24);\r
+ clrscr();\r
+ gotoxy(27,2);\r
+ cprintf("Updating Dictionary....");\r
+ \r
+ fp = fopen(dicname,"w+");\r
+ if (fp == NULL)\r
+ FILERR("spell.dic");\r
+ \r
+ for(n = 0; n <= lastelem; n++)\r
+ fprintf(fp,"%s\n",dic[n]);\r
+ \r
+ fclose(fp);\r
+ }\r
+ }\r
+ \r
+ void IGNORE()\r
+ {\r
+ /* Add a word to the ignore table */\r
+ \r
+ if (lastign < 100)\r
+ {\r
+ ignore[lastign] = calloc(strlen(word) + 1,1);\r
+ if (ignore[lastign])\r
+ strcpy(ignore[lastign++],comp);\r
+ else\r
+ {\r
+ clrscr();\r
+ cprintf("No available memory for new words!\r\nPress\r
+ A key....");\r
+ bioskey(0);\r
+ }\r
+ }\r
+ else\r
+ {\r
+ clrscr();\r
+ cprintf("No available memory for new words!\r\nPress A\r
+ key....");\r
+ bioskey(0);\r
+ }\r
+ }\r
+ \r
+ \r
+ \r
+ \r
+ void FATAL(char *text)\r
+ {\r
+ /* Fatal error drop out */\r
+ \r
+ textcolor(LIGHTGRAY);\r
+ textbackground(BLACK);\r
+ window(1,1,80,25);\r
+ clrscr();\r
+ printf("SERVILE SOFTWARE\n\nSPELL V1.7\nFATAL ERROR:\r
+ %s\n\n",text);\r
+ CURSOR(ON);\r
+ exit(0);\r
+ }\r
+ \r
+ void FILERR(char *fname)\r
+ {\r
+ char text[60];\r
+ \r
+ strcpy(text,"Unable To Access: ");\r
+ strcat(text,fname);\r
+ FATAL(text);\r
+ }\r
+ \r
+ int COMPARE()\r
+ {\r
+ char **p;\r
+ \r
+ /* Check Ignore table */\r
+ for(p = ignore; p <= &ignore[lastign]; p++)\r
+ if (strcmp(comp,*p) == 0)\r
+ return(1);\r
+ \r
+ /* Binary search of dictionary file */\r
+ bp = 0;\r
+ tp = lastelem;\r
+ mp = (tp + bp) / 2;\r
+ \r
+ \r
+ \r
+ \r
+ while((result = strcmp(dic[mp],comp)) != 0)\r
+ {\r
+ if (mp >= tp)\r
+ {\r
+ /* Not found! */\r
+ insert = mp;\r
+ if (result > 0)\r
+ insert--;\r
+ return(0);\r
+ }\r
+ if (result < 0)\r
+ bp = mp + 1;\r
+ else\r
+ tp = mp - 1;\r
+ \r
+ mp = (bp + tp) / 2;\r
+ }\r
+ return(1);\r
+ }\r
+ \r
+ void INSERT()\r
+ {\r
+ int n;\r
+ \r
+ changed = 1;\r
+ lastelem++;\r
+ n = lastelem;\r
+ \r
+ dic[n] = calloc(WORDLEN,1);\r
+ \r
+ if (dic[n] == NULL)\r
+ {\r
+ clrscr();\r
+ cprintf("No available memory for new words!\r\nPress A\r
+ key....");\r
+ bioskey(0);\r
+ free(dic[n]);\r
+ lastelem--;\r
+ return;\r
+ }\r
+ \r
+ while(n > (insert + 1))\r
+ {\r
+ strcpy(dic[n],dic[n-1]);\r
+ n--;\r
+ };\r
+ \r
+ strcpy(dic[insert + 1],comp);\r
+ }\r
+ \r
+ \r
+ \r
+ \r
+ void SPELL()\r
+ {\r
+ FILE *target;\r
+ FILE *source;\r
+ char *p;\r
+ char *x;\r
+ char temp[256];\r
+ char dat1[1250];\r
+ char dat2[1250];\r
+ int c;\r
+ int m;\r
+ int found;\r
+ int curpos;\r
+ int key;\r
+ int row;\r
+ int col;\r
+ int srow;\r
+ int scol;\r
+ \r
+ window(1,1,80,20);\r
+ textcolor(BLACK);\r
+ textbackground(WHITE);\r
+ \r
+ /* Open temporary file to take spell checked copy */\r
+ target = fopen("spell.$$$","w+");\r
+ \r
+ source = fopen(fname,"r");\r
+ \r
+ if (source == NULL)\r
+ FILERR(fname);\r
+ \r
+ lastign = 0;\r
+ \r
+ do\r
+ {\r
+ clrscr();\r
+ \r
+ text = dat1;\r
+ \r
+ p = text;\r
+ \r
+ textsav = dat2;\r
+ \r
+ strcpy(text,"");\r
+ \r
+ /* Display read text */\r
+ row = wherey();\r
+ col = wherex();\r
+ \r
+ \r
+ \r
+ \r
+ for(m = 0; m < 15; m++)\r
+ {\r
+ x = fgets(temp,200,source);\r
+ if (x)\r
+ {\r
+ strcat(text,temp);\r
+ DISPLAY(temp);\r
+ }\r
+ if (wherey() > 18)\r
+ break;\r
+ }\r
+ \r
+ /* return cursor to start position */\r
+ gotoxy(col,row);\r
+ \r
+ do\r
+ {\r
+ memset(word,32,30);\r
+ curpos = 0;\r
+ do\r
+ {\r
+ c = *text++;\r
+ if ((isalpha(c)) || (c == '-') && (curpos != 0))\r
+ word[curpos++] = c;\r
+ }\r
+ while(((isalpha(c)) || (c == '-') && (curpos != 0))\r
+ && (curpos < 30));\r
+ word[curpos] = 0;\r
+ strcpy(comp,word);\r
+ strupr(comp);\r
+ \r
+ if (*comp != 0)\r
+ {\r
+ found = COMPARE();\r
+ if (!found){\r
+ textbackground(RED);\r
+ textcolor(WHITE);\r
+ }\r
+ }\r
+ else\r
+ found = 1;\r
+ \r
+ srow = wherey();\r
+ scol = wherex();\r
+ \r
+ cputs(word);\r
+ textbackground(WHITE);\r
+ textcolor(BLACK);\r
+ \r
+ \r
+ \r
+ \r
+ \r
+ switch(c)\r
+ {\r
+ case '\n': cputs("\r\n");\r
+ break;\r
+ case '\t': cputs(" ");\r
+ break;\r
+ default: putch(c);\r
+ }\r
+ \r
+ row = wherey();\r
+ col = wherex();\r
+ \r
+ if (!found)\r
+ {\r
+ window(1,22,80,24);\r
+ clrscr();\r
+ cputs("Unknown word ");\r
+ textcolor(BLUE);\r
+ cprintf("%s ",word);\r
+ textcolor(BLACK);\r
+ cputs("[A]dd [I]gnore [C]orrect [S]kip");\r
+ do\r
+ {\r
+ key = toupper(getch());\r
+ if (key == 27)\r
+ key = 'Q';\r
+ }\r
+ while(strchr("AICSQ",key) == NULL);\r
+ \r
+ switch(key)\r
+ {\r
+ case 'A':INSERT();\r
+ break;\r
+ \r
+ case 'C':CORRECT();\r
+ break;\r
+ \r
+ case 'I':IGNORE();\r
+ break;\r
+ }\r
+ \r
+ \r
+ \r
+ \r
+ if (key == 'C')\r
+ {\r
+ clrscr();\r
+ gotoxy(1,1);\r
+ strcpy(textsav,--text);\r
+ /* Delete old word */\r
+ text -= strlen(comp);\r
+ *text = 0;\r
+ /* Insert new word */\r
+ strcat(text,word);\r
+ /* Append remainder of text */\r
+ strcat(text,textsav);\r
+ text += strlen(word);\r
+ text++;\r
+ /* Length of text may have changed ! */\r
+ if (strlen(word) < strlen(comp))\r
+ col -= (strlen(comp) - strlen(word));\r
+ window(1,1,80,20);\r
+ clrscr();\r
+ DISPLAY(p);\r
+ }\r
+ else\r
+ {\r
+ clrscr();\r
+ gotoxy(29,2);\r
+ cputs("Checking Spelling....");\r
+ window(1,1,80,20);\r
+ gotoxy(scol,srow);\r
+ cputs(word);\r
+ }\r
+ window(1,1,80,20);\r
+ gotoxy(col,row);\r
+ }\r
+ }\r
+ while((*text) && (key != 'Q'));\r
+ fprintf(target,"%s",p);\r
+ }\r
+ while((x != NULL) && (key != 'Q'));\r
+ \r
+ window(1,22,80,24);\r
+ clrscr();\r
+ gotoxy(27,2);\r
+ cprintf("Writing Updated File....");\r
+ \r
+ \r
+ \r
+ \r
+ do\r
+ {\r
+ p = fgets(temp,200,source);\r
+ if (p)\r
+ fprintf(target,"%s",temp);\r
+ }\r
+ while(p);\r
+ \r
+ fclose(target);\r
+ fclose(source);\r
+ \r
+ /* Now transfer spell.$$$ to fname */\r
+ unlink(fname);\r
+ rename("SPELL.$$$",fname);\r
+ }\r
+ \r
+ void CORRECT()\r
+ {\r
+ /* Locate a good match and return word */\r
+ \r
+ char text[51];\r
+ int m;\r
+ int n;\r
+ int key;\r
+ \r
+ window(1,22,80,24);\r
+ clrscr();\r
+ gotoxy(25,2);\r
+ cprintf("Searching For Alternatives....");\r
+ \r
+ /* Remove any pending key strokes from keyboard buffer */\r
+ while(kbhit())\r
+ getch();\r
+ \r
+ for(n = 0; n <= lastelem; n++)\r
+ {\r
+ if (MATCHSTR(dic[n],comp))\r
+ {\r
+ strcpy(text,dic[n]);\r
+ if (strlen(word) <= strlen(text))\r
+ {\r
+ for (m = 0; m < strlen(word); m++)\r
+ {\r
+ if (isupper(word[m]))\r
+ text[m] = toupper(text[m]);\r
+ else\r
+ text[m] = tolower(text[m]);\r
+ }\r
+ \r
+ \r
+ \r
+ \r
+ for(m = strlen(word); m < strlen(text); m++)\r
+ if (isupper(word[strlen(word)]))\r
+ text[m] = toupper(text[m]);\r
+ else\r
+ text[m] = tolower(text[m]);\r
+ }\r
+ else\r
+ {\r
+ for (m = 0; m < strlen(text); m++)\r
+ {\r
+ if (isupper(word[m]))\r
+ text[m] = toupper(text[m]);\r
+ else\r
+ text[m] = tolower(text[m]);\r
+ }\r
+ }\r
+ clrscr();\r
+ cprintf("Replace ");\r
+ textcolor(BLUE);\r
+ cprintf("%s ",word);\r
+ textcolor(BLACK);\r
+ cprintf("With ");\r
+ textcolor(BLUE);\r
+ cprintf("%s",text);\r
+ textcolor(BLACK);\r
+ cprintf(" Yes No Continue");\r
+ do\r
+ {\r
+ key = toupper(getch());\r
+ }\r
+ while(strchr("YNC",key) == NULL);\r
+ if (key == 'Y')\r
+ {\r
+ strcpy(word,text);\r
+ return;\r
+ }\r
+ clrscr();\r
+ gotoxy(25,2);\r
+ cprintf("Searching For Alternatives....");\r
+ \r
+ /* Remove any pending key strokes from keyboard\r
+ buffer */\r
+ while(kbhit())\r
+ getch();\r
+ \r
+ if (key == 'C')\r
+ return;\r
+ }\r
+ }\r
+ clrscr();\r
+ gotoxy(23,2);\r
+ \r
+ \r
+ \r
+ \r
+ cprintf("NO ALTERNATIVES FOUND! (Press a key)");\r
+ bioskey(0);\r
+ return;\r
+ }\r
+ \r
+ \r
+ int MATCHSTR(char *src, char *tgt)\r
+ {\r
+ /* Compare two words and return non zero if they are similar */\r
+ \r
+ int match;\r
+ int result;\r
+ int strsrc;\r
+ int strtgt;\r
+ int longest;\r
+ \r
+ strtgt = strlen(strupr(tgt));\r
+ strsrc = strlen(strupr(src));\r
+ \r
+ longest = max(strtgt,strsrc);\r
+ \r
+ match = 0;\r
+ \r
+ if(strtgt > strsrc)\r
+ {\r
+ for(; *src ; match += (*src++ == *tgt++))\r
+ ;\r
+ }\r
+ else\r
+ {\r
+ for(; *tgt ; match += (*src++ == *tgt++))\r
+ ;\r
+ }\r
+ \r
+ result = (match * 100 / longest);\r
+ \r
+ /* result holds percentage similarity */\r
+ \r
+ if (result > 50)\r
+ return(1);\r
+ return(0);\r
+ }\r
+ \r
+ void AT(int row, int col)\r
+ {\r
+ /* Position the text cursor */\r
+ inreg.h.bh = 0;\r
+ inreg.h.dh = row;\r
+ inreg.h.dl = col;\r
+ inreg.h.ah = 0x02;\r
+ int86 (0x10, &inreg, &outreg);\r
+ }\r
+ \r
+ void WRTCHA (unsigned char ch, unsigned char attrib, int num)\r
+ {\r
+ /* Display a character num times in colour attrib */\r
+ /* via the BIOS */\r
+ \r
+ inreg.h.al = ch;\r
+ inreg.h.bh = 0;\r
+ inreg.h.bl = attrib;\r
+ inreg.x.cx = num;\r
+ inreg.h.ah = 0x09;\r
+ int86 (0x10, &inreg, &outreg);\r
+ }\r
+ \r
+ void SHADE_BLOCK(int left,int top,int right,int bottom)\r
+ {\r
+ int c;\r
+ \r
+ AT(bottom,right);\r
+ WRTCHA(223,56,1);\r
+ AT(top,right);\r
+ WRTCHA('á',7,1);\r
+ for (c = top+1; c < bottom; c++)\r
+ {\r
+ AT(c,right);\r
+ WRTCHA(' ',7,1);\r
+ }\r
+ AT(bottom,left+1);\r
+ WRTCHA('\9a',7,right-left);\r
+ }\r
+ \r
+ \r
+ \r
+ \r
+ void BOX(int l, int t, int r, int b)\r
+ {\r
+ /* Draws a single line box around a described area */\r
+ \r
+ int n;\r
+ char top[81];\r
+ char bottom[81];\r
+ char tolc[5];\r
+ char torc[5];\r
+ char bolc[5];\r
+ char borc[5];\r
+ char hoor[5];\r
+ \r
+ sprintf(tolc,"%c",218);\r
+ sprintf(bolc,"%c",192);\r
+ sprintf(hoor,"%c",196);\r
+ sprintf(torc,"%c",191);\r
+ sprintf(borc,"%c",217);\r
+ \r
+ strcpy(top,tolc);\r
+ strcpy(bottom,bolc);\r
+ for(n = l + 1; n < r; n++)\r
+ {\r
+ strcat(top,hoor);\r
+ strcat(bottom,hoor);\r
+ }\r
+ strcat(top,torc);\r
+ strcat(bottom,borc);\r
+ \r
+ window(1,1,80,25);\r
+ gotoxy(l,t);\r
+ cputs(top);\r
+ for (n = t + 1; n < b; n++)\r
+ {\r
+ gotoxy(l,n);\r
+ putch(179);\r
+ gotoxy(r,n);\r
+ putch(179);\r
+ }\r
+ gotoxy(l,b);\r
+ cputs(bottom);\r
+ }\r
+ \r
+ \r
+ \r
+ \r
+ void BANNER()\r
+ {\r
+ window (2,2,78,4);\r
+ textcolor(BLACK);\r
+ textbackground(GREEN);\r
+ clrscr();\r
+ SHADE_BLOCK(1,1,78,4);\r
+ BOX(2,2,78,4);\r
+ gotoxy(4,3);\r
+ cprintf("Servile Software SPELL CHECKER V1.7\r
+ (c)1992");\r
+ }\r
+ \r
+ \r
+ void main(int argc, char *argv[])\r
+ {\r
+ char *p;\r
+ char tmp_name[160];\r
+ char tmp_fname[160];\r
+ \r
+ if (argc != 2)\r
+ {\r
+ puts("\nERROR: Usage is SPELL document");\r
+ exit(1);\r
+ }\r
+ else\r
+ strcpy(fname,argv[1]);\r
+ \r
+ CURSOR(OFF);\r
+ \r
+ GETDIC();\r
+ \r
+ window(1,22,80,24);\r
+ clrscr();\r
+ gotoxy(28,2);\r
+ cprintf("Making Backup File....");\r
+ \r
+ strcpy(tmp_fname,argv[1]);\r
+ \r
+ /* Remove extension from tmp_fname */\r
+ p = strchr(tmp_fname,'.');\r
+ if(p)\r
+ *p = 0;\r
+ \r
+ /* Create backup file name using DOS */\r
+ sprintf(tmp_name,"copy %s %s.!s! > NUL",argv[1],tmp_fname);\r
+ \r
+ system(tmp_name);\r
+ \r
+ window(1,1,80,25);\r
+ \r
+ \r
+ \r
+ \r
+ textcolor(WHITE);\r
+ textbackground(BLACK);\r
+ clrscr();\r
+ gotoxy(29,2);\r
+ cprintf("Checking Spelling....");\r
+ \r
+ SPELL();\r
+ \r
+ UPDATE();\r
+ window(1,1,80,25);\r
+ textcolor(LIGHTGRAY);\r
+ textbackground(BLACK);\r
+ clrscr();\r
+ CURSOR(ON);\r
+ }\r
+ \r
+ \r
+ APPENDIX A - USING LINK\r
+\r
+\r
+\r
+General Syntax:\r
+\r
+ LINK [options] obj[,[exe][,[map][,[lib]]]][;]\r
+\r
+`obj' is a list of object files to be linked. Each obj file name must be\r
+separated by a + or a space. If you do not specify an extension, LINK\r
+will assume .OBJ. `exe' allows you to specify a name for the executable\r
+file. If this file name is ommited, LINK will use the first obj file name\r
+and suffix it with .EXE. `map' is an optional map file name. If you\r
+specify the name `NUL', no map file is produced. `lib' is a list of\r
+library files to link. LINK searches each library file and only links in\r
+modules which are referenced.\r
+\r
+\r
+eg:\r
+\r
+ LINK filea+fileb,myfile,NUL;\r
+\r
+Links .obj files `filea.obj' and `fileb.obj' into .exe file `myfile.exe'\r
+with no map file produced. The ; at the end of the line tells LINK that\r
+there are no more parameters.\r
+\r
+\r
+\r
+Using Overlays\r
+\r
+Overlay .obj modules are specified by encasing the .obj name in\r
+parenthesis in the link line.\r
+\r
+eg:\r
+\r
+ LINK filea + (fileb) + (filec),myfile,NUL;\r
+\r
+Will link filea.obj fileb.obj and filec.obj with modules fileb.obj and\r
+filec.obj as overlay code.\r
+\r
+\r
+Overlay modules must use FAR call/return instructions.\r
+\r
+\r
+Linker Options\r
+\r
+All LINK options commence with a forward slash `/'. Options which accept\r
+a number can accept a decimal number or a hex number prefixed 0X. eg:\r
+0X10 is interpreted as 10h, decimal 16.\r
+\r
+\r
+\r
+Pause during Linking (/PAU)\r
+\r
+ Tells LINK to wait before writing the .exe file to disk. LINK\r
+displays a\r
+ message and waits for you to press enter.\r
+\r
+Display Linker Process Information (/I)\r
+\r
+ Tells LINK to display information about the link process.\r
+\r
+Pack Executable File (/E)\r
+\r
+ Tells LINK to remove sequences of repeated bytes and to optimise the\r
+load-time\r
+ relocation table before creating the executable file. Symbolic debug\r
+ information is stripped out of the file.\r
+\r
+List Public Symbols (/M)\r
+\r
+ Tells LINK to create a list of all public symbols defined in the\r
+ object files\r
+ in the MAP file.\r
+\r
+Include Line Numbers In Map File (/LI)\r
+\r
+ Tells LINK to include line numbers and associated addresses of the\r
+source\r
+ program in the MAP file.\r
+\r
+Preserve Case Sensitivity (/NOI)\r
+\r
+ By default LINK treats uppercase and lowercase letters as the same.\r
+This\r
+ option tells LINK that they are different.\r
+\r
+Ignore Default Libraries (/NOD)\r
+\r
+ Tells LINK not to search any library specified in the object files\r
+to resolve\r
+ external references.\r
+\r
+Controlling Stack Size (/ST:n)\r
+\r
+ Specifies the size of the stack segment where 'n' is the number of\r
+bytes.\r
+\r
+Setting Maximum Allocation Space (/CP:n)\r
+\r
+ Tells LINK to write the parameter 'n' into the exe file header. When\r
+the exe\r
+ file is executed by DOS, 'n' 16 byte paragraphs of memory are\r
+reserved. If 'n'\r
+ is less than the minimum required, it will be set to the minimum.\r
+This option\r
+ is ESSENTIAL to free memory from the program. C programs free memory\r
+ automatically on start-up, assembly language programs which want to\r
+use\r
+ dynamic memory allocation must be linked with this option set to a\r
+minimum.\r
+\r
+Setting Maximum Number Of Segments (/SE:n)\r
+\r
+ Tells LINK how many segments a program is allowed to have. The\r
+default is 128\r
+ but 'n' can be any number between 1 and 3072.\r
+\r
+\r
+Setting Overlay Interrupt (/O:n)\r
+\r
+ Tells LINK which interrupt number will be used for passing control\r
+to\r
+ overlays. The default is 63. Valid values for 'n' are 0 through 255.\r
+\r
+Ordering Segments (/DO)\r
+\r
+ Tells LINK to use DOS segment ordering. This option is also enabled\r
+by the\r
+ MASM directive .DOSSEG.\r
+\r
+Controlling Data Loading (/DS)\r
+\r
+ By default LINK loads all data starting at the low end of the data\r
+segment. At\r
+ run time the DS register is set to the lowest possible address to\r
+allow the\r
+ entire data segment to be used. This option tells LINK to load all\r
+data\r
+ starting at the high end of the data segment.\r
+\r
+Control Exe File Loading (/HI)\r
+\r
+ Tells LINK to place the exe file as high as possible in memory.\r
+\r
+Prepare for Debugging (/CO)\r
+\r
+ Tells LINK to include symbolic debug information for use by\r
+codeview.\r
+\r
+Optimising Far Calls (/F)\r
+\r
+ Tells LINK to translate FAR calls to NEAR calls where possible. This\r
+results\r
+ in faster code.\r
+\r
+Disabling Far Call Optimisation (/NOF)\r
+\r
+ Tells LINK not to translate FAR calls. This option is specified by\r
+default.\r
+\r
+Packing Contiguous Segments (/PAC:n)\r
+\r
+ Tells LINK to group together neighbouring code segments, providing\r
+more\r
+ oportunities for FAR call translation. 'n' specifies the maximum\r
+size of a\r
+ segment. By default 'n' is 65530. This option is only relevant to\r
+obj files\r
+ created using FAR calls.\r
+\r
+Disabling Segment Packing (/NOP)\r
+\r
+ Disables segment packing. This option is specified by default.\r
+\r
+\r
+\r
+Using Response Files\r
+\r
+Linker options and file names may be specified in a response file. Each\r
+file list starting on a new line instead of being separated by a comma.\r
+\r
+eg:\r
+\r
+ filea.obj fileb.obj\r
+ myfile.exe\r
+ NUL\r
+ liba.lib libb.lib\r
+ \r
+A response file is specified to LINK by prefixing the response file name\r
+with '@'.\r
+eg:\r
+\r
+ LINK @response\r
+\r
OSDN Git Service
