fleurer » 备忘

数据结构课设，表达式计算

fleurer — Wed, 30 Jun 2010 11:28:34 +0000

随便写了下，没仔细调试。

大约这么定义
double parse_expr(char *input, char **output);

input就是表达式的字符串，output是解析剩下的部分。如果output==input，就是解析失败。如果正确，返回运算结果。

用起来大约这样

    char *out, *exp="2+(1+3)*4";
    double r = parse_expr(exp, &out);
    if (out==exp){
        printf("parse fail\n");
        return 0;
    }
    printf("%s => %f \n", exp, r);

回头想下，思路跟以前写的parser几乎是葫芦画瓢，也该算是递归下降吧。

代码如下

exp.h

double parse_expr(char *input, char **output);
double parse_term(char *input, char **output);
double parse_fact(char *input, char **output);
double parse_numb(char *input, char **output);

exp.c

#include "exp.h"
 
// expr ::= term {[+-] term}
double parse_expr(char *input, char **output){
    double r=0;
    char *tmp, op;
    tmp = input;
    // factor
    r = parse_term(tmp, output);
    if (output==tmp){
        return 0;
    }
    // {[+-] term}
    tmp = *output;
    while ((op=*tmp)=='+' || op=='-'){
        double r2 = parse_term(++tmp, output);
        if (tmp==*output){
            *output = input;
            return 0;
        }
        r = (op=='+')? r+r2: r-r2;
        tmp = *output;
    }
    return r;
}
 
// term ::= factor {[*/] factor}
double parse_term(char *input, char **output){
    double r=0;
    char *tmp, op;
    tmp = input;
    // factor
    r = parse_fact(tmp, output);
    if (output==tmp){
        return 0;
    }
    // {[*/] factor}
    tmp = *output;
    while ((op=*tmp)=='*' || op=='/'){
        double r2 = parse_fact(++tmp, output);
        if (tmp==*output){
            *output = input;
            return 0;
        }
        r = (op=='*')? r*r2: r/r2;
        tmp = *output;
    }
    return r;
}
 
// fact ::= (expr) | numb
double parse_fact(char *input, char **output){
    double r=0;
    char *tmp;
    // (expr)
    if (*input=='(') {
        tmp = input+1;
        r = parse_expr(tmp, output);
        if(**output==')'){
            (*output)++;
            return r;
        }
        // if fail, output == input
        else {
            *output = input;
            return 0;
        }
    }
    // numb
    r = parse_numb(input, output);
    return r;
}
 
double parse_numb(char *input, char **output){
    double  r = 0;
    char ch, *tmp=input;
    while((ch = *tmp++)>='0' && ch<='9'){
        r = r*10+ch-'0';
    }
    *output = tmp-1;
    return r;
}

main.c

int main(){
    double r;
 
    char *out, exp[1024];
    scanf("%256s", exp);
    r = parse_expr(exp, &out);
    if (out==exp){
        printf("parse fail\n");
        return 0;
    }
    printf("%s => %f \n", exp, r);
 
    return 0;
}

写一个bootsector

fleurer — Wed, 26 May 2010 13:40:12 +0000

看的这个教程 http://share.solrex.org/WriteOS/

仿照《自己动手写操作系统》的格式，除却gas确实很囧的因素，大体上还是不错的。万事开头难，在开头的bootloader这里卡了好久的说…不过动手写一下也不过半小时的功夫 TvT

机器在启动的时候可能是遍历每个磁盘分区，若有发现第512字节位置是个0xAA55的魔数，就认为这是个引导的分区了。然后就把它的前512字节装入内存，从0×7c00位置开始执行。这就是最简单的引导方式了好像。

我们把汇编代码编译成一个512bytes的二进制文件，再把它放到一个软盘的映像里就好。

boot.S

[bits 16]                       ;real mode
[org 0x7c00]                  ;put code start at 0x7c00
[section .text]
 
_start:
    mov     ax, cs            ; init seg registers
    mov     ds, ax
    mov     es, ax
    call    _print_str      
 
_print_str:
    mov     ax, str            
    mov     cx, len    
    mov     bp, ax
    mov     bx, 0x000c
    mov     dl, 0
    mov     ax, 0x1301
    int     0x10                              ;int 0x10, just as manual says
 
_loop: 
    jmp     _loop                             ; forever loop
 
str: db      "screw you guys all fucked up~",10,13
len: equ     $-str
 
times 510-($-$$) db 0                   ; fill the rest with 0
dw 0xAA55                                  ; magic number

编译之

nasm -f bin boot.S

生成一个boot.bin，下一步搞个软盘镜像

dd if=boot.bin of=boot.img bs=512 count=1
dd if=/dev/zero of=boot.img skip=1 seek=1 bs=512 count=2879

