URL
https://opencores.org/ocsvn/c16/c16/trunk
Subversion Repositories c16
[/] [c16/] [trunk/] [rtos.asm] - Rev 33
Go to most recent revision | Compare with Previous | Blame | View Log
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<DeclItem>
;;; { 3 DeclItem
;;; what = DECL_NAME
;;; name = switch_tasks
;;; } 3 DeclItem
;;; } 2 List<DeclItem>
;;; } 1 TypeName
;;; { 1 List<DeclItem>
;;; { 2 DeclItem
;;; what = DECL_NAME
;;; name = switch_tasks
;;; } 2 DeclItem
;;; { 2 DeclItem
;;; what = DECL_FUN
;;; } 2 DeclItem
;;; } 1 List<DeclItem>
Cswitch_tasks:
;;; { 1 CompoundStatement
;;; { 2 InitDeclarator
;;; { 3 List<DeclItem>
;;; { 4 DeclItem
;;; what = DECL_POINTER
;;; { 5 List<Ptr>
;;; { 6 Ptr
;;; } 6 Ptr
;;; } 5 List<Ptr>
;;; } 4 DeclItem
;;; { 4 DeclItem
;;; what = DECL_NAME
;;; name = next
;;; } 4 DeclItem
;;; } 3 List<DeclItem>
;;; { 3 Initializer (skalar)
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 3 Initializer (skalar)
;;; } 2 InitDeclarator
;;; { 2 InitDeclarator
;;; { 3 List<DeclItem>
;;; { 4 DeclItem
;;; what = DECL_POINTER
;;; { 5 List<Ptr>
;;; { 6 Ptr
;;; } 6 Ptr
;;; } 5 List<Ptr>
;;; } 4 DeclItem
;;; { 4 DeclItem
;;; what = DECL_NAME
;;; name = t
;;; } 4 DeclItem
;;; } 3 List<DeclItem>
;;; { 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<ExpressionStatement>
;;; { 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<DeclItem>
;;; { 7 DeclItem
;;; what = DECL_POINTER
;;; { 8 List<Ptr>
;;; { 9 Ptr
;;; } 9 Ptr
;;; } 8 List<Ptr>
;;; } 7 DeclItem
;;; { 7 DeclItem
;;; what = DECL_NAME
;;; name = current_task
;;; } 7 DeclItem
;;; } 6 List<DeclItem>
;;; } 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<ExpressionStatement>
;;; { 6 ExpressionStatement
;;; { 7 Expr l = r
;;; { 8 TypeName
;;; { 9 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 9 TypeSpecifier (all)
;;; { 9 List<DeclItem>
;;; { 10 DeclItem
;;; what = DECL_POINTER
;;; { 11 List<Ptr>
;;; { 12 Ptr
;;; } 12 Ptr
;;; } 11 List<Ptr>
;;; } 10 DeclItem
;;; { 10 DeclItem
;;; what = DECL_NAME
;;; name = stack_pointer
;;; } 10 DeclItem
;;; } 9 List<DeclItem>
;;; } 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<DeclItem>
;;; { 10 DeclItem
;;; what = DECL_POINTER
;;; { 11 List<Ptr>
;;; { 12 Ptr
;;; } 12 Ptr
;;; } 11 List<Ptr>
;;; } 10 DeclItem
;;; { 10 DeclItem
;;; what = DECL_NAME
;;; name = current_task
;;; } 10 DeclItem
;;; } 9 List<DeclItem>
;;; } 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<ExpressionStatement>
;-- pop 0 bytes
;;; } 4 CompoundStatement
L2_endif_1:
;;; } 3 IfElseStatement
;;; } 2 List<ExpressionStatement>
;-- 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<DeclItem>
;;; { 4 DeclItem
;;; what = DECL_NAME
;;; name = P
;;; } 4 DeclItem
;;; } 3 List<DeclItem>
;;; } 2 TypeName
;;; { 2 List<DeclItem>
;;; { 3 DeclItem
;;; what = DECL_NAME
;;; name = P
;;; } 3 DeclItem
;;; { 3 DeclItem
;;; what = DECL_FUN
;;; { 4 List<ParameterDeclaration>
;;; { 5 ParameterDeclaration
;;; isEllipsis = false
;;; { 6 TypeName
;;; { 7 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 7 TypeSpecifier (struct/union)
;;; { 7 List<DeclItem>
;;; { 8 DeclItem
;;; what = DECL_POINTER
;;; { 9 List<Ptr>
;;; { 10 Ptr
;;; } 10 Ptr
;;; } 9 List<Ptr>
;;; } 8 DeclItem
;;; { 8 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 8 DeclItem
;;; } 7 List<DeclItem>
;;; } 6 TypeName
;;; } 5 ParameterDeclaration
;;; } 4 List<ParameterDeclaration>
;;; } 3 DeclItem
;;; } 2 List<DeclItem>
CP:
;;; { 2 CompoundStatement
;;; { 3 List<ExpressionStatement>
;;; { 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<ExpressionStatement>
;;; { 7 ExpressionStatement
;;; { 8 Expr l = r
;;; { 9 TypeName
;;; { 10 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 10 TypeSpecifier (struct/union)
;;; { 10 List<DeclItem>
;;; { 11 DeclItem
;;; what = DECL_POINTER
;;; { 12 List<Ptr>
;;; { 13 Ptr
;;; } 13 Ptr
;;; } 12 List<Ptr>
;;; } 11 DeclItem
;;; { 11 DeclItem
;;; what = DECL_NAME
;;; name = waiting_for
;;; } 11 DeclItem
;;; } 10 List<DeclItem>
;;; } 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<DeclItem>
;;; { 11 DeclItem
;;; what = DECL_POINTER
;;; { 12 List<Ptr>
;;; { 13 Ptr
;;; } 13 Ptr
;;; } 12 List<Ptr>
;;; } 11 DeclItem
;;; { 11 DeclItem
;;; what = DECL_NAME
;;; name = next_waiting_task
;;; } 11 DeclItem
;;; } 10 List<DeclItem>
;;; } 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<DeclItem>
;;; { 11 DeclItem
;;; what = DECL_NAME
;;; name = status
;;; } 11 DeclItem
;;; } 10 List<DeclItem>
;;; } 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<DeclItem>
;;; { 12 DeclItem
;;; what = DECL_POINTER
;;; { 13 List<Ptr>
;;; { 14 Ptr
;;; } 14 Ptr
;;; } 13 List<Ptr>
;;; } 12 DeclItem
;;; { 12 DeclItem
;;; what = DECL_NAME
;;; name = next_waiting_task
;;; } 12 DeclItem
;;; } 11 List<DeclItem>
;;; } 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<DeclItem>
;;; { 12 DeclItem
;;; what = DECL_POINTER
;;; { 13 List<Ptr>
;;; { 14 Ptr
;;; } 14 Ptr
;;; } 13 List<Ptr>
;;; } 12 DeclItem
;;; { 12 DeclItem
;;; what = DECL_NAME
;;; name = next_waiting
;;; } 12 DeclItem
;;; } 11 List<DeclItem>
;;; } 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<DeclItem>
;;; { 11 DeclItem
;;; what = DECL_POINTER
;;; { 12 List<Ptr>
;;; { 13 Ptr
;;; } 13 Ptr
;;; } 12 List<Ptr>
;;; } 11 DeclItem
;;; { 11 DeclItem
;;; what = DECL_NAME
;;; name = last_waiting
;;; } 11 DeclItem
;;; } 10 List<DeclItem>
;;; } 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<DeclItem>
;;; { 11 DeclItem
;;; what = DECL_NAME
;;; name = switch_tasks
;;; } 11 DeclItem
;;; } 10 List<DeclItem>
;;; } 9 TypeName
;-- push 0 bytes
;-- call
CALL Cswitch_tasks
;-- pop 0 bytes
;;; } 8 Expr l(r)
;;; } 7 ExpressionStatement
;;; } 6 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 5 CompoundStatement
L3_endif_2:
;;; } 4 IfElseStatement
;;; { 4 ExpressionStatement
RETI
;;; } 4 ExpressionStatement
;;; } 3 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 2 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 2 FunctionDefinition
;;; { 3 TypeName
;;; { 4 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 4 TypeSpecifier (all)
;;; { 4 List<DeclItem>
;;; { 5 DeclItem
;;; what = DECL_NAME
;;; name = P_timed
;;; } 5 DeclItem
;;; } 4 List<DeclItem>
;;; } 3 TypeName
;;; { 3 List<DeclItem>
;;; { 4 DeclItem
;;; what = DECL_NAME
;;; name = P_timed
;;; } 4 DeclItem
;;; { 4 DeclItem
;;; what = DECL_FUN
;;; { 5 List<ParameterDeclaration>
;;; { 6 ParameterDeclaration
;;; isEllipsis = false
;;; { 7 TypeName
;;; { 8 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 8 TypeSpecifier (struct/union)
;;; { 8 List<DeclItem>
;;; { 9 DeclItem
;;; what = DECL_POINTER
;;; { 10 List<Ptr>
;;; { 11 Ptr
;;; } 11 Ptr
;;; } 10 List<Ptr>
;;; } 9 DeclItem
;;; { 9 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 9 DeclItem
;;; } 8 List<DeclItem>
;;; } 7 TypeName
;;; } 6 ParameterDeclaration
;;; { 6 ParameterDeclaration
;;; isEllipsis = false
;;; { 7 TypeName
;;; { 8 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 8 TypeSpecifier (all)
;;; { 8 List<DeclItem>
;;; { 9 DeclItem
;;; what = DECL_NAME
;;; name = ticks
;;; } 9 DeclItem
;;; } 8 List<DeclItem>
;;; } 7 TypeName
;;; } 6 ParameterDeclaration
;;; } 5 List<ParameterDeclaration>
;;; } 4 DeclItem
;;; } 3 List<DeclItem>
CP_timed:
;;; { 3 CompoundStatement
;;; { 4 InitDeclarator
;;; { 5 List<DeclItem>
;;; { 6 DeclItem
;;; what = DECL_NAME
;;; name = ret
;;; } 6 DeclItem
;;; } 5 List<DeclItem>
;;; { 5 Initializer (skalar)
;-- push_zero 1 bytes
CLRB -(SP)
;;; } 5 Initializer (skalar)
;;; } 4 InitDeclarator
;;; { 4 List<ExpressionStatement>
;;; { 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<ExpressionStatement>
;;; { 8 ExpressionStatement
;;; { 9 Expr l = r
;;; { 10 TypeName
;;; { 11 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 11 TypeSpecifier (struct/union)
;;; { 11 List<DeclItem>
;;; { 12 DeclItem
;;; what = DECL_POINTER
;;; { 13 List<Ptr>
;;; { 14 Ptr
;;; } 14 Ptr
;;; } 13 List<Ptr>
;;; } 12 DeclItem
;;; { 12 DeclItem
;;; what = DECL_NAME
;;; name = waiting_for
;;; } 12 DeclItem
;;; } 11 List<DeclItem>
;;; } 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<DeclItem>
;;; { 12 DeclItem
;;; what = DECL_NAME
;;; name = sleep_count
;;; } 12 DeclItem
;;; } 11 List<DeclItem>
;;; } 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<DeclItem>
;;; { 12 DeclItem
;;; what = DECL_POINTER
;;; { 13 List<Ptr>
;;; { 14 Ptr
;;; } 14 Ptr
;;; } 13 List<Ptr>
;;; } 12 DeclItem
;;; { 12 DeclItem
;;; what = DECL_NAME
;;; name = next_waiting_task
;;; } 12 DeclItem
;;; } 11 List<DeclItem>
;;; } 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<DeclItem>
;;; { 12 DeclItem
;;; what = DECL_NAME
;;; name = status
;;; } 12 DeclItem
;;; } 11 List<DeclItem>
;;; } 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
;;; } 11 Expression (variable name)
;;; } 10 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)
;;; } 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<DeclItem>
;;; { 12 DeclItem
;;; what = DECL_NAME
;;; name = sema_ret
;;; } 12 DeclItem
;;; } 11 List<DeclItem>
;;; } 10 TypeName
;;; { 10 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 10 NumericExpression (constant 0 = 0x0)
;-- 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
;;; } 11 Expression (variable name)
;;; } 10 Expr * r
;-- + (member)
ADD RR, #0x000C
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (8 bit)
MOVE (SP)+, RS
;-- assign (8 bit)
MOVE R, (LL)
;;; } 9 Expr l = r
;;; } 8 ExpressionStatement
;;; { 8 IfElseStatement
;;; { 9 Expr * r
;;; { 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)
;;; } 9 Expr * r
;-- + (member)
ADD RR, #0x0002
;-- content
MOVE (RR), RR
;-- branch_false
JMP RRZ, L4_else_5
;;; { 9 ExpressionStatement
;;; { 10 Expr l = r
;;; { 11 TypeName
;;; { 12 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 12 TypeSpecifier (struct/union)
;;; { 12 List<DeclItem>
;;; { 13 DeclItem
;;; what = DECL_POINTER
;;; { 14 List<Ptr>
;;; { 15 Ptr
;;; } 15 Ptr
;;; } 14 List<Ptr>
;;; } 13 DeclItem
;;; { 13 DeclItem
;;; what = DECL_NAME
;;; name = next_waiting_task
;;; } 13 DeclItem
;;; } 12 List<DeclItem>
;;; } 11 TypeName
;;; { 11 Expression (variable name)
;;; expr_type = "identifier" (current_task)
;-- load_rr_var current_task, (16 bit)
MOVE (Ccurrent_task), RR
;;; } 11 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 11 Expr * r
;;; { 12 Expr * r
;;; { 13 Expression (variable name)
;;; expr_type = "identifier" (sema)
;-- load_rr_var sema = 2(FP), SP at -3 (16 bit)
MOVE 5(SP), RR
;;; } 13 Expression (variable name)
;;; } 12 Expr * r
;-- + (member)
ADD RR, #0x0004
;-- content
MOVE (RR), RR
;;; } 11 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)
;;; } 10 Expr l = r
;;; } 9 ExpressionStatement
;-- branch
JMP L4_endif_5
L4_else_5:
;;; { 9 ExpressionStatement
;;; { 10 Expr l = r
;;; { 11 TypeName
;;; { 12 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 12 TypeSpecifier (struct/union)
;;; { 12 List<DeclItem>
;;; { 13 DeclItem
;;; what = DECL_POINTER
;;; { 14 List<Ptr>
;;; { 15 Ptr
;;; } 15 Ptr
;;; } 14 List<Ptr>
;;; } 13 DeclItem
;;; { 13 DeclItem
;;; what = DECL_NAME
;;; name = next_waiting
;;; } 13 DeclItem
;;; } 12 List<DeclItem>
;;; } 11 TypeName
;;; { 11 Expression (variable name)
;;; expr_type = "identifier" (current_task)
;-- load_rr_var current_task, (16 bit)
MOVE (Ccurrent_task), RR
;;; } 11 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 11 Expr * r
;;; { 12 Expression (variable name)
;;; expr_type = "identifier" (sema)
;-- load_rr_var sema = 2(FP), SP at -3 (16 bit)
MOVE 5(SP), RR
;;; } 12 Expression (variable name)
;;; } 11 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)
;;; } 10 Expr l = r
;;; } 9 ExpressionStatement
L4_endif_5:
;;; } 8 IfElseStatement
;;; { 8 ExpressionStatement
;;; { 9 Expr l(r)
;;; { 10 TypeName
;;; { 11 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 11 TypeSpecifier (all)
;;; { 11 List<DeclItem>
;;; { 12 DeclItem
;;; what = DECL_NAME
;;; name = switch_tasks
;;; } 12 DeclItem
;;; } 11 List<DeclItem>
;;; } 10 TypeName
;-- push 0 bytes
;-- call
CALL Cswitch_tasks
;-- pop 0 bytes
;;; } 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<DeclItem>
;;; { 12 DeclItem
;;; what = DECL_NAME
;;; name = ret
;;; } 12 DeclItem
;;; } 11 List<DeclItem>
;;; } 10 TypeName
;;; { 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, #0x000C
;-- content
MOVE (RR), RS
;-- store_rr_var ret = -1(FP), SP at -1
MOVE R, 0(SP)
;;; } 9 Expr l = r
;;; } 8 ExpressionStatement
;;; } 7 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 6 CompoundStatement
L4_endif_4:
;;; } 5 IfElseStatement
;;; { 5 ExpressionStatement
EI
;;; } 5 ExpressionStatement
;;; { 5 return Statement
;;; { 6 Expression (variable name)
;;; expr_type = "identifier" (ret)
;-- load_rr_var ret = -1(FP), SP at -1 (8 bit)
MOVE 0(SP), RS
;;; } 6 Expression (variable name)
;-- ret
ADD SP, #1
RET
;;; } 5 return Statement
;;; } 4 List<ExpressionStatement>
;-- pop 1 bytes
ADD SP, #1
;;; } 3 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 3 FunctionDefinition
;;; { 4 TypeName
;;; { 5 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 5 TypeSpecifier (all)
;;; { 5 List<DeclItem>
;;; { 6 DeclItem
;;; what = DECL_NAME
;;; name = Vint
;;; } 6 DeclItem
;;; } 5 List<DeclItem>
;;; } 4 TypeName
;;; { 4 List<DeclItem>
;;; { 5 DeclItem
;;; what = DECL_NAME
;;; name = Vint
;;; } 5 DeclItem
;;; { 5 DeclItem
;;; what = DECL_FUN
;;; { 6 List<ParameterDeclaration>
;;; { 7 ParameterDeclaration
;;; isEllipsis = false
;;; { 8 TypeName
;;; { 9 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 9 TypeSpecifier (struct/union)
;;; { 9 List<DeclItem>
;;; { 10 DeclItem
;;; what = DECL_POINTER
;;; { 11 List<Ptr>
;;; { 12 Ptr
;;; } 12 Ptr
;;; } 11 List<Ptr>
;;; } 10 DeclItem
;;; { 10 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 10 DeclItem
;;; } 9 List<DeclItem>
;;; } 8 TypeName
;;; } 7 ParameterDeclaration
;;; } 6 List<ParameterDeclaration>
;;; } 5 DeclItem
;;; } 4 List<DeclItem>
CVint:
;;; { 4 CompoundStatement
;;; { 5 InitDeclarator
;;; { 6 List<DeclItem>
;;; { 7 DeclItem
;;; what = DECL_POINTER
;;; { 8 List<Ptr>
;;; { 9 Ptr
;;; } 9 Ptr
;;; } 8 List<Ptr>
;;; } 7 DeclItem
;;; { 7 DeclItem
;;; what = DECL_NAME
;;; name = next
;;; } 7 DeclItem
;;; } 6 List<DeclItem>
;;; { 6 Initializer (skalar)
;;; { 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)
ADD RR, #0x0002
;-- content
MOVE (RR), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 6 Initializer (skalar)
;;; } 5 InitDeclarator
;;; { 5 List<ExpressionStatement>
;;; { 6 ExpressionStatement
;;; { 7 Expr ++r
;;; { 8 Expr * r
;;; { 9 Expression (variable name)
;;; expr_type = "identifier" (sema)
;-- load_rr_var sema = 2(FP), SP at -2 (16 bit)
MOVE 4(SP), RR
;;; } 9 Expression (variable name)
;;; } 8 Expr * r
;-- + (member)
;-- move_rr_to_ll
MOVE RR, LL
;-- content
MOVE (RR), RR
;-- ++
ADD RR, #0x0001
;-- assign (16 bit)
MOVE RR, (LL)
;;; } 7 Expr ++r
;;; } 6 ExpressionStatement
;;; { 6 IfElseStatement
;;; { 7 Expression (variable name)
;;; expr_type = "identifier" (next)
;-- load_rr_var next = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 7 Expression (variable name)
;-- branch_false
JMP RRZ, L5_endif_6
;;; { 7 CompoundStatement
;;; { 8 List<ExpressionStatement>
;;; { 9 ExpressionStatement
;;; { 10 Expr l & r
;;; { 11 TypeName
;;; { 12 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 12 TypeSpecifier (all)
;;; { 12 List<DeclItem>
;;; { 13 DeclItem
;;; what = DECL_NAME
;;; name = status
;;; } 13 DeclItem
;;; } 12 List<DeclItem>
;;; } 11 TypeName
;;; { 11 Expr l & r
;;; { 12 TypeName (internal)
;;; { 13 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 13 TypeSpecifier (all)
;;; } 12 TypeName (internal)
;;; { 12 Expr * r
;;; { 13 Expression (variable name)
;;; expr_type = "identifier" (next)
;-- load_rr_var next = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 13 Expression (variable name)
;;; } 12 Expr * r
;-- + (member)
ADD RR, #0x0004
;-- content
MOVE (RR), RS
;-- l & r
AND RR, #0xFFFC
;;; } 11 Expr l & r
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 11 Expr * r
;;; { 12 Expression (variable name)
;;; expr_type = "identifier" (next)
;-- load_rr_var next = -2(FP), SP at -3 (16 bit)
MOVE 1(SP), RR
;;; } 12 Expression (variable name)
;;; } 11 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)
;;; } 10 Expr l & r
;;; } 9 ExpressionStatement
;;; { 9 ExpressionStatement
;;; { 10 Expr l = r
;;; { 11 TypeName
;;; { 12 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 12 TypeSpecifier (struct/union)
;;; { 12 List<DeclItem>
;;; { 13 DeclItem
;;; what = DECL_POINTER
;;; { 14 List<Ptr>
;;; { 15 Ptr
;;; } 15 Ptr
;;; } 14 List<Ptr>
;;; } 13 DeclItem
;;; { 13 DeclItem
;;; what = DECL_NAME
;;; name = next_waiting
;;; } 13 DeclItem
;;; } 12 List<DeclItem>
;;; } 11 TypeName
;;; { 11 Expr * r
;;; { 12 Expression (variable name)
;;; expr_type = "identifier" (next)
;-- load_rr_var next = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 12 Expression (variable name)
;;; } 11 Expr * r
;-- + (member)
ADD RR, #0x0010
;-- content
MOVE (RR), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 11 Expr * r
;;; { 12 Expression (variable name)
;;; expr_type = "identifier" (sema)
;-- load_rr_var sema = 2(FP), SP at -4 (16 bit)
MOVE 6(SP), RR
;;; } 12 Expression (variable name)
;;; } 11 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)
;;; } 10 Expr l = r
;;; } 9 ExpressionStatement
;;; { 9 IfElseStatement
;;; { 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, #0x0002
;-- content
MOVE (RR), RR
;-- 16 bit ! r
LNOT RR
;;; } 10 Expr ! r
;-- branch_false
JMP RRZ, L5_endif_7
;;; { 10 ExpressionStatement
;;; { 11 Expr l = r
;;; { 12 TypeName
;;; { 13 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 13 TypeSpecifier (struct/union)
;;; { 13 List<DeclItem>
;;; { 14 DeclItem
;;; what = DECL_POINTER
;;; { 15 List<Ptr>
;;; { 16 Ptr
;;; } 16 Ptr
;;; } 15 List<Ptr>
;;; } 14 DeclItem
;;; { 14 DeclItem
;;; what = DECL_NAME
;;; name = last_waiting
;;; } 14 DeclItem
;;; } 13 List<DeclItem>
;;; } 12 TypeName
;;; { 12 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 12 NumericExpression (constant 0 = 0x0)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 12 Expr * r
;;; { 13 Expression (variable name)
;;; expr_type = "identifier" (sema)
;-- load_rr_var sema = 2(FP), SP at -4 (16 bit)
MOVE 6(SP), RR
;;; } 13 Expression (variable name)
;;; } 12 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)
;;; } 11 Expr l = r
;;; } 10 ExpressionStatement
L5_endif_7:
;;; } 9 IfElseStatement
;;; { 9 return Statement
;;; { 10 Expr l > r
;;; { 11 TypeName (internal)
;;; { 12 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 12 TypeSpecifier (all)
;;; } 11 TypeName (internal)
;;; { 11 Expr * r
;;; { 12 Expression (variable name)
;;; expr_type = "identifier" (next)
;-- load_rr_var next = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 12 Expression (variable name)
;;; } 11 Expr * r
;-- + (member)
ADD RR, #0x0005
;-- content
MOVE (RR), RU
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 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, #0x0005
;-- content
MOVE (RR), RU
;-- pop_ll (16 bit)
MOVE (SP)+, LL
;-- l > r
SHI LL, RR
;;; } 10 Expr l > r
;-- ret
ADD SP, #2
RET
;;; } 9 return Statement
;;; } 8 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 7 CompoundStatement
L5_endif_6:
;;; } 6 IfElseStatement
;;; { 6 return Statement
;;; { 7 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 7 NumericExpression (constant 0 = 0x0)
;-- ret
ADD SP, #2
RET
;;; } 6 return Statement
;;; } 5 List<ExpressionStatement>
;-- pop 2 bytes
ADD SP, #2
;;; } 4 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 4 FunctionDefinition
;;; { 5 TypeName
;;; { 6 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 6 TypeSpecifier (all)
;;; { 6 List<DeclItem>
;;; { 7 DeclItem
;;; what = DECL_NAME
;;; name = V
;;; } 7 DeclItem
;;; } 6 List<DeclItem>
;;; } 5 TypeName
;;; { 5 List<DeclItem>
;;; { 6 DeclItem
;;; what = DECL_NAME
;;; name = V
;;; } 6 DeclItem
;;; { 6 DeclItem
;;; what = DECL_FUN
;;; { 7 List<ParameterDeclaration>
;;; { 8 ParameterDeclaration
;;; isEllipsis = false
;;; { 9 TypeName
;;; { 10 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 10 TypeSpecifier (struct/union)
;;; { 10 List<DeclItem>
;;; { 11 DeclItem
;;; what = DECL_POINTER
;;; { 12 List<Ptr>
;;; { 13 Ptr
;;; } 13 Ptr
;;; } 12 List<Ptr>
;;; } 11 DeclItem
;;; { 11 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 11 DeclItem
;;; } 10 List<DeclItem>
;;; } 9 TypeName
;;; } 8 ParameterDeclaration
;;; } 7 List<ParameterDeclaration>
;;; } 6 DeclItem
;;; } 5 List<DeclItem>
CV:
;;; { 5 CompoundStatement
;;; { 6 List<ExpressionStatement>
;;; { 7 ExpressionStatement
DI
;;; } 7 ExpressionStatement
;;; { 7 IfElseStatement
;;; { 8 Expr l(r)
;;; { 9 TypeName
;;; { 10 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 10 TypeSpecifier (all)
;;; { 10 List<DeclItem>
;;; { 11 DeclItem
;;; what = DECL_NAME
;;; name = Vint
;;; } 11 DeclItem
;;; } 10 List<DeclItem>
;;; } 9 TypeName
;;; { 9 ParameterDeclaration
;;; isEllipsis = false
;;; { 10 TypeName
;;; { 11 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 11 TypeSpecifier (struct/union)
;;; { 11 List<DeclItem>
;;; { 12 DeclItem
;;; what = DECL_POINTER
;;; { 13 List<Ptr>
;;; { 14 Ptr
;;; } 14 Ptr
;;; } 13 List<Ptr>
;;; } 12 DeclItem
;;; { 12 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 12 DeclItem
;;; } 11 List<DeclItem>
;;; } 10 TypeName
;;; } 9 ParameterDeclaration
;;; { 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)
;-- push 1 bytes
;-- call
CALL CVint
;-- pop 2 bytes
ADD SP, #2
;;; } 8 Expr l(r)
;-- branch_false
JMP RRZ, L6_endif_8
;;; { 8 ExpressionStatement
;;; { 9 Expr l(r)
;;; { 10 TypeName
;;; { 11 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 11 TypeSpecifier (all)
;;; { 11 List<DeclItem>
;;; { 12 DeclItem
;;; what = DECL_NAME
;;; name = switch_tasks
;;; } 12 DeclItem
;;; } 11 List<DeclItem>
;;; } 10 TypeName
;-- push 0 bytes
;-- call
CALL Cswitch_tasks
;-- pop 0 bytes
;;; } 9 Expr l(r)
;;; } 8 ExpressionStatement
L6_endif_8:
;;; } 7 IfElseStatement
;;; { 7 ExpressionStatement
RETI
;;; } 7 ExpressionStatement
;;; } 6 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 5 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 5 Declaration
;;; { 6 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 6 TypeSpecifier (all)
Cserial_in_buffer: ;
.BYTE 0 ; VOID [0]
.BYTE 0 ; VOID [1]
.BYTE 0 ; VOID [2]
.BYTE 0 ; VOID [3]
.BYTE 0 ; VOID [4]
.BYTE 0 ; VOID [5]
.BYTE 0 ; VOID [6]
.BYTE 0 ; VOID [7]
.BYTE 0 ; VOID [8]
.BYTE 0 ; VOID [9]
.BYTE 0 ; VOID [10]
.BYTE 0 ; VOID [11]
.BYTE 0 ; VOID [12]
.BYTE 0 ; VOID [13]
.BYTE 0 ; VOID [14]
.BYTE 0 ; VOID [15]
;;; } 5 Declaration
;;; ------------------------------------;
;;; { 5 Declaration
;;; { 6 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 6 TypeSpecifier (all)
Cserial_in_get: ;
.BYTE 0
;;; } 5 Declaration
;;; ------------------------------------;
;;; { 5 Declaration
;;; { 6 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 6 TypeSpecifier (all)
Cserial_in_put: ;
.BYTE 0
;;; } 5 Declaration
;;; ------------------------------------;
;;; { 5 Declaration
;;; { 6 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 6 TypeSpecifier (all)
Cserial_in_overflows: ;
.WORD 0
;;; } 5 Declaration
;;; ------------------------------------;
;;; { 5 FunctionDefinition
;;; { 6 TypeName
;;; { 7 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 7 TypeSpecifier (all)
;;; { 7 List<DeclItem>
;;; { 8 DeclItem
;;; what = DECL_NAME
;;; name = rx_interrupt
;;; } 8 DeclItem
;;; } 7 List<DeclItem>
;;; } 6 TypeName
;;; { 6 List<DeclItem>
;;; { 7 DeclItem
;;; what = DECL_NAME
;;; name = rx_interrupt
;;; } 7 DeclItem
;;; { 7 DeclItem
;;; what = DECL_FUN
;;; } 7 DeclItem
;;; } 6 List<DeclItem>
Crx_interrupt:
;;; { 6 CompoundStatement
;;; { 7 InitDeclarator
;;; { 8 List<DeclItem>
;;; { 9 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 9 DeclItem
;;; } 8 List<DeclItem>
;;; { 8 Initializer (skalar)
IN (IN_RX_DATA), RU
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; } 8 Initializer (skalar)
;;; } 7 InitDeclarator
;;; { 7 List<IfElseStatement>
;;; { 8 IfElseStatement
;;; { 9 Expr l < r
;;; { 10 TypeName (internal)
;;; { 11 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 11 TypeSpecifier (all)
;;; } 10 TypeName (internal)
;-- load_address rx_sema
MOVE #Crx_sema, RR
;-- + (member)
;-- content
MOVE (RR), RR
;-- l < r
SLT RR, #0x0010
;;; } 9 Expr l < r
;-- branch_false
JMP RRZ, L7_else_9
;;; { 9 CompoundStatement
;;; { 10 List<ExpressionStatement>
;;; { 11 ExpressionStatement
;;; { 12 Expr l = r
;;; { 13 TypeName
;;; { 14 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 14 TypeSpecifier (all)
;;; { 14 List<DeclItem>
;;; { 15 DeclItem
;;; what = DECL_NAME
;;; name = serial_in_buffer
;;; } 15 DeclItem
;;; } 14 List<DeclItem>
;;; } 13 TypeName
;;; { 13 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -1(FP), SP at -1 (8 bit)
MOVE 0(SP), RS
;;; } 13 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 13 Expr l[r]
;;; { 14 Expression (variable name)
;;; expr_type = "identifier" (serial_in_put)
;-- load_rr_var serial_in_put, (8 bit)
MOVE (Cserial_in_put), RU
;;; } 14 Expression (variable name)
;-- scale_rr *1
;-- add_address serial_in_buffer
ADD RR, #Cserial_in_buffer
;;; } 13 Expr l[r]
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (8 bit)
MOVE (SP)+, RU
;-- assign (8 bit)
MOVE R, (LL)
;;; } 12 Expr l = r
;;; } 11 ExpressionStatement
;;; { 11 IfElseStatement
;;; { 12 Expr l >= r
;;; { 13 TypeName (internal)
;;; { 14 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 14 TypeSpecifier (all)
;;; } 13 TypeName (internal)
;;; { 13 Expr ++r
;;; { 14 Expression (variable name)
;;; expr_type = "identifier" (serial_in_put)
;-- load_rr_var serial_in_put, (8 bit)
MOVE (Cserial_in_put), RU
;;; } 14 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var serial_in_put
MOVE R, (Cserial_in_put)
;;; } 13 Expr ++r
;-- l >= r
SHS RR, #0x0010
;;; } 12 Expr l >= r
;-- branch_false
JMP RRZ, L7_endif_10
;;; { 12 ExpressionStatement
;;; { 13 Expr l = r
;;; { 14 TypeName
;;; { 15 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 15 TypeSpecifier (all)
;;; { 15 List<DeclItem>
;;; { 16 DeclItem
;;; what = DECL_NAME
;;; name = serial_in_put
;;; } 16 DeclItem
;;; } 15 List<DeclItem>
;;; } 14 TypeName
;;; { 14 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 14 NumericExpression (constant 0 = 0x0)
;-- store_rr_var serial_in_put
MOVE R, (Cserial_in_put)
;;; } 13 Expr l = r
;;; } 12 ExpressionStatement
L7_endif_10:
;;; } 11 IfElseStatement
;;; { 11 return Statement
;;; { 12 Expr l(r)
;;; { 13 TypeName
;;; { 14 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 14 TypeSpecifier (all)
;;; { 14 List<DeclItem>
;;; { 15 DeclItem
;;; what = DECL_NAME
;;; name = Vint
;;; } 15 DeclItem
;;; } 14 List<DeclItem>
;;; } 13 TypeName
;;; { 13 ParameterDeclaration
;;; isEllipsis = false
;;; { 14 TypeName
;;; { 15 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 15 TypeSpecifier (struct/union)
;;; { 15 List<DeclItem>
;;; { 16 DeclItem
;;; what = DECL_POINTER
;;; { 17 List<Ptr>
;;; { 18 Ptr
;;; } 18 Ptr
;;; } 17 List<Ptr>
;;; } 16 DeclItem
;;; { 16 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 16 DeclItem
;;; } 15 List<DeclItem>
;;; } 14 TypeName
;;; } 13 ParameterDeclaration
;;; { 13 Expr & r
;-- load_address rx_sema
MOVE #Crx_sema, RR
;;; } 13 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 1 bytes
;-- call
CALL CVint
;-- pop 2 bytes
ADD SP, #2
;;; } 12 Expr l(r)
;-- ret
ADD SP, #1
RET
;;; } 11 return Statement
;;; } 10 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 9 CompoundStatement
;-- branch
JMP L7_endif_9
L7_else_9:
;;; { 9 CompoundStatement
;;; { 10 List<ExpressionStatement>
;;; { 11 ExpressionStatement
;;; { 12 Expr ++r
;;; { 13 Expression (variable name)
;;; expr_type = "identifier" (serial_in_overflows)
;-- load_rr_var serial_in_overflows, (16 bit)
MOVE (Cserial_in_overflows), RR
;;; } 13 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var serial_in_overflows
MOVE RR, (Cserial_in_overflows)
;;; } 12 Expr ++r
;;; } 11 ExpressionStatement
;;; { 11 return Statement
;;; { 12 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 12 NumericExpression (constant 0 = 0x0)
;-- ret
ADD SP, #1
RET
;;; } 11 return Statement
;;; } 10 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 9 CompoundStatement
L7_endif_9:
;;; } 8 IfElseStatement
;;; } 7 List<IfElseStatement>
;-- pop 1 bytes
ADD SP, #1
;;; } 6 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 6 Declaration
;;; { 7 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 7 TypeSpecifier (all)
Cserial_out_buffer: ;
.BYTE 0 ; VOID [0]
.BYTE 0 ; VOID [1]
.BYTE 0 ; VOID [2]
.BYTE 0 ; VOID [3]
.BYTE 0 ; VOID [4]
.BYTE 0 ; VOID [5]
.BYTE 0 ; VOID [6]
.BYTE 0 ; VOID [7]
.BYTE 0 ; VOID [8]
.BYTE 0 ; VOID [9]
.BYTE 0 ; VOID [10]
.BYTE 0 ; VOID [11]
.BYTE 0 ; VOID [12]
.BYTE 0 ; VOID [13]
.BYTE 0 ; VOID [14]
.BYTE 0 ; VOID [15]
;;; } 6 Declaration
;;; ------------------------------------;
;;; { 6 Declaration
;;; { 7 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 7 TypeSpecifier (all)
Cserial_out_get: ;
.BYTE 0
;;; } 6 Declaration
;;; ------------------------------------;
;;; { 6 Declaration
;;; { 7 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 7 TypeSpecifier (all)
Cserial_out_put: ;
.BYTE 0
;;; } 6 Declaration
;;; ------------------------------------;
;;; { 6 FunctionDefinition
;;; { 7 TypeName
;;; { 8 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 8 TypeSpecifier (all)
;;; { 8 List<DeclItem>
;;; { 9 DeclItem
;;; what = DECL_NAME
;;; name = tx_interrupt
;;; } 9 DeclItem
;;; } 8 List<DeclItem>
;;; } 7 TypeName
;;; { 7 List<DeclItem>
;;; { 8 DeclItem
;;; what = DECL_NAME
;;; name = tx_interrupt
;;; } 8 DeclItem
;;; { 8 DeclItem
;;; what = DECL_FUN
;;; } 8 DeclItem
;;; } 7 List<DeclItem>
Ctx_interrupt:
;;; { 7 CompoundStatement
;;; { 8 List<IfElseStatement>
;;; { 9 IfElseStatement
;;; { 10 Expr l < r
;;; { 11 TypeName (internal)
;;; { 12 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 12 TypeSpecifier (all)
;;; } 11 TypeName (internal)
;-- load_address tx_sema
MOVE #Ctx_sema, RR
;-- + (member)
;-- content
MOVE (RR), RR
;-- l < r
SLT RR, #0x0010
;;; } 10 Expr l < r
;-- branch_false
JMP RRZ, L8_else_11
;;; { 10 CompoundStatement
;;; { 11 List<ExpressionStatement>
;;; { 12 ExpressionStatement
;;; { 13 Expr l[r]
;;; { 14 TypeName
;;; { 15 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 15 TypeSpecifier (all)
;;; { 15 List<DeclItem>
;;; { 16 DeclItem
;;; what = DECL_NAME
;;; name = serial_out_buffer
;;; } 16 DeclItem
;;; } 15 List<DeclItem>
;;; } 14 TypeName
;;; { 14 Expr l[r]
;;; { 15 Expression (variable name)
;;; expr_type = "identifier" (serial_out_get)
;-- load_rr_var serial_out_get, (8 bit)
MOVE (Cserial_out_get), RU
;;; } 15 Expression (variable name)
;-- scale_rr *1
;-- add_address serial_out_buffer
ADD RR, #Cserial_out_buffer
;;; } 14 Expr l[r]
;-- content
MOVE (RR), RU
;;; } 13 Expr l[r]
;;; } 12 ExpressionStatement
;;; { 12 ExpressionStatement
OUT R, (OUT_TX_DATA)
;;; } 12 ExpressionStatement
;;; { 12 IfElseStatement
;;; { 13 Expr l >= r
;;; { 14 TypeName (internal)
;;; { 15 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 15 TypeSpecifier (all)
;;; } 14 TypeName (internal)
;;; { 14 Expr ++r
;;; { 15 Expression (variable name)
;;; expr_type = "identifier" (serial_out_get)
;-- load_rr_var serial_out_get, (8 bit)
MOVE (Cserial_out_get), RU
;;; } 15 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var serial_out_get
MOVE R, (Cserial_out_get)
;;; } 14 Expr ++r
;-- l >= r
SHS RR, #0x0010
;;; } 13 Expr l >= r
;-- branch_false
JMP RRZ, L8_endif_12
;;; { 13 ExpressionStatement
;;; { 14 Expr l = r
;;; { 15 TypeName
;;; { 16 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 16 TypeSpecifier (all)
;;; { 16 List<DeclItem>
;;; { 17 DeclItem
;;; what = DECL_NAME
;;; name = serial_out_get
;;; } 17 DeclItem
;;; } 16 List<DeclItem>
;;; } 15 TypeName
;;; { 15 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 15 NumericExpression (constant 0 = 0x0)
;-- store_rr_var serial_out_get
MOVE R, (Cserial_out_get)
;;; } 14 Expr l = r
;;; } 13 ExpressionStatement
L8_endif_12:
;;; } 12 IfElseStatement
;;; { 12 return Statement
;;; { 13 Expr l(r)
;;; { 14 TypeName
;;; { 15 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 15 TypeSpecifier (all)
;;; { 15 List<DeclItem>
;;; { 16 DeclItem
;;; what = DECL_NAME
;;; name = Vint
;;; } 16 DeclItem
;;; } 15 List<DeclItem>
;;; } 14 TypeName
;;; { 14 ParameterDeclaration
;;; isEllipsis = false
;;; { 15 TypeName
;;; { 16 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 16 TypeSpecifier (struct/union)
;;; { 16 List<DeclItem>
;;; { 17 DeclItem
;;; what = DECL_POINTER
;;; { 18 List<Ptr>
;;; { 19 Ptr
;;; } 19 Ptr
;;; } 18 List<Ptr>
;;; } 17 DeclItem
;;; { 17 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 17 DeclItem
;;; } 16 List<DeclItem>
;;; } 15 TypeName
;;; } 14 ParameterDeclaration
;;; { 14 Expr & r
;-- load_address tx_sema
MOVE #Ctx_sema, RR
;;; } 14 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 1 bytes
;-- call
CALL CVint
;-- pop 2 bytes
ADD SP, #2
;;; } 13 Expr l(r)
;-- ret
RET
;;; } 12 return Statement
;;; } 11 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 10 CompoundStatement
;-- branch
JMP L8_endif_11
L8_else_11:
;;; { 10 CompoundStatement
;;; { 11 List<ExpressionStatement>
;;; { 12 ExpressionStatement
MOVE #0x05, RR
;;; } 12 ExpressionStatement
;;; { 12 ExpressionStatement
OUT R, (OUT_INT_MASK)
;;; } 12 ExpressionStatement
;;; { 12 return Statement
;;; { 13 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 13 NumericExpression (constant 0 = 0x0)
;-- ret
RET
;;; } 12 return Statement
;;; } 11 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 10 CompoundStatement
L8_endif_11:
;;; } 9 IfElseStatement
;;; } 8 List<IfElseStatement>
;-- pop 0 bytes
;;; } 7 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 7 Declaration
;;; { 8 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 8 TypeSpecifier (all)
Cmilliseconds: ;
.WORD 0
;;; } 7 Declaration
;;; ------------------------------------;
;;; { 7 Declaration
;;; { 8 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 8 TypeSpecifier (all)
Cseconds_low: ;
.WORD 0
;;; } 7 Declaration
;;; ------------------------------------;
;;; { 7 Declaration
;;; { 8 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 8 TypeSpecifier (all)
Cseconds_mid: ;
.WORD 0
;;; } 7 Declaration
;;; ------------------------------------;
;;; { 7 Declaration
;;; { 8 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 8 TypeSpecifier (all)
Cseconds_high: ;
.WORD 0
;;; } 7 Declaration
;;; ------------------------------------;
;;; { 7 Declaration
;;; { 8 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 8 TypeSpecifier (all)
Cseconds_changed: ;
.BYTE 0
;;; } 7 Declaration
;;; ------------------------------------;
;;; { 7 FunctionDefinition
;;; { 8 TypeName
;;; { 9 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 9 TypeSpecifier (all)
;;; { 9 List<DeclItem>
;;; { 10 DeclItem
;;; what = DECL_NAME
;;; name = timer_interrupt
;;; } 10 DeclItem
;;; } 9 List<DeclItem>
;;; } 8 TypeName
;;; { 8 List<DeclItem>
;;; { 9 DeclItem
;;; what = DECL_NAME
;;; name = timer_interrupt
;;; } 9 DeclItem
;;; { 9 DeclItem
;;; what = DECL_FUN
;;; } 9 DeclItem
;;; } 8 List<DeclItem>
Ctimer_interrupt:
;;; { 8 CompoundStatement
;;; { 9 InitDeclarator
;;; { 10 List<DeclItem>
;;; { 11 DeclItem
;;; what = DECL_POINTER
;;; { 12 List<Ptr>
;;; { 13 Ptr
;;; } 13 Ptr
;;; } 12 List<Ptr>
;;; } 11 DeclItem
;;; { 11 DeclItem
;;; what = DECL_NAME
;;; name = t
;;; } 11 DeclItem
;;; } 10 List<DeclItem>
;;; { 10 Initializer (skalar)
;;; { 11 Expression (variable name)
;;; expr_type = "identifier" (current_task)
;-- load_rr_var current_task, (16 bit)
MOVE (Ccurrent_task), RR
;;; } 11 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 10 Initializer (skalar)
;;; } 9 InitDeclarator
;;; { 9 InitDeclarator
;;; { 10 List<DeclItem>
;;; { 11 DeclItem
;;; what = DECL_POINTER
;;; { 12 List<Ptr>
;;; { 13 Ptr
;;; } 13 Ptr
;;; } 12 List<Ptr>
;;; } 11 DeclItem
;;; { 11 DeclItem
;;; what = DECL_NAME
;;; name = s
;;; } 11 DeclItem
;;; } 10 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 9 InitDeclarator
;;; { 9 InitDeclarator
;;; { 10 List<DeclItem>
;;; { 11 DeclItem
;;; what = DECL_POINTER
;;; { 12 List<Ptr>
;;; { 13 Ptr
;;; } 13 Ptr
;;; } 12 List<Ptr>
;;; } 11 DeclItem
;;; { 11 DeclItem
;;; what = DECL_NAME
;;; name = ts
;;; } 11 DeclItem
;;; } 10 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 9 InitDeclarator
;;; { 9 List<ExpressionStatement>
;;; { 10 ExpressionStatement
OUT R, (OUT_RESET_TIMER)
;;; } 10 ExpressionStatement
;;; { 10 IfElseStatement
;;; { 11 Expr l == r
;;; { 12 TypeName (internal)
;;; { 13 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 13 TypeSpecifier (all)
;;; } 12 TypeName (internal)
;;; { 12 Expr ++r
;;; { 13 Expression (variable name)
;;; expr_type = "identifier" (milliseconds)
;-- load_rr_var milliseconds, (16 bit)
MOVE (Cmilliseconds), RR
;;; } 13 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var milliseconds
MOVE RR, (Cmilliseconds)
;;; } 12 Expr ++r
;-- l == r
SEQ RR, #0x03E8
;;; } 11 Expr l == r
;-- branch_false
JMP RRZ, L9_endif_13
;;; { 11 CompoundStatement
;;; { 12 List<ExpressionStatement>
;;; { 13 ExpressionStatement
;;; { 14 Expr l = r
;;; { 15 TypeName
;;; { 16 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 16 TypeSpecifier (all)
;;; { 16 List<DeclItem>
;;; { 17 DeclItem
;;; what = DECL_NAME
;;; name = milliseconds
;;; } 17 DeclItem
;;; } 16 List<DeclItem>
;;; } 15 TypeName
;;; { 15 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 15 NumericExpression (constant 0 = 0x0)
;-- store_rr_var milliseconds
MOVE RR, (Cmilliseconds)
;;; } 14 Expr l = r
;;; } 13 ExpressionStatement
;;; { 13 ExpressionStatement
;;; { 14 Expr l = r
;;; { 15 TypeName
;;; { 16 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 16 TypeSpecifier (all)
;;; { 16 List<DeclItem>
;;; { 17 DeclItem
;;; what = DECL_NAME
;;; name = seconds_changed
;;; } 17 DeclItem
;;; } 16 List<DeclItem>
;;; } 15 TypeName
;;; { 15 NumericExpression (constant 255 = 0xFF)
;-- load_rr_constant
MOVE #0x00FF, RR
;;; } 15 NumericExpression (constant 255 = 0xFF)
;-- store_rr_var seconds_changed
MOVE R, (Cseconds_changed)
;;; } 14 Expr l = r
;;; } 13 ExpressionStatement
;;; { 13 IfElseStatement
;;; { 14 Expr l == r
;;; { 15 TypeName (internal)
;;; { 16 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 16 TypeSpecifier (all)
;;; } 15 TypeName (internal)
;;; { 15 Expr ++r
;;; { 16 Expression (variable name)
;;; expr_type = "identifier" (seconds_low)
;-- load_rr_var seconds_low, (16 bit)
MOVE (Cseconds_low), RR
;;; } 16 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var seconds_low
MOVE RR, (Cseconds_low)
;;; } 15 Expr ++r
;-- l == r
SEQ RR, #0x0000
;;; } 14 Expr l == r
;-- branch_false
JMP RRZ, L9_endif_14
;;; { 14 CompoundStatement
;;; { 15 List<IfElseStatement>
;;; { 16 IfElseStatement
;;; { 17 Expr l == r
;;; { 18 TypeName (internal)
;;; { 19 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 19 TypeSpecifier (all)
;;; } 18 TypeName (internal)
;;; { 18 Expr ++r
;;; { 19 Expression (variable name)
;;; expr_type = "identifier" (seconds_mid)
;-- load_rr_var seconds_mid, (16 bit)
MOVE (Cseconds_mid), RR
;;; } 19 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var seconds_mid
MOVE RR, (Cseconds_mid)
;;; } 18 Expr ++r
;-- l == r
SEQ RR, #0x0000
;;; } 17 Expr l == r
;-- branch_false
JMP RRZ, L9_endif_15
;;; { 17 ExpressionStatement
;;; { 18 Expr ++r
;;; { 19 Expression (variable name)
;;; expr_type = "identifier" (seconds_high)
;-- load_rr_var seconds_high, (16 bit)
MOVE (Cseconds_high), RR
;;; } 19 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var seconds_high
MOVE RR, (Cseconds_high)
;;; } 18 Expr ++r
;;; } 17 ExpressionStatement
L9_endif_15:
;;; } 16 IfElseStatement
;;; } 15 List<IfElseStatement>
;-- pop 0 bytes
;;; } 14 CompoundStatement
L9_endif_14:
;;; } 13 IfElseStatement
;;; } 12 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 11 CompoundStatement
L9_endif_13:
;;; } 10 IfElseStatement
;;; { 10 do while Statement
L9_loop_16:
;;; { 11 CompoundStatement
;;; { 12 List<IfElseStatement>
;;; { 13 IfElseStatement
;;; { 14 Expr l && r
;;; { 15 TypeName (internal)
;;; { 16 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 16 TypeSpecifier (all)
;;; } 15 TypeName (internal)
;;; { 15 IfElseStatement
;;; { 16 Expr ! r
;;; { 17 Expr --r
;;; { 18 Expr * r
;;; { 19 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -6 (16 bit)
MOVE 4(SP), RR
;;; } 19 Expression (variable name)
;;; } 18 Expr * r
;-- + (member)
ADD RR, #0x0012
;-- move_rr_to_ll
MOVE RR, LL
;-- content
MOVE (RR), RR
;-- --
SUB RR, #0x0001
;-- assign (16 bit)
MOVE RR, (LL)
;;; } 17 Expr --r
;-- 16 bit ! r
LNOT RR
;;; } 16 Expr ! r
;-- branch_false
JMP RRZ, L9_endif_19
;;; { 16 ExpressionStatement
;;; { 17 Expr l & r
;;; { 18 TypeName (internal)
;;; { 19 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 19 TypeSpecifier (all)
;;; } 18 TypeName (internal)
;;; { 18 Expr * r
;;; { 19 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -6 (16 bit)
MOVE 4(SP), RR
;;; } 19 Expression (variable name)
;;; } 18 Expr * r
;-- + (member)
ADD RR, #0x0004
;-- content
MOVE (RR), RS
;-- l & r
AND RR, #0x0002
;;; } 17 Expr l & r
;;; } 16 ExpressionStatement
L9_endif_19:
;;; } 15 IfElseStatement
;;; } 14 Expr l && r
;-- branch_false
JMP RRZ, L9_endif_18
;;; { 14 CompoundStatement
;;; { 15 List<ExpressionStatement>
;;; { 16 ExpressionStatement
;;; { 17 Expr l & r
;;; { 18 TypeName
;;; { 19 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 19 TypeSpecifier (all)
;;; { 19 List<DeclItem>
;;; { 20 DeclItem
;;; what = DECL_NAME
;;; name = status
;;; } 20 DeclItem
;;; } 19 List<DeclItem>
;;; } 18 TypeName
;;; { 18 Expr l & r
;;; { 19 TypeName (internal)
;;; { 20 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 20 TypeSpecifier (all)
;;; } 19 TypeName (internal)
;;; { 19 Expr * r
;;; { 20 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -6 (16 bit)
MOVE 4(SP), RR
;;; } 20 Expression (variable name)
;;; } 19 Expr * r
;-- + (member)
ADD RR, #0x0004
;-- content
MOVE (RR), RS
;-- l & r
AND RR, #0xFFFD
;;; } 18 Expr l & r
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 18 Expr * r
;;; { 19 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -7 (16 bit)
MOVE 5(SP), RR
;;; } 19 Expression (variable name)
;;; } 18 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)
;;; } 17 Expr l & r
;;; } 16 ExpressionStatement
;;; { 16 IfElseStatement
;;; { 17 Expr l & r
;;; { 18 TypeName (internal)
;;; { 19 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 19 TypeSpecifier (all)
;;; } 18 TypeName (internal)
;;; { 18 Expr * r
;;; { 19 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -6 (16 bit)
MOVE 4(SP), RR
;;; } 19 Expression (variable name)
;;; } 18 Expr * r
;-- + (member)
ADD RR, #0x0004
;-- content
MOVE (RR), RS
;-- l & r
AND RR, #0x0001
;;; } 17 Expr l & r
;-- branch_false
JMP RRZ, L9_endif_20
;;; { 17 CompoundStatement
;;; { 18 List<ExpressionStatement>
;;; { 19 ExpressionStatement
;;; { 20 Expr l & r
;;; { 21 TypeName
;;; { 22 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 22 TypeSpecifier (all)
;;; { 22 List<DeclItem>
;;; { 23 DeclItem
;;; what = DECL_NAME
;;; name = status
;;; } 23 DeclItem
;;; } 22 List<DeclItem>
;;; } 21 TypeName
;;; { 21 Expr l & r
;;; { 22 TypeName (internal)
;;; { 23 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 23 TypeSpecifier (all)
;;; } 22 TypeName (internal)
;;; { 22 Expr * r
;;; { 23 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -6 (16 bit)
MOVE 4(SP), RR
;;; } 23 Expression (variable name)
;;; } 22 Expr * r
;-- + (member)
ADD RR, #0x0004
;-- content
MOVE (RR), RS
;-- l & r
AND RR, #0xFFFE
;;; } 21 Expr l & r
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 21 Expr * r
;;; { 22 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -7 (16 bit)
MOVE 5(SP), RR
;;; } 22 Expression (variable name)
;;; } 21 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)
;;; } 20 Expr l & r
;;; } 19 ExpressionStatement
;;; { 19 ExpressionStatement
;;; { 20 Expr l = r
;;; { 21 TypeName
;;; { 22 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 22 TypeSpecifier (all)
;;; { 22 List<DeclItem>
;;; { 23 DeclItem
;;; what = DECL_NAME
;;; name = sema_ret
;;; } 23 DeclItem
;;; } 22 List<DeclItem>
;;; } 21 TypeName
;;; { 21 NumericExpression (constant 1 = 0x1)
;-- load_rr_constant
MOVE #0xFFFF, RR
;;; } 21 NumericExpression (constant 1 = 0x1)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 21 Expr * r
;;; { 22 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -7 (16 bit)
MOVE 5(SP), RR
;;; } 22 Expression (variable name)
;;; } 21 Expr * r
;-- + (member)
ADD RR, #0x000C
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (8 bit)
MOVE (SP)+, RS
;-- assign (8 bit)
MOVE R, (LL)
;;; } 20 Expr l = r
;;; } 19 ExpressionStatement
;;; { 19 ExpressionStatement
;;; { 20 Expr l = r
;;; { 21 TypeName
;;; { 22 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 22 TypeSpecifier (struct/union)
;;; { 22 List<DeclItem>
;;; { 23 DeclItem
;;; what = DECL_POINTER
;;; { 24 List<Ptr>
;;; { 25 Ptr
;;; } 25 Ptr
;;; } 24 List<Ptr>
;;; } 23 DeclItem
;;; { 23 DeclItem
;;; what = DECL_NAME
;;; name = s
;;; } 23 DeclItem
;;; } 22 List<DeclItem>
;;; } 21 TypeName
;;; { 21 Expr * r
;;; { 22 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -6 (16 bit)
MOVE 4(SP), RR
;;; } 22 Expression (variable name)
;;; } 21 Expr * r
;-- + (member)
ADD RR, #0x000E
;-- content
MOVE (RR), RR
;-- store_rr_var s = -4(FP), SP at -6
MOVE RR, 2(SP)
;;; } 20 Expr l = r
;;; } 19 ExpressionStatement
;;; { 19 ExpressionStatement
;;; { 20 Expr ++r
;;; { 21 Expr * r
;;; { 22 Expression (variable name)
;;; expr_type = "identifier" (s)
;-- load_rr_var s = -4(FP), SP at -6 (16 bit)
MOVE 2(SP), RR
;;; } 22 Expression (variable name)
;;; } 21 Expr * r
;-- + (member)
;-- move_rr_to_ll
MOVE RR, LL
;-- content
MOVE (RR), RR
;-- ++
ADD RR, #0x0001
;-- assign (16 bit)
MOVE RR, (LL)
;;; } 20 Expr ++r
;;; } 19 ExpressionStatement
;;; { 19 ExpressionStatement
;;; { 20 Expr l = r
;;; { 21 TypeName
;;; { 22 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 22 TypeSpecifier (struct/union)
;;; { 22 List<DeclItem>
;;; { 23 DeclItem
;;; what = DECL_POINTER
;;; { 24 List<Ptr>
;;; { 25 Ptr
;;; } 25 Ptr
;;; } 24 List<Ptr>
;;; } 23 DeclItem
;;; { 23 DeclItem
;;; what = DECL_NAME
;;; name = ts
;;; } 23 DeclItem
;;; } 22 List<DeclItem>
;;; } 21 TypeName
;;; { 21 Expr * r
;;; { 22 Expression (variable name)
;;; expr_type = "identifier" (s)
;-- load_rr_var s = -4(FP), SP at -6 (16 bit)
MOVE 2(SP), RR
;;; } 22 Expression (variable name)
;;; } 21 Expr * r
;-- + (member)
ADD RR, #0x0002
;-- content
MOVE (RR), RR
;-- store_rr_var ts = -6(FP), SP at -6
MOVE RR, 0(SP)
;;; } 20 Expr l = r
;;; } 19 ExpressionStatement
;;; { 19 IfElseStatement
;;; { 20 Expr l == r
;;; { 21 TypeName
;;; { 22 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 22 TypeSpecifier (struct/union)
;;; { 22 List<DeclItem>
;;; { 23 DeclItem
;;; what = DECL_POINTER
;;; { 24 List<Ptr>
;;; { 25 Ptr
;;; } 25 Ptr
;;; } 24 List<Ptr>
;;; } 23 DeclItem
;;; { 23 DeclItem
;;; what = DECL_NAME
;;; name = t
;;; } 23 DeclItem
;;; } 22 List<DeclItem>
;;; } 21 TypeName
;;; { 21 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -6 (16 bit)
MOVE 4(SP), RR
;;; } 21 Expression (variable name)
;-- move_rr_to_ll
MOVE RR, LL
;;; { 21 Expression (variable name)
;;; expr_type = "identifier" (ts)
;-- load_rr_var ts = -6(FP), SP at -6 (16 bit)
MOVE 0(SP), RR
;;; } 21 Expression (variable name)
;-- l == r
SEQ LL, RR
;;; } 20 Expr l == r
;-- branch_false
JMP RRZ, L9_else_21
;;; { 20 CompoundStatement
;;; { 21 List<IfElseStatement>
;;; { 22 IfElseStatement
;;; { 23 Expr l == r
;;; { 24 TypeName
;;; { 25 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 25 TypeSpecifier (struct/union)
;;; { 25 List<DeclItem>
;;; { 26 DeclItem
;;; what = DECL_POINTER
;;; { 27 List<Ptr>
;;; { 28 Ptr
;;; } 28 Ptr
;;; } 27 List<Ptr>
;;; } 26 DeclItem
;;; { 26 DeclItem
;;; what = DECL_NAME
;;; name = t
;;; } 26 DeclItem
;;; } 25 List<DeclItem>
;;; } 24 TypeName
;;; { 24 Expr * r
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (s)
;-- load_rr_var s = -4(FP), SP at -6 (16 bit)
MOVE 2(SP), RR
;;; } 25 Expression (variable name)
;;; } 24 Expr * r
;-- + (member)
ADD RR, #0x0004
;-- content
MOVE (RR), RR
;;; { 24 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_ll_var t = -2(FP), SP at -6 (16 bit)
MOVE 4(SP), LL
;;; } 24 Expression (variable name)
;-- l == r
SEQ LL, RR
;;; } 23 Expr l == r
;-- branch_false
JMP RRZ, L9_else_22
;;; { 23 CompoundStatement
;;; { 24 List<ExpressionStatement>
;;; { 25 ExpressionStatement
;;; { 26 Expr l = r
;;; { 27 TypeName
;;; { 28 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 28 TypeSpecifier (struct/union)
;;; { 28 List<DeclItem>
;;; { 29 DeclItem
;;; what = DECL_POINTER
;;; { 30 List<Ptr>
;;; { 31 Ptr
;;; } 31 Ptr
;;; } 30 List<Ptr>
;;; } 29 DeclItem
;;; { 29 DeclItem
;;; what = DECL_NAME
;;; name = next_waiting
;;; } 29 DeclItem
;;; } 28 List<DeclItem>
;;; } 27 TypeName
;;; { 27 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 27 NumericExpression (constant 0 = 0x0)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 27 Expr * r
;;; { 28 Expression (variable name)
;;; expr_type = "identifier" (s)
;-- load_rr_var s = -4(FP), SP at -8 (16 bit)
MOVE 4(SP), RR
;;; } 28 Expression (variable name)
;;; } 27 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)
;;; } 26 Expr l = r
;;; } 25 ExpressionStatement
;;; { 25 ExpressionStatement
;;; { 26 Expr l = r
;;; { 27 TypeName
;;; { 28 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 28 TypeSpecifier (struct/union)
;;; { 28 List<DeclItem>
;;; { 29 DeclItem
;;; what = DECL_POINTER
;;; { 30 List<Ptr>
;;; { 31 Ptr
;;; } 31 Ptr
;;; } 30 List<Ptr>
;;; } 29 DeclItem
;;; { 29 DeclItem
;;; what = DECL_NAME
;;; name = last_waiting
;;; } 29 DeclItem
;;; } 28 List<DeclItem>
;;; } 27 TypeName
;;; { 27 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 27 NumericExpression (constant 0 = 0x0)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 27 Expr * r
;;; { 28 Expression (variable name)
;;; expr_type = "identifier" (s)
;-- load_rr_var s = -4(FP), SP at -8 (16 bit)
MOVE 4(SP), RR
;;; } 28 Expression (variable name)
;;; } 27 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)
;;; } 26 Expr l = r
;;; } 25 ExpressionStatement
;;; } 24 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 23 CompoundStatement
;-- branch
JMP L9_endif_22
L9_else_22:
;;; { 23 CompoundStatement
;;; { 24 List<ExpressionStatement>
;;; { 25 ExpressionStatement
;;; { 26 Expr l = r
;;; { 27 TypeName
;;; { 28 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 28 TypeSpecifier (struct/union)
;;; { 28 List<DeclItem>
;;; { 29 DeclItem
;;; what = DECL_POINTER
;;; { 30 List<Ptr>
;;; { 31 Ptr
;;; } 31 Ptr
;;; } 30 List<Ptr>
;;; } 29 DeclItem
;;; { 29 DeclItem
;;; what = DECL_NAME
;;; name = next_waiting
;;; } 29 DeclItem
;;; } 28 List<DeclItem>
;;; } 27 TypeName
;;; { 27 Expr * r
;;; { 28 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -6 (16 bit)
MOVE 4(SP), RR
;;; } 28 Expression (variable name)
;;; } 27 Expr * r
;-- + (member)
ADD RR, #0x0010
;-- content
MOVE (RR), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 27 Expr * r
;;; { 28 Expression (variable name)
;;; expr_type = "identifier" (s)
;-- load_rr_var s = -4(FP), SP at -8 (16 bit)
MOVE 4(SP), RR
;;; } 28 Expression (variable name)
;;; } 27 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)
;;; } 26 Expr l = r
;;; } 25 ExpressionStatement
;;; } 24 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 23 CompoundStatement
L9_endif_22:
;;; } 22 IfElseStatement
;;; } 21 List<IfElseStatement>
;-- pop 0 bytes
;;; } 20 CompoundStatement
;-- branch
JMP L9_endif_21
L9_else_21:
;;; { 20 CompoundStatement
;;; { 21 List<while Statement>
;;; { 22 while Statement
;-- branch
JMP L9_cont_23
L9_loop_23:
;;; { 23 ExpressionStatement
;;; { 24 Expr l = r
;;; { 25 TypeName
;;; { 26 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 26 TypeSpecifier (struct/union)
;;; { 26 List<DeclItem>
;;; { 27 DeclItem
;;; what = DECL_POINTER
;;; { 28 List<Ptr>
;;; { 29 Ptr
;;; } 29 Ptr
;;; } 28 List<Ptr>
;;; } 27 DeclItem
;;; { 27 DeclItem
;;; what = DECL_NAME
;;; name = ts
;;; } 27 DeclItem
;;; } 26 List<DeclItem>
;;; } 25 TypeName
;;; { 25 Expr * r
;;; { 26 Expression (variable name)
;;; expr_type = "identifier" (ts)
;-- load_rr_var ts = -6(FP), SP at -6 (16 bit)
MOVE 0(SP), RR
;;; } 26 Expression (variable name)
;;; } 25 Expr * r
;-- + (member)
ADD RR, #0x0010
;-- content
MOVE (RR), RR
;-- store_rr_var ts = -6(FP), SP at -6
MOVE RR, 0(SP)
;;; } 24 Expr l = r
;;; } 23 ExpressionStatement
L9_cont_23:
;;; { 23 Expr l != r
;;; { 24 TypeName
;;; { 25 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 25 TypeSpecifier (struct/union)
;;; { 25 List<DeclItem>
;;; { 26 DeclItem
;;; what = DECL_POINTER
;;; { 27 List<Ptr>
;;; { 28 Ptr
;;; } 28 Ptr
;;; } 27 List<Ptr>
;;; } 26 DeclItem
;;; { 26 DeclItem
;;; what = DECL_NAME
;;; name = t
;;; } 26 DeclItem
;;; } 25 List<DeclItem>
;;; } 24 TypeName
;;; { 24 Expr * r
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (ts)
;-- load_rr_var ts = -6(FP), SP at -6 (16 bit)
MOVE 0(SP), RR
;;; } 25 Expression (variable name)
;;; } 24 Expr * r
;-- + (member)
ADD RR, #0x0010
;-- content
MOVE (RR), RR
;;; { 24 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_ll_var t = -2(FP), SP at -6 (16 bit)
MOVE 4(SP), LL
;;; } 24 Expression (variable name)
;-- l != r
SNE LL, RR
;;; } 23 Expr l != r
;-- branch_true
JMP RRNZ, L9_loop_23
L9_brk_24:
;;; } 22 while Statement
;;; { 22 ExpressionStatement
;;; { 23 Expr l = r
;;; { 24 TypeName
;;; { 25 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 25 TypeSpecifier (struct/union)
;;; { 25 List<DeclItem>
;;; { 26 DeclItem
;;; what = DECL_POINTER
;;; { 27 List<Ptr>
;;; { 28 Ptr
;;; } 28 Ptr
;;; } 27 List<Ptr>
;;; } 26 DeclItem
;;; { 26 DeclItem
;;; what = DECL_NAME
;;; name = next_waiting_task
;;; } 26 DeclItem
;;; } 25 List<DeclItem>
;;; } 24 TypeName
;;; { 24 Expr * r
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -6 (16 bit)
MOVE 4(SP), RR
;;; } 25 Expression (variable name)
;;; } 24 Expr * r
;-- + (member)
ADD RR, #0x0010
;-- content
MOVE (RR), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 24 Expr * r
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (ts)
;-- load_rr_var ts = -6(FP), SP at -8 (16 bit)
MOVE 2(SP), RR
;;; } 25 Expression (variable name)
;;; } 24 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)
;;; } 23 Expr l = r
;;; } 22 ExpressionStatement
;;; { 22 IfElseStatement
;;; { 23 Expr l == r
;;; { 24 TypeName
;;; { 25 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 25 TypeSpecifier (struct/union)
;;; { 25 List<DeclItem>
;;; { 26 DeclItem
;;; what = DECL_POINTER
;;; { 27 List<Ptr>
;;; { 28 Ptr
;;; } 28 Ptr
;;; } 27 List<Ptr>
;;; } 26 DeclItem
;;; { 26 DeclItem
;;; what = DECL_NAME
;;; name = t
;;; } 26 DeclItem
;;; } 25 List<DeclItem>
;;; } 24 TypeName
;;; { 24 Expr * r
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (s)
;-- load_rr_var s = -4(FP), SP at -6 (16 bit)
MOVE 2(SP), RR
;;; } 25 Expression (variable name)
;;; } 24 Expr * r
;-- + (member)
ADD RR, #0x0004
;-- content
MOVE (RR), RR
;;; { 24 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_ll_var t = -2(FP), SP at -6 (16 bit)
MOVE 4(SP), LL
;;; } 24 Expression (variable name)
;-- l == r
SEQ LL, RR
;;; } 23 Expr l == r
;-- branch_false
JMP RRZ, L9_endif_25
;;; { 23 ExpressionStatement
;;; { 24 Expr l = r
;;; { 25 TypeName
;;; { 26 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 26 TypeSpecifier (struct/union)
;;; { 26 List<DeclItem>
;;; { 27 DeclItem
;;; what = DECL_POINTER
;;; { 28 List<Ptr>
;;; { 29 Ptr
;;; } 29 Ptr
;;; } 28 List<Ptr>
;;; } 27 DeclItem
;;; { 27 DeclItem
;;; what = DECL_NAME
;;; name = last_waiting
;;; } 27 DeclItem
;;; } 26 List<DeclItem>
;;; } 25 TypeName
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (ts)
;-- load_rr_var ts = -6(FP), SP at -6 (16 bit)
MOVE 0(SP), RR
;;; } 25 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 25 Expr * r
;;; { 26 Expression (variable name)
;;; expr_type = "identifier" (s)
;-- load_rr_var s = -4(FP), SP at -8 (16 bit)
MOVE 4(SP), RR
;;; } 26 Expression (variable name)
;;; } 25 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)
;;; } 24 Expr l = r
;;; } 23 ExpressionStatement
L9_endif_25:
;;; } 22 IfElseStatement
;;; } 21 List<while Statement>
;-- pop 0 bytes
;;; } 20 CompoundStatement
L9_endif_21:
;;; } 19 IfElseStatement
;;; } 18 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 17 CompoundStatement
L9_endif_20:
;;; } 16 IfElseStatement
;;; } 15 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 14 CompoundStatement
L9_endif_18:
;;; } 13 IfElseStatement
;;; } 12 List<IfElseStatement>
;-- pop 0 bytes
;;; } 11 CompoundStatement
L9_cont_16:
;;; { 11 Expr l != r
;;; { 12 TypeName
;;; { 13 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 13 TypeSpecifier (struct/union)
;;; { 13 List<DeclItem>
;;; { 14 DeclItem
;;; what = DECL_POINTER
;;; { 15 List<Ptr>
;;; { 16 Ptr
;;; } 16 Ptr
;;; } 15 List<Ptr>
;;; } 14 DeclItem
;;; { 14 DeclItem
;;; what = DECL_NAME
;;; name = current_task
;;; } 14 DeclItem
;;; } 13 List<DeclItem>
;;; } 12 TypeName
;;; { 12 Expr l = r
;;; { 13 TypeName
;;; { 14 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 14 TypeSpecifier (struct/union)
;;; { 14 List<DeclItem>
;;; { 15 DeclItem
;;; what = DECL_POINTER
;;; { 16 List<Ptr>
;;; { 17 Ptr
;;; } 17 Ptr
;;; } 16 List<Ptr>
;;; } 15 DeclItem
;;; { 15 DeclItem
;;; what = DECL_NAME
;;; name = t
;;; } 15 DeclItem
;;; } 14 List<DeclItem>
;;; } 13 TypeName
;;; { 13 Expr * r
;;; { 14 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -6 (16 bit)
MOVE 4(SP), RR
;;; } 14 Expression (variable name)
;;; } 13 Expr * r
;-- + (member)
;-- content
MOVE (RR), RR
;-- store_rr_var t = -2(FP), SP at -6
MOVE RR, 4(SP)
;;; } 12 Expr l = r
;;; { 12 Expression (variable name)
;;; expr_type = "identifier" (current_task)
;-- load_ll_var current_task, (16 bit)
MOVE (Ccurrent_task), LL
;;; } 12 Expression (variable name)
;-- l != r
SNE LL, RR
;;; } 11 Expr l != r
;-- branch_true
JMP RRNZ, L9_loop_16
L9_brk_17:
;;; } 10 do while Statement
;;; } 9 List<ExpressionStatement>
;-- pop 6 bytes
ADD SP, #6
;;; } 8 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 8 FunctionDefinition
;;; { 9 TypeName
;;; { 10 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 10 TypeSpecifier (all)
;;; { 10 List<DeclItem>
;;; { 11 DeclItem
;;; what = DECL_NAME
;;; name = interrupt
;;; } 11 DeclItem
;;; } 10 List<DeclItem>
;;; } 9 TypeName
;;; { 9 List<DeclItem>
;;; { 10 DeclItem
;;; what = DECL_NAME
;;; name = interrupt
;;; } 10 DeclItem
;;; { 10 DeclItem
;;; what = DECL_FUN
;;; } 10 DeclItem
;;; } 9 List<DeclItem>
Cinterrupt:
;;; { 9 CompoundStatement
;;; { 10 InitDeclarator
;;; { 11 List<DeclItem>
;;; { 12 DeclItem
;;; what = DECL_NAME
;;; name = ts_1
;;; } 12 DeclItem
;;; } 11 List<DeclItem>
;;; { 11 Initializer (skalar)
;-- push_zero 1 bytes
CLRB -(SP)
;;; } 11 Initializer (skalar)
;;; } 10 InitDeclarator
;;; { 10 InitDeclarator
;;; { 11 List<DeclItem>
;;; { 12 DeclItem
;;; what = DECL_NAME
;;; name = ts_2
;;; } 12 DeclItem
;;; } 11 List<DeclItem>
;;; { 11 Initializer (skalar)
;-- push_zero 1 bytes
CLRB -(SP)
;;; } 11 Initializer (skalar)
;;; } 10 InitDeclarator
;;; { 10 List<ExpressionStatement>
;;; { 11 ExpressionStatement
MOVE RR, -(SP)
;;; } 11 ExpressionStatement
;;; { 11 ExpressionStatement
MOVE LL, RR
;;; } 11 ExpressionStatement
;;; { 11 ExpressionStatement
MOVE RR, -(SP)
;;; } 11 ExpressionStatement
;;; { 11 IfElseStatement
;;; { 12 Expr l & r
;;; { 13 TypeName (internal)
;;; { 14 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 14 TypeSpecifier (all)
;;; } 13 TypeName (internal)
IN (IN_STATUS), RU
;-- l & r
AND RR, #0x0010
;;; } 12 Expr l & r
;-- branch_false
JMP RRZ, L10_endif_26
;;; { 12 ExpressionStatement
;;; { 13 Expr l = r
;;; { 14 TypeName
;;; { 15 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 15 TypeSpecifier (all)
;;; { 15 List<DeclItem>
;;; { 16 DeclItem
;;; what = DECL_NAME
;;; name = ts_1
;;; } 16 DeclItem
;;; } 15 List<DeclItem>
;;; } 14 TypeName
;;; { 14 Expr l(r)
;;; { 15 TypeName
;;; { 16 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 16 TypeSpecifier (all)
;;; { 16 List<DeclItem>
;;; { 17 DeclItem
;;; what = DECL_NAME
;;; name = rx_interrupt
;;; } 17 DeclItem
;;; } 16 List<DeclItem>
;;; } 15 TypeName
;-- push 1 bytes
;-- call
CALL Crx_interrupt
;-- pop 0 bytes
;;; } 14 Expr l(r)
;-- store_rr_var ts_1 = -1(FP), SP at -6
MOVE R, 5(SP)
;;; } 13 Expr l = r
;;; } 12 ExpressionStatement
L10_endif_26:
;;; } 11 IfElseStatement
;;; { 11 IfElseStatement
;;; { 12 Expr l & r
;;; { 13 TypeName (internal)
;;; { 14 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 14 TypeSpecifier (all)
;;; } 13 TypeName (internal)
IN (IN_STATUS), RU
;-- l & r
AND RR, #0x0020
;;; } 12 Expr l & r
;-- branch_false
JMP RRZ, L10_endif_27
;;; { 12 ExpressionStatement
;;; { 13 Expr l = r
;;; { 14 TypeName
;;; { 15 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 15 TypeSpecifier (all)
;;; { 15 List<DeclItem>
;;; { 16 DeclItem
;;; what = DECL_NAME
;;; name = ts_2
;;; } 16 DeclItem
;;; } 15 List<DeclItem>
;;; } 14 TypeName
;;; { 14 Expr l(r)
;;; { 15 TypeName
;;; { 16 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 16 TypeSpecifier (all)
;;; { 16 List<DeclItem>
;;; { 17 DeclItem
;;; what = DECL_NAME
;;; name = tx_interrupt
;;; } 17 DeclItem
;;; } 16 List<DeclItem>
;;; } 15 TypeName
;-- push 1 bytes
;-- call
CALL Ctx_interrupt
;-- pop 0 bytes
;;; } 14 Expr l(r)
;-- store_rr_var ts_2 = -2(FP), SP at -6
MOVE R, 4(SP)
;;; } 13 Expr l = r
;;; } 12 ExpressionStatement
L10_endif_27:
;;; } 11 IfElseStatement
;;; { 11 IfElseStatement
;;; { 12 Expr l & r
;;; { 13 TypeName (internal)
;;; { 14 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 14 TypeSpecifier (all)
;;; } 13 TypeName (internal)
IN (IN_STATUS), RU
;-- l & r
AND RR, #0x0040
;;; } 12 Expr l & r
;-- branch_false
JMP RRZ, L10_endif_28
;;; { 12 CompoundStatement
;;; { 13 List<ExpressionStatement>
;;; { 14 ExpressionStatement
;;; { 15 Expr l(r)
;;; { 16 TypeName
;;; { 17 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 17 TypeSpecifier (all)
;;; { 17 List<DeclItem>
;;; { 18 DeclItem
;;; what = DECL_NAME
;;; name = timer_interrupt
;;; } 18 DeclItem
;;; } 17 List<DeclItem>
;;; } 16 TypeName
;-- push 0 bytes
;-- call
CALL Ctimer_interrupt
;-- pop 0 bytes
;;; } 15 Expr l(r)
;;; } 14 ExpressionStatement
;;; { 14 ExpressionStatement
;;; { 15 Expr l = r
;;; { 16 TypeName
;;; { 17 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 17 TypeSpecifier (all)
;;; { 17 List<DeclItem>
;;; { 18 DeclItem
;;; what = DECL_NAME
;;; name = ts_1
;;; } 18 DeclItem
;;; } 17 List<DeclItem>
;;; } 16 TypeName
;;; { 16 NumericExpression (constant 1 = 0x1)
;-- load_rr_constant
MOVE #0xFFFF, RR
;;; } 16 NumericExpression (constant 1 = 0x1)
;-- store_rr_var ts_1 = -1(FP), SP at -6
MOVE R, 5(SP)
;;; } 15 Expr l = r
;;; } 14 ExpressionStatement
;;; } 13 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 12 CompoundStatement
L10_endif_28:
;;; } 11 IfElseStatement
;;; { 11 IfElseStatement
;;; { 12 Expr l | r
;;; { 13 TypeName (internal)
;;; { 14 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 14 TypeSpecifier (all)
;;; } 13 TypeName (internal)
;;; { 13 Expression (variable name)
;;; expr_type = "identifier" (ts_1)
;-- load_rr_var ts_1 = -1(FP), SP at -6 (8 bit)
MOVE 5(SP), RS
;;; } 13 Expression (variable name)
;-- move_rr_to_ll
MOVE RR, LL
;;; { 13 Expression (variable name)
;;; expr_type = "identifier" (ts_2)
;-- load_rr_var ts_2 = -2(FP), SP at -6 (8 bit)
MOVE 4(SP), RS
;;; } 13 Expression (variable name)
;-- l | r
OR LL, RR
;;; } 12 Expr l | r
;-- branch_false
JMP RRZ, L10_endif_29
;;; { 12 ExpressionStatement
;;; { 13 Expr l(r)
;;; { 14 TypeName
;;; { 15 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 15 TypeSpecifier (all)
;;; { 15 List<DeclItem>
;;; { 16 DeclItem
;;; what = DECL_NAME
;;; name = switch_tasks
;;; } 16 DeclItem
;;; } 15 List<DeclItem>
;;; } 14 TypeName
;-- push 0 bytes
;-- call
CALL Cswitch_tasks
;-- pop 0 bytes
;;; } 13 Expr l(r)
;;; } 12 ExpressionStatement
L10_endif_29:
;;; } 11 IfElseStatement
;;; { 11 ExpressionStatement
MOVE (SP)+, RR
;;; } 11 ExpressionStatement
;;; { 11 ExpressionStatement
MOVE RR, LL
;;; } 11 ExpressionStatement
;;; { 11 ExpressionStatement
MOVE (SP)+, RR
;;; } 11 ExpressionStatement
;;; { 11 ExpressionStatement
ADD SP, #2
;;; } 11 ExpressionStatement
;;; { 11 ExpressionStatement
RETI
;;; } 11 ExpressionStatement
;;; } 10 List<ExpressionStatement>
;-- pop 2 bytes
ADD SP, #2
;;; } 9 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 9 FunctionDefinition
;;; { 10 TypeName
;;; { 11 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 11 TypeSpecifier (all)
;;; { 11 List<DeclItem>
;;; { 12 DeclItem
;;; what = DECL_NAME
;;; name = sleep
;;; } 12 DeclItem
;;; } 11 List<DeclItem>
;;; } 10 TypeName
;;; { 10 List<DeclItem>
;;; { 11 DeclItem
;;; what = DECL_NAME
;;; name = sleep
;;; } 11 DeclItem
;;; { 11 DeclItem
;;; what = DECL_FUN
;;; { 12 List<ParameterDeclaration>
;;; { 13 ParameterDeclaration
;;; isEllipsis = false
;;; { 14 TypeName
;;; { 15 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 15 TypeSpecifier (all)
;;; { 15 List<DeclItem>
;;; { 16 DeclItem
;;; what = DECL_NAME
;;; name = millisecs
;;; } 16 DeclItem
;;; } 15 List<DeclItem>
;;; } 14 TypeName
;;; } 13 ParameterDeclaration
;;; } 12 List<ParameterDeclaration>
;;; } 11 DeclItem
;;; } 10 List<DeclItem>
Csleep:
;;; { 10 CompoundStatement
;;; { 11 List<ExpressionStatement>
;;; { 12 ExpressionStatement
DI
;;; } 12 ExpressionStatement
;;; { 12 ExpressionStatement
;;; { 13 Expr l = r
;;; { 14 TypeName
;;; { 15 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 15 TypeSpecifier (all)
;;; { 15 List<DeclItem>
;;; { 16 DeclItem
;;; what = DECL_NAME
;;; name = sleep_count
;;; } 16 DeclItem
;;; } 15 List<DeclItem>
;;; } 14 TypeName
;;; { 14 Expression (variable name)
;;; expr_type = "identifier" (millisecs)
;-- load_rr_var millisecs = 2(FP), SP at 0 (16 bit)
MOVE 2(SP), RR
;;; } 14 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 14 Expr * r
;;; { 15 Expression (variable name)
;;; expr_type = "identifier" (current_task)
;-- load_rr_var current_task, (16 bit)
MOVE (Ccurrent_task), RR
;;; } 15 Expression (variable name)
;;; } 14 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)
;;; } 13 Expr l = r
;;; } 12 ExpressionStatement
;;; { 12 ExpressionStatement
;;; { 13 Expr l = r
;;; { 14 TypeName
;;; { 15 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 15 TypeSpecifier (all)
;;; { 15 List<DeclItem>
;;; { 16 DeclItem
;;; what = DECL_NAME
;;; name = status
;;; } 16 DeclItem
;;; } 15 List<DeclItem>
;;; } 14 TypeName
;;; { 14 NumericExpression (constant 2 = 0x2)
;-- load_rr_constant
MOVE #0x0002, RR
;;; } 14 NumericExpression (constant 2 = 0x2)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 14 Expr * r
;;; { 15 Expression (variable name)
;;; expr_type = "identifier" (current_task)
;-- load_rr_var current_task, (16 bit)
MOVE (Ccurrent_task), RR
;;; } 15 Expression (variable name)
;;; } 14 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)
;;; } 13 Expr l = r
;;; } 12 ExpressionStatement
;;; { 12 ExpressionStatement
;;; { 13 Expr l(r)
;;; { 14 TypeName
;;; { 15 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 15 TypeSpecifier (all)
;;; { 15 List<DeclItem>
;;; { 16 DeclItem
;;; what = DECL_NAME
;;; name = switch_tasks
;;; } 16 DeclItem
;;; } 15 List<DeclItem>
;;; } 14 TypeName
;-- push 0 bytes
;-- call
CALL Cswitch_tasks
;-- pop 0 bytes
;;; } 13 Expr l(r)
;;; } 12 ExpressionStatement
;;; { 12 ExpressionStatement
RETI
;;; } 12 ExpressionStatement
;;; } 11 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 10 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 10 FunctionDefinition
;;; { 11 TypeName
;;; { 12 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 12 TypeSpecifier (all)
;;; { 12 List<DeclItem>
;;; { 13 DeclItem
;;; what = DECL_NAME
;;; name = deschedule
;;; } 13 DeclItem
;;; } 12 List<DeclItem>
;;; } 11 TypeName
;;; { 11 List<DeclItem>
;;; { 12 DeclItem
;;; what = DECL_NAME
;;; name = deschedule
;;; } 12 DeclItem
;;; { 12 DeclItem
;;; what = DECL_FUN
;;; } 12 DeclItem
;;; } 11 List<DeclItem>
Cdeschedule:
;;; { 11 CompoundStatement
;;; { 12 List<ExpressionStatement>
;;; { 13 ExpressionStatement
DI
;;; } 13 ExpressionStatement
;;; { 13 ExpressionStatement
;;; { 14 Expr l(r)
;;; { 15 TypeName
;;; { 16 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 16 TypeSpecifier (all)
;;; { 16 List<DeclItem>
;;; { 17 DeclItem
;;; what = DECL_NAME
;;; name = switch_tasks
;;; } 17 DeclItem
;;; } 16 List<DeclItem>
;;; } 15 TypeName
;-- push 0 bytes
;-- call
CALL Cswitch_tasks
;-- pop 0 bytes
;;; } 14 Expr l(r)
;;; } 13 ExpressionStatement
;;; { 13 ExpressionStatement
RETI
;;; } 13 ExpressionStatement
;;; } 12 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 11 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 11 FunctionDefinition
;;; { 12 TypeName
;;; { 13 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 13 TypeSpecifier (all)
;;; { 13 List<DeclItem>
;;; { 14 DeclItem
;;; what = DECL_NAME
;;; name = strlen
;;; } 14 DeclItem
;;; } 13 List<DeclItem>
;;; } 12 TypeName
;;; { 12 List<DeclItem>
;;; { 13 DeclItem
;;; what = DECL_NAME
;;; name = strlen
;;; } 13 DeclItem
;;; { 13 DeclItem
;;; what = DECL_FUN
;;; { 14 List<ParameterDeclaration>
;;; { 15 ParameterDeclaration
;;; isEllipsis = false
;;; { 16 TypeName
;;; { 17 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 17 TypeSpecifier (all)
;;; { 17 List<DeclItem>
;;; { 18 DeclItem
;;; what = DECL_POINTER
;;; { 19 List<Ptr>
;;; { 20 Ptr
;;; } 20 Ptr
;;; } 19 List<Ptr>
;;; } 18 DeclItem
;;; { 18 DeclItem
;;; what = DECL_NAME
;;; name = buffer
;;; } 18 DeclItem
;;; } 17 List<DeclItem>
;;; } 16 TypeName
;;; } 15 ParameterDeclaration
;;; } 14 List<ParameterDeclaration>
;;; } 13 DeclItem
;;; } 12 List<DeclItem>
Cstrlen:
;;; { 12 CompoundStatement
;;; { 13 InitDeclarator
;;; { 14 List<DeclItem>
;;; { 15 DeclItem
;;; what = DECL_POINTER
;;; { 16 List<Ptr>
;;; { 17 Ptr
;;; } 17 Ptr
;;; } 16 List<Ptr>
;;; } 15 DeclItem
;;; { 15 DeclItem
;;; what = DECL_NAME
;;; name = from
;;; } 15 DeclItem
;;; } 14 List<DeclItem>
;;; { 14 Initializer (skalar)
;;; { 15 Expression (variable name)
;;; expr_type = "identifier" (buffer)
;-- load_rr_var buffer = 2(FP), SP at 0 (16 bit)
MOVE 2(SP), RR
;;; } 15 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 14 Initializer (skalar)
;;; } 13 InitDeclarator
;;; { 13 List<while Statement>
;;; { 14 while Statement
;-- branch
JMP L13_cont_30
L13_loop_30:
;;; { 15 ExpressionStatement
;;; { 16 Expr l - r
;;; { 17 Expr ++r
;;; { 18 Expression (variable name)
;;; expr_type = "identifier" (buffer)
;-- load_rr_var buffer = 2(FP), SP at -2 (16 bit)
MOVE 4(SP), RR
;;; } 18 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var buffer = 2(FP), SP at -2
MOVE RR, 4(SP)
;;; } 17 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 16 Expr l - r
;;; } 15 ExpressionStatement
L13_cont_30:
;;; { 15 Expr * r
;;; { 16 Expression (variable name)
;;; expr_type = "identifier" (buffer)
;-- load_rr_var buffer = 2(FP), SP at -2 (16 bit)
MOVE 4(SP), RR
;;; } 16 Expression (variable name)
;-- content
MOVE (RR), RS
;;; } 15 Expr * r
;-- branch_true
JMP RRNZ, L13_loop_30
L13_brk_31:
;;; } 14 while Statement
;;; { 14 return Statement
;;; { 15 Expr l - r
;;; { 16 Expression (variable name)
;;; expr_type = "identifier" (buffer)
;-- load_rr_var buffer = 2(FP), SP at -2 (16 bit)
MOVE 4(SP), RR
;;; } 16 Expression (variable name)
;-- move_rr_to_ll
MOVE RR, LL
;;; { 16 Expression (variable name)
;;; expr_type = "identifier" (from)
;-- load_rr_var from = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 16 Expression (variable name)
;-- scale_rr *1
;-- l - r
SUB LL, RR
;-- scale *1
;;; } 15 Expr l - r
;-- ret
ADD SP, #2
RET
;;; } 14 return Statement
;;; } 13 List<while Statement>
;-- pop 2 bytes
ADD SP, #2
;;; } 12 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 12 FunctionDefinition
;;; { 13 TypeName
;;; { 14 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 14 TypeSpecifier (all)
;;; { 14 List<DeclItem>
;;; { 15 DeclItem
;;; what = DECL_NAME
;;; name = putchr
;;; } 15 DeclItem
;;; } 14 List<DeclItem>
;;; } 13 TypeName
;;; { 13 List<DeclItem>
;;; { 14 DeclItem
;;; what = DECL_NAME
;;; name = putchr
;;; } 14 DeclItem
;;; { 14 DeclItem
;;; what = DECL_FUN
;;; { 15 List<ParameterDeclaration>
;;; { 16 ParameterDeclaration
;;; isEllipsis = false
;;; { 17 TypeName
;;; { 18 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 18 TypeSpecifier (all)
;;; { 18 List<DeclItem>
;;; { 19 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 19 DeclItem
;;; } 18 List<DeclItem>
;;; } 17 TypeName
;;; } 16 ParameterDeclaration
;;; } 15 List<ParameterDeclaration>
;;; } 14 DeclItem
;;; } 13 List<DeclItem>
Cputchr:
;;; { 13 CompoundStatement
;;; { 14 List<ExpressionStatement>
;;; { 15 ExpressionStatement
;;; { 16 Expr l(r)
;;; { 17 TypeName
;;; { 18 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 18 TypeSpecifier (all)
;;; { 18 List<DeclItem>
;;; { 19 DeclItem
;;; what = DECL_NAME
;;; name = P
;;; } 19 DeclItem
;;; } 18 List<DeclItem>
;;; } 17 TypeName
;;; { 17 ParameterDeclaration
;;; isEllipsis = false
;;; { 18 TypeName
;;; { 19 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 19 TypeSpecifier (struct/union)
;;; { 19 List<DeclItem>
;;; { 20 DeclItem
;;; what = DECL_POINTER
;;; { 21 List<Ptr>
;;; { 22 Ptr
;;; } 22 Ptr
;;; } 21 List<Ptr>
;;; } 20 DeclItem
;;; { 20 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 20 DeclItem
;;; } 19 List<DeclItem>
;;; } 18 TypeName
;;; } 17 ParameterDeclaration
;;; { 17 Expr & r
;-- load_address tx_sema
MOVE #Ctx_sema, RR
;;; } 17 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CP
;-- pop 2 bytes
ADD SP, #2
;;; } 16 Expr l(r)
;;; } 15 ExpressionStatement
;;; { 15 ExpressionStatement
;;; { 16 Expr l = r
;;; { 17 TypeName
;;; { 18 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 18 TypeSpecifier (all)
;;; { 18 List<DeclItem>
;;; { 19 DeclItem
;;; what = DECL_NAME
;;; name = serial_out_buffer
;;; } 19 DeclItem
;;; } 18 List<DeclItem>
;;; } 17 TypeName
;;; { 17 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = 2(FP), SP at 0 (8 bit)
MOVE 2(SP), RS
;;; } 17 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 17 Expr l[r]
;;; { 18 Expression (variable name)
;;; expr_type = "identifier" (serial_out_put)
;-- load_rr_var serial_out_put, (8 bit)
MOVE (Cserial_out_put), RU
;;; } 18 Expression (variable name)
;-- scale_rr *1
;-- add_address serial_out_buffer
ADD RR, #Cserial_out_buffer
;;; } 17 Expr l[r]
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (8 bit)
MOVE (SP)+, RU
;-- assign (8 bit)
MOVE R, (LL)
;;; } 16 Expr l = r
;;; } 15 ExpressionStatement
;;; { 15 IfElseStatement
;;; { 16 Expr l >= r
;;; { 17 TypeName (internal)
;;; { 18 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 18 TypeSpecifier (all)
;;; } 17 TypeName (internal)
;;; { 17 Expr ++r
;;; { 18 Expression (variable name)
;;; expr_type = "identifier" (serial_out_put)
;-- load_rr_var serial_out_put, (8 bit)
MOVE (Cserial_out_put), RU
;;; } 18 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var serial_out_put
MOVE R, (Cserial_out_put)
;;; } 17 Expr ++r
;-- l >= r
SHS RR, #0x0010
;;; } 16 Expr l >= r
;-- branch_false
JMP RRZ, L14_endif_32
;;; { 16 ExpressionStatement
;;; { 17 Expr l = r
;;; { 18 TypeName
;;; { 19 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 19 TypeSpecifier (all)
;;; { 19 List<DeclItem>
;;; { 20 DeclItem
;;; what = DECL_NAME
;;; name = serial_out_put
;;; } 20 DeclItem
;;; } 19 List<DeclItem>
;;; } 18 TypeName
;;; { 18 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 18 NumericExpression (constant 0 = 0x0)
;-- store_rr_var serial_out_put
MOVE R, (Cserial_out_put)
;;; } 17 Expr l = r
;;; } 16 ExpressionStatement
L14_endif_32:
;;; } 15 IfElseStatement
;;; { 15 ExpressionStatement
MOVE #0x07, RR
;;; } 15 ExpressionStatement
;;; { 15 ExpressionStatement
OUT R, (OUT_INT_MASK)
;;; } 15 ExpressionStatement
;;; { 15 ExpressionStatement
;;; { 16 NumericExpression (constant 1 = 0x1)
;-- load_rr_constant
MOVE #0x0001, RR
;;; } 16 NumericExpression (constant 1 = 0x1)
;;; } 15 ExpressionStatement
;;; } 14 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 13 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 13 FunctionDefinition
;;; { 14 TypeName
;;; { 15 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 15 TypeSpecifier (all)
;;; { 15 List<DeclItem>
;;; { 16 DeclItem
;;; what = DECL_NAME
;;; name = print_n
;;; } 16 DeclItem
;;; } 15 List<DeclItem>
;;; } 14 TypeName
;;; { 14 List<DeclItem>
;;; { 15 DeclItem
;;; what = DECL_NAME
;;; name = print_n
;;; } 15 DeclItem
;;; { 15 DeclItem
;;; what = DECL_FUN
;;; { 16 List<ParameterDeclaration>
;;; { 17 ParameterDeclaration
;;; isEllipsis = false
;;; { 18 TypeName
;;; { 19 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 19 TypeSpecifier (all)
;;; { 19 List<DeclItem>
;;; { 20 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 20 DeclItem
;;; } 19 List<DeclItem>
;;; } 18 TypeName
;;; } 17 ParameterDeclaration
;;; { 17 ParameterDeclaration
;;; isEllipsis = false
;;; { 18 TypeName
;;; { 19 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 19 TypeSpecifier (all)
;;; { 19 List<DeclItem>
;;; { 20 DeclItem
;;; what = DECL_NAME
;;; name = count
;;; } 20 DeclItem
;;; } 19 List<DeclItem>
;;; } 18 TypeName
;;; } 17 ParameterDeclaration
;;; } 16 List<ParameterDeclaration>
;;; } 15 DeclItem
;;; } 14 List<DeclItem>
Cprint_n:
;;; { 14 CompoundStatement
;;; { 15 List<for Statement>
;;; { 16 for Statement
;;; { 17 ExpressionStatement
;;; } 17 ExpressionStatement
;-- branch
JMP L15_tst_33
L15_loop_33:
;;; { 17 ExpressionStatement
;;; { 18 Expr l(r)
;;; { 19 TypeName
;;; { 20 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 20 TypeSpecifier (all)
;;; { 20 List<DeclItem>
;;; { 21 DeclItem
;;; what = DECL_NAME
;;; name = putchr
;;; } 21 DeclItem
;;; } 20 List<DeclItem>
;;; } 19 TypeName
;;; { 19 ParameterDeclaration
;;; isEllipsis = false
;;; { 20 TypeName
;;; { 21 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 21 TypeSpecifier (all)
;;; { 21 List<DeclItem>
;;; { 22 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 22 DeclItem
;;; } 21 List<DeclItem>
;;; } 20 TypeName
;;; } 19 ParameterDeclaration
;;; { 19 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = 2(FP), SP at 0 (8 bit)
MOVE 2(SP), RS
;;; } 19 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;-- push 2 bytes
;-- call
CALL Cputchr
;-- pop 1 bytes
ADD SP, #1
;;; } 18 Expr l(r)
;;; } 17 ExpressionStatement
L15_cont_33:
;;; { 17 Expr --r
;;; { 18 Expression (variable name)
;;; expr_type = "identifier" (count)
;-- load_rr_var count = 3(FP), SP at 0 (16 bit)
MOVE 3(SP), RR
;;; } 18 Expression (variable name)
;-- --
SUB RR, #0x0001
;-- store_rr_var count = 3(FP), SP at 0
MOVE RR, 3(SP)
;;; } 17 Expr --r
L15_tst_33:
;;; { 17 Expr l > r
;;; { 18 TypeName (internal)
;;; { 19 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 19 TypeSpecifier (all)
;;; } 18 TypeName (internal)
;;; { 18 Expression (variable name)
;;; expr_type = "identifier" (count)
;-- load_rr_var count = 3(FP), SP at 0 (16 bit)
MOVE 3(SP), RR
;;; } 18 Expression (variable name)
;-- l > r
SGT RR, #0x0000
;;; } 17 Expr l > r
;-- branch_true
JMP RRNZ, L15_loop_33
L15_brk_34:
;;; } 16 for Statement
;;; } 15 List<for Statement>
;-- pop 0 bytes
;;; } 14 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 14 FunctionDefinition
;;; { 15 TypeName
;;; { 16 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 16 TypeSpecifier (all)
;;; { 16 List<DeclItem>
;;; { 17 DeclItem
;;; what = DECL_NAME
;;; name = print_string
;;; } 17 DeclItem
;;; } 16 List<DeclItem>
;;; } 15 TypeName
;;; { 15 List<DeclItem>
;;; { 16 DeclItem
;;; what = DECL_NAME
;;; name = print_string
;;; } 16 DeclItem
;;; { 16 DeclItem
;;; what = DECL_FUN
;;; { 17 List<ParameterDeclaration>
;;; { 18 ParameterDeclaration
;;; isEllipsis = false
;;; { 19 TypeName
;;; { 20 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 20 TypeSpecifier (all)
;;; { 20 List<DeclItem>
;;; { 21 DeclItem
;;; what = DECL_POINTER
;;; { 22 List<Ptr>
;;; { 23 Ptr
;;; } 23 Ptr
;;; } 22 List<Ptr>
;;; } 21 DeclItem
;;; { 21 DeclItem
;;; what = DECL_NAME
;;; name = buffer
;;; } 21 DeclItem
;;; } 20 List<DeclItem>
;;; } 19 TypeName
;;; } 18 ParameterDeclaration
;;; } 17 List<ParameterDeclaration>
;;; } 16 DeclItem
;;; } 15 List<DeclItem>
Cprint_string:
;;; { 15 CompoundStatement
;;; { 16 List<while Statement>
;;; { 17 while Statement
;-- branch
JMP L16_cont_35
L16_loop_35:
;;; { 18 ExpressionStatement
;;; { 19 Expr l(r)
;;; { 20 TypeName
;;; { 21 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 21 TypeSpecifier (all)
;;; { 21 List<DeclItem>
;;; { 22 DeclItem
;;; what = DECL_NAME
;;; name = putchr
;;; } 22 DeclItem
;;; } 21 List<DeclItem>
;;; } 20 TypeName
;;; { 20 ParameterDeclaration
;;; isEllipsis = false
;;; { 21 TypeName
;;; { 22 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 22 TypeSpecifier (all)
;;; { 22 List<DeclItem>
;;; { 23 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 23 DeclItem
;;; } 22 List<DeclItem>
;;; } 21 TypeName
;;; } 20 ParameterDeclaration
;;; { 20 Expr * r
;;; { 21 Expr l - r
;;; { 22 Expr ++r
;;; { 23 Expression (variable name)
;;; expr_type = "identifier" (buffer)
;-- load_rr_var buffer = 2(FP), SP at 0 (16 bit)
MOVE 2(SP), RR
;;; } 23 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var buffer = 2(FP), SP at 0
MOVE RR, 2(SP)
;;; } 22 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 21 Expr l - r
;-- content
MOVE (RR), RS
;;; } 20 Expr * r
;-- push_rr (8 bit)
MOVE R, -(SP)
;-- push 2 bytes
;-- call
CALL Cputchr
;-- pop 1 bytes
ADD SP, #1
;;; } 19 Expr l(r)
;;; } 18 ExpressionStatement
L16_cont_35:
;;; { 18 Expr * r
;;; { 19 Expression (variable name)
;;; expr_type = "identifier" (buffer)
;-- load_rr_var buffer = 2(FP), SP at 0 (16 bit)
MOVE 2(SP), RR
;;; } 19 Expression (variable name)
;-- content
MOVE (RR), RS
;;; } 18 Expr * r
;-- branch_true
JMP RRNZ, L16_loop_35
L16_brk_36:
;;; } 17 while Statement
;;; } 16 List<while Statement>
;-- pop 0 bytes
;;; } 15 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 15 FunctionDefinition
;;; { 16 TypeName
;;; { 17 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 17 TypeSpecifier (all)
;;; { 17 List<DeclItem>
;;; { 18 DeclItem
;;; what = DECL_NAME
;;; name = print_hex
;;; } 18 DeclItem
;;; } 17 List<DeclItem>
;;; } 16 TypeName
;;; { 16 List<DeclItem>
;;; { 17 DeclItem
;;; what = DECL_NAME
;;; name = print_hex
;;; } 17 DeclItem
;;; { 17 DeclItem
;;; what = DECL_FUN
;;; { 18 List<ParameterDeclaration>
;;; { 19 ParameterDeclaration
;;; isEllipsis = false
;;; { 20 TypeName
;;; { 21 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 21 TypeSpecifier (all)
;;; { 21 List<DeclItem>
;;; { 22 DeclItem
;;; what = DECL_POINTER
;;; { 23 List<Ptr>
;;; { 24 Ptr
;;; } 24 Ptr
;;; } 23 List<Ptr>
;;; } 22 DeclItem
;;; { 22 DeclItem
;;; what = DECL_NAME
;;; name = dest
;;; } 22 DeclItem
;;; } 21 List<DeclItem>
;;; } 20 TypeName
;;; } 19 ParameterDeclaration
;;; { 19 ParameterDeclaration
;;; isEllipsis = false
;;; { 20 TypeName
;;; { 21 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 21 TypeSpecifier (all)
;;; { 21 List<DeclItem>
;;; { 22 DeclItem
;;; what = DECL_NAME
;;; name = value
;;; } 22 DeclItem
;;; } 21 List<DeclItem>
;;; } 20 TypeName
;;; } 19 ParameterDeclaration
;;; { 19 ParameterDeclaration
;;; isEllipsis = false
;;; { 20 TypeName
;;; { 21 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 21 TypeSpecifier (all)
;;; { 21 List<DeclItem>
;;; { 22 DeclItem
;;; what = DECL_POINTER
;;; { 23 List<Ptr>
;;; { 24 Ptr
;;; } 24 Ptr
;;; } 23 List<Ptr>
;;; } 22 DeclItem
;;; { 22 DeclItem
;;; what = DECL_NAME
;;; name = hex
;;; } 22 DeclItem
;;; } 21 List<DeclItem>
;;; } 20 TypeName
;;; } 19 ParameterDeclaration
;;; } 18 List<ParameterDeclaration>
;;; } 17 DeclItem
;;; } 16 List<DeclItem>
Cprint_hex:
;;; { 16 CompoundStatement
;;; { 17 List<IfElseStatement>
;;; { 18 IfElseStatement
;;; { 19 Expr l >= r
;;; { 20 TypeName (internal)
;;; { 21 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 21 TypeSpecifier (all)
;;; } 20 TypeName (internal)
;;; { 20 Expression (variable name)
;;; expr_type = "identifier" (value)
;-- load_rr_var value = 4(FP), SP at 0 (16 bit)
MOVE 4(SP), RR
;;; } 20 Expression (variable name)
;-- l >= r
SHS RR, #0x1000
;;; } 19 Expr l >= r
;-- branch_false
JMP RRZ, L17_endif_37
;;; { 19 ExpressionStatement
;;; { 20 Expr l = r
;;; { 21 TypeName
;;; { 22 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 22 TypeSpecifier (all)
;;; { 22 List<DeclItem>
;;; { 23 DeclItem
;;; what = DECL_NAME
;;; name = dest
;;; } 23 DeclItem
;;; } 22 List<DeclItem>
;;; } 21 TypeName
;;; { 21 Expr l[r]
;;; { 22 TypeName
;;; { 23 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 23 TypeSpecifier (all)
;;; { 23 List<DeclItem>
;;; { 24 DeclItem
;;; what = DECL_NAME
;;; name = hex
;;; } 24 DeclItem
;;; } 23 List<DeclItem>
;;; } 22 TypeName
;;; { 22 Expr l[r]
;;; { 23 Expr l & r
;;; { 24 TypeName (internal)
;;; { 25 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 25 TypeSpecifier (all)
;;; } 24 TypeName (internal)
;;; { 24 Expr l >> r
;;; { 25 TypeName (internal)
;;; { 26 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 26 TypeSpecifier (all)
;;; } 25 TypeName (internal)
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (value)
;-- load_rr_var value = 4(FP), SP at 0 (16 bit)
MOVE 4(SP), RR
;;; } 25 Expression (variable name)
;-- l >> r
ASR RR, #0x000C
;;; } 24 Expr l >> r
;-- l & r
AND RR, #0x000F
;;; } 23 Expr l & r
;-- scale_rr *1
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 23 Expression (variable name)
;;; expr_type = "identifier" (hex)
;-- load_rr_var hex = 6(FP), SP at -2 (16 bit)
MOVE 8(SP), RR
;;; } 23 Expression (variable name)
;-- pop_ll (16 bit)
MOVE (SP)+, LL
;-- + (element)
ADD LL, RR
;;; } 22 Expr l[r]
;-- content
MOVE (RR), RS
;;; } 21 Expr l[r]
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 21 Expr * r
;;; { 22 Expr l - r
;;; { 23 Expr ++r
;;; { 24 Expression (variable name)
;;; expr_type = "identifier" (dest)
;-- load_rr_var dest = 2(FP), SP at -1 (16 bit)
MOVE 3(SP), RR
;;; } 24 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var dest = 2(FP), SP at -1
MOVE RR, 3(SP)
;;; } 23 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 22 Expr l - r
;;; } 21 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (8 bit)
MOVE (SP)+, RS
;-- assign (8 bit)
MOVE R, (LL)
;;; } 20 Expr l = r
;;; } 19 ExpressionStatement
L17_endif_37:
;;; } 18 IfElseStatement
;;; { 18 IfElseStatement
;;; { 19 Expr l >= r
;;; { 20 TypeName (internal)
;;; { 21 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 21 TypeSpecifier (all)
;;; } 20 TypeName (internal)
;;; { 20 Expression (variable name)
;;; expr_type = "identifier" (value)
;-- load_rr_var value = 4(FP), SP at 0 (16 bit)
MOVE 4(SP), RR
;;; } 20 Expression (variable name)
;-- l >= r
SHS RR, #0x0100
;;; } 19 Expr l >= r
;-- branch_false
JMP RRZ, L17_endif_38
;;; { 19 ExpressionStatement
;;; { 20 Expr l = r
;;; { 21 TypeName
;;; { 22 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 22 TypeSpecifier (all)
;;; { 22 List<DeclItem>
;;; { 23 DeclItem
;;; what = DECL_NAME
;;; name = dest
;;; } 23 DeclItem
;;; } 22 List<DeclItem>
;;; } 21 TypeName
;;; { 21 Expr l[r]
;;; { 22 TypeName
;;; { 23 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 23 TypeSpecifier (all)
;;; { 23 List<DeclItem>
;;; { 24 DeclItem
;;; what = DECL_NAME
;;; name = hex
;;; } 24 DeclItem
;;; } 23 List<DeclItem>
;;; } 22 TypeName
;;; { 22 Expr l[r]
;;; { 23 Expr l & r
;;; { 24 TypeName (internal)
;;; { 25 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 25 TypeSpecifier (all)
;;; } 24 TypeName (internal)
;;; { 24 Expr l >> r
;;; { 25 TypeName (internal)
;;; { 26 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 26 TypeSpecifier (all)
;;; } 25 TypeName (internal)
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (value)
;-- load_rr_var value = 4(FP), SP at 0 (16 bit)
MOVE 4(SP), RR
;;; } 25 Expression (variable name)
;-- l >> r
ASR RR, #0x0008
;;; } 24 Expr l >> r
;-- l & r
AND RR, #0x000F
;;; } 23 Expr l & r
;-- scale_rr *1
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 23 Expression (variable name)
;;; expr_type = "identifier" (hex)
;-- load_rr_var hex = 6(FP), SP at -2 (16 bit)
MOVE 8(SP), RR
;;; } 23 Expression (variable name)
;-- pop_ll (16 bit)
MOVE (SP)+, LL
;-- + (element)
ADD LL, RR
;;; } 22 Expr l[r]
;-- content
MOVE (RR), RS
;;; } 21 Expr l[r]
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 21 Expr * r
;;; { 22 Expr l - r
;;; { 23 Expr ++r
;;; { 24 Expression (variable name)
;;; expr_type = "identifier" (dest)
;-- load_rr_var dest = 2(FP), SP at -1 (16 bit)
MOVE 3(SP), RR
;;; } 24 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var dest = 2(FP), SP at -1
MOVE RR, 3(SP)
;;; } 23 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 22 Expr l - r
;;; } 21 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (8 bit)
MOVE (SP)+, RS
;-- assign (8 bit)
MOVE R, (LL)
;;; } 20 Expr l = r
;;; } 19 ExpressionStatement
L17_endif_38:
;;; } 18 IfElseStatement
;;; { 18 IfElseStatement
;;; { 19 Expr l >= r
;;; { 20 TypeName (internal)
;;; { 21 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 21 TypeSpecifier (all)
;;; } 20 TypeName (internal)
;;; { 20 Expression (variable name)
;;; expr_type = "identifier" (value)
;-- load_rr_var value = 4(FP), SP at 0 (16 bit)
MOVE 4(SP), RR
;;; } 20 Expression (variable name)
;-- l >= r
SHS RR, #0x0010
;;; } 19 Expr l >= r
;-- branch_false
JMP RRZ, L17_endif_39
;;; { 19 ExpressionStatement
;;; { 20 Expr l = r
;;; { 21 TypeName
;;; { 22 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 22 TypeSpecifier (all)
;;; { 22 List<DeclItem>
;;; { 23 DeclItem
;;; what = DECL_NAME
;;; name = dest
;;; } 23 DeclItem
;;; } 22 List<DeclItem>
;;; } 21 TypeName
;;; { 21 Expr l[r]
;;; { 22 TypeName
;;; { 23 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 23 TypeSpecifier (all)
;;; { 23 List<DeclItem>
;;; { 24 DeclItem
;;; what = DECL_NAME
;;; name = hex
;;; } 24 DeclItem
;;; } 23 List<DeclItem>
;;; } 22 TypeName
;;; { 22 Expr l[r]
;;; { 23 Expr l & r
;;; { 24 TypeName (internal)
;;; { 25 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 25 TypeSpecifier (all)
;;; } 24 TypeName (internal)
;;; { 24 Expr l >> r
;;; { 25 TypeName (internal)
;;; { 26 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 26 TypeSpecifier (all)
;;; } 25 TypeName (internal)
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (value)
;-- load_rr_var value = 4(FP), SP at 0 (16 bit)
MOVE 4(SP), RR
;;; } 25 Expression (variable name)
;-- l >> r
ASR RR, #0x0004
;;; } 24 Expr l >> r
;-- l & r
AND RR, #0x000F
;;; } 23 Expr l & r
;-- scale_rr *1
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 23 Expression (variable name)
;;; expr_type = "identifier" (hex)
;-- load_rr_var hex = 6(FP), SP at -2 (16 bit)
MOVE 8(SP), RR
;;; } 23 Expression (variable name)
;-- pop_ll (16 bit)
MOVE (SP)+, LL
;-- + (element)
ADD LL, RR
;;; } 22 Expr l[r]
;-- content
MOVE (RR), RS
;;; } 21 Expr l[r]
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 21 Expr * r
;;; { 22 Expr l - r
;;; { 23 Expr ++r
;;; { 24 Expression (variable name)
;;; expr_type = "identifier" (dest)
;-- load_rr_var dest = 2(FP), SP at -1 (16 bit)
MOVE 3(SP), RR
;;; } 24 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var dest = 2(FP), SP at -1
MOVE RR, 3(SP)
;;; } 23 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 22 Expr l - r
;;; } 21 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (8 bit)
MOVE (SP)+, RS
;-- assign (8 bit)
MOVE R, (LL)
;;; } 20 Expr l = r
;;; } 19 ExpressionStatement
L17_endif_39:
;;; } 18 IfElseStatement
;;; { 18 ExpressionStatement
;;; { 19 Expr l = r
;;; { 20 TypeName
;;; { 21 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 21 TypeSpecifier (all)
;;; { 21 List<DeclItem>
;;; { 22 DeclItem
;;; what = DECL_NAME
;;; name = dest
;;; } 22 DeclItem
;;; } 21 List<DeclItem>
;;; } 20 TypeName
;;; { 20 Expr l[r]
;;; { 21 TypeName
;;; { 22 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 22 TypeSpecifier (all)
;;; { 22 List<DeclItem>
;;; { 23 DeclItem
;;; what = DECL_NAME
;;; name = hex
;;; } 23 DeclItem
;;; } 22 List<DeclItem>
;;; } 21 TypeName
;;; { 21 Expr l[r]
;;; { 22 Expr l & r
;;; { 23 TypeName (internal)
;;; { 24 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 24 TypeSpecifier (all)
;;; } 23 TypeName (internal)
;;; { 23 Expression (variable name)
;;; expr_type = "identifier" (value)
;-- load_rr_var value = 4(FP), SP at 0 (16 bit)
MOVE 4(SP), RR
;;; } 23 Expression (variable name)
;-- l & r
AND RR, #0x000F
;;; } 22 Expr l & r
;-- scale_rr *1
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 22 Expression (variable name)
;;; expr_type = "identifier" (hex)
;-- load_rr_var hex = 6(FP), SP at -2 (16 bit)
MOVE 8(SP), RR
;;; } 22 Expression (variable name)
;-- pop_ll (16 bit)
MOVE (SP)+, LL
;-- + (element)
ADD LL, RR
;;; } 21 Expr l[r]
;-- content
MOVE (RR), RS
;;; } 20 Expr l[r]
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 20 Expr * r
;;; { 21 Expr l - r
;;; { 22 Expr ++r
;;; { 23 Expression (variable name)
;;; expr_type = "identifier" (dest)
;-- load_rr_var dest = 2(FP), SP at -1 (16 bit)
MOVE 3(SP), RR
;;; } 23 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var dest = 2(FP), SP at -1
MOVE RR, 3(SP)
;;; } 22 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 21 Expr l - r
;;; } 20 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (8 bit)
MOVE (SP)+, RS
;-- assign (8 bit)
MOVE R, (LL)
;;; } 19 Expr l = r
;;; } 18 ExpressionStatement
;;; { 18 ExpressionStatement
;;; { 19 Expr l = r
;;; { 20 TypeName
;;; { 21 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 21 TypeSpecifier (all)
;;; { 21 List<DeclItem>
;;; { 22 DeclItem
;;; what = DECL_NAME
;;; name = dest
;;; } 22 DeclItem
;;; } 21 List<DeclItem>
;;; } 20 TypeName
;;; { 20 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 20 NumericExpression (constant 0 = 0x0)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 20 Expr * r
;;; { 21 Expression (variable name)
;;; expr_type = "identifier" (dest)
;-- load_rr_var dest = 2(FP), SP at -1 (16 bit)
MOVE 3(SP), RR
;;; } 21 Expression (variable name)
;;; } 20 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (8 bit)
MOVE (SP)+, RS
;-- assign (8 bit)
MOVE R, (LL)
;;; } 19 Expr l = r
;;; } 18 ExpressionStatement
;;; } 17 List<IfElseStatement>
;-- pop 0 bytes
;;; } 16 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 16 FunctionDefinition
;;; { 17 TypeName
;;; { 18 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 18 TypeSpecifier (all)
;;; { 18 List<DeclItem>
;;; { 19 DeclItem
;;; what = DECL_NAME
;;; name = print_unsigned
;;; } 19 DeclItem
;;; } 18 List<DeclItem>
;;; } 17 TypeName
;;; { 17 List<DeclItem>
;;; { 18 DeclItem
;;; what = DECL_NAME
;;; name = print_unsigned
;;; } 18 DeclItem
;;; { 18 DeclItem
;;; what = DECL_FUN
;;; { 19 List<ParameterDeclaration>
;;; { 20 ParameterDeclaration
;;; isEllipsis = false
;;; { 21 TypeName
;;; { 22 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 22 TypeSpecifier (all)
;;; { 22 List<DeclItem>
;;; { 23 DeclItem
;;; what = DECL_POINTER
;;; { 24 List<Ptr>
;;; { 25 Ptr
;;; } 25 Ptr
;;; } 24 List<Ptr>
;;; } 23 DeclItem
;;; { 23 DeclItem
;;; what = DECL_NAME
;;; name = dest
;;; } 23 DeclItem
;;; } 22 List<DeclItem>
;;; } 21 TypeName
;;; } 20 ParameterDeclaration
;;; { 20 ParameterDeclaration
;;; isEllipsis = false
;;; { 21 TypeName
;;; { 22 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 22 TypeSpecifier (all)
;;; { 22 List<DeclItem>
;;; { 23 DeclItem
;;; what = DECL_NAME
;;; name = value
;;; } 23 DeclItem
;;; } 22 List<DeclItem>
;;; } 21 TypeName
;;; } 20 ParameterDeclaration
;;; } 19 List<ParameterDeclaration>
;;; } 18 DeclItem
;;; } 17 List<DeclItem>
Cprint_unsigned:
;;; { 17 CompoundStatement
;;; { 18 List<IfElseStatement>
;;; { 19 IfElseStatement
;;; { 20 Expr l >= r
;;; { 21 TypeName (internal)
;;; { 22 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 22 TypeSpecifier (all)
;;; } 21 TypeName (internal)
;;; { 21 Expression (variable name)
;;; expr_type = "identifier" (value)
;-- load_rr_var value = 4(FP), SP at 0 (16 bit)
MOVE 4(SP), RR
;;; } 21 Expression (variable name)
;-- l >= r
SHS RR, #0x2710
;;; } 20 Expr l >= r
;-- branch_false
JMP RRZ, L18_endif_40
;;; { 20 ExpressionStatement
;;; { 21 Expr l = r
;;; { 22 TypeName
;;; { 23 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 23 TypeSpecifier (all)
;;; { 23 List<DeclItem>
;;; { 24 DeclItem
;;; what = DECL_NAME
;;; name = dest
;;; } 24 DeclItem
;;; } 23 List<DeclItem>
;;; } 22 TypeName
;;; { 22 Expr l + r
;;; { 23 Expr l / r
;;; { 24 TypeName (internal)
;;; { 25 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 25 TypeSpecifier (all)
;;; } 24 TypeName (internal)
;;; { 24 Expression (variable name)
;;; expr_type = "identifier" (value)
;-- load_rr_var value = 4(FP), SP at 0 (16 bit)
MOVE 4(SP), RR
;;; } 24 Expression (variable name)
;-- l / r
MOVE RR, LL
MOVE #0x2710, RR
;-- l / r
DI
DIV_IU
CALL mult_div
MD_FIN
EI
;;; } 23 Expr l / r
;-- l + r
ADD RR, #0x0030
;;; } 22 Expr l + r
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 22 Expr * r
;;; { 23 Expr l - r
;;; { 24 Expr ++r
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (dest)
;-- load_rr_var dest = 2(FP), SP at -1 (16 bit)
MOVE 3(SP), RR
;;; } 25 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var dest = 2(FP), SP at -1
MOVE RR, 3(SP)
;;; } 24 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 23 Expr l - r
;;; } 22 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (8 bit)
MOVE (SP)+, RS
;-- assign (8 bit)
MOVE R, (LL)
;;; } 21 Expr l = r
;;; } 20 ExpressionStatement
L18_endif_40:
;;; } 19 IfElseStatement
;;; { 19 IfElseStatement
;;; { 20 Expr l >= r
;;; { 21 TypeName (internal)
;;; { 22 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 22 TypeSpecifier (all)
;;; } 21 TypeName (internal)
;;; { 21 Expression (variable name)
;;; expr_type = "identifier" (value)
;-- load_rr_var value = 4(FP), SP at 0 (16 bit)
MOVE 4(SP), RR
;;; } 21 Expression (variable name)
;-- l >= r
SHS RR, #0x03E8
;;; } 20 Expr l >= r
;-- branch_false
JMP RRZ, L18_endif_41
;;; { 20 ExpressionStatement
;;; { 21 Expr l = r
;;; { 22 TypeName
;;; { 23 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 23 TypeSpecifier (all)
;;; { 23 List<DeclItem>
;;; { 24 DeclItem
;;; what = DECL_NAME
;;; name = dest
;;; } 24 DeclItem
;;; } 23 List<DeclItem>
;;; } 22 TypeName
;;; { 22 Expr l + r
;;; { 23 Expr l % r
;;; { 24 TypeName (internal)
;;; { 25 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 25 TypeSpecifier (all)
;;; } 24 TypeName (internal)
;;; { 24 Expr l / r
;;; { 25 TypeName (internal)
;;; { 26 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 26 TypeSpecifier (all)
;;; } 25 TypeName (internal)
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (value)
;-- load_rr_var value = 4(FP), SP at 0 (16 bit)
MOVE 4(SP), RR
;;; } 25 Expression (variable name)
;-- l / r
MOVE RR, LL
MOVE #0x03E8, RR
;-- l / r
DI
DIV_IU
CALL mult_div
MD_FIN
EI
;;; } 24 Expr l / r
;-- l % r
MOVE RR, LL
MOVE #0x000A, RR
;-- l % r
DI
DIV_IU
CALL mult_div
MOD_FIN
EI
;;; } 23 Expr l % r
;-- l + r
ADD RR, #0x0030
;;; } 22 Expr l + r
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 22 Expr * r
;;; { 23 Expr l - r
;;; { 24 Expr ++r
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (dest)
;-- load_rr_var dest = 2(FP), SP at -1 (16 bit)
MOVE 3(SP), RR
;;; } 25 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var dest = 2(FP), SP at -1
MOVE RR, 3(SP)
;;; } 24 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 23 Expr l - r
;;; } 22 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (8 bit)
MOVE (SP)+, RS
;-- assign (8 bit)
MOVE R, (LL)
;;; } 21 Expr l = r
;;; } 20 ExpressionStatement
L18_endif_41:
;;; } 19 IfElseStatement
;;; { 19 IfElseStatement
;;; { 20 Expr l >= r
;;; { 21 TypeName (internal)
;;; { 22 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 22 TypeSpecifier (all)
;;; } 21 TypeName (internal)
;;; { 21 Expression (variable name)
;;; expr_type = "identifier" (value)
;-- load_rr_var value = 4(FP), SP at 0 (16 bit)
MOVE 4(SP), RR
;;; } 21 Expression (variable name)
;-- l >= r
SHS RR, #0x0064
;;; } 20 Expr l >= r
;-- branch_false
JMP RRZ, L18_endif_42
;;; { 20 ExpressionStatement
;;; { 21 Expr l = r
;;; { 22 TypeName
;;; { 23 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 23 TypeSpecifier (all)
;;; { 23 List<DeclItem>
;;; { 24 DeclItem
;;; what = DECL_NAME
;;; name = dest
;;; } 24 DeclItem
;;; } 23 List<DeclItem>
;;; } 22 TypeName
;;; { 22 Expr l + r
;;; { 23 Expr l % r
;;; { 24 TypeName (internal)
;;; { 25 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 25 TypeSpecifier (all)
;;; } 24 TypeName (internal)
;;; { 24 Expr l / r
;;; { 25 TypeName (internal)
;;; { 26 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 26 TypeSpecifier (all)
;;; } 25 TypeName (internal)
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (value)
;-- load_rr_var value = 4(FP), SP at 0 (16 bit)
MOVE 4(SP), RR
;;; } 25 Expression (variable name)
;-- l / r
MOVE RR, LL
MOVE #0x0064, RR
;-- l / r
DI
DIV_IU
CALL mult_div
MD_FIN
EI
;;; } 24 Expr l / r
;-- l % r
MOVE RR, LL
MOVE #0x000A, RR
;-- l % r
DI
DIV_IU
CALL mult_div
MOD_FIN
EI
;;; } 23 Expr l % r
;-- l + r
ADD RR, #0x0030
;;; } 22 Expr l + r
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 22 Expr * r
;;; { 23 Expr l - r
;;; { 24 Expr ++r
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (dest)
;-- load_rr_var dest = 2(FP), SP at -1 (16 bit)
MOVE 3(SP), RR
;;; } 25 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var dest = 2(FP), SP at -1
MOVE RR, 3(SP)
;;; } 24 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 23 Expr l - r
;;; } 22 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (8 bit)
MOVE (SP)+, RS
;-- assign (8 bit)
MOVE R, (LL)
;;; } 21 Expr l = r
;;; } 20 ExpressionStatement
L18_endif_42:
;;; } 19 IfElseStatement
;;; { 19 IfElseStatement
;;; { 20 Expr l >= r
;;; { 21 TypeName (internal)
;;; { 22 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 22 TypeSpecifier (all)
;;; } 21 TypeName (internal)
;;; { 21 Expression (variable name)
;;; expr_type = "identifier" (value)
;-- load_rr_var value = 4(FP), SP at 0 (16 bit)
MOVE 4(SP), RR
;;; } 21 Expression (variable name)
;-- l >= r
SHS RR, #0x000A
;;; } 20 Expr l >= r
;-- branch_false
JMP RRZ, L18_endif_43
;;; { 20 ExpressionStatement
;;; { 21 Expr l = r
;;; { 22 TypeName
;;; { 23 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 23 TypeSpecifier (all)
;;; { 23 List<DeclItem>
;;; { 24 DeclItem
;;; what = DECL_NAME
;;; name = dest
;;; } 24 DeclItem
;;; } 23 List<DeclItem>
;;; } 22 TypeName
;;; { 22 Expr l + r
;;; { 23 Expr l % r
;;; { 24 TypeName (internal)
;;; { 25 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 25 TypeSpecifier (all)
;;; } 24 TypeName (internal)
;;; { 24 Expr l / r
;;; { 25 TypeName (internal)
;;; { 26 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 26 TypeSpecifier (all)
;;; } 25 TypeName (internal)
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (value)
;-- load_rr_var value = 4(FP), SP at 0 (16 bit)
MOVE 4(SP), RR
;;; } 25 Expression (variable name)
;-- l / r
MOVE RR, LL
MOVE #0x000A, RR
;-- l / r
DI
DIV_IU
CALL mult_div
MD_FIN
EI
;;; } 24 Expr l / r
;-- l % r
MOVE RR, LL
MOVE #0x000A, RR
;-- l % r
DI
DIV_IU
CALL mult_div
MOD_FIN
EI
;;; } 23 Expr l % r
;-- l + r
ADD RR, #0x0030
;;; } 22 Expr l + r
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 22 Expr * r
;;; { 23 Expr l - r
;;; { 24 Expr ++r
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (dest)
;-- load_rr_var dest = 2(FP), SP at -1 (16 bit)
MOVE 3(SP), RR
;;; } 25 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var dest = 2(FP), SP at -1
MOVE RR, 3(SP)
;;; } 24 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 23 Expr l - r
;;; } 22 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (8 bit)
MOVE (SP)+, RS
;-- assign (8 bit)
MOVE R, (LL)
;;; } 21 Expr l = r
;;; } 20 ExpressionStatement
L18_endif_43:
;;; } 19 IfElseStatement
;;; { 19 ExpressionStatement
;;; { 20 Expr l = r
;;; { 21 TypeName
;;; { 22 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 22 TypeSpecifier (all)
;;; { 22 List<DeclItem>
;;; { 23 DeclItem
;;; what = DECL_NAME
;;; name = dest
;;; } 23 DeclItem
;;; } 22 List<DeclItem>
;;; } 21 TypeName
;;; { 21 Expr l + r
;;; { 22 Expr l % r
;;; { 23 TypeName (internal)
;;; { 24 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 24 TypeSpecifier (all)
;;; } 23 TypeName (internal)
;;; { 23 Expression (variable name)
;;; expr_type = "identifier" (value)
;-- load_rr_var value = 4(FP), SP at 0 (16 bit)
MOVE 4(SP), RR
;;; } 23 Expression (variable name)
;-- l % r
MOVE RR, LL
MOVE #0x000A, RR
;-- l % r
DI
DIV_IU
CALL mult_div
MOD_FIN
EI
;;; } 22 Expr l % r
;-- l + r
ADD RR, #0x0030
;;; } 21 Expr l + r
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 21 Expr * r
;;; { 22 Expr l - r
;;; { 23 Expr ++r
;;; { 24 Expression (variable name)
;;; expr_type = "identifier" (dest)
;-- load_rr_var dest = 2(FP), SP at -1 (16 bit)
MOVE 3(SP), RR
;;; } 24 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var dest = 2(FP), SP at -1
MOVE RR, 3(SP)
;;; } 23 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 22 Expr l - r
;;; } 21 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (8 bit)
MOVE (SP)+, RS
;-- assign (8 bit)
MOVE R, (LL)
;;; } 20 Expr l = r
;;; } 19 ExpressionStatement
;;; { 19 ExpressionStatement
;;; { 20 Expr l = r
;;; { 21 TypeName
;;; { 22 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 22 TypeSpecifier (all)
;;; { 22 List<DeclItem>
;;; { 23 DeclItem
;;; what = DECL_NAME
;;; name = dest
;;; } 23 DeclItem
;;; } 22 List<DeclItem>
;;; } 21 TypeName
;;; { 21 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 21 NumericExpression (constant 0 = 0x0)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 21 Expr * r
;;; { 22 Expression (variable name)
;;; expr_type = "identifier" (dest)
;-- load_rr_var dest = 2(FP), SP at -1 (16 bit)
MOVE 3(SP), RR
;;; } 22 Expression (variable name)
;;; } 21 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (8 bit)
MOVE (SP)+, RS
;-- assign (8 bit)
MOVE R, (LL)
;;; } 20 Expr l = r
;;; } 19 ExpressionStatement
;;; } 18 List<IfElseStatement>
;-- pop 0 bytes
;;; } 17 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 17 FunctionDefinition
;;; { 18 TypeName
;;; { 19 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 19 TypeSpecifier (all)
;;; { 19 List<DeclItem>
;;; { 20 DeclItem
;;; what = DECL_NAME
;;; name = print_item
;;; } 20 DeclItem
;;; } 19 List<DeclItem>
;;; } 18 TypeName
;;; { 18 List<DeclItem>
;;; { 19 DeclItem
;;; what = DECL_NAME
;;; name = print_item
;;; } 19 DeclItem
;;; { 19 DeclItem
;;; what = DECL_FUN
;;; { 20 List<ParameterDeclaration>
;;; { 21 ParameterDeclaration
;;; isEllipsis = false
;;; { 22 TypeName
;;; { 23 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 23 TypeSpecifier (all)
;;; { 23 List<DeclItem>
;;; { 24 DeclItem
;;; what = DECL_POINTER
;;; { 25 List<Ptr>
;;; { 26 Ptr
;;; } 26 Ptr
;;; } 25 List<Ptr>
;;; } 24 DeclItem
;;; { 24 DeclItem
;;; what = DECL_NAME
;;; name = buffer
;;; } 24 DeclItem
;;; } 23 List<DeclItem>
;;; } 22 TypeName
;;; } 21 ParameterDeclaration
;;; { 21 ParameterDeclaration
;;; isEllipsis = false
;;; { 22 TypeName
;;; { 23 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 23 TypeSpecifier (all)
;;; { 23 List<DeclItem>
;;; { 24 DeclItem
;;; what = DECL_NAME
;;; name = flags
;;; } 24 DeclItem
;;; } 23 List<DeclItem>
;;; } 22 TypeName
;;; } 21 ParameterDeclaration
;;; { 21 ParameterDeclaration
;;; isEllipsis = false
;;; { 22 TypeName
;;; { 23 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 23 TypeSpecifier (all)
;;; { 23 List<DeclItem>
;;; { 24 DeclItem
;;; what = DECL_NAME
;;; name = sign
;;; } 24 DeclItem
;;; } 23 List<DeclItem>
;;; } 22 TypeName
;;; } 21 ParameterDeclaration
;;; { 21 ParameterDeclaration
;;; isEllipsis = false
;;; { 22 TypeName
;;; { 23 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 23 TypeSpecifier (all)
;;; { 23 List<DeclItem>
;;; { 24 DeclItem
;;; what = DECL_NAME
;;; name = pad
;;; } 24 DeclItem
;;; } 23 List<DeclItem>
;;; } 22 TypeName
;;; } 21 ParameterDeclaration
;;; { 21 ParameterDeclaration
;;; isEllipsis = false
;;; { 22 TypeName
;;; { 23 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 23 TypeSpecifier (all)
;;; { 23 List<DeclItem>
;;; { 24 DeclItem
;;; what = DECL_POINTER
;;; { 25 List<Ptr>
;;; { 26 Ptr
;;; } 26 Ptr
;;; } 25 List<Ptr>
;;; } 24 DeclItem
;;; { 24 DeclItem
;;; what = DECL_NAME
;;; name = alt
;;; } 24 DeclItem
;;; } 23 List<DeclItem>
;;; } 22 TypeName
;;; } 21 ParameterDeclaration
;;; { 21 ParameterDeclaration
;;; isEllipsis = false
;;; { 22 TypeName
;;; { 23 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 23 TypeSpecifier (all)
;;; { 23 List<DeclItem>
;;; { 24 DeclItem
;;; what = DECL_NAME
;;; name = field_w
;;; } 24 DeclItem
;;; } 23 List<DeclItem>
;;; } 22 TypeName
;;; } 21 ParameterDeclaration
;;; { 21 ParameterDeclaration
;;; isEllipsis = false
;;; { 22 TypeName
;;; { 23 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 23 TypeSpecifier (all)
;;; { 23 List<DeclItem>
;;; { 24 DeclItem
;;; what = DECL_NAME
;;; name = min_w
;;; } 24 DeclItem
;;; } 23 List<DeclItem>
;;; } 22 TypeName
;;; } 21 ParameterDeclaration
;;; { 21 ParameterDeclaration
;;; isEllipsis = false
;;; { 22 TypeName
;;; { 23 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 23 TypeSpecifier (all)
;;; { 23 List<DeclItem>
;;; { 24 DeclItem
;;; what = DECL_NAME
;;; name = min_p
;;; } 24 DeclItem
;;; } 23 List<DeclItem>
;;; } 22 TypeName
;;; } 21 ParameterDeclaration
;;; } 20 List<ParameterDeclaration>
;;; } 19 DeclItem
;;; } 18 List<DeclItem>
Cprint_item:
;;; { 18 CompoundStatement
;;; { 19 InitDeclarator
;;; { 20 List<DeclItem>
;;; { 21 DeclItem
;;; what = DECL_NAME
;;; name = filllen
;;; } 21 DeclItem
;;; } 20 List<DeclItem>
;;; { 20 Initializer (skalar)
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 20 Initializer (skalar)
;;; } 19 InitDeclarator
;;; { 19 InitDeclarator
;;; { 20 List<DeclItem>
;;; { 21 DeclItem
;;; what = DECL_NAME
;;; name = signlen
;;; } 21 DeclItem
;;; } 20 List<DeclItem>
;;; { 20 Initializer (skalar)
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 20 Initializer (skalar)
;;; } 19 InitDeclarator
;;; { 19 InitDeclarator
;;; { 20 List<DeclItem>
;;; { 21 DeclItem
;;; what = DECL_NAME
;;; name = altlen
;;; } 21 DeclItem
;;; } 20 List<DeclItem>
;;; { 20 Initializer (skalar)
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 20 Initializer (skalar)
;;; } 19 InitDeclarator
;;; { 19 InitDeclarator
;;; { 20 List<DeclItem>
;;; { 21 DeclItem
;;; what = DECL_NAME
;;; name = padlen
;;; } 21 DeclItem
;;; } 20 List<DeclItem>
;;; { 20 Initializer (skalar)
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 20 Initializer (skalar)
;;; } 19 InitDeclarator
;;; { 19 InitDeclarator
;;; { 20 List<DeclItem>
;;; { 21 DeclItem
;;; what = DECL_NAME
;;; name = buflen
;;; } 21 DeclItem
;;; } 20 List<DeclItem>
;;; { 20 Initializer (skalar)
;;; { 21 Expr l(r)
;;; { 22 TypeName
;;; { 23 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 23 TypeSpecifier (all)
;;; { 23 List<DeclItem>
;;; { 24 DeclItem
;;; what = DECL_NAME
;;; name = strlen
;;; } 24 DeclItem
;;; } 23 List<DeclItem>
;;; } 22 TypeName
;;; { 22 ParameterDeclaration
;;; isEllipsis = false
;;; { 23 TypeName
;;; { 24 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 24 TypeSpecifier (all)
;;; { 24 List<DeclItem>
;;; { 25 DeclItem
;;; what = DECL_POINTER
;;; { 26 List<Ptr>
;;; { 27 Ptr
;;; } 27 Ptr
;;; } 26 List<Ptr>
;;; } 25 DeclItem
;;; { 25 DeclItem
;;; what = DECL_NAME
;;; name = buffer
;;; } 25 DeclItem
;;; } 24 List<DeclItem>
;;; } 23 TypeName
;;; } 22 ParameterDeclaration
;;; { 22 Expression (variable name)
;;; expr_type = "identifier" (buffer)
;-- load_rr_var buffer = 2(FP), SP at -8 (16 bit)
MOVE 10(SP), RR
;;; } 22 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cstrlen
;-- pop 2 bytes
ADD SP, #2
;;; } 21 Expr l(r)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 20 Initializer (skalar)
;;; } 19 InitDeclarator
;;; { 19 InitDeclarator
;;; { 20 List<DeclItem>
;;; { 21 DeclItem
;;; what = DECL_NAME
;;; name = len
;;; } 21 DeclItem
;;; } 20 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 19 InitDeclarator
;;; { 19 InitDeclarator
;;; { 20 List<DeclItem>
;;; { 21 DeclItem
;;; what = DECL_NAME
;;; name = i
;;; } 21 DeclItem
;;; } 20 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 19 InitDeclarator
;;; { 19 List<IfElseStatement>
;;; { 20 IfElseStatement
;;; { 21 Expr l > r
;;; { 22 TypeName (internal)
;;; { 23 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 23 TypeSpecifier (all)
;;; } 22 TypeName (internal)
;;; { 22 Expression (variable name)
;;; expr_type = "identifier" (min_w)
;-- load_rr_var min_w = 11(FP), SP at -14 (16 bit)
MOVE 25(SP), RR
;;; } 22 Expression (variable name)
;-- move_rr_to_ll
MOVE RR, LL
;;; { 22 Expression (variable name)
;;; expr_type = "identifier" (buflen)
;-- load_rr_var buflen = -10(FP), SP at -14 (16 bit)
MOVE 4(SP), RR
;;; } 22 Expression (variable name)
;-- l > r
SGT LL, RR
;;; } 21 Expr l > r
;-- branch_false
JMP RRZ, L19_endif_44
;;; { 21 ExpressionStatement
;;; { 22 Expr l = r
;;; { 23 TypeName
;;; { 24 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 24 TypeSpecifier (all)
;;; { 24 List<DeclItem>
;;; { 25 DeclItem
;;; what = DECL_NAME
;;; name = padlen
;;; } 25 DeclItem
;;; } 24 List<DeclItem>
;;; } 23 TypeName
;;; { 23 Expr l - r
;;; { 24 Expression (variable name)
;;; expr_type = "identifier" (min_w)
;-- load_rr_var min_w = 11(FP), SP at -14 (16 bit)
MOVE 25(SP), RR
;;; } 24 Expression (variable name)
;-- move_rr_to_ll
MOVE RR, LL
;;; { 24 Expression (variable name)
;;; expr_type = "identifier" (buflen)
;-- load_rr_var buflen = -10(FP), SP at -14 (16 bit)
MOVE 4(SP), RR
;;; } 24 Expression (variable name)
;-- scale_rr *1
;-- l - r
SUB LL, RR
;-- scale *1
;;; } 23 Expr l - r
;-- store_rr_var padlen = -8(FP), SP at -14
MOVE RR, 6(SP)
;;; } 22 Expr l = r
;;; } 21 ExpressionStatement
L19_endif_44:
;;; } 20 IfElseStatement
;;; { 20 IfElseStatement
;;; { 21 Expression (variable name)
;;; expr_type = "identifier" (sign)
;-- load_rr_var sign = 5(FP), SP at -14 (8 bit)
MOVE 19(SP), RS
;;; } 21 Expression (variable name)
;-- branch_false
JMP RRZ, L19_endif_45
;;; { 21 ExpressionStatement
;;; { 22 Expr l = r
;;; { 23 TypeName
;;; { 24 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 24 TypeSpecifier (all)
;;; { 24 List<DeclItem>
;;; { 25 DeclItem
;;; what = DECL_NAME
;;; name = signlen
;;; } 25 DeclItem
;;; } 24 List<DeclItem>
;;; } 23 TypeName
;;; { 23 NumericExpression (constant 1 = 0x1)
;-- load_rr_constant
MOVE #0x0001, RR
;;; } 23 NumericExpression (constant 1 = 0x1)
;-- store_rr_var signlen = -4(FP), SP at -14
MOVE RR, 10(SP)
;;; } 22 Expr l = r
;;; } 21 ExpressionStatement
L19_endif_45:
;;; } 20 IfElseStatement
;;; { 20 IfElseStatement
;;; { 21 Expr l && r
;;; { 22 TypeName (internal)
;;; { 23 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 23 TypeSpecifier (all)
;;; } 22 TypeName (internal)
;;; { 22 IfElseStatement
;;; { 23 Expression (variable name)
;;; expr_type = "identifier" (alt)
;-- load_rr_var alt = 7(FP), SP at -14 (16 bit)
MOVE 21(SP), RR
;;; } 23 Expression (variable name)
;-- branch_false
JMP RRZ, L19_endif_47
;;; { 23 ExpressionStatement
;;; { 24 Expr l & r
;;; { 25 TypeName (internal)
;;; { 26 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 26 TypeSpecifier (all)
;;; } 25 TypeName (internal)
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (flags)
;-- load_rr_var flags = 4(FP), SP at -14 (8 bit)
MOVE 18(SP), RS
;;; } 25 Expression (variable name)
;-- l & r
AND RR, #0x0001
;;; } 24 Expr l & r
;;; } 23 ExpressionStatement
L19_endif_47:
;;; } 22 IfElseStatement
;;; } 21 Expr l && r
;-- branch_false
JMP RRZ, L19_endif_46
;;; { 21 ExpressionStatement
;;; { 22 Expr l = r
;;; { 23 TypeName
;;; { 24 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 24 TypeSpecifier (all)
;;; { 24 List<DeclItem>
;;; { 25 DeclItem
;;; what = DECL_NAME
;;; name = altlen
;;; } 25 DeclItem
;;; } 24 List<DeclItem>
;;; } 23 TypeName
;;; { 23 Expr l(r)
;;; { 24 TypeName
;;; { 25 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 25 TypeSpecifier (all)
;;; { 25 List<DeclItem>
;;; { 26 DeclItem
;;; what = DECL_NAME
;;; name = strlen
;;; } 26 DeclItem
;;; } 25 List<DeclItem>
;;; } 24 TypeName
;;; { 24 ParameterDeclaration
;;; isEllipsis = false
;;; { 25 TypeName
;;; { 26 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 26 TypeSpecifier (all)
;;; { 26 List<DeclItem>
;;; { 27 DeclItem
;;; what = DECL_POINTER
;;; { 28 List<Ptr>
;;; { 29 Ptr
;;; } 29 Ptr
;;; } 28 List<Ptr>
;;; } 27 DeclItem
;;; { 27 DeclItem
;;; what = DECL_NAME
;;; name = buffer
;;; } 27 DeclItem
;;; } 26 List<DeclItem>
;;; } 25 TypeName
;;; } 24 ParameterDeclaration
;;; { 24 Expression (variable name)
;;; expr_type = "identifier" (alt)
;-- load_rr_var alt = 7(FP), SP at -14 (16 bit)
MOVE 21(SP), RR
;;; } 24 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cstrlen
;-- pop 2 bytes
ADD SP, #2
;;; } 23 Expr l(r)
;-- store_rr_var altlen = -6(FP), SP at -14
MOVE RR, 8(SP)
;;; } 22 Expr l = r
;;; } 21 ExpressionStatement
L19_endif_46:
;;; } 20 IfElseStatement
;;; { 20 ExpressionStatement
;;; { 21 Expr l = r
;;; { 22 TypeName
;;; { 23 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 23 TypeSpecifier (all)
;;; { 23 List<DeclItem>
;;; { 24 DeclItem
;;; what = DECL_NAME
;;; name = len
;;; } 24 DeclItem
;;; } 23 List<DeclItem>
;;; } 22 TypeName
;;; { 22 Expr l + r
;;; { 23 Expr l + r
;;; { 24 Expr l + r
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (signlen)
;-- load_rr_var signlen = -4(FP), SP at -14 (16 bit)
MOVE 10(SP), RR
;;; } 25 Expression (variable name)
;-- move_rr_to_ll
MOVE RR, LL
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (altlen)
;-- load_rr_var altlen = -6(FP), SP at -14 (16 bit)
MOVE 8(SP), RR
;;; } 25 Expression (variable name)
;-- scale_rr *1
;-- l + r
ADD LL, RR
;;; } 24 Expr l + r
;-- move_rr_to_ll
MOVE RR, LL
;;; { 24 Expression (variable name)
;;; expr_type = "identifier" (padlen)
;-- load_rr_var padlen = -8(FP), SP at -14 (16 bit)
MOVE 6(SP), RR
;;; } 24 Expression (variable name)
;-- scale_rr *1
;-- l + r
ADD LL, RR
;;; } 23 Expr l + r
;-- move_rr_to_ll
MOVE RR, LL
;;; { 23 Expression (variable name)
;;; expr_type = "identifier" (buflen)
;-- load_rr_var buflen = -10(FP), SP at -14 (16 bit)
MOVE 4(SP), RR
;;; } 23 Expression (variable name)
;-- scale_rr *1
;-- l + r
ADD LL, RR
;;; } 22 Expr l + r
;-- store_rr_var len = -12(FP), SP at -14
MOVE RR, 2(SP)
;;; } 21 Expr l = r
;;; } 20 ExpressionStatement
;;; { 20 IfElseStatement
;;; { 21 Expr l & r
;;; { 22 TypeName (internal)
;;; { 23 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 23 TypeSpecifier (all)
;;; } 22 TypeName (internal)
;;; { 22 Expr ~ r
;;; { 23 Expression (variable name)
;;; expr_type = "identifier" (flags)
;-- load_rr_var flags = 4(FP), SP at -14 (8 bit)
MOVE 18(SP), RS
;;; } 23 Expression (variable name)
;-- 16 bit ~ r
NOT RR
;;; } 22 Expr ~ r
;-- l & r
AND RR, #0x0002
;;; } 21 Expr l & r
;-- branch_false
JMP RRZ, L19_endif_48
;;; { 21 ExpressionStatement
;;; { 22 Expr l(r)
;;; { 23 TypeName
;;; { 24 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 24 TypeSpecifier (all)
;;; { 24 List<DeclItem>
;;; { 25 DeclItem
;;; what = DECL_NAME
;;; name = print_n
;;; } 25 DeclItem
;;; } 24 List<DeclItem>
;;; } 23 TypeName
;;; { 23 Expr (l , r)
;;; { 24 ParameterDeclaration
;;; isEllipsis = false
;;; { 25 TypeName
;;; { 26 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 26 TypeSpecifier (all)
;;; { 26 List<DeclItem>
;;; { 27 DeclItem
;;; what = DECL_NAME
;;; name = count
;;; } 27 DeclItem
;;; } 26 List<DeclItem>
;;; } 25 TypeName
;;; } 24 ParameterDeclaration
;;; { 24 Expr l - r
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (field_w)
;-- load_rr_var field_w = 9(FP), SP at -14 (16 bit)
MOVE 23(SP), RR
;;; } 25 Expression (variable name)
;-- move_rr_to_ll
MOVE RR, LL
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (len)
;-- load_rr_var len = -12(FP), SP at -14 (16 bit)
MOVE 2(SP), RR
;;; } 25 Expression (variable name)
;-- scale_rr *1
;-- l - r
SUB LL, RR
;-- scale *1
;;; } 24 Expr l - r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 24 ParameterDeclaration
;;; isEllipsis = false
;;; { 25 TypeName
;;; { 26 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 26 TypeSpecifier (all)
;;; { 26 List<DeclItem>
;;; { 27 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 27 DeclItem
;;; } 26 List<DeclItem>
;;; } 25 TypeName
;;; } 24 ParameterDeclaration
;;; { 24 Expression (variable name)
;;; expr_type = "identifier" (pad)
;-- load_rr_var pad = 6(FP), SP at -16 (8 bit)
MOVE 22(SP), RS
;;; } 24 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; } 23 Expr (l , r)
;-- push 0 bytes
;-- call
CALL Cprint_n
;-- pop 3 bytes
ADD SP, #3
;;; } 22 Expr l(r)
;;; } 21 ExpressionStatement
L19_endif_48:
;;; } 20 IfElseStatement
;;; { 20 IfElseStatement
;;; { 21 Expression (variable name)
;;; expr_type = "identifier" (sign)
;-- load_rr_var sign = 5(FP), SP at -14 (8 bit)
MOVE 19(SP), RS
;;; } 21 Expression (variable name)
;-- branch_false
JMP RRZ, L19_endif_49
;;; { 21 ExpressionStatement
;;; { 22 Expr l(r)
;;; { 23 TypeName
;;; { 24 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 24 TypeSpecifier (all)
;;; { 24 List<DeclItem>
;;; { 25 DeclItem
;;; what = DECL_NAME
;;; name = putchr
;;; } 25 DeclItem
;;; } 24 List<DeclItem>
;;; } 23 TypeName
;;; { 23 ParameterDeclaration
;;; isEllipsis = false
;;; { 24 TypeName
;;; { 25 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 25 TypeSpecifier (all)
;;; { 25 List<DeclItem>
;;; { 26 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 26 DeclItem
;;; } 25 List<DeclItem>
;;; } 24 TypeName
;;; } 23 ParameterDeclaration
;;; { 23 Expression (variable name)
;;; expr_type = "identifier" (sign)
;-- load_rr_var sign = 5(FP), SP at -14 (8 bit)
MOVE 19(SP), RS
;;; } 23 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;-- push 2 bytes
;-- call
CALL Cputchr
;-- pop 1 bytes
ADD SP, #1
;;; } 22 Expr l(r)
;;; } 21 ExpressionStatement
L19_endif_49:
;;; } 20 IfElseStatement
;;; { 20 IfElseStatement
;;; { 21 Expression (variable name)
;;; expr_type = "identifier" (alt)
;-- load_rr_var alt = 7(FP), SP at -14 (16 bit)
MOVE 21(SP), RR
;;; } 21 Expression (variable name)
;-- branch_false
JMP RRZ, L19_endif_50
;;; { 21 CompoundStatement
;;; { 22 List<IfElseStatement>
;;; { 23 IfElseStatement
;;; { 24 Expr l & r
;;; { 25 TypeName (internal)
;;; { 26 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 26 TypeSpecifier (all)
;;; } 25 TypeName (internal)
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (flags)
;-- load_rr_var flags = 4(FP), SP at -14 (8 bit)
MOVE 18(SP), RS
;;; } 25 Expression (variable name)
;-- l & r
AND RR, #0x0001
;;; } 24 Expr l & r
;-- branch_false
JMP RRZ, L19_endif_51
;;; { 24 ExpressionStatement
;;; { 25 Expr l(r)
;;; { 26 TypeName
;;; { 27 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 27 TypeSpecifier (all)
;;; { 27 List<DeclItem>
;;; { 28 DeclItem
;;; what = DECL_NAME
;;; name = print_string
;;; } 28 DeclItem
;;; } 27 List<DeclItem>
;;; } 26 TypeName
;;; { 26 ParameterDeclaration
;;; isEllipsis = false
;;; { 27 TypeName
;;; { 28 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 28 TypeSpecifier (all)
;;; { 28 List<DeclItem>
;;; { 29 DeclItem
;;; what = DECL_POINTER
;;; { 30 List<Ptr>
;;; { 31 Ptr
;;; } 31 Ptr
;;; } 30 List<Ptr>
;;; } 29 DeclItem
;;; { 29 DeclItem
;;; what = DECL_NAME
;;; name = buffer
;;; } 29 DeclItem
;;; } 28 List<DeclItem>
;;; } 27 TypeName
;;; } 26 ParameterDeclaration
;;; { 26 Expression (variable name)
;;; expr_type = "identifier" (alt)
;-- load_rr_var alt = 7(FP), SP at -14 (16 bit)
MOVE 21(SP), RR
;;; } 26 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL Cprint_string
;-- pop 2 bytes
ADD SP, #2
;;; } 25 Expr l(r)
;;; } 24 ExpressionStatement
L19_endif_51:
;;; } 23 IfElseStatement
;;; } 22 List<IfElseStatement>
;-- pop 0 bytes
;;; } 21 CompoundStatement
L19_endif_50:
;;; } 20 IfElseStatement
;;; { 20 for Statement
;;; { 21 ExpressionStatement
;;; { 22 Expr l = r
;;; { 23 TypeName
;;; { 24 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 24 TypeSpecifier (all)
;;; { 24 List<DeclItem>
;;; { 25 DeclItem
;;; what = DECL_NAME
;;; name = i
;;; } 25 DeclItem
;;; } 24 List<DeclItem>
;;; } 23 TypeName
;;; { 23 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 23 NumericExpression (constant 0 = 0x0)
;-- store_rr_var i = -14(FP), SP at -14
MOVE RR, 0(SP)
;;; } 22 Expr l = r
;;; } 21 ExpressionStatement
;-- branch
JMP L19_tst_52
L19_loop_52:
;;; { 21 ExpressionStatement
;;; { 22 Expr l(r)
;;; { 23 TypeName
;;; { 24 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 24 TypeSpecifier (all)
;;; { 24 List<DeclItem>
;;; { 25 DeclItem
;;; what = DECL_NAME
;;; name = putchr
;;; } 25 DeclItem
;;; } 24 List<DeclItem>
;;; } 23 TypeName
;;; { 23 ParameterDeclaration
;;; isEllipsis = false
;;; { 24 TypeName
;;; { 25 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 25 TypeSpecifier (all)
;;; { 25 List<DeclItem>
;;; { 26 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 26 DeclItem
;;; } 25 List<DeclItem>
;;; } 24 TypeName
;;; } 23 ParameterDeclaration
;;; { 23 Expression (variable name)
;;; expr_type = "identifier" (min_p)
;-- load_rr_var min_p = 13(FP), SP at -14 (8 bit)
MOVE 27(SP), RS
;;; } 23 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;-- push 2 bytes
;-- call
CALL Cputchr
;-- pop 1 bytes
ADD SP, #1
;;; } 22 Expr l(r)
;;; } 21 ExpressionStatement
L19_cont_52:
;;; { 21 Expr l - r
;;; { 22 Expr ++r
;;; { 23 Expression (variable name)
;;; expr_type = "identifier" (i)
;-- load_rr_var i = -14(FP), SP at -14 (16 bit)
MOVE 0(SP), RR
;;; } 23 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var i = -14(FP), SP at -14
MOVE RR, 0(SP)
;;; } 22 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 21 Expr l - r
L19_tst_52:
;;; { 21 Expr l < r
;;; { 22 TypeName (internal)
;;; { 23 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 23 TypeSpecifier (all)
;;; } 22 TypeName (internal)
;;; { 22 Expression (variable name)
;;; expr_type = "identifier" (i)
;-- load_rr_var i = -14(FP), SP at -14 (16 bit)
MOVE 0(SP), RR
;;; } 22 Expression (variable name)
;-- move_rr_to_ll
MOVE RR, LL
;;; { 22 Expression (variable name)
;;; expr_type = "identifier" (padlen)
;-- load_rr_var padlen = -8(FP), SP at -14 (16 bit)
MOVE 6(SP), RR
;;; } 22 Expression (variable name)
;-- l < r
SLT LL, RR
;;; } 21 Expr l < r
;-- branch_true
JMP RRNZ, L19_loop_52
L19_brk_53:
;;; } 20 for Statement
;;; { 20 ExpressionStatement
;;; { 21 Expr l(r)
;;; { 22 TypeName
;;; { 23 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 23 TypeSpecifier (all)
;;; { 23 List<DeclItem>
;;; { 24 DeclItem
;;; what = DECL_NAME
;;; name = print_string
;;; } 24 DeclItem
;;; } 23 List<DeclItem>
;;; } 22 TypeName
;;; { 22 ParameterDeclaration
;;; isEllipsis = false
;;; { 23 TypeName
;;; { 24 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 24 TypeSpecifier (all)
;;; { 24 List<DeclItem>
;;; { 25 DeclItem
;;; what = DECL_POINTER
;;; { 26 List<Ptr>
;;; { 27 Ptr
;;; } 27 Ptr
;;; } 26 List<Ptr>
;;; } 25 DeclItem
;;; { 25 DeclItem
;;; what = DECL_NAME
;;; name = buffer
;;; } 25 DeclItem
;;; } 24 List<DeclItem>
;;; } 23 TypeName
;;; } 22 ParameterDeclaration
;;; { 22 Expression (variable name)
;;; expr_type = "identifier" (buffer)
;-- load_rr_var buffer = 2(FP), SP at -14 (16 bit)
MOVE 16(SP), RR
;;; } 22 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL Cprint_string
;-- pop 2 bytes
ADD SP, #2
;;; } 21 Expr l(r)
;;; } 20 ExpressionStatement
;;; { 20 IfElseStatement
;;; { 21 Expr l & r
;;; { 22 TypeName (internal)
;;; { 23 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 23 TypeSpecifier (all)
;;; } 22 TypeName (internal)
;;; { 22 Expression (variable name)
;;; expr_type = "identifier" (flags)
;-- load_rr_var flags = 4(FP), SP at -14 (8 bit)
MOVE 18(SP), RS
;;; } 22 Expression (variable name)
;-- l & r
AND RR, #0x0002
;;; } 21 Expr l & r
;-- branch_false
JMP RRZ, L19_endif_54
;;; { 21 ExpressionStatement
;;; { 22 Expr l(r)
;;; { 23 TypeName
;;; { 24 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 24 TypeSpecifier (all)
;;; { 24 List<DeclItem>
;;; { 25 DeclItem
;;; what = DECL_NAME
;;; name = print_n
;;; } 25 DeclItem
;;; } 24 List<DeclItem>
;;; } 23 TypeName
;;; { 23 Expr (l , r)
;;; { 24 ParameterDeclaration
;;; isEllipsis = false
;;; { 25 TypeName
;;; { 26 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 26 TypeSpecifier (all)
;;; { 26 List<DeclItem>
;;; { 27 DeclItem
;;; what = DECL_NAME
;;; name = count
;;; } 27 DeclItem
;;; } 26 List<DeclItem>
;;; } 25 TypeName
;;; } 24 ParameterDeclaration
;;; { 24 Expr l - r
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (field_w)
;-- load_rr_var field_w = 9(FP), SP at -14 (16 bit)
MOVE 23(SP), RR
;;; } 25 Expression (variable name)
;-- move_rr_to_ll
MOVE RR, LL
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (len)
;-- load_rr_var len = -12(FP), SP at -14 (16 bit)
MOVE 2(SP), RR
;;; } 25 Expression (variable name)
;-- scale_rr *1
;-- l - r
SUB LL, RR
;-- scale *1
;;; } 24 Expr l - r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 24 ParameterDeclaration
;;; isEllipsis = false
;;; { 25 TypeName
;;; { 26 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 26 TypeSpecifier (all)
;;; { 26 List<DeclItem>
;;; { 27 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 27 DeclItem
;;; } 26 List<DeclItem>
;;; } 25 TypeName
;;; } 24 ParameterDeclaration
;;; { 24 Expression (variable name)
;;; expr_type = "identifier" (pad)
;-- load_rr_var pad = 6(FP), SP at -16 (8 bit)
MOVE 22(SP), RS
;;; } 24 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; } 23 Expr (l , r)
;-- push 0 bytes
;-- call
CALL Cprint_n
;-- pop 3 bytes
ADD SP, #3
;;; } 22 Expr l(r)
;;; } 21 ExpressionStatement
L19_endif_54:
;;; } 20 IfElseStatement
;;; { 20 return Statement
;;; { 21 Expression (variable name)
;;; expr_type = "identifier" (len)
;-- load_rr_var len = -12(FP), SP at -14 (16 bit)
MOVE 2(SP), RR
;;; } 21 Expression (variable name)
;-- ret
ADD SP, #14
RET
;;; } 20 return Statement
;;; } 19 List<IfElseStatement>
;-- pop 14 bytes
ADD SP, #14
;;; } 18 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 18 FunctionDefinition
;;; { 19 TypeName
;;; { 20 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 20 TypeSpecifier (all)
;;; { 20 List<DeclItem>
;;; { 21 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 21 DeclItem
;;; } 20 List<DeclItem>
;;; } 19 TypeName
;;; { 19 List<DeclItem>
;;; { 20 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 20 DeclItem
;;; { 20 DeclItem
;;; what = DECL_FUN
;;; { 21 List
;;; { 22 ParameterDeclaration
;;; isEllipsis = true
;;; { 23 TypeName
;;; { 24 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 24 TypeSpecifier (all)
;;; { 24 List<DeclItem>
;;; { 25 DeclItem
;;; what = DECL_POINTER
;;; { 26 List<Ptr>
;;; { 27 Ptr
;;; } 27 Ptr
;;; } 26 List<Ptr>
;;; } 25 DeclItem
;;; { 25 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 25 DeclItem
;;; } 24 List<DeclItem>
;;; } 23 TypeName
;;; } 22 ParameterDeclaration
;;; } 21 List
;;; } 20 DeclItem
;;; } 19 List<DeclItem>
Cprintf:
;;; { 19 CompoundStatement
;;; { 20 InitDeclarator
;;; { 21 List<DeclItem>
;;; { 22 DeclItem
;;; what = DECL_POINTER
;;; { 23 List<Ptr>
;;; { 24 Ptr
;;; } 24 Ptr
;;; { 24 Ptr
;;; } 24 Ptr
;;; } 23 List<Ptr>
;;; } 22 DeclItem
;;; { 22 DeclItem
;;; what = DECL_NAME
;;; name = args
;;; } 22 DeclItem
;;; } 21 List<DeclItem>
;;; { 21 Initializer (skalar)
;;; { 22 Expr l + r
;;; { 23 Expr & r
;-- load_address format = 2(FP), SP at 0
LEA 2(SP), RR
;;; } 23 Expr & r
;-- l + r
ADD RR, #0x0002
;;; } 22 Expr l + r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 21 Initializer (skalar)
;;; } 20 InitDeclarator
;;; { 20 InitDeclarator
;;; { 21 List<DeclItem>
;;; { 22 DeclItem
;;; what = DECL_NAME
;;; name = len
;;; } 22 DeclItem
;;; } 21 List<DeclItem>
;;; { 21 Initializer (skalar)
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 21 Initializer (skalar)
;;; } 20 InitDeclarator
;;; { 20 InitDeclarator
;;; { 21 List<DeclItem>
;;; { 22 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 22 DeclItem
;;; } 21 List<DeclItem>
;-- push_zero 1 bytes
CLRB -(SP)
;;; } 20 InitDeclarator
;;; { 20 InitDeclarator
;;; { 21 List<DeclItem>
;;; { 22 DeclItem
;;; what = DECL_NAME
;;; name = flags
;;; } 22 DeclItem
;;; } 21 List<DeclItem>
;-- push_zero 1 bytes
CLRB -(SP)
;;; } 20 InitDeclarator
;;; { 20 InitDeclarator
;;; { 21 List<DeclItem>
;;; { 22 DeclItem
;;; what = DECL_NAME
;;; name = sign
;;; } 22 DeclItem
;;; } 21 List<DeclItem>
;-- push_zero 1 bytes
CLRB -(SP)
;;; } 20 InitDeclarator
;;; { 20 InitDeclarator
;;; { 21 List<DeclItem>
;;; { 22 DeclItem
;;; what = DECL_NAME
;;; name = pad
;;; } 22 DeclItem
;;; } 21 List<DeclItem>
;-- push_zero 1 bytes
CLRB -(SP)
;;; } 20 InitDeclarator
;;; { 20 InitDeclarator
;;; { 21 List<DeclItem>
;;; { 22 DeclItem
;;; what = DECL_POINTER
;;; { 23 List<Ptr>
;;; { 24 Ptr
;;; } 24 Ptr
;;; } 23 List<Ptr>
;;; } 22 DeclItem
;;; { 22 DeclItem
;;; what = DECL_NAME
;;; name = alt
;;; } 22 DeclItem
;;; } 21 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 20 InitDeclarator
;;; { 20 InitDeclarator
;;; { 21 List<DeclItem>
;;; { 22 DeclItem
;;; what = DECL_NAME
;;; name = field_w
;;; } 22 DeclItem
;;; } 21 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 20 InitDeclarator
;;; { 20 InitDeclarator
;;; { 21 List<DeclItem>
;;; { 22 DeclItem
;;; what = DECL_NAME
;;; name = min_w
;;; } 22 DeclItem
;;; } 21 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 20 InitDeclarator
;;; { 20 InitDeclarator
;;; { 21 List<DeclItem>
;;; { 22 DeclItem
;;; what = DECL_POINTER
;;; { 23 List<Ptr>
;;; { 24 Ptr
;;; } 24 Ptr
;;; } 23 List<Ptr>
;;; } 22 DeclItem
;;; { 22 DeclItem
;;; what = DECL_NAME
;;; name = which_w
;;; } 22 DeclItem
;;; } 21 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 20 InitDeclarator
;;; { 20 InitDeclarator
;;; { 21 List<DeclItem>
;;; { 22 DeclItem
;;; what = DECL_NAME
;;; name = buffer
;;; } 22 DeclItem
;;; { 22 DeclItem
;;; what = DECL_ARRAY
;;; } 22 DeclItem
;;; } 21 List<DeclItem>
;-- push_zero 12 bytes
CLRW -(SP)
CLRW -(SP)
CLRW -(SP)
CLRW -(SP)
CLRW -(SP)
CLRW -(SP)
;;; } 20 InitDeclarator
;;; { 20 List<while Statement>
;;; { 21 while Statement
;-- branch
JMP L20_cont_55
L20_loop_55:
;;; { 22 CompoundStatement
;;; { 23 List<IfElseStatement>
;;; { 24 IfElseStatement
;;; { 25 Expr l != r
;;; { 26 TypeName (internal)
;;; { 27 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 27 TypeSpecifier (all)
;;; } 26 TypeName (internal)
;;; { 26 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -5(FP), SP at -28 (8 bit)
MOVE 23(SP), RS
;;; } 26 Expression (variable name)
;-- l != r
SNE RR, #0x0025
;;; } 25 Expr l != r
;-- branch_false
JMP RRZ, L20_endif_57
;;; { 25 CompoundStatement
;;; { 26 List<ExpressionStatement>
;;; { 27 ExpressionStatement
;;; { 28 Expr l += r
;;; { 29 TypeName
;;; { 30 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 30 TypeSpecifier (all)
;;; { 30 List<DeclItem>
;;; { 31 DeclItem
;;; what = DECL_NAME
;;; name = len
;;; } 31 DeclItem
;;; } 30 List<DeclItem>
;;; } 29 TypeName
;;; { 29 Expr l + r
;;; { 30 Expr l(r)
;;; { 31 TypeName
;;; { 32 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 32 TypeSpecifier (all)
;;; { 32 List<DeclItem>
;;; { 33 DeclItem
;;; what = DECL_NAME
;;; name = putchr
;;; } 33 DeclItem
;;; } 32 List<DeclItem>
;;; } 31 TypeName
;;; { 31 ParameterDeclaration
;;; isEllipsis = false
;;; { 32 TypeName
;;; { 33 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 33 TypeSpecifier (all)
;;; { 33 List<DeclItem>
;;; { 34 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 34 DeclItem
;;; } 33 List<DeclItem>
;;; } 32 TypeName
;;; } 31 ParameterDeclaration
;;; { 31 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -5(FP), SP at -28 (8 bit)
MOVE 23(SP), RS
;;; } 31 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;-- push 2 bytes
;-- call
CALL Cputchr
;-- pop 1 bytes
ADD SP, #1
;;; } 30 Expr l(r)
;;; { 30 Expression (variable name)
;;; expr_type = "identifier" (len)
;-- load_ll_var len = -4(FP), SP at -28 (16 bit)
MOVE 24(SP), LL
;;; } 30 Expression (variable name)
;-- scale_rr *1
;-- l + r
ADD LL, RR
;;; } 29 Expr l + r
;-- store_rr_var len = -4(FP), SP at -28
MOVE RR, 24(SP)
;;; } 28 Expr l += r
;;; } 27 ExpressionStatement
;;; { 27 break/continue Statement
;-- branch
JMP L20_cont_55
;;; } 27 break/continue Statement
;;; } 26 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 25 CompoundStatement
L20_endif_57:
;;; } 24 IfElseStatement
;;; { 24 ExpressionStatement
;;; { 25 Expr l = r
;;; { 26 TypeName
;;; { 27 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 27 TypeSpecifier (all)
;;; { 27 List<DeclItem>
;;; { 28 DeclItem
;;; what = DECL_NAME
;;; name = flags
;;; } 28 DeclItem
;;; } 27 List<DeclItem>
;;; } 26 TypeName
;;; { 26 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 26 NumericExpression (constant 0 = 0x0)
;-- store_rr_var flags = -6(FP), SP at -28
MOVE R, 22(SP)
;;; } 25 Expr l = r
;;; } 24 ExpressionStatement
;;; { 24 ExpressionStatement
;;; { 25 Expr l = r
;;; { 26 TypeName
;;; { 27 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 27 TypeSpecifier (all)
;;; { 27 List<DeclItem>
;;; { 28 DeclItem
;;; what = DECL_NAME
;;; name = sign
;;; } 28 DeclItem
;;; } 27 List<DeclItem>
;;; } 26 TypeName
;;; { 26 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 26 NumericExpression (constant 0 = 0x0)
;-- store_rr_var sign = -7(FP), SP at -28
MOVE R, 21(SP)
;;; } 25 Expr l = r
;;; } 24 ExpressionStatement
;;; { 24 ExpressionStatement
;;; { 25 Expr l = r
;;; { 26 TypeName
;;; { 27 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 27 TypeSpecifier (all)
;;; { 27 List<DeclItem>
;;; { 28 DeclItem
;;; what = DECL_NAME
;;; name = pad
;;; } 28 DeclItem
;;; } 27 List<DeclItem>
;;; } 26 TypeName
;;; { 26 NumericExpression (constant 32 = 0x20)
;-- load_rr_constant
MOVE #0x0020, RR
;;; } 26 NumericExpression (constant 32 = 0x20)
;-- store_rr_var pad = -8(FP), SP at -28
MOVE R, 20(SP)
;;; } 25 Expr l = r
;;; } 24 ExpressionStatement
;;; { 24 ExpressionStatement
;;; { 25 Expr l = r
;;; { 26 TypeName
;;; { 27 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 27 TypeSpecifier (all)
;;; { 27 List<DeclItem>
;;; { 28 DeclItem
;;; what = DECL_NAME
;;; name = field_w
;;; } 28 DeclItem
;;; } 27 List<DeclItem>
;;; } 26 TypeName
;;; { 26 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 26 NumericExpression (constant 0 = 0x0)
;-- store_rr_var field_w = -12(FP), SP at -28
MOVE RR, 16(SP)
;;; } 25 Expr l = r
;;; } 24 ExpressionStatement
;;; { 24 ExpressionStatement
;;; { 25 Expr l = r
;;; { 26 TypeName
;;; { 27 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 27 TypeSpecifier (all)
;;; { 27 List<DeclItem>
;;; { 28 DeclItem
;;; what = DECL_NAME
;;; name = min_w
;;; } 28 DeclItem
;;; } 27 List<DeclItem>
;;; } 26 TypeName
;;; { 26 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 26 NumericExpression (constant 0 = 0x0)
;-- store_rr_var min_w = -14(FP), SP at -28
MOVE RR, 14(SP)
;;; } 25 Expr l = r
;;; } 24 ExpressionStatement
;;; { 24 ExpressionStatement
;;; { 25 Expr l = r
;;; { 26 TypeName
;;; { 27 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 27 TypeSpecifier (all)
;;; { 27 List<DeclItem>
;;; { 28 DeclItem
;;; what = DECL_POINTER
;;; { 29 List<Ptr>
;;; { 30 Ptr
;;; } 30 Ptr
;;; } 29 List<Ptr>
;;; } 28 DeclItem
;;; { 28 DeclItem
;;; what = DECL_NAME
;;; name = which_w
;;; } 28 DeclItem
;;; } 27 List<DeclItem>
;;; } 26 TypeName
;;; { 26 Expr & r
;-- load_address field_w = -12(FP), SP at -28
LEA 16(SP), RR
;;; } 26 Expr & r
;-- store_rr_var which_w = -16(FP), SP at -28
MOVE RR, 12(SP)
;;; } 25 Expr l = r
;;; } 24 ExpressionStatement
;;; { 24 for Statement
;;; { 25 ExpressionStatement
;;; } 25 ExpressionStatement
L20_loop_58:
;;; { 25 CompoundStatement
;;; { 26 List<SwitchStatement>
;;; { 27 SwitchStatement
;;; { 28 Expr l = r
;;; { 29 TypeName
;;; { 30 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 30 TypeSpecifier (all)
;;; { 30 List<DeclItem>
;;; { 31 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 31 DeclItem
;;; } 30 List<DeclItem>
;;; } 29 TypeName
;;; { 29 Expr * r
;;; { 30 Expr l - r
;;; { 31 Expr ++r
;;; { 32 Expression (variable name)
;;; expr_type = "identifier" (format)
;-- load_rr_var format = 2(FP), SP at -28 (16 bit)
MOVE 30(SP), RR
;;; } 32 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var format = 2(FP), SP at -28
MOVE RR, 30(SP)
;;; } 31 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 30 Expr l - r
;-- content
MOVE (RR), RS
;;; } 29 Expr * r
;-- store_rr_var c = -5(FP), SP at -28
MOVE R, 23(SP)
;;; } 28 Expr l = r
;-- move_rr_to_ll
MOVE RR, LL
;-- branch_case (8 bit)
SEQ LL, #0x0058
JMP RRNZ, L20_case_60_0058
;-- branch_case (8 bit)
SEQ LL, #0x0064
JMP RRNZ, L20_case_60_0064
;-- branch_case (8 bit)
SEQ LL, #0x0073
JMP RRNZ, L20_case_60_0073
;-- branch_case (8 bit)
SEQ LL, #0x0075
JMP RRNZ, L20_case_60_0075
;-- branch_case (8 bit)
SEQ LL, #0x0078
JMP RRNZ, L20_case_60_0078
;-- branch_case (8 bit)
SEQ LL, #0x0063
JMP RRNZ, L20_case_60_0063
;-- branch_case (8 bit)
SEQ LL, #0x0023
JMP RRNZ, L20_case_60_0023
;-- branch_case (8 bit)
SEQ LL, #0x002D
JMP RRNZ, L20_case_60_002D
;-- branch_case (8 bit)
SEQ LL, #0x0020
JMP RRNZ, L20_case_60_0020
;-- branch_case (8 bit)
SEQ LL, #0x002B
JMP RRNZ, L20_case_60_002B
;-- branch_case (8 bit)
SEQ LL, #0x002E
JMP RRNZ, L20_case_60_002E
;-- branch_case (8 bit)
SEQ LL, #0x0030
JMP RRNZ, L20_case_60_0030
;-- branch_case (8 bit)
SEQ LL, #0x0031
JMP RRNZ, L20_case_60_0031
;-- branch_case (8 bit)
SEQ LL, #0x0032
JMP RRNZ, L20_case_60_0032
;-- branch_case (8 bit)
SEQ LL, #0x0033
JMP RRNZ, L20_case_60_0033
;-- branch_case (8 bit)
SEQ LL, #0x0034
JMP RRNZ, L20_case_60_0034
;-- branch_case (8 bit)
SEQ LL, #0x0035
JMP RRNZ, L20_case_60_0035
;-- branch_case (8 bit)
SEQ LL, #0x0036
JMP RRNZ, L20_case_60_0036
;-- branch_case (8 bit)
SEQ LL, #0x0037
JMP RRNZ, L20_case_60_0037
;-- branch_case (8 bit)
SEQ LL, #0x0038
JMP RRNZ, L20_case_60_0038
;-- branch_case (8 bit)
SEQ LL, #0x0039
JMP RRNZ, L20_case_60_0039
;-- branch_case (8 bit)
SEQ LL, #0x002A
JMP RRNZ, L20_case_60_002A
;-- branch_case (8 bit)
SEQ LL, #0x0000
JMP RRNZ, L20_case_60_0000
;-- branch
JMP L20_deflt_60
;;; { 28 CompoundStatement
;;; { 29 List<case Statement>
;;; { 30 case Statement
L20_case_60_0058:
;;; { 31 ExpressionStatement
;;; { 32 Expr l(r)
;;; { 33 TypeName
;;; { 34 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 34 TypeSpecifier (all)
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = print_hex
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;;; } 33 TypeName
;;; { 33 Expr (l , r)
;;; { 34 ParameterDeclaration
;;; isEllipsis = false
;;; { 35 TypeName
;;; { 36 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 36 TypeSpecifier (all)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_POINTER
;;; { 38 List<Ptr>
;;; { 39 Ptr
;;; } 39 Ptr
;;; } 38 List<Ptr>
;;; } 37 DeclItem
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = hex
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; } 34 ParameterDeclaration
;;; { 34 StringExpression
;-- load_rr_string
MOVE #Cstr_36, RR
;;; } 34 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 34 Expr (l , r)
;;; { 35 ParameterDeclaration
;;; isEllipsis = false
;;; { 36 TypeName
;;; { 37 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 37 TypeSpecifier (all)
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = value
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;;; } 36 TypeName
;;; } 35 ParameterDeclaration
;;; { 35 Expression (cast)r
;;; { 36 Expr * r
;;; { 37 Expr l - r
;;; { 38 Expr ++r
;;; { 39 Expression (variable name)
;;; expr_type = "identifier" (args)
;-- load_rr_var args = -2(FP), SP at -30 (16 bit)
MOVE 28(SP), RR
;;; } 39 Expression (variable name)
;-- ++
ADD RR, #0x0002
;-- store_rr_var args = -2(FP), SP at -30
MOVE RR, 28(SP)
;;; } 38 Expr ++r
;-- l - r
SUB RR, #0x0002
;;; } 37 Expr l - r
;-- content
MOVE (RR), RR
;;; } 36 Expr * r
;;; } 35 Expression (cast)r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 35 ParameterDeclaration
;;; isEllipsis = false
;;; { 36 TypeName
;;; { 37 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 37 TypeSpecifier (all)
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_POINTER
;;; { 39 List<Ptr>
;;; { 40 Ptr
;;; } 40 Ptr
;;; } 39 List<Ptr>
;;; } 38 DeclItem
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = dest
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;;; } 36 TypeName
;;; } 35 ParameterDeclaration
;-- load_address buffer = -28(FP), SP at -32
LEA 4(SP), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 34 Expr (l , r)
;;; } 33 Expr (l , r)
;-- push 0 bytes
;-- call
CALL Cprint_hex
;-- pop 6 bytes
ADD SP, #6
;;; } 32 Expr l(r)
;;; } 31 ExpressionStatement
;;; } 30 case Statement
;;; { 30 ExpressionStatement
;;; { 31 Expr l += r
;;; { 32 TypeName
;;; { 33 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 33 TypeSpecifier (all)
;;; { 33 List<DeclItem>
;;; { 34 DeclItem
;;; what = DECL_NAME
;;; name = len
;;; } 34 DeclItem
;;; } 33 List<DeclItem>
;;; } 32 TypeName
;;; { 32 Expr l + r
;;; { 33 Expr l(r)
;;; { 34 TypeName
;;; { 35 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 35 TypeSpecifier (all)
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = print_item
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;;; } 34 TypeName
;;; { 34 Expr (l , r)
;;; { 35 ParameterDeclaration
;;; isEllipsis = false
;;; { 36 TypeName
;;; { 37 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 37 TypeSpecifier (all)
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = min_p
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;;; } 36 TypeName
;;; } 35 ParameterDeclaration
;;; { 35 NumericExpression (constant 48 = 0x30)
;-- load_rr_constant
MOVE #0x0030, RR
;;; } 35 NumericExpression (constant 48 = 0x30)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 35 Expr (l , r)
;;; { 36 ParameterDeclaration
;;; isEllipsis = false
;;; { 37 TypeName
;;; { 38 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 38 TypeSpecifier (all)
;;; { 38 List<DeclItem>
;;; { 39 DeclItem
;;; what = DECL_NAME
;;; name = min_w
;;; } 39 DeclItem
;;; } 38 List<DeclItem>
;;; } 37 TypeName
;;; } 36 ParameterDeclaration
;;; { 36 Expression (variable name)
;;; expr_type = "identifier" (min_w)
;-- load_rr_var min_w = -14(FP), SP at -29 (16 bit)
MOVE 15(SP), RR
;;; } 36 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 36 Expr (l , r)
;;; { 37 ParameterDeclaration
;;; isEllipsis = false
;;; { 38 TypeName
;;; { 39 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 39 TypeSpecifier (all)
;;; { 39 List<DeclItem>
;;; { 40 DeclItem
;;; what = DECL_NAME
;;; name = field_w
;;; } 40 DeclItem
;;; } 39 List<DeclItem>
;;; } 38 TypeName
;;; } 37 ParameterDeclaration
;;; { 37 Expression (variable name)
;;; expr_type = "identifier" (field_w)
;-- load_rr_var field_w = -12(FP), SP at -31 (16 bit)
MOVE 19(SP), RR
;;; } 37 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 37 Expr (l , r)
;;; { 38 ParameterDeclaration
;;; isEllipsis = false
;;; { 39 TypeName
;;; { 40 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 40 TypeSpecifier (all)
;;; { 40 List<DeclItem>
;;; { 41 DeclItem
;;; what = DECL_POINTER
;;; { 42 List<Ptr>
;;; { 43 Ptr
;;; } 43 Ptr
;;; } 42 List<Ptr>
;;; } 41 DeclItem
;;; { 41 DeclItem
;;; what = DECL_NAME
;;; name = alt
;;; } 41 DeclItem
;;; } 40 List<DeclItem>
;;; } 39 TypeName
;;; } 38 ParameterDeclaration
;;; { 38 StringExpression
;-- load_rr_string
MOVE #Cstr_37, RR
;;; } 38 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 38 Expr (l , r)
;;; { 39 ParameterDeclaration
;;; isEllipsis = false
;;; { 40 TypeName
;;; { 41 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 41 TypeSpecifier (all)
;;; { 41 List<DeclItem>
;;; { 42 DeclItem
;;; what = DECL_NAME
;;; name = pad
;;; } 42 DeclItem
;;; } 41 List<DeclItem>
;;; } 40 TypeName
;;; } 39 ParameterDeclaration
;;; { 39 Expression (variable name)
;;; expr_type = "identifier" (pad)
;-- load_rr_var pad = -8(FP), SP at -35 (8 bit)
MOVE 27(SP), RS
;;; } 39 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 39 Expr (l , r)
;;; { 40 ParameterDeclaration
;;; isEllipsis = false
;;; { 41 TypeName
;;; { 42 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 42 TypeSpecifier (all)
;;; { 42 List<DeclItem>
;;; { 43 DeclItem
;;; what = DECL_NAME
;;; name = sign
;;; } 43 DeclItem
;;; } 42 List<DeclItem>
;;; } 41 TypeName
;;; } 40 ParameterDeclaration
;;; { 40 Expression (variable name)
;;; expr_type = "identifier" (sign)
;-- load_rr_var sign = -7(FP), SP at -36 (8 bit)
MOVE 29(SP), RS
;;; } 40 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 40 Expr (l , r)
;;; { 41 ParameterDeclaration
;;; isEllipsis = false
;;; { 42 TypeName
;;; { 43 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 43 TypeSpecifier (all)
;;; { 43 List<DeclItem>
;;; { 44 DeclItem
;;; what = DECL_NAME
;;; name = flags
;;; } 44 DeclItem
;;; } 43 List<DeclItem>
;;; } 42 TypeName
;;; } 41 ParameterDeclaration
;;; { 41 Expression (variable name)
;;; expr_type = "identifier" (flags)
;-- load_rr_var flags = -6(FP), SP at -37 (8 bit)
MOVE 31(SP), RS
;;; } 41 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 41 ParameterDeclaration
;;; isEllipsis = false
;;; { 42 TypeName
;;; { 43 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 43 TypeSpecifier (all)
;;; { 43 List<DeclItem>
;;; { 44 DeclItem
;;; what = DECL_POINTER
;;; { 45 List<Ptr>
;;; { 46 Ptr
;;; } 46 Ptr
;;; } 45 List<Ptr>
;;; } 44 DeclItem
;;; { 44 DeclItem
;;; what = DECL_NAME
;;; name = buffer
;;; } 44 DeclItem
;;; } 43 List<DeclItem>
;;; } 42 TypeName
;;; } 41 ParameterDeclaration
;-- load_address buffer = -28(FP), SP at -38
LEA 10(SP), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 40 Expr (l , r)
;;; } 39 Expr (l , r)
;;; } 38 Expr (l , r)
;;; } 37 Expr (l , r)
;;; } 36 Expr (l , r)
;;; } 35 Expr (l , r)
;;; } 34 Expr (l , r)
;-- push 2 bytes
;-- call
CALL Cprint_item
;-- pop 12 bytes
ADD SP, #12
;;; } 33 Expr l(r)
;;; { 33 Expression (variable name)
;;; expr_type = "identifier" (len)
;-- load_ll_var len = -4(FP), SP at -28 (16 bit)
MOVE 24(SP), LL
;;; } 33 Expression (variable name)
;-- scale_rr *1
;-- l + r
ADD LL, RR
;;; } 32 Expr l + r
;-- store_rr_var len = -4(FP), SP at -28
MOVE RR, 24(SP)
;;; } 31 Expr l += r
;;; } 30 ExpressionStatement
;;; { 30 break/continue Statement
;-- branch
JMP L20_brk_60
;;; } 30 break/continue Statement
;;; { 30 case Statement
L20_case_60_0064:
;;; { 31 IfElseStatement
;;; { 32 Expr l < r
;;; { 33 TypeName (internal)
;;; { 34 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 34 TypeSpecifier (all)
;;; } 33 TypeName (internal)
;;; { 33 Expression (cast)r
;;; { 34 Expr * r
;;; { 35 Expression (variable name)
;;; expr_type = "identifier" (args)
;-- load_rr_var args = -2(FP), SP at -28 (16 bit)
MOVE 26(SP), RR
;;; } 35 Expression (variable name)
;-- content
MOVE (RR), RR
;;; } 34 Expr * r
;;; } 33 Expression (cast)r
;-- l < r
SLT RR, #0x0000
;;; } 32 Expr l < r
;-- branch_false
JMP RRZ, L20_endif_61
;;; { 32 CompoundStatement
;;; { 33 List<ExpressionStatement>
;;; { 34 ExpressionStatement
;;; { 35 Expr l = r
;;; { 36 TypeName
;;; { 37 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 37 TypeSpecifier (all)
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = sign
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;;; } 36 TypeName
;;; { 36 NumericExpression (constant 45 = 0x2D)
;-- load_rr_constant
MOVE #0x002D, RR
;;; } 36 NumericExpression (constant 45 = 0x2D)
;-- store_rr_var sign = -7(FP), SP at -28
MOVE R, 21(SP)
;;; } 35 Expr l = r
;;; } 34 ExpressionStatement
;;; { 34 ExpressionStatement
;;; { 35 Expr l = r
;;; { 36 TypeName
;;; { 37 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 37 TypeSpecifier (all)
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_POINTER
;;; { 39 List<Ptr>
;;; { 40 Ptr
;;; } 40 Ptr
;;; } 39 List<Ptr>
;;; } 38 DeclItem
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = args
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;;; } 36 TypeName
;;; { 36 Expression (cast)r
;;; { 37 Expr - r
;;; { 38 Expression (cast)r
;;; { 39 Expr * r
;;; { 40 Expression (variable name)
;;; expr_type = "identifier" (args)
;-- load_rr_var args = -2(FP), SP at -28 (16 bit)
MOVE 26(SP), RR
;;; } 40 Expression (variable name)
;-- content
MOVE (RR), RR
;;; } 39 Expr * r
;;; } 38 Expression (cast)r
;-- 16 bit - r
NEG RR
;;; } 37 Expr - r
;;; } 36 Expression (cast)r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 36 Expr * r
;;; { 37 Expression (variable name)
;;; expr_type = "identifier" (args)
;-- load_rr_var args = -2(FP), SP at -30 (16 bit)
MOVE 28(SP), RR
;;; } 37 Expression (variable name)
;;; } 36 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (16 bit)
MOVE (SP)+, RR
;-- assign (16 bit)
MOVE RR, (LL)
;;; } 35 Expr l = r
;;; } 34 ExpressionStatement
;;; } 33 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 32 CompoundStatement
L20_endif_61:
;;; } 31 IfElseStatement
;;; } 30 case Statement
;;; { 30 ExpressionStatement
;;; { 31 Expr l(r)
;;; { 32 TypeName
;;; { 33 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 33 TypeSpecifier (all)
;;; { 33 List<DeclItem>
;;; { 34 DeclItem
;;; what = DECL_NAME
;;; name = print_unsigned
;;; } 34 DeclItem
;;; } 33 List<DeclItem>
;;; } 32 TypeName
;;; { 32 Expr (l , r)
;;; { 33 ParameterDeclaration
;;; isEllipsis = false
;;; { 34 TypeName
;;; { 35 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 35 TypeSpecifier (all)
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = value
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;;; } 34 TypeName
;;; } 33 ParameterDeclaration
;;; { 33 Expression (cast)r
;;; { 34 Expr * r
;;; { 35 Expr l - r
;;; { 36 Expr ++r
;;; { 37 Expression (variable name)
;;; expr_type = "identifier" (args)
;-- load_rr_var args = -2(FP), SP at -28 (16 bit)
MOVE 26(SP), RR
;;; } 37 Expression (variable name)
;-- ++
ADD RR, #0x0002
;-- store_rr_var args = -2(FP), SP at -28
MOVE RR, 26(SP)
;;; } 36 Expr ++r
;-- l - r
SUB RR, #0x0002
;;; } 35 Expr l - r
;-- content
MOVE (RR), RR
;;; } 34 Expr * r
;;; } 33 Expression (cast)r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 33 ParameterDeclaration
;;; isEllipsis = false
;;; { 34 TypeName
;;; { 35 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 35 TypeSpecifier (all)
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_POINTER
;;; { 37 List<Ptr>
;;; { 38 Ptr
;;; } 38 Ptr
;;; } 37 List<Ptr>
;;; } 36 DeclItem
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = dest
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;;; } 34 TypeName
;;; } 33 ParameterDeclaration
;-- load_address buffer = -28(FP), SP at -30
LEA 2(SP), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 32 Expr (l , r)
;-- push 0 bytes
;-- call
CALL Cprint_unsigned
;-- pop 4 bytes
ADD SP, #4
;;; } 31 Expr l(r)
;;; } 30 ExpressionStatement
;;; { 30 ExpressionStatement
;;; { 31 Expr l += r
;;; { 32 TypeName
;;; { 33 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 33 TypeSpecifier (all)
;;; { 33 List<DeclItem>
;;; { 34 DeclItem
;;; what = DECL_NAME
;;; name = len
;;; } 34 DeclItem
;;; } 33 List<DeclItem>
;;; } 32 TypeName
;;; { 32 Expr l + r
;;; { 33 Expr l(r)
;;; { 34 TypeName
;;; { 35 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 35 TypeSpecifier (all)
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = print_item
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;;; } 34 TypeName
;;; { 34 Expr (l , r)
;;; { 35 ParameterDeclaration
;;; isEllipsis = false
;;; { 36 TypeName
;;; { 37 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 37 TypeSpecifier (all)
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = min_p
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;;; } 36 TypeName
;;; } 35 ParameterDeclaration
;;; { 35 NumericExpression (constant 48 = 0x30)
;-- load_rr_constant
MOVE #0x0030, RR
;;; } 35 NumericExpression (constant 48 = 0x30)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 35 Expr (l , r)
;;; { 36 ParameterDeclaration
;;; isEllipsis = false
;;; { 37 TypeName
;;; { 38 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 38 TypeSpecifier (all)
;;; { 38 List<DeclItem>
;;; { 39 DeclItem
;;; what = DECL_NAME
;;; name = min_w
;;; } 39 DeclItem
;;; } 38 List<DeclItem>
;;; } 37 TypeName
;;; } 36 ParameterDeclaration
;;; { 36 Expression (variable name)
;;; expr_type = "identifier" (min_w)
;-- load_rr_var min_w = -14(FP), SP at -29 (16 bit)
MOVE 15(SP), RR
;;; } 36 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 36 Expr (l , r)
;;; { 37 ParameterDeclaration
;;; isEllipsis = false
;;; { 38 TypeName
;;; { 39 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 39 TypeSpecifier (all)
;;; { 39 List<DeclItem>
;;; { 40 DeclItem
;;; what = DECL_NAME
;;; name = field_w
;;; } 40 DeclItem
;;; } 39 List<DeclItem>
;;; } 38 TypeName
;;; } 37 ParameterDeclaration
;;; { 37 Expression (variable name)
;;; expr_type = "identifier" (field_w)
;-- load_rr_var field_w = -12(FP), SP at -31 (16 bit)
MOVE 19(SP), RR
;;; } 37 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 37 Expr (l , r)
;;; { 38 ParameterDeclaration
;;; isEllipsis = false
;;; { 39 TypeName
;;; { 40 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 40 TypeSpecifier (all)
;;; { 40 List<DeclItem>
;;; { 41 DeclItem
;;; what = DECL_POINTER
;;; { 42 List<Ptr>
;;; { 43 Ptr
;;; } 43 Ptr
;;; } 42 List<Ptr>
;;; } 41 DeclItem
;;; { 41 DeclItem
;;; what = DECL_NAME
;;; name = alt
;;; } 41 DeclItem
;;; } 40 List<DeclItem>
;;; } 39 TypeName
;;; } 38 ParameterDeclaration
;;; { 38 StringExpression
;-- load_rr_string
MOVE #Cstr_38, RR
;;; } 38 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 38 Expr (l , r)
;;; { 39 ParameterDeclaration
;;; isEllipsis = false
;;; { 40 TypeName
;;; { 41 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 41 TypeSpecifier (all)
;;; { 41 List<DeclItem>
;;; { 42 DeclItem
;;; what = DECL_NAME
;;; name = pad
;;; } 42 DeclItem
;;; } 41 List<DeclItem>
;;; } 40 TypeName
;;; } 39 ParameterDeclaration
;;; { 39 Expression (variable name)
;;; expr_type = "identifier" (pad)
;-- load_rr_var pad = -8(FP), SP at -35 (8 bit)
MOVE 27(SP), RS
;;; } 39 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 39 Expr (l , r)
;;; { 40 ParameterDeclaration
;;; isEllipsis = false
;;; { 41 TypeName
;;; { 42 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 42 TypeSpecifier (all)
;;; { 42 List<DeclItem>
;;; { 43 DeclItem
;;; what = DECL_NAME
;;; name = sign
;;; } 43 DeclItem
;;; } 42 List<DeclItem>
;;; } 41 TypeName
;;; } 40 ParameterDeclaration
;;; { 40 Expression (variable name)
;;; expr_type = "identifier" (sign)
;-- load_rr_var sign = -7(FP), SP at -36 (8 bit)
MOVE 29(SP), RS
;;; } 40 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 40 Expr (l , r)
;;; { 41 ParameterDeclaration
;;; isEllipsis = false
;;; { 42 TypeName
;;; { 43 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 43 TypeSpecifier (all)
;;; { 43 List<DeclItem>
;;; { 44 DeclItem
;;; what = DECL_NAME
;;; name = flags
;;; } 44 DeclItem
;;; } 43 List<DeclItem>
;;; } 42 TypeName
;;; } 41 ParameterDeclaration
;;; { 41 Expression (variable name)
;;; expr_type = "identifier" (flags)
;-- load_rr_var flags = -6(FP), SP at -37 (8 bit)
MOVE 31(SP), RS
;;; } 41 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 41 ParameterDeclaration
;;; isEllipsis = false
;;; { 42 TypeName
;;; { 43 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 43 TypeSpecifier (all)
;;; { 43 List<DeclItem>
;;; { 44 DeclItem
;;; what = DECL_POINTER
;;; { 45 List<Ptr>
;;; { 46 Ptr
;;; } 46 Ptr
;;; } 45 List<Ptr>
;;; } 44 DeclItem
;;; { 44 DeclItem
;;; what = DECL_NAME
;;; name = buffer
;;; } 44 DeclItem
;;; } 43 List<DeclItem>
;;; } 42 TypeName
;;; } 41 ParameterDeclaration
;-- load_address buffer = -28(FP), SP at -38
LEA 10(SP), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 40 Expr (l , r)
;;; } 39 Expr (l , r)
;;; } 38 Expr (l , r)
;;; } 37 Expr (l , r)
;;; } 36 Expr (l , r)
;;; } 35 Expr (l , r)
;;; } 34 Expr (l , r)
;-- push 2 bytes
;-- call
CALL Cprint_item
;-- pop 12 bytes
ADD SP, #12
;;; } 33 Expr l(r)
;;; { 33 Expression (variable name)
;;; expr_type = "identifier" (len)
;-- load_ll_var len = -4(FP), SP at -28 (16 bit)
MOVE 24(SP), LL
;;; } 33 Expression (variable name)
;-- scale_rr *1
;-- l + r
ADD LL, RR
;;; } 32 Expr l + r
;-- store_rr_var len = -4(FP), SP at -28
MOVE RR, 24(SP)
;;; } 31 Expr l += r
;;; } 30 ExpressionStatement
;;; { 30 break/continue Statement
;-- branch
JMP L20_brk_60
;;; } 30 break/continue Statement
;;; { 30 case Statement
L20_case_60_0073:
;;; { 31 ExpressionStatement
;;; { 32 Expr l += r
;;; { 33 TypeName
;;; { 34 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 34 TypeSpecifier (all)
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = len
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;;; } 33 TypeName
;;; { 33 Expr l + r
;;; { 34 Expr l(r)
;;; { 35 TypeName
;;; { 36 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 36 TypeSpecifier (all)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = print_item
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; { 35 Expr (l , r)
;;; { 36 ParameterDeclaration
;;; isEllipsis = false
;;; { 37 TypeName
;;; { 38 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 38 TypeSpecifier (all)
;;; { 38 List<DeclItem>
;;; { 39 DeclItem
;;; what = DECL_NAME
;;; name = min_p
;;; } 39 DeclItem
;;; } 38 List<DeclItem>
;;; } 37 TypeName
;;; } 36 ParameterDeclaration
;;; { 36 NumericExpression (constant 32 = 0x20)
;-- load_rr_constant
MOVE #0x0020, RR
;;; } 36 NumericExpression (constant 32 = 0x20)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 36 Expr (l , r)
;;; { 37 ParameterDeclaration
;;; isEllipsis = false
;;; { 38 TypeName
;;; { 39 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 39 TypeSpecifier (all)
;;; { 39 List<DeclItem>
;;; { 40 DeclItem
;;; what = DECL_NAME
;;; name = min_w
;;; } 40 DeclItem
;;; } 39 List<DeclItem>
;;; } 38 TypeName
;;; } 37 ParameterDeclaration
;;; { 37 Expression (variable name)
;;; expr_type = "identifier" (min_w)
;-- load_rr_var min_w = -14(FP), SP at -29 (16 bit)
MOVE 15(SP), RR
;;; } 37 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 37 Expr (l , r)
;;; { 38 ParameterDeclaration
;;; isEllipsis = false
;;; { 39 TypeName
;;; { 40 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 40 TypeSpecifier (all)
;;; { 40 List<DeclItem>
;;; { 41 DeclItem
;;; what = DECL_NAME
;;; name = field_w
;;; } 41 DeclItem
;;; } 40 List<DeclItem>
;;; } 39 TypeName
;;; } 38 ParameterDeclaration
;;; { 38 Expression (variable name)
;;; expr_type = "identifier" (field_w)
;-- load_rr_var field_w = -12(FP), SP at -31 (16 bit)
MOVE 19(SP), RR
;;; } 38 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 38 Expr (l , r)
;;; { 39 ParameterDeclaration
;;; isEllipsis = false
;;; { 40 TypeName
;;; { 41 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 41 TypeSpecifier (all)
;;; { 41 List<DeclItem>
;;; { 42 DeclItem
;;; what = DECL_POINTER
;;; { 43 List<Ptr>
;;; { 44 Ptr
;;; } 44 Ptr
;;; } 43 List<Ptr>
;;; } 42 DeclItem
;;; { 42 DeclItem
;;; what = DECL_NAME
;;; name = alt
;;; } 42 DeclItem
;;; } 41 List<DeclItem>
;;; } 40 TypeName
;;; } 39 ParameterDeclaration
;;; { 39 StringExpression
;-- load_rr_string
MOVE #Cstr_39, RR
;;; } 39 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 39 Expr (l , r)
;;; { 40 ParameterDeclaration
;;; isEllipsis = false
;;; { 41 TypeName
;;; { 42 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 42 TypeSpecifier (all)
;;; { 42 List<DeclItem>
;;; { 43 DeclItem
;;; what = DECL_NAME
;;; name = pad
;;; } 43 DeclItem
;;; } 42 List<DeclItem>
;;; } 41 TypeName
;;; } 40 ParameterDeclaration
;;; { 40 NumericExpression (constant 32 = 0x20)
;-- load_rr_constant
MOVE #0x0020, RR
;;; } 40 NumericExpression (constant 32 = 0x20)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 40 Expr (l , r)
;;; { 41 ParameterDeclaration
;;; isEllipsis = false
;;; { 42 TypeName
;;; { 43 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 43 TypeSpecifier (all)
;;; { 43 List<DeclItem>
;;; { 44 DeclItem
;;; what = DECL_NAME
;;; name = sign
;;; } 44 DeclItem
;;; } 43 List<DeclItem>
;;; } 42 TypeName
;;; } 41 ParameterDeclaration
;;; { 41 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 41 NumericExpression (constant 0 = 0x0)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 41 Expr (l , r)
;;; { 42 ParameterDeclaration
;;; isEllipsis = false
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = flags
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; } 42 ParameterDeclaration
;;; { 42 Expr l & r
;;; { 43 TypeName (internal)
;;; { 44 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 44 TypeSpecifier (all)
;;; } 43 TypeName (internal)
;;; { 43 Expression (variable name)
;;; expr_type = "identifier" (flags)
;-- load_rr_var flags = -6(FP), SP at -37 (8 bit)
MOVE 31(SP), RS
;;; } 43 Expression (variable name)
;-- l & r
AND RR, #0x0002
;;; } 42 Expr l & r
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 42 ParameterDeclaration
;;; isEllipsis = false
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_POINTER
;;; { 46 List<Ptr>
;;; { 47 Ptr
;;; } 47 Ptr
;;; } 46 List<Ptr>
;;; } 45 DeclItem
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = buffer
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; } 42 ParameterDeclaration
;;; { 42 Expr * r
;;; { 43 Expr l - r
;;; { 44 Expr ++r
;;; { 45 Expression (variable name)
;;; expr_type = "identifier" (args)
;-- load_rr_var args = -2(FP), SP at -38 (16 bit)
MOVE 36(SP), RR
;;; } 45 Expression (variable name)
;-- ++
ADD RR, #0x0002
;-- store_rr_var args = -2(FP), SP at -38
MOVE RR, 36(SP)
;;; } 44 Expr ++r
;-- l - r
SUB RR, #0x0002
;;; } 43 Expr l - r
;-- content
MOVE (RR), RR
;;; } 42 Expr * r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 41 Expr (l , r)
;;; } 40 Expr (l , r)
;;; } 39 Expr (l , r)
;;; } 38 Expr (l , r)
;;; } 37 Expr (l , r)
;;; } 36 Expr (l , r)
;;; } 35 Expr (l , r)
;-- push 2 bytes
;-- call
CALL Cprint_item
;-- pop 12 bytes
ADD SP, #12
;;; } 34 Expr l(r)
;;; { 34 Expression (variable name)
;;; expr_type = "identifier" (len)
;-- load_ll_var len = -4(FP), SP at -28 (16 bit)
MOVE 24(SP), LL
;;; } 34 Expression (variable name)
;-- scale_rr *1
;-- l + r
ADD LL, RR
;;; } 33 Expr l + r
;-- store_rr_var len = -4(FP), SP at -28
MOVE RR, 24(SP)
;;; } 32 Expr l += r
;;; } 31 ExpressionStatement
;;; } 30 case Statement
;;; { 30 break/continue Statement
;-- branch
JMP L20_brk_60
;;; } 30 break/continue Statement
;;; { 30 case Statement
L20_case_60_0075:
;;; { 31 ExpressionStatement
;;; { 32 Expr l(r)
;;; { 33 TypeName
;;; { 34 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 34 TypeSpecifier (all)
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = print_unsigned
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;;; } 33 TypeName
;;; { 33 Expr (l , r)
;;; { 34 ParameterDeclaration
;;; isEllipsis = false
;;; { 35 TypeName
;;; { 36 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 36 TypeSpecifier (all)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = value
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; } 34 ParameterDeclaration
;;; { 34 Expression (cast)r
;;; { 35 Expr * r
;;; { 36 Expr l - r
;;; { 37 Expr ++r
;;; { 38 Expression (variable name)
;;; expr_type = "identifier" (args)
;-- load_rr_var args = -2(FP), SP at -28 (16 bit)
MOVE 26(SP), RR
;;; } 38 Expression (variable name)
;-- ++
ADD RR, #0x0002
;-- store_rr_var args = -2(FP), SP at -28
MOVE RR, 26(SP)
;;; } 37 Expr ++r
;-- l - r
SUB RR, #0x0002
;;; } 36 Expr l - r
;-- content
MOVE (RR), RR
;;; } 35 Expr * r
;;; } 34 Expression (cast)r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 34 ParameterDeclaration
;;; isEllipsis = false
;;; { 35 TypeName
;;; { 36 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 36 TypeSpecifier (all)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_POINTER
;;; { 38 List<Ptr>
;;; { 39 Ptr
;;; } 39 Ptr
;;; } 38 List<Ptr>
;;; } 37 DeclItem
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = dest
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; } 34 ParameterDeclaration
;-- load_address buffer = -28(FP), SP at -30
LEA 2(SP), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 33 Expr (l , r)
;-- push 0 bytes
;-- call
CALL Cprint_unsigned
;-- pop 4 bytes
ADD SP, #4
;;; } 32 Expr l(r)
;;; } 31 ExpressionStatement
;;; } 30 case Statement
;;; { 30 ExpressionStatement
;;; { 31 Expr l += r
;;; { 32 TypeName
;;; { 33 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 33 TypeSpecifier (all)
;;; { 33 List<DeclItem>
;;; { 34 DeclItem
;;; what = DECL_NAME
;;; name = len
;;; } 34 DeclItem
;;; } 33 List<DeclItem>
;;; } 32 TypeName
;;; { 32 Expr l + r
;;; { 33 Expr l(r)
;;; { 34 TypeName
;;; { 35 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 35 TypeSpecifier (all)
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = print_item
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;;; } 34 TypeName
;;; { 34 Expr (l , r)
;;; { 35 ParameterDeclaration
;;; isEllipsis = false
;;; { 36 TypeName
;;; { 37 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 37 TypeSpecifier (all)
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = min_p
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;;; } 36 TypeName
;;; } 35 ParameterDeclaration
;;; { 35 NumericExpression (constant 48 = 0x30)
;-- load_rr_constant
MOVE #0x0030, RR
;;; } 35 NumericExpression (constant 48 = 0x30)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 35 Expr (l , r)
;;; { 36 ParameterDeclaration
;;; isEllipsis = false
;;; { 37 TypeName
;;; { 38 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 38 TypeSpecifier (all)
;;; { 38 List<DeclItem>
;;; { 39 DeclItem
;;; what = DECL_NAME
;;; name = min_w
;;; } 39 DeclItem
;;; } 38 List<DeclItem>
;;; } 37 TypeName
;;; } 36 ParameterDeclaration
;;; { 36 Expression (variable name)
;;; expr_type = "identifier" (min_w)
;-- load_rr_var min_w = -14(FP), SP at -29 (16 bit)
MOVE 15(SP), RR
;;; } 36 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 36 Expr (l , r)
;;; { 37 ParameterDeclaration
;;; isEllipsis = false
;;; { 38 TypeName
;;; { 39 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 39 TypeSpecifier (all)
;;; { 39 List<DeclItem>
;;; { 40 DeclItem
;;; what = DECL_NAME
;;; name = field_w
;;; } 40 DeclItem
;;; } 39 List<DeclItem>
;;; } 38 TypeName
;;; } 37 ParameterDeclaration
;;; { 37 Expression (variable name)
;;; expr_type = "identifier" (field_w)
;-- load_rr_var field_w = -12(FP), SP at -31 (16 bit)
MOVE 19(SP), RR
;;; } 37 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 37 Expr (l , r)
;;; { 38 ParameterDeclaration
;;; isEllipsis = false
;;; { 39 TypeName
;;; { 40 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 40 TypeSpecifier (all)
;;; { 40 List<DeclItem>
;;; { 41 DeclItem
;;; what = DECL_POINTER
;;; { 42 List<Ptr>
;;; { 43 Ptr
;;; } 43 Ptr
;;; } 42 List<Ptr>
;;; } 41 DeclItem
;;; { 41 DeclItem
;;; what = DECL_NAME
;;; name = alt
;;; } 41 DeclItem
;;; } 40 List<DeclItem>
;;; } 39 TypeName
;;; } 38 ParameterDeclaration
;;; { 38 StringExpression
;-- load_rr_string
MOVE #Cstr_40, RR
;;; } 38 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 38 Expr (l , r)
;;; { 39 ParameterDeclaration
;;; isEllipsis = false
;;; { 40 TypeName
;;; { 41 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 41 TypeSpecifier (all)
;;; { 41 List<DeclItem>
;;; { 42 DeclItem
;;; what = DECL_NAME
;;; name = pad
;;; } 42 DeclItem
;;; } 41 List<DeclItem>
;;; } 40 TypeName
;;; } 39 ParameterDeclaration
;;; { 39 Expression (variable name)
;;; expr_type = "identifier" (pad)
;-- load_rr_var pad = -8(FP), SP at -35 (8 bit)
MOVE 27(SP), RS
;;; } 39 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 39 Expr (l , r)
;;; { 40 ParameterDeclaration
;;; isEllipsis = false
;;; { 41 TypeName
;;; { 42 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 42 TypeSpecifier (all)
;;; { 42 List<DeclItem>
;;; { 43 DeclItem
;;; what = DECL_NAME
;;; name = sign
;;; } 43 DeclItem
;;; } 42 List<DeclItem>
;;; } 41 TypeName
;;; } 40 ParameterDeclaration
;;; { 40 Expression (variable name)
;;; expr_type = "identifier" (sign)
;-- load_rr_var sign = -7(FP), SP at -36 (8 bit)
MOVE 29(SP), RS
;;; } 40 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 40 Expr (l , r)
;;; { 41 ParameterDeclaration
;;; isEllipsis = false
;;; { 42 TypeName
;;; { 43 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 43 TypeSpecifier (all)
;;; { 43 List<DeclItem>
;;; { 44 DeclItem
;;; what = DECL_NAME
;;; name = flags
;;; } 44 DeclItem
;;; } 43 List<DeclItem>
;;; } 42 TypeName
;;; } 41 ParameterDeclaration
;;; { 41 Expression (variable name)
;;; expr_type = "identifier" (flags)
;-- load_rr_var flags = -6(FP), SP at -37 (8 bit)
MOVE 31(SP), RS
;;; } 41 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 41 ParameterDeclaration
;;; isEllipsis = false
;;; { 42 TypeName
;;; { 43 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 43 TypeSpecifier (all)
;;; { 43 List<DeclItem>
;;; { 44 DeclItem
;;; what = DECL_POINTER
;;; { 45 List<Ptr>
;;; { 46 Ptr
;;; } 46 Ptr
;;; } 45 List<Ptr>
;;; } 44 DeclItem
;;; { 44 DeclItem
;;; what = DECL_NAME
;;; name = buffer
;;; } 44 DeclItem
;;; } 43 List<DeclItem>
;;; } 42 TypeName
;;; } 41 ParameterDeclaration
;-- load_address buffer = -28(FP), SP at -38
LEA 10(SP), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 40 Expr (l , r)
;;; } 39 Expr (l , r)
;;; } 38 Expr (l , r)
;;; } 37 Expr (l , r)
;;; } 36 Expr (l , r)
;;; } 35 Expr (l , r)
;;; } 34 Expr (l , r)
;-- push 2 bytes
;-- call
CALL Cprint_item
;-- pop 12 bytes
ADD SP, #12
;;; } 33 Expr l(r)
;;; { 33 Expression (variable name)
;;; expr_type = "identifier" (len)
;-- load_ll_var len = -4(FP), SP at -28 (16 bit)
MOVE 24(SP), LL
;;; } 33 Expression (variable name)
;-- scale_rr *1
;-- l + r
ADD LL, RR
;;; } 32 Expr l + r
;-- store_rr_var len = -4(FP), SP at -28
MOVE RR, 24(SP)
;;; } 31 Expr l += r
;;; } 30 ExpressionStatement
;;; { 30 break/continue Statement
;-- branch
JMP L20_brk_60
;;; } 30 break/continue Statement
;;; { 30 case Statement
L20_case_60_0078:
;;; { 31 ExpressionStatement
;;; { 32 Expr l(r)
;;; { 33 TypeName
;;; { 34 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 34 TypeSpecifier (all)
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = print_hex
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;;; } 33 TypeName
;;; { 33 Expr (l , r)
;;; { 34 ParameterDeclaration
;;; isEllipsis = false
;;; { 35 TypeName
;;; { 36 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 36 TypeSpecifier (all)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_POINTER
;;; { 38 List<Ptr>
;;; { 39 Ptr
;;; } 39 Ptr
;;; } 38 List<Ptr>
;;; } 37 DeclItem
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = hex
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; } 34 ParameterDeclaration
;;; { 34 StringExpression
;-- load_rr_string
MOVE #Cstr_41, RR
;;; } 34 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 34 Expr (l , r)
;;; { 35 ParameterDeclaration
;;; isEllipsis = false
;;; { 36 TypeName
;;; { 37 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 37 TypeSpecifier (all)
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = value
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;;; } 36 TypeName
;;; } 35 ParameterDeclaration
;;; { 35 Expression (cast)r
;;; { 36 Expr * r
;;; { 37 Expr l - r
;;; { 38 Expr ++r
;;; { 39 Expression (variable name)
;;; expr_type = "identifier" (args)
;-- load_rr_var args = -2(FP), SP at -30 (16 bit)
MOVE 28(SP), RR
;;; } 39 Expression (variable name)
;-- ++
ADD RR, #0x0002
;-- store_rr_var args = -2(FP), SP at -30
MOVE RR, 28(SP)
;;; } 38 Expr ++r
;-- l - r
SUB RR, #0x0002
;;; } 37 Expr l - r
;-- content
MOVE (RR), RR
;;; } 36 Expr * r
;;; } 35 Expression (cast)r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 35 ParameterDeclaration
;;; isEllipsis = false
;;; { 36 TypeName
;;; { 37 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 37 TypeSpecifier (all)
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_POINTER
;;; { 39 List<Ptr>
;;; { 40 Ptr
;;; } 40 Ptr
;;; } 39 List<Ptr>
;;; } 38 DeclItem
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = dest
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;;; } 36 TypeName
;;; } 35 ParameterDeclaration
;-- load_address buffer = -28(FP), SP at -32
LEA 4(SP), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 34 Expr (l , r)
;;; } 33 Expr (l , r)
;-- push 0 bytes
;-- call
CALL Cprint_hex
;-- pop 6 bytes
ADD SP, #6
;;; } 32 Expr l(r)
;;; } 31 ExpressionStatement
;;; } 30 case Statement
;;; { 30 ExpressionStatement
;;; { 31 Expr l += r
;;; { 32 TypeName
;;; { 33 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 33 TypeSpecifier (all)
;;; { 33 List<DeclItem>
;;; { 34 DeclItem
;;; what = DECL_NAME
;;; name = len
;;; } 34 DeclItem
;;; } 33 List<DeclItem>
;;; } 32 TypeName
;;; { 32 Expr l + r
;;; { 33 Expr l(r)
;;; { 34 TypeName
;;; { 35 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 35 TypeSpecifier (all)
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = print_item
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;;; } 34 TypeName
;;; { 34 Expr (l , r)
;;; { 35 ParameterDeclaration
;;; isEllipsis = false
;;; { 36 TypeName
;;; { 37 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 37 TypeSpecifier (all)
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = min_p
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;;; } 36 TypeName
;;; } 35 ParameterDeclaration
;;; { 35 NumericExpression (constant 48 = 0x30)
;-- load_rr_constant
MOVE #0x0030, RR
;;; } 35 NumericExpression (constant 48 = 0x30)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 35 Expr (l , r)
;;; { 36 ParameterDeclaration
;;; isEllipsis = false
;;; { 37 TypeName
;;; { 38 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 38 TypeSpecifier (all)
;;; { 38 List<DeclItem>
;;; { 39 DeclItem
;;; what = DECL_NAME
;;; name = min_w
;;; } 39 DeclItem
;;; } 38 List<DeclItem>
;;; } 37 TypeName
;;; } 36 ParameterDeclaration
;;; { 36 Expression (variable name)
;;; expr_type = "identifier" (min_w)
;-- load_rr_var min_w = -14(FP), SP at -29 (16 bit)
MOVE 15(SP), RR
;;; } 36 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 36 Expr (l , r)
;;; { 37 ParameterDeclaration
;;; isEllipsis = false
;;; { 38 TypeName
;;; { 39 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 39 TypeSpecifier (all)
;;; { 39 List<DeclItem>
;;; { 40 DeclItem
;;; what = DECL_NAME
;;; name = field_w
;;; } 40 DeclItem
;;; } 39 List<DeclItem>
;;; } 38 TypeName
;;; } 37 ParameterDeclaration
;;; { 37 Expression (variable name)
;;; expr_type = "identifier" (field_w)
;-- load_rr_var field_w = -12(FP), SP at -31 (16 bit)
MOVE 19(SP), RR
;;; } 37 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 37 Expr (l , r)
;;; { 38 ParameterDeclaration
;;; isEllipsis = false
;;; { 39 TypeName
;;; { 40 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 40 TypeSpecifier (all)
;;; { 40 List<DeclItem>
;;; { 41 DeclItem
;;; what = DECL_POINTER
;;; { 42 List<Ptr>
;;; { 43 Ptr
;;; } 43 Ptr
;;; } 42 List<Ptr>
;;; } 41 DeclItem
;;; { 41 DeclItem
;;; what = DECL_NAME
;;; name = alt
;;; } 41 DeclItem
;;; } 40 List<DeclItem>
;;; } 39 TypeName
;;; } 38 ParameterDeclaration
;;; { 38 StringExpression
;-- load_rr_string
MOVE #Cstr_42, RR
;;; } 38 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 38 Expr (l , r)
;;; { 39 ParameterDeclaration
;;; isEllipsis = false
;;; { 40 TypeName
;;; { 41 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 41 TypeSpecifier (all)
;;; { 41 List<DeclItem>
;;; { 42 DeclItem
;;; what = DECL_NAME
;;; name = pad
;;; } 42 DeclItem
;;; } 41 List<DeclItem>
;;; } 40 TypeName
;;; } 39 ParameterDeclaration
;;; { 39 Expression (variable name)
;;; expr_type = "identifier" (pad)
;-- load_rr_var pad = -8(FP), SP at -35 (8 bit)
MOVE 27(SP), RS
;;; } 39 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 39 Expr (l , r)
;;; { 40 ParameterDeclaration
;;; isEllipsis = false
;;; { 41 TypeName
;;; { 42 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 42 TypeSpecifier (all)
;;; { 42 List<DeclItem>
;;; { 43 DeclItem
;;; what = DECL_NAME
;;; name = sign
;;; } 43 DeclItem
;;; } 42 List<DeclItem>
;;; } 41 TypeName
;;; } 40 ParameterDeclaration
;;; { 40 Expression (variable name)
;;; expr_type = "identifier" (sign)
;-- load_rr_var sign = -7(FP), SP at -36 (8 bit)
MOVE 29(SP), RS
;;; } 40 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 40 Expr (l , r)
;;; { 41 ParameterDeclaration
;;; isEllipsis = false
;;; { 42 TypeName
;;; { 43 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 43 TypeSpecifier (all)
;;; { 43 List<DeclItem>
;;; { 44 DeclItem
;;; what = DECL_NAME
;;; name = flags
;;; } 44 DeclItem
;;; } 43 List<DeclItem>
;;; } 42 TypeName
;;; } 41 ParameterDeclaration
;;; { 41 Expression (variable name)
;;; expr_type = "identifier" (flags)
;-- load_rr_var flags = -6(FP), SP at -37 (8 bit)
MOVE 31(SP), RS
;;; } 41 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 41 ParameterDeclaration
;;; isEllipsis = false
;;; { 42 TypeName
;;; { 43 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 43 TypeSpecifier (all)
;;; { 43 List<DeclItem>
;;; { 44 DeclItem
;;; what = DECL_POINTER
;;; { 45 List<Ptr>
;;; { 46 Ptr
;;; } 46 Ptr
;;; } 45 List<Ptr>
;;; } 44 DeclItem
;;; { 44 DeclItem
;;; what = DECL_NAME
;;; name = buffer
;;; } 44 DeclItem
;;; } 43 List<DeclItem>
;;; } 42 TypeName
;;; } 41 ParameterDeclaration
;-- load_address buffer = -28(FP), SP at -38
LEA 10(SP), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 40 Expr (l , r)
;;; } 39 Expr (l , r)
;;; } 38 Expr (l , r)
;;; } 37 Expr (l , r)
;;; } 36 Expr (l , r)
;;; } 35 Expr (l , r)
;;; } 34 Expr (l , r)
;-- push 2 bytes
;-- call
CALL Cprint_item
;-- pop 12 bytes
ADD SP, #12
;;; } 33 Expr l(r)
;;; { 33 Expression (variable name)
;;; expr_type = "identifier" (len)
;-- load_ll_var len = -4(FP), SP at -28 (16 bit)
MOVE 24(SP), LL
;;; } 33 Expression (variable name)
;-- scale_rr *1
;-- l + r
ADD LL, RR
;;; } 32 Expr l + r
;-- store_rr_var len = -4(FP), SP at -28
MOVE RR, 24(SP)
;;; } 31 Expr l += r
;;; } 30 ExpressionStatement
;;; { 30 break/continue Statement
;-- branch
JMP L20_brk_60
;;; } 30 break/continue Statement
;;; { 30 case Statement
L20_case_60_0063:
;;; { 31 ExpressionStatement
;;; { 32 Expr l += r
;;; { 33 TypeName
;;; { 34 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 34 TypeSpecifier (all)
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = len
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;;; } 33 TypeName
;;; { 33 Expr l + r
;;; { 34 Expr l(r)
;;; { 35 TypeName
;;; { 36 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 36 TypeSpecifier (all)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = putchr
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; { 35 ParameterDeclaration
;;; isEllipsis = false
;;; { 36 TypeName
;;; { 37 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 37 TypeSpecifier (all)
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;;; } 36 TypeName
;;; } 35 ParameterDeclaration
;;; { 35 Expression (cast)r
;;; { 36 Expr * r
;;; { 37 Expr l - r
;;; { 38 Expr ++r
;;; { 39 Expression (variable name)
;;; expr_type = "identifier" (args)
;-- load_rr_var args = -2(FP), SP at -28 (16 bit)
MOVE 26(SP), RR
;;; } 39 Expression (variable name)
;-- ++
ADD RR, #0x0002
;-- store_rr_var args = -2(FP), SP at -28
MOVE RR, 26(SP)
;;; } 38 Expr ++r
;-- l - r
SUB RR, #0x0002
;;; } 37 Expr l - r
;-- content
MOVE (RR), RR
;;; } 36 Expr * r
;;; } 35 Expression (cast)r
;-- push_rr (8 bit)
MOVE R, -(SP)
;-- push 2 bytes
;-- call
CALL Cputchr
;-- pop 1 bytes
ADD SP, #1
;;; } 34 Expr l(r)
;;; { 34 Expression (variable name)
;;; expr_type = "identifier" (len)
;-- load_ll_var len = -4(FP), SP at -28 (16 bit)
MOVE 24(SP), LL
;;; } 34 Expression (variable name)
;-- scale_rr *1
;-- l + r
ADD LL, RR
;;; } 33 Expr l + r
;-- store_rr_var len = -4(FP), SP at -28
MOVE RR, 24(SP)
;;; } 32 Expr l += r
;;; } 31 ExpressionStatement
;;; } 30 case Statement
;;; { 30 break/continue Statement
;-- branch
JMP L20_brk_60
;;; } 30 break/continue Statement
;;; { 30 case Statement
L20_case_60_0023:
;;; { 31 ExpressionStatement
;;; { 32 Expr l | r
;;; { 33 TypeName
;;; { 34 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 34 TypeSpecifier (all)
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = flags
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;;; } 33 TypeName
;;; { 33 Expr l | r
;;; { 34 TypeName (internal)
;;; { 35 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 35 TypeSpecifier (all)
;;; } 34 TypeName (internal)
;;; { 34 Expression (variable name)
;;; expr_type = "identifier" (flags)
;-- load_rr_var flags = -6(FP), SP at -28 (8 bit)
MOVE 22(SP), RS
;;; } 34 Expression (variable name)
;-- l | r
OR RR, #0x0001
;;; } 33 Expr l | r
;-- store_rr_var flags = -6(FP), SP at -28
MOVE R, 22(SP)
;;; } 32 Expr l | r
;;; } 31 ExpressionStatement
;;; } 30 case Statement
;;; { 30 break/continue Statement
;-- branch
JMP L20_cont_58
;;; } 30 break/continue Statement
;;; { 30 case Statement
L20_case_60_002D:
;;; { 31 ExpressionStatement
;;; { 32 Expr l | r
;;; { 33 TypeName
;;; { 34 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 34 TypeSpecifier (all)
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = flags
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;;; } 33 TypeName
;;; { 33 Expr l | r
;;; { 34 TypeName (internal)
;;; { 35 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 35 TypeSpecifier (all)
;;; } 34 TypeName (internal)
;;; { 34 Expression (variable name)
;;; expr_type = "identifier" (flags)
;-- load_rr_var flags = -6(FP), SP at -28 (8 bit)
MOVE 22(SP), RS
;;; } 34 Expression (variable name)
;-- l | r
OR RR, #0x0002
;;; } 33 Expr l | r
;-- store_rr_var flags = -6(FP), SP at -28
MOVE R, 22(SP)
;;; } 32 Expr l | r
;;; } 31 ExpressionStatement
;;; } 30 case Statement
;;; { 30 break/continue Statement
;-- branch
JMP L20_cont_58
;;; } 30 break/continue Statement
;;; { 30 case Statement
L20_case_60_0020:
;;; { 31 IfElseStatement
;;; { 32 Expr ! r
;;; { 33 Expression (variable name)
;;; expr_type = "identifier" (sign)
;-- load_rr_var sign = -7(FP), SP at -28 (8 bit)
MOVE 21(SP), RS
;;; } 33 Expression (variable name)
;-- 16 bit ! r
LNOT RR
;;; } 32 Expr ! r
;-- branch_false
JMP RRZ, L20_endif_62
;;; { 32 ExpressionStatement
;;; { 33 Expr l = r
;;; { 34 TypeName
;;; { 35 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 35 TypeSpecifier (all)
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = sign
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;;; } 34 TypeName
;;; { 34 NumericExpression (constant 32 = 0x20)
;-- load_rr_constant
MOVE #0x0020, RR
;;; } 34 NumericExpression (constant 32 = 0x20)
;-- store_rr_var sign = -7(FP), SP at -28
MOVE R, 21(SP)
;;; } 33 Expr l = r
;;; } 32 ExpressionStatement
L20_endif_62:
;;; } 31 IfElseStatement
;;; } 30 case Statement
;;; { 30 break/continue Statement
;-- branch
JMP L20_cont_58
;;; } 30 break/continue Statement
;;; { 30 case Statement
L20_case_60_002B:
;;; { 31 ExpressionStatement
;;; { 32 Expr l = r
;;; { 33 TypeName
;;; { 34 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 34 TypeSpecifier (all)
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = sign
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;;; } 33 TypeName
;;; { 33 NumericExpression (constant 43 = 0x2B)
;-- load_rr_constant
MOVE #0x002B, RR
;;; } 33 NumericExpression (constant 43 = 0x2B)
;-- store_rr_var sign = -7(FP), SP at -28
MOVE R, 21(SP)
;;; } 32 Expr l = r
;;; } 31 ExpressionStatement
;;; } 30 case Statement
;;; { 30 break/continue Statement
;-- branch
JMP L20_cont_58
;;; } 30 break/continue Statement
;;; { 30 case Statement
L20_case_60_002E:
;;; { 31 ExpressionStatement
;;; { 32 Expr l = r
;;; { 33 TypeName
;;; { 34 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 34 TypeSpecifier (all)
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_POINTER
;;; { 36 List<Ptr>
;;; { 37 Ptr
;;; } 37 Ptr
;;; } 36 List<Ptr>
;;; } 35 DeclItem
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = which_w
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;;; } 33 TypeName
;;; { 33 Expr & r
;-- load_address min_w = -14(FP), SP at -28
LEA 14(SP), RR
;;; } 33 Expr & r
;-- store_rr_var which_w = -16(FP), SP at -28
MOVE RR, 12(SP)
;;; } 32 Expr l = r
;;; } 31 ExpressionStatement
;;; } 30 case Statement
;;; { 30 break/continue Statement
;-- branch
JMP L20_cont_58
;;; } 30 break/continue Statement
;;; { 30 case Statement
L20_case_60_0030:
;;; { 31 IfElseStatement
;;; { 32 Expr * r
;;; { 33 Expression (variable name)
;;; expr_type = "identifier" (which_w)
;-- load_rr_var which_w = -16(FP), SP at -28 (16 bit)
MOVE 12(SP), RR
;;; } 33 Expression (variable name)
;-- content
MOVE (RR), RR
;;; } 32 Expr * r
;-- branch_false
JMP RRZ, L20_else_63
;;; { 32 ExpressionStatement
;;; { 33 Expr l *- r
;;; { 34 TypeName
;;; { 35 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 35 TypeSpecifier (all)
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = which_w
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;;; } 34 TypeName
;;; { 34 Expr l * r
;;; { 35 TypeName (internal)
;;; { 36 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 36 TypeSpecifier (all)
;;; } 35 TypeName (internal)
;;; { 35 Expr * r
;;; { 36 Expression (variable name)
;;; expr_type = "identifier" (which_w)
;-- load_rr_var which_w = -16(FP), SP at -28 (16 bit)
MOVE 12(SP), RR
;;; } 36 Expression (variable name)
;-- content
MOVE (RR), RR
;;; } 35 Expr * r
;-- l * r
MOVE RR, LL
MOVE #0x000A, RR
;-- l * r
DI
MUL_IU
CALL mult_div
MD_FIN
EI
;;; } 34 Expr l * r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 34 Expr * r
;;; { 35 Expression (variable name)
;;; expr_type = "identifier" (which_w)
;-- load_rr_var which_w = -16(FP), SP at -30 (16 bit)
MOVE 14(SP), RR
;;; } 35 Expression (variable name)
;;; } 34 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (16 bit)
MOVE (SP)+, RR
;-- assign (16 bit)
MOVE RR, (LL)
;;; } 33 Expr l *- r
;;; } 32 ExpressionStatement
;-- branch
JMP L20_endif_63
L20_else_63:
;;; { 32 ExpressionStatement
;;; { 33 Expr l = r
;;; { 34 TypeName
;;; { 35 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 35 TypeSpecifier (all)
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = pad
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;;; } 34 TypeName
;;; { 34 NumericExpression (constant 48 = 0x30)
;-- load_rr_constant
MOVE #0x0030, RR
;;; } 34 NumericExpression (constant 48 = 0x30)
;-- store_rr_var pad = -8(FP), SP at -28
MOVE R, 20(SP)
;;; } 33 Expr l = r
;;; } 32 ExpressionStatement
L20_endif_63:
;;; } 31 IfElseStatement
;;; } 30 case Statement
;;; { 30 break/continue Statement
;-- branch
JMP L20_cont_58
;;; } 30 break/continue Statement
;;; { 30 case Statement
L20_case_60_0031:
;;; { 31 ExpressionStatement
;;; { 32 Expr l = r
;;; { 33 TypeName
;;; { 34 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 34 TypeSpecifier (all)
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = which_w
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;;; } 33 TypeName
;;; { 33 Expr l + r
;;; { 34 Expr l * r
;;; { 35 TypeName (internal)
;;; { 36 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 36 TypeSpecifier (all)
;;; } 35 TypeName (internal)
;;; { 35 Expr * r
;;; { 36 Expression (variable name)
;;; expr_type = "identifier" (which_w)
;-- load_rr_var which_w = -16(FP), SP at -28 (16 bit)
MOVE 12(SP), RR
;;; } 36 Expression (variable name)
;-- content
MOVE (RR), RR
;;; } 35 Expr * r
;-- l * r
MOVE RR, LL
MOVE #0x000A, RR
;-- l * r
DI
MUL_IU
CALL mult_div
MD_FIN
EI
;;; } 34 Expr l * r
;-- l + r
ADD RR, #0x0001
;;; } 33 Expr l + r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 33 Expr * r
;;; { 34 Expression (variable name)
;;; expr_type = "identifier" (which_w)
;-- load_rr_var which_w = -16(FP), SP at -30 (16 bit)
MOVE 14(SP), RR
;;; } 34 Expression (variable name)
;;; } 33 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (16 bit)
MOVE (SP)+, RR
;-- assign (16 bit)
MOVE RR, (LL)
;;; } 32 Expr l = r
;;; } 31 ExpressionStatement
;;; } 30 case Statement
;;; { 30 break/continue Statement
;-- branch
JMP L20_cont_58
;;; } 30 break/continue Statement
;;; { 30 case Statement
L20_case_60_0032:
;;; { 31 ExpressionStatement
;;; { 32 Expr l = r
;;; { 33 TypeName
;;; { 34 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 34 TypeSpecifier (all)
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = which_w
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;;; } 33 TypeName
;;; { 33 Expr l + r
;;; { 34 Expr l * r
;;; { 35 TypeName (internal)
;;; { 36 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 36 TypeSpecifier (all)
;;; } 35 TypeName (internal)
;;; { 35 Expr * r
;;; { 36 Expression (variable name)
;;; expr_type = "identifier" (which_w)
;-- load_rr_var which_w = -16(FP), SP at -28 (16 bit)
MOVE 12(SP), RR
;;; } 36 Expression (variable name)
;-- content
MOVE (RR), RR
;;; } 35 Expr * r
;-- l * r
MOVE RR, LL
MOVE #0x000A, RR
;-- l * r
DI
MUL_IU
CALL mult_div
MD_FIN
EI
;;; } 34 Expr l * r
;-- l + r
ADD RR, #0x0002
;;; } 33 Expr l + r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 33 Expr * r
;;; { 34 Expression (variable name)
;;; expr_type = "identifier" (which_w)
;-- load_rr_var which_w = -16(FP), SP at -30 (16 bit)
MOVE 14(SP), RR
;;; } 34 Expression (variable name)
;;; } 33 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (16 bit)
MOVE (SP)+, RR
;-- assign (16 bit)
MOVE RR, (LL)
;;; } 32 Expr l = r
;;; } 31 ExpressionStatement
;;; } 30 case Statement
;;; { 30 break/continue Statement
;-- branch
JMP L20_cont_58
;;; } 30 break/continue Statement
;;; { 30 case Statement
L20_case_60_0033:
;;; { 31 ExpressionStatement
;;; { 32 Expr l = r
;;; { 33 TypeName
;;; { 34 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 34 TypeSpecifier (all)
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = which_w
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;;; } 33 TypeName
;;; { 33 Expr l + r
;;; { 34 Expr l * r
;;; { 35 TypeName (internal)
;;; { 36 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 36 TypeSpecifier (all)
;;; } 35 TypeName (internal)
;;; { 35 Expr * r
;;; { 36 Expression (variable name)
;;; expr_type = "identifier" (which_w)
;-- load_rr_var which_w = -16(FP), SP at -28 (16 bit)
MOVE 12(SP), RR
;;; } 36 Expression (variable name)
;-- content
MOVE (RR), RR
;;; } 35 Expr * r
;-- l * r
MOVE RR, LL
MOVE #0x000A, RR
;-- l * r
DI
MUL_IU
CALL mult_div
MD_FIN
EI
;;; } 34 Expr l * r
;-- l + r
ADD RR, #0x0003
;;; } 33 Expr l + r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 33 Expr * r
;;; { 34 Expression (variable name)
;;; expr_type = "identifier" (which_w)
;-- load_rr_var which_w = -16(FP), SP at -30 (16 bit)
MOVE 14(SP), RR
;;; } 34 Expression (variable name)
;;; } 33 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (16 bit)
MOVE (SP)+, RR
;-- assign (16 bit)
MOVE RR, (LL)
;;; } 32 Expr l = r
;;; } 31 ExpressionStatement
;;; } 30 case Statement
;;; { 30 break/continue Statement
;-- branch
JMP L20_cont_58
;;; } 30 break/continue Statement
;;; { 30 case Statement
L20_case_60_0034:
;;; { 31 ExpressionStatement
;;; { 32 Expr l = r
;;; { 33 TypeName
;;; { 34 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 34 TypeSpecifier (all)
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = which_w
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;;; } 33 TypeName
;;; { 33 Expr l + r
;;; { 34 Expr l * r
;;; { 35 TypeName (internal)
;;; { 36 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 36 TypeSpecifier (all)
;;; } 35 TypeName (internal)
;;; { 35 Expr * r
;;; { 36 Expression (variable name)
;;; expr_type = "identifier" (which_w)
;-- load_rr_var which_w = -16(FP), SP at -28 (16 bit)
MOVE 12(SP), RR
;;; } 36 Expression (variable name)
;-- content
MOVE (RR), RR
;;; } 35 Expr * r
;-- l * r
MOVE RR, LL
MOVE #0x000A, RR
;-- l * r
DI
MUL_IU
CALL mult_div
MD_FIN
EI
;;; } 34 Expr l * r
;-- l + r
ADD RR, #0x0004
;;; } 33 Expr l + r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 33 Expr * r
;;; { 34 Expression (variable name)
;;; expr_type = "identifier" (which_w)
;-- load_rr_var which_w = -16(FP), SP at -30 (16 bit)
MOVE 14(SP), RR
;;; } 34 Expression (variable name)
;;; } 33 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (16 bit)
MOVE (SP)+, RR
;-- assign (16 bit)
MOVE RR, (LL)
;;; } 32 Expr l = r
;;; } 31 ExpressionStatement
;;; } 30 case Statement
;;; { 30 break/continue Statement
;-- branch
JMP L20_cont_58
;;; } 30 break/continue Statement
;;; { 30 case Statement
L20_case_60_0035:
;;; { 31 ExpressionStatement
;;; { 32 Expr l = r
;;; { 33 TypeName
;;; { 34 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 34 TypeSpecifier (all)
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = which_w
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;;; } 33 TypeName
;;; { 33 Expr l + r
;;; { 34 Expr l * r
;;; { 35 TypeName (internal)
;;; { 36 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 36 TypeSpecifier (all)
;;; } 35 TypeName (internal)
;;; { 35 Expr * r
;;; { 36 Expression (variable name)
;;; expr_type = "identifier" (which_w)
;-- load_rr_var which_w = -16(FP), SP at -28 (16 bit)
MOVE 12(SP), RR
;;; } 36 Expression (variable name)
;-- content
MOVE (RR), RR
;;; } 35 Expr * r
;-- l * r
MOVE RR, LL
MOVE #0x000A, RR
;-- l * r
DI
MUL_IU
CALL mult_div
MD_FIN
EI
;;; } 34 Expr l * r
;-- l + r
ADD RR, #0x0005
;;; } 33 Expr l + r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 33 Expr * r
;;; { 34 Expression (variable name)
;;; expr_type = "identifier" (which_w)
;-- load_rr_var which_w = -16(FP), SP at -30 (16 bit)
MOVE 14(SP), RR
;;; } 34 Expression (variable name)
;;; } 33 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (16 bit)
MOVE (SP)+, RR
;-- assign (16 bit)
MOVE RR, (LL)
;;; } 32 Expr l = r
;;; } 31 ExpressionStatement
;;; } 30 case Statement
;;; { 30 break/continue Statement
;-- branch
JMP L20_cont_58
;;; } 30 break/continue Statement
;;; { 30 case Statement
L20_case_60_0036:
;;; { 31 ExpressionStatement
;;; { 32 Expr l = r
;;; { 33 TypeName
;;; { 34 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 34 TypeSpecifier (all)
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = which_w
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;;; } 33 TypeName
;;; { 33 Expr l + r
;;; { 34 Expr l * r
;;; { 35 TypeName (internal)
;;; { 36 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 36 TypeSpecifier (all)
;;; } 35 TypeName (internal)
;;; { 35 Expr * r
;;; { 36 Expression (variable name)
;;; expr_type = "identifier" (which_w)
;-- load_rr_var which_w = -16(FP), SP at -28 (16 bit)
MOVE 12(SP), RR
;;; } 36 Expression (variable name)
;-- content
MOVE (RR), RR
;;; } 35 Expr * r
;-- l * r
MOVE RR, LL
MOVE #0x000A, RR
;-- l * r
DI
MUL_IU
CALL mult_div
MD_FIN
EI
;;; } 34 Expr l * r
;-- l + r
ADD RR, #0x0006
;;; } 33 Expr l + r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 33 Expr * r
;;; { 34 Expression (variable name)
;;; expr_type = "identifier" (which_w)
;-- load_rr_var which_w = -16(FP), SP at -30 (16 bit)
MOVE 14(SP), RR
;;; } 34 Expression (variable name)
;;; } 33 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (16 bit)
MOVE (SP)+, RR
;-- assign (16 bit)
MOVE RR, (LL)
;;; } 32 Expr l = r
;;; } 31 ExpressionStatement
;;; } 30 case Statement
;;; { 30 break/continue Statement
;-- branch
JMP L20_cont_58
;;; } 30 break/continue Statement
;;; { 30 case Statement
L20_case_60_0037:
;;; { 31 ExpressionStatement
;;; { 32 Expr l = r
;;; { 33 TypeName
;;; { 34 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 34 TypeSpecifier (all)
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = which_w
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;;; } 33 TypeName
;;; { 33 Expr l + r
;;; { 34 Expr l * r
;;; { 35 TypeName (internal)
;;; { 36 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 36 TypeSpecifier (all)
;;; } 35 TypeName (internal)
;;; { 35 Expr * r
;;; { 36 Expression (variable name)
;;; expr_type = "identifier" (which_w)
;-- load_rr_var which_w = -16(FP), SP at -28 (16 bit)
MOVE 12(SP), RR
;;; } 36 Expression (variable name)
;-- content
MOVE (RR), RR
;;; } 35 Expr * r
;-- l * r
MOVE RR, LL
MOVE #0x000A, RR
;-- l * r
DI
MUL_IU
CALL mult_div
MD_FIN
EI
;;; } 34 Expr l * r
;-- l + r
ADD RR, #0x0007
;;; } 33 Expr l + r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 33 Expr * r
;;; { 34 Expression (variable name)
;;; expr_type = "identifier" (which_w)
;-- load_rr_var which_w = -16(FP), SP at -30 (16 bit)
MOVE 14(SP), RR
;;; } 34 Expression (variable name)
;;; } 33 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (16 bit)
MOVE (SP)+, RR
;-- assign (16 bit)
MOVE RR, (LL)
;;; } 32 Expr l = r
;;; } 31 ExpressionStatement
;;; } 30 case Statement
;;; { 30 break/continue Statement
;-- branch
JMP L20_cont_58
;;; } 30 break/continue Statement
;;; { 30 case Statement
L20_case_60_0038:
;;; { 31 ExpressionStatement
;;; { 32 Expr l = r
;;; { 33 TypeName
;;; { 34 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 34 TypeSpecifier (all)
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = which_w
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;;; } 33 TypeName
;;; { 33 Expr l + r
;;; { 34 Expr l * r
;;; { 35 TypeName (internal)
;;; { 36 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 36 TypeSpecifier (all)
;;; } 35 TypeName (internal)
;;; { 35 Expr * r
;;; { 36 Expression (variable name)
;;; expr_type = "identifier" (which_w)
;-- load_rr_var which_w = -16(FP), SP at -28 (16 bit)
MOVE 12(SP), RR
;;; } 36 Expression (variable name)
;-- content
MOVE (RR), RR
;;; } 35 Expr * r
;-- l * r
MOVE RR, LL
MOVE #0x000A, RR
;-- l * r
DI
MUL_IU
CALL mult_div
MD_FIN
EI
;;; } 34 Expr l * r
;-- l + r
ADD RR, #0x0008
;;; } 33 Expr l + r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 33 Expr * r
;;; { 34 Expression (variable name)
;;; expr_type = "identifier" (which_w)
;-- load_rr_var which_w = -16(FP), SP at -30 (16 bit)
MOVE 14(SP), RR
;;; } 34 Expression (variable name)
;;; } 33 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (16 bit)
MOVE (SP)+, RR
;-- assign (16 bit)
MOVE RR, (LL)
;;; } 32 Expr l = r
;;; } 31 ExpressionStatement
;;; } 30 case Statement
;;; { 30 break/continue Statement
;-- branch
JMP L20_cont_58
;;; } 30 break/continue Statement
;;; { 30 case Statement
L20_case_60_0039:
;;; { 31 ExpressionStatement
;;; { 32 Expr l = r
;;; { 33 TypeName
;;; { 34 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 34 TypeSpecifier (all)
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = which_w
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;;; } 33 TypeName
;;; { 33 Expr l + r
;;; { 34 Expr l * r
;;; { 35 TypeName (internal)
;;; { 36 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 36 TypeSpecifier (all)
;;; } 35 TypeName (internal)
;;; { 35 Expr * r
;;; { 36 Expression (variable name)
;;; expr_type = "identifier" (which_w)
;-- load_rr_var which_w = -16(FP), SP at -28 (16 bit)
MOVE 12(SP), RR
;;; } 36 Expression (variable name)
;-- content
MOVE (RR), RR
;;; } 35 Expr * r
;-- l * r
MOVE RR, LL
MOVE #0x000A, RR
;-- l * r
DI
MUL_IU
CALL mult_div
MD_FIN
EI
;;; } 34 Expr l * r
;-- l + r
ADD RR, #0x0009
;;; } 33 Expr l + r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 33 Expr * r
;;; { 34 Expression (variable name)
;;; expr_type = "identifier" (which_w)
;-- load_rr_var which_w = -16(FP), SP at -30 (16 bit)
MOVE 14(SP), RR
;;; } 34 Expression (variable name)
;;; } 33 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (16 bit)
MOVE (SP)+, RR
;-- assign (16 bit)
MOVE RR, (LL)
;;; } 32 Expr l = r
;;; } 31 ExpressionStatement
;;; } 30 case Statement
;;; { 30 break/continue Statement
;-- branch
JMP L20_cont_58
;;; } 30 break/continue Statement
;;; { 30 case Statement
L20_case_60_002A:
;;; { 31 ExpressionStatement
;;; { 32 Expr l = r
;;; { 33 TypeName
;;; { 34 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 34 TypeSpecifier (all)
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = which_w
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;;; } 33 TypeName
;;; { 33 Expression (cast)r
;;; { 34 Expr * r
;;; { 35 Expr l - r
;;; { 36 Expr ++r
;;; { 37 Expression (variable name)
;;; expr_type = "identifier" (args)
;-- load_rr_var args = -2(FP), SP at -28 (16 bit)
MOVE 26(SP), RR
;;; } 37 Expression (variable name)
;-- ++
ADD RR, #0x0002
;-- store_rr_var args = -2(FP), SP at -28
MOVE RR, 26(SP)
;;; } 36 Expr ++r
;-- l - r
SUB RR, #0x0002
;;; } 35 Expr l - r
;-- content
MOVE (RR), RR
;;; } 34 Expr * r
;;; } 33 Expression (cast)r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 33 Expr * r
;;; { 34 Expression (variable name)
;;; expr_type = "identifier" (which_w)
;-- load_rr_var which_w = -16(FP), SP at -30 (16 bit)
MOVE 14(SP), RR
;;; } 34 Expression (variable name)
;;; } 33 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (16 bit)
MOVE (SP)+, RR
;-- assign (16 bit)
MOVE RR, (LL)
;;; } 32 Expr l = r
;;; } 31 ExpressionStatement
;;; } 30 case Statement
;;; { 30 break/continue Statement
;-- branch
JMP L20_cont_58
;;; } 30 break/continue Statement
;;; { 30 case Statement
L20_case_60_0000:
;;; { 31 ExpressionStatement
;;; { 32 Expr l + r
;;; { 33 Expr --r
;;; { 34 Expression (variable name)
;;; expr_type = "identifier" (format)
;-- load_rr_var format = 2(FP), SP at -28 (16 bit)
MOVE 30(SP), RR
;;; } 34 Expression (variable name)
;-- --
SUB RR, #0x0001
;-- store_rr_var format = 2(FP), SP at -28
MOVE RR, 30(SP)
;;; } 33 Expr --r
;-- l + r
ADD RR, #0x0001
;;; } 32 Expr l + r
;;; } 31 ExpressionStatement
;;; } 30 case Statement
;;; { 30 break/continue Statement
;-- branch
JMP L20_brk_60
;;; } 30 break/continue Statement
;;; { 30 case Statement
L20_deflt_60:
;;; { 31 ExpressionStatement
;;; { 32 Expr l += r
;;; { 33 TypeName
;;; { 34 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 34 TypeSpecifier (all)
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = len
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;;; } 33 TypeName
;;; { 33 Expr l + r
;;; { 34 Expr l(r)
;;; { 35 TypeName
;;; { 36 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 36 TypeSpecifier (all)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = putchr
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; { 35 ParameterDeclaration
;;; isEllipsis = false
;;; { 36 TypeName
;;; { 37 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 37 TypeSpecifier (all)
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;;; } 36 TypeName
;;; } 35 ParameterDeclaration
;;; { 35 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -5(FP), SP at -28 (8 bit)
MOVE 23(SP), RS
;;; } 35 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;-- push 2 bytes
;-- call
CALL Cputchr
;-- pop 1 bytes
ADD SP, #1
;;; } 34 Expr l(r)
;;; { 34 Expression (variable name)
;;; expr_type = "identifier" (len)
;-- load_ll_var len = -4(FP), SP at -28 (16 bit)
MOVE 24(SP), LL
;;; } 34 Expression (variable name)
;-- scale_rr *1
;-- l + r
ADD LL, RR
;;; } 33 Expr l + r
;-- store_rr_var len = -4(FP), SP at -28
MOVE RR, 24(SP)
;;; } 32 Expr l += r
;;; } 31 ExpressionStatement
;;; } 30 case Statement
;;; { 30 break/continue Statement
;-- branch
JMP L20_brk_60
;;; } 30 break/continue Statement
;;; } 29 List<case Statement>
;-- pop 0 bytes
;;; } 28 CompoundStatement
L20_brk_60:
;;; } 27 SwitchStatement
;;; { 27 break/continue Statement
;-- branch
JMP L20_brk_59
;;; } 27 break/continue Statement
;;; } 26 List<SwitchStatement>
;-- pop 0 bytes
;;; } 25 CompoundStatement
L20_cont_58:
;-- branch
JMP L20_loop_58
L20_brk_59:
;;; } 24 for Statement
;;; } 23 List<IfElseStatement>
;-- pop 0 bytes
;;; } 22 CompoundStatement
L20_cont_55:
;;; { 22 Expr l = r
;;; { 23 TypeName
;;; { 24 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 24 TypeSpecifier (all)
;;; { 24 List<DeclItem>
;;; { 25 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 25 DeclItem
;;; } 24 List<DeclItem>
;;; } 23 TypeName
;;; { 23 Expr * r
;;; { 24 Expr l - r
;;; { 25 Expr ++r
;;; { 26 Expression (variable name)
;;; expr_type = "identifier" (format)
;-- load_rr_var format = 2(FP), SP at -28 (16 bit)
MOVE 30(SP), RR
;;; } 26 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var format = 2(FP), SP at -28
MOVE RR, 30(SP)
;;; } 25 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 24 Expr l - r
;-- content
MOVE (RR), RS
;;; } 23 Expr * r
;-- store_rr_var c = -5(FP), SP at -28
MOVE R, 23(SP)
;;; } 22 Expr l = r
;-- branch_true
JMP RRNZ, L20_loop_55
L20_brk_56:
;;; } 21 while Statement
;;; { 21 return Statement
;;; { 22 Expression (variable name)
;;; expr_type = "identifier" (len)
;-- load_rr_var len = -4(FP), SP at -28 (16 bit)
MOVE 24(SP), RR
;;; } 22 Expression (variable name)
;-- ret
ADD SP, #28
RET
;;; } 21 return Statement
;;; } 20 List<while Statement>
;-- pop 28 bytes
ADD SP, #28
;;; } 19 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 19 FunctionDefinition
;;; { 20 TypeName
;;; { 21 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 21 TypeSpecifier (all)
;;; { 21 List<DeclItem>
;;; { 22 DeclItem
;;; what = DECL_NAME
;;; name = getchr
;;; } 22 DeclItem
;;; } 21 List<DeclItem>
;;; } 20 TypeName
;;; { 20 List<DeclItem>
;;; { 21 DeclItem
;;; what = DECL_NAME
;;; name = getchr
;;; } 21 DeclItem
;;; { 21 DeclItem
;;; what = DECL_FUN
;;; } 21 DeclItem
;;; } 20 List<DeclItem>
Cgetchr:
;;; { 20 CompoundStatement
;;; { 21 InitDeclarator
;;; { 22 List<DeclItem>
;;; { 23 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 23 DeclItem
;;; } 22 List<DeclItem>
;-- push_zero 1 bytes
CLRB -(SP)
;;; } 21 InitDeclarator
;;; { 21 List<ExpressionStatement>
;;; { 22 ExpressionStatement
;;; { 23 Expr l(r)
;;; { 24 TypeName
;;; { 25 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 25 TypeSpecifier (all)
;;; { 25 List<DeclItem>
;;; { 26 DeclItem
;;; what = DECL_NAME
;;; name = P
;;; } 26 DeclItem
;;; } 25 List<DeclItem>
;;; } 24 TypeName
;;; { 24 ParameterDeclaration
;;; isEllipsis = false
;;; { 25 TypeName
;;; { 26 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 26 TypeSpecifier (struct/union)
;;; { 26 List<DeclItem>
;;; { 27 DeclItem
;;; what = DECL_POINTER
;;; { 28 List<Ptr>
;;; { 29 Ptr
;;; } 29 Ptr
;;; } 28 List<Ptr>
;;; } 27 DeclItem
;;; { 27 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 27 DeclItem
;;; } 26 List<DeclItem>
;;; } 25 TypeName
;;; } 24 ParameterDeclaration
;;; { 24 Expr & r
;-- load_address rx_sema
MOVE #Crx_sema, RR
;;; } 24 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CP
;-- pop 2 bytes
ADD SP, #2
;;; } 23 Expr l(r)
;;; } 22 ExpressionStatement
;;; { 22 ExpressionStatement
;;; { 23 Expr l = r
;;; { 24 TypeName
;;; { 25 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 25 TypeSpecifier (all)
;;; { 25 List<DeclItem>
;;; { 26 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 26 DeclItem
;;; } 25 List<DeclItem>
;;; } 24 TypeName
;;; { 24 Expr l[r]
;;; { 25 TypeName
;;; { 26 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 26 TypeSpecifier (all)
;;; { 26 List<DeclItem>
;;; { 27 DeclItem
;;; what = DECL_NAME
;;; name = serial_in_buffer
;;; } 27 DeclItem
;;; } 26 List<DeclItem>
;;; } 25 TypeName
;;; { 25 Expr l[r]
;;; { 26 Expression (variable name)
;;; expr_type = "identifier" (serial_in_get)
;-- load_rr_var serial_in_get, (8 bit)
MOVE (Cserial_in_get), RU
;;; } 26 Expression (variable name)
;-- scale_rr *1
;-- add_address serial_in_buffer
ADD RR, #Cserial_in_buffer
;;; } 25 Expr l[r]
;-- content
MOVE (RR), RU
;;; } 24 Expr l[r]
;-- store_rr_var c = -1(FP), SP at -1
MOVE R, 0(SP)
;;; } 23 Expr l = r
;;; } 22 ExpressionStatement
;;; { 22 IfElseStatement
;;; { 23 Expr l >= r
;;; { 24 TypeName (internal)
;;; { 25 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 25 TypeSpecifier (all)
;;; } 24 TypeName (internal)
;;; { 24 Expr ++r
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (serial_in_get)
;-- load_rr_var serial_in_get, (8 bit)
MOVE (Cserial_in_get), RU
;;; } 25 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var serial_in_get
MOVE R, (Cserial_in_get)
;;; } 24 Expr ++r
;-- l >= r
SHS RR, #0x0010
;;; } 23 Expr l >= r
;-- branch_false
JMP RRZ, L21_endif_64
;;; { 23 ExpressionStatement
;;; { 24 Expr l = r
;;; { 25 TypeName
;;; { 26 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 26 TypeSpecifier (all)
;;; { 26 List<DeclItem>
;;; { 27 DeclItem
;;; what = DECL_NAME
;;; name = serial_in_get
;;; } 27 DeclItem
;;; } 26 List<DeclItem>
;;; } 25 TypeName
;;; { 25 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 25 NumericExpression (constant 0 = 0x0)
;-- store_rr_var serial_in_get
MOVE R, (Cserial_in_get)
;;; } 24 Expr l = r
;;; } 23 ExpressionStatement
L21_endif_64:
;;; } 22 IfElseStatement
;;; { 22 return Statement
;;; { 23 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -1(FP), SP at -1 (8 bit)
MOVE 0(SP), RS
;;; } 23 Expression (variable name)
;-- ret
ADD SP, #1
RET
;;; } 22 return Statement
;;; } 21 List<ExpressionStatement>
;-- pop 1 bytes
ADD SP, #1
;;; } 20 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 20 FunctionDefinition
;;; { 21 TypeName
;;; { 22 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 22 TypeSpecifier (all)
;;; { 22 List<DeclItem>
;;; { 23 DeclItem
;;; what = DECL_NAME
;;; name = getchr_timed
;;; } 23 DeclItem
;;; } 22 List<DeclItem>
;;; } 21 TypeName
;;; { 21 List<DeclItem>
;;; { 22 DeclItem
;;; what = DECL_NAME
;;; name = getchr_timed
;;; } 22 DeclItem
;;; { 22 DeclItem
;;; what = DECL_FUN
;;; { 23 List<ParameterDeclaration>
;;; { 24 ParameterDeclaration
;;; isEllipsis = false
;;; { 25 TypeName
;;; { 26 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 26 TypeSpecifier (all)
;;; { 26 List<DeclItem>
;;; { 27 DeclItem
;;; what = DECL_NAME
;;; name = ticks
;;; } 27 DeclItem
;;; } 26 List<DeclItem>
;;; } 25 TypeName
;;; } 24 ParameterDeclaration
;;; } 23 List<ParameterDeclaration>
;;; } 22 DeclItem
;;; } 21 List<DeclItem>
Cgetchr_timed:
;;; { 21 CompoundStatement
;;; { 22 InitDeclarator
;;; { 23 List<DeclItem>
;;; { 24 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 24 DeclItem
;;; } 23 List<DeclItem>
;-- push_zero 1 bytes
CLRB -(SP)
;;; } 22 InitDeclarator
;;; { 22 List<ExpressionStatement>
;;; { 23 ExpressionStatement
;;; { 24 Expr l = r
;;; { 25 TypeName
;;; { 26 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 26 TypeSpecifier (all)
;;; { 26 List<DeclItem>
;;; { 27 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 27 DeclItem
;;; } 26 List<DeclItem>
;;; } 25 TypeName
;;; { 25 Expr l(r)
;;; { 26 TypeName
;;; { 27 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 27 TypeSpecifier (all)
;;; { 27 List<DeclItem>
;;; { 28 DeclItem
;;; what = DECL_NAME
;;; name = P_timed
;;; } 28 DeclItem
;;; } 27 List<DeclItem>
;;; } 26 TypeName
;;; { 26 Expr (l , r)
;;; { 27 ParameterDeclaration
;;; isEllipsis = false
;;; { 28 TypeName
;;; { 29 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 29 TypeSpecifier (all)
;;; { 29 List<DeclItem>
;;; { 30 DeclItem
;;; what = DECL_NAME
;;; name = ticks
;;; } 30 DeclItem
;;; } 29 List<DeclItem>
;;; } 28 TypeName
;;; } 27 ParameterDeclaration
;;; { 27 Expression (variable name)
;;; expr_type = "identifier" (ticks)
;-- load_rr_var ticks = 2(FP), SP at -1 (16 bit)
MOVE 3(SP), RR
;;; } 27 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 27 ParameterDeclaration
;;; isEllipsis = false
;;; { 28 TypeName
;;; { 29 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 29 TypeSpecifier (struct/union)
;;; { 29 List<DeclItem>
;;; { 30 DeclItem
;;; what = DECL_POINTER
;;; { 31 List<Ptr>
;;; { 32 Ptr
;;; } 32 Ptr
;;; } 31 List<Ptr>
;;; } 30 DeclItem
;;; { 30 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 30 DeclItem
;;; } 29 List<DeclItem>
;;; } 28 TypeName
;;; } 27 ParameterDeclaration
;;; { 27 Expr & r
;-- load_address rx_sema
MOVE #Crx_sema, RR
;;; } 27 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 26 Expr (l , r)
;-- push 1 bytes
;-- call
CALL CP_timed
;-- pop 4 bytes
ADD SP, #4
;;; } 25 Expr l(r)
;-- store_rr_var c = -1(FP), SP at -1
MOVE R, 0(SP)
;;; } 24 Expr l = r
;;; } 23 ExpressionStatement
;;; { 23 IfElseStatement
;;; { 24 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -1(FP), SP at -1 (8 bit)
MOVE 0(SP), RS
;;; } 24 Expression (variable name)
;-- branch_false
JMP RRZ, L22_endif_65
;;; { 24 return Statement
;;; { 25 NumericExpression (constant 1 = 0x1)
;-- load_rr_constant
MOVE #0xFFFF, RR
;;; } 25 NumericExpression (constant 1 = 0x1)
;-- ret
ADD SP, #1
RET
;;; } 24 return Statement
L22_endif_65:
;;; } 23 IfElseStatement
;;; { 23 ExpressionStatement
;;; { 24 Expr l = r
;;; { 25 TypeName
;;; { 26 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 26 TypeSpecifier (all)
;;; { 26 List<DeclItem>
;;; { 27 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 27 DeclItem
;;; } 26 List<DeclItem>
;;; } 25 TypeName
;;; { 25 Expr l[r]
;;; { 26 TypeName
;;; { 27 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 27 TypeSpecifier (all)
;;; { 27 List<DeclItem>
;;; { 28 DeclItem
;;; what = DECL_NAME
;;; name = serial_in_buffer
;;; } 28 DeclItem
;;; } 27 List<DeclItem>
;;; } 26 TypeName
;;; { 26 Expr l[r]
;;; { 27 Expression (variable name)
;;; expr_type = "identifier" (serial_in_get)
;-- load_rr_var serial_in_get, (8 bit)
MOVE (Cserial_in_get), RU
;;; } 27 Expression (variable name)
;-- scale_rr *1
;-- add_address serial_in_buffer
ADD RR, #Cserial_in_buffer
;;; } 26 Expr l[r]
;-- content
MOVE (RR), RU
;;; } 25 Expr l[r]
;-- store_rr_var c = -1(FP), SP at -1
MOVE R, 0(SP)
;;; } 24 Expr l = r
;;; } 23 ExpressionStatement
;;; { 23 IfElseStatement
;;; { 24 Expr l >= r
;;; { 25 TypeName (internal)
;;; { 26 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 26 TypeSpecifier (all)
;;; } 25 TypeName (internal)
;;; { 25 Expr ++r
;;; { 26 Expression (variable name)
;;; expr_type = "identifier" (serial_in_get)
;-- load_rr_var serial_in_get, (8 bit)
MOVE (Cserial_in_get), RU
;;; } 26 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var serial_in_get
MOVE R, (Cserial_in_get)
;;; } 25 Expr ++r
;-- l >= r
SHS RR, #0x0010
;;; } 24 Expr l >= r
;-- branch_false
JMP RRZ, L22_endif_66
;;; { 24 ExpressionStatement
;;; { 25 Expr l = r
;;; { 26 TypeName
;;; { 27 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 27 TypeSpecifier (all)
;;; { 27 List<DeclItem>
;;; { 28 DeclItem
;;; what = DECL_NAME
;;; name = serial_in_get
;;; } 28 DeclItem
;;; } 27 List<DeclItem>
;;; } 26 TypeName
;;; { 26 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 26 NumericExpression (constant 0 = 0x0)
;-- store_rr_var serial_in_get
MOVE R, (Cserial_in_get)
;;; } 25 Expr l = r
;;; } 24 ExpressionStatement
L22_endif_66:
;;; } 23 IfElseStatement
;;; { 23 return Statement
;;; { 24 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -1(FP), SP at -1 (8 bit)
MOVE 0(SP), RS
;;; } 24 Expression (variable name)
;-- ret
ADD SP, #1
RET
;;; } 23 return Statement
;;; } 22 List<ExpressionStatement>
;-- pop 1 bytes
ADD SP, #1
;;; } 21 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 21 FunctionDefinition
;;; { 22 TypeName
;;; { 23 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 23 TypeSpecifier (all)
;;; { 23 List<DeclItem>
;;; { 24 DeclItem
;;; what = DECL_NAME
;;; name = peekchr
;;; } 24 DeclItem
;;; } 23 List<DeclItem>
;;; } 22 TypeName
;;; { 22 List<DeclItem>
;;; { 23 DeclItem
;;; what = DECL_NAME
;;; name = peekchr
;;; } 23 DeclItem
;;; { 23 DeclItem
;;; what = DECL_FUN
;;; } 23 DeclItem
;;; } 22 List<DeclItem>
Cpeekchr:
;;; { 22 CompoundStatement
;;; { 23 InitDeclarator
;;; { 24 List<DeclItem>
;;; { 25 DeclItem
;;; what = DECL_NAME
;;; name = ret
;;; } 25 DeclItem
;;; } 24 List<DeclItem>
;-- push_zero 1 bytes
CLRB -(SP)
;;; } 23 InitDeclarator
;;; { 23 List<ExpressionStatement>
;;; { 24 ExpressionStatement
;;; { 25 Expr l(r)
;;; { 26 TypeName
;;; { 27 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 27 TypeSpecifier (all)
;;; { 27 List<DeclItem>
;;; { 28 DeclItem
;;; what = DECL_NAME
;;; name = P
;;; } 28 DeclItem
;;; } 27 List<DeclItem>
;;; } 26 TypeName
;;; { 26 ParameterDeclaration
;;; isEllipsis = false
;;; { 27 TypeName
;;; { 28 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 28 TypeSpecifier (struct/union)
;;; { 28 List<DeclItem>
;;; { 29 DeclItem
;;; what = DECL_POINTER
;;; { 30 List<Ptr>
;;; { 31 Ptr
;;; } 31 Ptr
;;; } 30 List<Ptr>
;;; } 29 DeclItem
;;; { 29 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 29 DeclItem
;;; } 28 List<DeclItem>
;;; } 27 TypeName
;;; } 26 ParameterDeclaration
;;; { 26 Expr & r
;-- load_address rx_sema
MOVE #Crx_sema, RR
;;; } 26 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CP
;-- pop 2 bytes
ADD SP, #2
;;; } 25 Expr l(r)
;;; } 24 ExpressionStatement
;;; { 24 ExpressionStatement
;;; { 25 Expr l = r
;;; { 26 TypeName
;;; { 27 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 27 TypeSpecifier (all)
;;; { 27 List<DeclItem>
;;; { 28 DeclItem
;;; what = DECL_NAME
;;; name = ret
;;; } 28 DeclItem
;;; } 27 List<DeclItem>
;;; } 26 TypeName
;;; { 26 Expr l[r]
;;; { 27 TypeName
;;; { 28 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 28 TypeSpecifier (all)
;;; { 28 List<DeclItem>
;;; { 29 DeclItem
;;; what = DECL_NAME
;;; name = serial_in_buffer
;;; } 29 DeclItem
;;; } 28 List<DeclItem>
;;; } 27 TypeName
;;; { 27 Expr l[r]
;;; { 28 Expression (variable name)
;;; expr_type = "identifier" (serial_in_get)
;-- load_rr_var serial_in_get, (8 bit)
MOVE (Cserial_in_get), RU
;;; } 28 Expression (variable name)
;-- scale_rr *1
;-- add_address serial_in_buffer
ADD RR, #Cserial_in_buffer
;;; } 27 Expr l[r]
;-- content
MOVE (RR), RU
;;; } 26 Expr l[r]
;-- store_rr_var ret = -1(FP), SP at -1
MOVE R, 0(SP)
;;; } 25 Expr l = r
;;; } 24 ExpressionStatement
;;; { 24 ExpressionStatement
;;; { 25 Expr l(r)
;;; { 26 TypeName
;;; { 27 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 27 TypeSpecifier (all)
;;; { 27 List<DeclItem>
;;; { 28 DeclItem
;;; what = DECL_NAME
;;; name = V
;;; } 28 DeclItem
;;; } 27 List<DeclItem>
;;; } 26 TypeName
;;; { 26 ParameterDeclaration
;;; isEllipsis = false
;;; { 27 TypeName
;;; { 28 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 28 TypeSpecifier (struct/union)
;;; { 28 List<DeclItem>
;;; { 29 DeclItem
;;; what = DECL_POINTER
;;; { 30 List<Ptr>
;;; { 31 Ptr
;;; } 31 Ptr
;;; } 30 List<Ptr>
;;; } 29 DeclItem
;;; { 29 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 29 DeclItem
;;; } 28 List<DeclItem>
;;; } 27 TypeName
;;; } 26 ParameterDeclaration
;;; { 26 Expr & r
;-- load_address rx_sema
MOVE #Crx_sema, RR
;;; } 26 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CV
;-- pop 2 bytes
ADD SP, #2
;;; } 25 Expr l(r)
;;; } 24 ExpressionStatement
;;; { 24 return Statement
;;; { 25 Expression (variable name)
;;; expr_type = "identifier" (ret)
;-- load_rr_var ret = -1(FP), SP at -1 (8 bit)
MOVE 0(SP), RS
;;; } 25 Expression (variable name)
;-- ret
ADD SP, #1
RET
;;; } 24 return Statement
;;; } 23 List<ExpressionStatement>
;-- pop 1 bytes
ADD SP, #1
;;; } 22 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 22 FunctionDefinition
;;; { 23 TypeName
;;; { 24 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 24 TypeSpecifier (all)
;;; { 24 List<DeclItem>
;;; { 25 DeclItem
;;; what = DECL_NAME
;;; name = getnibble
;;; } 25 DeclItem
;;; } 24 List<DeclItem>
;;; } 23 TypeName
;;; { 23 List<DeclItem>
;;; { 24 DeclItem
;;; what = DECL_NAME
;;; name = getnibble
;;; } 24 DeclItem
;;; { 24 DeclItem
;;; what = DECL_FUN
;;; { 25 List<ParameterDeclaration>
;;; { 26 ParameterDeclaration
;;; isEllipsis = false
;;; { 27 TypeName
;;; { 28 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 28 TypeSpecifier (all)
;;; { 28 List<DeclItem>
;;; { 29 DeclItem
;;; what = DECL_NAME
;;; name = echo
;;; } 29 DeclItem
;;; } 28 List<DeclItem>
;;; } 27 TypeName
;;; } 26 ParameterDeclaration
;;; } 25 List<ParameterDeclaration>
;;; } 24 DeclItem
;;; } 23 List<DeclItem>
Cgetnibble:
;;; { 23 CompoundStatement
;;; { 24 InitDeclarator
;;; { 25 List<DeclItem>
;;; { 26 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 26 DeclItem
;;; } 25 List<DeclItem>
;;; { 25 Initializer (skalar)
;;; { 26 Expr l(r)
;;; { 27 TypeName
;;; { 28 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 28 TypeSpecifier (all)
;;; { 28 List<DeclItem>
;;; { 29 DeclItem
;;; what = DECL_NAME
;;; name = peekchr
;;; } 29 DeclItem
;;; } 28 List<DeclItem>
;;; } 27 TypeName
;-- push 1 bytes
;-- call
CALL Cpeekchr
;-- pop 0 bytes
;;; } 26 Expr l(r)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; } 25 Initializer (skalar)
;;; } 24 InitDeclarator
;;; { 24 InitDeclarator
;;; { 25 List<DeclItem>
;;; { 26 DeclItem
;;; what = DECL_NAME
;;; name = ret
;;; } 26 DeclItem
;;; } 25 List<DeclItem>
;;; { 25 Initializer (skalar)
;;; { 26 NumericExpression (constant 1 = 0x1)
;-- load_rr_constant
MOVE #0xFFFF, RR
;;; } 26 NumericExpression (constant 1 = 0x1)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 25 Initializer (skalar)
;;; } 24 InitDeclarator
;;; { 24 List<IfElseStatement>
;;; { 25 IfElseStatement
;;; { 26 Expr l && r
;;; { 27 TypeName (internal)
;;; { 28 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 28 TypeSpecifier (all)
;;; } 27 TypeName (internal)
;;; { 27 IfElseStatement
;;; { 28 Expr l >= r
;;; { 29 TypeName (internal)
;;; { 30 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 30 TypeSpecifier (all)
;;; } 29 TypeName (internal)
;;; { 29 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -1(FP), SP at -3 (8 bit)
MOVE 2(SP), RS
;;; } 29 Expression (variable name)
;-- l >= r
SGE RR, #0x0030
;;; } 28 Expr l >= r
;-- branch_false
JMP RRZ, L24_endif_68
;;; { 28 ExpressionStatement
;;; { 29 Expr l <= r
;;; { 30 TypeName (internal)
;;; { 31 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 31 TypeSpecifier (all)
;;; } 30 TypeName (internal)
;;; { 30 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -1(FP), SP at -3 (8 bit)
MOVE 2(SP), RS
;;; } 30 Expression (variable name)
;-- l <= r
SLE RR, #0x0039
;;; } 29 Expr l <= r
;;; } 28 ExpressionStatement
L24_endif_68:
;;; } 27 IfElseStatement
;;; } 26 Expr l && r
;-- branch_false
JMP RRZ, L24_else_67
;;; { 26 ExpressionStatement
;;; { 27 Expr l = r
;;; { 28 TypeName
;;; { 29 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 29 TypeSpecifier (all)
;;; { 29 List<DeclItem>
;;; { 30 DeclItem
;;; what = DECL_NAME
;;; name = ret
;;; } 30 DeclItem
;;; } 29 List<DeclItem>
;;; } 28 TypeName
;;; { 28 Expr l - r
;;; { 29 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -1(FP), SP at -3 (8 bit)
MOVE 2(SP), RS
;;; } 29 Expression (variable name)
;-- l - r
SUB RR, #0x0030
;;; } 28 Expr l - r
;-- store_rr_var ret = -3(FP), SP at -3
MOVE RR, 0(SP)
;;; } 27 Expr l = r
;;; } 26 ExpressionStatement
;-- branch
JMP L24_endif_67
L24_else_67:
;;; { 26 IfElseStatement
;;; { 27 Expr l && r
;;; { 28 TypeName (internal)
;;; { 29 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 29 TypeSpecifier (all)
;;; } 28 TypeName (internal)
;;; { 28 IfElseStatement
;;; { 29 Expr l >= r
;;; { 30 TypeName (internal)
;;; { 31 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 31 TypeSpecifier (all)
;;; } 30 TypeName (internal)
;;; { 30 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -1(FP), SP at -3 (8 bit)
MOVE 2(SP), RS
;;; } 30 Expression (variable name)
;-- l >= r
SGE RR, #0x0041
;;; } 29 Expr l >= r
;-- branch_false
JMP RRZ, L24_endif_70
;;; { 29 ExpressionStatement
;;; { 30 Expr l <= r
;;; { 31 TypeName (internal)
;;; { 32 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 32 TypeSpecifier (all)
;;; } 31 TypeName (internal)
;;; { 31 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -1(FP), SP at -3 (8 bit)
MOVE 2(SP), RS
;;; } 31 Expression (variable name)
;-- l <= r
SLE RR, #0x0046
;;; } 30 Expr l <= r
;;; } 29 ExpressionStatement
L24_endif_70:
;;; } 28 IfElseStatement
;;; } 27 Expr l && r
;-- branch_false
JMP RRZ, L24_else_69
;;; { 27 ExpressionStatement
;;; { 28 Expr l = r
;;; { 29 TypeName
;;; { 30 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 30 TypeSpecifier (all)
;;; { 30 List<DeclItem>
;;; { 31 DeclItem
;;; what = DECL_NAME
;;; name = ret
;;; } 31 DeclItem
;;; } 30 List<DeclItem>
;;; } 29 TypeName
;;; { 29 Expr l - r
;;; { 30 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -1(FP), SP at -3 (8 bit)
MOVE 2(SP), RS
;;; } 30 Expression (variable name)
;-- l - r
SUB RR, #0x0037
;;; } 29 Expr l - r
;-- store_rr_var ret = -3(FP), SP at -3
MOVE RR, 0(SP)
;;; } 28 Expr l = r
;;; } 27 ExpressionStatement
;-- branch
JMP L24_endif_69
L24_else_69:
;;; { 27 IfElseStatement
;;; { 28 Expr l && r
;;; { 29 TypeName (internal)
;;; { 30 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 30 TypeSpecifier (all)
;;; } 29 TypeName (internal)
;;; { 29 IfElseStatement
;;; { 30 Expr l >= r
;;; { 31 TypeName (internal)
;;; { 32 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 32 TypeSpecifier (all)
;;; } 31 TypeName (internal)
;;; { 31 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -1(FP), SP at -3 (8 bit)
MOVE 2(SP), RS
;;; } 31 Expression (variable name)
;-- l >= r
SGE RR, #0x0061
;;; } 30 Expr l >= r
;-- branch_false
JMP RRZ, L24_endif_72
;;; { 30 ExpressionStatement
;;; { 31 Expr l <= r
;;; { 32 TypeName (internal)
;;; { 33 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 33 TypeSpecifier (all)
;;; } 32 TypeName (internal)
;;; { 32 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -1(FP), SP at -3 (8 bit)
MOVE 2(SP), RS
;;; } 32 Expression (variable name)
;-- l <= r
SLE RR, #0x0066
;;; } 31 Expr l <= r
;;; } 30 ExpressionStatement
L24_endif_72:
;;; } 29 IfElseStatement
;;; } 28 Expr l && r
;-- branch_false
JMP RRZ, L24_endif_71
;;; { 28 ExpressionStatement
;;; { 29 Expr l = r
;;; { 30 TypeName
;;; { 31 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 31 TypeSpecifier (all)
;;; { 31 List<DeclItem>
;;; { 32 DeclItem
;;; what = DECL_NAME
;;; name = ret
;;; } 32 DeclItem
;;; } 31 List<DeclItem>
;;; } 30 TypeName
;;; { 30 Expr l - r
;;; { 31 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -1(FP), SP at -3 (8 bit)
MOVE 2(SP), RS
;;; } 31 Expression (variable name)
;-- l - r
SUB RR, #0x0057
;;; } 30 Expr l - r
;-- store_rr_var ret = -3(FP), SP at -3
MOVE RR, 0(SP)
;;; } 29 Expr l = r
;;; } 28 ExpressionStatement
L24_endif_71:
;;; } 27 IfElseStatement
L24_endif_69:
;;; } 26 IfElseStatement
L24_endif_67:
;;; } 25 IfElseStatement
;;; { 25 IfElseStatement
;;; { 26 Expr l != r
;;; { 27 TypeName (internal)
;;; { 28 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 28 TypeSpecifier (all)
;;; } 27 TypeName (internal)
;;; { 27 Expression (variable name)
;;; expr_type = "identifier" (ret)
;-- load_rr_var ret = -3(FP), SP at -3 (16 bit)
MOVE 0(SP), RR
;;; } 27 Expression (variable name)
;-- l != r
SNE RR, #0xFFFF
;;; } 26 Expr l != r
;-- branch_false
JMP RRZ, L24_endif_73
;;; { 26 CompoundStatement
;;; { 27 List<ExpressionStatement>
;;; { 28 ExpressionStatement
;;; { 29 Expr l(r)
;;; { 30 TypeName
;;; { 31 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 31 TypeSpecifier (all)
;;; { 31 List<DeclItem>
;;; { 32 DeclItem
;;; what = DECL_NAME
;;; name = getchr
;;; } 32 DeclItem
;;; } 31 List<DeclItem>
;;; } 30 TypeName
;-- push 2 bytes
;-- call
CALL Cgetchr
;-- pop 0 bytes
;;; } 29 Expr l(r)
;;; } 28 ExpressionStatement
;;; { 28 IfElseStatement
;;; { 29 Expression (variable name)
;;; expr_type = "identifier" (echo)
;-- load_rr_var echo = 2(FP), SP at -3 (8 bit)
MOVE 5(SP), RS
;;; } 29 Expression (variable name)
;-- branch_false
JMP RRZ, L24_endif_74
;;; { 29 ExpressionStatement
;;; { 30 Expr l(r)
;;; { 31 TypeName
;;; { 32 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 32 TypeSpecifier (all)
;;; { 32 List<DeclItem>
;;; { 33 DeclItem
;;; what = DECL_NAME
;;; name = putchr
;;; } 33 DeclItem
;;; } 32 List<DeclItem>
;;; } 31 TypeName
;;; { 31 ParameterDeclaration
;;; isEllipsis = false
;;; { 32 TypeName
;;; { 33 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 33 TypeSpecifier (all)
;;; { 33 List<DeclItem>
;;; { 34 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 34 DeclItem
;;; } 33 List<DeclItem>
;;; } 32 TypeName
;;; } 31 ParameterDeclaration
;;; { 31 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -1(FP), SP at -3 (8 bit)
MOVE 2(SP), RS
;;; } 31 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;-- push 2 bytes
;-- call
CALL Cputchr
;-- pop 1 bytes
ADD SP, #1
;;; } 30 Expr l(r)
;;; } 29 ExpressionStatement
L24_endif_74:
;;; } 28 IfElseStatement
;;; } 27 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 26 CompoundStatement
L24_endif_73:
;;; } 25 IfElseStatement
;;; { 25 return Statement
;;; { 26 Expression (variable name)
;;; expr_type = "identifier" (ret)
;-- load_rr_var ret = -3(FP), SP at -3 (16 bit)
MOVE 0(SP), RR
;;; } 26 Expression (variable name)
;-- ret
ADD SP, #3
RET
;;; } 25 return Statement
;;; } 24 List<IfElseStatement>
;-- pop 3 bytes
ADD SP, #3
;;; } 23 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 23 FunctionDefinition
;;; { 24 TypeName
;;; { 25 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 25 TypeSpecifier (all)
;;; { 25 List<DeclItem>
;;; { 26 DeclItem
;;; what = DECL_NAME
;;; name = gethex
;;; } 26 DeclItem
;;; } 25 List<DeclItem>
;;; } 24 TypeName
;;; { 24 List<DeclItem>
;;; { 25 DeclItem
;;; what = DECL_NAME
;;; name = gethex
;;; } 25 DeclItem
;;; { 25 DeclItem
;;; what = DECL_FUN
;;; { 26 List<ParameterDeclaration>
;;; { 27 ParameterDeclaration
;;; isEllipsis = false
;;; { 28 TypeName
;;; { 29 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 29 TypeSpecifier (all)
;;; { 29 List<DeclItem>
;;; { 30 DeclItem
;;; what = DECL_NAME
;;; name = echo
;;; } 30 DeclItem
;;; } 29 List<DeclItem>
;;; } 28 TypeName
;;; } 27 ParameterDeclaration
;;; } 26 List<ParameterDeclaration>
;;; } 25 DeclItem
;;; } 24 List<DeclItem>
Cgethex:
;;; { 24 CompoundStatement
;;; { 25 InitDeclarator
;;; { 26 List<DeclItem>
;;; { 27 DeclItem
;;; what = DECL_NAME
;;; name = ret
;;; } 27 DeclItem
;;; } 26 List<DeclItem>
;;; { 26 Initializer (skalar)
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 26 Initializer (skalar)
;;; } 25 InitDeclarator
;;; { 25 InitDeclarator
;;; { 26 List<DeclItem>
;;; { 27 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 27 DeclItem
;;; } 26 List<DeclItem>
;-- push_zero 1 bytes
CLRB -(SP)
;;; } 25 InitDeclarator
;;; { 25 List<while Statement>
;;; { 26 while Statement
;-- branch
JMP L25_cont_75
L25_loop_75:
;;; { 27 ExpressionStatement
;;; { 28 Expr l = r
;;; { 29 TypeName
;;; { 30 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 30 TypeSpecifier (all)
;;; { 30 List<DeclItem>
;;; { 31 DeclItem
;;; what = DECL_NAME
;;; name = ret
;;; } 31 DeclItem
;;; } 30 List<DeclItem>
;;; } 29 TypeName
;;; { 29 Expr l | r
;;; { 30 TypeName (internal)
;;; { 31 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 31 TypeSpecifier (all)
;;; } 30 TypeName (internal)
;;; { 30 Expr l << r
;;; { 31 TypeName (internal)
;;; { 32 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 32 TypeSpecifier (all)
;;; } 31 TypeName (internal)
;;; { 31 Expression (variable name)
;;; expr_type = "identifier" (ret)
;-- load_rr_var ret = -2(FP), SP at -3 (16 bit)
MOVE 1(SP), RR
;;; } 31 Expression (variable name)
;-- l << r
LSL RR, #0x0004
;;; } 30 Expr l << r
;-- move_rr_to_ll
MOVE RR, LL
;;; { 30 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -3(FP), SP at -3 (8 bit)
MOVE 0(SP), RS
;;; } 30 Expression (variable name)
;-- l | r
OR LL, RR
;;; } 29 Expr l | r
;-- store_rr_var ret = -2(FP), SP at -3
MOVE RR, 1(SP)
;;; } 28 Expr l = r
;;; } 27 ExpressionStatement
L25_cont_75:
;;; { 27 Expr l != r
;;; { 28 TypeName (internal)
;;; { 29 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 29 TypeSpecifier (all)
;;; } 28 TypeName (internal)
;;; { 28 Expr l = r
;;; { 29 TypeName
;;; { 30 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 30 TypeSpecifier (all)
;;; { 30 List<DeclItem>
;;; { 31 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 31 DeclItem
;;; } 30 List<DeclItem>
;;; } 29 TypeName
;;; { 29 Expr l(r)
;;; { 30 TypeName
;;; { 31 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 31 TypeSpecifier (all)
;;; { 31 List<DeclItem>
;;; { 32 DeclItem
;;; what = DECL_NAME
;;; name = getnibble
;;; } 32 DeclItem
;;; } 31 List<DeclItem>
;;; } 30 TypeName
;;; { 30 ParameterDeclaration
;;; isEllipsis = false
;;; { 31 TypeName
;;; { 32 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 32 TypeSpecifier (all)
;;; { 32 List<DeclItem>
;;; { 33 DeclItem
;;; what = DECL_NAME
;;; name = echo
;;; } 33 DeclItem
;;; } 32 List<DeclItem>
;;; } 31 TypeName
;;; } 30 ParameterDeclaration
;;; { 30 Expression (variable name)
;;; expr_type = "identifier" (echo)
;-- load_rr_var echo = 2(FP), SP at -3 (8 bit)
MOVE 5(SP), RS
;;; } 30 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;-- push 1 bytes
;-- call
CALL Cgetnibble
;-- pop 1 bytes
ADD SP, #1
;;; } 29 Expr l(r)
;-- store_rr_var c = -3(FP), SP at -3
MOVE R, 0(SP)
;;; } 28 Expr l = r
;-- l != r
SNE RR, #0xFFFF
;;; } 27 Expr l != r
;-- branch_true
JMP RRNZ, L25_loop_75
L25_brk_76:
;;; } 26 while Statement
;;; { 26 return Statement
;;; { 27 Expression (variable name)
;;; expr_type = "identifier" (ret)
;-- load_rr_var ret = -2(FP), SP at -3 (16 bit)
MOVE 1(SP), RR
;;; } 27 Expression (variable name)
;-- ret
ADD SP, #3
RET
;;; } 26 return Statement
;;; } 25 List<while Statement>
;-- pop 3 bytes
ADD SP, #3
;;; } 24 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 24 FunctionDefinition
;;; { 25 TypeName
;;; { 26 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 26 TypeSpecifier (all)
;;; { 26 List<DeclItem>
;;; { 27 DeclItem
;;; what = DECL_NAME
;;; name = init_stack
;;; } 27 DeclItem
;;; } 26 List<DeclItem>
;;; } 25 TypeName
;;; { 25 List<DeclItem>
;;; { 26 DeclItem
;;; what = DECL_NAME
;;; name = init_stack
;;; } 26 DeclItem
;;; { 26 DeclItem
;;; what = DECL_FUN
;;; } 26 DeclItem
;;; } 25 List<DeclItem>
Cinit_stack:
;;; { 25 CompoundStatement
;;; { 26 InitDeclarator
;;; { 27 List<DeclItem>
;;; { 28 DeclItem
;;; what = DECL_POINTER
;;; { 29 List<Ptr>
;;; { 30 Ptr
;;; } 30 Ptr
;;; } 29 List<Ptr>
;;; } 28 DeclItem
;;; { 28 DeclItem
;;; what = DECL_NAME
;;; name = bottom
;;; } 28 DeclItem
;;; } 27 List<DeclItem>
;;; { 27 Initializer (skalar)
;;; { 28 Expr * r
;;; { 29 Expression (variable name)
;;; expr_type = "identifier" (current_task)
;-- load_rr_var current_task, (16 bit)
MOVE (Ccurrent_task), RR
;;; } 29 Expression (variable name)
;;; } 28 Expr * r
;-- + (member)
ADD RR, #0x0008
;-- content
MOVE (RR), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 27 Initializer (skalar)
;;; } 26 InitDeclarator
;;; { 26 List<while Statement>
;;; { 27 while Statement
;-- branch
JMP L26_cont_77
L26_loop_77:
;;; { 28 ExpressionStatement
;;; { 29 Expr l = r
;;; { 30 TypeName
;;; { 31 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 31 TypeSpecifier (all)
;;; { 31 List<DeclItem>
;;; { 32 DeclItem
;;; what = DECL_NAME
;;; name = bottom
;;; } 32 DeclItem
;;; } 31 List<DeclItem>
;;; } 30 TypeName
;;; { 30 NumericExpression (constant 83 = 0x53)
;-- load_rr_constant
MOVE #0x0053, RR
;;; } 30 NumericExpression (constant 83 = 0x53)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 30 Expr * r
;;; { 31 Expr l - r
;;; { 32 Expr ++r
;;; { 33 Expression (variable name)
;;; expr_type = "identifier" (bottom)
;-- load_rr_var bottom = -2(FP), SP at -3 (16 bit)
MOVE 1(SP), RR
;;; } 33 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var bottom = -2(FP), SP at -3
MOVE RR, 1(SP)
;;; } 32 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 31 Expr l - r
;;; } 30 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (8 bit)
MOVE (SP)+, RS
;-- assign (8 bit)
MOVE R, (LL)
;;; } 29 Expr l = r
;;; } 28 ExpressionStatement
L26_cont_77:
;;; { 28 Expr l < r
;;; { 29 TypeName
;;; { 30 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 30 TypeSpecifier (all)
;;; { 30 List<DeclItem>
;;; { 31 DeclItem
;;; what = DECL_POINTER
;;; { 32 List<Ptr>
;;; { 33 Ptr
;;; } 33 Ptr
;;; } 32 List<Ptr>
;;; } 31 DeclItem
;;; { 31 DeclItem
;;; what = DECL_NAME
;;; name = bottom
;;; } 31 DeclItem
;;; } 30 List<DeclItem>
;;; } 29 TypeName
;;; { 29 Expression (cast)r
LEA 0(SP), RR
;;; } 29 Expression (cast)r
;;; { 29 Expression (variable name)
;;; expr_type = "identifier" (bottom)
;-- load_ll_var bottom = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), LL
;;; } 29 Expression (variable name)
;-- l < r
SLO LL, RR
;;; } 28 Expr l < r
;-- branch_true
JMP RRNZ, L26_loop_77
L26_brk_78:
;;; } 27 while Statement
;;; } 26 List<while Statement>
;-- pop 2 bytes
ADD SP, #2
;;; } 25 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 25 Declaration
;;; { 26 TypeSpecifier (all)
;;; spec = extern char (20002)
;;; } 26 TypeSpecifier (all)
.EXTERN Cend_text
;;; } 25 Declaration
;;; ------------------------------------;
;;; { 25 FunctionDefinition
;;; { 26 TypeName
;;; { 27 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 27 TypeSpecifier (all)
;;; { 27 List<DeclItem>
;;; { 28 DeclItem
;;; what = DECL_NAME
;;; name = init_unused
;;; } 28 DeclItem
;;; } 27 List<DeclItem>
;;; } 26 TypeName
;;; { 26 List<DeclItem>
;;; { 27 DeclItem
;;; what = DECL_NAME
;;; name = init_unused
;;; } 27 DeclItem
;;; { 27 DeclItem
;;; what = DECL_FUN
;;; } 27 DeclItem
;;; } 26 List<DeclItem>
Cinit_unused:
;;; { 26 CompoundStatement
;;; { 27 InitDeclarator
;;; { 28 List<DeclItem>
;;; { 29 DeclItem
;;; what = DECL_POINTER
;;; { 30 List<Ptr>
;;; { 31 Ptr
;;; } 31 Ptr
;;; } 30 List<Ptr>
;;; } 29 DeclItem
;;; { 29 DeclItem
;;; what = DECL_NAME
;;; name = cp
;;; } 29 DeclItem
;;; } 28 List<DeclItem>
;;; { 28 Initializer (skalar)
;;; { 29 Expr * r
;;; { 30 Expression (variable name)
;;; expr_type = "identifier" (current_task)
;-- load_rr_var current_task, (16 bit)
MOVE (Ccurrent_task), RR
;;; } 30 Expression (variable name)
;;; } 29 Expr * r
;-- + (member)
ADD RR, #0x0008
;-- content
MOVE (RR), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 28 Initializer (skalar)
;;; } 27 InitDeclarator
;;; { 27 List<while Statement>
;;; { 28 while Statement
;-- branch
JMP L27_cont_79
L27_loop_79:
;;; { 29 ExpressionStatement
;;; { 30 Expr l = r
;;; { 31 TypeName
;;; { 32 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 32 TypeSpecifier (all)
;;; { 32 List<DeclItem>
;;; { 33 DeclItem
;;; what = DECL_NAME
;;; name = cp
;;; } 33 DeclItem
;;; } 32 List<DeclItem>
;;; } 31 TypeName
;;; { 31 NumericExpression (constant 32 = 0x20)
;-- load_rr_constant
MOVE #0x0020, RR
;;; } 31 NumericExpression (constant 32 = 0x20)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 31 Expr * r
;;; { 32 Expression (variable name)
;;; expr_type = "identifier" (cp)
;-- load_rr_var cp = -2(FP), SP at -3 (16 bit)
MOVE 1(SP), RR
;;; } 32 Expression (variable name)
;;; } 31 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (8 bit)
MOVE (SP)+, RS
;-- assign (8 bit)
MOVE R, (LL)
;;; } 30 Expr l = r
;;; } 29 ExpressionStatement
L27_cont_79:
;;; { 29 Expr l >= r
;;; { 30 TypeName
;;; { 31 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 31 TypeSpecifier (all)
;;; { 31 List<DeclItem>
;;; { 32 DeclItem
;;; what = DECL_POINTER
;;; { 33 List<Ptr>
;;; { 34 Ptr
;;; } 34 Ptr
;;; } 33 List<Ptr>
;;; } 32 DeclItem
;;; { 32 DeclItem
;;; what = DECL_NAME
;;; name = cp
;;; } 32 DeclItem
;;; } 31 List<DeclItem>
;;; } 30 TypeName
;;; { 30 Expr --r
;;; { 31 Expression (variable name)
;;; expr_type = "identifier" (cp)
;-- load_rr_var cp = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 31 Expression (variable name)
;-- --
SUB RR, #0x0001
;-- store_rr_var cp = -2(FP), SP at -2
MOVE RR, 0(SP)
;;; } 30 Expr --r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 30 Expression (cast)r
;;; { 31 Expr & r
;-- load_address end_text
MOVE #Cend_text, RR
;;; } 31 Expr & r
;;; } 30 Expression (cast)r
;-- pop_ll (16 bit)
MOVE (SP)+, LL
;-- l >= r
SHS LL, RR
;;; } 29 Expr l >= r
;-- branch_true
JMP RRNZ, L27_loop_79
L27_brk_80:
;;; } 28 while Statement
;;; } 27 List<while Statement>
;-- pop 2 bytes
ADD SP, #2
;;; } 26 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 26 FunctionDefinition
;;; { 27 TypeName
;;; { 28 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 28 TypeSpecifier (all)
;;; { 28 List<DeclItem>
;;; { 29 DeclItem
;;; what = DECL_NAME
;;; name = stack_used
;;; } 29 DeclItem
;;; } 28 List<DeclItem>
;;; } 27 TypeName
;;; { 27 List<DeclItem>
;;; { 28 DeclItem
;;; what = DECL_NAME
;;; name = stack_used
;;; } 28 DeclItem
;;; { 28 DeclItem
;;; what = DECL_FUN
;;; { 29 List<ParameterDeclaration>
;;; { 30 ParameterDeclaration
;;; isEllipsis = false
;;; { 31 TypeName
;;; { 32 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 32 TypeSpecifier (struct/union)
;;; { 32 List<DeclItem>
;;; { 33 DeclItem
;;; what = DECL_POINTER
;;; { 34 List<Ptr>
;;; { 35 Ptr
;;; } 35 Ptr
;;; } 34 List<Ptr>
;;; } 33 DeclItem
;;; { 33 DeclItem
;;; what = DECL_NAME
;;; name = t
;;; } 33 DeclItem
;;; } 32 List<DeclItem>
;;; } 31 TypeName
;;; } 30 ParameterDeclaration
;;; } 29 List<ParameterDeclaration>
;;; } 28 DeclItem
;;; } 27 List<DeclItem>
Cstack_used:
;;; { 27 CompoundStatement
;;; { 28 InitDeclarator
;;; { 29 List<DeclItem>
;;; { 30 DeclItem
;;; what = DECL_POINTER
;;; { 31 List<Ptr>
;;; { 32 Ptr
;;; } 32 Ptr
;;; } 31 List<Ptr>
;;; } 30 DeclItem
;;; { 30 DeclItem
;;; what = DECL_NAME
;;; name = bottom
;;; } 30 DeclItem
;;; } 29 List<DeclItem>
;;; { 29 Initializer (skalar)
;;; { 30 Expr * r
;;; { 31 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = 2(FP), SP at 0 (16 bit)
MOVE 2(SP), RR
;;; } 31 Expression (variable name)
;;; } 30 Expr * r
;-- + (member)
ADD RR, #0x0008
;-- content
MOVE (RR), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 29 Initializer (skalar)
;;; } 28 InitDeclarator
;;; { 28 List<while Statement>
;;; { 29 while Statement
;-- branch
JMP L28_cont_81
L28_loop_81:
;;; { 30 ExpressionStatement
;;; { 31 Expr l - r
;;; { 32 Expr ++r
;;; { 33 Expression (variable name)
;;; expr_type = "identifier" (bottom)
;-- load_rr_var bottom = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 33 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var bottom = -2(FP), SP at -2
MOVE RR, 0(SP)
;;; } 32 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 31 Expr l - r
;;; } 30 ExpressionStatement
L28_cont_81:
;;; { 30 Expr l == r
;;; { 31 TypeName (internal)
;;; { 32 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 32 TypeSpecifier (all)
;;; } 31 TypeName (internal)
;;; { 31 Expr * r
;;; { 32 Expression (variable name)
;;; expr_type = "identifier" (bottom)
;-- load_rr_var bottom = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 32 Expression (variable name)
;-- content
MOVE (RR), RS
;;; } 31 Expr * r
;-- l == r
SEQ RR, #0x0053
;;; } 30 Expr l == r
;-- branch_true
JMP RRNZ, L28_loop_81
L28_brk_82:
;;; } 29 while Statement
;;; { 29 return Statement
;;; { 30 Expr l - r
;;; { 31 Expr * r
;;; { 32 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = 2(FP), SP at -2 (16 bit)
MOVE 4(SP), RR
;;; } 32 Expression (variable name)
;;; } 31 Expr * r
;-- + (member)
ADD RR, #0x000A
;-- content
MOVE (RR), RR
;-- move_rr_to_ll
MOVE RR, LL
;;; { 31 Expression (variable name)
;;; expr_type = "identifier" (bottom)
;-- load_rr_var bottom = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 31 Expression (variable name)
;-- scale_rr *1
;-- l - r
SUB LL, RR
;-- scale *1
;;; } 30 Expr l - r
;-- ret
ADD SP, #2
RET
;;; } 29 return Statement
;;; } 28 List<while Statement>
;-- pop 2 bytes
ADD SP, #2
;;; } 27 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 27 FunctionDefinition
;;; { 28 TypeName
;;; { 29 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 29 TypeSpecifier (all)
;;; { 29 List<DeclItem>
;;; { 30 DeclItem
;;; what = DECL_NAME
;;; name = show_sema
;;; } 30 DeclItem
;;; } 29 List<DeclItem>
;;; } 28 TypeName
;;; { 28 List<DeclItem>
;;; { 29 DeclItem
;;; what = DECL_NAME
;;; name = show_sema
;;; } 29 DeclItem
;;; { 29 DeclItem
;;; what = DECL_FUN
;;; { 30 List<ParameterDeclaration>
;;; { 31 ParameterDeclaration
;;; isEllipsis = false
;;; { 32 TypeName
;;; { 33 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 33 TypeSpecifier (struct/union)
;;; { 33 List<DeclItem>
;;; { 34 DeclItem
;;; what = DECL_POINTER
;;; { 35 List<Ptr>
;;; { 36 Ptr
;;; } 36 Ptr
;;; } 35 List<Ptr>
;;; } 34 DeclItem
;;; { 34 DeclItem
;;; what = DECL_NAME
;;; name = s
;;; } 34 DeclItem
;;; } 33 List<DeclItem>
;;; } 32 TypeName
;;; } 31 ParameterDeclaration
;;; } 30 List<ParameterDeclaration>
;;; } 29 DeclItem
;;; } 28 List<DeclItem>
Cshow_sema:
;;; { 28 CompoundStatement
;;; { 29 InitDeclarator
;;; { 30 List<DeclItem>
;;; { 31 DeclItem
;;; what = DECL_POINTER
;;; { 32 List<Ptr>
;;; { 33 Ptr
;;; } 33 Ptr
;;; } 32 List<Ptr>
;;; } 31 DeclItem
;;; { 31 DeclItem
;;; what = DECL_NAME
;;; name = t
;;; } 31 DeclItem
;;; } 30 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 29 InitDeclarator
;;; { 29 List<ExpressionStatement>
;;; { 30 ExpressionStatement
;;; { 31 Expr l(r)
;;; { 32 TypeName
;;; { 33 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 33 TypeSpecifier (all)
;;; { 33 List<DeclItem>
;;; { 34 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 34 DeclItem
;;; } 33 List<DeclItem>
;;; } 32 TypeName
;;; { 32 Expr (l , r)
;;; { 33 ParameterDeclaration
;;; isEllipsis = true
;;; { 34 TypeName
;;; { 35 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 35 TypeSpecifier (all)
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_POINTER
;;; { 37 List<Ptr>
;;; { 38 Ptr
;;; } 38 Ptr
;;; } 37 List<Ptr>
;;; } 36 DeclItem
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;;; } 34 TypeName
;;; } 33 ParameterDeclaration
;;; { 33 Expr * r
;;; { 34 Expression (variable name)
;;; expr_type = "identifier" (s)
;-- load_rr_var s = 2(FP), SP at -2 (16 bit)
MOVE 4(SP), RR
;;; } 34 Expression (variable name)
;;; } 33 Expr * r
;-- + (member)
;-- content
MOVE (RR), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 33 Expr (l , r)
;;; { 34 ParameterDeclaration
;;; isEllipsis = true
;;; { 35 TypeName
;;; { 36 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 36 TypeSpecifier (all)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_POINTER
;;; { 38 List<Ptr>
;;; { 39 Ptr
;;; } 39 Ptr
;;; } 38 List<Ptr>
;;; } 37 DeclItem
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; } 34 ParameterDeclaration
;;; { 34 Expr * r
;;; { 35 Expression (variable name)
;;; expr_type = "identifier" (s)
;-- load_rr_var s = 2(FP), SP at -4 (16 bit)
MOVE 6(SP), RR
;;; } 35 Expression (variable name)
;;; } 34 Expr * r
;-- + (member)
ADD RR, #0x0006
;-- content
MOVE (RR), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 34 ParameterDeclaration
;;; isEllipsis = true
;;; { 35 TypeName
;;; { 36 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 36 TypeSpecifier (all)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_POINTER
;;; { 38 List<Ptr>
;;; { 39 Ptr
;;; } 39 Ptr
;;; } 38 List<Ptr>
;;; } 37 DeclItem
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; } 34 ParameterDeclaration
;;; { 34 StringExpression
;-- load_rr_string
MOVE #Cstr_44, RR
;;; } 34 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 33 Expr (l , r)
;;; } 32 Expr (l , r)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 6 bytes
ADD SP, #6
;;; } 31 Expr l(r)
;;; } 30 ExpressionStatement
;;; { 30 IfElseStatement
;;; { 31 Expr l < r
;;; { 32 TypeName (internal)
;;; { 33 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 33 TypeSpecifier (all)
;;; } 32 TypeName (internal)
;;; { 32 Expr * r
;;; { 33 Expression (variable name)
;;; expr_type = "identifier" (s)
;-- load_rr_var s = 2(FP), SP at -2 (16 bit)
MOVE 4(SP), RR
;;; } 33 Expression (variable name)
;;; } 32 Expr * r
;-- + (member)
;-- content
MOVE (RR), RR
;-- l < r
SLT RR, #0x0000
;;; } 31 Expr l < r
;-- branch_false
JMP RRZ, L29_else_83
;;; { 31 CompoundStatement
;;; { 32 List<for Statement>
;;; { 33 for Statement
;;; { 34 ExpressionStatement
;;; { 35 Expr l = r
;;; { 36 TypeName
;;; { 37 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 37 TypeSpecifier (struct/union)
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_POINTER
;;; { 39 List<Ptr>
;;; { 40 Ptr
;;; } 40 Ptr
;;; } 39 List<Ptr>
;;; } 38 DeclItem
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = t
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;;; } 36 TypeName
;;; { 36 Expr * r
;;; { 37 Expression (variable name)
;;; expr_type = "identifier" (s)
;-- load_rr_var s = 2(FP), SP at -2 (16 bit)
MOVE 4(SP), RR
;;; } 37 Expression (variable name)
;;; } 36 Expr * r
;-- + (member)
ADD RR, #0x0002
;-- content
MOVE (RR), RR
;-- store_rr_var t = -2(FP), SP at -2
MOVE RR, 0(SP)
;;; } 35 Expr l = r
;;; } 34 ExpressionStatement
;-- branch
JMP L29_tst_84
L29_loop_84:
;;; { 34 CompoundStatement
;;; { 35 List<ExpressionStatement>
;;; { 36 ExpressionStatement
;;; { 37 Expr l(r)
;;; { 38 TypeName
;;; { 39 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 39 TypeSpecifier (all)
;;; { 39 List<DeclItem>
;;; { 40 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 40 DeclItem
;;; } 39 List<DeclItem>
;;; } 38 TypeName
;;; { 38 Expr (l , r)
;;; { 39 ParameterDeclaration
;;; isEllipsis = true
;;; { 40 TypeName
;;; { 41 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 41 TypeSpecifier (all)
;;; { 41 List<DeclItem>
;;; { 42 DeclItem
;;; what = DECL_POINTER
;;; { 43 List<Ptr>
;;; { 44 Ptr
;;; } 44 Ptr
;;; } 43 List<Ptr>
;;; } 42 DeclItem
;;; { 42 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 42 DeclItem
;;; } 41 List<DeclItem>
;;; } 40 TypeName
;;; } 39 ParameterDeclaration
;;; { 39 Expr * r
;;; { 40 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 40 Expression (variable name)
;;; } 39 Expr * r
;-- + (member)
ADD RR, #0x0006
;-- content
MOVE (RR), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 39 ParameterDeclaration
;;; isEllipsis = true
;;; { 40 TypeName
;;; { 41 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 41 TypeSpecifier (all)
;;; { 41 List<DeclItem>
;;; { 42 DeclItem
;;; what = DECL_POINTER
;;; { 43 List<Ptr>
;;; { 44 Ptr
;;; } 44 Ptr
;;; } 43 List<Ptr>
;;; } 42 DeclItem
;;; { 42 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 42 DeclItem
;;; } 41 List<DeclItem>
;;; } 40 TypeName
;;; } 39 ParameterDeclaration
;;; { 39 StringExpression
;-- load_rr_string
MOVE #Cstr_45, RR
;;; } 39 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 38 Expr (l , r)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 4 bytes
ADD SP, #4
;;; } 37 Expr l(r)
;;; } 36 ExpressionStatement
;;; { 36 IfElseStatement
;;; { 37 Expr l == r
;;; { 38 TypeName
;;; { 39 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 39 TypeSpecifier (struct/union)
;;; { 39 List<DeclItem>
;;; { 40 DeclItem
;;; what = DECL_POINTER
;;; { 41 List<Ptr>
;;; { 42 Ptr
;;; } 42 Ptr
;;; } 41 List<Ptr>
;;; } 40 DeclItem
;;; { 40 DeclItem
;;; what = DECL_NAME
;;; name = t
;;; } 40 DeclItem
;;; } 39 List<DeclItem>
;;; } 38 TypeName
;;; { 38 Expr * r
;;; { 39 Expression (variable name)
;;; expr_type = "identifier" (s)
;-- load_rr_var s = 2(FP), SP at -2 (16 bit)
MOVE 4(SP), RR
;;; } 39 Expression (variable name)
;;; } 38 Expr * r
;-- + (member)
ADD RR, #0x0004
;-- content
MOVE (RR), RR
;;; { 38 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_ll_var t = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), LL
;;; } 38 Expression (variable name)
;-- l == r
SEQ LL, RR
;;; } 37 Expr l == r
;-- branch_false
JMP RRZ, L29_endif_86
;;; { 37 ExpressionStatement
;;; { 38 Expr l(r)
;;; { 39 TypeName
;;; { 40 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 40 TypeSpecifier (all)
;;; { 40 List<DeclItem>
;;; { 41 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 41 DeclItem
;;; } 40 List<DeclItem>
;;; } 39 TypeName
;;; { 39 ParameterDeclaration
;;; isEllipsis = true
;;; { 40 TypeName
;;; { 41 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 41 TypeSpecifier (all)
;;; { 41 List<DeclItem>
;;; { 42 DeclItem
;;; what = DECL_POINTER
;;; { 43 List<Ptr>
;;; { 44 Ptr
;;; } 44 Ptr
;;; } 43 List<Ptr>
;;; } 42 DeclItem
;;; { 42 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 42 DeclItem
;;; } 41 List<DeclItem>
;;; } 40 TypeName
;;; } 39 ParameterDeclaration
;;; { 39 StringExpression
;-- load_rr_string
MOVE #Cstr_46, RR
;;; } 39 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 38 Expr l(r)
;;; } 37 ExpressionStatement
L29_endif_86:
;;; } 36 IfElseStatement
;;; } 35 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 34 CompoundStatement
L29_cont_84:
;;; { 34 Expr l = r
;;; { 35 TypeName
;;; { 36 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 36 TypeSpecifier (struct/union)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_POINTER
;;; { 38 List<Ptr>
;;; { 39 Ptr
;;; } 39 Ptr
;;; } 38 List<Ptr>
;;; } 37 DeclItem
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = t
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; { 35 Expr * r
;;; { 36 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 36 Expression (variable name)
;;; } 35 Expr * r
;-- + (member)
ADD RR, #0x0010
;-- content
MOVE (RR), RR
;-- store_rr_var t = -2(FP), SP at -2
MOVE RR, 0(SP)
;;; } 34 Expr l = r
L29_tst_84:
;;; { 34 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 34 Expression (variable name)
;-- branch_true
JMP RRNZ, L29_loop_84
L29_brk_85:
;;; } 33 for Statement
;;; } 32 List<for Statement>
;-- pop 0 bytes
;;; } 31 CompoundStatement
;-- branch
JMP L29_endif_83
L29_else_83:
;;; { 31 CompoundStatement
;;; { 32 List<ExpressionStatement>
;;; { 33 ExpressionStatement
;;; { 34 Expr l(r)
;;; { 35 TypeName
;;; { 36 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 36 TypeSpecifier (all)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; { 35 ParameterDeclaration
;;; isEllipsis = true
;;; { 36 TypeName
;;; { 37 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 37 TypeSpecifier (all)
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_POINTER
;;; { 39 List<Ptr>
;;; { 40 Ptr
;;; } 40 Ptr
;;; } 39 List<Ptr>
;;; } 38 DeclItem
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;;; } 36 TypeName
;;; } 35 ParameterDeclaration
;;; { 35 StringExpression
;-- load_rr_string
MOVE #Cstr_47, RR
;;; } 35 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 34 Expr l(r)
;;; } 33 ExpressionStatement
;;; } 32 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 31 CompoundStatement
L29_endif_83:
;;; } 30 IfElseStatement
;;; { 30 ExpressionStatement
;;; { 31 Expr l(r)
;;; { 32 TypeName
;;; { 33 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 33 TypeSpecifier (all)
;;; { 33 List<DeclItem>
;;; { 34 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 34 DeclItem
;;; } 33 List<DeclItem>
;;; } 32 TypeName
;;; { 32 ParameterDeclaration
;;; isEllipsis = true
;;; { 33 TypeName
;;; { 34 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 34 TypeSpecifier (all)
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_POINTER
;;; { 36 List<Ptr>
;;; { 37 Ptr
;;; } 37 Ptr
;;; } 36 List<Ptr>
;;; } 35 DeclItem
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;;; } 33 TypeName
;;; } 32 ParameterDeclaration
;;; { 32 StringExpression
;-- load_rr_string
MOVE #Cstr_48, RR
;;; } 32 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 31 Expr l(r)
;;; } 30 ExpressionStatement
;;; } 29 List<ExpressionStatement>
;-- pop 2 bytes
ADD SP, #2
;;; } 28 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 28 Declaration
;;; { 29 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 29 TypeSpecifier (all)
Cloader: ;
.BYTE 46
.BYTE 1
.BYTE 17
.BYTE 1
.BYTE 61
.BYTE 3
.BYTE 50
.BYTE 30
.BYTE 46
.BYTE 0
.BYTE 7
.BYTE 46
.BYTE 1
.BYTE 17
.BYTE 2
.BYTE 3
.BYTE 61
.BYTE 30
.BYTE 101
.BYTE 2
.BYTE 47
.BYTE 0
.BYTE 7
.BYTE 2
.BYTE 89
.BYTE 30
.BYTE 97
.BYTE 2
.BYTE 161
.BYTE 93
.BYTE 2
.BYTE 177
.BYTE 71
.BYTE 15
.BYTE 5
.BYTE 61
.BYTE 30
.BYTE 43
.BYTE 1
.BYTE 97
.BYTE 2
.BYTE 71
.BYTE 3
.BYTE 76
.BYTE 30
.BYTE 7
.BYTE 5
.BYTE 50
.BYTE 30
.BYTE 15
.BYTE 101
.BYTE 0
.BYTE 41
.BYTE 48
.BYTE 4
.BYTE 113
.BYTE 30
.BYTE 248
.BYTE 255
.BYTE 0
.BYTE 2
.BYTE 187
.BYTE 30
.BYTE 101
.BYTE 0
.BYTE 39
.BYTE 57
.BYTE 4
.BYTE 127
.BYTE 30
.BYTE 101
.BYTE 0
.BYTE 247
.BYTE 48
.BYTE 2
.BYTE 187
.BYTE 30
.BYTE 101
.BYTE 0
.BYTE 41
.BYTE 65
.BYTE 4
.BYTE 140
.BYTE 30
.BYTE 248
.BYTE 255
.BYTE 0
.BYTE 2
.BYTE 187
.BYTE 30
.BYTE 101
.BYTE 0
.BYTE 39
.BYTE 70
.BYTE 4
.BYTE 154
.BYTE 30
.BYTE 101
.BYTE 0
.BYTE 247
.BYTE 55
.BYTE 2
.BYTE 187
.BYTE 30
.BYTE 101
.BYTE 0
.BYTE 41
.BYTE 97
.BYTE 4
.BYTE 167
.BYTE 30
.BYTE 248
.BYTE 255
.BYTE 0
.BYTE 2
.BYTE 187
.BYTE 30
.BYTE 101
.BYTE 0
.BYTE 39
.BYTE 102
.BYTE 4
.BYTE 181
.BYTE 30
.BYTE 101
.BYTE 0
.BYTE 247
.BYTE 87
.BYTE 2
.BYTE 187
.BYTE 30
.BYTE 248
.BYTE 255
.BYTE 0
.BYTE 2
.BYTE 187
.BYTE 30
.BYTE 43
.BYTE 1
.BYTE 7
.BYTE 5
.BYTE 96
.BYTE 30
.BYTE 15
.BYTE 45
.BYTE 101
.BYTE 1
.BYTE 24
.BYTE 255
.BYTE 0
.BYTE 4
.BYTE 227
.BYTE 30
.BYTE 5
.BYTE 96
.BYTE 30
.BYTE 95
.BYTE 0
.BYTE 101
.BYTE 0
.BYTE 24
.BYTE 255
.BYTE 0
.BYTE 4
.BYTE 227
.BYTE 30
.BYTE 101
.BYTE 1
.BYTE 82
.BYTE 4
.BYTE 67
.BYTE 101
.BYTE 0
.BYTE 49
.BYTE 2
.BYTE 237
.BYTE 30
.BYTE 248
.BYTE 199
.BYTE 31
.BYTE 14
.BYTE 5
.BYTE 73
.BYTE 30
.BYTE 43
.BYTE 2
.BYTE 0
.BYTE 43
.BYTE 2
.BYTE 7
.BYTE 45
.BYTE 44
.BYTE 45
.BYTE 45
.BYTE 45
.BYTE 45
.BYTE 248
.BYTE 218
.BYTE 31
.BYTE 14
.BYTE 5
.BYTE 73
.BYTE 30
.BYTE 43
.BYTE 2
.BYTE 5
.BYTE 50
.BYTE 30
.BYTE 95
.BYTE 0
.BYTE 25
.BYTE 58
.BYTE 3
.BYTE 255
.BYTE 30
.BYTE 192
.BYTE 95
.BYTE 2
.BYTE 5
.BYTE 190
.BYTE 30
.BYTE 95
.BYTE 0
.BYTE 101
.BYTE 2
.BYTE 67
.BYTE 101
.BYTE 0
.BYTE 88
.BYTE 95
.BYTE 2
.BYTE 101
.BYTE 0
.BYTE 95
.BYTE 6
.BYTE 5
.BYTE 190
.BYTE 30
.BYTE 95
.BYTE 0
.BYTE 101
.BYTE 2
.BYTE 67
.BYTE 101
.BYTE 0
.BYTE 88
.BYTE 95
.BYTE 2
.BYTE 101
.BYTE 0
.BYTE 82
.BYTE 8
.BYTE 93
.BYTE 4
.BYTE 5
.BYTE 190
.BYTE 30
.BYTE 95
.BYTE 0
.BYTE 101
.BYTE 2
.BYTE 67
.BYTE 101
.BYTE 0
.BYTE 88
.BYTE 95
.BYTE 2
.BYTE 97
.BYTE 4
.BYTE 67
.BYTE 101
.BYTE 0
.BYTE 49
.BYTE 93
.BYTE 4
.BYTE 5
.BYTE 190
.BYTE 30
.BYTE 95
.BYTE 0
.BYTE 101
.BYTE 2
.BYTE 67
.BYTE 101
.BYTE 0
.BYTE 88
.BYTE 95
.BYTE 2
.BYTE 101
.BYTE 0
.BYTE 95
.BYTE 3
.BYTE 192
.BYTE 95
.BYTE 1
.BYTE 2
.BYTE 124
.BYTE 31
.BYTE 5
.BYTE 190
.BYTE 30
.BYTE 95
.BYTE 0
.BYTE 101
.BYTE 0
.BYTE 15
.BYTE 101
.BYTE 2
.BYTE 14
.BYTE 97
.BYTE 7
.BYTE 11
.BYTE 88
.BYTE 67
.BYTE 9
.BYTE 69
.BYTE 101
.BYTE 2
.BYTE 67
.BYTE 101
.BYTE 0
.BYTE 88
.BYTE 95
.BYTE 2
.BYTE 101
.BYTE 1
.BYTE 161
.BYTE 95
.BYTE 1
.BYTE 177
.BYTE 101
.BYTE 1
.BYTE 67
.BYTE 101
.BYTE 6
.BYTE 60
.BYTE 3
.BYTE 92
.BYTE 31
.BYTE 5
.BYTE 190
.BYTE 30
.BYTE 95
.BYTE 0
.BYTE 101
.BYTE 2
.BYTE 67
.BYTE 101
.BYTE 0
.BYTE 88
.BYTE 95
.BYTE 2
.BYTE 101
.BYTE 2
.BYTE 4
.BYTE 154
.BYTE 31
.BYTE 2
.BYTE 184
.BYTE 31
.BYTE 249
.BYTE 46
.BYTE 15
.BYTE 5
.BYTE 61
.BYTE 30
.BYTE 43
.BYTE 1
.BYTE 101
.BYTE 3
.BYTE 23
.BYTE 1
.BYTE 4
.BYTE 181
.BYTE 31
.BYTE 248
.BYTE 228
.BYTE 31
.BYTE 14
.BYTE 5
.BYTE 73
.BYTE 30
.BYTE 43
.BYTE 2
.BYTE 97
.BYTE 4
.BYTE 6
.BYTE 2
.BYTE 255
.BYTE 30
.BYTE 248
.BYTE 238
.BYTE 31
.BYTE 14
.BYTE 5
.BYTE 73
.BYTE 30
.BYTE 43
.BYTE 2
.BYTE 2
.BYTE 246
.BYTE 30
.BYTE 43
.BYTE 7
.BYTE 7
.BYTE 13
.BYTE 10
.BYTE 69
.BYTE 82
.BYTE 82
.BYTE 79
.BYTE 82
.BYTE 58
.BYTE 32
.BYTE 110
.BYTE 111
.BYTE 116
.BYTE 32
.BYTE 104
.BYTE 101
.BYTE 120
.BYTE 13
.BYTE 10
.BYTE 0
.BYTE 13
.BYTE 10
.BYTE 76
.BYTE 79
.BYTE 65
.BYTE 68
.BYTE 32
.BYTE 62
.BYTE 32
.BYTE 0
.BYTE 13
.BYTE 10
.BYTE 68
.BYTE 79
.BYTE 78
.BYTE 69
.BYTE 46
.BYTE 13
.BYTE 10
.BYTE 0
.BYTE 13
.BYTE 10
.BYTE 67
.BYTE 72
.BYTE 69
.BYTE 67
.BYTE 75
.BYTE 83
.BYTE 85
.BYTE 77
.BYTE 32
.BYTE 69
.BYTE 82
.BYTE 82
.BYTE 79
.BYTE 82
.BYTE 46
.BYTE 0
;;; } 28 Declaration
;;; ------------------------------------;
;;; { 28 FunctionDefinition
;;; { 29 TypeName
;;; { 30 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 30 TypeSpecifier (all)
;;; { 30 List<DeclItem>
;;; { 31 DeclItem
;;; what = DECL_NAME
;;; name = load_image
;;; } 31 DeclItem
;;; } 30 List<DeclItem>
;;; } 29 TypeName
;;; { 29 List<DeclItem>
;;; { 30 DeclItem
;;; what = DECL_NAME
;;; name = load_image
;;; } 30 DeclItem
;;; { 30 DeclItem
;;; what = DECL_FUN
;;; } 30 DeclItem
;;; } 29 List<DeclItem>
Cload_image:
;;; { 29 CompoundStatement
;;; { 30 InitDeclarator
;;; { 31 List<DeclItem>
;;; { 32 DeclItem
;;; what = DECL_POINTER
;;; { 33 List<Ptr>
;;; { 34 Ptr
;;; } 34 Ptr
;;; } 33 List<Ptr>
;;; } 32 DeclItem
;;; { 32 DeclItem
;;; what = DECL_NAME
;;; name = from
;;; } 32 DeclItem
;;; } 31 List<DeclItem>
;;; { 31 Initializer (skalar)
;;; { 32 Expression (cast)r
;;; { 33 Expr & r
;-- load_address loader
MOVE #Cloader, RR
;;; } 33 Expr & r
;;; } 32 Expression (cast)r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 31 Initializer (skalar)
;;; } 30 InitDeclarator
;;; { 30 InitDeclarator
;;; { 31 List<DeclItem>
;;; { 32 DeclItem
;;; what = DECL_POINTER
;;; { 33 List<Ptr>
;;; { 34 Ptr
;;; } 34 Ptr
;;; } 33 List<Ptr>
;;; } 32 DeclItem
;;; { 32 DeclItem
;;; what = DECL_NAME
;;; name = to
;;; } 32 DeclItem
;;; } 31 List<DeclItem>
;;; { 31 Initializer (skalar)
;;; { 32 Expr l - r
;;; { 33 Expression (cast)r
;;; { 34 NumericExpression (constant 8192 = 0x2000)
;-- load_rr_constant
MOVE #0x2000, RR
;;; } 34 NumericExpression (constant 8192 = 0x2000)
;;; } 33 Expression (cast)r
;-- l - r
SUB RR, #0x01CE
;;; } 32 Expr l - r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 31 Initializer (skalar)
;;; } 30 InitDeclarator
;;; { 30 InitDeclarator
;;; { 31 List<DeclItem>
;;; { 32 DeclItem
;;; what = DECL_NAME
;;; name = len
;;; } 32 DeclItem
;;; } 31 List<DeclItem>
;;; { 31 Initializer (skalar)
;;; { 32 NumericExpression (sizeof expr)
;-- load_rr_constant
MOVE #0x01CE, RR
;;; } 32 NumericExpression (sizeof expr)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 31 Initializer (skalar)
;;; } 30 InitDeclarator
;;; { 30 List<ExpressionStatement>
;;; { 31 ExpressionStatement
;;; { 32 Expr l(r)
;;; { 33 TypeName
;;; { 34 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 34 TypeSpecifier (all)
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;;; } 33 TypeName
;;; { 33 ParameterDeclaration
;;; isEllipsis = true
;;; { 34 TypeName
;;; { 35 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 35 TypeSpecifier (all)
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_POINTER
;;; { 37 List<Ptr>
;;; { 38 Ptr
;;; } 38 Ptr
;;; } 37 List<Ptr>
;;; } 36 DeclItem
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;;; } 34 TypeName
;;; } 33 ParameterDeclaration
;;; { 33 StringExpression
;-- load_rr_string
MOVE #Cstr_49, RR
;;; } 33 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 32 Expr l(r)
;;; } 31 ExpressionStatement
;;; { 31 while Statement
L30_loop_87:
;;; { 32 ExpressionStatement
;;; } 32 ExpressionStatement
L30_cont_87:
;;; { 32 Expr l < r
;;; { 33 TypeName (internal)
;;; { 34 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 34 TypeSpecifier (all)
;;; } 33 TypeName (internal)
;-- load_address tx_sema
MOVE #Ctx_sema, RR
;-- + (member)
;-- content
MOVE (RR), RR
;-- l < r
SLT RR, #0x0010
;;; } 32 Expr l < r
;-- branch_true
JMP RRNZ, L30_loop_87
L30_brk_88:
;;; } 31 while Statement
;;; { 31 ExpressionStatement
DI
;;; } 31 ExpressionStatement
;;; { 31 ExpressionStatement
MOVE #0x00, RR
;;; } 31 ExpressionStatement
;;; { 31 ExpressionStatement
OUT R, (OUT_INT_MASK)
;;; } 31 ExpressionStatement
;;; { 31 for Statement
;;; { 32 ExpressionStatement
;;; } 32 ExpressionStatement
;-- branch
JMP L30_tst_89
L30_loop_89:
;;; { 32 ExpressionStatement
;;; { 33 Expr l = r
;;; { 34 TypeName
;;; { 35 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 35 TypeSpecifier (all)
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = to
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;;; } 34 TypeName
;;; { 34 Expr * r
;;; { 35 Expr l - r
;;; { 36 Expr ++r
;;; { 37 Expression (variable name)
;;; expr_type = "identifier" (from)
;-- load_rr_var from = -2(FP), SP at -6 (16 bit)
MOVE 4(SP), RR
;;; } 37 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var from = -2(FP), SP at -6
MOVE RR, 4(SP)
;;; } 36 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 35 Expr l - r
;-- content
MOVE (RR), RU
;;; } 34 Expr * r
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 34 Expr * r
;;; { 35 Expr l - r
;;; { 36 Expr ++r
;;; { 37 Expression (variable name)
;;; expr_type = "identifier" (to)
;-- load_rr_var to = -4(FP), SP at -7 (16 bit)
MOVE 3(SP), RR
;;; } 37 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var to = -4(FP), SP at -7
MOVE RR, 3(SP)
;;; } 36 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 35 Expr l - r
;;; } 34 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (8 bit)
MOVE (SP)+, RU
;-- assign (8 bit)
MOVE R, (LL)
;;; } 33 Expr l = r
;;; } 32 ExpressionStatement
L30_cont_89:
;;; { 32 Expr --r
;;; { 33 Expression (variable name)
;;; expr_type = "identifier" (len)
;-- load_rr_var len = -6(FP), SP at -6 (16 bit)
MOVE 0(SP), RR
;;; } 33 Expression (variable name)
;-- --
SUB RR, #0x0001
;-- store_rr_var len = -6(FP), SP at -6
MOVE RR, 0(SP)
;;; } 32 Expr --r
L30_tst_89:
;;; { 32 Expression (variable name)
;;; expr_type = "identifier" (len)
;-- load_rr_var len = -6(FP), SP at -6 (16 bit)
MOVE 0(SP), RR
;;; } 32 Expression (variable name)
;-- branch_true
JMP RRNZ, L30_loop_89
L30_brk_90:
;;; } 31 for Statement
;;; { 31 ExpressionStatement
;;; { 32 Expression (variable name)
;;; expr_type = "identifier" (to)
;-- load_rr_var to = -4(FP), SP at -6 (16 bit)
MOVE 2(SP), RR
;;; } 32 Expression (variable name)
;;; } 31 ExpressionStatement
;;; { 31 ExpressionStatement
MOVE RR, SP
;;; } 31 ExpressionStatement
;;; { 31 ExpressionStatement
JMP 0x1EF0 ; &main
;;; } 31 ExpressionStatement
;;; } 30 List<ExpressionStatement>
;-- pop 6 bytes
ADD SP, #6
;;; } 29 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 29 FunctionDefinition
;;; { 30 TypeName
;;; { 31 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 31 TypeSpecifier (all)
;;; { 31 List<DeclItem>
;;; { 32 DeclItem
;;; what = DECL_NAME
;;; name = show_semas
;;; } 32 DeclItem
;;; } 31 List<DeclItem>
;;; } 30 TypeName
;;; { 30 List<DeclItem>
;;; { 31 DeclItem
;;; what = DECL_NAME
;;; name = show_semas
;;; } 31 DeclItem
;;; { 31 DeclItem
;;; what = DECL_FUN
;;; } 31 DeclItem
;;; } 30 List<DeclItem>
Cshow_semas:
;;; { 30 CompoundStatement
;;; { 31 List<ExpressionStatement>
;;; { 32 ExpressionStatement
;;; { 33 Expr l(r)
;;; { 34 TypeName
;;; { 35 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 35 TypeSpecifier (all)
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;;; } 34 TypeName
;;; { 34 ParameterDeclaration
;;; isEllipsis = true
;;; { 35 TypeName
;;; { 36 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 36 TypeSpecifier (all)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_POINTER
;;; { 38 List<Ptr>
;;; { 39 Ptr
;;; } 39 Ptr
;;; } 38 List<Ptr>
;;; } 37 DeclItem
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; } 34 ParameterDeclaration
;;; { 34 StringExpression
;-- load_rr_string
MOVE #Cstr_55, RR
;;; } 34 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 33 Expr l(r)
;;; } 32 ExpressionStatement
;;; { 32 ExpressionStatement
;;; { 33 Expr l(r)
;;; { 34 TypeName
;;; { 35 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 35 TypeSpecifier (all)
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = print_n
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;;; } 34 TypeName
;;; { 34 Expr (l , r)
;;; { 35 ParameterDeclaration
;;; isEllipsis = false
;;; { 36 TypeName
;;; { 37 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 37 TypeSpecifier (all)
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = count
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;;; } 36 TypeName
;;; } 35 ParameterDeclaration
;;; { 35 NumericExpression (constant 79 = 0x4F)
;-- load_rr_constant
MOVE #0x004F, RR
;;; } 35 NumericExpression (constant 79 = 0x4F)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 35 ParameterDeclaration
;;; isEllipsis = false
;;; { 36 TypeName
;;; { 37 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 37 TypeSpecifier (all)
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;;; } 36 TypeName
;;; } 35 ParameterDeclaration
;;; { 35 NumericExpression (constant 45 = 0x2D)
;-- load_rr_constant
MOVE #0x002D, RR
;;; } 35 NumericExpression (constant 45 = 0x2D)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; } 34 Expr (l , r)
;-- push 0 bytes
;-- call
CALL Cprint_n
;-- pop 3 bytes
ADD SP, #3
;;; } 33 Expr l(r)
;;; } 32 ExpressionStatement
;;; { 32 ExpressionStatement
;;; { 33 Expr l(r)
;;; { 34 TypeName
;;; { 35 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 35 TypeSpecifier (all)
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;;; } 34 TypeName
;;; { 34 ParameterDeclaration
;;; isEllipsis = true
;;; { 35 TypeName
;;; { 36 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 36 TypeSpecifier (all)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_POINTER
;;; { 38 List<Ptr>
;;; { 39 Ptr
;;; } 39 Ptr
;;; } 38 List<Ptr>
;;; } 37 DeclItem
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; } 34 ParameterDeclaration
;;; { 34 StringExpression
;-- load_rr_string
MOVE #Cstr_56, RR
;;; } 34 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 33 Expr l(r)
;;; } 32 ExpressionStatement
;;; { 32 ExpressionStatement
;;; { 33 Expr l(r)
;;; { 34 TypeName
;;; { 35 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 35 TypeSpecifier (all)
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = show_sema
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;;; } 34 TypeName
;;; { 34 ParameterDeclaration
;;; isEllipsis = false
;;; { 35 TypeName
;;; { 36 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 36 TypeSpecifier (struct/union)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_POINTER
;;; { 38 List<Ptr>
;;; { 39 Ptr
;;; } 39 Ptr
;;; } 38 List<Ptr>
;;; } 37 DeclItem
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = s
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; } 34 ParameterDeclaration
;;; { 34 Expr & r
;-- load_address serial_out
MOVE #Cserial_out, RR
;;; } 34 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL Cshow_sema
;-- pop 2 bytes
ADD SP, #2
;;; } 33 Expr l(r)
;;; } 32 ExpressionStatement
;;; { 32 ExpressionStatement
;;; { 33 Expr l(r)
;;; { 34 TypeName
;;; { 35 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 35 TypeSpecifier (all)
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = show_sema
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;;; } 34 TypeName
;;; { 34 ParameterDeclaration
;;; isEllipsis = false
;;; { 35 TypeName
;;; { 36 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 36 TypeSpecifier (struct/union)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_POINTER
;;; { 38 List<Ptr>
;;; { 39 Ptr
;;; } 39 Ptr
;;; } 38 List<Ptr>
;;; } 37 DeclItem
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = s
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; } 34 ParameterDeclaration
;;; { 34 Expr & r
;-- load_address rx_sema
MOVE #Crx_sema, RR
;;; } 34 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL Cshow_sema
;-- pop 2 bytes
ADD SP, #2
;;; } 33 Expr l(r)
;;; } 32 ExpressionStatement
;;; { 32 ExpressionStatement
;;; { 33 Expr l(r)
;;; { 34 TypeName
;;; { 35 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 35 TypeSpecifier (all)
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = show_sema
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;;; } 34 TypeName
;;; { 34 ParameterDeclaration
;;; isEllipsis = false
;;; { 35 TypeName
;;; { 36 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 36 TypeSpecifier (struct/union)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_POINTER
;;; { 38 List<Ptr>
;;; { 39 Ptr
;;; } 39 Ptr
;;; } 38 List<Ptr>
;;; } 37 DeclItem
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = s
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; } 34 ParameterDeclaration
;;; { 34 Expr & r
;-- load_address tx_sema
MOVE #Ctx_sema, RR
;;; } 34 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL Cshow_sema
;-- pop 2 bytes
ADD SP, #2
;;; } 33 Expr l(r)
;;; } 32 ExpressionStatement
;;; { 32 ExpressionStatement
;;; { 33 Expr l(r)
;;; { 34 TypeName
;;; { 35 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 35 TypeSpecifier (all)
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = show_sema
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;;; } 34 TypeName
;;; { 34 ParameterDeclaration
;;; isEllipsis = false
;;; { 35 TypeName
;;; { 36 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 36 TypeSpecifier (struct/union)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_POINTER
;;; { 38 List<Ptr>
;;; { 39 Ptr
;;; } 39 Ptr
;;; } 38 List<Ptr>
;;; } 37 DeclItem
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = s
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; } 34 ParameterDeclaration
;;; { 34 Expr & r
;-- load_address t2_control
MOVE #Ct2_control, RR
;;; } 34 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL Cshow_sema
;-- pop 2 bytes
ADD SP, #2
;;; } 33 Expr l(r)
;;; } 32 ExpressionStatement
;;; { 32 ExpressionStatement
;;; { 33 Expr l(r)
;;; { 34 TypeName
;;; { 35 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 35 TypeSpecifier (all)
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = show_sema
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;;; } 34 TypeName
;;; { 34 ParameterDeclaration
;;; isEllipsis = false
;;; { 35 TypeName
;;; { 36 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 36 TypeSpecifier (struct/union)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_POINTER
;;; { 38 List<Ptr>
;;; { 39 Ptr
;;; } 39 Ptr
;;; } 38 List<Ptr>
;;; } 37 DeclItem
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = s
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; } 34 ParameterDeclaration
;;; { 34 Expr & r
;-- load_address t3_control
MOVE #Ct3_control, RR
;;; } 34 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL Cshow_sema
;-- pop 2 bytes
ADD SP, #2
;;; } 33 Expr l(r)
;;; } 32 ExpressionStatement
;;; { 32 ExpressionStatement
;;; { 33 Expr l(r)
;;; { 34 TypeName
;;; { 35 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 35 TypeSpecifier (all)
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = print_n
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;;; } 34 TypeName
;;; { 34 Expr (l , r)
;;; { 35 ParameterDeclaration
;;; isEllipsis = false
;;; { 36 TypeName
;;; { 37 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 37 TypeSpecifier (all)
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = count
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;;; } 36 TypeName
;;; } 35 ParameterDeclaration
;;; { 35 NumericExpression (constant 79 = 0x4F)
;-- load_rr_constant
MOVE #0x004F, RR
;;; } 35 NumericExpression (constant 79 = 0x4F)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 35 ParameterDeclaration
;;; isEllipsis = false
;;; { 36 TypeName
;;; { 37 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 37 TypeSpecifier (all)
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;;; } 36 TypeName
;;; } 35 ParameterDeclaration
;;; { 35 NumericExpression (constant 61 = 0x3D)
;-- load_rr_constant
MOVE #0x003D, RR
;;; } 35 NumericExpression (constant 61 = 0x3D)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; } 34 Expr (l , r)
;-- push 0 bytes
;-- call
CALL Cprint_n
;-- pop 3 bytes
ADD SP, #3
;;; } 33 Expr l(r)
;;; } 32 ExpressionStatement
;;; { 32 ExpressionStatement
;;; { 33 Expr l(r)
;;; { 34 TypeName
;;; { 35 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 35 TypeSpecifier (all)
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;;; } 34 TypeName
;;; { 34 ParameterDeclaration
;;; isEllipsis = true
;;; { 35 TypeName
;;; { 36 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 36 TypeSpecifier (all)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_POINTER
;;; { 38 List<Ptr>
;;; { 39 Ptr
;;; } 39 Ptr
;;; } 38 List<Ptr>
;;; } 37 DeclItem
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; } 34 ParameterDeclaration
;;; { 34 StringExpression
;-- load_rr_string
MOVE #Cstr_57, RR
;;; } 34 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 33 Expr l(r)
;;; } 32 ExpressionStatement
;;; { 32 IfElseStatement
;;; { 33 Expression (variable name)
;;; expr_type = "identifier" (serial_in_overflows)
;-- load_rr_var serial_in_overflows, (16 bit)
MOVE (Cserial_in_overflows), RR
;;; } 33 Expression (variable name)
;-- branch_false
JMP RRZ, L31_endif_91
;;; { 33 ExpressionStatement
;;; { 34 Expr l(r)
;;; { 35 TypeName
;;; { 36 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 36 TypeSpecifier (all)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; { 35 Expr (l , r)
;;; { 36 ParameterDeclaration
;;; isEllipsis = true
;;; { 37 TypeName
;;; { 38 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 38 TypeSpecifier (all)
;;; { 38 List<DeclItem>
;;; { 39 DeclItem
;;; what = DECL_POINTER
;;; { 40 List<Ptr>
;;; { 41 Ptr
;;; } 41 Ptr
;;; } 40 List<Ptr>
;;; } 39 DeclItem
;;; { 39 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 39 DeclItem
;;; } 38 List<DeclItem>
;;; } 37 TypeName
;;; } 36 ParameterDeclaration
;;; { 36 Expression (variable name)
;;; expr_type = "identifier" (serial_in_overflows)
;-- load_rr_var serial_in_overflows, (16 bit)
MOVE (Cserial_in_overflows), RR
;;; } 36 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 36 ParameterDeclaration
;;; isEllipsis = true
;;; { 37 TypeName
;;; { 38 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 38 TypeSpecifier (all)
;;; { 38 List<DeclItem>
;;; { 39 DeclItem
;;; what = DECL_POINTER
;;; { 40 List<Ptr>
;;; { 41 Ptr
;;; } 41 Ptr
;;; } 40 List<Ptr>
;;; } 39 DeclItem
;;; { 39 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 39 DeclItem
;;; } 38 List<DeclItem>
;;; } 37 TypeName
;;; } 36 ParameterDeclaration
;;; { 36 StringExpression
;-- load_rr_string
MOVE #Cstr_58, RR
;;; } 36 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 35 Expr (l , r)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 4 bytes
ADD SP, #4
;;; } 34 Expr l(r)
;;; } 33 ExpressionStatement
L31_endif_91:
;;; } 32 IfElseStatement
;;; } 31 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 30 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 30 FunctionDefinition
;;; { 31 TypeName
;;; { 32 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 32 TypeSpecifier (all)
;;; { 32 List<DeclItem>
;;; { 33 DeclItem
;;; what = DECL_NAME
;;; name = show_tasks
;;; } 33 DeclItem
;;; } 32 List<DeclItem>
;;; } 31 TypeName
;;; { 31 List<DeclItem>
;;; { 32 DeclItem
;;; what = DECL_NAME
;;; name = show_tasks
;;; } 32 DeclItem
;;; { 32 DeclItem
;;; what = DECL_FUN
;;; } 32 DeclItem
;;; } 31 List<DeclItem>
Cshow_tasks:
;;; { 31 CompoundStatement
;;; { 32 InitDeclarator
;;; { 33 List<DeclItem>
;;; { 34 DeclItem
;;; what = DECL_POINTER
;;; { 35 List<Ptr>
;;; { 36 Ptr
;;; } 36 Ptr
;;; } 35 List<Ptr>
;;; } 34 DeclItem
;;; { 34 DeclItem
;;; what = DECL_NAME
;;; name = t
;;; } 34 DeclItem
;;; } 33 List<DeclItem>
;;; { 33 Initializer (skalar)
;;; { 34 Expr & r
;-- load_address task_idle
MOVE #Ctask_idle, RR
;;; } 34 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 33 Initializer (skalar)
;;; } 32 InitDeclarator
;;; { 32 List<ExpressionStatement>
;;; { 33 ExpressionStatement
;;; { 34 Expr l(r)
;;; { 35 TypeName
;;; { 36 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 36 TypeSpecifier (all)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; { 35 ParameterDeclaration
;;; isEllipsis = true
;;; { 36 TypeName
;;; { 37 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 37 TypeSpecifier (all)
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_POINTER
;;; { 39 List<Ptr>
;;; { 40 Ptr
;;; } 40 Ptr
;;; } 39 List<Ptr>
;;; } 38 DeclItem
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;;; } 36 TypeName
;;; } 35 ParameterDeclaration
;;; { 35 StringExpression
;-- load_rr_string
MOVE #Cstr_59, RR
;;; } 35 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 34 Expr l(r)
;;; } 33 ExpressionStatement
;;; { 33 ExpressionStatement
;;; { 34 Expr l(r)
;;; { 35 TypeName
;;; { 36 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 36 TypeSpecifier (all)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = print_n
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; { 35 Expr (l , r)
;;; { 36 ParameterDeclaration
;;; isEllipsis = false
;;; { 37 TypeName
;;; { 38 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 38 TypeSpecifier (all)
;;; { 38 List<DeclItem>
;;; { 39 DeclItem
;;; what = DECL_NAME
;;; name = count
;;; } 39 DeclItem
;;; } 38 List<DeclItem>
;;; } 37 TypeName
;;; } 36 ParameterDeclaration
;;; { 36 NumericExpression (constant 79 = 0x4F)
;-- load_rr_constant
MOVE #0x004F, RR
;;; } 36 NumericExpression (constant 79 = 0x4F)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 36 ParameterDeclaration
;;; isEllipsis = false
;;; { 37 TypeName
;;; { 38 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 38 TypeSpecifier (all)
;;; { 38 List<DeclItem>
;;; { 39 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 39 DeclItem
;;; } 38 List<DeclItem>
;;; } 37 TypeName
;;; } 36 ParameterDeclaration
;;; { 36 NumericExpression (constant 45 = 0x2D)
;-- load_rr_constant
MOVE #0x002D, RR
;;; } 36 NumericExpression (constant 45 = 0x2D)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; } 35 Expr (l , r)
;-- push 0 bytes
;-- call
CALL Cprint_n
;-- pop 3 bytes
ADD SP, #3
;;; } 34 Expr l(r)
;;; } 33 ExpressionStatement
;;; { 33 ExpressionStatement
;;; { 34 Expr l(r)
;;; { 35 TypeName
;;; { 36 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 36 TypeSpecifier (all)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; { 35 ParameterDeclaration
;;; isEllipsis = true
;;; { 36 TypeName
;;; { 37 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 37 TypeSpecifier (all)
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_POINTER
;;; { 39 List<Ptr>
;;; { 40 Ptr
;;; } 40 Ptr
;;; } 39 List<Ptr>
;;; } 38 DeclItem
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;;; } 36 TypeName
;;; } 35 ParameterDeclaration
;;; { 35 StringExpression
;-- load_rr_string
MOVE #Cstr_61, RR
;;; } 35 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 34 Expr l(r)
;;; } 33 ExpressionStatement
;;; { 33 do while Statement
L32_loop_92:
;;; { 34 CompoundStatement
;;; { 35 List<ExpressionStatement>
;;; { 36 ExpressionStatement
;;; { 37 Expr l(r)
;;; { 38 TypeName
;;; { 39 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 39 TypeSpecifier (all)
;;; { 39 List<DeclItem>
;;; { 40 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 40 DeclItem
;;; } 39 List<DeclItem>
;;; } 38 TypeName
;;; { 38 Expr (l , r)
;;; { 39 ParameterDeclaration
;;; isEllipsis = true
;;; { 40 TypeName
;;; { 41 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 41 TypeSpecifier (all)
;;; { 41 List<DeclItem>
;;; { 42 DeclItem
;;; what = DECL_POINTER
;;; { 43 List<Ptr>
;;; { 44 Ptr
;;; } 44 Ptr
;;; } 43 List<Ptr>
;;; } 42 DeclItem
;;; { 42 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 42 DeclItem
;;; } 41 List<DeclItem>
;;; } 40 TypeName
;;; } 39 ParameterDeclaration
;;; { 39 Expr l(r)
;;; { 40 TypeName
;;; { 41 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 41 TypeSpecifier (all)
;;; { 41 List<DeclItem>
;;; { 42 DeclItem
;;; what = DECL_NAME
;;; name = stack_used
;;; } 42 DeclItem
;;; } 41 List<DeclItem>
;;; } 40 TypeName
;;; { 40 ParameterDeclaration
;;; isEllipsis = false
;;; { 41 TypeName
;;; { 42 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 42 TypeSpecifier (struct/union)
;;; { 42 List<DeclItem>
;;; { 43 DeclItem
;;; what = DECL_POINTER
;;; { 44 List<Ptr>
;;; { 45 Ptr
;;; } 45 Ptr
;;; } 44 List<Ptr>
;;; } 43 DeclItem
;;; { 43 DeclItem
;;; what = DECL_NAME
;;; name = t
;;; } 43 DeclItem
;;; } 42 List<DeclItem>
;;; } 41 TypeName
;;; } 40 ParameterDeclaration
;;; { 40 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 40 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cstack_used
;-- pop 2 bytes
ADD SP, #2
;;; } 39 Expr l(r)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 39 Expr (l , r)
;;; { 40 ParameterDeclaration
;;; isEllipsis = true
;;; { 41 TypeName
;;; { 42 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 42 TypeSpecifier (all)
;;; { 42 List<DeclItem>
;;; { 43 DeclItem
;;; what = DECL_POINTER
;;; { 44 List<Ptr>
;;; { 45 Ptr
;;; } 45 Ptr
;;; } 44 List<Ptr>
;;; } 43 DeclItem
;;; { 43 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 43 DeclItem
;;; } 42 List<DeclItem>
;;; } 41 TypeName
;;; } 40 ParameterDeclaration
;;; { 40 Expr l - r
;;; { 41 Expr * r
;;; { 42 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -4 (16 bit)
MOVE 2(SP), RR
;;; } 42 Expression (variable name)
;;; } 41 Expr * r
;-- + (member)
ADD RR, #0x0008
;-- content
MOVE (RR), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 41 Expr * r
;;; { 42 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -6 (16 bit)
MOVE 4(SP), RR
;;; } 42 Expression (variable name)
;;; } 41 Expr * r
;-- + (member)
ADD RR, #0x000A
;-- content
MOVE (RR), RR
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (16 bit)
MOVE (SP)+, RR
;-- scale_rr *1
;-- l - r
SUB LL, RR
;-- scale *1
;;; } 40 Expr l - r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 40 Expr (l , r)
;;; { 41 ParameterDeclaration
;;; isEllipsis = true
;;; { 42 TypeName
;;; { 43 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 43 TypeSpecifier (all)
;;; { 43 List<DeclItem>
;;; { 44 DeclItem
;;; what = DECL_POINTER
;;; { 45 List<Ptr>
;;; { 46 Ptr
;;; } 46 Ptr
;;; } 45 List<Ptr>
;;; } 44 DeclItem
;;; { 44 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 44 DeclItem
;;; } 43 List<DeclItem>
;;; } 42 TypeName
;;; } 41 ParameterDeclaration
;;; { 41 Expr * r
;;; { 42 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -6 (16 bit)
MOVE 4(SP), RR
;;; } 42 Expression (variable name)
;;; } 41 Expr * r
;-- + (member)
ADD RR, #0x0002
;-- content
MOVE (RR), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 41 Expr (l , r)
;;; { 42 ParameterDeclaration
;;; isEllipsis = true
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_POINTER
;;; { 46 List<Ptr>
;;; { 47 Ptr
;;; } 47 Ptr
;;; } 46 List<Ptr>
;;; } 45 DeclItem
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; } 42 ParameterDeclaration
;;; { 42 Expr l[r]
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = stack_pointer
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; { 43 Expr l[r]
;;; { 44 NumericExpression (constant 2 = 0x2)
;-- load_rr_constant
MOVE #0x0002, RR
;;; } 44 NumericExpression (constant 2 = 0x2)
;-- scale_rr *2
;-- *
LSL RR, #1
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 44 Expr * r
;;; { 45 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -10 (16 bit)
MOVE 8(SP), RR
;;; } 45 Expression (variable name)
;;; } 44 Expr * r
;-- + (member)
ADD RR, #0x0002
;-- content
MOVE (RR), RR
;-- pop_ll (16 bit)
MOVE (SP)+, LL
;-- + (element)
ADD LL, RR
;;; } 43 Expr l[r]
;-- content
MOVE (RR), RR
;;; } 42 Expr l[r]
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 42 Expr (l , r)
;;; { 43 ParameterDeclaration
;;; isEllipsis = true
;;; { 44 TypeName
;;; { 45 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 45 TypeSpecifier (all)
;;; { 45 List<DeclItem>
;;; { 46 DeclItem
;;; what = DECL_POINTER
;;; { 47 List<Ptr>
;;; { 48 Ptr
;;; } 48 Ptr
;;; } 47 List<Ptr>
;;; } 46 DeclItem
;;; { 46 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 46 DeclItem
;;; } 45 List<DeclItem>
;;; } 44 TypeName
;;; } 43 ParameterDeclaration
;;; { 43 Expr * r
;;; { 44 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -10 (16 bit)
MOVE 8(SP), RR
;;; } 44 Expression (variable name)
;;; } 43 Expr * r
;-- + (member)
ADD RR, #0x0005
;-- content
MOVE (RR), RU
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 43 Expr (l , r)
;;; { 44 ParameterDeclaration
;;; isEllipsis = true
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_POINTER
;;; { 48 List<Ptr>
;;; { 49 Ptr
;;; } 49 Ptr
;;; } 48 List<Ptr>
;;; } 47 DeclItem
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; } 44 ParameterDeclaration
;;; { 44 Expr * r
;;; { 45 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -12 (16 bit)
MOVE 10(SP), RR
;;; } 45 Expression (variable name)
;;; } 44 Expr * r
;-- + (member)
ADD RR, #0x0006
;-- content
MOVE (RR), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 44 ParameterDeclaration
;;; isEllipsis = true
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_POINTER
;;; { 48 List<Ptr>
;;; { 49 Ptr
;;; } 49 Ptr
;;; } 48 List<Ptr>
;;; } 47 DeclItem
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; } 44 ParameterDeclaration
;;; { 44 StringExpression
;-- load_rr_string
MOVE #Cstr_62, RR
;;; } 44 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 43 Expr (l , r)
;;; } 42 Expr (l , r)
;;; } 41 Expr (l , r)
;;; } 40 Expr (l , r)
;;; } 39 Expr (l , r)
;;; } 38 Expr (l , r)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 14 bytes
ADD SP, #14
;;; } 37 Expr l(r)
;;; } 36 ExpressionStatement
;;; { 36 IfElseStatement
;;; { 37 Expr * r
;;; { 38 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 38 Expression (variable name)
;;; } 37 Expr * r
;-- + (member)
ADD RR, #0x0010
;-- content
MOVE (RR), RR
;-- branch_false
JMP RRZ, L32_else_94
;;; { 37 ExpressionStatement
;;; { 38 Expr l(r)
;;; { 39 TypeName
;;; { 40 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 40 TypeSpecifier (all)
;;; { 40 List<DeclItem>
;;; { 41 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 41 DeclItem
;;; } 40 List<DeclItem>
;;; } 39 TypeName
;;; { 39 Expr (l , r)
;;; { 40 ParameterDeclaration
;;; isEllipsis = true
;;; { 41 TypeName
;;; { 42 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 42 TypeSpecifier (all)
;;; { 42 List<DeclItem>
;;; { 43 DeclItem
;;; what = DECL_POINTER
;;; { 44 List<Ptr>
;;; { 45 Ptr
;;; } 45 Ptr
;;; } 44 List<Ptr>
;;; } 43 DeclItem
;;; { 43 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 43 DeclItem
;;; } 42 List<DeclItem>
;;; } 41 TypeName
;;; } 40 ParameterDeclaration
;;; { 40 Expr * r
;;; { 41 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 41 Expression (variable name)
;;; } 40 Expr * r
;-- + (member)
ADD RR, #0x0010
;-- content
MOVE (RR), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 40 ParameterDeclaration
;;; isEllipsis = true
;;; { 41 TypeName
;;; { 42 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 42 TypeSpecifier (all)
;;; { 42 List<DeclItem>
;;; { 43 DeclItem
;;; what = DECL_POINTER
;;; { 44 List<Ptr>
;;; { 45 Ptr
;;; } 45 Ptr
;;; } 44 List<Ptr>
;;; } 43 DeclItem
;;; { 43 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 43 DeclItem
;;; } 42 List<DeclItem>
;;; } 41 TypeName
;;; } 40 ParameterDeclaration
;;; { 40 StringExpression
;-- load_rr_string
MOVE #Cstr_63, RR
;;; } 40 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 39 Expr (l , r)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 4 bytes
ADD SP, #4
;;; } 38 Expr l(r)
;;; } 37 ExpressionStatement
;-- branch
JMP L32_endif_94
L32_else_94:
;;; { 37 ExpressionStatement
;;; { 38 Expr l(r)
;;; { 39 TypeName
;;; { 40 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 40 TypeSpecifier (all)
;;; { 40 List<DeclItem>
;;; { 41 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 41 DeclItem
;;; } 40 List<DeclItem>
;;; } 39 TypeName
;;; { 39 ParameterDeclaration
;;; isEllipsis = true
;;; { 40 TypeName
;;; { 41 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 41 TypeSpecifier (all)
;;; { 41 List<DeclItem>
;;; { 42 DeclItem
;;; what = DECL_POINTER
;;; { 43 List<Ptr>
;;; { 44 Ptr
;;; } 44 Ptr
;;; } 43 List<Ptr>
;;; } 42 DeclItem
;;; { 42 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 42 DeclItem
;;; } 41 List<DeclItem>
;;; } 40 TypeName
;;; } 39 ParameterDeclaration
;;; { 39 StringExpression
;-- load_rr_string
MOVE #Cstr_64, RR
;;; } 39 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 38 Expr l(r)
;;; } 37 ExpressionStatement
L32_endif_94:
;;; } 36 IfElseStatement
;;; { 36 IfElseStatement
;;; { 37 Expr l == r
;;; { 38 TypeName (internal)
;;; { 39 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 39 TypeSpecifier (all)
;;; } 38 TypeName (internal)
;;; { 38 Expr * r
;;; { 39 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 39 Expression (variable name)
;;; } 38 Expr * r
;-- + (member)
ADD RR, #0x0004
;-- content
MOVE (RR), RS
;-- l == r
SEQ RR, #0x0000
;;; } 37 Expr l == r
;-- branch_false
JMP RRZ, L32_endif_95
;;; { 37 ExpressionStatement
;;; { 38 Expr l(r)
;;; { 39 TypeName
;;; { 40 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 40 TypeSpecifier (all)
;;; { 40 List<DeclItem>
;;; { 41 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 41 DeclItem
;;; } 40 List<DeclItem>
;;; } 39 TypeName
;;; { 39 ParameterDeclaration
;;; isEllipsis = true
;;; { 40 TypeName
;;; { 41 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 41 TypeSpecifier (all)
;;; { 41 List<DeclItem>
;;; { 42 DeclItem
;;; what = DECL_POINTER
;;; { 43 List<Ptr>
;;; { 44 Ptr
;;; } 44 Ptr
;;; } 43 List<Ptr>
;;; } 42 DeclItem
;;; { 42 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 42 DeclItem
;;; } 41 List<DeclItem>
;;; } 40 TypeName
;;; } 39 ParameterDeclaration
;;; { 39 StringExpression
;-- load_rr_string
MOVE #Cstr_65, RR
;;; } 39 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 38 Expr l(r)
;;; } 37 ExpressionStatement
L32_endif_95:
;;; } 36 IfElseStatement
;;; { 36 IfElseStatement
;;; { 37 Expr l & r
;;; { 38 TypeName (internal)
;;; { 39 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 39 TypeSpecifier (all)
;;; } 38 TypeName (internal)
;;; { 38 Expr * r
;;; { 39 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 39 Expression (variable name)
;;; } 38 Expr * r
;-- + (member)
ADD RR, #0x0004
;-- content
MOVE (RR), RS
;-- l & r
AND RR, #0x0004
;;; } 37 Expr l & r
;-- branch_false
JMP RRZ, L32_endif_96
;;; { 37 ExpressionStatement
;;; { 38 Expr l(r)
;;; { 39 TypeName
;;; { 40 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 40 TypeSpecifier (all)
;;; { 40 List<DeclItem>
;;; { 41 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 41 DeclItem
;;; } 40 List<DeclItem>
;;; } 39 TypeName
;;; { 39 ParameterDeclaration
;;; isEllipsis = true
;;; { 40 TypeName
;;; { 41 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 41 TypeSpecifier (all)
;;; { 41 List<DeclItem>
;;; { 42 DeclItem
;;; what = DECL_POINTER
;;; { 43 List<Ptr>
;;; { 44 Ptr
;;; } 44 Ptr
;;; } 43 List<Ptr>
;;; } 42 DeclItem
;;; { 42 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 42 DeclItem
;;; } 41 List<DeclItem>
;;; } 40 TypeName
;;; } 39 ParameterDeclaration
;;; { 39 StringExpression
;-- load_rr_string
MOVE #Cstr_66, RR
;;; } 39 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 38 Expr l(r)
;;; } 37 ExpressionStatement
L32_endif_96:
;;; } 36 IfElseStatement
;;; { 36 IfElseStatement
;;; { 37 Expr l & r
;;; { 38 TypeName (internal)
;;; { 39 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 39 TypeSpecifier (all)
;;; } 38 TypeName (internal)
;;; { 38 Expr * r
;;; { 39 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 39 Expression (variable name)
;;; } 38 Expr * r
;-- + (member)
ADD RR, #0x0004
;-- content
MOVE (RR), RS
;-- l & r
AND RR, #0x0002
;;; } 37 Expr l & r
;-- branch_false
JMP RRZ, L32_endif_97
;;; { 37 ExpressionStatement
;;; { 38 Expr l(r)
;;; { 39 TypeName
;;; { 40 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 40 TypeSpecifier (all)
;;; { 40 List<DeclItem>
;;; { 41 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 41 DeclItem
;;; } 40 List<DeclItem>
;;; } 39 TypeName
;;; { 39 Expr (l , r)
;;; { 40 ParameterDeclaration
;;; isEllipsis = true
;;; { 41 TypeName
;;; { 42 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 42 TypeSpecifier (all)
;;; { 42 List<DeclItem>
;;; { 43 DeclItem
;;; what = DECL_POINTER
;;; { 44 List<Ptr>
;;; { 45 Ptr
;;; } 45 Ptr
;;; } 44 List<Ptr>
;;; } 43 DeclItem
;;; { 43 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 43 DeclItem
;;; } 42 List<DeclItem>
;;; } 41 TypeName
;;; } 40 ParameterDeclaration
;;; { 40 Expr * r
;;; { 41 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 41 Expression (variable name)
;;; } 40 Expr * r
;-- + (member)
ADD RR, #0x0012
;-- content
MOVE (RR), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 40 ParameterDeclaration
;;; isEllipsis = true
;;; { 41 TypeName
;;; { 42 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 42 TypeSpecifier (all)
;;; { 42 List<DeclItem>
;;; { 43 DeclItem
;;; what = DECL_POINTER
;;; { 44 List<Ptr>
;;; { 45 Ptr
;;; } 45 Ptr
;;; } 44 List<Ptr>
;;; } 43 DeclItem
;;; { 43 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 43 DeclItem
;;; } 42 List<DeclItem>
;;; } 41 TypeName
;;; } 40 ParameterDeclaration
;;; { 40 StringExpression
;-- load_rr_string
MOVE #Cstr_67, RR
;;; } 40 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 39 Expr (l , r)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 4 bytes
ADD SP, #4
;;; } 38 Expr l(r)
;;; } 37 ExpressionStatement
L32_endif_97:
;;; } 36 IfElseStatement
;;; { 36 IfElseStatement
;;; { 37 Expr l & r
;;; { 38 TypeName (internal)
;;; { 39 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 39 TypeSpecifier (all)
;;; } 38 TypeName (internal)
;;; { 38 Expr * r
;;; { 39 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 39 Expression (variable name)
;;; } 38 Expr * r
;-- + (member)
ADD RR, #0x0004
;-- content
MOVE (RR), RS
;-- l & r
AND RR, #0x0001
;;; } 37 Expr l & r
;-- branch_false
JMP RRZ, L32_endif_98
;;; { 37 ExpressionStatement
;;; { 38 Expr l(r)
;;; { 39 TypeName
;;; { 40 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 40 TypeSpecifier (all)
;;; { 40 List<DeclItem>
;;; { 41 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 41 DeclItem
;;; } 40 List<DeclItem>
;;; } 39 TypeName
;;; { 39 Expr (l , r)
;;; { 40 ParameterDeclaration
;;; isEllipsis = true
;;; { 41 TypeName
;;; { 42 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 42 TypeSpecifier (all)
;;; { 42 List<DeclItem>
;;; { 43 DeclItem
;;; what = DECL_POINTER
;;; { 44 List<Ptr>
;;; { 45 Ptr
;;; } 45 Ptr
;;; } 44 List<Ptr>
;;; } 43 DeclItem
;;; { 43 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 43 DeclItem
;;; } 42 List<DeclItem>
;;; } 41 TypeName
;;; } 40 ParameterDeclaration
;;; { 40 Expr * r
;;; { 41 Expr * r
;;; { 42 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 42 Expression (variable name)
;;; } 41 Expr * r
;-- + (member)
ADD RR, #0x000E
;-- content
MOVE (RR), RR
;;; } 40 Expr * r
;-- + (member)
ADD RR, #0x0006
;-- content
MOVE (RR), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 40 ParameterDeclaration
;;; isEllipsis = true
;;; { 41 TypeName
;;; { 42 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 42 TypeSpecifier (all)
;;; { 42 List<DeclItem>
;;; { 43 DeclItem
;;; what = DECL_POINTER
;;; { 44 List<Ptr>
;;; { 45 Ptr
;;; } 45 Ptr
;;; } 44 List<Ptr>
;;; } 43 DeclItem
;;; { 43 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 43 DeclItem
;;; } 42 List<DeclItem>
;;; } 41 TypeName
;;; } 40 ParameterDeclaration
;;; { 40 StringExpression
;-- load_rr_string
MOVE #Cstr_68, RR
;;; } 40 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 39 Expr (l , r)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 4 bytes
ADD SP, #4
;;; } 38 Expr l(r)
;;; } 37 ExpressionStatement
L32_endif_98:
;;; } 36 IfElseStatement
;;; { 36 ExpressionStatement
;;; { 37 Expr l(r)
;;; { 38 TypeName
;;; { 39 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 39 TypeSpecifier (all)
;;; { 39 List<DeclItem>
;;; { 40 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 40 DeclItem
;;; } 39 List<DeclItem>
;;; } 38 TypeName
;;; { 38 ParameterDeclaration
;;; isEllipsis = true
;;; { 39 TypeName
;;; { 40 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 40 TypeSpecifier (all)
;;; { 40 List<DeclItem>
;;; { 41 DeclItem
;;; what = DECL_POINTER
;;; { 42 List<Ptr>
;;; { 43 Ptr
;;; } 43 Ptr
;;; } 42 List<Ptr>
;;; } 41 DeclItem
;;; { 41 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 41 DeclItem
;;; } 40 List<DeclItem>
;;; } 39 TypeName
;;; } 38 ParameterDeclaration
;;; { 38 StringExpression
;-- load_rr_string
MOVE #Cstr_69, RR
;;; } 38 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 37 Expr l(r)
;;; } 36 ExpressionStatement
;;; { 36 ExpressionStatement
;;; { 37 Expr l = r
;;; { 38 TypeName
;;; { 39 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 39 TypeSpecifier (struct/union)
;;; { 39 List<DeclItem>
;;; { 40 DeclItem
;;; what = DECL_POINTER
;;; { 41 List<Ptr>
;;; { 42 Ptr
;;; } 42 Ptr
;;; } 41 List<Ptr>
;;; } 40 DeclItem
;;; { 40 DeclItem
;;; what = DECL_NAME
;;; name = t
;;; } 40 DeclItem
;;; } 39 List<DeclItem>
;;; } 38 TypeName
;;; { 38 Expr * r
;;; { 39 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_rr_var t = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 39 Expression (variable name)
;;; } 38 Expr * r
;-- + (member)
;-- content
MOVE (RR), RR
;-- store_rr_var t = -2(FP), SP at -2
MOVE RR, 0(SP)
;;; } 37 Expr l = r
;;; } 36 ExpressionStatement
;;; } 35 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 34 CompoundStatement
L32_cont_92:
;;; { 34 Expr l != r
;;; { 35 TypeName
;;; { 36 TypeSpecifier (struct/union)
;;; spec = struct '_task' (800000)
;;; name = _task
;;; } 36 TypeSpecifier (struct/union)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_POINTER
;;; { 38 List<Ptr>
;;; { 39 Ptr
;;; } 39 Ptr
;;; } 38 List<Ptr>
;;; } 37 DeclItem
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = t
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; { 35 Expr & r
;-- load_address task_idle
MOVE #Ctask_idle, RR
;;; } 35 Expr & r
;;; { 35 Expression (variable name)
;;; expr_type = "identifier" (t)
;-- load_ll_var t = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), LL
;;; } 35 Expression (variable name)
;-- l != r
SNE LL, RR
;;; } 34 Expr l != r
;-- branch_true
JMP RRNZ, L32_loop_92
L32_brk_93:
;;; } 33 do while Statement
;;; { 33 ExpressionStatement
;;; { 34 Expr l(r)
;;; { 35 TypeName
;;; { 36 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 36 TypeSpecifier (all)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = print_n
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; { 35 Expr (l , r)
;;; { 36 ParameterDeclaration
;;; isEllipsis = false
;;; { 37 TypeName
;;; { 38 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 38 TypeSpecifier (all)
;;; { 38 List<DeclItem>
;;; { 39 DeclItem
;;; what = DECL_NAME
;;; name = count
;;; } 39 DeclItem
;;; } 38 List<DeclItem>
;;; } 37 TypeName
;;; } 36 ParameterDeclaration
;;; { 36 NumericExpression (constant 79 = 0x4F)
;-- load_rr_constant
MOVE #0x004F, RR
;;; } 36 NumericExpression (constant 79 = 0x4F)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 36 ParameterDeclaration
;;; isEllipsis = false
;;; { 37 TypeName
;;; { 38 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 38 TypeSpecifier (all)
;;; { 38 List<DeclItem>
;;; { 39 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 39 DeclItem
;;; } 38 List<DeclItem>
;;; } 37 TypeName
;;; } 36 ParameterDeclaration
;;; { 36 NumericExpression (constant 61 = 0x3D)
;-- load_rr_constant
MOVE #0x003D, RR
;;; } 36 NumericExpression (constant 61 = 0x3D)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; } 35 Expr (l , r)
;-- push 0 bytes
;-- call
CALL Cprint_n
;-- pop 3 bytes
ADD SP, #3
;;; } 34 Expr l(r)
;;; } 33 ExpressionStatement
;;; { 33 ExpressionStatement
;;; { 34 Expr l(r)
;;; { 35 TypeName
;;; { 36 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 36 TypeSpecifier (all)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; { 35 ParameterDeclaration
;;; isEllipsis = true
;;; { 36 TypeName
;;; { 37 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 37 TypeSpecifier (all)
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_POINTER
;;; { 39 List<Ptr>
;;; { 40 Ptr
;;; } 40 Ptr
;;; } 39 List<Ptr>
;;; } 38 DeclItem
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;;; } 36 TypeName
;;; } 35 ParameterDeclaration
;;; { 35 StringExpression
;-- load_rr_string
MOVE #Cstr_70, RR
;;; } 35 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 34 Expr l(r)
;;; } 33 ExpressionStatement
;;; } 32 List<ExpressionStatement>
;-- pop 2 bytes
ADD SP, #2
;;; } 31 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 31 FunctionDefinition
;;; { 32 TypeName
;;; { 33 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 33 TypeSpecifier (all)
;;; { 33 List<DeclItem>
;;; { 34 DeclItem
;;; what = DECL_NAME
;;; name = show_time
;;; } 34 DeclItem
;;; } 33 List<DeclItem>
;;; } 32 TypeName
;;; { 32 List<DeclItem>
;;; { 33 DeclItem
;;; what = DECL_NAME
;;; name = show_time
;;; } 33 DeclItem
;;; { 33 DeclItem
;;; what = DECL_FUN
;;; } 33 DeclItem
;;; } 32 List<DeclItem>
Cshow_time:
;;; { 32 CompoundStatement
;;; { 33 InitDeclarator
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = sl
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 33 InitDeclarator
;;; { 33 InitDeclarator
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = sm
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 33 InitDeclarator
;;; { 33 InitDeclarator
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = sh
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 33 InitDeclarator
;;; { 33 List<do while Statement>
;;; { 34 do while Statement
L33_loop_99:
;;; { 35 CompoundStatement
;;; { 36 List<ExpressionStatement>
;;; { 37 ExpressionStatement
;;; { 38 Expr l = r
;;; { 39 TypeName
;;; { 40 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 40 TypeSpecifier (all)
;;; { 40 List<DeclItem>
;;; { 41 DeclItem
;;; what = DECL_NAME
;;; name = seconds_changed
;;; } 41 DeclItem
;;; } 40 List<DeclItem>
;;; } 39 TypeName
;;; { 39 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 39 NumericExpression (constant 0 = 0x0)
;-- store_rr_var seconds_changed
MOVE R, (Cseconds_changed)
;;; } 38 Expr l = r
;;; } 37 ExpressionStatement
;;; { 37 ExpressionStatement
;;; { 38 Expr l = r
;;; { 39 TypeName
;;; { 40 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 40 TypeSpecifier (all)
;;; { 40 List<DeclItem>
;;; { 41 DeclItem
;;; what = DECL_NAME
;;; name = sl
;;; } 41 DeclItem
;;; } 40 List<DeclItem>
;;; } 39 TypeName
;;; { 39 Expression (variable name)
;;; expr_type = "identifier" (seconds_low)
;-- load_rr_var seconds_low, (16 bit)
MOVE (Cseconds_low), RR
;;; } 39 Expression (variable name)
;-- store_rr_var sl = -2(FP), SP at -6
MOVE RR, 4(SP)
;;; } 38 Expr l = r
;;; } 37 ExpressionStatement
;;; { 37 ExpressionStatement
;;; { 38 Expr l = r
;;; { 39 TypeName
;;; { 40 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 40 TypeSpecifier (all)
;;; { 40 List<DeclItem>
;;; { 41 DeclItem
;;; what = DECL_NAME
;;; name = sm
;;; } 41 DeclItem
;;; } 40 List<DeclItem>
;;; } 39 TypeName
;;; { 39 Expression (variable name)
;;; expr_type = "identifier" (seconds_mid)
;-- load_rr_var seconds_mid, (16 bit)
MOVE (Cseconds_mid), RR
;;; } 39 Expression (variable name)
;-- store_rr_var sm = -4(FP), SP at -6
MOVE RR, 2(SP)
;;; } 38 Expr l = r
;;; } 37 ExpressionStatement
;;; { 37 ExpressionStatement
;;; { 38 Expr l = r
;;; { 39 TypeName
;;; { 40 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 40 TypeSpecifier (all)
;;; { 40 List<DeclItem>
;;; { 41 DeclItem
;;; what = DECL_NAME
;;; name = sh
;;; } 41 DeclItem
;;; } 40 List<DeclItem>
;;; } 39 TypeName
;;; { 39 Expression (variable name)
;;; expr_type = "identifier" (seconds_high)
;-- load_rr_var seconds_high, (16 bit)
MOVE (Cseconds_high), RR
;;; } 39 Expression (variable name)
;-- store_rr_var sh = -6(FP), SP at -6
MOVE RR, 0(SP)
;;; } 38 Expr l = r
;;; } 37 ExpressionStatement
;;; } 36 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 35 CompoundStatement
L33_cont_99:
;;; { 35 Expression (variable name)
;;; expr_type = "identifier" (seconds_changed)
;-- load_rr_var seconds_changed, (8 bit)
MOVE (Cseconds_changed), RU
;;; } 35 Expression (variable name)
;-- branch_true
JMP RRNZ, L33_loop_99
L33_brk_100:
;;; } 34 do while Statement
;;; { 34 ExpressionStatement
;;; { 35 Expr l(r)
;;; { 36 TypeName
;;; { 37 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 37 TypeSpecifier (all)
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;;; } 36 TypeName
;;; { 36 Expr (l , r)
;;; { 37 ParameterDeclaration
;;; isEllipsis = true
;;; { 38 TypeName
;;; { 39 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 39 TypeSpecifier (all)
;;; { 39 List<DeclItem>
;;; { 40 DeclItem
;;; what = DECL_POINTER
;;; { 41 List<Ptr>
;;; { 42 Ptr
;;; } 42 Ptr
;;; } 41 List<Ptr>
;;; } 40 DeclItem
;;; { 40 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 40 DeclItem
;;; } 39 List<DeclItem>
;;; } 38 TypeName
;;; } 37 ParameterDeclaration
;;; { 37 Expression (variable name)
;;; expr_type = "identifier" (sl)
;-- load_rr_var sl = -2(FP), SP at -6 (16 bit)
MOVE 4(SP), RR
;;; } 37 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 37 Expr (l , r)
;;; { 38 ParameterDeclaration
;;; isEllipsis = true
;;; { 39 TypeName
;;; { 40 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 40 TypeSpecifier (all)
;;; { 40 List<DeclItem>
;;; { 41 DeclItem
;;; what = DECL_POINTER
;;; { 42 List<Ptr>
;;; { 43 Ptr
;;; } 43 Ptr
;;; } 42 List<Ptr>
;;; } 41 DeclItem
;;; { 41 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 41 DeclItem
;;; } 40 List<DeclItem>
;;; } 39 TypeName
;;; } 38 ParameterDeclaration
;;; { 38 Expression (variable name)
;;; expr_type = "identifier" (sm)
;-- load_rr_var sm = -4(FP), SP at -8 (16 bit)
MOVE 4(SP), RR
;;; } 38 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 38 Expr (l , r)
;;; { 39 ParameterDeclaration
;;; isEllipsis = true
;;; { 40 TypeName
;;; { 41 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 41 TypeSpecifier (all)
;;; { 41 List<DeclItem>
;;; { 42 DeclItem
;;; what = DECL_POINTER
;;; { 43 List<Ptr>
;;; { 44 Ptr
;;; } 44 Ptr
;;; } 43 List<Ptr>
;;; } 42 DeclItem
;;; { 42 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 42 DeclItem
;;; } 41 List<DeclItem>
;;; } 40 TypeName
;;; } 39 ParameterDeclaration
;;; { 39 Expression (variable name)
;;; expr_type = "identifier" (sh)
;-- load_rr_var sh = -6(FP), SP at -10 (16 bit)
MOVE 4(SP), RR
;;; } 39 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 39 ParameterDeclaration
;;; isEllipsis = true
;;; { 40 TypeName
;;; { 41 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 41 TypeSpecifier (all)
;;; { 41 List<DeclItem>
;;; { 42 DeclItem
;;; what = DECL_POINTER
;;; { 43 List<Ptr>
;;; { 44 Ptr
;;; } 44 Ptr
;;; } 43 List<Ptr>
;;; } 42 DeclItem
;;; { 42 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 42 DeclItem
;;; } 41 List<DeclItem>
;;; } 40 TypeName
;;; } 39 ParameterDeclaration
;;; { 39 StringExpression
;-- load_rr_string
MOVE #Cstr_71, RR
;;; } 39 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 38 Expr (l , r)
;;; } 37 Expr (l , r)
;;; } 36 Expr (l , r)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 8 bytes
ADD SP, #8
;;; } 35 Expr l(r)
;;; } 34 ExpressionStatement
;;; } 33 List<do while Statement>
;-- pop 6 bytes
ADD SP, #6
;;; } 32 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 32 FunctionDefinition
;;; { 33 TypeName
;;; { 34 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 34 TypeSpecifier (all)
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = display_memory
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
;;; } 33 TypeName
;;; { 33 List<DeclItem>
;;; { 34 DeclItem
;;; what = DECL_NAME
;;; name = display_memory
;;; } 34 DeclItem
;;; { 34 DeclItem
;;; what = DECL_FUN
;;; { 35 List<ParameterDeclaration>
;;; { 36 ParameterDeclaration
;;; isEllipsis = false
;;; { 37 TypeName
;;; { 38 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 38 TypeSpecifier (all)
;;; { 38 List<DeclItem>
;;; { 39 DeclItem
;;; what = DECL_POINTER
;;; { 40 List<Ptr>
;;; { 41 Ptr
;;; } 41 Ptr
;;; } 40 List<Ptr>
;;; } 39 DeclItem
;;; { 39 DeclItem
;;; what = DECL_NAME
;;; name = address
;;; } 39 DeclItem
;;; } 38 List<DeclItem>
;;; } 37 TypeName
;;; } 36 ParameterDeclaration
;;; } 35 List<ParameterDeclaration>
;;; } 34 DeclItem
;;; } 33 List<DeclItem>
Cdisplay_memory:
;;; { 33 CompoundStatement
;;; { 34 InitDeclarator
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;-- push_zero 1 bytes
CLRB -(SP)
;;; } 34 InitDeclarator
;;; { 34 InitDeclarator
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = row
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 34 InitDeclarator
;;; { 34 InitDeclarator
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = col
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 34 InitDeclarator
;;; { 34 List<for Statement>
;;; { 35 for Statement
;;; { 36 ExpressionStatement
;;; { 37 Expr l = r
;;; { 38 TypeName
;;; { 39 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 39 TypeSpecifier (all)
;;; { 39 List<DeclItem>
;;; { 40 DeclItem
;;; what = DECL_NAME
;;; name = row
;;; } 40 DeclItem
;;; } 39 List<DeclItem>
;;; } 38 TypeName
;;; { 38 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 38 NumericExpression (constant 0 = 0x0)
;-- store_rr_var row = -3(FP), SP at -5
MOVE RR, 2(SP)
;;; } 37 Expr l = r
;;; } 36 ExpressionStatement
;-- branch
JMP L34_tst_101
L34_loop_101:
;;; { 36 CompoundStatement
;;; { 37 List<ExpressionStatement>
;;; { 38 ExpressionStatement
;;; { 39 Expr l(r)
;;; { 40 TypeName
;;; { 41 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 41 TypeSpecifier (all)
;;; { 41 List<DeclItem>
;;; { 42 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 42 DeclItem
;;; } 41 List<DeclItem>
;;; } 40 TypeName
;;; { 40 Expr (l , r)
;;; { 41 ParameterDeclaration
;;; isEllipsis = true
;;; { 42 TypeName
;;; { 43 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 43 TypeSpecifier (all)
;;; { 43 List<DeclItem>
;;; { 44 DeclItem
;;; what = DECL_POINTER
;;; { 45 List<Ptr>
;;; { 46 Ptr
;;; } 46 Ptr
;;; } 45 List<Ptr>
;;; } 44 DeclItem
;;; { 44 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 44 DeclItem
;;; } 43 List<DeclItem>
;;; } 42 TypeName
;;; } 41 ParameterDeclaration
;;; { 41 Expression (variable name)
;;; expr_type = "identifier" (address)
;-- load_rr_var address = 2(FP), SP at -5 (16 bit)
MOVE 7(SP), RR
;;; } 41 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 41 ParameterDeclaration
;;; isEllipsis = true
;;; { 42 TypeName
;;; { 43 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 43 TypeSpecifier (all)
;;; { 43 List<DeclItem>
;;; { 44 DeclItem
;;; what = DECL_POINTER
;;; { 45 List<Ptr>
;;; { 46 Ptr
;;; } 46 Ptr
;;; } 45 List<Ptr>
;;; } 44 DeclItem
;;; { 44 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 44 DeclItem
;;; } 43 List<DeclItem>
;;; } 42 TypeName
;;; } 41 ParameterDeclaration
;;; { 41 StringExpression
;-- load_rr_string
MOVE #Cstr_72, RR
;;; } 41 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 40 Expr (l , r)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 4 bytes
ADD SP, #4
;;; } 39 Expr l(r)
;;; } 38 ExpressionStatement
;;; { 38 for Statement
;;; { 39 ExpressionStatement
;;; { 40 Expr l = r
;;; { 41 TypeName
;;; { 42 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 42 TypeSpecifier (all)
;;; { 42 List<DeclItem>
;;; { 43 DeclItem
;;; what = DECL_NAME
;;; name = col
;;; } 43 DeclItem
;;; } 42 List<DeclItem>
;;; } 41 TypeName
;;; { 41 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 41 NumericExpression (constant 0 = 0x0)
;-- store_rr_var col = -5(FP), SP at -5
MOVE RR, 0(SP)
;;; } 40 Expr l = r
;;; } 39 ExpressionStatement
;-- branch
JMP L34_tst_103
L34_loop_103:
;;; { 39 ExpressionStatement
;;; { 40 Expr l(r)
;;; { 41 TypeName
;;; { 42 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 42 TypeSpecifier (all)
;;; { 42 List<DeclItem>
;;; { 43 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 43 DeclItem
;;; } 42 List<DeclItem>
;;; } 41 TypeName
;;; { 41 Expr (l , r)
;;; { 42 ParameterDeclaration
;;; isEllipsis = true
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_POINTER
;;; { 46 List<Ptr>
;;; { 47 Ptr
;;; } 47 Ptr
;;; } 46 List<Ptr>
;;; } 45 DeclItem
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; } 42 ParameterDeclaration
;;; { 42 Expr * r
;;; { 43 Expr l - r
;;; { 44 Expr ++r
;;; { 45 Expression (variable name)
;;; expr_type = "identifier" (address)
;-- load_rr_var address = 2(FP), SP at -5 (16 bit)
MOVE 7(SP), RR
;;; } 45 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var address = 2(FP), SP at -5
MOVE RR, 7(SP)
;;; } 44 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 43 Expr l - r
;-- content
MOVE (RR), RU
;;; } 42 Expr * r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 42 ParameterDeclaration
;;; isEllipsis = true
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_POINTER
;;; { 46 List<Ptr>
;;; { 47 Ptr
;;; } 47 Ptr
;;; } 46 List<Ptr>
;;; } 45 DeclItem
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; } 42 ParameterDeclaration
;;; { 42 StringExpression
;-- load_rr_string
MOVE #Cstr_73, RR
;;; } 42 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 41 Expr (l , r)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 4 bytes
ADD SP, #4
;;; } 40 Expr l(r)
;;; } 39 ExpressionStatement
L34_cont_103:
;;; { 39 Expr l - r
;;; { 40 Expr ++r
;;; { 41 Expression (variable name)
;;; expr_type = "identifier" (col)
;-- load_rr_var col = -5(FP), SP at -5 (16 bit)
MOVE 0(SP), RR
;;; } 41 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var col = -5(FP), SP at -5
MOVE RR, 0(SP)
;;; } 40 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 39 Expr l - r
L34_tst_103:
;;; { 39 Expr l < r
;;; { 40 TypeName (internal)
;;; { 41 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 41 TypeSpecifier (all)
;;; } 40 TypeName (internal)
;;; { 40 Expression (variable name)
;;; expr_type = "identifier" (col)
;-- load_rr_var col = -5(FP), SP at -5 (16 bit)
MOVE 0(SP), RR
;;; } 40 Expression (variable name)
;-- l < r
SLT RR, #0x0010
;;; } 39 Expr l < r
;-- branch_true
JMP RRNZ, L34_loop_103
L34_brk_104:
;;; } 38 for Statement
;;; { 38 ExpressionStatement
;;; { 39 Expr l -= r
;;; { 40 TypeName
;;; { 41 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 41 TypeSpecifier (all)
;;; { 41 List<DeclItem>
;;; { 42 DeclItem
;;; what = DECL_POINTER
;;; { 43 List<Ptr>
;;; { 44 Ptr
;;; } 44 Ptr
;;; } 43 List<Ptr>
;;; } 42 DeclItem
;;; { 42 DeclItem
;;; what = DECL_NAME
;;; name = address
;;; } 42 DeclItem
;;; } 41 List<DeclItem>
;;; } 40 TypeName
;;; { 40 Expr l - r
;;; { 41 Expression (variable name)
;;; expr_type = "identifier" (address)
;-- load_rr_var address = 2(FP), SP at -5 (16 bit)
MOVE 7(SP), RR
;;; } 41 Expression (variable name)
;-- l - r
SUB RR, #0x0010
;;; } 40 Expr l - r
;-- store_rr_var address = 2(FP), SP at -5
MOVE RR, 7(SP)
;;; } 39 Expr l -= r
;;; } 38 ExpressionStatement
;;; { 38 ExpressionStatement
;;; { 39 Expr l(r)
;;; { 40 TypeName
;;; { 41 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 41 TypeSpecifier (all)
;;; { 41 List<DeclItem>
;;; { 42 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 42 DeclItem
;;; } 41 List<DeclItem>
;;; } 40 TypeName
;;; { 40 ParameterDeclaration
;;; isEllipsis = true
;;; { 41 TypeName
;;; { 42 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 42 TypeSpecifier (all)
;;; { 42 List<DeclItem>
;;; { 43 DeclItem
;;; what = DECL_POINTER
;;; { 44 List<Ptr>
;;; { 45 Ptr
;;; } 45 Ptr
;;; } 44 List<Ptr>
;;; } 43 DeclItem
;;; { 43 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 43 DeclItem
;;; } 42 List<DeclItem>
;;; } 41 TypeName
;;; } 40 ParameterDeclaration
;;; { 40 StringExpression
;-- load_rr_string
MOVE #Cstr_74, RR
;;; } 40 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 39 Expr l(r)
;;; } 38 ExpressionStatement
;;; { 38 for Statement
;;; { 39 ExpressionStatement
;;; { 40 Expr l = r
;;; { 41 TypeName
;;; { 42 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 42 TypeSpecifier (all)
;;; { 42 List<DeclItem>
;;; { 43 DeclItem
;;; what = DECL_NAME
;;; name = col
;;; } 43 DeclItem
;;; } 42 List<DeclItem>
;;; } 41 TypeName
;;; { 41 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 41 NumericExpression (constant 0 = 0x0)
;-- store_rr_var col = -5(FP), SP at -5
MOVE RR, 0(SP)
;;; } 40 Expr l = r
;;; } 39 ExpressionStatement
;-- branch
JMP L34_tst_105
L34_loop_105:
;;; { 39 CompoundStatement
;;; { 40 List<ExpressionStatement>
;;; { 41 ExpressionStatement
;;; { 42 Expr l = r
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; { 43 Expr * r
;;; { 44 Expr l - r
;;; { 45 Expr ++r
;;; { 46 Expression (variable name)
;;; expr_type = "identifier" (address)
;-- load_rr_var address = 2(FP), SP at -5 (16 bit)
MOVE 7(SP), RR
;;; } 46 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var address = 2(FP), SP at -5
MOVE RR, 7(SP)
;;; } 45 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 44 Expr l - r
;-- content
MOVE (RR), RU
;;; } 43 Expr * r
;-- store_rr_var c = -1(FP), SP at -5
MOVE R, 4(SP)
;;; } 42 Expr l = r
;;; } 41 ExpressionStatement
;;; { 41 IfElseStatement
;;; { 42 Expr l < r
;;; { 43 TypeName (internal)
;;; { 44 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 44 TypeSpecifier (all)
;;; } 43 TypeName (internal)
;;; { 43 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -1(FP), SP at -5 (8 bit)
MOVE 4(SP), RS
;;; } 43 Expression (variable name)
;-- l < r
SLT RR, #0x0020
;;; } 42 Expr l < r
;-- branch_false
JMP RRZ, L34_else_107
;;; { 42 ExpressionStatement
;;; { 43 Expr l(r)
;;; { 44 TypeName
;;; { 45 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 45 TypeSpecifier (all)
;;; { 45 List<DeclItem>
;;; { 46 DeclItem
;;; what = DECL_NAME
;;; name = putchr
;;; } 46 DeclItem
;;; } 45 List<DeclItem>
;;; } 44 TypeName
;;; { 44 ParameterDeclaration
;;; isEllipsis = false
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; } 44 ParameterDeclaration
;;; { 44 NumericExpression (constant 46 = 0x2E)
;-- load_rr_constant
MOVE #0x002E, RR
;;; } 44 NumericExpression (constant 46 = 0x2E)
;-- push_rr (8 bit)
MOVE R, -(SP)
;-- push 2 bytes
;-- call
CALL Cputchr
;-- pop 1 bytes
ADD SP, #1
;;; } 43 Expr l(r)
;;; } 42 ExpressionStatement
;-- branch
JMP L34_endif_107
L34_else_107:
;;; { 42 IfElseStatement
;;; { 43 Expr l < r
;;; { 44 TypeName (internal)
;;; { 45 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 45 TypeSpecifier (all)
;;; } 44 TypeName (internal)
;;; { 44 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -1(FP), SP at -5 (8 bit)
MOVE 4(SP), RS
;;; } 44 Expression (variable name)
;-- l < r
SLT RR, #0x007F
;;; } 43 Expr l < r
;-- branch_false
JMP RRZ, L34_else_108
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = putchr
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 ParameterDeclaration
;;; isEllipsis = false
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; } 45 ParameterDeclaration
;;; { 45 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -1(FP), SP at -5 (8 bit)
MOVE 4(SP), RS
;;; } 45 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;-- push 2 bytes
;-- call
CALL Cputchr
;-- pop 1 bytes
ADD SP, #1
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
;-- branch
JMP L34_endif_108
L34_else_108:
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = putchr
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 ParameterDeclaration
;;; isEllipsis = false
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; } 45 ParameterDeclaration
;;; { 45 NumericExpression (constant 46 = 0x2E)
;-- load_rr_constant
MOVE #0x002E, RR
;;; } 45 NumericExpression (constant 46 = 0x2E)
;-- push_rr (8 bit)
MOVE R, -(SP)
;-- push 2 bytes
;-- call
CALL Cputchr
;-- pop 1 bytes
ADD SP, #1
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
L34_endif_108:
;;; } 42 IfElseStatement
L34_endif_107:
;;; } 41 IfElseStatement
;;; } 40 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 39 CompoundStatement
L34_cont_105:
;;; { 39 Expr l - r
;;; { 40 Expr ++r
;;; { 41 Expression (variable name)
;;; expr_type = "identifier" (col)
;-- load_rr_var col = -5(FP), SP at -5 (16 bit)
MOVE 0(SP), RR
;;; } 41 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var col = -5(FP), SP at -5
MOVE RR, 0(SP)
;;; } 40 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 39 Expr l - r
L34_tst_105:
;;; { 39 Expr l < r
;;; { 40 TypeName (internal)
;;; { 41 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 41 TypeSpecifier (all)
;;; } 40 TypeName (internal)
;;; { 40 Expression (variable name)
;;; expr_type = "identifier" (col)
;-- load_rr_var col = -5(FP), SP at -5 (16 bit)
MOVE 0(SP), RR
;;; } 40 Expression (variable name)
;-- l < r
SLT RR, #0x0010
;;; } 39 Expr l < r
;-- branch_true
JMP RRNZ, L34_loop_105
L34_brk_106:
;;; } 38 for Statement
;;; { 38 ExpressionStatement
;;; { 39 Expr l(r)
;;; { 40 TypeName
;;; { 41 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 41 TypeSpecifier (all)
;;; { 41 List<DeclItem>
;;; { 42 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 42 DeclItem
;;; } 41 List<DeclItem>
;;; } 40 TypeName
;;; { 40 ParameterDeclaration
;;; isEllipsis = true
;;; { 41 TypeName
;;; { 42 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 42 TypeSpecifier (all)
;;; { 42 List<DeclItem>
;;; { 43 DeclItem
;;; what = DECL_POINTER
;;; { 44 List<Ptr>
;;; { 45 Ptr
;;; } 45 Ptr
;;; } 44 List<Ptr>
;;; } 43 DeclItem
;;; { 43 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 43 DeclItem
;;; } 42 List<DeclItem>
;;; } 41 TypeName
;;; } 40 ParameterDeclaration
;;; { 40 StringExpression
;-- load_rr_string
MOVE #Cstr_75, RR
;;; } 40 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 39 Expr l(r)
;;; } 38 ExpressionStatement
;;; } 37 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 36 CompoundStatement
L34_cont_101:
;;; { 36 Expr l - r
;;; { 37 Expr ++r
;;; { 38 Expression (variable name)
;;; expr_type = "identifier" (row)
;-- load_rr_var row = -3(FP), SP at -5 (16 bit)
MOVE 2(SP), RR
;;; } 38 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var row = -3(FP), SP at -5
MOVE RR, 2(SP)
;;; } 37 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 36 Expr l - r
L34_tst_101:
;;; { 36 Expr l < r
;;; { 37 TypeName (internal)
;;; { 38 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 38 TypeSpecifier (all)
;;; } 37 TypeName (internal)
;;; { 37 Expression (variable name)
;;; expr_type = "identifier" (row)
;-- load_rr_var row = -3(FP), SP at -5 (16 bit)
MOVE 2(SP), RR
;;; } 37 Expression (variable name)
;-- l < r
SLT RR, #0x0010
;;; } 36 Expr l < r
;-- branch_true
JMP RRNZ, L34_loop_101
L34_brk_102:
;;; } 35 for Statement
;;; } 34 List<for Statement>
;-- pop 5 bytes
ADD SP, #5
;;; } 33 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 33 FunctionDefinition
;;; { 34 TypeName
;;; { 35 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 35 TypeSpecifier (all)
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = main
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
;;; } 34 TypeName
;;; { 34 List<DeclItem>
;;; { 35 DeclItem
;;; what = DECL_NAME
;;; name = main
;;; } 35 DeclItem
;;; { 35 DeclItem
;;; what = DECL_FUN
;;; } 35 DeclItem
;;; } 34 List<DeclItem>
Cmain:
;;; { 34 CompoundStatement
;;; { 35 InitDeclarator
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = i
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 35 InitDeclarator
;;; { 35 List<ExpressionStatement>
;;; { 36 ExpressionStatement
;;; { 37 Expr l(r)
;;; { 38 TypeName
;;; { 39 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 39 TypeSpecifier (all)
;;; { 39 List<DeclItem>
;;; { 40 DeclItem
;;; what = DECL_NAME
;;; name = init_unused
;;; } 40 DeclItem
;;; } 39 List<DeclItem>
;;; } 38 TypeName
;-- push 0 bytes
;-- call
CALL Cinit_unused
;-- pop 0 bytes
;;; } 37 Expr l(r)
;;; } 36 ExpressionStatement
;;; { 36 ExpressionStatement
;;; { 37 Expr l(r)
;;; { 38 TypeName
;;; { 39 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 39 TypeSpecifier (all)
;;; { 39 List<DeclItem>
;;; { 40 DeclItem
;;; what = DECL_NAME
;;; name = init_stack
;;; } 40 DeclItem
;;; } 39 List<DeclItem>
;;; } 38 TypeName
;-- push 0 bytes
;-- call
CALL Cinit_stack
;-- pop 0 bytes
;;; } 37 Expr l(r)
;;; } 36 ExpressionStatement
;;; { 36 ExpressionStatement
MOVE #0x00, RR
;;; } 36 ExpressionStatement
;;; { 36 ExpressionStatement
OUT R, (OUT_INT_MASK)
;;; } 36 ExpressionStatement
;;; { 36 for Statement
;;; { 37 ExpressionStatement
;;; { 38 Expr l = r
;;; { 39 TypeName
;;; { 40 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 40 TypeSpecifier (all)
;;; { 40 List<DeclItem>
;;; { 41 DeclItem
;;; what = DECL_NAME
;;; name = i
;;; } 41 DeclItem
;;; } 40 List<DeclItem>
;;; } 39 TypeName
;;; { 39 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 39 NumericExpression (constant 0 = 0x0)
;-- store_rr_var i = -2(FP), SP at -2
MOVE RR, 0(SP)
;;; } 38 Expr l = r
;;; } 37 ExpressionStatement
;-- branch
JMP L35_tst_109
L35_loop_109:
;;; { 37 ExpressionStatement
EI
;;; } 37 ExpressionStatement
L35_cont_109:
;;; { 37 Expr ++r
;;; { 38 Expression (variable name)
;;; expr_type = "identifier" (i)
;-- load_rr_var i = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 38 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var i = -2(FP), SP at -2
MOVE RR, 0(SP)
;;; } 37 Expr ++r
L35_tst_109:
;;; { 37 Expr l < r
;;; { 38 TypeName (internal)
;;; { 39 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 39 TypeSpecifier (all)
;;; } 38 TypeName (internal)
;;; { 38 Expression (variable name)
;;; expr_type = "identifier" (i)
;-- load_rr_var i = -2(FP), SP at -2 (16 bit)
MOVE 0(SP), RR
;;; } 38 Expression (variable name)
;-- l < r
SLT RR, #0x0010
;;; } 37 Expr l < r
;-- branch_true
JMP RRNZ, L35_loop_109
L35_brk_110:
;;; } 36 for Statement
;;; { 36 ExpressionStatement
MOVE #0x05, RR
;;; } 36 ExpressionStatement
;;; { 36 ExpressionStatement
OUT R, (OUT_INT_MASK)
;;; } 36 ExpressionStatement
;;; { 36 ExpressionStatement
;;; { 37 Expr l(r)
;;; { 38 TypeName
;;; { 39 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 39 TypeSpecifier (all)
;;; { 39 List<DeclItem>
;;; { 40 DeclItem
;;; what = DECL_NAME
;;; name = deschedule
;;; } 40 DeclItem
;;; } 39 List<DeclItem>
;;; } 38 TypeName
;-- push 0 bytes
;-- call
CALL Cdeschedule
;-- pop 0 bytes
;;; } 37 Expr l(r)
;;; } 36 ExpressionStatement
;;; { 36 for Statement
;;; { 37 ExpressionStatement
;;; } 37 ExpressionStatement
L35_loop_111:
;;; { 37 ExpressionStatement
HALT
;;; } 37 ExpressionStatement
L35_cont_111:
;-- branch
JMP L35_loop_111
L35_brk_112:
;;; } 36 for Statement
;;; } 35 List<ExpressionStatement>
;-- pop 2 bytes
ADD SP, #2
;;; } 34 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 34 FunctionDefinition
;;; { 35 TypeName
;;; { 36 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 36 TypeSpecifier (all)
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = main_1
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
;;; } 35 TypeName
;;; { 35 List<DeclItem>
;;; { 36 DeclItem
;;; what = DECL_NAME
;;; name = main_1
;;; } 36 DeclItem
;;; { 36 DeclItem
;;; what = DECL_FUN
;;; { 37 List<ParameterDeclaration>
;;; { 38 ParameterDeclaration
;;; isEllipsis = false
;;; { 39 TypeName
;;; { 40 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 40 TypeSpecifier (all)
;;; { 40 List<DeclItem>
;;; { 41 DeclItem
;;; what = DECL_NAME
;;; name = argc
;;; } 41 DeclItem
;;; } 40 List<DeclItem>
;;; } 39 TypeName
;;; } 38 ParameterDeclaration
;;; { 38 ParameterDeclaration
;;; isEllipsis = false
;;; { 39 TypeName
;;; { 40 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 40 TypeSpecifier (all)
;;; { 40 List<DeclItem>
;;; { 41 DeclItem
;;; what = DECL_POINTER
;;; { 42 List<Ptr>
;;; { 43 Ptr
;;; } 43 Ptr
;;; } 42 List<Ptr>
;;; } 41 DeclItem
;;; { 41 DeclItem
;;; what = DECL_NAME
;;; name = argv
;;; } 41 DeclItem
;;; { 41 DeclItem
;;; what = DECL_ARRAY
;;; } 41 DeclItem
;;; } 40 List<DeclItem>
;;; } 39 TypeName
;;; } 38 ParameterDeclaration
;;; } 37 List<ParameterDeclaration>
;;; } 36 DeclItem
;;; } 35 List<DeclItem>
Cmain_1:
;;; { 35 CompoundStatement
;;; { 36 InitDeclarator
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 36 InitDeclarator
;;; { 36 InitDeclarator
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = last_c
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;-- push_zero 1 bytes
CLRB -(SP)
;;; } 36 InitDeclarator
;;; { 36 InitDeclarator
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_POINTER
;;; { 39 List<Ptr>
;;; { 40 Ptr
;;; } 40 Ptr
;;; } 39 List<Ptr>
;;; } 38 DeclItem
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = address
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 36 InitDeclarator
;;; { 36 InitDeclarator
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = value
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 36 InitDeclarator
;;; { 36 List<ExpressionStatement>
;;; { 37 ExpressionStatement
EI
;;; } 37 ExpressionStatement
;;; { 37 ExpressionStatement
;;; { 38 Expr l(r)
;;; { 39 TypeName
;;; { 40 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 40 TypeSpecifier (all)
;;; { 40 List<DeclItem>
;;; { 41 DeclItem
;;; what = DECL_NAME
;;; name = init_stack
;;; } 41 DeclItem
;;; } 40 List<DeclItem>
;;; } 39 TypeName
;-- push 0 bytes
;-- call
CALL Cinit_stack
;-- pop 0 bytes
;;; } 38 Expr l(r)
;;; } 37 ExpressionStatement
;;; { 37 for Statement
;;; { 38 ExpressionStatement
;;; } 38 ExpressionStatement
L36_loop_113:
;;; { 38 CompoundStatement
;;; { 39 List<ExpressionStatement>
;;; { 40 ExpressionStatement
;;; { 41 Expr l(r)
;;; { 42 TypeName
;;; { 43 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 43 TypeSpecifier (all)
;;; { 43 List<DeclItem>
;;; { 44 DeclItem
;;; what = DECL_NAME
;;; name = P
;;; } 44 DeclItem
;;; } 43 List<DeclItem>
;;; } 42 TypeName
;;; { 42 ParameterDeclaration
;;; isEllipsis = false
;;; { 43 TypeName
;;; { 44 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 44 TypeSpecifier (struct/union)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_POINTER
;;; { 46 List<Ptr>
;;; { 47 Ptr
;;; } 47 Ptr
;;; } 46 List<Ptr>
;;; } 45 DeclItem
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; } 42 ParameterDeclaration
;;; { 42 Expr & r
;-- load_address serial_out
MOVE #Cserial_out, RR
;;; } 42 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CP
;-- pop 2 bytes
ADD SP, #2
;;; } 41 Expr l(r)
;;; } 40 ExpressionStatement
;;; { 40 ExpressionStatement
;;; { 41 Expr l(r)
;;; { 42 TypeName
;;; { 43 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 43 TypeSpecifier (all)
;;; { 43 List<DeclItem>
;;; { 44 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 44 DeclItem
;;; } 43 List<DeclItem>
;;; } 42 TypeName
;;; { 42 ParameterDeclaration
;;; isEllipsis = true
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_POINTER
;;; { 46 List<Ptr>
;;; { 47 Ptr
;;; } 47 Ptr
;;; } 46 List<Ptr>
;;; } 45 DeclItem
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; } 42 ParameterDeclaration
;;; { 42 StringExpression
;-- load_rr_string
MOVE #Cstr_83, RR
;;; } 42 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 41 Expr l(r)
;;; } 40 ExpressionStatement
;;; { 40 ExpressionStatement
;;; { 41 Expr l(r)
;;; { 42 TypeName
;;; { 43 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 43 TypeSpecifier (all)
;;; { 43 List<DeclItem>
;;; { 44 DeclItem
;;; what = DECL_NAME
;;; name = V
;;; } 44 DeclItem
;;; } 43 List<DeclItem>
;;; } 42 TypeName
;;; { 42 ParameterDeclaration
;;; isEllipsis = false
;;; { 43 TypeName
;;; { 44 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 44 TypeSpecifier (struct/union)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_POINTER
;;; { 46 List<Ptr>
;;; { 47 Ptr
;;; } 47 Ptr
;;; } 46 List<Ptr>
;;; } 45 DeclItem
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; } 42 ParameterDeclaration
;;; { 42 Expr & r
;-- load_address serial_out
MOVE #Cserial_out, RR
;;; } 42 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CV
;-- pop 2 bytes
ADD SP, #2
;;; } 41 Expr l(r)
;;; } 40 ExpressionStatement
;;; { 40 ExpressionStatement
;;; { 41 Expr l = r
;;; { 42 TypeName
;;; { 43 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 43 TypeSpecifier (all)
;;; { 43 List<DeclItem>
;;; { 44 DeclItem
;;; what = DECL_NAME
;;; name = last_c
;;; } 44 DeclItem
;;; } 43 List<DeclItem>
;;; } 42 TypeName
;;; { 42 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -2(FP), SP at -7 (16 bit)
MOVE 5(SP), RR
;;; } 42 Expression (variable name)
;-- store_rr_var last_c = -3(FP), SP at -7
MOVE R, 4(SP)
;;; } 41 Expr l = r
;;; } 40 ExpressionStatement
;;; { 40 ExpressionStatement
;;; { 41 Expr l = r
;;; { 42 TypeName
;;; { 43 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 43 TypeSpecifier (all)
;;; { 43 List<DeclItem>
;;; { 44 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 44 DeclItem
;;; } 43 List<DeclItem>
;;; } 42 TypeName
;;; { 42 Expr l(r)
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = getchr_timed
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; { 43 ParameterDeclaration
;;; isEllipsis = false
;;; { 44 TypeName
;;; { 45 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 45 TypeSpecifier (all)
;;; { 45 List<DeclItem>
;;; { 46 DeclItem
;;; what = DECL_NAME
;;; name = ticks
;;; } 46 DeclItem
;;; } 45 List<DeclItem>
;;; } 44 TypeName
;;; } 43 ParameterDeclaration
;;; { 43 NumericExpression (constant 60000 = 0xEA60)
;-- load_rr_constant
MOVE #0xEA60, RR
;;; } 43 NumericExpression (constant 60000 = 0xEA60)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cgetchr_timed
;-- pop 2 bytes
ADD SP, #2
;;; } 42 Expr l(r)
;-- store_rr_var c = -2(FP), SP at -7
MOVE RR, 5(SP)
;;; } 41 Expr l = r
;;; } 40 ExpressionStatement
;;; { 40 IfElseStatement
;;; { 41 Expr l == r
;;; { 42 TypeName (internal)
;;; { 43 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 43 TypeSpecifier (all)
;;; } 42 TypeName (internal)
;;; { 42 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -2(FP), SP at -7 (16 bit)
MOVE 5(SP), RR
;;; } 42 Expression (variable name)
;-- l == r
SEQ RR, #0xFFFF
;;; } 41 Expr l == r
;-- branch_false
JMP RRZ, L36_endif_115
;;; { 41 CompoundStatement
;;; { 42 List<ExpressionStatement>
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = P
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 ParameterDeclaration
;;; isEllipsis = false
;;; { 46 TypeName
;;; { 47 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 47 TypeSpecifier (struct/union)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_POINTER
;;; { 49 List<Ptr>
;;; { 50 Ptr
;;; } 50 Ptr
;;; } 49 List<Ptr>
;;; } 48 DeclItem
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; } 45 ParameterDeclaration
;;; { 45 Expr & r
;-- load_address serial_out
MOVE #Cserial_out, RR
;;; } 45 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CP
;-- pop 2 bytes
ADD SP, #2
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 Expr (l , r)
;;; { 46 ParameterDeclaration
;;; isEllipsis = true
;;; { 47 TypeName
;;; { 48 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 48 TypeSpecifier (all)
;;; { 48 List<DeclItem>
;;; { 49 DeclItem
;;; what = DECL_POINTER
;;; { 50 List<Ptr>
;;; { 51 Ptr
;;; } 51 Ptr
;;; } 50 List<Ptr>
;;; } 49 DeclItem
;;; { 49 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 49 DeclItem
;;; } 48 List<DeclItem>
;;; } 47 TypeName
;;; } 46 ParameterDeclaration
;;; { 46 Expr * r
;;; { 47 Expression (variable name)
;;; expr_type = "identifier" (current_task)
;-- load_rr_var current_task, (16 bit)
MOVE (Ccurrent_task), RR
;;; } 47 Expression (variable name)
;;; } 46 Expr * r
;-- + (member)
ADD RR, #0x0006
;-- content
MOVE (RR), RR
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 46 ParameterDeclaration
;;; isEllipsis = true
;;; { 47 TypeName
;;; { 48 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 48 TypeSpecifier (all)
;;; { 48 List<DeclItem>
;;; { 49 DeclItem
;;; what = DECL_POINTER
;;; { 50 List<Ptr>
;;; { 51 Ptr
;;; } 51 Ptr
;;; } 50 List<Ptr>
;;; } 49 DeclItem
;;; { 49 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 49 DeclItem
;;; } 48 List<DeclItem>
;;; } 47 TypeName
;;; } 46 ParameterDeclaration
;;; { 46 StringExpression
;-- load_rr_string
MOVE #Cstr_84, RR
;;; } 46 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 45 Expr (l , r)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 4 bytes
ADD SP, #4
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = V
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 ParameterDeclaration
;;; isEllipsis = false
;;; { 46 TypeName
;;; { 47 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 47 TypeSpecifier (struct/union)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_POINTER
;;; { 49 List<Ptr>
;;; { 50 Ptr
;;; } 50 Ptr
;;; } 49 List<Ptr>
;;; } 48 DeclItem
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; } 45 ParameterDeclaration
;;; { 45 Expr & r
;-- load_address serial_out
MOVE #Cserial_out, RR
;;; } 45 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CV
;-- pop 2 bytes
ADD SP, #2
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
;;; { 43 break/continue Statement
;-- branch
JMP L36_cont_113
;;; } 43 break/continue Statement
;;; } 42 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 41 CompoundStatement
L36_endif_115:
;;; } 40 IfElseStatement
;;; { 40 ExpressionStatement
;;; { 41 Expr l(r)
;;; { 42 TypeName
;;; { 43 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 43 TypeSpecifier (all)
;;; { 43 List<DeclItem>
;;; { 44 DeclItem
;;; what = DECL_NAME
;;; name = P
;;; } 44 DeclItem
;;; } 43 List<DeclItem>
;;; } 42 TypeName
;;; { 42 ParameterDeclaration
;;; isEllipsis = false
;;; { 43 TypeName
;;; { 44 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 44 TypeSpecifier (struct/union)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_POINTER
;;; { 46 List<Ptr>
;;; { 47 Ptr
;;; } 47 Ptr
;;; } 46 List<Ptr>
;;; } 45 DeclItem
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; } 42 ParameterDeclaration
;;; { 42 Expr & r
;-- load_address serial_out
MOVE #Cserial_out, RR
;;; } 42 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CP
;-- pop 2 bytes
ADD SP, #2
;;; } 41 Expr l(r)
;;; } 40 ExpressionStatement
;;; { 40 SwitchStatement
;;; { 41 Expression (variable name)
;;; expr_type = "identifier" (c)
;-- load_rr_var c = -2(FP), SP at -7 (16 bit)
MOVE 5(SP), RR
;;; } 41 Expression (variable name)
;-- move_rr_to_ll
MOVE RR, LL
;-- branch_case (16 bit)
SEQ LL, #0x000D
JMP RRNZ, L36_case_116_000D
;-- branch_case (16 bit)
SEQ LL, #0x000A
JMP RRNZ, L36_case_116_000A
;-- branch_case (16 bit)
SEQ LL, #0x0032
JMP RRNZ, L36_case_116_0032
;-- branch_case (16 bit)
SEQ LL, #0x0033
JMP RRNZ, L36_case_116_0033
;-- branch_case (16 bit)
SEQ LL, #0x0062
JMP RRNZ, L36_case_116_0062
;-- branch_case (16 bit)
SEQ LL, #0x0063
JMP RRNZ, L36_case_116_0063
;-- branch_case (16 bit)
SEQ LL, #0x0064
JMP RRNZ, L36_case_116_0064
;-- branch_case (16 bit)
SEQ LL, #0x0065
JMP RRNZ, L36_case_116_0065
;-- branch_case (16 bit)
SEQ LL, #0x006D
JMP RRNZ, L36_case_116_006D
;-- branch_case (16 bit)
SEQ LL, #0x0073
JMP RRNZ, L36_case_116_0073
;-- branch_case (16 bit)
SEQ LL, #0x0074
JMP RRNZ, L36_case_116_0074
;-- branch_case (16 bit)
SEQ LL, #0x0048
JMP RRNZ, L36_case_116_0048
;-- branch_case (16 bit)
SEQ LL, #0x0049
JMP RRNZ, L36_case_116_0049
;-- branch_case (16 bit)
SEQ LL, #0x0053
JMP RRNZ, L36_case_116_0053
;-- branch_case (16 bit)
SEQ LL, #0x0054
JMP RRNZ, L36_case_116_0054
;-- branch
JMP L36_deflt_116
;;; { 41 CompoundStatement
;;; { 42 List<case Statement>
;;; { 43 case Statement
L36_case_116_000D:
;;; { 44 case Statement
L36_case_116_000A:
;;; { 45 IfElseStatement
;;; { 46 Expr l == r
;;; { 47 TypeName (internal)
;;; { 48 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 48 TypeSpecifier (all)
;;; } 47 TypeName (internal)
;;; { 47 Expression (variable name)
;;; expr_type = "identifier" (last_c)
;-- load_rr_var last_c = -3(FP), SP at -7 (8 bit)
MOVE 4(SP), RS
;;; } 47 Expression (variable name)
;-- l == r
SEQ RR, #0x0064
;;; } 46 Expr l == r
;-- branch_false
JMP RRZ, L36_endif_117
;;; { 46 CompoundStatement
;;; { 47 List<ExpressionStatement>
;;; { 48 ExpressionStatement
;;; { 49 Expr l += r
;;; { 50 TypeName
;;; { 51 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 51 TypeSpecifier (all)
;;; { 51 List<DeclItem>
;;; { 52 DeclItem
;;; what = DECL_POINTER
;;; { 53 List<Ptr>
;;; { 54 Ptr
;;; } 54 Ptr
;;; } 53 List<Ptr>
;;; } 52 DeclItem
;;; { 52 DeclItem
;;; what = DECL_NAME
;;; name = address
;;; } 52 DeclItem
;;; } 51 List<DeclItem>
;;; } 50 TypeName
;;; { 50 Expr l + r
;;; { 51 Expression (variable name)
;;; expr_type = "identifier" (address)
;-- load_rr_var address = -5(FP), SP at -7 (16 bit)
MOVE 2(SP), RR
;;; } 51 Expression (variable name)
;-- l + r
ADD RR, #0x0100
;;; } 50 Expr l + r
;-- store_rr_var address = -5(FP), SP at -7
MOVE RR, 2(SP)
;;; } 49 Expr l += r
;;; } 48 ExpressionStatement
;;; { 48 ExpressionStatement
;;; { 49 Expr l(r)
;;; { 50 TypeName
;;; { 51 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 51 TypeSpecifier (all)
;;; { 51 List<DeclItem>
;;; { 52 DeclItem
;;; what = DECL_NAME
;;; name = putchr
;;; } 52 DeclItem
;;; } 51 List<DeclItem>
;;; } 50 TypeName
;;; { 50 ParameterDeclaration
;;; isEllipsis = false
;;; { 51 TypeName
;;; { 52 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 52 TypeSpecifier (all)
;;; { 52 List<DeclItem>
;;; { 53 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 53 DeclItem
;;; } 52 List<DeclItem>
;;; } 51 TypeName
;;; } 50 ParameterDeclaration
;;; { 50 NumericExpression (constant 13 = 0xD)
;-- load_rr_constant
MOVE #0x000D, RR
;;; } 50 NumericExpression (constant 13 = 0xD)
;-- push_rr (8 bit)
MOVE R, -(SP)
;-- push 2 bytes
;-- call
CALL Cputchr
;-- pop 1 bytes
ADD SP, #1
;;; } 49 Expr l(r)
;;; } 48 ExpressionStatement
;;; { 48 ExpressionStatement
;;; { 49 Expr l(r)
;;; { 50 TypeName
;;; { 51 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 51 TypeSpecifier (all)
;;; { 51 List<DeclItem>
;;; { 52 DeclItem
;;; what = DECL_NAME
;;; name = display_memory
;;; } 52 DeclItem
;;; } 51 List<DeclItem>
;;; } 50 TypeName
;;; { 50 ParameterDeclaration
;;; isEllipsis = false
;;; { 51 TypeName
;;; { 52 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 52 TypeSpecifier (all)
;;; { 52 List<DeclItem>
;;; { 53 DeclItem
;;; what = DECL_POINTER
;;; { 54 List<Ptr>
;;; { 55 Ptr
;;; } 55 Ptr
;;; } 54 List<Ptr>
;;; } 53 DeclItem
;;; { 53 DeclItem
;;; what = DECL_NAME
;;; name = address
;;; } 53 DeclItem
;;; } 52 List<DeclItem>
;;; } 51 TypeName
;;; } 50 ParameterDeclaration
;;; { 50 Expression (variable name)
;;; expr_type = "identifier" (address)
;-- load_rr_var address = -5(FP), SP at -7 (16 bit)
MOVE 2(SP), RR
;;; } 50 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL Cdisplay_memory
;-- pop 2 bytes
ADD SP, #2
;;; } 49 Expr l(r)
;;; } 48 ExpressionStatement
;;; { 48 ExpressionStatement
;;; { 49 Expr l = r
;;; { 50 TypeName
;;; { 51 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 51 TypeSpecifier (all)
;;; { 51 List<DeclItem>
;;; { 52 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 52 DeclItem
;;; } 51 List<DeclItem>
;;; } 50 TypeName
;;; { 50 NumericExpression (constant 100 = 0x64)
;-- load_rr_constant
MOVE #0x0064, RR
;;; } 50 NumericExpression (constant 100 = 0x64)
;-- store_rr_var c = -2(FP), SP at -7
MOVE RR, 5(SP)
;;; } 49 Expr l = r
;;; } 48 ExpressionStatement
;;; } 47 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 46 CompoundStatement
L36_endif_117:
;;; } 45 IfElseStatement
;;; } 44 case Statement
;;; } 43 case Statement
;;; { 43 break/continue Statement
;-- branch
JMP L36_brk_116
;;; } 43 break/continue Statement
;;; { 43 case Statement
L36_case_116_0032:
;;; { 44 ExpressionStatement
;;; { 45 Expr l(r)
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = V
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; { 46 ParameterDeclaration
;;; isEllipsis = false
;;; { 47 TypeName
;;; { 48 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 48 TypeSpecifier (struct/union)
;;; { 48 List<DeclItem>
;;; { 49 DeclItem
;;; what = DECL_POINTER
;;; { 50 List<Ptr>
;;; { 51 Ptr
;;; } 51 Ptr
;;; } 50 List<Ptr>
;;; } 49 DeclItem
;;; { 49 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 49 DeclItem
;;; } 48 List<DeclItem>
;;; } 47 TypeName
;;; } 46 ParameterDeclaration
;;; { 46 Expr & r
;-- load_address t2_control
MOVE #Ct2_control, RR
;;; } 46 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CV
;-- pop 2 bytes
ADD SP, #2
;;; } 45 Expr l(r)
;;; } 44 ExpressionStatement
;;; } 43 case Statement
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 ParameterDeclaration
;;; isEllipsis = true
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_POINTER
;;; { 49 List<Ptr>
;;; { 50 Ptr
;;; } 50 Ptr
;;; } 49 List<Ptr>
;;; } 48 DeclItem
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; } 45 ParameterDeclaration
;;; { 45 StringExpression
;-- load_rr_string
MOVE #Cstr_85, RR
;;; } 45 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
;;; { 43 break/continue Statement
;-- branch
JMP L36_brk_116
;;; } 43 break/continue Statement
;;; { 43 case Statement
L36_case_116_0033:
;;; { 44 ExpressionStatement
;;; { 45 Expr l(r)
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = V
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; { 46 ParameterDeclaration
;;; isEllipsis = false
;;; { 47 TypeName
;;; { 48 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 48 TypeSpecifier (struct/union)
;;; { 48 List<DeclItem>
;;; { 49 DeclItem
;;; what = DECL_POINTER
;;; { 50 List<Ptr>
;;; { 51 Ptr
;;; } 51 Ptr
;;; } 50 List<Ptr>
;;; } 49 DeclItem
;;; { 49 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 49 DeclItem
;;; } 48 List<DeclItem>
;;; } 47 TypeName
;;; } 46 ParameterDeclaration
;;; { 46 Expr & r
;-- load_address t3_control
MOVE #Ct3_control, RR
;;; } 46 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CV
;-- pop 2 bytes
ADD SP, #2
;;; } 45 Expr l(r)
;;; } 44 ExpressionStatement
;;; } 43 case Statement
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = sleep
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 ParameterDeclaration
;;; isEllipsis = false
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = millisecs
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; } 45 ParameterDeclaration
;;; { 45 NumericExpression (constant 100 = 0x64)
;-- load_rr_constant
MOVE #0x0064, RR
;;; } 45 NumericExpression (constant 100 = 0x64)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL Csleep
;-- pop 2 bytes
ADD SP, #2
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = P
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 ParameterDeclaration
;;; isEllipsis = false
;;; { 46 TypeName
;;; { 47 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 47 TypeSpecifier (struct/union)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_POINTER
;;; { 49 List<Ptr>
;;; { 50 Ptr
;;; } 50 Ptr
;;; } 49 List<Ptr>
;;; } 48 DeclItem
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; } 45 ParameterDeclaration
;;; { 45 Expr & r
;-- load_address t3_control
MOVE #Ct3_control, RR
;;; } 45 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CP
;-- pop 2 bytes
ADD SP, #2
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 ParameterDeclaration
;;; isEllipsis = true
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_POINTER
;;; { 49 List<Ptr>
;;; { 50 Ptr
;;; } 50 Ptr
;;; } 49 List<Ptr>
;;; } 48 DeclItem
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; } 45 ParameterDeclaration
;;; { 45 StringExpression
;-- load_rr_string
MOVE #Cstr_86, RR
;;; } 45 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
;;; { 43 break/continue Statement
;-- branch
JMP L36_brk_116
;;; } 43 break/continue Statement
;;; { 43 case Statement
L36_case_116_0062:
;;; { 44 ExpressionStatement
;;; { 45 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 45 NumericExpression (constant 0 = 0x0)
;;; } 44 ExpressionStatement
;;; } 43 case Statement
;;; { 43 ExpressionStatement
OUT R, (OUT_START_CLK_CTR)
;;; } 43 ExpressionStatement
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = deschedule
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;-- push 0 bytes
;-- call
CALL Cdeschedule
;-- pop 0 bytes
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
;;; { 43 ExpressionStatement
OUT R, (OUT_STOP_CLK_CTR)
;;; } 43 ExpressionStatement
;;; { 43 ExpressionStatement
;;; { 44 Expr l = r
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = value
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 Expr l | r
;;; { 46 TypeName (internal)
;;; { 47 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 47 TypeSpecifier (all)
;;; } 46 TypeName (internal)
;;; { 46 Expr l << r
;;; { 47 TypeName (internal)
;;; { 48 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 48 TypeSpecifier (all)
;;; } 47 TypeName (internal)
IN (IN_CLK_CTR_HIGH), RU
;-- l << r
LSL RR, #0x0008
;;; } 46 Expr l << r
;-- push_rr (16 bit)
MOVE RR, -(SP)
IN (IN_CLK_CTR_LOW), RU
;-- pop_ll (16 bit)
MOVE (SP)+, LL
;-- l | r
OR LL, RR
;;; } 45 Expr l | r
;-- store_rr_var value = -7(FP), SP at -7
MOVE RR, 0(SP)
;;; } 44 Expr l = r
;;; } 43 ExpressionStatement
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 Expr (l , r)
;;; { 46 ParameterDeclaration
;;; isEllipsis = true
;;; { 47 TypeName
;;; { 48 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 48 TypeSpecifier (all)
;;; { 48 List<DeclItem>
;;; { 49 DeclItem
;;; what = DECL_POINTER
;;; { 50 List<Ptr>
;;; { 51 Ptr
;;; } 51 Ptr
;;; } 50 List<Ptr>
;;; } 49 DeclItem
;;; { 49 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 49 DeclItem
;;; } 48 List<DeclItem>
;;; } 47 TypeName
;;; } 46 ParameterDeclaration
;;; { 46 Expr l / r
;;; { 47 TypeName (internal)
;;; { 48 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 48 TypeSpecifier (all)
;;; } 47 TypeName (internal)
;;; { 47 Expr l + r
;;; { 48 Expression (variable name)
;;; expr_type = "identifier" (value)
;-- load_rr_var value = -7(FP), SP at -7 (16 bit)
MOVE 0(SP), RR
;;; } 48 Expression (variable name)
;-- l + r
ADD RR, #0x000A
;;; } 47 Expr l + r
;-- l / r
MOVE RR, LL
MOVE #0x0014, RR
;-- l / r
DI
DIV_IS
CALL mult_div
MD_FIN
EI
;;; } 46 Expr l / r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 46 Expr (l , r)
;;; { 47 ParameterDeclaration
;;; isEllipsis = true
;;; { 48 TypeName
;;; { 49 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 49 TypeSpecifier (all)
;;; { 49 List<DeclItem>
;;; { 50 DeclItem
;;; what = DECL_POINTER
;;; { 51 List<Ptr>
;;; { 52 Ptr
;;; } 52 Ptr
;;; } 51 List<Ptr>
;;; } 50 DeclItem
;;; { 50 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 50 DeclItem
;;; } 49 List<DeclItem>
;;; } 48 TypeName
;;; } 47 ParameterDeclaration
;;; { 47 Expression (variable name)
;;; expr_type = "identifier" (value)
;-- load_rr_var value = -7(FP), SP at -9 (16 bit)
MOVE 2(SP), RR
;;; } 47 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 47 ParameterDeclaration
;;; isEllipsis = true
;;; { 48 TypeName
;;; { 49 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 49 TypeSpecifier (all)
;;; { 49 List<DeclItem>
;;; { 50 DeclItem
;;; what = DECL_POINTER
;;; { 51 List<Ptr>
;;; { 52 Ptr
;;; } 52 Ptr
;;; } 51 List<Ptr>
;;; } 50 DeclItem
;;; { 50 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 50 DeclItem
;;; } 49 List<DeclItem>
;;; } 48 TypeName
;;; } 47 ParameterDeclaration
;;; { 47 StringExpression
;-- load_rr_string
MOVE #Cstr_91, RR
;;; } 47 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 46 Expr (l , r)
;;; } 45 Expr (l , r)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 6 bytes
ADD SP, #6
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
;;; { 43 break/continue Statement
;-- branch
JMP L36_brk_116
;;; } 43 break/continue Statement
;;; { 43 case Statement
L36_case_116_0063:
;;; { 44 ExpressionStatement
;;; { 45 Expr l(r)
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = show_time
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;-- push 0 bytes
;-- call
CALL Cshow_time
;-- pop 0 bytes
;;; } 45 Expr l(r)
;;; } 44 ExpressionStatement
;;; } 43 case Statement
;;; { 43 break/continue Statement
;-- branch
JMP L36_brk_116
;;; } 43 break/continue Statement
;;; { 43 case Statement
L36_case_116_0064:
;;; { 44 ExpressionStatement
;;; { 45 Expr l = r
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = last_c
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; { 46 NumericExpression (constant 100 = 0x64)
;-- load_rr_constant
MOVE #0x0064, RR
;;; } 46 NumericExpression (constant 100 = 0x64)
;-- store_rr_var last_c = -3(FP), SP at -7
MOVE R, 4(SP)
;;; } 45 Expr l = r
;;; } 44 ExpressionStatement
;;; } 43 case Statement
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 ParameterDeclaration
;;; isEllipsis = true
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_POINTER
;;; { 49 List<Ptr>
;;; { 50 Ptr
;;; } 50 Ptr
;;; } 49 List<Ptr>
;;; } 48 DeclItem
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; } 45 ParameterDeclaration
;;; { 45 StringExpression
;-- load_rr_string
MOVE #Cstr_92, RR
;;; } 45 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
;;; { 43 ExpressionStatement
;;; { 44 Expr l = r
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_POINTER
;;; { 48 List<Ptr>
;;; { 49 Ptr
;;; } 49 Ptr
;;; } 48 List<Ptr>
;;; } 47 DeclItem
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = address
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 Expression (cast)r
;;; { 46 Expr l(r)
;;; { 47 TypeName
;;; { 48 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 48 TypeSpecifier (all)
;;; { 48 List<DeclItem>
;;; { 49 DeclItem
;;; what = DECL_NAME
;;; name = gethex
;;; } 49 DeclItem
;;; } 48 List<DeclItem>
;;; } 47 TypeName
;;; { 47 ParameterDeclaration
;;; isEllipsis = false
;;; { 48 TypeName
;;; { 49 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 49 TypeSpecifier (all)
;;; { 49 List<DeclItem>
;;; { 50 DeclItem
;;; what = DECL_NAME
;;; name = echo
;;; } 50 DeclItem
;;; } 49 List<DeclItem>
;;; } 48 TypeName
;;; } 47 ParameterDeclaration
;;; { 47 NumericExpression (constant 1 = 0x1)
;-- load_rr_constant
MOVE #0x0001, RR
;;; } 47 NumericExpression (constant 1 = 0x1)
;-- push_rr (8 bit)
MOVE R, -(SP)
;-- push 2 bytes
;-- call
CALL Cgethex
;-- pop 1 bytes
ADD SP, #1
;;; } 46 Expr l(r)
;;; } 45 Expression (cast)r
;-- store_rr_var address = -5(FP), SP at -7
MOVE RR, 2(SP)
;;; } 44 Expr l = r
;;; } 43 ExpressionStatement
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 ParameterDeclaration
;;; isEllipsis = true
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_POINTER
;;; { 49 List<Ptr>
;;; { 50 Ptr
;;; } 50 Ptr
;;; } 49 List<Ptr>
;;; } 48 DeclItem
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; } 45 ParameterDeclaration
;;; { 45 StringExpression
;-- load_rr_string
MOVE #Cstr_93, RR
;;; } 45 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = getchr
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;-- push 2 bytes
;-- call
CALL Cgetchr
;-- pop 0 bytes
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = display_memory
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 ParameterDeclaration
;;; isEllipsis = false
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_POINTER
;;; { 49 List<Ptr>
;;; { 50 Ptr
;;; } 50 Ptr
;;; } 49 List<Ptr>
;;; } 48 DeclItem
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = address
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; } 45 ParameterDeclaration
;;; { 45 Expression (variable name)
;;; expr_type = "identifier" (address)
;-- load_rr_var address = -5(FP), SP at -7 (16 bit)
MOVE 2(SP), RR
;;; } 45 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL Cdisplay_memory
;-- pop 2 bytes
ADD SP, #2
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
;;; { 43 break/continue Statement
;-- branch
JMP L36_brk_116
;;; } 43 break/continue Statement
;;; { 43 case Statement
L36_case_116_0065:
;;; { 44 ExpressionStatement
;;; { 45 Expr l(r)
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; { 46 ParameterDeclaration
;;; isEllipsis = true
;;; { 47 TypeName
;;; { 48 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 48 TypeSpecifier (all)
;;; { 48 List<DeclItem>
;;; { 49 DeclItem
;;; what = DECL_POINTER
;;; { 50 List<Ptr>
;;; { 51 Ptr
;;; } 51 Ptr
;;; } 50 List<Ptr>
;;; } 49 DeclItem
;;; { 49 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 49 DeclItem
;;; } 48 List<DeclItem>
;;; } 47 TypeName
;;; } 46 ParameterDeclaration
;;; { 46 StringExpression
;-- load_rr_string
MOVE #Cstr_94, RR
;;; } 46 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 45 Expr l(r)
;;; } 44 ExpressionStatement
;;; } 43 case Statement
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = gethex
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 ParameterDeclaration
;;; isEllipsis = false
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = echo
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; } 45 ParameterDeclaration
;;; { 45 NumericExpression (constant 1 = 0x1)
;-- load_rr_constant
MOVE #0x0001, RR
;;; } 45 NumericExpression (constant 1 = 0x1)
;-- push_rr (8 bit)
MOVE R, -(SP)
;-- push 2 bytes
;-- call
CALL Cgethex
;-- pop 1 bytes
ADD SP, #1
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
;;; { 43 ExpressionStatement
OUT R, (OUT_LEDS)
;;; } 43 ExpressionStatement
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 ParameterDeclaration
;;; isEllipsis = true
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_POINTER
;;; { 49 List<Ptr>
;;; { 50 Ptr
;;; } 50 Ptr
;;; } 49 List<Ptr>
;;; } 48 DeclItem
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; } 45 ParameterDeclaration
;;; { 45 StringExpression
;-- load_rr_string
MOVE #Cstr_96, RR
;;; } 45 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = getchr
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;-- push 2 bytes
;-- call
CALL Cgetchr
;-- pop 0 bytes
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
;;; { 43 break/continue Statement
;-- branch
JMP L36_brk_116
;;; } 43 break/continue Statement
;;; { 43 case Statement
L36_case_116_006D:
;;; { 44 ExpressionStatement
;;; { 45 Expr l(r)
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; { 46 ParameterDeclaration
;;; isEllipsis = true
;;; { 47 TypeName
;;; { 48 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 48 TypeSpecifier (all)
;;; { 48 List<DeclItem>
;;; { 49 DeclItem
;;; what = DECL_POINTER
;;; { 50 List<Ptr>
;;; { 51 Ptr
;;; } 51 Ptr
;;; } 50 List<Ptr>
;;; } 49 DeclItem
;;; { 49 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 49 DeclItem
;;; } 48 List<DeclItem>
;;; } 47 TypeName
;;; } 46 ParameterDeclaration
;;; { 46 StringExpression
;-- load_rr_string
MOVE #Cstr_97, RR
;;; } 46 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 45 Expr l(r)
;;; } 44 ExpressionStatement
;;; } 43 case Statement
;;; { 43 ExpressionStatement
;;; { 44 Expr l = r
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_POINTER
;;; { 48 List<Ptr>
;;; { 49 Ptr
;;; } 49 Ptr
;;; } 48 List<Ptr>
;;; } 47 DeclItem
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = address
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 Expression (cast)r
;;; { 46 Expr l(r)
;;; { 47 TypeName
;;; { 48 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 48 TypeSpecifier (all)
;;; { 48 List<DeclItem>
;;; { 49 DeclItem
;;; what = DECL_NAME
;;; name = gethex
;;; } 49 DeclItem
;;; } 48 List<DeclItem>
;;; } 47 TypeName
;;; { 47 ParameterDeclaration
;;; isEllipsis = false
;;; { 48 TypeName
;;; { 49 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 49 TypeSpecifier (all)
;;; { 49 List<DeclItem>
;;; { 50 DeclItem
;;; what = DECL_NAME
;;; name = echo
;;; } 50 DeclItem
;;; } 49 List<DeclItem>
;;; } 48 TypeName
;;; } 47 ParameterDeclaration
;;; { 47 NumericExpression (constant 1 = 0x1)
;-- load_rr_constant
MOVE #0x0001, RR
;;; } 47 NumericExpression (constant 1 = 0x1)
;-- push_rr (8 bit)
MOVE R, -(SP)
;-- push 2 bytes
;-- call
CALL Cgethex
;-- pop 1 bytes
ADD SP, #1
;;; } 46 Expr l(r)
;;; } 45 Expression (cast)r
;-- store_rr_var address = -5(FP), SP at -7
MOVE RR, 2(SP)
;;; } 44 Expr l = r
;;; } 43 ExpressionStatement
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 ParameterDeclaration
;;; isEllipsis = true
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_POINTER
;;; { 49 List<Ptr>
;;; { 50 Ptr
;;; } 50 Ptr
;;; } 49 List<Ptr>
;;; } 48 DeclItem
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; } 45 ParameterDeclaration
;;; { 45 StringExpression
;-- load_rr_string
MOVE #Cstr_98, RR
;;; } 45 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = getchr
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;-- push 2 bytes
;-- call
CALL Cgetchr
;-- pop 0 bytes
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
;;; { 43 ExpressionStatement
;;; { 44 Expr l = r
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = unsigned char (22000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = address
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 Expr l(r)
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = gethex
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; { 46 ParameterDeclaration
;;; isEllipsis = false
;;; { 47 TypeName
;;; { 48 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 48 TypeSpecifier (all)
;;; { 48 List<DeclItem>
;;; { 49 DeclItem
;;; what = DECL_NAME
;;; name = echo
;;; } 49 DeclItem
;;; } 48 List<DeclItem>
;;; } 47 TypeName
;;; } 46 ParameterDeclaration
;;; { 46 NumericExpression (constant 1 = 0x1)
;-- load_rr_constant
MOVE #0x0001, RR
;;; } 46 NumericExpression (constant 1 = 0x1)
;-- push_rr (8 bit)
MOVE R, -(SP)
;-- push 2 bytes
;-- call
CALL Cgethex
;-- pop 1 bytes
ADD SP, #1
;;; } 45 Expr l(r)
;-- push_rr (8 bit)
MOVE R, -(SP)
;;; { 45 Expr * r
;;; { 46 Expression (variable name)
;;; expr_type = "identifier" (address)
;-- load_rr_var address = -5(FP), SP at -8 (16 bit)
MOVE 3(SP), RR
;;; } 46 Expression (variable name)
;;; } 45 Expr * r
;-- move_rr_to_ll
MOVE RR, LL
;-- pop_rr (8 bit)
MOVE (SP)+, RU
;-- assign (8 bit)
MOVE R, (LL)
;;; } 44 Expr l = r
;;; } 43 ExpressionStatement
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = getchr
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;-- push 2 bytes
;-- call
CALL Cgetchr
;-- pop 0 bytes
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 ParameterDeclaration
;;; isEllipsis = true
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_POINTER
;;; { 49 List<Ptr>
;;; { 50 Ptr
;;; } 50 Ptr
;;; } 49 List<Ptr>
;;; } 48 DeclItem
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; } 45 ParameterDeclaration
;;; { 45 StringExpression
;-- load_rr_string
MOVE #Cstr_99, RR
;;; } 45 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
;;; { 43 break/continue Statement
;-- branch
JMP L36_brk_116
;;; } 43 break/continue Statement
;;; { 43 case Statement
L36_case_116_0073:
;;; { 44 ExpressionStatement
;;; { 45 Expr l(r)
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; { 46 Expr (l , r)
;;; { 47 ParameterDeclaration
;;; isEllipsis = true
;;; { 48 TypeName
;;; { 49 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 49 TypeSpecifier (all)
;;; { 49 List<DeclItem>
;;; { 50 DeclItem
;;; what = DECL_POINTER
;;; { 51 List<Ptr>
;;; { 52 Ptr
;;; } 52 Ptr
;;; } 51 List<Ptr>
;;; } 50 DeclItem
;;; { 50 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 50 DeclItem
;;; } 49 List<DeclItem>
;;; } 48 TypeName
;;; } 47 ParameterDeclaration
IN (IN_DIP_SWITCH), RU
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 47 ParameterDeclaration
;;; isEllipsis = true
;;; { 48 TypeName
;;; { 49 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 49 TypeSpecifier (all)
;;; { 49 List<DeclItem>
;;; { 50 DeclItem
;;; what = DECL_POINTER
;;; { 51 List<Ptr>
;;; { 52 Ptr
;;; } 52 Ptr
;;; } 51 List<Ptr>
;;; } 50 DeclItem
;;; { 50 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 50 DeclItem
;;; } 49 List<DeclItem>
;;; } 48 TypeName
;;; } 47 ParameterDeclaration
;;; { 47 StringExpression
;-- load_rr_string
MOVE #Cstr_100, RR
;;; } 47 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 46 Expr (l , r)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 4 bytes
ADD SP, #4
;;; } 45 Expr l(r)
;;; } 44 ExpressionStatement
;;; } 43 case Statement
;;; { 43 break/continue Statement
;-- branch
JMP L36_brk_116
;;; } 43 break/continue Statement
;;; { 43 case Statement
L36_case_116_0074:
;;; { 44 ExpressionStatement
;;; { 45 Expr l(r)
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; { 46 Expr (l , r)
;;; { 47 ParameterDeclaration
;;; isEllipsis = true
;;; { 48 TypeName
;;; { 49 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 49 TypeSpecifier (all)
;;; { 49 List<DeclItem>
;;; { 50 DeclItem
;;; what = DECL_POINTER
;;; { 51 List<Ptr>
;;; { 52 Ptr
;;; } 52 Ptr
;;; } 51 List<Ptr>
;;; } 50 DeclItem
;;; { 50 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 50 DeclItem
;;; } 49 List<DeclItem>
;;; } 48 TypeName
;;; } 47 ParameterDeclaration
IN (IN_TEMPERAT), RU
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 47 ParameterDeclaration
;;; isEllipsis = true
;;; { 48 TypeName
;;; { 49 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 49 TypeSpecifier (all)
;;; { 49 List<DeclItem>
;;; { 50 DeclItem
;;; what = DECL_POINTER
;;; { 51 List<Ptr>
;;; { 52 Ptr
;;; } 52 Ptr
;;; } 51 List<Ptr>
;;; } 50 DeclItem
;;; { 50 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 50 DeclItem
;;; } 49 List<DeclItem>
;;; } 48 TypeName
;;; } 47 ParameterDeclaration
;;; { 47 StringExpression
;-- load_rr_string
MOVE #Cstr_102, RR
;;; } 47 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 46 Expr (l , r)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 4 bytes
ADD SP, #4
;;; } 45 Expr l(r)
;;; } 44 ExpressionStatement
;;; } 43 case Statement
;;; { 43 break/continue Statement
;-- branch
JMP L36_brk_116
;;; } 43 break/continue Statement
;;; { 43 case Statement
L36_case_116_0048:
;;; { 44 ExpressionStatement
;;; { 45 Expr l(r)
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; { 46 ParameterDeclaration
;;; isEllipsis = true
;;; { 47 TypeName
;;; { 48 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 48 TypeSpecifier (all)
;;; { 48 List<DeclItem>
;;; { 49 DeclItem
;;; what = DECL_POINTER
;;; { 50 List<Ptr>
;;; { 51 Ptr
;;; } 51 Ptr
;;; } 50 List<Ptr>
;;; } 49 DeclItem
;;; { 49 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 49 DeclItem
;;; } 48 List<DeclItem>
;;; } 47 TypeName
;;; } 46 ParameterDeclaration
;;; { 46 StringExpression
;-- load_rr_string
MOVE #Cstr_104, RR
;;; } 46 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 45 Expr l(r)
;;; } 44 ExpressionStatement
;;; } 43 case Statement
;;; { 43 while Statement
L36_loop_118:
;;; { 44 ExpressionStatement
;;; } 44 ExpressionStatement
L36_cont_118:
;;; { 44 Expr l < r
;;; { 45 TypeName (internal)
;;; { 46 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 46 TypeSpecifier (all)
;;; } 45 TypeName (internal)
;-- load_address tx_sema
MOVE #Ctx_sema, RR
;-- + (member)
;-- content
MOVE (RR), RR
;-- l < r
SLT RR, #0x0010
;;; } 44 Expr l < r
;-- branch_true
JMP RRNZ, L36_loop_118
L36_brk_119:
;;; } 43 while Statement
;;; { 43 ExpressionStatement
DI
;;; } 43 ExpressionStatement
;;; { 43 ExpressionStatement
HALT
;;; } 43 ExpressionStatement
;;; { 43 break/continue Statement
;-- branch
JMP L36_brk_116
;;; } 43 break/continue Statement
;;; { 43 case Statement
L36_case_116_0049:
;;; { 44 ExpressionStatement
;;; { 45 Expr l(r)
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = load_image
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;-- push 0 bytes
;-- call
CALL Cload_image
;-- pop 0 bytes
;;; } 45 Expr l(r)
;;; } 44 ExpressionStatement
;;; } 43 case Statement
;;; { 43 break/continue Statement
;-- branch
JMP L36_brk_116
;;; } 43 break/continue Statement
;;; { 43 case Statement
L36_case_116_0053:
;;; { 44 ExpressionStatement
;;; { 45 Expr l(r)
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = show_semas
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;-- push 0 bytes
;-- call
CALL Cshow_semas
;-- pop 0 bytes
;;; } 45 Expr l(r)
;;; } 44 ExpressionStatement
;;; } 43 case Statement
;;; { 43 break/continue Statement
;-- branch
JMP L36_brk_116
;;; } 43 break/continue Statement
;;; { 43 case Statement
L36_case_116_0054:
;;; { 44 ExpressionStatement
;;; { 45 Expr l(r)
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = show_tasks
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;-- push 0 bytes
;-- call
CALL Cshow_tasks
;-- pop 0 bytes
;;; } 45 Expr l(r)
;;; } 44 ExpressionStatement
;;; } 43 case Statement
;;; { 43 break/continue Statement
;-- branch
JMP L36_brk_116
;;; } 43 break/continue Statement
;;; { 43 case Statement
L36_deflt_116:
;;; { 44 ExpressionStatement
;;; { 45 Expr l(r)
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; { 46 ParameterDeclaration
;;; isEllipsis = true
;;; { 47 TypeName
;;; { 48 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 48 TypeSpecifier (all)
;;; { 48 List<DeclItem>
;;; { 49 DeclItem
;;; what = DECL_POINTER
;;; { 50 List<Ptr>
;;; { 51 Ptr
;;; } 51 Ptr
;;; } 50 List<Ptr>
;;; } 49 DeclItem
;;; { 49 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 49 DeclItem
;;; } 48 List<DeclItem>
;;; } 47 TypeName
;;; } 46 ParameterDeclaration
;;; { 46 StringExpression
;-- load_rr_string
MOVE #Cstr_107, RR
;;; } 46 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 45 Expr l(r)
;;; } 44 ExpressionStatement
;;; } 43 case Statement
;;; } 42 List<case Statement>
;-- pop 0 bytes
;;; } 41 CompoundStatement
L36_brk_116:
;;; } 40 SwitchStatement
;;; { 40 ExpressionStatement
;;; { 41 Expr l(r)
;;; { 42 TypeName
;;; { 43 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 43 TypeSpecifier (all)
;;; { 43 List<DeclItem>
;;; { 44 DeclItem
;;; what = DECL_NAME
;;; name = V
;;; } 44 DeclItem
;;; } 43 List<DeclItem>
;;; } 42 TypeName
;;; { 42 ParameterDeclaration
;;; isEllipsis = false
;;; { 43 TypeName
;;; { 44 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 44 TypeSpecifier (struct/union)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_POINTER
;;; { 46 List<Ptr>
;;; { 47 Ptr
;;; } 47 Ptr
;;; } 46 List<Ptr>
;;; } 45 DeclItem
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; } 42 ParameterDeclaration
;;; { 42 Expr & r
;-- load_address serial_out
MOVE #Cserial_out, RR
;;; } 42 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CV
;-- pop 2 bytes
ADD SP, #2
;;; } 41 Expr l(r)
;;; } 40 ExpressionStatement
;;; } 39 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 38 CompoundStatement
L36_cont_113:
;-- branch
JMP L36_loop_113
L36_brk_114:
;;; } 37 for Statement
;;; } 36 List<ExpressionStatement>
;-- pop 7 bytes
ADD SP, #7
;;; } 35 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 35 FunctionDefinition
;;; { 36 TypeName
;;; { 37 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 37 TypeSpecifier (all)
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = main_2
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
;;; } 36 TypeName
;;; { 36 List<DeclItem>
;;; { 37 DeclItem
;;; what = DECL_NAME
;;; name = main_2
;;; } 37 DeclItem
;;; { 37 DeclItem
;;; what = DECL_FUN
;;; } 37 DeclItem
;;; } 36 List<DeclItem>
Cmain_2:
;;; { 36 CompoundStatement
;;; { 37 InitDeclarator
;;; { 38 List<DeclItem>
;;; { 39 DeclItem
;;; what = DECL_NAME
;;; name = all_value
;;; } 39 DeclItem
;;; } 38 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 37 InitDeclarator
;;; { 37 InitDeclarator
;;; { 38 List<DeclItem>
;;; { 39 DeclItem
;;; what = DECL_NAME
;;; name = halt_value
;;; } 39 DeclItem
;;; } 38 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 37 InitDeclarator
;;; { 37 InitDeclarator
;;; { 38 List<DeclItem>
;;; { 39 DeclItem
;;; what = DECL_NAME
;;; name = all_total
;;; } 39 DeclItem
;;; } 38 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 37 InitDeclarator
;;; { 37 InitDeclarator
;;; { 38 List<DeclItem>
;;; { 39 DeclItem
;;; what = DECL_NAME
;;; name = halt_total
;;; } 39 DeclItem
;;; } 38 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 37 InitDeclarator
;;; { 37 InitDeclarator
;;; { 38 List<DeclItem>
;;; { 39 DeclItem
;;; what = DECL_NAME
;;; name = n
;;; } 39 DeclItem
;;; } 38 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 37 InitDeclarator
;;; { 37 InitDeclarator
;;; { 38 List<DeclItem>
;;; { 39 DeclItem
;;; what = DECL_NAME
;;; name = idle
;;; } 39 DeclItem
;;; } 38 List<DeclItem>
;-- push_zero 2 bytes
CLRW -(SP)
;;; } 37 InitDeclarator
;;; { 37 List<ExpressionStatement>
;;; { 38 ExpressionStatement
EI
;;; } 38 ExpressionStatement
;;; { 38 ExpressionStatement
;;; { 39 Expr l(r)
;;; { 40 TypeName
;;; { 41 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 41 TypeSpecifier (all)
;;; { 41 List<DeclItem>
;;; { 42 DeclItem
;;; what = DECL_NAME
;;; name = init_stack
;;; } 42 DeclItem
;;; } 41 List<DeclItem>
;;; } 40 TypeName
;-- push 0 bytes
;-- call
CALL Cinit_stack
;-- pop 0 bytes
;;; } 39 Expr l(r)
;;; } 38 ExpressionStatement
;;; { 38 for Statement
;;; { 39 ExpressionStatement
;;; } 39 ExpressionStatement
L37_loop_120:
;;; { 39 CompoundStatement
;;; { 40 List<ExpressionStatement>
;;; { 41 ExpressionStatement
;;; { 42 Expr l(r)
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = P
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; { 43 ParameterDeclaration
;;; isEllipsis = false
;;; { 44 TypeName
;;; { 45 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 45 TypeSpecifier (struct/union)
;;; { 45 List<DeclItem>
;;; { 46 DeclItem
;;; what = DECL_POINTER
;;; { 47 List<Ptr>
;;; { 48 Ptr
;;; } 48 Ptr
;;; } 47 List<Ptr>
;;; } 46 DeclItem
;;; { 46 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 46 DeclItem
;;; } 45 List<DeclItem>
;;; } 44 TypeName
;;; } 43 ParameterDeclaration
;;; { 43 Expr & r
;-- load_address t2_control
MOVE #Ct2_control, RR
;;; } 43 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CP
;-- pop 2 bytes
ADD SP, #2
;;; } 42 Expr l(r)
;;; } 41 ExpressionStatement
;;; { 41 ExpressionStatement
;;; { 42 Expr l = r
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = all_value
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; { 43 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 43 NumericExpression (constant 0 = 0x0)
;-- store_rr_var all_value = -2(FP), SP at -12
MOVE RR, 10(SP)
;;; } 42 Expr l = r
;;; } 41 ExpressionStatement
;;; { 41 ExpressionStatement
;;; { 42 Expr l = r
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = halt_value
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; { 43 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 43 NumericExpression (constant 0 = 0x0)
;-- store_rr_var halt_value = -4(FP), SP at -12
MOVE RR, 8(SP)
;;; } 42 Expr l = r
;;; } 41 ExpressionStatement
;;; { 41 ExpressionStatement
;;; { 42 Expr l = r
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = all_total
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; { 43 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 43 NumericExpression (constant 0 = 0x0)
;-- store_rr_var all_total = -6(FP), SP at -12
MOVE RR, 6(SP)
;;; } 42 Expr l = r
;;; } 41 ExpressionStatement
;;; { 41 ExpressionStatement
;;; { 42 Expr l = r
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = halt_total
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; { 43 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 43 NumericExpression (constant 0 = 0x0)
;-- store_rr_var halt_total = -8(FP), SP at -12
MOVE RR, 4(SP)
;;; } 42 Expr l = r
;;; } 41 ExpressionStatement
;;; { 41 ExpressionStatement
;;; { 42 Expr l(r)
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = P
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; { 43 ParameterDeclaration
;;; isEllipsis = false
;;; { 44 TypeName
;;; { 45 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 45 TypeSpecifier (struct/union)
;;; { 45 List<DeclItem>
;;; { 46 DeclItem
;;; what = DECL_POINTER
;;; { 47 List<Ptr>
;;; { 48 Ptr
;;; } 48 Ptr
;;; } 47 List<Ptr>
;;; } 46 DeclItem
;;; { 46 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 46 DeclItem
;;; } 45 List<DeclItem>
;;; } 44 TypeName
;;; } 43 ParameterDeclaration
;;; { 43 Expr & r
;-- load_address serial_out
MOVE #Cserial_out, RR
;;; } 43 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CP
;-- pop 2 bytes
ADD SP, #2
;;; } 42 Expr l(r)
;;; } 41 ExpressionStatement
;;; { 41 ExpressionStatement
;;; { 42 Expr l(r)
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; { 43 ParameterDeclaration
;;; isEllipsis = true
;;; { 44 TypeName
;;; { 45 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 45 TypeSpecifier (all)
;;; { 45 List<DeclItem>
;;; { 46 DeclItem
;;; what = DECL_POINTER
;;; { 47 List<Ptr>
;;; { 48 Ptr
;;; } 48 Ptr
;;; } 47 List<Ptr>
;;; } 46 DeclItem
;;; { 46 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 46 DeclItem
;;; } 45 List<DeclItem>
;;; } 44 TypeName
;;; } 43 ParameterDeclaration
;;; { 43 StringExpression
;-- load_rr_string
MOVE #Cstr_123, RR
;;; } 43 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 2 bytes
ADD SP, #2
;;; } 42 Expr l(r)
;;; } 41 ExpressionStatement
;;; { 41 ExpressionStatement
;;; { 42 Expr l(r)
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = V
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; { 43 ParameterDeclaration
;;; isEllipsis = false
;;; { 44 TypeName
;;; { 45 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 45 TypeSpecifier (struct/union)
;;; { 45 List<DeclItem>
;;; { 46 DeclItem
;;; what = DECL_POINTER
;;; { 47 List<Ptr>
;;; { 48 Ptr
;;; } 48 Ptr
;;; } 47 List<Ptr>
;;; } 46 DeclItem
;;; { 46 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 46 DeclItem
;;; } 45 List<DeclItem>
;;; } 44 TypeName
;;; } 43 ParameterDeclaration
;;; { 43 Expr & r
;-- load_address serial_out
MOVE #Cserial_out, RR
;;; } 43 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CV
;-- pop 2 bytes
ADD SP, #2
;;; } 42 Expr l(r)
;;; } 41 ExpressionStatement
;;; { 41 ExpressionStatement
;;; { 42 Expr l(r)
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = V
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; { 43 ParameterDeclaration
;;; isEllipsis = false
;;; { 44 TypeName
;;; { 45 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 45 TypeSpecifier (struct/union)
;;; { 45 List<DeclItem>
;;; { 46 DeclItem
;;; what = DECL_POINTER
;;; { 47 List<Ptr>
;;; { 48 Ptr
;;; } 48 Ptr
;;; } 47 List<Ptr>
;;; } 46 DeclItem
;;; { 46 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 46 DeclItem
;;; } 45 List<DeclItem>
;;; } 44 TypeName
;;; } 43 ParameterDeclaration
;;; { 43 Expr & r
;-- load_address t3_control
MOVE #Ct3_control, RR
;;; } 43 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CV
;-- pop 2 bytes
ADD SP, #2
;;; } 42 Expr l(r)
;;; } 41 ExpressionStatement
;;; { 41 for Statement
;;; { 42 ExpressionStatement
;;; { 43 Expr l = r
;;; { 44 TypeName
;;; { 45 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 45 TypeSpecifier (all)
;;; { 45 List<DeclItem>
;;; { 46 DeclItem
;;; what = DECL_NAME
;;; name = n
;;; } 46 DeclItem
;;; } 45 List<DeclItem>
;;; } 44 TypeName
;;; { 44 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 44 NumericExpression (constant 0 = 0x0)
;-- store_rr_var n = -10(FP), SP at -12
MOVE RR, 2(SP)
;;; } 43 Expr l = r
;;; } 42 ExpressionStatement
;-- branch
JMP L37_tst_122
L37_loop_122:
;;; { 42 CompoundStatement
;;; { 43 List<ExpressionStatement>
;;; { 44 ExpressionStatement
;;; { 45 Expr l(r)
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = sleep
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; { 46 ParameterDeclaration
;;; isEllipsis = false
;;; { 47 TypeName
;;; { 48 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 48 TypeSpecifier (all)
;;; { 48 List<DeclItem>
;;; { 49 DeclItem
;;; what = DECL_NAME
;;; name = millisecs
;;; } 49 DeclItem
;;; } 48 List<DeclItem>
;;; } 47 TypeName
;;; } 46 ParameterDeclaration
;;; { 46 NumericExpression (constant 1 = 0x1)
;-- load_rr_constant
MOVE #0x0001, RR
;;; } 46 NumericExpression (constant 1 = 0x1)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL Csleep
;-- pop 2 bytes
ADD SP, #2
;;; } 45 Expr l(r)
;;; } 44 ExpressionStatement
;;; { 44 ExpressionStatement
;;; { 45 NumericExpression (constant 0 = 0x0)
;-- load_rr_constant
MOVE #0x0000, RR
;;; } 45 NumericExpression (constant 0 = 0x0)
;;; } 44 ExpressionStatement
;;; { 44 ExpressionStatement
OUT R, (OUT_START_CLK_CTR)
;;; } 44 ExpressionStatement
;;; { 44 ExpressionStatement
;;; { 45 Expr l(r)
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = sleep
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; { 46 ParameterDeclaration
;;; isEllipsis = false
;;; { 47 TypeName
;;; { 48 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 48 TypeSpecifier (all)
;;; { 48 List<DeclItem>
;;; { 49 DeclItem
;;; what = DECL_NAME
;;; name = millisecs
;;; } 49 DeclItem
;;; } 48 List<DeclItem>
;;; } 47 TypeName
;;; } 46 ParameterDeclaration
;;; { 46 NumericExpression (constant 1 = 0x1)
;-- load_rr_constant
MOVE #0x0001, RR
;;; } 46 NumericExpression (constant 1 = 0x1)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL Csleep
;-- pop 2 bytes
ADD SP, #2
;;; } 45 Expr l(r)
;;; } 44 ExpressionStatement
;;; { 44 ExpressionStatement
OUT R, (OUT_STOP_CLK_CTR)
;;; } 44 ExpressionStatement
;;; { 44 ExpressionStatement
;;; { 45 Expr l += r
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = all_value
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; { 46 Expr l + r
;;; { 47 Expr l | r
;;; { 48 TypeName (internal)
;;; { 49 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 49 TypeSpecifier (all)
;;; } 48 TypeName (internal)
;;; { 48 Expr l << r
;;; { 49 TypeName (internal)
;;; { 50 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 50 TypeSpecifier (all)
;;; } 49 TypeName (internal)
IN (IN_CLK_CTR_HIGH), RU
;-- l << r
LSL RR, #0x0008
;;; } 48 Expr l << r
;-- push_rr (16 bit)
MOVE RR, -(SP)
IN (IN_CLK_CTR_LOW), RU
;-- pop_ll (16 bit)
MOVE (SP)+, LL
;-- l | r
OR LL, RR
;;; } 47 Expr l | r
;;; { 47 Expression (variable name)
;;; expr_type = "identifier" (all_value)
;-- load_ll_var all_value = -2(FP), SP at -12 (16 bit)
MOVE 10(SP), LL
;;; } 47 Expression (variable name)
;-- scale_rr *1
;-- l + r
ADD LL, RR
;;; } 46 Expr l + r
;-- store_rr_var all_value = -2(FP), SP at -12
MOVE RR, 10(SP)
;;; } 45 Expr l += r
;;; } 44 ExpressionStatement
;;; { 44 ExpressionStatement
;;; { 45 Expr l += r
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = all_total
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; { 46 Expr l + r
;;; { 47 Expr l >> r
;;; { 48 TypeName (internal)
;;; { 49 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 49 TypeSpecifier (all)
;;; } 48 TypeName (internal)
;;; { 48 Expression (variable name)
;;; expr_type = "identifier" (all_value)
;-- load_rr_var all_value = -2(FP), SP at -12 (16 bit)
MOVE 10(SP), RR
;;; } 48 Expression (variable name)
;-- l >> r
ASR RR, #0x0008
;;; } 47 Expr l >> r
;;; { 47 Expression (variable name)
;;; expr_type = "identifier" (all_total)
;-- load_ll_var all_total = -6(FP), SP at -12 (16 bit)
MOVE 6(SP), LL
;;; } 47 Expression (variable name)
;-- scale_rr *1
;-- l + r
ADD LL, RR
;;; } 46 Expr l + r
;-- store_rr_var all_total = -6(FP), SP at -12
MOVE RR, 6(SP)
;;; } 45 Expr l += r
;;; } 44 ExpressionStatement
;;; { 44 ExpressionStatement
;;; { 45 Expr l & r
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = all_value
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; { 46 Expr l & r
;;; { 47 TypeName (internal)
;;; { 48 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 48 TypeSpecifier (all)
;;; } 47 TypeName (internal)
;;; { 47 Expression (variable name)
;;; expr_type = "identifier" (all_value)
;-- load_rr_var all_value = -2(FP), SP at -12 (16 bit)
MOVE 10(SP), RR
;;; } 47 Expression (variable name)
;-- l & r
AND RR, #0x00FF
;;; } 46 Expr l & r
;-- store_rr_var all_value = -2(FP), SP at -12
MOVE RR, 10(SP)
;;; } 45 Expr l & r
;;; } 44 ExpressionStatement
;;; { 44 ExpressionStatement
;;; { 45 Expr l(r)
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = sleep
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; { 46 ParameterDeclaration
;;; isEllipsis = false
;;; { 47 TypeName
;;; { 48 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 48 TypeSpecifier (all)
;;; { 48 List<DeclItem>
;;; { 49 DeclItem
;;; what = DECL_NAME
;;; name = millisecs
;;; } 49 DeclItem
;;; } 48 List<DeclItem>
;;; } 47 TypeName
;;; } 46 ParameterDeclaration
;;; { 46 NumericExpression (constant 1 = 0x1)
;-- load_rr_constant
MOVE #0x0001, RR
;;; } 46 NumericExpression (constant 1 = 0x1)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL Csleep
;-- pop 2 bytes
ADD SP, #2
;;; } 45 Expr l(r)
;;; } 44 ExpressionStatement
;;; { 44 ExpressionStatement
;;; { 45 NumericExpression (constant 3 = 0x3)
;-- load_rr_constant
MOVE #0x0003, RR
;;; } 45 NumericExpression (constant 3 = 0x3)
;;; } 44 ExpressionStatement
;;; { 44 ExpressionStatement
OUT R, (OUT_START_CLK_CTR)
;;; } 44 ExpressionStatement
;;; { 44 ExpressionStatement
;;; { 45 Expr l(r)
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = sleep
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; { 46 ParameterDeclaration
;;; isEllipsis = false
;;; { 47 TypeName
;;; { 48 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 48 TypeSpecifier (all)
;;; { 48 List<DeclItem>
;;; { 49 DeclItem
;;; what = DECL_NAME
;;; name = millisecs
;;; } 49 DeclItem
;;; } 48 List<DeclItem>
;;; } 47 TypeName
;;; } 46 ParameterDeclaration
;;; { 46 NumericExpression (constant 1 = 0x1)
;-- load_rr_constant
MOVE #0x0001, RR
;;; } 46 NumericExpression (constant 1 = 0x1)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL Csleep
;-- pop 2 bytes
ADD SP, #2
;;; } 45 Expr l(r)
;;; } 44 ExpressionStatement
;;; { 44 ExpressionStatement
OUT R, (OUT_STOP_CLK_CTR)
;;; } 44 ExpressionStatement
;;; { 44 ExpressionStatement
;;; { 45 Expr l += r
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = halt_value
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; { 46 Expr l + r
;;; { 47 Expr l | r
;;; { 48 TypeName (internal)
;;; { 49 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 49 TypeSpecifier (all)
;;; } 48 TypeName (internal)
;;; { 48 Expr l << r
;;; { 49 TypeName (internal)
;;; { 50 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 50 TypeSpecifier (all)
;;; } 49 TypeName (internal)
IN (IN_CLK_CTR_HIGH), RU
;-- l << r
LSL RR, #0x0008
;;; } 48 Expr l << r
;-- push_rr (16 bit)
MOVE RR, -(SP)
IN (IN_CLK_CTR_LOW), RU
;-- pop_ll (16 bit)
MOVE (SP)+, LL
;-- l | r
OR LL, RR
;;; } 47 Expr l | r
;;; { 47 Expression (variable name)
;;; expr_type = "identifier" (halt_value)
;-- load_ll_var halt_value = -4(FP), SP at -12 (16 bit)
MOVE 8(SP), LL
;;; } 47 Expression (variable name)
;-- scale_rr *1
;-- l + r
ADD LL, RR
;;; } 46 Expr l + r
;-- store_rr_var halt_value = -4(FP), SP at -12
MOVE RR, 8(SP)
;;; } 45 Expr l += r
;;; } 44 ExpressionStatement
;;; { 44 ExpressionStatement
;;; { 45 Expr l += r
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = halt_total
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; { 46 Expr l + r
;;; { 47 Expr l >> r
;;; { 48 TypeName (internal)
;;; { 49 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 49 TypeSpecifier (all)
;;; } 48 TypeName (internal)
;;; { 48 Expression (variable name)
;;; expr_type = "identifier" (halt_value)
;-- load_rr_var halt_value = -4(FP), SP at -12 (16 bit)
MOVE 8(SP), RR
;;; } 48 Expression (variable name)
;-- l >> r
ASR RR, #0x0008
;;; } 47 Expr l >> r
;;; { 47 Expression (variable name)
;;; expr_type = "identifier" (halt_total)
;-- load_ll_var halt_total = -8(FP), SP at -12 (16 bit)
MOVE 4(SP), LL
;;; } 47 Expression (variable name)
;-- scale_rr *1
;-- l + r
ADD LL, RR
;;; } 46 Expr l + r
;-- store_rr_var halt_total = -8(FP), SP at -12
MOVE RR, 4(SP)
;;; } 45 Expr l += r
;;; } 44 ExpressionStatement
;;; { 44 ExpressionStatement
;;; { 45 Expr l & r
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = halt_value
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; { 46 Expr l & r
;;; { 47 TypeName (internal)
;;; { 48 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 48 TypeSpecifier (all)
;;; } 47 TypeName (internal)
;;; { 47 Expression (variable name)
;;; expr_type = "identifier" (halt_value)
;-- load_rr_var halt_value = -4(FP), SP at -12 (16 bit)
MOVE 8(SP), RR
;;; } 47 Expression (variable name)
;-- l & r
AND RR, #0x00FF
;;; } 46 Expr l & r
;-- store_rr_var halt_value = -4(FP), SP at -12
MOVE RR, 8(SP)
;;; } 45 Expr l & r
;;; } 44 ExpressionStatement
;;; } 43 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 42 CompoundStatement
L37_cont_122:
;;; { 42 Expr l - r
;;; { 43 Expr ++r
;;; { 44 Expression (variable name)
;;; expr_type = "identifier" (n)
;-- load_rr_var n = -10(FP), SP at -12 (16 bit)
MOVE 2(SP), RR
;;; } 44 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var n = -10(FP), SP at -12
MOVE RR, 2(SP)
;;; } 43 Expr ++r
;-- l - r
SUB RR, #0x0001
;;; } 42 Expr l - r
L37_tst_122:
;;; { 42 Expr l < r
;;; { 43 TypeName (internal)
;;; { 44 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 44 TypeSpecifier (all)
;;; } 43 TypeName (internal)
;;; { 43 Expression (variable name)
;;; expr_type = "identifier" (n)
;-- load_rr_var n = -10(FP), SP at -12 (16 bit)
MOVE 2(SP), RR
;;; } 43 Expression (variable name)
;-- l < r
SLT RR, #0x0064
;;; } 42 Expr l < r
;-- branch_true
JMP RRNZ, L37_loop_122
L37_brk_123:
;;; } 41 for Statement
;;; { 41 ExpressionStatement
;;; { 42 Expr l(r)
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = P
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; { 43 ParameterDeclaration
;;; isEllipsis = false
;;; { 44 TypeName
;;; { 45 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 45 TypeSpecifier (struct/union)
;;; { 45 List<DeclItem>
;;; { 46 DeclItem
;;; what = DECL_POINTER
;;; { 47 List<Ptr>
;;; { 48 Ptr
;;; } 48 Ptr
;;; } 47 List<Ptr>
;;; } 46 DeclItem
;;; { 46 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 46 DeclItem
;;; } 45 List<DeclItem>
;;; } 44 TypeName
;;; } 43 ParameterDeclaration
;;; { 43 Expr & r
;-- load_address t3_control
MOVE #Ct3_control, RR
;;; } 43 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CP
;-- pop 2 bytes
ADD SP, #2
;;; } 42 Expr l(r)
;;; } 41 ExpressionStatement
;;; { 41 ExpressionStatement
;;; { 42 Expr l(r)
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = P
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; { 43 ParameterDeclaration
;;; isEllipsis = false
;;; { 44 TypeName
;;; { 45 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 45 TypeSpecifier (struct/union)
;;; { 45 List<DeclItem>
;;; { 46 DeclItem
;;; what = DECL_POINTER
;;; { 47 List<Ptr>
;;; { 48 Ptr
;;; } 48 Ptr
;;; } 47 List<Ptr>
;;; } 46 DeclItem
;;; { 46 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 46 DeclItem
;;; } 45 List<DeclItem>
;;; } 44 TypeName
;;; } 43 ParameterDeclaration
;;; { 43 Expr & r
;-- load_address serial_out
MOVE #Cserial_out, RR
;;; } 43 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CP
;-- pop 2 bytes
ADD SP, #2
;;; } 42 Expr l(r)
;;; } 41 ExpressionStatement
;;; { 41 ExpressionStatement
;;; { 42 Expr l(r)
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; { 43 Expr (l , r)
;;; { 44 ParameterDeclaration
;;; isEllipsis = true
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_POINTER
;;; { 48 List<Ptr>
;;; { 49 Ptr
;;; } 49 Ptr
;;; } 48 List<Ptr>
;;; } 47 DeclItem
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; } 44 ParameterDeclaration
;;; { 44 Expression (variable name)
;;; expr_type = "identifier" (all_total)
;-- load_rr_var all_total = -6(FP), SP at -12 (16 bit)
MOVE 6(SP), RR
;;; } 44 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 44 ParameterDeclaration
;;; isEllipsis = true
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_POINTER
;;; { 48 List<Ptr>
;;; { 49 Ptr
;;; } 49 Ptr
;;; } 48 List<Ptr>
;;; } 47 DeclItem
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; } 44 ParameterDeclaration
;;; { 44 StringExpression
;-- load_rr_string
MOVE #Cstr_132, RR
;;; } 44 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 43 Expr (l , r)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 4 bytes
ADD SP, #4
;;; } 42 Expr l(r)
;;; } 41 ExpressionStatement
;;; { 41 ExpressionStatement
;;; { 42 Expr l(r)
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; { 43 Expr (l , r)
;;; { 44 ParameterDeclaration
;;; isEllipsis = true
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_POINTER
;;; { 48 List<Ptr>
;;; { 49 Ptr
;;; } 49 Ptr
;;; } 48 List<Ptr>
;;; } 47 DeclItem
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; } 44 ParameterDeclaration
;;; { 44 Expression (variable name)
;;; expr_type = "identifier" (halt_total)
;-- load_rr_var halt_total = -8(FP), SP at -12 (16 bit)
MOVE 4(SP), RR
;;; } 44 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 44 ParameterDeclaration
;;; isEllipsis = true
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_POINTER
;;; { 48 List<Ptr>
;;; { 49 Ptr
;;; } 49 Ptr
;;; } 48 List<Ptr>
;;; } 47 DeclItem
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; } 44 ParameterDeclaration
;;; { 44 StringExpression
;-- load_rr_string
MOVE #Cstr_133, RR
;;; } 44 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 43 Expr (l , r)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 4 bytes
ADD SP, #4
;;; } 42 Expr l(r)
;;; } 41 ExpressionStatement
;;; { 41 ExpressionStatement
;;; { 42 Expr l = r
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = idle
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; { 43 Expr l / r
;;; { 44 TypeName (internal)
;;; { 45 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 45 TypeSpecifier (all)
;;; } 44 TypeName (internal)
;;; { 44 Expr l * r
;;; { 45 TypeName (internal)
;;; { 46 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 46 TypeSpecifier (all)
;;; } 45 TypeName (internal)
;;; { 45 Expr l >> r
;;; { 46 TypeName (internal)
;;; { 47 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 47 TypeSpecifier (all)
;;; } 46 TypeName (internal)
;;; { 46 Expression (variable name)
;;; expr_type = "identifier" (halt_total)
;-- load_rr_var halt_total = -8(FP), SP at -12 (16 bit)
MOVE 4(SP), RR
;;; } 46 Expression (variable name)
;-- l >> r
ASR RR, #0x0008
;;; } 45 Expr l >> r
;-- l * r
MOVE RR, LL
MOVE #0x0064, RR
;-- l * r
DI
MUL_IS
CALL mult_div
MD_FIN
EI
;;; } 44 Expr l * r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 44 Expr l >> r
;;; { 45 TypeName (internal)
;;; { 46 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 46 TypeSpecifier (all)
;;; } 45 TypeName (internal)
;;; { 45 Expression (variable name)
;;; expr_type = "identifier" (all_total)
;-- load_rr_var all_total = -6(FP), SP at -14 (16 bit)
MOVE 8(SP), RR
;;; } 45 Expression (variable name)
;-- l >> r
ASR RR, #0x0008
;;; } 44 Expr l >> r
;-- pop_ll (16 bit)
MOVE (SP)+, LL
;-- l / r
DI
DIV_IS
CALL mult_div
MD_FIN
EI
;;; } 43 Expr l / r
;-- store_rr_var idle = -12(FP), SP at -12
MOVE RR, 0(SP)
;;; } 42 Expr l = r
;;; } 41 ExpressionStatement
;;; { 41 ExpressionStatement
;;; { 42 Expr l(r)
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; { 43 Expr (l , r)
;;; { 44 ParameterDeclaration
;;; isEllipsis = true
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_POINTER
;;; { 48 List<Ptr>
;;; { 49 Ptr
;;; } 49 Ptr
;;; } 48 List<Ptr>
;;; } 47 DeclItem
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; } 44 ParameterDeclaration
;;; { 44 Expression (variable name)
;;; expr_type = "identifier" (idle)
;-- load_rr_var idle = -12(FP), SP at -12 (16 bit)
MOVE 0(SP), RR
;;; } 44 Expression (variable name)
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 44 ParameterDeclaration
;;; isEllipsis = true
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_POINTER
;;; { 48 List<Ptr>
;;; { 49 Ptr
;;; } 49 Ptr
;;; } 48 List<Ptr>
;;; } 47 DeclItem
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; } 44 ParameterDeclaration
;;; { 44 StringExpression
;-- load_rr_string
MOVE #Cstr_134, RR
;;; } 44 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 43 Expr (l , r)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 4 bytes
ADD SP, #4
;;; } 42 Expr l(r)
;;; } 41 ExpressionStatement
;;; { 41 ExpressionStatement
;;; { 42 Expr l(r)
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = printf
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; { 43 Expr (l , r)
;;; { 44 ParameterDeclaration
;;; isEllipsis = true
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_POINTER
;;; { 48 List<Ptr>
;;; { 49 Ptr
;;; } 49 Ptr
;;; } 48 List<Ptr>
;;; } 47 DeclItem
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; } 44 ParameterDeclaration
;;; { 44 Expr l - r
;;; { 45 Expression (variable name)
;;; expr_type = "identifier" (idle)
;-- load_rr_var idle = -12(FP), SP at -12 (16 bit)
MOVE 0(SP), RR
;;; } 45 Expression (variable name)
MOVE #0x0064, LL
;-- l - r
SUB LL, RR
;;; } 44 Expr l - r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; { 44 ParameterDeclaration
;;; isEllipsis = true
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = const char (20100)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_POINTER
;;; { 48 List<Ptr>
;;; { 49 Ptr
;;; } 49 Ptr
;;; } 48 List<Ptr>
;;; } 47 DeclItem
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = format
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; } 44 ParameterDeclaration
;;; { 44 StringExpression
;-- load_rr_string
MOVE #Cstr_135, RR
;;; } 44 StringExpression
;-- push_rr (16 bit)
MOVE RR, -(SP)
;;; } 43 Expr (l , r)
;-- push 2 bytes
;-- call
CALL Cprintf
;-- pop 4 bytes
ADD SP, #4
;;; } 42 Expr l(r)
;;; } 41 ExpressionStatement
;;; { 41 ExpressionStatement
;;; { 42 Expr l(r)
;;; { 43 TypeName
;;; { 44 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 44 TypeSpecifier (all)
;;; { 44 List<DeclItem>
;;; { 45 DeclItem
;;; what = DECL_NAME
;;; name = V
;;; } 45 DeclItem
;;; } 44 List<DeclItem>
;;; } 43 TypeName
;;; { 43 ParameterDeclaration
;;; isEllipsis = false
;;; { 44 TypeName
;;; { 45 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 45 TypeSpecifier (struct/union)
;;; { 45 List<DeclItem>
;;; { 46 DeclItem
;;; what = DECL_POINTER
;;; { 47 List<Ptr>
;;; { 48 Ptr
;;; } 48 Ptr
;;; } 47 List<Ptr>
;;; } 46 DeclItem
;;; { 46 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 46 DeclItem
;;; } 45 List<DeclItem>
;;; } 44 TypeName
;;; } 43 ParameterDeclaration
;;; { 43 Expr & r
;-- load_address serial_out
MOVE #Cserial_out, RR
;;; } 43 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CV
;-- pop 2 bytes
ADD SP, #2
;;; } 42 Expr l(r)
;;; } 41 ExpressionStatement
;;; } 40 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 39 CompoundStatement
L37_cont_120:
;-- branch
JMP L37_loop_120
L37_brk_121:
;;; } 38 for Statement
;;; } 37 List<ExpressionStatement>
;-- pop 12 bytes
ADD SP, #12
;;; } 36 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 36 FunctionDefinition
;;; { 37 TypeName
;;; { 38 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 38 TypeSpecifier (all)
;;; { 38 List<DeclItem>
;;; { 39 DeclItem
;;; what = DECL_NAME
;;; name = main_3
;;; } 39 DeclItem
;;; } 38 List<DeclItem>
;;; } 37 TypeName
;;; { 37 List<DeclItem>
;;; { 38 DeclItem
;;; what = DECL_NAME
;;; name = main_3
;;; } 38 DeclItem
;;; { 38 DeclItem
;;; what = DECL_FUN
;;; } 38 DeclItem
;;; } 37 List<DeclItem>
Cmain_3:
;;; { 37 CompoundStatement
;;; { 38 InitDeclarator
;;; { 39 List<DeclItem>
;;; { 40 DeclItem
;;; what = DECL_NAME
;;; name = out
;;; } 40 DeclItem
;;; } 39 List<DeclItem>
;-- push_zero 1 bytes
CLRB -(SP)
;;; } 38 InitDeclarator
;;; { 38 List<ExpressionStatement>
;;; { 39 ExpressionStatement
EI
;;; } 39 ExpressionStatement
;;; { 39 ExpressionStatement
;;; { 40 Expr l(r)
;;; { 41 TypeName
;;; { 42 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 42 TypeSpecifier (all)
;;; { 42 List<DeclItem>
;;; { 43 DeclItem
;;; what = DECL_NAME
;;; name = init_stack
;;; } 43 DeclItem
;;; } 42 List<DeclItem>
;;; } 41 TypeName
;-- push 0 bytes
;-- call
CALL Cinit_stack
;-- pop 0 bytes
;;; } 40 Expr l(r)
;;; } 39 ExpressionStatement
;;; { 39 for Statement
;;; { 40 ExpressionStatement
;;; } 40 ExpressionStatement
L38_loop_124:
;;; { 40 CompoundStatement
;;; { 41 List<ExpressionStatement>
;;; { 42 ExpressionStatement
;;; { 43 Expr l(r)
;;; { 44 TypeName
;;; { 45 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 45 TypeSpecifier (all)
;;; { 45 List<DeclItem>
;;; { 46 DeclItem
;;; what = DECL_NAME
;;; name = P
;;; } 46 DeclItem
;;; } 45 List<DeclItem>
;;; } 44 TypeName
;;; { 44 ParameterDeclaration
;;; isEllipsis = false
;;; { 45 TypeName
;;; { 46 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 46 TypeSpecifier (struct/union)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_POINTER
;;; { 48 List<Ptr>
;;; { 49 Ptr
;;; } 49 Ptr
;;; } 48 List<Ptr>
;;; } 47 DeclItem
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; } 44 ParameterDeclaration
;;; { 44 Expr & r
;-- load_address t3_control
MOVE #Ct3_control, RR
;;; } 44 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CP
;-- pop 2 bytes
ADD SP, #2
;;; } 43 Expr l(r)
;;; } 42 ExpressionStatement
;;; { 42 ExpressionStatement
;;; { 43 Expr l(r)
;;; { 44 TypeName
;;; { 45 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 45 TypeSpecifier (all)
;;; { 45 List<DeclItem>
;;; { 46 DeclItem
;;; what = DECL_NAME
;;; name = V
;;; } 46 DeclItem
;;; } 45 List<DeclItem>
;;; } 44 TypeName
;;; { 44 ParameterDeclaration
;;; isEllipsis = false
;;; { 45 TypeName
;;; { 46 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 46 TypeSpecifier (struct/union)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_POINTER
;;; { 48 List<Ptr>
;;; { 49 Ptr
;;; } 49 Ptr
;;; } 48 List<Ptr>
;;; } 47 DeclItem
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; } 44 ParameterDeclaration
;;; { 44 Expr & r
;-- load_address t3_control
MOVE #Ct3_control, RR
;;; } 44 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CV
;-- pop 2 bytes
ADD SP, #2
;;; } 43 Expr l(r)
;;; } 42 ExpressionStatement
;;; { 42 ExpressionStatement
;;; { 43 Expr l(r)
;;; { 44 TypeName
;;; { 45 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 45 TypeSpecifier (all)
;;; { 45 List<DeclItem>
;;; { 46 DeclItem
;;; what = DECL_NAME
;;; name = P
;;; } 46 DeclItem
;;; } 45 List<DeclItem>
;;; } 44 TypeName
;;; { 44 ParameterDeclaration
;;; isEllipsis = false
;;; { 45 TypeName
;;; { 46 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 46 TypeSpecifier (struct/union)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_POINTER
;;; { 48 List<Ptr>
;;; { 49 Ptr
;;; } 49 Ptr
;;; } 48 List<Ptr>
;;; } 47 DeclItem
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; } 44 ParameterDeclaration
;;; { 44 Expr & r
;-- load_address serial_out
MOVE #Cserial_out, RR
;;; } 44 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CP
;-- pop 2 bytes
ADD SP, #2
;;; } 43 Expr l(r)
;;; } 42 ExpressionStatement
;;; { 42 for Statement
;;; { 43 ExpressionStatement
;;; { 44 Expr l = r
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = out
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 NumericExpression (constant 48 = 0x30)
;-- load_rr_constant
MOVE #0x0030, RR
;;; } 45 NumericExpression (constant 48 = 0x30)
;-- store_rr_var out = -1(FP), SP at -1
MOVE R, 0(SP)
;;; } 44 Expr l = r
;;; } 43 ExpressionStatement
;-- branch
JMP L38_tst_126
L38_loop_126:
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = putchr
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 ParameterDeclaration
;;; isEllipsis = false
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; } 45 ParameterDeclaration
;;; { 45 Expression (variable name)
;;; expr_type = "identifier" (out)
;-- load_rr_var out = -1(FP), SP at -1 (8 bit)
MOVE 0(SP), RS
;;; } 45 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;-- push 2 bytes
;-- call
CALL Cputchr
;-- pop 1 bytes
ADD SP, #1
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
L38_cont_126:
;;; { 43 Expr ++r
;;; { 44 Expression (variable name)
;;; expr_type = "identifier" (out)
;-- load_rr_var out = -1(FP), SP at -1 (8 bit)
MOVE 0(SP), RS
;;; } 44 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var out = -1(FP), SP at -1
MOVE R, 0(SP)
;;; } 43 Expr ++r
L38_tst_126:
;;; { 43 Expr l <= r
;;; { 44 TypeName (internal)
;;; { 45 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 45 TypeSpecifier (all)
;;; } 44 TypeName (internal)
;;; { 44 Expression (variable name)
;;; expr_type = "identifier" (out)
;-- load_rr_var out = -1(FP), SP at -1 (8 bit)
MOVE 0(SP), RS
;;; } 44 Expression (variable name)
;-- l <= r
SLE RR, #0x0039
;;; } 43 Expr l <= r
;-- branch_true
JMP RRNZ, L38_loop_126
L38_brk_127:
;;; } 42 for Statement
;;; { 42 for Statement
;;; { 43 ExpressionStatement
;;; { 44 Expr l = r
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = out
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 NumericExpression (constant 65 = 0x41)
;-- load_rr_constant
MOVE #0x0041, RR
;;; } 45 NumericExpression (constant 65 = 0x41)
;-- store_rr_var out = -1(FP), SP at -1
MOVE R, 0(SP)
;;; } 44 Expr l = r
;;; } 43 ExpressionStatement
;-- branch
JMP L38_tst_128
L38_loop_128:
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = putchr
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 ParameterDeclaration
;;; isEllipsis = false
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; } 45 ParameterDeclaration
;;; { 45 Expression (variable name)
;;; expr_type = "identifier" (out)
;-- load_rr_var out = -1(FP), SP at -1 (8 bit)
MOVE 0(SP), RS
;;; } 45 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;-- push 2 bytes
;-- call
CALL Cputchr
;-- pop 1 bytes
ADD SP, #1
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
L38_cont_128:
;;; { 43 Expr ++r
;;; { 44 Expression (variable name)
;;; expr_type = "identifier" (out)
;-- load_rr_var out = -1(FP), SP at -1 (8 bit)
MOVE 0(SP), RS
;;; } 44 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var out = -1(FP), SP at -1
MOVE R, 0(SP)
;;; } 43 Expr ++r
L38_tst_128:
;;; { 43 Expr l <= r
;;; { 44 TypeName (internal)
;;; { 45 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 45 TypeSpecifier (all)
;;; } 44 TypeName (internal)
;;; { 44 Expression (variable name)
;;; expr_type = "identifier" (out)
;-- load_rr_var out = -1(FP), SP at -1 (8 bit)
MOVE 0(SP), RS
;;; } 44 Expression (variable name)
;-- l <= r
SLE RR, #0x005A
;;; } 43 Expr l <= r
;-- branch_true
JMP RRNZ, L38_loop_128
L38_brk_129:
;;; } 42 for Statement
;;; { 42 for Statement
;;; { 43 ExpressionStatement
;;; { 44 Expr l = r
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = out
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 NumericExpression (constant 97 = 0x61)
;-- load_rr_constant
MOVE #0x0061, RR
;;; } 45 NumericExpression (constant 97 = 0x61)
;-- store_rr_var out = -1(FP), SP at -1
MOVE R, 0(SP)
;;; } 44 Expr l = r
;;; } 43 ExpressionStatement
;-- branch
JMP L38_tst_130
L38_loop_130:
;;; { 43 ExpressionStatement
;;; { 44 Expr l(r)
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = putchr
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; { 45 ParameterDeclaration
;;; isEllipsis = false
;;; { 46 TypeName
;;; { 47 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 47 TypeSpecifier (all)
;;; { 47 List<DeclItem>
;;; { 48 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 48 DeclItem
;;; } 47 List<DeclItem>
;;; } 46 TypeName
;;; } 45 ParameterDeclaration
;;; { 45 Expression (variable name)
;;; expr_type = "identifier" (out)
;-- load_rr_var out = -1(FP), SP at -1 (8 bit)
MOVE 0(SP), RS
;;; } 45 Expression (variable name)
;-- push_rr (8 bit)
MOVE R, -(SP)
;-- push 2 bytes
;-- call
CALL Cputchr
;-- pop 1 bytes
ADD SP, #1
;;; } 44 Expr l(r)
;;; } 43 ExpressionStatement
L38_cont_130:
;;; { 43 Expr ++r
;;; { 44 Expression (variable name)
;;; expr_type = "identifier" (out)
;-- load_rr_var out = -1(FP), SP at -1 (8 bit)
MOVE 0(SP), RS
;;; } 44 Expression (variable name)
;-- ++
ADD RR, #0x0001
;-- store_rr_var out = -1(FP), SP at -1
MOVE R, 0(SP)
;;; } 43 Expr ++r
L38_tst_130:
;;; { 43 Expr l <= r
;;; { 44 TypeName (internal)
;;; { 45 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 45 TypeSpecifier (all)
;;; } 44 TypeName (internal)
;;; { 44 Expression (variable name)
;;; expr_type = "identifier" (out)
;-- load_rr_var out = -1(FP), SP at -1 (8 bit)
MOVE 0(SP), RS
;;; } 44 Expression (variable name)
;-- l <= r
SLE RR, #0x007A
;;; } 43 Expr l <= r
;-- branch_true
JMP RRNZ, L38_loop_130
L38_brk_131:
;;; } 42 for Statement
;;; { 42 ExpressionStatement
;;; { 43 Expr l(r)
;;; { 44 TypeName
;;; { 45 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 45 TypeSpecifier (all)
;;; { 45 List<DeclItem>
;;; { 46 DeclItem
;;; what = DECL_NAME
;;; name = putchr
;;; } 46 DeclItem
;;; } 45 List<DeclItem>
;;; } 44 TypeName
;;; { 44 ParameterDeclaration
;;; isEllipsis = false
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; } 44 ParameterDeclaration
;;; { 44 NumericExpression (constant 13 = 0xD)
;-- load_rr_constant
MOVE #0x000D, RR
;;; } 44 NumericExpression (constant 13 = 0xD)
;-- push_rr (8 bit)
MOVE R, -(SP)
;-- push 2 bytes
;-- call
CALL Cputchr
;-- pop 1 bytes
ADD SP, #1
;;; } 43 Expr l(r)
;;; } 42 ExpressionStatement
;;; { 42 ExpressionStatement
;;; { 43 Expr l(r)
;;; { 44 TypeName
;;; { 45 TypeSpecifier (all)
;;; spec = int (80000)
;;; } 45 TypeSpecifier (all)
;;; { 45 List<DeclItem>
;;; { 46 DeclItem
;;; what = DECL_NAME
;;; name = putchr
;;; } 46 DeclItem
;;; } 45 List<DeclItem>
;;; } 44 TypeName
;;; { 44 ParameterDeclaration
;;; isEllipsis = false
;;; { 45 TypeName
;;; { 46 TypeSpecifier (all)
;;; spec = char (20000)
;;; } 46 TypeSpecifier (all)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = c
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; } 44 ParameterDeclaration
;;; { 44 NumericExpression (constant 10 = 0xA)
;-- load_rr_constant
MOVE #0x000A, RR
;;; } 44 NumericExpression (constant 10 = 0xA)
;-- push_rr (8 bit)
MOVE R, -(SP)
;-- push 2 bytes
;-- call
CALL Cputchr
;-- pop 1 bytes
ADD SP, #1
;;; } 43 Expr l(r)
;;; } 42 ExpressionStatement
;;; { 42 ExpressionStatement
;;; { 43 Expr l(r)
;;; { 44 TypeName
;;; { 45 TypeSpecifier (all)
;;; spec = void (10000)
;;; } 45 TypeSpecifier (all)
;;; { 45 List<DeclItem>
;;; { 46 DeclItem
;;; what = DECL_NAME
;;; name = V
;;; } 46 DeclItem
;;; } 45 List<DeclItem>
;;; } 44 TypeName
;;; { 44 ParameterDeclaration
;;; isEllipsis = false
;;; { 45 TypeName
;;; { 46 TypeSpecifier (struct/union)
;;; spec = struct '_semaphore' (800000)
;;; name = _semaphore
;;; } 46 TypeSpecifier (struct/union)
;;; { 46 List<DeclItem>
;;; { 47 DeclItem
;;; what = DECL_POINTER
;;; { 48 List<Ptr>
;;; { 49 Ptr
;;; } 49 Ptr
;;; } 48 List<Ptr>
;;; } 47 DeclItem
;;; { 47 DeclItem
;;; what = DECL_NAME
;;; name = sema
;;; } 47 DeclItem
;;; } 46 List<DeclItem>
;;; } 45 TypeName
;;; } 44 ParameterDeclaration
;;; { 44 Expr & r
;-- load_address serial_out
MOVE #Cserial_out, RR
;;; } 44 Expr & r
;-- push_rr (16 bit)
MOVE RR, -(SP)
;-- push 0 bytes
;-- call
CALL CV
;-- pop 2 bytes
ADD SP, #2
;;; } 43 Expr l(r)
;;; } 42 ExpressionStatement
;;; } 41 List<ExpressionStatement>
;-- pop 0 bytes
;;; } 40 CompoundStatement
L38_cont_124:
;-- branch
JMP L38_loop_124
L38_brk_125:
;;; } 39 for Statement
;;; } 38 List<ExpressionStatement>
;-- pop 1 bytes
ADD SP, #1
;;; } 37 CompoundStatement
;-- ret
RET
;;; ------------------------------------;
;;; { 37 Declaration
;;; { 38 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 38 TypeSpecifier (all)
Cstack_1: ;
.BYTE 0 ; VOID [0]
.BYTE 0 ; VOID [1]
.BYTE 0 ; VOID [2]
.BYTE 0 ; VOID [3]
.BYTE 0 ; VOID [4]
.BYTE 0 ; VOID [5]
.BYTE 0 ; VOID [6]
.BYTE 0 ; VOID [7]
.BYTE 0 ; VOID [8]
.BYTE 0 ; VOID [9]
.BYTE 0 ; VOID [10]
.BYTE 0 ; VOID [11]
.BYTE 0 ; VOID [12]
.BYTE 0 ; VOID [13]
.BYTE 0 ; VOID [14]
.BYTE 0 ; VOID [15]
.BYTE 0 ; VOID [16]
.BYTE 0 ; VOID [17]
.BYTE 0 ; VOID [18]
.BYTE 0 ; VOID [19]
.BYTE 0 ; VOID [20]
.BYTE 0 ; VOID [21]
.BYTE 0 ; VOID [22]
.BYTE 0 ; VOID [23]
.BYTE 0 ; VOID [24]
.BYTE 0 ; VOID [25]
.BYTE 0 ; VOID [26]
.BYTE 0 ; VOID [27]
.BYTE 0 ; VOID [28]
.BYTE 0 ; VOID [29]
.BYTE 0 ; VOID [30]
.BYTE 0 ; VOID [31]
.BYTE 0 ; VOID [32]
.BYTE 0 ; VOID [33]
.BYTE 0 ; VOID [34]
.BYTE 0 ; VOID [35]
.BYTE 0 ; VOID [36]
.BYTE 0 ; VOID [37]
.BYTE 0 ; VOID [38]
.BYTE 0 ; VOID [39]
.BYTE 0 ; VOID [40]
.BYTE 0 ; VOID [41]
.BYTE 0 ; VOID [42]
.BYTE 0 ; VOID [43]
.BYTE 0 ; VOID [44]
.BYTE 0 ; VOID [45]
.BYTE 0 ; VOID [46]
.BYTE 0 ; VOID [47]
.BYTE 0 ; VOID [48]
.BYTE 0 ; VOID [49]
.BYTE 0 ; VOID [50]
.BYTE 0 ; VOID [51]
.BYTE 0 ; VOID [52]
.BYTE 0 ; VOID [53]
.BYTE 0 ; VOID [54]
.BYTE 0 ; VOID [55]
.BYTE 0 ; VOID [56]
.BYTE 0 ; VOID [57]
.BYTE 0 ; VOID [58]
.BYTE 0 ; VOID [59]
.BYTE 0 ; VOID [60]
.BYTE 0 ; VOID [61]
.BYTE 0 ; VOID [62]
.BYTE 0 ; VOID [63]
.BYTE 0 ; VOID [64]
.BYTE 0 ; VOID [65]
.BYTE 0 ; VOID [66]
.BYTE 0 ; VOID [67]
.BYTE 0 ; VOID [68]
.BYTE 0 ; VOID [69]
.BYTE 0 ; VOID [70]
.BYTE 0 ; VOID [71]
.BYTE 0 ; VOID [72]
.BYTE 0 ; VOID [73]
.BYTE 0 ; VOID [74]
.BYTE 0 ; VOID [75]
.BYTE 0 ; VOID [76]
.BYTE 0 ; VOID [77]
.BYTE 0 ; VOID [78]
.BYTE 0 ; VOID [79]
.BYTE 0 ; VOID [80]
.BYTE 0 ; VOID [81]
.BYTE 0 ; VOID [82]
.BYTE 0 ; VOID [83]
.BYTE 0 ; VOID [84]
.BYTE 0 ; VOID [85]
.BYTE 0 ; VOID [86]
.BYTE 0 ; VOID [87]
.BYTE 0 ; VOID [88]
.BYTE 0 ; VOID [89]
.BYTE 0 ; VOID [90]
.BYTE 0 ; VOID [91]
.BYTE 0 ; VOID [92]
.BYTE 0 ; VOID [93]
.BYTE 0 ; VOID [94]
.BYTE 0 ; VOID [95]
.BYTE 0 ; VOID [96]
.BYTE 0 ; VOID [97]
.BYTE 0 ; VOID [98]
.BYTE 0 ; VOID [99]
.BYTE 0 ; VOID [100]
.BYTE 0 ; VOID [101]
.BYTE 0 ; VOID [102]
.BYTE 0 ; VOID [103]
.BYTE 0 ; VOID [104]
.BYTE 0 ; VOID [105]
.BYTE 0 ; VOID [106]
.BYTE 0 ; VOID [107]
.BYTE 0 ; VOID [108]
.BYTE 0 ; VOID [109]
.BYTE 0 ; VOID [110]
.BYTE 0 ; VOID [111]
.BYTE 0 ; VOID [112]
.BYTE 0 ; VOID [113]
.BYTE 0 ; VOID [114]
.BYTE 0 ; VOID [115]
.BYTE 0 ; VOID [116]
.BYTE 0 ; VOID [117]
.BYTE 0 ; VOID [118]
.BYTE 0 ; VOID [119]
.BYTE 0 ; VOID [120]
.BYTE 0 ; VOID [121]
.BYTE 0 ; VOID [122]
.BYTE 0 ; VOID [123]
.BYTE 0 ; VOID [124]
.BYTE 0 ; VOID [125]
.BYTE 0 ; VOID [126]
.BYTE 0 ; VOID [127]
.BYTE 0 ; VOID [128]
.BYTE 0 ; VOID [129]
.BYTE 0 ; VOID [130]
.BYTE 0 ; VOID [131]
.BYTE 0 ; VOID [132]
.BYTE 0 ; VOID [133]
.BYTE 0 ; VOID [134]
.BYTE 0 ; VOID [135]
.BYTE 0 ; VOID [136]
.BYTE 0 ; VOID [137]
.BYTE 0 ; VOID [138]
.BYTE 0 ; VOID [139]
.BYTE 0 ; VOID [140]
.BYTE 0 ; VOID [141]
.BYTE 0 ; VOID [142]
.BYTE 0 ; VOID [143]
.BYTE 0 ; VOID [144]
.BYTE 0 ; VOID [145]
.BYTE 0 ; VOID [146]
.BYTE 0 ; VOID [147]
.BYTE 0 ; VOID [148]
.BYTE 0 ; VOID [149]
.BYTE 0 ; VOID [150]
.BYTE 0 ; VOID [151]
.BYTE 0 ; VOID [152]
.BYTE 0 ; VOID [153]
.BYTE 0 ; VOID [154]
.BYTE 0 ; VOID [155]
.BYTE 0 ; VOID [156]
.BYTE 0 ; VOID [157]
.BYTE 0 ; VOID [158]
.BYTE 0 ; VOID [159]
.BYTE 0 ; VOID [160]
.BYTE 0 ; VOID [161]
.BYTE 0 ; VOID [162]
.BYTE 0 ; VOID [163]
.BYTE 0 ; VOID [164]
.BYTE 0 ; VOID [165]
.BYTE 0 ; VOID [166]
.BYTE 0 ; VOID [167]
.BYTE 0 ; VOID [168]
.BYTE 0 ; VOID [169]
.BYTE 0 ; VOID [170]
.BYTE 0 ; VOID [171]
.BYTE 0 ; VOID [172]
.BYTE 0 ; VOID [173]
.BYTE 0 ; VOID [174]
.BYTE 0 ; VOID [175]
.BYTE 0 ; VOID [176]
.BYTE 0 ; VOID [177]
.BYTE 0 ; VOID [178]
.BYTE 0 ; VOID [179]
.BYTE 0 ; VOID [180]
.BYTE 0 ; VOID [181]
.BYTE 0 ; VOID [182]
.BYTE 0 ; VOID [183]
.BYTE 0 ; VOID [184]
.BYTE 0 ; VOID [185]
.BYTE 0 ; VOID [186]
.BYTE 0 ; VOID [187]
.BYTE 0 ; VOID [188]
.BYTE 0 ; VOID [189]
.BYTE 0 ; VOID [190]
.BYTE 0 ; VOID [191]
.BYTE 0 ; VOID [192]
.BYTE 0 ; VOID [193]
.BYTE 0 ; VOID [194]
.BYTE 0 ; VOID [195]
.BYTE 0 ; VOID [196]
.BYTE 0 ; VOID [197]
.BYTE 0 ; VOID [198]
.BYTE 0 ; VOID [199]
.BYTE 0 ; VOID [200]
.BYTE 0 ; VOID [201]
.BYTE 0 ; VOID [202]
.BYTE 0 ; VOID [203]
.BYTE 0 ; VOID [204]
.BYTE 0 ; VOID [205]
.BYTE 0 ; VOID [206]
.BYTE 0 ; VOID [207]
.BYTE 0 ; VOID [208]
.BYTE 0 ; VOID [209]
.BYTE 0 ; VOID [210]
.BYTE 0 ; VOID [211]
.BYTE 0 ; VOID [212]
.BYTE 0 ; VOID [213]
.BYTE 0 ; VOID [214]
.BYTE 0 ; VOID [215]
.BYTE 0 ; VOID [216]
.BYTE 0 ; VOID [217]
.BYTE 0 ; VOID [218]
.BYTE 0 ; VOID [219]
.BYTE 0 ; VOID [220]
.BYTE 0 ; VOID [221]
.BYTE 0 ; VOID [222]
.BYTE 0 ; VOID [223]
.BYTE 0 ; VOID [224]
.BYTE 0 ; VOID [225]
.BYTE 0 ; VOID [226]
.BYTE 0 ; VOID [227]
.BYTE 0 ; VOID [228]
.BYTE 0 ; VOID [229]
.BYTE 0 ; VOID [230]
.BYTE 0 ; VOID [231]
.BYTE 0 ; VOID [232]
.BYTE 0 ; VOID [233]
.BYTE 0 ; VOID [234]
.BYTE 0 ; VOID [235]
.BYTE 0 ; VOID [236]
.BYTE 0 ; VOID [237]
.BYTE 0 ; VOID [238]
.BYTE 0 ; VOID [239]
.BYTE 0 ; VOID [240]
.BYTE 0 ; VOID [241]
.BYTE 0 ; VOID [242]
.BYTE 0 ; VOID [243]
.BYTE 0 ; VOID [244]
.BYTE 0 ; VOID [245]
.BYTE 0 ; VOID [246]
.BYTE 0 ; VOID [247]
.BYTE 0 ; VOID [248]
.BYTE 0 ; VOID [249]
.BYTE 0 ; VOID [250]
.BYTE 0 ; VOID [251]
.BYTE 0 ; VOID [252]
.BYTE 0 ; VOID [253]
.BYTE 0 ; VOID [254]
.BYTE 0 ; VOID [255]
.BYTE 0 ; VOID [256]
.BYTE 0 ; VOID [257]
.BYTE 0 ; VOID [258]
.BYTE 0 ; VOID [259]
.BYTE 0 ; VOID [260]
.BYTE 0 ; VOID [261]
.BYTE 0 ; VOID [262]
.BYTE 0 ; VOID [263]
.BYTE 0 ; VOID [264]
.BYTE 0 ; VOID [265]
.BYTE 0 ; VOID [266]
.BYTE 0 ; VOID [267]
.BYTE 0 ; VOID [268]
.BYTE 0 ; VOID [269]
.BYTE 0 ; VOID [270]
.BYTE 0 ; VOID [271]
.BYTE 0 ; VOID [272]
.BYTE 0 ; VOID [273]
.BYTE 0 ; VOID [274]
.BYTE 0 ; VOID [275]
.BYTE 0 ; VOID [276]
.BYTE 0 ; VOID [277]
.BYTE 0 ; VOID [278]
.BYTE 0 ; VOID [279]
.BYTE 0 ; VOID [280]
.BYTE 0 ; VOID [281]
.BYTE 0 ; VOID [282]
.BYTE 0 ; VOID [283]
.BYTE 0 ; VOID [284]
.BYTE 0 ; VOID [285]
.BYTE 0 ; VOID [286]
.BYTE 0 ; VOID [287]
.BYTE 0 ; VOID [288]
.BYTE 0 ; VOID [289]
.BYTE 0 ; VOID [290]
.BYTE 0 ; VOID [291]
.BYTE 0 ; VOID [292]
.BYTE 0 ; VOID [293]
.BYTE 0 ; VOID [294]
.BYTE 0 ; VOID [295]
.BYTE 0 ; VOID [296]
.BYTE 0 ; VOID [297]
.BYTE 0 ; VOID [298]
.BYTE 0 ; VOID [299]
.BYTE 0 ; VOID [300]
.BYTE 0 ; VOID [301]
.BYTE 0 ; VOID [302]
.BYTE 0 ; VOID [303]
.BYTE 0 ; VOID [304]
.BYTE 0 ; VOID [305]
.BYTE 0 ; VOID [306]
.BYTE 0 ; VOID [307]
.BYTE 0 ; VOID [308]
.BYTE 0 ; VOID [309]
.BYTE 0 ; VOID [310]
.BYTE 0 ; VOID [311]
.BYTE 0 ; VOID [312]
.BYTE 0 ; VOID [313]
.BYTE 0 ; VOID [314]
.BYTE 0 ; VOID [315]
.BYTE 0 ; VOID [316]
.BYTE 0 ; VOID [317]
.BYTE 0 ; VOID [318]
.BYTE 0 ; VOID [319]
.BYTE 0 ; VOID [320]
.BYTE 0 ; VOID [321]
.BYTE 0 ; VOID [322]
.BYTE 0 ; VOID [323]
.BYTE 0 ; VOID [324]
.BYTE 0 ; VOID [325]
.BYTE 0 ; VOID [326]
.BYTE 0 ; VOID [327]
.BYTE 0 ; VOID [328]
.BYTE 0 ; VOID [329]
.BYTE 0 ; VOID [330]
.BYTE 0 ; VOID [331]
.BYTE 0 ; VOID [332]
.BYTE 0 ; VOID [333]
.BYTE 0 ; VOID [334]
.BYTE 0 ; VOID [335]
.BYTE 0 ; VOID [336]
.BYTE 0 ; VOID [337]
.BYTE 0 ; VOID [338]
.BYTE 0 ; VOID [339]
.BYTE 0 ; VOID [340]
.BYTE 0 ; VOID [341]
.BYTE 0 ; VOID [342]
.BYTE 0 ; VOID [343]
.BYTE 0 ; VOID [344]
.BYTE 0 ; VOID [345]
.BYTE 0 ; VOID [346]
.BYTE 0 ; VOID [347]
.BYTE 0 ; VOID [348]
.BYTE 0 ; VOID [349]
.BYTE 0 ; VOID [350]
.BYTE 0 ; VOID [351]
.BYTE 0 ; VOID [352]
.BYTE 0 ; VOID [353]
.BYTE 0 ; VOID [354]
.BYTE 0 ; VOID [355]
.BYTE 0 ; VOID [356]
.BYTE 0 ; VOID [357]
.BYTE 0 ; VOID [358]
.BYTE 0 ; VOID [359]
.BYTE 0 ; VOID [360]
.BYTE 0 ; VOID [361]
.BYTE 0 ; VOID [362]
.BYTE 0 ; VOID [363]
.BYTE 0 ; VOID [364]
.BYTE 0 ; VOID [365]
.BYTE 0 ; VOID [366]
.BYTE 0 ; VOID [367]
.BYTE 0 ; VOID [368]
.BYTE 0 ; VOID [369]
.BYTE 0 ; VOID [370]
.BYTE 0 ; VOID [371]
.BYTE 0 ; VOID [372]
.BYTE 0 ; VOID [373]
.BYTE 0 ; VOID [374]
.BYTE 0 ; VOID [375]
.BYTE 0 ; VOID [376]
.BYTE 0 ; VOID [377]
.BYTE 0 ; VOID [378]
.BYTE 0 ; VOID [379]
.BYTE 0 ; VOID [380]
.BYTE 0 ; VOID [381]
.BYTE 0 ; VOID [382]
.BYTE 0 ; VOID [383]
.BYTE 0 ; VOID [384]
.BYTE 0 ; VOID [385]
.BYTE 0 ; VOID [386]
.BYTE 0 ; VOID [387]
.BYTE 0 ; VOID [388]
.BYTE 0 ; VOID [389]
.BYTE 0 ; VOID [390]
.BYTE 0 ; VOID [391]
.BYTE 0 ; VOID [392]
.BYTE 0 ; VOID [393]
.BYTE 0 ; VOID [394]
.BYTE 0 ; VOID [395]
.BYTE 0 ; VOID [396]
.BYTE 0 ; VOID [397]
.BYTE 0 ; VOID [398]
.BYTE 0 ; VOID [399]
Ctos_1: ;
.WORD 0
.WORD 0
.WORD Cmain_1 ; & main_1
Ctop_1: ;
;;; } 37 Declaration
;;; ------------------------------------;
;;; { 37 Declaration
;;; { 38 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 38 TypeSpecifier (all)
Cstack_2: ;
.BYTE 0 ; VOID [0]
.BYTE 0 ; VOID [1]
.BYTE 0 ; VOID [2]
.BYTE 0 ; VOID [3]
.BYTE 0 ; VOID [4]
.BYTE 0 ; VOID [5]
.BYTE 0 ; VOID [6]
.BYTE 0 ; VOID [7]
.BYTE 0 ; VOID [8]
.BYTE 0 ; VOID [9]
.BYTE 0 ; VOID [10]
.BYTE 0 ; VOID [11]
.BYTE 0 ; VOID [12]
.BYTE 0 ; VOID [13]
.BYTE 0 ; VOID [14]
.BYTE 0 ; VOID [15]
.BYTE 0 ; VOID [16]
.BYTE 0 ; VOID [17]
.BYTE 0 ; VOID [18]
.BYTE 0 ; VOID [19]
.BYTE 0 ; VOID [20]
.BYTE 0 ; VOID [21]
.BYTE 0 ; VOID [22]
.BYTE 0 ; VOID [23]
.BYTE 0 ; VOID [24]
.BYTE 0 ; VOID [25]
.BYTE 0 ; VOID [26]
.BYTE 0 ; VOID [27]
.BYTE 0 ; VOID [28]
.BYTE 0 ; VOID [29]
.BYTE 0 ; VOID [30]
.BYTE 0 ; VOID [31]
.BYTE 0 ; VOID [32]
.BYTE 0 ; VOID [33]
.BYTE 0 ; VOID [34]
.BYTE 0 ; VOID [35]
.BYTE 0 ; VOID [36]
.BYTE 0 ; VOID [37]
.BYTE 0 ; VOID [38]
.BYTE 0 ; VOID [39]
.BYTE 0 ; VOID [40]
.BYTE 0 ; VOID [41]
.BYTE 0 ; VOID [42]
.BYTE 0 ; VOID [43]
.BYTE 0 ; VOID [44]
.BYTE 0 ; VOID [45]
.BYTE 0 ; VOID [46]
.BYTE 0 ; VOID [47]
.BYTE 0 ; VOID [48]
.BYTE 0 ; VOID [49]
.BYTE 0 ; VOID [50]
.BYTE 0 ; VOID [51]
.BYTE 0 ; VOID [52]
.BYTE 0 ; VOID [53]
.BYTE 0 ; VOID [54]
.BYTE 0 ; VOID [55]
.BYTE 0 ; VOID [56]
.BYTE 0 ; VOID [57]
.BYTE 0 ; VOID [58]
.BYTE 0 ; VOID [59]
.BYTE 0 ; VOID [60]
.BYTE 0 ; VOID [61]
.BYTE 0 ; VOID [62]
.BYTE 0 ; VOID [63]
.BYTE 0 ; VOID [64]
.BYTE 0 ; VOID [65]
.BYTE 0 ; VOID [66]
.BYTE 0 ; VOID [67]
.BYTE 0 ; VOID [68]
.BYTE 0 ; VOID [69]
.BYTE 0 ; VOID [70]
.BYTE 0 ; VOID [71]
.BYTE 0 ; VOID [72]
.BYTE 0 ; VOID [73]
.BYTE 0 ; VOID [74]
.BYTE 0 ; VOID [75]
.BYTE 0 ; VOID [76]
.BYTE 0 ; VOID [77]
.BYTE 0 ; VOID [78]
.BYTE 0 ; VOID [79]
.BYTE 0 ; VOID [80]
.BYTE 0 ; VOID [81]
.BYTE 0 ; VOID [82]
.BYTE 0 ; VOID [83]
.BYTE 0 ; VOID [84]
.BYTE 0 ; VOID [85]
.BYTE 0 ; VOID [86]
.BYTE 0 ; VOID [87]
.BYTE 0 ; VOID [88]
.BYTE 0 ; VOID [89]
.BYTE 0 ; VOID [90]
.BYTE 0 ; VOID [91]
.BYTE 0 ; VOID [92]
.BYTE 0 ; VOID [93]
.BYTE 0 ; VOID [94]
.BYTE 0 ; VOID [95]
.BYTE 0 ; VOID [96]
.BYTE 0 ; VOID [97]
.BYTE 0 ; VOID [98]
.BYTE 0 ; VOID [99]
.BYTE 0 ; VOID [100]
.BYTE 0 ; VOID [101]
.BYTE 0 ; VOID [102]
.BYTE 0 ; VOID [103]
.BYTE 0 ; VOID [104]
.BYTE 0 ; VOID [105]
.BYTE 0 ; VOID [106]
.BYTE 0 ; VOID [107]
.BYTE 0 ; VOID [108]
.BYTE 0 ; VOID [109]
.BYTE 0 ; VOID [110]
.BYTE 0 ; VOID [111]
.BYTE 0 ; VOID [112]
.BYTE 0 ; VOID [113]
.BYTE 0 ; VOID [114]
.BYTE 0 ; VOID [115]
.BYTE 0 ; VOID [116]
.BYTE 0 ; VOID [117]
.BYTE 0 ; VOID [118]
.BYTE 0 ; VOID [119]
.BYTE 0 ; VOID [120]
.BYTE 0 ; VOID [121]
.BYTE 0 ; VOID [122]
.BYTE 0 ; VOID [123]
.BYTE 0 ; VOID [124]
.BYTE 0 ; VOID [125]
.BYTE 0 ; VOID [126]
.BYTE 0 ; VOID [127]
.BYTE 0 ; VOID [128]
.BYTE 0 ; VOID [129]
.BYTE 0 ; VOID [130]
.BYTE 0 ; VOID [131]
.BYTE 0 ; VOID [132]
.BYTE 0 ; VOID [133]
.BYTE 0 ; VOID [134]
.BYTE 0 ; VOID [135]
.BYTE 0 ; VOID [136]
.BYTE 0 ; VOID [137]
.BYTE 0 ; VOID [138]
.BYTE 0 ; VOID [139]
.BYTE 0 ; VOID [140]
.BYTE 0 ; VOID [141]
.BYTE 0 ; VOID [142]
.BYTE 0 ; VOID [143]
.BYTE 0 ; VOID [144]
.BYTE 0 ; VOID [145]
.BYTE 0 ; VOID [146]
.BYTE 0 ; VOID [147]
.BYTE 0 ; VOID [148]
.BYTE 0 ; VOID [149]
.BYTE 0 ; VOID [150]
.BYTE 0 ; VOID [151]
.BYTE 0 ; VOID [152]
.BYTE 0 ; VOID [153]
.BYTE 0 ; VOID [154]
.BYTE 0 ; VOID [155]
.BYTE 0 ; VOID [156]
.BYTE 0 ; VOID [157]
.BYTE 0 ; VOID [158]
.BYTE 0 ; VOID [159]
.BYTE 0 ; VOID [160]
.BYTE 0 ; VOID [161]
.BYTE 0 ; VOID [162]
.BYTE 0 ; VOID [163]
.BYTE 0 ; VOID [164]
.BYTE 0 ; VOID [165]
.BYTE 0 ; VOID [166]
.BYTE 0 ; VOID [167]
.BYTE 0 ; VOID [168]
.BYTE 0 ; VOID [169]
.BYTE 0 ; VOID [170]
.BYTE 0 ; VOID [171]
.BYTE 0 ; VOID [172]
.BYTE 0 ; VOID [173]
.BYTE 0 ; VOID [174]
.BYTE 0 ; VOID [175]
.BYTE 0 ; VOID [176]
.BYTE 0 ; VOID [177]
.BYTE 0 ; VOID [178]
.BYTE 0 ; VOID [179]
.BYTE 0 ; VOID [180]
.BYTE 0 ; VOID [181]
.BYTE 0 ; VOID [182]
.BYTE 0 ; VOID [183]
.BYTE 0 ; VOID [184]
.BYTE 0 ; VOID [185]
.BYTE 0 ; VOID [186]
.BYTE 0 ; VOID [187]
.BYTE 0 ; VOID [188]
.BYTE 0 ; VOID [189]
.BYTE 0 ; VOID [190]
.BYTE 0 ; VOID [191]
.BYTE 0 ; VOID [192]
.BYTE 0 ; VOID [193]
.BYTE 0 ; VOID [194]
.BYTE 0 ; VOID [195]
.BYTE 0 ; VOID [196]
.BYTE 0 ; VOID [197]
.BYTE 0 ; VOID [198]
.BYTE 0 ; VOID [199]
.BYTE 0 ; VOID [200]
.BYTE 0 ; VOID [201]
.BYTE 0 ; VOID [202]
.BYTE 0 ; VOID [203]
.BYTE 0 ; VOID [204]
.BYTE 0 ; VOID [205]
.BYTE 0 ; VOID [206]
.BYTE 0 ; VOID [207]
.BYTE 0 ; VOID [208]
.BYTE 0 ; VOID [209]
.BYTE 0 ; VOID [210]
.BYTE 0 ; VOID [211]
.BYTE 0 ; VOID [212]
.BYTE 0 ; VOID [213]
.BYTE 0 ; VOID [214]
.BYTE 0 ; VOID [215]
.BYTE 0 ; VOID [216]
.BYTE 0 ; VOID [217]
.BYTE 0 ; VOID [218]
.BYTE 0 ; VOID [219]
.BYTE 0 ; VOID [220]
.BYTE 0 ; VOID [221]
.BYTE 0 ; VOID [222]
.BYTE 0 ; VOID [223]
.BYTE 0 ; VOID [224]
.BYTE 0 ; VOID [225]
.BYTE 0 ; VOID [226]
.BYTE 0 ; VOID [227]
.BYTE 0 ; VOID [228]
.BYTE 0 ; VOID [229]
.BYTE 0 ; VOID [230]
.BYTE 0 ; VOID [231]
.BYTE 0 ; VOID [232]
.BYTE 0 ; VOID [233]
.BYTE 0 ; VOID [234]
.BYTE 0 ; VOID [235]
.BYTE 0 ; VOID [236]
.BYTE 0 ; VOID [237]
.BYTE 0 ; VOID [238]
.BYTE 0 ; VOID [239]
.BYTE 0 ; VOID [240]
.BYTE 0 ; VOID [241]
.BYTE 0 ; VOID [242]
.BYTE 0 ; VOID [243]
.BYTE 0 ; VOID [244]
.BYTE 0 ; VOID [245]
.BYTE 0 ; VOID [246]
.BYTE 0 ; VOID [247]
.BYTE 0 ; VOID [248]
.BYTE 0 ; VOID [249]
.BYTE 0 ; VOID [250]
.BYTE 0 ; VOID [251]
.BYTE 0 ; VOID [252]
.BYTE 0 ; VOID [253]
.BYTE 0 ; VOID [254]
.BYTE 0 ; VOID [255]
.BYTE 0 ; VOID [256]
.BYTE 0 ; VOID [257]
.BYTE 0 ; VOID [258]
.BYTE 0 ; VOID [259]
.BYTE 0 ; VOID [260]
.BYTE 0 ; VOID [261]
.BYTE 0 ; VOID [262]
.BYTE 0 ; VOID [263]
.BYTE 0 ; VOID [264]
.BYTE 0 ; VOID [265]
.BYTE 0 ; VOID [266]
.BYTE 0 ; VOID [267]
.BYTE 0 ; VOID [268]
.BYTE 0 ; VOID [269]
.BYTE 0 ; VOID [270]
.BYTE 0 ; VOID [271]
.BYTE 0 ; VOID [272]
.BYTE 0 ; VOID [273]
.BYTE 0 ; VOID [274]
.BYTE 0 ; VOID [275]
.BYTE 0 ; VOID [276]
.BYTE 0 ; VOID [277]
.BYTE 0 ; VOID [278]
.BYTE 0 ; VOID [279]
.BYTE 0 ; VOID [280]
.BYTE 0 ; VOID [281]
.BYTE 0 ; VOID [282]
.BYTE 0 ; VOID [283]
.BYTE 0 ; VOID [284]
.BYTE 0 ; VOID [285]
.BYTE 0 ; VOID [286]
.BYTE 0 ; VOID [287]
.BYTE 0 ; VOID [288]
.BYTE 0 ; VOID [289]
.BYTE 0 ; VOID [290]
.BYTE 0 ; VOID [291]
.BYTE 0 ; VOID [292]
.BYTE 0 ; VOID [293]
.BYTE 0 ; VOID [294]
.BYTE 0 ; VOID [295]
.BYTE 0 ; VOID [296]
.BYTE 0 ; VOID [297]
.BYTE 0 ; VOID [298]
.BYTE 0 ; VOID [299]
.BYTE 0 ; VOID [300]
.BYTE 0 ; VOID [301]
.BYTE 0 ; VOID [302]
.BYTE 0 ; VOID [303]
.BYTE 0 ; VOID [304]
.BYTE 0 ; VOID [305]
.BYTE 0 ; VOID [306]
.BYTE 0 ; VOID [307]
.BYTE 0 ; VOID [308]
.BYTE 0 ; VOID [309]
.BYTE 0 ; VOID [310]
.BYTE 0 ; VOID [311]
.BYTE 0 ; VOID [312]
.BYTE 0 ; VOID [313]
.BYTE 0 ; VOID [314]
.BYTE 0 ; VOID [315]
.BYTE 0 ; VOID [316]
.BYTE 0 ; VOID [317]
.BYTE 0 ; VOID [318]
.BYTE 0 ; VOID [319]
.BYTE 0 ; VOID [320]
.BYTE 0 ; VOID [321]
.BYTE 0 ; VOID [322]
.BYTE 0 ; VOID [323]
.BYTE 0 ; VOID [324]
.BYTE 0 ; VOID [325]
.BYTE 0 ; VOID [326]
.BYTE 0 ; VOID [327]
.BYTE 0 ; VOID [328]
.BYTE 0 ; VOID [329]
.BYTE 0 ; VOID [330]
.BYTE 0 ; VOID [331]
.BYTE 0 ; VOID [332]
.BYTE 0 ; VOID [333]
.BYTE 0 ; VOID [334]
.BYTE 0 ; VOID [335]
.BYTE 0 ; VOID [336]
.BYTE 0 ; VOID [337]
.BYTE 0 ; VOID [338]
.BYTE 0 ; VOID [339]
.BYTE 0 ; VOID [340]
.BYTE 0 ; VOID [341]
.BYTE 0 ; VOID [342]
.BYTE 0 ; VOID [343]
.BYTE 0 ; VOID [344]
.BYTE 0 ; VOID [345]
.BYTE 0 ; VOID [346]
.BYTE 0 ; VOID [347]
.BYTE 0 ; VOID [348]
.BYTE 0 ; VOID [349]
.BYTE 0 ; VOID [350]
.BYTE 0 ; VOID [351]
.BYTE 0 ; VOID [352]
.BYTE 0 ; VOID [353]
.BYTE 0 ; VOID [354]
.BYTE 0 ; VOID [355]
.BYTE 0 ; VOID [356]
.BYTE 0 ; VOID [357]
.BYTE 0 ; VOID [358]
.BYTE 0 ; VOID [359]
.BYTE 0 ; VOID [360]
.BYTE 0 ; VOID [361]
.BYTE 0 ; VOID [362]
.BYTE 0 ; VOID [363]
.BYTE 0 ; VOID [364]
.BYTE 0 ; VOID [365]
.BYTE 0 ; VOID [366]
.BYTE 0 ; VOID [367]
.BYTE 0 ; VOID [368]
.BYTE 0 ; VOID [369]
.BYTE 0 ; VOID [370]
.BYTE 0 ; VOID [371]
.BYTE 0 ; VOID [372]
.BYTE 0 ; VOID [373]
.BYTE 0 ; VOID [374]
.BYTE 0 ; VOID [375]
.BYTE 0 ; VOID [376]
.BYTE 0 ; VOID [377]
.BYTE 0 ; VOID [378]
.BYTE 0 ; VOID [379]
.BYTE 0 ; VOID [380]
.BYTE 0 ; VOID [381]
.BYTE 0 ; VOID [382]
.BYTE 0 ; VOID [383]
.BYTE 0 ; VOID [384]
.BYTE 0 ; VOID [385]
.BYTE 0 ; VOID [386]
.BYTE 0 ; VOID [387]
.BYTE 0 ; VOID [388]
.BYTE 0 ; VOID [389]
.BYTE 0 ; VOID [390]
.BYTE 0 ; VOID [391]
.BYTE 0 ; VOID [392]
.BYTE 0 ; VOID [393]
.BYTE 0 ; VOID [394]
.BYTE 0 ; VOID [395]
.BYTE 0 ; VOID [396]
.BYTE 0 ; VOID [397]
.BYTE 0 ; VOID [398]
.BYTE 0 ; VOID [399]
Ctos_2: ;
.WORD 0
.WORD 0
.WORD Cmain_2 ; & main_2
Ctop_2: ;
;;; } 37 Declaration
;;; ------------------------------------;
;;; { 37 Declaration
;;; { 38 TypeSpecifier (all)
;;; spec = unsigned int (82000)
;;; } 38 TypeSpecifier (all)
Cstack_3: ;
.BYTE 0 ; VOID [0]
.BYTE 0 ; VOID [1]
.BYTE 0 ; VOID [2]
.BYTE 0 ; VOID [3]
.BYTE 0 ; VOID [4]
.BYTE 0 ; VOID [5]
.BYTE 0 ; VOID [6]
.BYTE 0 ; VOID [7]
.BYTE 0 ; VOID [8]
.BYTE 0 ; VOID [9]
.BYTE 0 ; VOID [10]
.BYTE 0 ; VOID [11]
.BYTE 0 ; VOID [12]
.BYTE 0 ; VOID [13]
.BYTE 0 ; VOID [14]
.BYTE 0 ; VOID [15]
.BYTE 0 ; VOID [16]
.BYTE 0 ; VOID [17]
.BYTE 0 ; VOID [18]
.BYTE 0 ; VOID [19]
.BYTE 0 ; VOID [20]
.BYTE 0 ; VOID [21]
.BYTE 0 ; VOID [22]
.BYTE 0 ; VOID [23]
.BYTE 0 ; VOID [24]
.BYTE 0 ; VOID [25]
.BYTE 0 ; VOID [26]
.BYTE 0 ; VOID [27]
.BYTE 0 ; VOID [28]
.BYTE 0 ; VOID [29]
.BYTE 0 ; VOID [30]
.BYTE 0 ; VOID [31]
.BYTE 0 ; VOID [32]
.BYTE 0 ; VOID [33]
.BYTE 0 ; VOID [34]
.BYTE 0 ; VOID [35]
.BYTE 0 ; VOID [36]
.BYTE 0 ; VOID [37]
.BYTE 0 ; VOID [38]
.BYTE 0 ; VOID [39]
.BYTE 0 ; VOID [40]
.BYTE 0 ; VOID [41]
.BYTE 0 ; VOID [42]
.BYTE 0 ; VOID [43]
.BYTE 0 ; VOID [44]
.BYTE 0 ; VOID [45]
.BYTE 0 ; VOID [46]
.BYTE 0 ; VOID [47]
.BYTE 0 ; VOID [48]
.BYTE 0 ; VOID [49]
.BYTE 0 ; VOID [50]
.BYTE 0 ; VOID [51]
.BYTE 0 ; VOID [52]
.BYTE 0 ; VOID [53]
.BYTE 0 ; VOID [54]
.BYTE 0 ; VOID [55]
.BYTE 0 ; VOID [56]
.BYTE 0 ; VOID [57]
.BYTE 0 ; VOID [58]
.BYTE 0 ; VOID [59]
.BYTE 0 ; VOID [60]
.BYTE 0 ; VOID [61]
.BYTE 0 ; VOID [62]
.BYTE 0 ; VOID [63]
.BYTE 0 ; VOID [64]
.BYTE 0 ; VOID [65]
.BYTE 0 ; VOID [66]
.BYTE 0 ; VOID [67]
.BYTE 0 ; VOID [68]
.BYTE 0 ; VOID [69]
.BYTE 0 ; VOID [70]
.BYTE 0 ; VOID [71]
.BYTE 0 ; VOID [72]
.BYTE 0 ; VOID [73]
.BYTE 0 ; VOID [74]
.BYTE 0 ; VOID [75]
.BYTE 0 ; VOID [76]
.BYTE 0 ; VOID [77]
.BYTE 0 ; VOID [78]
.BYTE 0 ; VOID [79]
.BYTE 0 ; VOID [80]
.BYTE 0 ; VOID [81]
.BYTE 0 ; VOID [82]
.BYTE 0 ; VOID [83]
.BYTE 0 ; VOID [84]
.BYTE 0 ; VOID [85]
.BYTE 0 ; VOID [86]
.BYTE 0 ; VOID [87]
.BYTE 0 ; VOID [88]
.BYTE 0 ; VOID [89]
.BYTE 0 ; VOID [90]
.BYTE 0 ; VOID [91]
.BYTE 0 ; VOID [92]
.BYTE 0 ; VOID [93]
.BYTE 0 ; VOID [94]
.BYTE 0 ; VOID [95]
.BYTE 0 ; VOID [96]
.BYTE 0 ; VOID [97]
.BYTE 0 ; VOID [98]
.BYTE 0 ; VOID [99]
.BYTE 0 ; VOID [100]
.BYTE 0 ; VOID [101]
.BYTE 0 ; VOID [102]
.BYTE 0 ; VOID [103]
.BYTE 0 ; VOID [104]
.BYTE 0 ; VOID [105]
.BYTE 0 ; VOID [106]
.BYTE 0 ; VOID [107]
.BYTE 0 ; VOID [108]
.BYTE 0 ; VOID [109]
.BYTE 0 ; VOID [110]
.BYTE 0 ; VOID [111]
.BYTE 0 ; VOID [112]
.BYTE 0 ; VOID [113]
.BYTE 0 ; VOID [114]
.BYTE 0 ; VOID [115]
.BYTE 0 ; VOID [116]
.BYTE 0 ; VOID [117]
.BYTE 0 ; VOID [118]
.BYTE 0 ; VOID [119]
.BYTE 0 ; VOID [120]
.BYTE 0 ; VOID [121]
.BYTE 0 ; VOID [122]
.BYTE 0 ; VOID [123]
.BYTE 0 ; VOID [124]
.BYTE 0 ; VOID [125]
.BYTE 0 ; VOID [126]
.BYTE 0 ; VOID [127]
.BYTE 0 ; VOID [128]
.BYTE 0 ; VOID [129]
.BYTE 0 ; VOID [130]
.BYTE 0 ; VOID [131]
.BYTE 0 ; VOID [132]
.BYTE 0 ; VOID [133]
.BYTE 0 ; VOID [134]
.BYTE 0 ; VOID [135]
.BYTE 0 ; VOID [136]
.BYTE 0 ; VOID [137]
.BYTE 0 ; VOID [138]
.BYTE 0 ; VOID [139]
.BYTE 0 ; VOID [140]
.BYTE 0 ; VOID [141]
.BYTE 0 ; VOID [142]
.BYTE 0 ; VOID [143]
.BYTE 0 ; VOID [144]
.BYTE 0 ; VOID [145]
.BYTE 0 ; VOID [146]
.BYTE 0 ; VOID [147]
.BYTE 0 ; VOID [148]
.BYTE 0 ; VOID [149]
.BYTE 0 ; VOID [150]
.BYTE 0 ; VOID [151]
.BYTE 0 ; VOID [152]
.BYTE 0 ; VOID [153]
.BYTE 0 ; VOID [154]
.BYTE 0 ; VOID [155]
.BYTE 0 ; VOID [156]
.BYTE 0 ; VOID [157]
.BYTE 0 ; VOID [158]
.BYTE 0 ; VOID [159]
.BYTE 0 ; VOID [160]
.BYTE 0 ; VOID [161]
.BYTE 0 ; VOID [162]
.BYTE 0 ; VOID [163]
.BYTE 0 ; VOID [164]
.BYTE 0 ; VOID [165]
.BYTE 0 ; VOID [166]
.BYTE 0 ; VOID [167]
.BYTE 0 ; VOID [168]
.BYTE 0 ; VOID [169]
.BYTE 0 ; VOID [170]
.BYTE 0 ; VOID [171]
.BYTE 0 ; VOID [172]
.BYTE 0 ; VOID [173]
.BYTE 0 ; VOID [174]
.BYTE 0 ; VOID [175]
.BYTE 0 ; VOID [176]
.BYTE 0 ; VOID [177]
.BYTE 0 ; VOID [178]
.BYTE 0 ; VOID [179]
.BYTE 0 ; VOID [180]
.BYTE 0 ; VOID [181]
.BYTE 0 ; VOID [182]
.BYTE 0 ; VOID [183]
.BYTE 0 ; VOID [184]
.BYTE 0 ; VOID [185]
.BYTE 0 ; VOID [186]
.BYTE 0 ; VOID [187]
.BYTE 0 ; VOID [188]
.BYTE 0 ; VOID [189]
.BYTE 0 ; VOID [190]
.BYTE 0 ; VOID [191]
.BYTE 0 ; VOID [192]
.BYTE 0 ; VOID [193]
.BYTE 0 ; VOID [194]
.BYTE 0 ; VOID [195]
.BYTE 0 ; VOID [196]
.BYTE 0 ; VOID [197]
.BYTE 0 ; VOID [198]
.BYTE 0 ; VOID [199]
.BYTE 0 ; VOID [200]
.BYTE 0 ; VOID [201]
.BYTE 0 ; VOID [202]
.BYTE 0 ; VOID [203]
.BYTE 0 ; VOID [204]
.BYTE 0 ; VOID [205]
.BYTE 0 ; VOID [206]
.BYTE 0 ; VOID [207]
.BYTE 0 ; VOID [208]
.BYTE 0 ; VOID [209]
.BYTE 0 ; VOID [210]
.BYTE 0 ; VOID [211]
.BYTE 0 ; VOID [212]
.BYTE 0 ; VOID [213]
.BYTE 0 ; VOID [214]
.BYTE 0 ; VOID [215]
.BYTE 0 ; VOID [216]
.BYTE 0 ; VOID [217]
.BYTE 0 ; VOID [218]
.BYTE 0 ; VOID [219]
.BYTE 0 ; VOID [220]
.BYTE 0 ; VOID [221]
.BYTE 0 ; VOID [222]
.BYTE 0 ; VOID [223]
.BYTE 0 ; VOID [224]
.BYTE 0 ; VOID [225]
.BYTE 0 ; VOID [226]
.BYTE 0 ; VOID [227]
.BYTE 0 ; VOID [228]
.BYTE 0 ; VOID [229]
.BYTE 0 ; VOID [230]
.BYTE 0 ; VOID [231]
.BYTE 0 ; VOID [232]
.BYTE 0 ; VOID [233]
.BYTE 0 ; VOID [234]
.BYTE 0 ; VOID [235]
.BYTE 0 ; VOID [236]
.BYTE 0 ; VOID [237]
.BYTE 0 ; VOID [238]
.BYTE 0 ; VOID [239]
.BYTE 0 ; VOID [240]
.BYTE 0 ; VOID [241]
.BYTE 0 ; VOID [242]
.BYTE 0 ; VOID [243]
.BYTE 0 ; VOID [244]
.BYTE 0 ; VOID [245]
.BYTE 0 ; VOID [246]
.BYTE 0 ; VOID [247]
.BYTE 0 ; VOID [248]
.BYTE 0 ; VOID [249]
.BYTE 0 ; VOID [250]
.BYTE 0 ; VOID [251]
.BYTE 0 ; VOID [252]
.BYTE 0 ; VOID [253]
.BYTE 0 ; VOID [254]
.BYTE 0 ; VOID [255]
.BYTE 0 ; VOID [256]
.BYTE 0 ; VOID [257]
.BYTE 0 ; VOID [258]
.BYTE 0 ; VOID [259]
.BYTE 0 ; VOID [260]
.BYTE 0 ; VOID [261]
.BYTE 0 ; VOID [262]
.BYTE 0 ; VOID [263]
.BYTE 0 ; VOID [264]
.BYTE 0 ; VOID [265]
.BYTE 0 ; VOID [266]
.BYTE 0 ; VOID [267]
.BYTE 0 ; VOID [268]
.BYTE 0 ; VOID [269]
.BYTE 0 ; VOID [270]
.BYTE 0 ; VOID [271]
.BYTE 0 ; VOID [272]
.BYTE 0 ; VOID [273]
.BYTE 0 ; VOID [274]
.BYTE 0 ; VOID [275]
.BYTE 0 ; VOID [276]
.BYTE 0 ; VOID [277]
.BYTE 0 ; VOID [278]
.BYTE 0 ; VOID [279]
.BYTE 0 ; VOID [280]
.BYTE 0 ; VOID [281]
.BYTE 0 ; VOID [282]
.BYTE 0 ; VOID [283]
.BYTE 0 ; VOID [284]
.BYTE 0 ; VOID [285]
.BYTE 0 ; VOID [286]
.BYTE 0 ; VOID [287]
.BYTE 0 ; VOID [288]
.BYTE 0 ; VOID [289]
.BYTE 0 ; VOID [290]
.BYTE 0 ; VOID [291]
.BYTE 0 ; VOID [292]
.BYTE 0 ; VOID [293]
.BYTE 0 ; VOID [294]
.BYTE 0 ; VOID [295]
.BYTE 0 ; VOID [296]
.BYTE 0 ; VOID [297]
.BYTE 0 ; VOID [298]
.BYTE 0 ; VOID [299]
.BYTE 0 ; VOID [300]
.BYTE 0 ; VOID [301]
.BYTE 0 ; VOID [302]
.BYTE 0 ; VOID [303]
.BYTE 0 ; VOID [304]
.BYTE 0 ; VOID [305]
.BYTE 0 ; VOID [306]
.BYTE 0 ; VOID [307]
.BYTE 0 ; VOID [308]
.BYTE 0 ; VOID [309]
.BYTE 0 ; VOID [310]
.BYTE 0 ; VOID [311]
.BYTE 0 ; VOID [312]
.BYTE 0 ; VOID [313]
.BYTE 0 ; VOID [314]
.BYTE 0 ; VOID [315]
.BYTE 0 ; VOID [316]
.BYTE 0 ; VOID [317]
.BYTE 0 ; VOID [318]
.BYTE 0 ; VOID [319]
.BYTE 0 ; VOID [320]
.BYTE 0 ; VOID [321]
.BYTE 0 ; VOID [322]
.BYTE 0 ; VOID [323]
.BYTE 0 ; VOID [324]
.BYTE 0 ; VOID [325]
.BYTE 0 ; VOID [326]
.BYTE 0 ; VOID [327]
.BYTE 0 ; VOID [328]
.BYTE 0 ; VOID [329]
.BYTE 0 ; VOID [330]
.BYTE 0 ; VOID [331]
.BYTE 0 ; VOID [332]
.BYTE 0 ; VOID [333]
.BYTE 0 ; VOID [334]
.BYTE 0 ; VOID [335]
.BYTE 0 ; VOID [336]
.BYTE 0 ; VOID [337]
.BYTE 0 ; VOID [338]
.BYTE 0 ; VOID [339]
.BYTE 0 ; VOID [340]
.BYTE 0 ; VOID [341]
.BYTE 0 ; VOID [342]
.BYTE 0 ; VOID [343]
.BYTE 0 ; VOID [344]
.BYTE 0 ; VOID [345]
.BYTE 0 ; VOID [346]
.BYTE 0 ; VOID [347]
.BYTE 0 ; VOID [348]
.BYTE 0 ; VOID [349]
.BYTE 0 ; VOID [350]
.BYTE 0 ; VOID [351]
.BYTE 0 ; VOID [352]
.BYTE 0 ; VOID [353]
.BYTE 0 ; VOID [354]
.BYTE 0 ; VOID [355]
.BYTE 0 ; VOID [356]
.BYTE 0 ; VOID [357]
.BYTE 0 ; VOID [358]
.BYTE 0 ; VOID [359]
.BYTE 0 ; VOID [360]
.BYTE 0 ; VOID [361]
.BYTE 0 ; VOID [362]
.BYTE 0 ; VOID [363]
.BYTE 0 ; VOID [364]
.BYTE 0 ; VOID [365]
.BYTE 0 ; VOID [366]
.BYTE 0 ; VOID [367]
.BYTE 0 ; VOID [368]
.BYTE 0 ; VOID [369]
.BYTE 0 ; VOID [370]
.BYTE 0 ; VOID [371]
.BYTE 0 ; VOID [372]
.BYTE 0 ; VOID [373]
.BYTE 0 ; VOID [374]
.BYTE 0 ; VOID [375]
.BYTE 0 ; VOID [376]
.BYTE 0 ; VOID [377]
.BYTE 0 ; VOID [378]
.BYTE 0 ; VOID [379]
.BYTE 0 ; VOID [380]
.BYTE 0 ; VOID [381]
.BYTE 0 ; VOID [382]
.BYTE 0 ; VOID [383]
.BYTE 0 ; VOID [384]
.BYTE 0 ; VOID [385]
.BYTE 0 ; VOID [386]
.BYTE 0 ; VOID [387]
.BYTE 0 ; VOID [388]
.BYTE 0 ; VOID [389]
.BYTE 0 ; VOID [390]
.BYTE 0 ; VOID [391]
.BYTE 0 ; VOID [392]
.BYTE 0 ; VOID [393]
.BYTE 0 ; VOID [394]
.BYTE 0 ; VOID [395]
.BYTE 0 ; VOID [396]
.BYTE 0 ; VOID [397]
.BYTE 0 ; VOID [398]
.BYTE 0 ; VOID [399]
Ctos_3: ;
.WORD 0
.WORD 0
.WORD Cmain_3 ; & main_3
Ctop_3: ;
;;; } 37 Declaration
;;; ------------------------------------;
;;; { 37 Declaration
;;; { 38 TypeSpecifier (struct/union)
;;; spec = 'Task' (4000000)
;;; name = Task
;;; } 38 TypeSpecifier (struct/union)
Ctask_3: ;
.WORD Ctask_idle ; & task_idle
.WORD Ctos_3
.BYTE 0
.BYTE 30
.WORD Cstr_137
.WORD Cstack_3 ; & stack_3
.WORD Ctop_3 ; & top_3
.BYTE 0 ; VOID sema_ret
.BYTE 0 ; VOID saved_priority
.WORD 0 ; VOID waiting_for
.WORD 0 ; VOID next_waiting_task
.WORD 0 ; VOID sleep_count
;;; } 37 Declaration
;;; ------------------------------------;
;;; { 37 Declaration
;;; { 38 TypeSpecifier (struct/union)
;;; spec = 'Task' (4000000)
;;; name = Task
;;; } 38 TypeSpecifier (struct/union)
Ctask_2: ;
.WORD Ctask_3 ; & task_3
.WORD Ctos_2
.BYTE 0
.BYTE 40
.WORD Cstr_138
.WORD Cstack_2 ; & stack_2
.WORD Ctop_2 ; & top_2
.BYTE 0 ; VOID sema_ret
.BYTE 0 ; VOID saved_priority
.WORD 0 ; VOID waiting_for
.WORD 0 ; VOID next_waiting_task
.WORD 0 ; VOID sleep_count
;;; } 37 Declaration
;;; ------------------------------------;
;;; { 37 Declaration
;;; { 38 TypeSpecifier (struct/union)
;;; spec = 'Task' (4000000)
;;; name = Task
;;; } 38 TypeSpecifier (struct/union)
Ctask_1: ;
.WORD Ctask_2 ; & task_2
.WORD Ctos_1
.BYTE 0
.BYTE 50
.WORD Cstr_139
.WORD Cstack_1 ; & stack_1
.WORD Ctop_1 ; & top_1
.BYTE 0 ; VOID sema_ret
.BYTE 0 ; VOID saved_priority
.WORD 0 ; VOID waiting_for
.WORD 0 ; VOID next_waiting_task
.WORD 0 ; VOID sleep_count
;;; } 37 Declaration
;;; ------------------------------------;
;;; { 37 Declaration
;;; { 38 TypeSpecifier (struct/union)
;;; spec = 'Task' (4000000)
;;; name = Task
;;; } 38 TypeSpecifier (struct/union)
Ctask_idle: ;
.WORD Ctask_1 ; & task_1
.WORD 0
.BYTE 0
.BYTE 0
.WORD Cstr_140
.WORD 8064
.WORD 8192
.BYTE 0 ; VOID sema_ret
.BYTE 0 ; VOID saved_priority
.WORD 0 ; VOID waiting_for
.WORD 0 ; VOID next_waiting_task
.WORD 0 ; VOID sleep_count
;;; } 37 Declaration
;;; ------------------------------------;
;;; { 37 Declaration
;;; { 38 TypeSpecifier (struct/union)
;;; spec = 'Task' (4000000)
;;; name = Task
;;; } 38 TypeSpecifier (struct/union)
Ccurrent_task: ;
.WORD Ctask_idle ; & task_idle
;;; } 37 Declaration
;;; ------------------------------------;
Cstr_0: ;
.BYTE 0x72 ;
.BYTE 0x78 ;
.BYTE 0x5F ;
.BYTE 0x73 ;
.BYTE 0x65 ;
.BYTE 0x6D ;
.BYTE 0x61 ;
.BYTE 0x70 ;
.BYTE 0x68 ;
.BYTE 0x6F ;
.BYTE 0x72 ;
.BYTE 0x65 ;
.BYTE 0 ;
Cstr_1: ;
.BYTE 0x74 ;
.BYTE 0x61 ;
.BYTE 0x73 ;
.BYTE 0x6B ;
.BYTE 0x20 ;
.BYTE 0x32 ;
.BYTE 0x20 ;
.BYTE 0x63 ;
.BYTE 0x6F ;
.BYTE 0x6E ;
.BYTE 0x74 ;
.BYTE 0x72 ;
.BYTE 0x6F ;
.BYTE 0x6C ;
.BYTE 0 ;
Cstr_2: ;
.BYTE 0x74 ;
.BYTE 0x61 ;
.BYTE 0x73 ;
.BYTE 0x6B ;
.BYTE 0x20 ;
.BYTE 0x33 ;
.BYTE 0x20 ;
.BYTE 0x63 ;
.BYTE 0x6F ;
.BYTE 0x6E ;
.BYTE 0x74 ;
.BYTE 0x72 ;
.BYTE 0x6F ;
.BYTE 0x6C ;
.BYTE 0 ;
Cstr_3: ;
.BYTE 0x73 ;
.BYTE 0x65 ;
.BYTE 0x72 ;
.BYTE 0x69 ;
.BYTE 0x61 ;
.BYTE 0x6C ;
.BYTE 0x20 ;
.BYTE 0x6F ;
.BYTE 0x75 ;
.BYTE 0x74 ;
.BYTE 0 ;
Cstr_4: ;
.BYTE 0x74 ;
.BYTE 0x78 ;
.BYTE 0x5F ;
.BYTE 0x73 ;
.BYTE 0x65 ;
.BYTE 0x6D ;
.BYTE 0x61 ;
.BYTE 0x70 ;
.BYTE 0x68 ;
.BYTE 0x6F ;
.BYTE 0x72 ;
.BYTE 0x65 ;
.BYTE 0 ;
Cstr_36: ;
.BYTE 0x30 ;
.BYTE 0x31 ;
.BYTE 0x32 ;
.BYTE 0x33 ;
.BYTE 0x34 ;
.BYTE 0x35 ;
.BYTE 0x36 ;
.BYTE 0x37 ;
.BYTE 0x38 ;
.BYTE 0x39 ;
.BYTE 0x41 ;
.BYTE 0x42 ;
.BYTE 0x43 ;
.BYTE 0x44 ;
.BYTE 0x45 ;
.BYTE 0x46 ;
.BYTE 0 ;
Cstr_37: ;
.BYTE 0x30 ;
.BYTE 0x58 ;
.BYTE 0 ;
Cstr_38: ;
.BYTE 0 ;
Cstr_39: ;
.BYTE 0 ;
Cstr_40: ;
.BYTE 0 ;
Cstr_41: ;
.BYTE 0x30 ;
.BYTE 0x31 ;
.BYTE 0x32 ;
.BYTE 0x33 ;
.BYTE 0x34 ;
.BYTE 0x35 ;
.BYTE 0x36 ;
.BYTE 0x37 ;
.BYTE 0x38 ;
.BYTE 0x39 ;
.BYTE 0x61 ;
.BYTE 0x62 ;
.BYTE 0x63 ;
.BYTE 0x64 ;
.BYTE 0x65 ;
.BYTE 0x66 ;
.BYTE 0 ;
Cstr_42: ;
.BYTE 0x30 ;
.BYTE 0x78 ;
.BYTE 0 ;
Cstr_44: ;
.BYTE 0x25 ;
.BYTE 0x2D ;
.BYTE 0x32 ;
.BYTE 0x30 ;
.BYTE 0x73 ;
.BYTE 0x20 ;
.BYTE 0x25 ;
.BYTE 0x34 ;
.BYTE 0x64 ;
.BYTE 0x20 ;
.BYTE 0 ;
Cstr_45: ;
.BYTE 0x25 ;
.BYTE 0x73 ;
.BYTE 0x20 ;
.BYTE 0x2D ;
.BYTE 0x3E ;
.BYTE 0x20 ;
.BYTE 0 ;
Cstr_46: ;
.BYTE 0x30 ;
.BYTE 0 ;
Cstr_47: ;
.BYTE 0x6E ;
.BYTE 0x6F ;
.BYTE 0x6E ;
.BYTE 0x65 ;
.BYTE 0x2E ;
.BYTE 0 ;
Cstr_48: ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_49: ;
.BYTE 0x4C ;
.BYTE 0x6F ;
.BYTE 0x61 ;
.BYTE 0x64 ;
.BYTE 0x69 ;
.BYTE 0x6E ;
.BYTE 0x67 ;
.BYTE 0x20 ;
.BYTE 0x69 ;
.BYTE 0x6D ;
.BYTE 0x61 ;
.BYTE 0x67 ;
.BYTE 0x65 ;
.BYTE 0x2E ;
.BYTE 0x2E ;
.BYTE 0x2E ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_55: ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0x53 ;
.BYTE 0x65 ;
.BYTE 0x6D ;
.BYTE 0x61 ;
.BYTE 0x70 ;
.BYTE 0x68 ;
.BYTE 0x6F ;
.BYTE 0x72 ;
.BYTE 0x65 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x43 ;
.BYTE 0x6F ;
.BYTE 0x75 ;
.BYTE 0x6E ;
.BYTE 0x74 ;
.BYTE 0x20 ;
.BYTE 0x57 ;
.BYTE 0x61 ;
.BYTE 0x69 ;
.BYTE 0x74 ;
.BYTE 0x69 ;
.BYTE 0x6E ;
.BYTE 0x67 ;
.BYTE 0x20 ;
.BYTE 0x74 ;
.BYTE 0x61 ;
.BYTE 0x73 ;
.BYTE 0x6B ;
.BYTE 0x73 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_56: ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_57: ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_58: ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0x53 ;
.BYTE 0x65 ;
.BYTE 0x72 ;
.BYTE 0x69 ;
.BYTE 0x61 ;
.BYTE 0x6C ;
.BYTE 0x20 ;
.BYTE 0x4F ;
.BYTE 0x76 ;
.BYTE 0x65 ;
.BYTE 0x72 ;
.BYTE 0x66 ;
.BYTE 0x6C ;
.BYTE 0x6F ;
.BYTE 0x77 ;
.BYTE 0x73 ;
.BYTE 0x3A ;
.BYTE 0x20 ;
.BYTE 0x25 ;
.BYTE 0x75 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_59: ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0x54 ;
.BYTE 0x61 ;
.BYTE 0x73 ;
.BYTE 0x6B ;
.BYTE 0x20 ;
.BYTE 0x6E ;
.BYTE 0x61 ;
.BYTE 0x6D ;
.BYTE 0x65 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x50 ;
.BYTE 0x72 ;
.BYTE 0x69 ;
.BYTE 0x6F ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x50 ;
.BYTE 0x43 ;
.BYTE 0x20 ;
.BYTE 0x53 ;
.BYTE 0x74 ;
.BYTE 0x61 ;
.BYTE 0x63 ;
.BYTE 0x6B ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x53 ;
.BYTE 0x69 ;
.BYTE 0x7A ;
.BYTE 0x65 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x55 ;
.BYTE 0x73 ;
.BYTE 0x65 ;
.BYTE 0x64 ;
.BYTE 0x20 ;
.BYTE 0x4E ;
.BYTE 0x65 ;
.BYTE 0x78 ;
.BYTE 0x74 ;
.BYTE 0x20 ;
.BYTE 0x77 ;
.BYTE 0x61 ;
.BYTE 0x69 ;
.BYTE 0x74 ;
.BYTE 0x69 ;
.BYTE 0x6E ;
.BYTE 0x67 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x53 ;
.BYTE 0x74 ;
.BYTE 0x61 ;
.BYTE 0x74 ;
.BYTE 0x75 ;
.BYTE 0x73 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_61: ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_62: ;
.BYTE 0x25 ;
.BYTE 0x2D ;
.BYTE 0x31 ;
.BYTE 0x36 ;
.BYTE 0x73 ;
.BYTE 0x20 ;
.BYTE 0x25 ;
.BYTE 0x34 ;
.BYTE 0x64 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x25 ;
.BYTE 0x34 ;
.BYTE 0x58 ;
.BYTE 0x20 ;
.BYTE 0x25 ;
.BYTE 0x34 ;
.BYTE 0x58 ;
.BYTE 0x20 ;
.BYTE 0x25 ;
.BYTE 0x35 ;
.BYTE 0x64 ;
.BYTE 0x20 ;
.BYTE 0x25 ;
.BYTE 0x35 ;
.BYTE 0x64 ;
.BYTE 0x20 ;
.BYTE 0 ;
Cstr_63: ;
.BYTE 0x25 ;
.BYTE 0x2D ;
.BYTE 0x31 ;
.BYTE 0x36 ;
.BYTE 0x73 ;
.BYTE 0x20 ;
.BYTE 0 ;
Cstr_64: ;
.BYTE 0x6E ;
.BYTE 0x6F ;
.BYTE 0x6E ;
.BYTE 0x65 ;
.BYTE 0x2E ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0 ;
Cstr_65: ;
.BYTE 0x52 ;
.BYTE 0x55 ;
.BYTE 0x4E ;
.BYTE 0x20 ;
.BYTE 0 ;
Cstr_66: ;
.BYTE 0x53 ;
.BYTE 0x55 ;
.BYTE 0x53 ;
.BYTE 0x50 ;
.BYTE 0x20 ;
.BYTE 0 ;
Cstr_67: ;
.BYTE 0x53 ;
.BYTE 0x4C ;
.BYTE 0x45 ;
.BYTE 0x45 ;
.BYTE 0x50 ;
.BYTE 0x20 ;
.BYTE 0x25 ;
.BYTE 0x64 ;
.BYTE 0x20 ;
.BYTE 0x6D ;
.BYTE 0x73 ;
.BYTE 0x20 ;
.BYTE 0 ;
Cstr_68: ;
.BYTE 0x42 ;
.BYTE 0x4C ;
.BYTE 0x4B ;
.BYTE 0x44 ;
.BYTE 0x20 ;
.BYTE 0x6F ;
.BYTE 0x6E ;
.BYTE 0x20 ;
.BYTE 0x25 ;
.BYTE 0x73 ;
.BYTE 0x20 ;
.BYTE 0 ;
Cstr_69: ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_70: ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_71: ;
.BYTE 0x55 ;
.BYTE 0x70 ;
.BYTE 0x74 ;
.BYTE 0x69 ;
.BYTE 0x6D ;
.BYTE 0x65 ;
.BYTE 0x20 ;
.BYTE 0x69 ;
.BYTE 0x73 ;
.BYTE 0x20 ;
.BYTE 0x25 ;
.BYTE 0x34 ;
.BYTE 0x2E ;
.BYTE 0x34 ;
.BYTE 0x58 ;
.BYTE 0x25 ;
.BYTE 0x34 ;
.BYTE 0x2E ;
.BYTE 0x34 ;
.BYTE 0x58 ;
.BYTE 0x25 ;
.BYTE 0x34 ;
.BYTE 0x2E ;
.BYTE 0x34 ;
.BYTE 0x58 ;
.BYTE 0x20 ;
.BYTE 0x73 ;
.BYTE 0x65 ;
.BYTE 0x63 ;
.BYTE 0x6F ;
.BYTE 0x6E ;
.BYTE 0x64 ;
.BYTE 0x73 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_72: ;
.BYTE 0x25 ;
.BYTE 0x34 ;
.BYTE 0x2E ;
.BYTE 0x34 ;
.BYTE 0x58 ;
.BYTE 0x3A ;
.BYTE 0 ;
Cstr_73: ;
.BYTE 0x20 ;
.BYTE 0x25 ;
.BYTE 0x32 ;
.BYTE 0x2E ;
.BYTE 0x32 ;
.BYTE 0x58 ;
.BYTE 0 ;
Cstr_74: ;
.BYTE 0x20 ;
.BYTE 0x2D ;
.BYTE 0x20 ;
.BYTE 0 ;
Cstr_75: ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_83: ;
.BYTE 0x52 ;
.BYTE 0x45 ;
.BYTE 0x41 ;
.BYTE 0x44 ;
.BYTE 0x59 ;
.BYTE 0x0D ;
.BYTE 0 ;
Cstr_84: ;
.BYTE 0x25 ;
.BYTE 0x73 ;
.BYTE 0x20 ;
.BYTE 0x69 ;
.BYTE 0x73 ;
.BYTE 0x20 ;
.BYTE 0x62 ;
.BYTE 0x6F ;
.BYTE 0x72 ;
.BYTE 0x65 ;
.BYTE 0x64 ;
.BYTE 0x2E ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_85: ;
.BYTE 0x54 ;
.BYTE 0x61 ;
.BYTE 0x73 ;
.BYTE 0x6B ;
.BYTE 0x20 ;
.BYTE 0x32 ;
.BYTE 0x20 ;
.BYTE 0x6B ;
.BYTE 0x69 ;
.BYTE 0x63 ;
.BYTE 0x6B ;
.BYTE 0x65 ;
.BYTE 0x64 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_86: ;
.BYTE 0x54 ;
.BYTE 0x61 ;
.BYTE 0x73 ;
.BYTE 0x6B ;
.BYTE 0x20 ;
.BYTE 0x33 ;
.BYTE 0x20 ;
.BYTE 0x65 ;
.BYTE 0x6E ;
.BYTE 0x61 ;
.BYTE 0x62 ;
.BYTE 0x6C ;
.BYTE 0x65 ;
.BYTE 0x64 ;
.BYTE 0x20 ;
.BYTE 0x66 ;
.BYTE 0x6F ;
.BYTE 0x72 ;
.BYTE 0x20 ;
.BYTE 0x31 ;
.BYTE 0x30 ;
.BYTE 0x30 ;
.BYTE 0x20 ;
.BYTE 0x6D ;
.BYTE 0x73 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_91: ;
.BYTE 0x64 ;
.BYTE 0x65 ;
.BYTE 0x73 ;
.BYTE 0x63 ;
.BYTE 0x68 ;
.BYTE 0x65 ;
.BYTE 0x64 ;
.BYTE 0x75 ;
.BYTE 0x6C ;
.BYTE 0x65 ;
.BYTE 0x20 ;
.BYTE 0x74 ;
.BYTE 0x6F ;
.BYTE 0x6F ;
.BYTE 0x6B ;
.BYTE 0x20 ;
.BYTE 0x25 ;
.BYTE 0x64 ;
.BYTE 0x20 ;
.BYTE 0x43 ;
.BYTE 0x4C ;
.BYTE 0x4B ;
.BYTE 0x73 ;
.BYTE 0x20 ;
.BYTE 0x3D ;
.BYTE 0x20 ;
.BYTE 0x25 ;
.BYTE 0x64 ;
.BYTE 0x20 ;
.BYTE 0x75 ;
.BYTE 0x73 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_92: ;
.BYTE 0x44 ;
.BYTE 0x69 ;
.BYTE 0x73 ;
.BYTE 0x70 ;
.BYTE 0x6C ;
.BYTE 0x61 ;
.BYTE 0x79 ;
.BYTE 0x20 ;
.BYTE 0 ;
Cstr_93: ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_94: ;
.BYTE 0x4C ;
.BYTE 0x45 ;
.BYTE 0x44 ;
.BYTE 0x73 ;
.BYTE 0x20 ;
.BYTE 0 ;
Cstr_96: ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_97: ;
.BYTE 0x4D ;
.BYTE 0x65 ;
.BYTE 0x6D ;
.BYTE 0x6F ;
.BYTE 0x72 ;
.BYTE 0x79 ;
.BYTE 0x20 ;
.BYTE 0 ;
Cstr_98: ;
.BYTE 0x20 ;
.BYTE 0x56 ;
.BYTE 0x61 ;
.BYTE 0x6C ;
.BYTE 0x75 ;
.BYTE 0x65 ;
.BYTE 0x20 ;
.BYTE 0 ;
Cstr_99: ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_100: ;
.BYTE 0x44 ;
.BYTE 0x49 ;
.BYTE 0x50 ;
.BYTE 0x20 ;
.BYTE 0x73 ;
.BYTE 0x77 ;
.BYTE 0x69 ;
.BYTE 0x74 ;
.BYTE 0x63 ;
.BYTE 0x68 ;
.BYTE 0x20 ;
.BYTE 0x69 ;
.BYTE 0x73 ;
.BYTE 0x20 ;
.BYTE 0x30 ;
.BYTE 0x78 ;
.BYTE 0x25 ;
.BYTE 0x58 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_102: ;
.BYTE 0x54 ;
.BYTE 0x65 ;
.BYTE 0x6D ;
.BYTE 0x70 ;
.BYTE 0x65 ;
.BYTE 0x72 ;
.BYTE 0x61 ;
.BYTE 0x74 ;
.BYTE 0x75 ;
.BYTE 0x72 ;
.BYTE 0x65 ;
.BYTE 0x20 ;
.BYTE 0x69 ;
.BYTE 0x73 ;
.BYTE 0x20 ;
.BYTE 0x25 ;
.BYTE 0x64 ;
.BYTE 0x20 ;
.BYTE 0x64 ;
.BYTE 0x65 ;
.BYTE 0x67 ;
.BYTE 0x72 ;
.BYTE 0x65 ;
.BYTE 0x65 ;
.BYTE 0x73 ;
.BYTE 0x20 ;
.BYTE 0x43 ;
.BYTE 0x65 ;
.BYTE 0x6C ;
.BYTE 0x73 ;
.BYTE 0x69 ;
.BYTE 0x75 ;
.BYTE 0x73 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_104: ;
.BYTE 0x48 ;
.BYTE 0x61 ;
.BYTE 0x6C ;
.BYTE 0x74 ;
.BYTE 0x65 ;
.BYTE 0x64 ;
.BYTE 0x2E ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_107: ;
.BYTE 0x48 ;
.BYTE 0x65 ;
.BYTE 0x6C ;
.BYTE 0x70 ;
.BYTE 0x3A ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0x32 ;
.BYTE 0x20 ;
.BYTE 0x2D ;
.BYTE 0x20 ;
.BYTE 0x6B ;
.BYTE 0x69 ;
.BYTE 0x63 ;
.BYTE 0x6B ;
.BYTE 0x20 ;
.BYTE 0x74 ;
.BYTE 0x61 ;
.BYTE 0x73 ;
.BYTE 0x6B ;
.BYTE 0x20 ;
.BYTE 0x32 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0x33 ;
.BYTE 0x20 ;
.BYTE 0x2D ;
.BYTE 0x20 ;
.BYTE 0x6B ;
.BYTE 0x69 ;
.BYTE 0x63 ;
.BYTE 0x6B ;
.BYTE 0x20 ;
.BYTE 0x74 ;
.BYTE 0x61 ;
.BYTE 0x73 ;
.BYTE 0x6B ;
.BYTE 0x20 ;
.BYTE 0x33 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0x49 ;
.BYTE 0x20 ;
.BYTE 0x2D ;
.BYTE 0x20 ;
.BYTE 0x6C ;
.BYTE 0x6F ;
.BYTE 0x61 ;
.BYTE 0x64 ;
.BYTE 0x20 ;
.BYTE 0x69 ;
.BYTE 0x6D ;
.BYTE 0x61 ;
.BYTE 0x67 ;
.BYTE 0x65 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0x53 ;
.BYTE 0x20 ;
.BYTE 0x2D ;
.BYTE 0x20 ;
.BYTE 0x73 ;
.BYTE 0x68 ;
.BYTE 0x6F ;
.BYTE 0x77 ;
.BYTE 0x20 ;
.BYTE 0x73 ;
.BYTE 0x65 ;
.BYTE 0x6D ;
.BYTE 0x61 ;
.BYTE 0x70 ;
.BYTE 0x68 ;
.BYTE 0x6F ;
.BYTE 0x72 ;
.BYTE 0x65 ;
.BYTE 0x73 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0x54 ;
.BYTE 0x20 ;
.BYTE 0x2D ;
.BYTE 0x20 ;
.BYTE 0x73 ;
.BYTE 0x68 ;
.BYTE 0x6F ;
.BYTE 0x77 ;
.BYTE 0x20 ;
.BYTE 0x74 ;
.BYTE 0x61 ;
.BYTE 0x73 ;
.BYTE 0x6B ;
.BYTE 0x73 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0x62 ;
.BYTE 0x20 ;
.BYTE 0x2D ;
.BYTE 0x20 ;
.BYTE 0x6D ;
.BYTE 0x65 ;
.BYTE 0x61 ;
.BYTE 0x73 ;
.BYTE 0x75 ;
.BYTE 0x72 ;
.BYTE 0x65 ;
.BYTE 0x20 ;
.BYTE 0x74 ;
.BYTE 0x61 ;
.BYTE 0x73 ;
.BYTE 0x6B ;
.BYTE 0x20 ;
.BYTE 0x73 ;
.BYTE 0x77 ;
.BYTE 0x69 ;
.BYTE 0x74 ;
.BYTE 0x63 ;
.BYTE 0x68 ;
.BYTE 0x20 ;
.BYTE 0x28 ;
.BYTE 0x64 ;
.BYTE 0x65 ;
.BYTE 0x73 ;
.BYTE 0x63 ;
.BYTE 0x68 ;
.BYTE 0x65 ;
.BYTE 0x64 ;
.BYTE 0x75 ;
.BYTE 0x6C ;
.BYTE 0x65 ;
.BYTE 0x29 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0x63 ;
.BYTE 0x20 ;
.BYTE 0x2D ;
.BYTE 0x20 ;
.BYTE 0x73 ;
.BYTE 0x68 ;
.BYTE 0x6F ;
.BYTE 0x77 ;
.BYTE 0x20 ;
.BYTE 0x74 ;
.BYTE 0x69 ;
.BYTE 0x6D ;
.BYTE 0x65 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0x64 ;
.BYTE 0x20 ;
.BYTE 0x2D ;
.BYTE 0x20 ;
.BYTE 0x64 ;
.BYTE 0x69 ;
.BYTE 0x73 ;
.BYTE 0x70 ;
.BYTE 0x6C ;
.BYTE 0x61 ;
.BYTE 0x79 ;
.BYTE 0x20 ;
.BYTE 0x6D ;
.BYTE 0x65 ;
.BYTE 0x6D ;
.BYTE 0x6F ;
.BYTE 0x72 ;
.BYTE 0x79 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0x65 ;
.BYTE 0x20 ;
.BYTE 0x2D ;
.BYTE 0x20 ;
.BYTE 0x73 ;
.BYTE 0x65 ;
.BYTE 0x74 ;
.BYTE 0x20 ;
.BYTE 0x4C ;
.BYTE 0x45 ;
.BYTE 0x44 ;
.BYTE 0x73 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0x6D ;
.BYTE 0x20 ;
.BYTE 0x2D ;
.BYTE 0x20 ;
.BYTE 0x6D ;
.BYTE 0x6F ;
.BYTE 0x64 ;
.BYTE 0x69 ;
.BYTE 0x66 ;
.BYTE 0x79 ;
.BYTE 0x20 ;
.BYTE 0x6D ;
.BYTE 0x65 ;
.BYTE 0x6D ;
.BYTE 0x6F ;
.BYTE 0x72 ;
.BYTE 0x79 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0x73 ;
.BYTE 0x20 ;
.BYTE 0x2D ;
.BYTE 0x20 ;
.BYTE 0x72 ;
.BYTE 0x65 ;
.BYTE 0x61 ;
.BYTE 0x64 ;
.BYTE 0x20 ;
.BYTE 0x44 ;
.BYTE 0x49 ;
.BYTE 0x50 ;
.BYTE 0x20 ;
.BYTE 0x73 ;
.BYTE 0x77 ;
.BYTE 0x69 ;
.BYTE 0x74 ;
.BYTE 0x63 ;
.BYTE 0x68 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0x74 ;
.BYTE 0x20 ;
.BYTE 0x2D ;
.BYTE 0x20 ;
.BYTE 0x72 ;
.BYTE 0x65 ;
.BYTE 0x61 ;
.BYTE 0x64 ;
.BYTE 0x20 ;
.BYTE 0x74 ;
.BYTE 0x65 ;
.BYTE 0x6D ;
.BYTE 0x70 ;
.BYTE 0x65 ;
.BYTE 0x72 ;
.BYTE 0x61 ;
.BYTE 0x74 ;
.BYTE 0x75 ;
.BYTE 0x72 ;
.BYTE 0x65 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0x48 ;
.BYTE 0x20 ;
.BYTE 0x2D ;
.BYTE 0x20 ;
.BYTE 0x48 ;
.BYTE 0x41 ;
.BYTE 0x4C ;
.BYTE 0x54 ;
.BYTE 0x20 ;
.BYTE 0x28 ;
.BYTE 0x66 ;
.BYTE 0x6F ;
.BYTE 0x72 ;
.BYTE 0x65 ;
.BYTE 0x76 ;
.BYTE 0x65 ;
.BYTE 0x72 ;
.BYTE 0x29 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_123: ;
.BYTE 0x4D ;
.BYTE 0x65 ;
.BYTE 0x61 ;
.BYTE 0x73 ;
.BYTE 0x75 ;
.BYTE 0x72 ;
.BYTE 0x69 ;
.BYTE 0x6E ;
.BYTE 0x67 ;
.BYTE 0x2E ;
.BYTE 0x2E ;
.BYTE 0x2E ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_132: ;
.BYTE 0x74 ;
.BYTE 0x6F ;
.BYTE 0x74 ;
.BYTE 0x61 ;
.BYTE 0x6C ;
.BYTE 0x3A ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x25 ;
.BYTE 0x64 ;
.BYTE 0x20 ;
.BYTE 0x63 ;
.BYTE 0x79 ;
.BYTE 0x63 ;
.BYTE 0x6C ;
.BYTE 0x65 ;
.BYTE 0x73 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_133: ;
.BYTE 0x68 ;
.BYTE 0x61 ;
.BYTE 0x6C ;
.BYTE 0x74 ;
.BYTE 0x65 ;
.BYTE 0x64 ;
.BYTE 0x3A ;
.BYTE 0x20 ;
.BYTE 0x25 ;
.BYTE 0x64 ;
.BYTE 0x20 ;
.BYTE 0x63 ;
.BYTE 0x79 ;
.BYTE 0x63 ;
.BYTE 0x6C ;
.BYTE 0x65 ;
.BYTE 0x73 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_134: ;
.BYTE 0x69 ;
.BYTE 0x64 ;
.BYTE 0x6C ;
.BYTE 0x65 ;
.BYTE 0x3A ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x25 ;
.BYTE 0x64 ;
.BYTE 0x20 ;
.BYTE 0x25 ;
.BYTE 0x25 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_135: ;
.BYTE 0x6C ;
.BYTE 0x6F ;
.BYTE 0x61 ;
.BYTE 0x64 ;
.BYTE 0x3A ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x20 ;
.BYTE 0x25 ;
.BYTE 0x64 ;
.BYTE 0x20 ;
.BYTE 0x25 ;
.BYTE 0x25 ;
.BYTE 0x0D ;
.BYTE 0x0A ;
.BYTE 0 ;
Cstr_137: ;
.BYTE 0x4C ;
.BYTE 0x6F ;
.BYTE 0x61 ;
.BYTE 0x64 ;
.BYTE 0x20 ;
.BYTE 0x54 ;
.BYTE 0x61 ;
.BYTE 0x73 ;
.BYTE 0x6B ;
.BYTE 0x20 ;
.BYTE 0 ;
Cstr_138: ;
.BYTE 0x4D ;
.BYTE 0x65 ;
.BYTE 0x61 ;
.BYTE 0x73 ;
.BYTE 0x75 ;
.BYTE 0x72 ;
.BYTE 0x65 ;
.BYTE 0x6D ;
.BYTE 0x65 ;
.BYTE 0x6E ;
.BYTE 0x74 ;
.BYTE 0 ;
Cstr_139: ;
.BYTE 0x4D ;
.BYTE 0x6F ;
.BYTE 0x6E ;
.BYTE 0x69 ;
.BYTE 0x74 ;
.BYTE 0x6F ;
.BYTE 0x72 ;
.BYTE 0 ;
Cstr_140: ;
.BYTE 0x49 ;
.BYTE 0x64 ;
.BYTE 0x6C ;
.BYTE 0x65 ;
.BYTE 0x20 ;
.BYTE 0x54 ;
.BYTE 0x61 ;
.BYTE 0x73 ;
.BYTE 0x6B ;
.BYTE 0 ;
Cend_text: ;
Go to most recent revision | Compare with Previous | Blame | View Log