5.16.7.17. Variable and Constant Declaration

Start data section to src/flx_parse.mly[24 /35 ] Next Prev First Last
  1815: name_suffix:
  1816:   | COMMA NAME name_suffix { snd $2 :: $3 }
  1817:   | COMMA NAME { [snd $2] }
  1818: 
  1819: var_def:
  1820:   | VAR NAME name_suffix EQUAL expr SEMI
  1821:     {
  1822:       let sr = rstoken $1 $6 in
  1823:       let names = snd $2 :: $3 in
  1824:       let n = length names in
  1825:       let expr = $5 in
  1826:       match expr with
  1827:       | `AST_tuple (_,ls) ->
  1828:         if length ls <> n then
  1829:           Flx_exceptions.clierr sr ("Wrong number of initialisers, expected " ^ string_of_int n)
  1830:         else
  1831:         `AST_seq
  1832:         (
  1833:           sr,
  1834:           map2
  1835:           (fun name v ->
  1836:             `AST_var_decl ( sr, name, dfltvs, None, Some v)
  1837:           )
  1838:           names ls
  1839:         )
  1840: 
  1841:       | x ->
  1842:         let lexpr: tlvalue_t list = map (fun name -> `Var (sr,name),None) names in
  1843:         `AST_assign (sr,"_set",(`List lexpr, None), expr)
  1844:     }
  1845: 
  1846:   | VAR declname EQUAL expr SEMI
  1847:     {
  1848:       let name,vs = hd $2 in
  1849:       let sr = rstoken $1 $5 in
  1850:       let stmt = `AST_var_decl ( sr,name,vs, None, Some $4) in
  1851:       fold_left (fun stmt (name,vs) -> `AST_namespace (sr,name,vs,[stmt])) stmt (tl $2)
  1852:     }
  1853: 
  1854:   | VAR declname COLON expr LEFTARROW expr SEMI
  1855:    {
  1856:       let name,vs = hd $2 in
  1857:       let sr = rstoken $1 $7 in
  1858:       let call =
  1859:         let lsym = `AST_name (slift $1,name,[]) in
  1860:         match $6 with
  1861:         | `AST_apply (sr2,(f,a)) ->
  1862:           begin match a with
  1863:           | `AST_tuple (sr3,ls) ->
  1864:             `AST_call (sr,f,`AST_tuple (sr3,lsym::ls))
  1865:           | _ ->
  1866:             `AST_call (sr,f,`AST_tuple (sr2,[lsym;a]))
  1867:           end
  1868:         | _ as f ->
  1869:           `AST_call (sr,f,lsym)
  1870:       in
  1871:       let vardef = `AST_var_decl (sr,name,vs, Some (typecode_of_expr $4), None) in
  1872:       let stmt = `AST_seq (sr,[vardef;call]) in
  1873:       fold_left (fun stmt (name,vs) -> `AST_namespace (sr,name,vs,[stmt])) stmt (tl $2)
  1874: 
  1875:     }
  1876: 
  1877:   | VAR AMPER NAME tvarlist COLON expr LEFTARROW expr SEMI
  1878:    {
  1879:       let sr = rstoken $1 $9 in
  1880:       let call =
  1881:         let srn = slift (fst $3) in
  1882:         let lsym = `AST_ref
  1883:           (rsrange (slift $2) srn,
  1884:             `AST_name (srn,snd $3,[])
  1885:           )
  1886:         in
  1887:         match $8 with
  1888:         | `AST_apply (sr2,(f,a)) ->
  1889:           begin match a with
  1890:           | `AST_tuple (sr3,ls) ->
  1891:             `AST_call (sr,f,`AST_tuple (sr3,lsym::ls))
  1892:           | _ ->
  1893:             `AST_call (sr,f,`AST_tuple (sr2,[lsym;a]))
  1894:           end
  1895:         | _ as f ->
  1896:           `AST_call (sr,f,lsym)
  1897:       in
  1898:       let vardef =
  1899:         `AST_var_decl
  1900:         (
  1901:           rstoken $1 $7,
  1902:           snd $3,
  1903:           $4,
  1904:           Some (typecode_of_expr $6),
  1905:           None
  1906:         )
  1907:       in
  1908:         `AST_seq (sr,[vardef;call])
  1909:     }
  1910: 
  1911:   | VAR declname COLON expr EQUAL expr SEMI
  1912:     {
  1913:       let name,vs = hd $2 in
  1914:       let sr = rstoken $1 $7 in
  1915:       let stmt = `AST_var_decl ( sr,name,vs, Some (typecode_of_expr $4), Some $6) in
  1916:       fold_left (fun stmt (name,vs) -> `AST_namespace (sr,name,vs,[stmt])) stmt (tl $2)
  1917:     }
  1918: 
  1919:   | VAR declname COLON expr SEMI
  1920:     {
  1921:       let name,vs = hd $2 in
  1922:       let sr = rstoken $1 $5 in
  1923:       let stmt = `AST_var_decl ( sr,name,vs, Some (typecode_of_expr $4), None) in
  1924:       fold_left (fun stmt (name,vs) -> `AST_namespace (sr,name,vs,[stmt])) stmt (tl $2)
  1925:     }
  1926: 
  1927: val_def:
  1928:   | VAL NAME name_suffix EQUAL expr SEMI
  1929:     {
  1930:       let sr = rstoken $1 $6 in
  1931:       let names = snd $2 :: $3 in
  1932:       let n = length names in
  1933:       let expr = $5 in
  1934:       match expr with
  1935:       | `AST_tuple (_,ls) ->
  1936:         if length ls <> n then
  1937:           Flx_exceptions.clierr sr ("Wrong number of initialisers, expected " ^ string_of_int n)
  1938:         else
  1939:         `AST_seq
  1940:         (
  1941:           sr,
  1942:           map2
  1943:           (fun name v ->
  1944:             `AST_val_decl ( sr, name, dfltvs, None, Some v)
  1945:           )
  1946:           names ls
  1947:         )
  1948: 
  1949:       | x ->
  1950:         let lexpr: tlvalue_t list = map (fun name -> `Val (sr,name),None) names in
  1951:         `AST_assign (sr,"_set",(`List lexpr, None), expr)
  1952:     }
  1953: 
  1954:   | VAL declname EQUAL expr SEMI
  1955:     {
  1956:       let name,vs = hd $2 in
  1957:       let sr = rstoken $1 $5 in
  1958:       let stmt = `AST_val_decl ( sr,name,vs, None, Some $4) in
  1959:       fold_left (fun stmt (name,vs) -> `AST_namespace (sr,name,vs,[stmt])) stmt (tl $2)
  1960:     }
  1961: 
  1962:   | VAL declname COLON expr EQUAL expr SEMI
  1963:     {
  1964:       let name,vs = hd $2 in
  1965:       let sr = rstoken $1 $7 in
  1966:       let stmt = `AST_val_decl ( sr,name,vs, Some (typecode_of_expr $4), Some $6) in
  1967:       fold_left (fun stmt (name,vs) -> `AST_namespace (sr,name,vs,[stmt])) stmt (tl $2)
  1968:     }
  1969: 
  1970:   | VAL declname COLON expr SEMI
  1971:     {
  1972:       let name,vs = hd $2 in
  1973:       let sr = rstoken $1 $5 in
  1974:       let stmt = `AST_val_decl ( sr,name,vs, Some (typecode_of_expr $4), None) in
  1975:       fold_left (fun stmt (name,vs) -> `AST_namespace (sr,name,vs,[stmt])) stmt (tl $2)
  1976:     }
  1977: 
  1978:   | REF declname LEFTARROW expr SEMI
  1979:     {
  1980:       let name,vs = hd $2 in
  1981:       let sr = rstoken $1 $5 in
  1982:       let stmt = `AST_ref_decl ( sr,name,vs, None, Some $4) in
  1983:       fold_left (fun stmt (name,vs) -> `AST_namespace (sr,name,vs,[stmt])) stmt (tl $2)
  1984:     }
  1985: 
  1986:   | REF declname COLON expr LEFTARROW expr SEMI
  1987:     {
  1988:       let name,vs = hd $2 in
  1989:       let sr = rstoken $1 $7 in
  1990:       let stmt = `AST_ref_decl ( sr,name,vs, Some (typecode_of_expr $4), Some $6) in
  1991:       fold_left (fun stmt (name,vs) -> `AST_namespace (sr,name,vs,[stmt])) stmt (tl $2)
  1992:     }
  1993: 
End data section to src/flx_parse.mly[24]
Variables can be declared in both procedures and functions.