太极出世：发布太极语言编译器演示版

太极出世：发布太极语言编译器演示版

（太极元年丙戌四月十八日）

现在发布太极语言编译器，下载地址在http://taiji9.getbbs.com/

太极语言灵灵至极，以无招胜有招，以无为而臻于无不为之境界。

现在我们先来体验一下太极语言面向概念的程序设计，在前文"太极语言出世----比C++更好的语言”中我已初步介绍了“面向概念”的概念。

把下面的程序存为t1.u，输入 taiji t1.u 进行编译。

mean while(a,b)
{
SignWhileBegin:;
 goto (a) SignWhileBody;
 goto SignWhileEnd;
SignWhileBody:;
 b;
 goto SignWhileBegin;
SignWhileEnd:;
}

mean if(a,b,c)
{
 goto(a) SignIfTrue;
 c;
 goto SignIfEnd;
SignIfTrue:;
 b;
SignIfEnd: ;
}

type chain
{
 int id;
 char * name;
 chain * before;
 chain * next; 
};

mean goover(a,b)
{
 while(a)
 {
  b;
  a=a->next;  
 }
}

chain a;chain b;chain e;
a.next=&b;b.next=&e;e.next=0;
e.before=&b;b.before=&a;a.before=0;
a.name="sky";b.name="moon";e.name="star";
chain * pchn;chain * pchn1;

pchn=&a;
pchn1=pchn;

a.id=b.id=e.id=0;

pchn=pchn1;

goover(pchn)
{
 if(pchn->name[0]=='s') 
 (
  pchn->name[1]=pchn->name[2];
 )
}

---------------------------------
//输入 taiji t1.u 进行编译，生成t1.asm如下

.386p
.model flat
.code
_universe proc
push ebp
mov ebp,esp
sub esp,56
push ebx
push esi
push edi
a =-16
b =-32
e =-48
pchn =-52
pchn1 =-56
nop
lea eax,dword ptr b[ebp]
lea ebx,dword ptr a[ebp]
add ebx,12
mov dword ptr [ebx],eax
lea eax,dword ptr e[ebp]
lea ebx,dword ptr b[ebp]
add ebx,12
mov dword ptr [ebx],eax
mov eax,0
lea ebx,dword ptr e[ebp]
add ebx,12
mov dword ptr [ebx],eax
lea eax,dword ptr b[ebp]
lea ebx,dword ptr e[ebp]
add ebx,8
mov dword ptr [ebx],eax
lea eax,dword ptr a[ebp]
lea ebx,dword ptr b[ebp]
add ebx,8
mov dword ptr [ebx],eax
mov eax,0
lea ebx,dword ptr a[ebp]
add ebx,8
mov dword ptr [ebx],eax
lea eax, OFFSET FLAT:constr1
lea ebx,dword ptr a[ebp]
add ebx,4
mov dword ptr [ebx],eax
lea eax, OFFSET FLAT:constr2
lea ebx,dword ptr b[ebp]
add ebx,4
mov dword ptr [ebx],eax
lea eax, OFFSET FLAT:constr3
lea ebx,dword ptr e[ebp]
add ebx,4
mov dword ptr [ebx],eax
lea eax,dword ptr a[ebp]
mov dword ptr pchn[ebp],eax
mov eax,dword ptr pchn[ebp]
mov dword ptr pchn1[ebp],eax
mov eax,0
lea ebx,dword ptr e[ebp]
add ebx,0
mov dword ptr [ebx],eax
lea ebx,dword ptr b[ebp]
add ebx,0
mov dword ptr [ebx],eax
lea ebx,dword ptr a[ebp]
add ebx,0
mov dword ptr [ebx],eax
mov eax,dword ptr pchn1[ebp]
mov dword ptr pchn[ebp],eax
SignWhileBegin :
mov eax,dword ptr pchn[ebp]
jnz SignWhileBody
jmp SignWhileEnd
SignWhileBody :
mov eax,dword ptr pchn[ebp]
add eax,4
mov ebx,0
movsx ebx,bl
add eax,ebx
mov eax,dword ptr [eax]
cmp al,'s'
je SignIfTrue
jmp SignIfEnd
SignIfTrue :
mov eax,dword ptr pchn[ebp]
add eax,4
mov ebx,2
movsx ebx,bl
add eax,ebx
mov ebx,dword ptr pchn[ebp]
add ebx,4
mov ecx,1
movsx ecx,cl
add ebx,ecx
mov eax,dword ptr [eax]
mov byte ptr [ebx],al
SignIfEnd :
mov eax,dword ptr pchn[ebp]
add eax,12
mov eax,dword ptr [eax]
mov dword ptr pchn[ebp],eax
jmp SignWhileBegin
SignWhileEnd :
nop
functionend1 :
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
_universe endp
.data
constr1 db "sky",0
constr2 db "moon",0
constr3 db "star",0
end _universe

