HelpScribble project file.
14
YNQ`bsg-113363
0
2




TRUE


1
BrowseButtons()
0
TRUE

FALSE
TRUE
16777215
0
32768
8388736
255
TRUE
TRUE
TRUE
FALSE
1
FALSE
FALSE
Contents
%s Contents
Index
%s Index
Previous
Next
FALSE

62
10
Scribble10
Index
index; welcome; home



Writing



FALSE
22
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;\red0\green128\blue0;\red128\green0\blue0;}
\viewkind4\uc1\pard\ri1480\cf1\b\fs32 Welcome to help for the command line tools\b0 
\par \cf0\f1\fs20 
\par \f0 The following help topics are available:\f1 
\par \f0 
\par \pard\ri1460\tx700\tab\cf2\strike CC386 compiler\cf3\strike0\{linkID=15\}\cf0\tab 
\par \tab\cf2\strike NASM assembler\cf3\strike0\{linkID=20\}
\par \cf0\tab\cf2\strike VALX linker\cf3\strike0\{linkID=30\}\cf0 
\par \tab\cf2\strike XLIB librarian\cf3\strike0\{linkID=40\}
\par \tab I\cf2\strike MPORT librarian\cf3\strike0\{linkID=42\}
\par \tab\cf2\strike MKLIBLST library helper\cf3\strike0\{linkID=45\}\cf0 
\par \tab\cf2\strike XRC resource compiler\cf3\strike0\{linkID=50\}
\par \cf0\tab\cf2\strike CL386 compiler wrapper\cf3\strike0\{linkID=60\}\cf0 
\par \tab\cf2\strike IMAKE make utility\cf3\strike0\{linkID=70\}\cf0 
\par \tab\cf2\strike ITOUCH touch utility\cf3\strike0\{linkID=80\}\cf0 
\par \tab\cf2\strike GREP search utility\cf3\strike0\{linkID=90\}\cf0 
\par \cf1\b\fs32 
\par For licensing information, see the following:
\par \b0\fs20\tab 
\par \tab\cf2\strike GPL Copyright Information\cf3\strike0\{linkID=12\}\cf2\strike 
\par }
12
Scribble12
Copyright
gnu; copyright; copyleft



Writing



FALSE
344
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}}
{\colortbl ;\red0\green0\blue255;\red0\green0\blue0;}
\viewkind4\uc1\pard\cf1\fs20  \cf2                    GNU GENERAL PUBLIC LICENSE
\par                        Version 2, June 1991
\par 
\par  Copyright (C) 1989, 1991 Free Software Foundation, Inc.
\par      59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
\par  Everyone is permitted to copy and distribute verbatim copies
\par  of this license document, but changing it is not allowed.
\par 
\par                             Preamble
\par 
\par   The licenses for most software are designed to take away your
\par freedom to share and change it.  By contrast, the GNU General Public
\par License is intended to guarantee your freedom to share and change free
\par software--to make sure the software is free for all its users.  This
\par General Public License applies to most of the Free Software
\par Foundation's software and to any other program whose authors commit to
\par using it.  (Some other Free Software Foundation software is covered by
\par the GNU Library General Public License instead.)  You can apply it to
\par your programs, too.
\par 
\par   When we speak of free software, we are referring to freedom, not
\par price.  Our General Public Licenses are designed to make sure that you
\par have the freedom to distribute copies of free software (and charge for
\par this service if you wish), that you receive source code or can get it
\par if you want it, that you can change the software or use pieces of it
\par in new free programs; and that you know you can do these things.
\par 
\par   To protect your rights, we need to make restrictions that forbid
\par anyone to deny you these rights or to ask you to surrender the rights.
\par These restrictions translate to certain responsibilities for you if you
\par distribute copies of the software, or if you modify it.
\par 
\par   For example, if you distribute copies of such a program, whether
\par gratis or for a fee, you must give the recipients all the rights that
\par you have.  You must make sure that they, too, receive or can get the
\par source code.  And you must show them these terms so they know their
\par rights.
\par 
\par   We protect your rights with two steps: (1) copyright the software, and
\par (2) offer you this license which gives you legal permission to copy,
\par distribute and/or modify the software.
\par 
\par   Also, for each author's protection and ours, we want to make certain
\par that everyone understands that there is no warranty for this free
\par software.  If the software is modified by someone else and passed on, we
\par want its recipients to know that what they have is not the original, so
\par that any problems introduced by others will not reflect on the original
\par authors' reputations.
\par 
\par   Finally, any free program is threatened constantly by software
\par patents.  We wish to avoid the danger that redistributors of a free
\par program will individually obtain patent licenses, in effect making the
\par program proprietary.  To prevent this, we have made it clear that any
\par patent must be licensed for everyone's free use or not licensed at all.
\par 
\par   The precise terms and conditions for copying, distribution and
\par modification follow.
\par \page 
\par                     GNU GENERAL PUBLIC LICENSE
\par    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
\par 
\par   0. This License applies to any program or other work which contains
\par a notice placed by the copyright holder saying it may be distributed
\par under the terms of this General Public License.  The "Program", below,
\par refers to any such program or work, and a "work based on the Program"
\par means either the Program or any derivative work under copyright law:
\par that is to say, a work containing the Program or a portion of it,
\par either verbatim or with modifications and/or translated into another
\par language.  (Hereinafter, translation is included without limitation in
\par the term "modification".)  Each licensee is addressed as "you".
\par 
\par Activities other than copying, distribution and modification are not
\par covered by this License; they are outside its scope.  The act of
\par running the Program is not restricted, and the output from the Program
\par is covered only if its contents constitute a work based on the
\par Program (independent of having been made by running the Program).
\par Whether that is true depends on what the Program does.
\par 
\par   1. You may copy and distribute verbatim copies of the Program's
\par source code as you receive it, in any medium, provided that you
\par conspicuously and appropriately publish on each copy an appropriate
\par copyright notice and disclaimer of warranty; keep intact all the
\par notices that refer to this License and to the absence of any warranty;
\par and give any other recipients of the Program a copy of this License
\par along with the Program.
\par 
\par You may charge a fee for the physical act of transferring a copy, and
\par you may at your option offer warranty protection in exchange for a fee.
\par 
\par   2. You may modify your copy or copies of the Program or any portion
\par of it, thus forming a work based on the Program, and copy and
\par distribute such modifications or work under the terms of Section 1
\par above, provided that you also meet all of these conditions:
\par 
\par     a) You must cause the modified files to carry prominent notices
\par     stating that you changed the files and the date of any change.
\par 
\par     b) You must cause any work that you distribute or publish, that in
\par     whole or in part contains or is derived from the Program or any
\par     part thereof, to be licensed as a whole at no charge to all third
\par     parties under the terms of this License.
\par 
\par     c) If the modified program normally reads commands interactively
\par     when run, you must cause it, when started running for such
\par     interactive use in the most ordinary way, to print or display an
\par     announcement including an appropriate copyright notice and a
\par     notice that there is no warranty (or else, saying that you provide
\par     a warranty) and that users may redistribute the program under
\par     these conditions, and telling the user how to view a copy of this
\par     License.  (Exception: if the Program itself is interactive but
\par     does not normally print such an announcement, your work based on
\par     the Program is not required to print an announcement.)
\par \page 
\par These requirements apply to the modified work as a whole.  If
\par identifiable sections of that work are not derived from the Program,
\par and can be reasonably considered independent and separate works in
\par themselves, then this License, and its terms, do not apply to those
\par sections when you distribute them as separate works.  But when you
\par distribute the same sections as part of a whole which is a work based
\par on the Program, the distribution of the whole must be on the terms of
\par this License, whose permissions for other licensees extend to the
\par entire whole, and thus to each and every part regardless of who wrote it.
\par 
\par Thus, it is not the intent of this section to claim rights or contest
\par your rights to work written entirely by you; rather, the intent is to
\par exercise the right to control the distribution of derivative or
\par collective works based on the Program.
\par 
\par In addition, mere aggregation of another work not based on the Program
\par with the Program (or with a work based on the Program) on a volume of
\par a storage or distribution medium does not bring the other work under
\par the scope of this License.
\par 
\par   3. You may copy and distribute the Program (or a work based on it,
\par under Section 2) in object code or executable form under the terms of
\par Sections 1 and 2 above provided that you also do one of the following:
\par 
\par     a) Accompany it with the complete corresponding machine-readable
\par     source code, which must be distributed under the terms of Sections
\par     1 and 2 above on a medium customarily used for software interchange; or,
\par 
\par     b) Accompany it with a written offer, valid for at least three
\par     years, to give any third party, for a charge no more than your
\par     cost of physically performing source distribution, a complete
\par     machine-readable copy of the corresponding source code, to be
\par     distributed under the terms of Sections 1 and 2 above on a medium
\par     customarily used for software interchange; or,
\par 
\par     c) Accompany it with the information you received as to the offer
\par     to distribute corresponding source code.  (This alternative is
\par     allowed only for noncommercial distribution and only if you
\par     received the program in object code or executable form with such
\par     an offer, in accord with Subsection b above.)
\par 
\par The source code for a work means the preferred form of the work for
\par making modifications to it.  For an executable work, complete source
\par code means all the source code for all modules it contains, plus any
\par associated interface definition files, plus the scripts used to
\par control compilation and installation of the executable.  However, as a
\par special exception, the source code distributed need not include
\par anything that is normally distributed (in either source or binary
\par form) with the major components (compiler, kernel, and so on) of the
\par operating system on which the executable runs, unless that component
\par itself accompanies the executable.
\par 
\par If distribution of executable or object code is made by offering
\par access to copy from a designated place, then offering equivalent
\par access to copy the source code from the same place counts as
\par distribution of the source code, even though third parties are not
\par compelled to copy the source along with the object code.
\par \page 
\par   4. You may not copy, modify, sublicense, or distribute the Program
\par except as expressly provided under this License.  Any attempt
\par otherwise to copy, modify, sublicense or distribute the Program is
\par void, and will automatically terminate your rights under this License.
\par However, parties who have received copies, or rights, from you under
\par this License will not have their licenses terminated so long as such
\par parties remain in full compliance.
\par 
\par   5. You are not required to accept this License, since you have not
\par signed it.  However, nothing else grants you permission to modify or
\par distribute the Program or its derivative works.  These actions are
\par prohibited by law if you do not accept this License.  Therefore, by
\par modifying or distributing the Program (or any work based on the
\par Program), you indicate your acceptance of this License to do so, and
\par all its terms and conditions for copying, distributing or modifying
\par the Program or works based on it.
\par 
\par   6. Each time you redistribute the Program (or any work based on the
\par Program), the recipient automatically receives a license from the
\par original licensor to copy, distribute or modify the Program subject to
\par these terms and conditions.  You may not impose any further
\par restrictions on the recipients' exercise of the rights granted herein.
\par You are not responsible for enforcing compliance by third parties to
\par this License.
\par 
\par   7. If, as a consequence of a court judgment or allegation of patent
\par infringement or for any other reason (not limited to patent issues),
\par conditions are imposed on you (whether by court order, agreement or
\par otherwise) that contradict the conditions of this License, they do not
\par excuse you from the conditions of this License.  If you cannot
\par distribute so as to satisfy simultaneously your obligations under this
\par License and any other pertinent obligations, then as a consequence you
\par may not distribute the Program at all.  For example, if a patent
\par license would not permit royalty-free redistribution of the Program by
\par all those who receive copies directly or indirectly through you, then
\par the only way you could satisfy both it and this License would be to
\par refrain entirely from distribution of the Program.
\par 
\par If any portion of this section is held invalid or unenforceable under
\par any particular circumstance, the balance of the section is intended to
\par apply and the section as a whole is intended to apply in other
\par circumstances.
\par 
\par It is not the purpose of this section to induce you to infringe any
\par patents or other property right claims or to contest validity of any
\par such claims; this section has the sole purpose of protecting the
\par integrity of the free software distribution system, which is
\par implemented by public license practices.  Many people have made
\par generous contributions to the wide range of software distributed
\par through that system in reliance on consistent application of that
\par system; it is up to the author/donor to decide if he or she is willing
\par to distribute software through any other system and a licensee cannot
\par impose that choice.
\par 
\par This section is intended to make thoroughly clear what is believed to
\par be a consequence of the rest of this License.
\par \page 
\par   8. If the distribution and/or use of the Program is restricted in
\par certain countries either by patents or by copyrighted interfaces, the
\par original copyright holder who places the Program under this License
\par may add an explicit geographical distribution limitation excluding
\par those countries, so that distribution is permitted only in or among
\par countries not thus excluded.  In such case, this License incorporates
\par the limitation as if written in the body of this License.
\par 
\par   9. The Free Software Foundation may publish revised and/or new versions
\par of the General Public License from time to time.  Such new versions will
\par be similar in spirit to the present version, but may differ in detail to
\par address new problems or concerns.
\par 
\par Each version is given a distinguishing version number.  If the Program
\par specifies a version number of this License which applies to it and "any
\par later version", you have the option of following the terms and conditions
\par either of that version or of any later version published by the Free
\par Software Foundation.  If the Program does not specify a version number of
\par this License, you may choose any version ever published by the Free Software
\par Foundation.
\par 
\par   10. If you wish to incorporate parts of the Program into other free
\par programs whose distribution conditions are different, write to the author
\par to ask for permission.  For software which is copyrighted by the Free
\par Software Foundation, write to the Free Software Foundation; we sometimes
\par make exceptions for this.  Our decision will be guided by the two goals
\par of preserving the free status of all derivatives of our free software and
\par of promoting the sharing and reuse of software generally.
\par 
\par                             NO WARRANTY
\par 
\par   11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
\par FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
\par OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
\par PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
\par OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
\par MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
\par TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
\par PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
\par REPAIR OR CORRECTION.
\par 
\par   12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
\par WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
\par REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
\par INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
\par OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
\par TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
\par YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
\par PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
\par POSSIBILITY OF SUCH DAMAGES.
\par 
\par                      END OF TERMS AND CONDITIONS
\par \page 
\par             How to Apply These Terms to Your New Programs
\par 
\par   If you develop a new program, and you want it to be of the greatest
\par possible use to the public, the best way to achieve this is to make it
\par free software which everyone can redistribute and change under these terms.
\par 
\par   To do so, attach the following notices to the program.  It is safest
\par to attach them to the start of each source file to most effectively
\par convey the exclusion of warranty; and each file should have at least
\par the "copyright" line and a pointer to where the full notice is found.
\par 
\par     <one line to give the program's name and a brief idea of what it does.>
\par     Copyright (C) 19yy  <name of author>
\par 
\par     This program is free software; you can redistribute it and/or modify
\par     it under the terms of the GNU General Public License as published by
\par     the Free Software Foundation; either version 2 of the License, or
\par     (at your option) any later version.
\par 
\par     This program is distributed in the hope that it will be useful,
\par     but WITHOUT ANY WARRANTY; without even the implied warranty of
\par     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
\par     GNU General Public License for more details.
\par 
\par     You should have received a copy of the GNU General Public License
\par     along with this program; if not, write to the Free Software
\par     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
\par 
\par 
\par Also add information on how to contact you by electronic and paper mail.
\par 
\par If the program is interactive, make it output a short notice like this
\par when it starts in an interactive mode:
\par 
\par     Gnomovision version 69, Copyright (C) 19yy name of author
\par     Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
\par     This is free software, and you are welcome to redistribute it
\par     under certain conditions; type `show c' for details.
\par 
\par The hypothetical commands `show w' and `show c' should show the appropriate
\par parts of the General Public License.  Of course, the commands you use may
\par be called something other than `show w' and `show c'; they could even be
\par mouse-clicks or menu items--whatever suits your program.
\par 
\par You should also get your employer (if you work as a programmer) or your
\par school, if any, to sign a "copyright disclaimer" for the program, if
\par necessary.  Here is a sample; alter the names:
\par 
\par   Yoyodyne, Inc., hereby disclaims all copyright interest in the program
\par   `Gnomovision' (which makes passes at compilers) written by James Hacker.
\par 
\par   <signature of Ty Coon>, 1 April 1989
\par   Ty Coon, President of Vice
\par 
\par This General Public License does not permit incorporating your program into
\par proprietary programs.  If your program is a subroutine library, you may
\par consider it more useful to permit linking proprietary applications with the
\par library.  If this is what you want to do, use the GNU Library General
\par Public License instead of this License.
\par \cf1\b\fs32 
\par }
15
Scribble15
CC386 compiler
cc386; compiler



Writing



FALSE
15
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;\red0\green128\blue0;\red128\green0\blue0;}
\viewkind4\uc1\pard\ri1460\cf1\b\fs32 CC386 Compiler
\par 
\par \cf0\b0\fs20 The CC386 C compiler has support for ANSI C, and supports a small subset of C++ functionality.
\par Some of the newer features of ANSI-99 still are not supported however.  This is a fully functional compiler, and will even generate Debug information; however the debug information is a variation of the earlier Microsoft CodeView format.  The included IDE is the only debugger capable of understanding it.
\par 
\par The following help topics are available:
\par \pard\ri1440\tx720 
\par \tab\cf2\strike Command Line Syntax\cf3\strike0\{linkID=110\}\cf0 
\par \tab\cf2\strike Extended Keywords\cf3\strike0\{linkID=120\}
\par \tab\cf2\strike #pragma directives\cf3\strike0\{linkID=130\}\cf0\f1 
\par 
\par \cf1\b\f0\fs32 
\par }
20
Scribble20
NASM assembler
nasm; assembler



Writing



FALSE
10
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;\red0\green128\blue0;\red128\green0\blue0;}
\viewkind4\uc1\pard\ri1480\cf1\b\fs32 NASM Assembler
\par 
\par \cf0\b0\fs20 The NASM (Net wide) assembler is an up-to-date assembler for current x86 processors; sources are available on the net.  The version included in this package is relatively recent, and was compiled with no changes other than to add a resource section.  Refer to the separate NASM documentation if you need to code assembly language for this assembler.\f1 
\par 
\par \f0 The following help topics are available:
\par 
\par \pard\ri1460\tx720\tab\cf2\strike Command Line Syntax\cf3\strike0\{linkID=140\}\cf0\f1 
\par }
30
Scribble30
VALX Linker
valx; linker



Writing



FALSE
10
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil Arial;}{\f1\fnil\fcharset0 Arial;}}
{\colortbl ;\red0\green0\blue255;\red0\green128\blue0;\red128\green0\blue0;}
\viewkind4\uc1\pard\ri1460\cf1\b\f0\fs32 VALX Linker\cf0\b0\fs20 
\par 
\par \f1 The VALX linker is an extension of a public-domain linker called VAL; the extensions include support for 32 bit code and Windows PE files.  Note that this linker uses the legacy DOS OMF file format and is not compatible with files and libraries distributed by Microsoft.  The purpose of VALX is to take compiled files and turn them into an executable program.  VALX will also work with 16 bit DOS programs, however this usage is deprecated for purposes of the CC386 compiler.
\par 
\par The following help topics are available:
\par \pard\ri1440 
\par \tab\cf2\strike Command Line Syntax\cf3\strike0\{linkID=150\}\cf0\f0 
\par }
40
Scribble40
XLIB Librarian
xlib ; librarian



Writing



FALSE
10
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil Arial;}{\f1\fnil\fcharset0 Arial;}}
{\colortbl ;\red0\green0\blue255;\red0\green128\blue0;\red128\green0\blue0;}
\viewkind4\uc1\pard\ri1460\cf1\b\f0\fs32 XLIB Librarian\cf0\b0\fs20 
\par 
\par \f1 The Xlib librarian is a simple librarian patterned after the old DOS librarians.  Its purpose is to gather a group of compiled files together into a logical grouping called a library.
\par 
\par The following help topics are available:
\par 
\par \pard\ri1440\tx700\tab\cf2\strike Command Line Syntax\cf3\strike0\{linkID=160\}\cf0\f0 
\par }
42
Scribble42
IMPORT Librarian
import; librarian



Writing



FALSE
10
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;\red0\green128\blue0;\red128\green0\blue0;}
\viewkind4\uc1\pard\ri1480\cf1\b\fs32 IMPORT Librarian\cf0\b0\f1\fs20 
\par 
\par \f0 The IMPORT program is used to make OMF style import libraries from a DLL's export section.  It can  also make simple .DEF files based on the contents of the DLL.
\par 
\par The following help topics are available:
\par 
\par \pard\ri1460\tx700\tab\cf2\strike Command Line Syntax\cf3\strike0\{linkID=172\}\cf0\f1 
\par }
45
Scribble45
MKLIBLST Library Utility
mkliblst



Writing



FALSE
12
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;\red0\green128\blue0;\red128\green0\blue0;}
\viewkind4\uc1\pard\ri1480\cf1\b\fs32 MKLIBLST Library Utility\cf0\b0\f1\fs20 
\par 
\par \f0 MKLIBLST is used to create or append to a response file used in creating a library.  The idea is that if there are a bunch of source files scattered across a disk, you compile them and gather their objects into one place, possibly creating the definition file as you go along.  Then when the build succeeds XLIB can use the definition file to determine what files to import into the library.
\par 
\par The following help topics are available:
\par \pard\ri1460\tx720 
\par \tab\cf2\strike Command Line Syntax\cf3\strike0\{linkID=170\}\cf0 
\par \tab\cf2\strike Using the definition file\cf3\strike0\{linkID=175\}\cf0 
\par \pard\ri1480\tab\f1 
\par }
50
Scribble50
XRC Resource compiler
xrc; resource; compiler



Writing



FALSE
12
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil Arial;}{\f1\fnil\fcharset0 Arial;}}
{\colortbl ;\red0\green0\blue255;\red0\green128\blue0;\red128\green0\blue0;}
\viewkind4\uc1\pard\ri1460\cf1\b\f0\fs32 XRC Resource compiler\cf0\b0\fs20 
\par 
\par \f1 The XRC compiler takes an .RC file and makes a .RES file out of it.  The .RES file gets linked to the image with VALX and creates predefined resources used by the executable.
\par 
\par The syntax of a .RC file is beyond the scope of this documentation; refer to external documentation.
\par 
\par The following help topics are available:
\par 
\par \pard\ri1440\tx700\tab\cf2\strike Command Line Syntax\cf3\strike0\{linkID=180\}\cf0\f0 
\par }
60
Scribble60
CL386
cl386; command line; shell



Writing



FALSE
11
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;\red0\green128\blue0;\red128\green0\blue0;}
\viewkind4\uc1\pard\ri1460\cf1\b\fs32 CL386 Compiler shell\cf0\b0\f1\fs20 
\par 
\par \f0 The CL386 compiler shell combines the various stages of processing required to change source files into an executable program.
\par 
\par The following help topics are available:
\par \tab 
\par \pard\ri1440\tx680\tab\cf2\strike Command Line Syntax\cf3\strike0\{linkID=190\}\cf0\f1 
\par \cf1\b\fs32 
\par }
70
Scribble70
IMAKE make utility
imake; make; makefile



Writing



FALSE
13
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;\red0\green128\blue0;\red128\green0\blue0;}
\viewkind4\uc1\pard\ri1480\cf1\b\fs32 IMAKE make utility\cf0\b0\f1\fs20 
\par 
\par \f0 The IMAKE utility is a generic make program styled after borland make.  It takes a MAKEFILE and uses it along with file time stamps to determine what aspects of the program have to be recompiled/rebuilt to create the executable.  Note that this is a very primitive type of make; it fully supports macro expansion, ifdef and so forth, and the basics of explicit and implicit rules.  Advanced features found in other make programs are however not present.
\par 
\par The syntax of a MAKEFILE is beyond the scope of this document.
\par 
\par The following help topics are available:
\par 
\par \pard\ri1460\tx700\tab\cf2\strike Command Line Syntax\cf3\strike0\{linkID=200\}\cf0\f1 
\par \pard\ri1480\cf1\b\fs32 
\par }
80
Scribble80
ITOUCH
itouch; touch



Writing



FALSE
11
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil Arial;}{\f1\fnil\fcharset0 Arial;}}
{\colortbl ;\red0\green0\blue255;\red0\green128\blue0;\red128\green0\blue0;}
\viewkind4\uc1\pard\ri1480\cf1\b\f0\fs32 ITOUCH\cf0\b0\fs20 
\par 
\par \f1 ITOUCH puts the current system time on the specified files.  It can be used in conjunction with IMAKE to tell it not to recompile a file, or alone just to put the current time on a file.
\par 
\par The following help topics are available:
\par 
\par \pard\ri1460\tx700\tab\cf2\strike Command Line Syntax\cf3\strike0\{linkID=220\}\cf0 
\par \pard\ri1480\f0 
\par }
90
Scribble90
GREP
grep; search in files



Writing



FALSE
11
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil Arial;}{\f1\fnil\fcharset0 Arial;}}
{\colortbl ;\red0\green0\blue255;\red0\green128\blue0;\red128\green0\blue0;}
\viewkind4\uc1\pard\ri1500\cf1\b\f0\fs32 GREP\cf0\b0\fs20 
\par 
\par \f1 The GREP utility searches a file or a group of files for any occurrence of a specified string.  This particular grep program was found on the internet; it was for DOS but modified for WIN32.
\par 
\par The following help topics are available:
\par 
\par \pard\ri1500\tx700\tab\cf2\strike Command Line Syntax\cf3\strike0\{linkID=230\}
\par \tab\cf2\strike Regular Expressions\cf3\strike0\{linkID=232\}\cf0\f0 
\par }
110
Scribble110
CC386 Command Line
cc386; command line



Writing



FALSE
30
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;\red0\green128\blue0;\red128\green0\blue0;}
\viewkind4\uc1\pard\ri1480\cf1\b\fs32 CC386 Command Line\cf0\b0\f1\fs20 
\par 
\par \f0 CC386 has a variety of command line parameters, most of which aren't needed to just compile a file.  It will also allow you to specify multiple input files.  The current default for CC386 is to generate executable files.  Prior to processing the command line, CC386 will process \cf2\strike environment variables\cf3\strike0\{linkID=280\}\cf0 . While processing the command line, CC386 may encounter a command to process \cf2\strike command line arguments from a file\cf3\strike0\{linkID=270\}\cf0 .
\par 
\par The general format of the command line is as follows:
\par 
\par CC386 [parameters]  list of files
\par 
\par The list of files can be a list of one or more C language files.  C++ language files are partially supported, but the C++ support is minimal at this time.  If you don't specify an extension on the command line it will default to .C; it will detect a .CPP extension and activate C++ mode as required.
\par 
\par CC386 will accept response files with a list of command line options.  To use a response file, prefix its name with '@':
\par 
\par CC386 [parameters] @resp.cc
\par 
\par There are a variety of parameters that can be set.  Help is available for the following:
\par \cf2\strike 
\par \pard\ri1460\tx700\cf3\strike0\tab\cf2\strike CC386 Output Control\cf3\strike0\{linkID=235\}\cf0 
\par \tab\cf2\strike Warning Control\cf3\strike0\{linkID=240\}\cf0 
\par \tab\cf2\strike List File Control\cf3\strike0\{linkID=250\}\cf0 
\par \tab\cf2\strike Preprocessor File Control\cf3\strike0\{linkID=260\}\cf0 
\par \tab\cf2\strike Debug Information\cf3\strike0\{linkID=290\}\cf0 
\par \tab\cf2\strike Compilation Modes\cf3\strike0\{linkID=300\}\cf0 
\par \tab\cf2\strike Defining Macros\cf3\strike0\{linkID=310\}\cf0 
\par \tab\cf2\strike Specifying Include Paths\cf3\strike0\{linkID=320\}\cf0 
\par \tab\cf2\strike Translating Trigraphs\cf3\strike0\{linkID=330\}\cf0 
\par \tab\cf2\strike Code Generation Parameters\cf3\strike0\{linkID=340\}\cf0 
\par \tab\cf2\strike Optimizer Parameters\cf3\strike0\{linkID=350\}\cf0 
\par }
120
Scribble120
CC386 Extended Keywords
cc386; extended keywords



Writing



FALSE
37
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;\red0\green128\blue0;\red128\green0\blue0;}
\viewkind4\uc1\pard\ri1480\tx680\cf1\b\fs32 CC386 Extended Keywords\cf0\b0\f1\fs20 
\par 
\par \f0 CC386 supports a variety of non-ansi keywords for different types of control functions.  Register names for the 32 bit registers of the x86 processor are also keywords.  There is presently no support for far functions or variables.
\par 
\par These keywords are as follows:
\par \pard\ri1460 
\par \tab\cf2\strike _absolute\cf3\strike0\{linkID=360\}
\par \tab\cf2\strike alloca\cf3\strike0\{linkID=363\}\cf0 
\par \tab\cf2\strike _cdecl and cdecl\cf3\strike0\{linkID=380\}\cf0 
\par \tab\cf2\strike _export\cf3\strike0\{linkID=460\}
\par \tab\cf2\strike _far\cf3\strike0\{linkID=365\}\cf0 
\par \tab\cf2\strike _genbyte\cf3\strike0\{linkID=420\}\cf0\tab 
\par \tab\cf2\strike _import\cf3\strike0\{linkID=400\}\cf0 
\par \tab\cf2\strike _indirect\cf3\strike0\{linkID=450\}\cf0 
\par \tab\cf2\strike _interrupt\cf3\strike0\{linkID=410\}
\par \tab\cf2\strike _fault\cf3\strike0\{linkID=410\}
\par \cf0\tab\cf2\strike _intrinsic\cf3\strike0\{linkID=430\}\cf0 
\par \tab\cf2\strike _loadds\cf3\strike0\{linkID=440\}
\par \tab\cf2\strike _near\cf3\strike0\{linkID=365\}\cf0 
\par \tab\cf2\strike _pascal\cf3\strike0\{linkID=370\}\cf0 
\par \tab\cf2\strike _stdcall\cf3\strike0\{linkID=390\}
\par \tab\cf2\strike _typeof\cf3\strike0\{linkID=465\}
\par 
\par \pard\ri1480\tx680\cf0 CC386 also supports names for the registers.  These include:
\par 
\par \pard\ri1460\tab _EAX, _EBX, ECX, EDX
\par \tab _ESP, _EBP, _ESI, _EDI
\par \tab _CS, _DS, _ES, _FS, _GS, _SS
\par 
\par \tab _CR0,_CR1,_CR2,_CR3,_CR4,_CR5,_CR6,_CR7
\par \tab _DR0,_DR1,_DR2,_DR3,_DR4,_DR5,_DR6,_DR7
\par \tab _TR0,_TR1,_TR2,_TR3,_TR4,_TR5,_TR6,_TR7
\par 
\par \pard\ri1480\tx680 Note that the values of the registers may be changed by compiled code as part of the access to them; accesses should be kept simple if you wish to use this mechanism for accessing the registers.  Further some of these registers may be set up by the operating system and should not be accessed by the programmer.\f1 
\par }
130
Scribble130
CC386 #pragma directives
cc386; #pragma directives



Writing



FALSE
18
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;\red0\green128\blue0;\red128\green0\blue0;}
\viewkind4\uc1\pard\ri1480\tx680\cf1\b\fs32 CC386 #pragma directives\cf0\b0\f1\fs20 
\par 
\par \f0 CC386 supports a number of extended directives which control the compilation or output files.
\par These directives are placed in the source code.
\par 
\par The following directives are available:
\par 
\par \pard\ri1460\tab\cf2\strike #pragma aux\cf3\strike0\{linkID=530\}\cf0 
\par \tab\cf2\strike #pragma error\cf3\strike0\{linkID=470\}
\par \tab\cf2\strike #pragma farkeyword\cf3\strike0\{linkID=475\}\cf0 
\par \tab\cf2\strike #pragma library\cf3\strike0\{linkID=500\}\cf0 
\par \tab\cf2\strike #pragma pack(n)\cf3\strike0\{linkID=510\}\cf0 
\par \tab\cf2\strike #pragma rundown\cf3\strike0\{linkID=490\}
\par \cf0\tab\cf2\strike #pragma startup\cf3\strike0\{linkID=490\}\cf0 
\par \tab\cf2\strike #pragma warning\cf3\strike0\{linkID=480\}\cf0\f1 
\par }
140
Scribble140
NASM Command Line
nasm; command line



Writing



FALSE
49
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\ri1460\tx2240\cf1\b\fs32 NASM Command Line\cf0\b0\f1\fs20 
\par 
\par \f0 The NASM assembler has a variety of command line options, most of which aren't used by CC386.  The general format of a command line is as follows:
\par 
\par nasm [parameters] filename
\par 
\par By default nasm will output a plain binary file; it has a variety of output formats which it supports, but for CC386 we use the OBJ format.  For example:
\par 
\par nasm -fobj filename
\par \f1 
\par \f0 The nasm command line parameters are as follows.  Full discussion of the NASM programming syntax can be found in the NASM documentation.
\par 
\par \pard\fi-2220\li2220\ri1440\tx2220 
\par \b\fs22 -v\tab Version information
\par 
\par -t\tab Assemble in SciTech TASM compatible mode
\par 
\par -g\tab generate debug information
\par \tab\b0\fs20 This version of NASM will not generate debug information compatible with the CC386 ide
\par 
\par \b\fs22 -e\tab preprocess only
\par 
\par -a\tab skip preprocessing
\par 
\par -M\tab generate makefile dependencies on stdout
\par 
\par -Efile\tab redirect error messages to file
\par 
\par -s\tab redirect error messages to stdout
\par \tab\b0\fs20 CCIDE selects this option\b\fs22 
\par 
\par -f\tab select an output format
\par \tab\b0\fs20 CCIDE selects OBJ format\b\fs22 
\par 
\par -Ipath\tab add a path to the include search list
\par 
\par -O\tab optimize branch offsets
\par 
\par -P\tab preinclude a file
\par 
\par -D\tab predefine a macro
\par 
\par -U\tab undefine a macro
\par 
\par 
\par \pard\b0\f1\fs20 
\par }
150
Scribble150
VALX Command Line
valx; command line



Writing



FALSE
112
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\ri1460\cf1\b\fs32 VALX Command Line\cf0\b0\f1\fs20 
\par \f0 
\par The general format of a VALX command line is:
\par 
\par valx [parameters]  <list of object files>,<executable file>, <map file>, <list of library files>,<resource file>
\par 
\par If there are less than 4 commas separating file names, VALX, will stop and prompt the user for the remaining information.  It is ok to select empty lists or file names to force it to not prompt, for example the following is valid:
\par 
\par valx  myfile.obj,myfile.exe,,,
\par 
\par Valx will accept response files having a list of command line arguments to process. To use a response file, just place an @ in front of a file name:
\par 
\par valx @resp.lnk
\par 
\par will perform the operations in resp.lnk.  Response files can be mixed with other command-line parameters.
\par 
\par Valx has a variety of options.  In general for DOS programs with CC386 the following options are required:
\par 
\par /32 /NCI
\par 
\par for the PMODE/W extender.  Or you can use:
\par 
\par /LX /NCI
\par 
\par if you want to default to the DOS32A extender.
\par 
\par For windows programs the following are required:
\par 
\par /32 /PE /NCI
\par 
\par and either /CON or /WIN
\par 
\par additionally /DEB may be used to specify the debug information.
\par 
\par 
\par 
\par \pard\ri1440\tx700\tx2780\tx3660 Following is a list of all possible options to VALX:
\par Abbr\tab Full
\par Name\tab Name\tab Def\tab Description
\par ----\tab ----------------- \tab ------ \tab -----------------------------------------------
\par AH\tab ALignexeheader\tab Yes\tab Align EXE header to paragraph boundary
\par A32\tab Align32\tab 0\tab Alignment for 32-bit images, not PE or LX
\par BDL\tab buildDll          \tab No\tab PE files will be dlls.
\par BSZ\tab BUffersize:n      \tab 32768\tab Set I/O buffer size (512 - 65,024 bytes)
\par CI\tab CAseignore        \tab Yes\tab Linker will ignore the case of symbols
\par CO\tab COmfile           \tab No     \tab Linker will to produce a .COM file
\par CON\tab consoleSubSys     \tab Yes    \tab PE files will be console apps
\par \tab CParmaxalloc      \tab 0xFFFF\tab Sets max paragraphs needed beyond EXE file
\par DE\tab Debug             \tab No     \tab Enable debug information
\par DET\tab DEtaillevel       \tab 0      \tab Sets the detail included in the .MAP file:
\par \pard\ri1440\tx660\tx2760\tx3660\tx4500\tx4500                                \tab\tab\tab 0 - Standard link map 
\par                                \tab\tab\tab 1 - Include Segment header info
\par                                \tab\tab\tab 2 - Include Segment header info by module
\par                                \tab\tab\tab 3 - Include data map by module
\par                                \tab\tab\tab 4 - Include EXE header
\par                                \tab\tab\tab 5 - Include fixup info
\par \pard\ri1440\tx700\tx2780\tx3660\tab DOsseg            \tab No     \tab Use Microsoft "DOSSEG" segment ordering
\par \tab EXechecksum       \tab No     \tab Compute checksum in .EXE header file 
\par FA\tab FileAlign         \tab 8192   \tab File alignment for PE images
\par GHS\tab GRouphashsize:n   \tab 25     \tab Hash size for group symbols (1, 1023)
\par HLP\tab HElp              \tab No     \tab Produce this information
\par L\tab LIbdir            \tab None   \tab Library search directory path
\par LE\tab LE\tab No\tab Linker will produce an LE executable
\par LHS\tab LNamehashsize:n   \tab 25     \tab Hash size for LNAMES symbols (1 - 1023)
\par LX\tab LX                \tab No     \tab Linker will produce an LX executeable
\par LXP\tab LXPAGESIze        \tab 4096   \tab LX file format page size (128-32768)
\par LXS\tab LXPAGESHift       \tab 12     \tab LX file format page shift (7-15)
\par LXV\tab LXVersion         \tab 0      \tab LX module version (0-0xffffffff)
\par MP\tab MAp               \tab No     \tab Produce link map with public symbols
\par NAH\tab NOALignexeheader  \tab No     \tab Align EXE header to standard page boundary
\par NCI\tab NOCAseignore      \tab No     \tab Linker will respect case of symbols
\par NCO\tab NOCOMfile         \tab Yes    \tab Linker will not produce a .COM file
\par NDL\tab NObuildDLL        \tab Yes    \tab PE files will not be DLLs.
\par NDO\tab NODOsseg          \tab Yes    \tab Linker will not use DOSSEG ordering
\par NEX\tab NOEXechecksum     \tab Yes    \tab Set checksum in .EXE header file to 0
\par NLE\tab NOLE\tab Yes\tab Linker will not produce an LE executable
\par NLX\tab NOLX              \tab Yes    \tab Linker will not produce an LX executable
\par NMP\tab NOMAp             \tab Yes    \tab Publics not included in link map
\par NOB\tab NOOBjchecksum     \tab Yes    \tab Ignore checksum in .OBJ records               
\par NPS\tab NOpadSegments     \tab Yes    \tab Don't pad PE sections
\par NPA\tab NOPAuse           \tab Yes    \tab No pause before writing executable image
\par NSY\tab NOSYsfile         \tab Yes    \tab Linker will not produce a .SYS file
\par NSYM\tab NOSymbolTable\tab Yes\tab Linker will not produce a symbol table
\par NST\tab NOSTatistics      \tab Yes    \tab Linker will not give performance statistics
\par N32\tab NOUse32           \tab Yes    \tab Linker will not allow 32-bit segments
\par \tab OBjchecksum       \tab No     \tab Test checksum in .OBJ records               
\par \tab ORder:(text)      \tab none   \tab Segment ordering expression (see below)
\par NPE\tab NoPE              \tab Yes    \tab Linker will not produce a PE executable
\par OA\tab ObjectAlign       \tab 64K    \tab Object alignment for PE images
\par \tab PAuse             \tab No     \tab Pause before writing executable image
\par PAS\tab padSegments\tab No     \tab Pad PE sections
\par PE\tab PE\tab No     \tab Produce a PE executable
\par PH\tab peHeapSize\tab 65536  \tab Heap size for PE files
\par PHC\tab peHeapCommit\tab 0      \tab Amount of heap to commit for PE files
\par PIB\tab peImageBase\tab 4M     \tab Image base for PE files
\par PSC\tab peStackCommit\tab 8K     \tab Amount of heap to commit for PE files
\par PS\tab peStackSize\tab 1M  \tab Stack size for PE and LX files
\par PHS\tab PUblichashsize:n\tab 525    \tab Hash size for public symbols (1 - 1023)
\par \tab SYsfile\tab No     \tab Produce a .SYS file (e.g., device driver)
\par SHS\tab SEgmenthashsize:n\tab 25     \tab Hash size for segment (1 - 1023)
\par STB\tab StubFile\tab stub32a.exe  MSDOS Stub file for PE/LE/LX formats
\par STK\tab STACk:n\tab none\tab Insure there is a stack of at least n bytes
\par SY\tab SYsfile           \tab NO\tab Linker will produce a .SYS file
\par SYM\tab SymTable          \tab No\tab Produce GRDB compatible symbol table
\par STS\tab STATistics\tab No     \tab Produce performance statistics for linker
\par TMP\tab TEmpfile:(text)\tab val.tmp \tab Specifies name of linker temporary file
\par WIN\tab winSubSys\tab No     \tab PE files will use WIN32 subsystem
\par 32\tab Use32\tab No     \tab Linker will allow 32-bit segments
\par \pard 
\par }
160
Scribble160
XLIB Command Line
xlib; command line



Writing



FALSE
35
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\ri1460\cf1\b\fs32 XLIB Command Line\cf0\b0\f1\fs20 
\par 
\par \f0 The general format of the XLIB command line is as follows:
\par 
\par XLIB [options] library [+,-,*] filename ...
\par 
\par XLIB can work with response files by preceding the name of the response file with '@':
\par 
\par XLIB @resp.rsp
\par 
\par Note that each physical line of a response file should end in '&'.
\par 
\par XLIB has the following operation specifiers:
\par 
\par \pard\ri1440\tx680\tx2780\tab + \tab add a file to a lib
\par \tab -\tab delete a file from a lib
\par \tab *\tab extract a file from a lib
\par \tab -+\tab replace a file in a lib
\par 
\par \pard\ri1460 Each file on the command line must have a specifier; however specifiers are in scope from the time they are specified until the time a next specifier is specified.  Therefore one doesn't need to repeat specifiers that are being reused.  For example:
\par 
\par XLIB xlib.lib + file1.obj file2.obj file3.obj - file4.obj
\par 
\par adds three files and deletes one.
\par 
\par XLIB has the following options:
\par 
\par \pard\ri1440\tx2220\b\fs22 /u \tab create case-insensitive dictionary for library searches
\par 
\par /pnn\tab set page size
\par \tab\b0\fs20 page size can be any multiple of 16 bytes
\par \pard\f1 
\par }
170
Scribble170
MKLIBLST Command Line
mkliblst; command line



Writing



FALSE
14
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\ri1480\cf1\b\fs32 MKLIBLST Command Line\cf0\b0\f1\fs20 
\par 
\par \f0 The general format of a MKLIBLST command line is:
\par 
\par mkliblst respfile [.obj] list of files
\par 
\par Use the .obj option for CC386 XLIB librarian, or omit if for use with Borland's TLIB.
\par 
\par mkliblst will attempt to append the file list to the response file; it will create the response file if it doesn't already exist.
\par 
\par \f1 
\par }
172
Scribble172
IMPORT Command Line
import; command line



Writing



FALSE
20
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\ri1460\cf1\b\fs32 IMPORT Command Line\cf0\b0\f1\fs20 
\par 
\par \f0 The general format of the command line for the IMPORT program is as follows:
\par 
\par import [options] target [source list]
\par 
\par The source list can be a response file, which starts with the @ character.
\par 
\par The target can be either a LIB file or a DEF file.  If the target is a LIB file the source must be a DEF or DLL file or combination of them.  If the target is a DEF file the source must be a DLL file and there can only be one source.
\par 
\par IMPORT has the following options:
\par \pard\ri1440\tx2240 
\par \b\fs22 /u \tab create case-insensitive dictionary for library searches
\par 
\par /pnn\tab set page size
\par \tab\b0\fs20 page size can be any multiple of 16 bytes
\par \b\fs22 
\par }
175
Scribble175
Using the created definition file
mkliblist; definition file



Writing



FALSE
11
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\ri1460\cf1\b\fs32 Using the created definition file\cf0\b0\f1\fs20 
\par 
\par \f0 The definition file is used as the response file on the XLIB command line.  For example:
\par 
\par mkliblst xlib.rsp .obj file1.obj file2.obj file3.obj
\par xlib aa.lib @xlib.rsp
\par 
\par will result in a library holding the three files listed on the mkliblst command line.\f1 
\par }
180
Scribble180
XRC Command Line
xrc; command line



Writing



FALSE
18
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\ri1480\cf1\b\fs32 XRC Command Line\cf0\b0\f1\fs20 
\par 
\par \f0 The general format for the XRC command line is as follows:
\par 
\par XRC [parameters] source file
\par 
\par By default a target file having the same name as the source but with the extension RES will be generated.
\par 
\par XRC has the following options:
\par 
\par \pard\ri1460\tx2240\b\fs22 /Dname\tab define something
\par /Ipath\tab set include path
\par /foname\tab set name of output file
\par 
\par \f1 
\par }
190
Scribble190
CL386 Command Line
cl386; command line



Writing



FALSE
41
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\ri1500\cf1\b\fs32 CL386 Command line
\par 
\par \cf0\b0\fs20 The general format for the CL386 command line is as follows:
\par 
\par CL386 [options] files
\par 
\par CL386 will allow response files, for example:
\par 
\par CL386 @resp.rsp
\par 
\par CL386 has the following options.  Note that unless otherwise specified options can be turned on or off by prefixing '+' or '-' after the option.
\par For example:
\par 
\par CL386 /A- myfile.c
\par 
\par compiles without extensions to ANSI
\par \pard\ri1500\tx2240 
\par \b\fs22 /A\tab Enable or disable extensions to ANSI
\par /Dxxx\tab Define something
\par /Ipath\tab Specify include path
\par /Oxxx\tab optimize parameters
\par /q\tab Enable or disable quiet mode
\par /K\tab keep response file
\par /e\tab put errors in file
\par /l\tab make listing file
\par /w-xxx\tab disable a warning
\par /e=name \tab set name of EXE file
\par /a\tab generate .asm file
\par /Ennn\tab max number of errors
\par /Lpath\tab specify lib directory
\par /Cxxx\tab codegen parameters
\par /k\tab keep generated files
\par /m\tab generate a map file
\par /i\tab dump preprocessed file
\par /n\tab ignore default lib and OBJ files
\par /v\tab debug info
\par /c\tab generate obj file
\par \pard\b0\f1\fs20 
\par }
200
Scribble200
IMAKE Command Line
imake; command line



Writing



FALSE
52
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\ri1480\cf1\b\fs32 IMAKE Command Line\cf0\b0\f1\fs20 
\par 
\par \f0 The general format for the IMAKE command line is:
\par 
\par imake [options] <target-list>
\par 
\par By default Imake will attempt to open a file MAKEFILE or MAKEFILE.MAK and process the instructions for building the project.  If target-list is omitted the first explicit target found will be evaluated; otherwise IMAKE will attempt to evaluate all targets found on the command line.
\par 
\par IMAKE has the following options:
\par \pard\fi-2200\li2200\ri1460\tx2220 
\par \b\fs22 -e\tab macros derived from environment variables cannot be overridden
\par \tab\b0\fs20 prevents changing values that are derived from the environment
\par \b\fs22 
\par -fname\tab specify the name of a makefile.
\par \tab\b0\fs20 Will attempt to open the specified file name for a list of instructions.  If the file does not exist then appends the extension MAK to the name and attempts to open it\b\fs22 
\par 
\par -h\tab command line help
\par 
\par -i\tab ignore return status of executed programs
\par \tab\b0\fs20 imake will keep going even if something fails with an error
\par \b\fs22 
\par -m\tab display time stamps
\par \tab\tab 
\par -n\tab test mode
\par \tab\b0\fs20 imake will evaluate the targets, without actually executing any programs listed for execution
\par \b\fs22 
\par -p\tab dump database of definitions and targets
\par \tab\b0\fs20 imake will dump all the information it has gathered after processing the file\b\fs22 
\par 
\par -r\tab don't run builtins.mak
\par \b0\fs20\tab by default, IMAKE will run a file 'builtins.mak' prior to loading the primary make file.  This specifies some convenient default values.  Use this option to ignore builtins.mak.
\par \b 
\par \fs22 -s\tab suppress display of commands being executed
\par \tab\b0\fs20 quiet mode\b\fs22 
\par 
\par -B\tab full build
\par \b0\fs20\tab ignore time stamps and fully evaluate every node which is a dependency of the listed targets
\par 
\par \b\fs22 -Dxxx\tab define something
\par \b0\fs20\tab make a macro definition
\par 
\par \b\fs22 -I\tab set include directory
\par \tab\b0\fs20 set directory for files included in the makefile
\par 
\par \b\fs22 -K\tab keep intermediate files
\par 
\par -Uxxx\tab prevent XXX from being defined
\par \tab\b0\fs20 When this option is used, IMAKE will prevent definitions of the corresponding macros\b\fs22 
\par \f1 
\par }
220
Scribble220
ITOUCH Command Line
itouch; command line



Writing



FALSE
15
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\cf1\b\fs32 ITOUCH Command Line\cf0\b0\f1\fs20 
\par 
\par \f0 The general format for the ITOUCH command is:
\par 
\par ITOUCH [options] files
\par 
\par Files can be a list of files with wild cards.
\par 
\par ITOUCH has the following options:
\par 
\par \pard\ri1460\tx2220\b\fs22 /v\tab verbose mode
\par \tab\b0\fs20 show files as they are being processed\b\f1\fs22 
\par }
230
Scribble230
Grep Command Line
grep; command line



Writing



FALSE
39
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\ri1500\tx2220\cf1\b\fs32 Grep Command Line\cf0\b0\f1\fs20 
\par 
\par \f0 The general format of the grep command line is:
\par 
\par GREP [options] searchstring file[s]
\par 
\par The files may have wild card characters.
\par 
\par GREP has the following options:
\par 
\par \b\fs22 /c\tab show match count
\par /d\tab recurse in subdirectories
\par /i\tab case insensitive
\par /l\tab show file names but not matched lines
\par /n\tab show line numbers
\par /o\tab UNIX output format
\par /r\tab disable regular expressions
\par /v\tab show non-matching lines
\par /w\tab complete words only
\par /z\tab verbose
\par ?\tab help
\par \b0 
\par Grep has limited regular expression matching.  The following special characters are used in regular exprssions.
\par 
\par \\\tab quote the next character
\par .\tab match any character
\par *\tab match zero or more occurrances of the next character or set
\par +\tab match one or more occurrances of the next character or set
\par ^\tab match the start of line
\par $\tab match the end of line
\par 
\par Sets are specified with [] as follows
\par 
\par [aeiou4-7]\tab specifies vowels and digits from 4-7 inclusive
\par [^aeiou4-7]\tab specified anything but vowels and digits from 4-7 inclusive
\par \b 
\par }
232
Scribble232
Grep Regular Expressions
grep; regular; expression



Writing



FALSE
55
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;\red0\green128\blue0;\red128\green0\blue0;}
\viewkind4\uc1\pard\fi-1640\li1640\ri1480\tx700\tx1660\cf1\b\fs32 Grep Regular Expressions\cf0\b0\f1\fs20 
\par \pard\ri1460\tx680\tx1640 
\par \f0 Regular expressions may be used in the query boxes of the \cf2\strike Find\cf3\strike0\{linkID=310\}\cf0  and \cf2\strike Replace\cf3\strike0\{linkID=320\}\cf0  dialogs.  The regular expression operators are a subset of those used by the EMACS editor.  In general characters have their normal meanings, but there are a few special characters that can be used.
\par 
\par Regular expressions work by taking a list of operators with generic meanings and trying to match parts of the source text (the edit file).  If all the operators taken together in sequence match some string in the source text, the find operation is successful.
\par 
\par \pard\fi-1640\li1640\ri1480\tx700\tx1660\tab .\tab matches any single character
\par \tab +\tab matches one or more occurrences of the preceding character
\par \tab *\tab matches zero or more occurrences of the preceding character
\par \tab ?\tab matches exactly zero or one occurrences of the preceding character
\par \tab ^\tab matches beginning of line
\par \tab $\tab matches end of line
\par \tab [ and ]\tab define a list of characters which can match present character
\par \tab\tab between the brackets can be placed either a list of letters, any of which matches the current character, or the name of a character class which is matched against the current character.  The format for a character class is:
\par 
\par \tab [:classname:]
\par 
\par \pard\fi-680\li680\ri1460\tx680\tx1640\tab for example [[:alpha:]] matches any letter.  The class names follow the macros found in ctype.h:  the following class names are valid:
\par \pard\fi-1640\li1640\ri1480\tx700\tx1660 
\par \pard\fi-3360\li3360\ri1460\tx1640\tx3360\tab alpha\tab matches a letter
\par \tab upper\tab matches an upper case letter
\par \tab lower\tab matches a lower case letter
\par \tab digit\tab matches a digit
\par \tab alnum\tab matches a letter or digit
\par \tab xdigit\tab matches a hexadecimal digit
\par \tab space\tab matches any white space character, e.g. spaces,
\par \tab\tab newlines, tabs, form feeds 
\par \tab print\tab matches any printable character
\par \tab punct\tab matches punctuation characters
\par \tab graph\tab matches non-space printable characters
\par \tab cntrl\tab matches control characters
\par \tab blank\tab matches space and tab
\par 
\par \pard\fi-1640\li1640\ri1480\tx700\tx1660 
\par \tab |\tab alternator, an 'or' operator
\par \tab\\\tab escape character.  When it precedes a special character, it quotes that character.  When used with other characters it can cause special matching functions to occur
\par \tab 
\par The escape sequences are as follows:
\par 
\par \tab\\b\tab matches a word boundary
\par \tab\\B\tab matches inside a word
\par \tab\\w\tab matches word constituents
\par \tab\\W\tab matches non-word constituents
\par \tab\\<\tab matches beginning of word
\par \tab\\>\tab matches end of word
\par \tab\\`\tab matches beginning of buffer
\par \tab\\'\tab matches end of buffer
\par \tab\\( and \\)\tab define a group to be indexed in back-reference and replace operations
\par \tab\\\{ and \\\}\tab interval operators
\par \tab\tab for example: "a\{2,4\} matches from 2 to 4 'a' characters.  less than two or greater than four characters don't match
\par \tab\\digit\tab back-reference operator... references a parenthesized group
\par 
\par }
235
Scribble235
CC386 Output Control
cc386; compiler output control