ls -l 下，大约会是这样

-rwxr-xr-x 1 ssword ssword     512 2010-05-26 21:28 boot.bin
-rw-r--r-- 1 ssword ssword 1474560 2010-05-26 21:28 boot.img
-rw-r--r-- 1 ssword ssword     399 2010-05-26 21:28 boot.S

然后打开virtualbox，设置软驱映像为boot.img。启动虚拟机就可以看到一个可爱的”screw you all”什么的了 >v<

使用rake编译C程序

fleurer — Thu, 20 May 2010 15:11:40 +0000

每次修改代码一般只会涉及一部分文件，大部分代码都是不必重复编译的。而且编译明显是分步骤也有依赖关系，比如要测试程序就得先链接出一个可执行文件，要链接就得先编译成.o。。。所以就有了make，自动分析任务的依赖关系，只对有变更的文件执行编译，省心省时间。

不过make的语法晦涩啊…就有了rake

rake提供了file函数可以指明文件的依赖关系，比如：

file 'fdict.o' => ['src/fdict.c', 'src/fdict.h'] do
  sh 'gcc -Wall -c src/fdict.c'
end
file 'test.o' => ['src/test.c'] do 
  sh 'gcc -Wall -c src/test.c'
end

file就是个ruby的函数调用，把重复的东西去掉很简单

CFlags = '-Wall'
 
[
  ['src/fdict.c', 'src/fdict.h'],
  ['src/test.c']
].each do |fn_c, *_|
  fn_o = File.basename(fn_c).ext('o')
  file fn_o => [fn_c, *_] do
    sh "gcc #{CFlags} -c #{fn_c}"
  end
end

再就是链接和执行

OFiles = %w{fdict.o test.o}
 
task :run => [:link] do 
  sh "./test"
end
 
task :link => OFiles do
  sh "gcc #{CFlags} #{OFiles.join(' ')} -o test"
end

每修改两行C程序到控制台下边一个rake run就可以立即执行，这一来写c就有点像写脚本了。

rails使用paperclip插件上传时遇到500 Internal Server Error

fleurer — Tue, 11 May 2010 07:57:27 +0000

有可能是imageMagick没装利索。找不到imagemagick，显示错误信息的时候试图把上传的文件对象序列化，就505了。

sudo apt-get install imagemagick --fix-missing

使用三方库就得做好不可预料事件的准备哇

关于paperclip的使用，这两篇简介好像不错：
http://jimneath.org/2008/04/17/paperclip-attaching-files-in-rails/
http://thewebfellas.com/blog/2008/11/2/goodbye-attachment_fu-hello-paperclip

ps: 又遇到了个没预料的问题，上传validates_attachment_content_type指定的类型之外的文件时候同样会遇到个500 internal server error，未解中。

踩踩数据结构什么的 =“=

fleurer — Sat, 08 May 2010 00:51:14 +0000

发觉算法太弱了 =”=

当年在ACM那里呆了两天就隐身了，可惜那个老师非常非常非常好的（实验室里还有空调 >_<）。总觉得这玩意水太深，掉进去就出不来了....“不成熟的优化乃万恶之源”这话又正好应了惰性心理，心安理得地“出了性能问题再说之前先弄出来再说管算法干嘛”...可现实往往是，不会算法你压根就弄不出来...

先从一棵二叉查找树开始好了。挖坑慢慢填，时间有的是(?)

module BTree where
 
data BTree a b = Empty 
               | BNode {
                    kv :: (a, b), 
                    left :: BTree a b,
                    right :: BTree a b
               } 
               deriving(Show, Eq)
 
insert :: (Ord a) => (a, b) -> BTree a b -> BTree a b
insert (k,v) Empty = BNode (k, v) Empty Empty
insert (k,v) pnode@(BNode (pk, _) lnode rnode) 
    | k == pk   = pnode { kv = (k,v) }
    | k <  pk   = pnode { left  = insert (k,v) lnode }
    | k >  pk   = pnode { right = insert (k,v) rnode }
 
find :: (Ord a) => a -> BTree a b -> Maybe b
find k Empty = Nothing
find k (BNode (pk,pv) lnode rnode)
    | k == pk = Just pv
    | k <= pk = find k lnode
    | k >  pk = find k rnode
find _ _ = Nothing
 
remove :: (Ord a) => a -> BTree a b -> BTree a b
remove k Empty = Empty
remove k pnode@(BNode (pk,pv) lnode rnode) 
    | k == pk = merge lnode rnode
    | k <= pk = pnode { left = remove k lnode }
    | k >  pk = pnode { right = remove k rnode }
 
