Glossary - common terms used in fbc development

FreeBASIC

previous page next page
Glossary - common terms used in fbc development
 
arg, argument
An expression passed to a parameter in a procedure call.

cast
A type cast changes the compile-time data type of an expression and either causes a conversion (e.g. float <-> int) or a reinterpretation of the expression value's bit representation (e.g. integer <-> uinteger).

comp, compound
  • Compound blocks in the language: Any code block that allows nested code such as IF blocks, SCOPE blocks, NAMESPACE blocks, etc. is called a compound.
  • Compound symbols: UDTs, sometimes also namespaces, because both may contain nested (namespaced) symbols and they share some common code.

conv, conversion
A conversion is an operation that translates between two different representations of the same value (e.g. float <-> int, or 32bit <-> 64bit).

cast and conv are often used interchangeably in the compiler sources. For example, the AST's CONV nodes represent type casts, no matter whether they perform conversions or not.

Some (but not all) casts require run-time conversions, for example:
short <-> integer
single <-> integer
single <-> double

Simple casts between types of equal class and size do not require a run-time conversion, because the bit representation wouldn't change anyways. For example:
short <-> ushort
integer <-> uinteger
These are also called noconv casts.

ctor, constructor
  • UDT constructor
  • module constructor

ctx, context
UDTs/"classes" in the fbc sources for holding global information shared amongst multiple procedures or modules.

desc, descriptor
  • Dynamic string descriptor
  • Dynamic array descriptor

dtor, destructor
  • UDT destructor
  • module destructor

fbc
  • The FreeBASIC compiler project as a whole, the Git repository, the project registered on Sourceforge
  • The compiler program binary/executable (fbc or fbc.exe), as built from the compiler sources
  • The compiler's main module/frontend/driver

fbctinf
FB compile-time information, also see objinfo.

fbgfx
FB graphics, usually referring to the use of FB's built-in graphics keywords, implemented in gfxlib2

frontend stage 1
Compilation of the .bas input files into the next intermediate format: .asm (-gen gas), .c (-gen gcc) or .ll (-gen llvm)

frontend stage 2
Compilation of the .c (-gen gcc) or .ll (-gen llvm) intermediate files into .asm files. (doesn't apply to -gen gas because there the FB compiler generates .asm itself directly)

function
A procedure with result value; sometimes also used in place of procedure, as in C.

gfxlib2
The FB graphics runtime library implementation from the fbc project.

hashtb
A hash table, often used together with a symbol table to allow fast lookup of the symbols in that symbol table.

libfb, libfbmt, libfbgfx, libfbgfxmt
Names of the libraries built from the rtlib/gfxlib2 sources. Libraries named lib*mt are the thread-safe versions of their lib* counterparts. They are built with the ENABLE_MT #define.

local
  • Sometimes: A variable allocated on stack
  • Any symbol in a nested scope, not the global/toplevel namespace. Scoped static variables also have the FB_SYMBATTRIB_LOCAL attribute, even though they are not allocated on stack.

method
  • A member-procedure with THIS parameter. Static member-procedures (those without the THIS parameter) do not have FB_SYMBATTRIB_METHOD.
  • Sometimes: Any member-procedure, with or without THIS parameter

noconv cast
A cast that does not require a conversion.

normal build
Described here: Normal vs. Standalone

objinfo
See DevObjinfo

param, parameter
Procedure parameters as declared in procedure DECLARE statements or bodies.

paramvar
For each parameter, the compiler will create a corresponding local variable in the procedure's scope, allowing the parameters to be accessed by user code.

proc, procedure
Any sub or function, including constructors/destructors, operator overloads, property setters/getters.

standalone build
Described here: Normal vs. Standalone

static
  • static variable allocation: on the heap instead of the stack, but still scoped -- also see local.
  • static member variables: are actually externs.
  • static member procedures: member-procedures without a THIS parameter, also see method.
  • "static array" is often used in place of "fixed-size array" (QB language)

struct, structure
TYPE or UNION, also known as struct/union in C.

sub
A procedure without result (with VOID result).

symtb
A symbol table: owns a linked list of FBSYMBOL in a specific scope. This is where FBSYMBOLs live.

rtlib
The FB runtime library implementation from the fbc project

UDT, user-defined type
TYPEs/UNIONs/ENUMs, sometimes just TYPEs/UNIONs.

vreg
Virtual registers are used when emitting the AST. The AST creates a vreg for the operands and results of all operations that make up the input program. Each backend emits them differently:
    • The ASM backend actually maps the vregs to real registers and also re-uses them as they become free again. The vregs then also let the x86 code emitter know which exact registers are used.
    • The C backend sometimes emits vregs as temporary variables, sometimes simply inserts the expression whose result is represented by a vreg in place of that vreg's first use.
    • The LLVM backend simply emits each vreg as a numbered intermediate value.
Since the C/LLVM backends don't re-use vregs, the vregs are almost in static-single-assignment form; although not quite because there still are self-operations etc. produced by the AST which don't take SSA form into account.


previous page start next page