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

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

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

现在发布太极语言编译器，下载地址在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++；以后要修改时呢，再一个个的修改。
 现在我们看太极语言面向概念的程序设计中这个怎么实现的。
 
mean do_sth(mean a,mean c)//定义do_sth概念
{
 a
 {
  i++;
  c;
 }
}

do_sth(int fc1(int a))
{
 return a*a;
}
do_sth(int fc2(int a,int b))
{
 return a+b;
}
do_sth(int fc3(int a))
{
 return a+3;
}
do_sth(int fc4(int a))
{
 return a-2;
}
 
编译后这就成了一组函数，
int fc1(int a)
{
 i++;
 return a*a;
}
int fc2(int a,int b)
{
 i++;
 return a+b;
}
int fc3(int a)
{
 i++;
 return a+3;
}
int fc4(int a)
{
 i++;
 return a-2;
}

规则还是刚才的规则：依次第n个参数用后面第n个括号中的代码来代换，最后一个可以用{}。
这是非常奇妙的，你现在可以自己试着写一段公用退出代码。

其实在太极语言中while,if等控制语句都是这样基于概念虚拟出来的。
比如定义while概念
mean while(a)
{
 sign://进入代码
 b;
 goto(a) sign;//退出代码
}
后

while(i<100)
{
 n=n+i;
 i++;
}
被编译成
sign:
n=n+i;
i++
goto(i<100) sign;

（goto(i<100) sign;是条件goto语句，就是if(i<100) goto sign。另外sign是一个标号编译自增量，概念中的标号都是这样的，这样才能多次使用，在本演示版中没有加入此功能，所以只能用一次）

基于概念的编程可以方便的控制非线性上下文相关代码。比如有进入和退出模式的代码。

例1：
mean usepointer(mean pointertype,mean pointer,mean c)
{
 pointertype * pointer=new pointertype; 
 c;
 delete pointer;
}
usepointer(int,p)
{ ... }
想想这个编译后是什么了？
是：

int * p=new int;
……
delete p;

但是delete的语句不用写了，会自动产生这句话。一次定义，到处使用。在头文件里包含usepointer的定义。好了，这样可以自动解决一大部分可能造成内存泄露的代码了。

usepointer(int,p1)
{
 usepointer(int,p2)
 {
  ...
 }
}
这个呢？会被编译成什么？

再举一个例子
例2：
mean paint(a)
{
 hdc=BeginPaint(hWnd, &ps);
 a;
 EndPaint(hWnd, &ps);
}
paint
{
 TextOut(hdc,0,0,str, strlen(str));
}
被编译成什么了？
hdc=BeginPaint(hWnd, &ps);
TextOut(hdc,0,0,str, strlen(str));
EndPaint(hWnd, &ps);

限于篇幅，这里不多讲了，而且概念的设计还可以继承，还有“代码装配”的概念，就象机械装配，电路搭配那样，非常有趣。

太极语言非常讲究怎么想怎么编（HTHC）。看前面那个chain_show，是不是思维的直接描述？
 void chain_show(chain * pchn)
 {
  goover(pchn)
  { printf(pchn->name); }
 }

太极语言提出了基于概念描述的编程模式，这是根据模拟思维的原则做的。认识世界，通过概念的设立与关联应用。 比如我们刚才的例子中，遍历就是一个概念，每一个概念都单独用一个模块表示，概念间的关系用模块的组合来描述。
 这是比现在流行的“面向对象”，“泛型”更先进的模式。我可以预言，“基于概念”将是未来软件开发的主要模式，因为这几乎完全是在模拟人的思维形式。
 以前的“函数”，“类”，“面向对象”，“泛型”……只是非常有限度的局部部分模拟，“基于概念”将带来更深远的影响。
 基于概念的代码有极强的可复用性。你想想你自己头脑中的概念这种东西被你思维复用了多少次。
 概念不只是描述静态物体，而且对于运行状态也同样可以描述，比如刚才说的“遍历”。数学上的定理都可以用概念的形式描述。
 概念的实现不只是一种编译器技术。还是一个软件总体设计工程的原则。

