; ----------------------------------------- The Quincy 4.0 C Interpreter [..C Preprocessor] [..Standard C Header Files] [..C Language Keywords] ; ----------------------------------------- [<<] [>>] Help for Help Getting Into the Help System ---------------------------- There are three ways to get into the Help system: 1. Execute commands on the [..Help] menu 2. Press F1 3. Press the Help command button on a dialog box. Contextual Help (F1) -------------------- The F1 key provides contextual help--help for the part of Quincy that currently has the focus. You can press F1 with the action bar selected, a pull-down menu displayed, a field on a dialog box selected, or while editing source code. The Help Command Button ----------------------- The Help command button on a dialog box displays information about the dialog box and its purpose. The help window that displays when you press F1 with a dialog box field selected relates to the field itself. References to Other Help Windows -------------------------------- A Help window can include a reference to another help window. That reference is highlighted like this: [..Help] You can Tab to the highlighted reference and press the Enter key to select the referenced help window. You can select it with the mouse by double-clicking on it. Definitions ----------- Some references, such as [**function key], are definitions of terms. These definitions are highlighted the same as references. When you select the definition, a window displays in the upper left corner of the desktop. The window contains the definition of the selected term and stays in view until you release the Enter key or the mouse button. Command Buttons on the Help Windows ----------------------------------- Each help window contains these command buttons: Close This button closes the help window and exits from the help system. Back This button changes to the help window that you viewed before the current one. Prev This button changes to the help window that logically preceeds the current one. Next This button changes to the help window that logically follows the current one. Exiting from the Help System ---------------------------- You exit from the Help system by closing the current help window in one of these three ways: 1. Press the Esc key 2. Use the Close command button on the Help window. 5. Double click the window's [..Control Box]. 4. Close the help window from its [..System Menu]. ; ----------------------------------------- [<<] [>>] Extended Help ; ----------------------------------------- [<<] Keys Help Editor/Debugger Keys ---------------- F2 Set/reset breakpoint F3 Next search F6 Open Watch Window F7 Step to next statement F8 Step over function call F9 Run the program F10 or Alt Activate the menubar. Esc Deactivate the Action Bar. Alt+letter Open the associated pull-down menu. Alt+W Open the Watch window and add a watch variable. Alt+F6 Switch to the Watch window. Alt+X Exit the application. Arrow keys Move the cursor one character. Ctrl+arrow Move the cursor one word. Shift+arrow Mark a [..block]. Del Delete character to the right of the cursor. If a [..block] is marked, delete the block. Backspace Delete character to the left of the cursor. If a block is marked, delete the block. PgUp/PgDn Scroll forward and back one page. Ctrl+PgUp/PgDn Scroll horizontally one page. Shift+PgUP/PgDn Mark a [..block]. Home/End Move the cursor to the beginning and end of the line. Ctrl+Home/End Move the cursor to the beginning and end of the document. Shift+Home/End Mark a [..block]. Tab Tab to the next Tab Stop position. From the Watch window --------------------- Alt+F6 Switch to the editor Ins Add a watch variable. Del Delete the selected a watch variable. Up and down arrow Select watch variables [..Clipboard] Keys -------------- Shift+Del [..Cut] the marked text to the Clipboard Ctrl+Ins [..Copy] the marked text to the Clipboard. Shift+Ins [..Paste] the contents of the Clipboard into the document. [..Dialog Box] Keys --------------- Tab Move to the next control. Shift+Tab Move to the previous control. Enter Execute the control. Esc Close the Dialog Box with no action. Tutorial Keys ------------- Alt+C Table of Contents Alt+A Current chapter exercise list Alt+T Display this exercise's help window Alt+N Load the next exercise in the chapter Alt+P Load the previous exercise in the chapter ; ----------------------------------------- ; ; Following are menu command help windows ; ; ----------------------------------------- [<<] [>>] The New Command This command opens a new, untitled source code file. When you use the [..Save] or [..Save as] command on the File menu the file gets a file name. ; ----------------------------------------- [<<] [>>] The Open Command This command opens an existing source code file and loads it. You select the file by filling in the [..File Open] dialog box. ; ----------------------------------------- [<<] [>>] The Save Command This command saves the source code into a disk file. The file name is the same as when the file was loaded. If the program contains an untitled document, this command works just like the [..Save as] command. ; ----------------------------------------- [<<] [>>] The Save As Command This command allows you to save the source code under a new file name. You specify the file's name by filling in the fields on the [..Save as] dialog box. ; ----------------------------------------- [<<] [>>] The Print Command This command prints the source code. ; ----------------------------------------- [<<] [>>] The Print Setup Command This command displays the [..Print Setup] dialog box to allow you to change the printer port for the printout. ; ----------------------------------------- [<<] [>>] The DOS Command This command "shells" out to DOS. You return to Quincy from DOS by executing the DOS exit command at the DOS command line. ; ----------------------------------------- [<<] The Exit Command This command exits to DOS from Quincy. If there are any changes to the code that you have not saved, the program will ask if you want to save the file. ; ----------------------------------------- [<<] [>>] The Cut Command This command is active only when the source code has a [..marked block]. The command deletes the text in the marked block, copies it to the [..Clipboard], and closes up the space in the code that the text previously occupied. ; ----------------------------------------- [<<] [>>] The Copy Command This command is active only when the source code has a [..marked block]. The command copies the text in the marked block to the [..Clipboard], and closes up the space in the code that the text previously occupied. ; ----------------------------------------- [<<] [>>] The Paste Command This command is active only when the [..Clipboard] contains text. The command inserts the text from the Clipboard into the source code at the current cursor location. ; ----------------------------------------- [<<] The Delete Command This command is active only when the current document window has a [..marked block]. The command deletes the block of text, closing the space in the document where the text had been. ; ----------------------------------------- [>>] The Examine Command Use this command to examine and modify memory variables. [<<] [>>] The Output Screen Command Use this command to view the output screen. [<<] [>>] The Function Command Use this command to view all of the functions in the program. [<<] [>>] The Function History Command Use this command to view the function stack from the current one back to main. [<<] [>>] The Watch Window Command Use this command to open the Watch Window [<<] The Switch Window Command Use this command to toggle the focus between the Watch Window and the Editor Window. [<<] [>>] The Run Command Use this command to run the program non-stop. [<<] [>>] The Step Command Use this command to step through the program one source code line at a time. [<<] [>>] The Step Over Command Use this command to step over a function, executing it but not stepping through it. [<<] The Stop Command Use this command to stop the program. [<<] [>>] Add a watch variable Use this command to add a Watch variable to the Watch Window [<<] [>>] Breakpoint on/off Use this command to toggle a breakpoint on/off at the current source code line. [<<] Delete all breakpoints Use this command to delete all breakpoints. [<<] [>>] The Search Command This command opens the [..Search Text] Dialog Box to allow you to search the source code for a matching string. [<<] [>>] The Replace Command This command opens the [..Replace Text] Dialog Box to allow you to search the source code for a matching string and replace it with a different text string. [<<] The Next Command This command continues the most recent [..Search] command beginning at the current cursor position. [<<] [>>] The Tabs Command This command allows you to change the editor's tab settings. [<<] [>>] The Display Command This command displays the [..Display] dialog box to allow you to modify the screen's colors and configuration. [<<] [>>] Help for Help This command describes how to use the Help system. [<<] [>>] Extended Help Extended Help displays information about the application. [<<] [>>] Keys Help This command displays a help window that shows the keystrokes that you use to operate the application. ; ----------------------------------------- [<<] [>>] Help Index The Help index lists the subjects covered in the Help database. You can go directly to a subject from the index by selecting the subject's name. ; ----------------------------------------- [<<] The About Command This command displays a message that tells you about Quincy. ; ----------------------------------------- [>>] The Filename Field On the Open File dialog box: Enter the name of the file you wish to load into the source code editor, or enter the file specification with wild cards to display a list of files in the [..Files] field. On the Save As dialog box: Enter the name with which you wish to save the file. ; ----------------------------------------- [<<] [>>] The Files Field Select a file from the listbox by using one of these methods: Keyboard: Move the selection cursor to the file name and press Enter. Mouse: Double-click the file name. ; ----------------------------------------- [<<] [>>] The Directories Field Use this listbox to select a different subdirectory. Select by using one of these methods: Keyboard: Move the selection cursor to the subdirectory and press Enter. Mouse: Double-click the subdirectory. ; ----------------------------------------- [<<] The Drives Field Use this listbox to select a different drive. Select a drive by using one of these methods: Keyboard: Move the selection cursor to the drive and press Enter. Mouse: Double-click drive. ; ----------------------------------------- [<<] The Printer Port Combo Box Use this combo box to change the printer port. ; ----------------------------------------- [>>] The Search For Text Entry Box Enter the text you want to search for in this text box. Press Enter or the OK command button to begin the search. Press Esc to forget it. Use the [..Match Upper/Lower Case Check Box] to select whether the search will match only if the case matches or if the search is insensitive to the case of the two strings. ; ----------------------------------------- [<<] [>>] The Replace With Text Entry Box Enter the text string that will replace the matching text string in the [..Search For Text Entry Box]. ; ----------------------------------------- [<<] [>>] The Match Upper/Lower Case Check Box Use this checkbox to select whether the search will match only if the case matches or if the search is insensitive to the case of the two strings. ; ----------------------------------------- [<<] The Replace Every Match Check Box Use this checkbox to select whether the search will replace every match in the document. ; ----------------------------------------- [<<] [>>] The Color Option Button Select this option for a color display. ; ----------------------------------------- [<<] [>>] The Mono Option Button Select this option for a monochrome display. ; ----------------------------------------- [<<] [>>] The Reverse Option Button Select this option for a reverse monochrome display. You might find that this option works well with the LCD screens of some laptop computers, particularly when you turn off the [..Texture] check box. ; ----------------------------------------- [<<] [>>] The 25 Lines Option Button Use this button to select a 25-line display. ; ----------------------------------------- [<<] [>>] The 43 Lines Option Button Use this button to select a 43-line display. (EGA and VGA) ; ----------------------------------------- [<<] The 50 Lines Option Button Use this button to select a 50-line display. (VGA only) ; ----------------------------------------- [>>] The File Menu The File menu contains commands that open, save, and print files. The menu also has the command that exits the program. Following are the commands and associated [**function keys]. [..New] [..Open] [..Save] (Alt+S) [..Save as] [..Print] [..Exit] (Alt+X or Alt+F4) [**Inactive] commands display in a dim font. ; ----------------------------------------- [<<] [>>] The Edit Menu The Edit menu contains commands that support text editing. Following are the commands and associated [**function keys]. [..Cut] (Shift+Del) [..Copy] (Ctrl+Ins) [..Paste] (Shift+Ins) [..Delete] (Del) [**Inactive] commands display in a dim font. ; ----------------------------------------- [<<] [>>] The View Menu The View menu commands let you examine memory variables, the output screen, functions, and the Watch Window [..Examine...] [..Output screen] [..Functions] [..Function history] [..Watch window] (F6) [..Switch windows] (ALT_F6) ; ----------------------------------------- [<<] [>>] The Run Menu This menu has commands to run, stop, and step through the program. [..Run] (F9) [..Step] (F7) [..Step over] (F8) [..Stop] ; ----------------------------------------- [<<] [>>] The Debug Menu This menu has commands to let you set watchpoints and breakpoints and clear them all. [..Add a watch variable] (ALT_W) [..Breakpoint on/off] (F2) [..Delete all breakpoints] ; ----------------------------------------- [<<] [>>] The Search Menu The Search menu allows you to search the text for a matching string. The commands are: [..Search] [..Next] (F3) ; ----------------------------------------- [<<] [>>] The Options Menu The Options menu contains commands that let you control the editor's behavior and the video display characteristics. You can save the options in a configuration file. Following are the commands on the Options menu. [..Command Line] [..Display] [..Tabs] [..Memory] ; ----------------------------------------- [<<] The Help Menu The Help menu provides information about the application and the desktop. The selections are: [..Help for help...] [..Extended help...] [..Keys help...] [..Help index...] [..About...] ; ----------------------------------------- ; ; Following are dialog box help windows ; ; ----------------------------------------- The File Open Dialog Box Use this dialog box to open a new source code file. ; ----------------------------------------- The Save As Dialog Box Use this dialog box to save a source code file under a name that you specify. ; ----------------------------------------- The Print Setup Dialog Box Use this dialog box to select a printer port. ; ----------------------------------------- The Search Text Dialog Box Use this dialog box to search the source code file for a matching text string. ; ----------------------------------------- The Replace Text Dialog Box Use this dialog box to search for a matching text string and replace it with a different string value. ; ----------------------------------------- The Display Dialog Box Use this dialog box to change how Quincy uses the video display. ; ----------------------------------------- ; ; Following are keyword reference definition windows ; ; ----------------------------------------- An inactive menu command is one that is, for the moment, not available. The command becomes active at another time when conditions within the program require or permit its use. ; ----------------------------------------- Function keys are key combinations that you can press to execute a menu command without selecting the pull-down menu itself. Not all menu commands have function keys. The most frequently used operations do. ; ----------------------------------------- Marking Text Blocks Marked text blocks affect the operation of these commands: [..Cut] [..Copy] [..Paste] [..Delete] Mark a text block by using one of these operations: Keyboard: --------- Hold the Shift key down and move the keyboard cursor. The block will be marked in reverse video. To clear the marked block, release the Shift key and press any text entry or cursor movement key. Mouse: ------ Click on the first or last character of the block. Hold the mouse button down and move the mouse cursor around. The marked block will follow the mouse cursor. To clear the marked block, release the mouse cursor and click anywhere. ; ----------------------------------------- The Clipboard The Clipboard is a scratchpad where you can save text that can be pasted into a different location in the same or another source code file. You save text with the [..Copy] and [..Cut] commands, and you paste text into from the Clipboard into a document with the [..Paste] command. ; ----------------------------------------- stdio.h [..fclose] [..fflush] [..fgetc] [..fgets] [..fopen] [..fprintf] [..fputc] [..fputs] [..fread] [..fscanf] [..fseek] [..ftell] [..fwrite] [..getc] [..getchar] [..gets] [..printf] [..putc] [..putchar] [..puts] [..remove] [..rename] [..rewind] [..scanf] [..sprintf] [..sscanf] [..tmpfile] [..tmpnam] [..ungetc] fflush() #include <[..stdio.h]> int fflush(FILE *fp) Flushes the data stream. Returns EOF on error, 0 otherwise. printf() #include <[..stdio.h]> int printf(const char*,...); Prints a formatted string to the standard output file. The characters in the string format are copied to the standard output file. If a percent character (%) is encountered in the format string, it is assumed to be a conversion specification. Each conversion specification converts exactly one argument that follows in the list. getchar() #include <[..stdio.h]> int getchar(void); Reads a single character from the standard input device. Returns the character read, or EOF if end of file or a Ctrl-Z is read. If the standard input device is the console keyboard, the character is echoed to the standard output device. putchar() #include <[..stdio.h]> int putchar(int c); Writes the character c to the standard output device. Returns the character written, or a -1 on error. gets() #include <[..stdio.h]> char *gets(char *s); Reads a string of characters from the standard input device. Characters are read from the file until either a newline or end of file is found. Returns the address of buffer, or a zero on end of file. puts() #include <[..stdio.h]> int puts(const char *s); Writes the null-terminated string to the standard output device followed by a newline character. Returns the last character written, or EOF if an error occurs. fopen() #include <[..stdio.h]> FILE *fopen(const char *fname, const char *mode); Opens a disk file named by fname. Mode is one of these: "a" Append. The file is created if it does not exist. "w" Write. If the file exists, it is deleted first. "r" Read. The file must already exist. "r+" Read and write. The file must already exist. "w+" Read and write. If the file exists, it is deleted first. "a+" Read and append. The file is created if it does not exist. You can add "t" to any of the above to use text mode and "b" to use binary mode. In text mode a newline character in memory is converted to a carriage return, line feed when the data is written, and a carriage return line feed in the file is converted to a newline character when the data is read. In binary mode, no translations are made. Returns a FILE pointer to be used in other file I/O functions. Returns NULL if the file cannot be opened. fclose() #include <[..stdio.h]> int fclose(FILE *fp); Closes a disk file previously opened by fopen. Returns zero if successful, or EOF if an error occurs. fgetc() #include <[..stdio.h]> int fgetc(FILE *fp); Reads a character from the file. Returns the character read, or EOF on error or end of file. getc() #include <[..stdio.h]> int getc(FILE *fp); Reads a character from the file. Returns the character read, or EOF on error or end of file. ungetc() #include <[..stdio.h]> int ungetc(int c, FILE *fp); Pushes the character c onto the file so that the next read will return c. Only one character at a time should be pushed between reads if the file is stdin. fputc() #include <[..stdio.h]> int fputc(int c,FILE *fp); Writes the character c to the specified file. Returns the character written, or EOF on error. putc() #include <[..stdio.h]> int putc(int c,FILE *fp); Writes the character c to the specified file. Returns the character written, or EOF on error. fgets() #include <[..stdio.h]> char *fgets(void *buf, int length ,FILE *fp); Reads characters from the file until a newline is encountered, length minus 1 characters have been read, or end of file is found. Returns the address of the buffer, or NULL on end of file or error. fputs() #include <[..stdio.h]> int fputs(const char *s,FILE *fp); Writes the string to the file. Returns the last character written, zero if the string is empty, or EOF on error. fread() #include <[..stdio.h]> int fread(void *buf, int len, int num, FILE *fp); Reads a maximum of num items of len bytes each into memory at the address pointed to by buf from the file. If the file was opened in text read or read/write mode, fread only reads up to and including a newline character. If the file was opened in binary read mode, length times number characters are read if they are available. Returns the number of items read or 0 on EOF. fwrite() #include <[..stdio.h]> int fwrite(const void *buf, int len, int num, FILE *fp); Writes num items of len characters each from the address pointed to by buf to the file. Returns the number of items written. ftell() #include <[..stdio.h]> long ftell(FILE *fp); Returns the current file position. fseek() #include <[..stdio.h]> int fseek(FILE *fp, long offset, int where); Seeks the file to a new character position. The where parameter specifes how the offset parameter is applied to the character position of the file to derive the new character position following the seek. Returns the new position. Offset can be positive or negative. SEEK_SET: offset added to current character position. SEEK_CUR: offset added to last character position. SEEK_END: offset added to first character position. Returns 0 for a successful seek and -1 if an error occurs. rename() #include <[..stdio.h]> int rename(const char *oldname, const char *newname); Renames an unopened file. Oldname points to the old file name. Newname points to the new file name. remove() #include <[..stdio.h]> int remove(const char *name); Removes (deletes) the named file from the file system. tmpfile() #include <[..stdio.h]> FILE *tmpfile(void); Creates a temporary file in "wb+" mode. The file is deleted when the program terminates normally. tmpnam() #include <[..stdio.h]> char *tmpnam(char *fn); Creates a unique, unused file name. Returns a pointer to the unique name. If the argument is not NULL, copies the filename to the address pointed to by the argument. rewind() #include <[..stdio.h]> void rewind(FILE *fp); Seeks the file to its zero character position. scanf() #include <[..stdio.h]> int scanf(const char *fmt,...); Reads characters from the standard input file and converts them using the conversion string format (same as for [..printf]). The arguments must be pointers to the appropriate data types. Since float is the same as double, always use the l modifier (%lf). fprintf() #include <[..stdio.h]> int fprintf(FILE *fp, const char *fmt, ...); Performs format conversion of the arguments, exactly like [..printf], but writes its output to the file instead of to the standard output file. fscanf() #include <[..stdio.h]> int fscanf(FILE *fp, char *fmt, ...); Reads characters from the file and converts them using the conversion string format (same as for [..printf]). The arguments must be pointers to the appropriate data types. Since float is the same as double, always use the l modifier (%lf). sprintf() #include <[..stdio.h]> int sprintf(char *buf, const char *fmt, ...); Performs format conversion of the arguments, exactly like printf, but writes its output to the buffer instead of the standard output file. sscanf() #include <[..stdio.h]> int sscanf(char *buf, const char *fmt, ...); Performs format input conversion of the arguments, exactly like [..scanf] but reads its input from the buffer instead of the standard input file. ctype.h [..isdigit] [..isupper] [..islower] [..isalpha] [..isprint] [..isalnum] [..isspace] [..toupper] [..tolower] isdigit() #include <[..ctype.h]> int isdigit(int c); Returns a true value (1) if c is in the range '0' - '9'. Otherwise returns false (0). isupper() #include <[..ctype.h]> int isupper(int c); Returns a true value (1) if c is 'A' - 'Z'. Otherwise returns false (0). islower() #include <[..ctype.h]> int islower(int c); Returns a true value (1) if c is 'a' - 'z'. Otherwise returns false (0). isalpha() #include <[..ctype.h]> int isalpha(int c); Returns a true value (1) if c is 'A' - 'Z' or 'a' - 'z'. Otherwise returns false (0). isprint() #include <[..ctype.h]> int isprint(int c); Returns a true value (1) if c is a printable character (between 32 and 127). Otherwise returns false (0). isalnum() #include <[..ctype.h]> int isalnum(int c); Returns a true value (1) if c is in one of the character ranges 'a' - 'z', 'A' - 'Z', or '0' - '9'. Otherwise returns false (0). isspace() #include <[..ctype.h]> int isspace(int c); Returns a true value (1) if c is ' ', '\t', '\n', '\v', '\f', or '\r'. Otherwise returns false (0). toupper() #include <[..ctype.h]> int toupper(int c); If c is a lower case alphabetic character, returns its upper case equivalent, otherwise returns c. tolower() #include <[..ctype.h]> int tolower(int c); If c is an upper case alphabetic character, returns its lower case equivalent, otherwise returns c. atoi() #include <[..ctype.h]> int atoi(const char *s); Converts the string containing the ASCII representation of a decimal number to an int. The string consists of optional leading spaces or tabs, an optional plus or minus sign (+ or -) followed by one or more decimal digits. Returns the value of the ASCII number string. atol() #include <[..ctype.h]> long atol(const char *s); Converts the string containing the ASCII representation of a decimal number to a long. The string consists of optional leading spaces or tabs, an optional plus or minus sign (+ or -) followed by one or more decimal digits. Returns the value of the ASCII number string. setjmp.h [..setjmp] [..longjmp] setjmp() #include <[..setjmp.h]> int setjmp(jmp_buf jb); Sets a jmp_buf for use by [..longjmp]. Returns 0. When the program calls longjmp, execution resumes just past the matching setjmp with the non-zero return value passed as the second parameter to longjmp. Use setjmp as the conditional expression in [..if] and [..switch] statements such as: if (setjmp(jb) == 0) { /* first execution */ } else { /* longjmp executed for this jmp_buf */ } longjmp() #include <[..setjmp.h]> void longjmp(jmp_buf jb, int rtn); Jumps to the most recent [..setjmp] test associated with the jmp_buf. The rtn value is the value returned by the setjmp expression. stdlib.h [..abort] [..abs] [..atof] [..atoi] [..atol] [..calloc] [..exit] [..free] [..malloc] [..max] [..min] [..system] abort() #include <[..stdlib.h]> void abort(void); Aborts the program. malloc() #include <[..stdlib.h]> void *malloc(int size); Allocates a block of memory of size bytes from the heap. Returns a pointer to the block or a null pointer if the memory is not available. calloc() #include <[..stdlib.h]> void *calloc(int size, int n); Allocates n blocks of memory of size bytes each from the heap and initializes the blocks to zero. Returns a pointer to the block or a null pointer if the memory is not available. free() #include <[..stdlib.h]> int free(void *bf); Returns the block of memory pointed to by bf that was previously allocated by a call to malloc or calloc. exit() #include <[..stdlib.h]> void exit(int n); The program terminates and returns the parameter to the operating system. it flushes all output streams and closes all open stream files. system() #include <[..stdlib.h]> int system(const char *cmd); Executes the DOS command interpreter (usually the program in COMMAND.COM) and passes it the DOS command found in cmd. min() #include <[..stdlib.h]> #define min(a,b) ((a)<(b)?(a):(b)) Returns the lesser of the two arguments. max() #include <[..stdlib.h]> #define max(a,b) ((a)>(b)?(a):(b)) Returns the greater of the two arguments. string.h [..memset] [..strcmp] [..strncmp] [..*strcpy]<*strcpy> [..*strncpy]<*strncpy> [..strlen] [..*strcat]<*strcat> [..*strncat]<*strncat> memset() #include <[..string.h]> void *memset(void *s,int c,int n) Fills the memory buffer pointed to by s with the character c. Fills n characters. strcmp() #include <[..string.h]> int strcmp(const char *s1, const char *s2); Compares the two strings. The comparison stops when a null terminator is encountered in either of the two strings. Returns a 0 if the two strings are identical, less than zero if s2 is greater than s1, and greater than zero if s1 is greater than s2. strncmp() #include <[..string.h]> int strncmp(const char *s1, const char *s2, int n); Compares the two strings. The comparison stops when a null terminator is encountered in either of the two strings or when n number of bytes are compared. Returns a 0 if the two strings are identical, less than zero if s2 is greater than s1, and greater than zero if s1 is greater than s2. strcpy() #include <[..string.h]> char *strcpy(char *s1, const char *s2); Copies s2 into s1. The copy stops after the null character is copied. strncpy() #include <[..string.h]> char *strncpy(char *s1, const char *s2, int n); Copies s2 into s1. The comparison stops after the null character is copied or after n number of bytes are copied. strlen() #include <[..string.h]> int strlen(const char *s); Returns the length of the null-terminated string. The length does not include the null terminator. strcat() #include <[..string.h]> char *strcat(char *s2, const char *s1); Concatenates the string pointed to by s2 onto the string pointed to by s1. The calling program must assure that s1 has enough space for the concatenation. strncat() #include <[..string.h]> char *strncat(char *s2, const char *s1, int n); Concatenates the string pointed to by s2 onto the string pointed to by s1. Copies at most n bytes or until a null terminator is copied from s2. The calling program must assure that s1 has enough space for the concatenation. dir.h [..findfirst] [..findnext] findfirst() #include <[..dir.h]> int findfirst(const char *path, struct ffblk *ff, int mode); findnext() #include <[..dir.h]> int findnext(struct ffblk *ff); math.h [..acos] [..asin] [..atan] [..ceil] [..cos] [..cosh] [..exp] [..fabs] [..floor] [..sin] [..sinh] [..sqrt] [..tan] [..tanh] [..log] [..log10] [..pow] [..atan2] abs() #include <[..stdlib.h]> int abs(int n); Returns the absolute integer value of the integer argument. acos() #include <[..math.h]> double acos(double x); Returns the arc cosine of x. asin() #include <[..math.h]> double asin(double x); Returns the arc sine of x. atan() #include <[..math.h]> double atan(double x); Returns the arc tangent of x. ceil() #include <[..math.h]> double ceil(double x); Returns the smallest integer greater than or equal to x. The returned value is a double. cos() #include <[..math.h]> double cos(double x); Returns the cosine of x. cosh() #include <[..math.h]> double cosh(double x); Returns the hyperbolic cosine of x. exp() #include <[..math.h]> double exp(double x); Returns the exponential function of x. fabs() #include <[..math.h]> double fabs(double x); Returns the absolute value of x. The value returned is a double. floor() #include <[..math.h]> double floor(double x); Returns the largest integer less than or equal to x. The returned value is a float. sin() #include <[..math.h]> double sin(double x); Returns the sine of x. sinh() #include <[..math.h]> double sinh(double x); Returns the hyperbolic sine of x. sqrt() #include <[..math.h]> double sqrt(double x); Returns the square root of x. tan() #include <[..math.h]> double tan(double x); Returns the tangent of x. tanh() #include <[..math.h]> double tanh(double x); Returns the hyperbolic tangent of x. log() #include <[..math.h]> double log(double x); Returns the natural logarithm of x. log10() #include <[..math.h]> double log10(double x); Returns the base 10 logarithm of x. pow() #include <[..math.h]> double pow(double x, double y); Returns x raised to the yth power. atan2() #include <[..math.h]> double atan2(double x, double y); Returns the arc tangent of y/x. atof() #include <[..math.h]> float atof(const char *s); Converts the string containing the ASCII representation of a decimal number to a float. The string consists of optional leading spaces or tabs, an optional plus or minus sign (+ or -) followed by one or more decimal digits. Returns the value of the ASCII number string. The string passed to atof can contain a decimal point with digits to the right of the decimal point. It can also take the form of a floating point constant. time.h Declares functions and data structures to support time and date operations [..struct tm] [..asctime] [..ctime] [..difftime] [..gmtime] [..localtime] [..mktime] [..time]