The level of access associated with Type or Class members. Public members are accessible to any code; protected members are accessible to member functions and any derived Type or Class member functions; private members are accessible only to member functions of that Type or Class. By default, Type members have public access rights, while Class members are private.

A variable or expression that points to a memory address where it is not known, at least from the compiler's point of view, what type of data is stored at that address. In C this would be the same as a void pointer or (void *). See Ptr.

An archive is a group or files or a single file packed into a container format and usually compressed before or afterward. Typical container formats are GNU Tar and Zip. Typical compression formats are Gzip and Zip.

Data that is passed to a procedure. The procedure refers to this data using the parameter(s) in it's parameter list.

The method in which arguments are passed to procedures, being either By Reference or By Value. See Passing Arguments to Procedures.

A collection of data whose elements are stored contiguously in memory (one after the other, in increasing order). Because of this, an array offers random-access to it's elements (any element can be accessed at any time). Insertion or removal of elements anywhere but at the back of the container requires that those elements that follow be relocated, so a linked-list is typically preferred when insertion or removal needs to be efficient.

A component in the tool chain for translating source code in to executable programs. The assembler converts the low level assembly instruction mnemonics emitted by the compiler to object code.

Assignment is one of the fundamental operations of computing. All it means is copying a value into the memory location pointed at by a variable. The value might be a literal, another variable, or the result of some expression. For an instance of a Type or Class, this involves calling one of it's assignment operators. Not to be confused with initialization.

Refers to storage on the call stack. Local procedure variables, objects and arrays with automatic storage are allocated when the procedure is called, initialized when defined, destroyed (in the case of objects) when leaving the scope they're declared in and deallocated when returning from the procedure.

A variable, object or array with automatic storage.

ByRef specifies passing arguments to procedures by reference. Arguments passed by reference can be modified by the procedure and the changes seen by the caller.

ByVal specifies passing arguments to procedures by value. Procedures receive a copy of the argument passed. With Type or Class instances, this involves instantiating temporary objects by calling their copy constructor. These temporaries are destroyed upon procedure exit.

Binaries are the end result of source code. Binaries include executable files (.exe on windows), static library files (.a), dynamic library files (.dll on windows, .so on Linux), and relocatable object files. (.o)

The part of the executable program that will contain zero bytes only when the program starts. Since all of the bytes are zero, the final size of the executable can often be reduced by placing uninitialized data, or zero initialized data in this section.

A region of memory that allows data to be saved or manipulated before being copied somewhere else. In a communications device this may hold incoming or outgoing data yet to be processed. In graphics, a buffer may contain an image before being copied to the screen.

A control mechanism where a caller lets a procedure call another procedure (the call back) provided by the caller typically through a function pointer.

A chunk of memory reserved for a process or thread that is used as a stack for storing various information needed by procedures when they are called. Among the information stored on the call stack are all of the local automatic variables, objects and array data and usually whatever parameters are passed to the procedure. These items are allocated (pushed onto the call stack) when the procedure is called and deallocated (popped from the call stack) when the procedure returns, either by the caller or the callee, depending on the calling convention used. The initial and maximum sizes of this reserved memory vary by platform.

A misnomer used to refer to the point in code in which a procedure is called.

A cast operation changes one data type to another using specified rules. A Type structure can implement a custom Cast for any intrinsic data type, and/or other TYPEs, See Cast.

Several lines of source code grouped together all sharing at least one common scope. For example a procedure's code block will be all the lines of code between Sub and End Sub.

A short name for serial communications port. A program can communicate with an external device, such as modem or another computer through a com port. See Open Com.

A compiler is a computer program which takes source code and transforms it into machine or object code.

These are instructions included in the text of the program that affect the way the compiler behaves. For instance the compiler might be directed to include one section of code or another of depending on the target operating system.

A statement composed one or more additional statements. Typically, a compound statement has a beginning (opening statement), a middle (a statement block) and an end (closing or ending statement), while some have additional parts. Examples of compound statements would be If and Function.

A symbol that retains a consistent value throughout the execution of the program. See Const.

A special type of module-level procedure that is automatically called prior to the module-level code flow. See Constructor (Module).

A special member function of a Type or Class that is called when an object is instantiated.

Concurrent Versions System. The file manager implemented at Sourceforge where sources are stored, it keeps the history of the changes introduced by the developers. Used by FB in the past. (see also SVN)

The part of the executable program that will data that can be changed while to program is running.

A program that allows controlled execution of compiled code. The values of variables can be tracked, execution can be paused, stepped or accelerated, etc. A debugger is typically used to help find the source of programmer errors in source code, called 'bugs'.

A source code statement that introduces a symbol, constant, variable, procedure, data type, or similar, to the compiler but not necessarily allocate any space for it. See Dim, Declare, Extern, Type.

A source code statement (or statements) that allocates space for data or code. For example, Sub defines a procedure by allocating space for the program code it will contain. Some statements can be both a declaration and a definition. For example, Dim both declares and defines a variable.

The act of obtaining a value from memory at a given address. See Operator * (Valueof), Pointers.