-----------------------------------
下面我再简单介绍一下面向概念的概念。

太极语言实现了“概念的概念”，太极语言中的这种“面向概念的程序设计”将有深远的意义。太极语言讲究“所思既程序”，怎么想怎么编（HTHC -- How Thinking How Coding）。

 举个具体例子，许多程序员都编写过遍历链表做一些事情的代码。
 比如显示
 void chain_show(chain * pchn)
 {
  while(pchn)
  {
   printf(pchn->name);
   pchn=pchn->next;
  }
 }
 又如搜索
 chain * chain_search(chain * pchn,char * keyname)
 {
  while(pchn)
  {
   if(str_equal(pchn->name,keyname))
    return pchn;
   pchn=pchn->next;
  }
  return 0;
 }
 这些遍历的框架是重复出现的，还有更多的要用到这种框架，如计数，条件计数，定位更改……都写出来？太多了，同一件事情不要做两次。而且这种遍历方式不利于维护，修改时要一处处都修改，很容易出问题（当然这个例子比较简单，修改的可能性也不大，但对复杂的情况必须做到利于维护）。
 
 看－－
 现在把这个遍历的框架单独实现。（注意 mean 是一个关键字，表示概念）
 
 mean goover(chain * a,mean b)//定义遍历的概念
 {
  while(a)
  {
   b;
   a=a->next;
  }
 }
 void chain_show(chain * pchn)
 {
  goover(pchn)
  { printf(pchn->name); }
 }
 chain * chain_search(chain * pchn,char * keyname)
 {
  goover(pchn)
  {
   if(str_equal(pchn->name,keyname))
    return pchn;
  }
  return 0;
 }
 ……
 mean goover(chain * a,mean b)描述了一个概念goover,有参数a,b。用到这个概念时，依次第n个参数用goover后面第n个括号中的代码来代换，最后一个可以用{}。
 让代码的本身做为参数，进行代码组合！
 其他如计数，条件计数，定位更改……都可以这样实现。
 一次定义，到处使用。
 
 大家会注意到这里的mean跟C中define的概念很相似。
 （要注意区别，mean 定义是要{}的。比如mean a{b} 与define a b 一样，）
 是的，宏确实是很厉害的。在太极语言中，实现define同时实现mean。而且这里的mean还是类型敏感的，比如对tree可以重载实现一个
 mean goover(tree * a,mean b){……}。
 甚至你可以用一个更通用的模式mean goover(mean a,mean b)，这个是不判断类型的，或mean goover(a,b)。
 
 
 在庞大的程序中，面向概念是非常有效的编程方式。
 
 再举一个例子：
例2：
 我们有一组函数，想让它们都会在被调用时自动做一些事情，这里就假如是使一个全局变量i自增1.在C/C++中你可以一个个的都在其前面加上个i++；以后要修改时呢，再一个个的修改。
 现在我们看太极语言面向概念的程序设计中这个怎么实现的。<