编译原理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

;