太极语言实现了垣的概念。一段包含进入与退出代码的区域就叫垣，其中进入与退出代码都可以为空。简单一点的说，就是两个括号一包就叫垣——这个字怎么这么形象呢。

太极语言中的函数，类，while等都是基于垣而实现的。垣可以无限嵌套。比如你可以在函数中再定义函数，甚至在if后面的（）里再定义另一个函数，在表达式的（）里定义一个类，……这都是可以的。太极语言的语法就是自由到这种程度。

…………

----------------------------------
现在解释一下开始的那个程序

//定义while的概念
mean while(a,b)
{
SignWhileBegin:;
 goto (a) SignWhileBody;
 goto SignWhileEnd;
SignWhileBody:;
 b;
 goto SignWhileBegin;
SignWhileEnd:;
}
//定义if的概念
mean if(a,b,c)
{
 goto(a) SignIfTrue;
 c;
 goto SignIfEnd;
SignIfTrue:;
 b;
SignIfEnd: ;
}

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

//定义遍历的概念，这里你写成汉语的也可以  mean 遍历(a,b)
mean goover(a,b)
{
 while(a)
 {
  b;
  a=a->next;  
 }
}

chain a;chain b;chain c;
a->next=&b;b->next=&c;c->next=0;
c->before=&b;b->before=&a;a->before=0;
a->name="sky";b->name="moon";c->name="star";
chain * pchn;chain * pchn1;

pchn=&a;
pchn1=pchn;

//遍历pchn把id赋值0
goover(pchn)
{
 pchn->id=0; 
}

pchn=pchn1;

//遍历pchn，若name[0]=='s'则……
goover(pchn)
{
 if(pchn->name[0]=='s') 
 (
  pchn->id=pchn->id+2;
  pchn->name[1]=pchn->name[2]+pchn->id;
 )
}

-------------------------------------------

刚才我们已经看到了while,if概念的定义。
现在想一想for应该怎么定义呢？
看下面的程序：

mean for(a,b,c,d)
{
 a;
SignForBegin:;
 goto (b) SignForBody;
 goto SignForEnd;
SignForBody:;
 d;
SignForContinue:;
 c;
 goto SignForBegin;
SignForEnd:;
}

for(int i;int j;i=0;j=0)(i<100)(i=i+1)
{
 j=j+i; 
}

规则仍然是：依次第n个参数用后面第n个括号中的代码来代换，最后一个可以用{}。

以下是编译后的代码
.386p
.model flat
.code
universe proc
push ebp
mov ebp,esp
sub esp,8
push ebx
push esi
push edi
i =-4
j =-8
nop
mov eax,0
mov dword ptr i[ebp],eax
mov eax,0
mov dword ptr j[ebp],eax
SignForBegin :
mov eax,dword ptr i[ebp]
cmp eax,100
jb SignForBody
jmp SignForEnd
SignForBody :
mov eax,dword ptr j[ebp]
add eax,dword ptr i[ebp]
mov dword ptr j[ebp],eax
SignForContinue :
mov eax,dword ptr i[ebp]
add eax,1
mov dword ptr i[ebp],eax
jmp SignForBegin
SignForEnd :
nop
functionend1 :
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
universe endp
.data
end universe

 

好了，现在再想一下类似c中的do while怎么实现，自己想一下吧。

在太极语言中，没有while,没有if，else，switch，没有do while，没有for……所有的这些都是用“概念的概念”来实现的“概念”。

玄之又玄，众妙之门。学习太极语言，你要学会忘记，与学太极门武功是一样的，要学会忘记，而不是记忆，当你忘掉几乎所有固定招式时才是初窥太极门径。

