• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>
    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>
            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>

            糯米

            TI DaVinci, gstreamer, ffmpeg
            隨筆 - 167, 文章 - 0, 評論 - 47, 引用 - 0
            數據加載中……

            HDU 2817 A sequence of numbers 數論

            最近又開始做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;
            }

            posted @ 2010-10-25 21:29 糯米 閱讀(340) | 評論 (0)編輯 收藏

            ubuntu下安裝精簡而實用的桌面環境

            apt-get install xfwm4
            apt-get install scim-chinese
            apt-get install roxterm
            cat >~/.xinitrc <<E
            roxterm &
            scim &
            xfwm4
            E
            xinit

            posted @ 2010-10-08 20:49 糯米 閱讀(742) | 評論 (0)編輯 收藏

            dell m1330 xps筆記本linux下的無線網卡驅動的安裝

            插入買機的時候送的驅動光盤,灰色的那張。
            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 .....

            posted @ 2010-10-08 20:43 糯米 閱讀(549) | 評論 (0)編輯 收藏

            POJ 2362 Square 搜索

            題意:
            給出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(00, part);
            }


            int main()
            {
                
            int t;

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

                
            return 0;
            }




            posted @ 2010-10-04 13:08 糯米 閱讀(993) | 評論 (0)編輯 收藏

            POJ 1920 Towers of Hanoi 漢諾塔問題

            題目大意:
            給出一個玩到一半的漢諾塔。叫你把所有的盤子歸到任意一根針上,求最少步數。

            由于結果很大,輸出它和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

            posted @ 2010-09-27 14:58 糯米 閱讀(806) | 評論 (0)編輯 收藏

            POJ 1934 Trip 打印出所有的最長公共子序列

            這題很難,我只寫出了一個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;
            }

            posted @ 2010-09-27 14:30 糯米 閱讀(1998) | 評論 (0)編輯 收藏

            別問這有什么用---蔡康永

            大學畢業時,爸說:“你一定要念一個碩士學位。不用念博士,可是碩士是一定要的。” 

            為什么“碩士是一定要的”?我沒問。爸爸對我的要求非常少,所以一旦他開口了,我都很“上道”的照單全收,當然,也因為碩士大都很容易念,選個容易的科目,常常可以在九個月內就拿到碩士。 

            博士就麻煩得多,要是不幸遇上貪圖廉價人工的指導教授,想把研究生一直留在身邊幫忙,那一個博士學位耗掉你十年以上,也是常有的事。 
            所以我就很安然的接受了爸的指示。 

            “沒問題,一個碩士。”我很有精神的覆誦一次,好像柜臺后的日本料理師傅。 

            “而且要念一流的學校。”爸進行第二階段的指示。 

            “沒問題,一流學校。”師傅覆誦客人點的第二道菜。 

            我當然很同意“念一流學校”的想法。我在大學四年,整天聽我有學問的好友阿筆,不斷告訴我西方最厲害的幾間大學,到底都厲害在什么地方:柏克萊待了多少個得過諾貝爾獎的物理學家、約翰霍普金斯大學的醫學院又完成了什么手術、德國的法學博士和美國的有何不同、牛津的研究生吃晚飯時要穿什么、康乃爾的研究生為什么自殺比例最高……聊的都是這一類的事情。 

            對于在臺灣各種爛學校混了十幾年的我們來說,沒事就把這些知識神殿的名字,在牙齒之間盤弄一番,實在是個方便又悲傷的娛樂。 
            就像兩個臺灣的初中男生,翻看著“花花公子”雜志拉頁上的金發兔女郎。夾雜著向往和民族的自卑。 

            爸對學位的指示,已經清楚收到。“一流學校、碩士就好”。 

            輪到我對爸開出條件了。 

            有風格的料理師傅,是不會任憑客人想點什么、就做什么的。客人可以要求吃生魚片,可是有風格的師夫,會決定此刻最適合做生魚片的,是哪一種魚。也就是說,你點歸你點,未必吃得到。 

            “爸,我只念我想念的東西喔。” 

            “可以,不要念太多就好。” 

            爽快。這是爸跟我隨著歲月培養出來的默契。各取所需,互蒙其利。 


            不過,老實說,“我取我需”的狀況,似乎比“爸取爸需”的狀況,要多那么一兩百次吧。 

            我想念的東西,對一般的臺灣爸媽來說,似乎有點怪。 

            我想學“舞臺劇”。 

            還好我爸不是“一般的臺灣爸媽”。 

            從小到大,爸從來沒問過我:“這有什么用?” 

            “這有什么用?”幾乎是我們這個島上,最受歡迎的一個問題。每個人都好像上好發條的娃娃,你只要拍他的后腦一下,他就理直氣壯的問:“這有什么用?” 

            “我想學舞臺劇。”“這有什么用?” 

            “我正在讀《追憶似水年華》。”“這有什么用?” 

            “我會彈巴哈了。”“這有什么用?” 

            “我會辨認楝樹了。”“這有什么用?” 

            這是我最不習慣回答的問題,因為我沒被我爸問過這個問題。 

            從小,我就眼睜睜看著爸媽做很多“一點用也沒有”的事情。爸買回家里一件又一件動不動就摔破的瓷器水晶;媽叫裁縫來家里量制一件又一件繁復的旗袍;一桌又一桌吃完就沒有的大菜;一圈又一圈堆倒又砌好的麻將,從來沒有半個人會問:“這有什么用?” 

            “漂不漂亮?”“喜不喜歡?”“好不好吃?”這些才是整天會被問到的問題。 

            長大以后,越來越常被別人問:“這有什么用?”才忽然領悟很多人,是隨著這個問題一起長大的。 

            我不大確定——這是不是值得慶幸的事。一直到,反復確認了“人生最重要的東西,其實都沒有什么用”時,才覺得自己運氣真好。 

            人生,并不是拿來用的。 

            愛情,光榮,正義,尊嚴,文明,這些一再在灰黯時刻拯救我、安慰我的力量,對很多人來講“沒有用”,我卻堅持相信這才都是人生的珍寶,才禁得起反復追求。

            posted @ 2010-09-25 09:13 糯米 閱讀(373) | 評論 (0)編輯 收藏

            Dinic 算法模板

            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;
            }


            posted @ 2010-08-12 14:33 糯米 閱讀(2541) | 評論 (4)編輯 收藏

            [bash源碼分析] 4 語法分析 - 后臺運行、管道、重定向


            語法分析 - 后臺運行、管道、重定向

            --- 后臺運行
                我們從上一節提到的入口點 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高級編程》里面提到的,
                有些就是根本沒提到,完全沒見過的用法。。
                現在我們先不去深究這些用法。
               



            posted @ 2010-07-25 10:20 糯米 閱讀(935) | 評論 (0)編輯 收藏

            [bash源碼分析] 3 語法分析 - 入口點


            語法分析 - 入口點


            --- 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的書,都不如看代碼來的直接,呵呵。
                我們以后慢慢看。





            posted @ 2010-07-25 10:19 糯米 閱讀(1255) | 評論 (0)編輯 收藏

            僅列出標題
            共17頁: 1 2 3 4 5 6 7 8 9 Last 
            日本久久久久亚洲中字幕| 久久成人18免费网站| 精品久久久久久中文字幕人妻最新| 久久精品人人做人人爽97| 91精品国产综合久久香蕉| 久久久亚洲裙底偷窥综合| 久久狠狠高潮亚洲精品| 亚洲国产成人精品女人久久久 | 久久精品视频91| 一本色道久久99一综合| 久久精品国产亚洲5555| 亚洲∧v久久久无码精品| 久久er国产精品免费观看8| 亚洲精品无码久久久影院相关影片| 99久久精品免费看国产一区二区三区 | 久久人人爽人人精品视频| 久久精品人人做人人爽电影蜜月 | 国产L精品国产亚洲区久久| 18禁黄久久久AAA片| 国产高潮国产高潮久久久91 | 久久亚洲国产午夜精品理论片| 精品国产乱码久久久久软件| 精品久久久久久国产免费了| 久久国产高潮流白浆免费观看| 国产69精品久久久久观看软件| 久久久久久A亚洲欧洲AV冫 | 97精品依人久久久大香线蕉97| 久久精品一区二区三区中文字幕| 亚洲国产精品人久久| 久久国产精品久久精品国产| 精品久久久久久无码专区不卡| 97久久婷婷五月综合色d啪蜜芽| 模特私拍国产精品久久| 久久精品成人一区二区三区| 久久99国产精品成人欧美| 人人狠狠综合久久亚洲88| 美女写真久久影院| 国产成人精品久久一区二区三区av| 色成年激情久久综合| 午夜不卡888久久| 久久99精品久久久久久噜噜|