Refers to the internal data structure used by the compiler and runtime library for managing variable length strings and arrays.

The act of deconstructing and deallocating memory for an object instance. When an object is destroyed, it's destructor is called. This happens automatically when an object goes out of scope, or when Delete is called with a pointer to an object.

A special type of module-level procedure that is automatically called at program termination. See Destructor (Module).

A special member function of a Type or Class that is called when an object is destroyed.

Shorthand for dynamically linked library.

A method / standard allowing to execute protected mode code (mostly also 32-bit) on a 16-bit real mode DOS kernel. Affects only DOS version of FreeBASIC. See also DOS related FAQ

A complete 32-bit C/C++ development system for Intel 80386 (and higher) PCs running DOS and includes ports of many GNU development utilities.

A file containing executable code that is loaded by another application when it is started. Also referred to as a dll or shared library. See Shared Libraries (DLLs).

A data type restricted to a sequence of named values given in a particular order. See Enum.

A binary file that can be run. It consists of libraries and object files bound together by the linker.

When called inside a procedure, leaves the procedure and returns control to the calling program.

An instruction to execute a statement that will evaluate/return a value.

Commonly refers to a data member in a Type or Class.

An integer associated with an open file or device as given in Open. All subsequent operations on the opened file or device must use the same file number.

A sequence of characters that controls how data should be presented. See Format, Print Using.

A procedure defined using Function, optionally taking parameters and returning a value.

A variable containing the address of a function. The address (function) to which the variable points can be changed while the program is running allowing for dynamic program flow, such as call back functions.

See: Image Buffer. An image buffer in FreeBASIC's native format.

A graphics primitive is another term for common shapes like circles and rectangles.

A variable that is visible to all procedures within a module, across multiple modules, or both. See Common and Extern.

A mass collaboration project with the primary goal to provide a free and non-proprietary Unix-like operating system.

Short hand for GNU General Public License: a free, copyleft license for software and other kinds of works.

A data structure that associates keys with values allowing for efficient look-up of values based on a given key.

When talking about a collection of data, this is generally the first part of that data that describes the rest. When talking about (header) files, this refers to an include file. In FreeBASIC the file extension '.bi' is usually used.

The area of memory (free store) provided by the runtime library (and operating system) from which the program can dynamically allocate memory. See Allocate.

A collection of data used to describe an image, containing such information as width, height, color depth and pixel data.

A kind of source file that typically contains type definitions and declarations for variables and procedures that one or more other source files refer to. In general, these files provide a public interface to some module or modules, although a file that is #included can contain any text whatsoever.

The act of giving a variable a value at the point of it's creation. For object instances, this involves calling one of it's constructors. Not to be confused with assignment, which gives an already existing variable another value.

An instantiated object of a Type or Class.

The act of creating an object of a Type or Class, either directly with Dim, or indirectly by, for example, passing an object to a procedure by value.

Compiled code stored in a single file that can be used when making other programs. A library typically has one or more headers (or include files) to provide all the needed declarations for using the library.

A collection of data whose elements are typically stored on the heap. The linked list's elements store the addresses of their adjacent elements, and so only sequential access (an element is accessed by following the links from adjacent elements) is possible. This scheme does provide constant-time insertion of elements anywhere into the container, however, and because of this is often preferred over the array.

A program which combines a number of programs to form a complete set of instructions which can be loaded into the computer's memory and followed by the computer.

Shorthand for GNU Lesser General Public License. Like the GNU GPL, but more permissive allowing non-(L)GPL'd works to be statically linked to the LGPL'd work, provided that the new work can have the LGPL'd portion relinked or replaced.

A variable that is visible only within the scope in which it is declared, and that is destroyed when program execution leaves that scope.

A synchronization mechanism such that only one thread or process can have access to a shared object, for example a global variable, a device, or a file.

A data field, procedure, enumeration, type alias or anything else declared within a Type or Class definition.

Variables associated with a Type or Class. Member data can be static or non-static.

A procedure associated with a Type or Class. Member functions have full access rights to the members of it's type or class, and can be static or non-static.

See member function.

A source file in it's entirety, including any include files that may be present as well. Typically, a module is a logical unit of code, containing parts of a program that relate to one another. For example, if making a game, one may separate the procedures needed for error logging from the procedures that control graphics into their own modules.

Member data that each instance of a Type or Class gets their own copy of.

A member function that has an implicit This reference as an argument.

A constant usually associated with pointers denoting a 'nothing' value. This value is typically an integer '0' (zero) - the 'NULL terminator' appended to zstrings is chr(0), or asc(!"\0") - but can also be defined as a pointer type, like Cast(any ptr, 0).

Code in machine-readable form that can be executed by your computer's CPU and operating system, usually linked with libraries to create an executable file.

One of the arguments passed to an operator. For example, in the expression a = b + c, the operands are a, b and c, while the operators are = and +.

A function taking one or more operands (arguments) and returning a value. Operators can work on built-in data types, or can be overloaded to work on user defined types. See Operators.

