/// <summary>
/// Parse given input string in the concrete grammar.
/// </summary>
/// <param name="str">Input string to be parsed.</param>
/// <param name="cat">Category (Type) to parse.</param>
/// <param name="heuristics">Heuristic (see the GF C runtime docs).</param>
/// <param name="Callback1">Callback function.</param>
/// <param name="Callback2">Callback function.</param>
/// <returns>Enumerates pairs of (abstract grammar) expressions and corresponding probability.</returns>
public IEnumerable <Tuple <Expr, float> > Parse(string str, Type cat = null, double?heuristics = null,
Action Callback1 = null, Action Callback2 = null)
{
var parse_pool = new NativeGU.NativeMemoryPool();
var exn = new NativeGU.NativeExceptionContext(parse_pool);
cat = cat ?? PGF.StartCat;
using (var nativeStr = new Native.NativeString(str))
{
var result_pool = new NativeGU.NativeMemoryPool();
var callbackMap = Native.pgf_new_callbacks_map(this.Ptr, parse_pool.Ptr);
var iterator = Native.pgf_parse_with_heuristics(this.Ptr, cat.Ptr,
nativeStr.Ptr, heuristics ?? -1, callbackMap,
exn.Ptr, parse_pool.Ptr, result_pool.Ptr);
if (iterator == IntPtr.Zero || exn.IsRaised)
{
throw new ParseError();
}
else
{
foreach (var ptr in NativeGU.IteratorToIEnumerable(iterator, parse_pool.Ptr))
{
var exprProb = (Native.PgfExprProb)Marshal.PtrToStructure(ptr, typeof(Native.PgfExprProb));
yield return(Tuple.Create(Expr.FromPtr(exprProb.expr, result_pool),
exprProb.prob));
}
}
}
}
/// <summary>
/// Returns a list with all functions with a given return category.
/// </summary>
/// <param name="catName">The name of the return category.</param>
public IEnumerable <string> FunctionsByCat(string catName)
{
using (var str = new Native.NativeString(catName))
{
return(GetStringList(new Native.IterFuncCurryName(Native.pgf_iter_functions_by_cat, str.Ptr).IterFunc));
}
}
public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
{
result = null;
uint n_hypos = 0;
using (var str = new Native.NativeString(binder.Name))
{
var typePtr = Native.pgf_function_type(gr._ptr, str.Ptr);
if (typePtr == IntPtr.Zero)
{
return(false);
}
n_hypos = NativeGU.SeqLength(Marshal.PtrToStructure <Type.PgfType>(typePtr).hypos);
}
if (args.Length != n_hypos)
{
return(false);
}
Expr[] exprs = new Expr[args.Length];
for (var i = 0; i < args.Length; i++)
{
exprs[i] = args[i] as Expr;
if (exprs[i] == null)
{
return(false);
}
}
result = new ApplicationExpr(binder.Name, exprs);
return(true);
}
/// <summary>
/// Returns the type of the function with the given name.
/// </summary>
/// <param name="funName">The name of the function.</param>
/// <returns></returns>
public Type FunctionType(string funName)
{
using (var str = new Native.NativeString(funName))
{
var typePtr = Native.pgf_function_type(_ptr, str.Ptr);
if (typePtr == IntPtr.Zero)
{
throw new NullReferenceException();
}
return(Type.FromPtr(typePtr, pool));
}
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
result = null;
using (var str = new Native.NativeString(binder.Name))
{
var typePtr = Native.pgf_function_type(gr._ptr, str.Ptr);
if (typePtr == IntPtr.Zero)
{
return(false);
}
}
result = new ApplicationExpr(binder.Name, new Expr[0]);
return(true);
}
/// <summary>
/// Read expression from string.
/// </summary>
/// <param name="exprStr"></param>
/// <returns></returns>
public static Expr ReadExpr(string exprStr)
{
var tmp_pool = new NativeGU.NativeMemoryPool();
var exn = new NativeGU.NativeExceptionContext(tmp_pool);
var result_pool = new NativeGU.NativeMemoryPool();
using (var strNative = new Native.NativeString(exprStr))
{
var in_ = NativeGU.gu_data_in(strNative.Ptr, strNative.Size, tmp_pool.Ptr);
var expr = Native.pgf_read_expr(in_, result_pool.Ptr, tmp_pool.Ptr, exn.Ptr);
if (exn.IsRaised || expr == IntPtr.Zero)
{
throw new PGFError();
}
else
{
return(Expr.FromPtr(expr, result_pool));
}
}
}
/// <summary>
/// Read type from string.
/// </summary>
/// <param name="typeStr"></param>
/// <returns></returns>
public static Type ReadType(string typeStr)
{
var tmp_pool = new NativeGU.NativeMemoryPool();
var exn = new NativeGU.NativeExceptionContext(tmp_pool);
var result_pool = new NativeGU.NativeMemoryPool();
using (var strNative = new Native.NativeString(typeStr))
{
var in_ = NativeGU.gu_data_in(strNative.Ptr, strNative.Size, tmp_pool.Ptr);
var typ = Native.pgf_read_type(in_, result_pool.Ptr, tmp_pool.Ptr, exn.Ptr);
if (exn.IsRaised || typ == IntPtr.Zero)
{
throw new PGFError();
}
else
{
return(Type.FromPtr(typ, result_pool));
}
}
}
