public IActionResult GetCodes([FromRoute] int id, [FromQuery] int page)
{
var sql = new SQL(connectionString: _config.GetConnectionString("Storage"));
var codeConverter = new CodeConverter(_config.GetSection("Base26")["Alphabet"]);
var tableData = sql.GetCodes(
campaignID: id,
pageNumber: page,
pageSize: Convert.ToInt32(_config.GetSection("Pagination")["PageSize"]),
codeConverter: new CodeConverter(_config.GetSection("Base26")["Alphabet"]));
return(Ok(tableData));
}
public static EocIfStatement Translate(CodeConverter C, IfStatement stat)
{
if (stat == null)
{
return(null);
}
return(new EocIfStatement(
C,
EocExpression.Translate(C, stat.Condition),
EocStatementBlock.Translate(C, stat.Block),
stat.Mask,
stat.Comment));
}
public static EocCallExpression Translate(CodeConverter C, CallExpression expr)
{
if (expr == null)
{
return(null);
}
return(new EocCallExpression(
C,
C.P.GetEocCmdInfo(expr),
EocExpression.Translate(C, expr.Target),
expr.ParamList?.Select(x => EocExpression.Translate(C, x)).ToList(),
expr.LibraryId >= 0 ? C.P.EocLibs[expr.LibraryId]?.SuperTemplateAssembly : null));
}
public static void LetMutilCmd(CodeConverter C, CodeWriter writer, EocCallExpression callExpr)
{
var source = callExpr.ParamList[0];
for (int i = 1; i < callExpr.ParamList.Count; i++)
{
var cur = callExpr.ParamList[i];
source = new EocCallExpression(C, C.P.GetEocCmdInfo(0, 54), null, new List <EocExpression> {
cur, source
}, C.P.EocLibs[0].SuperTemplateAssembly);
}
source.WriteTo(writer);
}
public JsonResult allTranslate([FromBody] List <Lang> langs)
{
Lang lang1 = langs.Where(x => x.text != String.Empty).First();
if (lang1.text != null)
{
langs.ForEach(x =>
{
x.text = x.name != lang1.name ? CodeConverter.ConvertCode(lang1.text, lang1.name, x.name) : lang1.text;
});
}
return(Json(langs, JsonRequestBehavior.AllowGet));
}
public IActionResult RedeemCode([FromRoute] string code, [FromBody] string email)
{
var sql = new SQL(connectionString: _config.GetConnectionString("Storage"));
var codeConverter = new CodeConverter(_config.GetSection("Base26")["Alphabet"]);
var seedValue = codeConverter.ConvertFromCode(code);
var isRedeemed = sql.RedeemCode(seedValue, email);
if (isRedeemed)
{
return(Ok());
}
return(BadRequest());
}
//Draw stairs to grid
public void PutGroup(GridContext bgc, string filename, int x1, int y1, int z1, byte groupId)
{
if (bgc == null)
{
return;
}
string stringCode = ReadGlyc(filename + ".glyc");
Grid newGrid = CodeConverter.CodeToGrid(stringCode);
//DrawHollowRect(bgc, x1, y1, z1, x2, y2, z2);
CopyInto(bgc, x1, y1, z1, newGrid, groupId);
}
//Draw stairs to grid
public void Put(GridContext bgc, string filename, int x1, int y1, int z1)
{
if (bgc == null)
{
return;
}
//@"C:\Github\Glyphics2\Glyph Cores\" +
string stringCode = ReadGlyc(filename + ".glyc");
Grid newGrid = CodeConverter.CodeToGrid(stringCode);
//DrawHollowRect(bgc, x1, y1, z1, x2, y2, z2);
CopyInto(bgc, x1, y1, z1, newGrid);
}
// [ClassInitialize]
public static void Init(/* TestContext testContext */)
{
var codeGenerator = new AutoRestCSharpCodeGenerator(
Path.GetFullPath("Swagger.json"),
typeof(AutoRestVisualBasicCodeGeneratorTests).Namespace);
var options = new CodeWithOptions(codeGenerator.GenerateCode(mock.Object));
var result = CodeConverter
.Convert(options)
.GetAwaiter()
.GetResult();
code = result.ConvertedCode;
}
public static EocDoWhileStatement Translate(CodeConverter C, DoWhileStatement stat)
{
if (stat == null)
{
return(null);
}
return(new EocDoWhileStatement(
C,
EocExpression.Translate(C, stat.Condition),
EocStatementBlock.Translate(C, stat.Block),
stat.MaskOnStart || stat.MaskOnEnd,
stat.CommentOnStart,
stat.CommentOnEnd));
}
public static EocExpression Translate(CodeConverter C, Expression expr)
{
switch (expr)
{
case null:
return(null);
case MethodPtrExpression v:
return(EocMethodPtrExpression.Translate(C, v));
case CallExpression v:
return(EocCallExpression.Translate(C, v));
case StringLiteral v:
return(EocStringLiteral.Translate(C, v));
case NumberLiteral v:
return(EocNumberLiteral.Translate(C, v));
case DateTimeLiteral v:
return(EocDateTimeLiteral.Translate(C, v));
case BoolLiteral v:
return(EocBoolLiteral.Translate(C, v));
case VariableExpression v:
return(EocVariableExpression.Translate(C, v));
case AccessArrayExpression v:
return(EocAccessArrayExpression.Translate(C, v));
case AccessMemberExpression v:
return(EocAccessMemberExpression.Translate(C, v));
case ConstantExpression v:
return(EocConstantExpression.Translate(C, v));
case EmnuConstantExpression v:
return(EocConstantExpression.Translate(C, v));
case ArrayLiteralExpression v:
return(EocArrayLiteralExpression.Translate(C, v));
case DefaultValueExpression v:
return(null);
default:
throw new Exception("<error-expression>");
}
}
public IActionResult SearchCode([FromRoute] string code)
{
var sql = new SQL(connectionString: _config.GetConnectionString("Storage"));
var codeConverter = new CodeConverter(_config.GetSection("Base26")["Alphabet"]);
var searchedCode = sql.SearchCode(code, codeConverter);
if (searchedCode == null)
{
return(NotFound());
}
else
{
return(Ok(searchedCode));
}
}
// [ClassInitialize]
public static async Task InitAsync(/* TestContext testContext */)
{
var defaultNamespace = typeof(NSwagVisualBasicCodeGeneratorTests).Namespace;
var codeGenerator = new NSwagCSharpCodeGenerator(
Path.GetFullPath(SwaggerJsonFilename),
defaultNamespace,
optionsMock.Object,
new OpenApiDocumentFactory(),
new NSwagCodeGeneratorSettingsFactory(defaultNamespace, optionsMock.Object));
var options = new CodeWithOptions(codeGenerator.GenerateCode(mock.Object));
var result = await CodeConverter.Convert(options);
code = result.ConvertedCode;
}
// [ClassInitialize]
public static async Task InitAsync(/* TestContext testContext */)
{
optionsMock = new Mock <IGeneralOptions>();
optionsMock.Setup(c => c.NSwagPath).Returns(PathProvider.GetJavaPath());
var codeGenerator = new OpenApiCSharpCodeGenerator(
Path.GetFullPath(SwaggerJsonFilename),
"GeneratedCode",
optionsMock.Object);
var options = new CodeWithOptions(codeGenerator.GenerateCode(mock.Object));
var result = await CodeConverter.Convert(options);
code = result.ConvertedCode;
}
public static async Task InitAsync(TestContext testContext)
{
optionsMock = new Mock <IGeneralOptions>();
optionsMock.Setup(c => c.NSwagPath).Returns(PathProvider.GetJavaPath());
var codeGenerator = new OpenApiCSharpCodeGenerator(
Path.GetFullPath("Swagger.json"),
typeof(OpenApiVisualBasicCodeGeneratorTests).Namespace,
optionsMock.Object);
var options = new CodeWithOptions(codeGenerator.GenerateCode(mock.Object));
var result = await CodeConverter.Convert(options);
code = result.ConvertedCode;
}
static bool TryConvertingCSToVBCode(string csCode, out string vbCode)
{
vbCode = null;
var codeWithOptions = new CodeWithOptions(csCode)
.WithDefaultReferences();
var result = CodeConverter.Convert(codeWithOptions);
if (result.Success)
{
vbCode = result.ConvertedCode;
return(true);
}
return(false);
}
//Load archetypes from a file
public static bool LoadArchetypes(string filename)
{
using (var file = new System.IO.StreamReader(filename))
{
string line;
while ((line = file.ReadLine()) != null)
{
Grid grid = CodeConverter.TokensToGrid(CodeConverter.CodeToTokens(new Code(line)));
if (grid != null)
{
GridLibrary.GridList.AddGrid(grid);
}
}
}
return(false);
}
public static EocForStatement Translate(CodeConverter C, ForStatement stat)
{
if (stat == null)
{
return(null);
}
return(new EocForStatement(
C,
EocExpression.Translate(C, stat.Start),
EocExpression.Translate(C, stat.End),
EocExpression.Translate(C, stat.Step),
EocExpression.Translate(C, stat.Var),
EocStatementBlock.Translate(C, stat.Block),
stat.MaskOnStart || stat.MaskOnEnd,
stat.CommentOnStart,
stat.CommentOnEnd));
}
ProcessModifiedFiles(ICollection <string> modifiedFiles, ILogger logger)
{
if (!modifiedFiles.Any())
{
return(
Enumerable.Empty <CodeFragment>(),
Enumerable.Empty <CodeFragment>(),
Enumerable.Empty <CodeFragment>()
);
}
var fragmentsToAdd = new List <CodeFragment>();
var fragmentsToModify = new List <CodeFragment>();
var fragmentsToRemove = new List <CodeFragment>();
var codeConverter = new CodeConverter();
foreach (var filePath in modifiedFiles)
{
var oldCodeFile = await _codeFileRepository.GetAsync(filePath);
var newCodeFile = await _githubService.GetCodeFileAsync(filePath);
await _codeFileRepository.StoreAsync(newCodeFile);
if (oldCodeFile == null)
{
logger.LogWarning(
$"Trying to modify code file {filePath} might result in inconsistent content " +
"in KC because there is no known previous version of the code file.");
fragmentsToAdd.AddRange(newCodeFile.CodeFragments);
}
else
{
var(newFragments, modifiedFragments, removedFragments) =
codeConverter.CompareFragmentLists(oldCodeFile.CodeFragments, newCodeFile.CodeFragments);
fragmentsToAdd.AddRange(newFragments);
fragmentsToModify.AddRange(modifiedFragments);
fragmentsToRemove.AddRange(removedFragments);
}
}
return(fragmentsToAdd, fragmentsToModify, fragmentsToRemove);
}
public static EocStatementBlock Translate(CodeConverter C, StatementBlock block)
{
if (block == null)
{
return(null);
}
return(new EocStatementBlock(C, block?.Select(x =>
{
try
{
return EocStatement.Translate(C, x);
}
catch (Exception exception)
{
return new EocErrorStatement(C, exception, x.ToTextCode(C.P.IdToNameMap));
}
})));
}
static void Main(string[] args)
{
var result = CodeConverter.Convert(
new CodeWithOptions(Console.In.ReadToEnd())
.WithDefaultReferences()
.SetFromLanguage("Visual Basic", 14)
.SetToLanguage("C#", 6));
if (result.Success)
{
Console.WriteLine(result.ConvertedCode);
}
else
{
Console.Error.WriteLine("Error:");
Console.Error.WriteLine(result.GetExceptionsAsString());
}
}
//Generates a set of thumbnails of the codeString, down to 1 pixels size
public static GridList CodeToThumbnailed(Code code)
{
GridList gridList = new GridList();
Grid grid = CodeConverter.CodeToGrid(code.codeString);
int toX = grid.SizeX;
int toY = grid.SizeY;
int toZ = grid.SizeZ;
while ((toX > 0) && (toY > 0) && (toZ > 0))
{
Code newCode = CodeConverter.CodeToRescaledCode(code, toX, toY, toZ);
Grid newGrid = CodeConverter.CodeToGrid(newCode.codeString);
gridList.AddGrid(newGrid);
toX /= 2;
toY /= 2;
toZ /= 2;
}
return(gridList);
}
public static EocCallExpression Translate(CodeConverter C, CallExpression expr)
{
var P = C.P;
if (expr == null)
{
return(null);
}
var result = new EocCallExpression(
C,
P.GetEocCmdInfo(expr),
EocExpression.Translate(C, expr.Target),
expr.ParamList?.Select(x => EocExpression.Translate(C, x)).ToList(),
expr.LibraryId >= 0 ? P.EocLibs[expr.LibraryId]?.SuperTemplateAssembly : null);
if (expr.InvokeSpecial)
{
result.SpecialScope = "raw_" + P.GetUserDefinedName_SimpleCppName(P.MethodIdToClassMap[expr.MethodId].Id);
}
return(result);
}
public static EocExpressionStatement Translate(CodeConverter C, ExpressionStatement stat)
{
if (stat == null)
{
return(null);
}
if (stat.Mask)
{
return(new EocExpressionStatement(
C,
null,
stat.Expression.ToTextCode(C.P.IdToNameMap) + " '" + stat.Comment));
}
else
{
return(new EocExpressionStatement(
C,
EocExpression.Translate(C, stat.Expression),
stat.Comment));
}
}
public static async Task <ConvertResponse> ConvertAsync(ConvertRequest todo)
{
var languages = todo.requestedConversion.Split('2');
string fromLanguage = LanguageNames.CSharp;
string toLanguage = LanguageNames.VisualBasic;
if (languages.Length == 2)
{
fromLanguage = ParseLanguage(languages[0]);
toLanguage = ParseLanguage(languages[1]);
}
var codeWithOptions = new CodeWithOptions(todo.code)
.WithTypeReferences(DefaultReferences.NetStandard2)
.SetFromLanguage(fromLanguage)
.SetToLanguage(toLanguage);
var result = await CodeConverter.ConvertAsync(codeWithOptions);
return(new ConvertResponse(result.Success, result.ConvertedCode, result.GetExceptionsAsString()));
}
public static EocStatement Translate(CodeConverter converter, Statement item)
{
switch (item)
{
case null:
return(null);
case ExpressionStatement v:
return(EocExpressionStatement.Translate(converter, v));
case UnexaminedStatement v:
throw new Exception("不允许出现未验证语句：" + v.UnexaminedCode);
case IfElseStatement v:
return(EocIfElseStatement.Translate(converter, v));
case IfStatement v:
return(EocIfStatement.Translate(converter, v));
case WhileStatement v:
return(EocWhileStatement.Translate(converter, v));
case DoWhileStatement v:
return(EocDoWhileStatement.Translate(converter, v));
case CounterStatement v:
return(EocCounterStatement.Translate(converter, v));
case ForStatement v:
return(EocForStatement.Translate(converter, v));
case SwitchStatement v:
return(EocSwitchStatement.Translate(converter, v));
default:
throw new Exception("<error-statement>");
}
}
static void Main(string[] args)
{
//Load XML File
string xmlFileName = @"C:\DFIR Project\DFIR\Tests\MyAdder.gvi.xml";
string xmlFileName2 = @"C:\DFIR Project\Compiler\Tests\MyAdder.gvi.xml";
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(xmlFileName);
xmlDoc.DocumentElement.Normalize();
//Validate XML File with XML Schema
string schemaFileName = @"C:\DFIR Project\DFIR\Src\DFIR.xsd";
XmlSchemaSet schemas = new XmlSchemaSet();
schemas.Add("", schemaFileName);
SchemaValidation.Validate(xmlFileName, schemas);
//XML DOM Parser
Console.WriteLine("Root element :" + xmlDoc.DocumentElement.Name);
IDiagram iDiagram = DomParser.GetIDiagram(xmlDoc.DocumentElement);
Console.WriteLine("\nIDiagram Print :\n");
iDiagram.Print();
//Compiler
File.Delete(xmlFileName2);
File.Copy(xmlFileName, xmlFileName2); //Copy the XML file into the Compiler directory
CFileName cfilename = new CFileName(xmlFileName2);
string s = cfilename.GetCCodeName(cfilename.GetCodeFileName());
CodeConverter converter = new CodeConverter();
converter.Printout(iDiagram, true, 0, s);
Console.ReadKey();
}
public static EocCallExpression Translate(CodeConverter C, CallExpression expr)
{
var P = C.P;
if (expr == null)
{
return(null);
}
var paramList = expr.ParamList?.Select(x => EocExpression.Translate(C, x)).ToList();
var countOfDefaultAtEnd = 0;
for (int i = paramList.Count - 1; i >= 0; i--)
{
if (paramList[i] != null)
{
break;
}
countOfDefaultAtEnd++;
}
if (countOfDefaultAtEnd != 0)
{
paramList.RemoveRange(paramList.Count - countOfDefaultAtEnd, countOfDefaultAtEnd);
}
var result = new EocCallExpression(
C,
P.GetEocCmdInfo(expr),
EocExpression.Translate(C, expr.Target),
paramList,
expr.LibraryId >= 0 ? P.EocLibs[expr.LibraryId]?.SuperTemplateAssembly : null);
if (expr.InvokeSpecial)
{
result.SpecialScope = "raw_" + P.GetUserDefinedName_SimpleCppName(P.MethodIdToClassMap[expr.MethodId].Id);
}
return(result);
}
public EocStatementBlock(CodeConverter c, IEnumerable <EocStatement> block) : base(c)
{
statements = block?.ToList();
}
public EocStatementBlock(CodeConverter c) : base(c)
{
statements = new List <EocStatement>();
}
