C++博客-岁月流转，往昔空明

VS8 C++ 头文件护卫宏的生成插件

空明流转 — Sun, 08 Mar 2009 16:06:00 GMT

没啥好说的，没什么技术含量，就是有点用，功能类似于VA X的#ifndef guard.
生成的格式按照 PROJECTNAME_FILENAME_FILEEXTNAME_GUID 来的。
比方说我的就是

SPIRIT_SASL_AST_NODE_STATEMENT_H_B530FB44_F5C8_431F_A250_E426F791B7CF

如果有需要可以自己改一下代码就好了。

语言是VB.NET.

工程+源代码文件下载地址

空明流转 2009-03-09 00:06 发表评论

静态强类型语言的类型声明与变量声明

空明流转 — Tue, 24 Feb 2009 17:33:00 GMT

摘要: 详细讨论了在设计静态强类型语言语法时如何处理类型别名(typedef)和变量定义的类型声明的问题。阅读全文

空明流转 2009-02-25 01:33 发表评论

C++下Windows Forms + MFC + WTL + wxWidgets + Qt + GTK+ 非官方综合比较

空明流转 — Tue, 06 Jan 2009 10:09:00 GMT

最近用了一段时间的wxWidgets。
基本上主流的界面库也就算用的差不多了。
这里拿一个表格对这些界面库做一个比较直观的比较。

界面库名称	接口设计	界面编辑器	高级布局功能	平面绘制	平台兼容性	语言支持	IDE兼容性	视图-模型分离机制	运行时	其它
Windows Forms	接口优秀。C++下使用CLI扩展，其它语言为原生支持。	界面编辑器完整，包括布局、属性、消息关联的完整设置。不可预览。	Table Layout，Splitter Layout，Flow Layout等，Anchor和Dock机制。多分辨率界面下表现良好。	GDI+，面向对象的2D绘制接口，使用简便。	需要.Net平台支持。WIndows或Linux（Mono，非官方支持），支持Windows CE	C++/CLI, 支持.net的语言。	仅VS。	布局和视图方案建立在代码中。部分组件支持Model-View架构。	需要部署对应的.net	商业协议
MFC	基于宏和虚函数，使用特殊格式注释，使用自定义的RTTI系统。类接口设计优良。通过回调函数和虚继承重载调用客户代码。	基于资源编辑器，仅能对空间基本布局和少量属性进行调整。不可预览。	缺乏高级布局功能，多分辨率需要是手工或程序中调整。	GDI及GDI封装，可选GDI+	Windows，Windows CE	C++ Only，支持COM时可以实现Binary级别复用。	仅Visual Studio	使用资源保存控件的基本控件布局，提供Doc-View机制和控件数据交换支持视图分离。	需要部署MFC运行时库。	商业协议
WTL	基于模板和虚函数。类接口类似于MFC。需要使用多重继承。通过模板特化和回调函数与客户代码交互。	同MFC	同MFC	同MFC	同MFC	同MFC，对COM的支持比MFC完善很多。	Visual Studio，Windows下支持标准的C++编译器。	使用资源文件保存空间布局。	无	自由协议
wxWidget	宏，自定义RTTI。使用回调函数与用户代码交互。	无官方界面编辑器。可使用第三方界面编辑器。部分编辑器具有完整的所见即所得功能，且具有预览能力。	使用Sizer实现多分辨率的布局。功能偏弱。	wxDC等。	Windows，Linux，Unix，MacOS等	C++, .NET, Python, Lua, Ruby等	良好的编译器兼容性，缺乏IDE继承。	可以将界面属性生成到代码中，也可以使用XML格式保存。	wx的动态链接库或静态链接。	自由协议
Qt	使用宏和自定义的RTTI。使用Singal-Slot机制实现用户代码交互。可通过继承实现扩展。	Qt Designer，具备完整的所见即所得编辑功能。可预览界面。	具备完整的布局功能。多分辨率/多平台下表现良好。	QCanvas等。	Windows，Linux，Unix，MacOS等。	C++，Python等	可集成到Eclipse和VS	使用资源文件保存界面信息。部分组件具备Model-View-Delegate架构	qt的动态链接库。	开源协议+商业协议
GTK+	使用signal-slot机制完成用户代码交互。	GLADE，具备所见即所得的界面编辑功能	Layout Containers，具备较完整的布局能力。	GTK Graphics Context	Windows，Linux，Unix，MacOS等。	C，C++，Python，.NET等。	（暂时未知）	使用代码完成界面设置。部分组件具备Model-View架构。	GTK Runtime	开源协议

