Exp TranslateDeclaration(FunctionDeclaration dec)
{
List <SymbolTable.Symbol> list = new List <SymbolTable.Symbol>();
for (FunctionDeclaration d = dec; d != null; d = d.Next)
{
if (Env.ValueEnvironment[d.Name] != null && Env.ValueEnvironment[d.Name] is StandardFunctionEntry)
{
Error.Report(d.Pos, "Function in standard libaray cannot be redefined");
}
else if (list.Contains(d.Name))
{
Error.Report(d.Pos, "Function cannot be redefined in a sequence");
}
else
{
list.Add(d.Name);
Types.Type result = d.Result == null ? Types.Type._void : TranslateType(d.Result).Actual;
Types.RECORD formals = TranslateTypeFields(d.Param);
Label label = new Label(d.Name + "_" + Count++.ToString());
Translate.Level level = new Translate.Level(Level, label, BoolList.BuildFromFieldList(d.Param));
Env.ValueEnvironment[d.Name] = new FunctionEntry(level, label, formals, result);
}
}
for (FunctionDeclaration d = dec; d != null; d = d.Next)
{
FunctionEntry function = Env.ValueEnvironment[d.Name] as FunctionEntry;
Env.ValueEnvironment.BeginScope();
Env.LoopEnvironment.BeginScope();
Translate.Level backup = Level;
Level = function.Level;
Translate.AccessList al = Level.Formals.Tail;
for (FieldList field = d.Param; field != null; field = field.Tail, al = al.Tail)
{
Types.Type type = Env.TypeEnvironment[field.Type] as Types.Type;
if (type == null)
{
Error.Report(field.Pos, "Undefined type '" + field.Name + "'");
}
else
{
Translate.Access access = new Translate.Access(Level, al.Head.Acc);
Env.ValueEnvironment[field.Name] = new VariableEntry(access, type.Actual);
}
}
ExpressionType et = TranslateExpression(d.Body);
Translate.ProcessEntryExit(Level, et.Exp, !(et.Type.CoerceTo(Types.Type._void)));
if (!et.Type.CoerceTo((Env.ValueEnvironment[d.Name] as FunctionEntry).Result))
{
Error.Report(d.Result != null ? d.Result.Pos : d.Body.Pos, "Type mismatched for function return value");
}
Env.ValueEnvironment.EndScope();
Env.LoopEnvironment.EndScope();
Level = backup;
}
return(Translate.TranslateNoOp());
}
public override List <string> ExecuteSemanticAction(Stack <SemanticRecord> semanticRecordTable, Stack <SymbolTable> symbolTable, IToken lastToken)
{
SymbolTable currentTable = symbolTable.Peek();
Entry funcEntry = new FunctionEntry(currentTable, lastToken.getSemanticName(), new ClassEntry(""));
symbolTable.Push(funcEntry.getChild());
return(new List <string>());
}
public async Task EmitArgumentWrites(CodegenContext context, FunctionEntry function)
{
var args = function.Type.Arguments;
for (int i = 0; i < args.Count; ++i)
{
var arg = args[i];
await context.EmitLine($"{CodeGenerator.DataBuffer}.write<{arg.Type}>({arg.Name});");
}
}
public override List <string> ExecuteSemanticAction(Stack <SemanticRecord> semanticRecordTable, Stack <SymbolTable> symbolTable, IToken lastToken, MoonCodeResult moonCode)
{
SymbolTable currentTable = symbolTable.Peek();
LinkedList <Variable> foundParameters = new LinkedList <Variable>();
bool entryCreated = false;
string funcName = string.Empty;
List <string> errors = new List <string>();
// Iterate over the semantic stack and consume records relevant to this function
while (!entryCreated)
{
SemanticRecord topRecord = semanticRecordTable.Pop();
// Handle the record depending on its type
switch (topRecord.recordType)
{
case RecordTypes.Variable:
// Encountered paramenters
foundParameters.AddFirst(topRecord.getVariable());
break;
case RecordTypes.IdName:
// The name of this function
funcName = topRecord.getValue();
break;
case RecordTypes.TypeName:
// If we encounter a type we are done collecting and can create the entry
FunctionEntry funcEntry = new FunctionEntry(currentTable, funcName, topRecord.getType());
funcEntry.AddParameters(foundParameters);
// Push the function's scope to the stack of symbol tables
symbolTable.Push(funcEntry.getChild());
entryCreated = true;
break;
default:
// This should only fail if there is an error in the grammar.
errors.Add("Grammar error, parsed rule that placed unexpected character on semantic stack");
break;
}
}
return(errors);
}
public override object CreateNewInstance(SelectItem item)
{
FunctionEntry functionEntry = item.Value as FunctionEntry;
Debug.Assert(functionEntry != null);
ActivityFactory factory = Parent.EditingContext.Services.GetService <ActivityFactory>();
Activity function = factory.CreateActivity(functionEntry.Create, Parent.GetModelProperty());
// Create InArgument instance wrapping the activity
Type genericType = typeof(InArgument <>).MakeGenericType(functionEntry.ReturnType);
InArgument argument = Activator.CreateInstance(genericType, function) as InArgument;
return(argument);
}
public string GenerateTypelessArgumentList(FunctionEntry function)
{
StringBuilder build = new StringBuilder();
var args = function.Type.Arguments;
for (int i = 0; i < args.Count; ++i)
{
var arg = args[i];
build.Append($"{arg.Name}");
if (i < args.Count - 1)
{
build.Append(", ");
}
}
return(build.ToString());
}
protected override double RunDisruptorPass(int passNumber)
{
stepThreeFunctionHandler.reset();
Task.Factory.StartNew(stepOneBatchConsumer.Run);
Task.Factory.StartNew(stepTwoBatchConsumer.Run);
Task.Factory.StartNew(stepThreeBatchConsumer.Run);
var stopwatch = new Stopwatch();
stopwatch.Start();
long operandTwo = OPERAND_TWO_INITIAL_VALUE;
for (long i = 0; i < ITERATIONS; i++)
{
FunctionEntry entry = producerBarrier.NextEntry();
entry.OperandOne = i;
entry.OperandTwo = operandTwo--;
producerBarrier.Commit(entry);
}
long expectedSequence = ringBuffer.Cursor;
while (stepThreeBatchConsumer.Sequence < expectedSequence)
{
// busy spin
}
stopwatch.Stop();
double opsPerSecond = ITERATIONS / stopwatch.Elapsed.TotalSeconds;
stepOneBatchConsumer.Halt();
stepTwoBatchConsumer.Halt();
stepThreeBatchConsumer.Halt();
Assert.AreEqual(expectedResult, stepThreeFunctionHandler.getStepThreeCounter());
return(opsPerSecond);
}
private Expression.Expression ConvertFunction(FunctionNode node)
{
if (FunctionTable.IsValidFunction(node.FunctionName))
{
//check number of arguments
FunctionEntry entry = FunctionTable.GetFunctionEntry(node.FunctionName);
if (entry.ArgNumber != node.Arguments.Count)
{
compilerErrors.Add(new ErrorMessage($"{entry.ArgNumber.ToString()} аргументов ожидалось в функции \"{node.FunctionName}", node.Line, node.Position));
return(null);
}
List <Expression.Expression> arguments = new List <Expression.Expression>();
foreach (var argument in node.Arguments)
{
arguments.Add(ConvertToExpression(argument));
}
return(new Function(entry, arguments));
}
else
{
compilerErrors.Add(new ErrorMessage($"Неизвестная функция \"{node.FunctionName}\"", node.Line, node.Position));
return(null);
}
}
// Get the parameters for a function
private IEnumerable <Entry> GetParameters(FunctionEntry enty)
{
return(enty.getChild().GetEntries().Where(x => x.getKind() == EntryKinds.parameter));
}