Writing



FALSE
66
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\ri1480\tx2220\tx3340\tx3360\tx4500\cf1\b\fs32 Output Control\cf0\b0\f1\fs20 
\par 
\par \f0 This section deals with compiler parameters related to controlling the type of output.
\par \b\f1\fs22 
\par \pard\fi-2200\li2200\ri1460\tx2220\tx3320\tx3360\tx4500\f0 /c\tab generate object file only
\par 
\par \b0\fs20\tab Causes CC386 to not generate an EXE file automatically.  Useful when compiling many files prior to a later link stage.
\par 
\par \tab\cf1 CC386 /c hello.c
\par 
\par \tab\cf0 generates a file hello.obj instead of generating hello.exe\b\fs22 
\par 
\par /o  \tab set output file name
\par 
\par \b0\fs20\tab Causes cc386 to rename the output file. If generating an EXE output, cc386 will rename the exe file.  If generating an object (OBJ) file, cc386 will rename the obj file.  Note that you cannot set the output file name for a group of files unless you are generating an EXE file.
\par 
\par \tab\cf1 CC386 /ohi hello.c
\par 
\par \pard\fi-2180\li2180\ri1440\tx2220\tx3300\tx3360\tx4500\cf0\tab generates an EXE file called HI.EXE.
\par \b\fs22 
\par /S\tab generate assembly language file only
\par 
\par \pard\fi-2200\li2200\ri1460\tx2220\tx3320\tx3360\tx4500\b0\fs20\tab Causes CC386 to generate an assembly language file in NASM format, but no object or EXE files
\par 
\par \tab\cf1 CC386 /c hello.c
\par 
\par \tab\cf0 generates a file hello.asm
\par \pard\fi-2180\li2180\ri1440\tx2220\tx3300\tx3360\tx4500\b\fs22 
\par /s\tab generate intermediate assembly language file
\par 
\par \b0\fs20\tab CC386 will generate an executable file by compiling via assembly.  The intermediate assembly language file will remain after compilation.
\par 
\par \tab\cf1 CC386 /c hello.c\b\fs22 
\par \tab 
\par \cf0\b0\fs20\tab generates the files hello.asm and hello.exe.
\par 
\par \b\fs22 /W \tab set exe file type
\par 
\par \b0\fs20\tab When CC386 is generating an EXE file, several formats are possible.  These are as follows:
\par 
\par \pard\fi-4620\li4620\ri1440\tx2220\tx3300\tx3360\tx4500\tab\tab\tab /Wd\tab - generate a WIN32 DLL program
\par \tab\tab\tab /Wdc\tab - generate a WIN32 DLL program, use CRTDLL run time library
\par \tab\tab\tab /Wdl\tab - generate a WIN32 DLL program, use LSCRTL run time library
\par \tab\tab\tab /Wdm\tab - generate a WIN32 DLL program, use MSVCRT run time library
\par \tab\tab\tab /Wc\tab - generate a WIN32 console program
\par \tab\tab\tab /Wcc\tab - generate a WIN32 console program, use CRTDLL run time library
\par \tab\tab\tab /Wcl\tab - generate a WIN32 console program, use LSCRTL run time library
\par \tab\tab\tab /Wcm\tab - generate a WIN32 console program, use MSVCRT run time library
\par \tab\tab\tab /Wg\tab - generate a WIN32 gui program
\par \tab\tab\tab /Wgc\tab - generate a WIN32 gui program, use CRTDLL run time library
\par \tab\tab\tab /Wgl\tab - generate a WIN32 gui program, use LSCRTL run time library
\par \tab\tab\tab /Wgm\tab - generate a WIN32 gui program, use MSVCRT run time library
\par \tab\tab\tab /We\tab - generate an MSDOS program (using Tran's PMODE)
\par \tab\tab\tab /Wa\tab - generate an MSDOS program (using DOS32A)
\par \tab\tab\tab /Wh\tab - generate an MSDOS program (using HXDOS/WIN32 runtime)
\par \tab\tab\tab /Wr\tab - generete a RAW program
\par \tab\tab\tab /Wx\tab - generate an MSDOS program (using HXDOS/DOS runtime)
\par \f1 
\par \pard\fi-2180\li2180\ri1440\tx2220\tx3300\tx3360\tx4500\f0\tab\cf1 CC386 /Wcl hello.c
\par 
\par \tab\cf0 generates a win32 console program hello.exe, which will use the LSCRTL.DLL run time library.
\par 
\par \tab Note: when compiling files for use with the LSCRTL.DLL, one of the switches /Wdl /Wcl or /Wgl must be present to indicate to the compiler that linkage will be against that library.  Failing to use one of these switches can result in errant run-time behavior.\f1 
\par }
240
Scribble240
CC386 Warning control
cc386; warning control



