5.16.5.17. Variable and Constant Declaration

Start data section to src/flx_parse.mly[22 /33 ] Next Prev First Last
  1526: name_suffix:
  1527:   | COMMA NAME name_suffix { snd $2 :: $3 }
  1528:   | COMMA NAME { [snd $2] }
  1529: 
  1530: var_def:
  1531:   | VAR NAME name_suffix EQUAL expr SEMI
  1532:     {
  1533:       let sr = rstoken $1 $6 in
  1534:       let names = snd $2 :: $3 in
  1535:       let n = length names in
  1536:       let expr = $5 in
  1537:       let ls =
  1538:         match $5 with
  1539:         | `AST_tuple (_,ls) ->
  1540:           if length ls <> n then
  1541:             Flx_exceptions.clierr sr ("Wrong number of initialisers, expected " ^ string_of_int n)
  1542:           else ls
  1543:         | x -> map (fun i -> `AST_get_n (sr,(i,x))) (nlist n)
  1544:       in
  1545:       `AST_seq
  1546:       (
  1547:         sr,
  1548:         map2
  1549:         (fun name v ->
  1550:           `AST_var_decl ( sr, name, [], None, Some v)
  1551:         )
  1552:         names ls
  1553:       )
  1554:     }
  1555: 
  1556:   | VAR NAME tvarlist EQUAL expr SEMI
  1557:     {
  1558:       `AST_var_decl
  1559:       (
  1560:         rstoken $1 $6,
  1561:         snd $2,
  1562:         $3, None, Some $5
  1563:       )
  1564:     }
  1565: 
  1566:   | VAR NAME tvarlist COLON expr LEFTARROW expr SEMI
  1567:    {
  1568:       let sr = rstoken $1 $8 in
  1569:       let call =
  1570:         let lsym = `AST_name (slift (fst $2),snd $2,[]) in
  1571:         match $7 with
  1572:         | `AST_apply (sr2,(f,a)) ->
  1573:           begin match a with
  1574:           | `AST_tuple (sr3,ls) ->
  1575:             `AST_call (sr,f,`AST_tuple (sr3,lsym::ls))
  1576:           | _ ->
  1577:             `AST_call (sr,f,`AST_tuple (sr2,[lsym;a]))
  1578:           end
  1579:         | _ as f ->
  1580:           `AST_call (sr,f,lsym)
  1581:       in
  1582:       let vardef =
  1583:         `AST_var_decl
  1584:         (
  1585:           rstoken $1 $6,
  1586:           snd $2,
  1587:           $3,
  1588:           Some (typecode_of_expr $5),
  1589:           None
  1590:         )
  1591:       in
  1592:         `AST_seq (sr,[vardef;call])
  1593:     }
  1594: 
  1595:   | VAR AMPER NAME tvarlist COLON expr LEFTARROW expr SEMI
  1596:    {
  1597:       let sr = rstoken $1 $9 in
  1598:       let call =
  1599:         let srn = slift (fst $3) in
  1600:         let lsym = `AST_ref
  1601:           (rsrange (slift $2) srn,
  1602:             `AST_name (srn,snd $3,[])
  1603:           )
  1604:         in
  1605:         match $8 with
  1606:         | `AST_apply (sr2,(f,a)) ->
  1607:           begin match a with
  1608:           | `AST_tuple (sr3,ls) ->
  1609:             `AST_call (sr,f,`AST_tuple (sr3,lsym::ls))
  1610:           | _ ->
  1611:             `AST_call (sr,f,`AST_tuple (sr2,[lsym;a]))
  1612:           end
  1613:         | _ as f ->
  1614:           `AST_call (sr,f,lsym)
  1615:       in
  1616:       let vardef =
  1617:         `AST_var_decl
  1618:         (
  1619:           rstoken $1 $7,
  1620:           snd $3,
  1621:           $4,
  1622:           Some (typecode_of_expr $6),
  1623:           None
  1624:         )
  1625:       in
  1626:         `AST_seq (sr,[vardef;call])
  1627:     }
  1628: 
  1629:   | VAR NAME tvarlist COLON expr EQUAL expr SEMI
  1630:     {
  1631:       `AST_var_decl
  1632:       (
  1633:         rstoken $1 $8,
  1634:         snd $2,
  1635:         $3,
  1636:         Some (typecode_of_expr $5),
  1637:         Some $7
  1638:       )
  1639:     }
  1640: 
  1641:   | VAR NAME tvarlist COLON expr SEMI
  1642:     {
  1643:       `AST_var_decl
  1644:       (
  1645:         rstoken $1 $6,
  1646:         snd $2,
  1647:         $3,
  1648:         Some (typecode_of_expr $5),
  1649:         None
  1650:       )
  1651:     }
  1652: 
  1653: val_def:
  1654:   | VAL NAME name_suffix EQUAL expr SEMI
  1655:     {
  1656:       let sr = rstoken $1 $6 in
  1657:       let names = snd $2 :: $3 in
  1658:       let n = length names in
  1659:       let expr = $5 in
  1660:       let ls =
  1661:         match $5 with
  1662:         | `AST_tuple (_,ls) ->
  1663:           if length ls <> n then
  1664:             Flx_exceptions.clierr sr ("Wrong number of initialisers, expected " ^ string_of_int n)
  1665:           else ls
  1666:         | x -> map (fun i -> `AST_get_n (sr,(i,x))) (nlist n)
  1667:       in
  1668:       `AST_seq
  1669:       (
  1670:         sr,
  1671:         map2
  1672:         (fun name v ->
  1673:           `AST_val_decl ( sr, name, [], None, Some v)
  1674:         )
  1675:         names ls
  1676:       )
  1677:     }
  1678: 
  1679:   | VAL NAME tvarlist EQUAL expr SEMI
  1680:     {
  1681:       `AST_val_decl
  1682:       (
  1683:         rstoken $1 $6,
  1684:         snd $2,
  1685:         $3,
  1686:         None,
  1687:         Some $5
  1688:       )
  1689:     }
  1690: 
  1691:   | VAL NAME tvarlist COLON expr EQUAL expr SEMI
  1692:     {
  1693:       `AST_val_decl
  1694:       (
  1695:         rstoken $1 $8,
  1696:         snd $2,
  1697:         $3,
  1698:         Some (typecode_of_expr $5),
  1699:         Some $7
  1700:       )
  1701:     }
  1702:   | VAL NAME tvarlist COLON expr SEMI
  1703:     {
  1704:       `AST_val_decl
  1705:       (
  1706:         rstoken $1 $6,
  1707:         snd $2,
  1708:         $3,
  1709:         Some (typecode_of_expr $5),
  1710:         None
  1711:       )
  1712:     }
End data section to src/flx_parse.mly[22]
Variables can be declared in both procedures and functions.