me_util.tcl

Go to the documentation of this file.

/*  -*- tcl -*-*/
/*  ### ### ### ######### ######### #########*/
/*  Package description*/

/*  Utility commands for the conversion between various representations*/
/*  of abstract syntax trees.*/

/*  ### ### ### ######### ######### #########*/
/*  Requisites*/

namespace ::grammar::me::util {
    namespace export ast2tree ast2etree tree2ast
}

/*  ### ### ### ######### ######### #########*/
/*  Implementation*/

/*  ### ### ### ######### ######### #########*/
/*  API Implementation.*/

ret  ::grammar::me::util::ast2tree (type ast , type tree , optional root ={)} {
    # See grammar::me_ast for the specification of both value and tree
    # representations.

    if {$root eq ""} {
     root =  [$tree rootname]
    }

    /*  Decompose the AST value into its components.*/

    if {[llength $ast] < 3} {
    return -code error "Bad node \"$ast\", not enough elements"
    }

     type =      [lindex $ast 0]
     range =     [lrange $ast 1 2]
     children =  [lrange $ast 3 end]

    if {($type eq "") && [llength $children]} {
    return -code error \
        "Terminal node \"[lrange $ast 0 2]\" has children"
    }
    foreach {s e} $range break
    if {
    ![string is integer -strict $s] || ($s < 0) ||
    ![string is integer -strict $e] || ($e < 0)
    } {
    return -code error "Bad range information \"$range\""
    }

    /*  Create a node for the root of the AST and fill it with the data*/
    /*  from the value. Afterward recurse and build the tree for the*/
    /*  children of the root.*/

     new =  [lindex [$tree insert $root end] 0]

    if {$type eq ""} {
    $tree  $new =  type terminal
    } else {
    $tree  $new =  type   nonterminal
    $tree  $new =  detail $type
    }

    $tree  $new =  range $range

    foreach child $children {
    ast2tree $child $tree $new
    }
    return
}

ret  ::grammar::me::util::ast2etree (type ast , type mcmd , type tree , optional root ={)} {
    # See grammar::me_ast for the specification of both value and tree
    # representations.

    if {$root eq ""} {
     root =  [$tree rootname]
    }

    /*  Decompose the AST value into its components.*/

    if {[llength $ast] < 3} {
    return -code error "Bad node \"$ast\", not enough elements"
    }

     type =      [lindex $ast 0]
     range =     [lrange $ast 1 2]
     children =  [lrange $ast 3 end]

    if {($type eq "") && [llength $children]} {
    return -code error \
        "Terminal node \"[lrange $ast 0 2]\" has children"
    }
    foreach {s e} $range break
    if {
    ![string is integer -strict $s] || ($s < 0) ||
    ![string is integer -strict $e] || ($e < 0)
    } {
    return -code error "Bad range information \"$range\""
    }

    /*  Create a node for the root of the AST and fill it with the data*/
    /*  from the value. Afterward recurse and build the tree for the*/
    /*  children of the root.*/

     new =  [lindex [$tree insert $root end] 0]

    if {$type eq ""} {
         cmd =  $mcmd
    lappend cmd tok
    foreach loc $range {lappend cmd $loc}

    $tree  $new =  type   terminal
    $tree  $new =  detail [uplevel \/* 0 $cmd]*/
    } else {
    $tree  $new =  type   nonterminal
    $tree  $new =  detail $type
    }

     range = _lc {}
    foreach loc $range {
    lappend range_lc [uplevel \/* 0 \*/
        [linsert $mcmd end lc $loc]]
    }

    $tree  $new =  range    $range
    $tree  $new =  range_lc $range_lc

    foreach child $children {
    ast2etree $child $mcmd $tree $new
    }
    return
}

ret  ::grammar::me::util::tree2ast (type tree , optional root ={)} {
    # See grammar::me_ast for the specification of both value and tree
    # representations.

    if {$root eq ""} {
     root =  [$tree rootname]
    }

     value =  {}

    if {![$tree keyexists $root type]} {
    return -code error "Bad node \"$root\", type information is missing"
    }
    if {![$tree keyexists $root range]} {
    return -code error "Bad node \"$root\", range information is missing"
    }

     range =  [$tree get $root range]
    if {[llength $range] != 2} {
    return -code error "Bad node \"root\", bad range information \"$range\""
    }

    foreach {s e} $range break
    if {
    ![string is integer -strict $s] || ($s < 0) ||
    ![string is integer -strict $e] || ($e < 0)
    } {
    return -code error "Bad node \"root\", bad range information \"$range\""
    }

    if {[$tree get $root type] eq "terminal"} {
    lappend value {}
    } else {
    if {![$tree keyexists $root detail]} {
        return -code error "Bad node \"$root\", nonterminal detail is missing"
    }

    lappend value [$tree get $root detail]
    }

    /*  Range data ...*/
    lappend value $s $e

    foreach child [$tree children $root] {
    lappend value [tree2ast $tree $child]
    }

    return $value
}

/*  ### ### ### ######### ######### #########*/
/*  Package Management*/

package provide grammar::me::util 0.1