Writing



FALSE
40
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2220\li2220\ri1500\tx2220\cf1\b\fs32 Error control
\par 
\par \cf0\b0\fs20 This section deals with compiler parameters related to error messages.\f1 
\par 
\par \b\fs22 +e \tab put the compiler errors in a file.  
\par \b0\f0\fs20 
\par \tab For each file processed, CC386 will create a file with the same name as the original source with the extension.  '.err'.  The contents of this file will be a listing of any errors or warnings which occurred during the compile.  For example:
\par 
\par 
\par \cf1\tab CC386 +e myfile.c
\par 
\par \cf0\tab results in myfile.err
\par 
\par \b\f1\fs22 +Q\tab Quiet mode
\par \b0\f0\fs20 
\par \tab Don't display errors or warnings on the console.  Generally this is used in conjunction with the +e switch.  For example:
\par 
\par \cf1\tab CC386 +e +Q myfile.c
\par 
\par \cf0\tab puts the errors in a file, without displaying them on the console.
\par 
\par \b\f1\fs22 /w-xxx\tab disable warnings
\par \b0\f0\fs20 
\par \tab you use this once for each warning you want to disable, xxx is a three character warning code.  These are presently undocumented, except for /W-all which disables all warnings.  For example:
\par 
\par \cf1\tab CC386 /w-all myfile.c
\par 
\par \cf0\tab disables all warnings
\par 
\par \b\f1\fs22 /E[+]nn\tab error control
\par \b0\f0\fs20 
\par \tab nn is the maximum number of errors before the compile fails; if + is specified extended warnings will be shown that are normally disabled by default.  For example:
\par 
\par \cf1\tab CC386 /E+44 myfile.c
\par 
\par \cf0\tab enables extended warnings and limits the number of errors to 44.  By default only 25 errors will be shown and then the compiler will abort.
\par \pard\fi-1440\li1440 
\par }
250
Scribble250
CC386 List file control
cc386; list file control



