Skip to content

L
Lab02
提交 5110454a 创建 作者: 赵鹏翀's avatar 赵鹏翀
浏览文件
操作

init template

上级
隐藏空白字符变更
内嵌 并排
正在显示 包含 835 行增加 和 0 行删除
.gitignore 0 → 100644
浏览文件 @ 5110454a
/Debug
/Release
NFAFragmentStack.c 0 → 100644
浏览文件 @ 5110454a
#include "NFAFragmentStack.h"
/*
功能：
初始化栈。
参数：
pS -- 栈的指针
*/
void InitNFAFragmentStack(NFAFragmentStack* pS)
{
pS->top = -1;
}
/*
功能：
将元素入栈。
参数：
pS -- 栈的指针
Elem -- 入栈的元素
返回值：
空
*/
void PushNFAFragment(NFAFragmentStack* pS, NFAFragment Elem)
{
//
// 栈满，入栈失败。
//
if(MAX_STACK_LENGTH - 1 <= pS->top)
return;
pS->top++;
pS->buffer[pS->top] = Elem; // 将元素插入栈顶
return;
}
/*
功能：
将栈顶元素出栈
参数：
pS -- 栈的指针
返回值：
如果出栈成功返回出栈元素的值。
如果出栈失败返回 -1。
*/
NFAFragment PopNFAFragment(NFAFragmentStack* pS)
{
int pos;
NFAFragment fragment = {0, 0};
//
// 栈为空，出栈失败
//
if(NFAFragmentStackEmpty(pS))
return fragment;
pos = pS->top;
pS->top--;
return pS->buffer[pos];
}
/*
功能：
判断栈是否为空。
参数：
pQ -- 栈的指针
返回值：
如果栈空返回 1（真）
如果栈非空返回 0（假）
*/
int NFAFragmentStackEmpty(NFAFragmentStack* pS)
{
return -1 == pS->top ? 1 : 0;
}
NFAFragmentStack.h 0 → 100644
浏览文件 @ 5110454a
#ifndef _NFAFRAGMENTSTACK_H_
#define _NFAFRAGMENTSTACK_H_
//
// 在此处包含 C 标准库头文件
//
//
// 在此处包含其他头文件
//
#include "NFAToDFA.h"
//
// 在此处定义数据结构
//
#define MAX_STACK_LENGTH 1024 // 栈的最大长度
// 栈
typedef struct _NFAFragmentStack{
NFAFragment buffer[MAX_STACK_LENGTH]; // 栈的缓冲区
int top; // 指示栈顶的位置，而不是栈中元素的个数
}NFAFragmentStack;
//
// 在此处声明函数
//
void InitNFAFragmentStack(NFAFragmentStack* pS);
void PushNFAFragment(NFAFragmentStack* pS, NFAFragment Elem);
NFAFragment PopNFAFragment(NFAFragmentStack* pS);
int NFAFragmentStackEmpty(NFAFragmentStack* pS);
//
// 在此处声明全局变量
//
#endif /* _NFAFRAGMENTSTACK_H_ */
NFAStateStack.c 0 → 100644
浏览文件 @ 5110454a
#include "NFAToDFA.h"
#include "NFAStateStack.h"
/*
功能：
初始化栈。
参数：
pS -- 栈的指针
*/
void InitNFAStateStack(NFAStateStack* pS)
{
pS->top = -1;
}
/*
功能：
将元素入栈。
参数：
pS -- 栈的指针
Elem -- 入栈的元素
返回值：
空
*/
void PushNFAState(NFAStateStack* pS, NFAState* Elem)
{
//
// 栈满，入栈失败。
//
if(MAX_STACK_LENGTH - 1 <= pS->top)
return;
pS->top++;
pS->buffer[pS->top] = Elem; // 将元素插入栈顶
return;
}
/*
功能：
将栈顶元素出栈
参数：
pS -- 栈的指针
返回值：
如果出栈成功返回出栈元素的值。
如果出栈失败返回 -1。
*/
NFAState* PopNFAState(NFAStateStack* pS)
{
int pos;
NFAState* State = 0;
//
// 栈为空，出栈失败
//
if(NFAStateStackEmpty(pS))
return State;
pos = pS->top;
pS->top--;
return pS->buffer[pos];
}
/*
功能：
判断栈是否为空。
参数：
pQ -- 栈的指针
返回值：
如果栈空返回 1（真）
如果栈非空返回 0（假）
*/
int NFAStateStackEmpty(NFAStateStack* pS)
{
return -1 == pS->top ? 1 : 0;
}
NFAStateStack.h 0 → 100644
浏览文件 @ 5110454a
#ifndef _NFASTATESTACK_H_
#define _NFASTATESTACK_H_
//
// 在此处包含 C 标准库头文件
//
//
// 在此处包含其他头文件
//
//
// 在此处定义数据结构
//
#define MAX_STACK_LENGTH 1024 // 栈的最大长度
// 栈
typedef struct _NFAStateStack{
NFAState* buffer[MAX_STACK_LENGTH]; // 栈的缓冲区
int top; // 指示栈顶的位置，而不是栈中元素的个数
}NFAStateStack;
//
// 在此处声明函数
//
void InitNFAStateStack(NFAStateStack* pS);
void PushNFAState(NFAStateStack* pS, NFAState* Elem);
NFAState* PopNFAState(NFAStateStack* pS);
int NFAStateStackEmpty(NFAStateStack* pS);
//
// 在此处声明全局变量
//
#endif /* _NFASTATESTACK_H_ */
NFAToDFA.cplproj 0 → 100644
浏览文件 @ 5110454a
<?xml version="1.0" encoding="gb2312"?>
<OSLProject Version="1.00" Name="NFAToDFA" SubjectID="11c951f4-9b13-40e1-8b73-39ba7d73b89b" ProjectTemplateID="04c3e277-faed-4ab5-a22d-8218c07edf52">
<Configurations>
<Configuration Name="Debug">
<Tool Name="PreBuildEventTool"/>
<Tool Name="CustomBuildTool"/>
<Tool Name="GCCCompilerTool" PreprocessorDefinitions="_DEBUG" GenerateDebugInformation="-1"/>
<Tool Name="PreLinkEventTool"/>
<Tool Name="GCCLinkerTool" AdditionalDependencies="&quot;$(CPLInstallDir)Dump\lib\NFAToDFA_Demo.o&quot;"/>
<Tool Name="PostBuildEventTool"/>
<VisualContext>
<WatchPoints>
<WatchPoint FunctionName="post2dfa" ObserverID="6183D540-E3EF-45d9-BEB5-D69242FBD682">
</WatchPoint>
</WatchPoints>
</VisualContext>
</Configuration>
<Configuration Name="Release">
<Tool Name="PreBuildEventTool"/>
<Tool Name="CustomBuildTool"/>
<Tool Name="GCCCompilerTool" PreprocessorDefinitions="NDEBUG"/>
<Tool Name="PreLinkEventTool"/>
<Tool Name="GCCLinkerTool"/>
<Tool Name="PostBuildEventTool"/>
</Configuration>
</Configurations>
<Files>
<Filter Name="ͷļ" Filter="h;hpp;hxx">
<File RelativePath=".\NFAFragmentStack.h">
</File>
<File RelativePath=".\NFAStateStack.h">
</File>
<File RelativePath=".\NFAToDFA.h">
</File>
<File RelativePath=".\PostToNFA.h">
</File>
<File RelativePath=".\RegexpToPost.h">
</File>
</Filter>
<Filter Name="Դļ" Filter="cpp;c;cc;cxx">
<File RelativePath=".\main.c">
</File>
<File RelativePath=".\NFAFragmentStack.c">
</File>
<File RelativePath=".\NFAStateStack.c">
</File>
<File RelativePath=".\PostToNFA.c">
</File>
<File RelativePath=".\RegexpToPost.c">
</File>
</Filter>
</Files>
</OSLProject>
NFAToDFA.h 0 → 100644
浏览文件 @ 5110454a
#ifndef _NFATODFA_H_
#define _NFATODFA_H_
//
// 在此处包含 C 标准库头文件
//
#include <stdio.h>
//
// 在此处包含其他头文件
//
//
// 在此处定义数据结构
//
#define MAX_STATE_NUM 64 // 状态的最大数量。
typedef struct _NFAState{
char Transform; // 状态间装换的标识，用 '$' 表示 'ε-转换'。
struct _NFAState *Next1; // 指向下一个状态。
struct _NFAState *Next2; // 指向下一个状态。
int Name; // 状态名称。
int AcceptFlag; // 是否为接受状态的标志，1 表示是接受状态 0 表示非接受状态。
}NFAState;
// Fragment 结构是一个 NFA 的片段
typedef struct _NFAFragment{
NFAState *StartState; // 开始状态。
NFAState *AcceptState; // 接受状态。
}NFAFragment;
// 转换
typedef struct _Transform{
char TransformChar; // 状态之间的转换标识符。
int DFAStateIndex; // DFA 状态在数组中的下标。
NFAState* NFAlist[MAX_STATE_NUM];// NFA 状态集合。
int NFAStateCount; // 状态集合计数。
struct _Transform* NextTrans; // 指向下一个转换。
}Transform;
// DFA 状态
typedef struct _DFAState{
NFAState* NFAlist[MAX_STATE_NUM];// NFA 状态集合。
int NFAStateCount; // 状态集合计数。
Transform* firstTran; // 指向第一个转换。
}DFAState;
// DFA
typedef struct DFA{
DFAState* DFAlist[MAX_STATE_NUM]; // DFA 状态集合。
int length; // 状态集合计数。
}DFA;
//
// 在此处声明函数
//
void Closure(NFAState* State, NFAState** StateArray, int* Count);
DFAState* CreateDFAState(Transform* pTransform);
Transform* CreateDFATransform(char TransformChar, NFAState** NFAStateArray, int Count);
int NFAStateIsSubset(DFA* pDFA, Transform* pTransform);
Transform* IsTransformExist(DFAState* pDFAState, char TransformChar);
void AddNFAStateArrayToTransform(NFAState** NFAStateArray, int Count, Transform* pTransform);
DFA* post2dfa(DFA* pDFA, char *postfix);
//
// 在此声明全局变量
//
extern const char VoidTrans;
extern NFAState* Start;
#endif /* _NFATODFA_H_ */
NFAToDFA.puo 0 → 100644
浏览文件 @ 5110454a
添加文件
PostToNFA.c 0 → 100644
浏览文件 @ 5110454a
#include "PostToNFA.h"
#include "NFAFragmentStack.h"
NFAFragmentStack FragmentStack;
/*
功能：
初始化一个 NFA 状态。
返回值：
状态结构体指针。
*/
int nstate = 1;
NFAState* CreateNFAState()
{
NFAState* s = (NFAState*)malloc(sizeof(NFAState));
s->Name = nstate++;
s->Transform = '\0';
s->Next1 = NULL;
s->Next2 = NULL;
s->AcceptFlag = 0;
return s;
}
/*
功能：
初始化 NFAFragment 结构体。
参数：
StartState -- 开始状态。
AcceptState -- 接受状态。
返回值：
NFAFragment 结构体指针。
*/
NFAFragment MakeNFAFragment(NFAState *StartState, NFAState *AcceptState)
{
NFAFragment n = {StartState, AcceptState};
return n;
}
/*
功能：
将解析树的后序序列转换为 NFA。
参数：
postfix -- 解析树的后序序列指针。
返回值：
NFA 的开始状态指针。
*/
NFAState* post2nfa(char *postfix)
{
char *p; // 游标
NFAFragment fragment1, fragment2, fm; // NFA 片段结构体变量
NFAFragment fragment = {0, 0}; // 初始化用于返回的 NFA 片段
NFAState *NewStartState, *NewAcceptState; // 开始状态和接受状态指针
//
// TODO: 在此添加代码
//
return fragment.StartState;
}
PostToNFA.h 0 → 100644
浏览文件 @ 5110454a
#ifndef _POSTTONFA_H_
#define _POSTTONFA_H_
//
// 在此处包含 C 标准库头文件
//
//
// 在此处包含其他头文件
//
#include "NFAToDFA.h"
//
// 在此处定义数据结构
//
//
// 在此处声明函数
//
NFAState* CreateNFAState();
NFAFragment MakeNFAFragment(NFAState *StartState, NFAState *AcceptState);
NFAState* post2nfa(char *postfix);
//
// 在此声明全局变量
//
#endif /* _POSTTONFA_H_ */
RegexpToPost.c 0 → 100644
浏览文件 @ 5110454a
#include "RegexpToPost.h"
/*
功能：
将输入的正则表达式字符串转换成解析树的后续遍历序列。
参数：
re -- 正则表达式指针。
返回值：
解析树的后续遍历序列数组指针。
*/
char* re2post(char *re)
{
int nalt; // 表示解析到这个字符为止，已经有多少个分支结构
int natom; // 表示解析到这个字符为止，已经有多少个原子结构
static char buf[8000];
char *dst;
struct {
int nalt;
int natom;
} paren[100], *p;
p = paren;
dst = buf;
nalt = 0;
natom = 0;
if(strlen(re) >= sizeof buf/2)
return NULL;
for(; *re; re++){
switch(*re){
case '(':
if(natom > 1)
{
--natom;
*dst++ = '.';
}
if(p >= paren+100)
return NULL;
p->nalt = nalt;
p->natom = natom;
p++;
nalt = 0;
natom = 0;
break;
case '|':
if(natom == 0)
return NULL;
while(--natom > 0)
*dst++ = '.';
nalt++;
break;
case ')':
if(p == paren)
return NULL;
if(natom == 0)
return NULL;
while(--natom > 0)
*dst++ = '.';
for(; nalt > 0; nalt--)
*dst++ = '|';
--p;
nalt = p->nalt;
natom = p->natom;
natom++;
break;
case '*':
case '+':
case '?':
if(natom == 0)
return NULL;
*dst++ = *re;
break;
default:
if(natom > 1)
{
--natom;
*dst++ = '.';
}
*dst++ = *re;
natom++;
break;
}
}
if(p != paren)
return NULL;
while(--natom > 0)
*dst++ = '.';
for(; nalt > 0; nalt--)
*dst++ = '|';
*dst = 0;
return buf;
}
RegexpToPost.h 0 → 100644
浏览文件 @ 5110454a
#ifndef _REGEXPTOPOST_H_
#define _REGEXPTOPOST_H_
//
// 在此处包含 C 标准库头文件
//
//
// 在此处包含其他头文件
//
#include "NFAToDFA.h"
//
// 在此处定义数据结构
//
//
// 在此处声明函数
//
char* re2post(char *re);
#endif /* _REGEXPTOPOST_H_ */
main.c 0 → 100644
浏览文件 @ 5110454a
#include "NFAToDFA.h"
#include "RegexpToPost.h"
#include "PostToNFA.h"
#include "NFAStateStack.h"
#include "NFAFragmentStack.h"
NFAFragmentStack FragmentStack; // 栈。用于储存 NFA 片段
NFAStateStack StateStack; // 栈。用于储存 NFA 状态
const char VoidTrans = '$'; // 表示空转换
char* regexp = "a(a|1)*"; // 例 1
// char* regexp = "(aa|b)*a(a|bb)*"; // 例 2
// char* regexp = "(a|b)*a(a|b)?"; // 例 3
int main(int argc, char **argv)
{
char *post;
DFA* dfa = (DFA*)malloc(sizeof(DFA));
dfa->length = 0;
//
// 初始化栈
//
InitNFAFragmentStack(&FragmentStack);
//
// 调用 re2post 函数将正则表达式字符串转换成解析树的后序遍历序列
//
post = re2post(regexp);
//
// 调用 post2dfa 函数将解析树的后序遍历序列转换为 DFA
//
dfa = post2dfa(dfa, post);
return 0;
}
/*
功能：
创建一个 DFA 状态的转换。
参数：
TransformChar -- 转换符号。
NFAStateArray -- NFA 状态指针数组。
Count -- 数组元素个数。
返回值：
Transform 结构体指针。
*/
Transform* CreateDFATransform(char TransformChar, NFAState** NFAStateArray, int Count)
{
int i;
Transform* pTransform = (Transform*)malloc(sizeof(Transform));
for(i=0; i<Count; i++)
pTransform->NFAlist[i] = NFAStateArray[i];
pTransform->NFAStateCount = Count;
pTransform->TransformChar = TransformChar;
pTransform->DFAStateIndex = -1;
pTransform->NextTrans = NULL;
return pTransform;
}
/*
功能：
创建一个 DFA 状态。
参数：
pTransform -- DFA 状态转换指针。
返回值：
DFAState 结构体指针。
*/
DFAState* CreateDFAState(Transform* pTransform)
{
int i;
DFAState* pDFAState = (DFAState*)malloc(sizeof(DFAState));
for(i=0; i<pTransform->NFAStateCount; i++)
pDFAState->NFAlist[i] = pTransform->NFAlist[i];
pDFAState->NFAStateCount = pTransform->NFAStateCount;
pDFAState->firstTran = NULL;
return pDFAState;
}
/*
功能：
判断一个转换中的 NFA 状态集合是否为某一个 DFA 状态中 NFA 状态集合的子集。
参数：
pDFA -- DFA 指针。
pTransform -- DFA 状态转换指针。
返回值：
如果存在返回 DFA 状态下标，不存在返回 -1。
*/
int NFAStateIsSubset(DFA* pDFA, Transform* pTransform)
{
//
// TODO: 在此添加代码
//
}
/*
功能：
判断某个 DFA 状态的转换链表中是否已经存在一个字符的转换。
参数：
pDFAState -- DFAState 指针。
TransformChar -- 转换标识符。
返回值：
Transform 结构体指针。
*/
Transform* IsTransformExist(DFAState* pDFAState, char TransformChar)
{
//
// TODO: 在此添加代码
//
}
/*
功能：
将一个 NFA 集合合并到一个 DFA 转换中的 NFA 集合中。
注意，合并后的 NFA 集合中不应有重复的 NFA 状态。
参数：
NFAStateArray -- NFA 状态指针数组，即待加入的 NFA 集合。
Count -- 待加入的 NFA 集合中元素个数。
pTransform -- 转换指针。
*/
void AddNFAStateArrayToTransform(NFAState** NFAStateArray, int Count, Transform* pTransform)
{
//
// TODO: 在此添加代码
//
}
/*
功能：
使用二叉树的先序遍历算法求一个 NFA 状态的ε-闭包。
参数：
State -- NFA 状态指针。从此 NFA 状态开始求ε-闭包。
StateArray -- NFA 状态指针数组。用于返回ε-闭包。
Count -- 元素个数。 用于返回ε-闭包中 NFA 状态的个数。
*/
void Closure(NFAState* State, NFAState** StateArray, int* Count)
{
InitNFAStateStack(&StateStack); // 调用 InitNFAStateStack 函数初始化栈
//
// TODO: 在此添加代码
//
}
/*
功能：
将解析树的后序遍历序列转换为 DFA。
参数：
pDFA -- DFA 指针。
postfix -- 正则表达式的解析树后序遍历序列。
返回值：
DFA 指针。
*/
NFAState* Start = NULL;
DFA* post2dfa(DFA* pDFA, char *postfix)
{
int i, j; // 游标
Transform* pTFCursor; // 转换指针
NFAState* NFAStateArray[MAX_STATE_NUM]; // NFA 状态指针数组。用于保存ε-闭包
int Count = 0; // ε-闭包中元素个数
//
// 调用 post2nfa 函数将解析树的后序遍历序列转换为 NFA 并返回开始状态
//
Start = post2nfa(postfix);
//
// TODO: 在此添加代码
//
return pDFA;
}
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论