Subversion Repositories c16

IN_RX_DATA              = 0x00          ;

IN_STATUS               = 0x01          ;

IN_TEMPERAT             = 0x02          ;

IN_DIP_SWITCH           = 0x03          ;

IN_CLK_CTR_LOW          = 0x05          ;

IN_CLK_CTR_HIGH         = 0x06          ;

MEMTOP  =0x2000

OUT_TX_DATA             = 0x00          ;

OUT_LEDS                = 0x02          ;

OUT_INT_MASK            = 0x03          ;

OUT_RESET_TIMER         = 0x04          ;

OUT_START_CLK_CTR       = 0x05          ;

OUT_STOP_CLK_CTR        = 0x06          ;

;---------------------------------------;

        MOVE    #MEMTOP, RR             ;

        MOVE    RR, SP                  ;

        EI                              ;

        JMP     Cmain                   ;

        JMP     Cinterrupt              ;

;---------------------------------------;

mult_div:                               ;

        MD_STP                          ; 1

        MD_STP                          ; 2

        MD_STP                          ; 3

        MD_STP                          ; 4

        MD_STP                          ; 5

        MD_STP                          ; 6

        MD_STP                          ; 7

        MD_STP                          ; 8

        MD_STP                          ; 9

        MD_STP                          ; 10

        MD_STP                          ; 11

        MD_STP                          ; 12

        MD_STP                          ; 13

        MD_STP                          ; 14

        MD_STP                          ; 15

        MD_STP                          ; 16

        RET                             ;

;---------------------------------------;

;;; { 0 Declaration

;;;   { 1 TypeSpecifier (enum)

;;;     spec = anonymous enum (2000000)

;;;   } 1 TypeSpecifier (enum)

;;; } 0 Declaration

;;; ------------------------------------;

;;; { 0 Declaration

;;;   { 1 TypeSpecifier (struct/union)

;;;     spec = typedef struct '_task' (800001)

;;;     name = _task

;;;   } 1 TypeSpecifier (struct/union)

;;; } 0 Declaration

;;; ------------------------------------;

;;; { 0 Declaration

;;;   { 1 TypeSpecifier (struct/union)

;;;     spec = typedef struct '_semaphore' (800001)

;;;     name = _semaphore

;;;   } 1 TypeSpecifier (struct/union)

;;; } 0 Declaration

;;; ------------------------------------;

;;; { 0 Declaration

;;;   { 1 TypeSpecifier (struct/union)

;;;     spec = struct '_task' (800000)

;;;     name = _task

;;;   } 1 TypeSpecifier (struct/union)

;;; } 0 Declaration

;;; ------------------------------------;

;;; { 0 Declaration

;;;   { 1 TypeSpecifier (struct/union)

;;;     spec = extern 'Task' (4000002)

;;;     name = Task

;;;   } 1 TypeSpecifier (struct/union)

        .EXTERN Ccurrent_task

;;; } 0 Declaration

;;; ------------------------------------;

;;; { 0 Declaration

;;;   { 1 TypeSpecifier (struct/union)

;;;     spec = extern 'Task' (4000002)

;;;     name = Task

;;;   } 1 TypeSpecifier (struct/union)

        .EXTERN Ctask_idle

;;; } 0 Declaration

;;; ------------------------------------;

;;; { 0 Declaration

;;;   { 1 TypeSpecifier (struct/union)

;;;     spec = struct '_semaphore' (800000)

;;;     name = _semaphore

;;;   } 1 TypeSpecifier (struct/union)

;;; } 0 Declaration

;;; ------------------------------------;

;;; { 0 Declaration

;;;   { 1 TypeSpecifier (struct/union)

;;;     spec = 'Semaphore' (4000000)

;;;     name = Semaphore

;;;   } 1 TypeSpecifier (struct/union)

Crx_sema:                       ;

        .WORD   0

        .WORD   0

        .WORD   0

        .WORD   Cstr_0

;;; } 0 Declaration

;;; ------------------------------------;

;;; { 0 Declaration

;;;   { 1 TypeSpecifier (struct/union)

;;;     spec = 'Semaphore' (4000000)

;;;     name = Semaphore

;;;   } 1 TypeSpecifier (struct/union)

Ct2_control:                    ;

        .WORD   0

        .WORD   0

        .WORD   0

        .WORD   Cstr_1

;;; } 0 Declaration

;;; ------------------------------------;

;;; { 0 Declaration

;;;   { 1 TypeSpecifier (struct/union)

;;;     spec = 'Semaphore' (4000000)

;;;     name = Semaphore

;;;   } 1 TypeSpecifier (struct/union)

Ct3_control:                    ;

        .WORD   0

        .WORD   0

        .WORD   0

        .WORD   Cstr_2

;;; } 0 Declaration

;;; ------------------------------------;

;;; { 0 Declaration

;;;   { 1 TypeSpecifier (struct/union)

;;;     spec = 'Semaphore' (4000000)

;;;     name = Semaphore

;;;   } 1 TypeSpecifier (struct/union)

Cserial_out:                    ;

        .WORD   1

        .WORD   0

        .WORD   0

        .WORD   Cstr_3

;;; } 0 Declaration