merge :: (Ord a) => BTree a b -> BTree a b -> BTree a b
merge lnode rnode = fromList $ (toList lnode) ++ (toList rnode)
 
--helper
isEmpty Empty = True 
isEmpty _     = False
 
fromList :: (Ord a) => [(a,b)] -> BTree a b
fromList = foldl (flip insert) Empty 
 
toList :: BTree a b -> [(a,b)]
toList Empty = [] 
toList (BNode (k,v) lnode rnode) = 
    (toList lnode) ++ [(k,v)] ++ (toList rnode)
 
-- for test
root = fromList $ [
    (4, "fleurer"), 
    (10, "ssword"), 
    (100, "ssword"), 
    (2, "xx")]

haskell做数据结构好像别扭的很…不用ST Monad或者IO的话什么都是值还不能引用，像二叉树的旋转什么的就没想出常数时间的办法。像上面那个remove就直接简单粗暴了orz

(邪恶音：用ST Monad不就好了嘛)
(ST Monad都用了还用haskell干嘛 TvT)

git使用入门

fleurer — Fri, 02 Apr 2010 14:30:11 +0000

自己写小东西什么的还是git最省心 ^_^

版本控制工具里的命令什么还真够多的，所幸一个人要求不高，平时用的功能也就这么几个了。所以…..忘掉svn吧！ =V=

开始

git init 
git add .
git commit -a -m "commit message"

git init就是创建当前目录的版本库，所有信息都在.git这一个文件夹里面。比起svn的每个目录下边都一个.svn可要清爽多了 :)
git add . 将目录中的所有文件加入跟踪，新建文件时候别忘了这个。
git commit 就是提交啦~注意下这个commit只是提交到本地。

git是跟踪代码变动的工具，而不是上传工具。commit时候需要注意的一点就是不要把二进制什么的文件交进去。记得在根目录下边加个.gitignore文件，内容大约可以这样：

*.o
*.so
*.a
*.exe
*~

代码杯具了怎么办~

git checkout -- blah.c

这样就把blah.c恢复到了commit时的状态，存档复活~

要恢复到之前的版本就用git reset了，git在每次提交的时候都有个hash作为标记，知道这个hash就行了（例如git log或者直接翻github的history之类）

git reset --hard 4df38hdf29f

（reset好像有三种？初学者不用刨根究底的 =v=）

分支

git branch blah 
git checkout blah

就创建出了一个名为blah的分支了~
git checkout 的功能就是将当前工作目录转向blah~

合并分支…

git branch master
git merge blah

blah就合并进master啦~

github

ssh密钥好像比较绕…github使用ssh协议传输东东也做了身份验证嘛，所以需要一个双向的密匙。具体的操作步骤忘了囧，不过照着提示来也就一次性的工作啦~

git config --global user.name 'Fleurer'
git config --global user.email me.ssword@gmail.com
 
git remote add origin git@github.com:（你的名字，这里是Fleurer~）/项目名.git  
git push origin master

Fleurer’s Stack VM

fleurer — Wed, 03 Feb 2010 05:09:18 +0000

http://github.com/Fleurer/fsvm
尝试用C写的堆栈机，好像烂尾了 – -!

只是个运行时，无视了语法分析。随便写的东西也没什么规划，编写的时候就郁闷不知道哪部分该归分析器那部分该归vm，也不知道现有的部分能不能真用到解释器上，于是华丽地烂尾～只实现了20来条指令，可以递归可以闭包，不过不能算乘法…囧，很简陋啦~

好像是第一次写C，不会make就先凑合了rake – -！对C不熟悉，满地的Segmentation Fault对我们只会用printf调试的菜鸟太残酷了…用了那个保守式的gc库Boehm GC，面对满地的malloc而无free不清楚泄漏起来会怎样…囧

本来是对C++那套OO无爱，想单用struct和函数也可以OO么。于是用了C，然后就后悔了：我不想重新实现hashmap之类的东西，C++那stl多好…T_T。倒也找到了个C的泛型库khash，不过宏终究不如模板来的好看…现在想来，信息学奥赛acm中用C的那些同学做题的时候都是自己实现一遍各个数据结构么？

拿段伪代码：

def main:
     sum(10)
 
def sum(i):
     if (i==0) : return 0;
     else: return(i+sum(i-1));

放到fsvm下大约是这样：

