![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to readme.txt CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools|
Return to readme.txt CVS log | Up to [WindowsNT SDKs] / mstools |
1.1 root 1: LANGREAD.TXT File
2: README file for Microsoft(R) Windows NT(TM) SDK (BETA)
3: Development Tools
4: (C) Copyright Microsoft Corporation, 1992
5:
6: This document contains release notes for the developent tools, C/C++
7: language, and libraries provided with the Microsoft(R) Windows NT(TM)
8: Software Development Kit (BETA). The information in this file is newer,
9: and therefore supersedes any similar information in the printed
10: manuals.
11:
12:
13: ================================< Contents >================================
14:
15:
16: This file has six parts:
17:
18: Part Title
19: ---- -----
20: 1 Additional 32-bit Run-time Functions:
21: _find Functions
22: _seterrormode
23: _loaddll
24: _unloaddll
25: _getdllprocaddr
26: _getdiskfree
27: _sleep
28: _beep
29: _getsystime
30: _setsystime
31: _futime
32: _getdrives
33: _get_osfhandle
34: _open_osfhandle
35:
36: 2 Further note on the _beginthread function
37:
38: 3 Notes on "C Language Reference"
39:
40: 4 Linker Options
41:
42: 5 Building Multithreaded Applications and DLLs
43:
44: 6 The WinDebug Graphical Debugger
45:
46: ===============< Part 1: Additional 32-bit Run-time Functions >=========
47:
48: In addition to the 32-bit C run-time functions listed in the appendix
49: to the Programming Techniques manual, the following routines are
50: specific to 32-bit operating systems:
51:
52: _find Functions
53: ***************
54:
55: Description
56: ===========
57: Find the first matching file, find the next matching file, or release
58: resources from previous find operations.
59:
60: #include <io.h>
61:
62: long _findfirst( char *filespec, struct _finddata_t *fileinfo );
63: int _findnext( long handle, struct _finddata_t *fileinfo );
64: int _findclose( long handle );
65:
66: filespec Target file specification (may include
67: wildcards)
68: handle Search handle returned by a previous call to
69: _findfirst
70: fileinfo File information buffer
71:
72: Remarks
73: =======
74: The _findfirst routine returns information about the first instance of
75: a file whose name matches the filename argument. The filename argument
76: may use wildcards (* and ?). Any wildcard combination supported by the
77: host operating system may be used.
78:
79: Information is returned in a _finddata_t structure, defined in IO.H.
80: The _finddata_t structure contains the following elements:
81:
82: Element Description
83: ------- -----------
84: unsigned attrib File attribute
85:
86: time_t time_create Time of file creation (-1 for FAT file
87: systems)
88:
89: time_t time_access Time of last file access (-1 for FAT file
90: systems)
91:
92: time_t time_write Time of last write to file
93:
94: _fsize_t size Length of file in bytes
95:
96: char name[_MAX_FNAME] Null-terminated name of matched
97: file/directory, without the path
98:
99: _MAX_FNAME is defined in STDLIB.H.
100:
101: Unlike its MS-DOS counterpart, _findfirst does not allow the programmer
102: to specify target attributes (_A_RDONLY, etc.) by which to limit the
103: find operation. This attribute is returned in the attrib field of the
104: _finddata_t structure and can have the following values (defined in
105: IO.H):
106:
107: Constant Meaning Value
108: -------- ------- -----
109: _A_ARCH Archive. Set whenever the file 0x20
110: is changed, and cleared by the
111: MS-DOS BACKUP command.
112:
113: _A_HIDDEN Hidden file. Cannot be found 0x02
114: with the MS-DOS DIR command. Returns
115: information about normal files as well
116: as about files with this attribute.
117:
118: _A_NORMAL Normal. File can be read or written 0x00
119: without restriction.
120:
121: _A_RDONLY Read-only. File cannot be opened for 0x01
122: writing, and a file with the same name
123: cannot be created. Returns information
124: about normal files as well as about
125: files with this attribute.
126:
127: _A_SUBDIR Subdirectory. Returns information about 0x10
128: normal files as well as about files
129: with this attribute.
130:
131: _A_SYSTEM System file. Cannot be found with the 0x04
132: MS-DOS DIR command. Returns information
133: about normal files as well as about
134: files with this attribute.
135:
136: The _findnext routine finds the next name, if any, that matches the
137: filespec argument specified in a prior call to _findfirst. The fileinfo
138: argument should point to a structure initialized by a previous call to
139: _findfirst. The contents of the structure will be altered as described
140: above if a match is found.
141:
142: The _findclose routine closes the specified search handle and releases
143: associated resources.
144:
145: The _find functions allow nested calls. For example, if the file found
146: by a call to _findfirst or _findnext is a subdirectory, a new search
147: can then be initiated with another call to _findfirst or _findnext.
148:
149: Return Value
150: ============
151: If successful, the _findfirst function returns a unique search handle
152: identifying the file or group of files matching the filespec
153: specification which can be used in a subsequent call to _findnext or
154: _findclose. Otherwise, it returns -1 and sets errno to one of the
155: following values:
156:
157: Value Description
158: ----- -----------
159: ENOENT filespec could not be matched
160:
161: EINVAL Illegal filename specification
162:
163: If successful, the _findnext and _findclose functions return 0.
164: Otherwise, they return -1 and set errno to ENOENT, indicating that no
165: more matching files could be found. Although each search operation
166: returns its own unique handle, the same
167:
168: _seterrormode
169: *************
170:
171: Description
172: ===========
173: Controls whether the operating system handles hard errors or allows the
174: calling application to handle them.
175:
176: #include <stdlib.h>
177:
178: void _seterrormode( int mode );
179:
180: mode Error mode
181:
182: Remarks
183: =======
184: The mode argument specifies the error-mode flag. If mode is set to
185: _CRIT_ERROR_PROMPT, The system displays an error message prompt
186: indicating that a hard error has occurred. If mode is set to
187: _CRIT_ERROR_FAIL, the system returns the failed call to the calling
188: application with an error indicating the cause.
189:
190: Return Value
191: ============
192: None.
193:
194: _loaddll
195: ********
196:
197: Description
198: ===========
199: Loads the specified DLL into memory.
200:
201: #include <process.h>
202:
203: int _loaddll( char *dllname );
204:
205: dllname Null-terminated string that names the DLL to
206: be loaded.
207:
208: Remarks
209: =======
210: The _loaddll routine loads the specified Dynamic Link Library. If the
211: dllname argument does not include a fully-qualified path name, the
212: library is searched for according to the search path specified by the
213: host operating system.
214:
215: Return Value
216: ============
217: If successful, the _loaddll routine returns a unique handle to the DLL.
218: Otherwise, it returns 0.
219:
220: _unloaddll
221: **********
222:
223: Description
224: ===========
225: Unloads the specified DLL from the current process.
226:
227: #include <process.h>
228:
229: int _unloaddll( int handle );
230:
231: handle Handle to the loaded DLL, from a previous call
232: to _loaddll.
233:
234: Remarks
235: =======
236: The _unloaddll routine unloads the specified DLL. The DLL�s resources
237: may be freed if no other processes are using it.
238:
239: Return Value
240: ============
241: If successful, the _unloaddll routine returns 0. Otherwise, it returns
242: an operating system error code.
243:
244: _getdllprocaddr
245: ***************
246:
247: Description
248: ===========
249: Returns the address of the specified exported DLL function.
250:
251: #include <process.h>
252:
253: int (* _getdllprocaddr(int handle, char *procname, int ordinal))();
254:
255: handle Handle to DLL module that contains the function
256: (returned by previous call to _loaddll)
257:
258: procname Pointer to null-terminated string containing
259: the function name, or NULL if the function's
260: ordinal value is to be used.
261:
262: ordinal Function's ordinal value, or -1 if the
263: function's name is to be used.
264:
265: Remarks
266: =======
267: The _getdllprocaddr routine retrieves the address of exported
268: functions in DLLs. The function can be specified by name or by ordinal
269: value. The retrieved address can then be called as a function pointer.
270:
271: Return Value
272: ============
273: If successful, the _getdllprocaddr function returns a pointer to the
274: function's entry point. Otherwise, it returns NULL.
275:
276: _getdiskfree
277: ************
278:
279: Description
280: ===========
281: Retrieves information about the current or specified disk drive,
282: including the amount of free space on the disk.
283:
284: include <direct.h>
285: include <dos.h>
286:
287: int _getdiskfree( unsigned drive, struct _diskfree_t diskinfo );
288:
289: drive Specified drive number. This argument is 0 for
290: the current drive, or 1-26 for another
291: specified disk drive.
292:
293: diskinfo Disk information structure
294:
295: Remarks
296: =======
297: The _getdiskfree function retrieves information about the specified
298: disk drive. This information is returned in a _diskfree_t structure,
299: which is defined in DIRECT.H and has the following fields:
300:
301: Element Description
302: ------- -----------
303: unsigned total_clusters Total number of clusters on the disk
304:
305: unsigned avail_clusters Total number of free clusters on the disk
306:
307: unsigned sectors_per_cluster Number of sectors per cluster
308:
309: unsigned bytes_per_sector Number of bytes per sector
310:
311: Return Value
312: ============
313: If successful, the _getdiskfree routine returns 0. Otherwise, it
314: returns an operating system error code.
315:
316: _sleep
317: ******
318:
319: Description
320: ===========
321: Delays execution of the current thread or process for a specified
322: interval.
323:
324: include <stdlib.h>
325:
326: void _sleep( unsigned long duration );
327:
328: duration Specifies the relative time, in milliseconds,
329: that the delay is to occur.
330:
331: Remarks
332: =======
333: In multithreaded operating systems, the _sleep routine causes the
334: current thread to enter a waiting state until the specified interval of
335: time has passed. In single- threaded operating systems, the _sleep
336: routine causes the current process to be delayed. During the delay,
337: other threads or processes can continue execution. With MS-DOS, yield
338: messages are sent periodically which can be handled by Windows or other
339: multitasking operating systems.
340:
341: The duration argument indicates the length of the interval in
342: milliseconds. It can also be one of the following two values:
343:
344: Constant Value
345: -------- -----
346: _SLEEP_MINIMUM Function returns immediately
347:
348: _SLEEP_FOREVER Infinite delay
349:
350: Note that in non-preemptive multitasking operating systems (such as
351: Windows), the duration may be longer than specified, since other
352: processes may not return control at the end of the delay.
353:
354: Return Value
355: ============
356: None.
357:
358: _beep
359: *****
360:
361: Description
362: ===========
363: Generates simple tones on the speaker.
364:
365: #include <stdlib.h>
366:
367: void _beep( unsigned frequency, unsigned duration );
368:
369: frequency Specifies the frequency of the sound in hertz.
370: Audible sounds will be generated by frequencies
371: between 37 (25 hex) and 32767 (07FFF hex).
372:
373: duration Specifies the duration of the sound in
374: milliseconds. See the description of the _sleep
375: function for possible values. Note that in
376: non-preemptive multitasking operating systems
377: (such as Windows), the duration may be longer
378: than specified, since other processes may not
379: return control at the end of the delay.
380:
381: Return Value
382: ============
383: None.
384:
385: _getsystime
386: ***********
387:
388: Description
389: ===========
390: Retrieves the current system time.
391:
392: #include <time.h>
393:
394: unsigned _getsystime( struct tm *tmstruct );
395:
396: tmstruct Pointer to a tm time structure containing
397: information about the system date and time.
398:
399: Remarks
400: =======
401: The _getsystime routine fills in a tm time structure (defined in
402: TIME.H) with information about the system date and time. The routine
403: then returns the fractional portion of the nearest second, in
404: milliseconds.
405:
406: Return Value
407: ============
408: The _getsystime function returns the fractional portion of the nearest
409: second, in milliseconds.
410:
411: _setsystime
412: ***********
413:
414: Description
415: ===========
416: Sets the current system time.
417:
418: #include <time.h>
419:
420: unsigned _setsystime( struct tm *tmstruct, unsigned milliseconds );
421:
422: tmstruct Pointer to a tm time structure containing
423: information about the system date and time
424:
425: milliseconds Fractional portion of nearest second, in
426: milliseconds
427:
428: Remarks
429: =======
430: The _setsystime routine sets the current system time to the specified
431: time.
432:
433: Return Value
434: ============
435: If successful, the _setsystime routine returns 0. Otherwise, it
436: returns an operating system error code.
437:
438: _futime
439: *******
440:
441: Description
442: ===========
443: Sets the modification time on an open file.
444:
445: #include <\sys\utime.h>
446:
447: int _futime( int handle, struct _utimbuf *filetime );
448:
449: handle Handle to open file
450:
451: filetime Pointer to structure containing new
452: modification date
453:
454: Remarks
455: =======
456: The _futime routine sets the modification date on the open file
457: associated with handle. It is identical to the _utime function, except
458: that its argument is the handle to an open file, rather than the name
459: of a file or a path to a file. Although the _utimbuf structure contains
460: a field for access time, only the modification time is set with systems
461: that do not support access time (such as MS- DOS).
462:
463: Return Value
464: ============
465: The _futime function returns 0 if successful. A return value of -1
466: indicates an error; in this case, errno is set to EBADF, indicating an
467: invalid file handle.
468:
469: _getdrives
470: **********
471:
472: Description
473: ===========
474: Returns a bitmask representing the currently available disk drives.
475:
476: #include <direct.h>
477:
478: unsigned long _getdrives ( void );
479:
480: Return Value
481: ============
482: The return value is a bit map with bits set for each currently
483: available disk drive. Bit position 0 (the least-significant bit) is
484: drive A, bit position 1 is drive B, bit position 2 is drive C, and so
485: on.
486:
487: _get_osfhandle
488: **************
489:
490: Description
491: ===========
492: Associates an operating system file handle with an existing C run-time
493: file handle.
494:
495: #include <io.h>
496:
497: long _get_osfhandle( int filehandle );
498:
499: filehandle User file handle
500:
501: Return Value
502: ============
503: If successful, the _get_osfhandle routine returns an operating system
504: file handle, corresponding to filehandle. Otherwise, it returns -1 and
505: sets errno to EBADF, indicating an invalid file handle.
506:
507: _open_osfhandle
508: ***************
509:
510: Description
511: ===========
512: Associates a C run-time file handle with an existing operating system
513: file handle.
514:
515: #include <io.h>
516:
517: int _open_osfhandle( long osfhandle, int flags );
518:
519: osfhandle Operating system file handle
520:
521: flags Type of operations allowed
522:
523: Remarks
524: =======
525: The _open_osfhandle routine allocates a C run-time file handle and
526: sets it to point to the operating system file handle specified by
527: osfhandle. The flags argument is an integer expression formed from one
528: or more of the manifest constants defined in FCNTL.H and listed below.
529: When two or more manifest constants are used to form the flags
530: argument, the constants are combined with the bitwise-OR operator (|).
531:
532: The FCNTL.H file defines the following manifest constants:
533:
534: Constant Meaning
535: -------- -------
536: _O_APPEND Repositions the file pointer to the end of the
537: file before every write operation.
538:
539: _O_RDONLY Opens file for reading only.
540:
541: _O_TEXT Opens file in text (translated) mode.
542:
543: Return Value
544: ============
545: If successful, the _open_osfhandle function returns a C run-time file
546: handle. Otherwise, it returns -1.
547:
548:
549: =============< Part 2: Further note on the _beginthread function >==============
550:
551: Windows NT handles the allocation of the stack when the _beginthread
552: routine is called. Therefore, unlike previous 16-bit versions of the
553: function, the programmer does not need to pass the address of the
554: thread stack to _beginthread. The following description supersedes the
555: information in the appendix to the Programming Techniques manual:
556:
557: unsigned long _beginthread( void( *start_address )( void * ), unsigned
558: stack_size, void *arglist );
559:
560: start_address Starting address of thread
561: stack_size Stack size for thread
562: arglist Argument list for thread
563:
564: =====================< Part 3: C Language Reference >================================
565:
566: The following information is 16- and 32-bit specific information that
567: supersedes the information listed on the corresponding pages of the
568: Microsoft C/C++ C Language Reference manual.
569:
570: Page 5
571: The following keywords are not supported for 32-bit targets: __far,
572: __fortran, __huge, __interrupt, __loadds, __pascal, __saveregs,
573: __segment, __self. Limited 32-bit support is available for __based. The
574: __try, __except and __finally keywords are supported only for 32-bit
575: compilations.
576:
577: Page 13
578: For 32-bit targets, the values of long double are the same as for double.
579:
580: Page 48
581: The 32-bit compiler ignores the register keyword.
582:
583: Page 56
584: The 32-bit compiler ignores the use of the __near keyword.
585:
586: Page 57
587: The 32-bit compiler does not allow the use of the __far keyword.
588:
589: Page 57
590: The 32-bit compiler does not allow the use of the __huge keyword.
591:
592: Page 57
593: For 32-bit targets, __based specifies that a pointer is a 32-bit offset
594: from a 32-bit base.
595:
596: Page 57
597: The __fortran and __pascal keywords are not accepted for 32-bit targets.
598:
599: Page 58
600: The __cdecl calling convention is the default for 32-bit targets.
601:
602: Page 58
603: The 32-bit compiler uses the ECX and EDX registers, but Microsoft
604: reserves the right to change the registers and implementation of the
605: __fastcall calling convention between releases of the compiler.
606:
607: Page 59
608: The __segment keyword is not supported by the 32-bit compiler.
609:
610: Page 70
611: The default packing size is 4 for 32-bit targets.
612:
613: Page 71
614: Bit fields default to size long for the 32-bit compiler.
615:
616: Page 76
617: For 32-bit targets, size_t is unsigned long and the __huge keyword is
618: not required.
619:
620: Page 80
621: The __segment type and the built-in function __segname are not
622: supported by the 32-bit compiler.
623:
624: Page 82
625: Pointers based on pointers are the only form of the __based keyword
626: valid in 32-bit compilations. In such compilations, they are 32-bit
627: displacements from a 32-bit base.
628:
629: Page 84
630: Pointers based on __self are not available for 32-bit targets.
631:
632: Page 95
633: On 32-bit computers, sizeof is unsigned long.
634:
635: Page 100
636: The 32-bit compiler maps long double to type double.
637:
638: Page 121
639: The base operator is not supported for 32-bit targets.
640:
641: Page 169
642: The use of the __near keyword is ignored by the 32-bit compiler.
643:
644: Page 169
645: The use of the __far keyword is illegal for 32-bit targets.
646:
647: Page 170
648: The __fortran and __pascal keywords are illegal for 32-bit targets.
649:
650: Page 175
651: For 16-bit targets, the __interrupt keyword specifies that the function
652: is an interrupt handler. The compiler generates appropriate entry and
653: exit sequences for the handling function, including saving and
654: restoring all registers and executing an IRET instruction to return.
655: Use this form to specify an interrupt function:
656:
657: __interrupt declarator
658:
659: where declarator is the name of the function to be called. An interrupt
660: function must be __far. If you are compiling with the small (default)
661: or compact memory model, you must explicitly declare the function with
662: the __far attribute. An interrupt function cannot be declared as an
663: inline function.
664:
665: Interrupt functions must observe the C calling convention. If you use
666: the /Gc compiler option (forcing the __pascal or __fortran calling
667: convention) or the /Gr compiler option (forcing the __fastcall calling
668: convention), you must explicitly declare your interrupt-handling
669: function with the __cdecl attribute.
670:
671: You cannot declare an interrupt function with both the __interrupt
672: attribute and the __saveregs attribute or the __fastcall calling
673: convention.
674:
675: This example statement declares a function pointer that can be used to
676: point to an interrupt handler:
677:
678: void ( __interrupt __far *oldtime ) ( void );
679:
680: Page 175
681: The __interrupt keyword is illegal in 32-bit targets. See Help for
682: more information on writing interrupt functions.
683:
684: Page 176
685: The __loadds keyword is not supported in 32-bit targets.
686:
687: Page 176
688: The __saveregs keyword is not supported in 32-bit targets.
689:
690: Page 199
691: The following predefined macros are for 16-bit targets only:
692:
693: Identifier Function
694: ---------- --------
695: _DLL Code for run-time library as a dynamic-link
696: library. Defined when /MD is specified. (For
697: 16-bit targets only.)
698:
699: _FAST Fast-compile. Defined when /f is specified
700: (the default). Supersedes _QC, which is still
701: supported but not recommended. Using /Od causes
702: CL to compile your program with /f. The /f
703: option compiles source files without any default
704: optimizations.(For 16-bit targets only.)
705:
706: M_I8086, _M_I8086 Defined for 8086 and 8088 processors (default
707: or /G0 option) (For 16-bit targets only.)
708:
709: M_I286, _M_I286 Defined for 80286 processor (/G1 or /G2 option).
710: (For 16-bit targets only.)
711:
712: M_I86mM, _M_I86mM Always defined. Identifies memory model, where
713: `m' is either T (tiny model), S (small model),
714: C (compact model), M (medium model), L (large
715: model), or H (huge model). Defined by /AT, /AS,
716: /AC, /AM, /AL and /AH, respectively. If huge
717: model is used, both M_I86LM and M_I86HM are
718: defined. Small model is the default. (For
719: 16-bit targets only.)
720:
721: _PCODE Defined for sections of code that are compiled
722: as pcode. Defined when /Oq is enabled. (For
723: 16-bit targets only.)
724:
725: _QC Supported for compatibility with Microsoft C
726: version 6.0. The _FAST macro (or /f) is the
727: default for C8 and is the recommended
728: alternative. (For 16-bit targets only.)
729:
730: _WINDLL Windows protected-mode dynamic-link library is
731: selected with /GD. (For 16-bit targets only.)
732:
733: _WINDOWS Windows protected mode is selected with /GA,
734: /Gn, /GW, /Mq, or /GD. (For 16-bit targets
735: only.)
736:
737: Page 199
738: The following predefined macro is for 32-bit targets only:
739:
740: Identifier Function
741: ---------- --------
742: _M_IX86 Defined as 300 for the 80386 processor (/G3
743: option) and as 400 for the 80486 (/G4) processor.
744:
745: Page 210
746: The following pragmas are for 16-bit targets only:
747:
748: #pragma check_pointer ([[{ on | off }]])
749: ----------------------------------------
750: Instructs the compiler to turn off pointer checking if off is
751: specified, or to turn on pointer checking if on is specified. If turned
752: on, this pragma causes the compiler to check every pointer dereference
753: to make sure the pointer is not a null or out- of-range pointer. The
754: check_pointer pragma is also enabled with the /Zr command-line option,
755: which is only available with the /f option. If you do not specify
756: either on or off, the effect of check_pointer is to reverse the
757: current state of pointer checking. If pointer checking is on, it is
758: turned off and vice versa.
759:
760: This pragma works function by function, not statement by statement. To
761: use this pragma, place a pair of check_pointer pragmas around any
762: function definition that contains pointer usage you want to check.
763:
764: #pragma code_seg ( [[ "segment-name" [[, "segment-class"]] )
765: ------------------------------------------------------------
766: Specifies a segment where functions are to be allocated, allowing the
767: use of based allocation without rewriting code. The code_seg pragma
768: specifies the default segment for functions. This is equivalent to
769: using the /NT (name of TEXT segment) compilation option. It is also
770: equivalent to specifying functions as based. You can, optionally,
771: specify the class as well as the segment name. For example:
772:
773: #pragma code_seg( "MY_CODE", "CODE" )
774:
775: The preceding example causes functions following to be allocated in a
776: segment called MY_CODE. The segment is given a CODE class.
777:
778: Specifying the code_seg pragma with no arguments causes the compiler
779: to allocate all following functions in the default code segment called
780: MY_CODE. The segment is given a CODE class.
781:
782: Note
783: ----
784: There is no way to specify the segment class using based function
785: allocation or the /NT compilation option.
786:
787: Functions allocated using the /NT option or code_seg pragma do not
788: retain any information about their location. However, functions
789: allocated using the based function-allocation syntax retain that
790: information in their external name.
791:
792: #pragma data_seg ( [[ "segment-name"[[, "segment-class"]] )
793: -----------------------------------------------------------
794: Specifies the default segment for data. This is equivalent to using the
795: /ND (name of DATA segment) compilation option. It is also equivalent to
796: specifying objects or pointers as based. You can, optionally, specify
797: the class as well as the segment name. For example:
798:
799: #pragma data_seg( "MY_DATA", "DATA" )
800:
801: The preceding example causes functions following to be allocated in a
802: segment called MY_DATA. The segment is given a DATA class.
803:
804: Specifying the data_seg pragma with no arguments causes the compiler
805: to allocate all following data in the default data segment called
806: MY_DATA. The segment is given a DATA class.
807:
808: Note
809: ----
810: There is no way to specify the segment class using based function
811: allocation or the /ND compilation option.
812:
813: Data allocated using the /ND option or data_seg pragma do not retain
814: any information about their location. However, data allocated using the
815: based syntax retain that information in their external name.
816:
817: If you compile with /Za, the data_seg pragma does not affect the
818: allocation of uninitialized objects. This is true under /Za. However,
819: under /Ze the uninitialized objects also get allocated in the segment
820: specified by the data_seg pragma.
821:
822: #pragma native_caller ( [[ { on | off } ]] )
823: --------------------------------------------
824: Controls the removal of native-code entry points from within source
825: code on a function by function basis. To suppress all native entry
826: points, use the /Gn command-line option. See the Programming Techniques
827: manual for more information about p-code.
828:
829: Page 210
830: #pragma alloc_text( textsegment, function1, ...)
831: ------------------------------------------------
832: Names the segment where the specified function definitions are to
833: reside. This must occur between a function declarator and the function
834: definition for the named functions.
835:
836: The recommended technique for functions in 16-bit targets is to use
837: __based to specify the function location.
838:
839: Use the alloc_text pragma for 32-bit targets since __based is not
840: supported for functions in 32-bit targets.
841:
842: Page 211
843: #pragma intrinsic( function1 [[, function2, ...]] )
844: ---------------------------------------------------
845: Specifies that calls to the specified functions are intrinsic (a
846: library function known to the compiler). Alternatively, you can use the
847: /Oi option to make intrinsic the default for functions that have
848: intrinsic forms. In this case, you can use the function pragma to
849: override /Oi for specified functions. This pragma cannot be used with
850: /f. This pragma takes effect at the first function defined after the
851: pragma is seen.
852:
853: The following functions have intrinsic forms for both the 16-bit and
854: 32-bit compilers:
855:
856: _alloca
857: _disable
858: _enable
859: _inp
860: _inpw
861: _lrotl
862: _lrotr
863: _outp
864: _outpw
865: _rotl
866: _rotr
867: _strset
868: abs
869: acos
870: asin
871: atan
872: atan2
873: ceil
874: cos
875: cosh
876: exp
877: fabs
878: floor
879: fmod
880: labs
881: log
882: log10
883: memcmp
884: memcpy
885: memset
886: pow
887: sin
888: sinh
889: sqrt
890: strcat
891: strcmp
892: strcpy
893: strlen
894: tan
895: tanh
896:
897: The following functions have intrinsic forms for the 16-bit compiler
898: only:
899:
900: _acosl
901: _asinl
902: _atanl
903: _atan2l
904: _ceill
905: _cosl
906: _coshl
907: _expl
908: _floorl
909: _fmodl
910: _logl
911: _log10l
912: _powl
913: _sinl
914: _sinhl
915: _sqrtl
916: _tanl
917: _tanhl
918: _fmemcmp
919: _fmemcpy
920: _fmemset
921: _fstrcat
922: _fstrcmp
923: _fstrcpy
924: _fstrlen
925: _fstrsetu
926:
927: Page 212
928: #pragma optimize( "[[optimization-option-list]]", {off | on } )
929: ---------------------------------------------------------------
930: Specifies optimizations to be performed. Must appear outside a
931: function. The optimization option list may be zero or more of the
932: following: a, c, e, g, l, n, p, q, t, and w. These letters correspond
933: to the /O compilation options. This pragma takes effect at the first
934: function defined after the pragma is seen. The optimization list for
935: 32-bit targets may be zero or more of the following: a, g, n, p, t, and
936: w.
937:
938: Page 212
939: #pragma pack( [[{1 | 2 | 4 | 8 | 16 }]] )
940: -----------------------------------------
941: Specifies packing alignment for structure types. You can use the /Zp
942: option to specify the same packing for all structures in a module. The
943: default is 2 for 16- bit targets and 4 for 32-bit targets.
944:
945: When you give the /Zpn option, where n is 1, 2, 4, 8, or 16, each
946: structure member after the first is stored on n-byte boundaries,
947: depending on the number you choose. If you use the /Zp option without
948: an argument, structure members are packed on one-byte boundaries. No
949: space is allowed between /Zp and its argument. This pragma takes effect
950: at the first function defined after the pragma is seen.
951:
952: On 32-bit targets, the packing can be set at 8 or 16 as well as 1, 2,
953: or 4 as given for 16-bit targets.
954:
955: Page 240
956: For the 32-bit compiler, long double and double are the same.
957:
958: ========================< Part 4: Linker Options >===========================
959:
960: Throughout Programming Techniques (Chapter 1: Building Applications
961: and DLLs) and Tools (Chapter 5: Linker), the NOTMAPPED parameter for
962: the LINK and COFF /DEBUG: option is incorrectly given as "NOMAPPED."
963: The correct syntax for the /DEBUG option is:
964:
965: /DEBUG:[{MAPPED|NOTMAPPED},]{NONE|MINIMAL|PARTIAL|FULL}
966:
967:
968: =============< Part 5: Building Multithreaded Applications and DLLs >============
969:
970:
971: The following information should be added to Programming Techniques
972: Chapter 1: Building Applications and DLLs:
973:
974: Building Multithreaded Programs
975: -------------------------------
976: Building a multithreaded program is only slightly different from
977: building a single-threaded program. Two additional parameters must be
978: specified:
979:
980: 1. Compile with the /D_MT option.
981:
982: 2. Link with LIBCMT.LIB (multithread C run-time library) instead
983: of LIBC.LIB (single-thread C run-time library).
984:
985: Using the C Run-Time DLL
986: ------------------------
987: You can reduce the size of an executable file by using the C run-time
988: DLL instead of statically linking the C run-time libraries to the
989: program. The cost is a small startup overhead to initialize the DLL,
990: and the normal DLL calling overhead.
991:
992: To use the C run-time DLL (CRTDLL.DLL) with either a single- threaded
993: or multithreaded program, link with CRTDLL.LIB. Do not link with either
994: LIBC.LIB or LIBCMT.LIB. The C run-time DLL supports both types of
995: programs.
996:
997:
998: =============< Part 6: The WinDebug Graphical Debugger >=============
999:
1000:
1001: Loading Programs
1002: ----------------
1003:
1004: NOTE: The Program menu is disabled in this version of WinDebug. To
1005: load a program for debugging, you must enter the program
1006: name on the command-line when you start the debugger. For
1007: example:
1008:
1009: WINDBG MYPROG.EXE
1010:
1011: WINDBG C:\BUILDDIR\TESTOR.EXE
1012:
1013:
1014:
1015: Expression Evaluator
1016: --------------------
1017:
1018: The expression evaluator in this release of WinDebug cannot
1019: evaluate a type-cast followed by the following characters: *, &,
1020: +, and |. You can acheive the same meaning by enclosing the casted
1021: expression in parenthesis. For example:
1022:
1023: (char *) &i
1024:
1025: would become
1026:
1027: (char *) (&i)
1028:
1029:
1030:
1031: Command Window
1032: --------------
1033:
1034: Command Window Editing
1035: ----------------------
1036: In the Command window, you can use editing keys similar to those
1037: available from the NT command prompt. The Up- and Down-Arrow keys let
1038: You retrieve previously-entered WinDebug commands. You can edit the
1039: current command line with the Backspace, Delete, Insert, and Left-
1040: and Right-Arrow keys.
1041:
1042:
1043: Process Specifiers
1044: ------------------
1045:
1046: The process-specifier syntax should be as follows:
1047:
1048: Symbol Description
1049: ------ -----------
1050: |. The current process.
1051: |number The process number.
1052: |* All processes.
1053:
1054:
1055: Set Breakpoint (BP)
1056: ------------------
1057:
1058: The Set Breakpoint (BP) options /M and /H are not available in this
1059: release.
1060:
1061: With the /C option, you must enclose the semicolon-separated list
1062: of multiple commands in quotation marks.
1063:
1064:
1065: Enter ANSI Characters (EA)
1066: --------------------------
1067:
1068: If you want to include space (" ") characters, you must enclose
1069: the character string in quotation marks (" or '). If you enclose
1070: the string in double quotation marks, WinDebug will automatically
1071: null-terminate the string. Single quotation marks (') will not add
1072: a null character.
1073:
1074:
1075: Display and Entry Commands (D* and E*)
1076: --------------------------------------
1077:
1078: The display and entry commands (such as DD and EB) will use the
1079: current default radix. You can enter numbers with a different radix
1080: by using the standard C/C++ radix overrides (such as 0x).
1081:
1082:
1083: Find and Search (F and S)
1084: -------------------------
1085:
1086: These commands are unavailable in this release.
1087:
1088:
1089: Display Stack Backtrace (K)
1090: ---------------------------
1091:
1092: This command can be used when handling an exception.
1093:
1094:
1095: Set Exceptions (SX*)
1096: --------------------
1097:
1098: These commands can be followed by /C2<commandlist>, where
1099: <commandlist> is a quote-enclosed, semicolon-separated list of
1100: WinDebug commands to execute after an exception is handled. The
1101: SXE command can also be followed by /C<commandlist>, where
1102: <commandlist> specifies commands to execute before an exception
1103: triggers the debugger.
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.