編譯原理basic語言,basic語言編譯器

本文目錄一覽：

• 1、自學的話是basic語言好還是C語言好
• 2、北大青鳥設計培訓：計算機有哪些專業？
• 3、想學計算機的話，主要會學些什麼內容
• 4、編譯原理的名字與標識符的區別是什麼?
• 5、我想學編程，請問該怎麼入門?
• 6、編譯原理課程設計

自學的話是basic語言好還是C語言好

你這種問題的提問方法就有問題，所以沒辦法回答。

你要說，我為什麼要學basic，為什麼要學C，我現在是一個小學生？初中生？大學生？研究生？

只有你描述清楚了問題，才可能得到滿意的回答。

一般來說，BASIC不太推薦了，用的人逐漸減少，比起現代語言沒什麼優勢。

根據不同的用途，首門語言推薦：

C語言，最高要求，沒有不能做的。當然，說的是入門。達到最高要求，需要大量數學、彙編、編譯原理、操作系統。

Java語言，面嚮應用，好學、好用。

PHP語言，出類拔萃的腳本語言。

此外，C#、JavaScript等等也都是不錯的語言。真正搞計算機的，就是精通一門語言，其他的需要什麼語言，幾個小時就要學會。一個巨型程序，混用幾十種語言並不稀奇，光是C、C++、Java、PHP、SQL、JavaScript、彙編、Perl、Fortran、TCL、Python，就已經不少了，還有大量的其他語言，每一種語言都有它適合的場合。

北大青鳥設計培訓：計算機有哪些專業？

計算機有哪些專業?通常計算機專業主要有電路原理、模擬電子技術、數字邏輯、數字分析、計算機原理、微型計算機技術、計算機系統結構、計算機網絡、彙編語言、數據結構、操作系統、編譯原理、系統分析與控制、信號處理原理、通信原理概論等專業

\t計算機應用專業的主要課程有：計算機應用基礎、計算機組裝與維護、Visual

Basic語言、專業英語、計算機平面與動畫設計、計算機網絡基礎與局域網絡的建設與管理、數據庫的開發與應用、廣告設計與製作、網站建設與網頁設計、多媒體設計與製作。

\t網頁與平面設計是近十年逐步發展起來的新型複合型職業，涉及廣泛而發展迅速。

包括網頁製作與設計、商業藝術設計、商業展示設計、商業廣告設計、書籍裝幀設計、包裝結構與工業產品設計、商業插畫、標誌設計等。

\t本專業培養具有良好的科學素養，系統地、較好地掌握計算機科學與技術包括計算機硬件、軟件與應用的基本理論、基本知識和基本技能與方法，能在科研部門、教育單位、企業、事業、技術和行政管理部門等單位從事計算機教學、科學研究和應用的計算機科學與技術學科的專門科學技術人才。

\t北大青鳥計算機學校不同於高校計算機專業設置，銀川北大青鳥校區專業課程有以下：

\tAccp軟件工程師專業

\tACCP軟件工程師培訓課程是北大青鳥IT職業教育的核心產品之一，也是目前國內針對軟件開發培訓非常系統和嚴謹的培訓課程體系。

\t學士後專業

\t北大青鳥IT教育推出“學士後”專業，包括Java、.NET、等，專門為20周歲以及學歷以上的人群設置，學期短，6個月即可學會一門技術，成為高薪的軟件工程師。

想學計算機的話，主要會學些什麼內容

基礎課程：高等數學、革命史、大學物理、概率論、計算機導論、大學英語、線性代數、馬克思主義原理、大學生素養、法律基礎、金工實習等。

專業課程：編譯原理、自動化控制原理、計算機控制原理、C語言、Visual basic語言、圖形學、計算方法、操作系統、實習課、計算機專業英語、數據結構、單片機、計算機接口等

課外：辯論課程。

編譯原理的名字與標識符的區別是什麼?

不太明白樓主想問什麼，先幫你查這麼多，如果還不明白，請繼續詢問百度和谷哥。

標識符

是用戶編程時使用的名字。我們指定某個東西、人，都要用到它，他或她的名字；在數學中解方程時，我們也常常用到這樣或那樣的變量名或函數名。同樣的道理，在電腦語言中，對於變量，常量，函數，語句塊也有名字，我們統統稱之為標識符。我們在給人起名字時有一定的規矩，比如，頭一個字為父親或母親的姓氏，後面一般為一個或兩個字。所以，您可以想當然地認為電腦語言里的標識符也有一定的命名規則，如果您這樣想，那您就想對了!

保留字(reserved word)

保留字又稱關鍵字。

指在高級語言中已經定義過的字，使用者不能再將這些字作為變量名或過程名使用。

每種程序設計語言都規定了自己的一套保留字。

例如：BASIC語言規定不能使用LIST作為變量名或過程名，因為LIST是一個BASIC語言專用於顯示內存程序的命令。

C有22+10 = 32個關鍵字

C++ 有22+10+11+20 = 63 個關鍵字

JAVA 有22+ 9+ 17 = 48 個關鍵字