此外，除了WTL外，其余各界面库均有完整及时的文档和手册，因此比较项中不再指明。
回帖中有人指出国际化问题的比较，事实上MS的产品和开源对于国际化的解决方法是不同的。但是都可以比较方便的解决国际化问题。

空明流转 2009-01-06 18:09 发表评论

Flex 2.5.33 和 Bison 2.3 下载

空明流转 — Fri, 19 Dec 2008 14:16:00 GMT

如果为了一个Flex和Bison就下整个MSYS和Cygwin我觉得有点太夸张了。
不过为了提个可用的新版本花了我两个晚上。麻烦死了。
我估计还有人也会觉得很麻烦。
所以就把这个下载放上来，在win下面可以独立运行的，不过最好把bin目录设置到Path中。

在我的工程里面是用批处理做的，这样可以放到编译前脚本里面，就可以在编译前自动生成新的分析文件。

其实我还改了下FlexLexer.h，不知道为什么我的那个会有redefine的编译错误，mingw gcc432(tdm版)。
VS下面没有运行过，不过应该没问题。
也不知道我修的是对是错，还请高人指点。

@echo off
set path=%path%;../util/bin/
bison -d gram.y
flex -o lex.yy.cc lex.l

下载地址，带RR10%, .

空明流转 2008-12-19 22:16 发表评论

设计模式小结（四） -- 终于完结了，哇咔咔，和上篇隔了9个月，汗。

空明流转 — Fri, 21 Nov 2008 10:29:00 GMT

摘要: 设计模式小结的最后一篇，这样 GOF 2X 个模式就都齐全了。。。
欢迎大家喷。。。。阅读全文

空明流转 2008-11-21 18:29 发表评论

文件夹比较备份工具

空明流转 — Thu, 06 Nov 2008 15:48:00 GMT

这个工具源自于我的一个需求，
我将文档都保存在了硬盘上，只不过由于分布不够大而只能分开放置于多个文件夹中。
有时候我需要将这些数据进行备份，一张盘也放不下，也就需要备份到多张盘中。

此时问题出现了，如果我往硬盘上新添了一些文档，在我下一次备份的时，我如何准确的筛选出新增的文档。

一般来讲如果只是一个源盘和一个目标盘，用Beyond Compare或者类似的工具就能解决问题。
不过现在是多对多的，问题就变得比较复杂。

因此我就做了这么个东西，可以将多个目录组成虚拟的文件树再进行比较。
文件夹的对应关系直接利用同级文件夹的名称来判断。
我也提供了手工设置文件夹对应关系的功能，不过因为UI方面还没考虑好所以没有加上。

而文件之间的比较利用两种方案，一种方案在文件被计算过MD5效验的时候直接使用MD5比较；
如果没有MD5的话使用文件大小和最后修改时间比较。
由于文件比较不使用文件名，也就获得不了对应关系，因此目录树下面的所有文件的所有组合都要一一遍历。
同时由于计算MD5效验码需要读取整个文件，时间较长，因此Checksum是需要手动计算和刷新的。

最后就是树可以整棵的被保存到快照文件中，格式是XML的格式，人也可以读。
比较过后，可以某个子树或者单棵整树的相同文件或这新增文件拷贝到一个目录下。
本来希望能直接生成Nero的刻录清单的文件格式，后来找不到相关的资料就只好放弃了。

Download Source Code Project，VS2005 / VS2005 SP1, XP SP2/SP3下通过。

