private static void Process_ModuleOpenParen_For(string ItemText)
{
switch (ItemText)
{
case "":
// ignoring trimmed spaces / blanks
thisModuleDeclarationText += " ";
break;
case ")":
BuildHoverState = BuildHoverStates.ModuleCloseParen;
break;
case "input":
case "output":
case "inout":
case "wire":
case "reg":
case "parameter":
// the same keywords could be used for module parameters, or variables:
BuildHoverState = BuildHoverStates.ModuleParameterNaming;
thisModuleParameterText = ItemText;
break;
default:
BuildHoverState = BuildHoverStates.UndefinedState;
break;
}
}
/// <summary>
/// InitHoverBuilder - prep for another refresh of hover item lookup
/// </summary>
public static void InitHoverBuilder()
{
// re-initialize variables to above values
VerilogVariableHoverText = new Dictionary <string, Dictionary <string, string> >
// e.g. ["led"] = "An LED."
{
{
"global",
new Dictionary <string, string> {
}
}
};
VerilogVariables = new Dictionary <string, Dictionary <string, VerilogTokenTypes> >
// e.g. ["module name"]["led"] = VerilogTokenTypes.Verilog_Variable,
{
{
"global",
new Dictionary <string, VerilogTokenTypes> {
}
}
};
thisHoverName = "";
thisVariableDeclarationText = ""; // this is only variable declaration, even if inside a module declaration
thisModuleDeclarationText = ""; // this is the full module declaration
thisModuleParameterText = "";
thisModuleName = "";
BuildHoverState = BuildHoverStates.UndefinedState;
}
/// <summary>
/// Process_XXX_For - template
/// </summary>
/// <param name="ItemText"></param>
private static void Process_XXX_For(string ItemText)
{
if (1 == 1)
{
BuildHoverState = BuildHoverStates.UndefinedState;
}
else
{
//syntax error
}
}
/// <summary>
/// Process_ModuleNamed_For
/// </summary>
/// <param name="ItemText"></param>
private static void Process_ModuleNamed_For(string ItemText)
{
switch (ItemText)
{
case "":
// trimming blanks to a single space
thisModuleDeclarationText += " ";
break;
case "(":
thisModuleDeclarationText += ItemText;
BuildHoverState = BuildHoverStates.ModuleOpenParen;
break;
default:
thisModuleDeclarationText += ItemText;
// BuildHoverState = BuildHoverStates.ModuleNamed; no state change
break;
}
}
/// <summary>
/// Process_ModuleStart_For
/// </summary>
/// <param name="ItemText"></param>
private static void Process_ModuleStart_For(string ItemText)
{
// we've found the "module" keyword, the next word should be the module name
// TODO - flag syntax error for non-variable names found
switch (ItemText)
{
case "":
// trimming blanks to a single space
thisModuleDeclarationText += " ";
break;
default:
thisModuleName = ItemText;
thisModuleDeclarationText += ItemText;
//editingBufferModuleAttributes.Add(new BufferModuleAttribute { LineStart = 0,
// ModuleName = thisModuleName });
BuildHoverState = BuildHoverStates.ModuleNamed;
break;
}
}
/// <summary>
/// Process_VariableMimicNaming_For
/// </summary>
/// <param name="ItemText"></param>
private static void Process_VariableMimicNaming_For(string ItemText)
{
// once we are naming a module parameter, we only end with a closing parenthesis, or a comman
switch (ItemText)
{
case "":
if ((lastHoverItem == "") || (lastHoverItem == "\t") || (lastHoverItem == ","))
{
// we'll ignore sequentual tabs, or alternating table-space, commas mean we are mimicing prior definition
// only one space will be used
}
else
{
thisVariableDeclarationText += " ";
}
break;
case ",":
AddHoverItem(thisModuleName, thisHoverName, thisVariableDeclarationText);
thisVariableDeclarationText = thisVariableDeclarationText.Replace(thisHoverName, "");
break;
case ";":
AddHoverItem(thisModuleName, thisHoverName, thisVariableDeclarationText);
thisVariableDeclarationText = "";
BuildHoverState = BuildHoverStates.UndefinedState;
break;
case "endmodule":
BuildHoverState = BuildHoverStates.UndefinedState;
// we're done naming a module
//AddHoverItem(thisModuleName, thisHoverName, thisModuleParameterText);
//BuildHoverState = BuildHoverStates.ModuleNamed;
//thisHoverName = "";
//thisVariableDeclarationText = "";
//thisModuleName = "";
//thisModuleParameterText = "";
break;
default:
// if we encounter a NamerKeyword during a sequence of comma-delimited vars, then this is a new type!
// e.g. input a,b, // this is input a; input b;
// output c // this is output c;
if (IsVerilogNamerKeyword(ItemText))
{
Process_UndefinedState_For(ItemText);
}
else
{
if (IsVerilogBracket(ItemText) || IsNumeric(ItemText) || IsVerilogValue(ItemText) || IsDelimiter(ItemText))
{
SetBracketContentStatus_For(ItemText);
// nothing at this time; we are still bulding the declaration part
thisVariableDeclarationText += ItemText;
}
else
{
thisHoverName = ItemText;
thisVariableDeclarationText += ItemText;
}
}
break;
}
}
/// <summary>
/// Process_VariableNaming_For
/// </summary>
/// <param name="ItemText"></param>
private static void Process_VariableNaming_For(string ItemText)
{
if (thisHoverName == "")
{
string a = "breakpoint";
// TODO - how did we wend up here? (seen during multi-thread)
//return;
}
// once we are naming a module parameter, we only end with a closing parenthesis, or a comman
switch (ItemText)
{
case "":
if ((lastHoverItem == "") || (lastHoverItem == "\t"))
{
// we'll ignore sequentual tabs, or alternating table-space
// only one space will be used
}
else
{
thisVariableDeclarationText += " ";
}
break;
case ";":
AddHoverItem(thisModuleName, thisHoverName, thisVariableDeclarationText);
thisVariableDeclarationText = ""; // reminder we do this manually, as AddHoverItem does not know *what* it is adding
BuildHoverState = BuildHoverStates.UndefinedState;
break;
case ",":
if (thisHoverName == "")
{
string a = "breakpoint";
// no hovername = nothing to do
BuildHoverState = BuildHoverStates.VariableMimicNaming; // Mimic naming is the same declaration but comma-delimited (e.g. input a,b // b has the input "mimic'd" )
}
else
{
if (IsInsideSquigglyBracket)
{
thisVariableDeclarationText += ItemText;
// BuildHoverState remains variable building
}
else
{
AddHoverItem(thisModuleName, thisHoverName, thisVariableDeclarationText);
// since we en countered a comma, we will use the same declaration text for a new name, so replace this name with a blank
thisVariableDeclarationText = thisVariableDeclarationText.Replace(thisHoverName, "");
BuildHoverState = BuildHoverStates.VariableMimicNaming; // Mimic naming is the same declaration but comma-delimited (e.g. input a,b // b has the input "mimic'd" )
}
}
break;
case "reg":
case "integer":
thisVariableDeclarationText += ItemText;
break;
case "endmodule":
// we're done naming a module
AddHoverItem(thisModuleName, thisHoverName, thisModuleParameterText);
BuildHoverState = BuildHoverStates.UndefinedState;
thisHoverName = "";
thisVariableDeclarationText = "";
thisModuleName = "";
thisModuleParameterText = "";
break;
default:
// TODO implement IsVerilogAssignment
if ((thisHoverName != "") || (ItemText == "=") || IsVerilogBracket(ItemText) || IsNumeric(ItemText) || IsVerilogValue(ItemText) || Is_BracketContent_For(thisModuleName, ItemText) || IsDelimiter(ItemText) || IsVerilogVariableSigner(ItemText))
{
// we continue building the declaration text
SetBracketContentStatus_For(ItemText);
// nothing at this time; we are still bulding the declaration part for the given thisHoverName (aka variable name)
thisVariableDeclarationText += ItemText;
}
else
{
// we found a new hover name to assign declaration text
thisHoverName = ItemText;
thisVariableDeclarationText += ItemText;
}
break;
}
}
/// <summary>
/// Process_ModuleParameterMimicNaming_For
/// </summary>
/// <param name="ItemText"></param>
private static void Process_ModuleParameterMimicNaming_For(string ItemText)
{
// once we are naming a module parameter, we only end with a closing parenthesis, or a comman
switch (ItemText)
{
case "":
if ((lastHoverItem == "") || (lastHoverItem == "\t"))
{
// we'll ignore sequentual tabs, or alternating table-space
// only one space will be used
}
else
{
thisModuleDeclarationText += " ";
}
// thisModuleParameterText += " ";
break;
case "\t":
if ((lastHoverItem == "") || (lastHoverItem == "\t"))
{
// we'll ignore sequentual tabs, or alternating table-space
// only one space will be used
}
else
{
thisModuleParameterText += " ";
}
break;
case ")":
thisModuleDeclarationText += ItemText;
AddHoverItem(thisModuleName, thisModuleName, thisModuleDeclarationText);
// also add an individual parameter as needed
AddHoverItem(thisModuleName, thisHoverName, thisModuleParameterText);
thisModuleParameterText = ""; // upon the close parenthesis, no more module parameters. we might try to re-add the last param during syntax errot (e.g. traling comma immediately followed by closing parenthesis
BuildHoverState = BuildHoverStates.UndefinedState; // and no more module definition
break;
case ",":
thisModuleDeclarationText += ItemText; // only the module declaration will include the comment
thisModuleDeclarationText += System.Environment.NewLine;
// add the module parameter
AddHoverItem(thisModuleName, thisHoverName, thisModuleParameterText);
thisModuleParameterText = thisModuleParameterText.Replace(thisHoverName, "");
break;
case ";":
thisModuleDeclarationText += ItemText; // only the module declaration will include the comment
thisModuleDeclarationText += System.Environment.NewLine;
// add the module parameter
AddHoverItem(thisModuleName, thisHoverName, thisModuleParameterText);
thisModuleParameterText = "";
BuildHoverState = BuildHoverStates.ModuleParameterNaming; // certainly not mimic naming after a semi-colon!
break;
default:
// thisModuleParameterText += ItemText;
thisModuleDeclarationText += ItemText;
if (IsVerilogNamerKeyword(ItemText) || IsVerilogBracket(ItemText) || IsNumeric(ItemText) || IsVerilogValue(ItemText) || IsDelimiter(ItemText))
{
SetBracketContentStatus_For(ItemText);
// no longer mimic naming
BuildHoverState = BuildHoverStates.ModuleParameterNaming;
thisModuleParameterText = ItemText; // start over for the module parameter
}
else
{
thisHoverName = ItemText;
thisModuleParameterText += ItemText;
}
break;
}
}
/// <summary>
/// Process_ModuleParameterNaming_For
/// </summary>
/// <param name="ItemText"></param>
private static void Process_ModuleParameterNaming_For(string ItemText)
{
// once we are naming a module parameter, we only end with a closing parenthesis, or a comman
switch (ItemText)
{
case "":
// only append whitespace when not found at beginning
if (thisModuleParameterText != "")
{
if ((lastHoverItem == "") || (lastHoverItem == "\t"))
{
// we'll ignore sequentual tabs, or alternating table-space
// only one space will be used
}
else
{
thisModuleDeclarationText += " ";
thisModuleParameterText += " ";
}
}
break;
case "\t":
if ((lastHoverItem == "") || (lastHoverItem == "\t"))
{
// we'll ignore sequentual tabs, or alternating table-space
// only one space will be used
}
else
{
thisModuleDeclarationText += " ";
thisModuleParameterText += " ";
}
break;
case ")":
// also add an indivisual parameter as needed
// note all module parameters have test appended: "module [modulename]" + {} + ")"
AddHoverItem(thisModuleName, thisHoverName, thisModuleParameterText);
thisModuleParameterText = ""; // upon the colose parenthesis, no more module parameters
BuildHoverState = BuildHoverStates.UndefinedState; // and no more module definition
// we add the module definition afterwards to avoid any additional, manually added closing ")" that is included for *every( module parameter, but not actually in the text
thisModuleDeclarationText += ItemText;
if (lastNonblankHoverItem == ",")
{
// we won't try to add a duplicate if there's a trailing ",)" syntax error
}
else
{
AddHoverItem(thisModuleName, thisModuleName, thisModuleDeclarationText);
}
break;
case ",":
thisModuleDeclarationText += ItemText; // only the module declaration will include the comment
thisModuleDeclarationText += System.Environment.NewLine;
// add the module parameter
AddHoverItem(thisModuleName, thisHoverName, thisModuleParameterText);
thisModuleParameterText = thisModuleParameterText.Replace(thisHoverName, ""); // TODO - use a placeholder here, not an empty string
// the next parameter after the comma will use the same definition
BuildHoverState = BuildHoverStates.ModuleParameterMimicNaming;
break;
case ";":
thisModuleDeclarationText += ItemText; // only the module declaration will include the comment
thisModuleDeclarationText += System.Environment.NewLine;
// add the module parameter
AddHoverItem(thisModuleName, thisHoverName, thisModuleParameterText);
thisModuleParameterText = ""; // we can't use the same parameter def after a semicolon
BuildHoverState = BuildHoverStates.ModuleParameterNaming; // certainly not mimic naming after a semi-colon!
break;
case "=":
thisModuleParameterText += ItemText;
thisModuleDeclarationText += ItemText;
break;
default:
thisModuleParameterText += ItemText;
thisModuleDeclarationText += ItemText;
if (IsVerilogNamerKeyword(ItemText) || IsVerilogBracket(ItemText) || IsNumeric(ItemText) || IsVerilogValue(ItemText) || IsDelimiter(ItemText))
{
SetBracketContentStatus_For(ItemText);
// nothing at this time; we are still bulding the declaration part
// thisModuleParameterText += ItemText;
}
else
{
thisHoverName = ItemText;
}
break;
}
}
/// <summary>
/// Process_UndefinedState_For
/// </summary>
/// <param name="ItemText"></param>
private static void Process_UndefinedState_For(string ItemText)
{
switch (ItemText)
{
case "":
// ignoring trimmed spaces / blanks
break;
case "module":
// we're naming a module
BuildHoverState = BuildHoverStates.ModuleStart;
thisModuleDeclarationText = ItemText;
break;
case "input":
case "output":
case "inout":
case "wire":
case "reg":
case "localparam":
case "parameter":
// the same keywords could be used for module parameters, or variables:
switch (BuildHoverState)
{
case BuildHoverStates.ModuleStart:
BuildHoverState = BuildHoverStates.ModuleParameterNaming;
break;
case BuildHoverStates.VariableMimicNaming: // comma-delimited types have the type copied (mimic) into hover text for each variable
BuildHoverState = BuildHoverStates.VariableNaming;
thisVariableDeclarationText = ItemText;
thisHoverName = ""; // we are no longer using the same type declaration, so reset to blank
break;
default:
BuildHoverState = BuildHoverStates.VariableNaming;
thisVariableDeclarationText = ItemText;
break;
}
thisVariableType = VerilogGlobals.VerilogTypes["variable_" + ItemText];
break;
case "endmodule":
// we're naming a module
BuildHoverState = BuildHoverStates.UndefinedState;
// this is likely a syntax error
break;
default:
if (VerilogVariables.ContainsKey(ItemText))
{
// a scope-level module name is defined, so treat it like a variable type
BuildHoverState = BuildHoverStates.VariableNaming; // actually, we are module naming. TODO different color for modules?
// a module instantiation will have the work "module" manually prepended
thisVariableDeclarationText = "module " + ItemText;
}
else
{
BuildHoverState = BuildHoverStates.UndefinedState;
}
break;
}
}