To declare a procedure having the same name as another, but with different parameters. Free functions, or module-level functions, can be overloaded using the Overload keyword. Type or Class member functions can be overloaded by default.

A buffer used for holding the contents of the screen before being displayed on screen. Where multiple page buffers are allowed, one page will be visible to the users while all others are hidden. Also the active page (the one to which changes are made) need not be the visible one allowing changes to one page while showing another.

The name used by a procedure that corresponds to the argument that is passed to it.

The parenthesized comma-separated list of parameters in a procedure declaration or definition.

Professional Development System. Sometimes referred to as QB7.1.

The number of bytes per row, in an image or screen buffer. If there is no padding between rows, then this can be calculated by width * bytes_per_pixel, but this is not necessarily safe to assume. The screen's pitch can be found using ScreenInfo, and an image buffer's pitch can be found by checking the pitch value in the image's header.

A data type used to hold addresses. The kind of pointer determines how the data at the address is interpreted when the pointer is dereferenced, or when used with Operator -> (Pointer To Member Access). See Pointers.

The FreeBASIC preprocessor is responsible for expanding Macros and replacing Defined values with their values.

A generic name for any block of code that can be called from somewhere else in a program. See Sub, Function.

A property is a special sort of type/class members, intermediate between a field (or data member) and a method. See Property.

Shorthand for pointer. See pointer.

A collection of data that offers first-in first-out (FIFO) storage and retrieval. Typically, elements can only be inserted at the back and removed from the front but can be accessed from either end.

A ragged array is an array having rows of differing lengths.

Any positive or negative number including fractions, irrational and transcendental numbers (like pi or e) and zero. Variables containing a real number have a limited range and precision depending on the number of bits used to represent the number. See: Single and Double.

Places inside the CPU for data storage. 80386 and compatible 32-bit models have EAX, EBX, ECX, EDX, ESI, EDI, EBP and ESP, plus some special (control/test/debug) registers. NOT related to "Windows registry".

Refers to the life-time and visibility of some component of the program, like a variable or a procedure. For example, a variable defined inside a procedure would have procedure scope: it is visible throughout the procedure, but not outside the procedure's code block. When the procedure ends, the variable goes out of scope and no longer exists.

A code block where all the lines of source have the same scope. An explicit scope block can be indicated with the Scope statement. Scope blocks may also be implicit with the usage of If..Then, For..Next, and other compound statements.

A library that exists once on a system that multiple executables can link to at runtime. See Shared Libraries (DLLs).

Code written by the programmer, in a human-readable form, not yet compiled.

A collection of data that offers last-in first-out (LIFO) storage and retrieval. Typically, elements can only be inserted, accessed and removed from the top of the stack.

One or more lines of code bookended by a compound statement.

A library that is linked into a program at link time. There is one copy of the library for each executable that links to it. All data is executable specific. See Static Libraries.

Member data that each instance of a Type or Class shares. This data is defined outside of any Type or Class, and takes up no space in the resulting object instance.

A member function without an implicit this reference as an argument. Static member functions can be called normally through a variable, or directly using the type's name and the scope resolution operator See Static (Member).

Refers to storage in the .BSS or .DATA sections of an executable. Variables, objects and arrays with static storage are allocated and initialized at compile-time and destroyed (in the case of objects) and deallocated at program-termination. Explicitly initialized variables, objects and arrays are allocated in the .DATA section.

A variable, object or array with static storage.

A procedure defined using Sub, optionally taking parameters and not returning a value.

Subversion. A version control system that allows users to keep track of changes made to sources and documents. All the users can browse and download sources here: fbc.svn.sf.net/viewvc/fbc/trunk , but only developers have write access as well. (see also CVS)

A tool that automatically translates C headers to FreeBASIC (although not always perfectly).

Used to refer to variables, labels, functions, methods, procedures, or other programmatic constructs in a program.

The part of the executable program that will contain program instructions and constant data.

A reference to an instance of a Type or Class that is passed as a hidden argument to non-static member functions of that type or class. Throughout the member function, this instance is referred to using the this keyword, See This.

A thread of execution within a process (running program) that shares execution time with other threads in the same process. See Threading.

To follow the execution of a program step-by-step either manually by examining the source code, or more practically with a debugger.

A structure that can be used to store different types of variables, such as integers, doubles and fixed-length strings in the same location, but only one at a time. See Union.

A Type, Union, Enum, or Class data type.

A symbol representing data in memory.

Visual BASIC for DOS, a historical BASIC compiler by M$ from 1992, following after QBASIC. DOS platform dropped very soon, VBDOS never became popular.

A series of data items in memory that can be accessed by an index number. Similar to an array except that vector elements are not necessarily all contained within a single block of memory.

A message displayed by the compiler during compilation that suggests there may be potential problems with the current code.

An on-line system that provides a set of pages containing information that can be viewed and modified by the public. In this context, it is typically used to refer to the FreeBASIC on line documentation.

Refers to the instruction set compatible with the 80386 (and later) CPU architecture.

A zstring is in essence a standard C style string ending with an embedded null character. This data type is provided for greater compatibility with C libraries.