屏幕快照。红色表示新增文件，蓝色表示相同文件，黄色表示不完全对应。

空明流转 2008-11-06 23:48 发表评论

将树型数据结构转换为图片并自动排版

空明流转 — Sat, 13 Sep 2008 04:42:00 GMT

呃，怎么说呢，这个和vczh的同名文章是互为补充的。这是最近老板的要求，所以就写了这么个东西。

vczh的方法生成的树是sparse的，而我这里树则要紧凑一些，所使用的坐标系也与之不同。

效果（看起来挺菜，哇咔咔）

布局分为水平布局和竖直布局两个部分，我这里先进行了水平布局再进行了竖直布局。

一般来讲紧凑的树主要指同级节点方向上的紧凑性。由于这里树是父节点在上，子结点在下，因此水平方向上的节点要尽量紧凑。那么便需要我将节点尽量往左布局。
如果自左往右布置节点，那么很显然，左边的节点的位置一旦固定下来就不需要再行调整。
同时，为了保持树的美观，父节点的水平中心应当是子结点的水平中心，这样子结点就会对称分布在父节点的下方，有利于美观。
然而父节点能正常布局的位置，子结点可能无法正常布局（子结点的宽度比父节点宽得多）。因此我们还需要调整子结点的布局。
由于是自左向右布局的，此时子结点的左边的节点都已经确定了，正确的布局很容易便可以通过右移得到。
为了保证正确性，还需要把父节点也右移。因为父节点的右边没有布局限制，因而可以放心的右移。这样一直传递到根节点就可以了。
那么很明显，整体来说，布局顺序就是，自下而上，自左而右。

为了让节点在布局的时候知道自己能被安排的最左位置，需要为每一层保存最左可布局位置的坐标。
一旦有节点被安排妥当，便更新节点所在层次的最左可布局位置。后来的节点只要在这个位置的右方布局，就不会与已布置的节点冲突。

竖直布局并不复杂，算出每一层的Top就可以了。

代码如下：

using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;

//布局算法：
//采用平行节点最左布局，父子节点对中布局的原则。

/****
*  void Layout(int lyr)
*  {
*
*  }
*
*****/
namespace CrowdTree
{
    class LayoutTreeLayerInfo
    {
        //可安排布局的最左坐标
        private Dictionary<int, float> lyrLefts = new Dictionary<int,float>();
        private Dictionary<int, float> heights = new Dictionary<int,float>();

        public void Reset()
        {
            lyrLefts = new Dictionary<int, float>();
            heights = new Dictionary<int, float>();
        }

        public float GetLayoutableLeft(int level)
        {
            if (lyrLefts.ContainsKey(level))
            {
                return lyrLefts[level];
            }
            return 0;
        }

        public void SetLayoutableLeft(int level, float left)
        {
            if (lyrLefts.ContainsKey(level))
            {
                lyrLefts[level] = Math.Max(left, lyrLefts[level]);
            }
            else
            {
                lyrLefts[level] = Math.Max(0, left);
            }
        }

        public void SetLayoutLevelMinHeight(int level, float height)
        {
            if (heights.ContainsKey(level))
            {
                heights[level] = Math.Max(heights[level], height);
            }
            else
            {
                heights[level] = height;
            }
        }

        public float GetLayoutLevelMinHeight(int level)
        {
            if (heights.ContainsKey(level))
            {
                return heights[level];
            }
            return 0;
        }
    }

    class LayoutTreeNode
    {
        protected LayoutTree owner_;
        protected LayoutTreeLayerInfo lyrInfo_;
        protected int lyrLevel_;
        protected RectangleF rect_;
        protected List<LayoutTreeNode> children_ = new List<LayoutTreeNode>();

        public int Level
        {
            get { return lyrLevel_; }
            set { lyrLevel_ = value; }
        }

        public LayoutTree Owner
        {
            get { return owner_; }
            set { owner_ = value; }
        }

