Atravesar un volcado de árbol (gráfico) similar a un esquema usando C

Question

Tengo una estructura de gráfica de árbol similar a un esquema.Quiero analizarlo usando C en alguna representación en memoria y caminar sobre él.

¿Existe alguna biblioteca o front-end de analizador para hacer esto?

EDITAR:

He analizado la siguiente expresión

true && (false || true) ;
true ;
false || false 

para seguir (este es mi volcado de árbol similar a un esquema)

(PROG [(AndExp TVal(OrExp FValTVal)), TVal, (OrExp FValFVal)])

Que quiero atravesar usando C (tengo que dárselo a otra persona que solo trabaja con C).PROG es una etiqueta;AndExp, OrExp, etc. son tokens para &&, ||etc ..

Answer 1

Parece que esta es una forma de S-Expression .Quizás Este analizador de expresiones S pueda modificarse según sus necesidades.

Answer 2

Creo que he entendido su requisito, pero no estoy seguro.

Tiene las expresiones en notación de prefijo, por lo tanto, esto básicamente está cargando la expresión de prefijo que tiene en su archivo de volcado en un árbol binario.

Aquí hay un pseudocódigo que describe el proceso para cargar las expresiones en un árbol.

tree_node make_tree (string dump)
{
  tok1 = get_tok (dump);
  tok2 = get_tok (dump);
  tok3 = get_tok (dump);

  if (tok1 == operand)
  {
    node = make_new_node_with (tok1);
    return node;
  }

  node = make_new_node_with (tok1);
  node->left = make_tree (tok2);
  node->right = make_tree (tok3);
  return node;
}

• llamada 1 recursiva con (AndExp TVal(OrExp FValTVal))

  tok1= AndExp crea un nuevo nodo1

  tok2= TVal

  tok3= (OrExp FValTVal)

• La llamada 2 recursiva con TVal devuelve node2 a call 1 que lo vincula con el puntero izquierdo de node1.

• llamada 3 recursiva con (OrExp FValTVal) de la llamada 1.

  tok1= ORExp crea un nuevo nodo3

  tok2= FVal

  tok3= TVal

• La llamada 3 recursiva con FVal y la llamada 4 con TVal, respectivamente, devuelve node4 y node5 con los valores del operando, que están vinculados a los enlaces izquierdo y derecho de el nodo3 de la llamada 3.

No se deben considerar más subexpresiones, la recursividad regresa al punto de partida. Tienes la raíz del árbol.

                         ( node1 )
                         |AndExp |
                         +---+---+
                             |
                +------------+------------+
                |                         |
            ( node2 )                ( node3 )
            | TVal  |                | ORExp |
            +---+---+                +---+---+
                                         |
                             +-----------+-----------+
                             |                       |
                         ( node4 )               ( node5 )
                         |  FVal |               |  TVal |
                         +---+---+               +---+---+ 

Si hay más de dos operandos, el procesamiento se puede realizar de manera similar agregando enlaces adicionales a los nodos del árbol.

Para cada expresión de su archivo de volcado, que están separados por comas, tendrán árboles separados, que después de la creación se pueden recorrer.