public static string GenerateSyntaxFactory(SlotModels models, CodeGeneratorContext context)
        {
            var template = GetTemplate(SyntaxFactoryGroup.Value, models, context);
            var content  = template.Render();

            return(content);
        }
        public ActionResult DeleteConfirmed(int id)
        {
            SlotModels slotModels = db.SlotModels.Find(id);

            db.SlotModels.Remove(slotModels);
            db.SaveChanges();
            return(RedirectToAction("Index", "SlotModels"));
        }
Beispiel #3
0
        private static void WriteSyntaxFactory(string targetDirectory,
                                               SlotModels model,
                                               CodeGeneratorContext context)
        {
            var content  = CodeGenerator.GenerateSyntaxFactory(model, context);
            var fullname = Path.Combine(targetDirectory, "SyntaxFactory.generated.cs");

            File.WriteAllText(fullname, content, Encoding.UTF8);
        }
 public ActionResult Edit([Bind(Include = "SlotModelID,Name")] SlotModels m)
 {
     if (ModelState.IsValid)
     {
         db.Entry(m).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index", "SlotModels"));
     }
     return(View(m));
 }
        public ActionResult Create([Bind(Include = "SlotModelID,Name")] SlotModels m)
        {
            if (ModelState.IsValid)
            {
                db.SlotModels.Add(m);
                db.SaveChanges();
                return(RedirectToAction("Index", "SlotMachines"));
            }

            return(View(m));
        }
        public ActionResult Delete(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            SlotModels m = db.SlotModels.Find(id);

            if (m == null)
            {
                return(HttpNotFound());
            }
            return(View(m));
        }
Beispiel #7
0
        private static void WriteMetaModel(string targetDirectory, SlotModels slotModels, CodeGeneratorContext context)
        {
            // TODO WriteMetaModel

            var guiElements = from t in typeof(GuiElement).Assembly.GetTypes()
                              where t.IsSubclassOf(typeof(GuiElement))
                              select t;

            foreach (var c in guiElements)
            {
                Console.WriteLine($"{c.Name} {c.BaseType?.Name}");
                //WriteVerbose(c.Name);
            }

            var controls = from t in typeof(GuiElement).Assembly.GetTypes()
                           where t.IsSubclassOf(typeof(Control))
                           select t;

            var controlTypesToSkip = new[] {
Beispiel #8
0
        static void WriteGeneratedFiles(string targetDirectory,
                                        string baseNamespace,
                                        TokenInfo tokenInfo,
                                        GrammarInfo grammarInfo)
        {
            var syntaxKindModel = new SyntaxKindEnumModel(
                @namespace: baseNamespace,
                tokenInfo: tokenInfo,
                grammarInfo: grammarInfo
                );
            var slotModels = new SlotModels(
                baseNamespace: baseNamespace,
                grammarInfo: grammarInfo
                );

            var tokenModel = new TokenModel(
                tokenInfo: tokenInfo,
                baseNamespace: baseNamespace);

            Console.WriteLine(targetDirectory);

            if (!Directory.Exists(targetDirectory))
            {
                Directory.CreateDirectory(targetDirectory);
            }

            var context = new CodeGeneratorContext();

            WriteSyntaxKind(targetDirectory, syntaxKindModel, context);
            WriteSyntaxSlots(targetDirectory, slotModels, context);
            WriteSyntaxNodes(targetDirectory, slotModels, context);
            WriteSyntaxSlotBuilder(targetDirectory, slotModels, context);
            WriteSyntaxVisitor(targetDirectory, slotModels, context);
            WriteSyntaxFactory(targetDirectory, slotModels, context);
            WriteSyntaxFacts(targetDirectory, tokenModel, context);
            WriteMetaModel(targetDirectory, slotModels, context);
        }