mirror of
https://github.com/GrammaticalFramework/gf-core.git
synced 2026-04-17 08:49:31 -06:00
157 lines
3.8 KiB
C
157 lines
3.8 KiB
C
/*
|
|
* Copyright 2010-2011 University of Helsinki.
|
|
*
|
|
* This file is part of libpgf.
|
|
*
|
|
* Libpgf is free software: you can redistribute it and/or modify it under
|
|
* the terms of the GNU Lesser General Public License as published by the
|
|
* Free Software Foundation, either version 3 of the License, or (at your
|
|
* option) any later version.
|
|
*
|
|
* Libpgf is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
|
* License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with libpgf. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <gu/type.h>
|
|
#include <gu/dump.h>
|
|
#include <gu/enum.h>
|
|
#include <pgf/data.h>
|
|
|
|
/// Linearization of abstract syntax trees.
|
|
/// @file
|
|
|
|
/** @name Linearizers
|
|
*
|
|
* Linearization begins by choosing a concrete category (#PgfConcr) for some
|
|
* grammar, and creating a new linearizer (#PgfLzr) which can then be used to
|
|
* linearize abstract syntax trees (#PgfExpr) of that grammar into the given
|
|
* concrete category.
|
|
*
|
|
* @{
|
|
*/
|
|
|
|
|
|
/// A linearizer.
|
|
typedef struct PgfLzr PgfLzr;
|
|
/**<
|
|
*
|
|
* A #PgfLzr object transforms abstract syntax trees of a PGF grammar
|
|
* into sequences of token events for a single concrete category of
|
|
* that grammar.
|
|
*
|
|
*/
|
|
GU_DECLARE_TYPE(PgfLzr, struct);
|
|
|
|
|
|
/// Create a new linearizer.
|
|
PgfLzr*
|
|
pgf_new_lzr(PgfConcr* cnc, GuPool* pool);
|
|
/**<
|
|
* @param cnc The concrete category to linearize to.
|
|
*
|
|
* @pool
|
|
*
|
|
* @return A new linearizer.
|
|
*/
|
|
|
|
/** @}
|
|
*
|
|
* @name Enumerating concrete syntax trees
|
|
*
|
|
* Because of the \c variants construct in GF, there may be several
|
|
* possible concrete syntax trees that correspond to a given abstract
|
|
* syntax tree. These can be enumerated with #pgf_lzr_concretize and
|
|
* #pgf_cnc_trees_next.
|
|
*
|
|
* @{
|
|
*/
|
|
|
|
|
|
/// A concrete syntax tree
|
|
typedef GuVariant PgfCncTree;
|
|
|
|
/// An enumeration of #PgfCncTree trees.
|
|
typedef GuEnum PgfCncTreeEnum;
|
|
|
|
/// Begin enumerating concrete syntax variants.
|
|
PgfCncTreeEnum*
|
|
pgf_lzr_concretize(PgfLzr* lzr, PgfExpr expr, GuPool* pool);
|
|
|
|
/** @}
|
|
*
|
|
* @name Linearizing concrete syntax trees
|
|
*
|
|
* An individual concrete syntax tree has several different
|
|
* linearizations, corresponding to the various fields and cases of
|
|
* corresponding GF values. The number of these linearizations, called
|
|
* the \e dimension of the tree, can be retrieved with
|
|
* #pgf_cnc_tree_dimension.
|
|
*
|
|
* A single linearization of a concrete syntax tree is performed by
|
|
* #pgf_lzr_linearize. The linearization is realized as a sequence of
|
|
* events that are notified by calling the functions of a #PgfLinFuncs
|
|
* structure that the client provides.
|
|
*
|
|
* @{
|
|
*/
|
|
|
|
/// Callback functions for linearization.
|
|
typedef struct PgfLinFuncs PgfLinFuncs;
|
|
|
|
struct PgfLinFuncs
|
|
{
|
|
/// Output tokens
|
|
void (*symbol_tokens)(PgfLinFuncs** self, PgfTokens toks);
|
|
|
|
void (*symbol_expr)(PgfLinFuncs** self,
|
|
int argno, PgfExpr expr, int lin_idx);
|
|
|
|
/// Begin application
|
|
void (*expr_apply)(PgfLinFuncs** self, PgfCId cid, int n_args);
|
|
|
|
/// Output literal
|
|
void (*expr_literal)(PgfLinFuncs** self, PgfLiteral lit);
|
|
|
|
void (*abort)(PgfLinFuncs** self);
|
|
void (*finish)(PgfLinFuncs** self);
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/// Linearize a concrete syntax tree.
|
|
void
|
|
pgf_lzr_linearize(PgfLzr* lzr, PgfCncTree ctree, size_t lin_idx,
|
|
PgfLinFuncs** fnsp);
|
|
|
|
|
|
/// Linearize a concrete syntax tree as space-separated tokens.
|
|
void
|
|
pgf_lzr_linearize_simple(PgfLzr* lzr, PgfCncTree ctree,
|
|
size_t lin_idx, GuWriter* wtr, GuExn* err);
|
|
|
|
|
|
/// Return the dimension of a concrete syntax tree.
|
|
int
|
|
pgf_cnc_tree_dimension(PgfCncTree ctree);
|
|
/**<
|
|
* @param ctree A concrete syntax tree.
|
|
*
|
|
* @return The dimension of the tree, i.e. the number of different
|
|
* linearizations the tree has.
|
|
*/
|
|
|
|
//@}
|
|
|
|
|
|
|
|
extern GuTypeTable
|
|
pgf_linearize_dump_table;
|
|
|