public override object VisitStatementSeq([NotNull] SLangGrammarParser.StatementSeqContext context)
{
var newScope = new Scope(scope);
scope = newScope;
cppText.WriteLine();
cppText.WriteLine('{');
cppText.Indent++;
foreach (var stmt in context.statement())
{
Visit(stmt);
}
cppText.Indent--;
cppText.WriteLine('}');
scope = scope?.Outer;
return(null);
}
public override object VisitStatementSeq([NotNull] SLangGrammarParser.StatementSeqContext context)
{
var newScope = new Scope(scope);
scope = newScope;
var returning = false;
foreach (var statement in context.statement())
{
var res = Visit(statement) as StatementResult;
if (res?.Returning == true || statement?.simpleStatement()?.returnC() != null)
{
returning = true;
}
}
scope = scope?.Outer;
return(new StatementResult(returning));
}
private void TranslateRoutines(SLangGrammarParser.StatementSeqContext ctx)
{
if (currentRoutine.Header != null)
{
return;
}
if (!(currentRoutine is MethodNameTableItem))
{
// write in header
WriteRoutineHeader(headerText, currentRoutine);
headerText.WriteLine(';');
}
// write to cpp
cppText.Write($"{GetStringFromType(currentRoutine.ReturnType)} ");
if (currentRoutine is MethodNameTableItem)
{
cppText.Write($"{currentType.Name}::");
}
cppText.Write(currentRoutine.Name);
WriteParameters(cppText, currentRoutine.Params);
Visit(ctx);
}
/// <summary>
/// Exit a parse tree produced by <see cref="SLangGrammarParser.statementSeq"/>.
/// <para>The default implementation does nothing.</para>
/// </summary>
/// <param name="context">The parse tree.</param>
public virtual void ExitStatementSeq([NotNull] SLangGrammarParser.StatementSeqContext context)
{
}
/// <summary>
/// Visit a parse tree produced by <see cref="SLangGrammarParser.statementSeq"/>.
/// <para>
/// The default implementation returns the result of calling <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)"/>
/// on <paramref name="context"/>.
/// </para>
/// </summary>
/// <param name="context">The parse tree.</param>
/// <return>The visitor result.</return>
public virtual Result VisitStatementSeq([NotNull] SLangGrammarParser.StatementSeqContext context)
{
return(VisitChildren(context));
}
private void ValidateContext(SLangGrammarParser.ThisHeaderContext thisHeader, ITerminalNode id, SLangGrammarParser.ImportHeadContext importHead, ITerminalNode accessModifier, ITerminalNode abstractToken, ITerminalNode overrideToken, SLangGrammarParser.RoutineArgListContext routineArgList, SLangGrammarParser.TypeNameContext typeName, SLangGrammarParser.StatementSeqContext statementSeq)
{
var isMethod = thisHeader != null;
var symbol = id.Symbol;
string nameOfThis = string.Empty;
if (isMethod)
{
nameOfThis = thisHeader.Id().GetText();
ThrowIfReservedWord(nameOfThis, ModuleData.File, thisHeader.Id().Symbol);
if (importHead != null)
{
ThrowImportHeaderMethodsException(ModuleData.File, id);
}
}
var name = id.GetText();
ThrowIfReservedWord(name, ModuleData.File, symbol);
var args = Visit(routineArgList) as List <RoutineArgNameTableItem>;
ImportHeader header = null;
if (importHead != null)
{
header = Visit(importHead) as ImportHeader;
}
SlangType returnType = typeName != null?Visit(typeName) as SlangType : null;
var modifier = GetModifierByName(accessModifier.GetText());
var isAbstract = abstractToken != null;
var isOverride = overrideToken != null;
if (!isMethod && (isAbstract || isOverride))
{
ThrowRoutinesAbstractOverrideException(ModuleData.File, abstractToken ?? overrideToken);
}
if (header != null && statementSeq.statement().Length != 0)
{
ThrowImportHeaderException(ModuleData.File, id);
}
if (isMethod)
{
if (Visit(thisHeader) is SlangCustomType methodTypeIdent && methodTypeIdent.ModuleName != ModuleData.Name)
{
ThrowModuleFromOtherClassModuleException(id, ModuleData.File);
}
if (isAbstract)
{
ThrowIfAbstractMethodPrivate(modifier, ModuleData.File, id);
}
if ((args ?? throw new InvalidOperationException(nameof(args))).Any(a => a.Name == nameOfThis))
{
ThrowConfictsThisException(thisHeader.Id(), ModuleData.File);
}
var classData = Visit(thisHeader) as SlangCustomType;
var foundClass = Table.FindClass(classData);
if (foundClass.Methods.ContainsKey(name))
{
ThrowMethodSignatureExistsException(classData, id, ModuleData.File);
}
if (isAbstract && statementSeq.statement().Length != 0)
{
ThrowAbstractEmptyException(id, ModuleData.File);
}
var method = new MethodNameTableItem
{
AccessModifier = modifier,
Column = symbol.Column,
Header = header,
IsAbstract = isAbstract,
IsOverride = isOverride,
Line = symbol.Line,
Name = name,
NameOfThis = nameOfThis,
Params = args,
ReturnType = returnType
};
if (modifier == AccessModifier.Public)
{
CheckLevelAccessForMethods(method, id, classData);
}
foundClass.CheckRoutineConflicts(moduleItem.ModuleData, method);
foundClass.Methods.Add(method.Name, method);
}
else
{
if (moduleItem.Routines.ContainsKey(name))
{
ThrowRoutineExistsException(id, ModuleData.File);
}
var routine = new RoutineNameTableItem
{
AccessModifier = modifier,
Column = symbol.Column,
Line = symbol.Line,
Header = header,
Name = name,
Params = args,
ReturnType = returnType
};
if (modifier == AccessModifier.Public)
{
CheckLevelAccessForRoutines(routine, id, name);
}
moduleItem.CheckCommonNamesConflicts(routine.Name, routine.Line, routine.Column);
moduleItem.Routines.Add(routine.Name, routine);
}
}
