1.条件语句（if_else语句）

3钟形式的if语句：

1）if（表达式）语句。如

if(a>b)

out1 = int1;

2）if（表达式）

语句；

else

语句；如

if(a>b)

out1 = int1;

else

out1 = int2;

3）if（表达式1）

语句1；

else if（表达式2） 语句2；

else if（表达式3） 语句3；

…………………...

else if（表达式m） 语句m；

else 语句n；

条件语句必须在过程块语句中是用（initial和always语句），除了这两个语句引导的bedin end块中可以编写条件语句外，模块中的其他地方都不能编写。

说明

（1）3钟形式的if语句中if后面的表达式一般为逻辑表达式或关系表达式。判断若为0、Z、X按假处理，若为1，按真处理执行指定语句。

（2）在每个else前面有一分号，整个语句结束处有一分号。

（3）if和else后包含多个操作语句时要用begin_end包含成一个复合语句。

（4）允许一定形式的表达式简写

（5）else总是与它上面最近的if配对

2.case语句

case语句提供一种多分支选择语句，形式如下：

（1）case（表达式）<case分支项> endcase

（2）casez（表达式）<case分支项> endcase

（3）casex（表达式）<case分支项> endcase

case分支项格式如下

分支表达式： 语句；

default： 语句；

说明：

1）分支表达式又可以称为常量表达式。

2）当控制表达式与分支表达式相等时就执行分支表达式后的语句，如没有相等的就执行default后的语句。

3）default项可有可无，一个case语句只准有一个default项。

4）每个case的分支表达式的值必须互不相等，否则就会出现问题。

5）执行完case分项后的语句则跳出case语句结构，终止case语句。

6）在用case语句表达式进行比较时只当信号对应位的值能明确进行比较时，比较才会成功，因此要详细说明case分项的分支表达式的值。

7）case语句的所有表达式的值位宽必须相等。

Casez语句用来处理不考虑高阻值z的比较过程

casex语句用来处理不考虑高阻值X的比较过程

如果用到if语句最好写上else项；

如果用case语句最好写上default项。

3.条件语句的语法

If else表示的条件语句共有3种类型：

//第一类条件语句

if ( !lock ) buffer = data ;

if ( enable ) out = in ;

//第二类条件语句

if (number_queued < MAX_Q_DEPTH)

begin

data_queue = data ;

number_queued = number_queued + 1 ;

end

else

$display ( " Queue Full. Try again " ) ;

//第三类条件语句

//根据不同的算术逻辑单元的控制信号 alu_control 执行不同的算术运算操作

if ( alu_control = = 0 )

y = x + z ;

else if ( alu_control = = 1 )

y = x - z ;

else if ( alu_control = = 2 )

y = x * z ;

else

$ display ( " Invalid ALU control signal ");

reg [ 1: 0] alu_control ;

case (alu_control)

2 'd 0 : y = x + z ;

2 'd 1 : y = x - z ;

2 'd 2 : y = x * z ;

default : $display ( "Invalid ALU control signal ") ;

endcase

4.多路分支语句

case语句 case endcase default

5.循环语句

（1）forever语句：连续的执行语句。

（2）repeat语句：连续执行一条语句n次。

（3）while语句：执行一条语句直到某个条件不满足。如果一开始就不满足则语句一次也不执行。

（4）for语句通过以下3个步骤决定语句的循环次数

1）先给控制循环次数的变量赋初值。

2）判定控制循环的表达式的值，为假则跳出循环语句，为真则执行指定的语句。

3）执行一条赋值语句来修正控制循环变量次数的变量的值，返回第二步。

forever语句格式

Forever 语句；

或

Forever begin 多条语句 end

forever循环语句常用于生产周期性的波形，用来作为仿真测试信号。

它与always语句不同之处在于不能独立写在程序中，而必须写在initial块中。

repeat语句格式

repeat（表达式）语句

或

Repeat(表达式)begin多条语句；end

在repeated语句中，其表达式通常为常量表达式。

while语句格式

while（表达式）语句；

或

while（表达式）begin多条语句；end

for语句格式

for（表达式1；表达式2；表达式3）语句；

例子：

用for语句来初始化memory

begin: init_mem

reg[7:0] tempi;

for(tempi=0;tempi<memsize;tempi=tempi+1)

memory[tempi]=0;

end

用for语句来实现乘法器。

parameter size = 8, longsize = 16;

reg[size:1] opa, opb;

reg[longsize:1] result;

begin:mult

integer bindex;

result=0;

for( bindex=1; bindex<=size; bindex=bindex+1 )

if(opb[bindex])

result = result + (opa<<(bindex-1));

end

用for语句对rega这八位二进制数中的值为1的位数进行计数

begin: count1s

reg[7:0] tempreg;

count=0;

for( tempreg=rega; tempreg; tempreg=tempreg>>1 )

if(tempreg[0])

count=count+1;

end

6.顺序块和并行块

