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

   1 USING: alien alien.complex help.syntax help.markup libc kernel.private
   2 byte-arrays strings hashtables alien.syntax alien.strings sequences
   3 io.encodings.string debugger destructors vocabs.loader
   4 classes.struct ;
   5 QUALIFIED: math
   6 QUALIFIED: sequences
   7 IN: alien.c-types
   8
   9 HELP: byte-length
  10 { $values { "seq" "A byte array or float array" } { "n" "a non-negative integer" } }
  11 { $contract "Outputs the size of the byte array, struct, or specialized array data in bytes." } ;
  12
  13 HELP: heap-size
  14 { $values { "name" "a C type name" } { "size" math:integer } }
  15 { $description "Outputs the number of bytes needed for a heap-allocated value of this C type." }
  16 { $examples
  17     { $example "USING: alien alien.c-types prettyprint ;\nint heap-size ." "4" }
  18 }
  19 { $errors "Throws a " { $link no-c-type } " error if the type does not exist." } ;
  20
  21 HELP: stack-size
  22 { $values { "name" "a C type name" } { "size" math:integer } }
  23 { $description "Outputs the number of bytes to reserve on the C stack by a value of this C type. In most cases this is equal to " { $link heap-size } ", except on some platforms where C structs are passed by invisible reference, in which case a C struct type only uses as much space as a pointer on the C stack." }
  24 { $errors "Throws a " { $link no-c-type } " error if the type does not exist." } ;
  25
  26 HELP: <c-type>
  27 { $values { "c-type" c-type } }
  28 { $description "Creates a prototypical C type. User code should use higher-level facilities to define C types; see " { $link "c-data" } "." } ;
  29
  30 HELP: no-c-type
  31 { $values { "name" "a C type name" } }
  32 { $description "Throws a " { $link no-c-type } " error." }
  33 { $error-description "Thrown by " { $link c-type } " if a given string does not name a C type. When thrown during compile time, indicates a typo in an " { $link alien-invoke } " or " { $link alien-callback } " form." } ;
  34
  35 HELP: c-type
  36 { $values { "name" "a C type" } { "c-type" c-type } }
  37 { $description "Looks up a C type by name." }
  38 { $errors "Throws a " { $link no-c-type } " error if the type does not exist, or the word is not a C type." } ;
  39
  40 HELP: c-getter
  41 { $values { "name" "a C type" } { "quot" { $quotation "( c-ptr n -- obj )" } } }
  42 { $description "Outputs a quotation which reads values of this C type from a C structure." }
  43 { $errors "Throws a " { $link no-c-type } " error if the type does not exist." } ;
  44
  45 HELP: c-setter
  46 { $values { "name" "a C type" } { "quot" { $quotation "( obj c-ptr n -- )" } } }
  47 { $description "Outputs a quotation which writes values of this C type to a C structure." }
  48 { $errors "Throws an error if the type does not exist." } ;
  49
  50 HELP: box-parameter
  51 { $values { "n" math:integer } { "c-type" "a C type" } }
  52 { $description "Generates code for converting a C value stored at  offset " { $snippet "n" } " from the top of the stack into a Factor object to be pushed on the data stack." }
  53 { $notes "This is an internal word used by the compiler when compiling callbacks." } ;
  54
  55 HELP: box-return
  56 { $values { "c-type" "a C type" } }
  57 { $description "Generates code for converting a C value stored in return registers into a Factor object to be pushed on the data stack." }
  58 { $notes "This is an internal word used by the compiler when compiling alien calls." } ;
  59
  60 HELP: unbox-return
  61 { $values { "c-type" "a C type" } }
  62 { $description "Generates code for converting a Factor value on the data stack into a C value to be stored in the return registers." }
  63 { $notes "This is an internal word used by the compiler when compiling callbacks." } ;
  64
  65 HELP: define-deref
  66 { $values { "c-type" "a C type" } }
  67 { $description "Defines a word " { $snippet "*name" } " with stack effect " { $snippet "( c-ptr -- value )" } " for reading a value with C type " { $snippet "name" } " stored at an alien pointer." }
  68 { $notes "This is an internal word called when defining C types, there is no need to call it on your own." } ;
  69
  70 HELP: define-out
  71 { $values { "c-type" "a C type" } }
  72 { $description "Defines a word " { $snippet "<" { $emphasis "name" } ">" } " with stack effect " { $snippet "( value -- array )" } ". This word allocates a byte array large enough to hold a value with C type " { $snippet "name" } ", and writes the value at the top of the stack to the array." }
  73 { $notes "This is an internal word called when defining C types, there is no need to call it on your own." } ;
  74
  75 HELP: char
  76 { $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." } ;
  77 HELP: uchar
  78 { $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." } ;
  79 HELP: short
  80 { $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." } ;
  81 HELP: ushort
  82 { $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." } ;
  83 HELP: int
  84 { $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." } ;
  85 HELP: uint
  86 { $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." } ;
  87 HELP: long
  88 { $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." } ;
  89 HELP: intptr_t
  90 { $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." } ;
  91 HELP: ulong
  92 { $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." } ;
  93 HELP: uintptr_t
  94 { $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." } ;
  95 HELP: ptrdiff_t
  96 { $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." } ;
  97 HELP: size_t
  98 { $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." } ;
  99 HELP: longlong
 100 { $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." } ;
 101 HELP: ulonglong
 102 { $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." } ;
 103 HELP: void
 104 { $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." } ;
 105 HELP: void*
 106 { $description "This C type represents a pointer to C memory. " { $link byte-array } " and " { $link alien } " values can be passed as " { $snippet "void*" } " function inputs, but see " { $link "byte-arrays-gc" } " for notes about passing byte arrays into C functions. " { $snippet "void*" } " output values are returned as " { $link alien } "s." } ;
 107 HELP: char*
 108 { $description "This C type represents a pointer to a C string. See " { $link "c-strings" } " for details about using strings with the FFI." } ;
 109 HELP: float
 110 { $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." } ;
 111 HELP: double
 112 { $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." } ;
 113 HELP: complex-float
 114 { $description "This C type represents a single-precision IEEE 754 floating-point complex type. Input values will be converted from Factor " { $link math:complex } " objects into a single-precision complex float type; output values will be returned as Factor " { $link math:complex } " objects." } ;
 115 HELP: complex-double
 116 { $description "This C type represents a double-precision IEEE 754 floating-point complex type. Input values will be converted from Factor " { $link math:complex } " objects into a double-precision complex float type; output values will be returned as Factor " { $link math:complex } " objects." } ;
 117
 118
 119 ARTICLE: "byte-arrays-gc" "Byte arrays and the garbage collector"
 120 "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."
 121 $nl
 122 "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:"
 123 { $list
 124     "the C function returns"
 125     "the C function calls Factor code via a callback"
 126 }
 127 "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."
 128 $nl
 129 "If this condition is not satisfied, " { $link "malloc" } " must be used instead."
 130 { $warning "Failure to comply with these requirements can lead to crashes, data corruption, and security exploits." } ;
 131
 132 ARTICLE: "c-out-params" "Output parameters in C"
 133 "A frequently-occurring idiom in C code is the \"out parameter\". If a C function returns more than one value, the caller passes pointers of the correct type, and the C function writes its return values to those locations."
 134 $nl
 135 "Each numerical C type, together with " { $snippet "void*" } ", has an associated " { $emphasis "out parameter constructor" } " word which takes a Factor object as input, constructs a byte array of the correct size, and converts the Factor object to a C value stored into the byte array:"
 136 { $subsections
 137     <char>
 138     <uchar>
 139     <short>
 140     <ushort>
 141     <int>
 142     <uint>
 143     <long>
 144     <ulong>
 145     <longlong>
 146     <ulonglong>
 147     <float>
 148     <double>
 149     <void*>
 150 }
 151 "You call the out parameter constructor with the required initial value, then pass the byte array to the C function, which receives a pointer to the start of the byte array's data area. The C function then returns, leaving the result in the byte array; you read it back using the next set of words:"
 152 { $subsections
 153     *char
 154     *uchar
 155     *short
 156     *ushort
 157     *int
 158     *uint
 159     *long
 160     *ulong
 161     *longlong
 162     *ulonglong
 163     *float
 164     *double
 165     *void*
 166 }
 167 "Note that while structure and union types do not get these words defined for them, there is no loss of generality since " { $link <void*> } " and " { $link *void* } " may be used." ;
 168
 169 ARTICLE: "c-types.primitives" "Primitive C types"
 170 "The following numerical types are defined in the " { $vocab-link "alien.c-types" } " vocabulary; a " { $snippet "u" } " prefix denotes an unsigned type:"
 171 { $table
 172     { "C type" "Notes" }
 173     { { $link char } "always 1 byte" }
 174     { { $link uchar } { } }
 175     { { $link short } "always 2 bytes" }
 176     { { $link ushort } { } }
 177     { { $link int } "always 4 bytes" }
 178     { { $link uint } { } }
 179     { { $link long } { "same size as CPU word size and " { $link void* } ", except on 64-bit Windows, where it is 4 bytes" } }
 180     { { $link ulong } { } }
 181     { { $link longlong } "always 8 bytes" }
 182     { { $link ulonglong } { } }
 183     { { $link float } { "single-precision float (not the same as Factor's " { $link math:float } " class!)" } }
 184     { { $link double } { "double-precision float (the same format as Factor's " { $link math:float } " objects)" } }
 185 }
 186 "The following C99 complex number types are defined in the " { $vocab-link "alien.complex" } " vocabulary:"
 187 { $table
 188     { { $link complex-float } { "C99 or Fortran " { $snippet "complex float" } " type, converted to and from Factor " { $link math:complex } " values" } }
 189     { { $link complex-double } { "C99 or Fortran " { $snippet "complex double" } " type, converted to and from Factor " { $link math:complex } " values" } }
 190 }
 191 "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." ;
 192
 193 ARTICLE: "c-types.pointers" "Pointer and array types"
 194 "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. With the exception of strings (see " { $link "c-strings" } "), all pointer types are identical to " { $snippet "void*" } " as far as the C library interface is concerned."
 195 $nl
 196 "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:"
 197 { $code "int[3][4]" }
 198 "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 and thus the dimensions only serve as documentation." ;
 199
 200 ARTICLE: "c-types.ambiguity" "Word name clashes with C types"
 201 "Note that some of the C type word names clash with commonly-used Factor words:"
 202 { $list
 203   { { $link short } " clashes with the " { $link sequences:short } " word in the " { $vocab-link "sequences" } " vocabulary" }
 204   { { $link float } " clashes with the " { $link math:float } " word in the " { $vocab-link "math" } " vocabulary" }
 205 }
 206 "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:"
 207 { $code
 208   "USING: alien.syntax math prettyprint ;"
 209   "FUNCTION: float magic_number ( ) ;"
 210   "magic_number 3.0 + ."
 211 }
 212 "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" } ":"
 213 { $code
 214   "USING: alien.c-types alien.syntax math prettyprint ;"
 215   "FUNCTION: float magic_number ( ) ;"
 216   "magic_number 3.0 + ."
 217 }
 218 "The correct solution is to use one of " { $link POSTPONE: FROM: } ", " { $link POSTPONE: QUALIFIED: } " or " { $link POSTPONE: QUALIFIED-WITH: } " to disambiguate word lookup:"
 219 { $code
 220   "USING: alien.syntax math prettyprint ;"
 221   "QUALIFIED-WITH: alien.c-types c"
 222   "FUNCTION: c:float magic_number ( ) ;"
 223   "magic_number 3.0 + ."
 224 }
 225 "See " { $link "word-search-semantics" } " for details." ;
 226
 227 ARTICLE: "c-types.structs" "Struct and union types"
 228 "Struct and union types are identified by their class word. See " { $link "classes.struct" } "." ;
 229
 230 ARTICLE: "c-types-specs" "C type specifiers"
 231 "C types are identified by special words, and type names occur as parameters to the " { $link alien-invoke } ", " { $link alien-indirect } " and " { $link alien-callback } " words."
 232 $nl
 233 "Defining new C types:"
 234 { $subsections
 235     POSTPONE: STRUCT:
 236     POSTPONE: UNION-STRUCT:
 237     POSTPONE: CALLBACK:
 238     POSTPONE: TYPEDEF:
 239 }
 240 { $heading "Related articles" }
 241 { $subsections
 242     "c-types.primitives"
 243     "c-types.pointers"
 244     "c-types.ambiguity"
 245     "c-types.structs"
 246 }
 247 ;
 248
 249 ABOUT: "c-types-specs"