语义分析

最新推荐文章于 2024-01-09 16:31:16 发布
最新推荐文章于 2024-01-09 16:31:16 发布
阅读量3.2k 收藏 1
点赞数
分类专栏： 编译原理 文章标签： tree token integer semantic string 语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tm_wb/article/details/1955386
版权
 
语义分析
       进行语法分析后正确的源代码只能证明是语法方面正确的, 但是语言还有许多语义上的要求和规矩. 语义分析就是基于整个源代码的上下文的分析. <<编译原理与实践>>中对TINY语言的语义规定很简单. 因为TINY中没有声明, 也没有作用域的规定, 表达式的类型只有两种整型和布尔型, 所以整个TINY的语义分析主要集中在对表达式的类型检查上. 而这个检查也是十分简单的, 只有四条规则:
       if 后面的表达式要求为布尔型
       until 后面的表达式要求为布尔型
       write 中的表达式要求为整型
       赋值语句中的表达式要求为整型
 
一 语义分析程序在编译器中的位置
       不同的编译器中语义分析程序的实现不同, 语义分析程序可以和语法分析程序整合到一起实现一遍编译, 也可以在语法分析程序生成语法树后对语法树进行单独的处理如图:

二 语法直到定义和属性.
       语义分析的根本是对语言的各个元素的属性的合理性的分析. 这个属性就是语言规定的语义如TINY中if后面的表达式一定要求是布尔类型等. 有时候语言符合语法的规定但是不符合语义的规定如TINY中:
       if x + 2 then
              …
       end
这里x + 2是符合语法的规定的但是它的类型是整型不符合上面提到的语义的规定, 语义分析就是要对这种情况进行分析.
       语义是使用属性来描述的, 语言的元素都是在语法中描述的, 所以这个语义又与语法相关, 是根据语法来制定的. 如TINY中描述上面语义的属性定义:
9)IF-STMT-> if EXP then STMT-SEQUENCE end
{
if EXP.type <> bool or STMT-SEQUENCE.type = error then
    IF-STMT.type = error
else
    IF-STMT.type = void
end
}
10)IF-STMT-> if EXP then STMT-SEQUENCT else STMT-SEQUENCE end
{
if EXP.type <> bool or STMT-SEQUENCE1.type = error or STMT-SEQUENCE2.type = error then
    IF-STMT.type = error
else
    IF-STMT.type = void
end
}
这里{}中的部分就是语义的描述(其中使用的如if <> 等伪代码的描述). 这里只规定的TINY的语法元素只有一种名为type的属性, 它表示这个表达式的属性或者是integer或者是void或者是bool或者是error.
       上面的描述都说明了当if语句中的EXP不是bool类型或者if语句其中的语句序列的属性错误(属性为error)时if语句的属性也是错误的.要不然if语句的属性就是空(void). 这个描述中if的语句都是依赖于它的子表达式EXP和STMT-SEQUENCE的属性, 这种属性是综合属性. 还有一种属性称为继承属性, 当一个产生式中的子表达式中一个属性依赖于这个产生式的属性或者是依赖于其前面的表达式的属性这要的属性是继承属性. 如假设
STMT-SEQUENCE中有一个属性x依赖于IF-STMT某种属性a或者是EXP的某种属性b
如:
9)IF-STMT-> if EXP then STMT-SEQUENCE end
{
STMT-SEQUENCE.x = attr0(IF-STMT.a)
或
STMT-SEQUENCE.x = attr1(EXP.b)
}
求出这个属性前必须已知IF-STMT.a或者EXP.b.
 
