"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."
$nl
"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:"
-{ $unchecked-example "FUNCTION: int* foo ( char* bar ) ;" }
+{ $unchecked-example "FUNCTION: int* foo ( char* bar )" }
{ $unchecked-example ": foo ( bar -- int* )
pointer: int f \"foo\" { pointer: char } f alien-invoke ;" } } ;
"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:"
{ $code
"USING: alien.syntax math prettyprint ;"
- "FUNCTION: float magic_number ( ) ;"
+ "FUNCTION: float magic_number ( )"
"magic_number 3.0 + ."
}
"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" } ":"
{ $code
"USING: alien.c-types alien.syntax math prettyprint ;"
- "FUNCTION: float magic_number ( ) ;"
+ "FUNCTION: float magic_number ( )"
"magic_number 3.0 + ."
}
"The correct solution is to use one of " { $link POSTPONE: FROM: } ", " { $link POSTPONE: QUALIFIED: } " or " { $link POSTPONE: QUALIFIED-WITH: } " to disambiguate word lookup:"
{ $code
"USING: alien.syntax math prettyprint ;"
"QUALIFIED-WITH: alien.c-types c"
- "FUNCTION: c:float magic_number ( ) ;"
+ "FUNCTION: c:float magic_number ( )"
"magic_number 3.0 + ."
}
"See " { $link "word-search-semantics" } " for details." ;
{ $examples
"Suppose you are writing a binding to the GLib library, which as a " { $snippet "g_object_unref" } " function. Then you can define the function and destructor like so,"
{ $code
- "FUNCTION: void g_object_unref ( gpointer object ) ;"
+ "FUNCTION: void g_object_unref ( gpointer object )"
"DESTRUCTOR: g_object_unref"
}
"Now, memory management becomes easier:"
"A C function which returns a struct by value:"
{ $code
"USING: alien.syntax ;"
- "FUNCTION: Point give_me_a_point ( c-string description ) ;"
+ "FUNCTION: Point give_me_a_point ( c-string description )"
}
"A C function which takes a struct parameter by reference:"
{ $code
- "FUNCTION: void print_point ( Point* p ) ;"
+ "FUNCTION: void print_point ( Point* p )"
} ;
ARTICLE: "classes.struct" "Struct classes"
{ $code
"USING: alien.syntax specialized-arrays ;"
"SPECIALIZED-ARRAY: int"
- "FUNCTION: void process_data ( int* data, int len ) ;"
+ "FUNCTION: void process_data ( int* data, int len )"
"int-array{ 10 20 30 } dup length process_data"
}
"Literal specialized arrays, as well as specialized arrays created with " { $snippet "<T-array>" } " and " { $snippet "T >c-array" } " are backed by a " { $link byte-array } " in the Factor heap, and can move as a result of garbage collection. If this is unsuitable, the array can be allocated in unmanaged memory instead."
{ $code
"USING: alien.syntax specialized-arrays ;"
"SPECIALIZED-ARRAY: float"
- "FUNCTION: void init_with_data ( float* data, int len ) ;"
- "FUNCTION: float compute_result ( ) ;"
+ "FUNCTION: void init_with_data ( float* data, int len )"
+ "FUNCTION: float compute_result ( )"
"["
" 100 malloc-float-array &free"
" dup length init_with_data"
" { id int }"
" { name char* } ;"
""
- "FUNCTION: void get_device_info ( int* length ) ;"
+ "FUNCTION: void get_device_info ( int* length )"
""
"0 int <ref> [ get_device_info ] keep <direct-int-array> ."
}