naru.h

Go to the documentation of this file.

/*  library to help you to define a type system for a compiler
    Copyright (C) 2008  Patrick Frey

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program 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 General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/*
    libnaru is a library that supports you to define a type system for a 
    programming language. It is thought to be another lego piece beside 
    lexical and syntax analysis in a compiler project. 
    The public addressed by libnaru are people that already have some 
    experience in mapping of programming languages. 
    Libnaru introduces a notion of scope that is part of all definitions
    and queries. You define your type system by type identifiers, deduction
    rules from one type to another and tuples of types. 
    The resolving of expressions is seen as finding the unifier of your 
    query expression to any defined type tuple with minimal costs. The costs 
    of a unifier is the sum of costs of the type deduction rules used for it. 
    The expensive minimal costs path search is doable with reasonable 
    performance under the assumption that the first types of a tuple are 
    reducing the search space a lot. If the type system of your source 
    language is mappable in this form then things like multiple class or 
    interface inheritance, global and local namespaces, privilege levels 
    of access and even generics (though recursion needed in a meta 
    language has to be provided outside) come at your hands.
    The name libnaru comes from the Finish word "naru" that means string. 
    The reason for this choice is that the results of a resolved expression
    are sequences of constructor functors you defined with your type, rule
    and tuple definitions. You build the mapped result of the expression 
    in the target language by iterating over the elements of these strings 
    and doing some mapping defined by the visited constructors.
*/

/*
*   Author:  Patrick Frey
*   Address: Korneliusstr. 11 8008 Zurich Switzerland
*   My mail at yahoo is "patrick p frey"
*/
#ifndef NARU_H
#define NARU_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h>

typedef int nu_Scope;

#define nu_Scope_NULL  -1

typedef struct nu_TypeSystemStruct* nu_TypeSystem;

typedef int nu_TypeId;

#define nu_TypeId_NULL  -1

typedef enum {
   NU_OK=0,                           
   NU_ERROR_NOMEM=1,                  
   NU_ERROR_CONFLICT_RULE=2,          
   NU_ERROR_CONFLICT_DECISION=3,      
   NU_ERROR_CONFLICT_DUPLICATE_DEF=4, 
   NU_ERROR_SYNTAX=5                  
} nu_ErrorCode;

nu_TypeSystem nu_createTypeSystem(void);

void nu_destroyTypeSystem( nu_TypeSystem ts);


nu_Scope nu_beginScope( nu_TypeSystem ts);

nu_Scope nu_declareScope( nu_TypeSystem ts);

int nu_endScope( nu_TypeSystem ts);

int nu_cmpScope( nu_TypeSystem ts, nu_Scope A, nu_Scope B); 

int nu_sameScope( nu_TypeSystem ts, nu_Scope A, nu_Scope B);

int nu_scopeId( nu_TypeSystem ts, nu_Scope scope);


nu_TypeId nu_declareType( nu_TypeSystem ts, nu_Scope scope, const char* id, uintptr_t tc, uintptr_t tcarg, nu_ErrorCode* errcode);

nu_TypeId nu_getType( nu_TypeSystem ts, nu_Scope scope, const char* id);

char* nu_getTypeName( nu_TypeSystem ts, nu_TypeId type);

uintptr_t nu_getTypeConstructor( nu_TypeSystem ts, nu_TypeId type, uintptr_t* tcarg);

int nu_declareRule( nu_TypeSystem ts, nu_Scope scope, nu_TypeId src, nu_TypeId dest, unsigned int cstord, unsigned int cst, uintptr_t tc, uintptr_t tcarg, nu_ErrorCode* errcode); 

int nu_declareExpression( nu_TypeSystem ts, nu_Scope scope, unsigned int nof_tps, nu_TypeId* tps, nu_TypeId restype, uintptr_t tc, uintptr_t tcarg, nu_ErrorCode* errcode);  

nu_TypeId nu_getExpressionType( nu_TypeSystem ts, nu_Scope scope, unsigned int nof_tps, nu_TypeId* tps, uintptr_t* tc, uintptr_t* tcarg);

int nu_resolveExpression( nu_TypeSystem ts, nu_Scope scope, unsigned int nof_tps, nu_TypeId* tps, nu_TypeId* resulttype, nu_ErrorCode* errcode);

int nu_getRuleConflict( nu_TypeSystem ts, nu_TypeId** path1, nu_TypeId** path2);

int nu_getDecisionConflict( nu_TypeSystem ts, nu_TypeId** expr1, nu_TypeId** expr2);

int nu_getElementConstructor( nu_TypeSystem ts, int result_handle, unsigned int tps_idx, int iter, uintptr_t* tc, uintptr_t* tcarg);

int nu_getResultConstructor( nu_TypeSystem ts, int result_handle, uintptr_t* tc, uintptr_t* tcarg);

void nu_clearResultBuffer( nu_TypeSystem ts);

#ifdef __cplusplus
}
#endif
#endif

---