|
最近又開始做ACM了。原因是,我在學校里面找了份兼職,做ACM興趣班的助教。 任務是給大一的新生講一些ACM的入門知識。 雖然講的東西很基礎很簡單,但我覺得他們的潛力巨大,很快就能達到跟我一樣的水平。。 所以我自己也得補下課啦。 這次我下決心,堅決不做一道水題! 我放棄了原來在POJ賬號,轉戰HOJ,因為這樣我才不會為了題目數量而刷水題。 我覺得以前真的很傻逼,老是挑著做一些自己已經會了的題目,還總是抱怨自己的水平一直沒提高。 整天刷水題,水平他媽的能提高么。 人都是很懶的,懶得動腦子,只是享受敲完一道水題后ac的感覺,還很有成就感。 但這樣子有什么用,遇到難題的時候,始終還是想不出來,還以為是自己腦子不好使。 實際上不是的,只要克服惰性,多思考問題,每個人的腦子都是很好使的。 我挑戰的第一道難題,呵呵,對我來說比較難的題,就是這道。 想了一下發現了這個規律: (A*B)%M = ((A%M)*(B%M))%M 演算一下就可以得出這個的。 對與輸入中的一個數字,可以分別計算出: A%M A^2 %M A^4 %M ... 然后再相乘取模就行了。 這樣二分一下,就很好辦了。 這是我自己克服了懶惰動了腦子想出來的!我他媽的很自豪!
#include <stdio.h>

__int64 N, K, A, B, C, d, i, n, ans;
#define M 200907

int main()
  {
scanf("%I64d", &N);
 while (N--) {
scanf("%I64d%I64d%I64d%I64d", &A, &B, &C, &K);
 if (B - A == C - B) {
ans = ((A%M) + (((K-1)%M)*((B-A)%M)%M))%M;
 } else {
d = (B/A)%M;
n = K - 1;
ans = A%M;
 for (i = 0; (1LL << i) <= n; i++) {
if (n & (1LL << i))
ans = (ans*d)%M;
d = (d*d)%M;
}
}
printf("%I64d\n", ans);
}

return 0;
}

apt-get install xfwm4 apt-get install scim-chinese apt-get install roxterm cat >~/.xinitrc <<E roxterm & scim & xfwm4 E xinit
插入買機的時候送的驅動光盤,灰色的那張。 mount /dev/cdrom /media/cdrom cd /tmp find /media/cdrom -name '*.exe' | while read i; do unzip -ao $i; done cd DRIVER_US ndiswrapper -i bcmwl5.inf rmmod b43 rmmod ssb modprobe ndiswrapper iwconfg .....
題意: 給出N條木棍的長度,問能不能用這些木棍拼成一個正方形。
思路: 這題一開始想復雜了,后來發現只要2個最簡單的剪枝題目就能79ms通過了。 再加上一個比較屌的剪枝就可以到16ms。 參考了網上的代碼,很多份代碼如出一轍。思想十分牛逼。
剪枝1: 所有木棍的長度必須能被4整除 剪枝2: 最長的木棍不能長于正方形的邊長 這兩個是最容易想到的,用上這兩個可以79ms通過 剪枝3: 同樣長度的木棍的同樣數量的組合只搜索一次。 這個剪枝需要將木棍從大到小排列,在搜索的時候加一句代碼就行了,代碼很巧妙。 由于數據問題,這個剪枝貌似不管用。 剪枝4: 每條邊的木棍按照從大到小的順序拼接 如果某條木棍不能夠作為某邊的第一條木棍,那比它短的也不行 想一想還是可以理解,后面的邊始終會用到這條長的棍子,那時候可供選擇的木棍更少 所以在前面的邊拼不成,在后面的邊更加拼不成 這個剪枝非常牛逼,不知道誰想出來的,代碼只需要一句。太牛逼了。 由于數據的N比較小,這個剪枝相當管用。 無法實現的理想化剪枝: 如果在枚舉中,發現用一條長的棍子枚舉失敗,那么幾條短的棍子組成同樣長度的棍子也必然不用試驗。 這個很理想,但是實現的代價很大。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 1+2 : 79ms
// 1+2+3 : 79ms
// 1+2+4 : 16ms
// 1+2+3+4: 16ms

