private static void LoadBlock(BlockValues dst, byte[] src)
{
for (int i = 0; i < QwordsInBlock; ++i)
{
dst[i] = Load64(src, i * 8);
}
}
private static void StoreBlock(byte[] buf, BlockValues blockValues)
{
for (int i = 0; i < QwordsInBlock; ++i)
{
Store64(buf, 8 * i, blockValues[i]);
}
}
private static void FillBlock(BlockValues prevBlock, BlockValues refBlock, BlockValues nextBlock)
{
// TODO: figure out and lift the code from Blake2BCore-FullyUnrolled.cs
var buf = new ulong[QwordsInBlock * 2];
var blockR = new BlockValues(buf, 0);
var blockTmp = new BlockValues(buf, 1);
blockR.Copy(refBlock);
blockR.Xor(prevBlock);
blockTmp.Copy(blockR);
// apply Blake2 on columns of 64-bit words:
// (0,1,...,15), then
// (16,17,..31)... finally
// (112,113,...127)
for (int i = 0; i < 8; ++i)
{
ulong v0 = blockR[16 * i];
ulong v1 = blockR[(16 * i) + 1];
ulong v2 = blockR[(16 * i) + 2];
ulong v3 = blockR[(16 * i) + 3];
ulong v4 = blockR[(16 * i) + 4];
ulong v5 = blockR[(16 * i) + 5];
ulong v6 = blockR[(16 * i) + 6];
ulong v7 = blockR[(16 * i) + 7];
ulong v8 = blockR[(16 * i) + 8];
ulong v9 = blockR[(16 * i) + 9];
ulong v10 = blockR[(16 * i) + 10];
ulong v11 = blockR[(16 * i) + 11];
ulong v12 = blockR[(16 * i) + 12];
ulong v13 = blockR[(16 * i) + 13];
ulong v14 = blockR[(16 * i) + 14];
ulong v15 = blockR[(16 * i) + 15];
BlakeRoundNoMsg(
ref v0,
ref v1,
ref v2,
ref v3,
ref v4,
ref v5,
ref v6,
ref v7,
ref v8,
ref v9,
ref v10,
ref v11,
ref v12,
ref v13,
ref v14,
ref v15);
blockR[16 * i] = v0;
blockR[(16 * i) + 1] = v1;
blockR[(16 * i) + 2] = v2;
blockR[(16 * i) + 3] = v3;
blockR[(16 * i) + 4] = v4;
blockR[(16 * i) + 5] = v5;
blockR[(16 * i) + 6] = v6;
blockR[(16 * i) + 7] = v7;
blockR[(16 * i) + 8] = v8;
blockR[(16 * i) + 9] = v9;
blockR[(16 * i) + 10] = v10;
blockR[(16 * i) + 11] = v11;
blockR[(16 * i) + 12] = v12;
blockR[(16 * i) + 13] = v13;
blockR[(16 * i) + 14] = v14;
blockR[(16 * i) + 15] = v15;
}
// Apply Blake2 on rows of 64-bit words:
// (0,1,16,17,...112,113), then
// (2,3,18,19,...,114,115).. finally
// (14,15,30,31,...,126,127)
for (int i = 0; i < 8; ++i)
{
ulong v0 = blockR[2 * i];
ulong v1 = blockR[(2 * i) + 1];
ulong v2 = blockR[(2 * i) + 16];
ulong v3 = blockR[(2 * i) + 17];
ulong v4 = blockR[(2 * i) + 32];
ulong v5 = blockR[(2 * i) + 33];
ulong v6 = blockR[(2 * i) + 48];
ulong v7 = blockR[(2 * i) + 49];
ulong v8 = blockR[(2 * i) + 64];
ulong v9 = blockR[(2 * i) + 65];
ulong v10 = blockR[(2 * i) + 80];
ulong v11 = blockR[(2 * i) + 81];
ulong v12 = blockR[(2 * i) + 96];
ulong v13 = blockR[(2 * i) + 97];
ulong v14 = blockR[(2 * i) + 112];
ulong v15 = blockR[(2 * i) + 113];
BlakeRoundNoMsg(
ref v0,
ref v1,
ref v2,
ref v3,
ref v4,
ref v5,
ref v6,
ref v7,
ref v8,
ref v9,
ref v10,
ref v11,
ref v12,
ref v13,
ref v14,
ref v15);
blockR[2 * i] = v0;
blockR[(2 * i) + 1] = v1;
blockR[(2 * i) + 16] = v2;
blockR[(2 * i) + 17] = v3;
blockR[(2 * i) + 32] = v4;
blockR[(2 * i) + 33] = v5;
blockR[(2 * i) + 48] = v6;
blockR[(2 * i) + 49] = v7;
blockR[(2 * i) + 64] = v8;
blockR[(2 * i) + 65] = v9;
blockR[(2 * i) + 80] = v10;
blockR[(2 * i) + 81] = v11;
blockR[(2 * i) + 96] = v12;
blockR[(2 * i) + 97] = v13;
blockR[(2 * i) + 112] = v14;
blockR[(2 * i) + 113] = v15;
}
nextBlock.Copy(blockTmp);
nextBlock.Xor(blockR);
}
internal void CreateRules(SourceJavadocToXmldocGrammar grammar)
{
AllBlockTerms.Rule = AuthorDeclaration
| ApiSinceDeclaration
| DeprecatedDeclaration
| DeprecatedSinceDeclaration
| ExceptionDeclaration
| ParamDeclaration
| ReturnDeclaration
| SeeDeclaration
| SerialDataDeclaration
| SerialFieldDeclaration
| SinceDeclaration
| ThrowsDeclaration
| UnknownTagDeclaration
| VersionDeclaration
;
BlockValue.Rule = grammar.HtmlTerms.ParsedCharacterData
| grammar.HtmlTerms.InlineDeclaration
;
BlockValues.MakePlusRule(grammar, BlockValue);
AuthorDeclaration.Rule = "@author" + BlockValues;
AuthorDeclaration.AstConfig.NodeCreator = (context, parseNode) => {
if (!grammar.ShouldImport(ImportJavadoc.AuthorTag))
{
return;
}
// Ignore; not sure how best to convert to Xmldoc
FinishParse(context, parseNode);
};
ApiSinceDeclaration.Rule = "@apiSince" + BlockValues;
ApiSinceDeclaration.AstConfig.NodeCreator = (context, parseNode) => {
if (!grammar.ShouldImport(ImportJavadoc.SinceTag))
{
return;
}
var p = new XElement("para", "Added in API level ", AstNodeToXmlContent(parseNode.ChildNodes [1]), ".");
FinishParse(context, parseNode).Remarks.Add(p);
parseNode.AstNode = p;
};
DeprecatedDeclaration.Rule = "@deprecated" + BlockValues;
DeprecatedDeclaration.AstConfig.NodeCreator = (context, parseNode) => {
if (!grammar.ShouldImport(ImportJavadoc.DeprecatedTag))
{
return;
}
var p = new XElement("para", "This member is deprecated. ", AstNodeToXmlContent(parseNode.ChildNodes [1]));
FinishParse(context, parseNode).Remarks.Add(p);
parseNode.AstNode = p;
};
DeprecatedSinceDeclaration.Rule = "@deprecatedSince" + BlockValues;
DeprecatedSinceDeclaration.AstConfig.NodeCreator = (context, parseNode) => {
if (!grammar.ShouldImport(ImportJavadoc.DeprecatedTag))
{
return;
}
var p = new XElement("para", "This member was deprecated in API level ", AstNodeToXmlContent(parseNode.ChildNodes [1]), ".");
FinishParse(context, parseNode).Remarks.Add(p);
parseNode.AstNode = p;
};
var nonSpaceTerm = new RegexBasedTerminal("[^ ]", "[^ ]+")
{
AstConfig = new AstNodeConfig {
NodeCreator = (context, parseNode) => parseNode.AstNode = parseNode.Token.Value,
},
};
ExceptionDeclaration.Rule = "@exception" + nonSpaceTerm + BlockValues;
ExceptionDeclaration.AstConfig.NodeCreator = (context, parseNode) => {
if (!grammar.ShouldImport(ImportJavadoc.ExceptionTag))
{
return;
}
/* TODO: convert `nonSpaceTerm` into a proper CREF
* var e = new XElement ("exception",
* new XAttribute ("cref", string.Join ("", AstNodeToXmlContent (parseNode.ChildNodes [1]))),
* AstNodeToXmlContent (parseNode.ChildNodes [2]));
* FinishParse (context, parseNode).Exceptions.Add (e);
* parseNode.AstNode = e;
*/
FinishParse(context, parseNode);
};
ParamDeclaration.Rule = "@param" + nonSpaceTerm + BlockValues;
ParamDeclaration.AstConfig.NodeCreator = (context, parseNode) => {
if (!grammar.ShouldImport(ImportJavadoc.ParamTag))
{
return;
}
var p = new XElement("param",
new XAttribute("name", string.Join("", AstNodeToXmlContent(parseNode.ChildNodes [1]))),
AstNodeToXmlContent(parseNode.ChildNodes [2]));
FinishParse(context, parseNode).Parameters.Add(p);
parseNode.AstNode = p;
};
ReturnDeclaration.Rule = "@return" + BlockValues;
ReturnDeclaration.AstConfig.NodeCreator = (context, parseNode) => {
if (!grammar.ShouldImport(ImportJavadoc.ReturnTag))
{
return;
}
// When encountering multiple @return keys in a line, append subsequent @return key content to the original <returns> element.
var jdi = FinishParse(context, parseNode);
if (jdi.Returns.Count == 0)
{
var r = new XElement("returns",
AstNodeToXmlContent(parseNode.ChildNodes [1]));
FinishParse(context, parseNode).Returns.Add(r);
parseNode.AstNode = r;
}
else
{
var r = jdi.Returns.First() as XElement;
if (r != null)
{
r.Add(" ", AstNodeToXmlContent(parseNode.ChildNodes [1]));
parseNode.AstNode = r;
}
}
};
SeeDeclaration.Rule = "@see" + BlockValues;
SeeDeclaration.AstConfig.NodeCreator = (context, parseNode) => {
if (!grammar.ShouldImport(ImportJavadoc.SeeTag))
{
return;
}
/* TODO: @see supports multiple forms; see: https://docs.oracle.com/javase/7/docs/technotes/tools/windows/javadoc.html#see
* // Also need to convert to appropriate CREF value, ignore for now
* var e = new XElement ("seealso",
* new XAttribute ("cref", string.Join ("", AstNodeToXmlContent (parseNode.ChildNodes [1]))));
* FinishParse (context, parseNode).Extra.Add (e);
* parseNode.AstNode = e;
*/
FinishParse(context, parseNode);
};
SinceDeclaration.Rule = "@since" + BlockValues;
SinceDeclaration.AstConfig.NodeCreator = (context, parseNode) => {
if (!grammar.ShouldImport(ImportJavadoc.SinceTag))
{
return;
}
var p = new XElement("para", "Added in ", AstNodeToXmlContent(parseNode.ChildNodes [1]), ".");
FinishParse(context, parseNode).Remarks.Add(p);
parseNode.AstNode = p;
};
ThrowsDeclaration.Rule = "@throws" + nonSpaceTerm + BlockValues;
ThrowsDeclaration.AstConfig.NodeCreator = (context, parseNode) => {
if (!grammar.ShouldImport(ImportJavadoc.ExceptionTag))
{
return;
}
/* TODO: convert `nonSpaceTerm` into a proper CREF
* var e = new XElement ("exception",
* new XAttribute ("cref", string.Join ("", AstNodeToXmlContent (parseNode.ChildNodes [1]))),
* AstNodeToXmlContent (parseNode.ChildNodes [2]));
* FinishParse (context, parseNode).Exceptions.Add (e);
* parseNode.AstNode = e;
*/
FinishParse(context, parseNode);
};
// Ignore serialization informatino
SerialDeclaration.Rule = "@serial" + BlockValues;
SerialDeclaration.AstConfig.NodeCreator = (context, parseNode) => {
if (!grammar.ShouldImport(ImportJavadoc.SerialTag))
{
return;
}
FinishParse(context, parseNode);
};
SerialDataDeclaration.Rule = "@serialData" + BlockValues;
SerialDataDeclaration.AstConfig.NodeCreator = (context, parseNode) => {
if (!grammar.ShouldImport(ImportJavadoc.SerialTag))
{
return;
}
FinishParse(context, parseNode);
};
SerialFieldDeclaration.Rule = "@serialField" + BlockValues;
SerialFieldDeclaration.AstConfig.NodeCreator = (context, parseNode) => {
if (!grammar.ShouldImport(ImportJavadoc.SerialTag))
{
return;
}
FinishParse(context, parseNode);
};
var unknownTagTerminal = new RegexBasedTerminal("@[unknown]", @"@\S+")
{
Priority = TerminalPriority.Low,
};
unknownTagTerminal.AstConfig.NodeCreator = (context, parseNode) =>
parseNode.AstNode = parseNode.Token.Value.ToString();
UnknownTagDeclaration.Rule = unknownTagTerminal + BlockValues;
UnknownTagDeclaration.AstConfig.NodeCreator = (context, parseNode) => {
if (!grammar.ShouldImport(ImportJavadoc.Remarks))
{
return;
}
Console.WriteLine($"# Unsupported @block-tag value: {parseNode.ChildNodes [0].AstNode}");
FinishParse(context, parseNode);
};
// Ignore Version
VersionDeclaration.Rule = "@version" + BlockValues;
VersionDeclaration.AstConfig.NodeCreator = (context, parseNode) => {
if (!grammar.ShouldImport(ImportJavadoc.VersionTag))
{
return;
}
FinishParse(context, parseNode);
};
}