Writing



FALSE
13
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2220\li2220\ri1460\tx2220\cf1\b\fs32 List file control\cf0\b0\f1\fs20 
\par 
\par \b\fs22 +l\tab create a listing file 
\par 
\par \b0\f0\fs20\tab For each file processed, CC386 will create a file with the same name as the original source with the extension.  '.lst'.  The contents of this file will be various information gathered about the program which was processed.  For example:
\par 
\par \cf1\tab CC386 +l myfile.c
\par 
\par \cf0\tab results in myfile.lst
\par 
\par }
260
Scribble260
CC386 preprocessor control
cc386; preprocessor control



Writing



FALSE
13
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2220\li2220\ri1460\tx2240\cf1\b\fs32 Preprocessor file control\cf0\b0\f1\fs20 
\par \b\fs22 
\par +i\tab create a file with preprocessed text.\b0\f0\fs20   
\par 
\par \tab For each file processed, CC386 will create a file with the same name as the original source with the extension.  '.i'.  The contents of this file will be the source code, with each identifier which corresponded to a macro expanded out to its full value.  For example:
\par 
\par \cf1\b\f1\fs22\tab\b0\fs20 CC386 +i myfile.c\b\fs22 
\par 
\par \cf0\b0\f0\fs20\tab results in myfile.i
\par 
\par }
270
Scribble270
CC386 command line files
cc386; command line files