        public LayoutTreeLayerInfo LayerInfo
        {
            set { lyrInfo_ = value; }
        }

        public List<LayoutTreeNode> Children
        {
            get { return children_; }
        }

        public RectangleF Extent
        {
            get { return rect_; }
        }

        protected void LayoutHorizontal()
        {
            //获取当前节点能够排布的最左位置，并预先安排当前节点。
            float originLeft = lyrInfo_.GetLayoutableLeft(lyrLevel_);
            rect_.X = originLeft;

            //根据当前结点的坐标，安排子结点，并需要根据子结点的安置情况重新调整父节点的安置
            if (children_.Count > 0)
            {
                //计算子结点最左可以安放的位置
                float childrenTotalWidth = 0.0F;
                foreach (LayoutTreeNode child in children_)
                {
                    childrenTotalWidth += child.Extent.Width;
                }
                childrenTotalWidth += ((children_.Count - 1) * owner_.HorizontalSpacer);
                float childLeftest = originLeft + (rect_.Width / 2.0f) - (childrenTotalWidth / 2.0F);

                //设置子结点安放的最左位
                lyrInfo_.SetLayoutableLeft(lyrLevel_ + 1, childLeftest);

                //安放子结点
                for (int idxChild = 0; idxChild < children_.Count; ++idxChild)
                {
                    children_[idxChild].LayoutHorizontal();
                }

                 //利用子结点重新对中安置当前节点
                float center = (children_[0].Extent.Left + children_[children_.Count - 1].Extent.Right) / 2.0F;
                rect_.X = center - rect_.Width / 2.0F;
            }

            //利用节点坐标设置该层其他子结点所能安放的最左位置，并设置一下当前层元素的最大高度
            lyrInfo_.SetLayoutableLeft(lyrLevel_, this.rect_.Right + owner_.HorizontalSpacer);
            lyrInfo_.SetLayoutLevelMinHeight(lyrLevel_, this.rect_.Height);
        }

        protected void LayoutVertical(float top)
        {
            rect_.Y = top;
            foreach (LayoutTreeNode child in children_)
            {
                child.LayoutVertical(top + lyrInfo_.GetLayoutLevelMinHeight(lyrLevel_) + owner_.VerticalSpacer);
            }
        }

        public void Layout()
        {
            LayoutHorizontal();
            LayoutVertical(0.0f);
        }

        public virtual void CalculateSize(float maxWidth, Font font, Graphics g)
        {
        }

        public virtual void CalculateSizeRecursive(float maxWidth, Font font, Graphics g)
        {
        }

        public virtual void Draw(Graphics g) { }
    }

    class TextLayoutTreeNode: LayoutTreeNode
    {
        private string text;
        private StringFormat strFmt = new StringFormat();
        private Font font;

        public String Text
        {
            get { return text; }
            set { text = value; }
        }

        public override void CalculateSize(float maxWidth, Font font, Graphics g)
        {
            strFmt.Alignment = StringAlignment.Center;
            strFmt.LineAlignment = StringAlignment.Center;

            rect_.Size = g.MeasureString(text, font, (int)maxWidth, strFmt);
            this.font = font;
        }

        public override void CalculateSizeRecursive(float maxWidth, Font font, Graphics g)
        {
            CalculateSize(maxWidth, font, g);
            foreach (LayoutTreeNode node in children_)
            {
                node.CalculateSizeRecursive(maxWidth, font, g);
            }
        }

        public override void Draw(Graphics g)
        {
            //外轮廓，内容，连线
            g.DrawRectangle(Pens.Black, Rectangle.Round(Extent));
            g.DrawString(text, font, Brushes.Red, Extent);

            foreach (LayoutTreeNode childNode in children_)
            {
                //绘制斜线

                float childX = (childNode.Extent.Left + childNode.Extent.Right) / 2.0F;
                float childY = childNode.Extent.Top;

                float curX = (Extent.Left + Extent.Right) / 2.0f;
                float curY = Extent.Bottom;

                g.DrawLine(Pens.Black, new PointF(childX, childY), new PointF(curX, curY));
            }
        }
    }

