手寫編譯框架原理
① 匯編語言程序框架的基本原理是什麼 [電腦常識]
程序框架的原理：可以分三類框架：
1、msdos下的
exe
型程序框架
2、msdos下的
com
型程序框架
3、win32下的exe
型程序框架
這跟masm
編譯器的約定有關系。三類框架略有不同
當然，也有非intel80x86的匯編語言程序框架，也跟他們相應的編譯器約定有關
② 匯編語言程序框架的基本原理是什麼
程序框架的原理：可以分三類框架：
1、MSDOS下的 EXE 型程序框架
2、MSDOS下的 COM 型程序框架
3、Win32下的EXE 型程序框架
這跟MASM 編譯器的約定有關系。三類框架略有不同
當然，也有非Intel80x86的匯編語言程序框架，也跟他們相應的編譯器約定有關
③ 如何單獨編譯frameworks下的某個模塊
註：mmm和mm命令必須在執行「.build/envsetup.sh」之後才能使用，並且只編譯發生變化的文件。如果要編譯模塊的所有文件，需要-B選項，例如mm -B。
④ 解釋一下linux驅動程序結構框架及工作原理
一、Linux device driver 的概念
系統調用是操作系統內核和應用程序之間的介面，設備驅動程序是操作系統內核和機器硬體之間的介面。設備驅動程序為應用程序屏蔽了硬體的細節，這樣在應用程序看來，硬體設備只是一個設備文件，應用程序可以象操作普通文件一樣對硬體設備進行操作。設備驅動程序是內核的一部分，它完成以下的功能:
1、對設備初始化和釋放；
2、把數據從內核傳送到硬體和從硬體讀取數據；
3、讀取應用程序傳送給設備文件的數據和回送應用程序請求的數據；
4、檢測和處理設備出現的錯誤。
在Linux操作系統下有三類主要的設備文件類型，一是字元設備，二是塊設備，三是網路設備。字元設備和塊設備的主要區別是:在對字元設備發出讀/寫請求時，實際的硬體I/O一般就緊接著發生了，塊設備則不然，它利用一塊系統內存作緩沖區，當用戶進程對設備請求能滿足用戶的要求，就返回請求的數據，如果不能，就調用請求函數來進行實際的I/O操作。塊設備是主要針對磁碟等慢速設備設計的，以免耗費過多的CPU時間來等待。
已經提到，用戶進程是通過設備文件來與實際的硬體打交道。每個設備文件都都有其文件屬性(c/b)，表示是字元設備還是塊設備?另外每個文件都有兩個設備號，第一個是主設備號，標識驅動程序，第二個是從設備號，標識使用同一個設備驅動程序的不同的硬體設備，比如有兩個軟盤，就可以用從設備號來區分他們。設備文件的的主設備號必須與設備驅動程序在登記時申請的主設備號一致，否則用戶進程將無法訪問到驅動程序。
最後必須提到的是，在用戶進程調用驅動程序時，系統進入核心態，這時不再是搶先式調度。也就是說，系統必須在你的驅動程序的子函數返回後才能進行其他的工作。如果你的驅動程序陷入死循環，不幸的是你只有重新啟動機器了，然後就是漫長的fsck。
二、實例剖析
我們來寫一個最簡單的字元設備驅動程序。雖然它什麼也不做，但是通過它可以了解Linux的設備驅動程序的工作原理。把下面的C代碼輸入機器，你就會獲得一個真正的設備驅動程序。
由於用戶進程是通過設備文件同硬體打交道，對設備文件的操作方式不外乎就是一些系統調用，如 open，read，write，close…， 注意，不是fopen， fread，但是如何把系統調用和驅動程序關聯起來呢?這需要了解一個非常關鍵的數據結構：
STruct file_operatiONs {
int (*seek) (struct inode * ，struct file *， off_t ，int);
int (*read) (struct inode * ，struct file *， char ，int);
int (*write) (struct inode * ，struct file *， off_t ，int);
int (*readdir) (struct inode * ，struct file *， struct dirent * ，int);
int (*select) (struct inode * ，struct file *， int ，select_table *);
int (*ioctl) (struct inode * ，struct file *， unsined int ，unsigned long);
int (*mmap) (struct inode * ，struct file *， struct vm_area_struct *);
int (*open) (struct inode * ，struct file *);
int (*release) (struct inode * ，struct file *);
int (*fsync) (struct inode * ，struct file *);
int (*fasync) (struct inode * ，struct file *，int);
int (*check_media_change) (struct inode * ，struct file *);
int (*revalidate) (dev_t dev);
}
這個結構的每一個成員的名字都對應著一個系統調用。用戶進程利用系統調用在對設備文件進行諸如read/write操作時，系統調用通過設備文件的主設備號找到相應的設備驅動程序，然後讀取這個數據結構相應的函數指針，接著把控制權交給該函數。這是linux的設備驅動程序工作的基本原理。既然是這樣，則編寫設備驅動程序的主要工作就是編寫子函數，並填充file_operations的各個域。
下面就開始寫子程序。
#include <linux/types.h> 基本的類型定義
#include <linux/fs.h> 文件系統使用相關的頭文件
#include <linux/mm.h>
#include <linux/errno.h>
#include <asm/segment.h>
unsigned int test_major = 0;
static int read_test(struct inode *inode，struct file *file，char *buf，int count)
{
int left; 用戶空間和內核空間
if (verify_area(VERIFY_WRITE，buf，count) == -EFAULT )
return -EFAULT;
for(left = count ; left > 0 ; left--)
{
__put_user(1，buf，1);
buf++;
}
return count;
}
這個函數是為read調用准備的。當調用read時，read_test()被調用，它把用戶的緩沖區全部寫1。buf 是read調用的一個參數。它是用戶進程空間的一個地址。但是在read_test被調用時，系統進入核心態。所以不能使用buf這個地址，必須用__put_user()，這是kernel提供的一個函數，用於向用戶傳送數據。另外還有很多類似功能的函數。請參考，在向用戶空間拷貝數據之前，必須驗證buf是否可用。這就用到函數verify_area。為了驗證BUF是否可以用。
static int write_test(struct inode *inode，struct file *file，const char *buf，int count)
{
return count;
}
static int open_test(struct inode *inode，struct file *file )
{
MOD_INC_USE_COUNT; 模塊計數加以，表示當前內核有個設備載入內核當中去
return 0;
}
static void release_test(struct inode *inode，struct file *file )
{
MOD_DEC_USE_COUNT;
}
這幾個函數都是空操作。實際調用發生時什麼也不做，他們僅僅為下面的結構提供函數指針。
struct file_operations test_fops = {?
read_test，
write_test，
open_test，
release_test，
};
設備驅動程序的主體可以說是寫好了。現在要把驅動程序嵌入內核。驅動程序可以按照兩種方式編譯。一種是編譯進kernel，另一種是編譯成模塊(moles)，如果編譯進內核的話，會增加內核的大小，還要改動內核的源文件，而且不能動態的卸載，不利於調試，所以推薦使用模塊方式。
int init_mole(void)
{
int result;
result = register_chrdev(0， "test"， &test_fops); 對設備操作的整個介面
if (result < 0) {
printk(KERN_INFO "test: can't get major number\n");
return result;
}
if (test_major == 0) test_major = result; /* dynamic */
return 0;
}
在用insmod命令將編譯好的模塊調入內存時，init_mole 函數被調用。在這里，init_mole只做了一件事，就是向系統的字元設備表登記了一個字元設備。register_chrdev需要三個參數，參數一是希望獲得的設備號，如果是零的話，系統將選擇一個沒有被佔用的設備號返回。參數二是設備文件名，參數三用來登記驅動程序實際執行操作的函數的指針。
如果登記成功，返回設備的主設備號，不成功，返回一個負值。
void cleanup_mole(void)
{
unregister_chrdev(test_major，"test");
}
在用rmmod卸載模塊時，cleanup_mole函數被調用，它釋放字元設備test在系統字元設備表中佔有的表項。
一個極其簡單的字元設備可以說寫好了，文件名就叫test.c吧。
下面編譯 :
$ gcc -O2 -DMODULE -D__KERNEL__ -c test.c –c表示輸出制定名，自動生成.o文件
得到文件test.o就是一個設備驅動程序。
如果設備驅動程序有多個文件，把每個文件按上面的命令行編譯，然後
ld ?-r ?file1.o ?file2.o ?-o ?molename。
驅動程序已經編譯好了，現在把它安裝到系統中去。
$ insmod ?–f ?test.o
如果安裝成功，在/proc/devices文件中就可以看到設備test，並可以看到它的主設備號。要卸載的話，運行 :
$ rmmod test
下一步要創建設備文件。
mknod /dev/test c major minor
c 是指字元設備，major是主設備號，就是在/proc/devices里看到的。
用shell命令
$ cat /proc/devices
就可以獲得主設備號，可以把上面的命令行加入你的shell script中去。
minor是從設備號，設置成0就可以了。
我們現在可以通過設備文件來訪問我們的驅動程序。寫一個小小的測試程序。
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
main()
{
int testdev;
int i;
char buf[10];
testdev = open("/dev/test"，O_RDWR);
if ( testdev == -1 )
{
printf("Cann't open file \n");
exit(0);
}
read(testdev，buf，10);
for (i = 0; i < 10;i++)
printf("%d\n"，buf[i]);
close(testdev);
}
編譯運行，看看是不是列印出全1
以上只是一個簡單的演示。真正實用的驅動程序要復雜的多，要處理如中斷，DMA，I/O port等問題。這些才是真正的難點。上述給出了一個簡單的字元設備驅動編寫的框架和原理，更為復雜的編寫需要去認真研究LINUX內核的運行機制和具體的設備運行的機制等等。希望大家好好掌握LINUX設備驅動程序編寫的方法。
⑤ 如何寫一個編譯時註解框架
1、註解
我們日常使用的很多開源庫都有註解的實現，主要有運行時註解和編譯時註解兩種。
運行時註解：主要作用就是得到註解的信息
Retrofit：
調用
@GET("/users/{username}")
User getUser(@Path("username") String username);
定義
@Documented
@Target(METHOD)
@Retention(RUNTIME)
@RestMethod("GET")
public @interface GET {
String value();
}
編譯時註解：主要作用動態生成代碼
Butter Knife
調用
@InjectView(R.id.user)
EditText username;
定義
@Retention(CLASS)
@Target(FIELD)
public @interface InjectView {
int value();
}
2、編譯時註解
要實現編譯時註解需要3步：
1、定義註解（關於註解的定義可以參考下面引用的博客）
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.ElementType;
@Target({ ElementType.FIELD, ElementType.TYPE })
@Retention(RetentionPolicy.CLASS)
public @interface Seriable
{
}
2、編寫註解解析器
@SupportedAnnotationTypes("annotation.Seriable")
@SupportedSourceVersion(SourceVersion.RELEASE_6)
public class ViewInjectProcessor extends AbstractProcessor {
@Override
public boolean process(Set annotations,
RoundEnvironment roundEnv) {
for (Element ele : roundEnv.getElementsAnnotatedWith(InjectView.class)) {
if(ele.getKind() == ElementKind.FIELD){
//todo
}
return true;
}
@SupportedAnnotationTypes，定義要支持註解的完整路徑，也可以通過getSupportedAnnotationTypes方法來定義
@Override
public Set getSupportedAnnotationTypes() {
Set types = new LinkedHashSet<>();
types.add(InjectView.class.getCanonicalName());
return types;
}
@SupportedSourceVersion(SourceVersion.RELEASE_6)表示支持的jdk的版本
3、創建制定文件resources/META-INF/services/javax.annotation.processing.Processor，並填寫註解解析器的類路徑，這樣在編譯的時候就能自動找到解析器
看上去實現編譯時註解還是很容易的，但是真要完整的實現一個類似Butter Knife的框架，這還只是開始。
Butter Knife是專注View的注入，在使用註解的類編譯後，查看編譯後的class文件，會發現多出了文件，如：
SimpleActivity$$ViewInjector.java
SimpleActivity$$ViewInjector.java,就是通過編譯時註解動態創建出來的，查看SimpleActivity$$ViewInjector.java的內容
// Generated code from Butter Knife. Do not modify!
package com.example.butterknife;
import android.view.View;
import butterknife.ButterKnife.Finder;
public class SimpleActivity$$ViewInjector {
public static void inject(Finder finder, final com.example.butterknife.SimpleActivity target, Object source) {
View view;
view = finder.findRequiredView(source, 2131230759, "field 'title'");
target.title = (android.widget.TextView) view;
view = finder.findRequiredView(source, 2131230783, "field 'subtitle'");
target.subtitle = (android.widget.TextView) view;
view = finder.findRequiredView(source, 2131230784, "field 'hello', method 'sayHello', and method 'sayGetOffMe'");
target.hello = (android.widget.Button) view;
view.setOnClickListener(
new butterknife.internal.DebouncingOnClickListener() {
@Override
public void doClick(
android.view.View p0
) {
target.sayHello();
}
});
view.setOnLongClickListener(
new android.view.View.OnLongClickListener() {
@Override
public boolean onLongClick(
android.view.View p0
) {
return target.sayGetOffMe();
}
});
view = finder.findRequiredView(source, 2131230785, "field 'listOfThings' and method 'onItemClick'");
target.listOfThings = (android.widget.ListView) view;
((android.widget.AdapterView) view).setOnItemClickListener(
new android.widget.AdapterView.OnItemClickListener() {
@Override
public void onItemClick(
android.widget.AdapterView p0,
android.view.View p1,
int p2,
long p3
) {
target.onItemClick(p2);
}
});
view = finder.findRequiredView(source, 2131230786, "field 'footer'");
target.footer = (android.widget.TextView) view;
}
public static void reset(com.example.butterknife.SimpleActivity target) {
target.title = null;
target.subtitle = null;
target.hello = null;
target.listOfThings = null;
target.footer = null;
}
}
inject方法進行初始化，reset進行釋放。inject都是調用Finder的方法與android系統的findViewById等方法很像，再來看Finder類，只截取部分。
public enum Finder {
public T findRequiredView(Object source, int id, String who) {
T view = findOptionalView(source, id, who);
if (view == null) {
String name = getResourceEntryName(source, id);
throw new IllegalStateException("Required view '"
+ name
+ "' with ID "
+ id
+ " for "
+ who
+ " was not found. If this view is optional add '@Nullable' (fields) or '@Optional'"
+ " (methods) annotation.");
}
return view;
}
public T findOptionalView(Object source, int id, String who) {
View view = findView(source, id);
return castView(view, id, who);
}
@Override protected View findView(Object source, int id) {
return ((View) source).findViewById(id);
}
@SuppressWarnings("unchecked") // That's the point.
public T castView(View view, int id, String who) {
try {
return (T) view;
} catch (ClassCastException e) {
if (who == null) {
throw new AssertionError();
}
String name = getResourceEntryName(view, id);
throw new IllegalStateException("View '"
+ name
+ "' with ID "
+ id
+ " for "
+ who
+ " was of the wrong type. See cause for more info.", e);
}
}
findRequiredView方法實際上就是我們常用findViewById的實現，其動態幫我們添加了這些實現。view注入的原理我們就清楚了。
雖然編譯時創建了這個類，運行的時候如何使用這個類呢，這里我用自己實現的一個類來描述
public class XlViewInjector {
static final Map, AbstractInjector> INJECTORS = new LinkedHashMap, AbstractInjector>();
public static void inject(Activity activity){
AbstractInjector injector = findInjector(activity);
injector.inject(Finder.ACTIVITY, activity, activity);
}
public static void inject(Object target, View view){
AbstractInjector injector = findInjector(target);
injector.inject(Finder.VIEW, target, view);
}
private static AbstractInjector findInjector(Object target){
Class clazz = target.getClass();
AbstractInjector injector = INJECTORS.get(clazz);
if(injector == null){
try{
Class injectorClazz = Class.forName(clazz.getName()+"$$"+ProxyInfo.PROXY);
injector = (AbstractInjector) injectorClazz.newInstance();
INJECTORS.put(clazz, injector);
}catch(Exception e){
e.printStackTrace();
}
}
return injector;
}
}
XlViewInjector與ButterKnife，比如調用時我們都會執行XlViewInjector.inject方法，通過傳入目標類的名稱獲得封裝後的類實例就是SimpleActivity$$ViewInjector.java，再調用它的inject，來初始化各個view。
總結一下整個實現的流程：
1、通過編譯時註解動態創建了一個包裝類，在這個類中已解析了註解，實現了獲取view、設置監聽等代碼。
2、執行時調用XlViewInjector.inject（object）方法，實例化object類對應的包裝類，並執行他的初始化方法inject；
因此我們也能明白為什麼XlViewInjector.inject（object）方法一定要在setContentView之後執行。
3、實現註解框架時的坑
解析有用到android api，因此需要創建Android工程，但是android library並沒有javax的一些功能，
在eclipse環境下，右鍵build-path add library把jdk加進來
在android studio下，需要先創建java Library功能，實現與view無關的解析，再創建一個android library功能引用這個工程並實現餘下的解析。
⑥ 有什麼動態編譯java源代碼的框架
可以的，我說說大概思路，很簡單，你自己具體實現吧，把代碼寫給你沒意義的：
將你這段字元串輸出到一個文件里，用Java類文件的方式命名。
2.調用外部javac命令將該文件編譯。
3.用類載入器（ClassLoad）動態載入新的class文件並用Class.forName()注冊該類，然後就可以正常使用了。
上面的每一步都能在中找到實現方法，自己發揮吧。
⑦ 如何編譯CNTK框架
如何編譯CNTK框架
現階段不可能。
.NET 下你用的所有 CLR 方法也好類也好都是封裝在一個個 .NET Framework 的 DLL 里的，程序運行時必須這些文件，除非你一個 CLR 類和方法都沒用過（那不就是純 C 語言而且是只有標准庫的 C 了么）。
有些類似於 Remote Soft's Salamander .NET Native Compiler、Infralution Globalizer 這些工具，也不是把代碼編譯成機器語言了，而是把需要的類庫等直接寫入了 PE，會導致程序體積大大增加，而且只支持 .NET 2.0，最重要的是還是收費軟體。
⑧ 什麼是程序的編輯器,編譯器,什麼是Framework(框架)
編譯器是程序輔助工具，一般會生成一些幫助代碼
框架是編程的一種模式，把正個代碼實現的功能按起的作用分類，可以使思路清析