protected override void VisitClassBody(ClassBody classBody)
{
for (int i = 0, n = classBody.Body.Count; i < n; i++)
{
Visit(classBody.Body[i]);
}
}
public static Prog Load2(TextWriter outputWriter, TextWriter errorWriter, IReadOnlyList <string> rootPaths, bool checkTypes)
{
rootPaths = rootPaths.Select(Path.GetFullPath).ToList();
var prog = new Prog(outputWriter, errorWriter, checkTypes);
var modules = new List <ClassItem>();
foreach (var fp in rootPaths)
{
var codeFilesPaths = getAllCodeFiles(fp, prog.RemarkList);
var shortest = codeFilesPaths.OrderBy(cfp => cfp.Length).First();
var numSeparators = shortest.Split('\\').Length - 2;
foreach (var cfp in codeFilesPaths)
{
var startIndex = "C:\\".Length;
var f = cfp.Substring(startIndex, cfp.Length - ".ef".Length - startIndex);
var sections = f.Split('\\').Skip(numSeparators).ToList();
var es = parseFile(prog, cfp);
var moduleBody = new ClassBody(es.AsClassItems(prog.RemarkList));
addMod(sections, moduleBody, modules, prog);
}
}
var start = new FnApply(getStartQualifiedName(modules, prog.RemarkList), new FnArguments());
var seqItems = modules.Cast <SequenceItem>().Append(start).ToList();
prog.RootElement = new FnApply(
new Fn(new FnParameters(), new Sequence(seqItems)),
new FnArguments());
postProcess(prog, checkTypes);
return(prog);
}
public ReadOnlyClassBody(ClassBody classBody)
{
Classes = new ReadOnlyClassNestedClassCollection(classBody);
Constructors = new ConstructorNotSupported[0];
ConversionOperators = classBody.ConversionOperators
.ToArray(conversionOperator => new ReadOnlyConversionOperator(conversionOperator));
Delegates = classBody.NestedDelegates.ToArray(nestedDelegate => new ReadOnlyClassNestedDelegate(nestedDelegate));
Enums = classBody.NestedEnums.ToArray(nestedEnum => new ReadOnlyClassNestedEnum(nestedEnum));
Events = new ReadOnlyClassEventCollection(classBody);
Fields = new ReadOnlyClassFieldCollection(classBody);
Indexers = new ReadOnlyClassIndexerCollection(classBody);
Interfaces = classBody.NestedInterfaces.ToArray(@interface => new ReadOnlyClassNestedInterface(@interface));
Methods = new ReadOnlyClassMethodCollection(classBody);
OperatorOverloads =
classBody.BinaryOperators.Select(@operator => new ReadOnlyOperatorOverload(@operator))
.Concat(classBody.UnaryOperators.Select(@operator => new ReadOnlyOperatorOverload(@operator)))
.ToArray();
Properties = new ReadOnlyClassPropertyCollection(classBody);
if (classBody.StaticConstructor != null)
{
StaticConstructor = new ReadOnlyStaticConstructor(classBody.StaticConstructor);
}
Structs = new ReadOnlyClassNestedStructCollection(classBody);
}
public ClassDeclaration(Identifier id, PropertyKey superClass, ClassBody body)
{
Type = Nodes.ClassDeclaration;
Id = id;
SuperClass = superClass;
Body = body;
}
public ClassDeclaration(Identifier id, Expression superClass, ClassBody body)
{
Type = Nodes.ClassDeclaration;
Id = id;
SuperClass = superClass;
Body = body;
}
private static void addMod(IReadOnlyList <string> sections, ClassBody moduleBody, List <ClassItem> modules, Prog prog)
{
C.Nn(sections, moduleBody, modules, prog);
foreach (var s in sections.Skip(1))
{
var m = findParentModule(modules, s);
if (m == null)
{
modules.AddValue(new Let(new Ident(s, TokenType.Ident), new New(new ClassBody(new List <ClassItem>()))));
modules = new List <ClassItem>();
}
else
{
modules = m.ToList();
}
}
var lastSection = sections.Last();
var m2 = findParentModule(modules, lastSection);
if (m2 != null)
{
throw new Exception();
}
modules.AddValue(getNewModule(lastSection, moduleBody, prog));
}
public ClassDeclaration(Identifier?id, Expression?superClass, ClassBody body) :
base(Nodes.ClassDeclaration)
{
Id = id;
SuperClass = superClass;
Body = body;
}
public ClassExpression(
Identifier id,
Expression superClass,
ClassBody body) : base(Nodes.ClassExpression)
{
Id = id;
SuperClass = superClass;
Body = body;
}
public ReadOnlyClassEventCollection(ClassBody classBody)
{
List <ReadOnlyClassEvent> events = new List <ReadOnlyClassEvent>();
List <ReadOnlyClassEvent> eventProperties = new List <ReadOnlyClassEvent>();
this.events = events;
this.eventProperties = eventProperties;
InitializeEvents(classBody, events, eventProperties);
explicitInterfaceEvents = classBody.ExplicitInterfaceEvents.ToArray(@event => new ReadOnlyExplicitInterfaceEvent(@event));
}
private static Let getNewModule(string name, ClassBody moduleBody, Prog prog)
{
var preludeImport = new Import(new Ident("prelude", TokenType.Ident));
if (name != "prelude")
{
moduleBody.InsertImport(preludeImport);
}
return(new Let(new Ident(name, TokenType.Ident),
new New(new ClassBody(moduleBody.AsClassItems(prog.RemarkList)))));
}
private Collections.List <PropertyDeclaration> VisitClassBody(ClassBody classBody)
{
var properties = new Collections.List <PropertyDeclaration>(classBody.Body.Count);
foreach (ClassProperty classProperty in classBody.Body)
{
properties.Add(VisitClassProperty(classProperty));
}
return(properties);
}
private Node CreateClassBody(List <List <Node> > parameters)
{
parameters.CheckLength(1);
var node = new ClassBody
{
Members = parameters[0].Cast <ClassMember>().ToList()
};
node.AddChildren(node.Members?.ToArray());
return(node);
}
public void Visit(ClassBody t, IEnvironment env)
{
foreach (ASTree tree in t)
{
tree.Accept(this, env);
if (result is ErrorValue)
{
return;
}
}
result = 0;
return;
}
public ReadOnlyClassFieldCollection(ClassBody body)
{
List <ReadOnlyClassField> constants = new List <ReadOnlyClassField>();
List <ReadOnlyClassField> fields = new List <ReadOnlyClassField>();
foreach (ClassField classField in body.Fields)
{
ReadOnlyClassField field = new ReadOnlyClassField(classField);
fields.Add(field);
}
this.constants = constants;
this.fields = fields;
}
private void InitializeEvents(ClassBody classBody, List <ReadOnlyClassEvent> events, List <ReadOnlyClassEvent> eventProperties)
{
foreach (ClassEvent classEvent in classBody.Events)
{
ReadOnlyClassEvent @event = new ReadOnlyClassEvent(classEvent);
if (classEvent.IsEventProperty)
{
eventProperties.Add(@event);
}
else
{
events.Add(@event);
}
}
}
public CarFactory()
{
GetParts = new CarParts();
GetBody = new ClassBody();
}
public ReadOnlyClassIndexerCollection(ClassBody body)
{
indexers = body.Indexers.ToArray(indexer => new ReadOnlyClassIndexer(indexer));
explicitInterfaceIndexers = body.ExplicitInterfaceIndexers.ToArray(indexer => new ReadOnlyExplicitInterfaceIndexer(indexer));
}
public virtual void Visit(ClassBody body, TContext context)
{
Visit(body.Body, context);
}
public ReadOnlyClassPropertyCollection(ClassBody body)
{
properties = body.Properties.ToArray(property => new ReadOnlyClassProperty(property));
explicitInterfaceProperties = body.ExplicitInterfaceProperties.ToArray(property => new ReadOnlyExplicitInterfaceProperty(property));
}
public ReadOnlyClassMethodCollection(ClassBody body)
{
methods = body.Methods.ToArray(method => new ReadOnlyClassMethod(method));
explicitInterfaceMethods = body.ExplicitInterfaceMethods.ToArray(method => new ReadOnlyExplicitInterfaceMethod(method));
}
public ReadOnlyClassNestedClassCollection(ClassBody classBody)
{
classes = classBody.NestedClasses.ToArray(@class => new ReadOnlyClassNestedClass(@class));
}
public virtual void VistClassBody(ClassBody classBody)
{
}
public ReadOnlyClassNestedStructCollection(ClassBody classBody)
{
structs = classBody.NestedStructs.ToArray(@struct => new ReadOnlyClassNestedStruct(@struct));
}
protected internal override void VisitClassBody(ClassBody classBody)
{
VisitingClassBody?.Invoke(this, classBody);
base.VisitClassBody(classBody);
VisitedClassBody?.Invoke(this, classBody);
}
protected virtual void VisitClassBody(ClassBody classBody)
{
}
protected override void VisitClassBody(ClassBody classBody)
{
using (StartNodeObject(classBody))
Member("body", classBody.Body);
}
void InitializeDocument()
{
body = new ClassBody();
footer = new ClassFooter();
title = new ClassTitle();
}
