Changing : foo ; parsing to SYNTAX: foo ;

diff --git a/basis/alien/destructors/destructors.factor b/basis/alien/destructors/destructors.factor
index 6c55528b70438c3fb146e78b3e2cefce355b4a82..1b6022d3b7b21bea1dadde136f2013a4761770e0 100644 (file)
--- a/basis/alien/destructors/destructors.factor
+++ b/basis/alien/destructors/destructors.factor
@@ -26,4 +26,4 @@ M: F-destructor dispose* alien>> F ;
 
 ;FUNCTOR
 
-: DESTRUCTOR: scan-word define-destructor ; parsing
\ No newline at end of file
+SYNTAX: DESTRUCTOR: scan-word define-destructor ;
\ No newline at end of file

diff --git a/basis/alien/fortran/fortran.factor b/basis/alien/fortran/fortran.factor
index 5e3dc24476520496b59b36c59987d9ccfda93562..83d56bf9e266b73cd90e400d1df9eb7b4159e933 100644 (file)
--- a/basis/alien/fortran/fortran.factor
+++ b/basis/alien/fortran/fortran.factor
@@ -416,7 +416,7 @@ PRIVATE>
 : define-fortran-record ( name vocab fields -- )
     [ >lower ] [ ] [ fortran-record>c-struct ] tri* define-struct ;
 
-: RECORD: scan in get parse-definition define-fortran-record ; parsing
+SYNTAX: RECORD: scan in get parse-definition define-fortran-record ;
 
 : set-fortran-abi ( library -- )
     library-fortran-abis get-global at fortran-abi set ;
@@ -437,16 +437,16 @@ MACRO: fortran-invoke ( return library function parameters -- )
     return library function parameters return [ "void" ] unless* parse-arglist
     [ \ fortran-invoke 5 [ ] nsequence ] dip define-declared ;
 
-: SUBROUTINE: 
+SYNTAX: SUBROUTINE: 
     f "c-library" get scan ";" parse-tokens
-    [ "()" subseq? not ] filter define-fortran-function ; parsing
+    [ "()" subseq? not ] filter define-fortran-function ;
 
-: FUNCTION:
+SYNTAX: FUNCTION:
     scan "c-library" get scan ";" parse-tokens
-    [ "()" subseq? not ] filter define-fortran-function ; parsing
+    [ "()" subseq? not ] filter define-fortran-function ;
 
-: LIBRARY:
+SYNTAX: LIBRARY:
     scan
     [ "c-library" set ]
-    [ set-fortran-abi ] bi  ; parsing
+    [ set-fortran-abi ] bi ;
 

diff --git a/basis/alien/syntax/syntax.factor b/basis/alien/syntax/syntax.factor
index 987c73127ee5feddf694a3bed65338920af44225..5406970364f54da685f27539d774ca3a1dd89414 100644 (file)
--- a/basis/alien/syntax/syntax.factor
+++ b/basis/alien/syntax/syntax.factor
@@ -7,35 +7,34 @@ effects assocs combinators lexer strings.parser alien.parser
 fry vocabs.parser words.constant ;
 IN: alien.syntax
 
-: DLL" lexer get skip-blank parse-string dlopen parsed ; parsing
+SYNTAX: DLL" lexer get skip-blank parse-string dlopen parsed ;
 
-: ALIEN: scan string>number <alien> parsed ; parsing
+SYNTAX: ALIEN: scan string>number <alien> parsed ;
 
-: BAD-ALIEN <bad-alien> parsed ; parsing
+SYNTAX: BAD-ALIEN <bad-alien> parsed ;
 
-: LIBRARY: scan "c-library" set ; parsing
+SYNTAX: LIBRARY: scan "c-library" set ;
 
-: FUNCTION:
+SYNTAX: FUNCTION:
     scan "c-library" get scan ";" parse-tokens
     [ "()" subseq? not ] filter
-    define-function ; parsing
+    define-function ;
 
-: TYPEDEF:
-    scan scan typedef ; parsing
+SYNTAX: TYPEDEF:
+    scan scan typedef ;
 
-: C-STRUCT:
-    scan in get parse-definition define-struct ; parsing
+SYNTAX: C-STRUCT:
+    scan in get parse-definition define-struct ;
 
-: C-UNION:
-    scan parse-definition define-union ; parsing
+SYNTAX: C-UNION:
+    scan parse-definition define-union ;
 
-: C-ENUM:
+SYNTAX: C-ENUM:
     ";" parse-tokens
     [ [ create-in ] dip define-constant ] each-index ;
-    parsing
 
 : address-of ( name library -- value )
     load-library dlsym [ "No such symbol" throw ] unless* ;
 
-: &:
-    scan "c-library" get '[ _ _ address-of ] over push-all ; parsing
+SYNTAX: &:
+    scan "c-library" get '[ _ _ address-of ] over push-all ;

diff --git a/basis/bit-arrays/bit-arrays.factor b/basis/bit-arrays/bit-arrays.factor
index e7dd6695a7e90bdfc36c3bb9bdbf290272faa8fa..be8c434e36918c9f60b937fcf4d263042515394c 100644 (file)
--- a/basis/bit-arrays/bit-arrays.factor
+++ b/basis/bit-arrays/bit-arrays.factor
@@ -68,7 +68,7 @@ M: bit-array resize
 
 M: bit-array byte-length length 7 + -3 shift ;
 
-: ?{ \ } [ >bit-array ] parse-literal ; parsing
+SYNTAX: ?{ \ } [ >bit-array ] parse-literal ;
 
 : integer>bit-array ( n -- bit-array )
     dup 0 = [

diff --git a/basis/bit-vectors/bit-vectors.factor b/basis/bit-vectors/bit-vectors.factor
index 85bea80b2dbadc239747c2a20fa22d65314a5c4e..a238f61244dc1675fed7bf94c32344e65035a924 100644 (file)
--- a/basis/bit-vectors/bit-vectors.factor
+++ b/basis/bit-vectors/bit-vectors.factor
@@ -31,7 +31,7 @@ M: bit-array new-resizable drop <bit-vector> ;
 \r
 INSTANCE: bit-vector growable\r
 \r
-: ?V{ \ } [ >bit-vector ] parse-literal ; parsing\r
+SYNTAX: ?V{ \ } [ >bit-vector ] parse-literal ;\r
 \r
 M: bit-vector >pprint-sequence ;\r
 M: bit-vector pprint-delims drop \ ?V{ \ } ;\r

diff --git a/basis/byte-vectors/byte-vectors.factor b/basis/byte-vectors/byte-vectors.factor
index d146017db08d636d5022f64fbf833e67f562e376..970f4abbd8918bd750aaecce36e5a1fcc8f9ec9c 100644 (file)
--- a/basis/byte-vectors/byte-vectors.factor
+++ b/basis/byte-vectors/byte-vectors.factor
@@ -42,7 +42,7 @@ M: byte-array like
 \r
 M: byte-array new-resizable drop <byte-vector> ;\r
 \r
-: BV{ \ } [ >byte-vector ] parse-literal ; parsing\r
+SYNTAX: BV{ \ } [ >byte-vector ] parse-literal ;\r
 \r
 M: byte-vector pprint* pprint-object ;\r
 M: byte-vector pprint-delims drop \ BV{ \ } ;\r

diff --git a/basis/cocoa/cocoa.factor b/basis/cocoa/cocoa.factor
index 01f134e2836cac06f1f314f5fc2119ea12abda39..69d698f9b10c1943a4170eebe2f92d64ddd59cf8 100644 (file)
--- a/basis/cocoa/cocoa.factor
+++ b/basis/cocoa/cocoa.factor
@@ -14,18 +14,14 @@ SYMBOL: sent-messages
 : remember-send ( selector -- )
     sent-messages (remember-send) ;
 
-: ->
-    scan dup remember-send parsed \ send parsed ;
-    parsing
+SYNTAX: -> scan dup remember-send parsed \ send parsed ;
 
 SYMBOL: super-sent-messages
 
 : remember-super-send ( selector -- )
     super-sent-messages (remember-send) ;
 
-: SUPER->
-    scan dup remember-super-send parsed \ super-send parsed ;
-    parsing
+SYNTAX: SUPER-> scan dup remember-super-send parsed \ super-send parsed ;
 
 SYMBOL: frameworks
 
@@ -33,9 +29,9 @@ frameworks [ V{ } clone ] initialize
 
 [ frameworks get [ load-framework ] each ] "cocoa.messages" add-init-hook
 
-: FRAMEWORK: scan [ load-framework ] [ frameworks get push ] bi ; parsing
+SYNTAX: FRAMEWORK: scan [ load-framework ] [ frameworks get push ] bi ;
 
-: IMPORT: scan [ ] import-objc-class ; parsing
+SYNTAX: IMPORT: scan [ ] import-objc-class ;
 
 "Compiling Objective C bridge..." print
 

diff --git a/basis/cocoa/subclassing/subclassing.factor b/basis/cocoa/subclassing/subclassing.factor
index c3f1b471e0a72dcfbb4b352cba8ba99aa12d21c2..e4db56221f33a40e0c7ba5911bb0e7d3a04f6896 100644 (file)
--- a/basis/cocoa/subclassing/subclassing.factor
+++ b/basis/cocoa/subclassing/subclassing.factor
@@ -76,6 +76,6 @@ SYMBOL: +superclass+
         import-objc-class
     ] bind ;
 
-: CLASS:
+SYNTAX: CLASS:
     parse-definition unclip
-    >hashtable define-objc-class ; parsing
+    >hashtable define-objc-class ;

diff --git a/basis/colors/constants/constants.factor b/basis/colors/constants/constants.factor
index 91621c110b4bcdd663ac0404117edaab5e930478..38339577cf93a37c7c4de7a16bed77aa54147f01 100644 (file)
--- a/basis/colors/constants/constants.factor
+++ b/basis/colors/constants/constants.factor
@@ -30,4 +30,4 @@ ERROR: no-such-color name ;
 : named-color ( name -- color )
     dup rgb.txt at [ ] [ no-such-color ] ?if ;
 
-: COLOR: scan named-color parsed ; parsing
\ No newline at end of file
+SYNTAX: COLOR: scan named-color parsed ;
\ No newline at end of file

diff --git a/basis/compiler/cfg/instructions/syntax/syntax.factor b/basis/compiler/cfg/instructions/syntax/syntax.factor
index 0389841e8f5ec78a25eaa410c4e7fff405ceb798..876ac5596cd829906b03b19505286f004daf6e1a 100644 (file)
--- a/basis/compiler/cfg/instructions/syntax/syntax.factor
+++ b/basis/compiler/cfg/instructions/syntax/syntax.factor
@@ -13,10 +13,10 @@ IN: compiler.cfg.instructions.syntax
 : insn-effect ( word -- effect )
     boa-effect in>> but-last f <effect> ;
 
