public void Emit(string fnName, EmitFlags f, Formatter fmt, CodeFormatter w, TypeReferenceFormatter t)
{
bool emitStorage = (f & EmitFlags.ArgumentKind) == EmitFlags.ArgumentKind;
if (ParametersValid)
{
if (emitStorage)
{
if (HasVoidReturn)
{
fmt.Write("void ");
}
else
{
w.WriteFormalArgumentType(ReturnValue, emitStorage);
fmt.Write(" ");
}
fmt.Write("{0}(", fnName);
}
else
{
if (HasVoidReturn)
{
fmt.Write("void {0}", fnName);
}
else
{
t.WriteDeclaration(ReturnValue.DataType, fnName); //$TODO: won't work with fn's that return pointers to functions or arrays.
}
fmt.Write("(");
}
var sep = "";
if (Parameters != null)
{
IEnumerable <Identifier> parms = this.IsInstanceMetod
? Parameters.Skip(1)
: Parameters;
foreach (var p in parms)
{
fmt.Write(sep);
sep = ", ";
w.WriteFormalArgument(p, emitStorage, t);
}
}
fmt.Write(")");
}
else
{
fmt.WriteKeyword("define");
fmt.Write(" ");
fmt.Write(fnName);
}
if ((f & EmitFlags.LowLevelInfo) == EmitFlags.LowLevelInfo)
{
fmt.WriteLine();
fmt.Write("// stackDelta: {0}; fpuStackDelta: {1}; fpuMaxParam: {2}", StackDelta, FpuStackDelta, FpuStackArgumentMax);
fmt.WriteLine();
}
}
public string ToString(string name, EmitFlags flags = EmitFlags.ArgumentKind)
{
StringWriter sw = new StringWriter();
TextFormatter f = new TextFormatter(sw);
CodeFormatter cf = new CodeFormatter(f);
TypeFormatter tf = new TypeFormatter(f);
Emit(name, flags, f, cf, tf);
return(sw.ToString());
}
/// <summary>
///
/// </summary>
/// <param name="outputFile"></param>
/// <param name="flags"></param>
public void ToADIF(string outputFile, EmitFlags flags = EmitFlags.None)
{
if (string.IsNullOrEmpty(outputFile))
{
throw new ArgumentException("Output file is required.", nameof(outputFile));
}
var adif = ToADIF(flags);
if (!string.IsNullOrEmpty(adif))
{
File.WriteAllText(outputFile, adif);
}
}
public void Emit(string fnName, EmitFlags f, Formatter fmt, CodeFormatter w, TypeFormatter t)
{
bool emitStorage = (f & EmitFlags.ArgumentKind) == EmitFlags.ArgumentKind;
if (emitStorage)
{
if (ReturnValue != null)
{
w.WriteFormalArgumentType(ReturnValue, emitStorage);
fmt.Write(" ");
}
else
{
fmt.Write("void ");
}
fmt.Write("{0}(", fnName);
}
else
{
if (ReturnValue == null)
{
fmt.Write("void {0}", fnName);
}
else
{
t.Write(ReturnValue.DataType, fnName); //$TODO: won't work with fn's that return pointers to functions or arrays.
}
fmt.Write("(");
}
var sep = "";
if (Parameters != null)
{
for (int i = 0; i < Parameters.Length; ++i)
{
fmt.Write(sep);
sep = ", ";
w.WriteFormalArgument(Parameters[i], emitStorage, t);
}
}
fmt.Write(")");
if ((f & EmitFlags.LowLevelInfo) == EmitFlags.LowLevelInfo)
{
fmt.WriteLine();
fmt.Write("// stackDelta: {0}; fpuStackDelta: {1}; fpuMaxParam: {2}", StackDelta, FpuStackDelta, FpuStackArgumentMax);
fmt.WriteLine();
}
}
public void Emit(string fnName, EmitFlags f, Formatter fmt)
{
Emit(fnName, f, fmt, new CodeFormatter(fmt), new TypeFormatter(fmt));
}
public void Emit(string fnName, EmitFlags f, TextWriter writer)
{
Emit(fnName, f, new TextFormatter(writer));
}
public void Emit(string fnName, EmitFlags f, TextWriter writer)
{
Emit(fnName, f, new TextFormatter(writer));
}
public void Emit(string fnName, EmitFlags f, Formatter fmt, CodeFormatter w, TypeFormatter t)
{
bool emitStorage = (f & EmitFlags.ArgumentKind) == EmitFlags.ArgumentKind;
if (emitStorage)
{
if (ReturnValue != null)
{
w.WriteFormalArgumentType(ReturnValue, emitStorage);
fmt.Write(" ");
}
else
{
fmt.Write("void ");
}
fmt.Write("{0}(", fnName);
}
else
{
if (ReturnValue == null)
fmt.Write("void {0}", fnName);
else
{
t.Write(ReturnValue.DataType, fnName); //$TODO: won't work with fn's that return pointers to functions or arrays.
}
fmt.Write("(");
}
var sep = "";
if (Parameters != null)
{
for (int i = 0; i < Parameters.Length; ++i)
{
fmt.Write(sep);
sep = ", ";
w.WriteFormalArgument(Parameters[i], emitStorage, t);
}
}
fmt.Write(")");
if ((f & EmitFlags.LowLevelInfo) == EmitFlags.LowLevelInfo)
{
fmt.WriteLine();
fmt.Write("// stackDelta: {0}; fpuStackDelta: {1}; fpuMaxParam: {2}", StackDelta, FpuStackDelta, FpuStackArgumentMax);
fmt.WriteLine();
}
}
public void Emit(string fnName, EmitFlags f, Formatter fmt)
{
Emit(fnName, f, fmt, new CodeFormatter(fmt), new TypeFormatter(fmt, true));
}
/// <summary>
///
/// </summary>
public string ToADIF(EmitFlags flags = EmitFlags.None)
{
var formatString = (flags & EmitFlags.LowercaseTagNames) == EmitFlags.LowercaseTagNames ? "a" : "A";
if ((flags & EmitFlags.MirrorOperatorAndStationCallSign) == EmitFlags.MirrorOperatorAndStationCallSign)
{
if (QSOs != null)
{
for (var q = 0; q < QSOs.Count; q++)
{
if (QSOs[q] != null)
{
var qso = QSOs[q];
if (qso.Contains(TagNames.Operator) && !qso.Contains(TagNames.StationCallSign))
{
var stationCallSignTag = TagFactory.TagFromName(TagNames.StationCallSign);
var operatorTag = qso[qso.IndexOf(TagNames.Operator)];
stationCallSignTag.SetValue(operatorTag.Value);
QSOs[q].Insert(QSOs[q].IndexOf(TagNames.Operator), stationCallSignTag);
}
else if (!qso.Contains(TagNames.Operator) && qso.Contains(TagNames.StationCallSign))
{
var operatorTag = TagFactory.TagFromName(TagNames.Operator);
var stationCallSignTag = qso[qso.IndexOf(TagNames.StationCallSign)];
operatorTag.SetValue(stationCallSignTag.Value);
QSOs[q].Insert(QSOs[q].IndexOf(TagNames.StationCallSign), operatorTag);
}
}
}
}
if ((flags & EmitFlags.AddCreatedTimestampIfNotPresent) == EmitFlags.AddCreatedTimestampIfNotPresent)
{
if (Header == null)
{
Header = new ADIFHeader();
}
if (!Header.Contains(TagNames.CreatedTimestamp))
{
Header.Add(new CreatedTimestampTag(DateTime.UtcNow));
}
}
if ((flags & EmitFlags.AddProgramIdIfNotPresent) == EmitFlags.AddProgramIdIfNotPresent)
{
if (Header == null)
{
Header = new ADIFHeader();
}
if (!Header.Contains(TagNames.ProgramId))
{
Header.Add(new ProgramIdTag(Values.DEFAULT_PROGRAM_ID));
}
}
}
return(ToString(formatString, CultureInfo.CurrentCulture));
}