int part, N;
int len[128];
char used[128];

int cmp(const void *a, const void *b)
  {
return *(int *)b - *(int *)a;
}

int dfs(int side, int start, int left)
  {
int i;

 if (!left) {
left = part;
side++;
start = 0;
}

if (side == 4)
return 1;

 for (i = start; i < N; i++) {
if (len[i] > left)
continue;
if (used[i])
continue;

// 3
if (i && !used[i - 1] && len[i] == len[i - 1])
continue;

used[i] = 1;
if (dfs(side, i + 1, left - len[i]))
return 1;
used[i] = 0;

// 4
if (left == part)
return 0;
}

return 0;
}

int solve()
  {
int i, sum;

scanf("%d", &N);
sum = 0;
 for (i = 0; i < N; i++) {
scanf("%d", &len[i]);
sum += len[i];
}

// 1
if (sum % 4)
return 0;

part = sum / 4;
qsort(len, N, sizeof(len[0]), cmp);
// 2
if (len[0] > part)
return 0;

memset(used, 0, N);
return dfs(0, 0, part);
}

int main()
  {
int t;

scanf("%d", &t);
while (t--)
printf("%s\n", solve() ? "yes" : "no");

return 0;
}


題目大意: 給出一個玩到一半的漢諾塔。叫你把所有的盤子歸到任意一根針上,求最少步數。
由于結果很大,輸出它和100000的模。 最基本的思路是動態規劃,跟一般的漢諾塔問題類似 位于任意一個狀態的漢諾塔。必然有位于最底層的最大的盤子。 最終的目的是把這個盤子移動到某根針上。 所以必然會出現的一個場景就是: 最大的盤子單獨在一根針上,其他的盤子在另外一根針上 假設: f(n, idx) = { 將初始狀態下盤子 1~n 集中到第idx根針上所需要的最小步數 } g(n) = { 將位于一根針上的盤子 1~n 移動到另外一根針所需要的最小步數 } 那么轉移方程就是: f(n, idx) = { 如果盤子n位于idx:f(n - 1, idx) 否則:f(n - 1, idx) } 從普通的漢諾塔問題上可以得出: g(n) = 2^n - 1
這題很難,我只寫出了一個TLE的版本。 后來找了解題報告,只找到了一個,就是這位alpc43大牛的版本: http://hi.baidu.com/alpc43/blog/item/95184e03a5fef4e209fa932d.html
這個代碼很牛逼! 它的思路是:
1)首先按照常規的方法求出最長公共子序列的長度 也就是用O(MN)的那個動態規劃,結果放在二維數組dp里 dp[i][j] = { 字串a的1~i部分與字串b的1~j部分的最長公共子序列的長度 } 2)求輔助數組 last1[i][j] = { 到下標i為止,字符j在字串a中最后一次出現的下標 } last2[i][j] = { 到下標i為止,字符j在字串b中最后一次出現的下標 } 3)枚舉最長公共字串的每一個字符 從最后一個字符開始枚舉 比如說現在枚舉最后一個字符是'C'的情況。 那么 'CDCD' 與 'FUCKC' 這兩個字串。 一共有 (0, 2) (0, 4) (2, 2) (2. 4) 這四種可能。 很明顯前三個是可以舍棄的,因為第四個優于前三個,為后續的枚舉提供了更大的空間。 last數組正好是用來做這個的。 4)排序輸出 代碼里用了stl的set。 注意,由于剛剛的枚舉過程是針對每個字符,所以是不用判重的。 這個思路非常之牛逼!
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <string>
#include <set>;

using namespace std;

const int MAXLEN=100;
char s1[MAXLEN];
char s2[MAXLEN];
int len1,len2;
int dp[MAXLEN][MAXLEN];
int last1[MAXLEN][27];
int last2[MAXLEN][27];
int longest;
char temp[MAXLEN];
set<string> SET;
void input()
  {
scanf("%s %s",&s1[1],&s2[1]);

}
inline int maxab(int a,int b)
  {
if(a>b) return a;
return b;
}