Writing



FALSE
13
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2240\li2240\ri1480\tx2240\cf1\b\fs32 Taking arguments from the command line\cf0\b0\f1\fs20 
\par 
\par \b\fs22 /fname\tab  - gather parameters from the file 
\par 
\par \b0\f0\fs20\tab This switch is used to indicate the CC386 should take further command-line options from a file.  Each line of the file is parsed as if it was a command line and the result is cumulative.  For example:
\par 
\par \cf1\tab CC386 /fmyoptions myfile.c
\par 
\par \cf0\tab Will perform the actions defined in the file 'myoptions'
\par \f1 
\par }
280
Scribble280
CC386 environment variables
cc386; environment variables



Writing



FALSE
9
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-920\li920\ri1480\cf1\b\fs32 Environment variables\cf0\b0\f1\fs20 
\par \pard\fi-1060\li1060\ri1440\tx1040\tx1040\tx13560 
\par \f0 CC386 supports two environment variables you may set to default compiler options.  These are:
\par 
\par \cf1 CCINCL\tab\cf0 sets a default path for the -I switch.  You may additional use the -I switch to set further paths
\par \cf1 CC386\cf0\tab CC386 will parse this variable prior to parsing the command line.  Switches in this variable will take effect just as if they were present on the command line or in a command line file.\f1 
\par }
290
Scribble290
CC386 Debug information
cc386; debug information