int test_rec(){
    Op op_main[]={
        OP_PUSH_NUM, 10, 
        OP_PUSH_CONST, 0, //"sum"  
        OP_PUSH_VAR, 
        OP_CALL, 1,
        OP_RET
    };
    Op op_sum[]={
        OP_PUSH_CONST, 0, //"i"
        OP_PUSH_VAR, 
        OP_POP_TMP, 0, //store i
        OP_PUSH_TMP, 0, //push i
        OP_PUSH_NUM, 0, 
        OP_EQ,
        OP_NOT, // i!=0?
        OP_BRANCH, 3, 
            OP_PUSH_NUM, 0,
            OP_RET,
        //else
            OP_PUSH_TMP, 0, 
            OP_PUSH_NUM, 1, //1
            OP_SUB, 
            OP_PUSH_CONST, 1, //"sum"
            OP_PUSH_VAR, 
            OP_CALL, 1,   //sum(tmp[0]-1)
            OP_PUSH_TMP, 0, 
            OP_PRINT_STACK, 
            OP_ADD, //tmp[0]+sum(tmp[0]-1)
        OP_RET
    };
    Env *env=fnew_env(NULL); 
 
    Proto *p_main = fnew_proto(op_main, 0);
    fset_const(p_main, 0, fstr("sum"));
    Func* f_main=fnew_func(p_main, env);
    Obj o_main=ffunc(f_main);
 
    Proto* p_sum=fnew_proto(op_sum, 1);
    fset_const(p_sum, 0, fstr("i"));
    fset_const(p_sum, 1, fstr("sum"));
    Func* f_sum=fnew_func(p_sum, env);
    Obj o_sum=ffunc(f_sum);
 
    fbind_var(env, "sum", o_sum);
 
    fio_puts(fcall(0, f_main));
    return 0;
}

创建函数的那几个函数我自己也看着别扭…不过写C还是老实点好 >_<

C的泛型库khash

fleurer — Sat, 30 Jan 2010 03:39:43 +0000

写小东西需要用到哈希表这样的数据结构时候才后悔没用C++，最起码还有stl能用来着。虽说C也能搞泛型，不过宏实现的泛型…真的好恐怖。

tinyrb用了khash做哈希表，据作者说已经是一个稳定的实现了。

khash.h的内容：
http://attractivechaos.awardspace.com/khash.h.html

大体可以这么用：

#include "stdio.h"
#include "khash.h"
KHASH_MAP_INIT_STR(str, int) //以“str”这名字初始化一个类型的map，键类型为字符串，值类型为int
int main() {
    int ret, is_missing;
    khiter_t k; //khash的索引器，好像就是个int
    khash_t(str) *h = kh_init(str); //str只是个名字，初始化
    k = kh_put(str, h, "test", &ret); //“test”即键，ret判定操作是否成功，返回k为索引器
 
    if (!ret) kh_del(str, h, k); //如果h中已经存在了这个键，就删除之
    kh_value(h, k) = 10; //设置键“test”对应的值（10）
 
    printf("%d\n", kh_val(h,k)); //kh_val(h,k)即10
 
    k = kh_get(str, h, "test"); //获得“test”对应的索引器k
    printf("%d\n", kh_val(h,k)); //得10
 
    kh_destroy(str, h);
    return 0;
}

终究不如模板来的自然，呵呵~不过也不错了。

折腾grub小记

fleurer — Tue, 26 Jan 2010 02:33:07 +0000

蛋疼用PQMagic改了下/swap分区的大小，重启发现mbr没了。

拿手机google下之后，找了张windows me的光盘（初一时候买的盘还能用…orz）引导进入dos，fdisk /mbr，windows原地满血复活…满血，是的，windows又把mbr占了…

接着装个wingrub，折腾半天找回了原先的menu.lst，重启，接着是：

Error 2: Bad file or directory type

而且在grub命令下无法列出ext3分区的文件，当时冷汗天杀的PQMagic没把我盘格了吧…回头想下，感情这个wingrub好像不认ext3…

下载个live-CD，进去发现可以读那个分区。apt-get一个grub，进入命令行之后：

root (hd0, 4)
setup (hd0)

提示成功。重启，原先的grub回来了…

关于进程的疑问集

ssword — Sun, 29 Nov 2009 15:13:42 +0000

如何在有限的空间（如内存和硬盘，可以将其看作一个大数组）内储存不定长度不定生命周期的个体（如进程或者文件）？
如何限制一个进程在运行时无法访问或修改其他进程的数据？
如何实现共享库或者系统调用？
能否把进程的调度、连续对象（字节、页）的分配抽象为纯粹的最优问题？

最近看几本linux内核的书，貌似开始弄明白了点门道。通过分页机制实现一个虚拟地址空间貌似就可以解决上述的问题。不过现在只了解其机制，而不解其策略。纸上谈兵显然还差的远。

大约去年这时候曾经问过FlowerCode一些关于分页的东西，当时fc说分页有点像文件系统，现在才越想越觉得有道理。后知后觉了一些，呵呵 :)