max_stars_repo_path stringlengths 4 261 | max_stars_repo_name stringlengths 6 106 | max_stars_count int64 0 38.8k | id stringlengths 1 6 | text stringlengths 7 1.05M |
|---|---|---|---|---|
src/test/resources/framework_specifications/PdslCommonLexer.g4 | google/polymorphicDSL | 3 | 3304 | lexer grammar PdslCommonLexer ;
import GherkinCommonLexer;
WHEN_THE_TEST_RESOURCE_IS_PROCESSED_BY_A_FACTORY : GHERKIN_STEP_KEYWORD 'the test resource is processed by ' ('the ' | 'a ') '"Test Specification Factory"' END ;
TEST_SPECIFICATION_IS_PRODUCED : GHERKIN_STEP_KEYWORD 'a "Test Specification" is produced' END ;
TEST_SPECIFICATION_IS_PROCESSED_BY_TEST_CASE_FACTORY : GHERKIN_STEP_KEYWORD 'the Test Specification is processed by a "Test Case Factory"' END ;
POLYMORPHIC_DSL_TEST_EXECUTOR : GHERKIN_STEP_KEYWORD 'a "Polymorphic DSL Test Executor"' END ;
TEST_CASE_IS_PROCESSED : GHERKIN_STEP_KEYWORD 'the Test Case' 's'? ' ' ('is ' | 'are ') 'processed by a "Polymorphic DSL Test Executor"' END ;
TEST_RUN_RESULT_PRODUCED : GHERKIN_STEP_KEYWORD 'a "Test Run Result" is produced' END ; |
tools/goctl/api/parser/g4/ApiParser.g4 | almas1992/go-zero | 0 | 4574 | <filename>tools/goctl/api/parser/g4/ApiParser.g4
grammar ApiParser;
import ApiLexer;
@lexer::members{
const COMEMNTS = 88
}
api: spec*;
spec: syntaxLit
|importSpec
|infoSpec
|typeSpec
|serviceSpec
;
// syntax
syntaxLit: {match(p,"syntax")}syntaxToken=ID assign='=' {checkVersion(p)}version=STRING;
// import
importSpec: importLit|importBlock;
importLit: {match(p,"import")}importToken=ID importValue ;
importBlock: {match(p,"import")}importToken=ID '(' importBlockValue+ ')';
importBlockValue: importValue;
importValue: {checkImportValue(p)}STRING;
// info
infoSpec: {match(p,"info")}infoToken=ID lp='(' kvLit+ rp=')';
// type
typeSpec: typeLit
|typeBlock;
// eg: type Foo int
typeLit: {match(p,"type")}typeToken=ID typeLitBody;
// eg: type (...)
typeBlock: {match(p,"type")}typeToken=ID lp='(' typeBlockBody* rp=')';
typeLitBody: typeStruct|typeAlias;
typeBlockBody: typeBlockStruct|typeBlockAlias;
typeStruct: {checkKeyword(p)}structName=ID structToken=ID? lbrace='{' field* rbrace='}';
typeAlias: {checkKeyword(p)}alias=ID assign='='? dataType;
typeBlockStruct: {checkKeyword(p)}structName=ID structToken=ID? lbrace='{' field* rbrace='}';
typeBlockAlias: {checkKeyword(p)}alias=ID assign='='? dataType;
field: {isNormal(p)}? normalField|anonymousFiled ;
normalField: {checkKeyword(p)}fieldName=ID dataType tag=RAW_STRING?;
anonymousFiled: star='*'? ID;
dataType: {isInterface(p)}ID
|mapType
|arrayType
|inter='interface{}'
|time='time.Time'
|pointerType
|typeStruct
;
pointerType: star='*' {checkKeyword(p)}ID;
mapType: {match(p,"map")}mapToken=ID lbrack='[' {checkKey(p)}key=ID rbrack=']' value=dataType;
arrayType: lbrack='[' rbrack=']' dataType;
// service
serviceSpec: atServer? serviceApi;
atServer: ATSERVER lp='(' kvLit+ rp=')';
serviceApi: {match(p,"service")}serviceToken=ID serviceName lbrace='{' serviceRoute* rbrace='}';
serviceRoute: atDoc? (atServer|atHandler) route;
atDoc: ATDOC lp='('? ((kvLit+)|STRING) rp=')'?;
atHandler: ATHANDLER ID;
route: {checkHTTPMethod(p)}httpMethod=ID path request=body? returnToken=ID? response=replybody?;
body: lp='(' (ID)? rp=')';
replybody: lp='(' dataType? rp=')';
// kv
kvLit: key=ID {checkKeyValue(p)}value=LINE_VALUE;
serviceName: (ID '-'?)+;
path: '/' | (('/' (ID ('-' ID)*))|('/:' (ID ('-' ID)?)))+; |
Data/Binary/Testers.agda | oisdk/agda-playground | 6 | 8514 | <gh_stars>1-10
{-# OPTIONS --cubical --safe #-}
module Data.Binary.Testers where
open import Prelude
open import Data.Binary.Conversion.Fast.Strict
open import Data.Binary.Definition
open import Data.List using (List; _⋯_)
open import Data.List.Sugar using (liftA2)
test : (𝔹 → 𝔹 → 𝔹) →
(ℕ → ℕ → ℕ) →
ℕ → Type
test bf nf n = let ns = 0 ⋯ n in
liftA2 (λ n m → bf ⟦ n ⇑⟧ ⟦ m ⇑⟧) ns ns ≡
liftA2 (λ n m → ⟦ nf n m ⇑⟧) ns ns
import Data.Nat as ℕ
open import Data.Binary.Addition using (_+_)
open import Data.Binary.Multiplication using (_*_)
_ : test _+_ ℕ._+_ 15
_ = refl
_ : test _*_ ℕ._*_ 15
_ = refl
|
kernel.asm | ericong18/lab2-f17 | 0 | 5141 | <filename>kernel.asm
kernel: file format elf32-i386
Disassembly of section .text:
80100000 <multiboot_header>:
80100000: 02 b0 ad 1b 00 00 add 0x1bad(%eax),%dh
80100006: 00 00 add %al,(%eax)
80100008: fe 4f 52 decb 0x52(%edi)
8010000b: e4 .byte 0xe4
8010000c <entry>:
# Entering xv6 on boot processor, with paging off.
.globl entry
entry:
# Turn on page size extension for 4Mbyte pages
movl %cr4, %eax
8010000c: 0f 20 e0 mov %cr4,%eax
orl $(CR4_PSE), %eax
8010000f: 83 c8 10 or $0x10,%eax
movl %eax, %cr4
80100012: 0f 22 e0 mov %eax,%cr4
# Set page directory
movl $(V2P_WO(entrypgdir)), %eax
80100015: b8 00 90 10 00 mov $0x109000,%eax
movl %eax, %cr3
8010001a: 0f 22 d8 mov %eax,%cr3
# Turn on paging.
movl %cr0, %eax
8010001d: 0f 20 c0 mov %cr0,%eax
orl $(CR0_PG|CR0_WP), %eax
80100020: 0d 00 00 01 80 or $0x80010000,%eax
movl %eax, %cr0
80100025: 0f 22 c0 mov %eax,%cr0
# Set up the stack pointer.
movl $(stack + KSTACKSIZE), %esp
80100028: bc c0 b5 10 80 mov $0x8010b5c0,%esp
# Jump to main(), and switch to executing at
# high addresses. The indirect call is needed because
# the assembler produces a PC-relative instruction
# for a direct jump.
mov $main, %eax
8010002d: b8 e0 2d 10 80 mov $0x80102de0,%eax
jmp *%eax
80100032: ff e0 jmp *%eax
80100034: 66 90 xchg %ax,%ax
80100036: 66 90 xchg %ax,%ax
80100038: 66 90 xchg %ax,%ax
8010003a: 66 90 xchg %ax,%ax
8010003c: 66 90 xchg %ax,%ax
8010003e: 66 90 xchg %ax,%ax
80100040 <binit>:
struct buf head;
} bcache;
void
binit(void)
{
80100040: 55 push %ebp
80100041: 89 e5 mov %esp,%ebp
80100043: 53 push %ebx
//PAGEBREAK!
// Create linked list of buffers
bcache.head.prev = &bcache.head;
bcache.head.next = &bcache.head;
for(b = bcache.buf; b < bcache.buf+NBUF; b++){
80100044: bb f4 b5 10 80 mov $0x8010b5f4,%ebx
{
80100049: 83 ec 14 sub $0x14,%esp
initlock(&bcache.lock, "bcache");
8010004c: c7 44 24 04 20 6e 10 movl $0x80106e20,0x4(%esp)
80100053: 80
80100054: c7 04 24 c0 b5 10 80 movl $0x8010b5c0,(%esp)
8010005b: e8 e0 3f 00 00 call 80104040 <initlock>
bcache.head.next = &bcache.head;
80100060: ba bc fc 10 80 mov $0x8010fcbc,%edx
bcache.head.prev = &bcache.head;
80100065: c7 05 0c fd 10 80 bc movl $0x8010fcbc,0x8010fd0c
8010006c: fc 10 80
bcache.head.next = &bcache.head;
8010006f: c7 05 10 fd 10 80 bc movl $0x8010fcbc,0x8010fd10
80100076: fc 10 80
80100079: eb 09 jmp 80100084 <binit+0x44>
8010007b: 90 nop
8010007c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80100080: 89 da mov %ebx,%edx
for(b = bcache.buf; b < bcache.buf+NBUF; b++){
80100082: 89 c3 mov %eax,%ebx
80100084: 8d 43 0c lea 0xc(%ebx),%eax
b->next = bcache.head.next;
80100087: 89 53 54 mov %edx,0x54(%ebx)
b->prev = &bcache.head;
8010008a: c7 43 50 bc fc 10 80 movl $0x8010fcbc,0x50(%ebx)
initsleeplock(&b->lock, "buffer");
80100091: 89 04 24 mov %eax,(%esp)
80100094: c7 44 24 04 27 6e 10 movl $0x80106e27,0x4(%esp)
8010009b: 80
8010009c: e8 8f 3e 00 00 call 80103f30 <initsleeplock>
bcache.head.next->prev = b;
801000a1: a1 10 fd 10 80 mov 0x8010fd10,%eax
801000a6: 89 58 50 mov %ebx,0x50(%eax)
for(b = bcache.buf; b < bcache.buf+NBUF; b++){
801000a9: 8d 83 5c 02 00 00 lea 0x25c(%ebx),%eax
801000af: 3d bc fc 10 80 cmp $0x8010fcbc,%eax
bcache.head.next = b;
801000b4: 89 1d 10 fd 10 80 mov %ebx,0x8010fd10
for(b = bcache.buf; b < bcache.buf+NBUF; b++){
801000ba: 75 c4 jne 80100080 <binit+0x40>
}
}
801000bc: 83 c4 14 add $0x14,%esp
801000bf: 5b pop %ebx
801000c0: 5d pop %ebp
801000c1: c3 ret
801000c2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
801000c9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801000d0 <bread>:
}
// Return a locked buf with the contents of the indicated block.
struct buf*
bread(uint dev, uint blockno)
{
801000d0: 55 push %ebp
801000d1: 89 e5 mov %esp,%ebp
801000d3: 57 push %edi
801000d4: 56 push %esi
801000d5: 53 push %ebx
801000d6: 83 ec 1c sub $0x1c,%esp
801000d9: 8b 75 08 mov 0x8(%ebp),%esi
acquire(&bcache.lock);
801000dc: c7 04 24 c0 b5 10 80 movl $0x8010b5c0,(%esp)
{
801000e3: 8b 7d 0c mov 0xc(%ebp),%edi
acquire(&bcache.lock);
801000e6: e8 45 40 00 00 call 80104130 <acquire>
for(b = bcache.head.next; b != &bcache.head; b = b->next){
801000eb: 8b 1d 10 fd 10 80 mov 0x8010fd10,%ebx
801000f1: 81 fb bc fc 10 80 cmp $0x8010fcbc,%ebx
801000f7: 75 12 jne 8010010b <bread+0x3b>
801000f9: eb 25 jmp 80100120 <bread+0x50>
801000fb: 90 nop
801000fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80100100: 8b 5b 54 mov 0x54(%ebx),%ebx
80100103: 81 fb bc fc 10 80 cmp $0x8010fcbc,%ebx
80100109: 74 15 je 80100120 <bread+0x50>
if(b->dev == dev && b->blockno == blockno){
8010010b: 3b 73 04 cmp 0x4(%ebx),%esi
8010010e: 75 f0 jne 80100100 <bread+0x30>
80100110: 3b 7b 08 cmp 0x8(%ebx),%edi
80100113: 75 eb jne 80100100 <bread+0x30>
b->refcnt++;
80100115: 83 43 4c 01 addl $0x1,0x4c(%ebx)
80100119: eb 3f jmp 8010015a <bread+0x8a>
8010011b: 90 nop
8010011c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for(b = bcache.head.prev; b != &bcache.head; b = b->prev){
80100120: 8b 1d 0c fd 10 80 mov 0x8010fd0c,%ebx
80100126: 81 fb bc fc 10 80 cmp $0x8010fcbc,%ebx
8010012c: 75 0d jne 8010013b <bread+0x6b>
8010012e: eb 58 jmp 80100188 <bread+0xb8>
80100130: 8b 5b 50 mov 0x50(%ebx),%ebx
80100133: 81 fb bc fc 10 80 cmp $0x8010fcbc,%ebx
80100139: 74 4d je 80100188 <bread+0xb8>
if(b->refcnt == 0 && (b->flags & B_DIRTY) == 0) {
8010013b: 8b 43 4c mov 0x4c(%ebx),%eax
8010013e: 85 c0 test %eax,%eax
80100140: 75 ee jne 80100130 <bread+0x60>
80100142: f6 03 04 testb $0x4,(%ebx)
80100145: 75 e9 jne 80100130 <bread+0x60>
b->dev = dev;
80100147: 89 73 04 mov %esi,0x4(%ebx)
b->blockno = blockno;
8010014a: 89 7b 08 mov %edi,0x8(%ebx)
b->flags = 0;
8010014d: c7 03 00 00 00 00 movl $0x0,(%ebx)
b->refcnt = 1;
80100153: c7 43 4c 01 00 00 00 movl $0x1,0x4c(%ebx)
release(&bcache.lock);
8010015a: c7 04 24 c0 b5 10 80 movl $0x8010b5c0,(%esp)
80100161: e8 ba 40 00 00 call 80104220 <release>
acquiresleep(&b->lock);
80100166: 8d 43 0c lea 0xc(%ebx),%eax
80100169: 89 04 24 mov %eax,(%esp)
8010016c: e8 ff 3d 00 00 call 80103f70 <acquiresleep>
struct buf *b;
b = bget(dev, blockno);
if((b->flags & B_VALID) == 0) {
80100171: f6 03 02 testb $0x2,(%ebx)
80100174: 75 08 jne 8010017e <bread+0xae>
iderw(b);
80100176: 89 1c 24 mov %ebx,(%esp)
80100179: e8 92 1f 00 00 call 80102110 <iderw>
}
return b;
}
8010017e: 83 c4 1c add $0x1c,%esp
80100181: 89 d8 mov %ebx,%eax
80100183: 5b pop %ebx
80100184: 5e pop %esi
80100185: 5f pop %edi
80100186: 5d pop %ebp
80100187: c3 ret
panic("bget: no buffers");
80100188: c7 04 24 2e 6e 10 80 movl $0x80106e2e,(%esp)
8010018f: e8 cc 01 00 00 call 80100360 <panic>
80100194: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
8010019a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
801001a0 <bwrite>:
// Write b's contents to disk. Must be locked.
void
bwrite(struct buf *b)
{
801001a0: 55 push %ebp
801001a1: 89 e5 mov %esp,%ebp
801001a3: 53 push %ebx
801001a4: 83 ec 14 sub $0x14,%esp
801001a7: 8b 5d 08 mov 0x8(%ebp),%ebx
if(!holdingsleep(&b->lock))
801001aa: 8d 43 0c lea 0xc(%ebx),%eax
801001ad: 89 04 24 mov %eax,(%esp)
801001b0: e8 5b 3e 00 00 call 80104010 <holdingsleep>
801001b5: 85 c0 test %eax,%eax
801001b7: 74 10 je 801001c9 <bwrite+0x29>
panic("bwrite");
b->flags |= B_DIRTY;
801001b9: 83 0b 04 orl $0x4,(%ebx)
iderw(b);
801001bc: 89 5d 08 mov %ebx,0x8(%ebp)
}
801001bf: 83 c4 14 add $0x14,%esp
801001c2: 5b pop %ebx
801001c3: 5d pop %ebp
iderw(b);
801001c4: e9 47 1f 00 00 jmp 80102110 <iderw>
panic("bwrite");
801001c9: c7 04 24 3f 6e 10 80 movl $0x80106e3f,(%esp)
801001d0: e8 8b 01 00 00 call 80100360 <panic>
801001d5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801001d9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801001e0 <brelse>:
// Release a locked buffer.
// Move to the head of the MRU list.
void
brelse(struct buf *b)
{
801001e0: 55 push %ebp
801001e1: 89 e5 mov %esp,%ebp
801001e3: 56 push %esi
801001e4: 53 push %ebx
801001e5: 83 ec 10 sub $0x10,%esp
801001e8: 8b 5d 08 mov 0x8(%ebp),%ebx
if(!holdingsleep(&b->lock))
801001eb: 8d 73 0c lea 0xc(%ebx),%esi
801001ee: 89 34 24 mov %esi,(%esp)
801001f1: e8 1a 3e 00 00 call 80104010 <holdingsleep>
801001f6: 85 c0 test %eax,%eax
801001f8: 74 5b je 80100255 <brelse+0x75>
panic("brelse");
releasesleep(&b->lock);
801001fa: 89 34 24 mov %esi,(%esp)
801001fd: e8 ce 3d 00 00 call 80103fd0 <releasesleep>
acquire(&bcache.lock);
80100202: c7 04 24 c0 b5 10 80 movl $0x8010b5c0,(%esp)
80100209: e8 22 3f 00 00 call 80104130 <acquire>
b->refcnt--;
if (b->refcnt == 0) {
8010020e: 83 6b 4c 01 subl $0x1,0x4c(%ebx)
80100212: 75 2f jne 80100243 <brelse+0x63>
// no one is waiting for it.
b->next->prev = b->prev;
80100214: 8b 43 54 mov 0x54(%ebx),%eax
80100217: 8b 53 50 mov 0x50(%ebx),%edx
8010021a: 89 50 50 mov %edx,0x50(%eax)
b->prev->next = b->next;
8010021d: 8b 43 50 mov 0x50(%ebx),%eax
80100220: 8b 53 54 mov 0x54(%ebx),%edx
80100223: 89 50 54 mov %edx,0x54(%eax)
b->next = bcache.head.next;
80100226: a1 10 fd 10 80 mov 0x8010fd10,%eax
b->prev = &bcache.head;
8010022b: c7 43 50 bc fc 10 80 movl $0x8010fcbc,0x50(%ebx)
b->next = bcache.head.next;
80100232: 89 43 54 mov %eax,0x54(%ebx)
bcache.head.next->prev = b;
80100235: a1 10 fd 10 80 mov 0x8010fd10,%eax
8010023a: 89 58 50 mov %ebx,0x50(%eax)
bcache.head.next = b;
8010023d: 89 1d 10 fd 10 80 mov %ebx,0x8010fd10
}
release(&bcache.lock);
80100243: c7 45 08 c0 b5 10 80 movl $0x8010b5c0,0x8(%ebp)
}
8010024a: 83 c4 10 add $0x10,%esp
8010024d: 5b pop %ebx
8010024e: 5e pop %esi
8010024f: 5d pop %ebp
release(&bcache.lock);
80100250: e9 cb 3f 00 00 jmp 80104220 <release>
panic("brelse");
80100255: c7 04 24 46 6e 10 80 movl $0x80106e46,(%esp)
8010025c: e8 ff 00 00 00 call 80100360 <panic>
80100261: 66 90 xchg %ax,%ax
80100263: 66 90 xchg %ax,%ax
80100265: 66 90 xchg %ax,%ax
80100267: 66 90 xchg %ax,%ax
80100269: 66 90 xchg %ax,%ax
8010026b: 66 90 xchg %ax,%ax
8010026d: 66 90 xchg %ax,%ax
8010026f: 90 nop
80100270 <consoleread>:
}
}
int
consoleread(struct inode *ip, char *dst, int n)
{
80100270: 55 push %ebp
80100271: 89 e5 mov %esp,%ebp
80100273: 57 push %edi
80100274: 56 push %esi
80100275: 53 push %ebx
80100276: 83 ec 1c sub $0x1c,%esp
80100279: 8b 7d 08 mov 0x8(%ebp),%edi
8010027c: 8b 75 0c mov 0xc(%ebp),%esi
uint target;
int c;
iunlock(ip);
8010027f: 89 3c 24 mov %edi,(%esp)
80100282: e8 f9 14 00 00 call 80101780 <iunlock>
target = n;
acquire(&cons.lock);
80100287: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
8010028e: e8 9d 3e 00 00 call 80104130 <acquire>
while(n > 0){
80100293: 8b 55 10 mov 0x10(%ebp),%edx
80100296: 85 d2 test %edx,%edx
80100298: 0f 8e bc 00 00 00 jle 8010035a <consoleread+0xea>
8010029e: 8b 5d 10 mov 0x10(%ebp),%ebx
801002a1: eb 25 jmp 801002c8 <consoleread+0x58>
801002a3: 90 nop
801002a4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
while(input.r == input.w){
if(myproc()->killed){
801002a8: e8 e3 33 00 00 call 80103690 <myproc>
801002ad: 8b 40 28 mov 0x28(%eax),%eax
801002b0: 85 c0 test %eax,%eax
801002b2: 75 74 jne 80100328 <consoleread+0xb8>
release(&cons.lock);
ilock(ip);
return -1;
}
sleep(&input.r, &cons.lock);
801002b4: c7 44 24 04 20 a5 10 movl $0x8010a520,0x4(%esp)
801002bb: 80
801002bc: c7 04 24 a0 ff 10 80 movl $0x8010ffa0,(%esp)
801002c3: e8 28 39 00 00 call 80103bf0 <sleep>
while(input.r == input.w){
801002c8: a1 a0 ff 10 80 mov 0x8010ffa0,%eax
801002cd: 3b 05 a4 ff 10 80 cmp 0x8010ffa4,%eax
801002d3: 74 d3 je 801002a8 <consoleread+0x38>
}
c = input.buf[input.r++ % INPUT_BUF];
801002d5: 8d 50 01 lea 0x1(%eax),%edx
801002d8: 89 15 a0 ff 10 80 mov %edx,0x8010ffa0
801002de: 89 c2 mov %eax,%edx
801002e0: 83 e2 7f and $0x7f,%edx
801002e3: 0f b6 8a 20 ff 10 80 movzbl -0x7fef00e0(%edx),%ecx
801002ea: 0f be d1 movsbl %cl,%edx
if(c == C('D')){ // EOF
801002ed: 83 fa 04 cmp $0x4,%edx
801002f0: 74 57 je 80100349 <consoleread+0xd9>
// caller gets a 0-byte result.
input.r--;
}
break;
}
*dst++ = c;
801002f2: 83 c6 01 add $0x1,%esi
--n;
801002f5: 83 eb 01 sub $0x1,%ebx
if(c == '\n')
801002f8: 83 fa 0a cmp $0xa,%edx
*dst++ = c;
801002fb: 88 4e ff mov %cl,-0x1(%esi)
if(c == '\n')
801002fe: 74 53 je 80100353 <consoleread+0xe3>
while(n > 0){
80100300: 85 db test %ebx,%ebx
80100302: 75 c4 jne 801002c8 <consoleread+0x58>
80100304: 8b 45 10 mov 0x10(%ebp),%eax
break;
}
release(&cons.lock);
80100307: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
8010030e: 89 45 e4 mov %eax,-0x1c(%ebp)
80100311: e8 0a 3f 00 00 call 80104220 <release>
ilock(ip);
80100316: 89 3c 24 mov %edi,(%esp)
80100319: e8 82 13 00 00 call 801016a0 <ilock>
8010031e: 8b 45 e4 mov -0x1c(%ebp),%eax
return target - n;
80100321: eb 1e jmp 80100341 <consoleread+0xd1>
80100323: 90 nop
80100324: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
release(&cons.lock);
80100328: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
8010032f: e8 ec 3e 00 00 call 80104220 <release>
ilock(ip);
80100334: 89 3c 24 mov %edi,(%esp)
80100337: e8 64 13 00 00 call 801016a0 <ilock>
return -1;
8010033c: b8 ff ff ff ff mov $0xffffffff,%eax
}
80100341: 83 c4 1c add $0x1c,%esp
80100344: 5b pop %ebx
80100345: 5e pop %esi
80100346: 5f pop %edi
80100347: 5d pop %ebp
80100348: c3 ret
if(n < target){
80100349: 39 5d 10 cmp %ebx,0x10(%ebp)
8010034c: 76 05 jbe 80100353 <consoleread+0xe3>
input.r--;
8010034e: a3 a0 ff 10 80 mov %eax,0x8010ffa0
80100353: 8b 45 10 mov 0x10(%ebp),%eax
80100356: 29 d8 sub %ebx,%eax
80100358: eb ad jmp 80100307 <consoleread+0x97>
while(n > 0){
8010035a: 31 c0 xor %eax,%eax
8010035c: eb a9 jmp 80100307 <consoleread+0x97>
8010035e: 66 90 xchg %ax,%ax
80100360 <panic>:
{
80100360: 55 push %ebp
80100361: 89 e5 mov %esp,%ebp
80100363: 56 push %esi
80100364: 53 push %ebx
80100365: 83 ec 40 sub $0x40,%esp
}
static inline void
cli(void)
{
asm volatile("cli");
80100368: fa cli
cons.locking = 0;
80100369: c7 05 54 a5 10 80 00 movl $0x0,0x8010a554
80100370: 00 00 00
getcallerpcs(&s, pcs);
80100373: 8d 5d d0 lea -0x30(%ebp),%ebx
cprintf("lapicid %d: panic: ", lapicid());
80100376: e8 d5 23 00 00 call 80102750 <lapicid>
8010037b: 8d 75 f8 lea -0x8(%ebp),%esi
8010037e: c7 04 24 4d 6e 10 80 movl $0x80106e4d,(%esp)
80100385: 89 44 24 04 mov %eax,0x4(%esp)
80100389: e8 c2 02 00 00 call 80100650 <cprintf>
cprintf(s);
8010038e: 8b 45 08 mov 0x8(%ebp),%eax
80100391: 89 04 24 mov %eax,(%esp)
80100394: e8 b7 02 00 00 call 80100650 <cprintf>
cprintf("\n");
80100399: c7 04 24 07 78 10 80 movl $0x80107807,(%esp)
801003a0: e8 ab 02 00 00 call 80100650 <cprintf>
getcallerpcs(&s, pcs);
801003a5: 8d 45 08 lea 0x8(%ebp),%eax
801003a8: 89 5c 24 04 mov %ebx,0x4(%esp)
801003ac: 89 04 24 mov %eax,(%esp)
801003af: e8 ac 3c 00 00 call 80104060 <getcallerpcs>
801003b4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
cprintf(" %p", pcs[i]);
801003b8: 8b 03 mov (%ebx),%eax
801003ba: 83 c3 04 add $0x4,%ebx
801003bd: c7 04 24 61 6e 10 80 movl $0x80106e61,(%esp)
801003c4: 89 44 24 04 mov %eax,0x4(%esp)
801003c8: e8 83 02 00 00 call 80100650 <cprintf>
for(i=0; i<10; i++)
801003cd: 39 f3 cmp %esi,%ebx
801003cf: 75 e7 jne 801003b8 <panic+0x58>
panicked = 1; // freeze other CPU
801003d1: c7 05 58 a5 10 80 01 movl $0x1,0x8010a558
801003d8: 00 00 00
801003db: eb fe jmp 801003db <panic+0x7b>
801003dd: 8d 76 00 lea 0x0(%esi),%esi
801003e0 <consputc>:
if(panicked){
801003e0: 8b 15 58 a5 10 80 mov 0x8010a558,%edx
801003e6: 85 d2 test %edx,%edx
801003e8: 74 06 je 801003f0 <consputc+0x10>
801003ea: fa cli
801003eb: eb fe jmp 801003eb <consputc+0xb>
801003ed: 8d 76 00 lea 0x0(%esi),%esi
{
801003f0: 55 push %ebp
801003f1: 89 e5 mov %esp,%ebp
801003f3: 57 push %edi
801003f4: 56 push %esi
801003f5: 53 push %ebx
801003f6: 89 c3 mov %eax,%ebx
801003f8: 83 ec 1c sub $0x1c,%esp
if(c == BACKSPACE){
801003fb: 3d 00 01 00 00 cmp $0x100,%eax
80100400: 0f 84 ac 00 00 00 je 801004b2 <consputc+0xd2>
uartputc(c);
80100406: 89 04 24 mov %eax,(%esp)
80100409: e8 12 54 00 00 call 80105820 <uartputc>
asm volatile("out %0,%1" : : "a" (data), "d" (port));
8010040e: bf d4 03 00 00 mov $0x3d4,%edi
80100413: b8 0e 00 00 00 mov $0xe,%eax
80100418: 89 fa mov %edi,%edx
8010041a: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
8010041b: be d5 03 00 00 mov $0x3d5,%esi
80100420: 89 f2 mov %esi,%edx
80100422: ec in (%dx),%al
pos = inb(CRTPORT+1) << 8;
80100423: 0f b6 c8 movzbl %al,%ecx
asm volatile("out %0,%1" : : "a" (data), "d" (port));
80100426: 89 fa mov %edi,%edx
80100428: c1 e1 08 shl $0x8,%ecx
8010042b: b8 0f 00 00 00 mov $0xf,%eax
80100430: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80100431: 89 f2 mov %esi,%edx
80100433: ec in (%dx),%al
pos |= inb(CRTPORT+1);
80100434: 0f b6 c0 movzbl %al,%eax
80100437: 09 c1 or %eax,%ecx
if(c == '\n')
80100439: 83 fb 0a cmp $0xa,%ebx
8010043c: 0f 84 0d 01 00 00 je 8010054f <consputc+0x16f>
else if(c == BACKSPACE){
80100442: 81 fb 00 01 00 00 cmp $0x100,%ebx
80100448: 0f 84 e8 00 00 00 je 80100536 <consputc+0x156>
crt[pos++] = (c&0xff) | 0x0700; // black on white
8010044e: 0f b6 db movzbl %bl,%ebx
80100451: 80 cf 07 or $0x7,%bh
80100454: 8d 79 01 lea 0x1(%ecx),%edi
80100457: 66 89 9c 09 00 80 0b mov %bx,-0x7ff48000(%ecx,%ecx,1)
8010045e: 80
if(pos < 0 || pos > 25*80)
8010045f: 81 ff d0 07 00 00 cmp $0x7d0,%edi
80100465: 0f 87 bf 00 00 00 ja 8010052a <consputc+0x14a>
if((pos/80) >= 24){ // Scroll up.
8010046b: 81 ff 7f 07 00 00 cmp $0x77f,%edi
80100471: 7f 68 jg 801004db <consputc+0xfb>
80100473: 89 f8 mov %edi,%eax
80100475: 89 fb mov %edi,%ebx
80100477: c1 e8 08 shr $0x8,%eax
8010047a: 89 c6 mov %eax,%esi
8010047c: 8d 8c 3f 00 80 0b 80 lea -0x7ff48000(%edi,%edi,1),%ecx
asm volatile("out %0,%1" : : "a" (data), "d" (port));
80100483: bf d4 03 00 00 mov $0x3d4,%edi
80100488: b8 0e 00 00 00 mov $0xe,%eax
8010048d: 89 fa mov %edi,%edx
8010048f: ee out %al,(%dx)
80100490: 89 f0 mov %esi,%eax
80100492: b2 d5 mov $0xd5,%dl
80100494: ee out %al,(%dx)
80100495: b8 0f 00 00 00 mov $0xf,%eax
8010049a: 89 fa mov %edi,%edx
8010049c: ee out %al,(%dx)
8010049d: 89 d8 mov %ebx,%eax
8010049f: b2 d5 mov $0xd5,%dl
801004a1: ee out %al,(%dx)
crt[pos] = ' ' | 0x0700;
801004a2: b8 20 07 00 00 mov $0x720,%eax
801004a7: 66 89 01 mov %ax,(%ecx)
}
801004aa: 83 c4 1c add $0x1c,%esp
801004ad: 5b pop %ebx
801004ae: 5e pop %esi
801004af: 5f pop %edi
801004b0: 5d pop %ebp
801004b1: c3 ret
uartputc('\b'); uartputc(' '); uartputc('\b');
801004b2: c7 04 24 08 00 00 00 movl $0x8,(%esp)
801004b9: e8 62 53 00 00 call 80105820 <uartputc>
801004be: c7 04 24 20 00 00 00 movl $0x20,(%esp)
801004c5: e8 56 53 00 00 call 80105820 <uartputc>
801004ca: c7 04 24 08 00 00 00 movl $0x8,(%esp)
801004d1: e8 4a 53 00 00 call 80105820 <uartputc>
801004d6: e9 33 ff ff ff jmp 8010040e <consputc+0x2e>
memmove(crt, crt+80, sizeof(crt[0])*23*80);
801004db: c7 44 24 08 60 0e 00 movl $0xe60,0x8(%esp)
801004e2: 00
pos -= 80;
801004e3: 8d 5f b0 lea -0x50(%edi),%ebx
memmove(crt, crt+80, sizeof(crt[0])*23*80);
801004e6: c7 44 24 04 a0 80 0b movl $0x800b80a0,0x4(%esp)
801004ed: 80
memset(crt+pos, 0, sizeof(crt[0])*(24*80 - pos));
801004ee: 8d b4 1b 00 80 0b 80 lea -0x7ff48000(%ebx,%ebx,1),%esi
memmove(crt, crt+80, sizeof(crt[0])*23*80);
801004f5: c7 04 24 00 80 0b 80 movl $0x800b8000,(%esp)
801004fc: e8 0f 3e 00 00 call 80104310 <memmove>
memset(crt+pos, 0, sizeof(crt[0])*(24*80 - pos));
80100501: b8 d0 07 00 00 mov $0x7d0,%eax
80100506: 29 f8 sub %edi,%eax
80100508: 01 c0 add %eax,%eax
8010050a: 89 34 24 mov %esi,(%esp)
8010050d: 89 44 24 08 mov %eax,0x8(%esp)
80100511: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80100518: 00
80100519: e8 52 3d 00 00 call 80104270 <memset>
8010051e: 89 f1 mov %esi,%ecx
80100520: be 07 00 00 00 mov $0x7,%esi
80100525: e9 59 ff ff ff jmp 80100483 <consputc+0xa3>
panic("pos under/overflow");
8010052a: c7 04 24 65 6e 10 80 movl $0x80106e65,(%esp)
80100531: e8 2a fe ff ff call 80100360 <panic>
if(pos > 0) --pos;
80100536: 85 c9 test %ecx,%ecx
80100538: 8d 79 ff lea -0x1(%ecx),%edi
8010053b: 0f 85 1e ff ff ff jne 8010045f <consputc+0x7f>
80100541: b9 00 80 0b 80 mov $0x800b8000,%ecx
80100546: 31 db xor %ebx,%ebx
80100548: 31 f6 xor %esi,%esi
8010054a: e9 34 ff ff ff jmp 80100483 <consputc+0xa3>
pos += 80 - pos%80;
8010054f: 89 c8 mov %ecx,%eax
80100551: ba 67 66 66 66 mov $0x66666667,%edx
80100556: f7 ea imul %edx
80100558: c1 ea 05 shr $0x5,%edx
8010055b: 8d 04 92 lea (%edx,%edx,4),%eax
8010055e: c1 e0 04 shl $0x4,%eax
80100561: 8d 78 50 lea 0x50(%eax),%edi
80100564: e9 f6 fe ff ff jmp 8010045f <consputc+0x7f>
80100569: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80100570 <printint>:
{
80100570: 55 push %ebp
80100571: 89 e5 mov %esp,%ebp
80100573: 57 push %edi
80100574: 56 push %esi
80100575: 89 d6 mov %edx,%esi
80100577: 53 push %ebx
80100578: 83 ec 1c sub $0x1c,%esp
if(sign && (sign = xx < 0))
8010057b: 85 c9 test %ecx,%ecx
8010057d: 74 61 je 801005e0 <printint+0x70>
8010057f: 85 c0 test %eax,%eax
80100581: 79 5d jns 801005e0 <printint+0x70>
x = -xx;
80100583: f7 d8 neg %eax
80100585: bf 01 00 00 00 mov $0x1,%edi
i = 0;
8010058a: 31 c9 xor %ecx,%ecx
8010058c: eb 04 jmp 80100592 <printint+0x22>
8010058e: 66 90 xchg %ax,%ax
buf[i++] = digits[x % base];
80100590: 89 d9 mov %ebx,%ecx
80100592: 31 d2 xor %edx,%edx
80100594: f7 f6 div %esi
80100596: 8d 59 01 lea 0x1(%ecx),%ebx
80100599: 0f b6 92 90 6e 10 80 movzbl -0x7fef9170(%edx),%edx
}while((x /= base) != 0);
801005a0: 85 c0 test %eax,%eax
buf[i++] = digits[x % base];
801005a2: 88 54 1d d7 mov %dl,-0x29(%ebp,%ebx,1)
}while((x /= base) != 0);
801005a6: 75 e8 jne 80100590 <printint+0x20>
if(sign)
801005a8: 85 ff test %edi,%edi
buf[i++] = digits[x % base];
801005aa: 89 d8 mov %ebx,%eax
if(sign)
801005ac: 74 08 je 801005b6 <printint+0x46>
buf[i++] = '-';
801005ae: 8d 59 02 lea 0x2(%ecx),%ebx
801005b1: c6 44 05 d8 2d movb $0x2d,-0x28(%ebp,%eax,1)
while(--i >= 0)
801005b6: 83 eb 01 sub $0x1,%ebx
801005b9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
consputc(buf[i]);
801005c0: 0f be 44 1d d8 movsbl -0x28(%ebp,%ebx,1),%eax
while(--i >= 0)
801005c5: 83 eb 01 sub $0x1,%ebx
consputc(buf[i]);
801005c8: e8 13 fe ff ff call 801003e0 <consputc>
while(--i >= 0)
801005cd: 83 fb ff cmp $0xffffffff,%ebx
801005d0: 75 ee jne 801005c0 <printint+0x50>
}
801005d2: 83 c4 1c add $0x1c,%esp
801005d5: 5b pop %ebx
801005d6: 5e pop %esi
801005d7: 5f pop %edi
801005d8: 5d pop %ebp
801005d9: c3 ret
801005da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
x = xx;
801005e0: 31 ff xor %edi,%edi
801005e2: eb a6 jmp 8010058a <printint+0x1a>
801005e4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801005ea: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
801005f0 <consolewrite>:
int
consolewrite(struct inode *ip, char *buf, int n)
{
801005f0: 55 push %ebp
801005f1: 89 e5 mov %esp,%ebp
801005f3: 57 push %edi
801005f4: 56 push %esi
801005f5: 53 push %ebx
801005f6: 83 ec 1c sub $0x1c,%esp
int i;
iunlock(ip);
801005f9: 8b 45 08 mov 0x8(%ebp),%eax
{
801005fc: 8b 75 10 mov 0x10(%ebp),%esi
iunlock(ip);
801005ff: 89 04 24 mov %eax,(%esp)
80100602: e8 79 11 00 00 call 80101780 <iunlock>
acquire(&cons.lock);
80100607: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
8010060e: e8 1d 3b 00 00 call 80104130 <acquire>
80100613: 8b 7d 0c mov 0xc(%ebp),%edi
for(i = 0; i < n; i++)
80100616: 85 f6 test %esi,%esi
80100618: 8d 1c 37 lea (%edi,%esi,1),%ebx
8010061b: 7e 12 jle 8010062f <consolewrite+0x3f>
8010061d: 8d 76 00 lea 0x0(%esi),%esi
consputc(buf[i] & 0xff);
80100620: 0f b6 07 movzbl (%edi),%eax
80100623: 83 c7 01 add $0x1,%edi
80100626: e8 b5 fd ff ff call 801003e0 <consputc>
for(i = 0; i < n; i++)
8010062b: 39 df cmp %ebx,%edi
8010062d: 75 f1 jne 80100620 <consolewrite+0x30>
release(&cons.lock);
8010062f: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
80100636: e8 e5 3b 00 00 call 80104220 <release>
ilock(ip);
8010063b: 8b 45 08 mov 0x8(%ebp),%eax
8010063e: 89 04 24 mov %eax,(%esp)
80100641: e8 5a 10 00 00 call 801016a0 <ilock>
return n;
}
80100646: 83 c4 1c add $0x1c,%esp
80100649: 89 f0 mov %esi,%eax
8010064b: 5b pop %ebx
8010064c: 5e pop %esi
8010064d: 5f pop %edi
8010064e: 5d pop %ebp
8010064f: c3 ret
80100650 <cprintf>:
{
80100650: 55 push %ebp
80100651: 89 e5 mov %esp,%ebp
80100653: 57 push %edi
80100654: 56 push %esi
80100655: 53 push %ebx
80100656: 83 ec 1c sub $0x1c,%esp
locking = cons.locking;
80100659: a1 54 a5 10 80 mov 0x8010a554,%eax
if(locking)
8010065e: 85 c0 test %eax,%eax
locking = cons.locking;
80100660: 89 45 e0 mov %eax,-0x20(%ebp)
if(locking)
80100663: 0f 85 27 01 00 00 jne 80100790 <cprintf+0x140>
if (fmt == 0)
80100669: 8b 45 08 mov 0x8(%ebp),%eax
8010066c: 85 c0 test %eax,%eax
8010066e: 89 c1 mov %eax,%ecx
80100670: 0f 84 2b 01 00 00 je 801007a1 <cprintf+0x151>
for(i = 0; (c = fmt[i] & 0xff) != 0; i++){
80100676: 0f b6 00 movzbl (%eax),%eax
80100679: 31 db xor %ebx,%ebx
8010067b: 89 cf mov %ecx,%edi
8010067d: 8d 75 0c lea 0xc(%ebp),%esi
80100680: 85 c0 test %eax,%eax
80100682: 75 4c jne 801006d0 <cprintf+0x80>
80100684: eb 5f jmp 801006e5 <cprintf+0x95>
80100686: 66 90 xchg %ax,%ax
c = fmt[++i] & 0xff;
80100688: 83 c3 01 add $0x1,%ebx
8010068b: 0f b6 14 1f movzbl (%edi,%ebx,1),%edx
if(c == 0)
8010068f: 85 d2 test %edx,%edx
80100691: 74 52 je 801006e5 <cprintf+0x95>
switch(c){
80100693: 83 fa 70 cmp $0x70,%edx
80100696: 74 72 je 8010070a <cprintf+0xba>
80100698: 7f 66 jg 80100700 <cprintf+0xb0>
8010069a: 83 fa 25 cmp $0x25,%edx
8010069d: 8d 76 00 lea 0x0(%esi),%esi
801006a0: 0f 84 a2 00 00 00 je 80100748 <cprintf+0xf8>
801006a6: 83 fa 64 cmp $0x64,%edx
801006a9: 75 7d jne 80100728 <cprintf+0xd8>
printint(*argp++, 10, 1);
801006ab: 8d 46 04 lea 0x4(%esi),%eax
801006ae: b9 01 00 00 00 mov $0x1,%ecx
801006b3: 89 45 e4 mov %eax,-0x1c(%ebp)
801006b6: 8b 06 mov (%esi),%eax
801006b8: ba 0a 00 00 00 mov $0xa,%edx
801006bd: e8 ae fe ff ff call 80100570 <printint>
801006c2: 8b 75 e4 mov -0x1c(%ebp),%esi
for(i = 0; (c = fmt[i] & 0xff) != 0; i++){
801006c5: 83 c3 01 add $0x1,%ebx
801006c8: 0f b6 04 1f movzbl (%edi,%ebx,1),%eax
801006cc: 85 c0 test %eax,%eax
801006ce: 74 15 je 801006e5 <cprintf+0x95>
if(c != '%'){
801006d0: 83 f8 25 cmp $0x25,%eax
801006d3: 74 b3 je 80100688 <cprintf+0x38>
consputc(c);
801006d5: e8 06 fd ff ff call 801003e0 <consputc>
for(i = 0; (c = fmt[i] & 0xff) != 0; i++){
801006da: 83 c3 01 add $0x1,%ebx
801006dd: 0f b6 04 1f movzbl (%edi,%ebx,1),%eax
801006e1: 85 c0 test %eax,%eax
801006e3: 75 eb jne 801006d0 <cprintf+0x80>
if(locking)
801006e5: 8b 45 e0 mov -0x20(%ebp),%eax
801006e8: 85 c0 test %eax,%eax
801006ea: 74 0c je 801006f8 <cprintf+0xa8>
release(&cons.lock);
801006ec: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
801006f3: e8 28 3b 00 00 call 80104220 <release>
}
801006f8: 83 c4 1c add $0x1c,%esp
801006fb: 5b pop %ebx
801006fc: 5e pop %esi
801006fd: 5f pop %edi
801006fe: 5d pop %ebp
801006ff: c3 ret
switch(c){
80100700: 83 fa 73 cmp $0x73,%edx
80100703: 74 53 je 80100758 <cprintf+0x108>
80100705: 83 fa 78 cmp $0x78,%edx
80100708: 75 1e jne 80100728 <cprintf+0xd8>
printint(*argp++, 16, 0);
8010070a: 8d 46 04 lea 0x4(%esi),%eax
8010070d: 31 c9 xor %ecx,%ecx
8010070f: 89 45 e4 mov %eax,-0x1c(%ebp)
80100712: 8b 06 mov (%esi),%eax
80100714: ba 10 00 00 00 mov $0x10,%edx
80100719: e8 52 fe ff ff call 80100570 <printint>
8010071e: 8b 75 e4 mov -0x1c(%ebp),%esi
break;
80100721: eb a2 jmp 801006c5 <cprintf+0x75>
80100723: 90 nop
80100724: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
consputc('%');
80100728: b8 25 00 00 00 mov $0x25,%eax
8010072d: 89 55 e4 mov %edx,-0x1c(%ebp)
80100730: e8 ab fc ff ff call 801003e0 <consputc>
consputc(c);
80100735: 8b 55 e4 mov -0x1c(%ebp),%edx
80100738: 89 d0 mov %edx,%eax
8010073a: e8 a1 fc ff ff call 801003e0 <consputc>
8010073f: eb 99 jmp 801006da <cprintf+0x8a>
80100741: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
consputc('%');
80100748: b8 25 00 00 00 mov $0x25,%eax
8010074d: e8 8e fc ff ff call 801003e0 <consputc>
break;
80100752: e9 6e ff ff ff jmp 801006c5 <cprintf+0x75>
80100757: 90 nop
if((s = (char*)*argp++) == 0)
80100758: 8d 46 04 lea 0x4(%esi),%eax
8010075b: 8b 36 mov (%esi),%esi
8010075d: 89 45 e4 mov %eax,-0x1c(%ebp)
s = "(null)";
80100760: b8 78 6e 10 80 mov $0x80106e78,%eax
80100765: 85 f6 test %esi,%esi
80100767: 0f 44 f0 cmove %eax,%esi
for(; *s; s++)
8010076a: 0f be 06 movsbl (%esi),%eax
8010076d: 84 c0 test %al,%al
8010076f: 74 16 je 80100787 <cprintf+0x137>
80100771: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80100778: 83 c6 01 add $0x1,%esi
consputc(*s);
8010077b: e8 60 fc ff ff call 801003e0 <consputc>
for(; *s; s++)
80100780: 0f be 06 movsbl (%esi),%eax
80100783: 84 c0 test %al,%al
80100785: 75 f1 jne 80100778 <cprintf+0x128>
if((s = (char*)*argp++) == 0)
80100787: 8b 75 e4 mov -0x1c(%ebp),%esi
8010078a: e9 36 ff ff ff jmp 801006c5 <cprintf+0x75>
8010078f: 90 nop
acquire(&cons.lock);
80100790: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
80100797: e8 94 39 00 00 call 80104130 <acquire>
8010079c: e9 c8 fe ff ff jmp 80100669 <cprintf+0x19>
panic("null fmt");
801007a1: c7 04 24 7f 6e 10 80 movl $0x80106e7f,(%esp)
801007a8: e8 b3 fb ff ff call 80100360 <panic>
801007ad: 8d 76 00 lea 0x0(%esi),%esi
801007b0 <consoleintr>:
{
801007b0: 55 push %ebp
801007b1: 89 e5 mov %esp,%ebp
801007b3: 57 push %edi
801007b4: 56 push %esi
int c, doprocdump = 0;
801007b5: 31 f6 xor %esi,%esi
{
801007b7: 53 push %ebx
801007b8: 83 ec 1c sub $0x1c,%esp
801007bb: 8b 5d 08 mov 0x8(%ebp),%ebx
acquire(&cons.lock);
801007be: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
801007c5: e8 66 39 00 00 call 80104130 <acquire>
801007ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
while((c = getc()) >= 0){
801007d0: ff d3 call *%ebx
801007d2: 85 c0 test %eax,%eax
801007d4: 89 c7 mov %eax,%edi
801007d6: 78 48 js 80100820 <consoleintr+0x70>
switch(c){
801007d8: 83 ff 10 cmp $0x10,%edi
801007db: 0f 84 2f 01 00 00 je 80100910 <consoleintr+0x160>
801007e1: 7e 5d jle 80100840 <consoleintr+0x90>
801007e3: 83 ff 15 cmp $0x15,%edi
801007e6: 0f 84 d4 00 00 00 je 801008c0 <consoleintr+0x110>
801007ec: 83 ff 7f cmp $0x7f,%edi
801007ef: 90 nop
801007f0: 75 53 jne 80100845 <consoleintr+0x95>
if(input.e != input.w){
801007f2: a1 a8 ff 10 80 mov 0x8010ffa8,%eax
801007f7: 3b 05 a4 ff 10 80 cmp 0x8010ffa4,%eax
801007fd: 74 d1 je 801007d0 <consoleintr+0x20>
input.e--;
801007ff: 83 e8 01 sub $0x1,%eax
80100802: a3 a8 ff 10 80 mov %eax,0x8010ffa8
consputc(BACKSPACE);
80100807: b8 00 01 00 00 mov $0x100,%eax
8010080c: e8 cf fb ff ff call 801003e0 <consputc>
while((c = getc()) >= 0){
80100811: ff d3 call *%ebx
80100813: 85 c0 test %eax,%eax
80100815: 89 c7 mov %eax,%edi
80100817: 79 bf jns 801007d8 <consoleintr+0x28>
80100819: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
release(&cons.lock);
80100820: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
80100827: e8 f4 39 00 00 call 80104220 <release>
if(doprocdump) {
8010082c: 85 f6 test %esi,%esi
8010082e: 0f 85 ec 00 00 00 jne 80100920 <consoleintr+0x170>
}
80100834: 83 c4 1c add $0x1c,%esp
80100837: 5b pop %ebx
80100838: 5e pop %esi
80100839: 5f pop %edi
8010083a: 5d pop %ebp
8010083b: c3 ret
8010083c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
switch(c){
80100840: 83 ff 08 cmp $0x8,%edi
80100843: 74 ad je 801007f2 <consoleintr+0x42>
if(c != 0 && input.e-input.r < INPUT_BUF){
80100845: 85 ff test %edi,%edi
80100847: 74 87 je 801007d0 <consoleintr+0x20>
80100849: a1 a8 ff 10 80 mov 0x8010ffa8,%eax
8010084e: 89 c2 mov %eax,%edx
80100850: 2b 15 a0 ff 10 80 sub 0x8010ffa0,%edx
80100856: 83 fa 7f cmp $0x7f,%edx
80100859: 0f 87 71 ff ff ff ja 801007d0 <consoleintr+0x20>
input.buf[input.e++ % INPUT_BUF] = c;
8010085f: 8d 50 01 lea 0x1(%eax),%edx
80100862: 83 e0 7f and $0x7f,%eax
c = (c == '\r') ? '\n' : c;
80100865: 83 ff 0d cmp $0xd,%edi
input.buf[input.e++ % INPUT_BUF] = c;
80100868: 89 15 a8 ff 10 80 mov %edx,0x8010ffa8
c = (c == '\r') ? '\n' : c;
8010086e: 0f 84 b8 00 00 00 je 8010092c <consoleintr+0x17c>
input.buf[input.e++ % INPUT_BUF] = c;
80100874: 89 f9 mov %edi,%ecx
80100876: 88 88 20 ff 10 80 mov %cl,-0x7fef00e0(%eax)
consputc(c);
8010087c: 89 f8 mov %edi,%eax
8010087e: e8 5d fb ff ff call 801003e0 <consputc>
if(c == '\n' || c == C('D') || input.e == input.r+INPUT_BUF){
80100883: 83 ff 04 cmp $0x4,%edi
80100886: a1 a8 ff 10 80 mov 0x8010ffa8,%eax
8010088b: 74 19 je 801008a6 <consoleintr+0xf6>
8010088d: 83 ff 0a cmp $0xa,%edi
80100890: 74 14 je 801008a6 <consoleintr+0xf6>
80100892: 8b 0d a0 ff 10 80 mov 0x8010ffa0,%ecx
80100898: 8d 91 80 00 00 00 lea 0x80(%ecx),%edx
8010089e: 39 d0 cmp %edx,%eax
801008a0: 0f 85 2a ff ff ff jne 801007d0 <consoleintr+0x20>
wakeup(&input.r);
801008a6: c7 04 24 a0 ff 10 80 movl $0x8010ffa0,(%esp)
input.w = input.e;
801008ad: a3 a4 ff 10 80 mov %eax,0x8010ffa4
wakeup(&input.r);
801008b2: e8 c9 34 00 00 call 80103d80 <wakeup>
801008b7: e9 14 ff ff ff jmp 801007d0 <consoleintr+0x20>
801008bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
while(input.e != input.w &&
801008c0: a1 a8 ff 10 80 mov 0x8010ffa8,%eax
801008c5: 3b 05 a4 ff 10 80 cmp 0x8010ffa4,%eax
801008cb: 75 2b jne 801008f8 <consoleintr+0x148>
801008cd: e9 fe fe ff ff jmp 801007d0 <consoleintr+0x20>
801008d2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
input.e--;
801008d8: a3 a8 ff 10 80 mov %eax,0x8010ffa8
consputc(BACKSPACE);
801008dd: b8 00 01 00 00 mov $0x100,%eax
801008e2: e8 f9 fa ff ff call 801003e0 <consputc>
while(input.e != input.w &&
801008e7: a1 a8 ff 10 80 mov 0x8010ffa8,%eax
801008ec: 3b 05 a4 ff 10 80 cmp 0x8010ffa4,%eax
801008f2: 0f 84 d8 fe ff ff je 801007d0 <consoleintr+0x20>
input.buf[(input.e-1) % INPUT_BUF] != '\n'){
801008f8: 83 e8 01 sub $0x1,%eax
801008fb: 89 c2 mov %eax,%edx
801008fd: 83 e2 7f and $0x7f,%edx
while(input.e != input.w &&
80100900: 80 ba 20 ff 10 80 0a cmpb $0xa,-0x7fef00e0(%edx)
80100907: 75 cf jne 801008d8 <consoleintr+0x128>
80100909: e9 c2 fe ff ff jmp 801007d0 <consoleintr+0x20>
8010090e: 66 90 xchg %ax,%ax
doprocdump = 1;
80100910: be 01 00 00 00 mov $0x1,%esi
80100915: e9 b6 fe ff ff jmp 801007d0 <consoleintr+0x20>
8010091a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
}
80100920: 83 c4 1c add $0x1c,%esp
80100923: 5b pop %ebx
80100924: 5e pop %esi
80100925: 5f pop %edi
80100926: 5d pop %ebp
procdump(); // now call procdump() wo. cons.lock held
80100927: e9 34 35 00 00 jmp 80103e60 <procdump>
input.buf[input.e++ % INPUT_BUF] = c;
8010092c: c6 80 20 ff 10 80 0a movb $0xa,-0x7fef00e0(%eax)
consputc(c);
80100933: b8 0a 00 00 00 mov $0xa,%eax
80100938: e8 a3 fa ff ff call 801003e0 <consputc>
8010093d: a1 a8 ff 10 80 mov 0x8010ffa8,%eax
80100942: e9 5f ff ff ff jmp 801008a6 <consoleintr+0xf6>
80100947: 89 f6 mov %esi,%esi
80100949: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80100950 <consoleinit>:
void
consoleinit(void)
{
80100950: 55 push %ebp
80100951: 89 e5 mov %esp,%ebp
80100953: 83 ec 18 sub $0x18,%esp
initlock(&cons.lock, "console");
80100956: c7 44 24 04 88 6e 10 movl $0x80106e88,0x4(%esp)
8010095d: 80
8010095e: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
80100965: e8 d6 36 00 00 call 80104040 <initlock>
devsw[CONSOLE].write = consolewrite;
devsw[CONSOLE].read = consoleread;
cons.locking = 1;
ioapicenable(IRQ_KBD, 0);
8010096a: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80100971: 00
80100972: c7 04 24 01 00 00 00 movl $0x1,(%esp)
devsw[CONSOLE].write = consolewrite;
80100979: c7 05 6c 09 11 80 f0 movl $0x801005f0,0x8011096c
80100980: 05 10 80
devsw[CONSOLE].read = consoleread;
80100983: c7 05 68 09 11 80 70 movl $0x80100270,0x80110968
8010098a: 02 10 80
cons.locking = 1;
8010098d: c7 05 54 a5 10 80 01 movl $0x1,0x8010a554
80100994: 00 00 00
ioapicenable(IRQ_KBD, 0);
80100997: e8 04 19 00 00 call 801022a0 <ioapicenable>
}
8010099c: c9 leave
8010099d: c3 ret
8010099e: 66 90 xchg %ax,%ax
801009a0 <exec>:
#include "x86.h"
#include "elf.h"
int
exec(char *path, char **argv)
{
801009a0: 55 push %ebp
801009a1: 89 e5 mov %esp,%ebp
801009a3: 57 push %edi
801009a4: 56 push %esi
801009a5: 53 push %ebx
801009a6: 81 ec 2c 01 00 00 sub $0x12c,%esp
uint argc, sz, sp, ustack[3+MAXARG+1];
struct elfhdr elf;
struct inode *ip;
struct proghdr ph;
pde_t *pgdir, *oldpgdir;
struct proc *curproc = myproc();
801009ac: e8 df 2c 00 00 call 80103690 <myproc>
801009b1: 89 85 f4 fe ff ff mov %eax,-0x10c(%ebp)
begin_op();
801009b7: e8 44 21 00 00 call 80102b00 <begin_op>
if((ip = namei(path)) == 0){
801009bc: 8b 45 08 mov 0x8(%ebp),%eax
801009bf: 89 04 24 mov %eax,(%esp)
801009c2: e8 29 15 00 00 call 80101ef0 <namei>
801009c7: 85 c0 test %eax,%eax
801009c9: 89 c3 mov %eax,%ebx
801009cb: 0f 84 3f 02 00 00 je 80100c10 <exec+0x270>
end_op();
cprintf("exec: fail\n");
return -1;
}
ilock(ip);
801009d1: 89 04 24 mov %eax,(%esp)
801009d4: e8 c7 0c 00 00 call 801016a0 <ilock>
pgdir = 0;
// Check ELF header
if(readi(ip, (char*)&elf, 0, sizeof(elf)) != sizeof(elf))
801009d9: 8d 85 24 ff ff ff lea -0xdc(%ebp),%eax
801009df: c7 44 24 0c 34 00 00 movl $0x34,0xc(%esp)
801009e6: 00
801009e7: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
801009ee: 00
801009ef: 89 44 24 04 mov %eax,0x4(%esp)
801009f3: 89 1c 24 mov %ebx,(%esp)
801009f6: e8 55 0f 00 00 call 80101950 <readi>
801009fb: 83 f8 34 cmp $0x34,%eax
801009fe: 74 20 je 80100a20 <exec+0x80>
bad:
if(pgdir)
freevm(pgdir);
if(ip){
iunlockput(ip);
80100a00: 89 1c 24 mov %ebx,(%esp)
80100a03: e8 f8 0e 00 00 call 80101900 <iunlockput>
end_op();
80100a08: e8 63 21 00 00 call 80102b70 <end_op>
}
return -1;
80100a0d: b8 ff ff ff ff mov $0xffffffff,%eax
}
80100a12: 81 c4 2c 01 00 00 add $0x12c,%esp
80100a18: 5b pop %ebx
80100a19: 5e pop %esi
80100a1a: 5f pop %edi
80100a1b: 5d pop %ebp
80100a1c: c3 ret
80100a1d: 8d 76 00 lea 0x0(%esi),%esi
if(elf.magic != ELF_MAGIC)
80100a20: 81 bd 24 ff ff ff 7f cmpl $0x464c457f,-0xdc(%ebp)
80100a27: 45 4c 46
80100a2a: 75 d4 jne 80100a00 <exec+0x60>
if((pgdir = setupkvm()) == 0)
80100a2c: e8 ff 5f 00 00 call 80106a30 <setupkvm>
80100a31: 85 c0 test %eax,%eax
80100a33: 89 85 f0 fe ff ff mov %eax,-0x110(%ebp)
80100a39: 74 c5 je 80100a00 <exec+0x60>
for(i=0, off=elf.phoff; i<elf.phnum; i++, off+=sizeof(ph)){
80100a3b: 66 83 bd 50 ff ff ff cmpw $0x0,-0xb0(%ebp)
80100a42: 00
80100a43: 8b b5 40 ff ff ff mov -0xc0(%ebp),%esi
sz = 0;
80100a49: c7 85 ec fe ff ff 00 movl $0x0,-0x114(%ebp)
80100a50: 00 00 00
for(i=0, off=elf.phoff; i<elf.phnum; i++, off+=sizeof(ph)){
80100a53: 0f 84 da 00 00 00 je 80100b33 <exec+0x193>
80100a59: 31 ff xor %edi,%edi
80100a5b: eb 18 jmp 80100a75 <exec+0xd5>
80100a5d: 8d 76 00 lea 0x0(%esi),%esi
80100a60: 0f b7 85 50 ff ff ff movzwl -0xb0(%ebp),%eax
80100a67: 83 c7 01 add $0x1,%edi
80100a6a: 83 c6 20 add $0x20,%esi
80100a6d: 39 f8 cmp %edi,%eax
80100a6f: 0f 8e be 00 00 00 jle 80100b33 <exec+0x193>
if(readi(ip, (char*)&ph, off, sizeof(ph)) != sizeof(ph))
80100a75: 8d 85 04 ff ff ff lea -0xfc(%ebp),%eax
80100a7b: c7 44 24 0c 20 00 00 movl $0x20,0xc(%esp)
80100a82: 00
80100a83: 89 74 24 08 mov %esi,0x8(%esp)
80100a87: 89 44 24 04 mov %eax,0x4(%esp)
80100a8b: 89 1c 24 mov %ebx,(%esp)
80100a8e: e8 bd 0e 00 00 call 80101950 <readi>
80100a93: 83 f8 20 cmp $0x20,%eax
80100a96: 0f 85 84 00 00 00 jne 80100b20 <exec+0x180>
if(ph.type != ELF_PROG_LOAD)
80100a9c: 83 bd 04 ff ff ff 01 cmpl $0x1,-0xfc(%ebp)
80100aa3: 75 bb jne 80100a60 <exec+0xc0>
if(ph.memsz < ph.filesz)
80100aa5: 8b 85 18 ff ff ff mov -0xe8(%ebp),%eax
80100aab: 3b 85 14 ff ff ff cmp -0xec(%ebp),%eax
80100ab1: 72 6d jb 80100b20 <exec+0x180>
if(ph.vaddr + ph.memsz < ph.vaddr)
80100ab3: 03 85 0c ff ff ff add -0xf4(%ebp),%eax
80100ab9: 72 65 jb 80100b20 <exec+0x180>
if((sz = allocuvm(pgdir, sz, ph.vaddr + ph.memsz)) == 0)
80100abb: 89 44 24 08 mov %eax,0x8(%esp)
80100abf: 8b 85 ec fe ff ff mov -0x114(%ebp),%eax
80100ac5: 89 44 24 04 mov %eax,0x4(%esp)
80100ac9: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax
80100acf: 89 04 24 mov %eax,(%esp)
80100ad2: e8 b9 5d 00 00 call 80106890 <allocuvm>
80100ad7: 85 c0 test %eax,%eax
80100ad9: 89 85 ec fe ff ff mov %eax,-0x114(%ebp)
80100adf: 74 3f je 80100b20 <exec+0x180>
if(ph.vaddr % PGSIZE != 0)
80100ae1: 8b 85 0c ff ff ff mov -0xf4(%ebp),%eax
80100ae7: a9 ff 0f 00 00 test $0xfff,%eax
80100aec: 75 32 jne 80100b20 <exec+0x180>
if(loaduvm(pgdir, (char*)ph.vaddr, ip, ph.off, ph.filesz) < 0)
80100aee: 8b 95 14 ff ff ff mov -0xec(%ebp),%edx
80100af4: 89 44 24 04 mov %eax,0x4(%esp)
80100af8: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax
80100afe: 89 5c 24 08 mov %ebx,0x8(%esp)
80100b02: 89 54 24 10 mov %edx,0x10(%esp)
80100b06: 8b 95 08 ff ff ff mov -0xf8(%ebp),%edx
80100b0c: 89 04 24 mov %eax,(%esp)
80100b0f: 89 54 24 0c mov %edx,0xc(%esp)
80100b13: e8 b8 5c 00 00 call 801067d0 <loaduvm>
80100b18: 85 c0 test %eax,%eax
80100b1a: 0f 89 40 ff ff ff jns 80100a60 <exec+0xc0>
freevm(pgdir);
80100b20: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax
80100b26: 89 04 24 mov %eax,(%esp)
80100b29: e8 82 5e 00 00 call 801069b0 <freevm>
80100b2e: e9 cd fe ff ff jmp 80100a00 <exec+0x60>
iunlockput(ip);
80100b33: 89 1c 24 mov %ebx,(%esp)
80100b36: e8 c5 0d 00 00 call 80101900 <iunlockput>
80100b3b: 90 nop
80100b3c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
end_op();
80100b40: e8 2b 20 00 00 call 80102b70 <end_op>
if((allocuvm(pgdir, KERNBASE - PGSIZE, KERNBASE - PGSIZE + 4)) == 0)
80100b45: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax
80100b4b: c7 44 24 08 04 f0 ff movl $0x7ffff004,0x8(%esp)
80100b52: 7f
80100b53: c7 44 24 04 00 f0 ff movl $0x7ffff000,0x4(%esp)
80100b5a: 7f
80100b5b: 89 04 24 mov %eax,(%esp)
80100b5e: e8 2d 5d 00 00 call 80106890 <allocuvm>
80100b63: 85 c0 test %eax,%eax
80100b65: 0f 84 8d 00 00 00 je 80100bf8 <exec+0x258>
for(argc = 0; argv[argc]; argc++) {
80100b6b: 8b 45 0c mov 0xc(%ebp),%eax
80100b6e: 8b 00 mov (%eax),%eax
80100b70: 85 c0 test %eax,%eax
80100b72: 0f 84 9b 01 00 00 je 80100d13 <exec+0x373>
80100b78: 8b 4d 0c mov 0xc(%ebp),%ecx
80100b7b: 31 d2 xor %edx,%edx
80100b7d: bb fc ff ff 7f mov $0x7ffffffc,%ebx
80100b82: 8d 71 04 lea 0x4(%ecx),%esi
80100b85: 89 cf mov %ecx,%edi
80100b87: 89 f1 mov %esi,%ecx
80100b89: 89 d6 mov %edx,%esi
80100b8b: 89 ca mov %ecx,%edx
80100b8d: eb 27 jmp 80100bb6 <exec+0x216>
80100b8f: 90 nop
80100b90: 8b 95 e8 fe ff ff mov -0x118(%ebp),%edx
ustack[3+argc] = sp;
80100b96: 8d 8d 58 ff ff ff lea -0xa8(%ebp),%ecx
80100b9c: 89 9c b5 64 ff ff ff mov %ebx,-0x9c(%ebp,%esi,4)
for(argc = 0; argv[argc]; argc++) {
80100ba3: 83 c6 01 add $0x1,%esi
80100ba6: 8b 02 mov (%edx),%eax
80100ba8: 89 d7 mov %edx,%edi
80100baa: 85 c0 test %eax,%eax
80100bac: 74 7d je 80100c2b <exec+0x28b>
80100bae: 83 c2 04 add $0x4,%edx
if(argc >= MAXARG)
80100bb1: 83 fe 20 cmp $0x20,%esi
80100bb4: 74 42 je 80100bf8 <exec+0x258>
sp = (sp - (strlen(argv[argc]) + 1)) & ~3;
80100bb6: 89 04 24 mov %eax,(%esp)
80100bb9: 89 95 e8 fe ff ff mov %edx,-0x118(%ebp)
80100bbf: e8 cc 38 00 00 call 80104490 <strlen>
80100bc4: f7 d0 not %eax
80100bc6: 01 c3 add %eax,%ebx
if(copyout(pgdir, sp, argv[argc], strlen(argv[argc]) + 1) < 0)
80100bc8: 8b 07 mov (%edi),%eax
sp = (sp - (strlen(argv[argc]) + 1)) & ~3;
80100bca: 83 e3 fc and $0xfffffffc,%ebx
if(copyout(pgdir, sp, argv[argc], strlen(argv[argc]) + 1) < 0)
80100bcd: 89 04 24 mov %eax,(%esp)
80100bd0: e8 bb 38 00 00 call 80104490 <strlen>
80100bd5: 83 c0 01 add $0x1,%eax
80100bd8: 89 44 24 0c mov %eax,0xc(%esp)
80100bdc: 8b 07 mov (%edi),%eax
80100bde: 89 5c 24 04 mov %ebx,0x4(%esp)
80100be2: 89 44 24 08 mov %eax,0x8(%esp)
80100be6: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax
80100bec: 89 04 24 mov %eax,(%esp)
80100bef: e8 0c 61 00 00 call 80106d00 <copyout>
80100bf4: 85 c0 test %eax,%eax
80100bf6: 79 98 jns 80100b90 <exec+0x1f0>
freevm(pgdir);
80100bf8: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax
80100bfe: 89 04 24 mov %eax,(%esp)
80100c01: e8 aa 5d 00 00 call 801069b0 <freevm>
return -1;
80100c06: b8 ff ff ff ff mov $0xffffffff,%eax
80100c0b: e9 02 fe ff ff jmp 80100a12 <exec+0x72>
end_op();
80100c10: e8 5b 1f 00 00 call 80102b70 <end_op>
cprintf("exec: fail\n");
80100c15: c7 04 24 a1 6e 10 80 movl $0x80106ea1,(%esp)
80100c1c: e8 2f fa ff ff call 80100650 <cprintf>
return -1;
80100c21: b8 ff ff ff ff mov $0xffffffff,%eax
80100c26: e9 e7 fd ff ff jmp 80100a12 <exec+0x72>
80100c2b: 89 f2 mov %esi,%edx
ustack[3+argc] = 0;
80100c2d: c7 84 95 64 ff ff ff movl $0x0,-0x9c(%ebp,%edx,4)
80100c34: 00 00 00 00
ustack[2] = sp - (argc+1)*4; // argv pointer
80100c38: 8d 04 95 04 00 00 00 lea 0x4(,%edx,4),%eax
ustack[1] = argc;
80100c3f: 89 95 5c ff ff ff mov %edx,-0xa4(%ebp)
ustack[2] = sp - (argc+1)*4; // argv pointer
80100c45: 89 da mov %ebx,%edx
80100c47: 29 c2 sub %eax,%edx
sp -= (3+argc+1) * 4;
80100c49: 83 c0 0c add $0xc,%eax
80100c4c: 29 c3 sub %eax,%ebx
if(copyout(pgdir, sp, ustack, (3+argc+1)*4) < 0)
80100c4e: 89 44 24 0c mov %eax,0xc(%esp)
80100c52: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax
80100c58: 89 4c 24 08 mov %ecx,0x8(%esp)
80100c5c: 89 5c 24 04 mov %ebx,0x4(%esp)
ustack[0] = 0xffffffff; // fake return PC
80100c60: c7 85 58 ff ff ff ff movl $0xffffffff,-0xa8(%ebp)
80100c67: ff ff ff
if(copyout(pgdir, sp, ustack, (3+argc+1)*4) < 0)
80100c6a: 89 04 24 mov %eax,(%esp)
ustack[2] = sp - (argc+1)*4; // argv pointer
80100c6d: 89 95 60 ff ff ff mov %edx,-0xa0(%ebp)
if(copyout(pgdir, sp, ustack, (3+argc+1)*4) < 0)
80100c73: e8 88 60 00 00 call 80106d00 <copyout>
80100c78: 85 c0 test %eax,%eax
80100c7a: 0f 88 78 ff ff ff js 80100bf8 <exec+0x258>
for(last=s=path; *s; s++)
80100c80: 8b 45 08 mov 0x8(%ebp),%eax
80100c83: 0f b6 10 movzbl (%eax),%edx
80100c86: 84 d2 test %dl,%dl
80100c88: 74 19 je 80100ca3 <exec+0x303>
80100c8a: 8b 4d 08 mov 0x8(%ebp),%ecx
80100c8d: 83 c0 01 add $0x1,%eax
last = s+1;
80100c90: 80 fa 2f cmp $0x2f,%dl
for(last=s=path; *s; s++)
80100c93: 0f b6 10 movzbl (%eax),%edx
last = s+1;
80100c96: 0f 44 c8 cmove %eax,%ecx
80100c99: 83 c0 01 add $0x1,%eax
for(last=s=path; *s; s++)
80100c9c: 84 d2 test %dl,%dl
80100c9e: 75 f0 jne 80100c90 <exec+0x2f0>
80100ca0: 89 4d 08 mov %ecx,0x8(%ebp)
safestrcpy(curproc->name, last, sizeof(curproc->name));
80100ca3: 8b bd f4 fe ff ff mov -0x10c(%ebp),%edi
80100ca9: 8b 45 08 mov 0x8(%ebp),%eax
80100cac: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp)
80100cb3: 00
80100cb4: 89 44 24 04 mov %eax,0x4(%esp)
80100cb8: 89 f8 mov %edi,%eax
80100cba: 83 c0 70 add $0x70,%eax
80100cbd: 89 04 24 mov %eax,(%esp)
80100cc0: e8 8b 37 00 00 call 80104450 <safestrcpy>
sz = PGROUNDUP(sz);
80100cc5: 8b 85 ec fe ff ff mov -0x114(%ebp),%eax
curproc->pgdir = pgdir;
80100ccb: 8b 95 f0 fe ff ff mov -0x110(%ebp),%edx
oldpgdir = curproc->pgdir;
80100cd1: 8b 77 08 mov 0x8(%edi),%esi
curproc->sb = 1;
80100cd4: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi)
sz = PGROUNDUP(sz);
80100cdb: 05 ff 0f 00 00 add $0xfff,%eax
80100ce0: 25 00 f0 ff ff and $0xfffff000,%eax
80100ce5: 89 07 mov %eax,(%edi)
curproc->tf->eip = elf.entry; // main
80100ce7: 8b 47 1c mov 0x1c(%edi),%eax
curproc->pgdir = pgdir;
80100cea: 89 57 08 mov %edx,0x8(%edi)
curproc->tf->eip = elf.entry; // main
80100ced: 8b 95 3c ff ff ff mov -0xc4(%ebp),%edx
80100cf3: 89 50 38 mov %edx,0x38(%eax)
curproc->tf->esp = sp;
80100cf6: 8b 47 1c mov 0x1c(%edi),%eax
80100cf9: 89 58 44 mov %ebx,0x44(%eax)
switchuvm(curproc);
80100cfc: 89 3c 24 mov %edi,(%esp)
80100cff: e8 2c 59 00 00 call 80106630 <switchuvm>
freevm(oldpgdir);
80100d04: 89 34 24 mov %esi,(%esp)
80100d07: e8 a4 5c 00 00 call 801069b0 <freevm>
return 0;
80100d0c: 31 c0 xor %eax,%eax
80100d0e: e9 ff fc ff ff jmp 80100a12 <exec+0x72>
for(argc = 0; argv[argc]; argc++) {
80100d13: bb fc ff ff 7f mov $0x7ffffffc,%ebx
80100d18: 31 d2 xor %edx,%edx
80100d1a: 8d 8d 58 ff ff ff lea -0xa8(%ebp),%ecx
80100d20: e9 08 ff ff ff jmp 80100c2d <exec+0x28d>
80100d25: 66 90 xchg %ax,%ax
80100d27: 66 90 xchg %ax,%ax
80100d29: 66 90 xchg %ax,%ax
80100d2b: 66 90 xchg %ax,%ax
80100d2d: 66 90 xchg %ax,%ax
80100d2f: 90 nop
80100d30 <fileinit>:
struct file file[NFILE];
} ftable;
void
fileinit(void)
{
80100d30: 55 push %ebp
80100d31: 89 e5 mov %esp,%ebp
80100d33: 83 ec 18 sub $0x18,%esp
initlock(&ftable.lock, "ftable");
80100d36: c7 44 24 04 ad 6e 10 movl $0x80106ead,0x4(%esp)
80100d3d: 80
80100d3e: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
80100d45: e8 f6 32 00 00 call 80104040 <initlock>
}
80100d4a: c9 leave
80100d4b: c3 ret
80100d4c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80100d50 <filealloc>:
// Allocate a file structure.
struct file*
filealloc(void)
{
80100d50: 55 push %ebp
80100d51: 89 e5 mov %esp,%ebp
80100d53: 53 push %ebx
struct file *f;
acquire(&ftable.lock);
for(f = ftable.file; f < ftable.file + NFILE; f++){
80100d54: bb f4 ff 10 80 mov $0x8010fff4,%ebx
{
80100d59: 83 ec 14 sub $0x14,%esp
acquire(&ftable.lock);
80100d5c: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
80100d63: e8 c8 33 00 00 call 80104130 <acquire>
80100d68: eb 11 jmp 80100d7b <filealloc+0x2b>
80100d6a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
for(f = ftable.file; f < ftable.file + NFILE; f++){
80100d70: 83 c3 18 add $0x18,%ebx
80100d73: 81 fb 54 09 11 80 cmp $0x80110954,%ebx
80100d79: 74 25 je 80100da0 <filealloc+0x50>
if(f->ref == 0){
80100d7b: 8b 43 04 mov 0x4(%ebx),%eax
80100d7e: 85 c0 test %eax,%eax
80100d80: 75 ee jne 80100d70 <filealloc+0x20>
f->ref = 1;
release(&ftable.lock);
80100d82: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
f->ref = 1;
80100d89: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx)
release(&ftable.lock);
80100d90: e8 8b 34 00 00 call 80104220 <release>
return f;
}
}
release(&ftable.lock);
return 0;
}
80100d95: 83 c4 14 add $0x14,%esp
return f;
80100d98: 89 d8 mov %ebx,%eax
}
80100d9a: 5b pop %ebx
80100d9b: 5d pop %ebp
80100d9c: c3 ret
80100d9d: 8d 76 00 lea 0x0(%esi),%esi
release(&ftable.lock);
80100da0: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
80100da7: e8 74 34 00 00 call 80104220 <release>
}
80100dac: 83 c4 14 add $0x14,%esp
return 0;
80100daf: 31 c0 xor %eax,%eax
}
80100db1: 5b pop %ebx
80100db2: 5d pop %ebp
80100db3: c3 ret
80100db4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80100dba: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
80100dc0 <filedup>:
// Increment ref count for file f.
struct file*
filedup(struct file *f)
{
80100dc0: 55 push %ebp
80100dc1: 89 e5 mov %esp,%ebp
80100dc3: 53 push %ebx
80100dc4: 83 ec 14 sub $0x14,%esp
80100dc7: 8b 5d 08 mov 0x8(%ebp),%ebx
acquire(&ftable.lock);
80100dca: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
80100dd1: e8 5a 33 00 00 call 80104130 <acquire>
if(f->ref < 1)
80100dd6: 8b 43 04 mov 0x4(%ebx),%eax
80100dd9: 85 c0 test %eax,%eax
80100ddb: 7e 1a jle 80100df7 <filedup+0x37>
panic("filedup");
f->ref++;
80100ddd: 83 c0 01 add $0x1,%eax
80100de0: 89 43 04 mov %eax,0x4(%ebx)
release(&ftable.lock);
80100de3: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
80100dea: e8 31 34 00 00 call 80104220 <release>
return f;
}
80100def: 83 c4 14 add $0x14,%esp
80100df2: 89 d8 mov %ebx,%eax
80100df4: 5b pop %ebx
80100df5: 5d pop %ebp
80100df6: c3 ret
panic("filedup");
80100df7: c7 04 24 b4 6e 10 80 movl $0x80106eb4,(%esp)
80100dfe: e8 5d f5 ff ff call 80100360 <panic>
80100e03: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80100e09: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80100e10 <fileclose>:
// Close file f. (Decrement ref count, close when reaches 0.)
void
fileclose(struct file *f)
{
80100e10: 55 push %ebp
80100e11: 89 e5 mov %esp,%ebp
80100e13: 57 push %edi
80100e14: 56 push %esi
80100e15: 53 push %ebx
80100e16: 83 ec 1c sub $0x1c,%esp
80100e19: 8b 7d 08 mov 0x8(%ebp),%edi
struct file ff;
acquire(&ftable.lock);
80100e1c: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
80100e23: e8 08 33 00 00 call 80104130 <acquire>
if(f->ref < 1)
80100e28: 8b 57 04 mov 0x4(%edi),%edx
80100e2b: 85 d2 test %edx,%edx
80100e2d: 0f 8e 89 00 00 00 jle 80100ebc <fileclose+0xac>
panic("fileclose");
if(--f->ref > 0){
80100e33: 83 ea 01 sub $0x1,%edx
80100e36: 85 d2 test %edx,%edx
80100e38: 89 57 04 mov %edx,0x4(%edi)
80100e3b: 74 13 je 80100e50 <fileclose+0x40>
release(&ftable.lock);
80100e3d: c7 45 08 c0 ff 10 80 movl $0x8010ffc0,0x8(%ebp)
else if(ff.type == FD_INODE){
begin_op();
iput(ff.ip);
end_op();
}
}
80100e44: 83 c4 1c add $0x1c,%esp
80100e47: 5b pop %ebx
80100e48: 5e pop %esi
80100e49: 5f pop %edi
80100e4a: 5d pop %ebp
release(&ftable.lock);
80100e4b: e9 d0 33 00 00 jmp 80104220 <release>
ff = *f;
80100e50: 0f b6 47 09 movzbl 0x9(%edi),%eax
80100e54: 8b 37 mov (%edi),%esi
80100e56: 8b 5f 0c mov 0xc(%edi),%ebx
f->type = FD_NONE;
80100e59: c7 07 00 00 00 00 movl $0x0,(%edi)
ff = *f;
80100e5f: 88 45 e7 mov %al,-0x19(%ebp)
80100e62: 8b 47 10 mov 0x10(%edi),%eax
release(&ftable.lock);
80100e65: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
ff = *f;
80100e6c: 89 45 e0 mov %eax,-0x20(%ebp)
release(&ftable.lock);
80100e6f: e8 ac 33 00 00 call 80104220 <release>
if(ff.type == FD_PIPE)
80100e74: 83 fe 01 cmp $0x1,%esi
80100e77: 74 0f je 80100e88 <fileclose+0x78>
else if(ff.type == FD_INODE){
80100e79: 83 fe 02 cmp $0x2,%esi
80100e7c: 74 22 je 80100ea0 <fileclose+0x90>
}
80100e7e: 83 c4 1c add $0x1c,%esp
80100e81: 5b pop %ebx
80100e82: 5e pop %esi
80100e83: 5f pop %edi
80100e84: 5d pop %ebp
80100e85: c3 ret
80100e86: 66 90 xchg %ax,%ax
pipeclose(ff.pipe, ff.writable);
80100e88: 0f be 75 e7 movsbl -0x19(%ebp),%esi
80100e8c: 89 1c 24 mov %ebx,(%esp)
80100e8f: 89 74 24 04 mov %esi,0x4(%esp)
80100e93: e8 b8 23 00 00 call 80103250 <pipeclose>
80100e98: eb e4 jmp 80100e7e <fileclose+0x6e>
80100e9a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
begin_op();
80100ea0: e8 5b 1c 00 00 call 80102b00 <begin_op>
iput(ff.ip);
80100ea5: 8b 45 e0 mov -0x20(%ebp),%eax
80100ea8: 89 04 24 mov %eax,(%esp)
80100eab: e8 10 09 00 00 call 801017c0 <iput>
}
80100eb0: 83 c4 1c add $0x1c,%esp
80100eb3: 5b pop %ebx
80100eb4: 5e pop %esi
80100eb5: 5f pop %edi
80100eb6: 5d pop %ebp
end_op();
80100eb7: e9 b4 1c 00 00 jmp 80102b70 <end_op>
panic("fileclose");
80100ebc: c7 04 24 bc 6e 10 80 movl $0x80106ebc,(%esp)
80100ec3: e8 98 f4 ff ff call 80100360 <panic>
80100ec8: 90 nop
80100ec9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80100ed0 <filestat>:
// Get metadata about file f.
int
filestat(struct file *f, struct stat *st)
{
80100ed0: 55 push %ebp
80100ed1: 89 e5 mov %esp,%ebp
80100ed3: 53 push %ebx
80100ed4: 83 ec 14 sub $0x14,%esp
80100ed7: 8b 5d 08 mov 0x8(%ebp),%ebx
if(f->type == FD_INODE){
80100eda: 83 3b 02 cmpl $0x2,(%ebx)
80100edd: 75 31 jne 80100f10 <filestat+0x40>
ilock(f->ip);
80100edf: 8b 43 10 mov 0x10(%ebx),%eax
80100ee2: 89 04 24 mov %eax,(%esp)
80100ee5: e8 b6 07 00 00 call 801016a0 <ilock>
stati(f->ip, st);
80100eea: 8b 45 0c mov 0xc(%ebp),%eax
80100eed: 89 44 24 04 mov %eax,0x4(%esp)
80100ef1: 8b 43 10 mov 0x10(%ebx),%eax
80100ef4: 89 04 24 mov %eax,(%esp)
80100ef7: e8 24 0a 00 00 call 80101920 <stati>
iunlock(f->ip);
80100efc: 8b 43 10 mov 0x10(%ebx),%eax
80100eff: 89 04 24 mov %eax,(%esp)
80100f02: e8 79 08 00 00 call 80101780 <iunlock>
return 0;
}
return -1;
}
80100f07: 83 c4 14 add $0x14,%esp
return 0;
80100f0a: 31 c0 xor %eax,%eax
}
80100f0c: 5b pop %ebx
80100f0d: 5d pop %ebp
80100f0e: c3 ret
80100f0f: 90 nop
80100f10: 83 c4 14 add $0x14,%esp
return -1;
80100f13: b8 ff ff ff ff mov $0xffffffff,%eax
}
80100f18: 5b pop %ebx
80100f19: 5d pop %ebp
80100f1a: c3 ret
80100f1b: 90 nop
80100f1c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80100f20 <fileread>:
// Read from file f.
int
fileread(struct file *f, char *addr, int n)
{
80100f20: 55 push %ebp
80100f21: 89 e5 mov %esp,%ebp
80100f23: 57 push %edi
80100f24: 56 push %esi
80100f25: 53 push %ebx
80100f26: 83 ec 1c sub $0x1c,%esp
80100f29: 8b 5d 08 mov 0x8(%ebp),%ebx
80100f2c: 8b 75 0c mov 0xc(%ebp),%esi
80100f2f: 8b 7d 10 mov 0x10(%ebp),%edi
int r;
if(f->readable == 0)
80100f32: 80 7b 08 00 cmpb $0x0,0x8(%ebx)
80100f36: 74 68 je 80100fa0 <fileread+0x80>
return -1;
if(f->type == FD_PIPE)
80100f38: 8b 03 mov (%ebx),%eax
80100f3a: 83 f8 01 cmp $0x1,%eax
80100f3d: 74 49 je 80100f88 <fileread+0x68>
return piperead(f->pipe, addr, n);
if(f->type == FD_INODE){
80100f3f: 83 f8 02 cmp $0x2,%eax
80100f42: 75 63 jne 80100fa7 <fileread+0x87>
ilock(f->ip);
80100f44: 8b 43 10 mov 0x10(%ebx),%eax
80100f47: 89 04 24 mov %eax,(%esp)
80100f4a: e8 51 07 00 00 call 801016a0 <ilock>
if((r = readi(f->ip, addr, f->off, n)) > 0)
80100f4f: 89 7c 24 0c mov %edi,0xc(%esp)
80100f53: 8b 43 14 mov 0x14(%ebx),%eax
80100f56: 89 74 24 04 mov %esi,0x4(%esp)
80100f5a: 89 44 24 08 mov %eax,0x8(%esp)
80100f5e: 8b 43 10 mov 0x10(%ebx),%eax
80100f61: 89 04 24 mov %eax,(%esp)
80100f64: e8 e7 09 00 00 call 80101950 <readi>
80100f69: 85 c0 test %eax,%eax
80100f6b: 89 c6 mov %eax,%esi
80100f6d: 7e 03 jle 80100f72 <fileread+0x52>
f->off += r;
80100f6f: 01 43 14 add %eax,0x14(%ebx)
iunlock(f->ip);
80100f72: 8b 43 10 mov 0x10(%ebx),%eax
80100f75: 89 04 24 mov %eax,(%esp)
80100f78: e8 03 08 00 00 call 80101780 <iunlock>
if((r = readi(f->ip, addr, f->off, n)) > 0)
80100f7d: 89 f0 mov %esi,%eax
return r;
}
panic("fileread");
}
80100f7f: 83 c4 1c add $0x1c,%esp
80100f82: 5b pop %ebx
80100f83: 5e pop %esi
80100f84: 5f pop %edi
80100f85: 5d pop %ebp
80100f86: c3 ret
80100f87: 90 nop
return piperead(f->pipe, addr, n);
80100f88: 8b 43 0c mov 0xc(%ebx),%eax
80100f8b: 89 45 08 mov %eax,0x8(%ebp)
}
80100f8e: 83 c4 1c add $0x1c,%esp
80100f91: 5b pop %ebx
80100f92: 5e pop %esi
80100f93: 5f pop %edi
80100f94: 5d pop %ebp
return piperead(f->pipe, addr, n);
80100f95: e9 36 24 00 00 jmp 801033d0 <piperead>
80100f9a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return -1;
80100fa0: b8 ff ff ff ff mov $0xffffffff,%eax
80100fa5: eb d8 jmp 80100f7f <fileread+0x5f>
panic("fileread");
80100fa7: c7 04 24 c6 6e 10 80 movl $0x80106ec6,(%esp)
80100fae: e8 ad f3 ff ff call 80100360 <panic>
80100fb3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80100fb9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80100fc0 <filewrite>:
//PAGEBREAK!
// Write to file f.
int
filewrite(struct file *f, char *addr, int n)
{
80100fc0: 55 push %ebp
80100fc1: 89 e5 mov %esp,%ebp
80100fc3: 57 push %edi
80100fc4: 56 push %esi
80100fc5: 53 push %ebx
80100fc6: 83 ec 2c sub $0x2c,%esp
80100fc9: 8b 45 0c mov 0xc(%ebp),%eax
80100fcc: 8b 7d 08 mov 0x8(%ebp),%edi
80100fcf: 89 45 dc mov %eax,-0x24(%ebp)
80100fd2: 8b 45 10 mov 0x10(%ebp),%eax
int r;
if(f->writable == 0)
80100fd5: 80 7f 09 00 cmpb $0x0,0x9(%edi)
{
80100fd9: 89 45 e4 mov %eax,-0x1c(%ebp)
if(f->writable == 0)
80100fdc: 0f 84 ae 00 00 00 je 80101090 <filewrite+0xd0>
return -1;
if(f->type == FD_PIPE)
80100fe2: 8b 07 mov (%edi),%eax
80100fe4: 83 f8 01 cmp $0x1,%eax
80100fe7: 0f 84 c2 00 00 00 je 801010af <filewrite+0xef>
return pipewrite(f->pipe, addr, n);
if(f->type == FD_INODE){
80100fed: 83 f8 02 cmp $0x2,%eax
80100ff0: 0f 85 d7 00 00 00 jne 801010cd <filewrite+0x10d>
// and 2 blocks of slop for non-aligned writes.
// this really belongs lower down, since writei()
// might be writing a device like the console.
int max = ((LOGSIZE-1-1-2) / 2) * 512;
int i = 0;
while(i < n){
80100ff6: 8b 45 e4 mov -0x1c(%ebp),%eax
80100ff9: 31 db xor %ebx,%ebx
80100ffb: 85 c0 test %eax,%eax
80100ffd: 7f 31 jg 80101030 <filewrite+0x70>
80100fff: e9 9c 00 00 00 jmp 801010a0 <filewrite+0xe0>
80101004: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
begin_op();
ilock(f->ip);
if ((r = writei(f->ip, addr + i, f->off, n1)) > 0)
f->off += r;
iunlock(f->ip);
80101008: 8b 4f 10 mov 0x10(%edi),%ecx
f->off += r;
8010100b: 01 47 14 add %eax,0x14(%edi)
8010100e: 89 45 e0 mov %eax,-0x20(%ebp)
iunlock(f->ip);
80101011: 89 0c 24 mov %ecx,(%esp)
80101014: e8 67 07 00 00 call 80101780 <iunlock>
end_op();
80101019: e8 52 1b 00 00 call 80102b70 <end_op>
8010101e: 8b 45 e0 mov -0x20(%ebp),%eax
if(r < 0)
break;
if(r != n1)
80101021: 39 f0 cmp %esi,%eax
80101023: 0f 85 98 00 00 00 jne 801010c1 <filewrite+0x101>
panic("short filewrite");
i += r;
80101029: 01 c3 add %eax,%ebx
while(i < n){
8010102b: 39 5d e4 cmp %ebx,-0x1c(%ebp)
8010102e: 7e 70 jle 801010a0 <filewrite+0xe0>
int n1 = n - i;
80101030: 8b 75 e4 mov -0x1c(%ebp),%esi
80101033: b8 00 1a 00 00 mov $0x1a00,%eax
80101038: 29 de sub %ebx,%esi
8010103a: 81 fe 00 1a 00 00 cmp $0x1a00,%esi
80101040: 0f 4f f0 cmovg %eax,%esi
begin_op();
80101043: e8 b8 1a 00 00 call 80102b00 <begin_op>
ilock(f->ip);
80101048: 8b 47 10 mov 0x10(%edi),%eax
8010104b: 89 04 24 mov %eax,(%esp)
8010104e: e8 4d 06 00 00 call 801016a0 <ilock>
if ((r = writei(f->ip, addr + i, f->off, n1)) > 0)
80101053: 89 74 24 0c mov %esi,0xc(%esp)
80101057: 8b 47 14 mov 0x14(%edi),%eax
8010105a: 89 44 24 08 mov %eax,0x8(%esp)
8010105e: 8b 45 dc mov -0x24(%ebp),%eax
80101061: 01 d8 add %ebx,%eax
80101063: 89 44 24 04 mov %eax,0x4(%esp)
80101067: 8b 47 10 mov 0x10(%edi),%eax
8010106a: 89 04 24 mov %eax,(%esp)
8010106d: e8 de 09 00 00 call 80101a50 <writei>
80101072: 85 c0 test %eax,%eax
80101074: 7f 92 jg 80101008 <filewrite+0x48>
iunlock(f->ip);
80101076: 8b 4f 10 mov 0x10(%edi),%ecx
80101079: 89 45 e0 mov %eax,-0x20(%ebp)
8010107c: 89 0c 24 mov %ecx,(%esp)
8010107f: e8 fc 06 00 00 call 80101780 <iunlock>
end_op();
80101084: e8 e7 1a 00 00 call 80102b70 <end_op>
if(r < 0)
80101089: 8b 45 e0 mov -0x20(%ebp),%eax
8010108c: 85 c0 test %eax,%eax
8010108e: 74 91 je 80101021 <filewrite+0x61>
}
return i == n ? n : -1;
}
panic("filewrite");
}
80101090: 83 c4 2c add $0x2c,%esp
return -1;
80101093: b8 ff ff ff ff mov $0xffffffff,%eax
}
80101098: 5b pop %ebx
80101099: 5e pop %esi
8010109a: 5f pop %edi
8010109b: 5d pop %ebp
8010109c: c3 ret
8010109d: 8d 76 00 lea 0x0(%esi),%esi
return i == n ? n : -1;
801010a0: 3b 5d e4 cmp -0x1c(%ebp),%ebx
801010a3: 89 d8 mov %ebx,%eax
801010a5: 75 e9 jne 80101090 <filewrite+0xd0>
}
801010a7: 83 c4 2c add $0x2c,%esp
801010aa: 5b pop %ebx
801010ab: 5e pop %esi
801010ac: 5f pop %edi
801010ad: 5d pop %ebp
801010ae: c3 ret
return pipewrite(f->pipe, addr, n);
801010af: 8b 47 0c mov 0xc(%edi),%eax
801010b2: 89 45 08 mov %eax,0x8(%ebp)
}
801010b5: 83 c4 2c add $0x2c,%esp
801010b8: 5b pop %ebx
801010b9: 5e pop %esi
801010ba: 5f pop %edi
801010bb: 5d pop %ebp
return pipewrite(f->pipe, addr, n);
801010bc: e9 1f 22 00 00 jmp 801032e0 <pipewrite>
panic("short filewrite");
801010c1: c7 04 24 cf 6e 10 80 movl $0x80106ecf,(%esp)
801010c8: e8 93 f2 ff ff call 80100360 <panic>
panic("filewrite");
801010cd: c7 04 24 d5 6e 10 80 movl $0x80106ed5,(%esp)
801010d4: e8 87 f2 ff ff call 80100360 <panic>
801010d9: 66 90 xchg %ax,%ax
801010db: 66 90 xchg %ax,%ax
801010dd: 66 90 xchg %ax,%ax
801010df: 90 nop
801010e0 <balloc>:
// Blocks.
// Allocate a zeroed disk block.
static uint
balloc(uint dev)
{
801010e0: 55 push %ebp
801010e1: 89 e5 mov %esp,%ebp
801010e3: 57 push %edi
801010e4: 56 push %esi
801010e5: 53 push %ebx
801010e6: 83 ec 2c sub $0x2c,%esp
801010e9: 89 45 d8 mov %eax,-0x28(%ebp)
int b, bi, m;
struct buf *bp;
bp = 0;
for(b = 0; b < sb.size; b += BPB){
801010ec: a1 c0 09 11 80 mov 0x801109c0,%eax
801010f1: 85 c0 test %eax,%eax
801010f3: 0f 84 8c 00 00 00 je 80101185 <balloc+0xa5>
801010f9: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
bp = bread(dev, BBLOCK(b, sb));
80101100: 8b 75 dc mov -0x24(%ebp),%esi
80101103: 89 f0 mov %esi,%eax
80101105: c1 f8 0c sar $0xc,%eax
80101108: 03 05 d8 09 11 80 add 0x801109d8,%eax
8010110e: 89 44 24 04 mov %eax,0x4(%esp)
80101112: 8b 45 d8 mov -0x28(%ebp),%eax
80101115: 89 04 24 mov %eax,(%esp)
80101118: e8 b3 ef ff ff call 801000d0 <bread>
8010111d: 89 45 e4 mov %eax,-0x1c(%ebp)
80101120: a1 c0 09 11 80 mov 0x801109c0,%eax
80101125: 89 45 e0 mov %eax,-0x20(%ebp)
for(bi = 0; bi < BPB && b + bi < sb.size; bi++){
80101128: 31 c0 xor %eax,%eax
8010112a: eb 33 jmp 8010115f <balloc+0x7f>
8010112c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
m = 1 << (bi % 8);
if((bp->data[bi/8] & m) == 0){ // Is block free?
80101130: 8b 5d e4 mov -0x1c(%ebp),%ebx
80101133: 89 c2 mov %eax,%edx
m = 1 << (bi % 8);
80101135: 89 c1 mov %eax,%ecx
if((bp->data[bi/8] & m) == 0){ // Is block free?
80101137: c1 fa 03 sar $0x3,%edx
m = 1 << (bi % 8);
8010113a: 83 e1 07 and $0x7,%ecx
8010113d: bf 01 00 00 00 mov $0x1,%edi
80101142: d3 e7 shl %cl,%edi
if((bp->data[bi/8] & m) == 0){ // Is block free?
80101144: 0f b6 5c 13 5c movzbl 0x5c(%ebx,%edx,1),%ebx
m = 1 << (bi % 8);
80101149: 89 f9 mov %edi,%ecx
if((bp->data[bi/8] & m) == 0){ // Is block free?
8010114b: 0f b6 fb movzbl %bl,%edi
8010114e: 85 cf test %ecx,%edi
80101150: 74 46 je 80101198 <balloc+0xb8>
for(bi = 0; bi < BPB && b + bi < sb.size; bi++){
80101152: 83 c0 01 add $0x1,%eax
80101155: 83 c6 01 add $0x1,%esi
80101158: 3d 00 10 00 00 cmp $0x1000,%eax
8010115d: 74 05 je 80101164 <balloc+0x84>
8010115f: 3b 75 e0 cmp -0x20(%ebp),%esi
80101162: 72 cc jb 80101130 <balloc+0x50>
brelse(bp);
bzero(dev, b + bi);
return b + bi;
}
}
brelse(bp);
80101164: 8b 45 e4 mov -0x1c(%ebp),%eax
80101167: 89 04 24 mov %eax,(%esp)
8010116a: e8 71 f0 ff ff call 801001e0 <brelse>
for(b = 0; b < sb.size; b += BPB){
8010116f: 81 45 dc 00 10 00 00 addl $0x1000,-0x24(%ebp)
80101176: 8b 45 dc mov -0x24(%ebp),%eax
80101179: 3b 05 c0 09 11 80 cmp 0x801109c0,%eax
8010117f: 0f 82 7b ff ff ff jb 80101100 <balloc+0x20>
}
panic("balloc: out of blocks");
80101185: c7 04 24 df 6e 10 80 movl $0x80106edf,(%esp)
8010118c: e8 cf f1 ff ff call 80100360 <panic>
80101191: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
bp->data[bi/8] |= m; // Mark block in use.
80101198: 09 d9 or %ebx,%ecx
8010119a: 8b 5d e4 mov -0x1c(%ebp),%ebx
8010119d: 88 4c 13 5c mov %cl,0x5c(%ebx,%edx,1)
log_write(bp);
801011a1: 89 1c 24 mov %ebx,(%esp)
801011a4: e8 f7 1a 00 00 call 80102ca0 <log_write>
brelse(bp);
801011a9: 89 1c 24 mov %ebx,(%esp)
801011ac: e8 2f f0 ff ff call 801001e0 <brelse>
bp = bread(dev, bno);
801011b1: 8b 45 d8 mov -0x28(%ebp),%eax
801011b4: 89 74 24 04 mov %esi,0x4(%esp)
801011b8: 89 04 24 mov %eax,(%esp)
801011bb: e8 10 ef ff ff call 801000d0 <bread>
memset(bp->data, 0, BSIZE);
801011c0: c7 44 24 08 00 02 00 movl $0x200,0x8(%esp)
801011c7: 00
801011c8: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
801011cf: 00
bp = bread(dev, bno);
801011d0: 89 c3 mov %eax,%ebx
memset(bp->data, 0, BSIZE);
801011d2: 8d 40 5c lea 0x5c(%eax),%eax
801011d5: 89 04 24 mov %eax,(%esp)
801011d8: e8 93 30 00 00 call 80104270 <memset>
log_write(bp);
801011dd: 89 1c 24 mov %ebx,(%esp)
801011e0: e8 bb 1a 00 00 call 80102ca0 <log_write>
brelse(bp);
801011e5: 89 1c 24 mov %ebx,(%esp)
801011e8: e8 f3 ef ff ff call 801001e0 <brelse>
}
801011ed: 83 c4 2c add $0x2c,%esp
801011f0: 89 f0 mov %esi,%eax
801011f2: 5b pop %ebx
801011f3: 5e pop %esi
801011f4: 5f pop %edi
801011f5: 5d pop %ebp
801011f6: c3 ret
801011f7: 89 f6 mov %esi,%esi
801011f9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101200 <iget>:
// Find the inode with number inum on device dev
// and return the in-memory copy. Does not lock
// the inode and does not read it from disk.
static struct inode*
iget(uint dev, uint inum)
{
80101200: 55 push %ebp
80101201: 89 e5 mov %esp,%ebp
80101203: 57 push %edi
80101204: 89 c7 mov %eax,%edi
80101206: 56 push %esi
struct inode *ip, *empty;
acquire(&icache.lock);
// Is the inode already cached?
empty = 0;
80101207: 31 f6 xor %esi,%esi
{
80101209: 53 push %ebx
for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){
8010120a: bb 14 0a 11 80 mov $0x80110a14,%ebx
{
8010120f: 83 ec 1c sub $0x1c,%esp
acquire(&icache.lock);
80101212: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
{
80101219: 89 55 e4 mov %edx,-0x1c(%ebp)
acquire(&icache.lock);
8010121c: e8 0f 2f 00 00 call 80104130 <acquire>
for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){
80101221: 8b 55 e4 mov -0x1c(%ebp),%edx
80101224: eb 14 jmp 8010123a <iget+0x3a>
80101226: 66 90 xchg %ax,%ax
if(ip->ref > 0 && ip->dev == dev && ip->inum == inum){
ip->ref++;
release(&icache.lock);
return ip;
}
if(empty == 0 && ip->ref == 0) // Remember empty slot.
80101228: 85 f6 test %esi,%esi
8010122a: 74 3c je 80101268 <iget+0x68>
for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){
8010122c: 81 c3 90 00 00 00 add $0x90,%ebx
80101232: 81 fb 34 26 11 80 cmp $0x80112634,%ebx
80101238: 74 46 je 80101280 <iget+0x80>
if(ip->ref > 0 && ip->dev == dev && ip->inum == inum){
8010123a: 8b 4b 08 mov 0x8(%ebx),%ecx
8010123d: 85 c9 test %ecx,%ecx
8010123f: 7e e7 jle 80101228 <iget+0x28>
80101241: 39 3b cmp %edi,(%ebx)
80101243: 75 e3 jne 80101228 <iget+0x28>
80101245: 39 53 04 cmp %edx,0x4(%ebx)
80101248: 75 de jne 80101228 <iget+0x28>
ip->ref++;
8010124a: 83 c1 01 add $0x1,%ecx
return ip;
8010124d: 89 de mov %ebx,%esi
release(&icache.lock);
8010124f: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
ip->ref++;
80101256: 89 4b 08 mov %ecx,0x8(%ebx)
release(&icache.lock);
80101259: e8 c2 2f 00 00 call 80104220 <release>
ip->ref = 1;
ip->valid = 0;
release(&icache.lock);
return ip;
}
8010125e: 83 c4 1c add $0x1c,%esp
80101261: 89 f0 mov %esi,%eax
80101263: 5b pop %ebx
80101264: 5e pop %esi
80101265: 5f pop %edi
80101266: 5d pop %ebp
80101267: c3 ret
80101268: 85 c9 test %ecx,%ecx
8010126a: 0f 44 f3 cmove %ebx,%esi
for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){
8010126d: 81 c3 90 00 00 00 add $0x90,%ebx
80101273: 81 fb 34 26 11 80 cmp $0x80112634,%ebx
80101279: 75 bf jne 8010123a <iget+0x3a>
8010127b: 90 nop
8010127c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if(empty == 0)
80101280: 85 f6 test %esi,%esi
80101282: 74 29 je 801012ad <iget+0xad>
ip->dev = dev;
80101284: 89 3e mov %edi,(%esi)
ip->inum = inum;
80101286: 89 56 04 mov %edx,0x4(%esi)
ip->ref = 1;
80101289: c7 46 08 01 00 00 00 movl $0x1,0x8(%esi)
ip->valid = 0;
80101290: c7 46 4c 00 00 00 00 movl $0x0,0x4c(%esi)
release(&icache.lock);
80101297: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
8010129e: e8 7d 2f 00 00 call 80104220 <release>
}
801012a3: 83 c4 1c add $0x1c,%esp
801012a6: 89 f0 mov %esi,%eax
801012a8: 5b pop %ebx
801012a9: 5e pop %esi
801012aa: 5f pop %edi
801012ab: 5d pop %ebp
801012ac: c3 ret
panic("iget: no inodes");
801012ad: c7 04 24 f5 6e 10 80 movl $0x80106ef5,(%esp)
801012b4: e8 a7 f0 ff ff call 80100360 <panic>
801012b9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
801012c0 <bmap>:
// Return the disk block address of the nth block in inode ip.
// If there is no such block, bmap allocates one.
static uint
bmap(struct inode *ip, uint bn)
{
801012c0: 55 push %ebp
801012c1: 89 e5 mov %esp,%ebp
801012c3: 57 push %edi
801012c4: 56 push %esi
801012c5: 53 push %ebx
801012c6: 89 c3 mov %eax,%ebx
801012c8: 83 ec 1c sub $0x1c,%esp
uint addr, *a;
struct buf *bp;
if(bn < NDIRECT){
801012cb: 83 fa 0b cmp $0xb,%edx
801012ce: 77 18 ja 801012e8 <bmap+0x28>
801012d0: 8d 34 90 lea (%eax,%edx,4),%esi
if((addr = ip->addrs[bn]) == 0)
801012d3: 8b 46 5c mov 0x5c(%esi),%eax
801012d6: 85 c0 test %eax,%eax
801012d8: 74 66 je 80101340 <bmap+0x80>
brelse(bp);
return addr;
}
panic("bmap: out of range");
}
801012da: 83 c4 1c add $0x1c,%esp
801012dd: 5b pop %ebx
801012de: 5e pop %esi
801012df: 5f pop %edi
801012e0: 5d pop %ebp
801012e1: c3 ret
801012e2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
bn -= NDIRECT;
801012e8: 8d 72 f4 lea -0xc(%edx),%esi
if(bn < NINDIRECT){
801012eb: 83 fe 7f cmp $0x7f,%esi
801012ee: 77 77 ja 80101367 <bmap+0xa7>
if((addr = ip->addrs[NDIRECT]) == 0)
801012f0: 8b 80 8c 00 00 00 mov 0x8c(%eax),%eax
801012f6: 85 c0 test %eax,%eax
801012f8: 74 5e je 80101358 <bmap+0x98>
bp = bread(ip->dev, addr);
801012fa: 89 44 24 04 mov %eax,0x4(%esp)
801012fe: 8b 03 mov (%ebx),%eax
80101300: 89 04 24 mov %eax,(%esp)
80101303: e8 c8 ed ff ff call 801000d0 <bread>
if((addr = a[bn]) == 0){
80101308: 8d 54 b0 5c lea 0x5c(%eax,%esi,4),%edx
bp = bread(ip->dev, addr);
8010130c: 89 c7 mov %eax,%edi
if((addr = a[bn]) == 0){
8010130e: 8b 32 mov (%edx),%esi
80101310: 85 f6 test %esi,%esi
80101312: 75 19 jne 8010132d <bmap+0x6d>
a[bn] = addr = balloc(ip->dev);
80101314: 8b 03 mov (%ebx),%eax
80101316: 89 55 e4 mov %edx,-0x1c(%ebp)
80101319: e8 c2 fd ff ff call 801010e0 <balloc>
8010131e: 8b 55 e4 mov -0x1c(%ebp),%edx
80101321: 89 02 mov %eax,(%edx)
80101323: 89 c6 mov %eax,%esi
log_write(bp);
80101325: 89 3c 24 mov %edi,(%esp)
80101328: e8 73 19 00 00 call 80102ca0 <log_write>
brelse(bp);
8010132d: 89 3c 24 mov %edi,(%esp)
80101330: e8 ab ee ff ff call 801001e0 <brelse>
}
80101335: 83 c4 1c add $0x1c,%esp
brelse(bp);
80101338: 89 f0 mov %esi,%eax
}
8010133a: 5b pop %ebx
8010133b: 5e pop %esi
8010133c: 5f pop %edi
8010133d: 5d pop %ebp
8010133e: c3 ret
8010133f: 90 nop
ip->addrs[bn] = addr = balloc(ip->dev);
80101340: 8b 03 mov (%ebx),%eax
80101342: e8 99 fd ff ff call 801010e0 <balloc>
80101347: 89 46 5c mov %eax,0x5c(%esi)
}
8010134a: 83 c4 1c add $0x1c,%esp
8010134d: 5b pop %ebx
8010134e: 5e pop %esi
8010134f: 5f pop %edi
80101350: 5d pop %ebp
80101351: c3 ret
80101352: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
ip->addrs[NDIRECT] = addr = balloc(ip->dev);
80101358: 8b 03 mov (%ebx),%eax
8010135a: e8 81 fd ff ff call 801010e0 <balloc>
8010135f: 89 83 8c 00 00 00 mov %eax,0x8c(%ebx)
80101365: eb 93 jmp 801012fa <bmap+0x3a>
panic("bmap: out of range");
80101367: c7 04 24 05 6f 10 80 movl $0x80106f05,(%esp)
8010136e: e8 ed ef ff ff call 80100360 <panic>
80101373: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80101379: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101380 <readsb>:
{
80101380: 55 push %ebp
80101381: 89 e5 mov %esp,%ebp
80101383: 56 push %esi
80101384: 53 push %ebx
80101385: 83 ec 10 sub $0x10,%esp
bp = bread(dev, 1);
80101388: 8b 45 08 mov 0x8(%ebp),%eax
8010138b: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
80101392: 00
{
80101393: 8b 75 0c mov 0xc(%ebp),%esi
bp = bread(dev, 1);
80101396: 89 04 24 mov %eax,(%esp)
80101399: e8 32 ed ff ff call 801000d0 <bread>
memmove(sb, bp->data, sizeof(*sb));
8010139e: 89 34 24 mov %esi,(%esp)
801013a1: c7 44 24 08 1c 00 00 movl $0x1c,0x8(%esp)
801013a8: 00
bp = bread(dev, 1);
801013a9: 89 c3 mov %eax,%ebx
memmove(sb, bp->data, sizeof(*sb));
801013ab: 8d 40 5c lea 0x5c(%eax),%eax
801013ae: 89 44 24 04 mov %eax,0x4(%esp)
801013b2: e8 59 2f 00 00 call 80104310 <memmove>
brelse(bp);
801013b7: 89 5d 08 mov %ebx,0x8(%ebp)
}
801013ba: 83 c4 10 add $0x10,%esp
801013bd: 5b pop %ebx
801013be: 5e pop %esi
801013bf: 5d pop %ebp
brelse(bp);
801013c0: e9 1b ee ff ff jmp 801001e0 <brelse>
801013c5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801013c9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801013d0 <bfree>:
{
801013d0: 55 push %ebp
801013d1: 89 e5 mov %esp,%ebp
801013d3: 57 push %edi
801013d4: 89 d7 mov %edx,%edi
801013d6: 56 push %esi
801013d7: 53 push %ebx
801013d8: 89 c3 mov %eax,%ebx
801013da: 83 ec 1c sub $0x1c,%esp
readsb(dev, &sb);
801013dd: 89 04 24 mov %eax,(%esp)
801013e0: c7 44 24 04 c0 09 11 movl $0x801109c0,0x4(%esp)
801013e7: 80
801013e8: e8 93 ff ff ff call 80101380 <readsb>
bp = bread(dev, BBLOCK(b, sb));
801013ed: 89 fa mov %edi,%edx
801013ef: c1 ea 0c shr $0xc,%edx
801013f2: 03 15 d8 09 11 80 add 0x801109d8,%edx
801013f8: 89 1c 24 mov %ebx,(%esp)
m = 1 << (bi % 8);
801013fb: bb 01 00 00 00 mov $0x1,%ebx
bp = bread(dev, BBLOCK(b, sb));
80101400: 89 54 24 04 mov %edx,0x4(%esp)
80101404: e8 c7 ec ff ff call 801000d0 <bread>
m = 1 << (bi % 8);
80101409: 89 f9 mov %edi,%ecx
bi = b % BPB;
8010140b: 81 e7 ff 0f 00 00 and $0xfff,%edi
80101411: 89 fa mov %edi,%edx
m = 1 << (bi % 8);
80101413: 83 e1 07 and $0x7,%ecx
if((bp->data[bi/8] & m) == 0)
80101416: c1 fa 03 sar $0x3,%edx
m = 1 << (bi % 8);
80101419: d3 e3 shl %cl,%ebx
bp = bread(dev, BBLOCK(b, sb));
8010141b: 89 c6 mov %eax,%esi
if((bp->data[bi/8] & m) == 0)
8010141d: 0f b6 44 10 5c movzbl 0x5c(%eax,%edx,1),%eax
80101422: 0f b6 c8 movzbl %al,%ecx
80101425: 85 d9 test %ebx,%ecx
80101427: 74 20 je 80101449 <bfree+0x79>
bp->data[bi/8] &= ~m;
80101429: f7 d3 not %ebx
8010142b: 21 c3 and %eax,%ebx
8010142d: 88 5c 16 5c mov %bl,0x5c(%esi,%edx,1)
log_write(bp);
80101431: 89 34 24 mov %esi,(%esp)
80101434: e8 67 18 00 00 call 80102ca0 <log_write>
brelse(bp);
80101439: 89 34 24 mov %esi,(%esp)
8010143c: e8 9f ed ff ff call 801001e0 <brelse>
}
80101441: 83 c4 1c add $0x1c,%esp
80101444: 5b pop %ebx
80101445: 5e pop %esi
80101446: 5f pop %edi
80101447: 5d pop %ebp
80101448: c3 ret
panic("freeing free block");
80101449: c7 04 24 18 6f 10 80 movl $0x80106f18,(%esp)
80101450: e8 0b ef ff ff call 80100360 <panic>
80101455: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80101459: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101460 <iinit>:
{
80101460: 55 push %ebp
80101461: 89 e5 mov %esp,%ebp
80101463: 53 push %ebx
80101464: bb 20 0a 11 80 mov $0x80110a20,%ebx
80101469: 83 ec 24 sub $0x24,%esp
initlock(&icache.lock, "icache");
8010146c: c7 44 24 04 2b 6f 10 movl $0x80106f2b,0x4(%esp)
80101473: 80
80101474: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
8010147b: e8 c0 2b 00 00 call 80104040 <initlock>
initsleeplock(&icache.inode[i].lock, "inode");
80101480: 89 1c 24 mov %ebx,(%esp)
80101483: 81 c3 90 00 00 00 add $0x90,%ebx
80101489: c7 44 24 04 32 6f 10 movl $0x80106f32,0x4(%esp)
80101490: 80
80101491: e8 9a 2a 00 00 call 80103f30 <initsleeplock>
for(i = 0; i < NINODE; i++) {
80101496: 81 fb 40 26 11 80 cmp $0x80112640,%ebx
8010149c: 75 e2 jne 80101480 <iinit+0x20>
readsb(dev, &sb);
8010149e: 8b 45 08 mov 0x8(%ebp),%eax
801014a1: c7 44 24 04 c0 09 11 movl $0x801109c0,0x4(%esp)
801014a8: 80
801014a9: 89 04 24 mov %eax,(%esp)
801014ac: e8 cf fe ff ff call 80101380 <readsb>
cprintf("sb: size %d nblocks %d ninodes %d nlog %d logstart %d\
801014b1: a1 d8 09 11 80 mov 0x801109d8,%eax
801014b6: c7 04 24 98 6f 10 80 movl $0x80106f98,(%esp)
801014bd: 89 44 24 1c mov %eax,0x1c(%esp)
801014c1: a1 d4 09 11 80 mov 0x801109d4,%eax
801014c6: 89 44 24 18 mov %eax,0x18(%esp)
801014ca: a1 d0 09 11 80 mov 0x801109d0,%eax
801014cf: 89 44 24 14 mov %eax,0x14(%esp)
801014d3: a1 cc 09 11 80 mov 0x801109cc,%eax
801014d8: 89 44 24 10 mov %eax,0x10(%esp)
801014dc: a1 c8 09 11 80 mov 0x801109c8,%eax
801014e1: 89 44 24 0c mov %eax,0xc(%esp)
801014e5: a1 c4 09 11 80 mov 0x801109c4,%eax
801014ea: 89 44 24 08 mov %eax,0x8(%esp)
801014ee: a1 c0 09 11 80 mov 0x801109c0,%eax
801014f3: 89 44 24 04 mov %eax,0x4(%esp)
801014f7: e8 54 f1 ff ff call 80100650 <cprintf>
}
801014fc: 83 c4 24 add $0x24,%esp
801014ff: 5b pop %ebx
80101500: 5d pop %ebp
80101501: c3 ret
80101502: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80101509: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101510 <ialloc>:
{
80101510: 55 push %ebp
80101511: 89 e5 mov %esp,%ebp
80101513: 57 push %edi
80101514: 56 push %esi
80101515: 53 push %ebx
80101516: 83 ec 2c sub $0x2c,%esp
80101519: 8b 45 0c mov 0xc(%ebp),%eax
for(inum = 1; inum < sb.ninodes; inum++){
8010151c: 83 3d c8 09 11 80 01 cmpl $0x1,0x801109c8
{
80101523: 8b 7d 08 mov 0x8(%ebp),%edi
80101526: 89 45 e4 mov %eax,-0x1c(%ebp)
for(inum = 1; inum < sb.ninodes; inum++){
80101529: 0f 86 a2 00 00 00 jbe 801015d1 <ialloc+0xc1>
8010152f: be 01 00 00 00 mov $0x1,%esi
80101534: bb 01 00 00 00 mov $0x1,%ebx
80101539: eb 1a jmp 80101555 <ialloc+0x45>
8010153b: 90 nop
8010153c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
brelse(bp);
80101540: 89 14 24 mov %edx,(%esp)
for(inum = 1; inum < sb.ninodes; inum++){
80101543: 83 c3 01 add $0x1,%ebx
brelse(bp);
80101546: e8 95 ec ff ff call 801001e0 <brelse>
for(inum = 1; inum < sb.ninodes; inum++){
8010154b: 89 de mov %ebx,%esi
8010154d: 3b 1d c8 09 11 80 cmp 0x801109c8,%ebx
80101553: 73 7c jae 801015d1 <ialloc+0xc1>
bp = bread(dev, IBLOCK(inum, sb));
80101555: 89 f0 mov %esi,%eax
80101557: c1 e8 03 shr $0x3,%eax
8010155a: 03 05 d4 09 11 80 add 0x801109d4,%eax
80101560: 89 3c 24 mov %edi,(%esp)
80101563: 89 44 24 04 mov %eax,0x4(%esp)
80101567: e8 64 eb ff ff call 801000d0 <bread>
8010156c: 89 c2 mov %eax,%edx
dip = (struct dinode*)bp->data + inum%IPB;
8010156e: 89 f0 mov %esi,%eax
80101570: 83 e0 07 and $0x7,%eax
80101573: c1 e0 06 shl $0x6,%eax
80101576: 8d 4c 02 5c lea 0x5c(%edx,%eax,1),%ecx
if(dip->type == 0){ // a free inode
8010157a: 66 83 39 00 cmpw $0x0,(%ecx)
8010157e: 75 c0 jne 80101540 <ialloc+0x30>
memset(dip, 0, sizeof(*dip));
80101580: 89 0c 24 mov %ecx,(%esp)
80101583: c7 44 24 08 40 00 00 movl $0x40,0x8(%esp)
8010158a: 00
8010158b: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80101592: 00
80101593: 89 55 dc mov %edx,-0x24(%ebp)
80101596: 89 4d e0 mov %ecx,-0x20(%ebp)
80101599: e8 d2 2c 00 00 call 80104270 <memset>
dip->type = type;
8010159e: 0f b7 45 e4 movzwl -0x1c(%ebp),%eax
log_write(bp); // mark it allocated on the disk
801015a2: 8b 55 dc mov -0x24(%ebp),%edx
dip->type = type;
801015a5: 8b 4d e0 mov -0x20(%ebp),%ecx
log_write(bp); // mark it allocated on the disk
801015a8: 89 55 e4 mov %edx,-0x1c(%ebp)
dip->type = type;
801015ab: 66 89 01 mov %ax,(%ecx)
log_write(bp); // mark it allocated on the disk
801015ae: 89 14 24 mov %edx,(%esp)
801015b1: e8 ea 16 00 00 call 80102ca0 <log_write>
brelse(bp);
801015b6: 8b 55 e4 mov -0x1c(%ebp),%edx
801015b9: 89 14 24 mov %edx,(%esp)
801015bc: e8 1f ec ff ff call 801001e0 <brelse>
}
801015c1: 83 c4 2c add $0x2c,%esp
return iget(dev, inum);
801015c4: 89 f2 mov %esi,%edx
}
801015c6: 5b pop %ebx
return iget(dev, inum);
801015c7: 89 f8 mov %edi,%eax
}
801015c9: 5e pop %esi
801015ca: 5f pop %edi
801015cb: 5d pop %ebp
return iget(dev, inum);
801015cc: e9 2f fc ff ff jmp 80101200 <iget>
panic("ialloc: no inodes");
801015d1: c7 04 24 38 6f 10 80 movl $0x80106f38,(%esp)
801015d8: e8 83 ed ff ff call 80100360 <panic>
801015dd: 8d 76 00 lea 0x0(%esi),%esi
801015e0 <iupdate>:
{
801015e0: 55 push %ebp
801015e1: 89 e5 mov %esp,%ebp
801015e3: 56 push %esi
801015e4: 53 push %ebx
801015e5: 83 ec 10 sub $0x10,%esp
801015e8: 8b 5d 08 mov 0x8(%ebp),%ebx
bp = bread(ip->dev, IBLOCK(ip->inum, sb));
801015eb: 8b 43 04 mov 0x4(%ebx),%eax
memmove(dip->addrs, ip->addrs, sizeof(ip->addrs));
801015ee: 83 c3 5c add $0x5c,%ebx
bp = bread(ip->dev, IBLOCK(ip->inum, sb));
801015f1: c1 e8 03 shr $0x3,%eax
801015f4: 03 05 d4 09 11 80 add 0x801109d4,%eax
801015fa: 89 44 24 04 mov %eax,0x4(%esp)
801015fe: 8b 43 a4 mov -0x5c(%ebx),%eax
80101601: 89 04 24 mov %eax,(%esp)
80101604: e8 c7 ea ff ff call 801000d0 <bread>
dip = (struct dinode*)bp->data + ip->inum%IPB;
80101609: 8b 53 a8 mov -0x58(%ebx),%edx
8010160c: 83 e2 07 and $0x7,%edx
8010160f: c1 e2 06 shl $0x6,%edx
80101612: 8d 54 10 5c lea 0x5c(%eax,%edx,1),%edx
bp = bread(ip->dev, IBLOCK(ip->inum, sb));
80101616: 89 c6 mov %eax,%esi
dip->type = ip->type;
80101618: 0f b7 43 f4 movzwl -0xc(%ebx),%eax
memmove(dip->addrs, ip->addrs, sizeof(ip->addrs));
8010161c: 83 c2 0c add $0xc,%edx
dip->type = ip->type;
8010161f: 66 89 42 f4 mov %ax,-0xc(%edx)
dip->major = ip->major;
80101623: 0f b7 43 f6 movzwl -0xa(%ebx),%eax
80101627: 66 89 42 f6 mov %ax,-0xa(%edx)
dip->minor = ip->minor;
8010162b: 0f b7 43 f8 movzwl -0x8(%ebx),%eax
8010162f: 66 89 42 f8 mov %ax,-0x8(%edx)
dip->nlink = ip->nlink;
80101633: 0f b7 43 fa movzwl -0x6(%ebx),%eax
80101637: 66 89 42 fa mov %ax,-0x6(%edx)
dip->size = ip->size;
8010163b: 8b 43 fc mov -0x4(%ebx),%eax
8010163e: 89 42 fc mov %eax,-0x4(%edx)
memmove(dip->addrs, ip->addrs, sizeof(ip->addrs));
80101641: 89 5c 24 04 mov %ebx,0x4(%esp)
80101645: 89 14 24 mov %edx,(%esp)
80101648: c7 44 24 08 34 00 00 movl $0x34,0x8(%esp)
8010164f: 00
80101650: e8 bb 2c 00 00 call 80104310 <memmove>
log_write(bp);
80101655: 89 34 24 mov %esi,(%esp)
80101658: e8 43 16 00 00 call 80102ca0 <log_write>
brelse(bp);
8010165d: 89 75 08 mov %esi,0x8(%ebp)
}
80101660: 83 c4 10 add $0x10,%esp
80101663: 5b pop %ebx
80101664: 5e pop %esi
80101665: 5d pop %ebp
brelse(bp);
80101666: e9 75 eb ff ff jmp 801001e0 <brelse>
8010166b: 90 nop
8010166c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80101670 <idup>:
{
80101670: 55 push %ebp
80101671: 89 e5 mov %esp,%ebp
80101673: 53 push %ebx
80101674: 83 ec 14 sub $0x14,%esp
80101677: 8b 5d 08 mov 0x8(%ebp),%ebx
acquire(&icache.lock);
8010167a: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
80101681: e8 aa 2a 00 00 call 80104130 <acquire>
ip->ref++;
80101686: 83 43 08 01 addl $0x1,0x8(%ebx)
release(&icache.lock);
8010168a: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
80101691: e8 8a 2b 00 00 call 80104220 <release>
}
80101696: 83 c4 14 add $0x14,%esp
80101699: 89 d8 mov %ebx,%eax
8010169b: 5b pop %ebx
8010169c: 5d pop %ebp
8010169d: c3 ret
8010169e: 66 90 xchg %ax,%ax
801016a0 <ilock>:
{
801016a0: 55 push %ebp
801016a1: 89 e5 mov %esp,%ebp
801016a3: 56 push %esi
801016a4: 53 push %ebx
801016a5: 83 ec 10 sub $0x10,%esp
801016a8: 8b 5d 08 mov 0x8(%ebp),%ebx
if(ip == 0 || ip->ref < 1)
801016ab: 85 db test %ebx,%ebx
801016ad: 0f 84 b3 00 00 00 je 80101766 <ilock+0xc6>
801016b3: 8b 53 08 mov 0x8(%ebx),%edx
801016b6: 85 d2 test %edx,%edx
801016b8: 0f 8e a8 00 00 00 jle 80101766 <ilock+0xc6>
acquiresleep(&ip->lock);
801016be: 8d 43 0c lea 0xc(%ebx),%eax
801016c1: 89 04 24 mov %eax,(%esp)
801016c4: e8 a7 28 00 00 call 80103f70 <acquiresleep>
if(ip->valid == 0){
801016c9: 8b 43 4c mov 0x4c(%ebx),%eax
801016cc: 85 c0 test %eax,%eax
801016ce: 74 08 je 801016d8 <ilock+0x38>
}
801016d0: 83 c4 10 add $0x10,%esp
801016d3: 5b pop %ebx
801016d4: 5e pop %esi
801016d5: 5d pop %ebp
801016d6: c3 ret
801016d7: 90 nop
bp = bread(ip->dev, IBLOCK(ip->inum, sb));
801016d8: 8b 43 04 mov 0x4(%ebx),%eax
801016db: c1 e8 03 shr $0x3,%eax
801016de: 03 05 d4 09 11 80 add 0x801109d4,%eax
801016e4: 89 44 24 04 mov %eax,0x4(%esp)
801016e8: 8b 03 mov (%ebx),%eax
801016ea: 89 04 24 mov %eax,(%esp)
801016ed: e8 de e9 ff ff call 801000d0 <bread>
dip = (struct dinode*)bp->data + ip->inum%IPB;
801016f2: 8b 53 04 mov 0x4(%ebx),%edx
801016f5: 83 e2 07 and $0x7,%edx
801016f8: c1 e2 06 shl $0x6,%edx
801016fb: 8d 54 10 5c lea 0x5c(%eax,%edx,1),%edx
bp = bread(ip->dev, IBLOCK(ip->inum, sb));
801016ff: 89 c6 mov %eax,%esi
ip->type = dip->type;
80101701: 0f b7 02 movzwl (%edx),%eax
memmove(ip->addrs, dip->addrs, sizeof(ip->addrs));
80101704: 83 c2 0c add $0xc,%edx
ip->type = dip->type;
80101707: 66 89 43 50 mov %ax,0x50(%ebx)
ip->major = dip->major;
8010170b: 0f b7 42 f6 movzwl -0xa(%edx),%eax
8010170f: 66 89 43 52 mov %ax,0x52(%ebx)
ip->minor = dip->minor;
80101713: 0f b7 42 f8 movzwl -0x8(%edx),%eax
80101717: 66 89 43 54 mov %ax,0x54(%ebx)
ip->nlink = dip->nlink;
8010171b: 0f b7 42 fa movzwl -0x6(%edx),%eax
8010171f: 66 89 43 56 mov %ax,0x56(%ebx)
ip->size = dip->size;
80101723: 8b 42 fc mov -0x4(%edx),%eax
80101726: 89 43 58 mov %eax,0x58(%ebx)
memmove(ip->addrs, dip->addrs, sizeof(ip->addrs));
80101729: 8d 43 5c lea 0x5c(%ebx),%eax
8010172c: 89 54 24 04 mov %edx,0x4(%esp)
80101730: c7 44 24 08 34 00 00 movl $0x34,0x8(%esp)
80101737: 00
80101738: 89 04 24 mov %eax,(%esp)
8010173b: e8 d0 2b 00 00 call 80104310 <memmove>
brelse(bp);
80101740: 89 34 24 mov %esi,(%esp)
80101743: e8 98 ea ff ff call 801001e0 <brelse>
if(ip->type == 0)
80101748: 66 83 7b 50 00 cmpw $0x0,0x50(%ebx)
ip->valid = 1;
8010174d: c7 43 4c 01 00 00 00 movl $0x1,0x4c(%ebx)
if(ip->type == 0)
80101754: 0f 85 76 ff ff ff jne 801016d0 <ilock+0x30>
panic("ilock: no type");
8010175a: c7 04 24 50 6f 10 80 movl $0x80106f50,(%esp)
80101761: e8 fa eb ff ff call 80100360 <panic>
panic("ilock");
80101766: c7 04 24 4a 6f 10 80 movl $0x80106f4a,(%esp)
8010176d: e8 ee eb ff ff call 80100360 <panic>
80101772: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80101779: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101780 <iunlock>:
{
80101780: 55 push %ebp
80101781: 89 e5 mov %esp,%ebp
80101783: 56 push %esi
80101784: 53 push %ebx
80101785: 83 ec 10 sub $0x10,%esp
80101788: 8b 5d 08 mov 0x8(%ebp),%ebx
if(ip == 0 || !holdingsleep(&ip->lock) || ip->ref < 1)
8010178b: 85 db test %ebx,%ebx
8010178d: 74 24 je 801017b3 <iunlock+0x33>
8010178f: 8d 73 0c lea 0xc(%ebx),%esi
80101792: 89 34 24 mov %esi,(%esp)
80101795: e8 76 28 00 00 call 80104010 <holdingsleep>
8010179a: 85 c0 test %eax,%eax
8010179c: 74 15 je 801017b3 <iunlock+0x33>
8010179e: 8b 43 08 mov 0x8(%ebx),%eax
801017a1: 85 c0 test %eax,%eax
801017a3: 7e 0e jle 801017b3 <iunlock+0x33>
releasesleep(&ip->lock);
801017a5: 89 75 08 mov %esi,0x8(%ebp)
}
801017a8: 83 c4 10 add $0x10,%esp
801017ab: 5b pop %ebx
801017ac: 5e pop %esi
801017ad: 5d pop %ebp
releasesleep(&ip->lock);
801017ae: e9 1d 28 00 00 jmp 80103fd0 <releasesleep>
panic("iunlock");
801017b3: c7 04 24 5f 6f 10 80 movl $0x80106f5f,(%esp)
801017ba: e8 a1 eb ff ff call 80100360 <panic>
801017bf: 90 nop
801017c0 <iput>:
{
801017c0: 55 push %ebp
801017c1: 89 e5 mov %esp,%ebp
801017c3: 57 push %edi
801017c4: 56 push %esi
801017c5: 53 push %ebx
801017c6: 83 ec 1c sub $0x1c,%esp
801017c9: 8b 75 08 mov 0x8(%ebp),%esi
acquiresleep(&ip->lock);
801017cc: 8d 7e 0c lea 0xc(%esi),%edi
801017cf: 89 3c 24 mov %edi,(%esp)
801017d2: e8 99 27 00 00 call 80103f70 <acquiresleep>
if(ip->valid && ip->nlink == 0){
801017d7: 8b 56 4c mov 0x4c(%esi),%edx
801017da: 85 d2 test %edx,%edx
801017dc: 74 07 je 801017e5 <iput+0x25>
801017de: 66 83 7e 56 00 cmpw $0x0,0x56(%esi)
801017e3: 74 2b je 80101810 <iput+0x50>
releasesleep(&ip->lock);
801017e5: 89 3c 24 mov %edi,(%esp)
801017e8: e8 e3 27 00 00 call 80103fd0 <releasesleep>
acquire(&icache.lock);
801017ed: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
801017f4: e8 37 29 00 00 call 80104130 <acquire>
ip->ref--;
801017f9: 83 6e 08 01 subl $0x1,0x8(%esi)
release(&icache.lock);
801017fd: c7 45 08 e0 09 11 80 movl $0x801109e0,0x8(%ebp)
}
80101804: 83 c4 1c add $0x1c,%esp
80101807: 5b pop %ebx
80101808: 5e pop %esi
80101809: 5f pop %edi
8010180a: 5d pop %ebp
release(&icache.lock);
8010180b: e9 10 2a 00 00 jmp 80104220 <release>
acquire(&icache.lock);
80101810: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
80101817: e8 14 29 00 00 call 80104130 <acquire>
int r = ip->ref;
8010181c: 8b 5e 08 mov 0x8(%esi),%ebx
release(&icache.lock);
8010181f: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
80101826: e8 f5 29 00 00 call 80104220 <release>
if(r == 1){
8010182b: 83 fb 01 cmp $0x1,%ebx
8010182e: 75 b5 jne 801017e5 <iput+0x25>
80101830: 8d 4e 30 lea 0x30(%esi),%ecx
80101833: 89 f3 mov %esi,%ebx
80101835: 89 7d e4 mov %edi,-0x1c(%ebp)
80101838: 89 cf mov %ecx,%edi
8010183a: eb 0b jmp 80101847 <iput+0x87>
8010183c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80101840: 83 c3 04 add $0x4,%ebx
{
int i, j;
struct buf *bp;
uint *a;
for(i = 0; i < NDIRECT; i++){
80101843: 39 fb cmp %edi,%ebx
80101845: 74 19 je 80101860 <iput+0xa0>
if(ip->addrs[i]){
80101847: 8b 53 5c mov 0x5c(%ebx),%edx
8010184a: 85 d2 test %edx,%edx
8010184c: 74 f2 je 80101840 <iput+0x80>
bfree(ip->dev, ip->addrs[i]);
8010184e: 8b 06 mov (%esi),%eax
80101850: e8 7b fb ff ff call 801013d0 <bfree>
ip->addrs[i] = 0;
80101855: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx)
8010185c: eb e2 jmp 80101840 <iput+0x80>
8010185e: 66 90 xchg %ax,%ax
}
}
if(ip->addrs[NDIRECT]){
80101860: 8b 86 8c 00 00 00 mov 0x8c(%esi),%eax
80101866: 8b 7d e4 mov -0x1c(%ebp),%edi
80101869: 85 c0 test %eax,%eax
8010186b: 75 2b jne 80101898 <iput+0xd8>
brelse(bp);
bfree(ip->dev, ip->addrs[NDIRECT]);
ip->addrs[NDIRECT] = 0;
}
ip->size = 0;
8010186d: c7 46 58 00 00 00 00 movl $0x0,0x58(%esi)
iupdate(ip);
80101874: 89 34 24 mov %esi,(%esp)
80101877: e8 64 fd ff ff call 801015e0 <iupdate>
ip->type = 0;
8010187c: 31 c0 xor %eax,%eax
8010187e: 66 89 46 50 mov %ax,0x50(%esi)
iupdate(ip);
80101882: 89 34 24 mov %esi,(%esp)
80101885: e8 56 fd ff ff call 801015e0 <iupdate>
ip->valid = 0;
8010188a: c7 46 4c 00 00 00 00 movl $0x0,0x4c(%esi)
80101891: e9 4f ff ff ff jmp 801017e5 <iput+0x25>
80101896: 66 90 xchg %ax,%ax
bp = bread(ip->dev, ip->addrs[NDIRECT]);
80101898: 89 44 24 04 mov %eax,0x4(%esp)
8010189c: 8b 06 mov (%esi),%eax
for(j = 0; j < NINDIRECT; j++){
8010189e: 31 db xor %ebx,%ebx
bp = bread(ip->dev, ip->addrs[NDIRECT]);
801018a0: 89 04 24 mov %eax,(%esp)
801018a3: e8 28 e8 ff ff call 801000d0 <bread>
for(j = 0; j < NINDIRECT; j++){
801018a8: 89 7d e0 mov %edi,-0x20(%ebp)
a = (uint*)bp->data;
801018ab: 8d 48 5c lea 0x5c(%eax),%ecx
bp = bread(ip->dev, ip->addrs[NDIRECT]);
801018ae: 89 45 e4 mov %eax,-0x1c(%ebp)
for(j = 0; j < NINDIRECT; j++){
801018b1: 89 cf mov %ecx,%edi
801018b3: 31 c0 xor %eax,%eax
801018b5: eb 0e jmp 801018c5 <iput+0x105>
801018b7: 90 nop
801018b8: 83 c3 01 add $0x1,%ebx
801018bb: 81 fb 80 00 00 00 cmp $0x80,%ebx
801018c1: 89 d8 mov %ebx,%eax
801018c3: 74 10 je 801018d5 <iput+0x115>
if(a[j])
801018c5: 8b 14 87 mov (%edi,%eax,4),%edx
801018c8: 85 d2 test %edx,%edx
801018ca: 74 ec je 801018b8 <iput+0xf8>
bfree(ip->dev, a[j]);
801018cc: 8b 06 mov (%esi),%eax
801018ce: e8 fd fa ff ff call 801013d0 <bfree>
801018d3: eb e3 jmp 801018b8 <iput+0xf8>
brelse(bp);
801018d5: 8b 45 e4 mov -0x1c(%ebp),%eax
801018d8: 8b 7d e0 mov -0x20(%ebp),%edi
801018db: 89 04 24 mov %eax,(%esp)
801018de: e8 fd e8 ff ff call 801001e0 <brelse>
bfree(ip->dev, ip->addrs[NDIRECT]);
801018e3: 8b 96 8c 00 00 00 mov 0x8c(%esi),%edx
801018e9: 8b 06 mov (%esi),%eax
801018eb: e8 e0 fa ff ff call 801013d0 <bfree>
ip->addrs[NDIRECT] = 0;
801018f0: c7 86 8c 00 00 00 00 movl $0x0,0x8c(%esi)
801018f7: 00 00 00
801018fa: e9 6e ff ff ff jmp 8010186d <iput+0xad>
801018ff: 90 nop
80101900 <iunlockput>:
{
80101900: 55 push %ebp
80101901: 89 e5 mov %esp,%ebp
80101903: 53 push %ebx
80101904: 83 ec 14 sub $0x14,%esp
80101907: 8b 5d 08 mov 0x8(%ebp),%ebx
iunlock(ip);
8010190a: 89 1c 24 mov %ebx,(%esp)
8010190d: e8 6e fe ff ff call 80101780 <iunlock>
iput(ip);
80101912: 89 5d 08 mov %ebx,0x8(%ebp)
}
80101915: 83 c4 14 add $0x14,%esp
80101918: 5b pop %ebx
80101919: 5d pop %ebp
iput(ip);
8010191a: e9 a1 fe ff ff jmp 801017c0 <iput>
8010191f: 90 nop
80101920 <stati>:
// Copy stat information from inode.
// Caller must hold ip->lock.
void
stati(struct inode *ip, struct stat *st)
{
80101920: 55 push %ebp
80101921: 89 e5 mov %esp,%ebp
80101923: 8b 55 08 mov 0x8(%ebp),%edx
80101926: 8b 45 0c mov 0xc(%ebp),%eax
st->dev = ip->dev;
80101929: 8b 0a mov (%edx),%ecx
8010192b: 89 48 04 mov %ecx,0x4(%eax)
st->ino = ip->inum;
8010192e: 8b 4a 04 mov 0x4(%edx),%ecx
80101931: 89 48 08 mov %ecx,0x8(%eax)
st->type = ip->type;
80101934: 0f b7 4a 50 movzwl 0x50(%edx),%ecx
80101938: 66 89 08 mov %cx,(%eax)
st->nlink = ip->nlink;
8010193b: 0f b7 4a 56 movzwl 0x56(%edx),%ecx
8010193f: 66 89 48 0c mov %cx,0xc(%eax)
st->size = ip->size;
80101943: 8b 52 58 mov 0x58(%edx),%edx
80101946: 89 50 10 mov %edx,0x10(%eax)
}
80101949: 5d pop %ebp
8010194a: c3 ret
8010194b: 90 nop
8010194c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80101950 <readi>:
//PAGEBREAK!
// Read data from inode.
// Caller must hold ip->lock.
int
readi(struct inode *ip, char *dst, uint off, uint n)
{
80101950: 55 push %ebp
80101951: 89 e5 mov %esp,%ebp
80101953: 57 push %edi
80101954: 56 push %esi
80101955: 53 push %ebx
80101956: 83 ec 2c sub $0x2c,%esp
80101959: 8b 45 0c mov 0xc(%ebp),%eax
8010195c: 8b 7d 08 mov 0x8(%ebp),%edi
8010195f: 8b 75 10 mov 0x10(%ebp),%esi
80101962: 89 45 e0 mov %eax,-0x20(%ebp)
80101965: 8b 45 14 mov 0x14(%ebp),%eax
uint tot, m;
struct buf *bp;
if(ip->type == T_DEV){
80101968: 66 83 7f 50 03 cmpw $0x3,0x50(%edi)
{
8010196d: 89 45 e4 mov %eax,-0x1c(%ebp)
if(ip->type == T_DEV){
80101970: 0f 84 aa 00 00 00 je 80101a20 <readi+0xd0>
if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].read)
return -1;
return devsw[ip->major].read(ip, dst, n);
}
if(off > ip->size || off + n < off)
80101976: 8b 47 58 mov 0x58(%edi),%eax
80101979: 39 f0 cmp %esi,%eax
8010197b: 0f 82 c7 00 00 00 jb 80101a48 <readi+0xf8>
80101981: 8b 5d e4 mov -0x1c(%ebp),%ebx
80101984: 89 da mov %ebx,%edx
80101986: 01 f2 add %esi,%edx
80101988: 0f 82 ba 00 00 00 jb 80101a48 <readi+0xf8>
return -1;
if(off + n > ip->size)
n = ip->size - off;
8010198e: 89 c1 mov %eax,%ecx
80101990: 29 f1 sub %esi,%ecx
80101992: 39 d0 cmp %edx,%eax
80101994: 0f 43 cb cmovae %ebx,%ecx
for(tot=0; tot<n; tot+=m, off+=m, dst+=m){
80101997: 31 c0 xor %eax,%eax
80101999: 85 c9 test %ecx,%ecx
n = ip->size - off;
8010199b: 89 4d e4 mov %ecx,-0x1c(%ebp)
for(tot=0; tot<n; tot+=m, off+=m, dst+=m){
8010199e: 74 70 je 80101a10 <readi+0xc0>
801019a0: 89 7d d8 mov %edi,-0x28(%ebp)
801019a3: 89 c7 mov %eax,%edi
801019a5: 8d 76 00 lea 0x0(%esi),%esi
bp = bread(ip->dev, bmap(ip, off/BSIZE));
801019a8: 8b 5d d8 mov -0x28(%ebp),%ebx
801019ab: 89 f2 mov %esi,%edx
801019ad: c1 ea 09 shr $0x9,%edx
801019b0: 89 d8 mov %ebx,%eax
801019b2: e8 09 f9 ff ff call 801012c0 <bmap>
801019b7: 89 44 24 04 mov %eax,0x4(%esp)
801019bb: 8b 03 mov (%ebx),%eax
m = min(n - tot, BSIZE - off%BSIZE);
801019bd: bb 00 02 00 00 mov $0x200,%ebx
bp = bread(ip->dev, bmap(ip, off/BSIZE));
801019c2: 89 04 24 mov %eax,(%esp)
801019c5: e8 06 e7 ff ff call 801000d0 <bread>
m = min(n - tot, BSIZE - off%BSIZE);
801019ca: 8b 4d e4 mov -0x1c(%ebp),%ecx
801019cd: 29 f9 sub %edi,%ecx
bp = bread(ip->dev, bmap(ip, off/BSIZE));
801019cf: 89 c2 mov %eax,%edx
m = min(n - tot, BSIZE - off%BSIZE);
801019d1: 89 f0 mov %esi,%eax
801019d3: 25 ff 01 00 00 and $0x1ff,%eax
801019d8: 29 c3 sub %eax,%ebx
memmove(dst, bp->data + off%BSIZE, m);
801019da: 8d 44 02 5c lea 0x5c(%edx,%eax,1),%eax
m = min(n - tot, BSIZE - off%BSIZE);
801019de: 39 cb cmp %ecx,%ebx
memmove(dst, bp->data + off%BSIZE, m);
801019e0: 89 44 24 04 mov %eax,0x4(%esp)
801019e4: 8b 45 e0 mov -0x20(%ebp),%eax
m = min(n - tot, BSIZE - off%BSIZE);
801019e7: 0f 47 d9 cmova %ecx,%ebx
memmove(dst, bp->data + off%BSIZE, m);
801019ea: 89 5c 24 08 mov %ebx,0x8(%esp)
for(tot=0; tot<n; tot+=m, off+=m, dst+=m){
801019ee: 01 df add %ebx,%edi
801019f0: 01 de add %ebx,%esi
memmove(dst, bp->data + off%BSIZE, m);
801019f2: 89 55 dc mov %edx,-0x24(%ebp)
801019f5: 89 04 24 mov %eax,(%esp)
801019f8: e8 13 29 00 00 call 80104310 <memmove>
brelse(bp);
801019fd: 8b 55 dc mov -0x24(%ebp),%edx
80101a00: 89 14 24 mov %edx,(%esp)
80101a03: e8 d8 e7 ff ff call 801001e0 <brelse>
for(tot=0; tot<n; tot+=m, off+=m, dst+=m){
80101a08: 01 5d e0 add %ebx,-0x20(%ebp)
80101a0b: 39 7d e4 cmp %edi,-0x1c(%ebp)
80101a0e: 77 98 ja 801019a8 <readi+0x58>
}
return n;
80101a10: 8b 45 e4 mov -0x1c(%ebp),%eax
}
80101a13: 83 c4 2c add $0x2c,%esp
80101a16: 5b pop %ebx
80101a17: 5e pop %esi
80101a18: 5f pop %edi
80101a19: 5d pop %ebp
80101a1a: c3 ret
80101a1b: 90 nop
80101a1c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].read)
80101a20: 0f bf 47 52 movswl 0x52(%edi),%eax
80101a24: 66 83 f8 09 cmp $0x9,%ax
80101a28: 77 1e ja 80101a48 <readi+0xf8>
80101a2a: 8b 04 c5 60 09 11 80 mov -0x7feef6a0(,%eax,8),%eax
80101a31: 85 c0 test %eax,%eax
80101a33: 74 13 je 80101a48 <readi+0xf8>
return devsw[ip->major].read(ip, dst, n);
80101a35: 8b 75 e4 mov -0x1c(%ebp),%esi
80101a38: 89 75 10 mov %esi,0x10(%ebp)
}
80101a3b: 83 c4 2c add $0x2c,%esp
80101a3e: 5b pop %ebx
80101a3f: 5e pop %esi
80101a40: 5f pop %edi
80101a41: 5d pop %ebp
return devsw[ip->major].read(ip, dst, n);
80101a42: ff e0 jmp *%eax
80101a44: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return -1;
80101a48: b8 ff ff ff ff mov $0xffffffff,%eax
80101a4d: eb c4 jmp 80101a13 <readi+0xc3>
80101a4f: 90 nop
80101a50 <writei>:
// PAGEBREAK!
// Write data to inode.
// Caller must hold ip->lock.
int
writei(struct inode *ip, char *src, uint off, uint n)
{
80101a50: 55 push %ebp
80101a51: 89 e5 mov %esp,%ebp
80101a53: 57 push %edi
80101a54: 56 push %esi
80101a55: 53 push %ebx
80101a56: 83 ec 2c sub $0x2c,%esp
80101a59: 8b 45 08 mov 0x8(%ebp),%eax
80101a5c: 8b 75 0c mov 0xc(%ebp),%esi
80101a5f: 8b 4d 14 mov 0x14(%ebp),%ecx
uint tot, m;
struct buf *bp;
if(ip->type == T_DEV){
80101a62: 66 83 78 50 03 cmpw $0x3,0x50(%eax)
{
80101a67: 89 75 dc mov %esi,-0x24(%ebp)
80101a6a: 8b 75 10 mov 0x10(%ebp),%esi
80101a6d: 89 45 d8 mov %eax,-0x28(%ebp)
80101a70: 89 4d e0 mov %ecx,-0x20(%ebp)
if(ip->type == T_DEV){
80101a73: 0f 84 b7 00 00 00 je 80101b30 <writei+0xe0>
if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].write)
return -1;
return devsw[ip->major].write(ip, src, n);
}
if(off > ip->size || off + n < off)
80101a79: 8b 45 d8 mov -0x28(%ebp),%eax
80101a7c: 39 70 58 cmp %esi,0x58(%eax)
80101a7f: 0f 82 e3 00 00 00 jb 80101b68 <writei+0x118>
80101a85: 8b 4d e0 mov -0x20(%ebp),%ecx
80101a88: 89 c8 mov %ecx,%eax
80101a8a: 01 f0 add %esi,%eax
80101a8c: 0f 82 d6 00 00 00 jb 80101b68 <writei+0x118>
return -1;
if(off + n > MAXFILE*BSIZE)
80101a92: 3d 00 18 01 00 cmp $0x11800,%eax
80101a97: 0f 87 cb 00 00 00 ja 80101b68 <writei+0x118>
return -1;
for(tot=0; tot<n; tot+=m, off+=m, src+=m){
80101a9d: 85 c9 test %ecx,%ecx
80101a9f: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
80101aa6: 74 77 je 80101b1f <writei+0xcf>
bp = bread(ip->dev, bmap(ip, off/BSIZE));
80101aa8: 8b 7d d8 mov -0x28(%ebp),%edi
80101aab: 89 f2 mov %esi,%edx
m = min(n - tot, BSIZE - off%BSIZE);
80101aad: bb 00 02 00 00 mov $0x200,%ebx
bp = bread(ip->dev, bmap(ip, off/BSIZE));
80101ab2: c1 ea 09 shr $0x9,%edx
80101ab5: 89 f8 mov %edi,%eax
80101ab7: e8 04 f8 ff ff call 801012c0 <bmap>
80101abc: 89 44 24 04 mov %eax,0x4(%esp)
80101ac0: 8b 07 mov (%edi),%eax
80101ac2: 89 04 24 mov %eax,(%esp)
80101ac5: e8 06 e6 ff ff call 801000d0 <bread>
m = min(n - tot, BSIZE - off%BSIZE);
80101aca: 8b 4d e0 mov -0x20(%ebp),%ecx
80101acd: 2b 4d e4 sub -0x1c(%ebp),%ecx
memmove(bp->data + off%BSIZE, src, m);
80101ad0: 8b 55 dc mov -0x24(%ebp),%edx
bp = bread(ip->dev, bmap(ip, off/BSIZE));
80101ad3: 89 c7 mov %eax,%edi
m = min(n - tot, BSIZE - off%BSIZE);
80101ad5: 89 f0 mov %esi,%eax
80101ad7: 25 ff 01 00 00 and $0x1ff,%eax
80101adc: 29 c3 sub %eax,%ebx
80101ade: 39 cb cmp %ecx,%ebx
80101ae0: 0f 47 d9 cmova %ecx,%ebx
memmove(bp->data + off%BSIZE, src, m);
80101ae3: 8d 44 07 5c lea 0x5c(%edi,%eax,1),%eax
for(tot=0; tot<n; tot+=m, off+=m, src+=m){
80101ae7: 01 de add %ebx,%esi
memmove(bp->data + off%BSIZE, src, m);
80101ae9: 89 54 24 04 mov %edx,0x4(%esp)
80101aed: 89 5c 24 08 mov %ebx,0x8(%esp)
80101af1: 89 04 24 mov %eax,(%esp)
80101af4: e8 17 28 00 00 call 80104310 <memmove>
log_write(bp);
80101af9: 89 3c 24 mov %edi,(%esp)
80101afc: e8 9f 11 00 00 call 80102ca0 <log_write>
brelse(bp);
80101b01: 89 3c 24 mov %edi,(%esp)
80101b04: e8 d7 e6 ff ff call 801001e0 <brelse>
for(tot=0; tot<n; tot+=m, off+=m, src+=m){
80101b09: 01 5d e4 add %ebx,-0x1c(%ebp)
80101b0c: 8b 45 e4 mov -0x1c(%ebp),%eax
80101b0f: 01 5d dc add %ebx,-0x24(%ebp)
80101b12: 39 45 e0 cmp %eax,-0x20(%ebp)
80101b15: 77 91 ja 80101aa8 <writei+0x58>
}
if(n > 0 && off > ip->size){
80101b17: 8b 45 d8 mov -0x28(%ebp),%eax
80101b1a: 39 70 58 cmp %esi,0x58(%eax)
80101b1d: 72 39 jb 80101b58 <writei+0x108>
ip->size = off;
iupdate(ip);
}
return n;
80101b1f: 8b 45 e0 mov -0x20(%ebp),%eax
}
80101b22: 83 c4 2c add $0x2c,%esp
80101b25: 5b pop %ebx
80101b26: 5e pop %esi
80101b27: 5f pop %edi
80101b28: 5d pop %ebp
80101b29: c3 ret
80101b2a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].write)
80101b30: 0f bf 40 52 movswl 0x52(%eax),%eax
80101b34: 66 83 f8 09 cmp $0x9,%ax
80101b38: 77 2e ja 80101b68 <writei+0x118>
80101b3a: 8b 04 c5 64 09 11 80 mov -0x7feef69c(,%eax,8),%eax
80101b41: 85 c0 test %eax,%eax
80101b43: 74 23 je 80101b68 <writei+0x118>
return devsw[ip->major].write(ip, src, n);
80101b45: 89 4d 10 mov %ecx,0x10(%ebp)
}
80101b48: 83 c4 2c add $0x2c,%esp
80101b4b: 5b pop %ebx
80101b4c: 5e pop %esi
80101b4d: 5f pop %edi
80101b4e: 5d pop %ebp
return devsw[ip->major].write(ip, src, n);
80101b4f: ff e0 jmp *%eax
80101b51: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
ip->size = off;
80101b58: 8b 45 d8 mov -0x28(%ebp),%eax
80101b5b: 89 70 58 mov %esi,0x58(%eax)
iupdate(ip);
80101b5e: 89 04 24 mov %eax,(%esp)
80101b61: e8 7a fa ff ff call 801015e0 <iupdate>
80101b66: eb b7 jmp 80101b1f <writei+0xcf>
}
80101b68: 83 c4 2c add $0x2c,%esp
return -1;
80101b6b: b8 ff ff ff ff mov $0xffffffff,%eax
}
80101b70: 5b pop %ebx
80101b71: 5e pop %esi
80101b72: 5f pop %edi
80101b73: 5d pop %ebp
80101b74: c3 ret
80101b75: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80101b79: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101b80 <namecmp>:
//PAGEBREAK!
// Directories
int
namecmp(const char *s, const char *t)
{
80101b80: 55 push %ebp
80101b81: 89 e5 mov %esp,%ebp
80101b83: 83 ec 18 sub $0x18,%esp
return strncmp(s, t, DIRSIZ);
80101b86: 8b 45 0c mov 0xc(%ebp),%eax
80101b89: c7 44 24 08 0e 00 00 movl $0xe,0x8(%esp)
80101b90: 00
80101b91: 89 44 24 04 mov %eax,0x4(%esp)
80101b95: 8b 45 08 mov 0x8(%ebp),%eax
80101b98: 89 04 24 mov %eax,(%esp)
80101b9b: e8 f0 27 00 00 call 80104390 <strncmp>
}
80101ba0: c9 leave
80101ba1: c3 ret
80101ba2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80101ba9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101bb0 <dirlookup>:
// Look for a directory entry in a directory.
// If found, set *poff to byte offset of entry.
struct inode*
dirlookup(struct inode *dp, char *name, uint *poff)
{
80101bb0: 55 push %ebp
80101bb1: 89 e5 mov %esp,%ebp
80101bb3: 57 push %edi
80101bb4: 56 push %esi
80101bb5: 53 push %ebx
80101bb6: 83 ec 2c sub $0x2c,%esp
80101bb9: 8b 5d 08 mov 0x8(%ebp),%ebx
uint off, inum;
struct dirent de;
if(dp->type != T_DIR)
80101bbc: 66 83 7b 50 01 cmpw $0x1,0x50(%ebx)
80101bc1: 0f 85 97 00 00 00 jne 80101c5e <dirlookup+0xae>
panic("dirlookup not DIR");
for(off = 0; off < dp->size; off += sizeof(de)){
80101bc7: 8b 53 58 mov 0x58(%ebx),%edx
80101bca: 31 ff xor %edi,%edi
80101bcc: 8d 75 d8 lea -0x28(%ebp),%esi
80101bcf: 85 d2 test %edx,%edx
80101bd1: 75 0d jne 80101be0 <dirlookup+0x30>
80101bd3: eb 73 jmp 80101c48 <dirlookup+0x98>
80101bd5: 8d 76 00 lea 0x0(%esi),%esi
80101bd8: 83 c7 10 add $0x10,%edi
80101bdb: 39 7b 58 cmp %edi,0x58(%ebx)
80101bde: 76 68 jbe 80101c48 <dirlookup+0x98>
if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
80101be0: c7 44 24 0c 10 00 00 movl $0x10,0xc(%esp)
80101be7: 00
80101be8: 89 7c 24 08 mov %edi,0x8(%esp)
80101bec: 89 74 24 04 mov %esi,0x4(%esp)
80101bf0: 89 1c 24 mov %ebx,(%esp)
80101bf3: e8 58 fd ff ff call 80101950 <readi>
80101bf8: 83 f8 10 cmp $0x10,%eax
80101bfb: 75 55 jne 80101c52 <dirlookup+0xa2>
panic("dirlookup read");
if(de.inum == 0)
80101bfd: 66 83 7d d8 00 cmpw $0x0,-0x28(%ebp)
80101c02: 74 d4 je 80101bd8 <dirlookup+0x28>
return strncmp(s, t, DIRSIZ);
80101c04: 8d 45 da lea -0x26(%ebp),%eax
80101c07: 89 44 24 04 mov %eax,0x4(%esp)
80101c0b: 8b 45 0c mov 0xc(%ebp),%eax
80101c0e: c7 44 24 08 0e 00 00 movl $0xe,0x8(%esp)
80101c15: 00
80101c16: 89 04 24 mov %eax,(%esp)
80101c19: e8 72 27 00 00 call 80104390 <strncmp>
continue;
if(namecmp(name, de.name) == 0){
80101c1e: 85 c0 test %eax,%eax
80101c20: 75 b6 jne 80101bd8 <dirlookup+0x28>
// entry matches path element
if(poff)
80101c22: 8b 45 10 mov 0x10(%ebp),%eax
80101c25: 85 c0 test %eax,%eax
80101c27: 74 05 je 80101c2e <dirlookup+0x7e>
*poff = off;
80101c29: 8b 45 10 mov 0x10(%ebp),%eax
80101c2c: 89 38 mov %edi,(%eax)
inum = de.inum;
80101c2e: 0f b7 55 d8 movzwl -0x28(%ebp),%edx
return iget(dp->dev, inum);
80101c32: 8b 03 mov (%ebx),%eax
80101c34: e8 c7 f5 ff ff call 80101200 <iget>
}
}
return 0;
}
80101c39: 83 c4 2c add $0x2c,%esp
80101c3c: 5b pop %ebx
80101c3d: 5e pop %esi
80101c3e: 5f pop %edi
80101c3f: 5d pop %ebp
80101c40: c3 ret
80101c41: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80101c48: 83 c4 2c add $0x2c,%esp
return 0;
80101c4b: 31 c0 xor %eax,%eax
}
80101c4d: 5b pop %ebx
80101c4e: 5e pop %esi
80101c4f: 5f pop %edi
80101c50: 5d pop %ebp
80101c51: c3 ret
panic("dirlookup read");
80101c52: c7 04 24 79 6f 10 80 movl $0x80106f79,(%esp)
80101c59: e8 02 e7 ff ff call 80100360 <panic>
panic("dirlookup not DIR");
80101c5e: c7 04 24 67 6f 10 80 movl $0x80106f67,(%esp)
80101c65: e8 f6 e6 ff ff call 80100360 <panic>
80101c6a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80101c70 <namex>:
// If parent != 0, return the inode for the parent and copy the final
// path element into name, which must have room for DIRSIZ bytes.
// Must be called inside a transaction since it calls iput().
static struct inode*
namex(char *path, int nameiparent, char *name)
{
80101c70: 55 push %ebp
80101c71: 89 e5 mov %esp,%ebp
80101c73: 57 push %edi
80101c74: 89 cf mov %ecx,%edi
80101c76: 56 push %esi
80101c77: 53 push %ebx
80101c78: 89 c3 mov %eax,%ebx
80101c7a: 83 ec 2c sub $0x2c,%esp
struct inode *ip, *next;
if(*path == '/')
80101c7d: 80 38 2f cmpb $0x2f,(%eax)
{
80101c80: 89 55 e0 mov %edx,-0x20(%ebp)
if(*path == '/')
80101c83: 0f 84 51 01 00 00 je 80101dda <namex+0x16a>
ip = iget(ROOTDEV, ROOTINO);
else
ip = idup(myproc()->cwd);
80101c89: e8 02 1a 00 00 call 80103690 <myproc>
80101c8e: 8b 70 6c mov 0x6c(%eax),%esi
acquire(&icache.lock);
80101c91: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
80101c98: e8 93 24 00 00 call 80104130 <acquire>
ip->ref++;
80101c9d: 83 46 08 01 addl $0x1,0x8(%esi)
release(&icache.lock);
80101ca1: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
80101ca8: e8 73 25 00 00 call 80104220 <release>
80101cad: eb 04 jmp 80101cb3 <namex+0x43>
80101caf: 90 nop
path++;
80101cb0: 83 c3 01 add $0x1,%ebx
while(*path == '/')
80101cb3: 0f b6 03 movzbl (%ebx),%eax
80101cb6: 3c 2f cmp $0x2f,%al
80101cb8: 74 f6 je 80101cb0 <namex+0x40>
if(*path == 0)
80101cba: 84 c0 test %al,%al
80101cbc: 0f 84 ed 00 00 00 je 80101daf <namex+0x13f>
while(*path != '/' && *path != 0)
80101cc2: 0f b6 03 movzbl (%ebx),%eax
80101cc5: 89 da mov %ebx,%edx
80101cc7: 84 c0 test %al,%al
80101cc9: 0f 84 b1 00 00 00 je 80101d80 <namex+0x110>
80101ccf: 3c 2f cmp $0x2f,%al
80101cd1: 75 0f jne 80101ce2 <namex+0x72>
80101cd3: e9 a8 00 00 00 jmp 80101d80 <namex+0x110>
80101cd8: 3c 2f cmp $0x2f,%al
80101cda: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80101ce0: 74 0a je 80101cec <namex+0x7c>
path++;
80101ce2: 83 c2 01 add $0x1,%edx
while(*path != '/' && *path != 0)
80101ce5: 0f b6 02 movzbl (%edx),%eax
80101ce8: 84 c0 test %al,%al
80101cea: 75 ec jne 80101cd8 <namex+0x68>
80101cec: 89 d1 mov %edx,%ecx
80101cee: 29 d9 sub %ebx,%ecx
if(len >= DIRSIZ)
80101cf0: 83 f9 0d cmp $0xd,%ecx
80101cf3: 0f 8e 8f 00 00 00 jle 80101d88 <namex+0x118>
memmove(name, s, DIRSIZ);
80101cf9: 89 5c 24 04 mov %ebx,0x4(%esp)
80101cfd: c7 44 24 08 0e 00 00 movl $0xe,0x8(%esp)
80101d04: 00
80101d05: 89 3c 24 mov %edi,(%esp)
80101d08: 89 55 e4 mov %edx,-0x1c(%ebp)
80101d0b: e8 00 26 00 00 call 80104310 <memmove>
path++;
80101d10: 8b 55 e4 mov -0x1c(%ebp),%edx
80101d13: 89 d3 mov %edx,%ebx
while(*path == '/')
80101d15: 80 3a 2f cmpb $0x2f,(%edx)
80101d18: 75 0e jne 80101d28 <namex+0xb8>
80101d1a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
path++;
80101d20: 83 c3 01 add $0x1,%ebx
while(*path == '/')
80101d23: 80 3b 2f cmpb $0x2f,(%ebx)
80101d26: 74 f8 je 80101d20 <namex+0xb0>
while((path = skipelem(path, name)) != 0){
ilock(ip);
80101d28: 89 34 24 mov %esi,(%esp)
80101d2b: e8 70 f9 ff ff call 801016a0 <ilock>
if(ip->type != T_DIR){
80101d30: 66 83 7e 50 01 cmpw $0x1,0x50(%esi)
80101d35: 0f 85 85 00 00 00 jne 80101dc0 <namex+0x150>
iunlockput(ip);
return 0;
}
if(nameiparent && *path == '\0'){
80101d3b: 8b 55 e0 mov -0x20(%ebp),%edx
80101d3e: 85 d2 test %edx,%edx
80101d40: 74 09 je 80101d4b <namex+0xdb>
80101d42: 80 3b 00 cmpb $0x0,(%ebx)
80101d45: 0f 84 a5 00 00 00 je 80101df0 <namex+0x180>
// Stop one level early.
iunlock(ip);
return ip;
}
if((next = dirlookup(ip, name, 0)) == 0){
80101d4b: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
80101d52: 00
80101d53: 89 7c 24 04 mov %edi,0x4(%esp)
80101d57: 89 34 24 mov %esi,(%esp)
80101d5a: e8 51 fe ff ff call 80101bb0 <dirlookup>
80101d5f: 85 c0 test %eax,%eax
80101d61: 74 5d je 80101dc0 <namex+0x150>
iunlock(ip);
80101d63: 89 34 24 mov %esi,(%esp)
80101d66: 89 45 e4 mov %eax,-0x1c(%ebp)
80101d69: e8 12 fa ff ff call 80101780 <iunlock>
iput(ip);
80101d6e: 89 34 24 mov %esi,(%esp)
80101d71: e8 4a fa ff ff call 801017c0 <iput>
iunlockput(ip);
return 0;
}
iunlockput(ip);
ip = next;
80101d76: 8b 45 e4 mov -0x1c(%ebp),%eax
80101d79: 89 c6 mov %eax,%esi
80101d7b: e9 33 ff ff ff jmp 80101cb3 <namex+0x43>
while(*path != '/' && *path != 0)
80101d80: 31 c9 xor %ecx,%ecx
80101d82: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
memmove(name, s, len);
80101d88: 89 4c 24 08 mov %ecx,0x8(%esp)
80101d8c: 89 5c 24 04 mov %ebx,0x4(%esp)
80101d90: 89 3c 24 mov %edi,(%esp)
80101d93: 89 55 dc mov %edx,-0x24(%ebp)
80101d96: 89 4d e4 mov %ecx,-0x1c(%ebp)
80101d99: e8 72 25 00 00 call 80104310 <memmove>
name[len] = 0;
80101d9e: 8b 4d e4 mov -0x1c(%ebp),%ecx
80101da1: 8b 55 dc mov -0x24(%ebp),%edx
80101da4: c6 04 0f 00 movb $0x0,(%edi,%ecx,1)
80101da8: 89 d3 mov %edx,%ebx
80101daa: e9 66 ff ff ff jmp 80101d15 <namex+0xa5>
}
if(nameiparent){
80101daf: 8b 45 e0 mov -0x20(%ebp),%eax
80101db2: 85 c0 test %eax,%eax
80101db4: 75 4c jne 80101e02 <namex+0x192>
80101db6: 89 f0 mov %esi,%eax
iput(ip);
return 0;
}
return ip;
}
80101db8: 83 c4 2c add $0x2c,%esp
80101dbb: 5b pop %ebx
80101dbc: 5e pop %esi
80101dbd: 5f pop %edi
80101dbe: 5d pop %ebp
80101dbf: c3 ret
iunlock(ip);
80101dc0: 89 34 24 mov %esi,(%esp)
80101dc3: e8 b8 f9 ff ff call 80101780 <iunlock>
iput(ip);
80101dc8: 89 34 24 mov %esi,(%esp)
80101dcb: e8 f0 f9 ff ff call 801017c0 <iput>
}
80101dd0: 83 c4 2c add $0x2c,%esp
return 0;
80101dd3: 31 c0 xor %eax,%eax
}
80101dd5: 5b pop %ebx
80101dd6: 5e pop %esi
80101dd7: 5f pop %edi
80101dd8: 5d pop %ebp
80101dd9: c3 ret
ip = iget(ROOTDEV, ROOTINO);
80101dda: ba 01 00 00 00 mov $0x1,%edx
80101ddf: b8 01 00 00 00 mov $0x1,%eax
80101de4: e8 17 f4 ff ff call 80101200 <iget>
80101de9: 89 c6 mov %eax,%esi
80101deb: e9 c3 fe ff ff jmp 80101cb3 <namex+0x43>
iunlock(ip);
80101df0: 89 34 24 mov %esi,(%esp)
80101df3: e8 88 f9 ff ff call 80101780 <iunlock>
}
80101df8: 83 c4 2c add $0x2c,%esp
return ip;
80101dfb: 89 f0 mov %esi,%eax
}
80101dfd: 5b pop %ebx
80101dfe: 5e pop %esi
80101dff: 5f pop %edi
80101e00: 5d pop %ebp
80101e01: c3 ret
iput(ip);
80101e02: 89 34 24 mov %esi,(%esp)
80101e05: e8 b6 f9 ff ff call 801017c0 <iput>
return 0;
80101e0a: 31 c0 xor %eax,%eax
80101e0c: eb aa jmp 80101db8 <namex+0x148>
80101e0e: 66 90 xchg %ax,%ax
80101e10 <dirlink>:
{
80101e10: 55 push %ebp
80101e11: 89 e5 mov %esp,%ebp
80101e13: 57 push %edi
80101e14: 56 push %esi
80101e15: 53 push %ebx
80101e16: 83 ec 2c sub $0x2c,%esp
80101e19: 8b 5d 08 mov 0x8(%ebp),%ebx
if((ip = dirlookup(dp, name, 0)) != 0){
80101e1c: 8b 45 0c mov 0xc(%ebp),%eax
80101e1f: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
80101e26: 00
80101e27: 89 1c 24 mov %ebx,(%esp)
80101e2a: 89 44 24 04 mov %eax,0x4(%esp)
80101e2e: e8 7d fd ff ff call 80101bb0 <dirlookup>
80101e33: 85 c0 test %eax,%eax
80101e35: 0f 85 8b 00 00 00 jne 80101ec6 <dirlink+0xb6>
for(off = 0; off < dp->size; off += sizeof(de)){
80101e3b: 8b 43 58 mov 0x58(%ebx),%eax
80101e3e: 31 ff xor %edi,%edi
80101e40: 8d 75 d8 lea -0x28(%ebp),%esi
80101e43: 85 c0 test %eax,%eax
80101e45: 75 13 jne 80101e5a <dirlink+0x4a>
80101e47: eb 35 jmp 80101e7e <dirlink+0x6e>
80101e49: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80101e50: 8d 57 10 lea 0x10(%edi),%edx
80101e53: 39 53 58 cmp %edx,0x58(%ebx)
80101e56: 89 d7 mov %edx,%edi
80101e58: 76 24 jbe 80101e7e <dirlink+0x6e>
if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
80101e5a: c7 44 24 0c 10 00 00 movl $0x10,0xc(%esp)
80101e61: 00
80101e62: 89 7c 24 08 mov %edi,0x8(%esp)
80101e66: 89 74 24 04 mov %esi,0x4(%esp)
80101e6a: 89 1c 24 mov %ebx,(%esp)
80101e6d: e8 de fa ff ff call 80101950 <readi>
80101e72: 83 f8 10 cmp $0x10,%eax
80101e75: 75 5e jne 80101ed5 <dirlink+0xc5>
if(de.inum == 0)
80101e77: 66 83 7d d8 00 cmpw $0x0,-0x28(%ebp)
80101e7c: 75 d2 jne 80101e50 <dirlink+0x40>
strncpy(de.name, name, DIRSIZ);
80101e7e: 8b 45 0c mov 0xc(%ebp),%eax
80101e81: c7 44 24 08 0e 00 00 movl $0xe,0x8(%esp)
80101e88: 00
80101e89: 89 44 24 04 mov %eax,0x4(%esp)
80101e8d: 8d 45 da lea -0x26(%ebp),%eax
80101e90: 89 04 24 mov %eax,(%esp)
80101e93: e8 68 25 00 00 call 80104400 <strncpy>
de.inum = inum;
80101e98: 8b 45 10 mov 0x10(%ebp),%eax
if(writei(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
80101e9b: c7 44 24 0c 10 00 00 movl $0x10,0xc(%esp)
80101ea2: 00
80101ea3: 89 7c 24 08 mov %edi,0x8(%esp)
80101ea7: 89 74 24 04 mov %esi,0x4(%esp)
80101eab: 89 1c 24 mov %ebx,(%esp)
de.inum = inum;
80101eae: 66 89 45 d8 mov %ax,-0x28(%ebp)
if(writei(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
80101eb2: e8 99 fb ff ff call 80101a50 <writei>
80101eb7: 83 f8 10 cmp $0x10,%eax
80101eba: 75 25 jne 80101ee1 <dirlink+0xd1>
return 0;
80101ebc: 31 c0 xor %eax,%eax
}
80101ebe: 83 c4 2c add $0x2c,%esp
80101ec1: 5b pop %ebx
80101ec2: 5e pop %esi
80101ec3: 5f pop %edi
80101ec4: 5d pop %ebp
80101ec5: c3 ret
iput(ip);
80101ec6: 89 04 24 mov %eax,(%esp)
80101ec9: e8 f2 f8 ff ff call 801017c0 <iput>
return -1;
80101ece: b8 ff ff ff ff mov $0xffffffff,%eax
80101ed3: eb e9 jmp 80101ebe <dirlink+0xae>
panic("dirlink read");
80101ed5: c7 04 24 88 6f 10 80 movl $0x80106f88,(%esp)
80101edc: e8 7f e4 ff ff call 80100360 <panic>
panic("dirlink");
80101ee1: c7 04 24 86 75 10 80 movl $0x80107586,(%esp)
80101ee8: e8 73 e4 ff ff call 80100360 <panic>
80101eed: 8d 76 00 lea 0x0(%esi),%esi
80101ef0 <namei>:
struct inode*
namei(char *path)
{
80101ef0: 55 push %ebp
char name[DIRSIZ];
return namex(path, 0, name);
80101ef1: 31 d2 xor %edx,%edx
{
80101ef3: 89 e5 mov %esp,%ebp
80101ef5: 83 ec 18 sub $0x18,%esp
return namex(path, 0, name);
80101ef8: 8b 45 08 mov 0x8(%ebp),%eax
80101efb: 8d 4d ea lea -0x16(%ebp),%ecx
80101efe: e8 6d fd ff ff call 80101c70 <namex>
}
80101f03: c9 leave
80101f04: c3 ret
80101f05: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80101f09: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101f10 <nameiparent>:
struct inode*
nameiparent(char *path, char *name)
{
80101f10: 55 push %ebp
return namex(path, 1, name);
80101f11: ba 01 00 00 00 mov $0x1,%edx
{
80101f16: 89 e5 mov %esp,%ebp
return namex(path, 1, name);
80101f18: 8b 4d 0c mov 0xc(%ebp),%ecx
80101f1b: 8b 45 08 mov 0x8(%ebp),%eax
}
80101f1e: 5d pop %ebp
return namex(path, 1, name);
80101f1f: e9 4c fd ff ff jmp 80101c70 <namex>
80101f24: 66 90 xchg %ax,%ax
80101f26: 66 90 xchg %ax,%ax
80101f28: 66 90 xchg %ax,%ax
80101f2a: 66 90 xchg %ax,%ax
80101f2c: 66 90 xchg %ax,%ax
80101f2e: 66 90 xchg %ax,%ax
80101f30 <idestart>:
}
// Start the request for b. Caller must hold idelock.
static void
idestart(struct buf *b)
{
80101f30: 55 push %ebp
80101f31: 89 e5 mov %esp,%ebp
80101f33: 56 push %esi
80101f34: 89 c6 mov %eax,%esi
80101f36: 53 push %ebx
80101f37: 83 ec 10 sub $0x10,%esp
if(b == 0)
80101f3a: 85 c0 test %eax,%eax
80101f3c: 0f 84 99 00 00 00 je 80101fdb <idestart+0xab>
panic("idestart");
if(b->blockno >= FSSIZE)
80101f42: 8b 48 08 mov 0x8(%eax),%ecx
80101f45: 81 f9 e7 03 00 00 cmp $0x3e7,%ecx
80101f4b: 0f 87 7e 00 00 00 ja 80101fcf <idestart+0x9f>
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80101f51: ba f7 01 00 00 mov $0x1f7,%edx
80101f56: 66 90 xchg %ax,%ax
80101f58: ec in (%dx),%al
while(((r = inb(0x1f7)) & (IDE_BSY|IDE_DRDY)) != IDE_DRDY)
80101f59: 83 e0 c0 and $0xffffffc0,%eax
80101f5c: 3c 40 cmp $0x40,%al
80101f5e: 75 f8 jne 80101f58 <idestart+0x28>
asm volatile("out %0,%1" : : "a" (data), "d" (port));
80101f60: 31 db xor %ebx,%ebx
80101f62: ba f6 03 00 00 mov $0x3f6,%edx
80101f67: 89 d8 mov %ebx,%eax
80101f69: ee out %al,(%dx)
80101f6a: ba f2 01 00 00 mov $0x1f2,%edx
80101f6f: b8 01 00 00 00 mov $0x1,%eax
80101f74: ee out %al,(%dx)
80101f75: 0f b6 c1 movzbl %cl,%eax
80101f78: b2 f3 mov $0xf3,%dl
80101f7a: ee out %al,(%dx)
idewait(0);
outb(0x3f6, 0); // generate interrupt
outb(0x1f2, sector_per_block); // number of sectors
outb(0x1f3, sector & 0xff);
outb(0x1f4, (sector >> 8) & 0xff);
80101f7b: 89 c8 mov %ecx,%eax
80101f7d: b2 f4 mov $0xf4,%dl
80101f7f: c1 f8 08 sar $0x8,%eax
80101f82: ee out %al,(%dx)
80101f83: b2 f5 mov $0xf5,%dl
80101f85: 89 d8 mov %ebx,%eax
80101f87: ee out %al,(%dx)
outb(0x1f5, (sector >> 16) & 0xff);
outb(0x1f6, 0xe0 | ((b->dev&1)<<4) | ((sector>>24)&0x0f));
80101f88: 0f b6 46 04 movzbl 0x4(%esi),%eax
80101f8c: b2 f6 mov $0xf6,%dl
80101f8e: 83 e0 01 and $0x1,%eax
80101f91: c1 e0 04 shl $0x4,%eax
80101f94: 83 c8 e0 or $0xffffffe0,%eax
80101f97: ee out %al,(%dx)
if(b->flags & B_DIRTY){
80101f98: f6 06 04 testb $0x4,(%esi)
80101f9b: 75 13 jne 80101fb0 <idestart+0x80>
80101f9d: ba f7 01 00 00 mov $0x1f7,%edx
80101fa2: b8 20 00 00 00 mov $0x20,%eax
80101fa7: ee out %al,(%dx)
outb(0x1f7, write_cmd);
outsl(0x1f0, b->data, BSIZE/4);
} else {
outb(0x1f7, read_cmd);
}
}
80101fa8: 83 c4 10 add $0x10,%esp
80101fab: 5b pop %ebx
80101fac: 5e pop %esi
80101fad: 5d pop %ebp
80101fae: c3 ret
80101faf: 90 nop
80101fb0: b2 f7 mov $0xf7,%dl
80101fb2: b8 30 00 00 00 mov $0x30,%eax
80101fb7: ee out %al,(%dx)
asm volatile("cld; rep outsl" :
80101fb8: b9 80 00 00 00 mov $0x80,%ecx
outsl(0x1f0, b->data, BSIZE/4);
80101fbd: 83 c6 5c add $0x5c,%esi
80101fc0: ba f0 01 00 00 mov $0x1f0,%edx
80101fc5: fc cld
80101fc6: f3 6f rep outsl %ds:(%esi),(%dx)
}
80101fc8: 83 c4 10 add $0x10,%esp
80101fcb: 5b pop %ebx
80101fcc: 5e pop %esi
80101fcd: 5d pop %ebp
80101fce: c3 ret
panic("incorrect blockno");
80101fcf: c7 04 24 f4 6f 10 80 movl $0x80106ff4,(%esp)
80101fd6: e8 85 e3 ff ff call 80100360 <panic>
panic("idestart");
80101fdb: c7 04 24 eb 6f 10 80 movl $0x80106feb,(%esp)
80101fe2: e8 79 e3 ff ff call 80100360 <panic>
80101fe7: 89 f6 mov %esi,%esi
80101fe9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101ff0 <ideinit>:
{
80101ff0: 55 push %ebp
80101ff1: 89 e5 mov %esp,%ebp
80101ff3: 83 ec 18 sub $0x18,%esp
initlock(&idelock, "ide");
80101ff6: c7 44 24 04 06 70 10 movl $0x80107006,0x4(%esp)
80101ffd: 80
80101ffe: c7 04 24 80 a5 10 80 movl $0x8010a580,(%esp)
80102005: e8 36 20 00 00 call 80104040 <initlock>
ioapicenable(IRQ_IDE, ncpu - 1);
8010200a: a1 00 2d 11 80 mov 0x80112d00,%eax
8010200f: c7 04 24 0e 00 00 00 movl $0xe,(%esp)
80102016: 83 e8 01 sub $0x1,%eax
80102019: 89 44 24 04 mov %eax,0x4(%esp)
8010201d: e8 7e 02 00 00 call 801022a0 <ioapicenable>
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102022: ba f7 01 00 00 mov $0x1f7,%edx
80102027: 90 nop
80102028: ec in (%dx),%al
while(((r = inb(0x1f7)) & (IDE_BSY|IDE_DRDY)) != IDE_DRDY)
80102029: 83 e0 c0 and $0xffffffc0,%eax
8010202c: 3c 40 cmp $0x40,%al
8010202e: 75 f8 jne 80102028 <ideinit+0x38>
asm volatile("out %0,%1" : : "a" (data), "d" (port));
80102030: ba f6 01 00 00 mov $0x1f6,%edx
80102035: b8 f0 ff ff ff mov $0xfffffff0,%eax
8010203a: ee out %al,(%dx)
8010203b: b9 e8 03 00 00 mov $0x3e8,%ecx
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102040: b2 f7 mov $0xf7,%dl
80102042: eb 09 jmp 8010204d <ideinit+0x5d>
80102044: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for(i=0; i<1000; i++){
80102048: 83 e9 01 sub $0x1,%ecx
8010204b: 74 0f je 8010205c <ideinit+0x6c>
8010204d: ec in (%dx),%al
if(inb(0x1f7) != 0){
8010204e: 84 c0 test %al,%al
80102050: 74 f6 je 80102048 <ideinit+0x58>
havedisk1 = 1;
80102052: c7 05 60 a5 10 80 01 movl $0x1,0x8010a560
80102059: 00 00 00
asm volatile("out %0,%1" : : "a" (data), "d" (port));
8010205c: ba f6 01 00 00 mov $0x1f6,%edx
80102061: b8 e0 ff ff ff mov $0xffffffe0,%eax
80102066: ee out %al,(%dx)
}
80102067: c9 leave
80102068: c3 ret
80102069: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80102070 <ideintr>:
// Interrupt handler.
void
ideintr(void)
{
80102070: 55 push %ebp
80102071: 89 e5 mov %esp,%ebp
80102073: 57 push %edi
80102074: 56 push %esi
80102075: 53 push %ebx
80102076: 83 ec 1c sub $0x1c,%esp
struct buf *b;
// First queued buffer is the active request.
acquire(&idelock);
80102079: c7 04 24 80 a5 10 80 movl $0x8010a580,(%esp)
80102080: e8 ab 20 00 00 call 80104130 <acquire>
if((b = idequeue) == 0){
80102085: 8b 1d 64 a5 10 80 mov 0x8010a564,%ebx
8010208b: 85 db test %ebx,%ebx
8010208d: 74 30 je 801020bf <ideintr+0x4f>
release(&idelock);
return;
}
idequeue = b->qnext;
8010208f: 8b 43 58 mov 0x58(%ebx),%eax
80102092: a3 64 a5 10 80 mov %eax,0x8010a564
// Read data if needed.
if(!(b->flags & B_DIRTY) && idewait(1) >= 0)
80102097: 8b 33 mov (%ebx),%esi
80102099: f7 c6 04 00 00 00 test $0x4,%esi
8010209f: 74 37 je 801020d8 <ideintr+0x68>
insl(0x1f0, b->data, BSIZE/4);
// Wake process waiting for this buf.
b->flags |= B_VALID;
b->flags &= ~B_DIRTY;
801020a1: 83 e6 fb and $0xfffffffb,%esi
801020a4: 83 ce 02 or $0x2,%esi
801020a7: 89 33 mov %esi,(%ebx)
wakeup(b);
801020a9: 89 1c 24 mov %ebx,(%esp)
801020ac: e8 cf 1c 00 00 call 80103d80 <wakeup>
// Start disk on next buf in queue.
if(idequeue != 0)
801020b1: a1 64 a5 10 80 mov 0x8010a564,%eax
801020b6: 85 c0 test %eax,%eax
801020b8: 74 05 je 801020bf <ideintr+0x4f>
idestart(idequeue);
801020ba: e8 71 fe ff ff call 80101f30 <idestart>
release(&idelock);
801020bf: c7 04 24 80 a5 10 80 movl $0x8010a580,(%esp)
801020c6: e8 55 21 00 00 call 80104220 <release>
release(&idelock);
}
801020cb: 83 c4 1c add $0x1c,%esp
801020ce: 5b pop %ebx
801020cf: 5e pop %esi
801020d0: 5f pop %edi
801020d1: 5d pop %ebp
801020d2: c3 ret
801020d3: 90 nop
801020d4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
801020d8: ba f7 01 00 00 mov $0x1f7,%edx
801020dd: 8d 76 00 lea 0x0(%esi),%esi
801020e0: ec in (%dx),%al
while(((r = inb(0x1f7)) & (IDE_BSY|IDE_DRDY)) != IDE_DRDY)
801020e1: 89 c1 mov %eax,%ecx
801020e3: 83 e1 c0 and $0xffffffc0,%ecx
801020e6: 80 f9 40 cmp $0x40,%cl
801020e9: 75 f5 jne 801020e0 <ideintr+0x70>
if(checkerr && (r & (IDE_DF|IDE_ERR)) != 0)
801020eb: a8 21 test $0x21,%al
801020ed: 75 b2 jne 801020a1 <ideintr+0x31>
insl(0x1f0, b->data, BSIZE/4);
801020ef: 8d 7b 5c lea 0x5c(%ebx),%edi
asm volatile("cld; rep insl" :
801020f2: b9 80 00 00 00 mov $0x80,%ecx
801020f7: ba f0 01 00 00 mov $0x1f0,%edx
801020fc: fc cld
801020fd: f3 6d rep insl (%dx),%es:(%edi)
801020ff: 8b 33 mov (%ebx),%esi
80102101: eb 9e jmp 801020a1 <ideintr+0x31>
80102103: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80102109: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80102110 <iderw>:
// Sync buf with disk.
// If B_DIRTY is set, write buf to disk, clear B_DIRTY, set B_VALID.
// Else if B_VALID is not set, read buf from disk, set B_VALID.
void
iderw(struct buf *b)
{
80102110: 55 push %ebp
80102111: 89 e5 mov %esp,%ebp
80102113: 53 push %ebx
80102114: 83 ec 14 sub $0x14,%esp
80102117: 8b 5d 08 mov 0x8(%ebp),%ebx
struct buf **pp;
if(!holdingsleep(&b->lock))
8010211a: 8d 43 0c lea 0xc(%ebx),%eax
8010211d: 89 04 24 mov %eax,(%esp)
80102120: e8 eb 1e 00 00 call 80104010 <holdingsleep>
80102125: 85 c0 test %eax,%eax
80102127: 0f 84 9e 00 00 00 je 801021cb <iderw+0xbb>
panic("iderw: buf not locked");
if((b->flags & (B_VALID|B_DIRTY)) == B_VALID)
8010212d: 8b 03 mov (%ebx),%eax
8010212f: 83 e0 06 and $0x6,%eax
80102132: 83 f8 02 cmp $0x2,%eax
80102135: 0f 84 a8 00 00 00 je 801021e3 <iderw+0xd3>
panic("iderw: nothing to do");
if(b->dev != 0 && !havedisk1)
8010213b: 8b 53 04 mov 0x4(%ebx),%edx
8010213e: 85 d2 test %edx,%edx
80102140: 74 0d je 8010214f <iderw+0x3f>
80102142: a1 60 a5 10 80 mov 0x8010a560,%eax
80102147: 85 c0 test %eax,%eax
80102149: 0f 84 88 00 00 00 je 801021d7 <iderw+0xc7>
panic("iderw: ide disk 1 not present");
acquire(&idelock); //DOC:acquire-lock
8010214f: c7 04 24 80 a5 10 80 movl $0x8010a580,(%esp)
80102156: e8 d5 1f 00 00 call 80104130 <acquire>
// Append b to idequeue.
b->qnext = 0;
for(pp=&idequeue; *pp; pp=&(*pp)->qnext) //DOC:insert-queue
8010215b: a1 64 a5 10 80 mov 0x8010a564,%eax
b->qnext = 0;
80102160: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx)
for(pp=&idequeue; *pp; pp=&(*pp)->qnext) //DOC:insert-queue
80102167: 85 c0 test %eax,%eax
80102169: 75 07 jne 80102172 <iderw+0x62>
8010216b: eb 4e jmp 801021bb <iderw+0xab>
8010216d: 8d 76 00 lea 0x0(%esi),%esi
80102170: 89 d0 mov %edx,%eax
80102172: 8b 50 58 mov 0x58(%eax),%edx
80102175: 85 d2 test %edx,%edx
80102177: 75 f7 jne 80102170 <iderw+0x60>
80102179: 83 c0 58 add $0x58,%eax
;
*pp = b;
8010217c: 89 18 mov %ebx,(%eax)
// Start disk if necessary.
if(idequeue == b)
8010217e: 39 1d 64 a5 10 80 cmp %ebx,0x8010a564
80102184: 74 3c je 801021c2 <iderw+0xb2>
idestart(b);
// Wait for request to finish.
while((b->flags & (B_VALID|B_DIRTY)) != B_VALID){
80102186: 8b 03 mov (%ebx),%eax
80102188: 83 e0 06 and $0x6,%eax
8010218b: 83 f8 02 cmp $0x2,%eax
8010218e: 74 1a je 801021aa <iderw+0x9a>
sleep(b, &idelock);
80102190: c7 44 24 04 80 a5 10 movl $0x8010a580,0x4(%esp)
80102197: 80
80102198: 89 1c 24 mov %ebx,(%esp)
8010219b: e8 50 1a 00 00 call 80103bf0 <sleep>
while((b->flags & (B_VALID|B_DIRTY)) != B_VALID){
801021a0: 8b 13 mov (%ebx),%edx
801021a2: 83 e2 06 and $0x6,%edx
801021a5: 83 fa 02 cmp $0x2,%edx
801021a8: 75 e6 jne 80102190 <iderw+0x80>
}
release(&idelock);
801021aa: c7 45 08 80 a5 10 80 movl $0x8010a580,0x8(%ebp)
}
801021b1: 83 c4 14 add $0x14,%esp
801021b4: 5b pop %ebx
801021b5: 5d pop %ebp
release(&idelock);
801021b6: e9 65 20 00 00 jmp 80104220 <release>
for(pp=&idequeue; *pp; pp=&(*pp)->qnext) //DOC:insert-queue
801021bb: b8 64 a5 10 80 mov $0x8010a564,%eax
801021c0: eb ba jmp 8010217c <iderw+0x6c>
idestart(b);
801021c2: 89 d8 mov %ebx,%eax
801021c4: e8 67 fd ff ff call 80101f30 <idestart>
801021c9: eb bb jmp 80102186 <iderw+0x76>
panic("iderw: buf not locked");
801021cb: c7 04 24 0a 70 10 80 movl $0x8010700a,(%esp)
801021d2: e8 89 e1 ff ff call 80100360 <panic>
panic("iderw: ide disk 1 not present");
801021d7: c7 04 24 35 70 10 80 movl $0x80107035,(%esp)
801021de: e8 7d e1 ff ff call 80100360 <panic>
panic("iderw: nothing to do");
801021e3: c7 04 24 20 70 10 80 movl $0x80107020,(%esp)
801021ea: e8 71 e1 ff ff call 80100360 <panic>
801021ef: 90 nop
801021f0 <ioapicinit>:
ioapic->data = data;
}
void
ioapicinit(void)
{
801021f0: 55 push %ebp
801021f1: 89 e5 mov %esp,%ebp
801021f3: 56 push %esi
801021f4: 53 push %ebx
801021f5: 83 ec 10 sub $0x10,%esp
int i, id, maxintr;
ioapic = (volatile struct ioapic*)IOAPIC;
801021f8: c7 05 34 26 11 80 00 movl $0xfec00000,0x80112634
801021ff: 00 c0 fe
ioapic->reg = reg;
80102202: c7 05 00 00 c0 fe 01 movl $0x1,0xfec00000
80102209: 00 00 00
return ioapic->data;
8010220c: 8b 15 34 26 11 80 mov 0x80112634,%edx
80102212: 8b 42 10 mov 0x10(%edx),%eax
ioapic->reg = reg;
80102215: c7 02 00 00 00 00 movl $0x0,(%edx)
return ioapic->data;
8010221b: 8b 1d 34 26 11 80 mov 0x80112634,%ebx
maxintr = (ioapicread(REG_VER) >> 16) & 0xFF;
id = ioapicread(REG_ID) >> 24;
if(id != ioapicid)
80102221: 0f b6 15 60 27 11 80 movzbl 0x80112760,%edx
maxintr = (ioapicread(REG_VER) >> 16) & 0xFF;
80102228: c1 e8 10 shr $0x10,%eax
8010222b: 0f b6 f0 movzbl %al,%esi
return ioapic->data;
8010222e: 8b 43 10 mov 0x10(%ebx),%eax
id = ioapicread(REG_ID) >> 24;
80102231: c1 e8 18 shr $0x18,%eax
if(id != ioapicid)
80102234: 39 c2 cmp %eax,%edx
80102236: 74 12 je 8010224a <ioapicinit+0x5a>
cprintf("ioapicinit: id isn't equal to ioapicid; not a MP\n");
80102238: c7 04 24 54 70 10 80 movl $0x80107054,(%esp)
8010223f: e8 0c e4 ff ff call 80100650 <cprintf>
80102244: 8b 1d 34 26 11 80 mov 0x80112634,%ebx
8010224a: ba 10 00 00 00 mov $0x10,%edx
8010224f: 31 c0 xor %eax,%eax
80102251: eb 07 jmp 8010225a <ioapicinit+0x6a>
80102253: 90 nop
80102254: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80102258: 89 cb mov %ecx,%ebx
ioapic->reg = reg;
8010225a: 89 13 mov %edx,(%ebx)
ioapic->data = data;
8010225c: 8b 1d 34 26 11 80 mov 0x80112634,%ebx
80102262: 8d 48 20 lea 0x20(%eax),%ecx
// Mark all interrupts edge-triggered, active high, disabled,
// and not routed to any CPUs.
for(i = 0; i <= maxintr; i++){
ioapicwrite(REG_TABLE+2*i, INT_DISABLED | (T_IRQ0 + i));
80102265: 81 c9 00 00 01 00 or $0x10000,%ecx
for(i = 0; i <= maxintr; i++){
8010226b: 83 c0 01 add $0x1,%eax
ioapic->data = data;
8010226e: 89 4b 10 mov %ecx,0x10(%ebx)
80102271: 8d 4a 01 lea 0x1(%edx),%ecx
80102274: 83 c2 02 add $0x2,%edx
ioapic->reg = reg;
80102277: 89 0b mov %ecx,(%ebx)
ioapic->data = data;
80102279: 8b 0d 34 26 11 80 mov 0x80112634,%ecx
for(i = 0; i <= maxintr; i++){
8010227f: 39 c6 cmp %eax,%esi
ioapic->data = data;
80102281: c7 41 10 00 00 00 00 movl $0x0,0x10(%ecx)
for(i = 0; i <= maxintr; i++){
80102288: 7d ce jge 80102258 <ioapicinit+0x68>
ioapicwrite(REG_TABLE+2*i+1, 0);
}
}
8010228a: 83 c4 10 add $0x10,%esp
8010228d: 5b pop %ebx
8010228e: 5e pop %esi
8010228f: 5d pop %ebp
80102290: c3 ret
80102291: eb 0d jmp 801022a0 <ioapicenable>
80102293: 90 nop
80102294: 90 nop
80102295: 90 nop
80102296: 90 nop
80102297: 90 nop
80102298: 90 nop
80102299: 90 nop
8010229a: 90 nop
8010229b: 90 nop
8010229c: 90 nop
8010229d: 90 nop
8010229e: 90 nop
8010229f: 90 nop
801022a0 <ioapicenable>:
void
ioapicenable(int irq, int cpunum)
{
801022a0: 55 push %ebp
801022a1: 89 e5 mov %esp,%ebp
801022a3: 8b 55 08 mov 0x8(%ebp),%edx
801022a6: 53 push %ebx
801022a7: 8b 45 0c mov 0xc(%ebp),%eax
// Mark interrupt edge-triggered, active high,
// enabled, and routed to the given cpunum,
// which happens to be that cpu's APIC ID.
ioapicwrite(REG_TABLE+2*irq, T_IRQ0 + irq);
801022aa: 8d 5a 20 lea 0x20(%edx),%ebx
801022ad: 8d 4c 12 10 lea 0x10(%edx,%edx,1),%ecx
ioapic->reg = reg;
801022b1: 8b 15 34 26 11 80 mov 0x80112634,%edx
ioapicwrite(REG_TABLE+2*irq+1, cpunum << 24);
801022b7: c1 e0 18 shl $0x18,%eax
ioapic->reg = reg;
801022ba: 89 0a mov %ecx,(%edx)
ioapic->data = data;
801022bc: 8b 15 34 26 11 80 mov 0x80112634,%edx
ioapicwrite(REG_TABLE+2*irq+1, cpunum << 24);
801022c2: 83 c1 01 add $0x1,%ecx
ioapic->data = data;
801022c5: 89 5a 10 mov %ebx,0x10(%edx)
ioapic->reg = reg;
801022c8: 89 0a mov %ecx,(%edx)
ioapic->data = data;
801022ca: 8b 15 34 26 11 80 mov 0x80112634,%edx
801022d0: 89 42 10 mov %eax,0x10(%edx)
}
801022d3: 5b pop %ebx
801022d4: 5d pop %ebp
801022d5: c3 ret
801022d6: 66 90 xchg %ax,%ax
801022d8: 66 90 xchg %ax,%ax
801022da: 66 90 xchg %ax,%ax
801022dc: 66 90 xchg %ax,%ax
801022de: 66 90 xchg %ax,%ax
801022e0 <kfree>:
// which normally should have been returned by a
// call to kalloc(). (The exception is when
// initializing the allocator; see kinit above.)
void
kfree(char *v)
{
801022e0: 55 push %ebp
801022e1: 89 e5 mov %esp,%ebp
801022e3: 53 push %ebx
801022e4: 83 ec 14 sub $0x14,%esp
801022e7: 8b 5d 08 mov 0x8(%ebp),%ebx
struct run *r;
if((uint)v % PGSIZE || v < end || V2P(v) >= PHYSTOP)
801022ea: f7 c3 ff 0f 00 00 test $0xfff,%ebx
801022f0: 75 7c jne 8010236e <kfree+0x8e>
801022f2: 81 fb f4 58 11 80 cmp $0x801158f4,%ebx
801022f8: 72 74 jb 8010236e <kfree+0x8e>
801022fa: 8d 83 00 00 00 80 lea -0x80000000(%ebx),%eax
80102300: 3d ff ff ff 0d cmp $0xdffffff,%eax
80102305: 77 67 ja 8010236e <kfree+0x8e>
panic("kfree");
// Fill with junk to catch dangling refs.
memset(v, 1, PGSIZE);
80102307: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
8010230e: 00
8010230f: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
80102316: 00
80102317: 89 1c 24 mov %ebx,(%esp)
8010231a: e8 51 1f 00 00 call 80104270 <memset>
if(kmem.use_lock)
8010231f: 8b 15 74 26 11 80 mov 0x80112674,%edx
80102325: 85 d2 test %edx,%edx
80102327: 75 37 jne 80102360 <kfree+0x80>
acquire(&kmem.lock);
r = (struct run*)v;
r->next = kmem.freelist;
80102329: a1 78 26 11 80 mov 0x80112678,%eax
8010232e: 89 03 mov %eax,(%ebx)
kmem.freelist = r;
if(kmem.use_lock)
80102330: a1 74 26 11 80 mov 0x80112674,%eax
kmem.freelist = r;
80102335: 89 1d 78 26 11 80 mov %ebx,0x80112678
if(kmem.use_lock)
8010233b: 85 c0 test %eax,%eax
8010233d: 75 09 jne 80102348 <kfree+0x68>
release(&kmem.lock);
}
8010233f: 83 c4 14 add $0x14,%esp
80102342: 5b pop %ebx
80102343: 5d pop %ebp
80102344: c3 ret
80102345: 8d 76 00 lea 0x0(%esi),%esi
release(&kmem.lock);
80102348: c7 45 08 40 26 11 80 movl $0x80112640,0x8(%ebp)
}
8010234f: 83 c4 14 add $0x14,%esp
80102352: 5b pop %ebx
80102353: 5d pop %ebp
release(&kmem.lock);
80102354: e9 c7 1e 00 00 jmp 80104220 <release>
80102359: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
acquire(&kmem.lock);
80102360: c7 04 24 40 26 11 80 movl $0x80112640,(%esp)
80102367: e8 c4 1d 00 00 call 80104130 <acquire>
8010236c: eb bb jmp 80102329 <kfree+0x49>
panic("kfree");
8010236e: c7 04 24 86 70 10 80 movl $0x80107086,(%esp)
80102375: e8 e6 df ff ff call 80100360 <panic>
8010237a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80102380 <freerange>:
{
80102380: 55 push %ebp
80102381: 89 e5 mov %esp,%ebp
80102383: 56 push %esi
80102384: 53 push %ebx
80102385: 83 ec 10 sub $0x10,%esp
p = (char*)PGROUNDUP((uint)vstart);
80102388: 8b 45 08 mov 0x8(%ebp),%eax
{
8010238b: 8b 75 0c mov 0xc(%ebp),%esi
p = (char*)PGROUNDUP((uint)vstart);
8010238e: 8d 90 ff 0f 00 00 lea 0xfff(%eax),%edx
80102394: 81 e2 00 f0 ff ff and $0xfffff000,%edx
for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
8010239a: 8d 9a 00 10 00 00 lea 0x1000(%edx),%ebx
801023a0: 39 de cmp %ebx,%esi
801023a2: 73 08 jae 801023ac <freerange+0x2c>
801023a4: eb 18 jmp 801023be <freerange+0x3e>
801023a6: 66 90 xchg %ax,%ax
801023a8: 89 da mov %ebx,%edx
801023aa: 89 c3 mov %eax,%ebx
kfree(p);
801023ac: 89 14 24 mov %edx,(%esp)
801023af: e8 2c ff ff ff call 801022e0 <kfree>
for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
801023b4: 8d 83 00 10 00 00 lea 0x1000(%ebx),%eax
801023ba: 39 f0 cmp %esi,%eax
801023bc: 76 ea jbe 801023a8 <freerange+0x28>
}
801023be: 83 c4 10 add $0x10,%esp
801023c1: 5b pop %ebx
801023c2: 5e pop %esi
801023c3: 5d pop %ebp
801023c4: c3 ret
801023c5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801023c9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801023d0 <kinit1>:
{
801023d0: 55 push %ebp
801023d1: 89 e5 mov %esp,%ebp
801023d3: 56 push %esi
801023d4: 53 push %ebx
801023d5: 83 ec 10 sub $0x10,%esp
801023d8: 8b 75 0c mov 0xc(%ebp),%esi
initlock(&kmem.lock, "kmem");
801023db: c7 44 24 04 8c 70 10 movl $0x8010708c,0x4(%esp)
801023e2: 80
801023e3: c7 04 24 40 26 11 80 movl $0x80112640,(%esp)
801023ea: e8 51 1c 00 00 call 80104040 <initlock>
p = (char*)PGROUNDUP((uint)vstart);
801023ef: 8b 45 08 mov 0x8(%ebp),%eax
kmem.use_lock = 0;
801023f2: c7 05 74 26 11 80 00 movl $0x0,0x80112674
801023f9: 00 00 00
p = (char*)PGROUNDUP((uint)vstart);
801023fc: 8d 90 ff 0f 00 00 lea 0xfff(%eax),%edx
80102402: 81 e2 00 f0 ff ff and $0xfffff000,%edx
for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
80102408: 8d 9a 00 10 00 00 lea 0x1000(%edx),%ebx
8010240e: 39 de cmp %ebx,%esi
80102410: 73 0a jae 8010241c <kinit1+0x4c>
80102412: eb 1a jmp 8010242e <kinit1+0x5e>
80102414: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80102418: 89 da mov %ebx,%edx
8010241a: 89 c3 mov %eax,%ebx
kfree(p);
8010241c: 89 14 24 mov %edx,(%esp)
8010241f: e8 bc fe ff ff call 801022e0 <kfree>
for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
80102424: 8d 83 00 10 00 00 lea 0x1000(%ebx),%eax
8010242a: 39 c6 cmp %eax,%esi
8010242c: 73 ea jae 80102418 <kinit1+0x48>
}
8010242e: 83 c4 10 add $0x10,%esp
80102431: 5b pop %ebx
80102432: 5e pop %esi
80102433: 5d pop %ebp
80102434: c3 ret
80102435: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80102439: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80102440 <kinit2>:
{
80102440: 55 push %ebp
80102441: 89 e5 mov %esp,%ebp
80102443: 56 push %esi
80102444: 53 push %ebx
80102445: 83 ec 10 sub $0x10,%esp
p = (char*)PGROUNDUP((uint)vstart);
80102448: 8b 45 08 mov 0x8(%ebp),%eax
{
8010244b: 8b 75 0c mov 0xc(%ebp),%esi
p = (char*)PGROUNDUP((uint)vstart);
8010244e: 8d 90 ff 0f 00 00 lea 0xfff(%eax),%edx
80102454: 81 e2 00 f0 ff ff and $0xfffff000,%edx
for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
8010245a: 8d 9a 00 10 00 00 lea 0x1000(%edx),%ebx
80102460: 39 de cmp %ebx,%esi
80102462: 73 08 jae 8010246c <kinit2+0x2c>
80102464: eb 18 jmp 8010247e <kinit2+0x3e>
80102466: 66 90 xchg %ax,%ax
80102468: 89 da mov %ebx,%edx
8010246a: 89 c3 mov %eax,%ebx
kfree(p);
8010246c: 89 14 24 mov %edx,(%esp)
8010246f: e8 6c fe ff ff call 801022e0 <kfree>
for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
80102474: 8d 83 00 10 00 00 lea 0x1000(%ebx),%eax
8010247a: 39 c6 cmp %eax,%esi
8010247c: 73 ea jae 80102468 <kinit2+0x28>
kmem.use_lock = 1;
8010247e: c7 05 74 26 11 80 01 movl $0x1,0x80112674
80102485: 00 00 00
}
80102488: 83 c4 10 add $0x10,%esp
8010248b: 5b pop %ebx
8010248c: 5e pop %esi
8010248d: 5d pop %ebp
8010248e: c3 ret
8010248f: 90 nop
80102490 <kalloc>:
// Allocate one 4096-byte page of physical memory.
// Returns a pointer that the kernel can use.
// Returns 0 if the memory cannot be allocated.
char*
kalloc(void)
{
80102490: 55 push %ebp
80102491: 89 e5 mov %esp,%ebp
80102493: 53 push %ebx
80102494: 83 ec 14 sub $0x14,%esp
struct run *r;
if(kmem.use_lock)
80102497: a1 74 26 11 80 mov 0x80112674,%eax
8010249c: 85 c0 test %eax,%eax
8010249e: 75 30 jne 801024d0 <kalloc+0x40>
acquire(&kmem.lock);
r = kmem.freelist;
801024a0: 8b 1d 78 26 11 80 mov 0x80112678,%ebx
if(r)
801024a6: 85 db test %ebx,%ebx
801024a8: 74 08 je 801024b2 <kalloc+0x22>
kmem.freelist = r->next;
801024aa: 8b 13 mov (%ebx),%edx
801024ac: 89 15 78 26 11 80 mov %edx,0x80112678
if(kmem.use_lock)
801024b2: 85 c0 test %eax,%eax
801024b4: 74 0c je 801024c2 <kalloc+0x32>
release(&kmem.lock);
801024b6: c7 04 24 40 26 11 80 movl $0x80112640,(%esp)
801024bd: e8 5e 1d 00 00 call 80104220 <release>
return (char*)r;
}
801024c2: 83 c4 14 add $0x14,%esp
801024c5: 89 d8 mov %ebx,%eax
801024c7: 5b pop %ebx
801024c8: 5d pop %ebp
801024c9: c3 ret
801024ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
acquire(&kmem.lock);
801024d0: c7 04 24 40 26 11 80 movl $0x80112640,(%esp)
801024d7: e8 54 1c 00 00 call 80104130 <acquire>
801024dc: a1 74 26 11 80 mov 0x80112674,%eax
801024e1: eb bd jmp 801024a0 <kalloc+0x10>
801024e3: 66 90 xchg %ax,%ax
801024e5: 66 90 xchg %ax,%ax
801024e7: 66 90 xchg %ax,%ax
801024e9: 66 90 xchg %ax,%ax
801024eb: 66 90 xchg %ax,%ax
801024ed: 66 90 xchg %ax,%ax
801024ef: 90 nop
801024f0 <kbdgetc>:
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
801024f0: ba 64 00 00 00 mov $0x64,%edx
801024f5: ec in (%dx),%al
normalmap, shiftmap, ctlmap, ctlmap
};
uint st, data, c;
st = inb(KBSTATP);
if((st & KBS_DIB) == 0)
801024f6: a8 01 test $0x1,%al
801024f8: 0f 84 ba 00 00 00 je 801025b8 <kbdgetc+0xc8>
801024fe: b2 60 mov $0x60,%dl
80102500: ec in (%dx),%al
return -1;
data = inb(KBDATAP);
80102501: 0f b6 c8 movzbl %al,%ecx
if(data == 0xE0){
80102504: 81 f9 e0 00 00 00 cmp $0xe0,%ecx
8010250a: 0f 84 88 00 00 00 je 80102598 <kbdgetc+0xa8>
shift |= E0ESC;
return 0;
} else if(data & 0x80){
80102510: 84 c0 test %al,%al
80102512: 79 2c jns 80102540 <kbdgetc+0x50>
// Key released
data = (shift & E0ESC ? data : data & 0x7F);
80102514: 8b 15 b4 a5 10 80 mov 0x8010a5b4,%edx
8010251a: f6 c2 40 test $0x40,%dl
8010251d: 75 05 jne 80102524 <kbdgetc+0x34>
8010251f: 89 c1 mov %eax,%ecx
80102521: 83 e1 7f and $0x7f,%ecx
shift &= ~(shiftcode[data] | E0ESC);
80102524: 0f b6 81 c0 71 10 80 movzbl -0x7fef8e40(%ecx),%eax
8010252b: 83 c8 40 or $0x40,%eax
8010252e: 0f b6 c0 movzbl %al,%eax
80102531: f7 d0 not %eax
80102533: 21 d0 and %edx,%eax
80102535: a3 b4 a5 10 80 mov %eax,0x8010a5b4
return 0;
8010253a: 31 c0 xor %eax,%eax
8010253c: c3 ret
8010253d: 8d 76 00 lea 0x0(%esi),%esi
{
80102540: 55 push %ebp
80102541: 89 e5 mov %esp,%ebp
80102543: 53 push %ebx
80102544: 8b 1d b4 a5 10 80 mov 0x8010a5b4,%ebx
} else if(shift & E0ESC){
8010254a: f6 c3 40 test $0x40,%bl
8010254d: 74 09 je 80102558 <kbdgetc+0x68>
// Last character was an E0 escape; or with 0x80
data |= 0x80;
8010254f: 83 c8 80 or $0xffffff80,%eax
shift &= ~E0ESC;
80102552: 83 e3 bf and $0xffffffbf,%ebx
data |= 0x80;
80102555: 0f b6 c8 movzbl %al,%ecx
}
shift |= shiftcode[data];
80102558: 0f b6 91 c0 71 10 80 movzbl -0x7fef8e40(%ecx),%edx
shift ^= togglecode[data];
8010255f: 0f b6 81 c0 70 10 80 movzbl -0x7fef8f40(%ecx),%eax
shift |= shiftcode[data];
80102566: 09 da or %ebx,%edx
shift ^= togglecode[data];
80102568: 31 c2 xor %eax,%edx
c = charcode[shift & (CTL | SHIFT)][data];
8010256a: 89 d0 mov %edx,%eax
8010256c: 83 e0 03 and $0x3,%eax
8010256f: 8b 04 85 a0 70 10 80 mov -0x7fef8f60(,%eax,4),%eax
shift ^= togglecode[data];
80102576: 89 15 b4 a5 10 80 mov %edx,0x8010a5b4
if(shift & CAPSLOCK){
8010257c: 83 e2 08 and $0x8,%edx
c = charcode[shift & (CTL | SHIFT)][data];
8010257f: 0f b6 04 08 movzbl (%eax,%ecx,1),%eax
if(shift & CAPSLOCK){
80102583: 74 0b je 80102590 <kbdgetc+0xa0>
if('a' <= c && c <= 'z')
80102585: 8d 50 9f lea -0x61(%eax),%edx
80102588: 83 fa 19 cmp $0x19,%edx
8010258b: 77 1b ja 801025a8 <kbdgetc+0xb8>
c += 'A' - 'a';
8010258d: 83 e8 20 sub $0x20,%eax
else if('A' <= c && c <= 'Z')
c += 'a' - 'A';
}
return c;
}
80102590: 5b pop %ebx
80102591: 5d pop %ebp
80102592: c3 ret
80102593: 90 nop
80102594: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
shift |= E0ESC;
80102598: 83 0d b4 a5 10 80 40 orl $0x40,0x8010a5b4
return 0;
8010259f: 31 c0 xor %eax,%eax
801025a1: c3 ret
801025a2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
else if('A' <= c && c <= 'Z')
801025a8: 8d 48 bf lea -0x41(%eax),%ecx
c += 'a' - 'A';
801025ab: 8d 50 20 lea 0x20(%eax),%edx
801025ae: 83 f9 19 cmp $0x19,%ecx
801025b1: 0f 46 c2 cmovbe %edx,%eax
return c;
801025b4: eb da jmp 80102590 <kbdgetc+0xa0>
801025b6: 66 90 xchg %ax,%ax
return -1;
801025b8: b8 ff ff ff ff mov $0xffffffff,%eax
801025bd: c3 ret
801025be: 66 90 xchg %ax,%ax
801025c0 <kbdintr>:
void
kbdintr(void)
{
801025c0: 55 push %ebp
801025c1: 89 e5 mov %esp,%ebp
801025c3: 83 ec 18 sub $0x18,%esp
consoleintr(kbdgetc);
801025c6: c7 04 24 f0 24 10 80 movl $0x801024f0,(%esp)
801025cd: e8 de e1 ff ff call 801007b0 <consoleintr>
}
801025d2: c9 leave
801025d3: c3 ret
801025d4: 66 90 xchg %ax,%ax
801025d6: 66 90 xchg %ax,%ax
801025d8: 66 90 xchg %ax,%ax
801025da: 66 90 xchg %ax,%ax
801025dc: 66 90 xchg %ax,%ax
801025de: 66 90 xchg %ax,%ax
801025e0 <fill_rtcdate>:
return inb(CMOS_RETURN);
}
static void fill_rtcdate(struct rtcdate *r)
{
801025e0: 55 push %ebp
801025e1: 89 c1 mov %eax,%ecx
801025e3: 89 e5 mov %esp,%ebp
asm volatile("out %0,%1" : : "a" (data), "d" (port));
801025e5: ba 70 00 00 00 mov $0x70,%edx
801025ea: 53 push %ebx
801025eb: 31 c0 xor %eax,%eax
801025ed: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
801025ee: bb 71 00 00 00 mov $0x71,%ebx
801025f3: 89 da mov %ebx,%edx
801025f5: ec in (%dx),%al
return inb(CMOS_RETURN);
801025f6: 0f b6 c0 movzbl %al,%eax
asm volatile("out %0,%1" : : "a" (data), "d" (port));
801025f9: b2 70 mov $0x70,%dl
801025fb: 89 01 mov %eax,(%ecx)
801025fd: b8 02 00 00 00 mov $0x2,%eax
80102602: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102603: 89 da mov %ebx,%edx
80102605: ec in (%dx),%al
80102606: 0f b6 c0 movzbl %al,%eax
asm volatile("out %0,%1" : : "a" (data), "d" (port));
80102609: b2 70 mov $0x70,%dl
8010260b: 89 41 04 mov %eax,0x4(%ecx)
8010260e: b8 04 00 00 00 mov $0x4,%eax
80102613: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102614: 89 da mov %ebx,%edx
80102616: ec in (%dx),%al
80102617: 0f b6 c0 movzbl %al,%eax
asm volatile("out %0,%1" : : "a" (data), "d" (port));
8010261a: b2 70 mov $0x70,%dl
8010261c: 89 41 08 mov %eax,0x8(%ecx)
8010261f: b8 07 00 00 00 mov $0x7,%eax
80102624: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102625: 89 da mov %ebx,%edx
80102627: ec in (%dx),%al
80102628: 0f b6 c0 movzbl %al,%eax
asm volatile("out %0,%1" : : "a" (data), "d" (port));
8010262b: b2 70 mov $0x70,%dl
8010262d: 89 41 0c mov %eax,0xc(%ecx)
80102630: b8 08 00 00 00 mov $0x8,%eax
80102635: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102636: 89 da mov %ebx,%edx
80102638: ec in (%dx),%al
80102639: 0f b6 c0 movzbl %al,%eax
asm volatile("out %0,%1" : : "a" (data), "d" (port));
8010263c: b2 70 mov $0x70,%dl
8010263e: 89 41 10 mov %eax,0x10(%ecx)
80102641: b8 09 00 00 00 mov $0x9,%eax
80102646: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102647: 89 da mov %ebx,%edx
80102649: ec in (%dx),%al
8010264a: 0f b6 d8 movzbl %al,%ebx
8010264d: 89 59 14 mov %ebx,0x14(%ecx)
r->minute = cmos_read(MINS);
r->hour = cmos_read(HOURS);
r->day = cmos_read(DAY);
r->month = cmos_read(MONTH);
r->year = cmos_read(YEAR);
}
80102650: 5b pop %ebx
80102651: 5d pop %ebp
80102652: c3 ret
80102653: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80102659: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80102660 <lapicinit>:
if(!lapic)
80102660: a1 7c 26 11 80 mov 0x8011267c,%eax
{
80102665: 55 push %ebp
80102666: 89 e5 mov %esp,%ebp
if(!lapic)
80102668: 85 c0 test %eax,%eax
8010266a: 0f 84 c0 00 00 00 je 80102730 <lapicinit+0xd0>
lapic[index] = value;
80102670: c7 80 f0 00 00 00 3f movl $0x13f,0xf0(%eax)
80102677: 01 00 00
lapic[ID]; // wait for write to finish, by reading
8010267a: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
8010267d: c7 80 e0 03 00 00 0b movl $0xb,0x3e0(%eax)
80102684: 00 00 00
lapic[ID]; // wait for write to finish, by reading
80102687: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
8010268a: c7 80 20 03 00 00 20 movl $0x20020,0x320(%eax)
80102691: 00 02 00
lapic[ID]; // wait for write to finish, by reading
80102694: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
80102697: c7 80 80 03 00 00 80 movl $0x989680,0x380(%eax)
8010269e: 96 98 00
lapic[ID]; // wait for write to finish, by reading
801026a1: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801026a4: c7 80 50 03 00 00 00 movl $0x10000,0x350(%eax)
801026ab: 00 01 00
lapic[ID]; // wait for write to finish, by reading
801026ae: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801026b1: c7 80 60 03 00 00 00 movl $0x10000,0x360(%eax)
801026b8: 00 01 00
lapic[ID]; // wait for write to finish, by reading
801026bb: 8b 50 20 mov 0x20(%eax),%edx
if(((lapic[VER]>>16) & 0xFF) >= 4)
801026be: 8b 50 30 mov 0x30(%eax),%edx
801026c1: c1 ea 10 shr $0x10,%edx
801026c4: 80 fa 03 cmp $0x3,%dl
801026c7: 77 6f ja 80102738 <lapicinit+0xd8>
lapic[index] = value;
801026c9: c7 80 70 03 00 00 33 movl $0x33,0x370(%eax)
801026d0: 00 00 00
lapic[ID]; // wait for write to finish, by reading
801026d3: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801026d6: c7 80 80 02 00 00 00 movl $0x0,0x280(%eax)
801026dd: 00 00 00
lapic[ID]; // wait for write to finish, by reading
801026e0: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801026e3: c7 80 80 02 00 00 00 movl $0x0,0x280(%eax)
801026ea: 00 00 00
lapic[ID]; // wait for write to finish, by reading
801026ed: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801026f0: c7 80 b0 00 00 00 00 movl $0x0,0xb0(%eax)
801026f7: 00 00 00
lapic[ID]; // wait for write to finish, by reading
801026fa: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801026fd: c7 80 10 03 00 00 00 movl $0x0,0x310(%eax)
80102704: 00 00 00
lapic[ID]; // wait for write to finish, by reading
80102707: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
8010270a: c7 80 00 03 00 00 00 movl $0x88500,0x300(%eax)
80102711: 85 08 00
lapic[ID]; // wait for write to finish, by reading
80102714: 8b 50 20 mov 0x20(%eax),%edx
80102717: 90 nop
while(lapic[ICRLO] & DELIVS)
80102718: 8b 90 00 03 00 00 mov 0x300(%eax),%edx
8010271e: 80 e6 10 and $0x10,%dh
80102721: 75 f5 jne 80102718 <lapicinit+0xb8>
lapic[index] = value;
80102723: c7 80 80 00 00 00 00 movl $0x0,0x80(%eax)
8010272a: 00 00 00
lapic[ID]; // wait for write to finish, by reading
8010272d: 8b 40 20 mov 0x20(%eax),%eax
}
80102730: 5d pop %ebp
80102731: c3 ret
80102732: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
lapic[index] = value;
80102738: c7 80 40 03 00 00 00 movl $0x10000,0x340(%eax)
8010273f: 00 01 00
lapic[ID]; // wait for write to finish, by reading
80102742: 8b 50 20 mov 0x20(%eax),%edx
80102745: eb 82 jmp 801026c9 <lapicinit+0x69>
80102747: 89 f6 mov %esi,%esi
80102749: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80102750 <lapicid>:
if (!lapic)
80102750: a1 7c 26 11 80 mov 0x8011267c,%eax
{
80102755: 55 push %ebp
80102756: 89 e5 mov %esp,%ebp
if (!lapic)
80102758: 85 c0 test %eax,%eax
8010275a: 74 0c je 80102768 <lapicid+0x18>
return lapic[ID] >> 24;
8010275c: 8b 40 20 mov 0x20(%eax),%eax
}
8010275f: 5d pop %ebp
return lapic[ID] >> 24;
80102760: c1 e8 18 shr $0x18,%eax
}
80102763: c3 ret
80102764: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return 0;
80102768: 31 c0 xor %eax,%eax
}
8010276a: 5d pop %ebp
8010276b: c3 ret
8010276c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80102770 <lapiceoi>:
if(lapic)
80102770: a1 7c 26 11 80 mov 0x8011267c,%eax
{
80102775: 55 push %ebp
80102776: 89 e5 mov %esp,%ebp
if(lapic)
80102778: 85 c0 test %eax,%eax
8010277a: 74 0d je 80102789 <lapiceoi+0x19>
lapic[index] = value;
8010277c: c7 80 b0 00 00 00 00 movl $0x0,0xb0(%eax)
80102783: 00 00 00
lapic[ID]; // wait for write to finish, by reading
80102786: 8b 40 20 mov 0x20(%eax),%eax
}
80102789: 5d pop %ebp
8010278a: c3 ret
8010278b: 90 nop
8010278c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80102790 <microdelay>:
{
80102790: 55 push %ebp
80102791: 89 e5 mov %esp,%ebp
}
80102793: 5d pop %ebp
80102794: c3 ret
80102795: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80102799: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801027a0 <lapicstartap>:
{
801027a0: 55 push %ebp
asm volatile("out %0,%1" : : "a" (data), "d" (port));
801027a1: ba 70 00 00 00 mov $0x70,%edx
801027a6: 89 e5 mov %esp,%ebp
801027a8: b8 0f 00 00 00 mov $0xf,%eax
801027ad: 53 push %ebx
801027ae: 8b 4d 08 mov 0x8(%ebp),%ecx
801027b1: 8b 5d 0c mov 0xc(%ebp),%ebx
801027b4: ee out %al,(%dx)
801027b5: b8 0a 00 00 00 mov $0xa,%eax
801027ba: b2 71 mov $0x71,%dl
801027bc: ee out %al,(%dx)
wrv[0] = 0;
801027bd: 31 c0 xor %eax,%eax
801027bf: 66 a3 67 04 00 80 mov %ax,0x80000467
wrv[1] = addr >> 4;
801027c5: 89 d8 mov %ebx,%eax
801027c7: c1 e8 04 shr $0x4,%eax
801027ca: 66 a3 69 04 00 80 mov %ax,0x80000469
lapic[index] = value;
801027d0: a1 7c 26 11 80 mov 0x8011267c,%eax
lapicw(ICRHI, apicid<<24);
801027d5: c1 e1 18 shl $0x18,%ecx
lapicw(ICRLO, STARTUP | (addr>>12));
801027d8: c1 eb 0c shr $0xc,%ebx
lapic[index] = value;
801027db: 89 88 10 03 00 00 mov %ecx,0x310(%eax)
lapic[ID]; // wait for write to finish, by reading
801027e1: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801027e4: c7 80 00 03 00 00 00 movl $0xc500,0x300(%eax)
801027eb: c5 00 00
lapic[ID]; // wait for write to finish, by reading
801027ee: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801027f1: c7 80 00 03 00 00 00 movl $0x8500,0x300(%eax)
801027f8: 85 00 00
lapic[ID]; // wait for write to finish, by reading
801027fb: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801027fe: 89 88 10 03 00 00 mov %ecx,0x310(%eax)
lapic[ID]; // wait for write to finish, by reading
80102804: 8b 50 20 mov 0x20(%eax),%edx
lapicw(ICRLO, STARTUP | (addr>>12));
80102807: 89 da mov %ebx,%edx
80102809: 80 ce 06 or $0x6,%dh
lapic[index] = value;
8010280c: 89 90 00 03 00 00 mov %edx,0x300(%eax)
lapic[ID]; // wait for write to finish, by reading
80102812: 8b 58 20 mov 0x20(%eax),%ebx
lapic[index] = value;
80102815: 89 88 10 03 00 00 mov %ecx,0x310(%eax)
lapic[ID]; // wait for write to finish, by reading
8010281b: 8b 48 20 mov 0x20(%eax),%ecx
lapic[index] = value;
8010281e: 89 90 00 03 00 00 mov %edx,0x300(%eax)
lapic[ID]; // wait for write to finish, by reading
80102824: 8b 40 20 mov 0x20(%eax),%eax
}
80102827: 5b pop %ebx
80102828: 5d pop %ebp
80102829: c3 ret
8010282a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80102830 <cmostime>:
// qemu seems to use 24-hour GWT and the values are BCD encoded
void cmostime(struct rtcdate *r)
{
80102830: 55 push %ebp
80102831: ba 70 00 00 00 mov $0x70,%edx
80102836: 89 e5 mov %esp,%ebp
80102838: b8 0b 00 00 00 mov $0xb,%eax
8010283d: 57 push %edi
8010283e: 56 push %esi
8010283f: 53 push %ebx
80102840: 83 ec 4c sub $0x4c,%esp
80102843: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102844: b2 71 mov $0x71,%dl
80102846: ec in (%dx),%al
80102847: 88 45 b7 mov %al,-0x49(%ebp)
8010284a: 8d 5d b8 lea -0x48(%ebp),%ebx
struct rtcdate t1, t2;
int sb, bcd;
sb = cmos_read(CMOS_STATB);
bcd = (sb & (1 << 2)) == 0;
8010284d: 80 65 b7 04 andb $0x4,-0x49(%ebp)
80102851: 8d 7d d0 lea -0x30(%ebp),%edi
80102854: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
asm volatile("out %0,%1" : : "a" (data), "d" (port));
80102858: be 70 00 00 00 mov $0x70,%esi
// make sure CMOS doesn't modify time while we read it
for(;;) {
fill_rtcdate(&t1);
8010285d: 89 d8 mov %ebx,%eax
8010285f: e8 7c fd ff ff call 801025e0 <fill_rtcdate>
80102864: b8 0a 00 00 00 mov $0xa,%eax
80102869: 89 f2 mov %esi,%edx
8010286b: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
8010286c: ba 71 00 00 00 mov $0x71,%edx
80102871: ec in (%dx),%al
if(cmos_read(CMOS_STATA) & CMOS_UIP)
80102872: 84 c0 test %al,%al
80102874: 78 e7 js 8010285d <cmostime+0x2d>
continue;
fill_rtcdate(&t2);
80102876: 89 f8 mov %edi,%eax
80102878: e8 63 fd ff ff call 801025e0 <fill_rtcdate>
if(memcmp(&t1, &t2, sizeof(t1)) == 0)
8010287d: c7 44 24 08 18 00 00 movl $0x18,0x8(%esp)
80102884: 00
80102885: 89 7c 24 04 mov %edi,0x4(%esp)
80102889: 89 1c 24 mov %ebx,(%esp)
8010288c: e8 2f 1a 00 00 call 801042c0 <memcmp>
80102891: 85 c0 test %eax,%eax
80102893: 75 c3 jne 80102858 <cmostime+0x28>
break;
}
// convert
if(bcd) {
80102895: 80 7d b7 00 cmpb $0x0,-0x49(%ebp)
80102899: 75 78 jne 80102913 <cmostime+0xe3>
#define CONV(x) (t1.x = ((t1.x >> 4) * 10) + (t1.x & 0xf))
CONV(second);
8010289b: 8b 45 b8 mov -0x48(%ebp),%eax
8010289e: 89 c2 mov %eax,%edx
801028a0: 83 e0 0f and $0xf,%eax
801028a3: c1 ea 04 shr $0x4,%edx
801028a6: 8d 14 92 lea (%edx,%edx,4),%edx
801028a9: 8d 04 50 lea (%eax,%edx,2),%eax
801028ac: 89 45 b8 mov %eax,-0x48(%ebp)
CONV(minute);
801028af: 8b 45 bc mov -0x44(%ebp),%eax
801028b2: 89 c2 mov %eax,%edx
801028b4: 83 e0 0f and $0xf,%eax
801028b7: c1 ea 04 shr $0x4,%edx
801028ba: 8d 14 92 lea (%edx,%edx,4),%edx
801028bd: 8d 04 50 lea (%eax,%edx,2),%eax
801028c0: 89 45 bc mov %eax,-0x44(%ebp)
CONV(hour );
801028c3: 8b 45 c0 mov -0x40(%ebp),%eax
801028c6: 89 c2 mov %eax,%edx
801028c8: 83 e0 0f and $0xf,%eax
801028cb: c1 ea 04 shr $0x4,%edx
801028ce: 8d 14 92 lea (%edx,%edx,4),%edx
801028d1: 8d 04 50 lea (%eax,%edx,2),%eax
801028d4: 89 45 c0 mov %eax,-0x40(%ebp)
CONV(day );
801028d7: 8b 45 c4 mov -0x3c(%ebp),%eax
801028da: 89 c2 mov %eax,%edx
801028dc: 83 e0 0f and $0xf,%eax
801028df: c1 ea 04 shr $0x4,%edx
801028e2: 8d 14 92 lea (%edx,%edx,4),%edx
801028e5: 8d 04 50 lea (%eax,%edx,2),%eax
801028e8: 89 45 c4 mov %eax,-0x3c(%ebp)
CONV(month );
801028eb: 8b 45 c8 mov -0x38(%ebp),%eax
801028ee: 89 c2 mov %eax,%edx
801028f0: 83 e0 0f and $0xf,%eax
801028f3: c1 ea 04 shr $0x4,%edx
801028f6: 8d 14 92 lea (%edx,%edx,4),%edx
801028f9: 8d 04 50 lea (%eax,%edx,2),%eax
801028fc: 89 45 c8 mov %eax,-0x38(%ebp)
CONV(year );
801028ff: 8b 45 cc mov -0x34(%ebp),%eax
80102902: 89 c2 mov %eax,%edx
80102904: 83 e0 0f and $0xf,%eax
80102907: c1 ea 04 shr $0x4,%edx
8010290a: 8d 14 92 lea (%edx,%edx,4),%edx
8010290d: 8d 04 50 lea (%eax,%edx,2),%eax
80102910: 89 45 cc mov %eax,-0x34(%ebp)
#undef CONV
}
*r = t1;
80102913: 8b 4d 08 mov 0x8(%ebp),%ecx
80102916: 8b 45 b8 mov -0x48(%ebp),%eax
80102919: 89 01 mov %eax,(%ecx)
8010291b: 8b 45 bc mov -0x44(%ebp),%eax
8010291e: 89 41 04 mov %eax,0x4(%ecx)
80102921: 8b 45 c0 mov -0x40(%ebp),%eax
80102924: 89 41 08 mov %eax,0x8(%ecx)
80102927: 8b 45 c4 mov -0x3c(%ebp),%eax
8010292a: 89 41 0c mov %eax,0xc(%ecx)
8010292d: 8b 45 c8 mov -0x38(%ebp),%eax
80102930: 89 41 10 mov %eax,0x10(%ecx)
80102933: 8b 45 cc mov -0x34(%ebp),%eax
80102936: 89 41 14 mov %eax,0x14(%ecx)
r->year += 2000;
80102939: 81 41 14 d0 07 00 00 addl $0x7d0,0x14(%ecx)
}
80102940: 83 c4 4c add $0x4c,%esp
80102943: 5b pop %ebx
80102944: 5e pop %esi
80102945: 5f pop %edi
80102946: 5d pop %ebp
80102947: c3 ret
80102948: 66 90 xchg %ax,%ax
8010294a: 66 90 xchg %ax,%ax
8010294c: 66 90 xchg %ax,%ax
8010294e: 66 90 xchg %ax,%ax
80102950 <install_trans>:
}
// Copy committed blocks from log to their home location
static void
install_trans(void)
{
80102950: 55 push %ebp
80102951: 89 e5 mov %esp,%ebp
80102953: 57 push %edi
80102954: 56 push %esi
80102955: 53 push %ebx
int tail;
for (tail = 0; tail < log.lh.n; tail++) {
80102956: 31 db xor %ebx,%ebx
{
80102958: 83 ec 1c sub $0x1c,%esp
for (tail = 0; tail < log.lh.n; tail++) {
8010295b: a1 c8 26 11 80 mov 0x801126c8,%eax
80102960: 85 c0 test %eax,%eax
80102962: 7e 78 jle 801029dc <install_trans+0x8c>
80102964: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
struct buf *lbuf = bread(log.dev, log.start+tail+1); // read log block
80102968: a1 b4 26 11 80 mov 0x801126b4,%eax
8010296d: 01 d8 add %ebx,%eax
8010296f: 83 c0 01 add $0x1,%eax
80102972: 89 44 24 04 mov %eax,0x4(%esp)
80102976: a1 c4 26 11 80 mov 0x801126c4,%eax
8010297b: 89 04 24 mov %eax,(%esp)
8010297e: e8 4d d7 ff ff call 801000d0 <bread>
80102983: 89 c7 mov %eax,%edi
struct buf *dbuf = bread(log.dev, log.lh.block[tail]); // read dst
80102985: 8b 04 9d cc 26 11 80 mov -0x7feed934(,%ebx,4),%eax
for (tail = 0; tail < log.lh.n; tail++) {
8010298c: 83 c3 01 add $0x1,%ebx
struct buf *dbuf = bread(log.dev, log.lh.block[tail]); // read dst
8010298f: 89 44 24 04 mov %eax,0x4(%esp)
80102993: a1 c4 26 11 80 mov 0x801126c4,%eax
80102998: 89 04 24 mov %eax,(%esp)
8010299b: e8 30 d7 ff ff call 801000d0 <bread>
memmove(dbuf->data, lbuf->data, BSIZE); // copy block to dst
801029a0: c7 44 24 08 00 02 00 movl $0x200,0x8(%esp)
801029a7: 00
struct buf *dbuf = bread(log.dev, log.lh.block[tail]); // read dst
801029a8: 89 c6 mov %eax,%esi
memmove(dbuf->data, lbuf->data, BSIZE); // copy block to dst
801029aa: 8d 47 5c lea 0x5c(%edi),%eax
801029ad: 89 44 24 04 mov %eax,0x4(%esp)
801029b1: 8d 46 5c lea 0x5c(%esi),%eax
801029b4: 89 04 24 mov %eax,(%esp)
801029b7: e8 54 19 00 00 call 80104310 <memmove>
bwrite(dbuf); // write dst to disk
801029bc: 89 34 24 mov %esi,(%esp)
801029bf: e8 dc d7 ff ff call 801001a0 <bwrite>
brelse(lbuf);
801029c4: 89 3c 24 mov %edi,(%esp)
801029c7: e8 14 d8 ff ff call 801001e0 <brelse>
brelse(dbuf);
801029cc: 89 34 24 mov %esi,(%esp)
801029cf: e8 0c d8 ff ff call 801001e0 <brelse>
for (tail = 0; tail < log.lh.n; tail++) {
801029d4: 39 1d c8 26 11 80 cmp %ebx,0x801126c8
801029da: 7f 8c jg 80102968 <install_trans+0x18>
}
}
801029dc: 83 c4 1c add $0x1c,%esp
801029df: 5b pop %ebx
801029e0: 5e pop %esi
801029e1: 5f pop %edi
801029e2: 5d pop %ebp
801029e3: c3 ret
801029e4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801029ea: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
801029f0 <write_head>:
// Write in-memory log header to disk.
// This is the true point at which the
// current transaction commits.
static void
write_head(void)
{
801029f0: 55 push %ebp
801029f1: 89 e5 mov %esp,%ebp
801029f3: 57 push %edi
801029f4: 56 push %esi
801029f5: 53 push %ebx
801029f6: 83 ec 1c sub $0x1c,%esp
struct buf *buf = bread(log.dev, log.start);
801029f9: a1 b4 26 11 80 mov 0x801126b4,%eax
801029fe: 89 44 24 04 mov %eax,0x4(%esp)
80102a02: a1 c4 26 11 80 mov 0x801126c4,%eax
80102a07: 89 04 24 mov %eax,(%esp)
80102a0a: e8 c1 d6 ff ff call 801000d0 <bread>
struct logheader *hb = (struct logheader *) (buf->data);
int i;
hb->n = log.lh.n;
80102a0f: 8b 1d c8 26 11 80 mov 0x801126c8,%ebx
for (i = 0; i < log.lh.n; i++) {
80102a15: 31 d2 xor %edx,%edx
80102a17: 85 db test %ebx,%ebx
struct buf *buf = bread(log.dev, log.start);
80102a19: 89 c7 mov %eax,%edi
hb->n = log.lh.n;
80102a1b: 89 58 5c mov %ebx,0x5c(%eax)
80102a1e: 8d 70 5c lea 0x5c(%eax),%esi
for (i = 0; i < log.lh.n; i++) {
80102a21: 7e 17 jle 80102a3a <write_head+0x4a>
80102a23: 90 nop
80102a24: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
hb->block[i] = log.lh.block[i];
80102a28: 8b 0c 95 cc 26 11 80 mov -0x7feed934(,%edx,4),%ecx
80102a2f: 89 4c 96 04 mov %ecx,0x4(%esi,%edx,4)
for (i = 0; i < log.lh.n; i++) {
80102a33: 83 c2 01 add $0x1,%edx
80102a36: 39 da cmp %ebx,%edx
80102a38: 75 ee jne 80102a28 <write_head+0x38>
}
bwrite(buf);
80102a3a: 89 3c 24 mov %edi,(%esp)
80102a3d: e8 5e d7 ff ff call 801001a0 <bwrite>
brelse(buf);
80102a42: 89 3c 24 mov %edi,(%esp)
80102a45: e8 96 d7 ff ff call 801001e0 <brelse>
}
80102a4a: 83 c4 1c add $0x1c,%esp
80102a4d: 5b pop %ebx
80102a4e: 5e pop %esi
80102a4f: 5f pop %edi
80102a50: 5d pop %ebp
80102a51: c3 ret
80102a52: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80102a59: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80102a60 <initlog>:
{
80102a60: 55 push %ebp
80102a61: 89 e5 mov %esp,%ebp
80102a63: 56 push %esi
80102a64: 53 push %ebx
80102a65: 83 ec 30 sub $0x30,%esp
80102a68: 8b 5d 08 mov 0x8(%ebp),%ebx
initlock(&log.lock, "log");
80102a6b: c7 44 24 04 c0 72 10 movl $0x801072c0,0x4(%esp)
80102a72: 80
80102a73: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102a7a: e8 c1 15 00 00 call 80104040 <initlock>
readsb(dev, &sb);
80102a7f: 8d 45 dc lea -0x24(%ebp),%eax
80102a82: 89 44 24 04 mov %eax,0x4(%esp)
80102a86: 89 1c 24 mov %ebx,(%esp)
80102a89: e8 f2 e8 ff ff call 80101380 <readsb>
log.start = sb.logstart;
80102a8e: 8b 45 ec mov -0x14(%ebp),%eax
log.size = sb.nlog;
80102a91: 8b 55 e8 mov -0x18(%ebp),%edx
struct buf *buf = bread(log.dev, log.start);
80102a94: 89 1c 24 mov %ebx,(%esp)
log.dev = dev;
80102a97: 89 1d c4 26 11 80 mov %ebx,0x801126c4
struct buf *buf = bread(log.dev, log.start);
80102a9d: 89 44 24 04 mov %eax,0x4(%esp)
log.size = sb.nlog;
80102aa1: 89 15 b8 26 11 80 mov %edx,0x801126b8
log.start = sb.logstart;
80102aa7: a3 b4 26 11 80 mov %eax,0x801126b4
struct buf *buf = bread(log.dev, log.start);
80102aac: e8 1f d6 ff ff call 801000d0 <bread>
for (i = 0; i < log.lh.n; i++) {
80102ab1: 31 d2 xor %edx,%edx
log.lh.n = lh->n;
80102ab3: 8b 58 5c mov 0x5c(%eax),%ebx
80102ab6: 8d 70 5c lea 0x5c(%eax),%esi
for (i = 0; i < log.lh.n; i++) {
80102ab9: 85 db test %ebx,%ebx
log.lh.n = lh->n;
80102abb: 89 1d c8 26 11 80 mov %ebx,0x801126c8
for (i = 0; i < log.lh.n; i++) {
80102ac1: 7e 17 jle 80102ada <initlog+0x7a>
80102ac3: 90 nop
80102ac4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
log.lh.block[i] = lh->block[i];
80102ac8: 8b 4c 96 04 mov 0x4(%esi,%edx,4),%ecx
80102acc: 89 0c 95 cc 26 11 80 mov %ecx,-0x7feed934(,%edx,4)
for (i = 0; i < log.lh.n; i++) {
80102ad3: 83 c2 01 add $0x1,%edx
80102ad6: 39 da cmp %ebx,%edx
80102ad8: 75 ee jne 80102ac8 <initlog+0x68>
brelse(buf);
80102ada: 89 04 24 mov %eax,(%esp)
80102add: e8 fe d6 ff ff call 801001e0 <brelse>
static void
recover_from_log(void)
{
read_head();
install_trans(); // if committed, copy from log to disk
80102ae2: e8 69 fe ff ff call 80102950 <install_trans>
log.lh.n = 0;
80102ae7: c7 05 c8 26 11 80 00 movl $0x0,0x801126c8
80102aee: 00 00 00
write_head(); // clear the log
80102af1: e8 fa fe ff ff call 801029f0 <write_head>
}
80102af6: 83 c4 30 add $0x30,%esp
80102af9: 5b pop %ebx
80102afa: 5e pop %esi
80102afb: 5d pop %ebp
80102afc: c3 ret
80102afd: 8d 76 00 lea 0x0(%esi),%esi
80102b00 <begin_op>:
}
// called at the start of each FS system call.
void
begin_op(void)
{
80102b00: 55 push %ebp
80102b01: 89 e5 mov %esp,%ebp
80102b03: 83 ec 18 sub $0x18,%esp
acquire(&log.lock);
80102b06: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102b0d: e8 1e 16 00 00 call 80104130 <acquire>
80102b12: eb 18 jmp 80102b2c <begin_op+0x2c>
80102b14: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
while(1){
if(log.committing){
sleep(&log, &log.lock);
80102b18: c7 44 24 04 80 26 11 movl $0x80112680,0x4(%esp)
80102b1f: 80
80102b20: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102b27: e8 c4 10 00 00 call 80103bf0 <sleep>
if(log.committing){
80102b2c: a1 c0 26 11 80 mov 0x801126c0,%eax
80102b31: 85 c0 test %eax,%eax
80102b33: 75 e3 jne 80102b18 <begin_op+0x18>
} else if(log.lh.n + (log.outstanding+1)*MAXOPBLOCKS > LOGSIZE){
80102b35: a1 bc 26 11 80 mov 0x801126bc,%eax
80102b3a: 8b 15 c8 26 11 80 mov 0x801126c8,%edx
80102b40: 83 c0 01 add $0x1,%eax
80102b43: 8d 0c 80 lea (%eax,%eax,4),%ecx
80102b46: 8d 14 4a lea (%edx,%ecx,2),%edx
80102b49: 83 fa 1e cmp $0x1e,%edx
80102b4c: 7f ca jg 80102b18 <begin_op+0x18>
// this op might exhaust log space; wait for commit.
sleep(&log, &log.lock);
} else {
log.outstanding += 1;
release(&log.lock);
80102b4e: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
log.outstanding += 1;
80102b55: a3 bc 26 11 80 mov %eax,0x801126bc
release(&log.lock);
80102b5a: e8 c1 16 00 00 call 80104220 <release>
break;
}
}
}
80102b5f: c9 leave
80102b60: c3 ret
80102b61: eb 0d jmp 80102b70 <end_op>
80102b63: 90 nop
80102b64: 90 nop
80102b65: 90 nop
80102b66: 90 nop
80102b67: 90 nop
80102b68: 90 nop
80102b69: 90 nop
80102b6a: 90 nop
80102b6b: 90 nop
80102b6c: 90 nop
80102b6d: 90 nop
80102b6e: 90 nop
80102b6f: 90 nop
80102b70 <end_op>:
// called at the end of each FS system call.
// commits if this was the last outstanding operation.
void
end_op(void)
{
80102b70: 55 push %ebp
80102b71: 89 e5 mov %esp,%ebp
80102b73: 57 push %edi
80102b74: 56 push %esi
80102b75: 53 push %ebx
80102b76: 83 ec 1c sub $0x1c,%esp
int do_commit = 0;
acquire(&log.lock);
80102b79: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102b80: e8 ab 15 00 00 call 80104130 <acquire>
log.outstanding -= 1;
80102b85: a1 bc 26 11 80 mov 0x801126bc,%eax
if(log.committing)
80102b8a: 8b 15 c0 26 11 80 mov 0x801126c0,%edx
log.outstanding -= 1;
80102b90: 83 e8 01 sub $0x1,%eax
if(log.committing)
80102b93: 85 d2 test %edx,%edx
log.outstanding -= 1;
80102b95: a3 bc 26 11 80 mov %eax,0x801126bc
if(log.committing)
80102b9a: 0f 85 f3 00 00 00 jne 80102c93 <end_op+0x123>
panic("log.committing");
if(log.outstanding == 0){
80102ba0: 85 c0 test %eax,%eax
80102ba2: 0f 85 cb 00 00 00 jne 80102c73 <end_op+0x103>
// begin_op() may be waiting for log space,
// and decrementing log.outstanding has decreased
// the amount of reserved space.
wakeup(&log);
}
release(&log.lock);
80102ba8: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
}
static void
commit()
{
if (log.lh.n > 0) {
80102baf: 31 db xor %ebx,%ebx
log.committing = 1;
80102bb1: c7 05 c0 26 11 80 01 movl $0x1,0x801126c0
80102bb8: 00 00 00
release(&log.lock);
80102bbb: e8 60 16 00 00 call 80104220 <release>
if (log.lh.n > 0) {
80102bc0: a1 c8 26 11 80 mov 0x801126c8,%eax
80102bc5: 85 c0 test %eax,%eax
80102bc7: 0f 8e 90 00 00 00 jle 80102c5d <end_op+0xed>
80102bcd: 8d 76 00 lea 0x0(%esi),%esi
struct buf *to = bread(log.dev, log.start+tail+1); // log block
80102bd0: a1 b4 26 11 80 mov 0x801126b4,%eax
80102bd5: 01 d8 add %ebx,%eax
80102bd7: 83 c0 01 add $0x1,%eax
80102bda: 89 44 24 04 mov %eax,0x4(%esp)
80102bde: a1 c4 26 11 80 mov 0x801126c4,%eax
80102be3: 89 04 24 mov %eax,(%esp)
80102be6: e8 e5 d4 ff ff call 801000d0 <bread>
80102beb: 89 c6 mov %eax,%esi
struct buf *from = bread(log.dev, log.lh.block[tail]); // cache block
80102bed: 8b 04 9d cc 26 11 80 mov -0x7feed934(,%ebx,4),%eax
for (tail = 0; tail < log.lh.n; tail++) {
80102bf4: 83 c3 01 add $0x1,%ebx
struct buf *from = bread(log.dev, log.lh.block[tail]); // cache block
80102bf7: 89 44 24 04 mov %eax,0x4(%esp)
80102bfb: a1 c4 26 11 80 mov 0x801126c4,%eax
80102c00: 89 04 24 mov %eax,(%esp)
80102c03: e8 c8 d4 ff ff call 801000d0 <bread>
memmove(to->data, from->data, BSIZE);
80102c08: c7 44 24 08 00 02 00 movl $0x200,0x8(%esp)
80102c0f: 00
struct buf *from = bread(log.dev, log.lh.block[tail]); // cache block
80102c10: 89 c7 mov %eax,%edi
memmove(to->data, from->data, BSIZE);
80102c12: 8d 40 5c lea 0x5c(%eax),%eax
80102c15: 89 44 24 04 mov %eax,0x4(%esp)
80102c19: 8d 46 5c lea 0x5c(%esi),%eax
80102c1c: 89 04 24 mov %eax,(%esp)
80102c1f: e8 ec 16 00 00 call 80104310 <memmove>
bwrite(to); // write the log
80102c24: 89 34 24 mov %esi,(%esp)
80102c27: e8 74 d5 ff ff call 801001a0 <bwrite>
brelse(from);
80102c2c: 89 3c 24 mov %edi,(%esp)
80102c2f: e8 ac d5 ff ff call 801001e0 <brelse>
brelse(to);
80102c34: 89 34 24 mov %esi,(%esp)
80102c37: e8 a4 d5 ff ff call 801001e0 <brelse>
for (tail = 0; tail < log.lh.n; tail++) {
80102c3c: 3b 1d c8 26 11 80 cmp 0x801126c8,%ebx
80102c42: 7c 8c jl 80102bd0 <end_op+0x60>
write_log(); // Write modified blocks from cache to log
write_head(); // Write header to disk -- the real commit
80102c44: e8 a7 fd ff ff call 801029f0 <write_head>
install_trans(); // Now install writes to home locations
80102c49: e8 02 fd ff ff call 80102950 <install_trans>
log.lh.n = 0;
80102c4e: c7 05 c8 26 11 80 00 movl $0x0,0x801126c8
80102c55: 00 00 00
write_head(); // Erase the transaction from the log
80102c58: e8 93 fd ff ff call 801029f0 <write_head>
acquire(&log.lock);
80102c5d: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102c64: e8 c7 14 00 00 call 80104130 <acquire>
log.committing = 0;
80102c69: c7 05 c0 26 11 80 00 movl $0x0,0x801126c0
80102c70: 00 00 00
wakeup(&log);
80102c73: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102c7a: e8 01 11 00 00 call 80103d80 <wakeup>
release(&log.lock);
80102c7f: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102c86: e8 95 15 00 00 call 80104220 <release>
}
80102c8b: 83 c4 1c add $0x1c,%esp
80102c8e: 5b pop %ebx
80102c8f: 5e pop %esi
80102c90: 5f pop %edi
80102c91: 5d pop %ebp
80102c92: c3 ret
panic("log.committing");
80102c93: c7 04 24 c4 72 10 80 movl $0x801072c4,(%esp)
80102c9a: e8 c1 d6 ff ff call 80100360 <panic>
80102c9f: 90 nop
80102ca0 <log_write>:
// modify bp->data[]
// log_write(bp)
// brelse(bp)
void
log_write(struct buf *b)
{
80102ca0: 55 push %ebp
80102ca1: 89 e5 mov %esp,%ebp
80102ca3: 53 push %ebx
80102ca4: 83 ec 14 sub $0x14,%esp
int i;
if (log.lh.n >= LOGSIZE || log.lh.n >= log.size - 1)
80102ca7: a1 c8 26 11 80 mov 0x801126c8,%eax
{
80102cac: 8b 5d 08 mov 0x8(%ebp),%ebx
if (log.lh.n >= LOGSIZE || log.lh.n >= log.size - 1)
80102caf: 83 f8 1d cmp $0x1d,%eax
80102cb2: 0f 8f 98 00 00 00 jg 80102d50 <log_write+0xb0>
80102cb8: 8b 0d b8 26 11 80 mov 0x801126b8,%ecx
80102cbe: 8d 51 ff lea -0x1(%ecx),%edx
80102cc1: 39 d0 cmp %edx,%eax
80102cc3: 0f 8d 87 00 00 00 jge 80102d50 <log_write+0xb0>
panic("too big a transaction");
if (log.outstanding < 1)
80102cc9: a1 bc 26 11 80 mov 0x801126bc,%eax
80102cce: 85 c0 test %eax,%eax
80102cd0: 0f 8e 86 00 00 00 jle 80102d5c <log_write+0xbc>
panic("log_write outside of trans");
acquire(&log.lock);
80102cd6: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102cdd: e8 4e 14 00 00 call 80104130 <acquire>
for (i = 0; i < log.lh.n; i++) {
80102ce2: 8b 15 c8 26 11 80 mov 0x801126c8,%edx
80102ce8: 83 fa 00 cmp $0x0,%edx
80102ceb: 7e 54 jle 80102d41 <log_write+0xa1>
if (log.lh.block[i] == b->blockno) // log absorbtion
80102ced: 8b 4b 08 mov 0x8(%ebx),%ecx
for (i = 0; i < log.lh.n; i++) {
80102cf0: 31 c0 xor %eax,%eax
if (log.lh.block[i] == b->blockno) // log absorbtion
80102cf2: 39 0d cc 26 11 80 cmp %ecx,0x801126cc
80102cf8: 75 0f jne 80102d09 <log_write+0x69>
80102cfa: eb 3c jmp 80102d38 <log_write+0x98>
80102cfc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80102d00: 39 0c 85 cc 26 11 80 cmp %ecx,-0x7feed934(,%eax,4)
80102d07: 74 2f je 80102d38 <log_write+0x98>
for (i = 0; i < log.lh.n; i++) {
80102d09: 83 c0 01 add $0x1,%eax
80102d0c: 39 d0 cmp %edx,%eax
80102d0e: 75 f0 jne 80102d00 <log_write+0x60>
break;
}
log.lh.block[i] = b->blockno;
80102d10: 89 0c 95 cc 26 11 80 mov %ecx,-0x7feed934(,%edx,4)
if (i == log.lh.n)
log.lh.n++;
80102d17: 83 c2 01 add $0x1,%edx
80102d1a: 89 15 c8 26 11 80 mov %edx,0x801126c8
b->flags |= B_DIRTY; // prevent eviction
80102d20: 83 0b 04 orl $0x4,(%ebx)
release(&log.lock);
80102d23: c7 45 08 80 26 11 80 movl $0x80112680,0x8(%ebp)
}
80102d2a: 83 c4 14 add $0x14,%esp
80102d2d: 5b pop %ebx
80102d2e: 5d pop %ebp
release(&log.lock);
80102d2f: e9 ec 14 00 00 jmp 80104220 <release>
80102d34: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
log.lh.block[i] = b->blockno;
80102d38: 89 0c 85 cc 26 11 80 mov %ecx,-0x7feed934(,%eax,4)
80102d3f: eb df jmp 80102d20 <log_write+0x80>
80102d41: 8b 43 08 mov 0x8(%ebx),%eax
80102d44: a3 cc 26 11 80 mov %eax,0x801126cc
if (i == log.lh.n)
80102d49: 75 d5 jne 80102d20 <log_write+0x80>
80102d4b: eb ca jmp 80102d17 <log_write+0x77>
80102d4d: 8d 76 00 lea 0x0(%esi),%esi
panic("too big a transaction");
80102d50: c7 04 24 d3 72 10 80 movl $0x801072d3,(%esp)
80102d57: e8 04 d6 ff ff call 80100360 <panic>
panic("log_write outside of trans");
80102d5c: c7 04 24 e9 72 10 80 movl $0x801072e9,(%esp)
80102d63: e8 f8 d5 ff ff call 80100360 <panic>
80102d68: 66 90 xchg %ax,%ax
80102d6a: 66 90 xchg %ax,%ax
80102d6c: 66 90 xchg %ax,%ax
80102d6e: 66 90 xchg %ax,%ax
80102d70 <mpmain>:
}
// Common CPU setup code.
static void
mpmain(void)
{
80102d70: 55 push %ebp
80102d71: 89 e5 mov %esp,%ebp
80102d73: 53 push %ebx
80102d74: 83 ec 14 sub $0x14,%esp
cprintf("cpu%d: starting %d\n", cpuid(), cpuid());
80102d77: e8 f4 08 00 00 call 80103670 <cpuid>
80102d7c: 89 c3 mov %eax,%ebx
80102d7e: e8 ed 08 00 00 call 80103670 <cpuid>
80102d83: 89 5c 24 08 mov %ebx,0x8(%esp)
80102d87: c7 04 24 04 73 10 80 movl $0x80107304,(%esp)
80102d8e: 89 44 24 04 mov %eax,0x4(%esp)
80102d92: e8 b9 d8 ff ff call 80100650 <cprintf>
idtinit(); // load idt register
80102d97: e8 34 27 00 00 call 801054d0 <idtinit>
xchg(&(mycpu()->started), 1); // tell startothers() we're up
80102d9c: e8 4f 08 00 00 call 801035f0 <mycpu>
80102da1: 89 c2 mov %eax,%edx
xchg(volatile uint *addr, uint newval)
{
uint result;
// The + in "+m" denotes a read-modify-write operand.
asm volatile("lock; xchgl %0, %1" :
80102da3: b8 01 00 00 00 mov $0x1,%eax
80102da8: f0 87 82 a0 00 00 00 lock xchg %eax,0xa0(%edx)
scheduler(); // start running processes
80102daf: e8 9c 0b 00 00 call 80103950 <scheduler>
80102db4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80102dba: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
80102dc0 <mpenter>:
{
80102dc0: 55 push %ebp
80102dc1: 89 e5 mov %esp,%ebp
80102dc3: 83 ec 08 sub $0x8,%esp
switchkvm();
80102dc6: e8 45 38 00 00 call 80106610 <switchkvm>
seginit();
80102dcb: e8 00 37 00 00 call 801064d0 <seginit>
lapicinit();
80102dd0: e8 8b f8 ff ff call 80102660 <lapicinit>
mpmain();
80102dd5: e8 96 ff ff ff call 80102d70 <mpmain>
80102dda: 66 90 xchg %ax,%ax
80102ddc: 66 90 xchg %ax,%ax
80102dde: 66 90 xchg %ax,%ax
80102de0 <main>:
{
80102de0: 55 push %ebp
80102de1: 89 e5 mov %esp,%ebp
80102de3: 53 push %ebx
// The linker has placed the image of entryother.S in
// _binary_entryother_start.
code = P2V(0x7000);
memmove(code, _binary_entryother_start, (uint)_binary_entryother_size);
for(c = cpus; c < cpus+ncpu; c++){
80102de4: bb 80 27 11 80 mov $0x80112780,%ebx
{
80102de9: 83 e4 f0 and $0xfffffff0,%esp
80102dec: 83 ec 10 sub $0x10,%esp
kinit1(end, P2V(4*1024*1024)); // phys page allocator
80102def: c7 44 24 04 00 00 40 movl $0x80400000,0x4(%esp)
80102df6: 80
80102df7: c7 04 24 f4 58 11 80 movl $0x801158f4,(%esp)
80102dfe: e8 cd f5 ff ff call 801023d0 <kinit1>
kvmalloc(); // kernel page table
80102e03: e8 b8 3c 00 00 call 80106ac0 <kvmalloc>
mpinit(); // detect other processors
80102e08: e8 73 01 00 00 call 80102f80 <mpinit>
80102e0d: 8d 76 00 lea 0x0(%esi),%esi
lapicinit(); // interrupt controller
80102e10: e8 4b f8 ff ff call 80102660 <lapicinit>
seginit(); // segment descriptors
80102e15: e8 b6 36 00 00 call 801064d0 <seginit>
picinit(); // disable pic
80102e1a: e8 21 03 00 00 call 80103140 <picinit>
80102e1f: 90 nop
ioapicinit(); // another interrupt controller
80102e20: e8 cb f3 ff ff call 801021f0 <ioapicinit>
consoleinit(); // console hardware
80102e25: e8 26 db ff ff call 80100950 <consoleinit>
uartinit(); // serial port
80102e2a: e8 41 2a 00 00 call 80105870 <uartinit>
80102e2f: 90 nop
pinit(); // process table
80102e30: e8 9b 07 00 00 call 801035d0 <pinit>
shminit(); // shared memory
80102e35: e8 56 3f 00 00 call 80106d90 <shminit>
tvinit(); // trap vectors
80102e3a: e8 f1 25 00 00 call 80105430 <tvinit>
80102e3f: 90 nop
binit(); // buffer cache
80102e40: e8 fb d1 ff ff call 80100040 <binit>
fileinit(); // file table
80102e45: e8 e6 de ff ff call 80100d30 <fileinit>
ideinit(); // disk
80102e4a: e8 a1 f1 ff ff call 80101ff0 <ideinit>
memmove(code, _binary_entryother_start, (uint)_binary_entryother_size);
80102e4f: c7 44 24 08 8a 00 00 movl $0x8a,0x8(%esp)
80102e56: 00
80102e57: c7 44 24 04 8c a4 10 movl $0x8010a48c,0x4(%esp)
80102e5e: 80
80102e5f: c7 04 24 00 70 00 80 movl $0x80007000,(%esp)
80102e66: e8 a5 14 00 00 call 80104310 <memmove>
for(c = cpus; c < cpus+ncpu; c++){
80102e6b: 69 05 00 2d 11 80 b0 imul $0xb0,0x80112d00,%eax
80102e72: 00 00 00
80102e75: 05 80 27 11 80 add $0x80112780,%eax
80102e7a: 39 d8 cmp %ebx,%eax
80102e7c: 76 65 jbe 80102ee3 <main+0x103>
80102e7e: 66 90 xchg %ax,%ax
if(c == mycpu()) // We've started already.
80102e80: e8 6b 07 00 00 call 801035f0 <mycpu>
80102e85: 39 d8 cmp %ebx,%eax
80102e87: 74 41 je 80102eca <main+0xea>
continue;
// Tell entryother.S what stack to use, where to enter, and what
// pgdir to use. We cannot use kpgdir yet, because the AP processor
// is running in low memory, so we use entrypgdir for the APs too.
stack = kalloc();
80102e89: e8 02 f6 ff ff call 80102490 <kalloc>
*(void**)(code-4) = stack + KSTACKSIZE;
*(void**)(code-8) = mpenter;
80102e8e: c7 05 f8 6f 00 80 c0 movl $0x80102dc0,0x80006ff8
80102e95: 2d 10 80
*(int**)(code-12) = (void *) V2P(entrypgdir);
80102e98: c7 05 f4 6f 00 80 00 movl $0x109000,0x80006ff4
80102e9f: 90 10 00
*(void**)(code-4) = stack + KSTACKSIZE;
80102ea2: 05 00 10 00 00 add $0x1000,%eax
80102ea7: a3 fc 6f 00 80 mov %eax,0x80006ffc
lapicstartap(c->apicid, V2P(code));
80102eac: 0f b6 03 movzbl (%ebx),%eax
80102eaf: c7 44 24 04 00 70 00 movl $0x7000,0x4(%esp)
80102eb6: 00
80102eb7: 89 04 24 mov %eax,(%esp)
80102eba: e8 e1 f8 ff ff call 801027a0 <lapicstartap>
80102ebf: 90 nop
// wait for cpu to finish mpmain()
while(c->started == 0)
80102ec0: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax
80102ec6: 85 c0 test %eax,%eax
80102ec8: 74 f6 je 80102ec0 <main+0xe0>
for(c = cpus; c < cpus+ncpu; c++){
80102eca: 69 05 00 2d 11 80 b0 imul $0xb0,0x80112d00,%eax
80102ed1: 00 00 00
80102ed4: 81 c3 b0 00 00 00 add $0xb0,%ebx
80102eda: 05 80 27 11 80 add $0x80112780,%eax
80102edf: 39 c3 cmp %eax,%ebx
80102ee1: 72 9d jb 80102e80 <main+0xa0>
kinit2(P2V(4*1024*1024), P2V(PHYSTOP)); // must come after startothers()
80102ee3: c7 44 24 04 00 00 00 movl $0x8e000000,0x4(%esp)
80102eea: 8e
80102eeb: c7 04 24 00 00 40 80 movl $0x80400000,(%esp)
80102ef2: e8 49 f5 ff ff call 80102440 <kinit2>
userinit(); // first user process
80102ef7: e8 c4 07 00 00 call 801036c0 <userinit>
mpmain(); // finish this processor's setup
80102efc: e8 6f fe ff ff call 80102d70 <mpmain>
80102f01: 66 90 xchg %ax,%ax
80102f03: 66 90 xchg %ax,%ax
80102f05: 66 90 xchg %ax,%ax
80102f07: 66 90 xchg %ax,%ax
80102f09: 66 90 xchg %ax,%ax
80102f0b: 66 90 xchg %ax,%ax
80102f0d: 66 90 xchg %ax,%ax
80102f0f: 90 nop
80102f10 <mpsearch1>:
}
// Look for an MP structure in the len bytes at addr.
static struct mp*
mpsearch1(uint a, int len)
{
80102f10: 55 push %ebp
80102f11: 89 e5 mov %esp,%ebp
80102f13: 56 push %esi
uchar *e, *p, *addr;
addr = P2V(a);
80102f14: 8d b0 00 00 00 80 lea -0x80000000(%eax),%esi
{
80102f1a: 53 push %ebx
e = addr+len;
80102f1b: 8d 1c 16 lea (%esi,%edx,1),%ebx
{
80102f1e: 83 ec 10 sub $0x10,%esp
for(p = addr; p < e; p += sizeof(struct mp))
80102f21: 39 de cmp %ebx,%esi
80102f23: 73 3c jae 80102f61 <mpsearch1+0x51>
80102f25: 8d 76 00 lea 0x0(%esi),%esi
if(memcmp(p, "_MP_", 4) == 0 && sum(p, sizeof(struct mp)) == 0)
80102f28: c7 44 24 08 04 00 00 movl $0x4,0x8(%esp)
80102f2f: 00
80102f30: c7 44 24 04 18 73 10 movl $0x80107318,0x4(%esp)
80102f37: 80
80102f38: 89 34 24 mov %esi,(%esp)
80102f3b: e8 80 13 00 00 call 801042c0 <memcmp>
80102f40: 85 c0 test %eax,%eax
80102f42: 75 16 jne 80102f5a <mpsearch1+0x4a>
80102f44: 31 c9 xor %ecx,%ecx
80102f46: 31 d2 xor %edx,%edx
sum += addr[i];
80102f48: 0f b6 04 16 movzbl (%esi,%edx,1),%eax
for(i=0; i<len; i++)
80102f4c: 83 c2 01 add $0x1,%edx
sum += addr[i];
80102f4f: 01 c1 add %eax,%ecx
for(i=0; i<len; i++)
80102f51: 83 fa 10 cmp $0x10,%edx
80102f54: 75 f2 jne 80102f48 <mpsearch1+0x38>
if(memcmp(p, "_MP_", 4) == 0 && sum(p, sizeof(struct mp)) == 0)
80102f56: 84 c9 test %cl,%cl
80102f58: 74 10 je 80102f6a <mpsearch1+0x5a>
for(p = addr; p < e; p += sizeof(struct mp))
80102f5a: 83 c6 10 add $0x10,%esi
80102f5d: 39 f3 cmp %esi,%ebx
80102f5f: 77 c7 ja 80102f28 <mpsearch1+0x18>
return (struct mp*)p;
return 0;
}
80102f61: 83 c4 10 add $0x10,%esp
return 0;
80102f64: 31 c0 xor %eax,%eax
}
80102f66: 5b pop %ebx
80102f67: 5e pop %esi
80102f68: 5d pop %ebp
80102f69: c3 ret
80102f6a: 83 c4 10 add $0x10,%esp
80102f6d: 89 f0 mov %esi,%eax
80102f6f: 5b pop %ebx
80102f70: 5e pop %esi
80102f71: 5d pop %ebp
80102f72: c3 ret
80102f73: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80102f79: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80102f80 <mpinit>:
return conf;
}
void
mpinit(void)
{
80102f80: 55 push %ebp
80102f81: 89 e5 mov %esp,%ebp
80102f83: 57 push %edi
80102f84: 56 push %esi
80102f85: 53 push %ebx
80102f86: 83 ec 1c sub $0x1c,%esp
if((p = ((bda[0x0F]<<8)| bda[0x0E]) << 4)){
80102f89: 0f b6 05 0f 04 00 80 movzbl 0x8000040f,%eax
80102f90: 0f b6 15 0e 04 00 80 movzbl 0x8000040e,%edx
80102f97: c1 e0 08 shl $0x8,%eax
80102f9a: 09 d0 or %edx,%eax
80102f9c: c1 e0 04 shl $0x4,%eax
80102f9f: 85 c0 test %eax,%eax
80102fa1: 75 1b jne 80102fbe <mpinit+0x3e>
p = ((bda[0x14]<<8)|bda[0x13])*1024;
80102fa3: 0f b6 05 14 04 00 80 movzbl 0x80000414,%eax
80102faa: 0f b6 15 13 04 00 80 movzbl 0x80000413,%edx
80102fb1: c1 e0 08 shl $0x8,%eax
80102fb4: 09 d0 or %edx,%eax
80102fb6: c1 e0 0a shl $0xa,%eax
if((mp = mpsearch1(p-1024, 1024)))
80102fb9: 2d 00 04 00 00 sub $0x400,%eax
if((mp = mpsearch1(p, 1024)))
80102fbe: ba 00 04 00 00 mov $0x400,%edx
80102fc3: e8 48 ff ff ff call 80102f10 <mpsearch1>
80102fc8: 85 c0 test %eax,%eax
80102fca: 89 c7 mov %eax,%edi
80102fcc: 0f 84 22 01 00 00 je 801030f4 <mpinit+0x174>
if((mp = mpsearch()) == 0 || mp->physaddr == 0)
80102fd2: 8b 77 04 mov 0x4(%edi),%esi
80102fd5: 85 f6 test %esi,%esi
80102fd7: 0f 84 30 01 00 00 je 8010310d <mpinit+0x18d>
conf = (struct mpconf*) P2V((uint) mp->physaddr);
80102fdd: 8d 86 00 00 00 80 lea -0x80000000(%esi),%eax
if(memcmp(conf, "PCMP", 4) != 0)
80102fe3: c7 44 24 08 04 00 00 movl $0x4,0x8(%esp)
80102fea: 00
80102feb: c7 44 24 04 1d 73 10 movl $0x8010731d,0x4(%esp)
80102ff2: 80
80102ff3: 89 04 24 mov %eax,(%esp)
conf = (struct mpconf*) P2V((uint) mp->physaddr);
80102ff6: 89 45 e4 mov %eax,-0x1c(%ebp)
if(memcmp(conf, "PCMP", 4) != 0)
80102ff9: e8 c2 12 00 00 call 801042c0 <memcmp>
80102ffe: 85 c0 test %eax,%eax
80103000: 0f 85 07 01 00 00 jne 8010310d <mpinit+0x18d>
if(conf->version != 1 && conf->version != 4)
80103006: 0f b6 86 06 00 00 80 movzbl -0x7ffffffa(%esi),%eax
8010300d: 3c 04 cmp $0x4,%al
8010300f: 0f 85 0b 01 00 00 jne 80103120 <mpinit+0x1a0>
if(sum((uchar*)conf, conf->length) != 0)
80103015: 0f b7 86 04 00 00 80 movzwl -0x7ffffffc(%esi),%eax
for(i=0; i<len; i++)
8010301c: 85 c0 test %eax,%eax
8010301e: 74 21 je 80103041 <mpinit+0xc1>
sum = 0;
80103020: 31 c9 xor %ecx,%ecx
for(i=0; i<len; i++)
80103022: 31 d2 xor %edx,%edx
80103024: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
sum += addr[i];
80103028: 0f b6 9c 16 00 00 00 movzbl -0x80000000(%esi,%edx,1),%ebx
8010302f: 80
for(i=0; i<len; i++)
80103030: 83 c2 01 add $0x1,%edx
sum += addr[i];
80103033: 01 d9 add %ebx,%ecx
for(i=0; i<len; i++)
80103035: 39 d0 cmp %edx,%eax
80103037: 7f ef jg 80103028 <mpinit+0xa8>
if(sum((uchar*)conf, conf->length) != 0)
80103039: 84 c9 test %cl,%cl
8010303b: 0f 85 cc 00 00 00 jne 8010310d <mpinit+0x18d>
struct mp *mp;
struct mpconf *conf;
struct mpproc *proc;
struct mpioapic *ioapic;
if((conf = mpconfig(&mp)) == 0)
80103041: 8b 45 e4 mov -0x1c(%ebp),%eax
80103044: 85 c0 test %eax,%eax
80103046: 0f 84 c1 00 00 00 je 8010310d <mpinit+0x18d>
panic("Expect to run on an SMP");
ismp = 1;
lapic = (uint*)conf->lapicaddr;
8010304c: 8b 86 24 00 00 80 mov -0x7fffffdc(%esi),%eax
ismp = 1;
80103052: bb 01 00 00 00 mov $0x1,%ebx
lapic = (uint*)conf->lapicaddr;
80103057: a3 7c 26 11 80 mov %eax,0x8011267c
for(p=(uchar*)(conf+1), e=(uchar*)conf+conf->length; p<e; ){
8010305c: 0f b7 96 04 00 00 80 movzwl -0x7ffffffc(%esi),%edx
80103063: 8d 86 2c 00 00 80 lea -0x7fffffd4(%esi),%eax
80103069: 03 55 e4 add -0x1c(%ebp),%edx
8010306c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80103070: 39 c2 cmp %eax,%edx
80103072: 76 1b jbe 8010308f <mpinit+0x10f>
80103074: 0f b6 08 movzbl (%eax),%ecx
switch(*p){
80103077: 80 f9 04 cmp $0x4,%cl
8010307a: 77 74 ja 801030f0 <mpinit+0x170>
8010307c: ff 24 8d 5c 73 10 80 jmp *-0x7fef8ca4(,%ecx,4)
80103083: 90 nop
80103084: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
p += sizeof(struct mpioapic);
continue;
case MPBUS:
case MPIOINTR:
case MPLINTR:
p += 8;
80103088: 83 c0 08 add $0x8,%eax
for(p=(uchar*)(conf+1), e=(uchar*)conf+conf->length; p<e; ){
8010308b: 39 c2 cmp %eax,%edx
8010308d: 77 e5 ja 80103074 <mpinit+0xf4>
default:
ismp = 0;
break;
}
}
if(!ismp)
8010308f: 85 db test %ebx,%ebx
80103091: 0f 84 93 00 00 00 je 8010312a <mpinit+0x1aa>
panic("Didn't find a suitable machine");
if(mp->imcrp){
80103097: 80 7f 0c 00 cmpb $0x0,0xc(%edi)
8010309b: 74 12 je 801030af <mpinit+0x12f>
asm volatile("out %0,%1" : : "a" (data), "d" (port));
8010309d: ba 22 00 00 00 mov $0x22,%edx
801030a2: b8 70 00 00 00 mov $0x70,%eax
801030a7: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
801030a8: b2 23 mov $0x23,%dl
801030aa: ec in (%dx),%al
// Bochs doesn't support IMCR, so this doesn't run on Bochs.
// But it would on real hardware.
outb(0x22, 0x70); // Select IMCR
outb(0x23, inb(0x23) | 1); // Mask external interrupts.
801030ab: 83 c8 01 or $0x1,%eax
asm volatile("out %0,%1" : : "a" (data), "d" (port));
801030ae: ee out %al,(%dx)
}
}
801030af: 83 c4 1c add $0x1c,%esp
801030b2: 5b pop %ebx
801030b3: 5e pop %esi
801030b4: 5f pop %edi
801030b5: 5d pop %ebp
801030b6: c3 ret
801030b7: 90 nop
if(ncpu < NCPU) {
801030b8: 8b 35 00 2d 11 80 mov 0x80112d00,%esi
801030be: 83 fe 07 cmp $0x7,%esi
801030c1: 7f 17 jg 801030da <mpinit+0x15a>
cpus[ncpu].apicid = proc->apicid; // apicid may differ from ncpu
801030c3: 0f b6 48 01 movzbl 0x1(%eax),%ecx
801030c7: 69 f6 b0 00 00 00 imul $0xb0,%esi,%esi
ncpu++;
801030cd: 83 05 00 2d 11 80 01 addl $0x1,0x80112d00
cpus[ncpu].apicid = proc->apicid; // apicid may differ from ncpu
801030d4: 88 8e 80 27 11 80 mov %cl,-0x7feed880(%esi)
p += sizeof(struct mpproc);
801030da: 83 c0 14 add $0x14,%eax
continue;
801030dd: eb 91 jmp 80103070 <mpinit+0xf0>
801030df: 90 nop
ioapicid = ioapic->apicno;
801030e0: 0f b6 48 01 movzbl 0x1(%eax),%ecx
p += sizeof(struct mpioapic);
801030e4: 83 c0 08 add $0x8,%eax
ioapicid = ioapic->apicno;
801030e7: 88 0d 60 27 11 80 mov %cl,0x80112760
continue;
801030ed: eb 81 jmp 80103070 <mpinit+0xf0>
801030ef: 90 nop
ismp = 0;
801030f0: 31 db xor %ebx,%ebx
801030f2: eb 83 jmp 80103077 <mpinit+0xf7>
return mpsearch1(0xF0000, 0x10000);
801030f4: ba 00 00 01 00 mov $0x10000,%edx
801030f9: b8 00 00 0f 00 mov $0xf0000,%eax
801030fe: e8 0d fe ff ff call 80102f10 <mpsearch1>
if((mp = mpsearch()) == 0 || mp->physaddr == 0)
80103103: 85 c0 test %eax,%eax
return mpsearch1(0xF0000, 0x10000);
80103105: 89 c7 mov %eax,%edi
if((mp = mpsearch()) == 0 || mp->physaddr == 0)
80103107: 0f 85 c5 fe ff ff jne 80102fd2 <mpinit+0x52>
panic("Expect to run on an SMP");
8010310d: c7 04 24 22 73 10 80 movl $0x80107322,(%esp)
80103114: e8 47 d2 ff ff call 80100360 <panic>
80103119: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if(conf->version != 1 && conf->version != 4)
80103120: 3c 01 cmp $0x1,%al
80103122: 0f 84 ed fe ff ff je 80103015 <mpinit+0x95>
80103128: eb e3 jmp 8010310d <mpinit+0x18d>
panic("Didn't find a suitable machine");
8010312a: c7 04 24 3c 73 10 80 movl $0x8010733c,(%esp)
80103131: e8 2a d2 ff ff call 80100360 <panic>
80103136: 66 90 xchg %ax,%ax
80103138: 66 90 xchg %ax,%ax
8010313a: 66 90 xchg %ax,%ax
8010313c: 66 90 xchg %ax,%ax
8010313e: 66 90 xchg %ax,%ax
80103140 <picinit>:
#define IO_PIC2 0xA0 // Slave (IRQs 8-15)
// Don't use the 8259A interrupt controllers. Xv6 assumes SMP hardware.
void
picinit(void)
{
80103140: 55 push %ebp
80103141: ba 21 00 00 00 mov $0x21,%edx
80103146: 89 e5 mov %esp,%ebp
80103148: b8 ff ff ff ff mov $0xffffffff,%eax
8010314d: ee out %al,(%dx)
8010314e: b2 a1 mov $0xa1,%dl
80103150: ee out %al,(%dx)
// mask all interrupts
outb(IO_PIC1+1, 0xFF);
outb(IO_PIC2+1, 0xFF);
}
80103151: 5d pop %ebp
80103152: c3 ret
80103153: 66 90 xchg %ax,%ax
80103155: 66 90 xchg %ax,%ax
80103157: 66 90 xchg %ax,%ax
80103159: 66 90 xchg %ax,%ax
8010315b: 66 90 xchg %ax,%ax
8010315d: 66 90 xchg %ax,%ax
8010315f: 90 nop
80103160 <pipealloc>:
int writeopen; // write fd is still open
};
int
pipealloc(struct file **f0, struct file **f1)
{
80103160: 55 push %ebp
80103161: 89 e5 mov %esp,%ebp
80103163: 57 push %edi
80103164: 56 push %esi
80103165: 53 push %ebx
80103166: 83 ec 1c sub $0x1c,%esp
80103169: 8b 75 08 mov 0x8(%ebp),%esi
8010316c: 8b 5d 0c mov 0xc(%ebp),%ebx
struct pipe *p;
p = 0;
*f0 = *f1 = 0;
8010316f: c7 03 00 00 00 00 movl $0x0,(%ebx)
80103175: c7 06 00 00 00 00 movl $0x0,(%esi)
if((*f0 = filealloc()) == 0 || (*f1 = filealloc()) == 0)
8010317b: e8 d0 db ff ff call 80100d50 <filealloc>
80103180: 85 c0 test %eax,%eax
80103182: 89 06 mov %eax,(%esi)
80103184: 0f 84 a4 00 00 00 je 8010322e <pipealloc+0xce>
8010318a: e8 c1 db ff ff call 80100d50 <filealloc>
8010318f: 85 c0 test %eax,%eax
80103191: 89 03 mov %eax,(%ebx)
80103193: 0f 84 87 00 00 00 je 80103220 <pipealloc+0xc0>
goto bad;
if((p = (struct pipe*)kalloc()) == 0)
80103199: e8 f2 f2 ff ff call 80102490 <kalloc>
8010319e: 85 c0 test %eax,%eax
801031a0: 89 c7 mov %eax,%edi
801031a2: 74 7c je 80103220 <pipealloc+0xc0>
goto bad;
p->readopen = 1;
801031a4: c7 80 3c 02 00 00 01 movl $0x1,0x23c(%eax)
801031ab: 00 00 00
p->writeopen = 1;
801031ae: c7 80 40 02 00 00 01 movl $0x1,0x240(%eax)
801031b5: 00 00 00
p->nwrite = 0;
801031b8: c7 80 38 02 00 00 00 movl $0x0,0x238(%eax)
801031bf: 00 00 00
p->nread = 0;
801031c2: c7 80 34 02 00 00 00 movl $0x0,0x234(%eax)
801031c9: 00 00 00
initlock(&p->lock, "pipe");
801031cc: 89 04 24 mov %eax,(%esp)
801031cf: c7 44 24 04 70 73 10 movl $0x80107370,0x4(%esp)
801031d6: 80
801031d7: e8 64 0e 00 00 call 80104040 <initlock>
(*f0)->type = FD_PIPE;
801031dc: 8b 06 mov (%esi),%eax
801031de: c7 00 01 00 00 00 movl $0x1,(%eax)
(*f0)->readable = 1;
801031e4: 8b 06 mov (%esi),%eax
801031e6: c6 40 08 01 movb $0x1,0x8(%eax)
(*f0)->writable = 0;
801031ea: 8b 06 mov (%esi),%eax
801031ec: c6 40 09 00 movb $0x0,0x9(%eax)
(*f0)->pipe = p;
801031f0: 8b 06 mov (%esi),%eax
801031f2: 89 78 0c mov %edi,0xc(%eax)
(*f1)->type = FD_PIPE;
801031f5: 8b 03 mov (%ebx),%eax
801031f7: c7 00 01 00 00 00 movl $0x1,(%eax)
(*f1)->readable = 0;
801031fd: 8b 03 mov (%ebx),%eax
801031ff: c6 40 08 00 movb $0x0,0x8(%eax)
(*f1)->writable = 1;
80103203: 8b 03 mov (%ebx),%eax
80103205: c6 40 09 01 movb $0x1,0x9(%eax)
(*f1)->pipe = p;
80103209: 8b 03 mov (%ebx),%eax
return 0;
8010320b: 31 db xor %ebx,%ebx
(*f1)->pipe = p;
8010320d: 89 78 0c mov %edi,0xc(%eax)
if(*f0)
fileclose(*f0);
if(*f1)
fileclose(*f1);
return -1;
}
80103210: 83 c4 1c add $0x1c,%esp
80103213: 89 d8 mov %ebx,%eax
80103215: 5b pop %ebx
80103216: 5e pop %esi
80103217: 5f pop %edi
80103218: 5d pop %ebp
80103219: c3 ret
8010321a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if(*f0)
80103220: 8b 06 mov (%esi),%eax
80103222: 85 c0 test %eax,%eax
80103224: 74 08 je 8010322e <pipealloc+0xce>
fileclose(*f0);
80103226: 89 04 24 mov %eax,(%esp)
80103229: e8 e2 db ff ff call 80100e10 <fileclose>
if(*f1)
8010322e: 8b 03 mov (%ebx),%eax
return -1;
80103230: bb ff ff ff ff mov $0xffffffff,%ebx
if(*f1)
80103235: 85 c0 test %eax,%eax
80103237: 74 d7 je 80103210 <pipealloc+0xb0>
fileclose(*f1);
80103239: 89 04 24 mov %eax,(%esp)
8010323c: e8 cf db ff ff call 80100e10 <fileclose>
}
80103241: 83 c4 1c add $0x1c,%esp
80103244: 89 d8 mov %ebx,%eax
80103246: 5b pop %ebx
80103247: 5e pop %esi
80103248: 5f pop %edi
80103249: 5d pop %ebp
8010324a: c3 ret
8010324b: 90 nop
8010324c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80103250 <pipeclose>:
void
pipeclose(struct pipe *p, int writable)
{
80103250: 55 push %ebp
80103251: 89 e5 mov %esp,%ebp
80103253: 56 push %esi
80103254: 53 push %ebx
80103255: 83 ec 10 sub $0x10,%esp
80103258: 8b 5d 08 mov 0x8(%ebp),%ebx
8010325b: 8b 75 0c mov 0xc(%ebp),%esi
acquire(&p->lock);
8010325e: 89 1c 24 mov %ebx,(%esp)
80103261: e8 ca 0e 00 00 call 80104130 <acquire>
if(writable){
80103266: 85 f6 test %esi,%esi
80103268: 74 3e je 801032a8 <pipeclose+0x58>
p->writeopen = 0;
wakeup(&p->nread);
8010326a: 8d 83 34 02 00 00 lea 0x234(%ebx),%eax
p->writeopen = 0;
80103270: c7 83 40 02 00 00 00 movl $0x0,0x240(%ebx)
80103277: 00 00 00
wakeup(&p->nread);
8010327a: 89 04 24 mov %eax,(%esp)
8010327d: e8 fe 0a 00 00 call 80103d80 <wakeup>
} else {
p->readopen = 0;
wakeup(&p->nwrite);
}
if(p->readopen == 0 && p->writeopen == 0){
80103282: 8b 93 3c 02 00 00 mov 0x23c(%ebx),%edx
80103288: 85 d2 test %edx,%edx
8010328a: 75 0a jne 80103296 <pipeclose+0x46>
8010328c: 8b 83 40 02 00 00 mov 0x240(%ebx),%eax
80103292: 85 c0 test %eax,%eax
80103294: 74 32 je 801032c8 <pipeclose+0x78>
release(&p->lock);
kfree((char*)p);
} else
release(&p->lock);
80103296: 89 5d 08 mov %ebx,0x8(%ebp)
}
80103299: 83 c4 10 add $0x10,%esp
8010329c: 5b pop %ebx
8010329d: 5e pop %esi
8010329e: 5d pop %ebp
release(&p->lock);
8010329f: e9 7c 0f 00 00 jmp 80104220 <release>
801032a4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
wakeup(&p->nwrite);
801032a8: 8d 83 38 02 00 00 lea 0x238(%ebx),%eax
p->readopen = 0;
801032ae: c7 83 3c 02 00 00 00 movl $0x0,0x23c(%ebx)
801032b5: 00 00 00
wakeup(&p->nwrite);
801032b8: 89 04 24 mov %eax,(%esp)
801032bb: e8 c0 0a 00 00 call 80103d80 <wakeup>
801032c0: eb c0 jmp 80103282 <pipeclose+0x32>
801032c2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
release(&p->lock);
801032c8: 89 1c 24 mov %ebx,(%esp)
801032cb: e8 50 0f 00 00 call 80104220 <release>
kfree((char*)p);
801032d0: 89 5d 08 mov %ebx,0x8(%ebp)
}
801032d3: 83 c4 10 add $0x10,%esp
801032d6: 5b pop %ebx
801032d7: 5e pop %esi
801032d8: 5d pop %ebp
kfree((char*)p);
801032d9: e9 02 f0 ff ff jmp 801022e0 <kfree>
801032de: 66 90 xchg %ax,%ax
801032e0 <pipewrite>:
//PAGEBREAK: 40
int
pipewrite(struct pipe *p, char *addr, int n)
{
801032e0: 55 push %ebp
801032e1: 89 e5 mov %esp,%ebp
801032e3: 57 push %edi
801032e4: 56 push %esi
801032e5: 53 push %ebx
801032e6: 83 ec 1c sub $0x1c,%esp
801032e9: 8b 5d 08 mov 0x8(%ebp),%ebx
int i;
acquire(&p->lock);
801032ec: 89 1c 24 mov %ebx,(%esp)
801032ef: e8 3c 0e 00 00 call 80104130 <acquire>
for(i = 0; i < n; i++){
801032f4: 8b 4d 10 mov 0x10(%ebp),%ecx
801032f7: 85 c9 test %ecx,%ecx
801032f9: 0f 8e b2 00 00 00 jle 801033b1 <pipewrite+0xd1>
801032ff: 8b 4d 0c mov 0xc(%ebp),%ecx
while(p->nwrite == p->nread + PIPESIZE){ //DOC: pipewrite-full
if(p->readopen == 0 || myproc()->killed){
release(&p->lock);
return -1;
}
wakeup(&p->nread);
80103302: 8d bb 34 02 00 00 lea 0x234(%ebx),%edi
80103308: 8b 83 38 02 00 00 mov 0x238(%ebx),%eax
sleep(&p->nwrite, &p->lock); //DOC: pipewrite-sleep
8010330e: 8d b3 38 02 00 00 lea 0x238(%ebx),%esi
80103314: 89 4d e4 mov %ecx,-0x1c(%ebp)
80103317: 03 4d 10 add 0x10(%ebp),%ecx
8010331a: 89 4d e0 mov %ecx,-0x20(%ebp)
while(p->nwrite == p->nread + PIPESIZE){ //DOC: pipewrite-full
8010331d: 8b 8b 34 02 00 00 mov 0x234(%ebx),%ecx
80103323: 81 c1 00 02 00 00 add $0x200,%ecx
80103329: 39 c8 cmp %ecx,%eax
8010332b: 74 38 je 80103365 <pipewrite+0x85>
8010332d: eb 55 jmp 80103384 <pipewrite+0xa4>
8010332f: 90 nop
if(p->readopen == 0 || myproc()->killed){
80103330: e8 5b 03 00 00 call 80103690 <myproc>
80103335: 8b 40 28 mov 0x28(%eax),%eax
80103338: 85 c0 test %eax,%eax
8010333a: 75 33 jne 8010336f <pipewrite+0x8f>
wakeup(&p->nread);
8010333c: 89 3c 24 mov %edi,(%esp)
8010333f: e8 3c 0a 00 00 call 80103d80 <wakeup>
sleep(&p->nwrite, &p->lock); //DOC: pipewrite-sleep
80103344: 89 5c 24 04 mov %ebx,0x4(%esp)
80103348: 89 34 24 mov %esi,(%esp)
8010334b: e8 a0 08 00 00 call 80103bf0 <sleep>
while(p->nwrite == p->nread + PIPESIZE){ //DOC: pipewrite-full
80103350: 8b 83 34 02 00 00 mov 0x234(%ebx),%eax
80103356: 8b 93 38 02 00 00 mov 0x238(%ebx),%edx
8010335c: 05 00 02 00 00 add $0x200,%eax
80103361: 39 c2 cmp %eax,%edx
80103363: 75 23 jne 80103388 <pipewrite+0xa8>
if(p->readopen == 0 || myproc()->killed){
80103365: 8b 93 3c 02 00 00 mov 0x23c(%ebx),%edx
8010336b: 85 d2 test %edx,%edx
8010336d: 75 c1 jne 80103330 <pipewrite+0x50>
release(&p->lock);
8010336f: 89 1c 24 mov %ebx,(%esp)
80103372: e8 a9 0e 00 00 call 80104220 <release>
return -1;
80103377: b8 ff ff ff ff mov $0xffffffff,%eax
p->data[p->nwrite++ % PIPESIZE] = addr[i];
}
wakeup(&p->nread); //DOC: pipewrite-wakeup1
release(&p->lock);
return n;
}
8010337c: 83 c4 1c add $0x1c,%esp
8010337f: 5b pop %ebx
80103380: 5e pop %esi
80103381: 5f pop %edi
80103382: 5d pop %ebp
80103383: c3 ret
while(p->nwrite == p->nread + PIPESIZE){ //DOC: pipewrite-full
80103384: 89 c2 mov %eax,%edx
80103386: 66 90 xchg %ax,%ax
p->data[p->nwrite++ % PIPESIZE] = addr[i];
80103388: 8b 4d e4 mov -0x1c(%ebp),%ecx
8010338b: 8d 42 01 lea 0x1(%edx),%eax
8010338e: 81 e2 ff 01 00 00 and $0x1ff,%edx
80103394: 89 83 38 02 00 00 mov %eax,0x238(%ebx)
8010339a: 83 45 e4 01 addl $0x1,-0x1c(%ebp)
8010339e: 0f b6 09 movzbl (%ecx),%ecx
801033a1: 88 4c 13 34 mov %cl,0x34(%ebx,%edx,1)
for(i = 0; i < n; i++){
801033a5: 8b 4d e4 mov -0x1c(%ebp),%ecx
801033a8: 3b 4d e0 cmp -0x20(%ebp),%ecx
801033ab: 0f 85 6c ff ff ff jne 8010331d <pipewrite+0x3d>
wakeup(&p->nread); //DOC: pipewrite-wakeup1
801033b1: 8d 83 34 02 00 00 lea 0x234(%ebx),%eax
801033b7: 89 04 24 mov %eax,(%esp)
801033ba: e8 c1 09 00 00 call 80103d80 <wakeup>
release(&p->lock);
801033bf: 89 1c 24 mov %ebx,(%esp)
801033c2: e8 59 0e 00 00 call 80104220 <release>
return n;
801033c7: 8b 45 10 mov 0x10(%ebp),%eax
801033ca: eb b0 jmp 8010337c <pipewrite+0x9c>
801033cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801033d0 <piperead>:
int
piperead(struct pipe *p, char *addr, int n)
{
801033d0: 55 push %ebp
801033d1: 89 e5 mov %esp,%ebp
801033d3: 57 push %edi
801033d4: 56 push %esi
801033d5: 53 push %ebx
801033d6: 83 ec 1c sub $0x1c,%esp
801033d9: 8b 75 08 mov 0x8(%ebp),%esi
801033dc: 8b 7d 0c mov 0xc(%ebp),%edi
int i;
acquire(&p->lock);
801033df: 89 34 24 mov %esi,(%esp)
801033e2: e8 49 0d 00 00 call 80104130 <acquire>
while(p->nread == p->nwrite && p->writeopen){ //DOC: pipe-empty
801033e7: 8b 86 34 02 00 00 mov 0x234(%esi),%eax
801033ed: 3b 86 38 02 00 00 cmp 0x238(%esi),%eax
801033f3: 75 5b jne 80103450 <piperead+0x80>
801033f5: 8b 9e 40 02 00 00 mov 0x240(%esi),%ebx
801033fb: 85 db test %ebx,%ebx
801033fd: 74 51 je 80103450 <piperead+0x80>
if(myproc()->killed){
release(&p->lock);
return -1;
}
sleep(&p->nread, &p->lock); //DOC: piperead-sleep
801033ff: 8d 9e 34 02 00 00 lea 0x234(%esi),%ebx
80103405: eb 25 jmp 8010342c <piperead+0x5c>
80103407: 90 nop
80103408: 89 74 24 04 mov %esi,0x4(%esp)
8010340c: 89 1c 24 mov %ebx,(%esp)
8010340f: e8 dc 07 00 00 call 80103bf0 <sleep>
while(p->nread == p->nwrite && p->writeopen){ //DOC: pipe-empty
80103414: 8b 86 34 02 00 00 mov 0x234(%esi),%eax
8010341a: 3b 86 38 02 00 00 cmp 0x238(%esi),%eax
80103420: 75 2e jne 80103450 <piperead+0x80>
80103422: 8b 96 40 02 00 00 mov 0x240(%esi),%edx
80103428: 85 d2 test %edx,%edx
8010342a: 74 24 je 80103450 <piperead+0x80>
if(myproc()->killed){
8010342c: e8 5f 02 00 00 call 80103690 <myproc>
80103431: 8b 48 28 mov 0x28(%eax),%ecx
80103434: 85 c9 test %ecx,%ecx
80103436: 74 d0 je 80103408 <piperead+0x38>
release(&p->lock);
80103438: 89 34 24 mov %esi,(%esp)
8010343b: e8 e0 0d 00 00 call 80104220 <release>
addr[i] = p->data[p->nread++ % PIPESIZE];
}
wakeup(&p->nwrite); //DOC: piperead-wakeup
release(&p->lock);
return i;
}
80103440: 83 c4 1c add $0x1c,%esp
return -1;
80103443: b8 ff ff ff ff mov $0xffffffff,%eax
}
80103448: 5b pop %ebx
80103449: 5e pop %esi
8010344a: 5f pop %edi
8010344b: 5d pop %ebp
8010344c: c3 ret
8010344d: 8d 76 00 lea 0x0(%esi),%esi
for(i = 0; i < n; i++){ //DOC: piperead-copy
80103450: 8b 55 10 mov 0x10(%ebp),%edx
if(p->nread == p->nwrite)
80103453: 31 db xor %ebx,%ebx
for(i = 0; i < n; i++){ //DOC: piperead-copy
80103455: 85 d2 test %edx,%edx
80103457: 7f 2b jg 80103484 <piperead+0xb4>
80103459: eb 31 jmp 8010348c <piperead+0xbc>
8010345b: 90 nop
8010345c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
addr[i] = p->data[p->nread++ % PIPESIZE];
80103460: 8d 48 01 lea 0x1(%eax),%ecx
80103463: 25 ff 01 00 00 and $0x1ff,%eax
80103468: 89 8e 34 02 00 00 mov %ecx,0x234(%esi)
8010346e: 0f b6 44 06 34 movzbl 0x34(%esi,%eax,1),%eax
80103473: 88 04 1f mov %al,(%edi,%ebx,1)
for(i = 0; i < n; i++){ //DOC: piperead-copy
80103476: 83 c3 01 add $0x1,%ebx
80103479: 3b 5d 10 cmp 0x10(%ebp),%ebx
8010347c: 74 0e je 8010348c <piperead+0xbc>
if(p->nread == p->nwrite)
8010347e: 8b 86 34 02 00 00 mov 0x234(%esi),%eax
80103484: 3b 86 38 02 00 00 cmp 0x238(%esi),%eax
8010348a: 75 d4 jne 80103460 <piperead+0x90>
wakeup(&p->nwrite); //DOC: piperead-wakeup
8010348c: 8d 86 38 02 00 00 lea 0x238(%esi),%eax
80103492: 89 04 24 mov %eax,(%esp)
80103495: e8 e6 08 00 00 call 80103d80 <wakeup>
release(&p->lock);
8010349a: 89 34 24 mov %esi,(%esp)
8010349d: e8 7e 0d 00 00 call 80104220 <release>
}
801034a2: 83 c4 1c add $0x1c,%esp
return i;
801034a5: 89 d8 mov %ebx,%eax
}
801034a7: 5b pop %ebx
801034a8: 5e pop %esi
801034a9: 5f pop %edi
801034aa: 5d pop %ebp
801034ab: c3 ret
801034ac: 66 90 xchg %ax,%ax
801034ae: 66 90 xchg %ax,%ax
801034b0 <allocproc>:
// If found, change state to EMBRYO and initialize
// state required to run in the kernel.
// Otherwise return 0.
static struct proc*
allocproc(void)
{
801034b0: 55 push %ebp
801034b1: 89 e5 mov %esp,%ebp
801034b3: 53 push %ebx
struct proc *p;
char *sp;
acquire(&ptable.lock);
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
801034b4: bb 54 2d 11 80 mov $0x80112d54,%ebx
{
801034b9: 83 ec 14 sub $0x14,%esp
acquire(&ptable.lock);
801034bc: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
801034c3: e8 68 0c 00 00 call 80104130 <acquire>
801034c8: eb 11 jmp 801034db <allocproc+0x2b>
801034ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
801034d0: 83 eb 80 sub $0xffffff80,%ebx
801034d3: 81 fb 54 4d 11 80 cmp $0x80114d54,%ebx
801034d9: 74 7d je 80103558 <allocproc+0xa8>
if(p->state == UNUSED)
801034db: 8b 43 10 mov 0x10(%ebx),%eax
801034de: 85 c0 test %eax,%eax
801034e0: 75 ee jne 801034d0 <allocproc+0x20>
release(&ptable.lock);
return 0;
found:
p->state = EMBRYO;
p->pid = nextpid++;
801034e2: a1 04 a0 10 80 mov 0x8010a004,%eax
release(&ptable.lock);
801034e7: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
p->state = EMBRYO;
801034ee: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx)
p->pid = nextpid++;
801034f5: 8d 50 01 lea 0x1(%eax),%edx
801034f8: 89 15 04 a0 10 80 mov %edx,0x8010a004
801034fe: 89 43 14 mov %eax,0x14(%ebx)
release(&ptable.lock);
80103501: e8 1a 0d 00 00 call 80104220 <release>
// Allocate kernel stack.
if((p->kstack = kalloc()) == 0){
80103506: e8 85 ef ff ff call 80102490 <kalloc>
8010350b: 85 c0 test %eax,%eax
8010350d: 89 43 0c mov %eax,0xc(%ebx)
80103510: 74 5a je 8010356c <allocproc+0xbc>
return 0;
}
sp = p->kstack + KSTACKSIZE;
// Leave room for trap frame.
sp -= sizeof *p->tf;
80103512: 8d 90 b4 0f 00 00 lea 0xfb4(%eax),%edx
// Set up new context to start executing at forkret,
// which returns to trapret.
sp -= 4;
*(uint*)sp = (uint)trapret;
sp -= sizeof *p->context;
80103518: 05 9c 0f 00 00 add $0xf9c,%eax
sp -= sizeof *p->tf;
8010351d: 89 53 1c mov %edx,0x1c(%ebx)
*(uint*)sp = (uint)trapret;
80103520: c7 40 14 25 54 10 80 movl $0x80105425,0x14(%eax)
p->context = (struct context*)sp;
memset(p->context, 0, sizeof *p->context);
80103527: c7 44 24 08 14 00 00 movl $0x14,0x8(%esp)
8010352e: 00
8010352f: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80103536: 00
80103537: 89 04 24 mov %eax,(%esp)
p->context = (struct context*)sp;
8010353a: 89 43 20 mov %eax,0x20(%ebx)
memset(p->context, 0, sizeof *p->context);
8010353d: e8 2e 0d 00 00 call 80104270 <memset>
p->context->eip = (uint)forkret;
80103542: 8b 43 20 mov 0x20(%ebx),%eax
80103545: c7 40 10 80 35 10 80 movl $0x80103580,0x10(%eax)
return p;
8010354c: 89 d8 mov %ebx,%eax
}
8010354e: 83 c4 14 add $0x14,%esp
80103551: 5b pop %ebx
80103552: 5d pop %ebp
80103553: c3 ret
80103554: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
release(&ptable.lock);
80103558: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
8010355f: e8 bc 0c 00 00 call 80104220 <release>
}
80103564: 83 c4 14 add $0x14,%esp
return 0;
80103567: 31 c0 xor %eax,%eax
}
80103569: 5b pop %ebx
8010356a: 5d pop %ebp
8010356b: c3 ret
p->state = UNUSED;
8010356c: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
return 0;
80103573: eb d9 jmp 8010354e <allocproc+0x9e>
80103575: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80103579: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80103580 <forkret>:
// A fork child's very first scheduling by scheduler()
// will swtch here. "Return" to user space.
void
forkret(void)
{
80103580: 55 push %ebp
80103581: 89 e5 mov %esp,%ebp
80103583: 83 ec 18 sub $0x18,%esp
static int first = 1;
// Still holding ptable.lock from scheduler.
release(&ptable.lock);
80103586: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
8010358d: e8 8e 0c 00 00 call 80104220 <release>
if (first) {
80103592: a1 00 a0 10 80 mov 0x8010a000,%eax
80103597: 85 c0 test %eax,%eax
80103599: 75 05 jne 801035a0 <forkret+0x20>
iinit(ROOTDEV);
initlog(ROOTDEV);
}
// Return to "caller", actually trapret (see allocproc).
}
8010359b: c9 leave
8010359c: c3 ret
8010359d: 8d 76 00 lea 0x0(%esi),%esi
iinit(ROOTDEV);
801035a0: c7 04 24 01 00 00 00 movl $0x1,(%esp)
first = 0;
801035a7: c7 05 00 a0 10 80 00 movl $0x0,0x8010a000
801035ae: 00 00 00
iinit(ROOTDEV);
801035b1: e8 aa de ff ff call 80101460 <iinit>
initlog(ROOTDEV);
801035b6: c7 04 24 01 00 00 00 movl $0x1,(%esp)
801035bd: e8 9e f4 ff ff call 80102a60 <initlog>
}
801035c2: c9 leave
801035c3: c3 ret
801035c4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801035ca: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
801035d0 <pinit>:
{
801035d0: 55 push %ebp
801035d1: 89 e5 mov %esp,%ebp
801035d3: 83 ec 18 sub $0x18,%esp
initlock(&ptable.lock, "ptable");
801035d6: c7 44 24 04 75 73 10 movl $0x80107375,0x4(%esp)
801035dd: 80
801035de: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
801035e5: e8 56 0a 00 00 call 80104040 <initlock>
}
801035ea: c9 leave
801035eb: c3 ret
801035ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801035f0 <mycpu>:
{
801035f0: 55 push %ebp
801035f1: 89 e5 mov %esp,%ebp
801035f3: 56 push %esi
801035f4: 53 push %ebx
801035f5: 83 ec 10 sub $0x10,%esp
asm volatile("pushfl; popl %0" : "=r" (eflags));
801035f8: 9c pushf
801035f9: 58 pop %eax
if(readeflags()&FL_IF)
801035fa: f6 c4 02 test $0x2,%ah
801035fd: 75 57 jne 80103656 <mycpu+0x66>
apicid = lapicid();
801035ff: e8 4c f1 ff ff call 80102750 <lapicid>
for (i = 0; i < ncpu; ++i) {
80103604: 8b 35 00 2d 11 80 mov 0x80112d00,%esi
8010360a: 85 f6 test %esi,%esi
8010360c: 7e 3c jle 8010364a <mycpu+0x5a>
if (cpus[i].apicid == apicid)
8010360e: 0f b6 15 80 27 11 80 movzbl 0x80112780,%edx
80103615: 39 c2 cmp %eax,%edx
80103617: 74 2d je 80103646 <mycpu+0x56>
80103619: b9 30 28 11 80 mov $0x80112830,%ecx
for (i = 0; i < ncpu; ++i) {
8010361e: 31 d2 xor %edx,%edx
80103620: 83 c2 01 add $0x1,%edx
80103623: 39 f2 cmp %esi,%edx
80103625: 74 23 je 8010364a <mycpu+0x5a>
if (cpus[i].apicid == apicid)
80103627: 0f b6 19 movzbl (%ecx),%ebx
8010362a: 81 c1 b0 00 00 00 add $0xb0,%ecx
80103630: 39 c3 cmp %eax,%ebx
80103632: 75 ec jne 80103620 <mycpu+0x30>
return &cpus[i];
80103634: 69 c2 b0 00 00 00 imul $0xb0,%edx,%eax
}
8010363a: 83 c4 10 add $0x10,%esp
8010363d: 5b pop %ebx
8010363e: 5e pop %esi
8010363f: 5d pop %ebp
return &cpus[i];
80103640: 05 80 27 11 80 add $0x80112780,%eax
}
80103645: c3 ret
for (i = 0; i < ncpu; ++i) {
80103646: 31 d2 xor %edx,%edx
80103648: eb ea jmp 80103634 <mycpu+0x44>
panic("unknown apicid\n");
8010364a: c7 04 24 7c 73 10 80 movl $0x8010737c,(%esp)
80103651: e8 0a cd ff ff call 80100360 <panic>
panic("mycpu called with interrupts enabled\n");
80103656: c7 04 24 58 74 10 80 movl $0x80107458,(%esp)
8010365d: e8 fe cc ff ff call 80100360 <panic>
80103662: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80103669: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80103670 <cpuid>:
cpuid() {
80103670: 55 push %ebp
80103671: 89 e5 mov %esp,%ebp
80103673: 83 ec 08 sub $0x8,%esp
return mycpu()-cpus;
80103676: e8 75 ff ff ff call 801035f0 <mycpu>
}
8010367b: c9 leave
return mycpu()-cpus;
8010367c: 2d 80 27 11 80 sub $0x80112780,%eax
80103681: c1 f8 04 sar $0x4,%eax
80103684: 69 c0 a3 8b 2e ba imul $0xba2e8ba3,%eax,%eax
}
8010368a: c3 ret
8010368b: 90 nop
8010368c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80103690 <myproc>:
myproc(void) {
80103690: 55 push %ebp
80103691: 89 e5 mov %esp,%ebp
80103693: 53 push %ebx
80103694: 83 ec 04 sub $0x4,%esp
pushcli();
80103697: e8 54 0a 00 00 call 801040f0 <pushcli>
c = mycpu();
8010369c: e8 4f ff ff ff call 801035f0 <mycpu>
p = c->proc;
801036a1: 8b 98 ac 00 00 00 mov 0xac(%eax),%ebx
popcli();
801036a7: e8 04 0b 00 00 call 801041b0 <popcli>
}
801036ac: 83 c4 04 add $0x4,%esp
801036af: 89 d8 mov %ebx,%eax
801036b1: 5b pop %ebx
801036b2: 5d pop %ebp
801036b3: c3 ret
801036b4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801036ba: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
801036c0 <userinit>:
{
801036c0: 55 push %ebp
801036c1: 89 e5 mov %esp,%ebp
801036c3: 53 push %ebx
801036c4: 83 ec 14 sub $0x14,%esp
p = allocproc();
801036c7: e8 e4 fd ff ff call 801034b0 <allocproc>
801036cc: 89 c3 mov %eax,%ebx
initproc = p;
801036ce: a3 b8 a5 10 80 mov %eax,0x8010a5b8
if((p->pgdir = setupkvm()) == 0)
801036d3: e8 58 33 00 00 call 80106a30 <setupkvm>
801036d8: 85 c0 test %eax,%eax
801036da: 89 43 08 mov %eax,0x8(%ebx)
801036dd: 0f 84 d4 00 00 00 je 801037b7 <userinit+0xf7>
inituvm(p->pgdir, _binary_initcode_start, (int)_binary_initcode_size);
801036e3: 89 04 24 mov %eax,(%esp)
801036e6: c7 44 24 08 2c 00 00 movl $0x2c,0x8(%esp)
801036ed: 00
801036ee: c7 44 24 04 60 a4 10 movl $0x8010a460,0x4(%esp)
801036f5: 80
801036f6: e8 45 30 00 00 call 80106740 <inituvm>
p->sz = PGSIZE;
801036fb: c7 03 00 10 00 00 movl $0x1000,(%ebx)
memset(p->tf, 0, sizeof(*p->tf));
80103701: c7 44 24 08 4c 00 00 movl $0x4c,0x8(%esp)
80103708: 00
80103709: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80103710: 00
80103711: 8b 43 1c mov 0x1c(%ebx),%eax
80103714: 89 04 24 mov %eax,(%esp)
80103717: e8 54 0b 00 00 call 80104270 <memset>
p->tf->cs = (SEG_UCODE << 3) | DPL_USER;
8010371c: 8b 43 1c mov 0x1c(%ebx),%eax
8010371f: ba 1b 00 00 00 mov $0x1b,%edx
p->tf->ds = (SEG_UDATA << 3) | DPL_USER;
80103724: b9 23 00 00 00 mov $0x23,%ecx
p->tf->cs = (SEG_UCODE << 3) | DPL_USER;
80103729: 66 89 50 3c mov %dx,0x3c(%eax)
p->tf->ds = (SEG_UDATA << 3) | DPL_USER;
8010372d: 8b 43 1c mov 0x1c(%ebx),%eax
80103730: 66 89 48 2c mov %cx,0x2c(%eax)
p->tf->es = p->tf->ds;
80103734: 8b 43 1c mov 0x1c(%ebx),%eax
80103737: 0f b7 50 2c movzwl 0x2c(%eax),%edx
8010373b: 66 89 50 28 mov %dx,0x28(%eax)
p->tf->ss = p->tf->ds;
8010373f: 8b 43 1c mov 0x1c(%ebx),%eax
80103742: 0f b7 50 2c movzwl 0x2c(%eax),%edx
80103746: 66 89 50 48 mov %dx,0x48(%eax)
p->tf->eflags = FL_IF;
8010374a: 8b 43 1c mov 0x1c(%ebx),%eax
8010374d: c7 40 40 00 02 00 00 movl $0x200,0x40(%eax)
p->tf->esp = PGSIZE;
80103754: 8b 43 1c mov 0x1c(%ebx),%eax
80103757: c7 40 44 00 10 00 00 movl $0x1000,0x44(%eax)
p->tf->eip = 0; // beginning of initcode.S
8010375e: 8b 43 1c mov 0x1c(%ebx),%eax
80103761: c7 40 38 00 00 00 00 movl $0x0,0x38(%eax)
safestrcpy(p->name, "initcode", sizeof(p->name));
80103768: 8d 43 70 lea 0x70(%ebx),%eax
8010376b: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp)
80103772: 00
80103773: c7 44 24 04 a5 73 10 movl $0x801073a5,0x4(%esp)
8010377a: 80
8010377b: 89 04 24 mov %eax,(%esp)
8010377e: e8 cd 0c 00 00 call 80104450 <safestrcpy>
p->cwd = namei("/");
80103783: c7 04 24 ae 73 10 80 movl $0x801073ae,(%esp)
8010378a: e8 61 e7 ff ff call 80101ef0 <namei>
8010378f: 89 43 6c mov %eax,0x6c(%ebx)
acquire(&ptable.lock);
80103792: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103799: e8 92 09 00 00 call 80104130 <acquire>
p->state = RUNNABLE;
8010379e: c7 43 10 03 00 00 00 movl $0x3,0x10(%ebx)
release(&ptable.lock);
801037a5: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
801037ac: e8 6f 0a 00 00 call 80104220 <release>
}
801037b1: 83 c4 14 add $0x14,%esp
801037b4: 5b pop %ebx
801037b5: 5d pop %ebp
801037b6: c3 ret
panic("userinit: out of memory?");
801037b7: c7 04 24 8c 73 10 80 movl $0x8010738c,(%esp)
801037be: e8 9d cb ff ff call 80100360 <panic>
801037c3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801037c9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801037d0 <growproc>:
{
801037d0: 55 push %ebp
801037d1: 89 e5 mov %esp,%ebp
801037d3: 56 push %esi
801037d4: 53 push %ebx
801037d5: 83 ec 10 sub $0x10,%esp
801037d8: 8b 75 08 mov 0x8(%ebp),%esi
struct proc *curproc = myproc();
801037db: e8 b0 fe ff ff call 80103690 <myproc>
if(n > 0){
801037e0: 83 fe 00 cmp $0x0,%esi
struct proc *curproc = myproc();
801037e3: 89 c3 mov %eax,%ebx
sz = curproc->sz;
801037e5: 8b 00 mov (%eax),%eax
if(n > 0){
801037e7: 7e 2f jle 80103818 <growproc+0x48>
if((sz = allocuvm(curproc->pgdir, sz, sz + n)) == 0)
801037e9: 01 c6 add %eax,%esi
801037eb: 89 74 24 08 mov %esi,0x8(%esp)
801037ef: 89 44 24 04 mov %eax,0x4(%esp)
801037f3: 8b 43 08 mov 0x8(%ebx),%eax
801037f6: 89 04 24 mov %eax,(%esp)
801037f9: e8 92 30 00 00 call 80106890 <allocuvm>
801037fe: 85 c0 test %eax,%eax
80103800: 74 36 je 80103838 <growproc+0x68>
curproc->sz = sz;
80103802: 89 03 mov %eax,(%ebx)
switchuvm(curproc);
80103804: 89 1c 24 mov %ebx,(%esp)
80103807: e8 24 2e 00 00 call 80106630 <switchuvm>
return 0;
8010380c: 31 c0 xor %eax,%eax
}
8010380e: 83 c4 10 add $0x10,%esp
80103811: 5b pop %ebx
80103812: 5e pop %esi
80103813: 5d pop %ebp
80103814: c3 ret
80103815: 8d 76 00 lea 0x0(%esi),%esi
} else if(n < 0){
80103818: 74 e8 je 80103802 <growproc+0x32>
if((sz = deallocuvm(curproc->pgdir, sz, sz + n)) == 0)
8010381a: 01 c6 add %eax,%esi
8010381c: 89 74 24 08 mov %esi,0x8(%esp)
80103820: 89 44 24 04 mov %eax,0x4(%esp)
80103824: 8b 43 08 mov 0x8(%ebx),%eax
80103827: 89 04 24 mov %eax,(%esp)
8010382a: e8 61 31 00 00 call 80106990 <deallocuvm>
8010382f: 85 c0 test %eax,%eax
80103831: 75 cf jne 80103802 <growproc+0x32>
80103833: 90 nop
80103834: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return -1;
80103838: b8 ff ff ff ff mov $0xffffffff,%eax
8010383d: eb cf jmp 8010380e <growproc+0x3e>
8010383f: 90 nop
80103840 <fork>:
{
80103840: 55 push %ebp
80103841: 89 e5 mov %esp,%ebp
80103843: 57 push %edi
80103844: 56 push %esi
80103845: 53 push %ebx
80103846: 83 ec 1c sub $0x1c,%esp
struct proc *curproc = myproc();
80103849: e8 42 fe ff ff call 80103690 <myproc>
8010384e: 89 c3 mov %eax,%ebx
if((np = allocproc()) == 0){
80103850: e8 5b fc ff ff call 801034b0 <allocproc>
80103855: 85 c0 test %eax,%eax
80103857: 89 c7 mov %eax,%edi
80103859: 89 45 e4 mov %eax,-0x1c(%ebp)
8010385c: 0f 84 c4 00 00 00 je 80103926 <fork+0xe6>
if((np->pgdir = copyuvm(curproc->pgdir, curproc->sz, curproc->sb)) == 0){
80103862: 8b 43 04 mov 0x4(%ebx),%eax
80103865: 89 44 24 08 mov %eax,0x8(%esp)
80103869: 8b 03 mov (%ebx),%eax
8010386b: 89 44 24 04 mov %eax,0x4(%esp)
8010386f: 8b 43 08 mov 0x8(%ebx),%eax
80103872: 89 04 24 mov %eax,(%esp)
80103875: e8 96 32 00 00 call 80106b10 <copyuvm>
8010387a: 85 c0 test %eax,%eax
8010387c: 89 47 08 mov %eax,0x8(%edi)
8010387f: 0f 84 a8 00 00 00 je 8010392d <fork+0xed>
np->sz = curproc->sz;
80103885: 8b 03 mov (%ebx),%eax
80103887: 8b 4d e4 mov -0x1c(%ebp),%ecx
8010388a: 89 01 mov %eax,(%ecx)
*np->tf = *curproc->tf;
8010388c: 8b 79 1c mov 0x1c(%ecx),%edi
8010388f: 89 c8 mov %ecx,%eax
np->parent = curproc;
80103891: 89 59 18 mov %ebx,0x18(%ecx)
*np->tf = *curproc->tf;
80103894: 8b 73 1c mov 0x1c(%ebx),%esi
80103897: b9 13 00 00 00 mov $0x13,%ecx
8010389c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
for(i = 0; i < NOFILE; i++)
8010389e: 31 f6 xor %esi,%esi
np->tf->eax = 0;
801038a0: 8b 40 1c mov 0x1c(%eax),%eax
801038a3: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
801038aa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if(curproc->ofile[i])
801038b0: 8b 44 b3 2c mov 0x2c(%ebx,%esi,4),%eax
801038b4: 85 c0 test %eax,%eax
801038b6: 74 0f je 801038c7 <fork+0x87>
np->ofile[i] = filedup(curproc->ofile[i]);
801038b8: 89 04 24 mov %eax,(%esp)
801038bb: e8 00 d5 ff ff call 80100dc0 <filedup>
801038c0: 8b 55 e4 mov -0x1c(%ebp),%edx
801038c3: 89 44 b2 2c mov %eax,0x2c(%edx,%esi,4)
for(i = 0; i < NOFILE; i++)
801038c7: 83 c6 01 add $0x1,%esi
801038ca: 83 fe 10 cmp $0x10,%esi
801038cd: 75 e1 jne 801038b0 <fork+0x70>
np->cwd = idup(curproc->cwd);
801038cf: 8b 43 6c mov 0x6c(%ebx),%eax
safestrcpy(np->name, curproc->name, sizeof(curproc->name));
801038d2: 83 c3 70 add $0x70,%ebx
np->cwd = idup(curproc->cwd);
801038d5: 89 04 24 mov %eax,(%esp)
801038d8: e8 93 dd ff ff call 80101670 <idup>
801038dd: 8b 7d e4 mov -0x1c(%ebp),%edi
801038e0: 89 47 6c mov %eax,0x6c(%edi)
safestrcpy(np->name, curproc->name, sizeof(curproc->name));
801038e3: 8d 47 70 lea 0x70(%edi),%eax
801038e6: 89 5c 24 04 mov %ebx,0x4(%esp)
801038ea: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp)
801038f1: 00
801038f2: 89 04 24 mov %eax,(%esp)
801038f5: e8 56 0b 00 00 call 80104450 <safestrcpy>
pid = np->pid;
801038fa: 8b 5f 14 mov 0x14(%edi),%ebx
acquire(&ptable.lock);
801038fd: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103904: e8 27 08 00 00 call 80104130 <acquire>
np->state = RUNNABLE;
80103909: c7 47 10 03 00 00 00 movl $0x3,0x10(%edi)
release(&ptable.lock);
80103910: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103917: e8 04 09 00 00 call 80104220 <release>
return pid;
8010391c: 89 d8 mov %ebx,%eax
}
8010391e: 83 c4 1c add $0x1c,%esp
80103921: 5b pop %ebx
80103922: 5e pop %esi
80103923: 5f pop %edi
80103924: 5d pop %ebp
80103925: c3 ret
return -1;
80103926: b8 ff ff ff ff mov $0xffffffff,%eax
8010392b: eb f1 jmp 8010391e <fork+0xde>
kfree(np->kstack);
8010392d: 8b 7d e4 mov -0x1c(%ebp),%edi
80103930: 8b 47 0c mov 0xc(%edi),%eax
80103933: 89 04 24 mov %eax,(%esp)
80103936: e8 a5 e9 ff ff call 801022e0 <kfree>
return -1;
8010393b: b8 ff ff ff ff mov $0xffffffff,%eax
np->kstack = 0;
80103940: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi)
np->state = UNUSED;
80103947: c7 47 10 00 00 00 00 movl $0x0,0x10(%edi)
return -1;
8010394e: eb ce jmp 8010391e <fork+0xde>
80103950 <scheduler>:
{
80103950: 55 push %ebp
80103951: 89 e5 mov %esp,%ebp
80103953: 57 push %edi
80103954: 56 push %esi
80103955: 53 push %ebx
80103956: 83 ec 1c sub $0x1c,%esp
struct cpu *c = mycpu();
80103959: e8 92 fc ff ff call 801035f0 <mycpu>
8010395e: 89 c6 mov %eax,%esi
c->proc = 0;
80103960: c7 80 ac 00 00 00 00 movl $0x0,0xac(%eax)
80103967: 00 00 00
8010396a: 8d 78 04 lea 0x4(%eax),%edi
8010396d: 8d 76 00 lea 0x0(%esi),%esi
asm volatile("sti");
80103970: fb sti
acquire(&ptable.lock);
80103971: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103978: bb 54 2d 11 80 mov $0x80112d54,%ebx
acquire(&ptable.lock);
8010397d: e8 ae 07 00 00 call 80104130 <acquire>
80103982: eb 0f jmp 80103993 <scheduler+0x43>
80103984: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103988: 83 eb 80 sub $0xffffff80,%ebx
8010398b: 81 fb 54 4d 11 80 cmp $0x80114d54,%ebx
80103991: 74 45 je 801039d8 <scheduler+0x88>
if(p->state != RUNNABLE)
80103993: 83 7b 10 03 cmpl $0x3,0x10(%ebx)
80103997: 75 ef jne 80103988 <scheduler+0x38>
c->proc = p;
80103999: 89 9e ac 00 00 00 mov %ebx,0xac(%esi)
switchuvm(p);
8010399f: 89 1c 24 mov %ebx,(%esp)
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
801039a2: 83 eb 80 sub $0xffffff80,%ebx
switchuvm(p);
801039a5: e8 86 2c 00 00 call 80106630 <switchuvm>
swtch(&(c->scheduler), p->context);
801039aa: 8b 43 a0 mov -0x60(%ebx),%eax
p->state = RUNNING;
801039ad: c7 43 90 04 00 00 00 movl $0x4,-0x70(%ebx)
swtch(&(c->scheduler), p->context);
801039b4: 89 3c 24 mov %edi,(%esp)
801039b7: 89 44 24 04 mov %eax,0x4(%esp)
801039bb: e8 eb 0a 00 00 call 801044ab <swtch>
switchkvm();
801039c0: e8 4b 2c 00 00 call 80106610 <switchkvm>
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
801039c5: 81 fb 54 4d 11 80 cmp $0x80114d54,%ebx
c->proc = 0;
801039cb: c7 86 ac 00 00 00 00 movl $0x0,0xac(%esi)
801039d2: 00 00 00
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
801039d5: 75 bc jne 80103993 <scheduler+0x43>
801039d7: 90 nop
release(&ptable.lock);
801039d8: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
801039df: e8 3c 08 00 00 call 80104220 <release>
}
801039e4: eb 8a jmp 80103970 <scheduler+0x20>
801039e6: 8d 76 00 lea 0x0(%esi),%esi
801039e9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801039f0 <sched>:
{
801039f0: 55 push %ebp
801039f1: 89 e5 mov %esp,%ebp
801039f3: 56 push %esi
801039f4: 53 push %ebx
801039f5: 83 ec 10 sub $0x10,%esp
struct proc *p = myproc();
801039f8: e8 93 fc ff ff call 80103690 <myproc>
if(!holding(&ptable.lock))
801039fd: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
struct proc *p = myproc();
80103a04: 89 c3 mov %eax,%ebx
if(!holding(&ptable.lock))
80103a06: e8 b5 06 00 00 call 801040c0 <holding>
80103a0b: 85 c0 test %eax,%eax
80103a0d: 74 4f je 80103a5e <sched+0x6e>
if(mycpu()->ncli != 1)
80103a0f: e8 dc fb ff ff call 801035f0 <mycpu>
80103a14: 83 b8 a4 00 00 00 01 cmpl $0x1,0xa4(%eax)
80103a1b: 75 65 jne 80103a82 <sched+0x92>
if(p->state == RUNNING)
80103a1d: 83 7b 10 04 cmpl $0x4,0x10(%ebx)
80103a21: 74 53 je 80103a76 <sched+0x86>
asm volatile("pushfl; popl %0" : "=r" (eflags));
80103a23: 9c pushf
80103a24: 58 pop %eax
if(readeflags()&FL_IF)
80103a25: f6 c4 02 test $0x2,%ah
80103a28: 75 40 jne 80103a6a <sched+0x7a>
intena = mycpu()->intena;
80103a2a: e8 c1 fb ff ff call 801035f0 <mycpu>
swtch(&p->context, mycpu()->scheduler);
80103a2f: 83 c3 20 add $0x20,%ebx
intena = mycpu()->intena;
80103a32: 8b b0 a8 00 00 00 mov 0xa8(%eax),%esi
swtch(&p->context, mycpu()->scheduler);
80103a38: e8 b3 fb ff ff call 801035f0 <mycpu>
80103a3d: 8b 40 04 mov 0x4(%eax),%eax
80103a40: 89 1c 24 mov %ebx,(%esp)
80103a43: 89 44 24 04 mov %eax,0x4(%esp)
80103a47: e8 5f 0a 00 00 call 801044ab <swtch>
mycpu()->intena = intena;
80103a4c: e8 9f fb ff ff call 801035f0 <mycpu>
80103a51: 89 b0 a8 00 00 00 mov %esi,0xa8(%eax)
}
80103a57: 83 c4 10 add $0x10,%esp
80103a5a: 5b pop %ebx
80103a5b: 5e pop %esi
80103a5c: 5d pop %ebp
80103a5d: c3 ret
panic("sched ptable.lock");
80103a5e: c7 04 24 b0 73 10 80 movl $0x801073b0,(%esp)
80103a65: e8 f6 c8 ff ff call 80100360 <panic>
panic("sched interruptible");
80103a6a: c7 04 24 dc 73 10 80 movl $0x801073dc,(%esp)
80103a71: e8 ea c8 ff ff call 80100360 <panic>
panic("sched running");
80103a76: c7 04 24 ce 73 10 80 movl $0x801073ce,(%esp)
80103a7d: e8 de c8 ff ff call 80100360 <panic>
panic("sched locks");
80103a82: c7 04 24 c2 73 10 80 movl $0x801073c2,(%esp)
80103a89: e8 d2 c8 ff ff call 80100360 <panic>
80103a8e: 66 90 xchg %ax,%ax
80103a90 <exit>:
{
80103a90: 55 push %ebp
80103a91: 89 e5 mov %esp,%ebp
80103a93: 56 push %esi
if(curproc == initproc)
80103a94: 31 f6 xor %esi,%esi
{
80103a96: 53 push %ebx
80103a97: 83 ec 10 sub $0x10,%esp
struct proc *curproc = myproc();
80103a9a: e8 f1 fb ff ff call 80103690 <myproc>
if(curproc == initproc)
80103a9f: 3b 05 b8 a5 10 80 cmp 0x8010a5b8,%eax
struct proc *curproc = myproc();
80103aa5: 89 c3 mov %eax,%ebx
if(curproc == initproc)
80103aa7: 0f 84 ea 00 00 00 je 80103b97 <exit+0x107>
80103aad: 8d 76 00 lea 0x0(%esi),%esi
if(curproc->ofile[fd]){
80103ab0: 8b 44 b3 2c mov 0x2c(%ebx,%esi,4),%eax
80103ab4: 85 c0 test %eax,%eax
80103ab6: 74 10 je 80103ac8 <exit+0x38>
fileclose(curproc->ofile[fd]);
80103ab8: 89 04 24 mov %eax,(%esp)
80103abb: e8 50 d3 ff ff call 80100e10 <fileclose>
curproc->ofile[fd] = 0;
80103ac0: c7 44 b3 2c 00 00 00 movl $0x0,0x2c(%ebx,%esi,4)
80103ac7: 00
for(fd = 0; fd < NOFILE; fd++){
80103ac8: 83 c6 01 add $0x1,%esi
80103acb: 83 fe 10 cmp $0x10,%esi
80103ace: 75 e0 jne 80103ab0 <exit+0x20>
begin_op();
80103ad0: e8 2b f0 ff ff call 80102b00 <begin_op>
iput(curproc->cwd);
80103ad5: 8b 43 6c mov 0x6c(%ebx),%eax
80103ad8: 89 04 24 mov %eax,(%esp)
80103adb: e8 e0 dc ff ff call 801017c0 <iput>
end_op();
80103ae0: e8 8b f0 ff ff call 80102b70 <end_op>
curproc->cwd = 0;
80103ae5: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
acquire(&ptable.lock);
80103aec: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103af3: e8 38 06 00 00 call 80104130 <acquire>
wakeup1(curproc->parent);
80103af8: 8b 43 18 mov 0x18(%ebx),%eax
static void
wakeup1(void *chan)
{
struct proc *p;
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
80103afb: ba 54 2d 11 80 mov $0x80112d54,%edx
80103b00: eb 11 jmp 80103b13 <exit+0x83>
80103b02: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80103b08: 83 ea 80 sub $0xffffff80,%edx
80103b0b: 81 fa 54 4d 11 80 cmp $0x80114d54,%edx
80103b11: 74 1d je 80103b30 <exit+0xa0>
if(p->state == SLEEPING && p->chan == chan)
80103b13: 83 7a 10 02 cmpl $0x2,0x10(%edx)
80103b17: 75 ef jne 80103b08 <exit+0x78>
80103b19: 3b 42 24 cmp 0x24(%edx),%eax
80103b1c: 75 ea jne 80103b08 <exit+0x78>
p->state = RUNNABLE;
80103b1e: c7 42 10 03 00 00 00 movl $0x3,0x10(%edx)
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
80103b25: 83 ea 80 sub $0xffffff80,%edx
80103b28: 81 fa 54 4d 11 80 cmp $0x80114d54,%edx
80103b2e: 75 e3 jne 80103b13 <exit+0x83>
p->parent = initproc;
80103b30: a1 b8 a5 10 80 mov 0x8010a5b8,%eax
80103b35: b9 54 2d 11 80 mov $0x80112d54,%ecx
80103b3a: eb 0f jmp 80103b4b <exit+0xbb>
80103b3c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103b40: 83 e9 80 sub $0xffffff80,%ecx
80103b43: 81 f9 54 4d 11 80 cmp $0x80114d54,%ecx
80103b49: 74 34 je 80103b7f <exit+0xef>
if(p->parent == curproc){
80103b4b: 39 59 18 cmp %ebx,0x18(%ecx)
80103b4e: 75 f0 jne 80103b40 <exit+0xb0>
if(p->state == ZOMBIE)
80103b50: 83 79 10 05 cmpl $0x5,0x10(%ecx)
p->parent = initproc;
80103b54: 89 41 18 mov %eax,0x18(%ecx)
if(p->state == ZOMBIE)
80103b57: 75 e7 jne 80103b40 <exit+0xb0>
80103b59: ba 54 2d 11 80 mov $0x80112d54,%edx
80103b5e: eb 0b jmp 80103b6b <exit+0xdb>
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
80103b60: 83 ea 80 sub $0xffffff80,%edx
80103b63: 81 fa 54 4d 11 80 cmp $0x80114d54,%edx
80103b69: 74 d5 je 80103b40 <exit+0xb0>
if(p->state == SLEEPING && p->chan == chan)
80103b6b: 83 7a 10 02 cmpl $0x2,0x10(%edx)
80103b6f: 75 ef jne 80103b60 <exit+0xd0>
80103b71: 3b 42 24 cmp 0x24(%edx),%eax
80103b74: 75 ea jne 80103b60 <exit+0xd0>
p->state = RUNNABLE;
80103b76: c7 42 10 03 00 00 00 movl $0x3,0x10(%edx)
80103b7d: eb e1 jmp 80103b60 <exit+0xd0>
curproc->state = ZOMBIE;
80103b7f: c7 43 10 05 00 00 00 movl $0x5,0x10(%ebx)
sched();
80103b86: e8 65 fe ff ff call 801039f0 <sched>
panic("zombie exit");
80103b8b: c7 04 24 fd 73 10 80 movl $0x801073fd,(%esp)
80103b92: e8 c9 c7 ff ff call 80100360 <panic>
panic("init exiting");
80103b97: c7 04 24 f0 73 10 80 movl $0x801073f0,(%esp)
80103b9e: e8 bd c7 ff ff call 80100360 <panic>
80103ba3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80103ba9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80103bb0 <yield>:
{
80103bb0: 55 push %ebp
80103bb1: 89 e5 mov %esp,%ebp
80103bb3: 83 ec 18 sub $0x18,%esp
acquire(&ptable.lock); //DOC: yieldlock
80103bb6: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103bbd: e8 6e 05 00 00 call 80104130 <acquire>
myproc()->state = RUNNABLE;
80103bc2: e8 c9 fa ff ff call 80103690 <myproc>
80103bc7: c7 40 10 03 00 00 00 movl $0x3,0x10(%eax)
sched();
80103bce: e8 1d fe ff ff call 801039f0 <sched>
release(&ptable.lock);
80103bd3: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103bda: e8 41 06 00 00 call 80104220 <release>
}
80103bdf: c9 leave
80103be0: c3 ret
80103be1: eb 0d jmp 80103bf0 <sleep>
80103be3: 90 nop
80103be4: 90 nop
80103be5: 90 nop
80103be6: 90 nop
80103be7: 90 nop
80103be8: 90 nop
80103be9: 90 nop
80103bea: 90 nop
80103beb: 90 nop
80103bec: 90 nop
80103bed: 90 nop
80103bee: 90 nop
80103bef: 90 nop
80103bf0 <sleep>:
{
80103bf0: 55 push %ebp
80103bf1: 89 e5 mov %esp,%ebp
80103bf3: 57 push %edi
80103bf4: 56 push %esi
80103bf5: 53 push %ebx
80103bf6: 83 ec 1c sub $0x1c,%esp
80103bf9: 8b 7d 08 mov 0x8(%ebp),%edi
80103bfc: 8b 75 0c mov 0xc(%ebp),%esi
struct proc *p = myproc();
80103bff: e8 8c fa ff ff call 80103690 <myproc>
if(p == 0)
80103c04: 85 c0 test %eax,%eax
struct proc *p = myproc();
80103c06: 89 c3 mov %eax,%ebx
if(p == 0)
80103c08: 0f 84 7c 00 00 00 je 80103c8a <sleep+0x9a>
if(lk == 0)
80103c0e: 85 f6 test %esi,%esi
80103c10: 74 6c je 80103c7e <sleep+0x8e>
if(lk != &ptable.lock){ //DOC: sleeplock0
80103c12: 81 fe 20 2d 11 80 cmp $0x80112d20,%esi
80103c18: 74 46 je 80103c60 <sleep+0x70>
acquire(&ptable.lock); //DOC: sleeplock1
80103c1a: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103c21: e8 0a 05 00 00 call 80104130 <acquire>
release(lk);
80103c26: 89 34 24 mov %esi,(%esp)
80103c29: e8 f2 05 00 00 call 80104220 <release>
p->chan = chan;
80103c2e: 89 7b 24 mov %edi,0x24(%ebx)
p->state = SLEEPING;
80103c31: c7 43 10 02 00 00 00 movl $0x2,0x10(%ebx)
sched();
80103c38: e8 b3 fd ff ff call 801039f0 <sched>
p->chan = 0;
80103c3d: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
release(&ptable.lock);
80103c44: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103c4b: e8 d0 05 00 00 call 80104220 <release>
acquire(lk);
80103c50: 89 75 08 mov %esi,0x8(%ebp)
}
80103c53: 83 c4 1c add $0x1c,%esp
80103c56: 5b pop %ebx
80103c57: 5e pop %esi
80103c58: 5f pop %edi
80103c59: 5d pop %ebp
acquire(lk);
80103c5a: e9 d1 04 00 00 jmp 80104130 <acquire>
80103c5f: 90 nop
p->chan = chan;
80103c60: 89 78 24 mov %edi,0x24(%eax)
p->state = SLEEPING;
80103c63: c7 40 10 02 00 00 00 movl $0x2,0x10(%eax)
sched();
80103c6a: e8 81 fd ff ff call 801039f0 <sched>
p->chan = 0;
80103c6f: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
}
80103c76: 83 c4 1c add $0x1c,%esp
80103c79: 5b pop %ebx
80103c7a: 5e pop %esi
80103c7b: 5f pop %edi
80103c7c: 5d pop %ebp
80103c7d: c3 ret
panic("sleep without lk");
80103c7e: c7 04 24 0f 74 10 80 movl $0x8010740f,(%esp)
80103c85: e8 d6 c6 ff ff call 80100360 <panic>
panic("sleep");
80103c8a: c7 04 24 09 74 10 80 movl $0x80107409,(%esp)
80103c91: e8 ca c6 ff ff call 80100360 <panic>
80103c96: 8d 76 00 lea 0x0(%esi),%esi
80103c99: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80103ca0 <wait>:
{
80103ca0: 55 push %ebp
80103ca1: 89 e5 mov %esp,%ebp
80103ca3: 56 push %esi
80103ca4: 53 push %ebx
80103ca5: 83 ec 10 sub $0x10,%esp
struct proc *curproc = myproc();
80103ca8: e8 e3 f9 ff ff call 80103690 <myproc>
acquire(&ptable.lock);
80103cad: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
struct proc *curproc = myproc();
80103cb4: 89 c6 mov %eax,%esi
acquire(&ptable.lock);
80103cb6: e8 75 04 00 00 call 80104130 <acquire>
havekids = 0;
80103cbb: 31 c0 xor %eax,%eax
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103cbd: bb 54 2d 11 80 mov $0x80112d54,%ebx
80103cc2: eb 0f jmp 80103cd3 <wait+0x33>
80103cc4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80103cc8: 83 eb 80 sub $0xffffff80,%ebx
80103ccb: 81 fb 54 4d 11 80 cmp $0x80114d54,%ebx
80103cd1: 74 1d je 80103cf0 <wait+0x50>
if(p->parent != curproc)
80103cd3: 39 73 18 cmp %esi,0x18(%ebx)
80103cd6: 75 f0 jne 80103cc8 <wait+0x28>
if(p->state == ZOMBIE){
80103cd8: 83 7b 10 05 cmpl $0x5,0x10(%ebx)
80103cdc: 74 2f je 80103d0d <wait+0x6d>
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103cde: 83 eb 80 sub $0xffffff80,%ebx
havekids = 1;
80103ce1: b8 01 00 00 00 mov $0x1,%eax
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103ce6: 81 fb 54 4d 11 80 cmp $0x80114d54,%ebx
80103cec: 75 e5 jne 80103cd3 <wait+0x33>
80103cee: 66 90 xchg %ax,%ax
if(!havekids || curproc->killed){
80103cf0: 85 c0 test %eax,%eax
80103cf2: 74 6e je 80103d62 <wait+0xc2>
80103cf4: 8b 46 28 mov 0x28(%esi),%eax
80103cf7: 85 c0 test %eax,%eax
80103cf9: 75 67 jne 80103d62 <wait+0xc2>
sleep(curproc, &ptable.lock); //DOC: wait-sleep
80103cfb: c7 44 24 04 20 2d 11 movl $0x80112d20,0x4(%esp)
80103d02: 80
80103d03: 89 34 24 mov %esi,(%esp)
80103d06: e8 e5 fe ff ff call 80103bf0 <sleep>
}
80103d0b: eb ae jmp 80103cbb <wait+0x1b>
kfree(p->kstack);
80103d0d: 8b 43 0c mov 0xc(%ebx),%eax
pid = p->pid;
80103d10: 8b 73 14 mov 0x14(%ebx),%esi
kfree(p->kstack);
80103d13: 89 04 24 mov %eax,(%esp)
80103d16: e8 c5 e5 ff ff call 801022e0 <kfree>
freevm(p->pgdir);
80103d1b: 8b 43 08 mov 0x8(%ebx),%eax
p->kstack = 0;
80103d1e: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
freevm(p->pgdir);
80103d25: 89 04 24 mov %eax,(%esp)
80103d28: e8 83 2c 00 00 call 801069b0 <freevm>
release(&ptable.lock);
80103d2d: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
p->pid = 0;
80103d34: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
p->parent = 0;
80103d3b: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
p->name[0] = 0;
80103d42: c6 43 70 00 movb $0x0,0x70(%ebx)
p->killed = 0;
80103d46: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx)
p->state = UNUSED;
80103d4d: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
release(&ptable.lock);
80103d54: e8 c7 04 00 00 call 80104220 <release>
}
80103d59: 83 c4 10 add $0x10,%esp
return pid;
80103d5c: 89 f0 mov %esi,%eax
}
80103d5e: 5b pop %ebx
80103d5f: 5e pop %esi
80103d60: 5d pop %ebp
80103d61: c3 ret
release(&ptable.lock);
80103d62: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103d69: e8 b2 04 00 00 call 80104220 <release>
}
80103d6e: 83 c4 10 add $0x10,%esp
return -1;
80103d71: b8 ff ff ff ff mov $0xffffffff,%eax
}
80103d76: 5b pop %ebx
80103d77: 5e pop %esi
80103d78: 5d pop %ebp
80103d79: c3 ret
80103d7a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80103d80 <wakeup>:
}
// Wake up all processes sleeping on chan.
void
wakeup(void *chan)
{
80103d80: 55 push %ebp
80103d81: 89 e5 mov %esp,%ebp
80103d83: 53 push %ebx
80103d84: 83 ec 14 sub $0x14,%esp
80103d87: 8b 5d 08 mov 0x8(%ebp),%ebx
acquire(&ptable.lock);
80103d8a: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103d91: e8 9a 03 00 00 call 80104130 <acquire>
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
80103d96: b8 54 2d 11 80 mov $0x80112d54,%eax
80103d9b: eb 0d jmp 80103daa <wakeup+0x2a>
80103d9d: 8d 76 00 lea 0x0(%esi),%esi
80103da0: 83 e8 80 sub $0xffffff80,%eax
80103da3: 3d 54 4d 11 80 cmp $0x80114d54,%eax
80103da8: 74 1e je 80103dc8 <wakeup+0x48>
if(p->state == SLEEPING && p->chan == chan)
80103daa: 83 78 10 02 cmpl $0x2,0x10(%eax)
80103dae: 75 f0 jne 80103da0 <wakeup+0x20>
80103db0: 3b 58 24 cmp 0x24(%eax),%ebx
80103db3: 75 eb jne 80103da0 <wakeup+0x20>
p->state = RUNNABLE;
80103db5: c7 40 10 03 00 00 00 movl $0x3,0x10(%eax)
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
80103dbc: 83 e8 80 sub $0xffffff80,%eax
80103dbf: 3d 54 4d 11 80 cmp $0x80114d54,%eax
80103dc4: 75 e4 jne 80103daa <wakeup+0x2a>
80103dc6: 66 90 xchg %ax,%ax
wakeup1(chan);
release(&ptable.lock);
80103dc8: c7 45 08 20 2d 11 80 movl $0x80112d20,0x8(%ebp)
}
80103dcf: 83 c4 14 add $0x14,%esp
80103dd2: 5b pop %ebx
80103dd3: 5d pop %ebp
release(&ptable.lock);
80103dd4: e9 47 04 00 00 jmp 80104220 <release>
80103dd9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80103de0 <kill>:
// Kill the process with the given pid.
// Process won't exit until it returns
// to user space (see trap in trap.c).
int
kill(int pid)
{
80103de0: 55 push %ebp
80103de1: 89 e5 mov %esp,%ebp
80103de3: 53 push %ebx
80103de4: 83 ec 14 sub $0x14,%esp
80103de7: 8b 5d 08 mov 0x8(%ebp),%ebx
struct proc *p;
acquire(&ptable.lock);
80103dea: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103df1: e8 3a 03 00 00 call 80104130 <acquire>
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103df6: b8 54 2d 11 80 mov $0x80112d54,%eax
80103dfb: eb 0d jmp 80103e0a <kill+0x2a>
80103dfd: 8d 76 00 lea 0x0(%esi),%esi
80103e00: 83 e8 80 sub $0xffffff80,%eax
80103e03: 3d 54 4d 11 80 cmp $0x80114d54,%eax
80103e08: 74 36 je 80103e40 <kill+0x60>
if(p->pid == pid){
80103e0a: 39 58 14 cmp %ebx,0x14(%eax)
80103e0d: 75 f1 jne 80103e00 <kill+0x20>
p->killed = 1;
// Wake process from sleep if necessary.
if(p->state == SLEEPING)
80103e0f: 83 78 10 02 cmpl $0x2,0x10(%eax)
p->killed = 1;
80103e13: c7 40 28 01 00 00 00 movl $0x1,0x28(%eax)
if(p->state == SLEEPING)
80103e1a: 74 14 je 80103e30 <kill+0x50>
p->state = RUNNABLE;
release(&ptable.lock);
80103e1c: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103e23: e8 f8 03 00 00 call 80104220 <release>
return 0;
}
}
release(&ptable.lock);
return -1;
}
80103e28: 83 c4 14 add $0x14,%esp
return 0;
80103e2b: 31 c0 xor %eax,%eax
}
80103e2d: 5b pop %ebx
80103e2e: 5d pop %ebp
80103e2f: c3 ret
p->state = RUNNABLE;
80103e30: c7 40 10 03 00 00 00 movl $0x3,0x10(%eax)
80103e37: eb e3 jmp 80103e1c <kill+0x3c>
80103e39: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
release(&ptable.lock);
80103e40: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103e47: e8 d4 03 00 00 call 80104220 <release>
}
80103e4c: 83 c4 14 add $0x14,%esp
return -1;
80103e4f: b8 ff ff ff ff mov $0xffffffff,%eax
}
80103e54: 5b pop %ebx
80103e55: 5d pop %ebp
80103e56: c3 ret
80103e57: 89 f6 mov %esi,%esi
80103e59: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80103e60 <procdump>:
// Print a process listing to console. For debugging.
// Runs when user types ^P on console.
// No lock to avoid wedging a stuck machine further.
void
procdump(void)
{
80103e60: 55 push %ebp
80103e61: 89 e5 mov %esp,%ebp
80103e63: 57 push %edi
80103e64: 56 push %esi
80103e65: 53 push %ebx
80103e66: bb c4 2d 11 80 mov $0x80112dc4,%ebx
80103e6b: 83 ec 4c sub $0x4c,%esp
80103e6e: 8d 75 e8 lea -0x18(%ebp),%esi
80103e71: eb 20 jmp 80103e93 <procdump+0x33>
80103e73: 90 nop
80103e74: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if(p->state == SLEEPING){
getcallerpcs((uint*)p->context->ebp+2, pc);
for(i=0; i<10 && pc[i] != 0; i++)
cprintf(" %p", pc[i]);
}
cprintf("\n");
80103e78: c7 04 24 07 78 10 80 movl $0x80107807,(%esp)
80103e7f: e8 cc c7 ff ff call 80100650 <cprintf>
80103e84: 83 eb 80 sub $0xffffff80,%ebx
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103e87: 81 fb c4 4d 11 80 cmp $0x80114dc4,%ebx
80103e8d: 0f 84 8d 00 00 00 je 80103f20 <procdump+0xc0>
if(p->state == UNUSED)
80103e93: 8b 43 a0 mov -0x60(%ebx),%eax
80103e96: 85 c0 test %eax,%eax
80103e98: 74 ea je 80103e84 <procdump+0x24>
if(p->state >= 0 && p->state < NELEM(states) && states[p->state])
80103e9a: 83 f8 05 cmp $0x5,%eax
state = "???";
80103e9d: ba 20 74 10 80 mov $0x80107420,%edx
if(p->state >= 0 && p->state < NELEM(states) && states[p->state])
80103ea2: 77 11 ja 80103eb5 <procdump+0x55>
80103ea4: 8b 14 85 80 74 10 80 mov -0x7fef8b80(,%eax,4),%edx
state = "???";
80103eab: b8 20 74 10 80 mov $0x80107420,%eax
80103eb0: 85 d2 test %edx,%edx
80103eb2: 0f 44 d0 cmove %eax,%edx
cprintf("%d %s %s", p->pid, state, p->name);
80103eb5: 8b 43 a4 mov -0x5c(%ebx),%eax
80103eb8: 89 5c 24 0c mov %ebx,0xc(%esp)
80103ebc: 89 54 24 08 mov %edx,0x8(%esp)
80103ec0: c7 04 24 24 74 10 80 movl $0x80107424,(%esp)
80103ec7: 89 44 24 04 mov %eax,0x4(%esp)
80103ecb: e8 80 c7 ff ff call 80100650 <cprintf>
if(p->state == SLEEPING){
80103ed0: 83 7b a0 02 cmpl $0x2,-0x60(%ebx)
80103ed4: 75 a2 jne 80103e78 <procdump+0x18>
getcallerpcs((uint*)p->context->ebp+2, pc);
80103ed6: 8d 45 c0 lea -0x40(%ebp),%eax
80103ed9: 89 44 24 04 mov %eax,0x4(%esp)
80103edd: 8b 43 b0 mov -0x50(%ebx),%eax
80103ee0: 8d 7d c0 lea -0x40(%ebp),%edi
80103ee3: 8b 40 0c mov 0xc(%eax),%eax
80103ee6: 83 c0 08 add $0x8,%eax
80103ee9: 89 04 24 mov %eax,(%esp)
80103eec: e8 6f 01 00 00 call 80104060 <getcallerpcs>
80103ef1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
for(i=0; i<10 && pc[i] != 0; i++)
80103ef8: 8b 17 mov (%edi),%edx
80103efa: 85 d2 test %edx,%edx
80103efc: 0f 84 76 ff ff ff je 80103e78 <procdump+0x18>
cprintf(" %p", pc[i]);
80103f02: 89 54 24 04 mov %edx,0x4(%esp)
80103f06: 83 c7 04 add $0x4,%edi
80103f09: c7 04 24 61 6e 10 80 movl $0x80106e61,(%esp)
80103f10: e8 3b c7 ff ff call 80100650 <cprintf>
for(i=0; i<10 && pc[i] != 0; i++)
80103f15: 39 f7 cmp %esi,%edi
80103f17: 75 df jne 80103ef8 <procdump+0x98>
80103f19: e9 5a ff ff ff jmp 80103e78 <procdump+0x18>
80103f1e: 66 90 xchg %ax,%ax
}
}
80103f20: 83 c4 4c add $0x4c,%esp
80103f23: 5b pop %ebx
80103f24: 5e pop %esi
80103f25: 5f pop %edi
80103f26: 5d pop %ebp
80103f27: c3 ret
80103f28: 66 90 xchg %ax,%ax
80103f2a: 66 90 xchg %ax,%ax
80103f2c: 66 90 xchg %ax,%ax
80103f2e: 66 90 xchg %ax,%ax
80103f30 <initsleeplock>:
#include "spinlock.h"
#include "sleeplock.h"
void
initsleeplock(struct sleeplock *lk, char *name)
{
80103f30: 55 push %ebp
80103f31: 89 e5 mov %esp,%ebp
80103f33: 53 push %ebx
80103f34: 83 ec 14 sub $0x14,%esp
80103f37: 8b 5d 08 mov 0x8(%ebp),%ebx
initlock(&lk->lk, "sleep lock");
80103f3a: c7 44 24 04 98 74 10 movl $0x80107498,0x4(%esp)
80103f41: 80
80103f42: 8d 43 04 lea 0x4(%ebx),%eax
80103f45: 89 04 24 mov %eax,(%esp)
80103f48: e8 f3 00 00 00 call 80104040 <initlock>
lk->name = name;
80103f4d: 8b 45 0c mov 0xc(%ebp),%eax
lk->locked = 0;
80103f50: c7 03 00 00 00 00 movl $0x0,(%ebx)
lk->pid = 0;
80103f56: c7 43 3c 00 00 00 00 movl $0x0,0x3c(%ebx)
lk->name = name;
80103f5d: 89 43 38 mov %eax,0x38(%ebx)
}
80103f60: 83 c4 14 add $0x14,%esp
80103f63: 5b pop %ebx
80103f64: 5d pop %ebp
80103f65: c3 ret
80103f66: 8d 76 00 lea 0x0(%esi),%esi
80103f69: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80103f70 <acquiresleep>:
void
acquiresleep(struct sleeplock *lk)
{
80103f70: 55 push %ebp
80103f71: 89 e5 mov %esp,%ebp
80103f73: 56 push %esi
80103f74: 53 push %ebx
80103f75: 83 ec 10 sub $0x10,%esp
80103f78: 8b 5d 08 mov 0x8(%ebp),%ebx
acquire(&lk->lk);
80103f7b: 8d 73 04 lea 0x4(%ebx),%esi
80103f7e: 89 34 24 mov %esi,(%esp)
80103f81: e8 aa 01 00 00 call 80104130 <acquire>
while (lk->locked) {
80103f86: 8b 13 mov (%ebx),%edx
80103f88: 85 d2 test %edx,%edx
80103f8a: 74 16 je 80103fa2 <acquiresleep+0x32>
80103f8c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
sleep(lk, &lk->lk);
80103f90: 89 74 24 04 mov %esi,0x4(%esp)
80103f94: 89 1c 24 mov %ebx,(%esp)
80103f97: e8 54 fc ff ff call 80103bf0 <sleep>
while (lk->locked) {
80103f9c: 8b 03 mov (%ebx),%eax
80103f9e: 85 c0 test %eax,%eax
80103fa0: 75 ee jne 80103f90 <acquiresleep+0x20>
}
lk->locked = 1;
80103fa2: c7 03 01 00 00 00 movl $0x1,(%ebx)
lk->pid = myproc()->pid;
80103fa8: e8 e3 f6 ff ff call 80103690 <myproc>
80103fad: 8b 40 14 mov 0x14(%eax),%eax
80103fb0: 89 43 3c mov %eax,0x3c(%ebx)
release(&lk->lk);
80103fb3: 89 75 08 mov %esi,0x8(%ebp)
}
80103fb6: 83 c4 10 add $0x10,%esp
80103fb9: 5b pop %ebx
80103fba: 5e pop %esi
80103fbb: 5d pop %ebp
release(&lk->lk);
80103fbc: e9 5f 02 00 00 jmp 80104220 <release>
80103fc1: eb 0d jmp 80103fd0 <releasesleep>
80103fc3: 90 nop
80103fc4: 90 nop
80103fc5: 90 nop
80103fc6: 90 nop
80103fc7: 90 nop
80103fc8: 90 nop
80103fc9: 90 nop
80103fca: 90 nop
80103fcb: 90 nop
80103fcc: 90 nop
80103fcd: 90 nop
80103fce: 90 nop
80103fcf: 90 nop
80103fd0 <releasesleep>:
void
releasesleep(struct sleeplock *lk)
{
80103fd0: 55 push %ebp
80103fd1: 89 e5 mov %esp,%ebp
80103fd3: 56 push %esi
80103fd4: 53 push %ebx
80103fd5: 83 ec 10 sub $0x10,%esp
80103fd8: 8b 5d 08 mov 0x8(%ebp),%ebx
acquire(&lk->lk);
80103fdb: 8d 73 04 lea 0x4(%ebx),%esi
80103fde: 89 34 24 mov %esi,(%esp)
80103fe1: e8 4a 01 00 00 call 80104130 <acquire>
lk->locked = 0;
80103fe6: c7 03 00 00 00 00 movl $0x0,(%ebx)
lk->pid = 0;
80103fec: c7 43 3c 00 00 00 00 movl $0x0,0x3c(%ebx)
wakeup(lk);
80103ff3: 89 1c 24 mov %ebx,(%esp)
80103ff6: e8 85 fd ff ff call 80103d80 <wakeup>
release(&lk->lk);
80103ffb: 89 75 08 mov %esi,0x8(%ebp)
}
80103ffe: 83 c4 10 add $0x10,%esp
80104001: 5b pop %ebx
80104002: 5e pop %esi
80104003: 5d pop %ebp
release(&lk->lk);
80104004: e9 17 02 00 00 jmp 80104220 <release>
80104009: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80104010 <holdingsleep>:
int
holdingsleep(struct sleeplock *lk)
{
80104010: 55 push %ebp
80104011: 89 e5 mov %esp,%ebp
80104013: 56 push %esi
80104014: 53 push %ebx
80104015: 83 ec 10 sub $0x10,%esp
80104018: 8b 5d 08 mov 0x8(%ebp),%ebx
int r;
acquire(&lk->lk);
8010401b: 8d 73 04 lea 0x4(%ebx),%esi
8010401e: 89 34 24 mov %esi,(%esp)
80104021: e8 0a 01 00 00 call 80104130 <acquire>
r = lk->locked;
80104026: 8b 1b mov (%ebx),%ebx
release(&lk->lk);
80104028: 89 34 24 mov %esi,(%esp)
8010402b: e8 f0 01 00 00 call 80104220 <release>
return r;
}
80104030: 83 c4 10 add $0x10,%esp
80104033: 89 d8 mov %ebx,%eax
80104035: 5b pop %ebx
80104036: 5e pop %esi
80104037: 5d pop %ebp
80104038: c3 ret
80104039: 66 90 xchg %ax,%ax
8010403b: 66 90 xchg %ax,%ax
8010403d: 66 90 xchg %ax,%ax
8010403f: 90 nop
80104040 <initlock>:
#include "proc.h"
#include "spinlock.h"
void
initlock(struct spinlock *lk, char *name)
{
80104040: 55 push %ebp
80104041: 89 e5 mov %esp,%ebp
80104043: 8b 45 08 mov 0x8(%ebp),%eax
lk->name = name;
80104046: 8b 55 0c mov 0xc(%ebp),%edx
lk->locked = 0;
80104049: c7 00 00 00 00 00 movl $0x0,(%eax)
lk->name = name;
8010404f: 89 50 04 mov %edx,0x4(%eax)
lk->cpu = 0;
80104052: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
}
80104059: 5d pop %ebp
8010405a: c3 ret
8010405b: 90 nop
8010405c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104060 <getcallerpcs>:
}
// Record the current call stack in pcs[] by following the %ebp chain.
void
getcallerpcs(void *v, uint pcs[])
{
80104060: 55 push %ebp
80104061: 89 e5 mov %esp,%ebp
uint *ebp;
int i;
ebp = (uint*)v - 2;
80104063: 8b 45 08 mov 0x8(%ebp),%eax
{
80104066: 8b 4d 0c mov 0xc(%ebp),%ecx
80104069: 53 push %ebx
ebp = (uint*)v - 2;
8010406a: 8d 50 f8 lea -0x8(%eax),%edx
for(i = 0; i < 10; i++){
8010406d: 31 c0 xor %eax,%eax
8010406f: 90 nop
if(ebp == 0 || ebp < (uint*)KERNBASE || ebp == (uint*)0xffffffff)
80104070: 8d 9a 00 00 00 80 lea -0x80000000(%edx),%ebx
80104076: 81 fb fe ff ff 7f cmp $0x7ffffffe,%ebx
8010407c: 77 1a ja 80104098 <getcallerpcs+0x38>
break;
pcs[i] = ebp[1]; // saved %eip
8010407e: 8b 5a 04 mov 0x4(%edx),%ebx
80104081: 89 1c 81 mov %ebx,(%ecx,%eax,4)
for(i = 0; i < 10; i++){
80104084: 83 c0 01 add $0x1,%eax
ebp = (uint*)ebp[0]; // saved %ebp
80104087: 8b 12 mov (%edx),%edx
for(i = 0; i < 10; i++){
80104089: 83 f8 0a cmp $0xa,%eax
8010408c: 75 e2 jne 80104070 <getcallerpcs+0x10>
}
for(; i < 10; i++)
pcs[i] = 0;
}
8010408e: 5b pop %ebx
8010408f: 5d pop %ebp
80104090: c3 ret
80104091: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
pcs[i] = 0;
80104098: c7 04 81 00 00 00 00 movl $0x0,(%ecx,%eax,4)
for(; i < 10; i++)
8010409f: 83 c0 01 add $0x1,%eax
801040a2: 83 f8 0a cmp $0xa,%eax
801040a5: 74 e7 je 8010408e <getcallerpcs+0x2e>
pcs[i] = 0;
801040a7: c7 04 81 00 00 00 00 movl $0x0,(%ecx,%eax,4)
for(; i < 10; i++)
801040ae: 83 c0 01 add $0x1,%eax
801040b1: 83 f8 0a cmp $0xa,%eax
801040b4: 75 e2 jne 80104098 <getcallerpcs+0x38>
801040b6: eb d6 jmp 8010408e <getcallerpcs+0x2e>
801040b8: 90 nop
801040b9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
801040c0 <holding>:
// Check whether this cpu is holding the lock.
int
holding(struct spinlock *lock)
{
801040c0: 55 push %ebp
return lock->locked && lock->cpu == mycpu();
801040c1: 31 c0 xor %eax,%eax
{
801040c3: 89 e5 mov %esp,%ebp
801040c5: 53 push %ebx
801040c6: 83 ec 04 sub $0x4,%esp
801040c9: 8b 55 08 mov 0x8(%ebp),%edx
return lock->locked && lock->cpu == mycpu();
801040cc: 8b 0a mov (%edx),%ecx
801040ce: 85 c9 test %ecx,%ecx
801040d0: 74 10 je 801040e2 <holding+0x22>
801040d2: 8b 5a 08 mov 0x8(%edx),%ebx
801040d5: e8 16 f5 ff ff call 801035f0 <mycpu>
801040da: 39 c3 cmp %eax,%ebx
801040dc: 0f 94 c0 sete %al
801040df: 0f b6 c0 movzbl %al,%eax
}
801040e2: 83 c4 04 add $0x4,%esp
801040e5: 5b pop %ebx
801040e6: 5d pop %ebp
801040e7: c3 ret
801040e8: 90 nop
801040e9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
801040f0 <pushcli>:
// it takes two popcli to undo two pushcli. Also, if interrupts
// are off, then pushcli, popcli leaves them off.
void
pushcli(void)
{
801040f0: 55 push %ebp
801040f1: 89 e5 mov %esp,%ebp
801040f3: 53 push %ebx
801040f4: 83 ec 04 sub $0x4,%esp
801040f7: 9c pushf
801040f8: 5b pop %ebx
asm volatile("cli");
801040f9: fa cli
int eflags;
eflags = readeflags();
cli();
if(mycpu()->ncli == 0)
801040fa: e8 f1 f4 ff ff call 801035f0 <mycpu>
801040ff: 8b 80 a4 00 00 00 mov 0xa4(%eax),%eax
80104105: 85 c0 test %eax,%eax
80104107: 75 11 jne 8010411a <pushcli+0x2a>
mycpu()->intena = eflags & FL_IF;
80104109: e8 e2 f4 ff ff call 801035f0 <mycpu>
8010410e: 81 e3 00 02 00 00 and $0x200,%ebx
80104114: 89 98 a8 00 00 00 mov %ebx,0xa8(%eax)
mycpu()->ncli += 1;
8010411a: e8 d1 f4 ff ff call 801035f0 <mycpu>
8010411f: 83 80 a4 00 00 00 01 addl $0x1,0xa4(%eax)
}
80104126: 83 c4 04 add $0x4,%esp
80104129: 5b pop %ebx
8010412a: 5d pop %ebp
8010412b: c3 ret
8010412c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104130 <acquire>:
{
80104130: 55 push %ebp
80104131: 89 e5 mov %esp,%ebp
80104133: 53 push %ebx
80104134: 83 ec 14 sub $0x14,%esp
pushcli(); // disable interrupts to avoid deadlock.
80104137: e8 b4 ff ff ff call 801040f0 <pushcli>
if(holding(lk))
8010413c: 8b 55 08 mov 0x8(%ebp),%edx
return lock->locked && lock->cpu == mycpu();
8010413f: 8b 02 mov (%edx),%eax
80104141: 85 c0 test %eax,%eax
80104143: 75 43 jne 80104188 <acquire+0x58>
asm volatile("lock; xchgl %0, %1" :
80104145: b9 01 00 00 00 mov $0x1,%ecx
8010414a: eb 07 jmp 80104153 <acquire+0x23>
8010414c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104150: 8b 55 08 mov 0x8(%ebp),%edx
80104153: 89 c8 mov %ecx,%eax
80104155: f0 87 02 lock xchg %eax,(%edx)
while(xchg(&lk->locked, 1) != 0)
80104158: 85 c0 test %eax,%eax
8010415a: 75 f4 jne 80104150 <acquire+0x20>
__sync_synchronize();
8010415c: 0f ae f0 mfence
lk->cpu = mycpu();
8010415f: 8b 5d 08 mov 0x8(%ebp),%ebx
80104162: e8 89 f4 ff ff call 801035f0 <mycpu>
80104167: 89 43 08 mov %eax,0x8(%ebx)
getcallerpcs(&lk, lk->pcs);
8010416a: 8b 45 08 mov 0x8(%ebp),%eax
8010416d: 83 c0 0c add $0xc,%eax
80104170: 89 44 24 04 mov %eax,0x4(%esp)
80104174: 8d 45 08 lea 0x8(%ebp),%eax
80104177: 89 04 24 mov %eax,(%esp)
8010417a: e8 e1 fe ff ff call 80104060 <getcallerpcs>
}
8010417f: 83 c4 14 add $0x14,%esp
80104182: 5b pop %ebx
80104183: 5d pop %ebp
80104184: c3 ret
80104185: 8d 76 00 lea 0x0(%esi),%esi
return lock->locked && lock->cpu == mycpu();
80104188: 8b 5a 08 mov 0x8(%edx),%ebx
8010418b: e8 60 f4 ff ff call 801035f0 <mycpu>
if(holding(lk))
80104190: 39 c3 cmp %eax,%ebx
80104192: 74 05 je 80104199 <acquire+0x69>
80104194: 8b 55 08 mov 0x8(%ebp),%edx
80104197: eb ac jmp 80104145 <acquire+0x15>
panic("acquire");
80104199: c7 04 24 a3 74 10 80 movl $0x801074a3,(%esp)
801041a0: e8 bb c1 ff ff call 80100360 <panic>
801041a5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801041a9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801041b0 <popcli>:
void
popcli(void)
{
801041b0: 55 push %ebp
801041b1: 89 e5 mov %esp,%ebp
801041b3: 83 ec 18 sub $0x18,%esp
asm volatile("pushfl; popl %0" : "=r" (eflags));
801041b6: 9c pushf
801041b7: 58 pop %eax
if(readeflags()&FL_IF)
801041b8: f6 c4 02 test $0x2,%ah
801041bb: 75 49 jne 80104206 <popcli+0x56>
panic("popcli - interruptible");
if(--mycpu()->ncli < 0)
801041bd: e8 2e f4 ff ff call 801035f0 <mycpu>
801041c2: 8b 88 a4 00 00 00 mov 0xa4(%eax),%ecx
801041c8: 8d 51 ff lea -0x1(%ecx),%edx
801041cb: 85 d2 test %edx,%edx
801041cd: 89 90 a4 00 00 00 mov %edx,0xa4(%eax)
801041d3: 78 25 js 801041fa <popcli+0x4a>
panic("popcli");
if(mycpu()->ncli == 0 && mycpu()->intena)
801041d5: e8 16 f4 ff ff call 801035f0 <mycpu>
801041da: 8b 90 a4 00 00 00 mov 0xa4(%eax),%edx
801041e0: 85 d2 test %edx,%edx
801041e2: 74 04 je 801041e8 <popcli+0x38>
sti();
}
801041e4: c9 leave
801041e5: c3 ret
801041e6: 66 90 xchg %ax,%ax
if(mycpu()->ncli == 0 && mycpu()->intena)
801041e8: e8 03 f4 ff ff call 801035f0 <mycpu>
801041ed: 8b 80 a8 00 00 00 mov 0xa8(%eax),%eax
801041f3: 85 c0 test %eax,%eax
801041f5: 74 ed je 801041e4 <popcli+0x34>
asm volatile("sti");
801041f7: fb sti
}
801041f8: c9 leave
801041f9: c3 ret
panic("popcli");
801041fa: c7 04 24 c2 74 10 80 movl $0x801074c2,(%esp)
80104201: e8 5a c1 ff ff call 80100360 <panic>
panic("popcli - interruptible");
80104206: c7 04 24 ab 74 10 80 movl $0x801074ab,(%esp)
8010420d: e8 4e c1 ff ff call 80100360 <panic>
80104212: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80104219: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80104220 <release>:
{
80104220: 55 push %ebp
80104221: 89 e5 mov %esp,%ebp
80104223: 56 push %esi
80104224: 53 push %ebx
80104225: 83 ec 10 sub $0x10,%esp
80104228: 8b 5d 08 mov 0x8(%ebp),%ebx
return lock->locked && lock->cpu == mycpu();
8010422b: 8b 03 mov (%ebx),%eax
8010422d: 85 c0 test %eax,%eax
8010422f: 75 0f jne 80104240 <release+0x20>
panic("release");
80104231: c7 04 24 c9 74 10 80 movl $0x801074c9,(%esp)
80104238: e8 23 c1 ff ff call 80100360 <panic>
8010423d: 8d 76 00 lea 0x0(%esi),%esi
return lock->locked && lock->cpu == mycpu();
80104240: 8b 73 08 mov 0x8(%ebx),%esi
80104243: e8 a8 f3 ff ff call 801035f0 <mycpu>
if(!holding(lk))
80104248: 39 c6 cmp %eax,%esi
8010424a: 75 e5 jne 80104231 <release+0x11>
lk->pcs[0] = 0;
8010424c: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
lk->cpu = 0;
80104253: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
__sync_synchronize();
8010425a: 0f ae f0 mfence
asm volatile("movl $0, %0" : "+m" (lk->locked) : );
8010425d: c7 03 00 00 00 00 movl $0x0,(%ebx)
}
80104263: 83 c4 10 add $0x10,%esp
80104266: 5b pop %ebx
80104267: 5e pop %esi
80104268: 5d pop %ebp
popcli();
80104269: e9 42 ff ff ff jmp 801041b0 <popcli>
8010426e: 66 90 xchg %ax,%ax
80104270 <memset>:
#include "types.h"
#include "x86.h"
void*
memset(void *dst, int c, uint n)
{
80104270: 55 push %ebp
80104271: 89 e5 mov %esp,%ebp
80104273: 8b 55 08 mov 0x8(%ebp),%edx
80104276: 57 push %edi
80104277: 8b 4d 10 mov 0x10(%ebp),%ecx
8010427a: 53 push %ebx
if ((int)dst%4 == 0 && n%4 == 0){
8010427b: f6 c2 03 test $0x3,%dl
8010427e: 75 05 jne 80104285 <memset+0x15>
80104280: f6 c1 03 test $0x3,%cl
80104283: 74 13 je 80104298 <memset+0x28>
asm volatile("cld; rep stosb" :
80104285: 89 d7 mov %edx,%edi
80104287: 8b 45 0c mov 0xc(%ebp),%eax
8010428a: fc cld
8010428b: f3 aa rep stos %al,%es:(%edi)
c &= 0xFF;
stosl(dst, (c<<24)|(c<<16)|(c<<8)|c, n/4);
} else
stosb(dst, c, n);
return dst;
}
8010428d: 5b pop %ebx
8010428e: 89 d0 mov %edx,%eax
80104290: 5f pop %edi
80104291: 5d pop %ebp
80104292: c3 ret
80104293: 90 nop
80104294: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
c &= 0xFF;
80104298: 0f b6 7d 0c movzbl 0xc(%ebp),%edi
stosl(dst, (c<<24)|(c<<16)|(c<<8)|c, n/4);
8010429c: c1 e9 02 shr $0x2,%ecx
8010429f: 89 f8 mov %edi,%eax
801042a1: 89 fb mov %edi,%ebx
801042a3: c1 e0 18 shl $0x18,%eax
801042a6: c1 e3 10 shl $0x10,%ebx
801042a9: 09 d8 or %ebx,%eax
801042ab: 09 f8 or %edi,%eax
801042ad: c1 e7 08 shl $0x8,%edi
801042b0: 09 f8 or %edi,%eax
asm volatile("cld; rep stosl" :
801042b2: 89 d7 mov %edx,%edi
801042b4: fc cld
801042b5: f3 ab rep stos %eax,%es:(%edi)
}
801042b7: 5b pop %ebx
801042b8: 89 d0 mov %edx,%eax
801042ba: 5f pop %edi
801042bb: 5d pop %ebp
801042bc: c3 ret
801042bd: 8d 76 00 lea 0x0(%esi),%esi
801042c0 <memcmp>:
int
memcmp(const void *v1, const void *v2, uint n)
{
801042c0: 55 push %ebp
801042c1: 89 e5 mov %esp,%ebp
801042c3: 8b 45 10 mov 0x10(%ebp),%eax
801042c6: 57 push %edi
801042c7: 56 push %esi
801042c8: 8b 75 0c mov 0xc(%ebp),%esi
801042cb: 53 push %ebx
801042cc: 8b 5d 08 mov 0x8(%ebp),%ebx
const uchar *s1, *s2;
s1 = v1;
s2 = v2;
while(n-- > 0){
801042cf: 85 c0 test %eax,%eax
801042d1: 8d 78 ff lea -0x1(%eax),%edi
801042d4: 74 26 je 801042fc <memcmp+0x3c>
if(*s1 != *s2)
801042d6: 0f b6 03 movzbl (%ebx),%eax
801042d9: 31 d2 xor %edx,%edx
801042db: 0f b6 0e movzbl (%esi),%ecx
801042de: 38 c8 cmp %cl,%al
801042e0: 74 16 je 801042f8 <memcmp+0x38>
801042e2: eb 24 jmp 80104308 <memcmp+0x48>
801042e4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801042e8: 0f b6 44 13 01 movzbl 0x1(%ebx,%edx,1),%eax
801042ed: 83 c2 01 add $0x1,%edx
801042f0: 0f b6 0c 16 movzbl (%esi,%edx,1),%ecx
801042f4: 38 c8 cmp %cl,%al
801042f6: 75 10 jne 80104308 <memcmp+0x48>
while(n-- > 0){
801042f8: 39 fa cmp %edi,%edx
801042fa: 75 ec jne 801042e8 <memcmp+0x28>
return *s1 - *s2;
s1++, s2++;
}
return 0;
}
801042fc: 5b pop %ebx
return 0;
801042fd: 31 c0 xor %eax,%eax
}
801042ff: 5e pop %esi
80104300: 5f pop %edi
80104301: 5d pop %ebp
80104302: c3 ret
80104303: 90 nop
80104304: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104308: 5b pop %ebx
return *s1 - *s2;
80104309: 29 c8 sub %ecx,%eax
}
8010430b: 5e pop %esi
8010430c: 5f pop %edi
8010430d: 5d pop %ebp
8010430e: c3 ret
8010430f: 90 nop
80104310 <memmove>:
void*
memmove(void *dst, const void *src, uint n)
{
80104310: 55 push %ebp
80104311: 89 e5 mov %esp,%ebp
80104313: 57 push %edi
80104314: 8b 45 08 mov 0x8(%ebp),%eax
80104317: 56 push %esi
80104318: 8b 75 0c mov 0xc(%ebp),%esi
8010431b: 53 push %ebx
8010431c: 8b 5d 10 mov 0x10(%ebp),%ebx
const char *s;
char *d;
s = src;
d = dst;
if(s < d && s + n > d){
8010431f: 39 c6 cmp %eax,%esi
80104321: 73 35 jae 80104358 <memmove+0x48>
80104323: 8d 0c 1e lea (%esi,%ebx,1),%ecx
80104326: 39 c8 cmp %ecx,%eax
80104328: 73 2e jae 80104358 <memmove+0x48>
s += n;
d += n;
while(n-- > 0)
8010432a: 85 db test %ebx,%ebx
d += n;
8010432c: 8d 3c 18 lea (%eax,%ebx,1),%edi
while(n-- > 0)
8010432f: 8d 53 ff lea -0x1(%ebx),%edx
80104332: 74 1b je 8010434f <memmove+0x3f>
80104334: f7 db neg %ebx
80104336: 8d 34 19 lea (%ecx,%ebx,1),%esi
80104339: 01 fb add %edi,%ebx
8010433b: 90 nop
8010433c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
*--d = *--s;
80104340: 0f b6 0c 16 movzbl (%esi,%edx,1),%ecx
80104344: 88 0c 13 mov %cl,(%ebx,%edx,1)
while(n-- > 0)
80104347: 83 ea 01 sub $0x1,%edx
8010434a: 83 fa ff cmp $0xffffffff,%edx
8010434d: 75 f1 jne 80104340 <memmove+0x30>
} else
while(n-- > 0)
*d++ = *s++;
return dst;
}
8010434f: 5b pop %ebx
80104350: 5e pop %esi
80104351: 5f pop %edi
80104352: 5d pop %ebp
80104353: c3 ret
80104354: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
while(n-- > 0)
80104358: 31 d2 xor %edx,%edx
8010435a: 85 db test %ebx,%ebx
8010435c: 74 f1 je 8010434f <memmove+0x3f>
8010435e: 66 90 xchg %ax,%ax
*d++ = *s++;
80104360: 0f b6 0c 16 movzbl (%esi,%edx,1),%ecx
80104364: 88 0c 10 mov %cl,(%eax,%edx,1)
80104367: 83 c2 01 add $0x1,%edx
while(n-- > 0)
8010436a: 39 da cmp %ebx,%edx
8010436c: 75 f2 jne 80104360 <memmove+0x50>
}
8010436e: 5b pop %ebx
8010436f: 5e pop %esi
80104370: 5f pop %edi
80104371: 5d pop %ebp
80104372: c3 ret
80104373: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80104379: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80104380 <memcpy>:
// memcpy exists to placate GCC. Use memmove.
void*
memcpy(void *dst, const void *src, uint n)
{
80104380: 55 push %ebp
80104381: 89 e5 mov %esp,%ebp
return memmove(dst, src, n);
}
80104383: 5d pop %ebp
return memmove(dst, src, n);
80104384: eb 8a jmp 80104310 <memmove>
80104386: 8d 76 00 lea 0x0(%esi),%esi
80104389: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80104390 <strncmp>:
int
strncmp(const char *p, const char *q, uint n)
{
80104390: 55 push %ebp
80104391: 89 e5 mov %esp,%ebp
80104393: 56 push %esi
80104394: 8b 75 10 mov 0x10(%ebp),%esi
80104397: 53 push %ebx
80104398: 8b 4d 08 mov 0x8(%ebp),%ecx
8010439b: 8b 5d 0c mov 0xc(%ebp),%ebx
while(n > 0 && *p && *p == *q)
8010439e: 85 f6 test %esi,%esi
801043a0: 74 30 je 801043d2 <strncmp+0x42>
801043a2: 0f b6 01 movzbl (%ecx),%eax
801043a5: 84 c0 test %al,%al
801043a7: 74 2f je 801043d8 <strncmp+0x48>
801043a9: 0f b6 13 movzbl (%ebx),%edx
801043ac: 38 d0 cmp %dl,%al
801043ae: 75 46 jne 801043f6 <strncmp+0x66>
801043b0: 8d 51 01 lea 0x1(%ecx),%edx
801043b3: 01 ce add %ecx,%esi
801043b5: eb 14 jmp 801043cb <strncmp+0x3b>
801043b7: 90 nop
801043b8: 0f b6 02 movzbl (%edx),%eax
801043bb: 84 c0 test %al,%al
801043bd: 74 31 je 801043f0 <strncmp+0x60>
801043bf: 0f b6 19 movzbl (%ecx),%ebx
801043c2: 83 c2 01 add $0x1,%edx
801043c5: 38 d8 cmp %bl,%al
801043c7: 75 17 jne 801043e0 <strncmp+0x50>
n--, p++, q++;
801043c9: 89 cb mov %ecx,%ebx
while(n > 0 && *p && *p == *q)
801043cb: 39 f2 cmp %esi,%edx
n--, p++, q++;
801043cd: 8d 4b 01 lea 0x1(%ebx),%ecx
while(n > 0 && *p && *p == *q)
801043d0: 75 e6 jne 801043b8 <strncmp+0x28>
if(n == 0)
return 0;
return (uchar)*p - (uchar)*q;
}
801043d2: 5b pop %ebx
return 0;
801043d3: 31 c0 xor %eax,%eax
}
801043d5: 5e pop %esi
801043d6: 5d pop %ebp
801043d7: c3 ret
801043d8: 0f b6 1b movzbl (%ebx),%ebx
while(n > 0 && *p && *p == *q)
801043db: 31 c0 xor %eax,%eax
801043dd: 8d 76 00 lea 0x0(%esi),%esi
return (uchar)*p - (uchar)*q;
801043e0: 0f b6 d3 movzbl %bl,%edx
801043e3: 29 d0 sub %edx,%eax
}
801043e5: 5b pop %ebx
801043e6: 5e pop %esi
801043e7: 5d pop %ebp
801043e8: c3 ret
801043e9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
801043f0: 0f b6 5b 01 movzbl 0x1(%ebx),%ebx
801043f4: eb ea jmp 801043e0 <strncmp+0x50>
while(n > 0 && *p && *p == *q)
801043f6: 89 d3 mov %edx,%ebx
801043f8: eb e6 jmp 801043e0 <strncmp+0x50>
801043fa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80104400 <strncpy>:
char*
strncpy(char *s, const char *t, int n)
{
80104400: 55 push %ebp
80104401: 89 e5 mov %esp,%ebp
80104403: 8b 45 08 mov 0x8(%ebp),%eax
80104406: 56 push %esi
80104407: 8b 4d 10 mov 0x10(%ebp),%ecx
8010440a: 53 push %ebx
8010440b: 8b 5d 0c mov 0xc(%ebp),%ebx
char *os;
os = s;
while(n-- > 0 && (*s++ = *t++) != 0)
8010440e: 89 c2 mov %eax,%edx
80104410: eb 19 jmp 8010442b <strncpy+0x2b>
80104412: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80104418: 83 c3 01 add $0x1,%ebx
8010441b: 0f b6 4b ff movzbl -0x1(%ebx),%ecx
8010441f: 83 c2 01 add $0x1,%edx
80104422: 84 c9 test %cl,%cl
80104424: 88 4a ff mov %cl,-0x1(%edx)
80104427: 74 09 je 80104432 <strncpy+0x32>
80104429: 89 f1 mov %esi,%ecx
8010442b: 85 c9 test %ecx,%ecx
8010442d: 8d 71 ff lea -0x1(%ecx),%esi
80104430: 7f e6 jg 80104418 <strncpy+0x18>
;
while(n-- > 0)
80104432: 31 c9 xor %ecx,%ecx
80104434: 85 f6 test %esi,%esi
80104436: 7e 0f jle 80104447 <strncpy+0x47>
*s++ = 0;
80104438: c6 04 0a 00 movb $0x0,(%edx,%ecx,1)
8010443c: 89 f3 mov %esi,%ebx
8010443e: 83 c1 01 add $0x1,%ecx
80104441: 29 cb sub %ecx,%ebx
while(n-- > 0)
80104443: 85 db test %ebx,%ebx
80104445: 7f f1 jg 80104438 <strncpy+0x38>
return os;
}
80104447: 5b pop %ebx
80104448: 5e pop %esi
80104449: 5d pop %ebp
8010444a: c3 ret
8010444b: 90 nop
8010444c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104450 <safestrcpy>:
// Like strncpy but guaranteed to NUL-terminate.
char*
safestrcpy(char *s, const char *t, int n)
{
80104450: 55 push %ebp
80104451: 89 e5 mov %esp,%ebp
80104453: 8b 4d 10 mov 0x10(%ebp),%ecx
80104456: 56 push %esi
80104457: 8b 45 08 mov 0x8(%ebp),%eax
8010445a: 53 push %ebx
8010445b: 8b 55 0c mov 0xc(%ebp),%edx
char *os;
os = s;
if(n <= 0)
8010445e: 85 c9 test %ecx,%ecx
80104460: 7e 26 jle 80104488 <safestrcpy+0x38>
80104462: 8d 74 0a ff lea -0x1(%edx,%ecx,1),%esi
80104466: 89 c1 mov %eax,%ecx
80104468: eb 17 jmp 80104481 <safestrcpy+0x31>
8010446a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return os;
while(--n > 0 && (*s++ = *t++) != 0)
80104470: 83 c2 01 add $0x1,%edx
80104473: 0f b6 5a ff movzbl -0x1(%edx),%ebx
80104477: 83 c1 01 add $0x1,%ecx
8010447a: 84 db test %bl,%bl
8010447c: 88 59 ff mov %bl,-0x1(%ecx)
8010447f: 74 04 je 80104485 <safestrcpy+0x35>
80104481: 39 f2 cmp %esi,%edx
80104483: 75 eb jne 80104470 <safestrcpy+0x20>
;
*s = 0;
80104485: c6 01 00 movb $0x0,(%ecx)
return os;
}
80104488: 5b pop %ebx
80104489: 5e pop %esi
8010448a: 5d pop %ebp
8010448b: c3 ret
8010448c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104490 <strlen>:
int
strlen(const char *s)
{
80104490: 55 push %ebp
int n;
for(n = 0; s[n]; n++)
80104491: 31 c0 xor %eax,%eax
{
80104493: 89 e5 mov %esp,%ebp
80104495: 8b 55 08 mov 0x8(%ebp),%edx
for(n = 0; s[n]; n++)
80104498: 80 3a 00 cmpb $0x0,(%edx)
8010449b: 74 0c je 801044a9 <strlen+0x19>
8010449d: 8d 76 00 lea 0x0(%esi),%esi
801044a0: 83 c0 01 add $0x1,%eax
801044a3: 80 3c 02 00 cmpb $0x0,(%edx,%eax,1)
801044a7: 75 f7 jne 801044a0 <strlen+0x10>
;
return n;
}
801044a9: 5d pop %ebp
801044aa: c3 ret
801044ab <swtch>:
# Save current register context in old
# and then load register context from new.
.globl swtch
swtch:
movl 4(%esp), %eax
801044ab: 8b 44 24 04 mov 0x4(%esp),%eax
movl 8(%esp), %edx
801044af: 8b 54 24 08 mov 0x8(%esp),%edx
# Save old callee-save registers
pushl %ebp
801044b3: 55 push %ebp
pushl %ebx
801044b4: 53 push %ebx
pushl %esi
801044b5: 56 push %esi
pushl %edi
801044b6: 57 push %edi
# Switch stacks
movl %esp, (%eax)
801044b7: 89 20 mov %esp,(%eax)
movl %edx, %esp
801044b9: 89 d4 mov %edx,%esp
# Load new callee-save registers
popl %edi
801044bb: 5f pop %edi
popl %esi
801044bc: 5e pop %esi
popl %ebx
801044bd: 5b pop %ebx
popl %ebp
801044be: 5d pop %ebp
ret
801044bf: c3 ret
801044c0 <fetchint>:
// to a saved program counter, and then the first argument.
// Fetch the int at addr from the current process.
int
fetchint(uint addr, int *ip)
{
801044c0: 55 push %ebp
801044c1: 89 e5 mov %esp,%ebp
801044c3: 8b 45 08 mov 0x8(%ebp),%eax
//struct proc *curproc = myproc();
if(addr >= USERSTACKTOP || addr+4 > USERSTACKTOP)
801044c6: 3d fb ff ff 7f cmp $0x7ffffffb,%eax
801044cb: 77 0b ja 801044d8 <fetchint+0x18>
return -1;
*ip = *(int*)(addr);
801044cd: 8b 10 mov (%eax),%edx
801044cf: 8b 45 0c mov 0xc(%ebp),%eax
801044d2: 89 10 mov %edx,(%eax)
return 0;
801044d4: 31 c0 xor %eax,%eax
}
801044d6: 5d pop %ebp
801044d7: c3 ret
return -1;
801044d8: b8 ff ff ff ff mov $0xffffffff,%eax
}
801044dd: 5d pop %ebp
801044de: c3 ret
801044df: 90 nop
801044e0 <fetchstr>:
// Fetch the nul-terminated string at addr from the current process.
// Doesn't actually copy the string - just sets *pp to point at it.
// Returns length of string, not including nul.
int
fetchstr(uint addr, char **pp)
{
801044e0: 55 push %ebp
801044e1: 89 e5 mov %esp,%ebp
801044e3: 8b 55 08 mov 0x8(%ebp),%edx
char *s, *ep;
//struct proc *curproc = myproc();
if(addr >= USERSTACKTOP)
801044e6: 81 fa fe ff ff 7f cmp $0x7ffffffe,%edx
801044ec: 77 21 ja 8010450f <fetchstr+0x2f>
return -1;
*pp = (char*)addr;
801044ee: 8b 4d 0c mov 0xc(%ebp),%ecx
801044f1: 89 d0 mov %edx,%eax
801044f3: 89 11 mov %edx,(%ecx)
ep = (char*)USERSTACKTOP;
for(s = *pp; s < ep; s++){
if(*s == 0)
801044f5: 80 3a 00 cmpb $0x0,(%edx)
801044f8: 75 0b jne 80104505 <fetchstr+0x25>
801044fa: eb 1c jmp 80104518 <fetchstr+0x38>
801044fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104500: 80 38 00 cmpb $0x0,(%eax)
80104503: 74 13 je 80104518 <fetchstr+0x38>
for(s = *pp; s < ep; s++){
80104505: 83 c0 01 add $0x1,%eax
80104508: 3d ff ff ff 7f cmp $0x7fffffff,%eax
8010450d: 75 f1 jne 80104500 <fetchstr+0x20>
return -1;
8010450f: b8 ff ff ff ff mov $0xffffffff,%eax
return s - *pp;
}
return -1;
}
80104514: 5d pop %ebp
80104515: c3 ret
80104516: 66 90 xchg %ax,%ax
return s - *pp;
80104518: 29 d0 sub %edx,%eax
}
8010451a: 5d pop %ebp
8010451b: c3 ret
8010451c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104520 <argint>:
// Fetch the nth 32-bit system call argument.
int
argint(int n, int *ip)
{
80104520: 55 push %ebp
80104521: 89 e5 mov %esp,%ebp
80104523: 83 ec 08 sub $0x8,%esp
return fetchint((myproc()->tf->esp) + 4 + 4*n, ip);
80104526: e8 65 f1 ff ff call 80103690 <myproc>
8010452b: 8b 55 08 mov 0x8(%ebp),%edx
8010452e: 8b 40 1c mov 0x1c(%eax),%eax
80104531: 8b 40 44 mov 0x44(%eax),%eax
80104534: 8d 44 90 04 lea 0x4(%eax,%edx,4),%eax
if(addr >= USERSTACKTOP || addr+4 > USERSTACKTOP)
80104538: 3d fb ff ff 7f cmp $0x7ffffffb,%eax
8010453d: 77 11 ja 80104550 <argint+0x30>
*ip = *(int*)(addr);
8010453f: 8b 10 mov (%eax),%edx
80104541: 8b 45 0c mov 0xc(%ebp),%eax
80104544: 89 10 mov %edx,(%eax)
return 0;
80104546: 31 c0 xor %eax,%eax
}
80104548: c9 leave
80104549: c3 ret
8010454a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return -1;
80104550: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104555: c9 leave
80104556: c3 ret
80104557: 89 f6 mov %esi,%esi
80104559: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80104560 <argptr>:
// Fetch the nth word-sized system call argument as a pointer
// to a block of memory of size bytes. Check that the pointer
// lies within the process address space.
int
argptr(int n, char **pp, int size)
{
80104560: 55 push %ebp
80104561: 89 e5 mov %esp,%ebp
80104563: 53 push %ebx
80104564: 83 ec 24 sub $0x24,%esp
80104567: 8b 5d 10 mov 0x10(%ebp),%ebx
int i;
//struct proc *curproc = myproc();
if(argint(n, &i) < 0)
8010456a: 8d 45 f4 lea -0xc(%ebp),%eax
8010456d: 89 44 24 04 mov %eax,0x4(%esp)
80104571: 8b 45 08 mov 0x8(%ebp),%eax
80104574: 89 04 24 mov %eax,(%esp)
80104577: e8 a4 ff ff ff call 80104520 <argint>
8010457c: 85 c0 test %eax,%eax
8010457e: 78 20 js 801045a0 <argptr+0x40>
return -1;
if(size < 0 || (uint)i >= USERSTACKTOP || (uint)i+size > USERSTACKTOP)
80104580: 85 db test %ebx,%ebx
80104582: 78 1c js 801045a0 <argptr+0x40>
80104584: 8b 45 f4 mov -0xc(%ebp),%eax
80104587: 3d fe ff ff 7f cmp $0x7ffffffe,%eax
8010458c: 77 12 ja 801045a0 <argptr+0x40>
8010458e: 01 c3 add %eax,%ebx
80104590: 78 0e js 801045a0 <argptr+0x40>
return -1;
*pp = (char*)i;
80104592: 8b 55 0c mov 0xc(%ebp),%edx
80104595: 89 02 mov %eax,(%edx)
return 0;
80104597: 31 c0 xor %eax,%eax
}
80104599: 83 c4 24 add $0x24,%esp
8010459c: 5b pop %ebx
8010459d: 5d pop %ebp
8010459e: c3 ret
8010459f: 90 nop
return -1;
801045a0: b8 ff ff ff ff mov $0xffffffff,%eax
801045a5: eb f2 jmp 80104599 <argptr+0x39>
801045a7: 89 f6 mov %esi,%esi
801045a9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801045b0 <argstr>:
// Check that the pointer is valid and the string is nul-terminated.
// (There is no shared writable memory, so the string can't change
// between this check and being used by the kernel.)
int
argstr(int n, char **pp)
{
801045b0: 55 push %ebp
801045b1: 89 e5 mov %esp,%ebp
801045b3: 83 ec 28 sub $0x28,%esp
int addr;
if(argint(n, &addr) < 0)
801045b6: 8d 45 f4 lea -0xc(%ebp),%eax
801045b9: 89 44 24 04 mov %eax,0x4(%esp)
801045bd: 8b 45 08 mov 0x8(%ebp),%eax
801045c0: 89 04 24 mov %eax,(%esp)
801045c3: e8 58 ff ff ff call 80104520 <argint>
801045c8: 85 c0 test %eax,%eax
801045ca: 78 2b js 801045f7 <argstr+0x47>
return -1;
return fetchstr(addr, pp);
801045cc: 8b 55 f4 mov -0xc(%ebp),%edx
if(addr >= USERSTACKTOP)
801045cf: 81 fa fe ff ff 7f cmp $0x7ffffffe,%edx
801045d5: 77 20 ja 801045f7 <argstr+0x47>
*pp = (char*)addr;
801045d7: 8b 4d 0c mov 0xc(%ebp),%ecx
801045da: 89 d0 mov %edx,%eax
801045dc: 89 11 mov %edx,(%ecx)
if(*s == 0)
801045de: 80 3a 00 cmpb $0x0,(%edx)
801045e1: 75 0a jne 801045ed <argstr+0x3d>
801045e3: eb 1b jmp 80104600 <argstr+0x50>
801045e5: 8d 76 00 lea 0x0(%esi),%esi
801045e8: 80 38 00 cmpb $0x0,(%eax)
801045eb: 74 13 je 80104600 <argstr+0x50>
for(s = *pp; s < ep; s++){
801045ed: 83 c0 01 add $0x1,%eax
801045f0: 3d fe ff ff 7f cmp $0x7ffffffe,%eax
801045f5: 76 f1 jbe 801045e8 <argstr+0x38>
return -1;
801045f7: b8 ff ff ff ff mov $0xffffffff,%eax
}
801045fc: c9 leave
801045fd: c3 ret
801045fe: 66 90 xchg %ax,%ax
return s - *pp;
80104600: 29 d0 sub %edx,%eax
}
80104602: c9 leave
80104603: c3 ret
80104604: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
8010460a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
80104610 <syscall>:
[SYS_shm_close] sys_shm_close
};
void
syscall(void)
{
80104610: 55 push %ebp
80104611: 89 e5 mov %esp,%ebp
80104613: 56 push %esi
80104614: 53 push %ebx
80104615: 83 ec 10 sub $0x10,%esp
int num;
struct proc *curproc = myproc();
80104618: e8 73 f0 ff ff call 80103690 <myproc>
num = curproc->tf->eax;
8010461d: 8b 70 1c mov 0x1c(%eax),%esi
struct proc *curproc = myproc();
80104620: 89 c3 mov %eax,%ebx
num = curproc->tf->eax;
80104622: 8b 46 1c mov 0x1c(%esi),%eax
if(num > 0 && num < NELEM(syscalls) && syscalls[num]) {
80104625: 8d 50 ff lea -0x1(%eax),%edx
80104628: 83 fa 16 cmp $0x16,%edx
8010462b: 77 1b ja 80104648 <syscall+0x38>
8010462d: 8b 14 85 00 75 10 80 mov -0x7fef8b00(,%eax,4),%edx
80104634: 85 d2 test %edx,%edx
80104636: 74 10 je 80104648 <syscall+0x38>
curproc->tf->eax = syscalls[num]();
80104638: ff d2 call *%edx
8010463a: 89 46 1c mov %eax,0x1c(%esi)
} else {
cprintf("%d %s: unknown sys call %d\n",
curproc->pid, curproc->name, num);
curproc->tf->eax = -1;
}
}
8010463d: 83 c4 10 add $0x10,%esp
80104640: 5b pop %ebx
80104641: 5e pop %esi
80104642: 5d pop %ebp
80104643: c3 ret
80104644: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
cprintf("%d %s: unknown sys call %d\n",
80104648: 89 44 24 0c mov %eax,0xc(%esp)
curproc->pid, curproc->name, num);
8010464c: 8d 43 70 lea 0x70(%ebx),%eax
8010464f: 89 44 24 08 mov %eax,0x8(%esp)
cprintf("%d %s: unknown sys call %d\n",
80104653: 8b 43 14 mov 0x14(%ebx),%eax
80104656: c7 04 24 d1 74 10 80 movl $0x801074d1,(%esp)
8010465d: 89 44 24 04 mov %eax,0x4(%esp)
80104661: e8 ea bf ff ff call 80100650 <cprintf>
curproc->tf->eax = -1;
80104666: 8b 43 1c mov 0x1c(%ebx),%eax
80104669: c7 40 1c ff ff ff ff movl $0xffffffff,0x1c(%eax)
}
80104670: 83 c4 10 add $0x10,%esp
80104673: 5b pop %ebx
80104674: 5e pop %esi
80104675: 5d pop %ebp
80104676: c3 ret
80104677: 66 90 xchg %ax,%ax
80104679: 66 90 xchg %ax,%ax
8010467b: 66 90 xchg %ax,%ax
8010467d: 66 90 xchg %ax,%ax
8010467f: 90 nop
80104680 <fdalloc>:
// Allocate a file descriptor for the given file.
// Takes over file reference from caller on success.
static int
fdalloc(struct file *f)
{
80104680: 55 push %ebp
80104681: 89 e5 mov %esp,%ebp
80104683: 53 push %ebx
80104684: 89 c3 mov %eax,%ebx
80104686: 83 ec 04 sub $0x4,%esp
int fd;
struct proc *curproc = myproc();
80104689: e8 02 f0 ff ff call 80103690 <myproc>
for(fd = 0; fd < NOFILE; fd++){
8010468e: 31 d2 xor %edx,%edx
if(curproc->ofile[fd] == 0){
80104690: 8b 4c 90 2c mov 0x2c(%eax,%edx,4),%ecx
80104694: 85 c9 test %ecx,%ecx
80104696: 74 18 je 801046b0 <fdalloc+0x30>
for(fd = 0; fd < NOFILE; fd++){
80104698: 83 c2 01 add $0x1,%edx
8010469b: 83 fa 10 cmp $0x10,%edx
8010469e: 75 f0 jne 80104690 <fdalloc+0x10>
curproc->ofile[fd] = f;
return fd;
}
}
return -1;
}
801046a0: 83 c4 04 add $0x4,%esp
return -1;
801046a3: b8 ff ff ff ff mov $0xffffffff,%eax
}
801046a8: 5b pop %ebx
801046a9: 5d pop %ebp
801046aa: c3 ret
801046ab: 90 nop
801046ac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
curproc->ofile[fd] = f;
801046b0: 89 5c 90 2c mov %ebx,0x2c(%eax,%edx,4)
}
801046b4: 83 c4 04 add $0x4,%esp
return fd;
801046b7: 89 d0 mov %edx,%eax
}
801046b9: 5b pop %ebx
801046ba: 5d pop %ebp
801046bb: c3 ret
801046bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801046c0 <create>:
return -1;
}
static struct inode*
create(char *path, short type, short major, short minor)
{
801046c0: 55 push %ebp
801046c1: 89 e5 mov %esp,%ebp
801046c3: 57 push %edi
801046c4: 56 push %esi
801046c5: 53 push %ebx
801046c6: 83 ec 4c sub $0x4c,%esp
801046c9: 89 4d c0 mov %ecx,-0x40(%ebp)
801046cc: 8b 4d 08 mov 0x8(%ebp),%ecx
uint off;
struct inode *ip, *dp;
char name[DIRSIZ];
if((dp = nameiparent(path, name)) == 0)
801046cf: 8d 5d da lea -0x26(%ebp),%ebx
801046d2: 89 5c 24 04 mov %ebx,0x4(%esp)
801046d6: 89 04 24 mov %eax,(%esp)
{
801046d9: 89 55 c4 mov %edx,-0x3c(%ebp)
801046dc: 89 4d bc mov %ecx,-0x44(%ebp)
if((dp = nameiparent(path, name)) == 0)
801046df: e8 2c d8 ff ff call 80101f10 <nameiparent>
801046e4: 85 c0 test %eax,%eax
801046e6: 89 c7 mov %eax,%edi
801046e8: 0f 84 da 00 00 00 je 801047c8 <create+0x108>
return 0;
ilock(dp);
801046ee: 89 04 24 mov %eax,(%esp)
801046f1: e8 aa cf ff ff call 801016a0 <ilock>
if((ip = dirlookup(dp, name, &off)) != 0){
801046f6: 8d 45 d4 lea -0x2c(%ebp),%eax
801046f9: 89 44 24 08 mov %eax,0x8(%esp)
801046fd: 89 5c 24 04 mov %ebx,0x4(%esp)
80104701: 89 3c 24 mov %edi,(%esp)
80104704: e8 a7 d4 ff ff call 80101bb0 <dirlookup>
80104709: 85 c0 test %eax,%eax
8010470b: 89 c6 mov %eax,%esi
8010470d: 74 41 je 80104750 <create+0x90>
iunlockput(dp);
8010470f: 89 3c 24 mov %edi,(%esp)
80104712: e8 e9 d1 ff ff call 80101900 <iunlockput>
ilock(ip);
80104717: 89 34 24 mov %esi,(%esp)
8010471a: e8 81 cf ff ff call 801016a0 <ilock>
if(type == T_FILE && ip->type == T_FILE)
8010471f: 66 83 7d c4 02 cmpw $0x2,-0x3c(%ebp)
80104724: 75 12 jne 80104738 <create+0x78>
80104726: 66 83 7e 50 02 cmpw $0x2,0x50(%esi)
8010472b: 89 f0 mov %esi,%eax
8010472d: 75 09 jne 80104738 <create+0x78>
panic("create: dirlink");
iunlockput(dp);
return ip;
}
8010472f: 83 c4 4c add $0x4c,%esp
80104732: 5b pop %ebx
80104733: 5e pop %esi
80104734: 5f pop %edi
80104735: 5d pop %ebp
80104736: c3 ret
80104737: 90 nop
iunlockput(ip);
80104738: 89 34 24 mov %esi,(%esp)
8010473b: e8 c0 d1 ff ff call 80101900 <iunlockput>
}
80104740: 83 c4 4c add $0x4c,%esp
return 0;
80104743: 31 c0 xor %eax,%eax
}
80104745: 5b pop %ebx
80104746: 5e pop %esi
80104747: 5f pop %edi
80104748: 5d pop %ebp
80104749: c3 ret
8010474a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if((ip = ialloc(dp->dev, type)) == 0)
80104750: 0f bf 45 c4 movswl -0x3c(%ebp),%eax
80104754: 89 44 24 04 mov %eax,0x4(%esp)
80104758: 8b 07 mov (%edi),%eax
8010475a: 89 04 24 mov %eax,(%esp)
8010475d: e8 ae cd ff ff call 80101510 <ialloc>
80104762: 85 c0 test %eax,%eax
80104764: 89 c6 mov %eax,%esi
80104766: 0f 84 bf 00 00 00 je 8010482b <create+0x16b>
ilock(ip);
8010476c: 89 04 24 mov %eax,(%esp)
8010476f: e8 2c cf ff ff call 801016a0 <ilock>
ip->major = major;
80104774: 0f b7 45 c0 movzwl -0x40(%ebp),%eax
80104778: 66 89 46 52 mov %ax,0x52(%esi)
ip->minor = minor;
8010477c: 0f b7 45 bc movzwl -0x44(%ebp),%eax
80104780: 66 89 46 54 mov %ax,0x54(%esi)
ip->nlink = 1;
80104784: b8 01 00 00 00 mov $0x1,%eax
80104789: 66 89 46 56 mov %ax,0x56(%esi)
iupdate(ip);
8010478d: 89 34 24 mov %esi,(%esp)
80104790: e8 4b ce ff ff call 801015e0 <iupdate>
if(type == T_DIR){ // Create . and .. entries.
80104795: 66 83 7d c4 01 cmpw $0x1,-0x3c(%ebp)
8010479a: 74 34 je 801047d0 <create+0x110>
if(dirlink(dp, name, ip->inum) < 0)
8010479c: 8b 46 04 mov 0x4(%esi),%eax
8010479f: 89 5c 24 04 mov %ebx,0x4(%esp)
801047a3: 89 3c 24 mov %edi,(%esp)
801047a6: 89 44 24 08 mov %eax,0x8(%esp)
801047aa: e8 61 d6 ff ff call 80101e10 <dirlink>
801047af: 85 c0 test %eax,%eax
801047b1: 78 6c js 8010481f <create+0x15f>
iunlockput(dp);
801047b3: 89 3c 24 mov %edi,(%esp)
801047b6: e8 45 d1 ff ff call 80101900 <iunlockput>
}
801047bb: 83 c4 4c add $0x4c,%esp
return ip;
801047be: 89 f0 mov %esi,%eax
}
801047c0: 5b pop %ebx
801047c1: 5e pop %esi
801047c2: 5f pop %edi
801047c3: 5d pop %ebp
801047c4: c3 ret
801047c5: 8d 76 00 lea 0x0(%esi),%esi
return 0;
801047c8: 31 c0 xor %eax,%eax
801047ca: e9 60 ff ff ff jmp 8010472f <create+0x6f>
801047cf: 90 nop
dp->nlink++; // for ".."
801047d0: 66 83 47 56 01 addw $0x1,0x56(%edi)
iupdate(dp);
801047d5: 89 3c 24 mov %edi,(%esp)
801047d8: e8 03 ce ff ff call 801015e0 <iupdate>
if(dirlink(ip, ".", ip->inum) < 0 || dirlink(ip, "..", dp->inum) < 0)
801047dd: 8b 46 04 mov 0x4(%esi),%eax
801047e0: c7 44 24 04 7c 75 10 movl $0x8010757c,0x4(%esp)
801047e7: 80
801047e8: 89 34 24 mov %esi,(%esp)
801047eb: 89 44 24 08 mov %eax,0x8(%esp)
801047ef: e8 1c d6 ff ff call 80101e10 <dirlink>
801047f4: 85 c0 test %eax,%eax
801047f6: 78 1b js 80104813 <create+0x153>
801047f8: 8b 47 04 mov 0x4(%edi),%eax
801047fb: c7 44 24 04 7b 75 10 movl $0x8010757b,0x4(%esp)
80104802: 80
80104803: 89 34 24 mov %esi,(%esp)
80104806: 89 44 24 08 mov %eax,0x8(%esp)
8010480a: e8 01 d6 ff ff call 80101e10 <dirlink>
8010480f: 85 c0 test %eax,%eax
80104811: 79 89 jns 8010479c <create+0xdc>
panic("create dots");
80104813: c7 04 24 6f 75 10 80 movl $0x8010756f,(%esp)
8010481a: e8 41 bb ff ff call 80100360 <panic>
panic("create: dirlink");
8010481f: c7 04 24 7e 75 10 80 movl $0x8010757e,(%esp)
80104826: e8 35 bb ff ff call 80100360 <panic>
panic("create: ialloc");
8010482b: c7 04 24 60 75 10 80 movl $0x80107560,(%esp)
80104832: e8 29 bb ff ff call 80100360 <panic>
80104837: 89 f6 mov %esi,%esi
80104839: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80104840 <argfd.constprop.0>:
argfd(int n, int *pfd, struct file **pf)
80104840: 55 push %ebp
80104841: 89 e5 mov %esp,%ebp
80104843: 56 push %esi
80104844: 89 c6 mov %eax,%esi
80104846: 53 push %ebx
80104847: 89 d3 mov %edx,%ebx
80104849: 83 ec 20 sub $0x20,%esp
if(argint(n, &fd) < 0)
8010484c: 8d 45 f4 lea -0xc(%ebp),%eax
8010484f: 89 44 24 04 mov %eax,0x4(%esp)
80104853: c7 04 24 00 00 00 00 movl $0x0,(%esp)
8010485a: e8 c1 fc ff ff call 80104520 <argint>
8010485f: 85 c0 test %eax,%eax
80104861: 78 2d js 80104890 <argfd.constprop.0+0x50>
if(fd < 0 || fd >= NOFILE || (f=myproc()->ofile[fd]) == 0)
80104863: 83 7d f4 0f cmpl $0xf,-0xc(%ebp)
80104867: 77 27 ja 80104890 <argfd.constprop.0+0x50>
80104869: e8 22 ee ff ff call 80103690 <myproc>
8010486e: 8b 55 f4 mov -0xc(%ebp),%edx
80104871: 8b 44 90 2c mov 0x2c(%eax,%edx,4),%eax
80104875: 85 c0 test %eax,%eax
80104877: 74 17 je 80104890 <argfd.constprop.0+0x50>
if(pfd)
80104879: 85 f6 test %esi,%esi
8010487b: 74 02 je 8010487f <argfd.constprop.0+0x3f>
*pfd = fd;
8010487d: 89 16 mov %edx,(%esi)
if(pf)
8010487f: 85 db test %ebx,%ebx
80104881: 74 1d je 801048a0 <argfd.constprop.0+0x60>
*pf = f;
80104883: 89 03 mov %eax,(%ebx)
return 0;
80104885: 31 c0 xor %eax,%eax
}
80104887: 83 c4 20 add $0x20,%esp
8010488a: 5b pop %ebx
8010488b: 5e pop %esi
8010488c: 5d pop %ebp
8010488d: c3 ret
8010488e: 66 90 xchg %ax,%ax
80104890: 83 c4 20 add $0x20,%esp
return -1;
80104893: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104898: 5b pop %ebx
80104899: 5e pop %esi
8010489a: 5d pop %ebp
8010489b: c3 ret
8010489c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return 0;
801048a0: 31 c0 xor %eax,%eax
801048a2: eb e3 jmp 80104887 <argfd.constprop.0+0x47>
801048a4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801048aa: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
801048b0 <sys_dup>:
{
801048b0: 55 push %ebp
if(argfd(0, 0, &f) < 0)
801048b1: 31 c0 xor %eax,%eax
{
801048b3: 89 e5 mov %esp,%ebp
801048b5: 53 push %ebx
801048b6: 83 ec 24 sub $0x24,%esp
if(argfd(0, 0, &f) < 0)
801048b9: 8d 55 f4 lea -0xc(%ebp),%edx
801048bc: e8 7f ff ff ff call 80104840 <argfd.constprop.0>
801048c1: 85 c0 test %eax,%eax
801048c3: 78 23 js 801048e8 <sys_dup+0x38>
if((fd=fdalloc(f)) < 0)
801048c5: 8b 45 f4 mov -0xc(%ebp),%eax
801048c8: e8 b3 fd ff ff call 80104680 <fdalloc>
801048cd: 85 c0 test %eax,%eax
801048cf: 89 c3 mov %eax,%ebx
801048d1: 78 15 js 801048e8 <sys_dup+0x38>
filedup(f);
801048d3: 8b 45 f4 mov -0xc(%ebp),%eax
801048d6: 89 04 24 mov %eax,(%esp)
801048d9: e8 e2 c4 ff ff call 80100dc0 <filedup>
return fd;
801048de: 89 d8 mov %ebx,%eax
}
801048e0: 83 c4 24 add $0x24,%esp
801048e3: 5b pop %ebx
801048e4: 5d pop %ebp
801048e5: c3 ret
801048e6: 66 90 xchg %ax,%ax
return -1;
801048e8: b8 ff ff ff ff mov $0xffffffff,%eax
801048ed: eb f1 jmp 801048e0 <sys_dup+0x30>
801048ef: 90 nop
801048f0 <sys_read>:
{
801048f0: 55 push %ebp
if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argptr(1, &p, n) < 0)
801048f1: 31 c0 xor %eax,%eax
{
801048f3: 89 e5 mov %esp,%ebp
801048f5: 83 ec 28 sub $0x28,%esp
if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argptr(1, &p, n) < 0)
801048f8: 8d 55 ec lea -0x14(%ebp),%edx
801048fb: e8 40 ff ff ff call 80104840 <argfd.constprop.0>
80104900: 85 c0 test %eax,%eax
80104902: 78 54 js 80104958 <sys_read+0x68>
80104904: 8d 45 f0 lea -0x10(%ebp),%eax
80104907: 89 44 24 04 mov %eax,0x4(%esp)
8010490b: c7 04 24 02 00 00 00 movl $0x2,(%esp)
80104912: e8 09 fc ff ff call 80104520 <argint>
80104917: 85 c0 test %eax,%eax
80104919: 78 3d js 80104958 <sys_read+0x68>
8010491b: 8b 45 f0 mov -0x10(%ebp),%eax
8010491e: c7 04 24 01 00 00 00 movl $0x1,(%esp)
80104925: 89 44 24 08 mov %eax,0x8(%esp)
80104929: 8d 45 f4 lea -0xc(%ebp),%eax
8010492c: 89 44 24 04 mov %eax,0x4(%esp)
80104930: e8 2b fc ff ff call 80104560 <argptr>
80104935: 85 c0 test %eax,%eax
80104937: 78 1f js 80104958 <sys_read+0x68>
return fileread(f, p, n);
80104939: 8b 45 f0 mov -0x10(%ebp),%eax
8010493c: 89 44 24 08 mov %eax,0x8(%esp)
80104940: 8b 45 f4 mov -0xc(%ebp),%eax
80104943: 89 44 24 04 mov %eax,0x4(%esp)
80104947: 8b 45 ec mov -0x14(%ebp),%eax
8010494a: 89 04 24 mov %eax,(%esp)
8010494d: e8 ce c5 ff ff call 80100f20 <fileread>
}
80104952: c9 leave
80104953: c3 ret
80104954: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return -1;
80104958: b8 ff ff ff ff mov $0xffffffff,%eax
}
8010495d: c9 leave
8010495e: c3 ret
8010495f: 90 nop
80104960 <sys_write>:
{
80104960: 55 push %ebp
if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argptr(1, &p, n) < 0)
80104961: 31 c0 xor %eax,%eax
{
80104963: 89 e5 mov %esp,%ebp
80104965: 83 ec 28 sub $0x28,%esp
if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argptr(1, &p, n) < 0)
80104968: 8d 55 ec lea -0x14(%ebp),%edx
8010496b: e8 d0 fe ff ff call 80104840 <argfd.constprop.0>
80104970: 85 c0 test %eax,%eax
80104972: 78 54 js 801049c8 <sys_write+0x68>
80104974: 8d 45 f0 lea -0x10(%ebp),%eax
80104977: 89 44 24 04 mov %eax,0x4(%esp)
8010497b: c7 04 24 02 00 00 00 movl $0x2,(%esp)
80104982: e8 99 fb ff ff call 80104520 <argint>
80104987: 85 c0 test %eax,%eax
80104989: 78 3d js 801049c8 <sys_write+0x68>
8010498b: 8b 45 f0 mov -0x10(%ebp),%eax
8010498e: c7 04 24 01 00 00 00 movl $0x1,(%esp)
80104995: 89 44 24 08 mov %eax,0x8(%esp)
80104999: 8d 45 f4 lea -0xc(%ebp),%eax
8010499c: 89 44 24 04 mov %eax,0x4(%esp)
801049a0: e8 bb fb ff ff call 80104560 <argptr>
801049a5: 85 c0 test %eax,%eax
801049a7: 78 1f js 801049c8 <sys_write+0x68>
return filewrite(f, p, n);
801049a9: 8b 45 f0 mov -0x10(%ebp),%eax
801049ac: 89 44 24 08 mov %eax,0x8(%esp)
801049b0: 8b 45 f4 mov -0xc(%ebp),%eax
801049b3: 89 44 24 04 mov %eax,0x4(%esp)
801049b7: 8b 45 ec mov -0x14(%ebp),%eax
801049ba: 89 04 24 mov %eax,(%esp)
801049bd: e8 fe c5 ff ff call 80100fc0 <filewrite>
}
801049c2: c9 leave
801049c3: c3 ret
801049c4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return -1;
801049c8: b8 ff ff ff ff mov $0xffffffff,%eax
}
801049cd: c9 leave
801049ce: c3 ret
801049cf: 90 nop
801049d0 <sys_close>:
{
801049d0: 55 push %ebp
801049d1: 89 e5 mov %esp,%ebp
801049d3: 83 ec 28 sub $0x28,%esp
if(argfd(0, &fd, &f) < 0)
801049d6: 8d 55 f4 lea -0xc(%ebp),%edx
801049d9: 8d 45 f0 lea -0x10(%ebp),%eax
801049dc: e8 5f fe ff ff call 80104840 <argfd.constprop.0>
801049e1: 85 c0 test %eax,%eax
801049e3: 78 23 js 80104a08 <sys_close+0x38>
myproc()->ofile[fd] = 0;
801049e5: e8 a6 ec ff ff call 80103690 <myproc>
801049ea: 8b 55 f0 mov -0x10(%ebp),%edx
801049ed: c7 44 90 2c 00 00 00 movl $0x0,0x2c(%eax,%edx,4)
801049f4: 00
fileclose(f);
801049f5: 8b 45 f4 mov -0xc(%ebp),%eax
801049f8: 89 04 24 mov %eax,(%esp)
801049fb: e8 10 c4 ff ff call 80100e10 <fileclose>
return 0;
80104a00: 31 c0 xor %eax,%eax
}
80104a02: c9 leave
80104a03: c3 ret
80104a04: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return -1;
80104a08: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104a0d: c9 leave
80104a0e: c3 ret
80104a0f: 90 nop
80104a10 <sys_fstat>:
{
80104a10: 55 push %ebp
if(argfd(0, 0, &f) < 0 || argptr(1, (void*)&st, sizeof(*st)) < 0)
80104a11: 31 c0 xor %eax,%eax
{
80104a13: 89 e5 mov %esp,%ebp
80104a15: 83 ec 28 sub $0x28,%esp
if(argfd(0, 0, &f) < 0 || argptr(1, (void*)&st, sizeof(*st)) < 0)
80104a18: 8d 55 f0 lea -0x10(%ebp),%edx
80104a1b: e8 20 fe ff ff call 80104840 <argfd.constprop.0>
80104a20: 85 c0 test %eax,%eax
80104a22: 78 34 js 80104a58 <sys_fstat+0x48>
80104a24: 8d 45 f4 lea -0xc(%ebp),%eax
80104a27: c7 44 24 08 14 00 00 movl $0x14,0x8(%esp)
80104a2e: 00
80104a2f: 89 44 24 04 mov %eax,0x4(%esp)
80104a33: c7 04 24 01 00 00 00 movl $0x1,(%esp)
80104a3a: e8 21 fb ff ff call 80104560 <argptr>
80104a3f: 85 c0 test %eax,%eax
80104a41: 78 15 js 80104a58 <sys_fstat+0x48>
return filestat(f, st);
80104a43: 8b 45 f4 mov -0xc(%ebp),%eax
80104a46: 89 44 24 04 mov %eax,0x4(%esp)
80104a4a: 8b 45 f0 mov -0x10(%ebp),%eax
80104a4d: 89 04 24 mov %eax,(%esp)
80104a50: e8 7b c4 ff ff call 80100ed0 <filestat>
}
80104a55: c9 leave
80104a56: c3 ret
80104a57: 90 nop
return -1;
80104a58: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104a5d: c9 leave
80104a5e: c3 ret
80104a5f: 90 nop
80104a60 <sys_link>:
{
80104a60: 55 push %ebp
80104a61: 89 e5 mov %esp,%ebp
80104a63: 57 push %edi
80104a64: 56 push %esi
80104a65: 53 push %ebx
80104a66: 83 ec 3c sub $0x3c,%esp
if(argstr(0, &old) < 0 || argstr(1, &new) < 0)
80104a69: 8d 45 d4 lea -0x2c(%ebp),%eax
80104a6c: 89 44 24 04 mov %eax,0x4(%esp)
80104a70: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104a77: e8 34 fb ff ff call 801045b0 <argstr>
80104a7c: 85 c0 test %eax,%eax
80104a7e: 0f 88 e6 00 00 00 js 80104b6a <sys_link+0x10a>
80104a84: 8d 45 d0 lea -0x30(%ebp),%eax
80104a87: 89 44 24 04 mov %eax,0x4(%esp)
80104a8b: c7 04 24 01 00 00 00 movl $0x1,(%esp)
80104a92: e8 19 fb ff ff call 801045b0 <argstr>
80104a97: 85 c0 test %eax,%eax
80104a99: 0f 88 cb 00 00 00 js 80104b6a <sys_link+0x10a>
begin_op();
80104a9f: e8 5c e0 ff ff call 80102b00 <begin_op>
if((ip = namei(old)) == 0){
80104aa4: 8b 45 d4 mov -0x2c(%ebp),%eax
80104aa7: 89 04 24 mov %eax,(%esp)
80104aaa: e8 41 d4 ff ff call 80101ef0 <namei>
80104aaf: 85 c0 test %eax,%eax
80104ab1: 89 c3 mov %eax,%ebx
80104ab3: 0f 84 ac 00 00 00 je 80104b65 <sys_link+0x105>
ilock(ip);
80104ab9: 89 04 24 mov %eax,(%esp)
80104abc: e8 df cb ff ff call 801016a0 <ilock>
if(ip->type == T_DIR){
80104ac1: 66 83 7b 50 01 cmpw $0x1,0x50(%ebx)
80104ac6: 0f 84 91 00 00 00 je 80104b5d <sys_link+0xfd>
ip->nlink++;
80104acc: 66 83 43 56 01 addw $0x1,0x56(%ebx)
if((dp = nameiparent(new, name)) == 0)
80104ad1: 8d 7d da lea -0x26(%ebp),%edi
iupdate(ip);
80104ad4: 89 1c 24 mov %ebx,(%esp)
80104ad7: e8 04 cb ff ff call 801015e0 <iupdate>
iunlock(ip);
80104adc: 89 1c 24 mov %ebx,(%esp)
80104adf: e8 9c cc ff ff call 80101780 <iunlock>
if((dp = nameiparent(new, name)) == 0)
80104ae4: 8b 45 d0 mov -0x30(%ebp),%eax
80104ae7: 89 7c 24 04 mov %edi,0x4(%esp)
80104aeb: 89 04 24 mov %eax,(%esp)
80104aee: e8 1d d4 ff ff call 80101f10 <nameiparent>
80104af3: 85 c0 test %eax,%eax
80104af5: 89 c6 mov %eax,%esi
80104af7: 74 4f je 80104b48 <sys_link+0xe8>
ilock(dp);
80104af9: 89 04 24 mov %eax,(%esp)
80104afc: e8 9f cb ff ff call 801016a0 <ilock>
if(dp->dev != ip->dev || dirlink(dp, name, ip->inum) < 0){
80104b01: 8b 03 mov (%ebx),%eax
80104b03: 39 06 cmp %eax,(%esi)
80104b05: 75 39 jne 80104b40 <sys_link+0xe0>
80104b07: 8b 43 04 mov 0x4(%ebx),%eax
80104b0a: 89 7c 24 04 mov %edi,0x4(%esp)
80104b0e: 89 34 24 mov %esi,(%esp)
80104b11: 89 44 24 08 mov %eax,0x8(%esp)
80104b15: e8 f6 d2 ff ff call 80101e10 <dirlink>
80104b1a: 85 c0 test %eax,%eax
80104b1c: 78 22 js 80104b40 <sys_link+0xe0>
iunlockput(dp);
80104b1e: 89 34 24 mov %esi,(%esp)
80104b21: e8 da cd ff ff call 80101900 <iunlockput>
iput(ip);
80104b26: 89 1c 24 mov %ebx,(%esp)
80104b29: e8 92 cc ff ff call 801017c0 <iput>
end_op();
80104b2e: e8 3d e0 ff ff call 80102b70 <end_op>
}
80104b33: 83 c4 3c add $0x3c,%esp
return 0;
80104b36: 31 c0 xor %eax,%eax
}
80104b38: 5b pop %ebx
80104b39: 5e pop %esi
80104b3a: 5f pop %edi
80104b3b: 5d pop %ebp
80104b3c: c3 ret
80104b3d: 8d 76 00 lea 0x0(%esi),%esi
iunlockput(dp);
80104b40: 89 34 24 mov %esi,(%esp)
80104b43: e8 b8 cd ff ff call 80101900 <iunlockput>
ilock(ip);
80104b48: 89 1c 24 mov %ebx,(%esp)
80104b4b: e8 50 cb ff ff call 801016a0 <ilock>
ip->nlink--;
80104b50: 66 83 6b 56 01 subw $0x1,0x56(%ebx)
iupdate(ip);
80104b55: 89 1c 24 mov %ebx,(%esp)
80104b58: e8 83 ca ff ff call 801015e0 <iupdate>
iunlockput(ip);
80104b5d: 89 1c 24 mov %ebx,(%esp)
80104b60: e8 9b cd ff ff call 80101900 <iunlockput>
end_op();
80104b65: e8 06 e0 ff ff call 80102b70 <end_op>
}
80104b6a: 83 c4 3c add $0x3c,%esp
return -1;
80104b6d: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104b72: 5b pop %ebx
80104b73: 5e pop %esi
80104b74: 5f pop %edi
80104b75: 5d pop %ebp
80104b76: c3 ret
80104b77: 89 f6 mov %esi,%esi
80104b79: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80104b80 <sys_unlink>:
{
80104b80: 55 push %ebp
80104b81: 89 e5 mov %esp,%ebp
80104b83: 57 push %edi
80104b84: 56 push %esi
80104b85: 53 push %ebx
80104b86: 83 ec 5c sub $0x5c,%esp
if(argstr(0, &path) < 0)
80104b89: 8d 45 c0 lea -0x40(%ebp),%eax
80104b8c: 89 44 24 04 mov %eax,0x4(%esp)
80104b90: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104b97: e8 14 fa ff ff call 801045b0 <argstr>
80104b9c: 85 c0 test %eax,%eax
80104b9e: 0f 88 76 01 00 00 js 80104d1a <sys_unlink+0x19a>
begin_op();
80104ba4: e8 57 df ff ff call 80102b00 <begin_op>
if((dp = nameiparent(path, name)) == 0){
80104ba9: 8b 45 c0 mov -0x40(%ebp),%eax
80104bac: 8d 5d ca lea -0x36(%ebp),%ebx
80104baf: 89 5c 24 04 mov %ebx,0x4(%esp)
80104bb3: 89 04 24 mov %eax,(%esp)
80104bb6: e8 55 d3 ff ff call 80101f10 <nameiparent>
80104bbb: 85 c0 test %eax,%eax
80104bbd: 89 45 b4 mov %eax,-0x4c(%ebp)
80104bc0: 0f 84 4f 01 00 00 je 80104d15 <sys_unlink+0x195>
ilock(dp);
80104bc6: 8b 75 b4 mov -0x4c(%ebp),%esi
80104bc9: 89 34 24 mov %esi,(%esp)
80104bcc: e8 cf ca ff ff call 801016a0 <ilock>
if(namecmp(name, ".") == 0 || namecmp(name, "..") == 0)
80104bd1: c7 44 24 04 7c 75 10 movl $0x8010757c,0x4(%esp)
80104bd8: 80
80104bd9: 89 1c 24 mov %ebx,(%esp)
80104bdc: e8 9f cf ff ff call 80101b80 <namecmp>
80104be1: 85 c0 test %eax,%eax
80104be3: 0f 84 21 01 00 00 je 80104d0a <sys_unlink+0x18a>
80104be9: c7 44 24 04 7b 75 10 movl $0x8010757b,0x4(%esp)
80104bf0: 80
80104bf1: 89 1c 24 mov %ebx,(%esp)
80104bf4: e8 87 cf ff ff call 80101b80 <namecmp>
80104bf9: 85 c0 test %eax,%eax
80104bfb: 0f 84 09 01 00 00 je 80104d0a <sys_unlink+0x18a>
if((ip = dirlookup(dp, name, &off)) == 0)
80104c01: 8d 45 c4 lea -0x3c(%ebp),%eax
80104c04: 89 5c 24 04 mov %ebx,0x4(%esp)
80104c08: 89 44 24 08 mov %eax,0x8(%esp)
80104c0c: 89 34 24 mov %esi,(%esp)
80104c0f: e8 9c cf ff ff call 80101bb0 <dirlookup>
80104c14: 85 c0 test %eax,%eax
80104c16: 89 c3 mov %eax,%ebx
80104c18: 0f 84 ec 00 00 00 je 80104d0a <sys_unlink+0x18a>
ilock(ip);
80104c1e: 89 04 24 mov %eax,(%esp)
80104c21: e8 7a ca ff ff call 801016a0 <ilock>
if(ip->nlink < 1)
80104c26: 66 83 7b 56 00 cmpw $0x0,0x56(%ebx)
80104c2b: 0f 8e 24 01 00 00 jle 80104d55 <sys_unlink+0x1d5>
if(ip->type == T_DIR && !isdirempty(ip)){
80104c31: 66 83 7b 50 01 cmpw $0x1,0x50(%ebx)
80104c36: 8d 75 d8 lea -0x28(%ebp),%esi
80104c39: 74 7d je 80104cb8 <sys_unlink+0x138>
memset(&de, 0, sizeof(de));
80104c3b: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp)
80104c42: 00
80104c43: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80104c4a: 00
80104c4b: 89 34 24 mov %esi,(%esp)
80104c4e: e8 1d f6 ff ff call 80104270 <memset>
if(writei(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
80104c53: 8b 45 c4 mov -0x3c(%ebp),%eax
80104c56: c7 44 24 0c 10 00 00 movl $0x10,0xc(%esp)
80104c5d: 00
80104c5e: 89 74 24 04 mov %esi,0x4(%esp)
80104c62: 89 44 24 08 mov %eax,0x8(%esp)
80104c66: 8b 45 b4 mov -0x4c(%ebp),%eax
80104c69: 89 04 24 mov %eax,(%esp)
80104c6c: e8 df cd ff ff call 80101a50 <writei>
80104c71: 83 f8 10 cmp $0x10,%eax
80104c74: 0f 85 cf 00 00 00 jne 80104d49 <sys_unlink+0x1c9>
if(ip->type == T_DIR){
80104c7a: 66 83 7b 50 01 cmpw $0x1,0x50(%ebx)
80104c7f: 0f 84 a3 00 00 00 je 80104d28 <sys_unlink+0x1a8>
iunlockput(dp);
80104c85: 8b 45 b4 mov -0x4c(%ebp),%eax
80104c88: 89 04 24 mov %eax,(%esp)
80104c8b: e8 70 cc ff ff call 80101900 <iunlockput>
ip->nlink--;
80104c90: 66 83 6b 56 01 subw $0x1,0x56(%ebx)
iupdate(ip);
80104c95: 89 1c 24 mov %ebx,(%esp)
80104c98: e8 43 c9 ff ff call 801015e0 <iupdate>
iunlockput(ip);
80104c9d: 89 1c 24 mov %ebx,(%esp)
80104ca0: e8 5b cc ff ff call 80101900 <iunlockput>
end_op();
80104ca5: e8 c6 de ff ff call 80102b70 <end_op>
}
80104caa: 83 c4 5c add $0x5c,%esp
return 0;
80104cad: 31 c0 xor %eax,%eax
}
80104caf: 5b pop %ebx
80104cb0: 5e pop %esi
80104cb1: 5f pop %edi
80104cb2: 5d pop %ebp
80104cb3: c3 ret
80104cb4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for(off=2*sizeof(de); off<dp->size; off+=sizeof(de)){
80104cb8: 83 7b 58 20 cmpl $0x20,0x58(%ebx)
80104cbc: 0f 86 79 ff ff ff jbe 80104c3b <sys_unlink+0xbb>
80104cc2: bf 20 00 00 00 mov $0x20,%edi
80104cc7: eb 15 jmp 80104cde <sys_unlink+0x15e>
80104cc9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80104cd0: 8d 57 10 lea 0x10(%edi),%edx
80104cd3: 3b 53 58 cmp 0x58(%ebx),%edx
80104cd6: 0f 83 5f ff ff ff jae 80104c3b <sys_unlink+0xbb>
80104cdc: 89 d7 mov %edx,%edi
if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
80104cde: c7 44 24 0c 10 00 00 movl $0x10,0xc(%esp)
80104ce5: 00
80104ce6: 89 7c 24 08 mov %edi,0x8(%esp)
80104cea: 89 74 24 04 mov %esi,0x4(%esp)
80104cee: 89 1c 24 mov %ebx,(%esp)
80104cf1: e8 5a cc ff ff call 80101950 <readi>
80104cf6: 83 f8 10 cmp $0x10,%eax
80104cf9: 75 42 jne 80104d3d <sys_unlink+0x1bd>
if(de.inum != 0)
80104cfb: 66 83 7d d8 00 cmpw $0x0,-0x28(%ebp)
80104d00: 74 ce je 80104cd0 <sys_unlink+0x150>
iunlockput(ip);
80104d02: 89 1c 24 mov %ebx,(%esp)
80104d05: e8 f6 cb ff ff call 80101900 <iunlockput>
iunlockput(dp);
80104d0a: 8b 45 b4 mov -0x4c(%ebp),%eax
80104d0d: 89 04 24 mov %eax,(%esp)
80104d10: e8 eb cb ff ff call 80101900 <iunlockput>
end_op();
80104d15: e8 56 de ff ff call 80102b70 <end_op>
}
80104d1a: 83 c4 5c add $0x5c,%esp
return -1;
80104d1d: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104d22: 5b pop %ebx
80104d23: 5e pop %esi
80104d24: 5f pop %edi
80104d25: 5d pop %ebp
80104d26: c3 ret
80104d27: 90 nop
dp->nlink--;
80104d28: 8b 45 b4 mov -0x4c(%ebp),%eax
80104d2b: 66 83 68 56 01 subw $0x1,0x56(%eax)
iupdate(dp);
80104d30: 89 04 24 mov %eax,(%esp)
80104d33: e8 a8 c8 ff ff call 801015e0 <iupdate>
80104d38: e9 48 ff ff ff jmp 80104c85 <sys_unlink+0x105>
panic("isdirempty: readi");
80104d3d: c7 04 24 a0 75 10 80 movl $0x801075a0,(%esp)
80104d44: e8 17 b6 ff ff call 80100360 <panic>
panic("unlink: writei");
80104d49: c7 04 24 b2 75 10 80 movl $0x801075b2,(%esp)
80104d50: e8 0b b6 ff ff call 80100360 <panic>
panic("unlink: nlink < 1");
80104d55: c7 04 24 8e 75 10 80 movl $0x8010758e,(%esp)
80104d5c: e8 ff b5 ff ff call 80100360 <panic>
80104d61: eb 0d jmp 80104d70 <sys_open>
80104d63: 90 nop
80104d64: 90 nop
80104d65: 90 nop
80104d66: 90 nop
80104d67: 90 nop
80104d68: 90 nop
80104d69: 90 nop
80104d6a: 90 nop
80104d6b: 90 nop
80104d6c: 90 nop
80104d6d: 90 nop
80104d6e: 90 nop
80104d6f: 90 nop
80104d70 <sys_open>:
int
sys_open(void)
{
80104d70: 55 push %ebp
80104d71: 89 e5 mov %esp,%ebp
80104d73: 57 push %edi
80104d74: 56 push %esi
80104d75: 53 push %ebx
80104d76: 83 ec 2c sub $0x2c,%esp
char *path;
int fd, omode;
struct file *f;
struct inode *ip;
if(argstr(0, &path) < 0 || argint(1, &omode) < 0)
80104d79: 8d 45 e0 lea -0x20(%ebp),%eax
80104d7c: 89 44 24 04 mov %eax,0x4(%esp)
80104d80: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104d87: e8 24 f8 ff ff call 801045b0 <argstr>
80104d8c: 85 c0 test %eax,%eax
80104d8e: 0f 88 d1 00 00 00 js 80104e65 <sys_open+0xf5>
80104d94: 8d 45 e4 lea -0x1c(%ebp),%eax
80104d97: 89 44 24 04 mov %eax,0x4(%esp)
80104d9b: c7 04 24 01 00 00 00 movl $0x1,(%esp)
80104da2: e8 79 f7 ff ff call 80104520 <argint>
80104da7: 85 c0 test %eax,%eax
80104da9: 0f 88 b6 00 00 00 js 80104e65 <sys_open+0xf5>
return -1;
begin_op();
80104daf: e8 4c dd ff ff call 80102b00 <begin_op>
if(omode & O_CREATE){
80104db4: f6 45 e5 02 testb $0x2,-0x1b(%ebp)
80104db8: 0f 85 82 00 00 00 jne 80104e40 <sys_open+0xd0>
if(ip == 0){
end_op();
return -1;
}
} else {
if((ip = namei(path)) == 0){
80104dbe: 8b 45 e0 mov -0x20(%ebp),%eax
80104dc1: 89 04 24 mov %eax,(%esp)
80104dc4: e8 27 d1 ff ff call 80101ef0 <namei>
80104dc9: 85 c0 test %eax,%eax
80104dcb: 89 c6 mov %eax,%esi
80104dcd: 0f 84 8d 00 00 00 je 80104e60 <sys_open+0xf0>
end_op();
return -1;
}
ilock(ip);
80104dd3: 89 04 24 mov %eax,(%esp)
80104dd6: e8 c5 c8 ff ff call 801016a0 <ilock>
if(ip->type == T_DIR && omode != O_RDONLY){
80104ddb: 66 83 7e 50 01 cmpw $0x1,0x50(%esi)
80104de0: 0f 84 92 00 00 00 je 80104e78 <sys_open+0x108>
end_op();
return -1;
}
}
if((f = filealloc()) == 0 || (fd = fdalloc(f)) < 0){
80104de6: e8 65 bf ff ff call 80100d50 <filealloc>
80104deb: 85 c0 test %eax,%eax
80104ded: 89 c3 mov %eax,%ebx
80104def: 0f 84 93 00 00 00 je 80104e88 <sys_open+0x118>
80104df5: e8 86 f8 ff ff call 80104680 <fdalloc>
80104dfa: 85 c0 test %eax,%eax
80104dfc: 89 c7 mov %eax,%edi
80104dfe: 0f 88 94 00 00 00 js 80104e98 <sys_open+0x128>
fileclose(f);
iunlockput(ip);
end_op();
return -1;
}
iunlock(ip);
80104e04: 89 34 24 mov %esi,(%esp)
80104e07: e8 74 c9 ff ff call 80101780 <iunlock>
end_op();
80104e0c: e8 5f dd ff ff call 80102b70 <end_op>
f->type = FD_INODE;
80104e11: c7 03 02 00 00 00 movl $0x2,(%ebx)
f->ip = ip;
f->off = 0;
f->readable = !(omode & O_WRONLY);
80104e17: 8b 45 e4 mov -0x1c(%ebp),%eax
f->ip = ip;
80104e1a: 89 73 10 mov %esi,0x10(%ebx)
f->off = 0;
80104e1d: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
f->readable = !(omode & O_WRONLY);
80104e24: 89 c2 mov %eax,%edx
80104e26: 83 e2 01 and $0x1,%edx
80104e29: 83 f2 01 xor $0x1,%edx
f->writable = (omode & O_WRONLY) || (omode & O_RDWR);
80104e2c: a8 03 test $0x3,%al
f->readable = !(omode & O_WRONLY);
80104e2e: 88 53 08 mov %dl,0x8(%ebx)
return fd;
80104e31: 89 f8 mov %edi,%eax
f->writable = (omode & O_WRONLY) || (omode & O_RDWR);
80104e33: 0f 95 43 09 setne 0x9(%ebx)
}
80104e37: 83 c4 2c add $0x2c,%esp
80104e3a: 5b pop %ebx
80104e3b: 5e pop %esi
80104e3c: 5f pop %edi
80104e3d: 5d pop %ebp
80104e3e: c3 ret
80104e3f: 90 nop
ip = create(path, T_FILE, 0, 0);
80104e40: 8b 45 e0 mov -0x20(%ebp),%eax
80104e43: 31 c9 xor %ecx,%ecx
80104e45: ba 02 00 00 00 mov $0x2,%edx
80104e4a: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104e51: e8 6a f8 ff ff call 801046c0 <create>
if(ip == 0){
80104e56: 85 c0 test %eax,%eax
ip = create(path, T_FILE, 0, 0);
80104e58: 89 c6 mov %eax,%esi
if(ip == 0){
80104e5a: 75 8a jne 80104de6 <sys_open+0x76>
80104e5c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
end_op();
80104e60: e8 0b dd ff ff call 80102b70 <end_op>
}
80104e65: 83 c4 2c add $0x2c,%esp
return -1;
80104e68: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104e6d: 5b pop %ebx
80104e6e: 5e pop %esi
80104e6f: 5f pop %edi
80104e70: 5d pop %ebp
80104e71: c3 ret
80104e72: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if(ip->type == T_DIR && omode != O_RDONLY){
80104e78: 8b 45 e4 mov -0x1c(%ebp),%eax
80104e7b: 85 c0 test %eax,%eax
80104e7d: 0f 84 63 ff ff ff je 80104de6 <sys_open+0x76>
80104e83: 90 nop
80104e84: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
iunlockput(ip);
80104e88: 89 34 24 mov %esi,(%esp)
80104e8b: e8 70 ca ff ff call 80101900 <iunlockput>
80104e90: eb ce jmp 80104e60 <sys_open+0xf0>
80104e92: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
fileclose(f);
80104e98: 89 1c 24 mov %ebx,(%esp)
80104e9b: e8 70 bf ff ff call 80100e10 <fileclose>
80104ea0: eb e6 jmp 80104e88 <sys_open+0x118>
80104ea2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80104ea9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80104eb0 <sys_mkdir>:
int
sys_mkdir(void)
{
80104eb0: 55 push %ebp
80104eb1: 89 e5 mov %esp,%ebp
80104eb3: 83 ec 28 sub $0x28,%esp
char *path;
struct inode *ip;
begin_op();
80104eb6: e8 45 dc ff ff call 80102b00 <begin_op>
if(argstr(0, &path) < 0 || (ip = create(path, T_DIR, 0, 0)) == 0){
80104ebb: 8d 45 f4 lea -0xc(%ebp),%eax
80104ebe: 89 44 24 04 mov %eax,0x4(%esp)
80104ec2: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104ec9: e8 e2 f6 ff ff call 801045b0 <argstr>
80104ece: 85 c0 test %eax,%eax
80104ed0: 78 2e js 80104f00 <sys_mkdir+0x50>
80104ed2: 8b 45 f4 mov -0xc(%ebp),%eax
80104ed5: 31 c9 xor %ecx,%ecx
80104ed7: ba 01 00 00 00 mov $0x1,%edx
80104edc: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104ee3: e8 d8 f7 ff ff call 801046c0 <create>
80104ee8: 85 c0 test %eax,%eax
80104eea: 74 14 je 80104f00 <sys_mkdir+0x50>
end_op();
return -1;
}
iunlockput(ip);
80104eec: 89 04 24 mov %eax,(%esp)
80104eef: e8 0c ca ff ff call 80101900 <iunlockput>
end_op();
80104ef4: e8 77 dc ff ff call 80102b70 <end_op>
return 0;
80104ef9: 31 c0 xor %eax,%eax
}
80104efb: c9 leave
80104efc: c3 ret
80104efd: 8d 76 00 lea 0x0(%esi),%esi
end_op();
80104f00: e8 6b dc ff ff call 80102b70 <end_op>
return -1;
80104f05: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104f0a: c9 leave
80104f0b: c3 ret
80104f0c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104f10 <sys_mknod>:
int
sys_mknod(void)
{
80104f10: 55 push %ebp
80104f11: 89 e5 mov %esp,%ebp
80104f13: 83 ec 28 sub $0x28,%esp
struct inode *ip;
char *path;
int major, minor;
begin_op();
80104f16: e8 e5 db ff ff call 80102b00 <begin_op>
if((argstr(0, &path)) < 0 ||
80104f1b: 8d 45 ec lea -0x14(%ebp),%eax
80104f1e: 89 44 24 04 mov %eax,0x4(%esp)
80104f22: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104f29: e8 82 f6 ff ff call 801045b0 <argstr>
80104f2e: 85 c0 test %eax,%eax
80104f30: 78 5e js 80104f90 <sys_mknod+0x80>
argint(1, &major) < 0 ||
80104f32: 8d 45 f0 lea -0x10(%ebp),%eax
80104f35: 89 44 24 04 mov %eax,0x4(%esp)
80104f39: c7 04 24 01 00 00 00 movl $0x1,(%esp)
80104f40: e8 db f5 ff ff call 80104520 <argint>
if((argstr(0, &path)) < 0 ||
80104f45: 85 c0 test %eax,%eax
80104f47: 78 47 js 80104f90 <sys_mknod+0x80>
argint(2, &minor) < 0 ||
80104f49: 8d 45 f4 lea -0xc(%ebp),%eax
80104f4c: 89 44 24 04 mov %eax,0x4(%esp)
80104f50: c7 04 24 02 00 00 00 movl $0x2,(%esp)
80104f57: e8 c4 f5 ff ff call 80104520 <argint>
argint(1, &major) < 0 ||
80104f5c: 85 c0 test %eax,%eax
80104f5e: 78 30 js 80104f90 <sys_mknod+0x80>
(ip = create(path, T_DEV, major, minor)) == 0){
80104f60: 0f bf 45 f4 movswl -0xc(%ebp),%eax
argint(2, &minor) < 0 ||
80104f64: ba 03 00 00 00 mov $0x3,%edx
(ip = create(path, T_DEV, major, minor)) == 0){
80104f69: 0f bf 4d f0 movswl -0x10(%ebp),%ecx
80104f6d: 89 04 24 mov %eax,(%esp)
argint(2, &minor) < 0 ||
80104f70: 8b 45 ec mov -0x14(%ebp),%eax
80104f73: e8 48 f7 ff ff call 801046c0 <create>
80104f78: 85 c0 test %eax,%eax
80104f7a: 74 14 je 80104f90 <sys_mknod+0x80>
end_op();
return -1;
}
iunlockput(ip);
80104f7c: 89 04 24 mov %eax,(%esp)
80104f7f: e8 7c c9 ff ff call 80101900 <iunlockput>
end_op();
80104f84: e8 e7 db ff ff call 80102b70 <end_op>
return 0;
80104f89: 31 c0 xor %eax,%eax
}
80104f8b: c9 leave
80104f8c: c3 ret
80104f8d: 8d 76 00 lea 0x0(%esi),%esi
end_op();
80104f90: e8 db db ff ff call 80102b70 <end_op>
return -1;
80104f95: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104f9a: c9 leave
80104f9b: c3 ret
80104f9c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104fa0 <sys_chdir>:
int
sys_chdir(void)
{
80104fa0: 55 push %ebp
80104fa1: 89 e5 mov %esp,%ebp
80104fa3: 56 push %esi
80104fa4: 53 push %ebx
80104fa5: 83 ec 20 sub $0x20,%esp
char *path;
struct inode *ip;
struct proc *curproc = myproc();
80104fa8: e8 e3 e6 ff ff call 80103690 <myproc>
80104fad: 89 c6 mov %eax,%esi
begin_op();
80104faf: e8 4c db ff ff call 80102b00 <begin_op>
if(argstr(0, &path) < 0 || (ip = namei(path)) == 0){
80104fb4: 8d 45 f4 lea -0xc(%ebp),%eax
80104fb7: 89 44 24 04 mov %eax,0x4(%esp)
80104fbb: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104fc2: e8 e9 f5 ff ff call 801045b0 <argstr>
80104fc7: 85 c0 test %eax,%eax
80104fc9: 78 4a js 80105015 <sys_chdir+0x75>
80104fcb: 8b 45 f4 mov -0xc(%ebp),%eax
80104fce: 89 04 24 mov %eax,(%esp)
80104fd1: e8 1a cf ff ff call 80101ef0 <namei>
80104fd6: 85 c0 test %eax,%eax
80104fd8: 89 c3 mov %eax,%ebx
80104fda: 74 39 je 80105015 <sys_chdir+0x75>
end_op();
return -1;
}
ilock(ip);
80104fdc: 89 04 24 mov %eax,(%esp)
80104fdf: e8 bc c6 ff ff call 801016a0 <ilock>
if(ip->type != T_DIR){
80104fe4: 66 83 7b 50 01 cmpw $0x1,0x50(%ebx)
iunlockput(ip);
80104fe9: 89 1c 24 mov %ebx,(%esp)
if(ip->type != T_DIR){
80104fec: 75 22 jne 80105010 <sys_chdir+0x70>
end_op();
return -1;
}
iunlock(ip);
80104fee: e8 8d c7 ff ff call 80101780 <iunlock>
iput(curproc->cwd);
80104ff3: 8b 46 6c mov 0x6c(%esi),%eax
80104ff6: 89 04 24 mov %eax,(%esp)
80104ff9: e8 c2 c7 ff ff call 801017c0 <iput>
end_op();
80104ffe: e8 6d db ff ff call 80102b70 <end_op>
curproc->cwd = ip;
return 0;
80105003: 31 c0 xor %eax,%eax
curproc->cwd = ip;
80105005: 89 5e 6c mov %ebx,0x6c(%esi)
}
80105008: 83 c4 20 add $0x20,%esp
8010500b: 5b pop %ebx
8010500c: 5e pop %esi
8010500d: 5d pop %ebp
8010500e: c3 ret
8010500f: 90 nop
iunlockput(ip);
80105010: e8 eb c8 ff ff call 80101900 <iunlockput>
end_op();
80105015: e8 56 db ff ff call 80102b70 <end_op>
}
8010501a: 83 c4 20 add $0x20,%esp
return -1;
8010501d: b8 ff ff ff ff mov $0xffffffff,%eax
}
80105022: 5b pop %ebx
80105023: 5e pop %esi
80105024: 5d pop %ebp
80105025: c3 ret
80105026: 8d 76 00 lea 0x0(%esi),%esi
80105029: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80105030 <sys_exec>:
int
sys_exec(void)
{
80105030: 55 push %ebp
80105031: 89 e5 mov %esp,%ebp
80105033: 57 push %edi
80105034: 56 push %esi
80105035: 53 push %ebx
80105036: 81 ec ac 00 00 00 sub $0xac,%esp
char *path, *argv[MAXARG];
int i;
uint uargv, uarg;
if(argstr(0, &path) < 0 || argint(1, (int*)&uargv) < 0){
8010503c: 8d 85 5c ff ff ff lea -0xa4(%ebp),%eax
80105042: 89 44 24 04 mov %eax,0x4(%esp)
80105046: c7 04 24 00 00 00 00 movl $0x0,(%esp)
8010504d: e8 5e f5 ff ff call 801045b0 <argstr>
80105052: 85 c0 test %eax,%eax
80105054: 0f 88 84 00 00 00 js 801050de <sys_exec+0xae>
8010505a: 8d 85 60 ff ff ff lea -0xa0(%ebp),%eax
80105060: 89 44 24 04 mov %eax,0x4(%esp)
80105064: c7 04 24 01 00 00 00 movl $0x1,(%esp)
8010506b: e8 b0 f4 ff ff call 80104520 <argint>
80105070: 85 c0 test %eax,%eax
80105072: 78 6a js 801050de <sys_exec+0xae>
return -1;
}
memset(argv, 0, sizeof(argv));
80105074: 8d 85 68 ff ff ff lea -0x98(%ebp),%eax
for(i=0;; i++){
8010507a: 31 db xor %ebx,%ebx
memset(argv, 0, sizeof(argv));
8010507c: c7 44 24 08 80 00 00 movl $0x80,0x8(%esp)
80105083: 00
80105084: 8d b5 68 ff ff ff lea -0x98(%ebp),%esi
8010508a: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80105091: 00
80105092: 8d bd 64 ff ff ff lea -0x9c(%ebp),%edi
80105098: 89 04 24 mov %eax,(%esp)
8010509b: e8 d0 f1 ff ff call 80104270 <memset>
if(i >= NELEM(argv))
return -1;
if(fetchint(uargv+4*i, (int*)&uarg) < 0)
801050a0: 8b 85 60 ff ff ff mov -0xa0(%ebp),%eax
801050a6: 89 7c 24 04 mov %edi,0x4(%esp)
801050aa: 8d 04 98 lea (%eax,%ebx,4),%eax
801050ad: 89 04 24 mov %eax,(%esp)
801050b0: e8 0b f4 ff ff call 801044c0 <fetchint>
801050b5: 85 c0 test %eax,%eax
801050b7: 78 25 js 801050de <sys_exec+0xae>
return -1;
if(uarg == 0){
801050b9: 8b 85 64 ff ff ff mov -0x9c(%ebp),%eax
801050bf: 85 c0 test %eax,%eax
801050c1: 74 2d je 801050f0 <sys_exec+0xc0>
argv[i] = 0;
break;
}
if(fetchstr(uarg, &argv[i]) < 0)
801050c3: 89 74 24 04 mov %esi,0x4(%esp)
801050c7: 89 04 24 mov %eax,(%esp)
801050ca: e8 11 f4 ff ff call 801044e0 <fetchstr>
801050cf: 85 c0 test %eax,%eax
801050d1: 78 0b js 801050de <sys_exec+0xae>
for(i=0;; i++){
801050d3: 83 c3 01 add $0x1,%ebx
801050d6: 83 c6 04 add $0x4,%esi
if(i >= NELEM(argv))
801050d9: 83 fb 20 cmp $0x20,%ebx
801050dc: 75 c2 jne 801050a0 <sys_exec+0x70>
return -1;
}
return exec(path, argv);
}
801050de: 81 c4 ac 00 00 00 add $0xac,%esp
return -1;
801050e4: b8 ff ff ff ff mov $0xffffffff,%eax
}
801050e9: 5b pop %ebx
801050ea: 5e pop %esi
801050eb: 5f pop %edi
801050ec: 5d pop %ebp
801050ed: c3 ret
801050ee: 66 90 xchg %ax,%ax
return exec(path, argv);
801050f0: 8d 85 68 ff ff ff lea -0x98(%ebp),%eax
801050f6: 89 44 24 04 mov %eax,0x4(%esp)
801050fa: 8b 85 5c ff ff ff mov -0xa4(%ebp),%eax
argv[i] = 0;
80105100: c7 84 9d 68 ff ff ff movl $0x0,-0x98(%ebp,%ebx,4)
80105107: 00 00 00 00
return exec(path, argv);
8010510b: 89 04 24 mov %eax,(%esp)
8010510e: e8 8d b8 ff ff call 801009a0 <exec>
}
80105113: 81 c4 ac 00 00 00 add $0xac,%esp
80105119: 5b pop %ebx
8010511a: 5e pop %esi
8010511b: 5f pop %edi
8010511c: 5d pop %ebp
8010511d: c3 ret
8010511e: 66 90 xchg %ax,%ax
80105120 <sys_pipe>:
int
sys_pipe(void)
{
80105120: 55 push %ebp
80105121: 89 e5 mov %esp,%ebp
80105123: 53 push %ebx
80105124: 83 ec 24 sub $0x24,%esp
int *fd;
struct file *rf, *wf;
int fd0, fd1;
if(argptr(0, (void*)&fd, 2*sizeof(fd[0])) < 0)
80105127: 8d 45 ec lea -0x14(%ebp),%eax
8010512a: c7 44 24 08 08 00 00 movl $0x8,0x8(%esp)
80105131: 00
80105132: 89 44 24 04 mov %eax,0x4(%esp)
80105136: c7 04 24 00 00 00 00 movl $0x0,(%esp)
8010513d: e8 1e f4 ff ff call 80104560 <argptr>
80105142: 85 c0 test %eax,%eax
80105144: 78 6d js 801051b3 <sys_pipe+0x93>
return -1;
if(pipealloc(&rf, &wf) < 0)
80105146: 8d 45 f4 lea -0xc(%ebp),%eax
80105149: 89 44 24 04 mov %eax,0x4(%esp)
8010514d: 8d 45 f0 lea -0x10(%ebp),%eax
80105150: 89 04 24 mov %eax,(%esp)
80105153: e8 08 e0 ff ff call 80103160 <pipealloc>
80105158: 85 c0 test %eax,%eax
8010515a: 78 57 js 801051b3 <sys_pipe+0x93>
return -1;
fd0 = -1;
if((fd0 = fdalloc(rf)) < 0 || (fd1 = fdalloc(wf)) < 0){
8010515c: 8b 45 f0 mov -0x10(%ebp),%eax
8010515f: e8 1c f5 ff ff call 80104680 <fdalloc>
80105164: 85 c0 test %eax,%eax
80105166: 89 c3 mov %eax,%ebx
80105168: 78 33 js 8010519d <sys_pipe+0x7d>
8010516a: 8b 45 f4 mov -0xc(%ebp),%eax
8010516d: e8 0e f5 ff ff call 80104680 <fdalloc>
80105172: 85 c0 test %eax,%eax
80105174: 78 1a js 80105190 <sys_pipe+0x70>
myproc()->ofile[fd0] = 0;
fileclose(rf);
fileclose(wf);
return -1;
}
fd[0] = fd0;
80105176: 8b 55 ec mov -0x14(%ebp),%edx
80105179: 89 1a mov %ebx,(%edx)
fd[1] = fd1;
8010517b: 8b 55 ec mov -0x14(%ebp),%edx
8010517e: 89 42 04 mov %eax,0x4(%edx)
return 0;
}
80105181: 83 c4 24 add $0x24,%esp
return 0;
80105184: 31 c0 xor %eax,%eax
}
80105186: 5b pop %ebx
80105187: 5d pop %ebp
80105188: c3 ret
80105189: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
myproc()->ofile[fd0] = 0;
80105190: e8 fb e4 ff ff call 80103690 <myproc>
80105195: c7 44 98 2c 00 00 00 movl $0x0,0x2c(%eax,%ebx,4)
8010519c: 00
fileclose(rf);
8010519d: 8b 45 f0 mov -0x10(%ebp),%eax
801051a0: 89 04 24 mov %eax,(%esp)
801051a3: e8 68 bc ff ff call 80100e10 <fileclose>
fileclose(wf);
801051a8: 8b 45 f4 mov -0xc(%ebp),%eax
801051ab: 89 04 24 mov %eax,(%esp)
801051ae: e8 5d bc ff ff call 80100e10 <fileclose>
}
801051b3: 83 c4 24 add $0x24,%esp
return -1;
801051b6: b8 ff ff ff ff mov $0xffffffff,%eax
}
801051bb: 5b pop %ebx
801051bc: 5d pop %ebp
801051bd: c3 ret
801051be: 66 90 xchg %ax,%ax
801051c0 <sys_shm_open>:
#include "param.h"
#include "memlayout.h"
#include "mmu.h"
#include "proc.h"
int sys_shm_open(void) {
801051c0: 55 push %ebp
801051c1: 89 e5 mov %esp,%ebp
801051c3: 83 ec 28 sub $0x28,%esp
int id;
char **pointer;
if(argint(0, &id) < 0)
801051c6: 8d 45 f0 lea -0x10(%ebp),%eax
801051c9: 89 44 24 04 mov %eax,0x4(%esp)
801051cd: c7 04 24 00 00 00 00 movl $0x0,(%esp)
801051d4: e8 47 f3 ff ff call 80104520 <argint>
801051d9: 85 c0 test %eax,%eax
801051db: 78 33 js 80105210 <sys_shm_open+0x50>
return -1;
if(argptr(1, (char **) (&pointer),4)<0)
801051dd: 8d 45 f4 lea -0xc(%ebp),%eax
801051e0: c7 44 24 08 04 00 00 movl $0x4,0x8(%esp)
801051e7: 00
801051e8: 89 44 24 04 mov %eax,0x4(%esp)
801051ec: c7 04 24 01 00 00 00 movl $0x1,(%esp)
801051f3: e8 68 f3 ff ff call 80104560 <argptr>
801051f8: 85 c0 test %eax,%eax
801051fa: 78 14 js 80105210 <sys_shm_open+0x50>
return -1;
return shm_open(id, pointer);
801051fc: 8b 45 f4 mov -0xc(%ebp),%eax
801051ff: 89 44 24 04 mov %eax,0x4(%esp)
80105203: 8b 45 f0 mov -0x10(%ebp),%eax
80105206: 89 04 24 mov %eax,(%esp)
80105209: e8 e2 1b 00 00 call 80106df0 <shm_open>
}
8010520e: c9 leave
8010520f: c3 ret
return -1;
80105210: b8 ff ff ff ff mov $0xffffffff,%eax
}
80105215: c9 leave
80105216: c3 ret
80105217: 89 f6 mov %esi,%esi
80105219: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80105220 <sys_shm_close>:
int sys_shm_close(void) {
80105220: 55 push %ebp
80105221: 89 e5 mov %esp,%ebp
80105223: 83 ec 28 sub $0x28,%esp
int id;
if(argint(0, &id) < 0)
80105226: 8d 45 f4 lea -0xc(%ebp),%eax
80105229: 89 44 24 04 mov %eax,0x4(%esp)
8010522d: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80105234: e8 e7 f2 ff ff call 80104520 <argint>
80105239: 85 c0 test %eax,%eax
8010523b: 78 13 js 80105250 <sys_shm_close+0x30>
return -1;
return shm_close(id);
8010523d: 8b 45 f4 mov -0xc(%ebp),%eax
80105240: 89 04 24 mov %eax,(%esp)
80105243: e8 b8 1b 00 00 call 80106e00 <shm_close>
}
80105248: c9 leave
80105249: c3 ret
8010524a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return -1;
80105250: b8 ff ff ff ff mov $0xffffffff,%eax
}
80105255: c9 leave
80105256: c3 ret
80105257: 89 f6 mov %esi,%esi
80105259: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80105260 <sys_fork>:
int
sys_fork(void)
{
80105260: 55 push %ebp
80105261: 89 e5 mov %esp,%ebp
return fork();
}
80105263: 5d pop %ebp
return fork();
80105264: e9 d7 e5 ff ff jmp 80103840 <fork>
80105269: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80105270 <sys_exit>:
int
sys_exit(void)
{
80105270: 55 push %ebp
80105271: 89 e5 mov %esp,%ebp
80105273: 83 ec 08 sub $0x8,%esp
exit();
80105276: e8 15 e8 ff ff call 80103a90 <exit>
return 0; // not reached
}
8010527b: 31 c0 xor %eax,%eax
8010527d: c9 leave
8010527e: c3 ret
8010527f: 90 nop
80105280 <sys_wait>:
int
sys_wait(void)
{
80105280: 55 push %ebp
80105281: 89 e5 mov %esp,%ebp
return wait();
}
80105283: 5d pop %ebp
return wait();
80105284: e9 17 ea ff ff jmp 80103ca0 <wait>
80105289: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80105290 <sys_kill>:
int
sys_kill(void)
{
80105290: 55 push %ebp
80105291: 89 e5 mov %esp,%ebp
80105293: 83 ec 28 sub $0x28,%esp
int pid;
if(argint(0, &pid) < 0)
80105296: 8d 45 f4 lea -0xc(%ebp),%eax
80105299: 89 44 24 04 mov %eax,0x4(%esp)
8010529d: c7 04 24 00 00 00 00 movl $0x0,(%esp)
801052a4: e8 77 f2 ff ff call 80104520 <argint>
801052a9: 85 c0 test %eax,%eax
801052ab: 78 13 js 801052c0 <sys_kill+0x30>
return -1;
return kill(pid);
801052ad: 8b 45 f4 mov -0xc(%ebp),%eax
801052b0: 89 04 24 mov %eax,(%esp)
801052b3: e8 28 eb ff ff call 80103de0 <kill>
}
801052b8: c9 leave
801052b9: c3 ret
801052ba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return -1;
801052c0: b8 ff ff ff ff mov $0xffffffff,%eax
}
801052c5: c9 leave
801052c6: c3 ret
801052c7: 89 f6 mov %esi,%esi
801052c9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801052d0 <sys_getpid>:
int
sys_getpid(void)
{
801052d0: 55 push %ebp
801052d1: 89 e5 mov %esp,%ebp
801052d3: 83 ec 08 sub $0x8,%esp
return myproc()->pid;
801052d6: e8 b5 e3 ff ff call 80103690 <myproc>
801052db: 8b 40 14 mov 0x14(%eax),%eax
}
801052de: c9 leave
801052df: c3 ret
801052e0 <sys_sbrk>:
int
sys_sbrk(void)
{
801052e0: 55 push %ebp
801052e1: 89 e5 mov %esp,%ebp
801052e3: 53 push %ebx
801052e4: 83 ec 24 sub $0x24,%esp
int addr;
int n;
if(argint(0, &n) < 0)
801052e7: 8d 45 f4 lea -0xc(%ebp),%eax
801052ea: 89 44 24 04 mov %eax,0x4(%esp)
801052ee: c7 04 24 00 00 00 00 movl $0x0,(%esp)
801052f5: e8 26 f2 ff ff call 80104520 <argint>
801052fa: 85 c0 test %eax,%eax
801052fc: 78 22 js 80105320 <sys_sbrk+0x40>
return -1;
addr = myproc()->sz;
801052fe: e8 8d e3 ff ff call 80103690 <myproc>
if(growproc(n) < 0)
80105303: 8b 55 f4 mov -0xc(%ebp),%edx
addr = myproc()->sz;
80105306: 8b 18 mov (%eax),%ebx
if(growproc(n) < 0)
80105308: 89 14 24 mov %edx,(%esp)
8010530b: e8 c0 e4 ff ff call 801037d0 <growproc>
80105310: 85 c0 test %eax,%eax
80105312: 78 0c js 80105320 <sys_sbrk+0x40>
return -1;
return addr;
80105314: 89 d8 mov %ebx,%eax
}
80105316: 83 c4 24 add $0x24,%esp
80105319: 5b pop %ebx
8010531a: 5d pop %ebp
8010531b: c3 ret
8010531c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return -1;
80105320: b8 ff ff ff ff mov $0xffffffff,%eax
80105325: eb ef jmp 80105316 <sys_sbrk+0x36>
80105327: 89 f6 mov %esi,%esi
80105329: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80105330 <sys_sleep>:
int
sys_sleep(void)
{
80105330: 55 push %ebp
80105331: 89 e5 mov %esp,%ebp
80105333: 53 push %ebx
80105334: 83 ec 24 sub $0x24,%esp
int n;
uint ticks0;
if(argint(0, &n) < 0)
80105337: 8d 45 f4 lea -0xc(%ebp),%eax
8010533a: 89 44 24 04 mov %eax,0x4(%esp)
8010533e: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80105345: e8 d6 f1 ff ff call 80104520 <argint>
8010534a: 85 c0 test %eax,%eax
8010534c: 78 7e js 801053cc <sys_sleep+0x9c>
return -1;
acquire(&tickslock);
8010534e: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
80105355: e8 d6 ed ff ff call 80104130 <acquire>
ticks0 = ticks;
while(ticks - ticks0 < n){
8010535a: 8b 55 f4 mov -0xc(%ebp),%edx
ticks0 = ticks;
8010535d: 8b 1d a0 55 11 80 mov 0x801155a0,%ebx
while(ticks - ticks0 < n){
80105363: 85 d2 test %edx,%edx
80105365: 75 29 jne 80105390 <sys_sleep+0x60>
80105367: eb 4f jmp 801053b8 <sys_sleep+0x88>
80105369: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if(myproc()->killed){
release(&tickslock);
return -1;
}
sleep(&ticks, &tickslock);
80105370: c7 44 24 04 60 4d 11 movl $0x80114d60,0x4(%esp)
80105377: 80
80105378: c7 04 24 a0 55 11 80 movl $0x801155a0,(%esp)
8010537f: e8 6c e8 ff ff call 80103bf0 <sleep>
while(ticks - ticks0 < n){
80105384: a1 a0 55 11 80 mov 0x801155a0,%eax
80105389: 29 d8 sub %ebx,%eax
8010538b: 3b 45 f4 cmp -0xc(%ebp),%eax
8010538e: 73 28 jae 801053b8 <sys_sleep+0x88>
if(myproc()->killed){
80105390: e8 fb e2 ff ff call 80103690 <myproc>
80105395: 8b 40 28 mov 0x28(%eax),%eax
80105398: 85 c0 test %eax,%eax
8010539a: 74 d4 je 80105370 <sys_sleep+0x40>
release(&tickslock);
8010539c: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
801053a3: e8 78 ee ff ff call 80104220 <release>
return -1;
801053a8: b8 ff ff ff ff mov $0xffffffff,%eax
}
release(&tickslock);
return 0;
}
801053ad: 83 c4 24 add $0x24,%esp
801053b0: 5b pop %ebx
801053b1: 5d pop %ebp
801053b2: c3 ret
801053b3: 90 nop
801053b4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
release(&tickslock);
801053b8: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
801053bf: e8 5c ee ff ff call 80104220 <release>
}
801053c4: 83 c4 24 add $0x24,%esp
return 0;
801053c7: 31 c0 xor %eax,%eax
}
801053c9: 5b pop %ebx
801053ca: 5d pop %ebp
801053cb: c3 ret
return -1;
801053cc: b8 ff ff ff ff mov $0xffffffff,%eax
801053d1: eb da jmp 801053ad <sys_sleep+0x7d>
801053d3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801053d9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801053e0 <sys_uptime>:
// return how many clock tick interrupts have occurred
// since start.
int
sys_uptime(void)
{
801053e0: 55 push %ebp
801053e1: 89 e5 mov %esp,%ebp
801053e3: 53 push %ebx
801053e4: 83 ec 14 sub $0x14,%esp
uint xticks;
acquire(&tickslock);
801053e7: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
801053ee: e8 3d ed ff ff call 80104130 <acquire>
xticks = ticks;
801053f3: 8b 1d a0 55 11 80 mov 0x801155a0,%ebx
release(&tickslock);
801053f9: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
80105400: e8 1b ee ff ff call 80104220 <release>
return xticks;
}
80105405: 83 c4 14 add $0x14,%esp
80105408: 89 d8 mov %ebx,%eax
8010540a: 5b pop %ebx
8010540b: 5d pop %ebp
8010540c: c3 ret
8010540d <alltraps>:
# vectors.S sends all traps here.
.globl alltraps
alltraps:
# Build trap frame.
pushl %ds
8010540d: 1e push %ds
pushl %es
8010540e: 06 push %es
pushl %fs
8010540f: 0f a0 push %fs
pushl %gs
80105411: 0f a8 push %gs
pushal
80105413: 60 pusha
# Set up data segments.
movw $(SEG_KDATA<<3), %ax
80105414: 66 b8 10 00 mov $0x10,%ax
movw %ax, %ds
80105418: 8e d8 mov %eax,%ds
movw %ax, %es
8010541a: 8e c0 mov %eax,%es
# Call trap(tf), where tf=%esp
pushl %esp
8010541c: 54 push %esp
call trap
8010541d: e8 de 00 00 00 call 80105500 <trap>
addl $4, %esp
80105422: 83 c4 04 add $0x4,%esp
80105425 <trapret>:
# Return falls through to trapret...
.globl trapret
trapret:
popal
80105425: 61 popa
popl %gs
80105426: 0f a9 pop %gs
popl %fs
80105428: 0f a1 pop %fs
popl %es
8010542a: 07 pop %es
popl %ds
8010542b: 1f pop %ds
addl $0x8, %esp # trapno and errcode
8010542c: 83 c4 08 add $0x8,%esp
iret
8010542f: cf iret
80105430 <tvinit>:
void
tvinit(void)
{
int i;
for(i = 0; i < 256; i++)
80105430: 31 c0 xor %eax,%eax
80105432: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
SETGATE(idt[i], 0, SEG_KCODE<<3, vectors[i], 0);
80105438: 8b 14 85 08 a0 10 80 mov -0x7fef5ff8(,%eax,4),%edx
8010543f: b9 08 00 00 00 mov $0x8,%ecx
80105444: 66 89 0c c5 a2 4d 11 mov %cx,-0x7feeb25e(,%eax,8)
8010544b: 80
8010544c: c6 04 c5 a4 4d 11 80 movb $0x0,-0x7feeb25c(,%eax,8)
80105453: 00
80105454: c6 04 c5 a5 4d 11 80 movb $0x8e,-0x7feeb25b(,%eax,8)
8010545b: 8e
8010545c: 66 89 14 c5 a0 4d 11 mov %dx,-0x7feeb260(,%eax,8)
80105463: 80
80105464: c1 ea 10 shr $0x10,%edx
80105467: 66 89 14 c5 a6 4d 11 mov %dx,-0x7feeb25a(,%eax,8)
8010546e: 80
for(i = 0; i < 256; i++)
8010546f: 83 c0 01 add $0x1,%eax
80105472: 3d 00 01 00 00 cmp $0x100,%eax
80105477: 75 bf jne 80105438 <tvinit+0x8>
{
80105479: 55 push %ebp
SETGATE(idt[T_SYSCALL], 1, SEG_KCODE<<3, vectors[T_SYSCALL], DPL_USER);
8010547a: ba 08 00 00 00 mov $0x8,%edx
{
8010547f: 89 e5 mov %esp,%ebp
80105481: 83 ec 18 sub $0x18,%esp
SETGATE(idt[T_SYSCALL], 1, SEG_KCODE<<3, vectors[T_SYSCALL], DPL_USER);
80105484: a1 08 a1 10 80 mov 0x8010a108,%eax
initlock(&tickslock, "time");
80105489: c7 44 24 04 c1 75 10 movl $0x801075c1,0x4(%esp)
80105490: 80
80105491: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
SETGATE(idt[T_SYSCALL], 1, SEG_KCODE<<3, vectors[T_SYSCALL], DPL_USER);
80105498: 66 89 15 a2 4f 11 80 mov %dx,0x80114fa2
8010549f: 66 a3 a0 4f 11 80 mov %ax,0x80114fa0
801054a5: c1 e8 10 shr $0x10,%eax
801054a8: c6 05 a4 4f 11 80 00 movb $0x0,0x80114fa4
801054af: c6 05 a5 4f 11 80 ef movb $0xef,0x80114fa5
801054b6: 66 a3 a6 4f 11 80 mov %ax,0x80114fa6
initlock(&tickslock, "time");
801054bc: e8 7f eb ff ff call 80104040 <initlock>
}
801054c1: c9 leave
801054c2: c3 ret
801054c3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801054c9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801054d0 <idtinit>:
void
idtinit(void)
{
801054d0: 55 push %ebp
pd[0] = size-1;
801054d1: b8 ff 07 00 00 mov $0x7ff,%eax
801054d6: 89 e5 mov %esp,%ebp
801054d8: 83 ec 10 sub $0x10,%esp
801054db: 66 89 45 fa mov %ax,-0x6(%ebp)
pd[1] = (uint)p;
801054df: b8 a0 4d 11 80 mov $0x80114da0,%eax
801054e4: 66 89 45 fc mov %ax,-0x4(%ebp)
pd[2] = (uint)p >> 16;
801054e8: c1 e8 10 shr $0x10,%eax
801054eb: 66 89 45 fe mov %ax,-0x2(%ebp)
asm volatile("lidt (%0)" : : "r" (pd));
801054ef: 8d 45 fa lea -0x6(%ebp),%eax
801054f2: 0f 01 18 lidtl (%eax)
lidt(idt, sizeof(idt));
}
801054f5: c9 leave
801054f6: c3 ret
801054f7: 89 f6 mov %esi,%esi
801054f9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80105500 <trap>:
//PAGEBREAK: 41
void
trap(struct trapframe *tf)
{
80105500: 55 push %ebp
80105501: 89 e5 mov %esp,%ebp
80105503: 57 push %edi
80105504: 56 push %esi
80105505: 53 push %ebx
80105506: 83 ec 3c sub $0x3c,%esp
80105509: 8b 5d 08 mov 0x8(%ebp),%ebx
if(tf->trapno == T_SYSCALL){
8010550c: 8b 43 30 mov 0x30(%ebx),%eax
8010550f: 83 f8 40 cmp $0x40,%eax
80105512: 0f 84 e0 01 00 00 je 801056f8 <trap+0x1f8>
if(myproc()->killed)
exit();
return;
}
switch(tf->trapno){
80105518: 83 e8 0e sub $0xe,%eax
8010551b: 83 f8 31 cmp $0x31,%eax
8010551e: 77 08 ja 80105528 <trap+0x28>
80105520: ff 24 85 88 76 10 80 jmp *-0x7fef8978(,%eax,4)
80105527: 90 nop
cprintf("Hello\n");
break;
//PAGEBREAK: 13
default:
if(myproc() == 0 || (tf->cs&3) == 0){
80105528: e8 63 e1 ff ff call 80103690 <myproc>
8010552d: 85 c0 test %eax,%eax
8010552f: 90 nop
80105530: 0f 84 80 02 00 00 je 801057b6 <trap+0x2b6>
80105536: f6 43 3c 03 testb $0x3,0x3c(%ebx)
8010553a: 0f 84 76 02 00 00 je 801057b6 <trap+0x2b6>
static inline uint
rcr2(void)
{
uint val;
asm volatile("movl %%cr2,%0" : "=r" (val));
80105540: 0f 20 d1 mov %cr2,%ecx
cprintf("unexpected trap %d from cpu %d eip %x (cr2=0x%x)\n",
tf->trapno, cpuid(), tf->eip, rcr2());
panic("trap");
}
// In user space, assume process misbehaved.
cprintf("pid %d %s: trap %d err %d on cpu %d "
80105543: 8b 53 38 mov 0x38(%ebx),%edx
80105546: 89 4d d8 mov %ecx,-0x28(%ebp)
80105549: 89 55 dc mov %edx,-0x24(%ebp)
8010554c: e8 1f e1 ff ff call 80103670 <cpuid>
80105551: 8b 73 30 mov 0x30(%ebx),%esi
80105554: 89 c7 mov %eax,%edi
80105556: 8b 43 34 mov 0x34(%ebx),%eax
80105559: 89 45 e4 mov %eax,-0x1c(%ebp)
"eip 0x%x addr 0x%x--kill proc\n",
myproc()->pid, myproc()->name, tf->trapno,
8010555c: e8 2f e1 ff ff call 80103690 <myproc>
80105561: 89 45 e0 mov %eax,-0x20(%ebp)
80105564: e8 27 e1 ff ff call 80103690 <myproc>
cprintf("pid %d %s: trap %d err %d on cpu %d "
80105569: 8b 4d d8 mov -0x28(%ebp),%ecx
8010556c: 89 74 24 0c mov %esi,0xc(%esp)
myproc()->pid, myproc()->name, tf->trapno,
80105570: 8b 75 e0 mov -0x20(%ebp),%esi
cprintf("pid %d %s: trap %d err %d on cpu %d "
80105573: 8b 55 dc mov -0x24(%ebp),%edx
80105576: 89 7c 24 14 mov %edi,0x14(%esp)
8010557a: 8b 7d e4 mov -0x1c(%ebp),%edi
8010557d: 89 4c 24 1c mov %ecx,0x1c(%esp)
myproc()->pid, myproc()->name, tf->trapno,
80105581: 83 c6 70 add $0x70,%esi
cprintf("pid %d %s: trap %d err %d on cpu %d "
80105584: 89 54 24 18 mov %edx,0x18(%esp)
80105588: 89 7c 24 10 mov %edi,0x10(%esp)
myproc()->pid, myproc()->name, tf->trapno,
8010558c: 89 74 24 08 mov %esi,0x8(%esp)
cprintf("pid %d %s: trap %d err %d on cpu %d "
80105590: 8b 40 14 mov 0x14(%eax),%eax
80105593: c7 04 24 44 76 10 80 movl $0x80107644,(%esp)
8010559a: 89 44 24 04 mov %eax,0x4(%esp)
8010559e: e8 ad b0 ff ff call 80100650 <cprintf>
tf->err, cpuid(), tf->eip, rcr2());
myproc()->killed = 1;
801055a3: e8 e8 e0 ff ff call 80103690 <myproc>
801055a8: c7 40 28 01 00 00 00 movl $0x1,0x28(%eax)
801055af: 90 nop
}
// Force process exit if it has been killed and is in user space.
// (If it is still executing in the kernel, let it keep running
// until it gets to the regular system call return.)
if(myproc() && myproc()->killed && (tf->cs&3) == DPL_USER)
801055b0: e8 db e0 ff ff call 80103690 <myproc>
801055b5: 85 c0 test %eax,%eax
801055b7: 74 0c je 801055c5 <trap+0xc5>
801055b9: e8 d2 e0 ff ff call 80103690 <myproc>
801055be: 8b 50 28 mov 0x28(%eax),%edx
801055c1: 85 d2 test %edx,%edx
801055c3: 75 4b jne 80105610 <trap+0x110>
exit();
// Force process to give up CPU on clock tick.
// If interrupts were on while locks held, would need to check nlock.
if(myproc() && myproc()->state == RUNNING &&
801055c5: e8 c6 e0 ff ff call 80103690 <myproc>
801055ca: 85 c0 test %eax,%eax
801055cc: 74 0d je 801055db <trap+0xdb>
801055ce: 66 90 xchg %ax,%ax
801055d0: e8 bb e0 ff ff call 80103690 <myproc>
801055d5: 83 78 10 04 cmpl $0x4,0x10(%eax)
801055d9: 74 4d je 80105628 <trap+0x128>
tf->trapno == T_IRQ0+IRQ_TIMER)
yield();
// Check if the process has been killed since we yielded
if(myproc() && myproc()->killed && (tf->cs&3) == DPL_USER)
801055db: e8 b0 e0 ff ff call 80103690 <myproc>
801055e0: 85 c0 test %eax,%eax
801055e2: 74 1d je 80105601 <trap+0x101>
801055e4: e8 a7 e0 ff ff call 80103690 <myproc>
801055e9: 8b 40 28 mov 0x28(%eax),%eax
801055ec: 85 c0 test %eax,%eax
801055ee: 74 11 je 80105601 <trap+0x101>
801055f0: 0f b7 43 3c movzwl 0x3c(%ebx),%eax
801055f4: 83 e0 03 and $0x3,%eax
801055f7: 66 83 f8 03 cmp $0x3,%ax
801055fb: 0f 84 28 01 00 00 je 80105729 <trap+0x229>
exit();
}
80105601: 83 c4 3c add $0x3c,%esp
80105604: 5b pop %ebx
80105605: 5e pop %esi
80105606: 5f pop %edi
80105607: 5d pop %ebp
80105608: c3 ret
80105609: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if(myproc() && myproc()->killed && (tf->cs&3) == DPL_USER)
80105610: 0f b7 43 3c movzwl 0x3c(%ebx),%eax
80105614: 83 e0 03 and $0x3,%eax
80105617: 66 83 f8 03 cmp $0x3,%ax
8010561b: 75 a8 jne 801055c5 <trap+0xc5>
exit();
8010561d: e8 6e e4 ff ff call 80103a90 <exit>
80105622: eb a1 jmp 801055c5 <trap+0xc5>
80105624: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if(myproc() && myproc()->state == RUNNING &&
80105628: 83 7b 30 20 cmpl $0x20,0x30(%ebx)
8010562c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80105630: 75 a9 jne 801055db <trap+0xdb>
yield();
80105632: e8 79 e5 ff ff call 80103bb0 <yield>
80105637: eb a2 jmp 801055db <trap+0xdb>
80105639: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
uint stackPages = myproc()->sb;
80105640: e8 4b e0 ff ff call 80103690 <myproc>
80105645: 0f 20 d1 mov %cr2,%ecx
if (oAddress < USERSTACKTOP - (stackPages * PGSIZE) && oAddress > PGROUNDDOWN(USERSTACKTOP - (stackPages * PGSIZE) - 1)) {
80105648: 8b 40 04 mov 0x4(%eax),%eax
8010564b: be ff ff ff 7f mov $0x7fffffff,%esi
80105650: c1 e0 0c shl $0xc,%eax
80105653: 29 c6 sub %eax,%esi
80105655: 39 ce cmp %ecx,%esi
80105657: 76 15 jbe 8010566e <trap+0x16e>
80105659: ba fe ff ff 7f mov $0x7ffffffe,%edx
8010565e: 29 c2 sub %eax,%edx
80105660: 81 e2 00 f0 ff ff and $0xfffff000,%edx
80105666: 39 ca cmp %ecx,%edx
80105668: 0f 82 02 01 00 00 jb 80105770 <trap+0x270>
cprintf("Hello\n");
8010566e: c7 04 24 de 75 10 80 movl $0x801075de,(%esp)
80105675: e8 d6 af ff ff call 80100650 <cprintf>
break;
8010567a: e9 31 ff ff ff jmp 801055b0 <trap+0xb0>
8010567f: 90 nop
if(cpuid() == 0){
80105680: e8 eb df ff ff call 80103670 <cpuid>
80105685: 85 c0 test %eax,%eax
80105687: 0f 84 b3 00 00 00 je 80105740 <trap+0x240>
8010568d: 8d 76 00 lea 0x0(%esi),%esi
lapiceoi();
80105690: e8 db d0 ff ff call 80102770 <lapiceoi>
break;
80105695: e9 16 ff ff ff jmp 801055b0 <trap+0xb0>
8010569a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
kbdintr();
801056a0: e8 1b cf ff ff call 801025c0 <kbdintr>
lapiceoi();
801056a5: e8 c6 d0 ff ff call 80102770 <lapiceoi>
break;
801056aa: e9 01 ff ff ff jmp 801055b0 <trap+0xb0>
801056af: 90 nop
uartintr();
801056b0: e8 5b 02 00 00 call 80105910 <uartintr>
lapiceoi();
801056b5: e8 b6 d0 ff ff call 80102770 <lapiceoi>
break;
801056ba: e9 f1 fe ff ff jmp 801055b0 <trap+0xb0>
801056bf: 90 nop
cprintf("cpu%d: spurious interrupt at %x:%x\n",
801056c0: 8b 7b 38 mov 0x38(%ebx),%edi
801056c3: 0f b7 73 3c movzwl 0x3c(%ebx),%esi
801056c7: e8 a4 df ff ff call 80103670 <cpuid>
801056cc: c7 04 24 ec 75 10 80 movl $0x801075ec,(%esp)
801056d3: 89 7c 24 0c mov %edi,0xc(%esp)
801056d7: 89 74 24 08 mov %esi,0x8(%esp)
801056db: 89 44 24 04 mov %eax,0x4(%esp)
801056df: e8 6c af ff ff call 80100650 <cprintf>
lapiceoi();
801056e4: e8 87 d0 ff ff call 80102770 <lapiceoi>
break;
801056e9: e9 c2 fe ff ff jmp 801055b0 <trap+0xb0>
801056ee: 66 90 xchg %ax,%ax
ideintr();
801056f0: e8 7b c9 ff ff call 80102070 <ideintr>
801056f5: eb 96 jmp 8010568d <trap+0x18d>
801056f7: 90 nop
801056f8: 90 nop
801056f9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if(myproc()->killed)
80105700: e8 8b df ff ff call 80103690 <myproc>
80105705: 8b 70 28 mov 0x28(%eax),%esi
80105708: 85 f6 test %esi,%esi
8010570a: 75 2c jne 80105738 <trap+0x238>
myproc()->tf = tf;
8010570c: e8 7f df ff ff call 80103690 <myproc>
80105711: 89 58 1c mov %ebx,0x1c(%eax)
syscall();
80105714: e8 f7 ee ff ff call 80104610 <syscall>
if(myproc()->killed)
80105719: e8 72 df ff ff call 80103690 <myproc>
8010571e: 8b 48 28 mov 0x28(%eax),%ecx
80105721: 85 c9 test %ecx,%ecx
80105723: 0f 84 d8 fe ff ff je 80105601 <trap+0x101>
}
80105729: 83 c4 3c add $0x3c,%esp
8010572c: 5b pop %ebx
8010572d: 5e pop %esi
8010572e: 5f pop %edi
8010572f: 5d pop %ebp
exit();
80105730: e9 5b e3 ff ff jmp 80103a90 <exit>
80105735: 8d 76 00 lea 0x0(%esi),%esi
exit();
80105738: e8 53 e3 ff ff call 80103a90 <exit>
8010573d: eb cd jmp 8010570c <trap+0x20c>
8010573f: 90 nop
acquire(&tickslock);
80105740: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
80105747: e8 e4 e9 ff ff call 80104130 <acquire>
wakeup(&ticks);
8010574c: c7 04 24 a0 55 11 80 movl $0x801155a0,(%esp)
ticks++;
80105753: 83 05 a0 55 11 80 01 addl $0x1,0x801155a0
wakeup(&ticks);
8010575a: e8 21 e6 ff ff call 80103d80 <wakeup>
release(&tickslock);
8010575f: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
80105766: e8 b5 ea ff ff call 80104220 <release>
8010576b: e9 1d ff ff ff jmp 8010568d <trap+0x18d>
if (allocuvm(myproc()->pgdir, PGROUNDDOWN(USERSTACKTOP - (stackPages * PGSIZE)), USERSTACKTOP - (stackPages * PGSIZE)) == 0) {
80105770: e8 1b df ff ff call 80103690 <myproc>
80105775: 89 74 24 08 mov %esi,0x8(%esp)
80105779: 81 e6 00 f0 ff ff and $0xfffff000,%esi
8010577f: 89 74 24 04 mov %esi,0x4(%esp)
80105783: 8b 40 08 mov 0x8(%eax),%eax
80105786: 89 04 24 mov %eax,(%esp)
80105789: e8 02 11 00 00 call 80106890 <allocuvm>
8010578e: 85 c0 test %eax,%eax
80105790: 75 16 jne 801057a8 <trap+0x2a8>
cprintf("Page allocation failed\n");
80105792: c7 04 24 c6 75 10 80 movl $0x801075c6,(%esp)
80105799: e8 b2 ae ff ff call 80100650 <cprintf>
break;
8010579e: e9 0d fe ff ff jmp 801055b0 <trap+0xb0>
801057a3: 90 nop
801057a4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
myproc()->sb += 1;
801057a8: e8 e3 de ff ff call 80103690 <myproc>
801057ad: 83 40 04 01 addl $0x1,0x4(%eax)
break;
801057b1: e9 fa fd ff ff jmp 801055b0 <trap+0xb0>
801057b6: 0f 20 d7 mov %cr2,%edi
cprintf("unexpected trap %d from cpu %d eip %x (cr2=0x%x)\n",
801057b9: 8b 73 38 mov 0x38(%ebx),%esi
801057bc: e8 af de ff ff call 80103670 <cpuid>
801057c1: 89 7c 24 10 mov %edi,0x10(%esp)
801057c5: 89 74 24 0c mov %esi,0xc(%esp)
801057c9: 89 44 24 08 mov %eax,0x8(%esp)
801057cd: 8b 43 30 mov 0x30(%ebx),%eax
801057d0: c7 04 24 10 76 10 80 movl $0x80107610,(%esp)
801057d7: 89 44 24 04 mov %eax,0x4(%esp)
801057db: e8 70 ae ff ff call 80100650 <cprintf>
panic("trap");
801057e0: c7 04 24 e5 75 10 80 movl $0x801075e5,(%esp)
801057e7: e8 74 ab ff ff call 80100360 <panic>
801057ec: 66 90 xchg %ax,%ax
801057ee: 66 90 xchg %ax,%ax
801057f0 <uartgetc>:
}
static int
uartgetc(void)
{
if(!uart)
801057f0: a1 bc a5 10 80 mov 0x8010a5bc,%eax
{
801057f5: 55 push %ebp
801057f6: 89 e5 mov %esp,%ebp
if(!uart)
801057f8: 85 c0 test %eax,%eax
801057fa: 74 14 je 80105810 <uartgetc+0x20>
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
801057fc: ba fd 03 00 00 mov $0x3fd,%edx
80105801: ec in (%dx),%al
return -1;
if(!(inb(COM1+5) & 0x01))
80105802: a8 01 test $0x1,%al
80105804: 74 0a je 80105810 <uartgetc+0x20>
80105806: b2 f8 mov $0xf8,%dl
80105808: ec in (%dx),%al
return -1;
return inb(COM1+0);
80105809: 0f b6 c0 movzbl %al,%eax
}
8010580c: 5d pop %ebp
8010580d: c3 ret
8010580e: 66 90 xchg %ax,%ax
return -1;
80105810: b8 ff ff ff ff mov $0xffffffff,%eax
}
80105815: 5d pop %ebp
80105816: c3 ret
80105817: 89 f6 mov %esi,%esi
80105819: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80105820 <uartputc>:
if(!uart)
80105820: a1 bc a5 10 80 mov 0x8010a5bc,%eax
80105825: 85 c0 test %eax,%eax
80105827: 74 3f je 80105868 <uartputc+0x48>
{
80105829: 55 push %ebp
8010582a: 89 e5 mov %esp,%ebp
8010582c: 56 push %esi
8010582d: be fd 03 00 00 mov $0x3fd,%esi
80105832: 53 push %ebx
if(!uart)
80105833: bb 80 00 00 00 mov $0x80,%ebx
{
80105838: 83 ec 10 sub $0x10,%esp
8010583b: eb 14 jmp 80105851 <uartputc+0x31>
8010583d: 8d 76 00 lea 0x0(%esi),%esi
microdelay(10);
80105840: c7 04 24 0a 00 00 00 movl $0xa,(%esp)
80105847: e8 44 cf ff ff call 80102790 <microdelay>
for(i = 0; i < 128 && !(inb(COM1+5) & 0x20); i++)
8010584c: 83 eb 01 sub $0x1,%ebx
8010584f: 74 07 je 80105858 <uartputc+0x38>
80105851: 89 f2 mov %esi,%edx
80105853: ec in (%dx),%al
80105854: a8 20 test $0x20,%al
80105856: 74 e8 je 80105840 <uartputc+0x20>
outb(COM1+0, c);
80105858: 0f b6 45 08 movzbl 0x8(%ebp),%eax
asm volatile("out %0,%1" : : "a" (data), "d" (port));
8010585c: ba f8 03 00 00 mov $0x3f8,%edx
80105861: ee out %al,(%dx)
}
80105862: 83 c4 10 add $0x10,%esp
80105865: 5b pop %ebx
80105866: 5e pop %esi
80105867: 5d pop %ebp
80105868: f3 c3 repz ret
8010586a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80105870 <uartinit>:
{
80105870: 55 push %ebp
80105871: 31 c9 xor %ecx,%ecx
80105873: 89 e5 mov %esp,%ebp
80105875: 89 c8 mov %ecx,%eax
80105877: 57 push %edi
80105878: bf fa 03 00 00 mov $0x3fa,%edi
8010587d: 56 push %esi
8010587e: 89 fa mov %edi,%edx
80105880: 53 push %ebx
80105881: 83 ec 1c sub $0x1c,%esp
80105884: ee out %al,(%dx)
80105885: be fb 03 00 00 mov $0x3fb,%esi
8010588a: b8 80 ff ff ff mov $0xffffff80,%eax
8010588f: 89 f2 mov %esi,%edx
80105891: ee out %al,(%dx)
80105892: b8 0c 00 00 00 mov $0xc,%eax
80105897: b2 f8 mov $0xf8,%dl
80105899: ee out %al,(%dx)
8010589a: bb f9 03 00 00 mov $0x3f9,%ebx
8010589f: 89 c8 mov %ecx,%eax
801058a1: 89 da mov %ebx,%edx
801058a3: ee out %al,(%dx)
801058a4: b8 03 00 00 00 mov $0x3,%eax
801058a9: 89 f2 mov %esi,%edx
801058ab: ee out %al,(%dx)
801058ac: b2 fc mov $0xfc,%dl
801058ae: 89 c8 mov %ecx,%eax
801058b0: ee out %al,(%dx)
801058b1: b8 01 00 00 00 mov $0x1,%eax
801058b6: 89 da mov %ebx,%edx
801058b8: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
801058b9: b2 fd mov $0xfd,%dl
801058bb: ec in (%dx),%al
if(inb(COM1+5) == 0xFF)
801058bc: 3c ff cmp $0xff,%al
801058be: 74 42 je 80105902 <uartinit+0x92>
uart = 1;
801058c0: c7 05 bc a5 10 80 01 movl $0x1,0x8010a5bc
801058c7: 00 00 00
801058ca: 89 fa mov %edi,%edx
801058cc: ec in (%dx),%al
801058cd: b2 f8 mov $0xf8,%dl
801058cf: ec in (%dx),%al
ioapicenable(IRQ_COM1, 0);
801058d0: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
801058d7: 00
for(p="xv6...\n"; *p; p++)
801058d8: bb 50 77 10 80 mov $0x80107750,%ebx
ioapicenable(IRQ_COM1, 0);
801058dd: c7 04 24 04 00 00 00 movl $0x4,(%esp)
801058e4: e8 b7 c9 ff ff call 801022a0 <ioapicenable>
for(p="xv6...\n"; *p; p++)
801058e9: b8 78 00 00 00 mov $0x78,%eax
801058ee: 66 90 xchg %ax,%ax
uartputc(*p);
801058f0: 89 04 24 mov %eax,(%esp)
for(p="xv6...\n"; *p; p++)
801058f3: 83 c3 01 add $0x1,%ebx
uartputc(*p);
801058f6: e8 25 ff ff ff call 80105820 <uartputc>
for(p="xv6...\n"; *p; p++)
801058fb: 0f be 03 movsbl (%ebx),%eax
801058fe: 84 c0 test %al,%al
80105900: 75 ee jne 801058f0 <uartinit+0x80>
}
80105902: 83 c4 1c add $0x1c,%esp
80105905: 5b pop %ebx
80105906: 5e pop %esi
80105907: 5f pop %edi
80105908: 5d pop %ebp
80105909: c3 ret
8010590a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80105910 <uartintr>:
void
uartintr(void)
{
80105910: 55 push %ebp
80105911: 89 e5 mov %esp,%ebp
80105913: 83 ec 18 sub $0x18,%esp
consoleintr(uartgetc);
80105916: c7 04 24 f0 57 10 80 movl $0x801057f0,(%esp)
8010591d: e8 8e ae ff ff call 801007b0 <consoleintr>
}
80105922: c9 leave
80105923: c3 ret
80105924 <vector0>:
# generated by vectors.pl - do not edit
# handlers
.globl alltraps
.globl vector0
vector0:
pushl $0
80105924: 6a 00 push $0x0
pushl $0
80105926: 6a 00 push $0x0
jmp alltraps
80105928: e9 e0 fa ff ff jmp 8010540d <alltraps>
8010592d <vector1>:
.globl vector1
vector1:
pushl $0
8010592d: 6a 00 push $0x0
pushl $1
8010592f: 6a 01 push $0x1
jmp alltraps
80105931: e9 d7 fa ff ff jmp 8010540d <alltraps>
80105936 <vector2>:
.globl vector2
vector2:
pushl $0
80105936: 6a 00 push $0x0
pushl $2
80105938: 6a 02 push $0x2
jmp alltraps
8010593a: e9 ce fa ff ff jmp 8010540d <alltraps>
8010593f <vector3>:
.globl vector3
vector3:
pushl $0
8010593f: 6a 00 push $0x0
pushl $3
80105941: 6a 03 push $0x3
jmp alltraps
80105943: e9 c5 fa ff ff jmp 8010540d <alltraps>
80105948 <vector4>:
.globl vector4
vector4:
pushl $0
80105948: 6a 00 push $0x0
pushl $4
8010594a: 6a 04 push $0x4
jmp alltraps
8010594c: e9 bc fa ff ff jmp 8010540d <alltraps>
80105951 <vector5>:
.globl vector5
vector5:
pushl $0
80105951: 6a 00 push $0x0
pushl $5
80105953: 6a 05 push $0x5
jmp alltraps
80105955: e9 b3 fa ff ff jmp 8010540d <alltraps>
8010595a <vector6>:
.globl vector6
vector6:
pushl $0
8010595a: 6a 00 push $0x0
pushl $6
8010595c: 6a 06 push $0x6
jmp alltraps
8010595e: e9 aa fa ff ff jmp 8010540d <alltraps>
80105963 <vector7>:
.globl vector7
vector7:
pushl $0
80105963: 6a 00 push $0x0
pushl $7
80105965: 6a 07 push $0x7
jmp alltraps
80105967: e9 a1 fa ff ff jmp 8010540d <alltraps>
8010596c <vector8>:
.globl vector8
vector8:
pushl $8
8010596c: 6a 08 push $0x8
jmp alltraps
8010596e: e9 9a fa ff ff jmp 8010540d <alltraps>
80105973 <vector9>:
.globl vector9
vector9:
pushl $0
80105973: 6a 00 push $0x0
pushl $9
80105975: 6a 09 push $0x9
jmp alltraps
80105977: e9 91 fa ff ff jmp 8010540d <alltraps>
8010597c <vector10>:
.globl vector10
vector10:
pushl $10
8010597c: 6a 0a push $0xa
jmp alltraps
8010597e: e9 8a fa ff ff jmp 8010540d <alltraps>
80105983 <vector11>:
.globl vector11
vector11:
pushl $11
80105983: 6a 0b push $0xb
jmp alltraps
80105985: e9 83 fa ff ff jmp 8010540d <alltraps>
8010598a <vector12>:
.globl vector12
vector12:
pushl $12
8010598a: 6a 0c push $0xc
jmp alltraps
8010598c: e9 7c fa ff ff jmp 8010540d <alltraps>
80105991 <vector13>:
.globl vector13
vector13:
pushl $13
80105991: 6a 0d push $0xd
jmp alltraps
80105993: e9 75 fa ff ff jmp 8010540d <alltraps>
80105998 <vector14>:
.globl vector14
vector14:
pushl $14
80105998: 6a 0e push $0xe
jmp alltraps
8010599a: e9 6e fa ff ff jmp 8010540d <alltraps>
8010599f <vector15>:
.globl vector15
vector15:
pushl $0
8010599f: 6a 00 push $0x0
pushl $15
801059a1: 6a 0f push $0xf
jmp alltraps
801059a3: e9 65 fa ff ff jmp 8010540d <alltraps>
801059a8 <vector16>:
.globl vector16
vector16:
pushl $0
801059a8: 6a 00 push $0x0
pushl $16
801059aa: 6a 10 push $0x10
jmp alltraps
801059ac: e9 5c fa ff ff jmp 8010540d <alltraps>
801059b1 <vector17>:
.globl vector17
vector17:
pushl $17
801059b1: 6a 11 push $0x11
jmp alltraps
801059b3: e9 55 fa ff ff jmp 8010540d <alltraps>
801059b8 <vector18>:
.globl vector18
vector18:
pushl $0
801059b8: 6a 00 push $0x0
pushl $18
801059ba: 6a 12 push $0x12
jmp alltraps
801059bc: e9 4c fa ff ff jmp 8010540d <alltraps>
801059c1 <vector19>:
.globl vector19
vector19:
pushl $0
801059c1: 6a 00 push $0x0
pushl $19
801059c3: 6a 13 push $0x13
jmp alltraps
801059c5: e9 43 fa ff ff jmp 8010540d <alltraps>
801059ca <vector20>:
.globl vector20
vector20:
pushl $0
801059ca: 6a 00 push $0x0
pushl $20
801059cc: 6a 14 push $0x14
jmp alltraps
801059ce: e9 3a fa ff ff jmp 8010540d <alltraps>
801059d3 <vector21>:
.globl vector21
vector21:
pushl $0
801059d3: 6a 00 push $0x0
pushl $21
801059d5: 6a 15 push $0x15
jmp alltraps
801059d7: e9 31 fa ff ff jmp 8010540d <alltraps>
801059dc <vector22>:
.globl vector22
vector22:
pushl $0
801059dc: 6a 00 push $0x0
pushl $22
801059de: 6a 16 push $0x16
jmp alltraps
801059e0: e9 28 fa ff ff jmp 8010540d <alltraps>
801059e5 <vector23>:
.globl vector23
vector23:
pushl $0
801059e5: 6a 00 push $0x0
pushl $23
801059e7: 6a 17 push $0x17
jmp alltraps
801059e9: e9 1f fa ff ff jmp 8010540d <alltraps>
801059ee <vector24>:
.globl vector24
vector24:
pushl $0
801059ee: 6a 00 push $0x0
pushl $24
801059f0: 6a 18 push $0x18
jmp alltraps
801059f2: e9 16 fa ff ff jmp 8010540d <alltraps>
801059f7 <vector25>:
.globl vector25
vector25:
pushl $0
801059f7: 6a 00 push $0x0
pushl $25
801059f9: 6a 19 push $0x19
jmp alltraps
801059fb: e9 0d fa ff ff jmp 8010540d <alltraps>
80105a00 <vector26>:
.globl vector26
vector26:
pushl $0
80105a00: 6a 00 push $0x0
pushl $26
80105a02: 6a 1a push $0x1a
jmp alltraps
80105a04: e9 04 fa ff ff jmp 8010540d <alltraps>
80105a09 <vector27>:
.globl vector27
vector27:
pushl $0
80105a09: 6a 00 push $0x0
pushl $27
80105a0b: 6a 1b push $0x1b
jmp alltraps
80105a0d: e9 fb f9 ff ff jmp 8010540d <alltraps>
80105a12 <vector28>:
.globl vector28
vector28:
pushl $0
80105a12: 6a 00 push $0x0
pushl $28
80105a14: 6a 1c push $0x1c
jmp alltraps
80105a16: e9 f2 f9 ff ff jmp 8010540d <alltraps>
80105a1b <vector29>:
.globl vector29
vector29:
pushl $0
80105a1b: 6a 00 push $0x0
pushl $29
80105a1d: 6a 1d push $0x1d
jmp alltraps
80105a1f: e9 e9 f9 ff ff jmp 8010540d <alltraps>
80105a24 <vector30>:
.globl vector30
vector30:
pushl $0
80105a24: 6a 00 push $0x0
pushl $30
80105a26: 6a 1e push $0x1e
jmp alltraps
80105a28: e9 e0 f9 ff ff jmp 8010540d <alltraps>
80105a2d <vector31>:
.globl vector31
vector31:
pushl $0
80105a2d: 6a 00 push $0x0
pushl $31
80105a2f: 6a 1f push $0x1f
jmp alltraps
80105a31: e9 d7 f9 ff ff jmp 8010540d <alltraps>
80105a36 <vector32>:
.globl vector32
vector32:
pushl $0
80105a36: 6a 00 push $0x0
pushl $32
80105a38: 6a 20 push $0x20
jmp alltraps
80105a3a: e9 ce f9 ff ff jmp 8010540d <alltraps>
80105a3f <vector33>:
.globl vector33
vector33:
pushl $0
80105a3f: 6a 00 push $0x0
pushl $33
80105a41: 6a 21 push $0x21
jmp alltraps
80105a43: e9 c5 f9 ff ff jmp 8010540d <alltraps>
80105a48 <vector34>:
.globl vector34
vector34:
pushl $0
80105a48: 6a 00 push $0x0
pushl $34
80105a4a: 6a 22 push $0x22
jmp alltraps
80105a4c: e9 bc f9 ff ff jmp 8010540d <alltraps>
80105a51 <vector35>:
.globl vector35
vector35:
pushl $0
80105a51: 6a 00 push $0x0
pushl $35
80105a53: 6a 23 push $0x23
jmp alltraps
80105a55: e9 b3 f9 ff ff jmp 8010540d <alltraps>
80105a5a <vector36>:
.globl vector36
vector36:
pushl $0
80105a5a: 6a 00 push $0x0
pushl $36
80105a5c: 6a 24 push $0x24
jmp alltraps
80105a5e: e9 aa f9 ff ff jmp 8010540d <alltraps>
80105a63 <vector37>:
.globl vector37
vector37:
pushl $0
80105a63: 6a 00 push $0x0
pushl $37
80105a65: 6a 25 push $0x25
jmp alltraps
80105a67: e9 a1 f9 ff ff jmp 8010540d <alltraps>
80105a6c <vector38>:
.globl vector38
vector38:
pushl $0
80105a6c: 6a 00 push $0x0
pushl $38
80105a6e: 6a 26 push $0x26
jmp alltraps
80105a70: e9 98 f9 ff ff jmp 8010540d <alltraps>
80105a75 <vector39>:
.globl vector39
vector39:
pushl $0
80105a75: 6a 00 push $0x0
pushl $39
80105a77: 6a 27 push $0x27
jmp alltraps
80105a79: e9 8f f9 ff ff jmp 8010540d <alltraps>
80105a7e <vector40>:
.globl vector40
vector40:
pushl $0
80105a7e: 6a 00 push $0x0
pushl $40
80105a80: 6a 28 push $0x28
jmp alltraps
80105a82: e9 86 f9 ff ff jmp 8010540d <alltraps>
80105a87 <vector41>:
.globl vector41
vector41:
pushl $0
80105a87: 6a 00 push $0x0
pushl $41
80105a89: 6a 29 push $0x29
jmp alltraps
80105a8b: e9 7d f9 ff ff jmp 8010540d <alltraps>
80105a90 <vector42>:
.globl vector42
vector42:
pushl $0
80105a90: 6a 00 push $0x0
pushl $42
80105a92: 6a 2a push $0x2a
jmp alltraps
80105a94: e9 74 f9 ff ff jmp 8010540d <alltraps>
80105a99 <vector43>:
.globl vector43
vector43:
pushl $0
80105a99: 6a 00 push $0x0
pushl $43
80105a9b: 6a 2b push $0x2b
jmp alltraps
80105a9d: e9 6b f9 ff ff jmp 8010540d <alltraps>
80105aa2 <vector44>:
.globl vector44
vector44:
pushl $0
80105aa2: 6a 00 push $0x0
pushl $44
80105aa4: 6a 2c push $0x2c
jmp alltraps
80105aa6: e9 62 f9 ff ff jmp 8010540d <alltraps>
80105aab <vector45>:
.globl vector45
vector45:
pushl $0
80105aab: 6a 00 push $0x0
pushl $45
80105aad: 6a 2d push $0x2d
jmp alltraps
80105aaf: e9 59 f9 ff ff jmp 8010540d <alltraps>
80105ab4 <vector46>:
.globl vector46
vector46:
pushl $0
80105ab4: 6a 00 push $0x0
pushl $46
80105ab6: 6a 2e push $0x2e
jmp alltraps
80105ab8: e9 50 f9 ff ff jmp 8010540d <alltraps>
80105abd <vector47>:
.globl vector47
vector47:
pushl $0
80105abd: 6a 00 push $0x0
pushl $47
80105abf: 6a 2f push $0x2f
jmp alltraps
80105ac1: e9 47 f9 ff ff jmp 8010540d <alltraps>
80105ac6 <vector48>:
.globl vector48
vector48:
pushl $0
80105ac6: 6a 00 push $0x0
pushl $48
80105ac8: 6a 30 push $0x30
jmp alltraps
80105aca: e9 3e f9 ff ff jmp 8010540d <alltraps>
80105acf <vector49>:
.globl vector49
vector49:
pushl $0
80105acf: 6a 00 push $0x0
pushl $49
80105ad1: 6a 31 push $0x31
jmp alltraps
80105ad3: e9 35 f9 ff ff jmp 8010540d <alltraps>
80105ad8 <vector50>:
.globl vector50
vector50:
pushl $0
80105ad8: 6a 00 push $0x0
pushl $50
80105ada: 6a 32 push $0x32
jmp alltraps
80105adc: e9 2c f9 ff ff jmp 8010540d <alltraps>
80105ae1 <vector51>:
.globl vector51
vector51:
pushl $0
80105ae1: 6a 00 push $0x0
pushl $51
80105ae3: 6a 33 push $0x33
jmp alltraps
80105ae5: e9 23 f9 ff ff jmp 8010540d <alltraps>
80105aea <vector52>:
.globl vector52
vector52:
pushl $0
80105aea: 6a 00 push $0x0
pushl $52
80105aec: 6a 34 push $0x34
jmp alltraps
80105aee: e9 1a f9 ff ff jmp 8010540d <alltraps>
80105af3 <vector53>:
.globl vector53
vector53:
pushl $0
80105af3: 6a 00 push $0x0
pushl $53
80105af5: 6a 35 push $0x35
jmp alltraps
80105af7: e9 11 f9 ff ff jmp 8010540d <alltraps>
80105afc <vector54>:
.globl vector54
vector54:
pushl $0
80105afc: 6a 00 push $0x0
pushl $54
80105afe: 6a 36 push $0x36
jmp alltraps
80105b00: e9 08 f9 ff ff jmp 8010540d <alltraps>
80105b05 <vector55>:
.globl vector55
vector55:
pushl $0
80105b05: 6a 00 push $0x0
pushl $55
80105b07: 6a 37 push $0x37
jmp alltraps
80105b09: e9 ff f8 ff ff jmp 8010540d <alltraps>
80105b0e <vector56>:
.globl vector56
vector56:
pushl $0
80105b0e: 6a 00 push $0x0
pushl $56
80105b10: 6a 38 push $0x38
jmp alltraps
80105b12: e9 f6 f8 ff ff jmp 8010540d <alltraps>
80105b17 <vector57>:
.globl vector57
vector57:
pushl $0
80105b17: 6a 00 push $0x0
pushl $57
80105b19: 6a 39 push $0x39
jmp alltraps
80105b1b: e9 ed f8 ff ff jmp 8010540d <alltraps>
80105b20 <vector58>:
.globl vector58
vector58:
pushl $0
80105b20: 6a 00 push $0x0
pushl $58
80105b22: 6a 3a push $0x3a
jmp alltraps
80105b24: e9 e4 f8 ff ff jmp 8010540d <alltraps>
80105b29 <vector59>:
.globl vector59
vector59:
pushl $0
80105b29: 6a 00 push $0x0
pushl $59
80105b2b: 6a 3b push $0x3b
jmp alltraps
80105b2d: e9 db f8 ff ff jmp 8010540d <alltraps>
80105b32 <vector60>:
.globl vector60
vector60:
pushl $0
80105b32: 6a 00 push $0x0
pushl $60
80105b34: 6a 3c push $0x3c
jmp alltraps
80105b36: e9 d2 f8 ff ff jmp 8010540d <alltraps>
80105b3b <vector61>:
.globl vector61
vector61:
pushl $0
80105b3b: 6a 00 push $0x0
pushl $61
80105b3d: 6a 3d push $0x3d
jmp alltraps
80105b3f: e9 c9 f8 ff ff jmp 8010540d <alltraps>
80105b44 <vector62>:
.globl vector62
vector62:
pushl $0
80105b44: 6a 00 push $0x0
pushl $62
80105b46: 6a 3e push $0x3e
jmp alltraps
80105b48: e9 c0 f8 ff ff jmp 8010540d <alltraps>
80105b4d <vector63>:
.globl vector63
vector63:
pushl $0
80105b4d: 6a 00 push $0x0
pushl $63
80105b4f: 6a 3f push $0x3f
jmp alltraps
80105b51: e9 b7 f8 ff ff jmp 8010540d <alltraps>
80105b56 <vector64>:
.globl vector64
vector64:
pushl $0
80105b56: 6a 00 push $0x0
pushl $64
80105b58: 6a 40 push $0x40
jmp alltraps
80105b5a: e9 ae f8 ff ff jmp 8010540d <alltraps>
80105b5f <vector65>:
.globl vector65
vector65:
pushl $0
80105b5f: 6a 00 push $0x0
pushl $65
80105b61: 6a 41 push $0x41
jmp alltraps
80105b63: e9 a5 f8 ff ff jmp 8010540d <alltraps>
80105b68 <vector66>:
.globl vector66
vector66:
pushl $0
80105b68: 6a 00 push $0x0
pushl $66
80105b6a: 6a 42 push $0x42
jmp alltraps
80105b6c: e9 9c f8 ff ff jmp 8010540d <alltraps>
80105b71 <vector67>:
.globl vector67
vector67:
pushl $0
80105b71: 6a 00 push $0x0
pushl $67
80105b73: 6a 43 push $0x43
jmp alltraps
80105b75: e9 93 f8 ff ff jmp 8010540d <alltraps>
80105b7a <vector68>:
.globl vector68
vector68:
pushl $0
80105b7a: 6a 00 push $0x0
pushl $68
80105b7c: 6a 44 push $0x44
jmp alltraps
80105b7e: e9 8a f8 ff ff jmp 8010540d <alltraps>
80105b83 <vector69>:
.globl vector69
vector69:
pushl $0
80105b83: 6a 00 push $0x0
pushl $69
80105b85: 6a 45 push $0x45
jmp alltraps
80105b87: e9 81 f8 ff ff jmp 8010540d <alltraps>
80105b8c <vector70>:
.globl vector70
vector70:
pushl $0
80105b8c: 6a 00 push $0x0
pushl $70
80105b8e: 6a 46 push $0x46
jmp alltraps
80105b90: e9 78 f8 ff ff jmp 8010540d <alltraps>
80105b95 <vector71>:
.globl vector71
vector71:
pushl $0
80105b95: 6a 00 push $0x0
pushl $71
80105b97: 6a 47 push $0x47
jmp alltraps
80105b99: e9 6f f8 ff ff jmp 8010540d <alltraps>
80105b9e <vector72>:
.globl vector72
vector72:
pushl $0
80105b9e: 6a 00 push $0x0
pushl $72
80105ba0: 6a 48 push $0x48
jmp alltraps
80105ba2: e9 66 f8 ff ff jmp 8010540d <alltraps>
80105ba7 <vector73>:
.globl vector73
vector73:
pushl $0
80105ba7: 6a 00 push $0x0
pushl $73
80105ba9: 6a 49 push $0x49
jmp alltraps
80105bab: e9 5d f8 ff ff jmp 8010540d <alltraps>
80105bb0 <vector74>:
.globl vector74
vector74:
pushl $0
80105bb0: 6a 00 push $0x0
pushl $74
80105bb2: 6a 4a push $0x4a
jmp alltraps
80105bb4: e9 54 f8 ff ff jmp 8010540d <alltraps>
80105bb9 <vector75>:
.globl vector75
vector75:
pushl $0
80105bb9: 6a 00 push $0x0
pushl $75
80105bbb: 6a 4b push $0x4b
jmp alltraps
80105bbd: e9 4b f8 ff ff jmp 8010540d <alltraps>
80105bc2 <vector76>:
.globl vector76
vector76:
pushl $0
80105bc2: 6a 00 push $0x0
pushl $76
80105bc4: 6a 4c push $0x4c
jmp alltraps
80105bc6: e9 42 f8 ff ff jmp 8010540d <alltraps>
80105bcb <vector77>:
.globl vector77
vector77:
pushl $0
80105bcb: 6a 00 push $0x0
pushl $77
80105bcd: 6a 4d push $0x4d
jmp alltraps
80105bcf: e9 39 f8 ff ff jmp 8010540d <alltraps>
80105bd4 <vector78>:
.globl vector78
vector78:
pushl $0
80105bd4: 6a 00 push $0x0
pushl $78
80105bd6: 6a 4e push $0x4e
jmp alltraps
80105bd8: e9 30 f8 ff ff jmp 8010540d <alltraps>
80105bdd <vector79>:
.globl vector79
vector79:
pushl $0
80105bdd: 6a 00 push $0x0
pushl $79
80105bdf: 6a 4f push $0x4f
jmp alltraps
80105be1: e9 27 f8 ff ff jmp 8010540d <alltraps>
80105be6 <vector80>:
.globl vector80
vector80:
pushl $0
80105be6: 6a 00 push $0x0
pushl $80
80105be8: 6a 50 push $0x50
jmp alltraps
80105bea: e9 1e f8 ff ff jmp 8010540d <alltraps>
80105bef <vector81>:
.globl vector81
vector81:
pushl $0
80105bef: 6a 00 push $0x0
pushl $81
80105bf1: 6a 51 push $0x51
jmp alltraps
80105bf3: e9 15 f8 ff ff jmp 8010540d <alltraps>
80105bf8 <vector82>:
.globl vector82
vector82:
pushl $0
80105bf8: 6a 00 push $0x0
pushl $82
80105bfa: 6a 52 push $0x52
jmp alltraps
80105bfc: e9 0c f8 ff ff jmp 8010540d <alltraps>
80105c01 <vector83>:
.globl vector83
vector83:
pushl $0
80105c01: 6a 00 push $0x0
pushl $83
80105c03: 6a 53 push $0x53
jmp alltraps
80105c05: e9 03 f8 ff ff jmp 8010540d <alltraps>
80105c0a <vector84>:
.globl vector84
vector84:
pushl $0
80105c0a: 6a 00 push $0x0
pushl $84
80105c0c: 6a 54 push $0x54
jmp alltraps
80105c0e: e9 fa f7 ff ff jmp 8010540d <alltraps>
80105c13 <vector85>:
.globl vector85
vector85:
pushl $0
80105c13: 6a 00 push $0x0
pushl $85
80105c15: 6a 55 push $0x55
jmp alltraps
80105c17: e9 f1 f7 ff ff jmp 8010540d <alltraps>
80105c1c <vector86>:
.globl vector86
vector86:
pushl $0
80105c1c: 6a 00 push $0x0
pushl $86
80105c1e: 6a 56 push $0x56
jmp alltraps
80105c20: e9 e8 f7 ff ff jmp 8010540d <alltraps>
80105c25 <vector87>:
.globl vector87
vector87:
pushl $0
80105c25: 6a 00 push $0x0
pushl $87
80105c27: 6a 57 push $0x57
jmp alltraps
80105c29: e9 df f7 ff ff jmp 8010540d <alltraps>
80105c2e <vector88>:
.globl vector88
vector88:
pushl $0
80105c2e: 6a 00 push $0x0
pushl $88
80105c30: 6a 58 push $0x58
jmp alltraps
80105c32: e9 d6 f7 ff ff jmp 8010540d <alltraps>
80105c37 <vector89>:
.globl vector89
vector89:
pushl $0
80105c37: 6a 00 push $0x0
pushl $89
80105c39: 6a 59 push $0x59
jmp alltraps
80105c3b: e9 cd f7 ff ff jmp 8010540d <alltraps>
80105c40 <vector90>:
.globl vector90
vector90:
pushl $0
80105c40: 6a 00 push $0x0
pushl $90
80105c42: 6a 5a push $0x5a
jmp alltraps
80105c44: e9 c4 f7 ff ff jmp 8010540d <alltraps>
80105c49 <vector91>:
.globl vector91
vector91:
pushl $0
80105c49: 6a 00 push $0x0
pushl $91
80105c4b: 6a 5b push $0x5b
jmp alltraps
80105c4d: e9 bb f7 ff ff jmp 8010540d <alltraps>
80105c52 <vector92>:
.globl vector92
vector92:
pushl $0
80105c52: 6a 00 push $0x0
pushl $92
80105c54: 6a 5c push $0x5c
jmp alltraps
80105c56: e9 b2 f7 ff ff jmp 8010540d <alltraps>
80105c5b <vector93>:
.globl vector93
vector93:
pushl $0
80105c5b: 6a 00 push $0x0
pushl $93
80105c5d: 6a 5d push $0x5d
jmp alltraps
80105c5f: e9 a9 f7 ff ff jmp 8010540d <alltraps>
80105c64 <vector94>:
.globl vector94
vector94:
pushl $0
80105c64: 6a 00 push $0x0
pushl $94
80105c66: 6a 5e push $0x5e
jmp alltraps
80105c68: e9 a0 f7 ff ff jmp 8010540d <alltraps>
80105c6d <vector95>:
.globl vector95
vector95:
pushl $0
80105c6d: 6a 00 push $0x0
pushl $95
80105c6f: 6a 5f push $0x5f
jmp alltraps
80105c71: e9 97 f7 ff ff jmp 8010540d <alltraps>
80105c76 <vector96>:
.globl vector96
vector96:
pushl $0
80105c76: 6a 00 push $0x0
pushl $96
80105c78: 6a 60 push $0x60
jmp alltraps
80105c7a: e9 8e f7 ff ff jmp 8010540d <alltraps>
80105c7f <vector97>:
.globl vector97
vector97:
pushl $0
80105c7f: 6a 00 push $0x0
pushl $97
80105c81: 6a 61 push $0x61
jmp alltraps
80105c83: e9 85 f7 ff ff jmp 8010540d <alltraps>
80105c88 <vector98>:
.globl vector98
vector98:
pushl $0
80105c88: 6a 00 push $0x0
pushl $98
80105c8a: 6a 62 push $0x62
jmp alltraps
80105c8c: e9 7c f7 ff ff jmp 8010540d <alltraps>
80105c91 <vector99>:
.globl vector99
vector99:
pushl $0
80105c91: 6a 00 push $0x0
pushl $99
80105c93: 6a 63 push $0x63
jmp alltraps
80105c95: e9 73 f7 ff ff jmp 8010540d <alltraps>
80105c9a <vector100>:
.globl vector100
vector100:
pushl $0
80105c9a: 6a 00 push $0x0
pushl $100
80105c9c: 6a 64 push $0x64
jmp alltraps
80105c9e: e9 6a f7 ff ff jmp 8010540d <alltraps>
80105ca3 <vector101>:
.globl vector101
vector101:
pushl $0
80105ca3: 6a 00 push $0x0
pushl $101
80105ca5: 6a 65 push $0x65
jmp alltraps
80105ca7: e9 61 f7 ff ff jmp 8010540d <alltraps>
80105cac <vector102>:
.globl vector102
vector102:
pushl $0
80105cac: 6a 00 push $0x0
pushl $102
80105cae: 6a 66 push $0x66
jmp alltraps
80105cb0: e9 58 f7 ff ff jmp 8010540d <alltraps>
80105cb5 <vector103>:
.globl vector103
vector103:
pushl $0
80105cb5: 6a 00 push $0x0
pushl $103
80105cb7: 6a 67 push $0x67
jmp alltraps
80105cb9: e9 4f f7 ff ff jmp 8010540d <alltraps>
80105cbe <vector104>:
.globl vector104
vector104:
pushl $0
80105cbe: 6a 00 push $0x0
pushl $104
80105cc0: 6a 68 push $0x68
jmp alltraps
80105cc2: e9 46 f7 ff ff jmp 8010540d <alltraps>
80105cc7 <vector105>:
.globl vector105
vector105:
pushl $0
80105cc7: 6a 00 push $0x0
pushl $105
80105cc9: 6a 69 push $0x69
jmp alltraps
80105ccb: e9 3d f7 ff ff jmp 8010540d <alltraps>
80105cd0 <vector106>:
.globl vector106
vector106:
pushl $0
80105cd0: 6a 00 push $0x0
pushl $106
80105cd2: 6a 6a push $0x6a
jmp alltraps
80105cd4: e9 34 f7 ff ff jmp 8010540d <alltraps>
80105cd9 <vector107>:
.globl vector107
vector107:
pushl $0
80105cd9: 6a 00 push $0x0
pushl $107
80105cdb: 6a 6b push $0x6b
jmp alltraps
80105cdd: e9 2b f7 ff ff jmp 8010540d <alltraps>
80105ce2 <vector108>:
.globl vector108
vector108:
pushl $0
80105ce2: 6a 00 push $0x0
pushl $108
80105ce4: 6a 6c push $0x6c
jmp alltraps
80105ce6: e9 22 f7 ff ff jmp 8010540d <alltraps>
80105ceb <vector109>:
.globl vector109
vector109:
pushl $0
80105ceb: 6a 00 push $0x0
pushl $109
80105ced: 6a 6d push $0x6d
jmp alltraps
80105cef: e9 19 f7 ff ff jmp 8010540d <alltraps>
80105cf4 <vector110>:
.globl vector110
vector110:
pushl $0
80105cf4: 6a 00 push $0x0
pushl $110
80105cf6: 6a 6e push $0x6e
jmp alltraps
80105cf8: e9 10 f7 ff ff jmp 8010540d <alltraps>
80105cfd <vector111>:
.globl vector111
vector111:
pushl $0
80105cfd: 6a 00 push $0x0
pushl $111
80105cff: 6a 6f push $0x6f
jmp alltraps
80105d01: e9 07 f7 ff ff jmp 8010540d <alltraps>
80105d06 <vector112>:
.globl vector112
vector112:
pushl $0
80105d06: 6a 00 push $0x0
pushl $112
80105d08: 6a 70 push $0x70
jmp alltraps
80105d0a: e9 fe f6 ff ff jmp 8010540d <alltraps>
80105d0f <vector113>:
.globl vector113
vector113:
pushl $0
80105d0f: 6a 00 push $0x0
pushl $113
80105d11: 6a 71 push $0x71
jmp alltraps
80105d13: e9 f5 f6 ff ff jmp 8010540d <alltraps>
80105d18 <vector114>:
.globl vector114
vector114:
pushl $0
80105d18: 6a 00 push $0x0
pushl $114
80105d1a: 6a 72 push $0x72
jmp alltraps
80105d1c: e9 ec f6 ff ff jmp 8010540d <alltraps>
80105d21 <vector115>:
.globl vector115
vector115:
pushl $0
80105d21: 6a 00 push $0x0
pushl $115
80105d23: 6a 73 push $0x73
jmp alltraps
80105d25: e9 e3 f6 ff ff jmp 8010540d <alltraps>
80105d2a <vector116>:
.globl vector116
vector116:
pushl $0
80105d2a: 6a 00 push $0x0
pushl $116
80105d2c: 6a 74 push $0x74
jmp alltraps
80105d2e: e9 da f6 ff ff jmp 8010540d <alltraps>
80105d33 <vector117>:
.globl vector117
vector117:
pushl $0
80105d33: 6a 00 push $0x0
pushl $117
80105d35: 6a 75 push $0x75
jmp alltraps
80105d37: e9 d1 f6 ff ff jmp 8010540d <alltraps>
80105d3c <vector118>:
.globl vector118
vector118:
pushl $0
80105d3c: 6a 00 push $0x0
pushl $118
80105d3e: 6a 76 push $0x76
jmp alltraps
80105d40: e9 c8 f6 ff ff jmp 8010540d <alltraps>
80105d45 <vector119>:
.globl vector119
vector119:
pushl $0
80105d45: 6a 00 push $0x0
pushl $119
80105d47: 6a 77 push $0x77
jmp alltraps
80105d49: e9 bf f6 ff ff jmp 8010540d <alltraps>
80105d4e <vector120>:
.globl vector120
vector120:
pushl $0
80105d4e: 6a 00 push $0x0
pushl $120
80105d50: 6a 78 push $0x78
jmp alltraps
80105d52: e9 b6 f6 ff ff jmp 8010540d <alltraps>
80105d57 <vector121>:
.globl vector121
vector121:
pushl $0
80105d57: 6a 00 push $0x0
pushl $121
80105d59: 6a 79 push $0x79
jmp alltraps
80105d5b: e9 ad f6 ff ff jmp 8010540d <alltraps>
80105d60 <vector122>:
.globl vector122
vector122:
pushl $0
80105d60: 6a 00 push $0x0
pushl $122
80105d62: 6a 7a push $0x7a
jmp alltraps
80105d64: e9 a4 f6 ff ff jmp 8010540d <alltraps>
80105d69 <vector123>:
.globl vector123
vector123:
pushl $0
80105d69: 6a 00 push $0x0
pushl $123
80105d6b: 6a 7b push $0x7b
jmp alltraps
80105d6d: e9 9b f6 ff ff jmp 8010540d <alltraps>
80105d72 <vector124>:
.globl vector124
vector124:
pushl $0
80105d72: 6a 00 push $0x0
pushl $124
80105d74: 6a 7c push $0x7c
jmp alltraps
80105d76: e9 92 f6 ff ff jmp 8010540d <alltraps>
80105d7b <vector125>:
.globl vector125
vector125:
pushl $0
80105d7b: 6a 00 push $0x0
pushl $125
80105d7d: 6a 7d push $0x7d
jmp alltraps
80105d7f: e9 89 f6 ff ff jmp 8010540d <alltraps>
80105d84 <vector126>:
.globl vector126
vector126:
pushl $0
80105d84: 6a 00 push $0x0
pushl $126
80105d86: 6a 7e push $0x7e
jmp alltraps
80105d88: e9 80 f6 ff ff jmp 8010540d <alltraps>
80105d8d <vector127>:
.globl vector127
vector127:
pushl $0
80105d8d: 6a 00 push $0x0
pushl $127
80105d8f: 6a 7f push $0x7f
jmp alltraps
80105d91: e9 77 f6 ff ff jmp 8010540d <alltraps>
80105d96 <vector128>:
.globl vector128
vector128:
pushl $0
80105d96: 6a 00 push $0x0
pushl $128
80105d98: 68 80 00 00 00 push $0x80
jmp alltraps
80105d9d: e9 6b f6 ff ff jmp 8010540d <alltraps>
80105da2 <vector129>:
.globl vector129
vector129:
pushl $0
80105da2: 6a 00 push $0x0
pushl $129
80105da4: 68 81 00 00 00 push $0x81
jmp alltraps
80105da9: e9 5f f6 ff ff jmp 8010540d <alltraps>
80105dae <vector130>:
.globl vector130
vector130:
pushl $0
80105dae: 6a 00 push $0x0
pushl $130
80105db0: 68 82 00 00 00 push $0x82
jmp alltraps
80105db5: e9 53 f6 ff ff jmp 8010540d <alltraps>
80105dba <vector131>:
.globl vector131
vector131:
pushl $0
80105dba: 6a 00 push $0x0
pushl $131
80105dbc: 68 83 00 00 00 push $0x83
jmp alltraps
80105dc1: e9 47 f6 ff ff jmp 8010540d <alltraps>
80105dc6 <vector132>:
.globl vector132
vector132:
pushl $0
80105dc6: 6a 00 push $0x0
pushl $132
80105dc8: 68 84 00 00 00 push $0x84
jmp alltraps
80105dcd: e9 3b f6 ff ff jmp 8010540d <alltraps>
80105dd2 <vector133>:
.globl vector133
vector133:
pushl $0
80105dd2: 6a 00 push $0x0
pushl $133
80105dd4: 68 85 00 00 00 push $0x85
jmp alltraps
80105dd9: e9 2f f6 ff ff jmp 8010540d <alltraps>
80105dde <vector134>:
.globl vector134
vector134:
pushl $0
80105dde: 6a 00 push $0x0
pushl $134
80105de0: 68 86 00 00 00 push $0x86
jmp alltraps
80105de5: e9 23 f6 ff ff jmp 8010540d <alltraps>
80105dea <vector135>:
.globl vector135
vector135:
pushl $0
80105dea: 6a 00 push $0x0
pushl $135
80105dec: 68 87 00 00 00 push $0x87
jmp alltraps
80105df1: e9 17 f6 ff ff jmp 8010540d <alltraps>
80105df6 <vector136>:
.globl vector136
vector136:
pushl $0
80105df6: 6a 00 push $0x0
pushl $136
80105df8: 68 88 00 00 00 push $0x88
jmp alltraps
80105dfd: e9 0b f6 ff ff jmp 8010540d <alltraps>
80105e02 <vector137>:
.globl vector137
vector137:
pushl $0
80105e02: 6a 00 push $0x0
pushl $137
80105e04: 68 89 00 00 00 push $0x89
jmp alltraps
80105e09: e9 ff f5 ff ff jmp 8010540d <alltraps>
80105e0e <vector138>:
.globl vector138
vector138:
pushl $0
80105e0e: 6a 00 push $0x0
pushl $138
80105e10: 68 8a 00 00 00 push $0x8a
jmp alltraps
80105e15: e9 f3 f5 ff ff jmp 8010540d <alltraps>
80105e1a <vector139>:
.globl vector139
vector139:
pushl $0
80105e1a: 6a 00 push $0x0
pushl $139
80105e1c: 68 8b 00 00 00 push $0x8b
jmp alltraps
80105e21: e9 e7 f5 ff ff jmp 8010540d <alltraps>
80105e26 <vector140>:
.globl vector140
vector140:
pushl $0
80105e26: 6a 00 push $0x0
pushl $140
80105e28: 68 8c 00 00 00 push $0x8c
jmp alltraps
80105e2d: e9 db f5 ff ff jmp 8010540d <alltraps>
80105e32 <vector141>:
.globl vector141
vector141:
pushl $0
80105e32: 6a 00 push $0x0
pushl $141
80105e34: 68 8d 00 00 00 push $0x8d
jmp alltraps
80105e39: e9 cf f5 ff ff jmp 8010540d <alltraps>
80105e3e <vector142>:
.globl vector142
vector142:
pushl $0
80105e3e: 6a 00 push $0x0
pushl $142
80105e40: 68 8e 00 00 00 push $0x8e
jmp alltraps
80105e45: e9 c3 f5 ff ff jmp 8010540d <alltraps>
80105e4a <vector143>:
.globl vector143
vector143:
pushl $0
80105e4a: 6a 00 push $0x0
pushl $143
80105e4c: 68 8f 00 00 00 push $0x8f
jmp alltraps
80105e51: e9 b7 f5 ff ff jmp 8010540d <alltraps>
80105e56 <vector144>:
.globl vector144
vector144:
pushl $0
80105e56: 6a 00 push $0x0
pushl $144
80105e58: 68 90 00 00 00 push $0x90
jmp alltraps
80105e5d: e9 ab f5 ff ff jmp 8010540d <alltraps>
80105e62 <vector145>:
.globl vector145
vector145:
pushl $0
80105e62: 6a 00 push $0x0
pushl $145
80105e64: 68 91 00 00 00 push $0x91
jmp alltraps
80105e69: e9 9f f5 ff ff jmp 8010540d <alltraps>
80105e6e <vector146>:
.globl vector146
vector146:
pushl $0
80105e6e: 6a 00 push $0x0
pushl $146
80105e70: 68 92 00 00 00 push $0x92
jmp alltraps
80105e75: e9 93 f5 ff ff jmp 8010540d <alltraps>
80105e7a <vector147>:
.globl vector147
vector147:
pushl $0
80105e7a: 6a 00 push $0x0
pushl $147
80105e7c: 68 93 00 00 00 push $0x93
jmp alltraps
80105e81: e9 87 f5 ff ff jmp 8010540d <alltraps>
80105e86 <vector148>:
.globl vector148
vector148:
pushl $0
80105e86: 6a 00 push $0x0
pushl $148
80105e88: 68 94 00 00 00 push $0x94
jmp alltraps
80105e8d: e9 7b f5 ff ff jmp 8010540d <alltraps>
80105e92 <vector149>:
.globl vector149
vector149:
pushl $0
80105e92: 6a 00 push $0x0
pushl $149
80105e94: 68 95 00 00 00 push $0x95
jmp alltraps
80105e99: e9 6f f5 ff ff jmp 8010540d <alltraps>
80105e9e <vector150>:
.globl vector150
vector150:
pushl $0
80105e9e: 6a 00 push $0x0
pushl $150
80105ea0: 68 96 00 00 00 push $0x96
jmp alltraps
80105ea5: e9 63 f5 ff ff jmp 8010540d <alltraps>
80105eaa <vector151>:
.globl vector151
vector151:
pushl $0
80105eaa: 6a 00 push $0x0
pushl $151
80105eac: 68 97 00 00 00 push $0x97
jmp alltraps
80105eb1: e9 57 f5 ff ff jmp 8010540d <alltraps>
80105eb6 <vector152>:
.globl vector152
vector152:
pushl $0
80105eb6: 6a 00 push $0x0
pushl $152
80105eb8: 68 98 00 00 00 push $0x98
jmp alltraps
80105ebd: e9 4b f5 ff ff jmp 8010540d <alltraps>
80105ec2 <vector153>:
.globl vector153
vector153:
pushl $0
80105ec2: 6a 00 push $0x0
pushl $153
80105ec4: 68 99 00 00 00 push $0x99
jmp alltraps
80105ec9: e9 3f f5 ff ff jmp 8010540d <alltraps>
80105ece <vector154>:
.globl vector154
vector154:
pushl $0
80105ece: 6a 00 push $0x0
pushl $154
80105ed0: 68 9a 00 00 00 push $0x9a
jmp alltraps
80105ed5: e9 33 f5 ff ff jmp 8010540d <alltraps>
80105eda <vector155>:
.globl vector155
vector155:
pushl $0
80105eda: 6a 00 push $0x0
pushl $155
80105edc: 68 9b 00 00 00 push $0x9b
jmp alltraps
80105ee1: e9 27 f5 ff ff jmp 8010540d <alltraps>
80105ee6 <vector156>:
.globl vector156
vector156:
pushl $0
80105ee6: 6a 00 push $0x0
pushl $156
80105ee8: 68 9c 00 00 00 push $0x9c
jmp alltraps
80105eed: e9 1b f5 ff ff jmp 8010540d <alltraps>
80105ef2 <vector157>:
.globl vector157
vector157:
pushl $0
80105ef2: 6a 00 push $0x0
pushl $157
80105ef4: 68 9d 00 00 00 push $0x9d
jmp alltraps
80105ef9: e9 0f f5 ff ff jmp 8010540d <alltraps>
80105efe <vector158>:
.globl vector158
vector158:
pushl $0
80105efe: 6a 00 push $0x0
pushl $158
80105f00: 68 9e 00 00 00 push $0x9e
jmp alltraps
80105f05: e9 03 f5 ff ff jmp 8010540d <alltraps>
80105f0a <vector159>:
.globl vector159
vector159:
pushl $0
80105f0a: 6a 00 push $0x0
pushl $159
80105f0c: 68 9f 00 00 00 push $0x9f
jmp alltraps
80105f11: e9 f7 f4 ff ff jmp 8010540d <alltraps>
80105f16 <vector160>:
.globl vector160
vector160:
pushl $0
80105f16: 6a 00 push $0x0
pushl $160
80105f18: 68 a0 00 00 00 push $0xa0
jmp alltraps
80105f1d: e9 eb f4 ff ff jmp 8010540d <alltraps>
80105f22 <vector161>:
.globl vector161
vector161:
pushl $0
80105f22: 6a 00 push $0x0
pushl $161
80105f24: 68 a1 00 00 00 push $0xa1
jmp alltraps
80105f29: e9 df f4 ff ff jmp 8010540d <alltraps>
80105f2e <vector162>:
.globl vector162
vector162:
pushl $0
80105f2e: 6a 00 push $0x0
pushl $162
80105f30: 68 a2 00 00 00 push $0xa2
jmp alltraps
80105f35: e9 d3 f4 ff ff jmp 8010540d <alltraps>
80105f3a <vector163>:
.globl vector163
vector163:
pushl $0
80105f3a: 6a 00 push $0x0
pushl $163
80105f3c: 68 a3 00 00 00 push $0xa3
jmp alltraps
80105f41: e9 c7 f4 ff ff jmp 8010540d <alltraps>
80105f46 <vector164>:
.globl vector164
vector164:
pushl $0
80105f46: 6a 00 push $0x0
pushl $164
80105f48: 68 a4 00 00 00 push $0xa4
jmp alltraps
80105f4d: e9 bb f4 ff ff jmp 8010540d <alltraps>
80105f52 <vector165>:
.globl vector165
vector165:
pushl $0
80105f52: 6a 00 push $0x0
pushl $165
80105f54: 68 a5 00 00 00 push $0xa5
jmp alltraps
80105f59: e9 af f4 ff ff jmp 8010540d <alltraps>
80105f5e <vector166>:
.globl vector166
vector166:
pushl $0
80105f5e: 6a 00 push $0x0
pushl $166
80105f60: 68 a6 00 00 00 push $0xa6
jmp alltraps
80105f65: e9 a3 f4 ff ff jmp 8010540d <alltraps>
80105f6a <vector167>:
.globl vector167
vector167:
pushl $0
80105f6a: 6a 00 push $0x0
pushl $167
80105f6c: 68 a7 00 00 00 push $0xa7
jmp alltraps
80105f71: e9 97 f4 ff ff jmp 8010540d <alltraps>
80105f76 <vector168>:
.globl vector168
vector168:
pushl $0
80105f76: 6a 00 push $0x0
pushl $168
80105f78: 68 a8 00 00 00 push $0xa8
jmp alltraps
80105f7d: e9 8b f4 ff ff jmp 8010540d <alltraps>
80105f82 <vector169>:
.globl vector169
vector169:
pushl $0
80105f82: 6a 00 push $0x0
pushl $169
80105f84: 68 a9 00 00 00 push $0xa9
jmp alltraps
80105f89: e9 7f f4 ff ff jmp 8010540d <alltraps>
80105f8e <vector170>:
.globl vector170
vector170:
pushl $0
80105f8e: 6a 00 push $0x0
pushl $170
80105f90: 68 aa 00 00 00 push $0xaa
jmp alltraps
80105f95: e9 73 f4 ff ff jmp 8010540d <alltraps>
80105f9a <vector171>:
.globl vector171
vector171:
pushl $0
80105f9a: 6a 00 push $0x0
pushl $171
80105f9c: 68 ab 00 00 00 push $0xab
jmp alltraps
80105fa1: e9 67 f4 ff ff jmp 8010540d <alltraps>
80105fa6 <vector172>:
.globl vector172
vector172:
pushl $0
80105fa6: 6a 00 push $0x0
pushl $172
80105fa8: 68 ac 00 00 00 push $0xac
jmp alltraps
80105fad: e9 5b f4 ff ff jmp 8010540d <alltraps>
80105fb2 <vector173>:
.globl vector173
vector173:
pushl $0
80105fb2: 6a 00 push $0x0
pushl $173
80105fb4: 68 ad 00 00 00 push $0xad
jmp alltraps
80105fb9: e9 4f f4 ff ff jmp 8010540d <alltraps>
80105fbe <vector174>:
.globl vector174
vector174:
pushl $0
80105fbe: 6a 00 push $0x0
pushl $174
80105fc0: 68 ae 00 00 00 push $0xae
jmp alltraps
80105fc5: e9 43 f4 ff ff jmp 8010540d <alltraps>
80105fca <vector175>:
.globl vector175
vector175:
pushl $0
80105fca: 6a 00 push $0x0
pushl $175
80105fcc: 68 af 00 00 00 push $0xaf
jmp alltraps
80105fd1: e9 37 f4 ff ff jmp 8010540d <alltraps>
80105fd6 <vector176>:
.globl vector176
vector176:
pushl $0
80105fd6: 6a 00 push $0x0
pushl $176
80105fd8: 68 b0 00 00 00 push $0xb0
jmp alltraps
80105fdd: e9 2b f4 ff ff jmp 8010540d <alltraps>
80105fe2 <vector177>:
.globl vector177
vector177:
pushl $0
80105fe2: 6a 00 push $0x0
pushl $177
80105fe4: 68 b1 00 00 00 push $0xb1
jmp alltraps
80105fe9: e9 1f f4 ff ff jmp 8010540d <alltraps>
80105fee <vector178>:
.globl vector178
vector178:
pushl $0
80105fee: 6a 00 push $0x0
pushl $178
80105ff0: 68 b2 00 00 00 push $0xb2
jmp alltraps
80105ff5: e9 13 f4 ff ff jmp 8010540d <alltraps>
80105ffa <vector179>:
.globl vector179
vector179:
pushl $0
80105ffa: 6a 00 push $0x0
pushl $179
80105ffc: 68 b3 00 00 00 push $0xb3
jmp alltraps
80106001: e9 07 f4 ff ff jmp 8010540d <alltraps>
80106006 <vector180>:
.globl vector180
vector180:
pushl $0
80106006: 6a 00 push $0x0
pushl $180
80106008: 68 b4 00 00 00 push $0xb4
jmp alltraps
8010600d: e9 fb f3 ff ff jmp 8010540d <alltraps>
80106012 <vector181>:
.globl vector181
vector181:
pushl $0
80106012: 6a 00 push $0x0
pushl $181
80106014: 68 b5 00 00 00 push $0xb5
jmp alltraps
80106019: e9 ef f3 ff ff jmp 8010540d <alltraps>
8010601e <vector182>:
.globl vector182
vector182:
pushl $0
8010601e: 6a 00 push $0x0
pushl $182
80106020: 68 b6 00 00 00 push $0xb6
jmp alltraps
80106025: e9 e3 f3 ff ff jmp 8010540d <alltraps>
8010602a <vector183>:
.globl vector183
vector183:
pushl $0
8010602a: 6a 00 push $0x0
pushl $183
8010602c: 68 b7 00 00 00 push $0xb7
jmp alltraps
80106031: e9 d7 f3 ff ff jmp 8010540d <alltraps>
80106036 <vector184>:
.globl vector184
vector184:
pushl $0
80106036: 6a 00 push $0x0
pushl $184
80106038: 68 b8 00 00 00 push $0xb8
jmp alltraps
8010603d: e9 cb f3 ff ff jmp 8010540d <alltraps>
80106042 <vector185>:
.globl vector185
vector185:
pushl $0
80106042: 6a 00 push $0x0
pushl $185
80106044: 68 b9 00 00 00 push $0xb9
jmp alltraps
80106049: e9 bf f3 ff ff jmp 8010540d <alltraps>
8010604e <vector186>:
.globl vector186
vector186:
pushl $0
8010604e: 6a 00 push $0x0
pushl $186
80106050: 68 ba 00 00 00 push $0xba
jmp alltraps
80106055: e9 b3 f3 ff ff jmp 8010540d <alltraps>
8010605a <vector187>:
.globl vector187
vector187:
pushl $0
8010605a: 6a 00 push $0x0
pushl $187
8010605c: 68 bb 00 00 00 push $0xbb
jmp alltraps
80106061: e9 a7 f3 ff ff jmp 8010540d <alltraps>
80106066 <vector188>:
.globl vector188
vector188:
pushl $0
80106066: 6a 00 push $0x0
pushl $188
80106068: 68 bc 00 00 00 push $0xbc
jmp alltraps
8010606d: e9 9b f3 ff ff jmp 8010540d <alltraps>
80106072 <vector189>:
.globl vector189
vector189:
pushl $0
80106072: 6a 00 push $0x0
pushl $189
80106074: 68 bd 00 00 00 push $0xbd
jmp alltraps
80106079: e9 8f f3 ff ff jmp 8010540d <alltraps>
8010607e <vector190>:
.globl vector190
vector190:
pushl $0
8010607e: 6a 00 push $0x0
pushl $190
80106080: 68 be 00 00 00 push $0xbe
jmp alltraps
80106085: e9 83 f3 ff ff jmp 8010540d <alltraps>
8010608a <vector191>:
.globl vector191
vector191:
pushl $0
8010608a: 6a 00 push $0x0
pushl $191
8010608c: 68 bf 00 00 00 push $0xbf
jmp alltraps
80106091: e9 77 f3 ff ff jmp 8010540d <alltraps>
80106096 <vector192>:
.globl vector192
vector192:
pushl $0
80106096: 6a 00 push $0x0
pushl $192
80106098: 68 c0 00 00 00 push $0xc0
jmp alltraps
8010609d: e9 6b f3 ff ff jmp 8010540d <alltraps>
801060a2 <vector193>:
.globl vector193
vector193:
pushl $0
801060a2: 6a 00 push $0x0
pushl $193
801060a4: 68 c1 00 00 00 push $0xc1
jmp alltraps
801060a9: e9 5f f3 ff ff jmp 8010540d <alltraps>
801060ae <vector194>:
.globl vector194
vector194:
pushl $0
801060ae: 6a 00 push $0x0
pushl $194
801060b0: 68 c2 00 00 00 push $0xc2
jmp alltraps
801060b5: e9 53 f3 ff ff jmp 8010540d <alltraps>
801060ba <vector195>:
.globl vector195
vector195:
pushl $0
801060ba: 6a 00 push $0x0
pushl $195
801060bc: 68 c3 00 00 00 push $0xc3
jmp alltraps
801060c1: e9 47 f3 ff ff jmp 8010540d <alltraps>
801060c6 <vector196>:
.globl vector196
vector196:
pushl $0
801060c6: 6a 00 push $0x0
pushl $196
801060c8: 68 c4 00 00 00 push $0xc4
jmp alltraps
801060cd: e9 3b f3 ff ff jmp 8010540d <alltraps>
801060d2 <vector197>:
.globl vector197
vector197:
pushl $0
801060d2: 6a 00 push $0x0
pushl $197
801060d4: 68 c5 00 00 00 push $0xc5
jmp alltraps
801060d9: e9 2f f3 ff ff jmp 8010540d <alltraps>
801060de <vector198>:
.globl vector198
vector198:
pushl $0
801060de: 6a 00 push $0x0
pushl $198
801060e0: 68 c6 00 00 00 push $0xc6
jmp alltraps
801060e5: e9 23 f3 ff ff jmp 8010540d <alltraps>
801060ea <vector199>:
.globl vector199
vector199:
pushl $0
801060ea: 6a 00 push $0x0
pushl $199
801060ec: 68 c7 00 00 00 push $0xc7
jmp alltraps
801060f1: e9 17 f3 ff ff jmp 8010540d <alltraps>
801060f6 <vector200>:
.globl vector200
vector200:
pushl $0
801060f6: 6a 00 push $0x0
pushl $200
801060f8: 68 c8 00 00 00 push $0xc8
jmp alltraps
801060fd: e9 0b f3 ff ff jmp 8010540d <alltraps>
80106102 <vector201>:
.globl vector201
vector201:
pushl $0
80106102: 6a 00 push $0x0
pushl $201
80106104: 68 c9 00 00 00 push $0xc9
jmp alltraps
80106109: e9 ff f2 ff ff jmp 8010540d <alltraps>
8010610e <vector202>:
.globl vector202
vector202:
pushl $0
8010610e: 6a 00 push $0x0
pushl $202
80106110: 68 ca 00 00 00 push $0xca
jmp alltraps
80106115: e9 f3 f2 ff ff jmp 8010540d <alltraps>
8010611a <vector203>:
.globl vector203
vector203:
pushl $0
8010611a: 6a 00 push $0x0
pushl $203
8010611c: 68 cb 00 00 00 push $0xcb
jmp alltraps
80106121: e9 e7 f2 ff ff jmp 8010540d <alltraps>
80106126 <vector204>:
.globl vector204
vector204:
pushl $0
80106126: 6a 00 push $0x0
pushl $204
80106128: 68 cc 00 00 00 push $0xcc
jmp alltraps
8010612d: e9 db f2 ff ff jmp 8010540d <alltraps>
80106132 <vector205>:
.globl vector205
vector205:
pushl $0
80106132: 6a 00 push $0x0
pushl $205
80106134: 68 cd 00 00 00 push $0xcd
jmp alltraps
80106139: e9 cf f2 ff ff jmp 8010540d <alltraps>
8010613e <vector206>:
.globl vector206
vector206:
pushl $0
8010613e: 6a 00 push $0x0
pushl $206
80106140: 68 ce 00 00 00 push $0xce
jmp alltraps
80106145: e9 c3 f2 ff ff jmp 8010540d <alltraps>
8010614a <vector207>:
.globl vector207
vector207:
pushl $0
8010614a: 6a 00 push $0x0
pushl $207
8010614c: 68 cf 00 00 00 push $0xcf
jmp alltraps
80106151: e9 b7 f2 ff ff jmp 8010540d <alltraps>
80106156 <vector208>:
.globl vector208
vector208:
pushl $0
80106156: 6a 00 push $0x0
pushl $208
80106158: 68 d0 00 00 00 push $0xd0
jmp alltraps
8010615d: e9 ab f2 ff ff jmp 8010540d <alltraps>
80106162 <vector209>:
.globl vector209
vector209:
pushl $0
80106162: 6a 00 push $0x0
pushl $209
80106164: 68 d1 00 00 00 push $0xd1
jmp alltraps
80106169: e9 9f f2 ff ff jmp 8010540d <alltraps>
8010616e <vector210>:
.globl vector210
vector210:
pushl $0
8010616e: 6a 00 push $0x0
pushl $210
80106170: 68 d2 00 00 00 push $0xd2
jmp alltraps
80106175: e9 93 f2 ff ff jmp 8010540d <alltraps>
8010617a <vector211>:
.globl vector211
vector211:
pushl $0
8010617a: 6a 00 push $0x0
pushl $211
8010617c: 68 d3 00 00 00 push $0xd3
jmp alltraps
80106181: e9 87 f2 ff ff jmp 8010540d <alltraps>
80106186 <vector212>:
.globl vector212
vector212:
pushl $0
80106186: 6a 00 push $0x0
pushl $212
80106188: 68 d4 00 00 00 push $0xd4
jmp alltraps
8010618d: e9 7b f2 ff ff jmp 8010540d <alltraps>
80106192 <vector213>:
.globl vector213
vector213:
pushl $0
80106192: 6a 00 push $0x0
pushl $213
80106194: 68 d5 00 00 00 push $0xd5
jmp alltraps
80106199: e9 6f f2 ff ff jmp 8010540d <alltraps>
8010619e <vector214>:
.globl vector214
vector214:
pushl $0
8010619e: 6a 00 push $0x0
pushl $214
801061a0: 68 d6 00 00 00 push $0xd6
jmp alltraps
801061a5: e9 63 f2 ff ff jmp 8010540d <alltraps>
801061aa <vector215>:
.globl vector215
vector215:
pushl $0
801061aa: 6a 00 push $0x0
pushl $215
801061ac: 68 d7 00 00 00 push $0xd7
jmp alltraps
801061b1: e9 57 f2 ff ff jmp 8010540d <alltraps>
801061b6 <vector216>:
.globl vector216
vector216:
pushl $0
801061b6: 6a 00 push $0x0
pushl $216
801061b8: 68 d8 00 00 00 push $0xd8
jmp alltraps
801061bd: e9 4b f2 ff ff jmp 8010540d <alltraps>
801061c2 <vector217>:
.globl vector217
vector217:
pushl $0
801061c2: 6a 00 push $0x0
pushl $217
801061c4: 68 d9 00 00 00 push $0xd9
jmp alltraps
801061c9: e9 3f f2 ff ff jmp 8010540d <alltraps>
801061ce <vector218>:
.globl vector218
vector218:
pushl $0
801061ce: 6a 00 push $0x0
pushl $218
801061d0: 68 da 00 00 00 push $0xda
jmp alltraps
801061d5: e9 33 f2 ff ff jmp 8010540d <alltraps>
801061da <vector219>:
.globl vector219
vector219:
pushl $0
801061da: 6a 00 push $0x0
pushl $219
801061dc: 68 db 00 00 00 push $0xdb
jmp alltraps
801061e1: e9 27 f2 ff ff jmp 8010540d <alltraps>
801061e6 <vector220>:
.globl vector220
vector220:
pushl $0
801061e6: 6a 00 push $0x0
pushl $220
801061e8: 68 dc 00 00 00 push $0xdc
jmp alltraps
801061ed: e9 1b f2 ff ff jmp 8010540d <alltraps>
801061f2 <vector221>:
.globl vector221
vector221:
pushl $0
801061f2: 6a 00 push $0x0
pushl $221
801061f4: 68 dd 00 00 00 push $0xdd
jmp alltraps
801061f9: e9 0f f2 ff ff jmp 8010540d <alltraps>
801061fe <vector222>:
.globl vector222
vector222:
pushl $0
801061fe: 6a 00 push $0x0
pushl $222
80106200: 68 de 00 00 00 push $0xde
jmp alltraps
80106205: e9 03 f2 ff ff jmp 8010540d <alltraps>
8010620a <vector223>:
.globl vector223
vector223:
pushl $0
8010620a: 6a 00 push $0x0
pushl $223
8010620c: 68 df 00 00 00 push $0xdf
jmp alltraps
80106211: e9 f7 f1 ff ff jmp 8010540d <alltraps>
80106216 <vector224>:
.globl vector224
vector224:
pushl $0
80106216: 6a 00 push $0x0
pushl $224
80106218: 68 e0 00 00 00 push $0xe0
jmp alltraps
8010621d: e9 eb f1 ff ff jmp 8010540d <alltraps>
80106222 <vector225>:
.globl vector225
vector225:
pushl $0
80106222: 6a 00 push $0x0
pushl $225
80106224: 68 e1 00 00 00 push $0xe1
jmp alltraps
80106229: e9 df f1 ff ff jmp 8010540d <alltraps>
8010622e <vector226>:
.globl vector226
vector226:
pushl $0
8010622e: 6a 00 push $0x0
pushl $226
80106230: 68 e2 00 00 00 push $0xe2
jmp alltraps
80106235: e9 d3 f1 ff ff jmp 8010540d <alltraps>
8010623a <vector227>:
.globl vector227
vector227:
pushl $0
8010623a: 6a 00 push $0x0
pushl $227
8010623c: 68 e3 00 00 00 push $0xe3
jmp alltraps
80106241: e9 c7 f1 ff ff jmp 8010540d <alltraps>
80106246 <vector228>:
.globl vector228
vector228:
pushl $0
80106246: 6a 00 push $0x0
pushl $228
80106248: 68 e4 00 00 00 push $0xe4
jmp alltraps
8010624d: e9 bb f1 ff ff jmp 8010540d <alltraps>
80106252 <vector229>:
.globl vector229
vector229:
pushl $0
80106252: 6a 00 push $0x0
pushl $229
80106254: 68 e5 00 00 00 push $0xe5
jmp alltraps
80106259: e9 af f1 ff ff jmp 8010540d <alltraps>
8010625e <vector230>:
.globl vector230
vector230:
pushl $0
8010625e: 6a 00 push $0x0
pushl $230
80106260: 68 e6 00 00 00 push $0xe6
jmp alltraps
80106265: e9 a3 f1 ff ff jmp 8010540d <alltraps>
8010626a <vector231>:
.globl vector231
vector231:
pushl $0
8010626a: 6a 00 push $0x0
pushl $231
8010626c: 68 e7 00 00 00 push $0xe7
jmp alltraps
80106271: e9 97 f1 ff ff jmp 8010540d <alltraps>
80106276 <vector232>:
.globl vector232
vector232:
pushl $0
80106276: 6a 00 push $0x0
pushl $232
80106278: 68 e8 00 00 00 push $0xe8
jmp alltraps
8010627d: e9 8b f1 ff ff jmp 8010540d <alltraps>
80106282 <vector233>:
.globl vector233
vector233:
pushl $0
80106282: 6a 00 push $0x0
pushl $233
80106284: 68 e9 00 00 00 push $0xe9
jmp alltraps
80106289: e9 7f f1 ff ff jmp 8010540d <alltraps>
8010628e <vector234>:
.globl vector234
vector234:
pushl $0
8010628e: 6a 00 push $0x0
pushl $234
80106290: 68 ea 00 00 00 push $0xea
jmp alltraps
80106295: e9 73 f1 ff ff jmp 8010540d <alltraps>
8010629a <vector235>:
.globl vector235
vector235:
pushl $0
8010629a: 6a 00 push $0x0
pushl $235
8010629c: 68 eb 00 00 00 push $0xeb
jmp alltraps
801062a1: e9 67 f1 ff ff jmp 8010540d <alltraps>
801062a6 <vector236>:
.globl vector236
vector236:
pushl $0
801062a6: 6a 00 push $0x0
pushl $236
801062a8: 68 ec 00 00 00 push $0xec
jmp alltraps
801062ad: e9 5b f1 ff ff jmp 8010540d <alltraps>
801062b2 <vector237>:
.globl vector237
vector237:
pushl $0
801062b2: 6a 00 push $0x0
pushl $237
801062b4: 68 ed 00 00 00 push $0xed
jmp alltraps
801062b9: e9 4f f1 ff ff jmp 8010540d <alltraps>
801062be <vector238>:
.globl vector238
vector238:
pushl $0
801062be: 6a 00 push $0x0
pushl $238
801062c0: 68 ee 00 00 00 push $0xee
jmp alltraps
801062c5: e9 43 f1 ff ff jmp 8010540d <alltraps>
801062ca <vector239>:
.globl vector239
vector239:
pushl $0
801062ca: 6a 00 push $0x0
pushl $239
801062cc: 68 ef 00 00 00 push $0xef
jmp alltraps
801062d1: e9 37 f1 ff ff jmp 8010540d <alltraps>
801062d6 <vector240>:
.globl vector240
vector240:
pushl $0
801062d6: 6a 00 push $0x0
pushl $240
801062d8: 68 f0 00 00 00 push $0xf0
jmp alltraps
801062dd: e9 2b f1 ff ff jmp 8010540d <alltraps>
801062e2 <vector241>:
.globl vector241
vector241:
pushl $0
801062e2: 6a 00 push $0x0
pushl $241
801062e4: 68 f1 00 00 00 push $0xf1
jmp alltraps
801062e9: e9 1f f1 ff ff jmp 8010540d <alltraps>
801062ee <vector242>:
.globl vector242
vector242:
pushl $0
801062ee: 6a 00 push $0x0
pushl $242
801062f0: 68 f2 00 00 00 push $0xf2
jmp alltraps
801062f5: e9 13 f1 ff ff jmp 8010540d <alltraps>
801062fa <vector243>:
.globl vector243
vector243:
pushl $0
801062fa: 6a 00 push $0x0
pushl $243
801062fc: 68 f3 00 00 00 push $0xf3
jmp alltraps
80106301: e9 07 f1 ff ff jmp 8010540d <alltraps>
80106306 <vector244>:
.globl vector244
vector244:
pushl $0
80106306: 6a 00 push $0x0
pushl $244
80106308: 68 f4 00 00 00 push $0xf4
jmp alltraps
8010630d: e9 fb f0 ff ff jmp 8010540d <alltraps>
80106312 <vector245>:
.globl vector245
vector245:
pushl $0
80106312: 6a 00 push $0x0
pushl $245
80106314: 68 f5 00 00 00 push $0xf5
jmp alltraps
80106319: e9 ef f0 ff ff jmp 8010540d <alltraps>
8010631e <vector246>:
.globl vector246
vector246:
pushl $0
8010631e: 6a 00 push $0x0
pushl $246
80106320: 68 f6 00 00 00 push $0xf6
jmp alltraps
80106325: e9 e3 f0 ff ff jmp 8010540d <alltraps>
8010632a <vector247>:
.globl vector247
vector247:
pushl $0
8010632a: 6a 00 push $0x0
pushl $247
8010632c: 68 f7 00 00 00 push $0xf7
jmp alltraps
80106331: e9 d7 f0 ff ff jmp 8010540d <alltraps>
80106336 <vector248>:
.globl vector248
vector248:
pushl $0
80106336: 6a 00 push $0x0
pushl $248
80106338: 68 f8 00 00 00 push $0xf8
jmp alltraps
8010633d: e9 cb f0 ff ff jmp 8010540d <alltraps>
80106342 <vector249>:
.globl vector249
vector249:
pushl $0
80106342: 6a 00 push $0x0
pushl $249
80106344: 68 f9 00 00 00 push $0xf9
jmp alltraps
80106349: e9 bf f0 ff ff jmp 8010540d <alltraps>
8010634e <vector250>:
.globl vector250
vector250:
pushl $0
8010634e: 6a 00 push $0x0
pushl $250
80106350: 68 fa 00 00 00 push $0xfa
jmp alltraps
80106355: e9 b3 f0 ff ff jmp 8010540d <alltraps>
8010635a <vector251>:
.globl vector251
vector251:
pushl $0
8010635a: 6a 00 push $0x0
pushl $251
8010635c: 68 fb 00 00 00 push $0xfb
jmp alltraps
80106361: e9 a7 f0 ff ff jmp 8010540d <alltraps>
80106366 <vector252>:
.globl vector252
vector252:
pushl $0
80106366: 6a 00 push $0x0
pushl $252
80106368: 68 fc 00 00 00 push $0xfc
jmp alltraps
8010636d: e9 9b f0 ff ff jmp 8010540d <alltraps>
80106372 <vector253>:
.globl vector253
vector253:
pushl $0
80106372: 6a 00 push $0x0
pushl $253
80106374: 68 fd 00 00 00 push $0xfd
jmp alltraps
80106379: e9 8f f0 ff ff jmp 8010540d <alltraps>
8010637e <vector254>:
.globl vector254
vector254:
pushl $0
8010637e: 6a 00 push $0x0
pushl $254
80106380: 68 fe 00 00 00 push $0xfe
jmp alltraps
80106385: e9 83 f0 ff ff jmp 8010540d <alltraps>
8010638a <vector255>:
.globl vector255
vector255:
pushl $0
8010638a: 6a 00 push $0x0
pushl $255
8010638c: 68 ff 00 00 00 push $0xff
jmp alltraps
80106391: e9 77 f0 ff ff jmp 8010540d <alltraps>
80106396: 66 90 xchg %ax,%ax
80106398: 66 90 xchg %ax,%ax
8010639a: 66 90 xchg %ax,%ax
8010639c: 66 90 xchg %ax,%ax
8010639e: 66 90 xchg %ax,%ax
801063a0 <walkpgdir>:
// Return the address of the PTE in page table pgdir
// that corresponds to virtual address va. If alloc!=0,
// create any required page table pages.
static pte_t *
walkpgdir(pde_t *pgdir, const void *va, int alloc)
{
801063a0: 55 push %ebp
801063a1: 89 e5 mov %esp,%ebp
801063a3: 57 push %edi
801063a4: 56 push %esi
801063a5: 89 d6 mov %edx,%esi
pde_t *pde;
pte_t *pgtab;
pde = &pgdir[PDX(va)];
801063a7: c1 ea 16 shr $0x16,%edx
{
801063aa: 53 push %ebx
pde = &pgdir[PDX(va)];
801063ab: 8d 3c 90 lea (%eax,%edx,4),%edi
{
801063ae: 83 ec 1c sub $0x1c,%esp
if(*pde & PTE_P){
801063b1: 8b 1f mov (%edi),%ebx
801063b3: f6 c3 01 test $0x1,%bl
801063b6: 74 28 je 801063e0 <walkpgdir+0x40>
pgtab = (pte_t*)P2V(PTE_ADDR(*pde));
801063b8: 81 e3 00 f0 ff ff and $0xfffff000,%ebx
801063be: 81 c3 00 00 00 80 add $0x80000000,%ebx
// The permissions here are overly generous, but they can
// be further restricted by the permissions in the page table
// entries, if necessary.
*pde = V2P(pgtab) | PTE_P | PTE_W | PTE_U;
}
return &pgtab[PTX(va)];
801063c4: c1 ee 0a shr $0xa,%esi
}
801063c7: 83 c4 1c add $0x1c,%esp
return &pgtab[PTX(va)];
801063ca: 89 f2 mov %esi,%edx
801063cc: 81 e2 fc 0f 00 00 and $0xffc,%edx
801063d2: 8d 04 13 lea (%ebx,%edx,1),%eax
}
801063d5: 5b pop %ebx
801063d6: 5e pop %esi
801063d7: 5f pop %edi
801063d8: 5d pop %ebp
801063d9: c3 ret
801063da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if(!alloc || (pgtab = (pte_t*)kalloc()) == 0)
801063e0: 85 c9 test %ecx,%ecx
801063e2: 74 34 je 80106418 <walkpgdir+0x78>
801063e4: e8 a7 c0 ff ff call 80102490 <kalloc>
801063e9: 85 c0 test %eax,%eax
801063eb: 89 c3 mov %eax,%ebx
801063ed: 74 29 je 80106418 <walkpgdir+0x78>
memset(pgtab, 0, PGSIZE);
801063ef: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
801063f6: 00
801063f7: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
801063fe: 00
801063ff: 89 04 24 mov %eax,(%esp)
80106402: e8 69 de ff ff call 80104270 <memset>
*pde = V2P(pgtab) | PTE_P | PTE_W | PTE_U;
80106407: 8d 83 00 00 00 80 lea -0x80000000(%ebx),%eax
8010640d: 83 c8 07 or $0x7,%eax
80106410: 89 07 mov %eax,(%edi)
80106412: eb b0 jmp 801063c4 <walkpgdir+0x24>
80106414: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
}
80106418: 83 c4 1c add $0x1c,%esp
return 0;
8010641b: 31 c0 xor %eax,%eax
}
8010641d: 5b pop %ebx
8010641e: 5e pop %esi
8010641f: 5f pop %edi
80106420: 5d pop %ebp
80106421: c3 ret
80106422: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80106429: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80106430 <deallocuvm.part.0>:
// Deallocate user pages to bring the process size from oldsz to
// newsz. oldsz and newsz need not be page-aligned, nor does newsz
// need to be less than oldsz. oldsz can be larger than the actual
// process size. Returns the new process size.
int
deallocuvm(pde_t *pgdir, uint oldsz, uint newsz)
80106430: 55 push %ebp
80106431: 89 e5 mov %esp,%ebp
80106433: 57 push %edi
80106434: 89 c7 mov %eax,%edi
80106436: 56 push %esi
80106437: 89 d6 mov %edx,%esi
80106439: 53 push %ebx
uint a, pa;
if(newsz >= oldsz)
return oldsz;
a = PGROUNDUP(newsz);
8010643a: 8d 99 ff 0f 00 00 lea 0xfff(%ecx),%ebx
deallocuvm(pde_t *pgdir, uint oldsz, uint newsz)
80106440: 83 ec 1c sub $0x1c,%esp
a = PGROUNDUP(newsz);
80106443: 81 e3 00 f0 ff ff and $0xfffff000,%ebx
for(; a < oldsz; a += PGSIZE){
80106449: 39 d3 cmp %edx,%ebx
deallocuvm(pde_t *pgdir, uint oldsz, uint newsz)
8010644b: 89 4d e0 mov %ecx,-0x20(%ebp)
for(; a < oldsz; a += PGSIZE){
8010644e: 72 3b jb 8010648b <deallocuvm.part.0+0x5b>
80106450: eb 5e jmp 801064b0 <deallocuvm.part.0+0x80>
80106452: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
pte = walkpgdir(pgdir, (char*)a, 0);
if(!pte)
a = PGADDR(PDX(a) + 1, 0, 0) - PGSIZE;
else if((*pte & PTE_P) != 0){
80106458: 8b 10 mov (%eax),%edx
8010645a: f6 c2 01 test $0x1,%dl
8010645d: 74 22 je 80106481 <deallocuvm.part.0+0x51>
pa = PTE_ADDR(*pte);
if(pa == 0)
8010645f: 81 e2 00 f0 ff ff and $0xfffff000,%edx
80106465: 74 54 je 801064bb <deallocuvm.part.0+0x8b>
panic("kfree");
char *v = P2V(pa);
80106467: 81 c2 00 00 00 80 add $0x80000000,%edx
kfree(v);
8010646d: 89 14 24 mov %edx,(%esp)
80106470: 89 45 e4 mov %eax,-0x1c(%ebp)
80106473: e8 68 be ff ff call 801022e0 <kfree>
*pte = 0;
80106478: 8b 45 e4 mov -0x1c(%ebp),%eax
8010647b: c7 00 00 00 00 00 movl $0x0,(%eax)
for(; a < oldsz; a += PGSIZE){
80106481: 81 c3 00 10 00 00 add $0x1000,%ebx
80106487: 39 f3 cmp %esi,%ebx
80106489: 73 25 jae 801064b0 <deallocuvm.part.0+0x80>
pte = walkpgdir(pgdir, (char*)a, 0);
8010648b: 31 c9 xor %ecx,%ecx
8010648d: 89 da mov %ebx,%edx
8010648f: 89 f8 mov %edi,%eax
80106491: e8 0a ff ff ff call 801063a0 <walkpgdir>
if(!pte)
80106496: 85 c0 test %eax,%eax
80106498: 75 be jne 80106458 <deallocuvm.part.0+0x28>
a = PGADDR(PDX(a) + 1, 0, 0) - PGSIZE;
8010649a: 81 e3 00 00 c0 ff and $0xffc00000,%ebx
801064a0: 81 c3 00 f0 3f 00 add $0x3ff000,%ebx
for(; a < oldsz; a += PGSIZE){
801064a6: 81 c3 00 10 00 00 add $0x1000,%ebx
801064ac: 39 f3 cmp %esi,%ebx
801064ae: 72 db jb 8010648b <deallocuvm.part.0+0x5b>
}
}
return newsz;
}
801064b0: 8b 45 e0 mov -0x20(%ebp),%eax
801064b3: 83 c4 1c add $0x1c,%esp
801064b6: 5b pop %ebx
801064b7: 5e pop %esi
801064b8: 5f pop %edi
801064b9: 5d pop %ebp
801064ba: c3 ret
panic("kfree");
801064bb: c7 04 24 86 70 10 80 movl $0x80107086,(%esp)
801064c2: e8 99 9e ff ff call 80100360 <panic>
801064c7: 89 f6 mov %esi,%esi
801064c9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801064d0 <seginit>:
{
801064d0: 55 push %ebp
801064d1: 89 e5 mov %esp,%ebp
801064d3: 83 ec 18 sub $0x18,%esp
c = &cpus[cpuid()];
801064d6: e8 95 d1 ff ff call 80103670 <cpuid>
c->gdt[SEG_KCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, 0);
801064db: 31 c9 xor %ecx,%ecx
801064dd: ba ff ff ff ff mov $0xffffffff,%edx
c = &cpus[cpuid()];
801064e2: 69 c0 b0 00 00 00 imul $0xb0,%eax,%eax
801064e8: 05 80 27 11 80 add $0x80112780,%eax
c->gdt[SEG_KCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, 0);
801064ed: 66 89 50 78 mov %dx,0x78(%eax)
c->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0);
801064f1: ba ff ff ff ff mov $0xffffffff,%edx
lgdt(c->gdt, sizeof(c->gdt));
801064f6: 83 c0 70 add $0x70,%eax
c->gdt[SEG_KCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, 0);
801064f9: 66 89 48 0a mov %cx,0xa(%eax)
c->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0);
801064fd: 31 c9 xor %ecx,%ecx
801064ff: 66 89 50 10 mov %dx,0x10(%eax)
c->gdt[SEG_UCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, DPL_USER);
80106503: ba ff ff ff ff mov $0xffffffff,%edx
c->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0);
80106508: 66 89 48 12 mov %cx,0x12(%eax)
c->gdt[SEG_UCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, DPL_USER);
8010650c: 31 c9 xor %ecx,%ecx
8010650e: 66 89 50 18 mov %dx,0x18(%eax)
c->gdt[SEG_UDATA] = SEG(STA_W, 0, 0xffffffff, DPL_USER);
80106512: ba ff ff ff ff mov $0xffffffff,%edx
c->gdt[SEG_UCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, DPL_USER);
80106517: 66 89 48 1a mov %cx,0x1a(%eax)
c->gdt[SEG_UDATA] = SEG(STA_W, 0, 0xffffffff, DPL_USER);
8010651b: 31 c9 xor %ecx,%ecx
c->gdt[SEG_KCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, 0);
8010651d: c6 40 0d 9a movb $0x9a,0xd(%eax)
80106521: c6 40 0e cf movb $0xcf,0xe(%eax)
c->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0);
80106525: c6 40 15 92 movb $0x92,0x15(%eax)
80106529: c6 40 16 cf movb $0xcf,0x16(%eax)
c->gdt[SEG_UCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, DPL_USER);
8010652d: c6 40 1d fa movb $0xfa,0x1d(%eax)
80106531: c6 40 1e cf movb $0xcf,0x1e(%eax)
c->gdt[SEG_UDATA] = SEG(STA_W, 0, 0xffffffff, DPL_USER);
80106535: c6 40 25 f2 movb $0xf2,0x25(%eax)
80106539: c6 40 26 cf movb $0xcf,0x26(%eax)
8010653d: 66 89 50 20 mov %dx,0x20(%eax)
pd[0] = size-1;
80106541: ba 2f 00 00 00 mov $0x2f,%edx
c->gdt[SEG_KCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, 0);
80106546: c6 40 0c 00 movb $0x0,0xc(%eax)
8010654a: c6 40 0f 00 movb $0x0,0xf(%eax)
c->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0);
8010654e: c6 40 14 00 movb $0x0,0x14(%eax)
80106552: c6 40 17 00 movb $0x0,0x17(%eax)
c->gdt[SEG_UCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, DPL_USER);
80106556: c6 40 1c 00 movb $0x0,0x1c(%eax)
8010655a: c6 40 1f 00 movb $0x0,0x1f(%eax)
c->gdt[SEG_UDATA] = SEG(STA_W, 0, 0xffffffff, DPL_USER);
8010655e: 66 89 48 22 mov %cx,0x22(%eax)
80106562: c6 40 24 00 movb $0x0,0x24(%eax)
80106566: c6 40 27 00 movb $0x0,0x27(%eax)
8010656a: 66 89 55 f2 mov %dx,-0xe(%ebp)
pd[1] = (uint)p;
8010656e: 66 89 45 f4 mov %ax,-0xc(%ebp)
pd[2] = (uint)p >> 16;
80106572: c1 e8 10 shr $0x10,%eax
80106575: 66 89 45 f6 mov %ax,-0xa(%ebp)
asm volatile("lgdt (%0)" : : "r" (pd));
80106579: 8d 45 f2 lea -0xe(%ebp),%eax
8010657c: 0f 01 10 lgdtl (%eax)
}
8010657f: c9 leave
80106580: c3 ret
80106581: eb 0d jmp 80106590 <mappages>
80106583: 90 nop
80106584: 90 nop
80106585: 90 nop
80106586: 90 nop
80106587: 90 nop
80106588: 90 nop
80106589: 90 nop
8010658a: 90 nop
8010658b: 90 nop
8010658c: 90 nop
8010658d: 90 nop
8010658e: 90 nop
8010658f: 90 nop
80106590 <mappages>:
{
80106590: 55 push %ebp
80106591: 89 e5 mov %esp,%ebp
80106593: 57 push %edi
80106594: 56 push %esi
80106595: 53 push %ebx
80106596: 83 ec 1c sub $0x1c,%esp
80106599: 8b 45 0c mov 0xc(%ebp),%eax
last = (char*)PGROUNDDOWN(((uint)va) + size - 1);
8010659c: 8b 55 10 mov 0x10(%ebp),%edx
{
8010659f: 8b 7d 14 mov 0x14(%ebp),%edi
*pte = pa | perm | PTE_P;
801065a2: 83 4d 18 01 orl $0x1,0x18(%ebp)
a = (char*)PGROUNDDOWN((uint)va);
801065a6: 89 c3 mov %eax,%ebx
801065a8: 81 e3 00 f0 ff ff and $0xfffff000,%ebx
last = (char*)PGROUNDDOWN(((uint)va) + size - 1);
801065ae: 8d 44 10 ff lea -0x1(%eax,%edx,1),%eax
801065b2: 29 df sub %ebx,%edi
801065b4: 89 45 e4 mov %eax,-0x1c(%ebp)
801065b7: 81 65 e4 00 f0 ff ff andl $0xfffff000,-0x1c(%ebp)
801065be: eb 15 jmp 801065d5 <mappages+0x45>
if(*pte & PTE_P)
801065c0: f6 00 01 testb $0x1,(%eax)
801065c3: 75 3d jne 80106602 <mappages+0x72>
*pte = pa | perm | PTE_P;
801065c5: 0b 75 18 or 0x18(%ebp),%esi
if(a == last)
801065c8: 3b 5d e4 cmp -0x1c(%ebp),%ebx
*pte = pa | perm | PTE_P;
801065cb: 89 30 mov %esi,(%eax)
if(a == last)
801065cd: 74 29 je 801065f8 <mappages+0x68>
a += PGSIZE;
801065cf: 81 c3 00 10 00 00 add $0x1000,%ebx
if((pte = walkpgdir(pgdir, a, 1)) == 0)
801065d5: 8b 45 08 mov 0x8(%ebp),%eax
801065d8: b9 01 00 00 00 mov $0x1,%ecx
801065dd: 89 da mov %ebx,%edx
801065df: 8d 34 3b lea (%ebx,%edi,1),%esi
801065e2: e8 b9 fd ff ff call 801063a0 <walkpgdir>
801065e7: 85 c0 test %eax,%eax
801065e9: 75 d5 jne 801065c0 <mappages+0x30>
}
801065eb: 83 c4 1c add $0x1c,%esp
return -1;
801065ee: b8 ff ff ff ff mov $0xffffffff,%eax
}
801065f3: 5b pop %ebx
801065f4: 5e pop %esi
801065f5: 5f pop %edi
801065f6: 5d pop %ebp
801065f7: c3 ret
801065f8: 83 c4 1c add $0x1c,%esp
return 0;
801065fb: 31 c0 xor %eax,%eax
}
801065fd: 5b pop %ebx
801065fe: 5e pop %esi
801065ff: 5f pop %edi
80106600: 5d pop %ebp
80106601: c3 ret
panic("remap");
80106602: c7 04 24 58 77 10 80 movl $0x80107758,(%esp)
80106609: e8 52 9d ff ff call 80100360 <panic>
8010660e: 66 90 xchg %ax,%ax
80106610 <switchkvm>:
lcr3(V2P(kpgdir)); // switch to the kernel page table
80106610: a1 a4 55 11 80 mov 0x801155a4,%eax
{
80106615: 55 push %ebp
80106616: 89 e5 mov %esp,%ebp
lcr3(V2P(kpgdir)); // switch to the kernel page table
80106618: 05 00 00 00 80 add $0x80000000,%eax
}
static inline void
lcr3(uint val)
{
asm volatile("movl %0,%%cr3" : : "r" (val));
8010661d: 0f 22 d8 mov %eax,%cr3
}
80106620: 5d pop %ebp
80106621: c3 ret
80106622: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80106629: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80106630 <switchuvm>:
{
80106630: 55 push %ebp
80106631: 89 e5 mov %esp,%ebp
80106633: 57 push %edi
80106634: 56 push %esi
80106635: 53 push %ebx
80106636: 83 ec 1c sub $0x1c,%esp
80106639: 8b 75 08 mov 0x8(%ebp),%esi
if(p == 0)
8010663c: 85 f6 test %esi,%esi
8010663e: 0f 84 cd 00 00 00 je 80106711 <switchuvm+0xe1>
if(p->kstack == 0)
80106644: 8b 46 0c mov 0xc(%esi),%eax
80106647: 85 c0 test %eax,%eax
80106649: 0f 84 da 00 00 00 je 80106729 <switchuvm+0xf9>
if(p->pgdir == 0)
8010664f: 8b 7e 08 mov 0x8(%esi),%edi
80106652: 85 ff test %edi,%edi
80106654: 0f 84 c3 00 00 00 je 8010671d <switchuvm+0xed>
pushcli();
8010665a: e8 91 da ff ff call 801040f0 <pushcli>
mycpu()->gdt[SEG_TSS] = SEG16(STS_T32A, &mycpu()->ts,
8010665f: e8 8c cf ff ff call 801035f0 <mycpu>
80106664: 89 c3 mov %eax,%ebx
80106666: e8 85 cf ff ff call 801035f0 <mycpu>
8010666b: 89 c7 mov %eax,%edi
8010666d: e8 7e cf ff ff call 801035f0 <mycpu>
80106672: 83 c7 08 add $0x8,%edi
80106675: 89 45 e4 mov %eax,-0x1c(%ebp)
80106678: e8 73 cf ff ff call 801035f0 <mycpu>
8010667d: 8b 4d e4 mov -0x1c(%ebp),%ecx
80106680: ba 67 00 00 00 mov $0x67,%edx
80106685: 66 89 93 98 00 00 00 mov %dx,0x98(%ebx)
8010668c: 66 89 bb 9a 00 00 00 mov %di,0x9a(%ebx)
80106693: c6 83 9d 00 00 00 99 movb $0x99,0x9d(%ebx)
8010669a: 83 c1 08 add $0x8,%ecx
8010669d: c1 e9 10 shr $0x10,%ecx
801066a0: 83 c0 08 add $0x8,%eax
801066a3: c1 e8 18 shr $0x18,%eax
801066a6: 88 8b 9c 00 00 00 mov %cl,0x9c(%ebx)
801066ac: c6 83 9e 00 00 00 40 movb $0x40,0x9e(%ebx)
801066b3: 88 83 9f 00 00 00 mov %al,0x9f(%ebx)
mycpu()->ts.iomb = (ushort) 0xFFFF;
801066b9: bb ff ff ff ff mov $0xffffffff,%ebx
mycpu()->gdt[SEG_TSS].s = 0;
801066be: e8 2d cf ff ff call 801035f0 <mycpu>
801066c3: 80 a0 9d 00 00 00 ef andb $0xef,0x9d(%eax)
mycpu()->ts.ss0 = SEG_KDATA << 3;
801066ca: e8 21 cf ff ff call 801035f0 <mycpu>
801066cf: b9 10 00 00 00 mov $0x10,%ecx
801066d4: 66 89 48 10 mov %cx,0x10(%eax)
mycpu()->ts.esp0 = (uint)p->kstack + KSTACKSIZE;
801066d8: e8 13 cf ff ff call 801035f0 <mycpu>
801066dd: 8b 56 0c mov 0xc(%esi),%edx
801066e0: 8d 8a 00 10 00 00 lea 0x1000(%edx),%ecx
801066e6: 89 48 0c mov %ecx,0xc(%eax)
mycpu()->ts.iomb = (ushort) 0xFFFF;
801066e9: e8 02 cf ff ff call 801035f0 <mycpu>
801066ee: 66 89 58 6e mov %bx,0x6e(%eax)
asm volatile("ltr %0" : : "r" (sel));
801066f2: b8 28 00 00 00 mov $0x28,%eax
801066f7: 0f 00 d8 ltr %ax
lcr3(V2P(p->pgdir)); // switch to process's address space
801066fa: 8b 46 08 mov 0x8(%esi),%eax
801066fd: 05 00 00 00 80 add $0x80000000,%eax
asm volatile("movl %0,%%cr3" : : "r" (val));
80106702: 0f 22 d8 mov %eax,%cr3
}
80106705: 83 c4 1c add $0x1c,%esp
80106708: 5b pop %ebx
80106709: 5e pop %esi
8010670a: 5f pop %edi
8010670b: 5d pop %ebp
popcli();
8010670c: e9 9f da ff ff jmp 801041b0 <popcli>
panic("switchuvm: no process");
80106711: c7 04 24 5e 77 10 80 movl $0x8010775e,(%esp)
80106718: e8 43 9c ff ff call 80100360 <panic>
panic("switchuvm: no pgdir");
8010671d: c7 04 24 89 77 10 80 movl $0x80107789,(%esp)
80106724: e8 37 9c ff ff call 80100360 <panic>
panic("switchuvm: no kstack");
80106729: c7 04 24 74 77 10 80 movl $0x80107774,(%esp)
80106730: e8 2b 9c ff ff call 80100360 <panic>
80106735: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80106739: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80106740 <inituvm>:
{
80106740: 55 push %ebp
80106741: 89 e5 mov %esp,%ebp
80106743: 57 push %edi
80106744: 56 push %esi
80106745: 53 push %ebx
80106746: 83 ec 2c sub $0x2c,%esp
80106749: 8b 75 10 mov 0x10(%ebp),%esi
8010674c: 8b 55 08 mov 0x8(%ebp),%edx
8010674f: 8b 7d 0c mov 0xc(%ebp),%edi
if(sz >= PGSIZE)
80106752: 81 fe ff 0f 00 00 cmp $0xfff,%esi
80106758: 77 64 ja 801067be <inituvm+0x7e>
8010675a: 89 55 e4 mov %edx,-0x1c(%ebp)
mem = kalloc();
8010675d: e8 2e bd ff ff call 80102490 <kalloc>
memset(mem, 0, PGSIZE);
80106762: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
80106769: 00
8010676a: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80106771: 00
80106772: 89 04 24 mov %eax,(%esp)
mem = kalloc();
80106775: 89 c3 mov %eax,%ebx
memset(mem, 0, PGSIZE);
80106777: e8 f4 da ff ff call 80104270 <memset>
mappages(pgdir, 0, PGSIZE, V2P(mem), PTE_W|PTE_U);
8010677c: 8b 55 e4 mov -0x1c(%ebp),%edx
8010677f: 8d 83 00 00 00 80 lea -0x80000000(%ebx),%eax
80106785: c7 44 24 10 06 00 00 movl $0x6,0x10(%esp)
8010678c: 00
8010678d: 89 44 24 0c mov %eax,0xc(%esp)
80106791: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
80106798: 00
80106799: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
801067a0: 00
801067a1: 89 14 24 mov %edx,(%esp)
801067a4: e8 e7 fd ff ff call 80106590 <mappages>
memmove(mem, init, sz);
801067a9: 89 75 10 mov %esi,0x10(%ebp)
801067ac: 89 7d 0c mov %edi,0xc(%ebp)
801067af: 89 5d 08 mov %ebx,0x8(%ebp)
}
801067b2: 83 c4 2c add $0x2c,%esp
801067b5: 5b pop %ebx
801067b6: 5e pop %esi
801067b7: 5f pop %edi
801067b8: 5d pop %ebp
memmove(mem, init, sz);
801067b9: e9 52 db ff ff jmp 80104310 <memmove>
panic("inituvm: more than a page");
801067be: c7 04 24 9d 77 10 80 movl $0x8010779d,(%esp)
801067c5: e8 96 9b ff ff call 80100360 <panic>
801067ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801067d0 <loaduvm>:
{
801067d0: 55 push %ebp
801067d1: 89 e5 mov %esp,%ebp
801067d3: 57 push %edi
801067d4: 56 push %esi
801067d5: 53 push %ebx
801067d6: 83 ec 1c sub $0x1c,%esp
if((uint) addr % PGSIZE != 0)
801067d9: f7 45 0c ff 0f 00 00 testl $0xfff,0xc(%ebp)
801067e0: 0f 85 98 00 00 00 jne 8010687e <loaduvm+0xae>
for(i = 0; i < sz; i += PGSIZE){
801067e6: 8b 75 18 mov 0x18(%ebp),%esi
801067e9: 31 db xor %ebx,%ebx
801067eb: 85 f6 test %esi,%esi
801067ed: 75 1a jne 80106809 <loaduvm+0x39>
801067ef: eb 77 jmp 80106868 <loaduvm+0x98>
801067f1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
801067f8: 81 c3 00 10 00 00 add $0x1000,%ebx
801067fe: 81 ee 00 10 00 00 sub $0x1000,%esi
80106804: 39 5d 18 cmp %ebx,0x18(%ebp)
80106807: 76 5f jbe 80106868 <loaduvm+0x98>
80106809: 8b 55 0c mov 0xc(%ebp),%edx
if((pte = walkpgdir(pgdir, addr+i, 0)) == 0)
8010680c: 31 c9 xor %ecx,%ecx
8010680e: 8b 45 08 mov 0x8(%ebp),%eax
80106811: 01 da add %ebx,%edx
80106813: e8 88 fb ff ff call 801063a0 <walkpgdir>
80106818: 85 c0 test %eax,%eax
8010681a: 74 56 je 80106872 <loaduvm+0xa2>
pa = PTE_ADDR(*pte);
8010681c: 8b 00 mov (%eax),%eax
n = PGSIZE;
8010681e: bf 00 10 00 00 mov $0x1000,%edi
80106823: 8b 4d 14 mov 0x14(%ebp),%ecx
pa = PTE_ADDR(*pte);
80106826: 25 00 f0 ff ff and $0xfffff000,%eax
n = PGSIZE;
8010682b: 81 fe 00 10 00 00 cmp $0x1000,%esi
80106831: 0f 42 fe cmovb %esi,%edi
if(readi(ip, P2V(pa), offset+i, n) != n)
80106834: 05 00 00 00 80 add $0x80000000,%eax
80106839: 89 44 24 04 mov %eax,0x4(%esp)
8010683d: 8b 45 10 mov 0x10(%ebp),%eax
80106840: 01 d9 add %ebx,%ecx
80106842: 89 7c 24 0c mov %edi,0xc(%esp)
80106846: 89 4c 24 08 mov %ecx,0x8(%esp)
8010684a: 89 04 24 mov %eax,(%esp)
8010684d: e8 fe b0 ff ff call 80101950 <readi>
80106852: 39 f8 cmp %edi,%eax
80106854: 74 a2 je 801067f8 <loaduvm+0x28>
}
80106856: 83 c4 1c add $0x1c,%esp
return -1;
80106859: b8 ff ff ff ff mov $0xffffffff,%eax
}
8010685e: 5b pop %ebx
8010685f: 5e pop %esi
80106860: 5f pop %edi
80106861: 5d pop %ebp
80106862: c3 ret
80106863: 90 nop
80106864: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80106868: 83 c4 1c add $0x1c,%esp
return 0;
8010686b: 31 c0 xor %eax,%eax
}
8010686d: 5b pop %ebx
8010686e: 5e pop %esi
8010686f: 5f pop %edi
80106870: 5d pop %ebp
80106871: c3 ret
panic("loaduvm: address should exist");
80106872: c7 04 24 b7 77 10 80 movl $0x801077b7,(%esp)
80106879: e8 e2 9a ff ff call 80100360 <panic>
panic("loaduvm: addr must be page aligned");
8010687e: c7 04 24 58 78 10 80 movl $0x80107858,(%esp)
80106885: e8 d6 9a ff ff call 80100360 <panic>
8010688a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80106890 <allocuvm>:
{
80106890: 55 push %ebp
80106891: 89 e5 mov %esp,%ebp
80106893: 57 push %edi
80106894: 56 push %esi
80106895: 53 push %ebx
80106896: 83 ec 2c sub $0x2c,%esp
80106899: 8b 7d 10 mov 0x10(%ebp),%edi
if(newsz >= KERNBASE)
8010689c: 85 ff test %edi,%edi
8010689e: 0f 88 8f 00 00 00 js 80106933 <allocuvm+0xa3>
if(newsz < oldsz)
801068a4: 3b 7d 0c cmp 0xc(%ebp),%edi
return oldsz;
801068a7: 8b 45 0c mov 0xc(%ebp),%eax
if(newsz < oldsz)
801068aa: 0f 82 85 00 00 00 jb 80106935 <allocuvm+0xa5>
a = PGROUNDUP(oldsz);
801068b0: 8d 98 ff 0f 00 00 lea 0xfff(%eax),%ebx
801068b6: 81 e3 00 f0 ff ff and $0xfffff000,%ebx
for(; a < newsz; a += PGSIZE){
801068bc: 39 df cmp %ebx,%edi
801068be: 77 57 ja 80106917 <allocuvm+0x87>
801068c0: eb 7e jmp 80106940 <allocuvm+0xb0>
801068c2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
memset(mem, 0, PGSIZE);
801068c8: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
801068cf: 00
801068d0: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
801068d7: 00
801068d8: 89 04 24 mov %eax,(%esp)
801068db: e8 90 d9 ff ff call 80104270 <memset>
if(mappages(pgdir, (char*)a, PGSIZE, V2P(mem), PTE_W|PTE_U) < 0){
801068e0: 8d 86 00 00 00 80 lea -0x80000000(%esi),%eax
801068e6: 89 44 24 0c mov %eax,0xc(%esp)
801068ea: 8b 45 08 mov 0x8(%ebp),%eax
801068ed: c7 44 24 10 06 00 00 movl $0x6,0x10(%esp)
801068f4: 00
801068f5: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
801068fc: 00
801068fd: 89 5c 24 04 mov %ebx,0x4(%esp)
80106901: 89 04 24 mov %eax,(%esp)
80106904: e8 87 fc ff ff call 80106590 <mappages>
80106909: 85 c0 test %eax,%eax
8010690b: 78 43 js 80106950 <allocuvm+0xc0>
for(; a < newsz; a += PGSIZE){
8010690d: 81 c3 00 10 00 00 add $0x1000,%ebx
80106913: 39 df cmp %ebx,%edi
80106915: 76 29 jbe 80106940 <allocuvm+0xb0>
mem = kalloc();
80106917: e8 74 bb ff ff call 80102490 <kalloc>
if(mem == 0){
8010691c: 85 c0 test %eax,%eax
mem = kalloc();
8010691e: 89 c6 mov %eax,%esi
if(mem == 0){
80106920: 75 a6 jne 801068c8 <allocuvm+0x38>
cprintf("allocuvm out of memory\n");
80106922: c7 04 24 d5 77 10 80 movl $0x801077d5,(%esp)
80106929: e8 22 9d ff ff call 80100650 <cprintf>
if(newsz >= oldsz)
8010692e: 3b 7d 0c cmp 0xc(%ebp),%edi
80106931: 77 47 ja 8010697a <allocuvm+0xea>
return 0;
80106933: 31 c0 xor %eax,%eax
}
80106935: 83 c4 2c add $0x2c,%esp
80106938: 5b pop %ebx
80106939: 5e pop %esi
8010693a: 5f pop %edi
8010693b: 5d pop %ebp
8010693c: c3 ret
8010693d: 8d 76 00 lea 0x0(%esi),%esi
80106940: 83 c4 2c add $0x2c,%esp
80106943: 89 f8 mov %edi,%eax
80106945: 5b pop %ebx
80106946: 5e pop %esi
80106947: 5f pop %edi
80106948: 5d pop %ebp
80106949: c3 ret
8010694a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
cprintf("allocuvm out of memory (2)\n");
80106950: c7 04 24 ed 77 10 80 movl $0x801077ed,(%esp)
80106957: e8 f4 9c ff ff call 80100650 <cprintf>
if(newsz >= oldsz)
8010695c: 3b 7d 0c cmp 0xc(%ebp),%edi
8010695f: 76 0d jbe 8010696e <allocuvm+0xde>
80106961: 8b 4d 0c mov 0xc(%ebp),%ecx
80106964: 89 fa mov %edi,%edx
80106966: 8b 45 08 mov 0x8(%ebp),%eax
80106969: e8 c2 fa ff ff call 80106430 <deallocuvm.part.0>
kfree(mem);
8010696e: 89 34 24 mov %esi,(%esp)
80106971: e8 6a b9 ff ff call 801022e0 <kfree>
return 0;
80106976: 31 c0 xor %eax,%eax
80106978: eb bb jmp 80106935 <allocuvm+0xa5>
8010697a: 8b 4d 0c mov 0xc(%ebp),%ecx
8010697d: 89 fa mov %edi,%edx
8010697f: 8b 45 08 mov 0x8(%ebp),%eax
80106982: e8 a9 fa ff ff call 80106430 <deallocuvm.part.0>
return 0;
80106987: 31 c0 xor %eax,%eax
80106989: eb aa jmp 80106935 <allocuvm+0xa5>
8010698b: 90 nop
8010698c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80106990 <deallocuvm>:
{
80106990: 55 push %ebp
80106991: 89 e5 mov %esp,%ebp
80106993: 8b 55 0c mov 0xc(%ebp),%edx
80106996: 8b 4d 10 mov 0x10(%ebp),%ecx
80106999: 8b 45 08 mov 0x8(%ebp),%eax
if(newsz >= oldsz)
8010699c: 39 d1 cmp %edx,%ecx
8010699e: 73 08 jae 801069a8 <deallocuvm+0x18>
}
801069a0: 5d pop %ebp
801069a1: e9 8a fa ff ff jmp 80106430 <deallocuvm.part.0>
801069a6: 66 90 xchg %ax,%ax
801069a8: 89 d0 mov %edx,%eax
801069aa: 5d pop %ebp
801069ab: c3 ret
801069ac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801069b0 <freevm>:
// Free a page table and all the physical memory pages
// in the user part.
void
freevm(pde_t *pgdir)
{
801069b0: 55 push %ebp
801069b1: 89 e5 mov %esp,%ebp
801069b3: 56 push %esi
801069b4: 53 push %ebx
801069b5: 83 ec 10 sub $0x10,%esp
801069b8: 8b 75 08 mov 0x8(%ebp),%esi
uint i;
if(pgdir == 0)
801069bb: 85 f6 test %esi,%esi
801069bd: 74 59 je 80106a18 <freevm+0x68>
801069bf: 31 c9 xor %ecx,%ecx
801069c1: ba 00 00 00 80 mov $0x80000000,%edx
801069c6: 89 f0 mov %esi,%eax
panic("freevm: no pgdir");
deallocuvm(pgdir, KERNBASE, 0);
for(i = 0; i < NPDENTRIES; i++){
801069c8: 31 db xor %ebx,%ebx
801069ca: e8 61 fa ff ff call 80106430 <deallocuvm.part.0>
801069cf: eb 12 jmp 801069e3 <freevm+0x33>
801069d1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
801069d8: 83 c3 01 add $0x1,%ebx
801069db: 81 fb 00 04 00 00 cmp $0x400,%ebx
801069e1: 74 27 je 80106a0a <freevm+0x5a>
if(pgdir[i] & PTE_P){
801069e3: 8b 14 9e mov (%esi,%ebx,4),%edx
801069e6: f6 c2 01 test $0x1,%dl
801069e9: 74 ed je 801069d8 <freevm+0x28>
char * v = P2V(PTE_ADDR(pgdir[i]));
801069eb: 81 e2 00 f0 ff ff and $0xfffff000,%edx
for(i = 0; i < NPDENTRIES; i++){
801069f1: 83 c3 01 add $0x1,%ebx
char * v = P2V(PTE_ADDR(pgdir[i]));
801069f4: 81 c2 00 00 00 80 add $0x80000000,%edx
kfree(v);
801069fa: 89 14 24 mov %edx,(%esp)
801069fd: e8 de b8 ff ff call 801022e0 <kfree>
for(i = 0; i < NPDENTRIES; i++){
80106a02: 81 fb 00 04 00 00 cmp $0x400,%ebx
80106a08: 75 d9 jne 801069e3 <freevm+0x33>
}
}
kfree((char*)pgdir);
80106a0a: 89 75 08 mov %esi,0x8(%ebp)
}
80106a0d: 83 c4 10 add $0x10,%esp
80106a10: 5b pop %ebx
80106a11: 5e pop %esi
80106a12: 5d pop %ebp
kfree((char*)pgdir);
80106a13: e9 c8 b8 ff ff jmp 801022e0 <kfree>
panic("freevm: no pgdir");
80106a18: c7 04 24 09 78 10 80 movl $0x80107809,(%esp)
80106a1f: e8 3c 99 ff ff call 80100360 <panic>
80106a24: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80106a2a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
80106a30 <setupkvm>:
{
80106a30: 55 push %ebp
80106a31: 89 e5 mov %esp,%ebp
80106a33: 56 push %esi
80106a34: 53 push %ebx
80106a35: 83 ec 20 sub $0x20,%esp
if((pgdir = (pde_t*)kalloc()) == 0)
80106a38: e8 53 ba ff ff call 80102490 <kalloc>
80106a3d: 85 c0 test %eax,%eax
80106a3f: 89 c6 mov %eax,%esi
80106a41: 74 75 je 80106ab8 <setupkvm+0x88>
memset(pgdir, 0, PGSIZE);
80106a43: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
80106a4a: 00
for(k = kmap; k < &kmap[NELEM(kmap)]; k++)
80106a4b: bb 20 a4 10 80 mov $0x8010a420,%ebx
memset(pgdir, 0, PGSIZE);
80106a50: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80106a57: 00
80106a58: 89 04 24 mov %eax,(%esp)
80106a5b: e8 10 d8 ff ff call 80104270 <memset>
if(mappages(pgdir, k->virt, k->phys_end - k->phys_start,
80106a60: 8b 53 0c mov 0xc(%ebx),%edx
80106a63: 8b 43 04 mov 0x4(%ebx),%eax
80106a66: 89 34 24 mov %esi,(%esp)
80106a69: 89 54 24 10 mov %edx,0x10(%esp)
80106a6d: 8b 53 08 mov 0x8(%ebx),%edx
80106a70: 89 44 24 0c mov %eax,0xc(%esp)
80106a74: 29 c2 sub %eax,%edx
80106a76: 8b 03 mov (%ebx),%eax
80106a78: 89 54 24 08 mov %edx,0x8(%esp)
80106a7c: 89 44 24 04 mov %eax,0x4(%esp)
80106a80: e8 0b fb ff ff call 80106590 <mappages>
80106a85: 85 c0 test %eax,%eax
80106a87: 78 17 js 80106aa0 <setupkvm+0x70>
for(k = kmap; k < &kmap[NELEM(kmap)]; k++)
80106a89: 83 c3 10 add $0x10,%ebx
80106a8c: 81 fb 60 a4 10 80 cmp $0x8010a460,%ebx
80106a92: 72 cc jb 80106a60 <setupkvm+0x30>
80106a94: 89 f0 mov %esi,%eax
}
80106a96: 83 c4 20 add $0x20,%esp
80106a99: 5b pop %ebx
80106a9a: 5e pop %esi
80106a9b: 5d pop %ebp
80106a9c: c3 ret
80106a9d: 8d 76 00 lea 0x0(%esi),%esi
freevm(pgdir);
80106aa0: 89 34 24 mov %esi,(%esp)
80106aa3: e8 08 ff ff ff call 801069b0 <freevm>
}
80106aa8: 83 c4 20 add $0x20,%esp
return 0;
80106aab: 31 c0 xor %eax,%eax
}
80106aad: 5b pop %ebx
80106aae: 5e pop %esi
80106aaf: 5d pop %ebp
80106ab0: c3 ret
80106ab1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
return 0;
80106ab8: 31 c0 xor %eax,%eax
80106aba: eb da jmp 80106a96 <setupkvm+0x66>
80106abc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80106ac0 <kvmalloc>:
{
80106ac0: 55 push %ebp
80106ac1: 89 e5 mov %esp,%ebp
80106ac3: 83 ec 08 sub $0x8,%esp
kpgdir = setupkvm();
80106ac6: e8 65 ff ff ff call 80106a30 <setupkvm>
80106acb: a3 a4 55 11 80 mov %eax,0x801155a4
lcr3(V2P(kpgdir)); // switch to the kernel page table
80106ad0: 05 00 00 00 80 add $0x80000000,%eax
80106ad5: 0f 22 d8 mov %eax,%cr3
}
80106ad8: c9 leave
80106ad9: c3 ret
80106ada: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80106ae0 <clearpteu>:
// Clear PTE_U on a page. Used to create an inaccessible
// page beneath the user stack.
void
clearpteu(pde_t *pgdir, char *uva)
{
80106ae0: 55 push %ebp
pte_t *pte;
pte = walkpgdir(pgdir, uva, 0);
80106ae1: 31 c9 xor %ecx,%ecx
{
80106ae3: 89 e5 mov %esp,%ebp
80106ae5: 83 ec 18 sub $0x18,%esp
pte = walkpgdir(pgdir, uva, 0);
80106ae8: 8b 55 0c mov 0xc(%ebp),%edx
80106aeb: 8b 45 08 mov 0x8(%ebp),%eax
80106aee: e8 ad f8 ff ff call 801063a0 <walkpgdir>
if(pte == 0)
80106af3: 85 c0 test %eax,%eax
80106af5: 74 05 je 80106afc <clearpteu+0x1c>
panic("clearpteu");
*pte &= ~PTE_U;
80106af7: 83 20 fb andl $0xfffffffb,(%eax)
}
80106afa: c9 leave
80106afb: c3 ret
panic("clearpteu");
80106afc: c7 04 24 1a 78 10 80 movl $0x8010781a,(%esp)
80106b03: e8 58 98 ff ff call 80100360 <panic>
80106b08: 90 nop
80106b09: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80106b10 <copyuvm>:
// Given a parent process's page table, create a copy
// of it for a child.
pde_t*
copyuvm(pde_t *pgdir, uint sz, uint sb)
{
80106b10: 55 push %ebp
80106b11: 89 e5 mov %esp,%ebp
80106b13: 57 push %edi
80106b14: 56 push %esi
80106b15: 53 push %ebx
80106b16: 83 ec 2c sub $0x2c,%esp
pde_t *d;
pte_t *pte;
uint pa, i, j, flags;
char *mem;
if((d = setupkvm()) == 0)
80106b19: e8 12 ff ff ff call 80106a30 <setupkvm>
80106b1e: 85 c0 test %eax,%eax
80106b20: 89 45 e0 mov %eax,-0x20(%ebp)
80106b23: 0f 84 6b 01 00 00 je 80106c94 <copyuvm+0x184>
return 0;
for(i = 0; i < sz; i += PGSIZE){
80106b29: 8b 55 0c mov 0xc(%ebp),%edx
80106b2c: 85 d2 test %edx,%edx
80106b2e: 0f 84 ac 00 00 00 je 80106be0 <copyuvm+0xd0>
80106b34: 31 db xor %ebx,%ebx
80106b36: eb 51 jmp 80106b89 <copyuvm+0x79>
panic("copyuvm: page not present");
pa = PTE_ADDR(*pte);
flags = PTE_FLAGS(*pte);
if((mem = kalloc()) == 0)
goto bad;
memmove(mem, (char*)P2V(pa), PGSIZE);
80106b38: 81 c7 00 00 00 80 add $0x80000000,%edi
80106b3e: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
80106b45: 00
80106b46: 89 7c 24 04 mov %edi,0x4(%esp)
80106b4a: 89 04 24 mov %eax,(%esp)
80106b4d: e8 be d7 ff ff call 80104310 <memmove>
if(mappages(d, (void*)i, PGSIZE, V2P(mem), flags) < 0)
80106b52: 8b 45 e4 mov -0x1c(%ebp),%eax
80106b55: 8d 96 00 00 00 80 lea -0x80000000(%esi),%edx
80106b5b: 89 54 24 0c mov %edx,0xc(%esp)
80106b5f: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
80106b66: 00
80106b67: 89 5c 24 04 mov %ebx,0x4(%esp)
80106b6b: 89 44 24 10 mov %eax,0x10(%esp)
80106b6f: 8b 45 e0 mov -0x20(%ebp),%eax
80106b72: 89 04 24 mov %eax,(%esp)
80106b75: e8 16 fa ff ff call 80106590 <mappages>
80106b7a: 85 c0 test %eax,%eax
80106b7c: 78 4d js 80106bcb <copyuvm+0xbb>
for(i = 0; i < sz; i += PGSIZE){
80106b7e: 81 c3 00 10 00 00 add $0x1000,%ebx
80106b84: 39 5d 0c cmp %ebx,0xc(%ebp)
80106b87: 76 57 jbe 80106be0 <copyuvm+0xd0>
if((pte = walkpgdir(pgdir, (void *) i, 0)) == 0)
80106b89: 8b 45 08 mov 0x8(%ebp),%eax
80106b8c: 31 c9 xor %ecx,%ecx
80106b8e: 89 da mov %ebx,%edx
80106b90: e8 0b f8 ff ff call 801063a0 <walkpgdir>
80106b95: 85 c0 test %eax,%eax
80106b97: 0f 84 0a 01 00 00 je 80106ca7 <copyuvm+0x197>
if(!(*pte & PTE_P))
80106b9d: 8b 30 mov (%eax),%esi
80106b9f: f7 c6 01 00 00 00 test $0x1,%esi
80106ba5: 0f 84 f0 00 00 00 je 80106c9b <copyuvm+0x18b>
pa = PTE_ADDR(*pte);
80106bab: 89 f7 mov %esi,%edi
flags = PTE_FLAGS(*pte);
80106bad: 81 e6 ff 0f 00 00 and $0xfff,%esi
80106bb3: 89 75 e4 mov %esi,-0x1c(%ebp)
pa = PTE_ADDR(*pte);
80106bb6: 81 e7 00 f0 ff ff and $0xfffff000,%edi
if((mem = kalloc()) == 0)
80106bbc: e8 cf b8 ff ff call 80102490 <kalloc>
80106bc1: 85 c0 test %eax,%eax
80106bc3: 89 c6 mov %eax,%esi
80106bc5: 0f 85 6d ff ff ff jne 80106b38 <copyuvm+0x28>
}
return d;
bad:
freevm(d);
80106bcb: 8b 45 e0 mov -0x20(%ebp),%eax
80106bce: 89 04 24 mov %eax,(%esp)
80106bd1: e8 da fd ff ff call 801069b0 <freevm>
return 0;
80106bd6: 31 c0 xor %eax,%eax
}
80106bd8: 83 c4 2c add $0x2c,%esp
80106bdb: 5b pop %ebx
80106bdc: 5e pop %esi
80106bdd: 5f pop %edi
80106bde: 5d pop %ebp
80106bdf: c3 ret
for (j = USERSTACKTOP - PGSIZE + 1; sb > 0; sb--, j -= PGSIZE){
80106be0: 8b 45 10 mov 0x10(%ebp),%eax
80106be3: 85 c0 test %eax,%eax
80106be5: 0f 84 9e 00 00 00 je 80106c89 <copyuvm+0x179>
80106beb: bb 00 f0 ff 7f mov $0x7ffff000,%ebx
80106bf0: eb 58 jmp 80106c4a <copyuvm+0x13a>
80106bf2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
memmove(mem, (char*)P2V(pa), PGSIZE);
80106bf8: 81 c7 00 00 00 80 add $0x80000000,%edi
80106bfe: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
80106c05: 00
80106c06: 89 7c 24 04 mov %edi,0x4(%esp)
80106c0a: 89 04 24 mov %eax,(%esp)
80106c0d: e8 fe d6 ff ff call 80104310 <memmove>
if(mappages(d, (void*)j, PGSIZE, V2P(mem), flags) < 0)
80106c12: 8b 45 e4 mov -0x1c(%ebp),%eax
80106c15: 8d 96 00 00 00 80 lea -0x80000000(%esi),%edx
80106c1b: 89 54 24 0c mov %edx,0xc(%esp)
80106c1f: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
80106c26: 00
80106c27: 89 5c 24 04 mov %ebx,0x4(%esp)
80106c2b: 89 44 24 10 mov %eax,0x10(%esp)
80106c2f: 8b 45 e0 mov -0x20(%ebp),%eax
80106c32: 89 04 24 mov %eax,(%esp)
80106c35: e8 56 f9 ff ff call 80106590 <mappages>
80106c3a: 85 c0 test %eax,%eax
80106c3c: 78 8d js 80106bcb <copyuvm+0xbb>
for (j = USERSTACKTOP - PGSIZE + 1; sb > 0; sb--, j -= PGSIZE){
80106c3e: 81 eb 00 10 00 00 sub $0x1000,%ebx
80106c44: 83 6d 10 01 subl $0x1,0x10(%ebp)
80106c48: 74 3f je 80106c89 <copyuvm+0x179>
if((pte = walkpgdir(pgdir, (void *) j, 0)) == 0)
80106c4a: 8b 45 08 mov 0x8(%ebp),%eax
80106c4d: 31 c9 xor %ecx,%ecx
80106c4f: 89 da mov %ebx,%edx
80106c51: e8 4a f7 ff ff call 801063a0 <walkpgdir>
80106c56: 85 c0 test %eax,%eax
80106c58: 74 4d je 80106ca7 <copyuvm+0x197>
if(!(*pte & PTE_P))
80106c5a: 8b 30 mov (%eax),%esi
80106c5c: f7 c6 01 00 00 00 test $0x1,%esi
80106c62: 74 37 je 80106c9b <copyuvm+0x18b>
pa = PTE_ADDR(*pte);
80106c64: 89 f7 mov %esi,%edi
flags = PTE_FLAGS(*pte);
80106c66: 81 e6 ff 0f 00 00 and $0xfff,%esi
80106c6c: 89 75 e4 mov %esi,-0x1c(%ebp)
pa = PTE_ADDR(*pte);
80106c6f: 81 e7 00 f0 ff ff and $0xfffff000,%edi
if((mem = kalloc()) == 0)
80106c75: e8 16 b8 ff ff call 80102490 <kalloc>
80106c7a: 85 c0 test %eax,%eax
80106c7c: 89 c6 mov %eax,%esi
80106c7e: 0f 85 74 ff ff ff jne 80106bf8 <copyuvm+0xe8>
80106c84: e9 42 ff ff ff jmp 80106bcb <copyuvm+0xbb>
80106c89: 8b 45 e0 mov -0x20(%ebp),%eax
}
80106c8c: 83 c4 2c add $0x2c,%esp
80106c8f: 5b pop %ebx
80106c90: 5e pop %esi
80106c91: 5f pop %edi
80106c92: 5d pop %ebp
80106c93: c3 ret
return 0;
80106c94: 31 c0 xor %eax,%eax
80106c96: e9 3d ff ff ff jmp 80106bd8 <copyuvm+0xc8>
panic("copyuvm: page not present");
80106c9b: c7 04 24 3e 78 10 80 movl $0x8010783e,(%esp)
80106ca2: e8 b9 96 ff ff call 80100360 <panic>
panic("copyuvm: pte should exist");
80106ca7: c7 04 24 24 78 10 80 movl $0x80107824,(%esp)
80106cae: e8 ad 96 ff ff call 80100360 <panic>
80106cb3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80106cb9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80106cc0 <uva2ka>:
//PAGEBREAK!
// Map user virtual address to kernel address.
char*
uva2ka(pde_t *pgdir, char *uva)
{
80106cc0: 55 push %ebp
pte_t *pte;
pte = walkpgdir(pgdir, uva, 0);
80106cc1: 31 c9 xor %ecx,%ecx
{
80106cc3: 89 e5 mov %esp,%ebp
80106cc5: 83 ec 08 sub $0x8,%esp
pte = walkpgdir(pgdir, uva, 0);
80106cc8: 8b 55 0c mov 0xc(%ebp),%edx
80106ccb: 8b 45 08 mov 0x8(%ebp),%eax
80106cce: e8 cd f6 ff ff call 801063a0 <walkpgdir>
if((*pte & PTE_P) == 0)
80106cd3: 8b 00 mov (%eax),%eax
80106cd5: 89 c2 mov %eax,%edx
80106cd7: 83 e2 05 and $0x5,%edx
return 0;
if((*pte & PTE_U) == 0)
80106cda: 83 fa 05 cmp $0x5,%edx
80106cdd: 75 11 jne 80106cf0 <uva2ka+0x30>
return 0;
return (char*)P2V(PTE_ADDR(*pte));
80106cdf: 25 00 f0 ff ff and $0xfffff000,%eax
80106ce4: 05 00 00 00 80 add $0x80000000,%eax
}
80106ce9: c9 leave
80106cea: c3 ret
80106ceb: 90 nop
80106cec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return 0;
80106cf0: 31 c0 xor %eax,%eax
}
80106cf2: c9 leave
80106cf3: c3 ret
80106cf4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80106cfa: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
80106d00 <copyout>:
// Copy len bytes from p to user address va in page table pgdir.
// Most useful when pgdir is not the current page table.
// uva2ka ensures this only works for PTE_U pages.
int
copyout(pde_t *pgdir, uint va, void *p, uint len)
{
80106d00: 55 push %ebp
80106d01: 89 e5 mov %esp,%ebp
80106d03: 57 push %edi
80106d04: 56 push %esi
80106d05: 53 push %ebx
80106d06: 83 ec 1c sub $0x1c,%esp
80106d09: 8b 5d 14 mov 0x14(%ebp),%ebx
80106d0c: 8b 4d 0c mov 0xc(%ebp),%ecx
80106d0f: 8b 7d 10 mov 0x10(%ebp),%edi
char *buf, *pa0;
uint n, va0;
buf = (char*)p;
while(len > 0){
80106d12: 85 db test %ebx,%ebx
80106d14: 75 3a jne 80106d50 <copyout+0x50>
80106d16: eb 68 jmp 80106d80 <copyout+0x80>
va0 = (uint)PGROUNDDOWN(va);
pa0 = uva2ka(pgdir, (char*)va0);
if(pa0 == 0)
return -1;
n = PGSIZE - (va - va0);
80106d18: 8b 4d e4 mov -0x1c(%ebp),%ecx
80106d1b: 89 f2 mov %esi,%edx
if(n > len)
n = len;
memmove(pa0 + (va - va0), buf, n);
80106d1d: 89 7c 24 04 mov %edi,0x4(%esp)
n = PGSIZE - (va - va0);
80106d21: 29 ca sub %ecx,%edx
80106d23: 81 c2 00 10 00 00 add $0x1000,%edx
80106d29: 39 da cmp %ebx,%edx
80106d2b: 0f 47 d3 cmova %ebx,%edx
memmove(pa0 + (va - va0), buf, n);
80106d2e: 29 f1 sub %esi,%ecx
80106d30: 01 c8 add %ecx,%eax
80106d32: 89 54 24 08 mov %edx,0x8(%esp)
80106d36: 89 04 24 mov %eax,(%esp)
80106d39: 89 55 e4 mov %edx,-0x1c(%ebp)
80106d3c: e8 cf d5 ff ff call 80104310 <memmove>
len -= n;
buf += n;
80106d41: 8b 55 e4 mov -0x1c(%ebp),%edx
va = va0 + PGSIZE;
80106d44: 8d 8e 00 10 00 00 lea 0x1000(%esi),%ecx
buf += n;
80106d4a: 01 d7 add %edx,%edi
while(len > 0){
80106d4c: 29 d3 sub %edx,%ebx
80106d4e: 74 30 je 80106d80 <copyout+0x80>
pa0 = uva2ka(pgdir, (char*)va0);
80106d50: 8b 45 08 mov 0x8(%ebp),%eax
va0 = (uint)PGROUNDDOWN(va);
80106d53: 89 ce mov %ecx,%esi
80106d55: 81 e6 00 f0 ff ff and $0xfffff000,%esi
pa0 = uva2ka(pgdir, (char*)va0);
80106d5b: 89 74 24 04 mov %esi,0x4(%esp)
va0 = (uint)PGROUNDDOWN(va);
80106d5f: 89 4d e4 mov %ecx,-0x1c(%ebp)
pa0 = uva2ka(pgdir, (char*)va0);
80106d62: 89 04 24 mov %eax,(%esp)
80106d65: e8 56 ff ff ff call 80106cc0 <uva2ka>
if(pa0 == 0)
80106d6a: 85 c0 test %eax,%eax
80106d6c: 75 aa jne 80106d18 <copyout+0x18>
}
return 0;
}
80106d6e: 83 c4 1c add $0x1c,%esp
return -1;
80106d71: b8 ff ff ff ff mov $0xffffffff,%eax
}
80106d76: 5b pop %ebx
80106d77: 5e pop %esi
80106d78: 5f pop %edi
80106d79: 5d pop %ebp
80106d7a: c3 ret
80106d7b: 90 nop
80106d7c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80106d80: 83 c4 1c add $0x1c,%esp
return 0;
80106d83: 31 c0 xor %eax,%eax
}
80106d85: 5b pop %ebx
80106d86: 5e pop %esi
80106d87: 5f pop %edi
80106d88: 5d pop %ebp
80106d89: c3 ret
80106d8a: 66 90 xchg %ax,%ax
80106d8c: 66 90 xchg %ax,%ax
80106d8e: 66 90 xchg %ax,%ax
80106d90 <shminit>:
char *frame;
int refcnt;
} shm_pages[64];
} shm_table;
void shminit() {
80106d90: 55 push %ebp
80106d91: 89 e5 mov %esp,%ebp
80106d93: 83 ec 18 sub $0x18,%esp
int i;
initlock(&(shm_table.lock), "SHM lock");
80106d96: c7 44 24 04 7c 78 10 movl $0x8010787c,0x4(%esp)
80106d9d: 80
80106d9e: c7 04 24 c0 55 11 80 movl $0x801155c0,(%esp)
80106da5: e8 96 d2 ff ff call 80104040 <initlock>
acquire(&(shm_table.lock));
80106daa: c7 04 24 c0 55 11 80 movl $0x801155c0,(%esp)
80106db1: e8 7a d3 ff ff call 80104130 <acquire>
80106db6: b8 f4 55 11 80 mov $0x801155f4,%eax
80106dbb: 90 nop
80106dbc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for (i = 0; i< 64; i++) {
shm_table.shm_pages[i].id =0;
80106dc0: c7 00 00 00 00 00 movl $0x0,(%eax)
80106dc6: 83 c0 0c add $0xc,%eax
shm_table.shm_pages[i].frame =0;
80106dc9: c7 40 f8 00 00 00 00 movl $0x0,-0x8(%eax)
shm_table.shm_pages[i].refcnt =0;
80106dd0: c7 40 fc 00 00 00 00 movl $0x0,-0x4(%eax)
for (i = 0; i< 64; i++) {
80106dd7: 3d f4 58 11 80 cmp $0x801158f4,%eax
80106ddc: 75 e2 jne 80106dc0 <shminit+0x30>
}
release(&(shm_table.lock));
80106dde: c7 04 24 c0 55 11 80 movl $0x801155c0,(%esp)
80106de5: e8 36 d4 ff ff call 80104220 <release>
}
80106dea: c9 leave
80106deb: c3 ret
80106dec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80106df0 <shm_open>:
int shm_open(int id, char **pointer) {
80106df0: 55 push %ebp
return 0; //added to remove compiler warning -- you should decide what to return
}
80106df1: 31 c0 xor %eax,%eax
int shm_open(int id, char **pointer) {
80106df3: 89 e5 mov %esp,%ebp
}
80106df5: 5d pop %ebp
80106df6: c3 ret
80106df7: 89 f6 mov %esi,%esi
80106df9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80106e00 <shm_close>:
int shm_close(int id) {
80106e00: 55 push %ebp
return 0; //added to remove compiler warning -- you should decide what to return
}
80106e01: 31 c0 xor %eax,%eax
int shm_close(int id) {
80106e03: 89 e5 mov %esp,%ebp
}
80106e05: 5d pop %ebp
80106e06: c3 ret
|
Transynther/x86/_processed/NONE/_st_/i7-8650U_0xd2.log_2583_55.asm | ljhsiun2/medusa | 9 | 162952 | .global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r11
push %r9
push %rbp
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_UC_ht+0x16333, %r10
nop
nop
nop
nop
add %rcx, %rcx
mov $0x6162636465666768, %rbp
movq %rbp, %xmm3
vmovups %ymm3, (%r10)
nop
nop
nop
dec %rsi
lea addresses_WT_ht+0x12673, %rbx
nop
nop
nop
nop
nop
inc %rsi
movl $0x61626364, (%rbx)
nop
sub $20578, %rbp
lea addresses_UC_ht+0xd613, %rbp
nop
nop
sub %r9, %r9
movb (%rbp), %r10b
nop
nop
xor %rbp, %rbp
lea addresses_D_ht+0x9b33, %rbp
nop
nop
nop
and $59928, %r10
movw $0x6162, (%rbp)
nop
nop
nop
nop
nop
add %r9, %r9
lea addresses_UC_ht+0x1bb33, %rsi
lea addresses_UC_ht+0x15049, %rdi
clflush (%rdi)
nop
nop
nop
nop
and $21772, %r10
mov $32, %rcx
rep movsb
nop
nop
inc %r11
lea addresses_UC_ht+0x1e133, %r10
nop
nop
nop
nop
lfence
mov $0x6162636465666768, %r9
movq %r9, %xmm0
vmovups %ymm0, (%r10)
nop
nop
nop
nop
add $2509, %rbp
lea addresses_normal_ht+0x1b333, %rcx
nop
nop
nop
nop
nop
add %rbp, %rbp
mov $0x6162636465666768, %rbx
movq %rbx, %xmm5
movups %xmm5, (%rcx)
nop
nop
nop
cmp %rcx, %rcx
lea addresses_UC_ht+0xdd5b, %rsi
lea addresses_WT_ht+0x17333, %rdi
nop
nop
add %r9, %r9
mov $88, %rcx
rep movsw
nop
nop
dec %rbx
lea addresses_WC_ht+0xceff, %rsi
xor %r10, %r10
movl $0x61626364, (%rsi)
nop
nop
nop
nop
nop
xor %r11, %r11
lea addresses_D_ht+0xa0d5, %rsi
nop
nop
nop
nop
cmp %rdi, %rdi
mov $0x6162636465666768, %r11
movq %r11, (%rsi)
nop
nop
nop
nop
nop
sub %rbx, %rbx
lea addresses_D_ht+0x1eb33, %r11
clflush (%r11)
nop
nop
nop
nop
nop
add $49418, %rbx
movl $0x61626364, (%r11)
nop
nop
add %r9, %r9
lea addresses_normal_ht+0x1c00b, %r11
nop
nop
nop
nop
xor $52047, %rbp
movb (%r11), %r9b
nop
nop
nop
nop
cmp %rbx, %rbx
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %r9
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r12
push %r13
push %r14
push %r15
push %rax
push %rdi
// Load
lea addresses_normal+0x195b3, %rdi
nop
nop
nop
nop
nop
cmp $1562, %r13
mov (%rdi), %r14d
nop
nop
cmp $14898, %r10
// Store
lea addresses_A+0xe333, %r15
nop
inc %r12
movw $0x5152, (%r15)
nop
xor %r14, %r14
// Faulty Load
lea addresses_UC+0x9333, %r13
clflush (%r13)
nop
sub %r14, %r14
mov (%r13), %rdi
lea oracles, %r13
and $0xff, %rdi
shlq $12, %rdi
mov (%r13,%rdi,1), %rdi
pop %rdi
pop %rax
pop %r15
pop %r14
pop %r13
pop %r12
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_UC', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_normal', 'size': 4, 'AVXalign': False, 'NT': True, 'congruent': 7, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_A', 'size': 2, 'AVXalign': False, 'NT': False, 'congruent': 9, 'same': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_UC', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': True}}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'type': 'addresses_UC_ht', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 11, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT_ht', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 5, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_UC_ht', 'size': 1, 'AVXalign': False, 'NT': True, 'congruent': 5, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'size': 2, 'AVXalign': False, 'NT': True, 'congruent': 7, 'same': True}}
{'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 11, 'same': False}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 1, 'same': True}}
{'OP': 'STOR', 'dst': {'type': 'addresses_UC_ht', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 9, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_normal_ht', 'size': 16, 'AVXalign': False, 'NT': False, 'congruent': 11, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 3, 'same': False}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 10, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC_ht', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 2, 'same': True}}
{'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 1, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 9, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_normal_ht', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 2, 'same': False}}
{'52': 2583}
52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52
*/
|
agda-stdlib-0.9/src/Relation/Binary/StrictToNonStrict.agda | qwe2/try-agda | 1 | 271 | <reponame>qwe2/try-agda
------------------------------------------------------------------------
-- The Agda standard library
--
-- Conversion of < to ≤, along with a number of properties
------------------------------------------------------------------------
-- Possible TODO: Prove that a conversion ≤ → < → ≤ returns a
-- relation equivalent to the original one (and similarly for
-- < → ≤ → <).
open import Relation.Binary
module Relation.Binary.StrictToNonStrict
{a ℓ₁ ℓ₂} {A : Set a}
(_≈_ : Rel A ℓ₁) (_<_ : Rel A ℓ₂)
where
open import Relation.Nullary
open import Relation.Binary.Consequences
open import Function
open import Data.Product
open import Data.Sum
open import Data.Empty
------------------------------------------------------------------------
-- Conversion
-- _<_ can be turned into _≤_ as follows:
_≤_ : Rel A _
x ≤ y = (x < y) ⊎ (x ≈ y)
------------------------------------------------------------------------
-- The converted relations have certain properties
-- (if the original relations have certain other properties)
reflexive : _≈_ ⇒ _≤_
reflexive = inj₂
antisym : IsEquivalence _≈_ →
Transitive _<_ →
Irreflexive _≈_ _<_ →
Antisymmetric _≈_ _≤_
antisym eq trans irrefl = as
where
module Eq = IsEquivalence eq
as : Antisymmetric _≈_ _≤_
as (inj₂ x≈y) _ = x≈y
as (inj₁ _) (inj₂ y≈x) = Eq.sym y≈x
as (inj₁ x<y) (inj₁ y<x) =
⊥-elim (trans∧irr⟶asym {_≈_ = _≈_} Eq.refl trans irrefl x<y y<x)
trans : IsEquivalence _≈_ → _<_ Respects₂ _≈_ →
Transitive _<_ → Transitive _≤_
trans eq <-resp-≈ <-trans = tr
where
module Eq = IsEquivalence eq
tr : Transitive _≤_
tr (inj₁ x<y) (inj₁ y<z) = inj₁ $ <-trans x<y y<z
tr (inj₁ x<y) (inj₂ y≈z) = inj₁ $ proj₁ <-resp-≈ y≈z x<y
tr (inj₂ x≈y) (inj₁ y<z) = inj₁ $ proj₂ <-resp-≈ (Eq.sym x≈y) y<z
tr (inj₂ x≈y) (inj₂ y≈z) = inj₂ $ Eq.trans x≈y y≈z
≤-resp-≈ : IsEquivalence _≈_ → _<_ Respects₂ _≈_ → _≤_ Respects₂ _≈_
≤-resp-≈ eq <-resp-≈ = ((λ {_ _ _} → resp₁) , (λ {_ _ _} → resp₂))
where
module Eq = IsEquivalence eq
resp₁ : ∀ {x y' y} → y' ≈ y → x ≤ y' → x ≤ y
resp₁ y'≈y (inj₁ x<y') = inj₁ (proj₁ <-resp-≈ y'≈y x<y')
resp₁ y'≈y (inj₂ x≈y') = inj₂ (Eq.trans x≈y' y'≈y)
resp₂ : ∀ {y x' x} → x' ≈ x → x' ≤ y → x ≤ y
resp₂ x'≈x (inj₁ x'<y) = inj₁ (proj₂ <-resp-≈ x'≈x x'<y)
resp₂ x'≈x (inj₂ x'≈y) = inj₂ (Eq.trans (Eq.sym x'≈x) x'≈y)
total : Trichotomous _≈_ _<_ → Total _≤_
total <-tri x y with <-tri x y
... | tri< x<y x≉y x≯y = inj₁ (inj₁ x<y)
... | tri≈ x≮y x≈y x≯y = inj₁ (inj₂ x≈y)
... | tri> x≮y x≉y x>y = inj₂ (inj₁ x>y)
decidable : Decidable _≈_ → Decidable _<_ → Decidable _≤_
decidable ≈-dec <-dec x y with ≈-dec x y | <-dec x y
... | yes x≈y | _ = yes (inj₂ x≈y)
... | no x≉y | yes x<y = yes (inj₁ x<y)
... | no x≉y | no x≮y = no helper
where
helper : x ≤ y → ⊥
helper (inj₁ x<y) = x≮y x<y
helper (inj₂ x≈y) = x≉y x≈y
decidable' : Trichotomous _≈_ _<_ → Decidable _≤_
decidable' compare x y with compare x y
... | tri< x<y _ _ = yes (inj₁ x<y)
... | tri≈ _ x≈y _ = yes (inj₂ x≈y)
... | tri> x≮y x≉y _ = no helper
where
helper : x ≤ y → ⊥
helper (inj₁ x<y) = x≮y x<y
helper (inj₂ x≈y) = x≉y x≈y
|
source/calendar/a-calari.ads | ytomino/drake | 33 | 1766 | <gh_stars>10-100
pragma License (Unrestricted);
package Ada.Calendar.Arithmetic is
-- Arithmetic on days:
type Day_Count is range
-366 * (1 + Year_Number'Last - Year_Number'First) ..
+366 * (1 + Year_Number'Last - Year_Number'First);
subtype Leap_Seconds_Count is Integer range -2047 .. 2047;
procedure Difference (
Left, Right : Time;
Days : out Day_Count;
Seconds : out Duration;
Leap_Seconds : out Leap_Seconds_Count);
function "+" (Left : Time; Right : Day_Count) return Time;
function "+" (Left : Day_Count; Right : Time) return Time;
function "-" (Left : Time; Right : Day_Count) return Time;
function "-" (Left, Right : Time) return Day_Count;
pragma Inline ("+");
pragma Inline ("-");
end Ada.Calendar.Arithmetic;
|
Categories/Category/Monoidal/Closed/IsClosed/Pentagon.agda | Taneb/agda-categories | 0 | 15157 | <filename>Categories/Category/Monoidal/Closed/IsClosed/Pentagon.agda
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
open import Categories.Category.Monoidal
open import Categories.Category.Monoidal.Closed
module Categories.Category.Monoidal.Closed.IsClosed.Pentagon
{o ℓ e} {C : Category o ℓ e} {M : Monoidal C} (Cl : Closed M) where
open import Data.Product using (Σ; _,_)
open import Function using (_$_) renaming (_∘_ to _∙_)
open import Function.Equality as Π using (Π)
open import Categories.Category.Product
open import Categories.Category.Monoidal.Properties M
open import Categories.Morphism C
open import Categories.Morphism.Properties C
open import Categories.Morphism.Reasoning C
open import Categories.Functor renaming (id to idF)
open import Categories.Functor.Bifunctor
open import Categories.Functor.Bifunctor.Properties
open import Categories.NaturalTransformation hiding (id)
open import Categories.NaturalTransformation.Dinatural hiding (_∘ʳ_)
open import Categories.NaturalTransformation.NaturalIsomorphism as NI hiding (refl)
import Categories.Category.Closed as Cls
open Closed Cl
private
module C = Category C
open Category C
open Commutation
module ℱ = Functor
module ⊗ = Functor ⊗
α⇒ = associator.from
α⇐ = associator.to
λ⇒ = unitorˡ.from
λ⇐ = unitorˡ.to
ρ⇒ = unitorʳ.from
ρ⇐ = unitorʳ.to
open HomReasoning
open Π.Π
open adjoint renaming (unit to η; counit to ε; Ladjunct to 𝕃; Ladjunct-comm′ to 𝕃-comm′;
Ladjunct-resp-≈ to 𝕃-resp-≈)
open import Categories.Category.Monoidal.Closed.IsClosed.Identity Cl
open import Categories.Category.Monoidal.Closed.IsClosed.L Cl
-- some intermediate steps as lemmas
private
-- ⊗.F₀ (⊗.F₀ ([-,-].F₀ (u , v) , [-,-].F₀ (x , u)) , x) ⇒ v
inner : {x : Obj} (v u : Obj) → ((Functor.F₀ [ u ,-] v) ⊗₀ (Functor.F₀ [ x ,-] u) ) ⊗₀ x ⇒ v
inner {x} v u = ε.η v ∘ id ⊗₁ ε.η {x} u ∘ α⇒
VU-UY⇒VY-VU : {U V X Y : Obj} → inner {X} V U ∘ (id ⊗₁ 𝕃 (inner U Y) ∘ α⇒) ⊗₁ id ≈
inner V Y ∘ (𝕃 (inner V U) ⊗₁ id) ⊗₁ id
VU-UY⇒VY-VU {U} {V} {X} {Y} = begin
inner V U ∘ (id ⊗₁ 𝕃 (inner U Y) ∘ α⇒) ⊗₁ id ≈⟨ pushʳ $ ℱ.homomorphism (-⊗ X) ⟩
(inner V U ∘ (id ⊗₁ 𝕃 (inner U Y)) ⊗₁ id) ∘ α⇒ ⊗₁ id ≈⟨ pull-last assoc-commute-from ⟩∘⟨refl ⟩
(ε.η V ∘ id ⊗₁ ε.η U ∘ id ⊗₁ 𝕃 (inner U Y) ⊗₁ id ∘ α⇒) ∘ α⇒ ⊗₁ id ≈⟨ (∘-resp-≈ʳ $ pullˡ $ ⟺ (ℱ.homomorphism ([ U , V ]₀ ⊗-))) ⟩∘⟨refl ⟩
(ε.η V ∘ id ⊗₁ (ε.η U ∘ 𝕃 (inner U Y) ⊗₁ id) ∘ α⇒) ∘ α⇒ ⊗₁ id ≈⟨ ∘-resp-≈ˡ (⟺ assoc) ○ assoc ⟩
(ε.η V ∘ id ⊗₁ (ε.η U ∘ 𝕃 (inner U Y) ⊗₁ id)) ∘ (α⇒ ∘ α⇒ ⊗₁ id) ≈⟨ ∘-resp-≈ˡ $ ∘-resp-≈ʳ $ ℱ.F-resp-≈ ([ U , V ]₀ ⊗-) (RLadjunct≈id ○ ⟺ assoc) ⟩
(ε.η V ∘ id ⊗₁ ((ε.η U ∘ id ⊗₁ ε.η Y) ∘ α⇒)) ∘ (α⇒ ∘ α⇒ ⊗₁ id) ≈⟨ ∘-resp-≈ˡ $ ∘-resp-≈ʳ $ ℱ.homomorphism ([ U , V ]₀ ⊗-) ⟩
(ε.η V ∘ id ⊗₁ (ε.η U ∘ id ⊗₁ ε.η Y) ∘ id ⊗₁ α⇒) ∘ (α⇒ ∘ α⇒ ⊗₁ id) ≈⟨ pull-last refl ⟩
ε.η V ∘ id ⊗₁ (ε.η U ∘ id ⊗₁ ε.η Y) ∘ (id ⊗₁ α⇒ ∘ α⇒ ∘ α⇒ ⊗₁ id) ≈⟨ refl⟩∘⟨ ∘-resp-≈ (ℱ.homomorphism ([ U , V ]₀ ⊗-)) pentagon ⟩
ε.η V ∘ (id ⊗₁ ε.η U ∘ id ⊗₁ (id ⊗₁ ε.η Y)) ∘ (α⇒ ∘ α⇒) ≈⟨ ⟺ assoc ○ ⟺ assoc ⟩
((ε.η V ∘ id ⊗₁ ε.η U ∘ id ⊗₁ (id ⊗₁ ε.η Y)) ∘ α⇒) ∘ α⇒ ≈⟨ pull-last (⟺ assoc-commute-from) ⟩∘⟨refl ⟩
(ε.η V ∘ id ⊗₁ ε.η U ∘ α⇒ ∘ (id ⊗₁ id) ⊗₁ ε.η Y) ∘ α⇒ ≈⟨ assoc ○ ∘-resp-≈ʳ (∘-resp-≈ˡ (⟺ assoc)) ○ ⟺ (center refl) ⟩
(ε.η V ∘ id ⊗₁ ε.η U ∘ α⇒) ∘ (id ⊗₁ id) ⊗₁ ε.η Y ∘ α⇒ ≈⟨ ∘-resp-≈ʳ $ ∘-resp-≈ˡ $ ⊗.F-resp-≈ (⊗.identity , refl) ⟩
(ε.η V ∘ id ⊗₁ ε.η U ∘ α⇒) ∘ id ⊗₁ ε.η Y ∘ α⇒ ≈˘⟨ center⁻¹ RLadjunct≈id refl ⟩
ε.η V ∘ (𝕃 (ε.η V ∘ id ⊗₁ ε.η U ∘ α⇒) ⊗₁ id ∘ id ⊗₁ ε.η Y) ∘ α⇒ ≈⟨ ∘-resp-≈ʳ $ pushˡ (⟺ [ ⊗ ]-commute) ⟩
ε.η V ∘ id ⊗₁ ε.η Y ∘ 𝕃 (inner V U) ⊗₁ id ∘ α⇒ ≈˘⟨ refl⟩∘⟨ refl⟩∘⟨ ⊗.F-resp-≈ (refl , ⊗.identity) ⟩∘⟨refl ⟩
ε.η V ∘ id ⊗₁ ε.η Y ∘ 𝕃 (inner V U) ⊗₁ (id ⊗₁ id) ∘ α⇒ ≈˘⟨ pull-last assoc-commute-from ⟩
(inner V Y) ∘ (𝕃 (inner V U) ⊗₁ id) ⊗₁ id ∎
expand-[-,-] : {U V X Y : Obj} →
(ε.η [ X , V ]₀ ∘ id ⊗₁ ε.η [ X , U ]₀ ∘ α⇒) ∘ (L X U V ⊗₁ L X Y U) ⊗₁ id ≈
𝕃 (ε.η V ∘ id ⊗₁ ε.η Y ∘ α⇒) ∘ 𝕃 (ε.η V ∘ id ⊗₁ ε.η U ∘ α⇒) ⊗₁ id
expand-[-,-] {U} {V} {X} {Y} = begin
(inner XV XU) ∘ (L X U V ⊗₁ L X Y U) ⊗₁ id ≈⟨ pull-last assoc-commute-from ⟩
ε.η XV ∘ id ⊗₁ ε.η XU ∘ L X U V ⊗₁ L X Y U ⊗₁ id ∘ α⇒ ≈⟨ refl⟩∘⟨ pullˡ (⟺ ⊗.homomorphism ○ ⊗.F-resp-≈ (identityˡ , refl)) ⟩
ε.η XV ∘ L X U V ⊗₁ (ε.η XU ∘ L X Y U ⊗₁ id) ∘ α⇒ ≈⟨ refl⟩∘⟨ [ ⊗ ]-decompose₁ ⟩∘⟨refl ⟩
ε.η XV ∘ (L X U V ⊗₁ id ∘ id ⊗₁ (ε.η XU ∘ L X Y U ⊗₁ id)) ∘ α⇒ ≈⟨ center⁻¹ RLadjunct≈id (∘-resp-≈ˡ (ℱ.F-resp-≈ ([ U , V ]₀ ⊗-) RLadjunct≈id)) ⟩
𝕃 (inner V U) ∘ (id ⊗₁ 𝕃 (inner U Y) ∘ α⇒) ≈˘⟨ 𝕃-comm′ ⟩
𝕃 (inner V U ∘ (id ⊗₁ 𝕃 (inner U Y) ∘ α⇒) ⊗₁ id) ≈⟨ 𝕃-resp-≈ VU-UY⇒VY-VU ⟩
𝕃 (inner V Y ∘ (𝕃 (inner V U) ⊗₁ id) ⊗₁ id) ≈⟨ 𝕃-comm′ ⟩
𝕃 (inner V Y) ∘ 𝕃 (inner V U) ⊗₁ id ∎
where
XV = [ X , V ]₀
XU = [ X , U ]₀
UV = [ U , V ]₀
pentagon′ : {U V X Y : Obj} →
[ [ U , V ]₀ ⇒ [ [ Y , U ]₀ , [ [ X , Y ]₀ , [ X , V ]₀ ]₀ ]₀ ]⟨
L X U V ⇒⟨ [ [ X , U ]₀ , [ X , V ]₀ ]₀ ⟩
L [ X , Y ]₀ [ X , U ]₀ [ X , V ]₀ ⇒⟨ [ [ [ X , Y ]₀ , [ X , U ]₀ ]₀ , [ [ X , Y ]₀ , [ X , V ]₀ ]₀ ]₀ ⟩
[ L X Y U , id ]₁
≈ L Y U V ⇒⟨ [ [ Y , U ]₀ , [ Y , V ]₀ ]₀ ⟩
[ id , L X Y V ]₁
⟩
pentagon′ {U} {V} {X} {Y} = begin
[ L X Y U , id ]₁ ∘ L [ X , Y ]₀ XU XV ∘ L X U V ≈˘⟨ refl ⟩∘⟨ 𝕃-comm′ ⟩
[ L X Y U , id ]₁ ∘ 𝕃 (𝕃 (ε.η XV ∘ id ⊗₁ ε.η XU ∘ α⇒) ∘ L X U V ⊗₁ id) ≈˘⟨ pushˡ [ [-,-] ]-commute ⟩
([ id , 𝕃 (inner XV XU) ∘ L X U V ⊗₁ id ]₁ ∘ [ L X Y U , id ]₁) ∘ η.η UV ≈˘⟨ pushʳ (mate.commute₁ (L X Y U)) ⟩
[ id , 𝕃 (inner XV XU) ∘ L X U V ⊗₁ id ]₁ ∘ [ id , id ⊗₁ L X Y U ]₁ ∘ η.η UV ≈˘⟨ pushˡ (ℱ.homomorphism [ [ Y , U ]₀ ,-]) ⟩
𝕃 ((𝕃 (inner XV XU) ∘ L X U V ⊗₁ id) ∘ id ⊗₁ L X Y U) ≈˘⟨ 𝕃-resp-≈ $ pushʳ [ ⊗ ]-decompose₁ ⟩
𝕃 (𝕃 (inner XV XU) ∘ L X U V ⊗₁ L X Y U) ≈˘⟨ 𝕃-resp-≈ $ 𝕃-comm′ ⟩
𝕃 (𝕃 $ (inner XV XU) ∘ (L X U V ⊗₁ L X Y U) ⊗₁ id) ≈⟨ 𝕃-resp-≈ $ 𝕃-resp-≈ $ expand-[-,-] ⟩
𝕃 (𝕃 $ 𝕃 (inner V Y) ∘ 𝕃 (inner V U) ⊗₁ id) ≈⟨ 𝕃-resp-≈ 𝕃-comm′ ⟩
𝕃 (L X Y V ∘ 𝕃 (inner V U)) ≈⟨ pushˡ (ℱ.homomorphism [ [ Y , U ]₀ ,-]) ⟩
[ id , L X Y V ]₁ ∘ L Y U V ∎
where
XV = [ X , V ]₀
XU = [ X , U ]₀
UV = [ U , V ]₀
|
env/zx/esxdos48/page2page.asm | pjshumphreys/querycsv | 18 | 99218 | include "../common/equs.inc"
DIVMMC equ 0xe3
org 0xbce0
;---------------------------------------
; mypager2 - switch to the low bank specified in the accumulator.
; Interupts must be disabled before this function is called
mypager2:
push bc
ld c, DIVMMC ; port used for switching low rom banks
out (c), a ; do the switch
pop bc
or a ;cp 0
jr nz, divmmcExit
divmmcDisable:
push af
ld a, (0x1ffa)
cp 0xc9
jr nz, divmmcSkip
call 0x1ffa
divmmcSkip:
pop af
divmmcExit:
ret
defs 10, 0 ; 32 bytes total
;---------------------------------------------------------------------------------------------------------
;loadFromDisk2 - loads virtual pages into low banks during program startup so that they can be quickly retrieved later
loadFromDisk2: ;; 5 pages can be preloaded into low banks. unrolled for simplicity
di
call loadFromDisk3 ;4
inc de ;skip 5
inc hl
call loadFromDisk3 ;6
call loadFromDisk3 ;7
call loadFromDisk3 ;8
call loadFromDisk3 ;9
ld a, 4 ; esxdos48 startup code
jp dosload ; dosload re-enables interupts before it returns
loadFromDisk3:
push de ; de contains the virtual page number we want to load into the low bank
push hl ; (hl) contains the low bank number we obtained from calling RESI_ALLOC
;load the data into the low bank
ld a, e
call dosload ; dosload re-enables interupts before it returns back to here...
di ; ... so disable interrupts again
pop hl
push hl
ld a, (hl) ; put the low bank number into the accumulator
call mypager ; switch it in to $2000-$3fff
; copy the code to the right place
ld hl, 0xc000 ; hl = source address for ldir
ld de, 0x2000 ; de = destination address for ldir
ld bc, 8192 ; bc = number of bytes to copy for ldir
ldir
pop hl
push hl
ld a, (hl) ; put the low bank number into the accumulator
inc a
call mypager ; switch it in to $2000-$3fff
; copy the code to the right place
ld hl, 0xe000 ; hl = source address for ldir
ld de, 0x2000 ; de = destination address for ldir
ld bc, 8192 ; bc = number of bytes to copy for ldir
ldir
ld a, (basicBank) ; put the low bank number into the accumulator
call mypager ; switch it in to $2000-$3fff
pop hl
pop de
inc de
inc hl
ret
;---------------------------------------
; pad the output binary out to the proper size.
; This is needed as the code above will be replaced by the interrupt mode 2 jump table after the program has started up.
defs 0x101 - ASMPC, 0xbf
|
oeis/274/A274969.asm | neoneye/loda-programs | 11 | 90190 | <gh_stars>10-100
; A274969: Number of walks in the first quadrant starting and ending at (0,0) consisting of 3n steps taken from {E=(1, 0), D=(-1, 1), S=(0, -1)}, no S step occurring before the final E step.
; Submitted by <NAME>
; 1,1,4,21,121,728,4488,28101,177859,1134705,7283640,46981740,304253964,1976886616,12880883408,84130964709,550649378199,3610705776755,23714554702020,155979407872365,1027269675638745,6773476758296220,44709685668953760,295402076512228140,1953492865541875476,12929009327311115628,85634004801756492928,567584357534546448072,3764401756733284438728,24981782165889424128048,165880468598660158536864,1102035732974190608863269,7325046420478236144913983,48710924701961171362937847,324064766844151839190491660
mov $2,$0
mov $3,$0
mul $0,2
add $2,1
sub $1,$2
bin $1,$0
add $0,1
mul $1,2
mul $2,$3
add $2,2
mov $3,1
add $3,$0
bin $3,2
div $1,$3
mul $1,$2
mov $0,$1
div $0,4
|
oeis/123/A123490.asm | neoneye/loda-programs | 11 | 164674 | <filename>oeis/123/A123490.asm
; A123490: Triangle whose k-th column satisfies a(n) = (k+3)*a(n-1)-(k+2)*a(n-2).
; Submitted by <NAME>
; 1,2,1,4,2,1,8,5,2,1,16,14,6,2,1,32,41,22,7,2,1,64,122,86,32,8,2,1,128,365,342,157,44,9,2,1,256,1094,1366,782,260,58,10,2,1,512,3281,5462,3907,1556,401,74,11,2,1,1024,9842,21846,19532,9332,2802,586,92,12,2,1,2048,29525,87382,97657,55988,19609,4682,821,112,13,2,1,4096,88574,349526,488282,335924,137258,37450,7382,1112,134,14,2,1,8192,265721,1398102,2441407,2015540,960801,299594,66431,11112
lpb $0
add $1,1
sub $0,$1
lpe
sub $1,$0
add $0,1
mov $2,1
add $2,$0
pow $2,$1
sub $2,1
div $2,$0
mov $0,$2
add $0,1
|
StopTemplates.g4 | stop-lang/stop-templates | 3 | 2934 | grammar StopTemplates;
tokens { INDENT, DEDENT }
@lexer::members {
// A queue where extra tokens are pushed on (see the NEWLINE lexer rule).
private java.util.LinkedList<Token> tokens = new java.util.LinkedList<>();
// The stack that keeps track of the indentation level.
private java.util.Stack<Integer> indents = new java.util.Stack<>();
// The amount of opened braces, brackets and parenthesis.
private int opened = 0;
// The most recently produced token.
private Token lastToken = null;
@Override
public void emit(Token t) {
super.setToken(t);
tokens.offer(t);
}
@Override
public Token nextToken() {
// Check if the end-of-file is ahead and there are still some DEDENTS expected.
if (_input.LA(1) == EOF && !this.indents.isEmpty()) {
// Remove any trailing EOF tokens from our buffer.
for (int i = tokens.size() - 1; i >= 0; i--) {
if (tokens.get(i).getType() == EOF) {
tokens.remove(i);
}
}
// First emit an extra line break that serves as the end of the statement.
this.emit(commonToken(StopTemplatesParser.NEWLINE, "\n"));
// Now emit as much DEDENT tokens as needed.
while (!indents.isEmpty()) {
this.emit(createDedent());
indents.pop();
}
// Put the EOF back on the token stream.
this.emit(commonToken(StopTemplatesParser.EOF, "<EOF>"));
}
Token next = super.nextToken();
if (next.getChannel() == Token.DEFAULT_CHANNEL) {
// Keep track of the last token on the default channel.
this.lastToken = next;
}
return tokens.isEmpty() ? next : tokens.poll();
}
private Token createDedent() {
CommonToken dedent = commonToken(StopTemplatesParser.DEDENT, "");
dedent.setLine(this.lastToken.getLine());
return dedent;
}
private CommonToken commonToken(int type, String text) {
int stop = this.getCharIndex() - 1;
int start = text.isEmpty() ? stop : stop - text.length() + 1;
return new CommonToken(this._tokenFactorySourcePair, type, DEFAULT_TOKEN_CHANNEL, start, stop);
}
static int getIndentationCount(String spaces) {
int count = 0;
for (char ch : spaces.toCharArray()) {
switch (ch) {
case '\t':
count += 4 - (count % 4);
break;
default:
// A normal space char.
count++;
}
}
return count;
}
boolean atStartOfInput() {
return super.getCharPositionInLine() == 0 && super.getLine() == 1;
}
}
file: (NEWLINE | statement)* EOF;
statement:
(component | collection | conditional) NEWLINE nested_statements?;
nested_statements: INDENT statement+ DEDENT;
component:
COMPONENT_TYPE '(' (component_parameter (',' component_parameter)*)* ')'
;
component_parameter
: ID ':' component_parameter_value_or_collection
;
component_parameter_value_or_collection
: component_parameter_value_collection
| component_parameter_value
;
component_parameter_value_collection
: '[' (component_parameter_value (',' component_parameter_value)*)* ']'
;
component_parameter_value
: ID
| REFERENCE
| STRING_LITERAL
| NUMBER_LITERAL
| BOOL_LITERAL
;
collection:
NOT? '[' (ID | REFERENCE) ']';
conditional:
NOT? (ID | REFERENCE);
/// stringliteral ::= [stringprefix](shortstring | longstring)
/// stringprefix ::= "r" | "u" | "R" | "U" | "f" | "F"
/// | "fr" | "Fr" | "fR" | "FR" | "rf" | "rF" | "Rf" | "RF"
STRING_LITERAL
: ( SHORT_STRING | LONG_STRING )
;
NUMBER_LITERAL
: NUMBER;
BOOL_LITERAL
: 'true' | 'false';
TAB : '\t';
NOT: '!';
DOT: '.';
NUMBER
: '-'? ( '.' DIGIT+ | DIGIT+ ( '.' DIGIT* )? )
;
COMPONENT_TYPE
: UPPERCASE_LETTER ( LETTER | DIGIT )*
;
ID
: LOWERCASE_LETTER ( LETTER | DIGIT )*
;
REFERENCE
: LOWERCASE_LETTER ( LETTER | DIGIT | DOT)*;
fragment UPPERCASE_LETTER
: [A-Z]
;
fragment LOWERCASE_LETTER
: [a-z]
;
fragment LETTER
: [a-zA-Z_]
;
fragment DIGIT
: [0-9]
;
fragment SPACES
: [ \t]+
;
fragment COMMENT
: '#' ~[\r\n\f]*
;
fragment LINE_JOINING
: '\\' SPACES? ( '\r'? '\n' | '\r' | '\f')
;
SKIP_
: ( SPACES | COMMENT | LINE_JOINING ) -> skip
;
NEWLINE
: ( {atStartOfInput()}? SPACES
| ( '\r'? '\n' | '\r' | '\f' ) SPACES?
)
{
String newLine = getText().replaceAll("[^\r\n\f]+", "");
String spaces = getText().replaceAll("[\r\n\f]+", "");
int next = _input.LA(1);
if (opened > 0 || next == '\r' || next == '\n' || next == '\f' || next == '#') {
// If we're inside a list or on a blank line, ignore all indents,
// dedents and line breaks.
skip();
}
else {
emit(commonToken(NEWLINE, newLine));
int indent = getIndentationCount(spaces);
int previous = indents.isEmpty() ? 0 : indents.peek();
if (indent == previous) {
// skip indents of the same size as the present indent-size
skip();
}
else if (((indent-previous) % 4) > 0){
emit(commonToken(Token.INVALID_TYPE, spaces));
}
else if (indent > previous) {
int diff = (indent - previous) / 4;
for (int i = 0; i < diff; i++){
indents.push(indent);
emit(commonToken(StopTemplatesParser.INDENT, spaces));
}
}
else {
// Possibly emit more than 1 DEDENT token.
while(!indents.isEmpty() && indents.peek() > indent) {
this.emit(createDedent());
indents.pop();
}
}
}
}
;
/*
* fragments
*/
/// shortstring ::= "'" shortstringitem* "'" | '"' shortstringitem* '"'
/// shortstringitem ::= shortstringchar | stringescapeseq
/// shortstringchar ::= <any source character except "\" or newline or the quote>
fragment SHORT_STRING
: '\'' ( STRING_ESCAPE_SEQ | ~[\\\r\n\f'] )* '\''
| '"' ( STRING_ESCAPE_SEQ | ~[\\\r\n\f"] )* '"'
;
/// longstring ::= "'''" longstringitem* "'''" | '"""' longstringitem* '"""'
fragment LONG_STRING
: '\'\'\'' LONG_STRING_ITEM*? '\'\'\''
| '"""' LONG_STRING_ITEM*? '"""'
;
/// longstringitem ::= longstringchar | stringescapeseq
fragment LONG_STRING_ITEM
: LONG_STRING_CHAR
| STRING_ESCAPE_SEQ
;
/// longstringchar ::= <any source character except "\">
fragment LONG_STRING_CHAR
: ~'\\'
;
/// stringescapeseq ::= "\" <any source character>
fragment STRING_ESCAPE_SEQ
: '\\' .
| '\\' NEWLINE
;
|
gcc-gcc-7_3_0-release/gcc/testsuite/gnat.dg/opt51_pkg.ads | best08618/asylo | 7 | 17519 | <gh_stars>1-10
package Opt51_Pkg is
type Enum is (One, Two, Three);
end Opt51_Pkg;
|
programs/oeis/338/A338996.asm | neoneye/loda | 22 | 16462 | <gh_stars>10-100
; A338996: Numbers of squares and rectangles of all sizes in 3*n*(n+1)/2-ominoes in form of three-quarters of Aztec diamonds.
; 0,5,27,85,205,420,770,1302,2070,3135,4565,6435,8827,11830,15540,20060,25500,31977,39615,48545,58905,70840,84502,100050,117650,137475,159705,184527,212135,242730,276520
lpb $0
mov $2,$0
sub $0,1
seq $2,245301 ; a(n) = n*(7*n^2 + 15*n + 8)/6.
add $1,$2
lpe
mov $0,$1
|
base/hals/halacpi/i386/pmtimer.asm | npocmaka/Windows-Server-2003 | 17 | 84188 | <filename>base/hals/halacpi/i386/pmtimer.asm
title "ACPI Timer Functions"
;++
;
; Copyright (c) 1989 Microsoft Corporation
;
; Module Name:
;
; pmtimer.asm
;
; Abstract:
;
; This module implements the code for ACPI-related timer
; functions.
;
; Author:
;
; <NAME> (jakeo) March 28, 1997
;
; Environment:
;
; Kernel mode only.
;
; Revision History:
;
; Split from pmclock.asm due to PIIX4 bugs.
;
;--
.386p
.xlist
include hal386.inc
include callconv.inc ; calling convention macros
include mac386.inc
include i386\ix8259.inc
include i386\ixcmos.inc
include xxacpi.h
.list
extrn _HalpFixedAcpiDescTable:DWORD
extrn _HalpPiix4:byte
extrn _HalpNextMSRate:DWORD
extrn _PMTimerFreq:DWORD
if DBG
extrn _LastKQPCValue:DWORD
endif
;
; ==== Values used for ACPI Clock ====
;
_DATA SEGMENT DWORD PUBLIC 'DATA'
MSBMASK24 equ 00800000h
MSBMASK32 equ 80000000h
CurrentTimePort equ 0
TimeLow equ 4
TimeHigh2 equ 8
TimeHigh1 equ 12
MsbMask equ 16
BiasLow equ 20
BiasHigh equ 24
UpperBoundLow equ 28
UpperBoundHigh2 equ 32
UpperBoundHigh1 equ 36
public _TimerInfo
_TimerInfo dd 0,0,0,0,MSBMASK24,0,0,0,2,2
public _QueryTimer
_QueryTimer dd offset FLAT:@HalpQueryPerformanceCounter
if 0
;
; The UpperBoundTable contains the values which should be added
; to the current counter value to ensure that the upper bound is
; reasonable. Values listed here are for all the 15 possible
; timer tick lengths. The unit is "PM Timer Ticks" and the
; value corresponds to the number of ticks that will pass in
; roughly two timer ticks at this rate.
;
UpperBoundTable dd 14000 ; 1 ms
dd 28600 ; 2 ms
dd 43200 ; 3 ms
dd 57200 ; 4 ms
dd 71600 ; 5 ms
dd 86000 ; 6 ms
dd 100200 ; 7 ms
dd 114600 ; 8 ms
dd 128800 ; 9 ms
dd 143400 ; 10 ms
dd 157400 ; 11 ms
dd 171800 ; 12 ms
dd 186200 ; 13 ms
dd 200400 ; 14 ms
dd 214800 ; 15 ms
endif
if DBG
TicksPassed dd 0,0
public _TimerPerf, _TimerPerfIndex
_TimerPerf db 4096 dup(0)
RawRead0 equ 0
RawRead1 equ 4
AdjustedLow0 equ 8
AdjustedHigh0 equ 12
AdjustedLow1 equ 16
AdjustedHigh1 equ 20
TITL equ 24
TITH equ 28
UBL equ 32
UBH equ 36
ReturnedLow equ 40
ReturnedHigh equ 44
ReadCount equ 48
TickMin equ 52
TickCount equ 56
TickNewUB equ 60
TimerPerfBytes equ 64
_TimerPerfIndex dd 0
endif
_DATA ends
_TEXT$03 SEGMENT DWORD PUBLIC 'CODE'
ASSUME DS:FLAT, ES:FLAT, SS:NOTHING, FS:NOTHING, GS:NOTHING
page ,132
subttl "Query Performance Counter"
;++
;
; VOID
; HalCalibratePerformanceCounter (
; IN LONG volatile *Number,
; IN ULONGLONG NewCount
; )
;
; /*++
;
; Routine Description:
;
; This routine resets the performance counter value for the current
; processor to zero. The reset is done such that the resulting value
; is closely synchronized with other processors in the configuration.
;
; Arguments:
;
; Number - Supplies a pointer to count of the number of processors in
; the configuration.
;
; NewCount - Supplies the value to synchronize the counter too
;
; Return Value:
;
; None.
;--
cPublicProc _HalpPmTimerCalibratePerfCount, 3
cPublicFpo 3,1
push edi
mov edi, [esp+8] ; ponter to context
cmp byte ptr PCR[PcNumber], 0 ; only execute on one processor
jnz short hcp_50 ; if not boot processor, wait
mov eax, _QueryTimer ; move current counter into edx:eax
call eax
mov ecx, [esp+12] ; compute how far current count
sub ecx, eax ; is from target count
mov eax, [esp+16]
sbb eax, edx
mov _TimerInfo.BiasLow, ecx ; replace bias
mov _TimerInfo.BiasHigh, eax
hcp_50:
lock dec dword ptr [edi] ; count down
@@: YIELD
cmp dword ptr [edi], 0 ; wait for all processors to signal
jnz short @b
pop edi
stdRET _HalpPmTimerCalibratePerfCount
stdENDP _HalpPmTimerCalibratePerfCount
page ,132
subttl "Query Performance Counter"
;++
;
; LARGE_INTEGER
; FASTCALL
; HalpQueryPerformanceCounter(
; VOID
; )
;
; Routine Description:
;
; This function is a simplified form of HalpAcpiTimerQueryPerfCount
; meant to be used internally by the HAL.
;
cPublicFastCall HalpQueryPerformanceCounter,0
cPublicFpo 0, 2
push ebx
push esi
;
; Snap current times
;
kqpc10: YIELD
mov esi, _TimerInfo.TimeHigh2
mov ebx, _TimerInfo.TimeLow
cmp esi, _TimerInfo.TimeHigh1
jne short kqpc10 ; Loop until consistent copy read
mov edx, _TimerInfo.CurrentTimePort
in eax, dx
;
; See if h/w MSb matches s/w copy
;
mov ecx, _TimerInfo.MsbMask
mov edx, eax
xor edx, ebx
and edx, ecx ; Isolate MSb match or mismatch
;
; Strip high hardware bit
;
not ecx
and eax, ecx
not ecx
;
; merge low bits
;
dec ecx
not ecx
and ebx, ecx
or eax, ebx
;
; If there was a mismatch, add a tick
;
add eax, edx
adc esi, 0
mov edx, esi ; get the top-half of the return value
pop esi
pop ebx
fstRET HalpQueryPerformanceCounter
fstENDP HalpQueryPerformanceCounter
;++
;
; LARGE_INTEGER
; HalpPmTimerQueryPerfCount (
; OUT PLARGE_INTEGER PerformanceFrequency OPTIONAL
; )
;
; Routine Description:
;
; This routine returns current 64-bit performance counter and,
; optionally, the Performance Frequency.
;
; N.B. The performace counter returned by this routine is
; not necessary the value when this routine is just entered.
; The value returned is actually the counter value at any point
; between the routine is entered and is exited.
;
; Arguments:
;
; PerformanceFrequency [TOS+4] - optionally, supplies the address
; of a variable to receive the performance counter frequency.
;
; Return Value:
;
; Current value of the performance counter will be returned.
;
;--
KqpcFrequency EQU [esp+8] ; User supplied Performance Frequence
cPublicProc _HalpPmTimerQueryPerfCount, 1
.FPO (0, 1, 0, 1, 0, 0)
push esi
mov eax, _QueryTimer
call eax
if 0
;
; Check to see if the timer ever reports time moving backwards
;
@@:
mov esi, [_LastKQPCValue+8]
mov ecx, [_LastKQPCValue]
cmp esi, [_LastKQPCValue+4]
jne short @b
cmp edx, esi ; check for rollover
jl short @f
sub ecx, eax
sbb esi, edx
jng short @f
int 3
@@:
mov [_LastKQPCValue+4], edx
mov [_LastKQPCValue], eax
mov [_LastKQPCValue+8], edx
endif
;
; Apply bias to time
;
mov ecx, _TimerInfo.BiasLow
mov esi, _TimerInfo.BiasHigh
add eax, ecx
adc edx, esi
mov ecx, KqpcFrequency
or ecx, ecx
jnz short kqpc20
pop esi
stdRET _HalpPmTimerQueryPerfCount
kqpc20: mov esi, _PMTimerFreq
mov [ecx], esi ; Hertz of PM timer
mov [ecx+4], 0
pop esi
stdRET _HalpPmTimerQueryPerfCount
stdENDP _HalpPmTimerQueryPerfCount
;++
;
; VOID
; HalAcpiTimerCarry (
; VOID
; )
;
; Routine Description:
;
; This routine is called to service the PM timer carry interrupt
;
; N.B. This function is called at interrupt time and assumes the
; caller clears the interrupt
;
; Arguments:
;
; None
;
; Return Value:
;
; None
;
;--
cPublicProc _HalAcpiTimerCarry, 0
cPublicFpo 0, 1
push ebx
;
; Get current time from h/w
;
mov edx, _TimerInfo.CurrentTimePort
in eax, dx
mov ebx, eax
mov ecx, _TimerInfo.MsbMask
mov eax, _TimerInfo.TimeLow
mov edx, _TimerInfo.TimeHigh2
;
; Add one tick
;
add eax, ecx
adc edx, 0
;
; MSb of h/w should now match s/w. If not, add another tick
; to get them back in sync. (debugger might knock them
; out of sync)
;
xor ebx, eax
and ebx, ecx
add eax, ebx
adc edx, 0
;
; Store in reverse order of code which reads it
;
mov _TimerInfo.TimeHigh1, edx
mov _TimerInfo.TimeLow, eax
mov _TimerInfo.TimeHigh2, edx
pop ebx
stdRET _HalAcpiTimerCarry
stdENDP _HalAcpiTimerCarry
;++
;
; VOID
; HalAcpiBrokenPiix4TimerCarry (
; VOID
; )
;
; Routine Description:
;
; This routine does nothing. When we are using the Broken Piix4
; Code (TM), we are guaranteed to have examined the timer many times
; since the last rollover. So we don't need to do any bookkeeping
; here.
;
; N.B. This function is called at interrupt time and assumes the
; caller clears the interrupt
;
; Arguments:
;
; None
;
; Return Value:
;
; None
;
;--
cPublicProc _HalAcpiBrokenPiix4TimerCarry, 0
stdRET _HalAcpiBrokenPiix4TimerCarry
stdENDP _HalAcpiBrokenPiix4TimerCarry
_TEXT$03 ends
end
|
utils/grammar/ClickHouseParser.g4 | dcastanier/ClickHouse | 0 | 2167 | parser grammar ClickHouseParser;
options {
tokenVocab=ClickHouseLexer;
}
// эта грамматика написана по сорсам парсеров, имена правил примерно соответствуют парсерам в cpp.
// известные расхождения
// 1. скобки не обязательно сразу идут после имени функции.
// 2. многословные токены поделены на самостоятельные слова
// 3. для INSERT запроса не написана часть парсинга значений.
// 4. правило для expr переписано чтобы понизить глубину AST и сразу выходить на уровень expr - al
parse
: ( query | err ) EOF
;
query
: show_tables_query
| select_query
| insert_query
| create_query
| rename_query
| drop_query
| alter_query
| use_query
| set_query
| optimize_query
| table_properties_query
| show_processlist_query
| check_query
| kill_query_query
;
// 1. QUERIES
select_query
: select_query_main ( K_UNION K_ALL select_query_main ) *
query_outfile_step?
select_format_step?
;
select_query_main
: select_with_step?
select_select_step select_from_step?
K_FINAL? select_sample_step?
select_array_join_step? select_join_step?
select_prewhere_step? select_where_step?
select_groupby_step? select_having_step?
select_orderby_step?
select_limitby_step? select_limit_step?
select_settings_step?
;
select_with_step
: K_WITH select_expr_list
;
select_select_step
: K_SELECT K_DISTINCT? select_expr_list
;
select_from_step
: K_FROM ( full_table_name
| table_function
| subquery
) select_alias?
;
select_array_join_step
: K_LEFT? K_ARRAY K_JOIN not_empty_expression_list
;
select_sample_step
: K_SAMPLE sample_ratio (K_OFFSET sample_ratio ) ?
;
sample_ratio
: NUMERIC_LITERAL ( DIVIDE NUMERIC_LITERAL ) ?
;
select_join_step
: K_GLOBAL?
( K_ANY | K_ALL ) ( K_INNER | K_LEFT K_OUTER? | K_RIGHT K_OUTER? | K_FULL K_OUTER? ) K_JOIN select_join_right_part
( K_USING LPAREN not_empty_expression_list RPAREN
| K_USING not_empty_expression_list
// | K_ON expr на самом деле нет.
)
| K_GLOBAL? K_CROSS K_JOIN select_join_right_part
;
select_join_right_part
: identifier
| subquery
;
select_prewhere_step
: K_PREWHERE expression_with_optional_alias
;
select_where_step
: K_WHERE expression_with_optional_alias
;
select_groupby_step
: K_GROUP K_BY not_empty_expression_list ( K_WITH K_TOTALS ) ?
;
select_having_step
: K_HAVING expression_with_optional_alias
;
select_orderby_step
: K_ORDER K_BY order_by_expression_list
;
select_limit_step
: K_LIMIT NUMERIC_LITERAL ( COMMA NUMERIC_LITERAL )?
;
select_limitby_step
: K_LIMIT NUMERIC_LITERAL K_BY not_empty_expression_list
;
select_settings_step
: K_SETTINGS assignment_list
;
select_format_step
: K_FORMAT identifier
;
insert_query
: K_INSERT K_INTO full_table_name
( K_ID ASSIGN STRING_LITERAL )? // wtf?
( LPAREN column_name_list RPAREN )?
( K_VALUES LPAREN literal (COMMA literal )* RPAREN(COMMA LPAREN literal (COMMA literal )* RPAREN)* // ch тут дальше не парсит. а я написал скобки
| K_FORMAT format_name // ch тут дальше не парсит, только доедает все пробелы или один перевод строки. pushMode()
| select_query )
;
create_query
: ( K_CREATE | K_ATTACH ) K_TEMPORARY?
( K_DATABASE ( K_IF K_NOT K_EXISTS ) ? database_name
| K_TABLE ( K_IF K_NOT K_EXISTS ) ? full_table_name ( K_ON K_CLUSTER cluster_name ) ?
( LPAREN column_declaration_list RPAREN engine ( K_AS select_query ) ? // если VIEW - то есть и колонки и select.
| engine K_AS ( select_query
| full_table_name engine? // wtf
)
)
| K_MATERIALIZED? K_VIEW ( K_IF K_NOT K_EXISTS ) ? full_table_name
( LPAREN column_declaration_list RPAREN ) ? engine? K_POPULATE? K_AS select_query
)
;
rename_query
: K_RENAME K_TABLE full_table_name K_TO full_table_name ( COMMA full_table_name K_TO full_table_name )* ( K_ON K_CLUSTER cluster_name ) ?
;
drop_query
: ( K_DROP | K_DETACH )
( K_DATABASE ( K_IF K_EXISTS ) ? database_name ( K_ON K_CLUSTER cluster_name ) ?
| K_TABLE ( K_IF K_EXISTS ) ? full_table_name ( K_ON K_CLUSTER cluster_name ) ?
)
;
alter_query
: K_ALTER K_TABLE full_table_name ( K_ON K_CLUSTER cluster_name ) ?
alter_query_element ( COMMA alter_query_element ) *
;
alter_query_element
: K_ADD K_COLUMN compound_name_type_pair ( K_AFTER column_name ) ?
| K_DROP K_COLUMN column_name
| K_MODIFY K_COLUMN compound_name_type_pair
| K_ATTACH K_PARTITION partition_name
| K_DETACH K_PARTITION partition_name
| K_DROP K_PARTITION partition_name
| K_FETCH K_PARTITION partition_name K_FROM STRING_LITERAL
| K_FREEZE K_PARTITION partition_name
;
clickhouse_type
: simple_type
| T_AGGREGATE_FUNCTION LPAREN function_name ( COMMA clickhouse_type ) * RPAREN
| T_ARRAY LPAREN clickhouse_type RPAREN
| T_TUPLE LPAREN clickhouse_type ( COMMA clickhouse_type ) * RPAREN
| T_NULLABLE LPAREN clickhouse_type RPAREN
;
simple_type
: T_UINT8
| T_UINT16
| T_UINT32
| T_UINT64
| T_INT8
| T_INT16
| T_INT32
| T_INT64
| T_FLOAT32
| T_FLOAT64
| T_ENUM8 LPAREN enum_entry ( COMMA enum_entry ) * LPAREN
| T_ENUM16 LPAREN enum_entry ( COMMA enum_entry ) * LPAREN
| T_UUID
| T_DATE
| T_DATETIME
| T_STRING
| T_INTERVAL_YEAR
| T_INTERVAL_MONTH
| T_INTERVAL_WEEK
| T_INTERVAL_DAY
| T_INTERVAL_HOUR
| T_INTERVAL_MINUTE
| T_INTERVAL_SECOND
| T_NULL
| T_FIXEDSTRING LPAREN NUMERIC_LITERAL LPAREN
;
enum_entry
: STRING_LITERAL ASSIGN NUMERIC_LITERAL
;
use_query
: K_USE database_name
;
set_query
: K_SET K_GLOBAL? assignment_list
;
assignment_list
: assignment ( COMMA assignment ) *
;
assignment
: identifier ASSIGN literal
;
kill_query_query
: K_KILL K_QUERY K_WHERE expression_with_optional_alias ( K_SYNC | K_ASYNC | K_TEST )
;
optimize_query
: K_OPTIMIZE K_TABLE full_table_name ( K_PARTITION STRING_LITERAL ) ? K_FINAL?
;
table_properties_query
: ( K_EXISTS | ( K_DESCRIBE | K_DESC ) | K_SHOW K_CREATE ) K_TABLE full_table_name query_outfile_step? ( K_FORMAT format_name ) ?
;
show_tables_query
: K_SHOW ( K_DATABASES
| K_TABLES ( K_FROM database_name ) ? ( K_NOT? K_LIKE STRING_LITERAL ) ? )
query_outfile_step?
( K_FORMAT format_name ) ?
;
show_processlist_query
: K_SHOW K_PROCESSLIST query_outfile_step? ( K_FORMAT format_name ) ?
;
check_query
: K_CHECK K_TABLE full_table_name
;
// 2. QUERY ELEMENTS
full_table_name
: ( database_name DOT ) ? table_name
;
partition_name
: identifier | STRING_LITERAL
;
cluster_name
: identifier | STRING_LITERAL
;
database_name
: identifier
;
table_name
: identifier
;
format_name
: identifier
;
query_outfile_step
: K_INTO K_OUTFILE STRING_LITERAL
;
engine
: K_ENGINE ASSIGN identifier_with_optional_parameters
;
identifier_with_optional_parameters
: identifier_with_parameters
| identifier
;
identifier_with_parameters
: function
| nested_table
;
order_by_expression_list
: order_by_element ( COMMA order_by_element ) *
;
order_by_element
: expression_with_optional_alias ( K_DESC | K_DESCENDING | K_ASC | K_ASCENDING ) ? ( K_NULLS ( K_FIRST | K_LAST ) ) ? ( K_COLLATE STRING_LITERAL ) ?
;
nested_table
: identifier LPAREN name_type_pair_list RPAREN
;
name_type_pair_list
: name_type_pair ( COMMA name_type_pair ) *
;
name_type_pair
: identifier column_type
;
compound_name_type_pair
: compound_identifier column_type
;
column_declaration_list
: column_declaration ( COMMA column_declaration ) *
;
column_declaration
: column_name
( ( K_DEFAULT | K_MATERIALIZED | K_ALIAS ) expr
| column_type
)
;
column_name
: identifier
;
column_type
: clickhouse_type
;
column_name_list
: column_name ( COMMA column_name ) *
;
select_expr_list
: select_expr ( COMMA select_expr) *
;
select_expr
: expr select_alias?
;
select_alias
: K_AS? alias_name
;
alias
: K_AS alias_name
;
alias_name
: identifier
;
table_function
: function
;
subquery
: LPAREN select_query_main RPAREN
;
expression_with_optional_alias
: expr alias?
;
// EXPRESSIONS
expr
: LPAREN expr RPAREN # ExprParen
| function # ExprFunction
| K_CASE expr? ( K_WHEN expr K_THEN expr ) ( K_WHEN expr K_THEN expr ) * K_ELSE expr K_END # ExprCase
| expr DOT expr # ExprTupleElement
| expr LBRAKET expr RBRAKET # ExprArrayElement
| MINUS expr # ExprUnaryMinus
| K_CAST LPAREN expr K_AS clickhouse_type RPAREN # ExprCast
| expr ( STAR | DIVIDE | PERCENT ) expr # ExprMul
| expr ( PLUS | MINUS ) expr # ExprAdd
| expr CONCAT expr # ExprConcat
| expr K_BETWEEN expr K_AND expr # ExprBetween
| expr ( EQUALS | ASSIGN | NOT_EQUALS | NOT_EQUALS2 | LE | GE | LT | GT | K_LIKE | K_NOT K_LIKE ) expr # ExprLogical
| expr ( K_IN | K_NOT K_IN | K_GLOBAL K_IN | K_GLOBAL K_NOT K_IN ) expr # ExprIn
| expr ( K_IS K_NULL | K_IS K_NOT K_NULL ) # ExprIsNull
| K_INTERVAL expr interval_unit # ExprInterval
| K_NOT expr # ExprNot
| expr K_AND expr # ExprAnd
| expr K_OR expr # ExprOr
| expr QUESTION expr COLON expr # ExprTernary
| ( LPAREN identifier ( COMMA identifier )* RPAREN | identifier ( COMMA identifier )* ) RARROW expr # ExprLambda
| subquery # ExprSubquery
| LPAREN not_empty_expression_list RPAREN # ExprList
| array # ExprArray
| literal # ExprLiteral
| compound_identifier # ExprId
| STAR # ExprStar
| expr alias # ExprWithAlias
;
interval_unit
: K_YEAR
| K_MONTH
| K_WEEK
| K_DAY
| K_HOUR
| K_MINUTE
| K_SECOND
;
expression_list
: ( not_empty_expression_list )?
;
not_empty_expression_list
: expr ( COMMA expr )*
;
array
: LBRAKET expression_list RBRAKET
;
function
: function_name function_parameters? function_arguments
;
function_parameters
: LPAREN ( expr ( COMMA expr )* )? RPAREN
;
function_arguments
: LPAREN ( expr ( COMMA expr )* )? RPAREN
;
function_name
: identifier
;
identifier
: QUOTED_LITERAL
| IDENTIFIER
// в данном случае мы разрешаем ключевым словам выступать в качестве имен колонок или функций.
| simple_type
| keyword
;
keyword
: K_ADD
| K_AFTER
| K_ALL
| K_ALIAS
| K_ALTER
| K_AND
| K_ANY
| K_ARRAY
| K_AS
| K_ASCENDING
| K_ASC
| K_ASYNC
| K_ATTACH
| K_BETWEEN
| K_BY
| K_CASE
| K_CHECK
| K_COLUMN
| K_COLLATE
| K_CREATE
| K_CROSS
| K_DESCRIBE
| K_DESCENDING
| K_DESC
| K_DATABASE
| K_DATABASES
| K_DEFAULT
| K_DETACH
| K_DISTINCT
| K_DROP
| K_ENGINE
| K_ELSE
| K_END
| K_EXISTS
| K_FINAL
| K_FIRST
| K_FROM
| K_FORMAT
| K_FULL
| K_GLOBAL
| K_GROUP
| K_HAVING
| K_ID
| K_IF
| K_INNER
| K_INSERT
| K_INTO
| K_IN
| K_IS
| K_JOIN
| K_KILL
| K_LAST
| K_LEFT
| K_LIKE
| K_LIMIT
| K_MAIN
| K_MATERIALIZED
| K_MODIFY
| K_NOT
| K_NULL
| K_NULLS
| K_OFFSET
| K_ON
| K_OPTIMIZE
| K_ORDER
| K_OR
| K_OUTFILE
| K_PARTITION
| K_POPULATE
| K_PREWHERE
| K_PROCESSLIST
| K_QUERY
| K_RENAME
| K_RETURN
| K_RIGHT
| K_SAMPLE
| K_SELECT
| K_SET
| K_SETTINGS
| K_SHOW
| K_SYNC
| K_TABLE
| K_TABLES
| K_TEMPORARY
| K_TEST
| K_THEN
| K_TOTALS
| K_TO
| K_OUTER
| K_VALUES
| K_VIEW
| K_UNION
| K_USE
| K_USING
| K_WHEN
| K_WHERE
| K_WITH
;
compound_identifier
: identifier DOT identifier
| identifier
;
literal
: K_NULL
| NUMERIC_LITERAL
| STRING_LITERAL
;
err
: UNEXPECTED_CHAR
{
throw new RuntimeException("UNEXPECTED_CHAR=" + $UNEXPECTED_CHAR.text);
}
;
|
src/asf-validators-numbers.adb | jquorning/ada-asf | 12 | 28185 | <filename>src/asf-validators-numbers.adb
-----------------------------------------------------------------------
-- asf-validators-numbers -- ASF Number Validators
-- Copyright (C) 2011, 2012 <NAME>
-- Written by <NAME> (<EMAIL>)
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
-----------------------------------------------------------------------
with Util.Beans.Objects;
package body ASF.Validators.Numbers is
-- ------------------------------
-- Create a range validator to check that the value is between the minimum and the maximum.
-- ------------------------------
function Create_Range_Validator (Minimum : in Long_Long_Integer;
Maximum : in Long_Long_Integer) return Validator_Access is
Result : constant Range_Validator_Access := new Range_Validator;
begin
Result.Minimum := Minimum;
Result.Maximum := Maximum;
return Result.all'Access;
end Create_Range_Validator;
-- ------------------------------
-- Verify that the value is between the validator minimum and maximum
-- boundaries.
-- If some error are found, the procedure should create a <b>FacesMessage</b>
-- describing the problem and add that message to the current faces context.
-- The procedure can examine the state and modify the component tree.
-- It must raise the <b>Invalid_Value</b> exception if the value is not valid.
-- ------------------------------
procedure Validate (Valid : in Range_Validator;
Context : in out ASF.Contexts.Faces.Faces_Context'Class;
Component : in out ASF.Components.Base.UIComponent'Class;
Value : in EL.Objects.Object) is
begin
if EL.Objects.Is_Null (Value) then
return;
end if;
declare
N : constant Long_Long_Integer := EL.Objects.To_Long_Long_Integer (Value);
begin
if N > Valid.Maximum then
Component.Add_Message (Name => ASF.Components.VALIDATOR_MESSAGE_NAME,
Default => MAXIMUM_MESSAGE_ID,
Arg1 => Util.Beans.Objects.To_Object (Valid.Maximum),
Arg2 => Component.Get_Label (Context),
Context => Context);
raise Invalid_Value;
end if;
if N < Valid.Minimum then
Component.Add_Message (Name => ASF.Components.VALIDATOR_MESSAGE_NAME,
Default => MINIMUM_MESSAGE_ID,
Arg1 => Util.Beans.Objects.To_Object (Valid.Minimum),
Arg2 => Component.Get_Label (Context),
Context => Context);
raise Invalid_Value;
end if;
end;
exception
when others =>
Component.Add_Message (Name => ASF.Components.VALIDATOR_MESSAGE_NAME,
Default => TYPE_MESSAGE_ID,
Arg1 => Util.Beans.Objects.To_Object (Valid.Minimum),
Arg2 => Component.Get_Label (Context),
Context => Context);
raise Invalid_Value;
end Validate;
end ASF.Validators.Numbers;
|
src/gnat/sinfo.adb | My-Colaborations/dynamo | 15 | 3761 | ------------------------------------------------------------------------------
-- --
-- GNAT COMPILER COMPONENTS --
-- --
-- S I N F O --
-- --
-- B o d y --
-- --
-- Copyright (C) 1992-2014, Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
-- ware Foundation; either version 3, or (at your option) any later ver- --
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE. --
-- --
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception, --
-- version 3.1, as published by the Free Software Foundation. --
-- --
-- You should have received a copy of the GNU General Public License and --
-- a copy of the GCC Runtime Library Exception along with this program; --
-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
-- <http://www.gnu.org/licenses/>. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
pragma Style_Checks (All_Checks);
-- No subprogram ordering check, due to logical grouping
with Atree; use Atree;
package body Sinfo is
use Atree.Unchecked_Access;
-- This package is one of the few packages which is allowed to make direct
-- references to tree nodes (since it is in the business of providing a
-- higher level of tree access which other clients are expected to use and
-- which implements checks).
use Atree_Private_Part;
-- The only reason that we ask for direct access to the private part of
-- the tree package is so that we can directly reference the Nkind field
-- of nodes table entries. We do this since it helps the efficiency of
-- the Sinfo debugging checks considerably (note that when we are checking
-- Nkind values, we don't need to check for a valid node reference, because
-- we will check that anyway when we reference the field).
NT : Nodes.Table_Ptr renames Nodes.Table;
-- A short hand abbreviation, useful for the debugging checks
----------------------------
-- Field Access Functions --
----------------------------
function ABE_Is_Certain
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Package_Declaration
or else NT (N).Nkind = N_Function_Call
or else NT (N).Nkind = N_Function_Instantiation
or else NT (N).Nkind = N_Package_Instantiation
or else NT (N).Nkind = N_Procedure_Call_Statement
or else NT (N).Nkind = N_Procedure_Instantiation);
return Flag18 (N);
end ABE_Is_Certain;
function Abort_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Requeue_Statement);
return Flag15 (N);
end Abort_Present;
function Abortable_Part
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Asynchronous_Select);
return Node2 (N);
end Abortable_Part;
function Abstract_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Derived_Type_Definition
or else NT (N).Nkind = N_Formal_Derived_Type_Definition
or else NT (N).Nkind = N_Formal_Private_Type_Definition
or else NT (N).Nkind = N_Private_Extension_Declaration
or else NT (N).Nkind = N_Private_Type_Declaration
or else NT (N).Nkind = N_Record_Definition);
return Flag4 (N);
end Abstract_Present;
function Accept_Handler_Records
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Accept_Alternative);
return List5 (N);
end Accept_Handler_Records;
function Accept_Statement
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Accept_Alternative);
return Node2 (N);
end Accept_Statement;
function Access_Definition
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Definition
or else NT (N).Nkind = N_Formal_Object_Declaration
or else NT (N).Nkind = N_Object_Renaming_Declaration);
return Node3 (N);
end Access_Definition;
function Access_To_Subprogram_Definition
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Access_Definition);
return Node3 (N);
end Access_To_Subprogram_Definition;
function Access_Types_To_Process
(N : Node_Id) return Elist_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Freeze_Entity);
return Elist2 (N);
end Access_Types_To_Process;
function Actions
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_And_Then
or else NT (N).Nkind = N_Case_Expression_Alternative
or else NT (N).Nkind = N_Compilation_Unit_Aux
or else NT (N).Nkind = N_Compound_Statement
or else NT (N).Nkind = N_Expression_With_Actions
or else NT (N).Nkind = N_Freeze_Entity
or else NT (N).Nkind = N_Or_Else);
return List1 (N);
end Actions;
function Activation_Chain_Entity
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Block_Statement
or else NT (N).Nkind = N_Entry_Body
or else NT (N).Nkind = N_Generic_Package_Declaration
or else NT (N).Nkind = N_Package_Declaration
or else NT (N).Nkind = N_Subprogram_Body
or else NT (N).Nkind = N_Task_Body);
return Node3 (N);
end Activation_Chain_Entity;
function Acts_As_Spec
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit
or else NT (N).Nkind = N_Subprogram_Body);
return Flag4 (N);
end Acts_As_Spec;
function Actual_Designated_Subtype
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Explicit_Dereference
or else NT (N).Nkind = N_Free_Statement);
return Node4 (N);
end Actual_Designated_Subtype;
function Address_Warning_Posted
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Attribute_Definition_Clause);
return Flag18 (N);
end Address_Warning_Posted;
function Aggregate_Bounds
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aggregate);
return Node3 (N);
end Aggregate_Bounds;
function Aliased_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Definition
or else NT (N).Nkind = N_Object_Declaration
or else NT (N).Nkind = N_Parameter_Specification);
return Flag4 (N);
end Aliased_Present;
function All_Others
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Others_Choice);
return Flag11 (N);
end All_Others;
function All_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Access_Definition
or else NT (N).Nkind = N_Access_To_Object_Definition
or else NT (N).Nkind = N_Quantified_Expression
or else NT (N).Nkind = N_Use_Type_Clause);
return Flag15 (N);
end All_Present;
function Alternatives
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Case_Expression
or else NT (N).Nkind = N_Case_Statement
or else NT (N).Nkind = N_In
or else NT (N).Nkind = N_Not_In);
return List4 (N);
end Alternatives;
function Ancestor_Part
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Extension_Aggregate);
return Node3 (N);
end Ancestor_Part;
function Atomic_Sync_Required
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Expanded_Name
or else NT (N).Nkind = N_Explicit_Dereference
or else NT (N).Nkind = N_Identifier
or else NT (N).Nkind = N_Indexed_Component
or else NT (N).Nkind = N_Selected_Component);
return Flag14 (N);
end Atomic_Sync_Required;
function Array_Aggregate
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Enumeration_Representation_Clause);
return Node3 (N);
end Array_Aggregate;
function Aspect_Rep_Item
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aspect_Specification);
return Node2 (N);
end Aspect_Rep_Item;
function Assignment_OK
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Object_Declaration
or else NT (N).Nkind in N_Subexpr);
return Flag15 (N);
end Assignment_OK;
function Associated_Node
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind in N_Has_Entity
or else NT (N).Nkind = N_Aggregate
or else NT (N).Nkind = N_Extension_Aggregate
or else NT (N).Nkind = N_Selected_Component);
return Node4 (N);
end Associated_Node;
function At_End_Proc
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Handled_Sequence_Of_Statements);
return Node1 (N);
end At_End_Proc;
function Attribute_Name
(N : Node_Id) return Name_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Attribute_Reference);
return Name2 (N);
end Attribute_Name;
function Aux_Decls_Node
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit);
return Node5 (N);
end Aux_Decls_Node;
function Backwards_OK
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Assignment_Statement);
return Flag6 (N);
end Backwards_OK;
function Bad_Is_Detected
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subprogram_Body);
return Flag15 (N);
end Bad_Is_Detected;
function Body_Required
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit);
return Flag13 (N);
end Body_Required;
function Body_To_Inline
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subprogram_Declaration);
return Node3 (N);
end Body_To_Inline;
function Box_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Association
or else NT (N).Nkind = N_Formal_Abstract_Subprogram_Declaration
or else NT (N).Nkind = N_Formal_Concrete_Subprogram_Declaration
or else NT (N).Nkind = N_Formal_Package_Declaration
or else NT (N).Nkind = N_Generic_Association);
return Flag15 (N);
end Box_Present;
function By_Ref
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Extended_Return_Statement
or else NT (N).Nkind = N_Simple_Return_Statement);
return Flag5 (N);
end By_Ref;
function Char_Literal_Value
(N : Node_Id) return Uint is
begin
pragma Assert (False
or else NT (N).Nkind = N_Character_Literal);
return Uint2 (N);
end Char_Literal_Value;
function Chars
(N : Node_Id) return Name_Id is
begin
pragma Assert (False
or else NT (N).Nkind in N_Has_Chars);
return Name1 (N);
end Chars;
function Check_Address_Alignment
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Attribute_Definition_Clause);
return Flag11 (N);
end Check_Address_Alignment;
function Choice_Parameter
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Exception_Handler);
return Node2 (N);
end Choice_Parameter;
function Choices
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Association);
return List1 (N);
end Choices;
function Class_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aspect_Specification
or else NT (N).Nkind = N_Pragma);
return Flag6 (N);
end Class_Present;
function Classifications
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Contract);
return Node3 (N);
end Classifications;
function Cleanup_Actions
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Block_Statement);
return List5 (N);
end Cleanup_Actions;
function Comes_From_Extended_Return_Statement
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Simple_Return_Statement);
return Flag18 (N);
end Comes_From_Extended_Return_Statement;
function Compile_Time_Known_Aggregate
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aggregate);
return Flag18 (N);
end Compile_Time_Known_Aggregate;
function Component_Associations
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aggregate
or else NT (N).Nkind = N_Extension_Aggregate);
return List2 (N);
end Component_Associations;
function Component_Clauses
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Record_Representation_Clause);
return List3 (N);
end Component_Clauses;
function Component_Definition
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Declaration
or else NT (N).Nkind = N_Constrained_Array_Definition
or else NT (N).Nkind = N_Unconstrained_Array_Definition);
return Node4 (N);
end Component_Definition;
function Component_Items
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_List);
return List3 (N);
end Component_Items;
function Component_List
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Record_Definition
or else NT (N).Nkind = N_Variant);
return Node1 (N);
end Component_List;
function Component_Name
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Clause);
return Node1 (N);
end Component_Name;
function Componentwise_Assignment
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Assignment_Statement);
return Flag14 (N);
end Componentwise_Assignment;
function Condition
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Accept_Alternative
or else NT (N).Nkind = N_Delay_Alternative
or else NT (N).Nkind = N_Elsif_Part
or else NT (N).Nkind = N_Entry_Body_Formal_Part
or else NT (N).Nkind = N_Exit_Statement
or else NT (N).Nkind = N_If_Statement
or else NT (N).Nkind = N_Iteration_Scheme
or else NT (N).Nkind = N_Quantified_Expression
or else NT (N).Nkind = N_Raise_Constraint_Error
or else NT (N).Nkind = N_Raise_Program_Error
or else NT (N).Nkind = N_Raise_Storage_Error
or else NT (N).Nkind = N_Terminate_Alternative);
return Node1 (N);
end Condition;
function Condition_Actions
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Elsif_Part
or else NT (N).Nkind = N_Iteration_Scheme);
return List3 (N);
end Condition_Actions;
function Config_Pragmas
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit_Aux);
return List4 (N);
end Config_Pragmas;
function Constant_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Access_Definition
or else NT (N).Nkind = N_Access_To_Object_Definition
or else NT (N).Nkind = N_Object_Declaration);
return Flag17 (N);
end Constant_Present;
function Constraint
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subtype_Indication);
return Node3 (N);
end Constraint;
function Constraints
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Index_Or_Discriminant_Constraint);
return List1 (N);
end Constraints;
function Context_Installed
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
return Flag13 (N);
end Context_Installed;
function Context_Items
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit);
return List1 (N);
end Context_Items;
function Context_Pending
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit);
return Flag16 (N);
end Context_Pending;
function Contract_Test_Cases
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Contract);
return Node2 (N);
end Contract_Test_Cases;
function Controlling_Argument
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Function_Call
or else NT (N).Nkind = N_Procedure_Call_Statement);
return Node1 (N);
end Controlling_Argument;
function Conversion_OK
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Type_Conversion);
return Flag14 (N);
end Conversion_OK;
function Convert_To_Return_False
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Raise_Expression);
return Flag13 (N);
end Convert_To_Return_False;
function Corresponding_Aspect
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Pragma);
return Node3 (N);
end Corresponding_Aspect;
function Corresponding_Body
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Entry_Declaration
or else NT (N).Nkind = N_Generic_Package_Declaration
or else NT (N).Nkind = N_Generic_Subprogram_Declaration
or else NT (N).Nkind = N_Package_Body_Stub
or else NT (N).Nkind = N_Package_Declaration
or else NT (N).Nkind = N_Protected_Body_Stub
or else NT (N).Nkind = N_Protected_Type_Declaration
or else NT (N).Nkind = N_Subprogram_Body_Stub
or else NT (N).Nkind = N_Subprogram_Declaration
or else NT (N).Nkind = N_Task_Body_Stub
or else NT (N).Nkind = N_Task_Type_Declaration);
return Node5 (N);
end Corresponding_Body;
function Corresponding_Formal_Spec
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subprogram_Renaming_Declaration);
return Node3 (N);
end Corresponding_Formal_Spec;
function Corresponding_Generic_Association
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Object_Declaration
or else NT (N).Nkind = N_Object_Renaming_Declaration);
return Node5 (N);
end Corresponding_Generic_Association;
function Corresponding_Integer_Value
(N : Node_Id) return Uint is
begin
pragma Assert (False
or else NT (N).Nkind = N_Real_Literal);
return Uint4 (N);
end Corresponding_Integer_Value;
function Corresponding_Spec
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Expression_Function
or else NT (N).Nkind = N_Package_Body
or else NT (N).Nkind = N_Protected_Body
or else NT (N).Nkind = N_Subprogram_Body
or else NT (N).Nkind = N_Subprogram_Renaming_Declaration
or else NT (N).Nkind = N_Task_Body
or else NT (N).Nkind = N_With_Clause);
return Node5 (N);
end Corresponding_Spec;
function Corresponding_Spec_Of_Stub
(N : Node_Id) return Entity_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Package_Body_Stub
or else NT (N).Nkind = N_Protected_Body_Stub
or else NT (N).Nkind = N_Subprogram_Body_Stub
or else NT (N).Nkind = N_Task_Body_Stub);
return Node2 (N);
end Corresponding_Spec_Of_Stub;
function Corresponding_Stub
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subunit);
return Node3 (N);
end Corresponding_Stub;
function Dcheck_Function
(N : Node_Id) return Entity_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Variant);
return Node5 (N);
end Dcheck_Function;
function Declarations
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Accept_Statement
or else NT (N).Nkind = N_Block_Statement
or else NT (N).Nkind = N_Compilation_Unit_Aux
or else NT (N).Nkind = N_Entry_Body
or else NT (N).Nkind = N_Package_Body
or else NT (N).Nkind = N_Protected_Body
or else NT (N).Nkind = N_Subprogram_Body
or else NT (N).Nkind = N_Task_Body);
return List2 (N);
end Declarations;
function Default_Expression
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Object_Declaration
or else NT (N).Nkind = N_Parameter_Specification);
return Node5 (N);
end Default_Expression;
function Default_Storage_Pool
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit_Aux);
return Node3 (N);
end Default_Storage_Pool;
function Default_Name
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Abstract_Subprogram_Declaration
or else NT (N).Nkind = N_Formal_Concrete_Subprogram_Declaration);
return Node2 (N);
end Default_Name;
function Defining_Identifier
(N : Node_Id) return Entity_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Declaration
or else NT (N).Nkind = N_Defining_Program_Unit_Name
or else NT (N).Nkind = N_Discriminant_Specification
or else NT (N).Nkind = N_Entry_Body
or else NT (N).Nkind = N_Entry_Declaration
or else NT (N).Nkind = N_Entry_Index_Specification
or else NT (N).Nkind = N_Exception_Declaration
or else NT (N).Nkind = N_Exception_Renaming_Declaration
or else NT (N).Nkind = N_Formal_Object_Declaration
or else NT (N).Nkind = N_Formal_Package_Declaration
or else NT (N).Nkind = N_Formal_Type_Declaration
or else NT (N).Nkind = N_Full_Type_Declaration
or else NT (N).Nkind = N_Implicit_Label_Declaration
or else NT (N).Nkind = N_Incomplete_Type_Declaration
or else NT (N).Nkind = N_Iterator_Specification
or else NT (N).Nkind = N_Loop_Parameter_Specification
or else NT (N).Nkind = N_Number_Declaration
or else NT (N).Nkind = N_Object_Declaration
or else NT (N).Nkind = N_Object_Renaming_Declaration
or else NT (N).Nkind = N_Package_Body_Stub
or else NT (N).Nkind = N_Parameter_Specification
or else NT (N).Nkind = N_Private_Extension_Declaration
or else NT (N).Nkind = N_Private_Type_Declaration
or else NT (N).Nkind = N_Protected_Body
or else NT (N).Nkind = N_Protected_Body_Stub
or else NT (N).Nkind = N_Protected_Type_Declaration
or else NT (N).Nkind = N_Single_Protected_Declaration
or else NT (N).Nkind = N_Single_Task_Declaration
or else NT (N).Nkind = N_Subtype_Declaration
or else NT (N).Nkind = N_Task_Body
or else NT (N).Nkind = N_Task_Body_Stub
or else NT (N).Nkind = N_Task_Type_Declaration);
return Node1 (N);
end Defining_Identifier;
function Defining_Unit_Name
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Function_Instantiation
or else NT (N).Nkind = N_Function_Specification
or else NT (N).Nkind = N_Generic_Function_Renaming_Declaration
or else NT (N).Nkind = N_Generic_Package_Renaming_Declaration
or else NT (N).Nkind = N_Generic_Procedure_Renaming_Declaration
or else NT (N).Nkind = N_Package_Body
or else NT (N).Nkind = N_Package_Instantiation
or else NT (N).Nkind = N_Package_Renaming_Declaration
or else NT (N).Nkind = N_Package_Specification
or else NT (N).Nkind = N_Procedure_Instantiation
or else NT (N).Nkind = N_Procedure_Specification);
return Node1 (N);
end Defining_Unit_Name;
function Delay_Alternative
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Timed_Entry_Call);
return Node4 (N);
end Delay_Alternative;
function Delay_Statement
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Delay_Alternative);
return Node2 (N);
end Delay_Statement;
function Delta_Expression
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Decimal_Fixed_Point_Definition
or else NT (N).Nkind = N_Delta_Constraint
or else NT (N).Nkind = N_Ordinary_Fixed_Point_Definition);
return Node3 (N);
end Delta_Expression;
function Digits_Expression
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Decimal_Fixed_Point_Definition
or else NT (N).Nkind = N_Digits_Constraint
or else NT (N).Nkind = N_Floating_Point_Definition);
return Node2 (N);
end Digits_Expression;
function Discr_Check_Funcs_Built
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Full_Type_Declaration);
return Flag11 (N);
end Discr_Check_Funcs_Built;
function Discrete_Choices
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Case_Expression_Alternative
or else NT (N).Nkind = N_Case_Statement_Alternative
or else NT (N).Nkind = N_Variant);
return List4 (N);
end Discrete_Choices;
function Discrete_Range
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Slice);
return Node4 (N);
end Discrete_Range;
function Discrete_Subtype_Definition
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Entry_Declaration
or else NT (N).Nkind = N_Entry_Index_Specification
or else NT (N).Nkind = N_Loop_Parameter_Specification);
return Node4 (N);
end Discrete_Subtype_Definition;
function Discrete_Subtype_Definitions
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Constrained_Array_Definition);
return List2 (N);
end Discrete_Subtype_Definitions;
function Discriminant_Specifications
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Type_Declaration
or else NT (N).Nkind = N_Full_Type_Declaration
or else NT (N).Nkind = N_Incomplete_Type_Declaration
or else NT (N).Nkind = N_Private_Extension_Declaration
or else NT (N).Nkind = N_Private_Type_Declaration
or else NT (N).Nkind = N_Protected_Type_Declaration
or else NT (N).Nkind = N_Task_Type_Declaration);
return List4 (N);
end Discriminant_Specifications;
function Discriminant_Type
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Discriminant_Specification);
return Node5 (N);
end Discriminant_Type;
function Do_Accessibility_Check
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Parameter_Specification);
return Flag13 (N);
end Do_Accessibility_Check;
function Do_Discriminant_Check
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Assignment_Statement
or else NT (N).Nkind = N_Selected_Component
or else NT (N).Nkind = N_Type_Conversion);
return Flag1 (N);
end Do_Discriminant_Check;
function Do_Division_Check
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Op_Divide
or else NT (N).Nkind = N_Op_Mod
or else NT (N).Nkind = N_Op_Rem);
return Flag13 (N);
end Do_Division_Check;
function Do_Length_Check
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Assignment_Statement
or else NT (N).Nkind = N_Op_And
or else NT (N).Nkind = N_Op_Or
or else NT (N).Nkind = N_Op_Xor
or else NT (N).Nkind = N_Type_Conversion);
return Flag4 (N);
end Do_Length_Check;
function Do_Overflow_Check
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind in N_Op
or else NT (N).Nkind = N_Attribute_Reference
or else NT (N).Nkind = N_Case_Expression
or else NT (N).Nkind = N_If_Expression
or else NT (N).Nkind = N_Type_Conversion);
return Flag17 (N);
end Do_Overflow_Check;
function Do_Range_Check
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind in N_Subexpr);
return Flag9 (N);
end Do_Range_Check;
function Do_Storage_Check
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Allocator
or else NT (N).Nkind = N_Subprogram_Body);
return Flag17 (N);
end Do_Storage_Check;
function Do_Tag_Check
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Assignment_Statement
or else NT (N).Nkind = N_Extended_Return_Statement
or else NT (N).Nkind = N_Function_Call
or else NT (N).Nkind = N_Procedure_Call_Statement
or else NT (N).Nkind = N_Simple_Return_Statement
or else NT (N).Nkind = N_Type_Conversion);
return Flag13 (N);
end Do_Tag_Check;
function Elaborate_All_Desirable
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
return Flag9 (N);
end Elaborate_All_Desirable;
function Elaborate_All_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
return Flag14 (N);
end Elaborate_All_Present;
function Elaborate_Desirable
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
return Flag11 (N);
end Elaborate_Desirable;
function Elaborate_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
return Flag4 (N);
end Elaborate_Present;
function Else_Actions
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_If_Expression);
return List3 (N);
end Else_Actions;
function Else_Statements
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Conditional_Entry_Call
or else NT (N).Nkind = N_If_Statement
or else NT (N).Nkind = N_Selective_Accept);
return List4 (N);
end Else_Statements;
function Elsif_Parts
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_If_Statement);
return List3 (N);
end Elsif_Parts;
function Enclosing_Variant
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Variant);
return Node2 (N);
end Enclosing_Variant;
function End_Label
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Enumeration_Type_Definition
or else NT (N).Nkind = N_Handled_Sequence_Of_Statements
or else NT (N).Nkind = N_Loop_Statement
or else NT (N).Nkind = N_Package_Specification
or else NT (N).Nkind = N_Protected_Body
or else NT (N).Nkind = N_Protected_Definition
or else NT (N).Nkind = N_Record_Definition
or else NT (N).Nkind = N_Task_Definition);
return Node4 (N);
end End_Label;
function End_Span
(N : Node_Id) return Uint is
begin
pragma Assert (False
or else NT (N).Nkind = N_Case_Statement
or else NT (N).Nkind = N_If_Statement);
return Uint5 (N);
end End_Span;
function Entity
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind in N_Has_Entity
or else NT (N).Nkind = N_Aspect_Specification
or else NT (N).Nkind = N_Attribute_Definition_Clause
or else NT (N).Nkind = N_Freeze_Entity
or else NT (N).Nkind = N_Freeze_Generic_Entity);
return Node4 (N);
end Entity;
function Entity_Or_Associated_Node
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind in N_Has_Entity
or else NT (N).Nkind = N_Freeze_Entity);
return Node4 (N);
end Entity_Or_Associated_Node;
function Entry_Body_Formal_Part
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Entry_Body);
return Node5 (N);
end Entry_Body_Formal_Part;
function Entry_Call_Alternative
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Conditional_Entry_Call
or else NT (N).Nkind = N_Timed_Entry_Call);
return Node1 (N);
end Entry_Call_Alternative;
function Entry_Call_Statement
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Entry_Call_Alternative);
return Node1 (N);
end Entry_Call_Statement;
function Entry_Direct_Name
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Accept_Statement);
return Node1 (N);
end Entry_Direct_Name;
function Entry_Index
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Accept_Statement);
return Node5 (N);
end Entry_Index;
function Entry_Index_Specification
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Entry_Body_Formal_Part);
return Node4 (N);
end Entry_Index_Specification;
function Etype
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind in N_Has_Etype);
return Node5 (N);
end Etype;
function Exception_Choices
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Exception_Handler);
return List4 (N);
end Exception_Choices;
function Exception_Handlers
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Handled_Sequence_Of_Statements);
return List5 (N);
end Exception_Handlers;
function Exception_Junk
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Block_Statement
or else NT (N).Nkind = N_Goto_Statement
or else NT (N).Nkind = N_Label
or else NT (N).Nkind = N_Object_Declaration
or else NT (N).Nkind = N_Subtype_Declaration);
return Flag8 (N);
end Exception_Junk;
function Exception_Label
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Exception_Handler
or else NT (N).Nkind = N_Push_Constraint_Error_Label
or else NT (N).Nkind = N_Push_Program_Error_Label
or else NT (N).Nkind = N_Push_Storage_Error_Label);
return Node5 (N);
end Exception_Label;
function Expansion_Delayed
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aggregate
or else NT (N).Nkind = N_Extension_Aggregate);
return Flag11 (N);
end Expansion_Delayed;
function Explicit_Actual_Parameter
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Parameter_Association);
return Node3 (N);
end Explicit_Actual_Parameter;
function Explicit_Generic_Actual_Parameter
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Generic_Association);
return Node1 (N);
end Explicit_Generic_Actual_Parameter;
function Expression
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Allocator
or else NT (N).Nkind = N_Aspect_Specification
or else NT (N).Nkind = N_Assignment_Statement
or else NT (N).Nkind = N_At_Clause
or else NT (N).Nkind = N_Attribute_Definition_Clause
or else NT (N).Nkind = N_Case_Expression
or else NT (N).Nkind = N_Case_Expression_Alternative
or else NT (N).Nkind = N_Case_Statement
or else NT (N).Nkind = N_Code_Statement
or else NT (N).Nkind = N_Component_Association
or else NT (N).Nkind = N_Component_Declaration
or else NT (N).Nkind = N_Delay_Relative_Statement
or else NT (N).Nkind = N_Delay_Until_Statement
or else NT (N).Nkind = N_Discriminant_Association
or else NT (N).Nkind = N_Discriminant_Specification
or else NT (N).Nkind = N_Exception_Declaration
or else NT (N).Nkind = N_Expression_Function
or else NT (N).Nkind = N_Expression_With_Actions
or else NT (N).Nkind = N_Free_Statement
or else NT (N).Nkind = N_Mod_Clause
or else NT (N).Nkind = N_Modular_Type_Definition
or else NT (N).Nkind = N_Number_Declaration
or else NT (N).Nkind = N_Object_Declaration
or else NT (N).Nkind = N_Parameter_Specification
or else NT (N).Nkind = N_Pragma_Argument_Association
or else NT (N).Nkind = N_Qualified_Expression
or else NT (N).Nkind = N_Raise_Expression
or else NT (N).Nkind = N_Raise_Statement
or else NT (N).Nkind = N_Simple_Return_Statement
or else NT (N).Nkind = N_Type_Conversion
or else NT (N).Nkind = N_Unchecked_Expression
or else NT (N).Nkind = N_Unchecked_Type_Conversion);
return Node3 (N);
end Expression;
function Expressions
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aggregate
or else NT (N).Nkind = N_Attribute_Reference
or else NT (N).Nkind = N_Extension_Aggregate
or else NT (N).Nkind = N_If_Expression
or else NT (N).Nkind = N_Indexed_Component);
return List1 (N);
end Expressions;
function First_Bit
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Clause);
return Node3 (N);
end First_Bit;
function First_Inlined_Subprogram
(N : Node_Id) return Entity_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit);
return Node3 (N);
end First_Inlined_Subprogram;
function First_Name
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
return Flag5 (N);
end First_Name;
function First_Named_Actual
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Entry_Call_Statement
or else NT (N).Nkind = N_Function_Call
or else NT (N).Nkind = N_Procedure_Call_Statement);
return Node4 (N);
end First_Named_Actual;
function First_Real_Statement
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Handled_Sequence_Of_Statements);
return Node2 (N);
end First_Real_Statement;
function First_Subtype_Link
(N : Node_Id) return Entity_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Freeze_Entity);
return Node5 (N);
end First_Subtype_Link;
function Float_Truncate
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Type_Conversion);
return Flag11 (N);
end Float_Truncate;
function Formal_Type_Definition
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Type_Declaration);
return Node3 (N);
end Formal_Type_Definition;
function Forwards_OK
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Assignment_Statement);
return Flag5 (N);
end Forwards_OK;
function From_Aspect_Specification
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Attribute_Definition_Clause
or else NT (N).Nkind = N_Pragma);
return Flag13 (N);
end From_Aspect_Specification;
function From_At_End
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Raise_Statement);
return Flag4 (N);
end From_At_End;
function From_At_Mod
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Attribute_Definition_Clause);
return Flag4 (N);
end From_At_Mod;
function From_Conditional_Expression
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Case_Statement
or else NT (N).Nkind = N_If_Statement);
return Flag1 (N);
end From_Conditional_Expression;
function From_Default
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subprogram_Renaming_Declaration);
return Flag6 (N);
end From_Default;
function Generalized_Indexing
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Indexed_Component);
return Node4 (N);
end Generalized_Indexing;
function Generic_Associations
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Package_Declaration
or else NT (N).Nkind = N_Function_Instantiation
or else NT (N).Nkind = N_Package_Instantiation
or else NT (N).Nkind = N_Procedure_Instantiation);
return List3 (N);
end Generic_Associations;
function Generic_Formal_Declarations
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Generic_Package_Declaration
or else NT (N).Nkind = N_Generic_Subprogram_Declaration);
return List2 (N);
end Generic_Formal_Declarations;
function Generic_Parent
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Function_Specification
or else NT (N).Nkind = N_Package_Specification
or else NT (N).Nkind = N_Procedure_Specification);
return Node5 (N);
end Generic_Parent;
function Generic_Parent_Type
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subtype_Declaration);
return Node4 (N);
end Generic_Parent_Type;
function Handled_Statement_Sequence
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Accept_Statement
or else NT (N).Nkind = N_Block_Statement
or else NT (N).Nkind = N_Entry_Body
or else NT (N).Nkind = N_Extended_Return_Statement
or else NT (N).Nkind = N_Package_Body
or else NT (N).Nkind = N_Subprogram_Body
or else NT (N).Nkind = N_Task_Body);
return Node4 (N);
end Handled_Statement_Sequence;
function Handler_List_Entry
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Object_Declaration);
return Node2 (N);
end Handler_List_Entry;
function Has_Created_Identifier
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Block_Statement
or else NT (N).Nkind = N_Loop_Statement);
return Flag15 (N);
end Has_Created_Identifier;
function Has_Dereference_Action
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Explicit_Dereference);
return Flag13 (N);
end Has_Dereference_Action;
function Has_Dynamic_Length_Check
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind in N_Subexpr);
return Flag10 (N);
end Has_Dynamic_Length_Check;
function Has_Dynamic_Range_Check
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subtype_Declaration
or else NT (N).Nkind in N_Subexpr);
return Flag12 (N);
end Has_Dynamic_Range_Check;
function Has_Init_Expression
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Object_Declaration);
return Flag14 (N);
end Has_Init_Expression;
function Has_Local_Raise
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Exception_Handler);
return Flag8 (N);
end Has_Local_Raise;
function Has_No_Elaboration_Code
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit);
return Flag17 (N);
end Has_No_Elaboration_Code;
function Has_Pragma_Suppress_All
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit);
return Flag14 (N);
end Has_Pragma_Suppress_All;
function Has_Private_View
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind in N_Op
or else NT (N).Nkind = N_Character_Literal
or else NT (N).Nkind = N_Expanded_Name
or else NT (N).Nkind = N_Identifier
or else NT (N).Nkind = N_Operator_Symbol);
return Flag11 (N);
end Has_Private_View;
function Has_Relative_Deadline_Pragma
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subprogram_Body
or else NT (N).Nkind = N_Task_Definition);
return Flag9 (N);
end Has_Relative_Deadline_Pragma;
function Has_Self_Reference
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aggregate
or else NT (N).Nkind = N_Extension_Aggregate);
return Flag13 (N);
end Has_Self_Reference;
function Has_SP_Choice
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Case_Expression_Alternative
or else NT (N).Nkind = N_Case_Statement_Alternative
or else NT (N).Nkind = N_Variant);
return Flag15 (N);
end Has_SP_Choice;
function Has_Storage_Size_Pragma
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Task_Definition);
return Flag5 (N);
end Has_Storage_Size_Pragma;
function Has_Wide_Character
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_String_Literal);
return Flag11 (N);
end Has_Wide_Character;
function Has_Wide_Wide_Character
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_String_Literal);
return Flag13 (N);
end Has_Wide_Wide_Character;
function Header_Size_Added
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Attribute_Reference);
return Flag11 (N);
end Header_Size_Added;
function Hidden_By_Use_Clause
(N : Node_Id) return Elist_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Use_Package_Clause
or else NT (N).Nkind = N_Use_Type_Clause);
return Elist4 (N);
end Hidden_By_Use_Clause;
function High_Bound
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Range
or else NT (N).Nkind = N_Real_Range_Specification
or else NT (N).Nkind = N_Signed_Integer_Type_Definition);
return Node2 (N);
end High_Bound;
function Identifier
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aspect_Specification
or else NT (N).Nkind = N_At_Clause
or else NT (N).Nkind = N_Block_Statement
or else NT (N).Nkind = N_Designator
or else NT (N).Nkind = N_Enumeration_Representation_Clause
or else NT (N).Nkind = N_Label
or else NT (N).Nkind = N_Loop_Statement
or else NT (N).Nkind = N_Record_Representation_Clause);
return Node1 (N);
end Identifier;
function Implicit_With
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
return Flag16 (N);
end Implicit_With;
function Implicit_With_From_Instantiation
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
return Flag12 (N);
end Implicit_With_From_Instantiation;
function Interface_List
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Derived_Type_Definition
or else NT (N).Nkind = N_Formal_Derived_Type_Definition
or else NT (N).Nkind = N_Private_Extension_Declaration
or else NT (N).Nkind = N_Protected_Type_Declaration
or else NT (N).Nkind = N_Record_Definition
or else NT (N).Nkind = N_Single_Protected_Declaration
or else NT (N).Nkind = N_Single_Task_Declaration
or else NT (N).Nkind = N_Task_Type_Declaration);
return List2 (N);
end Interface_List;
function Interface_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Derived_Type_Definition
or else NT (N).Nkind = N_Record_Definition);
return Flag16 (N);
end Interface_Present;
function Import_Interface_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Pragma);
return Flag16 (N);
end Import_Interface_Present;
function In_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Object_Declaration
or else NT (N).Nkind = N_Parameter_Specification);
return Flag15 (N);
end In_Present;
function Includes_Infinities
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Range);
return Flag11 (N);
end Includes_Infinities;
function Incomplete_View
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Full_Type_Declaration);
return Node2 (N);
end Incomplete_View;
function Inherited_Discriminant
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Association);
return Flag13 (N);
end Inherited_Discriminant;
function Instance_Spec
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Package_Declaration
or else NT (N).Nkind = N_Function_Instantiation
or else NT (N).Nkind = N_Package_Instantiation
or else NT (N).Nkind = N_Procedure_Instantiation);
return Node5 (N);
end Instance_Spec;
function Intval
(N : Node_Id) return Uint is
begin
pragma Assert (False
or else NT (N).Nkind = N_Integer_Literal);
return Uint3 (N);
end Intval;
function Is_Accessibility_Actual
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Parameter_Association);
return Flag13 (N);
end Is_Accessibility_Actual;
function Is_Asynchronous_Call_Block
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Block_Statement);
return Flag7 (N);
end Is_Asynchronous_Call_Block;
function Is_Boolean_Aspect
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aspect_Specification);
return Flag16 (N);
end Is_Boolean_Aspect;
function Is_Checked
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aspect_Specification
or else NT (N).Nkind = N_Pragma);
return Flag11 (N);
end Is_Checked;
function Is_Component_Left_Opnd
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Op_Concat);
return Flag13 (N);
end Is_Component_Left_Opnd;
function Is_Component_Right_Opnd
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Op_Concat);
return Flag14 (N);
end Is_Component_Right_Opnd;
function Is_Controlling_Actual
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind in N_Subexpr);
return Flag16 (N);
end Is_Controlling_Actual;
function Is_Disabled
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aspect_Specification
or else NT (N).Nkind = N_Pragma);
return Flag15 (N);
end Is_Disabled;
function Is_Delayed_Aspect
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aspect_Specification
or else NT (N).Nkind = N_Attribute_Definition_Clause
or else NT (N).Nkind = N_Pragma);
return Flag14 (N);
end Is_Delayed_Aspect;
function Is_Dynamic_Coextension
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Allocator);
return Flag18 (N);
end Is_Dynamic_Coextension;
function Is_Elsif
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_If_Expression);
return Flag13 (N);
end Is_Elsif;
function Is_Entry_Barrier_Function
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subprogram_Body);
return Flag8 (N);
end Is_Entry_Barrier_Function;
function Is_Expanded_Build_In_Place_Call
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Function_Call);
return Flag11 (N);
end Is_Expanded_Build_In_Place_Call;
function Is_Finalization_Wrapper
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Block_Statement);
return Flag9 (N);
end Is_Finalization_Wrapper;
function Is_Folded_In_Parser
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_String_Literal);
return Flag4 (N);
end Is_Folded_In_Parser;
function Is_Ignored
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aspect_Specification
or else NT (N).Nkind = N_Pragma);
return Flag9 (N);
end Is_Ignored;
function Is_In_Discriminant_Check
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Selected_Component);
return Flag11 (N);
end Is_In_Discriminant_Check;
function Is_Inherited
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Pragma);
return Flag4 (N);
end Is_Inherited;
function Is_Machine_Number
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Real_Literal);
return Flag11 (N);
end Is_Machine_Number;
function Is_Null_Loop
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Loop_Statement);
return Flag16 (N);
end Is_Null_Loop;
function Is_Overloaded
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind in N_Subexpr);
return Flag5 (N);
end Is_Overloaded;
function Is_Power_Of_2_For_Shift
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Op_Expon);
return Flag13 (N);
end Is_Power_Of_2_For_Shift;
function Is_Prefixed_Call
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Selected_Component);
return Flag17 (N);
end Is_Prefixed_Call;
function Is_Protected_Subprogram_Body
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subprogram_Body);
return Flag7 (N);
end Is_Protected_Subprogram_Body;
function Is_Static_Coextension
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Allocator);
return Flag14 (N);
end Is_Static_Coextension;
function Is_Static_Expression
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind in N_Subexpr);
return Flag6 (N);
end Is_Static_Expression;
function Is_Subprogram_Descriptor
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Object_Declaration);
return Flag16 (N);
end Is_Subprogram_Descriptor;
function Is_Task_Allocation_Block
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Block_Statement);
return Flag6 (N);
end Is_Task_Allocation_Block;
function Is_Task_Master
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Block_Statement
or else NT (N).Nkind = N_Subprogram_Body
or else NT (N).Nkind = N_Task_Body);
return Flag5 (N);
end Is_Task_Master;
function Iteration_Scheme
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Loop_Statement);
return Node2 (N);
end Iteration_Scheme;
function Iterator_Specification
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Iteration_Scheme
or else NT (N).Nkind = N_Quantified_Expression);
return Node2 (N);
end Iterator_Specification;
function Itype
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Itype_Reference);
return Node1 (N);
end Itype;
function Kill_Range_Check
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Unchecked_Type_Conversion);
return Flag11 (N);
end Kill_Range_Check;
function Label_Construct
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Implicit_Label_Declaration);
return Node2 (N);
end Label_Construct;
function Last_Bit
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Clause);
return Node4 (N);
end Last_Bit;
function Last_Name
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
return Flag6 (N);
end Last_Name;
function Left_Opnd
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_And_Then
or else NT (N).Nkind = N_In
or else NT (N).Nkind = N_Not_In
or else NT (N).Nkind = N_Or_Else
or else NT (N).Nkind in N_Binary_Op);
return Node2 (N);
end Left_Opnd;
function Library_Unit
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit
or else NT (N).Nkind = N_Package_Body_Stub
or else NT (N).Nkind = N_Protected_Body_Stub
or else NT (N).Nkind = N_Subprogram_Body_Stub
or else NT (N).Nkind = N_Task_Body_Stub
or else NT (N).Nkind = N_With_Clause);
return Node4 (N);
end Library_Unit;
function Limited_View_Installed
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Package_Specification
or else NT (N).Nkind = N_With_Clause);
return Flag18 (N);
end Limited_View_Installed;
function Limited_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Derived_Type_Definition
or else NT (N).Nkind = N_Formal_Derived_Type_Definition
or else NT (N).Nkind = N_Formal_Private_Type_Definition
or else NT (N).Nkind = N_Private_Extension_Declaration
or else NT (N).Nkind = N_Private_Type_Declaration
or else NT (N).Nkind = N_Record_Definition
or else NT (N).Nkind = N_With_Clause);
return Flag17 (N);
end Limited_Present;
function Literals
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Enumeration_Type_Definition);
return List1 (N);
end Literals;
function Local_Raise_Not_OK
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Exception_Handler);
return Flag7 (N);
end Local_Raise_Not_OK;
function Local_Raise_Statements
(N : Node_Id) return Elist_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Exception_Handler);
return Elist1 (N);
end Local_Raise_Statements;
function Loop_Actions
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Association);
return List2 (N);
end Loop_Actions;
function Loop_Parameter_Specification
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Iteration_Scheme
or else NT (N).Nkind = N_Quantified_Expression);
return Node4 (N);
end Loop_Parameter_Specification;
function Low_Bound
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Range
or else NT (N).Nkind = N_Real_Range_Specification
or else NT (N).Nkind = N_Signed_Integer_Type_Definition);
return Node1 (N);
end Low_Bound;
function Mod_Clause
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Record_Representation_Clause);
return Node2 (N);
end Mod_Clause;
function More_Ids
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Declaration
or else NT (N).Nkind = N_Discriminant_Specification
or else NT (N).Nkind = N_Exception_Declaration
or else NT (N).Nkind = N_Formal_Object_Declaration
or else NT (N).Nkind = N_Number_Declaration
or else NT (N).Nkind = N_Object_Declaration
or else NT (N).Nkind = N_Parameter_Specification);
return Flag5 (N);
end More_Ids;
function Must_Be_Byte_Aligned
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Attribute_Reference);
return Flag14 (N);
end Must_Be_Byte_Aligned;
function Must_Not_Freeze
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subtype_Indication
or else NT (N).Nkind in N_Subexpr);
return Flag8 (N);
end Must_Not_Freeze;
function Must_Not_Override
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Entry_Declaration
or else NT (N).Nkind = N_Function_Instantiation
or else NT (N).Nkind = N_Function_Specification
or else NT (N).Nkind = N_Procedure_Instantiation
or else NT (N).Nkind = N_Procedure_Specification);
return Flag15 (N);
end Must_Not_Override;
function Must_Override
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Entry_Declaration
or else NT (N).Nkind = N_Function_Instantiation
or else NT (N).Nkind = N_Function_Specification
or else NT (N).Nkind = N_Procedure_Instantiation
or else NT (N).Nkind = N_Procedure_Specification);
return Flag14 (N);
end Must_Override;
function Name
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Assignment_Statement
or else NT (N).Nkind = N_Attribute_Definition_Clause
or else NT (N).Nkind = N_Defining_Program_Unit_Name
or else NT (N).Nkind = N_Designator
or else NT (N).Nkind = N_Entry_Call_Statement
or else NT (N).Nkind = N_Exception_Renaming_Declaration
or else NT (N).Nkind = N_Exit_Statement
or else NT (N).Nkind = N_Formal_Package_Declaration
or else NT (N).Nkind = N_Function_Call
or else NT (N).Nkind = N_Function_Instantiation
or else NT (N).Nkind = N_Generic_Function_Renaming_Declaration
or else NT (N).Nkind = N_Generic_Package_Renaming_Declaration
or else NT (N).Nkind = N_Generic_Procedure_Renaming_Declaration
or else NT (N).Nkind = N_Goto_Statement
or else NT (N).Nkind = N_Iterator_Specification
or else NT (N).Nkind = N_Object_Renaming_Declaration
or else NT (N).Nkind = N_Package_Instantiation
or else NT (N).Nkind = N_Package_Renaming_Declaration
or else NT (N).Nkind = N_Procedure_Call_Statement
or else NT (N).Nkind = N_Procedure_Instantiation
or else NT (N).Nkind = N_Raise_Expression
or else NT (N).Nkind = N_Raise_Statement
or else NT (N).Nkind = N_Requeue_Statement
or else NT (N).Nkind = N_Subprogram_Renaming_Declaration
or else NT (N).Nkind = N_Subunit
or else NT (N).Nkind = N_Variant_Part
or else NT (N).Nkind = N_With_Clause);
return Node2 (N);
end Name;
function Names
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Abort_Statement
or else NT (N).Nkind = N_Use_Package_Clause);
return List2 (N);
end Names;
function Next_Entity
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Defining_Character_Literal
or else NT (N).Nkind = N_Defining_Identifier
or else NT (N).Nkind = N_Defining_Operator_Symbol);
return Node2 (N);
end Next_Entity;
function Next_Exit_Statement
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Exit_Statement);
return Node3 (N);
end Next_Exit_Statement;
function Next_Implicit_With
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
return Node3 (N);
end Next_Implicit_With;
function Next_Named_Actual
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Parameter_Association);
return Node4 (N);
end Next_Named_Actual;
function Next_Pragma
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Pragma);
return Node1 (N);
end Next_Pragma;
function Next_Rep_Item
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aspect_Specification
or else NT (N).Nkind = N_Attribute_Definition_Clause
or else NT (N).Nkind = N_Enumeration_Representation_Clause
or else NT (N).Nkind = N_Pragma
or else NT (N).Nkind = N_Record_Representation_Clause);
return Node5 (N);
end Next_Rep_Item;
function Next_Use_Clause
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Use_Package_Clause
or else NT (N).Nkind = N_Use_Type_Clause);
return Node3 (N);
end Next_Use_Clause;
function No_Ctrl_Actions
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Assignment_Statement);
return Flag7 (N);
end No_Ctrl_Actions;
function No_Elaboration_Check
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Function_Call
or else NT (N).Nkind = N_Procedure_Call_Statement);
return Flag14 (N);
end No_Elaboration_Check;
function No_Entities_Ref_In_Spec
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
return Flag8 (N);
end No_Entities_Ref_In_Spec;
function No_Initialization
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Allocator
or else NT (N).Nkind = N_Object_Declaration);
return Flag13 (N);
end No_Initialization;
function No_Minimize_Eliminate
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_In
or else NT (N).Nkind = N_Not_In);
return Flag17 (N);
end No_Minimize_Eliminate;
function No_Truncation
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Unchecked_Type_Conversion);
return Flag17 (N);
end No_Truncation;
function Non_Aliased_Prefix
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Attribute_Reference);
return Flag18 (N);
end Non_Aliased_Prefix;
function Null_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_List
or else NT (N).Nkind = N_Procedure_Specification
or else NT (N).Nkind = N_Record_Definition);
return Flag13 (N);
end Null_Present;
function Null_Excluding_Subtype
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Access_To_Object_Definition);
return Flag16 (N);
end Null_Excluding_Subtype;
function Null_Exclusion_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Access_Definition
or else NT (N).Nkind = N_Access_Function_Definition
or else NT (N).Nkind = N_Access_Procedure_Definition
or else NT (N).Nkind = N_Access_To_Object_Definition
or else NT (N).Nkind = N_Allocator
or else NT (N).Nkind = N_Component_Definition
or else NT (N).Nkind = N_Derived_Type_Definition
or else NT (N).Nkind = N_Discriminant_Specification
or else NT (N).Nkind = N_Formal_Object_Declaration
or else NT (N).Nkind = N_Function_Specification
or else NT (N).Nkind = N_Object_Declaration
or else NT (N).Nkind = N_Object_Renaming_Declaration
or else NT (N).Nkind = N_Parameter_Specification
or else NT (N).Nkind = N_Subtype_Declaration);
return Flag11 (N);
end Null_Exclusion_Present;
function Null_Exclusion_In_Return_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Access_Function_Definition);
return Flag14 (N);
end Null_Exclusion_In_Return_Present;
function Null_Record_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aggregate
or else NT (N).Nkind = N_Extension_Aggregate);
return Flag17 (N);
end Null_Record_Present;
function Object_Definition
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Object_Declaration);
return Node4 (N);
end Object_Definition;
function Of_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Iterator_Specification);
return Flag16 (N);
end Of_Present;
function Original_Discriminant
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Identifier);
return Node2 (N);
end Original_Discriminant;
function Original_Entity
(N : Node_Id) return Entity_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Integer_Literal
or else NT (N).Nkind = N_Real_Literal);
return Node2 (N);
end Original_Entity;
function Others_Discrete_Choices
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Others_Choice);
return List1 (N);
end Others_Discrete_Choices;
function Out_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Object_Declaration
or else NT (N).Nkind = N_Parameter_Specification);
return Flag17 (N);
end Out_Present;
function Parameter_Associations
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Entry_Call_Statement
or else NT (N).Nkind = N_Function_Call
or else NT (N).Nkind = N_Procedure_Call_Statement);
return List3 (N);
end Parameter_Associations;
function Parameter_Specifications
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Accept_Statement
or else NT (N).Nkind = N_Access_Function_Definition
or else NT (N).Nkind = N_Access_Procedure_Definition
or else NT (N).Nkind = N_Entry_Body_Formal_Part
or else NT (N).Nkind = N_Entry_Declaration
or else NT (N).Nkind = N_Function_Specification
or else NT (N).Nkind = N_Procedure_Specification);
return List3 (N);
end Parameter_Specifications;
function Parameter_Type
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Parameter_Specification);
return Node2 (N);
end Parameter_Type;
function Parent_Spec
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Function_Instantiation
or else NT (N).Nkind = N_Generic_Function_Renaming_Declaration
or else NT (N).Nkind = N_Generic_Package_Declaration
or else NT (N).Nkind = N_Generic_Package_Renaming_Declaration
or else NT (N).Nkind = N_Generic_Procedure_Renaming_Declaration
or else NT (N).Nkind = N_Generic_Subprogram_Declaration
or else NT (N).Nkind = N_Package_Declaration
or else NT (N).Nkind = N_Package_Instantiation
or else NT (N).Nkind = N_Package_Renaming_Declaration
or else NT (N).Nkind = N_Procedure_Instantiation
or else NT (N).Nkind = N_Subprogram_Declaration
or else NT (N).Nkind = N_Subprogram_Renaming_Declaration);
return Node4 (N);
end Parent_Spec;
function Position
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Clause);
return Node2 (N);
end Position;
function Pragma_Argument_Associations
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Pragma);
return List2 (N);
end Pragma_Argument_Associations;
function Pragma_Identifier
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Pragma);
return Node4 (N);
end Pragma_Identifier;
function Pragmas_After
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit_Aux
or else NT (N).Nkind = N_Terminate_Alternative);
return List5 (N);
end Pragmas_After;
function Pragmas_Before
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Accept_Alternative
or else NT (N).Nkind = N_Delay_Alternative
or else NT (N).Nkind = N_Entry_Call_Alternative
or else NT (N).Nkind = N_Mod_Clause
or else NT (N).Nkind = N_Terminate_Alternative
or else NT (N).Nkind = N_Triggering_Alternative);
return List4 (N);
end Pragmas_Before;
function Pre_Post_Conditions
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Contract);
return Node1 (N);
end Pre_Post_Conditions;
function Prefix
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Attribute_Reference
or else NT (N).Nkind = N_Expanded_Name
or else NT (N).Nkind = N_Explicit_Dereference
or else NT (N).Nkind = N_Indexed_Component
or else NT (N).Nkind = N_Reference
or else NT (N).Nkind = N_Selected_Component
or else NT (N).Nkind = N_Slice);
return Node3 (N);
end Prefix;
function Premature_Use
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Incomplete_Type_Declaration);
return Node5 (N);
end Premature_Use;
function Present_Expr
(N : Node_Id) return Uint is
begin
pragma Assert (False
or else NT (N).Nkind = N_Variant);
return Uint3 (N);
end Present_Expr;
function Prev_Ids
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Declaration
or else NT (N).Nkind = N_Discriminant_Specification
or else NT (N).Nkind = N_Exception_Declaration
or else NT (N).Nkind = N_Formal_Object_Declaration
or else NT (N).Nkind = N_Number_Declaration
or else NT (N).Nkind = N_Object_Declaration
or else NT (N).Nkind = N_Parameter_Specification);
return Flag6 (N);
end Prev_Ids;
function Print_In_Hex
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Integer_Literal);
return Flag13 (N);
end Print_In_Hex;
function Private_Declarations
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Package_Specification
or else NT (N).Nkind = N_Protected_Definition
or else NT (N).Nkind = N_Task_Definition);
return List3 (N);
end Private_Declarations;
function Private_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit
or else NT (N).Nkind = N_Formal_Derived_Type_Definition
or else NT (N).Nkind = N_With_Clause);
return Flag15 (N);
end Private_Present;
function Procedure_To_Call
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Allocator
or else NT (N).Nkind = N_Extended_Return_Statement
or else NT (N).Nkind = N_Free_Statement
or else NT (N).Nkind = N_Simple_Return_Statement);
return Node2 (N);
end Procedure_To_Call;
function Proper_Body
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subunit);
return Node1 (N);
end Proper_Body;
function Protected_Definition
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Protected_Type_Declaration
or else NT (N).Nkind = N_Single_Protected_Declaration);
return Node3 (N);
end Protected_Definition;
function Protected_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Access_Function_Definition
or else NT (N).Nkind = N_Access_Procedure_Definition
or else NT (N).Nkind = N_Derived_Type_Definition
or else NT (N).Nkind = N_Record_Definition);
return Flag6 (N);
end Protected_Present;
function Raises_Constraint_Error
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind in N_Subexpr);
return Flag7 (N);
end Raises_Constraint_Error;
function Range_Constraint
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Delta_Constraint
or else NT (N).Nkind = N_Digits_Constraint);
return Node4 (N);
end Range_Constraint;
function Range_Expression
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Range_Constraint);
return Node4 (N);
end Range_Expression;
function Real_Range_Specification
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Decimal_Fixed_Point_Definition
or else NT (N).Nkind = N_Floating_Point_Definition
or else NT (N).Nkind = N_Ordinary_Fixed_Point_Definition);
return Node4 (N);
end Real_Range_Specification;
function Realval
(N : Node_Id) return Ureal is
begin
pragma Assert (False
or else NT (N).Nkind = N_Real_Literal);
return Ureal3 (N);
end Realval;
function Reason
(N : Node_Id) return Uint is
begin
pragma Assert (False
or else NT (N).Nkind = N_Raise_Constraint_Error
or else NT (N).Nkind = N_Raise_Program_Error
or else NT (N).Nkind = N_Raise_Storage_Error);
return Uint3 (N);
end Reason;
function Record_Extension_Part
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Derived_Type_Definition);
return Node3 (N);
end Record_Extension_Part;
function Redundant_Use
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Attribute_Reference
or else NT (N).Nkind = N_Expanded_Name
or else NT (N).Nkind = N_Identifier);
return Flag13 (N);
end Redundant_Use;
function Renaming_Exception
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Exception_Declaration);
return Node2 (N);
end Renaming_Exception;
function Result_Definition
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Access_Function_Definition
or else NT (N).Nkind = N_Function_Specification);
return Node4 (N);
end Result_Definition;
function Return_Object_Declarations
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Extended_Return_Statement);
return List3 (N);
end Return_Object_Declarations;
function Return_Statement_Entity
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Extended_Return_Statement
or else NT (N).Nkind = N_Simple_Return_Statement);
return Node5 (N);
end Return_Statement_Entity;
function Reverse_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Iterator_Specification
or else NT (N).Nkind = N_Loop_Parameter_Specification);
return Flag15 (N);
end Reverse_Present;
function Right_Opnd
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind in N_Op
or else NT (N).Nkind = N_And_Then
or else NT (N).Nkind = N_In
or else NT (N).Nkind = N_Not_In
or else NT (N).Nkind = N_Or_Else);
return Node3 (N);
end Right_Opnd;
function Rounded_Result
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Op_Divide
or else NT (N).Nkind = N_Op_Multiply
or else NT (N).Nkind = N_Type_Conversion);
return Flag18 (N);
end Rounded_Result;
function SCIL_Controlling_Tag
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_SCIL_Dispatching_Call);
return Node5 (N);
end SCIL_Controlling_Tag;
function SCIL_Entity
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_SCIL_Dispatch_Table_Tag_Init
or else NT (N).Nkind = N_SCIL_Dispatching_Call
or else NT (N).Nkind = N_SCIL_Membership_Test);
return Node4 (N);
end SCIL_Entity;
function SCIL_Tag_Value
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_SCIL_Membership_Test);
return Node5 (N);
end SCIL_Tag_Value;
function SCIL_Target_Prim
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_SCIL_Dispatching_Call);
return Node2 (N);
end SCIL_Target_Prim;
function Scope
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Defining_Character_Literal
or else NT (N).Nkind = N_Defining_Identifier
or else NT (N).Nkind = N_Defining_Operator_Symbol);
return Node3 (N);
end Scope;
function Select_Alternatives
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Selective_Accept);
return List1 (N);
end Select_Alternatives;
function Selector_Name
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Expanded_Name
or else NT (N).Nkind = N_Generic_Association
or else NT (N).Nkind = N_Parameter_Association
or else NT (N).Nkind = N_Selected_Component);
return Node2 (N);
end Selector_Name;
function Selector_Names
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Discriminant_Association);
return List1 (N);
end Selector_Names;
function Shift_Count_OK
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Op_Rotate_Left
or else NT (N).Nkind = N_Op_Rotate_Right
or else NT (N).Nkind = N_Op_Shift_Left
or else NT (N).Nkind = N_Op_Shift_Right
or else NT (N).Nkind = N_Op_Shift_Right_Arithmetic);
return Flag4 (N);
end Shift_Count_OK;
function Source_Type
(N : Node_Id) return Entity_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Validate_Unchecked_Conversion);
return Node1 (N);
end Source_Type;
function Specification
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Abstract_Subprogram_Declaration
or else NT (N).Nkind = N_Expression_Function
or else NT (N).Nkind = N_Formal_Abstract_Subprogram_Declaration
or else NT (N).Nkind = N_Formal_Concrete_Subprogram_Declaration
or else NT (N).Nkind = N_Generic_Package_Declaration
or else NT (N).Nkind = N_Generic_Subprogram_Declaration
or else NT (N).Nkind = N_Package_Declaration
or else NT (N).Nkind = N_Subprogram_Body
or else NT (N).Nkind = N_Subprogram_Body_Stub
or else NT (N).Nkind = N_Subprogram_Declaration
or else NT (N).Nkind = N_Subprogram_Renaming_Declaration);
return Node1 (N);
end Specification;
function Split_PPC
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aspect_Specification
or else NT (N).Nkind = N_Pragma);
return Flag17 (N);
end Split_PPC;
function Statements
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Abortable_Part
or else NT (N).Nkind = N_Accept_Alternative
or else NT (N).Nkind = N_Case_Statement_Alternative
or else NT (N).Nkind = N_Delay_Alternative
or else NT (N).Nkind = N_Entry_Call_Alternative
or else NT (N).Nkind = N_Exception_Handler
or else NT (N).Nkind = N_Handled_Sequence_Of_Statements
or else NT (N).Nkind = N_Loop_Statement
or else NT (N).Nkind = N_Triggering_Alternative);
return List3 (N);
end Statements;
function Storage_Pool
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Allocator
or else NT (N).Nkind = N_Extended_Return_Statement
or else NT (N).Nkind = N_Free_Statement
or else NT (N).Nkind = N_Simple_Return_Statement);
return Node1 (N);
end Storage_Pool;
function Subpool_Handle_Name
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Allocator);
return Node4 (N);
end Subpool_Handle_Name;
function Strval
(N : Node_Id) return String_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Operator_Symbol
or else NT (N).Nkind = N_String_Literal);
return Str3 (N);
end Strval;
function Subtype_Indication
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Access_To_Object_Definition
or else NT (N).Nkind = N_Component_Definition
or else NT (N).Nkind = N_Derived_Type_Definition
or else NT (N).Nkind = N_Iterator_Specification
or else NT (N).Nkind = N_Private_Extension_Declaration
or else NT (N).Nkind = N_Subtype_Declaration);
return Node5 (N);
end Subtype_Indication;
function Suppress_Assignment_Checks
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Assignment_Statement
or else NT (N).Nkind = N_Object_Declaration);
return Flag18 (N);
end Suppress_Assignment_Checks;
function Suppress_Loop_Warnings
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Loop_Statement);
return Flag17 (N);
end Suppress_Loop_Warnings;
function Subtype_Mark
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Access_Definition
or else NT (N).Nkind = N_Formal_Derived_Type_Definition
or else NT (N).Nkind = N_Formal_Object_Declaration
or else NT (N).Nkind = N_Object_Renaming_Declaration
or else NT (N).Nkind = N_Qualified_Expression
or else NT (N).Nkind = N_Subtype_Indication
or else NT (N).Nkind = N_Type_Conversion
or else NT (N).Nkind = N_Unchecked_Type_Conversion);
return Node4 (N);
end Subtype_Mark;
function Subtype_Marks
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Unconstrained_Array_Definition
or else NT (N).Nkind = N_Use_Type_Clause);
return List2 (N);
end Subtype_Marks;
function Synchronized_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Derived_Type_Definition
or else NT (N).Nkind = N_Formal_Derived_Type_Definition
or else NT (N).Nkind = N_Private_Extension_Declaration
or else NT (N).Nkind = N_Record_Definition);
return Flag7 (N);
end Synchronized_Present;
function Tagged_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Incomplete_Type_Definition
or else NT (N).Nkind = N_Formal_Private_Type_Definition
or else NT (N).Nkind = N_Incomplete_Type_Declaration
or else NT (N).Nkind = N_Private_Type_Declaration
or else NT (N).Nkind = N_Record_Definition);
return Flag15 (N);
end Tagged_Present;
function Target_Type
(N : Node_Id) return Entity_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Validate_Unchecked_Conversion);
return Node2 (N);
end Target_Type;
function Task_Definition
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Single_Task_Declaration
or else NT (N).Nkind = N_Task_Type_Declaration);
return Node3 (N);
end Task_Definition;
function Task_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Derived_Type_Definition
or else NT (N).Nkind = N_Record_Definition);
return Flag5 (N);
end Task_Present;
function Then_Actions
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_If_Expression);
return List2 (N);
end Then_Actions;
function Then_Statements
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Elsif_Part
or else NT (N).Nkind = N_If_Statement);
return List2 (N);
end Then_Statements;
function Treat_Fixed_As_Integer
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Op_Divide
or else NT (N).Nkind = N_Op_Mod
or else NT (N).Nkind = N_Op_Multiply
or else NT (N).Nkind = N_Op_Rem);
return Flag14 (N);
end Treat_Fixed_As_Integer;
function Triggering_Alternative
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Asynchronous_Select);
return Node1 (N);
end Triggering_Alternative;
function Triggering_Statement
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Triggering_Alternative);
return Node1 (N);
end Triggering_Statement;
function TSS_Elist
(N : Node_Id) return Elist_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Freeze_Entity);
return Elist3 (N);
end TSS_Elist;
function Type_Definition
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Full_Type_Declaration);
return Node3 (N);
end Type_Definition;
function Uneval_Old_Accept
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Pragma);
return Flag7 (N);
end Uneval_Old_Accept;
function Uneval_Old_Warn
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Pragma);
return Flag18 (N);
end Uneval_Old_Warn;
function Unit
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit);
return Node2 (N);
end Unit;
function Unknown_Discriminants_Present
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Type_Declaration
or else NT (N).Nkind = N_Incomplete_Type_Declaration
or else NT (N).Nkind = N_Private_Extension_Declaration
or else NT (N).Nkind = N_Private_Type_Declaration);
return Flag13 (N);
end Unknown_Discriminants_Present;
function Unreferenced_In_Spec
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
return Flag7 (N);
end Unreferenced_In_Spec;
function Variant_Part
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_List);
return Node4 (N);
end Variant_Part;
function Variants
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Variant_Part);
return List1 (N);
end Variants;
function Visible_Declarations
(N : Node_Id) return List_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Package_Specification
or else NT (N).Nkind = N_Protected_Definition
or else NT (N).Nkind = N_Task_Definition);
return List2 (N);
end Visible_Declarations;
function Uninitialized_Variable
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Private_Type_Definition
or else NT (N).Nkind = N_Private_Extension_Declaration);
return Node3 (N);
end Uninitialized_Variable;
function Used_Operations
(N : Node_Id) return Elist_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_Use_Type_Clause);
return Elist5 (N);
end Used_Operations;
function Was_Originally_Stub
(N : Node_Id) return Boolean is
begin
pragma Assert (False
or else NT (N).Nkind = N_Package_Body
or else NT (N).Nkind = N_Protected_Body
or else NT (N).Nkind = N_Subprogram_Body
or else NT (N).Nkind = N_Task_Body);
return Flag13 (N);
end Was_Originally_Stub;
function Withed_Body
(N : Node_Id) return Node_Id is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
return Node1 (N);
end Withed_Body;
--------------------------
-- Field Set Procedures --
--------------------------
procedure Set_ABE_Is_Certain
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Package_Declaration
or else NT (N).Nkind = N_Function_Call
or else NT (N).Nkind = N_Function_Instantiation
or else NT (N).Nkind = N_Package_Instantiation
or else NT (N).Nkind = N_Procedure_Call_Statement
or else NT (N).Nkind = N_Procedure_Instantiation);
Set_Flag18 (N, Val);
end Set_ABE_Is_Certain;
procedure Set_Abort_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Requeue_Statement);
Set_Flag15 (N, Val);
end Set_Abort_Present;
procedure Set_Abortable_Part
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Asynchronous_Select);
Set_Node2_With_Parent (N, Val);
end Set_Abortable_Part;
procedure Set_Abstract_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Derived_Type_Definition
or else NT (N).Nkind = N_Formal_Derived_Type_Definition
or else NT (N).Nkind = N_Formal_Private_Type_Definition
or else NT (N).Nkind = N_Private_Extension_Declaration
or else NT (N).Nkind = N_Private_Type_Declaration
or else NT (N).Nkind = N_Record_Definition);
Set_Flag4 (N, Val);
end Set_Abstract_Present;
procedure Set_Accept_Handler_Records
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Accept_Alternative);
Set_List5 (N, Val); -- semantic field, no parent set
end Set_Accept_Handler_Records;
procedure Set_Accept_Statement
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Accept_Alternative);
Set_Node2_With_Parent (N, Val);
end Set_Accept_Statement;
procedure Set_Access_Definition
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Definition
or else NT (N).Nkind = N_Formal_Object_Declaration
or else NT (N).Nkind = N_Object_Renaming_Declaration);
Set_Node3_With_Parent (N, Val);
end Set_Access_Definition;
procedure Set_Access_To_Subprogram_Definition
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Access_Definition);
Set_Node3_With_Parent (N, Val);
end Set_Access_To_Subprogram_Definition;
procedure Set_Access_Types_To_Process
(N : Node_Id; Val : Elist_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Freeze_Entity);
Set_Elist2 (N, Val); -- semantic field, no parent set
end Set_Access_Types_To_Process;
procedure Set_Actions
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_And_Then
or else NT (N).Nkind = N_Case_Expression_Alternative
or else NT (N).Nkind = N_Compilation_Unit_Aux
or else NT (N).Nkind = N_Compound_Statement
or else NT (N).Nkind = N_Expression_With_Actions
or else NT (N).Nkind = N_Freeze_Entity
or else NT (N).Nkind = N_Or_Else);
Set_List1_With_Parent (N, Val);
end Set_Actions;
procedure Set_Activation_Chain_Entity
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Block_Statement
or else NT (N).Nkind = N_Entry_Body
or else NT (N).Nkind = N_Generic_Package_Declaration
or else NT (N).Nkind = N_Package_Declaration
or else NT (N).Nkind = N_Subprogram_Body
or else NT (N).Nkind = N_Task_Body);
Set_Node3 (N, Val); -- semantic field, no parent set
end Set_Activation_Chain_Entity;
procedure Set_Acts_As_Spec
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit
or else NT (N).Nkind = N_Subprogram_Body);
Set_Flag4 (N, Val);
end Set_Acts_As_Spec;
procedure Set_Actual_Designated_Subtype
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Explicit_Dereference
or else NT (N).Nkind = N_Free_Statement);
Set_Node4 (N, Val);
end Set_Actual_Designated_Subtype;
procedure Set_Address_Warning_Posted
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Attribute_Definition_Clause);
Set_Flag18 (N, Val);
end Set_Address_Warning_Posted;
procedure Set_Aggregate_Bounds
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aggregate);
Set_Node3 (N, Val); -- semantic field, no parent set
end Set_Aggregate_Bounds;
procedure Set_Aliased_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Definition
or else NT (N).Nkind = N_Object_Declaration
or else NT (N).Nkind = N_Parameter_Specification);
Set_Flag4 (N, Val);
end Set_Aliased_Present;
procedure Set_All_Others
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Others_Choice);
Set_Flag11 (N, Val);
end Set_All_Others;
procedure Set_All_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Access_Definition
or else NT (N).Nkind = N_Access_To_Object_Definition
or else NT (N).Nkind = N_Quantified_Expression
or else NT (N).Nkind = N_Use_Type_Clause);
Set_Flag15 (N, Val);
end Set_All_Present;
procedure Set_Alternatives
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Case_Expression
or else NT (N).Nkind = N_Case_Statement
or else NT (N).Nkind = N_In
or else NT (N).Nkind = N_Not_In);
Set_List4_With_Parent (N, Val);
end Set_Alternatives;
procedure Set_Ancestor_Part
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Extension_Aggregate);
Set_Node3_With_Parent (N, Val);
end Set_Ancestor_Part;
procedure Set_Atomic_Sync_Required
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Expanded_Name
or else NT (N).Nkind = N_Explicit_Dereference
or else NT (N).Nkind = N_Identifier
or else NT (N).Nkind = N_Indexed_Component
or else NT (N).Nkind = N_Selected_Component);
Set_Flag14 (N, Val);
end Set_Atomic_Sync_Required;
procedure Set_Array_Aggregate
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Enumeration_Representation_Clause);
Set_Node3_With_Parent (N, Val);
end Set_Array_Aggregate;
procedure Set_Aspect_Rep_Item
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aspect_Specification);
Set_Node2 (N, Val);
end Set_Aspect_Rep_Item;
procedure Set_Assignment_OK
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Object_Declaration
or else NT (N).Nkind in N_Subexpr);
Set_Flag15 (N, Val);
end Set_Assignment_OK;
procedure Set_Associated_Node
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind in N_Has_Entity
or else NT (N).Nkind = N_Aggregate
or else NT (N).Nkind = N_Extension_Aggregate
or else NT (N).Nkind = N_Selected_Component);
Set_Node4 (N, Val); -- semantic field, no parent set
end Set_Associated_Node;
procedure Set_At_End_Proc
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Handled_Sequence_Of_Statements);
Set_Node1 (N, Val);
end Set_At_End_Proc;
procedure Set_Attribute_Name
(N : Node_Id; Val : Name_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Attribute_Reference);
Set_Name2 (N, Val);
end Set_Attribute_Name;
procedure Set_Aux_Decls_Node
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit);
Set_Node5_With_Parent (N, Val);
end Set_Aux_Decls_Node;
procedure Set_Backwards_OK
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Assignment_Statement);
Set_Flag6 (N, Val);
end Set_Backwards_OK;
procedure Set_Bad_Is_Detected
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subprogram_Body);
Set_Flag15 (N, Val);
end Set_Bad_Is_Detected;
procedure Set_Body_Required
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit);
Set_Flag13 (N, Val);
end Set_Body_Required;
procedure Set_Body_To_Inline
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subprogram_Declaration);
Set_Node3 (N, Val);
end Set_Body_To_Inline;
procedure Set_Box_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Association
or else NT (N).Nkind = N_Formal_Abstract_Subprogram_Declaration
or else NT (N).Nkind = N_Formal_Concrete_Subprogram_Declaration
or else NT (N).Nkind = N_Formal_Package_Declaration
or else NT (N).Nkind = N_Generic_Association);
Set_Flag15 (N, Val);
end Set_Box_Present;
procedure Set_By_Ref
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Extended_Return_Statement
or else NT (N).Nkind = N_Simple_Return_Statement);
Set_Flag5 (N, Val);
end Set_By_Ref;
procedure Set_Char_Literal_Value
(N : Node_Id; Val : Uint) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Character_Literal);
Set_Uint2 (N, Val);
end Set_Char_Literal_Value;
procedure Set_Chars
(N : Node_Id; Val : Name_Id) is
begin
pragma Assert (False
or else NT (N).Nkind in N_Has_Chars);
Set_Name1 (N, Val);
end Set_Chars;
procedure Set_Check_Address_Alignment
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Attribute_Definition_Clause);
Set_Flag11 (N, Val);
end Set_Check_Address_Alignment;
procedure Set_Choice_Parameter
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Exception_Handler);
Set_Node2_With_Parent (N, Val);
end Set_Choice_Parameter;
procedure Set_Choices
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Association);
Set_List1_With_Parent (N, Val);
end Set_Choices;
procedure Set_Class_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aspect_Specification
or else NT (N).Nkind = N_Pragma);
Set_Flag6 (N, Val);
end Set_Class_Present;
procedure Set_Classifications
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Contract);
Set_Node3 (N, Val); -- semantic field, no parent set
end Set_Classifications;
procedure Set_Cleanup_Actions
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Block_Statement);
Set_List5 (N, Val); -- semantic field, no parent set
end Set_Cleanup_Actions;
procedure Set_Comes_From_Extended_Return_Statement
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Simple_Return_Statement);
Set_Flag18 (N, Val);
end Set_Comes_From_Extended_Return_Statement;
procedure Set_Compile_Time_Known_Aggregate
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aggregate);
Set_Flag18 (N, Val);
end Set_Compile_Time_Known_Aggregate;
procedure Set_Component_Associations
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aggregate
or else NT (N).Nkind = N_Extension_Aggregate);
Set_List2_With_Parent (N, Val);
end Set_Component_Associations;
procedure Set_Component_Clauses
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Record_Representation_Clause);
Set_List3_With_Parent (N, Val);
end Set_Component_Clauses;
procedure Set_Component_Definition
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Declaration
or else NT (N).Nkind = N_Constrained_Array_Definition
or else NT (N).Nkind = N_Unconstrained_Array_Definition);
Set_Node4_With_Parent (N, Val);
end Set_Component_Definition;
procedure Set_Component_Items
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_List);
Set_List3_With_Parent (N, Val);
end Set_Component_Items;
procedure Set_Component_List
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Record_Definition
or else NT (N).Nkind = N_Variant);
Set_Node1_With_Parent (N, Val);
end Set_Component_List;
procedure Set_Component_Name
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Clause);
Set_Node1_With_Parent (N, Val);
end Set_Component_Name;
procedure Set_Componentwise_Assignment
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Assignment_Statement);
Set_Flag14 (N, Val);
end Set_Componentwise_Assignment;
procedure Set_Condition
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Accept_Alternative
or else NT (N).Nkind = N_Delay_Alternative
or else NT (N).Nkind = N_Elsif_Part
or else NT (N).Nkind = N_Entry_Body_Formal_Part
or else NT (N).Nkind = N_Exit_Statement
or else NT (N).Nkind = N_If_Statement
or else NT (N).Nkind = N_Iteration_Scheme
or else NT (N).Nkind = N_Quantified_Expression
or else NT (N).Nkind = N_Raise_Constraint_Error
or else NT (N).Nkind = N_Raise_Program_Error
or else NT (N).Nkind = N_Raise_Storage_Error
or else NT (N).Nkind = N_Terminate_Alternative);
Set_Node1_With_Parent (N, Val);
end Set_Condition;
procedure Set_Condition_Actions
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Elsif_Part
or else NT (N).Nkind = N_Iteration_Scheme);
Set_List3 (N, Val); -- semantic field, no parent set
end Set_Condition_Actions;
procedure Set_Config_Pragmas
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit_Aux);
Set_List4_With_Parent (N, Val);
end Set_Config_Pragmas;
procedure Set_Constant_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Access_Definition
or else NT (N).Nkind = N_Access_To_Object_Definition
or else NT (N).Nkind = N_Object_Declaration);
Set_Flag17 (N, Val);
end Set_Constant_Present;
procedure Set_Constraint
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subtype_Indication);
Set_Node3_With_Parent (N, Val);
end Set_Constraint;
procedure Set_Constraints
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Index_Or_Discriminant_Constraint);
Set_List1_With_Parent (N, Val);
end Set_Constraints;
procedure Set_Context_Installed
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
Set_Flag13 (N, Val);
end Set_Context_Installed;
procedure Set_Context_Items
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit);
Set_List1_With_Parent (N, Val);
end Set_Context_Items;
procedure Set_Context_Pending
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit);
Set_Flag16 (N, Val);
end Set_Context_Pending;
procedure Set_Contract_Test_Cases
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Contract);
Set_Node2 (N, Val); -- semantic field, no parent set
end Set_Contract_Test_Cases;
procedure Set_Controlling_Argument
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Function_Call
or else NT (N).Nkind = N_Procedure_Call_Statement);
Set_Node1 (N, Val); -- semantic field, no parent set
end Set_Controlling_Argument;
procedure Set_Conversion_OK
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Type_Conversion);
Set_Flag14 (N, Val);
end Set_Conversion_OK;
procedure Set_Convert_To_Return_False
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Raise_Expression);
Set_Flag13 (N, Val);
end Set_Convert_To_Return_False;
procedure Set_Corresponding_Aspect
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Pragma);
Set_Node3 (N, Val);
end Set_Corresponding_Aspect;
procedure Set_Corresponding_Body
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Entry_Declaration
or else NT (N).Nkind = N_Generic_Package_Declaration
or else NT (N).Nkind = N_Generic_Subprogram_Declaration
or else NT (N).Nkind = N_Package_Body_Stub
or else NT (N).Nkind = N_Package_Declaration
or else NT (N).Nkind = N_Protected_Body_Stub
or else NT (N).Nkind = N_Protected_Type_Declaration
or else NT (N).Nkind = N_Subprogram_Body_Stub
or else NT (N).Nkind = N_Subprogram_Declaration
or else NT (N).Nkind = N_Task_Body_Stub
or else NT (N).Nkind = N_Task_Type_Declaration);
Set_Node5 (N, Val); -- semantic field, no parent set
end Set_Corresponding_Body;
procedure Set_Corresponding_Formal_Spec
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subprogram_Renaming_Declaration);
Set_Node3 (N, Val); -- semantic field, no parent set
end Set_Corresponding_Formal_Spec;
procedure Set_Corresponding_Generic_Association
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Object_Declaration
or else NT (N).Nkind = N_Object_Renaming_Declaration);
Set_Node5 (N, Val); -- semantic field, no parent set
end Set_Corresponding_Generic_Association;
procedure Set_Corresponding_Integer_Value
(N : Node_Id; Val : Uint) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Real_Literal);
Set_Uint4 (N, Val); -- semantic field, no parent set
end Set_Corresponding_Integer_Value;
procedure Set_Corresponding_Spec
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Expression_Function
or else NT (N).Nkind = N_Package_Body
or else NT (N).Nkind = N_Protected_Body
or else NT (N).Nkind = N_Subprogram_Body
or else NT (N).Nkind = N_Subprogram_Renaming_Declaration
or else NT (N).Nkind = N_Task_Body
or else NT (N).Nkind = N_With_Clause);
Set_Node5 (N, Val); -- semantic field, no parent set
end Set_Corresponding_Spec;
procedure Set_Corresponding_Spec_Of_Stub
(N : Node_Id; Val : Entity_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Package_Body_Stub
or else NT (N).Nkind = N_Protected_Body_Stub
or else NT (N).Nkind = N_Subprogram_Body_Stub
or else NT (N).Nkind = N_Task_Body_Stub);
Set_Node2 (N, Val); -- semantic field, no parent set
end Set_Corresponding_Spec_Of_Stub;
procedure Set_Corresponding_Stub
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subunit);
Set_Node3 (N, Val);
end Set_Corresponding_Stub;
procedure Set_Dcheck_Function
(N : Node_Id; Val : Entity_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Variant);
Set_Node5 (N, Val); -- semantic field, no parent set
end Set_Dcheck_Function;
procedure Set_Declarations
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Accept_Statement
or else NT (N).Nkind = N_Block_Statement
or else NT (N).Nkind = N_Compilation_Unit_Aux
or else NT (N).Nkind = N_Entry_Body
or else NT (N).Nkind = N_Package_Body
or else NT (N).Nkind = N_Protected_Body
or else NT (N).Nkind = N_Subprogram_Body
or else NT (N).Nkind = N_Task_Body);
Set_List2_With_Parent (N, Val);
end Set_Declarations;
procedure Set_Default_Expression
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Object_Declaration
or else NT (N).Nkind = N_Parameter_Specification);
Set_Node5 (N, Val); -- semantic field, no parent set
end Set_Default_Expression;
procedure Set_Default_Storage_Pool
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit_Aux);
Set_Node3 (N, Val); -- semantic field, no parent set
end Set_Default_Storage_Pool;
procedure Set_Default_Name
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Abstract_Subprogram_Declaration
or else NT (N).Nkind = N_Formal_Concrete_Subprogram_Declaration);
Set_Node2_With_Parent (N, Val);
end Set_Default_Name;
procedure Set_Defining_Identifier
(N : Node_Id; Val : Entity_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Declaration
or else NT (N).Nkind = N_Defining_Program_Unit_Name
or else NT (N).Nkind = N_Discriminant_Specification
or else NT (N).Nkind = N_Entry_Body
or else NT (N).Nkind = N_Entry_Declaration
or else NT (N).Nkind = N_Entry_Index_Specification
or else NT (N).Nkind = N_Exception_Declaration
or else NT (N).Nkind = N_Exception_Renaming_Declaration
or else NT (N).Nkind = N_Formal_Object_Declaration
or else NT (N).Nkind = N_Formal_Package_Declaration
or else NT (N).Nkind = N_Formal_Type_Declaration
or else NT (N).Nkind = N_Full_Type_Declaration
or else NT (N).Nkind = N_Implicit_Label_Declaration
or else NT (N).Nkind = N_Incomplete_Type_Declaration
or else NT (N).Nkind = N_Iterator_Specification
or else NT (N).Nkind = N_Loop_Parameter_Specification
or else NT (N).Nkind = N_Number_Declaration
or else NT (N).Nkind = N_Object_Declaration
or else NT (N).Nkind = N_Object_Renaming_Declaration
or else NT (N).Nkind = N_Package_Body_Stub
or else NT (N).Nkind = N_Parameter_Specification
or else NT (N).Nkind = N_Private_Extension_Declaration
or else NT (N).Nkind = N_Private_Type_Declaration
or else NT (N).Nkind = N_Protected_Body
or else NT (N).Nkind = N_Protected_Body_Stub
or else NT (N).Nkind = N_Protected_Type_Declaration
or else NT (N).Nkind = N_Single_Protected_Declaration
or else NT (N).Nkind = N_Single_Task_Declaration
or else NT (N).Nkind = N_Subtype_Declaration
or else NT (N).Nkind = N_Task_Body
or else NT (N).Nkind = N_Task_Body_Stub
or else NT (N).Nkind = N_Task_Type_Declaration);
Set_Node1_With_Parent (N, Val);
end Set_Defining_Identifier;
procedure Set_Defining_Unit_Name
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Function_Instantiation
or else NT (N).Nkind = N_Function_Specification
or else NT (N).Nkind = N_Generic_Function_Renaming_Declaration
or else NT (N).Nkind = N_Generic_Package_Renaming_Declaration
or else NT (N).Nkind = N_Generic_Procedure_Renaming_Declaration
or else NT (N).Nkind = N_Package_Body
or else NT (N).Nkind = N_Package_Instantiation
or else NT (N).Nkind = N_Package_Renaming_Declaration
or else NT (N).Nkind = N_Package_Specification
or else NT (N).Nkind = N_Procedure_Instantiation
or else NT (N).Nkind = N_Procedure_Specification);
Set_Node1_With_Parent (N, Val);
end Set_Defining_Unit_Name;
procedure Set_Delay_Alternative
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Timed_Entry_Call);
Set_Node4_With_Parent (N, Val);
end Set_Delay_Alternative;
procedure Set_Delay_Statement
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Delay_Alternative);
Set_Node2_With_Parent (N, Val);
end Set_Delay_Statement;
procedure Set_Delta_Expression
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Decimal_Fixed_Point_Definition
or else NT (N).Nkind = N_Delta_Constraint
or else NT (N).Nkind = N_Ordinary_Fixed_Point_Definition);
Set_Node3_With_Parent (N, Val);
end Set_Delta_Expression;
procedure Set_Digits_Expression
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Decimal_Fixed_Point_Definition
or else NT (N).Nkind = N_Digits_Constraint
or else NT (N).Nkind = N_Floating_Point_Definition);
Set_Node2_With_Parent (N, Val);
end Set_Digits_Expression;
procedure Set_Discr_Check_Funcs_Built
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Full_Type_Declaration);
Set_Flag11 (N, Val);
end Set_Discr_Check_Funcs_Built;
procedure Set_Discrete_Choices
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Case_Expression_Alternative
or else NT (N).Nkind = N_Case_Statement_Alternative
or else NT (N).Nkind = N_Variant);
Set_List4_With_Parent (N, Val);
end Set_Discrete_Choices;
procedure Set_Discrete_Range
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Slice);
Set_Node4_With_Parent (N, Val);
end Set_Discrete_Range;
procedure Set_Discrete_Subtype_Definition
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Entry_Declaration
or else NT (N).Nkind = N_Entry_Index_Specification
or else NT (N).Nkind = N_Loop_Parameter_Specification);
Set_Node4_With_Parent (N, Val);
end Set_Discrete_Subtype_Definition;
procedure Set_Discrete_Subtype_Definitions
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Constrained_Array_Definition);
Set_List2_With_Parent (N, Val);
end Set_Discrete_Subtype_Definitions;
procedure Set_Discriminant_Specifications
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Type_Declaration
or else NT (N).Nkind = N_Full_Type_Declaration
or else NT (N).Nkind = N_Incomplete_Type_Declaration
or else NT (N).Nkind = N_Private_Extension_Declaration
or else NT (N).Nkind = N_Private_Type_Declaration
or else NT (N).Nkind = N_Protected_Type_Declaration
or else NT (N).Nkind = N_Task_Type_Declaration);
Set_List4_With_Parent (N, Val);
end Set_Discriminant_Specifications;
procedure Set_Discriminant_Type
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Discriminant_Specification);
Set_Node5_With_Parent (N, Val);
end Set_Discriminant_Type;
procedure Set_Do_Accessibility_Check
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Parameter_Specification);
Set_Flag13 (N, Val);
end Set_Do_Accessibility_Check;
procedure Set_Do_Discriminant_Check
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Assignment_Statement
or else NT (N).Nkind = N_Selected_Component
or else NT (N).Nkind = N_Type_Conversion);
Set_Flag1 (N, Val);
end Set_Do_Discriminant_Check;
procedure Set_Do_Division_Check
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Op_Divide
or else NT (N).Nkind = N_Op_Mod
or else NT (N).Nkind = N_Op_Rem);
Set_Flag13 (N, Val);
end Set_Do_Division_Check;
procedure Set_Do_Length_Check
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Assignment_Statement
or else NT (N).Nkind = N_Op_And
or else NT (N).Nkind = N_Op_Or
or else NT (N).Nkind = N_Op_Xor
or else NT (N).Nkind = N_Type_Conversion);
Set_Flag4 (N, Val);
end Set_Do_Length_Check;
procedure Set_Do_Overflow_Check
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind in N_Op
or else NT (N).Nkind = N_Attribute_Reference
or else NT (N).Nkind = N_Case_Expression
or else NT (N).Nkind = N_If_Expression
or else NT (N).Nkind = N_Type_Conversion);
Set_Flag17 (N, Val);
end Set_Do_Overflow_Check;
procedure Set_Do_Range_Check
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind in N_Subexpr);
Set_Flag9 (N, Val);
end Set_Do_Range_Check;
procedure Set_Do_Storage_Check
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Allocator
or else NT (N).Nkind = N_Subprogram_Body);
Set_Flag17 (N, Val);
end Set_Do_Storage_Check;
procedure Set_Do_Tag_Check
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Assignment_Statement
or else NT (N).Nkind = N_Extended_Return_Statement
or else NT (N).Nkind = N_Function_Call
or else NT (N).Nkind = N_Procedure_Call_Statement
or else NT (N).Nkind = N_Simple_Return_Statement
or else NT (N).Nkind = N_Type_Conversion);
Set_Flag13 (N, Val);
end Set_Do_Tag_Check;
procedure Set_Elaborate_All_Desirable
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
Set_Flag9 (N, Val);
end Set_Elaborate_All_Desirable;
procedure Set_Elaborate_All_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
Set_Flag14 (N, Val);
end Set_Elaborate_All_Present;
procedure Set_Elaborate_Desirable
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
Set_Flag11 (N, Val);
end Set_Elaborate_Desirable;
procedure Set_Elaborate_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
Set_Flag4 (N, Val);
end Set_Elaborate_Present;
procedure Set_Else_Actions
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_If_Expression);
Set_List3_With_Parent (N, Val); -- semantic field, but needs parents
end Set_Else_Actions;
procedure Set_Else_Statements
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Conditional_Entry_Call
or else NT (N).Nkind = N_If_Statement
or else NT (N).Nkind = N_Selective_Accept);
Set_List4_With_Parent (N, Val);
end Set_Else_Statements;
procedure Set_Elsif_Parts
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_If_Statement);
Set_List3_With_Parent (N, Val);
end Set_Elsif_Parts;
procedure Set_Enclosing_Variant
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Variant);
Set_Node2 (N, Val); -- semantic field, no parent set
end Set_Enclosing_Variant;
procedure Set_End_Label
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Enumeration_Type_Definition
or else NT (N).Nkind = N_Handled_Sequence_Of_Statements
or else NT (N).Nkind = N_Loop_Statement
or else NT (N).Nkind = N_Package_Specification
or else NT (N).Nkind = N_Protected_Body
or else NT (N).Nkind = N_Protected_Definition
or else NT (N).Nkind = N_Record_Definition
or else NT (N).Nkind = N_Task_Definition);
Set_Node4_With_Parent (N, Val);
end Set_End_Label;
procedure Set_End_Span
(N : Node_Id; Val : Uint) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Case_Statement
or else NT (N).Nkind = N_If_Statement);
Set_Uint5 (N, Val);
end Set_End_Span;
procedure Set_Entity
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind in N_Has_Entity
or else NT (N).Nkind = N_Aspect_Specification
or else NT (N).Nkind = N_Attribute_Definition_Clause
or else NT (N).Nkind = N_Freeze_Entity
or else NT (N).Nkind = N_Freeze_Generic_Entity);
Set_Node4 (N, Val); -- semantic field, no parent set
end Set_Entity;
procedure Set_Entry_Body_Formal_Part
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Entry_Body);
Set_Node5_With_Parent (N, Val);
end Set_Entry_Body_Formal_Part;
procedure Set_Entry_Call_Alternative
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Conditional_Entry_Call
or else NT (N).Nkind = N_Timed_Entry_Call);
Set_Node1_With_Parent (N, Val);
end Set_Entry_Call_Alternative;
procedure Set_Entry_Call_Statement
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Entry_Call_Alternative);
Set_Node1_With_Parent (N, Val);
end Set_Entry_Call_Statement;
procedure Set_Entry_Direct_Name
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Accept_Statement);
Set_Node1_With_Parent (N, Val);
end Set_Entry_Direct_Name;
procedure Set_Entry_Index
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Accept_Statement);
Set_Node5_With_Parent (N, Val);
end Set_Entry_Index;
procedure Set_Entry_Index_Specification
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Entry_Body_Formal_Part);
Set_Node4_With_Parent (N, Val);
end Set_Entry_Index_Specification;
procedure Set_Etype
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind in N_Has_Etype);
Set_Node5 (N, Val); -- semantic field, no parent set
end Set_Etype;
procedure Set_Exception_Choices
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Exception_Handler);
Set_List4_With_Parent (N, Val);
end Set_Exception_Choices;
procedure Set_Exception_Handlers
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Handled_Sequence_Of_Statements);
Set_List5_With_Parent (N, Val);
end Set_Exception_Handlers;
procedure Set_Exception_Junk
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Block_Statement
or else NT (N).Nkind = N_Goto_Statement
or else NT (N).Nkind = N_Label
or else NT (N).Nkind = N_Object_Declaration
or else NT (N).Nkind = N_Subtype_Declaration);
Set_Flag8 (N, Val);
end Set_Exception_Junk;
procedure Set_Exception_Label
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Exception_Handler
or else NT (N).Nkind = N_Push_Constraint_Error_Label
or else NT (N).Nkind = N_Push_Program_Error_Label
or else NT (N).Nkind = N_Push_Storage_Error_Label);
Set_Node5 (N, Val); -- semantic field, no parent set
end Set_Exception_Label;
procedure Set_Expansion_Delayed
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aggregate
or else NT (N).Nkind = N_Extension_Aggregate);
Set_Flag11 (N, Val);
end Set_Expansion_Delayed;
procedure Set_Explicit_Actual_Parameter
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Parameter_Association);
Set_Node3_With_Parent (N, Val);
end Set_Explicit_Actual_Parameter;
procedure Set_Explicit_Generic_Actual_Parameter
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Generic_Association);
Set_Node1_With_Parent (N, Val);
end Set_Explicit_Generic_Actual_Parameter;
procedure Set_Expression
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Allocator
or else NT (N).Nkind = N_Aspect_Specification
or else NT (N).Nkind = N_Assignment_Statement
or else NT (N).Nkind = N_At_Clause
or else NT (N).Nkind = N_Attribute_Definition_Clause
or else NT (N).Nkind = N_Case_Expression
or else NT (N).Nkind = N_Case_Expression_Alternative
or else NT (N).Nkind = N_Case_Statement
or else NT (N).Nkind = N_Code_Statement
or else NT (N).Nkind = N_Component_Association
or else NT (N).Nkind = N_Component_Declaration
or else NT (N).Nkind = N_Delay_Relative_Statement
or else NT (N).Nkind = N_Delay_Until_Statement
or else NT (N).Nkind = N_Discriminant_Association
or else NT (N).Nkind = N_Discriminant_Specification
or else NT (N).Nkind = N_Exception_Declaration
or else NT (N).Nkind = N_Expression_Function
or else NT (N).Nkind = N_Expression_With_Actions
or else NT (N).Nkind = N_Free_Statement
or else NT (N).Nkind = N_Mod_Clause
or else NT (N).Nkind = N_Modular_Type_Definition
or else NT (N).Nkind = N_Number_Declaration
or else NT (N).Nkind = N_Object_Declaration
or else NT (N).Nkind = N_Parameter_Specification
or else NT (N).Nkind = N_Pragma_Argument_Association
or else NT (N).Nkind = N_Qualified_Expression
or else NT (N).Nkind = N_Raise_Expression
or else NT (N).Nkind = N_Raise_Statement
or else NT (N).Nkind = N_Simple_Return_Statement
or else NT (N).Nkind = N_Type_Conversion
or else NT (N).Nkind = N_Unchecked_Expression
or else NT (N).Nkind = N_Unchecked_Type_Conversion);
Set_Node3_With_Parent (N, Val);
end Set_Expression;
procedure Set_Expressions
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aggregate
or else NT (N).Nkind = N_Attribute_Reference
or else NT (N).Nkind = N_Extension_Aggregate
or else NT (N).Nkind = N_If_Expression
or else NT (N).Nkind = N_Indexed_Component);
Set_List1_With_Parent (N, Val);
end Set_Expressions;
procedure Set_First_Bit
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Clause);
Set_Node3_With_Parent (N, Val);
end Set_First_Bit;
procedure Set_First_Inlined_Subprogram
(N : Node_Id; Val : Entity_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit);
Set_Node3 (N, Val); -- semantic field, no parent set
end Set_First_Inlined_Subprogram;
procedure Set_First_Name
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
Set_Flag5 (N, Val);
end Set_First_Name;
procedure Set_First_Named_Actual
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Entry_Call_Statement
or else NT (N).Nkind = N_Function_Call
or else NT (N).Nkind = N_Procedure_Call_Statement);
Set_Node4 (N, Val); -- semantic field, no parent set
end Set_First_Named_Actual;
procedure Set_First_Real_Statement
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Handled_Sequence_Of_Statements);
Set_Node2 (N, Val); -- semantic field, no parent set
end Set_First_Real_Statement;
procedure Set_First_Subtype_Link
(N : Node_Id; Val : Entity_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Freeze_Entity);
Set_Node5 (N, Val); -- semantic field, no parent set
end Set_First_Subtype_Link;
procedure Set_Float_Truncate
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Type_Conversion);
Set_Flag11 (N, Val);
end Set_Float_Truncate;
procedure Set_Formal_Type_Definition
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Type_Declaration);
Set_Node3_With_Parent (N, Val);
end Set_Formal_Type_Definition;
procedure Set_Forwards_OK
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Assignment_Statement);
Set_Flag5 (N, Val);
end Set_Forwards_OK;
procedure Set_From_Aspect_Specification
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Attribute_Definition_Clause
or else NT (N).Nkind = N_Pragma);
Set_Flag13 (N, Val);
end Set_From_Aspect_Specification;
procedure Set_From_At_End
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Raise_Statement);
Set_Flag4 (N, Val);
end Set_From_At_End;
procedure Set_From_At_Mod
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Attribute_Definition_Clause);
Set_Flag4 (N, Val);
end Set_From_At_Mod;
procedure Set_From_Conditional_Expression
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Case_Statement
or else NT (N).Nkind = N_If_Statement);
Set_Flag1 (N, Val);
end Set_From_Conditional_Expression;
procedure Set_From_Default
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subprogram_Renaming_Declaration);
Set_Flag6 (N, Val);
end Set_From_Default;
procedure Set_Generalized_Indexing
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Indexed_Component);
Set_Node4 (N, Val);
end Set_Generalized_Indexing;
procedure Set_Generic_Associations
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Package_Declaration
or else NT (N).Nkind = N_Function_Instantiation
or else NT (N).Nkind = N_Package_Instantiation
or else NT (N).Nkind = N_Procedure_Instantiation);
Set_List3_With_Parent (N, Val);
end Set_Generic_Associations;
procedure Set_Generic_Formal_Declarations
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Generic_Package_Declaration
or else NT (N).Nkind = N_Generic_Subprogram_Declaration);
Set_List2_With_Parent (N, Val);
end Set_Generic_Formal_Declarations;
procedure Set_Generic_Parent
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Function_Specification
or else NT (N).Nkind = N_Package_Specification
or else NT (N).Nkind = N_Procedure_Specification);
Set_Node5 (N, Val);
end Set_Generic_Parent;
procedure Set_Generic_Parent_Type
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subtype_Declaration);
Set_Node4 (N, Val);
end Set_Generic_Parent_Type;
procedure Set_Handled_Statement_Sequence
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Accept_Statement
or else NT (N).Nkind = N_Block_Statement
or else NT (N).Nkind = N_Entry_Body
or else NT (N).Nkind = N_Extended_Return_Statement
or else NT (N).Nkind = N_Package_Body
or else NT (N).Nkind = N_Subprogram_Body
or else NT (N).Nkind = N_Task_Body);
Set_Node4_With_Parent (N, Val);
end Set_Handled_Statement_Sequence;
procedure Set_Handler_List_Entry
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Object_Declaration);
Set_Node2 (N, Val);
end Set_Handler_List_Entry;
procedure Set_Has_Created_Identifier
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Block_Statement
or else NT (N).Nkind = N_Loop_Statement);
Set_Flag15 (N, Val);
end Set_Has_Created_Identifier;
procedure Set_Has_Dereference_Action
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Explicit_Dereference);
Set_Flag13 (N, Val);
end Set_Has_Dereference_Action;
procedure Set_Has_Dynamic_Length_Check
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind in N_Subexpr);
Set_Flag10 (N, Val);
end Set_Has_Dynamic_Length_Check;
procedure Set_Has_Dynamic_Range_Check
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subtype_Declaration
or else NT (N).Nkind in N_Subexpr);
Set_Flag12 (N, Val);
end Set_Has_Dynamic_Range_Check;
procedure Set_Has_Init_Expression
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Object_Declaration);
Set_Flag14 (N, Val);
end Set_Has_Init_Expression;
procedure Set_Has_Local_Raise
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Exception_Handler);
Set_Flag8 (N, Val);
end Set_Has_Local_Raise;
procedure Set_Has_No_Elaboration_Code
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit);
Set_Flag17 (N, Val);
end Set_Has_No_Elaboration_Code;
procedure Set_Has_Pragma_Suppress_All
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit);
Set_Flag14 (N, Val);
end Set_Has_Pragma_Suppress_All;
procedure Set_Has_Private_View
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind in N_Op
or else NT (N).Nkind = N_Character_Literal
or else NT (N).Nkind = N_Expanded_Name
or else NT (N).Nkind = N_Identifier
or else NT (N).Nkind = N_Operator_Symbol);
Set_Flag11 (N, Val);
end Set_Has_Private_View;
procedure Set_Has_Relative_Deadline_Pragma
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subprogram_Body
or else NT (N).Nkind = N_Task_Definition);
Set_Flag9 (N, Val);
end Set_Has_Relative_Deadline_Pragma;
procedure Set_Has_Self_Reference
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aggregate
or else NT (N).Nkind = N_Extension_Aggregate);
Set_Flag13 (N, Val);
end Set_Has_Self_Reference;
procedure Set_Has_SP_Choice
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Case_Expression_Alternative
or else NT (N).Nkind = N_Case_Statement_Alternative
or else NT (N).Nkind = N_Variant);
Set_Flag15 (N, Val);
end Set_Has_SP_Choice;
procedure Set_Has_Storage_Size_Pragma
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Task_Definition);
Set_Flag5 (N, Val);
end Set_Has_Storage_Size_Pragma;
procedure Set_Has_Wide_Character
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_String_Literal);
Set_Flag11 (N, Val);
end Set_Has_Wide_Character;
procedure Set_Has_Wide_Wide_Character
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_String_Literal);
Set_Flag13 (N, Val);
end Set_Has_Wide_Wide_Character;
procedure Set_Header_Size_Added
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Attribute_Reference);
Set_Flag11 (N, Val);
end Set_Header_Size_Added;
procedure Set_Hidden_By_Use_Clause
(N : Node_Id; Val : Elist_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Use_Package_Clause
or else NT (N).Nkind = N_Use_Type_Clause);
Set_Elist4 (N, Val);
end Set_Hidden_By_Use_Clause;
procedure Set_High_Bound
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Range
or else NT (N).Nkind = N_Real_Range_Specification
or else NT (N).Nkind = N_Signed_Integer_Type_Definition);
Set_Node2_With_Parent (N, Val);
end Set_High_Bound;
procedure Set_Identifier
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aspect_Specification
or else NT (N).Nkind = N_At_Clause
or else NT (N).Nkind = N_Block_Statement
or else NT (N).Nkind = N_Designator
or else NT (N).Nkind = N_Enumeration_Representation_Clause
or else NT (N).Nkind = N_Label
or else NT (N).Nkind = N_Loop_Statement
or else NT (N).Nkind = N_Record_Representation_Clause);
Set_Node1_With_Parent (N, Val);
end Set_Identifier;
procedure Set_Implicit_With
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
Set_Flag16 (N, Val);
end Set_Implicit_With;
procedure Set_Implicit_With_From_Instantiation
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
Set_Flag12 (N, Val);
end Set_Implicit_With_From_Instantiation;
procedure Set_Interface_List
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Derived_Type_Definition
or else NT (N).Nkind = N_Formal_Derived_Type_Definition
or else NT (N).Nkind = N_Private_Extension_Declaration
or else NT (N).Nkind = N_Protected_Type_Declaration
or else NT (N).Nkind = N_Record_Definition
or else NT (N).Nkind = N_Single_Protected_Declaration
or else NT (N).Nkind = N_Single_Task_Declaration
or else NT (N).Nkind = N_Task_Type_Declaration);
Set_List2_With_Parent (N, Val);
end Set_Interface_List;
procedure Set_Interface_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Derived_Type_Definition
or else NT (N).Nkind = N_Record_Definition);
Set_Flag16 (N, Val);
end Set_Interface_Present;
procedure Set_Import_Interface_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Pragma);
Set_Flag16 (N, Val);
end Set_Import_Interface_Present;
procedure Set_In_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Object_Declaration
or else NT (N).Nkind = N_Parameter_Specification);
Set_Flag15 (N, Val);
end Set_In_Present;
procedure Set_Includes_Infinities
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Range);
Set_Flag11 (N, Val);
end Set_Includes_Infinities;
procedure Set_Incomplete_View
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Full_Type_Declaration);
Set_Node2 (N, Val); -- semantic field, no Parent set
end Set_Incomplete_View;
procedure Set_Inherited_Discriminant
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Association);
Set_Flag13 (N, Val);
end Set_Inherited_Discriminant;
procedure Set_Instance_Spec
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Package_Declaration
or else NT (N).Nkind = N_Function_Instantiation
or else NT (N).Nkind = N_Package_Instantiation
or else NT (N).Nkind = N_Procedure_Instantiation);
Set_Node5 (N, Val); -- semantic field, no Parent set
end Set_Instance_Spec;
procedure Set_Intval
(N : Node_Id; Val : Uint) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Integer_Literal);
Set_Uint3 (N, Val);
end Set_Intval;
procedure Set_Is_Accessibility_Actual
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Parameter_Association);
Set_Flag13 (N, Val);
end Set_Is_Accessibility_Actual;
procedure Set_Is_Asynchronous_Call_Block
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Block_Statement);
Set_Flag7 (N, Val);
end Set_Is_Asynchronous_Call_Block;
procedure Set_Is_Boolean_Aspect
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aspect_Specification);
Set_Flag16 (N, Val);
end Set_Is_Boolean_Aspect;
procedure Set_Is_Checked
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aspect_Specification
or else NT (N).Nkind = N_Pragma);
Set_Flag11 (N, Val);
end Set_Is_Checked;
procedure Set_Is_Component_Left_Opnd
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Op_Concat);
Set_Flag13 (N, Val);
end Set_Is_Component_Left_Opnd;
procedure Set_Is_Component_Right_Opnd
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Op_Concat);
Set_Flag14 (N, Val);
end Set_Is_Component_Right_Opnd;
procedure Set_Is_Controlling_Actual
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind in N_Subexpr);
Set_Flag16 (N, Val);
end Set_Is_Controlling_Actual;
procedure Set_Is_Delayed_Aspect
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aspect_Specification
or else NT (N).Nkind = N_Attribute_Definition_Clause
or else NT (N).Nkind = N_Pragma);
Set_Flag14 (N, Val);
end Set_Is_Delayed_Aspect;
procedure Set_Is_Disabled
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aspect_Specification
or else NT (N).Nkind = N_Pragma);
Set_Flag15 (N, Val);
end Set_Is_Disabled;
procedure Set_Is_Dynamic_Coextension
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Allocator);
Set_Flag18 (N, Val);
end Set_Is_Dynamic_Coextension;
procedure Set_Is_Elsif
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_If_Expression);
Set_Flag13 (N, Val);
end Set_Is_Elsif;
procedure Set_Is_Entry_Barrier_Function
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subprogram_Body);
Set_Flag8 (N, Val);
end Set_Is_Entry_Barrier_Function;
procedure Set_Is_Expanded_Build_In_Place_Call
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Function_Call);
Set_Flag11 (N, Val);
end Set_Is_Expanded_Build_In_Place_Call;
procedure Set_Is_Finalization_Wrapper
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Block_Statement);
Set_Flag9 (N, Val);
end Set_Is_Finalization_Wrapper;
procedure Set_Is_Folded_In_Parser
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_String_Literal);
Set_Flag4 (N, Val);
end Set_Is_Folded_In_Parser;
procedure Set_Is_Ignored
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aspect_Specification
or else NT (N).Nkind = N_Pragma);
Set_Flag9 (N, Val);
end Set_Is_Ignored;
procedure Set_Is_In_Discriminant_Check
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Selected_Component);
Set_Flag11 (N, Val);
end Set_Is_In_Discriminant_Check;
procedure Set_Is_Inherited
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Pragma);
Set_Flag4 (N, Val);
end Set_Is_Inherited;
procedure Set_Is_Machine_Number
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Real_Literal);
Set_Flag11 (N, Val);
end Set_Is_Machine_Number;
procedure Set_Is_Null_Loop
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Loop_Statement);
Set_Flag16 (N, Val);
end Set_Is_Null_Loop;
procedure Set_Is_Overloaded
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind in N_Subexpr);
Set_Flag5 (N, Val);
end Set_Is_Overloaded;
procedure Set_Is_Power_Of_2_For_Shift
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Op_Expon);
Set_Flag13 (N, Val);
end Set_Is_Power_Of_2_For_Shift;
procedure Set_Is_Prefixed_Call
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Selected_Component);
Set_Flag17 (N, Val);
end Set_Is_Prefixed_Call;
procedure Set_Is_Protected_Subprogram_Body
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subprogram_Body);
Set_Flag7 (N, Val);
end Set_Is_Protected_Subprogram_Body;
procedure Set_Is_Static_Coextension
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Allocator);
Set_Flag14 (N, Val);
end Set_Is_Static_Coextension;
procedure Set_Is_Static_Expression
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind in N_Subexpr);
Set_Flag6 (N, Val);
end Set_Is_Static_Expression;
procedure Set_Is_Subprogram_Descriptor
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Object_Declaration);
Set_Flag16 (N, Val);
end Set_Is_Subprogram_Descriptor;
procedure Set_Is_Task_Allocation_Block
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Block_Statement);
Set_Flag6 (N, Val);
end Set_Is_Task_Allocation_Block;
procedure Set_Is_Task_Master
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Block_Statement
or else NT (N).Nkind = N_Subprogram_Body
or else NT (N).Nkind = N_Task_Body);
Set_Flag5 (N, Val);
end Set_Is_Task_Master;
procedure Set_Iteration_Scheme
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Loop_Statement);
Set_Node2_With_Parent (N, Val);
end Set_Iteration_Scheme;
procedure Set_Iterator_Specification
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Iteration_Scheme
or else NT (N).Nkind = N_Quantified_Expression);
Set_Node2_With_Parent (N, Val);
end Set_Iterator_Specification;
procedure Set_Itype
(N : Node_Id; Val : Entity_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Itype_Reference);
Set_Node1 (N, Val); -- no parent, semantic field
end Set_Itype;
procedure Set_Kill_Range_Check
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Unchecked_Type_Conversion);
Set_Flag11 (N, Val);
end Set_Kill_Range_Check;
procedure Set_Label_Construct
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Implicit_Label_Declaration);
Set_Node2 (N, Val); -- semantic field, no parent set
end Set_Label_Construct;
procedure Set_Last_Bit
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Clause);
Set_Node4_With_Parent (N, Val);
end Set_Last_Bit;
procedure Set_Last_Name
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
Set_Flag6 (N, Val);
end Set_Last_Name;
procedure Set_Left_Opnd
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_And_Then
or else NT (N).Nkind = N_In
or else NT (N).Nkind = N_Not_In
or else NT (N).Nkind = N_Or_Else
or else NT (N).Nkind in N_Binary_Op);
Set_Node2_With_Parent (N, Val);
end Set_Left_Opnd;
procedure Set_Library_Unit
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit
or else NT (N).Nkind = N_Package_Body_Stub
or else NT (N).Nkind = N_Protected_Body_Stub
or else NT (N).Nkind = N_Subprogram_Body_Stub
or else NT (N).Nkind = N_Task_Body_Stub
or else NT (N).Nkind = N_With_Clause);
Set_Node4 (N, Val); -- semantic field, no parent set
end Set_Library_Unit;
procedure Set_Limited_View_Installed
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Package_Specification
or else NT (N).Nkind = N_With_Clause);
Set_Flag18 (N, Val);
end Set_Limited_View_Installed;
procedure Set_Limited_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Derived_Type_Definition
or else NT (N).Nkind = N_Formal_Derived_Type_Definition
or else NT (N).Nkind = N_Formal_Private_Type_Definition
or else NT (N).Nkind = N_Private_Extension_Declaration
or else NT (N).Nkind = N_Private_Type_Declaration
or else NT (N).Nkind = N_Record_Definition
or else NT (N).Nkind = N_With_Clause);
Set_Flag17 (N, Val);
end Set_Limited_Present;
procedure Set_Literals
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Enumeration_Type_Definition);
Set_List1_With_Parent (N, Val);
end Set_Literals;
procedure Set_Local_Raise_Not_OK
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Exception_Handler);
Set_Flag7 (N, Val);
end Set_Local_Raise_Not_OK;
procedure Set_Local_Raise_Statements
(N : Node_Id; Val : Elist_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Exception_Handler);
Set_Elist1 (N, Val);
end Set_Local_Raise_Statements;
procedure Set_Loop_Actions
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Association);
Set_List2 (N, Val); -- semantic field, no parent set
end Set_Loop_Actions;
procedure Set_Loop_Parameter_Specification
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Iteration_Scheme
or else NT (N).Nkind = N_Quantified_Expression);
Set_Node4_With_Parent (N, Val);
end Set_Loop_Parameter_Specification;
procedure Set_Low_Bound
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Range
or else NT (N).Nkind = N_Real_Range_Specification
or else NT (N).Nkind = N_Signed_Integer_Type_Definition);
Set_Node1_With_Parent (N, Val);
end Set_Low_Bound;
procedure Set_Mod_Clause
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Record_Representation_Clause);
Set_Node2_With_Parent (N, Val);
end Set_Mod_Clause;
procedure Set_More_Ids
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Declaration
or else NT (N).Nkind = N_Discriminant_Specification
or else NT (N).Nkind = N_Exception_Declaration
or else NT (N).Nkind = N_Formal_Object_Declaration
or else NT (N).Nkind = N_Number_Declaration
or else NT (N).Nkind = N_Object_Declaration
or else NT (N).Nkind = N_Parameter_Specification);
Set_Flag5 (N, Val);
end Set_More_Ids;
procedure Set_Must_Be_Byte_Aligned
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Attribute_Reference);
Set_Flag14 (N, Val);
end Set_Must_Be_Byte_Aligned;
procedure Set_Must_Not_Freeze
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subtype_Indication
or else NT (N).Nkind in N_Subexpr);
Set_Flag8 (N, Val);
end Set_Must_Not_Freeze;
procedure Set_Must_Not_Override
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Entry_Declaration
or else NT (N).Nkind = N_Function_Instantiation
or else NT (N).Nkind = N_Function_Specification
or else NT (N).Nkind = N_Procedure_Instantiation
or else NT (N).Nkind = N_Procedure_Specification);
Set_Flag15 (N, Val);
end Set_Must_Not_Override;
procedure Set_Must_Override
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Entry_Declaration
or else NT (N).Nkind = N_Function_Instantiation
or else NT (N).Nkind = N_Function_Specification
or else NT (N).Nkind = N_Procedure_Instantiation
or else NT (N).Nkind = N_Procedure_Specification);
Set_Flag14 (N, Val);
end Set_Must_Override;
procedure Set_Name
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Assignment_Statement
or else NT (N).Nkind = N_Attribute_Definition_Clause
or else NT (N).Nkind = N_Defining_Program_Unit_Name
or else NT (N).Nkind = N_Designator
or else NT (N).Nkind = N_Entry_Call_Statement
or else NT (N).Nkind = N_Exception_Renaming_Declaration
or else NT (N).Nkind = N_Exit_Statement
or else NT (N).Nkind = N_Formal_Package_Declaration
or else NT (N).Nkind = N_Function_Call
or else NT (N).Nkind = N_Function_Instantiation
or else NT (N).Nkind = N_Generic_Function_Renaming_Declaration
or else NT (N).Nkind = N_Generic_Package_Renaming_Declaration
or else NT (N).Nkind = N_Generic_Procedure_Renaming_Declaration
or else NT (N).Nkind = N_Goto_Statement
or else NT (N).Nkind = N_Iterator_Specification
or else NT (N).Nkind = N_Object_Renaming_Declaration
or else NT (N).Nkind = N_Package_Instantiation
or else NT (N).Nkind = N_Package_Renaming_Declaration
or else NT (N).Nkind = N_Procedure_Call_Statement
or else NT (N).Nkind = N_Procedure_Instantiation
or else NT (N).Nkind = N_Raise_Expression
or else NT (N).Nkind = N_Raise_Statement
or else NT (N).Nkind = N_Requeue_Statement
or else NT (N).Nkind = N_Subprogram_Renaming_Declaration
or else NT (N).Nkind = N_Subunit
or else NT (N).Nkind = N_Variant_Part
or else NT (N).Nkind = N_With_Clause);
Set_Node2_With_Parent (N, Val);
end Set_Name;
procedure Set_Names
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Abort_Statement
or else NT (N).Nkind = N_Use_Package_Clause);
Set_List2_With_Parent (N, Val);
end Set_Names;
procedure Set_Next_Entity
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Defining_Character_Literal
or else NT (N).Nkind = N_Defining_Identifier
or else NT (N).Nkind = N_Defining_Operator_Symbol);
Set_Node2 (N, Val); -- semantic field, no parent set
end Set_Next_Entity;
procedure Set_Next_Exit_Statement
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Exit_Statement);
Set_Node3 (N, Val); -- semantic field, no parent set
end Set_Next_Exit_Statement;
procedure Set_Next_Implicit_With
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
Set_Node3 (N, Val); -- semantic field, no parent set
end Set_Next_Implicit_With;
procedure Set_Next_Named_Actual
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Parameter_Association);
Set_Node4 (N, Val); -- semantic field, no parent set
end Set_Next_Named_Actual;
procedure Set_Next_Pragma
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Pragma);
Set_Node1 (N, Val); -- semantic field, no parent set
end Set_Next_Pragma;
procedure Set_Next_Rep_Item
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aspect_Specification
or else NT (N).Nkind = N_Attribute_Definition_Clause
or else NT (N).Nkind = N_Enumeration_Representation_Clause
or else NT (N).Nkind = N_Pragma
or else NT (N).Nkind = N_Record_Representation_Clause);
Set_Node5 (N, Val); -- semantic field, no parent set
end Set_Next_Rep_Item;
procedure Set_Next_Use_Clause
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Use_Package_Clause
or else NT (N).Nkind = N_Use_Type_Clause);
Set_Node3 (N, Val); -- semantic field, no parent set
end Set_Next_Use_Clause;
procedure Set_No_Ctrl_Actions
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Assignment_Statement);
Set_Flag7 (N, Val);
end Set_No_Ctrl_Actions;
procedure Set_No_Elaboration_Check
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Function_Call
or else NT (N).Nkind = N_Procedure_Call_Statement);
Set_Flag14 (N, Val);
end Set_No_Elaboration_Check;
procedure Set_No_Entities_Ref_In_Spec
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
Set_Flag8 (N, Val);
end Set_No_Entities_Ref_In_Spec;
procedure Set_No_Initialization
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Allocator
or else NT (N).Nkind = N_Object_Declaration);
Set_Flag13 (N, Val);
end Set_No_Initialization;
procedure Set_No_Minimize_Eliminate
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_In
or else NT (N).Nkind = N_Not_In);
Set_Flag17 (N, Val);
end Set_No_Minimize_Eliminate;
procedure Set_No_Truncation
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Unchecked_Type_Conversion);
Set_Flag17 (N, Val);
end Set_No_Truncation;
procedure Set_Non_Aliased_Prefix
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Attribute_Reference);
Set_Flag18 (N, Val);
end Set_Non_Aliased_Prefix;
procedure Set_Null_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_List
or else NT (N).Nkind = N_Procedure_Specification
or else NT (N).Nkind = N_Record_Definition);
Set_Flag13 (N, Val);
end Set_Null_Present;
procedure Set_Null_Excluding_Subtype
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Access_To_Object_Definition);
Set_Flag16 (N, Val);
end Set_Null_Excluding_Subtype;
procedure Set_Null_Exclusion_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Access_Definition
or else NT (N).Nkind = N_Access_Function_Definition
or else NT (N).Nkind = N_Access_Procedure_Definition
or else NT (N).Nkind = N_Access_To_Object_Definition
or else NT (N).Nkind = N_Allocator
or else NT (N).Nkind = N_Component_Definition
or else NT (N).Nkind = N_Derived_Type_Definition
or else NT (N).Nkind = N_Discriminant_Specification
or else NT (N).Nkind = N_Formal_Object_Declaration
or else NT (N).Nkind = N_Function_Specification
or else NT (N).Nkind = N_Object_Declaration
or else NT (N).Nkind = N_Object_Renaming_Declaration
or else NT (N).Nkind = N_Parameter_Specification
or else NT (N).Nkind = N_Subtype_Declaration);
Set_Flag11 (N, Val);
end Set_Null_Exclusion_Present;
procedure Set_Null_Exclusion_In_Return_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Access_Function_Definition);
Set_Flag14 (N, Val);
end Set_Null_Exclusion_In_Return_Present;
procedure Set_Null_Record_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aggregate
or else NT (N).Nkind = N_Extension_Aggregate);
Set_Flag17 (N, Val);
end Set_Null_Record_Present;
procedure Set_Object_Definition
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Object_Declaration);
Set_Node4_With_Parent (N, Val);
end Set_Object_Definition;
procedure Set_Of_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Iterator_Specification);
Set_Flag16 (N, Val);
end Set_Of_Present;
procedure Set_Original_Discriminant
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Identifier);
Set_Node2 (N, Val); -- semantic field, no parent set
end Set_Original_Discriminant;
procedure Set_Original_Entity
(N : Node_Id; Val : Entity_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Integer_Literal
or else NT (N).Nkind = N_Real_Literal);
Set_Node2 (N, Val); -- semantic field, no parent set
end Set_Original_Entity;
procedure Set_Others_Discrete_Choices
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Others_Choice);
Set_List1_With_Parent (N, Val);
end Set_Others_Discrete_Choices;
procedure Set_Out_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Object_Declaration
or else NT (N).Nkind = N_Parameter_Specification);
Set_Flag17 (N, Val);
end Set_Out_Present;
procedure Set_Parameter_Associations
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Entry_Call_Statement
or else NT (N).Nkind = N_Function_Call
or else NT (N).Nkind = N_Procedure_Call_Statement);
Set_List3_With_Parent (N, Val);
end Set_Parameter_Associations;
procedure Set_Parameter_Specifications
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Accept_Statement
or else NT (N).Nkind = N_Access_Function_Definition
or else NT (N).Nkind = N_Access_Procedure_Definition
or else NT (N).Nkind = N_Entry_Body_Formal_Part
or else NT (N).Nkind = N_Entry_Declaration
or else NT (N).Nkind = N_Function_Specification
or else NT (N).Nkind = N_Procedure_Specification);
Set_List3_With_Parent (N, Val);
end Set_Parameter_Specifications;
procedure Set_Parameter_Type
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Parameter_Specification);
Set_Node2_With_Parent (N, Val);
end Set_Parameter_Type;
procedure Set_Parent_Spec
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Function_Instantiation
or else NT (N).Nkind = N_Generic_Function_Renaming_Declaration
or else NT (N).Nkind = N_Generic_Package_Declaration
or else NT (N).Nkind = N_Generic_Package_Renaming_Declaration
or else NT (N).Nkind = N_Generic_Procedure_Renaming_Declaration
or else NT (N).Nkind = N_Generic_Subprogram_Declaration
or else NT (N).Nkind = N_Package_Declaration
or else NT (N).Nkind = N_Package_Instantiation
or else NT (N).Nkind = N_Package_Renaming_Declaration
or else NT (N).Nkind = N_Procedure_Instantiation
or else NT (N).Nkind = N_Subprogram_Declaration
or else NT (N).Nkind = N_Subprogram_Renaming_Declaration);
Set_Node4 (N, Val); -- semantic field, no parent set
end Set_Parent_Spec;
procedure Set_Position
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Clause);
Set_Node2_With_Parent (N, Val);
end Set_Position;
procedure Set_Pragma_Argument_Associations
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Pragma);
Set_List2_With_Parent (N, Val);
end Set_Pragma_Argument_Associations;
procedure Set_Pragma_Identifier
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Pragma);
Set_Node4_With_Parent (N, Val);
end Set_Pragma_Identifier;
procedure Set_Pragmas_After
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit_Aux
or else NT (N).Nkind = N_Terminate_Alternative);
Set_List5_With_Parent (N, Val);
end Set_Pragmas_After;
procedure Set_Pragmas_Before
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Accept_Alternative
or else NT (N).Nkind = N_Delay_Alternative
or else NT (N).Nkind = N_Entry_Call_Alternative
or else NT (N).Nkind = N_Mod_Clause
or else NT (N).Nkind = N_Terminate_Alternative
or else NT (N).Nkind = N_Triggering_Alternative);
Set_List4_With_Parent (N, Val);
end Set_Pragmas_Before;
procedure Set_Pre_Post_Conditions
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Contract);
Set_Node1 (N, Val); -- semantic field, no parent set
end Set_Pre_Post_Conditions;
procedure Set_Prefix
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Attribute_Reference
or else NT (N).Nkind = N_Expanded_Name
or else NT (N).Nkind = N_Explicit_Dereference
or else NT (N).Nkind = N_Indexed_Component
or else NT (N).Nkind = N_Reference
or else NT (N).Nkind = N_Selected_Component
or else NT (N).Nkind = N_Slice);
Set_Node3_With_Parent (N, Val);
end Set_Prefix;
procedure Set_Premature_Use
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Incomplete_Type_Declaration);
Set_Node5 (N, Val);
end Set_Premature_Use;
procedure Set_Present_Expr
(N : Node_Id; Val : Uint) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Variant);
Set_Uint3 (N, Val);
end Set_Present_Expr;
procedure Set_Prev_Ids
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_Declaration
or else NT (N).Nkind = N_Discriminant_Specification
or else NT (N).Nkind = N_Exception_Declaration
or else NT (N).Nkind = N_Formal_Object_Declaration
or else NT (N).Nkind = N_Number_Declaration
or else NT (N).Nkind = N_Object_Declaration
or else NT (N).Nkind = N_Parameter_Specification);
Set_Flag6 (N, Val);
end Set_Prev_Ids;
procedure Set_Print_In_Hex
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Integer_Literal);
Set_Flag13 (N, Val);
end Set_Print_In_Hex;
procedure Set_Private_Declarations
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Package_Specification
or else NT (N).Nkind = N_Protected_Definition
or else NT (N).Nkind = N_Task_Definition);
Set_List3_With_Parent (N, Val);
end Set_Private_Declarations;
procedure Set_Private_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit
or else NT (N).Nkind = N_Formal_Derived_Type_Definition
or else NT (N).Nkind = N_With_Clause);
Set_Flag15 (N, Val);
end Set_Private_Present;
procedure Set_Procedure_To_Call
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Allocator
or else NT (N).Nkind = N_Extended_Return_Statement
or else NT (N).Nkind = N_Free_Statement
or else NT (N).Nkind = N_Simple_Return_Statement);
Set_Node2 (N, Val); -- semantic field, no parent set
end Set_Procedure_To_Call;
procedure Set_Proper_Body
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Subunit);
Set_Node1_With_Parent (N, Val);
end Set_Proper_Body;
procedure Set_Protected_Definition
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Protected_Type_Declaration
or else NT (N).Nkind = N_Single_Protected_Declaration);
Set_Node3_With_Parent (N, Val);
end Set_Protected_Definition;
procedure Set_Protected_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Access_Function_Definition
or else NT (N).Nkind = N_Access_Procedure_Definition
or else NT (N).Nkind = N_Derived_Type_Definition
or else NT (N).Nkind = N_Record_Definition);
Set_Flag6 (N, Val);
end Set_Protected_Present;
procedure Set_Raises_Constraint_Error
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind in N_Subexpr);
Set_Flag7 (N, Val);
end Set_Raises_Constraint_Error;
procedure Set_Range_Constraint
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Delta_Constraint
or else NT (N).Nkind = N_Digits_Constraint);
Set_Node4_With_Parent (N, Val);
end Set_Range_Constraint;
procedure Set_Range_Expression
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Range_Constraint);
Set_Node4_With_Parent (N, Val);
end Set_Range_Expression;
procedure Set_Real_Range_Specification
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Decimal_Fixed_Point_Definition
or else NT (N).Nkind = N_Floating_Point_Definition
or else NT (N).Nkind = N_Ordinary_Fixed_Point_Definition);
Set_Node4_With_Parent (N, Val);
end Set_Real_Range_Specification;
procedure Set_Realval
(N : Node_Id; Val : Ureal) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Real_Literal);
Set_Ureal3 (N, Val);
end Set_Realval;
procedure Set_Reason
(N : Node_Id; Val : Uint) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Raise_Constraint_Error
or else NT (N).Nkind = N_Raise_Program_Error
or else NT (N).Nkind = N_Raise_Storage_Error);
Set_Uint3 (N, Val);
end Set_Reason;
procedure Set_Record_Extension_Part
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Derived_Type_Definition);
Set_Node3_With_Parent (N, Val);
end Set_Record_Extension_Part;
procedure Set_Redundant_Use
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Attribute_Reference
or else NT (N).Nkind = N_Expanded_Name
or else NT (N).Nkind = N_Identifier);
Set_Flag13 (N, Val);
end Set_Redundant_Use;
procedure Set_Renaming_Exception
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Exception_Declaration);
Set_Node2 (N, Val);
end Set_Renaming_Exception;
procedure Set_Result_Definition
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Access_Function_Definition
or else NT (N).Nkind = N_Function_Specification);
Set_Node4_With_Parent (N, Val);
end Set_Result_Definition;
procedure Set_Return_Object_Declarations
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Extended_Return_Statement);
Set_List3_With_Parent (N, Val);
end Set_Return_Object_Declarations;
procedure Set_Return_Statement_Entity
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Extended_Return_Statement
or else NT (N).Nkind = N_Simple_Return_Statement);
Set_Node5 (N, Val); -- semantic field, no parent set
end Set_Return_Statement_Entity;
procedure Set_Reverse_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Iterator_Specification
or else NT (N).Nkind = N_Loop_Parameter_Specification);
Set_Flag15 (N, Val);
end Set_Reverse_Present;
procedure Set_Right_Opnd
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind in N_Op
or else NT (N).Nkind = N_And_Then
or else NT (N).Nkind = N_In
or else NT (N).Nkind = N_Not_In
or else NT (N).Nkind = N_Or_Else);
Set_Node3_With_Parent (N, Val);
end Set_Right_Opnd;
procedure Set_Rounded_Result
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Op_Divide
or else NT (N).Nkind = N_Op_Multiply
or else NT (N).Nkind = N_Type_Conversion);
Set_Flag18 (N, Val);
end Set_Rounded_Result;
procedure Set_SCIL_Controlling_Tag
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_SCIL_Dispatching_Call);
Set_Node5 (N, Val); -- semantic field, no parent set
end Set_SCIL_Controlling_Tag;
procedure Set_SCIL_Entity
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_SCIL_Dispatch_Table_Tag_Init
or else NT (N).Nkind = N_SCIL_Dispatching_Call
or else NT (N).Nkind = N_SCIL_Membership_Test);
Set_Node4 (N, Val); -- semantic field, no parent set
end Set_SCIL_Entity;
procedure Set_SCIL_Tag_Value
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_SCIL_Membership_Test);
Set_Node5 (N, Val); -- semantic field, no parent set
end Set_SCIL_Tag_Value;
procedure Set_SCIL_Target_Prim
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_SCIL_Dispatching_Call);
Set_Node2 (N, Val); -- semantic field, no parent set
end Set_SCIL_Target_Prim;
procedure Set_Scope
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Defining_Character_Literal
or else NT (N).Nkind = N_Defining_Identifier
or else NT (N).Nkind = N_Defining_Operator_Symbol);
Set_Node3 (N, Val); -- semantic field, no parent set
end Set_Scope;
procedure Set_Select_Alternatives
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Selective_Accept);
Set_List1_With_Parent (N, Val);
end Set_Select_Alternatives;
procedure Set_Selector_Name
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Expanded_Name
or else NT (N).Nkind = N_Generic_Association
or else NT (N).Nkind = N_Parameter_Association
or else NT (N).Nkind = N_Selected_Component);
Set_Node2_With_Parent (N, Val);
end Set_Selector_Name;
procedure Set_Selector_Names
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Discriminant_Association);
Set_List1_With_Parent (N, Val);
end Set_Selector_Names;
procedure Set_Shift_Count_OK
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Op_Rotate_Left
or else NT (N).Nkind = N_Op_Rotate_Right
or else NT (N).Nkind = N_Op_Shift_Left
or else NT (N).Nkind = N_Op_Shift_Right
or else NT (N).Nkind = N_Op_Shift_Right_Arithmetic);
Set_Flag4 (N, Val);
end Set_Shift_Count_OK;
procedure Set_Source_Type
(N : Node_Id; Val : Entity_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Validate_Unchecked_Conversion);
Set_Node1 (N, Val); -- semantic field, no parent set
end Set_Source_Type;
procedure Set_Specification
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Abstract_Subprogram_Declaration
or else NT (N).Nkind = N_Expression_Function
or else NT (N).Nkind = N_Formal_Abstract_Subprogram_Declaration
or else NT (N).Nkind = N_Formal_Concrete_Subprogram_Declaration
or else NT (N).Nkind = N_Generic_Package_Declaration
or else NT (N).Nkind = N_Generic_Subprogram_Declaration
or else NT (N).Nkind = N_Package_Declaration
or else NT (N).Nkind = N_Subprogram_Body
or else NT (N).Nkind = N_Subprogram_Body_Stub
or else NT (N).Nkind = N_Subprogram_Declaration
or else NT (N).Nkind = N_Subprogram_Renaming_Declaration);
Set_Node1_With_Parent (N, Val);
end Set_Specification;
procedure Set_Split_PPC
(N : Node_Id; Val : Boolean) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Aspect_Specification
or else NT (N).Nkind = N_Pragma);
Set_Flag17 (N, Val);
end Set_Split_PPC;
procedure Set_Statements
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Abortable_Part
or else NT (N).Nkind = N_Accept_Alternative
or else NT (N).Nkind = N_Case_Statement_Alternative
or else NT (N).Nkind = N_Delay_Alternative
or else NT (N).Nkind = N_Entry_Call_Alternative
or else NT (N).Nkind = N_Exception_Handler
or else NT (N).Nkind = N_Handled_Sequence_Of_Statements
or else NT (N).Nkind = N_Loop_Statement
or else NT (N).Nkind = N_Triggering_Alternative);
Set_List3_With_Parent (N, Val);
end Set_Statements;
procedure Set_Storage_Pool
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Allocator
or else NT (N).Nkind = N_Extended_Return_Statement
or else NT (N).Nkind = N_Free_Statement
or else NT (N).Nkind = N_Simple_Return_Statement);
Set_Node1 (N, Val); -- semantic field, no parent set
end Set_Storage_Pool;
procedure Set_Subpool_Handle_Name
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Allocator);
Set_Node4_With_Parent (N, Val);
end Set_Subpool_Handle_Name;
procedure Set_Strval
(N : Node_Id; Val : String_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Operator_Symbol
or else NT (N).Nkind = N_String_Literal);
Set_Str3 (N, Val);
end Set_Strval;
procedure Set_Subtype_Indication
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Access_To_Object_Definition
or else NT (N).Nkind = N_Component_Definition
or else NT (N).Nkind = N_Derived_Type_Definition
or else NT (N).Nkind = N_Iterator_Specification
or else NT (N).Nkind = N_Private_Extension_Declaration
or else NT (N).Nkind = N_Subtype_Declaration);
Set_Node5_With_Parent (N, Val);
end Set_Subtype_Indication;
procedure Set_Subtype_Mark
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Access_Definition
or else NT (N).Nkind = N_Formal_Derived_Type_Definition
or else NT (N).Nkind = N_Formal_Object_Declaration
or else NT (N).Nkind = N_Object_Renaming_Declaration
or else NT (N).Nkind = N_Qualified_Expression
or else NT (N).Nkind = N_Subtype_Indication
or else NT (N).Nkind = N_Type_Conversion
or else NT (N).Nkind = N_Unchecked_Type_Conversion);
Set_Node4_With_Parent (N, Val);
end Set_Subtype_Mark;
procedure Set_Subtype_Marks
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Unconstrained_Array_Definition
or else NT (N).Nkind = N_Use_Type_Clause);
Set_List2_With_Parent (N, Val);
end Set_Subtype_Marks;
procedure Set_Suppress_Assignment_Checks
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Assignment_Statement
or else NT (N).Nkind = N_Object_Declaration);
Set_Flag18 (N, Val);
end Set_Suppress_Assignment_Checks;
procedure Set_Suppress_Loop_Warnings
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Loop_Statement);
Set_Flag17 (N, Val);
end Set_Suppress_Loop_Warnings;
procedure Set_Synchronized_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Derived_Type_Definition
or else NT (N).Nkind = N_Formal_Derived_Type_Definition
or else NT (N).Nkind = N_Private_Extension_Declaration
or else NT (N).Nkind = N_Record_Definition);
Set_Flag7 (N, Val);
end Set_Synchronized_Present;
procedure Set_Tagged_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Incomplete_Type_Definition
or else NT (N).Nkind = N_Formal_Private_Type_Definition
or else NT (N).Nkind = N_Incomplete_Type_Declaration
or else NT (N).Nkind = N_Private_Type_Declaration
or else NT (N).Nkind = N_Record_Definition);
Set_Flag15 (N, Val);
end Set_Tagged_Present;
procedure Set_Target_Type
(N : Node_Id; Val : Entity_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Validate_Unchecked_Conversion);
Set_Node2 (N, Val); -- semantic field, no parent set
end Set_Target_Type;
procedure Set_Task_Definition
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Single_Task_Declaration
or else NT (N).Nkind = N_Task_Type_Declaration);
Set_Node3_With_Parent (N, Val);
end Set_Task_Definition;
procedure Set_Task_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Derived_Type_Definition
or else NT (N).Nkind = N_Record_Definition);
Set_Flag5 (N, Val);
end Set_Task_Present;
procedure Set_Then_Actions
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_If_Expression);
Set_List2_With_Parent (N, Val); -- semantic field, but needs parents
end Set_Then_Actions;
procedure Set_Then_Statements
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Elsif_Part
or else NT (N).Nkind = N_If_Statement);
Set_List2_With_Parent (N, Val);
end Set_Then_Statements;
procedure Set_Treat_Fixed_As_Integer
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Op_Divide
or else NT (N).Nkind = N_Op_Mod
or else NT (N).Nkind = N_Op_Multiply
or else NT (N).Nkind = N_Op_Rem);
Set_Flag14 (N, Val);
end Set_Treat_Fixed_As_Integer;
procedure Set_Triggering_Alternative
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Asynchronous_Select);
Set_Node1_With_Parent (N, Val);
end Set_Triggering_Alternative;
procedure Set_Triggering_Statement
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Triggering_Alternative);
Set_Node1_With_Parent (N, Val);
end Set_Triggering_Statement;
procedure Set_TSS_Elist
(N : Node_Id; Val : Elist_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Freeze_Entity);
Set_Elist3 (N, Val); -- semantic field, no parent set
end Set_TSS_Elist;
procedure Set_Uneval_Old_Accept
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Pragma);
Set_Flag7 (N, Val);
end Set_Uneval_Old_Accept;
procedure Set_Uneval_Old_Warn
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Pragma);
Set_Flag18 (N, Val);
end Set_Uneval_Old_Warn;
procedure Set_Type_Definition
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Full_Type_Declaration);
Set_Node3_With_Parent (N, Val);
end Set_Type_Definition;
procedure Set_Unit
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Compilation_Unit);
Set_Node2_With_Parent (N, Val);
end Set_Unit;
procedure Set_Unknown_Discriminants_Present
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Type_Declaration
or else NT (N).Nkind = N_Incomplete_Type_Declaration
or else NT (N).Nkind = N_Private_Extension_Declaration
or else NT (N).Nkind = N_Private_Type_Declaration);
Set_Flag13 (N, Val);
end Set_Unknown_Discriminants_Present;
procedure Set_Unreferenced_In_Spec
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
Set_Flag7 (N, Val);
end Set_Unreferenced_In_Spec;
procedure Set_Variant_Part
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Component_List);
Set_Node4_With_Parent (N, Val);
end Set_Variant_Part;
procedure Set_Variants
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Variant_Part);
Set_List1_With_Parent (N, Val);
end Set_Variants;
procedure Set_Visible_Declarations
(N : Node_Id; Val : List_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Package_Specification
or else NT (N).Nkind = N_Protected_Definition
or else NT (N).Nkind = N_Task_Definition);
Set_List2_With_Parent (N, Val);
end Set_Visible_Declarations;
procedure Set_Uninitialized_Variable
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Formal_Private_Type_Definition
or else NT (N).Nkind = N_Private_Extension_Declaration);
Set_Node3 (N, Val);
end Set_Uninitialized_Variable;
procedure Set_Used_Operations
(N : Node_Id; Val : Elist_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Use_Type_Clause);
Set_Elist5 (N, Val);
end Set_Used_Operations;
procedure Set_Was_Originally_Stub
(N : Node_Id; Val : Boolean := True) is
begin
pragma Assert (False
or else NT (N).Nkind = N_Package_Body
or else NT (N).Nkind = N_Protected_Body
or else NT (N).Nkind = N_Subprogram_Body
or else NT (N).Nkind = N_Task_Body);
Set_Flag13 (N, Val);
end Set_Was_Originally_Stub;
procedure Set_Withed_Body
(N : Node_Id; Val : Node_Id) is
begin
pragma Assert (False
or else NT (N).Nkind = N_With_Clause);
Set_Node1 (N, Val);
end Set_Withed_Body;
-------------------------
-- Iterator Procedures --
-------------------------
procedure Next_Entity (N : in out Node_Id) is
begin
N := Next_Entity (N);
end Next_Entity;
procedure Next_Named_Actual (N : in out Node_Id) is
begin
N := Next_Named_Actual (N);
end Next_Named_Actual;
procedure Next_Rep_Item (N : in out Node_Id) is
begin
N := Next_Rep_Item (N);
end Next_Rep_Item;
procedure Next_Use_Clause (N : in out Node_Id) is
begin
N := Next_Use_Clause (N);
end Next_Use_Clause;
------------------
-- End_Location --
------------------
function End_Location (N : Node_Id) return Source_Ptr is
L : constant Uint := End_Span (N);
begin
if L = No_Uint then
return No_Location;
else
return Source_Ptr (Int (Sloc (N)) + UI_To_Int (L));
end if;
end End_Location;
--------------------
-- Get_Pragma_Arg --
--------------------
function Get_Pragma_Arg (Arg : Node_Id) return Node_Id is
begin
if Nkind (Arg) = N_Pragma_Argument_Association then
return Expression (Arg);
else
return Arg;
end if;
end Get_Pragma_Arg;
----------------------
-- Set_End_Location --
----------------------
procedure Set_End_Location (N : Node_Id; S : Source_Ptr) is
begin
Set_End_Span (N,
UI_From_Int (Int (S) - Int (Sloc (N))));
end Set_End_Location;
--------------
-- Nkind_In --
--------------
function Nkind_In
(T : Node_Kind;
V1 : Node_Kind;
V2 : Node_Kind) return Boolean
is
begin
return T = V1 or else
T = V2;
end Nkind_In;
function Nkind_In
(T : Node_Kind;
V1 : Node_Kind;
V2 : Node_Kind;
V3 : Node_Kind) return Boolean
is
begin
return T = V1 or else
T = V2 or else
T = V3;
end Nkind_In;
function Nkind_In
(T : Node_Kind;
V1 : Node_Kind;
V2 : Node_Kind;
V3 : Node_Kind;
V4 : Node_Kind) return Boolean
is
begin
return T = V1 or else
T = V2 or else
T = V3 or else
T = V4;
end Nkind_In;
function Nkind_In
(T : Node_Kind;
V1 : Node_Kind;
V2 : Node_Kind;
V3 : Node_Kind;
V4 : Node_Kind;
V5 : Node_Kind) return Boolean
is
begin
return T = V1 or else
T = V2 or else
T = V3 or else
T = V4 or else
T = V5;
end Nkind_In;
function Nkind_In
(T : Node_Kind;
V1 : Node_Kind;
V2 : Node_Kind;
V3 : Node_Kind;
V4 : Node_Kind;
V5 : Node_Kind;
V6 : Node_Kind) return Boolean
is
begin
return T = V1 or else
T = V2 or else
T = V3 or else
T = V4 or else
T = V5 or else
T = V6;
end Nkind_In;
function Nkind_In
(T : Node_Kind;
V1 : Node_Kind;
V2 : Node_Kind;
V3 : Node_Kind;
V4 : Node_Kind;
V5 : Node_Kind;
V6 : Node_Kind;
V7 : Node_Kind) return Boolean
is
begin
return T = V1 or else
T = V2 or else
T = V3 or else
T = V4 or else
T = V5 or else
T = V6 or else
T = V7;
end Nkind_In;
function Nkind_In
(T : Node_Kind;
V1 : Node_Kind;
V2 : Node_Kind;
V3 : Node_Kind;
V4 : Node_Kind;
V5 : Node_Kind;
V6 : Node_Kind;
V7 : Node_Kind;
V8 : Node_Kind) return Boolean
is
begin
return T = V1 or else
T = V2 or else
T = V3 or else
T = V4 or else
T = V5 or else
T = V6 or else
T = V7 or else
T = V8;
end Nkind_In;
function Nkind_In
(T : Node_Kind;
V1 : Node_Kind;
V2 : Node_Kind;
V3 : Node_Kind;
V4 : Node_Kind;
V5 : Node_Kind;
V6 : Node_Kind;
V7 : Node_Kind;
V8 : Node_Kind;
V9 : Node_Kind) return Boolean
is
begin
return T = V1 or else
T = V2 or else
T = V3 or else
T = V4 or else
T = V5 or else
T = V6 or else
T = V7 or else
T = V8 or else
T = V9;
end Nkind_In;
-----------------
-- Pragma_Name --
-----------------
function Pragma_Name (N : Node_Id) return Name_Id is
begin
return Chars (Pragma_Identifier (N));
end Pragma_Name;
end Sinfo;
|
src/Categories/Diagram/Coend/Properties.agda | Trebor-Huang/agda-categories | 279 | 2978 | {-# OPTIONS --without-K --safe #-}
module Categories.Diagram.Coend.Properties where
open import Categories.Category.Core using (Category)
open import Categories.Category.Product
import Categories.Category.Construction.Cowedges as Cowedges
open import Categories.Category.Construction.Functors
open import Categories.Category.Equivalence
open import Categories.Category.Equivalence.Preserves
open import Categories.Diagram.Coend
open import Categories.Diagram.Colimit
open import Categories.Diagram.Cowedge
open import Categories.Diagram.Cowedge.Properties
open import Categories.Functor using (Functor)
open import Categories.Functor.Bifunctor using (Bifunctor)
open import Categories.Functor.Instance.Twisted
import Categories.Morphism as M
open import Categories.NaturalTransformation hiding (id)
open import Categories.NaturalTransformation.Dinatural
open import Categories.Object.Initial as Initial
import Categories.Morphism.Reasoning as MR
open import Level
open import Data.Product using (Σ; _,_)
open import Function using (_$_)
module _ {o ℓ e o′ ℓ′ e′} {C : Category o ℓ e} {D : Category o′ ℓ′ e′}
(F : Bifunctor (Category.op C) C D) where
open Cowedges F
-- Being a Coend is the same as being an Initial object in the category of Cowedges
Coend⇒Initial : Coend F → Initial Cowedges
Coend⇒Initial c = record
{ ⊥ = cowedge
; ⊥-is-initial = record
{ ! = λ {A} → record { u = factor A ; commute = universal }
; !-unique = λ {A} f → unique {A} (Cowedge-Morphism.commute f)
}
}
where
open Coend c
Initial⇒Coend : Initial Cowedges → Coend F
Initial⇒Coend i = record
{ cowedge = ⊥
; factor = λ W → u {W₂ = W} !
; universal = commute !
; unique = λ {_} {g} x → !-unique (record { u = g ; commute = x })
}
where
open Initial.Initial i
open Cowedge-Morphism
private
variable
o ℓ e : Level
C D E : Category o ℓ e
module _ (F : Functor E (Functors (Product (Category.op C) C) D)) where
private
module C = Category C
module D = Category D
module E = Category E
module NT = NaturalTransformation
open D
open HomReasoning
open MR D
open Functor F
open Coend hiding (E)
open NT using (η)
CoendF : (∀ X → Coend (F₀ X)) → Functor E D
CoendF coend = record
{ F₀ = λ X → Coend.E (coend X)
; F₁ = F₁′
; identity = λ {A} → unique (coend A) (id-comm-sym ○ ∘-resp-≈ʳ (⟺ identity))
; homomorphism = λ {A B C} {f g} → unique (coend A) $ λ {Z} → begin
(F₁′ g ∘ F₁′ f) ∘ dinatural.α (coend A) Z ≈⟨ pullʳ (universal (coend A)) ⟩
(F₁′ g ∘ (dinatural.α (coend B) Z ∘ η (F₁ f) (Z , Z) ) ) ≈⟨ pullˡ (universal (coend B)) ⟩
((dinatural.α (coend C) Z ∘ η (F₁ g) (Z , Z)) ∘ η (F₁ f) (Z , Z)) ≈˘⟨ pushʳ homomorphism ⟩
dinatural.α (coend C) Z ∘ η (F₁ (g E.∘ f)) (Z , Z) ∎
; F-resp-≈ = λ {A B f g} eq → unique (coend A) $ λ {Z} → begin
F₁′ g ∘ dinatural.α (coend A) Z ≈⟨ universal (coend A) ⟩
dinatural.α (coend B) Z ∘ η (F₁ g) (Z , Z) ≈˘⟨ refl⟩∘⟨ F-resp-≈ eq ⟩
dinatural.α (coend B) Z ∘ η (F₁ f) (Z , Z) ∎
}
where F₁′ : ∀ {X Y} → X E.⇒ Y → Coend.E (coend X) ⇒ Coend.E (coend Y)
F₁′ {X} {Y} f = factor (coend X) $ record
{ E = Coend.E (coend Y)
; dinatural = dinatural (coend Y) ∘> F₁ f
}
-- A Natural Transformation between two functors induces an arrow between the
-- (object part of) the respective coends.
module _ {P Q : Functor (Product (Category.op C) C) D} (P⇒Q : NaturalTransformation P Q) where
open Coend renaming (E to coend)
open Category D
coend-η : {cp : Coend P} {cq : Coend Q} → coend cp ⇒ coend cq
coend-η {cp} {cq} = factor cp ((record
{ E = Coend.E cq
; dinatural = dtHelper record
{ α = λ c → dinatural.α cq c ∘ η (c , c)
; commute = λ {C} {C′} f → begin
id ∘ (αq C ∘ η (C , C)) ∘ P.₁ (f , C.id) ≈⟨ pushʳ assoc ⟩
(id ∘ αq C) ∘ (η (C , C) ∘ P.₁ (f , C.id)) ≈⟨ refl⟩∘⟨ nt.commute (f , C.id) ⟩
(id ∘ αq C) ∘ (Q.₁ (f , C.id) ∘ η (C′ , C)) ≈⟨ pullˡ assoc ⟩
(id ∘ αq C ∘ Q.₁ (f , C.id)) ∘ η (C′ , C) ≈⟨ αq-comm f ⟩∘⟨refl ⟩
(id ∘ αq C′ ∘ Q.₁ (C.id , f)) ∘ η (C′ , C) ≈⟨ pushˡ sym-assoc ⟩
(id ∘ αq C′) ∘ Q.₁ (C.id , f) ∘ η (C′ , C) ≈⟨ refl⟩∘⟨ nt.sym-commute (C.id , f) ⟩
(id ∘ αq C′) ∘ η (C′ , C′) ∘ P.₁ (C.id , f) ≈⟨ pullʳ sym-assoc ⟩
id ∘ (αq C′ ∘ η (C′ , C′)) ∘ P.₁ (C.id , f) ∎
}
}))
where
module nt = NaturalTransformation P⇒Q
open nt using (η)
open HomReasoning
module C = Category C
module P = Functor P
module Q = Functor Q
open DinaturalTransformation (dinatural cp) renaming (α to αp; commute to αp-comm)
open DinaturalTransformation (dinatural cq) renaming (α to αq; commute to αq-comm)
open Cowedge
open MR D
module _ {o ℓ e o′ ℓ′ e′} {C : Category o ℓ e} {D : Category o′ ℓ′ e′}
(F : Bifunctor (Category.op C) C D) where
private
Eq = CoconesTwist≅Cowedges F
module O = M D
open M (Cowedges.Cowedges F)
open Functor
open StrongEquivalence Eq renaming (F to F⇒)
-- Coends and Colimits are equivalent, in the category Cowedge F
Coend-as-Colimit : (coend : Coend F) → (cl : Colimit (Twist′ C D F)) → Coend.cowedge coend ≅ F₀ F⇒ (Colimit.initial.⊥ cl)
Coend-as-Colimit coend cl = Initial.up-to-iso (Cowedges.Cowedges F) (Coend⇒Initial F coend) (pres-Initial Eq initial)
where
open Colimit cl
-- Which then induces that the objects, in D, are also equivalent.
Coend-as-Colimit-on-Obj : (coend : Coend F) → (cl : Colimit (Twist′ C D F)) → Coend.E coend O.≅ Colimit.coapex cl
Coend-as-Colimit-on-Obj coend cl = record
{ from = Cowedge-Morphism.u (M._≅_.from X≅Y)
; to = Cowedge-Morphism.u (M._≅_.to X≅Y)
; iso = record
{ isoˡ = M._≅_.isoˡ X≅Y
; isoʳ = M._≅_.isoʳ X≅Y
}
}
where
X≅Y = Coend-as-Colimit coend cl
open Category D
|
Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0x48_notsx.log_21829_449.asm | ljhsiun2/medusa | 9 | 171412 | .global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r8
push %rax
push %rbp
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_D_ht+0x1c3ba, %rsi
lea addresses_normal_ht+0x1cefa, %rdi
nop
nop
xor %rax, %rax
mov $9, %rcx
rep movsw
nop
nop
nop
nop
and %r10, %r10
lea addresses_A_ht+0xbafa, %rbp
nop
nop
cmp %r10, %r10
movups (%rbp), %xmm6
vpextrq $1, %xmm6, %rax
nop
nop
xor $47743, %rbp
lea addresses_WT_ht+0x112fa, %rsi
nop
nop
and %rbx, %rbx
mov (%rsi), %ecx
cmp $12725, %rsi
lea addresses_WT_ht+0x45aa, %rdi
nop
nop
nop
add $64966, %rbx
movw $0x6162, (%rdi)
nop
nop
and %r10, %r10
lea addresses_WC_ht+0xa35e, %rbx
and $13743, %rdi
mov $0x6162636465666768, %r10
movq %r10, %xmm6
vmovups %ymm6, (%rbx)
nop
nop
nop
nop
add %rax, %rax
lea addresses_A_ht+0x2a0a, %rsi
lea addresses_WT_ht+0xc4fa, %rdi
add $24625, %r8
mov $59, %rcx
rep movsl
nop
nop
dec %rax
lea addresses_D_ht+0x1993a, %rbx
nop
sub %rax, %rax
mov (%rbx), %ecx
nop
nop
nop
nop
and %rbp, %rbp
lea addresses_WT_ht+0x57ba, %r10
nop
nop
nop
nop
nop
cmp %rbx, %rbx
mov (%r10), %r8
nop
nop
nop
sub %rbx, %rbx
lea addresses_UC_ht+0x12dba, %rsi
lea addresses_WT_ht+0x1affa, %rdi
nop
nop
nop
nop
nop
xor $64577, %r8
mov $17, %rcx
rep movsb
nop
nop
nop
nop
nop
sub %r10, %r10
lea addresses_normal_ht+0x6f7a, %rbx
nop
add %rax, %rax
mov $0x6162636465666768, %rdi
movq %rdi, (%rbx)
nop
nop
nop
nop
nop
sub $36515, %rbx
lea addresses_WC_ht+0xf762, %rsi
clflush (%rsi)
cmp %r10, %r10
mov (%rsi), %rbx
nop
nop
nop
and $6688, %rcx
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %rax
pop %r8
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r12
push %r8
push %rcx
push %rdx
// Store
lea addresses_normal+0x618a, %rcx
clflush (%rcx)
add $43854, %r10
movl $0x51525354, (%rcx)
nop
nop
nop
nop
nop
cmp $23801, %r11
// Faulty Load
lea addresses_PSE+0x11afa, %r10
clflush (%r10)
nop
nop
nop
and %r8, %r8
mov (%r10), %r12
lea oracles, %rdx
and $0xff, %r12
shlq $12, %r12
mov (%rdx,%r12,1), %r12
pop %rdx
pop %rcx
pop %r8
pop %r12
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': True, 'NT': False, 'AVXalign': False, 'size': 1, 'type': 'addresses_PSE', 'congruent': 0}}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 4, 'type': 'addresses_normal', 'congruent': 4}, 'OP': 'STOR'}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'NT': False, 'AVXalign': False, 'size': 8, 'type': 'addresses_PSE', 'congruent': 0}}
<gen_prepare_buffer>
{'dst': {'same': False, 'congruent': 8, 'type': 'addresses_normal_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 5, 'type': 'addresses_D_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 16, 'type': 'addresses_A_ht', 'congruent': 11}}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 4, 'type': 'addresses_WT_ht', 'congruent': 10}}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 2, 'type': 'addresses_WT_ht', 'congruent': 1}, 'OP': 'STOR'}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 32, 'type': 'addresses_WC_ht', 'congruent': 1}, 'OP': 'STOR'}
{'dst': {'same': False, 'congruent': 9, 'type': 'addresses_WT_ht'}, 'OP': 'REPM', 'src': {'same': True, 'congruent': 0, 'type': 'addresses_A_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'NT': True, 'AVXalign': False, 'size': 4, 'type': 'addresses_D_ht', 'congruent': 3}}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 8, 'type': 'addresses_WT_ht', 'congruent': 6}}
{'dst': {'same': False, 'congruent': 8, 'type': 'addresses_WT_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 5, 'type': 'addresses_UC_ht'}}
{'dst': {'same': False, 'NT': True, 'AVXalign': False, 'size': 8, 'type': 'addresses_normal_ht', 'congruent': 7}, 'OP': 'STOR'}
{'OP': 'LOAD', 'src': {'same': False, 'NT': True, 'AVXalign': False, 'size': 8, 'type': 'addresses_WC_ht', 'congruent': 2}}
{'33': 21829}
33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33
*/
|
src/words_engine/words_engine-trick_tables.ads | spr93/whitakers-words | 204 | 9443 | <gh_stars>100-1000
-- WORDS, a Latin dictionary, by <NAME> (USAF, Retired)
--
-- Copyright <NAME> (1936–2010)
--
-- This is a free program, which means it is proper to copy it and pass
-- it on to your friends. Consider it a developmental item for which
-- there is no charge. However, just for form, it is Copyrighted
-- (c). Permission is hereby freely given for any and all use of program
-- and data. You can sell it as your own, but at least tell me.
--
-- This version is distributed without obligation, but the developer
-- would appreciate comments and suggestions.
--
-- All parts of the WORDS system, source code and data files, are made freely
-- available to anyone who wishes to use them, for whatever purpose.
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
package Words_Engine.Trick_Tables is
Tricks_Exception : exception;
type Trick_Class is (TC_Flip_Flop, TC_Flip, TC_Internal, TC_Slur);
type Trick (Op : Trick_Class := TC_Flip_Flop) is
record
Max : Integer := 0;
case Op is
when TC_Flip_Flop =>
FF1 : Unbounded_String := Null_Unbounded_String;
FF2 : Unbounded_String := Null_Unbounded_String;
when TC_Flip =>
FF3 : Unbounded_String := Null_Unbounded_String;
FF4 : Unbounded_String := Null_Unbounded_String;
when TC_Internal =>
I1 : Unbounded_String := Null_Unbounded_String;
I2 : Unbounded_String := Null_Unbounded_String;
when TC_Slur =>
S1 : Unbounded_String := Null_Unbounded_String;
end case;
end record;
type TricksT is array (Integer range <>) of Trick;
type Strings is array (Integer range <>) of Unbounded_String;
function Member (Needle : Unbounded_String;
Haystack : Strings) return Boolean;
function "+" (Source : String) return Unbounded_String
renames To_Unbounded_String;
function Common_Prefix (S : String) return Boolean;
function Get_Tricks_Table (C : Character) return TricksT;
function Get_Slur_Tricks_Table (C : Character) return TricksT;
Any_Tricks : constant TricksT := (
(Max => 0, Op => TC_Internal, I1 => +"ae", I2 => +"e"),
(Max => 0, Op => TC_Internal, I1 => +"bul", I2 => +"bol"),
(Max => 0, Op => TC_Internal, I1 => +"bol", I2 => +"bul"),
(Max => 0, Op => TC_Internal, I1 => +"cl", I2 => +"cul"),
(Max => 0, Op => TC_Internal, I1 => +"cu", I2 => +"quu"),
(Max => 0, Op => TC_Internal, I1 => +"f", I2 => +"ph"),
(Max => 0, Op => TC_Internal, I1 => +"ph", I2 => +"f"),
(Max => 0, Op => TC_Internal, I1 => +"h", I2 => +""),
(Max => 0, Op => TC_Internal, I1 => +"oe", I2 => +"e"),
(Max => 0, Op => TC_Internal, I1 => +"vul", I2 => +"vol"),
(Max => 0, Op => TC_Internal, I1 => +"vol", I2 => +"vul"),
(Max => 0, Op => TC_Internal, I1 => +"uol", I2 => +"vul")
);
Mediaeval_Tricks : constant TricksT := (
-- Harrington/Elliott 1.1.1
(Max => 0, Op => TC_Internal, I1 => +"col", I2 => +"caul"),
-- Harrington/Elliott 1.3
(Max => 0, Op => TC_Internal, I1 => +"e", I2 => +"ae"),
(Max => 0, Op => TC_Internal, I1 => +"o", I2 => +"u"),
(Max => 0, Op => TC_Internal, I1 => +"i", I2 => +"y"),
-- Harrington/Elliott 1.3.1
(Max => 0, Op => TC_Internal, I1 => +"ism", I2 => +"sm"),
(Max => 0, Op => TC_Internal, I1 => +"isp", I2 => +"sp"),
(Max => 0, Op => TC_Internal, I1 => +"ist", I2 => +"st"),
(Max => 0, Op => TC_Internal, I1 => +"iz", I2 => +"z"),
(Max => 0, Op => TC_Internal, I1 => +"esm", I2 => +"sm"),
(Max => 0, Op => TC_Internal, I1 => +"esp", I2 => +"sp"),
(Max => 0, Op => TC_Internal, I1 => +"est", I2 => +"st"),
(Max => 0, Op => TC_Internal, I1 => +"ez", I2 => +"z"),
-- Harrington/Elliott 1.4
(Max => 0, Op => TC_Internal, I1 => +"di", I2 => +"z"),
(Max => 0, Op => TC_Internal, I1 => +"f", I2 => +"ph"),
(Max => 0, Op => TC_Internal, I1 => +"is", I2 => +"ix"),
(Max => 0, Op => TC_Internal, I1 => +"b", I2 => +"p"),
(Max => 0, Op => TC_Internal, I1 => +"d", I2 => +"t"),
(Max => 0, Op => TC_Internal, I1 => +"v", I2 => +"b"),
(Max => 0, Op => TC_Internal, I1 => +"v", I2 => +"f"),
(Max => 0, Op => TC_Internal, I1 => +"v", I2 => +"f"),
(Max => 0, Op => TC_Internal, I1 => +"s", I2 => +"x"),
-- Harrington/Elliott 1.4.1
(Max => 0, Op => TC_Internal, I1 => +"ci", I2 => +"ti"),
-- Harrington/Elliott 1.4.2
(Max => 0, Op => TC_Internal, I1 => +"nt", I2 => +"nct"),
(Max => 0, Op => TC_Internal, I1 => +"s", I2 => +"ns"),
-- Others
(Max => 0, Op => TC_Internal, I1 => +"ch", I2 => +"c"),
(Max => 0, Op => TC_Internal, I1 => +"c", I2 => +"ch"),
(Max => 0, Op => TC_Internal, I1 => +"th", I2 => +"t"),
(Max => 0, Op => TC_Internal, I1 => +"t", I2 => +"th")
);
end Words_Engine.Trick_Tables;
|
programs/oeis/171/A171477.asm | karttu/loda | 1 | 167433 | <reponame>karttu/loda
; A171477: a(n) = 6*a(n-1) - 8*a(n-2) + 1 for n > 1; a(0) = 1, a(1) = 7.
; 1,7,35,155,651,2667,10795,43435,174251,698027,2794155,11180715,44731051,178940587,715795115,2863245995,11453115051,45812722347,183251413675,733006703275,2932028910251,11728119835307,46912487729835,187649967696555,750599904340651,3002399684471467
mov $1,2
pow $1,$0
mov $0,2
sub $1,1
mul $1,2
mov $3,$1
mul $3,2
add $0,$3
mul $1,2
mov $2,$1
mov $4,1
mul $4,$1
add $0,$4
add $2,3
mul $2,$1
mov $1,$0
add $1,$2
div $1,12
mul $1,2
add $1,1
|
Mockingbird/Forest/Extensionality.agda | splintah/combinatory-logic | 1 | 6554 | open import Mockingbird.Forest using (Forest)
module Mockingbird.Forest.Extensionality {b ℓ} (forest : Forest {b} {ℓ}) where
open import Algebra using (RightCongruent)
open import Relation.Binary using (Rel; IsEquivalence; Setoid)
open import Level using (_⊔_)
open Forest forest
-- TODO: if the arguments to the predicates is{Mockingbird,Thrush,Cardinal,...}
-- are made implicit, then x can be implicit too.
Similar : Rel Bird (b ⊔ ℓ)
Similar A₁ A₂ = ∀ x → A₁ ∙ x ≈ A₂ ∙ x
infix 4 _≋_
_≋_ = Similar
-- A forest is called extensional if similarity implies equality.
IsExtensional : Set (b ⊔ ℓ)
IsExtensional = ∀ {A₁ A₂} → A₁ ≋ A₂ → A₁ ≈ A₂
-- A record to be used as an instance argument.
record Extensional : Set (b ⊔ ℓ) where
field
ext : IsExtensional
open Extensional ⦃ ... ⦄ public
ext′ : ⦃ _ : Extensional ⦄ → ∀ {A₁ A₂} → (∀ {x} → A₁ ∙ x ≈ A₂ ∙ x) → A₁ ≈ A₂
ext′ A₁≋A₂ = ext λ _ → A₁≋A₂
-- Similarity is an equivalence relation.
≋-isEquivalence : IsEquivalence _≋_
≋-isEquivalence = record
{ refl = λ _ → refl
; sym = λ x≋y z → sym (x≋y z)
; trans = λ x≋y y≋z w → trans (x≋y w) (y≋z w)
}
≋-congʳ : RightCongruent _≋_ _∙_
≋-congʳ {w} {x} {y} x≋y = λ _ → congʳ (x≋y w)
|
Ex1.agda | poscat0x04/CS410 | 0 | 16852 | <filename>Ex1.agda
{-# OPTIONS --allow-unsolved-metas #-}
------------------------------------------------------------------------------
------------------------------------------------------------------------------
-- CS410 2017/18 Exercise 1 VECTORS AND FRIENDS (worth 25%)
------------------------------------------------------------------------------
------------------------------------------------------------------------------
-- NOTE (19/9/17) This file is currently incomplete: more will arrive on
-- GitHub.
-- MARK SCHEME (transcribed from paper): the (m) numbers add up to slightly
-- more than 25, so should be taken as the maximum number of marks losable on
-- the exercise. In fact, I did mark it negatively, but mostly because it was
-- done so well (with Agda's help) that it was easier to find the errors.
------------------------------------------------------------------------------
-- Dependencies
------------------------------------------------------------------------------
open import CS410-Prelude
------------------------------------------------------------------------------
-- Vectors
------------------------------------------------------------------------------
data Vec (X : Set) : Nat -> Set where -- like lists, but length-indexed
[] : Vec X zero
_,-_ : {n : Nat} -> X -> Vec X n -> Vec X (suc n)
infixr 4 _,-_ -- the "cons" operator associates to the right
-- I like to use the asymmetric ,- to remind myself that the element is to
-- the left and the rest of the list is to the right.
-- Vectors are useful when there are important length-related safety
-- properties.
------------------------------------------------------------------------------
-- Heads and Tails
------------------------------------------------------------------------------
-- We can rule out nasty head and tail errors by insisting on nonemptiness!
--??--1.1-(2)-----------------------------------------------------------------
vHead : {X : Set}{n : Nat} -> Vec X (suc n) -> X
vHead (x ,- xs) = x
vTail : {X : Set}{n : Nat} -> Vec X (suc n) -> Vec X n
vTail (x ,- xs) = xs
vHeadTailFact : {X : Set}{n : Nat}(xs : Vec X (suc n)) ->
(vHead xs ,- vTail xs) == xs
vHeadTailFact (x ,- xs) = refl (x ,- xs)
--??--------------------------------------------------------------------------
------------------------------------------------------------------------------
-- Concatenation and its Inverse
------------------------------------------------------------------------------
--??--1.2-(2)-----------------------------------------------------------------
_+V_ : {X : Set}{m n : Nat} -> Vec X m -> Vec X n -> Vec X (m +N n)
[] +V ys = ys
(x ,- xs) +V ys = x ,- xs +V ys
infixr 4 _+V_
vChop : {X : Set}(m : Nat){n : Nat} -> Vec X (m +N n) -> Vec X m * Vec X n
vChop zero xs = [] , xs
vChop (suc m) (x ,- xs) with vChop m xs
vChop (suc m) (x ,- xs) | fst₁ , snd₁ = (x ,- fst₁) , snd₁
vChopAppendFact : {X : Set}{m n : Nat}(xs : Vec X m)(ys : Vec X n) ->
vChop m (xs +V ys) == (xs , ys)
vChopAppendFact [] ys = refl ([] , ys)
vChopAppendFact (x ,- xs) ys rewrite vChopAppendFact xs ys = refl ((x ,- xs) , ys)
--??--------------------------------------------------------------------------
------------------------------------------------------------------------------
-- Map, take I
------------------------------------------------------------------------------
-- Implement the higher-order function that takes an operation on
-- elements and does it to each element of a vector. Use recursion
-- on the vector.
-- Note that the type tells you the size remains the same.
-- Show that if the elementwise function "does nothing", neither does
-- its vMap. "map of identity is identity"
-- Show that two vMaps in a row can be collapsed to just one, or
-- "composition of maps is map of compositions"
--??--1.3-(2)-----------------------------------------------------------------
vMap : {X Y : Set} -> (X -> Y) -> {n : Nat} -> Vec X n -> Vec Y n
vMap f [] = []
vMap f (x ,- xs) = f x ,- vMap f xs
vMapIdFact : {X : Set}{f : X -> X}(feq : (x : X) -> f x == x) ->
{n : Nat}(xs : Vec X n) -> vMap f xs == xs
vMapIdFact feq [] = refl []
vMapIdFact feq (x ,- xs) rewrite feq x | vMapIdFact feq xs = refl (x ,- xs)
vMapCpFact : (X Y Z : Set)(f : Y -> Z)(g : X -> Y)(h : X -> Z)
(heq : (x : X) -> f (g x) == h x) ->
{n : Nat}(xs : Vec X n) ->
vMap f (vMap g xs) == vMap h xs
vMapCpFact _ _ _ _ _ _ heq [] = refl []
vMapCpFact X Y Z f g h heq (x ,- xs) rewrite heq x | vMapCpFact X Y Z f g h heq xs = refl (h x ,- vMap h xs)
--??--------------------------------------------------------------------------
------------------------------------------------------------------------------
-- vMap and +V
------------------------------------------------------------------------------
-- Show that if you've got two vectors of Xs and a function from X to Y,
-- and you want to concatenate and map, it doesn't matter which you do
-- first.
--??--1.4-(1)-----------------------------------------------------------------
vMap+VFact : {X Y : Set}(f : X -> Y) ->
{m n : Nat}(xs : Vec X m)(xs' : Vec X n) ->
vMap f (xs +V xs') == (vMap f xs +V vMap f xs')
vMap+VFact f [] xs' = refl (vMap f xs')
vMap+VFact f (x ,- xs) xs' rewrite vMap+VFact f xs xs' = refl _
--??--------------------------------------------------------------------------
-- Think about what you could prove, relating vMap with vHead, vTail, vChop...
-- Now google "<NAME>" "Theorems for Free"
------------------------------------------------------------------------------
-- Applicative Structure (giving mapping and zipping cheaply)
------------------------------------------------------------------------------
--??--1.5-(2)-----------------------------------------------------------------
-- HINT: you will need to override the default invisibility of n to do this.
vPure : {X : Set} -> X -> {n : Nat} -> Vec X n
vPure x {zero} = []
vPure x {suc n} = x ,- vPure x
_$V_ : {X Y : Set}{n : Nat} -> Vec (X -> Y) n -> Vec X n -> Vec Y n
[] $V [] = []
x ,- fs $V x₁ ,- xs = x x₁ ,- (fs $V xs)
infixl 3 _$V_ -- "Application associates to the left,
-- rather as we all did in the sixties." (Roger Hindley)
-- Pattern matching and recursion are forbidden for the next two tasks.
-- implement vMap again, but as a one-liner
vec : {X Y : Set} -> (X -> Y) -> {n : Nat} -> Vec X n -> Vec Y n
vec f xs = vPure f $V xs
-- implement the operation which pairs up corresponding elements
vZip : {X Y : Set}{n : Nat} -> Vec X n -> Vec Y n -> Vec (X * Y) n
vZip [] [] = []
vZip (x ,- xs) (x₁ ,- ys) = (x , x₁) ,- vZip xs ys
--??--------------------------------------------------------------------------
------------------------------------------------------------------------------
-- Applicative Laws
------------------------------------------------------------------------------
-- According to "Applicative programming with effects" by
-- <NAME> and <NAME>
-- some laws should hold for applicative functors.
-- Check that this is the case.
--??--1.6-(2)-----------------------------------------------------------------
vIdentity : {X : Set}{f : X -> X}(feq : (x : X) -> f x == x) ->
{n : Nat}(xs : Vec X n) -> (vPure f $V xs) == xs
vIdentity feq [] = refl []
vIdentity feq (x ,- xs) rewrite feq x | vIdentity feq xs = refl (x ,- xs)
vHomomorphism : {X Y : Set}(f : X -> Y)(x : X) ->
{n : Nat} -> (vPure f $V vPure x) == vPure (f x) {n}
vHomomorphism f x {zero} = refl []
vHomomorphism f x {suc n} rewrite vHomomorphism f x {n} = refl (f x ,- vPure (f x))
vInterchange : {X Y : Set}{n : Nat}(fs : Vec (X -> Y) n)(x : X) ->
(fs $V vPure x) == (vPure (_$ x) $V fs)
vInterchange [] x = refl []
vInterchange (x₁ ,- fs) x rewrite vInterchange fs x = refl _
vComposition : {X Y Z : Set}{n : Nat}
(fs : Vec (Y -> Z) n)(gs : Vec (X -> Y) n)(xs : Vec X n) ->
(vPure _<<_ $V fs $V gs $V xs) == (fs $V (gs $V xs))
vComposition [] [] [] = refl []
vComposition (x₁ ,- fs) (x₂ ,- gs) (x ,- xs) rewrite vComposition fs gs xs = refl _
--??--------------------------------------------------------------------------
------------------------------------------------------------------------------
-- Order-Preserving Embeddings (also known in the business as "thinnings")
------------------------------------------------------------------------------
-- What have these to do with Pascal's Triangle?
data _<=_ : Nat -> Nat -> Set where
oz : zero <= zero
os : {n m : Nat} -> n <= m -> suc n <= suc m
o' : {n m : Nat} -> n <= m -> n <= suc m
-- Find all the values in each of the following <= types.
-- This is a good opportunity to learn to use C-c C-a with the -l option
-- (a.k.a. "google the type" without "I feel lucky")
-- The -s n option also helps.
--??--1.7-(1)-----------------------------------------------------------------
all0<=4 : Vec (0 <= 4) 3
all0<=4 = o' (o' (o' (o' oz))) ,- o' (o' (o' (o' oz))) ,- o' (o' (o' (o' oz))) ,- []
all1<=4 : Vec (1 <= 4) 2
all1<=4 = os (o' (o' (o' oz))) ,- os (o' (o' (o' oz))) ,- []
all2<=4 : Vec (2 <= 4) _
all2<=4 = os (o' (o' (os oz))) ,- os (os (o' (o' oz))) ,- []
all3<=4 : Vec (3 <= 4) zero
all3<=4 = []
all4<=4 : Vec (4 <= 4) zero
all4<=4 = []
-- Prove the following. A massive case analysis "rant" is fine.
no5<=4 : 5 <= 4 -> Zero
no5<=4 (os (os (os (os ()))))
no5<=4 (os (os (os (o' ()))))
no5<=4 (os (os (o' (os ()))))
no5<=4 (os (os (o' (o' ()))))
no5<=4 (os (o' (os (os ()))))
no5<=4 (os (o' (os (o' ()))))
no5<=4 (os (o' (o' (os ()))))
no5<=4 (os (o' (o' (o' ()))))
no5<=4 (o' (os (os (os ()))))
no5<=4 (o' (os (os (o' ()))))
no5<=4 (o' (os (o' (os ()))))
no5<=4 (o' (os (o' (o' ()))))
no5<=4 (o' (o' (os (os ()))))
no5<=4 (o' (o' (os (o' ()))))
no5<=4 (o' (o' (o' (os ()))))
no5<=4 (o' (o' (o' (o' ()))))
--??--------------------------------------------------------------------------
------------------------------------------------------------------------------
-- Order-Preserving Embeddings Select From Vectors
------------------------------------------------------------------------------
-- Use n <= m to encode the choice of n elements from an m-Vector.
-- The os constructor tells you to take the next element of the vector;
-- the o' constructor tells you to omit the next element of the vector.
--??--1.8-(2)-----------------------------------------------------------------
_<?=_ : {X : Set}{n m : Nat} -> n <= m -> Vec X m
-> Vec X n
oz <?= [] = []
os th <?= (x ,- xs) = x ,- (th <?= xs)
o' th <?= (x ,- xs) = th <?= xs
-- it shouldn't matter whether you map then select or select then map
vMap<?=Fact : {X Y : Set}(f : X -> Y)
{n m : Nat}(th : n <= m)(xs : Vec X m) ->
vMap f (th <?= xs) == (th <?= vMap f xs)
vMap<?=Fact f oz [] = refl []
vMap<?=Fact f (os th) (x ,- xs) rewrite vMap<?=Fact f th xs = refl _
vMap<?=Fact f (o' th) (x ,- xs) = vMap<?=Fact f th xs
--??--------------------------------------------------------------------------
------------------------------------------------------------------------------
-- Our Favourite Thinnings
------------------------------------------------------------------------------
-- Construct the identity thinning and the empty thinning.
--??--1.9-(1)-----------------------------------------------------------------
oi : {n : Nat} -> n <= n
oi {zero} = oz
oi {suc n} = os oi
oe : {n : Nat} -> 0 <= n
oe {zero} = oz
oe {suc n} = o' oe
--??--------------------------------------------------------------------------
-- Show that all empty thinnings are equal to yours.
--??--1.10-(1)----------------------------------------------------------------
oeUnique : {n : Nat}(th : 0 <= n) -> th == oe
oeUnique oz = refl oz
oeUnique (o' i) rewrite oeUnique i = refl (o' oe)
--??--------------------------------------------------------------------------
-- Show that there are no thinnings of form big <= small (TRICKY)
-- Then show that all the identity thinnings are equal to yours.
-- Note that you can try the second even if you haven't finished the first.
-- HINT: you WILL need to expose the invisible numbers.
-- HINT: check CS410-Prelude for a reminder of >=
--??--1.11-(3)----------------------------------------------------------------
thinMore : {n m : Nat} -> suc n <= m -> n <= m
thinMore (os n<=m) = o' n<=m
thinMore (o' n<=m) = o' (thinMore n<=m)
oTooBig : {n m : Nat} -> n >= m -> suc n <= m -> Zero
oTooBig {zero} {.(suc _)} n>=m (os th) = n>=m
oTooBig {zero} {.(suc _)} n>=m (o' th) = n>=m
oTooBig {suc n} {.(suc _)} n>=m (os th) = oTooBig n>=m th
oTooBig {suc n} {.(suc _)} n>=m (o' th) = oTooBig n>=m (thinMore th)
oiUnique : {n : Nat}(th : n <= n) -> th == oi
oiUnique oz = refl oz
oiUnique (os th) rewrite oiUnique th = refl (os oi)
oiUnique {m} (o' th) with oTooBig (refl->= m) th
oiUnique {.(suc _)} (o' th) | ()
--??--------------------------------------------------------------------------
-- Show that the identity thinning selects the whole vector
--??--1.12-(1)----------------------------------------------------------------
id-<?= : {X : Set}{n : Nat}(xs : Vec X n) -> (oi <?= xs) == xs
id-<?= [] = refl []
id-<?= (x ,- xs) rewrite id-<?= xs = refl (x ,- xs)
--??--------------------------------------------------------------------------
------------------------------------------------------------------------------
-- Composition of Thinnings
------------------------------------------------------------------------------
-- Define the composition of thinnings and show that selecting by a
-- composite thinning is like selecting then selecting again.
-- A small bonus applies to minimizing the length of the proof.
-- To collect the bonus, you will need to think carefully about
-- how to make the composition as *lazy* as possible.
--??--1.13-(3)----------------------------------------------------------------
_o>>_ : {p n m : Nat} -> p <= n -> n <= m -> p <= m
th o>> oz = th
os th o>> os th' = os (th o>> th')
o' th o>> os th' = o' (th o>> th')
th o>> o' th' = o' (th o>> th')
cp-<?= : {p n m : Nat}(th : p <= n)(th' : n <= m) ->
{X : Set}(xs : Vec X m) ->
((th o>> th') <?= xs) == (th <?= (th' <?= xs))
cp-<?= th oz [] = refl (th <?= [])
cp-<?= oz (o' th') (x ,- xs) = cp-<?= oz th' xs
cp-<?= (os th) (os th') (x ,- xs) rewrite cp-<?= th th' xs = refl (x ,- (th <?= (th' <?= xs)))
cp-<?= (os th) (o' th') (x ,- xs) = cp-<?= (os th) th' xs
cp-<?= (o' th) (os th') (x ,- xs) = cp-<?= th th' xs
cp-<?= (o' th) (o' th') (x ,- xs) = cp-<?= (o' th) th' xs
--??--------------------------------------------------------------------------
------------------------------------------------------------------------------
-- <NAME>
------------------------------------------------------------------------------
--??--1.14-(3)----------------------------------------------------------------
idThen-o>> : {n m : Nat}(th : n <= m) -> (oi o>> th) == th
idThen-o>> oz = refl oz
idThen-o>> (os th) rewrite idThen-o>> th = refl (os th)
idThen-o>> (o' th) rewrite idThen-o>> th = refl (o' th)
idAfter-o>> : {n m : Nat}(th : n <= m) -> (th o>> oi) == th
idAfter-o>> oz = refl oz
idAfter-o>> (os th) rewrite idAfter-o>> th = refl (os th)
idAfter-o>> (o' th) rewrite idAfter-o>> th = refl (o' th)
assoc-o>> : {q p n m : Nat}(th0 : q <= p)(th1 : p <= n)(th2 : n <= m) ->
((th0 o>> th1) o>> th2) == (th0 o>> (th1 o>> th2))
assoc-o>> th0 th1 oz = refl (th0 o>> th1)
assoc-o>> th0 (o' th1) (os th2) rewrite assoc-o>> th0 th1 th2 = refl (o' (th0 o>> (th1 o>> th2)))
assoc-o>> (os th0) (os th1) (os th2) rewrite assoc-o>> th0 th1 th2 = refl (os (th0 o>> (th1 o>> th2)))
assoc-o>> (o' th0) (os th1) (os th2) rewrite assoc-o>> th0 th1 th2 = refl (o' (th0 o>> (th1 o>> th2)))
assoc-o>> th0 th1 (o' th2) rewrite assoc-o>> th0 th1 th2 = refl (o' (th0 o>> (th1 o>> th2)))
--??--------------------------------------------------------------------------
------------------------------------------------------------------------------
-- Vectors as Arrays
------------------------------------------------------------------------------
-- We can use 1 <= n as the type of bounded indices into a vector and do
-- a kind of "array projection". First we select a 1-element vector from
-- the n-element vector, then we take its head to get the element out.
vProject : {n : Nat}{X : Set} -> Vec X n -> 1 <= n -> X
vProject xs i = vHead (i <?= xs)
-- Your (TRICKY) mission is to reverse the process, tabulating a function
-- from indices as a vector. Then show that these operations are inverses.
--??--1.15-(3)----------------------------------------------------------------
selectHead : (n : Nat) -> 1 <= (suc n)
selectHead n = os oe
-- HINT: composition of functions
vTabulate : {n : Nat}{X : Set} -> (1 <= n -> X) -> Vec X n
vTabulate {zero} f = []
vTabulate {suc n} f = (f (selectHead n)) ,- (vTabulate (\p -> f (o' p)))
-- This should be easy if vTabulate is correct.
vTabulateProjections : {n : Nat}{X : Set}(xs : Vec X n) ->
vTabulate (vProject xs) == xs
vTabulateProjections [] = refl []
vTabulateProjections (x ,- xs) rewrite vTabulateProjections xs = refl (x ,- xs)
-- HINT: oeUnique
vProjectFromTable : {n : Nat}{X : Set}(f : 1 <= n -> X)(i : 1 <= n) ->
vProject (vTabulate f) i == f i
vProjectFromTable {.(suc _)} {X} f (os i) with oeUnique i
vProjectFromTable {.(suc _)} {X} f (os .oe) | refl .oe = refl (f (os oe))
vProjectFromTable {.(suc _)} {X} f (o' i) = vProjectFromTable (λ z → f (o' z)) i
--??--------------------------------------------------------------------------
|
UniDB/Subst/Reg.agda | skeuchel/unidb-agda | 0 | 10239 | <filename>UniDB/Subst/Reg.agda
module UniDB.Subst.Reg where
open import UniDB.Spec
open import UniDB.Subst.Core
open import UniDB.Morph.Reg
open import UniDB.Morph.WeakenPrime
module _ {T : STX} {{vrT : Vr T}} {{wkT : Wk T}} {{apTT : Ap T T}} where
instance
iCompReg : Comp (Reg T)
_⊙_ {{iCompReg}} (baseR ξ) ζ = ξ ⊡ ζ
_⊙_ {{iCompReg}} (snocR {γ₁} {γ₂} ξ t) ζ = snocR (ξ ⊙ ζ) (ap {T} ζ t)
iWkmHomReg : WkmHom (Reg T)
wkm-zero {{iWkmHomReg}} = refl
wkm-suc {{iWkmHomReg}} δ = refl
iWkmBetaReg : WkmBeta T (Reg T)
wkm-beta {{iWkmBetaReg}} t = refl
reg-zero : (γ : Dom) → Reg T zero γ
reg-zero zero = baseR baseW
reg-zero (suc γ) = reg-zero γ ⊙ wkm {Reg T} 1
complete : (γ₁ γ₂ : Dom) (f : Ix γ₁ → T γ₂) → Reg T γ₁ γ₂
complete zero γ₂ f = reg-zero γ₂
complete (suc γ₁) γ₂ f = snocR (complete γ₁ γ₂ (f ∘ suc)) (f zero)
⊡-⊙-assoc : {γ₁ γ₂ γ₃ γ₄ : Dom} (ξ₁ : Weaken` γ₁ γ₂) (ξ₂ : Reg T γ₂ γ₃) (ξ₃ : Reg T γ₃ γ₄) →
ξ₁ ⊡ (ξ₂ ⊙ ξ₃) ≡ (ξ₁ ⊡ ξ₂) ⊙ ξ₃
⊡-⊙-assoc ξ₁ (baseR ξ₂) ξ₃ = ⊡-⊡-assoc ξ₁ ξ₂ ξ₃
⊡-⊙-assoc baseW ξ₂ ξ₃ rewrite idm-⊡ {Weaken`} {Reg T} (ξ₂ ⊙ ξ₃) | idm-⊡ {Weaken`} {Reg T} ξ₂ = refl
⊡-⊙-assoc (stepW ξ₁) (snocR ξ₂ t) ξ₃ = ⊡-⊙-assoc ξ₁ ξ₂ ξ₃
wk₁-⊡ : {γ₁ γ₂ γ₃ : Dom} (ξ₁ : Weaken` γ₁ γ₂) (ξ₂ : Reg T γ₂ γ₃) →
wk₁ (_⊡_ {Weaken`} {Reg T} {Reg T} ξ₁ ξ₂) ≡ ξ₁ ⊡ wk₁ ξ₂
wk₁-⊡ ξ₁ (baseR ξ) = refl
wk₁-⊡ baseW (snocR ξ₂ t) = refl
wk₁-⊡ (stepW ξ₁) (snocR ξ₂ t) = wk₁-⊡ ξ₁ ξ₂
module _
{T : STX} {{vrT : Vr T}} {{wkT : Wk T}} {{apTT : Ap T T}} {{wkVrT : WkVr T}}
where
instance
iCompIdmReg : {{apRelTT : ApRel T T}} {{apIdmTT : ApIdm T T}} → CompIdm (Reg T)
⊙-idm {{iCompIdmReg}} (baseR ξ) = refl
⊙-idm {{iCompIdmReg}} (snocR ξ t) = cong₂ snocR (⊙-idm {Reg T} ξ) (ap-idm` {T} t)
idm-⊙ {{iCompIdmReg}} ξ = idm-⊡ {Weaken`} {Reg T} ξ
lk-⊡ : {{apVr : ApVr T}}
{γ₁ γ₂ γ₃ : Dom} (ξ₁ : Weaken` γ₁ γ₂) (ξ₂ : Reg T γ₂ γ₃) →
(i : Ix γ₁) → lk {T} {Reg T} (ξ₁ ⊡ ξ₂) i ≡ ap {T} ξ₂ (lk {T} ξ₁ i)
lk-⊡ ξ₁ (baseR ξ₂) i = begin
lk (ξ₁ ⊙ ξ₂) i ≡⟨ lk-ren-comp {T} ξ₁ ξ₂ i ⟩
lk ξ₂ (lk ξ₁ i) ≡⟨ sym (ap-vr {T} (baseR ξ₂) (lk ξ₁ i)) ⟩
ap {T} (baseR ξ₂) (vr (lk ξ₁ i)) ≡⟨ cong (ap {T} (baseR ξ₂)) (sym (lk-ren {T} ξ₁ i)) ⟩
ap {T} (baseR ξ₂) (lk ξ₁ i) ∎
lk-⊡ baseW ξ₂ i = begin
lk {T} {Reg T} (baseW ⊡ ξ₂) i ≡⟨ cong₂ lk (idm-⊡ {Weaken`} ξ₂) refl ⟩
lk {T} {Reg T} ξ₂ i ≡⟨ sym (ap-vr {T} ξ₂ i) ⟩
ap {T} ξ₂ (vr i) ∎
lk-⊡ (stepW ξ₁) (snocR ξ₂ t) i = begin
lk {T} {Reg T} (ξ₁ ⊡ ξ₂) i ≡⟨ lk-⊡ ξ₁ ξ₂ i ⟩
ap {T} ξ₂ (vr (lk ξ₁ i)) ≡⟨ ap-vr {T} ξ₂ (lk ξ₁ i) ⟩
lk ξ₂ (lk ξ₁ i) ≡⟨ refl ⟩
lk (snocR ξ₂ t) (suc (lk ξ₁ i)) ≡⟨ sym (ap-vr {T} (snocR ξ₂ t) (suc (lk ξ₁ i))) ⟩
ap {T} (snocR ξ₂ t) (vr (suc (lk ξ₁ i))) ∎
instance
iLkCompApReg : {{apVr : ApVr T}} → LkCompAp T (Reg T)
lk-⊙-ap {{iLkCompApReg}} (baseR ξ₁) ξ₂ i = lk-⊡ ξ₁ ξ₂ i
lk-⊙-ap {{iLkCompApReg}} (snocR ξ₁ t) ξ₂ zero = refl
lk-⊙-ap {{iLkCompApReg}} (snocR ξ₁ t) ξ₂ (suc i) = lk-⊙-ap {T} ξ₁ ξ₂ i
wk₁-⊙ : {{apWkTT : ApWk T T}}
{γ₁ γ₂ γ₃ : Dom} (ξ₁ : Reg T γ₁ γ₂) (ξ₂ : Reg T γ₂ γ₃) →
wk₁ (ξ₁ ⊙ ξ₂) ≡ wk₁ ξ₁ ⊙ snocR (wk₁ ξ₂) (Vr.vr vrT zero)
wk₁-⊙ (baseR ξ) ξ₂ = wk₁-⊡ ξ ξ₂
wk₁-⊙ (snocR ξ₁ t) ξ₂ = cong₂ snocR (wk₁-⊙ ξ₁ ξ₂) (sym (ap-wk₁ {T} ξ₂ t))
instance
iUpCompReg : {{apVrT : ApVr T}} {{apWkTT : ApWk T T}} → UpComp (Reg T)
⊙-↑₁ {{iUpCompReg}} ξ₁ ξ₂ = cong₂ snocR
(wk₁-⊙ ξ₁ ξ₂)
(sym (ap-vr {T} (snocR (wk₁ ξ₂) (vr zero)) zero))
iCompAssocReg : {{apVrT : ApVr T}} {{apCompT : ApComp T T}} {{apWkTT : ApWk T T}} →
CompAssoc (Reg T)
⊙-assoc {{iCompAssocReg}} (baseR ξ₁) ξ₂ ξ₃ = ⊡-⊙-assoc ξ₁ ξ₂ ξ₃
⊙-assoc {{iCompAssocReg}} (snocR ξ₁ t) ξ₂ ξ₃ =
cong₂ snocR (⊙-assoc {Reg T} ξ₁ ξ₂ ξ₃) (ap-⊙ {T} ξ₂ ξ₃ t)
⊙-wkm₁-reg : {{apWkmWkTT : ApWkmWk T T}}
{γ₁ γ₂ : Dom} (ξ : Reg T γ₁ γ₂) →
ξ ⊙ wkm {Reg T} 1 ≡ wk₁ ξ
⊙-wkm₁-reg (baseR ξ) = refl
⊙-wkm₁-reg (snocR ξ t) rewrite sym (wk1-wk₁ t) =
cong₂ snocR (⊙-wkm₁-reg ξ) (ap-wkm-wk {T} 1 t)
instance
iWkmCommReg : {{apVr : ApVr T}} {{apCompT : ApComp T T}} {{apWkTT : ApWk T T}}
{{apWkmWkTT : ApWkmWk T T}} {{apRelTT : ApRel T T}} {{apIdmTT : ApIdm T T}} →
WkmComm (Reg T)
wkm₁-comm {{iWkmCommReg}} (baseR baseW) = refl
wkm₁-comm {{iWkmCommReg}} (baseR (stepW ξ)) rewrite idm-⊙ {Weaken`} ξ = refl
wkm₁-comm {{iWkmCommReg}} (snocR ξ t) = ⊙-wkm₁-reg (snocR ξ t)
|
tests/src/testsuite-encode_decode-random.ads | Fabien-Chouteau/COBS | 0 | 19111 | <reponame>Fabien-Chouteau/COBS<gh_stars>0
private
package Testsuite.Encode_Decode.Random is
procedure Add_Tests (Suite : in out AUnit.Test_Suites.Test_Suite'Class);
end Testsuite.Encode_Decode.Random;
|
language/alloy/human_life2.als | pogin503/vbautil | 0 | 3818 | <reponame>pogin503/vbautil<gh_stars>0
abstract sig Person {
father: lone Man,
mother: lone Woman,
sibling: set Person
}
sig Man extends Person {
wife: lone Woman
}
sig Woman extends Person {
husband: lone Man,
}
fun siblings (p: Person) : set Person {
}
pred sibling (p, p': Person) {
sibling = p.mother = p'.mother and p.father = p'.father
}
fact {
-- Biology
no p: Person | p in p.^(mother + father + sibling)
-- sibling = p: Person |
-- SocialConvention
no (wife + husband ) & ^(mother + father)
}
fact Terminology {
wife = ~husband
}
assert NoSelfFather {
no m: Man | m = m.father
}
check NoSelfFather
fun grandpas (p: Person) : set Person {
let parent = mother + father + father.wife + mother.husband |
p.parent.parent & Man
}
pred ownGrandpa (p: Person) {
p in grandpas [p]
}
pred show (p: Person) {
p in grandpas [p]
#p.sibling >= 2
}
run show for 6
|
programs/oeis/185/A185456.asm | neoneye/loda | 22 | 87643 | ; A185456: Payphone packing sequence.
; 1,3,5,8,9,14,15,16,17,26,27,28,29,30,31,32,33,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124
mov $1,$0
seq $0,4760 ; List of numbers whose binary expansion does not begin 10.
lpb $1
add $0,1
mov $1,$2
lpe
add $0,1
|
programs/oeis/068/A068379.asm | karttu/loda | 1 | 85570 | ; A068379: Engel expansion of sinh(1/2).
; 2,24,80,168,288,440,624,840,1088,1368,1680,2024,2400,2808,3248,3720,4224,4760,5328,5928,6560,7224,7920,8648,9408,10200,11024,11880,12768,13688,14640,15624,16640,17688,18768,19880,21024,22200,23408,24648,25920,27224,28560,29928,31328,32760,34224,35720,37248,38808,40400,42024,43680,45368,47088,48840,50624,52440,54288,56168,58080,60024,62000,64008,66048,68120,70224,72360,74528,76728,78960,81224,83520,85848,88208,90600,93024,95480,97968,100488,103040,105624,108240,110888,113568,116280,119024,121800,124608,127448,130320,133224,136160,139128,142128,145160,148224,151320,154448,157608,160800,164024,167280,170568,173888,177240,180624,184040,187488,190968,194480,198024,201600,205208,208848,212520,216224,219960,223728,227528,231360,235224,239120,243048,247008,251000,255024,259080,263168,267288,271440,275624,279840,284088,288368,292680,297024,301400,305808,310248,314720,319224,323760,328328,332928,337560,342224,346920,351648,356408,361200,366024,370880,375768,380688,385640,390624,395640,400688,405768,410880,416024,421200,426408,431648,436920,442224,447560,452928,458328,463760,469224,474720,480248,485808,491400,497024,502680,508368,514088,519840,525624,531440,537288,543168,549080,555024,561000,567008,573048,579120,585224,591360,597528,603728,609960,616224,622520,628848,635208,641600,648024,654480,660968,667488,674040,680624,687240,693888,700568,707280,714024,720800,727608,734448,741320,748224,755160,762128,769128,776160,783224,790320,797448,804608,811800,819024,826280,833568,840888,848240,855624,863040,870488,877968,885480,893024,900600,908208,915848,923520,931224,938960,946728,954528,962360,970224,978120,986048,994008
mul $0,4
mov $1,$0
add $1,1
pow $1,2
sub $1,2
div $1,2
mul $1,2
add $1,2
|
other.7z/SFC.7z/SFC/ソースデータ/ヨッシーアイランド/ツール/press/Gdefchr4.asm | prismotizm/gigaleak | 0 | 7428 | Name: Gdefchr4.asm
Type: file
Size: 5091
Last-Modified: '2016-05-13T04:52:55Z'
SHA-1: 707CE5F699AB03EC61A75F6A23117281400E01C1
Description: null
|
hello_world_1/hello_world.asm | NrdyBhu1/learning-assembly-lang | 1 | 85250 | <reponame>NrdyBhu1/learning-assembly-lang
segment .data ; defining data segment
text db "Hello, World!",10 ; defining text = Hello, World!,10 where 10 is \n escape char
textLn equ $-text ; setting textln equal to len of text
segment .text ; text segment
global _start ; setting global to start
_exit: ; call to exit the program
mov rax, 60 ; id of syscall
mov rdi, 0 ; exit code
syscall ; syscall
ret ; ret
_start: ; global main
mov rax, 1 ; id of write syscall
mov rdi, 1 ; fd
mov rsi, text ; write text param
mov rdx, textLn ; write text len param
syscall ; syscall
call _exit ; calling exit
ret ; ret
|
KitsuneServer/AntlrLibrary/KitsuneGrammer.g4 | gone63/application-development-kit | 12 | 5111 | grammar KitsuneGrammer;
/*
* Parser Rules
*/
prog: expr+ ;
expr : '-' expr #NegativeNumber
| '(' expr ')' #Parens
| expr '.' op=('length'|'substr'|'replace' | 'urlencode' | 'distinct' | 'tolower' | 'toupper' | 'split' | 'indexof' | 'contains' | 'SubStr' | 'Length' | 'decode' | 'find' | 'tostring' | 'tonumber' ) '(' (expr ( ',' expr)* )* ')' #PostfixUnaryWithArg
| expr '.' op=('offset' | 'currentpagenumber' | 'nextpage' | 'nextpage.url' | 'prevpage' | 'previouspage.url' | 'pagesize' | 'firstpage' | 'lastpage' ) #ViewProperties
| expr '.' op=('geturl' | 'setobject') '(' (expr ( ',' expr)* ) ')' #PostfixUnaryView
| op=('length' | 'len') '(' expr ( ',' expr)* ')' #PrefixUnaryFunction
| PREFIXUNARY expr #PrefixUnary
| expr op=('*'|'/'|'%') expr #MulDiv
| expr op=('+'|'-') expr #AddSub
| expr op=('=='|'!='|'>'|'<'|'>='|'<=') expr #Conditional
| expr op=('&&'|'||') expr #Conjunctional
| OPERAND ( '.' OPERAND )* #Operand
| expr '?' expr ':' expr #Ternary
| expr ',' expr ',' expr ':' expr #ForLoop
| expr 'in' expr #ForEachLoop
| expr (',' expr)* 'in' expr #KObject
| ('[' expr (',' expr)* ']' | '['']') #Array
| ('view'| 'View' ) '(' expr ')' #ViewHandle
| OPERAND '.' expr #TransformedViewHandle
;
/*
* Lexer Rules
INT : [0-9]+;
MUL : '*';
DIV : '/';
ADD : '+';
SUB : '-';
*/
BINARYOPERATOR : ([*/+-] | '==' | '!=' | '<' | '>' | '<=' | '>=' | '&&' | '||' | ',');
PREFIXUNARY : '!';
OPERAND : ([a-zA-Z_][a-zA-Z0-9_[\]]* | [0-9]+ | [0-9]*[.][0-9]+ | '\'' ~('\'')* '\'' );
WS
: ' ' -> channel(HIDDEN)
;
|
arch/ARM/NXP/svd/lpc55s6x/nxp_svd-usart.ads | morbos/Ada_Drivers_Library | 2 | 24507 | -- Copyright 2016-2019 NXP
-- All rights reserved.SPDX-License-Identifier: BSD-3-Clause
-- This spec has been automatically generated from LPC55S6x.svd
pragma Restrictions (No_Elaboration_Code);
pragma Ada_2012;
pragma Style_Checks (Off);
with HAL;
with System;
package NXP_SVD.USART is
pragma Preelaborate;
---------------
-- Registers --
---------------
-- USART Enable.
type CFG_ENABLE_Field is
(
-- Disabled. The USART is disabled and the internal state machine and
-- counters are reset. While Enable = 0, all USART interrupts and DMA
-- transfers are disabled. When Enable is set again, CFG and most other
-- control bits remain unchanged. When re-enabled, the USART will
-- immediately be ready to transmit because the transmitter has been
-- reset and is therefore available.
Disabled,
-- Enabled. The USART is enabled for operation.
Enabled)
with Size => 1;
for CFG_ENABLE_Field use
(Disabled => 0,
Enabled => 1);
-- Selects the data size for the USART.
type CFG_DATALEN_Field is
(
-- 7 bit Data length.
Bit_7,
-- 8 bit Data length.
Bit_8,
-- 9 bit data length. The 9th bit is commonly used for addressing in
-- multidrop mode. See the ADDRDET bit in the CTL register.
Bit_9)
with Size => 2;
for CFG_DATALEN_Field use
(Bit_7 => 0,
Bit_8 => 1,
Bit_9 => 2);
-- Selects what type of parity is used by the USART.
type CFG_PARITYSEL_Field is
(
-- No parity.
No_Parity,
-- Even parity. Adds a bit to each character such that the number of 1s
-- in a transmitted character is even, and the number of 1s in a
-- received character is expected to be even.
Even_Parity,
-- Odd parity. Adds a bit to each character such that the number of 1s
-- in a transmitted character is odd, and the number of 1s in a received
-- character is expected to be odd.
Odd_Parity)
with Size => 2;
for CFG_PARITYSEL_Field use
(No_Parity => 0,
Even_Parity => 2,
Odd_Parity => 3);
-- Number of stop bits appended to transmitted data. Only a single stop bit
-- is required for received data.
type CFG_STOPLEN_Field is
(
-- 1 stop bit.
Bit_1,
-- 2 stop bits. This setting should only be used for asynchronous
-- communication.
Bits_2)
with Size => 1;
for CFG_STOPLEN_Field use
(Bit_1 => 0,
Bits_2 => 1);
-- Selects standard or 32 kHz clocking mode.
type CFG_MODE32K_Field is
(
-- Disabled. USART uses standard clocking.
Disabled,
-- Enabled. USART uses the 32 kHz clock from the RTC oscillator as the
-- clock source to the BRG, and uses a special bit clocking scheme.
Enabled)
with Size => 1;
for CFG_MODE32K_Field use
(Disabled => 0,
Enabled => 1);
-- LIN break mode enable.
type CFG_LINMODE_Field is
(
-- Disabled. Break detect and generate is configured for normal
-- operation.
Disabled,
-- Enabled. Break detect and generate is configured for LIN bus
-- operation.
Enabled)
with Size => 1;
for CFG_LINMODE_Field use
(Disabled => 0,
Enabled => 1);
-- CTS Enable. Determines whether CTS is used for flow control. CTS can be
-- from the input pin, or from the USART's own RTS if loopback mode is
-- enabled.
type CFG_CTSEN_Field is
(
-- No flow control. The transmitter does not receive any automatic flow
-- control signal.
Disabled,
-- Flow control enabled. The transmitter uses the CTS input (or RTS
-- output in loopback mode) for flow control purposes.
Enabled)
with Size => 1;
for CFG_CTSEN_Field use
(Disabled => 0,
Enabled => 1);
-- Selects synchronous or asynchronous operation.
type CFG_SYNCEN_Field is
(
-- Asynchronous mode.
Asynchronous_Mode,
-- Synchronous mode.
Synchronous_Mode)
with Size => 1;
for CFG_SYNCEN_Field use
(Asynchronous_Mode => 0,
Synchronous_Mode => 1);
-- Selects the clock polarity and sampling edge of received data in
-- synchronous mode.
type CFG_CLKPOL_Field is
(
-- Falling edge. Un_RXD is sampled on the falling edge of SCLK.
Falling_Edge,
-- Rising edge. Un_RXD is sampled on the rising edge of SCLK.
Rising_Edge)
with Size => 1;
for CFG_CLKPOL_Field use
(Falling_Edge => 0,
Rising_Edge => 1);
-- Synchronous mode Master select.
type CFG_SYNCMST_Field is
(
-- Slave. When synchronous mode is enabled, the USART is a slave.
Slave,
-- Master. When synchronous mode is enabled, the USART is a master.
Master)
with Size => 1;
for CFG_SYNCMST_Field use
(Slave => 0,
Master => 1);
-- Selects data loopback mode.
type CFG_LOOP_Field is
(
-- Normal operation.
Normal,
-- Loopback mode. This provides a mechanism to perform diagnostic
-- loopback testing for USART data. Serial data from the transmitter
-- (Un_TXD) is connected internally to serial input of the receive
-- (Un_RXD). Un_TXD and Un_RTS activity will also appear on external
-- pins if these functions are configured to appear on device pins. The
-- receiver RTS signal is also looped back to CTS and performs flow
-- control if enabled by CTSEN.
Loopback)
with Size => 1;
for CFG_LOOP_Field use
(Normal => 0,
Loopback => 1);
-- Output Enable Turnaround time enable for RS-485 operation.
type CFG_OETA_Field is
(
-- Disabled. If selected by OESEL, the Output Enable signal deasserted
-- at the end of the last stop bit of a transmission.
Disabled,
-- Enabled. If selected by OESEL, the Output Enable signal remains
-- asserted for one character time after the end of the last stop bit of
-- a transmission. OE will also remain asserted if another transmit
-- begins before it is deasserted.
Enabled)
with Size => 1;
for CFG_OETA_Field use
(Disabled => 0,
Enabled => 1);
-- Automatic Address matching enable.
type CFG_AUTOADDR_Field is
(
-- Disabled. When addressing is enabled by ADDRDET, address matching is
-- done by software. This provides the possibility of versatile
-- addressing (e.g. respond to more than one address).
Disabled,
-- Enabled. When addressing is enabled by ADDRDET, address matching is
-- done by hardware, using the value in the ADDR register as the address
-- to match.
Enabled)
with Size => 1;
for CFG_AUTOADDR_Field use
(Disabled => 0,
Enabled => 1);
-- Output Enable Select.
type CFG_OESEL_Field is
(
-- Standard. The RTS signal is used as the standard flow control
-- function.
Standard,
-- RS-485. The RTS signal configured to provide an output enable signal
-- to control an RS-485 transceiver.
Rs_485)
with Size => 1;
for CFG_OESEL_Field use
(Standard => 0,
Rs_485 => 1);
-- Output Enable Polarity.
type CFG_OEPOL_Field is
(
-- Low. If selected by OESEL, the output enable is active low.
Low,
-- High. If selected by OESEL, the output enable is active high.
High)
with Size => 1;
for CFG_OEPOL_Field use
(Low => 0,
High => 1);
-- Receive data polarity.
type CFG_RXPOL_Field is
(
-- Standard. The RX signal is used as it arrives from the pin. This
-- means that the RX rest value is 1, start bit is 0, data is not
-- inverted, and the stop bit is 1.
Standard,
-- Inverted. The RX signal is inverted before being used by the USART.
-- This means that the RX rest value is 0, start bit is 1, data is
-- inverted, and the stop bit is 0.
Inverted)
with Size => 1;
for CFG_RXPOL_Field use
(Standard => 0,
Inverted => 1);
-- Transmit data polarity.
type CFG_TXPOL_Field is
(
-- Standard. The TX signal is sent out without change. This means that
-- the TX rest value is 1, start bit is 0, data is not inverted, and the
-- stop bit is 1.
Standard,
-- Inverted. The TX signal is inverted by the USART before being sent
-- out. This means that the TX rest value is 0, start bit is 1, data is
-- inverted, and the stop bit is 0.
Inverted)
with Size => 1;
for CFG_TXPOL_Field use
(Standard => 0,
Inverted => 1);
-- USART Configuration register. Basic USART configuration settings that
-- typically are not changed during operation.
type CFG_Register is record
-- USART Enable.
ENABLE : CFG_ENABLE_Field := NXP_SVD.USART.Disabled;
-- unspecified
Reserved_1_1 : HAL.Bit := 16#0#;
-- Selects the data size for the USART.
DATALEN : CFG_DATALEN_Field := NXP_SVD.USART.Bit_7;
-- Selects what type of parity is used by the USART.
PARITYSEL : CFG_PARITYSEL_Field := NXP_SVD.USART.No_Parity;
-- Number of stop bits appended to transmitted data. Only a single stop
-- bit is required for received data.
STOPLEN : CFG_STOPLEN_Field := NXP_SVD.USART.Bit_1;
-- Selects standard or 32 kHz clocking mode.
MODE32K : CFG_MODE32K_Field := NXP_SVD.USART.Disabled;
-- LIN break mode enable.
LINMODE : CFG_LINMODE_Field := NXP_SVD.USART.Disabled;
-- CTS Enable. Determines whether CTS is used for flow control. CTS can
-- be from the input pin, or from the USART's own RTS if loopback mode
-- is enabled.
CTSEN : CFG_CTSEN_Field := NXP_SVD.USART.Disabled;
-- unspecified
Reserved_10_10 : HAL.Bit := 16#0#;
-- Selects synchronous or asynchronous operation.
SYNCEN : CFG_SYNCEN_Field := NXP_SVD.USART.Asynchronous_Mode;
-- Selects the clock polarity and sampling edge of received data in
-- synchronous mode.
CLKPOL : CFG_CLKPOL_Field := NXP_SVD.USART.Falling_Edge;
-- unspecified
Reserved_13_13 : HAL.Bit := 16#0#;
-- Synchronous mode Master select.
SYNCMST : CFG_SYNCMST_Field := NXP_SVD.USART.Slave;
-- Selects data loopback mode.
LOOP_k : CFG_LOOP_Field := NXP_SVD.USART.Normal;
-- unspecified
Reserved_16_17 : HAL.UInt2 := 16#0#;
-- Output Enable Turnaround time enable for RS-485 operation.
OETA : CFG_OETA_Field := NXP_SVD.USART.Disabled;
-- Automatic Address matching enable.
AUTOADDR : CFG_AUTOADDR_Field := NXP_SVD.USART.Disabled;
-- Output Enable Select.
OESEL : CFG_OESEL_Field := NXP_SVD.USART.Standard;
-- Output Enable Polarity.
OEPOL : CFG_OEPOL_Field := NXP_SVD.USART.Low;
-- Receive data polarity.
RXPOL : CFG_RXPOL_Field := NXP_SVD.USART.Standard;
-- Transmit data polarity.
TXPOL : CFG_TXPOL_Field := NXP_SVD.USART.Standard;
-- unspecified
Reserved_24_31 : HAL.UInt8 := 16#0#;
end record
with Volatile_Full_Access, Size => 32,
Bit_Order => System.Low_Order_First;
for CFG_Register use record
ENABLE at 0 range 0 .. 0;
Reserved_1_1 at 0 range 1 .. 1;
DATALEN at 0 range 2 .. 3;
PARITYSEL at 0 range 4 .. 5;
STOPLEN at 0 range 6 .. 6;
MODE32K at 0 range 7 .. 7;
LINMODE at 0 range 8 .. 8;
CTSEN at 0 range 9 .. 9;
Reserved_10_10 at 0 range 10 .. 10;
SYNCEN at 0 range 11 .. 11;
CLKPOL at 0 range 12 .. 12;
Reserved_13_13 at 0 range 13 .. 13;
SYNCMST at 0 range 14 .. 14;
LOOP_k at 0 range 15 .. 15;
Reserved_16_17 at 0 range 16 .. 17;
OETA at 0 range 18 .. 18;
AUTOADDR at 0 range 19 .. 19;
OESEL at 0 range 20 .. 20;
OEPOL at 0 range 21 .. 21;
RXPOL at 0 range 22 .. 22;
TXPOL at 0 range 23 .. 23;
Reserved_24_31 at 0 range 24 .. 31;
end record;
-- Break Enable.
type CTL_TXBRKEN_Field is
(
-- Normal operation.
Normal,
-- Continuous break. Continuous break is sent immediately when this bit
-- is set, and remains until this bit is cleared. A break may be sent
-- without danger of corrupting any currently transmitting character if
-- the transmitter is first disabled (TXDIS in CTL is set) and then
-- waiting for the transmitter to be disabled (TXDISINT in STAT = 1)
-- before writing 1 to TXBRKEN.
Continous)
with Size => 1;
for CTL_TXBRKEN_Field use
(Normal => 0,
Continous => 1);
-- Enable address detect mode.
type CTL_ADDRDET_Field is
(
-- Disabled. The USART presents all incoming data.
Disabled,
-- Enabled. The USART receiver ignores incoming data that does not have
-- the most significant bit of the data (typically the 9th bit) = 1.
-- When the data MSB bit = 1, the receiver treats the incoming data
-- normally, generating a received data interrupt. Software can then
-- check the data to see if this is an address that should be handled.
-- If it is, the ADDRDET bit is cleared by software and further incoming
-- data is handled normally.
Enabled)
with Size => 1;
for CTL_ADDRDET_Field use
(Disabled => 0,
Enabled => 1);
-- Transmit Disable.
type CTL_TXDIS_Field is
(
-- Not disabled. USART transmitter is not disabled.
Enabled,
-- Disabled. USART transmitter is disabled after any character currently
-- being transmitted is complete. This feature can be used to facilitate
-- software flow control.
Disabled)
with Size => 1;
for CTL_TXDIS_Field use
(Enabled => 0,
Disabled => 1);
-- Continuous Clock generation. By default, SCLK is only output while data
-- is being transmitted in synchronous mode.
type CTL_CC_Field is
(
-- Clock on character. In synchronous mode, SCLK cycles only when
-- characters are being sent on Un_TXD or to complete a character that
-- is being received.
Clock_On_Character,
-- Continuous clock. SCLK runs continuously in synchronous mode,
-- allowing characters to be received on Un_RxD independently from
-- transmission on Un_TXD).
Continous_Clock)
with Size => 1;
for CTL_CC_Field use
(Clock_On_Character => 0,
Continous_Clock => 1);
-- Clear Continuous Clock.
type CTL_CLRCCONRX_Field is
(
-- No effect. No effect on the CC bit.
No_Effect,
-- Auto-clear. The CC bit is automatically cleared when a complete
-- character has been received. This bit is cleared at the same time.
Auto_Clear)
with Size => 1;
for CTL_CLRCCONRX_Field use
(No_Effect => 0,
Auto_Clear => 1);
-- Autobaud enable.
type CTL_AUTOBAUD_Field is
(
-- Disabled. USART is in normal operating mode.
Disabled,
-- Enabled. USART is in autobaud mode. This bit should only be set when
-- the USART receiver is idle. The first start bit of RX is measured and
-- used the update the BRG register to match the received data rate.
-- AUTOBAUD is cleared once this process is complete, or if there is an
-- AERR.
Enabled)
with Size => 1;
for CTL_AUTOBAUD_Field use
(Disabled => 0,
Enabled => 1);
-- USART Control register. USART control settings that are more likely to
-- change during operation.
type CTL_Register is record
-- unspecified
Reserved_0_0 : HAL.Bit := 16#0#;
-- Break Enable.
TXBRKEN : CTL_TXBRKEN_Field := NXP_SVD.USART.Normal;
-- Enable address detect mode.
ADDRDET : CTL_ADDRDET_Field := NXP_SVD.USART.Disabled;
-- unspecified
Reserved_3_5 : HAL.UInt3 := 16#0#;
-- Transmit Disable.
TXDIS : CTL_TXDIS_Field := NXP_SVD.USART.Enabled;
-- unspecified
Reserved_7_7 : HAL.Bit := 16#0#;
-- Continuous Clock generation. By default, SCLK is only output while
-- data is being transmitted in synchronous mode.
CC : CTL_CC_Field := NXP_SVD.USART.Clock_On_Character;
-- Clear Continuous Clock.
CLRCCONRX : CTL_CLRCCONRX_Field := NXP_SVD.USART.No_Effect;
-- unspecified
Reserved_10_15 : HAL.UInt6 := 16#0#;
-- Autobaud enable.
AUTOBAUD : CTL_AUTOBAUD_Field := NXP_SVD.USART.Disabled;
-- unspecified
Reserved_17_31 : HAL.UInt15 := 16#0#;
end record
with Volatile_Full_Access, Size => 32,
Bit_Order => System.Low_Order_First;
for CTL_Register use record
Reserved_0_0 at 0 range 0 .. 0;
TXBRKEN at 0 range 1 .. 1;
ADDRDET at 0 range 2 .. 2;
Reserved_3_5 at 0 range 3 .. 5;
TXDIS at 0 range 6 .. 6;
Reserved_7_7 at 0 range 7 .. 7;
CC at 0 range 8 .. 8;
CLRCCONRX at 0 range 9 .. 9;
Reserved_10_15 at 0 range 10 .. 15;
AUTOBAUD at 0 range 16 .. 16;
Reserved_17_31 at 0 range 17 .. 31;
end record;
-- USART Status register. The complete status value can be read here.
-- Writing ones clears some bits in the register. Some bits can be cleared
-- by writing a 1 to them.
type STAT_Register is record
-- unspecified
Reserved_0_0 : HAL.Bit := 16#0#;
-- Read-only. Receiver Idle. When 0, indicates that the receiver is
-- currently in the process of receiving data. When 1, indicates that
-- the receiver is not currently in the process of receiving data.
RXIDLE : Boolean := True;
-- unspecified
Reserved_2_2 : HAL.Bit := 16#0#;
-- Read-only. Transmitter Idle. When 0, indicates that the transmitter
-- is currently in the process of sending data.When 1, indicate that the
-- transmitter is not currently in the process of sending data.
TXIDLE : Boolean := True;
-- Read-only. This bit reflects the current state of the CTS signal,
-- regardless of the setting of the CTSEN bit in the CFG register. This
-- will be the value of the CTS input pin unless loopback mode is
-- enabled.
CTS : Boolean := False;
-- Write-only. This bit is set when a change in the state is detected
-- for the CTS flag above. This bit is cleared by software.
DELTACTS : Boolean := False;
-- Read-only. Transmitter Disabled Status flag. When 1, this bit
-- indicates that the USART transmitter is fully idle after being
-- disabled via the TXDIS bit in the CFG register (TXDIS = 1).
TXDISSTAT : Boolean := False;
-- unspecified
Reserved_7_9 : HAL.UInt3 := 16#0#;
-- Read-only. Received Break. This bit reflects the current state of the
-- receiver break detection logic. It is set when the Un_RXD pin remains
-- low for 16 bit times. Note that FRAMERRINT will also be set when this
-- condition occurs because the stop bit(s) for the character would be
-- missing. RXBRK is cleared when the Un_RXD pin goes high.
RXBRK : Boolean := False;
-- Write-only. This bit is set when a change in the state of receiver
-- break detection occurs. Cleared by software.
DELTARXBRK : Boolean := False;
-- Write-only. This bit is set when a start is detected on the receiver
-- input. Its purpose is primarily to allow wake-up from Deep-sleep or
-- Power-down mode immediately when a start is detected. Cleared by
-- software.
START : Boolean := False;
-- Write-only. Framing Error interrupt flag. This flag is set when a
-- character is received with a missing stop bit at the expected
-- location. This could be an indication of a baud rate or configuration
-- mismatch with the transmitting source.
FRAMERRINT : Boolean := False;
-- Write-only. Parity Error interrupt flag. This flag is set when a
-- parity error is detected in a received character.
PARITYERRINT : Boolean := False;
-- Write-only. Received Noise interrupt flag. Three samples of received
-- data are taken in order to determine the value of each received data
-- bit, except in synchronous mode. This acts as a noise filter if one
-- sample disagrees. This flag is set when a received data bit contains
-- one disagreeing sample. This could indicate line noise, a baud rate
-- or character format mismatch, or loss of synchronization during data
-- reception.
RXNOISEINT : Boolean := False;
-- Write-only. Auto baud Error. An auto baud error can occur if the BRG
-- counts to its limit before the end of the start bit that is being
-- measured, essentially an auto baud time-out.
ABERR : Boolean := False;
-- unspecified
Reserved_17_31 : HAL.UInt15 := 16#0#;
end record
with Volatile_Full_Access, Size => 32,
Bit_Order => System.Low_Order_First;
for STAT_Register use record
Reserved_0_0 at 0 range 0 .. 0;
RXIDLE at 0 range 1 .. 1;
Reserved_2_2 at 0 range 2 .. 2;
TXIDLE at 0 range 3 .. 3;
CTS at 0 range 4 .. 4;
DELTACTS at 0 range 5 .. 5;
TXDISSTAT at 0 range 6 .. 6;
Reserved_7_9 at 0 range 7 .. 9;
RXBRK at 0 range 10 .. 10;
DELTARXBRK at 0 range 11 .. 11;
START at 0 range 12 .. 12;
FRAMERRINT at 0 range 13 .. 13;
PARITYERRINT at 0 range 14 .. 14;
RXNOISEINT at 0 range 15 .. 15;
ABERR at 0 range 16 .. 16;
Reserved_17_31 at 0 range 17 .. 31;
end record;
-- Interrupt Enable read and Set register for USART (not FIFO) status.
-- Contains individual interrupt enable bits for each potential USART
-- interrupt. A complete value may be read from this register. Writing a 1
-- to any implemented bit position causes that bit to be set.
type INTENSET_Register is record
-- unspecified
Reserved_0_2 : HAL.UInt3 := 16#0#;
-- When 1, enables an interrupt when the transmitter becomes idle
-- (TXIDLE = 1).
TXIDLEEN : Boolean := False;
-- unspecified
Reserved_4_4 : HAL.Bit := 16#0#;
-- When 1, enables an interrupt when there is a change in the state of
-- the CTS input.
DELTACTSEN : Boolean := False;
-- When 1, enables an interrupt when the transmitter is fully disabled
-- as indicated by the TXDISINT flag in STAT. See description of the
-- TXDISINT bit for details.
TXDISEN : Boolean := False;
-- unspecified
Reserved_7_10 : HAL.UInt4 := 16#0#;
-- When 1, enables an interrupt when a change of state has occurred in
-- the detection of a received break condition (break condition asserted
-- or deasserted).
DELTARXBRKEN : Boolean := False;
-- When 1, enables an interrupt when a received start bit has been
-- detected.
STARTEN : Boolean := False;
-- When 1, enables an interrupt when a framing error has been detected.
FRAMERREN : Boolean := False;
-- When 1, enables an interrupt when a parity error has been detected.
PARITYERREN : Boolean := False;
-- When 1, enables an interrupt when noise is detected. See description
-- of the RXNOISEINT bit in Table 354.
RXNOISEEN : Boolean := False;
-- When 1, enables an interrupt when an auto baud error occurs.
ABERREN : Boolean := False;
-- unspecified
Reserved_17_31 : HAL.UInt15 := 16#0#;
end record
with Volatile_Full_Access, Size => 32,
Bit_Order => System.Low_Order_First;
for INTENSET_Register use record
Reserved_0_2 at 0 range 0 .. 2;
TXIDLEEN at 0 range 3 .. 3;
Reserved_4_4 at 0 range 4 .. 4;
DELTACTSEN at 0 range 5 .. 5;
TXDISEN at 0 range 6 .. 6;
Reserved_7_10 at 0 range 7 .. 10;
DELTARXBRKEN at 0 range 11 .. 11;
STARTEN at 0 range 12 .. 12;
FRAMERREN at 0 range 13 .. 13;
PARITYERREN at 0 range 14 .. 14;
RXNOISEEN at 0 range 15 .. 15;
ABERREN at 0 range 16 .. 16;
Reserved_17_31 at 0 range 17 .. 31;
end record;
-- Interrupt Enable Clear register. Allows clearing any combination of bits
-- in the INTENSET register. Writing a 1 to any implemented bit position
-- causes the corresponding bit to be cleared.
type INTENCLR_Register is record
-- unspecified
Reserved_0_2 : HAL.UInt3 := 16#0#;
-- Write-only. Writing 1 clears the corresponding bit in the INTENSET
-- register.
TXIDLECLR : Boolean := False;
-- unspecified
Reserved_4_4 : HAL.Bit := 16#0#;
-- Write-only. Writing 1 clears the corresponding bit in the INTENSET
-- register.
DELTACTSCLR : Boolean := False;
-- Write-only. Writing 1 clears the corresponding bit in the INTENSET
-- register.
TXDISCLR : Boolean := False;
-- unspecified
Reserved_7_10 : HAL.UInt4 := 16#0#;
-- Write-only. Writing 1 clears the corresponding bit in the INTENSET
-- register.
DELTARXBRKCLR : Boolean := False;
-- Write-only. Writing 1 clears the corresponding bit in the INTENSET
-- register.
STARTCLR : Boolean := False;
-- Write-only. Writing 1 clears the corresponding bit in the INTENSET
-- register.
FRAMERRCLR : Boolean := False;
-- Write-only. Writing 1 clears the corresponding bit in the INTENSET
-- register.
PARITYERRCLR : Boolean := False;
-- Write-only. Writing 1 clears the corresponding bit in the INTENSET
-- register.
RXNOISECLR : Boolean := False;
-- Write-only. Writing 1 clears the corresponding bit in the INTENSET
-- register.
ABERRCLR : Boolean := False;
-- unspecified
Reserved_17_31 : HAL.UInt15 := 16#0#;
end record
with Volatile_Full_Access, Size => 32,
Bit_Order => System.Low_Order_First;
for INTENCLR_Register use record
Reserved_0_2 at 0 range 0 .. 2;
TXIDLECLR at 0 range 3 .. 3;
Reserved_4_4 at 0 range 4 .. 4;
DELTACTSCLR at 0 range 5 .. 5;
TXDISCLR at 0 range 6 .. 6;
Reserved_7_10 at 0 range 7 .. 10;
DELTARXBRKCLR at 0 range 11 .. 11;
STARTCLR at 0 range 12 .. 12;
FRAMERRCLR at 0 range 13 .. 13;
PARITYERRCLR at 0 range 14 .. 14;
RXNOISECLR at 0 range 15 .. 15;
ABERRCLR at 0 range 16 .. 16;
Reserved_17_31 at 0 range 17 .. 31;
end record;
subtype BRG_BRGVAL_Field is HAL.UInt16;
-- Baud Rate Generator register. 16-bit integer baud rate divisor value.
type BRG_Register is record
-- This value is used to divide the USART input clock to determine the
-- baud rate, based on the input clock from the FRG. 0 = FCLK is used
-- directly by the USART function. 1 = FCLK is divided by 2 before use
-- by the USART function. 2 = FCLK is divided by 3 before use by the
-- USART function. 0xFFFF = FCLK is divided by 65,536 before use by the
-- USART function.
BRGVAL : BRG_BRGVAL_Field := 16#0#;
-- unspecified
Reserved_16_31 : HAL.UInt16 := 16#0#;
end record
with Volatile_Full_Access, Size => 32,
Bit_Order => System.Low_Order_First;
for BRG_Register use record
BRGVAL at 0 range 0 .. 15;
Reserved_16_31 at 0 range 16 .. 31;
end record;
-- Interrupt status register. Reflects interrupts that are currently
-- enabled.
type INTSTAT_Register is record
-- unspecified
Reserved_0_2 : HAL.UInt3;
-- Read-only. Transmitter Idle status.
TXIDLE : Boolean;
-- unspecified
Reserved_4_4 : HAL.Bit;
-- Read-only. This bit is set when a change in the state of the CTS
-- input is detected.
DELTACTS : Boolean;
-- Read-only. Transmitter Disabled Interrupt flag.
TXDISINT : Boolean;
-- unspecified
Reserved_7_10 : HAL.UInt4;
-- Read-only. This bit is set when a change in the state of receiver
-- break detection occurs.
DELTARXBRK : Boolean;
-- Read-only. This bit is set when a start is detected on the receiver
-- input.
START : Boolean;
-- Read-only. Framing Error interrupt flag.
FRAMERRINT : Boolean;
-- Read-only. Parity Error interrupt flag.
PARITYERRINT : Boolean;
-- Read-only. Received Noise interrupt flag.
RXNOISEINT : Boolean;
-- Read-only. Auto baud Error Interrupt flag.
ABERRINT : Boolean;
-- unspecified
Reserved_17_31 : HAL.UInt15;
end record
with Volatile_Full_Access, Size => 32,
Bit_Order => System.Low_Order_First;
for INTSTAT_Register use record
Reserved_0_2 at 0 range 0 .. 2;
TXIDLE at 0 range 3 .. 3;
Reserved_4_4 at 0 range 4 .. 4;
DELTACTS at 0 range 5 .. 5;
TXDISINT at 0 range 6 .. 6;
Reserved_7_10 at 0 range 7 .. 10;
DELTARXBRK at 0 range 11 .. 11;
START at 0 range 12 .. 12;
FRAMERRINT at 0 range 13 .. 13;
PARITYERRINT at 0 range 14 .. 14;
RXNOISEINT at 0 range 15 .. 15;
ABERRINT at 0 range 16 .. 16;
Reserved_17_31 at 0 range 17 .. 31;
end record;
subtype OSR_OSRVAL_Field is HAL.UInt4;
-- Oversample selection register for asynchronous communication.
type OSR_Register is record
-- Oversample Selection Value. 0 to 3 = not supported 0x4 = 5 function
-- clocks are used to transmit and receive each data bit. 0x5 = 6
-- function clocks are used to transmit and receive each data bit. 0xF=
-- 16 function clocks are used to transmit and receive each data bit.
OSRVAL : OSR_OSRVAL_Field := 16#F#;
-- unspecified
Reserved_4_31 : HAL.UInt28 := 16#0#;
end record
with Volatile_Full_Access, Size => 32,
Bit_Order => System.Low_Order_First;
for OSR_Register use record
OSRVAL at 0 range 0 .. 3;
Reserved_4_31 at 0 range 4 .. 31;
end record;
subtype ADDR_ADDRESS_Field is HAL.UInt8;
-- Address register for automatic address matching.
type ADDR_Register is record
-- 8-bit address used with automatic address matching. Used when address
-- detection is enabled (ADDRDET in CTL = 1) and automatic address
-- matching is enabled (AUTOADDR in CFG = 1).
ADDRESS : ADDR_ADDRESS_Field := 16#0#;
-- unspecified
Reserved_8_31 : HAL.UInt24 := 16#0#;
end record
with Volatile_Full_Access, Size => 32,
Bit_Order => System.Low_Order_First;
for ADDR_Register use record
ADDRESS at 0 range 0 .. 7;
Reserved_8_31 at 0 range 8 .. 31;
end record;
-- Enable the transmit FIFO.
type FIFOCFG_ENABLETX_Field is
(
-- The transmit FIFO is not enabled.
Disabled,
-- The transmit FIFO is enabled.
Enabled)
with Size => 1;
for FIFOCFG_ENABLETX_Field use
(Disabled => 0,
Enabled => 1);
-- Enable the receive FIFO.
type FIFOCFG_ENABLERX_Field is
(
-- The receive FIFO is not enabled.
Disabled,
-- The receive FIFO is enabled.
Enabled)
with Size => 1;
for FIFOCFG_ENABLERX_Field use
(Disabled => 0,
Enabled => 1);
subtype FIFOCFG_SIZE_Field is HAL.UInt2;
-- DMA configuration for transmit.
type FIFOCFG_DMATX_Field is
(
-- DMA is not used for the transmit function.
Disabled,
-- Trigger DMA for the transmit function if the FIFO is not full.
-- Generally, data interrupts would be disabled if DMA is enabled.
Enabled)
with Size => 1;
for FIFOCFG_DMATX_Field use
(Disabled => 0,
Enabled => 1);
-- DMA configuration for receive.
type FIFOCFG_DMARX_Field is
(
-- DMA is not used for the receive function.
Disabled,
-- Trigger DMA for the receive function if the FIFO is not empty.
-- Generally, data interrupts would be disabled if DMA is enabled.
Enabled)
with Size => 1;
for FIFOCFG_DMARX_Field use
(Disabled => 0,
Enabled => 1);
-- Wake-up for transmit FIFO level. This allows the device to be woken from
-- reduced power modes (up to power-down, as long as the peripheral
-- function works in that power mode) without enabling the TXLVL interrupt.
-- Only DMA wakes up, processes data, and goes back to sleep. The CPU will
-- remain stopped until woken by another cause, such as DMA completion. See
-- Hardware Wake-up control register.
type FIFOCFG_WAKETX_Field is
(
-- Only enabled interrupts will wake up the device form reduced power
-- modes.
Disabled,
-- A device wake-up for DMA will occur if the transmit FIFO level
-- reaches the value specified by TXLVL in FIFOTRIG, even when the TXLVL
-- interrupt is not enabled.
Enabled)
with Size => 1;
for FIFOCFG_WAKETX_Field use
(Disabled => 0,
Enabled => 1);
-- Wake-up for receive FIFO level. This allows the device to be woken from
-- reduced power modes (up to power-down, as long as the peripheral
-- function works in that power mode) without enabling the TXLVL interrupt.
-- Only DMA wakes up, processes data, and goes back to sleep. The CPU will
-- remain stopped until woken by another cause, such as DMA completion. See
-- Hardware Wake-up control register.
type FIFOCFG_WAKERX_Field is
(
-- Only enabled interrupts will wake up the device form reduced power
-- modes.
Disabled,
-- A device wake-up for DMA will occur if the receive FIFO level reaches
-- the value specified by RXLVL in FIFOTRIG, even when the RXLVL
-- interrupt is not enabled.
Enabled)
with Size => 1;
for FIFOCFG_WAKERX_Field use
(Disabled => 0,
Enabled => 1);
-- FIFO configuration and enable register.
type FIFOCFG_Register is record
-- Enable the transmit FIFO.
ENABLETX : FIFOCFG_ENABLETX_Field := NXP_SVD.USART.Disabled;
-- Enable the receive FIFO.
ENABLERX : FIFOCFG_ENABLERX_Field := NXP_SVD.USART.Disabled;
-- unspecified
Reserved_2_3 : HAL.UInt2 := 16#0#;
-- Read-only. FIFO size configuration. This is a read-only field. 0x0 =
-- FIFO is configured as 16 entries of 8 bits. 0x1, 0x2, 0x3 = not
-- applicable to USART.
SIZE : FIFOCFG_SIZE_Field := 16#0#;
-- unspecified
Reserved_6_11 : HAL.UInt6 := 16#0#;
-- DMA configuration for transmit.
DMATX : FIFOCFG_DMATX_Field := NXP_SVD.USART.Disabled;
-- DMA configuration for receive.
DMARX : FIFOCFG_DMARX_Field := NXP_SVD.USART.Disabled;
-- Wake-up for transmit FIFO level. This allows the device to be woken
-- from reduced power modes (up to power-down, as long as the peripheral
-- function works in that power mode) without enabling the TXLVL
-- interrupt. Only DMA wakes up, processes data, and goes back to sleep.
-- The CPU will remain stopped until woken by another cause, such as DMA
-- completion. See Hardware Wake-up control register.
WAKETX : FIFOCFG_WAKETX_Field := NXP_SVD.USART.Disabled;
-- Wake-up for receive FIFO level. This allows the device to be woken
-- from reduced power modes (up to power-down, as long as the peripheral
-- function works in that power mode) without enabling the TXLVL
-- interrupt. Only DMA wakes up, processes data, and goes back to sleep.
-- The CPU will remain stopped until woken by another cause, such as DMA
-- completion. See Hardware Wake-up control register.
WAKERX : FIFOCFG_WAKERX_Field := NXP_SVD.USART.Disabled;
-- Empty command for the transmit FIFO. When a 1 is written to this bit,
-- the TX FIFO is emptied.
EMPTYTX : Boolean := False;
-- Empty command for the receive FIFO. When a 1 is written to this bit,
-- the RX FIFO is emptied.
EMPTYRX : Boolean := False;
-- unspecified
Reserved_18_31 : HAL.UInt14 := 16#0#;
end record
with Volatile_Full_Access, Size => 32,
Bit_Order => System.Low_Order_First;
for FIFOCFG_Register use record
ENABLETX at 0 range 0 .. 0;
ENABLERX at 0 range 1 .. 1;
Reserved_2_3 at 0 range 2 .. 3;
SIZE at 0 range 4 .. 5;
Reserved_6_11 at 0 range 6 .. 11;
DMATX at 0 range 12 .. 12;
DMARX at 0 range 13 .. 13;
WAKETX at 0 range 14 .. 14;
WAKERX at 0 range 15 .. 15;
EMPTYTX at 0 range 16 .. 16;
EMPTYRX at 0 range 17 .. 17;
Reserved_18_31 at 0 range 18 .. 31;
end record;
subtype FIFOSTAT_TXLVL_Field is HAL.UInt5;
subtype FIFOSTAT_RXLVL_Field is HAL.UInt5;
-- FIFO status register.
type FIFOSTAT_Register is record
-- TX FIFO error. Will be set if a transmit FIFO error occurs. This
-- could be an overflow caused by pushing data into a full FIFO, or by
-- an underflow if the FIFO is empty when data is needed. Cleared by
-- writing a 1 to this bit.
TXERR : Boolean := False;
-- RX FIFO error. Will be set if a receive FIFO overflow occurs, caused
-- by software or DMA not emptying the FIFO fast enough. Cleared by
-- writing a 1 to this bit.
RXERR : Boolean := False;
-- unspecified
Reserved_2_2 : HAL.Bit := 16#0#;
-- Read-only. Peripheral interrupt. When 1, this indicates that the
-- peripheral function has asserted an interrupt. The details can be
-- found by reading the peripheral's STAT register.
PERINT : Boolean := False;
-- Read-only. Transmit FIFO empty. When 1, the transmit FIFO is empty.
-- The peripheral may still be processing the last piece of data.
TXEMPTY : Boolean := True;
-- Read-only. Transmit FIFO not full. When 1, the transmit FIFO is not
-- full, so more data can be written. When 0, the transmit FIFO is full
-- and another write would cause it to overflow.
TXNOTFULL : Boolean := True;
-- Read-only. Receive FIFO not empty. When 1, the receive FIFO is not
-- empty, so data can be read. When 0, the receive FIFO is empty.
RXNOTEMPTY : Boolean := False;
-- Read-only. Receive FIFO full. When 1, the receive FIFO is full. Data
-- needs to be read out to prevent the peripheral from causing an
-- overflow.
RXFULL : Boolean := False;
-- Read-only. Transmit FIFO current level. A 0 means the TX FIFO is
-- currently empty, and the TXEMPTY and TXNOTFULL flags will be 1. Other
-- values tell how much data is actually in the TX FIFO at the point
-- where the read occurs. If the TX FIFO is full, the TXEMPTY and
-- TXNOTFULL flags will be 0.
TXLVL : FIFOSTAT_TXLVL_Field := 16#0#;
-- unspecified
Reserved_13_15 : HAL.UInt3 := 16#0#;
-- Read-only. Receive FIFO current level. A 0 means the RX FIFO is
-- currently empty, and the RXFULL and RXNOTEMPTY flags will be 0. Other
-- values tell how much data is actually in the RX FIFO at the point
-- where the read occurs. If the RX FIFO is full, the RXFULL and
-- RXNOTEMPTY flags will be 1.
RXLVL : FIFOSTAT_RXLVL_Field := 16#0#;
-- unspecified
Reserved_21_31 : HAL.UInt11 := 16#0#;
end record
with Volatile_Full_Access, Size => 32,
Bit_Order => System.Low_Order_First;
for FIFOSTAT_Register use record
TXERR at 0 range 0 .. 0;
RXERR at 0 range 1 .. 1;
Reserved_2_2 at 0 range 2 .. 2;
PERINT at 0 range 3 .. 3;
TXEMPTY at 0 range 4 .. 4;
TXNOTFULL at 0 range 5 .. 5;
RXNOTEMPTY at 0 range 6 .. 6;
RXFULL at 0 range 7 .. 7;
TXLVL at 0 range 8 .. 12;
Reserved_13_15 at 0 range 13 .. 15;
RXLVL at 0 range 16 .. 20;
Reserved_21_31 at 0 range 21 .. 31;
end record;
-- Transmit FIFO level trigger enable. This trigger will become an
-- interrupt if enabled in FIFOINTENSET, or a DMA trigger if DMATX in
-- FIFOCFG is set.
type FIFOTRIG_TXLVLENA_Field is
(
-- Transmit FIFO level does not generate a FIFO level trigger.
Disabled,
-- An trigger will be generated if the transmit FIFO level reaches the
-- value specified by the TXLVL field in this register.
Enabled)
with Size => 1;
for FIFOTRIG_TXLVLENA_Field use
(Disabled => 0,
Enabled => 1);
-- Receive FIFO level trigger enable. This trigger will become an interrupt
-- if enabled in FIFOINTENSET, or a DMA trigger if DMARX in FIFOCFG is set.
type FIFOTRIG_RXLVLENA_Field is
(
-- Receive FIFO level does not generate a FIFO level trigger.
Disabled,
-- An trigger will be generated if the receive FIFO level reaches the
-- value specified by the RXLVL field in this register.
Enabled)
with Size => 1;
for FIFOTRIG_RXLVLENA_Field use
(Disabled => 0,
Enabled => 1);
subtype FIFOTRIG_TXLVL_Field is HAL.UInt4;
subtype FIFOTRIG_RXLVL_Field is HAL.UInt4;
-- FIFO trigger settings for interrupt and DMA request.
type FIFOTRIG_Register is record
-- Transmit FIFO level trigger enable. This trigger will become an
-- interrupt if enabled in FIFOINTENSET, or a DMA trigger if DMATX in
-- FIFOCFG is set.
TXLVLENA : FIFOTRIG_TXLVLENA_Field := NXP_SVD.USART.Disabled;
-- Receive FIFO level trigger enable. This trigger will become an
-- interrupt if enabled in FIFOINTENSET, or a DMA trigger if DMARX in
-- FIFOCFG is set.
RXLVLENA : FIFOTRIG_RXLVLENA_Field := NXP_SVD.USART.Disabled;
-- unspecified
Reserved_2_7 : HAL.UInt6 := 16#0#;
-- Transmit FIFO level trigger point. This field is used only when
-- TXLVLENA = 1. If enabled to do so, the FIFO level can wake up the
-- device just enough to perform DMA, then return to the reduced power
-- mode. See Hardware Wake-up control register. 0 = trigger when the TX
-- FIFO becomes empty. 1 = trigger when the TX FIFO level decreases to
-- one entry. 15 = trigger when the TX FIFO level decreases to 15
-- entries (is no longer full).
TXLVL : FIFOTRIG_TXLVL_Field := 16#0#;
-- unspecified
Reserved_12_15 : HAL.UInt4 := 16#0#;
-- Receive FIFO level trigger point. The RX FIFO level is checked when a
-- new piece of data is received. This field is used only when RXLVLENA
-- = 1. If enabled to do so, the FIFO level can wake up the device just
-- enough to perform DMA, then return to the reduced power mode. See
-- Hardware Wake-up control register. 0 = trigger when the RX FIFO has
-- received one entry (is no longer empty). 1 = trigger when the RX FIFO
-- has received two entries. 15 = trigger when the RX FIFO has received
-- 16 entries (has become full).
RXLVL : FIFOTRIG_RXLVL_Field := 16#0#;
-- unspecified
Reserved_20_31 : HAL.UInt12 := 16#0#;
end record
with Volatile_Full_Access, Size => 32,
Bit_Order => System.Low_Order_First;
for FIFOTRIG_Register use record
TXLVLENA at 0 range 0 .. 0;
RXLVLENA at 0 range 1 .. 1;
Reserved_2_7 at 0 range 2 .. 7;
TXLVL at 0 range 8 .. 11;
Reserved_12_15 at 0 range 12 .. 15;
RXLVL at 0 range 16 .. 19;
Reserved_20_31 at 0 range 20 .. 31;
end record;
-- Determines whether an interrupt occurs when a transmit error occurs,
-- based on the TXERR flag in the FIFOSTAT register.
type FIFOINTENSET_TXERR_Field is
(
-- No interrupt will be generated for a transmit error.
Disabled,
-- An interrupt will be generated when a transmit error occurs.
Enabled)
with Size => 1;
for FIFOINTENSET_TXERR_Field use
(Disabled => 0,
Enabled => 1);
-- Determines whether an interrupt occurs when a receive error occurs,
-- based on the RXERR flag in the FIFOSTAT register.
type FIFOINTENSET_RXERR_Field is
(
-- No interrupt will be generated for a receive error.
Disabled,
-- An interrupt will be generated when a receive error occurs.
Enabled)
with Size => 1;
for FIFOINTENSET_RXERR_Field use
(Disabled => 0,
Enabled => 1);
-- Determines whether an interrupt occurs when a the transmit FIFO reaches
-- the level specified by the TXLVL field in the FIFOTRIG register.
type FIFOINTENSET_TXLVL_Field is
(
-- No interrupt will be generated based on the TX FIFO level.
Disabled,
-- If TXLVLENA in the FIFOTRIG register = 1, an interrupt will be
-- generated when the TX FIFO level decreases to the level specified by
-- TXLVL in the FIFOTRIG register.
Enabled)
with Size => 1;
for FIFOINTENSET_TXLVL_Field use
(Disabled => 0,
Enabled => 1);
-- Determines whether an interrupt occurs when a the receive FIFO reaches
-- the level specified by the TXLVL field in the FIFOTRIG register.
type FIFOINTENSET_RXLVL_Field is
(
-- No interrupt will be generated based on the RX FIFO level.
Disabled,
-- If RXLVLENA in the FIFOTRIG register = 1, an interrupt will be
-- generated when the when the RX FIFO level increases to the level
-- specified by RXLVL in the FIFOTRIG register.
Enabled)
with Size => 1;
for FIFOINTENSET_RXLVL_Field use
(Disabled => 0,
Enabled => 1);
-- FIFO interrupt enable set (enable) and read register.
type FIFOINTENSET_Register is record
-- Determines whether an interrupt occurs when a transmit error occurs,
-- based on the TXERR flag in the FIFOSTAT register.
TXERR : FIFOINTENSET_TXERR_Field := NXP_SVD.USART.Disabled;
-- Determines whether an interrupt occurs when a receive error occurs,
-- based on the RXERR flag in the FIFOSTAT register.
RXERR : FIFOINTENSET_RXERR_Field := NXP_SVD.USART.Disabled;
-- Determines whether an interrupt occurs when a the transmit FIFO
-- reaches the level specified by the TXLVL field in the FIFOTRIG
-- register.
TXLVL : FIFOINTENSET_TXLVL_Field := NXP_SVD.USART.Disabled;
-- Determines whether an interrupt occurs when a the receive FIFO
-- reaches the level specified by the TXLVL field in the FIFOTRIG
-- register.
RXLVL : FIFOINTENSET_RXLVL_Field := NXP_SVD.USART.Disabled;
-- unspecified
Reserved_4_31 : HAL.UInt28 := 16#0#;
end record
with Volatile_Full_Access, Size => 32,
Bit_Order => System.Low_Order_First;
for FIFOINTENSET_Register use record
TXERR at 0 range 0 .. 0;
RXERR at 0 range 1 .. 1;
TXLVL at 0 range 2 .. 2;
RXLVL at 0 range 3 .. 3;
Reserved_4_31 at 0 range 4 .. 31;
end record;
-- FIFO interrupt enable clear (disable) and read register.
type FIFOINTENCLR_Register is record
-- Writing one clears the corresponding bits in the FIFOINTENSET
-- register.
TXERR : Boolean := False;
-- Writing one clears the corresponding bits in the FIFOINTENSET
-- register.
RXERR : Boolean := False;
-- Writing one clears the corresponding bits in the FIFOINTENSET
-- register.
TXLVL : Boolean := False;
-- Writing one clears the corresponding bits in the FIFOINTENSET
-- register.
RXLVL : Boolean := False;
-- unspecified
Reserved_4_31 : HAL.UInt28 := 16#0#;
end record
with Volatile_Full_Access, Size => 32,
Bit_Order => System.Low_Order_First;
for FIFOINTENCLR_Register use record
TXERR at 0 range 0 .. 0;
RXERR at 0 range 1 .. 1;
TXLVL at 0 range 2 .. 2;
RXLVL at 0 range 3 .. 3;
Reserved_4_31 at 0 range 4 .. 31;
end record;
-- FIFO interrupt status register.
type FIFOINTSTAT_Register is record
-- Read-only. TX FIFO error.
TXERR : Boolean;
-- Read-only. RX FIFO error.
RXERR : Boolean;
-- Read-only. Transmit FIFO level interrupt.
TXLVL : Boolean;
-- Read-only. Receive FIFO level interrupt.
RXLVL : Boolean;
-- Read-only. Peripheral interrupt.
PERINT : Boolean;
-- unspecified
Reserved_5_31 : HAL.UInt27;
end record
with Volatile_Full_Access, Size => 32,
Bit_Order => System.Low_Order_First;
for FIFOINTSTAT_Register use record
TXERR at 0 range 0 .. 0;
RXERR at 0 range 1 .. 1;
TXLVL at 0 range 2 .. 2;
RXLVL at 0 range 3 .. 3;
PERINT at 0 range 4 .. 4;
Reserved_5_31 at 0 range 5 .. 31;
end record;
subtype FIFOWR_TXDATA_Field is HAL.UInt9;
-- FIFO write data.
type FIFOWR_Register is record
-- Write-only. Transmit data to the FIFO.
TXDATA : FIFOWR_TXDATA_Field := 16#0#;
-- unspecified
Reserved_9_31 : HAL.UInt23 := 16#0#;
end record
with Volatile_Full_Access, Size => 32,
Bit_Order => System.Low_Order_First;
for FIFOWR_Register use record
TXDATA at 0 range 0 .. 8;
Reserved_9_31 at 0 range 9 .. 31;
end record;
subtype FIFORD_RXDATA_Field is HAL.UInt9;
-- FIFO read data.
type FIFORD_Register is record
-- Read-only. Received data from the FIFO. The number of bits used
-- depends on the DATALEN and PARITYSEL settings.
RXDATA : FIFORD_RXDATA_Field;
-- unspecified
Reserved_9_12 : HAL.UInt4;
-- Read-only. Framing Error status flag. This bit reflects the status
-- for the data it is read along with from the FIFO, and indicates that
-- the character was received with a missing stop bit at the expected
-- location. This could be an indication of a baud rate or configuration
-- mismatch with the transmitting source.
FRAMERR : Boolean;
-- Read-only. Parity Error status flag. This bit reflects the status for
-- the data it is read along with from the FIFO. This bit will be set
-- when a parity error is detected in a received character.
PARITYERR : Boolean;
-- Read-only. Received Noise flag. See description of the RxNoiseInt bit
-- in Table 354.
RXNOISE : Boolean;
-- unspecified
Reserved_16_31 : HAL.UInt16;
end record
with Volatile_Full_Access, Size => 32,
Bit_Order => System.Low_Order_First;
for FIFORD_Register use record
RXDATA at 0 range 0 .. 8;
Reserved_9_12 at 0 range 9 .. 12;
FRAMERR at 0 range 13 .. 13;
PARITYERR at 0 range 14 .. 14;
RXNOISE at 0 range 15 .. 15;
Reserved_16_31 at 0 range 16 .. 31;
end record;
subtype FIFORDNOPOP_RXDATA_Field is HAL.UInt9;
-- FIFO data read with no FIFO pop.
type FIFORDNOPOP_Register is record
-- Read-only. Received data from the FIFO. The number of bits used
-- depends on the DATALEN and PARITYSEL settings.
RXDATA : FIFORDNOPOP_RXDATA_Field;
-- unspecified
Reserved_9_12 : HAL.UInt4;
-- Read-only. Framing Error status flag. This bit reflects the status
-- for the data it is read along with from the FIFO, and indicates that
-- the character was received with a missing stop bit at the expected
-- location. This could be an indication of a baud rate or configuration
-- mismatch with the transmitting source.
FRAMERR : Boolean;
-- Read-only. Parity Error status flag. This bit reflects the status for
-- the data it is read along with from the FIFO. This bit will be set
-- when a parity error is detected in a received character.
PARITYERR : Boolean;
-- Read-only. Received Noise flag. See description of the RxNoiseInt bit
-- in Table 354.
RXNOISE : Boolean;
-- unspecified
Reserved_16_31 : HAL.UInt16;
end record
with Volatile_Full_Access, Size => 32,
Bit_Order => System.Low_Order_First;
for FIFORDNOPOP_Register use record
RXDATA at 0 range 0 .. 8;
Reserved_9_12 at 0 range 9 .. 12;
FRAMERR at 0 range 13 .. 13;
PARITYERR at 0 range 14 .. 14;
RXNOISE at 0 range 15 .. 15;
Reserved_16_31 at 0 range 16 .. 31;
end record;
subtype ID_APERTURE_Field is HAL.UInt8;
subtype ID_MINOR_REV_Field is HAL.UInt4;
subtype ID_MAJOR_REV_Field is HAL.UInt4;
subtype ID_ID_Field is HAL.UInt16;
-- Peripheral identification register.
type ID_Register is record
-- Read-only. Aperture: encoded as (aperture size/4K) -1, so 0x00 means
-- a 4K aperture.
APERTURE : ID_APERTURE_Field;
-- Read-only. Minor revision of module implementation.
MINOR_REV : ID_MINOR_REV_Field;
-- Read-only. Major revision of module implementation.
MAJOR_REV : ID_MAJOR_REV_Field;
-- Read-only. Module identifier for the selected function.
ID : ID_ID_Field;
end record
with Volatile_Full_Access, Size => 32,
Bit_Order => System.Low_Order_First;
for ID_Register use record
APERTURE at 0 range 0 .. 7;
MINOR_REV at 0 range 8 .. 11;
MAJOR_REV at 0 range 12 .. 15;
ID at 0 range 16 .. 31;
end record;
-----------------
-- Peripherals --
-----------------
-- USARTs
type USART_Peripheral is record
-- USART Configuration register. Basic USART configuration settings that
-- typically are not changed during operation.
CFG : aliased CFG_Register;
-- USART Control register. USART control settings that are more likely
-- to change during operation.
CTL : aliased CTL_Register;
-- USART Status register. The complete status value can be read here.
-- Writing ones clears some bits in the register. Some bits can be
-- cleared by writing a 1 to them.
STAT : aliased STAT_Register;
-- Interrupt Enable read and Set register for USART (not FIFO) status.
-- Contains individual interrupt enable bits for each potential USART
-- interrupt. A complete value may be read from this register. Writing a
-- 1 to any implemented bit position causes that bit to be set.
INTENSET : aliased INTENSET_Register;
-- Interrupt Enable Clear register. Allows clearing any combination of
-- bits in the INTENSET register. Writing a 1 to any implemented bit
-- position causes the corresponding bit to be cleared.
INTENCLR : aliased INTENCLR_Register;
-- Baud Rate Generator register. 16-bit integer baud rate divisor value.
BRG : aliased BRG_Register;
-- Interrupt status register. Reflects interrupts that are currently
-- enabled.
INTSTAT : aliased INTSTAT_Register;
-- Oversample selection register for asynchronous communication.
OSR : aliased OSR_Register;
-- Address register for automatic address matching.
ADDR : aliased ADDR_Register;
-- FIFO configuration and enable register.
FIFOCFG : aliased FIFOCFG_Register;
-- FIFO status register.
FIFOSTAT : aliased FIFOSTAT_Register;
-- FIFO trigger settings for interrupt and DMA request.
FIFOTRIG : aliased FIFOTRIG_Register;
-- FIFO interrupt enable set (enable) and read register.
FIFOINTENSET : aliased FIFOINTENSET_Register;
-- FIFO interrupt enable clear (disable) and read register.
FIFOINTENCLR : aliased FIFOINTENCLR_Register;
-- FIFO interrupt status register.
FIFOINTSTAT : aliased FIFOINTSTAT_Register;
-- FIFO write data.
FIFOWR : aliased FIFOWR_Register;
-- FIFO read data.
FIFORD : aliased FIFORD_Register;
-- FIFO data read with no FIFO pop.
FIFORDNOPOP : aliased FIFORDNOPOP_Register;
-- Peripheral identification register.
ID : aliased ID_Register;
end record
with Volatile;
for USART_Peripheral use record
CFG at 16#0# range 0 .. 31;
CTL at 16#4# range 0 .. 31;
STAT at 16#8# range 0 .. 31;
INTENSET at 16#C# range 0 .. 31;
INTENCLR at 16#10# range 0 .. 31;
BRG at 16#20# range 0 .. 31;
INTSTAT at 16#24# range 0 .. 31;
OSR at 16#28# range 0 .. 31;
ADDR at 16#2C# range 0 .. 31;
FIFOCFG at 16#E00# range 0 .. 31;
FIFOSTAT at 16#E04# range 0 .. 31;
FIFOTRIG at 16#E08# range 0 .. 31;
FIFOINTENSET at 16#E10# range 0 .. 31;
FIFOINTENCLR at 16#E14# range 0 .. 31;
FIFOINTSTAT at 16#E18# range 0 .. 31;
FIFOWR at 16#E20# range 0 .. 31;
FIFORD at 16#E30# range 0 .. 31;
FIFORDNOPOP at 16#E40# range 0 .. 31;
ID at 16#FFC# range 0 .. 31;
end record;
-- USARTs
USART0_Periph : aliased USART_Peripheral
with Import, Address => System'To_Address (16#40086000#);
-- USARTs
USART1_Periph : aliased USART_Peripheral
with Import, Address => System'To_Address (16#40087000#);
-- USARTs
USART2_Periph : aliased USART_Peripheral
with Import, Address => System'To_Address (16#40088000#);
-- USARTs
USART3_Periph : aliased USART_Peripheral
with Import, Address => System'To_Address (16#40089000#);
-- USARTs
USART4_Periph : aliased USART_Peripheral
with Import, Address => System'To_Address (16#4008A000#);
-- USARTs
USART5_Periph : aliased USART_Peripheral
with Import, Address => System'To_Address (16#40096000#);
-- USARTs
USART6_Periph : aliased USART_Peripheral
with Import, Address => System'To_Address (16#40097000#);
-- USARTs
USART7_Periph : aliased USART_Peripheral
with Import, Address => System'To_Address (16#40098000#);
end NXP_SVD.USART;
|
alloy4fun_models/trashltl/models/9/9HZAeqnh5fj7h3tXB.als | Kaixi26/org.alloytools.alloy | 0 | 166 | <filename>alloy4fun_models/trashltl/models/9/9HZAeqnh5fj7h3tXB.als
open main
pred id9HZAeqnh5fj7h3tXB_prop10 {
always(all f:File | f in Protected implies( always f in Protected))
}
pred __repair { id9HZAeqnh5fj7h3tXB_prop10 }
check __repair { id9HZAeqnh5fj7h3tXB_prop10 <=> prop10o } |
src/gen/gstreamer-gst_low_level-gstreamer_0_10_gst_gstpad_h.ads | persan/A-gst | 1 | 26568 | <gh_stars>1-10
pragma Ada_2005;
pragma Style_Checks (Off);
pragma Warnings (Off);
with Interfaces.C; use Interfaces.C;
with glib;
with glib.Values;
with System;
with System;
-- with GStreamer.GST_Low_Level.glib_2_0_glib_gquark_h;
limited with GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstbuffer_h;
with GLIB; -- with GStreamer.GST_Low_Level.glibconfig_h;
limited with GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstevent_h;
-- limited with GStreamer.GST_Low_Level.glib_2_0_glib_glist_h;
limited with GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstiterator_h;
with GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstquery_h;
limited with GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstcaps_h;
limited with GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstpadtemplate_h;
with GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstobject_h;
-- limited -- with GStreamer.GST_Low_Level.glib_2_0_glib_deprecated_gthread_h;
with GStreamer.GST_Low_Level.gstreamer_0_10_gst_gsttask_h;
-- limited -- with GStreamer.GST_Low_Level.glib_2_0_glib_gthread_h;
limited with GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstminiobject_h;
with glib;
-- with GStreamer.GST_Low_Level.libxml2_libxml_tree_h;
package GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstpad_h is
-- unsupported macro: GST_TYPE_PAD (gst_pad_get_type ())
-- arg-macro: function GST_IS_PAD (obj)
-- return G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_PAD);
-- arg-macro: function GST_IS_PAD_CLASS (klass)
-- return G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_PAD);
-- arg-macro: function GST_PAD (obj)
-- return G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_PAD, GstPad);
-- arg-macro: function GST_PAD_CLASS (klass)
-- return G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_PAD, GstPadClass);
-- arg-macro: function GST_PAD_CAST (obj)
-- return (GstPad*)(obj);
-- arg-macro: function GST_PAD_LINK_FAILED (ret)
-- return (ret) < GST_PAD_LINK_OK;
-- arg-macro: function GST_PAD_LINK_SUCCESSFUL (ret)
-- return (ret) >= GST_PAD_LINK_OK;
-- arg-macro: function GST_FLOW_IS_FATAL (ret)
-- return (ret) <= GST_FLOW_UNEXPECTED;
-- arg-macro: function GST_FLOW_IS_SUCCESS (ret)
-- return (ret) >= GST_FLOW_OK;
-- unsupported macro: GST_PAD_LINK_CHECK_DEFAULT ((GstPadLinkCheck) (GST_PAD_LINK_CHECK_HIERARCHY | GST_PAD_LINK_CHECK_CAPS))
-- arg-macro: function GST_PAD_MODE_ACTIVATE (mode)
-- return (mode) /= GST_ACTIVATE_NONE;
-- arg-macro: function GST_PAD_NAME (pad)
-- return GST_OBJECT_NAME(pad);
-- arg-macro: function GST_PAD_PARENT (pad)
-- return GST_ELEMENT_CAST(GST_OBJECT_PARENT(pad));
-- arg-macro: function GST_PAD_ELEMENT_PRIVATE (pad)
-- return GST_PAD_CAST(pad).element_private;
-- arg-macro: function GST_PAD_PAD_TEMPLATE (pad)
-- return GST_PAD_CAST(pad).padtemplate;
-- arg-macro: function GST_PAD_DIRECTION (pad)
-- return GST_PAD_CAST(pad).direction;
-- arg-macro: function GST_PAD_TASK (pad)
-- return GST_PAD_CAST(pad).task;
-- arg-macro: function GST_PAD_ACTIVATE_MODE (pad)
-- return GST_PAD_CAST(pad).mode;
-- arg-macro: function GST_PAD_ACTIVATEFUNC (pad)
-- return GST_PAD_CAST(pad).activatefunc;
-- arg-macro: function GST_PAD_ACTIVATEPUSHFUNC (pad)
-- return GST_PAD_CAST(pad).activatepushfunc;
-- arg-macro: function GST_PAD_ACTIVATEPULLFUNC (pad)
-- return GST_PAD_CAST(pad).activatepullfunc;
-- arg-macro: function GST_PAD_CHAINFUNC (pad)
-- return GST_PAD_CAST(pad).chainfunc;
-- arg-macro: function GST_PAD_CHECKGETRANGEFUNC (pad)
-- return GST_PAD_CAST(pad).checkgetrangefunc;
-- arg-macro: function GST_PAD_GETRANGEFUNC (pad)
-- return GST_PAD_CAST(pad).getrangefunc;
-- arg-macro: function GST_PAD_EVENTFUNC (pad)
-- return GST_PAD_CAST(pad).eventfunc;
-- arg-macro: function GST_PAD_QUERYTYPEFUNC (pad)
-- return GST_PAD_CAST(pad).querytypefunc;
-- arg-macro: function GST_PAD_QUERYFUNC (pad)
-- return GST_PAD_CAST(pad).queryfunc;
-- arg-macro: function GST_PAD_INTLINKFUNC (pad)
-- return GST_PAD_CAST(pad).intlinkfunc;
-- arg-macro: function GST_PAD_ITERINTLINKFUNC (pad)
-- return GST_PAD_CAST(pad).iterintlinkfunc;
-- arg-macro: function GST_PAD_PEER (pad)
-- return GST_PAD_CAST(pad).peer;
-- arg-macro: function GST_PAD_LINKFUNC (pad)
-- return GST_PAD_CAST(pad).linkfunc;
-- arg-macro: function GST_PAD_UNLINKFUNC (pad)
-- return GST_PAD_CAST(pad).unlinkfunc;
-- arg-macro: function GST_PAD_CAPS (pad)
-- return GST_PAD_CAST(pad).caps;
-- arg-macro: function GST_PAD_GETCAPSFUNC (pad)
-- return GST_PAD_CAST(pad).getcapsfunc;
-- arg-macro: function GST_PAD_SETCAPSFUNC (pad)
-- return GST_PAD_CAST(pad).setcapsfunc;
-- arg-macro: function GST_PAD_ACCEPTCAPSFUNC (pad)
-- return GST_PAD_CAST(pad).acceptcapsfunc;
-- arg-macro: function GST_PAD_FIXATECAPSFUNC (pad)
-- return GST_PAD_CAST(pad).fixatecapsfunc;
-- arg-macro: function GST_PAD_BUFFERALLOCFUNC (pad)
-- return GST_PAD_CAST(pad).bufferallocfunc;
-- arg-macro: function GST_PAD_DO_BUFFER_SIGNALS (pad)
-- return GST_PAD_CAST(pad).do_buffer_signals;
-- arg-macro: function GST_PAD_DO_EVENT_SIGNALS (pad)
-- return GST_PAD_CAST(pad).do_event_signals;
-- arg-macro: function GST_PAD_IS_LINKED (pad)
-- return GST_PAD_PEER(pad) /= NULL;
-- arg-macro: function GST_PAD_IS_BLOCKED (pad)
-- return GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_BLOCKED);
-- arg-macro: function GST_PAD_IS_BLOCKING (pad)
-- return GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_BLOCKING);
-- arg-macro: function GST_PAD_IS_FLUSHING (pad)
-- return GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_FLUSHING);
-- arg-macro: function GST_PAD_IS_IN_GETCAPS (pad)
-- return GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_IN_GETCAPS);
-- arg-macro: function GST_PAD_IS_IN_SETCAPS (pad)
-- return GST_OBJECT_FLAG_IS_SET (pad, GST_PAD_IN_SETCAPS);
-- arg-macro: function GST_PAD_IS_SRC (pad)
-- return GST_PAD_DIRECTION(pad) = GST_PAD_SRC;
-- arg-macro: function GST_PAD_IS_SINK (pad)
-- return GST_PAD_DIRECTION(pad) = GST_PAD_SINK;
-- arg-macro: function GST_PAD_SET_FLUSHING (pad)
-- return GST_OBJECT_FLAG_SET (pad, GST_PAD_FLUSHING);
-- arg-macro: function GST_PAD_UNSET_FLUSHING (pad)
-- return GST_OBJECT_FLAG_UNSET (pad, GST_PAD_FLUSHING);
-- arg-macro: function GST_PAD_GET_STREAM_LOCK (pad)
-- return GST_PAD_CAST(pad).stream_rec_lock;
-- arg-macro: function GST_PAD_STREAM_LOCK (pad)
-- return g_static_rec_mutex_lock(GST_PAD_GET_STREAM_LOCK(pad));
-- arg-macro: function GST_PAD_STREAM_LOCK_FULL (pad, t)
-- return g_static_rec_mutex_lock_full(GST_PAD_GET_STREAM_LOCK(pad), t);
-- arg-macro: function GST_PAD_STREAM_TRYLOCK (pad)
-- return g_static_rec_mutex_trylock(GST_PAD_GET_STREAM_LOCK(pad));
-- arg-macro: function GST_PAD_STREAM_UNLOCK (pad)
-- return g_static_rec_mutex_unlock(GST_PAD_GET_STREAM_LOCK(pad));
-- arg-macro: function GST_PAD_STREAM_UNLOCK_FULL (pad)
-- return g_static_rec_mutex_unlock_full(GST_PAD_GET_STREAM_LOCK(pad));
-- arg-macro: function GST_PAD_GET_PREROLL_LOCK (pad)
-- return GST_PAD_CAST(pad).preroll_lock;
-- arg-macro: function GST_PAD_PREROLL_LOCK (pad)
-- return g_mutex_lock(GST_PAD_GET_PREROLL_LOCK(pad));
-- arg-macro: function GST_PAD_PREROLL_TRYLOCK (pad)
-- return g_mutex_trylock(GST_PAD_GET_PREROLL_LOCK(pad));
-- arg-macro: function GST_PAD_PREROLL_UNLOCK (pad)
-- return g_mutex_unlock(GST_PAD_GET_PREROLL_LOCK(pad));
-- arg-macro: function GST_PAD_GET_PREROLL_COND (pad)
-- return GST_PAD_CAST(pad).preroll_cond;
-- arg-macro: procedure GST_PAD_PREROLL_WAIT (pad)
-- g_cond_wait (GST_PAD_GET_PREROLL_COND (pad), GST_PAD_GET_PREROLL_LOCK (pad))
-- arg-macro: procedure GST_PAD_PREROLL_TIMED_WAIT (pad, timeval)
-- g_cond_timed_wait (GST_PAD_GET_PREROLL_COND (pad), GST_PAD_GET_PREROLL_LOCK (pad), timeval)
-- arg-macro: procedure GST_PAD_PREROLL_SIGNAL (pad)
-- g_cond_signal (GST_PAD_GET_PREROLL_COND (pad));
-- arg-macro: procedure GST_PAD_PREROLL_BROADCAST (pad)
-- g_cond_broadcast (GST_PAD_GET_PREROLL_COND (pad));
-- arg-macro: function GST_PAD_BLOCK_GET_COND (pad)
-- return GST_PAD_CAST(pad).block_cond;
-- arg-macro: function GST_PAD_BLOCK_WAIT (pad)
-- return g_cond_wait(GST_PAD_BLOCK_GET_COND (pad), GST_OBJECT_GET_LOCK (pad));
-- arg-macro: function GST_PAD_BLOCK_SIGNAL (pad)
-- return g_cond_signal(GST_PAD_BLOCK_GET_COND (pad));
-- arg-macro: function GST_PAD_BLOCK_BROADCAST (pad)
-- return g_cond_broadcast(GST_PAD_BLOCK_GET_COND (pad));
-- arg-macro: procedure gst_pad_get_name (pad)
-- gst_object_get_name (GST_OBJECT_CAST (pad))
-- arg-macro: procedure gst_pad_get_parent (pad)
-- gst_object_get_parent (GST_OBJECT_CAST (pad))
-- GStreamer
-- * Copyright (C) 1999,2000 <NAME> <<EMAIL>>
-- * 2000 <NAME> <<EMAIL>>
-- *
-- * gstpad.h: Header for GstPad object
-- *
-- * This library is free software; you can redistribute it and/or
-- * modify it under the terms of the GNU Library General Public
-- * License as published by the Free Software Foundation; either
-- * version 2 of the License, or (at your option) any later version.
-- *
-- * This library is distributed in the hope that it will be useful,
-- * but WITHOUT ANY WARRANTY; without even the implied warranty of
-- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-- * Library General Public License for more details.
-- *
-- * You should have received a copy of the GNU Library General Public
-- * License along with this library; if not, write to the
-- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-- * Boston, MA 02111-1307, USA.
--
-- * Pad base class
--
type GstPad;
type anon_200;
type anon_201 is record
block_callback_called : aliased GLIB.gboolean; -- gst/gstpad.h:739
priv : System.Address; -- gst/gstpad.h:740
end record;
pragma Convention (C_Pass_By_Copy, anon_201);
type u_GstPad_u_gst_reserved_array is array (0 .. 1) of System.Address;
type anon_200 (discr : unsigned := 0) is record
case discr is
when 0 =>
ABI : aliased anon_201; -- gst/gstpad.h:741
when others =>
u_gst_reserved : u_GstPad_u_gst_reserved_array; -- gst/gstpad.h:742
end case;
end record;
pragma Convention (C_Pass_By_Copy, anon_200);
pragma Unchecked_Union (anon_200);--subtype GstPad is u_GstPad; -- gst/gstpad.h:50
-- skipped empty struct u_GstPadPrivate
-- skipped empty struct GstPadPrivate
type GstPadClass;
type u_GstPadClass_u_gst_reserved_array is array (0 .. 3) of System.Address;
--subtype GstPadClass is u_GstPadClass; -- gst/gstpad.h:52
--*
-- * GstPadLinkReturn:
-- * @GST_PAD_LINK_OK : link succeeded
-- * @GST_PAD_LINK_WRONG_HIERARCHY: pads have no common grandparent
-- * @GST_PAD_LINK_WAS_LINKED : pad was already linked
-- * @GST_PAD_LINK_WRONG_DIRECTION: pads have wrong direction
-- * @GST_PAD_LINK_NOFORMAT : pads do not have common format
-- * @GST_PAD_LINK_NOSCHED : pads cannot cooperate in scheduling
-- * @GST_PAD_LINK_REFUSED : refused for some reason
-- *
-- * Result values from gst_pad_link and friends.
--
subtype GstPadLinkReturn is int;
GST_PAD_LINK_OK : constant GstPadLinkReturn := 0;
GST_PAD_LINK_WRONG_HIERARCHY : constant GstPadLinkReturn := -1;
GST_PAD_LINK_WAS_LINKED : constant GstPadLinkReturn := -2;
GST_PAD_LINK_WRONG_DIRECTION : constant GstPadLinkReturn := -3;
GST_PAD_LINK_NOFORMAT : constant GstPadLinkReturn := -4;
GST_PAD_LINK_NOSCHED : constant GstPadLinkReturn := -5;
GST_PAD_LINK_REFUSED : constant GstPadLinkReturn := -6; -- gst/gstpad.h:74
--*
-- * GST_PAD_LINK_FAILED:
-- * @ret: the #GstPadLinkReturn value
-- *
-- * Macro to test if the given #GstPadLinkReturn value indicates a failed
-- * link step.
--
--*
-- * GST_PAD_LINK_SUCCESSFUL:
-- * @ret: the #GstPadLinkReturn value
-- *
-- * Macro to test if the given #GstPadLinkReturn value indicates a successful
-- * link step.
--
--*
-- * GstFlowReturn:
-- * @GST_FLOW_RESEND: Resend buffer, possibly with new caps (not
-- * sent yet) (unused/unimplemented).
-- * @GST_FLOW_OK: Data passing was ok.
-- * @GST_FLOW_NOT_LINKED: Pad is not linked.
-- * @GST_FLOW_WRONG_STATE: Pad is in wrong state.
-- * @GST_FLOW_UNEXPECTED: Did not expect anything, like after EOS.
-- * @GST_FLOW_NOT_NEGOTIATED: Pad is not negotiated.
-- * @GST_FLOW_ERROR: Some (fatal) error occured. Element generating
-- * this error should post an error message with more
-- * details.
-- * @GST_FLOW_NOT_SUPPORTED: This operation is not supported.
-- * @GST_FLOW_CUSTOM_SUCCESS: Elements can use values starting from
-- * this (and higher) to define custom success
-- * codes. Since 0.10.7.
-- * @GST_FLOW_CUSTOM_SUCCESS_1: Pre-defined custom success code (define your
-- * custom success code to this to avoid compiler
-- * warnings). Since 0.10.29.
-- * @GST_FLOW_CUSTOM_SUCCESS_2: Pre-defined custom success code. Since 0.10.29.
-- * @GST_FLOW_CUSTOM_ERROR: Elements can use values starting from
-- * this (and lower) to define custom error codes.
-- * Since 0.10.7.
-- * @GST_FLOW_CUSTOM_ERROR_1: Pre-defined custom error code (define your
-- * custom error code to this to avoid compiler
-- * warnings). Since 0.10.29.
-- * @GST_FLOW_CUSTOM_ERROR_2: Pre-defined custom error code. Since 0.10.29.
-- *
-- * The result of passing data to a pad.
-- *
-- * Note that the custom return values should not be exposed outside of the
-- * element scope and are available since 0.10.7.
--
-- FIXME 0.11: remove custom flow returns
-- custom success starts here
-- core predefined
-- expected failures
-- error cases
-- custom error starts here
subtype GstFlowReturn is int;
GST_FLOW_CUSTOM_SUCCESS_2 : constant GstFlowReturn := 102;
GST_FLOW_CUSTOM_SUCCESS_1 : constant GstFlowReturn := 101;
GST_FLOW_CUSTOM_SUCCESS : constant GstFlowReturn := 100;
GST_FLOW_RESEND : constant GstFlowReturn := 1;
GST_FLOW_OK : constant GstFlowReturn := 0;
GST_FLOW_NOT_LINKED : constant GstFlowReturn := -1;
GST_FLOW_WRONG_STATE : constant GstFlowReturn := -2;
GST_FLOW_UNEXPECTED : constant GstFlowReturn := -3;
GST_FLOW_NOT_NEGOTIATED : constant GstFlowReturn := -4;
GST_FLOW_ERROR : constant GstFlowReturn := -5;
GST_FLOW_NOT_SUPPORTED : constant GstFlowReturn := -6;
GST_FLOW_CUSTOM_ERROR : constant GstFlowReturn := -100;
GST_FLOW_CUSTOM_ERROR_1 : constant GstFlowReturn := -101;
GST_FLOW_CUSTOM_ERROR_2 : constant GstFlowReturn := -102; -- gst/gstpad.h:150
--*
-- * GST_FLOW_IS_FATAL:
-- * @ret: a #GstFlowReturn value
-- *
-- * Macro to test if the given #GstFlowReturn value indicates a fatal
-- * error. This macro is mainly used in elements driving the pipeline to decide
-- * whether an error message should be posted on the bus. Note that such
-- * elements may also need to post an error message in the #GST_FLOW_NOT_LINKED
-- * case which is not caught by this macro.
-- *
-- * Deprecated: This macro is badly named and can't be used in any real
-- * scenarios without additional checks.
--
--*
-- * GST_FLOW_IS_SUCCESS:
-- * @ret: a #GstFlowReturn value
-- *
-- * Macro to test if the given #GstFlowReturn value indicates a
-- * successful result
-- * This macro is mainly used in elements to decide if the processing
-- * of a buffer was successful.
-- *
-- * Since: 0.10.7
-- *
-- * Deprecated: This macro is badly named and can't be used in any real
-- * scenarios without additional checks.
--
function gst_flow_get_name (ret : GstFlowReturn) return access GLIB.gchar; -- gst/gstpad.h:187
pragma Import (C, gst_flow_get_name, "gst_flow_get_name");
function gst_flow_to_quark (ret : GstFlowReturn) return Glib.GQuark; -- gst/gstpad.h:188
pragma Import (C, gst_flow_to_quark, "gst_flow_to_quark");
--*
-- * GstPadLinkCheck:
-- * @GST_PAD_LINK_CHECK_NOTHING: Don't check hierarchy or caps compatibility.
-- * @GST_PAD_LINK_CHECK_HIERARCHY: Check the pads have same parents/grandparents.
-- * Could be omitted if it is already known that the two elements that own the
-- * pads are in the same bin.
-- * @GST_PAD_LINK_CHECK_TEMPLATE_CAPS: Check if the pads are compatible by using
-- * their template caps. This is much faster than @GST_PAD_LINK_CHECK_CAPS, but
-- * would be unsafe e.g. if one pad has %GST_CAPS_ANY.
-- * @GST_PAD_LINK_CHECK_CAPS: Check if the pads are compatible by comparing the
-- * caps returned by gst_pad_get_caps().
-- *
-- * The amount of checking to be done when linking pads. @GST_PAD_LINK_CHECK_CAPS
-- * and @GST_PAD_LINK_CHECK_TEMPLATE_CAPS are mutually exclusive. If both are
-- * specified, expensive but safe @GST_PAD_LINK_CHECK_CAPS are performed.
-- *
-- * <warning><para>
-- * Only disable some of the checks if you are 100% certain you know the link
-- * will not fail because of hierarchy/caps compatibility failures. If uncertain,
-- * use the default checks (%GST_PAD_LINK_CHECK_DEFAULT) or the regular methods
-- * for linking the pads.
-- * </para></warning>
-- *
-- * Since: 0.10.30
--
subtype GstPadLinkCheck is unsigned;
GST_PAD_LINK_CHECK_NOTHING : constant GstPadLinkCheck := 0;
GST_PAD_LINK_CHECK_HIERARCHY : constant GstPadLinkCheck := 1;
GST_PAD_LINK_CHECK_TEMPLATE_CAPS : constant GstPadLinkCheck := 2;
GST_PAD_LINK_CHECK_CAPS : constant GstPadLinkCheck := 4; -- gst/gstpad.h:221
--*
-- * GST_PAD_LINK_CHECK_DEFAULT:
-- *
-- * The default checks done when linking pads (i.e. the ones used by
-- * gst_pad_link()).
-- *
-- * Since: 0.10.30
--
--*
-- * GstActivateMode:
-- * @GST_ACTIVATE_NONE: Pad will not handle dataflow
-- * @GST_ACTIVATE_PUSH: Pad handles dataflow in downstream push mode
-- * @GST_ACTIVATE_PULL: Pad handles dataflow in upstream pull mode
-- *
-- * The status of a GstPad. After activating a pad, which usually happens when the
-- * parent element goes from READY to PAUSED, the GstActivateMode defines if the
-- * pad operates in push or pull mode.
--
type GstActivateMode is
(GST_ACTIVATE_NONE,
GST_ACTIVATE_PUSH,
GST_ACTIVATE_PULL);
pragma Convention (C, GstActivateMode); -- gst/gstpad.h:247
--*
-- * GST_PAD_MODE_ACTIVATE:
-- * @mode: a #GstActivateMode
-- *
-- * Macro to test if the given #GstActivateMode value indicates that datapassing
-- * is possible or not.
--
-- pad states
--*
-- * GstPadActivateFunction:
-- * @pad: a #GstPad
-- *
-- * This function is called when the pad is activated during the element
-- * READY to PAUSED state change. By default this function will call the
-- * activate function that puts the pad in push mode but elements can
-- * override this function to activate the pad in pull mode if they wish.
-- *
-- * Returns: TRUE if the pad could be activated.
--
type GstPadActivateFunction is access function (arg1 : access GstPad) return GLIB.gboolean;
pragma Convention (C, GstPadActivateFunction); -- gst/gstpad.h:270
--*
-- * GstPadActivateModeFunction:
-- * @pad: a #GstPad
-- * @active: activate or deactivate the pad.
-- *
-- * The prototype of the push and pull activate functions.
-- *
-- * Returns: TRUE if the pad could be activated or deactivated.
--
type GstPadActivateModeFunction is access function (arg1 : access GstPad; arg2 : GLIB.gboolean) return GLIB.gboolean;
pragma Convention (C, GstPadActivateModeFunction); -- gst/gstpad.h:280
-- data passing
--*
-- * GstPadChainFunction:
-- * @pad: the sink #GstPad that performed the chain.
-- * @buffer: the #GstBuffer that is chained, not %NULL.
-- *
-- * A function that will be called on sinkpads when chaining buffers.
-- * The function typically processes the data contained in the buffer and
-- * either consumes the data or passes it on to the internally linked pad(s).
-- *
-- * The implementer of this function receives a refcount to @buffer and should
-- * gst_buffer_unref() when the buffer is no longer needed.
-- *
-- * When a chain function detects an error in the data stream, it must post an
-- * error on the bus and return an appropriate #GstFlowReturn value.
-- *
-- * Returns: #GST_FLOW_OK for success
--
type GstPadChainFunction is access function (arg1 : access GstPad; arg2 : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstbuffer_h.GstBuffer) return GstFlowReturn;
pragma Convention (C, GstPadChainFunction); -- gst/gstpad.h:301
--*
-- * GstPadChainListFunction:
-- * @pad: the sink #GstPad that performed the chain.
-- * @list: the #GstBufferList that is chained, not %NULL.
-- *
-- * A function that will be called on sinkpads when chaining buffer lists.
-- * The function typically processes the data contained in the buffer list and
-- * either consumes the data or passes it on to the internally linked pad(s).
-- *
-- * The implementer of this function receives a refcount to @list and
-- * should gst_buffer_list_unref() when the list is no longer needed.
-- *
-- * When a chainlist function detects an error in the data stream, it must
-- * post an error on the bus and return an appropriate #GstFlowReturn value.
-- *
-- * Returns: #GST_FLOW_OK for success
--
type GstPadChainListFunction is access function (arg1 : access GstPad; arg2 : System.Address) return GstFlowReturn;
pragma Convention (C, GstPadChainListFunction); -- gst/gstpad.h:320
--*
-- * GstPadGetRangeFunction:
-- * @pad: the src #GstPad to perform the getrange on.
-- * @offset: the offset of the range
-- * @length: the length of the range
-- * @buffer: a memory location to hold the result buffer, cannot be NULL.
-- *
-- * This function will be called on source pads when a peer element
-- * request a buffer at the specified @offset and @length. If this function
-- * returns #GST_FLOW_OK, the result buffer will be stored in @buffer. The
-- * contents of @buffer is invalid for any other return value.
-- *
-- * This function is installed on a source pad with
-- * gst_pad_set_getrange_function() and can only be called on source pads after
-- * they are successfully activated with gst_pad_activate_pull().
-- *
-- * @offset and @length are always given in byte units. @offset must normally be a value
-- * between 0 and the length in bytes of the data available on @pad. The
-- * length (duration in bytes) can be retrieved with a #GST_QUERY_DURATION or with a
-- * #GST_QUERY_SEEKING.
-- *
-- * Any @offset larger or equal than the length will make the function return
-- * #GST_FLOW_UNEXPECTED, which corresponds to EOS. In this case @buffer does not
-- * contain a valid buffer.
-- *
-- * The buffer size of @buffer will only be smaller than @length when @offset is
-- * near the end of the stream. In all other cases, the size of @buffer must be
-- * exactly the requested size.
-- *
-- * It is allowed to call this function with a 0 @length and valid @offset, in
-- * which case @buffer will contain a 0-sized buffer and the function returns
-- * #GST_FLOW_OK.
-- *
-- * When this function is called with a -1 @offset, the sequentially next buffer
-- * of length @length in the stream is returned.
-- *
-- * When this function is called with a -1 @length, a buffer with a default
-- * optimal length is returned in @buffer. The length might depend on the value
-- * of @offset.
-- *
-- * Returns: #GST_FLOW_OK for success and a valid buffer in @buffer. Any other
-- * return value leaves @buffer undefined.
--
type GstPadGetRangeFunction is access function
(arg1 : access GstPad;
arg2 : GLIB.guint64;
arg3 : GLIB.guint;
arg4 : System.Address) return GstFlowReturn;
pragma Convention (C, GstPadGetRangeFunction); -- gst/gstpad.h:365
--*
-- * GstPadEventFunction:
-- * @pad: the #GstPad to handle the event.
-- * @event: the #GstEvent to handle.
-- *
-- * Function signature to handle an event for the pad.
-- *
-- * Returns: TRUE if the pad could handle the event.
--
type GstPadEventFunction is access function (arg1 : access GstPad; arg2 : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstevent_h.GstEvent) return GLIB.gboolean;
pragma Convention (C, GstPadEventFunction); -- gst/gstpad.h:377
-- FIXME: 0.11: deprecate me, check range should use seeking query
--*
-- * GstPadCheckGetRangeFunction:
-- * @pad: a #GstPad
-- *
-- * Check if @pad can be activated in pull mode.
-- *
-- * This function will be deprecated after 0.10; use the seeking query to check
-- * if a pad can support random access.
-- *
-- * Returns: TRUE if the pad can operate in pull mode.
--
type GstPadCheckGetRangeFunction is access function (arg1 : access GstPad) return GLIB.gboolean;
pragma Convention (C, GstPadCheckGetRangeFunction); -- gst/gstpad.h:392
-- internal links
--*
-- * GstPadIntLinkFunction:
-- * @pad: The #GstPad to query.
-- *
-- * The signature of the internal pad link function.
-- *
-- * Returns: (element-type Gst.Pad) (transfer container): a newly allocated #GList of pads that are linked to the given pad on
-- * the inside of the parent element.
-- *
-- * The caller must call g_list_free() on it after use.
-- *
-- * Deprecated: use the threadsafe #GstPadIterIntLinkFunction instead.
--
type GstPadIntLinkFunction is access function (arg1 : access GstPad) return access GStreamer.GST_Low_Level.glib_2_0_glib_glist_h.GList;
pragma Convention (C, GstPadIntLinkFunction); -- gst/gstpad.h:409
--*
-- * GstPadIterIntLinkFunction:
-- * @pad: The #GstPad to query.
-- *
-- * The signature of the internal pad link iterator function.
-- *
-- * Returns: a new #GstIterator that will iterate over all pads that are
-- * linked to the given pad on the inside of the parent element.
-- *
-- * the caller must call gst_iterator_free() after usage.
-- *
-- * Since 0.10.21
--
type GstPadIterIntLinkFunction is access function (arg1 : access GstPad) return access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstiterator_h.GstIterator;
pragma Convention (C, GstPadIterIntLinkFunction); -- gst/gstpad.h:426
-- generic query function
--*
-- * GstPadQueryTypeFunction:
-- * @pad: a #GstPad to query
-- *
-- * The signature of the query types function.
-- *
-- * Returns: a constant array of query types
--
type GstPadQueryTypeFunction is access function (arg1 : access GstPad) return access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstquery_h.GstQueryType;
pragma Convention (C, GstPadQueryTypeFunction); -- gst/gstpad.h:437
--*
-- * GstPadQueryFunction:
-- * @pad: the #GstPad to query.
-- * @query: the #GstQuery object to execute
-- *
-- * The signature of the query function.
-- *
-- * Returns: TRUE if the query could be performed.
--
type GstPadQueryFunction is access function (arg1 : access GstPad; arg2 : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstquery_h.GstQuery) return GLIB.gboolean;
pragma Convention (C, GstPadQueryFunction); -- gst/gstpad.h:448
-- linking
--*
-- * GstPadLinkFunction
-- * @pad: the #GstPad that is linked.
-- * @peer: the peer #GstPad of the link
-- *
-- * Function signature to handle a new link on the pad.
-- *
-- * Returns: the result of the link with the specified peer.
--
type GstPadLinkFunction is access function (arg1 : access GstPad; arg2 : access GstPad) return GstPadLinkReturn;
pragma Convention (C, GstPadLinkFunction); -- gst/gstpad.h:461
--*
-- * GstPadUnlinkFunction
-- * @pad: the #GstPad that is linked.
-- *
-- * Function signature to handle a unlinking the pad prom its peer.
--
type GstPadUnlinkFunction is access procedure (arg1 : access GstPad);
pragma Convention (C, GstPadUnlinkFunction); -- gst/gstpad.h:468
-- caps nego
--*
-- * GstPadGetCapsFunction:
-- * @pad: the #GstPad to get the capabilities of.
-- *
-- * Returns a copy of the capabilities of the specified pad. By default this
-- * function will return the pad template capabilities, but can optionally
-- * be overridden by elements.
-- *
-- * Returns: a newly allocated copy #GstCaps of the pad.
--
type GstPadGetCapsFunction is access function (arg1 : access GstPad) return access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstcaps_h.GstCaps;
pragma Convention (C, GstPadGetCapsFunction); -- gst/gstpad.h:482
--*
-- * GstPadSetCapsFunction:
-- * @pad: the #GstPad to set the capabilities of.
-- * @caps: the #GstCaps to set
-- *
-- * Set @caps on @pad. By default this function updates the caps of the
-- * pad but the function can be overriden by elements to perform extra
-- * actions or verifications.
-- *
-- * Returns: TRUE if the caps could be set on the pad.
--
type GstPadSetCapsFunction is access function (arg1 : access GstPad; arg2 : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstcaps_h.GstCaps) return GLIB.gboolean;
pragma Convention (C, GstPadSetCapsFunction); -- gst/gstpad.h:495
--*
-- * GstPadAcceptCapsFunction:
-- * @pad: the #GstPad to check
-- * @caps: the #GstCaps to check
-- *
-- * Check if @pad can accept @caps. By default this function will see if @caps
-- * intersect with the result from gst_pad_get_caps() by can be overridden to
-- * perform extra checks.
-- *
-- * Returns: TRUE if the caps can be accepted by the pad.
--
type GstPadAcceptCapsFunction is access function (arg1 : access GstPad; arg2 : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstcaps_h.GstCaps) return GLIB.gboolean;
pragma Convention (C, GstPadAcceptCapsFunction); -- gst/gstpad.h:507
--*
-- * GstPadFixateCapsFunction:
-- * @pad: a #GstPad
-- * @caps: the #GstCaps to fixate
-- *
-- * Given possibly unfixed caps @caps, let @pad use its default preferred
-- * format to make a fixed caps. @caps should be writable. By default this
-- * function will pick the first value of any ranges or lists in the caps but
-- * elements can override this function to perform other behaviour.
--
type GstPadFixateCapsFunction is access procedure (arg1 : access GstPad; arg2 : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstcaps_h.GstCaps);
pragma Convention (C, GstPadFixateCapsFunction); -- gst/gstpad.h:518
--*
-- * GstPadBufferAllocFunction:
-- * @pad: a sink #GstPad
-- * @offset: the desired offset of the buffer
-- * @size: the desired size of the buffer
-- * @caps: the desired caps of the buffer
-- * @buf: pointer to hold the allocated buffer.
-- *
-- * Ask the sinkpad @pad to allocate a buffer with @offset, @size and @caps.
-- * The result will be stored in @buf.
-- *
-- * The purpose of this function is to allocate a buffer that is optimal to
-- * be processed by @pad. The function is mostly overridden by elements that can
-- * provide a hardware buffer in order to avoid additional memcpy operations.
-- *
-- * The function can return a buffer that has caps different from the requested
-- * @caps, in which case the upstream element requests a format change to this
-- * new caps.
-- * If a format change was requested, the returned buffer will be one to hold
-- * the data of said new caps, so its size might be different from the requested
-- * @size.
-- *
-- * When this function returns anything else than #GST_FLOW_OK, the buffer allocation
-- * failed and @buf does not contain valid data. If the function returns #GST_FLOW_OK and
-- * the @buf is NULL, a #GstBuffer will be created with @caps, @offset and @size.
-- *
-- * By default this function returns a new buffer of @size and with @caps containing
-- * purely malloced data. The buffer should be freed with gst_buffer_unref()
-- * after usage.
-- *
-- * Returns: #GST_FLOW_OK if @buf contains a valid buffer, any other return
-- * value means @buf does not hold a valid buffer.
--
type GstPadBufferAllocFunction is access function
(arg1 : access GstPad;
arg2 : GLIB.guint64;
arg3 : GLIB.guint;
arg4 : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstcaps_h.GstCaps;
arg5 : System.Address) return GstFlowReturn;
pragma Convention (C, GstPadBufferAllocFunction); -- gst/gstpad.h:552
-- misc
--*
-- * GstPadDispatcherFunction:
-- * @pad: the #GstPad that is dispatched.
-- * @data: the gpointer to optional user data.
-- *
-- * A dispatcher function is called for all internally linked pads, see
-- * gst_pad_dispatcher().
-- *
-- * Returns: TRUE if the dispatching procedure has to be stopped.
--
type GstPadDispatcherFunction is access function (arg1 : access GstPad; arg2 : System.Address) return GLIB.gboolean;
pragma Convention (C, GstPadDispatcherFunction); -- gst/gstpad.h:566
--*
-- * GstPadBlockCallback:
-- * @pad: the #GstPad that is blockend or unblocked.
-- * @blocked: blocking state for the pad
-- * @user_data: the gpointer to optional user data.
-- *
-- * Callback used by gst_pad_set_blocked_async(). Gets called when the blocking
-- * operation succeeds.
--
type GstPadBlockCallback is access procedure
(arg1 : access GstPad;
arg2 : GLIB.gboolean;
arg3 : System.Address);
pragma Convention (C, GstPadBlockCallback); -- gst/gstpad.h:577
--*
-- * GstPadDirection:
-- * @GST_PAD_UNKNOWN: direction is unknown.
-- * @GST_PAD_SRC: the pad is a source pad.
-- * @GST_PAD_SINK: the pad is a sink pad.
-- *
-- * The direction of a pad.
--
type GstPadDirection is
(GST_PAD_UNKNOWN,
GST_PAD_SRC,
GST_PAD_SINK);
pragma Convention (C, GstPadDirection); -- gst/gstpad.h:591
--*
-- * GstPadFlags:
-- * @GST_PAD_BLOCKED: is dataflow on a pad blocked
-- * @GST_PAD_FLUSHING: is pad refusing buffers
-- * @GST_PAD_IN_GETCAPS: GstPadGetCapsFunction() is running now
-- * @GST_PAD_IN_SETCAPS: GstPadSetCapsFunction() is running now
-- * @GST_PAD_BLOCKING: is pad currently blocking on a buffer or event
-- * @GST_PAD_FLAG_LAST: offset to define more flags
-- *
-- * Pad state flags
--
-- padding
type GstPadFlags is new unsigned;
GST_PAD_BLOCKED : constant GstPadFlags := 16;
GST_PAD_FLUSHING : constant GstPadFlags := 32;
GST_PAD_IN_GETCAPS : constant GstPadFlags := 64;
GST_PAD_IN_SETCAPS : constant GstPadFlags := 128;
GST_PAD_BLOCKING : constant GstPadFlags := 256;
GST_PAD_FLAG_LAST : constant GstPadFlags := 4096; -- gst/gstpad.h:612
-- FIXME: this awful circular dependency need to be resolved properly (see padtemplate.h)
-- subtype GstPadTemplate is GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstpadtemplate_h.GstPadTemplate -- gst/gstpad.h:615
--*
-- * GstPad:
-- * @element_private: private data owned by the parent element
-- * @padtemplate: padtemplate for this pad
-- * @direction: the direction of the pad, cannot change after creating
-- * the pad.
-- * @stream_rec_lock: recursive stream lock of the pad, used to protect
-- * the data used in streaming.
-- * @task: task for this pad if the pad is actively driving dataflow.
-- * @preroll_lock: lock used when prerolling
-- * @preroll_cond: conf to signal preroll
-- * @block_cond: conditional to signal pad block
-- * @block_callback: callback for the pad block if any
-- * @block_data: user data for @block_callback
-- * @caps: the current caps of the pad
-- * @getcapsfunc: function to get caps of the pad
-- * @setcapsfunc: function to set caps on the pad
-- * @acceptcapsfunc: function to check if pad can accept caps
-- * @fixatecapsfunc: function to fixate caps
-- * @activatefunc: pad activation function
-- * @activatepushfunc: function to activate/deactivate pad in push mode
-- * @activatepullfunc: function to activate/deactivate pad in pull mode
-- * @linkfunc: function called when pad is linked
-- * @unlinkfunc: function called when pad is unlinked
-- * @peer: the pad this pad is linked to
-- * @sched_private: private storage for the scheduler
-- * @chainfunc: function to chain buffer to pad
-- * @checkgetrangefunc: function to check if pad can operate in pull mode
-- * @getrangefunc: function to get a range of data from a pad
-- * @eventfunc: function to send an event to a pad
-- * @mode: current activation mode of the pad
-- * @querytypefunc: get list of supported queries
-- * @queryfunc: perform a query on the pad
-- * @intlinkfunc: get the internal links of this pad
-- * @bufferallocfunc: function to allocate a buffer for this pad
-- * @do_buffer_signals: counter counting installed buffer signals
-- * @do_event_signals: counter counting installed event signals
-- * @iterintlinkfunc: get the internal links iterator of this pad
-- * @block_destroy_data: notify function for gst_pad_set_blocked_async_full()
-- *
-- * The #GstPad structure. Use the functions to update the variables.
--
type GstPad is record
object : aliased GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstobject_h.GstObject; -- gst/gstpad.h:660
element_private : System.Address; -- gst/gstpad.h:663
padtemplate : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstpadtemplate_h.GstPadTemplate; -- gst/gstpad.h:665
direction : aliased GstPadDirection; -- gst/gstpad.h:667
stream_rec_lock : access GStreamer.GST_Low_Level.glib_2_0_glib_deprecated_gthread_h.GStaticRecMutex; -- gst/gstpad.h:671
c_task : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gsttask_h.GstTask; -- gst/gstpad.h:672
preroll_lock : access GStreamer.GST_Low_Level.glib_2_0_glib_gthread_h.GMutex; -- gst/gstpad.h:674
preroll_cond : access GStreamer.GST_Low_Level.glib_2_0_glib_gthread_h.GCond; -- gst/gstpad.h:675
block_cond : access GStreamer.GST_Low_Level.glib_2_0_glib_gthread_h.GCond; -- gst/gstpad.h:679
block_callback : GstPadBlockCallback; -- gst/gstpad.h:680
block_data : System.Address; -- gst/gstpad.h:681
caps : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstcaps_h.GstCaps; -- gst/gstpad.h:684
getcapsfunc : GstPadGetCapsFunction; -- gst/gstpad.h:685
setcapsfunc : GstPadSetCapsFunction; -- gst/gstpad.h:686
acceptcapsfunc : GstPadAcceptCapsFunction; -- gst/gstpad.h:687
fixatecapsfunc : GstPadFixateCapsFunction; -- gst/gstpad.h:688
activatefunc : GstPadActivateFunction; -- gst/gstpad.h:690
activatepushfunc : GstPadActivateModeFunction; -- gst/gstpad.h:691
activatepullfunc : GstPadActivateModeFunction; -- gst/gstpad.h:692
linkfunc : GstPadLinkFunction; -- gst/gstpad.h:695
unlinkfunc : GstPadUnlinkFunction; -- gst/gstpad.h:696
peer : access GstPad; -- gst/gstpad.h:697
sched_private : System.Address; -- gst/gstpad.h:699
chainfunc : GstPadChainFunction; -- gst/gstpad.h:702
checkgetrangefunc : GstPadCheckGetRangeFunction; -- gst/gstpad.h:703
getrangefunc : GstPadGetRangeFunction; -- gst/gstpad.h:704
eventfunc : GstPadEventFunction; -- gst/gstpad.h:705
mode : aliased GstActivateMode; -- gst/gstpad.h:707
querytypefunc : GstPadQueryTypeFunction; -- gst/gstpad.h:710
queryfunc : GstPadQueryFunction; -- gst/gstpad.h:711
intlinkfunc : GstPadIntLinkFunction; -- gst/gstpad.h:715
bufferallocfunc : GstPadBufferAllocFunction; -- gst/gstpad.h:722
do_buffer_signals : aliased GLIB.gint; -- gst/gstpad.h:726
do_event_signals : aliased GLIB.gint; -- gst/gstpad.h:727
iterintlinkfunc : GstPadIterIntLinkFunction; -- gst/gstpad.h:731
block_destroy_data : GStreamer.GST_Low_Level.glib_2_0_glib_gtypes_h.GDestroyNotify; -- gst/gstpad.h:734
abidata : aliased anon_200; -- gst/gstpad.h:743
end record;
pragma Convention (C_Pass_By_Copy, GstPad); -- gst/gstpad.h:659
--< public >
--< public >
-- with STREAM_LOCK
-- streaming rec_lock
--< public >
-- with PREROLL_LOCK
--< public >
-- with LOCK
-- block cond, mutex is from the object
-- the pad capabilities
-- pad link
-- data transport functions
-- generic query method
-- internal links
-- whether to emit signals for have-data. counts number
-- * of handlers attached.
-- ABI added
-- iterate internal links
-- free block_data
--< private >
type GstPadClass is record
parent_class : aliased GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstobject_h.GstObjectClass; -- gst/gstpad.h:747
linked : access procedure (arg1 : access GstPad; arg2 : access GstPad); -- gst/gstpad.h:750
unlinked : access procedure (arg1 : access GstPad; arg2 : access GstPad); -- gst/gstpad.h:751
request_link : access procedure (arg1 : access GstPad); -- gst/gstpad.h:752
have_data : access function (arg1 : access GstPad; arg2 : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstminiobject_h.GstMiniObject) return GLIB.gboolean; -- gst/gstpad.h:753
u_gst_reserved : u_GstPadClass_u_gst_reserved_array; -- gst/gstpad.h:756
end record;
pragma Convention (C_Pass_By_Copy, GstPadClass); -- gst/gstpad.h:746
-- signal callbacks
--< private >
--**** helper macros ****
-- GstPad
--*
-- * GST_PAD_CAPS:
-- * @pad: a #GstPad.
-- *
-- * The caps for this pad.
--
--*
-- * GST_PAD_GET_STREAM_LOCK:
-- * @pad: a #GstPad
-- *
-- * Get the stream lock of @pad. The stream lock is protecting the
-- * resources used in the data processing functions of @pad.
--
--*
-- * GST_PAD_STREAM_LOCK:
-- * @pad: a #GstPad
-- *
-- * Lock the stream lock of @pad.
--
--*
-- * GST_PAD_STREAM_LOCK_FULL:
-- * @pad: a #GstPad
-- * @t: the number of times to recursively lock
-- *
-- * Lock the stream lock of @pad @t times.
--
--*
-- * GST_PAD_STREAM_TRYLOCK:
-- * @pad: a #GstPad
-- *
-- * Try to Lock the stream lock of the pad, return TRUE if the lock could be
-- * taken.
--
--*
-- * GST_PAD_STREAM_UNLOCK:
-- * @pad: a #GstPad
-- *
-- * Unlock the stream lock of @pad.
--
--*
-- * GST_PAD_STREAM_UNLOCK_FULL:
-- * @pad: a #GstPad
-- *
-- * Fully unlock the recursive stream lock of @pad, return the number of times
-- * @pad was locked.
--
-- FIXME: this awful circular dependency need to be resolved properly (see padtemplate.h)
function gst_pad_get_type return GLIB.GType; -- gst/gstpad.h:885
pragma Import (C, gst_pad_get_type, "gst_pad_get_type");
-- creating pads
function gst_pad_new (name : access GLIB.gchar; direction : GstPadDirection) return access GstPad; -- gst/gstpad.h:888
pragma Import (C, gst_pad_new, "gst_pad_new");
function gst_pad_new_from_template (templ : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstpadtemplate_h.GstPadTemplate; name : access GLIB.gchar) return access GstPad; -- gst/gstpad.h:889
pragma Import (C, gst_pad_new_from_template, "gst_pad_new_from_template");
function gst_pad_new_from_static_template (templ : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstpadtemplate_h.GstStaticPadTemplate; name : access GLIB.gchar) return access GstPad; -- gst/gstpad.h:890
pragma Import (C, gst_pad_new_from_static_template, "gst_pad_new_from_static_template");
--*
-- * gst_pad_get_name:
-- * @pad: the pad to get the name from
-- *
-- * Get a copy of the name of the pad. g_free() after usage.
-- *
-- * MT safe.
--
--*
-- * gst_pad_get_parent:
-- * @pad: the pad to get the parent of
-- *
-- * Get the parent of @pad. This function increases the refcount
-- * of the parent object so you should gst_object_unref() it after usage.
-- * Can return NULL if the pad did not have a parent.
-- *
-- * MT safe.
--
function gst_pad_get_direction (pad : access GstPad) return GstPadDirection; -- gst/gstpad.h:914
pragma Import (C, gst_pad_get_direction, "gst_pad_get_direction");
function gst_pad_set_active (pad : access GstPad; active : GLIB.gboolean) return GLIB.gboolean; -- gst/gstpad.h:916
pragma Import (C, gst_pad_set_active, "gst_pad_set_active");
function gst_pad_is_active (pad : access GstPad) return GLIB.gboolean; -- gst/gstpad.h:917
pragma Import (C, gst_pad_is_active, "gst_pad_is_active");
function gst_pad_activate_pull (pad : access GstPad; active : GLIB.gboolean) return GLIB.gboolean; -- gst/gstpad.h:918
pragma Import (C, gst_pad_activate_pull, "gst_pad_activate_pull");
function gst_pad_activate_push (pad : access GstPad; active : GLIB.gboolean) return GLIB.gboolean; -- gst/gstpad.h:919
pragma Import (C, gst_pad_activate_push, "gst_pad_activate_push");
function gst_pad_set_blocked (pad : access GstPad; blocked : GLIB.gboolean) return GLIB.gboolean; -- gst/gstpad.h:921
pragma Import (C, gst_pad_set_blocked, "gst_pad_set_blocked");
function gst_pad_set_blocked_async
(pad : access GstPad;
blocked : GLIB.gboolean;
callback : GstPadBlockCallback;
user_data : System.Address) return GLIB.gboolean; -- gst/gstpad.h:922
pragma Import (C, gst_pad_set_blocked_async, "gst_pad_set_blocked_async");
function gst_pad_set_blocked_async_full
(pad : access GstPad;
blocked : GLIB.gboolean;
callback : GstPadBlockCallback;
user_data : System.Address;
destroy_data : GStreamer.GST_Low_Level.glib_2_0_glib_gtypes_h.GDestroyNotify) return GLIB.gboolean; -- gst/gstpad.h:924
pragma Import (C, gst_pad_set_blocked_async_full, "gst_pad_set_blocked_async_full");
function gst_pad_is_blocked (pad : access GstPad) return GLIB.gboolean; -- gst/gstpad.h:927
pragma Import (C, gst_pad_is_blocked, "gst_pad_is_blocked");
function gst_pad_is_blocking (pad : access GstPad) return GLIB.gboolean; -- gst/gstpad.h:928
pragma Import (C, gst_pad_is_blocking, "gst_pad_is_blocking");
procedure gst_pad_set_element_private (pad : access GstPad; priv : System.Address); -- gst/gstpad.h:930
pragma Import (C, gst_pad_set_element_private, "gst_pad_set_element_private");
function gst_pad_get_element_private (pad : access GstPad) return System.Address; -- gst/gstpad.h:931
pragma Import (C, gst_pad_get_element_private, "gst_pad_get_element_private");
function gst_pad_get_pad_template (pad : access GstPad) return access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstpadtemplate_h.GstPadTemplate; -- gst/gstpad.h:933
pragma Import (C, gst_pad_get_pad_template, "gst_pad_get_pad_template");
procedure gst_pad_set_bufferalloc_function (pad : access GstPad; bufalloc : GstPadBufferAllocFunction); -- gst/gstpad.h:935
pragma Import (C, gst_pad_set_bufferalloc_function, "gst_pad_set_bufferalloc_function");
function gst_pad_alloc_buffer
(pad : access GstPad;
offset : GLIB.guint64;
size : GLIB.gint;
caps : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstcaps_h.GstCaps;
buf : System.Address) return GstFlowReturn; -- gst/gstpad.h:936
pragma Import (C, gst_pad_alloc_buffer, "gst_pad_alloc_buffer");
function gst_pad_alloc_buffer_and_set_caps
(pad : access GstPad;
offset : GLIB.guint64;
size : GLIB.gint;
caps : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstcaps_h.GstCaps;
buf : System.Address) return GstFlowReturn; -- gst/gstpad.h:938
pragma Import (C, gst_pad_alloc_buffer_and_set_caps, "gst_pad_alloc_buffer_and_set_caps");
-- data passing setup functions
procedure gst_pad_set_activate_function (pad : access GstPad; activate : GstPadActivateFunction); -- gst/gstpad.h:942
pragma Import (C, gst_pad_set_activate_function, "gst_pad_set_activate_function");
procedure gst_pad_set_activatepull_function (pad : access GstPad; activatepull : GstPadActivateModeFunction); -- gst/gstpad.h:943
pragma Import (C, gst_pad_set_activatepull_function, "gst_pad_set_activatepull_function");
procedure gst_pad_set_activatepush_function (pad : access GstPad; activatepush : GstPadActivateModeFunction); -- gst/gstpad.h:944
pragma Import (C, gst_pad_set_activatepush_function, "gst_pad_set_activatepush_function");
procedure gst_pad_set_chain_function (pad : access GstPad; chain : GstPadChainFunction); -- gst/gstpad.h:945
pragma Import (C, gst_pad_set_chain_function, "gst_pad_set_chain_function");
procedure gst_pad_set_chain_list_function (pad : access GstPad; chainlist : GstPadChainListFunction); -- gst/gstpad.h:946
pragma Import (C, gst_pad_set_chain_list_function, "gst_pad_set_chain_list_function");
procedure gst_pad_set_getrange_function (pad : access GstPad; get : GstPadGetRangeFunction); -- gst/gstpad.h:947
pragma Import (C, gst_pad_set_getrange_function, "gst_pad_set_getrange_function");
procedure gst_pad_set_checkgetrange_function (pad : access GstPad; check : GstPadCheckGetRangeFunction); -- gst/gstpad.h:948
pragma Import (C, gst_pad_set_checkgetrange_function, "gst_pad_set_checkgetrange_function");
procedure gst_pad_set_event_function (pad : access GstPad; event : GstPadEventFunction); -- gst/gstpad.h:949
pragma Import (C, gst_pad_set_event_function, "gst_pad_set_event_function");
-- pad links
procedure gst_pad_set_link_function (pad : access GstPad; link : GstPadLinkFunction); -- gst/gstpad.h:952
pragma Import (C, gst_pad_set_link_function, "gst_pad_set_link_function");
procedure gst_pad_set_unlink_function (pad : access GstPad; unlink : GstPadUnlinkFunction); -- gst/gstpad.h:953
pragma Import (C, gst_pad_set_unlink_function, "gst_pad_set_unlink_function");
function gst_pad_can_link (srcpad : access GstPad; sinkpad : access GstPad) return GLIB.gboolean; -- gst/gstpad.h:955
pragma Import (C, gst_pad_can_link, "gst_pad_can_link");
function gst_pad_link (srcpad : access GstPad; sinkpad : access GstPad) return GstPadLinkReturn; -- gst/gstpad.h:956
pragma Import (C, gst_pad_link, "gst_pad_link");
function gst_pad_link_full
(srcpad : access GstPad;
sinkpad : access GstPad;
flags : GstPadLinkCheck) return GstPadLinkReturn; -- gst/gstpad.h:957
pragma Import (C, gst_pad_link_full, "gst_pad_link_full");
function gst_pad_unlink (srcpad : access GstPad; sinkpad : access GstPad) return GLIB.gboolean; -- gst/gstpad.h:958
pragma Import (C, gst_pad_unlink, "gst_pad_unlink");
function gst_pad_is_linked (pad : access GstPad) return GLIB.gboolean; -- gst/gstpad.h:959
pragma Import (C, gst_pad_is_linked, "gst_pad_is_linked");
function gst_pad_get_peer (pad : access GstPad) return access GstPad; -- gst/gstpad.h:961
pragma Import (C, gst_pad_get_peer, "gst_pad_get_peer");
-- capsnego functions
procedure gst_pad_set_getcaps_function (pad : access GstPad; getcaps : GstPadGetCapsFunction); -- gst/gstpad.h:964
pragma Import (C, gst_pad_set_getcaps_function, "gst_pad_set_getcaps_function");
procedure gst_pad_set_acceptcaps_function (pad : access GstPad; acceptcaps : GstPadAcceptCapsFunction); -- gst/gstpad.h:965
pragma Import (C, gst_pad_set_acceptcaps_function, "gst_pad_set_acceptcaps_function");
procedure gst_pad_set_fixatecaps_function (pad : access GstPad; fixatecaps : GstPadFixateCapsFunction); -- gst/gstpad.h:966
pragma Import (C, gst_pad_set_fixatecaps_function, "gst_pad_set_fixatecaps_function");
procedure gst_pad_set_setcaps_function (pad : access GstPad; setcaps : GstPadSetCapsFunction); -- gst/gstpad.h:967
pragma Import (C, gst_pad_set_setcaps_function, "gst_pad_set_setcaps_function");
function gst_pad_get_pad_template_caps (pad : access GstPad) return access constant GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstcaps_h.GstCaps; -- gst/gstpad.h:969
pragma Import (C, gst_pad_get_pad_template_caps, "gst_pad_get_pad_template_caps");
-- capsnego function for linked/unlinked pads
function gst_pad_get_caps_reffed (pad : access GstPad) return access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstcaps_h.GstCaps; -- gst/gstpad.h:972
pragma Import (C, gst_pad_get_caps_reffed, "gst_pad_get_caps_reffed");
function gst_pad_get_caps (pad : access GstPad) return access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstcaps_h.GstCaps; -- gst/gstpad.h:973
pragma Import (C, gst_pad_get_caps, "gst_pad_get_caps");
procedure gst_pad_fixate_caps (pad : access GstPad; caps : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstcaps_h.GstCaps); -- gst/gstpad.h:974
pragma Import (C, gst_pad_fixate_caps, "gst_pad_fixate_caps");
function gst_pad_accept_caps (pad : access GstPad; caps : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstcaps_h.GstCaps) return GLIB.gboolean; -- gst/gstpad.h:975
pragma Import (C, gst_pad_accept_caps, "gst_pad_accept_caps");
function gst_pad_set_caps (pad : access GstPad; caps : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstcaps_h.GstCaps) return GLIB.gboolean; -- gst/gstpad.h:976
pragma Import (C, gst_pad_set_caps, "gst_pad_set_caps");
function gst_pad_peer_get_caps_reffed (pad : access GstPad) return access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstcaps_h.GstCaps; -- gst/gstpad.h:978
pragma Import (C, gst_pad_peer_get_caps_reffed, "gst_pad_peer_get_caps_reffed");
function gst_pad_peer_get_caps (pad : access GstPad) return access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstcaps_h.GstCaps; -- gst/gstpad.h:979
pragma Import (C, gst_pad_peer_get_caps, "gst_pad_peer_get_caps");
function gst_pad_peer_accept_caps (pad : access GstPad; caps : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstcaps_h.GstCaps) return GLIB.gboolean; -- gst/gstpad.h:980
pragma Import (C, gst_pad_peer_accept_caps, "gst_pad_peer_accept_caps");
-- capsnego for linked pads
function gst_pad_get_allowed_caps (pad : access GstPad) return access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstcaps_h.GstCaps; -- gst/gstpad.h:983
pragma Import (C, gst_pad_get_allowed_caps, "gst_pad_get_allowed_caps");
function gst_pad_get_negotiated_caps (pad : access GstPad) return access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstcaps_h.GstCaps; -- gst/gstpad.h:984
pragma Import (C, gst_pad_get_negotiated_caps, "gst_pad_get_negotiated_caps");
-- data passing functions to peer
function gst_pad_push (pad : access GstPad; buffer : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstbuffer_h.GstBuffer) return GstFlowReturn; -- gst/gstpad.h:987
pragma Import (C, gst_pad_push, "gst_pad_push");
function gst_pad_push_list (pad : access GstPad; list : System.Address) return GstFlowReturn; -- gst/gstpad.h:988
pragma Import (C, gst_pad_push_list, "gst_pad_push_list");
function gst_pad_check_pull_range (pad : access GstPad) return GLIB.gboolean; -- gst/gstpad.h:989
pragma Import (C, gst_pad_check_pull_range, "gst_pad_check_pull_range");
function gst_pad_pull_range
(pad : access GstPad;
offset : GLIB.guint64;
size : GLIB.guint;
buffer : System.Address) return GstFlowReturn; -- gst/gstpad.h:990
pragma Import (C, gst_pad_pull_range, "gst_pad_pull_range");
function gst_pad_push_event (pad : access GstPad; event : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstevent_h.GstEvent) return GLIB.gboolean; -- gst/gstpad.h:992
pragma Import (C, gst_pad_push_event, "gst_pad_push_event");
function gst_pad_event_default (pad : access GstPad; event : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstevent_h.GstEvent) return GLIB.gboolean; -- gst/gstpad.h:993
pragma Import (C, gst_pad_event_default, "gst_pad_event_default");
-- data passing functions on pad
function gst_pad_chain (pad : access GstPad; buffer : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstbuffer_h.GstBuffer) return GstFlowReturn; -- gst/gstpad.h:996
pragma Import (C, gst_pad_chain, "gst_pad_chain");
function gst_pad_chain_list (pad : access GstPad; list : System.Address) return GstFlowReturn; -- gst/gstpad.h:997
pragma Import (C, gst_pad_chain_list, "gst_pad_chain_list");
function gst_pad_get_range
(pad : access GstPad;
offset : GLIB.guint64;
size : GLIB.guint;
buffer : System.Address) return GstFlowReturn; -- gst/gstpad.h:998
pragma Import (C, gst_pad_get_range, "gst_pad_get_range");
function gst_pad_send_event (pad : access GstPad; event : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstevent_h.GstEvent) return GLIB.gboolean; -- gst/gstpad.h:1000
pragma Import (C, gst_pad_send_event, "gst_pad_send_event");
-- pad tasks
function gst_pad_start_task
(pad : access GstPad;
func : GStreamer.GST_Low_Level.gstreamer_0_10_gst_gsttask_h.GstTaskFunction;
data : System.Address) return GLIB.gboolean; -- gst/gstpad.h:1003
pragma Import (C, gst_pad_start_task, "gst_pad_start_task");
function gst_pad_pause_task (pad : access GstPad) return GLIB.gboolean; -- gst/gstpad.h:1005
pragma Import (C, gst_pad_pause_task, "gst_pad_pause_task");
function gst_pad_stop_task (pad : access GstPad) return GLIB.gboolean; -- gst/gstpad.h:1006
pragma Import (C, gst_pad_stop_task, "gst_pad_stop_task");
-- internal links
procedure gst_pad_set_internal_link_function (pad : access GstPad; intlink : GstPadIntLinkFunction); -- gst/gstpad.h:1010
pragma Import (C, gst_pad_set_internal_link_function, "gst_pad_set_internal_link_function");
function gst_pad_get_internal_links (pad : access GstPad) return access GStreamer.GST_Low_Level.glib_2_0_glib_glist_h.GList; -- gst/gstpad.h:1011
pragma Import (C, gst_pad_get_internal_links, "gst_pad_get_internal_links");
function gst_pad_get_internal_links_default (pad : access GstPad) return access GStreamer.GST_Low_Level.glib_2_0_glib_glist_h.GList; -- gst/gstpad.h:1012
pragma Import (C, gst_pad_get_internal_links_default, "gst_pad_get_internal_links_default");
procedure gst_pad_set_iterate_internal_links_function (pad : access GstPad; iterintlink : GstPadIterIntLinkFunction); -- gst/gstpad.h:1015
pragma Import (C, gst_pad_set_iterate_internal_links_function, "gst_pad_set_iterate_internal_links_function");
function gst_pad_iterate_internal_links (pad : access GstPad) return access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstiterator_h.GstIterator; -- gst/gstpad.h:1017
pragma Import (C, gst_pad_iterate_internal_links, "gst_pad_iterate_internal_links");
function gst_pad_iterate_internal_links_default (pad : access GstPad) return access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstiterator_h.GstIterator; -- gst/gstpad.h:1018
pragma Import (C, gst_pad_iterate_internal_links_default, "gst_pad_iterate_internal_links_default");
-- generic query function
procedure gst_pad_set_query_type_function (pad : access GstPad; type_func : GstPadQueryTypeFunction); -- gst/gstpad.h:1022
pragma Import (C, gst_pad_set_query_type_function, "gst_pad_set_query_type_function");
function gst_pad_get_query_types (pad : access GstPad) return access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstquery_h.GstQueryType; -- gst/gstpad.h:1023
pragma Import (C, gst_pad_get_query_types, "gst_pad_get_query_types");
function gst_pad_get_query_types_default (pad : access GstPad) return access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstquery_h.GstQueryType; -- gst/gstpad.h:1024
pragma Import (C, gst_pad_get_query_types_default, "gst_pad_get_query_types_default");
function gst_pad_query (pad : access GstPad; query : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstquery_h.GstQuery) return GLIB.gboolean; -- gst/gstpad.h:1026
pragma Import (C, gst_pad_query, "gst_pad_query");
function gst_pad_peer_query (pad : access GstPad; query : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstquery_h.GstQuery) return GLIB.gboolean; -- gst/gstpad.h:1027
pragma Import (C, gst_pad_peer_query, "gst_pad_peer_query");
procedure gst_pad_set_query_function (pad : access GstPad; query : GstPadQueryFunction); -- gst/gstpad.h:1028
pragma Import (C, gst_pad_set_query_function, "gst_pad_set_query_function");
function gst_pad_query_default (pad : access GstPad; query : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstquery_h.GstQuery) return GLIB.gboolean; -- gst/gstpad.h:1029
pragma Import (C, gst_pad_query_default, "gst_pad_query_default");
-- misc helper functions
function gst_pad_dispatcher
(pad : access GstPad;
dispatch : GstPadDispatcherFunction;
data : System.Address) return GLIB.gboolean; -- gst/gstpad.h:1032
pragma Import (C, gst_pad_dispatcher, "gst_pad_dispatcher");
procedure gst_pad_load_and_link (self : GStreamer.GST_Low_Level.libxml2_libxml_tree_h.xmlNodePtr; parent : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstobject_h.GstObject); -- gst/gstpad.h:1036
pragma Import (C, gst_pad_load_and_link, "gst_pad_load_and_link");
end GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstpad_h;
|
programs/oeis/022/A022355.asm | karttu/loda | 0 | 164431 | <reponame>karttu/loda<filename>programs/oeis/022/A022355.asm
; A022355: Fibonacci sequence beginning 0, 21.
; 0,21,21,42,63,105,168,273,441,714,1155,1869,3024,4893,7917,12810,20727,33537,54264,87801,142065,229866,371931,601797,973728,1575525,2549253,4124778,6674031,10798809,17472840,28271649,45744489,74016138,119760627,193776765,313537392,507314157,820851549,1328165706,2149017255,3477182961,5626200216,9103383177,14729583393,23832966570,38562549963,62395516533,100958066496,163353583029,264311649525,427665232554,691976882079,1119642114633,1811618996712,2931261111345,4742880108057,7674141219402,12417021327459,20091162546861,32508183874320,52599346421181,85107530295501,137706876716682,222814407012183,360521283728865,583335690741048,943856974469913,1527192665210961,2471049639680874,3998242304891835,6469291944572709
mov $4,2
lpb $0,1
add $1,$0
sub $1,$0
sub $0,1
mov $2,$4
add $3,14
add $4,$1
mov $1,$2
add $1,$3
trn $3,$1
add $1,5
lpe
|
libsrc/_DEVELOPMENT/string/c/sccz80/strerror.asm | teknoplop/z88dk | 8 | 84654 | <reponame>teknoplop/z88dk<gh_stars>1-10
; char *strerror(int errnum)
SECTION code_clib
SECTION code_string
PUBLIC strerror
EXTERN asm_strerror
defc strerror = asm_strerror
|
oeis/074/A074597.asm | neoneye/loda-programs | 11 | 170697 | <filename>oeis/074/A074597.asm
; A074597: Numerator of 3 * H(n,3,2), a generalized harmonic number. See A075135.
; Submitted by <NAME>
; 3,21,99,1209,9123,164331,34437,823467,11066355,330317679,1355321733,990324351,19205317149,802205873349,815985479709,38957620226163,197637723726063,10617280487243739,75264900895382073
mov $1,1
lpb $0
mov $2,$0
sub $0,1
mul $2,3
add $2,2
mul $3,$2
add $3,$1
add $3,$1
mul $1,$2
lpe
add $1,$3
gcd $3,$1
div $1,$3
mov $0,$1
mul $0,3
|
ioq3/build/release-js-js/missionpack/game/ai_dmnet.asm | RawTechnique/quake-port | 1 | 29358 | export BotResetNodeSwitches
code
proc BotResetNodeSwitches 0 0
ADDRGP4 numnodeswitches
CNSTI4 0
ASGNI4
LABELV $54
endproc BotResetNodeSwitches 0 0
export BotDumpNodeSwitches
proc BotDumpNodeSwitches 40 20
ADDRFP4 0
INDIRP4
CNSTI4 8
ADDP4
INDIRI4
ARGI4
ADDRLP4 4
ARGP4
CNSTI4 36
ARGI4
ADDRGP4 ClientName
CALLP4
pop
CNSTI4 1
ARGI4
ADDRGP4 $56
ARGP4
ADDRLP4 4
ARGP4
ADDRGP4 floattime
INDIRF4
ARGF4
CNSTI4 50
ARGI4
ADDRGP4 BotAI_Print
CALLV
pop
ADDRLP4 0
CNSTI4 0
ASGNI4
ADDRGP4 $60
JUMPV
LABELV $57
CNSTI4 1
ARGI4
ADDRGP4 $61
ARGP4
CNSTI4 144
ADDRLP4 0
INDIRI4
MULI4
ADDRGP4 nodeswitch
ADDP4
ARGP4
ADDRGP4 BotAI_Print
CALLV
pop
LABELV $58
ADDRLP4 0
ADDRLP4 0
INDIRI4
CNSTI4 1
ADDI4
ASGNI4
LABELV $60
ADDRLP4 0
INDIRI4
ADDRGP4 numnodeswitches
INDIRI4
LTI4 $57
CNSTI4 4
ARGI4
ADDRGP4 $62
ARGP4
ADDRGP4 BotAI_Print
CALLV
pop
LABELV $55
endproc BotDumpNodeSwitches 40 20
export BotRecordNodeSwitch
proc BotRecordNodeSwitch 44 32
ADDRFP4 0
INDIRP4
CNSTI4 8
ADDP4
INDIRI4
ARGI4
ADDRLP4 0
ARGP4
CNSTI4 36
ARGI4
ADDRGP4 ClientName
CALLP4
pop
ADDRLP4 36
CNSTI4 144
ASGNI4
ADDRLP4 36
INDIRI4
ADDRGP4 numnodeswitches
INDIRI4
MULI4
ADDRGP4 nodeswitch
ADDP4
ARGP4
ADDRLP4 36
INDIRI4
ARGI4
ADDRGP4 $64
ARGP4
ADDRLP4 0
ARGP4
ADDRGP4 floattime
INDIRF4
ARGF4
ADDRFP4 4
INDIRP4
ARGP4
ADDRFP4 8
INDIRP4
ARGP4
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 Com_sprintf
CALLI4
pop
ADDRLP4 40
ADDRGP4 numnodeswitches
ASGNP4
ADDRLP4 40
INDIRP4
ADDRLP4 40
INDIRP4
INDIRI4
CNSTI4 1
ADDI4
ASGNI4
LABELV $63
endproc BotRecordNodeSwitch 44 32
lit
align 4
LABELV $66
byte 4 3245342720
byte 4 3245342720
byte 4 3221225472
align 4
LABELV $67
byte 4 1097859072
byte 4 1097859072
byte 4 1073741824
export BotGetAirGoal
code
proc BotGetAirGoal 140 28
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 4
ADDRFP4 4
INDIRP4
ASGNP4
ADDRLP4 96
ADDRGP4 $66
INDIRB
ASGNB 12
ADDRLP4 108
ADDRGP4 $67
INDIRB
ASGNB 12
ADDRLP4 0
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRB
ASGNB 12
ADDRLP4 0+8
ADDRLP4 0+8
INDIRF4
CNSTF4 1148846080
ADDF4
ASGNF4
ADDRLP4 12
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRLP4 96
ARGP4
ADDRLP4 108
ARGP4
ADDRLP4 0
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 12
ADDP4
INDIRI4
ARGI4
CNSTI4 65537
ARGI4
ADDRGP4 BotAI_Trace
CALLV
pop
ADDRLP4 0
ADDRLP4 12+12
INDIRB
ASGNB 12
ADDRLP4 12
ARGP4
ADDRLP4 0
ARGP4
ADDRLP4 96
ARGP4
ADDRLP4 108
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 12
ADDP4
INDIRI4
ARGI4
CNSTI4 56
ARGI4
ADDRGP4 BotAI_Trace
CALLV
pop
ADDRLP4 12+8
INDIRF4
CNSTF4 0
LEF4 $70
ADDRLP4 12+12
ARGP4
ADDRLP4 132
ADDRGP4 BotPointAreaNum
CALLI4
ASGNI4
ADDRLP4 120
ADDRLP4 132
INDIRI4
ASGNI4
ADDRLP4 120
INDIRI4
CNSTI4 0
EQI4 $74
ADDRFP4 4
INDIRP4
ADDRLP4 12+12
INDIRB
ASGNB 12
ADDRLP4 136
ADDRFP4 4
INDIRP4
CNSTI4 8
ADDP4
ASGNP4
ADDRLP4 136
INDIRP4
ADDRLP4 136
INDIRP4
INDIRF4
CNSTF4 1073741824
SUBF4
ASGNF4
ADDRFP4 4
INDIRP4
CNSTI4 12
ADDP4
ADDRLP4 120
INDIRI4
ASGNI4
ADDRFP4 4
INDIRP4
CNSTI4 16
ADDP4
CNSTF4 3245342720
ASGNF4
ADDRFP4 4
INDIRP4
CNSTI4 20
ADDP4
CNSTF4 3245342720
ASGNF4
ADDRFP4 4
INDIRP4
CNSTI4 24
ADDP4
CNSTF4 3212836864
ASGNF4
ADDRFP4 4
INDIRP4
CNSTI4 28
ADDP4
CNSTF4 1097859072
ASGNF4
ADDRFP4 4
INDIRP4
CNSTI4 32
ADDP4
CNSTF4 1097859072
ASGNF4
ADDRFP4 4
INDIRP4
CNSTI4 36
ADDP4
CNSTF4 1065353216
ASGNF4
ADDRFP4 4
INDIRP4
CNSTI4 48
ADDP4
CNSTI4 128
ASGNI4
ADDRFP4 4
INDIRP4
CNSTI4 44
ADDP4
CNSTI4 0
ASGNI4
ADDRFP4 4
INDIRP4
CNSTI4 52
ADDP4
CNSTI4 0
ASGNI4
ADDRFP4 4
INDIRP4
CNSTI4 40
ADDP4
CNSTI4 0
ASGNI4
CNSTI4 1
RETI4
ADDRGP4 $65
JUMPV
LABELV $74
LABELV $70
CNSTI4 0
RETI4
LABELV $65
endproc BotGetAirGoal 140 28
export BotGoForAir
proc BotGoForAir 68 24
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
CNSTI4 6176
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
CNSTF4 1086324736
SUBF4
GEF4 $78
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 0
ARGP4
ADDRLP4 56
ADDRGP4 BotGetAirGoal
CALLI4
ASGNI4
ADDRLP4 56
INDIRI4
CNSTI4 0
EQI4 $83
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRLP4 0
ARGP4
ADDRGP4 trap_BotPushGoal
CALLV
pop
CNSTI4 1
RETI4
ADDRGP4 $77
JUMPV
LABELV $82
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRLP4 0
ARGP4
ADDRGP4 trap_BotGetTopGoal
CALLI4
pop
ADDRLP4 0
ARGP4
ADDRLP4 60
ADDRGP4 trap_AAS_PointContents
CALLI4
ASGNI4
ADDRLP4 60
INDIRI4
CNSTI4 56
BANDI4
CNSTI4 0
NEI4 $85
CNSTI4 1
RETI4
ADDRGP4 $77
JUMPV
LABELV $85
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotPopGoal
CALLV
pop
LABELV $83
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 4952
ADDP4
ARGP4
ADDRFP4 4
INDIRI4
ARGI4
ADDRFP4 8
INDIRP4
ARGP4
ADDRFP4 12
INDIRF4
ARGF4
ADDRLP4 64
ADDRGP4 trap_BotChooseNBGItem
CALLI4
ASGNI4
ADDRLP4 64
INDIRI4
CNSTI4 0
NEI4 $82
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetAvoidGoals
CALLV
pop
LABELV $78
CNSTI4 0
RETI4
LABELV $77
endproc BotGoForAir 68 24
export BotNearbyGoal
proc BotNearbyGoal 28 24
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 4
INDIRI4
ARGI4
ADDRFP4 8
INDIRP4
ARGP4
ADDRFP4 12
INDIRF4
ARGF4
ADDRLP4 4
ADDRGP4 BotGoForAir
CALLI4
ASGNI4
ADDRLP4 4
INDIRI4
CNSTI4 0
EQI4 $88
CNSTI4 1
RETI4
ADDRGP4 $87
JUMPV
LABELV $88
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 8
ADDRGP4 BotCTFCarryingFlag
CALLI4
ASGNI4
ADDRLP4 8
INDIRI4
CNSTI4 0
NEI4 $93
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 12
ADDRGP4 Bot1FCTFCarryingFlag
CALLI4
ASGNI4
ADDRLP4 12
INDIRI4
CNSTI4 0
NEI4 $93
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 16
ADDRGP4 BotHarvesterCarryingCubes
CALLI4
ASGNI4
ADDRLP4 16
INDIRI4
CNSTI4 0
EQI4 $90
LABELV $93
ADDRFP4 0
INDIRP4
CNSTI4 4948
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6632
ADDP4
INDIRI4
ARGI4
CNSTI4 18616254
ARGI4
ADDRLP4 24
ADDRGP4 trap_AAS_AreaTravelTimeToGoalArea
CALLI4
ASGNI4
ADDRLP4 24
INDIRI4
CNSTI4 300
GEI4 $94
ADDRFP4 12
CNSTF4 1112014848
ASGNF4
LABELV $94
LABELV $90
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 4952
ADDP4
ARGP4
ADDRFP4 4
INDIRI4
ARGI4
ADDRFP4 8
INDIRP4
ARGP4
ADDRFP4 12
INDIRF4
ARGF4
ADDRLP4 24
ADDRGP4 trap_BotChooseNBGItem
CALLI4
ASGNI4
ADDRLP4 0
ADDRLP4 24
INDIRI4
ASGNI4
ADDRLP4 0
INDIRI4
RETI4
LABELV $87
endproc BotNearbyGoal 28 24
export BotReachedGoal
proc BotReachedGoal 40 16
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 4
ADDRFP4 4
INDIRP4
ASGNP4
ADDRFP4 4
INDIRP4
CNSTI4 48
ADDP4
INDIRI4
CNSTI4 1
BANDI4
CNSTI4 0
EQI4 $97
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRFP4 4
INDIRP4
ARGP4
ADDRLP4 0
ADDRGP4 trap_BotTouchingGoal
CALLI4
ASGNI4
ADDRLP4 0
INDIRI4
CNSTI4 0
EQI4 $99
ADDRFP4 4
INDIRP4
CNSTI4 48
ADDP4
INDIRI4
CNSTI4 4
BANDI4
CNSTI4 0
NEI4 $101
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRFP4 4
INDIRP4
CNSTI4 44
ADDP4
INDIRI4
ARGI4
CNSTF4 3212836864
ARGF4
ADDRGP4 trap_BotSetAvoidGoalTime
CALLV
pop
LABELV $101
CNSTI4 1
RETI4
ADDRGP4 $96
JUMPV
LABELV $99
ADDRFP4 0
INDIRP4
CNSTI4 12
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 4936
ADDP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6560
ADDP4
ARGP4
ADDRFP4 4
INDIRP4
ARGP4
ADDRLP4 8
ADDRGP4 trap_BotItemGoalInVisButNotVisible
CALLI4
ASGNI4
ADDRLP4 8
INDIRI4
CNSTI4 0
EQI4 $103
CNSTI4 1
RETI4
ADDRGP4 $96
JUMPV
LABELV $103
ADDRFP4 0
INDIRP4
CNSTI4 4948
ADDP4
INDIRI4
ADDRFP4 4
INDIRP4
CNSTI4 12
ADDP4
INDIRI4
NEI4 $98
ADDRLP4 12
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRF4
ASGNF4
ADDRLP4 20
ADDRFP4 4
INDIRP4
INDIRF4
ASGNF4
ADDRLP4 12
INDIRF4
ADDRLP4 20
INDIRF4
ADDRFP4 4
INDIRP4
CNSTI4 16
ADDP4
INDIRF4
ADDF4
LEF4 $98
ADDRLP4 12
INDIRF4
ADDRLP4 20
INDIRF4
ADDRFP4 4
INDIRP4
CNSTI4 28
ADDP4
INDIRF4
ADDF4
GEF4 $98
ADDRLP4 24
ADDRFP4 0
INDIRP4
CNSTI4 4912
ADDP4
INDIRF4
ASGNF4
ADDRLP4 32
ADDRFP4 4
INDIRP4
CNSTI4 4
ADDP4
INDIRF4
ASGNF4
ADDRLP4 24
INDIRF4
ADDRLP4 32
INDIRF4
ADDRFP4 4
INDIRP4
CNSTI4 20
ADDP4
INDIRF4
ADDF4
LEF4 $98
ADDRLP4 24
INDIRF4
ADDRLP4 32
INDIRF4
ADDRFP4 4
INDIRP4
CNSTI4 32
ADDP4
INDIRF4
ADDF4
GEF4 $98
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRLP4 36
ADDRGP4 trap_AAS_Swimming
CALLI4
ASGNI4
ADDRLP4 36
INDIRI4
CNSTI4 0
NEI4 $98
CNSTI4 1
RETI4
ADDRGP4 $96
JUMPV
LABELV $97
ADDRFP4 4
INDIRP4
CNSTI4 48
ADDP4
INDIRI4
CNSTI4 128
BANDI4
CNSTI4 0
EQI4 $113
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRFP4 4
INDIRP4
ARGP4
ADDRLP4 0
ADDRGP4 trap_BotTouchingGoal
CALLI4
ASGNI4
ADDRLP4 0
INDIRI4
CNSTI4 0
EQI4 $115
CNSTI4 1
RETI4
ADDRGP4 $96
JUMPV
LABELV $115
ADDRFP4 0
INDIRP4
CNSTI4 6176
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
CNSTF4 1065353216
SUBF4
LEF4 $114
CNSTI4 1
RETI4
ADDRGP4 $96
JUMPV
LABELV $113
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRFP4 4
INDIRP4
ARGP4
ADDRLP4 0
ADDRGP4 trap_BotTouchingGoal
CALLI4
ASGNI4
ADDRLP4 0
INDIRI4
CNSTI4 0
EQI4 $119
CNSTI4 1
RETI4
ADDRGP4 $96
JUMPV
LABELV $119
LABELV $114
LABELV $98
CNSTI4 0
RETI4
LABELV $96
endproc BotReachedGoal 40 16
export BotGetItemLongTermGoal
proc BotGetItemLongTermGoal 20 16
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRFP4 8
INDIRP4
ARGP4
ADDRLP4 0
ADDRGP4 trap_BotGetTopGoal
CALLI4
ASGNI4
ADDRLP4 0
INDIRI4
CNSTI4 0
NEI4 $122
ADDRFP4 0
INDIRP4
CNSTI4 6068
ADDP4
CNSTF4 0
ASGNF4
ADDRGP4 $123
JUMPV
LABELV $122
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 8
INDIRP4
ARGP4
ADDRLP4 4
ADDRGP4 BotReachedGoal
CALLI4
ASGNI4
ADDRLP4 4
INDIRI4
CNSTI4 0
EQI4 $124
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotChooseWeapon
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6068
ADDP4
CNSTF4 0
ASGNF4
LABELV $124
LABELV $123
ADDRFP4 0
INDIRP4
CNSTI4 6068
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $126
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotPopGoal
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 4952
ADDP4
ARGP4
ADDRFP4 4
INDIRI4
ARGI4
ADDRLP4 12
ADDRGP4 trap_BotChooseLTGItem
CALLI4
ASGNI4
ADDRLP4 12
INDIRI4
CNSTI4 0
EQI4 $128
ADDRFP4 0
INDIRP4
CNSTI4 6068
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1101004800
ADDF4
ASGNF4
ADDRGP4 $129
JUMPV
LABELV $128
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetAvoidGoals
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetAvoidReach
CALLV
pop
LABELV $129
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRFP4 8
INDIRP4
ARGP4
ADDRLP4 16
ADDRGP4 trap_BotGetTopGoal
CALLI4
ASGNI4
ADDRLP4 16
INDIRI4
RETI4
ADDRGP4 $121
JUMPV
LABELV $126
CNSTI4 1
RETI4
LABELV $121
endproc BotGetItemLongTermGoal 20 16
export BotGetLongTermGoal
proc BotGetLongTermGoal 672 20
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 8
ADDRFP4 8
INDIRI4
ASGNI4
ADDRFP4 12
ADDRFP4 12
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
CNSTI4 1
NEI4 $131
ADDRFP4 8
INDIRI4
CNSTI4 0
NEI4 $131
ADDRLP4 620
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
INDIRF4
ASGNF4
ADDRLP4 620
INDIRF4
CNSTF4 0
EQF4 $133
ADDRLP4 620
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $133
ADDRFP4 0
INDIRP4
CNSTI4 6600
ADDP4
INDIRI4
ARGI4
ADDRLP4 412
ARGP4
CNSTI4 36
ARGI4
ADDRLP4 624
ADDRGP4 EasyClientName
CALLP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $135
ARGP4
ADDRLP4 624
INDIRP4
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6604
ADDP4
INDIRI4
ARGI4
CNSTI4 2
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6604
ADDP4
INDIRI4
ARGI4
ADDRGP4 $136
ARGP4
ADDRGP4 BotVoiceChatOnly
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 8
ADDP4
INDIRI4
ARGI4
CNSTI4 1048576
ARGI4
ADDRGP4 trap_EA_Action
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
CNSTF4 0
ASGNF4
LABELV $133
ADDRFP4 0
INDIRP4
CNSTI4 6740
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $137
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $137
ADDRFP4 0
INDIRP4
CNSTI4 6744
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
CNSTF4 1092616192
SUBF4
GEF4 $139
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $139
ADDRFP4 0
INDIRP4
CNSTI4 6600
ADDP4
INDIRI4
ARGI4
ADDRLP4 272
ARGP4
ADDRGP4 BotEntityInfo
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 12
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 4936
ADDP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6560
ADDP4
ARGP4
CNSTF4 1135869952
ARGF4
ADDRFP4 0
INDIRP4
CNSTI4 6600
ADDP4
INDIRI4
ARGI4
ADDRLP4 628
ADDRGP4 BotEntityVisible
CALLF4
ASGNF4
ADDRLP4 628
INDIRF4
CNSTF4 0
EQF4 $141
ADDRLP4 260
ADDRLP4 272+24
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260+4
ADDRLP4 272+24+4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4912
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260+8
ADDRLP4 272+24+8
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4916
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260
ARGP4
ADDRLP4 636
ADDRGP4 VectorLengthSquared
CALLF4
ASGNF4
ADDRLP4 636
INDIRF4
CNSTF4 1176256512
GEF4 $142
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetAvoidReach
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $130
JUMPV
LABELV $141
ADDRFP4 0
INDIRP4
CNSTI4 6744
ADDP4
ADDRGP4 floattime
INDIRF4
ASGNF4
LABELV $142
ADDRLP4 272
INDIRI4
CNSTI4 0
EQI4 $152
ADDRLP4 272+24
ARGP4
ADDRLP4 632
ADDRGP4 BotPointAreaNum
CALLI4
ASGNI4
ADDRLP4 448
ADDRLP4 632
INDIRI4
ASGNI4
ADDRLP4 636
ADDRLP4 448
INDIRI4
ASGNI4
ADDRLP4 636
INDIRI4
CNSTI4 0
EQI4 $155
ADDRLP4 636
INDIRI4
ARGI4
ADDRLP4 640
ADDRGP4 trap_AAS_AreaReachability
CALLI4
ASGNI4
ADDRLP4 640
INDIRI4
CNSTI4 0
EQI4 $155
ADDRFP4 0
INDIRP4
CNSTI4 6660
ADDP4
ADDRFP4 0
INDIRP4
CNSTI4 6600
ADDP4
INDIRI4
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 6632
ADDP4
ADDRLP4 448
INDIRI4
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 6620
ADDP4
ADDRLP4 272+24
INDIRB
ASGNB 12
ADDRFP4 0
INDIRP4
CNSTI4 6636
ADDP4
CNSTF4 3238002688
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6640
ADDP4
CNSTF4 3238002688
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6644
ADDP4
CNSTF4 3238002688
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6648
ADDP4
CNSTF4 1090519040
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6652
ADDP4
CNSTF4 1090519040
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6656
ADDP4
CNSTF4 1090519040
ASGNF4
LABELV $155
LABELV $152
ADDRFP4 12
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6620
ADDP4
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
CNSTI4 1
RETI4
ADDRGP4 $130
JUMPV
LABELV $131
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
CNSTI4 2
NEI4 $158
ADDRFP4 8
INDIRI4
CNSTI4 0
NEI4 $158
ADDRLP4 620
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
INDIRF4
ASGNF4
ADDRLP4 620
INDIRF4
CNSTF4 0
EQF4 $160
ADDRLP4 620
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $160
ADDRFP4 0
INDIRP4
CNSTI4 6600
ADDP4
INDIRI4
ARGI4
ADDRLP4 412
ARGP4
CNSTI4 36
ARGI4
ADDRLP4 624
ADDRGP4 EasyClientName
CALLP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $162
ARGP4
ADDRLP4 624
INDIRP4
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6604
ADDP4
INDIRI4
ARGI4
CNSTI4 2
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6604
ADDP4
INDIRI4
ARGI4
ADDRGP4 $136
ARGP4
ADDRGP4 BotVoiceChatOnly
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 8
ADDP4
INDIRI4
ARGI4
CNSTI4 1048576
ARGI4
ADDRGP4 trap_EA_Action
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
CNSTF4 0
ASGNF4
LABELV $160
ADDRFP4 0
INDIRP4
CNSTI4 6740
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $163
ADDRFP4 0
INDIRP4
CNSTI4 6600
ADDP4
INDIRI4
ARGI4
ADDRLP4 412
ARGP4
CNSTI4 36
ARGI4
ADDRLP4 624
ADDRGP4 EasyClientName
CALLP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $165
ARGP4
ADDRLP4 624
INDIRP4
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6600
ADDP4
INDIRI4
ARGI4
CNSTI4 2
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $163
ADDRFP4 0
INDIRP4
CNSTI4 6600
ADDP4
INDIRI4
ARGI4
ADDRLP4 272
ARGP4
ADDRGP4 BotEntityInfo
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 12
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 4936
ADDP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6560
ADDP4
ARGP4
CNSTF4 1135869952
ARGF4
ADDRFP4 0
INDIRP4
CNSTI4 6600
ADDP4
INDIRI4
ARGI4
ADDRLP4 628
ADDRGP4 BotEntityVisible
CALLF4
ASGNF4
ADDRLP4 628
INDIRF4
CNSTF4 0
EQF4 $166
ADDRFP4 0
INDIRP4
CNSTI4 6744
ADDP4
ADDRGP4 floattime
INDIRF4
ASGNF4
ADDRLP4 260
ADDRLP4 272+24
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260+4
ADDRLP4 272+24+4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4912
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260+8
ADDRLP4 272+24+8
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4916
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260
ARGP4
ADDRLP4 636
ADDRGP4 VectorLengthSquared
CALLF4
ASGNF4
ADDRLP4 640
ADDRFP4 0
INDIRP4
CNSTI4 7008
ADDP4
INDIRF4
ASGNF4
ADDRLP4 636
INDIRF4
ADDRLP4 640
INDIRF4
ADDRLP4 640
INDIRF4
MULF4
GEF4 $175
ADDRFP4 0
INDIRP4
CNSTI4 12
ADDP4
INDIRI4
ARGI4
ADDRLP4 452
ARGP4
ADDRGP4 BotEntityInfo
CALLV
pop
ADDRLP4 452+24+8
INDIRF4
ADDRLP4 452+84+8
INDIRF4
ADDF4
ADDRLP4 272+24+8
INDIRF4
ADDRLP4 272+72+8
INDIRF4
ADDF4
LEF4 $177
ADDRLP4 644
CNSTF4 1082130432
ASGNF4
ADDRLP4 452+24
INDIRF4
ADDRLP4 452+84
INDIRF4
ADDF4
ADDRLP4 272+24
INDIRF4
ADDRLP4 272+72
INDIRF4
ADDF4
ADDRLP4 644
INDIRF4
SUBF4
LEF4 $187
ADDRLP4 452+24
INDIRF4
ADDRLP4 452+72
INDIRF4
ADDF4
ADDRLP4 272+24
INDIRF4
ADDRLP4 272+84
INDIRF4
ADDF4
ADDRLP4 644
INDIRF4
ADDF4
GEF4 $187
ADDRLP4 648
CNSTF4 1082130432
ASGNF4
ADDRLP4 452+24+4
INDIRF4
ADDRLP4 452+84+4
INDIRF4
ADDF4
ADDRLP4 272+24+4
INDIRF4
ADDRLP4 272+72+4
INDIRF4
ADDF4
ADDRLP4 648
INDIRF4
SUBF4
LEF4 $197
ADDRLP4 452+24+4
INDIRF4
ADDRLP4 452+72+4
INDIRF4
ADDF4
ADDRLP4 272+24+4
INDIRF4
ADDRLP4 272+84+4
INDIRF4
ADDF4
ADDRLP4 648
INDIRF4
ADDF4
GEF4 $197
ADDRLP4 652
CNSTF4 1082130432
ASGNF4
ADDRLP4 452+24+8
INDIRF4
ADDRLP4 452+84+8
INDIRF4
ADDF4
ADDRLP4 272+24+8
INDIRF4
ADDRLP4 272+72+8
INDIRF4
ADDF4
ADDRLP4 652
INDIRF4
SUBF4
LEF4 $215
ADDRLP4 452+24+8
INDIRF4
ADDRLP4 452+72+8
INDIRF4
ADDF4
ADDRLP4 272+24+8
INDIRF4
ADDRLP4 272+84+8
INDIRF4
ADDF4
ADDRLP4 652
INDIRF4
ADDF4
GEF4 $215
ADDRLP4 272+36
ARGP4
ADDRLP4 260
ARGP4
ADDRLP4 656
CNSTP4 0
ASGNP4
ADDRLP4 656
INDIRP4
ARGP4
ADDRLP4 656
INDIRP4
ARGP4
ADDRGP4 AngleVectors
CALLV
pop
ADDRLP4 260+8
CNSTF4 0
ASGNF4
ADDRLP4 260
ARGP4
ADDRGP4 VectorNormalize
CALLF4
pop
ADDRLP4 608
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRF4
ADDRLP4 272+24
INDIRF4
SUBF4
ASGNF4
ADDRLP4 608+4
ADDRFP4 0
INDIRP4
CNSTI4 4912
ADDP4
INDIRF4
ADDRLP4 272+24+4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 608+8
ADDRFP4 0
INDIRP4
CNSTI4 4916
ADDP4
INDIRF4
ADDRLP4 272+24+8
INDIRF4
SUBF4
ASGNF4
ADDRLP4 608
ARGP4
ADDRGP4 VectorNormalize
CALLF4
pop
ADDRLP4 260
INDIRF4
ADDRLP4 608
INDIRF4
MULF4
ADDRLP4 260+4
INDIRF4
ADDRLP4 608+4
INDIRF4
MULF4
ADDF4
ADDRLP4 260+8
INDIRF4
ADDRLP4 608+8
INDIRF4
MULF4
ADDF4
CNSTF4 1060320051
LEF4 $242
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotSetupForMovement
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRLP4 608
ARGP4
CNSTF4 1137180672
ARGF4
CNSTI4 1
ARGI4
ADDRGP4 trap_BotMoveInDirection
CALLI4
pop
LABELV $242
LABELV $215
LABELV $197
LABELV $187
LABELV $177
ADDRFP4 0
INDIRP4
CNSTI4 6120
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
CNSTF4 1084227584
SUBF4
GEF4 $248
ADDRFP4 0
INDIRP4
CNSTI4 6516
ADDP4
INDIRI4
ARGI4
CNSTI4 36
ARGI4
CNSTF4 0
ARGF4
CNSTF4 1065353216
ARGF4
ADDRLP4 644
ADDRGP4 trap_Characteristic_BFloat
CALLF4
ASGNF4
ADDRLP4 604
ADDRLP4 644
INDIRF4
ASGNF4
ADDRLP4 648
ADDRGP4 qk_rand
CALLI4
ASGNI4
ADDRLP4 648
INDIRI4
CNSTI4 32767
BANDI4
CVIF4 4
CNSTF4 1191181824
DIVF4
ADDRFP4 0
INDIRP4
CNSTI4 4904
ADDP4
INDIRF4
ADDRLP4 604
INDIRF4
MULF4
GEF4 $250
ADDRFP4 0
INDIRP4
CNSTI4 6120
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1084227584
ADDF4
CNSTF4 1097859072
ADDRLP4 604
INDIRF4
MULF4
ADDF4
ASGNF4
LABELV $250
LABELV $248
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRLP4 644
ADDRGP4 trap_AAS_Swimming
CALLI4
ASGNI4
ADDRLP4 644
INDIRI4
CNSTI4 0
EQI4 $252
ADDRFP4 0
INDIRP4
CNSTI4 6120
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1065353216
SUBF4
ASGNF4
LABELV $252
ADDRFP4 0
INDIRP4
CNSTI4 6172
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
CNSTF4 1073741824
SUBF4
GEF4 $254
ADDRFP4 0
INDIRP4
CNSTI4 6172
ADDP4
INDIRF4
CNSTF4 0
NEF4 $256
ADDRFP4 0
INDIRP4
CNSTI4 8
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_EA_Gesture
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6600
ADDP4
INDIRI4
ARGI4
ADDRLP4 412
ARGP4
CNSTI4 36
ARGI4
ADDRLP4 648
ADDRGP4 EasyClientName
CALLP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $258
ARGP4
ADDRLP4 648
INDIRP4
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6600
ADDP4
INDIRI4
ARGI4
CNSTI4 2
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6172
ADDP4
ADDRGP4 floattime
INDIRF4
ASGNF4
ADDRGP4 $257
JUMPV
LABELV $256
ADDRFP4 0
INDIRP4
CNSTI4 6120
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
LEF4 $259
ADDRFP4 0
INDIRP4
CNSTI4 8
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_EA_Crouch
CALLV
pop
ADDRGP4 $260
JUMPV
LABELV $259
ADDRLP4 648
ADDRGP4 qk_rand
CALLI4
ASGNI4
ADDRLP4 648
INDIRI4
CNSTI4 32767
BANDI4
CVIF4 4
CNSTF4 1191181824
DIVF4
CNSTF4 1028443341
ADDRFP4 0
INDIRP4
CNSTI4 4904
ADDP4
INDIRF4
MULF4
GEF4 $261
ADDRFP4 0
INDIRP4
CNSTI4 8
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_EA_Gesture
CALLV
pop
LABELV $261
LABELV $260
LABELV $257
LABELV $254
ADDRFP4 0
INDIRP4
CNSTI4 6172
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
CNSTF4 1073741824
SUBF4
LEF4 $263
ADDRLP4 260
ADDRLP4 272+24
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260+4
ADDRLP4 272+24+4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4912
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260+8
ADDRLP4 272+24+8
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4916
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ARGP4
ADDRGP4 vectoangles
CALLV
pop
ADDRLP4 652
ADDRFP4 0
INDIRP4
CNSTI4 6580
ADDP4
ASGNP4
ADDRLP4 652
INDIRP4
CNSTF4 1056964608
ADDRLP4 652
INDIRP4
INDIRF4
MULF4
ASGNF4
ADDRGP4 $264
JUMPV
LABELV $263
ADDRLP4 648
ADDRGP4 qk_rand
CALLI4
ASGNI4
ADDRLP4 648
INDIRI4
CNSTI4 32767
BANDI4
CVIF4 4
CNSTF4 1191181824
DIVF4
CNSTF4 1061997773
ADDRFP4 0
INDIRP4
CNSTI4 4904
ADDP4
INDIRF4
MULF4
GEF4 $272
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 592
ARGP4
ADDRGP4 BotRoamGoal
CALLV
pop
ADDRLP4 260
ADDRLP4 592
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260+4
ADDRLP4 592+4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4912
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260+8
ADDRLP4 592+8
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4916
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ARGP4
ADDRGP4 vectoangles
CALLV
pop
ADDRLP4 656
ADDRFP4 0
INDIRP4
CNSTI4 6580
ADDP4
ASGNP4
ADDRLP4 656
INDIRP4
CNSTF4 1056964608
ADDRLP4 656
INDIRP4
INDIRF4
MULF4
ASGNF4
LABELV $272
LABELV $264
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6620
ADDP4
ARGP4
CNSTF4 1137180672
ARGF4
ADDRLP4 656
ADDRGP4 BotGoForAir
CALLI4
ASGNI4
ADDRLP4 656
INDIRI4
CNSTI4 0
EQI4 $278
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetLastAvoidReach
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6072
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1090519040
ADDF4
ASGNF4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $280
ARGP4
ADDRGP4 AIEnter_Seek_NBG
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $130
JUMPV
LABELV $278
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetAvoidReach
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $130
JUMPV
LABELV $175
LABELV $166
ADDRLP4 272
INDIRI4
CNSTI4 0
EQI4 $281
ADDRLP4 272+24
ARGP4
ADDRLP4 632
ADDRGP4 BotPointAreaNum
CALLI4
ASGNI4
ADDRLP4 448
ADDRLP4 632
INDIRI4
ASGNI4
ADDRLP4 636
ADDRLP4 448
INDIRI4
ASGNI4
ADDRLP4 636
INDIRI4
CNSTI4 0
EQI4 $284
ADDRLP4 636
INDIRI4
ARGI4
ADDRLP4 640
ADDRGP4 trap_AAS_AreaReachability
CALLI4
ASGNI4
ADDRLP4 640
INDIRI4
CNSTI4 0
EQI4 $284
ADDRFP4 0
INDIRP4
CNSTI4 6660
ADDP4
ADDRFP4 0
INDIRP4
CNSTI4 6600
ADDP4
INDIRI4
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 6632
ADDP4
ADDRLP4 448
INDIRI4
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 6620
ADDP4
ADDRLP4 272+24
INDIRB
ASGNB 12
ADDRFP4 0
INDIRP4
CNSTI4 6636
ADDP4
CNSTF4 3238002688
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6640
ADDP4
CNSTF4 3238002688
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6644
ADDP4
CNSTF4 3238002688
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6648
ADDP4
CNSTF4 1090519040
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6652
ADDP4
CNSTF4 1090519040
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6656
ADDP4
CNSTF4 1090519040
ASGNF4
LABELV $284
LABELV $281
ADDRFP4 12
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6620
ADDP4
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
ADDRFP4 0
INDIRP4
CNSTI4 6744
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
CNSTF4 1114636288
SUBF4
GEF4 $287
ADDRFP4 0
INDIRP4
CNSTI4 6600
ADDP4
INDIRI4
ARGI4
ADDRLP4 412
ARGP4
CNSTI4 36
ARGI4
ADDRLP4 632
ADDRGP4 EasyClientName
CALLP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $289
ARGP4
ADDRLP4 632
INDIRP4
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6600
ADDP4
INDIRI4
ARGI4
CNSTI4 2
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 6744
ADDP4
ADDRGP4 floattime
INDIRF4
ASGNF4
LABELV $287
CNSTI4 1
RETI4
ADDRGP4 $130
JUMPV
LABELV $158
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
CNSTI4 3
NEI4 $290
ADDRFP4 0
INDIRP4
CNSTI4 4948
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6632
ADDP4
INDIRI4
ARGI4
CNSTI4 18616254
ARGI4
ADDRLP4 624
ADDRGP4 trap_AAS_AreaTravelTimeToGoalArea
CALLI4
ASGNI4
ADDRLP4 624
INDIRI4
CVIF4 4
ADDRFP4 0
INDIRP4
CNSTI4 6148
ADDP4
INDIRF4
LEF4 $292
ADDRFP4 0
INDIRP4
CNSTI4 6144
ADDP4
CNSTF4 0
ASGNF4
LABELV $292
LABELV $290
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
CNSTI4 3
NEI4 $294
ADDRFP4 8
INDIRI4
CNSTI4 0
NEI4 $294
ADDRFP4 0
INDIRP4
CNSTI4 6144
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $294
ADDRLP4 624
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
INDIRF4
ASGNF4
ADDRLP4 624
INDIRF4
CNSTF4 0
EQF4 $296
ADDRLP4 624
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $296
ADDRFP4 0
INDIRP4
CNSTI4 6664
ADDP4
INDIRI4
ARGI4
ADDRLP4 4
ARGP4
CNSTI4 256
ARGI4
ADDRGP4 trap_BotGoalName
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $298
ARGP4
ADDRLP4 4
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
CNSTI4 0
ARGI4
CNSTI4 1
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
CNSTI4 -1
ARGI4
ADDRGP4 $299
ARGP4
ADDRGP4 BotVoiceChatOnly
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
CNSTF4 0
ASGNF4
LABELV $296
ADDRFP4 12
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6620
ADDP4
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
ADDRFP4 0
INDIRP4
CNSTI4 6740
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $300
ADDRFP4 0
INDIRP4
CNSTI4 6664
ADDP4
INDIRI4
ARGI4
ADDRLP4 4
ARGP4
CNSTI4 256
ARGI4
ADDRGP4 trap_BotGoalName
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $302
ARGP4
ADDRLP4 4
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
CNSTI4 0
ARGI4
CNSTI4 1
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $300
ADDRLP4 260
ADDRFP4 12
INDIRP4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260+4
ADDRFP4 12
INDIRP4
CNSTI4 4
ADDP4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4912
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260+8
ADDRFP4 12
INDIRP4
CNSTI4 8
ADDP4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4916
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260
ARGP4
ADDRLP4 636
ADDRGP4 VectorLengthSquared
CALLF4
ASGNF4
ADDRLP4 636
INDIRF4
CNSTF4 1167663104
GEF4 $305
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetAvoidReach
CALLV
pop
ADDRLP4 640
ADDRGP4 qk_rand
CALLI4
ASGNI4
ADDRLP4 644
CNSTF4 1077936128
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6144
ADDP4
ADDRGP4 floattime
INDIRF4
ADDRLP4 644
INDIRF4
ADDF4
ADDRLP4 644
INDIRF4
ADDRLP4 640
INDIRI4
CNSTI4 32767
BANDI4
CVIF4 4
CNSTF4 1191181824
DIVF4
MULF4
ADDF4
ASGNF4
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 648
ADDRGP4 BotHasPersistantPowerupAndWeapon
CALLI4
ASGNI4
ADDRLP4 648
INDIRI4
CNSTI4 0
EQI4 $307
ADDRFP4 0
INDIRP4
CNSTI4 6148
ADDP4
CNSTF4 1120403456
ASGNF4
ADDRGP4 $308
JUMPV
LABELV $307
ADDRFP4 0
INDIRP4
CNSTI4 6148
ADDP4
CNSTF4 1135542272
ASGNF4
LABELV $308
LABELV $305
CNSTI4 1
RETI4
ADDRGP4 $130
JUMPV
LABELV $294
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
CNSTI4 11
NEI4 $309
ADDRFP4 8
INDIRI4
CNSTI4 0
NEI4 $309
ADDRLP4 624
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
INDIRF4
ASGNF4
ADDRLP4 624
INDIRF4
CNSTF4 0
EQF4 $311
ADDRLP4 624
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $311
ADDRFP4 0
INDIRP4
CNSTI4 6660
ADDP4
INDIRI4
ARGI4
ADDRLP4 4
ARGP4
CNSTI4 256
ARGI4
ADDRGP4 EasyClientName
CALLP4
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $313
ARGP4
ADDRLP4 4
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6604
ADDP4
INDIRI4
ARGI4
CNSTI4 2
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
CNSTF4 0
ASGNF4
LABELV $311
ADDRFP4 0
INDIRP4
CNSTI4 5992
ADDP4
INDIRI4
ADDRFP4 0
INDIRP4
CNSTI4 6660
ADDP4
INDIRI4
NEI4 $314
ADDRFP4 0
INDIRP4
CNSTI4 6660
ADDP4
INDIRI4
ARGI4
ADDRLP4 4
ARGP4
CNSTI4 256
ARGI4
ADDRGP4 EasyClientName
CALLP4
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $316
ARGP4
ADDRLP4 4
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6604
ADDP4
INDIRI4
ARGI4
CNSTI4 2
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 5992
ADDP4
CNSTI4 -1
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $314
ADDRFP4 0
INDIRP4
CNSTI4 6740
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $317
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $317
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 4
INDIRI4
ARGI4
ADDRFP4 12
INDIRP4
ARGP4
ADDRLP4 632
ADDRGP4 BotGetItemLongTermGoal
CALLI4
ASGNI4
ADDRLP4 632
INDIRI4
RETI4
ADDRGP4 $130
JUMPV
LABELV $309
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
CNSTI4 10
NEI4 $319
ADDRFP4 8
INDIRI4
CNSTI4 0
NEI4 $319
ADDRLP4 624
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
INDIRF4
ASGNF4
ADDRLP4 624
INDIRF4
CNSTF4 0
EQF4 $321
ADDRLP4 624
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $321
ADDRFP4 0
INDIRP4
CNSTI4 6664
ADDP4
INDIRI4
ARGI4
ADDRLP4 4
ARGP4
CNSTI4 256
ARGI4
ADDRGP4 trap_BotGoalName
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $323
ARGP4
ADDRLP4 4
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6604
ADDP4
INDIRI4
ARGI4
CNSTI4 2
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6604
ADDP4
INDIRI4
ARGI4
ADDRGP4 $136
ARGP4
ADDRGP4 BotVoiceChatOnly
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 8
ADDP4
INDIRI4
ARGI4
CNSTI4 1048576
ARGI4
ADDRGP4 trap_EA_Action
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
CNSTF4 0
ASGNF4
LABELV $321
ADDRFP4 12
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6620
ADDP4
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
ADDRFP4 0
INDIRP4
CNSTI4 6740
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $324
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $324
ADDRFP4 0
INDIRP4
CNSTI4 12
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 4936
ADDP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6560
ADDP4
ARGP4
ADDRFP4 12
INDIRP4
ARGP4
ADDRLP4 632
ADDRGP4 trap_BotItemGoalInVisButNotVisible
CALLI4
ASGNI4
ADDRLP4 632
INDIRI4
CNSTI4 0
EQI4 $326
ADDRFP4 0
INDIRP4
CNSTI4 6664
ADDP4
INDIRI4
ARGI4
ADDRLP4 4
ARGP4
CNSTI4 256
ARGI4
ADDRGP4 trap_BotGoalName
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $328
ARGP4
ADDRLP4 4
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6604
ADDP4
INDIRI4
ARGI4
CNSTI4 2
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
ADDRGP4 $327
JUMPV
LABELV $326
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 12
INDIRP4
ARGP4
ADDRLP4 636
ADDRGP4 BotReachedGoal
CALLI4
ASGNI4
ADDRLP4 636
INDIRI4
CNSTI4 0
EQI4 $329
ADDRFP4 0
INDIRP4
CNSTI4 6664
ADDP4
INDIRI4
ARGI4
ADDRLP4 4
ARGP4
CNSTI4 256
ARGI4
ADDRGP4 trap_BotGoalName
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $331
ARGP4
ADDRLP4 4
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6604
ADDP4
INDIRI4
ARGI4
CNSTI4 2
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $329
LABELV $327
CNSTI4 1
RETI4
ADDRGP4 $130
JUMPV
LABELV $319
ADDRLP4 624
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
ASGNI4
ADDRLP4 624
INDIRI4
CNSTI4 7
EQI4 $334
ADDRLP4 624
INDIRI4
CNSTI4 8
NEI4 $332
LABELV $334
ADDRFP4 8
INDIRI4
CNSTI4 0
NEI4 $332
ADDRLP4 628
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
INDIRF4
ASGNF4
ADDRLP4 628
INDIRF4
CNSTF4 0
EQF4 $335
ADDRLP4 628
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $335
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
CNSTI4 8
NEI4 $337
ADDRFP4 0
INDIRP4
CNSTI4 6600
ADDP4
INDIRI4
ARGI4
ADDRLP4 412
ARGP4
CNSTI4 36
ARGI4
ADDRLP4 632
ADDRGP4 EasyClientName
CALLP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $339
ARGP4
ADDRLP4 632
INDIRP4
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6604
ADDP4
INDIRI4
ARGI4
CNSTI4 2
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6604
ADDP4
INDIRI4
ARGI4
ADDRGP4 $136
ARGP4
ADDRGP4 BotVoiceChatOnly
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 8
ADDP4
INDIRI4
ARGI4
CNSTI4 1048576
ARGI4
ADDRGP4 trap_EA_Action
CALLV
pop
LABELV $337
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
CNSTF4 0
ASGNF4
LABELV $335
ADDRFP4 12
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6620
ADDP4
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
ADDRFP4 0
INDIRP4
CNSTI4 6740
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $340
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
CNSTI4 8
NEI4 $342
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $344
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6604
ADDP4
INDIRI4
ARGI4
CNSTI4 2
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
LABELV $342
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $340
ADDRLP4 260
ADDRFP4 12
INDIRP4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260+4
ADDRFP4 12
INDIRP4
CNSTI4 4
ADDP4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4912
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260+8
ADDRFP4 12
INDIRP4
CNSTI4 8
ADDP4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4916
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260
ARGP4
ADDRLP4 640
ADDRGP4 VectorLengthSquared
CALLF4
ASGNF4
ADDRLP4 640
INDIRF4
CNSTF4 1163984896
GEF4 $347
ADDRFP4 0
INDIRP4
CNSTI4 6172
ADDP4
INDIRF4
CNSTF4 0
NEF4 $349
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
CNSTI4 8
NEI4 $351
ADDRFP4 0
INDIRP4
CNSTI4 6600
ADDP4
INDIRI4
ARGI4
ADDRLP4 412
ARGP4
CNSTI4 36
ARGI4
ADDRLP4 644
ADDRGP4 EasyClientName
CALLP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $353
ARGP4
ADDRLP4 644
INDIRP4
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6604
ADDP4
INDIRI4
ARGI4
CNSTI4 2
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6604
ADDP4
INDIRI4
ARGI4
ADDRGP4 $354
ARGP4
ADDRGP4 BotVoiceChatOnly
CALLV
pop
LABELV $351
ADDRFP4 0
INDIRP4
CNSTI4 6172
ADDP4
ADDRGP4 floattime
INDIRF4
ASGNF4
LABELV $349
ADDRLP4 644
ADDRGP4 qk_rand
CALLI4
ASGNI4
ADDRLP4 644
INDIRI4
CNSTI4 32767
BANDI4
CVIF4 4
CNSTF4 1191181824
DIVF4
CNSTF4 1061997773
ADDRFP4 0
INDIRP4
CNSTI4 4904
ADDP4
INDIRF4
MULF4
GEF4 $355
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 592
ARGP4
ADDRGP4 BotRoamGoal
CALLV
pop
ADDRLP4 260
ADDRLP4 592
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260+4
ADDRLP4 592+4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4912
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260+8
ADDRLP4 592+8
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4916
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ARGP4
ADDRGP4 vectoangles
CALLV
pop
ADDRLP4 652
ADDRFP4 0
INDIRP4
CNSTI4 6580
ADDP4
ASGNP4
ADDRLP4 652
INDIRP4
CNSTF4 1056964608
ADDRLP4 652
INDIRP4
INDIRF4
MULF4
ASGNF4
LABELV $355
ADDRFP4 0
INDIRP4
CNSTI4 6120
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
CNSTF4 1084227584
SUBF4
GEF4 $361
ADDRFP4 0
INDIRP4
CNSTI4 6516
ADDP4
INDIRI4
ARGI4
CNSTI4 36
ARGI4
CNSTF4 0
ARGF4
CNSTF4 1065353216
ARGF4
ADDRLP4 648
ADDRGP4 trap_Characteristic_BFloat
CALLF4
ASGNF4
ADDRLP4 604
ADDRLP4 648
INDIRF4
ASGNF4
ADDRLP4 652
ADDRGP4 qk_rand
CALLI4
ASGNI4
ADDRLP4 652
INDIRI4
CNSTI4 32767
BANDI4
CVIF4 4
CNSTF4 1191181824
DIVF4
ADDRFP4 0
INDIRP4
CNSTI4 4904
ADDP4
INDIRF4
ADDRLP4 604
INDIRF4
MULF4
GEF4 $363
ADDRFP4 0
INDIRP4
CNSTI4 6120
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1084227584
ADDF4
CNSTF4 1097859072
ADDRLP4 604
INDIRF4
MULF4
ADDF4
ASGNF4
LABELV $363
LABELV $361
ADDRFP4 0
INDIRP4
CNSTI4 6120
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
LEF4 $365
ADDRFP4 0
INDIRP4
CNSTI4 8
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_EA_Crouch
CALLV
pop
LABELV $365
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRLP4 648
ADDRGP4 trap_AAS_Swimming
CALLI4
ASGNI4
ADDRLP4 648
INDIRI4
CNSTI4 0
EQI4 $367
ADDRFP4 0
INDIRP4
CNSTI4 6120
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1065353216
SUBF4
ASGNF4
LABELV $367
ADDRFP4 0
INDIRP4
CNSTI4 4936
ADDP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 12
ADDP4
INDIRI4
ARGI4
ADDRLP4 656
ADDRGP4 trap_PointContents
CALLI4
ASGNI4
ADDRLP4 656
INDIRI4
CNSTI4 56
BANDI4
CNSTI4 0
EQI4 $369
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
CNSTI4 8
NEI4 $371
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $344
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6604
ADDP4
INDIRI4
ARGI4
CNSTI4 2
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6756
ADDP4
INDIRI4
CNSTI4 8
NEI4 $373
ADDRFP4 0
INDIRP4
CNSTI4 6756
ADDP4
CNSTI4 0
ASGNI4
LABELV $373
LABELV $371
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $369
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetAvoidReach
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $130
JUMPV
LABELV $347
CNSTI4 1
RETI4
ADDRGP4 $130
JUMPV
LABELV $332
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
CNSTI4 9
NEI4 $375
ADDRFP4 8
INDIRI4
CNSTI4 0
NEI4 $375
ADDRLP4 628
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
INDIRF4
ASGNF4
ADDRLP4 628
INDIRF4
CNSTF4 0
EQF4 $377
ADDRLP4 628
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $377
ADDRLP4 4
ARGP4
ADDRGP4 $62
ARGP4
ADDRGP4 qk_strcpy
CALLP4
pop
ADDRLP4 0
ADDRFP4 0
INDIRP4
CNSTI4 8972
ADDP4
INDIRP4
ASGNP4
ADDRGP4 $382
JUMPV
LABELV $379
ADDRLP4 4
ARGP4
ADDRLP4 0
INDIRP4
CNSTI4 4
ADDP4
ARGP4
ADDRGP4 qk_strcat
CALLP4
pop
ADDRLP4 0
INDIRP4
CNSTI4 92
ADDP4
INDIRP4
CVPU4 4
CNSTU4 0
EQU4 $383
ADDRLP4 4
ARGP4
ADDRGP4 $385
ARGP4
ADDRGP4 qk_strcat
CALLP4
pop
LABELV $383
LABELV $380
ADDRLP4 0
ADDRLP4 0
INDIRP4
CNSTI4 92
ADDP4
INDIRP4
ASGNP4
LABELV $382
ADDRLP4 0
INDIRP4
CVPU4 4
CNSTU4 0
NEU4 $379
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $386
ARGP4
ADDRLP4 4
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6604
ADDP4
INDIRI4
ARGI4
CNSTI4 2
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6604
ADDP4
INDIRI4
ARGI4
ADDRGP4 $136
ARGP4
ADDRGP4 BotVoiceChatOnly
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 8
ADDP4
INDIRI4
ARGI4
CNSTI4 1048576
ARGI4
ADDRGP4 trap_EA_Action
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
CNSTF4 0
ASGNF4
LABELV $377
ADDRFP4 0
INDIRP4
CNSTI4 8976
ADDP4
INDIRP4
CVPU4 4
CNSTU4 0
NEU4 $387
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
CNSTI4 0
RETI4
ADDRGP4 $130
JUMPV
LABELV $387
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 8976
ADDP4
INDIRP4
CNSTI4 36
ADDP4
ARGP4
ADDRLP4 636
ADDRGP4 trap_BotTouchingGoal
CALLI4
ASGNI4
ADDRLP4 636
INDIRI4
CNSTI4 0
EQI4 $389
ADDRFP4 0
INDIRP4
CNSTI4 8980
ADDP4
INDIRI4
CNSTI4 4
BANDI4
CNSTI4 0
EQI4 $391
ADDRFP4 0
INDIRP4
CNSTI4 8976
ADDP4
INDIRP4
CNSTI4 96
ADDP4
INDIRP4
CVPU4 4
CNSTU4 0
EQU4 $393
ADDRLP4 640
ADDRFP4 0
INDIRP4
CNSTI4 8976
ADDP4
ASGNP4
ADDRLP4 640
INDIRP4
ADDRLP4 640
INDIRP4
INDIRP4
CNSTI4 96
ADDP4
INDIRP4
ASGNP4
ADDRGP4 $392
JUMPV
LABELV $393
ADDRLP4 640
ADDRFP4 0
INDIRP4
CNSTI4 8976
ADDP4
ASGNP4
ADDRLP4 640
INDIRP4
ADDRLP4 640
INDIRP4
INDIRP4
CNSTI4 92
ADDP4
INDIRP4
ASGNP4
ADDRLP4 644
ADDRFP4 0
INDIRP4
CNSTI4 8980
ADDP4
ASGNP4
ADDRLP4 644
INDIRP4
ADDRLP4 644
INDIRP4
INDIRI4
CNSTI4 -5
BANDI4
ASGNI4
ADDRGP4 $392
JUMPV
LABELV $391
ADDRFP4 0
INDIRP4
CNSTI4 8976
ADDP4
INDIRP4
CNSTI4 92
ADDP4
INDIRP4
CVPU4 4
CNSTU4 0
EQU4 $395
ADDRLP4 640
ADDRFP4 0
INDIRP4
CNSTI4 8976
ADDP4
ASGNP4
ADDRLP4 640
INDIRP4
ADDRLP4 640
INDIRP4
INDIRP4
CNSTI4 92
ADDP4
INDIRP4
ASGNP4
ADDRGP4 $396
JUMPV
LABELV $395
ADDRLP4 640
ADDRFP4 0
INDIRP4
CNSTI4 8976
ADDP4
ASGNP4
ADDRLP4 640
INDIRP4
ADDRLP4 640
INDIRP4
INDIRP4
CNSTI4 96
ADDP4
INDIRP4
ASGNP4
ADDRLP4 644
ADDRFP4 0
INDIRP4
CNSTI4 8980
ADDP4
ASGNP4
ADDRLP4 644
INDIRP4
ADDRLP4 644
INDIRP4
INDIRI4
CNSTI4 4
BORI4
ASGNI4
LABELV $396
LABELV $392
LABELV $389
ADDRFP4 0
INDIRP4
CNSTI4 6740
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $397
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $399
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6604
ADDP4
INDIRI4
ARGI4
CNSTI4 2
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $397
ADDRFP4 0
INDIRP4
CNSTI4 8976
ADDP4
INDIRP4
CVPU4 4
CNSTU4 0
NEU4 $400
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
CNSTI4 0
RETI4
ADDRGP4 $130
JUMPV
LABELV $400
ADDRFP4 12
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 8976
ADDP4
INDIRP4
CNSTI4 36
ADDP4
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
CNSTI4 1
RETI4
ADDRGP4 $130
JUMPV
LABELV $375
ADDRGP4 gametype
INDIRI4
CNSTI4 4
NEI4 $402
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
CNSTI4 4
NEI4 $404
ADDRLP4 628
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
INDIRF4
ASGNF4
ADDRLP4 628
INDIRF4
CNSTF4 0
EQF4 $406
ADDRLP4 628
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $406
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $408
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
CNSTI4 0
ARGI4
CNSTI4 1
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
CNSTI4 -1
ARGI4
ADDRGP4 $409
ARGP4
ADDRGP4 BotVoiceChatOnly
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
CNSTF4 0
ASGNF4
LABELV $406
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 636
ADDRGP4 BotTeam
CALLI4
ASGNI4
ADDRLP4 632
ADDRLP4 636
INDIRI4
ASGNI4
ADDRLP4 632
INDIRI4
CNSTI4 1
EQI4 $413
ADDRLP4 632
INDIRI4
CNSTI4 2
EQI4 $414
ADDRGP4 $410
JUMPV
LABELV $413
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 ctf_blueflag
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
ADDRGP4 $411
JUMPV
LABELV $414
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 ctf_redflag
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
ADDRGP4 $411
JUMPV
LABELV $410
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
CNSTI4 0
RETI4
ADDRGP4 $130
JUMPV
LABELV $411
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRFP4 12
INDIRP4
ARGP4
ADDRLP4 644
ADDRGP4 trap_BotTouchingGoal
CALLI4
ASGNI4
ADDRLP4 644
INDIRI4
CNSTI4 0
EQI4 $415
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 652
ADDRGP4 BotTeam
CALLI4
ASGNI4
ADDRLP4 648
ADDRLP4 652
INDIRI4
ASGNI4
ADDRLP4 648
INDIRI4
CNSTI4 1
EQI4 $420
ADDRLP4 648
INDIRI4
CNSTI4 2
EQI4 $421
ADDRGP4 $417
JUMPV
LABELV $420
ADDRFP4 0
INDIRP4
CNSTI4 6952
ADDP4
CNSTI4 1
ASGNI4
ADDRGP4 $418
JUMPV
LABELV $421
ADDRFP4 0
INDIRP4
CNSTI4 6948
ADDP4
CNSTI4 1
ASGNI4
LABELV $417
LABELV $418
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $415
ADDRFP4 0
INDIRP4
CNSTI4 6740
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $422
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $422
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 BotAlternateRoute
CALLP4
pop
CNSTI4 1
RETI4
ADDRGP4 $130
JUMPV
LABELV $404
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
CNSTI4 5
NEI4 $424
ADDRFP4 0
INDIRP4
CNSTI4 6152
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $424
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 636
ADDRGP4 BotTeam
CALLI4
ASGNI4
ADDRLP4 632
ADDRLP4 636
INDIRI4
ASGNI4
ADDRLP4 632
INDIRI4
CNSTI4 1
EQI4 $429
ADDRLP4 632
INDIRI4
CNSTI4 2
EQI4 $430
ADDRGP4 $426
JUMPV
LABELV $429
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 ctf_redflag
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
ADDRGP4 $427
JUMPV
LABELV $430
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 ctf_blueflag
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
ADDRGP4 $427
JUMPV
LABELV $426
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
CNSTI4 0
RETI4
ADDRGP4 $130
JUMPV
LABELV $427
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 644
ADDRGP4 BotCTFCarryingFlag
CALLI4
ASGNI4
ADDRLP4 644
INDIRI4
CNSTI4 0
NEI4 $431
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $431
ADDRFP4 0
INDIRP4
CNSTI4 6740
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $433
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $433
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRFP4 12
INDIRP4
ARGP4
ADDRLP4 648
ADDRGP4 trap_BotTouchingGoal
CALLI4
ASGNI4
ADDRLP4 648
INDIRI4
CNSTI4 0
EQI4 $435
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 652
ADDRGP4 BotCTFCarryingFlag
CALLI4
ASGNI4
ADDRLP4 652
INDIRI4
CNSTI4 0
EQI4 $437
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetAvoidReach
CALLV
pop
ADDRLP4 656
ADDRGP4 qk_rand
CALLI4
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 6152
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1084227584
ADDF4
CNSTF4 1092616192
ADDRLP4 656
INDIRI4
CNSTI4 32767
BANDI4
CVIF4 4
CNSTF4 1191181824
DIVF4
MULF4
ADDF4
ASGNF4
ADDRGP4 $438
JUMPV
LABELV $437
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $438
LABELV $435
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 BotAlternateRoute
CALLP4
pop
CNSTI4 1
RETI4
ADDRGP4 $130
JUMPV
LABELV $424
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
CNSTI4 6
NEI4 $403
ADDRLP4 632
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
INDIRF4
ASGNF4
ADDRLP4 632
INDIRF4
CNSTF4 0
EQF4 $441
ADDRLP4 632
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $441
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $443
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
CNSTI4 0
ARGI4
CNSTI4 1
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
CNSTI4 -1
ARGI4
ADDRGP4 $444
ARGP4
ADDRGP4 BotVoiceChatOnly
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
CNSTF4 0
ASGNF4
LABELV $441
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 640
ADDRGP4 BotTeam
CALLI4
ASGNI4
ADDRLP4 636
ADDRLP4 640
INDIRI4
ASGNI4
ADDRLP4 636
INDIRI4
CNSTI4 1
EQI4 $448
ADDRLP4 636
INDIRI4
CNSTI4 2
EQI4 $449
ADDRGP4 $445
JUMPV
LABELV $448
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 ctf_blueflag
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
ADDRGP4 $446
JUMPV
LABELV $449
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 ctf_redflag
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
ADDRGP4 $446
JUMPV
LABELV $445
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
CNSTI4 0
RETI4
ADDRGP4 $130
JUMPV
LABELV $446
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRFP4 12
INDIRP4
ARGP4
ADDRLP4 648
ADDRGP4 trap_BotTouchingGoal
CALLI4
ASGNI4
ADDRLP4 648
INDIRI4
CNSTI4 0
EQI4 $450
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $450
ADDRFP4 0
INDIRP4
CNSTI4 6740
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $452
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $452
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 BotAlternateRoute
CALLP4
pop
CNSTI4 1
RETI4
ADDRGP4 $130
JUMPV
LABELV $402
ADDRGP4 gametype
INDIRI4
CNSTI4 5
NEI4 $454
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
CNSTI4 4
NEI4 $456
ADDRLP4 628
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
INDIRF4
ASGNF4
ADDRLP4 628
INDIRF4
CNSTF4 0
EQF4 $458
ADDRLP4 628
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $458
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $408
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
CNSTI4 0
ARGI4
CNSTI4 1
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
CNSTI4 -1
ARGI4
ADDRGP4 $409
ARGP4
ADDRGP4 BotVoiceChatOnly
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
CNSTF4 0
ASGNF4
LABELV $458
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 ctf_neutralflag
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRFP4 12
INDIRP4
ARGP4
ADDRLP4 632
ADDRGP4 trap_BotTouchingGoal
CALLI4
ASGNI4
ADDRLP4 632
INDIRI4
CNSTI4 0
EQI4 $460
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $460
ADDRFP4 0
INDIRP4
CNSTI4 6740
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $462
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $462
CNSTI4 1
RETI4
ADDRGP4 $130
JUMPV
LABELV $456
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
CNSTI4 5
NEI4 $464
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 632
ADDRGP4 BotTeam
CALLI4
ASGNI4
ADDRLP4 628
ADDRLP4 632
INDIRI4
ASGNI4
ADDRLP4 628
INDIRI4
CNSTI4 1
EQI4 $469
ADDRLP4 628
INDIRI4
CNSTI4 2
EQI4 $470
ADDRGP4 $466
JUMPV
LABELV $469
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 ctf_blueflag
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
ADDRGP4 $467
JUMPV
LABELV $470
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 ctf_redflag
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
ADDRGP4 $467
JUMPV
LABELV $466
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
CNSTI4 0
RETI4
ADDRGP4 $130
JUMPV
LABELV $467
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 640
ADDRGP4 Bot1FCTFCarryingFlag
CALLI4
ASGNI4
ADDRLP4 640
INDIRI4
CNSTI4 0
NEI4 $471
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $471
ADDRFP4 0
INDIRP4
CNSTI4 6740
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $473
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $473
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRFP4 12
INDIRP4
ARGP4
ADDRLP4 644
ADDRGP4 trap_BotTouchingGoal
CALLI4
ASGNI4
ADDRLP4 644
INDIRI4
CNSTI4 0
EQI4 $475
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $475
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 BotAlternateRoute
CALLP4
pop
CNSTI4 1
RETI4
ADDRGP4 $130
JUMPV
LABELV $464
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
CNSTI4 13
NEI4 $477
ADDRFP4 0
INDIRP4
CNSTI4 6156
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $477
ADDRLP4 632
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
INDIRF4
ASGNF4
ADDRLP4 632
INDIRF4
CNSTF4 0
EQF4 $479
ADDRLP4 632
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $479
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $481
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
CNSTI4 0
ARGI4
CNSTI4 1
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
CNSTI4 -1
ARGI4
ADDRGP4 $482
ARGP4
ADDRGP4 BotVoiceChatOnly
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
CNSTF4 0
ASGNF4
LABELV $479
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 640
ADDRGP4 BotTeam
CALLI4
ASGNI4
ADDRLP4 636
ADDRLP4 640
INDIRI4
ASGNI4
ADDRLP4 636
INDIRI4
CNSTI4 1
EQI4 $486
ADDRLP4 636
INDIRI4
CNSTI4 2
EQI4 $487
ADDRGP4 $483
JUMPV
LABELV $486
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 ctf_blueflag
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
ADDRGP4 $484
JUMPV
LABELV $487
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 ctf_redflag
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
ADDRGP4 $484
JUMPV
LABELV $483
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
CNSTI4 0
RETI4
ADDRGP4 $130
JUMPV
LABELV $484
ADDRFP4 0
INDIRP4
CNSTI4 6740
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $488
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $488
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRFP4 12
INDIRP4
ARGP4
ADDRLP4 648
ADDRGP4 trap_BotTouchingGoal
CALLI4
ASGNI4
ADDRLP4 648
INDIRI4
CNSTI4 0
EQI4 $490
ADDRLP4 652
ADDRGP4 qk_rand
CALLI4
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 6156
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1073741824
ADDF4
CNSTF4 1084227584
ADDRLP4 652
INDIRI4
CNSTI4 32767
BANDI4
CVIF4 4
CNSTF4 1191181824
DIVF4
MULF4
ADDF4
ASGNF4
LABELV $490
CNSTI4 1
RETI4
ADDRGP4 $130
JUMPV
LABELV $477
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
CNSTI4 6
NEI4 $455
ADDRLP4 632
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
INDIRF4
ASGNF4
ADDRLP4 632
INDIRF4
CNSTF4 0
EQF4 $494
ADDRLP4 632
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $494
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $443
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
CNSTI4 0
ARGI4
CNSTI4 1
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
CNSTI4 -1
ARGI4
ADDRGP4 $444
ARGP4
ADDRGP4 BotVoiceChatOnly
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
CNSTF4 0
ASGNF4
LABELV $494
ADDRFP4 0
INDIRP4
CNSTI4 6740
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $496
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $496
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 4
INDIRI4
ARGI4
ADDRFP4 12
INDIRP4
ARGP4
ADDRLP4 636
ADDRGP4 BotGetItemLongTermGoal
CALLI4
ASGNI4
ADDRLP4 636
INDIRI4
RETI4
ADDRGP4 $130
JUMPV
LABELV $454
ADDRGP4 gametype
INDIRI4
CNSTI4 6
NEI4 $498
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
CNSTI4 13
NEI4 $499
ADDRFP4 0
INDIRP4
CNSTI4 6156
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $499
ADDRLP4 632
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
INDIRF4
ASGNF4
ADDRLP4 632
INDIRF4
CNSTF4 0
EQF4 $502
ADDRLP4 632
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $502
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $481
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
CNSTI4 0
ARGI4
CNSTI4 1
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
CNSTI4 -1
ARGI4
ADDRGP4 $482
ARGP4
ADDRGP4 BotVoiceChatOnly
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
CNSTF4 0
ASGNF4
LABELV $502
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 640
ADDRGP4 BotTeam
CALLI4
ASGNI4
ADDRLP4 636
ADDRLP4 640
INDIRI4
ASGNI4
ADDRLP4 636
INDIRI4
CNSTI4 1
EQI4 $507
ADDRLP4 636
INDIRI4
CNSTI4 2
EQI4 $508
ADDRGP4 $504
JUMPV
LABELV $507
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 blueobelisk
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
ADDRGP4 $505
JUMPV
LABELV $508
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 redobelisk
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
ADDRGP4 $505
JUMPV
LABELV $504
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
CNSTI4 0
RETI4
ADDRGP4 $130
JUMPV
LABELV $505
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 648
ADDRGP4 BotFeelingBad
CALLF4
ASGNF4
ADDRLP4 648
INDIRF4
CNSTF4 1112014848
LEF4 $509
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 4
INDIRI4
ARGI4
ADDRFP4 12
INDIRP4
ARGP4
ADDRLP4 652
ADDRGP4 BotGetItemLongTermGoal
CALLI4
ASGNI4
ADDRLP4 652
INDIRI4
RETI4
ADDRGP4 $130
JUMPV
LABELV $509
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRFP4 12
INDIRP4
ARGP4
ADDRLP4 652
ADDRGP4 trap_BotTouchingGoal
CALLI4
ASGNI4
ADDRLP4 652
INDIRI4
CNSTI4 0
EQI4 $511
ADDRLP4 656
ADDRGP4 qk_rand
CALLI4
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 6156
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1077936128
ADDF4
CNSTF4 1084227584
ADDRLP4 656
INDIRI4
CNSTI4 32767
BANDI4
CVIF4 4
CNSTF4 1191181824
DIVF4
MULF4
ADDF4
ASGNF4
LABELV $511
ADDRLP4 260
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRF4
ADDRFP4 12
INDIRP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260+4
ADDRFP4 0
INDIRP4
CNSTI4 4912
ADDP4
INDIRF4
ADDRFP4 12
INDIRP4
CNSTI4 4
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260+8
ADDRFP4 0
INDIRP4
CNSTI4 4916
ADDP4
INDIRF4
ADDRFP4 12
INDIRP4
CNSTI4 8
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 260
ARGP4
ADDRLP4 664
ADDRGP4 VectorLengthSquared
CALLF4
ASGNF4
ADDRLP4 664
INDIRF4
CNSTF4 1163984896
GEF4 $515
ADDRLP4 668
ADDRGP4 qk_rand
CALLI4
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 6156
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1077936128
ADDF4
CNSTF4 1084227584
ADDRLP4 668
INDIRI4
CNSTI4 32767
BANDI4
CVIF4 4
CNSTF4 1191181824
DIVF4
MULF4
ADDF4
ASGNF4
LABELV $515
ADDRFP4 0
INDIRP4
CNSTI4 6740
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $517
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $517
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 BotAlternateRoute
CALLP4
pop
CNSTI4 1
RETI4
ADDRGP4 $130
JUMPV
LABELV $498
ADDRGP4 gametype
INDIRI4
CNSTI4 7
NEI4 $519
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
CNSTI4 5
NEI4 $521
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 632
ADDRGP4 BotTeam
CALLI4
ASGNI4
ADDRLP4 628
ADDRLP4 632
INDIRI4
ASGNI4
ADDRLP4 628
INDIRI4
CNSTI4 1
EQI4 $526
ADDRLP4 628
INDIRI4
CNSTI4 2
EQI4 $527
ADDRGP4 $523
JUMPV
LABELV $526
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 blueobelisk
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
ADDRGP4 $524
JUMPV
LABELV $527
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 redobelisk
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
ADDRGP4 $524
JUMPV
LABELV $523
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotGoHarvest
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $130
JUMPV
LABELV $524
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 640
ADDRGP4 BotHarvesterCarryingCubes
CALLI4
ASGNI4
ADDRLP4 640
INDIRI4
CNSTI4 0
NEI4 $528
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotGoHarvest
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $130
JUMPV
LABELV $528
ADDRFP4 0
INDIRP4
CNSTI4 6740
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $530
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotGoHarvest
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $130
JUMPV
LABELV $530
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRFP4 12
INDIRP4
ARGP4
ADDRLP4 644
ADDRGP4 trap_BotTouchingGoal
CALLI4
ASGNI4
ADDRLP4 644
INDIRI4
CNSTI4 0
EQI4 $532
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotGoHarvest
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $130
JUMPV
LABELV $532
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 BotAlternateRoute
CALLP4
pop
CNSTI4 1
RETI4
ADDRGP4 $130
JUMPV
LABELV $521
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
CNSTI4 13
NEI4 $534
ADDRFP4 0
INDIRP4
CNSTI4 6156
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $534
ADDRLP4 632
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
INDIRF4
ASGNF4
ADDRLP4 632
INDIRF4
CNSTF4 0
EQF4 $536
ADDRLP4 632
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $536
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $481
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
CNSTI4 0
ARGI4
CNSTI4 1
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
CNSTI4 -1
ARGI4
ADDRGP4 $482
ARGP4
ADDRGP4 BotVoiceChatOnly
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
CNSTF4 0
ASGNF4
LABELV $536
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 640
ADDRGP4 BotTeam
CALLI4
ASGNI4
ADDRLP4 636
ADDRLP4 640
INDIRI4
ASGNI4
ADDRLP4 636
INDIRI4
CNSTI4 1
EQI4 $541
ADDRLP4 636
INDIRI4
CNSTI4 2
EQI4 $542
ADDRGP4 $538
JUMPV
LABELV $541
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 blueobelisk
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
ADDRGP4 $539
JUMPV
LABELV $542
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 redobelisk
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
ADDRGP4 $539
JUMPV
LABELV $538
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
CNSTI4 0
RETI4
ADDRGP4 $130
JUMPV
LABELV $539
ADDRFP4 0
INDIRP4
CNSTI4 6740
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $543
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $543
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRFP4 12
INDIRP4
ARGP4
ADDRLP4 648
ADDRGP4 trap_BotTouchingGoal
CALLI4
ASGNI4
ADDRLP4 648
INDIRI4
CNSTI4 0
EQI4 $545
ADDRLP4 652
ADDRGP4 qk_rand
CALLI4
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 6156
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1073741824
ADDF4
CNSTF4 1084227584
ADDRLP4 652
INDIRI4
CNSTI4 32767
BANDI4
CVIF4 4
CNSTF4 1191181824
DIVF4
MULF4
ADDF4
ASGNF4
LABELV $545
CNSTI4 1
RETI4
ADDRGP4 $130
JUMPV
LABELV $534
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
CNSTI4 12
NEI4 $547
ADDRFP4 0
INDIRP4
CNSTI4 6160
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $547
ADDRLP4 636
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
INDIRF4
ASGNF4
ADDRLP4 636
INDIRF4
CNSTF4 0
EQF4 $549
ADDRLP4 636
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $549
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $551
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
CNSTI4 0
ARGI4
CNSTI4 1
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
CNSTI4 -1
ARGI4
ADDRGP4 $482
ARGP4
ADDRGP4 BotVoiceChatOnly
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6736
ADDP4
CNSTF4 0
ASGNF4
LABELV $549
ADDRFP4 12
INDIRP4
ARGP4
ADDRGP4 neutralobelisk
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
ADDRFP4 0
INDIRP4
CNSTI4 6740
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $552
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
CNSTI4 0
ASGNI4
LABELV $552
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRFP4 12
INDIRP4
ARGP4
ADDRLP4 640
ADDRGP4 trap_BotTouchingGoal
CALLI4
ASGNI4
ADDRLP4 640
INDIRI4
CNSTI4 0
EQI4 $554
ADDRLP4 644
ADDRGP4 qk_rand
CALLI4
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 6160
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1082130432
ADDF4
CNSTF4 1077936128
ADDRLP4 644
INDIRI4
CNSTI4 32767
BANDI4
CVIF4 4
CNSTF4 1191181824
DIVF4
MULF4
ADDF4
ASGNF4
LABELV $554
CNSTI4 1
RETI4
ADDRGP4 $130
JUMPV
LABELV $547
LABELV $519
LABELV $499
LABELV $455
LABELV $403
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 4
INDIRI4
ARGI4
ADDRFP4 12
INDIRP4
ARGP4
ADDRLP4 628
ADDRGP4 BotGetItemLongTermGoal
CALLI4
ASGNI4
ADDRLP4 628
INDIRI4
RETI4
LABELV $130
endproc BotGetLongTermGoal 672 20
export BotLongTermGoal
proc BotLongTermGoal 448 20
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
CNSTI4 6880
ADDP4
INDIRF4
CNSTF4 0
LEF4 $557
ADDRFP4 8
INDIRI4
CNSTI4 0
NEI4 $557
ADDRFP4 0
INDIRP4
CNSTI4 6880
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $559
ADDRFP4 0
INDIRP4
CNSTI4 6820
ADDP4
INDIRI4
ARGI4
ADDRLP4 152
ARGP4
CNSTI4 256
ARGI4
ADDRLP4 416
ADDRGP4 EasyClientName
CALLP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $561
ARGP4
ADDRLP4 416
INDIRP4
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6600
ADDP4
INDIRI4
ARGI4
CNSTI4 2
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6880
ADDP4
CNSTF4 0
ASGNF4
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 4
INDIRI4
ARGI4
ADDRFP4 8
INDIRI4
ARGI4
ADDRFP4 12
INDIRP4
ARGP4
ADDRLP4 424
ADDRGP4 BotGetLongTermGoal
CALLI4
ASGNI4
ADDRLP4 424
INDIRI4
RETI4
ADDRGP4 $556
JUMPV
LABELV $559
ADDRLP4 416
ADDRFP4 0
INDIRP4
CNSTI4 6888
ADDP4
INDIRF4
ASGNF4
ADDRLP4 416
INDIRF4
CNSTF4 0
GEF4 $562
ADDRLP4 416
INDIRF4
NEGF4
ADDRGP4 floattime
INDIRF4
GEF4 $562
ADDRFP4 0
INDIRP4
CNSTI4 6820
ADDP4
INDIRI4
ARGI4
ADDRLP4 152
ARGP4
CNSTI4 256
ARGI4
ADDRLP4 420
ADDRGP4 EasyClientName
CALLP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $564
ARGP4
ADDRLP4 420
INDIRP4
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6600
ADDP4
INDIRI4
ARGI4
CNSTI4 2
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6888
ADDP4
ADDRGP4 floattime
INDIRF4
ASGNF4
LABELV $562
ADDRFP4 0
INDIRP4
CNSTI4 6820
ADDP4
INDIRI4
ARGI4
ADDRLP4 12
ARGP4
ADDRGP4 BotEntityInfo
CALLV
pop
ADDRLP4 12
INDIRI4
CNSTI4 0
EQI4 $565
ADDRLP4 12+24
ARGP4
ADDRLP4 420
ADDRGP4 BotPointAreaNum
CALLI4
ASGNI4
ADDRLP4 412
ADDRLP4 420
INDIRI4
ASGNI4
ADDRLP4 424
ADDRLP4 412
INDIRI4
ASGNI4
ADDRLP4 424
INDIRI4
CNSTI4 0
EQI4 $568
ADDRLP4 424
INDIRI4
ARGI4
ADDRLP4 428
ADDRGP4 trap_AAS_AreaReachability
CALLI4
ASGNI4
ADDRLP4 428
INDIRI4
CNSTI4 0
EQI4 $568
ADDRFP4 0
INDIRP4
CNSTI4 6864
ADDP4
ADDRFP4 0
INDIRP4
CNSTI4 6820
ADDP4
INDIRI4
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 6836
ADDP4
ADDRLP4 412
INDIRI4
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 6824
ADDP4
ADDRLP4 12+24
INDIRB
ASGNB 12
ADDRFP4 0
INDIRP4
CNSTI4 6840
ADDP4
CNSTF4 3238002688
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6844
ADDP4
CNSTF4 3238002688
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6848
ADDP4
CNSTF4 3238002688
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6852
ADDP4
CNSTF4 1090519040
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6856
ADDP4
CNSTF4 1090519040
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6860
ADDP4
CNSTF4 1090519040
ASGNF4
LABELV $568
LABELV $565
ADDRFP4 0
INDIRP4
CNSTI4 12
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 4936
ADDP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6560
ADDP4
ARGP4
CNSTF4 1135869952
ARGF4
ADDRFP4 0
INDIRP4
CNSTI4 6820
ADDP4
INDIRI4
ARGI4
ADDRLP4 424
ADDRGP4 BotEntityVisible
CALLF4
ASGNF4
ADDRLP4 424
INDIRF4
CNSTF4 0
EQF4 $571
ADDRFP4 0
INDIRP4
CNSTI4 6884
ADDP4
ADDRGP4 floattime
INDIRF4
ASGNF4
LABELV $571
ADDRFP4 0
INDIRP4
CNSTI4 6884
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
CNSTF4 1065353216
SUBF4
GEF4 $573
ADDRFP4 0
INDIRP4
CNSTI4 6892
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1073741824
ADDF4
ASGNF4
LABELV $573
ADDRLP4 0
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 6824
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 0+4
ADDRFP4 0
INDIRP4
CNSTI4 4912
ADDP4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 6828
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 0+8
ADDRFP4 0
INDIRP4
CNSTI4 4916
ADDP4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 6832
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 0
ARGP4
ADDRLP4 436
ADDRGP4 VectorLengthSquared
CALLF4
ASGNF4
ADDRLP4 408
ADDRLP4 436
INDIRF4
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6892
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
LEF4 $577
ADDRFP4 0
INDIRP4
CNSTI4 6888
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
CNSTF4 1101004800
SUBF4
GEF4 $579
ADDRFP4 0
INDIRP4
CNSTI4 6820
ADDP4
INDIRI4
ARGI4
ADDRLP4 152
ARGP4
CNSTI4 256
ARGI4
ADDRLP4 440
ADDRGP4 EasyClientName
CALLP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $564
ARGP4
ADDRLP4 440
INDIRP4
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6600
ADDP4
INDIRI4
ARGI4
CNSTI4 2
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6888
ADDP4
ADDRGP4 floattime
INDIRF4
ASGNF4
LABELV $579
ADDRLP4 408
INDIRF4
CNSTF4 1176256512
GEF4 $581
ADDRFP4 0
INDIRP4
CNSTI4 6892
ADDP4
CNSTF4 0
ASGNF4
LABELV $581
ADDRFP4 12
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6824
ADDP4
ARGP4
CNSTU4 56
ARGU4
ADDRGP4 qk_memcpy
CALLP4
pop
CNSTI4 1
RETI4
ADDRGP4 $556
JUMPV
LABELV $577
ADDRLP4 408
INDIRF4
CNSTF4 1215570944
LEF4 $583
ADDRFP4 0
INDIRP4
CNSTI4 6888
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
CNSTF4 1101004800
SUBF4
GEF4 $585
ADDRFP4 0
INDIRP4
CNSTI4 6820
ADDP4
INDIRI4
ARGI4
ADDRLP4 152
ARGP4
CNSTI4 256
ARGI4
ADDRLP4 440
ADDRGP4 EasyClientName
CALLP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $564
ARGP4
ADDRLP4 440
INDIRP4
ARGP4
CNSTP4 0
ARGP4
ADDRGP4 BotAI_BotInitialChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6600
ADDP4
INDIRI4
ARGI4
CNSTI4 2
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6888
ADDP4
ADDRGP4 floattime
INDIRF4
ASGNF4
LABELV $585
ADDRLP4 0
ADDRLP4 12+24
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 0+4
ADDRLP4 12+24+4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4912
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 0+8
ADDRLP4 12+24+8
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4916
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 0
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ARGP4
ADDRGP4 vectoangles
CALLV
pop
ADDRLP4 444
ADDRFP4 0
INDIRP4
CNSTI4 6580
ADDP4
ASGNP4
ADDRLP4 444
INDIRP4
CNSTF4 1056964608
ADDRLP4 444
INDIRP4
INDIRF4
MULF4
ASGNF4
CNSTI4 0
RETI4
ADDRGP4 $556
JUMPV
LABELV $583
LABELV $557
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 4
INDIRI4
ARGI4
ADDRFP4 8
INDIRI4
ARGI4
ADDRFP4 12
INDIRP4
ARGP4
ADDRLP4 416
ADDRGP4 BotGetLongTermGoal
CALLI4
ASGNI4
ADDRLP4 416
INDIRI4
RETI4
LABELV $556
endproc BotLongTermGoal 448 20
export AIEnter_Intermission
proc AIEnter_Intermission 8 16
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $595
ARGP4
ADDRGP4 $62
ARGP4
ADDRFP4 4
INDIRP4
ARGP4
ADDRGP4 BotRecordNodeSwitch
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotResetState
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 0
ADDRGP4 BotChat_EndLevel
CALLI4
ASGNI4
ADDRLP4 0
INDIRI4
CNSTI4 0
EQI4 $596
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
CNSTI4 0
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6052
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
LABELV $596
ADDRFP4 0
INDIRP4
CNSTI4 4900
ADDP4
ADDRGP4 AINode_Intermission
ASGNP4
LABELV $594
endproc AIEnter_Intermission 8 16
export AINode_Intermission
proc AINode_Intermission 16 8
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 0
ADDRGP4 BotIntermission
CALLI4
ASGNI4
ADDRLP4 0
INDIRI4
CNSTI4 0
NEI4 $599
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 4
ADDRGP4 BotChat_StartLevel
CALLI4
ASGNI4
ADDRLP4 4
INDIRI4
CNSTI4 0
EQI4 $601
ADDRLP4 8
ADDRFP4 0
INDIRP4
ASGNP4
ADDRLP4 8
INDIRP4
ARGP4
ADDRLP4 12
ADDRGP4 BotChatTime
CALLF4
ASGNF4
ADDRLP4 8
INDIRP4
CNSTI4 6096
ADDP4
ADDRGP4 floattime
INDIRF4
ADDRLP4 12
INDIRF4
ADDF4
ASGNF4
ADDRGP4 $602
JUMPV
LABELV $601
ADDRFP4 0
INDIRP4
CNSTI4 6096
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1073741824
ADDF4
ASGNF4
LABELV $602
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $603
ARGP4
ADDRGP4 AIEnter_Stand
CALLV
pop
LABELV $599
CNSTI4 1
RETI4
LABELV $598
endproc AINode_Intermission 16 8
export AIEnter_Observer
proc AIEnter_Observer 0 16
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $605
ARGP4
ADDRGP4 $62
ARGP4
ADDRFP4 4
INDIRP4
ARGP4
ADDRGP4 BotRecordNodeSwitch
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotResetState
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 4900
ADDP4
ADDRGP4 AINode_Observer
ASGNP4
LABELV $604
endproc AIEnter_Observer 0 16
export AINode_Observer
proc AINode_Observer 4 8
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 0
ADDRGP4 BotIsObserver
CALLI4
ASGNI4
ADDRLP4 0
INDIRI4
CNSTI4 0
NEI4 $607
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $609
ARGP4
ADDRGP4 AIEnter_Stand
CALLV
pop
LABELV $607
CNSTI4 1
RETI4
LABELV $606
endproc AINode_Observer 4 8
export AIEnter_Stand
proc AIEnter_Stand 0 16
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $611
ARGP4
ADDRGP4 $62
ARGP4
ADDRFP4 4
INDIRP4
ARGP4
ADDRGP4 BotRecordNodeSwitch
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6112
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1065353216
ADDF4
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 4900
ADDP4
ADDRGP4 AINode_Stand
ASGNP4
LABELV $610
endproc AIEnter_Stand 0 16
export AINode_Stand
proc AINode_Stand 24 12
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
CNSTI4 6044
ADDP4
INDIRI4
ADDRFP4 0
INDIRP4
CNSTI4 5068
ADDP4
INDIRI4
LEI4 $613
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 4
ADDRGP4 BotChat_HitTalking
CALLI4
ASGNI4
ADDRLP4 4
INDIRI4
CNSTI4 0
EQI4 $615
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 12
ADDRGP4 BotChatTime
CALLF4
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6112
ADDP4
ADDRGP4 floattime
INDIRF4
ADDRLP4 12
INDIRF4
ADDF4
CNSTF4 1036831949
ADDF4
ASGNF4
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 20
ADDRGP4 BotChatTime
CALLF4
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6096
ADDP4
ADDRGP4 floattime
INDIRF4
ADDRLP4 20
INDIRF4
ADDF4
CNSTF4 1036831949
ADDF4
ASGNF4
LABELV $615
LABELV $613
ADDRFP4 0
INDIRP4
CNSTI4 6112
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $617
ADDRFP4 0
INDIRP4
ARGP4
CNSTI4 -1
ARGI4
ADDRLP4 4
ADDRGP4 BotFindEnemy
CALLI4
ASGNI4
ADDRLP4 4
INDIRI4
CNSTI4 0
EQI4 $619
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $621
ARGP4
ADDRGP4 AIEnter_Battle_Fight
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $612
JUMPV
LABELV $619
ADDRFP4 0
INDIRP4
CNSTI4 6112
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1065353216
ADDF4
ASGNF4
LABELV $617
ADDRFP4 0
INDIRP4
CNSTI4 8
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_EA_Talk
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6096
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $622
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
CNSTI4 0
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6052
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $624
ARGP4
ADDRGP4 AIEnter_Seek_LTG
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $612
JUMPV
LABELV $622
CNSTI4 1
RETI4
LABELV $612
endproc AINode_Stand 24 12
export AIEnter_Respawn
proc AIEnter_Respawn 12 16
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $626
ARGP4
ADDRGP4 $62
ARGP4
ADDRFP4 4
INDIRP4
ARGP4
ADDRGP4 BotRecordNodeSwitch
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetMoveState
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetGoalState
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetAvoidGoals
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetAvoidReach
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 0
ADDRGP4 BotChat_Death
CALLI4
ASGNI4
ADDRLP4 0
INDIRI4
CNSTI4 0
EQI4 $627
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 8
ADDRGP4 BotChatTime
CALLF4
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6076
ADDP4
ADDRGP4 floattime
INDIRF4
ADDRLP4 8
INDIRF4
ADDF4
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6080
ADDP4
ADDRGP4 floattime
INDIRF4
ASGNF4
ADDRGP4 $628
JUMPV
LABELV $627
ADDRLP4 4
ADDRGP4 qk_rand
CALLI4
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 6076
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1065353216
ADDF4
ADDRLP4 4
INDIRI4
CNSTI4 32767
BANDI4
CVIF4 4
CNSTF4 1191181824
DIVF4
ADDF4
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6080
ADDP4
CNSTF4 0
ASGNF4
LABELV $628
ADDRFP4 0
INDIRP4
CNSTI4 5984
ADDP4
CNSTI4 0
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 4900
ADDP4
ADDRGP4 AINode_Respawn
ASGNP4
LABELV $625
endproc AIEnter_Respawn 12 16
export AINode_Respawn
proc AINode_Respawn 4 12
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
CNSTI4 5984
ADDP4
INDIRI4
CNSTI4 0
EQI4 $630
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 0
ADDRGP4 BotIsDead
CALLI4
ASGNI4
ADDRLP4 0
INDIRI4
CNSTI4 0
NEI4 $632
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $634
ARGP4
ADDRGP4 AIEnter_Seek_LTG
CALLV
pop
ADDRGP4 $631
JUMPV
LABELV $632
ADDRFP4 0
INDIRP4
CNSTI4 8
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_EA_Respawn
CALLV
pop
ADDRGP4 $631
JUMPV
LABELV $630
ADDRFP4 0
INDIRP4
CNSTI4 6076
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $635
ADDRFP4 0
INDIRP4
CNSTI4 5984
ADDP4
CNSTI4 1
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 8
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_EA_Respawn
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6080
ADDP4
INDIRF4
CNSTF4 0
EQF4 $637
ADDRFP4 0
INDIRP4
CNSTI4 6528
ADDP4
INDIRI4
ARGI4
CNSTI4 0
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 6052
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotEnterChat
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
CNSTI4 -1
ASGNI4
LABELV $637
LABELV $635
LABELV $631
ADDRLP4 0
ADDRFP4 0
INDIRP4
CNSTI4 6080
ADDP4
INDIRF4
ASGNF4
ADDRLP4 0
INDIRF4
CNSTF4 0
EQF4 $639
ADDRLP4 0
INDIRF4
ADDRGP4 floattime
INDIRF4
CNSTF4 1056964608
SUBF4
GEF4 $639
ADDRFP4 0
INDIRP4
CNSTI4 8
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_EA_Talk
CALLV
pop
LABELV $639
CNSTI4 1
RETI4
LABELV $629
endproc AINode_Respawn 4 12
export BotSelectActivateWeapon
proc BotSelectActivateWeapon 88 0
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRLP4 4
CNSTI4 0
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 4976
ADDP4
INDIRI4
ADDRLP4 4
INDIRI4
LEI4 $642
ADDRFP4 0
INDIRP4
CNSTI4 5028
ADDP4
INDIRI4
ADDRLP4 4
INDIRI4
LEI4 $642
CNSTI4 2
RETI4
ADDRGP4 $641
JUMPV
LABELV $642
ADDRLP4 12
CNSTI4 0
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 4972
ADDP4
INDIRI4
ADDRLP4 12
INDIRI4
LEI4 $644
ADDRFP4 0
INDIRP4
CNSTI4 5024
ADDP4
INDIRI4
ADDRLP4 12
INDIRI4
LEI4 $644
CNSTI4 3
RETI4
ADDRGP4 $641
JUMPV
LABELV $644
ADDRLP4 20
CNSTI4 0
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 4996
ADDP4
INDIRI4
ADDRLP4 20
INDIRI4
LEI4 $646
ADDRFP4 0
INDIRP4
CNSTI4 5036
ADDP4
INDIRI4
ADDRLP4 20
INDIRI4
LEI4 $646
CNSTI4 8
RETI4
ADDRGP4 $641
JUMPV
LABELV $646
ADDRLP4 28
CNSTI4 0
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 4988
ADDP4
INDIRI4
ADDRLP4 28
INDIRI4
LEI4 $648
ADDRFP4 0
INDIRP4
CNSTI4 5040
ADDP4
INDIRI4
ADDRLP4 28
INDIRI4
LEI4 $648
CNSTI4 6
RETI4
ADDRGP4 $641
JUMPV
LABELV $648
ADDRLP4 36
CNSTI4 0
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 5020
ADDP4
INDIRI4
ADDRLP4 36
INDIRI4
LEI4 $650
ADDRFP4 0
INDIRP4
CNSTI4 5064
ADDP4
INDIRI4
ADDRLP4 36
INDIRI4
LEI4 $650
CNSTI4 13
RETI4
ADDRGP4 $641
JUMPV
LABELV $650
ADDRLP4 44
CNSTI4 0
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 5012
ADDP4
INDIRI4
ADDRLP4 44
INDIRI4
LEI4 $652
ADDRFP4 0
INDIRP4
CNSTI4 5056
ADDP4
INDIRI4
ADDRLP4 44
INDIRI4
LEI4 $652
CNSTI4 11
RETI4
ADDRGP4 $641
JUMPV
LABELV $652
ADDRLP4 52
CNSTI4 0
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 5016
ADDP4
INDIRI4
ADDRLP4 52
INDIRI4
LEI4 $654
ADDRFP4 0
INDIRP4
CNSTI4 5060
ADDP4
INDIRI4
ADDRLP4 52
INDIRI4
LEI4 $654
CNSTI4 12
RETI4
ADDRGP4 $641
JUMPV
LABELV $654
ADDRLP4 60
CNSTI4 0
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 4980
ADDP4
INDIRI4
ADDRLP4 60
INDIRI4
LEI4 $656
ADDRFP4 0
INDIRP4
CNSTI4 5032
ADDP4
INDIRI4
ADDRLP4 60
INDIRI4
LEI4 $656
CNSTI4 4
RETI4
ADDRGP4 $641
JUMPV
LABELV $656
ADDRLP4 68
CNSTI4 0
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 4992
ADDP4
INDIRI4
ADDRLP4 68
INDIRI4
LEI4 $658
ADDRFP4 0
INDIRP4
CNSTI4 5048
ADDP4
INDIRI4
ADDRLP4 68
INDIRI4
LEI4 $658
CNSTI4 7
RETI4
ADDRGP4 $641
JUMPV
LABELV $658
ADDRLP4 76
CNSTI4 0
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 4984
ADDP4
INDIRI4
ADDRLP4 76
INDIRI4
LEI4 $660
ADDRFP4 0
INDIRP4
CNSTI4 5044
ADDP4
INDIRI4
ADDRLP4 76
INDIRI4
LEI4 $660
CNSTI4 5
RETI4
ADDRGP4 $641
JUMPV
LABELV $660
ADDRLP4 84
CNSTI4 0
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 5004
ADDP4
INDIRI4
ADDRLP4 84
INDIRI4
LEI4 $662
ADDRFP4 0
INDIRP4
CNSTI4 5052
ADDP4
INDIRI4
ADDRLP4 84
INDIRI4
LEI4 $662
CNSTI4 9
RETI4
ADDRGP4 $641
JUMPV
LABELV $662
CNSTI4 -1
RETI4
LABELV $641
endproc BotSelectActivateWeapon 88 0
export BotClearPath
proc BotClearPath 376 28
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 4
ADDRFP4 4
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
CNSTI4 6252
ADDP4
INDIRI4
CNSTI4 0
EQI4 $665
ADDRFP4 4
INDIRP4
CNSTI4 20
ADDP4
INDIRI4
CNSTI4 17
BANDI4
CNSTI4 0
NEI4 $667
ADDRFP4 0
INDIRP4
CNSTI4 6252
ADDP4
INDIRI4
ARGI4
ADDRLP4 12
ARGP4
ADDRGP4 BotAI_GetEntityState
CALLI4
pop
ADDRLP4 236
ADDRLP4 12+12+12
INDIRB
ASGNB 12
ADDRLP4 236+8
ADDRLP4 236+8
INDIRF4
CNSTF4 1090519040
ADDF4
ASGNF4
ADDRLP4 0
ADDRLP4 236
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4936
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 0+4
ADDRLP4 236+4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4940
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 0+8
ADDRLP4 236+8
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4944
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 0
ARGP4
ADDRFP4 4
INDIRP4
CNSTI4 40
ADDP4
ARGP4
ADDRGP4 vectoangles
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 336
ADDRGP4 BotSelectActivateWeapon
CALLI4
ASGNI4
ADDRFP4 4
INDIRP4
CNSTI4 24
ADDP4
ADDRLP4 336
INDIRI4
ASGNI4
ADDRFP4 4
INDIRP4
CNSTI4 24
ADDP4
INDIRI4
CNSTI4 -1
NEI4 $676
ADDRFP4 4
INDIRP4
CNSTI4 24
ADDP4
CNSTI4 0
ASGNI4
LABELV $676
ADDRFP4 4
INDIRP4
CNSTI4 24
ADDP4
INDIRI4
CNSTI4 0
EQI4 $678
ADDRLP4 340
ADDRFP4 4
INDIRP4
CNSTI4 20
ADDP4
ASGNP4
ADDRLP4 340
INDIRP4
ADDRLP4 340
INDIRP4
INDIRI4
CNSTI4 17
BORI4
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 160
ADDP4
INDIRI4
ADDRFP4 4
INDIRP4
CNSTI4 24
ADDP4
INDIRI4
NEI4 $680
ADDRFP4 0
INDIRP4
CNSTI4 6560
ADDP4
ARGP4
CNSTF4 1101004800
ARGF4
ADDRFP4 4
INDIRP4
CNSTI4 40
ADDP4
ARGP4
ADDRLP4 344
ADDRGP4 InFieldOfVision
CALLI4
ASGNI4
ADDRLP4 344
INDIRI4
CNSTI4 0
EQI4 $682
ADDRLP4 248
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 4936
ADDP4
ARGP4
ADDRLP4 352
CNSTP4 0
ASGNP4
ADDRLP4 352
INDIRP4
ARGP4
ADDRLP4 352
INDIRP4
ARGP4
ADDRLP4 236
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 12
ADDP4
INDIRI4
ARGI4
CNSTI4 100663297
ARGI4
ADDRGP4 BotAI_Trace
CALLV
pop
ADDRLP4 248+8
INDIRF4
CNSTF4 1065353216
GEF4 $688
ADDRLP4 248+80
INDIRI4
ADDRLP4 12
INDIRI4
NEI4 $684
LABELV $688
ADDRFP4 0
INDIRP4
CNSTI4 8
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_EA_Attack
CALLV
pop
LABELV $684
LABELV $682
LABELV $680
LABELV $678
LABELV $667
LABELV $665
ADDRFP4 4
INDIRP4
CNSTI4 20
ADDP4
INDIRI4
CNSTI4 256
BANDI4
CNSTI4 0
EQI4 $689
ADDRFP4 0
INDIRP4
CNSTI4 6204
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1084227584
ADDF4
ASGNF4
LABELV $689
ADDRFP4 0
INDIRP4
CNSTI4 6204
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
LEF4 $691
ADDRFP4 4
INDIRP4
CNSTI4 20
ADDP4
INDIRI4
CNSTI4 17
BANDI4
CNSTI4 0
NEI4 $691
ADDRLP4 228
CNSTF4 1133903872
ASGNF4
ADDRLP4 232
CNSTI4 -1
ASGNI4
ADDRLP4 220
CNSTI4 0
ASGNI4
ADDRGP4 $696
JUMPV
LABELV $693
ADDRLP4 220
INDIRI4
CNSTI4 2
LSHI4
ADDRFP4 0
INDIRP4
CNSTI4 6256
ADDP4
ADDP4
INDIRI4
ARGI4
ADDRLP4 12
ARGP4
ADDRGP4 BotAI_GetEntityState
CALLI4
pop
ADDRLP4 0
ADDRLP4 12+12+12
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 0+4
ADDRLP4 12+12+12+4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4912
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 0+8
ADDRLP4 12+12+12+8
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4916
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 0
ARGP4
ADDRLP4 336
ADDRGP4 VectorLength
CALLF4
ASGNF4
ADDRLP4 224
ADDRLP4 336
INDIRF4
ASGNF4
ADDRLP4 224
INDIRF4
ADDRLP4 228
INDIRF4
GEF4 $707
ADDRLP4 228
ADDRLP4 224
INDIRF4
ASGNF4
ADDRLP4 232
ADDRLP4 220
INDIRI4
ASGNI4
LABELV $707
LABELV $694
ADDRLP4 220
ADDRLP4 220
INDIRI4
CNSTI4 1
ADDI4
ASGNI4
LABELV $696
ADDRLP4 220
INDIRI4
ADDRFP4 0
INDIRP4
CNSTI4 6512
ADDP4
INDIRI4
LTI4 $693
ADDRLP4 232
INDIRI4
CNSTI4 -1
EQI4 $709
ADDRLP4 232
INDIRI4
CNSTI4 2
LSHI4
ADDRFP4 0
INDIRP4
CNSTI4 6256
ADDP4
ADDP4
INDIRI4
ARGI4
ADDRLP4 12
ARGP4
ADDRGP4 BotAI_GetEntityState
CALLI4
pop
ADDRLP4 236
ADDRLP4 12+12+12
INDIRB
ASGNB 12
ADDRLP4 236+8
ADDRLP4 236+8
INDIRF4
CNSTF4 1073741824
ADDF4
ASGNF4
ADDRLP4 0
ADDRLP4 236
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4936
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 0+4
ADDRLP4 236+4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4940
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 0+8
ADDRLP4 236+8
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4944
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 0
ARGP4
ADDRFP4 4
INDIRP4
CNSTI4 40
ADDP4
ARGP4
ADDRGP4 vectoangles
CALLV
pop
ADDRLP4 340
CNSTI4 0
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 4996
ADDP4
INDIRI4
ADDRLP4 340
INDIRI4
LEI4 $718
ADDRFP4 0
INDIRP4
CNSTI4 5036
ADDP4
INDIRI4
ADDRLP4 340
INDIRI4
LEI4 $718
ADDRFP4 4
INDIRP4
CNSTI4 24
ADDP4
CNSTI4 8
ASGNI4
ADDRGP4 $719
JUMPV
LABELV $718
ADDRLP4 348
CNSTI4 0
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 4984
ADDP4
INDIRI4
ADDRLP4 348
INDIRI4
LEI4 $720
ADDRFP4 0
INDIRP4
CNSTI4 5044
ADDP4
INDIRI4
ADDRLP4 348
INDIRI4
LEI4 $720
ADDRFP4 4
INDIRP4
CNSTI4 24
ADDP4
CNSTI4 5
ASGNI4
ADDRGP4 $721
JUMPV
LABELV $720
ADDRLP4 356
CNSTI4 0
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 5004
ADDP4
INDIRI4
ADDRLP4 356
INDIRI4
LEI4 $722
ADDRFP4 0
INDIRP4
CNSTI4 5052
ADDP4
INDIRI4
ADDRLP4 356
INDIRI4
LEI4 $722
ADDRFP4 4
INDIRP4
CNSTI4 24
ADDP4
CNSTI4 9
ASGNI4
ADDRGP4 $723
JUMPV
LABELV $722
ADDRFP4 4
INDIRP4
CNSTI4 24
ADDP4
CNSTI4 0
ASGNI4
LABELV $723
LABELV $721
LABELV $719
ADDRFP4 4
INDIRP4
CNSTI4 24
ADDP4
INDIRI4
CNSTI4 0
EQI4 $724
ADDRLP4 360
ADDRFP4 4
INDIRP4
CNSTI4 20
ADDP4
ASGNP4
ADDRLP4 360
INDIRP4
ADDRLP4 360
INDIRP4
INDIRI4
CNSTI4 17
BORI4
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 160
ADDP4
INDIRI4
ADDRFP4 4
INDIRP4
CNSTI4 24
ADDP4
INDIRI4
NEI4 $726
ADDRFP4 0
INDIRP4
CNSTI4 6560
ADDP4
ARGP4
CNSTF4 1101004800
ARGF4
ADDRFP4 4
INDIRP4
CNSTI4 40
ADDP4
ARGP4
ADDRLP4 364
ADDRGP4 InFieldOfVision
CALLI4
ASGNI4
ADDRLP4 364
INDIRI4
CNSTI4 0
EQI4 $728
ADDRLP4 248
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 4936
ADDP4
ARGP4
ADDRLP4 372
CNSTP4 0
ASGNP4
ADDRLP4 372
INDIRP4
ARGP4
ADDRLP4 372
INDIRP4
ARGP4
ADDRLP4 236
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 12
ADDP4
INDIRI4
ARGI4
CNSTI4 100663297
ARGI4
ADDRGP4 BotAI_Trace
CALLV
pop
ADDRLP4 248+8
INDIRF4
CNSTF4 1065353216
GEF4 $734
ADDRLP4 248+80
INDIRI4
ADDRLP4 12
INDIRI4
NEI4 $730
LABELV $734
ADDRFP4 0
INDIRP4
CNSTI4 8
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_EA_Attack
CALLV
pop
LABELV $730
LABELV $728
LABELV $726
LABELV $724
LABELV $709
LABELV $691
LABELV $664
endproc BotClearPath 376 28
export AIEnter_Seek_ActivateEntity
proc AIEnter_Seek_ActivateEntity 0 16
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $736
ARGP4
ADDRGP4 $62
ARGP4
ADDRFP4 4
INDIRP4
ARGP4
ADDRGP4 BotRecordNodeSwitch
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 4900
ADDP4
ADDRGP4 AINode_Seek_ActivateEntity
ASGNP4
LABELV $735
endproc AIEnter_Seek_ActivateEntity 0 16
export AINode_Seek_ActivateEntity
proc AINode_Seek_ActivateEntity 380 28
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 320
ADDRGP4 BotIsObserver
CALLI4
ASGNI4
ADDRLP4 320
INDIRI4
CNSTI4 0
EQI4 $738
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotClearActivateGoalStack
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $740
ARGP4
ADDRGP4 AIEnter_Observer
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $737
JUMPV
LABELV $738
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 324
ADDRGP4 BotIntermission
CALLI4
ASGNI4
ADDRLP4 324
INDIRI4
CNSTI4 0
EQI4 $741
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotClearActivateGoalStack
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $743
ARGP4
ADDRGP4 AIEnter_Intermission
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $737
JUMPV
LABELV $741
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 328
ADDRGP4 BotIsDead
CALLI4
ASGNI4
ADDRLP4 328
INDIRI4
CNSTI4 0
EQI4 $744
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotClearActivateGoalStack
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $746
ARGP4
ADDRGP4 AIEnter_Respawn
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $737
JUMPV
LABELV $744
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
CNSTI4 18616254
ASGNI4
ADDRGP4 bot_grapple+12
INDIRI4
CNSTI4 0
EQI4 $747
ADDRLP4 332
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
ASGNP4
ADDRLP4 332
INDIRP4
ADDRLP4 332
INDIRP4
INDIRI4
CNSTI4 16384
BORI4
ASGNI4
LABELV $747
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 336
ADDRGP4 BotInLavaOrSlime
CALLI4
ASGNI4
ADDRLP4 336
INDIRI4
CNSTI4 0
EQI4 $750
ADDRLP4 340
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
ASGNP4
ADDRLP4 340
INDIRP4
ADDRLP4 340
INDIRP4
INDIRI4
CNSTI4 6291456
BORI4
ASGNI4
LABELV $750
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotMapScripts
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
CNSTI4 -1
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
INDIRP4
CVPU4 4
CNSTU4 0
NEU4 $752
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotClearActivateGoalStack
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $754
ARGP4
ADDRGP4 AIEnter_Seek_NBG
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $737
JUMPV
LABELV $752
ADDRLP4 344
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
ASGNP4
ADDRLP4 52
ADDRLP4 344
INDIRP4
INDIRP4
CNSTI4 4
ADDP4
ASGNP4
ADDRLP4 348
CNSTI4 0
ASGNI4
ADDRLP4 68
ADDRLP4 348
INDIRI4
ASGNI4
ADDRLP4 344
INDIRP4
INDIRP4
CNSTI4 72
ADDP4
INDIRI4
ADDRLP4 348
INDIRI4
EQI4 $755
ADDRLP4 72
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 4936
ADDP4
ARGP4
ADDRLP4 356
CNSTP4 0
ASGNP4
ADDRLP4 356
INDIRP4
ARGP4
ADDRLP4 356
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
INDIRP4
CNSTI4 80
ADDP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 12
ADDP4
INDIRI4
ARGI4
CNSTI4 100663297
ARGI4
ADDRGP4 BotAI_Trace
CALLV
pop
ADDRLP4 72+8
INDIRF4
CNSTF4 1065353216
GEF4 $761
ADDRLP4 72+80
INDIRI4
ADDRLP4 52
INDIRP4
CNSTI4 40
ADDP4
INDIRI4
NEI4 $757
LABELV $761
ADDRLP4 68
CNSTI4 1
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 160
ADDP4
INDIRI4
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
INDIRP4
CNSTI4 76
ADDP4
INDIRI4
NEI4 $762
ADDRLP4 368
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
ASGNP4
ADDRLP4 56
ADDRLP4 368
INDIRP4
INDIRP4
CNSTI4 80
ADDP4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4936
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 56+4
ADDRLP4 368
INDIRP4
INDIRP4
CNSTI4 84
ADDP4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4940
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 56+8
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
INDIRP4
CNSTI4 88
ADDP4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4944
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 56
ARGP4
ADDRLP4 308
ARGP4
ADDRGP4 vectoangles
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6560
ADDP4
ARGP4
CNSTF4 1101004800
ARGF4
ADDRLP4 308
ARGP4
ADDRLP4 376
ADDRGP4 InFieldOfVision
CALLI4
ASGNI4
ADDRLP4 376
INDIRI4
CNSTI4 0
EQI4 $766
ADDRFP4 0
INDIRP4
CNSTI4 8
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_EA_Attack
CALLV
pop
LABELV $766
LABELV $762
LABELV $757
LABELV $755
ADDRLP4 68
INDIRI4
CNSTI4 0
EQI4 $768
ADDRLP4 52
INDIRP4
CNSTI4 40
ADDP4
INDIRI4
ARGI4
ADDRLP4 156
ARGP4
ADDRGP4 BotEntityInfo
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
INDIRP4
CNSTI4 92
ADDP4
ARGP4
ADDRLP4 156+24
ARGP4
ADDRLP4 352
ADDRGP4 VectorCompare
CALLI4
ASGNI4
ADDRLP4 352
INDIRI4
CNSTI4 0
NEI4 $770
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
INDIRP4
CNSTI4 60
ADDP4
CNSTF4 0
ASGNF4
LABELV $770
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
INDIRP4
CNSTI4 60
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $773
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotPopFromActivateGoalStack
CALLI4
pop
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
INDIRP4
CVPU4 4
CNSTU4 0
EQU4 $775
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
INDIRP4
CNSTI4 60
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1092616192
ADDF4
ASGNF4
CNSTI4 0
RETI4
ADDRGP4 $737
JUMPV
LABELV $775
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $777
ARGP4
ADDRGP4 AIEnter_Seek_NBG
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $737
JUMPV
LABELV $773
ADDRLP4 0
ARGP4
CNSTI4 0
ARGI4
CNSTU4 52
ARGU4
ADDRGP4 qk_memset
CALLP4
pop
ADDRGP4 $769
JUMPV
LABELV $768
ADDRLP4 52
INDIRP4
CVPU4 4
CNSTU4 0
NEU4 $778
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
INDIRP4
CNSTI4 60
ADDP4
CNSTF4 0
ASGNF4
ADDRGP4 $779
JUMPV
LABELV $778
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
INDIRP4
CNSTI4 72
ADDP4
INDIRI4
CNSTI4 0
NEI4 $780
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRLP4 52
INDIRP4
ARGP4
ADDRLP4 352
ADDRGP4 trap_BotTouchingGoal
CALLI4
ASGNI4
ADDRLP4 352
INDIRI4
CNSTI4 0
EQI4 $782
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
INDIRP4
CNSTI4 60
ADDP4
CNSTF4 0
ASGNF4
LABELV $782
LABELV $780
LABELV $779
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
INDIRP4
CNSTI4 60
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $784
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotPopFromActivateGoalStack
CALLI4
pop
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
INDIRP4
CVPU4 4
CNSTU4 0
EQU4 $786
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
INDIRP4
CNSTI4 60
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1092616192
ADDF4
ASGNF4
CNSTI4 0
RETI4
ADDRGP4 $737
JUMPV
LABELV $786
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $788
ARGP4
ADDRGP4 AIEnter_Seek_NBG
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $737
JUMPV
LABELV $784
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 52
INDIRP4
ARGP4
ADDRLP4 352
ADDRGP4 BotAIPredictObstacles
CALLI4
ASGNI4
ADDRLP4 352
INDIRI4
CNSTI4 0
EQI4 $789
CNSTI4 0
RETI4
ADDRGP4 $737
JUMPV
LABELV $789
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotSetupForMovement
CALLV
pop
ADDRLP4 0
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRLP4 52
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotMoveToGoal
CALLV
pop
ADDRLP4 0
INDIRI4
CNSTI4 0
EQI4 $791
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetAvoidReach
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
INDIRP4
CNSTI4 60
ADDP4
CNSTF4 0
ASGNF4
LABELV $791
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 0
ARGP4
CNSTI4 1
ARGI4
ADDRGP4 BotAIBlocked
CALLV
pop
LABELV $769
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 0
ARGP4
ADDRGP4 BotClearPath
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
INDIRP4
CNSTI4 72
ADDP4
INDIRI4
CNSTI4 0
EQI4 $793
ADDRLP4 0+20
INDIRI4
CNSTI4 1
BANDI4
CNSTI4 0
NEI4 $795
ADDRLP4 356
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
ASGNP4
ADDRLP4 56
ADDRLP4 356
INDIRP4
INDIRP4
CNSTI4 80
ADDP4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4936
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 56+4
ADDRLP4 356
INDIRP4
INDIRP4
CNSTI4 84
ADDP4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4940
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 56+8
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
INDIRP4
CNSTI4 88
ADDP4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4944
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 56
ARGP4
ADDRLP4 0+40
ARGP4
ADDRGP4 vectoangles
CALLV
pop
ADDRLP4 0+20
ADDRLP4 0+20
INDIRI4
CNSTI4 1
BORI4
ASGNI4
LABELV $795
ADDRLP4 0+20
INDIRI4
CNSTI4 16
BANDI4
CNSTI4 0
NEI4 $802
ADDRLP4 0+20
ADDRLP4 0+20
INDIRI4
CNSTI4 16
BORI4
ASGNI4
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 356
ADDRGP4 BotSelectActivateWeapon
CALLI4
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
INDIRP4
CNSTI4 76
ADDP4
ADDRLP4 356
INDIRI4
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
INDIRP4
CNSTI4 76
ADDP4
INDIRI4
CNSTI4 -1
NEI4 $806
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
INDIRP4
CNSTI4 76
ADDP4
CNSTI4 0
ASGNI4
LABELV $806
ADDRLP4 0+24
ADDRFP4 0
INDIRP4
CNSTI4 7012
ADDP4
INDIRP4
CNSTI4 76
ADDP4
INDIRI4
ASGNI4
LABELV $802
LABELV $793
ADDRLP4 0+20
INDIRI4
CNSTI4 11
BANDI4
CNSTI4 0
EQI4 $809
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ADDRLP4 0+40
INDIRB
ASGNB 12
ADDRGP4 $810
JUMPV
LABELV $809
ADDRLP4 0+20
INDIRI4
CNSTI4 4
BANDI4
CNSTI4 0
EQI4 $813
ADDRLP4 352
ADDRGP4 qk_rand
CALLI4
ASGNI4
ADDRLP4 352
INDIRI4
CNSTI4 32767
BANDI4
CVIF4 4
CNSTF4 1191181824
DIVF4
CNSTF4 1061997773
ADDRFP4 0
INDIRP4
CNSTI4 4904
ADDP4
INDIRF4
MULF4
GEF4 $814
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 296
ARGP4
ADDRGP4 BotRoamGoal
CALLV
pop
ADDRLP4 56
ADDRLP4 296
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 56+4
ADDRLP4 296+4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4912
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 56+8
ADDRLP4 296+8
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4916
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 56
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ARGP4
ADDRGP4 vectoangles
CALLV
pop
ADDRLP4 360
ADDRFP4 0
INDIRP4
CNSTI4 6580
ADDP4
ASGNP4
ADDRLP4 360
INDIRP4
CNSTF4 1056964608
ADDRLP4 360
INDIRP4
INDIRF4
MULF4
ASGNF4
ADDRGP4 $814
JUMPV
LABELV $813
ADDRFP4 0
INDIRP4
CNSTI4 5980
ADDP4
INDIRI4
CNSTI4 32
BANDI4
CNSTI4 0
NEI4 $822
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRLP4 52
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
INDIRI4
ARGI4
CNSTF4 1133903872
ARGF4
ADDRLP4 296
ARGP4
ADDRLP4 356
ADDRGP4 trap_BotMovementViewTarget
CALLI4
ASGNI4
ADDRLP4 356
INDIRI4
CNSTI4 0
EQI4 $824
ADDRLP4 56
ADDRLP4 296
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 56+4
ADDRLP4 296+4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4912
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 56+8
ADDRLP4 296+8
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4916
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 56
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ARGP4
ADDRGP4 vectoangles
CALLV
pop
ADDRGP4 $825
JUMPV
LABELV $824
ADDRLP4 0+28
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ARGP4
ADDRGP4 vectoangles
CALLV
pop
LABELV $825
ADDRLP4 360
ADDRFP4 0
INDIRP4
CNSTI4 6580
ADDP4
ASGNP4
ADDRLP4 360
INDIRP4
CNSTF4 1056964608
ADDRLP4 360
INDIRP4
INDIRF4
MULF4
ASGNF4
LABELV $822
LABELV $814
LABELV $810
ADDRLP4 0+20
INDIRI4
CNSTI4 16
BANDI4
CNSTI4 0
EQI4 $831
ADDRFP4 0
INDIRP4
CNSTI4 6556
ADDP4
ADDRLP4 0+24
INDIRI4
ASGNI4
LABELV $831
ADDRFP4 0
INDIRP4
ARGP4
CNSTI4 -1
ARGI4
ADDRLP4 352
ADDRGP4 BotFindEnemy
CALLI4
ASGNI4
ADDRLP4 352
INDIRI4
CNSTI4 0
EQI4 $835
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 356
ADDRGP4 BotWantsToRetreat
CALLI4
ASGNI4
ADDRLP4 356
INDIRI4
CNSTI4 0
EQI4 $837
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $839
ARGP4
ADDRGP4 AIEnter_Battle_NBG
CALLV
pop
ADDRGP4 $838
JUMPV
LABELV $837
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetLastAvoidReach
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotEmptyGoalStack
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $839
ARGP4
ADDRGP4 AIEnter_Battle_Fight
CALLV
pop
LABELV $838
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotClearActivateGoalStack
CALLV
pop
LABELV $835
CNSTI4 1
RETI4
LABELV $737
endproc AINode_Seek_ActivateEntity 380 28
export AIEnter_Seek_NBG
proc AIEnter_Seek_NBG 204 16
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRLP4 0
ARGP4
ADDRLP4 200
ADDRGP4 trap_BotGetTopGoal
CALLI4
ASGNI4
ADDRLP4 200
INDIRI4
CNSTI4 0
EQI4 $841
ADDRLP4 0+44
INDIRI4
ARGI4
ADDRLP4 56
ARGP4
CNSTI4 144
ARGI4
ADDRGP4 trap_BotGoalName
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $844
ARGP4
ADDRLP4 56
ARGP4
ADDRFP4 4
INDIRP4
ARGP4
ADDRGP4 BotRecordNodeSwitch
CALLV
pop
ADDRGP4 $842
JUMPV
LABELV $841
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $844
ARGP4
ADDRGP4 $845
ARGP4
ADDRFP4 4
INDIRP4
ARGP4
ADDRGP4 BotRecordNodeSwitch
CALLV
pop
LABELV $842
ADDRFP4 0
INDIRP4
CNSTI4 4900
ADDP4
ADDRGP4 AINode_Seek_NBG
ASGNP4
LABELV $840
endproc AIEnter_Seek_NBG 204 16
export AINode_Seek_NBG
proc AINode_Seek_NBG 192 20
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 132
ADDRGP4 BotIsObserver
CALLI4
ASGNI4
ADDRLP4 132
INDIRI4
CNSTI4 0
EQI4 $847
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $849
ARGP4
ADDRGP4 AIEnter_Observer
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $846
JUMPV
LABELV $847
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 136
ADDRGP4 BotIntermission
CALLI4
ASGNI4
ADDRLP4 136
INDIRI4
CNSTI4 0
EQI4 $850
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $852
ARGP4
ADDRGP4 AIEnter_Intermission
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $846
JUMPV
LABELV $850
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 140
ADDRGP4 BotIsDead
CALLI4
ASGNI4
ADDRLP4 140
INDIRI4
CNSTI4 0
EQI4 $853
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $855
ARGP4
ADDRGP4 AIEnter_Respawn
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $846
JUMPV
LABELV $853
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
CNSTI4 18616254
ASGNI4
ADDRGP4 bot_grapple+12
INDIRI4
CNSTI4 0
EQI4 $856
ADDRLP4 144
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
ASGNP4
ADDRLP4 144
INDIRP4
ADDRLP4 144
INDIRP4
INDIRI4
CNSTI4 16384
BORI4
ASGNI4
LABELV $856
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 148
ADDRGP4 BotInLavaOrSlime
CALLI4
ASGNI4
ADDRLP4 148
INDIRI4
CNSTI4 0
EQI4 $859
ADDRLP4 152
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
ASGNP4
ADDRLP4 152
INDIRP4
ADDRLP4 152
INDIRP4
INDIRI4
CNSTI4 6291456
BORI4
ASGNI4
LABELV $859
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 156
ADDRGP4 BotCanAndWantsToRocketJump
CALLI4
ASGNI4
ADDRLP4 156
INDIRI4
CNSTI4 0
EQI4 $861
ADDRLP4 160
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
ASGNP4
ADDRLP4 160
INDIRP4
ADDRLP4 160
INDIRP4
INDIRI4
CNSTI4 4096
BORI4
ASGNI4
LABELV $861
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotMapScripts
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
CNSTI4 -1
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRLP4 52
ARGP4
ADDRLP4 160
ADDRGP4 trap_BotGetTopGoal
CALLI4
ASGNI4
ADDRLP4 160
INDIRI4
CNSTI4 0
NEI4 $863
ADDRFP4 0
INDIRP4
CNSTI4 6072
ADDP4
CNSTF4 0
ASGNF4
ADDRGP4 $864
JUMPV
LABELV $863
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 52
ARGP4
ADDRLP4 164
ADDRGP4 BotReachedGoal
CALLI4
ASGNI4
ADDRLP4 164
INDIRI4
CNSTI4 0
EQI4 $865
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotChooseWeapon
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6072
ADDP4
CNSTF4 0
ASGNF4
LABELV $865
LABELV $864
ADDRFP4 0
INDIRP4
CNSTI4 6072
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $867
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotPopGoal
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6092
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1028443341
ADDF4
ASGNF4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $869
ARGP4
ADDRGP4 AIEnter_Seek_LTG
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $846
JUMPV
LABELV $867
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 52
ARGP4
ADDRLP4 168
ADDRGP4 BotAIPredictObstacles
CALLI4
ASGNI4
ADDRLP4 168
INDIRI4
CNSTI4 0
EQI4 $870
CNSTI4 0
RETI4
ADDRGP4 $846
JUMPV
LABELV $870
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotSetupForMovement
CALLV
pop
ADDRLP4 0
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRLP4 52
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotMoveToGoal
CALLV
pop
ADDRLP4 0
INDIRI4
CNSTI4 0
EQI4 $872
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetAvoidReach
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6072
ADDP4
CNSTF4 0
ASGNF4
LABELV $872
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 0
ARGP4
CNSTI4 1
ARGI4
ADDRGP4 BotAIBlocked
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 0
ARGP4
ADDRGP4 BotClearPath
CALLV
pop
ADDRLP4 0+20
INDIRI4
CNSTI4 11
BANDI4
CNSTI4 0
EQI4 $874
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ADDRLP4 0+40
INDIRB
ASGNB 12
ADDRGP4 $875
JUMPV
LABELV $874
ADDRLP4 0+20
INDIRI4
CNSTI4 4
BANDI4
CNSTI4 0
EQI4 $878
ADDRLP4 176
ADDRGP4 qk_rand
CALLI4
ASGNI4
ADDRLP4 176
INDIRI4
CNSTI4 32767
BANDI4
CVIF4 4
CNSTF4 1191181824
DIVF4
CNSTF4 1061997773
ADDRFP4 0
INDIRP4
CNSTI4 4904
ADDP4
INDIRF4
MULF4
GEF4 $879
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 108
ARGP4
ADDRGP4 BotRoamGoal
CALLV
pop
ADDRLP4 120
ADDRLP4 108
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 120+4
ADDRLP4 108+4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4912
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 120+8
ADDRLP4 108+8
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4916
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 120
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ARGP4
ADDRGP4 vectoangles
CALLV
pop
ADDRLP4 184
ADDRFP4 0
INDIRP4
CNSTI4 6580
ADDP4
ASGNP4
ADDRLP4 184
INDIRP4
CNSTF4 1056964608
ADDRLP4 184
INDIRP4
INDIRF4
MULF4
ASGNF4
ADDRGP4 $879
JUMPV
LABELV $878
ADDRFP4 0
INDIRP4
CNSTI4 5980
ADDP4
INDIRI4
CNSTI4 32
BANDI4
CNSTI4 0
NEI4 $887
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRLP4 52
ARGP4
ADDRLP4 176
ADDRGP4 trap_BotGetSecondGoal
CALLI4
ASGNI4
ADDRLP4 176
INDIRI4
CNSTI4 0
NEI4 $889
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRLP4 52
ARGP4
ADDRGP4 trap_BotGetTopGoal
CALLI4
pop
LABELV $889
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRLP4 52
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
INDIRI4
ARGI4
CNSTF4 1133903872
ARGF4
ADDRLP4 108
ARGP4
ADDRLP4 184
ADDRGP4 trap_BotMovementViewTarget
CALLI4
ASGNI4
ADDRLP4 184
INDIRI4
CNSTI4 0
EQI4 $891
ADDRLP4 120
ADDRLP4 108
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 120+4
ADDRLP4 108+4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4912
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 120+8
ADDRLP4 108+8
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4916
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 120
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ARGP4
ADDRGP4 vectoangles
CALLV
pop
ADDRGP4 $892
JUMPV
LABELV $891
ADDRLP4 0+28
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ARGP4
ADDRGP4 vectoangles
CALLV
pop
LABELV $892
ADDRLP4 188
ADDRFP4 0
INDIRP4
CNSTI4 6580
ADDP4
ASGNP4
ADDRLP4 188
INDIRP4
CNSTF4 1056964608
ADDRLP4 188
INDIRP4
INDIRF4
MULF4
ASGNF4
LABELV $887
LABELV $879
LABELV $875
ADDRLP4 0+20
INDIRI4
CNSTI4 16
BANDI4
CNSTI4 0
EQI4 $898
ADDRFP4 0
INDIRP4
CNSTI4 6556
ADDP4
ADDRLP4 0+24
INDIRI4
ASGNI4
LABELV $898
ADDRFP4 0
INDIRP4
ARGP4
CNSTI4 -1
ARGI4
ADDRLP4 176
ADDRGP4 BotFindEnemy
CALLI4
ASGNI4
ADDRLP4 176
INDIRI4
CNSTI4 0
EQI4 $902
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 180
ADDRGP4 BotWantsToRetreat
CALLI4
ASGNI4
ADDRLP4 180
INDIRI4
CNSTI4 0
EQI4 $904
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $906
ARGP4
ADDRGP4 AIEnter_Battle_NBG
CALLV
pop
ADDRGP4 $905
JUMPV
LABELV $904
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetLastAvoidReach
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotEmptyGoalStack
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $906
ARGP4
ADDRGP4 AIEnter_Battle_Fight
CALLV
pop
LABELV $905
LABELV $902
CNSTI4 1
RETI4
LABELV $846
endproc AINode_Seek_NBG 192 20
export AIEnter_Seek_LTG
proc AIEnter_Seek_LTG 204 16
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRLP4 0
ARGP4
ADDRLP4 200
ADDRGP4 trap_BotGetTopGoal
CALLI4
ASGNI4
ADDRLP4 200
INDIRI4
CNSTI4 0
EQI4 $908
ADDRLP4 0+44
INDIRI4
ARGI4
ADDRLP4 56
ARGP4
CNSTI4 144
ARGI4
ADDRGP4 trap_BotGoalName
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $911
ARGP4
ADDRLP4 56
ARGP4
ADDRFP4 4
INDIRP4
ARGP4
ADDRGP4 BotRecordNodeSwitch
CALLV
pop
ADDRGP4 $909
JUMPV
LABELV $908
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $911
ARGP4
ADDRGP4 $845
ARGP4
ADDRFP4 4
INDIRP4
ARGP4
ADDRGP4 BotRecordNodeSwitch
CALLV
pop
LABELV $909
ADDRFP4 0
INDIRP4
CNSTI4 4900
ADDP4
ADDRGP4 AINode_Seek_LTG
ASGNP4
LABELV $907
endproc AIEnter_Seek_LTG 204 16
export AINode_Seek_LTG
proc AINode_Seek_LTG 212 20
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 136
ADDRGP4 BotIsObserver
CALLI4
ASGNI4
ADDRLP4 136
INDIRI4
CNSTI4 0
EQI4 $913
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $915
ARGP4
ADDRGP4 AIEnter_Observer
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $912
JUMPV
LABELV $913
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 140
ADDRGP4 BotIntermission
CALLI4
ASGNI4
ADDRLP4 140
INDIRI4
CNSTI4 0
EQI4 $916
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $918
ARGP4
ADDRGP4 AIEnter_Intermission
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $912
JUMPV
LABELV $916
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 144
ADDRGP4 BotIsDead
CALLI4
ASGNI4
ADDRLP4 144
INDIRI4
CNSTI4 0
EQI4 $919
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $921
ARGP4
ADDRGP4 AIEnter_Respawn
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $912
JUMPV
LABELV $919
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 148
ADDRGP4 BotChat_Random
CALLI4
ASGNI4
ADDRLP4 148
INDIRI4
CNSTI4 0
EQI4 $922
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 156
ADDRGP4 BotChatTime
CALLF4
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6096
ADDP4
ADDRGP4 floattime
INDIRF4
ADDRLP4 156
INDIRF4
ADDF4
ASGNF4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $924
ARGP4
ADDRGP4 AIEnter_Stand
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $912
JUMPV
LABELV $922
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
CNSTI4 18616254
ASGNI4
ADDRGP4 bot_grapple+12
INDIRI4
CNSTI4 0
EQI4 $925
ADDRLP4 152
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
ASGNP4
ADDRLP4 152
INDIRP4
ADDRLP4 152
INDIRP4
INDIRI4
CNSTI4 16384
BORI4
ASGNI4
LABELV $925
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 156
ADDRGP4 BotInLavaOrSlime
CALLI4
ASGNI4
ADDRLP4 156
INDIRI4
CNSTI4 0
EQI4 $928
ADDRLP4 160
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
ASGNP4
ADDRLP4 160
INDIRP4
ADDRLP4 160
INDIRP4
INDIRI4
CNSTI4 6291456
BORI4
ASGNI4
LABELV $928
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 164
ADDRGP4 BotCanAndWantsToRocketJump
CALLI4
ASGNI4
ADDRLP4 164
INDIRI4
CNSTI4 0
EQI4 $930
ADDRLP4 168
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
ASGNP4
ADDRLP4 168
INDIRP4
ADDRLP4 168
INDIRP4
INDIRI4
CNSTI4 4096
BORI4
ASGNI4
LABELV $930
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotMapScripts
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
CNSTI4 -1
ASGNI4
ADDRFP4 0
INDIRP4
CNSTI4 6168
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
CNSTF4 1073741824
SUBF4
LEF4 $932
ADDRLP4 168
ADDRGP4 qk_rand
CALLI4
ASGNI4
ADDRLP4 168
INDIRI4
CNSTI4 32767
BANDI4
CVIF4 4
CNSTF4 1191181824
DIVF4
CNSTF4 1065353216
ADDRFP4 0
INDIRP4
CNSTI4 4904
ADDP4
INDIRF4
MULF4
GEF4 $934
ADDRFP4 0
INDIRP4
CNSTI4 8
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_EA_Gesture
CALLV
pop
LABELV $934
LABELV $932
ADDRFP4 0
INDIRP4
ARGP4
CNSTI4 -1
ARGI4
ADDRLP4 168
ADDRGP4 BotFindEnemy
CALLI4
ASGNI4
ADDRLP4 168
INDIRI4
CNSTI4 0
EQI4 $936
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 172
ADDRGP4 BotWantsToRetreat
CALLI4
ASGNI4
ADDRLP4 172
INDIRI4
CNSTI4 0
EQI4 $938
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $940
ARGP4
ADDRGP4 AIEnter_Battle_Retreat
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $912
JUMPV
LABELV $938
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetLastAvoidReach
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotEmptyGoalStack
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $940
ARGP4
ADDRGP4 AIEnter_Battle_Fight
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $912
JUMPV
LABELV $936
ADDRFP4 0
INDIRP4
ARGP4
CNSTI4 0
ARGI4
ADDRGP4 BotTeamGoals
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
INDIRI4
ARGI4
CNSTI4 0
ARGI4
ADDRLP4 52
ARGP4
ADDRLP4 176
ADDRGP4 BotLongTermGoal
CALLI4
ASGNI4
ADDRLP4 176
INDIRI4
CNSTI4 0
NEI4 $941
CNSTI4 1
RETI4
ADDRGP4 $912
JUMPV
LABELV $941
ADDRFP4 0
INDIRP4
CNSTI4 6092
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $943
ADDRFP4 0
INDIRP4
CNSTI4 6092
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1056964608
ADDF4
ASGNF4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotWantsToCamp
CALLI4
pop
ADDRFP4 0
INDIRP4
CNSTI4 6596
ADDP4
INDIRI4
CNSTI4 3
NEI4 $945
ADDRLP4 108
CNSTI4 400
ASGNI4
ADDRGP4 $946
JUMPV
LABELV $945
ADDRLP4 108
CNSTI4 150
ASGNI4
LABELV $946
ADDRGP4 gametype
INDIRI4
CNSTI4 4
NEI4 $947
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 180
ADDRGP4 BotCTFCarryingFlag
CALLI4
ASGNI4
ADDRLP4 180
INDIRI4
CNSTI4 0
EQI4 $948
ADDRLP4 108
CNSTI4 50
ASGNI4
ADDRGP4 $948
JUMPV
LABELV $947
ADDRGP4 gametype
INDIRI4
CNSTI4 5
NEI4 $951
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 180
ADDRGP4 Bot1FCTFCarryingFlag
CALLI4
ASGNI4
ADDRLP4 180
INDIRI4
CNSTI4 0
EQI4 $952
ADDRLP4 108
CNSTI4 50
ASGNI4
ADDRGP4 $952
JUMPV
LABELV $951
ADDRGP4 gametype
INDIRI4
CNSTI4 7
NEI4 $955
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 180
ADDRGP4 BotHarvesterCarryingCubes
CALLI4
ASGNI4
ADDRLP4 180
INDIRI4
CNSTI4 0
EQI4 $957
ADDRLP4 108
CNSTI4 80
ASGNI4
LABELV $957
LABELV $955
LABELV $952
LABELV $948
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
INDIRI4
ARGI4
ADDRLP4 52
ARGP4
ADDRLP4 108
INDIRI4
CVIF4 4
ARGF4
ADDRLP4 184
ADDRGP4 BotNearbyGoal
CALLI4
ASGNI4
ADDRLP4 184
INDIRI4
CNSTI4 0
EQI4 $959
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetLastAvoidReach
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6072
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1082130432
ADDF4
CNSTF4 1008981770
ADDRLP4 108
INDIRI4
CVIF4 4
MULF4
ADDF4
ASGNF4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $961
ARGP4
ADDRGP4 AIEnter_Seek_NBG
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $912
JUMPV
LABELV $959
LABELV $943
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 52
ARGP4
ADDRLP4 180
ADDRGP4 BotAIPredictObstacles
CALLI4
ASGNI4
ADDRLP4 180
INDIRI4
CNSTI4 0
EQI4 $962
CNSTI4 0
RETI4
ADDRGP4 $912
JUMPV
LABELV $962
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotSetupForMovement
CALLV
pop
ADDRLP4 0
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRLP4 52
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotMoveToGoal
CALLV
pop
ADDRLP4 0
INDIRI4
CNSTI4 0
EQI4 $964
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetAvoidReach
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6068
ADDP4
CNSTF4 0
ASGNF4
LABELV $964
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 0
ARGP4
CNSTI4 1
ARGI4
ADDRGP4 BotAIBlocked
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 0
ARGP4
ADDRGP4 BotClearPath
CALLV
pop
ADDRLP4 0+20
INDIRI4
CNSTI4 11
BANDI4
CNSTI4 0
EQI4 $966
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ADDRLP4 0+40
INDIRB
ASGNB 12
ADDRGP4 $967
JUMPV
LABELV $966
ADDRLP4 0+20
INDIRI4
CNSTI4 4
BANDI4
CNSTI4 0
EQI4 $970
ADDRLP4 188
ADDRGP4 qk_rand
CALLI4
ASGNI4
ADDRLP4 188
INDIRI4
CNSTI4 32767
BANDI4
CVIF4 4
CNSTF4 1191181824
DIVF4
CNSTF4 1061997773
ADDRFP4 0
INDIRP4
CNSTI4 4904
ADDP4
INDIRF4
MULF4
GEF4 $971
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 112
ARGP4
ADDRGP4 BotRoamGoal
CALLV
pop
ADDRLP4 124
ADDRLP4 112
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 124+4
ADDRLP4 112+4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4912
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 124+8
ADDRLP4 112+8
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4916
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 124
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ARGP4
ADDRGP4 vectoangles
CALLV
pop
ADDRLP4 196
ADDRFP4 0
INDIRP4
CNSTI4 6580
ADDP4
ASGNP4
ADDRLP4 196
INDIRP4
CNSTF4 1056964608
ADDRLP4 196
INDIRP4
INDIRF4
MULF4
ASGNF4
ADDRGP4 $971
JUMPV
LABELV $970
ADDRFP4 0
INDIRP4
CNSTI4 5980
ADDP4
INDIRI4
CNSTI4 32
BANDI4
CNSTI4 0
NEI4 $979
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRLP4 52
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
INDIRI4
ARGI4
CNSTF4 1133903872
ARGF4
ADDRLP4 112
ARGP4
ADDRLP4 192
ADDRGP4 trap_BotMovementViewTarget
CALLI4
ASGNI4
ADDRLP4 192
INDIRI4
CNSTI4 0
EQI4 $981
ADDRLP4 124
ADDRLP4 112
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 124+4
ADDRLP4 112+4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4912
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 124+8
ADDRLP4 112+8
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4916
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 124
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ARGP4
ADDRGP4 vectoangles
CALLV
pop
ADDRGP4 $982
JUMPV
LABELV $981
ADDRLP4 0+28
ARGP4
ADDRLP4 196
ADDRGP4 VectorLengthSquared
CALLF4
ASGNF4
ADDRLP4 196
INDIRF4
CNSTF4 0
EQF4 $987
ADDRLP4 0+28
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ARGP4
ADDRGP4 vectoangles
CALLV
pop
ADDRGP4 $988
JUMPV
LABELV $987
ADDRLP4 200
ADDRGP4 qk_rand
CALLI4
ASGNI4
ADDRLP4 200
INDIRI4
CNSTI4 32767
BANDI4
CVIF4 4
CNSTF4 1191181824
DIVF4
CNSTF4 1061997773
ADDRFP4 0
INDIRP4
CNSTI4 4904
ADDP4
INDIRF4
MULF4
GEF4 $991
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 112
ARGP4
ADDRGP4 BotRoamGoal
CALLV
pop
ADDRLP4 124
ADDRLP4 112
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 124+4
ADDRLP4 112+4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4912
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 124+8
ADDRLP4 112+8
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4916
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 124
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ARGP4
ADDRGP4 vectoangles
CALLV
pop
ADDRLP4 208
ADDRFP4 0
INDIRP4
CNSTI4 6580
ADDP4
ASGNP4
ADDRLP4 208
INDIRP4
CNSTF4 1056964608
ADDRLP4 208
INDIRP4
INDIRF4
MULF4
ASGNF4
LABELV $991
LABELV $988
LABELV $982
ADDRLP4 204
ADDRFP4 0
INDIRP4
CNSTI4 6580
ADDP4
ASGNP4
ADDRLP4 204
INDIRP4
CNSTF4 1056964608
ADDRLP4 204
INDIRP4
INDIRF4
MULF4
ASGNF4
LABELV $979
LABELV $971
LABELV $967
ADDRLP4 0+20
INDIRI4
CNSTI4 16
BANDI4
CNSTI4 0
EQI4 $997
ADDRFP4 0
INDIRP4
CNSTI4 6556
ADDP4
ADDRLP4 0+24
INDIRI4
ASGNI4
LABELV $997
CNSTI4 1
RETI4
LABELV $912
endproc AINode_Seek_LTG 212 20
export AIEnter_Battle_Fight
proc AIEnter_Battle_Fight 4 16
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1002
ARGP4
ADDRGP4 $62
ARGP4
ADDRFP4 4
INDIRP4
ARGP4
ADDRGP4 BotRecordNodeSwitch
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetLastAvoidReach
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 4900
ADDP4
ADDRGP4 AINode_Battle_Fight
ASGNP4
ADDRLP4 0
ADDRFP4 0
INDIRP4
CNSTI4 5980
ADDP4
ASGNP4
ADDRLP4 0
INDIRP4
ADDRLP4 0
INDIRP4
INDIRI4
CNSTI4 -65
BANDI4
ASGNI4
LABELV $1001
endproc AIEnter_Battle_Fight 4 16
export AIEnter_Battle_SuicidalFight
proc AIEnter_Battle_SuicidalFight 4 16
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1002
ARGP4
ADDRGP4 $62
ARGP4
ADDRFP4 4
INDIRP4
ARGP4
ADDRGP4 BotRecordNodeSwitch
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetLastAvoidReach
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 4900
ADDP4
ADDRGP4 AINode_Battle_Fight
ASGNP4
ADDRLP4 0
ADDRFP4 0
INDIRP4
CNSTI4 5980
ADDP4
ASGNP4
ADDRLP4 0
INDIRP4
ADDRLP4 0
INDIRP4
INDIRI4
CNSTI4 64
BORI4
ASGNI4
LABELV $1003
endproc AIEnter_Battle_SuicidalFight 4 16
export AINode_Battle_Fight
proc AINode_Battle_Fight 292 20
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 208
ADDRGP4 BotIsObserver
CALLI4
ASGNI4
ADDRLP4 208
INDIRI4
CNSTI4 0
EQI4 $1005
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1007
ARGP4
ADDRGP4 AIEnter_Observer
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1004
JUMPV
LABELV $1005
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 212
ADDRGP4 BotIntermission
CALLI4
ASGNI4
ADDRLP4 212
INDIRI4
CNSTI4 0
EQI4 $1008
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1010
ARGP4
ADDRGP4 AIEnter_Intermission
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1004
JUMPV
LABELV $1008
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 216
ADDRGP4 BotIsDead
CALLI4
ASGNI4
ADDRLP4 216
INDIRI4
CNSTI4 0
EQI4 $1011
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1013
ARGP4
ADDRGP4 AIEnter_Respawn
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1004
JUMPV
LABELV $1011
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
ARGI4
ADDRLP4 224
ADDRGP4 BotFindEnemy
CALLI4
ASGNI4
ADDRLP4 224
INDIRI4
CNSTI4 0
EQI4 $1014
LABELV $1014
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
CNSTI4 0
GEI4 $1016
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1018
ARGP4
ADDRGP4 AIEnter_Seek_LTG
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1004
JUMPV
LABELV $1016
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
ARGI4
ADDRLP4 0
ARGP4
ADDRGP4 BotEntityInfo
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6136
ADDP4
INDIRF4
CNSTF4 0
EQF4 $1019
ADDRFP4 0
INDIRP4
CNSTI4 6136
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
CNSTF4 1065353216
SUBF4
GEF4 $1020
ADDRFP4 0
INDIRP4
CNSTI4 6136
ADDP4
CNSTF4 0
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6012
ADDP4
INDIRI4
CNSTI4 0
EQI4 $1023
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotChat_EnemySuicide
CALLI4
pop
LABELV $1023
ADDRFP4 0
INDIRP4
CNSTI4 5992
ADDP4
INDIRI4
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
NEI4 $1025
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 232
ADDRGP4 BotChat_Kill
CALLI4
ASGNI4
ADDRLP4 232
INDIRI4
CNSTI4 0
EQI4 $1025
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 240
ADDRGP4 BotChatTime
CALLF4
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6096
ADDP4
ADDRGP4 floattime
INDIRF4
ADDRLP4 240
INDIRF4
ADDF4
ASGNF4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1027
ARGP4
ADDRGP4 AIEnter_Stand
CALLV
pop
ADDRGP4 $1026
JUMPV
LABELV $1025
ADDRFP4 0
INDIRP4
CNSTI4 6068
ADDP4
CNSTF4 0
ASGNF4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1027
ARGP4
ADDRGP4 AIEnter_Seek_LTG
CALLV
pop
LABELV $1026
CNSTI4 0
RETI4
ADDRGP4 $1004
JUMPV
LABELV $1019
ADDRLP4 0
ARGP4
ADDRLP4 228
ADDRGP4 EntityIsDead
CALLI4
ASGNI4
ADDRLP4 228
INDIRI4
CNSTI4 0
EQI4 $1028
ADDRFP4 0
INDIRP4
CNSTI4 6136
ADDP4
ADDRGP4 floattime
INDIRF4
ASGNF4
LABELV $1028
LABELV $1020
ADDRLP4 0
ARGP4
ADDRLP4 228
ADDRGP4 EntityIsInvisible
CALLI4
ASGNI4
ADDRLP4 228
INDIRI4
CNSTI4 0
EQI4 $1030
ADDRLP4 0
ARGP4
ADDRLP4 232
ADDRGP4 EntityIsShooting
CALLI4
ASGNI4
ADDRLP4 232
INDIRI4
CNSTI4 0
NEI4 $1030
ADDRLP4 236
ADDRGP4 qk_rand
CALLI4
ASGNI4
ADDRLP4 236
INDIRI4
CNSTI4 32767
BANDI4
CVIF4 4
CNSTF4 1191181824
DIVF4
CNSTF4 1045220557
GEF4 $1032
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1034
ARGP4
ADDRGP4 AIEnter_Seek_LTG
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1004
JUMPV
LABELV $1032
LABELV $1030
ADDRLP4 196
ADDRLP4 0+24
INDIRB
ASGNB 12
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
CNSTI4 64
LTI4 $1036
ADDRLP4 236
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
ASGNI4
ADDRLP4 236
INDIRI4
ADDRGP4 redobelisk+40
INDIRI4
EQI4 $1042
ADDRLP4 236
INDIRI4
ADDRGP4 blueobelisk+40
INDIRI4
NEI4 $1038
LABELV $1042
ADDRLP4 196+8
ADDRLP4 196+8
INDIRF4
CNSTF4 1098907648
ADDF4
ASGNF4
LABELV $1038
LABELV $1036
ADDRLP4 196
ARGP4
ADDRLP4 236
ADDRGP4 BotPointAreaNum
CALLI4
ASGNI4
ADDRLP4 192
ADDRLP4 236
INDIRI4
ASGNI4
ADDRLP4 192
INDIRI4
CNSTI4 0
EQI4 $1044
ADDRLP4 192
INDIRI4
ARGI4
ADDRLP4 244
ADDRGP4 trap_AAS_AreaReachability
CALLI4
ASGNI4
ADDRLP4 244
INDIRI4
CNSTI4 0
EQI4 $1044
ADDRFP4 0
INDIRP4
CNSTI4 6544
ADDP4
ADDRLP4 196
INDIRB
ASGNB 12
ADDRFP4 0
INDIRP4
CNSTI4 6540
ADDP4
ADDRLP4 192
INDIRI4
ASGNI4
LABELV $1044
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
ARGI4
ADDRGP4 BotUpdateBattleInventory
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6044
ADDP4
INDIRI4
ADDRFP4 0
INDIRP4
CNSTI4 5068
ADDP4
INDIRI4
LEI4 $1046
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 256
ADDRGP4 BotChat_HitNoDeath
CALLI4
ASGNI4
ADDRLP4 256
INDIRI4
CNSTI4 0
EQI4 $1048
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 264
ADDRGP4 BotChatTime
CALLF4
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6096
ADDP4
ADDRGP4 floattime
INDIRF4
ADDRLP4 264
INDIRF4
ADDF4
ASGNF4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1050
ARGP4
ADDRGP4 AIEnter_Stand
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1004
JUMPV
LABELV $1048
LABELV $1046
ADDRFP4 0
INDIRP4
CNSTI4 268
ADDP4
INDIRI4
ADDRFP4 0
INDIRP4
CNSTI4 6048
ADDP4
INDIRI4
LEI4 $1051
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 260
ADDRGP4 BotChat_HitNoKill
CALLI4
ASGNI4
ADDRLP4 260
INDIRI4
CNSTI4 0
EQI4 $1053
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 268
ADDRGP4 BotChatTime
CALLF4
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6096
ADDP4
ADDRGP4 floattime
INDIRF4
ADDRLP4 268
INDIRF4
ADDF4
ASGNF4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1055
ARGP4
ADDRGP4 AIEnter_Stand
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1004
JUMPV
LABELV $1053
LABELV $1051
ADDRFP4 0
INDIRP4
CNSTI4 12
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 4936
ADDP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6560
ADDP4
ARGP4
CNSTF4 1135869952
ARGF4
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
ARGI4
ADDRLP4 264
ADDRGP4 BotEntityVisible
CALLF4
ASGNF4
ADDRLP4 264
INDIRF4
CNSTF4 0
NEF4 $1056
ADDRLP4 268
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
ASGNI4
ADDRLP4 268
INDIRI4
ADDRGP4 redobelisk+40
INDIRI4
EQI4 $1062
ADDRLP4 268
INDIRI4
ADDRGP4 blueobelisk+40
INDIRI4
NEI4 $1058
LABELV $1062
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1063
ARGP4
ADDRGP4 AIEnter_Battle_Chase
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1004
JUMPV
LABELV $1058
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 272
ADDRGP4 BotWantsToChase
CALLI4
ASGNI4
ADDRLP4 272
INDIRI4
CNSTI4 0
EQI4 $1064
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1066
ARGP4
ADDRGP4 AIEnter_Battle_Chase
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1004
JUMPV
LABELV $1064
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1066
ARGP4
ADDRGP4 AIEnter_Seek_LTG
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1004
JUMPV
LABELV $1056
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotBattleUseItems
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
CNSTI4 18616254
ASGNI4
ADDRGP4 bot_grapple+12
INDIRI4
CNSTI4 0
EQI4 $1067
ADDRLP4 268
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
ASGNP4
ADDRLP4 268
INDIRP4
ADDRLP4 268
INDIRP4
INDIRI4
CNSTI4 16384
BORI4
ASGNI4
LABELV $1067
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 272
ADDRGP4 BotInLavaOrSlime
CALLI4
ASGNI4
ADDRLP4 272
INDIRI4
CNSTI4 0
EQI4 $1070
ADDRLP4 276
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
ASGNP4
ADDRLP4 276
INDIRP4
ADDRLP4 276
INDIRP4
INDIRI4
CNSTI4 6291456
BORI4
ASGNI4
LABELV $1070
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 280
ADDRGP4 BotCanAndWantsToRocketJump
CALLI4
ASGNI4
ADDRLP4 280
INDIRI4
CNSTI4 0
EQI4 $1072
ADDRLP4 284
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
ASGNP4
ADDRLP4 284
INDIRP4
ADDRLP4 284
INDIRP4
INDIRI4
CNSTI4 4096
BORI4
ASGNI4
LABELV $1072
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotChooseWeapon
CALLV
pop
ADDRLP4 140
ARGP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
INDIRI4
ARGI4
ADDRGP4 BotAttackMove
CALLV
pop
ADDRLP4 140
INDIRI4
CNSTI4 0
EQI4 $1074
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetAvoidReach
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6068
ADDP4
CNSTF4 0
ASGNF4
LABELV $1074
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 140
ARGP4
CNSTI4 0
ARGI4
ADDRGP4 BotAIBlocked
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotAimAtEnemy
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotCheckAttack
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 5980
ADDP4
INDIRI4
CNSTI4 64
BANDI4
CNSTI4 0
NEI4 $1076
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 288
ADDRGP4 BotWantsToRetreat
CALLI4
ASGNI4
ADDRLP4 288
INDIRI4
CNSTI4 0
EQI4 $1078
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1080
ARGP4
ADDRGP4 AIEnter_Battle_Retreat
CALLV
pop
CNSTI4 1
RETI4
ADDRGP4 $1004
JUMPV
LABELV $1078
LABELV $1076
CNSTI4 1
RETI4
LABELV $1004
endproc AINode_Battle_Fight 292 20
export AIEnter_Battle_Chase
proc AIEnter_Battle_Chase 0 16
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1082
ARGP4
ADDRGP4 $62
ARGP4
ADDRFP4 4
INDIRP4
ARGP4
ADDRGP4 BotRecordNodeSwitch
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6084
ADDP4
ADDRGP4 floattime
INDIRF4
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 4900
ADDP4
ADDRGP4 AINode_Battle_Chase
ASGNP4
LABELV $1081
endproc AIEnter_Battle_Chase 0 16
export AINode_Battle_Chase
proc AINode_Battle_Chase 204 20
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 136
ADDRGP4 BotIsObserver
CALLI4
ASGNI4
ADDRLP4 136
INDIRI4
CNSTI4 0
EQI4 $1084
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1086
ARGP4
ADDRGP4 AIEnter_Observer
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1083
JUMPV
LABELV $1084
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 140
ADDRGP4 BotIntermission
CALLI4
ASGNI4
ADDRLP4 140
INDIRI4
CNSTI4 0
EQI4 $1087
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1089
ARGP4
ADDRGP4 AIEnter_Intermission
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1083
JUMPV
LABELV $1087
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 144
ADDRGP4 BotIsDead
CALLI4
ASGNI4
ADDRLP4 144
INDIRI4
CNSTI4 0
EQI4 $1090
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1092
ARGP4
ADDRGP4 AIEnter_Respawn
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1083
JUMPV
LABELV $1090
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
CNSTI4 0
GEI4 $1093
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1095
ARGP4
ADDRGP4 AIEnter_Seek_LTG
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1083
JUMPV
LABELV $1093
ADDRFP4 0
INDIRP4
CNSTI4 12
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 4936
ADDP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6560
ADDP4
ARGP4
CNSTF4 1135869952
ARGF4
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
ARGI4
ADDRLP4 152
ADDRGP4 BotEntityVisible
CALLF4
ASGNF4
ADDRLP4 152
INDIRF4
CNSTF4 0
EQF4 $1096
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1082
ARGP4
ADDRGP4 AIEnter_Battle_Fight
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1083
JUMPV
LABELV $1096
ADDRFP4 0
INDIRP4
ARGP4
CNSTI4 -1
ARGI4
ADDRLP4 156
ADDRGP4 BotFindEnemy
CALLI4
ASGNI4
ADDRLP4 156
INDIRI4
CNSTI4 0
EQI4 $1098
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1100
ARGP4
ADDRGP4 AIEnter_Battle_Fight
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1083
JUMPV
LABELV $1098
ADDRFP4 0
INDIRP4
CNSTI4 6540
ADDP4
INDIRI4
CNSTI4 0
NEI4 $1101
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1103
ARGP4
ADDRGP4 AIEnter_Seek_LTG
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1083
JUMPV
LABELV $1101
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
CNSTI4 18616254
ASGNI4
ADDRGP4 bot_grapple+12
INDIRI4
CNSTI4 0
EQI4 $1104
ADDRLP4 160
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
ASGNP4
ADDRLP4 160
INDIRP4
ADDRLP4 160
INDIRP4
INDIRI4
CNSTI4 16384
BORI4
ASGNI4
LABELV $1104
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 164
ADDRGP4 BotInLavaOrSlime
CALLI4
ASGNI4
ADDRLP4 164
INDIRI4
CNSTI4 0
EQI4 $1107
ADDRLP4 168
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
ASGNP4
ADDRLP4 168
INDIRP4
ADDRLP4 168
INDIRP4
INDIRI4
CNSTI4 6291456
BORI4
ASGNI4
LABELV $1107
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 172
ADDRGP4 BotCanAndWantsToRocketJump
CALLI4
ASGNI4
ADDRLP4 172
INDIRI4
CNSTI4 0
EQI4 $1109
ADDRLP4 176
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
ASGNP4
ADDRLP4 176
INDIRP4
ADDRLP4 176
INDIRP4
INDIRI4
CNSTI4 4096
BORI4
ASGNI4
LABELV $1109
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotMapScripts
CALLV
pop
ADDRLP4 0+40
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
ASGNI4
ADDRLP4 0+12
ADDRFP4 0
INDIRP4
CNSTI4 6540
ADDP4
INDIRI4
ASGNI4
ADDRLP4 0
ADDRFP4 0
INDIRP4
CNSTI4 6544
ADDP4
INDIRB
ASGNB 12
ADDRLP4 0+16
CNSTF4 3238002688
ASGNF4
ADDRLP4 0+16+4
CNSTF4 3238002688
ASGNF4
ADDRLP4 0+16+8
CNSTF4 3238002688
ASGNF4
ADDRLP4 0+28
CNSTF4 1090519040
ASGNF4
ADDRLP4 0+28+4
CNSTF4 1090519040
ASGNF4
ADDRLP4 0+28+8
CNSTF4 1090519040
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
ARGP4
ADDRLP4 0
ARGP4
ADDRLP4 176
ADDRGP4 trap_BotTouchingGoal
CALLI4
ASGNI4
ADDRLP4 176
INDIRI4
CNSTI4 0
EQI4 $1123
ADDRFP4 0
INDIRP4
CNSTI4 6084
ADDP4
CNSTF4 0
ASGNF4
LABELV $1123
ADDRLP4 180
ADDRFP4 0
INDIRP4
CNSTI4 6084
ADDP4
INDIRF4
ASGNF4
ADDRLP4 180
INDIRF4
CNSTF4 0
EQF4 $1127
ADDRLP4 180
INDIRF4
ADDRGP4 floattime
INDIRF4
CNSTF4 1092616192
SUBF4
GEF4 $1125
LABELV $1127
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1128
ARGP4
ADDRGP4 AIEnter_Seek_LTG
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1083
JUMPV
LABELV $1125
ADDRFP4 0
INDIRP4
CNSTI4 6092
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $1129
ADDRFP4 0
INDIRP4
CNSTI4 6092
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1065353216
ADDF4
ASGNF4
ADDRLP4 108
CNSTF4 1125515264
ASGNF4
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
INDIRI4
ARGI4
ADDRLP4 0
ARGP4
ADDRLP4 108
INDIRF4
ARGF4
ADDRLP4 188
ADDRGP4 BotNearbyGoal
CALLI4
ASGNI4
ADDRLP4 188
INDIRI4
CNSTI4 0
EQI4 $1131
ADDRFP4 0
INDIRP4
CNSTI4 6072
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1036831949
ADDRLP4 108
INDIRF4
MULF4
ADDF4
CNSTF4 1065353216
ADDF4
ASGNF4
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetLastAvoidReach
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1133
ARGP4
ADDRGP4 AIEnter_Battle_NBG
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1083
JUMPV
LABELV $1131
LABELV $1129
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
ARGI4
ADDRGP4 BotUpdateBattleInventory
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotSetupForMovement
CALLV
pop
ADDRLP4 56
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRLP4 0
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotMoveToGoal
CALLV
pop
ADDRLP4 56
INDIRI4
CNSTI4 0
EQI4 $1134
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetAvoidReach
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6068
ADDP4
CNSTF4 0
ASGNF4
LABELV $1134
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 56
ARGP4
CNSTI4 0
ARGI4
ADDRGP4 BotAIBlocked
CALLV
pop
ADDRLP4 56+20
INDIRI4
CNSTI4 11
BANDI4
CNSTI4 0
EQI4 $1136
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ADDRLP4 56+40
INDIRB
ASGNB 12
ADDRGP4 $1137
JUMPV
LABELV $1136
ADDRFP4 0
INDIRP4
CNSTI4 5980
ADDP4
INDIRI4
CNSTI4 32
BANDI4
CNSTI4 0
NEI4 $1140
ADDRFP4 0
INDIRP4
CNSTI4 6084
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
CNSTF4 1073741824
SUBF4
LEF4 $1142
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotAimAtEnemy
CALLV
pop
ADDRGP4 $1143
JUMPV
LABELV $1142
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRLP4 0
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
INDIRI4
ARGI4
CNSTF4 1133903872
ARGF4
ADDRLP4 112
ARGP4
ADDRLP4 196
ADDRGP4 trap_BotMovementViewTarget
CALLI4
ASGNI4
ADDRLP4 196
INDIRI4
CNSTI4 0
EQI4 $1144
ADDRLP4 124
ADDRLP4 112
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 124+4
ADDRLP4 112+4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4912
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 124+8
ADDRLP4 112+8
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4916
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 124
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ARGP4
ADDRGP4 vectoangles
CALLV
pop
ADDRGP4 $1145
JUMPV
LABELV $1144
ADDRLP4 56+28
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ARGP4
ADDRGP4 vectoangles
CALLV
pop
LABELV $1145
LABELV $1143
ADDRLP4 192
ADDRFP4 0
INDIRP4
CNSTI4 6580
ADDP4
ASGNP4
ADDRLP4 192
INDIRP4
CNSTF4 1056964608
ADDRLP4 192
INDIRP4
INDIRF4
MULF4
ASGNF4
LABELV $1140
LABELV $1137
ADDRLP4 56+20
INDIRI4
CNSTI4 16
BANDI4
CNSTI4 0
EQI4 $1151
ADDRFP4 0
INDIRP4
CNSTI4 6556
ADDP4
ADDRLP4 56+24
INDIRI4
ASGNI4
LABELV $1151
ADDRFP4 0
INDIRP4
CNSTI4 4948
ADDP4
INDIRI4
ADDRFP4 0
INDIRP4
CNSTI4 6540
ADDP4
INDIRI4
NEI4 $1155
ADDRFP4 0
INDIRP4
CNSTI4 6084
ADDP4
CNSTF4 0
ASGNF4
LABELV $1155
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 196
ADDRGP4 BotWantsToRetreat
CALLI4
ASGNI4
ADDRLP4 196
INDIRI4
CNSTI4 0
EQI4 $1157
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1159
ARGP4
ADDRGP4 AIEnter_Battle_Retreat
CALLV
pop
CNSTI4 1
RETI4
ADDRGP4 $1083
JUMPV
LABELV $1157
CNSTI4 1
RETI4
LABELV $1083
endproc AINode_Battle_Chase 204 20
export AIEnter_Battle_Retreat
proc AIEnter_Battle_Retreat 0 16
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1161
ARGP4
ADDRGP4 $62
ARGP4
ADDRFP4 4
INDIRP4
ARGP4
ADDRGP4 BotRecordNodeSwitch
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 4900
ADDP4
ADDRGP4 AINode_Battle_Retreat
ASGNP4
LABELV $1160
endproc AIEnter_Battle_Retreat 0 16
export AINode_Battle_Retreat
proc AINode_Battle_Retreat 368 20
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 284
ADDRGP4 BotIsObserver
CALLI4
ASGNI4
ADDRLP4 284
INDIRI4
CNSTI4 0
EQI4 $1163
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1165
ARGP4
ADDRGP4 AIEnter_Observer
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1162
JUMPV
LABELV $1163
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 288
ADDRGP4 BotIntermission
CALLI4
ASGNI4
ADDRLP4 288
INDIRI4
CNSTI4 0
EQI4 $1166
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1168
ARGP4
ADDRGP4 AIEnter_Intermission
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1162
JUMPV
LABELV $1166
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 292
ADDRGP4 BotIsDead
CALLI4
ASGNI4
ADDRLP4 292
INDIRI4
CNSTI4 0
EQI4 $1169
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1171
ARGP4
ADDRGP4 AIEnter_Respawn
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1162
JUMPV
LABELV $1169
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
CNSTI4 0
GEI4 $1172
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1174
ARGP4
ADDRGP4 AIEnter_Seek_LTG
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1162
JUMPV
LABELV $1172
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
ARGI4
ADDRLP4 108
ARGP4
ADDRGP4 BotEntityInfo
CALLV
pop
ADDRLP4 108
ARGP4
ADDRLP4 296
ADDRGP4 EntityIsDead
CALLI4
ASGNI4
ADDRLP4 296
INDIRI4
CNSTI4 0
EQI4 $1175
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1177
ARGP4
ADDRGP4 AIEnter_Seek_LTG
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1162
JUMPV
LABELV $1175
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
ARGI4
ADDRLP4 304
ADDRGP4 BotFindEnemy
CALLI4
ASGNI4
ADDRLP4 304
INDIRI4
CNSTI4 0
EQI4 $1178
LABELV $1178
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
CNSTI4 18616254
ASGNI4
ADDRGP4 bot_grapple+12
INDIRI4
CNSTI4 0
EQI4 $1180
ADDRLP4 308
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
ASGNP4
ADDRLP4 308
INDIRP4
ADDRLP4 308
INDIRP4
INDIRI4
CNSTI4 16384
BORI4
ASGNI4
LABELV $1180
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 312
ADDRGP4 BotInLavaOrSlime
CALLI4
ASGNI4
ADDRLP4 312
INDIRI4
CNSTI4 0
EQI4 $1183
ADDRLP4 316
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
ASGNP4
ADDRLP4 316
INDIRP4
ADDRLP4 316
INDIRP4
INDIRI4
CNSTI4 6291456
BORI4
ASGNI4
LABELV $1183
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotMapScripts
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
ARGI4
ADDRGP4 BotUpdateBattleInventory
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 324
ADDRGP4 BotWantsToChase
CALLI4
ASGNI4
ADDRLP4 324
INDIRI4
CNSTI4 0
EQI4 $1185
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotEmptyGoalStack
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1187
ARGP4
ADDRGP4 AIEnter_Battle_Chase
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1162
JUMPV
LABELV $1185
ADDRFP4 0
INDIRP4
CNSTI4 12
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 4936
ADDP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6560
ADDP4
ARGP4
CNSTF4 1135869952
ARGF4
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
ARGI4
ADDRLP4 332
ADDRGP4 BotEntityVisible
CALLF4
ASGNF4
ADDRLP4 332
INDIRF4
CNSTF4 0
EQF4 $1188
ADDRFP4 0
INDIRP4
CNSTI4 6088
ADDP4
ADDRGP4 floattime
INDIRF4
ASGNF4
ADDRLP4 252
ADDRLP4 108+24
INDIRB
ASGNB 12
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
CNSTI4 64
LTI4 $1191
ADDRLP4 336
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
ASGNI4
ADDRLP4 336
INDIRI4
ADDRGP4 redobelisk+40
INDIRI4
EQI4 $1197
ADDRLP4 336
INDIRI4
ADDRGP4 blueobelisk+40
INDIRI4
NEI4 $1193
LABELV $1197
ADDRLP4 252+8
ADDRLP4 252+8
INDIRF4
CNSTF4 1098907648
ADDF4
ASGNF4
LABELV $1193
LABELV $1191
ADDRLP4 252
ARGP4
ADDRLP4 336
ADDRGP4 BotPointAreaNum
CALLI4
ASGNI4
ADDRLP4 248
ADDRLP4 336
INDIRI4
ASGNI4
ADDRLP4 340
ADDRLP4 248
INDIRI4
ASGNI4
ADDRLP4 340
INDIRI4
CNSTI4 0
EQI4 $1199
ADDRLP4 340
INDIRI4
ARGI4
ADDRLP4 344
ADDRGP4 trap_AAS_AreaReachability
CALLI4
ASGNI4
ADDRLP4 344
INDIRI4
CNSTI4 0
EQI4 $1199
ADDRFP4 0
INDIRP4
CNSTI4 6544
ADDP4
ADDRLP4 252
INDIRB
ASGNB 12
ADDRFP4 0
INDIRP4
CNSTI4 6540
ADDP4
ADDRLP4 248
INDIRI4
ASGNI4
LABELV $1199
LABELV $1188
ADDRFP4 0
INDIRP4
CNSTI4 6088
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
CNSTF4 1082130432
SUBF4
GEF4 $1201
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1203
ARGP4
ADDRGP4 AIEnter_Seek_LTG
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1162
JUMPV
LABELV $1201
ADDRFP4 0
INDIRP4
CNSTI4 6088
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $1204
ADDRFP4 0
INDIRP4
ARGP4
CNSTI4 -1
ARGI4
ADDRLP4 336
ADDRGP4 BotFindEnemy
CALLI4
ASGNI4
ADDRLP4 336
INDIRI4
CNSTI4 0
EQI4 $1206
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1208
ARGP4
ADDRGP4 AIEnter_Battle_Fight
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1162
JUMPV
LABELV $1206
LABELV $1204
ADDRFP4 0
INDIRP4
ARGP4
CNSTI4 1
ARGI4
ADDRGP4 BotTeamGoals
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotBattleUseItems
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
INDIRI4
ARGI4
CNSTI4 1
ARGI4
ADDRLP4 52
ARGP4
ADDRLP4 340
ADDRGP4 BotLongTermGoal
CALLI4
ASGNI4
ADDRLP4 340
INDIRI4
CNSTI4 0
NEI4 $1209
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1211
ARGP4
ADDRGP4 AIEnter_Battle_SuicidalFight
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1162
JUMPV
LABELV $1209
ADDRFP4 0
INDIRP4
CNSTI4 6092
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $1212
ADDRFP4 0
INDIRP4
CNSTI4 6092
ADDP4
ADDRGP4 floattime
INDIRF4
CNSTF4 1065353216
ADDF4
ASGNF4
ADDRLP4 264
CNSTF4 1125515264
ASGNF4
ADDRGP4 gametype
INDIRI4
CNSTI4 4
NEI4 $1214
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 344
ADDRGP4 BotCTFCarryingFlag
CALLI4
ASGNI4
ADDRLP4 344
INDIRI4
CNSTI4 0
EQI4 $1215
ADDRLP4 264
CNSTF4 1112014848
ASGNF4
ADDRGP4 $1215
JUMPV
LABELV $1214
ADDRGP4 gametype
INDIRI4
CNSTI4 5
NEI4 $1218
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 344
ADDRGP4 Bot1FCTFCarryingFlag
CALLI4
ASGNI4
ADDRLP4 344
INDIRI4
CNSTI4 0
EQI4 $1219
ADDRLP4 264
CNSTF4 1112014848
ASGNF4
ADDRGP4 $1219
JUMPV
LABELV $1218
ADDRGP4 gametype
INDIRI4
CNSTI4 7
NEI4 $1222
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 344
ADDRGP4 BotHarvesterCarryingCubes
CALLI4
ASGNI4
ADDRLP4 344
INDIRI4
CNSTI4 0
EQI4 $1224
ADDRLP4 264
CNSTF4 1117782016
ASGNF4
LABELV $1224
LABELV $1222
LABELV $1219
LABELV $1215
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
INDIRI4
ARGI4
ADDRLP4 52
ARGP4
ADDRLP4 264
INDIRF4
ARGF4
ADDRLP4 348
ADDRGP4 BotNearbyGoal
CALLI4
ASGNI4
ADDRLP4 348
INDIRI4
CNSTI4 0
EQI4 $1226
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetLastAvoidReach
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6072
ADDP4
ADDRGP4 floattime
INDIRF4
ADDRLP4 264
INDIRF4
CNSTF4 1120403456
DIVF4
ADDF4
CNSTF4 1065353216
ADDF4
ASGNF4
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1228
ARGP4
ADDRGP4 AIEnter_Battle_NBG
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1162
JUMPV
LABELV $1226
LABELV $1212
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotSetupForMovement
CALLV
pop
ADDRLP4 0
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRLP4 52
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotMoveToGoal
CALLV
pop
ADDRLP4 0
INDIRI4
CNSTI4 0
EQI4 $1229
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetAvoidReach
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6068
ADDP4
CNSTF4 0
ASGNF4
LABELV $1229
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 0
ARGP4
CNSTI4 0
ARGI4
ADDRGP4 BotAIBlocked
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotChooseWeapon
CALLV
pop
ADDRLP4 0+20
INDIRI4
CNSTI4 3
BANDI4
CNSTI4 0
EQI4 $1231
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ADDRLP4 0+40
INDIRB
ASGNB 12
ADDRGP4 $1232
JUMPV
LABELV $1231
ADDRLP4 348
CNSTI4 0
ASGNI4
ADDRLP4 0+20
INDIRI4
CNSTI4 8
BANDI4
ADDRLP4 348
INDIRI4
NEI4 $1235
ADDRFP4 0
INDIRP4
CNSTI4 5980
ADDP4
INDIRI4
CNSTI4 32
BANDI4
ADDRLP4 348
INDIRI4
NEI4 $1235
ADDRFP4 0
INDIRP4
CNSTI4 6516
ADDP4
INDIRI4
ARGI4
CNSTI4 2
ARGI4
CNSTF4 0
ARGF4
CNSTF4 1065353216
ARGF4
ADDRLP4 352
ADDRGP4 trap_Characteristic_BFloat
CALLF4
ASGNF4
ADDRLP4 268
ADDRLP4 352
INDIRF4
ASGNF4
ADDRLP4 268
INDIRF4
CNSTF4 1050253722
LEF4 $1238
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotAimAtEnemy
CALLV
pop
ADDRGP4 $1239
JUMPV
LABELV $1238
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRLP4 52
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
INDIRI4
ARGI4
CNSTF4 1133903872
ARGF4
ADDRLP4 252
ARGP4
ADDRLP4 360
ADDRGP4 trap_BotMovementViewTarget
CALLI4
ASGNI4
ADDRLP4 360
INDIRI4
CNSTI4 0
EQI4 $1240
ADDRLP4 272
ADDRLP4 252
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 272+4
ADDRLP4 252+4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4912
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 272+8
ADDRLP4 252+8
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4916
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 272
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ARGP4
ADDRGP4 vectoangles
CALLV
pop
ADDRGP4 $1241
JUMPV
LABELV $1240
ADDRLP4 0+28
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ARGP4
ADDRGP4 vectoangles
CALLV
pop
LABELV $1241
ADDRLP4 364
ADDRFP4 0
INDIRP4
CNSTI4 6580
ADDP4
ASGNP4
ADDRLP4 364
INDIRP4
CNSTF4 1056964608
ADDRLP4 364
INDIRP4
INDIRF4
MULF4
ASGNF4
LABELV $1239
LABELV $1235
LABELV $1232
ADDRLP4 0+20
INDIRI4
CNSTI4 16
BANDI4
CNSTI4 0
EQI4 $1247
ADDRFP4 0
INDIRP4
CNSTI4 6556
ADDP4
ADDRLP4 0+24
INDIRI4
ASGNI4
LABELV $1247
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotCheckAttack
CALLV
pop
CNSTI4 1
RETI4
LABELV $1162
endproc AINode_Battle_Retreat 368 20
export AIEnter_Battle_NBG
proc AIEnter_Battle_NBG 0 16
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1252
ARGP4
ADDRGP4 $62
ARGP4
ADDRFP4 4
INDIRP4
ARGP4
ADDRGP4 BotRecordNodeSwitch
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 4900
ADDP4
ADDRGP4 AINode_Battle_NBG
ASGNP4
LABELV $1251
endproc AIEnter_Battle_NBG 0 16
export AINode_Battle_NBG
proc AINode_Battle_NBG 356 20
ADDRFP4 0
ADDRFP4 0
INDIRP4
ASGNP4
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 280
ADDRGP4 BotIsObserver
CALLI4
ASGNI4
ADDRLP4 280
INDIRI4
CNSTI4 0
EQI4 $1254
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1256
ARGP4
ADDRGP4 AIEnter_Observer
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1253
JUMPV
LABELV $1254
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 284
ADDRGP4 BotIntermission
CALLI4
ASGNI4
ADDRLP4 284
INDIRI4
CNSTI4 0
EQI4 $1257
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1259
ARGP4
ADDRGP4 AIEnter_Intermission
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1253
JUMPV
LABELV $1257
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 288
ADDRGP4 BotIsDead
CALLI4
ASGNI4
ADDRLP4 288
INDIRI4
CNSTI4 0
EQI4 $1260
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1262
ARGP4
ADDRGP4 AIEnter_Respawn
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1253
JUMPV
LABELV $1260
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
CNSTI4 0
GEI4 $1263
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1265
ARGP4
ADDRGP4 AIEnter_Seek_NBG
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1253
JUMPV
LABELV $1263
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
ARGI4
ADDRLP4 108
ARGP4
ADDRGP4 BotEntityInfo
CALLV
pop
ADDRLP4 108
ARGP4
ADDRLP4 292
ADDRGP4 EntityIsDead
CALLI4
ASGNI4
ADDRLP4 292
INDIRI4
CNSTI4 0
EQI4 $1266
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1268
ARGP4
ADDRGP4 AIEnter_Seek_NBG
CALLV
pop
CNSTI4 0
RETI4
ADDRGP4 $1253
JUMPV
LABELV $1266
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
CNSTI4 18616254
ASGNI4
ADDRGP4 bot_grapple+12
INDIRI4
CNSTI4 0
EQI4 $1269
ADDRLP4 296
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
ASGNP4
ADDRLP4 296
INDIRP4
ADDRLP4 296
INDIRP4
INDIRI4
CNSTI4 16384
BORI4
ASGNI4
LABELV $1269
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 300
ADDRGP4 BotInLavaOrSlime
CALLI4
ASGNI4
ADDRLP4 300
INDIRI4
CNSTI4 0
EQI4 $1272
ADDRLP4 304
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
ASGNP4
ADDRLP4 304
INDIRP4
ADDRLP4 304
INDIRP4
INDIRI4
CNSTI4 6291456
BORI4
ASGNI4
LABELV $1272
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 308
ADDRGP4 BotCanAndWantsToRocketJump
CALLI4
ASGNI4
ADDRLP4 308
INDIRI4
CNSTI4 0
EQI4 $1274
ADDRLP4 312
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
ASGNP4
ADDRLP4 312
INDIRP4
ADDRLP4 312
INDIRP4
INDIRI4
CNSTI4 4096
BORI4
ASGNI4
LABELV $1274
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotMapScripts
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 12
ADDP4
INDIRI4
ARGI4
ADDRFP4 0
INDIRP4
CNSTI4 4936
ADDP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6560
ADDP4
ARGP4
CNSTF4 1135869952
ARGF4
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
ARGI4
ADDRLP4 316
ADDRGP4 BotEntityVisible
CALLF4
ASGNF4
ADDRLP4 316
INDIRF4
CNSTF4 0
EQF4 $1276
ADDRFP4 0
INDIRP4
CNSTI4 6088
ADDP4
ADDRGP4 floattime
INDIRF4
ASGNF4
ADDRLP4 252
ADDRLP4 108+24
INDIRB
ASGNB 12
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
CNSTI4 64
LTI4 $1279
ADDRLP4 320
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
ASGNI4
ADDRLP4 320
INDIRI4
ADDRGP4 redobelisk+40
INDIRI4
EQI4 $1285
ADDRLP4 320
INDIRI4
ADDRGP4 blueobelisk+40
INDIRI4
NEI4 $1281
LABELV $1285
ADDRLP4 252+8
ADDRLP4 252+8
INDIRF4
CNSTF4 1098907648
ADDF4
ASGNF4
LABELV $1281
LABELV $1279
ADDRLP4 252
ARGP4
ADDRLP4 320
ADDRGP4 BotPointAreaNum
CALLI4
ASGNI4
ADDRLP4 248
ADDRLP4 320
INDIRI4
ASGNI4
ADDRLP4 324
ADDRLP4 248
INDIRI4
ASGNI4
ADDRLP4 324
INDIRI4
CNSTI4 0
EQI4 $1287
ADDRLP4 324
INDIRI4
ARGI4
ADDRLP4 328
ADDRGP4 trap_AAS_AreaReachability
CALLI4
ASGNI4
ADDRLP4 328
INDIRI4
CNSTI4 0
EQI4 $1287
ADDRFP4 0
INDIRP4
CNSTI4 6544
ADDP4
ADDRLP4 252
INDIRB
ASGNB 12
ADDRFP4 0
INDIRP4
CNSTI4 6540
ADDP4
ADDRLP4 248
INDIRI4
ASGNI4
LABELV $1287
LABELV $1276
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRLP4 52
ARGP4
ADDRLP4 320
ADDRGP4 trap_BotGetTopGoal
CALLI4
ASGNI4
ADDRLP4 320
INDIRI4
CNSTI4 0
NEI4 $1289
ADDRFP4 0
INDIRP4
CNSTI4 6072
ADDP4
CNSTF4 0
ASGNF4
ADDRGP4 $1290
JUMPV
LABELV $1289
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 52
ARGP4
ADDRLP4 324
ADDRGP4 BotReachedGoal
CALLI4
ASGNI4
ADDRLP4 324
INDIRI4
CNSTI4 0
EQI4 $1291
ADDRFP4 0
INDIRP4
CNSTI4 6072
ADDP4
CNSTF4 0
ASGNF4
LABELV $1291
LABELV $1290
ADDRFP4 0
INDIRP4
CNSTI4 6072
ADDP4
INDIRF4
ADDRGP4 floattime
INDIRF4
GEF4 $1293
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotPopGoal
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6524
ADDP4
INDIRI4
ARGI4
ADDRLP4 52
ARGP4
ADDRLP4 328
ADDRGP4 trap_BotGetTopGoal
CALLI4
ASGNI4
ADDRLP4 328
INDIRI4
CNSTI4 0
EQI4 $1295
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1297
ARGP4
ADDRGP4 AIEnter_Battle_Retreat
CALLV
pop
ADDRGP4 $1296
JUMPV
LABELV $1295
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 $1297
ARGP4
ADDRGP4 AIEnter_Battle_Fight
CALLV
pop
LABELV $1296
CNSTI4 0
RETI4
ADDRGP4 $1253
JUMPV
LABELV $1293
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotSetupForMovement
CALLV
pop
ADDRLP4 0
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRLP4 52
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotMoveToGoal
CALLV
pop
ADDRLP4 0
INDIRI4
CNSTI4 0
EQI4 $1298
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRGP4 trap_BotResetAvoidReach
CALLV
pop
ADDRFP4 0
INDIRP4
CNSTI4 6072
ADDP4
CNSTF4 0
ASGNF4
LABELV $1298
ADDRFP4 0
INDIRP4
ARGP4
ADDRLP4 0
ARGP4
CNSTI4 0
ARGI4
ADDRGP4 BotAIBlocked
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6536
ADDP4
INDIRI4
ARGI4
ADDRGP4 BotUpdateBattleInventory
CALLV
pop
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotChooseWeapon
CALLV
pop
ADDRLP4 0+20
INDIRI4
CNSTI4 3
BANDI4
CNSTI4 0
EQI4 $1300
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ADDRLP4 0+40
INDIRB
ASGNB 12
ADDRGP4 $1301
JUMPV
LABELV $1300
ADDRLP4 336
CNSTI4 0
ASGNI4
ADDRLP4 0+20
INDIRI4
CNSTI4 8
BANDI4
ADDRLP4 336
INDIRI4
NEI4 $1304
ADDRFP4 0
INDIRP4
CNSTI4 5980
ADDP4
INDIRI4
CNSTI4 32
BANDI4
ADDRLP4 336
INDIRI4
NEI4 $1304
ADDRFP4 0
INDIRP4
CNSTI4 6516
ADDP4
INDIRI4
ARGI4
CNSTI4 2
ARGI4
CNSTF4 0
ARGF4
CNSTF4 1065353216
ARGF4
ADDRLP4 340
ADDRGP4 trap_Characteristic_BFloat
CALLF4
ASGNF4
ADDRLP4 264
ADDRLP4 340
INDIRF4
ASGNF4
ADDRLP4 264
INDIRF4
CNSTF4 1050253722
LEF4 $1307
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotAimAtEnemy
CALLV
pop
ADDRGP4 $1308
JUMPV
LABELV $1307
ADDRFP4 0
INDIRP4
CNSTI4 6520
ADDP4
INDIRI4
ARGI4
ADDRLP4 52
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 5976
ADDP4
INDIRI4
ARGI4
CNSTF4 1133903872
ARGF4
ADDRLP4 252
ARGP4
ADDRLP4 348
ADDRGP4 trap_BotMovementViewTarget
CALLI4
ASGNI4
ADDRLP4 348
INDIRI4
CNSTI4 0
EQI4 $1309
ADDRLP4 268
ADDRLP4 252
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4908
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 268+4
ADDRLP4 252+4
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4912
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 268+8
ADDRLP4 252+8
INDIRF4
ADDRFP4 0
INDIRP4
CNSTI4 4916
ADDP4
INDIRF4
SUBF4
ASGNF4
ADDRLP4 268
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ARGP4
ADDRGP4 vectoangles
CALLV
pop
ADDRGP4 $1310
JUMPV
LABELV $1309
ADDRLP4 0+28
ARGP4
ADDRFP4 0
INDIRP4
CNSTI4 6572
ADDP4
ARGP4
ADDRGP4 vectoangles
CALLV
pop
LABELV $1310
ADDRLP4 352
ADDRFP4 0
INDIRP4
CNSTI4 6580
ADDP4
ASGNP4
ADDRLP4 352
INDIRP4
CNSTF4 1056964608
ADDRLP4 352
INDIRP4
INDIRF4
MULF4
ASGNF4
LABELV $1308
LABELV $1304
LABELV $1301
ADDRLP4 0+20
INDIRI4
CNSTI4 16
BANDI4
CNSTI4 0
EQI4 $1316
ADDRFP4 0
INDIRP4
CNSTI4 6556
ADDP4
ADDRLP4 0+24
INDIRI4
ASGNI4
LABELV $1316
ADDRFP4 0
INDIRP4
ARGP4
ADDRGP4 BotCheckAttack
CALLV
pop
CNSTI4 1
RETI4
LABELV $1253
endproc AINode_Battle_NBG 356 20
bss
export nodeswitch
align 1
LABELV nodeswitch
skip 7344
export numnodeswitches
align 4
LABELV numnodeswitches
skip 4
import BotVoiceChatOnly
import BotVoiceChat
import BotSetTeamMateTaskPreference
import BotGetTeamMateTaskPreference
import BotTeamAI
import AIEnter_Seek_Camp
import BotPrintTeamGoal
import BotMatchMessage
import notleader
import BotChatTest
import BotValidChatPosition
import BotChatTime
import BotChat_Random
import BotChat_EnemySuicide
import BotChat_Kill
import BotChat_Death
import BotChat_HitNoKill
import BotChat_HitNoDeath
import BotChat_HitTalking
import BotChat_EndLevel
import BotChat_StartLevel
import BotChat_ExitGame
import BotChat_EnterGame
import neutralobelisk
import blueobelisk
import redobelisk
import ctf_neutralflag
import ctf_blueflag
import ctf_redflag
import bot_challenge
import bot_testrchat
import bot_nochat
import bot_fastchat
import bot_rocketjump
import bot_grapple
import maxclients
import gametype
import BotMapScripts
import BotPointAreaNum
import ClientOnSameTeamFromName
import ClientFromName
import stristr
import BotFindWayPoint
import BotCreateWayPoint
import BotAlternateRoute
import BotGetAlternateRouteGoal
import BotEnemyCubeCarrierVisible
import BotTeamCubeCarrierVisible
import BotHarvesterRetreatGoals
import BotHarvesterSeekGoals
import BotGoHarvest
import BotObeliskRetreatGoals
import BotObeliskSeekGoals
import Bot1FCTFRetreatGoals
import Bot1FCTFSeekGoals
import BotHarvesterCarryingCubes
import Bot1FCTFCarryingFlag
import BotCTFRetreatGoals
import BotCTFSeekGoals
import BotRememberLastOrderedTask
import BotCTFCarryingFlag
import BotOppositeTeam
import BotTeam
import BotClearActivateGoalStack
import BotPopFromActivateGoalStack
import BotEnableActivateGoalAreas
import BotAIPredictObstacles
import BotAIBlocked
import BotCheckAttack
import BotAimAtEnemy
import BotEntityVisible
import BotRoamGoal
import BotFindEnemy
import InFieldOfVision
import BotVisibleTeamMatesAndEnemies
import BotEnemyFlagCarrierVisible
import BotTeamFlagCarrierVisible
import BotTeamFlagCarrier
import TeamPlayIsOn
import BotSameTeam
import BotAttackMove
import BotWantsToCamp
import BotHasPersistantPowerupAndWeapon
import BotCanAndWantsToRocketJump
import BotWantsToHelp
import BotWantsToChase
import BotWantsToRetreat
import BotFeelingBad
import BotAggression
import BotTeamGoals
import BotSetLastOrderedTask
import BotSynonymContext
import ClientSkin
import EasyClientName
import ClientName
import BotSetTeamStatus
import BotSetUserInfo
import EntityHasKamikaze
import EntityIsShooting
import EntityIsInvisible
import EntityIsDead
import BotInLavaOrSlime
import BotIntermission
import BotIsObserver
import BotIsDead
import BotBattleUseItems
import BotUpdateBattleInventory
import BotUpdateInventory
import BotSetupForMovement
import BotChooseWeapon
import BotFreeWaypoints
import BotDeathmatchAI
import BotShutdownDeathmatchAI
import BotSetupDeathmatchAI
import BotTeamLeader
import BotAI_GetSnapshotEntity
import BotAI_GetEntityState
import BotAI_GetClientState
import BotAI_Trace
import BotAI_BotInitialChat
import BotAI_Print
import floattime
import BotEntityInfo
import NumBots
import BotResetState
import BotResetWeaponState
import BotFreeWeaponState
import BotAllocWeaponState
import BotLoadWeaponWeights
import BotGetWeaponInfo
import BotChooseBestFightWeapon
import BotShutdownWeaponAI
import BotSetupWeaponAI
import BotShutdownMoveAI
import BotSetupMoveAI
import BotSetBrushModelTypes
import BotAddAvoidSpot
import BotInitMoveState
import BotFreeMoveState
import BotAllocMoveState
import BotPredictVisiblePosition
import BotMovementViewTarget
import BotReachabilityArea
import BotResetLastAvoidReach
import BotResetAvoidReach
import BotMoveInDirection
import BotMoveToGoal
import BotResetMoveState
import BotShutdownGoalAI
import BotSetupGoalAI
import BotFreeGoalState
import BotAllocGoalState
import BotFreeItemWeights
import BotLoadItemWeights
import BotMutateGoalFuzzyLogic
import BotSaveGoalFuzzyLogic
import BotInterbreedGoalFuzzyLogic
import BotUpdateEntityItems
import BotInitLevelItems
import BotSetAvoidGoalTime
import BotAvoidGoalTime
import BotGetMapLocationGoal
import BotGetNextCampSpotGoal
import BotGetLevelItemGoal
import BotItemGoalInVisButNotVisible
import BotTouchingGoal
import BotChooseNBGItem
import BotChooseLTGItem
import BotGetSecondGoal
import BotGetTopGoal
import BotGoalName
import BotDumpGoalStack
import BotDumpAvoidGoals
import BotEmptyGoalStack
import BotPopGoal
import BotPushGoal
import BotRemoveFromAvoidGoals
import BotResetAvoidGoals
import BotResetGoalState
import GeneticParentsAndChildSelection
import BotSetChatName
import BotSetChatGender
import BotLoadChatFile
import BotReplaceSynonyms
import UnifyWhiteSpaces
import BotMatchVariable
import BotFindMatch
import StringContains
import BotGetChatMessage
import BotEnterChat
import BotChatLength
import BotReplyChat
import BotNumInitialChats
import BotInitialChat
import BotNumConsoleMessages
import BotNextConsoleMessage
import BotRemoveConsoleMessage
import BotQueueConsoleMessage
import BotFreeChatState
import BotAllocChatState
import BotShutdownChatAI
import BotSetupChatAI
import BotShutdownCharacters
import Characteristic_String
import Characteristic_BInteger
import Characteristic_Integer
import Characteristic_BFloat
import Characteristic_Float
import BotFreeCharacter
import BotLoadCharacter
import EA_Shutdown
import EA_Setup
import EA_ResetInput
import EA_GetInput
import EA_EndRegular
import EA_View
import EA_Move
import EA_DelayedJump
import EA_Jump
import EA_SelectWeapon
import EA_Use
import EA_Gesture
import EA_Talk
import EA_Respawn
import EA_Attack
import EA_MoveRight
import EA_MoveLeft
import EA_MoveBack
import EA_MoveForward
import EA_MoveDown
import EA_MoveUp
import EA_Walk
import EA_Crouch
import EA_Action
import EA_Command
import EA_SayTeam
import EA_Say
import GetBotLibAPI
import trap_SnapVector
import trap_GeneticParentsAndChildSelection
import trap_BotResetWeaponState
import trap_BotFreeWeaponState
import trap_BotAllocWeaponState
import trap_BotLoadWeaponWeights
import trap_BotGetWeaponInfo
import trap_BotChooseBestFightWeapon
import trap_BotAddAvoidSpot
import trap_BotInitMoveState
import trap_BotFreeMoveState
import trap_BotAllocMoveState
import trap_BotPredictVisiblePosition
import trap_BotMovementViewTarget
import trap_BotReachabilityArea
import trap_BotResetLastAvoidReach
import trap_BotResetAvoidReach
import trap_BotMoveInDirection
import trap_BotMoveToGoal
import trap_BotResetMoveState
import trap_BotFreeGoalState
import trap_BotAllocGoalState
import trap_BotMutateGoalFuzzyLogic
import trap_BotSaveGoalFuzzyLogic
import trap_BotInterbreedGoalFuzzyLogic
import trap_BotFreeItemWeights
import trap_BotLoadItemWeights
import trap_BotUpdateEntityItems
import trap_BotInitLevelItems
import trap_BotSetAvoidGoalTime
import trap_BotAvoidGoalTime
import trap_BotGetLevelItemGoal
import trap_BotGetMapLocationGoal
import trap_BotGetNextCampSpotGoal
import trap_BotItemGoalInVisButNotVisible
import trap_BotTouchingGoal
import trap_BotChooseNBGItem
import trap_BotChooseLTGItem
import trap_BotGetSecondGoal
import trap_BotGetTopGoal
import trap_BotGoalName
import trap_BotDumpGoalStack
import trap_BotDumpAvoidGoals
import trap_BotEmptyGoalStack
import trap_BotPopGoal
import trap_BotPushGoal
import trap_BotResetAvoidGoals
import trap_BotRemoveFromAvoidGoals
import trap_BotResetGoalState
import trap_BotSetChatName
import trap_BotSetChatGender
import trap_BotLoadChatFile
import trap_BotReplaceSynonyms
import trap_UnifyWhiteSpaces
import trap_BotMatchVariable
import trap_BotFindMatch
import trap_StringContains
import trap_BotGetChatMessage
import trap_BotEnterChat
import trap_BotChatLength
import trap_BotReplyChat
import trap_BotNumInitialChats
import trap_BotInitialChat
import trap_BotNumConsoleMessages
import trap_BotNextConsoleMessage
import trap_BotRemoveConsoleMessage
import trap_BotQueueConsoleMessage
import trap_BotFreeChatState
import trap_BotAllocChatState
import trap_Characteristic_String
import trap_Characteristic_BInteger
import trap_Characteristic_Integer
import trap_Characteristic_BFloat
import trap_Characteristic_Float
import trap_BotFreeCharacter
import trap_BotLoadCharacter
import trap_EA_ResetInput
import trap_EA_GetInput
import trap_EA_EndRegular
import trap_EA_View
import trap_EA_Move
import trap_EA_DelayedJump
import trap_EA_Jump
import trap_EA_SelectWeapon
import trap_EA_MoveRight
import trap_EA_MoveLeft
import trap_EA_MoveBack
import trap_EA_MoveForward
import trap_EA_MoveDown
import trap_EA_MoveUp
import trap_EA_Crouch
import trap_EA_Respawn
import trap_EA_Use
import trap_EA_Attack
import trap_EA_Talk
import trap_EA_Gesture
import trap_EA_Action
import trap_EA_Command
import trap_EA_SayTeam
import trap_EA_Say
import trap_AAS_PredictClientMovement
import trap_AAS_Swimming
import trap_AAS_AlternativeRouteGoals
import trap_AAS_PredictRoute
import trap_AAS_EnableRoutingArea
import trap_AAS_AreaTravelTimeToGoalArea
import trap_AAS_AreaReachability
import trap_AAS_IntForBSPEpairKey
import trap_AAS_FloatForBSPEpairKey
import trap_AAS_VectorForBSPEpairKey
import trap_AAS_ValueForBSPEpairKey
import trap_AAS_NextBSPEntity
import trap_AAS_PointContents
import trap_AAS_TraceAreas
import trap_AAS_PointReachabilityAreaIndex
import trap_AAS_PointAreaNum
import trap_AAS_Time
import trap_AAS_PresenceTypeBoundingBox
import trap_AAS_Initialized
import trap_AAS_EntityInfo
import trap_AAS_AreaInfo
import trap_AAS_BBoxAreas
import trap_BotUserCommand
import trap_BotGetServerCommand
import trap_BotGetSnapshotEntity
import trap_BotLibTest
import trap_BotLibUpdateEntity
import trap_BotLibLoadMap
import trap_BotLibStartFrame
import trap_BotLibDefine
import trap_BotLibVarGet
import trap_BotLibVarSet
import trap_BotLibShutdown
import trap_BotLibSetup
import trap_DebugPolygonDelete
import trap_DebugPolygonCreate
import trap_GetEntityToken
import trap_GetUsercmd
import trap_BotFreeClient
import trap_BotAllocateClient
import trap_EntityContact
import trap_EntitiesInBox
import trap_UnlinkEntity
import trap_LinkEntity
import trap_AreasConnected
import trap_AdjustAreaPortalState
import trap_InPVSIgnorePortals
import trap_InPVS
import trap_PointContents
import trap_Trace
import trap_SetBrushModel
import trap_GetServerinfo
import trap_SetUserinfo
import trap_GetUserinfo
import trap_GetConfigstring
import trap_SetConfigstring
import trap_SendServerCommand
import trap_DropClient
import trap_LocateGameData
import trap_Cvar_VariableStringBuffer
import trap_Cvar_VariableValue
import trap_Cvar_VariableIntegerValue
import trap_Cvar_Set
import trap_Cvar_Update
import trap_Cvar_Register
import trap_SendConsoleCommand
import trap_FS_Seek
import trap_FS_GetFileList
import trap_FS_FCloseFile
import trap_FS_Write
import trap_FS_Read
import trap_FS_FOpenFile
import trap_Args
import trap_Argv
import trap_Argc
import trap_RealTime
import trap_Milliseconds
import trap_Error
import trap_Print
import g_proxMineTimeout
import g_singlePlayer
import g_enableBreath
import g_enableDust
import g_rankings
import pmove_msec
import pmove_fixed
import g_smoothClients
import g_blueteam
import g_redteam
import g_cubeTimeout
import g_obeliskRespawnDelay
import g_obeliskRegenAmount
import g_obeliskRegenPeriod
import g_obeliskHealth
import g_filterBan
import g_banIPs
import g_teamForceBalance
import g_teamAutoJoin
import g_allowVote
import g_blood
import g_doWarmup
import g_warmup
import g_motd
import g_synchronousClients
import g_weaponTeamRespawn
import g_weaponRespawn
import g_debugDamage
import g_debugAlloc
import g_debugMove
import g_inactivity
import g_forcerespawn
import g_quadfactor
import g_knockback
import g_speed
import g_gravity
import g_needpass
import g_password
import g_friendlyFire
import g_capturelimit
import g_timelimit
import g_fraglimit
import g_dmflags
import g_restarted
import g_maxGameClients
import g_maxclients
import g_cheats
import g_dedicated
import g_gametype
import g_entities
import level
import Pickup_Team
import CheckTeamStatus
import TeamplayInfoMessage
import Team_GetLocationMsg
import Team_GetLocation
import SelectCTFSpawnPoint
import Team_FreeEntity
import Team_ReturnFlag
import Team_InitGame
import Team_CheckHurtCarrier
import Team_FragBonuses
import Team_DroppedFlagThink
import AddTeamScore
import TeamColorString
import TeamName
import OtherTeam
import BotTestAAS
import BotAIStartFrame
import BotAIShutdownClient
import BotAISetupClient
import BotAILoadMap
import BotAIShutdown
import BotAISetup
import BotInterbreedEndMatch
import Svcmd_BotList_f
import Svcmd_AddBot_f
import G_BotConnect
import G_RemoveQueuedBotBegin
import G_CheckBotSpawn
import G_GetBotInfoByName
import G_GetBotInfoByNumber
import G_InitBots
import Svcmd_AbortPodium_f
import SpawnModelsOnVictoryPads
import UpdateTournamentInfo
import G_WriteSessionData
import G_InitWorldSession
import G_InitSessionData
import G_ReadSessionData
import Svcmd_GameMem_f
import G_InitMemory
import G_Alloc
import CheckObeliskAttack
import Team_CheckDroppedItem
import OnSameTeam
import G_RunClient
import ClientEndFrame
import ClientThink
import ClientCommand
import ClientBegin
import ClientDisconnect
import ClientUserinfoChanged
import ClientConnect
import G_Error
import G_Printf
import SendScoreboardMessageToAllClients
import G_LogPrintf
import AddTournamentQueue
import G_RunThink
import CheckTeamLeader
import SetLeader
import FindIntermissionPoint
import MoveClientToIntermission
import DeathmatchScoreboardMessage
import G_StartKamikaze
import FireWeapon
import G_FilterPacket
import G_ProcessIPBans
import ConsoleCommand
import SpotWouldTelefrag
import CalculateRanks
import AddScore
import player_die
import ClientSpawn
import InitBodyQue
import BeginIntermission
import ClientRespawn
import CopyToBodyQue
import SelectSpawnPoint
import SetClientViewAngle
import PickTeam
import TeamLeader
import TeamCount
import Weapon_HookThink
import Weapon_HookFree
import CheckGauntletAttack
import SnapVectorTowards
import CalcMuzzlePoint
import LogAccuracyHit
import DropPortalDestination
import DropPortalSource
import TeleportPlayer
import trigger_teleporter_touch
import Touch_DoorTrigger
import G_RunMover
import fire_prox
import fire_nail
import fire_grapple
import fire_bfg
import fire_rocket
import fire_grenade
import fire_plasma
import G_RunMissile
import TossClientCubes
import TossClientPersistantPowerups
import TossClientItems
import body_die
import G_InvulnerabilityEffect
import G_RadiusDamage
import G_Damage
import CanDamage
import BuildShaderStateConfig
import AddRemap
import G_SetOrigin
import G_AddEvent
import G_AddPredictableEvent
import vectoyaw
import vtos
import tv
import G_TouchTriggers
import G_EntitiesFree
import G_FreeEntity
import G_Sound
import G_TempEntity
import G_Spawn
import G_InitGentity
import G_SetMovedir
import G_UseTargets
import G_PickTarget
import G_Find
import G_KillBox
import G_TeamCommand
import G_SoundIndex
import G_ModelIndex
import SaveRegisteredItems
import RegisterItem
import ClearRegisteredItems
import Touch_Item
import Add_Ammo
import ArmorIndex
import Think_Weapon
import FinishSpawningItem
import G_SpawnItem
import SetRespawn
import LaunchItem
import Drop_Item
import PrecacheItem
import UseHoldableItem
import RespawnItem
import G_RunItem
import G_CheckTeamItems
import Cmd_FollowCycle_f
import SetTeam
import BroadcastTeamChange
import StopFollowing
import Cmd_Score_f
import G_NewString
import G_SpawnEntitiesFromString
import G_SpawnVector
import G_SpawnInt
import G_SpawnFloat
import G_SpawnString
import BG_PlayerTouchesItem
import BG_PlayerStateToEntityStateExtraPolate
import BG_PlayerStateToEntityState
import BG_TouchJumpPad
import BG_AddPredictableEventToPlayerstate
import BG_EvaluateTrajectoryDelta
import BG_EvaluateTrajectory
import BG_CanItemBeGrabbed
import BG_FindItemForHoldable
import BG_FindItemForPowerup
import BG_FindItemForWeapon
import BG_FindItem
import bg_numItems
import bg_itemlist
import Pmove
import PM_UpdateViewAngles
import Com_Printf
import Com_Error
import Info_NextPair
import Info_Validate
import Info_SetValueForKey_Big
import Info_SetValueForKey
import Info_RemoveKey_Big
import Info_RemoveKey
import Info_ValueForKey
import Com_TruncateLongString
import va
import Q_CountChar
import Q_CleanStr
import Q_PrintStrlen
import Q_strcat
import Q_strncpyz
import Q_stristr
import Q_strupr
import Q_strlwr
import Q_stricmpn
import Q_strncmp
import Q_stricmp
import Q_isintegral
import Q_isanumber
import Q_isalpha
import Q_isupper
import Q_islower
import Q_isprint
import Com_RandomBytes
import Com_SkipCharset
import Com_SkipTokens
import Com_sprintf
import Com_HexStrToInt
import Parse3DMatrix
import Parse2DMatrix
import Parse1DMatrix
import SkipRestOfLine
import SkipBracedSection
import COM_MatchToken
import COM_ParseWarning
import COM_ParseError
import COM_Compress
import COM_ParseExt
import COM_Parse
import COM_GetCurrentParseLine
import COM_BeginParseSession
import COM_DefaultExtension
import COM_CompareExtension
import COM_StripExtension
import COM_GetExtension
import COM_SkipPath
import Com_Clamp
import PerpendicularVector
import AngleVectors
import MatrixMultiply
import MakeNormalVectors
import RotateAroundDirection
import RotatePointAroundVector
import ProjectPointOnPlane
import PlaneFromPoints
import AngleDelta
import AngleNormalize180
import AngleNormalize360
import AnglesSubtract
import AngleSubtract
import LerpAngle
import AngleMod
import BoundsIntersectPoint
import BoundsIntersectSphere
import BoundsIntersect
import BoxOnPlaneSide
import SetPlaneSignbits
import AxisCopy
import AxisClear
import AnglesToAxis
import vectoangles
import Q_crandom
import Q_random
import Q_rand
import Q_acos
import Q_log2
import VectorRotate
import Vector4Scale
import VectorNormalize2
import VectorNormalize
import CrossProduct
import VectorInverse
import VectorNormalizeFast
import DistanceSquared
import Distance
import VectorLengthSquared
import VectorLength
import VectorCompare
import AddPointToBounds
import ClearBounds
import RadiusFromBounds
import NormalizeColor
import ColorBytes4
import ColorBytes3
import _VectorMA
import _VectorScale
import _VectorCopy
import _VectorAdd
import _VectorSubtract
import _DotProduct
import ByteToDir
import DirToByte
import ClampShort
import ClampChar
import Q_rsqrt
import Q_fabs
import Q_isnan
import axisDefault
import vec3_origin
import g_color_table
import colorDkGrey
import colorMdGrey
import colorLtGrey
import colorWhite
import colorCyan
import colorMagenta
import colorYellow
import colorBlue
import colorGreen
import colorRed
import colorBlack
import bytedirs
import Hunk_AllocDebug
import FloatSwap
import LongSwap
import ShortSwap
import CopyLongSwap
import CopyShortSwap
import qk_acos
import qk_fabs
import qk_abs
import qk_tan
import qk_atan2
import qk_cos
import qk_sin
import qk_sqrt
import qk_floor
import qk_ceil
import qk_memcpy
import qk_memset
import qk_memmove
import qk_sscanf
import qk_vsnprintf
import qk_strtol
import qk_atoi
import qk_strtod
import qk_atof
import qk_toupper
import qk_tolower
import qk_strncpy
import qk_strstr
import qk_strrchr
import qk_strchr
import qk_strcmp
import qk_strcpy
import qk_strcat
import qk_strlen
import qk_rand
import qk_srand
import qk_qsort
lit
align 1
LABELV $1297
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 110
byte 1 98
byte 1 103
byte 1 58
byte 1 32
byte 1 116
byte 1 105
byte 1 109
byte 1 101
byte 1 32
byte 1 111
byte 1 117
byte 1 116
byte 1 0
align 1
LABELV $1268
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 110
byte 1 98
byte 1 103
byte 1 58
byte 1 32
byte 1 101
byte 1 110
byte 1 101
byte 1 109
byte 1 121
byte 1 32
byte 1 100
byte 1 101
byte 1 97
byte 1 100
byte 1 0
align 1
LABELV $1265
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 110
byte 1 98
byte 1 103
byte 1 58
byte 1 32
byte 1 110
byte 1 111
byte 1 32
byte 1 101
byte 1 110
byte 1 101
byte 1 109
byte 1 121
byte 1 0
align 1
LABELV $1262
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 110
byte 1 98
byte 1 103
byte 1 58
byte 1 32
byte 1 98
byte 1 111
byte 1 116
byte 1 32
byte 1 100
byte 1 101
byte 1 97
byte 1 100
byte 1 0
align 1
LABELV $1259
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 110
byte 1 98
byte 1 103
byte 1 58
byte 1 32
byte 1 105
byte 1 110
byte 1 116
byte 1 101
byte 1 114
byte 1 109
byte 1 105
byte 1 115
byte 1 115
byte 1 105
byte 1 111
byte 1 110
byte 1 0
align 1
LABELV $1256
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 110
byte 1 98
byte 1 103
byte 1 58
byte 1 32
byte 1 111
byte 1 98
byte 1 115
byte 1 101
byte 1 114
byte 1 118
byte 1 101
byte 1 114
byte 1 0
align 1
LABELV $1252
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 78
byte 1 66
byte 1 71
byte 1 0
align 1
LABELV $1228
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 114
byte 1 101
byte 1 116
byte 1 114
byte 1 101
byte 1 97
byte 1 116
byte 1 58
byte 1 32
byte 1 110
byte 1 98
byte 1 103
byte 1 0
align 1
LABELV $1211
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 114
byte 1 101
byte 1 116
byte 1 114
byte 1 101
byte 1 97
byte 1 116
byte 1 58
byte 1 32
byte 1 110
byte 1 111
byte 1 32
byte 1 119
byte 1 97
byte 1 121
byte 1 32
byte 1 111
byte 1 117
byte 1 116
byte 1 0
align 1
LABELV $1208
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 114
byte 1 101
byte 1 116
byte 1 114
byte 1 101
byte 1 97
byte 1 116
byte 1 58
byte 1 32
byte 1 97
byte 1 110
byte 1 111
byte 1 116
byte 1 104
byte 1 101
byte 1 114
byte 1 32
byte 1 101
byte 1 110
byte 1 101
byte 1 109
byte 1 121
byte 1 0
align 1
LABELV $1203
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 114
byte 1 101
byte 1 116
byte 1 114
byte 1 101
byte 1 97
byte 1 116
byte 1 58
byte 1 32
byte 1 108
byte 1 111
byte 1 115
byte 1 116
byte 1 32
byte 1 101
byte 1 110
byte 1 101
byte 1 109
byte 1 121
byte 1 0
align 1
LABELV $1187
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 114
byte 1 101
byte 1 116
byte 1 114
byte 1 101
byte 1 97
byte 1 116
byte 1 58
byte 1 32
byte 1 119
byte 1 97
byte 1 110
byte 1 116
byte 1 115
byte 1 32
byte 1 116
byte 1 111
byte 1 32
byte 1 99
byte 1 104
byte 1 97
byte 1 115
byte 1 101
byte 1 0
align 1
LABELV $1177
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 114
byte 1 101
byte 1 116
byte 1 114
byte 1 101
byte 1 97
byte 1 116
byte 1 58
byte 1 32
byte 1 101
byte 1 110
byte 1 101
byte 1 109
byte 1 121
byte 1 32
byte 1 100
byte 1 101
byte 1 97
byte 1 100
byte 1 0
align 1
LABELV $1174
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 114
byte 1 101
byte 1 116
byte 1 114
byte 1 101
byte 1 97
byte 1 116
byte 1 58
byte 1 32
byte 1 110
byte 1 111
byte 1 32
byte 1 101
byte 1 110
byte 1 101
byte 1 109
byte 1 121
byte 1 0
align 1
LABELV $1171
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 114
byte 1 101
byte 1 116
byte 1 114
byte 1 101
byte 1 97
byte 1 116
byte 1 58
byte 1 32
byte 1 98
byte 1 111
byte 1 116
byte 1 32
byte 1 100
byte 1 101
byte 1 97
byte 1 100
byte 1 0
align 1
LABELV $1168
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 114
byte 1 101
byte 1 116
byte 1 114
byte 1 101
byte 1 97
byte 1 116
byte 1 58
byte 1 32
byte 1 105
byte 1 110
byte 1 116
byte 1 101
byte 1 114
byte 1 109
byte 1 105
byte 1 115
byte 1 115
byte 1 105
byte 1 111
byte 1 110
byte 1 0
align 1
LABELV $1165
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 114
byte 1 101
byte 1 116
byte 1 114
byte 1 101
byte 1 97
byte 1 116
byte 1 58
byte 1 32
byte 1 111
byte 1 98
byte 1 115
byte 1 101
byte 1 114
byte 1 118
byte 1 101
byte 1 114
byte 1 0
align 1
LABELV $1161
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 114
byte 1 101
byte 1 116
byte 1 114
byte 1 101
byte 1 97
byte 1 116
byte 1 0
align 1
LABELV $1159
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 99
byte 1 104
byte 1 97
byte 1 115
byte 1 101
byte 1 58
byte 1 32
byte 1 119
byte 1 97
byte 1 110
byte 1 116
byte 1 115
byte 1 32
byte 1 116
byte 1 111
byte 1 32
byte 1 114
byte 1 101
byte 1 116
byte 1 114
byte 1 101
byte 1 97
byte 1 116
byte 1 0
align 1
LABELV $1133
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 99
byte 1 104
byte 1 97
byte 1 115
byte 1 101
byte 1 58
byte 1 32
byte 1 110
byte 1 98
byte 1 103
byte 1 0
align 1
LABELV $1128
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 99
byte 1 104
byte 1 97
byte 1 115
byte 1 101
byte 1 58
byte 1 32
byte 1 116
byte 1 105
byte 1 109
byte 1 101
byte 1 32
byte 1 111
byte 1 117
byte 1 116
byte 1 0
align 1
LABELV $1103
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 99
byte 1 104
byte 1 97
byte 1 115
byte 1 101
byte 1 58
byte 1 32
byte 1 110
byte 1 111
byte 1 32
byte 1 101
byte 1 110
byte 1 101
byte 1 109
byte 1 121
byte 1 32
byte 1 97
byte 1 114
byte 1 101
byte 1 97
byte 1 0
align 1
LABELV $1100
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 99
byte 1 104
byte 1 97
byte 1 115
byte 1 101
byte 1 58
byte 1 32
byte 1 98
byte 1 101
byte 1 116
byte 1 116
byte 1 101
byte 1 114
byte 1 32
byte 1 101
byte 1 110
byte 1 101
byte 1 109
byte 1 121
byte 1 0
align 1
LABELV $1095
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 99
byte 1 104
byte 1 97
byte 1 115
byte 1 101
byte 1 58
byte 1 32
byte 1 110
byte 1 111
byte 1 32
byte 1 101
byte 1 110
byte 1 101
byte 1 109
byte 1 121
byte 1 0
align 1
LABELV $1092
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 99
byte 1 104
byte 1 97
byte 1 115
byte 1 101
byte 1 58
byte 1 32
byte 1 98
byte 1 111
byte 1 116
byte 1 32
byte 1 100
byte 1 101
byte 1 97
byte 1 100
byte 1 0
align 1
LABELV $1089
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 99
byte 1 104
byte 1 97
byte 1 115
byte 1 101
byte 1 58
byte 1 32
byte 1 105
byte 1 110
byte 1 116
byte 1 101
byte 1 114
byte 1 109
byte 1 105
byte 1 115
byte 1 115
byte 1 105
byte 1 111
byte 1 110
byte 1 0
align 1
LABELV $1086
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 99
byte 1 104
byte 1 97
byte 1 115
byte 1 101
byte 1 58
byte 1 32
byte 1 111
byte 1 98
byte 1 115
byte 1 101
byte 1 114
byte 1 118
byte 1 101
byte 1 114
byte 1 0
align 1
LABELV $1082
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 99
byte 1 104
byte 1 97
byte 1 115
byte 1 101
byte 1 0
align 1
LABELV $1080
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 102
byte 1 105
byte 1 103
byte 1 104
byte 1 116
byte 1 58
byte 1 32
byte 1 119
byte 1 97
byte 1 110
byte 1 116
byte 1 115
byte 1 32
byte 1 116
byte 1 111
byte 1 32
byte 1 114
byte 1 101
byte 1 116
byte 1 114
byte 1 101
byte 1 97
byte 1 116
byte 1 0
align 1
LABELV $1066
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 102
byte 1 105
byte 1 103
byte 1 104
byte 1 116
byte 1 58
byte 1 32
byte 1 101
byte 1 110
byte 1 101
byte 1 109
byte 1 121
byte 1 32
byte 1 111
byte 1 117
byte 1 116
byte 1 32
byte 1 111
byte 1 102
byte 1 32
byte 1 115
byte 1 105
byte 1 103
byte 1 104
byte 1 116
byte 1 0
align 1
LABELV $1063
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 102
byte 1 105
byte 1 103
byte 1 104
byte 1 116
byte 1 58
byte 1 32
byte 1 111
byte 1 98
byte 1 101
byte 1 108
byte 1 105
byte 1 115
byte 1 107
byte 1 32
byte 1 111
byte 1 117
byte 1 116
byte 1 32
byte 1 111
byte 1 102
byte 1 32
byte 1 115
byte 1 105
byte 1 103
byte 1 104
byte 1 116
byte 1 0
align 1
LABELV $1055
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 102
byte 1 105
byte 1 103
byte 1 104
byte 1 116
byte 1 58
byte 1 32
byte 1 99
byte 1 104
byte 1 97
byte 1 116
byte 1 32
byte 1 104
byte 1 105
byte 1 116
byte 1 32
byte 1 115
byte 1 111
byte 1 109
byte 1 101
byte 1 111
byte 1 110
byte 1 101
byte 1 0
align 1
LABELV $1050
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 102
byte 1 105
byte 1 103
byte 1 104
byte 1 116
byte 1 58
byte 1 32
byte 1 99
byte 1 104
byte 1 97
byte 1 116
byte 1 32
byte 1 104
byte 1 101
byte 1 97
byte 1 108
byte 1 116
byte 1 104
byte 1 32
byte 1 100
byte 1 101
byte 1 99
byte 1 114
byte 1 101
byte 1 97
byte 1 115
byte 1 101
byte 1 100
byte 1 0
align 1
LABELV $1034
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 102
byte 1 105
byte 1 103
byte 1 104
byte 1 116
byte 1 58
byte 1 32
byte 1 105
byte 1 110
byte 1 118
byte 1 105
byte 1 115
byte 1 105
byte 1 98
byte 1 108
byte 1 101
byte 1 0
align 1
LABELV $1027
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 102
byte 1 105
byte 1 103
byte 1 104
byte 1 116
byte 1 58
byte 1 32
byte 1 101
byte 1 110
byte 1 101
byte 1 109
byte 1 121
byte 1 32
byte 1 100
byte 1 101
byte 1 97
byte 1 100
byte 1 0
align 1
LABELV $1018
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 102
byte 1 105
byte 1 103
byte 1 104
byte 1 116
byte 1 58
byte 1 32
byte 1 110
byte 1 111
byte 1 32
byte 1 101
byte 1 110
byte 1 101
byte 1 109
byte 1 121
byte 1 0
align 1
LABELV $1013
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 102
byte 1 105
byte 1 103
byte 1 104
byte 1 116
byte 1 58
byte 1 32
byte 1 98
byte 1 111
byte 1 116
byte 1 32
byte 1 100
byte 1 101
byte 1 97
byte 1 100
byte 1 0
align 1
LABELV $1010
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 102
byte 1 105
byte 1 103
byte 1 104
byte 1 116
byte 1 58
byte 1 32
byte 1 105
byte 1 110
byte 1 116
byte 1 101
byte 1 114
byte 1 109
byte 1 105
byte 1 115
byte 1 115
byte 1 105
byte 1 111
byte 1 110
byte 1 0
align 1
LABELV $1007
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 102
byte 1 105
byte 1 103
byte 1 104
byte 1 116
byte 1 58
byte 1 32
byte 1 111
byte 1 98
byte 1 115
byte 1 101
byte 1 114
byte 1 118
byte 1 101
byte 1 114
byte 1 0
align 1
LABELV $1002
byte 1 98
byte 1 97
byte 1 116
byte 1 116
byte 1 108
byte 1 101
byte 1 32
byte 1 102
byte 1 105
byte 1 103
byte 1 104
byte 1 116
byte 1 0
align 1
LABELV $961
byte 1 108
byte 1 116
byte 1 103
byte 1 32
byte 1 115
byte 1 101
byte 1 101
byte 1 107
byte 1 58
byte 1 32
byte 1 110
byte 1 98
byte 1 103
byte 1 0
align 1
LABELV $940
byte 1 115
byte 1 101
byte 1 101
byte 1 107
byte 1 32
byte 1 108
byte 1 116
byte 1 103
byte 1 58
byte 1 32
byte 1 102
byte 1 111
byte 1 117
byte 1 110
byte 1 100
byte 1 32
byte 1 101
byte 1 110
byte 1 101
byte 1 109
byte 1 121
byte 1 0
align 1
LABELV $924
byte 1 115
byte 1 101
byte 1 101
byte 1 107
byte 1 32
byte 1 108
byte 1 116
byte 1 103
byte 1 58
byte 1 32
byte 1 114
byte 1 97
byte 1 110
byte 1 100
byte 1 111
byte 1 109
byte 1 32
byte 1 99
byte 1 104
byte 1 97
byte 1 116
byte 1 0
align 1
LABELV $921
byte 1 115
byte 1 101
byte 1 101
byte 1 107
byte 1 32
byte 1 108
byte 1 116
byte 1 103
byte 1 58
byte 1 32
byte 1 98
byte 1 111
byte 1 116
byte 1 32
byte 1 100
byte 1 101
byte 1 97
byte 1 100
byte 1 0
align 1
LABELV $918
byte 1 115
byte 1 101
byte 1 101
byte 1 107
byte 1 32
byte 1 108
byte 1 116
byte 1 103
byte 1 58
byte 1 32
byte 1 105
byte 1 110
byte 1 116
byte 1 101
byte 1 114
byte 1 109
byte 1 105
byte 1 115
byte 1 115
byte 1 105
byte 1 111
byte 1 110
byte 1 0
align 1
LABELV $915
byte 1 115
byte 1 101
byte 1 101
byte 1 107
byte 1 32
byte 1 108
byte 1 116
byte 1 103
byte 1 58
byte 1 32
byte 1 111
byte 1 98
byte 1 115
byte 1 101
byte 1 114
byte 1 118
byte 1 101
byte 1 114
byte 1 0
align 1
LABELV $911
byte 1 115
byte 1 101
byte 1 101
byte 1 107
byte 1 32
byte 1 76
byte 1 84
byte 1 71
byte 1 0
align 1
LABELV $906
byte 1 115
byte 1 101
byte 1 101
byte 1 107
byte 1 32
byte 1 110
byte 1 98
byte 1 103
byte 1 58
byte 1 32
byte 1 102
byte 1 111
byte 1 117
byte 1 110
byte 1 100
byte 1 32
byte 1 101
byte 1 110
byte 1 101
byte 1 109
byte 1 121
byte 1 0
align 1
LABELV $869
byte 1 115
byte 1 101
byte 1 101
byte 1 107
byte 1 32
byte 1 110
byte 1 98
byte 1 103
byte 1 58
byte 1 32
byte 1 116
byte 1 105
byte 1 109
byte 1 101
byte 1 32
byte 1 111
byte 1 117
byte 1 116
byte 1 0
align 1
LABELV $855
byte 1 115
byte 1 101
byte 1 101
byte 1 107
byte 1 32
byte 1 110
byte 1 98
byte 1 103
byte 1 58
byte 1 32
byte 1 98
byte 1 111
byte 1 116
byte 1 32
byte 1 100
byte 1 101
byte 1 97
byte 1 100
byte 1 0
align 1
LABELV $852
byte 1 115
byte 1 101
byte 1 101
byte 1 107
byte 1 32
byte 1 110
byte 1 98
byte 1 103
byte 1 58
byte 1 32
byte 1 105
byte 1 110
byte 1 116
byte 1 101
byte 1 114
byte 1 109
byte 1 105
byte 1 115
byte 1 105
byte 1 111
byte 1 110
byte 1 0
align 1
LABELV $849
byte 1 115
byte 1 101
byte 1 101
byte 1 107
byte 1 32
byte 1 110
byte 1 98
byte 1 103
byte 1 58
byte 1 32
byte 1 111
byte 1 98
byte 1 115
byte 1 101
byte 1 114
byte 1 118
byte 1 101
byte 1 114
byte 1 0
align 1
LABELV $845
byte 1 110
byte 1 111
byte 1 32
byte 1 103
byte 1 111
byte 1 97
byte 1 108
byte 1 0
align 1
LABELV $844
byte 1 115
byte 1 101
byte 1 101
byte 1 107
byte 1 32
byte 1 78
byte 1 66
byte 1 71
byte 1 0
align 1
LABELV $839
byte 1 97
byte 1 99
byte 1 116
byte 1 105
byte 1 118
byte 1 97
byte 1 116
byte 1 101
byte 1 32
byte 1 101
byte 1 110
byte 1 116
byte 1 105
byte 1 116
byte 1 121
byte 1 58
byte 1 32
byte 1 102
byte 1 111
byte 1 117
byte 1 110
byte 1 100
byte 1 32
byte 1 101
byte 1 110
byte 1 101
byte 1 109
byte 1 121
byte 1 0
align 1
LABELV $788
byte 1 97
byte 1 99
byte 1 116
byte 1 105
byte 1 118
byte 1 97
byte 1 116
byte 1 101
byte 1 32
byte 1 101
byte 1 110
byte 1 116
byte 1 105
byte 1 116
byte 1 121
byte 1 58
byte 1 32
byte 1 97
byte 1 99
byte 1 116
byte 1 105
byte 1 118
byte 1 97
byte 1 116
byte 1 101
byte 1 100
byte 1 0
align 1
LABELV $777
byte 1 97
byte 1 99
byte 1 116
byte 1 105
byte 1 118
byte 1 97
byte 1 116
byte 1 101
byte 1 32
byte 1 101
byte 1 110
byte 1 116
byte 1 105
byte 1 116
byte 1 121
byte 1 58
byte 1 32
byte 1 116
byte 1 105
byte 1 109
byte 1 101
byte 1 32
byte 1 111
byte 1 117
byte 1 116
byte 1 0
align 1
LABELV $754
byte 1 97
byte 1 99
byte 1 116
byte 1 105
byte 1 118
byte 1 97
byte 1 116
byte 1 101
byte 1 32
byte 1 101
byte 1 110
byte 1 116
byte 1 105
byte 1 116
byte 1 121
byte 1 58
byte 1 32
byte 1 110
byte 1 111
byte 1 32
byte 1 103
byte 1 111
byte 1 97
byte 1 108
byte 1 0
align 1
LABELV $746
byte 1 97
byte 1 99
byte 1 116
byte 1 105
byte 1 118
byte 1 97
byte 1 116
byte 1 101
byte 1 32
byte 1 101
byte 1 110
byte 1 116
byte 1 105
byte 1 116
byte 1 121
byte 1 58
byte 1 32
byte 1 98
byte 1 111
byte 1 116
byte 1 32
byte 1 100
byte 1 101
byte 1 97
byte 1 100
byte 1 0
align 1
LABELV $743
byte 1 97
byte 1 99
byte 1 116
byte 1 105
byte 1 118
byte 1 97
byte 1 116
byte 1 101
byte 1 32
byte 1 101
byte 1 110
byte 1 116
byte 1 105
byte 1 116
byte 1 121
byte 1 58
byte 1 32
byte 1 105
byte 1 110
byte 1 116
byte 1 101
byte 1 114
byte 1 109
byte 1 105
byte 1 115
byte 1 115
byte 1 105
byte 1 111
byte 1 110
byte 1 0
align 1
LABELV $740
byte 1 97
byte 1 99
byte 1 116
byte 1 105
byte 1 118
byte 1 101
byte 1 32
byte 1 101
byte 1 110
byte 1 116
byte 1 105
byte 1 116
byte 1 121
byte 1 58
byte 1 32
byte 1 111
byte 1 98
byte 1 115
byte 1 101
byte 1 114
byte 1 118
byte 1 101
byte 1 114
byte 1 0
align 1
LABELV $736
byte 1 97
byte 1 99
byte 1 116
byte 1 105
byte 1 118
byte 1 97
byte 1 116
byte 1 101
byte 1 32
byte 1 101
byte 1 110
byte 1 116
byte 1 105
byte 1 116
byte 1 121
byte 1 0
align 1
LABELV $634
byte 1 114
byte 1 101
byte 1 115
byte 1 112
byte 1 97
byte 1 119
byte 1 110
byte 1 58
byte 1 32
byte 1 114
byte 1 101
byte 1 115
byte 1 112
byte 1 97
byte 1 119
byte 1 110
byte 1 101
byte 1 100
byte 1 0
align 1
LABELV $626
byte 1 114
byte 1 101
byte 1 115
byte 1 112
byte 1 97
byte 1 119
byte 1 110
byte 1 0
align 1
LABELV $624
byte 1 115
byte 1 116
byte 1 97
byte 1 110
byte 1 100
byte 1 58
byte 1 32
byte 1 116
byte 1 105
byte 1 109
byte 1 101
byte 1 32
byte 1 111
byte 1 117
byte 1 116
byte 1 0
align 1
LABELV $621
byte 1 115
byte 1 116
byte 1 97
byte 1 110
byte 1 100
byte 1 58
byte 1 32
byte 1 102
byte 1 111
byte 1 117
byte 1 110
byte 1 100
byte 1 32
byte 1 101
byte 1 110
byte 1 101
byte 1 109
byte 1 121
byte 1 0
align 1
LABELV $611
byte 1 115
byte 1 116
byte 1 97
byte 1 110
byte 1 100
byte 1 0
align 1
LABELV $609
byte 1 111
byte 1 98
byte 1 115
byte 1 101
byte 1 114
byte 1 118
byte 1 101
byte 1 114
byte 1 58
byte 1 32
byte 1 108
byte 1 101
byte 1 102
byte 1 116
byte 1 32
byte 1 111
byte 1 98
byte 1 115
byte 1 101
byte 1 114
byte 1 118
byte 1 101
byte 1 114
byte 1 0
align 1
LABELV $605
byte 1 111
byte 1 98
byte 1 115
byte 1 101
byte 1 114
byte 1 118
byte 1 101
byte 1 114
byte 1 0
align 1
LABELV $603
byte 1 105
byte 1 110
byte 1 116
byte 1 101
byte 1 114
byte 1 109
byte 1 105
byte 1 115
byte 1 115
byte 1 105
byte 1 111
byte 1 110
byte 1 58
byte 1 32
byte 1 99
byte 1 104
byte 1 97
byte 1 116
byte 1 0
align 1
LABELV $595
byte 1 105
byte 1 110
byte 1 116
byte 1 101
byte 1 114
byte 1 109
byte 1 105
byte 1 115
byte 1 115
byte 1 105
byte 1 111
byte 1 110
byte 1 0
align 1
LABELV $564
byte 1 102
byte 1 111
byte 1 108
byte 1 108
byte 1 111
byte 1 119
byte 1 109
byte 1 101
byte 1 0
align 1
LABELV $561
byte 1 108
byte 1 101
byte 1 97
byte 1 100
byte 1 95
byte 1 115
byte 1 116
byte 1 111
byte 1 112
byte 1 0
align 1
LABELV $551
byte 1 104
byte 1 97
byte 1 114
byte 1 118
byte 1 101
byte 1 115
byte 1 116
byte 1 95
byte 1 115
byte 1 116
byte 1 97
byte 1 114
byte 1 116
byte 1 0
align 1
LABELV $482
byte 1 111
byte 1 110
byte 1 111
byte 1 102
byte 1 102
byte 1 101
byte 1 110
byte 1 115
byte 1 101
byte 1 0
align 1
LABELV $481
byte 1 97
byte 1 116
byte 1 116
byte 1 97
byte 1 99
byte 1 107
byte 1 101
byte 1 110
byte 1 101
byte 1 109
byte 1 121
byte 1 98
byte 1 97
byte 1 115
byte 1 101
byte 1 95
byte 1 115
byte 1 116
byte 1 97
byte 1 114
byte 1 116
byte 1 0
align 1
LABELV $444
byte 1 111
byte 1 110
byte 1 114
byte 1 101
byte 1 116
byte 1 117
byte 1 114
byte 1 110
byte 1 102
byte 1 108
byte 1 97
byte 1 103
byte 1 0
align 1
LABELV $443
byte 1 114
byte 1 101
byte 1 116
byte 1 117
byte 1 114
byte 1 110
byte 1 102
byte 1 108
byte 1 97
byte 1 103
byte 1 95
byte 1 115
byte 1 116
byte 1 97
byte 1 114
byte 1 116
byte 1 0
align 1
LABELV $409
byte 1 111
byte 1 110
byte 1 103
byte 1 101
byte 1 116
byte 1 102
byte 1 108
byte 1 97
byte 1 103
byte 1 0
align 1
LABELV $408
byte 1 99
byte 1 97
byte 1 112
byte 1 116
byte 1 117
byte 1 114
byte 1 101
byte 1 102
byte 1 108
byte 1 97
byte 1 103
byte 1 95
byte 1 115
byte 1 116
byte 1 97
byte 1 114
byte 1 116
byte 1 0
align 1
LABELV $399
byte 1 112
byte 1 97
byte 1 116
byte 1 114
byte 1 111
byte 1 108
byte 1 95
byte 1 115
byte 1 116
byte 1 111
byte 1 112
byte 1 0
align 1
LABELV $386
byte 1 112
byte 1 97
byte 1 116
byte 1 114
byte 1 111
byte 1 108
byte 1 95
byte 1 115
byte 1 116
byte 1 97
byte 1 114
byte 1 116
byte 1 0
align 1
LABELV $385
byte 1 32
byte 1 116
byte 1 111
byte 1 32
byte 1 0
align 1
LABELV $354
byte 1 105
byte 1 110
byte 1 112
byte 1 111
byte 1 115
byte 1 105
byte 1 116
byte 1 105
byte 1 111
byte 1 110
byte 1 0
align 1
LABELV $353
byte 1 99
byte 1 97
byte 1 109
byte 1 112
byte 1 95
byte 1 97
byte 1 114
byte 1 114
byte 1 105
byte 1 118
byte 1 101
byte 1 0
align 1
LABELV $344
byte 1 99
byte 1 97
byte 1 109
byte 1 112
byte 1 95
byte 1 115
byte 1 116
byte 1 111
byte 1 112
byte 1 0
align 1
LABELV $339
byte 1 99
byte 1 97
byte 1 109
byte 1 112
byte 1 95
byte 1 115
byte 1 116
byte 1 97
byte 1 114
byte 1 116
byte 1 0
align 1
LABELV $331
byte 1 103
byte 1 101
byte 1 116
byte 1 105
byte 1 116
byte 1 101
byte 1 109
byte 1 95
byte 1 103
byte 1 111
byte 1 116
byte 1 105
byte 1 116
byte 1 0
align 1
LABELV $328
byte 1 103
byte 1 101
byte 1 116
byte 1 105
byte 1 116
byte 1 101
byte 1 109
byte 1 95
byte 1 110
byte 1 111
byte 1 116
byte 1 116
byte 1 104
byte 1 101
byte 1 114
byte 1 101
byte 1 0
align 1
LABELV $323
byte 1 103
byte 1 101
byte 1 116
byte 1 105
byte 1 116
byte 1 101
byte 1 109
byte 1 95
byte 1 115
byte 1 116
byte 1 97
byte 1 114
byte 1 116
byte 1 0
align 1
LABELV $316
byte 1 107
byte 1 105
byte 1 108
byte 1 108
byte 1 95
byte 1 100
byte 1 111
byte 1 110
byte 1 101
byte 1 0
align 1
LABELV $313
byte 1 107
byte 1 105
byte 1 108
byte 1 108
byte 1 95
byte 1 115
byte 1 116
byte 1 97
byte 1 114
byte 1 116
byte 1 0
align 1
LABELV $302
byte 1 100
byte 1 101
byte 1 102
byte 1 101
byte 1 110
byte 1 100
byte 1 95
byte 1 115
byte 1 116
byte 1 111
byte 1 112
byte 1 0
align 1
LABELV $299
byte 1 111
byte 1 110
byte 1 100
byte 1 101
byte 1 102
byte 1 101
byte 1 110
byte 1 115
byte 1 101
byte 1 0
align 1
LABELV $298
byte 1 100
byte 1 101
byte 1 102
byte 1 101
byte 1 110
byte 1 100
byte 1 95
byte 1 115
byte 1 116
byte 1 97
byte 1 114
byte 1 116
byte 1 0
align 1
LABELV $289
byte 1 97
byte 1 99
byte 1 99
byte 1 111
byte 1 109
byte 1 112
byte 1 97
byte 1 110
byte 1 121
byte 1 95
byte 1 99
byte 1 97
byte 1 110
byte 1 110
byte 1 111
byte 1 116
byte 1 102
byte 1 105
byte 1 110
byte 1 100
byte 1 0
align 1
LABELV $280
byte 1 66
byte 1 111
byte 1 116
byte 1 76
byte 1 111
byte 1 110
byte 1 103
byte 1 84
byte 1 101
byte 1 114
byte 1 109
byte 1 71
byte 1 111
byte 1 97
byte 1 108
byte 1 58
byte 1 32
byte 1 103
byte 1 111
byte 1 32
byte 1 102
byte 1 111
byte 1 114
byte 1 32
byte 1 97
byte 1 105
byte 1 114
byte 1 0
align 1
LABELV $258
byte 1 97
byte 1 99
byte 1 99
byte 1 111
byte 1 109
byte 1 112
byte 1 97
byte 1 110
byte 1 121
byte 1 95
byte 1 97
byte 1 114
byte 1 114
byte 1 105
byte 1 118
byte 1 101
byte 1 0
align 1
LABELV $165
byte 1 97
byte 1 99
byte 1 99
byte 1 111
byte 1 109
byte 1 112
byte 1 97
byte 1 110
byte 1 121
byte 1 95
byte 1 115
byte 1 116
byte 1 111
byte 1 112
byte 1 0
align 1
LABELV $162
byte 1 97
byte 1 99
byte 1 99
byte 1 111
byte 1 109
byte 1 112
byte 1 97
byte 1 110
byte 1 121
byte 1 95
byte 1 115
byte 1 116
byte 1 97
byte 1 114
byte 1 116
byte 1 0
align 1
LABELV $136
byte 1 121
byte 1 101
byte 1 115
byte 1 0
align 1
LABELV $135
byte 1 104
byte 1 101
byte 1 108
byte 1 112
byte 1 95
byte 1 115
byte 1 116
byte 1 97
byte 1 114
byte 1 116
byte 1 0
align 1
LABELV $64
byte 1 37
byte 1 115
byte 1 32
byte 1 97
byte 1 116
byte 1 32
byte 1 37
byte 1 50
byte 1 46
byte 1 49
byte 1 102
byte 1 32
byte 1 101
byte 1 110
byte 1 116
byte 1 101
byte 1 114
byte 1 101
byte 1 100
byte 1 32
byte 1 37
byte 1 115
byte 1 58
byte 1 32
byte 1 37
byte 1 115
byte 1 32
byte 1 102
byte 1 114
byte 1 111
byte 1 109
byte 1 32
byte 1 37
byte 1 115
byte 1 10
byte 1 0
align 1
LABELV $62
byte 1 0
align 1
LABELV $61
byte 1 37
byte 1 115
byte 1 0
align 1
LABELV $56
byte 1 37
byte 1 115
byte 1 32
byte 1 97
byte 1 116
byte 1 32
byte 1 37
byte 1 49
byte 1 46
byte 1 49
byte 1 102
byte 1 32
byte 1 115
byte 1 119
byte 1 105
byte 1 116
byte 1 99
byte 1 104
byte 1 101
byte 1 100
byte 1 32
byte 1 109
byte 1 111
byte 1 114
byte 1 101
byte 1 32
byte 1 116
byte 1 104
byte 1 97
byte 1 110
byte 1 32
byte 1 37
byte 1 100
byte 1 32
byte 1 65
byte 1 73
byte 1 32
byte 1 110
byte 1 111
byte 1 100
byte 1 101
byte 1 115
byte 1 10
byte 1 0
|
src/security-auth-openid.adb | Letractively/ada-security | 0 | 23865 | -----------------------------------------------------------------------
-- security-openid -- OpenID 2.0 Support
-- Copyright (C) 2009, 2010, 2011, 2012 <NAME>
-- Written by <NAME> (<EMAIL>)
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
-----------------------------------------------------------------------
with Ada.Strings.Fixed;
with Ada.Text_IO;
with Util.Http.Clients;
with Util.Strings;
with Util.Encoders;
with Util.Log.Loggers;
with Util.Encoders.SHA1;
with Util.Encoders.HMAC.SHA1;
package body Security.Auth.OpenID is
use Ada.Strings.Fixed;
use Util.Log;
Log : constant Util.Log.Loggers.Logger := Loggers.Create ("Security.Auth.OpenID");
procedure Extract_Profile (Prefix : in String;
Request : in Parameters'Class;
Result : in out Authentication);
function Extract (From : String;
Start_Tag : String;
End_Tag : String) return String;
procedure Extract_Value (Into : in out Unbounded_String;
Request : in Parameters'Class;
Name : in String);
function Get_Association_Query return String;
-- ------------------------------
-- Initialize the OpenID authentication realm. Get the <tt>openid.realm</tt>
-- and <tt>openid.callback_url</tt> parameters to configure the realm.
-- ------------------------------
overriding
procedure Initialize (Realm : in out Manager;
Params : in Parameters'Class;
Name : in String := PROVIDER_OPENID) is
pragma Unreferenced (Name);
begin
Realm.Realm := To_Unbounded_String (Params.Get_Parameter ("openid.realm"));
Realm.Return_To := To_Unbounded_String (Params.Get_Parameter ("openid.callback_url"));
end Initialize;
-- ------------------------------
-- Discover the OpenID provider that must be used to authenticate the user.
-- The <b>Name</b> can be an URL or an alias that identifies the provider.
-- A cached OpenID provider can be returned.
-- Read the XRDS document from the URI and initialize the OpenID provider end point.
-- (See OpenID Section 7.3 Discovery)
-- ------------------------------
overriding
procedure Discover (Realm : in out Manager;
Name : in String;
Result : out End_Point) is
Client : Util.Http.Clients.Client;
Reply : Util.Http.Clients.Response;
begin
Log.Info ("Discover XRDS on {0}", Name);
Client.Add_Header ("Accept", "application/xrds+xml");
Client.Get (URL => Name,
Reply => Reply);
if Reply.Get_Status /= Util.Http.SC_OK then
Log.Error ("Received error {0} when discovering XRDS on {1}",
Util.Strings.Image (Reply.Get_Status), Name);
raise Service_Error with "Discovering XRDS of OpenID provider failed.";
end if;
Manager'Class (Realm).Extract_XRDS (Content => Reply.Get_Body,
Result => Result);
end Discover;
function Extract (From : String;
Start_Tag : String;
End_Tag : String) return String is
Pos : Natural := Index (From, Start_Tag);
Last : Natural;
Url_Pos : Natural;
begin
if Pos = 0 then
Pos := Index (From, Start_Tag (Start_Tag'First .. Start_Tag'Last - 1));
if Pos = 0 then
return "";
end if;
Pos := Index (From, ">", Pos + 1);
if Pos = 0 then
return "";
end if;
Url_Pos := Pos + 1;
else
Url_Pos := Pos + Start_Tag'Length;
end if;
Last := Index (From, End_Tag, Pos);
if Last <= Pos then
return "";
end if;
return From (Url_Pos .. Last - 1);
end Extract;
-- ------------------------------
-- Extract from the XRDS content the OpenID provider URI.
-- The default implementation is very basic as it returns the first <URI>
-- available in the stream without validating the XRDS document.
-- Raises the <b>Invalid_End_Point</b> exception if the URI cannot be found.
-- ------------------------------
procedure Extract_XRDS (Realm : in out Manager;
Content : in String;
Result : out End_Point) is
pragma Unreferenced (Realm);
URI : constant String := Extract (Content, "<URI>", "</URI>");
begin
if URI'Length = 0 then
raise Invalid_End_Point with "Cannot extract the <URI> from the XRDS document";
end if;
Result.URL := To_Unbounded_String (URI);
end Extract_XRDS;
function Get_Association_Query return String is
begin
return "openid.ns=http://specs.openid.net/auth/2.0&"
& "openid.mode=associate&"
& "openid.session_type=no-encryption&"
& "openid.assoc_type=HMAC-SHA1";
end Get_Association_Query;
-- ------------------------------
-- Associate the application (relying party) with the OpenID provider.
-- The association can be cached.
-- (See OpenID Section 8 Establishing Associations)
-- ------------------------------
overriding
procedure Associate (Realm : in out Manager;
OP : in End_Point;
Result : out Association) is
pragma Unreferenced (Realm);
Output : Unbounded_String;
URI : constant String := To_String (OP.URL);
Params : constant String := Get_Association_Query;
Client : Util.Http.Clients.Client;
Reply : Util.Http.Clients.Response;
Pos, Last, N : Natural;
begin
Client.Post (URL => URI,
Data => Params,
Reply => Reply);
if Reply.Get_Status /= Util.Http.SC_OK then
Log.Error ("Received error {0} when creating assoication with {1}",
Util.Strings.Image (Reply.Get_Status), URI);
raise Service_Error with "Cannot create association with OpenID provider.";
end if;
Output := To_Unbounded_String (Reply.Get_Body);
Pos := 1;
while Pos < Length (Output) loop
N := Index (Output, ":", Pos);
exit when N = 0;
Last := Index (Output, "" & ASCII.LF, N);
if Last = 0 then
Last := Length (Output);
else
Last := Last - 1;
end if;
declare
Key : constant String := Slice (Output, Pos, N - 1);
begin
if Key = "session_type" then
Result.Session_Type := Unbounded_Slice (Output, N + 1, Last);
elsif Key = "assoc_type" then
Result.Assoc_Type := Unbounded_Slice (Output, N + 1, Last);
elsif Key = "assoc_handle" then
Result.Assoc_Handle := Unbounded_Slice (Output, N + 1, Last);
elsif Key = "mac_key" then
Result.Mac_Key := Unbounded_Slice (Output, N + 1, Last);
elsif Key = "expires_in" then
declare
Val : constant String := Slice (Output, N + 1, Last);
-- Expires : Integer := Integer'Value (Val);
begin
Ada.Text_IO.Put_Line ("Expires: |" & Val & "|");
Result.Expired := Ada.Calendar.Clock;
end;
elsif Key /= "ns" then
Ada.Text_IO.Put_Line ("Key not recognized: " & Key);
end if;
end;
Pos := Last + 2;
end loop;
Log.Debug ("Received end point {0}", To_String (Output));
end Associate;
-- ------------------------------
-- Get the authentication URL to which the user must be redirected for authentication
-- by the authentication server.
-- ------------------------------
overriding
function Get_Authentication_URL (Realm : in Manager;
OP : in End_Point;
Assoc : in Association) return String is
Result : Unbounded_String := OP.URL;
Axa : constant String := "ax";
begin
if Index (Result, "?") > 0 then
Append (Result, "&");
else
Append (Result, "?");
end if;
Append (Result, "openid.ns=http://specs.openid.net/auth/2.0");
Append (Result, "&openid.claimed_id=http://specs.openid.net/auth/2.0/identifier_select");
Append (Result, "&openid.identity=http://specs.openid.net/auth/2.0/identifier_select");
Append (Result, "&openid.mode=checkid_setup");
Append (Result, "&openid.ns." & Axa & "=http://openid.net/srv/ax/1.0");
Append (Result, "&openid." & Axa & ".mode=fetch_request");
Append (Result, "&openid." & Axa & ".type.email=http://axschema.org/contact/email");
Append (Result, "&openid." & Axa & ".type.fullname=http://axschema.org/namePerson");
Append (Result, "&openid." & Axa & ".type.language=http://axschema.org/pref/language");
Append (Result, "&openid." & Axa & ".type.firstname=http://axschema.org/namePerson/first");
Append (Result, "&openid." & Axa & ".type.lastname=http://axschema.org/namePerson/last");
Append (Result, "&openid." & Axa & ".type.gender=http://axschema.org/person/gender");
Append (Result, "&openid." & Axa & ".required=email,fullname,language,firstname,"
& "lastname,gender");
Append (Result, "&openid.ns.sreg=http://openid.net/extensions/sreg/1.1");
Append (Result, "&openid.sreg.required=email,fullname,gender,country,nickname");
Append (Result, "&openid.return_to=");
Append (Result, Realm.Return_To);
Append (Result, "&openid.assoc_handle=");
Append (Result, Assoc.Assoc_Handle);
Append (Result, "&openid.realm=");
Append (Result, Realm.Realm);
return To_String (Result);
end Get_Authentication_URL;
procedure Extract_Value (Into : in out Unbounded_String;
Request : in Parameters'Class;
Name : in String) is
begin
if Length (Into) = 0 then
Into := To_Unbounded_String (Request.Get_Parameter (Name));
end if;
end Extract_Value;
procedure Extract_Profile (Prefix : in String;
Request : in Parameters'Class;
Result : in out Authentication) is
begin
Extract_Value (Result.Email, Request, Prefix & ".email");
Extract_Value (Result.Nickname, Request, Prefix & ".nickname");
Extract_Value (Result.Gender, Request, Prefix & ".gender");
Extract_Value (Result.Country, Request, Prefix & ".country");
Extract_Value (Result.Language, Request, Prefix & ".language");
Extract_Value (Result.Full_Name, Request, Prefix & ".fullname");
Extract_Value (Result.Timezone, Request, Prefix & ".timezone");
Extract_Value (Result.First_Name, Request, Prefix & ".firstname");
Extract_Value (Result.Last_Name, Request, Prefix & ".lastname");
-- If the fullname is not specified, try to build one from the first_name and last_name.
if Length (Result.Full_Name) = 0 then
Append (Result.Full_Name, Result.First_Name);
if Length (Result.First_Name) > 0 and Length (Result.Last_Name) > 0 then
Append (Result.Full_Name, " ");
Append (Result.Full_Name, Result.Last_Name);
end if;
end if;
end Extract_Profile;
-- ------------------------------
-- Verify the authentication result
-- ------------------------------
overriding
procedure Verify (Realm : in out Manager;
Assoc : in Association;
Request : in Parameters'Class;
Result : out Authentication) is
Mode : constant String := Request.Get_Parameter ("openid.mode");
begin
-- Step 1: verify the response status
if Mode = "cancel" then
Set_Result (Result, CANCEL, "Authentication refused");
return;
end if;
if Mode = "setup_needed" then
Set_Result (Result, SETUP_NEEDED, "Setup is needed");
return;
end if;
if Mode /= "id_res" then
Set_Result (Result, UNKNOWN, "Setup is needed");
return;
end if;
-- OpenID Section: 11.1. Verifying the Return URL
declare
Value : constant String := Request.Get_Parameter ("openid.return_to");
begin
if Value /= Realm.Return_To then
Set_Result (Result, UNKNOWN, "openid.return_to URL does not match");
return;
end if;
end;
-- OpenID Section: 11.2. Verifying Discovered Information
Manager'Class (Realm).Verify_Discovered (Assoc, Request, Result);
-- OpenID Section: 11.3. Checking the Nonce
declare
Value : constant String := Request.Get_Parameter ("openid.response_nonce");
begin
if Value = "" then
Set_Result (Result, UNKNOWN, "openid.response_nonce is empty");
return;
end if;
end;
-- OpenID Section: 11.4. Verifying Signatures
Manager'Class (Realm).Verify_Signature (Assoc, Request, Result);
declare
Value : constant String := Request.Get_Parameter ("openid.ns.sreg");
begin
-- Extract profile information
if Value = "http://openid.net/extensions/sreg/1.1" then
Extract_Profile ("openid.sreg", Request, Result);
end if;
end;
declare
Value : constant String := Request.Get_Parameter ("openid.ns.ax");
begin
if Value = "http://openid.net/srv/ax/1.0" then
Extract_Profile ("openid.ax.value", Request, Result);
end if;
end;
declare
Value : constant String := Request.Get_Parameter ("openid.ns.ext1");
begin
if Value = "http://openid.net/srv/ax/1.0" then
Extract_Profile ("openid.ext1.value", Request, Result);
end if;
end;
end Verify;
-- ------------------------------
-- Verify the signature part of the result
-- ------------------------------
procedure Verify_Signature (Realm : in Manager;
Assoc : in Association;
Request : in Parameters'Class;
Result : in out Authentication) is
pragma Unreferenced (Realm);
use type Util.Encoders.SHA1.Digest;
Signed : constant String := Request.Get_Parameter ("openid.signed");
Len : constant Natural := Signed'Length;
Sign : Unbounded_String;
Param : Unbounded_String;
Pos : Natural := 1;
Last : Natural;
begin
while Pos < Len loop
Last := Index (Signed, ",", Pos);
if Last > 0 then
Param := To_Unbounded_String (Signed (Pos .. Last - 1));
Pos := Last + 1;
else
Param := To_Unbounded_String (Signed (Pos .. Len));
Pos := Len + 1;
end if;
declare
Name : constant String := "openid." & To_String (Param);
Value : constant String := Request.Get_Parameter (Name);
begin
Append (Sign, Param);
Append (Sign, ':');
Append (Sign, Value);
Append (Sign, ASCII.LF);
end;
end loop;
Log.Info ("Signing: '{0}'", To_String (Sign));
declare
Decoder : constant Util.Encoders.Encoder := Util.Encoders.Create (Util.Encoders.BASE_64);
S : constant String := Request.Get_Parameter ("openid.sig");
Key : constant String := Decoder.Decode (To_String (Assoc.Mac_Key));
R : constant Util.Encoders.SHA1.Base64_Digest
:= Util.Encoders.HMAC.SHA1.Sign_Base64 (Key, To_String (Sign));
begin
Log.Info ("Signature: {0} - {1}", S, R);
if R /= S then
Set_Result (Result, INVALID_SIGNATURE, "openid.response_nonce is empty");
else
Set_Result (Result, AUTHENTICATED, "authenticated");
end if;
end;
end Verify_Signature;
-- ------------------------------
-- Verify the authentication result
-- ------------------------------
procedure Verify_Discovered (Realm : in out Manager;
Assoc : in Association;
Request : in Parameters'Class;
Result : out Authentication) is
pragma Unreferenced (Realm, Assoc);
begin
Result.Claimed_Id := To_Unbounded_String (Request.Get_Parameter ("openid.claimed_id"));
Result.Identity := To_Unbounded_String (Request.Get_Parameter ("openid.identity"));
end Verify_Discovered;
end Security.Auth.OpenID;
|
src/parser/TPKB.g4 | mniepert/TPKB | 3 | 324 | <reponame>mniepert/TPKB
//http://stackoverflow.com/questions/15610183/if-else-statements-in-antlr-using-listeners
grammar TPKB;
tpkb
: tpkb_class+
;
tpkb_class
: CLASS ID OBRACE
tpkb_class_subclass
tpkb_class_subpart
tpkb_class_attribute
CBRACE
;
tpkb_class_subclass
: (SUBCLASSES (ID FLOAT COMMA)* ID FLOAT SEMI | )
;
tpkb_class_subpart
: (PARTS (ID ID COMMA)* ID ID SEMI | )
;
tpkb_class_attribute
: (ATTRIBUTES (ID (DBTOKEN | CSVTOKEN) COMMA)* ID (DBTOKEN | CSVTOKEN) SEMI | )
;
DBTOKEN : 'IDB';
CSVTOKEN : 'ICSV';
COMMA : ',';
SEMI : ';';
CLASS : 'Class';
OR : '||';
AND : '&&';
EQ : '==';
NEQ : '!=';
GT : '>';
LT : '<';
GTEQ : '>=';
LTEQ : '<=';
PLUS : '+';
MINUS : '-';
MULT : '*';
DIV : '/';
MOD : '%';
POW : '^';
NOT : '!';
SCOL : ';';
ASSIGN : '=';
OPAR : '(';
CPAR : ')';
OBRACE : '{';
CBRACE : '}';
TRUE : 'true';
FALSE : 'false';
NIL : 'nil';
ATTRIBUTES : 'attributes';
SUBCLASSES : 'subclasses';
PARTS : 'parts';
ID
: [a-zA-Z_] [a-zA-Z_0-9]*
;
INT
: [0-9]+
;
FLOAT
: [0-9]+ '.' [0-9]*
| '.' [0-9]+
;
STRING
: '"' (~["\r\n] | '""')* '"'
;
COMMENT
: '#' ~[\r\n]* -> skip
;
SPACE
: [ \t\r\n] -> skip
;
OTHER
: .
; |
airhvctrl/vmintrin.asm | CKWindowsProject/airhv | 71 | 94020 | .CODE
__vm_call proc
mov rax,0CDAEFAEDBBAEBEEFh
vmcall
ret
__vm_call endp
__vm_call_ex proc
mov rax,0CDAEFAEDBBAEBEEFh ; Our vmcall indentitifer
sub rsp, 30h
mov qword ptr [rsp], r10
mov qword ptr [rsp + 8h], r11
mov qword ptr [rsp + 10h], r12
mov qword ptr [rsp + 18h], r13
mov qword ptr [rsp + 20h], r14
mov qword ptr [rsp + 28h], r15
mov r10, qword ptr [rsp + 58h]
mov r11, qword ptr [rsp + 60h]
mov r12, qword ptr [rsp + 68h]
mov r13, qword ptr [rsp + 70h]
mov r14, qword ptr [rsp + 78h]
mov r15, qword ptr [rsp + 80h]
vmcall
mov r10, qword ptr [rsp]
mov r11, qword ptr [rsp + 8h]
mov r12, qword ptr [rsp + 10h]
mov r13, qword ptr [rsp + 18h]
mov r14, qword ptr [rsp + 20h]
mov r15, qword ptr [rsp + 28h]
add rsp, 30h
ret
__vm_call_ex endp
END |
test/Succeed/MatchIrrelevant.agda | redfish64/autonomic-agda | 3 | 9258 | <reponame>redfish64/autonomic-agda
-- Andreas, 2011-10-03
-- allow matching on irrelevant data as long as there is at most one
-- matching constructor
{-# OPTIONS --experimental-irrelevance #-}
module MatchIrrelevant where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
data NAT : Nat -> Set where
Zero : NAT zero
Suc : (n : Nat) -> NAT n -> NAT (suc n)
-- should succeed:
f : (n : Nat).(N : NAT n) -> Nat
f zero Zero = zero
f (suc n) (Suc .n N) = f n N
-- prove the equations to test reduction
data _≡_ {A : Set}(a : A) : A → Set where
refl : a ≡ a
fzero : f zero Zero ≡ zero
fzero = refl
fsuc : (n : Nat)(N : NAT n) -> f (suc n) (Suc n N) ≡ f n N
fsuc n N = refl
{- DOES NOT YET WORK and probably should never work
fzero' : (N : NAT zero) → f zero N ≡ zero
fzero' N = refl
-}
{-
-- should fail:
f' : (n : Nat).(N : NAT n) -> Nat
f' zero Zero = zero
f' (suc _) (Suc n N) = n
-}
{-
-- should fail:
g : {n : Nat}.(N : NAT n) -> Nat
g Zero = zero
g (Suc _ N) = g N
-}
{-
data Fin : Nat -> Set where
zero : (n : Nat) -> Fin (suc n)
suc : (n : Nat) -> Fin n -> Fin (suc n)
-- should fail:
toNat : {n : Nat} → .(Fin n) -> Nat
toNat (zero n) = zero
toNat (suc n i) = suc (toNat i)
-}
{-
-- fails for other reasons
weak : {n : Nat} → .(Fin n) -> Fin (suc n)
weak (zero n) = zero (suc n)
weak (suc n i) = suc (suc n) (weak i)
-}
|
Lab2April/exam2.asm | forkkr/Assembly-Lab | 0 | 177638 | segment .data
scfmt: dq "%s",0
prr: dq "",10,0
fmt: dq "%lld",10,0
chk: dq "checked",10,0
balanced: dq "Color Balanced", 10 , 0
notbalanced: dq "Not Balanced",10,0
segment .bss
B: resq 1
G: resq 1
R: resq 1
Y: resq 1
str: resb 111
segment .text
global main
extern scanf
extern printf
main:
push RBP
mov RBP , RSP
xor rax , rax
mov rdi , scfmt
mov rsi , str
call scanf
xor rcx , rcx
push rcx
build_array:
pop rcx
push rcx
mov rbx , rcx
mov al , [str+rcx]
cmp al , 0
je _exit
cmp al , 66
je b_count
cmp al , 71
je g_count
cmp al , 82
je r_count
cmp al , 89
je y_count
b_count:
mov rdx , [B]
add rdx , 1
mov [B], rdx
jmp loop_control
g_count:
mov rdx , [G]
add rdx , 1
mov [G], rdx
jmp loop_control
r_count:
mov rdx , [R]
add rdx , 1
mov [R], rdx
jmp loop_control
y_count:
mov rdx , [Y]
add rdx , 1
mov [Y], rdx
jmp loop_control
loop_control:
pop rcx
inc rcx
push rcx
jmp build_array
_exit:
mov r8, [R]
mov r9, [G]
mov r10, [Y]
mov r11, [B]
cmp r8, r9
jne notbalanced_print
cmp r10, r11
jne notbalanced_print
xor rax ,rax
mov rdi , balanced
call printf
xor rax ,rax
mov rdi, prr
call printf
jmp the_end
notbalanced_print:
xor rax ,rax
mov rdi , notbalanced
call printf
xor rax ,rax
mov rdi, prr
call printf
the_end:
pop rbp
ret
|
other.7z/NEWS.7z/NEWS/テープリストア/NEWS_05/NEWS_05.tar/home/kimura/kart/risc.lzh/risc/join/Pause.asm | prismotizm/gigaleak | 0 | 1049 | Name: Pause.asm
Type: file
Size: 43998
Last-Modified: '1992-11-18T01:48:24Z'
SHA-1: 5EF37873932D83415B1BC750E16A6AE0DE882E18
Description: null
|
Transynther/x86/_processed/AVXALIGN/_zr_/i9-9900K_12_0xa0_notsx.log_7_1479.asm | ljhsiun2/medusa | 9 | 399 | <reponame>ljhsiun2/medusa<gh_stars>1-10
.global s_prepare_buffers
s_prepare_buffers:
push %r12
push %r14
push %r9
push %rax
push %rbp
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_A_ht+0x182d, %r9
nop
inc %r14
movb $0x61, (%r9)
nop
nop
nop
nop
nop
cmp $54974, %rbx
lea addresses_A_ht+0x10d, %rax
nop
nop
nop
nop
nop
sub $28219, %rdx
vmovups (%rax), %ymm0
vextracti128 $1, %ymm0, %xmm0
vpextrq $0, %xmm0, %r12
nop
nop
and %rbp, %rbp
lea addresses_A_ht+0x1616d, %rbx
nop
nop
nop
nop
xor %r12, %r12
vmovups (%rbx), %ymm3
vextracti128 $1, %ymm3, %xmm3
vpextrq $1, %xmm3, %rdx
nop
nop
nop
nop
sub $12060, %rbx
lea addresses_A_ht+0x135ad, %rbp
nop
nop
nop
cmp %rbx, %rbx
mov $0x6162636465666768, %rdx
movq %rdx, %xmm7
and $0xffffffffffffffc0, %rbp
movaps %xmm7, (%rbp)
nop
nop
sub $29512, %rdx
lea addresses_WC_ht+0xd1bd, %r14
nop
nop
nop
add %r12, %r12
mov (%r14), %dx
nop
nop
dec %r14
lea addresses_WC_ht+0x1782f, %rsi
lea addresses_A_ht+0x1ebf7, %rdi
clflush (%rsi)
clflush (%rdi)
nop
nop
inc %rdx
mov $109, %rcx
rep movsl
and %rsi, %rsi
lea addresses_normal_ht+0x3aeb, %rsi
lea addresses_WC_ht+0x12021, %rdi
nop
nop
nop
nop
nop
cmp %rbp, %rbp
mov $101, %rcx
rep movsb
nop
nop
nop
inc %rcx
lea addresses_D_ht+0x6bad, %rsi
nop
nop
dec %r14
mov (%rsi), %eax
nop
inc %rcx
lea addresses_WT_ht+0xbe6d, %rsi
lea addresses_WC_ht+0x1abd, %rdi
nop
nop
dec %rax
mov $82, %rcx
rep movsl
nop
nop
nop
nop
and $62818, %rsi
lea addresses_normal_ht+0xf4ad, %rsi
lea addresses_WC_ht+0x521c, %rdi
sub %r14, %r14
mov $74, %rcx
rep movsl
nop
nop
nop
nop
sub %rbx, %rbx
lea addresses_WT_ht+0x35cd, %rdi
nop
nop
nop
nop
sub $8916, %rsi
mov $0x6162636465666768, %r14
movq %r14, (%rdi)
nop
nop
sub $57995, %rdi
lea addresses_A_ht+0x14fad, %r9
nop
nop
nop
add %rdi, %rdi
and $0xffffffffffffffc0, %r9
movaps (%r9), %xmm7
vpextrq $1, %xmm7, %r14
sub %rsi, %rsi
lea addresses_WC_ht+0x1b9ed, %rax
clflush (%rax)
nop
nop
nop
xor $51025, %rcx
mov (%rax), %rbp
nop
nop
add %rsi, %rsi
lea addresses_A_ht+0x1c6a8, %rsi
nop
nop
nop
xor %r9, %r9
mov $0x6162636465666768, %rdx
movq %rdx, %xmm2
movups %xmm2, (%rsi)
nop
nop
nop
nop
dec %rbp
lea addresses_WC_ht+0xacb1, %rsi
lea addresses_A_ht+0x48ad, %rdi
nop
add %r12, %r12
mov $124, %rcx
rep movsw
nop
nop
nop
nop
nop
xor %rbx, %rbx
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %rax
pop %r9
pop %r14
pop %r12
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r13
push %r14
push %r15
push %rbp
push %rcx
// Load
lea addresses_RW+0x1d82d, %r15
nop
nop
cmp %r11, %r11
mov (%r15), %r13d
cmp $55928, %rcx
// Store
lea addresses_PSE+0x6fad, %rbp
nop
nop
nop
add %r10, %r10
movl $0x51525354, (%rbp)
sub $46566, %r13
// Faulty Load
lea addresses_US+0x27ad, %r13
nop
nop
nop
nop
and %r14, %r14
mov (%r13), %rcx
lea oracles, %r11
and $0xff, %rcx
shlq $12, %rcx
mov (%r11,%rcx,1), %rcx
pop %rcx
pop %rbp
pop %r15
pop %r14
pop %r13
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_US', 'AVXalign': False, 'size': 2, 'NT': False, 'same': False, 'congruent': 0}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_RW', 'AVXalign': False, 'size': 4, 'NT': True, 'same': False, 'congruent': 6}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'type': 'addresses_PSE', 'AVXalign': False, 'size': 4, 'NT': False, 'same': False, 'congruent': 11}}
[Faulty Load]
{'src': {'type': 'addresses_US', 'AVXalign': True, 'size': 8, 'NT': False, 'same': True, 'congruent': 0}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'type': 'addresses_A_ht', 'AVXalign': False, 'size': 1, 'NT': False, 'same': False, 'congruent': 7}}
{'src': {'type': 'addresses_A_ht', 'AVXalign': False, 'size': 32, 'NT': False, 'same': False, 'congruent': 5}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_A_ht', 'AVXalign': False, 'size': 32, 'NT': False, 'same': False, 'congruent': 6}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'type': 'addresses_A_ht', 'AVXalign': True, 'size': 16, 'NT': True, 'same': True, 'congruent': 9}}
{'src': {'type': 'addresses_WC_ht', 'AVXalign': False, 'size': 2, 'NT': True, 'same': False, 'congruent': 1}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_WC_ht', 'congruent': 1, 'same': True}, 'OP': 'REPM', 'dst': {'type': 'addresses_A_ht', 'congruent': 1, 'same': False}}
{'src': {'type': 'addresses_normal_ht', 'congruent': 1, 'same': True}, 'OP': 'REPM', 'dst': {'type': 'addresses_WC_ht', 'congruent': 2, 'same': False}}
{'src': {'type': 'addresses_D_ht', 'AVXalign': False, 'size': 4, 'NT': False, 'same': False, 'congruent': 10}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_WT_ht', 'congruent': 6, 'same': True}, 'OP': 'REPM', 'dst': {'type': 'addresses_WC_ht', 'congruent': 4, 'same': False}}
{'src': {'type': 'addresses_normal_ht', 'congruent': 8, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WC_ht', 'congruent': 0, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT_ht', 'AVXalign': False, 'size': 8, 'NT': False, 'same': False, 'congruent': 1}}
{'src': {'type': 'addresses_A_ht', 'AVXalign': True, 'size': 16, 'NT': False, 'same': False, 'congruent': 11}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_WC_ht', 'AVXalign': False, 'size': 8, 'NT': False, 'same': False, 'congruent': 6}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'type': 'addresses_A_ht', 'AVXalign': False, 'size': 16, 'NT': False, 'same': False, 'congruent': 0}}
{'src': {'type': 'addresses_WC_ht', 'congruent': 2, 'same': True}, 'OP': 'REPM', 'dst': {'type': 'addresses_A_ht', 'congruent': 8, 'same': False}}
{'00': 7}
00 00 00 00 00 00 00
*/
|
oeis/030/A030240.asm | neoneye/loda-programs | 11 | 90945 | ; A030240: Scaled Chebyshev U-polynomials evaluated at sqrt(7)/2.
; 1,7,42,245,1421,8232,47677,276115,1599066,9260657,53631137,310593360,1798735561,10416995407,60327818922,349375764605,2023335619781,11717718986232,67860683565157,393000752052475,2275980479411226,13180858091511257,76334143284700217,442072996352322720,2560171971473357521,14826692825847243607,85865645980617202602,497272672083389712965,2879849182719407572541,16678035574452125017032,96587304742129022111437,559364884173738279660835,3239443056021264802845786,18760547202932685662294657
mov $1,1
lpb $0
sub $0,1
sub $1,$2
add $2,$1
mul $1,7
lpe
mov $0,$1
|
programs/oeis/161/A161703.asm | karttu/loda | 1 | 172119 | ; A161703: a(n) = (4*n^3 - 12*n^2 + 14*n + 3)/3.
; 1,3,5,15,41,91,173,295,465,691,981,1343,1785,2315,2941,3671,4513,5475,6565,7791,9161,10683,12365,14215,16241,18451,20853,23455,26265,29291,32541,36023,39745,43715,47941,52431,57193,62235,67565,73191,79121,85363,91925,98815,106041,113611,121533,129815,138465,147491,156901,166703,176905,187515,198541,209991,221873,234195,246965,260191,273881,288043,302685,317815,333441,349571,366213,383375,401065,419291,438061,457383,477265,497715,518741,540351,562553,585355,608765,632791,657441,682723,708645,735215,762441,790331,818893,848135,878065,908691,940021,972063,1004825,1038315,1072541,1107511,1143233,1179715,1216965,1254991,1293801,1333403,1373805,1415015,1457041,1499891,1543573,1588095,1633465,1679691,1726781,1774743,1823585,1873315,1923941,1975471,2027913,2081275,2135565,2190791,2246961,2304083,2362165,2421215,2481241,2542251,2604253,2667255,2731265,2796291,2862341,2929423,2997545,3066715,3136941,3208231,3280593,3354035,3428565,3504191,3580921,3658763,3737725,3817815,3899041,3981411,4064933,4149615,4235465,4322491,4410701,4500103,4590705,4682515,4775541,4869791,4965273,5061995,5159965,5259191,5359681,5461443,5564485,5668815,5774441,5881371,5989613,6099175,6210065,6322291,6435861,6550783,6667065,6784715,6903741,7024151,7145953,7269155,7393765,7519791,7647241,7776123,7906445,8038215,8171441,8306131,8442293,8579935,8719065,8859691,9001821,9145463,9290625,9437315,9585541,9735311,9886633,10039515,10193965,10349991,10507601,10666803,10827605,10990015,11154041,11319691,11486973,11655895,11826465,11998691,12172581,12348143,12525385,12704315,12884941,13067271,13251313,13437075,13624565,13813791,14004761,14197483,14391965,14588215,14786241,14986051,15187653,15391055,15596265,15803291,16012141,16222823,16435345,16649715,16865941,17084031,17303993,17525835,17749565,17975191,18202721,18432163,18663525,18896815,19132041,19369211,19608333,19849415,20092465,20337491
mov $2,$0
bin $2,3
mul $2,4
add $0,$2
mov $1,$0
mul $1,2
add $1,1
|
libsrc/_DEVELOPMENT/z180/z180/__Unhandled_Trap.asm | jpoikela/z88dk | 640 | 86125 | SECTION code_crt_common
PUBLIC __Unhandled_Trap
EXTERN asm_abort
defc __Unhandled_Trap = asm_abort
|
source/league/matreshka-json_types.ads | svn2github/matreshka | 24 | 20347 | <filename>source/league/matreshka-json_types.ads
------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- Localization, Internationalization, Globalization for Ada --
-- --
-- Runtime Library Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2013, <NAME> <<EMAIL>> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
with Ada.Containers.Hashed_Maps;
with Ada.Containers.Vectors;
with League.Holders;
with League.Strings.Hash;
with Matreshka.Atomics.Counters;
with Matreshka.Internals.Strings;
package Matreshka.JSON_Types is
pragma Preelaborate;
type Value_Kinds is
(Empty_Value,
Boolean_Value,
Integer_Value,
Float_Value,
String_Value,
Array_Value,
Object_Value,
Null_Value);
-- JSON doesn't distinguish integer and float numbers, but we distinguish
-- them to avoid potential loss of precision on conversions.
type Shared_JSON_Value;
type Shared_JSON_Value_Access is access all Shared_JSON_Value;
-----------------------
-- Shared_JSON_Array --
-----------------------
package Value_Vectors is
new Ada.Containers.Vectors (Positive, Shared_JSON_Value_Access);
type Shared_JSON_Array is limited record
Counter : Matreshka.Atomics.Counters.Counter;
Values : Value_Vectors.Vector;
end record;
type Shared_JSON_Array_Access is access all Shared_JSON_Array;
Empty_Shared_JSON_Array : aliased Shared_JSON_Array
:= (Counter => <>, Values => <>);
procedure Reference (Self : not null Shared_JSON_Array_Access);
-- Increments internal reference counter.
procedure Dereference (Self : in out Shared_JSON_Array_Access);
-- Decrements internal reference counter and deallocates shared Array when
-- counter reach zero. Sets Self to null.
procedure Mutate (Self : in out not null Shared_JSON_Array_Access);
-- Mutate object: new shared object is allocated when reference counter is
-- greater than one, reference counter of original object is decremented
-- and original value is copied. Otherwise, shared object is unchanged.
------------------------
-- Shared_JSON_Object --
------------------------
package Value_Maps is
new Ada.Containers.Hashed_Maps
(League.Strings.Universal_String,
Shared_JSON_Value_Access,
League.Strings.Hash,
League.Strings."=");
type Shared_JSON_Object is limited record
Counter : Matreshka.Atomics.Counters.Counter;
Values : Value_Maps.Map;
end record;
type Shared_JSON_Object_Access is access all Shared_JSON_Object;
Empty_Shared_JSON_Object : aliased Shared_JSON_Object
:= (Counter => <>, Values => <>);
procedure Reference (Self : not null Shared_JSON_Object_Access);
-- Increments internal reference counter.
procedure Dereference (Self : in out Shared_JSON_Object_Access);
-- Decrements internal reference counter and deallocates shared object when
-- counter reach zero. Sets Self to null.
procedure Mutate (Self : in out not null Shared_JSON_Object_Access);
-- Mutate object: new shared object is allocated when reference counter is
-- greater than one, reference counter of original object is decremented
-- and original value is copied. Otherwise, shared object is unchanged.
-----------------------
-- Shared_JSON_Value --
-----------------------
type Internal_Value (Kind : Value_Kinds := Empty_Value) is record
case Kind is
when Empty_Value =>
null;
when Boolean_Value =>
Boolean_Value : Boolean;
when Integer_Value =>
Integer_Value : League.Holders.Universal_Integer;
when Float_Value =>
Float_Value : League.Holders.Universal_Float;
when String_Value =>
String_Value : Matreshka.Internals.Strings.Shared_String_Access
:= Matreshka.Internals.Strings.Shared_Empty'Access;
when Array_Value =>
Array_Value : Shared_JSON_Array_Access
:= Empty_Shared_JSON_Array'Access;
when Object_Value =>
Object_Value : Shared_JSON_Object_Access
:= Empty_Shared_JSON_Object'Access;
when Null_Value =>
null;
end case;
end record;
type Shared_JSON_Value is limited record
Counter : Matreshka.Atomics.Counters.Counter;
Value : Internal_Value;
end record;
Empty_Shared_JSON_Value : aliased Shared_JSON_Value
:= (Counter => <>, Value => (Kind => Empty_Value));
-- Preallocated shared object for empty value.
Null_Shared_JSON_Value : aliased Shared_JSON_Value
:= (Counter => <>, Value => (Kind => Null_Value));
-- Preallocated shared object for 'null' value.
procedure Reference (Self : not null Shared_JSON_Value_Access);
-- Increments internal reference counter.
procedure Dereference (Self : in out Shared_JSON_Value_Access);
-- Decrements internal reference counter and deallocates shared object when
-- counter reach zero. Sets Self to null.
procedure Mutate (Self : in out not null Shared_JSON_Value_Access);
-- Mutate object: new shared object is allocated when reference counter is
-- greater than one, reference counter of original object is decremented
-- and original value is copied. Otherwise, shared object is unchanged.
procedure Mutate
(Self : in out not null Shared_JSON_Value_Access;
Kind : Value_Kinds);
-- Mutate object: allocate new shared then reference counter is greater
-- than one, and decrement reference counter of original object. Value of
-- the object is reset to default value of specifid kind.
end Matreshka.JSON_Types;
|
15multitask/kernel_entry.asm | SwordYork/slef | 8 | 22079 | [bits 32]
[extern main]
call main
jmp $
|
Setoids/Intersection/Lemmas.agda | Smaug123/agdaproofs | 4 | 8451 | <reponame>Smaug123/agdaproofs
{-# OPTIONS --safe --warning=error --without-K #-}
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
open import LogicalFormulae
open import Sets.EquivalenceRelations
open import Setoids.Setoids
open import Setoids.Subset
module Setoids.Intersection.Lemmas {a b : _} {A : Set a} (S : Setoid {a} {b} A) {c d : _} {pred1 : A → Set c} {pred2 : A → Set d} (s1 : subset S pred1) (s2 : subset S pred2) where
open import Setoids.Intersection.Definition S
open import Setoids.Equality S
intersectionCommutative : intersection s1 s2 =S intersection s2 s1
intersectionCommutative i = (λ t → _&&_.snd t ,, _&&_.fst t) ,, λ t → _&&_.snd t ,, _&&_.fst t
intersectionAssociative : {e : _} {pred3 : A → Set e} (s3 : subset S pred3) → intersection (intersection s1 s2) s3 =S intersection s1 (intersection s2 s3)
intersectionAssociative s3 x = (λ pr → _&&_.fst (_&&_.fst pr) ,, (_&&_.snd (_&&_.fst pr) ,, _&&_.snd pr)) ,, λ z → (_&&_.fst z ,, _&&_.fst (_&&_.snd z)) ,, _&&_.snd (_&&_.snd z)
|
Miscellaneous/Chip16-Emulator/roms/Sources/ASCII.asm | ghivert/Student-Projects | 2 | 87819 | <gh_stars>1-10
;Ascii support for Chip16 ver 0.5
;Shendo 2010 - 2011
;
;Registers ra-rf are reserved for printing strings.
;Registers r0-r9 are free to use.
;
cls ;Start clean
spr #0F05 ;10x15 px sprites
:start ;Start of the program
ldi ra,10 ;X coordinate
ldi rb,10 ;Y coordinate
ldi rc,#AAAA ;Green color
ldi rd,string_data_0 ;Pointer to the "Hello World" string
call print_string ;Draw string on screen
ldi ra,10 ;X coordinate
ldi rb,50 ;Y coordinate
ldi rc,#FFFF ;White color
ldi rd,string_data_1 ;Pointer to the "The quick brown fox" string
call print_string ;Draw string on screen
ldi ra,10 ;X coordinate
ldi rb,65 ;Y coordinate
ldi rc,#FFFF ;White color
ldi rd,string_data_2 ;Pointer to the "jumps over the lazy dog" string
call print_string ;Draw string on screen
:loop
jmp loop ;Endless loop
:print_string ;Print string on screen
ldi re,font_data ;Pointer to the graphic data
ldm rf,rd ;Get ascii code
andi rf,255 ;Use only low part of the data
jz print_end ;If the char is null stop printing
subi rf,32 ;Convert to char offset
jc print_end ;If the char is below zero it's unprintable
muli rf,75 ;Convert char offset to byte offset
add re,rf ;Get the char sprite address
call copy_to_cache ;Copy char data to cache
drw ra,rb,font_cache ;Draw char on screen
addi ra,8 ;Increase X offset
addi rd,1 ;Point to next char
jmp print_string ;Print next char
:print_end
ret
:copy_to_cache
stm ra,var_cache0 ;Store register data
stm rb,var_cache1
stm rd,var_cache2
ldi ra,38 ;Word counter
ldi rb,font_cache ;Data cache pointer
:copy_loop
ldm rd,re ;Copy data to temp buffer
and rd,rc ;Apply desired color to the sprite
stm rd,rb ;Store modified data
addi re,2 ;Go to next word
addi rb,2 ;Point to next word in data cache
subi ra,1 ;Decrease counter
jz copy_end ;Desired data has been cached, end process
jmp copy_loop ;Go to next word
:copy_end
ldm ra,var_cache0 ;Recover register data
ldm rb,var_cache1
ldm rd,var_cache2
ret
:var_cache0
db #00
db #00
:var_cache1
db #00
db #00
:var_cache2
db #00
db #00
:string_data_0
db #48 ;H
db #65 ;e
db #6C ;l
db #6C ;l
db #6F ;o
db #20 ;
db #57 ;W
db #6F ;o
db #72 ;r
db #6C ;l
db #64 ;d
db #21 ;!
db #00 ;Null
:string_data_1
db #54 ;T
db #68 ;h
db #65 ;e
db #20 ;
db #71 ;q
db #75 ;u
db #69 ;i
db #63 ;c
db #6B ;k
db #20 ;
db #62 ;b
db #72 ;r
db #6F ;o
db #77 ;w
db #6E ;n
db #20 ;
db #66 ;f
db #6F ;o
db #78 ;x
db #00 ;Null
:string_data_2
db #6A ;j
db #75 ;u
db #6D ;m
db #70 ;p
db #73 ;s
db #20 ;
db #6F ;o
db #76 ;v
db #65 ;e
db #72 ;r
db #20 ;
db #74 ;t
db #68 ;h
db #65 ;e
db #20 ;
db #6C ;l
db #61 ;a
db #7A ;z
db #79 ;y
db #20 ;
db #64 ;d
db #6F ;o
db #67 ;g
db #2E ;.
db #00 ;Null
:font_data
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #0F
db #F0
db #00
db #00
db #FF
db #0F
db #F0
db #00
db #0F
db #FF
db #FF
db #FF
db #00
db #00
db #FF
db #0F
db #F0
db #00
db #00
db #FF
db #0F
db #F0
db #00
db #00
db #FF
db #0F
db #F0
db #00
db #0F
db #FF
db #FF
db #FF
db #00
db #00
db #FF
db #0F
db #F0
db #00
db #00
db #FF
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #00
db #00
db #00
db #FF
db #0F
db #F0
db #00
db #00
db #FF
db #0F
db #F0
db #F0
db #00
db #0F
db #FF
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #FF
db #F0
db #00
db #0F
db #0F
db #F0
db #FF
db #00
db #00
db #0F
db #F0
db #FF
db #00
db #00
db #00
db #FF
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #F0
db #00
db #00
db #0F
db #F0
db #FF
db #00
db #00
db #0F
db #F0
db #FF
db #00
db #00
db #00
db #FF
db #F0
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #FF
db #FF
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #F0
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #0F
db #F0
db #00
db #00
db #0F
db #FF
db #00
db #00
db #0F
db #FF
db #FF
db #FF
db #00
db #00
db #0F
db #FF
db #00
db #00
db #00
db #FF
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #00
db #00
db #00
db #0F
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #00
db #00
db #00
db #0F
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #F0
db #00
db #00
db #FF
db #00
db #FF
db #00
db #00
db #FF
db #0F
db #FF
db #00
db #00
db #FF
db #0F
db #FF
db #00
db #00
db #FF
db #00
db #FF
db #00
db #00
db #FF
db #F0
db #FF
db #00
db #00
db #FF
db #F0
db #FF
db #00
db #00
db #FF
db #00
db #FF
db #00
db #00
db #0F
db #FF
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #FF
db #00
db #00
db #0F
db #FF
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #0F
db #FF
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #0F
db #F0
db #00
db #00
db #FF
db #0F
db #F0
db #00
db #00
db #FF
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #FF
db #FF
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #0F
db #FF
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #FF
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #FF
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #00
db #00
db #00
db #0F
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #00
db #00
db #00
db #0F
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #00
db #00
db #00
db #0F
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #00
db #00
db #00
db #0F
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #FF
db #00
db #00
db #FF
db #00
db #FF
db #00
db #00
db #FF
db #00
db #FF
db #00
db #FF
db #FF
db #00
db #FF
db #0F
db #F0
db #FF
db #00
db #FF
db #0F
db #F0
db #FF
db #00
db #FF
db #00
db #FF
db #FF
db #00
db #FF
db #00
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #FF
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #F0
db #00
db #00
db #0F
db #F0
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #FF
db #00
db #00
db #0F
db #FF
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #FF
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #FF
db #00
db #00
db #0F
db #F0
db #FF
db #00
db #00
db #0F
db #FF
db #F0
db #00
db #00
db #0F
db #F0
db #FF
db #00
db #00
db #0F
db #F0
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #FF
db #00
db #0F
db #F0
db #00
db #FF
db #00
db #0F
db #FF
db #0F
db #FF
db #00
db #0F
db #F0
db #F0
db #FF
db #00
db #0F
db #F0
db #F0
db #FF
db #00
db #0F
db #F0
db #F0
db #FF
db #00
db #0F
db #F0
db #00
db #FF
db #00
db #0F
db #F0
db #00
db #FF
db #00
db #0F
db #F0
db #00
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #FF
db #00
db #0F
db #F0
db #00
db #FF
db #00
db #0F
db #FF
db #00
db #FF
db #00
db #0F
db #FF
db #F0
db #FF
db #00
db #0F
db #F0
db #FF
db #FF
db #00
db #0F
db #F0
db #0F
db #FF
db #00
db #0F
db #F0
db #00
db #FF
db #00
db #0F
db #F0
db #00
db #FF
db #00
db #0F
db #F0
db #00
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #FF
db #00
db #0F
db #F0
db #00
db #FF
db #00
db #0F
db #F0
db #00
db #FF
db #00
db #0F
db #F0
db #F0
db #FF
db #00
db #0F
db #F0
db #F0
db #FF
db #00
db #0F
db #F0
db #F0
db #FF
db #00
db #00
db #FF
db #0F
db #F0
db #00
db #00
db #FF
db #0F
db #F0
db #00
db #00
db #FF
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #0F
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #F0
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #FF
db #FF
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #FF
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #F0
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #FF
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #0F
db #FF
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #0F
db #FF
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #FF
db #00
db #00
db #0F
db #FF
db #F0
db #00
db #00
db #0F
db #F0
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #0F
db #F0
db #F0
db #FF
db #00
db #0F
db #F0
db #F0
db #FF
db #00
db #0F
db #F0
db #F0
db #FF
db #00
db #0F
db #F0
db #F0
db #FF
db #00
db #0F
db #F0
db #F0
db #FF
db #00
db #0F
db #F0
db #00
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #FF
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #FF
db #F0
db #00
db #0F
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #FF
db #F0
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #0F
db #FF
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #0F
db #FF
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #FF
db #00
db #0F
db #F0
db #F0
db #FF
db #00
db #0F
db #F0
db #F0
db #FF
db #00
db #0F
db #F0
db #F0
db #FF
db #00
db #0F
db #F0
db #F0
db #FF
db #00
db #00
db #FF
db #0F
db #F0
db #00
db #00
db #FF
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #FF
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #0F
db #F0
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #FF
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #FF
db #FF
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #0F
db #F0
db #00
db #00
db #00
db #FF
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #0F
db #FF
db #00
db #0F
db #00
db #FF
db #0F
db #F0
db #FF
db #00
db #F0
db #00
db #FF
db #F0
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
db #00
:font_cache ;Copied font data is stored here |
masm(msdos)/cadeasiguales.asm | GioProyects/ensamblador | 0 | 20759 | PAGE 60,132
TITLE ESCANECADENAS cadenas iguales .exe
.model small
.stack 64
.data
cad1 db "h<NAME>undo$"
cad2 db "hola mundo$"
msg db "son iguales$"
msg2 db "no son iguales$"
conta dw 0
.code
begin proc far
mov ax,@data
mov ds,ax
comienzo:
mov si,conta
mov al,cad2[si]
cmp cad1[si],al
jne fin
cmp cad1[si],"$"
jz final
inc conta
loop comienzo
final:
mov dx,offset msg
mov ah,09h
int 21h
jmp salir
fin:
mov dx,offset msg2
mov ah,09h
int 21h
salir:
mov ax,4c00h
int 21h
begin endp
end begin
|
libsrc/_DEVELOPMENT/l/sdcc/____sdcc_ll_add_deix_hlix.asm | jpoikela/z88dk | 640 | 15208 |
SECTION code_clib
SECTION code_l_sdcc
PUBLIC ____sdcc_ll_add_deix_hlix
EXTERN l_add_64_mde_mhl
____sdcc_ll_add_deix_hlix:
; deix = deix + hlix
push de ; save deix
IFDEF __SDCC_IX
push ix
pop de ; de = ix
ELSE
push iy
pop de
ENDIF
add hl,de
ex (sp),hl ; save hlix + ix
add hl,de
ex de,hl ; de = deix + ix
pop hl ; hl = hlix + ix
jp l_add_64_mde_mhl
|
scripts/Route15.asm | opiter09/ASM-Machina | 1 | 26754 | Route15_Script:
call EnableAutoTextBoxDrawing
ld hl, Route15TrainerHeaders
ld de, Route15_ScriptPointers
ld a, [wRoute15CurScript]
call ExecuteCurMapScriptInTable
ld [wRoute15CurScript], a
ret
Route15_ScriptPointers:
dw CheckFightingMapTrainers
dw DisplayEnemyTrainerTextAndStartBattle
dw EndTrainerBattle
Route15_TextPointers:
dw Route15Text1
dw Route15Text2
dw Route15Text3
dw Route15Text4
dw Route15Text5
dw Route15Text6
dw Route15Text7
dw Route15Text8
dw Route15Text9
dw Route15Text10
dw PickUpItemText
dw Route15Text12
Route15TrainerHeaders:
def_trainers
Route15TrainerHeader0:
trainer EVENT_BEAT_ROUTE_15_TRAINER_0, 2, Route15BattleText1, Route15EndBattleText1, Route15AfterBattleText1
Route15TrainerHeader1:
trainer EVENT_BEAT_ROUTE_15_TRAINER_1, 3, Route15BattleText2, Route15EndBattleText2, Route15AfterBattleText2
Route15TrainerHeader2:
trainer EVENT_BEAT_ROUTE_15_TRAINER_2, 3, Route15BattleText3, Route15EndBattleText3, Route15AfterBattleText3
Route15TrainerHeader3:
trainer EVENT_BEAT_ROUTE_15_TRAINER_3, 3, Route15BattleText4, Route15EndBattleText4, Route15AfterBattleText4
Route15TrainerHeader4:
trainer EVENT_BEAT_ROUTE_15_TRAINER_4, 2, Route15BattleText5, Route15EndBattleText5, Route15AfterBattleText5
Route15TrainerHeader5:
trainer EVENT_BEAT_ROUTE_15_TRAINER_5, 3, Route15BattleText6, Route15EndBattleText6, Route15AfterBattleText6
Route15TrainerHeader6:
trainer EVENT_BEAT_ROUTE_15_TRAINER_6, 3, Route15BattleText7, Route15EndBattleText7, Route15AfterBattleText7
Route15TrainerHeader7:
trainer EVENT_BEAT_ROUTE_15_TRAINER_7, 3, Route15BattleText8, Route15EndBattleText8, Route15AfterBattleText8
Route15TrainerHeader8:
trainer EVENT_BEAT_ROUTE_15_TRAINER_8, 3, Route15BattleText9, Route15EndBattleText9, Route15AfterBattleText9
Route15TrainerHeader9:
trainer EVENT_BEAT_ROUTE_15_TRAINER_9, 3, Route15BattleText10, Route15EndBattleText10, Route15AfterBattleText10
db -1 ; end
Route15Text1:
text_asm
ld hl, Route15TrainerHeader0
jr Route15TalkToTrainer
Route15Text2:
text_asm
ld hl, Route15TrainerHeader1
jr Route15TalkToTrainer
Route15Text3:
text_asm
ld hl, Route15TrainerHeader2
jr Route15TalkToTrainer
Route15Text4:
text_asm
ld hl, Route15TrainerHeader3
jr Route15TalkToTrainer
Route15Text5:
text_asm
ld hl, Route15TrainerHeader4
jr Route15TalkToTrainer
Route15Text6:
text_asm
ld hl, Route15TrainerHeader5
jr Route15TalkToTrainer
Route15Text7:
text_asm
ld hl, Route15TrainerHeader6
jr Route15TalkToTrainer
Route15Text8:
text_asm
ld hl, Route15TrainerHeader7
jr Route15TalkToTrainer
Route15Text9:
text_asm
ld hl, Route15TrainerHeader8
jr Route15TalkToTrainer
Route15Text10:
text_asm
ld hl, Route15TrainerHeader9
Route15TalkToTrainer:
call TalkToTrainer
jp TextScriptEnd
Route15BattleText1:
text_far _Route15BattleText1
text_end
Route15EndBattleText1:
text_far _Route15EndBattleText1
text_end
Route15AfterBattleText1:
text_far _Route15AfterBattleText1
text_end
Route15BattleText2:
text_far _Route15BattleText2
text_end
Route15EndBattleText2:
text_far _Route15EndBattleText2
text_end
Route15AfterBattleText2:
text_far _Route15AfterBattleText2
text_end
Route15BattleText3:
text_far _Route15BattleText3
text_end
Route15EndBattleText3:
text_far _Route15EndBattleText3
text_end
Route15AfterBattleText3:
text_far _Route15AfterBattleText3
text_end
Route15BattleText4:
text_far _Route15BattleText4
text_end
Route15EndBattleText4:
text_far _Route15EndBattleText4
text_end
Route15AfterBattleText4:
text_far _Route15AfterBattleText4
text_end
Route15BattleText5:
text_far _Route15BattleText5
text_end
Route15EndBattleText5:
text_far _Route15EndBattleText5
text_end
Route15AfterBattleText5:
text_far _Route15AfterBattleText5
text_end
Route15BattleText6:
text_far _Route15BattleText6
text_end
Route15EndBattleText6:
text_far _Route15EndBattleText6
text_end
Route15AfterBattleText6:
text_far _Route15AfterBattleText6
text_end
Route15BattleText7:
text_far _Route15BattleText7
text_end
Route15EndBattleText7:
text_far _Route15EndBattleText7
text_end
Route15AfterBattleText7:
text_far _Route15AfterBattleText7
text_end
Route15BattleText8:
text_far _Route15BattleText8
text_end
Route15EndBattleText8:
text_far _Route15EndBattleText8
text_end
Route15AfterBattleText8:
text_far _Route15AfterBattleText8
text_end
Route15BattleText9:
text_far _Route15BattleText9
text_end
Route15EndBattleText9:
text_far _Route15EndBattleText9
text_end
Route15AfterBattleText9:
text_far _Route15AfterBattleText9
text_end
Route15BattleText10:
text_far _Route15BattleText10
text_end
Route15EndBattleText10:
text_far _Route15EndBattleText10
text_end
Route15AfterBattleText10:
text_far _Route15AfterBattleText10
text_end
Route15Text12:
text_far _Route15Text12
text_end
|
Task/String-length/Ada/string-length-1.ada | LaudateCorpus1/RosettaCodeData | 1 | 7024 | <filename>Task/String-length/Ada/string-length-1.ada
Str : String := "<NAME>";
Length : constant Natural := Str'Size / 8;
|
oeis/208/A208724.asm | neoneye/loda-programs | 11 | 167999 | ; A208724: Number of 2n-bead necklaces labeled with numbers 1..5 not allowing reversal, with neighbors differing by exactly 1.
; Submitted by <NAME>
; 4,7,12,25,52,131,316,835,2196,5935,16108,44369,122644,341803,956636,2690845,7596484,21524543,61171660,174342217,498112276,1426419859,4093181692,11767920119,33891544420,97764131647,282429537948,817028472961,2366564736724,6863038218843,19924948267228,57906882247255,168456380815460,490505347906087,1429472717114572,4169295435709001,12169835294351284,35548729443032995,103911670590311932,303941636563596475,889585277491970404,2605214027190054463,7633882962663652972,22381156868522560177
add $0,1
mov $2,$0
lpb $0
add $3,$1
cmp $3,$2
cmp $3,0
mul $3,$0
sub $0,1
mov $4,$2
gcd $4,$3
mov $3,3
pow $3,$4
add $1,$3
lpe
div $1,$2
mov $0,$1
add $0,1
|
programs/oeis/074/A074150.asm | karttu/loda | 1 | 172406 | <gh_stars>1-10
; A074150: Duplicate of A061925.
; 1,2,3,6,9,14,19,26,33,42,51,62,73,86,99,114,129,146,163,182,201,222
pow $0,2
mov $1,$0
add $1,3
div $1,2
|
src/words_engine/words_engine-list_package.ads | spr93/whitakers-words | 204 | 1596 | -- WORDS, a Latin dictionary, by <NAME> (USAF, Retired)
--
-- Copyright <NAME> (1936–2010)
--
-- This is a free program, which means it is proper to copy it and pass
-- it on to your friends. Consider it a developmental item for which
-- there is no charge. However, just for form, it is Copyrighted
-- (c). Permission is hereby freely given for any and all use of program
-- and data. You can sell it as your own, but at least tell me.
--
-- This version is distributed without obligation, but the developer
-- would appreciate comments and suggestions.
--
-- All parts of the WORDS system, source code and data files, are made freely
-- available to anyone who wishes to use them, for whatever purpose.
with Ada.Text_IO;
with Latin_Utils.Dictionary_Package; use Latin_Utils.Dictionary_Package;
with Latin_Utils.Config; use Latin_Utils.Config;
with Latin_Utils.Inflections_Package; use Latin_Utils.Inflections_Package;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Words_Engine.Explanation_Package; use Words_Engine.Explanation_Package;
package Words_Engine.List_Package is
-- SCROLL_LINE_NUMBER : INTEGER := 0;
-- OUTPUT_SCROLL_COUNT : INTEGER := 0;
--
type Word_Analysis is private;
function Analyse_Word (Pa : Parse_Array;
Pa_Last : Integer;
Raw_Word : String;
Xp : Explanations)
return Word_Analysis;
procedure List_Stems (Configuration : Configuration_Type;
Output : Ada.Text_IO.File_Type;
WA : Word_Analysis;
Input_Line : String);
procedure Unknown_Search (Unknown : in String;
Unknown_Count : out Dict_IO.Count);
procedure List_Neighborhood
(Output : Ada.Text_IO.File_Type;
Input_Word : String);
private
type Stem_Inflection_Record is
record
Stem : Stem_Type := Null_Stem_Type;
Ir : Inflection_Record := Null_Inflection_Record;
end record;
Stem_Inflection_Array_Size : constant := 12;
Stem_Inflection_Array_Array_Size : constant := 40;
type Stem_Inflection_Array is
array (Integer range <>) of Stem_Inflection_Record;
type Stem_Inflection_Array_Array is array (Integer range <>)
of Stem_Inflection_Array (1 .. Stem_Inflection_Array_Size);
type Dictionary_MNPC_Record is record
D_K : Dictionary_Kind := Default_Dictionary_Kind;
MNPC : MNPC_Type := Null_MNPC;
De : Dictionary_Entry := Null_Dictionary_Entry;
end record;
Dictionary_MNPC_Array_Size : constant := 40;
type Dictionary_MNPC_Array is array (1 .. Dictionary_MNPC_Array_Size)
of Dictionary_MNPC_Record;
type Word_Analysis is
record
Stem_IAA : Stem_Inflection_Array_Array
(1 .. Stem_Inflection_Array_Array_Size);
Dict : Dictionary_MNPC_Array;
I_Is_Pa_Last : Boolean;
Unknowns : Boolean;
The_Word : Unbounded_String;
Was_Trimmed : Boolean;
Xp : Explanations;
end record;
end Words_Engine.List_Package;
|
formalization/agda/Spire/DarkwingDuck/Primitive.agda | spire/spire | 43 | 15492 | <filename>formalization/agda/Spire/DarkwingDuck/Primitive.agda
{-# OPTIONS --type-in-type #-}
module Spire.DarkwingDuck.Primitive where
----------------------------------------------------------------------
infixr 4 _,_
infixr 5 _∷_
----------------------------------------------------------------------
postulate String : Set
{-# BUILTIN STRING String #-}
----------------------------------------------------------------------
data ⊥ : Set where
elimBot : (P : ⊥ → Set)
(v : ⊥) → P v
elimBot P ()
----------------------------------------------------------------------
data ⊤ : Set where
tt : ⊤
elimUnit : (P : ⊤ → Set)
(ptt : P tt)
(u : ⊤) → P u
elimUnit P ptt tt = ptt
----------------------------------------------------------------------
data Σ (A : Set) (B : A → Set) : Set where
_,_ : (a : A) (b : B a) → Σ A B
elimPair : (A : Set) (B : A → Set)
(P : Σ A B → Set)
(ppair : (a : A) (b : B a) → P (a , b))
(ab : Σ A B) → P ab
elimPair A B P ppair (a , b) = ppair a b
----------------------------------------------------------------------
data _≡_ {A : Set} (x : A) : {B : Set} → B → Set where
refl : x ≡ x
elimEq : (A : Set) (x : A) (P : (y : A) → x ≡ y → Set)
(prefl : P x refl)
(y : A) (q : x ≡ y) → P y q
elimEq A .x P prefl x refl = prefl
----------------------------------------------------------------------
data Enum : Set where
[] : Enum
_∷_ : (x : String) (xs : Enum) → Enum
elimEnum : (P : Enum → Set)
(pnil : P [])
(pcons : (x : String) (xs : Enum) → P xs → P (x ∷ xs))
(xs : Enum) → P xs
elimEnum P pnil pcons [] = pnil
elimEnum P pnil pcons (x ∷ xs) = pcons x xs (elimEnum P pnil pcons xs)
----------------------------------------------------------------------
data Tag : Enum → Set where
here : ∀{x xs} → Tag (x ∷ xs)
there : ∀{x xs} → Tag xs → Tag (x ∷ xs)
Branches : (E : Enum) (P : Tag E → Set) → Set
Branches [] P = ⊤
Branches (l ∷ E) P = Σ (P here) (λ _ → Branches E (λ t → P (there t)))
case : (E : Enum) (P : Tag E → Set) (cs : Branches E P) (t : Tag E) → P t
case (ℓ ∷ E) P ccs here = elimPair (P here) (λ _ → Branches E (λ t → P (there t))) (λ _ → P here)
(λ c cs → c) ccs
case (ℓ ∷ E) P ccs (there t) = elimPair (P here) (λ _ → Branches E (λ t → P (there t))) (λ _ → P (there t))
(λ c cs → case E (λ t → P (there t)) cs t) ccs
----------------------------------------------------------------------
data Tel : Set₁ where
Emp : Tel
Ext : (A : Set) (B : A → Tel) → Tel
elimTel : (P : Tel → Set)
(pemp : P Emp)
(pext : (A : Set) (B : A → Tel) (pb : (a : A) → P (B a)) → P (Ext A B))
(T : Tel) → P T
elimTel P pemp pext Emp = pemp
elimTel P pemp pext (Ext A B) = pext A B (λ a → elimTel P pemp pext (B a))
----------------------------------------------------------------------
data Desc (I : Set) : Set₁ where
End : (i : I) → Desc I
Rec : (i : I) (D : Desc I) → Desc I
Arg : (A : Set) (B : A → Desc I) → Desc I
elimDesc : (I : Set) (P : Desc I → Set)
(pend : (i : I) → P (End i))
(prec : (i : I) (D : Desc I) (pd : P D) → P (Rec i D))
(parg : (A : Set) (B : A → Desc I) (pb : (a : A) → P (B a)) → P (Arg A B))
(D : Desc I) → P D
elimDesc I P pend prec parg (End i) = pend i
elimDesc I P pend prec parg (Rec i D) = prec i D (elimDesc I P pend prec parg D)
elimDesc I P pend prec parg (Arg A B) = parg A B (λ a → elimDesc I P pend prec parg (B a))
Func : (I : Set) (D : Desc I) → (I → Set) → I → Set
Func I (End j) X i = j ≡ i
Func I (Rec j D) X i = Σ (X j) (λ _ → Func I D X i)
Func I (Arg A B) X i = Σ A (λ a → Func I (B a) X i)
Hyps : (I : Set) (D : Desc I) (X : I → Set) (M : (i : I) → X i → Set) (i : I) (xs : Func I D X i) → Set
Hyps I (End j) X M i q = ⊤
Hyps I (Rec j D) X M i = elimPair (X j) (λ _ → Func I D X i) (λ _ → Set)
(λ x xs → Σ (M j x) (λ _ → Hyps I D X M i xs))
Hyps I (Arg A B) X M i = elimPair A (λ a → Func I (B a) X i) (λ _ → Set)
(λ a xs → Hyps I (B a) X M i xs)
----------------------------------------------------------------------
data μ (ℓ : String) (P I : Set) (D : Desc I) (p : P) (i : I) : Set where
init : Func I D (μ ℓ P I D p) i → μ ℓ P I D p i
prove : (I : Set) (D : Desc I) (X : I → Set) (M : (i : I) → X i → Set)
(m : (i : I) (x : X i) → M i x)
(i : I) (xs : Func I D X i)
→ Hyps I D X M i xs
prove I (End j) X M m i q = tt
prove I (Rec j D) X M m i = elimPair (X j) (λ _ → Func I D X i)
(λ xxs → Hyps I (Rec j D) X M i xxs)
(λ x xs → m j x , prove I D X M m i xs)
prove I (Arg A B) X M m i = elimPair A (λ a → Func I (B a) X i)
(λ axs → Hyps I (Arg A B) X M i axs)
(λ a xs → prove I (B a) X M m i xs)
{-# NO_TERMINATION_CHECK #-}
ind : (ℓ : String) (P I : Set) (D : Desc I) (p : P)
(M : (i : I) → μ ℓ P I D p i → Set)
(α : ∀ i (xs : Func I D (μ ℓ P I D p) i) (ihs : Hyps I D (μ ℓ P I D p) M i xs) → M i (init xs))
(i : I)
(x : μ ℓ P I D p i)
→ M i x
ind ℓ P I D p M α i (init xs) = α i xs (prove I D (μ ℓ P I D p) M (ind ℓ P I D p M α) i xs)
----------------------------------------------------------------------
|
oeis/342/A342040.asm | neoneye/loda-programs | 11 | 83547 | ; A342040: Binary palindromes of odd length.
; Submitted by <NAME>(s4)
; 1,101,111,10001,10101,11011,11111,1000001,1001001,1010101,1011101,1100011,1101011,1110111,1111111,100000001,100010001,100101001,100111001,101000101,101010101,101101101,101111101,110000011,110010011,110101011
seq $0,48700 ; Binary palindromes of odd length (written in base 10).
seq $0,7088 ; The binary numbers (or binary words, or binary vectors, or binary expansion of n): numbers written in base 2.
|
orka/src/orka/implementation/orka-inputs-joysticks-chords.adb | onox/orka | 52 | 13266 | <gh_stars>10-100
-- SPDX-License-Identifier: Apache-2.0
--
-- Copyright (c) 2019 onox <<EMAIL>>
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
package body Orka.Inputs.Joysticks.Chords is
function Create_Chord
(Buttons : Button_Index_Array;
Frames : Positive) return Chord is
begin
return
(Frame_Count => Frames,
Button_Count => Buttons'Length,
Buttons => Buttons,
States => (others => (others => False)),
Frame_Index => 1);
end Create_Chord;
function Detect_Activation
(Object : in out Chord;
Joystick : Joystick_Input'Class) return Boolean
is
Current_State : constant Joystick_State := Joystick.Current_State;
Pressed_Buttons : Boolean_Button_States := (others => False);
begin
Object.States (Object.Frame_Index) := Joystick.Just_Pressed;
for State of Object.States loop
Pressed_Buttons := Pressed_Buttons or State;
end loop;
if Object.Frame_Index < Object.Frame_Count then
Object.Frame_Index := Object.Frame_Index + 1;
else
Object.Frame_Index := 1;
end if;
return Result : constant Boolean :=
(for all Index of Object.Buttons =>
Current_State.Buttons (Index) = Pressed and Pressed_Buttons (Index))
do
if Result then
Object.States := (others => (others => False));
end if;
end return;
end Detect_Activation;
end Orka.Inputs.Joysticks.Chords;
|
codigo/capitulo 39/archivo_apertura.asm | codeneomatrix/ENSAMBLADOR-x86-ACEVEDO | 1 | 27750 | segment .data
MsgError db "se produjo un error",0xA,0xD ;mensaje en caso de
; existir un error al crear el archivo los numeros
; hexadecimales son equivalentes a los numeros decimales
; 10 y 13 los cuales permiten el salto de linea
lon equ $ -MsgError
MsgExito db "archivo abierto con exito",0xA,0xD
lonexito equ $ -MsgExito
archivo db "/home/neomatrix/codigo ensamblador/prueba.txt",0
; ubicacion en el sistema de archivos del archivo a crear y
; y su nombre (prueba.txt), se usa el 0 como indicador
; de fin de cadena
segment .bss
idarchivo resd 1
segment .text
global _start
_start:
; abrimos el archivo
mov eax,5 ; indicamos que abriremos un archivo
mov ebx,archivo ; indicamos la ruta y el nombre del archivo
mov ecx, 0; indicamos el modo de apertura del archivo
; solo lectura = 0000h
; solo escritura = 0001h
; lectura/escritura = 0002h
; banderas
; escritura la final del archivo = 0400h
; trunca a cero la longitud el archivo = 0200h
; crea el archivo si no existe = 0040h, es necesario indicar los permisos
; mod edx, 640q
; O_ACCMODE = 3h
; O_ASYNC = 2000h
; O_CLOEXEC= 80000h
; O_DIRECT = 4000h
; O_DIRECTORY = 10000h
; O_DSYNC = 1000h
; O_EXCL = 80h
; O_FSYNC = 101000h
; O_NDELAY = 800h
; O_NOATIME= 40000h
; O_NOCTTY = 100h
; O_NOFOLLOW = 20000h
; O_NONBLOCK = 800h
; O_RSYNC = 101000h
; O_SYNC = 101000h
int 80h
cmp eax,0 ; el descriptor de archivo es un numero entero
; no negativo
jl error ; de ser negativo ha ocurrido un error
mov dword[idarchivo] , eax ; guardamos el descriptor del archivo
; en memoria, para su uso posterior
mov eax, 4
mov ebx, 1
mov ecx, MsgExito
mov edx, lonexito
int 80h
;cierre del archivo
mov eax, 6
mov ebx, [idarchivo] ; colocamos el descriptor de archivo
int 80h
jmp salir
error:
; Mostramos el mensaje de error
mov eax, 4
mov ebx, 1
mov ecx, MsgError
mov edx, lon
int 80h
salir:
mov eax, 1
xor ebx,ebx
int 0x80 |
libsrc/_DEVELOPMENT/l/sdcc/__mulint_callee.asm | jpoikela/z88dk | 640 | 90605 | <filename>libsrc/_DEVELOPMENT/l/sdcc/__mulint_callee.asm
SECTION code_clib
SECTION code_l_sdcc
PUBLIC __mulint_callee
EXTERN l_mulu_16_16x16
__mulint_callee:
; 16-bit multiplication, LSW 16-bit result
;
; enter : stack = multiplicand, multiplicand, ret
;
; exit : hl = product
pop af
pop hl
pop de
push af
jp l_mulu_16_16x16
|
vendor/stdlib/src/Data/Bool/Properties.agda | isabella232/Lemmachine | 56 | 6281 | ------------------------------------------------------------------------
-- A bunch of properties
------------------------------------------------------------------------
module Data.Bool.Properties where
open import Data.Bool as Bool
open import Data.Fin
open import Data.Function
open import Algebra
open import Algebra.Structures
import Algebra.RingSolver.Simple as Solver
import Algebra.RingSolver.AlmostCommutativeRing as ACR
open import Relation.Nullary using (_⇔_)
open import Relation.Binary.PropositionalEquality
import Algebra.FunctionProperties as P; open P _≡_
open import Data.Product
open import Data.Sum
open import Data.Empty
import Relation.Binary.EqReasoning as EqR; open EqR Bool.setoid
------------------------------------------------------------------------
-- Duality
-- Can we take advantage of duality in some (nice) way?
------------------------------------------------------------------------
-- (Bool, ∨, ∧, false, true) forms a commutative semiring
private
∨-assoc : Associative _∨_
∨-assoc true y z = refl
∨-assoc false y z = refl
∧-assoc : Associative _∧_
∧-assoc true y z = refl
∧-assoc false y z = refl
∨-comm : Commutative _∨_
∨-comm true true = refl
∨-comm true false = refl
∨-comm false true = refl
∨-comm false false = refl
∧-comm : Commutative _∧_
∧-comm true true = refl
∧-comm true false = refl
∧-comm false true = refl
∧-comm false false = refl
∨-identity : Identity false _∨_
∨-identity = (λ _ → refl) , (λ x → ∨-comm x false)
∧-identity : Identity true _∧_
∧-identity = (λ _ → refl) , (λ x → ∧-comm x true)
zero-∧ : Zero false _∧_
zero-∧ = (λ _ → refl) , (λ x → ∧-comm x false)
distrib-∧-∨ : _∧_ DistributesOver _∨_
distrib-∧-∨ = distˡ , distʳ
where
distˡ : _∧_ DistributesOverˡ _∨_
distˡ true y z = refl
distˡ false y z = refl
distʳ : _∧_ DistributesOverʳ _∨_
distʳ x y z =
begin
(y ∨ z) ∧ x
≈⟨ ∧-comm (y ∨ z) x ⟩
x ∧ (y ∨ z)
≈⟨ distˡ x y z ⟩
x ∧ y ∨ x ∧ z
≈⟨ cong₂ _∨_ (∧-comm x y) (∧-comm x z) ⟩
y ∧ x ∨ z ∧ x
∎
isCommutativeSemiring-∨-∧
: IsCommutativeSemiring _≡_ _∨_ _∧_ false true
isCommutativeSemiring-∨-∧ = record
{ isSemiring = record
{ isSemiringWithoutAnnihilatingZero = record
{ +-isCommutativeMonoid = record
{ isMonoid = record
{ isSemigroup = record
{ isEquivalence = isEquivalence
; assoc = ∨-assoc
; ∙-pres-≈ = cong₂ _∨_
}
; identity = ∨-identity
}
; comm = ∨-comm
}
; *-isMonoid = record
{ isSemigroup = record
{ isEquivalence = isEquivalence
; assoc = ∧-assoc
; ∙-pres-≈ = cong₂ _∧_
}
; identity = ∧-identity
}
; distrib = distrib-∧-∨
}
; zero = zero-∧
}
; *-comm = ∧-comm
}
commutativeSemiring-∨-∧ : CommutativeSemiring
commutativeSemiring-∨-∧ = record
{ _+_ = _∨_
; _*_ = _∧_
; 0# = false
; 1# = true
; isCommutativeSemiring = isCommutativeSemiring-∨-∧
}
module RingSolver =
Solver (ACR.fromCommutativeSemiring commutativeSemiring-∨-∧)
------------------------------------------------------------------------
-- (Bool, ∧, ∨, true, false) forms a commutative semiring
private
zero-∨ : Zero true _∨_
zero-∨ = (λ _ → refl) , (λ x → ∨-comm x true)
distrib-∨-∧ : _∨_ DistributesOver _∧_
distrib-∨-∧ = distˡ , distʳ
where
distˡ : _∨_ DistributesOverˡ _∧_
distˡ true y z = refl
distˡ false y z = refl
distʳ : _∨_ DistributesOverʳ _∧_
distʳ x y z =
begin
(y ∧ z) ∨ x
≈⟨ ∨-comm (y ∧ z) x ⟩
x ∨ (y ∧ z)
≈⟨ distˡ x y z ⟩
(x ∨ y) ∧ (x ∨ z)
≈⟨ cong₂ _∧_ (∨-comm x y) (∨-comm x z) ⟩
(y ∨ x) ∧ (z ∨ x)
∎
isCommutativeSemiring-∧-∨
: IsCommutativeSemiring _≡_ _∧_ _∨_ true false
isCommutativeSemiring-∧-∨ = record
{ isSemiring = record
{ isSemiringWithoutAnnihilatingZero = record
{ +-isCommutativeMonoid = record
{ isMonoid = record
{ isSemigroup = record
{ isEquivalence = isEquivalence
; assoc = ∧-assoc
; ∙-pres-≈ = cong₂ _∧_
}
; identity = ∧-identity
}
; comm = ∧-comm
}
; *-isMonoid = record
{ isSemigroup = record
{ isEquivalence = isEquivalence
; assoc = ∨-assoc
; ∙-pres-≈ = cong₂ _∨_
}
; identity = ∨-identity
}
; distrib = distrib-∨-∧
}
; zero = zero-∨
}
; *-comm = ∨-comm
}
commutativeSemiring-∧-∨ : CommutativeSemiring
commutativeSemiring-∧-∨ = record
{ _+_ = _∧_
; _*_ = _∨_
; 0# = true
; 1# = false
; isCommutativeSemiring = isCommutativeSemiring-∧-∨
}
------------------------------------------------------------------------
-- (Bool, ∨, ∧, not, true, false) is a boolean algebra
private
absorptive : Absorptive _∨_ _∧_
absorptive = abs-∨-∧ , abs-∧-∨
where
abs-∨-∧ : _∨_ Absorbs _∧_
abs-∨-∧ true y = refl
abs-∨-∧ false y = refl
abs-∧-∨ : _∧_ Absorbs _∨_
abs-∧-∨ true y = refl
abs-∧-∨ false y = refl
not-∧-inverse : Inverse false not _∧_
not-∧-inverse =
¬x∧x≡⊥ , (λ x → ∧-comm x (not x) ⟨ trans ⟩ ¬x∧x≡⊥ x)
where
¬x∧x≡⊥ : LeftInverse false not _∧_
¬x∧x≡⊥ false = refl
¬x∧x≡⊥ true = refl
not-∨-inverse : Inverse true not _∨_
not-∨-inverse =
¬x∨x≡⊤ , (λ x → ∨-comm x (not x) ⟨ trans ⟩ ¬x∨x≡⊤ x)
where
¬x∨x≡⊤ : LeftInverse true not _∨_
¬x∨x≡⊤ false = refl
¬x∨x≡⊤ true = refl
isBooleanAlgebra : IsBooleanAlgebra _≡_ _∨_ _∧_ not true false
isBooleanAlgebra = record
{ isDistributiveLattice = record
{ isLattice = record
{ isEquivalence = isEquivalence
; ∨-comm = ∨-comm
; ∨-assoc = ∨-assoc
; ∨-pres-≈ = cong₂ _∨_
; ∧-comm = ∧-comm
; ∧-assoc = ∧-assoc
; ∧-pres-≈ = cong₂ _∧_
; absorptive = absorptive
}
; ∨-∧-distribʳ = proj₂ distrib-∨-∧
}
; ∨-complementʳ = proj₂ not-∨-inverse
; ∧-complementʳ = proj₂ not-∧-inverse
; ¬-pres-≈ = cong not
}
booleanAlgebra : BooleanAlgebra
booleanAlgebra = record
{ _∨_ = _∨_
; _∧_ = _∧_
; ¬_ = not
; ⊤ = true
; ⊥ = false
; isBooleanAlgebra = isBooleanAlgebra
}
------------------------------------------------------------------------
-- (Bool, xor, ∧, id, false, true) forms a commutative ring
private
xor-is-ok : ∀ x y → x xor y ≡ (x ∨ y) ∧ not (x ∧ y)
xor-is-ok true y = refl
xor-is-ok false y = sym $ proj₂ ∧-identity _
commutativeRing-xor-∧ : CommutativeRing
commutativeRing-xor-∧ = commutativeRing
where
import Algebra.Props.BooleanAlgebra as BA
open BA booleanAlgebra
open XorRing _xor_ xor-is-ok
module XorRingSolver =
Solver (ACR.fromCommutativeRing commutativeRing-xor-∧)
------------------------------------------------------------------------
-- Miscellaneous other properties
not-involutive : Involutive not
not-involutive true = refl
not-involutive false = refl
not-¬ : ∀ {x y} → x ≡ y → x ≢ not y
not-¬ {true} refl ()
not-¬ {false} refl ()
¬-not : ∀ {x y} → x ≢ y → x ≡ not y
¬-not {true} {true} x≢y = ⊥-elim (x≢y refl)
¬-not {true} {false} _ = refl
¬-not {false} {true} _ = refl
¬-not {false} {false} x≢y = ⊥-elim (x≢y refl)
⇔→≡ : {b₁ b₂ b : Bool} → b₁ ≡ b ⇔ b₂ ≡ b → b₁ ≡ b₂
⇔→≡ {true } {true } hyp = refl
⇔→≡ {true } {false} {true } hyp = sym (proj₁ hyp refl)
⇔→≡ {true } {false} {false} hyp = proj₂ hyp refl
⇔→≡ {false} {true } {true } hyp = proj₂ hyp refl
⇔→≡ {false} {true } {false} hyp = sym (proj₁ hyp refl)
⇔→≡ {false} {false} hyp = refl
T-≡ : ∀ {b} → T b ⇔ b ≡ true
T-≡ {false} = ((λ ()) , λ ())
T-≡ {true} = (const refl , const _)
T-∧ : ∀ {b₁ b₂} → T (b₁ ∧ b₂) ⇔ (T b₁ × T b₂)
T-∧ {true} {true} = (const (_ , _) , const _)
T-∧ {true} {false} = ((λ ()) , proj₂)
T-∧ {false} {_} = ((λ ()) , proj₁)
T-∨ : ∀ {b₁ b₂} → T (b₁ ∨ b₂) ⇔ (T b₁ ⊎ T b₂)
T-∨ {true} {b₂} = (inj₁ , const _)
T-∨ {false} {true} = (inj₂ , const _)
T-∨ {false} {false} = (inj₁ , [ id , id ])
proof-irrelevance : ∀ {b} (p q : T b) → p ≡ q
proof-irrelevance {true} _ _ = refl
proof-irrelevance {false} () ()
|
parse_clipboard.applescript | teake/pasterrr | 3 | 84 | <filename>parse_clipboard.applescript
on run argv
set theQuery to item 1 of argv
set textItemList to splitString(theQuery)
if textItemList is {} then
return
end if
set skipPrefix to (system attribute "skip_prefix")
set firstOk to false
repeat while not firstOk and textItemList is not {}
set firstTextItem to trimWhitespace(first item of textItemList)
set restTextItems to the rest of textItemList
set textItemList to restTextItems
set firstOk to (firstTextItem does not start with skipPrefix)
end repeat
set the clipboard to trimWhitespace(joinToString(restTextItems))
if firstOk then
set bundleID to (system attribute "alfred_workflow_bundleid")
tell application id "com.runningwithcrayons.Alfred"
run trigger "singleItemPaste" in workflow bundleID with argument firstTextItem
end tell
end if
end run
on splitString(thisString)
set previousDelimiters to AppleScript's text item delimiters
set AppleScript's text item delimiters to getDelimiter()
set textItemList to text items of thisString
set AppleScript's text item delimiters to previousDelimiters
return textItemList
end splitString
on joinToString(thisList)
set previousDelimiters to AppleScript's text item delimiters
set AppleScript's text item delimiters to getDelimiter()
set joinedString to thisList as text
set AppleScript's text item delimiters to previousDelimiters
return joinedString
end joinToString
on getDelimiter()
set prefD to (system attribute "delimiter")
return {linefeed & prefD & linefeed, return & prefD & return, return & prefD & return, character id 8233 & prefD & character id 8233, character id 8233 & prefD & character id 8233}
end getDelimiter
on trimWhitespace(this_text)
return trimString(this_text, return & linefeed & character id 8233 & character id 8232 & " ", 2)
end trimWhitespace
on trimString(this_text, trim_chars, trim_indicator)
-- 0 = beginning, 1 = end, 2 = both
-- TRIM BEGINNING
if the trim_indicator is in {0, 2} then
repeat while the length of this_text > 0 and trim_chars contains character 1 of this_text
try
set this_text to characters 2 thru -1 of this_text as string
on error
-- the text contains nothing but the trim characters
return ""
end try
end repeat
end if
-- TRIM ENDING
if the trim_indicator is in {1, 2} then
repeat while the length of this_text > 0 and trim_chars contains character -1 of this_text
try
set this_text to characters 1 thru -2 of this_text as string
on error
-- the text contains nothing but the trim characters
return ""
end try
end repeat
end if
return this_text
end trimString |
programs/oeis/147/A147612.asm | jmorken/loda | 1 | 83408 | ; A147612: If n is a Jacobsthal number then 1 else 0.
; 1,1,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
mov $11,$0
mov $13,2
lpb $13
clr $0,11
mov $0,$11
sub $13,1
add $0,$13
sub $0,1
mov $5,$0
mul $5,3
trn $5,1
add $6,2
add $6,$5
log $6,2
mov $1,$6
mov $14,$13
lpb $14
mov $12,$1
sub $14,1
lpe
lpe
lpb $11
mov $11,0
sub $12,$1
lpe
mov $1,$12
|
Transynther/x86/_processed/NONE/_xt_sm_/i3-7100_9_0x84_notsx.log_85_1401.asm | ljhsiun2/medusa | 9 | 245325 | .global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r12
push %r14
push %rax
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_normal_ht+0x1d222, %r12
nop
xor $2520, %rax
mov (%r12), %si
nop
xor $37008, %rbx
lea addresses_D_ht+0x1622, %rcx
nop
nop
nop
and %r11, %r11
vmovups (%rcx), %ymm0
vextracti128 $0, %ymm0, %xmm0
vpextrq $1, %xmm0, %r14
nop
nop
nop
add $26132, %r14
lea addresses_WC_ht+0x17622, %r11
nop
nop
nop
nop
add %r14, %r14
movups (%r11), %xmm2
vpextrq $1, %xmm2, %rbx
nop
sub %rsi, %rsi
lea addresses_WT_ht+0x637a, %rsi
lea addresses_A_ht+0x149e2, %rdi
cmp $29215, %rax
mov $73, %rcx
rep movsb
nop
inc %rdi
lea addresses_WC_ht+0x1b322, %rax
clflush (%rax)
add $9297, %r11
movups (%rax), %xmm2
vpextrq $1, %xmm2, %rcx
nop
nop
add %rbx, %rbx
lea addresses_D_ht+0xfcd2, %rsi
lea addresses_D_ht+0x1cb82, %rdi
nop
add $27010, %r12
mov $25, %rcx
rep movsq
nop
nop
nop
xor %r14, %r14
lea addresses_UC_ht+0x9a22, %rsi
lea addresses_WC_ht+0x1ce22, %rdi
nop
nop
nop
add $34482, %rbx
mov $114, %rcx
rep movsb
nop
nop
nop
add $2226, %r11
lea addresses_D_ht+0x1776e, %rsi
lea addresses_WC_ht+0x14622, %rdi
sub %r11, %r11
mov $83, %rcx
rep movsq
nop
nop
cmp $34707, %rax
lea addresses_UC_ht+0x15c22, %rbx
nop
nop
nop
cmp $18172, %rdi
mov $0x6162636465666768, %r11
movq %r11, %xmm5
vmovups %ymm5, (%rbx)
nop
nop
nop
nop
nop
inc %r11
lea addresses_normal_ht+0x1d8a2, %rsi
lea addresses_UC_ht+0x10c2, %rdi
nop
nop
and %r14, %r14
mov $69, %rcx
rep movsq
nop
nop
nop
nop
sub %r14, %r14
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rax
pop %r14
pop %r12
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %rbp
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
// Store
lea addresses_normal+0x9d4a, %rdi
nop
nop
nop
nop
dec %rbx
movw $0x5152, (%rdi)
nop
nop
nop
nop
nop
and $20601, %rdi
// Store
lea addresses_A+0xee22, %rbp
nop
nop
nop
nop
xor $24393, %rdx
mov $0x5152535455565758, %r10
movq %r10, (%rbp)
nop
nop
add $24726, %r10
// Load
lea addresses_WC+0x10622, %rdi
nop
nop
nop
xor %rsi, %rsi
movb (%rdi), %dl
nop
inc %rsi
// Store
lea addresses_WC+0x89c2, %rbx
clflush (%rbx)
nop
nop
nop
xor $4514, %rsi
mov $0x5152535455565758, %rcx
movq %rcx, %xmm4
movups %xmm4, (%rbx)
nop
and %rcx, %rcx
// Load
lea addresses_A+0xee22, %rdi
nop
nop
sub %r10, %r10
mov (%rdi), %rcx
nop
nop
nop
nop
inc %rsi
// REPMOV
lea addresses_US+0x4ac2, %rsi
mov $0x962, %rdi
nop
nop
nop
nop
sub %rbp, %rbp
mov $12, %rcx
rep movsw
nop
nop
nop
xor %rdi, %rdi
// Faulty Load
lea addresses_A+0xee22, %rbp
nop
nop
nop
nop
xor $31820, %rcx
vmovups (%rbp), %ymm1
vextracti128 $0, %ymm1, %xmm1
vpextrq $0, %xmm1, %rdx
lea oracles, %r10
and $0xff, %rdx
shlq $12, %rdx
mov (%r10,%rdx,1), %rdx
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_A', 'same': False, 'size': 4, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_normal', 'same': False, 'size': 2, 'congruent': 1, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_A', 'same': True, 'size': 8, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_WC', 'same': False, 'size': 1, 'congruent': 11, 'NT': True, 'AVXalign': True}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_WC', 'same': False, 'size': 16, 'congruent': 5, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_A', 'same': True, 'size': 8, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_US', 'congruent': 5, 'same': False}, 'dst': {'type': 'addresses_P', 'congruent': 2, 'same': False}, 'OP': 'REPM'}
[Faulty Load]
{'src': {'type': 'addresses_A', 'same': True, 'size': 32, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'type': 'addresses_normal_ht', 'same': False, 'size': 2, 'congruent': 8, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_D_ht', 'same': False, 'size': 32, 'congruent': 11, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_WC_ht', 'same': False, 'size': 16, 'congruent': 10, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_WT_ht', 'congruent': 3, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 6, 'same': True}, 'OP': 'REPM'}
{'src': {'type': 'addresses_WC_ht', 'same': False, 'size': 16, 'congruent': 7, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_D_ht', 'congruent': 4, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 5, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_UC_ht', 'congruent': 10, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 11, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_D_ht', 'congruent': 2, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 11, 'same': False}, 'OP': 'REPM'}
{'dst': {'type': 'addresses_UC_ht', 'same': True, 'size': 32, 'congruent': 9, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_normal_ht', 'congruent': 6, 'same': False}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 5, 'same': False}, 'OP': 'REPM'}
{'58': 85}
58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58
*/
|
core/lib/types/Int.agda | cmknapp/HoTT-Agda | 0 | 782 | {-# OPTIONS --without-K #-}
open import lib.Basics
open import lib.types.Nat
open import lib.types.Group
open import lib.types.TLevel
module lib.types.Int where
data ℤ : Type₀ where
pos : (n : ℕ) → ℤ
negsucc : (n : ℕ) → ℤ
Int = ℤ
{-# BUILTIN INTEGER Int #-}
{-# BUILTIN INTEGERPOS pos #-}
{-# BUILTIN INTEGERNEGSUC negsucc #-}
{- literal overloading -}
instance
ℤ-reader : FromNat ℤ
FromNat.in-range ℤ-reader _ = ⊤
FromNat.read ℤ-reader n = pos n
ℤ-neg-reader : FromNeg ℤ
FromNeg.in-range ℤ-neg-reader _ = ⊤
FromNeg.read ℤ-neg-reader O = pos O
FromNeg.read ℤ-neg-reader (S n) = negsucc n
{- succ and pred -}
succ : ℤ → ℤ
succ (pos n) = pos (S n)
succ (negsucc O) = pos O
succ (negsucc (S n)) = negsucc n
pred : ℤ → ℤ
pred (pos O) = negsucc O
pred (pos (S n)) = pos n
pred (negsucc n) = negsucc (S n)
abstract
succ-pred : (n : ℤ) → succ (pred n) == n
succ-pred (pos O) = idp
succ-pred (pos (S n)) = idp
succ-pred (negsucc n) = idp
pred-succ : (n : ℤ) → pred (succ n) == n
pred-succ (pos n) = idp
pred-succ (negsucc O) = idp
pred-succ (negsucc (S n)) = idp
succ-equiv : ℤ ≃ ℤ
succ-equiv = equiv succ pred succ-pred pred-succ
pred-injective : (z₁ z₂ : ℤ) → pred z₁ == pred z₂ → z₁ == z₂
pred-injective z₁ z₂ p = ! (succ-pred z₁) ∙ ap succ p ∙ succ-pred z₂
succ-injective : (z₁ z₂ : ℤ) → succ z₁ == succ z₂ → z₁ == z₂
succ-injective z₁ z₂ p = ! (pred-succ z₁) ∙ ap pred p ∙ pred-succ z₂
{- Converting between ℤ, ℕ, and ℕ₋₂ -}
ℤ-to-ℕ₋₂ : ℤ → ℕ₋₂
ℤ-to-ℕ₋₂ (pos m) = ⟨ m ⟩
ℤ-to-ℕ₋₂ (negsucc O) = -1
ℤ-to-ℕ₋₂ (negsucc _) = -2
ℕ-to-ℤ : ℕ → ℤ
ℕ-to-ℤ n = pos n
{- Proof that [ℤ] has decidable equality and hence is a set -}
private
ℤ-get-pos : ℤ → ℕ
ℤ-get-pos (pos n) = n
ℤ-get-pos (negsucc n) = O
ℤ-get-negsucc : ℤ → ℕ
ℤ-get-negsucc (pos n) = O
ℤ-get-negsucc (negsucc n) = n
ℤ-negsucc≠pos-type : ℤ → Type₀
ℤ-negsucc≠pos-type (pos n) = Empty
ℤ-negsucc≠pos-type (negsucc n) = Unit
abstract
pos-injective : (n m : ℕ) (p : pos n == pos m) → n == m
pos-injective n m p = ap ℤ-get-pos p
pos-≠ : {n m : ℕ} (p : n ≠ m) → pos n ≠ pos m
pos-≠ p = p ∘ pos-injective _ _
negsucc-injective : (n m : ℕ) (p : negsucc n == negsucc m) → n == m
negsucc-injective n m p = ap ℤ-get-negsucc p
ℤ-negsucc≠pos : (n m : ℕ) → negsucc n ≠ pos m
ℤ-negsucc≠pos n m p = transport ℤ-negsucc≠pos-type p unit
ℤ-pos≠negsucc : (n m : ℕ) → pos n ≠ negsucc m
ℤ-pos≠negsucc n m p = transport ℤ-negsucc≠pos-type (! p) unit
ℤ-has-dec-eq : has-dec-eq ℤ
ℤ-has-dec-eq (pos n) (pos m) with ℕ-has-dec-eq n m
ℤ-has-dec-eq (pos n) (pos m) | inl p = inl (ap pos p)
ℤ-has-dec-eq (pos n) (pos m) | inr p⊥ = inr (pos-≠ p⊥)
ℤ-has-dec-eq (pos n) (negsucc m) = inr (ℤ-pos≠negsucc n m)
ℤ-has-dec-eq (negsucc n) (pos m) = inr (ℤ-negsucc≠pos n m)
ℤ-has-dec-eq (negsucc n) (negsucc m) with ℕ-has-dec-eq n m
ℤ-has-dec-eq (negsucc n) (negsucc m) | inl p = inl (ap negsucc p)
ℤ-has-dec-eq (negsucc n) (negsucc m) | inr p⊥ = inr (λ p → p⊥ (negsucc-injective n m p))
ℤ-is-set : is-set ℤ
ℤ-is-set = dec-eq-is-set ℤ-has-dec-eq
ℤ-level = ℤ-is-set
{-
ℤ is also a group!
-}
-- inv
ℤ~ : ℤ → ℤ
ℤ~ (pos (S n)) = negsucc n
ℤ~ (pos O) = pos O
ℤ~ (negsucc n) = pos (S n)
-- comp
infixl 80 _ℤ+_
_ℤ+_ : ℤ → ℤ → ℤ
pos O ℤ+ z = z
pos (S n) ℤ+ z = succ (pos n ℤ+ z)
negsucc O ℤ+ z = pred z
negsucc (S n) ℤ+ z = pred (negsucc n ℤ+ z)
-- unit-l
ℤ+-unit-l : ∀ z → pos O ℤ+ z == z
ℤ+-unit-l _ = idp
-- unit-r
private
ℤ+-unit-r-pos : ∀ n → pos n ℤ+ pos O == pos n
ℤ+-unit-r-pos O = idp
ℤ+-unit-r-pos (S n) = ap succ $ ℤ+-unit-r-pos n
ℤ+-unit-r-negsucc : ∀ n → negsucc n ℤ+ pos O == negsucc n
ℤ+-unit-r-negsucc O = idp
ℤ+-unit-r-negsucc (S n) = ap pred $ ℤ+-unit-r-negsucc n
ℤ+-unit-r : ∀ z → z ℤ+ pos O == z
ℤ+-unit-r (pos n) = ℤ+-unit-r-pos n
ℤ+-unit-r (negsucc n) = ℤ+-unit-r-negsucc n
-- assoc
succ-ℤ+ : ∀ z₁ z₂ → succ z₁ ℤ+ z₂ == succ (z₁ ℤ+ z₂)
succ-ℤ+ (pos n) _ = idp
succ-ℤ+ (negsucc O) _ = ! $ succ-pred _
succ-ℤ+ (negsucc (S _)) _ = ! $ succ-pred _
pred-ℤ+ : ∀ z₁ z₂ → pred z₁ ℤ+ z₂ == pred (z₁ ℤ+ z₂)
pred-ℤ+ (negsucc _) _ = idp
pred-ℤ+ (pos O) _ = idp
pred-ℤ+ (pos (S n)) _ = ! $ pred-succ _
ℤ+-assoc : ∀ z₁ z₂ z₃ → (z₁ ℤ+ z₂) ℤ+ z₃ == z₁ ℤ+ (z₂ ℤ+ z₃)
ℤ+-assoc (pos O) z₂ z₃ = idp
ℤ+-assoc (pos (S n₁)) z₂ z₃ =
succ (pos n₁ ℤ+ z₂) ℤ+ z₃ =⟨ succ-ℤ+ (pos n₁ ℤ+ z₂) z₃ ⟩
succ ((pos n₁ ℤ+ z₂) ℤ+ z₃) =⟨ ap succ $ ℤ+-assoc (pos n₁) z₂ z₃ ⟩
succ (pos n₁ ℤ+ (z₂ ℤ+ z₃)) ∎
ℤ+-assoc (negsucc O) z₂ z₃ = pred-ℤ+ z₂ z₃
ℤ+-assoc (negsucc (S n₁)) z₂ z₃ =
pred (negsucc n₁ ℤ+ z₂) ℤ+ z₃ =⟨ pred-ℤ+ (negsucc n₁ ℤ+ z₂) z₃ ⟩
pred ((negsucc n₁ ℤ+ z₂) ℤ+ z₃) =⟨ ap pred $ ℤ+-assoc (negsucc n₁) z₂ z₃ ⟩
pred (negsucc n₁ ℤ+ (z₂ ℤ+ z₃)) ∎
--comm
ℤ+-succ : ∀ z₁ z₂ → z₁ ℤ+ succ z₂ == succ (z₁ ℤ+ z₂)
ℤ+-succ (pos O) z₂ = idp
ℤ+-succ (pos (S n)) z₂ = ap succ (ℤ+-succ (pos n) z₂)
ℤ+-succ (negsucc O) z₂ = pred-succ z₂ ∙ ! (succ-pred z₂)
ℤ+-succ (negsucc (S n)) z₂ =
pred (negsucc n ℤ+ succ z₂)
=⟨ ap pred (ℤ+-succ (negsucc n) z₂) ⟩
pred (succ (negsucc n ℤ+ z₂))
=⟨ pred-succ (negsucc n ℤ+ z₂) ⟩
negsucc n ℤ+ z₂
=⟨ ! $ succ-pred (negsucc n ℤ+ z₂) ⟩
succ (pred (negsucc n ℤ+ z₂))
∎
ℤ+-pred : ∀ z₁ z₂ → z₁ ℤ+ pred z₂ == pred (z₁ ℤ+ z₂)
ℤ+-pred (pos O) z₂ = idp
ℤ+-pred (pos (S n)) z₂ =
succ (pos n ℤ+ pred z₂)
=⟨ ap succ (ℤ+-pred (pos n) z₂) ⟩
succ (pred (pos n ℤ+ z₂))
=⟨ succ-pred (pos n ℤ+ z₂) ⟩
pos n ℤ+ z₂
=⟨ ! $ pred-succ (pos n ℤ+ z₂) ⟩
pred (succ (pos n ℤ+ z₂))
∎
ℤ+-pred (negsucc O) z₂ = idp
ℤ+-pred (negsucc (S n)) z₂ = ap pred (ℤ+-pred (negsucc n) z₂)
ℤ+-comm : ∀ z₁ z₂ → z₁ ℤ+ z₂ == z₂ ℤ+ z₁
ℤ+-comm (pos O) z₂ = ! $ ℤ+-unit-r z₂
ℤ+-comm (pos (S n₁)) z₂ =
succ (pos n₁ ℤ+ z₂)
=⟨ ℤ+-comm (pos n₁) z₂ |in-ctx succ ⟩
succ (z₂ ℤ+ pos n₁)
=⟨ ! $ ℤ+-succ z₂ (pos n₁) ⟩
z₂ ℤ+ pos (S n₁)
∎
ℤ+-comm (negsucc O) z₂ =
pred z₂
=⟨ ! $ ℤ+-unit-r z₂ |in-ctx pred ⟩
pred (z₂ ℤ+ pos O)
=⟨ ! $ ℤ+-pred z₂ (pos O) ⟩
z₂ ℤ+ negsucc O
∎
ℤ+-comm (negsucc (S n)) z₂ =
pred (negsucc n ℤ+ z₂)
=⟨ ℤ+-comm (negsucc n) z₂ |in-ctx pred ⟩
pred (z₂ ℤ+ negsucc n)
=⟨ ! $ ℤ+-pred z₂ (negsucc n) ⟩
z₂ ℤ+ negsucc (S n)
∎
private
pos-S-ℤ+-negsucc-S : ∀ n₁ n₂ → pos (S n₁) ℤ+ negsucc (S n₂) == pos n₁ ℤ+ negsucc n₂
pos-S-ℤ+-negsucc-S O n₂ = idp
pos-S-ℤ+-negsucc-S (S n₁) n₂ = ap succ $ pos-S-ℤ+-negsucc-S n₁ n₂
negsucc-S-ℤ+-pos-S : ∀ n₁ n₂ → negsucc (S n₁) ℤ+ pos (S n₂) == negsucc n₁ ℤ+ pos n₂
negsucc-S-ℤ+-pos-S O n₂ = idp
negsucc-S-ℤ+-pos-S (S n₁) n₂ = ap pred $ negsucc-S-ℤ+-pos-S n₁ n₂
ℤ~-inv-r : ∀ z → z ℤ+ ℤ~ z == 0
ℤ~-inv-r (pos O) = idp
ℤ~-inv-r (pos (S O)) = idp
ℤ~-inv-r (pos (S (S n))) =
pos (S (S n)) ℤ+ negsucc (S n) =⟨ pos-S-ℤ+-negsucc-S (S n) n ⟩
pos (S n) ℤ+ negsucc n =⟨ ℤ~-inv-r (pos (S n)) ⟩
0 ∎
ℤ~-inv-r (negsucc O) = idp
ℤ~-inv-r (negsucc (S n)) =
negsucc (S n) ℤ+ pos (S (S n)) =⟨ negsucc-S-ℤ+-pos-S n (S n) ⟩
negsucc n ℤ+ pos (S n) =⟨ ℤ~-inv-r (negsucc n) ⟩
0 ∎
ℤ~-inv-l : ∀ z → ℤ~ z ℤ+ z == 0
ℤ~-inv-l (pos O) = idp
ℤ~-inv-l (pos (S n)) = ℤ~-inv-r (negsucc n)
ℤ~-inv-l (negsucc n) = ℤ~-inv-r (pos (S n))
ℤ-group-structure : GroupStructure ℤ
ℤ-group-structure = record
{ ident = 0
; inv = ℤ~
; comp = _ℤ+_
; unitl = ℤ+-unit-l
; unitr = ℤ+-unit-r
; assoc = ℤ+-assoc
; invr = ℤ~-inv-r
; invl = ℤ~-inv-l
}
ℤ-group : Group₀
ℤ-group = group _ ℤ-is-set ℤ-group-structure
-- More properties about [ℤ~]
ℤ~-succ : ∀ z → ℤ~ (succ z) == pred (ℤ~ z)
ℤ~-succ (pos 0) = idp
ℤ~-succ (pos (S n)) = idp
ℤ~-succ (negsucc 0) = idp
ℤ~-succ (negsucc (S n)) = idp
ℤ~-pred : ∀ z → ℤ~ (pred z) == succ (ℤ~ z)
ℤ~-pred (pos 0) = idp
ℤ~-pred (pos 1) = idp
ℤ~-pred (pos (S (S n))) = idp
ℤ~-pred (negsucc 0) = idp
ℤ~-pred (negsucc (S n)) = idp
ℤ~-ℤ+ : ∀ z₁ z₂ → ℤ~ (z₁ ℤ+ z₂) == ℤ~ z₁ ℤ+ ℤ~ z₂
ℤ~-ℤ+ (pos 0) z₂ = idp
ℤ~-ℤ+ (pos 1) z₂ = ℤ~-succ z₂
ℤ~-ℤ+ (pos (S (S n))) z₂ =
ℤ~-succ (pos (S n) ℤ+ z₂) ∙ ap pred (ℤ~-ℤ+ (pos (S n)) z₂)
ℤ~-ℤ+ (negsucc O) z₂ = ℤ~-pred z₂
ℤ~-ℤ+ (negsucc (S n)) z₂ =
ℤ~-pred (negsucc n ℤ+ z₂) ∙ ap succ (ℤ~-ℤ+ (negsucc n) z₂)
|
src/aco-utils-ds-generic_protected_queue.ads | jonashaggstrom/ada-canopen | 6 | 22377 | <filename>src/aco-utils-ds-generic_protected_queue.ads<gh_stars>1-10
with System;
private with Ada.Synchronous_Task_Control;
private with ACO.Utils.DS.Generic_Queue;
generic
type Item_Type is private;
Maximum_Nof_Items : Positive;
package ACO.Utils.DS.Generic_Protected_Queue is
-- A protected queue
pragma Preelaborate;
type Protected_Queue
(Ceiling : System.Priority)
is tagged limited private;
procedure Put_Blocking
(This : in out Protected_Queue;
Item : in Item_Type);
procedure Put
(This : in out Protected_Queue;
Item : in Item_Type;
Success : out Boolean);
procedure Get_Blocking
(This : in out Protected_Queue;
Item : out Item_Type);
procedure Get
(This : in out Protected_Queue;
Item : out Item_Type)
with Pre => not This.Is_Empty;
function Count
(This : Protected_Queue)
return Natural;
function Is_Empty
(This : Protected_Queue)
return Boolean;
function Is_Full
(This : Protected_Queue)
return Boolean;
private
package Q is new ACO.Utils.DS.Generic_Queue (Item_Type);
protected type Buffer_Type
(Ceiling : System.Priority)
is
procedure Put
(Item : in Item_Type;
Success : out Boolean);
procedure Get
(Item : out Item_Type;
Success : out Boolean);
function Nof_Items return Natural;
private
pragma Priority (Ceiling);
Queue : Q.Queue (Max_Nof_Items => Maximum_Nof_Items);
end Buffer_Type;
type Protected_Queue
(Ceiling : System.Priority)
is tagged limited record
Buffer : Buffer_Type (Ceiling);
Non_Full : Ada.Synchronous_Task_Control.Suspension_Object;
Non_Empty : Ada.Synchronous_Task_Control.Suspension_Object;
end record;
end ACO.Utils.DS.Generic_Protected_Queue;
|
oeis/314/A314239.asm | neoneye/loda-programs | 11 | 17298 | ; A314239: Coordination sequence Gal.6.642.2 where G.u.t.v denotes the coordination sequence for a vertex of type v in tiling number t in the Galebach list of u-uniform tilings.
; Submitted by <NAME>(s3)
; 1,5,11,17,23,28,34,39,45,51,57,62,67,73,79,85,90,96,101,107,113,119,124,129,135,141,147,152,158,163,169,175,181,186,191,197,203,209,214,220,225,231,237,243,248,253,259,265,271,276
mov $1,$0
mul $0,13
add $0,5
div $0,11
mul $1,49
sub $1,6
div $1,11
add $1,1
add $0,$1
|
FoldingText.lbaction/Contents/Scripts/next.scpt | raguay/MyLaunchBarActions | 29 | 2186 | property pTitle : "Move the @next tag along, leaving @done in its wake"
property pVer : "0.5" -- DRAFT ...
property pAuthor : "RobTrew"
property pblnDebug : false
-- ROUGH DRAFT:
-- **MOVE** THE @NEXT OR @NOW TAG (edit pstrTag below) ON TO THE NEXT UNCOMPLETED ITEM IN THE PROJECT
-- [Marking the current line as @done(yyy-mm-dd hh:mm) ]
-- (If all lines under this heading/project are now @done, then mark the heading/project itself as @done)
-- (and if there are no lines after this which are not @done, but there are some before, jump to the first of them and place the @next tag there)
property pstrTag : "next"
property plstExcept : {"done", "wait"}
property precOptions : {tag:pstrTag, except:plstExcept}
property pstrJS : "
function(editor, options) {
// WALK A PROJECT OUTLINE - WHICH IS THE NEXT ELIGIBLE NODE ?
function nextNode(tree, oCurrent, strWhere, strTag) {
var oNext=null, oAncestor,
strID = oCurrent.id, lstNodes, strPath, i;
// ANY INCOMPLETE DESCENDANTS ?
// (if not, mark as done)
strPath = nextPath(strID, 'descendant', strWhere);
lstNodes = tree.evaluateNodePath(strPath);
if (lstNodes.length) {
oNext = lstNodes[0];
} else {
if (oCurrent.type() != 'root') {
oCurrent.addTag('done', fmtTP(new Date()));
//ANY FOLLOWING SIBLINGS REMAIN ?
strPath = nextPath(strID, 'following-sibling', strWhere);
lstNodes = tree.evaluateNodePath(strPath);
if (lstNodes.length) {
oNext = lstNodes[0];
} else {
// WHAT IS THE MOST RECENT INCOMPLETE ANCESTOR ?
strPath = nextPath(strID, 'ancestor', strWhere);
oAncestor = tree.evaluateNodePath(strPath)[0];
if (oAncestor !== undefined) {
oNext = nextNode(tree, oAncestor, strWhere,strTag);
}
}
} else {
//whole document appears to be complete ... nothing to be done
}
}
return oNext;
}
// Assemble node path for next eligible descendant, sibling, or ancestor
function nextPath(strID, strAxis, strWhere) {
var strPath = '//@id=' + strID + '/' + strAxis + '::' + strWhere + ')';
if (strAxis != 'ancestor') {
strPath += '[0]'; //first found sibling or descendant
} else {
strPath += '[-1]'; //last found (most immediate) ancestor
}
return strPath;
}
// Javascript Date() to FT/TP datetime string
function fmtTP(dte) {
if (dte) {
var strDate = [dte.getFullYear(),
('0' + (dte.getMonth()+1)).slice(-2),
('0'+ dte.getDate()).slice(-2)].join('-'),
strTime = [('00'+dte.getHours()).slice(-2),
('00'+dte.getMinutes()).slice(-2)].join(':');
if (strTime !== '00:00') {
return [strDate, strTime].join(' ');
} else {
return strDate;
}
} else {
return '';
}
}
// TAG THE CURRENT LINE AS 'NOW' OR 'NEXT'
// (AND IF IT'S ALREADY TAGGED NOW/NEXT, TAG IT AS 'DONE' AND MOVE THE @NOW TAG TO THE NEXT
// ELIGIBLE LINE UNDER THIS PROJECT/HEADING, OR MARK THE WHOLE PROJECT/HEADING AS 'DONE')
//debugger;
var tree = editor.tree(),
strTag = options.tag, lstExcept = options.except,
oSelnNode = editor.selectedRange().startNode,
oCurrent, oNextNode,
strSelnID = oSelnNode.id,
strWhere = '(@type!=root and @line:text!=\"\" and not @done and not @' + strTag,
strAncestors = '//@id=' + strSelnID + '/ancestor-or-self::(not @done and (@type=heading or @type=project or @type=root))[-1]',
lstAncestors = tree.evaluateNodePath(strAncestors), lstNext,
strTaggedNext,
strProjectID=0;
//ANY CURRENT @NEXT NODE(S) IN THIS PROJECT ?
if (lstAncestors.length) {
strProjectID = lstAncestors[0].id;
}
//debugger;
if (strProjectID != '0') {
strTaggedNext = '//@id=' + strProjectID + '/descendant-or-self::@' + strTag;
} else {
strTaggedNext = '//@' + strTag;
}
lstNext = tree.evaluateNodePath(strTaggedNext);
if (lstNext.length) {
oCurrent = lstNext[0];
// Clear this and other @next tags in the project
lstNext.forEach(function(oNode) {
oNode.removeTag(strTag);
});
// add any excluded tags to the list of conditions for @next status
if (lstExcept.length) {
lstExcept.forEach(function(strExcept) {
if (strExcept !== 'done') {
strWhere += (' and not @' + strExcept);
}
});
}
// and look for a successor
oNextNode = nextNode(tree, oCurrent, strWhere, strTag);
if (oNextNode) {
oNextNode.addTag(strTag);
}
} else {
oSelnNode.addTag(strTag);
}
}
"
tell application "FoldingText"
if not pblnDebug then
set lstDocs to documents
if lstDocs ≠ {} then
tell item 1 of lstDocs
set varResult to (evaluate script pstrJS with options precOptions)
end tell
end if
else
-- debug script automatically refers to the SDK version of the editor
-- which must be open: FoldingText > Help > SDK > Run Editor
set varResult to (debug script pstrJS with options precOptions)
end if
return varResult
end tell |
programs/oeis/276/A276881.asm | neoneye/loda | 22 | 18303 | ; A276881: Sums-complement of the Beatty sequence for 1 + sqrt(5).
; 1,2,5,8,11,14,15,18,21,24,27,28,31,34,37,40,41,44,47,50,53,54,57,60,63,66,69,70,73,76,79,82,83,86,89,92,95,96,99,102,105,108,109,112,115,118,121,124,125,128,131,134,137,138,141,144,147,150,151,154
mov $1,17
mul $1,$0
sub $1,1
div $1,21
add $1,1
mul $1,2
sub $1,1
add $1,$0
mov $0,$1
|
oeis/086/A086273.asm | neoneye/loda-programs | 11 | 171591 | <reponame>neoneye/loda-programs
; A086273: Rectangular array T(n,k) of central polygonal numbers, by antidiagonals.
; Submitted by <NAME>
; 1,1,3,1,4,7,1,5,10,13,1,6,13,19,21,1,7,16,25,31,31,1,8,19,31,41,46,43,1,9,22,37,51,61,64,57,1,10,25,43,61,76,85,85,73,1,11,28,49,71,91,106,113,109,91,1,12,31,55,81,106,127,141,145,136,111,1,13,34,61,91,121,148
lpb $0
add $1,1
sub $0,$1
lpe
add $0,1
sub $1,$0
bin $0,2
add $1,3
mul $1,$0
mov $0,$1
add $0,1
|
programs/oeis/063/A063099.asm | karttu/loda | 1 | 15927 | ; A063099: Dimension of the space of weight 2n cusp forms for Gamma_0( 31 ).
; 2,7,13,17,23,29,33,39,45,49,55,61,65,71,77,81,87,93,97,103,109,113,119,125,129,135,141,145,151,157,161,167,173,177,183,189,193,199,205,209,215,221,225,231,237,241,247,253,257,263
mov $3,$0
add $3,$0
mov $0,$3
mov $1,1
lpb $2,$0
add $0,1
mov $1,$0
mul $1,2
trn $3,3
lpe
add $1,1
|
gcc-gcc-7_3_0-release/gcc/testsuite/gnat.dg/deques.ads | best08618/asylo | 7 | 12922 | package Deques is
type Deque (<>) is tagged limited private;
function Create return Deque;
procedure Pop (D : access Deque);
type Sequence is limited interface;
type P_Deque is new Deque and Sequence with private;
function Create return P_Deque;
private
type Deque is tagged limited null record;
type P_Deque is new Deque and Sequence with null record;
end Deques;
|
C51/RtxTiny2/SourceCode/os_create.a51 | AllRoundeer/Keil | 0 | 171877 | ;------------------------------------------------------------------------------
; This file is part of the RTX-51 TINY Real-Time Operating System Package
; Copyright KEIL ELEKTRONIK GmbH and Keil Software, Inc. 1991 - 2002
;------------------------------------------------------------------------------
;
; OS_CREATE.A51: This module contains the OS_CREATE_TASK function call.
;
; RTX51 TINY VERSION 2
;
;------------------------------------------------------------------------------
NAME ?RTX51_TINY_OS_CREATE
$include (os_defines.inc)
PUBLIC _os_create_task
?RTX?CODE SEGMENT CODE
RSEG ?RTX?CODE
USING 0 ; Registerbank 0 for following code
; uchar os_create_task (uchar no) {
; uchar i;
; uchar p1, p2;
;---- Variable 'p1' assigned to Register 'R1' ----
;---- Variable 'p2' assigned to Register 'R5' ----
;---- Variable 'no' assigned to Register 'R7' ----
;---- Variable 'i' assigned to Register 'R6' ----
;
; Returns 0xFF if the task number is too large
; 0xFF if the task is already active
; 0x00 if the task was inserted into the task list
;
;
; if (no > MAXTASKN) return (0xff);
_os_create_task:
MOV A,R7
SETB C
SUBB A,#?RTX_MAXTASKN
JC ?C0010
?C0012_: MOV R7,#0FFH
RET
?C0010:
; if (STATE[no].st & K_ACTIVE) return (0xff);
MOV A,#?RTX?TASKSTATE?S+1
ADD A,R7
ADD A,R7
MOV R0,A
MOV A,@R0
JB ACC.B_ACTIVE,?C0012_
; STATE[no].st |= K_ACTIVE + K_READY;
CLR EA
MOV A,@R0
ORL A,#K_ACTIVE+K_READY
MOV @R0,A
SETB EA
;
; i = current;
MOV R6,?RTX_CURRENTTASK
?C0013_:
; while (i < no) {
MOV A,R6
CLR C
SUBB A,R7
JNC ?C0014
; i++;
INC R6
; p1 = STKP[i];
MOV A,#?RTX?TASKSP?S
ADD A,R6
MOV R0,A
MOV A,@R0
MOV R1,A
; p2 = i == MAXTASKN ? RAMTOP : STKP[i+1];
INC R0
MOV A,@R0
DEC R0
CJNE R6,#?RTX_MAXTASKN,?C0015_
MOV A,#?RTX_RAMTOP
?C0015_:
MOV R5,A
?C0017:
MOV A,R5
XRL A,R1
JZ ?C0018
; while (p1 != p2) {
; p1++;
; DBYTE[p1-2] = DBYTE[p1];
; }
INC R1
MOV A,@R1
DEC R1
DEC R1
$IF (CODE_BANKING)
DEC R1
$ENDIF
MOV @R1,A
$IF (CODE_BANKING)
INC R1
$ENDIF
INC R1
INC R1
SJMP ?C0017
?C0018:
; STKP[i] -= 2;
$IF (CODE_BANKING)
DEC @R0
$ENDIF
DEC @R0
DEC @R0
; }
SJMP ?C0013_
?C0014:
; if (i > no) SP += 2;
MOV A,R6
SETB C
SUBB A,R7
JC ?C0020
$IF (CODE_BANKING)
INC SP
$ENDIF
INC SP
INC SP
?C0020:
; while (i > no) {
MOV A,R6
SETB C
SUBB A,R7
JC ?C0021
; p1 = i == current ? SP : STKP[i+1];
MOV A,#?RTX?TASKSP?S
ADD A,R6
MOV R0,A
INC R0
MOV A,@R0
MOV R1,A
MOV A,R6
CJNE A,?RTX_CURRENTTASK,?C0022
MOV R1,SP
?C0022:
; STKP[i] += 2;
DEC R0
INC @R0
INC @R0
$IF (CODE_BANKING)
INC @R0
$ENDIF
; p2 = STKP[i];
MOV A,@R0
MOV R5,A
?C0024:
; while (p1 != p2) {
MOV A,R5
XRL A,R1
JZ ?C0025
; DBYTE[p1] = DBYTE[p1-2];
DEC R1
DEC R1
$IF (CODE_BANKING)
DEC R1
$ENDIF
MOV A,@R1
$IF (CODE_BANKING)
INC R1
$ENDIF
INC R1
INC R1
MOV @R1,A
; p1--;
DEC R1
; }
SJMP ?C0024
?C0025:
; i--;
DEC R6
; }
SJMP ?C0020
?C0021:
;
; DWORD[STKP[no]] = ENTRY[no];
;
; Copy the entry point address of a task onto the stack.
;
MOV A,R7
ADD A,#?RTX?TASKSP?S
MOV R0,A
MOV A,@R0
INC A
MOV R0,A
MOV A,R7
ADD A,R7
INC A
MOV DPTR,#?RTX?TASKENT?S
MOVC A,@A+DPTR
MOV @R0,A
INC R0
MOV A,R7
ADD A,R7
MOVC A,@A+DPTR
MOV @R0,A
; return (0);
MOV R7,#0
$IF (CODE_BANKING)
EXTRN DATA (?B_CURRENTBANK)
INC R0
MOV A,?B_CURRENTBANK ; Set the initial code bank
MOV @R0,A
$ENDIF
; }
RET
END
|
src/asis/a4g-contt-sd.ads | My-Colaborations/dynamo | 15 | 2598 | <reponame>My-Colaborations/dynamo
------------------------------------------------------------------------------
-- --
-- ASIS-for-GNAT IMPLEMENTATION COMPONENTS --
-- --
-- A 4 G . C O N T T . S D --
-- --
-- S p e c --
-- --
-- Copyright (C) 1995-2012, Free Software Foundation, Inc. --
-- --
-- ASIS-for-GNAT is free software; you can redistribute it and/or modify it --
-- under terms of the GNU General Public License as published by the Free --
-- Software Foundation; either version 2, or (at your option) any later --
-- version. ASIS-for-GNAT is distributed in the hope that it will be use- --
-- ful, but WITHOUT ANY WARRANTY; without even the implied warranty of MER- --
-- CHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General --
-- Public License for more details. You should have received a copy of the --
-- GNU General Public License distributed with ASIS-for-GNAT; see file --
-- COPYING. If not, write to the Free Software Foundation, 51 Franklin --
-- Street, Fifth Floor, Boston, MA 02110-1301, USA. --
-- --
-- --
-- --
-- --
-- --
-- --
-- --
-- --
-- ASIS-for-GNAT was originally developed by the ASIS-for-GNAT team at the --
-- Software Engineering Laboratory of the Swiss Federal Institute of --
-- Technology (LGL-EPFL) in Lausanne, Switzerland, in cooperation with the --
-- Scientific Research Computer Center of Moscow State University (SRCC --
-- MSU), Russia, with funding partially provided by grants from the Swiss --
-- National Science Foundation and the Swiss Academy of Engineering --
-- Sciences. ASIS-for-GNAT is now maintained by AdaCore --
-- (http://www.adacore.<EMAIL>). --
-- --
------------------------------------------------------------------------------
-- This package defines the procedures which scans the tree search paths for
-- a given Context and analyses the availible tree files
with Namet; use Namet;
package A4G.Contt.SD is
First_Tree_File : Name_Id := First_Name_Id;
Last_Tree_File : Name_Id := First_Name_Id - 1;
-- Indexes of the first and the last tree file candidates, which were
-- found during the last scanning of the tree search path of some
-- directory. Are set by Scan_Tree_Files below. These variables are
-- undefinite
-- SHOULD WE MOVE THESE VARIABLES IN THE BODY
-- AND EVEN MORE - DO WE REALLY NEED THEM AT ALL??!!
procedure Scan_Tree_Files_New (C : Context_Id);
-- Stores the names of the tree files making up the Context C in the Tree
-- table for C. Every tree file name is stored only once.
-- In All_Trees Context mode it scans the tree search path, using the same
-- approach for the tree files with the same name as GNAT does for source
-- files in the source search path. In N_Trees mode it scans the Parametes
-- string set when C was associated. In this case, if the name of the same
-- tree file is given more than once, but in diffrent forms (for example
-- ../my_dir/foo.ats and ../../my_home_dir/my_dir/foo.ats), all these
-- different names of the same tree file will be stored in the tree table
procedure Investigate_Trees_New (C : Context_Id);
-- This procedure implements the second step of opening a Context. It uses
-- the names of the tree files in the Context Tree Table. For every tree
-- file, it reads it in and extracts some information about compilation
-- units presented by this file. It also makes the consistency check.
-- Checks which are made by this procedure depend on the context options
-- which were set when C was associated.
--
-- Is this package the right location for this procedure???
procedure Scan_Units_New;
-- Scans the currently accessed tree which was readed in by the
-- immediately preceding call to Read_and_Check_New. If a unit is "new"
-- (that is, if it has not already been encountered during opening a
-- Context), all the black-box information is computed and stored in the
-- Context table. Otherwise (that is, if the unit is already "known")
-- the consistency check is made.
--
-- When this procedure raises ASIS_Failed, it forms the Diagnosis string
-- on befalf on Asis.Ada_Environments.Open
end A4G.Contt.SD;
|
programs/oeis/114/A114647.asm | jmorken/loda | 1 | 176132 | <reponame>jmorken/loda<gh_stars>1-10
; A114647: Expansion of (-3+4*x+3*x^2)/((1-x)*(x+1)*(x^2+2*x-1)); a Pellian-related sequence.
; 3,2,7,12,31,70,171,408,987,2378,5743,13860,33463,80782,195027,470832,1136691,2744210,6625111,15994428,38613967,93222358,225058683,543339720,1311738123,3166815962,7645370047,18457556052,44560482151,107578520350,259717522851,627013566048,1513744654947,3654502875938,8822750406823,21300003689580,51422757785983,124145519261542,299713796309067,723573111879672,1746860020068411,4217293152016490
mov $3,2
mov $5,$0
lpb $3
mov $0,$5
sub $3,1
add $0,$3
add $0,1
cal $0,97075 ; Expansion of (1-x-x^2)/(1-x-3*x^2-x^3).
mul $0,2
mov $2,$3
mov $4,$0
lpb $2
mov $1,$4
sub $2,1
lpe
lpe
lpb $5
sub $1,$4
mov $5,0
lpe
sub $1,2
div $1,2
add $1,2
|
固件源码/三代控A12-带模型命名源码-易深工程/List/main.adb | wooddoor/Loli3 | 47 | 22591 | M:main
F:G$Delay1ms$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$delay_ms$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$EEPROM_read$0_0$0({2}DF,SC:U),C,0,0,0,0,0
F:G$EEPROM_write$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$EEPROM_clean$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$Data_change$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$DATA_read1$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$DATA_save1$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$Model_data_reset$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$Model_adress$0_0$0({2}DF,SI:U),C,0,0,0,0,0
F:G$DATA_read2$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$DATA_save2$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$SPI$0_0$0({2}DF,SC:U),C,0,0,0,0,0
F:G$REG_write$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$REG_read$0_0$0({2}DF,SC:U),C,0,0,0,0,0
F:G$FIFO_write$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$FIFO_write2$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$FIFO_read$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$FIFO_read2$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$TX_address$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$RX_address$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$RX_mode$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$TX_mode$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$NRF_power$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$NRF_size$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$NRF_channel$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$NRF_init$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$NRF_test$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$device_connect$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$LCD$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$location$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$LCD_ON$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$LCD_OFF$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$LCD_clean$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$LCD_init$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$send$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$send2$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$send2_rev$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$send2_hex$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$send3$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$write$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$write0$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$photo$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$display_trim1$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$display_trim2$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$display_throttle$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$warning$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$write_num100$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$write_num1000$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$move_cursor$0_0$0({2}DF,SC:U),C,0,0,0,0,0
F:G$displayModel$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$display_menu$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$display_mapping$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$display_receiver_mode$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$display_switch$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$display_bar$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$point$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$display_curve$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$display_curve2$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$Xdata_check$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$rounding$0_0$0({2}DF,SC:U),C,0,0,0,0,0
F:G$get_curve$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$get_curve2$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$function_size$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$function_inverted$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$function_mix$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$function_curve$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$function_curve2$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$function_mapping$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$change_trim$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$CH_calib$0_0$0({2}DF,SI:S),C,0,0,0,0,0
F:G$function_filter$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$Switch_Check$0_0$0({2}DF,SC:U),C,0,0,0,0,0
F:G$UartInit$0_0$0({2}DF,SV:S),C,0,0,0,0,0
F:G$initial$0_0$0({2}DF,SV:S),C,0,0,0,0,0
|
host/stm32gd-gpio-pin.adb | ekoeppen/STM32_Generic_Ada_Drivers | 1 | 17409 | <reponame>ekoeppen/STM32_Generic_Ada_Drivers
package body STM32GD.GPIO.Pin is
procedure Init is
begin
null;
end Init;
procedure Set_Mode (Mode : Pin_IO_Modes) is
begin
null;
end Set_Mode;
procedure Set_Type (Pin_Type : Pin_Output_Types) is
begin
null;
end Set_Type;
function Get_Pull_Resistor return Internal_Pin_Resistors is
begin
return Pull_Down;
end Get_Pull_Resistor;
procedure Set_Pull_Resistor (Pull : Internal_Pin_Resistors) is
begin
null;
end Set_Pull_Resistor;
function Is_Set return Boolean is
begin
return False;
end Is_Set;
procedure Set is
begin
null;
end Set;
procedure Clear is
begin
null;
end Clear;
procedure Toggle is
begin
null;
end Toggle;
procedure Configure_Alternate_Function (AF : GPIO_Alternate_Function) is
begin
null;
end Configure_Alternate_Function;
procedure Connect_External_Interrupt is
begin
null;
end Connect_External_Interrupt;
end STM32GD.GPIO.Pin;
|
tests/hello.asm | ntrupin/navmv | 8 | 160575 | section .data:
.dec HELLO Hello, world!
_start:
mov ax, 1
mov bx, 1
mov cx, [HELLO]
syscall |
text/maps/rocket_hideout_b4f.asm | etdv-thevoid/pokemon-rgb-enhanced | 9 | 88703 | _RocketHideout4Text_4557a::
text "So! I must say, I"
line "am impressed you"
cont "got here!"
done
_RocketHideout4Text_4557f::
text "WHAT!"
line "This cannot be!"
prompt
_RocketHideout4Text_45584::
text "I see that you"
line "raise #MON"
cont "with utmost care."
para "A child like you"
line "would never"
cont "understand what I"
cont "hope to achieve."
para "I shall step"
line "aside this time!"
para "I hope we meet"
line "again..."
done
_RocketHideout4BattleText2::
text "I know you! You"
line "ruined our plans"
cont "at MT.MOON!"
done
_RocketHideout4EndBattleText2::
text "Burned"
line "again!"
prompt
_RocketHide4AfterBattleText2::
text "Do you have"
line "something against"
cont "TEAM ROCKET?"
done
_RocketHideout4BattleText3::
text "How can you not"
line "see the beauty of"
cont "our evil?"
done
_RocketHideout4EndBattleText3::
text "Ayaya!"
prompt
_RocketHide4AfterBattleText3::
text "BOSS! I'm sorry I"
line "failed you!"
done
_RocketHideout4BattleText4::
text "The elevator"
line "doesn't work? Who"
cont "has the LIFT KEY?"
done
_RocketHideout4EndBattleText4::
text "No!"
prompt
_RocketHideout4Text_455ec::
text "Oh no! I dropped"
line "the LIFT KEY!"
done
|
gcc-gcc-7_3_0-release/gcc/ada/sem_ch5.adb | best08618/asylo | 7 | 4332 | <filename>gcc-gcc-7_3_0-release/gcc/ada/sem_ch5.adb
------------------------------------------------------------------------------
-- --
-- GNAT COMPILER COMPONENTS --
-- --
-- S E M _ C H 5 --
-- --
-- B o d y --
-- --
-- Copyright (C) 1992-2016, Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
-- ware Foundation; either version 3, or (at your option) any later ver- --
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
-- for more details. You should have received a copy of the GNU General --
-- Public License distributed with GNAT; see file COPYING3. If not, go to --
-- http://www.gnu.org/licenses for a complete copy of the license. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
with Aspects; use Aspects;
with Atree; use Atree;
with Checks; use Checks;
with Einfo; use Einfo;
with Errout; use Errout;
with Expander; use Expander;
with Exp_Ch6; use Exp_Ch6;
with Exp_Util; use Exp_Util;
with Freeze; use Freeze;
with Ghost; use Ghost;
with Lib; use Lib;
with Lib.Xref; use Lib.Xref;
with Namet; use Namet;
with Nlists; use Nlists;
with Nmake; use Nmake;
with Opt; use Opt;
with Restrict; use Restrict;
with Rident; use Rident;
with Sem; use Sem;
with Sem_Aux; use Sem_Aux;
with Sem_Case; use Sem_Case;
with Sem_Ch3; use Sem_Ch3;
with Sem_Ch6; use Sem_Ch6;
with Sem_Ch8; use Sem_Ch8;
with Sem_Dim; use Sem_Dim;
with Sem_Disp; use Sem_Disp;
with Sem_Elab; use Sem_Elab;
with Sem_Eval; use Sem_Eval;
with Sem_Res; use Sem_Res;
with Sem_Type; use Sem_Type;
with Sem_Util; use Sem_Util;
with Sem_Warn; use Sem_Warn;
with Snames; use Snames;
with Stand; use Stand;
with Sinfo; use Sinfo;
with Targparm; use Targparm;
with Tbuild; use Tbuild;
with Uintp; use Uintp;
package body Sem_Ch5 is
Current_LHS : Node_Id := Empty;
-- Holds the left-hand side of the assignment statement being analyzed.
-- Used to determine the type of a target_name appearing on the RHS, for
-- AI12-0125 and the use of '@' as an abbreviation for the LHS.
Unblocked_Exit_Count : Nat := 0;
-- This variable is used when processing if statements, case statements,
-- and block statements. It counts the number of exit points that are not
-- blocked by unconditional transfer instructions: for IF and CASE, these
-- are the branches of the conditional; for a block, they are the statement
-- sequence of the block, and the statement sequences of any exception
-- handlers that are part of the block. When processing is complete, if
-- this count is zero, it means that control cannot fall through the IF,
-- CASE or block statement. This is used for the generation of warning
-- messages. This variable is recursively saved on entry to processing the
-- construct, and restored on exit.
procedure Preanalyze_Range (R_Copy : Node_Id);
-- Determine expected type of range or domain of iteration of Ada 2012
-- loop by analyzing separate copy. Do the analysis and resolution of the
-- copy of the bound(s) with expansion disabled, to prevent the generation
-- of finalization actions. This prevents memory leaks when the bounds
-- contain calls to functions returning controlled arrays or when the
-- domain of iteration is a container.
------------------------
-- Analyze_Assignment --
------------------------
-- WARNING: This routine manages Ghost regions. Return statements must be
-- replaced by gotos which jump to the end of the routine and restore the
-- Ghost mode.
procedure Analyze_Assignment (N : Node_Id) is
Lhs : constant Node_Id := Name (N);
Rhs : constant Node_Id := Expression (N);
T1 : Entity_Id;
T2 : Entity_Id;
Decl : Node_Id;
procedure Diagnose_Non_Variable_Lhs (N : Node_Id);
-- N is the node for the left hand side of an assignment, and it is not
-- a variable. This routine issues an appropriate diagnostic.
procedure Kill_Lhs;
-- This is called to kill current value settings of a simple variable
-- on the left hand side. We call it if we find any error in analyzing
-- the assignment, and at the end of processing before setting any new
-- current values in place.
procedure Set_Assignment_Type
(Opnd : Node_Id;
Opnd_Type : in out Entity_Id);
-- Opnd is either the Lhs or Rhs of the assignment, and Opnd_Type is the
-- nominal subtype. This procedure is used to deal with cases where the
-- nominal subtype must be replaced by the actual subtype.
-------------------------------
-- Diagnose_Non_Variable_Lhs --
-------------------------------
procedure Diagnose_Non_Variable_Lhs (N : Node_Id) is
begin
-- Not worth posting another error if left hand side already flagged
-- as being illegal in some respect.
if Error_Posted (N) then
return;
-- Some special bad cases of entity names
elsif Is_Entity_Name (N) then
declare
Ent : constant Entity_Id := Entity (N);
begin
if Ekind (Ent) = E_In_Parameter then
Error_Msg_N
("assignment to IN mode parameter not allowed", N);
return;
-- Renamings of protected private components are turned into
-- constants when compiling a protected function. In the case
-- of single protected types, the private component appears
-- directly.
elsif (Is_Prival (Ent)
and then
(Ekind (Current_Scope) = E_Function
or else Ekind (Enclosing_Dynamic_Scope
(Current_Scope)) = E_Function))
or else
(Ekind (Ent) = E_Component
and then Is_Protected_Type (Scope (Ent)))
then
Error_Msg_N
("protected function cannot modify protected object", N);
return;
elsif Ekind (Ent) = E_Loop_Parameter then
Error_Msg_N ("assignment to loop parameter not allowed", N);
return;
end if;
end;
-- For indexed components, test prefix if it is in array. We do not
-- want to recurse for cases where the prefix is a pointer, since we
-- may get a message confusing the pointer and what it references.
elsif Nkind (N) = N_Indexed_Component
and then Is_Array_Type (Etype (Prefix (N)))
then
Diagnose_Non_Variable_Lhs (Prefix (N));
return;
-- Another special case for assignment to discriminant
elsif Nkind (N) = N_Selected_Component then
if Present (Entity (Selector_Name (N)))
and then Ekind (Entity (Selector_Name (N))) = E_Discriminant
then
Error_Msg_N ("assignment to discriminant not allowed", N);
return;
-- For selection from record, diagnose prefix, but note that again
-- we only do this for a record, not e.g. for a pointer.
elsif Is_Record_Type (Etype (Prefix (N))) then
Diagnose_Non_Variable_Lhs (Prefix (N));
return;
end if;
end if;
-- If we fall through, we have no special message to issue
Error_Msg_N ("left hand side of assignment must be a variable", N);
end Diagnose_Non_Variable_Lhs;
--------------
-- Kill_Lhs --
--------------
procedure Kill_Lhs is
begin
if Is_Entity_Name (Lhs) then
declare
Ent : constant Entity_Id := Entity (Lhs);
begin
if Present (Ent) then
Kill_Current_Values (Ent);
end if;
end;
end if;
end Kill_Lhs;
-------------------------
-- Set_Assignment_Type --
-------------------------
procedure Set_Assignment_Type
(Opnd : Node_Id;
Opnd_Type : in out Entity_Id)
is
begin
Require_Entity (Opnd);
-- If the assignment operand is an in-out or out parameter, then we
-- get the actual subtype (needed for the unconstrained case). If the
-- operand is the actual in an entry declaration, then within the
-- accept statement it is replaced with a local renaming, which may
-- also have an actual subtype.
if Is_Entity_Name (Opnd)
and then (Ekind (Entity (Opnd)) = E_Out_Parameter
or else Ekind_In (Entity (Opnd),
E_In_Out_Parameter,
E_Generic_In_Out_Parameter)
or else
(Ekind (Entity (Opnd)) = E_Variable
and then Nkind (Parent (Entity (Opnd))) =
N_Object_Renaming_Declaration
and then Nkind (Parent (Parent (Entity (Opnd)))) =
N_Accept_Statement))
then
Opnd_Type := Get_Actual_Subtype (Opnd);
-- If assignment operand is a component reference, then we get the
-- actual subtype of the component for the unconstrained case.
elsif Nkind_In (Opnd, N_Selected_Component, N_Explicit_Dereference)
and then not Is_Unchecked_Union (Opnd_Type)
then
Decl := Build_Actual_Subtype_Of_Component (Opnd_Type, Opnd);
if Present (Decl) then
Insert_Action (N, Decl);
Mark_Rewrite_Insertion (Decl);
Analyze (Decl);
Opnd_Type := Defining_Identifier (Decl);
Set_Etype (Opnd, Opnd_Type);
Freeze_Itype (Opnd_Type, N);
elsif Is_Constrained (Etype (Opnd)) then
Opnd_Type := Etype (Opnd);
end if;
-- For slice, use the constrained subtype created for the slice
elsif Nkind (Opnd) = N_Slice then
Opnd_Type := Etype (Opnd);
end if;
end Set_Assignment_Type;
-- Local variables
Mode : Ghost_Mode_Type;
-- Start of processing for Analyze_Assignment
begin
-- Save LHS for use in target names (AI12-125)
Current_LHS := Lhs;
Mark_Coextensions (N, Rhs);
-- Analyze the target of the assignment first in case the expression
-- contains references to Ghost entities. The checks that verify the
-- proper use of a Ghost entity need to know the enclosing context.
Analyze (Lhs);
-- An assignment statement is Ghost when the left hand side denotes a
-- Ghost entity. Set the mode now to ensure that any nodes generated
-- during analysis and expansion are properly marked as Ghost.
Mark_And_Set_Ghost_Assignment (N, Mode);
Analyze (Rhs);
-- Ensure that we never do an assignment on a variable marked as
-- as Safe_To_Reevaluate.
pragma Assert (not Is_Entity_Name (Lhs)
or else Ekind (Entity (Lhs)) /= E_Variable
or else not Is_Safe_To_Reevaluate (Entity (Lhs)));
-- Start type analysis for assignment
T1 := Etype (Lhs);
-- In the most general case, both Lhs and Rhs can be overloaded, and we
-- must compute the intersection of the possible types on each side.
if Is_Overloaded (Lhs) then
declare
I : Interp_Index;
It : Interp;
begin
T1 := Any_Type;
Get_First_Interp (Lhs, I, It);
while Present (It.Typ) loop
-- An indexed component with generalized indexing is always
-- overloaded with the corresponding dereference. Discard the
-- interpretation that yields a reference type, which is not
-- assignable.
if Nkind (Lhs) = N_Indexed_Component
and then Present (Generalized_Indexing (Lhs))
and then Has_Implicit_Dereference (It.Typ)
then
null;
-- This may be a call to a parameterless function through an
-- implicit dereference, so discard interpretation as well.
elsif Is_Entity_Name (Lhs)
and then Has_Implicit_Dereference (It.Typ)
then
null;
elsif Has_Compatible_Type (Rhs, It.Typ) then
if T1 /= Any_Type then
-- An explicit dereference is overloaded if the prefix
-- is. Try to remove the ambiguity on the prefix, the
-- error will be posted there if the ambiguity is real.
if Nkind (Lhs) = N_Explicit_Dereference then
declare
PI : Interp_Index;
PI1 : Interp_Index := 0;
PIt : Interp;
Found : Boolean;
begin
Found := False;
Get_First_Interp (Prefix (Lhs), PI, PIt);
while Present (PIt.Typ) loop
if Is_Access_Type (PIt.Typ)
and then Has_Compatible_Type
(Rhs, Designated_Type (PIt.Typ))
then
if Found then
PIt :=
Disambiguate (Prefix (Lhs),
PI1, PI, Any_Type);
if PIt = No_Interp then
Error_Msg_N
("ambiguous left-hand side in "
& "assignment", Lhs);
exit;
else
Resolve (Prefix (Lhs), PIt.Typ);
end if;
exit;
else
Found := True;
PI1 := PI;
end if;
end if;
Get_Next_Interp (PI, PIt);
end loop;
end;
else
Error_Msg_N
("ambiguous left-hand side in assignment", Lhs);
exit;
end if;
else
T1 := It.Typ;
end if;
end if;
Get_Next_Interp (I, It);
end loop;
end;
if T1 = Any_Type then
Error_Msg_N
("no valid types for left-hand side for assignment", Lhs);
Kill_Lhs;
goto Leave;
end if;
end if;
-- The resulting assignment type is T1, so now we will resolve the left
-- hand side of the assignment using this determined type.
Resolve (Lhs, T1);
-- Cases where Lhs is not a variable
-- Cases where Lhs is not a variable. In an instance or an inlined body
-- no need for further check because assignment was legal in template.
if In_Inlined_Body then
null;
elsif not Is_Variable (Lhs) then
-- Ada 2005 (AI-327): Check assignment to the attribute Priority of a
-- protected object.
declare
Ent : Entity_Id;
S : Entity_Id;
begin
if Ada_Version >= Ada_2005 then
-- Handle chains of renamings
Ent := Lhs;
while Nkind (Ent) in N_Has_Entity
and then Present (Entity (Ent))
and then Present (Renamed_Object (Entity (Ent)))
loop
Ent := Renamed_Object (Entity (Ent));
end loop;
if (Nkind (Ent) = N_Attribute_Reference
and then Attribute_Name (Ent) = Name_Priority)
-- Renamings of the attribute Priority applied to protected
-- objects have been previously expanded into calls to the
-- Get_Ceiling run-time subprogram.
or else Is_Expanded_Priority_Attribute (Ent)
then
-- The enclosing subprogram cannot be a protected function
S := Current_Scope;
while not (Is_Subprogram (S)
and then Convention (S) = Convention_Protected)
and then S /= Standard_Standard
loop
S := Scope (S);
end loop;
if Ekind (S) = E_Function
and then Convention (S) = Convention_Protected
then
Error_Msg_N
("protected function cannot modify protected object",
Lhs);
end if;
-- Changes of the ceiling priority of the protected object
-- are only effective if the Ceiling_Locking policy is in
-- effect (AARM D.5.2 (5/2)).
if Locking_Policy /= 'C' then
Error_Msg_N
("assignment to the attribute PRIORITY has no effect??",
Lhs);
Error_Msg_N
("\since no Locking_Policy has been specified??", Lhs);
end if;
goto Leave;
end if;
end if;
end;
Diagnose_Non_Variable_Lhs (Lhs);
goto Leave;
-- Error of assigning to limited type. We do however allow this in
-- certain cases where the front end generates the assignments.
elsif Is_Limited_Type (T1)
and then not Assignment_OK (Lhs)
and then not Assignment_OK (Original_Node (Lhs))
then
-- CPP constructors can only be called in declarations
if Is_CPP_Constructor_Call (Rhs) then
Error_Msg_N ("invalid use of 'C'P'P constructor", Rhs);
else
Error_Msg_N
("left hand of assignment must not be limited type", Lhs);
Explain_Limited_Type (T1, Lhs);
end if;
goto Leave;
-- A class-wide type may be a limited view. This illegal case is not
-- caught by previous checks.
elsif Ekind (T1) = E_Class_Wide_Type and then From_Limited_With (T1) then
Error_Msg_NE ("invalid use of limited view of&", Lhs, T1);
goto Leave;
-- Enforce RM 3.9.3 (8): the target of an assignment operation cannot be
-- abstract. This is only checked when the assignment Comes_From_Source,
-- because in some cases the expander generates such assignments (such
-- in the _assign operation for an abstract type).
elsif Is_Abstract_Type (T1) and then Comes_From_Source (N) then
Error_Msg_N
("target of assignment operation must not be abstract", Lhs);
end if;
-- Resolution may have updated the subtype, in case the left-hand side
-- is a private protected component. Use the correct subtype to avoid
-- scoping issues in the back-end.
T1 := Etype (Lhs);
-- Ada 2005 (AI-50217, AI-326): Check wrong dereference of incomplete
-- type. For example:
-- limited with P;
-- package Pkg is
-- type Acc is access P.T;
-- end Pkg;
-- with Pkg; use Acc;
-- procedure Example is
-- A, B : Acc;
-- begin
-- A.all := B.all; -- ERROR
-- end Example;
if Nkind (Lhs) = N_Explicit_Dereference
and then Ekind (T1) = E_Incomplete_Type
then
Error_Msg_N ("invalid use of incomplete type", Lhs);
Kill_Lhs;
goto Leave;
end if;
-- Now we can complete the resolution of the right hand side
Set_Assignment_Type (Lhs, T1);
Resolve (Rhs, T1);
-- If the right-hand side contains target names, expansion has been
-- disabled to prevent expansion that might move target names out of
-- the context of the assignment statement. Restore the expander mode
-- now so that assignment statement can be properly expanded.
if Nkind (N) = N_Assignment_Statement and then Has_Target_Names (N) then
Expander_Mode_Restore;
end if;
-- This is the point at which we check for an unset reference
Check_Unset_Reference (Rhs);
Check_Unprotected_Access (Lhs, Rhs);
-- Remaining steps are skipped if Rhs was syntactically in error
if Rhs = Error then
Kill_Lhs;
goto Leave;
end if;
T2 := Etype (Rhs);
if not Covers (T1, T2) then
Wrong_Type (Rhs, Etype (Lhs));
Kill_Lhs;
goto Leave;
end if;
-- Ada 2005 (AI-326): In case of explicit dereference of incomplete
-- types, use the non-limited view if available
if Nkind (Rhs) = N_Explicit_Dereference
and then Is_Tagged_Type (T2)
and then Has_Non_Limited_View (T2)
then
T2 := Non_Limited_View (T2);
end if;
Set_Assignment_Type (Rhs, T2);
if Total_Errors_Detected /= 0 then
if No (T1) then
T1 := Any_Type;
end if;
if No (T2) then
T2 := Any_Type;
end if;
end if;
if T1 = Any_Type or else T2 = Any_Type then
Kill_Lhs;
goto Leave;
end if;
-- If the rhs is class-wide or dynamically tagged, then require the lhs
-- to be class-wide. The case where the rhs is a dynamically tagged call
-- to a dispatching operation with a controlling access result is
-- excluded from this check, since the target has an access type (and
-- no tag propagation occurs in that case).
if (Is_Class_Wide_Type (T2)
or else (Is_Dynamically_Tagged (Rhs)
and then not Is_Access_Type (T1)))
and then not Is_Class_Wide_Type (T1)
then
Error_Msg_N ("dynamically tagged expression not allowed!", Rhs);
elsif Is_Class_Wide_Type (T1)
and then not Is_Class_Wide_Type (T2)
and then not Is_Tag_Indeterminate (Rhs)
and then not Is_Dynamically_Tagged (Rhs)
then
Error_Msg_N ("dynamically tagged expression required!", Rhs);
end if;
-- Propagate the tag from a class-wide target to the rhs when the rhs
-- is a tag-indeterminate call.
if Is_Tag_Indeterminate (Rhs) then
if Is_Class_Wide_Type (T1) then
Propagate_Tag (Lhs, Rhs);
elsif Nkind (Rhs) = N_Function_Call
and then Is_Entity_Name (Name (Rhs))
and then Is_Abstract_Subprogram (Entity (Name (Rhs)))
then
Error_Msg_N
("call to abstract function must be dispatching", Name (Rhs));
elsif Nkind (Rhs) = N_Qualified_Expression
and then Nkind (Expression (Rhs)) = N_Function_Call
and then Is_Entity_Name (Name (Expression (Rhs)))
and then
Is_Abstract_Subprogram (Entity (Name (Expression (Rhs))))
then
Error_Msg_N
("call to abstract function must be dispatching",
Name (Expression (Rhs)));
end if;
end if;
-- Ada 2005 (AI-385): When the lhs type is an anonymous access type,
-- apply an implicit conversion of the rhs to that type to force
-- appropriate static and run-time accessibility checks. This applies
-- as well to anonymous access-to-subprogram types that are component
-- subtypes or formal parameters.
if Ada_Version >= Ada_2005 and then Is_Access_Type (T1) then
if Is_Local_Anonymous_Access (T1)
or else Ekind (T2) = E_Anonymous_Access_Subprogram_Type
-- Handle assignment to an Ada 2012 stand-alone object
-- of an anonymous access type.
or else (Ekind (T1) = E_Anonymous_Access_Type
and then Nkind (Associated_Node_For_Itype (T1)) =
N_Object_Declaration)
then
Rewrite (Rhs, Convert_To (T1, Relocate_Node (Rhs)));
Analyze_And_Resolve (Rhs, T1);
end if;
end if;
-- Ada 2005 (AI-231): Assignment to not null variable
if Ada_Version >= Ada_2005
and then Can_Never_Be_Null (T1)
and then not Assignment_OK (Lhs)
then
-- Case where we know the right hand side is null
if Known_Null (Rhs) then
Apply_Compile_Time_Constraint_Error
(N => Rhs,
Msg =>
"(Ada 2005) null not allowed in null-excluding objects??",
Reason => CE_Null_Not_Allowed);
-- We still mark this as a possible modification, that's necessary
-- to reset Is_True_Constant, and desirable for xref purposes.
Note_Possible_Modification (Lhs, Sure => True);
goto Leave;
-- If we know the right hand side is non-null, then we convert to the
-- target type, since we don't need a run time check in that case.
elsif not Can_Never_Be_Null (T2) then
Rewrite (Rhs, Convert_To (T1, Relocate_Node (Rhs)));
Analyze_And_Resolve (Rhs, T1);
end if;
end if;
if Is_Scalar_Type (T1) then
Apply_Scalar_Range_Check (Rhs, Etype (Lhs));
-- For array types, verify that lengths match. If the right hand side
-- is a function call that has been inlined, the assignment has been
-- rewritten as a block, and the constraint check will be applied to the
-- assignment within the block.
elsif Is_Array_Type (T1)
and then (Nkind (Rhs) /= N_Type_Conversion
or else Is_Constrained (Etype (Rhs)))
and then (Nkind (Rhs) /= N_Function_Call
or else Nkind (N) /= N_Block_Statement)
then
-- Assignment verifies that the length of the Lsh and Rhs are equal,
-- but of course the indexes do not have to match. If the right-hand
-- side is a type conversion to an unconstrained type, a length check
-- is performed on the expression itself during expansion. In rare
-- cases, the redundant length check is computed on an index type
-- with a different representation, triggering incorrect code in the
-- back end.
Apply_Length_Check (Rhs, Etype (Lhs));
else
-- Discriminant checks are applied in the course of expansion
null;
end if;
-- Note: modifications of the Lhs may only be recorded after
-- checks have been applied.
Note_Possible_Modification (Lhs, Sure => True);
-- ??? a real accessibility check is needed when ???
-- Post warning for redundant assignment or variable to itself
if Warn_On_Redundant_Constructs
-- We only warn for source constructs
and then Comes_From_Source (N)
-- Where the object is the same on both sides
and then Same_Object (Lhs, Original_Node (Rhs))
-- But exclude the case where the right side was an operation that
-- got rewritten (e.g. JUNK + K, where K was known to be zero). We
-- don't want to warn in such a case, since it is reasonable to write
-- such expressions especially when K is defined symbolically in some
-- other package.
and then Nkind (Original_Node (Rhs)) not in N_Op
then
if Nkind (Lhs) in N_Has_Entity then
Error_Msg_NE -- CODEFIX
("?r?useless assignment of & to itself!", N, Entity (Lhs));
else
Error_Msg_N -- CODEFIX
("?r?useless assignment of object to itself!", N);
end if;
end if;
-- Check for non-allowed composite assignment
if not Support_Composite_Assign_On_Target
and then (Is_Array_Type (T1) or else Is_Record_Type (T1))
and then (not Has_Size_Clause (T1) or else Esize (T1) > 64)
then
Error_Msg_CRT ("composite assignment", N);
end if;
-- Check elaboration warning for left side if not in elab code
if not In_Subprogram_Or_Concurrent_Unit then
Check_Elab_Assign (Lhs);
end if;
-- Set Referenced_As_LHS if appropriate. We only set this flag if the
-- assignment is a source assignment in the extended main source unit.
-- We are not interested in any reference information outside this
-- context, or in compiler generated assignment statements.
if Comes_From_Source (N)
and then In_Extended_Main_Source_Unit (Lhs)
then
Set_Referenced_Modified (Lhs, Out_Param => False);
end if;
-- RM 7.3.2 (12/3): An assignment to a view conversion (from a type
-- to one of its ancestors) requires an invariant check. Apply check
-- only if expression comes from source, otherwise it will be applied
-- when value is assigned to source entity.
if Nkind (Lhs) = N_Type_Conversion
and then Has_Invariants (Etype (Expression (Lhs)))
and then Comes_From_Source (Expression (Lhs))
then
Insert_After (N, Make_Invariant_Call (Expression (Lhs)));
end if;
-- Final step. If left side is an entity, then we may be able to reset
-- the current tracked values to new safe values. We only have something
-- to do if the left side is an entity name, and expansion has not
-- modified the node into something other than an assignment, and of
-- course we only capture values if it is safe to do so.
if Is_Entity_Name (Lhs)
and then Nkind (N) = N_Assignment_Statement
then
declare
Ent : constant Entity_Id := Entity (Lhs);
begin
if Safe_To_Capture_Value (N, Ent) then
-- If simple variable on left side, warn if this assignment
-- blots out another one (rendering it useless). We only do
-- this for source assignments, otherwise we can generate bogus
-- warnings when an assignment is rewritten as another
-- assignment, and gets tied up with itself.
-- There may have been a previous reference to a component of
-- the variable, which in general removes the Last_Assignment
-- field of the variable to indicate a relevant use of the
-- previous assignment. However, if the assignment is to a
-- subcomponent the reference may not have registered, because
-- it is not possible to determine whether the context is an
-- assignment. In those cases we generate a Deferred_Reference,
-- to be used at the end of compilation to generate the right
-- kind of reference, and we suppress a potential warning for
-- a useless assignment, which might be premature. This may
-- lose a warning in rare cases, but seems preferable to a
-- misleading warning.
if Warn_On_Modified_Unread
and then Is_Assignable (Ent)
and then Comes_From_Source (N)
and then In_Extended_Main_Source_Unit (Ent)
and then not Has_Deferred_Reference (Ent)
then
Warn_On_Useless_Assignment (Ent, N);
end if;
-- If we are assigning an access type and the left side is an
-- entity, then make sure that the Is_Known_[Non_]Null flags
-- properly reflect the state of the entity after assignment.
if Is_Access_Type (T1) then
if Known_Non_Null (Rhs) then
Set_Is_Known_Non_Null (Ent, True);
elsif Known_Null (Rhs)
and then not Can_Never_Be_Null (Ent)
then
Set_Is_Known_Null (Ent, True);
else
Set_Is_Known_Null (Ent, False);
if not Can_Never_Be_Null (Ent) then
Set_Is_Known_Non_Null (Ent, False);
end if;
end if;
-- For discrete types, we may be able to set the current value
-- if the value is known at compile time.
elsif Is_Discrete_Type (T1)
and then Compile_Time_Known_Value (Rhs)
then
Set_Current_Value (Ent, Rhs);
else
Set_Current_Value (Ent, Empty);
end if;
-- If not safe to capture values, kill them
else
Kill_Lhs;
end if;
end;
end if;
-- If assigning to an object in whole or in part, note location of
-- assignment in case no one references value. We only do this for
-- source assignments, otherwise we can generate bogus warnings when an
-- assignment is rewritten as another assignment, and gets tied up with
-- itself.
declare
Ent : constant Entity_Id := Get_Enclosing_Object (Lhs);
begin
if Present (Ent)
and then Safe_To_Capture_Value (N, Ent)
and then Nkind (N) = N_Assignment_Statement
and then Warn_On_Modified_Unread
and then Is_Assignable (Ent)
and then Comes_From_Source (N)
and then In_Extended_Main_Source_Unit (Ent)
then
Set_Last_Assignment (Ent, Lhs);
end if;
end;
Analyze_Dimension (N);
<<Leave>>
Current_LHS := Empty;
Restore_Ghost_Mode (Mode);
end Analyze_Assignment;
-----------------------------
-- Analyze_Block_Statement --
-----------------------------
procedure Analyze_Block_Statement (N : Node_Id) is
procedure Install_Return_Entities (Scop : Entity_Id);
-- Install all entities of return statement scope Scop in the visibility
-- chain except for the return object since its entity is reused in a
-- renaming.
-----------------------------
-- Install_Return_Entities --
-----------------------------
procedure Install_Return_Entities (Scop : Entity_Id) is
Id : Entity_Id;
begin
Id := First_Entity (Scop);
while Present (Id) loop
-- Do not install the return object
if not Ekind_In (Id, E_Constant, E_Variable)
or else not Is_Return_Object (Id)
then
Install_Entity (Id);
end if;
Next_Entity (Id);
end loop;
end Install_Return_Entities;
-- Local constants and variables
Decls : constant List_Id := Declarations (N);
Id : constant Node_Id := Identifier (N);
HSS : constant Node_Id := Handled_Statement_Sequence (N);
Is_BIP_Return_Statement : Boolean;
-- Start of processing for Analyze_Block_Statement
begin
-- In SPARK mode, we reject block statements. Note that the case of
-- block statements generated by the expander is fine.
if Nkind (Original_Node (N)) = N_Block_Statement then
Check_SPARK_05_Restriction ("block statement is not allowed", N);
end if;
-- If no handled statement sequence is present, things are really messed
-- up, and we just return immediately (defence against previous errors).
if No (HSS) then
Check_Error_Detected;
return;
end if;
-- Detect whether the block is actually a rewritten return statement of
-- a build-in-place function.
Is_BIP_Return_Statement :=
Present (Id)
and then Present (Entity (Id))
and then Ekind (Entity (Id)) = E_Return_Statement
and then Is_Build_In_Place_Function
(Return_Applies_To (Entity (Id)));
-- Normal processing with HSS present
declare
EH : constant List_Id := Exception_Handlers (HSS);
Ent : Entity_Id := Empty;
S : Entity_Id;
Save_Unblocked_Exit_Count : constant Nat := Unblocked_Exit_Count;
-- Recursively save value of this global, will be restored on exit
begin
-- Initialize unblocked exit count for statements of begin block
-- plus one for each exception handler that is present.
Unblocked_Exit_Count := 1;
if Present (EH) then
Unblocked_Exit_Count := Unblocked_Exit_Count + List_Length (EH);
end if;
-- If a label is present analyze it and mark it as referenced
if Present (Id) then
Analyze (Id);
Ent := Entity (Id);
-- An error defense. If we have an identifier, but no entity, then
-- something is wrong. If previous errors, then just remove the
-- identifier and continue, otherwise raise an exception.
if No (Ent) then
Check_Error_Detected;
Set_Identifier (N, Empty);
else
Set_Ekind (Ent, E_Block);
Generate_Reference (Ent, N, ' ');
Generate_Definition (Ent);
if Nkind (Parent (Ent)) = N_Implicit_Label_Declaration then
Set_Label_Construct (Parent (Ent), N);
end if;
end if;
end if;
-- If no entity set, create a label entity
if No (Ent) then
Ent := New_Internal_Entity (E_Block, Current_Scope, Sloc (N), 'B');
Set_Identifier (N, New_Occurrence_Of (Ent, Sloc (N)));
Set_Parent (Ent, N);
end if;
Set_Etype (Ent, Standard_Void_Type);
Set_Block_Node (Ent, Identifier (N));
Push_Scope (Ent);
-- The block served as an extended return statement. Ensure that any
-- entities created during the analysis and expansion of the return
-- object declaration are once again visible.
if Is_BIP_Return_Statement then
Install_Return_Entities (Ent);
end if;
if Present (Decls) then
Analyze_Declarations (Decls);
Check_Completion;
Inspect_Deferred_Constant_Completion (Decls);
end if;
Analyze (HSS);
Process_End_Label (HSS, 'e', Ent);
-- If exception handlers are present, then we indicate that enclosing
-- scopes contain a block with handlers. We only need to mark non-
-- generic scopes.
if Present (EH) then
S := Scope (Ent);
loop
Set_Has_Nested_Block_With_Handler (S);
exit when Is_Overloadable (S)
or else Ekind (S) = E_Package
or else Is_Generic_Unit (S);
S := Scope (S);
end loop;
end if;
Check_References (Ent);
End_Scope;
if Unblocked_Exit_Count = 0 then
Unblocked_Exit_Count := Save_Unblocked_Exit_Count;
Check_Unreachable_Code (N);
else
Unblocked_Exit_Count := Save_Unblocked_Exit_Count;
end if;
end;
end Analyze_Block_Statement;
--------------------------------
-- Analyze_Compound_Statement --
--------------------------------
procedure Analyze_Compound_Statement (N : Node_Id) is
begin
Analyze_List (Actions (N));
end Analyze_Compound_Statement;
----------------------------
-- Analyze_Case_Statement --
----------------------------
procedure Analyze_Case_Statement (N : Node_Id) is
Exp : Node_Id;
Exp_Type : Entity_Id;
Exp_Btype : Entity_Id;
Last_Choice : Nat;
Others_Present : Boolean;
-- Indicates if Others was present
pragma Warnings (Off, Last_Choice);
-- Don't care about assigned value
Statements_Analyzed : Boolean := False;
-- Set True if at least some statement sequences get analyzed. If False
-- on exit, means we had a serious error that prevented full analysis of
-- the case statement, and as a result it is not a good idea to output
-- warning messages about unreachable code.
Save_Unblocked_Exit_Count : constant Nat := Unblocked_Exit_Count;
-- Recursively save value of this global, will be restored on exit
procedure Non_Static_Choice_Error (Choice : Node_Id);
-- Error routine invoked by the generic instantiation below when the
-- case statement has a non static choice.
procedure Process_Statements (Alternative : Node_Id);
-- Analyzes the statements associated with a case alternative. Needed
-- by instantiation below.
package Analyze_Case_Choices is new
Generic_Analyze_Choices
(Process_Associated_Node => Process_Statements);
use Analyze_Case_Choices;
-- Instantiation of the generic choice analysis package
package Check_Case_Choices is new
Generic_Check_Choices
(Process_Empty_Choice => No_OP,
Process_Non_Static_Choice => Non_Static_Choice_Error,
Process_Associated_Node => No_OP);
use Check_Case_Choices;
-- Instantiation of the generic choice processing package
-----------------------------
-- Non_Static_Choice_Error --
-----------------------------
procedure Non_Static_Choice_Error (Choice : Node_Id) is
begin
Flag_Non_Static_Expr
("choice given in case statement is not static!", Choice);
end Non_Static_Choice_Error;
------------------------
-- Process_Statements --
------------------------
procedure Process_Statements (Alternative : Node_Id) is
Choices : constant List_Id := Discrete_Choices (Alternative);
Ent : Entity_Id;
begin
Unblocked_Exit_Count := Unblocked_Exit_Count + 1;
Statements_Analyzed := True;
-- An interesting optimization. If the case statement expression
-- is a simple entity, then we can set the current value within an
-- alternative if the alternative has one possible value.
-- case N is
-- when 1 => alpha
-- when 2 | 3 => beta
-- when others => gamma
-- Here we know that N is initially 1 within alpha, but for beta and
-- gamma, we do not know anything more about the initial value.
if Is_Entity_Name (Exp) then
Ent := Entity (Exp);
if Ekind_In (Ent, E_Variable,
E_In_Out_Parameter,
E_Out_Parameter)
then
if List_Length (Choices) = 1
and then Nkind (First (Choices)) in N_Subexpr
and then Compile_Time_Known_Value (First (Choices))
then
Set_Current_Value (Entity (Exp), First (Choices));
end if;
Analyze_Statements (Statements (Alternative));
-- After analyzing the case, set the current value to empty
-- since we won't know what it is for the next alternative
-- (unless reset by this same circuit), or after the case.
Set_Current_Value (Entity (Exp), Empty);
return;
end if;
end if;
-- Case where expression is not an entity name of a variable
Analyze_Statements (Statements (Alternative));
end Process_Statements;
-- Start of processing for Analyze_Case_Statement
begin
Unblocked_Exit_Count := 0;
Exp := Expression (N);
Analyze (Exp);
-- The expression must be of any discrete type. In rare cases, the
-- expander constructs a case statement whose expression has a private
-- type whose full view is discrete. This can happen when generating
-- a stream operation for a variant type after the type is frozen,
-- when the partial of view of the type of the discriminant is private.
-- In that case, use the full view to analyze case alternatives.
if not Is_Overloaded (Exp)
and then not Comes_From_Source (N)
and then Is_Private_Type (Etype (Exp))
and then Present (Full_View (Etype (Exp)))
and then Is_Discrete_Type (Full_View (Etype (Exp)))
then
Resolve (Exp, Etype (Exp));
Exp_Type := Full_View (Etype (Exp));
else
Analyze_And_Resolve (Exp, Any_Discrete);
Exp_Type := Etype (Exp);
end if;
Check_Unset_Reference (Exp);
Exp_Btype := Base_Type (Exp_Type);
-- The expression must be of a discrete type which must be determinable
-- independently of the context in which the expression occurs, but
-- using the fact that the expression must be of a discrete type.
-- Moreover, the type this expression must not be a character literal
-- (which is always ambiguous) or, for Ada-83, a generic formal type.
-- If error already reported by Resolve, nothing more to do
if Exp_Btype = Any_Discrete or else Exp_Btype = Any_Type then
return;
elsif Exp_Btype = Any_Character then
Error_Msg_N
("character literal as case expression is ambiguous", Exp);
return;
elsif Ada_Version = Ada_83
and then (Is_Generic_Type (Exp_Btype)
or else Is_Generic_Type (Root_Type (Exp_Btype)))
then
Error_Msg_N
("(Ada 83) case expression cannot be of a generic type", Exp);
return;
end if;
-- If the case expression is a formal object of mode in out, then treat
-- it as having a nonstatic subtype by forcing use of the base type
-- (which has to get passed to Check_Case_Choices below). Also use base
-- type when the case expression is parenthesized.
if Paren_Count (Exp) > 0
or else (Is_Entity_Name (Exp)
and then Ekind (Entity (Exp)) = E_Generic_In_Out_Parameter)
then
Exp_Type := Exp_Btype;
end if;
-- Call instantiated procedures to analyzwe and check discrete choices
Analyze_Choices (Alternatives (N), Exp_Type);
Check_Choices (N, Alternatives (N), Exp_Type, Others_Present);
-- Case statement with single OTHERS alternative not allowed in SPARK
if Others_Present and then List_Length (Alternatives (N)) = 1 then
Check_SPARK_05_Restriction
("OTHERS as unique case alternative is not allowed", N);
end if;
if Exp_Type = Universal_Integer and then not Others_Present then
Error_Msg_N ("case on universal integer requires OTHERS choice", Exp);
end if;
-- If all our exits were blocked by unconditional transfers of control,
-- then the entire CASE statement acts as an unconditional transfer of
-- control, so treat it like one, and check unreachable code. Skip this
-- test if we had serious errors preventing any statement analysis.
if Unblocked_Exit_Count = 0 and then Statements_Analyzed then
Unblocked_Exit_Count := Save_Unblocked_Exit_Count;
Check_Unreachable_Code (N);
else
Unblocked_Exit_Count := Save_Unblocked_Exit_Count;
end if;
-- If the expander is active it will detect the case of a statically
-- determined single alternative and remove warnings for the case, but
-- if we are not doing expansion, that circuit won't be active. Here we
-- duplicate the effect of removing warnings in the same way, so that
-- we will get the same set of warnings in -gnatc mode.
if not Expander_Active
and then Compile_Time_Known_Value (Expression (N))
and then Serious_Errors_Detected = 0
then
declare
Chosen : constant Node_Id := Find_Static_Alternative (N);
Alt : Node_Id;
begin
Alt := First (Alternatives (N));
while Present (Alt) loop
if Alt /= Chosen then
Remove_Warning_Messages (Statements (Alt));
end if;
Next (Alt);
end loop;
end;
end if;
end Analyze_Case_Statement;
----------------------------
-- Analyze_Exit_Statement --
----------------------------
-- If the exit includes a name, it must be the name of a currently open
-- loop. Otherwise there must be an innermost open loop on the stack, to
-- which the statement implicitly refers.
-- Additionally, in SPARK mode:
-- The exit can only name the closest enclosing loop;
-- An exit with a when clause must be directly contained in a loop;
-- An exit without a when clause must be directly contained in an
-- if-statement with no elsif or else, which is itself directly contained
-- in a loop. The exit must be the last statement in the if-statement.
procedure Analyze_Exit_Statement (N : Node_Id) is
Target : constant Node_Id := Name (N);
Cond : constant Node_Id := Condition (N);
Scope_Id : Entity_Id;
U_Name : Entity_Id;
Kind : Entity_Kind;
begin
if No (Cond) then
Check_Unreachable_Code (N);
end if;
if Present (Target) then
Analyze (Target);
U_Name := Entity (Target);
if not In_Open_Scopes (U_Name) or else Ekind (U_Name) /= E_Loop then
Error_Msg_N ("invalid loop name in exit statement", N);
return;
else
if Has_Loop_In_Inner_Open_Scopes (U_Name) then
Check_SPARK_05_Restriction
("exit label must name the closest enclosing loop", N);
end if;
Set_Has_Exit (U_Name);
end if;
else
U_Name := Empty;
end if;
for J in reverse 0 .. Scope_Stack.Last loop
Scope_Id := Scope_Stack.Table (J).Entity;
Kind := Ekind (Scope_Id);
if Kind = E_Loop and then (No (Target) or else Scope_Id = U_Name) then
Set_Has_Exit (Scope_Id);
exit;
elsif Kind = E_Block
or else Kind = E_Loop
or else Kind = E_Return_Statement
then
null;
else
Error_Msg_N
("cannot exit from program unit or accept statement", N);
return;
end if;
end loop;
-- Verify that if present the condition is a Boolean expression
if Present (Cond) then
Analyze_And_Resolve (Cond, Any_Boolean);
Check_Unset_Reference (Cond);
end if;
-- In SPARK mode, verify that the exit statement respects the SPARK
-- restrictions.
if Present (Cond) then
if Nkind (Parent (N)) /= N_Loop_Statement then
Check_SPARK_05_Restriction
("exit with when clause must be directly in loop", N);
end if;
else
if Nkind (Parent (N)) /= N_If_Statement then
if Nkind (Parent (N)) = N_Elsif_Part then
Check_SPARK_05_Restriction
("exit must be in IF without ELSIF", N);
else
Check_SPARK_05_Restriction ("exit must be directly in IF", N);
end if;
elsif Nkind (Parent (Parent (N))) /= N_Loop_Statement then
Check_SPARK_05_Restriction
("exit must be in IF directly in loop", N);
-- First test the presence of ELSE, so that an exit in an ELSE leads
-- to an error mentioning the ELSE.
elsif Present (Else_Statements (Parent (N))) then
Check_SPARK_05_Restriction ("exit must be in IF without ELSE", N);
-- An exit in an ELSIF does not reach here, as it would have been
-- detected in the case (Nkind (Parent (N)) /= N_If_Statement).
elsif Present (Elsif_Parts (Parent (N))) then
Check_SPARK_05_Restriction ("exit must be in IF without ELSIF", N);
end if;
end if;
-- Chain exit statement to associated loop entity
Set_Next_Exit_Statement (N, First_Exit_Statement (Scope_Id));
Set_First_Exit_Statement (Scope_Id, N);
-- Since the exit may take us out of a loop, any previous assignment
-- statement is not useless, so clear last assignment indications. It
-- is OK to keep other current values, since if the exit statement
-- does not exit, then the current values are still valid.
Kill_Current_Values (Last_Assignment_Only => True);
end Analyze_Exit_Statement;
----------------------------
-- Analyze_Goto_Statement --
----------------------------
procedure Analyze_Goto_Statement (N : Node_Id) is
Label : constant Node_Id := Name (N);
Scope_Id : Entity_Id;
Label_Scope : Entity_Id;
Label_Ent : Entity_Id;
begin
Check_SPARK_05_Restriction ("goto statement is not allowed", N);
-- Actual semantic checks
Check_Unreachable_Code (N);
Kill_Current_Values (Last_Assignment_Only => True);
Analyze (Label);
Label_Ent := Entity (Label);
-- Ignore previous error
if Label_Ent = Any_Id then
Check_Error_Detected;
return;
-- We just have a label as the target of a goto
elsif Ekind (Label_Ent) /= E_Label then
Error_Msg_N ("target of goto statement must be a label", Label);
return;
-- Check that the target of the goto is reachable according to Ada
-- scoping rules. Note: the special gotos we generate for optimizing
-- local handling of exceptions would violate these rules, but we mark
-- such gotos as analyzed when built, so this code is never entered.
elsif not Reachable (Label_Ent) then
Error_Msg_N ("target of goto statement is not reachable", Label);
return;
end if;
-- Here if goto passes initial validity checks
Label_Scope := Enclosing_Scope (Label_Ent);
for J in reverse 0 .. Scope_Stack.Last loop
Scope_Id := Scope_Stack.Table (J).Entity;
if Label_Scope = Scope_Id
or else not Ekind_In (Scope_Id, E_Block, E_Loop, E_Return_Statement)
then
if Scope_Id /= Label_Scope then
Error_Msg_N
("cannot exit from program unit or accept statement", N);
end if;
return;
end if;
end loop;
raise Program_Error;
end Analyze_Goto_Statement;
--------------------------
-- Analyze_If_Statement --
--------------------------
-- A special complication arises in the analysis of if statements
-- The expander has circuitry to completely delete code that it can tell
-- will not be executed (as a result of compile time known conditions). In
-- the analyzer, we ensure that code that will be deleted in this manner
-- is analyzed but not expanded. This is obviously more efficient, but
-- more significantly, difficulties arise if code is expanded and then
-- eliminated (e.g. exception table entries disappear). Similarly, itypes
-- generated in deleted code must be frozen from start, because the nodes
-- on which they depend will not be available at the freeze point.
procedure Analyze_If_Statement (N : Node_Id) is
E : Node_Id;
Save_Unblocked_Exit_Count : constant Nat := Unblocked_Exit_Count;
-- Recursively save value of this global, will be restored on exit
Save_In_Deleted_Code : Boolean;
Del : Boolean := False;
-- This flag gets set True if a True condition has been found, which
-- means that remaining ELSE/ELSIF parts are deleted.
procedure Analyze_Cond_Then (Cnode : Node_Id);
-- This is applied to either the N_If_Statement node itself or to an
-- N_Elsif_Part node. It deals with analyzing the condition and the THEN
-- statements associated with it.
-----------------------
-- Analyze_Cond_Then --
-----------------------
procedure Analyze_Cond_Then (Cnode : Node_Id) is
Cond : constant Node_Id := Condition (Cnode);
Tstm : constant List_Id := Then_Statements (Cnode);
begin
Unblocked_Exit_Count := Unblocked_Exit_Count + 1;
Analyze_And_Resolve (Cond, Any_Boolean);
Check_Unset_Reference (Cond);
Set_Current_Value_Condition (Cnode);
-- If already deleting, then just analyze then statements
if Del then
Analyze_Statements (Tstm);
-- Compile time known value, not deleting yet
elsif Compile_Time_Known_Value (Cond) then
Save_In_Deleted_Code := In_Deleted_Code;
-- If condition is True, then analyze the THEN statements and set
-- no expansion for ELSE and ELSIF parts.
if Is_True (Expr_Value (Cond)) then
Analyze_Statements (Tstm);
Del := True;
Expander_Mode_Save_And_Set (False);
In_Deleted_Code := True;
-- If condition is False, analyze THEN with expansion off
else -- Is_False (Expr_Value (Cond))
Expander_Mode_Save_And_Set (False);
In_Deleted_Code := True;
Analyze_Statements (Tstm);
Expander_Mode_Restore;
In_Deleted_Code := Save_In_Deleted_Code;
end if;
-- Not known at compile time, not deleting, normal analysis
else
Analyze_Statements (Tstm);
end if;
end Analyze_Cond_Then;
-- Start of processing for Analyze_If_Statement
begin
-- Initialize exit count for else statements. If there is no else part,
-- this count will stay non-zero reflecting the fact that the uncovered
-- else case is an unblocked exit.
Unblocked_Exit_Count := 1;
Analyze_Cond_Then (N);
-- Now to analyze the elsif parts if any are present
if Present (Elsif_Parts (N)) then
E := First (Elsif_Parts (N));
while Present (E) loop
Analyze_Cond_Then (E);
Next (E);
end loop;
end if;
if Present (Else_Statements (N)) then
Analyze_Statements (Else_Statements (N));
end if;
-- If all our exits were blocked by unconditional transfers of control,
-- then the entire IF statement acts as an unconditional transfer of
-- control, so treat it like one, and check unreachable code.
if Unblocked_Exit_Count = 0 then
Unblocked_Exit_Count := Save_Unblocked_Exit_Count;
Check_Unreachable_Code (N);
else
Unblocked_Exit_Count := Save_Unblocked_Exit_Count;
end if;
if Del then
Expander_Mode_Restore;
In_Deleted_Code := Save_In_Deleted_Code;
end if;
if not Expander_Active
and then Compile_Time_Known_Value (Condition (N))
and then Serious_Errors_Detected = 0
then
if Is_True (Expr_Value (Condition (N))) then
Remove_Warning_Messages (Else_Statements (N));
if Present (Elsif_Parts (N)) then
E := First (Elsif_Parts (N));
while Present (E) loop
Remove_Warning_Messages (Then_Statements (E));
Next (E);
end loop;
end if;
else
Remove_Warning_Messages (Then_Statements (N));
end if;
end if;
-- Warn on redundant if statement that has no effect
-- Note, we could also check empty ELSIF parts ???
if Warn_On_Redundant_Constructs
-- If statement must be from source
and then Comes_From_Source (N)
-- Condition must not have obvious side effect
and then Has_No_Obvious_Side_Effects (Condition (N))
-- No elsif parts of else part
and then No (Elsif_Parts (N))
and then No (Else_Statements (N))
-- Then must be a single null statement
and then List_Length (Then_Statements (N)) = 1
then
-- Go to original node, since we may have rewritten something as
-- a null statement (e.g. a case we could figure the outcome of).
declare
T : constant Node_Id := First (Then_Statements (N));
S : constant Node_Id := Original_Node (T);
begin
if Comes_From_Source (S) and then Nkind (S) = N_Null_Statement then
Error_Msg_N ("if statement has no effect?r?", N);
end if;
end;
end if;
end Analyze_If_Statement;
----------------------------------------
-- Analyze_Implicit_Label_Declaration --
----------------------------------------
-- An implicit label declaration is generated in the innermost enclosing
-- declarative part. This is done for labels, and block and loop names.
-- Note: any changes in this routine may need to be reflected in
-- Analyze_Label_Entity.
procedure Analyze_Implicit_Label_Declaration (N : Node_Id) is
Id : constant Node_Id := Defining_Identifier (N);
begin
Enter_Name (Id);
Set_Ekind (Id, E_Label);
Set_Etype (Id, Standard_Void_Type);
Set_Enclosing_Scope (Id, Current_Scope);
end Analyze_Implicit_Label_Declaration;
------------------------------
-- Analyze_Iteration_Scheme --
------------------------------
procedure Analyze_Iteration_Scheme (N : Node_Id) is
Cond : Node_Id;
Iter_Spec : Node_Id;
Loop_Spec : Node_Id;
begin
-- For an infinite loop, there is no iteration scheme
if No (N) then
return;
end if;
Cond := Condition (N);
Iter_Spec := Iterator_Specification (N);
Loop_Spec := Loop_Parameter_Specification (N);
if Present (Cond) then
Analyze_And_Resolve (Cond, Any_Boolean);
Check_Unset_Reference (Cond);
Set_Current_Value_Condition (N);
elsif Present (Iter_Spec) then
Analyze_Iterator_Specification (Iter_Spec);
else
Analyze_Loop_Parameter_Specification (Loop_Spec);
end if;
end Analyze_Iteration_Scheme;
------------------------------------
-- Analyze_Iterator_Specification --
------------------------------------
procedure Analyze_Iterator_Specification (N : Node_Id) is
procedure Check_Reverse_Iteration (Typ : Entity_Id);
-- For an iteration over a container, if the loop carries the Reverse
-- indicator, verify that the container type has an Iterate aspect that
-- implements the reversible iterator interface.
function Get_Cursor_Type (Typ : Entity_Id) return Entity_Id;
-- For containers with Iterator and related aspects, the cursor is
-- obtained by locating an entity with the proper name in the scope
-- of the type.
-----------------------------
-- Check_Reverse_Iteration --
-----------------------------
procedure Check_Reverse_Iteration (Typ : Entity_Id) is
begin
if Reverse_Present (N)
and then not Is_Array_Type (Typ)
and then not Is_Reversible_Iterator (Typ)
then
Error_Msg_NE
("container type does not support reverse iteration", N, Typ);
end if;
end Check_Reverse_Iteration;
---------------------
-- Get_Cursor_Type --
---------------------
function Get_Cursor_Type (Typ : Entity_Id) return Entity_Id is
Ent : Entity_Id;
begin
-- If iterator type is derived, the cursor is declared in the scope
-- of the parent type.
if Is_Derived_Type (Typ) then
Ent := First_Entity (Scope (Etype (Typ)));
else
Ent := First_Entity (Scope (Typ));
end if;
while Present (Ent) loop
exit when Chars (Ent) = Name_Cursor;
Next_Entity (Ent);
end loop;
if No (Ent) then
return Any_Type;
end if;
-- The cursor is the target of generated assignments in the
-- loop, and cannot have a limited type.
if Is_Limited_Type (Etype (Ent)) then
Error_Msg_N ("cursor type cannot be limited", N);
end if;
return Etype (Ent);
end Get_Cursor_Type;
-- Local variables
Def_Id : constant Node_Id := Defining_Identifier (N);
Iter_Name : constant Node_Id := Name (N);
Loc : constant Source_Ptr := Sloc (N);
Subt : constant Node_Id := Subtype_Indication (N);
Bas : Entity_Id;
Typ : Entity_Id;
-- Start of processing for Analyze_Iterator_Specification
begin
Enter_Name (Def_Id);
-- AI12-0151 specifies that when the subtype indication is present, it
-- must statically match the type of the array or container element.
-- To simplify this check, we introduce a subtype declaration with the
-- given subtype indication when it carries a constraint, and rewrite
-- the original as a reference to the created subtype entity.
if Present (Subt) then
if Nkind (Subt) = N_Subtype_Indication then
declare
S : constant Entity_Id := Make_Temporary (Sloc (Subt), 'S');
Decl : constant Node_Id :=
Make_Subtype_Declaration (Loc,
Defining_Identifier => S,
Subtype_Indication => New_Copy_Tree (Subt));
begin
Insert_Before (Parent (Parent (N)), Decl);
Analyze (Decl);
Rewrite (Subt, New_Occurrence_Of (S, Sloc (Subt)));
end;
else
Analyze (Subt);
end if;
-- Save entity of subtype indication for subsequent check
Bas := Entity (Subt);
end if;
Preanalyze_Range (Iter_Name);
-- Set the kind of the loop variable, which is not visible within
-- the iterator name.
Set_Ekind (Def_Id, E_Variable);
-- Provide a link between the iterator variable and the container, for
-- subsequent use in cross-reference and modification information.
if Of_Present (N) then
Set_Related_Expression (Def_Id, Iter_Name);
-- For a container, the iterator is specified through the aspect
if not Is_Array_Type (Etype (Iter_Name)) then
declare
Iterator : constant Entity_Id :=
Find_Value_Of_Aspect
(Etype (Iter_Name), Aspect_Default_Iterator);
I : Interp_Index;
It : Interp;
begin
if No (Iterator) then
null; -- error reported below.
elsif not Is_Overloaded (Iterator) then
Check_Reverse_Iteration (Etype (Iterator));
-- If Iterator is overloaded, use reversible iterator if
-- one is available.
elsif Is_Overloaded (Iterator) then
Get_First_Interp (Iterator, I, It);
while Present (It.Nam) loop
if Ekind (It.Nam) = E_Function
and then Is_Reversible_Iterator (Etype (It.Nam))
then
Set_Etype (Iterator, It.Typ);
Set_Entity (Iterator, It.Nam);
exit;
end if;
Get_Next_Interp (I, It);
end loop;
Check_Reverse_Iteration (Etype (Iterator));
end if;
end;
end if;
end if;
-- If the domain of iteration is an expression, create a declaration for
-- it, so that finalization actions are introduced outside of the loop.
-- The declaration must be a renaming because the body of the loop may
-- assign to elements.
if not Is_Entity_Name (Iter_Name)
-- When the context is a quantified expression, the renaming
-- declaration is delayed until the expansion phase if we are
-- doing expansion.
and then (Nkind (Parent (N)) /= N_Quantified_Expression
or else Operating_Mode = Check_Semantics)
-- Do not perform this expansion for ASIS and when expansion is
-- disabled, where the temporary may hide the transformation of a
-- selected component into a prefixed function call, and references
-- need to see the original expression.
and then Expander_Active
then
declare
Id : constant Entity_Id := Make_Temporary (Loc, 'R', Iter_Name);
Decl : Node_Id;
Act_S : Node_Id;
begin
-- If the domain of iteration is an array component that depends
-- on a discriminant, create actual subtype for it. Pre-analysis
-- does not generate the actual subtype of a selected component.
if Nkind (Iter_Name) = N_Selected_Component
and then Is_Array_Type (Etype (Iter_Name))
then
Act_S :=
Build_Actual_Subtype_Of_Component
(Etype (Selector_Name (Iter_Name)), Iter_Name);
Insert_Action (N, Act_S);
if Present (Act_S) then
Typ := Defining_Identifier (Act_S);
else
Typ := Etype (Iter_Name);
end if;
else
Typ := Etype (Iter_Name);
-- Verify that the expression produces an iterator
if not Of_Present (N) and then not Is_Iterator (Typ)
and then not Is_Array_Type (Typ)
and then No (Find_Aspect (Typ, Aspect_Iterable))
then
Error_Msg_N
("expect object that implements iterator interface",
Iter_Name);
end if;
end if;
-- Protect against malformed iterator
if Typ = Any_Type then
Error_Msg_N ("invalid expression in loop iterator", Iter_Name);
return;
end if;
if not Of_Present (N) then
Check_Reverse_Iteration (Typ);
end if;
-- The name in the renaming declaration may be a function call.
-- Indicate that it does not come from source, to suppress
-- spurious warnings on renamings of parameterless functions,
-- a common enough idiom in user-defined iterators.
Decl :=
Make_Object_Renaming_Declaration (Loc,
Defining_Identifier => Id,
Subtype_Mark => New_Occurrence_Of (Typ, Loc),
Name =>
New_Copy_Tree (Iter_Name, New_Sloc => Loc));
Insert_Actions (Parent (Parent (N)), New_List (Decl));
Rewrite (Name (N), New_Occurrence_Of (Id, Loc));
Set_Etype (Id, Typ);
Set_Etype (Name (N), Typ);
end;
-- Container is an entity or an array with uncontrolled components, or
-- else it is a container iterator given by a function call, typically
-- called Iterate in the case of predefined containers, even though
-- Iterate is not a reserved name. What matters is that the return type
-- of the function is an iterator type.
elsif Is_Entity_Name (Iter_Name) then
Analyze (Iter_Name);
if Nkind (Iter_Name) = N_Function_Call then
declare
C : constant Node_Id := Name (Iter_Name);
I : Interp_Index;
It : Interp;
begin
if not Is_Overloaded (Iter_Name) then
Resolve (Iter_Name, Etype (C));
else
Get_First_Interp (C, I, It);
while It.Typ /= Empty loop
if Reverse_Present (N) then
if Is_Reversible_Iterator (It.Typ) then
Resolve (Iter_Name, It.Typ);
exit;
end if;
elsif Is_Iterator (It.Typ) then
Resolve (Iter_Name, It.Typ);
exit;
end if;
Get_Next_Interp (I, It);
end loop;
end if;
end;
-- Domain of iteration is not overloaded
else
Resolve (Iter_Name, Etype (Iter_Name));
end if;
if not Of_Present (N) then
Check_Reverse_Iteration (Etype (Iter_Name));
end if;
end if;
-- Get base type of container, for proper retrieval of Cursor type
-- and primitive operations.
Typ := Base_Type (Etype (Iter_Name));
if Is_Array_Type (Typ) then
if Of_Present (N) then
Set_Etype (Def_Id, Component_Type (Typ));
-- The loop variable is aliased if the array components are
-- aliased.
Set_Is_Aliased (Def_Id, Has_Aliased_Components (Typ));
-- AI12-0047 stipulates that the domain (array or container)
-- cannot be a component that depends on a discriminant if the
-- enclosing object is mutable, to prevent a modification of the
-- dowmain of iteration in the course of an iteration.
-- If the object is an expression it has been captured in a
-- temporary, so examine original node.
if Nkind (Original_Node (Iter_Name)) = N_Selected_Component
and then Is_Dependent_Component_Of_Mutable_Object
(Original_Node (Iter_Name))
then
Error_Msg_N
("iterable name cannot be a discriminant-dependent "
& "component of a mutable object", N);
end if;
if Present (Subt)
and then
(Base_Type (Bas) /= Base_Type (Component_Type (Typ))
or else
not Subtypes_Statically_Match (Bas, Component_Type (Typ)))
then
Error_Msg_N
("subtype indication does not match component type", Subt);
end if;
-- Here we have a missing Range attribute
else
Error_Msg_N
("missing Range attribute in iteration over an array", N);
-- In Ada 2012 mode, this may be an attempt at an iterator
if Ada_Version >= Ada_2012 then
Error_Msg_NE
("\if& is meant to designate an element of the array, use OF",
N, Def_Id);
end if;
-- Prevent cascaded errors
Set_Ekind (Def_Id, E_Loop_Parameter);
Set_Etype (Def_Id, Etype (First_Index (Typ)));
end if;
-- Check for type error in iterator
elsif Typ = Any_Type then
return;
-- Iteration over a container
else
Set_Ekind (Def_Id, E_Loop_Parameter);
Error_Msg_Ada_2012_Feature ("container iterator", Sloc (N));
-- OF present
if Of_Present (N) then
if Has_Aspect (Typ, Aspect_Iterable) then
declare
Elt : constant Entity_Id :=
Get_Iterable_Type_Primitive (Typ, Name_Element);
begin
if No (Elt) then
Error_Msg_N
("missing Element primitive for iteration", N);
else
Set_Etype (Def_Id, Etype (Elt));
end if;
end;
-- For a predefined container, The type of the loop variable is
-- the Iterator_Element aspect of the container type.
else
declare
Element : constant Entity_Id :=
Find_Value_Of_Aspect
(Typ, Aspect_Iterator_Element);
Iterator : constant Entity_Id :=
Find_Value_Of_Aspect
(Typ, Aspect_Default_Iterator);
Orig_Iter_Name : constant Node_Id :=
Original_Node (Iter_Name);
Cursor_Type : Entity_Id;
begin
if No (Element) then
Error_Msg_NE ("cannot iterate over&", N, Typ);
return;
else
Set_Etype (Def_Id, Entity (Element));
Cursor_Type := Get_Cursor_Type (Typ);
pragma Assert (Present (Cursor_Type));
-- If subtype indication was given, verify that it covers
-- the element type of the container.
if Present (Subt)
and then (not Covers (Bas, Etype (Def_Id))
or else not Subtypes_Statically_Match
(Bas, Etype (Def_Id)))
then
Error_Msg_N
("subtype indication does not match element type",
Subt);
end if;
-- If the container has a variable indexing aspect, the
-- element is a variable and is modifiable in the loop.
if Has_Aspect (Typ, Aspect_Variable_Indexing) then
Set_Ekind (Def_Id, E_Variable);
end if;
-- If the container is a constant, iterating over it
-- requires a Constant_Indexing operation.
if not Is_Variable (Iter_Name)
and then not Has_Aspect (Typ, Aspect_Constant_Indexing)
then
Error_Msg_N
("iteration over constant container require "
& "constant_indexing aspect", N);
-- The Iterate function may have an in_out parameter,
-- and a constant container is thus illegal.
elsif Present (Iterator)
and then Ekind (Entity (Iterator)) = E_Function
and then Ekind (First_Formal (Entity (Iterator))) /=
E_In_Parameter
and then not Is_Variable (Iter_Name)
then
Error_Msg_N ("variable container expected", N);
end if;
-- Detect a case where the iterator denotes a component
-- of a mutable object which depends on a discriminant.
-- Note that the iterator may denote a function call in
-- qualified form, in which case this check should not
-- be performed.
if Nkind (Orig_Iter_Name) = N_Selected_Component
and then
Present (Entity (Selector_Name (Orig_Iter_Name)))
and then Ekind_In
(Entity (Selector_Name (Orig_Iter_Name)),
E_Component,
E_Discriminant)
and then Is_Dependent_Component_Of_Mutable_Object
(Orig_Iter_Name)
then
Error_Msg_N
("container cannot be a discriminant-dependent "
& "component of a mutable object", N);
end if;
end if;
end;
end if;
-- IN iterator, domain is a range, or a call to Iterate function
else
-- For an iteration of the form IN, the name must denote an
-- iterator, typically the result of a call to Iterate. Give a
-- useful error message when the name is a container by itself.
-- The type may be a formal container type, which has to have
-- an Iterable aspect detailing the required primitives.
if Is_Entity_Name (Original_Node (Name (N)))
and then not Is_Iterator (Typ)
then
if Has_Aspect (Typ, Aspect_Iterable) then
null;
elsif not Has_Aspect (Typ, Aspect_Iterator_Element) then
Error_Msg_NE
("cannot iterate over&", Name (N), Typ);
else
Error_Msg_N
("name must be an iterator, not a container", Name (N));
end if;
if Has_Aspect (Typ, Aspect_Iterable) then
null;
else
Error_Msg_NE
("\to iterate directly over the elements of a container, "
& "write `of &`", Name (N), Original_Node (Name (N)));
-- No point in continuing analysis of iterator spec
return;
end if;
end if;
-- If the name is a call (typically prefixed) to some Iterate
-- function, it has been rewritten as an object declaration.
-- If that object is a selected component, verify that it is not
-- a component of an unconstrained mutable object.
if Nkind (Iter_Name) = N_Identifier
or else (not Expander_Active and Comes_From_Source (Iter_Name))
then
declare
Orig_Node : constant Node_Id := Original_Node (Iter_Name);
Iter_Kind : constant Node_Kind := Nkind (Orig_Node);
Obj : Node_Id;
begin
if Iter_Kind = N_Selected_Component then
Obj := Prefix (Orig_Node);
elsif Iter_Kind = N_Function_Call then
Obj := First_Actual (Orig_Node);
-- If neither, the name comes from source
else
Obj := Iter_Name;
end if;
if Nkind (Obj) = N_Selected_Component
and then Is_Dependent_Component_Of_Mutable_Object (Obj)
then
Error_Msg_N
("container cannot be a discriminant-dependent "
& "component of a mutable object", N);
end if;
end;
end if;
-- The result type of Iterate function is the classwide type of
-- the interface parent. We need the specific Cursor type defined
-- in the container package. We obtain it by name for a predefined
-- container, or through the Iterable aspect for a formal one.
if Has_Aspect (Typ, Aspect_Iterable) then
Set_Etype (Def_Id,
Get_Cursor_Type
(Parent (Find_Value_Of_Aspect (Typ, Aspect_Iterable)),
Typ));
else
Set_Etype (Def_Id, Get_Cursor_Type (Typ));
Check_Reverse_Iteration (Etype (Iter_Name));
end if;
end if;
end if;
end Analyze_Iterator_Specification;
-------------------
-- Analyze_Label --
-------------------
-- Note: the semantic work required for analyzing labels (setting them as
-- reachable) was done in a prepass through the statements in the block,
-- so that forward gotos would be properly handled. See Analyze_Statements
-- for further details. The only processing required here is to deal with
-- optimizations that depend on an assumption of sequential control flow,
-- since of course the occurrence of a label breaks this assumption.
procedure Analyze_Label (N : Node_Id) is
pragma Warnings (Off, N);
begin
Kill_Current_Values;
end Analyze_Label;
--------------------------
-- Analyze_Label_Entity --
--------------------------
procedure Analyze_Label_Entity (E : Entity_Id) is
begin
Set_Ekind (E, E_Label);
Set_Etype (E, Standard_Void_Type);
Set_Enclosing_Scope (E, Current_Scope);
Set_Reachable (E, True);
end Analyze_Label_Entity;
------------------------------------------
-- Analyze_Loop_Parameter_Specification --
------------------------------------------
procedure Analyze_Loop_Parameter_Specification (N : Node_Id) is
Loop_Nod : constant Node_Id := Parent (Parent (N));
procedure Check_Controlled_Array_Attribute (DS : Node_Id);
-- If the bounds are given by a 'Range reference on a function call
-- that returns a controlled array, introduce an explicit declaration
-- to capture the bounds, so that the function result can be finalized
-- in timely fashion.
procedure Check_Predicate_Use (T : Entity_Id);
-- Diagnose Attempt to iterate through non-static predicate. Note that
-- a type with inherited predicates may have both static and dynamic
-- forms. In this case it is not sufficent to check the static predicate
-- function only, look for a dynamic predicate aspect as well.
function Has_Call_Using_Secondary_Stack (N : Node_Id) return Boolean;
-- N is the node for an arbitrary construct. This function searches the
-- construct N to see if any expressions within it contain function
-- calls that use the secondary stack, returning True if any such call
-- is found, and False otherwise.
procedure Process_Bounds (R : Node_Id);
-- If the iteration is given by a range, create temporaries and
-- assignment statements block to capture the bounds and perform
-- required finalization actions in case a bound includes a function
-- call that uses the temporary stack. We first pre-analyze a copy of
-- the range in order to determine the expected type, and analyze and
-- resolve the original bounds.
--------------------------------------
-- Check_Controlled_Array_Attribute --
--------------------------------------
procedure Check_Controlled_Array_Attribute (DS : Node_Id) is
begin
if Nkind (DS) = N_Attribute_Reference
and then Is_Entity_Name (Prefix (DS))
and then Ekind (Entity (Prefix (DS))) = E_Function
and then Is_Array_Type (Etype (Entity (Prefix (DS))))
and then
Is_Controlled (Component_Type (Etype (Entity (Prefix (DS)))))
and then Expander_Active
then
declare
Loc : constant Source_Ptr := Sloc (N);
Arr : constant Entity_Id := Etype (Entity (Prefix (DS)));
Indx : constant Entity_Id :=
Base_Type (Etype (First_Index (Arr)));
Subt : constant Entity_Id := Make_Temporary (Loc, 'S');
Decl : Node_Id;
begin
Decl :=
Make_Subtype_Declaration (Loc,
Defining_Identifier => Subt,
Subtype_Indication =>
Make_Subtype_Indication (Loc,
Subtype_Mark => New_Occurrence_Of (Indx, Loc),
Constraint =>
Make_Range_Constraint (Loc, Relocate_Node (DS))));
Insert_Before (Loop_Nod, Decl);
Analyze (Decl);
Rewrite (DS,
Make_Attribute_Reference (Loc,
Prefix => New_Occurrence_Of (Subt, Loc),
Attribute_Name => Attribute_Name (DS)));
Analyze (DS);
end;
end if;
end Check_Controlled_Array_Attribute;
-------------------------
-- Check_Predicate_Use --
-------------------------
procedure Check_Predicate_Use (T : Entity_Id) is
begin
-- A predicated subtype is illegal in loops and related constructs
-- if the predicate is not static, or if it is a non-static subtype
-- of a statically predicated subtype.
if Is_Discrete_Type (T)
and then Has_Predicates (T)
and then (not Has_Static_Predicate (T)
or else not Is_Static_Subtype (T)
or else Has_Dynamic_Predicate_Aspect (T))
then
-- Seems a confusing message for the case of a static predicate
-- with a non-static subtype???
Bad_Predicated_Subtype_Use
("cannot use subtype& with non-static predicate for loop "
& "iteration", Discrete_Subtype_Definition (N),
T, Suggest_Static => True);
elsif Inside_A_Generic and then Is_Generic_Formal (T) then
Set_No_Dynamic_Predicate_On_Actual (T);
end if;
end Check_Predicate_Use;
------------------------------------
-- Has_Call_Using_Secondary_Stack --
------------------------------------
function Has_Call_Using_Secondary_Stack (N : Node_Id) return Boolean is
function Check_Call (N : Node_Id) return Traverse_Result;
-- Check if N is a function call which uses the secondary stack
----------------
-- Check_Call --
----------------
function Check_Call (N : Node_Id) return Traverse_Result is
Nam : Node_Id;
Subp : Entity_Id;
Return_Typ : Entity_Id;
begin
if Nkind (N) = N_Function_Call then
Nam := Name (N);
-- Call using access to subprogram with explicit dereference
if Nkind (Nam) = N_Explicit_Dereference then
Subp := Etype (Nam);
-- Call using a selected component notation or Ada 2005 object
-- operation notation
elsif Nkind (Nam) = N_Selected_Component then
Subp := Entity (Selector_Name (Nam));
-- Common case
else
Subp := Entity (Nam);
end if;
Return_Typ := Etype (Subp);
if Is_Composite_Type (Return_Typ)
and then not Is_Constrained (Return_Typ)
then
return Abandon;
elsif Sec_Stack_Needed_For_Return (Subp) then
return Abandon;
end if;
end if;
-- Continue traversing the tree
return OK;
end Check_Call;
function Check_Calls is new Traverse_Func (Check_Call);
-- Start of processing for Has_Call_Using_Secondary_Stack
begin
return Check_Calls (N) = Abandon;
end Has_Call_Using_Secondary_Stack;
--------------------
-- Process_Bounds --
--------------------
procedure Process_Bounds (R : Node_Id) is
Loc : constant Source_Ptr := Sloc (N);
function One_Bound
(Original_Bound : Node_Id;
Analyzed_Bound : Node_Id;
Typ : Entity_Id) return Node_Id;
-- Capture value of bound and return captured value
---------------
-- One_Bound --
---------------
function One_Bound
(Original_Bound : Node_Id;
Analyzed_Bound : Node_Id;
Typ : Entity_Id) return Node_Id
is
Assign : Node_Id;
Decl : Node_Id;
Id : Entity_Id;
begin
-- If the bound is a constant or an object, no need for a separate
-- declaration. If the bound is the result of previous expansion
-- it is already analyzed and should not be modified. Note that
-- the Bound will be resolved later, if needed, as part of the
-- call to Make_Index (literal bounds may need to be resolved to
-- type Integer).
if Analyzed (Original_Bound) then
return Original_Bound;
elsif Nkind_In (Analyzed_Bound, N_Integer_Literal,
N_Character_Literal)
or else Is_Entity_Name (Analyzed_Bound)
then
Analyze_And_Resolve (Original_Bound, Typ);
return Original_Bound;
end if;
-- Normally, the best approach is simply to generate a constant
-- declaration that captures the bound. However, there is a nasty
-- case where this is wrong. If the bound is complex, and has a
-- possible use of the secondary stack, we need to generate a
-- separate assignment statement to ensure the creation of a block
-- which will release the secondary stack.
-- We prefer the constant declaration, since it leaves us with a
-- proper trace of the value, useful in optimizations that get rid
-- of junk range checks.
if not Has_Call_Using_Secondary_Stack (Analyzed_Bound) then
Analyze_And_Resolve (Original_Bound, Typ);
-- Ensure that the bound is valid. This check should not be
-- generated when the range belongs to a quantified expression
-- as the construct is still not expanded into its final form.
if Nkind (Parent (R)) /= N_Loop_Parameter_Specification
or else Nkind (Parent (Parent (R))) /= N_Quantified_Expression
then
Ensure_Valid (Original_Bound);
end if;
Force_Evaluation (Original_Bound);
return Original_Bound;
end if;
Id := Make_Temporary (Loc, 'R', Original_Bound);
-- Here we make a declaration with a separate assignment
-- statement, and insert before loop header.
Decl :=
Make_Object_Declaration (Loc,
Defining_Identifier => Id,
Object_Definition => New_Occurrence_Of (Typ, Loc));
Assign :=
Make_Assignment_Statement (Loc,
Name => New_Occurrence_Of (Id, Loc),
Expression => Relocate_Node (Original_Bound));
Insert_Actions (Loop_Nod, New_List (Decl, Assign));
-- Now that this temporary variable is initialized we decorate it
-- as safe-to-reevaluate to inform to the backend that no further
-- asignment will be issued and hence it can be handled as side
-- effect free. Note that this decoration must be done when the
-- assignment has been analyzed because otherwise it will be
-- rejected (see Analyze_Assignment).
Set_Is_Safe_To_Reevaluate (Id);
Rewrite (Original_Bound, New_Occurrence_Of (Id, Loc));
if Nkind (Assign) = N_Assignment_Statement then
return Expression (Assign);
else
return Original_Bound;
end if;
end One_Bound;
Hi : constant Node_Id := High_Bound (R);
Lo : constant Node_Id := Low_Bound (R);
R_Copy : constant Node_Id := New_Copy_Tree (R);
New_Hi : Node_Id;
New_Lo : Node_Id;
Typ : Entity_Id;
-- Start of processing for Process_Bounds
begin
Set_Parent (R_Copy, Parent (R));
Preanalyze_Range (R_Copy);
Typ := Etype (R_Copy);
-- If the type of the discrete range is Universal_Integer, then the
-- bound's type must be resolved to Integer, and any object used to
-- hold the bound must also have type Integer, unless the literal
-- bounds are constant-folded expressions with a user-defined type.
if Typ = Universal_Integer then
if Nkind (Lo) = N_Integer_Literal
and then Present (Etype (Lo))
and then Scope (Etype (Lo)) /= Standard_Standard
then
Typ := Etype (Lo);
elsif Nkind (Hi) = N_Integer_Literal
and then Present (Etype (Hi))
and then Scope (Etype (Hi)) /= Standard_Standard
then
Typ := Etype (Hi);
else
Typ := Standard_Integer;
end if;
end if;
Set_Etype (R, Typ);
New_Lo := One_Bound (Lo, Low_Bound (R_Copy), Typ);
New_Hi := One_Bound (Hi, High_Bound (R_Copy), Typ);
-- Propagate staticness to loop range itself, in case the
-- corresponding subtype is static.
if New_Lo /= Lo and then Is_OK_Static_Expression (New_Lo) then
Rewrite (Low_Bound (R), New_Copy (New_Lo));
end if;
if New_Hi /= Hi and then Is_OK_Static_Expression (New_Hi) then
Rewrite (High_Bound (R), New_Copy (New_Hi));
end if;
end Process_Bounds;
-- Local variables
DS : constant Node_Id := Discrete_Subtype_Definition (N);
Id : constant Entity_Id := Defining_Identifier (N);
DS_Copy : Node_Id;
-- Start of processing for Analyze_Loop_Parameter_Specification
begin
Enter_Name (Id);
-- We always consider the loop variable to be referenced, since the loop
-- may be used just for counting purposes.
Generate_Reference (Id, N, ' ');
-- Check for the case of loop variable hiding a local variable (used
-- later on to give a nice warning if the hidden variable is never
-- assigned).
declare
H : constant Entity_Id := Homonym (Id);
begin
if Present (H)
and then Ekind (H) = E_Variable
and then Is_Discrete_Type (Etype (H))
and then Enclosing_Dynamic_Scope (H) = Enclosing_Dynamic_Scope (Id)
then
Set_Hiding_Loop_Variable (H, Id);
end if;
end;
-- Loop parameter specification must include subtype mark in SPARK
if Nkind (DS) = N_Range then
Check_SPARK_05_Restriction
("loop parameter specification must include subtype mark", N);
end if;
-- Analyze the subtype definition and create temporaries for the bounds.
-- Do not evaluate the range when preanalyzing a quantified expression
-- because bounds expressed as function calls with side effects will be
-- incorrectly replicated.
if Nkind (DS) = N_Range
and then Expander_Active
and then Nkind (Parent (N)) /= N_Quantified_Expression
then
Process_Bounds (DS);
-- Either the expander not active or the range of iteration is a subtype
-- indication, an entity, or a function call that yields an aggregate or
-- a container.
else
DS_Copy := New_Copy_Tree (DS);
Set_Parent (DS_Copy, Parent (DS));
Preanalyze_Range (DS_Copy);
-- Ada 2012: If the domain of iteration is:
-- a) a function call,
-- b) an identifier that is not a type,
-- c) an attribute reference 'Old (within a postcondition),
-- d) an unchecked conversion or a qualified expression with
-- the proper iterator type.
-- then it is an iteration over a container. It was classified as
-- a loop specification by the parser, and must be rewritten now
-- to activate container iteration. The last case will occur within
-- an expanded inlined call, where the expansion wraps an actual in
-- an unchecked conversion when needed. The expression of the
-- conversion is always an object.
if Nkind (DS_Copy) = N_Function_Call
or else (Is_Entity_Name (DS_Copy)
and then not Is_Type (Entity (DS_Copy)))
or else (Nkind (DS_Copy) = N_Attribute_Reference
and then Nam_In (Attribute_Name (DS_Copy),
Name_Loop_Entry, Name_Old))
or else Has_Aspect (Etype (DS_Copy), Aspect_Iterable)
or else Nkind (DS_Copy) = N_Unchecked_Type_Conversion
or else (Nkind (DS_Copy) = N_Qualified_Expression
and then Is_Iterator (Etype (DS_Copy)))
then
-- This is an iterator specification. Rewrite it as such and
-- analyze it to capture function calls that may require
-- finalization actions.
declare
I_Spec : constant Node_Id :=
Make_Iterator_Specification (Sloc (N),
Defining_Identifier => Relocate_Node (Id),
Name => DS_Copy,
Subtype_Indication => Empty,
Reverse_Present => Reverse_Present (N));
Scheme : constant Node_Id := Parent (N);
begin
Set_Iterator_Specification (Scheme, I_Spec);
Set_Loop_Parameter_Specification (Scheme, Empty);
Analyze_Iterator_Specification (I_Spec);
-- In a generic context, analyze the original domain of
-- iteration, for name capture.
if not Expander_Active then
Analyze (DS);
end if;
-- Set kind of loop parameter, which may be used in the
-- subsequent analysis of the condition in a quantified
-- expression.
Set_Ekind (Id, E_Loop_Parameter);
return;
end;
-- Domain of iteration is not a function call, and is side-effect
-- free.
else
-- A quantified expression that appears in a pre/post condition
-- is pre-analyzed several times. If the range is given by an
-- attribute reference it is rewritten as a range, and this is
-- done even with expansion disabled. If the type is already set
-- do not reanalyze, because a range with static bounds may be
-- typed Integer by default.
if Nkind (Parent (N)) = N_Quantified_Expression
and then Present (Etype (DS))
then
null;
else
Analyze (DS);
end if;
end if;
end if;
if DS = Error then
return;
end if;
-- Some additional checks if we are iterating through a type
if Is_Entity_Name (DS)
and then Present (Entity (DS))
and then Is_Type (Entity (DS))
then
-- The subtype indication may denote the completion of an incomplete
-- type declaration.
if Ekind (Entity (DS)) = E_Incomplete_Type then
Set_Entity (DS, Get_Full_View (Entity (DS)));
Set_Etype (DS, Entity (DS));
end if;
Check_Predicate_Use (Entity (DS));
end if;
-- Error if not discrete type
if not Is_Discrete_Type (Etype (DS)) then
Wrong_Type (DS, Any_Discrete);
Set_Etype (DS, Any_Type);
end if;
Check_Controlled_Array_Attribute (DS);
if Nkind (DS) = N_Subtype_Indication then
Check_Predicate_Use (Entity (Subtype_Mark (DS)));
end if;
Make_Index (DS, N, In_Iter_Schm => True);
Set_Ekind (Id, E_Loop_Parameter);
-- A quantified expression which appears in a pre- or post-condition may
-- be analyzed multiple times. The analysis of the range creates several
-- itypes which reside in different scopes depending on whether the pre-
-- or post-condition has been expanded. Update the type of the loop
-- variable to reflect the proper itype at each stage of analysis.
if No (Etype (Id))
or else Etype (Id) = Any_Type
or else
(Present (Etype (Id))
and then Is_Itype (Etype (Id))
and then Nkind (Parent (Loop_Nod)) = N_Expression_With_Actions
and then Nkind (Original_Node (Parent (Loop_Nod))) =
N_Quantified_Expression)
then
Set_Etype (Id, Etype (DS));
end if;
-- Treat a range as an implicit reference to the type, to inhibit
-- spurious warnings.
Generate_Reference (Base_Type (Etype (DS)), N, ' ');
Set_Is_Known_Valid (Id, True);
-- The loop is not a declarative part, so the loop variable must be
-- frozen explicitly. Do not freeze while preanalyzing a quantified
-- expression because the freeze node will not be inserted into the
-- tree due to flag Is_Spec_Expression being set.
if Nkind (Parent (N)) /= N_Quantified_Expression then
declare
Flist : constant List_Id := Freeze_Entity (Id, N);
begin
if Is_Non_Empty_List (Flist) then
Insert_Actions (N, Flist);
end if;
end;
end if;
-- Case where we have a range or a subtype, get type bounds
if Nkind_In (DS, N_Range, N_Subtype_Indication)
and then not Error_Posted (DS)
and then Etype (DS) /= Any_Type
and then Is_Discrete_Type (Etype (DS))
then
declare
L : Node_Id;
H : Node_Id;
begin
if Nkind (DS) = N_Range then
L := Low_Bound (DS);
H := High_Bound (DS);
else
L :=
Type_Low_Bound (Underlying_Type (Etype (Subtype_Mark (DS))));
H :=
Type_High_Bound (Underlying_Type (Etype (Subtype_Mark (DS))));
end if;
-- Check for null or possibly null range and issue warning. We
-- suppress such messages in generic templates and instances,
-- because in practice they tend to be dubious in these cases. The
-- check applies as well to rewritten array element loops where a
-- null range may be detected statically.
if Compile_Time_Compare (L, H, Assume_Valid => True) = GT then
-- Suppress the warning if inside a generic template or
-- instance, since in practice they tend to be dubious in these
-- cases since they can result from intended parameterization.
if not Inside_A_Generic and then not In_Instance then
-- Specialize msg if invalid values could make the loop
-- non-null after all.
if Compile_Time_Compare
(L, H, Assume_Valid => False) = GT
then
-- Since we know the range of the loop is null, set the
-- appropriate flag to remove the loop entirely during
-- expansion.
Set_Is_Null_Loop (Loop_Nod);
if Comes_From_Source (N) then
Error_Msg_N
("??loop range is null, loop will not execute", DS);
end if;
-- Here is where the loop could execute because of
-- invalid values, so issue appropriate message and in
-- this case we do not set the Is_Null_Loop flag since
-- the loop may execute.
elsif Comes_From_Source (N) then
Error_Msg_N
("??loop range may be null, loop may not execute",
DS);
Error_Msg_N
("??can only execute if invalid values are present",
DS);
end if;
end if;
-- In either case, suppress warnings in the body of the loop,
-- since it is likely that these warnings will be inappropriate
-- if the loop never actually executes, which is likely.
Set_Suppress_Loop_Warnings (Loop_Nod);
-- The other case for a warning is a reverse loop where the
-- upper bound is the integer literal zero or one, and the
-- lower bound may exceed this value.
-- For example, we have
-- for J in reverse N .. 1 loop
-- In practice, this is very likely to be a case of reversing
-- the bounds incorrectly in the range.
elsif Reverse_Present (N)
and then Nkind (Original_Node (H)) = N_Integer_Literal
and then
(Intval (Original_Node (H)) = Uint_0
or else
Intval (Original_Node (H)) = Uint_1)
then
-- Lower bound may in fact be known and known not to exceed
-- upper bound (e.g. reverse 0 .. 1) and that's OK.
if Compile_Time_Known_Value (L)
and then Expr_Value (L) <= Expr_Value (H)
then
null;
-- Otherwise warning is warranted
else
Error_Msg_N ("??loop range may be null", DS);
Error_Msg_N ("\??bounds may be wrong way round", DS);
end if;
end if;
-- Check if either bound is known to be outside the range of the
-- loop parameter type, this is e.g. the case of a loop from
-- 20..X where the type is 1..19.
-- Such a loop is dubious since either it raises CE or it executes
-- zero times, and that cannot be useful!
if Etype (DS) /= Any_Type
and then not Error_Posted (DS)
and then Nkind (DS) = N_Subtype_Indication
and then Nkind (Constraint (DS)) = N_Range_Constraint
then
declare
LLo : constant Node_Id :=
Low_Bound (Range_Expression (Constraint (DS)));
LHi : constant Node_Id :=
High_Bound (Range_Expression (Constraint (DS)));
Bad_Bound : Node_Id := Empty;
-- Suspicious loop bound
begin
-- At this stage L, H are the bounds of the type, and LLo
-- Lhi are the low bound and high bound of the loop.
if Compile_Time_Compare (LLo, L, Assume_Valid => True) = LT
or else
Compile_Time_Compare (LLo, H, Assume_Valid => True) = GT
then
Bad_Bound := LLo;
end if;
if Compile_Time_Compare (LHi, L, Assume_Valid => True) = LT
or else
Compile_Time_Compare (LHi, H, Assume_Valid => True) = GT
then
Bad_Bound := LHi;
end if;
if Present (Bad_Bound) then
Error_Msg_N
("suspicious loop bound out of range of "
& "loop subtype??", Bad_Bound);
Error_Msg_N
("\loop executes zero times or raises "
& "Constraint_Error??", Bad_Bound);
end if;
end;
end if;
-- This declare block is about warnings, if we get an exception while
-- testing for warnings, we simply abandon the attempt silently. This
-- most likely occurs as the result of a previous error, but might
-- just be an obscure case we have missed. In either case, not giving
-- the warning is perfectly acceptable.
exception
when others => null;
end;
end if;
-- A loop parameter cannot be effectively volatile (SPARK RM 7.1.3(4)).
-- This check is relevant only when SPARK_Mode is on as it is not a
-- standard Ada legality check.
if SPARK_Mode = On and then Is_Effectively_Volatile (Id) then
Error_Msg_N ("loop parameter cannot be volatile", Id);
end if;
end Analyze_Loop_Parameter_Specification;
----------------------------
-- Analyze_Loop_Statement --
----------------------------
procedure Analyze_Loop_Statement (N : Node_Id) is
function Is_Container_Iterator (Iter : Node_Id) return Boolean;
-- Given a loop iteration scheme, determine whether it is an Ada 2012
-- container iteration.
function Is_Wrapped_In_Block (N : Node_Id) return Boolean;
-- Determine whether loop statement N has been wrapped in a block to
-- capture finalization actions that may be generated for container
-- iterators. Prevents infinite recursion when block is analyzed.
-- Routine is a noop if loop is single statement within source block.
---------------------------
-- Is_Container_Iterator --
---------------------------
function Is_Container_Iterator (Iter : Node_Id) return Boolean is
begin
-- Infinite loop
if No (Iter) then
return False;
-- While loop
elsif Present (Condition (Iter)) then
return False;
-- for Def_Id in [reverse] Name loop
-- for Def_Id [: Subtype_Indication] of [reverse] Name loop
elsif Present (Iterator_Specification (Iter)) then
declare
Nam : constant Node_Id := Name (Iterator_Specification (Iter));
Nam_Copy : Node_Id;
begin
Nam_Copy := New_Copy_Tree (Nam);
Set_Parent (Nam_Copy, Parent (Nam));
Preanalyze_Range (Nam_Copy);
-- The only two options here are iteration over a container or
-- an array.
return not Is_Array_Type (Etype (Nam_Copy));
end;
-- for Def_Id in [reverse] Discrete_Subtype_Definition loop
else
declare
LP : constant Node_Id := Loop_Parameter_Specification (Iter);
DS : constant Node_Id := Discrete_Subtype_Definition (LP);
DS_Copy : Node_Id;
begin
DS_Copy := New_Copy_Tree (DS);
Set_Parent (DS_Copy, Parent (DS));
Preanalyze_Range (DS_Copy);
-- Check for a call to Iterate () or an expression with
-- an iterator type.
return
(Nkind (DS_Copy) = N_Function_Call
and then Needs_Finalization (Etype (DS_Copy)))
or else Is_Iterator (Etype (DS_Copy));
end;
end if;
end Is_Container_Iterator;
-------------------------
-- Is_Wrapped_In_Block --
-------------------------
function Is_Wrapped_In_Block (N : Node_Id) return Boolean is
HSS : Node_Id;
Stat : Node_Id;
begin
-- Check if current scope is a block that is not a transient block.
if Ekind (Current_Scope) /= E_Block
or else No (Block_Node (Current_Scope))
then
return False;
else
HSS :=
Handled_Statement_Sequence (Parent (Block_Node (Current_Scope)));
-- Skip leading pragmas that may be introduced for invariant and
-- predicate checks.
Stat := First (Statements (HSS));
while Present (Stat) and then Nkind (Stat) = N_Pragma loop
Stat := Next (Stat);
end loop;
return Stat = N and then No (Next (Stat));
end if;
end Is_Wrapped_In_Block;
-- Local declarations
Id : constant Node_Id := Identifier (N);
Iter : constant Node_Id := Iteration_Scheme (N);
Loc : constant Source_Ptr := Sloc (N);
Ent : Entity_Id;
Stmt : Node_Id;
-- Start of processing for Analyze_Loop_Statement
begin
if Present (Id) then
-- Make name visible, e.g. for use in exit statements. Loop labels
-- are always considered to be referenced.
Analyze (Id);
Ent := Entity (Id);
-- Guard against serious error (typically, a scope mismatch when
-- semantic analysis is requested) by creating loop entity to
-- continue analysis.
if No (Ent) then
if Total_Errors_Detected /= 0 then
Ent := New_Internal_Entity (E_Loop, Current_Scope, Loc, 'L');
else
raise Program_Error;
end if;
-- Verify that the loop name is hot hidden by an unrelated
-- declaration in an inner scope.
elsif Ekind (Ent) /= E_Label and then Ekind (Ent) /= E_Loop then
Error_Msg_Sloc := Sloc (Ent);
Error_Msg_N ("implicit label declaration for & is hidden#", Id);
if Present (Homonym (Ent))
and then Ekind (Homonym (Ent)) = E_Label
then
Set_Entity (Id, Ent);
Set_Ekind (Ent, E_Loop);
end if;
else
Generate_Reference (Ent, N, ' ');
Generate_Definition (Ent);
-- If we found a label, mark its type. If not, ignore it, since it
-- means we have a conflicting declaration, which would already
-- have been diagnosed at declaration time. Set Label_Construct
-- of the implicit label declaration, which is not created by the
-- parser for generic units.
if Ekind (Ent) = E_Label then
Set_Ekind (Ent, E_Loop);
if Nkind (Parent (Ent)) = N_Implicit_Label_Declaration then
Set_Label_Construct (Parent (Ent), N);
end if;
end if;
end if;
-- Case of no identifier present. Create one and attach it to the
-- loop statement for use as a scope and as a reference for later
-- expansions. Indicate that the label does not come from source,
-- and attach it to the loop statement so it is part of the tree,
-- even without a full declaration.
else
Ent := New_Internal_Entity (E_Loop, Current_Scope, Loc, 'L');
Set_Etype (Ent, Standard_Void_Type);
Set_Identifier (N, New_Occurrence_Of (Ent, Loc));
Set_Parent (Ent, N);
Set_Has_Created_Identifier (N);
end if;
-- If the iterator specification has a syntactic error, transform
-- construct into an infinite loop to prevent a crash and perform
-- some analysis.
if Present (Iter)
and then Present (Iterator_Specification (Iter))
and then Error_Posted (Iterator_Specification (Iter))
then
Set_Iteration_Scheme (N, Empty);
Analyze (N);
return;
end if;
-- Iteration over a container in Ada 2012 involves the creation of a
-- controlled iterator object. Wrap the loop in a block to ensure the
-- timely finalization of the iterator and release of container locks.
-- The same applies to the use of secondary stack when obtaining an
-- iterator.
if Ada_Version >= Ada_2012
and then Is_Container_Iterator (Iter)
and then not Is_Wrapped_In_Block (N)
then
declare
Block_Nod : Node_Id;
Block_Id : Entity_Id;
begin
Block_Nod :=
Make_Block_Statement (Loc,
Declarations => New_List,
Handled_Statement_Sequence =>
Make_Handled_Sequence_Of_Statements (Loc,
Statements => New_List (Relocate_Node (N))));
Add_Block_Identifier (Block_Nod, Block_Id);
-- The expansion of iterator loops generates an iterator in order
-- to traverse the elements of a container:
-- Iter : <iterator type> := Iterate (Container)'reference;
-- The iterator is controlled and returned on the secondary stack.
-- The analysis of the call to Iterate establishes a transient
-- scope to deal with the secondary stack management, but never
-- really creates a physical block as this would kill the iterator
-- too early (see Wrap_Transient_Declaration). To address this
-- case, mark the generated block as needing secondary stack
-- management.
Set_Uses_Sec_Stack (Block_Id);
Rewrite (N, Block_Nod);
Analyze (N);
return;
end;
end if;
-- Kill current values on entry to loop, since statements in the body of
-- the loop may have been executed before the loop is entered. Similarly
-- we kill values after the loop, since we do not know that the body of
-- the loop was executed.
Kill_Current_Values;
Push_Scope (Ent);
Analyze_Iteration_Scheme (Iter);
-- Check for following case which merits a warning if the type E of is
-- a multi-dimensional array (and no explicit subscript ranges present).
-- for J in E'Range
-- for K in E'Range
if Present (Iter)
and then Present (Loop_Parameter_Specification (Iter))
then
declare
LPS : constant Node_Id := Loop_Parameter_Specification (Iter);
DSD : constant Node_Id :=
Original_Node (Discrete_Subtype_Definition (LPS));
begin
if Nkind (DSD) = N_Attribute_Reference
and then Attribute_Name (DSD) = Name_Range
and then No (Expressions (DSD))
then
declare
Typ : constant Entity_Id := Etype (Prefix (DSD));
begin
if Is_Array_Type (Typ)
and then Number_Dimensions (Typ) > 1
and then Nkind (Parent (N)) = N_Loop_Statement
and then Present (Iteration_Scheme (Parent (N)))
then
declare
OIter : constant Node_Id :=
Iteration_Scheme (Parent (N));
OLPS : constant Node_Id :=
Loop_Parameter_Specification (OIter);
ODSD : constant Node_Id :=
Original_Node (Discrete_Subtype_Definition (OLPS));
begin
if Nkind (ODSD) = N_Attribute_Reference
and then Attribute_Name (ODSD) = Name_Range
and then No (Expressions (ODSD))
and then Etype (Prefix (ODSD)) = Typ
then
Error_Msg_Sloc := Sloc (ODSD);
Error_Msg_N
("inner range same as outer range#??", DSD);
end if;
end;
end if;
end;
end if;
end;
end if;
-- Analyze the statements of the body except in the case of an Ada 2012
-- iterator with the expander active. In this case the expander will do
-- a rewrite of the loop into a while loop. We will then analyze the
-- loop body when we analyze this while loop.
-- We need to do this delay because if the container is for indefinite
-- types the actual subtype of the components will only be determined
-- when the cursor declaration is analyzed.
-- If the expander is not active then we want to analyze the loop body
-- now even in the Ada 2012 iterator case, since the rewriting will not
-- be done. Insert the loop variable in the current scope, if not done
-- when analysing the iteration scheme. Set its kind properly to detect
-- improper uses in the loop body.
-- In GNATprove mode, we do one of the above depending on the kind of
-- loop. If it is an iterator over an array, then we do not analyze the
-- loop now. We will analyze it after it has been rewritten by the
-- special SPARK expansion which is activated in GNATprove mode. We need
-- to do this so that other expansions that should occur in GNATprove
-- mode take into account the specificities of the rewritten loop, in
-- particular the introduction of a renaming (which needs to be
-- expanded).
-- In other cases in GNATprove mode then we want to analyze the loop
-- body now, since no rewriting will occur. Within a generic the
-- GNATprove mode is irrelevant, we must analyze the generic for
-- non-local name capture.
if Present (Iter)
and then Present (Iterator_Specification (Iter))
then
if GNATprove_Mode
and then Is_Iterator_Over_Array (Iterator_Specification (Iter))
and then not Inside_A_Generic
then
null;
elsif not Expander_Active then
declare
I_Spec : constant Node_Id := Iterator_Specification (Iter);
Id : constant Entity_Id := Defining_Identifier (I_Spec);
begin
if Scope (Id) /= Current_Scope then
Enter_Name (Id);
end if;
-- In an element iterator, The loop parameter is a variable if
-- the domain of iteration (container or array) is a variable.
if not Of_Present (I_Spec)
or else not Is_Variable (Name (I_Spec))
then
Set_Ekind (Id, E_Loop_Parameter);
end if;
end;
Analyze_Statements (Statements (N));
end if;
else
-- Pre-Ada2012 for-loops and while loops.
Analyze_Statements (Statements (N));
end if;
-- When the iteration scheme of a loop contains attribute 'Loop_Entry,
-- the loop is transformed into a conditional block. Retrieve the loop.
Stmt := N;
if Subject_To_Loop_Entry_Attributes (Stmt) then
Stmt := Find_Loop_In_Conditional_Block (Stmt);
end if;
-- Finish up processing for the loop. We kill all current values, since
-- in general we don't know if the statements in the loop have been
-- executed. We could do a bit better than this with a loop that we
-- know will execute at least once, but it's not worth the trouble and
-- the front end is not in the business of flow tracing.
Process_End_Label (Stmt, 'e', Ent);
End_Scope;
Kill_Current_Values;
-- Check for infinite loop. Skip check for generated code, since it
-- justs waste time and makes debugging the routine called harder.
-- Note that we have to wait till the body of the loop is fully analyzed
-- before making this call, since Check_Infinite_Loop_Warning relies on
-- being able to use semantic visibility information to find references.
if Comes_From_Source (Stmt) then
Check_Infinite_Loop_Warning (Stmt);
end if;
-- Code after loop is unreachable if the loop has no WHILE or FOR and
-- contains no EXIT statements within the body of the loop.
if No (Iter) and then not Has_Exit (Ent) then
Check_Unreachable_Code (Stmt);
end if;
end Analyze_Loop_Statement;
----------------------------
-- Analyze_Null_Statement --
----------------------------
-- Note: the semantics of the null statement is implemented by a single
-- null statement, too bad everything isn't as simple as this.
procedure Analyze_Null_Statement (N : Node_Id) is
pragma Warnings (Off, N);
begin
null;
end Analyze_Null_Statement;
-------------------------
-- Analyze_Target_Name --
-------------------------
procedure Analyze_Target_Name (N : Node_Id) is
begin
if No (Current_LHS) then
Error_Msg_N ("target name can only appear within an assignment", N);
Set_Etype (N, Any_Type);
else
Set_Has_Target_Names (Parent (Current_LHS));
Set_Etype (N, Etype (Current_LHS));
-- Disable expansion for the rest of the analysis of the current
-- right-hand side. The enclosing assignment statement will be
-- rewritten during expansion, together with occurrences of the
-- target name.
if Expander_Active then
Expander_Mode_Save_And_Set (False);
end if;
end if;
end Analyze_Target_Name;
------------------------
-- Analyze_Statements --
------------------------
procedure Analyze_Statements (L : List_Id) is
S : Node_Id;
Lab : Entity_Id;
begin
-- The labels declared in the statement list are reachable from
-- statements in the list. We do this as a prepass so that any goto
-- statement will be properly flagged if its target is not reachable.
-- This is not required, but is nice behavior.
S := First (L);
while Present (S) loop
if Nkind (S) = N_Label then
Analyze (Identifier (S));
Lab := Entity (Identifier (S));
-- If we found a label mark it as reachable
if Ekind (Lab) = E_Label then
Generate_Definition (Lab);
Set_Reachable (Lab);
if Nkind (Parent (Lab)) = N_Implicit_Label_Declaration then
Set_Label_Construct (Parent (Lab), S);
end if;
-- If we failed to find a label, it means the implicit declaration
-- of the label was hidden. A for-loop parameter can do this to
-- a label with the same name inside the loop, since the implicit
-- label declaration is in the innermost enclosing body or block
-- statement.
else
Error_Msg_Sloc := Sloc (Lab);
Error_Msg_N
("implicit label declaration for & is hidden#",
Identifier (S));
end if;
end if;
Next (S);
end loop;
-- Perform semantic analysis on all statements
Conditional_Statements_Begin;
S := First (L);
while Present (S) loop
Analyze (S);
-- Remove dimension in all statements
Remove_Dimension_In_Statement (S);
Next (S);
end loop;
Conditional_Statements_End;
-- Make labels unreachable. Visibility is not sufficient, because labels
-- in one if-branch for example are not reachable from the other branch,
-- even though their declarations are in the enclosing declarative part.
S := First (L);
while Present (S) loop
if Nkind (S) = N_Label then
Set_Reachable (Entity (Identifier (S)), False);
end if;
Next (S);
end loop;
end Analyze_Statements;
----------------------------
-- Check_Unreachable_Code --
----------------------------
procedure Check_Unreachable_Code (N : Node_Id) is
Error_Node : Node_Id;
P : Node_Id;
begin
if Is_List_Member (N) and then Comes_From_Source (N) then
declare
Nxt : Node_Id;
begin
Nxt := Original_Node (Next (N));
-- Skip past pragmas
while Nkind (Nxt) = N_Pragma loop
Nxt := Original_Node (Next (Nxt));
end loop;
-- If a label follows us, then we never have dead code, since
-- someone could branch to the label, so we just ignore it, unless
-- we are in formal mode where goto statements are not allowed.
if Nkind (Nxt) = N_Label
and then not Restriction_Check_Required (SPARK_05)
then
return;
-- Otherwise see if we have a real statement following us
elsif Present (Nxt)
and then Comes_From_Source (Nxt)
and then Is_Statement (Nxt)
then
-- Special very annoying exception. If we have a return that
-- follows a raise, then we allow it without a warning, since
-- the Ada RM annoyingly requires a useless return here.
if Nkind (Original_Node (N)) /= N_Raise_Statement
or else Nkind (Nxt) /= N_Simple_Return_Statement
then
-- The rather strange shenanigans with the warning message
-- here reflects the fact that Kill_Dead_Code is very good
-- at removing warnings in deleted code, and this is one
-- warning we would prefer NOT to have removed.
Error_Node := Nxt;
-- If we have unreachable code, analyze and remove the
-- unreachable code, since it is useless and we don't
-- want to generate junk warnings.
-- We skip this step if we are not in code generation mode
-- or CodePeer mode.
-- This is the one case where we remove dead code in the
-- semantics as opposed to the expander, and we do not want
-- to remove code if we are not in code generation mode,
-- since this messes up the ASIS trees or loses useful
-- information in the CodePeer tree.
-- Note that one might react by moving the whole circuit to
-- exp_ch5, but then we lose the warning in -gnatc mode.
if Operating_Mode = Generate_Code
and then not CodePeer_Mode
then
loop
Nxt := Next (N);
-- Quit deleting when we have nothing more to delete
-- or if we hit a label (since someone could transfer
-- control to a label, so we should not delete it).
exit when No (Nxt) or else Nkind (Nxt) = N_Label;
-- Statement/declaration is to be deleted
Analyze (Nxt);
Remove (Nxt);
Kill_Dead_Code (Nxt);
end loop;
end if;
-- Now issue the warning (or error in formal mode)
if Restriction_Check_Required (SPARK_05) then
Check_SPARK_05_Restriction
("unreachable code is not allowed", Error_Node);
else
Error_Msg ("??unreachable code!", Sloc (Error_Node));
end if;
end if;
-- If the unconditional transfer of control instruction is the
-- last statement of a sequence, then see if our parent is one of
-- the constructs for which we count unblocked exits, and if so,
-- adjust the count.
else
P := Parent (N);
-- Statements in THEN part or ELSE part of IF statement
if Nkind (P) = N_If_Statement then
null;
-- Statements in ELSIF part of an IF statement
elsif Nkind (P) = N_Elsif_Part then
P := Parent (P);
pragma Assert (Nkind (P) = N_If_Statement);
-- Statements in CASE statement alternative
elsif Nkind (P) = N_Case_Statement_Alternative then
P := Parent (P);
pragma Assert (Nkind (P) = N_Case_Statement);
-- Statements in body of block
elsif Nkind (P) = N_Handled_Sequence_Of_Statements
and then Nkind (Parent (P)) = N_Block_Statement
then
-- The original loop is now placed inside a block statement
-- due to the expansion of attribute 'Loop_Entry. Return as
-- this is not a "real" block for the purposes of exit
-- counting.
if Nkind (N) = N_Loop_Statement
and then Subject_To_Loop_Entry_Attributes (N)
then
return;
end if;
-- Statements in exception handler in a block
elsif Nkind (P) = N_Exception_Handler
and then Nkind (Parent (P)) = N_Handled_Sequence_Of_Statements
and then Nkind (Parent (Parent (P))) = N_Block_Statement
then
null;
-- None of these cases, so return
else
return;
end if;
-- This was one of the cases we are looking for (i.e. the
-- parent construct was IF, CASE or block) so decrement count.
Unblocked_Exit_Count := Unblocked_Exit_Count - 1;
end if;
end;
end if;
end Check_Unreachable_Code;
----------------------
-- Preanalyze_Range --
----------------------
procedure Preanalyze_Range (R_Copy : Node_Id) is
Save_Analysis : constant Boolean := Full_Analysis;
Typ : Entity_Id;
begin
Full_Analysis := False;
Expander_Mode_Save_And_Set (False);
Analyze (R_Copy);
if Nkind (R_Copy) in N_Subexpr and then Is_Overloaded (R_Copy) then
-- Apply preference rules for range of predefined integer types, or
-- diagnose true ambiguity.
declare
I : Interp_Index;
It : Interp;
Found : Entity_Id := Empty;
begin
Get_First_Interp (R_Copy, I, It);
while Present (It.Typ) loop
if Is_Discrete_Type (It.Typ) then
if No (Found) then
Found := It.Typ;
else
if Scope (Found) = Standard_Standard then
null;
elsif Scope (It.Typ) = Standard_Standard then
Found := It.Typ;
else
-- Both of them are user-defined
Error_Msg_N
("ambiguous bounds in range of iteration", R_Copy);
Error_Msg_N ("\possible interpretations:", R_Copy);
Error_Msg_NE ("\\} ", R_Copy, Found);
Error_Msg_NE ("\\} ", R_Copy, It.Typ);
exit;
end if;
end if;
end if;
Get_Next_Interp (I, It);
end loop;
end;
end if;
-- Subtype mark in iteration scheme
if Is_Entity_Name (R_Copy) and then Is_Type (Entity (R_Copy)) then
null;
-- Expression in range, or Ada 2012 iterator
elsif Nkind (R_Copy) in N_Subexpr then
Resolve (R_Copy);
Typ := Etype (R_Copy);
if Is_Discrete_Type (Typ) then
null;
-- Check that the resulting object is an iterable container
elsif Has_Aspect (Typ, Aspect_Iterator_Element)
or else Has_Aspect (Typ, Aspect_Constant_Indexing)
or else Has_Aspect (Typ, Aspect_Variable_Indexing)
then
null;
-- The expression may yield an implicit reference to an iterable
-- container. Insert explicit dereference so that proper type is
-- visible in the loop.
elsif Has_Implicit_Dereference (Etype (R_Copy)) then
declare
Disc : Entity_Id;
begin
Disc := First_Discriminant (Typ);
while Present (Disc) loop
if Has_Implicit_Dereference (Disc) then
Build_Explicit_Dereference (R_Copy, Disc);
exit;
end if;
Next_Discriminant (Disc);
end loop;
end;
end if;
end if;
Expander_Mode_Restore;
Full_Analysis := Save_Analysis;
end Preanalyze_Range;
end Sem_Ch5;
|
uw1/eop-enqueueGridCoords.asm | JohnGlassmyer/UltimaHacks | 68 | 9134 | <reponame>JohnGlassmyer/UltimaHacks
%ifndef EXE_LENGTH
%include "../UltimaPatcher.asm"
%include "include/uw1.asm"
%include "include/uw1-eop.asm"
%endif
[bits 16]
startPatch EXE_LENGTH, \
expanded overlay procedure: enqueueGridCoords
startBlockAt addr_eop_enqueueGridCoords
push bp
mov bp, sp
; bp-based stack frame:
%assign arg_height 0x08
%assign arg_row 0x06
%assign arg_column 0x04
%assign ____callerIp 0x02
%assign ____callerBp 0x00
push si
push di
cmp byte [dseg_isDrawingBehindPlayer], 1
jz isDrawingBehindPlayer
isDrawingAheadOfPlayer:
push word [bp+arg_height]
push word [bp+arg_row]
push word [bp+arg_column]
callFromOverlay enqueueGridCoords
add sp, 6
jmp endProc
isDrawingBehindPlayer:
; call original proc with coords rotated 180 degrees
push word [bp+arg_height]
movsx ax, byte [bp+arg_row]
neg ax
inc ax
push ax
movsx ax, byte [bp+arg_column]
sub ax, 16
neg ax
inc ax
add ax, 16
push ax
callFromOverlay enqueueGridCoords
add sp, 6
jmp endProc
endProc:
; preserve return value of enqueueGridCoords in ax
pop di
pop si
mov sp, bp
pop bp
retn
endBlockAt off_eop_enqueueGridCoords_end
endPatch
|
gcc-gcc-7_3_0-release/gcc/testsuite/gnat.dg/vect13.ads | best08618/asylo | 7 | 4219 | package Vect13 is
-- Constrained array types are vectorizable
type Sarray is array (1 .. 4) of Float;
for Sarray'Alignment use 16;
function "+" (X, Y : Sarray) return Sarray;
procedure Add (X, Y : Sarray; R : out Sarray);
end Vect13;
|
src/led_control.adb | hgrodriguez/embedded-dashboard-console | 0 | 30893 | <reponame>hgrodriguez/embedded-dashboard-console
.-- Copyright 2021 (C) <NAME>
--
-- SPDX-License-Identifier: BSD-3-Clause
--
with RP.Device;
with RP.GPIO;
with ItsyBitsy;
package body LED_Control is
subtype LED_Type is RP.GPIO.GPIO_Point;
-----------------------------------------------------------------------
-- All Red LED related definitions
-----------------------------------------------------------------------
LED_0_Red : LED_Type renames ItsyBitsy.GP26;
procedure LED_0_Red_Off is
begin
LED_0_Red.Clear;
end LED_0_Red_Off;
procedure LED_0_Red_On is
begin
LED_0_Red.Set;
end LED_0_Red_On;
procedure LED_0_Red_Toggle is
begin
LED_0_Red.Toggle;
end LED_0_Red_Toggle;
-----------------------------------------------------------------------
-- All Amber LED related definitions
-----------------------------------------------------------------------
LED_0_Amber : LED_Type renames ItsyBitsy.GP27;
procedure LED_0_Amber_Off is
begin
LED_0_Amber.Clear;
end LED_0_Amber_Off;
procedure LED_0_Amber_On is
begin
LED_0_Amber.Set;
end LED_0_Amber_On;
procedure LED_0_Amber_Toggle is
begin
LED_0_Amber.Toggle;
end LED_0_Amber_Toggle;
-----------------------------------------------------------------------
-- All Green LED related definitions
-----------------------------------------------------------------------
LED_0_Green : LED_Type renames ItsyBitsy.GP28;
procedure LED_0_Green_Off is
begin
LED_0_Green.Clear;
end LED_0_Green_Off;
procedure LED_0_Green_On is
begin
LED_0_Green.Set;
end LED_0_Green_On;
procedure LED_0_Green_Toggle is
begin
LED_0_Green.Toggle;
end LED_0_Green_Toggle;
-----------------------------------------------------------------------
-- All White LED related definitions
-----------------------------------------------------------------------
LED_0_White : LED_Type renames ItsyBitsy.GP29;
procedure LED_0_White_Off is
begin
LED_0_White.Clear;
end LED_0_White_Off;
procedure LED_0_White_On is
begin
LED_0_White.Set;
end LED_0_White_On;
procedure LED_0_White_Toggle is
begin
LED_0_White.Toggle;
end LED_0_White_Toggle;
-----------------------------------------------------------------------
-- All Blue LED related definitions
-----------------------------------------------------------------------
LED_0_Blue : LED_Type renames ItsyBitsy.GP24;
procedure LED_0_Blue_Off is
begin
LED_0_Blue.Clear;
end LED_0_Blue_Off;
procedure LED_0_Blue_On is
begin
LED_0_Blue.Set;
end LED_0_Blue_On;
procedure LED_0_Blue_Toggle is
begin
LED_0_Blue.Toggle;
end LED_0_Blue_Toggle;
-----------------------------------------------------------------------
-- see .ads
-----------------------------------------------------------------------
procedure Toggle_All_LEDs (Delay_Between_In_Milliseconds : Integer
:= WAIT_FOR_NEXT_LED) is
begin
LED_0_Red_Toggle;
RP.Device.Timer.Delay_Milliseconds (Delay_Between_In_Milliseconds);
LED_0_Amber_Toggle;
RP.Device.Timer.Delay_Milliseconds (Delay_Between_In_Milliseconds);
LED_0_Green_Toggle;
RP.Device.Timer.Delay_Milliseconds (Delay_Between_In_Milliseconds);
LED_0_White_Toggle;
RP.Device.Timer.Delay_Milliseconds (Delay_Between_In_Milliseconds);
LED_0_Blue_Toggle;
RP.Device.Timer.Delay_Milliseconds (Delay_Between_In_Milliseconds);
end Toggle_All_LEDs;
begin
LED_0_Red.Configure (RP.GPIO.Output);
LED_0_Amber.Configure (RP.GPIO.Output);
LED_0_Green.Configure (RP.GPIO.Output);
LED_0_White.Configure (RP.GPIO.Output);
LED_0_Blue.Configure (RP.GPIO.Output);
end LED_Control;
|
src/Typed/LTLC.agda | laMudri/linear.agda | 34 | 13930 | <filename>src/Typed/LTLC.agda
module Typed.LTLC where
open import Prelude
open import Function
open import Level
open import Category.Monad
open import Relation.Unary.PredicateTransformer using (PT; Pt)
open import Relation.Ternary.Separation.Construct.Unit
open import Relation.Ternary.Separation.Allstar
open import Relation.Ternary.Separation.Monad
open import Relation.Ternary.Separation.Morphisms
open import Relation.Ternary.Separation.Monad.Reader
open import Relation.Ternary.Separation.Monad.Delay
data Ty : Set where
unit : Ty
_⊸_ : (a b : Ty) → Ty
open import Relation.Ternary.Separation.Construct.List Ty
Ctx = List Ty
CtxT = List Ty → List Ty
infixr 20 _◂_
_◂_ : Ty → CtxT → CtxT
(x ◂ f) Γ = x ∷ f Γ
variable a b : Ty
variable ℓv : Level
variable τ : Set ℓv
variable Γ Γ₁ Γ₂ Γ₃ : List τ
data Exp : Ty → Ctx → Set where
-- a base type
tt : ε[ Exp unit ]
letunit : ∀[ Exp unit ✴ Exp a ⇒ Exp a ]
-- the λ-calculus
lam : ∀[ (a ◂ id ⊢ Exp b) ⇒ Exp (a ⊸ b) ]
ap : ∀[ Exp (a ⊸ b) ✴ Exp a ⇒ Exp b ]
var : ∀[ Just a ⇒ Exp a ]
module _ {{m : MonoidalSep 0ℓ}} where
open MonoidalSep m using (Carrier)
CPred : Set₁
CPred = Carrier → Set
mutual
Env : Ctx → CPred
Env = Allstar Val
data Val : Ty → CPred where
tt : ε[ Val unit ]
clos : Exp b (a ∷ Γ) → ∀[ Env Γ ⇒ Val (a ⊸ b) ]
module _ {i : Size} where
open ReaderTransformer id-morph Val (Delay i) public
open Monads.Monad reader-monad public
M : Size → (Γ₁ Γ₂ : Ctx) → CPred → CPred
M i = Reader {i}
open Monads using (str; _&_; typed-str)
mutual
eval : ∀ {i} → Exp a Γ → ε[ M i Γ ε (Val a) ]
eval tt = do
return tt
eval (letunit (e₁ ×⟨ Γ≺ ⟩ e₂)) = do
tt ← frame Γ≺ (►eval e₁)
►eval e₂
eval (lam e) = do
env ← ask
return (clos e env)
eval (ap (f ×⟨ Γ≺ ⟩ e)) = do
clos body env ← frame Γ≺ (►eval f)
v ×⟨ σ ⟩ env ← ►eval e & env
empty ← append (v :⟨ σ ⟩: env)
►eval body
eval (var refl) = do
lookup
►eval : ∀ {i} → Exp a Γ → ε[ M i Γ ε (Val a) ]
app (►eval e) E σ = later (λ where .force → app (eval e) E σ)
|
programs/oeis/003/A003769.asm | neoneye/loda | 22 | 24056 | ; A003769: Number of perfect matchings (or domino tilings) in K_4 X P_n.
; 3,16,75,361,1728,8281,39675,190096,910803,4363921,20908800,100180081,479991603,2299777936,11018898075,52794712441,252954664128,1211978608201,5806938376875,27822713276176,133306628004003,638710426743841,3060245505715200,14662517101832161,70252340003445603,336599182915395856,1612743574573533675,7727118689952272521,37022849875187828928,177387130685986872121,849912803554746531675,4072176887087745786256,19510971631883982399603,93482681272332166211761,447902434729776848659200,2146029492376552077084241,10282245027152983536762003,49265195643388365606725776,236043733189788844496866875,1130953470305555856877608601,5418723618337990439891176128,25962664621384396342578272041,124394599488583991273000184075,596010332821535560022422648336,2855657064619093808839113057603,13682274990273933484173142639681,65555717886750573612026600140800,314096314443478934575959858064321,1504925854330644099267772690180803,7210532957209741561762903592839696,34547738931718063709546745274017675,165528161701380576985970822777248681,793093069575184821220307368612225728
add $0,2
seq $0,3501 ; a(n) = 5*a(n-1) - a(n-2), with a(0) = 2, a(1) = 5.
mov $1,4
add $1,$0
div $1,7
mov $0,$1
|
oeis/097/A097131.asm | neoneye/loda-programs | 11 | 169824 | <gh_stars>10-100
; A097131: F(n)+(-1)^n*F(n-1).
; Submitted by <NAME>
; 1,1,2,1,5,2,13,5,34,13,89,34,233,89,610,233,1597,610,4181,1597,10946,4181,28657,10946,75025,28657,196418,75025,514229,196418,1346269,514229,3524578,1346269,9227465,3524578,24157817,9227465,63245986,24157817
mov $2,1
lpb $0
sub $0,2
add $1,$2
add $2,$1
lpe
lpb $0
sub $0,1
sub $2,$1
lpe
mov $0,$2
|
other.7z/SFC.7z/SFC/ソースデータ/srd13-SFCマリオコレクション/export/mario-z/linkp/mario_n2/mn_hp_smsub1.asm | prismotizm/gigaleak | 0 | 10651 | <gh_stars>0
Name: mn_hp_smsub1.asm
Type: file
Size: 120205
Last-Modified: '1993-08-25T07:36:28Z'
SHA-1: B62D3B2FD14F16FBEE6F2EFBAB19DFD4FD5770D4
Description: null
|
tetris_os/boot/32pm_functions/print_string_pm.asm | vladcc/Tetris-OS | 20 | 96468 | <filename>tetris_os/boot/32pm_functions/print_string_pm.asm
; prints string in protected mode by writing directly to VGA memory
[bits 32] ; force 32 bit code for protected mode
; constants
%define VIDEO_MEMORY 0xb8000
%define GRAY_ON_BLACK 0x07
print_string_pm:
; eax - string address
; save registers
push eax
push ebx
push ecx
push edx
mov ebx, VIDEO_MEMORY ; set ebx to point to VGA memory
mov ch, GRAY_ON_BLACK ; set colors
mov cl, [eax] ; move character in cl
.print_loop:
mov [ebx], cx ; move whole word to VGA memory
add ebx, 2 ; increment for next character
inc eax ; increment for next character
mov cl, [eax] ; check character
cmp cl, 0 ; if not null print again
jnz .print_loop
; restore and return
pop edx
pop ecx
pop ebx
pop eax
ret |
libsrc/games/vg5k/bit_close_ei.asm | meesokim/z88dk | 0 | 91808 | ; $Id: bit_close_ei.asm,v 1.2 2015/01/19 01:32:45 pauloscustodio Exp $
;
; VG-5000 1 bit sound functions
;
; Close sound and restore interrupts
;
; <NAME> - 2014
;
PUBLIC bit_close_ei
EXTERN bit_irqstatus
.bit_close_ei
push hl
ld hl,(bit_irqstatus)
ex (sp),hl
pop af
ret po
ei
ret
|
gcc-gcc-7_3_0-release/gcc/testsuite/ada/acats/tests/c8/c86004b0.ada | best08618/asylo | 7 | 8172 | <reponame>best08618/asylo
-- C86004B0.ADA
-- Grant of Unlimited Rights
--
-- Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687,
-- F08630-91-C-0015, and DCA100-97-D-0025, the U.S. Government obtained
-- unlimited rights in the software and documentation contained herein.
-- Unlimited rights are defined in DFAR 252.227-7013(a)(19). By making
-- this public release, the Government intends to confer upon all
-- recipients unlimited rights equal to those held by the Government.
-- These rights include rights to use, duplicate, release or disclose the
-- released technical data and computer software in whole or in part, in
-- any manner and for any purpose whatsoever, and to have or permit others
-- to do so.
--
-- DISCLAIMER
--
-- ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR
-- DISCLOSED ARE AS IS. THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED
-- WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE
-- SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE
-- OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A
-- PARTICULAR PURPOSE OF SAID MATERIAL.
--*
-- OBJECTIVE:
-- INDEPENDENT FUNCTION AND SUBPROGRAM SPECIFICATION FOR C86004B
-- TEST.
-- HISTORY:
-- DHH 08/15/88 CREATED ORIGINAL TEST.
WITH REPORT; USE REPORT;
FUNCTION C86004B0(X : INTEGER) RETURN INTEGER IS
BEGIN
IF EQUAL(3,3) THEN
RETURN X;
ELSE
RETURN 0;
END IF;
END C86004B0;
WITH C86004B0;
WITH REPORT; USE REPORT; -- SPEC
PROCEDURE C86004B1(INTGR : INTEGER := STANDARD.C86004B0(4));
|
examples/outdated-and-incorrect/AIM6/Cat/lib/Data/PigeonHole.agda | larrytheliquid/agda | 0 | 13540 | <reponame>larrytheliquid/agda<gh_stars>0
module PigeonHole where
open import Prelude
open import Data.Nat hiding (_==_; _<_)
open import Data.Fin
open import Data.Vec as Vec
open import Logic.Base
open import Logic.Identity
open Vec.Elem
tooManyPigeons : {n : Nat}(xs : Vec (Fin (suc n)) n) -> ∃ \p -> p ∉ xs
tooManyPigeons {zero} [] = ∃-I fzero nl
tooManyPigeons {suc n} zs = aux zs (find _==_ fzero zs)
where
-- We start by checking whether or not fzero is an element of the list
aux : {n : Nat}(xs : Vec (Fin (suc (suc n))) (suc n)) ->
fzero ∈ xs \/ fzero ∉ xs -> ∃ \p -> p ∉ xs
-- If it's not then we're done
aux xs (\/-IR z∉xs) = ∃-I fzero z∉xs
-- If it is we have to find another element
aux xs (\/-IL z∈xs) = lem₂ ih
where
-- Let's remove the occurrence of fzero from the list and strip a fsuc
-- from each of the other elements (i.e. map pred $ delete fzero xs)
-- We can apply the induction hypothesis, giving us a p which is not in
-- this list.
ih : ∃ \p -> p ∉ map pred (delete fzero xs z∈xs)
ih = tooManyPigeons (map pred $ delete _ xs z∈xs)
-- First observe that if i ∉ map pred xs then fsuc i ∉ xs. Using this
-- lemma we conclude that fsuc p ∉ delete fzero xs.
lem₀ : {n m : Nat}(i : Fin (suc n))(xs : Vec (Fin (suc (suc n))) m) ->
i ∉ map pred xs -> fsuc i ∉ xs
lem₀ i [] nl = nl
lem₀ i (x :: xs) (cns h t) = cns (rem₀ h) (lem₀ i xs t)
where
rem₀ : {n : Nat}{i : Fin (suc n)}{j : Fin (suc (suc n))} ->
i ≢ pred j -> fsuc i ≢ j
rem₀ i≠i refl = i≠i refl
-- Furthermore, if i ∉ delete j xs and i ≠ j then i ∉ xs.
lem₁ : {n m : Nat}{i : Fin (suc n)}{j : Fin n}
(xs : Vec (Fin (suc n)) (suc m))(p : i ∈ xs) ->
thin i j ∉ delete i xs p -> thin i j ∉ xs
lem₁ (x :: xs) hd el = cns (thin-ij≠i _ _) el
lem₁ {m = zero } (x :: xs) (tl ()) _
lem₁ {m = suc _} (x :: xs) (tl p) (cns h t) = cns h (lem₁ xs p t)
-- So we get fsuc p ∉ xs and we're done.
lem₂ : (∃ \p -> p ∉ map pred (delete fzero xs z∈xs)) ->
(∃ \p -> p ∉ xs)
lem₂ (∃-I p h) = ∃-I (fsuc p) (lem₁ xs z∈xs $ lem₀ _ _ h)
-- tooManyHoles : {n : Nat}(xs : Vec (Fin n) (suc n)) ->
-- ∃ \p -> ∃ \i -> ∃ \j -> xs ! i ≡ p /\ xs ! thin i j ≡ p
-- tooManyHoles = ?
|
libsrc/compress/zx7/dzx7_agile_rcs_callee.asm | jpoikela/z88dk | 38 | 240678 |
; void dzx7_agile_rcs_callee(void *src, void *dst)
SECTION code_clib
SECTION code_compress_zx7
PUBLIC _dzx7_agile_rcs_callee
EXTERN asm_dzx7_agile_rcs
_dzx7_agile_rcs_callee:
pop hl
pop de
ex (sp),hl
jp asm_dzx7_agile_rcs
|
Cubical/HITs/James/Inductive/PushoutFormula.agda | thomas-lamiaux/cubical | 1 | 1111 | {-
This file contains:
- The inductive family 𝕁 can be constructed by iteratively applying pushouts;
- The special cases of 𝕁 n for n = 0, 1 and 2;
- Connectivity of inclusion maps.
Easy, almost direct consequences of the very definition.
-}
{-# OPTIONS --safe #-}
module Cubical.HITs.James.Inductive.PushoutFormula where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.GroupoidLaws
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Function
open import Cubical.Foundations.Pointed hiding (pt)
open import Cubical.Data.Nat
open import Cubical.Algebra.NatSolver.Reflection
open import Cubical.Data.Unit
open import Cubical.Data.Sigma
open import Cubical.HITs.Wedge
open import Cubical.HITs.Pushout
open import Cubical.HITs.Pushout.PushoutProduct
open import Cubical.HITs.SequentialColimit
open import Cubical.HITs.James.Inductive.Base
renaming (𝕁ames to 𝕁amesContruction ; 𝕁ames∞ to 𝕁ames∞Contruction)
open import Cubical.Homotopy.Connected
private
variable
ℓ : Level
module _
(X∙@(X , x₀) : Pointed ℓ) where
private
𝕁ames = 𝕁amesContruction (X , x₀)
𝕁ames∞ = 𝕁ames∞Contruction (X , x₀)
𝕁amesPush : (n : ℕ) → Type ℓ
𝕁amesPush n = Pushout {A = 𝕁ames n} {B = X × 𝕁ames n} {C = 𝕁ames (1 + n)} (λ xs → x₀ , xs) incl
X→𝕁ames1 : X → 𝕁ames 1
X→𝕁ames1 x = x ∷ []
𝕁ames1→X : 𝕁ames 1 → X
𝕁ames1→X (x ∷ []) = x
𝕁ames1→X (incl []) = x₀
𝕁ames1→X (unit [] i) = x₀
X→𝕁ames1→X : (x : X) → 𝕁ames1→X (X→𝕁ames1 x) ≡ x
X→𝕁ames1→X x = refl
𝕁ames1→X→𝕁ames1 : (xs : 𝕁ames 1) → X→𝕁ames1 (𝕁ames1→X xs) ≡ xs
𝕁ames1→X→𝕁ames1 (x ∷ []) = refl
𝕁ames1→X→𝕁ames1 (incl []) i = unit [] (~ i)
𝕁ames1→X→𝕁ames1 (unit [] i) j = unit [] (i ∨ ~ j)
leftMap : {n : ℕ} → 𝕁amesPush n → X × 𝕁ames (1 + n)
leftMap (inl (x , xs)) = x , incl xs
leftMap (inr ys) = x₀ , ys
leftMap (push xs i) = x₀ , incl xs
rightMap : {n : ℕ} → 𝕁amesPush n → 𝕁ames (1 + n)
rightMap (inl (x , xs)) = x ∷ xs
rightMap (inr ys) = ys
rightMap (push xs i) = unit xs (~ i)
PushMap : {n : ℕ} → Pushout {A = 𝕁amesPush n} leftMap rightMap → 𝕁ames (2 + n)
PushMap (inl (x , xs)) = x ∷ xs
PushMap (inr ys) = incl ys
PushMap (push (inl (x , xs)) i) = incl∷ x xs (~ i)
PushMap (push (inr ys) i) = unit ys (~ i)
PushMap (push (push xs i) j) = coh xs (~ i) (~ j)
PushInv : {n : ℕ} → 𝕁ames (2 + n) → Pushout {A = 𝕁amesPush n} leftMap rightMap
PushInv (x ∷ xs) = inl (x , xs)
PushInv (incl xs) = inr xs
PushInv (incl∷ x xs i) = push (inl (x , xs)) (~ i)
PushInv (unit xs i) = push (inr xs) (~ i)
PushInv (coh xs i j) = push (push xs (~ i)) (~ j)
PushInvMapInv : {n : ℕ}(xs : 𝕁ames (2 + n)) → PushMap (PushInv xs) ≡ xs
PushInvMapInv (x ∷ xs) = refl
PushInvMapInv (incl xs) = refl
PushInvMapInv (incl∷ x xs i) = refl
PushInvMapInv (unit xs i) = refl
PushInvMapInv (coh xs i j) = refl
PushMapInvMap : {n : ℕ}(xs : Pushout {A = 𝕁amesPush n} leftMap rightMap) → PushInv (PushMap xs) ≡ xs
PushMapInvMap (inl (x , xs)) = refl
PushMapInvMap (inr ys) = refl
PushMapInvMap (push (inl (x , xs)) i) = refl
PushMapInvMap (push (inr ys) i) = refl
PushMapInvMap (push (push xs i) j) = refl
-- The special case 𝕁ames 2
P0→X⋁X : 𝕁amesPush 0 → X∙ ⋁ X∙
P0→X⋁X (inl (x , [])) = inl x
P0→X⋁X (inr (x ∷ [])) = inr x
P0→X⋁X (inr (incl [])) = inr x₀
P0→X⋁X (inr (unit [] i)) = inr x₀
P0→X⋁X (push [] i) = push tt i
X⋁X→P0 : X∙ ⋁ X∙ → 𝕁amesPush 0
X⋁X→P0 (inl x) = inl (x , [])
X⋁X→P0 (inr x) = inr (x ∷ [])
X⋁X→P0 (push tt i) = (push [] ∙ (λ i → inr (unit [] i))) i
P0→X⋁X→P0 : (x : 𝕁amesPush 0) → X⋁X→P0 (P0→X⋁X x) ≡ x
P0→X⋁X→P0 (inl (x , [])) = refl
P0→X⋁X→P0 (inr (x ∷ [])) = refl
P0→X⋁X→P0 (inr (incl [])) i = inr (unit [] (~ i))
P0→X⋁X→P0 (inr (unit [] i)) j = inr (unit [] (i ∨ ~ j))
P0→X⋁X→P0 (push [] i) j =
hcomp (λ k → λ
{ (i = i0) → inl (x₀ , [])
; (i = i1) → inr (unit [] (~ j ∧ k))
; (j = i0) → compPath-filler (push []) (λ i → inr (unit [] i)) k i
; (j = i1) → push [] i })
(push [] i)
X⋁X→P0→X⋁X : (x : X∙ ⋁ X∙) → P0→X⋁X (X⋁X→P0 x) ≡ x
X⋁X→P0→X⋁X (inl x) = refl
X⋁X→P0→X⋁X (inr x) = refl
X⋁X→P0→X⋁X (push tt i) j =
hcomp (λ k → λ
{ (i = i0) → inl x₀
; (i = i1) → inr x₀
; (j = i0) → P0→X⋁X (compPath-filler (push []) refl k i)
; (j = i1) → push tt i })
(push tt i)
P0≃X⋁X : 𝕁amesPush 0 ≃ X∙ ⋁ X∙
P0≃X⋁X = isoToEquiv (iso P0→X⋁X X⋁X→P0 X⋁X→P0→X⋁X P0→X⋁X→P0)
-- The type family 𝕁ames can be constructed by iteratively using pushouts
𝕁ames0≃ : 𝕁ames 0 ≃ Unit
𝕁ames0≃ = isoToEquiv (iso (λ { [] → tt }) (λ { tt → [] }) (λ { tt → refl }) (λ { [] → refl }))
𝕁ames1≃ : 𝕁ames 1 ≃ X
𝕁ames1≃ = isoToEquiv (iso 𝕁ames1→X X→𝕁ames1 X→𝕁ames1→X 𝕁ames1→X→𝕁ames1)
𝕁ames2+n≃ : (n : ℕ) → 𝕁ames (2 + n) ≃ Pushout leftMap rightMap
𝕁ames2+n≃ n = isoToEquiv (iso PushInv PushMap PushMapInvMap PushInvMapInv)
private
left≃ : X × 𝕁ames 1 ≃ X × X
left≃ = ≃-× (idEquiv _) 𝕁ames1≃
lComm : (x : 𝕁amesPush 0) → left≃ .fst (leftMap x) ≡ ⋁↪ (P0→X⋁X x)
lComm (inl (x , [])) = refl
lComm (inr (x ∷ [])) = refl
lComm (inr (incl [])) = refl
lComm (inr (unit [] i)) = refl
lComm (push [] i) = refl
rComm : (x : 𝕁amesPush 0) → 𝕁ames1≃ .fst (rightMap x) ≡ fold⋁ (P0→X⋁X x)
rComm (inl (x , [])) = refl
rComm (inr (x ∷ [])) = refl
rComm (inr (incl [])) = refl
rComm (inr (unit [] i)) = refl
rComm (push [] i) = refl
𝕁ames2≃ : 𝕁ames 2 ≃ Pushout {A = X∙ ⋁ X∙} ⋁↪ fold⋁
𝕁ames2≃ =
compEquiv (𝕁ames2+n≃ 0)
(pushoutEquiv _ _ _ _ P0≃X⋁X left≃ 𝕁ames1≃ (funExt lComm) (funExt rComm))
-- The leftMap can be seen as pushout-product
private
Unit×-≃ : {A : Type ℓ} → A ≃ Unit × A
Unit×-≃ = isoToEquiv (invIso lUnit×Iso)
pt : Unit → X
pt _ = x₀
𝕁amesPush' : (n : ℕ) → Type ℓ
𝕁amesPush' n = PushProd {X = Unit} {A = X} {Y = 𝕁ames n} {B = 𝕁ames (1 + n)} pt incl
leftMap' : {n : ℕ} → 𝕁amesPush' n → X × 𝕁ames (1 + n)
leftMap' = pt ×̂ incl
𝕁amesPush→Push' : (n : ℕ) → 𝕁amesPush n → 𝕁amesPush' n
𝕁amesPush→Push' n (inl x) = inr x
𝕁amesPush→Push' n (inr x) = inl (tt , x)
𝕁amesPush→Push' n (push x i) = push (tt , x) (~ i)
𝕁amesPush'→Push : (n : ℕ) → 𝕁amesPush' n → 𝕁amesPush n
𝕁amesPush'→Push n (inl (tt , x)) = inr x
𝕁amesPush'→Push n (inr x) = inl x
𝕁amesPush'→Push n (push (tt , x) i) = push x (~ i)
𝕁amesPush≃ : (n : ℕ) → 𝕁amesPush n ≃ 𝕁amesPush' n
𝕁amesPush≃ n = isoToEquiv
(iso (𝕁amesPush→Push' n) (𝕁amesPush'→Push n)
(λ { (inl x) → refl ; (inr x) → refl ; (push x i) → refl })
(λ { (inl x) → refl ; (inr x) → refl ; (push x i) → refl }))
≃𝕁ames1 : X ≃ 𝕁ames 1
≃𝕁ames1 = isoToEquiv (iso X→𝕁ames1 𝕁ames1→X 𝕁ames1→X→𝕁ames1 X→𝕁ames1→X)
≃𝕁ames2+n : (n : ℕ) → Pushout leftMap rightMap ≃ 𝕁ames (2 + n)
≃𝕁ames2+n n = isoToEquiv (iso PushMap PushInv PushInvMapInv PushMapInvMap)
-- The connectivity of inclusion
private
comp1 : (n : ℕ) → leftMap' ∘ 𝕁amesPush≃ n .fst ≡ leftMap
comp1 n = funExt (λ { (inl x) → refl ; (inr x) → refl ; (push x i) → refl })
comp2 : (n : ℕ) → ≃𝕁ames2+n n .fst ∘ inr ≡ incl
comp2 n = funExt (λ _ → refl)
comp3 : ≃𝕁ames1 .fst ∘ pt ∘ 𝕁ames0≃ .fst ≡ incl
comp3 i [] = unit [] (~ i)
isConnIncl0 :
(n : ℕ) → isConnected (1 + n) X
→ isConnectedFun n (incl {X∙ = X∙} {n = 0})
isConnIncl0 n conn =
subst (isConnectedFun _) comp3
(isConnectedComp _ _ _ (isEquiv→isConnected _ (≃𝕁ames1 .snd) _)
(isConnectedComp _ _ _ (isConnectedPoint _ conn _)
(isEquiv→isConnected _ (𝕁ames0≃ .snd) _)))
isConnIncl-ind :
(m n k : ℕ) → isConnected (1 + m) X
→ isConnectedFun n (incl {X∙ = X∙} {n = k})
→ isConnectedFun (m + n) (incl {X∙ = X∙} {n = 1 + k})
isConnIncl-ind m n k connX connf =
subst (isConnectedFun _) (comp2 _)
(isConnectedComp _ _ _ (isEquiv→isConnected _ (≃𝕁ames2+n k .snd) _)
(inrConnected _ _ _
(subst (isConnectedFun _) (comp1 _)
(isConnectedComp _ _ _
(isConnected×̂ (isConnectedPoint _ connX _) connf)
(isEquiv→isConnected _ (𝕁amesPush≃ k .snd) _)))))
nat-path : (n m k : ℕ) → (1 + (k + m)) · n ≡ k · n + (1 + m) · n
nat-path = solve
-- Connectivity results
isConnectedIncl : (n : ℕ) → isConnected (1 + n) X
→ (m : ℕ) → isConnectedFun ((1 + m) · n) (incl {X∙ = X∙} {n = m})
isConnectedIncl n conn 0 = subst (λ d → isConnectedFun d _) (sym (+-zero n)) (isConnIncl0 n conn)
isConnectedIncl n conn (suc m) = isConnIncl-ind _ _ _ conn (isConnectedIncl n conn m)
isConnectedIncl>n : (n : ℕ) → isConnected (1 + n) X
→ (m k : ℕ) → isConnectedFun ((1 + m) · n) (incl {X∙ = X∙} {n = k + m})
isConnectedIncl>n n conn m k = isConnectedFunSubtr _ (k · n) _
(subst (λ d → isConnectedFun d (incl {X∙ = X∙} {n = k + m}))
(nat-path n m k) (isConnectedIncl n conn (k + m)))
private
inl∞ : (n : ℕ) → 𝕁ames n → 𝕁ames∞
inl∞ _ = inl
isConnectedInl : (n : ℕ) → isConnected (1 + n) X
→ (m : ℕ) → isConnectedFun ((1 + m) · n) (inl∞ m)
isConnectedInl n conn m = isConnectedInl∞ _ _ _ (isConnectedIncl>n _ conn _)
|
llvm-gcc-4.2-2.9/gcc/ada/a-ztcoio.ads | vidkidz/crossbridge | 1 | 2526 | <filename>llvm-gcc-4.2-2.9/gcc/ada/a-ztcoio.ads
------------------------------------------------------------------------------
-- --
-- GNAT RUN-TIME COMPONENTS --
-- --
-- A D A . W I D E _ W I D E _ T E X T _ IO . C O M P L E X _ I O --
-- --
-- S p e c --
-- --
-- This specification is adapted from the Ada Reference Manual for use with --
-- GNAT. In accordance with the copyright of that document, you can freely --
-- copy and modify this specification, provided that if you redistribute a --
-- modified version, any changes that you have made are clearly indicated. --
-- --
------------------------------------------------------------------------------
with Ada.Numerics.Generic_Complex_Types;
generic
with package Complex_Types is new Ada.Numerics.Generic_Complex_Types (<>);
package Ada.Wide_Wide_Text_IO.Complex_IO is
use Complex_Types;
Default_Fore : Field := 2;
Default_Aft : Field := Real'Digits - 1;
Default_Exp : Field := 3;
procedure Get
(File : File_Type;
Item : out Complex;
Width : Field := 0);
procedure Get
(Item : out Complex;
Width : Field := 0);
procedure Put
(File : File_Type;
Item : Complex;
Fore : Field := Default_Fore;
Aft : Field := Default_Aft;
Exp : Field := Default_Exp);
procedure Put
(Item : Complex;
Fore : Field := Default_Fore;
Aft : Field := Default_Aft;
Exp : Field := Default_Exp);
procedure Get
(From : Wide_Wide_String;
Item : out Complex;
Last : out Positive);
procedure Put
(To : out Wide_Wide_String;
Item : Complex;
Aft : Field := Default_Aft;
Exp : Field := Default_Exp);
end Ada.Wide_Wide_Text_IO.Complex_IO;
|
Graph/Walk/Functions/Proofs.agda | Lolirofle/stuff-in-agda | 6 | 13512 | <gh_stars>1-10
open import Type
module Graph.Walk.Functions.Proofs {ℓ₁ ℓ₂} {V : Type{ℓ₁}} where
import Data.Either as Either
open import Data.Either.Proofs
open import Logic.Propositional
import Lvl
open import Graph{ℓ₁}{ℓ₂}(V)
open import Graph.Properties
open import Graph.Walk{ℓ₁}{ℓ₂}{V}
open import Graph.Walk.Properties{ℓ₁}{ℓ₂}{V}
open import Graph.Walk.Functions{ℓ₁}{ℓ₂}{V}
open import Numeral.Natural
open import Numeral.Natural.Oper
open import Numeral.Natural.Oper.Proofs
open import Relator.Equals
open import Relator.Equals.Proofs
open import Structure.Relator.Properties
open import Syntax.Function
open import Type.Dependent
open import Type.Dependent.Functions
module _ (_⟶_ : Graph) where
at-path-length : ∀{a} → length{_⟶_}(at{x = a}) ≡ 0
at-path-length = reflexivity(_≡_)
edge-path-length : ∀{a b}{e : a ⟶ b} → length{_⟶_}(edge e) ≡ 1
edge-path-length = reflexivity(_≡_)
join-path-length : ∀{a b c}{e₁ : a ⟶ b}{e₂ : b ⟶ c} → length{_⟶_}(join e₁ e₂) ≡ 2
join-path-length = reflexivity(_≡_)
prepend-path-length : ∀{a b c}{e : a ⟶ b}{w : Walk(_⟶_) b c} → length(prepend e w) ≡ 𝐒(length w)
prepend-path-length {w = at} = reflexivity(_≡_)
prepend-path-length {w = prepend e w} = [≡]-with(𝐒) (prepend-path-length{e = e}{w = w})
[++]-identityᵣ : ∀{a b}{w : Walk(_⟶_) a b} → (w ++ at ≡ w)
[++]-identityᵣ {w = at} = reflexivity(_≡_)
[++]-identityᵣ {w = prepend x w} = [≡]-with(prepend x) ([++]-identityᵣ {w = w})
{-# REWRITE [++]-identityᵣ #-}
[++]-path-length : ∀{a b c}{w₁ : Walk(_⟶_) a b}{w₂ : Walk(_⟶_) b c} → length(w₁ ++ w₂) ≡ length w₁ + length w₂
[++]-path-length {a} {.a} {.a} {at} {at} = reflexivity(_≡_)
[++]-path-length {a} {.a} {c} {at} {prepend e w} = prepend-path-length {e = e}{w = w}
[++]-path-length {a} {b} {c} {prepend e₁ w₁} {w₂} = [≡]-with(𝐒) ([++]-path-length {w₁ = w₁}{w₂ = w₂})
{-# REWRITE [++]-path-length #-}
at-visits : ∀{v} → Visits(_⟶_) v (at{x = v})
at-visits = current
edge-visits-left : ∀{a b}{e : a ⟶ b} → Visits(_⟶_) a (edge e)
edge-visits-left = current
edge-visits-right : ∀{a b}{e : a ⟶ b} → Visits(_⟶_) b (edge e)
edge-visits-right = skip current
join-visits-1 : ∀{a b c}{e₁ : a ⟶ b}{e₂ : b ⟶ c} → Visits(_⟶_) a (join e₁ e₂)
join-visits-1 = current
join-visits-2 : ∀{a b c}{e₁ : a ⟶ b}{e₂ : b ⟶ c} → Visits(_⟶_) b (join e₁ e₂)
join-visits-2 = skip current
join-visits-3 : ∀{a b c}{e₁ : a ⟶ b}{e₂ : b ⟶ c} → Visits(_⟶_) c (join e₁ e₂)
join-visits-3 = skip (skip current)
prepend-visitsᵣ-left : ∀{a b c}{e : a ⟶ b}{w : Walk(_⟶_) b c} → Visits(_⟶_) a (prepend e w)
prepend-visitsᵣ-left = current
prepend-visitsᵣ-right : ∀{v b c}{w : Walk(_⟶_) b c} → Visits(_⟶_) v w → ∀{a}{e : a ⟶ b} → Visits(_⟶_) v (prepend e w)
prepend-visitsᵣ-right p = skip p
prepend-visitsₗ : ∀{v a b c}{e : a ⟶ b}{w : Walk(_⟶_) b c} → Visits(_⟶_) v (prepend e w) → ((v ≡ a) ∨ Visits(_⟶_) v w)
prepend-visitsₗ current = [∨]-introₗ(reflexivity(_≡_))
prepend-visitsₗ (skip p) = [∨]-introᵣ p
[++]-visitsᵣ : ∀{v a b c}{w₁ : Walk(_⟶_) a b}{w₂ : Walk(_⟶_) b c} → (Visits(_⟶_) v w₁) ∨ (Visits(_⟶_) v w₂) → Visits(_⟶_) v (w₁ ++ w₂)
[++]-visitsᵣ ([∨]-introₗ current) = current
[++]-visitsᵣ {w₂ = w₂} ([∨]-introₗ (skip {rest = rest} p)) = skip ([++]-visitsᵣ {w₁ = rest}{w₂ = w₂} ([∨]-introₗ p))
[++]-visitsᵣ {w₁ = at} ([∨]-introᵣ p) = p
[++]-visitsᵣ {w₁ = prepend x w₁} {w₂ = w₂} ([∨]-introᵣ p) = skip ([++]-visitsᵣ {w₁ = w₁}{w₂ = w₂} ([∨]-introᵣ p))
[++]-visitsₗ : ∀{v a b c}{w₁ : Walk(_⟶_) a b}{w₂ : Walk(_⟶_) b c} → (Visits(_⟶_) v w₁) ∨ (Visits(_⟶_) v w₂) ← Visits(_⟶_) v (w₁ ++ w₂)
[++]-visitsₗ {v} {a} {.a} {.a} {at} {at} p = [∨]-introₗ p
[++]-visitsₗ {v} {a} {.a} {c} {at} {prepend x w₂} p = [∨]-introᵣ p
[++]-visitsₗ {v} {a} {b} {c} {prepend e w₁} {w₂} p with prepend-visitsₗ p
[++]-visitsₗ {v} {a} {b} {c} {prepend e w₁} {w₂} p | [∨]-introₗ eq = [∨]-introₗ ([≡]-substitutionₗ eq (Visits.current {path = prepend e w₁}))
[++]-visitsₗ {v} {a} {b} {c} {prepend e w₁} {w₂} _ | [∨]-introᵣ p = Either.mapLeft skip ([++]-visitsₗ {w₁ = w₁} {w₂ = w₂} p)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.