public void Parse()
{
globalNamespace = currentNamespace = new Namespace
{
name = "Global"
};
globalNamespace.classes.Add(globalNamespace.GlobalClass);
while (true)
{
Back:
if (CurrentIs('\0'))
{
return;
}
string word = GetWord();
switch (word)
{
case "namespace":
case "module":
string name = GetWord();
if (!GoForwardIf('{'))
{
throw new Exception();
}
var @namespace = new Namespace
{
name = name,
UpNamespace = currentNamespace
};
@namespace.classes.Add(@namespace.GlobalClass);
currentNamespace.namespaces.Add(@namespace);
currentNamespace = @namespace;
break;
case "declare":
case "export":
goto Back;
case "const":
case "function":
case "var":
case "let":
GoForward(-word.Length);
currentClass = currentNamespace.GlobalClass;
if (ParseClassLine())
{
throw new Exception();
}
break;
case "type":
currentClass = null;
string typeName = TypeDeclName = GetWord();
bool generic = CurrentIs('<');
Inherit.Clear();
GenericDeclaration genericDeclaration = ParseGenericDeclaration();
if (!GoForwardIf('='))
{
throw new Exception();
}
Inherit.Add(genericDeclaration);
var type = ParseType();
bool created = false;
if (type is NamedType namedType)
{
if (namedType.Name == typeName)
{
created = true;
}
}
if (generic && created)
{
currentNamespace.classes.Last(v => v.name == typeName).GenericDeclaration = genericDeclaration;
}
if (!created)
{
currentNamespace.ttypes.Add(new TTypeDeclaration
{
Name = typeName,
Type = type,
GenericDeclaration = genericDeclaration
});
}
if (!GoForwardIf(';'))
{
throw new Exception();
}
break;
case "interface":
case "class":
var interfaceName = GetWord();
var implements = new List <Type>();
var genericDeclaration2 = ParseGenericDeclaration();
Inherit.Clear();
Inherit.Add(genericDeclaration2);
while (GoForwardIf("extends") || GoForwardIf("implements"))
{
do
{
implements.Add(ParseType());
}while (GoForwardIf(','));
}
Details details = ParseComment();
TypeDeclaration @class;
currentNamespace.classes.Add(@class = ParseClass(interfaceName, genericDeclaration2, implements, word == "interface"));
@class.details = details;
break;
case "enum":
string enumName = GetWord();
var enumDecl = new TypeDeclaration
{
name = enumName,
fields = new List <Field>(),
kind = TypeDeclaration.Kind.Enum,
upperNamespace = currentNamespace
};
if (!GoForwardIf('{'))
{
throw new Exception();
}
while (!GoForwardIf('}'))
{
var key = GetWord();
if (string.IsNullOrWhiteSpace(key))
{
throw new Exception();
}
enumDecl.fields.Add(new Field
{
@readonly = true,
@static = true,
@name = key,
type = new NamedType
{
Name = currentClass.name
}
});
GoForwardIf(',');
}
currentNamespace.classes.Add(enumDecl);
break;
case "":
if (GoForwardIf('}'))
{
currentNamespace = currentNamespace.UpNamespace;
}
break;
}
LastComment = null;
}
}
public Type ParseTypeLevel3()
{
Type resultType = null;
string word = GetWord();
switch (word)
{
case "":
case "new":
if (CurrentIs('(') || CurrentIs('<'))
{
bool function = true;
if (!CurrentIs('<'))
{
CreateRestorePoint();
GoForwardUntilEndBracket('(', ')');
function = GoForwardIf("=>");
Restore();
}
if (function)
{
string org = TypeDeclName;
GenericDeclaration genericDeclaration = ParseGenericDeclaration();
var newGen = new HashSet <string>();
foreach (var item in Inherit)
{
item.Generics.ForEach(v => newGen.Add(v));
}
genericDeclaration.Generics.AddRange(newGen);
GoForwardOne();
Inherit.Add(genericDeclaration);
var arguments = ParseArguments();
Inherit.RemoveAt(Inherit.Count - 1);
if (!GoForwardIf("=>"))
{
throw new Exception();
}
org += "_ReturnType";
TypeDeclName = org;
var returnType = ParseType();
MethodOrDelegate newType;
(currentClass?.delegates ?? currentNamespace.delegates).Add(newType = new MethodOrDelegate
{
Arguments = arguments,
ReturnType = returnType,
Name = TypeDeclName,
GenericDeclaration = genericDeclaration
});
resultType = new NamedType
{
Name = org,
ReferenceDelegates = newType,
Generics = new Generics
{
Generic = newGen.ToList().ConvertAll <Type>(v => new NamedType
{
Name = v
})
}
};
}
else
{
GoForwardOne();
resultType = ParseType();
if (!GoForwardIf(')'))
{
throw new Exception();
}
}
return(resultType);
}
else if (CurrentIs('{'))
{
string org = TypeDeclName;
TypeDeclaration created;
var old = currentClass;
(currentClass?.nested ?? currentNamespace.classes).Add(created = ParseClass(org, new GenericDeclaration(), new List <Type>(), true));
currentClass = old;
return(new NamedType
{
Generics = new Generics
{
Generic = new List <Type>()
},
Name = org,
TypeDeclaration = created
});
}
else if (GoForwardIf('['))
{
List <Type> types = new List <Type>();
string org = TypeDeclName;
int n = 0;
do
{
TypeDeclName = org + "_TupleParam" + n;
types.Add(ParseType());
++n;
}while (GoForwardIf(','));
if (!GoForwardIf(']'))
{
throw new Exception();
}
return(new NamedType
{
Generics = new Generics
{
Generic = types
},
Name = "Tuple"
});
}
else if (CurrentIs('"') || CurrentIs('\''))
{
var oldIdx = index;
GoForwardUntilEndBracket('"', '\'', '"', '\'');
int gIdx = index - 2 - oldIdx;
var stringLiteral = gIdx <= 0 ? string.Empty : ParseString.Substring(oldIdx + 1, gIdx);
return(CreateStringLiteralType(stringLiteral));
} //
throw new NotImplementedException();
default:
List <string> dotsSplit = word.Split('.').ToList();
string shortName = dotsSplit[dotsSplit.Count - 1];
dotsSplit.RemoveAt(dotsSplit.Count - 1);
List <Type> generics = new List <Type>();
if (GoForwardIf('<'))
{
do
{
generics.Add(ParseType());
}while (GoForwardIf(','));
if (!GoForwardIf('>'))
{
throw new Exception();
}
}
if (GoForwardIf("is"))
{
shortName = "boolean";
dotsSplit.Clear();
ParseType();
}
return(new NamedType
{
Name = shortName,
PreDots = dotsSplit.ToArray(),
Generics = new Generics
{
Generic = generics
}
});
}
}