太极语言当然全面支持汉语，看：
意 循环(a,b)
{
循环开始:;
 飞 (a) 循环体;
 飞 循环结束;
循环体:;
 b;
 goto 循环开始;
循环结束:;
}

以后就可以用“循环”啦。

意 环(条件,b)
{
环开始:;
 飞 (条件) 环体;
 飞 环结束;
环体:;
 b;
 飞 环开始;
环结束:;
}

以后就可以用“环”啦。

意 玉衡(a,b,c)
{
 飞(a) 玉衡真;
 c;
 飞 玉衡尾;
玉衡真:;
 b;
玉衡尾: ;
}

这是if判断，哈哈
当然这样写也行：
意 若(a,b,c)
{
 飞(a) 若真;
 c;
 飞 若终;
若真:;
 b;
若终:;
}

所有名字都可以用汉语。
所有关键字也都有汉语的。
太极语言支持无限长的名字，无限层括号嵌套。

下面再演示一些程序：

把以下代码存为t1.u
---------------
int a;int b;int c;
a=2;b=3;
c=a*8+b*(7+a)*(7+b);
----------------
输入taiji t1.u
生成t1.asm：

//t1.asm
.386p
.model flat
.code
universe proc
push ebp
mov ebp,esp
sub esp,12
push ebx
push esi
push edi
a =-4
b =-8
c =-12
nop
mov eax,2
mov dword ptr a[ebp],eax
mov eax,3
mov dword ptr b[ebp],eax
mov eax,dword ptr a[ebp]
imul eax,8
mov ebx,dword ptr b[ebp]
mov ecx,7
add ecx,dword ptr a[ebp]
imul ebx,ecx
mov ecx,7
add ecx,dword ptr b[ebp]
imul ebx,ecx
add eax,ebx
mov dword ptr c[ebp],eax
nop
functionend1 :
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
universe endp
.data
end universe

---------------------
//taiji2.u
int fc(int a;int b)
{
 int c;
 c=a*8+b*(7+a)*(7+b);
 return c;
}

int t;
t=2;
int k;
k=fc(2;t+3);
--------------------
//t2.asm

.386p
.model flat
.code
universe proc
push ebp
mov ebp,esp
sub esp,8
push ebx
push esi
push edi
t =-4
k =-8
nop
mov eax,2
mov dword ptr t[ebp],eax
mov eax,dword ptr t[ebp]
add eax,3
push eax
mov eax,2
push eax
call fc
add esp,8
mov eax,eax
mov dword ptr k[ebp],eax
nop
functionend1 :
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
universe endp
fc proc
push ebp
mov ebp,esp
sub esp,4
push ebx
push esi
push edi
b =8
a =12
c =-4
nop
mov eax,dword ptr a[ebp]
imul eax,8
mov ebx,dword ptr b[ebp]
mov ecx,7
add ecx,dword ptr a[ebp]
imul ebx,ecx
mov ecx,7
add ecx,dword ptr b[ebp]
imul ebx,ecx
add eax,ebx
mov dword ptr c[ebp],eax
mov eax,dword ptr c[ebp]
mov eax,eax
jmp functionend2
nop
functionend2 :
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
fc endp
.data
end universe

 

------------------------
//t3.u:
char * str1;
char * str2;
str1="aaaaaaaaaaaaa";
str2="bbbbbbbbbbbbbbbbb";
int i;i=1;
int j;j=2;
str1[i*2+1]=str2[j+3]+1;
j=str1[3];
------------------------