;;; ------------------------------------;

;;; { 0 Declaration

;;;   { 1 TypeSpecifier (struct/union)

;;;     spec = 'Semaphore' (4000000)

;;;     name = Semaphore

;;;   } 1 TypeSpecifier (struct/union)

Ctx_sema:                       ;

        .WORD   16

        .WORD   0

        .WORD   0

        .WORD   Cstr_4

;;; } 0 Declaration

;;; ------------------------------------;

;;; { 0 FunctionDefinition

;;;   { 1 TypeName

;;;     { 2 TypeSpecifier (all)

;;;       spec = void (10000)

;;;     } 2 TypeSpecifier (all)

;;;     { 2 List

;;;       { 3 DeclItem

;;;         what = DECL_NAME

;;;         name = switch_tasks

;;;       } 3 DeclItem

;;;     } 2 List

;;;   } 1 TypeName

;;;   { 1 List

;;;     { 2 DeclItem

;;;       what = DECL_NAME

;;;       name = switch_tasks

;;;     } 2 DeclItem

;;;     { 2 DeclItem

;;;       what = DECL_FUN

;;;     } 2 DeclItem

;;;   } 1 List

Cswitch_tasks:

;;;   { 1 CompoundStatement

;;;     { 2 InitDeclarator

;;;       { 3 List

;;;         { 4 DeclItem

;;;           what = DECL_POINTER

;;;           { 5 List

;;;             { 6 Ptr

;;;             } 6 Ptr

;;;           } 5 List

;;;         } 4 DeclItem

;;;         { 4 DeclItem

;;;           what = DECL_NAME

;;;           name = next

;;;         } 4 DeclItem

;;;       } 3 List

;;;       { 3 Initializer (skalar)

;--     push_zero 2 bytes

        CLRW    -(SP)

;;;       } 3 Initializer (skalar)

;;;     } 2 InitDeclarator

;;;     { 2 InitDeclarator

;;;       { 3 List

;;;         { 4 DeclItem

;;;           what = DECL_POINTER

;;;           { 5 List

;;;             { 6 Ptr

;;;             } 6 Ptr

;;;           } 5 List

;;;         } 4 DeclItem

;;;         { 4 DeclItem

;;;           what = DECL_NAME

;;;           name = t

;;;         } 4 DeclItem

;;;       } 3 List

;;;       { 3 Initializer (skalar)

;;;         { 4 Expression (variable name)

;;;           expr_type = "identifier" (current_task)

;--     load_rr_var current_task, (16 bit)

        MOVE    (Ccurrent_task), RR

;;;         } 4 Expression (variable name)

;--     push_rr (16 bit)

        MOVE    RR, -(SP)

;;;       } 3 Initializer (skalar)

;;;     } 2 InitDeclarator

;;;     { 2 List

;;;       { 3 ExpressionStatement

st_loop:

        MOVE    0(SP), RR               ; RR = t

        MOVE    (RR), RR                ; RR = t->next_task

        MOVE    RR, 0(SP)               ; t  = t->next_task

        ADD     RR, #4                  ; RR = & t->status

        MOVE    (RR), RS                ; RR = t->status

        JMP     RRNZ, st_next_task      ; jump if (status != 0)

                                        ;

        MOVE    2(SP), RR               ; RR = next

        JMP     RRZ, st_accept          ; jump if (next == 0)

                                        ;

        ADD     RR, #5                  ; RR = & next->priority

        MOVE    (RR), RS                ; RR = next->priority

        MOVE    RR, LL                  ; LL = next->priority

        MOVE    0(SP), RR               ; RR = t

        ADD     RR, #5                  ; RR = & t->priority

        MOVE    (RR), RS                ; RR = t->priority

        SGT     LL, RR                  ; RR = (next->priority > t->priority)

        JMP     RRNZ, st_next_task      ; jump if (next->priority > t->priority)

st_accept:                              ;

        MOVE    0(SP), RR               ; RR = t

        MOVE    RR, 2(SP)               ; next = t

st_next_task:                           ;

        MOVE    0(SP), RR               ; RR = t

        MOVE    (Ccurrent_task), LL     ; LL = current_task

        SNE     LL, RR                  ; RR = (t != current_task)

        JMP     RRNZ, st_loop           ;

;;;       } 3 ExpressionStatement

;;;       { 3 IfElseStatement

;;;         { 4 Expr l != r

;;;           { 5 TypeName

;;;             { 6 TypeSpecifier (struct/union)

;;;               spec = struct '_task' (800000)

;;;               name = _task

;;;             } 6 TypeSpecifier (struct/union)

;;;             { 6 List

;;;               { 7 DeclItem

;;;                 what = DECL_POINTER

;;;                 { 8 List

;;;                   { 9 Ptr

;;;                   } 9 Ptr

;;;                 } 8 List

;;;               } 7 DeclItem

;;;               { 7 DeclItem

;;;                 what = DECL_NAME

;;;                 name = current_task

;;;               } 7 DeclItem

;;;             } 6 List

;;;           } 5 TypeName

;;;           { 5 Expression (variable name)

;;;             expr_type = "identifier" (current_task)

;--     load_rr_var current_task, (16 bit)

        MOVE    (Ccurrent_task), RR

;;;           } 5 Expression (variable name)

;--     move_rr_to_ll

        MOVE    RR, LL

;;;           { 5 Expression (variable name)

;;;             expr_type = "identifier" (next)

;--     load_rr_var next = -2(FP), SP at -4 (16 bit)

        MOVE    2(SP), RR

;;;           } 5 Expression (variable name)

;--     l != r

        SNE     LL, RR

;;;         } 4 Expr l != r

;--     branch_false

        JMP     RRZ, L2_endif_1

;;;         { 4 CompoundStatement

;;;           { 5 List

;;;             { 6 ExpressionStatement

;;;               { 7 Expr l = r

;;;                 { 8 TypeName

;;;                   { 9 TypeSpecifier (all)

;;;                     spec = int (80000)

;;;                   } 9 TypeSpecifier (all)

;;;                   { 9 List

;;;                     { 10 DeclItem

;;;                       what = DECL_POINTER

;;;                       { 11 List

;;;                         { 12 Ptr

;;;                         } 12 Ptr

;;;                       } 11 List

;;;                     } 10 DeclItem

;;;                     { 10 DeclItem

;;;                       what = DECL_NAME

;;;                       name = stack_pointer

;;;                     } 10 DeclItem

;;;                   } 9 List

;;;                 } 8 TypeName

;;;                 { 8 Expression (cast)r

        LEA  0(SP), RR

;;;                 } 8 Expression (cast)r

;--     push_rr (16 bit)

        MOVE    RR, -(SP)

;;;                 { 8 Expr * r

;;;                   { 9 Expression (variable name)

;;;                     expr_type = "identifier" (current_task)

;--     load_rr_var current_task, (16 bit)

        MOVE    (Ccurrent_task), RR

;;;                   } 9 Expression (variable name)

;;;                 } 8 Expr * r

;--     + (member)

        ADD     RR, #0x0002

;--     move_rr_to_ll

        MOVE    RR, LL

;--     pop_rr (16 bit)

        MOVE    (SP)+, RR

;--     assign (16 bit)

        MOVE    RR, (LL)

;;;               } 7 Expr l = r

;;;             } 6 ExpressionStatement

;;;             { 6 ExpressionStatement

;;;               { 7 Expr l = r

;;;                 { 8 TypeName

;;;                   { 9 TypeSpecifier (struct/union)

;;;                     spec = struct '_task' (800000)

;;;                     name = _task

;;;                   } 9 TypeSpecifier (struct/union)

;;;                   { 9 List

;;;                     { 10 DeclItem

;;;                       what = DECL_POINTER

;;;                       { 11 List

;;;                         { 12 Ptr

;;;                         } 12 Ptr

;;;                       } 11 List

;;;                     } 10 DeclItem

;;;                     { 10 DeclItem

;;;                       what = DECL_NAME

;;;                       name = current_task

;;;                     } 10 DeclItem

;;;                   } 9 List

;;;                 } 8 TypeName

;;;                 { 8 Expression (variable name)

;;;                   expr_type = "identifier" (next)

;--     load_rr_var next = -2(FP), SP at -4 (16 bit)

        MOVE    2(SP), RR

;;;                 } 8 Expression (variable name)

;--     store_rr_var current_task

        MOVE    RR, (Ccurrent_task)

;;;               } 7 Expr l = r

;;;             } 6 ExpressionStatement

;;;             { 6 ExpressionStatement

;;;               { 7 Expr * r

;;;                 { 8 Expression (variable name)

;;;                   expr_type = "identifier" (current_task)

;--     load_rr_var current_task, (16 bit)

        MOVE    (Ccurrent_task), RR

;;;                 } 8 Expression (variable name)

;;;               } 7 Expr * r

;--     + (member)

        ADD     RR, #0x0002

;--     content

        MOVE    (RR), RR

;;;             } 6 ExpressionStatement

;;;             { 6 ExpressionStatement

        MOVE RR, SP

;;;             } 6 ExpressionStatement

;;;           } 5 List

;--     pop 0 bytes

;;;         } 4 CompoundStatement

L2_endif_1:

;;;       } 3 IfElseStatement

;;;     } 2 List

;--     pop 4 bytes

        ADD     SP, #4

;;;   } 1 CompoundStatement

;--     ret

        RET

;;; ------------------------------------;

;;;   { 1 FunctionDefinition

;;;     { 2 TypeName

;;;       { 3 TypeSpecifier (all)

;;;         spec = void (10000)

;;;       } 3 TypeSpecifier (all)

;;;       { 3 List

;;;         { 4 DeclItem

;;;           what = DECL_NAME

;;;           name = P

;;;         } 4 DeclItem

;;;       } 3 List

;;;     } 2 TypeName

;;;     { 2 List

;;;       { 3 DeclItem

;;;         what = DECL_NAME

;;;         name = P

;;;       } 3 DeclItem

;;;       { 3 DeclItem

;;;         what = DECL_FUN

;;;         { 4 List

;;;           { 5 ParameterDeclaration

;;;             isEllipsis = false

;;;             { 6 TypeName

;;;               { 7 TypeSpecifier (struct/union)

;;;                 spec = struct '_semaphore' (800000)

;;;                 name = _semaphore

;;;               } 7 TypeSpecifier (struct/union)

;;;               { 7 List

;;;                 { 8 DeclItem

;;;                   what = DECL_POINTER

;;;                   { 9 List

;;;                     { 10 Ptr

;;;                     } 10 Ptr

;;;                   } 9 List

;;;                 } 8 DeclItem

;;;                 { 8 DeclItem

;;;                   what = DECL_NAME

;;;                   name = sema

;;;                 } 8 DeclItem

;;;               } 7 List

;;;             } 6 TypeName

;;;           } 5 ParameterDeclaration

;;;         } 4 List

;;;       } 3 DeclItem

;;;     } 2 List

CP:

;;;     { 2 CompoundStatement

;;;       { 3 List

;;;         { 4 ExpressionStatement

        DI

;;;         } 4 ExpressionStatement

;;;         { 4 IfElseStatement

;;;           { 5 Expr l < r

;;;             { 6 TypeName (internal)

;;;               { 7 TypeSpecifier (all)

;;;                 spec = int (80000)

;;;               } 7 TypeSpecifier (all)

;;;             } 6 TypeName (internal)

;;;             { 6 Expr --r

;;;               { 7 Expr * r

;;;                 { 8 Expression (variable name)

;;;                   expr_type = "identifier" (sema)

;--     load_rr_var sema = 2(FP), SP at 0 (16 bit)

        MOVE    2(SP), RR

;;;                 } 8 Expression (variable name)

;;;               } 7 Expr * r

;--     + (member)

;--     move_rr_to_ll

        MOVE    RR, LL

;--     content

        MOVE    (RR), RR

;--     --

        SUB     RR, #0x0001

;--     assign (16 bit)

        MOVE    RR, (LL)

;;;             } 6 Expr --r

;--     l < r

        SLT     RR, #0x0000

;;;           } 5 Expr l < r

;--     branch_false

        JMP     RRZ, L3_endif_2

;;;           { 5 CompoundStatement

;;;             { 6 List

;;;               { 7 ExpressionStatement

;;;                 { 8 Expr l = r

;;;                   { 9 TypeName

;;;                     { 10 TypeSpecifier (struct/union)

;;;                       spec = struct '_semaphore' (800000)

;;;                       name = _semaphore

;;;                     } 10 TypeSpecifier (struct/union)

;;;                     { 10 List

;;;                       { 11 DeclItem

;;;                         what = DECL_POINTER

;;;                         { 12 List

;;;                           { 13 Ptr

;;;                           } 13 Ptr

;;;                         } 12 List

;;;                       } 11 DeclItem

;;;                       { 11 DeclItem

;;;                         what = DECL_NAME

;;;                         name = waiting_for

;;;                       } 11 DeclItem

;;;                     } 10 List

;;;                   } 9 TypeName

;;;                   { 9 Expression (variable name)

;;;                     expr_type = "identifier" (sema)

;--     load_rr_var sema = 2(FP), SP at 0 (16 bit)

        MOVE    2(SP), RR

;;;                   } 9 Expression (variable name)

;--     push_rr (16 bit)

        MOVE    RR, -(SP)

;;;                   { 9 Expr * r

;;;                     { 10 Expression (variable name)

;;;                       expr_type = "identifier" (current_task)

;--     load_rr_var current_task, (16 bit)

        MOVE    (Ccurrent_task), RR

;;;                     } 10 Expression (variable name)

;;;                   } 9 Expr * r

;--     + (member)

        ADD     RR, #0x000E

;--     move_rr_to_ll

        MOVE    RR, LL

;--     pop_rr (16 bit)

        MOVE    (SP)+, RR

;--     assign (16 bit)

        MOVE    RR, (LL)

;;;                 } 8 Expr l = r

;;;               } 7 ExpressionStatement

;;;               { 7 ExpressionStatement

;;;                 { 8 Expr l = r

;;;                   { 9 TypeName

;;;                     { 10 TypeSpecifier (struct/union)

;;;                       spec = struct '_task' (800000)

;;;                       name = _task

;;;                     } 10 TypeSpecifier (struct/union)

;;;                     { 10 List

;;;                       { 11 DeclItem

;;;                         what = DECL_POINTER

;;;                         { 12 List

;;;                           { 13 Ptr

;;;                           } 13 Ptr

;;;                         } 12 List

;;;                       } 11 DeclItem

;;;                       { 11 DeclItem

;;;                         what = DECL_NAME

;;;                         name = next_waiting_task

;;;                       } 11 DeclItem

;;;                     } 10 List

;;;                   } 9 TypeName

;;;                   { 9 NumericExpression (constant 0 = 0x0)

;--     load_rr_constant

        MOVE    #0x0000, RR

;;;                   } 9 NumericExpression (constant 0 = 0x0)

;--     push_rr (16 bit)

        MOVE    RR, -(SP)

;;;                   { 9 Expr * r

;;;                     { 10 Expression (variable name)

;;;                       expr_type = "identifier" (current_task)

;--     load_rr_var current_task, (16 bit)

        MOVE    (Ccurrent_task), RR

;;;                     } 10 Expression (variable name)

;;;                   } 9 Expr * r

;--     + (member)

        ADD     RR, #0x0010

;--     move_rr_to_ll

        MOVE    RR, LL

;--     pop_rr (16 bit)

        MOVE    (SP)+, RR

;--     assign (16 bit)

        MOVE    RR, (LL)

;;;                 } 8 Expr l = r

;;;               } 7 ExpressionStatement

;;;               { 7 ExpressionStatement

;;;                 { 8 Expr l | r

;;;                   { 9 TypeName

;;;                     { 10 TypeSpecifier (all)

;;;                       spec = char (20000)

;;;                     } 10 TypeSpecifier (all)

;;;                     { 10 List

;;;                       { 11 DeclItem

;;;                         what = DECL_NAME

;;;                         name = status

;;;                       } 11 DeclItem

;;;                     } 10 List

;;;                   } 9 TypeName

;;;                   { 9 Expr l | r

;;;                     { 10 TypeName (internal)

;;;                       { 11 TypeSpecifier (all)

;;;                         spec = int (80000)

;;;                       } 11 TypeSpecifier (all)

;;;                     } 10 TypeName (internal)

;;;                     { 10 Expr * r

;;;                       { 11 Expression (variable name)

;;;                         expr_type = "identifier" (current_task)

;--     load_rr_var current_task, (16 bit)

        MOVE    (Ccurrent_task), RR

;;;                       } 11 Expression (variable name)

;;;                     } 10 Expr * r

;--     + (member)

        ADD     RR, #0x0004

;--     content

        MOVE    (RR), RS

;--     l | r

        OR      RR, #0x0001

;;;                   } 9 Expr l | r

;--     push_rr (8 bit)

        MOVE    R, -(SP)

;;;                   { 9 Expr * r

;;;                     { 10 Expression (variable name)

;;;                       expr_type = "identifier" (current_task)

;--     load_rr_var current_task, (16 bit)

        MOVE    (Ccurrent_task), RR

;;;                     } 10 Expression (variable name)

;;;                   } 9 Expr * r

;--     + (member)

        ADD     RR, #0x0004

;--     move_rr_to_ll

        MOVE    RR, LL

;--     pop_rr (8 bit)

        MOVE    (SP)+, RS

;--     assign (8 bit)

        MOVE    R, (LL)

;;;                 } 8 Expr l | r

;;;               } 7 ExpressionStatement

;;;               { 7 IfElseStatement

;;;                 { 8 Expr * r

;;;                   { 9 Expression (variable name)

;;;                     expr_type = "identifier" (sema)

;--     load_rr_var sema = 2(FP), SP at 0 (16 bit)

        MOVE    2(SP), RR

;;;                   } 9 Expression (variable name)

;;;                 } 8 Expr * r

;--     + (member)

        ADD     RR, #0x0002

;--     content

        MOVE    (RR), RR

;--     branch_false

        JMP     RRZ, L3_else_3

;;;                 { 8 ExpressionStatement

;;;                   { 9 Expr l = r

;;;                     { 10 TypeName

;;;                       { 11 TypeSpecifier (struct/union)

;;;                         spec = struct '_task' (800000)

;;;                         name = _task

;;;                       } 11 TypeSpecifier (struct/union)

;;;                       { 11 List

;;;                         { 12 DeclItem

;;;                           what = DECL_POINTER

;;;                           { 13 List

;;;                             { 14 Ptr

;;;                             } 14 Ptr

;;;                           } 13 List

;;;                         } 12 DeclItem

;;;                         { 12 DeclItem

;;;                           what = DECL_NAME

;;;                           name = next_waiting_task

;;;                         } 12 DeclItem

;;;                       } 11 List

;;;                     } 10 TypeName

;;;                     { 10 Expression (variable name)

;;;                       expr_type = "identifier" (current_task)

;--     load_rr_var current_task, (16 bit)

        MOVE    (Ccurrent_task), RR

;;;                     } 10 Expression (variable name)

;--     push_rr (16 bit)

        MOVE    RR, -(SP)

;;;                     { 10 Expr * r

;;;                       { 11 Expr * r

;;;                         { 12 Expression (variable name)

;;;                           expr_type = "identifier" (sema)

;--     load_rr_var sema = 2(FP), SP at -2 (16 bit)

        MOVE    4(SP), RR

;;;                         } 12 Expression (variable name)

;;;                       } 11 Expr * r

;--     + (member)

        ADD     RR, #0x0004

;--     content

        MOVE    (RR), RR

;;;                     } 10 Expr * r

;--     + (member)

        ADD     RR, #0x0010

;--     move_rr_to_ll

        MOVE    RR, LL

;--     pop_rr (16 bit)

        MOVE    (SP)+, RR

;--     assign (16 bit)

        MOVE    RR, (LL)

;;;                   } 9 Expr l = r

;;;                 } 8 ExpressionStatement

;--     branch

        JMP     L3_endif_3

L3_else_3:

;;;                 { 8 ExpressionStatement

;;;                   { 9 Expr l = r

;;;                     { 10 TypeName

;;;                       { 11 TypeSpecifier (struct/union)

;;;                         spec = struct '_task' (800000)

;;;                         name = _task

;;;                       } 11 TypeSpecifier (struct/union)

;;;                       { 11 List

;;;                         { 12 DeclItem

;;;                           what = DECL_POINTER

;;;                           { 13 List

;;;                             { 14 Ptr

;;;                             } 14 Ptr

;;;                           } 13 List

;;;                         } 12 DeclItem

;;;                         { 12 DeclItem

;;;                           what = DECL_NAME

;;;                           name = next_waiting

;;;                         } 12 DeclItem

;;;                       } 11 List

;;;                     } 10 TypeName

;;;                     { 10 Expression (variable name)

;;;                       expr_type = "identifier" (current_task)

;--     load_rr_var current_task, (16 bit)

        MOVE    (Ccurrent_task), RR

;;;                     } 10 Expression (variable name)

;--     push_rr (16 bit)

        MOVE    RR, -(SP)

;;;                     { 10 Expr * r

;;;                       { 11 Expression (variable name)

;;;                         expr_type = "identifier" (sema)

;--     load_rr_var sema = 2(FP), SP at -2 (16 bit)

        MOVE    4(SP), RR

;;;                       } 11 Expression (variable name)

;;;                     } 10 Expr * r

;--     + (member)

        ADD     RR, #0x0002

;--     move_rr_to_ll

        MOVE    RR, LL

;--     pop_rr (16 bit)

        MOVE    (SP)+, RR

;--     assign (16 bit)

        MOVE    RR, (LL)

;;;                   } 9 Expr l = r

;;;                 } 8 ExpressionStatement

L3_endif_3:

;;;               } 7 IfElseStatement

;;;               { 7 ExpressionStatement

;;;                 { 8 Expr l = r

;;;                   { 9 TypeName

;;;                     { 10 TypeSpecifier (struct/union)

;;;                       spec = struct '_task' (800000)

;;;                       name = _task

;;;                     } 10 TypeSpecifier (struct/union)

;;;                     { 10 List

;;;                       { 11 DeclItem

;;;                         what = DECL_POINTER

;;;                         { 12 List

;;;                           { 13 Ptr

;;;                           } 13 Ptr

;;;                         } 12 List

;;;                       } 11 DeclItem

;;;                       { 11 DeclItem

;;;                         what = DECL_NAME

;;;                         name = last_waiting

;;;                       } 11 DeclItem

;;;                     } 10 List

;;;                   } 9 TypeName

;;;                   { 9 Expression (variable name)

;;;                     expr_type = "identifier" (current_task)

;--     load_rr_var current_task, (16 bit)

        MOVE    (Ccurrent_task), RR

;;;                   } 9 Expression (variable name)

;--     push_rr (16 bit)

        MOVE    RR, -(SP)

;;;                   { 9 Expr * r

;;;                     { 10 Expression (variable name)

;;;                       expr_type = "identifier" (sema)

;--     load_rr_var sema = 2(FP), SP at -2 (16 bit)

        MOVE    4(SP), RR

;;;                     } 10 Expression (variable name)

;;;                   } 9 Expr * r

;--     + (member)

        ADD     RR, #0x0004

;--     move_rr_to_ll

        MOVE    RR, LL

;--     pop_rr (16 bit)

        MOVE    (SP)+, RR

;--     assign (16 bit)

        MOVE    RR, (LL)

;;;                 } 8 Expr l = r

;;;               } 7 ExpressionStatement

;;;               { 7 ExpressionStatement

;;;                 { 8 Expr l(r)

;;;                   { 9 TypeName

;;;                     { 10 TypeSpecifier (all)

;;;                       spec = void (10000)

;;;                     } 10 TypeSpecifier (all)

;;;                     { 10 List

;;;                       { 11 DeclItem

;;;                         what = DECL_NAME

;;;                         name = switch_tasks

;;;                       } 11 DeclItem

;;;                     } 10 List

;;;                   } 9 TypeName

;--     push 0 bytes

;--     call

        CALL    Cswitch_tasks

;--     pop 0 bytes

;;;                 } 8 Expr l(r)

;;;               } 7 ExpressionStatement

;;;             } 6 List

;--     pop 0 bytes

;;;           } 5 CompoundStatement

L3_endif_2:

;;;         } 4 IfElseStatement

;;;         { 4 ExpressionStatement

        RETI

;;;         } 4 ExpressionStatement

;;;       } 3 List

;--     pop 0 bytes

;;;     } 2 CompoundStatement

;--     ret

        RET

;;; ------------------------------------;

;;;     { 2 FunctionDefinition

;;;       { 3 TypeName

;;;         { 4 TypeSpecifier (all)

;;;           spec = char (20000)

;;;         } 4 TypeSpecifier (all)

;;;         { 4 List

;;;           { 5 DeclItem

;;;             what = DECL_NAME

;;;             name = P_timed

;;;           } 5 DeclItem

;;;         } 4 List

;;;       } 3 TypeName

;;;       { 3 List

;;;         { 4 DeclItem

;;;           what = DECL_NAME

;;;           name = P_timed

;;;         } 4 DeclItem

;;;         { 4 DeclItem

;;;           what = DECL_FUN

;;;           { 5 List

;;;             { 6 ParameterDeclaration

;;;               isEllipsis = false

;;;               { 7 TypeName

;;;                 { 8 TypeSpecifier (struct/union)

;;;                   spec = struct '_semaphore' (800000)

;;;                   name = _semaphore

;;;                 } 8 TypeSpecifier (struct/union)

;;;                 { 8 List

;;;                   { 9 DeclItem

;;;                     what = DECL_POINTER

;;;                     { 10 List

;;;                       { 11 Ptr

;;;                       } 11 Ptr

;;;                     } 10 List

;;;                   } 9 DeclItem

;;;                   { 9 DeclItem

;;;                     what = DECL_NAME

;;;                     name = sema

;;;                   } 9 DeclItem

;;;                 } 8 List

;;;               } 7 TypeName

;;;             } 6 ParameterDeclaration

;;;             { 6 ParameterDeclaration

;;;               isEllipsis = false

;;;               { 7 TypeName

;;;                 { 8 TypeSpecifier (all)

;;;                   spec = unsigned int (82000)

;;;                 } 8 TypeSpecifier (all)

;;;                 { 8 List

;;;                   { 9 DeclItem

;;;                     what = DECL_NAME

;;;                     name = ticks

;;;                   } 9 DeclItem

;;;                 } 8 List

;;;               } 7 TypeName

;;;             } 6 ParameterDeclaration

;;;           } 5 List

;;;         } 4 DeclItem

;;;       } 3 List

CP_timed:

;;;       { 3 CompoundStatement

;;;         { 4 InitDeclarator

;;;           { 5 List

;;;             { 6 DeclItem

;;;               what = DECL_NAME

;;;               name = ret

;;;             } 6 DeclItem

;;;           } 5 List

;;;           { 5 Initializer (skalar)

;--     push_zero 1 bytes

        CLRB    -(SP)

;;;           } 5 Initializer (skalar)

;;;         } 4 InitDeclarator

;;;         { 4 List

;;;           { 5 ExpressionStatement

        DI

;;;           } 5 ExpressionStatement

;;;           { 5 IfElseStatement

;;;             { 6 Expr l < r

;;;               { 7 TypeName (internal)

;;;                 { 8 TypeSpecifier (all)

;;;                   spec = int (80000)

;;;                 } 8 TypeSpecifier (all)

;;;               } 7 TypeName (internal)

;;;               { 7 Expr --r

;;;                 { 8 Expr * r

;;;                   { 9 Expression (variable name)

;;;                     expr_type = "identifier" (sema)

;--     load_rr_var sema = 2(FP), SP at -1 (16 bit)

        MOVE    3(SP), RR

;;;                   } 9 Expression (variable name)

;;;                 } 8 Expr * r

;--     + (member)

;--     move_rr_to_ll

        MOVE    RR, LL

;--     content

        MOVE    (RR), RR

;--     --

        SUB     RR, #0x0001

;--     assign (16 bit)

        MOVE    RR, (LL)

;;;               } 7 Expr --r

;--     l < r

        SLT     RR, #0x0000

;;;             } 6 Expr l < r

;--     branch_false

        JMP     RRZ, L4_endif_4

;;;             { 6 CompoundStatement

;;;               { 7 List

;;;                 { 8 ExpressionStatement

;;;                   { 9 Expr l = r

;;;                     { 10 TypeName

;;;                       { 11 TypeSpecifier (struct/union)

;;;                         spec = struct '_semaphore' (800000)

;;;                         name = _semaphore

;;;                       } 11 TypeSpecifier (struct/union)

;;;                       { 11 List

;;;                         { 12 DeclItem

;;;                           what = DECL_POINTER

;;;                           { 13 List

;;;                             { 14 Ptr

;;;                             } 14 Ptr

;;;                           } 13 List

;;;                         } 12 DeclItem

;;;                         { 12 DeclItem

;;;                           what = DECL_NAME

;;;                           name = waiting_for

;;;                         } 12 DeclItem

;;;                       } 11 List

;;;                     } 10 TypeName

;;;                     { 10 Expression (variable name)

;;;                       expr_type = "identifier" (sema)

;--     load_rr_var sema = 2(FP), SP at -1 (16 bit)

        MOVE    3(SP), RR

;;;                     } 10 Expression (variable name)

;--     push_rr (16 bit)

        MOVE    RR, -(SP)

;;;                     { 10 Expr * r

;;;                       { 11 Expression (variable name)

;;;                         expr_type = "identifier" (current_task)

;--     load_rr_var current_task, (16 bit)

        MOVE    (Ccurrent_task), RR

;;;                       } 11 Expression (variable name)

;;;                     } 10 Expr * r

;--     + (member)

        ADD     RR, #0x000E

;--     move_rr_to_ll

        MOVE    RR, LL

;--     pop_rr (16 bit)

        MOVE    (SP)+, RR

;--     assign (16 bit)

        MOVE    RR, (LL)

;;;                   } 9 Expr l = r

;;;                 } 8 ExpressionStatement

;;;                 { 8 ExpressionStatement

;;;                   { 9 Expr l = r

;;;                     { 10 TypeName

;;;                       { 11 TypeSpecifier (all)

;;;                         spec = int (80000)

;;;                       } 11 TypeSpecifier (all)

;;;                       { 11 List

;;;                         { 12 DeclItem

;;;                           what = DECL_NAME

;;;                           name = sleep_count

;;;                         } 12 DeclItem

;;;                       } 11 List

;;;                     } 10 TypeName

;;;                     { 10 Expression (variable name)

;;;                       expr_type = "identifier" (ticks)

;--     load_rr_var ticks = 4(FP), SP at -1 (16 bit)

        MOVE    5(SP), RR

;;;                     } 10 Expression (variable name)

;--     push_rr (16 bit)

        MOVE    RR, -(SP)

;;;                     { 10 Expr * r

;;;                       { 11 Expression (variable name)

;;;                         expr_type = "identifier" (current_task)

;--     load_rr_var current_task, (16 bit)

        MOVE    (Ccurrent_task), RR

;;;                       } 11 Expression (variable name)

;;;                     } 10 Expr * r

;--     + (member)

        ADD     RR, #0x0012

;--     move_rr_to_ll

        MOVE    RR, LL

;--     pop_rr (16 bit)

        MOVE    (SP)+, RR

;--     assign (16 bit)

        MOVE    RR, (LL)

;;;                   } 9 Expr l = r

;;;                 } 8 ExpressionStatement

;;;                 { 8 ExpressionStatement

;;;                   { 9 Expr l = r

;;;                     { 10 TypeName

;;;                       { 11 TypeSpecifier (struct/union)

;;;                         spec = struct '_task' (800000)

;;;                         name = _task

;;;                       } 11 TypeSpecifier (struct/union)

;;;                       { 11 List

;;;                         { 12 DeclItem

;;;                           what = DECL_POINTER

;;;                           { 13 List

;;;                             { 14 Ptr

;;;                             } 14 Ptr

;;;                           } 13 List

;;;                         } 12 DeclItem

;;;                         { 12 DeclItem

;;;                           what = DECL_NAME

;;;                           name = next_waiting_task

;;;                         } 12 DeclItem

;;;                       } 11 List

;;;                     } 10 TypeName

;;;                     { 10 NumericExpression (constant 0 = 0x0)

;--     load_rr_constant

        MOVE    #0x0000, RR

;;;                     } 10 NumericExpression (constant 0 = 0x0)

;--     push_rr (16 bit)

        MOVE    RR, -(SP)

;;;                     { 10 Expr * r

;;;                       { 11 Expression (variable name)

;;;                         expr_type = "identifier" (current_task)

;--     load_rr_var current_task, (16 bit)

        MOVE    (Ccurrent_task), RR

;;;                       } 11 Expression (variable name)

;;;                     } 10 Expr * r

;--     + (member)

        ADD     RR, #0x0010

;--     move_rr_to_ll

        MOVE    RR, LL

;--     pop_rr (16 bit)

        MOVE    (SP)+, RR

;--     assign (16 bit)

        MOVE    RR, (LL)

;;;                   } 9 Expr l = r

;;;                 } 8 ExpressionStatement

;;;                 { 8 ExpressionStatement

;;;                   { 9 Expr l | r

;;;                     { 10 TypeName

;;;                       { 11 TypeSpecifier (all)

;;;                         spec = char (20000)

;;;                       } 11 TypeSpecifier (all)

;;;                       { 11 List

;;;                         { 12 DeclItem

;;;                           what = DECL_NAME

;;;                           name = status

;;;                         } 12 DeclItem

;;;                       } 11 List

;;;                     } 10 TypeName

;;;                     { 10 Expr l | r

;;;                       { 11 TypeName (internal)

;;;                         { 12 TypeSpecifier (all)

;;;                           spec = int (80000)

;;;                         } 12 TypeSpecifier (all)

;;;                       } 11 TypeName (internal)

;;;                       { 11 Expr * r

;;;                         { 12 Expression (variable name)

;;;                           expr_type = "identifier" (current_task)

;--     load_rr_var current_task, (16 bit)

        MOVE    (Ccurrent_task), RR

;;;                         } 12 Expression (variable name)

;;;                       } 11 Expr * r

;--     + (member)

        ADD     RR, #0x0004

;--     content

        MOVE    (RR), RS

;--     l | r

        OR      RR, #0x0003

;;;                     } 10 Expr l | r

;--     push_rr (8 bit)

        MOVE    R, -(SP)

;;;                     { 10 Expr * r

;;;                       { 11 Expression (variable name)

;;;                         expr_type = "identifier" (current_task)

;--     load_rr_var current_task, (16 bit)

        MOVE    (Ccurrent_task), RR