Annotation of researchv10dc/vol2/spin/spin.terms, revision 1.1

1.1     ! root        1: C program
        !             2: non-progress loops     s
        !             3: CW-a   S
        !             4: spin -a        S
        !             5: CW -a  S
        !             6: CW-f   S
        !             7: CW -f  S
        !             8: CW-c   S
        !             9: CW -c  S
        !            10: CW-m   S
        !            11: CW -m  S
        !            12: CW-n   S
        !            13: CW -n  S
        !            14: CW-p   S
        !            15: CW -p  S
        !            16: CW-t   S
        !            17: CW -t  S
        !            18: CW-w   S
        !            19: CW -w  S
        !            20: CW-g   S
        !            21: CW -g  S
        !            22: CW-l   S
        !            23: CW -l  S
        !            24: CW-r   S
        !            25: CW -r  S
        !            26: CW-s   S
        !            27: CW -s  S
        !            28: CW-q   S
        !            29: CW -q  S
        !            30: Progress-State Labels
        !            31: End-State Lables
        !            32: guarded command language       g
        !            33: Atomic Sequence        s
        !            34: CW assert      S
        !            35: CW block       S
        !            36: assertion violation
        !            37: asynchronous communication
        !            38: deadlock       g
        !            39:  synchronous
        !            40: communication protocol g
        !            41: concurrent processes   g
        !            42: pan.trail      S
        !            43: CW break       S
        !            44: buffer size    s
        !            45: chan   S
        !            46: channel        s
        !            47: curly braces   s
        !            48: CW do  S
        !            49: error sequence s
        !            50: error trail    s
        !            51: exhaustive validation
        !            52: CW goto        S
        !            53: global variables       s
        !            54: greatest common divisor        s
        !            55: CW halt        S
        !            56: hash collision s
        !            57: hash factor    s
        !            58: hash table     s
        !            59: local variables        s
        !            60: message type   s
        !            61: modeling language      g
        !            62: CW null        S
        !            63: process declaration    s
        !            64: CW proctype    S
        !            65: CW skip        S
        !            66: random simulation
        !            67: CW run S
        !            68: run-time error s
        !            69: search depth   s
        !            70: CW send        S
        !            71: state space    s
        !            72: symbolic names s
        !            73: system state space     s
        !            74: unary operator s
        !            75: unexecutable code      s
        !            76: unreachable state      s
        !            77: Spin \(em A Protocol Analyzer  g
        !            78: Introduction to \*P    s
        !            79: Executability
        !            80: Data Types     s
        !            81: Array Variables        s
        !            82: Process Type   s
        !            83: Process Instantiation
        !            84: Message Passing
        !            85: Rendez-Vous Communication
        !            86: Control Flow   s
        !            87: Case Selection s
        !            88: Repetition     s
        !            89: Unconditional Jumps    s
        !            90: Modeling Procedures and Recursion
        !            91: Assertions
        !            92: Message Type Definitions
        !            93: Pseudo Statements      s
        !            94: Introduction to Spin   s
        !            95: Building A Validations Suite   s
        !            96: The Simulator  s
        !            97: The Analyzer   s
        !            98: Full State Space       s
        !            99: Options        s
        !           100: Bit State Space        s
        !           101: \*P Reference Manual
        !           102: Lexical Conventions    s
        !           103: Comments       s
        !           104: Identifiers    s
        !           105: Keywords       s
        !           106: IH Constants   s
        !           107: Expressions    s
        !           108: Declarations   s
        !           109: IH Variables   s
        !           110: Message Queues
        !           111: Message Channels       s
        !           112: IH Processes
        !           113: IH Statements  s
        !           114: Selection      s
        !           115: Repetition and Break   s
        !           116: IH Send        s
        !           117: IH Receive     s
        !           118: Timeout
        !           119: Macros and Include File        s
        !           120: C|
        !           121: statement \f2separator s
        !           122: statement separator    s
        !           123: CW init        S
        !           124: CW run S
        !           125: \f2test and set\f1 problem     s
        !           126: channel names  s
        !           127: .CW len        S
        !           128: composite condition    s
        !           129: side-effects   s
        !           130: guard  s
        !           131: Advenced Usage s
        !           132: End-State Labels       s
        !           133: Progress-State Labels  s
        !           134: deadlocks      s
        !           135: grep   G
        !           136: Exhaustive Search      s
        !           137: Bit State Space Analysis       s
        !           138: CW if  S
        !           139: Building A Validation Suite    s
        !           140: Digging Deeper s
        !           141: propositional temporal logic

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.