    class LayoutTree
    {
        private float vertical_spacer;
        private float horizontal_spacer;

        private LayoutTreeNode root;
        private LayoutTreeLayerInfo lyrInfo = new LayoutTreeLayerInfo();

        public float VerticalSpacer
        {
            get { return vertical_spacer; }
            set { vertical_spacer = value; }
        }

        public float HorizontalSpacer
        {
            get { return horizontal_spacer; }
            set { horizontal_spacer = value; }
        }

        public LayoutTreeNode Root
        {
            get { return root; }
            set { root = value; }
        }

        public void ResetLayout()
        {
            lyrInfo.Reset();
        }

        public T CreateNode<T> (LayoutTreeNode parent) where T:LayoutTreeNode, new()
        {
            T retNode = new T();

            retNode.Owner = this;
            retNode.LayerInfo = this.lyrInfo;

            if (parent == null)
            {
                this.root = retNode;
                retNode.Level = 0;
            }
            else
            {
                parent.Children.Add(retNode);
                retNode.Level = parent.Level + 1;
            }
            return retNode;
        }
    }
}

空明流转 2008-09-13 12:42 发表评论

SoftArt Shader Language Syntax EBNF

空明流转 — Thu, 24 Jul 2008 18:25:00 GMT

经过一晚上的整理，把 SoftArt Shader Language 的 EBNF 弄出来了。
主要参照的是 ISO C++的EBNF 。
由于ISO C++并不是一个LALR(1)能够解决的问题，因此不知道这个C++ EBNF的简化版能否在YACC上比较方便的实现。
如果不能实现，我会先考虑修正语法满足需要，而不是手写编译器，我还没那个能耐。

Flex 与 Bison 的下载地址

//SASL: SoftArt Shader Language

Syntax

Program             ::= DeclSeq

//////////////////////////////////
//Declaration
//////////////////////////////////
DeclSeq             ::= Decl | 
                        DeclSeq Decl
                        
Decl                ::= BlockDecl |
                        FunctioDef

Declarator          ::= DirectDecl [SemanticSpec] [RegisterSpec]

DirectDecl          ::= DeclId |
                        DirectDecl '(' ParamDeclClause ')'|
                        DirectDecl '[' [ConstExp] ']'|
                        '(' Declarator ')'

CvQualifierSeq      ::= CvQualifier [CvQualifierSeq]

CvQualifier         ::= 'const' | 'uniform'

SemanticSpec        ::= ':' Semantic

RegisterSpec        ::= ':' 'register' '(' Register ')'
                        
BlockDecl           ::= SimpleDecl

SimpleDecl          ::= [DeclSpecSeq] [InitDeclList] ';'

AbsDecl             ::= DirectAbsDecl

DirectAbsDecl       ::= [DirectAbsDecl] '(' ParamDeclClause ')' |
                        [DirectAbsDecl] '[' [ConstExp] ']' |
                        '(' AbsDecl ')'
                        

DeclSpecSeq         ::= [DeclSpecSeq] DeclSpec

InitDeclList        ::= InitDecl |
                        InitDeclList ',' InitDecl

InitDecl            ::=    Declarator [Init]

Init                ::= '=' InitClause                         |
                        ( ExpList)
                        
InitClause          ::= AssignmentExp |
                        '{' InitList [','] '}' |
                        '{' '}'
InitList            ::= InitClause |
                        InitList ',' InitClause
                        
DeclSpec            ::= TypeSpec
                        
TypeSpec            ::= SimpleTypeSpec |
                        ClassSpec

SimpleTypeSpec      ::=    'int' | 'half' | 'float' |
                        'int2' | 'half2' | 'float2' |
                        'int3' | 'half3' | 'float3' |
                        'int4' | 'half4' | 'float4' |
                        'float4x4'

/////////////////////////////
//Function
/////////////////////////////
FunctionDef         ::= [DeclSpecSeq] Declarator FunctionBody

