Wednesday, February 17, 2016

compiler design topics

compiler design topics

  1. GOLD Parsing System
  2. GOLD Parser ::Instructions for the Builder and Engine
  3. Source Code and Documentation
  4. Let Your Parser Go for the GOLD
  5. GOLD Parse, how do you actually implement your code?
  6. Calitha C# GOLD Parser Engine
  7. compiler,gold parser,DFA,LALR
  8. The LLVM Project

  9. Introduction to GOLD Parser

    this is very good introduction. It mentions some tips for life cycle management for generated abstract class file and your own implementation class in separate file. so that it will not be wiped out after you add new features into your language and you need to regenerate your parse file.

  10. A Simple Compiler for the Common Language Runtime

    it generates a simple language with integer, float and array type. a very good demo on how to create our own language using GOLD parser.

  11. A Money type for the CLR

    a basic data type and it can be used in new language.

  12. Money pattern

    good article to start with in order to have basic introduction and concepts.

  13. Money DataType

    a good application and demo to look at money type.

  14. .NET Type Internals - From a Microsoft CLR Perspective

    worthy to browse it and see its perspective for primitive data type.

  15. Generating Code at Run Time With Reflection.Emit
  16. Dynamic Type Using Reflection.Emit
  17. Introduction to Creating Dynamic Types with Reflection.Emit
  18. Introduction to Creating Dynamic Types with Reflection.Emit: Part 2
  19. Using Reflection.Emit to Precompile Expressions to MSIL
  20. RunSharp - Reflection.Emit Has Never Been Easier
  21. Debugging Dynamically Generated Code (Reflection.Emit)
  22. Why you can’t do Edit-and-Continue on Dynamically generated code
  23. Runtime code generation for types
  24. Reflection, performance and runtime code generation

    Most applications don’t need runtime code generation — either they know everything they need to know at compile time, or the performance considerations are such that Reflection is good enough. However, if you’re running a lot of Reflection code, then replacing it with type-specific code generated at runtime can give you a big performance boost.

  25. RunSharp – IL Generation for Dummies
  26. Reflection and Reflection.Emit in C#
  27. A comparison of dynamic code generation methods in .NET
  28. Creating Code at Runtime / System.Reflection.Emit

    Here an example how we can create code at runtime. In this sample, I try to create the following class at runtime:

  29. Creating Code at Runtime (Part 2)

    If we need to handle events and delegates, here is the following sample:

  30. Creating Code at Runtime (Part 3)

    to change our previous delegate for one more standard, like EventHandler. we update this new class to looks like:

  31. Reflection Part 2: Emit

    In this article we will examine reflection emit - the ability to dynamically generate code at run-time.

  32. Reflection Part 1: Discovery and Execution

    we explain reflection in the .NET Framework and demonstrate where and how you can use this new tool in your applications.

  33. Get Drunk on the Power of Reflection.Emit
  34. CIL Instruction Set
  35. CIL Instructions Set Quick Reference
  36. MSIL Programming Part 1
  37. MSIL Programming Part 2
  38. Writings on Computer Science -- Dick Grune

No comments:

Post a Comment