Writing



FALSE
14
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2220\li2220\ri1480\tx2240\cf1\b\fs32 Debug information\cf0\b0\f1\fs20 
\par 
\par \b\fs22 +v\tab Put debug information in the output file
\par 
\par \b0\f0\fs20\tab The windows version of CC386 comes with an IDE which has a debugger.  If you want to use the debugger, use the +v switch.  Note that if you use this switch you may not use compile via assembly option, as debug information will not be passed through the assembler.  Also, you have to use appropriate linker switches to actually generate the debug image file used by the IDE.  For example:
\par 
\par \tab\cf1 CCIDE +v myfile.c
\par 
\par \cf0\tab Puts debug information in the object file.
\par 
\par \tab The debug file format is similar to the old codeview formats, but not exactly identical.  Other debuggers will not be able to cope with it.\cf1 
\par }
300
Scribble300
CC386 Compilation modes
cc386; compilation modes



Writing



FALSE
20
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2220\li2220\ri1460\tx2220\cf1\b\fs32 Compilation modes\cf0\b0\f1\fs20 
\par \pard\fi-2220\li2220\ri1480\tx2240 
\par \b\fs22 +A\tab disable non-ansi extensions
\par 
\par \b0\f0\fs20\tab By default the compiler allows several extensions to ansi, to make coding easier.  If you want strict adherence to ansi, use this switch.  For example:
\par 
\par \cf1\tab CC386 +A myfunc.c
\par 
\par \cf0\tab will enable ANSI mode
\par 
\par \b\fs22 +9\tab C99 Compatibility
\par \b0\fs20 
\par \tab By default the compiler compiles for pre-99 standard.  If you want extended features available in the later C99 standard, use this switch.  For example:
\par 
\par \tab\cf1 CC386 /9 myfunc.c\cf0 
\par 
\par \tab Will enable C99 mode.\b\fs22 
\par }
310
Scribble310
CC386 Defining macros
cc386; defining macros



Writing



FALSE
15
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2220\li2220\ri1460\tx2220\cf1\b\fs32 Defining macros\cf0\b0\f1\fs20 
\par 
\par \b\fs22 /Dxxx\tab define a macro
\par 
\par \b0\f0\fs20\tab This switch defines a macro as if a #define statement had been used somewhere in the source.  It is useful for building different versions of a program without modifying the source files between compiles.  Note that you may not give macros defined this way a value.  For example:
\par 
\par \cf1\tab CC386 /DORANGE myfunc.c
\par 
\par \cf0\tab is equivalent to:
\par 
\par \cf1\tab #define ORANGE 
\par 
\par }
320
Scribble320
CC386 Specifying include path
cc386; specifying include path



Writing



FALSE
15
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2200\li2200\ri1480\tx2220\cf1\b\fs32 Specifying include path\cf0\b0\f1\fs20 
\par 
\par \b\fs22 /Ipath\tab specify include path.  
\par 
\par \b0\f0\fs20\tab If your file uses headers that aren't in the directory you are running CC386 from, you will have to tell it what directory to look in.  You can have multiple search directories by using a semicolon between the directory names.  If there are multiple files with the same name in different directories being searched, CC386 will use the first instance of the file it finds by searching the path in order.  For example:
\par 
\par \cf1\tab CC386 /I..\\include;..\\source;c:\\libraries\\include myfile.c
\par 
\par \cf0\tab Will search the paths ..\\include , ..\\source, and c:\\libraries\\include in that order.  Note that you generally don't have to specify a path to the CC386 compiler header files such as stdio.h, as that will be taken care of automatically.\cf1 
\par 
\par \cf0 
\par 
\par }
330
Scribble330
CC386Translating trigraphs
cc386; translating trigraphs



Writing



FALSE
12
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2220\li2220\ri1480\tx2220\cf1\b\fs32 Translating trigraphs\cf0\b0\f1\fs20 
\par 
\par \b\fs22 /T\tab Translate trigraphs
\par 
\par \b0\f0\fs20\tab use  the /T switch to have CC386 translate trigraphs.  By default CC386 will not translate trigraphs in order to get the compiler speed a little faster.  For example:
\par 
\par \cf1\tab CC386 /T myfile.c
\par 
\par \cf0\tab Translates any trigraphs in the text.\f1 
\par }
340
Scribble340
CC386 Codegen params
cc386; codegen params



Writing