我想學編程，請問該怎麼入門?

學編程入門建議：

1.學編程要從根本出發，從理論上來說，需要廣泛的閱讀。了解算法的博大精深和計算機的基本理論。

2.從實踐上來說，需要有廣泛的練習，練習的廣泛在於練習不同的內容。然後就是創新精神和數學思維能力，這些都是需要培養的。基礎要打好學編程要具備一定的基礎。

3.邏輯思維能力的培養、學程序設計要有一定的邏輯思維能力。“思維能力”的培養要長時間的實踐鍛煉。要想成為一名優秀的程序員，最重要的是掌握編程思想。要做到這一點必須在反覆的實踐、觀察、分析、比較、總結中逐漸地積累。

編譯原理課程設計

%{

/* FILENAME: C.Y */

%}

#define YYDEBUG_LEXER_TEXT (yylval) /* our lexer loads this up each time */

#define YYDEBUG 1 /* get the pretty debugging code to compile*/

#define YYSTYPE char * /* interface with flex: should be in header file */

/* Define terminal tokens */

/* keywords */

%token AUTO DOUBLE INT STRUCT

%token BREAK ELSE LONG SWITCH

%token CASE ENUM REGISTER TYPEDEF

%token CHAR EXTERN RETURN UNION

%token CONST FLOAT SHORT UNSIGNED

%token CONTINUE FOR SIGNED VOID

%token DEFAULT GOTO SIZEOF VOLATILE

%token DO IF STATIC WHILE

/* ANSI Grammar suggestions */

%token IDENTIFIER STRINGliteral

%token FLOATINGconstant INTEGERconstant CHARACTERconstant

%token OCTALconstant HEXconstant

/* New Lexical element, whereas ANSI suggested non-terminal */

%token TYPEDEFname /* Lexer will tell the difference between this and

an identifier! An identifier that is CURRENTLY in scope as a

typedef name is provided to the parser as a TYPEDEFname.*/

/* Multi-Character operators */

%token ARROW /* – */

%token ICR DECR /* ++ — */

%token LS RS /* */

%token LE GE EQ NE /* = = == != */

%token ANDAND OROR /* || */

%token ELLIPSIS /* … */

/* modifying assignment operators */

%token MULTassign DIVassign MODassign /* *= /= %= */

%token PLUSassign MINUSassign /* += -= */

%token LSassign RSassign /* = = */

%token ANDassign ERassign ORassign /* = ^= |= */

%start translation_unit

%%

/* CONSTANTS */

constant:

INTEGERconstant

| FLOATINGconstant

/* We are not including ENUMERATIONconstant here because we

are treating it like a variable with a type of “enumeration

constant”. */

| OCTALconstant

| HEXconstant

| CHARACTERconstant

;

string_literal_list:

STRINGliteral

| string_literal_list STRINGliteral

;

/************************* EXPRESSIONS ********************************/

primary_expression:

IDENTIFIER /* We cannot use a typedef name as a variable */

| constant

| string_literal_list

| ‘(‘ comma_expression ‘)’

;

postfix_expression:

primary_expression

| postfix_expression ‘[‘ comma_expression ‘]’

| postfix_expression ‘(‘ ‘)’

| postfix_expression ‘(‘ argument_expression_list ‘)’

| postfix_expression {} ‘.’ member_name

| postfix_expression {} ARROW member_name

| postfix_expression ICR

| postfix_expression DECR

;

member_name:

IDENTIFIER

| TYPEDEFname

;

argument_expression_list:

assignment_expression

| argument_expression_list ‘,’ assignment_expression

;

unary_expression:

postfix_expression

| ICR unary_expression

| DECR unary_expression

| unary_operator cast_expression

| SIZEOF unary_expression

| SIZEOF ‘(‘ type_name ‘)’

;

unary_operator:

”

| ‘*’

| ‘+’

| ‘-‘

| ‘~’

| ‘!’

;

cast_expression:

unary_expression

| ‘(‘ type_name ‘)’ cast_expression

;

multiplicative_expression:

cast_expression

| multiplicative_expression ‘*’ cast_expression

| multiplicative_expression ‘/’ cast_expression

| multiplicative_expression ‘%’ cast_expression

;

additive_expression:

multiplicative_expression

| additive_expression ‘+’ multiplicative_expression

| additive_expression ‘-‘ multiplicative_expression

;

shift_expression:

additive_expression

| shift_expression LS additive_expression

| shift_expression RS additive_expression

;

relational_expression:

shift_expression

| relational_expression ” shift_expression

| relational_expression ” shift_expression

| relational_expression LE shift_expression

| relational_expression GE shift_expression

;

equality_expression:

relational_expression

| equality_expression EQ relational_expression

| equality_expression NE relational_expression

;

AND_expression:

equality_expression

| AND_expression ” equality_expression

;

exclusive_OR_expression:

AND_expression

| exclusive_OR_expression ‘^’ AND_expression

;

inclusive_OR_expression:

exclusive_OR_expression

| inclusive_OR_expression ‘|’ exclusive_OR_expression

