@echo "NO_UI=1 don't link with X11 libraries (ignored on Mac OS X)"
@echo "X11=1 force link with X11 libraries instead of Cocoa (only on Mac OS X)"
+ALL = factor factor-ffi-test factor-lib
+
openbsd-x86-32:
- $(MAKE) factor factor-ffi-test CONFIG=vm/Config.openbsd.x86.32
+ $(MAKE) $(ALL) CONFIG=vm/Config.openbsd.x86.32
openbsd-x86-64:
- $(MAKE) factor factor-ffi-test CONFIG=vm/Config.openbsd.x86.64
+ $(MAKE) $(ALL) CONFIG=vm/Config.openbsd.x86.64
freebsd-x86-32:
- $(MAKE) factor factor-ffi-test CONFIG=vm/Config.freebsd.x86.32
+ $(MAKE) $(ALL) CONFIG=vm/Config.freebsd.x86.32
freebsd-x86-64:
- $(MAKE) factor factor-ffi-test CONFIG=vm/Config.freebsd.x86.64
+ $(MAKE) $(ALL) CONFIG=vm/Config.freebsd.x86.64
netbsd-x86-32:
- $(MAKE) factor factor-ffi-test CONFIG=vm/Config.netbsd.x86.32
+ $(MAKE) $(ALL) CONFIG=vm/Config.netbsd.x86.32
netbsd-x86-64:
- $(MAKE) factor factor-ffi-test CONFIG=vm/Config.netbsd.x86.64
+ $(MAKE) $(ALL) CONFIG=vm/Config.netbsd.x86.64
macosx-ppc:
- $(MAKE) factor factor-ffi-test macosx.app CONFIG=vm/Config.macosx.ppc
+ $(MAKE) $(ALL) macosx.app CONFIG=vm/Config.macosx.ppc
macosx-x86-32:
- $(MAKE) factor factor-ffi-test macosx.app CONFIG=vm/Config.macosx.x86.32
+ $(MAKE) $(ALL) macosx.app CONFIG=vm/Config.macosx.x86.32
macosx-x86-64:
- $(MAKE) factor factor-ffi-test macosx.app CONFIG=vm/Config.macosx.x86.64
+ $(MAKE) $(ALL) macosx.app CONFIG=vm/Config.macosx.x86.64
linux-x86-32:
- $(MAKE) factor factor-ffi-test CONFIG=vm/Config.linux.x86.32
+ $(MAKE) $(ALL) CONFIG=vm/Config.linux.x86.32
linux-x86-64:
- $(MAKE) factor factor-ffi-test CONFIG=vm/Config.linux.x86.64
+ $(MAKE) $(ALL) CONFIG=vm/Config.linux.x86.64
linux-ppc:
- $(MAKE) factor factor-ffi-test CONFIG=vm/Config.linux.ppc
+ $(MAKE) $(ALL) CONFIG=vm/Config.linux.ppc
linux-arm:
- $(MAKE) factor factor-ffi-test CONFIG=vm/Config.linux.arm
+ $(MAKE) $(ALL) CONFIG=vm/Config.linux.arm
solaris-x86-32:
- $(MAKE) factor factor-ffi-test CONFIG=vm/Config.solaris.x86.32
+ $(MAKE) $(ALL) CONFIG=vm/Config.solaris.x86.32
solaris-x86-64:
- $(MAKE) factor factor-ffi-test CONFIG=vm/Config.solaris.x86.64
+ $(MAKE) $(ALL) CONFIG=vm/Config.solaris.x86.64
winnt-x86-32:
- $(MAKE) factor factor-ffi-test CONFIG=vm/Config.windows.nt.x86.32
+ $(MAKE) $(ALL) CONFIG=vm/Config.windows.nt.x86.32
$(MAKE) factor-console CONFIG=vm/Config.windows.nt.x86.32
winnt-x86-64:
- $(MAKE) factor factor-ffi-test CONFIG=vm/Config.windows.nt.x86.64
+ $(MAKE) $(ALL) CONFIG=vm/Config.windows.nt.x86.64
$(MAKE) factor-console CONFIG=vm/Config.windows.nt.x86.64
wince-arm:
- $(MAKE) factor factor-ffi-test CONFIG=vm/Config.windows.ce.arm
+ $(MAKE) $(ALL) CONFIG=vm/Config.windows.ce.arm
ifdef CONFIG
$(ENGINE): $(DLL_OBJS)
$(TOOLCHAIN_PREFIX)$(LINKER) $(ENGINE) $(DLL_OBJS)
+factor-lib: $(ENGINE)
+
factor: $(EXE_OBJS) $(DLL_OBJS)
$(TOOLCHAIN_PREFIX)$(CPP) $(LIBS) $(LIBPATH) -L. $(DLL_OBJS) \
$(CFLAGS) -o $(EXECUTABLE) $(EXE_OBJS)
tags:
etags vm/*.{cpp,hpp,mm,S,c}
-.PHONY: factor factor-console factor-ffi-test tags clean macosx.app
+.PHONY: factor factor-lib factor-console factor-ffi-test tags clean macosx.app
! Copyright (C) 2004, 2009 Slava Pestov.
! See http://factorcode.org/license.txt for BSD license.
-USING: byte-arrays arrays assocs kernel kernel.private math
+USING: byte-arrays arrays assocs delegate kernel kernel.private math
math.order math.parser namespaces make parser sequences strings
words splitting cpu.architecture alien alien.accessors
alien.strings quotations layouts system compiler.units io
M: abstract-c-type c-type-class class>> ;
-M: c-type-name c-type-class c-type c-type-class ;
-
GENERIC: c-type-boxed-class ( name -- class )
M: abstract-c-type c-type-boxed-class boxed-class>> ;
-M: c-type-name c-type-boxed-class c-type c-type-boxed-class ;
-
GENERIC: c-type-boxer ( name -- boxer )
M: c-type c-type-boxer boxer>> ;
-M: c-type-name c-type-boxer c-type c-type-boxer ;
-
GENERIC: c-type-boxer-quot ( name -- quot )
M: abstract-c-type c-type-boxer-quot boxer-quot>> ;
-M: c-type-name c-type-boxer-quot c-type c-type-boxer-quot ;
-
GENERIC: c-type-unboxer ( name -- boxer )
M: c-type c-type-unboxer unboxer>> ;
-M: c-type-name c-type-unboxer c-type c-type-unboxer ;
-
GENERIC: c-type-unboxer-quot ( name -- quot )
M: abstract-c-type c-type-unboxer-quot unboxer-quot>> ;
-M: c-type-name c-type-unboxer-quot c-type c-type-unboxer-quot ;
-
GENERIC: c-type-rep ( name -- rep )
M: c-type c-type-rep rep>> ;
-M: c-type-name c-type-rep c-type c-type-rep ;
-
GENERIC: c-type-getter ( name -- quot )
M: c-type c-type-getter getter>> ;
-M: c-type-name c-type-getter c-type c-type-getter ;
-
GENERIC: c-type-setter ( name -- quot )
M: c-type c-type-setter setter>> ;
-M: c-type-name c-type-setter c-type c-type-setter ;
-
GENERIC: c-type-align ( name -- n )
M: abstract-c-type c-type-align align>> ;
-M: c-type-name c-type-align c-type c-type-align ;
-
GENERIC: c-type-align-first ( name -- n )
-M: c-type-name c-type-align-first c-type c-type-align-first ;
-
M: abstract-c-type c-type-align-first align-first>> ;
GENERIC: c-type-stack-align? ( name -- ? )
M: c-type c-type-stack-align? stack-align?>> ;
-M: c-type-name c-type-stack-align? c-type c-type-stack-align? ;
-
: c-type-box ( n c-type -- )
[ c-type-rep ] [ c-type-boxer [ "No boxer" throw ] unless* ] bi
%box ;
M: c-type box-parameter c-type-box ;
-M: c-type-name box-parameter c-type box-parameter ;
-
GENERIC: box-return ( c-type -- )
M: c-type box-return f swap c-type-box ;
-M: c-type-name box-return c-type box-return ;
-
GENERIC: unbox-parameter ( n c-type -- )
M: c-type unbox-parameter c-type-unbox ;
-M: c-type-name unbox-parameter c-type unbox-parameter ;
-
GENERIC: unbox-return ( c-type -- )
M: c-type unbox-return f swap c-type-unbox ;
-M: c-type-name unbox-return c-type unbox-return ;
-
: little-endian? ( -- ? ) 1 <int> *char 1 = ; foldable
GENERIC: heap-size ( name -- size )
-M: c-type-name heap-size c-type heap-size ;
-
M: abstract-c-type heap-size size>> ;
GENERIC: stack-size ( name -- size )
-M: c-type-name stack-size c-type stack-size ;
-
M: c-type stack-size size>> cell align ;
: >c-bool ( ? -- int ) 1 0 ? ; inline
\ swap , [ heap-size , [ * >fixnum ] % ] [ % ] bi*
] [ ] make ;
+PROTOCOL: c-type-protocol
+ c-type-class
+ c-type-boxed-class
+ c-type-boxer
+ c-type-boxer-quot
+ c-type-unboxer
+ c-type-unboxer-quot
+ c-type-rep
+ c-type-getter
+ c-type-setter
+ c-type-align
+ c-type-align-first
+ c-type-stack-align?
+ box-parameter
+ box-return
+ unbox-parameter
+ unbox-return
+ heap-size
+ stack-size ;
+
+CONSULT: c-type-protocol c-type-name
+ c-type ;
+
PREDICATE: typedef-word < c-type-word
"c-type" word-prop c-type-name? ;
"Important guidelines for passing data in byte arrays:"
{ $subsections "byte-arrays-gc" }
"C-style enumerated types are supported:"
-{ $subsections POSTPONE: C-ENUM: }
+{ $subsections POSTPONE: ENUM: }
"C types can be aliased for convenience and consistency with native library documentation:"
{ $subsections POSTPONE: TYPEDEF: }
"A utility for defining " { $link "destructors" } " for deallocating memory:"
--- /dev/null
+! Copyright (C) 2010 Erik Charlebois.
+! See http://factorcode.org/license.txt for BSD license.
+USING: alien.c-types help.markup help.syntax words ;
+IN: alien.enums
+
+HELP: define-enum
+{ $values
+ { "word" word } { "base-type" c-type } { "members" "sequence of word and value pairs" }
+}
+{ $description "Defines an enum. This is the run-time equivalent of ENUM:." } ;
+
+HELP: enum>number
+{ $values
+ { "enum" "an enum word" }
+ { "number" "the corresponding number value" }
+}
+{ $description "Converts an enum to a number." } ;
+
+HELP: number>enum
+{ $values
+ { "number" "an enum number" } { "enum-c-type" "an enum type" }
+ { "enum" "the corresponding enum word" }
+}
+{ $description "Convert a number to an enum." } ;
+
+ARTICLE: "alien.enums" "alien.enums"
+{ $vocab-link "alien.enums" }
+;
+
+ABOUT: "alien.enums"
--- /dev/null
+! Copyright (C) 2010 Erik Charlebois.
+! See http://factorcode.org/license.txt for BSD license.
+USING: accessors alien.c-types alien.enums alien.enums.private
+alien.syntax sequences tools.test words ;
+IN: alien.enums.tests
+
+ENUM: color_t red { green 3 } blue ;
+ENUM: instrument_t < ushort trombone trumpet ;
+
+{ { red green blue 5 } }
+[ { 0 3 4 5 } [ <color_t> ] map ] unit-test
+
+{ { 0 3 4 5 } }
+[ { red green blue 5 } [ enum>number ] map ] unit-test
+
+{ { -1 trombone trumpet } }
+[ { -1 0 1 } [ <instrument_t> ] map ] unit-test
+
+{ { -1 0 1 } }
+[ { -1 trombone trumpet } [ enum>number ] map ] unit-test
+
+{ t }
+[ color_t "c-type" word-prop enum-c-type? ] unit-test
+
+{ f }
+[ ushort "c-type" word-prop enum-c-type? ] unit-test
+
+{ int }
+[ color_t "c-type" word-prop base-type>> ] unit-test
+
+{ ushort }
+[ instrument_t "c-type" word-prop base-type>> ] unit-test
+
+{ V{ { red 0 } { green 3 } { blue 4 } } }
+[ color_t "c-type" word-prop members>> ] unit-test
--- /dev/null
+! (c)2010 Joe Groff, Erik Charlebois bsd license
+USING: accessors alien.c-types arrays classes.singleton combinators
+delegate fry generic.parser kernel macros math parser sequences words ;
+IN: alien.enums
+
+<PRIVATE
+TUPLE: enum-c-type base-type members ;
+C: <enum-c-type> enum-c-type
+CONSULT: c-type-protocol enum-c-type
+ base-type>> ;
+PRIVATE>
+
+GENERIC: enum>number ( enum -- number ) foldable
+M: integer enum>number ;
+
+<PRIVATE
+: enum-boxer ( members -- quot )
+ [ first2 swap '[ _ ] 2array ]
+ { } map-as [ ] suffix '[ _ case ] ;
+PRIVATE>
+
+MACRO: number>enum ( enum-c-type -- )
+ c-type members>> enum-boxer ;
+
+M: enum-c-type c-type-boxed-class drop object ;
+M: enum-c-type c-type-boxer-quot members>> enum-boxer ;
+M: enum-c-type c-type-unboxer-quot drop [ enum>number ] ;
+M: enum-c-type c-type-setter
+ [ enum>number ] swap base-type>> c-type-setter '[ _ 2dip @ ] ;
+
+<PRIVATE
+
+: define-enum>number ( class value -- )
+ [ \ enum>number create-method-in ]
+ [ '[ drop _ ] ] bi* define ;
+
+: define-enum-members ( member-names -- )
+ [
+ [ first define-singleton-class ]
+ [ first2 define-enum>number ] bi
+ ] each ;
+
+: define-enum-constructor ( word -- )
+ [ name>> "<" ">" surround create-in ] keep
+ [ number>enum ] curry (( number -- enum )) define-inline ;
+
+PRIVATE>
+
+: define-enum ( word base-type members -- )
+ [ dup define-enum-constructor ] 2dip
+ dup define-enum-members
+ <enum-c-type> swap typedef ;
+
+PREDICATE: enum-c-type-word < c-type-word
+ "c-type" word-prop enum-c-type? ;
"*" ?head
[ [ <pointer> ] dip parse-pointers ] when ;
-PRIVATE>
+: next-enum-member ( members name value -- members value' )
+ [ 2array suffix! ] [ 1 + ] bi ;
+
+: parse-enum-name ( -- name )
+ scan (CREATE-C-TYPE) dup save-location ;
+
+: parse-enum-base-type ( -- base-type token )
+ scan dup "<" =
+ [ drop scan-object scan ]
+ [ [ int ] dip ] if ;
-: define-enum-member ( word-string value -- next-value )
- [ create-in ] dip [ define-constant ] keep 1 + ;
+: parse-enum-member ( members name value -- members value' )
+ over "{" =
+ [ 2drop scan create-in scan-object next-enum-member "}" expect ]
+ [ [ create-in ] dip next-enum-member ] if ;
-: parse-enum-member ( word-string value -- next-value )
- over "{" =
- [ 2drop scan scan-object define-enum-member "}" expect ]
- [ define-enum-member ] if ;
+: parse-enum-members ( members counter token -- members )
+ dup ";" = not
+ [ swap parse-enum-member scan parse-enum-members ] [ 2drop ] if ;
+
+PRIVATE>
-: parse-enum-members ( counter -- )
- scan dup ";" = not
- [ swap parse-enum-member parse-enum-members ] [ 2drop ] if ;
+: parse-enum ( -- name base-type members )
+ parse-enum-name
+ parse-enum-base-type
+ [ V{ } clone 0 ] dip parse-enum-members ;
: scan-function-name ( -- return function )
scan-c-type scan parse-pointers ;
! Copyright (C) 2008 Slava Pestov.
! See http://factorcode.org/license.txt for BSD license.
-USING: accessors kernel combinators alien alien.strings alien.c-types
-alien.parser alien.syntax arrays assocs effects math.parser
-prettyprint.backend prettyprint.custom prettyprint.sections
-definitions see see.private sequences strings words ;
+USING: accessors kernel combinators alien alien.enums
+alien.strings alien.c-types alien.parser alien.syntax arrays
+assocs effects math.parser prettyprint.backend prettyprint.custom
+prettyprint.sections definitions see see.private sequences
+strings words ;
IN: alien.prettyprint
M: alien pprint*
")" text block>
]
} cleave ;
+
+M: enum-c-type-word definer
+ drop \ ENUM: \ ; ;
+M: enum-c-type-word synopsis*
+ {
+ [ seeing-word ]
+ [ definer. ]
+ [ pprint-word ]
+ [ c-type base-type>> dup int eq? [ drop ] [ "<" text pprint-word ] if ]
+ } cleave ;
+M: enum-c-type-word definition
+ c-type members>> ;
IN: alien.syntax
-USING: alien alien.c-types alien.parser alien.libraries
-classes.struct help.markup help.syntax see ;
+USING: alien alien.c-types alien.enums alien.libraries classes.struct
+help.markup help.syntax see ;
HELP: DLL"
{ $syntax "DLL\" path\"" }
{ $description "Aliases the C type " { $snippet "old" } " under the name " { $snippet "new" } "." }
{ $notes "This word differs from " { $link typedef } " in that it runs at parse time, to ensure correct ordering of operations when loading source files. Words defined in source files are compiled before top-level forms are run, so if a source file defines C binding words and uses " { $link typedef } ", the type alias won't be available at compile time." } ;
-HELP: C-ENUM:
-{ $syntax "C-ENUM: type/f words... ;" }
+HELP: ENUM:
+{ $syntax "ENUM: type words... ;" "ENUM: type < base-type words..." }
{ $values { "type" "a name to typedef to int or f" } { "words" "a sequence of word names" } }
-{ $description "Creates a sequence of word definitions in the current vocabulary. Each word pushes an integer according to the rules of C enums." }
-{ $notes "This word emulates a C-style " { $snippet "enum" } " in Factor. While this feature can be used for any purpose, using integer constants is discouraged unless it is for interfacing with C libraries. Factor code should use " { $link "words.symbol" } " or " { $link "singletons" } " instead." }
+{ $description "Creates a c-type that boxes and unboxes integer values to singletons. A singleton is defined for each member word. The base c-type can optionally be specified and defaults to " { $snippet "int" } ". A constructor word " { $snippet "<type>" } " is defined for converting from integers to singletons. The generic word " { $link enum>number } " converts from singletons to integers. Enum-typed values are automatically prettyprinted as their singleton words. Unrecognizing enum numbers are kept as numbers." }
{ $examples
"Here is an example enumeration definition:"
- { $code "C-ENUM: color_t red { green 3 } blue ;" }
- "It is equivalent to the following series of definitions:"
- { $code "CONSTANT: red 0" "CONSTANT: green 3" "CONSTANT: blue 4" }
+ { $code "ENUM: color_t red { green 3 } blue ;" }
+ "The following expression returns true:"
+ { $code "3 <color_t> [ green = ] [ enum>number 3 = ] bi and" }
} ;
HELP: C-TYPE:
! Copyright (C) 2005, 2010 Slava Pestov, Alex Chapman.
! See http://factorcode.org/license.txt for BSD license.
-USING: accessors arrays alien alien.c-types alien.arrays
+USING: accessors arrays alien alien.c-types alien.enums alien.arrays
alien.strings kernel math namespaces parser sequences words
quotations math.parser splitting grouping effects assocs
combinators lexer strings.parser alien.parser fry vocabs.parser
SYNTAX: TYPEDEF:
scan-c-type CREATE-C-TYPE dup save-location typedef ;
-SYNTAX: C-ENUM:
- scan dup "f" =
- [ drop ]
- [ (CREATE-C-TYPE) dup save-location int swap typedef ] if
- 0 parse-enum-members ;
+SYNTAX: ENUM:
+ parse-enum define-enum ;
SYNTAX: C-TYPE:
void CREATE-C-TYPE typedef ;
STRUCT: cairo_user_data_key_t
{ unused int } ;
-C-ENUM: cairo_status_t
+ENUM: cairo_status_t
CAIRO_STATUS_SUCCESS
CAIRO_STATUS_NO_MEMORY
CAIRO_STATUS_INVALID_RESTORE
cairo_pop_group_to_source ( cairo_t* cr ) ;
! Modify state
-C-ENUM: cairo_operator_t
+ENUM: cairo_operator_t
CAIRO_OPERATOR_CLEAR
CAIRO_OPERATOR_SOURCE
FUNCTION: void
cairo_set_tolerance ( cairo_t* cr, double tolerance ) ;
-C-ENUM: cairo_antialias_t
+ENUM: cairo_antialias_t
CAIRO_ANTIALIAS_DEFAULT
CAIRO_ANTIALIAS_NONE
CAIRO_ANTIALIAS_GRAY
FUNCTION: void
cairo_set_antialias ( cairo_t* cr, cairo_antialias_t antialias ) ;
-C-ENUM: cairo_fill_rule_t
+ENUM: cairo_fill_rule_t
CAIRO_FILL_RULE_WINDING
CAIRO_FILL_RULE_EVEN_ODD ;
FUNCTION: void
cairo_set_line_width ( cairo_t* cr, double width ) ;
-C-ENUM: cairo_line_cap_t
+ENUM: cairo_line_cap_t
CAIRO_LINE_CAP_BUTT
CAIRO_LINE_CAP_ROUND
CAIRO_LINE_CAP_SQUARE ;
FUNCTION: void
cairo_set_line_cap ( cairo_t* cr, cairo_line_cap_t line_cap ) ;
-C-ENUM: cairo_line_join_t
+ENUM: cairo_line_join_t
CAIRO_LINE_JOIN_MITER
CAIRO_LINE_JOIN_ROUND
CAIRO_LINE_JOIN_BEVEL ;
{ max_x_advance double }
{ max_y_advance double } ;
-C-ENUM: cairo_font_slant_t
+ENUM: cairo_font_slant_t
CAIRO_FONT_SLANT_NORMAL
CAIRO_FONT_SLANT_ITALIC
CAIRO_FONT_SLANT_OBLIQUE ;
-C-ENUM: cairo_font_weight_t
+ENUM: cairo_font_weight_t
CAIRO_FONT_WEIGHT_NORMAL
CAIRO_FONT_WEIGHT_BOLD ;
-C-ENUM: cairo_subpixel_order_t
+ENUM: cairo_subpixel_order_t
CAIRO_SUBPIXEL_ORDER_DEFAULT
CAIRO_SUBPIXEL_ORDER_RGB
CAIRO_SUBPIXEL_ORDER_BGR
CAIRO_SUBPIXEL_ORDER_VRGB
CAIRO_SUBPIXEL_ORDER_VBGR ;
-C-ENUM: cairo_hint_style_t
+ENUM: cairo_hint_style_t
CAIRO_HINT_STYLE_DEFAULT
CAIRO_HINT_STYLE_NONE
CAIRO_HINT_STYLE_SLIGHT
CAIRO_HINT_STYLE_MEDIUM
CAIRO_HINT_STYLE_FULL ;
-C-ENUM: cairo_hint_metrics_t
+ENUM: cairo_hint_metrics_t
CAIRO_HINT_METRICS_DEFAULT
CAIRO_HINT_METRICS_OFF
CAIRO_HINT_METRICS_ON ;
FUNCTION: cairo_status_t
cairo_font_face_status ( cairo_font_face_t* font_face ) ;
-C-ENUM: cairo_font_type_t
+ENUM: cairo_font_type_t
CAIRO_FONT_TYPE_TOY
CAIRO_FONT_TYPE_FT
CAIRO_FONT_TYPE_WIN32
FUNCTION: cairo_surface_t*
cairo_get_group_target ( cairo_t* cr ) ;
-C-ENUM: cairo_path_data_type_t
+ENUM: cairo_path_data_type_t
CAIRO_PATH_MOVE_TO
CAIRO_PATH_LINE_TO
CAIRO_PATH_CURVE_TO
FUNCTION: cairo_status_t
cairo_surface_status ( cairo_surface_t* surface ) ;
-C-ENUM: cairo_surface_type_t
+ENUM: cairo_surface_type_t
CAIRO_SURFACE_TYPE_IMAGE
CAIRO_SURFACE_TYPE_PDF
CAIRO_SURFACE_TYPE_PS
! Image-surface functions
-C-ENUM: cairo_format_t
+ENUM: cairo_format_t
CAIRO_FORMAT_ARGB32
CAIRO_FORMAT_RGB24
CAIRO_FORMAT_A8
FUNCTION: cairo_status_t
cairo_pattern_set_user_data ( cairo_pattern_t* pattern, cairo_user_data_key_t* key, void* user_data, cairo_destroy_func_t destroy ) ;
-C-ENUM: cairo_pattern_type_t
+ENUM: cairo_pattern_type_t
CAIRO_PATTERN_TYPE_SOLID
CAIRO_PATTERN_TYPE_SURFACE
CAIRO_PATTERN_TYPE_LINEAR
FUNCTION: void
cairo_pattern_get_matrix ( cairo_pattern_t* pattern, cairo_matrix_t* matrix ) ;
-C-ENUM: cairo_extend_t
+ENUM: cairo_extend_t
CAIRO_EXTEND_NONE
CAIRO_EXTEND_REPEAT
CAIRO_EXTEND_REFLECT
FUNCTION: cairo_extend_t
cairo_pattern_get_extend ( cairo_pattern_t* pattern ) ;
-C-ENUM: cairo_filter_t
+ENUM: cairo_filter_t
CAIRO_FILTER_FAST
CAIRO_FILTER_GOOD
CAIRO_FILTER_BEST
: <NSString> ( str -- alien ) <CFString> -> autorelease ;
-C-ENUM: f
-NSApplicationDelegateReplySuccess
-NSApplicationDelegateReplyCancel
-NSApplicationDelegateReplyFailure ;
+CONSTANT: NSApplicationDelegateReplySuccess 0
+CONSTANT: NSApplicationDelegateReplyCancel 1
+CONSTANT: NSApplicationDelegateReplyFailure 2
: with-autorelease-pool ( quot -- )
NSAutoreleasePool -> new [ call ] [ -> release ] bi* ; inline
! Copyright (C) 2008, 2010 Slava Pestov.
! See http://factorcode.org/license.txt for BSD license.
USING: math kernel layouts system strings words quotations byte-arrays
-alien alien.syntax arrays literals sequences ;
+alien arrays literals sequences ;
IN: compiler.constants
! These constants must match vm/memory.h
: segment-end-offset ( -- n ) 2 bootstrap-cells ; inline
! Relocation classes
-C-ENUM: f
- rc-absolute-cell
- rc-absolute
- rc-relative
- rc-absolute-ppc-2/2
- rc-absolute-ppc-2
- rc-relative-ppc-2
- rc-relative-ppc-3
- rc-relative-arm-3
- rc-indirect-arm
- rc-indirect-arm-pc
- rc-absolute-2
- rc-absolute-1 ;
+CONSTANT: rc-absolute-cell 0
+CONSTANT: rc-absolute 1
+CONSTANT: rc-relative 2
+CONSTANT: rc-absolute-ppc-2/2 3
+CONSTANT: rc-absolute-ppc-2 4
+CONSTANT: rc-relative-ppc-2 5
+CONSTANT: rc-relative-ppc-3 6
+CONSTANT: rc-relative-arm-3 7
+CONSTANT: rc-indirect-arm 8
+CONSTANT: rc-indirect-arm-pc 9
+CONSTANT: rc-absolute-2 10
+CONSTANT: rc-absolute-1 11
! Relocation types
-C-ENUM: f
- rt-dlsym
- rt-entry-point
- rt-entry-point-pic
- rt-entry-point-pic-tail
- rt-here
- rt-this
- rt-literal
- rt-untagged
- rt-megamorphic-cache-hits
- rt-vm
- rt-cards-offset
- rt-decks-offset
- rt-exception-handler
- rt-float ;
+CONSTANT: rt-dlsym 0
+CONSTANT: rt-entry-point 1
+CONSTANT: rt-entry-point-pic 2
+CONSTANT: rt-entry-point-pic-tail 3
+CONSTANT: rt-here 4
+CONSTANT: rt-this 5
+CONSTANT: rt-literal 6
+CONSTANT: rt-untagged 7
+CONSTANT: rt-megamorphic-cache-hits 8
+CONSTANT: rt-vm 9
+CONSTANT: rt-cards-offset 10
+CONSTANT: rt-decks-offset 11
+CONSTANT: rt-exception-handler 12
+CONSTANT: rt-float 13
: rc-absolute? ( n -- ? )
${
- rc-absolute-ppc-2/2
- rc-absolute-cell
- rc-absolute
- rc-absolute-2
- rc-absolute-1
+ $ rc-absolute-ppc-2/2
+ $ rc-absolute-cell
+ $ rc-absolute
+ $ rc-absolute-2
+ $ rc-absolute-1
} member? ;
opengl.gl literals ;
IN: core-graphics
-C-ENUM: CGImageAlphaInfo
-kCGImageAlphaNone
-kCGImageAlphaPremultipliedLast
-kCGImageAlphaPremultipliedFirst
-kCGImageAlphaLast
-kCGImageAlphaFirst
-kCGImageAlphaNoneSkipLast
-kCGImageAlphaNoneSkipFirst ;
+TYPEDEF: int CGImageAlphaInfo
+CONSTANT: kCGImageAlphaNone 0
+CONSTANT: kCGImageAlphaPremultipliedLast 1
+CONSTANT: kCGImageAlphaPremultipliedFirst 2
+CONSTANT: kCGImageAlphaLast 3
+CONSTANT: kCGImageAlphaFirst 4
+CONSTANT: kCGImageAlphaNoneSkipLast 5
+CONSTANT: kCGImageAlphaNoneSkipFirst 6
CONSTANT: kCGBitmapAlphaInfoMask HEX: 1f
CONSTANT: kCGBitmapFloatComponents 256
LIBRARY: pango
-C-ENUM: PangoStyle
+ENUM: PangoStyle
PANGO_STYLE_NORMAL
PANGO_STYLE_OBLIQUE
PANGO_STYLE_ITALIC ;
<PRIVATE
! Grapheme breaks
-C-ENUM: f Any L V T LV LVT Extend Control CR LF
- SpacingMark Prepend graphemes ;
+CONSTANT: Any 0
+CONSTANT: L 1
+CONSTANT: V 2
+CONSTANT: T 3
+CONSTANT: LV 4
+CONSTANT: LVT 5
+CONSTANT: Extend 6
+CONSTANT: Control 7
+CONSTANT: CR 8
+CONSTANT: LF 9
+CONSTANT: SpacingMark 10
+CONSTANT: Prepend 11
+CONSTANT: graphemes 12
: jamo-class ( ch -- class )
dup initial? [ drop L ]
"vocab:unicode/data/WordBreakProperty.txt" load-interval-file
to: word-break-table
-C-ENUM: f wOther wCR wLF wNewline wExtend wFormat wKatakana wALetter wMidLetter
-wMidNum wMidNumLet wNumeric wExtendNumLet words ;
+CONSTANT: wOther 0
+CONSTANT: wCR 1
+CONSTANT: wLF 2
+CONSTANT: wNewline 3
+CONSTANT: wExtend 4
+CONSTANT: wFormat 5
+CONSTANT: wKatakana 6
+CONSTANT: wALetter 7
+CONSTANT: wMidLetter 8
+CONSTANT: wMidNum 9
+CONSTANT: wMidNumLet 10
+CONSTANT: wNumeric 11
+CONSTANT: wExtendNumLet 12
+CONSTANT: words 13
: word-break-classes ( -- table ) ! Is there a way to avoid this?
H{
: vm-field-offset ( field -- offset ) vm offset-of ; inline
-C-ENUM: f
-collect-nursery-op
-collect-aging-op
-collect-to-tenured-op
-collect-full-op
-collect-compact-op
-collect-growing-heap-op ;
+CONSTANT: collect-nursery-op 0
+CONSTANT: collect-aging-op 1
+CONSTANT: collect-to-tenured-op 2
+CONSTANT: collect-full-op 3
+CONSTANT: collect-compact-op 4
+CONSTANT: collect-growing-heap-op 5
STRUCT: copying-sizes
{ size cell }
CONSTANT: TokenSandBoxInert 15
! } TOKEN_INFORMATION_CLASS;
-C-ENUM: ACCESS_MODE
+ENUM: ACCESS_MODE
NOT_USED_ACCESS
GRANT_ACCESS
SET_ACCESS
SET_AUDIT_SUCCESS
SET_AUDIT_FAILURE ;
-C-ENUM: MULTIPLE_TRUSTEE_OPERATION
+ENUM: MULTIPLE_TRUSTEE_OPERATION
NO_MULTIPLE_TRUSTEE
TRUSTEE_IS_IMPERSONATE ;
-C-ENUM: TRUSTEE_FORM
+ENUM: TRUSTEE_FORM
TRUSTEE_IS_SID
TRUSTEE_IS_NAME
TRUSTEE_BAD_FORM
TRUSTEE_IS_OBJECTS_AND_SID
TRUSTEE_IS_OBJECTS_AND_NAME ;
-C-ENUM: TRUSTEE_TYPE
+ENUM: TRUSTEE_TYPE
TRUSTEE_IS_UNKNOWN
TRUSTEE_IS_USER
TRUSTEE_IS_GROUP
TRUSTEE_IS_INVALID
TRUSTEE_IS_COMPUTER ;
-C-ENUM: SE_OBJECT_TYPE
+ENUM: SE_OBJECT_TYPE
SE_UNKNOWN_OBJECT_TYPE
SE_FILE_OBJECT
SE_SERVICE
CONSTANT: HIDP_LINK_COLLECTION_ROOT -1
CONSTANT: HIDP_LINK_COLLECTION_UNSPECIFIED 0
-C-ENUM: HIDP_REPORT_TYPE
+ENUM: HIDP_REPORT_TYPE
HidP_Input
HidP_Output
HidP_Feature ;
ULONG UsageListLength
) ;
-C-ENUM: HIDP_KEYBOARD_DIRECTION
+ENUM: HIDP_KEYBOARD_DIRECTION
HidP_Keyboard_Break
HidP_Keyboard_Make ;
FUNCTION: BOOL SetupRemoveFileLogEntryW ( HSPFILELOG FileLogHandle, PCWSTR LogSectionName, PCWSTR TargetFilename ) ;
ALIAS: SetupRemoveFileLogEntry SetupRemoveFileLogEntryW
-C-ENUM: SetupFileLogInfo
+ENUM: SetupFileLogInfo
SetupFileLogSourceFilename
SetupFileLogChecksum
SetupFileLogDiskTagfile
{ iInterface UCHAR } ;
TYPEDEF: USB_INTERFACE_DESCRIPTOR* PUSB_INTERFACE_DESCRIPTOR
-C-ENUM: USBD_PIPE_TYPE
+ENUM: USBD_PIPE_TYPE
UsbdPipeTypeControl
UsbdPipeTypeIsochronous
UsbdPipeTypeBulk
CONSTANT: D3D11_RETURN_TYPE_CONTINUED 8
TYPEDEF: int D3D11_RESOURCE_RETURN_TYPE
-C-ENUM: D3D11_CBUFFER_TYPE
+ENUM: D3D11_CBUFFER_TYPE
D3D11_CT_CBUFFER
D3D11_CT_TBUFFER
D3D11_CT_INTERFACE_POINTERS
CONSTANT: MAXD3DDECLUSAGEINDEX 15
CONSTANT: MAXD3DDECLLENGTH 64
-C-ENUM: D3DDECLMETHOD
+ENUM: D3DDECLMETHOD
D3DDECLMETHOD_DEFAULT
D3DDECLMETHOD_PARTIALU
D3DDECLMETHOD_PARTIALV
HRESULT ForwardTransform ( ID3D11UnorderedAccessView* pInputBuffer, ID3D11UnorderedAccessView** ppOutputBuffer )
HRESULT InverseTransform ( ID3D11UnorderedAccessView* pInputBuffer, ID3D11UnorderedAccessView** ppOutputBuffer ) ;
-C-ENUM: D3DX11_FFT_DATA_TYPE
+ENUM: D3DX11_FFT_DATA_TYPE
D3DX11_FFT_DATA_TYPE_REAL
D3DX11_FFT_DATA_TYPE_COMPLEX ;
{ UsageIndex UINT } ;
TYPEDEF: D3DXSEMANTIC* LPD3DXSEMANTIC
-C-ENUM: D3DXREGISTER_SET
+ENUM: D3DXREGISTER_SET
D3DXRS_BOOL
D3DXRS_INT4
D3DXRS_FLOAT4
D3DXRS_SAMPLER ;
TYPEDEF: D3DXREGISTER_SET* LPD3DXREGISTER_SET
-C-ENUM: D3DXPARAMETER_CLASS
+ENUM: D3DXPARAMETER_CLASS
D3DXPC_SCALAR
D3DXPC_VECTOR
D3DXPC_MATRIX_ROWS
D3DXPC_STRUCT ;
TYPEDEF: D3DXPARAMETER_CLASS* LPD3DXPARAMETER_CLASS
-C-ENUM: D3DXPARAMETER_TYPE
+ENUM: D3DXPARAMETER_TYPE
D3DXPT_VOID
D3DXPT_BOOL
D3DXPT_INT
HRESULT SetMatrixTransposeArray ( D3DXHANDLE hConstant, D3DXMATRIX* pMatrix, UINT Count )
HRESULT SetMatrixTransposePointerArray ( D3DXHANDLE hConstant, D3DXMATRIX** ppMatrix, UINT Count ) ;
-C-ENUM: D3DXINCLUDE_TYPE
+ENUM: D3DXINCLUDE_TYPE
D3DXINC_LOCAL
D3DXINC_SYSTEM ;
TYPEDEF: D3DXINCLUDE_TYPE* LPD3DXINCLUDE_TYPE
USING: alien.c-types alien.syntax ;
IN: windows.directx.dcommon
-C-ENUM: DWRITE_MEASURING_MODE
+ENUM: DWRITE_MEASURING_MODE
DWRITE_MEASURING_MODE_NATURAL
DWRITE_MEASURING_MODE_GDI_CLASSIC
DWRITE_MEASURING_MODE_GDI_NATURAL ;
LIBRARY: dwrite
-C-ENUM: DWRITE_FONT_FILE_TYPE
+ENUM: DWRITE_FONT_FILE_TYPE
DWRITE_FONT_FILE_TYPE_UNKNOWN
DWRITE_FONT_FILE_TYPE_CFF
DWRITE_FONT_FILE_TYPE_TRUETYPE
DWRITE_FONT_FILE_TYPE_VECTOR
DWRITE_FONT_FILE_TYPE_BITMAP ;
-C-ENUM: DWRITE_FONT_FACE_TYPE
+ENUM: DWRITE_FONT_FACE_TYPE
DWRITE_FONT_FACE_TYPE_CFF
DWRITE_FONT_FACE_TYPE_TRUETYPE
DWRITE_FONT_FACE_TYPE_TRUETYPE_COLLECTION
DWRITE_FONT_FACE_TYPE_BITMAP
DWRITE_FONT_FACE_TYPE_UNKNOWN ;
-C-ENUM: DWRITE_FONT_SIMULATIONS
+ENUM: DWRITE_FONT_SIMULATIONS
DWRITE_FONT_SIMULATIONS_NONE
DWRITE_FONT_SIMULATIONS_BOLD
DWRITE_FONT_SIMULATIONS_OBLIQUE ;
-C-ENUM: DWRITE_FONT_WEIGHT
+ENUM: DWRITE_FONT_WEIGHT
{ DWRITE_FONT_WEIGHT_THIN 100 }
{ DWRITE_FONT_WEIGHT_EXTRA_LIGHT 200 }
{ DWRITE_FONT_WEIGHT_ULTRA_LIGHT 200 }
{ DWRITE_FONT_WEIGHT_EXTRA_BLACK 950 }
{ DWRITE_FONT_WEIGHT_ULTRA_BLACK 950 } ;
-C-ENUM: DWRITE_FONT_STRETCH
+ENUM: DWRITE_FONT_STRETCH
{ DWRITE_FONT_STRETCH_UNDEFINED 0 }
{ DWRITE_FONT_STRETCH_ULTRA_CONDENSED 1 }
{ DWRITE_FONT_STRETCH_EXTRA_CONDENSED 2 }
{ DWRITE_FONT_STRETCH_EXTRA_EXPANDED 8 }
{ DWRITE_FONT_STRETCH_ULTRA_EXPANDED 9 } ;
-C-ENUM: DWRITE_FONT_STYLE
+ENUM: DWRITE_FONT_STYLE
DWRITE_FONT_STYLE_NORMAL
DWRITE_FONT_STYLE_OBLIQUE
DWRITE_FONT_STYLE_ITALIC ;
-C-ENUM: DWRITE_INFORMATIONAL_STRING_ID
+ENUM: DWRITE_INFORMATIONAL_STRING_ID
DWRITE_INFORMATIONAL_STRING_NONE
DWRITE_INFORMATIONAL_STRING_COPYRIGHT_NOTICE
DWRITE_INFORMATIONAL_STRING_VERSION_STRINGS
{ advanceOffset FLOAT }
{ ascenderOffset FLOAT } ;
-C-ENUM: DWRITE_FACTORY_TYPE
+ENUM: DWRITE_FACTORY_TYPE
DWRITE_FACTORY_TYPE_SHARED
DWRITE_FACTORY_TYPE_ISOLATED ;
HRESULT GetLoader ( IDWriteFontFileLoader** fontFileLoader )
HRESULT Analyze ( BOOL* isSupportedFontType, DWRITE_FONT_FILE_TYPE* fontFileType, DWRITE_FONT_FACE_TYPE* fontFaceType, UINT32* numberOfFaces ) ;
-C-ENUM: DWRITE_PIXEL_GEOMETRY
+ENUM: DWRITE_PIXEL_GEOMETRY
DWRITE_PIXEL_GEOMETRY_FLAT
DWRITE_PIXEL_GEOMETRY_RGB
DWRITE_PIXEL_GEOMETRY_BGR ;
-C-ENUM: DWRITE_RENDERING_MODE
+ENUM: DWRITE_RENDERING_MODE
DWRITE_RENDERING_MODE_DEFAULT
DWRITE_RENDERING_MODE_ALIASED
DWRITE_RENDERING_MODE_CLEARTYPE_GDI_CLASSIC
HRESULT HasCharacter ( UINT32 unicodeValue, BOOL* exists )
HRESULT CreateFontFace ( IDWriteFontFace** fontFace ) ;
-C-ENUM: DWRITE_READING_DIRECTION
+ENUM: DWRITE_READING_DIRECTION
DWRITE_READING_DIRECTION_LEFT_TO_RIGHT
DWRITE_READING_DIRECTION_RIGHT_TO_LEFT ;
-C-ENUM: DWRITE_FLOW_DIRECTION
+ENUM: DWRITE_FLOW_DIRECTION
DWRITE_FLOW_DIRECTION_TOP_TO_BOTTOM ;
-C-ENUM: DWRITE_TEXT_ALIGNMENT
+ENUM: DWRITE_TEXT_ALIGNMENT
DWRITE_TEXT_ALIGNMENT_LEADING
DWRITE_TEXT_ALIGNMENT_TRAILING
DWRITE_TEXT_ALIGNMENT_CENTER ;
-C-ENUM: DWRITE_PARAGRAPH_ALIGNMENT
+ENUM: DWRITE_PARAGRAPH_ALIGNMENT
DWRITE_PARAGRAPH_ALIGNMENT_NEAR
DWRITE_PARAGRAPH_ALIGNMENT_FAR
DWRITE_PARAGRAPH_ALIGNMENT_CENTER ;
-C-ENUM: DWRITE_WORD_WRAPPING
+ENUM: DWRITE_WORD_WRAPPING
DWRITE_WORD_WRAPPING_WRAP
DWRITE_WORD_WRAPPING_NO_WRAP ;
-C-ENUM: DWRITE_LINE_SPACING_METHOD
+ENUM: DWRITE_LINE_SPACING_METHOD
DWRITE_LINE_SPACING_METHOD_DEFAULT
DWRITE_LINE_SPACING_METHOD_UNIFORM ;
-C-ENUM: DWRITE_TRIMMING_GRANULARITY
+ENUM: DWRITE_TRIMMING_GRANULARITY
DWRITE_TRIMMING_GRANULARITY_NONE
DWRITE_TRIMMING_GRANULARITY_CHARACTER
DWRITE_TRIMMING_GRANULARITY_WORD ;
UINT32 GetFontFeatureCount ( )
HRESULT GetFontFeature ( UINT32 fontFeatureIndex, DWRITE_FONT_FEATURE* fontFeature ) ;
-C-ENUM: DWRITE_SCRIPT_SHAPES
+ENUM: DWRITE_SCRIPT_SHAPES
DWRITE_SCRIPT_SHAPES_DEFAULT
DWRITE_SCRIPT_SHAPES_NO_VISUAL ;
{ script USHORT }
{ shapes DWRITE_SCRIPT_SHAPES } ;
-C-ENUM: DWRITE_BREAK_CONDITION
+ENUM: DWRITE_BREAK_CONDITION
DWRITE_BREAK_CONDITION_NEUTRAL
DWRITE_BREAK_CONDITION_CAN_BREAK
DWRITE_BREAK_CONDITION_MAY_NOT_BREAK
STRUCT: DWRITE_LINE_BREAKPOINT
{ data BYTE } ;
-C-ENUM: DWRITE_NUMBER_SUBSTITUTION_METHOD
+ENUM: DWRITE_NUMBER_SUBSTITUTION_METHOD
DWRITE_NUMBER_SUBSTITUTION_METHOD_FROM_CULTURE
DWRITE_NUMBER_SUBSTITUTION_METHOD_CONTEXTUAL
DWRITE_NUMBER_SUBSTITUTION_METHOD_NONE
HRESULT CreateFontFaceFromHdc ( HDC hdc, IDWriteFontFace** fontFace )
HRESULT CreateBitmapRenderTarget ( HDC hdc, UINT32 width, UINT32 height, IDWriteBitmapRenderTarget** renderTarget ) ;
-C-ENUM: DWRITE_TEXTURE_TYPE
+ENUM: DWRITE_TEXTURE_TYPE
DWRITE_TEXTURE_ALIASED_1x1
DWRITE_TEXTURE_CLEARTYPE_3x1 ;
{ Numerator UINT }
{ Denominator UINT } ;
-C-ENUM: DXGI_MODE_SCANLINE_ORDER
+ENUM: DXGI_MODE_SCANLINE_ORDER
DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED
DXGI_MODE_SCANLINE_ORDER_PROGRESSIVE
DXGI_MODE_SCANLINE_ORDER_UPPER_FIELD_FIRST
DXGI_MODE_SCANLINE_ORDER_LOWER_FIELD_FIRST ;
-C-ENUM: DXGI_MODE_SCALING
+ENUM: DXGI_MODE_SCALING
DXGI_MODE_SCALING_UNSPECIFIED
DXGI_MODE_SCALING_CENTERED
DXGI_MODE_SCALING_STRETCHED ;
-C-ENUM: DXGI_MODE_ROTATION
+ENUM: DXGI_MODE_ROTATION
DXGI_MODE_ROTATION_UNSPECIFIED
DXGI_MODE_ROTATION_IDENTITY
DXGI_MODE_ROTATION_ROTATE90
{ pFormat WAVEFORMATEX* }
{ MaxFrameCount UINT32 } ;
-C-ENUM: XAPO_BUFFER_FLAGS
+ENUM: XAPO_BUFFER_FLAGS
XAPO_BUFFER_SILENT
XAPO_BUFFER_VALID ;
{ EffectCount UINT32 }
{ pEffectDescriptors XAUDIO2_EFFECT_DESCRIPTOR* } ;
-C-ENUM: XAUDIO2_FILTER_TYPE
+ENUM: XAUDIO2_FILTER_TYPE
LowPassFilter
BandPassFilter
HighPassFilter
CONSTANT: THREAD_PRIORITY_NORMAL 0
CONSTANT: THREAD_PRIORITY_TIME_CRITICAL 15
-C-ENUM: COMPUTER_NAME_FORMAT
+ENUM: COMPUTER_NAME_FORMAT
ComputerNameNetBIOS
ComputerNameDnsHostname
ComputerNameDnsDomain
int* piLogicalToVisual
) ;
-C-ENUM: f
- SCRIPT_JUSTIFY_NONE
- SCRIPT_JUSTIFY_ARABIC_BLANK
- SCRIPT_JUSTIFY_CHARACTER
- SCRIPT_JUSTIFY_RESERVED1
- SCRIPT_JUSTIFY_BLANK
- SCRIPT_JUSTIFY_RESERVED2
- SCRIPT_JUSTIFY_RESERVED3
- SCRIPT_JUSTIFY_ARABIC_NORMAL
- SCRIPT_JUSTIFY_ARABIC_KASHIDA
- SCRIPT_JUSTIFY_ALEF
- SCRIPT_JUSTIFY_HA
- SCRIPT_JUSTIFY_RA
- SCRIPT_JUSTIFY_BA
- SCRIPT_JUSTIFY_BARA
- SCRIPT_JUSTIFY_SEEN
- SCRIPT_JUSTIFFY_RESERVED4 ;
+CONSTANT: SCRIPT_JUSTIFY_NONE 0
+CONSTANT: SCRIPT_JUSTIFY_ARABIC_BLANK 1
+CONSTANT: SCRIPT_JUSTIFY_CHARACTER 2
+CONSTANT: SCRIPT_JUSTIFY_RESERVED1 3
+CONSTANT: SCRIPT_JUSTIFY_BLANK 4
+CONSTANT: SCRIPT_JUSTIFY_RESERVED2 5
+CONSTANT: SCRIPT_JUSTIFY_RESERVED3 6
+CONSTANT: SCRIPT_JUSTIFY_ARABIC_NORMAL 7
+CONSTANT: SCRIPT_JUSTIFY_ARABIC_KASHIDA 8
+CONSTANT: SCRIPT_JUSTIFY_ALEF 9
+CONSTANT: SCRIPT_JUSTIFY_HA 10
+CONSTANT: SCRIPT_JUSTIFY_RA 11
+CONSTANT: SCRIPT_JUSTIFY_BA 12
+CONSTANT: SCRIPT_JUSTIFY_BARA 13
+CONSTANT: SCRIPT_JUSTIFY_SEEN 14
+CONSTANT: SCRIPT_JUSTIFFY_RESERVED4 15
STRUCT: SCRIPT_VISATTR
{ flags WORD } ;
! * EXTENDED WINDOW MANAGER HINTS
! *****************************************************************
-C-ENUM: f _NET_WM_STATE_REMOVE _NET_WM_STATE_ADD _NET_WM_STATE_TOGGLE ;
+CONSTANT: _NET_WM_STATE_REMOVE 0
+CONSTANT: _NET_WM_STATE_ADD 1
+CONSTANT: _NET_WM_STATE_TOGGLE 2
{ t cpFloat }
{ n cpVect } ;
-C-ENUM: cpShapeType
+ENUM: cpShapeType
CP_CIRCLE_SHAPE
CP_SEGMENT_SHAPE
CP_POLY_SHAPE
FUNCTION: cpContact* cpContactInit ( cpContact* con, cpVect p, cpVect n, cpFloat dist, cpHashValue hash ) ;
-C-ENUM: cpArbiterState
+ENUM: cpArbiterState
cpArbiterStateNormal
cpArbiterStateFirstColl
cpArbiterStateIgnore ;
STRUCT: CUuuid
{ bytes char[16] } ;
-C-ENUM: CUctx_flags
+ENUM: CUctx_flags
{ CU_CTX_SCHED_AUTO 0 }
{ CU_CTX_SCHED_SPIN 1 }
{ CU_CTX_SCHED_YIELD 2 }
{ CU_CTX_LMEM_RESIZE_TO_MAX 16 }
{ CU_CTX_FLAGS_MASK HEX: 1f } ;
-C-ENUM: CUevent_flags
+ENUM: CUevent_flags
{ CU_EVENT_DEFAULT 0 }
{ CU_EVENT_BLOCKING_SYNC 1 } ;
-C-ENUM: CUarray_format
+ENUM: CUarray_format
{ CU_AD_FORMAT_UNSIGNED_INT8 HEX: 01 }
{ CU_AD_FORMAT_UNSIGNED_INT16 HEX: 02 }
{ CU_AD_FORMAT_UNSIGNED_INT32 HEX: 03 }
{ CU_AD_FORMAT_HALF HEX: 10 }
{ CU_AD_FORMAT_FLOAT HEX: 20 } ;
-C-ENUM: CUaddress_mode
+ENUM: CUaddress_mode
{ CU_TR_ADDRESS_MODE_WRAP 0 }
{ CU_TR_ADDRESS_MODE_CLAMP 1 }
{ CU_TR_ADDRESS_MODE_MIRROR 2 } ;
-C-ENUM: CUfilter_mode
+ENUM: CUfilter_mode
{ CU_TR_FILTER_MODE_POINT 0 }
{ CU_TR_FILTER_MODE_LINEAR 1 } ;
-C-ENUM: CUdevice_attribute
+ENUM: CUdevice_attribute
{ CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK 1 }
{ CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X 2 }
{ CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y 3 }
{ clockRate int }
{ textureAlign int } ;
-C-ENUM: CUfunction_attribute
+ENUM: CUfunction_attribute
{ CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK 0 }
{ CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES 1 }
{ CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES 2 }
{ CU_FUNC_ATTRIBUTE_BINARY_VERSION 6 }
CU_FUNC_ATTRIBUTE_MAX ;
-C-ENUM: CUfunc_cache
+ENUM: CUfunc_cache
{ CU_FUNC_CACHE_PREFER_NONE HEX: 00 }
{ CU_FUNC_CACHE_PREFER_SHARED HEX: 01 }
{ CU_FUNC_CACHE_PREFER_L1 HEX: 02 } ;
-C-ENUM: CUmemorytype
+ENUM: CUmemorytype
{ CU_MEMORYTYPE_HOST HEX: 01 }
{ CU_MEMORYTYPE_DEVICE HEX: 02 }
{ CU_MEMORYTYPE_ARRAY HEX: 03 } ;
-C-ENUM: CUcomputemode
+ENUM: CUcomputemode
{ CU_COMPUTEMODE_DEFAULT 0 }
{ CU_COMPUTEMODE_EXCLUSIVE 1 }
{ CU_COMPUTEMODE_PROHIBITED 2 } ;
-C-ENUM: CUjit_option
+ENUM: CUjit_option
{ CU_JIT_MAX_REGISTERS 0 }
CU_JIT_THREADS_PER_BLOCK
CU_JIT_WALL_TIME
CU_JIT_TARGET
CU_JIT_FALLBACK_STRATEGY ;
-C-ENUM: CUjit_target
+ENUM: CUjit_target
{ CU_TARGET_COMPUTE_10 0 }
CU_TARGET_COMPUTE_11
CU_TARGET_COMPUTE_12
CU_TARGET_COMPUTE_13
CU_TARGET_COMPUTE_20 ;
-C-ENUM: CUjit_fallback
+ENUM: CUjit_fallback
{ CU_PREFER_PTX 0 }
CU_PREFER_BINARY ;
-C-ENUM: CUgraphicsRegisterFlags
+ENUM: CUgraphicsRegisterFlags
{ CU_GRAPHICS_REGISTER_FLAGS_NONE 0 } ;
-C-ENUM: CUgraphicsMapResourceFlags
+ENUM: CUgraphicsMapResourceFlags
{ CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE HEX: 00 }
{ CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY HEX: 01 }
{ CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD HEX: 02 } ;
-C-ENUM: CUarray_cubemap_face
+ENUM: CUarray_cubemap_face
{ CU_CUBEMAP_FACE_POSITIVE_X HEX: 00 }
{ CU_CUBEMAP_FACE_NEGATIVE_X HEX: 01 }
{ CU_CUBEMAP_FACE_POSITIVE_Y HEX: 02 }
{ CU_CUBEMAP_FACE_POSITIVE_Z HEX: 04 }
{ CU_CUBEMAP_FACE_NEGATIVE_Z HEX: 05 } ;
-C-ENUM: CUresult
+ENUM: CUresult
{ CUDA_SUCCESS 0 }
{ CUDA_ERROR_INVALID_VALUE 1 }
{ CUDA_ERROR_OUT_OF_MEMORY 2 }
-USING: cuda.ptx tools.test ;
+USING: cuda.ptx io.streams.string tools.test ;
IN: cuda.ptx.tests
[ """ .version 2.0
} ptx>string
] unit-test
+[ "a" ] [ [ "a" write-ptx-operand ] with-string-writer ] unit-test
+[ "2" ] [ [ 2 write-ptx-operand ] with-string-writer ] unit-test
+[ "0d4000000000000000" ] [ [ 2.0 write-ptx-operand ] with-string-writer ] unit-test
+[ "!a" ] [ [ T{ ptx-negation f "a" } write-ptx-operand ] with-string-writer ] unit-test
+[ "{a, b, c, d}" ] [ [ T{ ptx-vector f { "a" "b" "c" "d" } } write-ptx-operand ] with-string-writer ] unit-test
+[ "[a]" ] [ [ T{ ptx-indirect f "a" 0 } write-ptx-operand ] with-string-writer ] unit-test
+[ "[a+1]" ] [ [ T{ ptx-indirect f "a" 1 } write-ptx-operand ] with-string-writer ] unit-test
+[ "[a-1]" ] [ [ T{ ptx-indirect f "a" -1 } write-ptx-operand ] with-string-writer ] unit-test
+[ "a[1]" ] [ [ T{ ptx-element f "a" 1 } write-ptx-operand ] with-string-writer ] unit-test
+[ "{a, b[2], 3, 0d4000000000000000}" ] [ [ T{ ptx-vector f { "a" T{ ptx-element f "b" 2 } 3 2.0 } } write-ptx-operand ] with-string-writer ] unit-test
+
[ """ .version 2.0
.target sm_20
abs.s32 a, b;
{ body {
T{ abs { type .s32 } { dest "a" } { a "b" } }
T{ abs
- { predicate T{ ptx-predicate { variable "p" } } }
+ { predicate "p" }
{ type .s32 } { dest "a" } { a "b" }
}
T{ abs
- { predicate T{ ptx-predicate { negated? t } { variable "p" } } }
+ { predicate T{ ptx-negation f "p" } }
{ type .s32 } { dest "a" } { a "b" }
}
T{ abs
{ version "2.0" }
{ target T{ ptx-target { arch sm_20 } } }
{ body {
- T{ atom { op .and } { type .u32 } { dest "a" } { a "[b]" } { b "c" } }
- T{ atom { storage-space .global } { op .or } { type .u32 } { dest "a" } { a "[b]" } { b "c" } }
- T{ atom { storage-space .shared } { op .cas } { type .u32 } { dest "a" } { a "[b]" } { b "c" } { c "d" } }
+ T{ atom { op .and } { type .u32 } { dest "a" } { a T{ ptx-indirect f "b" } } { b "c" } }
+ T{ atom { storage-space .global } { op .or } { type .u32 } { dest "a" } { a T{ ptx-indirect f "b" } } { b "c" } }
+ T{ atom { storage-space .shared } { op .cas } { type .u32 } { dest "a" } { a T{ ptx-indirect f "b" } } { b "c" } { c "d" } }
} }
} ptx>string
{ body {
T{ bar.arrive { a "a" } { b "b" } }
T{ bar.red { op .popc } { type .u32 } { dest "a" } { a "b" } { c "d" } }
- T{ bar.red { op .popc } { type .u32 } { dest "a" } { a "b" } { c "!d" } }
- T{ bar.red { op .popc } { type .u32 } { dest "a" } { a "b" } { b "c" } { c "!d" } }
+ T{ bar.red { op .popc } { type .u32 } { dest "a" } { a "b" } { c T{ ptx-negation f "d" } } }
+ T{ bar.red { op .popc } { type .u32 } { dest "a" } { a "b" } { b "c" } { c T{ ptx-negation f "d" } } }
T{ bar.sync { a "a" } }
T{ bar.sync { a "a" } { b "b" } }
} }
call (a), foo, (b);
call (a), foo, (b, c);
call (a), foo, (b, c, d);
+ call (a[2]), foo, (b, c, d[3]);
call foo, (b, c, d);
""" ] [
T{ ptx
T{ call { return "a" } { target "foo" } { params { "b" } } }
T{ call { return "a" } { target "foo" } { params { "b" "c" } } }
T{ call { return "a" } { target "foo" } { params { "b" "c" "d" } } }
+ T{ call { return T{ ptx-element f "a" 2 } } { target "foo" } { params { "b" "c" T{ ptx-element f "d" 3 } } } }
T{ call { target "foo" } { params { "b" "c" "d" } } }
} }
} ptx>string
{ version "2.0" }
{ target T{ ptx-target { arch sm_20 } } }
{ body {
- T{ ld { type .u32 } { dest "a" } { a "[b]" } }
- T{ ld { type T{ .v2 { of .u32 } } } { dest "a" } { a "[b]" } }
- T{ ld { type T{ .v4 { of .u32 } } } { dest "a" } { a "[b]" } }
- T{ ld { type T{ .v4 { of .u32 } } } { dest "{a, b, c, d}" } { a "[e]" } }
+ T{ ld { type .u32 } { dest "a" } { a T{ ptx-indirect f "b" } } }
+ T{ ld { type T{ .v2 { of .u32 } } } { dest "a" } { a T{ ptx-indirect f "b" } } }
+ T{ ld { type T{ .v4 { of .u32 } } } { dest "a" } { a T{ ptx-indirect f "b" } } }
+ T{ ld { type T{ .v4 { of .u32 } } } { dest T{ ptx-vector f { "a" "b" "c" "d" } } } { a "[e]" } }
T{ ld { cache-op .lu } { type .u32 } { dest "a" } { a "[b]" } }
- T{ ld { storage-space T{ .const } } { cache-op .lu } { type .u32 } { dest "a" } { a "[b]" } }
- T{ ld { volatile? t } { storage-space T{ .const { bank 5 } } } { type .u32 } { dest "a" } { a "[b]" } }
+ T{ ld { storage-space T{ .const } } { cache-op .lu } { type .u32 } { dest "a" } { a T{ ptx-indirect f "b" } } }
+ T{ ld { volatile? t } { storage-space T{ .const { bank 5 } } } { type .u32 } { dest "a" } { a T{ ptx-indirect f "b" } } }
} }
} ptx>string
] unit-test
{ version "2.0" }
{ target T{ ptx-target { arch sm_20 } } }
{ body {
- T{ ldu { type .u32 } { dest "a" } { a "[b]" } }
- T{ ldu { type T{ .v2 { of .u32 } } } { dest "a" } { a "[b]" } }
- T{ ldu { type T{ .v4 { of .u32 } } } { dest "a" } { a "[b]" } }
- T{ ldu { type T{ .v4 { of .u32 } } } { dest "{a, b, c, d}" } { a "[e]" } }
+ T{ ldu { type .u32 } { dest "a" } { a T{ ptx-indirect f "b" } } }
+ T{ ldu { type T{ .v2 { of .u32 } } } { dest "a" } { a T{ ptx-indirect f "b" } } }
+ T{ ldu { type T{ .v4 { of .u32 } } } { dest "a" } { a T{ ptx-indirect f "b" } } }
+ T{ ldu { type T{ .v4 { of .u32 } } } { dest T{ ptx-vector f { "a" "b" "c" "d" } } } { a "[e]" } }
T{ ldu { cache-op .lu } { type .u32 } { dest "a" } { a "[b]" } }
- T{ ldu { storage-space T{ .const } } { cache-op .lu } { type .u32 } { dest "a" } { a "[b]" } }
- T{ ldu { volatile? t } { storage-space T{ .const { bank 5 } } } { type .u32 } { dest "a" } { a "[b]" } }
+ T{ ldu { storage-space T{ .const } } { cache-op .lu } { type .u32 } { dest "a" } { a T{ ptx-indirect f "b" } } }
+ T{ ldu { volatile? t } { storage-space T{ .const { bank 5 } } } { type .u32 } { dest "a" } { a T{ ptx-indirect f "b" } } }
} }
} ptx>string
] unit-test
{ version "2.0" }
{ target T{ ptx-target { arch sm_20 } } }
{ body {
- T{ prefetch { level .L1 } { a "[a]" } }
- T{ prefetch { storage-space .local } { level .L2 } { a "[a]" } }
- T{ prefetchu { level .L1 } { a "[a]" } }
+ T{ prefetch { level .L1 } { a T{ ptx-indirect f "a" } } }
+ T{ prefetch { storage-space .local } { level .L2 } { a T{ ptx-indirect f "a" } } }
+ T{ prefetchu { level .L1 } { a T{ ptx-indirect f "a" } } }
} }
} ptx>string
] unit-test
{ version "2.0" }
{ target T{ ptx-target { arch sm_20 } } }
{ body {
- T{ red { op .and } { type .u32 } { dest "[a]" } { a "b" } }
- T{ red { storage-space .global } { op .and } { type .u32 } { dest "[a]" } { a "b" } }
+ T{ red { op .and } { type .u32 } { dest T{ ptx-indirect f "a" } } { a "b" } }
+ T{ red { storage-space .global } { op .and } { type .u32 } { dest T{ ptx-indirect f "a" } } { a "b" } }
} }
} ptx>string
] unit-test
T{ set { cmp-op .gt } { dest-type .u32 } { type .s32 } { dest "a" } { a "b" } { b "c" } }
T{ set { cmp-op .gt } { ftz? t } { dest-type .u32 } { type .f32 } { dest "a" } { a "b" } { b "c" } }
T{ set { cmp-op .gt } { bool-op .and } { ftz? t } { dest-type .u32 } { type .f32 } { dest "a" } { a "b" } { b "c" } { c "d" } }
- T{ set { cmp-op .gt } { bool-op .and } { ftz? t } { dest-type .u32 } { type .f32 } { dest "a" } { a "b" } { b "c" } { c "!d" } }
+ T{ set { cmp-op .gt } { bool-op .and } { ftz? t } { dest-type .u32 } { type .f32 } { dest "a" } { a "b" } { b "c" } { c T{ ptx-negation f "d" } } }
} }
} ptx>string
] unit-test
{ version "2.0" }
{ target T{ ptx-target { arch sm_20 } } }
{ body {
- T{ st { type .u32 } { dest "[a]" } { a "b" } }
- T{ st { type T{ .v2 { of .u32 } } } { dest "[a]" } { a "b" } }
- T{ st { type T{ .v4 { of .u32 } } } { dest "[a]" } { a "b" } }
- T{ st { type T{ .v4 { of .u32 } } } { dest "[a]" } { a "{b, c, d, e}" } }
- T{ st { cache-op .lu } { type .u32 } { dest "[a]" } { a "b" } }
- T{ st { storage-space .local } { cache-op .lu } { type .u32 } { dest "[a]" } { a "b" } }
- T{ st { volatile? t } { storage-space .local } { type .u32 } { dest "[a]" } { a "b" } }
+ T{ st { type .u32 } { dest T{ ptx-indirect f "a" } } { a "b" } }
+ T{ st { type T{ .v2 { of .u32 } } } { dest T{ ptx-indirect f "a" } } { a "b" } }
+ T{ st { type T{ .v4 { of .u32 } } } { dest T{ ptx-indirect f "a" } } { a "b" } }
+ T{ st { type T{ .v4 { of .u32 } } } { dest T{ ptx-indirect f "a" } } { a T{ ptx-vector f { "b" "c" "d" "e" } } } }
+ T{ st { cache-op .lu } { type .u32 } { dest T{ ptx-indirect f "a" } } { a "b" } }
+ T{ st { storage-space .local } { cache-op .lu } { type .u32 } { dest T{ ptx-indirect f "a" } } { a "b" } }
+ T{ st { volatile? t } { storage-space .local } { type .u32 } { dest T{ ptx-indirect f "a" } } { a "b" } }
} }
} ptx>string
] unit-test
{ initializer ?string } ;
UNION: ?ptx-variable POSTPONE: f ptx-variable ;
-TUPLE: ptx-predicate
- { negated? boolean }
- { variable string } ;
-UNION: ?ptx-predicate POSTPONE: f ptx-predicate ;
+TUPLE: ptx-negation
+ { var string } ;
+
+TUPLE: ptx-vector
+ elements ;
+
+TUPLE: ptx-element
+ { var string }
+ { index integer } ;
+
+UNION: ptx-var
+ string ptx-element ;
+
+TUPLE: ptx-indirect
+ { base ptx-var }
+ { offset integer } ;
+
+UNION: ptx-operand
+ integer float ptx-var ptx-negation ptx-vector ptx-indirect ;
+UNION: ?ptx-operand POSTPONE: f ptx-operand ;
TUPLE: ptx-instruction
{ label ?string }
- { predicate ?ptx-predicate } ;
+ { predicate ?ptx-operand } ;
TUPLE: ptx-entry
{ name string }
TUPLE: ptx-typed-instruction < ptx-instruction
{ type ptx-type }
- { dest string } ;
+ { dest ptx-operand } ;
TUPLE: ptx-2op-instruction < ptx-typed-instruction
- { a string } ;
+ { a ptx-operand } ;
TUPLE: ptx-3op-instruction < ptx-typed-instruction
- { a string }
- { b string } ;
+ { a ptx-operand }
+ { b ptx-operand } ;
TUPLE: ptx-4op-instruction < ptx-typed-instruction
- { a string }
- { b string }
- { c string } ;
+ { a ptx-operand }
+ { b ptx-operand }
+ { c ptx-operand } ;
TUPLE: ptx-5op-instruction < ptx-typed-instruction
- { a string }
- { b string }
- { c string }
- { d string } ;
+ { a ptx-operand }
+ { b ptx-operand }
+ { c ptx-operand }
+ { d ptx-operand } ;
TUPLE: ptx-addsub-instruction < ptx-3op-instruction
{ sat? boolean }
TUPLE: ptx-set-instruction < ptx-3op-instruction
{ cmp-op ptx-cmp-op }
{ bool-op ?ptx-op }
- { c ?string }
+ { c ?ptx-operand }
{ ftz? boolean } ;
VARIANT: ptx-cache-op
TUPLE: atom < ptx-3op-instruction
{ storage-space ?ptx-storage-space }
{ op ptx-op }
- { c ?string } ;
+ { c ?ptx-operand } ;
TUPLE: bar.arrive < ptx-instruction
- { a string }
- { b string } ;
+ { a ptx-operand }
+ { b ptx-operand } ;
TUPLE: bar.red < ptx-2op-instruction
{ op ptx-op }
- { b ?string }
- { c string } ;
+ { b ?ptx-operand }
+ { c ptx-operand } ;
TUPLE: bar.sync < ptx-instruction
- { a string }
- { b ?string } ;
+ { a ptx-operand }
+ { b ?ptx-operand } ;
TUPLE: bfe < ptx-4op-instruction ;
TUPLE: bfi < ptx-5op-instruction ;
TUPLE: bfind < ptx-2op-instruction
TUPLE: brev < ptx-2op-instruction ;
TUPLE: brkpt < ptx-instruction ;
TUPLE: call < ptx-branch-instruction
- { return ?string }
+ { return ?ptx-operand }
params ;
TUPLE: clz < ptx-2op-instruction ;
TUPLE: cnot < ptx-2op-instruction ;
TUPLE: fma <{ ptx-mad-instruction ptx-float-env } ;
TUPLE: isspacep < ptx-instruction
{ storage-space ptx-storage-space }
- { dest string }
- { a string } ;
+ { dest ptx-operand }
+ { a ptx-operand } ;
TUPLE: ld < ptx-ldst-instruction ;
TUPLE: ldu < ptx-ldst-instruction ;
TUPLE: lg2 <{ ptx-2op-instruction ptx-float-env } ;
TUPLE: not < ptx-2op-instruction ;
TUPLE: or < ptx-3op-instruction ;
TUPLE: pmevent < ptx-instruction
- { a string } ;
+ { a ptx-operand } ;
TUPLE: popc < ptx-2op-instruction ;
TUPLE: prefetch < ptx-instruction
- { a string }
+ { a ptx-operand }
{ storage-space ?ptx-storage-space }
{ level ptx-cache-level } ;
TUPLE: prefetchu < ptx-instruction
- { a string }
+ { a ptx-operand }
{ level ptx-cache-level } ;
TUPLE: prmt < ptx-4op-instruction
{ mode ?ptx-prmt-mode } ;
TUPLE: set < ptx-set-instruction
{ dest-type ptx-type } ;
TUPLE: setp < ptx-set-instruction
- { |dest ?string } ;
+ { |dest ?ptx-operand } ;
TUPLE: shl < ptx-3op-instruction ;
TUPLE: shr < ptx-3op-instruction ;
TUPLE: sin <{ ptx-2op-instruction ptx-float-env } ;
M: .file ptx-semicolon? drop f ;
M: .loc ptx-semicolon? drop f ;
+GENERIC: write-ptx-operand ( operand -- )
+
+M: string write-ptx-operand write ;
+M: integer write-ptx-operand number>string write ;
+M: float write-ptx-operand "0d" write double>bits >hex 16 CHAR: 0 pad-head write ;
+M: ptx-negation write-ptx-operand "!" write var>> write ;
+M: ptx-vector write-ptx-operand
+ "{" write
+ elements>> [ ", " write ] [ write-ptx-operand ] interleave
+ "}" write ;
+M: ptx-element write-ptx-operand dup var>> write "[" write index>> number>string write "]" write ;
+M: ptx-indirect write-ptx-operand
+ "[" write
+ dup base>> write-ptx-operand
+ offset>> {
+ { [ dup zero? ] [ drop ] }
+ { [ dup 0 < ] [ number>string write ] }
+ [ "+" write number>string write ]
+ } cond
+ "]" write ;
+
GENERIC: (write-ptx-element) ( elt -- )
: write-ptx-element ( elt -- )
[ arch>> [ name>> ] [ f ] if* ]
[ map_f64_to_f32?>> [ "map_f64_to_f32" ] [ f ] if ]
[ texmode>> [ name>> ] [ f ] if* ] tri
- 3array sift ", " join write ;
+ 3array sift [ ", " write ] [ write ] interleave ;
: write-ptx-dim ( dim -- )
{
".maxnreg " write n>> number>string write ;
M: .maxntid (write-ptx-element)
".maxntid " write
- dup sequence? [ [ number>string ] map ", " join write ] [ number>string write ] if ;
+ dup sequence? [ [ ", " write ] [ number>string write ] interleave ] [ number>string write ] if ;
M: .pragma (write-ptx-element)
".pragma \"" write pragma>> write "\"" write ;
: write-insn ( insn name -- insn )
over predicate>>
- [ "@" write dup negated?>> [ "!" write ] when variable>> write " " write ] when*
+ [ "@" write write-ptx-operand " " write ] when*
write ;
: write-2op ( insn -- )
dup type>> (write-ptx-element) " " write
- dup dest>> write ", " write
- dup a>> write
+ dup dest>> write-ptx-operand ", " write
+ dup a>> write-ptx-operand
drop ;
: write-3op ( insn -- )
dup write-2op ", " write
- dup b>> write
+ dup b>> write-ptx-operand
drop ;
: write-4op ( insn -- )
dup write-3op ", " write
- dup c>> write
+ dup c>> write-ptx-operand
drop ;
: write-5op ( insn -- )
dup write-4op ", " write
- dup d>> write
+ dup d>> write-ptx-operand
drop ;
: write-ftz ( insn -- )
dup storage-space>> (write-ptx-element)
dup op>> (write-ptx-element)
dup write-3op
- c>> [ ", " write write ] when* ;
+ c>> [ ", " write write-ptx-operand ] when* ;
M: bar.arrive (write-ptx-element)
"bar.arrive " write-insn
- dup a>> write ", " write
- dup b>> write
+ dup a>> write-ptx-operand ", " write
+ dup b>> write-ptx-operand
drop ;
M: bar.red (write-ptx-element)
"bar.red" write-insn
dup op>> (write-ptx-element)
dup write-2op
- dup b>> [ ", " write write ] when*
- ", " write c>> write ;
+ dup b>> [ ", " write write-ptx-operand ] when*
+ ", " write c>> write-ptx-operand ;
M: bar.sync (write-ptx-element)
"bar.sync " write-insn
- dup a>> write
- dup b>> [ ", " write write ] when*
+ dup a>> write-ptx-operand
+ dup b>> [ ", " write write-ptx-operand ] when*
drop ;
M: bfe (write-ptx-element)
"bfe" write-insn
M: call (write-ptx-element)
"call" write-insn
dup write-uni " " write
- dup return>> [ "(" write write "), " write ] when*
+ dup return>> [ "(" write write-ptx-operand "), " write ] when*
dup target>> write
- dup params>> [ ", (" write ", " join write ")" write ] unless-empty
+ dup params>> [ ", (" write [ ", " write ] [ write-ptx-operand ] interleave ")" write ] unless-empty
drop ;
M: clz (write-ptx-element)
"clz" write-insn
"isspacep" write-insn
dup storage-space>> (write-ptx-element)
" " write
- dup dest>> write ", " write a>> write ;
+ dup dest>> write-ptx-operand ", " write a>> write-ptx-operand ;
M: ld (write-ptx-element)
"ld" write-insn
write-ldst ;
"prefetch" write-insn
dup storage-space>> (write-ptx-element)
dup level>> (write-ptx-element)
- " " write a>> write ;
+ " " write a>> write-ptx-operand ;
M: prefetchu (write-ptx-element)
"prefetchu" write-insn
dup level>> (write-ptx-element)
- " " write a>> write ;
+ " " write a>> write-ptx-operand ;
M: prmt (write-ptx-element)
"prmt" write-insn
dup type>> (write-ptx-element)
dup mode>> (write-ptx-element) " " write
- dup dest>> write ", " write
- dup a>> write ", " write
- dup b>> write ", " write
- dup c>> write
+ dup dest>> write-ptx-operand ", " write
+ dup a>> write-ptx-operand ", " write
+ dup b>> write-ptx-operand ", " write
+ dup c>> write-ptx-operand
drop ;
M: rcp (write-ptx-element)
"rcp" write-insn
dup write-set
dup dest-type>> (write-ptx-element)
dup write-3op
- c>> [ ", " write write ] when* ;
+ c>> [ ", " write write-ptx-operand ] when* ;
M: setp (write-ptx-element)
"setp" write-insn
dup write-set
dup type>> (write-ptx-element) " " write
- dup dest>> write
- dup |dest>> [ "|" write write ] when* ", " write
- dup a>> write ", " write
- dup b>> write
- c>> [ ", " write write ] when* ;
+ dup dest>> write-ptx-operand
+ dup |dest>> [ "|" write write-ptx-operand ] when* ", " write
+ dup a>> write-ptx-operand ", " write
+ dup b>> write-ptx-operand
+ c>> [ ", " write write-ptx-operand ] when* ;
M: shl (write-ptx-element)
"shl" write-insn
write-3op ;
dup fluid set
init-gpu
initial-particles clone >>particles
- "resource:extra/fluids/particle2.pgm" make-texture >>texture
- "resource:extra/fluids/colors.ppm" make-texture >>ramp
+ "vocab:fluids/particle2.pgm" make-texture >>texture
+ "vocab:fluids/colors.ppm" make-texture >>ramp
drop ;
M: fluids-world end-game-world
--- /dev/null
+particle2.pgm
+colors.ppm
FUNCTION: FT_Error FT_Load_Char ( face* face, FT_ULong charcode, FT_Int32 load_flags ) ;
-C-ENUM: f
- FT_RENDER_MODE_NORMAL
- FT_RENDER_MODE_LIGHT
- FT_RENDER_MODE_MONO
- FT_RENDER_MODE_LCD
- FT_RENDER_MODE_LCD_V ;
-
-C-ENUM: f
- FT_PIXEL_MODE_NONE
- FT_PIXEL_MODE_MONO
- FT_PIXEL_MODE_GRAY
- FT_PIXEL_MODE_GRAY2
- FT_PIXEL_MODE_GRAY4
- FT_PIXEL_MODE_LCD
- FT_PIXEL_MODE_LCD_V ;
+CONSTANT: FT_RENDER_MODE_NORMAL 0
+CONSTANT: FT_RENDER_MODE_LIGHT 1
+CONSTANT: FT_RENDER_MODE_MONO 2
+CONSTANT: FT_RENDER_MODE_LCD 3
+CONSTANT: FT_RENDER_MODE_LCD_V 4
+
+CONSTANT: FT_PIXEL_MODE_NONE 0
+CONSTANT: FT_PIXEL_MODE_MONO 1
+CONSTANT: FT_PIXEL_MODE_GRAY 2
+CONSTANT: FT_PIXEL_MODE_GRAY2 3
+CONSTANT: FT_PIXEL_MODE_GRAY4 4
+CONSTANT: FT_PIXEL_MODE_LCD 5
+CONSTANT: FT_PIXEL_MODE_LCD_V 6
FUNCTION: int FT_Render_Glyph ( glyph* slot, int render_mode ) ;
! Copyright (C) 2010 Doug Coleman.
! See http://factorcode.org/license.txt for BSD license.
USING: alien alien.c-types alien.libraries alien.syntax
-classes.struct combinators io.encodings.utf8 system ;
+classes.struct combinators io.encodings.utf16n
+io.encodings.utf8 kernel system ;
IN: javascriptcore.ffi
<<
"javascriptcore" {
- { [ os macosx? ] [ "/System/Library/Frameworks/JavaScriptCore.framework/Versions/Current/JavaScriptCore" ] }
- ! { [ os winnt? ] [ "javascriptcore.dll" ] }
- ! { [ os unix? ] [ "libsqlite3.so" ] }
- } cond cdecl add-library
+ { [ os macosx? ] [
+ "/System/Library/Frameworks/JavaScriptCore.framework/Versions/Current/JavaScriptCore" cdecl add-library
+ ] }
+ ! { [ os winnt? ] [ "javascriptcore.dll" ] }
+ ! { [ os unix? ] [ "libsqlite3.so" ] }
+ [ drop ]
+} cond
>>
LIBRARY: javascriptcore
TYPEDEF: void* JSObjectConvertToTypeCallback
TYPEDEF: uint unsigned
TYPEDEF: ushort JSChar
-! char[utf16n] for strings
C-ENUM: JSPropertyAttributes
{ kJSPropertyAttributeNone 0 }
FUNCTION: JSStringRef JSStringCreateWithCharacters ( JSChar* chars, size_t numChars ) ;
-FUNCTION: JSStringRef JSStringCreateWithUTF8CString ( c-string[utf8] string ) ;
+FUNCTION: JSStringRef JSStringCreateWithUTF8CString ( c-string string ) ;
FUNCTION: JSStringRef JSStringRetain ( JSStringRef string ) ;
--- /dev/null
+! Copyright (C) 2010 Doug Coleman.
+! See http://factorcode.org/license.txt for BSD license.
+USING: accessors javascriptcore kernel tools.test ;
+IN: javascriptcore.tests
+
+[ "2" ] [ "1+1" eval-js-standalone ] unit-test
+
+[ "1+shoes" eval-js-standalone ]
+[ error>> "ReferenceError: Can't find variable: shoes" = ] must-fail-with
+
! Copyright (C) 2010 Doug Coleman.
! See http://factorcode.org/license.txt for BSD license.
-USING: javascriptcore.ffi.hack kernel ;
+USING: alien.c-types alien.data byte-arrays continuations fry
+io.encodings.string io.encodings.utf8 io.files
+javascriptcore.ffi javascriptcore.ffi.hack kernel namespaces
+sequences ;
IN: javascriptcore
+ERROR: javascriptcore-error error ;
+
+SYMBOL: js-context
+
+: with-global-context ( quot -- )
+ [
+ [ f JSGlobalContextCreate dup js-context set ] dip
+ [ nip '[ @ ] ]
+ [ drop '[ _ JSGlobalContextRelease ] ] 2bi
+ [ ] cleanup
+ ] with-scope ; inline
+
: with-javascriptcore ( quot -- )
set-callstack-bounds
- call ; inline
+ with-global-context ; inline
+
+: JSString>string ( JSString -- string )
+ dup JSStringGetMaximumUTF8CStringSize [ <byte-array> ] keep
+ [ JSStringGetUTF8CString drop ] [ drop ] 2bi
+ utf8 decode [ 0 = ] trim-tail ;
+
+: JSValueRef>string ( ctx JSValueRef/f -- string/f )
+ [
+ f JSValueToStringCopy
+ [ JSString>string ] [ JSStringRelease ] bi
+ ] [
+ drop f
+ ] if* ;
+
+: eval-js ( string -- result-string )
+ [ js-context get dup ] dip
+ JSStringCreateWithUTF8CString f f 0 JSValueRef <c-object>
+ [ JSEvaluateScript ] keep *void*
+ dup [ nip JSValueRef>string javascriptcore-error ] [ drop JSValueRef>string ] if ;
+
+: eval-js-standalone ( string -- result-string )
+ '[ _ eval-js ] with-javascriptcore ;
+
+: eval-js-path-standalone ( path -- result-string ) utf8 file-contents eval-js-standalone ;
+
ALIAS: libusb_le16_to_cpu libusb_cpu_to_le16
-C-ENUM: libusb_class_code
+ENUM: libusb_class_code
{ LIBUSB_CLASS_PER_INTERFACE 0 }
{ LIBUSB_CLASS_AUDIO 1 }
{ LIBUSB_CLASS_COMM 2 }
{ LIBUSB_CLASS_DATA 10 }
{ LIBUSB_CLASS_VENDOR_SPEC HEX: ff } ;
-C-ENUM: libusb_descriptor_type
+ENUM: libusb_descriptor_type
{ LIBUSB_DT_DEVICE HEX: 01 }
{ LIBUSB_DT_CONFIG HEX: 02 }
{ LIBUSB_DT_STRING HEX: 03 }
CONSTANT: LIBUSB_ENDPOINT_ADDRESS_MASK HEX: 0f
CONSTANT: LIBUSB_ENDPOINT_DIR_MASK HEX: 80
-C-ENUM: libusb_endpoint_direction
+ENUM: libusb_endpoint_direction
{ LIBUSB_ENDPOINT_IN HEX: 80 }
{ LIBUSB_ENDPOINT_OUT HEX: 00 } ;
CONSTANT: LIBUSB_TRANSFER_TYPE_MASK HEX: 03
-C-ENUM: libusb_transfer_type
+ENUM: libusb_transfer_type
{ LIBUSB_TRANSFER_TYPE_CONTROL 0 }
{ LIBUSB_TRANSFER_TYPE_ISOCHRONOUS 1 }
{ LIBUSB_TRANSFER_TYPE_BULK 2 }
{ LIBUSB_TRANSFER_TYPE_INTERRUPT 3 } ;
-C-ENUM: libusb_standard_request
+ENUM: libusb_standard_request
{ LIBUSB_REQUEST_GET_STATUS HEX: 00 }
{ LIBUSB_REQUEST_CLEAR_FEATURE HEX: 01 }
{ LIBUSB_REQUEST_SET_FEATURE HEX: 03 }
{ LIBUSB_REQUEST_SET_INTERFACE HEX: 0B }
{ LIBUSB_REQUEST_SYNCH_FRAME HEX: 0C } ;
-C-ENUM: libusb_request_type
+ENUM: libusb_request_type
{ LIBUSB_REQUEST_TYPE_STANDARD HEX: 00 }
{ LIBUSB_REQUEST_TYPE_CLASS HEX: 20 }
{ LIBUSB_REQUEST_TYPE_VENDOR HEX: 40 }
{ LIBUSB_REQUEST_TYPE_RESERVED HEX: 60 } ;
-C-ENUM: libusb_request_recipient
+ENUM: libusb_request_recipient
{ LIBUSB_RECIPIENT_DEVICE HEX: 00 }
{ LIBUSB_RECIPIENT_INTERFACE HEX: 01 }
{ LIBUSB_RECIPIENT_ENDPOINT HEX: 02 }
CONSTANT: LIBUSB_ISO_SYNC_TYPE_MASK HEX: 0C
-C-ENUM: libusb_iso_sync_type
+ENUM: libusb_iso_sync_type
{ LIBUSB_ISO_SYNC_TYPE_NONE 0 }
{ LIBUSB_ISO_SYNC_TYPE_ASYNC 1 }
{ LIBUSB_ISO_SYNC_TYPE_ADAPTIVE 2 }
CONSTANT: LIBUSB_ISO_USAGE_TYPE_MASK HEX: 30
-C-ENUM: libusb_iso_usage_type
+ENUM: libusb_iso_usage_type
{ LIBUSB_ISO_USAGE_TYPE_DATA 0 }
{ LIBUSB_ISO_USAGE_TYPE_FEEDBACK 1 }
{ LIBUSB_ISO_USAGE_TYPE_IMPLICIT 2 } ;
C-TYPE: libusb_device
C-TYPE: libusb_device_handle
-C-ENUM: libusb_error
+ENUM: libusb_error
{ LIBUSB_SUCCESS 0 }
{ LIBUSB_ERROR_IO -1 }
{ LIBUSB_ERROR_INVALID_PARAM -2 }
{ LIBUSB_ERROR_NOT_SUPPORTED -12 }
{ LIBUSB_ERROR_OTHER -99 } ;
-C-ENUM: libusb_transfer_status
+ENUM: libusb_transfer_status
LIBUSB_TRANSFER_COMPLETED
LIBUSB_TRANSFER_ERROR
LIBUSB_TRANSFER_TIMED_OUT
LIBUSB_TRANSFER_NO_DEVICE
LIBUSB_TRANSFER_OVERFLOW ;
-C-ENUM: libusb_transfer_flags
+ENUM: libusb_transfer_flags
{ LIBUSB_TRANSFER_SHORT_NOT_OK 1 }
{ LIBUSB_TRANSFER_FREE_BUFFER 2 }
{ LIBUSB_TRANSFER_FREE_TRANSFER 4 } ;
TYPEDEF: uint unsigned
TYPEDEF: unsigned enum
-C-ENUM: LLVMAttribute
+ENUM: LLVMAttribute
{ LLVMZExtAttribute BIN: 1 }
{ LLVMSExtAttribute BIN: 10 }
{ LLVMNoReturnAttribute BIN: 100 }
{ LLVMReadNoneAttribute BIN: 1000000000 }
{ LLVMReadOnlyAttribute BIN: 10000000000 } ;
-C-ENUM: LLVMTypeKind
+ENUM: LLVMTypeKind
LLVMVoidTypeKind
LLVMFloatTypeKind
LLVMDoubleTypeKind
LLVMOpaqueTypeKind
LLVMVectorTypeKind ;
-C-ENUM: LLVMLinkage
+ENUM: LLVMLinkage
LLVMExternalLinkage
LLVMLinkOnceLinkage
LLVMWeakLinkage
LLVMExternalWeakLinkage
LLVMGhostLinkage ;
-C-ENUM: LLVMVisibility
+ENUM: LLVMVisibility
LLVMDefaultVisibility
LLVMHiddenVisibility
LLVMProtectedVisibility ;
-C-ENUM: LLVMCallConv
+ENUM: LLVMCallConv
{ LLVMCCallConv 0 }
{ LLVMFastCallConv 8 }
{ LLVMColdCallConv 9 }
{ LLVMX86StdcallCallConv 64 }
{ LLVMX86FastcallCallConv 65 } ;
-C-ENUM: LLVMIntPredicate
+ENUM: LLVMIntPredicate
{ LLVMIntEQ 32 }
{ LLVMIntNE 33 }
{ LLVMIntUGT 34 }
{ LLVMIntSLT 40 }
{ LLVMIntSLE 41 } ;
-C-ENUM: LLVMRealPredicate
+ENUM: LLVMRealPredicate
LLVMRealPredicateFalse
LLVMRealOEQ
LLVMRealOGT
--- /dev/null
+Erik Charlebois
--- /dev/null
+! Copyright (C) 2010 Erik Charlebois.
+! See http://factorcode.org/license.txt for BSD license.
+USING: accessors alien alien.accessors alien.c-types alien.libraries
+alien.syntax classes.struct combinators io.encodings.ascii kernel
+literals locals math system ;
+IN: lua
+
+<< "liblua5.1" {
+ { [ os windows? ] [ "lua5.1.dll" ] }
+ { [ os macosx? ] [ "liblua5.1.dylib" ] }
+ { [ os unix? ] [ "liblua5.1.so" ] }
+ } cond cdecl add-library >>
+LIBRARY: liblua5.1
+
+! luaconf.h
+TYPEDEF: double LUA_NUMBER
+TYPEDEF: ptrdiff_t LUA_INTEGER
+
+CONSTANT: LUA_IDSIZE 60
+
+! This is normally the BUFSIZ value of the given platform.
+CONSTANT: LUAL_BUFFERSIZE $[
+ {
+ { [ os windows? ] [ 512 ] }
+ { [ os macosx? ] [ 1024 ] }
+ { [ os unix? ] [ 8192 ] }
+ } cond ]
+
+! lua.h
+CONSTANT: LUA_SIGNATURE B{ 27 76 117 97 }
+CONSTANT: LUA_MULTRET -1
+
+CONSTANT: LUA_REGISTRYINDEX -10000
+CONSTANT: LUA_ENVIRONINDEX -10001
+CONSTANT: LUA_GLOBALSINDEX -10002
+
+: lua_upvalueindex ( i -- i ) [ LUA_GLOBALSINDEX ] dip - ; inline
+
+CONSTANT: LUA_YIELD 1
+CONSTANT: LUA_ERRRUN 2
+CONSTANT: LUA_ERRSYNTAX 3
+CONSTANT: LUA_ERRMEM 4
+CONSTANT: LUA_ERRERR 5
+
+C-TYPE: lua_State
+
+CALLBACK: int lua_CFunction ( lua_State* L ) ;
+CALLBACK: char* lua_Reader ( lua_State* L, void* ud, size_t* sz ) ;
+CALLBACK: int lua_Writer ( lua_State* L, void* p, size_t sz, void* ud ) ;
+CALLBACK: void* lua_Alloc ( void* ud, void* ptr, size_t osize, size_t nsize ) ;
+
+CONSTANT: LUA_TNONE -1
+CONSTANT: LUA_TNIL 0
+CONSTANT: LUA_TBOOLEAN 1
+CONSTANT: LUA_TLIGHTUSERDATA 2
+CONSTANT: LUA_TNUMBER 3
+CONSTANT: LUA_TSTRING 4
+CONSTANT: LUA_TTABLE 5
+CONSTANT: LUA_TFUNCTION 6
+CONSTANT: LUA_TUSERDATA 7
+CONSTANT: LUA_TTHREAD 8
+
+CONSTANT: LUA_MINSTACK 20
+
+TYPEDEF: LUA_NUMBER lua_Number
+TYPEDEF: LUA_INTEGER lua_Integer
+
+FUNCTION: lua_State* lua_newstate ( lua_Alloc f, void* ud ) ;
+FUNCTION: void lua_close ( lua_State* L ) ;
+FUNCTION: lua_State* lua_newthread ( lua_State* L ) ;
+
+FUNCTION: lua_CFunction lua_atpanic ( lua_State* L, lua_CFunction panicf ) ;
+
+FUNCTION: int lua_gettop ( lua_State* L ) ;
+FUNCTION: void lua_settop ( lua_State* L, int idx ) ;
+FUNCTION: void lua_pushvalue ( lua_State* L, int idx ) ;
+FUNCTION: void lua_remove ( lua_State* L, int idx ) ;
+FUNCTION: void lua_insert ( lua_State* L, int idx ) ;
+FUNCTION: void lua_replace ( lua_State* L, int idx ) ;
+FUNCTION: int lua_checkstack ( lua_State* L, int sz ) ;
+
+FUNCTION: void lua_xmove ( lua_State* from, lua_State* to, int n ) ;
+
+FUNCTION: int lua_isnumber ( lua_State* L, int idx ) ;
+FUNCTION: int lua_isstring ( lua_State* L, int idx ) ;
+FUNCTION: int lua_iscfunction ( lua_State* L, int idx ) ;
+FUNCTION: int lua_isuserdata ( lua_State* L, int idx ) ;
+FUNCTION: int lua_type ( lua_State* L, int idx ) ;
+FUNCTION: c-string[ascii] lua_typename ( lua_State* L, int tp ) ;
+
+FUNCTION: int lua_equal ( lua_State* L, int idx1, int idx2 ) ;
+FUNCTION: int lua_rawequal ( lua_State* L, int idx1, int idx2 ) ;
+FUNCTION: int lua_lessthan ( lua_State* L, int idx1, int idx2 ) ;
+
+FUNCTION: lua_Number lua_tonumber ( lua_State* L, int idx ) ;
+FUNCTION: lua_Integer lua_tointeger ( lua_State* L, int idx ) ;
+FUNCTION: int lua_toboolean ( lua_State* L, int idx ) ;
+FUNCTION: c-string[ascii] lua_tolstring ( lua_State* L, int idx, size_t* len ) ;
+FUNCTION: size_t lua_objlen ( lua_State* L, int idx ) ;
+FUNCTION: lua_CFunction lua_tocfunction ( lua_State* L, int idx ) ;
+FUNCTION: void* lua_touserdata ( lua_State* L, int idx ) ;
+FUNCTION: lua_State* lua_tothread ( lua_State* L, int idx ) ;
+FUNCTION: void* lua_topointer ( lua_State* L, int idx ) ;
+
+FUNCTION: void lua_pushnil ( lua_State* L ) ;
+FUNCTION: void lua_pushnumber ( lua_State* L, lua_Number n ) ;
+FUNCTION: void lua_pushinteger ( lua_State* L, lua_Integer n ) ;
+FUNCTION: void lua_pushlstring ( lua_State* L, char* s, size_t l ) ;
+FUNCTION: void lua_pushstring ( lua_State* L, c-string[ascii] ) ;
+! FUNCTION: c-string[ascii] lua_pushvfstring ( lua_State* L, c-string[ascii] fmt, va_list argp ) ;
+! FUNCTION: c-string[ascii] lua_pushfstring ( lua_State* L, c-string[ascii] fmt, ... ) ;
+FUNCTION: void lua_pushcclosure ( lua_State* L, lua_CFunction fn, int n ) ;
+FUNCTION: void lua_pushboolean ( lua_State* L, int b ) ;
+FUNCTION: void lua_pushlightuserdata ( lua_State* L, void* p ) ;
+FUNCTION: int lua_pushthread ( lua_State* L ) ;
+
+FUNCTION: void lua_gettable ( lua_State* L, int idx ) ;
+FUNCTION: void lua_getfield ( lua_State* L, int idx, c-string[ascii] k ) ;
+FUNCTION: void lua_rawget ( lua_State* L, int idx ) ;
+FUNCTION: void lua_rawgeti ( lua_State* L, int idx, int n ) ;
+FUNCTION: void lua_createtable ( lua_State* L, int narr, int nrec ) ;
+FUNCTION: void* lua_newuserdata ( lua_State* L, size_t sz ) ;
+FUNCTION: int lua_getmetatable ( lua_State* L, int objindex ) ;
+FUNCTION: void lua_getfenv ( lua_State* L, int idx ) ;
+
+FUNCTION: void lua_settable ( lua_State* L, int idx ) ;
+FUNCTION: void lua_setfield ( lua_State* L, int idx, c-string[ascii] k ) ;
+FUNCTION: void lua_rawset ( lua_State* L, int idx ) ;
+FUNCTION: void lua_rawseti ( lua_State* L, int idx, int n ) ;
+FUNCTION: int lua_setmetatable ( lua_State* L, int objindex ) ;
+FUNCTION: int lua_setfenv ( lua_State* L, int idx ) ;
+
+FUNCTION: void lua_call ( lua_State* L, int nargs, int nresults ) ;
+FUNCTION: int lua_pcall ( lua_State* L, int nargs, int nresults, int errfunc ) ;
+FUNCTION: int lua_cpcall ( lua_State* L, lua_CFunction func, void* ud ) ;
+FUNCTION: int lua_load ( lua_State* L, lua_Reader reader, void* dt, c-string[ascii] chunkname ) ;
+
+FUNCTION: int lua_dump ( lua_State* L, lua_Writer writer, void* data ) ;
+
+FUNCTION: int lua_yield ( lua_State* L, int nresults ) ;
+FUNCTION: int lua_resume ( lua_State* L, int narg ) ;
+FUNCTION: int lua_status ( lua_State* L ) ;
+
+CONSTANT: LUA_GCSTOP 0
+CONSTANT: LUA_GCRESTART 1
+CONSTANT: LUA_GCCOLLECT 2
+CONSTANT: LUA_GCCOUNT 3
+CONSTANT: LUA_GCCOUNTB 4
+CONSTANT: LUA_GCSTEP 5
+CONSTANT: LUA_GCSETPAUSE 6
+CONSTANT: LUA_GCSETSTEPMUL 7
+
+FUNCTION: int lua_gc ( lua_State* L, int what, int data ) ;
+
+FUNCTION: int lua_error ( lua_State* L ) ;
+FUNCTION: int lua_next ( lua_State* L, int idx ) ;
+FUNCTION: void lua_concat ( lua_State* L, int n ) ;
+FUNCTION: lua_Alloc lua_getallocf ( lua_State* L, void* *ud ) ;
+FUNCTION: void lua_setallocf ( lua_State* L, lua_Alloc f, void* ud ) ;
+
+TYPEDEF: lua_Reader lua_Chunkreader
+TYPEDEF: lua_Writer lua_Chunkwriter
+
+FUNCTION: void lua_setlevel ( lua_State* from, lua_State* to ) ;
+
+CONSTANT: LUA_HOOKCALL 0
+CONSTANT: LUA_HOOKRET 1
+CONSTANT: LUA_HOOKLINE 2
+CONSTANT: LUA_HOOKCOUNT 3
+CONSTANT: LUA_HOOKTAILRET 4
+
+: LUA_MASKCALL ( n -- n ) LUA_HOOKCALL shift ; inline
+: LUA_MASKRET ( n -- n ) LUA_HOOKRET shift ; inline
+: LUA_MASKLINE ( n -- n ) LUA_HOOKLINE shift ; inline
+: LUA_MASKCOUNT ( n -- n ) LUA_HOOKCOUNT shift ; inline
+
+C-TYPE: lua_Debug
+CALLBACK: void lua_Hook ( lua_State* L, lua_Debug* ar ) ;
+
+FUNCTION: int lua_getstack ( lua_State* L, int level, lua_Debug* ar ) ;
+FUNCTION: int lua_getinfo ( lua_State* L, c-string[ascii] what, lua_Debug* ar ) ;
+FUNCTION: c-string[ascii] lua_getlocal ( lua_State* L, lua_Debug* ar, int n ) ;
+FUNCTION: c-string[ascii] lua_setlocal ( lua_State* L, lua_Debug* ar, int n ) ;
+FUNCTION: c-string[ascii] lua_getupvalue ( lua_State* L, int funcindex, int n ) ;
+FUNCTION: c-string[ascii] lua_setupvalue ( lua_State* L, int funcindex, int n ) ;
+
+FUNCTION: int lua_sethook ( lua_State* L, lua_Hook func, int mask, int count ) ;
+FUNCTION: lua_Hook lua_gethook ( lua_State* L ) ;
+FUNCTION: int lua_gethookmask ( lua_State* L ) ;
+FUNCTION: int lua_gethookcount ( lua_State* L ) ;
+
+STRUCT: lua_Debug
+ { event int }
+ { name char* }
+ { namewhat char* }
+ { what char* }
+ { source char* }
+ { currentline int }
+ { nups int }
+ { linedefined int }
+ { lastlinedefined int }
+ { short_src char[LUA_IDSIZE] }
+ { i_ci int } ;
+
+! lauxlib.h
+
+: luaL_getn ( L i -- int ) lua_objlen ; inline
+: luaL_setn ( L i j -- ) 3drop ; inline
+
+CONSTANT: LUA_ERRFILE $[ $ LUA_ERRERR 1 + ]
+
+STRUCT: luaL_Reg
+ { name char* }
+ { func lua_CFunction } ;
+
+FUNCTION: void luaI_openlib ( lua_State* L, c-string[ascii] libname, luaL_Reg* l, int nup ) ;
+FUNCTION: void luaL_register ( lua_State* L, c-string[ascii] libname, luaL_Reg* l ) ;
+FUNCTION: int luaL_getmetafield ( lua_State* L, int obj, c-string[ascii] e ) ;
+FUNCTION: int luaL_callmeta ( lua_State* L, int obj, c-string[ascii] e ) ;
+FUNCTION: int luaL_typerror ( lua_State* L, int narg, c-string[ascii] tname ) ;
+FUNCTION: int luaL_argerror ( lua_State* L, int numarg, c-string[ascii] extramsg ) ;
+FUNCTION: c-string[ascii] luaL_checklstring ( lua_State* L, int numArg, size_t* l ) ;
+FUNCTION: c-string[ascii] luaL_optlstring ( lua_State* L, int numArg, c-string[ascii] def, size_t* l ) ;
+FUNCTION: lua_Number luaL_checknumber ( lua_State* L, int numArg ) ;
+FUNCTION: lua_Number luaL_optnumber ( lua_State* L, int nArg, lua_Number def ) ;
+
+FUNCTION: lua_Integer luaL_checkinteger ( lua_State* L, int numArg ) ;
+FUNCTION: lua_Integer luaL_optinteger ( lua_State* L, int nArg, lua_Integer def ) ;
+
+FUNCTION: void luaL_checkstack ( lua_State* L, int sz, c-string[ascii] msg ) ;
+FUNCTION: void luaL_checktype ( lua_State* L, int narg, int t ) ;
+FUNCTION: void luaL_checkany ( lua_State* L, int narg ) ;
+
+FUNCTION: int luaL_newmetatable ( lua_State* L, c-string[ascii] tname ) ;
+FUNCTION: void* luaL_checkudata ( lua_State* L, int ud, c-string[ascii] tname ) ;
+
+FUNCTION: void luaL_where ( lua_State* L, int lvl ) ;
+! FUNCTION: int luaL_error ( lua_State* L, c-string[ascii] fmt, ... ) ;
+FUNCTION: int luaL_checkoption ( lua_State* L, int narg, c-string[ascii] def, c-string[ascii] lst ) ;
+
+FUNCTION: int luaL_ref ( lua_State* L, int t ) ;
+FUNCTION: void luaL_unref ( lua_State* L, int t, int ref ) ;
+
+FUNCTION: int luaL_loadfile ( lua_State* L, c-string[ascii] filename ) ;
+FUNCTION: int luaL_loadbuffer ( lua_State* L, c-string[ascii] buff, size_t sz, c-string[ascii] name ) ;
+FUNCTION: int luaL_loadstring ( lua_State* L, c-string[ascii] s ) ;
+
+FUNCTION: lua_State* luaL_newstate ( ) ;
+FUNCTION: c-string[ascii] luaL_gsub ( lua_State* L, c-string[ascii] s, c-string[ascii] p, c-string[ascii] r ) ;
+FUNCTION: c-string[ascii] luaL_findtable ( lua_State* L, int idx, c-string[ascii] fname, int szhint ) ;
+
+: lua_pop ( L n -- ) neg 1 - lua_settop ; inline
+: lua_newtable ( L -- ) 0 0 lua_createtable ; inline
+: lua_pushcfunction ( L f -- ) 0 lua_pushcclosure ; inline
+: lua_setglobal ( L s -- ) [ LUA_GLOBALSINDEX ] dip lua_setfield ; inline
+: lua_register ( L n f -- ) pick swap lua_pushcfunction lua_setglobal ; inline
+: lua_strlen ( L i -- size_t ) lua_objlen ; inline
+: lua_isfunction ( L n -- ? ) lua_type LUA_TFUNCTION = ; inline
+: lua_istable ( L n -- ? ) lua_type LUA_TTABLE = ; inline
+: lua_islightuserdata ( L n -- ? ) lua_type LUA_TLIGHTUSERDATA = ; inline
+: lua_isnil ( L n -- ? ) lua_type LUA_TNIL = ; inline
+: lua_isboolean ( L n -- ? ) lua_type LUA_TBOOLEAN = ; inline
+: lua_isthread ( L n -- ? ) lua_type LUA_TTHREAD = ; inline
+: lua_isnone ( L n -- ? ) lua_type LUA_TNONE = ; inline
+: lua_isnoneornil ( L n -- ? ) lua_type 0 <= ; inline
+: lua_getglobal ( L s -- ) [ LUA_GLOBALSINDEX ] dip lua_getfield ; inline
+: lua_tostring ( L i -- string ) f lua_tolstring ; inline
+: lua_open ( -- lua_State* ) luaL_newstate ; inline
+: lua_getregistry ( L -- ) LUA_REGISTRYINDEX lua_pushvalue ; inline
+: lua_getgccount ( L -- int ) LUA_GCCOUNT 0 lua_gc ; inline
+
+: luaL_argcheck ( L cond numarg extramsg -- int ) rot 0 = [ luaL_argerror ] [ 3drop 1 ] if ; inline
+: luaL_checkstring ( L n -- string ) f luaL_checklstring ; inline
+: luaL_optstring ( L n d -- string ) f luaL_optlstring ; inline
+: luaL_checkint ( L n -- int ) luaL_checkinteger ; inline
+: luaL_optint ( L n d -- int ) luaL_optinteger ; inline
+: luaL_checklong ( L n -- long ) luaL_checkinteger ; inline
+: luaL_optlong ( L n d -- long ) luaL_optinteger ; inline
+
+: luaL_typename ( L i -- string ) dupd lua_type lua_typename ; inline
+: luaL_dofile ( L fn -- int )
+ dupd luaL_loadfile 0 = [
+ 0 LUA_MULTRET 0 lua_pcall
+ ] [ drop 1 ] if ; inline
+: luaL_dostring ( L s -- int )
+ dupd luaL_loadstring 0 = [
+ 0 LUA_MULTRET 0 lua_pcall
+ ] [ drop 1 ] if ; inline
+
+: luaL_getmetatable ( L n -- ) [ LUA_REGISTRYINDEX ] dip lua_getfield ; inline
+
+STRUCT: luaL_Buffer
+ { p char* }
+ { lvl int }
+ { L lua_State* }
+ { buffer char[LUAL_BUFFERSIZE] } ;
+
+FUNCTION: void luaL_buffinit ( lua_State* L, luaL_Buffer* B ) ;
+FUNCTION: char* luaL_prepbuffer ( luaL_Buffer* B ) ;
+FUNCTION: void luaL_addlstring ( luaL_Buffer* B, char* s, size_t l ) ;
+FUNCTION: void luaL_addstring ( luaL_Buffer* B, char* s ) ;
+FUNCTION: void luaL_addvalue ( luaL_Buffer* B ) ;
+FUNCTION: void luaL_pushresult ( luaL_Buffer* B ) ;
+
+:: luaL_addchar ( B c -- )
+ B p>> alien-address
+ LUAL_BUFFERSIZE B buffer>> <displaced-alien> alien-address
+ >= [ B luaL_prepbuffer drop ] when
+ c B p>> 0 set-alien-signed-1
+ B [ 1 swap <displaced-alien> ] change-p drop ; inline
+
+: luaL_putchar ( B c -- ) luaL_addchar ; inline
+: luaL_addsize ( B n -- ) [ swap <displaced-alien> ] curry change-p drop ; inline
--- /dev/null
+FFI bindings to the Lua programming language.
{ r_address_type_length_pcrel_scattered uint }
{ r_value int } ;
-C-ENUM: reloc_type_generic
+ENUM: reloc_type_generic
GENERIC_RELOC_VANILLA
GENERIC_RELOC_PAIR
GENERIC_RELOC_SECTDIFF
GENERIC_RELOC_PB_LA_PTR
GENERIC_RELOC_LOCAL_SECTDIFF ;
-C-ENUM: reloc_type_x86_64
+ENUM: reloc_type_x86_64
X86_64_RELOC_UNSIGNED
X86_64_RELOC_SIGNED
X86_64_RELOC_BRANCH
X86_64_RELOC_SIGNED_2
X86_64_RELOC_SIGNED_4 ;
-C-ENUM: reloc_type_ppc
+ENUM: reloc_type_ppc
PPC_RELOC_VANILLA
PPC_RELOC_PAIR
PPC_RELOC_BR14
math.matrices math.vectors.simd math.parser math.vectors
method-chains namespaces sequences splitting threads ui ui.gadgets
ui.gadgets.worlds ui.pixel-formats specialized-arrays
-specialized-vectors literals fry
-sequences.deep destructors math.bitwise opengl.gl
+specialized-vectors fry sequences.deep destructors math.bitwise opengl.gl
game.models game.models.obj game.models.loader game.models.collada
prettyprint images.tga literals ;
FROM: alien.c-types => float ;
TYPEDEF: void* TCADB
-C-ENUM: f
- ADBOVOID
- ADBOMDB
- ADBONDB
- ADBOHDB
- ADBOBDB
- ADBOFDB
- ADBOTDB
- ADBOSKEL ;
+CONSTANT: ADBOVOID 0
+CONSTANT: ADBOMDB 1
+CONSTANT: ADBONDB 2
+CONSTANT: ADBOHDB 3
+CONSTANT: ADBOBDB 4
+CONSTANT: ADBOFDB 5
+CONSTANT: ADBOTDB 6
+CONSTANT: ADBOSKEL 7
FUNCTION: TCADB* tcadbnew ( ) ;
FUNCTION: void tcadbdel ( TCADB* adb ) ;
TYPEDEF: void* BDBCUR
-C-ENUM: f
- BDBCPCURRENT
- BDBCPBEFORE
- BDBCPAFTER ;
+CONSTANT: BDBCPCURRENT 0
+CONSTANT: BDBCPBEFORE 1
+CONSTANT: BDBCPAFTER 2
FUNCTION: c-string tcbdberrmsg ( int ecode ) ;
FUNCTION: TCBDB* tcbdbnew ( ) ;
! { timeout double }
! { opts int } ;
-C-ENUM: f
- TTESUCCESS
- TTEINVALID
- TTENOHOST
- TTEREFUSED
- TTESEND
- TTERECV
- TTEKEEP
- TTENOREC ;
-CONSTANT: TTEMISC 9999
+CONSTANT: TTESUCCESS 0
+CONSTANT: TTEINVALID 1
+CONSTANT: TTENOHOST 2
+CONSTANT: TTEREFUSED 3
+CONSTANT: TTESEND 4
+CONSTANT: TTERECV 5
+CONSTANT: TTEKEEP 6
+CONSTANT: TTENOREC 7
+CONSTANT: TTEMISC 9999
CONSTANT: RDBTRECON 1
CONSTANT: RDBXOLCKREC 1
CONSTANT: TDBOLCKNB 32
CONSTANT: TDBOTSYNC 64
-C-ENUM: f
- TDBITLEXICAL
- TDBITDECIMAL ;
+CONSTANT: TDBITLEXICAL 0
+CONSTANT: TDBITDECIMAL 1
CONSTANT: TDBITOPT 9998
CONSTANT: TDBITVOID 9999
C-TYPE: TDBCOND
C-TYPE: TDBQRY
-C-ENUM: f
- TDBQCSTREQ
- TDBQCSTRINC
- TDBQCSTRBW
- TDBQCSTREW
- TDBQCSTRAND
- TDBQCSTROR
- TDBQCSTROREQ
- TDBQCSTRRX
- TDBQCNUMEQ
- TDBQCNUMGT
- TDBQCNUMGE
- TDBQCNUMLT
- TDBQCNUMLE
- TDBQCNUMBT
- TDBQCNUMOREQ ;
+CONSTANT: TDBQCSTREQ 0
+CONSTANT: TDBQCSTRINC 1
+CONSTANT: TDBQCSTRBW 2
+CONSTANT: TDBQCSTREW 3
+CONSTANT: TDBQCSTRAND 4
+CONSTANT: TDBQCSTROR 5
+CONSTANT: TDBQCSTROREQ 6
+CONSTANT: TDBQCSTRRX 7
+CONSTANT: TDBQCNUMEQ 8
+CONSTANT: TDBQCNUMGT 9
+CONSTANT: TDBQCNUMGE 10
+CONSTANT: TDBQCNUMLT 11
+CONSTANT: TDBQCNUMLE 12
+CONSTANT: TDBQCNUMBT 13
+CONSTANT: TDBQCNUMOREQ 14
CONSTANT: TDBQCNEGATE 16777216
CONSTANT: TDBQCNOIDX 33554432
-C-ENUM: f
- TDBQOSTRASC
- TDBQOSTRDESC
- TDBQONUMASC
- TDBQONUMDESC ;
+CONSTANT: TDBQOSTRASC 0
+CONSTANT: TDBQOSTRDESC 1
+CONSTANT: TDBQONUMASC 2
+CONSTANT: TDBQONUMDESC 3
CONSTANT: TDBQPPUT 1
CONSTANT: TDBQPOUT 2
LIBRARY: tokyocabinet
-C-ENUM: f
- TCDBTHASH
- TCDBTBTREE
- TCDBTFIXED
- TCDBTTABLE ;
+CONSTANT: TCDBTHASH 0
+CONSTANT: TCDBTBTREE 1
+CONSTANT: TCDBTFIXED 2
+CONSTANT: TCDBTTABLE 3
! FIXME: on windows 64bits this isn't correct, because long is 32bits there, and time_t is int64
TYPEDEF: long tokyo_time_t
'(":" "::" ";" "&:" "<<" "<PRIVATE" ">>"\r
"ABOUT:" "AFTER:" "ALIAS:" "ALIEN:" "ARTICLE:"\r
"B" "BEFORE:" "BIN:"\r
- "C:" "CALLBACK:" "C-ENUM:" "C-TYPE:" "CHAR:" "COM-INTERFACE:" "CONSTANT:" "CONSULT:" "call-next-method"\r
+ "C:" "CALLBACK:" "ENUM:" "C-TYPE:" "CHAR:" "COM-INTERFACE:" "CONSTANT:" "CONSULT:" "call-next-method"\r
"DEFER:"\r
"EBNF:" ";EBNF" "ERROR:" "EXCLUDE:"\r
"f" "FORGET:" "FROM:" "FUNCTION:"\r
\r
(defconst fuel-syntax--indent-def-starts '("" ":"\r
"AFTER" "BEFORE"\r
- "C-ENUM" "COM-INTERFACE" "CONSULT"\r
+ "ENUM" "COM-INTERFACE" "CONSULT"\r
"FROM" "FUNCTION:"\r
"INTERSECTION:"\r
"M" "M:" "MACRO" "MACRO:"\r
("\\_<\\(U\\)SING: \\(;\\)" (1 "<b") (2 ">b"))\r
("\\_<USING:\\( \\)" (1 "<b"))\r
("\\_<\\(C\\)-ENUM: \\(;\\)" (1 "<b") (2 ">b"))\r
- ("\\_<C-ENUM:\\( \\|\n\\)" (1 "<b"))\r
+ ("\\_<ENUM:\\( \\|\n\\)" (1 "<b"))\r
("\\_<TUPLE: +\\w+? +< +\\w+? *\\( \\|\n\\)\\([^;]\\|$\\)" (1 "<b"))\r
("\\_<TUPLE: +\\w+? *\\( \\|\n\\)\\([^;<\n]\\|\\_>\\)" (1 "<b"))\r
("\\_<\\(SYMBOLS\\|SPECIALIZED-ARRAYS\\|SINGLETONS\\|VARIANT\\): *?\\( \\|\n\\)\\([^;\n]\\|\\_>\\)"\r
! Internal keyset options
! (As _NONE but open for exclusive access, _CRYPT_DEFINED
! Last possible key option type, _CRYPT_DEFINED Last external keyset option)
-C-ENUM: f
- CRYPT_KEYOPT_NONE
- CRYPT_KEYOPT_READONLY
- CRYPT_KEYOPT_CREATE
- CRYPT_IKEYOPT_EXCLUSIVEACCESS
- CRYPT_KEYOPT_LAST
-;
+CONSTANT: CRYPT_KEYOPT_NONE 0
+CONSTANT: CRYPT_KEYOPT_READONLY 1
+CONSTANT: CRYPT_KEYOPT_CREATE 2
+CONSTANT: CRYPT_IKEYOPT_EXCLUSIVEACCESS 3
+CONSTANT: CRYPT_KEYOPT_LAST 4
: CRYPT_KEYOPT_LAST_EXTERNAL 3 ; inline ! = CRYPT_KEYOPT_CREATE + 1
: HPDF_COMP_MASK HEX: FF ; inline
! page mode
-C-ENUM: f
- HPDF_PAGE_MODE_USE_NONE
- HPDF_PAGE_MODE_USE_OUTLINE
- HPDF_PAGE_MODE_USE_THUMBS
- HPDF_PAGE_MODE_FULL_SCREEN
- HPDF_PAGE_MODE_EOF
-;
+CONSTANT: HPDF_PAGE_MODE_USE_NONE 0
+CONSTANT: HPDF_PAGE_MODE_USE_OUTLINE 1
+CONSTANT: HPDF_PAGE_MODE_USE_THUMBS 2
+CONSTANT: HPDF_PAGE_MODE_FULL_SCREEN 3
+CONSTANT: HPDF_PAGE_MODE_EOF 4
: error-code ( -- seq ) {
{ HEX: 1001 "HPDF_ARRAY_COUNT_ERR\nInternal error. The consistency of the data was lost." }