FALSE
67
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-1660\li1660\ri1500\tx700\tx1680\cf1\b\fs32 Code generation parameters\cf0\b0\f1\fs20 
\par 
\par \b\fs22 /Cparams\f0  specifies code generation parameters
\par \b0\f1\fs20 
\par \pard\fi-660\li660\ri1620\tx660\f0\tab Params is a list of parameters, seperated by + and - symbols.  Use the + symbol to indicate a parameter is to be turned on, the minus symbol that the parameter is to be turned off.  The default states of the various parameters are opposite what is shown here; i.e. this lists how to change the default state to something else.
\par \pard\fi-660\li660\ri1500\tx660\tx1680 
\par \pard\fi-1620\li1620\ri1500\tx660\tx1640\tx1680\tab +d\tab display diagnostics
\par \pard\fi-1660\li1660\ri1500\tx700\tx1680 
\par \tab\tab displays memory diagnostics, and some indication of what internal errors have occurred
\par 
\par \tab -b\tab merge BSS with initialized data 
\par \tab\tab 
\par \tab\tab Normally there are two segments used, one for initialized data and one for uninitialized data.  This prevents the OS from having to load uninitialized data from a file; instead the program just zeroes it during startup.  This switch merges the two sections into one initialized data section.
\par 
\par \tab -l\tab don't put C source in the ASM file
\par 
\par \tab\tab When an ASM file output option is specified, this will create an ASM file without cross-referencing the assembly code to the lines of the source file.
\par 
\par \tab -m\tab don't use leading underscores
\par 
\par \tab\tab Normal C language procedure is to prepend each identifier with an underscore.  If you want to use the compiler to generate function and variable names without an underscore use this switch.  However, doing so will create an incompatibility with the run time libraries and you won't be able to link.
\par 
\par \tab +r\tab reverse order of bit operations
\par 
\par \tab\tab Normally bit fields are allocated from least significant bit to most significant bit of whatever size variable is being used.  Use this switch to reverse the order, however this may create incompatibilities with the libraries which result in code bugs.
\par 
\par \tab +s\tab align stack
\par 
\par \tab\tab This switch causes CC386 to emit code to align the stack to 16-byte boundaries.  This is useful to speed up operations that involve loading and storing double-precision floating point values to auto variables.  By default, the run-time libraries cause main() or WinMain() to execute with an aligned stack.
\par 
\par \tab +F\tab use FLAT model in ASM file
\par 
\par \tab\tab When using ASM file, select FLAT model.
\par 
\par \tab +I\tab use Microsoft-style imports
\par 
\par \tab\tab Normally the linker creates a thunk table with jump addresses that jump indirectly through the import table.  This allows basic C code to compile and link.  However some linkers do not support this and instead need the compiler to call indirectly through the import table rather than to a thunk table.  Use this switch to generate code compatible with these linkers.
\par 
\par \tab +M\tab generate MASM assembler file
\par 
\par \tab +N\tab generate NASM assembler file for OMF
\par 
\par \tab +NX\tab generate generic NASM assembler file
\par 
\par \tab +R\tab use the far keyword to create far pointers or far procedure frames
\par 
\par \tab +S\tab add stack checking code
\par \tab\tab 
\par \tab\tab This switch adds calls to the run-time library's stack checking code.  If the stack overruns, an error is generated.
\par 
\par \tab +T\tab generate TASM assembler file
\par 
\par \tab +U\tab do not assume DS == SS
\par 
\par \tab +Z\tab add profiler calls
\par \f1 
\par \f0\tab\tab This switch adds calls to a profiler module at the beginning and ending of each compiled function.  This is DOS compatibility; the WIN32 profiler module does not exist at present.
\par 
\par \tab for example:
\par 
\par \cf1\tab CC386 /C+NX+Z myfile.c
\par 
\par \cf0\tab generates generic NASM assembler module, with profiler calls inserted.
\par \pard\fi-1420\li1420\f1 
\par }
350
Scribble350
CC386 Optimizer Params
cc386; optimizer params



Writing



FALSE
29
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-1680\li1680\ri1460\tx700\tx1680\cf1\b\fs32 Optimizer Parameters\cf0\b0\f1\fs20 
\par 
\par \b\fs22 /Oparams\tab Specify optimizer parameters.
\par \b0\f0\fs20 
\par \pard\fi-680\li680\ri1440\tx680\tx1680\tab Params is a list of parameters, separated by + and - symbols.  Use the + symbol to indicate a parameter is to be turned on, the minus symbol that the parameter is to be turned off.  The default states of the various parameters are opposite what is shown here; i.e. this lists how to change the default state to something else.
\par \pard\fi-1680\li1680\ri1460\tx700\tx1680\tab 
\par \tab +a\tab do peephole optimization on inline assembly code
\par 
\par \tab\tab Normally inline assembly code is left as it is written.  If you would like minor optimizations done such as turning statements like ADD EAX,1 into INC EAX, then turn on this switch.  However turning it on may introduce subtle bugs.
\par 
\par \tab +i\tab inline intrinsic functions instead of calling the RTL
\par 
\par \tab\tab some functions such as strcpy and strlen may be inlined into the code rather than called as part of the run time library.
\par 
\par \tab -m\tab don't merge matching constants
\par 
\par \tab\tab normally if two string constants or two integer constants in the same source file have the same value, the compiler will instantiate the data for the constants only once.  However as it is possible to change a string constant even though it is constant, this switch may be used to turn that behavior off.
\par 
\par \tab -p\tab turn off peephole optimizations
\par 
\par \tab\tab Peephole optimizations are simple code transformations such as turning MOV EAX,0 into SUB EAX,EAX.  In general this is a good thing as it speeds the code up, but historically this stage of optimization has sometimes caused problems so you can turn it off if you want.
\par 
\par \tab -RA-RD turn off register optimization
\par 
\par \tab\tab Generally you don't want to do this.  It is useful sometimes when trying to debug the compiler itself.
\par \pard 
\par }
360
Scribble360
_absolute
extended keywords; _absolute



Writing



FALSE
12
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2240\li2240\ri1480\tx2240\cf1\b\fs32 _absolute\cf0\b0\f1\fs20 
\par \f0 
\par \cf1\tab\cf0 create a variable at an absolute address.  For example:
\par 
\par \tab\cf1 _absolute(0x4c21) int a ;
\par \cf0 
\par \tab places the variable 'a' at address 0x4c21.  No storage is generated for such   variables and no relocation is done.
\par 
\par \f1 
\par }
363
Scribble363
alloca
extended keywords; alloca



Writing



FALSE
21
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;\red0\green0\blue0;}
\viewkind4\uc1\pard\cf1\b\fs32 alloca\cf2\b0\f1\fs20 
\par 
\par \pard\fi-2220\li2220\ri1460\tx2240\f0\tab Allocate memory from automatic storage (the processor stack).  The primary motivation for using this function is that it is much faster than the malloc() function.
\par 
\par \tab\b alloca \b0 is implicitly defined by the compiler as follows:
\par 
\par \tab\cf1 void *alloca(size_t size);
\par \cf2 
\par \tab For example:
\par 
\par \cf1\tab int size = 24;
\par \tab int *p = alloca(size * sizeof(int));
\par \cf2 
\par \tab will allocate enough space to store an array of 24 integers.
\par 
\par \tab\b alloca \b0 allocates space without checking there is enough.  If the space used by calls to this pseudo-function plus the space used by lower level functions and their data exceeds the stack size, the program will probably crash.  
\par 
\par \tab Memory allocated by \b alloca\b0  is normally freed at the end of the function it appears in, which makes it possible to allocate a lot of data in a loop.   However, if a block has both a call to \b alloca\b0  and uses variable length arrays, at the end of the block the variable length arrays will be freed, which will also result in freeing the memory allocated by \b alloca\b0 .
\par }
365
Scribble365
far and near
extended keywords; far; near



Writing



FALSE
14
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2220\li2220\ri1460\tx2220\cf1\b\fs32 far and near\cf0\b0\f1\fs20 
\par 
\par \f0\tab The 'far' and 'near' keywords control the segmentation mode of pointers, and the return type for far procedures.  In general 32 bit programs do not need segmented pointers but some legacy programs use the far and near keywords nonetheless; by default the far and near keywords do nothing.  
\par 
\par \tab If the /C+R switch is used or '#pragma farkeyword 1' preprocessor directive is encountered, then the 'far' keyword will switch the associated pointer,function, or variable into a segmented mode.  Note that use of this switch does not cause ordinary variables or function not qualified with the 'far' keyword to become segmented values.
\par 
\par \tab In general you don't want to use this feature for windows programs.  There is no run time support for it, and complex expressions involving far pointers can break the existing run-time support due to re usage of the ES register.
\par 
\par \tab for example :
\par 
\par \cf1\tab char far *pointer ;  \f1 
\par }
370
Scribble370
_pascal
extended keywords; _pascal



Writing



FALSE
12
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2220\li2220\ri1480\tx2240\cf1\b\fs32 _pascal\cf0\b0\f1\fs20 
\par \f0\tab\tab 
\par \tab use PASCAL linking mechanism.  This linking mechanism converts the function name to upper case, removes the leading underscore, pushes arguments in reverse order from standard functions, and uses callee stack cleanup.  For example:
\par 
\par \tab\cf1 void _pascal myfunc() ;
\par \cf0 
\par \tab Creates a function myfunc with pascal linkage.
\par 
\par \f1 
\par }
380
Scribble380
_cdecl
extended keywords; _cdecl



Writing



FALSE
12
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2220\li2220\ri1500\tx2220\cf1\b\fs32 _cdecl\cf0\b0\f1\fs20 
\par \f0 
\par \tab use standard C language linking mechanism (here for compatibility with other compilers).  In this linking mechanism, a leading underscore is prepended to the name, which is case sensitive.  The caller is responsible for cleaning up the stack.  For example:
\par 
\par \tab\cf1 void _cdecl myfunc() ;
\par \cf0 
\par \tab creates a function myfunc with standard linkage.
\par 
\par \f1 
\par }
390
Scribble390
_stdcall
extended keywords; _stdcall



Writing



FALSE
12
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2220\li2220\ri1480\tx2240\cf1\b\fs32 _stdcall\cf0\b0\f1\fs20 
\par 
\par \f0\tab Use STDCALL linking mechanism.  This linking mechanism removes the leading underscore and uses callee stack cleanup.  For example:
\par 
\par \tab\cf1 void _stdcall myfunc() ;
\par \cf0 
\par \tab Creates a function myfunc with pascal linkage.
\par \f1 
\par 
\par }
400
Scribble400
_import
extended keywords; _import



Writing



FALSE
18
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2220\li2220\ri1460\tx2220\cf1\b\fs32 _import\cf0\b0\f1\fs20 
\par 
\par \f0\tab This can be used for one of two purposes.  First it can make import record for the linker to process, which will result in the appropriate DLL being loaded at run-time.  Second, it can be used to declare a variable from a DLL so that the compiled code can access it.  For example:
\par 
\par \tab\cf1 int _import myvariable ;
\par \cf0 
\par \tab declares myvariable as being imported.  While
\par 
\par \tab\cf1 int _import("mylib.dll") myvariable ;
\par \cf0 
\par \tab declares myvariable as being imported from mylib.dll.
\par 
\par 
\par \tab\tab 
\par \f1 
\par }
410
Scribble410
_interrupt
extended keywords; _interrupt



Writing



FALSE
16
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2240\li2240\ri1480\tx2240\cf1\b\fs32 _interrupt & _fault\cf0\b0\f1\fs20 
\par 
\par \f0\tab Create an interrupt function.  Pushes registers and uses an IRET to return from the function.  For example:
\par 
\par \cf1\tab _interrupt void myfunc() 
\par \tab\{
\par \tab\}
\par \cf0 
\par \tab Creates a function myfunc which can be used as an interrupt handler.
\par 
\par \tab _fault is similar to _interrupt, but also pops the exception word from the stack.  Used when returning from certain processor fault vectors
\par 
\par \f1 
\par }
420
Scribble420
_genbyte
extended keywords; _genbyte



Writing