块语句类型

（1）顺序块（也称过程块）

关键字begin_end

顺序块中的语句一条条按顺序执行，只有前面语句执行完才执行后面的语句（除了带有内嵌延时控制的非阻塞赋值语句）。

如果语句包括延时或事件控制，那么延迟总是相对于前面那条语句执行完成的仿真时间的

（2）并行块

关键字fork_join

并行块内的语句是并发执行的；

语句的执行的顺序是由各自语句内延迟或事件控制决定的

语句中的延迟或事件控制是相对于块语句开始执行的时刻而言的。

（3）块语句的特点

1.嵌套式

块可以嵌套使用，顺序块和并行块能够混合在一起使用

2.命名块

命名块中可以声明局部变量；

命名块是设计层次的一部分，命名块中声明的变量可以通过层次名引用进行访问；

命名块可以被禁用例如停止其执行。

//命名块

module top ;

initial

begin : block1 //名字为block1的顺序命名块

integer i ; //整型变量 i 是block1命名块的静态本地变量

//可以用层次名top.block1.i 被其他模块访问

...

...

end

initial

fork : block2 //名字为block2的并行命名块

reg i ; //寄存器变量 i 是block2命名块的静态本地变量

//可以用层次名top.block2.i 被其他模块访问

...

...

join

3.命名块的禁用

通过关键字disable提供了一种中止命名块执行的方法。disable可以用来从循环中退出、处理错误条件以及根据控制信号来控制某些代码是否被执行。对块语句的禁用导致紧接在块后面的那条语句被执行。disable则可以禁用设计中的任何一个命名块。

//在（矢量）标志寄存器的各个位中从低有效位开始找寻第一个值为1的位

//从矢量标志寄存器的低有效位开始查找第一个值为1的位

reg [15:0] flag;

integer i; //用于计数的整数

initial

begin

flag = 16'b 0010_0000_0000_0000;

i = 0;

begin: block1 //while循环声明中的主模块是命名块block1

while(i < 16)

begin

if (flag[i])

begin

$display("Encountered a TRUE bit at element number %d", i);

disable block1; // 在标志寄存器中找到了值为真（1）的位，禁用block1

end

i = i + 1;

end

end

end

7.生成块

生成语句可以动态的生成verilog代码。这一声明语句方便了参数化模块的生成。当对矢量中的多个位进行重复操行时，或者当进行多个模块的实例引用的重复操作时。或者在根据参数的定义来确定程序中是否应该包括某段verilog代码的时候，使用生成语句能够大大简化程序的编写过程。

生成语句能够控制变量的声明、任务或函数的调用，还能对实例引用进行全面的控制。编写代码时必须在模块中说明生成的实例范围，用generate_endgenerate来指定该范围。

生成实例可以是以下的一个或多种类型：

（1）模块；

（2）用户定义原语；

（3）门级原语；

（4）连续赋值语句；

（5）initial和always块。

verilog语言允许在生成范围内声明下列数据类型：

（1）net（线网）、reg（寄存器）；

（2）integer（整型数）、real（实型数）、time（时间型）、realtime（实数时间型）；

（3）event（事件）。

不允许出现在生成范围之中的模块项声明包括：

（1）参数、局部参数；

（2）输入、输出和输入/输出声明；

（3）指定块。

生成模块的实例连接方法与常规模块实例相同。

3种创建生成语句的方法：

（1）循环生成；

（2）条件生成；

（3）case生成。

循环生成语句：

允许使用者对下面的模块或模块项进行多次实例引用：

（1）变量声明；

（2）模块；

（3）用户定义的原语、门级原语；

（4）连续赋值语句；

（5）initial和always块。

例子：

//本模块生成两条N位总线变量的按位异或

module bitwise_xor ( out , i0 , i1 ) ;

//参数声明语句。参数可以重新定义

parameter N = 32 ; // 缺省的总线位宽为32位

//端口声明语句

output [ N-1 : 0 ] out ;

input [ N-1 : 0 ] i0 , i1 ;

//声明一个临时循环变量。

//该变量只用于生成块的循环计算。

//Verilog仿真时该变量在设计中并不存在

genvar j ;

//用一个单循环生成按位异或的异或门（xor）

generate

for ( j = 0 ; j < N ; j = j + 1 )

begin : xor_loop

xor g1 (out [ j ] , i0 [ j ] , i1 [ j ] ) ;

end // 在生成块内部结束循环

endgenerate //结束生成块

//另外一种编写形式

//异或门可以用always块来替代

// reg [ N-1 : 0] out ;

// generate

// for ( j = 0 ; j < N ; j = j + 1 )

// begin : bit

// always @ ( i0 [ j ] or i1 [ j ] ) out [ j ] = i0 [ j ] ^ i0 [ j ] ;

// end

// endgenerate

endmodule

//本模块生成一个门级脉动加法器

module ripple_adder ( co , sum , a0 , a1 , ci ) ;

