Assignment 2 Phase 1 Checklist

Cập nhật lúc 11:30 PM 09/11/2013:

@All ai đang làm phase thì làm hết luôn những phần bị gạch (gạch vì không hiện thực trong phase 1 nhưng phase 2 yêu cầu làm đầy đủ phần này) luôn nhá

“nếu khác lượng params thì báo lỗi Undeclared Method” ở phần call statement và call expressoin

________________

Cập nhật lúc 9:50 PM: các phần liên quan các bạn phải tự biết để mà hiện thực nhá ________________

Cập nhật lúc 7:30 PM:
Testcases contain errors on type mismatch in constant expressions, i.e. just including literal, type mismatch in statement which contains literal expressions. LHS only use global variable

Sau khi xác nhận với vài thánh đã được kết quả như sau:
1. Expression chỉ chứa literal không chứa ident.
2. LHS chỉ dùng biến toàn cục.
Các bạn nào lỡ làm dư rồi thì cũng không sao, trước sau gì cũng phải làm thôi =D
Các bạn đọc lại phần dưới để biết thêm chi tiết

________________

Cập nhật lúc 5:00 PM: thêm: expr trong For cũng phải tương thích kiểu

________________

Tránh tình trạng các bạn làm dư phần này mà lại làm thiếu các phần cần thiết, mình xin làm một cái check list nho nhỏ về vấn đề này.

Nhưng trước hết mình xin nói một điều là bài viết này dựa trên quan điểm các nhân của mình, các bạn có thể dùng để tham khảo. Nhưng vì đây cũng chỉ là quan điểm của riêng mình, không thể tránh được thiếu sót, có gì mong các bạn đóng góp ý kiến chân thành, xin cám ơn.

1. Trước khi vào vấn đề chính, mình xin điểm sơ qua vài điều:

1.1. Các ràng buộc sẽ được kiểm tra của Assignment 2 (3. Semantic Constraints):

a. Redeclared Variable/Constant/Attribute/Class/Method/Parameter:

b. Undeclared Identifier/Attribute/Method/Class:

c. Cannot Assign To Constant:

d. No Prototype/No Implementation:

e. Type Mismatch In Statement:

f. Type Mismatch In Expression:

g. Cannot Access Private Attribute:

h. Method Not Return:

1.2 Submission and late penalties:

You are required to submit only file StaticCheck.scala with the entry check_program.

+ Phase 1: deadline November 4th, 2013 at 12:00 noon

– There are some limitation in this phase:

– Testcases contain errors on type mismatch in constant expressions, i.e. just including literal, type mismatch in statement which contains literal expressions. LHS only use global variable

– There is at most 1 error in each testcase.

____

– Theo mình hiểu thì trong phase này sẽ giới hạn lại như sau:

– Blah…blah…blah… cái gì gì đó, đọc xong chỉ hiểu được là trong expressions chỉ chứa literal, rồi còn LHS thì chỉ dùng biến toàn cục. => không cần quan tâm đến tầm vực của biến nữa (ít nhất là tạm thời). Còn lại chắc phải làm đầy đủ 2 phần e, f trên đặc tả cho chắc ăn

– Chỉ có nhiều nhất 1 lỗi trong mỗi testcase. => không cần quan tâm thứ tự các lỗi sẽ xuất hiện như thế nào, độ ưu tiên ra sao.

2. Rồi, và bây giờ, cần làm những gì trong Phase 1?

Như đã nói trong phần trên thì trong Phase 1 mình chỉ cần quan tâm tới 2 phần e và f (có thể sẽ dư thừa, nhưng chắc chắn không thiếu):

e. Type Mismatch In Statement:

A statement must conform the corresponding type rules for statements, otherwise the error message “Type Mismatch In Statement: ”+<statement> is released.

The type rules for statements are as follows:

– The type of a conditional expression in an if, repeat or while statement must be boolean.

– For an assignment statement, the left-hand side can be in any type except void type. The right-hand side (RHS) is either in the same type as that of the LHS or in the type that can coerce to the LHS type. In BKOOL, just the integer can coerce to the float or a subtype can coerce to its super type. When LHS is in an array type, RHS must be in array type whose size is the same and whose element type can be either the same or able to coerce to the element type of LHS.

– The type of the index variable and the expressions in a for statement must be integer.

– For a call statement E.<method name>(<args>), E must be in class type; the callee must have void as return type and the number of arguments must be equal to that of callee parameters. In addition, for parameter passing, the rule for an assignment is applied to parameter passing where a parameter is considered as the LHS and the corresponding argument is the RHS.

– For a return statement, the return expression can be considered as RHS of an implicit assignment whose LHS is the return type.

____

1.

case class If(val expr: Expr, val thenStmt: Stmt, val elseStmt: Option[Stmt]) extends Stmt {…}

case class While(val expr: Expr, val loop: Stmt) extends Stmt {…}

case class Repeat(val loop: List[Stmt], val expr: Expr) extends Stmt {…}