//t3.asm
.386p
.model flat
.code
universe proc
push ebp
mov ebp,esp
sub esp,16
push ebx
push esi
push edi
str1 =-4
str2 =-8
i =-12
j =-16
nop
lea eax,constr1
mov dword ptr str1[ebp],eax
lea eax,constr2
mov dword ptr str2[ebp],eax
mov eax,1
mov dword ptr i[ebp],eax
mov eax,2
mov dword ptr j[ebp],eax
mov eax,dword ptr j[ebp]
add eax,3
lea ebx,str2
add ebx,eax
mov ebx,dword ptr [ebx]
add bl,1
mov eax,dword ptr i[ebp]
imul eax,2
add eax,1
lea ecx,str1
add ecx,eax
mov byte ptr [ecx],bl
mov eax,3
lea ebx,str1
add ebx,eax
mov ebx,dword ptr [ebx]
movsx ebx,bl
mov dword ptr j[ebp],ebx
nop
functionend1 :
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
universe endp
.data
constr1 db "aaaaaaaaaaaaa",0
constr2 db "bbbbbbbbbbbbbbbbb",0
end universe

-------------------
//t4.u
type 学生
{
 char * 名;
 int 龄; 
 char * 址;
}

学生 陈伟;
陈伟.名="陈伟";
陈伟.龄=26;

---------------------
.386p
.model flat
.code
universe proc
push ebp
mov ebp,esp
sub esp,12
push ebx
push esi
push edi
陈伟 =-12
nop
lea eax,constr1
lea ebx,陈伟
add ebx,0
mov dword ptr [ebx],eax
mov eax,26
lea ebx,陈伟
add ebx,4
mov dword ptr [ebx],eax
nop
functionend1 :
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
universe endp
.data
constr1 db "陈伟",0
end universe

--------------------------------------
//t5.u
意 玉衡(a,b,c)
{
 飞(a) 玉衡真;
 c;
 飞 玉衡尾;
玉衡真:;
 b;
玉衡尾: ;
}

意 环(条件,b)
{
环开始:;
 飞 (条件) 环体;
 飞 环结束;
环体:;
 b;
 飞 环开始;
环结束:;
}

意 璇(a,b,c,d)
{
 
 a;
璇首:;
 飞 (b) 璇体;
 飞 璇尾;
璇体:;
 d;
璇递:;
 c;
 飞 璇首;
璇尾:;
}

整数 甲;
整数 乙;
甲=0;
乙=0;

环(甲<100)
{
 乙=乙+甲;
 甲=甲+1;
}

甲=0;
乙=0;

环(甲<100)
{
 乙=乙+甲;
 甲=甲+1;
 玉衡(甲==8)
 {
  乙=乙+甲*3;
 }
}

 

璇(整数 子;整数 午;)(子<100)(子=子+1)
{
  午=午+子;
}

--------------------------------
//t5.asm
.386p
.model flat
.code
universe proc
push ebp
mov ebp,esp
sub esp,16
push ebx
push esi
push edi
甲 =-4
乙 =-8
子 =-12
午 =-16
nop
mov eax,0
mov dword ptr 甲[ebp],eax
mov eax,0
mov dword ptr 乙[ebp],eax
环开始 :
mov eax,dword ptr 甲[ebp]
cmp eax,100
jb 环体
jmp 环结束
环体 :
mov eax,dword ptr 乙[ebp]
add eax,dword ptr 甲[ebp]
mov dword ptr 乙[ebp],eax
mov eax,dword ptr 甲[ebp]
add eax,1
mov dword ptr 甲[ebp],eax
jmp 环开始
环结束 :
mov eax,0
mov dword ptr 甲[ebp],eax
mov eax,0
mov dword ptr 乙[ebp],eax
环开始 :
mov eax,dword ptr 甲[ebp]
cmp eax,100
jb 环体
jmp 环结束
环体 :
mov eax,dword ptr 乙[ebp]
add eax,dword ptr 甲[ebp]
mov dword ptr 乙[ebp],eax
mov eax,dword ptr 甲[ebp]
add eax,1
mov dword ptr 甲[ebp],eax
mov eax,dword ptr 甲[ebp]
cmp eax,8
je 玉衡真
jmp 玉衡尾
玉衡真 :
mov eax,dword ptr 乙[ebp]
mov ebx,dword ptr 甲[ebp]
imul ebx,3
add eax,ebx
mov dword ptr 乙[ebp],eax
玉衡尾 :
jmp 环开始
环结束 :
璇首 :
mov eax,dword ptr 子[ebp]
cmp eax,100
jb 璇体
jmp 璇尾
璇体 :
mov eax,dword ptr 午[ebp]
add eax,dword ptr 子[ebp]
mov dword ptr 午[ebp],eax
璇递 :
mov eax,dword ptr 子[ebp]
add eax,1
mov dword ptr 子[ebp],eax
jmp 璇首
璇尾 :
nop
functionend1 :
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
universe endp
.data
end universe

