//------------------------------------------------------------
// TypePath。
TypePath parseTypePath()
{
// todo:
// 配列演算子対応
// オブジェクトハンドル対応
Token t = currentToken();
TypePath typePath = null;
if (t.Value == Token.Kind.Identifier)
{// identPath
IdentPath identPath = parseIdentPath();;
if (identPath != null)
{
typePath = new TypePath(identPath);
}
}
else
{// builtInType?
BuiltInType builtinType = ParseBuiltInType(t);
if (builtinType != BuiltInType.Unknown)
{
typePath = new TypePath(t, builtinType);
nextToken();
}
}
return(typePath);
}
//------------------------------------------------------------
// モジュールを追加する。
public bool Add(ModuleContext aModuleContext)
{
// 同じパスのものが既に追加されていないかチェックしつつ追加する
ISymbolNode node = mRoot;
IdentPath identPath = aModuleContext.ModuleDecl.IdentifierPath;
for (int i = 0; i < identPath.Count; ++i)
{
ISymbolNode nextNode = node.FindChildNode(identPath.At(i));
if (i + 1 == identPath.Count)
{ // 最後
if (nextNode != null)
{ // 最後なのに存在している
setErrorInfo(aModuleContext, ErrorKind.NODE_NAME_IS_ALREADY_EXIST, node.GetIdentifier().Token);
return(false);
}
break;
}
if (nextNode == null)
{// 存在しないようなので追加
NamespaceSymbolNode addNode = new NamespaceSymbolNode(node, identPath.At(i));
if (node.GetNodeKind() == SymbolNodeKind.Root)
{
((RootSymbolNode)node).AddNode(addNode);
}
else
{
((NamespaceSymbolNode)node).AddNode(addNode);
}
node = addNode;
}
else
{// 既に存在している
node = nextNode;
if (node.GetNodeKind() != SymbolNodeKind.NameSpace)
{// 名前空間じゃないものとして存在する
setErrorInfo(aModuleContext, ErrorKind.NODE_NAME_IS_ALREADY_EXIST_AS_NOT_NAMESPACE, node.GetIdentifier().Token);
return(false);
}
}
}
Assert.Check(node.GetNodeKind() == SymbolNodeKind.NameSpace);
// Moduleノードを追加
var moduleSymbolNode = new ModuleSymbolNode(node, aModuleContext);
((NamespaceSymbolNode)node).AddNode(moduleSymbolNode);
mModuleSymbolNodeList.Add(moduleSymbolNode);
return(true);
}
//------------------------------------------------------------
/// <summary>
/// ExternalModuleDecls:
/// ExternalModuleDecl
/// ExternalModuleDecl ExternalModuleDecls
///
/// ExternalModuleDecl:
/// ImportExternalModule
/// UsingExternalModule
///
/// ImportExternalModule:
/// "import" ModulePath ";"
///
/// UsingExternalModule
/// "using" ModulePath ";"
///
/// </summary>
bool parseExternalModuleDecls(ModuleContext aModuleContext)
{
List <ExternalModuleDecl> decls = new List <ExternalModuleDecl>();
while (true)
{
// キーワードチェック
ExternalModuleDecl.Kind kind;
if (currentToken().Value == Token.Kind.KeyImport)
{// import
kind = ExternalModuleDecl.Kind.IMPORT;
}
else if (currentToken().Value == Token.Kind.KeyUsing)
{// using
kind = ExternalModuleDecl.Kind.USING;
}
else
{// exit
break;
}
nextToken();
// パスをパース
IdentPath identPath = parseModulePath();
if (identPath == null)
{// パース失敗
return(false);
}
// セミコロンで終わるはず
if (currentToken().Value != Token.Kind.OpSemicolon)
{// 失敗
setErrorKind(ErrorKind.EXTERNAL_MODULE_DECL_SEMICOLON_TERM_EXPECTED);
return(false);
}
nextToken();
// 追加
decls.Add(new ExternalModuleDecl(identPath, kind));
}
// 設定
aModuleContext.ExternalModuleDecls = new ExternalModuleDecls(decls);
return(true);
}
//------------------------------------------------------------
/// <summary>
/// ModuleDecl:
/// "module" ModulePath ";"
/// "prototype" "module" ModulePath ";"
/// </summary>
bool parseModuleDecl(ModuleContext aModuleContext)
{
// 'prototype'
bool isProtoType = false;
if (currentToken().Value == Token.Kind.KeyPrototype)
{
isProtoType = true;
nextToken();
}
// 'module'
if (currentToken().Value != Token.Kind.KeyModule)
{
setErrorKind(ErrorKind.MODULE_DECL_KEYWORD_EXPECTED);
return(false);
}
nextToken();
// ModulePath
IdentPath modulePath = parseModulePath();
if (modulePath == null)
{
return(false);
}
// ';'
if (currentToken().Value != Token.Kind.OpSemicolon)
{
setErrorKind(ErrorKind.MODULE_DECL_SEMICOLON_TERM_EXPECTED);
return(false);
}
nextToken();
// ModuleDeclを作成
aModuleContext.ModuleDecl = new ModuleDecl(modulePath, isProtoType);
return(true);
}
//------------------------------------------------------------
// コンストラクタ。
public InheritType(IdentPath aTypeIdentPath)
{
IdentPath = aTypeIdentPath;
}
//------------------------------------------------------------
// コンストラクタ。
public ModuleDecl(IdentPath aPath, bool aIsProtoType)
{
IdentifierPath = aPath;
IsProtoType = aIsProtoType;
}
//------------------------------------------------------------
// コンストラクタ。
public ExternalModuleDecl(IdentPath aPath, Kind aKind)
{
mIdentifierPath = aPath;
mKind = aKind;
}
//------------------------------------------------------------
// StaticTypeDef
bool parseStaticTypeStandardDef(StaticTypeDef aTD, bool aIsProtoType)
{
// 最初はIdentifierのはず
if (currentToken().Value != Token.Kind.Identifier)
{
setErrorKind(ErrorKind.STATIC_TYPE_DEF_IDENTIFIER_EXPECTED);
return(false);
}
aTD.Ident = new Identifier(currentToken());
nextToken();
if (currentToken().Value == Token.Kind.OpColon)
{// 継承
if (aTD.TypeKind != StaticTypeDef.Kind.Class ||
aTD.TypeKind != StaticTypeDef.Kind.Interface
)
{
setErrorKind(ErrorKind.STATIC_TYPE_DEF_ONLY_CLASS_OR_INTERFACE_CAN_IMPLEMENT_INTERFACE);
return(false);
}
nextToken();
// IdentifierPath , のループ
while (true)
{
// 継承するインターフェースのパス
IdentPath typeIdentPath = parseIdentPath();
if (typeIdentPath == null)
{
setErrorKind(ErrorKind.STATIC_TYPE_DEF_IDENTIFIER_EXPECTED);
return(false);
}
// 登録
aTD.InheritTypeList.Add(new InheritType(typeIdentPath));
if (currentToken().Value == Token.Kind.OpColon)
{// 次のインターフェースへ
nextToken();
continue;
}
break;
}
}
// 開始括弧
if (currentToken().Value != Token.Kind.OpLCurly)
{
setErrorKind(ErrorKind.STATIC_TYPE_DEF_LCURLY_EXPECTED);
return(false);
}
nextToken();
// 内部実装ループ
{
Protection defaultProtection = Protection.Public;
while (currentToken().Value != Token.Kind.OpRCurly &&
currentToken().Value != Token.Kind.EOF
)
{
// Protection
if (parseTypeProtection(currentToken()) != Protection.Unknown &&
currentToken().Next.Value == Token.Kind.OpColon
)
{// DefaultProtectionChange
defaultProtection = parseTypeProtection(currentToken());
if (!checkProtection(defaultProtection, aIsProtoType))
{
return(false);
}
nextToken();
nextToken();
continue;
}
// Symbol
SymbolDef symbolDef = parseSymbolDef(aTD, defaultProtection, aIsProtoType);
if (symbolDef == null)
{
return(false);
}
aTD.SymbolDefList.Add(symbolDef);
}
}
// 終端括弧
if (currentToken().Value != Token.Kind.OpRCurly)
{
setErrorKind(ErrorKind.STATIC_TYPE_DEF_RCURLY_EXPECTED);
return(false);
}
nextToken();
// セミコロン
if (currentToken().Value != Token.Kind.OpSemicolon)
{
setErrorKind(ErrorKind.STATIC_TYPE_DEF_SEMICOLON_EXPECTED);
return(false);
}
nextToken();
return(true);
}
//------------------------------------------------------------
// ユーザー定義型として初期化。
public TypePath(IdentPath aIP)
{
IdentPath = aIP;
}