inline void find(int x,int y,int len)
  {
if(len<=0)
 {
//printf("%s\n",&temp[1]);
SET.insert(&temp[1]);
return ;
}
int i,j;
if(x>0 && y>0)
 {
for(i=0;i<26;i++)
 {
int t1=last1[x][i];
int t2=last2[y][i];
if(dp[t1][t2]==len)
 {
temp[len]='a'+i;
find(t1-1,t2-1,len-1);
}
}
}
}
void solve()
  {
int i,j,k;
len1=strlen(&s1[1]);
len2=strlen(&s2[1]);
for(i=0;i<=len1;i++)
dp[i][0]=0;
for(i=0;i<=len2;i++)
dp[0][i]=0;
for(i=1;i<=len1;i++)
for(j=1;j<=len2;j++)
 {
if(s1[i]==s2[j])
dp[i][j]=dp[i-1][j-1]+1;
else dp[i][j]=maxab(dp[i-1][j],dp[i][j-1]);
}
longest=dp[len1][len2];

for(j=0;j<26;j++)
for(i=0;i<=len1;i++)
last1[i][j]=0;
for(j=0;j<26;j++)
for(i=0;i<=len2;i++)
last2[i][j]=0;
for(i=1;i<=len1;i++)
 {
for(j=0;j<26;j++)
 {
if(s1[i]=='a'+j)
last1[i][j]=i;
else last1[i][j]=last1[i-1][j];
}
}
for(i=1;i<=len2;i++)
 {
for(j=0;j<26;j++)
 {
if(s2[i]=='a'+j)
last2[i][j]=i;
else last2[i][j]=last2[i-1][j];
}
}
temp[longest+1]='\0';
find(len1,len2,longest);
set<string>::iterator it;
for(it=SET.begin();it!=SET.end();it++)
 {
printf("%s\n",(*it).c_str());
}
}
int main()
  {
freopen("e:\\in.txt", "r", stdin);

input();
solve();
return 0;
}
大學畢業時,爸說:“你一定要念一個碩士學位。不用念博士,可是碩士是一定要的。”
為什么“碩士是一定要的”?我沒問。爸爸對我的要求非常少,所以一旦他開口了,我都很“上道”的照單全收,當然,也因為碩士大都很容易念,選個容易的科目,常常可以在九個月內就拿到碩士。
博士就麻煩得多,要是不幸遇上貪圖廉價人工的指導教授,想把研究生一直留在身邊幫忙,那一個博士學位耗掉你十年以上,也是常有的事。 所以我就很安然的接受了爸的指示。
“沒問題,一個碩士。”我很有精神的覆誦一次,好像柜臺后的日本料理師傅。
“而且要念一流的學校。”爸進行第二階段的指示。
“沒問題,一流學校。”師傅覆誦客人點的第二道菜。
我當然很同意“念一流學校”的想法。我在大學四年,整天聽我有學問的好友阿筆,不斷告訴我西方最厲害的幾間大學,到底都厲害在什么地方:柏克萊待了多少個得過諾貝爾獎的物理學家、約翰霍普金斯大學的醫學院又完成了什么手術、德國的法學博士和美國的有何不同、牛津的研究生吃晚飯時要穿什么、康乃爾的研究生為什么自殺比例最高……聊的都是這一類的事情。
對于在臺灣各種爛學校混了十幾年的我們來說,沒事就把這些知識神殿的名字,在牙齒之間盤弄一番,實在是個方便又悲傷的娛樂。 就像兩個臺灣的初中男生,翻看著“花花公子”雜志拉頁上的金發兔女郎。夾雜著向往和民族的自卑。
爸對學位的指示,已經清楚收到。“一流學校、碩士就好”。
輪到我對爸開出條件了。
有風格的料理師傅,是不會任憑客人想點什么、就做什么的。客人可以要求吃生魚片,可是有風格的師夫,會決定此刻最適合做生魚片的,是哪一種魚。也就是說,你點歸你點,未必吃得到。
“爸,我只念我想念的東西喔。”
“可以,不要念太多就好。”
爽快。這是爸跟我隨著歲月培養出來的默契。各取所需,互蒙其利。
不過,老實說,“我取我需”的狀況,似乎比“爸取爸需”的狀況,要多那么一兩百次吧。
我想念的東西,對一般的臺灣爸媽來說,似乎有點怪。
我想學“舞臺劇”。
還好我爸不是“一般的臺灣爸媽”。
從小到大,爸從來沒問過我:“這有什么用?”
“這有什么用?”幾乎是我們這個島上,最受歡迎的一個問題。每個人都好像上好發條的娃娃,你只要拍他的后腦一下,他就理直氣壯的問:“這有什么用?”
“我想學舞臺劇。”“這有什么用?”
“我正在讀《追憶似水年華》。”“這有什么用?”
“我會彈巴哈了。”“這有什么用?”
“我會辨認楝樹了。”“這有什么用?”
這是我最不習慣回答的問題,因為我沒被我爸問過這個問題。
從小,我就眼睜睜看著爸媽做很多“一點用也沒有”的事情。爸買回家里一件又一件動不動就摔破的瓷器水晶;媽叫裁縫來家里量制一件又一件繁復的旗袍;一桌又一桌吃完就沒有的大菜;一圈又一圈堆倒又砌好的麻將,從來沒有半個人會問:“這有什么用?”
“漂不漂亮?”“喜不喜歡?”“好不好吃?”這些才是整天會被問到的問題。
長大以后,越來越常被別人問:“這有什么用?”才忽然領悟很多人,是隨著這個問題一起長大的。
我不大確定——這是不是值得慶幸的事。一直到,反復確認了“人生最重要的東西,其實都沒有什么用”時,才覺得自己運氣真好。
人生,并不是拿來用的。
愛情,光榮,正義,尊嚴,文明,這些一再在灰黯時刻拯救我、安慰我的力量,對很多人來講“沒有用”,我卻堅持相信這才都是人生的珍寶,才禁得起反復追求。
Dinic算法是一種比較容易實現的,相對比較快的最大流算法。 今天看了一下它的原理,發現的確很牛逼。
求最大流的本質,就是不停的尋找增廣路徑。直到找不到增廣路徑為止。 對于這個一般性的過程,Dinic算法的優化如下:
(1) Dinic算法首先對圖進行一次BFS,然后在BFS生成的層次圖中進行多次DFS。 層次圖的意思就是,只有在BFS樹中深度相差1的節點才是連接的。 這就切斷了原有的圖中的許多不必要的連接。很牛逼! 這是需要證明的,估計證明也很復雜。
(2) 除此之外,每次DFS完后,會找到路徑中容量最小的一條邊。 在這條邊之前的路徑的容量是大于等于這條邊的容量的。 那么從這條邊之前的點,可能引發出別的增廣路徑。 比如說 S -> b -> c -> d -> T 是一條增廣路徑,容量最小的邊是 b -> c。 可能存在一條 S -> b -> e -> f -> g -> T 這樣的增廣路徑。 這樣的話,在找到第一條增廣路徑后,只需要回溯到 b 點,就可以繼續找下去了。 這樣做的好處是,避免了找到一條路徑就從頭開始尋找另外一條的開銷。 也就是再次從 S 尋找到 b 的開銷。 這個過程看似復雜,但是代碼實現起來很優雅,因為它的本質就是回溯!
(3) 在同一次 DFS 中。如果從一個點引發不出任何的增廣路徑,就將這個點在層次圖中抹去。 而這樣一個算法,實現起來居然只需要100行。太吊了。 我的代碼是參考別人的代碼寫的。可以用 POJ 1273 測試。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

