public override void BreakApartParsedTokens()
{
SynLog.Log($"Breaking apart type {this.typeName}.");
SynLog.LogFragments(this.declarationTokens);
// For struct structname { ... }, remove everything except the ...
this.declarationTokens.RemoveRange(0, 3);
int lastIdx = this.declarationTokens.Count - 1;
if (this.declarationTokens[lastIdx].MatchesSymbol(";"))
{
this.declarationTokens.RemoveRange(lastIdx - 1, 2);
}
else
{
this.declarationTokens.RemoveRange(lastIdx, 1);
}
while (this.declarationTokens.Count > 0)
{
if (this.declarationTokens[0].MatchesSymbol(";") == true)
{
this.declarationTokens.RemoveAt(0);
continue;
}
SynRegion rgn = SynRegion.Parse(this, this.declarationTokens);
if (rgn != null)
{
this.regions.Add(rgn.name, rgn);
continue;
}
SynFuncDecl fnParse =
SynFuncDecl.Parse(
this,
this.declarationTokens,
this.typeName,
false,
SynFuncDecl.ParseType.StructContext);
if (fnParse != null)
{
this.AddFunction(fnParse);
continue;
}
SynVarValue varParse = SynVarValue.ParseBodyVar(this.declarationTokens, SynVarValue.OuterScope.Struct);
if (varParse != null)
{
this.AddVariable(varParse);
continue;
}
}
}
public void ParseContext(List <Token> tokens)
{
SynLog.LogHeader("Starting Parse Content");
SynLog.Log("\tTokens:");
SynLog.Log(tokens);
// Get param globals first
//
//////////////////////////////////////////////////
while (tokens.Count > 0)
{
SynVarValue parsedParam = SynVarValue.ParseExposedParam(tokens);
if (parsedParam == null)
{
break;
}
this.AddVariable(parsedParam);
}
// Parse Sections
//
//////////////////////////////////////////////////
int idx = 0;
while (tokens.Count > 0)
{
// Get rid of stray parenthesis
if (tokens[idx].Matches(TokenType.tySymbol, ";") == true)
{
tokens.RemoveAt(0);
continue;
}
// Struct parsing
if (tokens[0].Matches(TokenType.tyWord, "struct") == true)
{
SynStruct sst = SynStruct.Parse(this, tokens);
if (sst != null)
{
this.AddType(sst);
continue;
}
}
// Function parsing
if (tokens[0].Matches(TokenType.tyWord, "entry") == true)
{
SynFuncDecl sfd = SynFuncDecl.Parse(this, tokens, "", true, SynFuncDecl.ParseType.Entry);
sfd.callType = SynFuncDecl.CallType.Entry;
if (sfd != null)
{
this.AddFunction(sfd);
continue;
}
else
{
throw new System.Exception("entry keyword not part of valid function.");
}
}
SynFuncDecl synthFn =
SynFuncDecl.Parse(
this, tokens,
"",
true,
SynFuncDecl.ParseType.RootContext);
if (synthFn != null)
{
this.AddFunction(synthFn);
continue;
}
SynVarValue synthVar = SynVarValue.ParseBodyVar(tokens, SynVarValue.OuterScope.Global);
if (synthVar != null)
{
this.AddVariable(synthVar);
continue;
}
throw new System.Exception("Unknown token while parsing root context.");
}
// Verify Structs
//
//////////////////////////////////////////////////
SynLog.LogHeader("Verifying types");
while (true)
{
TypeConsolidate tc = this.ResolveStaticTypeAlignments();
if (tc == TypeConsolidate.UndeterminedNoChange)
{
throw new System.Exception("Could not resolve all types");
}
if (tc == TypeConsolidate.AllDetermined)
{
break;
}
}
SynLog.Log("Finished verifying struct successfully.");
// Gathering globals
//
//////////////////////////////////////////////////
SynLog.LogHeader("Gathering globals");
List <SynVarValue> globals = new List <SynVarValue>();
foreach (SynScope s in this.EnumerateScopes())
{
s.RegisterGlobals(globals);
}
this.totalGlobalBytes = 0;
foreach (SynVarValue svv in globals)
{
svv.alignmentOffset = this.totalGlobalBytes;
int byteSz = svv.type.GetByteSize();
if (byteSz <= 0)
{
throw new SynthExceptionImpossible("Data type for global variable is zero in size.");
}
SynLog.Log($"Added {svv.varName} to globals at offset {svv.alignmentOffset}");
this.totalGlobalBytes += byteSz;
}
SynLog.Log($"Total global variable space is {this.totalGlobalBytes}.");
// Verify Functions
//
//////////////////////////////////////////////////
SynLog.LogHeader("Verifying After function and variable collection pass.");
this.Validate_AfterTypeAlignment(0);
SynLog.Log("Finished verifying functions successfully.");
}