private void CreateFunctions_Function(
ref TranslationUnitData transUnit, ES_NamespaceData.Builder namespaceBuilder,
SymbolStack <FrontendSymbol> symbols, SourceData unitSrc,
ES_TypeInfo *parentType, ES_AstFunctionDefinition funcDef
)
{
Debug.Assert(Environment is not null);
Debug.Assert(EnvironmentBuilder is not null);
var sourceUnit = transUnit.Name;
var idPool = Environment.IdPool;
// Get the namespace and function names.
var funcName = Environment.IdPool.GetIdentifier(funcDef.Name.Text.Span);
// Get the fully-qualified name.
ES_FullyQualifiedName fullyQualifiedName;
if (parentType == null)
{
var namespaceName = namespaceBuilder.NamespaceData.NamespaceName;
fullyQualifiedName = new ES_FullyQualifiedName(namespaceName, funcName);
}
else
{
using var namespaceBytes = UnmanagedArray <byte> .GetArray(parentType->Name.NamespaceName.Length + 2 + parentType->Name.TypeName.Length);
var span = namespaceBytes.Span;
parentType->Name.NamespaceName.Span.CopyTo(span);
span = span [parentType->Name.NamespaceName.Length..];
private void CreateTypes(ref TranslationUnitData transUnit)
{
var idPool = Environment !.IdPool;
foreach (ref var astUnit in transUnit.AstUnits.Span)
{
foreach (var nm in astUnit.Ast.Namespaces)
{
ArrayPointer <byte> namespaceName;
using (var nameArr = nm.NamespaceName.ToPooledChars())
namespaceName = idPool.GetIdentifier(nameArr);
var namespaceBuilder = EnvironmentBuilder !.GetOrCreateNamespace(namespaceName);
foreach (var type in nm.Contents)
{
switch (type)
{
case ES_AstClassDefinition classDef:
CreateTypes_Aggregate(ref transUnit, namespaceBuilder, ES_TypeTag.Class, classDef);
break;
case ES_AstStructDefinition structDef:
CreateTypes_Aggregate(ref transUnit, namespaceBuilder, ES_TypeTag.Struct, structDef);
break;
case ES_AstEnumDefinition enumDef: {
var typeName = Environment !.IdPool.GetIdentifier(enumDef.Name.Text.Span);
if (namespaceBuilder.CheckTypeExists(typeName, null) != null)
{
errorList.Add(ES_FrontendErrors.GenTypeAlreadyDefined(
namespaceBuilder.NamespaceData.NamespaceNameString,
enumDef.Name.Text.Span.GetPooledString(),
enumDef.Name
));
break;
}
var builder = namespaceBuilder.GetOrCreateEnum(enumDef.AccessModifier, typeName, transUnit.Name);
EnvironmentBuilder !.PointerAstMap.Add((IntPtr)builder.EnumData, enumDef);
break;
}
case ES_AstFunctionDefinition:
// Functions are handled in a pass of their own.
break;
default:
throw new NotImplementedException("Node type not implemented yet.");
}
}
}
}
}
private void CreateFunctions(ref TranslationUnitData transUnit)
{
var idPool = Environment !.IdPool;
foreach (ref var astUnit in transUnit.AstUnits.Span)
{
foreach (var nm in astUnit.Ast.Namespaces)
{
var symbols = astUnit.Symbols;
var unitSrc = astUnit.SourceData;
ArrayPointer <byte> namespaceName;
using (var nameArr = nm.NamespaceName.ToPooledChars())
namespaceName = idPool.GetIdentifier(nameArr);
var namespaceBuilder = EnvironmentBuilder !.GetOrCreateNamespace(namespaceName);
symbols.Push();
ImportNamespaceSymbols(astUnit.Symbols, namespaceBuilder.NamespaceData);
foreach (var type in nm.Contents)
{
switch (type)
{
case ES_AstFunctionDefinition funcDef: {
CreateFunctions_Function(
ref transUnit, namespaceBuilder,
symbols, unitSrc,
null, funcDef
);
break;
}
// [TODO] Once we've got everything else working with aggregates, we need to traverse
// these to create their functions.
case ES_AstClassDefinition classDef:
throw new NotImplementedException("[TODO] Classes not implemented yet.");
case ES_AstStructDefinition structDef:
break;
// These are ignored.
case ES_AstEnumDefinition enumDef:
break;
default:
throw new NotImplementedException("Node type not implemented.");
}
}
symbols.Pop();
}
}
}
private void CreateTypes_Aggregate(
ref TranslationUnitData transUnit, ES_NamespaceData.Builder namespaceBuilder,
ES_TypeTag type, ES_AstAggregateDefinition typeDef
)
{
var namespaceName = namespaceBuilder.NamespaceData.NamespaceName;
var typeName = Environment !.IdPool.GetIdentifier(typeDef.Name.Text.Span);
if (namespaceBuilder.CheckTypeExists(typeName, null) != null)
{
errorList.Add(ES_FrontendErrors.GenTypeAlreadyDefined(
namespaceBuilder.NamespaceData.NamespaceNameString,
typeDef.Name.Text.Span.GetPooledString(),
typeDef.Name
));
return;
}
ES_TypeInfo *typeData = null;
if (type == ES_TypeTag.Class)
{
var classBuilder = namespaceBuilder.GetOrCreateClass(typeDef.AccessModifier, typeName, transUnit.Name);
typeData = &classBuilder.ClassData->TypeInfo;
}
else if (type == ES_TypeTag.Struct)
{
var structBuilder = namespaceBuilder.GetOrCreateStruct(typeDef.AccessModifier, typeName, transUnit.Name);
typeData = &structBuilder.StructData->TypeInfo;
}
else
{
Debug.Fail("Not implemented/supported.");
}
EnvironmentBuilder !.PointerAstMap.Add((IntPtr)typeData, typeDef);
}
