// D grammar - according to http://dlang.org/grammar

module ddc.lexer.Lexer;
import ddc.lexer.tokenizer;

/** Lexem type constants */
enum LexemType : ushort {
    UNKNOWN,
    // types
    TYPE,
    TYPE_CTORS,
    TYPE_CTOR,
    BASIC_TYPE,
    BASIC_TYPE_X,
    BASIC_TYPE_2,
    IDENTIFIER_LIST,
    IDENTIFIER,
    TYPEOF,
    // templates
    TEMPLATE_INSTANCE,
    EXPRESSION,
    ALT_DECLARATOR,
}

class Lexem {
    public @property LexemType type() { return LexemType.UNKNOWN; }
}

/** 
    Returns true for  one of keywords: bool, byte, ubyte, short, ushort, int, uint, long, ulong, 
        char, wchar, dchar, float, double, real, ifloat, idouble, ireal, cfloat, cdouble, creal, void 
*/
bool isBasicTypeXToken(Token token) {
    if (token.type != TokenType.KEYWORD)
        return false;
    Keyword id = token.keyword;
    return id == Keyword.BOOL
        || id == Keyword.BYTE
        || id == Keyword.UBYTE
        || id == Keyword.SHORT
        || id == Keyword.USHORT
        || id == Keyword.INT
        || id == Keyword.UINT
        || id == Keyword.LONG
        || id == Keyword.ULONG
        || id == Keyword.CHAR
        || id == Keyword.WCHAR
        || id == Keyword.DCHAR
        || id == Keyword.FLOAT
        || id == Keyword.DOUBLE
        || id == Keyword.REAL
        || id == Keyword.IFLOAT
        || id == Keyword.IDOUBLE
        || id == Keyword.IREAL
        || id == Keyword.CFLOAT
        || id == Keyword.CDOUBLE
        || id == Keyword.CREAL
        || id == Keyword.VOID;
}

/** 
  Single token, one of keywords: bool, byte, ubyte, short, ushort, int, uint, long, ulong, 
  char, wchar, dchar, float, double, real, ifloat, idouble, ireal, cfloat, cdouble, creal, void
*/
class BasicTypeX : Lexem {
    public Token _token;
    public override @property LexemType type() { return LexemType.BASIC_TYPE_X; }
    public this(Token token) 
    in {
        assert(isBasicTypeXToken(token));
    }
    body {
        _token = token;
    }
}

/** 
    Returns true for  one of keywords: const, immutable, inout, shared 
*/
bool isTypeCtorToken(Token token) {
    if (token.type != TokenType.KEYWORD)
        return false;
    Keyword id = token.keyword;
    return id == Keyword.CONST
        || id == Keyword.IMMUTABLE
        || id == Keyword.INOUT
        || id == Keyword.SHARED;
}

/** 
    Single token, one of keywords: const, immutable, inout, shared 
*/
class TypeCtor : Lexem {
    public Token _token;
    public override @property LexemType type() { return LexemType.TYPE_CTOR; }
    public this(Token token)
    in {
        assert(isTypeCtorToken(token));
    }
    body {
        _token = token;
    }
}

/** 
    Zero, one or several keywords: const, immutable, inout, shared 
*/
class TypeCtors : Lexem {
    public TypeCtor[] _list;
    public override @property LexemType type() { return LexemType.TYPE_CTORS; }
    public this(Token token)
    in {
        assert(isTypeCtorToken(token));
    }
    body {
        _list ~= new TypeCtor(token);
    }
    public void append(Token token)
    in {
        assert(isTypeCtorToken(token));
    }
    body {
        _list ~= new TypeCtor(token);
    }
}

/**
    Identifier.
*/
class Identifier : Lexem {
    IdentToken _token;
    public override @property LexemType type() { return LexemType.IDENTIFIER; }
    public this(Token identifier)
    in {
        assert(identifier.type == TokenType.IDENTIFIER);
    }
    body {
        _token = cast(IdentToken)identifier;
    }
}

/**
    Identifier list.

    IdentifierList:
        Identifier
        Identifier . IdentifierList
        TemplateInstance
        TemplateInstance . IdentifierList
 */
class IdentifierList : Lexem {
    public Identifier _identifier;
    public IdentifierList _identifierList;
    public TemplateInstance _templateInstance;
    public override @property LexemType type() { return LexemType.IDENTIFIER_LIST; }
    public this(Token ident, IdentifierList identifierList = null)
    in {
        assert(ident.type == TokenType.IDENTIFIER);
    }
    body {
        _identifier = new Identifier(ident);
        _identifierList = identifierList;
    }
    public this(TemplateInstance templateInstance, IdentifierList identifierList = null)
    in {
    }
    body {
        _templateInstance = templateInstance;
        _identifierList = identifierList;
    }
}

/**
    Template instance.

    TemplateInstance:
        Identifier TemplateArguments
*/
class TemplateInstance : Lexem {
    public override @property LexemType type() { return LexemType.TEMPLATE_INSTANCE; }
    public this()
    in {
    }
    body {
    }
}

/**
    Basic type.

    BasicType:
        BasicTypeX
        . IdentifierList
        IdentifierList
        Typeof
        Typeof . IdentifierList
        TypeCtor ( Type )
*/
class BasicType : Lexem {
    public BasicTypeX _basicTypeX;
    public IdentifierList _identifierList;
    public Typeof _typeof;
    public TypeCtor _typeCtor;
    public Type _typeCtorType;
    public bool _dotBeforeIdentifierList;
    public override @property LexemType type() { return LexemType.BASIC_TYPE; }
    public this()
    in {
    }
    body {
    }
}



/**
    Typeof.

    Typeof:
        typeof ( Expression )
        typeof ( return )
    
    For typeof(return), _expression is null
*/
class Typeof : Lexem {
    public Expression _expression;
    public override @property LexemType type() { return LexemType.TYPEOF; }
    public this(Expression expression)
    in {
    }
    body {
        _expression = expression;
    }
}

/**
    Type.

*/
class Type : Lexem {
    public TypeCtors _typeCtors;
    public BasicType _basicType;
    public AltDeclarator _altDeclarator;
    public override @property LexemType type() { return LexemType.TYPE; }
    public this()
    in {
    }
    body {
    }
}

/**
    Expression.

    Expression:
*/
class Expression : Lexem {
    public override @property LexemType type() { return LexemType.EXPRESSION; }
    public this()
    in {
    }
    body {
    }
}

/**
    AltDeclarator.

    AltDeclarator:
*/
class AltDeclarator : Lexem {
    public override @property LexemType type() { return LexemType.ALT_DECLARATOR; }
    public this()
    in {
    }
    body {
    }
}

class Lexer
{
}