----------------------------------------------

//t6.u
int i;
mean do_sth(a,c)
{
 a
 {
  i=i+1;
  c;
 }
}
do_sth(int fc1(int a))
{
 return a*a; 
}
do_sth(int fc2(int a;int b))
{
 return a+b; 
}
do_sth(int fc3(int a))
{
 return a+3; 
}
do_sth(int fc4(int a))
{
 return a-2; 
}

i=0;
int j;

j=fc1(i);
j=fc2(i;3);
j=fc4(i);
j=fc3(i);

-----------------
//t5.asm
.386p
.model flat
.code
universe proc
push ebp
mov ebp,esp
sub esp,8
push ebx
push esi
push edi
i =-4
j =-8
nop
mov eax,0
mov dword ptr i[ebp],eax
mov eax,dword ptr i[ebp]
push eax
call fc1
add esp,4
mov eax,eax
mov dword ptr j[ebp],eax
mov eax,3
push eax
mov eax,dword ptr i[ebp]
push eax
call fc2
add esp,8
mov eax,eax
mov dword ptr j[ebp],eax
mov eax,dword ptr i[ebp]
push eax
call fc4
add esp,4
mov eax,eax
mov dword ptr j[ebp],eax
mov eax,dword ptr i[ebp]
push eax
call fc3
add esp,4
mov eax,eax
mov dword ptr j[ebp],eax
nop
functionend1 :
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
universe endp
fc4 proc
push ebp
mov ebp,esp
sub esp,0
push ebx
push esi
push edi
a =8
nop
mov eax,dword ptr i[ebp]
add eax,1
mov dword ptr i[ebp],eax
mov eax,dword ptr a[ebp]
sub eax,2
mov eax,eax
jmp functionend5
nop
functionend5 :
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
fc4 endp
fc3 proc
push ebp
mov ebp,esp
sub esp,0
push ebx
push esi
push edi
a =8
nop
mov eax,dword ptr i[ebp]
add eax,1
mov dword ptr i[ebp],eax
mov eax,dword ptr a[ebp]
add eax,3
mov eax,eax
jmp functionend4
nop
functionend4 :
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
fc3 endp
fc2 proc
push ebp
mov ebp,esp
sub esp,0
push ebx
push esi
push edi
b =8
a =12
nop
mov eax,dword ptr i[ebp]
add eax,1
mov dword ptr i[ebp],eax
mov eax,dword ptr a[ebp]
add eax,dword ptr b[ebp]
mov eax,eax
jmp functionend3
nop
functionend3 :
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
fc2 endp
fc1 proc
push ebp
mov ebp,esp
sub esp,0
push ebx
push esi
push edi
a =8
nop
mov eax,dword ptr i[ebp]
add eax,1
mov dword ptr i[ebp],eax
mov eax,dword ptr a[ebp]
imul eax,dword ptr a[ebp]
mov eax,eax
jmp functionend2
nop
functionend2 :
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
fc1 endp
.data
end universe

----------------------------------------------

……………

人法地，地法天，天法道，道法自然。太极语言是非常奇妙的，现在我仅仅讲了太极语言中之面向概念程序设计理论中之代码组合理论之一小小部分，我已经建立了0型文法正交完备描述模型，而且从数学角度进行了严谨的证明，太极语言将给程序设计带来极深远的影响。