FunctionBody        ::= CompoundStatement

/////////////////////////////
//Statements
/////////////////////////////
CompoundStatement   ::= '{' [StatementSeq] '}'

StatementSeq        ::= Statement |
                        StatementSeq Statement

Statement           ::= ExpStatement |
                        CompountStatement |
                        SelectionStatement |
                        IterationStatement |
                        DeclStatement
                        
ExpStatement        ::= [ Expression ] ';'

SelectionStatement  ::= 'if' '(' Condition ')' Statement |
                        'if' '(' Condition ')' Statement 'else' Statement

IterationStatement  ::= 'while' '(' Condition ')' Statement |
                        'do' Statement 'while' '(' Expression ')' ';'
                        'for' '(' ForInitStatement [Condition] ';' [ Expression ] ')' Statement
        
Condition           ::= Expression |
                        TypeSpecSeq Declarator '=' AssignmentExp

ForInitStatement    ::= ExpStatement |
                        SimpleDecl

DeclStatement       ::= BlockDecl

/////////////////////////////                        
//Parameter
/////////////////////////////
ParamDeclClause     ::= [ ParamDeclList ]

ParamDeclList       ::= ParamDecl |
                        ParamDeclList ',' ParamDecl

ParamDecl           ::= DeclSpecSeq Delarator |
                        DeclSpecSeq [AbsDecl]


/////////////////////////////
//Class And Struct
/////////////////////////////
ClassSpec           ::= ClassHead '{' [ MemberSpec ] '}'

ClassHead           ::= 'struct' [ Identifier ]