#define MAX_VETXS 1024
#define MAX_EDGES 1024

int E[MAX_EDGES], next[MAX_EDGES], C[MAX_EDGES], M;
int V[MAX_VETXS], L[MAX_VETXS], Q[MAX_VETXS], N;
int S, T;

void __insert(int from, int to, int cap)
  {
M++;
C[M] = cap;
E[M] = to;
next[M] = V[from];
V[from] = M;
}

void insert(int from, int to, int cap)
  {
__insert(from, to, cap);
__insert(to, from, 0);
}

int bfs()
  {
int h, t, e, u, v;

h = t = 0;
Q[t++] = S;
memset(L, 0, N*sizeof(L[0]));
L[S] = 1;
 while (h != t) {
u = Q[h++];
 for (e = V[u]; e; e = next[e]) {
v = E[e];
 if (!L[v] && C[e] > 0) {
L[v] = L[u] + 1;
Q[t++] = v;
}
}
}

return L[T];
}

int dfs()
  {
int t, u, v, e, i, f, r, back;

t = 1;
r = 0;

 while (t) {
u = (t == 1) ? S : E[Q[t - 1]];
 if (u == T) {
f = INT_MAX;
 for (i = 1; i < t; i++) {
e = Q[i];
 if (C[e] < f) {
f = C[e];
back = i;
}
}
 for (i = 1; i < t; i++) {
e = Q[i];
C[e] -= f;
C[e^1] += f;
}
r += f;
t = back;
 } else {
 for (e = V[u]; e; e = next[e]) {
v = E[e];
if (L[v] == L[u] + 1 && C[e] > 0)
break;
}
if (e)
Q[t++] = e;
 else {
t--;
L[u] = 0;
}
}
}

return r;
}