//参数声明语句，参数可以重新定义。

parameter N = 4 ; // 缺省的总线位宽为4

//端口声明语句

output [ N-1 : 0 ] sum ;

output co ;

input [N-1 : 0 ] a0 , a1 ;

input ci ;

//本地线网声明语句

wire [N-1 : 0 ] carry ;

//指定进位变量的第0位等于进位的输入

assign carry [0] = ci ;

//声明临时循环变量。该变量只用于生成块的计算。

//由于在仿真前，循环生成已经展平，所以用Verilog对

//设计进行仿真时，该变量已经不再存在。

genvar i ;

//用一个单循环生成按位异或门等逻辑

generate for ( i = 0 ; i < N ; i = i + 1 ) begin : r_loop

wire t1 , t2 , t3 ;

xor g1 ( t1 , a0[ i ] , a1 [ i ] ) ;

xor g2 ( sum [ i ] , t1 , carry [ i ] ) ;

and g3 ( t2 , a0[ i ] , a1 [ i ] ) ;

and g4 ( t3 , t1 , carry [ i ] ) ;

or g5 (carry [ i + 1 ] , t2 , t3 ) ;

end // 生成块内部循环的结束

endgenerate //生成块的结束

// 根据上面的循环生成，Verilog编译器会自动生成以下相对层次实例名

// xor : r_loop[0].g1 , r_loop[1].g1 , r_loop[2].g1 , r_loop[3].g1 ,

// r_loop[0].g2 , r_loop[1].g2 , r_loop[2].g2 , r_loop[3].g2 ,

// and : r_loop[0].g3 , r_loop[1].g3 , r_loop[2].g3 , r_loop[3].g3 ,

// r_loop[0].g4 , r_loop[1].g4 , r_loop[2].g4 , r_loop[3].g4 ,

// or : r_loop[0].g5 , r_loop[1].g5 , r_loop[2].g5 , r_loop[3].g5

// 上面生成的实例用下面这些生成的线网连接起来

// Nets : r_loop[0].t1 , r_loop[0].t2 , r_loop[0].t3

// r_loop[1].t1 , r_loop[1].t2 , r_loop[1].t3

// r_loop[2].t1 , r_loop[2].t2 , r_loop[2].t3

// r_loop[3].t1 , r_loop[3].t2 , r_loop[3].t3

assign co = carry [ N ] ;

endmodule

条件生成语句

有条件的调用（实例引用）以下verilog结构：

（1）模块；

（2）用户定义原语、门级原语；

（3）连续赋值语句；

（4）initial或always块。

例子

// 本模块实现一个参数化乘法器

module multiplier ( product , a0 , a1 ) ;

//参数声明，该参数可以重新定义

parameter a0_width = 8 ;

parameter a1_width = 8 ;

//本地参数声明

//本地参数不能用参数重新定义（defparam）修改 ,

//也不能在实例引用时通过传递参数语句，即 #（参数1，参数2，...）的方法修改

localparam product_width = a0_width + a1_width ;

//端口声明语句

output [ product_width - 1 : 0 ] product ;

input [ a0_width - 1 : 0 ] a0 ;

input [ a1_width - 1 : 0 ] a1 ;

//有条件地调用（实例引用）不同类型的乘法器

//根据参数a0_width 和 a1_width的值，在调用时

//引用相对应的乘法器实例。

generate

if ( a0_width < 8 ) | | ( a1_width < 8 )

cal_multiplier # ( a0_width , a1_width ) m0 ( product , a0 , a1 ) ;

else

tree_multiplier # ( a0_width , a1_width ) m0 ( product , a0 , a1 ) ;

endgenerate //生成块的结束

endmodule

case生成语句

可以调用一下verilog结构

（1）模块；

（2）用户定义原语、门级原语；

（3）连续赋值语句；

（4）initial或always块。

例子

//本模块生成N位的加法器

module adder ( co , sum , a0 , a1 , ci );

//参数声明，本参数可以重新定义

parameter N = 4 ; // 缺省的总线位宽为4

//端口声明

output [ N-1 : 0 ] sum ;

output co ;

input [ N-1 : 0 ] a0 , a1 ;

input ci ;

// 根据总线的位宽，调用（实例引用）相应的加法器

// 参数N在调用（实例引用）时可以重新定义，调用（实例引用）

// 不同位宽的加法器是根据不同的N来决定的。

generate

case ( N )

// 当N=1, 或2 时分别选用位宽为1位或2位的加法器

1 : adder_1bit adder1 ( co , sum , a0 , a1 , ci ) ; // 1位的加法器

2 : adder_2bit adder2 ( co , sum , a0 , a1 , ci ) ; // 2位的加法器

// 缺省的情况下选用位宽为N位的超前进位加法器

default : adder_cla # ( N ) adder3 ( co , sum , a0 , a1 , ci ) ;

endcase

endgenerate //生成块的结束

endmodule