MemberSpec    `     ::= MemberDecl [MemberSpec]

MemberDeclaration   ::= [DeclSpecSeq] [MemberDeclList]

MemberDeclList      ::= MemberDecl |
                        MemberDeclList ',' MemberDeclarator
                        
MemberDeclarator    ::=    Declarator [ PureSpec ] |
                        Declarator [ ConstInit ] |
                        [ Identifier ] ':' ConstExp



//////////////////////////////////////
//Expressions
//////////////////////////////////////
Expression          ::= AssignmentExp

ConstExp            ::= CondExp

AssignmentExp       ::= CondExp |
                        LogicalOrExp AssignmentOp AssignmentExp
                        
CondExp             ::= LogicalOrExp |
                        LogicalOrExp '?' Expression ':' AssignmentExp

LogicalOrExp        ::= LogicalAndExp |
                        LogicalOrExp '||' LogicalAndExp
                        
LogicalAndExp       ::= InclusiveOrExp |
                        LogicalAndExp '&&' InclusiveOrExp
                        
InclusiveOrExp      ::= ExclusiveOrExp |
                        InclusiveOrExp '|' ExclusiveOrExp
                        
ExclusiveOrExp      ::= AndExp |
                        ExclusiveOrExp '^' AndExp

AndExp              ::= EqualExp |
                        AndExp '&' EqualExp

EqualExp            ::= RelExp |
                        EqualExp '==' RelExp |
                        EqualExp '!=' RelExp

RelExp              ::= ShiftExp |
                        RelExp '<' ShiftExp |
                        RelExp '>' ShiftExp |
                        RelExp '<=' ShiftExp |
                        RelExp '>=' ShiftExp

ShiftExp            ::= AddExp |
                        ShiftExp '<<' AddExp |
                        ShiftExp '>>' AddExp

AddExp              ::= MulExp |
                        AddExp '+' MulExp |
                        AddExp '-' MulExp

MulExp              ::= PmExp |
                        MulExp '*' PmExp |
                        MulExp '/' PmExp |
                        MulExp '%' PmExp
    
PmExp               ::= CastExp |
                        PmExp '.*' CastExp

CastExp             ::= UnaryExp |
                        '(' TypeId ')' CastExp

UnaryExp            ::= PostfixExp |
                        '++' CastExp |
                        '--' CastExp |
                        UnaryOp CastExp
                        
PostfixExp          ::= PrimaryExp |
                        PostfixExp '[' Expression ']' |
                        PostfixExp '(' Expression ')' |
                        PostfixExp '(' [ ExpList ] ')' |
                        SimpleTypeSpec '(' [ ExpList ] ')' |
                        PostfixExp '++' |
                        PostfixExp '--'

PrimaryExp          ::= Literal |
                        '(' Expression ')' |
                        IdExp

IdExp               ::= UnqualifiedId

ExpList             ::= AssigmentExp |
                        ExpList ',' AssignmentExp
                        
//////////////////////////////
//Identifier
//////////////////////////////
DeclId              ::= IdExp |
                        TypeName

UnqualifiedId       ::= Identifier

Identifier          ::= NonDigit |
                        Identifier NonDigit |
                        Identifier Digit

//////////////////////////////
//Literals
//////////////////////////////
Literal             ::= IntLiteral |
                        FloatLiteral |
                        BoolLitreral

IntLiteral          ::= DemicalLiteral

DemicalLiteral      ::= NonZeroDigit |
                        DemicalLiteral | Digit
    
FloatLiteral        ::= FracConstant [ExponentPart] |
                        DigitSeq ExponentPart
                        
BoolLiteral         ::= 'false' |
                        'true'

FracConstant        ::= [DigitSeq] '.' DigitSeq |
                        DigitSeq '.'
                        
ExponentPart        ::= 'e' [Sign] DigitSeq |
                        'E' [Sign] DigitSeq
                        
DigitSeq            ::= Digit |
                        DigitSeq Digit
                        
//////////////////////////
//Terminals
//////////////////////////

NonDigit            ::= AlphaChar |
                        '_'

NonZeroDigit        ::= '1' |  | '9'

AssignmentOp        ::= '=' | 
                        '*='  | '/='  | '%=' |
                        '+='  | '-='  |
                        '>>=' | '<<=' |
                        '&='  | '^='  | '|='
Register
Semantic
Digit
AlphaChar
Keyword

有点儿参差不齐，哈哈。一些Terminator我就没有写了。预处理的部分由于使用Boost.Wave，因此也没有加入到EBNF中。这些都很大程度上简化了EBNF的内容。
然后大概的根据层次归了一下类，看起来要方便一点。
但愿语法树里面没有漏掉的。
等回到自己机器上就开始自下向上的实现这个东西了，争取10月份之前能把整个Shader编译器集成到SoftArt里面去。
目前就让它在SVN的SandBox里面待着好了。

空明流转 2008-07-25 02:25 发表评论

开始写EBNF Grammar for SoftArt Shader Language

空明流转 — Thu, 24 Jul 2008 16:11:00 GMT

最近在做Shader的编译器。

想好了我的编译器就叫SASL，SoftArt Shader Language。
因为之前没写过EBNF，没什么经验，因此找了C和C++的EBNF在参考。
特别是C的EBNF。
因为可以用LALR(1)实现，因此对我这样用LEX + YACC的人而言就更加有用一点。
整体而言准备尽可能和SM4.0一致，用Boost.Wave支持Preprocessing。
这样的话差不多就全了。这两天先把Shader的EBNF弄出来，完了开始从小往大写慢慢写语法分析器和编译器。

http://www.externsoft.ch/download/cpp-iso.html

这里是C++的EBNF。有点太复杂了觉得。。。

空明流转 2008-07-25 00:11 发表评论

再用Boost.Python

空明流转 — Mon, 14 Jul 2008 11:05:00 GMT

上次用boost.python的时候boost还是1.33的时候。

那个时候刚刚开始看shader的东西，就用boost.python做了用python做shader语言的演示。
其实当时看boost.python完全是半懂不懂的。
这段时间找了个C的数值库，要Python的接口，Python For C的Interface又懒得使用，还是用boost.python把一些我要的功能给封装出来好了。
结果一看才发现对Boost.Python的理解好了不好。

看来人都是在慢慢进步的。。。哈哈。

空明流转 2008-07-14 19:05 发表评论