From FTE
Jump to: navigation, search

Beginner's guide:
Grab fteqccgui. Associate it with your .src files or just run it from your sourcedir.
The first line of your .src file typically names the .dat file to be written as the result of the compiler. Note that you can specify relative paths here. There is no need to copy the .dat around (yes, people don't always realise this).
Once your mod is compiling and spitting the .dat file out to the correct game path, click the debug button and tell it where your basedir (ie: quake dir, not your mod's gamedir). Also select a recent version of fteqw (other engines do not support debugging, sadly).
Click the margin to set a breakpoint. f5 to resume, f11 to single step, etc. Check the menus for other shortcut keys.

What makes fteqcc different from id's qcc

  • pointers
  • structs
  • classes
  • debugger, with engine interaction (in the gui version)
  • self.somevector = [a, b, c+d]; for example, can be used to construct vectors.
  • warnings for just about everything
  • "local" is not required before local variables
  • semicolon after function body is optional
  • redundant semicolons at file scope are allowed
  • empty statements are allowed
  • empty curly braces are allowed
  • C-style function declarations and definitions are allowed
  • hexadecimal numeric constants are understood
  • varargs builtin functions with some required parms are supported.
e.g. "void bprint(float level, string s, ...)"
  • Supports working nested function calls.
  • Supports code like this: a = a-5;
  • Supports a bucket load of warnings. It's still possible to make a progs without default warnings.
  • Support for arrays
float anarray[64];
for (i = 0; i < 64; i++)
    anarray[i] = somecomplexfunction(i);
blah = anarray[floor(random()*64)];
  • preprocessor functionality:
    • Defines
#define <name> [<value>]
creates a new define - value is optional
#undef <name>
delete an existing define
#define name(a,b) ((a)*(b))
creates a new macro which multiplies a and b. Consider it as a function call
this is usable to create inline functions, eg: #define crandom() (random()-0.5)*2
  • Reserved Defines
the internally defined FTEQCC is always present and can be used to detect the compiler, e.g.
#ifndef FTEQCC
#error "Code may only be compiled with fteqcc!"
  • Conditional expressions for defines (nested conditions are allowed):
#ifdef <name>
    <statements if name is defined>
    <statements if name is not defined>
#ifndef <name>
    <statements if name is not defined>
    <statements if name is defined>
The #else cases are optional;
  • Message-Output
#error "<Error Message>"
print out the given message and stop the compilation.
#message "<Normal Message>"
#pragma message "<Normal Message>"
(synonyms) prints out the given message and continue compilation
#warning "<msg>"
#pragma warning "<msg>"
Displays a warning in a consistant way.
  • The copyright pragma
#pragma copyright "<blah>"
Causes text output into the progs just after the header. This will be the first thing anyone is able to read when opened in a text editor.
This is really useful when you have many targets all with the same filename.
  • The target pragma
#pragma target <targetname>
Targets supported:
  • H2 Hexen2 compatable output. Note that fteqcc is able to compile hexenc code. This target must be specified (normally on the commandline) for hexen2 engines to function properly.
  • KK7 (mostly) 32 bit output which is compatable with kkqwsv.
  • FTE FTE specific target. The advantage of this target is down to additional operations and thus many optimisations
  • FTE32 32 bit form of the FTE target. This allows much larger output files as well as the same operations added for the FTE target
  • Standard The default.
Note that switching targets on the fly is not always possible (and certainly not recommended).
Any switching of targets should be done before any functions or definitions are found.
  • The progs_dat pragma
#pragma progs_dat "../progs.dat"
Allows you to change the name of the produced progs file mid compilation.
If the first non-comment characture of the progs.src file is a #, progs.src is treated as a .qc file, and this pragma is required.
This is useful for small mods or addons. It is advised to use this pragma to specify.
  • #include precompiler directive:
#include "blah.qh"
  • #eof
Causes fteqcc to ignore any following lines in the current file.
  • The warning pragma
This pragma allows you to disable/enable display of various warnings
#pragma warning disable Q120
Will disable the warning for unrecognised pragmas.
#pragma warning disable Q201
Will disable the assignment in conditional warnings.
#pragma warning disable Q205
Will prevent warnings about hanging ; charactures (indications of additional ones, eg: if (blah); )
#pragma warning disable Q302
Will prevent fteqcc from warning when variables were not used.
  • Limits for preprocessor defines:
  • max. 2048 defines are allowed
  • in progs.src only allowed after first valid line (after definition of the output filename)
  • defines may not only be used in #ifdef conditions but can also be expanded from anywhere.
  • the stringify macro operator (#) and the concatenate macro operator (##) are supported, but only in macros.
  • Support for c-like switch statements
case 0:
case 1:
  • Support for c-like 'for' statements, with continue and break.
For statements are similar to while statements, though with a small difference

Think of a for statement and for ( <initialisation> ; <while> ; <increment> ) {dostuff();} The initialisation is done straight away, and only once. The code then loops until <while> becomes false.

Each time the end of the statement block is encountered, the <increment> is executed.
Thus to call a function 5 times, use this: for (i = 0; i < 5; i++) dostuff();
  • Support for += -= /= *= operations.
  • Support for both prefix and postfix forms of ++ and --.
  • Support for gotos.
Note that gotos are evil and should only be used as a last resort. :)
  • More optimisations than any other qc compiler.
  • Enhanced $frame macros.
  • $framevalue X specifies the next value for a $frame
Useful for defining separate frames for different models within the same qc file.
  • $framesave x saves off the current next value
Saves the nextmacro value to a name for restoring later.
  • $framerestore x restores a saved framemacro next.
Restores the nextmacro value from a name. This is useful when you have multiple models with some identical frames.
  • $flush wipes all macros, and all saved indexes.
  • if not flushed, frame macros can be used in subsequent qc files.
  • Straight forward Multiple-Document Interface for simpler browsing of code.