（未完待续）

http://taiji9.getbbs.com/
http://blog.csdn.net/universee

 

 

 

-----------------------------------------------------------------------------------------
这是以前的那篇文章：

太极语言出世----比C++更好的语言

我设计了一种新的计算机语言－－太极语言，英文名The Universe Language。

我是2002年秋天开始做太极语言的，（我是微波专业卫星通信方向的，当时我正在编一个非常复杂的程序，那个程序要自动做微积分自动推导一些电磁场与电磁波方程，用C++编觉的不够灵活，于是下决心做一套自己的编译器实现自己的语言）

下面我简单介绍一下太极语言。

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

do_sth(int fc1(int a))
{
 return a*a;
}
do_sth(int fc2(int a,int b))
{
 return a+b;
}
do_sth(int fc3(int a))
{
 return a+3;
}
do_sth(int fc4(int a))
{
 return a-2;
}
 
编译后这就成了一组函数，
int fc1(int a)
{
 i++;
 return a*a;
}
int fc2(int a,int b)
{
 i++;
 return a+b;
}
int fc3(int a)
{
 i++;
 return a+3;
}
int fc4(int a)
{
 i++;
 return a-2;
}

规则还是刚才的规则：依次第n个参数用后面第n个括号中的代码来代换，最后一个可以用{}。
这是非常奇妙的，你现在可以自己试着写一段公用退出代码。

其实在太极语言中while,if等控制语句都是这样基于概念虚拟出来的。
比如定义while概念
code while(a)
{
 sign://进入代码
 b;
 goto(a) sign;//退出代码
}
后

while(i<100)
{
 n=n+i;
 i++;
}
被编译成
sign:
n=n+i;
i++
goto(i<100) sign;

（goto(i<100) sign;是条件goto语句，就是if(i<100) goto sign。另外sign是一个标号编译自增量，这个以后再说了）

基于概念的编程可以方便的控制非线性上下文相关代码。比如有进入和退出模式的代码。

例1：
code usepointer(code pointertype,code pointer,code c)
{
 pointertype * pointer=new pointertype; 
 c;
 delete pointer;
}
usepointer(int,p)
{ ... }
想想这个编译后是什么了？
是：

int * p=new int;
……
delete p;

但是delete的语句不用写了，会自动产生这句话。一次定义，到处使用。在头文件里包含usepointer的定义。好了，这样可以自动解决一大部分可能造成内存泄露的代码了。

 

usepointer(int,p1)
{
 usepointer(int,p2)
 {
  ...
 }
}
这个呢？会被编译成什么？

再举一个例子
例2：
code paint(a)
{
 hdc=BeginPaint(hWnd, &ps);
 a;
 EndPaint(hWnd, &ps);
}
paint
{
 TextOut(hdc,0,0,str, strlen(str));
}
被编译成什么了？
hdc=BeginPaint(hWnd, &ps);
TextOut(hdc,0,0,str, strlen(str));
EndPaint(hWnd, &ps);

限于篇幅，这里不多讲了，而且概念的设计还可以继承，还有“代码装配”的概念，就象机械装配，电路搭配那样，非常有趣。

太极语言非常讲究怎么想怎么编（HTHC）。看前面那个chain_show，是不是思维的直接描述？
 void chain_show(chain * pchn)
 {
  goover(pchn)
  { printf(pchn->name); }
 }