三 语义分析
       语法分析分为自顶向下和自底向上的分析, 语法元素的属性也分为继承属性和综合属性, 在自顶向下的语法分析中求出继承属性是十分容易的, 但是求出综合属性很困难. 在自底向上的语法分析中求出综合属性很容易但是求出继承属性却很困难. 龙书中主要讲的就是在语法分析的同时进行语义分析的方法. 包括在自顶向下语法分析中求出继承和综合属性和在自底向上语法分析中求出继承和综合属性的算法.
       还有的时候继承属性和综合属性之间有依赖关系, 这种情况下是不能通过一遍编译求出所有属性的. 必须通过对语法树的多遍扫描来求出所有的属性(这里有一个属性求解的拓扑排序).
       将语法分析与语义分析分开进行的模型如上图中的第二幅图, 语义分析程序以语法分析生成的语法树为输入通过对语法树的遍历来求出继承属性和综合属性. 在就继承属性时要对树进行前序遍历, 在求综合属性时要对树进行后序遍历.
四 代码
       TINY的语义及其简单:
       if 后面的表达式要求为布尔型
       until 后面的表达式要求为布尔型
       write 中的表达式要求为整型
       赋值语句中的表达式要求为整型
按照上面的规则定义属性:
0)PROGRAM'-> PROGRAM
{PROGRAM'.type = PROGRAM.tpye}
1)PROGRAM-> STMT-SEQUENCE
{PROGRAM.type = STMT-SEQUENCE.tpye}
2)STMT-SEQUENCE-> STMT-SEQUENCE ; STATEMENT
{
if STMT-SEQUENCE1.type = error or STATEMENT.type = error then
    STMT-SEQUENCE0.type = error
else
    STMT-SEQUENC0.type = void
end
}
3)STMT-SEQUENCE-> STATEMENT
{STMT-SEQUENCE.type = STATEMENT.type}
4)STATEMENT-> IF-STMT
{STATEMENT.type = IF-STMT.type}
5)STATEMENT-> REPEAT-STMT
{STATEMENT.type = REPEAT-STMT.type}
6)STATEMENT-> ASSIGN-STMT
{STATEMENT.type = ASSIGN-STMT}
7)STATEMENT-> READ-STMT
{STATEMENT.type = READ-STMT.type}
8)STATEMENT-> WRITE-STMT
{STATEMENT.type = WRITE-STMT.type}
9)IF-STMT-> if EXP then STMT-SEQUENCE end
{
if EXP.type <> bool or STMT-SEQUENCE.type = error then
    IF-STMT.type = error
else
    IF-STMT.type = void
end
}
10)IF-STMT-> if EXP then STMT-SEQUENCT else STMT-SEQUENCE end
{
if EXP.type <> bool or STMT-SEQUENCE1.type = error or STMT-SEQUENCE2.type = error then
    IF-STMT.type = error
else
    IF-STMT.type = void
end
}
11)REPEAT-STMT-> repeat STMT-SEQUENCE until EXP
{
if STMT-SEQUENCE.type = error or EXP.type <> bool then
    REPEAT-STMT.type = error
else
    REPEAT-STMT.type = void
end
}
12)ASSIGN-STMT-> identifier := EXP
{
if EXP.type = bool then
    ASSIGN-STMT.type = error
else
    ASSIGN-STMT.type = void
end
}
13)READ-STMT-> read identifier
{READ-STMT.type = void}
14)WRITE-STMT-> write EXP
{
if EXP.type = bool then
    WRITE-STMT.type = error
else
    WRITE-STMT.type = void
end
}
15)EXP-> SIMPLE-EXP COMPARISON-OP SIMPLE-EXP
{
if SIMPLE-EXP1.type = error or COMPARISON-OP.type = error or SIMPLE-EXP.type = error then
    EXP.type = error
else
    EXP.type = bool
end
}
16)EXP-> SIMPLE-EXP
{EXP.type = SIMPLE-EXP.type}
17)COMPARISON-OP-> <
{COMPARISON-OP.type = bool}
18)COMPARISON-OP-> =
{COMPARISON-OP.type = bool}
19)SIMPLE-EXP-> SIMPLE-EXP ADDOP TERM
{
if SIMPALE-EXP1.type = error or ADDOP.type = error or TERM.type = error then
    SIMPLE-EXP0.type = error
else
    SIMPLE-EXP0.type = integer
end
}
20)SIMPLE-EXP-> TERM
{SIMPLE-EXP.type = TERM.type}
21)ADDOP-> +
{ADDOP.type = integer}
22)ADDOP-> -
{ADDOP.type = integer}
23)TERM-> TERM MULOP FACTOR
{
if TERM1.type = error or MULOP.type = error or FACTOR.type = error then
    TERM0.type = error
else
    TERM0.type = integer
}
24)TERM-> FACTOR
{TERM.type = FACTOR.type}
25)MULOP-> *
{MULOP.type = integer}
26)MULOP-> /
{MULOP.type = integer}
27)FACTOR-> (EXP)
{FACTOR.type = EXP.type}
28)FACTOR-> number
{FACTOR.type = integer}
29)FACTOR-> identifier
{FACTOR.type = integer}
 
