long_str_char = str_char | cr | lf;
+// because no substraction in sablecc3, complex long strings are difficult to express
+ls1 = '"' '"'? ;
+ls2 = '{' '{'? ;
+ls12 = ls1? (ls2 ls1)* ls2?;
+
long_str_part
- = long_str_char
- | '"' long_str_char
- | '"' '"' long_str_char
- | '{' long_str_char
- | '{' '{' long_str_char
+ = ls12 long_str_char
;
long_str_body = long_str_part*;
+lsend1 = ls2? (ls1 ls2)* '"""' '"'*;
+lsend2 = ls1? (ls2 ls1)* '{{{' '{'*;
long_sstr_char = sstr_char | cr | lf;
long_sstr_part
number = digit+;
float = digit* '.' digit+;
-string = '"' str_body '"' | '"' '"' '"' long_str_body '"' '"' '"' | ''' ''' ''' long_sstr_body ''' ''' ''';
-start_string = '"' str_body '{' | '"' '"' '"' long_str_body '{' '{' '{';
-mid_string = '}' str_body '{' | '}' '}' '}' long_str_body '{' '{' '{';
-end_string = '}' str_body '"' | '}' '}' '}' long_str_body '"' '"' '"';
+string = '"' str_body '"' | '"' '"' '"' long_str_body lsend1 | ''' ''' ''' long_sstr_body ''' ''' ''';
+start_string = '"' str_body '{' | '"' '"' '"' long_str_body lsend2;
+mid_string = '}' str_body '{' | '}' '}' '}' long_str_body lsend2;
+end_string = '}' str_body '"' | '}' '}' '}' long_str_body lsend1;
char = (''' [[any - '''] - '\'] ''') | (''' '\' any ''');
bad_string = ('"'|'}') str_body | '"' '"' '"' long_str_body | ''' ''' ''' long_sstr_body;
bad_char = ''' '\'? any;
!toplevel| {var} [doc]:no readable? writable? redef visibility kwvar attrid typing? {-> New propdef.attr(doc.doc, readable.able, writable.able, redef.kwredef, visibility, kwvar, attrid, Null, typing.type, Null, Null)}
!toplevel| {var2} [doc]:no readable? writable? redef visibility kwvar attrid typing? assign [n2]:no expr {-> New propdef.attr(doc.doc, readable.able, writable.able, redef.kwredef, visibility, kwvar, attrid, Null, typing.type, Null, expr)}
!toplevel| {var3} [doc]:no redef visibility kwvar id typing? writable2? annotation_withend? {-> New propdef.attr(doc.doc, Null, writable2.able, redef.kwredef, visibility, kwvar, Null, id, typing.type, annotation_withend.annotations, Null)}
-!toplevel| {var4} [doc]:no redef visibility kwvar id typing? writable2? assign [n2]:no expr_nois annotation_withend? {-> New propdef.attr(doc.doc, Null, writable2.able, redef.kwredef, visibility, kwvar, Null, id, typing.type, annotation_withend.annotations, expr_nois.expr)}
+!toplevel| {var4} [doc]:no redef visibility kwvar id typing? writable2? assign [n2]:no expr annotation_withend? {-> New propdef.attr(doc.doc, Null, writable2.able, redef.kwredef, visibility, kwvar, Null, id, typing.type, annotation_withend.annotations, expr.expr)}
!toplevel| {init} [doc]:no redef visibility kwinit methid? signature annotation_noend? kwdo stmtso kwend? {-> New propdef.concrete_init(doc.doc, redef.kwredef, visibility, kwinit, methid, signature, annotation_noend.annotations, stmtso.expr)}
!toplevel| {type} [doc]:no redef visibility kwtype classid typing annotation_withend? {-> New propdef.type(doc.doc, redef.kwredef, visibility, kwtype, classid, typing.type, annotation_withend.annotations)}
!toplevel| {extern_init} [doc]:no redef visibility kwnew methid? signature kwis kwextern string? extern_calls? extern_code_block? {-> New propdef.extern_init(doc.doc, redef.kwredef, visibility, kwnew, methid, signature, string, extern_calls, extern_code_block)}
;
signature~withret {-> signature}
- = opar no params? cpar typing [no2]:no closure_decls? {-> New signature(opar, [params.param], cpar, typing.type, [closure_decls.closure_decl])}
-!withret| {noret} opar no params? cpar [no2]:no closure_decls? {-> New signature(opar, [params.param], cpar, Null, [closure_decls.closure_decl])}
- | {nopar} typing no closure_decls? {-> New signature(Null, [], Null, typing.type, [closure_decls.closure_decl])}
-!withret| {noparnoret} no closure_decls? {-> New signature(Null, [], Null, Null, [closure_decls.closure_decl])}
- ;
-
-signature_noclosures {-> signature}
- = opar no params? cpar typing? {-> New signature(opar, [params.param], cpar, typing.type, [])}
- | {nopar} typing? {-> New signature(Null, [], Null, typing.type, [])}
+ = opar no params? cpar typing [no2]:no {-> New signature(opar, [params.param], cpar, typing.type)}
+!withret| {noret} opar no params? cpar [no2]:no {-> New signature(opar, [params.param], cpar, Null)}
+ | {nopar} typing no {-> New signature(Null, [], Null, typing.type)}
+!withret| {noparnoret} no {-> New signature(Null, [], Null, Null)}
;
params {-> param*}
| id annotations? typing dotdotdot? {-> New param(id, typing.type, dotdotdot, annotations)}
;
-closure_decls {->closure_decl*}
- = closure_decl+ {-> [closure_decl]};
-closure_decl
- = kwbreak? bang id signature_noclosures n {-> New closure_decl(kwbreak, bang, id, signature_noclosures.signature, Null)}
- | {optionnal} kwbreak? bang id signature_noclosures kwdo stmtso n {-> New closure_decl(kwbreak, bang, id, signature_noclosures.signature, stmtso.expr)}
- | {assign} kwbreak? bang id signature_noclosures assign no assign_continue n {-> New closure_decl(kwbreak, bang, id, signature_noclosures.signature, assign_continue.expr)}
- ;
-
assign_return{-> expr}
= expr_final {-> New expr.return(Null, expr_final.expr)}
;
;
extern_call_prop {-> extern_call}
= {local} methid {-> New extern_call.local_prop( methid )}
- | {full} classid quad methid {-> New extern_call.full_prop( classid, quad, methid )}
- | {init} classid {-> New extern_call.init_prop( classid )}
+ | {full} type quad methid {-> New extern_call.full_prop( type, Null, methid )}
+ | {full2} type dot methid {-> New extern_call.full_prop( type, dot, methid )}
+ | {init} type {-> New extern_call.init_prop( type )}
;
extern_call_cast {-> extern_call}
- = {as_cast} [from_type]:type kwas [n2]:no opar [n3]:no [to_type]:type [n4]:no cpar {-> New extern_call.cast_as(from_type, kwas, to_type)}
- | {as_nullable} type kwas [n2]:no kwnullable {-> New extern_call.as_nullable( type, kwas, kwnullable)}
- | {as_not_nullable} type kwas [n2]:no kwnot [n3]:no kwnullable {-> New extern_call.as_not_nullable( type, kwas, kwnot, kwnullable)}
+ = {as_cast} [from_type]:type dot? kwas [n2]:no opar [n3]:no [to_type]:type [n4]:no cpar {-> New extern_call.cast_as(from_type, dot, kwas, to_type)}
+ | {as_nullable} type dot? kwas [n2]:no kwnullable {-> New extern_call.as_nullable( type, kwas, kwnullable)}
+ | {as_not_nullable} type dot? kwas [n2]:no kwnot [n3]:no kwnullable {-> New extern_call.as_not_nullable( type, kwas, kwnot, kwnullable)}
;
in_language = kwin string;
| {loop} loop~withelse {-> loop~withelse.expr}
| {for} for~withelse {-> for~withelse.expr}
| {assert} assert~withelse {-> assert~withelse.expr}
-!noexpr | {call} recv qualified? id args_nopar closure_defs~withelse? {-> New expr.call(recv.expr, id, args_nopar.exprs, [closure_defs~withelse.closure_def])}
+!noexpr | {call} recv qualified? id args_nopar {-> New expr.call(recv.expr, id, args_nopar.exprs)}
!noexpr | {super} qualified? kwsuper args_nopar {-> New expr.super(qualified, kwsuper, args_nopar.exprs)}
!noexpr | {init} recv qualified? kwinit args_nopar {-> New expr.init(recv.expr, kwinit, args_nopar.exprs)}
| {debug_type_is} kwdebug kwtype type column expr_final~withelse {-> New expr.debug_type(kwdebug, kwtype, expr_final~withelse.expr, type) }
label= kwlabel id;
-closure_defs~withelse {-> closure_def*}
- = {one} closure_def_last~withelse {-> [closure_def_last~withelse.closure_def]}
- | closure_def closure_defs~withelse {-> [closure_def, closure_defs~withelse.closure_def]}
- ;
-
-closure_def_last~withelse {-> closure_def}
- = bang [id]:closure_id idlist? kwdo stmtso_withend label {-> New closure_def(bang, id, [idlist.id], kwdo, stmtso_withend.expr, label)}
- | {nolabel} bang [id]:closure_id idlist? kwdo stmtso~withelse {-> New closure_def(bang, id, [idlist.id], kwdo, stmtso~withelse.expr, Null)}
- | {assign} bang [id]:closure_id idlist? assign no assign_continue~withelse {-> New closure_def(bang, id, [idlist.id], Null, assign_continue~withelse.expr, Null)}
- ;
-
-closure_def {-> closure_def}
- = bang [id]:closure_id idlist? kwdo n stmtsn {-> New closure_def(bang, id, [idlist.id], kwdo, stmtsn.expr, Null)}
- | {empty} bang [id]:closure_id idlist? kwdo n {-> New closure_def(bang, id, [idlist.id], kwdo, Null, Null)}
- ;
-closure_id
- = {simple} id
- | {break} kwbreak
- ;
-
assign_continue~withelse{-> expr}
= expr_final~withelse {-> New expr.continue(Null, Null, expr_final~withelse.expr)}
;
/* EXPRESSIONS ***************************************************************/
expr_final~nopar~withelse~nobra {-> expr}
= expr~nopar~nobra {-> expr~nopar~nobra.expr}
- | {closure_call} recv~nobra qualified? id args closure_defs~withelse {-> New expr.call(recv~nobra.expr, id, args.exprs, [closure_defs~withelse.closure_def])}
-!nobra!nopar | {closure_bra} expr_atom braargs closure_defs~withelse {-> New expr.bra(expr_atom.expr, braargs.exprs, [closure_defs~withelse.closure_def])}
;
-expr~nopar~nobra~nois {-> expr}
- = expr_and~nopar~nobra~nois {-> expr_and~nopar~nobra~nois.expr}
- | {ifexpr} kwif [n1]:no expr [n2]:no kwthen [n3]:no [then]:expr [n4]:no kwelse [n5]:no [else]:expr~nopar~nobra~nois {-> New expr.ifexpr(kwif, expr, kwthen, then, kwelse, else.expr)}
+expr~nopar~nobra {-> expr}
+ = expr_and~nopar~nobra {-> expr_and~nopar~nobra.expr}
+ | {ifexpr} kwif [n1]:no expr [n2]:no kwthen [n3]:no [then]:expr [n4]:no kwelse [n5]:no [else]:expr~nopar~nobra {-> New expr.ifexpr(kwif, expr, kwthen, then, kwelse, else.expr)}
;
-expr_and~nopar~nobra~nois {-> expr}
- = expr_not~nopar~nobra~nois {-> expr_not~nopar~nobra~nois.expr}
- | {:or} expr_and~nopar~nobra~nois :kwor :no expr_not~nopar~nobra~nois
- | {:and} expr_and~nopar~nobra~nois :kwand :no expr_not~nopar~nobra~nois
- | {:or_else} expr_and~nopar~nobra~nois :kwor :kwelse :no expr_not~nopar~nobra~nois
- | {:implies} expr_and~nopar~nobra~nois :kwimplies :no expr_not~nopar~nobra~nois
+expr_and~nopar~nobra {-> expr}
+ = expr_not~nopar~nobra {-> expr_not~nopar~nobra.expr}
+ | {:or} expr_and~nopar~nobra :kwor :no expr_not~nopar~nobra
+ | {:and} expr_and~nopar~nobra :kwand :no expr_not~nopar~nobra
+ | {:or_else} expr_and~nopar~nobra :kwor :kwelse :no expr_not~nopar~nobra
+ | {:implies} expr_and~nopar~nobra :kwimplies :no expr_not~nopar~nobra
;
-expr_not~nopar~nobra~nois {-> expr}
- = expr_eq~nopar~nobra~nois {-> expr_eq~nopar~nobra~nois.expr}
- | {not} kwnot no expr_not~nopar~nobra~nois {-> New expr.not(kwnot, expr_not~nopar~nobra~nois.expr)}
+expr_not~nopar~nobra {-> expr}
+ = expr_eq~nopar~nobra {-> expr_eq~nopar~nobra.expr}
+ | {not} kwnot no expr_not~nopar~nobra {-> New expr.not(kwnot, expr_not~nopar~nobra.expr)}
;
-expr_eq~nopar~nobra~nois {-> expr}
+expr_eq~nopar~nobra {-> expr}
= expr_add~nopar~nobra {-> expr_add~nopar~nobra.expr}
| {:eq} expr_add~nopar~nobra :eq :no [expr2]:expr_add~nopar~nobra
-!nois | {ee} [expr]:expr_add~nopar~nobra kwis no [expr2]:expr_add~nopar~nobra {-> New expr.ee(expr.expr, expr2.expr)}
| {:ne} expr_add~nopar~nobra :ne :no [expr2]:expr_add~nopar~nobra
| {:lt} expr_add~nopar~nobra :lt :no [expr2]:expr_add~nopar~nobra
| {:le} expr_add~nopar~nobra :le :no [expr2]:expr_add~nopar~nobra
- | {:ll} expr_eq~nopar~nobra~nois :ll :no [expr2]:expr_add~nopar~nobra
+ | {:ll} expr_eq~nopar~nobra :ll :no [expr2]:expr_add~nopar~nobra
| {:gt} expr_add~nopar~nobra :gt :no [expr2]:expr_add~nopar~nobra
| {:ge} expr_add~nopar~nobra :ge :no [expr2]:expr_add~nopar~nobra
- | {:gg} expr_eq~nopar~nobra~nois :gg :no [expr2]:expr_add~nopar~nobra
+ | {:gg} expr_eq~nopar~nobra :gg :no [expr2]:expr_add~nopar~nobra
| {:starship} expr_add~nopar~nobra :starship :no [expr2]:expr_add~nopar~nobra
| {:isa} expr_add~nopar~nobra :kwisa :no type~nobra
;
expr_atom~nopar~nobra {-> expr}
= {attr} recv~nopar~nobra qualified? attrid {-> New expr.attr(recv~nopar~nobra.expr, attrid)}
- | {call} recv~nopar~nobra qualified? id args {-> New expr.call(recv~nopar~nobra.expr, id, args.exprs, [])}
+ | {call} recv~nopar~nobra qualified? id args {-> New expr.call(recv~nopar~nobra.expr, id, args.exprs)}
| {super} qualified? kwsuper args {-> New expr.super(qualified, kwsuper, args.exprs)}
| {init} recv~nopar~nobra kwinit args {-> New expr.init(recv~nopar~nobra.expr, kwinit, args.exprs)}
-!nobra | {bra} expr_atom~nopar braargs {-> New expr.bra(expr_atom~nopar.expr, braargs.exprs, [])}
+!nobra | {bra} expr_atom~nopar braargs {-> New expr.bra(expr_atom~nopar.expr, braargs.exprs)}
| {new} kwnew no type~nobra_nopar dot [n2]:no qualified? id args {-> New expr.new(kwnew, type~nobra_nopar.type, id, args.exprs)}
// !nopar to unambiguise 'foo[5].bar' between '(foo[5]).bar' and 'foo([5].bar),
!nobra!nopar | {range} obra no expr [n2]:no dotdot [n3]:no [expr2]:expr_nobra [n4]:no cbra annotations? {-> New expr.crange(obra, expr, expr2.expr, cbra, annotations)}
superstring {-> expr}
= superstring_start superstring_middle* superstring_end annotations? {-> New expr.superstring([superstring_start.expr, superstring_middle.expr, superstring_end.expr], annotations)};
superstring_start {-> expr*}
- = start_string_p no expr [n2]:no {-> [start_string_p.expr, expr]};
+ = start_string_p no expr [n2]:no {-> [start_string_p.expr, expr]}
+ | {noexpr} start_string_p no {-> [start_string_p.expr]}
+ ;
start_string_p {-> expr}
= start_string {-> New expr.start_string(start_string)};
superstring_middle {-> expr*}
- = mid_string_p no expr [n2]:no {-> [mid_string_p.expr, expr]};
+ = mid_string_p no expr [n2]:no {-> [mid_string_p.expr, expr]}
+ | {noexpr} mid_string_p no {-> [mid_string_p.expr]}
+ ;
mid_string_p {-> expr}
= mid_string {-> New expr.mid_string(mid_string)};
superstring_end {-> expr}
;
atid~forclass {-> atid}
- = {id} qualified? id {-> New atid.id(id)}
+ = {id} id {-> New atid.id(id)}
//!forclass | {kwextern} qualified? kwextern {-> New atid.kwextern(kwextern)}
//!forclass | {kwintern} qualified? kwintern {-> New atid.kwintern(kwintern)}
-!forclass | {kwreadable} qualified? kwreadable {-> New atid.kwreadable(kwreadable)}
-!forclass | {kwwritable} qualified? kwwritable {-> New atid.kwwritable(kwwritable)}
- | {kwimport} qualified? kwimport {-> New atid.kwimport(kwimport)}
+!forclass | {kwreadable} kwreadable {-> New atid.kwreadable(kwreadable)}
+!forclass | {kwwritable} kwwritable {-> New atid.kwwritable(kwwritable)}
+ | {kwimport} kwimport {-> New atid.kwimport(kwimport)}
;
/* MISC **********************************************************************/
methid = {id} id | {plus} plus | {minus} minus | {star} star | {slash} slash | {percent} percent | {eq} eq | {ne} ne | {le} le | {ge} ge | {lt} lt | {gt} gt | {ll} ll | {gg} gg | {bra} obra cbra | {starship} starship | {assign} id assign | {braassign} obra cbra assign;
-signature = opar? [params]:param* cpar? type? [closure_decls]:closure_decl*;
+signature = opar? [params]:param* cpar? type?;
param = id type? dotdotdot? annotations?
;
-closure_decl = kwbreak? bang id signature expr?
- ;
-
type = kwnullable? [id]:classid [types]:type* annotations?;
label = kwlabel id;
| {implies} expr [expr2]:expr
| {not} kwnot expr
| {eq} expr [expr2]:expr
- | {ee} expr [expr2]:expr
| {ne} expr [expr2]:expr
| {lt} expr [expr2]:expr
| {le} expr [expr2]:expr
| {attr} expr [id]:attrid
| {attr_assign} expr [id]:attrid assign [value]:expr
| {attr_reassign} expr [id]:attrid assign_op [value]:expr
- | {call} expr id [args]:exprs [closure_defs]:closure_def*
+ | {call} expr id [args]:exprs
| {call_assign} expr id [args]:exprs assign [value]:expr
| {call_reassign} expr id [args]:exprs assign_op [value]:expr
| {super} qualified? kwsuper [args]:exprs
| {init} expr kwinit [args]:exprs
- | {bra} expr [args]:exprs [closure_defs]:closure_def*
+ | {bra} expr [args]:exprs
| {bra_assign} expr [args]:exprs assign [value]:expr
| {bra_reassign} expr [args]:exprs assign_op [value]:expr
- | {closure_call} id [args]:exprs [closure_defs]:closure_def*
| {var} id
| {var_assign} id assign [value]:expr
| {var_reassign} id assign_op [value]:expr
| {minus} minuseq
;
-closure_def
- = bang [id]:closure_id [ids]:id* kwdo? expr? label?
- ;
-closure_id
- = {simple} id
- | {break} kwbreak
- ;
-
module_name = quad? [path]:id* id;
extern_calls = kwimport [extern_calls]:extern_call*
;
extern_call =
| {super} kwsuper
| {local_prop} methid
- | {full_prop} classid quad? methid
- | {init_prop} classid
- | {cast_as} [from_type]:type kwas [to_type]:type
+ | {full_prop} type dot? methid
+ | {init_prop} type
+ | {cast_as} [from_type]:type dot? kwas [to_type]:type
| {as_nullable} type kwas kwnullable
| {as_not_nullable} type kwas kwnot kwnullable
;
nitlanguage / nit.git / blobdiff