HelpScribble project file.
10
YNQ`bsg-1N4PNO9R
0
1




TRUE


1
BrowseButtons()
0
TRUE

FALSE
57
10
Scribble10
Index




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\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 \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




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




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\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 
\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




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\cf1\b\fs32 NASM Assembler
\par 
\par \cf0\b0\fs20 The NASM (Netwide) 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 seperate NASM documentation if you need to code assembly language for this assembler.\f1 
\par 
\par \f0 The following help topics are available:
\par 
\par \tab\cf2\strike Command line syntax\cf3\strike0\{linkID=140\}\cf0\f1 
\par }
30
Scribble30
VALX Linker




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\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 
\par \tab\cf2\strike Command Line Syntax\cf3\strike0\{linkID=150\}\cf0\tab 
\par \tab\f0 
\par }
40
Scribble40
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\cf1\b\f0\fs32 XLIB Librarian\cf0\b0\fs20 
\par 
\par \f1 The Xlib librarian is a simple librarian patterened 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 \tab\cf2\strike Command Line Syntax\cf3\strike0\{linkID=160\}\cf0\f0 
\par }
42
Scribble42
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\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 \tab\cf2\strike Command line syntax\cf3\strike0\{linkID=172\}\cf0\f1 
\par }
45
Scribble45
MKLIBLST Library Utility




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\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 
\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 \tab\f1 
\par }
50
Scribble50
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\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 \tab\cf2\strike Command line syntax\cf3\strike0\{linkID=180\}\cf0\f0 
\par }
60
Scribble60
CL386




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\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 \tab\cf2\strike Command line syntax\cf3\strike0\{linkID=190\}\cf0\f1 
\par \cf1\b\fs32 
\par }
70
Scribble70
IMAKE make utility




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\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 \tab\cf2\strike Command line syntax\cf3\strike0\{linkID=200\}\cf0\f1 
\par \cf1\b\fs32 
\par }
80
Scribble80
ITOUCH




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\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 \tab\cf2\strike Command line syntax\cf3\strike0\{linkID=220\}\cf0 
\par \f0 
\par }
90
Scribble90
GREP




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\cf1\b\f0\fs32 GREP\cf0\b0\fs20 
\par 
\par \f1 The GREP utility searches a file or a group of files for any occurance of a specified string.  This
\par 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 \tab\cf2\strike Command line syntax\cf3\strike0\{linkID=230\}\cf0\f0 
\par }
110
Scribble110
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\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 \cf3\strike0\tab\cf2\strike CC386 Output Control\cf3\strike0\{linkID=235\}\cf0\tab 
\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 ANSI mode\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




Writing



FALSE
20
{\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\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 
\par \tab\cf2\strike _absolute\cf3\strike0\{linkID=360\}\cf0 
\par \tab\cf2\strike _cdecl\cf3\strike0\{linkID=380\}\cf0 
\par \tab\cf2\strike _export\cf3\strike0\{linkID=460\}\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\}\cf0 
\par \tab\cf2\strike _intrinsic\cf3\strike0\{linkID=430\}\cf0 
\par \tab\cf2\strike _loadds\cf3\strike0\{linkID=440\}\cf0 
\par \tab\cf2\strike _pascal\cf3\strike0\{linkID=370\}\cf0 
\par \tab\cf2\strike _stdcall\cf3\strike0\{linkID=390\}\cf0\f1 
\par }
130
Scribble130
CC386 #pragma directives




Writing



FALSE
17
{\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\cf1\b\fs32 CC386 #pragma directives\cf0\b0\f1\fs20 
\par 
\par \pard\fi-720\li720\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 \tab\cf2\strike #pragma aux\cf3\strike0\{linkID=530\}\cf0 
\par \tab\cf2\strike #pragma error\cf3\strike0\{linkID=470\}
\par \cf0\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




Writing



FALSE
49
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\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 
\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 \b0\f1\fs20 
\par }
150
Scribble150
VALX Command Line




Writing



FALSE
95
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\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 seperating file names, VALX, will stop and prompt the user for the remaining information.  It is ok to select empty lists or filenames 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 filename:
\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 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 Following is a list of all possible options to VALX:
\par 
\par Abbr     Full
\par Name   Name        \tab   Def                 Description
\par \pard\tx680\tx860\tx860\tx1200\tx2280\tx3420 ----\tab ----------------- \tab ------ \tab    -----------------------------------------------
\par \pard AH   \tab ALignexeheader Yes    \tab\tab Align EXE header to paragraph boundary
\par BDL  \tab buildDll          \tab No     \tab\tab PE files will be dlls.
\par BSZ  \tab BUffersize:n      \tab 32768  \tab\tab Set I/O buffersize (512 - 65,024 bytes)
\par CI   \tab CAseignore       Yes    \tab\tab Linker will ignore the case of symbols
\par CO   \tab COmfile           \tab No     \tab\tab Linker will to produce a .COM file
\par CON  \tab consoleSubSys Yes    \tab\tab PE files will be console apps
\par      \tab CParmaxalloc    0xFFFF \tab Sets max paragraphs needed beyond EXE file
\par DEB  \tab Debug             \tab No     \tab\tab Enable debug information
\par      \tab DEtaillevel       \tab 0      \tab\tab Sets the detail included in the .MAP file:
\par                                0 - Standard link map
\par                                1 - Include Segment header info
\par                                2 - Include Segment header info by module
\par                                3 - Include data map by module
\par                                4 - Include EXE header
\par                                5 - Include fixup info
\par      \tab DOsseg            No     \tab\tab Use Microsoft "DOSSEG" segment ordering
\par      \tab EXechecksum  \tab No     \tab\tab Compute checksum in .EXE header file
\par FA   \tab FileAlign         \tab 8192   \tab\tab File alignment for PE images
\par GHS  \tab GRouphashsize:n   25     \tab Hash size for group symbols (1, 1023)
\par HLP  \tab HElp              \tab No     \tab\tab Produce this information
\par LHS  \tab LNamehashsize:n   25     \tab Hash size for LNAMES symbols (1 - 1023)
\par MP   \tab MAp               \tab No     \tab\tab Produce link map with public symbols
\par NAH  \tab NOALignexeheader  No     \tab Align EXE header to standard page boundary
\par NCI  \tab NOCAseignore   No     \tab\tab Linker will respect case of symbols
\par NCO  \tab NOCOMfile        Yes    \tab\tab Linker will not produce a .COM file
\par NDL  \tab NObuildDLL       Yes    \tab\tab PE files will not be DLLs.
\par NDO  \tab NODOsseg        Yes    \tab\tab Linker will not use DOSSEG ordering
\par NEX  \tab NOEXechecksum Yes    \tab Set checksum in .EXE header file to 0
\par NMP  \tab NOMAp             Yes    \tab\tab Publics not included in link map
\par NOB  \tab NOOBjchecksum Yes    \tab Ignore checksum in .OBJ records
\par NPS  \tab NOpadSegments Yes    \tab\tab Don't pad PE sections
\par NPA  \tab NOPAuse          Yes    \tab\tab No pause before writing executable image
\par NSY  \tab NOSYsfile         Yes    \tab\tab Linker will not produce a .SYS file
\par NST  \tab NOSTatistics     Yes    \tab\tab Linker will not give performance statistics
\par N32  \tab NOUse32          Yes   \tab\tab Linker will not allow 32-bit segments
\par      \tab OBjchecksum    No     \tab\tab Test checksum in .OBJ records
\par      \tab ORder:(text)      none   \tab\tab Segment ordering expression (see below)
\par NPE  \tab NoPE              \tab Yes    \tab\tab Linker will not produce a PE executable
\par OA   \tab ObjectAlign       64K    \tab\tab Object alignment for PE images
\par      \tab PAuse             \tab No     \tab\tab Pause before writing executable image
\par PAS  \tab padSegments    No     \tab\tab Pad PE sections
\par PE   \tab PE                \tab No     \tab\tab Produce a PE executable
\par PH   \tab peHeapSize       65536  \tab\tab Heap size for PE files
\par PHC  \tab peHeapCommit  0      \tab\tab Amount of heap to commit for PE files
\par PHS  \tab PUblichashsize:n  525   \tab\tab Hash size for public symbols (1 - 1023)
\par PIB  \tab peImageBase    \tab 4M     \tab\tab Image base for PE files
\par PS   \tab peStackSize     \tab 128K   \tab\tab Stack size for PE files
\par PSC  \tab peStackCommit  8K     \tab\tab Amount of heap to commit for PE files
\par SHS  \tab SEgmenthashsize:n 25     \tab Hash size for segment (1 - 1023)
\par STD  \tab STACk:n           none   \tab\tab Insure there is a stack of at least n bytes
\par STS  \tab STATistics        No     \tab\tab Produce performance statistics for linker
\par TMP  \tab TEmpfile:(text)  val.tmp \tab\tab Specifies name of linker temporary file
\par WIN  \tab winSubSys       \tab No     \tab\tab PE files will be use WIN32 subsystem
\par 32   \tab Use32             \tab No     \tab\tab Linker will allow 32-bit segments
\par 
\par 
\par \tab\f1 
\par }
160
Scribble160
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\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 + \tab add a file to a lib
\par -\tab delete a file from a lib
\par *\tab extract a file from a lib
\par -+\tab replace a file in a lib
\par 
\par 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 \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 \f1 
\par }
170
Scribble170
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\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




Writing



FALSE
20
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\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 
\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




Writing



FALSE
11
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\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 @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




Writing



FALSE
18
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\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 \b\fs22 /Dname\tab define something
\par /Ipath\tab\tab set include path
\par /foname\tab set name of output file
\par 
\par \f1 
\par }
190
Scribble190
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\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 
\par \b\fs22 /A\tab\tab Enable or disable extensions to ANSI
\par /Dxxx\tab\tab Define something
\par /Ipath\tab\tab Specify include path
\par /Oxxx\tab\tab optimize parameters
\par /q\tab\tab Enable or disable quiet mode
\par /K\tab\tab keep response file
\par /e\tab\tab put errors in file
\par /l\tab\tab make listing file
\par /w-xxx\tab\tab disable a warning
\par /e=name \tab set name of EXE file
\par /a\tab\tab generate .asm file
\par /Ennn\tab\tab max number of errors
\par /Lpath\tab\tab specify lib directory
\par /Cxxx\tab\tab codegen parameters
\par /k\tab\tab keep generated files
\par /m\tab\tab generate a map file
\par /i\tab\tab dump preprocessed file
\par /n\tab\tab ignore default lib and OBJ files
\par /v\tab\tab debug info
\par /c\tab\tab generate obj file
\par \b0\f1\fs20 
\par }
200
Scribble200
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\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 
\par \b\fs22 -e\tab\tab macros derived from environment variables cannot be overridden
\par \tab\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 \pard\fi-1440\li1440\tab\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 \pard 
\par -h\tab\tab command line help
\par 
\par -i\tab\tab ignore return status of executed programs
\par \tab\tab i\b0\fs20 make will keep going even if something fails
\par \b\fs22 
\par -m\tab\tab display time stamps
\par \tab\tab 
\par -n\tab\tab test mode
\par \tab\tab\b0\fs20 imake will evaluate the targets, without actually executing any programs listed for execution
\par \b\fs22 
\par -p\tab\tab dump database of definitions and targets
\par \tab\tab\b0\fs20 imake will dump all the information it has gathered after processing the file\b\fs22 
\par 
\par -r\tab\tab don't run builtins.mak
\par \pard\fi-1440\li1440\b0\fs20\tab\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 \pard\fi-1400\li1400\b 
\par \pard\fs22 -s\tab\tab suppress display of commands being executed
\par \tab\tab\b0\fs20 quiet mode\b\fs22 
\par 
\par -B\tab\tab full build
\par \b0\tab\tab ignore time stamps and fully evaluate every node which is a dependency of the listed targets
\par 
\par \b -Dxxx\tab\tab define something
\par \b0\fs20\tab\tab make a macro definition
\par 
\par \b\fs22 -I\tab\tab set include directory
\par \tab\tab\b0\fs20 set directory for files included in the makefile
\par 
\par \b\fs22 -K\tab\tab keep intermediate files
\par 
\par -Uxxx\tab\tab prevent XXX from being defined
\par \tab\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




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 wildcards.
\par 
\par ITOUCH has the following options:
\par 
\par \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




Writing



FALSE
21
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\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] list of files
\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 /f\tab load expression from file
\par /h\tab don't print file names
\par /l\tab print file name when only one file
\par /n\tab print line number if /l isn't set
\par /v\tab show nonmatching lines
\par /y\tab case insensitive matching
\par \f1 
\par }
235
Scribble235
CC386 Output Control




Writing



FALSE
38
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\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 \f0 /c\tab generate object file only
\par 
\par \pard\fi-700\li700\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 \pard 
\par /o  \tab set output file name
\par 
\par \pard\fi-720\li720\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 \pard 
\par \tab\cf1 CC386 /ohi hello.c
\par 
\par \cf0\tab generates an EXE file called HI.EXE.
\par \b\fs22 
\par /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 \tab /Wd\tab - generate a WIN32 DLL program
\par \tab /Wdc\tab - generate a WIN32 DLL program, use CRTDLL runtime library
\par \tab /Wc\tab - generate a WIN32 console program
\par \tab /Wcc\tab - generate a WIN32 console program, use CRTDLL runtime library
\par \tab /Wg\tab - generate a WIN32 gui program
\par \tab /Wgc\tab - generate a WIN32 gui program, use CRTDLL runtime library
\par \tab /We\tab - generate an MSDOS program
\par \f1 
\par \f0\tab\cf1 CC386 /Wcc hello.c
\par 
\par \tab\cf0 generates a win32 console program hello.exe, which will use the CRTDLL runtime library.\f1 
\par }
240
Scribble240
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\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 \pard\fi-720\li720\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 \pard 
\par \b\f1\fs22 +Q\tab Quiet mode
\par \b0\f0\fs20 
\par \pard\fi-720\li720\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 \pard\b\f1\fs22 /w-xxx\tab disable warnings
\par \b0\f0\fs20 
\par \pard\fi-720\li720\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 \pard 
\par \b\f1\fs22 /E[+]nn\tab error control
\par \b0\f0\fs20 
\par \pard\fi-720\li720\tab nn is the maximum number of errors before the compile fails; if + is specifed 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




Writing



FALSE
13
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\cf1\b\fs32 List file control\cf0\b0\f1\fs20 
\par 
\par \b\fs22 +l\tab create a listing file 
\par 
\par \pard\fi-720\li720\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 \pard\fi-1440\li1440 
\par }
260
Scribble260
CC386 preprocesor control




Writing



FALSE
13
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\cf1\b\fs32 Preprocesor file control\cf0\b0\f1\fs20 
\par \b\fs22 
\par +i\tab create a file with preprocessed text.\b0\f0\fs20   
\par 
\par \pard\fi-720\li720\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 \pard\cf1\b\f1\fs22\tab\b0\fs20 CC386 +i myfile.c\b\fs22 
\par 
\par \pard\fi-720\li720\cf0\b0\f0\fs20\tab results in myfile.i
\par \pard\fi-1440\li1440 
\par }
270
Scribble270
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\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 \pard\fi-700\li700\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 \pard\f1 
\par }
280
Scribble280
CC386 environment variables




Writing



FALSE
10
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\cf1\b\fs32 Environment variables\cf0\b0\f1\fs20 
\par 
\par \f0 CC386 supports two environment variables you may set to default compiler options.  These are:
\par 
\par \cf1 CCINCL\cf0  - sets a default path for the -I switch.  You may additionall use the -I switch to set further \tab paths\tab 
\par \cf1 CC386\cf0\tab - CC386 will parse this variable prior to parsing the command line.  Switches in this variable \tab will take effect just as if they were present on the command line or in a command line file.\tab\f1 
\par 
\par }
290
Scribble290
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\cf1\b\fs32 Debug information\cf0\b0\f1\fs20 
\par 
\par \b\fs22 +v\tab Put debug information in the output file
\par 
\par \pard\fi-720\li720\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 \pard 
\par \tab\cf1 CCIDE +v myfile.c
\par 
\par \cf0\tab Puts debug information in the object file.
\par 
\par \pard\fi-700\li700\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 ANSI mode




Writing



FALSE
12
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\cf1\b\fs32 ANSI mode\cf0\b0\f1\fs20 
\par 
\par \b\fs22 +A\tab disable non-ansi extensions
\par 
\par \pard\fi-720\li720\b0\f0\fs20\tab By default the compiler allows several extensions to ansi, to make coding easier.  If you want strict adherance to ansi, use this switch.  For example:
\par 
\par \cf1\tab CC386 +A myfunc.c
\par 
\par \cf0\tab will enable ANSI mode
\par }
310
Scribble310
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\cf1\b\fs32 Defining macros\cf0\b0\f1\fs20 
\par 
\par \b\fs22 /Dxxx\tab define a macro
\par 
\par \pard\fi-720\li720\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 \pard 
\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




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 Specifying include path\cf0\b0\f1\fs20 
\par 
\par \b\fs22 /Ipath\tab specify include path.  
\par 
\par \pard\fi-700\li700\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 \pard\fi-1460\li1460 
\par }
330
Scribble330
CC386Translating trigraphs




Writing



FALSE
12
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\cf1\b\fs32 Translating trigraphs\cf0\b0\f1\fs20 
\par 
\par \b\fs22 /T\tab Translate trigraphs
\par 
\par \pard\fi-720\li720\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




Writing



FALSE
59
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\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-700\li700\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.\tab 
\par \pard 
\par \tab +d\tab display diagnostics
\par 
\par \pard\fi-1420\li1420\tab\tab displays memory diagnostics, and some indication of what internal errors have occurred
\par \pard 
\par \tab -b\tab merge BSS with initialized data 
\par \tab\tab 
\par \pard\fi-1420\li1420\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 uninitialzed 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 \pard\tab -l\tab don't put C source in the ASM file
\par 
\par \pard\fi-1420\li1420\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 \pard 
\par \tab -m\tab don't use leading underscores
\par 
\par \pard\fi-1420\li1420\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 \pard 
\par \tab +r\tab reverse order of bit operations
\par 
\par \pard\fi-1420\li1420\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 \pard 
\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 \pard\fi-1440\li1440\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 \pard 
\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 +S\tab add stack checking code
\par \tab\tab 
\par \pard\fi-1420\li1420\tab\tab This switch adds calls to the run-time library's stack checking code.  If the stack overruns, an error is generated.
\par \pard 
\par \tab +T\tab generate TASM assembler file
\par 
\par \tab +Z\tab add profiler calls
\par \f1 
\par \pard\fi-1420\li1420\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 \f1 
\par }
350
Scribble350
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\cf1\b\fs32 Optimizer Parameters\cf0\b0\f1\fs20 
\par 
\par \b\fs22 /Oparams\tab Specify optimizer parameters.
\par \pard\fi-700\li700\b0\f0\fs20 
\par \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.\tab 
\par \pard\tab 
\par \tab +a\tab do peephole optimazation on inline assembly code
\par 
\par \pard\fi-1440\li1440\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 \pard 
\par \tab +i\tab inline intrinsic functions instead of calling the RTL
\par 
\par \pard\fi-1420\li1420\tab\tab some functions such as strcpy and strlen may be inlined into the code rather than called as part of the runtime library.
\par \pard 
\par \tab -m\tab don't merge matching constants
\par 
\par \pard\fi-1420\li1420\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 \pard\tab -p\tab turn off peephole optimizations
\par 
\par \pard\fi-1440\li1440\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 \pard\tab -RA-RD turn off register optimization
\par 
\par \pard\fi-1440\li1440\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




Writing



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




Writing



FALSE
12
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\cf1\b\fs32 _pascal\cf0\b0\f1\fs20 
\par \pard\fi-1440\li1440\f0\tab\tab 
\par \tab\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\tab\cf1 void _pascal myfunc() ;
\par \cf0 
\par \tab\tab Creates a function myfunc with pascal linkage.
\par 
\par \pard\f1 
\par }
380
Scribble380
_cdecl




Writing



FALSE
12
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\cf1\b\fs32 _cdecl\cf0\b0\f1\fs20 
\par \pard\fi-1440\li1440\f0 
\par \tab\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 \pard 
\par \tab\tab\cf1 void _cdecl myfunc() ;
\par \cf0 
\par \tab\tab creates a function myfunc with standard linkage.
\par 
\par \f1 
\par }
390
Scribble390
_stdcall




Writing



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




Writing



FALSE
18
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\cf1\b\fs32 _import\cf0\b0\f1\fs20 
\par 
\par \pard\fi-1440\li1440\f0\tab\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\tab\cf1 int _import myvariable ;
\par \cf0 
\par \tab\tab declares myvariable as being imported.  While
\par 
\par \tab\tab\cf1 int _import("mylib.dll") myvariable ;
\par \cf0 
\par \tab\tab declares myvariable as being imported from mylib.dll.
\par 
\par 
\par \tab\tab 
\par \pard\f1 
\par }
410
Scribble410
_interrupt




Writing



FALSE
14
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\cf1\b\fs32 _interrupt\cf0\b0\f1\fs20 
\par 
\par \pard\fi-1440\li1440\f0\tab\tab Create an interrupt function.  Pushes registers and uses an IRET to return from the function.  For example:
\par \pard 
\par \cf1\tab\tab _interrupt void myfunc() 
\par \tab\tab\{
\par \tab\tab\}
\par \cf0 
\par \pard\fi-1340\li1340\tab\tab Creates a function myfunc which can be used as an interrupt handler.
\par 
\par \pard\f1 
\par }
420
Scribble420
_genbyte




Writing



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




Writing



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




Writing



FALSE
14
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\cf1\b\fs32 _loadds\cf0\b0\f1\fs20 
\par 
\par \pard\fi-1440\li1440\f0\tab\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\tab _loadds _interrupt void myfunc() 
\par \tab\tab\{
\par \tab\tab\}
\par 
\par \tab\tab\cf0 will create an interrupt function that loads DS
\par \cf1 
\par \pard\cf0\f1 
\par }
450
Scribble450
_indirect




Writing



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




Writing



FALSE
12
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\cf1\b\fs32 _export\cf0\b0\f1\fs20 
\par 
\par \pard\fi-1440\li1440\f0\tab\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\tab\cf1 void _export myfunc() ;
\par \tab 
\par \tab\tab\cf0 will cause myfunc to be an exported function.
\par 
\par \pard\f1 
\par }
470
Scribble470
#pragma error




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 #pragma error\cf0\b0\f1\fs20 
\par 
\par \cf1\f0 #pragma error  <text>\tab\tab\tab 
\par \cf0\tab 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 }
480
Scribble480
#pragma warning




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 #pragma warning\cf0\b0\f1\fs20 
\par 
\par \cf1\f0 #pragma warning <text>
\par \cf0\tab 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




Writing



FALSE
18
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\cf1\b\fs32 Startup and rundown pragmas
\par 
\par \b0\fs20 #pragma startup <function> <priority>
\par #pragma rundown <function> <priority>
\par \pard\fi-700\li700\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 \pard 
\par \f1 
\par }
500
Scribble500
#pragma library




Writing



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




Writing



FALSE
14
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\cf1\b\fs32 #pragma pack\cf0\b0\f1\fs20 
\par 
\par \cf1\f0 #pragma pack(n)
\par \pard\fi-700\li700\cf0\tab 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 \pard 
\par \pard\fi-720\li720\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 \pard 
\par \cf1 #pragma pack()
\par \cf0\tab Resets the alignment to the last selection, or to the default.
\par 
\par \f1 
\par }
530
Scribble530
#pragma aux




Writing



FALSE
14
{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil Arial;}}
{\colortbl ;\red0\green0\blue255;}
\viewkind4\uc1\pard\cf1\b\fs32 #pragma aux\cf0\b0\f1\fs20 
\par 
\par \cf1\f0 #pragma aux <funcname> = <alias>
\par \pard\fi-720\li720\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 \pard\f1 
\par 
\par 
\par }
0
0
0
0
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