TINY的语义属性中只有一个type属性, 它是综合属性, 采用一遍编译的方法将语义分析程序加入到前面的SLR语法分析程序中:
TreeNode* parse_slr(void)
{
    int          count          = 0;
    int          i          = 0;
    TreeNode*     tree     = NULL;
    TreeNode*     tree_temp   = NULL;
    TokenType     bnf;
    TokenType     status_bnf;
    TokenType     token;
    TokenType     oper;
    TokenType     nes;
 
    init_slr_stack();
    init_tree_node_stack();
   
    token = get_token();
    oper = action(stack_top(), token, &status_bnf);
   
    while(oper != ACC)
    {
#ifdef TRACE_SLR_STACK
       trace_stack();
#endif
      
       switch(oper)
       {
       case MOVE:
           push(token);
           push(status_bnf);
 
           /* create id, num, comparison-op, mulop, addop node */
           switch(token)
           {
           case ID:
              tree = new_exp_node(KIND_ID);
              tree->attr.name = copy_string(token_string);
              tree->type = KIND_INT;
              child_stack_push(tree);
              break;
           case NUM:
              tree = new_exp_node(KIND_CONST);
              tree->attr.val = atoi(token_string);
              tree->type = KIND_INT;
              child_stack_push(tree);
              break;
           case LT:
           case EQ:
              tree = new_exp_node(KIND_OP);
              tree->attr.op = token;
              tree->type = KIND_BOOL;
              child_stack_push(tree);
              break;
           case PLUS:
           case MINUS:
           case MULT:
           case DIV:
              tree = new_exp_node(KIND_OP);
              tree->attr.op = token;
              tree->type = KIND_INT;
              child_stack_push(tree);
              break;
           default:
              break;
           }
          
           token = get_token();
           break;
       case MERGER:
           bnf = status_bnf;
           nes = merger(status_bnf, &count);
           for(i = 0; i < 2*count; i++)
              pop();
           status_bnf = go_to(stack_top(), nes);
           push(nes);
           push(status_bnf);
 
           /* create stmt tree node */
           switch(bnf)
           {
           /* TERM-> TERM MULOP FACTOR */
           case BNF23:
           /* SIMPLE-EXP-> SIMPLE-EXP ADDOP TERM */
           case BNF19:
           /* EXP-> SIMPLE-EXP COMPARISON-OP SIMPLE-EXP */
           case BNF15:
              tree_temp = child_stack_pop();
              tree = child_stack_pop();
              tree->child[1] = tree_temp;
              tree->child[0] = child_stack_pop();
              if((tree->child[0]->type == KIND_ERROR) ||
                 (tree->child[1]->type == KIND_ERROR))
                 tree->type = KIND_ERROR;
              child_stack_push(tree);
              break;
           /* WRITE-STMT-> write EXP */
           case BNF14:
              tree = new_stmt_node(KIND_WRITE);
              tree->child[0] = child_stack_pop();
              if(tree->child[0]->type == KIND_INT)
                  tree->type = KIND_VOID;
              else
              {
                  tree->type = KIND_ERROR;
                  slr_error(E5003, token);
              }
              child_stack_push(tree);
              break;
           /* READ-STMT-> read identifier */
           case BNF13:
              tree = new_stmt_node(KIND_READ);
              tree_temp = child_stack_pop();
              tree->attr.name = copy_string(tree_temp->attr.name);
              tree->type = KIND_VOID;
              destroy_tree_node(tree_temp);
              child_stack_push(tree);
              break;
           /* ASSIGN-STMT-> identifier := EXP */
           case BNF12:
              tree = new_stmt_node(KIND_ASSIGN);
              tree->child[0] = child_stack_pop();
              tree_temp = child_stack_pop();
              tree->attr.name = copy_string(tree_temp->attr.name);
              if(tree->child[0]->type == KIND_INT)
                  tree->type = KIND_VOID;
              else
              {
                  tree->type = KIND_ERROR;
                  slr_error(E5004, token);
              }
              destroy_tree_node(tree_temp);
              child_stack_push(tree);
              break;
           /* REPEAT-STMT-> repeat STMT-SEQUENCE until EXP */
           case BNF11:
              tree = new_stmt_node(KIND_REPEAT);
              tree->child[1] = child_stack_pop();
              tree->child[0] = child_stack_pop();
              if(tree->child[1]->type != KIND_BOOL)
              {
                  tree->type = KIND_ERROR;
                  slr_error(E5002, token);
              }
              else
                  tree->type = KIND_VOID;
              child_stack_push(tree);
              break;
           /* IF-STMT-> if EXP then STMT-SEQUENCE else STMT-SEQUENCE end */
           case BNF10:
              tree = new_stmt_node(KIND_IF);
              tree->child[2] = child_stack_pop();
              tree->child[1] = child_stack_pop();
              tree->child[0] = child_stack_pop();
              if(tree->child[0]->type != KIND_BOOL)
              {
                  tree->type = KIND_ERROR;
                  slr_error(E5001, token);
              }
              else
                  tree->type = KIND_VOID;
              child_stack_push(tree);
              break;
           /* IF-STMT-> if EXP then STMT-SEQUENCE end */
           case BNF9:
              tree = new_stmt_node(KIND_IF);
              tree->child[1] = child_stack_pop();
              tree->child[0] = child_stack_pop();
              if(tree->child[0]->type != KIND_BOOL)
              {
                  tree->type = KIND_ERROR;
                  slr_error(E5001, token);
              }
              else
                  tree->type = KIND_VOID;
              child_stack_push(tree);
              break;
           /* STMT-SEQUENCE-> STMT-SEQUENCE ; STATEMENT */
           case BNF2:
              tree_temp = child_stack_pop();
              tree = child_stack_top();
              while(tree->sibling != NULL)
                  tree = tree->sibling;
              tree->sibling = tree_temp;
              tree->type = KIND_VOID;
              break;
           default:
              break;          
           }
          
           break;
       default:
           token = slr_error(oper, token);
           break;
       }
 
       oper = action(stack_top(), token, &status_bnf);
    }
 
    tree = child_stack_pop();
    return tree;
}
 