int dinic()
  {
int f = 0;

while (bfs())
f += dfs();

return f;
}

int main()
  {
int n, m, a, b, c, i;

freopen("d:\\in.txt", "r", stdin);

 while (scanf("%d%d", &n, &m) != EOF) {
S = 0;
T = m - 1;
N = m;
memset(V, 0, N*sizeof(V[0]));
M = 2;
 for (i = 0; i < n; i++) {
scanf("%d%d%d", &a, &b, &c);
insert(a - 1, b - 1, c);
}
printf("%d\n", dinic());
}

return 0;
}

語法分析 - 后臺運行、管道、重定向
--- 后臺運行 我們從上一節提到的入口點 inputunit 看起。
inputunit: simple_list simple_list_terminator ... ;
simple_list: simple_list1 | simple_list1 '&' | simple_list1 ';' ;
simple_list1: simple_list1 AND_AND newline_list simple_list1 | simple_list1 OR_OR newline_list simple_list1 | simple_list1 '&' simple_list1 | simple_list1 ';' simple_list1 | pipeline_command ;
這幾句語法的功能,就是平時很常用的: check_ok && do_sth file_exists || create_it firefox & do_a; do_b; do_c; do_d
--- 管道 來看一下 pipe_command
pipeline_command: pipeline | BANG pipeline ... ;
pipeline: pipeline '|' newline_list pipeline | command ;
newline_list: | newline_list '\n' ;
BANG 對應的符號是 '!' 這里把 BANG 和 pipeline 放到一起并不是說明 '!' 和管道有什么關系。 只是在這里實現 '!' 這個符號的功能而已。
--- command_connect() 我們注意到,在語法的處理函數中,command_connect 這個函數被經常使用。
COMMAND * command_connect (com1, com2, connector) COMMAND *com1, *com2; int connector; { CONNECTION *temp;
temp = (CONNECTION *)xmalloc (sizeof (CONNECTION)); temp->connector = connector; temp->first = com1; temp->second = com2; return (make_command (cm_connection, (SIMPLE_COM *)temp)); } 這個函數的作用就是把兩個相關的語法樹節點連接起來,并構成一個新的節點。 而 COMMAND 這個數據結構,里面就包含了指向兩個孩子的指針,以及跟連接相關的屬性。 這里我們先不去詳細的看它。
--- 重定向 從 pipeline 引出了 command 。
command: simple_command | shell_command | shell_command redirection_list { COMMAND *tc;
tc = $1; if (tc->redirects) { register REDIRECT *t; for (t = tc->redirects; t->next; t = t->next) ; t->next = $2; } else tc->redirects = $2; $$ = $1; } | function_def ;
redirection_list: redirection | redirection_list redirection ;
這個項應該就是傳說中的,單項命令的實體了。 我們暫時不去理會其他的東西,先看一看 redirection_list。 那一段處理函數可以看出,它把一系列的重定向操作加入到 shell_command 的 redirects 鏈表尾部。 而 redirection_list 包含的內容就比較多了,也就是重定向的所有語法啦。
redirection: '>' WORD // > xxx | '<' WORD // < xxx | NUMBER '>' WORD // 1> xxx | NUMBER '<' WORD // 0< xxx | GREATER_GREATER WORD // >> xxx | NUMBER GREATER_GREATER WORD // 2>> xxx | LESS_LESS WORD // << xxx | NUMBER LESS_LESS WORD // 0<< xxx | LESS_LESS_LESS WORD // <<< xxx | NUMBER LESS_LESS_LESS WORD // 0<<< xxx | LESS_AND NUMBER // <&2 | NUMBER LESS_AND NUMBER // 1<&2 | GREATER_AND NUMBER // >&1 | NUMBER GREATER_AND NUMBER // 2>&1 | LESS_AND WORD // <& xxx | NUMBER LESS_AND WORD // 1<& xxx | GREATER_AND WORD // >& xxx | NUMBER GREATER_AND WORD // 1>& xxx | LESS_LESS_MINUS WORD // <<- xxx | NUMBER LESS_LESS_MINUS WORD // 1 <<- xxx | GREATER_AND '-' // >&- | NUMBER GREATER_AND '-' // 1>&- | LESS_AND '-' // <&- | NUMBER LESS_AND '-' // 1<&- | AND_GREATER WORD // &> xxx | NUMBER LESS_GREATER WORD // 1<> xxx | LESS_GREATER WORD // <> xxx | GREATER_BAR WORD // >| xxx | NUMBER GREATER_BAR WORD // 1>| xxx ;
可見,真的是十分之多阿,每一條后面我都加了注釋。 平時常用的基本只有幾種了,有一部分是《bash高級編程》里面提到的, 有些就是根本沒提到,完全沒見過的用法。。 現在我們先不去深究這些用法。
語法分析 - 入口點
--- main() 我們打開shell.c的main函數,大概300來行,其主題都是圍繞這xxx_init,做各種初始化操作。 我們可以略過不看,等遇到問題的時候再說。把目光放到最后一句 reader_loop()。這是一個循環讀 入并執行命令的函數。
--- reader_loop() 位于eval.c的reader_loop()函數,其中仿佛只有調用read_command()是重點。
--- read_command() 同樣位于eval.c的read_command()函數。一開始那一段ALARM信號的處理讓人覺得很費解,難道 在bash輸入命令還要有時間限制嗎?無論如何,這種看似偏門的、非關鍵性的東西,在代碼分析的初期 是不能理會的,如果太深究這些東西,沒有把握代碼的主線,則會走入死胡同,而且會失去源碼分析 的樂趣。 代碼主線走入parse_command()函數。
--- parse_command() 同樣位于eval.c的parse_command()函數。它調用的yyparse()函數是語法分析的開始。 用過yacc的人很明白這一點了。一開始我們看到文件列表中有y.tab.c這樣的文件,就能意識到bash也是 利用yacc生成的代碼來完成語法分析的。
--- Yacc的作用 你只要告訴yacc三樣東西:語法、每一條語法的處理函數、負責詞法分析的函數 yacc就會為你生成y.tab.c文件,只要調用這個文件中的yyparse()函數,就可以完成編譯器的 詞法分析和語法分析的部分了。在分析的過程中,你剛剛指定的每一條語法對應的處理函數也會 被調用。關于yacc的具體介紹,可以在網上搜搜,很多的。
例子: 告訴yacc:語法和對應的處理函數。 expr : expr '+' expr { $$ = add($1, $3) } | expr '*' expr { $$ = mul($1, $3) } | expr '-' expr { $$ = sub($1, $3) } | NUMBER ; 調用yyparse(),輸入 1 + 2 add(1, 2) 就會被回調了 在處理函數中 $$ 代表著處理函數的返回值 $1 代表著該條語法中的第一個元素(expr) $2 代表著該條語法中的第二個元素('+') $3 代表著該條語法中的第三個元素(expr) 至于說這些元素的類型,則會在前面定義。比如 %type<char *> expr 之類。 具體的還是找篇文章看看吧。
--- parse.y 觀察Makefile可以發現: y.tab.c y.tab.h: parse.y $(YACC) -d $(srcdir)/parse.y y.tab.c是由parse.y生成的。而parse.y中包含了語法和對應的處理函數,它是語法分析的核心文件。
首先是一個%union定義 %union { WORD_DESC *word; /* the word that we read. */ int number; /* the number that we read. */ WORD_LIST *word_list; COMMAND *command; REDIRECT *redirect; ELEMENT element; PATTERN_LIST *pattern; }
然后是一系列的token定義:
/* Reserved words. Members of the first group are only recognized in the case that they are preceded by a list_terminator. Members of the second group are for [[...]] commands. Members of the third group are recognized only under special circumstances. */ %token IF THEN ELSE ELIF FI CASE ESAC FOR SELECT WHILE UNTIL DO DONE FUNCTION %token COND_START COND_END COND_ERROR %token IN BANG TIME TIMEOPT
/* More general tokens. yylex () knows how to make these. */ %token <word> WORD ASSIGNMENT_WORD %token <number> NUMBER %token <word_list> ARITH_CMD ARITH_FOR_EXPRS %token <command> COND_CMD %token AND_AND OR_OR GREATER_GREATER LESS_LESS LESS_AND LESS_LESS_LESS %token GREATER_AND SEMI_SEMI LESS_LESS_MINUS AND_GREATER LESS_GREATER %token GREATER_BAR
讀入字符串流,返回token是詞法分析函數的責任。 以%token定義,表明返回值是int類型 以%token <word>定義,表明返回值是%union中對應的類型
詞法分析函數是lex生成的,但這個工程好像把原始的 .lex文件刪除了。我們只能看到生成后的yylex()函數。 但有一個表,可以看出token對應的字串內容:
/* Reserved words. These are only recognized as the first word of a command. */ STRING_INT_ALIST word_token_alist[] = { { "if", IF }, { "then", THEN }, { "else", ELSE }, { "elif", ELIF }, { "fi", FI }, { "case", CASE }, { "esac", ESAC }, { "for", FOR }, #if defined (SELECT_COMMAND) { "select", SELECT }, #endif { "while", WHILE }, { "until", UNTIL }, { "do", DO }, { "done", DONE }, { "in", IN }, { "function", FUNCTION }, #if defined (COMMAND_TIMING) { "time", TIME }, #endif { "{", '{' }, { "}", '}' }, { "!", BANG }, #if defined (COND_COMMAND) { "[[", COND_START }, { "]]", COND_END }, #endif { (char *)NULL, 0} };
/* other tokens that can be returned by read_token() */ STRING_INT_ALIST other_token_alist[] = { /* Multiple-character tokens with special values */ { "-p", TIMEOPT }, { "&&", AND_AND }, { "||", OR_OR }, { ">>", GREATER_GREATER }, { "<<", LESS_LESS }, { "<&", LESS_AND }, { ">&", GREATER_AND }, { ";;", SEMI_SEMI }, { "<<-", LESS_LESS_MINUS }, { "<<<", LESS_LESS_LESS }, { "&>", AND_GREATER }, { "<>", LESS_GREATER }, { ">|", GREATER_BAR }, { "EOF", yacc_EOF }, /* Tokens whose value is the character itself */ { ">", '>' }, { "<", '<' }, { "-", '-' }, { "{", '{' }, { "}", '}' }, { ";", ';' }, { "(", '(' }, { ")", ')' }, { "|", '|' }, { "&", '&' }, { "newline", '\n' }, { (char *)NULL, 0} };
/* others not listed here: WORD look at yylval.word ASSIGNMENT_WORD look at yylval.word NUMBER look at yylval.number ARITH_CMD look at yylval.word_list ARITH_FOR_EXPRS look at yylval.word_list COND_CMD look at yylval.command */
這些token在語法中會遇到的。
接下來是對語法中每一項內容(編譯原理沒學好,不知道這個術語叫什么。。)的定義:
/* The types that the various syntactical units return. */
%type <command> inputunit command pipeline pipeline_command %type <command> list list0 list1 compound_list simple_list simple_list1 %type <command> simple_command shell_command %type <command> for_command select_command case_command group_command %type <command> arith_command %type <command> cond_command %type <command> arith_for_command %type <command> function_def function_body if_command elif_clause subshell %type <redirect> redirection redirection_list %type <element> simple_command_element %type <word_list> word_list pattern %type <pattern> pattern_list case_clause_sequence case_clause %type <number> timespec %type <number> list_terminator
%start inputunit
從名字上來看,大概能知道是作什么的。 %start 表示整個語法分析的入口是 inputunit 那一項。 接著就是語法了,內容就比較多,不直接貼了。 語法是我比較感興趣的地方,無論看哪本關于bash的書,都不如看代碼來的直接,呵呵。 我們以后慢慢看。
|