太极语言提出了基于概念描述的编程模式，这是根据模拟思维的原则做的。认识世界，通过概念的设立与关联应用。 比如我们刚才的例子中，遍历就是一个概念，每一个概念都单独用一个模块表示，概念间的关系用模块的组合来描述。
 这是比现在流行的“面向对象”，“泛型”更先进的模式。我可以预言，“基于概念”将是未来软件开发的主要模式，因为这几乎完全是在模拟人的思维形式。
 以前的“函数”，“类”，“面向对象”，只是非常有限度的局部部分模拟，“基于概念”将带来更深远的影响。
 基于概念的代码有极强的可复用性。你想想你自己头脑中的概念这种东西被你思维是复用了多少次。
 概念不只是描述静态物体，而且对于运行状态也同样可以描述，比如刚才说的“遍历”。数学上的定理都可以用概念的形式描述。
 概念的实现不只是一种编译器技术。还是一个软件总体设计工程的原则。

太极语言实现了垣的概念。一段包含进入与退出代码的区域就叫垣，其中进入与退出代码都可以为空。简单一点的说，就是两个括号一包就叫垣——这个字怎么这么形象呢。

太极语言中的函数，类，while等都是基于垣而实现的。垣可以无限嵌套。比如你可以在函数中再定义函数，甚至在if后面的（）里再定义另一个函数，在表达式的（）里定义一个类，……这都是可以的。太极语言的语法就是自由到这种程度。

（二）

1.函数可以象类一样继承，从而大大的提高了复用能力
2.函数可以嵌套定义，有利于避免名字空间中的冲突。
3.对一般类型可以象类一样添加成员函数
 比如可以对int自己添加一个tostr成员函数，
 typedef出来的类型也可以添加自定义成员函数，
4.对变量也可以添加成员函数，
 比如 int a,然后你可以对a 添加一个onchange函数，a的值一被改变时就被触发，或一用a做加法就被触发——象触发器的概念了。我是以前上VHDL课设计电路时想到这个触发器概念是可以做到编译器中的。
5.函数可以返回多个值，（从matlab中学来的）。
6.动态代码（变形代码），等效于代码可在运行时改变自身。
7.对区域（比如函数体）设计了onenter,onout，可以自动触发。
8.可以自己定义函数或类中变量的OFFSET。
9.可以直接使用ASM与机器码。
………

太极语言比C++描述能力更强更灵活,比C更贴近系统底层更可控。

我拓展了许多C++的基本概念,使其具有全面的普适性。
比如在设计函数继承时，设置了有名体的概念——无论数据类型（类，结构，一般类型）还是变量还是函数都是有名字的，只要是有名体，就可以进行继承，重载，……等一切操作，“一切有名体平等”。

最少的语法规则,最强的组合能力，最灵活又最表义的组合，最强的描述能力，最自由的语法……
太极语言在编译时是完全动态的嵌入式代码。
太极语言设计时是这样考虑的：用最少的语法规则，通过最灵活又最表义的组合，实现最完备的编译描述功能。

更少却更灵活的语法规则,更强大的描述能力.
举个例子
 c++中 ：template<t1,t2> class cls
   {
    t1 a;
    t2 b;
    t1 * pt1;
   };
 这是干什么，不就是t1,t2是参数么，看我的
 class cls(code t1,code t2)
 {
  t1 a;
  t2 b;
  t1 * pt1;
 };
 
 这看上去多象函数的那种格式啊，这样建立模板类多直观。还有模板参数用（）多好，为什么非要设计个古怪的<>呢？

 而且C/C++中
 typedef count int;
 struct student {....};
 class cls {.......};
 看我的
 type count int;
 type student {....};
 type cls {.......};
 只要是定义数据类型就用type!

这也是可以的：
 class cls(type t1,type t2)
 {
  t1 a;
  t2 b;
  t1 * pt1;
 };
 
 我觉得一种好的语言,不是在于设计了多少代码规则让你去遵守服从，而是设计的尽量少的规则，让你去组合搭积木玩。这里我与C/C++的对比不是说C/C++不好，C/C++有很好的组合灵活性与完备程度，但是我觉的C/C++仍然做的不够好，所以我设计了太极语言。

（未完待续，今天先去睡觉，明天继续，我的EMAIL:[e-mail]）