FALSE
22
{\rtf1\ansi\ansicpg1252\deff0{\fonttbl{\f0\fnil\fcharset0 Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2220\li2220\ri1440\tx2220\cf1\lang1033\b\fs32 _genbyte
\par 
\par \cf0\b0\fs20 
\par \cf1\tab\cf0 Generate a byte of data into the code segment associated with the current function.  For example:
\par \cf1 
\par \tab void myfunc()
\par \tab\{
\par \tab .
\par \tab .
\par \tab .
\par \tab _genbyte(0x90) ;
\par \tab .
\par \tab .
\par \tab .
\par \tab\}
\par 
\par \cf0\tab puts a NOP into the code stream.
\par 
\par \cf1\b\fs32 
\par }
430
Scribble430
_intrinsic
extended keywords; _intrinsic



Writing



FALSE
8
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\ri1480\cf1\b\fs32 _intrinsic\cf0\b0\f1\fs20 
\par 
\par \f0\tab\tab Used by the RTL.  Has no effect for user functions.
\par 
\par \pard\f1 
\par }
440
Scribble440
_loadds
extended keywords; _loadds



Writing



FALSE
14
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2220\li2220\ri1500\tx2220\cf1\b\fs32 _loadds\cf0\b0\f1\fs20 
\par 
\par \f0\tab For an Interrupt function, force DS to be loaded at the beginning of the interrupt. This will be done by adding 0x10 to the CS selector to make a new DS selector.  For example:
\par 
\par \cf1\tab _loadds _interrupt void myfunc() 
\par \tab\{
\par \tab\}
\par 
\par \tab\cf0 will create an interrupt function that loads DS
\par \cf1 
\par \cf0\f1 
\par }
450
Scribble450
_indirect
extended keywords; _indirect



Writing



FALSE
12
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2220\li2220\ri1500\tx2220\cf1\b\fs32 _indirect\cf0\b0\f1\fs20 
\par 
\par \f0\tab turn a direct call into an indirect one.  Not presently used, but could be used to create header files compatible with Microsoft-style exports.  For example:
\par 
\par \tab\cf1 void _indirect myfunc() ;
\par \cf0 
\par \tab Will be called indirectly.  Do not use the indirect keyword on functions with bodies.
\par 
\par \f1 
\par }
460
Scribble460
_export
extended keywords; _export



Writing



FALSE
12
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2220\li2220\ri1500\tx2220\cf1\b\fs32 _export\cf0\b0\f1\fs20 
\par 
\par \f0\tab make an export record for the linker to process.  The current record becomes an entry in the EXE files export table.  For example:
\par 
\par \tab\cf1 void _export myfunc() ;
\par \tab 
\par \tab\cf0 will cause myfunc to be an exported function.
\par 
\par \f1 
\par }
465
Scribble465
typeof
extended keywords; typeof



Writing



FALSE
11
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2220\li2220\ri1480\tx2220\cf1\b\fs32 typeof\cf0\b0\f1\fs20 
\par 
\par \f0\tab the typeof operator may be used anywhere a type declaration is used, e.g. as the base type for a variable or in a cast expression.  It allows you to access the variable's type without explicitly knowing what that type is.  For example:
\par 
\par \cf1\tab long double aa ;
\par \tab typeof(aa) bb;
\par 
\par \cf0\tab declares bb as long double type.\f1 
\par }
470
Scribble470
#pragma error
#pragma directives; error



Writing



FALSE
14
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2220\li2220\ri1460\tx2240\cf1\b\fs32 #pragma error\cf0\b0\f1\fs20 
\par 
\par \cf1\f0 #pragma error  <text>\tab\cf0 allows conditional generation of errors.  For example:
\par 
\par \cf1\tab #ifndef WIN32
\par \tab #pragma error Not a win32 program
\par \tab #endif
\par \cf0 
\par \tab generates a compile time error if the WIN32 macro is not defined.
\par 
\par \f1 
\par }
475
Scribble475
#pragma farkeyword
#pragma directives; farkeyword



Writing



FALSE
12
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2220\li2220\ri1460\tx2220\cf1\b\fs32 #pragma farkeyword\cf0\b0\f1\fs20 
\par 
\par \cf1\f0 #pragma farkeyword  n\tab\cf0 enables or disables the 'far' keyword.  If disabled the far keyword may still be interpreted depending on the ANSI mode, but will be simply ignored.
\par \cf1 
\par \tab #pragma farkeyword 1
\par \cf0 
\par \tab enables the far keyword.
\par 
\par \f1 
\par }
480
Scribble480
#pragma warning
#pragma directives; warning



Writing



FALSE
14
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\ri1460\tx2240\cf1\b\fs32 #pragma warning\cf0\b0\f1\fs20 
\par 
\par \cf1\f0 #pragma warning <text>\tab\cf0 allows conditional generation of errors.  For example:
\par 
\par \cf1\tab #ifndef LONG
\par \tab #pragma warning long type not defined
\par \tab #endif
\par 
\par \cf0\tab generates a compile time warning if the LONG macro is not defined.
\par 
\par \f1 
\par }
490
Scribble490
#pragma startup
#pragma directives; startup



Writing



FALSE
18
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2200\li2200\ri1480\tx2220\cf1\b\fs32 Startup and rundown pragmas
\par 
\par \b0\fs20 #pragma startup <function> <priority>
\par #pragma rundown <function> <priority>
\par \cf0\tab These two directives allow you to specify functions that are automatically executed by the RTL before and after the main program is executed.  The priority scheme allows you to order functions in a priority order.  When the RTL is executing startup or rundown functions it executes all functions at priority 1, then all functions at priority 2, then all functions at priority 3, and so forth.  To have a function executed before your program runs, use #pragma startup, or to have it execute after the program exits, use #pragma rundown.  You should use priorities in the range 50-200, as priorities outside that range are used by RTL functions and their execution (or lack thereof) may prevent some functions in the RTL from working properly.  For example:
\par 
\par \cf1\tab #pragma startup myfunc 100
\par 
\par \cf0\tab runs the function 'myfunc' after the RTL functions have initialized.  Myfunc would be defined as follows:
\par 
\par \cf1\tab void myfunc(void) ;
\par 
\par \cf0\tab Note that #pragma rundown is equivalent to atexit.  
\par 
\par \f1 
\par }
500
Scribble500
#pragma library
#pragma directives; library



Writing



FALSE
8
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2220\li2220\ri1460\tx2240\cf1\b\fs32 #pragma library\cf0\b0\f1\fs20 
\par 
\par \cf1\f0 #pragma library(libname)\tab\cf0 Creates an object file record telling the linker to add 'libname' to the list of libraries to process.
\par 
\par \f1 
\par }
510
Scribble510
#pragma pack
#pragma directives; pack



Writing



FALSE
12
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2240\li2240\ri1500\tx2240\cf1\b\fs32 #pragma pack\cf0\b0\f1\fs20 
\par 
\par \cf1\f0 #pragma pack(n)\tab\cf0 Sets the alignment for structure members and global variables.  The default alignment is 1. Changing the alignment can increase performance by causing variable and structure alignment to optimal sizes, at the expense of using extra memory.  However, altered alignment can sometimes cause problems, for example when a structure is used directly in a network packet or as the contents of a file.
\par 
\par \tab The actual alignment of any given variable depends both on the value of 'n' and on the size of the variable.  CC386 will pick the minimum of the two values for the alignment of any given variable; for example if n is 2 characters will be aligned on byte boundaries and everything else will be aligned on two byte boundaries.  If n is 4 characters will be on byte boundaries, words (short quantities) on two-byte boundaries, and dwords (ints) on four byte boundaries.
\par 
\par \cf1 #pragma pack()\tab\cf0 Resets the alignment to the last selection, or to the default.
\par 
\par \f1 
\par }
530
Scribble530
#pragma aux
#pragma directives; aux



Writing



FALSE
14
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\fi-2220\li2220\ri1480\tx2220\cf1\b\fs32 #pragma aux\cf0\b0\f1\fs20 
\par 
\par \cf1\f0 #pragma aux <funcname> = <alias>
\par \tab\cf0 Creates an alias for a function.  The alias name is substituted for the function name in the OBJ and ASM output files.  For example:
\par 
\par \cf1\tab #pragma aux "myfunc"="mynewname"
\par 
\par \cf0\tab causes the linker to see the function as being called 'mynewname'.
\par \f1 
\par 
\par 
\par }
0
0
0
77
1 Welcome
2 Index=Scribble10
2 Copyright=Scribble12
1 CC386
2 CC386 compiler=Scribble15
2 Command Line
3 CC386 Command Line=Scribble110
3 CC386 Output Control=Scribble235
3 CC386 Warning control=Scribble240
3 CC386 List file control=Scribble250
3 CC386 Preprocesor control=Scribble260
3 CC386 Command line files=Scribble270
3 CC386 Environment Variables=Scribble280
3 CC386 Debug information=Scribble290
3 CC386 Compilation modes=Scribble300
3 CC386 Defining macros=Scribble310
3 CC386 Specifying include path=Scribble320
3 CC386Translating trigraphs=Scribble330
3 CC386 Codegen params=Scribble340
3 CC386 Optimizer Params=Scribble350
2 Keyword Extensions
3 CC386 Extended Keywords=Scribble120
3 _absolute=Scribble360
3 alloca=Scribble363
3 far and near=Scribble365
3 _pascal=Scribble370
3 _cdecl=Scribble380
3 _stdcall=Scribble390
3 _import=Scribble400
3 _interrupt=Scribble410
3 _genbyte=Scribble420
3 _intrinsic=Scribble430
3 _loadds=Scribble440
3 _indirect=Scribble450
3 _export=Scribble460
3 typeof=Scribble465
2 Pragma directives
3 CC386 #pragma directives=Scribble130
3 #pragma error=Scribble470
3 #pragma farkeyword=Scribble475
3 #pragma warning=Scribble480
3 #pragma startup=Scribble490
3 #pragma library=Scribble500
3 #pragma pack=Scribble510
3 #pragma aux=Scribble530
1 CL386
2 CL386=Scribble60
2 CL386 Command Line=Scribble190
1 GREP
2 GREP=Scribble90
2 Grep Command Line=Scribble230
2 Grep Regular Expressions=Scribble232
1 IMAKE
2 IMAKE make utility=Scribble70
2 IMAKE Command Line=Scribble200
1 IMPORT
2 IMPORT Librarian=Scribble42
2 IMPORT Command Line=Scribble172
2 Using the created definition file=Scribble175
1 ITOUCH
2 ITOUCH=Scribble80
2 ITOUCH Command Line=Scribble220
1 MKLIBLST
2 MKLIBLST Library Utility=Scribble45
2 MKLIBLST Command Line=Scribble170
1 NASM
2 NASM assembler=Scribble20
2 NASM Command Line=Scribble140
1 VALX
2 VALX Linker=Scribble30
2 VALX Command Line=Scribble150
1 XLIB
2 XLIB Librarian=Scribble40
2 XLIB Command Line=Scribble160
1 XRC
2 XRC Resource compiler=Scribble50
2 XRC Command Line=Scribble180
6
*InternetLink
16711680
Courier New
0
10
1
....
0
0
0
0
0
0
*ParagraphTitle
-2147483640
Arial
0
11
1
B...
0
0
0
0
0
0
*PopupLink
-2147483640
Arial
0
8
1
....
0
0
0
0
0
0
*PopupTopicTitle
16711680
Arial
0
10
1
B...
0
0
0
0
0
0
*TopicText
-2147483640
Arial
0
10
1
....
0
0
0
0
0
0
*TopicTitle
16711680
Arial
0
16
1
B...
0
0
0
0
0
0
