basis/alien/c-types/c-types-docs.factor

   1 USING: alien alien.syntax byte-arrays classes.struct help.markup
   2 help.syntax kernel math sequences ;
   3 IN: alien.c-types
   4
   5 HELP: heap-size
   6 { $values { "name" c-type-name } { "size" math:integer } }
   7 { $description "Outputs the number of bytes needed for a heap-allocated value of this C type." }
   8 { $examples
   9     { $example "USING: alien alien.c-types prettyprint ;\nint heap-size ." "4" }
  10 }
  11 { $errors "Throws a " { $link no-c-type } " error if the type does not exist." } ;
  12
  13 HELP: <c-type>
  14 { $values { "c-type" c-type } }
  15 { $description "Creates a prototypical C type. User code should use higher-level facilities to define C types; see " { $link "c-data" } "." } ;
  16
  17 HELP: no-c-type
  18 { $values { "name" c-type-name } }
  19 { $description "Throws a " { $link no-c-type } " error." }
  20 { $error-description "Thrown by " { $link c-type } " if a given word is not a C type." } ;
  21
  22 HELP: lookup-c-type
  23 { $values { "name" c-type-name } { "c-type" c-type } }
  24 { $description "Looks up a C type by name." }
  25 { $errors "Throws a " { $link no-c-type } " error if the type does not exist, or the word is not a C type." } ;
  26
  27 HELP: alien-value
  28 { $values { "c-ptr" c-ptr } { "offset" integer } { "c-type" c-type-name } { "value" object } }
  29 { $description "Loads a value at a byte offset from a base C pointer." }
  30 { $errors "Throws a " { $link no-c-type } " error if the type does not exist." } ;
  31
  32 HELP: set-alien-value
  33 { $values { "value" object } { "c-ptr" c-ptr } { "offset" integer } { "c-type" c-type-name } }
  34 { $description "Stores a value at a byte offset from a base C pointer." }
  35 { $errors "Throws a " { $link no-c-type } " error if the type does not exist." } ;
  36
  37 HELP: char
  38 { $description "This C type represents a one-byte signed integer type. Input values will be converted to " { $link math:integer } "s and truncated to eight bits; output values will be returned as " { $link math:fixnum } "s." } ;
  39 HELP: uchar
  40 { $description "This C type represents a one-byte unsigned integer type. Input values will be converted to " { $link math:integer } "s and truncated to eight bits; output values will be returned as " { $link math:fixnum } "s." } ;
  41 HELP: short
  42 { $description "This C type represents a two-byte signed integer type. Input values will be converted to " { $link math:integer } "s and truncated to sixteen bits; output values will be returned as " { $link math:fixnum } "s." } ;
  43 HELP: ushort
  44 { $description "This C type represents a two-byte unsigned integer type. Input values will be converted to " { $link math:integer } "s and truncated to sixteen bits; output values will be returned as " { $link math:fixnum } "s." } ;
  45 HELP: int
  46 { $description "This C type represents a four-byte signed integer type. Input values will be converted to " { $link math:integer } "s and truncated to 32 bits; output values will be returned as " { $link math:integer } "s." } ;
  47 HELP: uint
  48 { $description "This C type represents a four-byte unsigned integer type. Input values will be converted to " { $link math:integer } "s and truncated to 32 bits; output values will be returned as " { $link math:integer } "s." } ;
  49 HELP: long
  50 { $description "This C type represents a four- or eight-byte signed integer type. On Windows and on 32-bit Unix platforms, it will be four bytes. On 64-bit Unix platforms, it will be eight bytes. Input values will be converted to " { $link math:integer } "s and truncated to 32 or 64 bits; output values will be returned as " { $link math:integer } "s." } ;
  51 HELP: intptr_t
  52 { $description "This C type represents a signed integer type large enough to hold any pointer value; that is, on 32-bit platforms, it will be four bytes, and on 64-bit platforms, it will be eight bytes. Input values will be converted to " { $link math:integer } "s and truncated to 32 or 64 bits; output values will be returned as " { $link math:integer } "s." } ;
  53 HELP: ulong
  54 { $description "This C type represents a four- or eight-byte unsigned integer type. On Windows and on 32-bit Unix platforms, it will be four bytes. On 64-bit Unix platforms, it will be eight bytes. Input values will be converted to " { $link math:integer } "s and truncated to 32 or 64 bits; output values will be returned as " { $link math:integer } "s." } ;
  55 HELP: uintptr_t
  56 { $description "This C type represents an unsigned integer type large enough to hold any pointer value; that is, on 32-bit platforms, it will be four bytes, and on 64-bit platforms, it will be eight bytes. Input values will be converted to " { $link math:integer } "s and truncated to 32 or 64 bits; output values will be returned as " { $link math:integer } "s." } ;
  57 HELP: ptrdiff_t
  58 { $description "This C type represents a signed integer type large enough to hold the distance between two pointer values; that is, on 32-bit platforms, it will be four bytes, and on 64-bit platforms, it will be eight bytes. Input values will be converted to " { $link math:integer } "s and truncated to 32 or 64 bits; output values will be returned as " { $link math:integer } "s." } ;
  59 HELP: size_t
  60 { $description "This C type represents unsigned size values of the size expected by the platform's standard C library (usually four bytes on a 32-bit platform, and eight on a 64-bit platform). Input values will be converted to " { $link math:integer } "s and truncated to the appropriate size; output values will be returned as " { $link math:integer } "s." } ;
  61 HELP: longlong
  62 { $description "This C type represents an eight-byte signed integer type. Input values will be converted to " { $link math:integer } "s and truncated to 64 bits; output values will be returned as " { $link math:integer } "s." } ;
  63 HELP: ulonglong
  64 { $description "This C type represents an eight-byte unsigned integer type. Input values will be converted to " { $link math:integer } "s and truncated to 64 bits; output values will be returned as " { $link math:integer } "s." } ;
  65 HELP: void
  66 { $description "This symbol is not a valid C type, but it can be used as the return type for a " { $link POSTPONE: FUNCTION: } " or " { $link POSTPONE: CALLBACK: } " definition or for an " { $link alien-invoke } " or " { $link alien-callback } " call." } ;
  67 HELP: void*
  68 { $description "This C type represents a generic pointer to C memory. See " { $link pointer } " for information on pointer C types." } ;
  69 HELP: c-string
  70 { $description "This C type represents a pointer to a C string. See " { $link "c-strings" } " for details about using strings with the FFI." } ;
  71 HELP: float
  72 { $description "This C type represents a single-precision IEEE 754 floating-point type. Input values will be converted to Factor " { $link math:float } "s and demoted to single-precision; output values will be returned as Factor " { $link math:float } "s." } ;
  73 HELP: double
  74 { $description "This C type represents a double-precision IEEE 754 floating-point type. Input values will be converted to Factor " { $link math:float } "s; output values will be returned as Factor " { $link math:float } "s." } ;
  75
  76 HELP: pointer:
  77 { $syntax "pointer: c-type" }
  78 { $description "Constructs a " { $link pointer } " C type." } ;
  79
  80 HELP: pointer
  81 { $class-description "Represents a pointer C type. The " { $snippet "to" } " slot contains the C type being pointed to. Both " { $link byte-array } " and " { $link alien } " values can be provided as pointer function inputs, but see " { $link "byte-arrays-gc" } " for notes about passing byte arrays into C functions. Objects with methods on " { $link >c-ptr } ", such as structs and specialized arrays, may also be used as pointer inputs."
  82 $nl
  83 "Pointer output values are represented in Factor as " { $link alien } "s. If the pointed-to type is a struct, the alien will automatically be wrapped in a struct object if it is not null."
  84 $nl
  85 "In " { $link POSTPONE: TYPEDEF: } ", " { $link POSTPONE: FUNCTION: } ", " { $link POSTPONE: CALLBACK: } ", and " { $link POSTPONE: STRUCT: } " definitions, pointer types can be created by suffixing " { $snippet "*" } " to a C type name. Outside of FFI definitions, a pointer C type can be created using the " { $link POSTPONE: pointer: } " syntax word:"
  86 { $unchecked-example "FUNCTION: int* foo ( char* bar )" }
  87 { $unchecked-example ": foo ( bar -- int* )
  88     pointer: int f \"foo\" { pointer: char } f alien-invoke ;" } } ;
  89
  90 ARTICLE: "byte-arrays-gc" "Byte arrays and the garbage collector"
  91 "The Factor garbage collector can move byte arrays around, and it is only safe to pass byte arrays to C functions if the garbage collector will not run while C code still has a reference to the data."
  92 $nl
  93 "In particular, a byte array can only be passed as a parameter if the the C function does not use the parameter after one of the following occurs:"
  94 { $list
  95     "the C function returns"
  96     "the C function calls Factor code via a callback"
  97 }
  98 "Returning from C to Factor, as well as invoking Factor code via a callback, may trigger garbage collection, and if the function had stored a pointer to the byte array somewhere, this pointer may cease to be valid."
  99 $nl
 100 "If this condition is not satisfied, " { $link "malloc" } " must be used instead."
 101 { $warning "Failure to comply with these requirements can lead to crashes, data corruption, and security exploits." } ;
 102
 103 ARTICLE: "c-types.primitives" "Primitive C types"
 104 "The following numerical types are defined in the " { $vocab-link "alien.c-types" } " vocabulary; a " { $snippet "u" } " prefix denotes an unsigned type:"
 105 { $table
 106     { { $strong "C type" } { $strong "Notes" } }
 107     { { $link char } "always 1 byte" }
 108     { { $link uchar } { } }
 109     { { $link short } "always 2 bytes" }
 110     { { $link ushort } { } }
 111     { { $link int } "always 4 bytes" }
 112     { { $link uint } { } }
 113     { { $link long } { "same size as CPU word size and " { $link void* } ", except on 64-bit Windows, where it is 4 bytes" } }
 114     { { $link ulong } { } }
 115     { { $link longlong } "always 8 bytes" }
 116     { { $link ulonglong } { } }
 117     { { $link float } { "single-precision float (not the same as Factor's " { $link math:float } " class!)" } }
 118     { { $link double } { "double-precision float (the same format as Factor's " { $link math:float } " objects)" } }
 119 }
 120 "C99 complex number types are defined in the " { $vocab-link "alien.complex" } " vocabulary."
 121 $nl
 122 "When making alien calls, Factor numbers are converted to and from the above types in a canonical way. Converting a Factor number to a C value may result in a loss of precision." ;
 123
 124 ARTICLE: "c-types.pointers" "Pointer and array types"
 125 "Pointer types are specified by suffixing a C type with " { $snippet "*" } ", for example " { $snippet "float*" } ". One special case is " { $link void* } ", which denotes a generic pointer; " { $link void } " by itself is not a valid C type specifier. This syntax constructs a " { $link pointer } " object to represent the C type."
 126 $nl
 127 "Fixed-size array types are supported; the syntax consists of a C type name followed by dimension sizes in brackets; the following denotes a 3 by 4 array of integers:"
 128 { $code "int[3][4]" }
 129 "Fixed-size arrays differ from pointers in that they are allocated inside structures and unions; however, when used as function parameters, they behave exactly like pointers with the dimensions only serving as documentation." ;
 130
 131 ARTICLE: "c-types.ambiguity" "Word name clashes with C types"
 132 "Note that some of the C type word names clash with commonly-used Factor words:"
 133 { $list
 134   { { $link float } " clashes with the " { $link math:float } " word in the " { $vocab-link "math" } " vocabulary" }
 135 }
 136 "If you use the wrong vocabulary, you will see a " { $link no-c-type } " error. For example, the following is " { $strong "not" } " valid, and will raise an error because the " { $link math:float } " word from the " { $vocab-link "math" } " vocabulary is not a C type:"
 137 { $code
 138   "USING: alien.syntax math prettyprint ;"
 139   "FUNCTION: float magic_number ( )"
 140   "magic_number 3.0 + ."
 141 }
 142 "The following won't work either; now the problem is that there are two vocabularies in the search path that define a word named " { $snippet "float" } ":"
 143 { $code
 144   "USING: alien.c-types alien.syntax math prettyprint ;"
 145   "FUNCTION: float magic_number ( )"
 146   "magic_number 3.0 + ."
 147 }
 148 "The correct solution is to use one of " { $link POSTPONE: FROM: } ", " { $link POSTPONE: QUALIFIED: } " or " { $link POSTPONE: QUALIFIED-WITH: } " to disambiguate word lookup:"
 149 { $code
 150   "USING: alien.syntax math prettyprint ;"
 151   "QUALIFIED-WITH: alien.c-types c"
 152   "FUNCTION: c:float magic_number ( )"
 153   "magic_number 3.0 + ."
 154 }
 155 "See " { $link "word-search-semantics" } " for details." ;
 156
 157 ARTICLE: "c-types.structs" "Struct and union types"
 158 "Struct and union types are identified by their class word. See " { $link "classes.struct" } "." ;
 159
 160 ARTICLE: "c-types-specs" "C type specifiers"
 161 "C types are identified by special words. Type names occur as parameters to the " { $link alien-invoke } ", " { $link alien-indirect } " and " { $link alien-callback } " words."
 162 $nl
 163 "Defining new C types:"
 164 { $subsections
 165     POSTPONE: STRUCT:
 166     POSTPONE: UNION-STRUCT:
 167     POSTPONE: CALLBACK:
 168     POSTPONE: TYPEDEF:
 169 }
 170 "Getting the c-type of a class:"
 171 { $subsections lookup-c-type }
 172 { $heading "Related articles" }
 173 { $subsections
 174     "c-types.primitives"
 175     "c-types.pointers"
 176     "c-types.ambiguity"
 177     "c-types.structs"
 178 }
 179 ;
 180
 181 ABOUT: "c-types-specs"