-: INSN:
+SYNTAX: INSN:
     parse-tuple-definition "regs" suffix
     [ dup tuple eq? [ drop insn-word ] when ] dip
     [ define-tuple-class ]
     [ 2drop save-location ]
     [ 2drop [ ] [ '[ f _ boa , ] ] [ insn-effect ] tri define-inline ]
-    3tri ; parsing
+    3tri ;

diff --git a/basis/compiler/cfg/registers/registers.factor b/basis/compiler/cfg/registers/registers.factor
index 2b9d3df6f674896fb4e42a3a7759fb1e5eb17f9e..0882bed06e696d5b9fe255d9376dd5cd52ec8f83 100644 (file)
--- a/basis/compiler/cfg/registers/registers.factor
+++ b/basis/compiler/cfg/registers/registers.factor
@@ -17,6 +17,6 @@ C: <ds-loc> ds-loc
 TUPLE: rs-loc < loc ;
 C: <rs-loc> rs-loc
 
-: V scan-word scan-word vreg boa parsed ; parsing
-: D scan-word <ds-loc> parsed ; parsing
-: R scan-word <rs-loc> parsed ; parsing
+SYNTAX: V scan-word scan-word vreg boa parsed ;
+SYNTAX: D scan-word <ds-loc> parsed ;
+SYNTAX: R scan-word <rs-loc> parsed ;

diff --git a/basis/constructors/constructors.factor b/basis/constructors/constructors.factor
index 2eab91310ff7f37d0d70114d4142bfde6e4b4b9e..8cfeb83910624ce90c8aafe8d3baebead7957401 100644 (file)
--- a/basis/constructors/constructors.factor
+++ b/basis/constructors/constructors.factor
@@ -16,8 +16,8 @@ MACRO: set-slots ( slots -- quot )
     [ [ in>> '[ _ _ construct ] ] dip compose ] [ drop ] 2bi
     define-declared ;
 
-: CONSTRUCTOR:
+SYNTAX: CONSTRUCTOR:
     scan-word [ name>> "<" ">" surround create-in ] keep
     "(" expect ")" parse-effect
     parse-definition
-    define-constructor ; parsing
\ No newline at end of file
+    define-constructor ;
\ No newline at end of file

diff --git a/basis/core-text/utilities/utilities.factor b/basis/core-text/utilities/utilities.factor
index 8c085d40be3094e41ac7ffb26ab63353e0b90743..7de601c433a5d32fb3e67700d22bdf6d734ab675 100644 (file)
--- a/basis/core-text/utilities/utilities.factor
+++ b/basis/core-text/utilities/utilities.factor
@@ -3,7 +3,7 @@
 USING: words parser alien alien.c-types kernel fry accessors ;
 IN: core-text.utilities
 
-: C-GLOBAL:
+SYNTAX: C-GLOBAL:
     CREATE-WORD
     dup name>> '[ _ f dlsym *void* ]
-    (( -- value )) define-declared ; parsing
+    (( -- value )) define-declared ;

diff --git a/basis/cpu/ppc/assembler/backend/backend.factor b/basis/cpu/ppc/assembler/backend/backend.factor
index c6a3a941949dfb0eca459d232c75056500b4a53e..befbe112bd0d248fa46d4404eb5feb82d8170471 100644 (file)
--- a/basis/cpu/ppc/assembler/backend/backend.factor
+++ b/basis/cpu/ppc/assembler/backend/backend.factor
@@ -21,7 +21,7 @@ IN: cpu.ppc.assembler.backend
 : define-d-insn ( word opcode -- )
     [ d-insn ] curry (( d a simm -- )) define-declared ;
 
-: D: CREATE scan-word define-d-insn ; parsing
+SYNTAX: D: CREATE scan-word define-d-insn ;
 
 : sd-insn ( d a simm opcode -- )
     [ s>u16 { 0 21 16 } bitfield ] dip insn ;
@@ -29,7 +29,7 @@ IN: cpu.ppc.assembler.backend
 : define-sd-insn ( word opcode -- )
     [ sd-insn ] curry (( d a simm -- )) define-declared ;
 
-: SD: CREATE scan-word define-sd-insn ; parsing
+SYNTAX: SD: CREATE scan-word define-sd-insn ;
 
 : i-insn ( li aa lk opcode -- )
     [ { 0 1 0 } bitfield ] dip insn ;
@@ -40,26 +40,26 @@ IN: cpu.ppc.assembler.backend
 : (X) ( -- word quot )
     CREATE scan-word scan-word scan-word [ x-insn ] 3curry ;
 
-: X: (X) (( a s b -- )) define-declared ; parsing
+SYNTAX: X: (X) (( a s b -- )) define-declared ;
 
 : (1) ( quot -- quot' ) [ 0 ] prepose ;
 
-: X1: (X) (1) (( a s -- )) define-declared ; parsing
+SYNTAX: X1: (X) (1) (( a s -- )) define-declared ;
 
 : xfx-insn ( d spr xo opcode -- )
     [ { 1 11 21 } bitfield ] dip insn ;
 
 : CREATE-MF ( -- word ) scan "MF" prepend create-in ;
 
-: MFSPR:
+SYNTAX: MFSPR:
     CREATE-MF scan-word 5 shift [ 339 31 xfx-insn ] curry
-    (( d -- )) define-declared ; parsing
+    (( d -- )) define-declared ;
 
 : CREATE-MT ( -- word ) scan "MT" prepend create-in ;
 
-: MTSPR:
+SYNTAX: MTSPR:
     CREATE-MT scan-word 5 shift [ 467 31 xfx-insn ] curry
-    (( d -- )) define-declared ; parsing
+    (( d -- )) define-declared ;
 
 : xo-insn ( d a b oe rc xo opcode -- )
     [ { 1 0 10 11 16 21 } bitfield ] dip insn ;
@@ -68,9 +68,9 @@ IN: cpu.ppc.assembler.backend
     CREATE scan-word scan-word scan-word scan-word
     [ xo-insn ] 2curry 2curry ;
 
-: XO: (XO) (( a s b -- )) define-declared ; parsing
+SYNTAX: XO: (XO) (( a s b -- )) define-declared ;
 
-: XO1: (XO) (1) (( a s -- )) define-declared ; parsing
+SYNTAX: XO1: (XO) (1) (( a s -- )) define-declared ;
 
 GENERIC# (B) 2 ( dest aa lk -- )
 M: integer (B) 18 i-insn ;
@@ -84,11 +84,11 @@ M: label BC [ 0 BC ] dip rc-relative-ppc-2 label-fixup ;
 
 : CREATE-B ( -- word ) scan "B" prepend create-in ;
 
-: BC:
+SYNTAX: BC:
     CREATE-B scan-word scan-word
-    [ rot BC ] 2curry (( c -- )) define-declared ; parsing
+    [ rot BC ] 2curry (( c -- )) define-declared ;
 
-: B:
+SYNTAX: B:
     CREATE-B scan-word scan-word scan-word scan-word scan-word
     [ b-insn ] curry curry curry curry curry
-    (( bo -- )) define-declared ; parsing
+    (( bo -- )) define-declared ;

diff --git a/basis/cpu/x86/assembler/syntax/syntax.factor b/basis/cpu/x86/assembler/syntax/syntax.factor
index 343850f9e639dc47ffb8bb59947cb1e868721de9..631dcaa8f7d3536fae6f9d169f407a523a3c20bb 100644 (file)
--- a/basis/cpu/x86/assembler/syntax/syntax.factor
+++ b/basis/cpu/x86/assembler/syntax/syntax.factor
@@ -11,5 +11,4 @@ IN: cpu.x86.assembler.syntax
 : define-registers ( names size -- )
     '[ _ define-register ] each-index ;
 
-: REGISTERS: ( -- )
-    scan-word ";" parse-tokens swap define-registers ; parsing
+SYNTAX: REGISTERS: scan-word ";" parse-tokens swap define-registers ;

diff --git a/basis/definitions/icons/icons.factor b/basis/definitions/icons/icons.factor
index fb25ccf7151bc5b83163427e441fb588b8290f11..7c5fbed9f4c83bb858f942dbe397e1185150151e 100644 (file)
--- a/basis/definitions/icons/icons.factor
+++ b/basis/definitions/icons/icons.factor
@@ -14,10 +14,10 @@ GENERIC: definition-icon ( definition -- path )
 
 <<
 
-: ICON:
+SYNTAX: ICON:
     scan-word \ definition-icon create-method
     scan '[ drop _ definition-icon-path ]
-    define ; parsing
+    define ;
 
 >>
 

diff --git a/basis/delegate/delegate.factor b/basis/delegate/delegate.factor
index 0c16b7c336e0647aee9bc48515998bdf5397cf0c..fe6ea03794f01fa5e9578ee4c789260dbc3e2ee2 100644 (file)
--- a/basis/delegate/delegate.factor
+++ b/basis/delegate/delegate.factor
@@ -85,9 +85,9 @@ PRIVATE>
 : define-consult ( consultation -- )
     [ register-consult ] [ consult-methods ] bi ;
 
-: CONSULT:
+SYNTAX: CONSULT:
     scan-word scan-word parse-definition <consultation>
-    [ save-location ] [ define-consult ] bi ; parsing
+    [ save-location ] [ define-consult ] bi ;
 
 M: consultation where loc>> ;
 
@@ -144,8 +144,8 @@ PRIVATE>
         [ initialize-protocol-props ] 2tri
     ] 2bi ;
 
-: PROTOCOL:
-    CREATE-WORD parse-definition define-protocol ; parsing
+SYNTAX: PROTOCOL:
+    CREATE-WORD parse-definition define-protocol ;
 
 PREDICATE: protocol < word protocol-words ; ! Subclass of symbol?
 
@@ -159,7 +159,7 @@ M: protocol definer drop \ PROTOCOL: \ ; ;
 
 M: protocol group-words protocol-words ;
 
-: SLOT-PROTOCOL:
+SYNTAX: SLOT-PROTOCOL:
     CREATE-WORD ";" parse-tokens
     [ [ reader-word ] [ writer-word ] bi 2array ] map concat
-    define-protocol ; parsing
\ No newline at end of file
+    define-protocol ;
\ No newline at end of file

diff --git a/basis/fry/fry.factor b/basis/fry/fry.factor
index 9ffad43cf42fbf7483454c6210c61763c1088b53..d50fd9442bf72dd62baf65525f6a30e7e803b952 100644 (file)
--- a/basis/fry/fry.factor
+++ b/basis/fry/fry.factor
@@ -53,4 +53,4 @@ M: callable deep-fry
 
 M: object deep-fry , ;
 
-: '[ parse-quotation fry over push-all ; parsing
+SYNTAX: '[ parse-quotation fry over push-all ;

diff --git a/basis/functors/functors.factor b/basis/functors/functors.factor
index caa41d6c2962a0e651bc70792363fe136c81ee6c..58c9edaf0c4c196bd89e2ffcb34fd7a820e35851 100644 (file)
--- a/basis/functors/functors.factor
+++ b/basis/functors/functors.factor
@@ -16,6 +16,8 @@ IN: functors
 
 : define* ( word def effect -- ) pick set-word define-declared ;
 
+: define-syntax* ( word def -- ) over set-word define-syntax ;
+
 TUPLE: fake-quotation seq ;
 
 GENERIC: >fake-quotations ( quot -- fake )
@@ -41,7 +43,7 @@ M: object fake-quotations> ;
 
 : DEFINE* ( accum -- accum ) effect get parsed \ define* parsed ;
 
-: `TUPLE:
+SYNTAX: `TUPLE:
     scan-param parsed
     scan {
         { ";" [ tuple parsed f parsed ] }
@@ -52,40 +54,44 @@ M: object fake-quotations> ;
             make parsed
         ]
     } case
-    \ define-tuple-class parsed ; parsing
+    \ define-tuple-class parsed ;
 
-: `M:
+SYNTAX: `M:
     effect off
     scan-param parsed
     scan-param parsed
     \ create-method-in parsed
     parse-definition*
-    DEFINE* ; parsing
+    DEFINE* ;
 
-: `C:
+SYNTAX: `C:
     effect off
     scan-param parsed
     scan-param parsed
     [ [ boa ] curry ] over push-all
-    DEFINE* ; parsing
+    DEFINE* ;
 
-: `:
+SYNTAX: `:
     effect off
     scan-param parsed
     parse-definition*
-    DEFINE* ; parsing
+    DEFINE* ;
 
-: `INSTANCE:
-    scan-param parsed
+SYNTAX: `SYNTAX:
+    effect off
     scan-param parsed
-    \ add-mixin-instance parsed ; parsing
+    parse-definition*
+    \ define-syntax* parsed ;
 
-: `inline [ word make-inline ] over push-all ; parsing
+SYNTAX: `INSTANCE:
+    scan-param parsed
+    scan-param parsed
+    \ add-mixin-instance parsed ;
 
-: `parsing [ word make-parsing ] over push-all ; parsing
+SYNTAX: `inline [ word make-inline ] over push-all ;
 
-: `(
-    ")" parse-effect effect set ; parsing
+SYNTAX: `(
+    ")" parse-effect effect set ;
 
 : (INTERPOLATE) ( accum quot -- accum )
     [ scan interpolate-locals ] dip
@@ -93,11 +99,11 @@ M: object fake-quotations> ;
 
 PRIVATE>
 
-: IS [ dup search [ ] [ no-word ] ?if ] (INTERPOLATE) ; parsing
+SYNTAX: IS [ dup search [ ] [ no-word ] ?if ] (INTERPOLATE) ;
 
-: DEFINES [ create-in ] (INTERPOLATE) ; parsing
+SYNTAX: DEFINES [ create-in ] (INTERPOLATE) ;
 
-: DEFINES-CLASS [ create-class-in ] (INTERPOLATE) ; parsing
+SYNTAX: DEFINES-CLASS [ create-class-in ] (INTERPOLATE) ;
 
 DEFER: ;FUNCTOR delimiter
 
@@ -110,8 +116,8 @@ DEFER: ;FUNCTOR delimiter
         { "C:" POSTPONE: `C: }
         { ":" POSTPONE: `: }
         { "INSTANCE:" POSTPONE: `INSTANCE: }
+        { "SYNTAX:" POSTPONE: `SYNTAX: }
         { "inline" POSTPONE: `inline }
-        { "parsing" POSTPONE: `parsing }
         { "(" POSTPONE: `( }
     } ;
 
@@ -132,4 +138,4 @@ DEFER: ;FUNCTOR delimiter
 
 PRIVATE>
 
-: FUNCTOR: (FUNCTOR:) define ; parsing
+SYNTAX: FUNCTOR: (FUNCTOR:) define ;

diff --git a/basis/help/syntax/syntax.factor b/basis/help/syntax/syntax.factor
index 9f98ba6d8d607949dcef701a3a758ef9d74a5fbd..044768aec2f8ad7712db0ed0ac785e675803f3a9 100644 (file)
--- a/basis/help/syntax/syntax.factor
+++ b/basis/help/syntax/syntax.factor
@@ -5,19 +5,19 @@ help.topics namespaces vocabs definitions compiler.units
 vocabs.parser ;
 IN: help.syntax
 
-: HELP:
+SYNTAX: HELP:
     scan-word bootstrap-word
     dup set-word
     dup >link save-location
-    \ ; parse-until >array swap set-word-help ; parsing
+    \ ; parse-until >array swap set-word-help ;
 
-: ARTICLE:
+SYNTAX: ARTICLE:
     location [
         \ ; parse-until >array [ first2 ] keep 2 tail <article>
         over add-article >link
-    ] dip remember-definition ; parsing
+    ] dip remember-definition ;
 
-: ABOUT:
+SYNTAX: ABOUT:
     in get vocab
     dup changed-definition
-    scan-object >>help drop ; parsing
+    scan-object >>help drop ;

diff --git a/basis/hints/hints.factor b/basis/hints/hints.factor
index 4093666eb7fa59f3c864d0990fe655171e687ac1..52684e55f59ab19195f37c5f6d9a42a06e344bd6 100644 (file)
--- a/basis/hints/hints.factor
+++ b/basis/hints/hints.factor
@@ -59,12 +59,11 @@ M: object specializer-declaration class ;
 : specialized-length ( specializer -- n )
     dup [ array? ] all? [ first ] when length ;
 
-: HINTS:
+SYNTAX: HINTS:
     scan-object
     dup method-spec? [ first2 method ] when
     [ redefined ]
     [ parse-definition "specializer" set-word-prop ] bi ;
-    parsing
 
 ! Default specializers
 { first first2 first3 first4 }

diff --git a/basis/html/templates/chloe/syntax/syntax.factor b/basis/html/templates/chloe/syntax/syntax.factor
index 7af37b65929831ace268e9437c31c1dd6d6ff1b8..7c47a44d9efee186f87e6c7ffff88b65e00b73b0 100644 (file)
--- a/basis/html/templates/chloe/syntax/syntax.factor
+++ b/basis/html/templates/chloe/syntax/syntax.factor
@@ -15,8 +15,8 @@ tags [ H{ } clone ] initialize
 
 : define-chloe-tag ( name quot -- ) swap tags get set-at ;
 
-: CHLOE:
-    scan parse-definition define-chloe-tag ; parsing
+SYNTAX: CHLOE:
+    scan parse-definition define-chloe-tag ;
 
 CONSTANT: chloe-ns "http://factorcode.org/chloe/1.0"
 

diff --git a/basis/html/templates/fhtml/fhtml.factor b/basis/html/templates/fhtml/fhtml.factor
index f3539f6a0fb826e8006650a3f1cd63a5b35f44f7..21e9f8352d9119ba6c23edb760de9992022d5382 100644 (file)
--- a/basis/html/templates/fhtml/fhtml.factor
+++ b/basis/html/templates/fhtml/fhtml.factor
@@ -49,7 +49,7 @@ DEFER: <% delimiter
         drop
     ] if ;
 
-: %> lexer get parse-%> ; parsing
+SYNTAX: %> lexer get parse-%> ;
 
 : parse-template-lines ( lines -- quot )
     <template-lexer> [

diff --git a/basis/interpolate/interpolate.factor b/basis/interpolate/interpolate.factor
index 5c859f8947dcdca655a99bec9c4aba763b3b76c7..1de65fa91f8febc1f5002002cb8867f2dda5fd1a 100644 (file)
--- a/basis/interpolate/interpolate.factor
+++ b/basis/interpolate/interpolate.factor
@@ -38,6 +38,6 @@ MACRO: interpolate ( string -- )
 : interpolate-locals ( string -- quot )
     [ search [ ] ] (interpolate) ;
 
-: I[
+SYNTAX: I[
     "]I" parse-multiline-string
-    interpolate-locals over push-all ; parsing
+    interpolate-locals over push-all ;

diff --git a/basis/io/encodings/euc/euc.factor b/basis/io/encodings/euc/euc.factor
index e20580876e27578e027dd53b240a586d45bb8ff8..bf882fcfd02ac4def4eaa47bff8cb91677bcd6d4 100644 (file)
--- a/basis/io/encodings/euc/euc.factor
+++ b/basis/io/encodings/euc/euc.factor
@@ -63,6 +63,6 @@ SYMBOL: euc-table
 
 PRIVATE>
 
-: EUC:
+SYNTAX: EUC:
     ! EUC: euc-kr "vocab:io/encodings/korean/cp949.txt"
-    CREATE-CLASS scan-object define-euc ; parsing
+    CREATE-CLASS scan-object define-euc ;

diff --git a/basis/listener/listener-tests.factor b/basis/listener/listener-tests.factor
index 61aa3239245824e73b0735f4defc59a8981ffe03..00f1cca678298dd2687bd0826d6b5938296fb682 100644 (file)
--- a/basis/listener/listener-tests.factor
+++ b/basis/listener/listener-tests.factor
@@ -3,7 +3,7 @@ tools.test parser math namespaces continuations vocabs kernel
 compiler.units eval vocabs.parser ;
 IN: listener.tests
 
-: hello "Hi" print ; parsing
+SYNTAX: hello "Hi" print ;
 
 : parse-interactive ( string -- quot )
     <string-reader> stream-read-quot ;

diff --git a/basis/locals/locals.factor b/basis/locals/locals.factor
index 190be61e23c2b59eb6aafef775de7e7534035cf9..e6b363c209bc48de0be1dc4e6824328d3e9083d7 100644 (file)
--- a/basis/locals/locals.factor
+++ b/basis/locals/locals.factor
@@ -5,27 +5,25 @@ vocabs.loader words kernel namespaces locals.parser locals.types
 locals.errors ;
 IN: locals
 
-: :>
+SYNTAX: :>
     scan locals get [ :>-outside-lambda-error ] unless*
-    [ make-local ] bind <def> parsed ; parsing
+    [ make-local ] bind <def> parsed ;
 
-: [| parse-lambda over push-all ; parsing
+SYNTAX: [| parse-lambda over push-all ;
 
-: [let parse-let over push-all ; parsing
+SYNTAX: [let parse-let over push-all ;
 
-: [let* parse-let* over push-all ; parsing
+SYNTAX: [let* parse-let* over push-all ;
 
-: [wlet parse-wlet over push-all ; parsing
+SYNTAX: [wlet parse-wlet over push-all ;
 
-: :: (::) define ; parsing
+SYNTAX: :: (::) define ;
 
-: M:: (M::) define ; parsing
+SYNTAX: M:: (M::) define ;
 
-: MACRO:: (::) define-macro ; parsing
+SYNTAX: MACRO:: (::) define-macro ;
 
-: MEMO:: (::) define-memoized ; parsing
-
-USE: syntax
+SYNTAX: MEMO:: (::) define-memoized ;
 
 {
     "locals.macros"

diff --git a/basis/logging/logging.factor b/basis/logging/logging.factor
index c8413c14fe7a6b63750c7061b586b38e36d6fe45..c8179108ef12d359c2958bd413c5b68c164b09ff 100644 (file)
--- a/basis/logging/logging.factor
+++ b/basis/logging/logging.factor
@@ -135,11 +135,11 @@ PRIVATE>
     [ [ input-logging-quot ] 2keep drop error-logging-quot ]\r
     (define-logging) ;\r
 \r
-: LOG:\r
+SYNTAX: LOG:\r
     #! Syntax: name level\r
     CREATE-WORD dup scan-word\r
     '[ 1array stack>message _ _ log-message ]\r
-    (( message -- )) define-declared ; parsing\r
+    (( message -- )) define-declared ;\r
 \r
 USE: vocabs.loader\r
 \r

diff --git a/basis/macros/macros.factor b/basis/macros/macros.factor
index 21a91e567d4e193756b3f03a41d47e53268cdf5b..48696015885846d8e910044de1891666e06ae543 100644 (file)
--- a/basis/macros/macros.factor
+++ b/basis/macros/macros.factor
@@ -16,7 +16,7 @@ PRIVATE>
     [ over real-macro-effect memoize-quot [ call ] append define ]
     2bi ;
 
-: MACRO: (:) define-macro ; parsing
+SYNTAX: MACRO: (:) define-macro ;
 
 PREDICATE: macro < word "macro" word-prop >boolean ;
 

diff --git a/basis/match/match.factor b/basis/match/match.factor
index 3846dea3be6317944c30690230c60c36daca12cf..b21d8c6d733983bf237c6fc521dcdb16da43769a 100644 (file)
--- a/basis/match/match.factor
+++ b/basis/match/match.factor
@@ -16,8 +16,8 @@ SYMBOL: _
 : define-match-vars ( seq -- )
     [ define-match-var ] each ;
 
-: MATCH-VARS: ! vars ...
-    ";" parse-tokens define-match-vars ; parsing
+SYNTAX: MATCH-VARS: ! vars ...
+    ";" parse-tokens define-match-vars ;
 
 : match-var? ( symbol -- bool )
     dup word? [ "match-var" word-prop ] [ drop f ] if ;

diff --git a/basis/math/blas/matrices/matrices.factor b/basis/math/blas/matrices/matrices.factor
index 6fad54550104b00adeb1cbb463b52a65ddced9e8..1882ccd0d58ce4db8ad5359d0857e83c7f55ea9d 100755 (executable)
--- a/basis/math/blas/matrices/matrices.factor
+++ b/basis/math/blas/matrices/matrices.factor
@@ -289,7 +289,7 @@ M: MATRIX n*V(*)V+M!
 M: MATRIX n*V(*)Vconj+M!
     (prepare-ger) [ XGERC ] dip ;
 
-: XMATRIX{ \ } [ >MATRIX ] parse-literal ; parsing
+SYNTAX: XMATRIX{ \ } [ >MATRIX ] parse-literal ;
 
 M: MATRIX pprint-delims
     drop \ XMATRIX{ \ } ;

diff --git a/basis/math/blas/vectors/vectors.factor b/basis/math/blas/vectors/vectors.factor
index 84b5fd9e6f707490ca013ac89a3c997e93a71daa..d7c6ebc92739083c13b1dd176f489343a26ca124 100755 (executable)
--- a/basis/math/blas/vectors/vectors.factor
+++ b/basis/math/blas/vectors/vectors.factor
@@ -179,7 +179,7 @@ M: VECTOR n*V+V!
 M: VECTOR n*V!
     (prepare-scal) [ XSCAL ] dip ;
 
-: XVECTOR{ \ } [ >VECTOR ] parse-literal ; parsing
+SYNTAX: XVECTOR{ \ } [ >VECTOR ] parse-literal ;
 
 M: VECTOR pprint-delims
     drop \ XVECTOR{ \ } ;

diff --git a/basis/math/complex/complex.factor b/basis/math/complex/complex.factor
index 273fd0b2b52116759963f927d55234e429833bd7..c41faaf5585a1638e298b93638d00d220adb929d 100644 (file)
--- a/basis/math/complex/complex.factor
+++ b/basis/math/complex/complex.factor
@@ -31,7 +31,7 @@ M: complex sqrt >polar [ fsqrt ] [ 2.0 / ] bi* polar> ;
 
 IN: syntax
 
-: C{ \ } [ first2 rect> ] parse-literal ; parsing
+SYNTAX: C{ \ } [ first2 rect> ] parse-literal ;
 
 USE: prettyprint.custom
 

diff --git a/basis/memoize/memoize.factor b/basis/memoize/memoize.factor
index 3bc573dff513c73bb0bb3d3d0efc2e9aea616509..2c0cd357db90f806b52afdf4724f543573609696 100644 (file)
--- a/basis/memoize/memoize.factor
+++ b/basis/memoize/memoize.factor
@@ -41,7 +41,7 @@ PRIVATE>
     [ drop "memoize" set-word-prop ]
     3tri ;
 
-: MEMO: (:) define-memoized ; parsing
+SYNTAX: MEMO: (:) define-memoized ;
 
 PREDICATE: memoized < word "memoize" word-prop ;
 

diff --git a/basis/multiline/multiline.factor b/basis/multiline/multiline.factor
index 53c2789c50b669eb8355c5a30eebfb48a9b2b015..2e8f8eb4c497d1fb9252ee15b1b554f2d6645a6f 100644 (file)
--- a/basis/multiline/multiline.factor
+++ b/basis/multiline/multiline.factor
@@ -20,10 +20,10 @@ PRIVATE>
     [ (parse-here) ] "" make but-last
     lexer get next-line ;
 
-: STRING:
+SYNTAX: STRING:
     CREATE-WORD
     parse-here 1quotation
-    (( -- string )) define-inline ; parsing
+    (( -- string )) define-inline ;
 
 <PRIVATE
 
@@ -48,16 +48,16 @@ PRIVATE>
         change-column drop
     ] "" make ;
 
-: <"
-    "\">" parse-multiline-string parsed ; parsing
+SYNTAX: <"
+    "\">" parse-multiline-string parsed ;
 
-: <'
-    "'>" parse-multiline-string parsed ; parsing
+SYNTAX: <'
+    "'>" parse-multiline-string parsed ;
 
-: {'
-    "'}" parse-multiline-string parsed ; parsing
+SYNTAX: {'
+    "'}" parse-multiline-string parsed ;
 
-: {"
-    "\"}" parse-multiline-string parsed ; parsing
+SYNTAX: {"
+    "\"}" parse-multiline-string parsed ;
 
-: /* "*/" parse-multiline-string drop ; parsing
+SYNTAX: /* "*/" parse-multiline-string drop ;

diff --git a/basis/nibble-arrays/nibble-arrays.factor b/basis/nibble-arrays/nibble-arrays.factor
index 22a1515908fa7a1e8238c631cce6e20adaea2e08..16bea56862fe19bd921ae11d591cd89473043f7d 100644 (file)
--- a/basis/nibble-arrays/nibble-arrays.factor
+++ b/basis/nibble-arrays/nibble-arrays.factor
@@ -62,7 +62,7 @@ M: nibble-array resize
 
 M: nibble-array byte-length length nibbles>bytes ;
 
-: N{ \ } [ >nibble-array ] parse-literal ; parsing
+SYNTAX: N{ \ } [ >nibble-array ] parse-literal ;
 
 INSTANCE: nibble-array sequence
 

diff --git a/basis/opengl/gl/extensions/extensions.factor b/basis/opengl/gl/extensions/extensions.factor
index fb2ddfaf3e411498e22f449a7fb13d98d5e9c74b..ccd3f5fad74e2ed9806fe53f5b349fe91a3efd47 100644 (file)
--- a/basis/opengl/gl/extensions/extensions.factor
+++ b/basis/opengl/gl/extensions/extensions.factor
@@ -47,7 +47,7 @@ reset-gl-function-number-counter
     parameters return parse-arglist [ abi indirect-quot ] dip
     define-declared ;
 
-: GL-FUNCTION:
+SYNTAX: GL-FUNCTION:
     gl-function-calling-convention
     scan
     scan dup
@@ -55,5 +55,4 @@ reset-gl-function-number-counter
     gl-function-number
     [ gl-function-pointer ] 2curry swap
     ";" parse-tokens [ "()" subseq? not ] filter
-    define-indirect
-    ; parsing
+    define-indirect ;

diff --git a/basis/openssl/libssl/libssl.factor b/basis/openssl/libssl/libssl.factor
index e512e3134c66e644de062a9e8826fc1c02c2ab48..8ed15a4e5e2b2dd53963abdef639b0bf2f3cc035 100644 (file)
--- a/basis/openssl/libssl/libssl.factor
+++ b/basis/openssl/libssl/libssl.factor
@@ -279,12 +279,12 @@ H{ } clone verify-messages set-global
 
 : verify-message ( n -- word ) verify-messages get-global at ;
 
-: X509_V_:
+SYNTAX: X509_V_:
     scan "X509_V_" prepend create-in
     scan-word
     [ 1quotation (( -- value )) define-inline ]
     [ verify-messages get set-at ]
-    2bi ; parsing
+    2bi ;
 
 >>
 

diff --git a/basis/peg/ebnf/ebnf.factor b/basis/peg/ebnf/ebnf.factor
index 1f526d47f2bd3122a02197bf55d839fd2b2430ad..9f730831e79e11184a71d04814b20df6e88fc6de 100644 (file)
--- a/basis/peg/ebnf/ebnf.factor
+++ b/basis/peg/ebnf/ebnf.factor
@@ -34,9 +34,9 @@ TUPLE: tokenizer any one many ;
 : reset-tokenizer ( -- )\r
   default-tokenizer \ tokenizer set-global ;\r
 \r
-: TOKENIZER: \r
+SYNTAX: TOKENIZER: \r
   scan search [ "Tokenizer not found" throw ] unless*\r
-  execute( -- tokenizer ) \ tokenizer set-global ; parsing\r
+  execute( -- tokenizer ) \ tokenizer set-global ;\r
 \r
 TUPLE: ebnf-non-terminal symbol ;\r
 TUPLE: ebnf-terminal symbol ;\r
@@ -522,16 +522,14 @@ M: ebnf-non-terminal (transform) ( ast -- parser )
   parse-ebnf dup dup parser [ main swap at compile ] with-variable\r
   [ compiled-parse ] curry [ with-scope ast>> ] curry ;\r
 \r
-: <EBNF "EBNF>" reset-tokenizer parse-multiline-string parse-ebnf main swap at  \r
-  parsed reset-tokenizer ; parsing\r
+SYNTAX: <EBNF "EBNF>" reset-tokenizer parse-multiline-string parse-ebnf main swap at  \r
+  parsed reset-tokenizer ;\r
 \r
-: [EBNF "EBNF]" reset-tokenizer parse-multiline-string ebnf>quot nip \r
-  parsed \ call parsed reset-tokenizer ; parsing\r
+SYNTAX: [EBNF "EBNF]" reset-tokenizer parse-multiline-string ebnf>quot nip \r
+  parsed \ call parsed reset-tokenizer ;\r
 \r
-: EBNF: \r
+SYNTAX: EBNF: \r
   reset-tokenizer CREATE-WORD dup ";EBNF" parse-multiline-string  \r
   ebnf>quot swapd (( input -- ast )) define-declared "ebnf-parser" set-word-prop \r
-  reset-tokenizer ; parsing\r
-\r
-\r
+  reset-tokenizer ;\r
 \r

diff --git a/basis/peg/peg.factor b/basis/peg/peg.factor
index 6c0772aacc3269d883872d0874b25d8beeef14d1..febcde5b25869faef5b816f3d9f458ed14e495fd 100644 (file)
--- a/basis/peg/peg.factor
+++ b/basis/peg/peg.factor
@@ -616,7 +616,7 @@ PRIVATE>
 
 ERROR: parse-failed input word ;
 
-: PEG:
+SYNTAX: PEG:
   (:)
   [let | def [ ] word [ ] |
     [
@@ -630,7 +630,7 @@ ERROR: parse-failed input word ;
         ]
       ] with-compilation-unit
     ] over push-all
-  ] ; parsing
+  ] ;
 
 USING: vocabs vocabs.loader ;
 

diff --git a/basis/persistent/hashtables/hashtables.factor b/basis/persistent/hashtables/hashtables.factor
index 8c80782a2e5da3d8dfcda6d3e91ee63aa798848f..67886312c67379383fd7504e7e36178fc2ea5c7b 100644 (file)
--- a/basis/persistent/hashtables/hashtables.factor
+++ b/basis/persistent/hashtables/hashtables.factor
@@ -48,7 +48,7 @@ M: persistent-hash hashcode* nip assoc-size ;
 
 M: persistent-hash clone ;
 
-: PH{ \ } [ >persistent-hash ] parse-literal ; parsing
+SYNTAX: PH{ \ } [ >persistent-hash ] parse-literal ;
 
 M: persistent-hash pprint-delims drop \ PH{ \ } ;
 M: persistent-hash >pprint-sequence >alist ;

diff --git a/basis/persistent/vectors/vectors.factor b/basis/persistent/vectors/vectors.factor
index 478fc0ad254ade4c7cffdac81b4fa9147f57f4ca..ae33b7c39aa7f024d06e87ada22923e584a57cf8 100644 (file)
--- a/basis/persistent/vectors/vectors.factor
+++ b/basis/persistent/vectors/vectors.factor
@@ -179,7 +179,7 @@ M: persistent-vector equal?
 : >persistent-vector ( seq -- pvec )
     T{ persistent-vector } like ;
 
-: PV{ \ } [ >persistent-vector ] parse-literal ; parsing
+SYNTAX: PV{ \ } [ >persistent-vector ] parse-literal ;
 
 M: persistent-vector pprint-delims drop \ PV{ \ } ;
 M: persistent-vector >pprint-sequence ;

diff --git a/basis/prettyprint/prettyprint-docs.factor b/basis/prettyprint/prettyprint-docs.factor
index 2be725c0f65247045addf65c91e77974249c6222..f938ab30f763b32e77383b9b253f60bcbcdcdddd 100644 (file)
--- a/basis/prettyprint/prettyprint-docs.factor
+++ b/basis/prettyprint/prettyprint-docs.factor
@@ -96,12 +96,12 @@ ARTICLE: "prettyprint-literal" "Literal prettyprinting protocol"
 { $code
     "TUPLE: rect w h ;"
     ""
-    ": RECT["
+    "SYNTAX: RECT["
     "    scan-word"
     "    scan-word \\ * assert="
     "    scan-word"
     "    scan-word \\ ] assert="
-    "    <rect> parsed ; parsing"
+    "    <rect> parsed ;"
 }
 "An example literal might be:"
 { $code "RECT[ 100 * 200 ]" }

diff --git a/basis/regexp/regexp.factor b/basis/regexp/regexp.factor
index 33499b14372bc5e7a143cfda03d0afc6248f35fe..21439640fe18f6934606946006062c301265ab14 100644 (file)
--- a/basis/regexp/regexp.factor
+++ b/basis/regexp/regexp.factor
@@ -204,17 +204,17 @@ PRIVATE>
 
 PRIVATE>
 
-: R! CHAR: ! parsing-regexp ; parsing
-: R" CHAR: " parsing-regexp ; parsing
-: R# CHAR: # parsing-regexp ; parsing
-: R' CHAR: ' parsing-regexp ; parsing
-: R( CHAR: ) parsing-regexp ; parsing
-: R/ CHAR: / parsing-regexp ; parsing
-: R@ CHAR: @ parsing-regexp ; parsing
-: R[ CHAR: ] parsing-regexp ; parsing
-: R` CHAR: ` parsing-regexp ; parsing
-: R{ CHAR: } parsing-regexp ; parsing
-: R| CHAR: | parsing-regexp ; parsing
+SYNTAX: R! CHAR: ! parsing-regexp ;
+SYNTAX: R" CHAR: " parsing-regexp ;
+SYNTAX: R# CHAR: # parsing-regexp ;
+SYNTAX: R' CHAR: ' parsing-regexp ;
+SYNTAX: R( CHAR: ) parsing-regexp ;
+SYNTAX: R/ CHAR: / parsing-regexp ;
+SYNTAX: R@ CHAR: @ parsing-regexp ;
+SYNTAX: R[ CHAR: ] parsing-regexp ;
+SYNTAX: R` CHAR: ` parsing-regexp ;
+SYNTAX: R{ CHAR: } parsing-regexp ;
+SYNTAX: R| CHAR: | parsing-regexp ;
 
 USING: vocabs vocabs.loader ;
 

diff --git a/basis/roman/roman.factor b/basis/roman/roman.factor
index 24713545b136a92064b058569f5719cae4c05716..71343b723d1da06bd13ed284d83522a2065c1724 100644 (file)
--- a/basis/roman/roman.factor
+++ b/basis/roman/roman.factor
@@ -74,4 +74,4 @@ PRIVATE>
 : roman/mod ( str1 str2 -- str3 str4 )
     [ /mod ] binary-roman-op [ >roman ] dip ;
 
-: ROMAN: scan roman> parsed ; parsing
+SYNTAX: ROMAN: scan roman> parsed ;

diff --git a/basis/see/see.factor b/basis/see/see.factor
index ab9fa2006f16288e020a2ba69f8d774c4b139d05..041a72ea0e7a1999dc0d5c1bb24ac8a5e6407fd4 100644 (file)
--- a/basis/see/see.factor
+++ b/basis/see/see.factor
@@ -93,7 +93,6 @@ M: object declarations. drop ;
 
 M: word declarations.
     {
-        POSTPONE: parsing
         POSTPONE: delimiter
         POSTPONE: inline
         POSTPONE: recursive

diff --git a/basis/shuffle/shuffle.factor b/basis/shuffle/shuffle.factor
index 6cae048d2764290f7ca9371725068f0fd894f95e..d6a4ba8bbbfad58715825ca05269955eaeabad45 100644 (file)
--- a/basis/shuffle/shuffle.factor
+++ b/basis/shuffle/shuffle.factor
@@ -19,8 +19,8 @@ MACRO: shuffle-effect ( effect -- )
         [ [ at \ swap \ nth [ ] 3sequence ] curry map , \ cleave , ] 2bi
     ] [ ] make ;
 
-: shuffle(
-    ")" parse-effect parsed \ shuffle-effect parsed ; parsing
+SYNTAX: shuffle(
+    ")" parse-effect parsed \ shuffle-effect parsed ;
 
 : 2swap ( x y z t -- z t x y ) 2 2 mnswap ; inline
 

diff --git a/basis/specialized-arrays/functor/functor.factor b/basis/specialized-arrays/functor/functor.factor
index 09433a3b51c7181ba62475a501acb441c2e50223..c6641463f90fabcf7fa7ee1211633c5d3587bf4a 100644 (file)
--- a/basis/specialized-arrays/functor/functor.factor
+++ b/basis/specialized-arrays/functor/functor.factor
@@ -70,7 +70,7 @@ M: A >pprint-sequence ;
 
 M: A pprint* pprint-object ;
 
-: A{ \ } [ >A ] parse-literal ; parsing
+SYNTAX: A{ \ } [ >A ] parse-literal ;
 
 INSTANCE: A sequence
 

diff --git a/basis/specialized-vectors/functor/functor.factor b/basis/specialized-vectors/functor/functor.factor
index 9d48a9e79e4c85c576bb7af075458064b82dcbd6..412e5b468984a302b4e2705aeb901a5a1f9e04c8 100644 (file)
--- a/basis/specialized-vectors/functor/functor.factor
+++ b/basis/specialized-vectors/functor/functor.factor
@@ -39,7 +39,7 @@ M: V >pprint-sequence ;
 
 M: V pprint* pprint-object ;
 
-: V{ \ } [ >V ] parse-literal ; parsing
+SYNTAX: V{ \ } [ >V ] parse-literal ;
 
 INSTANCE: V growable
 

diff --git a/basis/suffix-arrays/suffix-arrays.factor b/basis/suffix-arrays/suffix-arrays.factor
index fa68cc0a8e0a1f63bb3be31d1f4e134ee650cdec..f4bd56348130f88a8b2a3c74ca7d13ef9892075d 100755 (executable)
--- a/basis/suffix-arrays/suffix-arrays.factor
+++ b/basis/suffix-arrays/suffix-arrays.factor
@@ -32,7 +32,7 @@ PRIVATE>
 : >suffix-array ( seq -- array )
     [ suffixes ] map concat natural-sort ;
 
-: SA{ \ } [ >suffix-array ] parse-literal ; parsing
+SYNTAX: SA{ \ } [ >suffix-array ] parse-literal ;
 
 : query ( begin suffix-array -- matches )
     2dup find-index dup

diff --git a/basis/tr/tr.factor b/basis/tr/tr.factor
index 66c0276055d460bc94242032f00289082e6f30b7..daac3c96c75035122abb8f9cb0b291f873c08484 100644 (file)
--- a/basis/tr/tr.factor
+++ b/basis/tr/tr.factor
@@ -40,10 +40,9 @@ M: bad-tr summary
 
 PRIVATE>
 
-: TR:
+SYNTAX: TR:
     scan parse-definition
     unclip-last [ unclip-last ] dip compute-tr
     [ check-tr ]
     [ [ create-tr ] dip define-tr ]
     [ [ "-fast" append create-tr ] dip define-fast-tr ] 2tri ;
-    parsing

diff --git a/basis/unicode/syntax/syntax.factor b/basis/unicode/syntax/syntax.factor
index 5bd8c05e153103658a6df5b25afdb10c49f503fa..dfae31d39cd9d818f20e78cff9a1a5ac0adb51af 100644 (file)
--- a/basis/unicode/syntax/syntax.factor
+++ b/basis/unicode/syntax/syntax.factor
@@ -27,12 +27,12 @@ IN: unicode.syntax
 
 PRIVATE>
 
-: CATEGORY:
-    CREATE ";" parse-tokens define-category ; parsing
+SYNTAX: CATEGORY:
+    CREATE ";" parse-tokens define-category ;
 
 : seq-minus ( seq1 seq2 -- diff )
     [ member? not ] curry filter ;
 
-: CATEGORY-NOT:
+SYNTAX: CATEGORY-NOT:
     CREATE ";" parse-tokens
-    categories swap seq-minus define-category ; parsing
+    categories swap seq-minus define-category ;

diff --git a/basis/urls/urls.factor b/basis/urls/urls.factor
index d71ce4ef7b992a3791f76975e8fe4edee36c67ba..38d0016d5658ab5d183ccfe32c668dcef38373ed 100644 (file)
--- a/basis/urls/urls.factor
+++ b/basis/urls/urls.factor
@@ -179,7 +179,7 @@ PRIVATE>
     dup protocol>> '[ _ protocol-port or ] change-port ;
 
 ! Literal syntax
-: URL" lexer get skip-blank parse-string >url parsed ; parsing
+SYNTAX: URL" lexer get skip-blank parse-string >url parsed ;
 
 USING: vocabs vocabs.loader ;
 

diff --git a/basis/values/values.factor b/basis/values/values.factor
index 75a37339b1797c60bcab6b6c8663b6dab74f5b8f..b15dcebe491ea0d76494815433a76c1651360e17 100644 (file)
--- a/basis/values/values.factor
+++ b/basis/values/values.factor
@@ -30,11 +30,11 @@ PREDICATE: value-word < word
         [ second \ obj>> = ]
     } 1&& ;
 
-: VALUE:
+SYNTAX: VALUE:
     CREATE-WORD
     dup t "no-def-strip" set-word-prop
     T{ value-holder } clone [ obj>> ] curry
-    (( -- value )) define-declared ; parsing
+    (( -- value )) define-declared ;
 
 M: value-word definer drop \ VALUE: f ;
 
@@ -43,9 +43,9 @@ M: value-word definition drop f ;
 : set-value ( value word -- )
     def>> first (>>obj) ;
 
-: to:
+SYNTAX: to:
     scan-word literalize parsed
-    \ set-value parsed ; parsing
+    \ set-value parsed ;
 
 : get-value ( word -- value )
     def>> first obj>> ;

diff --git a/basis/vlists/vlists.factor b/basis/vlists/vlists.factor
index e4f64ca8f80c42119c766b815d82d2b7e73ed0c4..ae106cbf93b9dfbb3ce2ada86972815320dfaac2 100644 (file)
--- a/basis/vlists/vlists.factor
+++ b/basis/vlists/vlists.factor
@@ -50,7 +50,7 @@ M: vlist like
 
 INSTANCE: vlist immutable-sequence
 
-: VL{ \ } [ >vlist ] parse-literal ; parsing
+SYNTAX: VL{ \ } [ >vlist ] parse-literal ;
 
 M: vlist pprint-delims drop \ VL{ \ } ;
 M: vlist >pprint-sequence ;
@@ -87,7 +87,7 @@ M: valist assoc-like
 
 INSTANCE: valist assoc
 
-: VA{ \ } [ >valist ] parse-literal ; parsing
+SYNTAX: VA{ \ } [ >valist ] parse-literal ;
 
 M: valist pprint-delims drop \ VA{ \ } ;
 M: valist >pprint-sequence >alist ;

diff --git a/basis/windows/com/syntax/syntax.factor b/basis/windows/com/syntax/syntax.factor
index 620b608afc6297a616240a3144e17a67f1b35133..59a76bf4d7df97a763d6f22af27a063eae6f4a0f 100755 (executable)
--- a/basis/windows/com/syntax/syntax.factor
+++ b/basis/windows/com/syntax/syntax.factor
@@ -90,14 +90,13 @@ unless
 
 PRIVATE>
 
-: COM-INTERFACE:
+SYNTAX: COM-INTERFACE:
     scan
     scan find-com-interface-definition
     scan string>guid
     parse-com-functions
     <com-interface-definition>
     dup save-com-interface-definition
-    define-words-for-com-interface
-    ; parsing
+    define-words-for-com-interface ;
 
-: GUID: scan string>guid parsed ; parsing
+SYNTAX: GUID: scan string>guid parsed ;

diff --git a/basis/xml/syntax/syntax.factor b/basis/xml/syntax/syntax.factor
index 067bb9ec1173756fca636c8bbf75524bf8f2fa64..0f23aafa6e67eb44e9f299db2793ea0c31459141 100644 (file)
--- a/basis/xml/syntax/syntax.factor
+++ b/basis/xml/syntax/syntax.factor
@@ -26,17 +26,17 @@ M: no-tag summary
 
 PRIVATE>
 
-: TAGS:
+SYNTAX: TAGS:
     CREATE
     [ H{ } clone "xtable" set-word-prop ]
-    [ define-tags ] bi ; parsing
+    [ define-tags ] bi ;
 
-: TAG:
-    scan scan-word parse-definition define-tag ; parsing
+SYNTAX: TAG:
+    scan scan-word parse-definition define-tag ;
 
-: XML-NS:
+SYNTAX: XML-NS:
     CREATE-WORD (( string -- name )) over set-stack-effect
-    scan '[ f swap _ <name> ] define-memoized ; parsing
+    scan '[ f swap _ <name> ] define-memoized ;
 
 <PRIVATE
 
@@ -168,11 +168,11 @@ MACRO: interpolate-xml ( xml -- quot )
 
 PRIVATE>
 
-: <XML
-    "XML>" [ string>doc ] parse-def ; parsing
+SYNTAX: <XML
+    "XML>" [ string>doc ] parse-def ;
 
-: [XML
-    "XML]" [ string>chunk ] parse-def ; parsing
+SYNTAX: [XML
+    "XML]" [ string>chunk ] parse-def ;
 
 <PRIVATE
 

diff --git a/basis/xmode/loader/syntax/syntax.factor b/basis/xmode/loader/syntax/syntax.factor
index 4cbf58c8aa62c59a244c631a72db353c5854e2a4..d2e1d997216dd73bb161607fabe8768509e8f052 100644 (file)
--- a/basis/xmode/loader/syntax/syntax.factor
+++ b/basis/xmode/loader/syntax/syntax.factor
@@ -10,11 +10,11 @@ IN: xmode.loader.syntax
 : (parse-rule-tag) ( rule-set tag specs class -- )
     new swap init-from-tag swap add-rule ; inline
 
-: RULE:
+SYNTAX: RULE:
     scan scan-word scan-word [
         [ parse-definition call( -- ) ] { } make
         swap [ (parse-rule-tag) ] 2curry
-    ] dip swap define-tag ; parsing
+    ] dip swap define-tag ;
 
 ! Attribute utilities
 : string>boolean ( string -- ? ) "TRUE" = ;

diff --git a/core/bootstrap/syntax.factor b/core/bootstrap/syntax.factor
index 1c97ee5a500cf482428bc25d74e0cd5fbc41b30d..6e6812e25c3ca3e1c098bc75bfc6f49530ed3489 100644 (file)
--- a/core/bootstrap/syntax.factor
+++ b/core/bootstrap/syntax.factor
@@ -57,6 +57,7 @@ IN: bootstrap.syntax
     "EXCLUDE:"
     "RENAME:"
     "ALIAS:"
+    "SYNTAX:"
     "V{"
     "W{"
     "["
@@ -68,7 +69,6 @@ IN: bootstrap.syntax
     "foldable"
     "inline"
     "recursive"
-    "parsing"
     "t"
     "{"
     "}"

diff --git a/core/parser/parser-docs.factor b/core/parser/parser-docs.factor
index 23bc41a1bb30f2b320d00be0877ee5760ca3938d..547f7c0490ebd3805c2ca5277eaa85b8be8245b7 100644 (file)
--- a/core/parser/parser-docs.factor
+++ b/core/parser/parser-docs.factor
@@ -54,8 +54,10 @@ $nl
 ARTICLE: "parsing-words" "Parsing words"
 "The Factor parser follows a simple recursive-descent design. The parser reads successive tokens from the input; if the token identifies a number or an ordinary word, it is added to an accumulator vector. Otherwise if the token identifies a parsing word, the parsing word is executed immediately."
 $nl
-"Parsing words are marked by suffixing the definition with a " { $link POSTPONE: parsing } " declaration. Here is the simplest possible parsing word; it prints a greeting at parse time:"
-{ $code ": hello \"Hello world\" print ; parsing" }
+"Parsing words are defined using the a defining word:"
+{ $subsection POSTPONE: SYNTAX: }
+"Parsing words have uppercase names by convention. Here is the simplest possible parsing word; it prints a greeting at parse time:"
+{ $code "SYNTAX: HELLO \"Hello world\" print ;" }
 "Parsing words must not pop or push items from the stack; however, they are permitted to access the accumulator vector supplied by the parser at the top of the stack. That is, parsing words must have stack effect " { $snippet "( accum -- accum )" } ", where " { $snippet "accum" } " is the accumulator vector supplied by the parser."
 $nl
 "Parsing words can read input, add word definitions to the dictionary, and do anything an ordinary word can."

diff --git a/core/parser/parser-tests.factor b/core/parser/parser-tests.factor
index adf1c8adcf84d377811804bb1f2a423b2ea5b8d8..2616e5fadb0132c1b6d3e7cfb3c22cb577c90e68 100644 (file)
--- a/core/parser/parser-tests.factor
+++ b/core/parser/parser-tests.factor
@@ -106,7 +106,7 @@ IN: parser.tests
     ] unit-test
     DEFER: foo
 
-    "IN: parser.tests USING: math prettyprint ; : foo 2 2 + . ; parsing" eval
+    "IN: parser.tests USING: math prettyprint ; SYNTAX: foo 2 2 + . ;" eval
 
     [ ] [ "USE: parser.tests foo" eval ] unit-test
 
@@ -487,7 +487,7 @@ IN: parser.tests
 [ "DEFER: blahy" eval ] [ error>> error>> no-current-vocab? ] must-fail-with
 
 [
-    "IN: parser.tests : blahy ; parsing FORGET: blahy" eval
+    "IN: parser.tests SYNTAX: blahy ; FORGET: blahy" eval
 ] [
     error>> staging-violation?
 ] must-fail-with

diff --git a/core/syntax/syntax-docs.factor b/core/syntax/syntax-docs.factor
index 1a61845fd183d50ce42f34f25cc0a43b03ab17cb..9609b4ffeeb98393153978142d8618db02de4489 100644 (file)
--- a/core/syntax/syntax-docs.factor
+++ b/core/syntax/syntax-docs.factor
@@ -177,10 +177,10 @@ HELP: delimiter
 { $syntax ": foo ... ; delimiter" }
 { $description "Declares the most recently defined word as a delimiter. Delimiters are words which are only ever valid as the end of a nested block to be read by " { $link parse-until } ". An unpaired occurrence of a delimiter is a parse error." } ;
 
-HELP: parsing
-{ $syntax ": foo ... ; parsing" }
-{ $description "Declares the most recently defined word as a parsing word." }
-{ $examples "In the below example, the " { $snippet "world" } " word is never called, however its body references a parsing word which executes immediately:" { $example "USE: io" "IN: scratchpad" "<< : hello \"Hello parser!\" print ; parsing >>\n: world hello ;" "Hello parser!" } } ;
+HELP: SYNTAX:
+{ $syntax "SYNTAX: foo ... ;" }
+{ $description "Defines a parsing word." }
+{ $examples "In the below example, the " { $snippet "world" } " word is never called, however its body references a parsing word which executes immediately:" { $example "USE: io" "IN: scratchpad" "<< SYNTAX: HELLO \"Hello parser!\" print ; >>\n: world HELLO ;" "Hello parser!" } } ;
 
 HELP: inline
 { $syntax ": foo ... ; inline" }

diff --git a/core/syntax/syntax.factor b/core/syntax/syntax.factor
index d01a9ebb2c2422ed64e1c38c29d3efd288abaead..47a45f6e4e38e5f9d4d03ab5a850abaa7e620f64 100644 (file)
--- a/core/syntax/syntax.factor
+++ b/core/syntax/syntax.factor
@@ -22,58 +22,58 @@ IN: bootstrap.syntax
 : define-delimiter ( name -- )
     "syntax" lookup t "delimiter" set-word-prop ;
 
-: define-syntax ( name quot -- )
-    [ dup "syntax" lookup [ dup ] [ no-word-error ] ?if ] dip
-    define make-parsing ;
+: define-core-syntax ( name quot -- )
+    [ dup "syntax" lookup [ ] [ no-word-error ] ?if ] dip
+    define-syntax ;
 
 [
     { "]" "}" ";" ">>" } [ define-delimiter ] each
 
     "PRIMITIVE:" [
         "Primitive definition is not supported" throw
-    ] define-syntax
+    ] define-core-syntax
 
     "CS{" [
         "Call stack literals are not supported" throw
-    ] define-syntax
+    ] define-core-syntax
 
-    "!" [ lexer get next-line ] define-syntax
+    "!" [ lexer get next-line ] define-core-syntax
 
-    "#!" [ POSTPONE: ! ] define-syntax
+    "#!" [ POSTPONE: ! ] define-core-syntax
 
-    "IN:" [ scan set-in ] define-syntax
+    "IN:" [ scan set-in ] define-core-syntax
 
-    "PRIVATE>" [ in get ".private" ?tail drop set-in ] define-syntax
+    "PRIVATE>" [ in get ".private" ?tail drop set-in ] define-core-syntax
 
     "<PRIVATE" [
         POSTPONE: PRIVATE> in get ".private" append set-in
-    ] define-syntax
+    ] define-core-syntax
 
-    "USE:" [ scan use+ ] define-syntax
+    "USE:" [ scan use+ ] define-core-syntax
 
-    "USING:" [ ";" parse-tokens add-use ] define-syntax
+    "USING:" [ ";" parse-tokens add-use ] define-core-syntax
 
-    "QUALIFIED:" [ scan dup add-qualified ] define-syntax
+    "QUALIFIED:" [ scan dup add-qualified ] define-core-syntax
 
-    "QUALIFIED-WITH:" [ scan scan add-qualified ] define-syntax
+    "QUALIFIED-WITH:" [ scan scan add-qualified ] define-core-syntax
 
     "FROM:" [
         scan "=>" expect ";" parse-tokens swap add-words-from
-    ] define-syntax
+    ] define-core-syntax
 
     "EXCLUDE:" [
         scan "=>" expect ";" parse-tokens swap add-words-excluding
-    ] define-syntax
+    ] define-core-syntax
 
     "RENAME:" [
         scan scan "=>" expect scan add-renamed-word
-    ] define-syntax
+    ] define-core-syntax
 
-    "HEX:" [ 16 parse-base ] define-syntax
-    "OCT:" [ 8 parse-base ] define-syntax
-    "BIN:" [ 2 parse-base ] define-syntax
+    "HEX:" [ 16 parse-base ] define-core-syntax
+    "OCT:" [ 8 parse-base ] define-core-syntax
+    "BIN:" [ 2 parse-base ] define-core-syntax
 
-    "f" [ f parsed ] define-syntax
+    "f" [ f parsed ] define-core-syntax
     "t" "syntax" lookup define-singleton-class
 
     "CHAR:" [
@@ -82,157 +82,160 @@ IN: bootstrap.syntax
             { [ "\\" ?head ] [ next-escape >string "" assert= ] }
             [ name>char-hook get call( name -- char ) ]
         } cond parsed
-    ] define-syntax
+    ] define-core-syntax
 
-    "\"" [ parse-string parsed ] define-syntax
+    "\"" [ parse-string parsed ] define-core-syntax
 
     "SBUF\"" [
         lexer get skip-blank parse-string >sbuf parsed
-    ] define-syntax
+    ] define-core-syntax
 
     "P\"" [
         lexer get skip-blank parse-string <pathname> parsed
-    ] define-syntax
-
-    "[" [ parse-quotation parsed ] define-syntax
-    "{" [ \ } [ >array ] parse-literal ] define-syntax
-    "V{" [ \ } [ >vector ] parse-literal ] define-syntax
-    "B{" [ \ } [ >byte-array ] parse-literal ] define-syntax
-    "H{" [ \ } [ >hashtable ] parse-literal ] define-syntax
-    "T{" [ parse-tuple-literal parsed ] define-syntax
-    "W{" [ \ } [ first <wrapper> ] parse-literal ] define-syntax
-
-    "POSTPONE:" [ scan-word parsed ] define-syntax
-    "\\" [ scan-word <wrapper> parsed ] define-syntax
-    "inline" [ word make-inline ] define-syntax
-    "recursive" [ word make-recursive ] define-syntax
-    "foldable" [ word make-foldable ] define-syntax
-    "flushable" [ word make-flushable ] define-syntax
-    "delimiter" [ word t "delimiter" set-word-prop ] define-syntax
-    "parsing" [ word make-parsing ] define-syntax
+    ] define-core-syntax
+
+    "[" [ parse-quotation parsed ] define-core-syntax
+    "{" [ \ } [ >array ] parse-literal ] define-core-syntax
+    "V{" [ \ } [ >vector ] parse-literal ] define-core-syntax
+    "B{" [ \ } [ >byte-array ] parse-literal ] define-core-syntax
+    "H{" [ \ } [ >hashtable ] parse-literal ] define-core-syntax
+    "T{" [ parse-tuple-literal parsed ] define-core-syntax
+    "W{" [ \ } [ first <wrapper> ] parse-literal ] define-core-syntax
+
+    "POSTPONE:" [ scan-word parsed ] define-core-syntax
+    "\\" [ scan-word <wrapper> parsed ] define-core-syntax
+    "inline" [ word make-inline ] define-core-syntax
+    "recursive" [ word make-recursive ] define-core-syntax
+    "foldable" [ word make-foldable ] define-core-syntax
+    "flushable" [ word make-flushable ] define-core-syntax
+    "delimiter" [ word t "delimiter" set-word-prop ] define-core-syntax
+
+    "SYNTAX:" [
+        (:) define-syntax
+    ] define-core-syntax
 
     "SYMBOL:" [
         CREATE-WORD define-symbol
-    ] define-syntax
+    ] define-core-syntax
 
     "SYMBOLS:" [
         ";" parse-tokens
         [ create-in dup reset-generic define-symbol ] each
-    ] define-syntax
+    ] define-core-syntax
 
     "SINGLETONS:" [
         ";" parse-tokens
         [ create-class-in define-singleton-class ] each
-    ] define-syntax
+    ] define-core-syntax
     
     "ALIAS:" [
         CREATE-WORD scan-word define-alias
-    ] define-syntax
+    ] define-core-syntax
 
     "CONSTANT:" [
         CREATE scan-object define-constant
-    ] define-syntax
+    ] define-core-syntax
 
     "DEFER:" [
         scan current-vocab create
         [ fake-definition ] [ set-word ] [ [ undefined ] define ] tri
-    ] define-syntax
+    ] define-core-syntax
 
     ":" [
         (:) define
-    ] define-syntax
+    ] define-core-syntax
 
     "GENERIC:" [
         CREATE-GENERIC define-simple-generic
-    ] define-syntax
+    ] define-core-syntax
 
     "GENERIC#" [
         CREATE-GENERIC
         scan-word <standard-combination> define-generic
-    ] define-syntax
+    ] define-core-syntax
 
     "MATH:" [
         CREATE-GENERIC
         T{ math-combination } define-generic
-    ] define-syntax
+    ] define-core-syntax
 
     "HOOK:" [
         CREATE-GENERIC scan-word
         <hook-combination> define-generic
-    ] define-syntax
+    ] define-core-syntax
 
     "M:" [
         (M:) define
-    ] define-syntax
+    ] define-core-syntax
 
     "UNION:" [
         CREATE-CLASS parse-definition define-union-class
-    ] define-syntax
+    ] define-core-syntax
 
     "INTERSECTION:" [
         CREATE-CLASS parse-definition define-intersection-class
-    ] define-syntax
+    ] define-core-syntax
 
     "MIXIN:" [
         CREATE-CLASS define-mixin-class
-    ] define-syntax
+    ] define-core-syntax
 
     "INSTANCE:" [
         location [
             scan-word scan-word 2dup add-mixin-instance
             <mixin-instance>
         ] dip remember-definition
-    ] define-syntax
+    ] define-core-syntax
 
     "PREDICATE:" [
         CREATE-CLASS
         scan "<" assert=
         scan-word
         parse-definition define-predicate-class
-    ] define-syntax
+    ] define-core-syntax
 
     "SINGLETON:" [
         CREATE-CLASS define-singleton-class
-    ] define-syntax
+    ] define-core-syntax
 
     "TUPLE:" [
         parse-tuple-definition define-tuple-class
-    ] define-syntax
+    ] define-core-syntax
 
     "SLOT:" [
         scan define-protocol-slot
-    ] define-syntax
+    ] define-core-syntax
 
     "C:" [
         CREATE-WORD scan-word define-boa-word
-    ] define-syntax
+    ] define-core-syntax
 
     "ERROR:" [
         parse-tuple-definition
         pick save-location
         define-error-class
-    ] define-syntax
+    ] define-core-syntax
 
     "FORGET:" [
         scan-object forget
-    ] define-syntax
+    ] define-core-syntax
 
     "(" [
         ")" parse-effect
         word dup [ set-stack-effect ] [ 2drop ] if
-    ] define-syntax
+    ] define-core-syntax
 
     "((" [
         "))" parse-effect parsed
-    ] define-syntax
+    ] define-core-syntax
 
-    "MAIN:" [ scan-word in get vocab (>>main) ] define-syntax
+    "MAIN:" [ scan-word in get vocab (>>main) ] define-core-syntax
 
     "<<" [
         [
             \ >> parse-until >quotation
         ] with-nested-compilation-unit call( -- )
-    ] define-syntax
+    ] define-core-syntax
 
     "call-next-method" [
         current-method get [
@@ -241,13 +244,13 @@ IN: bootstrap.syntax
         ] [
             not-in-a-method-error
         ] if*
-    ] define-syntax
+    ] define-core-syntax
     
     "initial:" "syntax" lookup define-symbol
     
     "read-only" "syntax" lookup define-symbol
 
-    "call(" [ \ call-effect parse-call( ] define-syntax
+    "call(" [ \ call-effect parse-call( ] define-core-syntax
 
-    "execute(" [ \ execute-effect parse-call( ] define-syntax
+    "execute(" [ \ execute-effect parse-call( ] define-core-syntax
 ] with-compilation-unit

diff --git a/core/words/words-docs.factor b/core/words/words-docs.factor
index 9c32a8094e8340dddc53261e5cb46a5e81f0edf3..63b58bf9d519201d07f6f506224f15c955592271 100644 (file)
--- a/core/words/words-docs.factor
+++ b/core/words/words-docs.factor
@@ -57,16 +57,12 @@ $nl
 } ;
 
 ARTICLE: "declarations" "Declarations"
-"Declarations give special behavior to a word. Declarations are parsing words that set a word property in the most recently defined word."
-$nl
-"The first declaration specifies the time when a word runs. It affects both the non-optimizing and optimizing compilers:"
-{ $subsection POSTPONE: parsing }
-"The remaining declarations only affect definitions compiled with the optimizing compiler. They do not change evaluation semantics of a word, but instead declare that the word follows a certain contract, and thus may be compiled differently."
-{ $warning "If a generic word is declared " { $link POSTPONE: foldable } " or " { $link POSTPONE: flushable } ", all methods must satisfy the contract, otherwise unpredicable behavior will occur." }
+"Declarations are parsing words that set a word property in the most recently defined word. Declarations only affect definitions compiled with the optimizing compiler. They do not change evaluation semantics of a word, but instead declare that the word follows a certain contract, and thus may be compiled differently."
 { $subsection POSTPONE: inline }
 { $subsection POSTPONE: foldable }
 { $subsection POSTPONE: flushable }
 { $subsection POSTPONE: recursive }
+{ $warning "If a generic word is declared " { $link POSTPONE: foldable } " or " { $link POSTPONE: flushable } ", all methods must satisfy the contract, otherwise unpredicable behavior will occur." }
 "Stack effect declarations are documented in " { $link "effect-declaration" } "." ;
 
 ARTICLE: "word-definition" "Defining words"
@@ -279,7 +275,7 @@ HELP: bootstrap-word
 
 HELP: parsing-word? ( obj -- ? )
 { $values { "obj" object } { "?" "a boolean" } }
-{ $description "Tests if an object is a parsing word declared by " { $link POSTPONE: parsing } "." }
+{ $description "Tests if an object is a parsing word declared by " { $link POSTPONE: SYNTAX: } "." }
 { $notes "Outputs " { $link f } " if the object is not a word." } ;
 
 HELP: define-declared

diff --git a/core/words/words.factor b/core/words/words.factor
index c4a94f0a4cfae8ea4d50e91759141a7ceeeb6618..c255c00eaee94a09c97a6155525c2b4c35ec4d1c 100755 (executable)
--- a/core/words/words.factor
+++ b/core/words/words.factor
@@ -232,7 +232,10 @@ ERROR: bad-create name vocab ;
 
 PREDICATE: parsing-word < word "parsing" word-prop ;
 
-: make-parsing ( word -- ) t "parsing" set-word-prop ;
+M: parsing-word definer drop \ SYNTAX: \ ; ;
+
+: define-syntax ( word quot -- )
+    [ drop ] [ define ] 2bi t "parsing" set-word-prop ;
 
 : delimiter? ( obj -- ? )
     dup word? [ "delimiter" word-prop ] [ drop f ] if ;

diff --git a/extra/advice/advice.factor b/extra/advice/advice.factor
index be9835c5b9bec8d819800750356089defc51dcae..9c0963469e42bbeabf6eb87a0102a0a50019542b 100644 (file)
--- a/extra/advice/advice.factor
+++ b/extra/advice/advice.factor
@@ -56,8 +56,8 @@ PRIVATE>
 : unadvise ( word --  )
     [ reset ] [ { before after around advised } [ f swap set-word-prop ] with each ] bi ;
 
-: ADVISE: ! word adname location => word adname quot loc
-    scan-word scan scan-word parse-definition swap [ spin ] dip advise ; parsing
+SYNTAX: ADVISE: ! word adname location => word adname quot loc
+    scan-word scan scan-word parse-definition swap [ spin ] dip advise ;
     
-: UNADVISE:    
-    scan-word parsed \ unadvise parsed ; parsing
\ No newline at end of file
+SYNTAX: UNADVISE:    
+    scan-word parsed \ unadvise parsed ;
\ No newline at end of file

diff --git a/extra/annotations/annotations.factor b/extra/annotations/annotations.factor
index b3eccad6a32d4d33c65ddd4b0912318811224871..387c73abe4807e0f2eb4ede82d245b91f4bf4ecf 100644 (file)
--- a/extra/annotations/annotations.factor
+++ b/extra/annotations/annotations.factor
@@ -24,7 +24,7 @@ NAMEs. DEFINES ${NAME}s.
 WHERE
 
 : (NAME) ( str -- ) drop ; inline
-: !NAME (parse-annotation) \ (NAME) parsed ; parsing
+SYNTAX: !NAME (parse-annotation) \ (NAME) parsed ;
 
 : NAMEs ( -- usages )
     \ (NAME) (non-annotation-usage) ;

diff --git a/extra/descriptive/descriptive.factor b/extra/descriptive/descriptive.factor
index dd0042455cc3d66e6ce6fefc0a94ca7a2afc574e..ed412ee445088e35f0eac8100460f4c811e5a14d 100755 (executable)
--- a/extra/descriptive/descriptive.factor
+++ b/extra/descriptive/descriptive.factor
@@ -23,8 +23,7 @@ PRIVATE>
     [ "descriptive-definition" set-word-prop ]\r
     [ dupd [descriptive] define ] 2bi ;\r
 \r
-: DESCRIPTIVE:\r
-    (:) define-descriptive ; parsing\r
+SYNTAX: DESCRIPTIVE: (:) define-descriptive ;\r
 \r
 PREDICATE: descriptive < word\r
     "descriptive-definition" word-prop ;\r
@@ -34,8 +33,7 @@ M: descriptive definer drop \ DESCRIPTIVE: \ ; ;
 M: descriptive definition\r
     "descriptive-definition" word-prop ;\r
 \r
-: DESCRIPTIVE::\r
-    (::) define-descriptive ; parsing\r
+SYNTAX: DESCRIPTIVE:: (::) define-descriptive ;\r
 \r
 INTERSECTION: descriptive-lambda descriptive lambda-word ;\r
 \r

diff --git a/extra/infix/infix.factor b/extra/infix/infix.factor
index 87080683b2c4e773ca27b2dff05531f88656a7d6..ed268e558daaee26b47325b1ef03b13c6672861b 100644 (file)
--- a/extra/infix/infix.factor
+++ b/extra/infix/infix.factor
@@ -81,8 +81,8 @@ M: ast-function infix-codegen
     infix-codegen prepare-operand ;
 PRIVATE>
 
-: [infix
-    "infix]" [infix-parse parsed \ call parsed ; parsing
+SYNTAX: [infix
+    "infix]" [infix-parse parsed \ call parsed ;
 
 <PRIVATE
 : parse-infix-locals ( assoc end -- quot )
@@ -93,6 +93,6 @@ PRIVATE>
     ] with-scope ;
 PRIVATE>
 
-: [infix|
+SYNTAX: [infix|
     "|" parse-bindings "infix]" parse-infix-locals <let>
-    ?rewrite-closures over push-all ; parsing
+    ?rewrite-closures over push-all ;

diff --git a/extra/literals/literals.factor b/extra/literals/literals.factor
index 6bff666f072c0672a19e6810ca644adc4e288989..e55d78ab6ef183781192d04f69da15f90b4ded77 100644 (file)
--- a/extra/literals/literals.factor
+++ b/extra/literals/literals.factor
@@ -2,5 +2,5 @@
 USING: accessors continuations kernel parser words quotations vectors ;
 IN: literals
 
-: $ scan-word [ def>> call ] curry with-datastack >vector ; parsing
-: $[ parse-quotation with-datastack >vector ; parsing
+SYNTAX: $ scan-word [ def>> call ] curry with-datastack >vector ;
+SYNTAX: $[ parse-quotation with-datastack >vector ;

diff --git a/extra/math/derivatives/syntax/syntax.factor b/extra/math/derivatives/syntax/syntax.factor
index 02b0608ed817251e1632abbd93cb8fdd26b4056a..1dadfd18c83c65182a8a7ce9c1b100a4732b3ce1 100644 (file)
--- a/extra/math/derivatives/syntax/syntax.factor
+++ b/extra/math/derivatives/syntax/syntax.factor
@@ -5,6 +5,6 @@ USING: kernel parser words effects accessors sequences
     
 IN: math.derivatives.syntax
 
-: DERIVATIVE: scan-object dup stack-effect in>> length [1,b] 
+SYNTAX: DERIVATIVE: scan-object dup stack-effect in>> length [1,b] 
     [ drop scan-object ] map 
-    "derivative" set-word-prop ; parsing
\ No newline at end of file
+    "derivative" set-word-prop ;
\ No newline at end of file

diff --git a/extra/method-chains/method-chains.factor b/extra/method-chains/method-chains.factor
index ae1801a8b590188670553356c6196878ac8aa4e9..5d243118981d822fd95050a110c66bcf6f61484f 100644 (file)
--- a/extra/method-chains/method-chains.factor
+++ b/extra/method-chains/method-chains.factor
@@ -3,5 +3,5 @@
 USING: kernel generic generic.parser words fry ;
 IN: method-chains
 
-: AFTER: (M:) dupd '[ [ _ (call-next-method) ] _ bi ] define ; parsing
-: BEFORE: (M:) over '[ _ [ _ (call-next-method) ] bi ] define ; parsing
+SYNTAX: AFTER: (M:) dupd '[ [ _ (call-next-method) ] _ bi ] define ;
+SYNTAX: BEFORE: (M:) over '[ _ [ _ (call-next-method) ] bi ] define ;

diff --git a/extra/money/money.factor b/extra/money/money.factor
index 1b9dee74b7ec6e9d7d6c513e02888bbaaf29304d..994d2143355c5925e2c583b855625ac325215d14 100644 (file)
--- a/extra/money/money.factor
+++ b/extra/money/money.factor
@@ -30,5 +30,4 @@ ERROR: not-an-integer x ;
     ] keep length
     10 swap ^ / + swap [ neg ] when ;
 
-: DECIMAL:
-    scan parse-decimal parsed ; parsing
+SYNTAX: DECIMAL: scan parse-decimal parsed ;

diff --git a/extra/peg-lexer/peg-lexer.factor b/extra/peg-lexer/peg-lexer.factor
index d48d67cfd40c6ef9239ca38cb408d6d6ed57672c..1b5f17df4c7abbacca362feef92a911455059b1e 100644 (file)
--- a/extra/peg-lexer/peg-lexer.factor
+++ b/extra/peg-lexer/peg-lexer.factor
@@ -40,8 +40,9 @@ M: lex-hash at* swap {
 : create-bnf ( name parser -- ) reset-tokenizer [ lexer get skip-blank parse* parsed ] curry
     define word make-parsing ;
     
-: ON-BNF: CREATE-WORD reset-tokenizer ";ON-BNF" parse-multiline-string parse-ebnf
-    main swap at create-bnf ; parsing
+SYNTAX: ON-BNF:
+    CREATE-WORD reset-tokenizer ";ON-BNF" parse-multiline-string parse-ebnf
+    main swap at create-bnf ;
 
 ! Tokenizer like standard factor lexer
 EBNF: factor

diff --git a/extra/project-euler/common/common.factor b/extra/project-euler/common/common.factor
index bd50f817b6dd8b5296aa081b38b45d3ab364ee2e..423512465eda8cf7d1d0fa312411c046f6c8db84 100644 (file)
--- a/extra/project-euler/common/common.factor
+++ b/extra/project-euler/common/common.factor
@@ -128,10 +128,10 @@ PRIVATE>
 : d-transform ( triple -- new-triple )
     { { -1 -2 -2 } { 2 1 2 } { 2 2 3 } } transform ;
 
-: SOLUTION:
+SYNTAX: SOLUTION:
     scan-word
     [ name>> "-main" append create-in ] keep
     [ drop in get vocab (>>main) ]
     [ [ . ] swap prefix (( -- )) define-declared ]
-    2bi ; parsing
+    2bi ;
 

diff --git a/extra/promises/promises.factor b/extra/promises/promises.factor
index 0e193741ebba35be1f1e7cad179dd691062fe385..60b4418c3f36de6394a7ce290eece9eb983f025e 100755 (executable)
--- a/extra/promises/promises.factor
+++ b/extra/promises/promises.factor
@@ -35,7 +35,7 @@ TUPLE: promise quot forced? value ;
     \ promise ,
   ] [ ] make ;
 
-: LAZY:
+SYNTAX: LAZY:
   CREATE-WORD
   dup parse-definition
-  make-lazy-quot define ; parsing
+  make-lazy-quot define ;

diff --git a/extra/slides/slides.factor b/extra/slides/slides.factor
index c7a27f87a486d46040dccbd9230359d3d53ec05b..29367a2b2bfd8a9382196da075073c38a8fcb571 100755 (executable)
--- a/extra/slides/slides.factor
+++ b/extra/slides/slides.factor
@@ -94,8 +94,8 @@ TUPLE: slides < book ;
         2 + (strip-tease)
     ] with map ;
 
-: STRIP-TEASE:
-    parse-definition strip-tease [ parsed ] each ; parsing
+SYNTAX: STRIP-TEASE:
+    parse-definition strip-tease [ parsed ] each ;
 
 \ slides H{
     { T{ button-down } [ request-focus ] }

diff --git a/extra/trees/avl/avl.factor b/extra/trees/avl/avl.factor
index 264db53a9eb8dfdf140cfd13384133a22bdbc364..04c7022077c0c4bb0914c5ded36c66e595b7e935 100755 (executable)
--- a/extra/trees/avl/avl.factor
+++ b/extra/trees/avl/avl.factor
@@ -152,7 +152,7 @@ M: avl new-assoc 2drop <avl> ;
 M: avl assoc-like
     drop dup avl? [ >avl ] unless ;
 
-: AVL{
-    \ } [ >avl ] parse-literal ; parsing
+SYNTAX: AVL{
+    \ } [ >avl ] parse-literal ;
 
 M: avl pprint-delims drop \ AVL{ \ } ;

diff --git a/extra/trees/splay/splay.factor b/extra/trees/splay/splay.factor
index c47b6b5d07345e0b15ac43927f60d6a837137c37..66ef154b63c726faf70f6e5bc586ecda2026e108 100755 (executable)
--- a/extra/trees/splay/splay.factor
+++ b/extra/trees/splay/splay.factor
@@ -131,8 +131,8 @@ M: splay new-assoc
 : >splay ( assoc -- tree )
     T{ splay f f 0 } assoc-clone-like ;
 
-: SPLAY{
-    \ } [ >splay ] parse-literal ; parsing
+SYNTAX: SPLAY{
+    \ } [ >splay ] parse-literal ;
 
 M: splay assoc-like
     drop dup splay? [ >splay ] unless ;

diff --git a/extra/trees/trees.factor b/extra/trees/trees.factor
index 41a8a21c1d9769e716a38ccc388bae48f429ca0a..4efea6ae427944efe9b40b90a9236ee549ec3e84 100755 (executable)
--- a/extra/trees/trees.factor
+++ b/extra/trees/trees.factor
@@ -198,8 +198,8 @@ M: tree clone dup assoc-clone-like ;
 
 M: tree assoc-like drop dup tree? [ >tree ] unless ;
 
-: TREE{
-    \ } [ >tree ] parse-literal ; parsing
+SYNTAX: TREE{
+    \ } [ >tree ] parse-literal ;
                                                         
 M: tree assoc-size count>> ;
 M: tree pprint-delims drop \ TREE{ \ } ;

diff --git a/extra/vars/vars.factor b/extra/vars/vars.factor
index c12367ba5ea35a82952aea6e68f9e3173d5c25b7..21c9b303f304946512cc5c85b8f6e342631667b1 100644 (file)
--- a/extra/vars/vars.factor
+++ b/extra/vars/vars.factor
@@ -21,11 +21,11 @@ IN: vars
     [ define-var-getter ]
     [ define-var-setter ] tri ;
 
-: VAR: ! var
-    scan define-var ; parsing
+SYNTAX: VAR: ! var
+    scan define-var ;
 
 : define-vars ( seq -- )
     [ define-var ] each ;
 
-: VARS: ! vars ...
-    ";" parse-tokens define-vars ; parsing
+SYNTAX: VARS: ! vars ...
+    ";" parse-tokens define-vars ;