def visit(ast: If, c: Context): Object = {…}

def visit(ast: While, c: Context): Object = {…}

def visit(ast: Repeat, c: Context): Object = {…}

Điều kiện của câu lệnh If, Repeat và While (tức là expr) phải là kiểu boolean
2.

case class Assign(val leftHandSide: LHS, val expr: Expr) extends Stmt {…}

def visit(ast: Assign, c: Context): Object = {…}

Câu lệnh gán:

a. LHS có thể là mọi kiểu, trừ kiểu void ra. “<lhs>, which can be a variable, a mutable attribute or an element of an array.” lấy đâu ra kiểu void?

b. RHS có thể cùng kiểu, hoặc là có thể ép kiểu về LHS (integer ép về float, class con ép về kiểu class cha literal chẳng có cái nào kiểu class cả).

c. Khi LHS là kiểu array thì RHS cũng phải là kiểu array có cùng kích thước, và kiểu thành phần của RHS có thể cùng kiểu, hoặc là có thể ép kiểu về LHS. do RHS expression chỉ chứa literal, mà literal thì không có cái nào có kiểu array cả, nên không cần quan tâm nữa

3.

case class For(val name: Id, val expr: Expr, val up: Boolean, val expr2: Expr, val loop: Stmt) extends Stmt {…}

def visit(ast: For, c: Context): Object = {…}

Kiểu của name, expr, expr2 trong câu lệnh For phải là kiểu integer.

4.

case class Call(val parent: Expr, val method: Id, val params: List[Expr]) extends Stmt {…}

def visit(ast: Call, c: Context): Object = {…}

Câu lệnh gọi hàm parent.method(params):

a. parent phải là kiểu class

b. Phương thức được gọi phải trả về kiểu void.

c. Số lượng params và parameter lúc khai báo phương thức phải như nhau, và phải tương thích kiểu (tương tự câu lệnh gán) nếu khác lượng params thì báo lỗi Undeclared Method

(hình như là cũng chưa cần làm, nguồn: đăng nhập vào sakai rồi xem link sau: https://elearning.cse.hcmut.edu.vn/portal/tool/18089505-e588-4143-ac43-9420ce866699/posts/list/0/6676.page#42177)

5.

case class Return(val expr: Expr) extends Stmt {…}

def visit(ast: Return, c: Context): Object = {…}

Câu lệnh return, expr trong return phải trả về kiểu dữ liệu tương thích với returnType của phương thức (method) đang được hiện thực. chỉ cần kiểm tra expr có hợp lệ không, không cần kiểm tra với returnType của method(nguồn như trên)

____

f. Type Mismatch In Expression:

An expression must conform the type rules for expressions, otherwise the error message “Type Mismatch In Expression: ”+<expression> is released.

The type rules for expression are as follows:

– For an array subscripting E1[E2], E1 must be in array type and E2 must be integer.

– For a binary and unary expression, the type rules are described in the BKOOL specification.

– For a method call E.<method name>(<args>), E must be in class type; the callee <method name> must have non-void as return type and the number of arguments <args> must be equal to that of callee parameters. The type rules for arguments and parameters are the same as those mentioned in a procedure call.

– For an attribute access E.id, E must be in class type.

____

1.

case class ArrayCell(name: Expr, expr: Expr) extends LHS {…}

def visit(ast: ArrayCell, c: Context): Object = {…}

Khi lấy phần tử của mảng name[expr]:

a. name phải là kiểu array

b. expr phải là kiểu integer.

2.

case class BinaryOp(op: String, left: Expr, right: Expr) extends Expr {…}

case class UnaryOp(op: String, body: Expr) extends Expr {…}

def visit(ast: BinaryOp, c: Context): Object = {…}

def visit(ast: UnaryOp, c: Context): Object = {…}

Đối với biểu thức binary và unary, các luật được đặc tả trong BKOOL.pdf (phần này dài,  nhưng không khó các bạn tự tham khảo lại trong đặc tả, nếu đưa vào đây sẽ làm loãng bài viết)

3.

case class CallExpr(val cName: Expr, val method: Id, val params: List[Expr]) extends LHS {…}

def visit(ast: CallExpr, c: Context): Object = {…}

Biểu thức gọi hàm cName.method(params): cũng tương tự như câu lệnh gọi hàm, nhưng kiểu trả về của phương thức được gọi phải khác void

vì chỉ chứa literal nên cũng không có CallExpr

4.

case class FieldAccess(name: Expr, field: Id) extends LHS {…}

def visit(ast: FieldAccess, c: Context): Object = {…}

Truy xuất thuộc tính name.field: name phải là kiểu class (hình như không cần quan tâm field có phải là thuộc tính của name hay không?? Không thấy đặc tả nhắc đến!)

vì LHS chỉ chứa biến toàn cục, và expression thì chỉ có literal, nên cũng không cần tới cái này

Cuối cùng, xin chúc các bạn hoàn thành tốt Phase 1 này!

-anKra-

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

w

Connecting to %s