;

logical_AND_expression:

inclusive_OR_expression

| logical_AND_expression ANDAND inclusive_OR_expression

;

logical_OR_expression:

logical_AND_expression

| logical_OR_expression OROR logical_AND_expression

;

conditional_expression:

logical_OR_expression

| logical_OR_expression ‘?’ comma_expression ‘:’

conditional_expression

;

assignment_expression:

conditional_expression

| unary_expression assignment_operator assignment_expression

;

assignment_operator:

‘=’

| MULTassign

| DIVassign

| MODassign

| PLUSassign

| MINUSassign

| LSassign

| RSassign

| ANDassign

| ERassign

| ORassign

;

comma_expression:

assignment_expression

| comma_expression ‘,’ assignment_expression

;

constant_expression:

conditional_expression

;

/* The following was used for clarity */

comma_expression_opt:

/* Nothing */

| comma_expression

;

/******************************* DECLARATIONS *********************************/

/* The following is different from the ANSI C specified grammar.

The changes were made to disambiguate typedef’s presence in

declaration_specifiers (vs. in the declarator for redefinition);

to allow struct/union/enum tag declarations without declarators,

and to better reflect the parsing of declarations (declarators

must be combined with declaration_specifiers ASAP so that they

are visible in scope).

Example of typedef use as either a declaration_specifier or a

declarator:

typedef int T;

struct S { T T;}; /* redefinition of T as member name * /

Example of legal and illegal statements detected by this grammar:

int; /* syntax error: vacuous declaration * /

struct S; /* no error: tag is defined or elaborated * /

Example of result of proper declaration binding:

int a=sizeof(a); /* note that “a” is declared with a type in

the name space BEFORE parsing the initializer * /

int b, c[sizeof(b)]; /* Note that the first declarator “b” is

declared with a type BEFORE the second declarator is

parsed * /

*/

declaration:

sue_declaration_specifier ‘;’

| sue_type_specifier ‘;’

| declaring_list ‘;’

| default_declaring_list ‘;’

;

/* Note that if a typedef were redeclared, then a declaration

specifier must be supplied */

default_declaring_list: /* Can’t redeclare typedef names */

declaration_qualifier_list identifier_declarator {} initializer_opt

| type_qualifier_list identifier_declarator {} initializer_opt

| default_declaring_list ‘,’ identifier_declarator {} initializer_opt

;

declaring_list:

declaration_specifier declarator {} initializer_opt

| type_specifier declarator {} initializer_opt

| declaring_list ‘,’ declarator {} initializer_opt

;

declaration_specifier:

basic_declaration_specifier /* Arithmetic or void */

| sue_declaration_specifier /* struct/union/enum */

| typedef_declaration_specifier /* typedef*/

;

type_specifier:

basic_type_specifier /* Arithmetic or void */

| sue_type_specifier /* Struct/Union/Enum */

| typedef_type_specifier /* Typedef */

;

declaration_qualifier_list: /* const/volatile, AND storage class */

storage_class

| type_qualifier_list storage_class

| declaration_qualifier_list declaration_qualifier

;

type_qualifier_list:

type_qualifier

| type_qualifier_list type_qualifier

;

declaration_qualifier:

storage_class

| type_qualifier /* const or volatile */

;

type_qualifier:

CONST

| VOLATILE

;

basic_declaration_specifier: /*Storage Class+Arithmetic or void*/

declaration_qualifier_list basic_type_name

| basic_type_specifier storage_class

| basic_declaration_specifier declaration_qualifier

| basic_declaration_specifier basic_type_name

;

basic_type_specifier:

basic_type_name /* Arithmetic or void */

| type_qualifier_list basic_type_name

| basic_type_specifier type_qualifier

| basic_type_specifier basic_type_name

;

sue_declaration_specifier: /* Storage Class + struct/union/enum */

declaration_qualifier_list elaborated_type_name

| sue_type_specifier storage_class

| sue_declaration_specifier declaration_qualifier

;

sue_type_specifier:

elaborated_type_name /* struct/union/enum */

| type_qualifier_list elaborated_type_name

| sue_type_specifier type_qualifier

;

typedef_declaration_specifier: /*Storage Class + typedef types */

typedef_type_specifier storage_class

| declaration_qualifier_list TYPEDEFname

| typedef_declaration_specifier declaration_qualifier

;

typedef_type_specifier: /* typedef types */

TYPEDEFname

| type_qualifier_list TYPEDEFname

| typedef_type_specifier type_qualifier

;

storage_class:

TYPEDEF

| EXTERN

| STATIC

| AUTO

| REGISTER

;

basic_type_name:

INT

| CHAR

| SHORT

| LONG

| FLOAT

| DOUBLE

| SIGNED

| UNSIGNED

| VOID

;

elaborated_type_name:

aggregate_name

| enum_name

;

aggregate_name:

aggregate_key ‘{‘ member_declaration_list ‘}’

| aggregate_key identifier_or_typedef_name

‘{‘ member_declaration_list ‘}’

| aggregate_key identifier_or_typedef_name

;