c語言語法分析
轉自http://blog.csdn.net/rill_zhen/article/details/7701259http://blog.csdn.net/rill_zhen/article/details/7701259
希望能幫到你
編譯原理-1-C語言的文法
編譯原理-1-C語言的文法
c語言的文法產生式：
program ->
external_declaration
| program external_declaration
external_declaration ->
function_definition
| declaration
function_definition -> type_specifier declarator compound_statement
type_specifier ->
VOID
| CHAR
| INT
| FLOAT
declarator
pointer direct_declarator
| direct_declarator
Pointer->
'*'
| '*' pointer
direct_declarator
IDENTIFIER
|direct_declarator』[『 『]』
|direct_declarator 』[』 constant_expression 』]』
| IDENTIFIER '(' parameter_list ')'
| IDENTIFIER '(' ')'
|direct_declarator『,』identifier_list
identifier_list
: IDENTIFIER
| identifier_list ',' IDENTIFIER
constant_expression->
conditional_expression
parameter_list ->
parameter_declaration
| parameter_list ',' parameter_declaration
parameter_declaration ->
declaration_specifiers IDENTIFIER
compound_statement ->
'{' '}'
| '{' statement_list '}'
| '{' declaration_list statement_list '}'
declaration_list ->
declaration
| declaration_list declaration
Declaration->
init_declarator
| init_declarator_list ',' init_declarator
init_declarator ->
declarator
| declarator '=' initializer
Initializer ->
assignment_expression
| '{' initializer_list '}'
| '{' initializer_list ',' '}'
initializer_list ->
initializer
| initializer_list ',' initializer
statement_list->
statement
| statement_list statement
Statement ->
| compound_statement
| expression_statement
| selection_statement
| iteration_statement
| jump_statement
expression_statement ->
';'
| expression ';'
selection_statement
: IF '(' expression ')' statement
| IF '(' expression ')' statement ELSE statement
iteration_statement->
WHILE '(' expression ')' statement
| FOR '(' expression_statement expression_statement ')' statement
| FOR '(' expression_statement expression_statement expression ')' statement
jump_statement
| CONTINUE ';'
| BREAK ';'
| RETURN ';'
| RETURN expression ';'
expression
: assignment_expression
| expression ',' assignment_expression
assignment_expression ->
conditional_expression
| unary_expression assignment_operator assignment_expression
conditional_expression ->
logical_or_expression
| logical_or_expression ' ' expression ':' conditional_expression
logical_or_expression ->
logical_and_expression
| logical_or_expression OR_OP logical_and_expression
logical_and_expression
: inclusive_or_expression
| logical_and_expression AND_OP inclusive_or_expression
inclusive_or_expression->
exclusive_or_expression
| inclusive_or_expression '|' exclusive_or_expression
exclusive_or_expression
: and_expression
| exclusive_or_expression '^' and_expression
and_expression
: equality_expression
| and_expression '&' equality_expression
equality_expression
: relational_expression
| equality_expression EQ_OP relational_expression
| equality_expression NE_OP relational_expression
relational_expression
: shift_expression
| relational_expression '$amp;
| relational_expression '$amp;>apos;$ shift_expression
| relational_expression LE_OP shift_expression
| relational_expression GE_OP shift_expression
shift_expression
: additive_expression
| shift_expression LEFT_OP additive_expression
| shift_expression RIGHT_OP additive_expression
additive_expression
: multiplicative_expression
| additive_expression '+' multiplicative_expression
| additive_expression '-' multiplicative_expression
multiplicative_expression
: cast_expression
| multiplicative_expression '*' cast_expression
| multiplicative_expression '/' cast_expression
| multiplicative_expression '%' cast_expression
cast_expression
: unary_expression
| '(' type_name ')' cast_expression
unary_expression
: postfix_expression
| INC_OP unary_expression
| DEC_OP unary_expression
| unary_operator cast_expression
| SIZEOF unary_expression
| SIZEOF '(' type_name ')'
postfix_expression ->
: primary_expression
| postfix_expression '[' expression ']'
| postfix_expression '(' ')'
| postfix_expression '(' argument_expression_list ')'
| postfix_expression '.' IDENTIFIER
| postfix_expression PTR_OP IDENTIFIER
| postfix_expression INC_OP
| postfix_expression DEC_OP
primary_expression ->
IDENTIFIER
| CONSTANT
| STRING_LITERAL
| '(' expression ')'
argument_expression_list
: assignment_expression
| argument_expression_list ',' assignment_expression
unary_operator
: '&'
| '*'
| '+'
| '-'
| '~'
| '!'
assignment_operator ->
'='
| MUL_ASSIGN
| DIV_ASSIGN
| MOD_ASSIGN
| ADD_ASSIGN
| SUB_ASSIGN
| LEFT_ASSIGN
| RIGHT_ASSIGN
| AND_ASSIGN
| XOR_ASSIGN
| OR_ASSIGN
storage_class_specifier ->
TYPEDEF
| EXTERN
| STATIC
| AUTO
| REGISTER
struct_or_union_specifier
: struct_or_union IDENTIFIER '{' struct_declaration_list '}'
| struct_or_union '{' struct_declaration_list '}'
| struct_or_union IDENTIFIER
struct_or_union
: STRUCT
| UNION
struct_declaration_list
: struct_declaration
| struct_declaration_list struct_declaration
struct_declaration
: specifier_qualifier_list struct_declarator_list ';'
specifier_qualifier_list ->
type_specifier specifier_qualifier_list
| type_specifier
| type_qualifier specifier_qualifier_list
| type_qualifier
struct_declarator_list ->
struct_declarator
| struct_declarator_list ',' struct_declarator
struct_declarator ->
: declarator
| ':' constant_expression
| declarator ':' constant_expression
enum_specifier ->
ENUM '{' enumerator_list '}'
| ENUM IDENTIFIER '{' enumerator_list '}'
| ENUM IDENTIFIER
enumerator_list ->
enumerator
| enumerator_list ',' enumerator
Enumerator ->
IDENTIFIER
| IDENTIFIER '=' constant_expression
type_qualifier ->
CONST
| VOLATILE
type_qualifier_list ->
type_qualifier
| type_qualifier_list type_qualifier
parameter_type_list ->
parameter_list
| parameter_list ',' ELLIPSIS
parameter_list ->
: parameter_declaration
| parameter_list ',' parameter_declaration
type_name ->
specifier_qualifier_list
| specifier_qualifier_list abstract_declarator
abstract_declarator ->
pointer
| direct_abstract_declarator
| pointer direct_abstract_declarator
direct_abstract_declarator ->
'(' abstract_declarator ')'
| '[' ']'
| '[' constant_expression ']'
| direct_abstract_declarator '[' ']'
| direct_abstract_declarator '[' constant_expression ']'
| '(' ')'
| '(' parameter_type_list ')'
| direct_abstract_declarator '(' ')'
| direct_abstract_declarator '(' parameter_type_list ')'
labeled_statement ->
IDENTIFIER ':' statement
| CASE constant_expression ':' statement
| DEFAULT ':' statement
⑵ 這里有一個c語言的語法分析程序，該怎麼使用，我想得到它的語法樹，然後在上面提取循環語句信息
在計算機科學中，抽象語法樹（abstract syntax tree或者縮寫為AST），或者語法樹（syntax tree），是源代碼的抽象語法結構的樹狀表現形式，這里特指編程語言的源代碼。樹上的每個節點都表示源代碼中的一種結構。之所以說語法是「抽象」的，是因為這里的語法並不會表示出真實語法中出現的每個細節。比如，嵌套括弧被隱含在樹的結構中，並沒有以節點的形式呈現；而類似於if-condition-then這樣的條件跳轉語句，可以使用帶有兩個分支的節點來表示。和抽象語法樹相對的是具體語法樹（concrete syntaxtree），通常稱作分析樹（parse tree）。一般的，在源代碼的翻譯和編譯過程中，語法分析器創建出分析樹。一旦AST被創建出來，在後續的處理過程中，比如語義分析階段，會添加一些信息。
⑶ c語言(m=a>b)&&(n=c>d),a=5,b=6,c=7,d=8,m=2,n=2,運算後m= ,n=
首先你應該明白運算的優先順序，包括邏輯運算與算術運算。注意，在c語言中是非0即1的思路，這里根據C語言語法分析：
a>b = 0, 後面是與運算，到此程序應該結束，表達式為0。最後結果：m=0, n=2
⑷ C語言的語法分析器
先做個LL(1)或者LALR的語法分析器，然後先把教材上的幾個LL(1)的例子調通過。然後網上有C語言子集的文法，有人做了轉成大小寫這樣的表述。通過那個的測試就差不多了。。。。其實做語法分析也沒多大用 編譯器的難點在於語法制導、代碼優化之類的，真要做C語言的完整編譯器，普通的學生都幾乎不可能實現。。。。就不多說了 你可以動手開始做了 如果你有較強的程序設計能力，做個漂亮的LR(1)分析器還是可以的，實在不會就做SLR(1)這樣的分析器，如果程序設計能力比較差，建議先做LL(1)，那個比較好做。碼字不易，望採納！
⑸ c語言的詞法分析器
任務1：識別小型語言所有單詞的詞法分析程序設計
源程序設計語言
G[<程序>]
<程序>→<變數說明><BEGIN>
<語句表>
<END>.
<變數說明>→VAR<變數表>:<類型>；|<空>
<變數表>→<變數表>,<變數>|<變數>
<類型>→INTEGER
<語句表>→<語句>
|
<語句>;<語句表>
<語句>→<賦值語句>|<條件語句>|<WHILE語句>|<復合語句>
<賦值語句>→<變數>:=<算術表達式>
<條件語句>→IF<關系表達式>THEN<語句>ELSE<語句>
<WHILE語句>→WHILE<關系表達式>DO<語句>
<復合語句>→BEGIN<語句表>END
<算術表達式>→<項>|<算術表達式>+<項>|<算術表達式>-<項>
<項>→<因式>|<項>*<因式>|<項>/<因式>
<因式>→<變數>|<整數>|(<算術表達式>)
<關系表達式>→<算術表達式><關系符><算術表達式>
<變數>→<標識符>
<標識符>→<標識符><字母>|<標識符><數字>|<字母>
<整數>→0|<非零數字><泛整數>
<泛整數>→<數字>|<數字><泛整數>|ε
<關系符>→<|<=|==|>|>=|<>
<字母>
→A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z
<非零數字>→1|2|3|4|5|6|7|8|9
<數字>→<非零數字>|0
<空>→
要求和提示：
詞法分析階段，可以打開任意位置和名稱的源文件進行詞法分析，可以進行非法字元和數字後邊跟字母的錯誤判斷，如果沒有錯誤則提示「詞法分析正確完成！」，並且可以選擇輸出token.txt（token文件）string.txt（符號表）兩個文件；
1．詞法分析程序的主要任務如下：
①
組織源程序的輸入，識別出源程序中的各個基本語法單位（也稱為單詞或語法符號），按規則轉換成二元式的形式；
②
刪除無用的空白字元、回車符、及其它非實質性符號；
③
刪除註解行；
④
為後面的語法和語義分析提供二元式鏈表；
單詞
編碼
單詞
編碼
標識符
1
<
15
正整數
2
<=
16
BEGIN
3
>
17
END
4
>=
18
IF
5
<>
19
THEN
6
==
20
ELSE
7
；
21
WHILE
8
．
22
DO
9
:=
23
INTEGER
10
，
24
+
11
(
25
-
12
）
26
*
13
/
14
1)
對標識符的長度控制在8個字元（包括8個）以內，超過的做截斷處理；
2)
數字不大於65535，否則報錯；
3)
能跳過源程序中的空白格：兩個單詞之間的任何空格，製表符，回車，換行都是白空格，除了用來分隔單詞以外，沒有意義；
4)
能跳過注釋：
a)
接連出現的/*到下一次接連出現的*/之間的任何文字都是注釋（多行）；
b)
從某行接連出現的//到該行的結尾的任何文字都是注釋（單行）。
3.怎樣編寫詞法分析程序：
1）
預處理：把源文件一個字元一個字元的讀入詞法分析程序設置的輸入字元結構體數組中（輸入緩沖區），讀入過程要刪除注釋，刪除多餘的白空格；
2）
從源程序字元數組中獲得單詞,
編碼為二元式.：
二元式採用結構體數組存儲,
把單詞類型和詞元記錄下來。
分解單詞的方法：
1）
Case多路轉換語句根據單詞的特點直接編寫；
2）
通過描述單詞的正規文法得到相應的有窮自動機，通過case多路轉換語句完成有窮自動機的處理流程。
3．編寫詞法分析程序要注意的問題：
1）
檢查詞法是否有錯誤
檢查是否有非法字元：如
@,
&,
!
檢查標志符和數字是否滿足限制條件
檢查注釋符號是否配對
2）
符分隔單詞
能夠區分兩個單詞的符號為界符
有些界符不是單詞：如白空格
有些界符僅僅用來分隔：如；
有些界符本身還是源程序不可缺少的單詞，如(,
),
+,
/,
等等
有些界符包含兩個字元：如<>,
>=等等
3）
輸出詞法錯誤
如果有錯誤，需要報告詞法錯誤的原因。並且要能夠越過錯誤，分解下一個單詞，直到源程序結束。
4）
輸出的二元式流保存在二元式結構體數組中。
⑹ c語言的詞法分析器和語法分析器有什麼區別
顧名思義，詞法分析器檢查的是詞法，語法分析器分析的是語法，什麼是詞法，什麼是語法你弄明白就知道了。
所謂詞法，源代碼由字元流組成，字元流中包括關鍵字，變數名，方法名，括弧等等符號，其中變數名要滿足不能包括標點符號，不能以數字開頭的數字與字母的字元串這個條件，對於括弧要成對出現等等，這就是詞法;
而語法，詞法沒有問題才能進入語法分析，語法就是詞排列的方法，字面意義，比如一句中文：我吃蘿卜，裡面有三個詞我 吃 蘿卜，除了「我吃蘿卜」外，這三個詞還可以組成，「蘿卜吃我」「蘿卜我吃」等，顯然按照中文文法，後面的兩句話是不對的，語法分析器就是分析類似這樣的語法的。
⑺ 編譯原理用C語言實現基於LR(1)或SLR（1）語法分析程序代碼，最好還有報告，急。。。
這個是精簡的語法分析程序，如果符合的話，hi我
給你實驗報告
#include <stdio.h>
#include<dos.h>
#include<stdlib.h>
#include<string.h>
char a[50] ,b[50];
char ch;
int n1,i1=0,n=5;
int E();int T();int E1();int T1();int F();
void main() /*遞歸分析*/
{
int f,j=0;
printf("請輸入字元串(長度<50,以#號結束）\n");
do{
scanf("%c",&ch);
a[j]=ch;
j++;
}while(ch!='#');
n1=j;
ch=b[0]=a[0];
f=E();
if (f==0) return;
if (ch=='#') printf("accept\n");
else printf("error\n");
}
int E() // E→TE'
{ int f,t;
f=T();
if (f==0) return(0);
t=E1();
if (t==0) return(0);
else return(1);
}
int T() // T→FT'
{ int f,t;
f=F();
if (f==0) return(0);
t=T1();
if (t==0) return(0);
else return(1);
}
int E1()/*E』*/ // E'→+TE'
{ int f;
if(ch=='+') {
b[i1]=ch;
ch=a[++i1];
f=T();
if (f==0) return(0);
E1();
return(1);
}
return(1);
}
int T1()/*T』*/ // T'→*FT'
{
int f,t;
if(ch=='*') {
b[i1]=ch;
ch=a[++i1];
f=F();
if (f==0) return(0);
t=T1();
if (t==0) return(0);
else return(1);}
a[i1]=ch;
return(1);
}
int F() // F→(E)
{ int f;
if(ch=='(') {
b[i1]=ch;
ch=a[++i1];
f=E();
if (f==0) return(0);
if(ch==')') {
b[i1]=ch;
ch=a[++i1];
}
else {
printf("error\n");
return(0);
}
}
else if(ch=='i') {
b[i1]=ch;
ch=a[++i1];
}
else {printf("error\n");return(0);}
return(1);
}
⑻ C語言知識總結
c語言概要
第一章、 概述
1、 c語言的基本知識
1.1、 c語言的執行步驟
編輯-程序代碼的錄入，生成源程序*.c
編譯-語法分析查錯，翻譯生成目標程序*.obj
（語法或邏輯錯誤，從第一個開始改，變數定義，語句格式，表達式格式等）
鏈接-與其他目標程序或庫鏈接裝配，生成可執行程序*.exe
執行
1.2、 main函數的基本知識
main（）函數的位置
c程序總是從main( )函數開始執行
一個c程序可以包含一個主函數，即main（）函數；也可以包含一個main()函數和若干其它函數
1.3、 c程序的結構
函數與主函數
程序由一個或多個函數組成
必須有一個且只能有一個主函數main()
程序執行從main開始，在main中結束，其他函數通過嵌套調用得以執行
程序語句
C程序由語句組成
用「；」作為語句終止符
注釋
//
或
/* */ 為注釋，不能嵌套
不產生編譯代碼
1.4、c 程序書寫的規則
習慣用小寫字母，大小寫敏感
不使用行號，無程序行概念：通常一個語句佔一行
可使用空行和空格
常用鋸齒形的書寫格式；同一層次結構的語句上下對齊。
第二章、基本數據類型與運算
2.1、c程序的數據類型
注意類型和變數含義的不同（類型是固定好的名字，變數是自己起的名字）
變數佔用的存儲空間
數據類型
基本類型：整型、字元型、浮點型（單精度型，雙精度型）
構造類型：數組類型、結構體類型
指針類型
空類型
注意基本類型賦初值的方式
基本數據類型的表示形式
整形數據
十進制：以非0數字開頭，如：123，-9，0
八進制;以0數字開頭，如：0123，067
十六進制：以0x開頭，如：0x123,0xff
實型數據
十進制：必須帶小數點，如：123.0，-9.0
指數形式;如：1.23E3，0.9e-2,5e2
字元型數據
普通字元：如：』a』,』2』,』H』,』#』
轉義字元：如：』\n』,』\167』,』\xlf,』\\』
（實現幾列的對齊：指定寬度。如%100\ 『\t』製表位）
（字元串長度。「abc\n\t\\」 strlen 6; sizeof 7）
基本數據類型的存儲長度
整型
Int 位元組數 2 位數 16 數的表示範圍 -32768—32767
Short 2 16 -32768—32767
Long 4 32 -2147483648—2147483647
實型
Float 4 32 3.4e-38---3.4e38
Double 8 64 1.7e-308---1.7e308
字元型
Char 1 8 -128----127
2.2、標識符命名規則
C語言標志符命名規則
標識符有數字，字母，下劃線組成
標識符的首字元必須為字母和下劃線
標識符不能為c語言的保留字（關鍵字）
如：auto extern sizeof float static case for struct char goto switch continue in typedef const if union default long unsigned do register void double return else short while enum signed
算術運算符 + - * / %
關系運算符 > < == >= <= !=
邏輯運算符 ！ && ||
位運算符 << >> ~ | ^ &
賦值運算符 = 及其擴展賦值運算符
條件運算符 ? :
逗號運算符 ，
指針運算符 * &
求位元組數運算符 sizeof
強制類型轉換運算符 （類型）
分量運算符 . ->
下標運算符 [ ]
其他 如函數調用運算符()
運算符的優先順序
由高到低：單目運算符，算數運算符，關系運算符，賦值運算符
說明：單目運算符：自增運算符，自減運算符，類型裝換運算符。結合方向：自右至左
如：++--I 先—i.。
算術運算 結合方向自左至右
2.3基本運算和表達式
關系表達式和邏輯表達式
(a>b)&&(x>y) (a==b)||(x==y) !=a||(a>b)
A&&b.a為0.不執行b
A||b a為1.不執行b
在 c 中邏輯運算結果：1代表「真」，0代表「假」；
判斷一個表達式是否真：0代表「假」，非0代表「真」
條件表達式 逗號表達式
如：k=5,k++
逗號值為5；k為6.
表達式1？表達式2 ：表達式3
K=5>6 ? 1 : 0
2.4、混合運算的數據類型轉換
2/3+0.5 雙精度浮點型
第三章、順序結構程序設計
3.1、c語句的分類
簡單語句
表達式語句 表達式+分號
空語句 只有分號的語句
復合語句 用花括弧將若干語句括起來
流程式控制制語句
選擇語句 if ,switch
循環語句 while, do while , for
轉移語句 break ,continue ,return goto
3.2、格式輸入函數scanf
一般形式：scanf(「格式控制字元串「，地址列表)；
使用scanf函數時，需要注意：
格式字元的個數必須與輸入項的個數相同，數據類型必須一一對應，非格式字元串（說明性的）要原封不動的輸入。
輸入實行數據時，可以不帶小數點，即按整型數據輸入
數值型數據與字元或字元串混合輸入時，需要注意輸入方式。
3.3、格式輸出函數printf
Printf（「格式控制字元串「，輸出列表）；
指定輸出格式，由格式字元串和非格式字元串兩種組成，非格式字元串照原樣輸出。
%[標志][輸出最小寬度][.精度][長度]類型
標志：- 左對齊；+ 右對齊；
%f, %d, %c, %s
3.4、其他輸入輸出函數
Putchar getchar puts gets
第四章、選擇結構程序設計
If選擇結構
單分支
If(表達式)
語句
雙分支
If(表達式)
語句1
Else
語句2
多分支
If （表達式1）
語句1
Else if（表達式2）
語句2
。。。
Else if(表達式m)
語句m
Else
語句n
Switch（表達式）
{
Case 常量表達式1：語句1；break；
Case 常量表達式2：語句2；break；
。。。
Case 常量表達式m：語句m；break;
Default:語句n；break;
}
注意break的使用
第五章、循環結構程序設計
循環三要素
初始條件 ；終止條件 ；在初始條件和終止條件間反復做某件事情（循環體）
While(表達式)
語句
Do
語句
While(表達式);
For(循環體變數賦初值；循環條件；循環變數增量)
( for( ) ; // ; 進行時間延遲。在信息交換等時用。如for(i=0,i<100) ; 互相通訊的時間延遲。 Delay )
Break語句 ：不能用於循環語句和switch語句之外的任何其他語句；跳出循環。
Continue語句 ：跳過循環體中剩餘的語句而強行執行下一次循環；跳出本次循環。
第六章、函數與編譯預處理
6.1、函數的定義和調用
類型標識符 函數名 （形式參數列表）
{ 聲明部分
語句
}
例：
Int max (int x,int y)
{int z;<br>Z=x>y?x:y;<br>Return(z);}
6.2、局部變數和全局變數
注意函數中靜態變數的定義和使用
6.3、變數的存儲類型
局部變數的存儲類型
自動變數(auto) 動態存儲
局部靜態變數（static） 靜態存儲
寄存器變數(register) 靜態存儲
全局變數的存儲類型
自動變數（auto） 動態存儲
外部變數 （extern） 靜態存儲
全局靜態變數（static ）靜態存儲
Extern 外部引用
Static 不能用extern 引用。
第七章、數組
7.1、一維數組的定義和使用
特別需要注意循環體的初值，終止條件
例：
Main()
{
Int I,a[10];
For(i=0;i<=9;i++)
A=I;
For(i=9;i>=0;i--)
Printf(「%d」,a);
}
注意下標問題
7.2、二維數組的定義和使用
二維數組的初始化
例如：
Int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
Int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
Int a[ ][4]={1,2,3,4,5,6,7,8,9,10,11,12};
Int a[ ][4]={{1,2,3,4},{5},{9,10,11,12}};
例如：int a[3][3]={{1},{2},{3}};
是對每一行的第一列元素賦值，未賦值的元素取0
7.3、字元數組和 字元串
字元串用字元數組來處理，結束標志符 『\0』
如：char c[ ]={「I am happy」};
用字元串常量使字元數組初值化
Char c[ ]={『I』,』 『,』a』,』m』,』 『,』h』,』a』,』p』,』p』,』y』,』\0』};
第八章、指針
8.1、地址和指針的概念
Int I;
Int *i_point;
8.2、指針變數和變數的地址
操作符：* &
8.3、指針和一維數組
若有定義
Int a[10];
Int *p=a;
分析下面表達式的含義：
A, &a,
*(a+i), a+I,
*(p+i), p+i
A=*(a+i)=*(P+i)
&a=a+i=p+i
8.4、指針與字元串
Main()
{
Char string[ ]=」I love china!」;
Printf(「%s\n」,string);
}
Main()
{ char *string=」I love china!」;
Printf(「%s\n」,string);
}
8.5、指針變數作為函數參數
形參的定義方式；實參的形式；參數的傳遞方式。
第九章、結構體
9.1、結構體類型和變數的定義
Struct 結構體名
{成員列表}；
Struct student
{char stuNO[8];<br>Char name[20];<br>Char sex;<br>Int age;<br>Float score;<br>Char addr[30];<br>};
Stuct student
{char stuNO[8];<br>Char name[20];<br>Char sex;<br>Int age;<br>Float score;<br>Char addr[30];<br>};
Struct student stu1, stu2;
9.2、結構體變數的引用
一般形式為：
結構體變數名.成員名
9.3、結構體數組
結構體數組 結構體數組元素.成員名
指向結構體的指針變數
（*p）.成員名
p->成員名
其他
Strcpy(字元數組1，字元串2)
Strcat(字元數組1，字元數組2)
Strcmp(字元串1，字元串2)
Strlen（字元數組）
⑼ 急（高懸賞 幫個忙） 求編譯原理課程設計---c語言實現c-的語法分析，在線等
新建一個文本文檔在你工程目錄下，名字起為"輸入.txt",裡面的內容可以為
begin a:=1+7*(6+3);b:=1end#
輸出是在"輸出.txt"中查看，以下為輸出情況：
詞法分析結果如下:
(1, begin)
(10, a)
(18, :=)
(11, 1)
(13, +)
(11, 7)
(15, *)
(27, ()
(11, 6)
(13, +)
(11, 3)
(28, ))
(26, ;)
(10, b)
(18, :=)
(11, 1)
(6, end)
(0, #)
語法分析結果如下:（以四元式形式輸出）
( +, 6, 3, t1)
( *, 7, t1, t2)
( +, 1, t2, t3)
( =, t3, __, a)
( =, 1, __, b)
//提供一個編譯原理的語義分析程序 你可以直接復制 用TC進行調試
#include "stdio.h"
#include "string.h"
#include <malloc.h>
#include <conio.h>
#include "stdlib.h"
char prog[100],token[8],ch;
char *rwtab[6]={"begin","if","then","while","do","end"};
int syn,p,m,n,sum,q;
int kk;
//四元式表的結構如下：
struct
{
char result1[8];
char ag11[8];
char op1[8];
char ag21[8];
}quad[20];
char *factor();
char *expression();
int yucu();
char *term();
int statement();
int lrparser();
char *newtemp();
void scaner();
void emit(char *result,char *ag1,char *op,char *ag2);
void main()
{
FILE *fp1,*fp2;
if((fp1=fopen("輸入.txt","rt"))==NULL)
{
printf("Cannot open 輸入.txt\n");
getch();
exit(1);
}
if((fp2=fopen("輸出.txt","wt+"))==NULL)
{
printf("Cannot create 輸出.txt FILE.strike any key exit");
getch();
exit(1);
}
int j;
q=p=kk=0;
p=0;
//printf("Please Input a String(end with '#'):\n");
while(ch!='#')
{
ch = fgetc(fp1);
if(ch == EOF)
{
printf("文件為空，請檢查後再嘗試!");
return ;
}
prog[p++]=ch;
}
if(prog[p]=='#')
{
printf("輸入的待分析的串不是以'#'結尾,請修改之後再嘗試!\n");
return;
}
p=0;
char buffer1[200] = {0};
sprintf(buffer1,"詞法分析結果如下:\n");
fputs(buffer1,fp2);
//printf("詞法分析結果如下:\n");
do
{
scaner();
switch(syn)
{
case 11:
//printf("(%d,%d)\n",syn,sum);
sprintf(buffer1,"(%d, %d) \n",syn,sum);
fputs(buffer1,fp2);
break;
default:
//printf("(%d,%s)\n",syn,token);
sprintf(buffer1,"(%d, %s)\n",syn,token);
fputs(buffer1,fp2);
break;
}
}while(syn!=0);
printf("\n");
p=0;
char buffer[200]={0};
sprintf(buffer,"語法分析結果如下:（以四元式形式輸出）\n");
fputs(buffer,fp2);
//printf("語法分析結果如下:（以四元式形式輸出）\n");
scaner();//掃描函數
lrparser();
if(q>19)
printf(" to long sentense!\n");
else
{
for (j=0;j<q;j++)
{
//printf("( %s, %s, %s, %s) \n\n",quad[j].op1,quad[j].ag11,quad[j].ag21,quad[j].result1);
sprintf(buffer,"( %s, %s, %s, %s) \n\n",quad[j].op1,quad[j].ag11,quad[j].ag21,quad[j].result1);
fputs(buffer,fp2);
}
}
printf("已把相應的詞法和語法的結果保存到相應的文件中，請查閱!\n");
fclose(fp1);
fclose(fp2);
}
int lrparser()
{
int schain=0;
kk=0;
if (syn==1) //得到begin
{
scaner();//掃描下個字元
schain=yucu();
if(syn==6)//得到end
{
scaner();//掃描下個字元
if((syn==0)&&(kk==0)) //得到#
printf("Success!\n");
}
else
{
if(kk!=1)
printf("short of 'end' !\n");
kk=1;
getch();
exit(0);
}
}
else
{
printf("short of 'begin' !\n");
kk=1;
getch();
exit(0);
}
return (schain);
}
int yucu()
{
int schain=0;
schain=statement();
while(syn==26)
{
scaner();
schain=statement();
}
return (schain);
}
int statement()
{
char tt[8],eplace[8];
int schain=0;
if (syn==10)
{
strcpy(tt,token); //tt中保存的是第一個字元
scaner();
if(syn==18) //檢測到=號
{
scaner();
strcpy(eplace,expression());
emit(tt,eplace,"=","__");
schain=0;
}
else
{
printf("short of sign ':=' !\n");
kk=1;
getch();
exit(0);
}
return (schain);
}
}
char *expression()
{
char *tp,*ep2,*eplace,*tt;
tp=(char *)malloc(12);
ep2=(char *)malloc(12);
eplace=(char *)malloc(12);
tt=(char *)malloc(12);
strcpy(eplace,term());
while((syn==13)||(syn==14))
{
if (syn==13)
strcpy(tt,"+");
else
strcpy(tt,"-");
scaner();
strcpy(ep2,term());
strcpy(tp,newtemp());
emit(tp,eplace,tt,ep2);
strcpy(eplace,tp);
}
return (eplace);
}
char *term()
{
char *tp,*ep2,*eplace,*tt;
tp=(char *)malloc(12);
ep2=(char *)malloc(12);
eplace=(char *)malloc(12);
tt=(char *)malloc(12);
strcpy(eplace,factor());
while((syn==15)||(syn==16))
{
if (syn==15)
strcpy(tt,"*");
else
strcpy(tt,"/");
scaner();
strcpy(ep2,factor());
strcpy(tp,newtemp());
emit(tp,eplace,tt,ep2);
strcpy(eplace,tp);
}
return (eplace);
}
char *factor()
{
char *fplace;
fplace=(char *)malloc(12);
strcpy(fplace,"");
if(syn==10) //得到字元
{
strcpy(fplace,token);
scaner();
}
else if(syn==11) //得到數字
{
itoa(sum,fplace,10);
scaner();
}
else if(syn==27) //得到)
{
scaner();
fplace=expression();
if(syn==28) //得到(
scaner();
else
{
printf("error on ')' !\n");
kk=1;
getch();
exit(0);
}
}
else
{
printf("error on '(' !\n");
kk=1;
getch();
exit(0);
}
return (fplace);
}
//該函數回送一個新的臨時變數名，臨時變數名產生的順序為T1,T2...
char *newtemp()
{
char *p;
char m[8];
p=(char *)malloc(8);
kk++;
itoa(kk,m,10);
strcpy(p+1,m);
p[0]='t';
return(p); //設置中間變數名放在一個字元數組中，字元數組的第一個字元為t第二個字元為m表示的數值
}
void scaner()
{
sum=0;
///for(m=0;m<8;m++)
//token[m++]=NULL;
memset(token,0,8);
m=0;
ch=prog[p++];
while(ch==' ')
ch=prog[p++];
if(((ch<='z')&&(ch>='a'))||((ch<='Z')&&(ch>='A')))
{
while(((ch<='z')&&(ch>='a'))||((ch<='Z')&&(ch>='A'))||((ch>='0')&&(ch<='9')))
{
token[m++]=ch;
ch=prog[p++];
}
p--;
syn=10;
token[m++]='\0';
for(n=0;n<6;n++)
if(strcmp(token,rwtab[n])==0)
{
syn=n+1;
break;
}
}
else if((ch>='0')&&(ch<='9'))
{
while((ch>='0')&&(ch<='9'))
{
sum=sum*10+ch-'0';
ch=prog[p++];
}
p--;
syn=11;
}
else switch(ch)
{
case '<':m=0;
ch=prog[p++];
if(ch=='>')
{
syn=21;
}
else if(ch=='=')
{
syn=22;
}
else
{
syn=20;
p--;
}
break;
case '>':m=0;
ch=prog[p++];
if(ch=='=')
{
syn=24;
}
else
{
syn=23;
p--;
}
break;
case ':':m=0;
token[m++] = ch;
ch=prog[p++];
if(ch=='=')
{
syn=18;
token[m++] = ch;
}
else
{
syn=17;
p--;
}
break;
case '+': syn=13;token[0] = ch; break;
case '-': syn=14;token[0] = ch; break;
case '*': syn=15;token[0] = ch;break;
case '/': syn=16;token[0] = ch;break;
case '(': syn=27;token[0] = ch;break;
case ')': syn=28;token[0] = ch;break;
case '=': syn=25;token[0] = ch;break;
case ';': syn=26;token[0] = ch;break;
case '#': syn=0;token[0] = ch;break;
default: syn=-1;break;
}
}
//該函數是生成一個三地址語句送到四元式表中
void emit(char *result,char *ag1,char *op,char *ag2)
{
strcpy(quad[q].result1,result);
strcpy(quad[q].ag11,ag1);
strcpy(quad[q].op1,op);
strcpy(quad[q].ag21,ag2);
q++; //統計有多少個四元式
}
⑽ gcc中C語言的詞法分析是怎麼做的
預編譯(Preprocessing)會對各種預處理...
1
編譯(Compilation)對代碼進行語法、語...
2
匯編(Assembly)把匯編代碼轉換與計算機...
3
鏈接(Linking/Build)通俗的講就是把多...
4
程序運行[root@wahoo test]#./hellohel...
5
總結：gcc 編譯c程序的主要過程包括 ...