其中对type属性的操作就是对属性的计算, 这里又加入了一些新的错误类型和新的错误处理程序:
 
    case E5001:
       fprintf(stderr, "semantic error(E5001) at line %d: "
                     "expression type after keyword /"if/" must be boolean./n",
                     line_no);
       break;
    case E5002:
       fprintf(stderr, "semantic error(E5002) at line %d: "
                     "expression type after keyword /"until/" must be boolean./n",
                     line_no);
       break;
    case E5003:
       fprintf(stderr, "semantic error(E5003) at line %d: "
                     "expression type after keyword /"write/" must be integer./n",
                     line_no);
       break;
    case E5004:
       fprintf(stderr, "semantic error(E5004) at line %d: "
                     "expression type in assign statement must be integer./n",
                     line_no);
 
这是新加入到slr_error中的代码, 只是输出错误信息, 并不进行任何错误处理.

 

tm_wb
关注
专栏目录
语义分析代码
01-11
1. 掌握自顶向下语义分析中语义子程序的添加过程； 2. 掌握“拉链”、“回填”操作的原理及实现； 3. 根据 MiniC 的上下文无关文法，对赋值语句、算术表达式、关系表达式、if-else 语句、while 语句、布尔表达式...
自然语言处理NLP（10）——语义分析
热门推荐
echoKangYL的博客
09-24 5万+
在上一部分中，我们介绍了句法分析中的局部句法分析以及依存关系分析（自然语言处理NLP（9）——句法分析c：局部句法分析、依存关系分析），至此，繁复冗长的句法分析部分就结束了。 在这一部分中，我们将要介绍NLP领域的一个重要问题：语义分析。 语义分析分为两个部分：词汇级语义分析以及句子级语义分析。 这也就是为什么在词法分析和句法分析之后，我们要介绍的是语义分析而不是篇章分析的原因。 【一】词汇级语义...
语义分析(一)
懒猫的脚印
11-04 6816
语义分析一般是和语法分析组合在一起执行的，语法分析完成前一步语法树分析的构建（调用某个产生式完成一步规约，形成当前的树节点），然后语义分析便接着调用相应产生式配备的语义动作或子程序，完成属性文法所要求的语义动作（比如类型转换或生成中间代码）。所以对于属性文法而言，属性的加工和使用过程便是语义处理的意义。 ...
6. 语义分析
weixin_45360119的博客
01-13 2862
语义分析 语义分析也称为类型检查，上下文相关分析 负责检查程序（抽象语法树）的上下文相关的属性 这是具体语言相关的，典型的情况包括 变量在使用前先进行声明 每个表达式都有合适的类型 函数调用和函数的定义一致 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YX2SxtEw-1642042136401)(…/picture/12.png)] 符号表 用来存储程序中的符号（标识符）相关属性信息，是进行上下文语义合法性检查的依据。 类型 作用域 访问控制信息
语义解析(一) —— 概述（数据和模型简介）
12-25 6745
一、简介 语义解析是近几年发展起来的一个NLP的分支，主要目的是将自然语言的文本描述，自动转成机器语言（SQL）语句。也称Text-to-SQL，nl2SQL等。随着知识图谱的发展，也逐渐孵化出很多nl2Cypher算法。 NL2SQL的历史悠久，早在1973年，Woods等人就开发了一个名为LUNAR的系统，可以回答关于从月球带回的岩石样本的问题。到了1978年，Hendrix设计了一个连接美国海军舰艇信息数据库的自然语言接口，名为LIFER/LADDER。这些系统仅仅支持特定数据库的单表操作，受..
自然语言处理（NLP）语义分析：“词汇级”语义分析【词义消歧、词义表示和学习】、“句子级”语义分析【浅层语义分析（语义角色标注）、深层语义分析】
u013250861的博客
01-10 4824
语义分析(Semantic Analysis)：指运用各种机器学习方法，学习与理解一段文本所表示的语义内容。 一段文本通常由词、句子和段落来构成，根据理解对象的语言单位不同，语义分析又可进一步分解为： - 词汇级语义分析； - 句子级语义分析； - 篇章级语义分析； 一般来说： - 词汇级语 义分析关注的是如何获取或区别单词的语义； - 句子级语义分析则试图分析整个句子所表达的 语义， - 篇章语义分析旨在研究自然语言文本的内在结构并理解文本单元(可以是句子从句 或段落)间的语义关系。
语义分析报告
01-03
语义分析是编译过程的一个逻辑阶段， 语义分析的任务是对结构上正确的源程序进行上下文有关性质的审查，进行类型审查。语义分析是审查源程序有误语义错误，为代码生成阶段收集类型信息。比如语义分析的一个工作是...
实验三_编译原理语义分析_语义分析_sectionnef_
09-30
在这个实验中，“实验三_编译原理语义分析_语义分析_sectionnef_”主要关注的是如何利用Java语言实现编译器的语义分析部分。 1. **编译原理**：编译原理是一门研究编程语言如何转换为另一种语言的学科，通常涉及...
潜在语义分析
01-03
潜在语义分析（Latent Semantic Analysis）或者潜在语义索引（Latent Semantic Index），是1988年S.T. Dumais等人提出的一种新的信息检索代数模型，是用于知识获取和展示的计算理论和方法，它使用统计计算的方法对...
语义分析实验(java版）
12-16
语义分析是编译器设计中的关键步骤，它在词法分析和语法分析之后进行，目的是检查源程序的语义是否正确，并将其转化为计算机可理解的形式。在这个“语义分析实验（Java版）”中，我们将重点探讨如何利用Java语言实现...
【NLP】语义分析
拟禾的个人技术博客
04-19 4370
自然语言处理中的语义分析
四、语义分析
Shanhj的博客
05-25 4605
语义分析
编译原理 语义分析
qq_40427276的博客
01-08 7374
文章目录
自然语言处理中的语义分析：理解人类语言的关键
程序员光剑
01-08 1190
1.背景介绍 自然语言处理(NLP)是人工智能领域的一个重要分支，其主要目标是让计算机能够理解、生成和处理人类语言。语义分析是NLP中的一个关键技术，它涉及到文本的语义解析和理解。语义分析的核心是将语言表面结构(词汇、句法等)映射到语义结构上，以便计算机能够理解人类语言的真实含义。 在过去的几十年里，语义分析的研究取得了显著的进展。早期的方法主要基于规则和知识库，但这些方法的泛化能力有限。随着...
自然语言处理（NLP）语义分析--文本分类、情感分析、意图识别
张伟的专栏
06-09 2万+
文章目录 第一部分：文本分类 一、文本预处理（解决特征空间高维性、语义相关性和特征分布稀疏） 二、文本特征提取 三、分类模型 第二部分：情感分析 一、概述 二、基于情感词典的情感分类方法 三、基于机器学习的情感分类方法 第三部分：意图识别 一、概述 二、意图识别的基本方法 三、意图识别的难点 转载来源：https://blog.csdn.net/weixin_41657760/article/details/93163519 第一部分：文.
语义分析的一些方法(一)(转)
soledede
02-11 2541
  语义分析，本文指运用各种机器学习方法，挖掘与学习文本、图片等的深层次概念。wikipedia上的解释：In machine learning, semantic analysis of a corpus is the task of building structures that approximate concepts from a large set of documents(or ...
自然语言处理中的语义分析：技术与实践
程序员光剑
12-31 1224
1.背景介绍 自然语言处理(NLP)是人工智能领域的一个重要分支，其主要目标是让计算机能够理解、生成和处理人类语言。语义分析是NLP的一个关键技术，它涉及到文本的意义和含义的理解。在过去的几年里，语义分析技术取得了显著的进展，这主要是由于深度学习和大规模数据的应用。 本文将介绍语义分析的核心概念、算法原理、实例代码和未来趋势。我们将从以下六个方面进行讨论： 背景介绍 核心概念与联系 核心算...
语义分析基础知识
weixin_47365232的博客
06-18 1124
语义分析基础知识
语义解析：连接自然语言与机器智能的桥梁
最新发布
weixin_50804299的博客
01-09 9178
语义解析（Semantic Parsing）是自然语言处理技术的核心任务之一，涉及语言学计算语言学机器学习以及认知语言等多个学科。具体来说，语义解析技术是指将自然语言文本转化为结构化的语义表示，使得计算机能够理解和执行人类的指令。语义解析技术可以提高人机交互的效率和准确性，在自然语言处理数据分析智能客服智能家居等领域都有广泛的应用前景。特别是在大数据时代，语义解析能够帮助企业更快速地从大量的数据中获取有用的信息，从而提高决策效率。
编译原理：语义分析详解与重要性
"本资源主要介绍了编译原理中的第六章——语义分析，涵盖了语义分析的概述，符号表，符号表的局部化以及语义分析的方法。通过讲解语法与语义的区别，强调了语义分析在确保程序正确性方面的重要性，并对静态和动态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值