PROGRAM TEX; LABEL 1, 9998, 9999; CONST MEM_MAX = 60000; MEM_MIN = 0; BUF_SIZE = 500; ERROR_LINE = 72; HALF_ERROR_LINE = 42; MAX_PRINT_LINE = 79; STACK_SIZE = 200; MAX_IN_OPEN = 6; FONT_MAX = 75; FONT_MEM_SIZE = 60000; PARAM_SIZE = 60; NEST_SIZE = 40; MAX_STRINGS = 9000; STRING_VACANCIES = 8000; POOL_SIZE = 64000; SAVE_SIZE = 600; TRIE_SIZE = 8000; TRIE_OP_SIZE = 500; DVI_BUF_SIZE = 800; FILE_NAME_SIZE = 40; POOL_NAME = 'TeXformats:TEX.POOL '; TYPE ASCII_CODE = 0..255; EIGHT_BITS = 0..255; ALPHA_FILE = TEXT; BYTE_FILE = PACKED FILE OF EIGHT_BITS; POOL_POINTER = 0..POOL_SIZE; STR_NUMBER = 0..MAX_STRINGS; PACKED_ASCII_CODE = 0..255; SCALED = INTEGER; NONNEGATIVE_INTEGER = 0..2147483647; SMALL_NUMBER = 0..63; GLUE_RATIO = REAL; QUARTERWORD = 0..255; HALFWORD = 0..65535; TWO_CHOICES = 1..2; FOUR_CHOICES = 1..4; TWO_HALVES = PACKED RECORD RH : HALFWORD; CASE TWO_CHOICES OF 1: (LH : HALFWORD); 2: (B0 : QUARTERWORD; B1 : QUARTERWORD) END; FOUR_QUARTERS = PACKED RECORD B0 : QUARTERWORD; B1 : QUARTERWORD; B2 : QUARTERWORD; B3 : QUARTERWORD END; MEMORY_WORD = RECORD CASE FOUR_CHOICES OF 1: (INT : INTEGER); 2: (GR : GLUE_RATIO); 3: (HH : TWO_HALVES); 4: (QQQQ : FOUR_QUARTERS) END; WORD_FILE = FILE OF MEMORY_WORD; GLUE_ORD = 0..3; LIST_STATE_RECORD = RECORD MODE_FIELD : -203..203; HEAD_FIELD : HALFWORD; TAIL_FIELD : HALFWORD; PG_FIELD : INTEGER; ML_FIELD : INTEGER; AUX_FIELD : MEMORY_WORD END; GROUP_CODE = 0..16; IN_STATE_RECORD = RECORD STATE_FIELD : QUARTERWORD; INDEX_FIELD : QUARTERWORD; START_FIELD : HALFWORD; LOC_FIELD : HALFWORD; LIMIT_FIELD : HALFWORD; NAME_FIELD : HALFWORD END; INTERNAL_FONT_NUMBER = 0..FONT_MAX; FONT_INDEX = 0..FONT_MEM_SIZE; DVI_INDEX = 0..DVI_BUF_SIZE; TRIE_POINTER = 0..TRIE_SIZE; HYPH_POINTER = 0..307; VAR BAD : INTEGER; XORD : ARRAY [CHAR] OF ASCII_CODE; XCHR : ARRAY [ASCII_CODE] OF CHAR; NAME_OF_FILE : PACKED ARRAY [1..FILE_NAME_SIZE] OF CHAR; NAME_LENGTH : 0..FILE_NAME_SIZE; BUFFER : ARRAY [0..BUF_SIZE] OF ASCII_CODE; FIRST : 0..BUF_SIZE; LAST : 0..BUF_SIZE; MAX_BUF_STACK : 0..BUF_SIZE; TERM_IN : ALPHA_FILE; TERM_OUT : ALPHA_FILE; STR_POOL : PACKED ARRAY [POOL_POINTER] OF PACKED_ASCII_CODE; STR_START : ARRAY [STR_NUMBER] OF POOL_POINTER; POOL_PTR : POOL_POINTER; STR_PTR : STR_NUMBER; INIT_POOL_PTR : POOL_POINTER; INIT_STR_PTR : STR_NUMBER; POOL_FILE : ALPHA_FILE; LOG_FILE : ALPHA_FILE; SELECTOR : 0..21; DIG : ARRAY [0..22] OF 0..15; TALLY : INTEGER; TERM_OFFSET : 0..MAX_PRINT_LINE; FILE_OFFSET : 0..MAX_PRINT_LINE; TRICK_BUF : ARRAY [0..ERROR_LINE] OF ASCII_CODE; TRICK_COUNT : INTEGER; FIRST_COUNT : INTEGER; INTERACTION : 0..3; DELETIONS_ALLOWED : BOOLEAN; SET_BOX_ALLOWED : BOOLEAN; HISTORY : 0..3; ERROR_COUNT : -1..100; HELP_LINE : ARRAY [0..5] OF STR_NUMBER; HELP_PTR : 0..6; USE_ERR_HELP : BOOLEAN; INTERRUPT : INTEGER; OK_TO_INTERRUPT : BOOLEAN; ARITH_ERROR : BOOLEAN; REMAINDER : SCALED; TEMP_PTR : HALFWORD; MEM : ARRAY [MEM_MIN..MEM_MAX] OF MEMORY_WORD; LO_MEM_MAX : HALFWORD; HI_MEM_MIN : HALFWORD; VAR_USED : INTEGER; DYN_USED : INTEGER; AVAIL : HALFWORD; MEM_END : HALFWORD; ROVER : HALFWORD; FONT_IN_SHORT_DISPLAY : INTEGER; DEPTH_THRESHOLD : INTEGER; BREADTH_MAX : INTEGER; NEST : ARRAY [0..NEST_SIZE] OF LIST_STATE_RECORD; NEST_PTR : 0..NEST_SIZE; MAX_NEST_STACK : 0..NEST_SIZE; CUR_LIST : LIST_STATE_RECORD; SHOWN_MODE : -203..203; OLD_SETTING : 0..21; SYS_TIME : INTEGER; SYS_DAY : INTEGER; SYS_MONTH : INTEGER; SYS_YEAR : INTEGER; EQTB : ARRAY [1..10006] OF MEMORY_WORD; XEQ_LEVEL : ARRAY [9163..10006] OF QUARTERWORD; HASH : ARRAY [514..6780] OF TWO_HALVES; HASH_USED : HALFWORD; NO_NEW_CONTROL_SEQUENCE : BOOLEAN; CS_COUNT : INTEGER; SAVE_STACK : ARRAY [0..SAVE_SIZE] OF MEMORY_WORD; SAVE_PTR : 0..SAVE_SIZE; MAX_SAVE_STACK : 0..SAVE_SIZE; CUR_LEVEL : QUARTERWORD; CUR_GROUP : GROUP_CODE; CUR_BOUNDARY : 0..SAVE_SIZE; MAG_SET : INTEGER; CUR_CMD : EIGHT_BITS; CUR_CHR : HALFWORD; CUR_CS : HALFWORD; CUR_TOK : HALFWORD; INPUT_STACK : ARRAY [0..STACK_SIZE] OF IN_STATE_RECORD; INPUT_PTR : 0..STACK_SIZE; MAX_IN_STACK : 0..STACK_SIZE; CUR_INPUT : IN_STATE_RECORD; IN_OPEN : 0..MAX_IN_OPEN; OPEN_PARENS : 0..MAX_IN_OPEN; INPUT_FILE : ARRAY [1..MAX_IN_OPEN] OF ALPHA_FILE; LINE : INTEGER; LINE_STACK : ARRAY [1..MAX_IN_OPEN] OF INTEGER; SCANNER_STATUS : 0..5; WARNING_INDEX : HALFWORD; DEF_REF : HALFWORD; PARAM_STACK : ARRAY [0..PARAM_SIZE] OF HALFWORD; PARAM_PTR : 0..PARAM_SIZE; MAX_PARAM_STACK : INTEGER; ALIGN_STATE : INTEGER; BASE_PTR : 0..STACK_SIZE; PAR_LOC : HALFWORD; PAR_TOKEN : HALFWORD; FORCE_EOF : BOOLEAN; CUR_MARK : ARRAY [0..4] OF HALFWORD; LONG_STATE : 111..114; PSTACK : ARRAY [0..8] OF HALFWORD; CUR_VAL : INTEGER; CUR_VAL_LEVEL : 0..5; RADIX : SMALL_NUMBER; CUR_ORDER : GLUE_ORD; READ_FILE : ARRAY [0..15] OF ALPHA_FILE; READ_OPEN : ARRAY [0..16] OF 0..2; COND_PTR : HALFWORD; IF_LIMIT : 0..4; CUR_IF : SMALL_NUMBER; IF_LINE : INTEGER; SKIP_LINE : INTEGER; CUR_NAME : STR_NUMBER; CUR_AREA : STR_NUMBER; CUR_EXT : STR_NUMBER; AREA_DELIMITER : POOL_POINTER; EXT_DELIMITER : POOL_POINTER; TEX_FORMAT_DEFAULT : PACKED ARRAY [1..20] OF CHAR; NAME_IN_PROGRESS : BOOLEAN; JOB_NAME : STR_NUMBER; LOG_OPENED : BOOLEAN; DVI_FILE : BYTE_FILE; OUTPUT_FILE_NAME : STR_NUMBER; LOG_NAME : STR_NUMBER; TFM_FILE : BYTE_FILE; FONT_INFO : ARRAY [FONT_INDEX] OF MEMORY_WORD; FMEM_PTR : FONT_INDEX; FONT_PTR : INTERNAL_FONT_NUMBER; FONT_CHECK : ARRAY [INTERNAL_FONT_NUMBER] OF FOUR_QUARTERS; FONT_SIZE : ARRAY [INTERNAL_FONT_NUMBER] OF SCALED; FONT_DSIZE : ARRAY [INTERNAL_FONT_NUMBER] OF SCALED; FONT_PARAMS : ARRAY [INTERNAL_FONT_NUMBER] OF FONT_INDEX; FONT_NAME : ARRAY [INTERNAL_FONT_NUMBER] OF STR_NUMBER; FONT_AREA : ARRAY [INTERNAL_FONT_NUMBER] OF STR_NUMBER; FONT_BC : ARRAY [INTERNAL_FONT_NUMBER] OF EIGHT_BITS; FONT_EC : ARRAY [INTERNAL_FONT_NUMBER] OF EIGHT_BITS; FONT_GLUE : ARRAY [INTERNAL_FONT_NUMBER] OF HALFWORD; FONT_USED : ARRAY [INTERNAL_FONT_NUMBER] OF BOOLEAN; HYPHEN_CHAR : ARRAY [INTERNAL_FONT_NUMBER] OF INTEGER; SKEW_CHAR : ARRAY [INTERNAL_FONT_NUMBER] OF INTEGER; BCHAR_LABEL : ARRAY [INTERNAL_FONT_NUMBER] OF FONT_INDEX; FONT_BCHAR : ARRAY [INTERNAL_FONT_NUMBER] OF 0..256; FONT_FALSE_BCHAR : ARRAY [INTERNAL_FONT_NUMBER] OF 0..256; CHAR_BASE : ARRAY [INTERNAL_FONT_NUMBER] OF INTEGER; WIDTH_BASE : ARRAY [INTERNAL_FONT_NUMBER] OF INTEGER; HEIGHT_BASE : ARRAY [INTERNAL_FONT_NUMBER] OF INTEGER; DEPTH_BASE : ARRAY [INTERNAL_FONT_NUMBER] OF INTEGER; ITALIC_BASE : ARRAY [INTERNAL_FONT_NUMBER] OF INTEGER; LIG_KERN_BASE : ARRAY [INTERNAL_FONT_NUMBER] OF INTEGER; KERN_BASE : ARRAY [INTERNAL_FONT_NUMBER] OF INTEGER; EXTEN_BASE : ARRAY [INTERNAL_FONT_NUMBER] OF INTEGER; PARAM_BASE : ARRAY [INTERNAL_FONT_NUMBER] OF INTEGER; NULL_CHARACTER : FOUR_QUARTERS; TOTAL_PAGES : INTEGER; MAX_V : SCALED; MAX_H : SCALED; MAX_PUSH : INTEGER; LAST_BOP : INTEGER; DEAD_CYCLES : INTEGER; DOING_LEADERS : BOOLEAN; C : QUARTERWORD; F : QUARTERWORD; RULE_HT : SCALED; RULE_DP : SCALED; RULE_WD : SCALED; G : HALFWORD; LQ : INTEGER; LR : INTEGER; DVI_BUF : ARRAY [DVI_INDEX] OF EIGHT_BITS; HALF_BUF : DVI_INDEX; DVI_LIMIT : DVI_INDEX; DVI_PTR : DVI_INDEX; DVI_OFFSET : INTEGER; DVI_GONE : INTEGER; DOWN_PTR : HALFWORD; RIGHT_PTR : HALFWORD; DVI_H : SCALED; DVI_V : SCALED; CUR_H : SCALED; CUR_V : SCALED; DVI_F : INTERNAL_FONT_NUMBER; CUR_S : INTEGER; TOTAL_STRETCH : ARRAY [GLUE_ORD] OF SCALED; TOTAL_SHRINK : ARRAY [GLUE_ORD] OF SCALED; LAST_BADNESS : INTEGER; ADJUST_TAIL : HALFWORD; PACK_BEGIN_LINE : INTEGER; EMPTY_FIELD : TWO_HALVES; NULL_DELIMITER : FOUR_QUARTERS; CUR_MLIST : HALFWORD; CUR_STYLE : SMALL_NUMBER; CUR_SIZE : SMALL_NUMBER; CUR_MU : SCALED; MLIST_PENALTIES : BOOLEAN; CUR_F : INTERNAL_FONT_NUMBER; CUR_C : QUARTERWORD; CUR_I : FOUR_QUARTERS; MAGIC_OFFSET : INTEGER; CUR_ALIGN : HALFWORD; CUR_SPAN : HALFWORD; CUR_LOOP : HALFWORD; ALIGN_PTR : HALFWORD; CUR_HEAD : HALFWORD; CUR_TAIL : HALFWORD; JUST_BOX : HALFWORD; PASSIVE : HALFWORD; PRINTED_NODE : HALFWORD; PASS_NUMBER : HALFWORD; ACTIVE_WIDTH : ARRAY [1..6] OF SCALED; CUR_ACTIVE_WIDTH : ARRAY [1..6] OF SCALED; BACKGROUND : ARRAY [1..6] OF SCALED; BREAK_WIDTH : ARRAY [1..6] OF SCALED; NO_SHRINK_ERROR_YET : BOOLEAN; CUR_P : HALFWORD; SECOND_PASS : BOOLEAN; FINAL_PASS : BOOLEAN; THRESHOLD : INTEGER; MINIMAL_DEMERITS : ARRAY [0..3] OF INTEGER; MINIMUM_DEMERITS : INTEGER; BEST_PLACE : ARRAY [0..3] OF HALFWORD; BEST_PL_LINE : ARRAY [0..3] OF HALFWORD; DISC_WIDTH : SCALED; EASY_LINE : HALFWORD; LAST_SPECIAL_LINE : HALFWORD; FIRST_WIDTH : SCALED; SECOND_WIDTH : SCALED; FIRST_INDENT : SCALED; SECOND_INDENT : SCALED; BEST_BET : HALFWORD; FEWEST_DEMERITS : INTEGER; BEST_LINE : HALFWORD; ACTUAL_LOOSENESS : INTEGER; LINE_DIFF : INTEGER; HC : ARRAY [0..65] OF 0..256; HN : 0..64; HA : HALFWORD; HB : HALFWORD; HF : INTERNAL_FONT_NUMBER; HU : ARRAY [0..63] OF 0..256; HYF_CHAR : INTEGER; CUR_LANG : ASCII_CODE; INIT_CUR_LANG : ASCII_CODE; L_HYF : INTEGER; R_HYF : INTEGER; INIT_L_HYF : INTEGER; INIT_R_HYF : INTEGER; HYF_BCHAR : HALFWORD; HYF : ARRAY [0..64] OF 0..9; INIT_LIST : HALFWORD; INIT_LIG : BOOLEAN; INIT_LFT : BOOLEAN; HYPHEN_PASSED : SMALL_NUMBER; CUR_L : HALFWORD; CUR_R : HALFWORD; CUR_Q : HALFWORD; LIG_STACK : HALFWORD; LIGATURE_PRESENT : BOOLEAN; LFT_HIT : BOOLEAN; RT_HIT : BOOLEAN; TRIE : ARRAY [TRIE_POINTER] OF TWO_HALVES; HYF_DISTANCE : ARRAY [1..TRIE_OP_SIZE] OF SMALL_NUMBER; HYF_NUM : ARRAY [1..TRIE_OP_SIZE] OF SMALL_NUMBER; HYF_NEXT : ARRAY [1..TRIE_OP_SIZE] OF QUARTERWORD; OP_START : ARRAY [ASCII_CODE] OF 0..TRIE_OP_SIZE; HYPH_WORD : ARRAY [HYPH_POINTER] OF STR_NUMBER; HYPH_LIST : ARRAY [HYPH_POINTER] OF HALFWORD; HYPH_COUNT : HYPH_POINTER; TRIE_OP_HASH : ARRAY [-TRIE_OP_SIZE..TRIE_OP_SIZE] OF 0..TRIE_OP_SIZE; TRIE_USED : ARRAY [ASCII_CODE] OF QUARTERWORD; TRIE_OP_LANG : ARRAY [1..TRIE_OP_SIZE] OF ASCII_CODE; TRIE_OP_VAL : ARRAY [1..TRIE_OP_SIZE] OF QUARTERWORD; TRIE_OP_PTR : 0..TRIE_OP_SIZE; TRIE_C : PACKED ARRAY [TRIE_POINTER] OF PACKED_ASCII_CODE; TRIE_O : PACKED ARRAY [TRIE_POINTER] OF QUARTERWORD; TRIE_L : PACKED ARRAY [TRIE_POINTER] OF TRIE_POINTER; TRIE_R : PACKED ARRAY [TRIE_POINTER] OF TRIE_POINTER; TRIE_PTR : TRIE_POINTER; TRIE_HASH : PACKED ARRAY [TRIE_POINTER] OF TRIE_POINTER; TRIE_TAKEN : PACKED ARRAY [1..TRIE_SIZE] OF BOOLEAN; TRIE_MIN : ARRAY [ASCII_CODE] OF TRIE_POINTER; TRIE_MAX : TRIE_POINTER; TRIE_NOT_READY : BOOLEAN; BEST_HEIGHT_PLUS_DEPTH : SCALED; PAGE_TAIL : HALFWORD; PAGE_CONTENTS : 0..2; PAGE_MAX_DEPTH : SCALED; BEST_PAGE_BREAK : HALFWORD; LEAST_PAGE_COST : INTEGER; BEST_SIZE : SCALED; PAGE_SO_FAR : ARRAY [0..7] OF SCALED; LAST_GLUE : HALFWORD; LAST_PENALTY : INTEGER; LAST_KERN : SCALED; INSERT_PENALTIES : INTEGER; OUTPUT_ACTIVE : BOOLEAN; MAIN_F : INTERNAL_FONT_NUMBER; MAIN_I : FOUR_QUARTERS; MAIN_J : FOUR_QUARTERS; MAIN_K : FONT_INDEX; MAIN_P : HALFWORD; MAIN_S : INTEGER; BCHAR : HALFWORD; FALSE_BCHAR : HALFWORD; CANCEL_BOUNDARY : BOOLEAN; INS_DISC : BOOLEAN; CUR_BOX : HALFWORD; AFTER_TOKEN : HALFWORD; LONG_HELP_SEEN : BOOLEAN; FORMAT_IDENT : STR_NUMBER; FMT_FILE : WORD_FILE; READY_ALREADY : INTEGER; WRITE_FILE : ARRAY [0..15] OF ALPHA_FILE; WRITE_OPEN : ARRAY [0..17] OF BOOLEAN; WRITE_LOC : HALFWORD; PROCEDURE INITIALIZE; VAR I : INTEGER; K : INTEGER; Z : HYPH_POINTER; BEGIN XCHR[32] ← ' '; XCHR[33] ← '!'; XCHR[34] ← '"'; XCHR[35] ← '#'; XCHR[36] ← '$'; XCHR[37] ← '%'; XCHR[38] ← '&'; XCHR[39] ← ''''; XCHR[40] ← '('; XCHR[41] ← ')'; XCHR[42] ← '*'; XCHR[43] ← '+'; XCHR[44] ← ','; XCHR[45] ← '-'; XCHR[46] ← '.'; XCHR[47] ← '/'; XCHR[48] ← '0'; XCHR[49] ← '1'; XCHR[50] ← '2'; XCHR[51] ← '3'; XCHR[52] ← '4'; XCHR[53] ← '5'; XCHR[54] ← '6'; XCHR[55] ← '7'; XCHR[56] ← '8'; XCHR[57] ← '9'; XCHR[58] ← ':'; XCHR[59] ← ';'; XCHR[60] ← '<'; XCHR[61] ← '='; XCHR[62] ← '>'; XCHR[63] ← '?'; XCHR[64] ← '@'; XCHR[65] ← 'A'; XCHR[66] ← 'B'; XCHR[67] ← 'C'; XCHR[68] ← 'D'; XCHR[69] ← 'E'; XCHR[70] ← 'F'; XCHR[71] ← 'G'; XCHR[72] ← 'H'; XCHR[73] ← 'I'; XCHR[74] ← 'J'; XCHR[75] ← 'K'; XCHR[76] ← 'L'; XCHR[77] ← 'M'; XCHR[78] ← 'N'; XCHR[79] ← 'O'; XCHR[80] ← 'P'; XCHR[81] ← 'Q'; XCHR[82] ← 'R'; XCHR[83] ← 'S'; XCHR[84] ← 'T'; XCHR[85] ← 'U'; XCHR[86] ← 'V'; XCHR[87] ← 'W'; XCHR[88] ← 'X'; XCHR[89] ← 'Y'; XCHR[90] ← 'Z'; XCHR[91] ← '['; XCHR[92] ← '\'; XCHR[93] ← ']'; XCHR[94] ← '^'; XCHR[95] ← '_'; XCHR[96] ← '`'; XCHR[97] ← 'a'; XCHR[98] ← 'b'; XCHR[99] ← 'c'; XCHR[100] ← 'd'; XCHR[101] ← 'e'; XCHR[102] ← 'f'; XCHR[103] ← 'g'; XCHR[104] ← 'h'; XCHR[105] ← 'i'; XCHR[106] ← 'j'; XCHR[107] ← 'k'; XCHR[108] ← 'l'; XCHR[109] ← 'm'; XCHR[110] ← 'n'; XCHR[111] ← 'o'; XCHR[112] ← 'p'; XCHR[113] ← 'q'; XCHR[114] ← 'r'; XCHR[115] ← 's'; XCHR[116] ← 't'; XCHR[117] ← 'u'; XCHR[118] ← 'v'; XCHR[119] ← 'w'; XCHR[120] ← 'x'; XCHR[121] ← 'y'; XCHR[122] ← 'z'; XCHR[123] ← '{'; XCHR[124] ← '|'; XCHR[125] ← '}'; XCHR[126] ← '~'; FOR I ← 0 TO 31 DO XCHR[I] ← ' '; FOR I ← 127 TO 255 DO XCHR[I] ← ' '; FOR I ← 0 TO 255 DO XORD[CHR (I)] ← 127; FOR I ← 128 TO 255 DO XORD[XCHR[I]] ← I; FOR I ← 0 TO 126 DO XORD[XCHR[I]] ← I; XORD[CHR (9)] ← 32; XORD[CHR (12)] ← 32; XCHR[9] ← CHR (32); XCHR[12] ← CHR (32); INTERACTION ← 3; DELETIONS_ALLOWED ← TRUE; SET_BOX_ALLOWED ← TRUE; ERROR_COUNT ← 0; HELP_PTR ← 0; USE_ERR_HELP ← FALSE; INTERRUPT ← 0; OK_TO_INTERRUPT ← TRUE; NEST_PTR ← 0; MAX_NEST_STACK ← 0; CUR_LIST.MODE_FIELD ← 1; CUR_LIST.HEAD_FIELD ← 59999; CUR_LIST.TAIL_FIELD ← 59999; CUR_LIST.AUX_FIELD.INT ← -65536000; CUR_LIST.ML_FIELD ← 0; CUR_LIST.PG_FIELD ← 0; SHOWN_MODE ← 0; PAGE_CONTENTS ← 0; PAGE_TAIL ← 59998; MEM[59998].HH.RH ← 0; LAST_GLUE ← 65535; LAST_PENALTY ← 0; LAST_KERN ← 0; PAGE_SO_FAR[7] ← 0; PAGE_MAX_DEPTH ← 0; FOR K ← 9163 TO 10006 DO XEQ_LEVEL[K] ← 1; NO_NEW_CONTROL_SEQUENCE ← TRUE; HASH[514].LH ← 0; HASH[514].RH ← 0; FOR K ← 515 TO 6780 DO HASH[K] ← HASH[514]; SAVE_PTR ← 0; CUR_LEVEL ← 1; CUR_GROUP ← 0; CUR_BOUNDARY ← 0; MAX_SAVE_STACK ← 0; MAG_SET ← 0; CUR_MARK[0] ← 0; CUR_MARK[1] ← 0; CUR_MARK[2] ← 0; CUR_MARK[3] ← 0; CUR_MARK[4] ← 0; CUR_VAL ← 0; CUR_VAL_LEVEL ← 0; RADIX ← 0; CUR_ORDER ← 0; FOR K ← 0 TO 16 DO READ_OPEN[K] ← 2; COND_PTR ← 0; IF_LIMIT ← 0; CUR_IF ← 0; IF_LINE ← 0; TEX_FORMAT_DEFAULT ← 'TeXformats:plain.fmt'; FOR K ← 0 TO FONT_MAX DO FONT_USED[K] ← FALSE; NULL_CHARACTER.B0 ← 0; NULL_CHARACTER.B1 ← 0; NULL_CHARACTER.B2 ← 0; NULL_CHARACTER.B3 ← 0; TOTAL_PAGES ← 0; MAX_V ← 0; MAX_H ← 0; MAX_PUSH ← 0; LAST_BOP ← -1; DOING_LEADERS ← FALSE; DEAD_CYCLES ← 0; CUR_S ← -1; HALF_BUF ← DVI_BUF_SIZE DIV 2; DVI_LIMIT ← DVI_BUF_SIZE; DVI_PTR ← 0; DVI_OFFSET ← 0; DVI_GONE ← 0; DOWN_PTR ← 0; RIGHT_PTR ← 0; ADJUST_TAIL ← 0; LAST_BADNESS ← 0; PACK_BEGIN_LINE ← 0; EMPTY_FIELD.RH ← 0; EMPTY_FIELD.LH ← 0; NULL_DELIMITER.B0 ← 0; NULL_DELIMITER.B1 ← 0; NULL_DELIMITER.B2 ← 0; NULL_DELIMITER.B3 ← 0; ALIGN_PTR ← 0; CUR_ALIGN ← 0; CUR_SPAN ← 0; CUR_LOOP ← 0; CUR_HEAD ← 0; CUR_TAIL ← 0; FOR Z ← 0 TO 307 DO BEGIN HYPH_WORD[Z] ← 0; HYPH_LIST[Z] ← 0 END; HYPH_COUNT ← 0; OUTPUT_ACTIVE ← FALSE; INSERT_PENALTIES ← 0; LIGATURE_PRESENT ← FALSE; CANCEL_BOUNDARY ← FALSE; LFT_HIT ← FALSE; RT_HIT ← FALSE; INS_DISC ← FALSE; AFTER_TOKEN ← 0; LONG_HELP_SEEN ← FALSE; FORMAT_IDENT ← 0; FOR K ← 0 TO 17 DO WRITE_OPEN[K] ← FALSE; FOR K ← 1 TO 19 DO MEM[K].INT ← 0; K ← 0; WHILE K ≤ 19 DO BEGIN MEM[K].HH.RH ← 1; MEM[K].HH.B0 ← 0; MEM[K].HH.B1 ← 0; K ← K + 4 END; MEM[6].INT ← 65536; MEM[4].HH.B0 ← 1; MEM[10].INT ← 65536; MEM[8].HH.B0 ← 2; MEM[14].INT ← 65536; MEM[12].HH.B0 ← 1; MEM[15].INT ← 65536; MEM[12].HH.B1 ← 1; MEM[18].INT ← -65536; MEM[16].HH.B0 ← 1; ROVER ← 20; MEM[ROVER].HH.RH ← 65535; MEM[ROVER].HH.LH ← 1000; MEM[ROVER + 1].HH.LH ← ROVER; MEM[ROVER + 1].HH.RH ← ROVER; LO_MEM_MAX ← ROVER + 1000; MEM[LO_MEM_MAX].HH.RH ← 0; MEM[LO_MEM_MAX].HH.LH ← 0; FOR K ← 59987 TO 60000 DO MEM[K] ← MEM[LO_MEM_MAX]; MEM[59990].HH.LH ← 10614; MEM[59991].HH.RH ← 256; MEM[59991].HH.LH ← 0; MEM[59993].HH.B0 ← 1; MEM[59994].HH.LH ← 65535; MEM[59993].HH.B1 ← 0; MEM[60000].HH.B1 ← 255; MEM[60000].HH.B0 ← 1; MEM[60000].HH.RH ← 60000; MEM[59998].HH.B0 ← 10; MEM[59998].HH.B1 ← 0; AVAIL ← 0; MEM_END ← 60000; HI_MEM_MIN ← 59987; VAR_USED ← 20; DYN_USED ← 14; EQTB[6781].HH.B0 ← 101; EQTB[6781].HH.RH ← 0; EQTB[6781].HH.B1 ← 0; FOR K ← 1 TO 6780 DO EQTB[K] ← EQTB[6781]; EQTB[6782].HH.RH ← 0; EQTB[6782].HH.B1 ← 1; EQTB[6782].HH.B0 ← 117; FOR K ← 6783 TO 7311 DO EQTB[K] ← EQTB[6782]; MEM[0].HH.RH ← MEM[0].HH.RH + 530; EQTB[7312].HH.RH ← 0; EQTB[7312].HH.B0 ← 118; EQTB[7312].HH.B1 ← 1; FOR K ← 7313 TO 7577 DO EQTB[K] ← EQTB[6781]; EQTB[7578].HH.RH ← 0; EQTB[7578].HH.B0 ← 119; EQTB[7578].HH.B1 ← 1; FOR K ← 7579 TO 7833 DO EQTB[K] ← EQTB[7578]; EQTB[7834].HH.RH ← 0; EQTB[7834].HH.B0 ← 120; EQTB[7834].HH.B1 ← 1; FOR K ← 7835 TO 7882 DO EQTB[K] ← EQTB[7834]; EQTB[7883].HH.RH ← 0; EQTB[7883].HH.B0 ← 120; EQTB[7883].HH.B1 ← 1; FOR K ← 7884 TO 9162 DO EQTB[K] ← EQTB[7883]; FOR K ← 0 TO 255 DO BEGIN EQTB[7883 + K].HH.RH ← 12; EQTB[8907 + K].HH.RH ← K + 0; EQTB[8651 + K].HH.RH ← 1000 END; EQTB[7896].HH.RH ← 5; EQTB[7915].HH.RH ← 10; EQTB[7975].HH.RH ← 0; EQTB[7920].HH.RH ← 14; EQTB[8010].HH.RH ← 15; EQTB[7883].HH.RH ← 9; FOR K ← 48 TO 57 DO EQTB[8907 + K].HH.RH ← K + 28672; FOR K ← 65 TO 90 DO BEGIN EQTB[7883 + K].HH.RH ← 11; EQTB[7883 + K + 32].HH.RH ← 11; EQTB[8907 + K].HH.RH ← K + 28928; EQTB[8907 + K + 32].HH.RH ← K + 28960; EQTB[8139 + K].HH.RH ← K + 32; EQTB[8139 + K + 32].HH.RH ← K + 32; EQTB[8395 + K].HH.RH ← K; EQTB[8395 + K + 32].HH.RH ← K; EQTB[8651 + K].HH.RH ← 999 END; FOR K ← 9163 TO 9473 DO EQTB[K].INT ← 0; EQTB[9180].INT ← 1000; EQTB[9164].INT ← 10000; EQTB[9204].INT ← 1; EQTB[9203].INT ← 25; EQTB[9208].INT ← 92; EQTB[9211].INT ← 13; FOR K ← 0 TO 255 DO EQTB[9474 + K].INT ← -1; EQTB[9520].INT ← 0; FOR K ← 9730 TO 10006 DO EQTB[K].INT ← 0; HASH_USED ← 6514; CS_COUNT ← 0; EQTB[6523].HH.B0 ← 116; HASH[6523].RH ← 502; FONT_PTR ← 0; FMEM_PTR ← 7; FONT_NAME[0] ← 801; FONT_AREA[0] ← 338; HYPHEN_CHAR[0] ← 45; SKEW_CHAR[0] ← -1; BCHAR_LABEL[0] ← 0; FONT_BCHAR[0] ← 256; FONT_FALSE_BCHAR[0] ← 256; FONT_BC[0] ← 1; FONT_EC[0] ← 0; FONT_SIZE[0] ← 0; FONT_DSIZE[0] ← 0; CHAR_BASE[0] ← 0; WIDTH_BASE[0] ← 0; HEIGHT_BASE[0] ← 0; DEPTH_BASE[0] ← 0; ITALIC_BASE[0] ← 0; LIG_KERN_BASE[0] ← 0; KERN_BASE[0] ← 0; EXTEN_BASE[0] ← 0; FONT_GLUE[0] ← 0; FONT_PARAMS[0] ← 7; PARAM_BASE[0] ← -1; FOR K ← 0 TO 6 DO FONT_INFO[K].INT ← 0; FOR K ← -TRIE_OP_SIZE TO TRIE_OP_SIZE DO TRIE_OP_HASH[K] ← 0; FOR K ← 0 TO 255 DO TRIE_USED[K] ← 0; TRIE_OP_PTR ← 0; TRIE_NOT_READY ← TRUE; TRIE_L[0] ← 0; TRIE_C[0] ← 0; TRIE_PTR ← 0; HASH[6514].RH ← 1190; FORMAT_IDENT ← 1257; HASH[6522].RH ← 1296; EQTB[6522].HH.B1 ← 1; EQTB[6522].HH.B0 ← 113; EQTB[6522].HH.RH ← 0 END; PROCEDURE PRINT_LN; BEGIN CASE SELECTOR OF 19: BEGIN WRITELN (TERM_OUT); WRITELN (LOG_FILE); TERM_OFFSET ← 0; FILE_OFFSET ← 0 END; 18: BEGIN WRITELN (LOG_FILE); FILE_OFFSET ← 0 END; 17: BEGIN WRITELN (TERM_OUT); TERM_OFFSET ← 0 END; 16,20,21: ; ELSE WRITELN (WRITE_FILE[SELECTOR]); END END; PROCEDURE PRINT_CHAR (S:ASCII_CODE); LABEL 10; BEGIN IF S = EQTB[9212].INT THEN IF SELECTOR < 20 THEN BEGIN PRINT_LN; GOTO 10 END; CASE SELECTOR OF 19: BEGIN WRITE (TERM_OUT, XCHR[S]); WRITE (LOG_FILE, XCHR[S]); TERM_OFFSET ← TERM_OFFSET + 1; FILE_OFFSET ← FILE_OFFSET + 1; IF TERM_OFFSET = MAX_PRINT_LINE THEN BEGIN WRITELN (TERM_OUT); TERM_OFFSET ← 0 END; IF FILE_OFFSET = MAX_PRINT_LINE THEN BEGIN WRITELN (LOG_FILE); FILE_OFFSET ← 0 END END; 18: BEGIN WRITE (LOG_FILE, XCHR[S]); FILE_OFFSET ← FILE_OFFSET + 1; IF FILE_OFFSET = MAX_PRINT_LINE THEN PRINT_LN END; 17: BEGIN WRITE (TERM_OUT, XCHR[S]); TERM_OFFSET ← TERM_OFFSET + 1; IF TERM_OFFSET = MAX_PRINT_LINE THEN PRINT_LN END; 16: ; 20: IF TALLY < TRICK_COUNT THEN TRICK_BUF[TALLY MOD ERROR_LINE] ← S; 21: BEGIN IF POOL_PTR < POOL_SIZE THEN BEGIN STR_POOL[POOL_PTR] ← S; POOL_PTR ← POOL_PTR + 1 END END; ELSE WRITE (WRITE_FILE[SELECTOR], XCHR[S]); END; TALLY ← TALLY + 1; 10: END; PROCEDURE PRINT (S:INTEGER); LABEL 10; VAR J : POOL_POINTER; NL : INTEGER; BEGIN IF S ≥ STR_PTR THEN S ← 259 ELSE IF S < 256 THEN IF S < 0 THEN S ← 259 ELSE BEGIN IF SELECTOR > 20 THEN BEGIN PRINT_CHAR (S); GOTO 10 END; IF S = EQTB[9212].INT THEN IF SELECTOR < 20 THEN BEGIN PRINT_LN; GOTO 10 END; NL ← EQTB[9212].INT; EQTB[9212].INT ← -1; J ← STR_START[S]; WHILE J < STR_START[S + 1] DO BEGIN PRINT_CHAR (STR_POOL[J]); J ← J + 1 END; EQTB[9212].INT ← NL; GOTO 10 END; J ← STR_START[S]; WHILE J < STR_START[S + 1] DO BEGIN PRINT_CHAR (STR_POOL[J]); J ← J + 1 END; 10: END; PROCEDURE SLOW_PRINT (S:INTEGER); VAR J : POOL_POINTER; BEGIN IF (S ≥ STR_PTR) OR (S < 256) THEN PRINT (S) ELSE BEGIN J ← STR_START[S]; WHILE J < STR_START[S + 1] DO BEGIN PRINT (STR_POOL[J]); J ← J + 1 END END END; PROCEDURE PRINT_NL (S:STR_NUMBER); BEGIN IF (TERM_OFFSET > 0) AND ODD (SELECTOR) OR (FILE_OFFSET > 0) AND (SELECTOR ≥ 18) THEN PRINT_LN; PRINT (S) END; PROCEDURE PRINT_ESC (S:STR_NUMBER); VAR C : INTEGER; BEGIN C ← EQTB[9208].INT; IF C ≥ 0 THEN IF C < 256 THEN PRINT (C); SLOW_PRINT (S) END; PROCEDURE PRINT_THE_DIGS (K:EIGHT_BITS); BEGIN WHILE K > 0 DO BEGIN K ← K - 1; IF DIG[K] < 10 THEN PRINT_CHAR (48 + DIG[K]) ELSE PRINT_CHAR (55 + DIG[K]) END END; PROCEDURE PRINT_INT (N:INTEGER); VAR K : 0..23; M : INTEGER; BEGIN K ← 0; IF N < 0 THEN BEGIN PRINT_CHAR (45); IF N > -100000000 THEN N ← -N ELSE BEGIN M ← -1 - N; N ← M DIV 10; M ← M MOD 10 + 1; K ← 1; IF M < 10 THEN DIG[0] ← M ELSE BEGIN DIG[0] ← 0; N ← N + 1 END END END; REPEAT DIG[K] ← N MOD 10; N ← N DIV 10; K ← K + 1 UNTIL N = 0; PRINT_THE_DIGS (K) END; PROCEDURE PRINT_CS (P:INTEGER); BEGIN IF P < 514 THEN IF P ≥ 257 THEN IF P = 513 THEN BEGIN PRINT_ESC (504); PRINT_ESC (505); PRINT_CHAR (32) END ELSE BEGIN PRINT_ESC (P - 257); IF EQTB[7883 + P - 257].HH.RH = 11 THEN PRINT_CHAR (32) END ELSE IF P < 1 THEN PRINT_ESC (506) ELSE PRINT (P - 1) ELSE IF P ≥ 6781 THEN PRINT_ESC (506) ELSE IF (HASH[P].RH < 0) OR (HASH[P].RH ≥ STR_PTR) THEN PRINT_ESC (507) ELSE BEGIN PRINT_ESC (HASH[P].RH); PRINT_CHAR (32) END END; PROCEDURE SPRINT_CS (P:HALFWORD); BEGIN IF P < 514 THEN IF P < 257 THEN PRINT (P - 1) ELSE IF P < 513 THEN PRINT_ESC (P - 257) ELSE BEGIN PRINT_ESC (504); PRINT_ESC (505) END ELSE PRINT_ESC (HASH[P].RH) END; PROCEDURE PRINT_FILE_NAME (N:INTEGER; A:INTEGER; E:INTEGER); BEGIN SLOW_PRINT (A); SLOW_PRINT (N); SLOW_PRINT (E) END; PROCEDURE PRINT_SIZE (S:INTEGER); BEGIN IF S = 0 THEN PRINT_ESC (412) ELSE IF S = 16 THEN PRINT_ESC (413) ELSE PRINT_ESC (414) END; PROCEDURE PRINT_WRITE_WHATSIT (S:STR_NUMBER; P:HALFWORD); BEGIN PRINT_ESC (S); IF MEM[P + 1].HH.LH < 16 THEN PRINT_INT (MEM[P + 1].HH.LH) ELSE IF MEM[P + 1].HH.LH = 16 THEN PRINT_CHAR (42) ELSE PRINT_CHAR (45) END; PROCEDURE NORMALIZE_SELECTOR; FORWARD; PROCEDURE GET_TOKEN; FORWARD; PROCEDURE TERM_INPUT; FORWARD; PROCEDURE SHOW_CONTEXT; FORWARD; PROCEDURE BEGIN_FILE_READING; FORWARD; PROCEDURE OPEN_LOG_FILE; FORWARD; PROCEDURE CLOSE_FILES_AND_TERMINATE; FORWARD; PROCEDURE CLEAR_FOR_ERROR_PROMPT; FORWARD; PROCEDURE GIVE_ERR_HELP; FORWARD; PROCEDURE JUMP_OUT; BEGIN GOTO 9998 END; PROCEDURE ERROR; LABEL 22, 10; VAR C : ASCII_CODE; S1 : INTEGER; S2 : INTEGER; S3 : INTEGER; S4 : INTEGER; BEGIN IF HISTORY < 2 THEN HISTORY ← 2; PRINT_CHAR (46); SHOW_CONTEXT; IF INTERACTION = 3 THEN WHILE TRUE DO BEGIN 22: IF INTERACTION ≠ 3 THEN GOTO 10; CLEAR_FOR_ERROR_PROMPT; BEGIN PRINT (264); TERM_INPUT END; IF LAST = FIRST THEN GOTO 10; C ← BUFFER[FIRST]; IF C ≥ 97 THEN C ← C - 32; CASE C OF 48,49,50,51,52,53,54,55,56, 57: IF DELETIONS_ALLOWED THEN BEGIN S1 ← CUR_TOK; S2 ← CUR_CMD; S3 ← CUR_CHR; S4 ← ALIGN_STATE; ALIGN_STATE ← 1000000; OK_TO_INTERRUPT ← FALSE; IF (LAST > FIRST + 1) AND (BUFFER[FIRST + 1] ≥ 48) AND (BUFFER[FIRST + 1] ≤ 57) THEN C ← C * 10 + BUFFER[FIRST + 1] - 48 * 11 ELSE C ← C - 48; WHILE C > 0 DO BEGIN GET_TOKEN; C ← C - 1 END; CUR_TOK ← S1; CUR_CMD ← S2; CUR_CHR ← S3; ALIGN_STATE ← S4; OK_TO_INTERRUPT ← TRUE; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 279; HELP_LINE[0] ← 280 END; SHOW_CONTEXT; GOTO 22 END; 69: IF BASE_PTR > 0 THEN IF INPUT_STACK[BASE_PTR].NAME_FIELD ≥ 256 THEN BEGIN PRINT_NL (265); SLOW_PRINT (INPUT_STACK[BASE_PTR].NAME_FIELD); PRINT (266); PRINT_INT (LINE); INTERACTION ← 2; JUMP_OUT END; 72: BEGIN IF USE_ERR_HELP THEN BEGIN GIVE_ERR_HELP; USE_ERR_HELP ← FALSE END ELSE BEGIN IF HELP_PTR = 0 THEN BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 281; HELP_LINE[0] ← 282 END; REPEAT HELP_PTR ← HELP_PTR - 1; PRINT (HELP_LINE[HELP_PTR]); PRINT_LN UNTIL HELP_PTR = 0 END; BEGIN HELP_PTR ← 4; HELP_LINE[3] ← 283; HELP_LINE[2] ← 282; HELP_LINE[1] ← 284; HELP_LINE[0] ← 285 END; GOTO 22 END; 73: BEGIN BEGIN_FILE_READING; IF LAST > FIRST + 1 THEN BEGIN CUR_INPUT.LOC_FIELD ← FIRST + 1; BUFFER[FIRST] ← 32 END ELSE BEGIN BEGIN PRINT (278); TERM_INPUT END; CUR_INPUT.LOC_FIELD ← FIRST END; FIRST ← LAST; CUR_INPUT.LIMIT_FIELD ← LAST - 1; GOTO 10 END; 81,82, 83: BEGIN ERROR_COUNT ← 0; INTERACTION ← 0 + C - 81; PRINT (273); CASE C OF 81: BEGIN PRINT_ESC (274); SELECTOR ← SELECTOR - 1 END; 82: PRINT_ESC (275); 83: PRINT_ESC (276); END; PRINT (277); PRINT_LN; BREAK (TERM_OUT); GOTO 10 END; 88: BEGIN INTERACTION ← 2; JUMP_OUT END; ELSE ; END; BEGIN PRINT (267); PRINT_NL (268); PRINT_NL (269); IF BASE_PTR > 0 THEN IF INPUT_STACK[BASE_PTR].NAME_FIELD ≥ 256 THEN PRINT (270); IF DELETIONS_ALLOWED THEN PRINT_NL (271); PRINT_NL (272) END END; ERROR_COUNT ← ERROR_COUNT + 1; IF ERROR_COUNT = 100 THEN BEGIN PRINT_NL (263); HISTORY ← 3; JUMP_OUT END; IF INTERACTION > 0 THEN SELECTOR ← SELECTOR - 1; IF USE_ERR_HELP THEN BEGIN PRINT_LN; GIVE_ERR_HELP END ELSE WHILE HELP_PTR > 0 DO BEGIN HELP_PTR ← HELP_PTR - 1; PRINT_NL (HELP_LINE[HELP_PTR]) END; PRINT_LN; IF INTERACTION > 0 THEN SELECTOR ← SELECTOR + 1; PRINT_LN; 10: END; PROCEDURE FATAL_ERROR (S:STR_NUMBER); BEGIN NORMALIZE_SELECTOR; BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (287) END; BEGIN HELP_PTR ← 1; HELP_LINE[0] ← S END; BEGIN IF INTERACTION = 3 THEN INTERACTION ← 2; IF LOG_OPENED THEN ERROR; HISTORY ← 3; JUMP_OUT END END; PROCEDURE OVERFLOW (S:STR_NUMBER; N:INTEGER); BEGIN NORMALIZE_SELECTOR; BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (288) END; PRINT (S); PRINT_CHAR (61); PRINT_INT (N); PRINT_CHAR (93); BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 289; HELP_LINE[0] ← 290 END; BEGIN IF INTERACTION = 3 THEN INTERACTION ← 2; IF LOG_OPENED THEN ERROR; HISTORY ← 3; JUMP_OUT END END; PROCEDURE CONFUSION (S:STR_NUMBER); BEGIN NORMALIZE_SELECTOR; IF HISTORY < 2 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (291) END; PRINT (S); PRINT_CHAR (41); BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 292 END END ELSE BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (293) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 294; HELP_LINE[0] ← 295 END END; BEGIN IF INTERACTION = 3 THEN INTERACTION ← 2; IF LOG_OPENED THEN ERROR; HISTORY ← 3; JUMP_OUT END END; FUNCTION A_OPEN_IN (VAR F:ALPHA_FILE):BOOLEAN; BEGIN RESET (F, NAME_OF_FILE, '/O'); A_OPEN_IN ← ERSTAT (F) = 0 END; FUNCTION A_OPEN_OUT (VAR F:ALPHA_FILE):BOOLEAN; BEGIN REWRITE (F, NAME_OF_FILE, '/O'); A_OPEN_OUT ← ERSTAT (F) = 0 END; FUNCTION B_OPEN_IN (VAR F:BYTE_FILE):BOOLEAN; BEGIN RESET (F, NAME_OF_FILE, '/O'); B_OPEN_IN ← ERSTAT (F) = 0 END; FUNCTION B_OPEN_OUT (VAR F:BYTE_FILE):BOOLEAN; BEGIN REWRITE (F, NAME_OF_FILE, '/O'); B_OPEN_OUT ← ERSTAT (F) = 0 END; FUNCTION W_OPEN_IN (VAR F:WORD_FILE):BOOLEAN; BEGIN RESET (F, NAME_OF_FILE, '/O'); W_OPEN_IN ← ERSTAT (F) = 0 END; FUNCTION W_OPEN_OUT (VAR F:WORD_FILE):BOOLEAN; BEGIN REWRITE (F, NAME_OF_FILE, '/O'); W_OPEN_OUT ← ERSTAT (F) = 0 END; PROCEDURE A_CLOSE (VAR F:ALPHA_FILE); BEGIN CLOSE (F) END; PROCEDURE B_CLOSE (VAR F:BYTE_FILE); BEGIN CLOSE (F) END; PROCEDURE W_CLOSE (VAR F:WORD_FILE); BEGIN CLOSE (F) END; FUNCTION INPUT_LN (VAR F:ALPHA_FILE; BYPASS_EOLN:BOOLEAN):BOOLEAN; VAR LAST_NONBLANK : 0..BUF_SIZE; BEGIN IF BYPASS_EOLN THEN IF NOT EOF (F) THEN GET (F); LAST ← FIRST; IF EOF (F) THEN INPUT_LN ← FALSE ELSE BEGIN LAST_NONBLANK ← FIRST; WHILE NOT EOLN (F) DO BEGIN IF LAST ≥ MAX_BUF_STACK THEN BEGIN MAX_BUF_STACK ← LAST + 1; IF MAX_BUF_STACK = BUF_SIZE THEN IF FORMAT_IDENT = 0 THEN BEGIN WRITELN (TERM_OUT, 'Buffer size exceeded!'); GOTO 9999 END ELSE BEGIN CUR_INPUT.LOC_FIELD ← FIRST; CUR_INPUT.LIMIT_FIELD ← LAST - 1; OVERFLOW (256, BUF_SIZE) END END; BUFFER[LAST] ← XORD[F↑]; GET (F); LAST ← LAST + 1; IF BUFFER[LAST - 1] ≠ 32 THEN LAST_NONBLANK ← LAST END; LAST ← LAST_NONBLANK; INPUT_LN ← TRUE END END; FUNCTION INIT_TERMINAL:BOOLEAN; LABEL 10; BEGIN RESET (TERM_IN, 'TTY:', '/O/I'); WHILE TRUE DO BEGIN WRITE (TERM_OUT, '**'); BREAK (TERM_OUT); IF NOT INPUT_LN (TERM_IN, TRUE) THEN BEGIN WRITELN (TERM_OUT); WRITE (TERM_OUT, '! End of file on the terminal... why?'); INIT_TERMINAL ← FALSE; GOTO 10 END; CUR_INPUT.LOC_FIELD ← FIRST; WHILE (CUR_INPUT.LOC_FIELD < LAST) AND (BUFFER[CUR_INPUT.LOC_FIELD] = 32) DO CUR_INPUT.LOC_FIELD ← CUR_INPUT.LOC_FIELD + 1; IF CUR_INPUT.LOC_FIELD < LAST THEN BEGIN INIT_TERMINAL ← TRUE; GOTO 10 END; WRITELN (TERM_OUT, 'Please type the name of your input file.') END; 10: END; FUNCTION MAKE_STRING:STR_NUMBER; BEGIN IF STR_PTR = MAX_STRINGS THEN OVERFLOW (258, MAX_STRINGS - INIT_STR_PTR); STR_PTR ← STR_PTR + 1; STR_START[STR_PTR] ← POOL_PTR; MAKE_STRING ← STR_PTR - 1 END; FUNCTION STR_EQ_BUF (S:STR_NUMBER; K:INTEGER):BOOLEAN; LABEL 45; VAR J : POOL_POINTER; RESULT : BOOLEAN; BEGIN J ← STR_START[S]; WHILE J < STR_START[S + 1] DO BEGIN IF STR_POOL[J] ≠ BUFFER[K] THEN BEGIN RESULT ← FALSE; GOTO 45 END; J ← J + 1; K ← K + 1 END; RESULT ← TRUE; 45: STR_EQ_BUF ← RESULT END; FUNCTION STR_EQ_STR (S:STR_NUMBER; T:STR_NUMBER):BOOLEAN; LABEL 45; VAR J : POOL_POINTER; K : POOL_POINTER; RESULT : BOOLEAN; BEGIN RESULT ← FALSE; IF STR_START[S + 1] - STR_START[S] ≠ STR_START[T + 1] - STR_START[T] THEN GOTO 45; J ← STR_START[S]; K ← STR_START[T]; WHILE J < STR_START[S + 1] DO BEGIN IF STR_POOL[J] ≠ STR_POOL[K] THEN GOTO 45; J ← J + 1; K ← K + 1 END; RESULT ← TRUE; 45: STR_EQ_STR ← RESULT END; FUNCTION GET_STRINGS_STARTED:BOOLEAN; LABEL 30, 10; VAR K : 0..255; L : 0..255; M : CHAR; N : CHAR; G : STR_NUMBER; A : INTEGER; C : BOOLEAN; BEGIN POOL_PTR ← 0; STR_PTR ← 0; STR_START[0] ← 0; FOR K ← 0 TO 255 DO BEGIN IF (K < 32) OR (K > 126) THEN BEGIN BEGIN STR_POOL[POOL_PTR] ← 94; POOL_PTR ← POOL_PTR + 1 END; BEGIN STR_POOL[POOL_PTR] ← 94; POOL_PTR ← POOL_PTR + 1 END; IF K < 64 THEN BEGIN STR_POOL[POOL_PTR] ← K + 64; POOL_PTR ← POOL_PTR + 1 END ELSE IF K < 128 THEN BEGIN STR_POOL[POOL_PTR] ← K - 64; POOL_PTR ← POOL_PTR + 1 END ELSE BEGIN L ← K DIV 16; IF L < 10 THEN BEGIN STR_POOL[POOL_PTR] ← L + 48; POOL_PTR ← POOL_PTR + 1 END ELSE BEGIN STR_POOL[POOL_PTR] ← L + 87; POOL_PTR ← POOL_PTR + 1 END; L ← K MOD 16; IF L < 10 THEN BEGIN STR_POOL[POOL_PTR] ← L + 48; POOL_PTR ← POOL_PTR + 1 END ELSE BEGIN STR_POOL[POOL_PTR] ← L + 87; POOL_PTR ← POOL_PTR + 1 END END END ELSE BEGIN STR_POOL[POOL_PTR] ← K; POOL_PTR ← POOL_PTR + 1 END; G ← MAKE_STRING END; NAME_OF_FILE ← POOL_NAME; IF A_OPEN_IN (POOL_FILE) THEN BEGIN C ← FALSE; REPEAT BEGIN IF EOF (POOL_FILE) THEN BEGIN WRITELN (TERM_OUT, '! TEX.POOL has no check sum.'); A_CLOSE (POOL_FILE); GET_STRINGS_STARTED ← FALSE; GOTO 10 END; READ (POOL_FILE, M, N); IF M = '*' THEN BEGIN A ← 0; K ← 1; WHILE TRUE DO BEGIN IF (XORD[N] < 48) OR (XORD[N] > 57) THEN BEGIN WRITELN (TERM_OUT, '! TEX.POOL check sum doesn''t have nine digits.'); A_CLOSE (POOL_FILE); GET_STRINGS_STARTED ← FALSE; GOTO 10 END; A ← 10 * A + XORD[N] - 48; IF K = 9 THEN GOTO 30; K ← K + 1; READ (POOL_FILE, N) END; 30: IF A ≠ 504454778 THEN BEGIN WRITELN (TERM_OUT, '! TEX.POOL doesn''t match; TANGLE me again.'); A_CLOSE (POOL_FILE); GET_STRINGS_STARTED ← FALSE; GOTO 10 END; C ← TRUE END ELSE BEGIN IF (XORD[M] < 48) OR (XORD[M] > 57) OR (XORD[N] < 48) OR (XORD[N] > 57) THEN BEGIN WRITELN (TERM_OUT, '! TEX.POOL line doesn''t begin with two digits.'); A_CLOSE (POOL_FILE); GET_STRINGS_STARTED ← FALSE; GOTO 10 END; L ← XORD[M] * 10 + XORD[N] - 48 * 11; IF POOL_PTR + L + STRING_VACANCIES > POOL_SIZE THEN BEGIN WRITELN (TERM_OUT, '! You have to increase POOLSIZE.'); A_CLOSE (POOL_FILE); GET_STRINGS_STARTED ← FALSE; GOTO 10 END; FOR K ← 1 TO L DO BEGIN IF EOLN (POOL_FILE) THEN M ← ' ' ELSE READ (POOL_FILE, M); BEGIN STR_POOL[POOL_PTR] ← XORD[M]; POOL_PTR ← POOL_PTR + 1 END END; READLN (POOL_FILE); G ← MAKE_STRING END END UNTIL C; A_CLOSE (POOL_FILE); GET_STRINGS_STARTED ← TRUE END ELSE BEGIN WRITELN (TERM_OUT, '! I can''t read TEX.POOL.'); A_CLOSE (POOL_FILE); GET_STRINGS_STARTED ← FALSE; GOTO 10 END; 10: END; PROCEDURE PRINT_TWO (N:INTEGER); BEGIN N ← ABS (N) MOD 100; PRINT_CHAR (48 + N DIV 10); PRINT_CHAR (48 + N MOD 10) END; PROCEDURE PRINT_HEX (N:INTEGER); VAR K : 0..22; BEGIN K ← 0; PRINT_CHAR (34); REPEAT DIG[K] ← N MOD 16; N ← N DIV 16; K ← K + 1 UNTIL N = 0; PRINT_THE_DIGS (K) END; PROCEDURE PRINT_ROMAN_INT (N:INTEGER); LABEL 10; VAR J : POOL_POINTER; K : POOL_POINTER; U : NONNEGATIVE_INTEGER; V : NONNEGATIVE_INTEGER; BEGIN J ← STR_START[260]; V ← 1000; WHILE TRUE DO BEGIN WHILE N ≥ V DO BEGIN PRINT_CHAR (STR_POOL[J]); N ← N - V END; IF N ≤ 0 THEN GOTO 10; K ← J + 2; U ← V DIV (STR_POOL[K - 1] - 48); IF STR_POOL[K - 1] = 50 THEN BEGIN K ← K + 2; U ← U DIV (STR_POOL[K - 1] - 48) END; IF N + U ≥ V THEN BEGIN PRINT_CHAR (STR_POOL[K]); N ← N + U END ELSE BEGIN J ← J + 2; V ← V DIV (STR_POOL[J - 1] - 48) END END; 10: END; PROCEDURE PRINT_CURRENT_STRING; VAR J : POOL_POINTER; BEGIN J ← STR_START[STR_PTR]; WHILE J < POOL_PTR DO BEGIN PRINT_CHAR (STR_POOL[J]); J ← J + 1 END END; PROCEDURE TERM_INPUT; VAR K : 0..BUF_SIZE; BEGIN BREAK (TERM_OUT); IF NOT INPUT_LN (TERM_IN, TRUE) THEN FATAL_ERROR (261); TERM_OFFSET ← 0; SELECTOR ← SELECTOR - 1; IF LAST ≠ FIRST THEN FOR K ← FIRST TO LAST - 1 DO PRINT (BUFFER[K]); PRINT_LN; SELECTOR ← SELECTOR + 1 END; PROCEDURE INT_ERROR (N:INTEGER); BEGIN PRINT (286); PRINT_INT (N); PRINT_CHAR (41); ERROR END; PROCEDURE NORMALIZE_SELECTOR; BEGIN IF LOG_OPENED THEN SELECTOR ← 19 ELSE SELECTOR ← 17; IF JOB_NAME = 0 THEN OPEN_LOG_FILE; IF INTERACTION = 0 THEN SELECTOR ← SELECTOR - 1 END; PROCEDURE PAUSE_FOR_INSTRUCTIONS; BEGIN IF OK_TO_INTERRUPT THEN BEGIN INTERACTION ← 3; IF (SELECTOR = 18) OR (SELECTOR = 16) THEN SELECTOR ← SELECTOR + 1; BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (296) END; BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 297; HELP_LINE[1] ← 298; HELP_LINE[0] ← 299 END; DELETIONS_ALLOWED ← FALSE; ERROR; DELETIONS_ALLOWED ← TRUE; INTERRUPT ← 0 END END; FUNCTION HALF (X:INTEGER):INTEGER; BEGIN IF ODD (X) THEN HALF ← (X + 1) DIV 2 ELSE HALF ← X DIV 2 END; FUNCTION ROUND_DECIMALS (K:SMALL_NUMBER):SCALED; VAR A : INTEGER; BEGIN A ← 0; WHILE K > 0 DO BEGIN K ← K - 1; A ← (A + DIG[K] * 131072) DIV 10 END; ROUND_DECIMALS ← (A + 1) DIV 2 END; PROCEDURE PRINT_SCALED (S:SCALED); VAR DELTA : SCALED; BEGIN IF S < 0 THEN BEGIN PRINT_CHAR (45); S ← -S END; PRINT_INT (S DIV 65536); PRINT_CHAR (46); S ← 10 * (S MOD 65536) + 5; DELTA ← 10; REPEAT IF DELTA > 65536 THEN S ← S - 17232; PRINT_CHAR (48 + S DIV 65536); S ← 10 * (S MOD 65536); DELTA ← DELTA * 10 UNTIL S ≤ DELTA END; FUNCTION MULT_AND_ADD (N:INTEGER; X:SCALED; Y:SCALED; MAX_ANSWER:SCALED):SCALED; BEGIN IF N < 0 THEN BEGIN X ← -X; N ← -N END; IF N = 0 THEN MULT_AND_ADD ← Y ELSE IF (X ≤ (MAX_ANSWER - Y) DIV N) AND (-X ≤ (MAX_ANSWER + Y) DIV N) THEN MULT_AND_ADD ← N * X + Y ELSE BEGIN ARITH_ERROR ← TRUE; MULT_AND_ADD ← 0 END END; FUNCTION X_OVER_N (X:SCALED; N:INTEGER):SCALED; VAR NEGATIVE : BOOLEAN; BEGIN NEGATIVE ← FALSE; IF N = 0 THEN BEGIN ARITH_ERROR ← TRUE; X_OVER_N ← 0; REMAINDER ← X END ELSE BEGIN IF N < 0 THEN BEGIN X ← -X; N ← -N; NEGATIVE ← TRUE END; IF X ≥ 0 THEN BEGIN X_OVER_N ← X DIV N; REMAINDER ← X MOD N END ELSE BEGIN X_OVER_N ← -(-X) DIV N; REMAINDER ← -(-X) MOD N END END; IF NEGATIVE THEN REMAINDER ← -REMAINDER END; FUNCTION XN_OVER_D (X:SCALED; N:INTEGER; D:INTEGER):SCALED; VAR POSITIVE : BOOLEAN; T : NONNEGATIVE_INTEGER; U : NONNEGATIVE_INTEGER; V : NONNEGATIVE_INTEGER; BEGIN IF X ≥ 0 THEN POSITIVE ← TRUE ELSE BEGIN X ← -X; POSITIVE ← FALSE END; T ← X MOD 32768 * N; U ← X DIV 32768 * N + T DIV 32768; V ← U MOD D * 32768 + T MOD 32768; IF U DIV D ≥ 32768 THEN ARITH_ERROR ← TRUE ELSE U ← 32768 * (U DIV D) + V DIV D; IF POSITIVE THEN BEGIN XN_OVER_D ← U; REMAINDER ← V MOD D END ELSE BEGIN XN_OVER_D ← -U; REMAINDER ← -V MOD D END END; FUNCTION BADNESS (T:SCALED; S:SCALED):HALFWORD; VAR R : INTEGER; BEGIN IF T = 0 THEN BADNESS ← 0 ELSE IF S ≤ 0 THEN BADNESS ← 10000 ELSE BEGIN IF T ≤ 7230584 THEN R ← T * 297 DIV S ELSE IF S ≥ 1663497 THEN R ← T DIV (S DIV 297) ELSE R ← T; IF R > 1290 THEN BADNESS ← 10000 ELSE BADNESS ← (R * R * R + 131072) DIV 262144 END END; PROCEDURE SHOW_TOKEN_LIST (P:INTEGER; Q:INTEGER; L:INTEGER); LABEL 10; VAR M : INTEGER; C : INTEGER; MATCH_CHR : ASCII_CODE; N : ASCII_CODE; BEGIN MATCH_CHR ← 35; N ← 48; TALLY ← 0; WHILE (P ≠ 0) AND (TALLY < L) DO BEGIN IF P = Q THEN BEGIN FIRST_COUNT ← TALLY; TRICK_COUNT ← TALLY + 1 + ERROR_LINE - HALF_ERROR_LINE; IF TRICK_COUNT < ERROR_LINE THEN TRICK_COUNT ← ERROR_LINE END; IF (P < HI_MEM_MIN) OR (P > MEM_END) THEN BEGIN PRINT_ESC (309); GOTO 10 END; IF MEM[P].HH.LH ≥ 4095 THEN PRINT_CS (MEM[P].HH.LH - 4095) ELSE BEGIN M ← MEM[P].HH.LH DIV 256; C ← MEM[P].HH.LH MOD 256; IF MEM[P].HH.LH < 0 THEN PRINT_ESC (555) ELSE CASE M OF 1,2,3,4,7,8,10,11,12: PRINT (C); 6: BEGIN PRINT (C); PRINT (C) END; 5: BEGIN PRINT (MATCH_CHR); IF C ≤ 9 THEN PRINT_CHAR (C + 48) ELSE BEGIN PRINT_CHAR (33); GOTO 10 END END; 13: BEGIN MATCH_CHR ← C; PRINT (C); N ← N + 1; PRINT_CHAR (N); IF N > 57 THEN GOTO 10 END; 14: PRINT (556); ELSE PRINT_ESC (555); END END; P ← MEM[P].HH.RH END; IF P ≠ 0 THEN PRINT_ESC (554); 10: END; PROCEDURE RUNAWAY; VAR P : HALFWORD; BEGIN IF SCANNER_STATUS > 1 THEN BEGIN PRINT_NL (569); CASE SCANNER_STATUS OF 2: BEGIN PRINT (570); P ← DEF_REF END; 3: BEGIN PRINT (571); P ← 59997 END; 4: BEGIN PRINT (572); P ← 59996 END; 5: BEGIN PRINT (573); P ← DEF_REF END; END; PRINT_CHAR (63); PRINT_LN; SHOW_TOKEN_LIST (MEM[P].HH.RH, 0, ERROR_LINE - 10) END END; FUNCTION GET_AVAIL:HALFWORD; VAR P : HALFWORD; BEGIN P ← AVAIL; IF P ≠ 0 THEN AVAIL ← MEM[AVAIL].HH.RH ELSE IF MEM_END < MEM_MAX THEN BEGIN MEM_END ← MEM_END + 1; P ← MEM_END END ELSE BEGIN HI_MEM_MIN ← HI_MEM_MIN - 1; P ← HI_MEM_MIN; IF HI_MEM_MIN ≤ LO_MEM_MAX THEN BEGIN RUNAWAY; OVERFLOW (300, MEM_MAX + 1 - MEM_MIN) END END; MEM[P].HH.RH ← 0; GET_AVAIL ← P END; PROCEDURE FLUSH_LIST (P:HALFWORD); VAR Q : HALFWORD; R : HALFWORD; BEGIN IF P ≠ 0 THEN BEGIN R ← P; REPEAT Q ← R; R ← MEM[R].HH.RH UNTIL R = 0; MEM[Q].HH.RH ← AVAIL; AVAIL ← P END END; FUNCTION GET_NODE (S:INTEGER):HALFWORD; LABEL 40, 10, 20; VAR P : HALFWORD; Q : HALFWORD; R : INTEGER; T : INTEGER; BEGIN 20: P ← ROVER; REPEAT Q ← P + MEM[P].HH.LH; WHILE MEM[Q].HH.RH = 65535 DO BEGIN T ← MEM[Q + 1].HH.RH; IF Q = ROVER THEN ROVER ← T; MEM[T + 1].HH.LH ← MEM[Q + 1].HH.LH; MEM[MEM[Q + 1].HH.LH + 1].HH.RH ← T; Q ← Q + MEM[Q].HH.LH END; R ← Q - S; IF R > P + 1 THEN BEGIN MEM[P].HH.LH ← R - P; ROVER ← P; GOTO 40 END; IF R = P THEN IF MEM[P + 1].HH.RH ≠ P THEN BEGIN ROVER ← MEM[P + 1].HH.RH; T ← MEM[P + 1].HH.LH; MEM[ROVER + 1].HH.LH ← T; MEM[T + 1].HH.RH ← ROVER; GOTO 40 END; MEM[P].HH.LH ← Q - P; P ← MEM[P + 1].HH.RH UNTIL P = ROVER; IF S = 1073741824 THEN BEGIN GET_NODE ← 65535; GOTO 10 END; IF LO_MEM_MAX + 2 < HI_MEM_MIN THEN IF LO_MEM_MAX + 2 ≤ 65535 THEN BEGIN IF HI_MEM_MIN - LO_MEM_MAX ≥ 1998 THEN T ← LO_MEM_MAX + 1000 ELSE T ← LO_MEM_MAX + 1 + (HI_MEM_MIN - LO_MEM_MAX) DIV 2; P ← MEM[ROVER + 1].HH.LH; Q ← LO_MEM_MAX; MEM[P + 1].HH.RH ← Q; MEM[ROVER + 1].HH.LH ← Q; IF T > 65535 THEN T ← 65535; MEM[Q + 1].HH.RH ← ROVER; MEM[Q + 1].HH.LH ← P; MEM[Q].HH.RH ← 65535; MEM[Q].HH.LH ← T - LO_MEM_MAX; LO_MEM_MAX ← T; MEM[LO_MEM_MAX].HH.RH ← 0; MEM[LO_MEM_MAX].HH.LH ← 0; ROVER ← Q; GOTO 20 END; OVERFLOW (300, MEM_MAX + 1 - MEM_MIN); 40: MEM[R].HH.RH ← 0; GET_NODE ← R; 10: END; PROCEDURE FREE_NODE (P:HALFWORD; S:HALFWORD); VAR Q : HALFWORD; BEGIN MEM[P].HH.LH ← S; MEM[P].HH.RH ← 65535; Q ← MEM[ROVER + 1].HH.LH; MEM[P + 1].HH.LH ← Q; MEM[P + 1].HH.RH ← ROVER; MEM[ROVER + 1].HH.LH ← P; MEM[Q + 1].HH.RH ← P END; PROCEDURE SORT_AVAIL; VAR P : HALFWORD; Q : HALFWORD; R : HALFWORD; OLD_ROVER : HALFWORD; BEGIN P ← GET_NODE (1073741824); P ← MEM[ROVER + 1].HH.RH; MEM[ROVER + 1].HH.RH ← 65535; OLD_ROVER ← ROVER; WHILE P ≠ OLD_ROVER DO IF P < ROVER THEN BEGIN Q ← P; P ← MEM[Q + 1].HH.RH; MEM[Q + 1].HH.RH ← ROVER; ROVER ← Q END ELSE BEGIN Q ← ROVER; WHILE MEM[Q + 1].HH.RH < P DO Q ← MEM[Q + 1].HH.RH; R ← MEM[P + 1].HH.RH; MEM[P + 1].HH.RH ← MEM[Q + 1].HH.RH; MEM[Q + 1].HH.RH ← P; P ← R END; P ← ROVER; WHILE MEM[P + 1].HH.RH ≠ 65535 DO BEGIN MEM[MEM[P + 1].HH.RH + 1].HH.LH ← P; P ← MEM[P + 1].HH.RH END; MEM[P + 1].HH.RH ← ROVER; MEM[ROVER + 1].HH.LH ← P END; FUNCTION NEW_NULL_BOX:HALFWORD; VAR P : HALFWORD; BEGIN P ← GET_NODE (7); MEM[P].HH.B0 ← 0; MEM[P].HH.B1 ← 0; MEM[P + 1].INT ← 0; MEM[P + 2].INT ← 0; MEM[P + 3].INT ← 0; MEM[P + 4].INT ← 0; MEM[P + 5].HH.RH ← 0; MEM[P + 5].HH.B0 ← 0; MEM[P + 5].HH.B1 ← 0; MEM[P + 6].GR ← 0.0; NEW_NULL_BOX ← P END; FUNCTION NEW_RULE:HALFWORD; VAR P : HALFWORD; BEGIN P ← GET_NODE (4); MEM[P].HH.B0 ← 2; MEM[P].HH.B1 ← 0; MEM[P + 1].INT ← -1073741824; MEM[P + 2].INT ← -1073741824; MEM[P + 3].INT ← -1073741824; NEW_RULE ← P END; FUNCTION NEW_LIGATURE (F:QUARTERWORD; C:QUARTERWORD; Q:HALFWORD):HALFWORD; VAR P : HALFWORD; BEGIN P ← GET_NODE (2); MEM[P].HH.B0 ← 6; MEM[P + 1].HH.B0 ← F; MEM[P + 1].HH.B1 ← C; MEM[P + 1].HH.RH ← Q; MEM[P].HH.B1 ← 0; NEW_LIGATURE ← P END; FUNCTION NEW_LIG_ITEM (C:QUARTERWORD):HALFWORD; VAR P : HALFWORD; BEGIN P ← GET_NODE (2); MEM[P].HH.B1 ← C; MEM[P + 1].HH.RH ← 0; NEW_LIG_ITEM ← P END; FUNCTION NEW_DISC:HALFWORD; VAR P : HALFWORD; BEGIN P ← GET_NODE (2); MEM[P].HH.B0 ← 7; MEM[P].HH.B1 ← 0; MEM[P + 1].HH.LH ← 0; MEM[P + 1].HH.RH ← 0; NEW_DISC ← P END; FUNCTION NEW_MATH (W:SCALED; S:SMALL_NUMBER):HALFWORD; VAR P : HALFWORD; BEGIN P ← GET_NODE (2); MEM[P].HH.B0 ← 9; MEM[P].HH.B1 ← S; MEM[P + 1].INT ← W; NEW_MATH ← P END; FUNCTION NEW_SPEC (P:HALFWORD):HALFWORD; VAR Q : HALFWORD; BEGIN Q ← GET_NODE (4); MEM[Q] ← MEM[P]; MEM[Q].HH.RH ← 0; MEM[Q + 1].INT ← MEM[P + 1].INT; MEM[Q + 2].INT ← MEM[P + 2].INT; MEM[Q + 3].INT ← MEM[P + 3].INT; NEW_SPEC ← Q END; FUNCTION NEW_PARAM_GLUE (N:SMALL_NUMBER):HALFWORD; VAR P : HALFWORD; Q : HALFWORD; BEGIN P ← GET_NODE (2); MEM[P].HH.B0 ← 10; MEM[P].HH.B1 ← N + 1; MEM[P + 1].HH.RH ← 0; Q ← EQTB[6782 + N].HH.RH; MEM[P + 1].HH.LH ← Q; MEM[Q].HH.RH ← MEM[Q].HH.RH + 1; NEW_PARAM_GLUE ← P END; FUNCTION NEW_GLUE (Q:HALFWORD):HALFWORD; VAR P : HALFWORD; BEGIN P ← GET_NODE (2); MEM[P].HH.B0 ← 10; MEM[P].HH.B1 ← 0; MEM[P + 1].HH.RH ← 0; MEM[P + 1].HH.LH ← Q; MEM[Q].HH.RH ← MEM[Q].HH.RH + 1; NEW_GLUE ← P END; FUNCTION NEW_SKIP_PARAM (N:SMALL_NUMBER):HALFWORD; VAR P : HALFWORD; BEGIN TEMP_PTR ← NEW_SPEC (EQTB[6782 + N].HH.RH); P ← NEW_GLUE (TEMP_PTR); MEM[TEMP_PTR].HH.RH ← 0; MEM[P].HH.B1 ← N + 1; NEW_SKIP_PARAM ← P END; FUNCTION NEW_KERN (W:SCALED):HALFWORD; VAR P : HALFWORD; BEGIN P ← GET_NODE (2); MEM[P].HH.B0 ← 11; MEM[P].HH.B1 ← 0; MEM[P + 1].INT ← W; NEW_KERN ← P END; FUNCTION NEW_PENALTY (M:INTEGER):HALFWORD; VAR P : HALFWORD; BEGIN P ← GET_NODE (2); MEM[P].HH.B0 ← 12; MEM[P].HH.B1 ← 0; MEM[P + 1].INT ← M; NEW_PENALTY ← P END; PROCEDURE SHORT_DISPLAY (P:INTEGER); VAR N : INTEGER; BEGIN WHILE P > MEM_MIN DO BEGIN IF P ≥ HI_MEM_MIN THEN BEGIN IF P ≤ MEM_END THEN BEGIN IF MEM[P].HH.B0 ≠ FONT_IN_SHORT_DISPLAY THEN BEGIN IF (MEM[P].HH.B0 < 0) OR (MEM[P].HH.B0 > FONT_MAX) THEN PRINT_CHAR (42) ELSE PRINT_ESC (HASH[6524 + MEM[P].HH.B0].RH); PRINT_CHAR (32); FONT_IN_SHORT_DISPLAY ← MEM[P].HH.B0 END; PRINT (MEM[P].HH.B1 - 0) END END ELSE CASE MEM[P].HH.B0 OF 0,1,3,8,4,5,13: PRINT (308); 2: PRINT_CHAR (124); 10: IF MEM[P + 1].HH.LH ≠ 0 THEN PRINT_CHAR (32); 9: PRINT_CHAR (36); 6: SHORT_DISPLAY (MEM[P + 1].HH.RH); 7: BEGIN SHORT_DISPLAY (MEM[P + 1].HH.LH); SHORT_DISPLAY (MEM[P + 1].HH.RH); N ← MEM[P].HH.B1; WHILE N > 0 DO BEGIN IF MEM[P].HH.RH ≠ 0 THEN P ← MEM[P].HH.RH; N ← N - 1 END END; ELSE ; END; P ← MEM[P].HH.RH END END; PROCEDURE PRINT_FONT_AND_CHAR (P:INTEGER); BEGIN IF P > MEM_END THEN PRINT_ESC (309) ELSE BEGIN IF (MEM[P].HH.B0 < 0) OR (MEM[P].HH.B0 > FONT_MAX) THEN PRINT_CHAR (42) ELSE PRINT_ESC (HASH[6524 + MEM[P].HH.B0].RH); PRINT_CHAR (32); PRINT (MEM[P].HH.B1 - 0) END END; PROCEDURE PRINT_MARK (P:INTEGER); BEGIN PRINT_CHAR (123); IF (P < HI_MEM_MIN) OR (P > MEM_END) THEN PRINT_ESC (309) ELSE SHOW_TOKEN_LIST (MEM[P].HH.RH, 0, MAX_PRINT_LINE - 10); PRINT_CHAR (125) END; PROCEDURE PRINT_RULE_DIMEN (D:SCALED); BEGIN IF D = -1073741824 THEN PRINT_CHAR (42) ELSE PRINT_SCALED (D) END; PROCEDURE PRINT_GLUE (D:SCALED; ORDER:INTEGER; S:STR_NUMBER); BEGIN PRINT_SCALED (D); IF (ORDER < 0) OR (ORDER > 3) THEN PRINT (310) ELSE IF ORDER > 0 THEN BEGIN PRINT (311); WHILE ORDER > 1 DO BEGIN PRINT_CHAR (108); ORDER ← ORDER - 1 END END ELSE IF S ≠ 0 THEN PRINT (S) END; PROCEDURE PRINT_SPEC (P:INTEGER; S:STR_NUMBER); BEGIN IF (P < MEM_MIN) OR (P ≥ LO_MEM_MAX) THEN PRINT_CHAR (42) ELSE BEGIN PRINT_SCALED (MEM[P + 1].INT); IF S ≠ 0 THEN PRINT (S); IF MEM[P + 2].INT ≠ 0 THEN BEGIN PRINT (312); PRINT_GLUE (MEM[P + 2].INT, MEM[P].HH.B0, S) END; IF MEM[P + 3].INT ≠ 0 THEN BEGIN PRINT (313); PRINT_GLUE (MEM[P + 3].INT, MEM[P].HH.B1, S) END END END; PROCEDURE PRINT_FAM_AND_CHAR (P:HALFWORD); BEGIN PRINT_ESC (464); PRINT_INT (MEM[P].HH.B0); PRINT_CHAR (32); PRINT (MEM[P].HH.B1 - 0) END; PROCEDURE PRINT_DELIMITER (P:HALFWORD); VAR A : INTEGER; BEGIN A ← MEM[P].QQQQ.B0 * 256 + MEM[P].QQQQ.B1 - 0; A ← A * 4096 + MEM[P].QQQQ.B2 * 256 + MEM[P].QQQQ.B3 - 0; IF A < 0 THEN PRINT_INT (A) ELSE PRINT_HEX (A) END; PROCEDURE SHOW_INFO; FORWARD; PROCEDURE PRINT_SUBSIDIARY_DATA (P:HALFWORD; C:ASCII_CODE); BEGIN IF POOL_PTR - STR_START[STR_PTR] ≥ DEPTH_THRESHOLD THEN BEGIN IF MEM[P].HH.RH ≠ 0 THEN PRINT (314) END ELSE BEGIN BEGIN STR_POOL[POOL_PTR] ← C; POOL_PTR ← POOL_PTR + 1 END; TEMP_PTR ← P; CASE MEM[P].HH.RH OF 1: BEGIN PRINT_LN; PRINT_CURRENT_STRING; PRINT_FAM_AND_CHAR (P) END; 2: SHOW_INFO; 3: IF MEM[P].HH.LH = 0 THEN BEGIN PRINT_LN; PRINT_CURRENT_STRING; PRINT (860) END ELSE SHOW_INFO; ELSE ; END; POOL_PTR ← POOL_PTR - 1 END END; PROCEDURE PRINT_STYLE (C:INTEGER); BEGIN CASE C DIV 2 OF 0: PRINT_ESC (861); 1: PRINT_ESC (862); 2: PRINT_ESC (863); 3: PRINT_ESC (864); ELSE PRINT (865); END END; PROCEDURE PRINT_SKIP_PARAM (N:INTEGER); BEGIN CASE N OF 0: PRINT_ESC (376); 1: PRINT_ESC (377); 2: PRINT_ESC (378); 3: PRINT_ESC (379); 4: PRINT_ESC (380); 5: PRINT_ESC (381); 6: PRINT_ESC (382); 7: PRINT_ESC (383); 8: PRINT_ESC (384); 9: PRINT_ESC (385); 10: PRINT_ESC (386); 11: PRINT_ESC (387); 12: PRINT_ESC (388); 13: PRINT_ESC (389); 14: PRINT_ESC (390); 15: PRINT_ESC (391); 16: PRINT_ESC (392); 17: PRINT_ESC (393); ELSE PRINT (394); END END; PROCEDURE SHOW_NODE_LIST (P:INTEGER); LABEL 10; VAR N : INTEGER; G : REAL; BEGIN IF POOL_PTR - STR_START[STR_PTR] > DEPTH_THRESHOLD THEN BEGIN IF P > 0 THEN PRINT (314); GOTO 10 END; N ← 0; WHILE P > MEM_MIN DO BEGIN PRINT_LN; PRINT_CURRENT_STRING; IF P > MEM_END THEN BEGIN PRINT (315); GOTO 10 END; N ← N + 1; IF N > BREADTH_MAX THEN BEGIN PRINT (316); GOTO 10 END; IF P ≥ HI_MEM_MIN THEN PRINT_FONT_AND_CHAR (P) ELSE CASE MEM[P].HH.B0 OF 0,1, 13: BEGIN IF MEM[P].HH.B0 = 0 THEN PRINT_ESC (104) ELSE IF MEM[P].HH.B0 = 1 THEN PRINT_ESC (118) ELSE PRINT_ESC (318); PRINT (319); PRINT_SCALED (MEM[P + 3].INT); PRINT_CHAR (43); PRINT_SCALED (MEM[P + 2].INT); PRINT (320); PRINT_SCALED (MEM[P + 1].INT); IF MEM[P].HH.B0 = 13 THEN BEGIN IF MEM[P].HH.B1 ≠ 0 THEN BEGIN PRINT (286); PRINT_INT (MEM[P].HH.B1 + 1); PRINT (322) END; IF MEM[P + 6].INT ≠ 0 THEN BEGIN PRINT (323); PRINT_GLUE (MEM[P + 6].INT, MEM[P + 5].HH.B1, 0) END; IF MEM[P + 4].INT ≠ 0 THEN BEGIN PRINT (324); PRINT_GLUE (MEM[P + 4].INT, MEM[P + 5].HH.B0, 0) END END ELSE BEGIN G ← MEM[P + 6].GR; IF (G ≠ 0.0) AND (MEM[P + 5].HH.B0 ≠ 0) THEN BEGIN PRINT (325); IF MEM[P + 5].HH.B0 = 2 THEN PRINT (326); IF FALSE THEN PRINT (327) ELSE IF ABS (G) > 20000.0 THEN BEGIN IF G > 0.0 THEN PRINT_CHAR (62) ELSE PRINT (328); PRINT_GLUE (20000 * 65536, MEM[P + 5].HH.B1, 0) END ELSE PRINT_GLUE (ROUND (65536 * G), MEM[P + 5].HH.B1, 0) END; IF MEM[P + 4].INT ≠ 0 THEN BEGIN PRINT (321); PRINT_SCALED (MEM[P + 4].INT) END END; BEGIN BEGIN STR_POOL[POOL_PTR] ← 46; POOL_PTR ← POOL_PTR + 1 END; SHOW_NODE_LIST (MEM[P + 5].HH.RH); POOL_PTR ← POOL_PTR - 1 END END; 2: BEGIN PRINT_ESC (329); PRINT_RULE_DIMEN (MEM[P + 3].INT); PRINT_CHAR (43); PRINT_RULE_DIMEN (MEM[P + 2].INT); PRINT (320); PRINT_RULE_DIMEN (MEM[P + 1].INT) END; 3: BEGIN PRINT_ESC (330); PRINT_INT (MEM[P].HH.B1 - 0); PRINT (331); PRINT_SCALED (MEM[P + 3].INT); PRINT (332); PRINT_SPEC (MEM[P + 4].HH.RH, 0); PRINT_CHAR (44); PRINT_SCALED (MEM[P + 2].INT); PRINT (333); PRINT_INT (MEM[P + 1].INT); BEGIN BEGIN STR_POOL[POOL_PTR] ← 46; POOL_PTR ← POOL_PTR + 1 END; SHOW_NODE_LIST (MEM[P + 4].HH.LH); POOL_PTR ← POOL_PTR - 1 END END; 8: CASE MEM[P].HH.B1 OF 0: BEGIN PRINT_WRITE_WHATSIT (1285, P); PRINT_CHAR (61); PRINT_FILE_NAME (MEM[P + 1].HH.RH, MEM[P + 2].HH.LH, MEM[P + 2].HH.RH) END; 1: BEGIN PRINT_WRITE_WHATSIT (594, P); PRINT_MARK (MEM[P + 1].HH.RH) END; 2: PRINT_WRITE_WHATSIT (1286, P); 3: BEGIN PRINT_ESC (1287); PRINT_MARK (MEM[P + 1].HH.RH) END; 4: BEGIN PRINT_ESC (1289); PRINT_INT (MEM[P + 1].HH.RH); PRINT (1292); PRINT_INT (MEM[P + 1].HH.B0); PRINT_CHAR (44); PRINT_INT (MEM[P + 1].HH.B1); PRINT_CHAR (41) END; ELSE PRINT (1293); END; 10: IF MEM[P].HH.B1 ≥ 100 THEN BEGIN PRINT_ESC (338); IF MEM[P].HH.B1 = 101 THEN PRINT_CHAR (99) ELSE IF MEM[P].HH.B1 = 102 THEN PRINT_CHAR (120); PRINT (339); PRINT_SPEC (MEM[P + 1].HH.LH, 0); BEGIN BEGIN STR_POOL[POOL_PTR] ← 46; POOL_PTR ← POOL_PTR + 1 END; SHOW_NODE_LIST (MEM[P + 1].HH.RH); POOL_PTR ← POOL_PTR - 1 END END ELSE BEGIN PRINT_ESC (334); IF MEM[P].HH.B1 ≠ 0 THEN BEGIN PRINT_CHAR (40); IF MEM[P].HH.B1 < 98 THEN PRINT_SKIP_PARAM (MEM[P].HH.B1 - 1) ELSE IF MEM[P].HH.B1 = 98 THEN PRINT_ESC (335) ELSE PRINT_ESC (336); PRINT_CHAR (41) END; IF MEM[P].HH.B1 ≠ 98 THEN BEGIN PRINT_CHAR (32); IF MEM[P].HH.B1 < 98 THEN PRINT_SPEC (MEM[P + 1].HH.LH, 0) ELSE PRINT_SPEC (MEM[P + 1].HH.LH, 337) END END; 11: IF MEM[P].HH.B1 ≠ 99 THEN BEGIN PRINT_ESC (340); IF MEM[P].HH.B1 ≠ 0 THEN PRINT_CHAR (32); PRINT_SCALED (MEM[P + 1].INT); IF MEM[P].HH.B1 = 2 THEN PRINT (341) END ELSE BEGIN PRINT_ESC (342); PRINT_SCALED (MEM[P + 1].INT); PRINT (337) END; 9: BEGIN PRINT_ESC (343); IF MEM[P].HH.B1 = 0 THEN PRINT (344) ELSE PRINT (345); IF MEM[P + 1].INT ≠ 0 THEN BEGIN PRINT (346); PRINT_SCALED (MEM[P + 1].INT) END END; 6: BEGIN PRINT_FONT_AND_CHAR (P + 1); PRINT (347); IF MEM[P].HH.B1 > 1 THEN PRINT_CHAR (124); FONT_IN_SHORT_DISPLAY ← MEM[P + 1].HH.B0; SHORT_DISPLAY (MEM[P + 1].HH.RH); IF ODD (MEM[P].HH.B1) THEN PRINT_CHAR (124); PRINT_CHAR (41) END; 12: BEGIN PRINT_ESC (348); PRINT_INT (MEM[P + 1].INT) END; 7: BEGIN PRINT_ESC (349); IF MEM[P].HH.B1 > 0 THEN BEGIN PRINT (350); PRINT_INT (MEM[P].HH.B1) END; BEGIN BEGIN STR_POOL[POOL_PTR] ← 46; POOL_PTR ← POOL_PTR + 1 END; SHOW_NODE_LIST (MEM[P + 1].HH.LH); POOL_PTR ← POOL_PTR - 1 END; BEGIN STR_POOL[POOL_PTR] ← 124; POOL_PTR ← POOL_PTR + 1 END; SHOW_NODE_LIST (MEM[P + 1].HH.RH); POOL_PTR ← POOL_PTR - 1 END; 4: BEGIN PRINT_ESC (351); PRINT_MARK (MEM[P + 1].INT) END; 5: BEGIN PRINT_ESC (352); BEGIN BEGIN STR_POOL[POOL_PTR] ← 46; POOL_PTR ← POOL_PTR + 1 END; SHOW_NODE_LIST (MEM[P + 1].INT); POOL_PTR ← POOL_PTR - 1 END END; 14: PRINT_STYLE (MEM[P].HH.B1); 15: BEGIN PRINT_ESC (525); BEGIN STR_POOL[POOL_PTR] ← 68; POOL_PTR ← POOL_PTR + 1 END; SHOW_NODE_LIST (MEM[P + 1].HH.LH); POOL_PTR ← POOL_PTR - 1; BEGIN STR_POOL[POOL_PTR] ← 84; POOL_PTR ← POOL_PTR + 1 END; SHOW_NODE_LIST (MEM[P + 1].HH.RH); POOL_PTR ← POOL_PTR - 1; BEGIN STR_POOL[POOL_PTR] ← 83; POOL_PTR ← POOL_PTR + 1 END; SHOW_NODE_LIST (MEM[P + 2].HH.LH); POOL_PTR ← POOL_PTR - 1; BEGIN STR_POOL[POOL_PTR] ← 115; POOL_PTR ← POOL_PTR + 1 END; SHOW_NODE_LIST (MEM[P + 2].HH.RH); POOL_PTR ← POOL_PTR - 1 END; 16,17,18,19,20,21,22,23,24,27,26,29,28,30, 31: BEGIN CASE MEM[P].HH.B0 OF 16: PRINT_ESC (866); 17: PRINT_ESC (867); 18: PRINT_ESC (868); 19: PRINT_ESC (869); 20: PRINT_ESC (870); 21: PRINT_ESC (871); 22: PRINT_ESC (872); 23: PRINT_ESC (873); 27: PRINT_ESC (874); 26: PRINT_ESC (875); 29: PRINT_ESC (539); 24: BEGIN PRINT_ESC (533); PRINT_DELIMITER (P + 4) END; 28: BEGIN PRINT_ESC (508); PRINT_FAM_AND_CHAR (P + 4) END; 30: BEGIN PRINT_ESC (876); PRINT_DELIMITER (P + 1) END; 31: BEGIN PRINT_ESC (877); PRINT_DELIMITER (P + 1) END; END; IF MEM[P].HH.B1 ≠ 0 THEN IF MEM[P].HH.B1 = 1 THEN PRINT_ESC (878) ELSE PRINT_ESC (879); IF MEM[P].HH.B0 < 30 THEN PRINT_SUBSIDIARY_DATA (P + 1, 46); PRINT_SUBSIDIARY_DATA (P + 2, 94); PRINT_SUBSIDIARY_DATA (P + 3, 95) END; 25: BEGIN PRINT_ESC (880); IF MEM[P + 1].INT = 1073741824 THEN PRINT (881) ELSE PRINT_SCALED (MEM[P + 1].INT); IF (MEM[P + 4].QQQQ.B0 ≠ 0) OR (MEM[P + 4].QQQQ.B1 ≠ 0) OR (MEM[P + 4].QQQQ.B2 ≠ 0) OR (MEM[P + 4].QQQQ.B3 ≠ 0) THEN BEGIN PRINT (882); PRINT_DELIMITER (P + 4) END; IF (MEM[P + 5].QQQQ.B0 ≠ 0) OR (MEM[P + 5].QQQQ.B1 ≠ 0) OR (MEM[P + 5].QQQQ.B2 ≠ 0) OR (MEM[P + 5].QQQQ.B3 ≠ 0) THEN BEGIN PRINT (883); PRINT_DELIMITER (P + 5) END; PRINT_SUBSIDIARY_DATA (P + 2, 92); PRINT_SUBSIDIARY_DATA (P + 3, 47) END; ELSE PRINT (317); END; P ← MEM[P].HH.RH END; 10: END; PROCEDURE SHOW_BOX (P:HALFWORD); BEGIN DEPTH_THRESHOLD ← EQTB[9188].INT; BREADTH_MAX ← EQTB[9187].INT; IF BREADTH_MAX ≤ 0 THEN BREADTH_MAX ← 5; IF POOL_PTR + DEPTH_THRESHOLD ≥ POOL_SIZE THEN DEPTH_THRESHOLD ← POOL_SIZE - POOL_PTR - 1; SHOW_NODE_LIST (P); PRINT_LN END; PROCEDURE DELETE_TOKEN_REF (P:HALFWORD); BEGIN IF MEM[P].HH.LH = 0 THEN FLUSH_LIST (P) ELSE MEM[P].HH.LH ← MEM[P].HH.LH - 1 END; PROCEDURE DELETE_GLUE_REF (P:HALFWORD); BEGIN IF MEM[P].HH.RH = 0 THEN FREE_NODE (P, 4) ELSE MEM[P].HH.RH ← MEM[P].HH.RH - 1 END; PROCEDURE FLUSH_NODE_LIST (P:HALFWORD); LABEL 30; VAR Q : HALFWORD; BEGIN WHILE P ≠ 0 DO BEGIN Q ← MEM[P].HH.RH; IF P ≥ HI_MEM_MIN THEN BEGIN MEM[P].HH.RH ← AVAIL; AVAIL ← P END ELSE BEGIN CASE MEM[P].HH.B0 OF 0,1, 13: BEGIN FLUSH_NODE_LIST (MEM[P + 5].HH.RH); FREE_NODE (P, 7); GOTO 30 END; 2: BEGIN FREE_NODE (P, 4); GOTO 30 END; 3: BEGIN FLUSH_NODE_LIST (MEM[P + 4].HH.LH); DELETE_GLUE_REF (MEM[P + 4].HH.RH); FREE_NODE (P, 5); GOTO 30 END; 8: BEGIN CASE MEM[P].HH.B1 OF 0: FREE_NODE (P, 3); 1, 3: BEGIN DELETE_TOKEN_REF (MEM[P + 1].HH.RH); FREE_NODE (P, 2); GOTO 30 END; 2,4: FREE_NODE (P, 2); ELSE CONFUSION (1295); END; GOTO 30 END; 10: BEGIN BEGIN IF MEM[MEM[P + 1].HH.LH].HH.RH = 0 THEN FREE_NODE (MEM[P + 1].HH.LH, 4) ELSE MEM[MEM[P + 1].HH.LH].HH.RH ← MEM[MEM[P + 1].HH.LH].HH.RH - 1 END; IF MEM[P + 1].HH.RH ≠ 0 THEN FLUSH_NODE_LIST (MEM[P + 1].HH.RH) END; 11,9,12: ; 6: FLUSH_NODE_LIST (MEM[P + 1].HH.RH); 4: DELETE_TOKEN_REF (MEM[P + 1].INT); 7: BEGIN FLUSH_NODE_LIST (MEM[P + 1].HH.LH); FLUSH_NODE_LIST (MEM[P + 1].HH.RH) END; 5: FLUSH_NODE_LIST (MEM[P + 1].INT); 14: BEGIN FREE_NODE (P, 3); GOTO 30 END; 15: BEGIN FLUSH_NODE_LIST (MEM[P + 1].HH.LH); FLUSH_NODE_LIST (MEM[P + 1].HH.RH); FLUSH_NODE_LIST (MEM[P + 2].HH.LH); FLUSH_NODE_LIST (MEM[P + 2].HH.RH); FREE_NODE (P, 3); GOTO 30 END; 16,17,18,19,20,21,22,23,24,27,26,29, 28: BEGIN IF MEM[P + 1].HH.RH ≥ 2 THEN FLUSH_NODE_LIST (MEM[P + 1].HH.LH); IF MEM[P + 2].HH.RH ≥ 2 THEN FLUSH_NODE_LIST (MEM[P + 2].HH.LH); IF MEM[P + 3].HH.RH ≥ 2 THEN FLUSH_NODE_LIST (MEM[P + 3].HH.LH); IF MEM[P].HH.B0 = 24 THEN FREE_NODE (P, 5) ELSE IF MEM[P].HH.B0 = 28 THEN FREE_NODE (P, 5) ELSE FREE_NODE (P, 4); GOTO 30 END; 30, 31: BEGIN FREE_NODE (P, 4); GOTO 30 END; 25: BEGIN FLUSH_NODE_LIST (MEM[P + 2].HH.LH); FLUSH_NODE_LIST (MEM[P + 3].HH.LH); FREE_NODE (P, 6); GOTO 30 END; ELSE CONFUSION (353); END; FREE_NODE (P, 2); 30: END; P ← Q END END; FUNCTION COPY_NODE_LIST (P:HALFWORD):HALFWORD; VAR H : HALFWORD; Q : HALFWORD; R : HALFWORD; WORDS : 0..5; BEGIN H ← GET_AVAIL; Q ← H; WHILE P ≠ 0 DO BEGIN WORDS ← 1; IF P ≥ HI_MEM_MIN THEN R ← GET_AVAIL ELSE CASE MEM[P].HH.B0 OF 0,1, 13: BEGIN R ← GET_NODE (7); MEM[R + 6] ← MEM[P + 6]; MEM[R + 5] ← MEM[P + 5]; MEM[R + 5].HH.RH ← COPY_NODE_LIST (MEM[P + 5].HH.RH); WORDS ← 5 END; 2: BEGIN R ← GET_NODE (4); WORDS ← 4 END; 3: BEGIN R ← GET_NODE (5); MEM[R + 4] ← MEM[P + 4]; MEM[MEM[P + 4].HH.RH].HH.RH ← MEM[MEM[P + 4].HH.RH].HH.RH + 1; MEM[R + 4].HH.LH ← COPY_NODE_LIST (MEM[P + 4].HH.LH); WORDS ← 4 END; 8: CASE MEM[P].HH.B1 OF 0: BEGIN R ← GET_NODE (3); WORDS ← 3 END; 1, 3: BEGIN R ← GET_NODE (2); MEM[MEM[P + 1].HH.RH].HH.LH ← MEM[MEM[P + 1].HH.RH].HH.LH + 1; WORDS ← 2 END; 2, 4: BEGIN R ← GET_NODE (2); WORDS ← 2 END; ELSE CONFUSION (1294); END; 10: BEGIN R ← GET_NODE (2); MEM[MEM[P + 1].HH.LH].HH.RH ← MEM[MEM[P + 1].HH.LH].HH.RH + 1; MEM[R + 1].HH.LH ← MEM[P + 1].HH.LH; MEM[R + 1].HH.RH ← COPY_NODE_LIST (MEM[P + 1].HH.RH) END; 11,9, 12: BEGIN R ← GET_NODE (2); WORDS ← 2 END; 6: BEGIN R ← GET_NODE (2); MEM[R + 1] ← MEM[P + 1]; MEM[R + 1].HH.RH ← COPY_NODE_LIST (MEM[P + 1].HH.RH) END; 7: BEGIN R ← GET_NODE (2); MEM[R + 1].HH.LH ← COPY_NODE_LIST (MEM[P + 1].HH.LH); MEM[R + 1].HH.RH ← COPY_NODE_LIST (MEM[P + 1].HH.RH) END; 4: BEGIN R ← GET_NODE (2); MEM[MEM[P + 1].INT].HH.LH ← MEM[MEM[P + 1].INT].HH.LH + 1; WORDS ← 2 END; 5: BEGIN R ← GET_NODE (2); MEM[R + 1].INT ← COPY_NODE_LIST (MEM[P + 1].INT) END; ELSE CONFUSION (354); END; WHILE WORDS > 0 DO BEGIN WORDS ← WORDS - 1; MEM[R + WORDS] ← MEM[P + WORDS] END; MEM[Q].HH.RH ← R; Q ← R; P ← MEM[P].HH.RH END; MEM[Q].HH.RH ← 0; Q ← MEM[H].HH.RH; BEGIN MEM[H].HH.RH ← AVAIL; AVAIL ← H END; COPY_NODE_LIST ← Q END; PROCEDURE PRINT_MODE (M:INTEGER); BEGIN IF M > 0 THEN CASE M DIV 101 OF 0: PRINT (355); 1: PRINT (356); 2: PRINT (357); END ELSE IF M = 0 THEN PRINT (358) ELSE CASE (-M) DIV 101 OF 0: PRINT (359); 1: PRINT (360); 2: PRINT (343); END; PRINT (361) END; PROCEDURE PUSH_NEST; BEGIN IF NEST_PTR > MAX_NEST_STACK THEN BEGIN MAX_NEST_STACK ← NEST_PTR; IF NEST_PTR = NEST_SIZE THEN OVERFLOW (362, NEST_SIZE) END; NEST[NEST_PTR] ← CUR_LIST; NEST_PTR ← NEST_PTR + 1; CUR_LIST.HEAD_FIELD ← GET_AVAIL; CUR_LIST.TAIL_FIELD ← CUR_LIST.HEAD_FIELD; CUR_LIST.PG_FIELD ← 0; CUR_LIST.ML_FIELD ← LINE END; PROCEDURE POP_NEST; BEGIN BEGIN MEM[CUR_LIST.HEAD_FIELD].HH.RH ← AVAIL; AVAIL ← CUR_LIST.HEAD_FIELD END; NEST_PTR ← NEST_PTR - 1; CUR_LIST ← NEST[NEST_PTR] END; PROCEDURE PRINT_TOTALS; FORWARD; PROCEDURE SHOW_ACTIVITIES; VAR P : 0..NEST_SIZE; M : -203..203; A : MEMORY_WORD; Q : HALFWORD; R : HALFWORD; T : INTEGER; BEGIN NEST[NEST_PTR] ← CUR_LIST; PRINT_NL (338); PRINT_LN; FOR P ← NEST_PTR DOWNTO 0 DO BEGIN M ← NEST[P].MODE_FIELD; A ← NEST[P].AUX_FIELD; PRINT_NL (363); PRINT_MODE (M); PRINT (364); PRINT_INT (ABS (NEST[P].ML_FIELD)); IF M = 102 THEN IF NEST[P].PG_FIELD ≠ 8585216 THEN BEGIN PRINT (365); PRINT_INT (NEST[P].PG_FIELD MOD 65536); PRINT (366); PRINT_INT (NEST[P].PG_FIELD DIV 4194304); PRINT_CHAR (44); PRINT_INT (NEST[P].PG_FIELD DIV 65536 MOD 64); PRINT_CHAR (41) END; IF NEST[P].ML_FIELD < 0 THEN PRINT (367); IF P = 0 THEN BEGIN IF 59998 ≠ PAGE_TAIL THEN BEGIN PRINT_NL (980); IF OUTPUT_ACTIVE THEN PRINT (981); SHOW_BOX (MEM[59998].HH.RH); IF PAGE_CONTENTS > 0 THEN BEGIN PRINT_NL (982); PRINT_TOTALS; PRINT_NL (983); PRINT_SCALED (PAGE_SO_FAR[0]); R ← MEM[60000].HH.RH; WHILE R ≠ 60000 DO BEGIN PRINT_LN; PRINT_ESC (330); T ← MEM[R].HH.B1 - 0; PRINT_INT (T); PRINT (984); IF EQTB[9218 + T].INT = 1000 THEN T ← MEM[R + 3].INT ELSE T ← X_OVER_N (MEM[R + 3].INT, 1000) * EQTB[9218 + T].INT; PRINT_SCALED (T); IF MEM[R].HH.B0 = 1 THEN BEGIN Q ← 59998; T ← 0; REPEAT Q ← MEM[Q].HH.RH; IF (MEM[Q].HH.B0 = 3) AND (MEM[Q].HH.B1 = MEM[R].HH.B1) THEN T ← T + 1 UNTIL Q = MEM[R + 1].HH.LH; PRINT (985); PRINT_INT (T); PRINT (986) END; R ← MEM[R].HH.RH END END END; IF MEM[59999].HH.RH ≠ 0 THEN PRINT_NL (368) END; SHOW_BOX (MEM[NEST[P].HEAD_FIELD].HH.RH); CASE ABS (M) DIV 101 OF 0: BEGIN PRINT_NL (369); IF A.INT ≤ -65536000 THEN PRINT (370) ELSE PRINT_SCALED (A.INT); IF NEST[P].PG_FIELD ≠ 0 THEN BEGIN PRINT (371); PRINT_INT (NEST[P].PG_FIELD); PRINT (372); IF NEST[P].PG_FIELD ≠ 1 THEN PRINT_CHAR (115) END END; 1: BEGIN PRINT_NL (373); PRINT_INT (A.HH.LH); IF M > 0 THEN IF A.HH.RH > 0 THEN BEGIN PRINT (374); PRINT_INT (A.HH.RH) END END; 2: IF A.INT ≠ 0 THEN BEGIN PRINT (375); SHOW_BOX (A.INT) END; END END END; PROCEDURE PRINT_PARAM (N:INTEGER); BEGIN CASE N OF 0: PRINT_ESC (420); 1: PRINT_ESC (421); 2: PRINT_ESC (422); 3: PRINT_ESC (423); 4: PRINT_ESC (424); 5: PRINT_ESC (425); 6: PRINT_ESC (426); 7: PRINT_ESC (427); 8: PRINT_ESC (428); 9: PRINT_ESC (429); 10: PRINT_ESC (430); 11: PRINT_ESC (431); 12: PRINT_ESC (432); 13: PRINT_ESC (433); 14: PRINT_ESC (434); 15: PRINT_ESC (435); 16: PRINT_ESC (436); 17: PRINT_ESC (437); 18: PRINT_ESC (438); 19: PRINT_ESC (439); 20: PRINT_ESC (440); 21: PRINT_ESC (441); 22: PRINT_ESC (442); 23: PRINT_ESC (443); 24: PRINT_ESC (444); 25: PRINT_ESC (445); 26: PRINT_ESC (446); 27: PRINT_ESC (447); 28: PRINT_ESC (448); 29: PRINT_ESC (449); 30: PRINT_ESC (450); 31: PRINT_ESC (451); 32: PRINT_ESC (452); 33: PRINT_ESC (453); 34: PRINT_ESC (454); 35: PRINT_ESC (455); 36: PRINT_ESC (456); 37: PRINT_ESC (457); 38: PRINT_ESC (458); 39: PRINT_ESC (459); 40: PRINT_ESC (460); 41: PRINT_ESC (461); 42: PRINT_ESC (462); 43: PRINT_ESC (463); 44: PRINT_ESC (464); 45: PRINT_ESC (465); 46: PRINT_ESC (466); 47: PRINT_ESC (467); 48: PRINT_ESC (468); 49: PRINT_ESC (469); 50: PRINT_ESC (470); 51: PRINT_ESC (471); 52: PRINT_ESC (472); 53: PRINT_ESC (473); 54: PRINT_ESC (474); ELSE PRINT (475); END END; PROCEDURE FIX_DATE_AND_TIME; BEGIN SYS_TIME ← 12 * 60; SYS_DAY ← 4; SYS_MONTH ← 7; SYS_YEAR ← 1776; EQTB[9183].INT ← SYS_TIME; EQTB[9184].INT ← SYS_DAY; EQTB[9185].INT ← SYS_MONTH; EQTB[9186].INT ← SYS_YEAR END; PROCEDURE BEGIN_DIAGNOSTIC; BEGIN OLD_SETTING ← SELECTOR; IF (EQTB[9192].INT ≤ 0) AND (SELECTOR = 19) THEN BEGIN SELECTOR ← SELECTOR - 1; IF HISTORY = 0 THEN HISTORY ← 1 END END; PROCEDURE END_DIAGNOSTIC (BLANK_LINE:BOOLEAN); BEGIN PRINT_NL (338); IF BLANK_LINE THEN PRINT_LN; SELECTOR ← OLD_SETTING END; PROCEDURE PRINT_LENGTH_PARAM (N:INTEGER); BEGIN CASE N OF 0: PRINT_ESC (478); 1: PRINT_ESC (479); 2: PRINT_ESC (480); 3: PRINT_ESC (481); 4: PRINT_ESC (482); 5: PRINT_ESC (483); 6: PRINT_ESC (484); 7: PRINT_ESC (485); 8: PRINT_ESC (486); 9: PRINT_ESC (487); 10: PRINT_ESC (488); 11: PRINT_ESC (489); 12: PRINT_ESC (490); 13: PRINT_ESC (491); 14: PRINT_ESC (492); 15: PRINT_ESC (493); 16: PRINT_ESC (494); 17: PRINT_ESC (495); 18: PRINT_ESC (496); 19: PRINT_ESC (497); 20: PRINT_ESC (498); ELSE PRINT (499); END END; PROCEDURE PRINT_CMD_CHR (CMD:QUARTERWORD; CHR_CODE:HALFWORD); BEGIN CASE CMD OF 1: BEGIN PRINT (557); PRINT (CHR_CODE) END; 2: BEGIN PRINT (558); PRINT (CHR_CODE) END; 3: BEGIN PRINT (559); PRINT (CHR_CODE) END; 6: BEGIN PRINT (560); PRINT (CHR_CODE) END; 7: BEGIN PRINT (561); PRINT (CHR_CODE) END; 8: BEGIN PRINT (562); PRINT (CHR_CODE) END; 9: PRINT (563); 10: BEGIN PRINT (564); PRINT (CHR_CODE) END; 11: BEGIN PRINT (565); PRINT (CHR_CODE) END; 12: BEGIN PRINT (566); PRINT (CHR_CODE) END; 75, 76: IF CHR_CODE < 6800 THEN PRINT_SKIP_PARAM (CHR_CODE - 6782) ELSE IF CHR_CODE < 7056 THEN BEGIN PRINT_ESC (395); PRINT_INT (CHR_CODE - 6800) END ELSE BEGIN PRINT_ESC (396); PRINT_INT (CHR_CODE - 7056) END; 72: IF CHR_CODE ≥ 7322 THEN BEGIN PRINT_ESC (407); PRINT_INT (CHR_CODE - 7322) END ELSE CASE CHR_CODE OF 7313: PRINT_ESC (398); 7314: PRINT_ESC (399); 7315: PRINT_ESC (400); 7316: PRINT_ESC (401); 7317: PRINT_ESC (402); 7318: PRINT_ESC (403); 7319: PRINT_ESC (404); 7320: PRINT_ESC (405); ELSE PRINT_ESC (406); END; 73: IF CHR_CODE < 9218 THEN PRINT_PARAM (CHR_CODE - 9163) ELSE BEGIN PRINT_ESC (476); PRINT_INT (CHR_CODE - 9218) END; 74: IF CHR_CODE < 9751 THEN PRINT_LENGTH_PARAM (CHR_CODE - 9730) ELSE BEGIN PRINT_ESC (500); PRINT_INT (CHR_CODE - 9751) END; 45: PRINT_ESC (508); 90: PRINT_ESC (509); 40: PRINT_ESC (510); 41: PRINT_ESC (511); 77: PRINT_ESC (519); 61: PRINT_ESC (512); 42: PRINT_ESC (531); 16: PRINT_ESC (513); 107: PRINT_ESC (504); 88: PRINT_ESC (518); 15: PRINT_ESC (514); 92: PRINT_ESC (515); 67: PRINT_ESC (505); 62: PRINT_ESC (516); 64: PRINT_ESC (32); 102: PRINT_ESC (517); 32: PRINT_ESC (520); 36: PRINT_ESC (521); 39: PRINT_ESC (522); 37: PRINT_ESC (330); 44: PRINT_ESC (47); 18: PRINT_ESC (351); 46: PRINT_ESC (523); 17: PRINT_ESC (524); 54: PRINT_ESC (525); 91: PRINT_ESC (526); 34: PRINT_ESC (527); 65: PRINT_ESC (528); 103: PRINT_ESC (529); 55: PRINT_ESC (335); 63: PRINT_ESC (530); 66: PRINT_ESC (533); 96: PRINT_ESC (534); 0: PRINT_ESC (535); 98: PRINT_ESC (536); 80: PRINT_ESC (532); 84: PRINT_ESC (408); 109: PRINT_ESC (537); 71: PRINT_ESC (407); 38: PRINT_ESC (352); 33: PRINT_ESC (538); 56: PRINT_ESC (539); 35: PRINT_ESC (540); 13: PRINT_ESC (597); 104: IF CHR_CODE = 0 THEN PRINT_ESC (629) ELSE PRINT_ESC (630); 110: CASE CHR_CODE OF 1: PRINT_ESC (632); 2: PRINT_ESC (633); 3: PRINT_ESC (634); 4: PRINT_ESC (635); ELSE PRINT_ESC (631); END; 89: IF CHR_CODE = 0 THEN PRINT_ESC (476) ELSE IF CHR_CODE = 1 THEN PRINT_ESC (500) ELSE IF CHR_CODE = 2 THEN PRINT_ESC (395) ELSE PRINT_ESC (396); 79: IF CHR_CODE = 1 THEN PRINT_ESC (669) ELSE PRINT_ESC (668); 82: IF CHR_CODE = 0 THEN PRINT_ESC (670) ELSE PRINT_ESC (671); 83: IF CHR_CODE = 1 THEN PRINT_ESC (672) ELSE IF CHR_CODE = 3 THEN PRINT_ESC (673) ELSE PRINT_ESC (674); 70: CASE CHR_CODE OF 0: PRINT_ESC (675); 1: PRINT_ESC (676); 2: PRINT_ESC (677); 3: PRINT_ESC (678); ELSE PRINT_ESC (679); END; 108: CASE CHR_CODE OF 0: PRINT_ESC (735); 1: PRINT_ESC (736); 2: PRINT_ESC (737); 3: PRINT_ESC (738); 4: PRINT_ESC (739); ELSE PRINT_ESC (740); END; 105: CASE CHR_CODE OF 1: PRINT_ESC (758); 2: PRINT_ESC (759); 3: PRINT_ESC (760); 4: PRINT_ESC (761); 5: PRINT_ESC (762); 6: PRINT_ESC (763); 7: PRINT_ESC (764); 8: PRINT_ESC (765); 9: PRINT_ESC (766); 10: PRINT_ESC (767); 11: PRINT_ESC (768); 12: PRINT_ESC (769); 13: PRINT_ESC (770); 14: PRINT_ESC (771); 15: PRINT_ESC (772); 16: PRINT_ESC (773); ELSE PRINT_ESC (757); END; 106: IF CHR_CODE = 2 THEN PRINT_ESC (774) ELSE IF CHR_CODE = 4 THEN PRINT_ESC (775) ELSE PRINT_ESC (776); 4: IF CHR_CODE = 256 THEN PRINT_ESC (898) ELSE BEGIN PRINT (902); PRINT (CHR_CODE) END; 5: IF CHR_CODE = 257 THEN PRINT_ESC (899) ELSE PRINT_ESC (900); 81: CASE CHR_CODE OF 0: PRINT_ESC (970); 1: PRINT_ESC (971); 2: PRINT_ESC (972); 3: PRINT_ESC (973); 4: PRINT_ESC (974); 5: PRINT_ESC (975); 6: PRINT_ESC (976); ELSE PRINT_ESC (977); END; 14: IF CHR_CODE = 1 THEN PRINT_ESC (1026) ELSE PRINT_ESC (1025); 26: CASE CHR_CODE OF 4: PRINT_ESC (1027); 0: PRINT_ESC (1028); 1: PRINT_ESC (1029); 2: PRINT_ESC (1030); ELSE PRINT_ESC (1031); END; 27: CASE CHR_CODE OF 4: PRINT_ESC (1032); 0: PRINT_ESC (1033); 1: PRINT_ESC (1034); 2: PRINT_ESC (1035); ELSE PRINT_ESC (1036); END; 28: PRINT_ESC (336); 29: PRINT_ESC (340); 30: PRINT_ESC (342); 21: IF CHR_CODE = 1 THEN PRINT_ESC (1054) ELSE PRINT_ESC (1055); 22: IF CHR_CODE = 1 THEN PRINT_ESC (1056) ELSE PRINT_ESC (1057); 20: CASE CHR_CODE OF 0: PRINT_ESC (409); 1: PRINT_ESC (1058); 2: PRINT_ESC (1059); 3: PRINT_ESC (965); 4: PRINT_ESC (1060); 5: PRINT_ESC (967); ELSE PRINT_ESC (1061); END; 31: IF CHR_CODE = 100 THEN PRINT_ESC (1063) ELSE IF CHR_CODE = 101 THEN PRINT_ESC (1064) ELSE IF CHR_CODE = 102 THEN PRINT_ESC (1065) ELSE PRINT_ESC (1062); 43: IF CHR_CODE = 0 THEN PRINT_ESC (1081) ELSE PRINT_ESC (1080); 25: IF CHR_CODE = 10 THEN PRINT_ESC (1092) ELSE IF CHR_CODE = 11 THEN PRINT_ESC (1091) ELSE PRINT_ESC (1090); 23: IF CHR_CODE = 1 THEN PRINT_ESC (1094) ELSE PRINT_ESC (1093); 24: IF CHR_CODE = 1 THEN PRINT_ESC (1096) ELSE PRINT_ESC (1095); 47: IF CHR_CODE = 1 THEN PRINT_ESC (45) ELSE PRINT_ESC (349); 48: IF CHR_CODE = 1 THEN PRINT_ESC (1128) ELSE PRINT_ESC (1127); 50: CASE CHR_CODE OF 16: PRINT_ESC (866); 17: PRINT_ESC (867); 18: PRINT_ESC (868); 19: PRINT_ESC (869); 20: PRINT_ESC (870); 21: PRINT_ESC (871); 22: PRINT_ESC (872); 23: PRINT_ESC (873); 26: PRINT_ESC (875); ELSE PRINT_ESC (874); END; 51: IF CHR_CODE = 1 THEN PRINT_ESC (878) ELSE IF CHR_CODE = 2 THEN PRINT_ESC (879) ELSE PRINT_ESC (1129); 53: PRINT_STYLE (CHR_CODE); 52: CASE CHR_CODE OF 1: PRINT_ESC (1148); 2: PRINT_ESC (1149); 3: PRINT_ESC (1150); 4: PRINT_ESC (1151); 5: PRINT_ESC (1152); ELSE PRINT_ESC (1147); END; 49: IF CHR_CODE = 30 THEN PRINT_ESC (876) ELSE PRINT_ESC (877); 93: IF CHR_CODE = 1 THEN PRINT_ESC (1171) ELSE IF CHR_CODE = 2 THEN PRINT_ESC (1172) ELSE PRINT_ESC (1173); 97: IF CHR_CODE = 0 THEN PRINT_ESC (1174) ELSE IF CHR_CODE = 1 THEN PRINT_ESC (1175) ELSE IF CHR_CODE = 2 THEN PRINT_ESC (1176) ELSE PRINT_ESC (1177); 94: IF CHR_CODE ≠ 0 THEN PRINT_ESC (1192) ELSE PRINT_ESC (1191); 95: CASE CHR_CODE OF 0: PRINT_ESC (1193); 1: PRINT_ESC (1194); 2: PRINT_ESC (1195); 3: PRINT_ESC (1196); 4: PRINT_ESC (1197); 5: PRINT_ESC (1198); ELSE PRINT_ESC (1199); END; 68: BEGIN PRINT_ESC (513); PRINT_HEX (CHR_CODE) END; 69: BEGIN PRINT_ESC (524); PRINT_HEX (CHR_CODE) END; 85: IF CHR_CODE = 7883 THEN PRINT_ESC (415) ELSE IF CHR_CODE = 8907 THEN PRINT_ESC (419) ELSE IF CHR_CODE = 8139 THEN PRINT_ESC (416) ELSE IF CHR_CODE = 8395 THEN PRINT_ESC (417) ELSE IF CHR_CODE = 8651 THEN PRINT_ESC (418) ELSE PRINT_ESC (477); 86: PRINT_SIZE (CHR_CODE - 7835); 99: IF CHR_CODE = 1 THEN PRINT_ESC (953) ELSE PRINT_ESC (941); 78: IF CHR_CODE = 0 THEN PRINT_ESC (1217) ELSE PRINT_ESC (1218); 87: BEGIN PRINT (1226); SLOW_PRINT (FONT_NAME[CHR_CODE]); IF FONT_SIZE[CHR_CODE] ≠ FONT_DSIZE[CHR_CODE] THEN BEGIN PRINT (741); PRINT_SCALED (FONT_SIZE[CHR_CODE]); PRINT (397) END END; 100: CASE CHR_CODE OF 0: PRINT_ESC (274); 1: PRINT_ESC (275); 2: PRINT_ESC (276); ELSE PRINT_ESC (1227); END; 60: IF CHR_CODE = 0 THEN PRINT_ESC (1229) ELSE PRINT_ESC (1228); 58: IF CHR_CODE = 0 THEN PRINT_ESC (1230) ELSE PRINT_ESC (1231); 57: IF CHR_CODE = 8139 THEN PRINT_ESC (1237) ELSE PRINT_ESC (1238); 19: CASE CHR_CODE OF 1: PRINT_ESC (1240); 2: PRINT_ESC (1241); 3: PRINT_ESC (1242); ELSE PRINT_ESC (1239); END; 101: PRINT (1249); 111: PRINT (1250); 112: PRINT_ESC (1251); 113: PRINT_ESC (1252); 114: BEGIN PRINT_ESC (1171); PRINT_ESC (1252) END; 115: PRINT_ESC (1253); 59: CASE CHR_CODE OF 0: PRINT_ESC (1285); 1: PRINT_ESC (594); 2: PRINT_ESC (1286); 3: PRINT_ESC (1287); 4: PRINT_ESC (1288); 5: PRINT_ESC (1289); ELSE PRINT (1290); END; ELSE PRINT (567); END END; FUNCTION ID_LOOKUP (J:INTEGER; L:INTEGER):HALFWORD; LABEL 40; VAR H : INTEGER; D : INTEGER; P : HALFWORD; K : HALFWORD; BEGIN H ← BUFFER[J]; FOR K ← J + 1 TO J + L - 1 DO BEGIN H ← H + H + BUFFER[K]; WHILE H ≥ 1777 DO H ← H - 1777 END; P ← H + 514; WHILE TRUE DO BEGIN IF HASH[P].RH > 0 THEN IF STR_START[HASH[P].RH + 1] - STR_START[HASH[P].RH] = L THEN IF STR_EQ_BUF (HASH[P].RH, J) THEN GOTO 40; IF HASH[P].LH = 0 THEN BEGIN IF NO_NEW_CONTROL_SEQUENCE THEN P ← 6781 ELSE BEGIN IF HASH[P].RH > 0 THEN BEGIN REPEAT IF HASH_USED = 514 THEN OVERFLOW (503, 6000); HASH_USED ← HASH_USED - 1 UNTIL HASH[HASH_USED].RH = 0; HASH[P].LH ← HASH_USED; P ← HASH_USED END; BEGIN IF POOL_PTR + L > POOL_SIZE THEN OVERFLOW (257, POOL_SIZE - INIT_POOL_PTR) END; D ← POOL_PTR - STR_START[STR_PTR]; WHILE POOL_PTR > STR_START[STR_PTR] DO BEGIN POOL_PTR ← POOL_PTR - 1; STR_POOL[POOL_PTR + L] ← STR_POOL[POOL_PTR] END; FOR K ← J TO J + L - 1 DO BEGIN STR_POOL[POOL_PTR] ← BUFFER[K]; POOL_PTR ← POOL_PTR + 1 END; HASH[P].RH ← MAKE_STRING; POOL_PTR ← POOL_PTR + D END; GOTO 40 END; P ← HASH[P].LH END; 40: ID_LOOKUP ← P END; PROCEDURE PRIMITIVE (S:STR_NUMBER; C:QUARTERWORD; O:HALFWORD); VAR K : POOL_POINTER; J : SMALL_NUMBER; L : SMALL_NUMBER; BEGIN IF S < 256 THEN CUR_VAL ← S + 257 ELSE BEGIN K ← STR_START[S]; L ← STR_START[S + 1] - K; FOR J ← 0 TO L - 1 DO BUFFER[J] ← STR_POOL[K + J]; CUR_VAL ← ID_LOOKUP (0, L); BEGIN STR_PTR ← STR_PTR - 1; POOL_PTR ← STR_START[STR_PTR] END; HASH[CUR_VAL].RH ← S END; EQTB[CUR_VAL].HH.B1 ← 1; EQTB[CUR_VAL].HH.B0 ← C; EQTB[CUR_VAL].HH.RH ← O END; PROCEDURE NEW_SAVE_LEVEL (C:GROUP_CODE); BEGIN IF SAVE_PTR > MAX_SAVE_STACK THEN BEGIN MAX_SAVE_STACK ← SAVE_PTR; IF MAX_SAVE_STACK > SAVE_SIZE - 6 THEN OVERFLOW (541, SAVE_SIZE) END; SAVE_STACK[SAVE_PTR].HH.B0 ← 3; SAVE_STACK[SAVE_PTR].HH.B1 ← CUR_GROUP; SAVE_STACK[SAVE_PTR].HH.RH ← CUR_BOUNDARY; IF CUR_LEVEL = 255 THEN OVERFLOW (542, 255); CUR_BOUNDARY ← SAVE_PTR; CUR_LEVEL ← CUR_LEVEL + 1; SAVE_PTR ← SAVE_PTR + 1; CUR_GROUP ← C END; PROCEDURE EQ_DESTROY (W:MEMORY_WORD); VAR Q : HALFWORD; BEGIN CASE W.HH.B0 OF 111,112,113,114: DELETE_TOKEN_REF (W.HH.RH); 117: DELETE_GLUE_REF (W.HH.RH); 118: BEGIN Q ← W.HH.RH; IF Q ≠ 0 THEN FREE_NODE (Q, MEM[Q].HH.LH + MEM[Q].HH.LH + 1) END; 119: FLUSH_NODE_LIST (W.HH.RH); ELSE ; END END; PROCEDURE EQ_SAVE (P:HALFWORD; L:QUARTERWORD); BEGIN IF SAVE_PTR > MAX_SAVE_STACK THEN BEGIN MAX_SAVE_STACK ← SAVE_PTR; IF MAX_SAVE_STACK > SAVE_SIZE - 6 THEN OVERFLOW (541, SAVE_SIZE) END; IF L = 0 THEN SAVE_STACK[SAVE_PTR].HH.B0 ← 1 ELSE BEGIN SAVE_STACK[SAVE_PTR] ← EQTB[P]; SAVE_PTR ← SAVE_PTR + 1; SAVE_STACK[SAVE_PTR].HH.B0 ← 0 END; SAVE_STACK[SAVE_PTR].HH.B1 ← L; SAVE_STACK[SAVE_PTR].HH.RH ← P; SAVE_PTR ← SAVE_PTR + 1 END; PROCEDURE EQ_DEFINE (P:HALFWORD; T:QUARTERWORD; E:HALFWORD); BEGIN IF EQTB[P].HH.B1 = CUR_LEVEL THEN EQ_DESTROY (EQTB[P]) ELSE IF CUR_LEVEL > 1 THEN EQ_SAVE (P, EQTB[P].HH.B1); EQTB[P].HH.B1 ← CUR_LEVEL; EQTB[P].HH.B0 ← T; EQTB[P].HH.RH ← E END; PROCEDURE EQ_WORD_DEFINE (P:HALFWORD; W:INTEGER); BEGIN IF XEQ_LEVEL[P] ≠ CUR_LEVEL THEN BEGIN EQ_SAVE (P, XEQ_LEVEL[P]); XEQ_LEVEL[P] ← CUR_LEVEL END; EQTB[P].INT ← W END; PROCEDURE GEQ_DEFINE (P:HALFWORD; T:QUARTERWORD; E:HALFWORD); BEGIN EQ_DESTROY (EQTB[P]); EQTB[P].HH.B1 ← 1; EQTB[P].HH.B0 ← T; EQTB[P].HH.RH ← E END; PROCEDURE GEQ_WORD_DEFINE (P:HALFWORD; W:INTEGER); BEGIN EQTB[P].INT ← W; XEQ_LEVEL[P] ← 1 END; PROCEDURE SAVE_FOR_AFTER (T:HALFWORD); BEGIN IF CUR_LEVEL > 1 THEN BEGIN IF SAVE_PTR > MAX_SAVE_STACK THEN BEGIN MAX_SAVE_STACK ← SAVE_PTR; IF MAX_SAVE_STACK > SAVE_SIZE - 6 THEN OVERFLOW (541, SAVE_SIZE) END; SAVE_STACK[SAVE_PTR].HH.B0 ← 2; SAVE_STACK[SAVE_PTR].HH.B1 ← 0; SAVE_STACK[SAVE_PTR].HH.RH ← T; SAVE_PTR ← SAVE_PTR + 1 END END; PROCEDURE BACK_INPUT; FORWARD; PROCEDURE UNSAVE; LABEL 30; VAR P : HALFWORD; L : QUARTERWORD; T : HALFWORD; BEGIN IF CUR_LEVEL > 1 THEN BEGIN CUR_LEVEL ← CUR_LEVEL - 1; WHILE TRUE DO BEGIN SAVE_PTR ← SAVE_PTR - 1; IF SAVE_STACK[SAVE_PTR].HH.B0 = 3 THEN GOTO 30; P ← SAVE_STACK[SAVE_PTR].HH.RH; IF SAVE_STACK[SAVE_PTR].HH.B0 = 2 THEN BEGIN T ← CUR_TOK; CUR_TOK ← P; BACK_INPUT; CUR_TOK ← T END ELSE BEGIN IF SAVE_STACK[SAVE_PTR].HH.B0 = 0 THEN BEGIN L ← SAVE_STACK[SAVE_PTR].HH.B1; SAVE_PTR ← SAVE_PTR - 1 END ELSE SAVE_STACK[SAVE_PTR] ← EQTB[6781]; IF P < 9163 THEN IF EQTB[P].HH.B1 = 1 THEN BEGIN EQ_DESTROY (SAVE_STACK[SAVE_PTR]) END ELSE BEGIN EQ_DESTROY (EQTB[P]); EQTB[P] ← SAVE_STACK[SAVE_PTR] END ELSE IF XEQ_LEVEL[P] ≠ 1 THEN BEGIN EQTB[P] ← SAVE_STACK[SAVE_PTR]; XEQ_LEVEL[P] ← L END ELSE BEGIN END END END; 30: CUR_GROUP ← SAVE_STACK[SAVE_PTR].HH.B1; CUR_BOUNDARY ← SAVE_STACK[SAVE_PTR].HH.RH END ELSE CONFUSION (543) END; PROCEDURE PREPARE_MAG; BEGIN IF (MAG_SET > 0) AND (EQTB[9180].INT ≠ MAG_SET) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (547) END; PRINT_INT (EQTB[9180].INT); PRINT (548); PRINT_NL (549); BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 550; HELP_LINE[0] ← 551 END; INT_ERROR (MAG_SET); GEQ_WORD_DEFINE (9180, MAG_SET) END; IF (EQTB[9180].INT ≤ 0) OR (EQTB[9180].INT > 32768) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (552) END; BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 553 END; INT_ERROR (EQTB[9180].INT); GEQ_WORD_DEFINE (9180, 1000) END; MAG_SET ← EQTB[9180].INT END; PROCEDURE TOKEN_SHOW (P:HALFWORD); BEGIN IF P ≠ 0 THEN SHOW_TOKEN_LIST (MEM[P].HH.RH, 0, 10000000) END; PROCEDURE PRINT_MEANING; BEGIN PRINT_CMD_CHR (CUR_CMD, CUR_CHR); IF CUR_CMD ≥ 111 THEN BEGIN PRINT_CHAR (58); PRINT_LN; TOKEN_SHOW (CUR_CHR) END ELSE IF CUR_CMD = 110 THEN BEGIN PRINT_CHAR (58); PRINT_LN; TOKEN_SHOW (CUR_MARK[CUR_CHR]) END END; PROCEDURE SHOW_CUR_CMD_CHR; BEGIN BEGIN_DIAGNOSTIC; PRINT_NL (123); IF CUR_LIST.MODE_FIELD ≠ SHOWN_MODE THEN BEGIN PRINT_MODE (CUR_LIST.MODE_FIELD); PRINT (568); SHOWN_MODE ← CUR_LIST.MODE_FIELD END; PRINT_CMD_CHR (CUR_CMD, CUR_CHR); PRINT_CHAR (125); END_DIAGNOSTIC (FALSE) END; PROCEDURE SHOW_CONTEXT; LABEL 30; VAR OLD_SETTING : 0..21; NN : INTEGER; BOTTOM_LINE : BOOLEAN; I : 0..BUF_SIZE; J : 0..BUF_SIZE; L : 0..HALF_ERROR_LINE; M : INTEGER; N : 0..ERROR_LINE; P : INTEGER; Q : INTEGER; BEGIN BASE_PTR ← INPUT_PTR; INPUT_STACK[BASE_PTR] ← CUR_INPUT; NN ← -1; BOTTOM_LINE ← FALSE; WHILE TRUE DO BEGIN CUR_INPUT ← INPUT_STACK[BASE_PTR]; IF CUR_INPUT.STATE_FIELD ≠ 0 THEN IF (CUR_INPUT.NAME_FIELD > 17) OR (BASE_PTR = 0) THEN BOTTOM_LINE ← TRUE; IF (BASE_PTR = INPUT_PTR) OR BOTTOM_LINE OR (NN < EQTB[9217].INT) THEN BEGIN IF (BASE_PTR = INPUT_PTR) OR (CUR_INPUT.STATE_FIELD ≠ 0) OR (CUR_INPUT.INDEX_FIELD ≠ 3) OR (CUR_INPUT.LOC_FIELD ≠ 0) THEN BEGIN TALLY ← 0; OLD_SETTING ← SELECTOR; IF CUR_INPUT.STATE_FIELD ≠ 0 THEN BEGIN IF CUR_INPUT.NAME_FIELD ≤ 17 THEN IF CUR_INPUT.NAME_FIELD = 0 THEN IF BASE_PTR = 0 THEN PRINT_NL (574) ELSE PRINT_NL (575) ELSE BEGIN PRINT_NL (576); IF CUR_INPUT.NAME_FIELD = 17 THEN PRINT_CHAR (42) ELSE PRINT_INT (CUR_INPUT.NAME_FIELD - 1); PRINT_CHAR (62) END ELSE BEGIN PRINT_NL (577); PRINT_INT (LINE) END; PRINT_CHAR (32); BEGIN L ← TALLY; TALLY ← 0; SELECTOR ← 20; TRICK_COUNT ← 1000000 END; IF BUFFER[CUR_INPUT.LIMIT_FIELD] = EQTB[9211].INT THEN J ← CUR_INPUT.LIMIT_FIELD ELSE J ← CUR_INPUT.LIMIT_FIELD + 1; IF J > 0 THEN FOR I ← CUR_INPUT.START_FIELD TO J - 1 DO BEGIN IF I = CUR_INPUT.LOC_FIELD THEN BEGIN FIRST_COUNT ← TALLY; TRICK_COUNT ← TALLY + 1 + ERROR_LINE - HALF_ERROR_LINE; IF TRICK_COUNT < ERROR_LINE THEN TRICK_COUNT ← ERROR_LINE END; PRINT (BUFFER[I]) END END ELSE BEGIN CASE CUR_INPUT.INDEX_FIELD OF 0: PRINT_NL (578); 1,2: PRINT_NL (579); 3: IF CUR_INPUT.LOC_FIELD = 0 THEN PRINT_NL (580) ELSE PRINT_NL (581); 4: PRINT_NL (582); 5: BEGIN PRINT_LN; PRINT_CS (CUR_INPUT.NAME_FIELD) END; 6: PRINT_NL (583); 7: PRINT_NL (584); 8: PRINT_NL (585); 9: PRINT_NL (586); 10: PRINT_NL (587); 11: PRINT_NL (588); 12: PRINT_NL (589); 13: PRINT_NL (590); 14: PRINT_NL (591); 15: PRINT_NL (592); ELSE PRINT_NL (63); END; BEGIN L ← TALLY; TALLY ← 0; SELECTOR ← 20; TRICK_COUNT ← 1000000 END; IF CUR_INPUT.INDEX_FIELD < 5 THEN SHOW_TOKEN_LIST (CUR_INPUT.START_FIELD, CUR_INPUT.LOC_FIELD, 100000) ELSE SHOW_TOKEN_LIST (MEM[CUR_INPUT.START_FIELD].HH.RH, CUR_INPUT.LOC_FIELD, 100000) END; SELECTOR ← OLD_SETTING; IF TRICK_COUNT = 1000000 THEN BEGIN FIRST_COUNT ← TALLY; TRICK_COUNT ← TALLY + 1 + ERROR_LINE - HALF_ERROR_LINE; IF TRICK_COUNT < ERROR_LINE THEN TRICK_COUNT ← ERROR_LINE END; IF TALLY < TRICK_COUNT THEN M ← TALLY - FIRST_COUNT ELSE M ← TRICK_COUNT - FIRST_COUNT; IF L + FIRST_COUNT ≤ HALF_ERROR_LINE THEN BEGIN P ← 0; N ← L + FIRST_COUNT END ELSE BEGIN PRINT (277); P ← L + FIRST_COUNT - HALF_ERROR_LINE + 3; N ← HALF_ERROR_LINE END; FOR Q ← P TO FIRST_COUNT - 1 DO PRINT_CHAR (TRICK_BUF[Q MOD ERROR_LINE]); PRINT_LN; FOR Q ← 1 TO N DO PRINT_CHAR (32); IF M + N ≤ ERROR_LINE THEN P ← FIRST_COUNT + M ELSE P ← FIRST_COUNT + (ERROR_LINE - N - 3); FOR Q ← FIRST_COUNT TO P - 1 DO PRINT_CHAR (TRICK_BUF[Q MOD ERROR_LINE]); IF M + N > ERROR_LINE THEN PRINT (277); NN ← NN + 1 END END ELSE IF NN = EQTB[9217].INT THEN BEGIN PRINT_NL (277); NN ← NN + 1 END; IF BOTTOM_LINE THEN GOTO 30; BASE_PTR ← BASE_PTR - 1 END; 30: CUR_INPUT ← INPUT_STACK[INPUT_PTR] END; PROCEDURE BEGIN_TOKEN_LIST (P:HALFWORD; T:QUARTERWORD); BEGIN BEGIN IF INPUT_PTR > MAX_IN_STACK THEN BEGIN MAX_IN_STACK ← INPUT_PTR; IF INPUT_PTR = STACK_SIZE THEN OVERFLOW (593, STACK_SIZE) END; INPUT_STACK[INPUT_PTR] ← CUR_INPUT; INPUT_PTR ← INPUT_PTR + 1 END; CUR_INPUT.STATE_FIELD ← 0; CUR_INPUT.START_FIELD ← P; CUR_INPUT.INDEX_FIELD ← T; IF T ≥ 5 THEN BEGIN MEM[P].HH.LH ← MEM[P].HH.LH + 1; IF T = 5 THEN CUR_INPUT.LIMIT_FIELD ← PARAM_PTR ELSE BEGIN CUR_INPUT.LOC_FIELD ← MEM[P].HH.RH; IF EQTB[9193].INT > 1 THEN BEGIN BEGIN_DIAGNOSTIC; PRINT_NL (338); CASE T OF 14: PRINT_ESC (351); 15: PRINT_ESC (594); ELSE PRINT_CMD_CHR (72, T + 7307); END; PRINT (556); TOKEN_SHOW (P); END_DIAGNOSTIC (FALSE) END END END ELSE CUR_INPUT.LOC_FIELD ← P END; PROCEDURE END_TOKEN_LIST; BEGIN IF CUR_INPUT.INDEX_FIELD ≥ 3 THEN BEGIN IF CUR_INPUT.INDEX_FIELD ≤ 4 THEN FLUSH_LIST (CUR_INPUT.START_FIELD) ELSE BEGIN DELETE_TOKEN_REF (CUR_INPUT.START_FIELD); IF CUR_INPUT.INDEX_FIELD = 5 THEN WHILE PARAM_PTR > CUR_INPUT.LIMIT_FIELD DO BEGIN PARAM_PTR ← PARAM_PTR - 1; FLUSH_LIST (PARAM_STACK[PARAM_PTR]) END END END ELSE IF CUR_INPUT.INDEX_FIELD = 1 THEN IF ALIGN_STATE > 500000 THEN ALIGN_STATE ← 0 ELSE FATAL_ERROR (595); BEGIN INPUT_PTR ← INPUT_PTR - 1; CUR_INPUT ← INPUT_STACK[INPUT_PTR] END; BEGIN IF INTERRUPT ≠ 0 THEN PAUSE_FOR_INSTRUCTIONS END END; PROCEDURE BACK_INPUT; VAR P : HALFWORD; BEGIN WHILE (CUR_INPUT.STATE_FIELD = 0) AND (CUR_INPUT.LOC_FIELD = 0) AND (CUR_INPUT.INDEX_FIELD ≠ 2) DO END_TOKEN_LIST; P ← GET_AVAIL; MEM[P].HH.LH ← CUR_TOK; IF CUR_TOK < 768 THEN IF CUR_TOK < 512 THEN ALIGN_STATE ← ALIGN_STATE - 1 ELSE ALIGN_STATE ← ALIGN_STATE + 1; BEGIN IF INPUT_PTR > MAX_IN_STACK THEN BEGIN MAX_IN_STACK ← INPUT_PTR; IF INPUT_PTR = STACK_SIZE THEN OVERFLOW (593, STACK_SIZE) END; INPUT_STACK[INPUT_PTR] ← CUR_INPUT; INPUT_PTR ← INPUT_PTR + 1 END; CUR_INPUT.STATE_FIELD ← 0; CUR_INPUT.START_FIELD ← P; CUR_INPUT.INDEX_FIELD ← 3; CUR_INPUT.LOC_FIELD ← P END; PROCEDURE BACK_ERROR; BEGIN OK_TO_INTERRUPT ← FALSE; BACK_INPUT; OK_TO_INTERRUPT ← TRUE; ERROR END; PROCEDURE INS_ERROR; BEGIN OK_TO_INTERRUPT ← FALSE; BACK_INPUT; CUR_INPUT.INDEX_FIELD ← 4; OK_TO_INTERRUPT ← TRUE; ERROR END; PROCEDURE BEGIN_FILE_READING; BEGIN IF IN_OPEN = MAX_IN_OPEN THEN OVERFLOW (596, MAX_IN_OPEN); IF FIRST = BUF_SIZE THEN OVERFLOW (256, BUF_SIZE); IN_OPEN ← IN_OPEN + 1; BEGIN IF INPUT_PTR > MAX_IN_STACK THEN BEGIN MAX_IN_STACK ← INPUT_PTR; IF INPUT_PTR = STACK_SIZE THEN OVERFLOW (593, STACK_SIZE) END; INPUT_STACK[INPUT_PTR] ← CUR_INPUT; INPUT_PTR ← INPUT_PTR + 1 END; CUR_INPUT.INDEX_FIELD ← IN_OPEN; LINE_STACK[CUR_INPUT.INDEX_FIELD] ← LINE; CUR_INPUT.START_FIELD ← FIRST; CUR_INPUT.STATE_FIELD ← 1; CUR_INPUT.NAME_FIELD ← 0 END; PROCEDURE END_FILE_READING; BEGIN FIRST ← CUR_INPUT.START_FIELD; LINE ← LINE_STACK[CUR_INPUT.INDEX_FIELD]; IF CUR_INPUT.NAME_FIELD > 17 THEN A_CLOSE (INPUT_FILE[CUR_INPUT.INDEX_FIELD]); BEGIN INPUT_PTR ← INPUT_PTR - 1; CUR_INPUT ← INPUT_STACK[INPUT_PTR] END; IN_OPEN ← IN_OPEN - 1 END; PROCEDURE CLEAR_FOR_ERROR_PROMPT; BEGIN WHILE (CUR_INPUT.STATE_FIELD ≠ 0) AND (CUR_INPUT.NAME_FIELD = 0) AND (INPUT_PTR > 0) AND (CUR_INPUT.LOC_FIELD > CUR_INPUT.LIMIT_FIELD) DO END_FILE_READING; PRINT_LN; BREAK_IN (TERM_IN, TRUE) END; PROCEDURE CHECK_OUTER_VALIDITY; VAR P : HALFWORD; Q : HALFWORD; BEGIN IF SCANNER_STATUS ≠ 0 THEN BEGIN DELETIONS_ALLOWED ← FALSE; IF CUR_CS ≠ 0 THEN BEGIN IF (CUR_INPUT.STATE_FIELD = 0) OR (CUR_INPUT.NAME_FIELD < 1) OR (CUR_INPUT.NAME_FIELD > 17) THEN BEGIN P ← GET_AVAIL; MEM[P].HH.LH ← 4095 + CUR_CS; BEGIN_TOKEN_LIST (P, 3) END; CUR_CMD ← 10; CUR_CHR ← 32 END; IF SCANNER_STATUS > 1 THEN BEGIN RUNAWAY; IF CUR_CS = 0 THEN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (604) END ELSE BEGIN CUR_CS ← 0; BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (605) END END; PRINT (606); P ← GET_AVAIL; CASE SCANNER_STATUS OF 2: BEGIN PRINT (570); MEM[P].HH.LH ← 637 END; 3: BEGIN PRINT (612); MEM[P].HH.LH ← PAR_TOKEN; LONG_STATE ← 113 END; 4: BEGIN PRINT (572); MEM[P].HH.LH ← 637; Q ← P; P ← GET_AVAIL; MEM[P].HH.RH ← Q; MEM[P].HH.LH ← 10610; ALIGN_STATE ← -1000000 END; 5: BEGIN PRINT (573); MEM[P].HH.LH ← 637 END; END; BEGIN_TOKEN_LIST (P, 4); PRINT (607); SPRINT_CS (WARNING_INDEX); BEGIN HELP_PTR ← 4; HELP_LINE[3] ← 608; HELP_LINE[2] ← 609; HELP_LINE[1] ← 610; HELP_LINE[0] ← 611 END; ERROR END ELSE BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (598) END; PRINT_CMD_CHR (105, CUR_IF); PRINT (599); PRINT_INT (SKIP_LINE); BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 600; HELP_LINE[1] ← 601; HELP_LINE[0] ← 602 END; IF CUR_CS ≠ 0 THEN CUR_CS ← 0 ELSE HELP_LINE[2] ← 603; CUR_TOK ← 10613; INS_ERROR END; DELETIONS_ALLOWED ← TRUE END END; PROCEDURE FIRM_UP_THE_LINE; FORWARD; PROCEDURE GET_NEXT; LABEL 20, 25, 21, 26, 40, 10; VAR K : 0..BUF_SIZE; T : HALFWORD; CAT : 0..15; C : ASCII_CODE; CC : ASCII_CODE; D : 2..3; BEGIN 20: CUR_CS ← 0; IF CUR_INPUT.STATE_FIELD ≠ 0 THEN BEGIN 25: IF CUR_INPUT.LOC_FIELD ≤ CUR_INPUT.LIMIT_FIELD THEN BEGIN CUR_CHR ← BUFFER[CUR_INPUT.LOC_FIELD]; CUR_INPUT.LOC_FIELD ← CUR_INPUT.LOC_FIELD + 1; 21: CUR_CMD ← EQTB[7883 + CUR_CHR].HH.RH; CASE CUR_INPUT.STATE_FIELD + CUR_CMD OF 10,26,42,27,43: GOTO 25; 1,17, 33: BEGIN IF CUR_INPUT.LOC_FIELD > CUR_INPUT.LIMIT_FIELD THEN CUR_CS ← 513 ELSE BEGIN 26: K ← CUR_INPUT.LOC_FIELD; CUR_CHR ← BUFFER[K]; CAT ← EQTB[7883 + CUR_CHR].HH.RH; K ← K + 1; IF CAT = 11 THEN CUR_INPUT.STATE_FIELD ← 17 ELSE IF CAT = 10 THEN CUR_INPUT.STATE_FIELD ← 17 ELSE CUR_INPUT.STATE_FIELD ← 1; IF (CAT = 11) AND (K ≤ CUR_INPUT.LIMIT_FIELD) THEN BEGIN REPEAT CUR_CHR ← BUFFER[K]; CAT ← EQTB[7883 + CUR_CHR].HH.RH; K ← K + 1 UNTIL (CAT ≠ 11) OR (K > CUR_INPUT.LIMIT_FIELD); BEGIN IF BUFFER[K] = CUR_CHR THEN IF CAT = 7 THEN IF K < CUR_INPUT.LIMIT_FIELD THEN BEGIN C ← BUFFER[K + 1]; IF C < 128 THEN BEGIN D ← 2; IF (C ≥ 48) AND (C ≤ 57) OR (C ≥ 97) AND (C ≤ 102) THEN IF K + 2 ≤ CUR_INPUT.LIMIT_FIELD THEN BEGIN CC ← BUFFER[K + 2]; IF (CC ≥ 48) AND (CC ≤ 57) OR (CC ≥ 97) AND (CC ≤ 102) THEN D ← D + 1 END; IF D > 2 THEN BEGIN IF C ≤ 57 THEN CUR_CHR ← C - 48 ELSE CUR_CHR ← C - 87; IF CC ≤ 57 THEN CUR_CHR ← 16 * CUR_CHR + CC - 48 ELSE CUR_CHR ← 16 * CUR_CHR + CC - 87; BUFFER[K - 1] ← CUR_CHR END ELSE IF C < 64 THEN BUFFER[K - 1] ← C + 64 ELSE BUFFER[K - 1] ← C - 64; CUR_INPUT.LIMIT_FIELD ← CUR_INPUT.LIMIT_FIELD - D; FIRST ← FIRST - D; WHILE K ≤ CUR_INPUT.LIMIT_FIELD DO BEGIN BUFFER[K] ← BUFFER[K + D]; K ← K + 1 END; GOTO 26 END END END; IF CAT ≠ 11 THEN K ← K - 1; IF K > CUR_INPUT.LOC_FIELD + 1 THEN BEGIN CUR_CS ← ID_LOOKUP (CUR_INPUT.LOC_FIELD, K - CUR_INPUT.LOC_FIELD); CUR_INPUT.LOC_FIELD ← K; GOTO 40 END END ELSE BEGIN IF BUFFER[K] = CUR_CHR THEN IF CAT = 7 THEN IF K < CUR_INPUT.LIMIT_FIELD THEN BEGIN C ← BUFFER[K + 1]; IF C < 128 THEN BEGIN D ← 2; IF (C ≥ 48) AND (C ≤ 57) OR (C ≥ 97) AND (C ≤ 102) THEN IF K + 2 ≤ CUR_INPUT.LIMIT_FIELD THEN BEGIN CC ← BUFFER[K + 2]; IF (CC ≥ 48) AND (CC ≤ 57) OR (CC ≥ 97) AND (CC ≤ 102) THEN D ← D + 1 END; IF D > 2 THEN BEGIN IF C ≤ 57 THEN CUR_CHR ← C - 48 ELSE CUR_CHR ← C - 87; IF CC ≤ 57 THEN CUR_CHR ← 16 * CUR_CHR + CC - 48 ELSE CUR_CHR ← 16 * CUR_CHR + CC - 87; BUFFER[K - 1] ← CUR_CHR END ELSE IF C < 64 THEN BUFFER[K - 1] ← C + 64 ELSE BUFFER[K - 1] ← C - 64; CUR_INPUT.LIMIT_FIELD ← CUR_INPUT.LIMIT_FIELD - D; FIRST ← FIRST - D; WHILE K ≤ CUR_INPUT.LIMIT_FIELD DO BEGIN BUFFER[K] ← BUFFER[K + D]; K ← K + 1 END; GOTO 26 END END END; CUR_CS ← 257 + BUFFER[CUR_INPUT.LOC_FIELD]; CUR_INPUT.LOC_FIELD ← CUR_INPUT.LOC_FIELD + 1 END; 40: CUR_CMD ← EQTB[CUR_CS].HH.B0; CUR_CHR ← EQTB[CUR_CS].HH.RH; IF CUR_CMD ≥ 113 THEN CHECK_OUTER_VALIDITY END; 14,30, 46: BEGIN CUR_CS ← CUR_CHR + 1; CUR_CMD ← EQTB[CUR_CS].HH.B0; CUR_CHR ← EQTB[CUR_CS].HH.RH; CUR_INPUT.STATE_FIELD ← 1; IF CUR_CMD ≥ 113 THEN CHECK_OUTER_VALIDITY END; 8,24, 40: BEGIN IF CUR_CHR = BUFFER[CUR_INPUT.LOC_FIELD] THEN IF CUR_INPUT.LOC_FIELD < CUR_INPUT.LIMIT_FIELD THEN BEGIN C ← BUFFER[CUR_INPUT.LOC_FIELD + 1]; IF C < 128 THEN BEGIN CUR_INPUT.LOC_FIELD ← CUR_INPUT.LOC_FIELD + 2; IF (C ≥ 48) AND (C ≤ 57) OR (C ≥ 97) AND (C ≤ 102) THEN IF CUR_INPUT.LOC_FIELD ≤ CUR_INPUT.LIMIT_FIELD THEN BEGIN CC ← BUFFER[CUR_INPUT.LOC_FIELD]; IF (CC ≥ 48) AND (CC ≤ 57) OR (CC ≥ 97) AND (CC ≤ 102) THEN BEGIN CUR_INPUT.LOC_FIELD ← CUR_INPUT.LOC_FIELD + 1; IF C ≤ 57 THEN CUR_CHR ← C - 48 ELSE CUR_CHR ← C - 87; IF CC ≤ 57 THEN CUR_CHR ← 16 * CUR_CHR + CC - 48 ELSE CUR_CHR ← 16 * CUR_CHR + CC - 87; GOTO 21 END END; IF C < 64 THEN CUR_CHR ← C + 64 ELSE CUR_CHR ← C - 64; GOTO 21 END END; CUR_INPUT.STATE_FIELD ← 1 END; 16,32, 48: BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (613) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 614; HELP_LINE[0] ← 615 END; DELETIONS_ALLOWED ← FALSE; ERROR; DELETIONS_ALLOWED ← TRUE; GOTO 20 END; 11: BEGIN CUR_INPUT.STATE_FIELD ← 17; CUR_CHR ← 32 END; 6: BEGIN CUR_INPUT.LOC_FIELD ← CUR_INPUT.LIMIT_FIELD + 1; CUR_CMD ← 10; CUR_CHR ← 32 END; 22,15,31, 47: BEGIN CUR_INPUT.LOC_FIELD ← CUR_INPUT.LIMIT_FIELD + 1; GOTO 25 END; 38: BEGIN CUR_INPUT.LOC_FIELD ← CUR_INPUT.LIMIT_FIELD + 1; CUR_CS ← PAR_LOC; CUR_CMD ← EQTB[CUR_CS].HH.B0; CUR_CHR ← EQTB[CUR_CS].HH.RH; IF CUR_CMD ≥ 113 THEN CHECK_OUTER_VALIDITY END; 2: ALIGN_STATE ← ALIGN_STATE + 1; 18, 34: BEGIN CUR_INPUT.STATE_FIELD ← 1; ALIGN_STATE ← ALIGN_STATE + 1 END; 3: ALIGN_STATE ← ALIGN_STATE - 1; 19, 35: BEGIN CUR_INPUT.STATE_FIELD ← 1; ALIGN_STATE ← ALIGN_STATE - 1 END; 20,21,23,25,28,29,36,37,39,41,44,45: CUR_INPUT.STATE_FIELD ← 1; ELSE ; END END ELSE BEGIN CUR_INPUT.STATE_FIELD ← 33; IF CUR_INPUT.NAME_FIELD > 17 THEN BEGIN LINE ← LINE + 1; FIRST ← CUR_INPUT.START_FIELD; IF NOT FORCE_EOF THEN BEGIN IF INPUT_LN (INPUT_FILE[CUR_INPUT.INDEX_FIELD], TRUE) THEN FIRM_UP_THE_LINE ELSE FORCE_EOF ← TRUE END; IF FORCE_EOF THEN BEGIN PRINT_CHAR (41); OPEN_PARENS ← OPEN_PARENS - 1; BREAK (TERM_OUT); FORCE_EOF ← FALSE; END_FILE_READING; CHECK_OUTER_VALIDITY; GOTO 20 END; IF (EQTB[9211].INT < 0) OR (EQTB[9211].INT > 255) THEN CUR_INPUT.LIMIT_FIELD ← CUR_INPUT.LIMIT_FIELD - 1 ELSE BUFFER[CUR_INPUT.LIMIT_FIELD] ← EQTB[9211].INT; FIRST ← CUR_INPUT.LIMIT_FIELD + 1; CUR_INPUT.LOC_FIELD ← CUR_INPUT.START_FIELD END ELSE BEGIN IF NOT (CUR_INPUT.NAME_FIELD = 0) THEN BEGIN CUR_CMD ← 0; CUR_CHR ← 0; GOTO 10 END; IF INPUT_PTR > 0 THEN BEGIN END_FILE_READING; GOTO 20 END; IF SELECTOR < 18 THEN OPEN_LOG_FILE; IF INTERACTION > 1 THEN BEGIN IF (EQTB[9211].INT < 0) OR (EQTB[9211].INT > 255) THEN CUR_INPUT.LIMIT_FIELD ← CUR_INPUT.LIMIT_FIELD + 1; IF CUR_INPUT.LIMIT_FIELD = CUR_INPUT.START_FIELD THEN PRINT_NL (616); PRINT_LN; FIRST ← CUR_INPUT.START_FIELD; BEGIN PRINT (42); TERM_INPUT END; CUR_INPUT.LIMIT_FIELD ← LAST; IF (EQTB[9211].INT < 0) OR (EQTB[9211].INT > 255) THEN CUR_INPUT.LIMIT_FIELD ← CUR_INPUT.LIMIT_FIELD - 1 ELSE BUFFER[CUR_INPUT.LIMIT_FIELD] ← EQTB[9211].INT; FIRST ← CUR_INPUT.LIMIT_FIELD + 1; CUR_INPUT.LOC_FIELD ← CUR_INPUT.START_FIELD END ELSE FATAL_ERROR (617) END; BEGIN IF INTERRUPT ≠ 0 THEN PAUSE_FOR_INSTRUCTIONS END; GOTO 25 END END ELSE IF CUR_INPUT.LOC_FIELD ≠ 0 THEN BEGIN T ← MEM[CUR_INPUT.LOC_FIELD].HH.LH; CUR_INPUT.LOC_FIELD ← MEM[CUR_INPUT.LOC_FIELD].HH.RH; IF T ≥ 4095 THEN BEGIN CUR_CS ← T - 4095; CUR_CMD ← EQTB[CUR_CS].HH.B0; CUR_CHR ← EQTB[CUR_CS].HH.RH; IF CUR_CMD ≥ 113 THEN IF CUR_CMD = 116 THEN BEGIN CUR_CS ← MEM[CUR_INPUT.LOC_FIELD].HH.LH - 4095; CUR_INPUT.LOC_FIELD ← 0; CUR_CMD ← EQTB[CUR_CS].HH.B0; CUR_CHR ← EQTB[CUR_CS].HH.RH; IF CUR_CMD > 100 THEN BEGIN CUR_CMD ← 0; CUR_CHR ← 257 END END ELSE CHECK_OUTER_VALIDITY END ELSE BEGIN CUR_CMD ← T DIV 256; CUR_CHR ← T MOD 256; CASE CUR_CMD OF 1: ALIGN_STATE ← ALIGN_STATE + 1; 2: ALIGN_STATE ← ALIGN_STATE - 1; 5: BEGIN BEGIN_TOKEN_LIST (PARAM_STACK[CUR_INPUT.LIMIT_FIELD + CUR_CHR - 1], 0); GOTO 20 END; ELSE ; END END END ELSE BEGIN END_TOKEN_LIST; GOTO 20 END; IF CUR_CMD ≤ 5 THEN IF CUR_CMD ≥ 4 THEN IF ALIGN_STATE = 0 THEN BEGIN IF (SCANNER_STATUS = 4) OR (CUR_ALIGN = 0) THEN FATAL_ERROR (595); CUR_CMD ← MEM[CUR_ALIGN + 5].HH.LH; MEM[CUR_ALIGN + 5].HH.LH ← CUR_CHR; IF CUR_CMD = 63 THEN BEGIN_TOKEN_LIST (59990, 2) ELSE BEGIN_TOKEN_LIST (MEM[CUR_ALIGN + 2].INT, 2); ALIGN_STATE ← 1000000; GOTO 20 END; 10: END; PROCEDURE FIRM_UP_THE_LINE; VAR K : 0..BUF_SIZE; BEGIN CUR_INPUT.LIMIT_FIELD ← LAST; IF EQTB[9191].INT > 0 THEN IF INTERACTION > 1 THEN BEGIN PRINT_LN; IF CUR_INPUT.START_FIELD < CUR_INPUT.LIMIT_FIELD THEN FOR K ← CUR_INPUT.START_FIELD TO CUR_INPUT.LIMIT_FIELD - 1 DO PRINT (BUFFER[K]); FIRST ← CUR_INPUT.LIMIT_FIELD; BEGIN PRINT (618); TERM_INPUT END; IF LAST > FIRST THEN BEGIN FOR K ← FIRST TO LAST - 1 DO BUFFER[K + CUR_INPUT.START_FIELD - FIRST] ← BUFFER[K]; CUR_INPUT.LIMIT_FIELD ← CUR_INPUT.START_FIELD + LAST - FIRST END END END; PROCEDURE GET_TOKEN; BEGIN NO_NEW_CONTROL_SEQUENCE ← FALSE; GET_NEXT; NO_NEW_CONTROL_SEQUENCE ← TRUE; IF CUR_CS = 0 THEN CUR_TOK ← CUR_CMD * 256 + CUR_CHR ELSE CUR_TOK ← 4095 + CUR_CS END; PROCEDURE MACRO_CALL; LABEL 10, 22, 30, 31, 40; VAR R : HALFWORD; P : HALFWORD; Q : HALFWORD; S : HALFWORD; T : HALFWORD; U : HALFWORD; V : HALFWORD; RBRACE_PTR : HALFWORD; N : SMALL_NUMBER; UNBALANCE : HALFWORD; M : HALFWORD; REF_COUNT : HALFWORD; SAVE_SCANNER_STATUS : SMALL_NUMBER; SAVE_WARNING_INDEX : HALFWORD; MATCH_CHR : ASCII_CODE; BEGIN SAVE_SCANNER_STATUS ← SCANNER_STATUS; SAVE_WARNING_INDEX ← WARNING_INDEX; WARNING_INDEX ← CUR_CS; REF_COUNT ← CUR_CHR; R ← MEM[REF_COUNT].HH.RH; N ← 0; IF EQTB[9193].INT > 0 THEN BEGIN BEGIN_DIAGNOSTIC; PRINT_LN; PRINT_CS (WARNING_INDEX); TOKEN_SHOW (REF_COUNT); END_DIAGNOSTIC (FALSE) END; IF MEM[R].HH.LH ≠ 3584 THEN BEGIN SCANNER_STATUS ← 3; UNBALANCE ← 0; LONG_STATE ← EQTB[CUR_CS].HH.B0; IF LONG_STATE ≥ 113 THEN LONG_STATE ← LONG_STATE - 2; REPEAT MEM[59997].HH.RH ← 0; IF (MEM[R].HH.LH > 3583) OR (MEM[R].HH.LH < 3328) THEN S ← 0 ELSE BEGIN MATCH_CHR ← MEM[R].HH.LH - 3328; S ← MEM[R].HH.RH; R ← S; P ← 59997; M ← 0 END; 22: GET_TOKEN; IF CUR_TOK = MEM[R].HH.LH THEN BEGIN R ← MEM[R].HH.RH; IF (MEM[R].HH.LH ≥ 3328) AND (MEM[R].HH.LH ≤ 3584) THEN BEGIN IF CUR_TOK < 512 THEN ALIGN_STATE ← ALIGN_STATE - 1; GOTO 40 END ELSE GOTO 22 END; IF S ≠ R THEN IF S = 0 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (650) END; SPRINT_CS (WARNING_INDEX); PRINT (651); BEGIN HELP_PTR ← 4; HELP_LINE[3] ← 652; HELP_LINE[2] ← 653; HELP_LINE[1] ← 654; HELP_LINE[0] ← 655 END; ERROR; GOTO 10 END ELSE BEGIN T ← S; REPEAT BEGIN Q ← GET_AVAIL; MEM[P].HH.RH ← Q; MEM[Q].HH.LH ← MEM[T].HH.LH; P ← Q END; M ← M + 1; U ← MEM[T].HH.RH; V ← S; WHILE TRUE DO BEGIN IF U = R THEN IF CUR_TOK ≠ MEM[V].HH.LH THEN GOTO 30 ELSE BEGIN R ← MEM[V].HH.RH; GOTO 22 END; IF MEM[U].HH.LH ≠ MEM[V].HH.LH THEN GOTO 30; U ← MEM[U].HH.RH; V ← MEM[V].HH.RH END; 30: T ← MEM[T].HH.RH UNTIL T = R; R ← S END; IF CUR_TOK = PAR_TOKEN THEN IF LONG_STATE ≠ 112 THEN BEGIN IF LONG_STATE = 111 THEN BEGIN RUNAWAY; BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (645) END; SPRINT_CS (WARNING_INDEX); PRINT (646); BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 647; HELP_LINE[1] ← 648; HELP_LINE[0] ← 649 END; BACK_ERROR END; PSTACK[N] ← MEM[59997].HH.RH; ALIGN_STATE ← ALIGN_STATE - UNBALANCE; FOR M ← 0 TO N DO FLUSH_LIST (PSTACK[M]); GOTO 10 END; IF CUR_TOK < 768 THEN IF CUR_TOK < 512 THEN BEGIN UNBALANCE ← 1; WHILE TRUE DO BEGIN BEGIN BEGIN Q ← AVAIL; IF Q = 0 THEN Q ← GET_AVAIL ELSE BEGIN AVAIL ← MEM[Q].HH.RH; MEM[Q].HH.RH ← 0 END END; MEM[P].HH.RH ← Q; MEM[Q].HH.LH ← CUR_TOK; P ← Q END; GET_TOKEN; IF CUR_TOK = PAR_TOKEN THEN IF LONG_STATE ≠ 112 THEN BEGIN IF LONG_STATE = 111 THEN BEGIN RUNAWAY; BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (645) END; SPRINT_CS (WARNING_INDEX); PRINT (646); BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 647; HELP_LINE[1] ← 648; HELP_LINE[0] ← 649 END; BACK_ERROR END; PSTACK[N] ← MEM[59997].HH.RH; ALIGN_STATE ← ALIGN_STATE - UNBALANCE; FOR M ← 0 TO N DO FLUSH_LIST (PSTACK[M]); GOTO 10 END; IF CUR_TOK < 768 THEN IF CUR_TOK < 512 THEN UNBALANCE ← UNBALANCE + 1 ELSE BEGIN UNBALANCE ← UNBALANCE - 1; IF UNBALANCE = 0 THEN GOTO 31 END END; 31: RBRACE_PTR ← P; BEGIN Q ← GET_AVAIL; MEM[P].HH.RH ← Q; MEM[Q].HH.LH ← CUR_TOK; P ← Q END END ELSE BEGIN BACK_INPUT; BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (637) END; SPRINT_CS (WARNING_INDEX); PRINT (638); BEGIN HELP_PTR ← 6; HELP_LINE[5] ← 639; HELP_LINE[4] ← 640; HELP_LINE[3] ← 641; HELP_LINE[2] ← 642; HELP_LINE[1] ← 643; HELP_LINE[0] ← 644 END; ALIGN_STATE ← ALIGN_STATE + 1; LONG_STATE ← 111; CUR_TOK ← PAR_TOKEN; INS_ERROR; GOTO 22 END ELSE BEGIN IF CUR_TOK = 2592 THEN IF MEM[R].HH.LH ≤ 3584 THEN IF MEM[R].HH.LH ≥ 3328 THEN GOTO 22; BEGIN Q ← GET_AVAIL; MEM[P].HH.RH ← Q; MEM[Q].HH.LH ← CUR_TOK; P ← Q END END; M ← M + 1; IF MEM[R].HH.LH > 3584 THEN GOTO 22; IF MEM[R].HH.LH < 3328 THEN GOTO 22; 40: IF S ≠ 0 THEN BEGIN IF (M = 1) AND (MEM[P].HH.LH < 768) THEN BEGIN MEM[RBRACE_PTR].HH.RH ← 0; BEGIN MEM[P].HH.RH ← AVAIL; AVAIL ← P END; P ← MEM[59997].HH.RH; PSTACK[N] ← MEM[P].HH.RH; BEGIN MEM[P].HH.RH ← AVAIL; AVAIL ← P END END ELSE PSTACK[N] ← MEM[59997].HH.RH; N ← N + 1; IF EQTB[9193].INT > 0 THEN BEGIN BEGIN_DIAGNOSTIC; PRINT_NL (MATCH_CHR); PRINT_INT (N); PRINT (656); SHOW_TOKEN_LIST (PSTACK[N - 1], 0, 1000); END_DIAGNOSTIC (FALSE) END END UNTIL MEM[R].HH.LH = 3584 END; WHILE (CUR_INPUT.STATE_FIELD = 0) AND (CUR_INPUT.LOC_FIELD = 0) AND (CUR_INPUT.INDEX_FIELD ≠ 2) DO END_TOKEN_LIST; BEGIN_TOKEN_LIST (REF_COUNT, 5); CUR_INPUT.NAME_FIELD ← WARNING_INDEX; CUR_INPUT.LOC_FIELD ← MEM[R].HH.RH; IF N > 0 THEN BEGIN IF PARAM_PTR + N > MAX_PARAM_STACK THEN BEGIN MAX_PARAM_STACK ← PARAM_PTR + N; IF MAX_PARAM_STACK > PARAM_SIZE THEN OVERFLOW (636, PARAM_SIZE) END; FOR M ← 0 TO N - 1 DO PARAM_STACK[PARAM_PTR + M] ← PSTACK[M]; PARAM_PTR ← PARAM_PTR + N END; 10: SCANNER_STATUS ← SAVE_SCANNER_STATUS; WARNING_INDEX ← SAVE_WARNING_INDEX END; PROCEDURE INSERT_RELAX; BEGIN CUR_TOK ← 4095 + CUR_CS; BACK_INPUT; CUR_TOK ← 10616; BACK_INPUT; CUR_INPUT.INDEX_FIELD ← 4 END; PROCEDURE PASS_TEXT; FORWARD; PROCEDURE START_INPUT; FORWARD; PROCEDURE CONDITIONAL; FORWARD; PROCEDURE GET_X_TOKEN; FORWARD; PROCEDURE CONV_TOKS; FORWARD; PROCEDURE INS_THE_TOKS; FORWARD; PROCEDURE EXPAND; VAR T : HALFWORD; P : HALFWORD; Q : HALFWORD; R : HALFWORD; J : 0..BUF_SIZE; CV_BACKUP : INTEGER; CVL_BACKUP : SMALL_NUMBER; RADIX_BACKUP : SMALL_NUMBER; CO_BACKUP : SMALL_NUMBER; BACKUP_BACKUP : HALFWORD; SAVE_SCANNER_STATUS : SMALL_NUMBER; BEGIN CV_BACKUP ← CUR_VAL; CVL_BACKUP ← CUR_VAL_LEVEL; RADIX_BACKUP ← RADIX; CO_BACKUP ← CUR_ORDER; BACKUP_BACKUP ← MEM[59987].HH.RH; IF CUR_CMD < 111 THEN BEGIN IF EQTB[9199].INT > 1 THEN SHOW_CUR_CMD_CHR; CASE CUR_CMD OF 110: BEGIN IF CUR_MARK[CUR_CHR] ≠ 0 THEN BEGIN_TOKEN_LIST (CUR_MARK[CUR_CHR], 14) END; 102: BEGIN GET_TOKEN; T ← CUR_TOK; GET_TOKEN; IF CUR_CMD > 100 THEN EXPAND ELSE BACK_INPUT; CUR_TOK ← T; BACK_INPUT END; 103: BEGIN SAVE_SCANNER_STATUS ← SCANNER_STATUS; SCANNER_STATUS ← 0; GET_TOKEN; SCANNER_STATUS ← SAVE_SCANNER_STATUS; T ← CUR_TOK; BACK_INPUT; IF T ≥ 4095 THEN BEGIN P ← GET_AVAIL; MEM[P].HH.LH ← 10618; MEM[P].HH.RH ← CUR_INPUT.LOC_FIELD; CUR_INPUT.START_FIELD ← P; CUR_INPUT.LOC_FIELD ← P END END; 107: BEGIN R ← GET_AVAIL; P ← R; REPEAT GET_X_TOKEN; IF CUR_CS = 0 THEN BEGIN Q ← GET_AVAIL; MEM[P].HH.RH ← Q; MEM[Q].HH.LH ← CUR_TOK; P ← Q END UNTIL CUR_CS ≠ 0; IF CUR_CMD ≠ 67 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (625) END; PRINT_ESC (505); PRINT (626); BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 627; HELP_LINE[0] ← 628 END; BACK_ERROR END; J ← FIRST; P ← MEM[R].HH.RH; WHILE P ≠ 0 DO BEGIN IF J ≥ MAX_BUF_STACK THEN BEGIN MAX_BUF_STACK ← J + 1; IF MAX_BUF_STACK = BUF_SIZE THEN OVERFLOW (256, BUF_SIZE) END; BUFFER[J] ← MEM[P].HH.LH MOD 256; J ← J + 1; P ← MEM[P].HH.RH END; IF J > FIRST + 1 THEN BEGIN NO_NEW_CONTROL_SEQUENCE ← FALSE; CUR_CS ← ID_LOOKUP (FIRST, J - FIRST); NO_NEW_CONTROL_SEQUENCE ← TRUE END ELSE IF J = FIRST THEN CUR_CS ← 513 ELSE CUR_CS ← 257 + BUFFER[FIRST]; FLUSH_LIST (R); IF EQTB[CUR_CS].HH.B0 = 101 THEN BEGIN EQ_DEFINE (CUR_CS, 0, 256) END; CUR_TOK ← CUR_CS + 4095; BACK_INPUT END; 108: CONV_TOKS; 109: INS_THE_TOKS; 105: CONDITIONAL; 106: IF CUR_CHR > IF_LIMIT THEN IF IF_LIMIT = 1 THEN INSERT_RELAX ELSE BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (777) END; PRINT_CMD_CHR (106, CUR_CHR); BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 778 END; ERROR END ELSE BEGIN WHILE CUR_CHR ≠ 2 DO PASS_TEXT; BEGIN P ← COND_PTR; IF_LINE ← MEM[P + 1].INT; CUR_IF ← MEM[P].HH.B1; IF_LIMIT ← MEM[P].HH.B0; COND_PTR ← MEM[P].HH.RH; FREE_NODE (P, 2) END END; 104: IF CUR_CHR > 0 THEN FORCE_EOF ← TRUE ELSE IF NAME_IN_PROGRESS THEN INSERT_RELAX ELSE START_INPUT; ELSE BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (619) END; BEGIN HELP_PTR ← 5; HELP_LINE[4] ← 620; HELP_LINE[3] ← 621; HELP_LINE[2] ← 622; HELP_LINE[1] ← 623; HELP_LINE[0] ← 624 END; ERROR END; END END ELSE IF CUR_CMD < 115 THEN MACRO_CALL ELSE BEGIN CUR_TOK ← 10615; BACK_INPUT END; CUR_VAL ← CV_BACKUP; CUR_VAL_LEVEL ← CVL_BACKUP; RADIX ← RADIX_BACKUP; CUR_ORDER ← CO_BACKUP; MEM[59987].HH.RH ← BACKUP_BACKUP END; PROCEDURE GET_X_TOKEN; LABEL 20, 30; BEGIN 20: GET_NEXT; IF CUR_CMD ≤ 100 THEN GOTO 30; IF CUR_CMD ≥ 111 THEN IF CUR_CMD < 115 THEN MACRO_CALL ELSE BEGIN CUR_CS ← 6520; CUR_CMD ← 9; GOTO 30 END ELSE EXPAND; GOTO 20; 30: IF CUR_CS = 0 THEN CUR_TOK ← CUR_CMD * 256 + CUR_CHR ELSE CUR_TOK ← 4095 + CUR_CS END; PROCEDURE X_TOKEN; BEGIN WHILE CUR_CMD > 100 DO BEGIN EXPAND; GET_NEXT END; IF CUR_CS = 0 THEN CUR_TOK ← CUR_CMD * 256 + CUR_CHR ELSE CUR_TOK ← 4095 + CUR_CS END; PROCEDURE SCAN_LEFT_BRACE; BEGIN REPEAT GET_X_TOKEN UNTIL (CUR_CMD ≠ 10) AND (CUR_CMD ≠ 0); IF CUR_CMD ≠ 1 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (657) END; BEGIN HELP_PTR ← 4; HELP_LINE[3] ← 658; HELP_LINE[2] ← 659; HELP_LINE[1] ← 660; HELP_LINE[0] ← 661 END; BACK_ERROR; CUR_TOK ← 379; CUR_CMD ← 1; CUR_CHR ← 123; ALIGN_STATE ← ALIGN_STATE + 1 END END; PROCEDURE SCAN_OPTIONAL_EQUALS; BEGIN REPEAT GET_X_TOKEN UNTIL CUR_CMD ≠ 10; IF CUR_TOK ≠ 3133 THEN BACK_INPUT END; FUNCTION SCAN_KEYWORD (S:STR_NUMBER):BOOLEAN; LABEL 10; VAR P : HALFWORD; Q : HALFWORD; K : POOL_POINTER; BEGIN P ← 59987; MEM[P].HH.RH ← 0; K ← STR_START[S]; WHILE K < STR_START[S + 1] DO BEGIN GET_X_TOKEN; IF (CUR_CS = 0) AND ((CUR_CHR = STR_POOL[K]) OR (CUR_CHR = STR_POOL[K] - 32)) THEN BEGIN BEGIN Q ← GET_AVAIL; MEM[P].HH.RH ← Q; MEM[Q].HH.LH ← CUR_TOK; P ← Q END; K ← K + 1 END ELSE IF (CUR_CMD ≠ 10) OR (P ≠ 59987) THEN BEGIN BACK_INPUT; IF P ≠ 59987 THEN BEGIN_TOKEN_LIST (MEM[59987].HH.RH, 3); SCAN_KEYWORD ← FALSE; GOTO 10 END END; FLUSH_LIST (MEM[59987].HH.RH); SCAN_KEYWORD ← TRUE; 10: END; PROCEDURE MU_ERROR; BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (662) END; BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 663 END; ERROR END; PROCEDURE SCAN_INT; FORWARD; PROCEDURE SCAN_EIGHT_BIT_INT; BEGIN SCAN_INT; IF (CUR_VAL < 0) OR (CUR_VAL > 255) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (687) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 688; HELP_LINE[0] ← 689 END; INT_ERROR (CUR_VAL); CUR_VAL ← 0 END END; PROCEDURE SCAN_CHAR_NUM; BEGIN SCAN_INT; IF (CUR_VAL < 0) OR (CUR_VAL > 255) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (690) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 691; HELP_LINE[0] ← 689 END; INT_ERROR (CUR_VAL); CUR_VAL ← 0 END END; PROCEDURE SCAN_FOUR_BIT_INT; BEGIN SCAN_INT; IF (CUR_VAL < 0) OR (CUR_VAL > 15) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (692) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 693; HELP_LINE[0] ← 689 END; INT_ERROR (CUR_VAL); CUR_VAL ← 0 END END; PROCEDURE SCAN_FIFTEEN_BIT_INT; BEGIN SCAN_INT; IF (CUR_VAL < 0) OR (CUR_VAL > 32767) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (694) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 695; HELP_LINE[0] ← 689 END; INT_ERROR (CUR_VAL); CUR_VAL ← 0 END END; PROCEDURE SCAN_TWENTY_SEVEN_BIT_INT; BEGIN SCAN_INT; IF (CUR_VAL < 0) OR (CUR_VAL > 134217727) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (696) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 697; HELP_LINE[0] ← 689 END; INT_ERROR (CUR_VAL); CUR_VAL ← 0 END END; PROCEDURE SCAN_FONT_IDENT; VAR F : INTERNAL_FONT_NUMBER; M : HALFWORD; BEGIN REPEAT GET_X_TOKEN UNTIL CUR_CMD ≠ 10; IF CUR_CMD = 88 THEN F ← EQTB[7834].HH.RH ELSE IF CUR_CMD = 87 THEN F ← CUR_CHR ELSE IF CUR_CMD = 86 THEN BEGIN M ← CUR_CHR; SCAN_FOUR_BIT_INT; F ← EQTB[M + CUR_VAL].HH.RH END ELSE BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (817) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 818; HELP_LINE[0] ← 819 END; BACK_ERROR; F ← 0 END; CUR_VAL ← F END; PROCEDURE FIND_FONT_DIMEN (WRITING:BOOLEAN); VAR F : INTERNAL_FONT_NUMBER; N : INTEGER; BEGIN SCAN_INT; N ← CUR_VAL; SCAN_FONT_IDENT; F ← CUR_VAL; IF N ≤ 0 THEN CUR_VAL ← FMEM_PTR ELSE BEGIN IF WRITING AND (N ≤ 4) AND (N ≥ 2) AND (FONT_GLUE[F] ≠ 0) THEN BEGIN DELETE_GLUE_REF (FONT_GLUE[F]); FONT_GLUE[F] ← 0 END; IF N > FONT_PARAMS[F] THEN IF F < FONT_PTR THEN CUR_VAL ← FMEM_PTR ELSE BEGIN REPEAT IF FMEM_PTR = FONT_MEM_SIZE THEN OVERFLOW (824, FONT_MEM_SIZE); FONT_INFO[FMEM_PTR].INT ← 0; FMEM_PTR ← FMEM_PTR + 1; FONT_PARAMS[F] ← FONT_PARAMS[F] + 1 UNTIL N = FONT_PARAMS[F]; CUR_VAL ← FMEM_PTR - 1 END ELSE CUR_VAL ← N + PARAM_BASE[F] END; IF CUR_VAL = FMEM_PTR THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (802) END; PRINT_ESC (HASH[6524 + F].RH); PRINT (820); PRINT_INT (FONT_PARAMS[F]); PRINT (821); BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 822; HELP_LINE[0] ← 823 END; ERROR END END; PROCEDURE SCAN_SOMETHING_INTERNAL (LEVEL:SMALL_NUMBER; NEGATIVE:BOOLEAN); VAR M : HALFWORD; P : 0..NEST_SIZE; BEGIN M ← CUR_CHR; CASE CUR_CMD OF 85: BEGIN SCAN_CHAR_NUM; IF M = 8907 THEN BEGIN CUR_VAL ← EQTB[8907 + CUR_VAL].HH.RH - 0; CUR_VAL_LEVEL ← 0 END ELSE IF M < 8907 THEN BEGIN CUR_VAL ← EQTB[M + CUR_VAL].HH.RH; CUR_VAL_LEVEL ← 0 END ELSE BEGIN CUR_VAL ← EQTB[M + CUR_VAL].INT; CUR_VAL_LEVEL ← 0 END END; 71,72,86,87, 88: IF LEVEL ≠ 5 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (664) END; BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 665; HELP_LINE[1] ← 666; HELP_LINE[0] ← 667 END; BACK_ERROR; BEGIN CUR_VAL ← 0; CUR_VAL_LEVEL ← 1 END END ELSE IF CUR_CMD ≤ 72 THEN BEGIN IF CUR_CMD < 72 THEN BEGIN SCAN_EIGHT_BIT_INT; M ← 7322 + CUR_VAL END; BEGIN CUR_VAL ← EQTB[M].HH.RH; CUR_VAL_LEVEL ← 5 END END ELSE BEGIN BACK_INPUT; SCAN_FONT_IDENT; BEGIN CUR_VAL ← 6524 + CUR_VAL; CUR_VAL_LEVEL ← 4 END END; 73: BEGIN CUR_VAL ← EQTB[M].INT; CUR_VAL_LEVEL ← 0 END; 74: BEGIN CUR_VAL ← EQTB[M].INT; CUR_VAL_LEVEL ← 1 END; 75: BEGIN CUR_VAL ← EQTB[M].HH.RH; CUR_VAL_LEVEL ← 2 END; 76: BEGIN CUR_VAL ← EQTB[M].HH.RH; CUR_VAL_LEVEL ← 3 END; 79: IF ABS (CUR_LIST.MODE_FIELD) ≠ M THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (680) END; PRINT_CMD_CHR (79, M); BEGIN HELP_PTR ← 4; HELP_LINE[3] ← 681; HELP_LINE[2] ← 682; HELP_LINE[1] ← 683; HELP_LINE[0] ← 684 END; ERROR; IF LEVEL ≠ 5 THEN BEGIN CUR_VAL ← 0; CUR_VAL_LEVEL ← 1 END ELSE BEGIN CUR_VAL ← 0; CUR_VAL_LEVEL ← 0 END END ELSE IF M = 1 THEN BEGIN CUR_VAL ← CUR_LIST.AUX_FIELD.INT; CUR_VAL_LEVEL ← 1 END ELSE BEGIN CUR_VAL ← CUR_LIST.AUX_FIELD.HH.LH; CUR_VAL_LEVEL ← 0 END; 80: IF CUR_LIST.MODE_FIELD = 0 THEN BEGIN CUR_VAL ← 0; CUR_VAL_LEVEL ← 0 END ELSE BEGIN NEST[NEST_PTR] ← CUR_LIST; P ← NEST_PTR; WHILE ABS (NEST[P].MODE_FIELD) ≠ 1 DO P ← P - 1; BEGIN CUR_VAL ← NEST[P].PG_FIELD; CUR_VAL_LEVEL ← 0 END END; 82: BEGIN IF M = 0 THEN CUR_VAL ← DEAD_CYCLES ELSE CUR_VAL ← INSERT_PENALTIES; CUR_VAL_LEVEL ← 0 END; 81: BEGIN IF (PAGE_CONTENTS = 0) AND NOT OUTPUT_ACTIVE THEN IF M = 0 THEN CUR_VAL ← 1073741823 ELSE CUR_VAL ← 0 ELSE CUR_VAL ← PAGE_SO_FAR[M]; CUR_VAL_LEVEL ← 1 END; 84: BEGIN IF EQTB[7312].HH.RH = 0 THEN CUR_VAL ← 0 ELSE CUR_VAL ← MEM[EQTB[7312].HH.RH].HH.LH; CUR_VAL_LEVEL ← 0 END; 83: BEGIN SCAN_EIGHT_BIT_INT; IF EQTB[7578 + CUR_VAL].HH.RH = 0 THEN CUR_VAL ← 0 ELSE CUR_VAL ← MEM[EQTB[7578 + CUR_VAL].HH.RH + M].INT; CUR_VAL_LEVEL ← 1 END; 68, 69: BEGIN CUR_VAL ← CUR_CHR; CUR_VAL_LEVEL ← 0 END; 77: BEGIN FIND_FONT_DIMEN (FALSE); FONT_INFO[FMEM_PTR].INT ← 0; BEGIN CUR_VAL ← FONT_INFO[CUR_VAL].INT; CUR_VAL_LEVEL ← 1 END END; 78: BEGIN SCAN_FONT_IDENT; IF M = 0 THEN BEGIN CUR_VAL ← HYPHEN_CHAR[CUR_VAL]; CUR_VAL_LEVEL ← 0 END ELSE BEGIN CUR_VAL ← SKEW_CHAR[CUR_VAL]; CUR_VAL_LEVEL ← 0 END END; 89: BEGIN SCAN_EIGHT_BIT_INT; CASE M OF 0: CUR_VAL ← EQTB[9218 + CUR_VAL].INT; 1: CUR_VAL ← EQTB[9751 + CUR_VAL].INT; 2: CUR_VAL ← EQTB[6800 + CUR_VAL].HH.RH; 3: CUR_VAL ← EQTB[7056 + CUR_VAL].HH.RH; END; CUR_VAL_LEVEL ← M END; 70: IF CUR_CHR > 2 THEN BEGIN IF CUR_CHR = 3 THEN CUR_VAL ← LINE ELSE CUR_VAL ← LAST_BADNESS; CUR_VAL_LEVEL ← 0 END ELSE BEGIN IF CUR_CHR = 2 THEN CUR_VAL ← 0 ELSE CUR_VAL ← 0; CUR_VAL_LEVEL ← CUR_CHR; IF NOT (CUR_LIST.TAIL_FIELD ≥ HI_MEM_MIN) AND (CUR_LIST.MODE_FIELD ≠ 0) THEN CASE CUR_CHR OF 0: IF MEM[CUR_LIST.TAIL_FIELD].HH.B0 = 12 THEN CUR_VAL ← MEM[CUR_LIST.TAIL_FIELD + 1].INT; 1: IF MEM[CUR_LIST.TAIL_FIELD].HH.B0 = 11 THEN CUR_VAL ← MEM[CUR_LIST.TAIL_FIELD + 1].INT; 2: IF MEM[CUR_LIST.TAIL_FIELD].HH.B0 = 10 THEN BEGIN CUR_VAL ← MEM[CUR_LIST.TAIL_FIELD + 1].HH.LH; IF MEM[CUR_LIST.TAIL_FIELD].HH.B1 = 99 THEN CUR_VAL_LEVEL ← 3 END; END ELSE IF (CUR_LIST.MODE_FIELD = 1) AND (CUR_LIST.TAIL_FIELD = CUR_LIST.HEAD_FIELD) THEN CASE CUR_CHR OF 0: CUR_VAL ← LAST_PENALTY; 1: CUR_VAL ← LAST_KERN; 2: IF LAST_GLUE ≠ 65535 THEN CUR_VAL ← LAST_GLUE; END END; ELSE BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (685) END; PRINT_CMD_CHR (CUR_CMD, CUR_CHR); PRINT (686); PRINT_ESC (537); BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 684 END; ERROR; IF LEVEL ≠ 5 THEN BEGIN CUR_VAL ← 0; CUR_VAL_LEVEL ← 1 END ELSE BEGIN CUR_VAL ← 0; CUR_VAL_LEVEL ← 0 END END; END; WHILE CUR_VAL_LEVEL > LEVEL DO BEGIN IF CUR_VAL_LEVEL = 2 THEN CUR_VAL ← MEM[CUR_VAL + 1].INT ELSE IF CUR_VAL_LEVEL = 3 THEN MU_ERROR; CUR_VAL_LEVEL ← CUR_VAL_LEVEL - 1 END; IF NEGATIVE THEN IF CUR_VAL_LEVEL ≥ 2 THEN BEGIN CUR_VAL ← NEW_SPEC (CUR_VAL); BEGIN MEM[CUR_VAL + 1].INT ← -MEM[CUR_VAL + 1].INT; MEM[CUR_VAL + 2].INT ← -MEM[CUR_VAL + 2].INT; MEM[CUR_VAL + 3].INT ← -MEM[CUR_VAL + 3].INT END END ELSE CUR_VAL ← -CUR_VAL ELSE IF (CUR_VAL_LEVEL ≥ 2) AND (CUR_VAL_LEVEL ≤ 3) THEN MEM[CUR_VAL].HH.RH ← MEM[CUR_VAL].HH.RH + 1 END; PROCEDURE SCAN_INT; LABEL 30; VAR NEGATIVE : BOOLEAN; M : INTEGER; D : SMALL_NUMBER; VACUOUS : BOOLEAN; OK_SO_FAR : BOOLEAN; BEGIN RADIX ← 0; OK_SO_FAR ← TRUE; NEGATIVE ← FALSE; REPEAT REPEAT GET_X_TOKEN UNTIL CUR_CMD ≠ 10; IF CUR_TOK = 3117 THEN BEGIN NEGATIVE ← NOT NEGATIVE; CUR_TOK ← 3115 END UNTIL CUR_TOK ≠ 3115; IF CUR_TOK = 3168 THEN BEGIN GET_TOKEN; IF CUR_TOK < 4095 THEN BEGIN CUR_VAL ← CUR_CHR; IF CUR_CMD ≤ 2 THEN IF CUR_CMD = 2 THEN ALIGN_STATE ← ALIGN_STATE + 1 ELSE ALIGN_STATE ← ALIGN_STATE - 1 END ELSE IF CUR_TOK < 4352 THEN CUR_VAL ← CUR_TOK - 4096 ELSE CUR_VAL ← CUR_TOK - 4352; IF CUR_VAL > 255 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (698) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 699; HELP_LINE[0] ← 700 END; CUR_VAL ← 48; BACK_ERROR END ELSE BEGIN GET_X_TOKEN; IF CUR_CMD ≠ 10 THEN BACK_INPUT END END ELSE IF (CUR_CMD ≥ 68) AND (CUR_CMD ≤ 89) THEN SCAN_SOMETHING_INTERNAL (0, FALSE) ELSE BEGIN RADIX ← 10; M ← 214748364; IF CUR_TOK = 3111 THEN BEGIN RADIX ← 8; M ← 268435456; GET_X_TOKEN END ELSE IF CUR_TOK = 3106 THEN BEGIN RADIX ← 16; M ← 134217728; GET_X_TOKEN END; VACUOUS ← TRUE; CUR_VAL ← 0; WHILE TRUE DO BEGIN IF (CUR_TOK < 3120 + RADIX) AND (CUR_TOK ≥ 3120) AND (CUR_TOK ≤ 3129) THEN D ← CUR_TOK - 3120 ELSE IF RADIX = 16 THEN IF (CUR_TOK ≤ 2886) AND (CUR_TOK ≥ 2881) THEN D ← CUR_TOK - 2871 ELSE IF (CUR_TOK ≤ 3142) AND (CUR_TOK ≥ 3137) THEN D ← CUR_TOK - 3127 ELSE GOTO 30 ELSE GOTO 30; VACUOUS ← FALSE; IF (CUR_VAL ≥ M) AND ((CUR_VAL > M) OR (D > 7) OR (RADIX ≠ 10)) THEN BEGIN IF OK_SO_FAR THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (701) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 702; HELP_LINE[0] ← 703 END; ERROR; CUR_VAL ← 2147483647; OK_SO_FAR ← FALSE END END ELSE CUR_VAL ← CUR_VAL * RADIX + D; GET_X_TOKEN END; 30: ; IF VACUOUS THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (664) END; BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 665; HELP_LINE[1] ← 666; HELP_LINE[0] ← 667 END; BACK_ERROR END ELSE IF CUR_CMD ≠ 10 THEN BACK_INPUT END; IF NEGATIVE THEN CUR_VAL ← -CUR_VAL END; PROCEDURE SCAN_DIMEN (MU:BOOLEAN; INF:BOOLEAN; SHORTCUT:BOOLEAN); LABEL 30, 31, 32, 40, 45, 88, 89; VAR NEGATIVE : BOOLEAN; F : INTEGER; NUM : 1..65536; DENOM : 1..65536; K : SMALL_NUMBER; KK : SMALL_NUMBER; P : HALFWORD; Q : HALFWORD; V : SCALED; SAVE_CUR_VAL : INTEGER; BEGIN F ← 0; ARITH_ERROR ← FALSE; CUR_ORDER ← 0; NEGATIVE ← FALSE; IF NOT SHORTCUT THEN BEGIN NEGATIVE ← FALSE; REPEAT REPEAT GET_X_TOKEN UNTIL CUR_CMD ≠ 10; IF CUR_TOK = 3117 THEN BEGIN NEGATIVE ← NOT NEGATIVE; CUR_TOK ← 3115 END UNTIL CUR_TOK ≠ 3115; IF (CUR_CMD ≥ 68) AND (CUR_CMD ≤ 89) THEN IF MU THEN BEGIN SCAN_SOMETHING_INTERNAL (3, FALSE); IF CUR_VAL_LEVEL ≥ 2 THEN BEGIN V ← MEM[CUR_VAL + 1].INT; DELETE_GLUE_REF (CUR_VAL); CUR_VAL ← V END; IF CUR_VAL_LEVEL = 3 THEN GOTO 89; IF CUR_VAL_LEVEL ≠ 0 THEN MU_ERROR END ELSE BEGIN SCAN_SOMETHING_INTERNAL (1, FALSE); IF CUR_VAL_LEVEL = 1 THEN GOTO 89 END ELSE BEGIN BACK_INPUT; IF CUR_TOK = 3116 THEN CUR_TOK ← 3118; IF CUR_TOK ≠ 3118 THEN SCAN_INT ELSE BEGIN RADIX ← 10; CUR_VAL ← 0 END; IF CUR_TOK = 3116 THEN CUR_TOK ← 3118; IF (RADIX = 10) AND (CUR_TOK = 3118) THEN BEGIN K ← 0; P ← 0; GET_TOKEN; WHILE TRUE DO BEGIN GET_X_TOKEN; IF (CUR_TOK > 3129) OR (CUR_TOK < 3120) THEN GOTO 31; IF K < 17 THEN BEGIN Q ← GET_AVAIL; MEM[Q].HH.RH ← P; MEM[Q].HH.LH ← CUR_TOK - 3120; P ← Q; K ← K + 1 END END; 31: FOR KK ← K DOWNTO 1 DO BEGIN DIG[KK - 1] ← MEM[P].HH.LH; Q ← P; P ← MEM[P].HH.RH; BEGIN MEM[Q].HH.RH ← AVAIL; AVAIL ← Q END END; F ← ROUND_DECIMALS (K); IF CUR_CMD ≠ 10 THEN BACK_INPUT END END END; IF CUR_VAL < 0 THEN BEGIN NEGATIVE ← NOT NEGATIVE; CUR_VAL ← -CUR_VAL END; IF INF THEN IF SCAN_KEYWORD (311) THEN BEGIN CUR_ORDER ← 1; WHILE SCAN_KEYWORD (108) DO BEGIN IF CUR_ORDER = 3 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (705) END; PRINT (706); BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 707 END; ERROR END ELSE CUR_ORDER ← CUR_ORDER + 1 END; GOTO 88 END; SAVE_CUR_VAL ← CUR_VAL; REPEAT GET_X_TOKEN UNTIL CUR_CMD ≠ 10; IF (CUR_CMD < 68) OR (CUR_CMD > 89) THEN BACK_INPUT ELSE BEGIN IF MU THEN BEGIN SCAN_SOMETHING_INTERNAL (3, FALSE); IF CUR_VAL_LEVEL ≥ 2 THEN BEGIN V ← MEM[CUR_VAL + 1].INT; DELETE_GLUE_REF (CUR_VAL); CUR_VAL ← V END; IF CUR_VAL_LEVEL ≠ 3 THEN MU_ERROR END ELSE SCAN_SOMETHING_INTERNAL (1, FALSE); V ← CUR_VAL; GOTO 40 END; IF MU THEN GOTO 45; IF SCAN_KEYWORD (708) THEN V ← FONT_INFO[6 + PARAM_BASE[EQTB[7834].HH.RH]].INT ELSE IF SCAN_KEYWORD (709) THEN V ← FONT_INFO[5 + PARAM_BASE[EQTB[7834].HH.RH]].INT ELSE GOTO 45; BEGIN GET_X_TOKEN; IF CUR_CMD ≠ 10 THEN BACK_INPUT END; 40: CUR_VAL ← MULT_AND_ADD (SAVE_CUR_VAL, V, XN_OVER_D (V, F, 65536), 1073741823); GOTO 89; 45: ; IF MU THEN IF SCAN_KEYWORD (337) THEN GOTO 88 ELSE BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (705) END; PRINT (710); BEGIN HELP_PTR ← 4; HELP_LINE[3] ← 711; HELP_LINE[2] ← 712; HELP_LINE[1] ← 713; HELP_LINE[0] ← 714 END; ERROR; GOTO 88 END; IF SCAN_KEYWORD (704) THEN BEGIN PREPARE_MAG; IF EQTB[9180].INT ≠ 1000 THEN BEGIN CUR_VAL ← XN_OVER_D (CUR_VAL, 1000, EQTB[9180].INT); F ← (1000 * F + 65536 * REMAINDER) DIV EQTB[9180].INT; CUR_VAL ← CUR_VAL + F DIV 65536; F ← F MOD 65536 END END; IF SCAN_KEYWORD (397) THEN GOTO 88; IF SCAN_KEYWORD (715) THEN BEGIN NUM ← 7227; DENOM ← 100 END ELSE IF SCAN_KEYWORD (716) THEN BEGIN NUM ← 12; DENOM ← 1 END ELSE IF SCAN_KEYWORD (717) THEN BEGIN NUM ← 7227; DENOM ← 254 END ELSE IF SCAN_KEYWORD (718) THEN BEGIN NUM ← 7227; DENOM ← 2540 END ELSE IF SCAN_KEYWORD (719) THEN BEGIN NUM ← 7227; DENOM ← 7200 END ELSE IF SCAN_KEYWORD (720) THEN BEGIN NUM ← 1238; DENOM ← 1157 END ELSE IF SCAN_KEYWORD (721) THEN BEGIN NUM ← 14856; DENOM ← 1157 END ELSE IF SCAN_KEYWORD (722) THEN GOTO 30 ELSE BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (705) END; PRINT (723); BEGIN HELP_PTR ← 6; HELP_LINE[5] ← 724; HELP_LINE[4] ← 725; HELP_LINE[3] ← 726; HELP_LINE[2] ← 712; HELP_LINE[1] ← 713; HELP_LINE[0] ← 714 END; ERROR; GOTO 32 END; CUR_VAL ← XN_OVER_D (CUR_VAL, NUM, DENOM); F ← (NUM * F + 65536 * REMAINDER) DIV DENOM; CUR_VAL ← CUR_VAL + F DIV 65536; F ← F MOD 65536; 32: ; 88: IF CUR_VAL ≥ 16384 THEN ARITH_ERROR ← TRUE ELSE CUR_VAL ← CUR_VAL * 65536 + F; 30: ; BEGIN GET_X_TOKEN; IF CUR_CMD ≠ 10 THEN BACK_INPUT END; 89: IF ARITH_ERROR OR (ABS (CUR_VAL) ≥ 1073741824) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (727) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 728; HELP_LINE[0] ← 729 END; ERROR; CUR_VAL ← 1073741823; ARITH_ERROR ← FALSE END; IF NEGATIVE THEN CUR_VAL ← -CUR_VAL END; PROCEDURE SCAN_GLUE (LEVEL:SMALL_NUMBER); LABEL 10; VAR NEGATIVE : BOOLEAN; Q : HALFWORD; MU : BOOLEAN; BEGIN MU ← LEVEL = 3; NEGATIVE ← FALSE; REPEAT REPEAT GET_X_TOKEN UNTIL CUR_CMD ≠ 10; IF CUR_TOK = 3117 THEN BEGIN NEGATIVE ← NOT NEGATIVE; CUR_TOK ← 3115 END UNTIL CUR_TOK ≠ 3115; IF (CUR_CMD ≥ 68) AND (CUR_CMD ≤ 89) THEN BEGIN SCAN_SOMETHING_INTERNAL (LEVEL, NEGATIVE); IF CUR_VAL_LEVEL ≥ 2 THEN BEGIN IF CUR_VAL_LEVEL ≠ LEVEL THEN MU_ERROR; GOTO 10 END; IF CUR_VAL_LEVEL = 0 THEN SCAN_DIMEN (MU, FALSE, TRUE) ELSE IF LEVEL = 3 THEN MU_ERROR END ELSE BEGIN BACK_INPUT; SCAN_DIMEN (MU, FALSE, FALSE); IF NEGATIVE THEN CUR_VAL ← -CUR_VAL END; Q ← NEW_SPEC (0); MEM[Q + 1].INT ← CUR_VAL; IF SCAN_KEYWORD (730) THEN BEGIN SCAN_DIMEN (MU, TRUE, FALSE); MEM[Q + 2].INT ← CUR_VAL; MEM[Q].HH.B0 ← CUR_ORDER END; IF SCAN_KEYWORD (731) THEN BEGIN SCAN_DIMEN (MU, TRUE, FALSE); MEM[Q + 3].INT ← CUR_VAL; MEM[Q].HH.B1 ← CUR_ORDER END; CUR_VAL ← Q; 10: END; FUNCTION SCAN_RULE_SPEC:HALFWORD; LABEL 21; VAR Q : HALFWORD; BEGIN Q ← NEW_RULE; IF CUR_CMD = 35 THEN MEM[Q + 1].INT ← 26214 ELSE BEGIN MEM[Q + 3].INT ← 26214; MEM[Q + 2].INT ← 0 END; 21: IF SCAN_KEYWORD (732) THEN BEGIN SCAN_DIMEN (FALSE, FALSE, FALSE); MEM[Q + 1].INT ← CUR_VAL; GOTO 21 END; IF SCAN_KEYWORD (733) THEN BEGIN SCAN_DIMEN (FALSE, FALSE, FALSE); MEM[Q + 3].INT ← CUR_VAL; GOTO 21 END; IF SCAN_KEYWORD (734) THEN BEGIN SCAN_DIMEN (FALSE, FALSE, FALSE); MEM[Q + 2].INT ← CUR_VAL; GOTO 21 END; SCAN_RULE_SPEC ← Q END; FUNCTION STR_TOKS (B:POOL_POINTER):HALFWORD; VAR P : HALFWORD; Q : HALFWORD; T : HALFWORD; K : POOL_POINTER; BEGIN BEGIN IF POOL_PTR + 1 > POOL_SIZE THEN OVERFLOW (257, POOL_SIZE - INIT_POOL_PTR) END; P ← 59997; MEM[P].HH.RH ← 0; K ← B; WHILE K < POOL_PTR DO BEGIN T ← STR_POOL[K]; IF T = 32 THEN T ← 2592 ELSE T ← 3072 + T; BEGIN BEGIN Q ← AVAIL; IF Q = 0 THEN Q ← GET_AVAIL ELSE BEGIN AVAIL ← MEM[Q].HH.RH; MEM[Q].HH.RH ← 0 END END; MEM[P].HH.RH ← Q; MEM[Q].HH.LH ← T; P ← Q END; K ← K + 1 END; POOL_PTR ← B; STR_TOKS ← P END; FUNCTION THE_TOKS:HALFWORD; VAR OLD_SETTING : 0..21; P : HALFWORD; Q : HALFWORD; R : HALFWORD; B : POOL_POINTER; BEGIN GET_X_TOKEN; SCAN_SOMETHING_INTERNAL (5, FALSE); IF CUR_VAL_LEVEL ≥ 4 THEN BEGIN P ← 59997; MEM[P].HH.RH ← 0; IF CUR_VAL_LEVEL = 4 THEN BEGIN Q ← GET_AVAIL; MEM[P].HH.RH ← Q; MEM[Q].HH.LH ← 4095 + CUR_VAL; P ← Q END ELSE IF CUR_VAL ≠ 0 THEN BEGIN R ← MEM[CUR_VAL].HH.RH; WHILE R ≠ 0 DO BEGIN BEGIN BEGIN Q ← AVAIL; IF Q = 0 THEN Q ← GET_AVAIL ELSE BEGIN AVAIL ← MEM[Q].HH.RH; MEM[Q].HH.RH ← 0 END END; MEM[P].HH.RH ← Q; MEM[Q].HH.LH ← MEM[R].HH.LH; P ← Q END; R ← MEM[R].HH.RH END END; THE_TOKS ← P END ELSE BEGIN OLD_SETTING ← SELECTOR; SELECTOR ← 21; B ← POOL_PTR; CASE CUR_VAL_LEVEL OF 0: PRINT_INT (CUR_VAL); 1: BEGIN PRINT_SCALED (CUR_VAL); PRINT (397) END; 2: BEGIN PRINT_SPEC (CUR_VAL, 397); DELETE_GLUE_REF (CUR_VAL) END; 3: BEGIN PRINT_SPEC (CUR_VAL, 337); DELETE_GLUE_REF (CUR_VAL) END; END; SELECTOR ← OLD_SETTING; THE_TOKS ← STR_TOKS (B) END END; PROCEDURE INS_THE_TOKS; BEGIN MEM[59988].HH.RH ← THE_TOKS; BEGIN_TOKEN_LIST (MEM[59997].HH.RH, 4) END; PROCEDURE CONV_TOKS; VAR OLD_SETTING : 0..21; C : 0..5; SAVE_SCANNER_STATUS : SMALL_NUMBER; B : POOL_POINTER; BEGIN C ← CUR_CHR; CASE C OF 0,1: SCAN_INT; 2, 3: BEGIN SAVE_SCANNER_STATUS ← SCANNER_STATUS; SCANNER_STATUS ← 0; GET_TOKEN; SCANNER_STATUS ← SAVE_SCANNER_STATUS END; 4: SCAN_FONT_IDENT; 5: IF JOB_NAME = 0 THEN OPEN_LOG_FILE; END; OLD_SETTING ← SELECTOR; SELECTOR ← 21; B ← POOL_PTR; CASE C OF 0: PRINT_INT (CUR_VAL); 1: PRINT_ROMAN_INT (CUR_VAL); 2: IF CUR_CS ≠ 0 THEN SPRINT_CS (CUR_CS) ELSE PRINT_CHAR (CUR_CHR); 3: PRINT_MEANING; 4: BEGIN PRINT (FONT_NAME[CUR_VAL]); IF FONT_SIZE[CUR_VAL] ≠ FONT_DSIZE[CUR_VAL] THEN BEGIN PRINT (741); PRINT_SCALED (FONT_SIZE[CUR_VAL]); PRINT (397) END END; 5: PRINT (JOB_NAME); END; SELECTOR ← OLD_SETTING; MEM[59988].HH.RH ← STR_TOKS (B); BEGIN_TOKEN_LIST (MEM[59997].HH.RH, 4) END; FUNCTION SCAN_TOKS (MACRO_DEF:BOOLEAN; XPAND:BOOLEAN):HALFWORD; LABEL 40, 22, 30, 31, 32; VAR T : HALFWORD; S : HALFWORD; P : HALFWORD; Q : HALFWORD; UNBALANCE : HALFWORD; HASH_BRACE : HALFWORD; BEGIN IF MACRO_DEF THEN SCANNER_STATUS ← 2 ELSE SCANNER_STATUS ← 5; WARNING_INDEX ← CUR_CS; DEF_REF ← GET_AVAIL; MEM[DEF_REF].HH.LH ← 0; P ← DEF_REF; HASH_BRACE ← 0; T ← 3120; IF MACRO_DEF THEN BEGIN WHILE TRUE DO BEGIN 22: GET_TOKEN; IF CUR_TOK < 768 THEN GOTO 31; IF CUR_CMD = 6 THEN BEGIN S ← 3328 + CUR_CHR; GET_TOKEN; IF CUR_TOK < 512 THEN BEGIN HASH_BRACE ← CUR_TOK; BEGIN Q ← GET_AVAIL; MEM[P].HH.RH ← Q; MEM[Q].HH.LH ← CUR_TOK; P ← Q END; BEGIN Q ← GET_AVAIL; MEM[P].HH.RH ← Q; MEM[Q].HH.LH ← 3584; P ← Q END; GOTO 30 END; IF T = 3129 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (744) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 745; HELP_LINE[0] ← 746 END; ERROR; GOTO 22 END ELSE BEGIN T ← T + 1; IF CUR_TOK ≠ T THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (747) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 748; HELP_LINE[0] ← 749 END; BACK_ERROR END; CUR_TOK ← S END END; BEGIN Q ← GET_AVAIL; MEM[P].HH.RH ← Q; MEM[Q].HH.LH ← CUR_TOK; P ← Q END END; 31: BEGIN Q ← GET_AVAIL; MEM[P].HH.RH ← Q; MEM[Q].HH.LH ← 3584; P ← Q END; IF CUR_CMD = 2 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (657) END; ALIGN_STATE ← ALIGN_STATE + 1; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 742; HELP_LINE[0] ← 743 END; ERROR; GOTO 40 END; 30: END ELSE SCAN_LEFT_BRACE; UNBALANCE ← 1; WHILE TRUE DO BEGIN IF XPAND THEN BEGIN WHILE TRUE DO BEGIN GET_NEXT; IF CUR_CMD ≤ 100 THEN GOTO 32; IF CUR_CMD ≠ 109 THEN EXPAND ELSE BEGIN Q ← THE_TOKS; IF MEM[59997].HH.RH ≠ 0 THEN BEGIN MEM[P].HH.RH ← MEM[59997].HH.RH; P ← Q END END END; 32: X_TOKEN END ELSE GET_TOKEN; IF CUR_TOK < 768 THEN IF CUR_CMD < 2 THEN UNBALANCE ← UNBALANCE + 1 ELSE BEGIN UNBALANCE ← UNBALANCE - 1; IF UNBALANCE = 0 THEN GOTO 40 END ELSE IF CUR_CMD = 6 THEN IF MACRO_DEF THEN BEGIN S ← CUR_TOK; IF XPAND THEN GET_X_TOKEN ELSE GET_TOKEN; IF CUR_CMD ≠ 6 THEN IF (CUR_TOK ≤ 3120) OR (CUR_TOK > T) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (750) END; SPRINT_CS (WARNING_INDEX); BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 751; HELP_LINE[1] ← 752; HELP_LINE[0] ← 753 END; BACK_ERROR; CUR_TOK ← S END ELSE CUR_TOK ← 1232 + CUR_CHR END; BEGIN Q ← GET_AVAIL; MEM[P].HH.RH ← Q; MEM[Q].HH.LH ← CUR_TOK; P ← Q END END; 40: SCANNER_STATUS ← 0; IF HASH_BRACE ≠ 0 THEN BEGIN Q ← GET_AVAIL; MEM[P].HH.RH ← Q; MEM[Q].HH.LH ← HASH_BRACE; P ← Q END; SCAN_TOKS ← P END; PROCEDURE READ_TOKS (N:INTEGER; R:HALFWORD); LABEL 30; VAR P : HALFWORD; Q : HALFWORD; S : INTEGER; M : SMALL_NUMBER; BEGIN SCANNER_STATUS ← 2; WARNING_INDEX ← R; DEF_REF ← GET_AVAIL; MEM[DEF_REF].HH.LH ← 0; P ← DEF_REF; BEGIN Q ← GET_AVAIL; MEM[P].HH.RH ← Q; MEM[Q].HH.LH ← 3584; P ← Q END; IF (N < 0) OR (N > 15) THEN M ← 16 ELSE M ← N; S ← ALIGN_STATE; ALIGN_STATE ← 1000000; REPEAT BEGIN_FILE_READING; CUR_INPUT.NAME_FIELD ← M + 1; IF READ_OPEN[M] = 2 THEN IF INTERACTION > 1 THEN IF N < 0 THEN BEGIN PRINT (338); TERM_INPUT END ELSE BEGIN PRINT_LN; SPRINT_CS (R); BEGIN PRINT (61); TERM_INPUT END; N ← -1 END ELSE FATAL_ERROR (754) ELSE IF READ_OPEN[M] = 1 THEN IF INPUT_LN (READ_FILE[M], FALSE) THEN READ_OPEN[M] ← 0 ELSE BEGIN A_CLOSE (READ_FILE[M]); READ_OPEN[M] ← 2 END ELSE BEGIN IF NOT INPUT_LN (READ_FILE[M], TRUE) THEN BEGIN A_CLOSE (READ_FILE[M]); READ_OPEN[M] ← 2; IF ALIGN_STATE ≠ 1000000 THEN BEGIN RUNAWAY; BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (755) END; PRINT_ESC (534); BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 756 END; ALIGN_STATE ← 1000000; CUR_INPUT.LIMIT_FIELD ← 0; ERROR END END END; CUR_INPUT.LIMIT_FIELD ← LAST; IF (EQTB[9211].INT < 0) OR (EQTB[9211].INT > 255) THEN CUR_INPUT.LIMIT_FIELD ← CUR_INPUT.LIMIT_FIELD - 1 ELSE BUFFER[CUR_INPUT.LIMIT_FIELD] ← EQTB[9211].INT; FIRST ← CUR_INPUT.LIMIT_FIELD + 1; CUR_INPUT.LOC_FIELD ← CUR_INPUT.START_FIELD; CUR_INPUT.STATE_FIELD ← 33; WHILE TRUE DO BEGIN GET_TOKEN; IF CUR_TOK = 0 THEN GOTO 30; IF ALIGN_STATE < 1000000 THEN BEGIN REPEAT GET_TOKEN UNTIL CUR_TOK = 0; ALIGN_STATE ← 1000000; GOTO 30 END; BEGIN Q ← GET_AVAIL; MEM[P].HH.RH ← Q; MEM[Q].HH.LH ← CUR_TOK; P ← Q END END; 30: END_FILE_READING UNTIL ALIGN_STATE = 1000000; CUR_VAL ← DEF_REF; SCANNER_STATUS ← 0; ALIGN_STATE ← S END; PROCEDURE PASS_TEXT; LABEL 30; VAR L : INTEGER; SAVE_SCANNER_STATUS : SMALL_NUMBER; BEGIN SAVE_SCANNER_STATUS ← SCANNER_STATUS; SCANNER_STATUS ← 1; L ← 0; SKIP_LINE ← LINE; WHILE TRUE DO BEGIN GET_NEXT; IF CUR_CMD = 106 THEN BEGIN IF L = 0 THEN GOTO 30; IF CUR_CHR = 2 THEN L ← L - 1 END ELSE IF CUR_CMD = 105 THEN L ← L + 1 END; 30: SCANNER_STATUS ← SAVE_SCANNER_STATUS END; PROCEDURE CHANGE_IF_LIMIT (L:SMALL_NUMBER; P:HALFWORD); LABEL 10; VAR Q : HALFWORD; BEGIN IF P = COND_PTR THEN IF_LIMIT ← L ELSE BEGIN Q ← COND_PTR; WHILE TRUE DO BEGIN IF Q = 0 THEN CONFUSION (757); IF MEM[Q].HH.RH = P THEN BEGIN MEM[Q].HH.B0 ← L; GOTO 10 END; Q ← MEM[Q].HH.RH END END; 10: END; PROCEDURE CONDITIONAL; LABEL 10, 50; VAR B : BOOLEAN; R : 60..62; M : INTEGER; N : INTEGER; P : HALFWORD; Q : HALFWORD; SAVE_SCANNER_STATUS : SMALL_NUMBER; SAVE_COND_PTR : HALFWORD; THIS_IF : SMALL_NUMBER; BEGIN BEGIN P ← GET_NODE (2); MEM[P].HH.RH ← COND_PTR; MEM[P].HH.B0 ← IF_LIMIT; MEM[P].HH.B1 ← CUR_IF; MEM[P + 1].INT ← IF_LINE; COND_PTR ← P; CUR_IF ← CUR_CHR; IF_LIMIT ← 1; IF_LINE ← LINE END; SAVE_COND_PTR ← COND_PTR; THIS_IF ← CUR_CHR; CASE THIS_IF OF 0, 1: BEGIN BEGIN GET_X_TOKEN; IF CUR_CMD = 0 THEN IF CUR_CHR = 257 THEN BEGIN CUR_CMD ← 13; CUR_CHR ← CUR_TOK - 4096 END END; IF (CUR_CMD > 13) OR (CUR_CHR > 255) THEN BEGIN M ← 0; N ← 256 END ELSE BEGIN M ← CUR_CMD; N ← CUR_CHR END; BEGIN GET_X_TOKEN; IF CUR_CMD = 0 THEN IF CUR_CHR = 257 THEN BEGIN CUR_CMD ← 13; CUR_CHR ← CUR_TOK - 4096 END END; IF (CUR_CMD > 13) OR (CUR_CHR > 255) THEN BEGIN CUR_CMD ← 0; CUR_CHR ← 256 END; IF THIS_IF = 0 THEN B ← N = CUR_CHR ELSE B ← M = CUR_CMD END; 2, 3: BEGIN IF THIS_IF = 2 THEN SCAN_INT ELSE SCAN_DIMEN (FALSE, FALSE, FALSE); N ← CUR_VAL; REPEAT GET_X_TOKEN UNTIL CUR_CMD ≠ 10; IF (CUR_TOK ≥ 3132) AND (CUR_TOK ≤ 3134) THEN R ← CUR_TOK - 3072 ELSE BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (781) END; PRINT_CMD_CHR (105, THIS_IF); BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 782 END; BACK_ERROR; R ← 61 END; IF THIS_IF = 2 THEN SCAN_INT ELSE SCAN_DIMEN (FALSE, FALSE, FALSE); CASE R OF 60: B ← N < CUR_VAL; 61: B ← N = CUR_VAL; 62: B ← N > CUR_VAL; END END; 4: BEGIN SCAN_INT; B ← ODD (CUR_VAL) END; 5: B ← ABS (CUR_LIST.MODE_FIELD) = 1; 6: B ← ABS (CUR_LIST.MODE_FIELD) = 102; 7: B ← ABS (CUR_LIST.MODE_FIELD) = 203; 8: B ← CUR_LIST.MODE_FIELD < 0; 9,10, 11: BEGIN SCAN_EIGHT_BIT_INT; P ← EQTB[7578 + CUR_VAL].HH.RH; IF THIS_IF = 9 THEN B ← P = 0 ELSE IF P = 0 THEN B ← FALSE ELSE IF THIS_IF = 10 THEN B ← MEM[P].HH.B0 = 0 ELSE B ← MEM[P].HH.B0 = 1 END; 12: BEGIN SAVE_SCANNER_STATUS ← SCANNER_STATUS; SCANNER_STATUS ← 0; GET_NEXT; N ← CUR_CS; P ← CUR_CMD; Q ← CUR_CHR; GET_NEXT; IF CUR_CMD ≠ P THEN B ← FALSE ELSE IF CUR_CMD < 111 THEN B ← CUR_CHR = Q ELSE BEGIN P ← MEM[CUR_CHR].HH.RH; Q ← MEM[EQTB[N].HH.RH].HH.RH; IF P = Q THEN B ← TRUE ELSE BEGIN WHILE (P ≠ 0) AND (Q ≠ 0) DO IF MEM[P].HH.LH ≠ MEM[Q].HH.LH THEN P ← 0 ELSE BEGIN P ← MEM[P].HH.RH; Q ← MEM[Q].HH.RH END; B ← (P = 0) AND (Q = 0) END END; SCANNER_STATUS ← SAVE_SCANNER_STATUS END; 13: BEGIN SCAN_FOUR_BIT_INT; B ← READ_OPEN[CUR_VAL] = 2 END; 14: B ← TRUE; 15: B ← FALSE; 16: BEGIN SCAN_INT; N ← CUR_VAL; IF EQTB[9199].INT > 1 THEN BEGIN BEGIN_DIAGNOSTIC; PRINT (783); PRINT_INT (N); PRINT_CHAR (125); END_DIAGNOSTIC (FALSE) END; WHILE N ≠ 0 DO BEGIN PASS_TEXT; IF COND_PTR = SAVE_COND_PTR THEN IF CUR_CHR = 4 THEN N ← N - 1 ELSE GOTO 50 ELSE IF CUR_CHR = 2 THEN BEGIN P ← COND_PTR; IF_LINE ← MEM[P + 1].INT; CUR_IF ← MEM[P].HH.B1; IF_LIMIT ← MEM[P].HH.B0; COND_PTR ← MEM[P].HH.RH; FREE_NODE (P, 2) END END; CHANGE_IF_LIMIT (4, SAVE_COND_PTR); GOTO 10 END; END; IF EQTB[9199].INT > 1 THEN BEGIN BEGIN_DIAGNOSTIC; IF B THEN PRINT (779) ELSE PRINT (780); END_DIAGNOSTIC (FALSE) END; IF B THEN BEGIN CHANGE_IF_LIMIT (3, SAVE_COND_PTR); GOTO 10 END; WHILE TRUE DO BEGIN PASS_TEXT; IF COND_PTR = SAVE_COND_PTR THEN BEGIN IF CUR_CHR ≠ 4 THEN GOTO 50; BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (777) END; PRINT_ESC (775); BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 778 END; ERROR END ELSE IF CUR_CHR = 2 THEN BEGIN P ← COND_PTR; IF_LINE ← MEM[P + 1].INT; CUR_IF ← MEM[P].HH.B1; IF_LIMIT ← MEM[P].HH.B0; COND_PTR ← MEM[P].HH.RH; FREE_NODE (P, 2) END END; 50: IF CUR_CHR = 2 THEN BEGIN P ← COND_PTR; IF_LINE ← MEM[P + 1].INT; CUR_IF ← MEM[P].HH.B1; IF_LIMIT ← MEM[P].HH.B0; COND_PTR ← MEM[P].HH.RH; FREE_NODE (P, 2) END ELSE IF_LIMIT ← 2; 10: END; PROCEDURE BEGIN_NAME; BEGIN AREA_DELIMITER ← 0; EXT_DELIMITER ← 0 END; FUNCTION MORE_NAME (C:ASCII_CODE):BOOLEAN; BEGIN IF C = 32 THEN MORE_NAME ← FALSE ELSE BEGIN BEGIN IF POOL_PTR + 1 > POOL_SIZE THEN OVERFLOW (257, POOL_SIZE - INIT_POOL_PTR) END; BEGIN STR_POOL[POOL_PTR] ← C; POOL_PTR ← POOL_PTR + 1 END; IF (C = 62) OR (C = 58) THEN BEGIN AREA_DELIMITER ← POOL_PTR - STR_START[STR_PTR]; EXT_DELIMITER ← 0 END ELSE IF (C = 46) AND (EXT_DELIMITER = 0) THEN EXT_DELIMITER ← POOL_PTR - STR_START[STR_PTR]; MORE_NAME ← TRUE END END; PROCEDURE END_NAME; BEGIN IF STR_PTR + 3 > MAX_STRINGS THEN OVERFLOW (258, MAX_STRINGS - INIT_STR_PTR); IF AREA_DELIMITER = 0 THEN CUR_AREA ← 338 ELSE BEGIN CUR_AREA ← STR_PTR; STR_START[STR_PTR + 1] ← STR_START[STR_PTR] + AREA_DELIMITER; STR_PTR ← STR_PTR + 1 END; IF EXT_DELIMITER = 0 THEN BEGIN CUR_EXT ← 338; CUR_NAME ← MAKE_STRING END ELSE BEGIN CUR_NAME ← STR_PTR; STR_START[STR_PTR + 1] ← STR_START[STR_PTR] + EXT_DELIMITER - AREA_DELIMITER - 1; STR_PTR ← STR_PTR + 1; CUR_EXT ← MAKE_STRING END END; PROCEDURE PACK_FILE_NAME (N:STR_NUMBER; A:STR_NUMBER; E:STR_NUMBER); VAR K : INTEGER; C : ASCII_CODE; J : POOL_POINTER; BEGIN K ← 0; FOR J ← STR_START[A] TO STR_START[A + 1] - 1 DO BEGIN C ← STR_POOL[J]; K ← K + 1; IF K ≤ FILE_NAME_SIZE THEN NAME_OF_FILE[K] ← XCHR[C] END; FOR J ← STR_START[N] TO STR_START[N + 1] - 1 DO BEGIN C ← STR_POOL[J]; K ← K + 1; IF K ≤ FILE_NAME_SIZE THEN NAME_OF_FILE[K] ← XCHR[C] END; FOR J ← STR_START[E] TO STR_START[E + 1] - 1 DO BEGIN C ← STR_POOL[J]; K ← K + 1; IF K ≤ FILE_NAME_SIZE THEN NAME_OF_FILE[K] ← XCHR[C] END; IF K ≤ FILE_NAME_SIZE THEN NAME_LENGTH ← K ELSE NAME_LENGTH ← FILE_NAME_SIZE; FOR K ← NAME_LENGTH + 1 TO FILE_NAME_SIZE DO NAME_OF_FILE[K] ← ' ' END; PROCEDURE PACK_BUFFERED_NAME (N:SMALL_NUMBER; A:INTEGER; B:INTEGER); VAR K : INTEGER; C : ASCII_CODE; J : INTEGER; BEGIN IF N + B - A + 5 > FILE_NAME_SIZE THEN B ← A + FILE_NAME_SIZE - N - 5; K ← 0; FOR J ← 1 TO N DO BEGIN C ← XORD[TEX_FORMAT_DEFAULT[J]]; K ← K + 1; IF K ≤ FILE_NAME_SIZE THEN NAME_OF_FILE[K] ← XCHR[C] END; FOR J ← A TO B DO BEGIN C ← BUFFER[J]; K ← K + 1; IF K ≤ FILE_NAME_SIZE THEN NAME_OF_FILE[K] ← XCHR[C] END; FOR J ← 17 TO 20 DO BEGIN C ← XORD[TEX_FORMAT_DEFAULT[J]]; K ← K + 1; IF K ≤ FILE_NAME_SIZE THEN NAME_OF_FILE[K] ← XCHR[C] END; IF K ≤ FILE_NAME_SIZE THEN NAME_LENGTH ← K ELSE NAME_LENGTH ← FILE_NAME_SIZE; FOR K ← NAME_LENGTH + 1 TO FILE_NAME_SIZE DO NAME_OF_FILE[K] ← ' ' END; FUNCTION MAKE_NAME_STRING:STR_NUMBER; VAR K : 1..FILE_NAME_SIZE; BEGIN IF (POOL_PTR + NAME_LENGTH > POOL_SIZE) OR (STR_PTR = MAX_STRINGS) OR (POOL_PTR - STR_START[STR_PTR] > 0) THEN MAKE_NAME_STRING ← 63 ELSE BEGIN FOR K ← 1 TO NAME_LENGTH DO BEGIN STR_POOL[POOL_PTR] ← XORD[NAME_OF_FILE[K]]; POOL_PTR ← POOL_PTR + 1 END; MAKE_NAME_STRING ← MAKE_STRING END END; FUNCTION A_MAKE_NAME_STRING (VAR F:ALPHA_FILE):STR_NUMBER; BEGIN A_MAKE_NAME_STRING ← MAKE_NAME_STRING END; FUNCTION B_MAKE_NAME_STRING (VAR F:BYTE_FILE):STR_NUMBER; BEGIN B_MAKE_NAME_STRING ← MAKE_NAME_STRING END; FUNCTION W_MAKE_NAME_STRING (VAR F:WORD_FILE):STR_NUMBER; BEGIN W_MAKE_NAME_STRING ← MAKE_NAME_STRING END; PROCEDURE SCAN_FILE_NAME; LABEL 30; BEGIN NAME_IN_PROGRESS ← TRUE; BEGIN_NAME; REPEAT GET_X_TOKEN UNTIL CUR_CMD ≠ 10; WHILE TRUE DO BEGIN IF (CUR_CMD > 12) OR (CUR_CHR > 255) THEN BEGIN BACK_INPUT; GOTO 30 END; IF NOT MORE_NAME (CUR_CHR) THEN GOTO 30; GET_X_TOKEN END; 30: END_NAME; NAME_IN_PROGRESS ← FALSE END; PROCEDURE PACK_JOB_NAME (S:STR_NUMBER); BEGIN CUR_AREA ← 338; CUR_EXT ← S; CUR_NAME ← JOB_NAME; PACK_FILE_NAME (CUR_NAME, CUR_AREA, CUR_EXT) END; PROCEDURE PROMPT_FILE_NAME (S:STR_NUMBER; E:STR_NUMBER); LABEL 30; VAR K : 0..BUF_SIZE; BEGIN IF INTERACTION = 2 THEN ; IF S = 787 THEN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (788) END ELSE BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (789) END; PRINT_FILE_NAME (CUR_NAME, CUR_AREA, CUR_EXT); PRINT (790); IF E = 791 THEN SHOW_CONTEXT; PRINT_NL (792); PRINT (S); IF INTERACTION < 2 THEN FATAL_ERROR (793); BREAK_IN (TERM_IN, TRUE); BEGIN PRINT (568); TERM_INPUT END; BEGIN BEGIN_NAME; K ← FIRST; WHILE (BUFFER[K] = 32) AND (K < LAST) DO K ← K + 1; WHILE TRUE DO BEGIN IF K = LAST THEN GOTO 30; IF NOT MORE_NAME (BUFFER[K]) THEN GOTO 30; K ← K + 1 END; 30: END_NAME END; IF CUR_EXT = 338 THEN CUR_EXT ← E; PACK_FILE_NAME (CUR_NAME, CUR_AREA, CUR_EXT) END; PROCEDURE OPEN_LOG_FILE; VAR OLD_SETTING : 0..21; K : 0..BUF_SIZE; L : 0..BUF_SIZE; MONTHS : PACKED ARRAY [1..36] OF CHAR; BEGIN OLD_SETTING ← SELECTOR; IF JOB_NAME = 0 THEN JOB_NAME ← 796; PACK_JOB_NAME (797); WHILE NOT A_OPEN_OUT (LOG_FILE) DO BEGIN SELECTOR ← 17; PROMPT_FILE_NAME (799, 797) END; LOG_NAME ← A_MAKE_NAME_STRING (LOG_FILE); SELECTOR ← 18; LOG_OPENED ← TRUE; BEGIN WRITE (LOG_FILE, 'This is TeX, Version 3.141592653'); SLOW_PRINT (FORMAT_IDENT); PRINT (800); PRINT_INT (SYS_DAY); PRINT_CHAR (32); MONTHS ← 'JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC'; FOR K ← 3 * SYS_MONTH - 2 TO 3 * SYS_MONTH DO WRITE (LOG_FILE, MONTHS[K]); PRINT_CHAR (32); PRINT_INT (SYS_YEAR); PRINT_CHAR (32); PRINT_TWO (SYS_TIME DIV 60); PRINT_CHAR (58); PRINT_TWO (SYS_TIME MOD 60) END; INPUT_STACK[INPUT_PTR] ← CUR_INPUT; PRINT_NL (798); L ← INPUT_STACK[0].LIMIT_FIELD; IF BUFFER[L] = EQTB[9211].INT THEN L ← L - 1; FOR K ← 1 TO L DO PRINT (BUFFER[K]); PRINT_LN; SELECTOR ← OLD_SETTING + 2 END; PROCEDURE START_INPUT; LABEL 30; BEGIN SCAN_FILE_NAME; IF CUR_EXT = 338 THEN CUR_EXT ← 791; PACK_FILE_NAME (CUR_NAME, CUR_AREA, CUR_EXT); WHILE TRUE DO BEGIN BEGIN_FILE_READING; IF A_OPEN_IN (INPUT_FILE[CUR_INPUT.INDEX_FIELD]) THEN GOTO 30; IF CUR_AREA = 338 THEN BEGIN PACK_FILE_NAME (CUR_NAME, 784, CUR_EXT); IF A_OPEN_IN (INPUT_FILE[CUR_INPUT.INDEX_FIELD]) THEN GOTO 30 END; END_FILE_READING; PROMPT_FILE_NAME (787, 791) END; 30: CUR_INPUT.NAME_FIELD ← A_MAKE_NAME_STRING (INPUT_FILE[CUR_INPUT.INDEX_FIELD]); IF JOB_NAME = 0 THEN BEGIN JOB_NAME ← CUR_NAME; OPEN_LOG_FILE END; IF TERM_OFFSET + (STR_START[CUR_INPUT.NAME_FIELD + 1] - STR_START[CUR_INPUT.NAME_FIELD]) > MAX_PRINT_LINE - 2 THEN PRINT_LN ELSE IF (TERM_OFFSET > 0) OR (FILE_OFFSET > 0) THEN PRINT_CHAR (32); PRINT_CHAR (40); OPEN_PARENS ← OPEN_PARENS + 1; SLOW_PRINT (CUR_INPUT.NAME_FIELD); BREAK (TERM_OUT); CUR_INPUT.STATE_FIELD ← 33; IF CUR_INPUT.NAME_FIELD = STR_PTR - 1 THEN BEGIN BEGIN STR_PTR ← STR_PTR - 1; POOL_PTR ← STR_START[STR_PTR] END; CUR_INPUT.NAME_FIELD ← CUR_NAME END; BEGIN LINE ← 1; IF INPUT_LN (INPUT_FILE[CUR_INPUT.INDEX_FIELD], FALSE) THEN ; FIRM_UP_THE_LINE; IF (EQTB[9211].INT < 0) OR (EQTB[9211].INT > 255) THEN CUR_INPUT.LIMIT_FIELD ← CUR_INPUT.LIMIT_FIELD - 1 ELSE BUFFER[CUR_INPUT.LIMIT_FIELD] ← EQTB[9211].INT; FIRST ← CUR_INPUT.LIMIT_FIELD + 1; CUR_INPUT.LOC_FIELD ← CUR_INPUT.START_FIELD END END; FUNCTION READ_FONT_INFO (U:HALFWORD; NOM:STR_NUMBER; AIRE:STR_NUMBER; S:SCALED):INTERNAL_FONT_NUMBER; LABEL 30, 11, 45; VAR K : FONT_INDEX; FILE_OPENED : BOOLEAN; LF : HALFWORD; LH : HALFWORD; BC : HALFWORD; EC : HALFWORD; NW : HALFWORD; NH : HALFWORD; ND : HALFWORD; NI : HALFWORD; NL : HALFWORD; NK : HALFWORD; NE : HALFWORD; NP : HALFWORD; F : INTERNAL_FONT_NUMBER; G : INTERNAL_FONT_NUMBER; A : EIGHT_BITS; B : EIGHT_BITS; C : EIGHT_BITS; D : EIGHT_BITS; QW : FOUR_QUARTERS; SW : SCALED; BCH_LABEL : INTEGER; BCHAR : 0..256; Z : SCALED; ALPHA : INTEGER; BETA : 1..16; BEGIN G ← 0; FILE_OPENED ← FALSE; IF AIRE = 338 THEN PACK_FILE_NAME (NOM, 785, 811) ELSE PACK_FILE_NAME (NOM, AIRE, 811); IF NOT B_OPEN_IN (TFM_FILE) THEN GOTO 11; FILE_OPENED ← TRUE; BEGIN BEGIN LF ← TFM_FILE↑; IF LF > 127 THEN GOTO 11; GET (TFM_FILE); LF ← LF * 256 + TFM_FILE↑ END; GET (TFM_FILE); BEGIN LH ← TFM_FILE↑; IF LH > 127 THEN GOTO 11; GET (TFM_FILE); LH ← LH * 256 + TFM_FILE↑ END; GET (TFM_FILE); BEGIN BC ← TFM_FILE↑; IF BC > 127 THEN GOTO 11; GET (TFM_FILE); BC ← BC * 256 + TFM_FILE↑ END; GET (TFM_FILE); BEGIN EC ← TFM_FILE↑; IF EC > 127 THEN GOTO 11; GET (TFM_FILE); EC ← EC * 256 + TFM_FILE↑ END; IF (BC > EC + 1) OR (EC > 255) THEN GOTO 11; IF BC > 255 THEN BEGIN BC ← 1; EC ← 0 END; GET (TFM_FILE); BEGIN NW ← TFM_FILE↑; IF NW > 127 THEN GOTO 11; GET (TFM_FILE); NW ← NW * 256 + TFM_FILE↑ END; GET (TFM_FILE); BEGIN NH ← TFM_FILE↑; IF NH > 127 THEN GOTO 11; GET (TFM_FILE); NH ← NH * 256 + TFM_FILE↑ END; GET (TFM_FILE); BEGIN ND ← TFM_FILE↑; IF ND > 127 THEN GOTO 11; GET (TFM_FILE); ND ← ND * 256 + TFM_FILE↑ END; GET (TFM_FILE); BEGIN NI ← TFM_FILE↑; IF NI > 127 THEN GOTO 11; GET (TFM_FILE); NI ← NI * 256 + TFM_FILE↑ END; GET (TFM_FILE); BEGIN NL ← TFM_FILE↑; IF NL > 127 THEN GOTO 11; GET (TFM_FILE); NL ← NL * 256 + TFM_FILE↑ END; GET (TFM_FILE); BEGIN NK ← TFM_FILE↑; IF NK > 127 THEN GOTO 11; GET (TFM_FILE); NK ← NK * 256 + TFM_FILE↑ END; GET (TFM_FILE); BEGIN NE ← TFM_FILE↑; IF NE > 127 THEN GOTO 11; GET (TFM_FILE); NE ← NE * 256 + TFM_FILE↑ END; GET (TFM_FILE); BEGIN NP ← TFM_FILE↑; IF NP > 127 THEN GOTO 11; GET (TFM_FILE); NP ← NP * 256 + TFM_FILE↑ END; IF LF ≠ 6 + LH + (EC - BC + 1) + NW + NH + ND + NI + NL + NK + NE + NP THEN GOTO 11; IF (NW = 0) OR (NH = 0) OR (ND = 0) OR (NI = 0) THEN GOTO 11 END; LF ← LF - 6 - LH; IF NP < 7 THEN LF ← LF + 7 - NP; IF (FONT_PTR = FONT_MAX) OR (FMEM_PTR + LF > FONT_MEM_SIZE) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (802) END; SPRINT_CS (U); PRINT_CHAR (61); PRINT_FILE_NAME (NOM, AIRE, 338); IF S ≥ 0 THEN BEGIN PRINT (741); PRINT_SCALED (S); PRINT (397) END ELSE IF S ≠ -1000 THEN BEGIN PRINT (803); PRINT_INT (-S) END; PRINT (812); BEGIN HELP_PTR ← 4; HELP_LINE[3] ← 813; HELP_LINE[2] ← 814; HELP_LINE[1] ← 815; HELP_LINE[0] ← 816 END; ERROR; GOTO 30 END; F ← FONT_PTR + 1; CHAR_BASE[F] ← FMEM_PTR - BC; WIDTH_BASE[F] ← CHAR_BASE[F] + EC + 1; HEIGHT_BASE[F] ← WIDTH_BASE[F] + NW; DEPTH_BASE[F] ← HEIGHT_BASE[F] + NH; ITALIC_BASE[F] ← DEPTH_BASE[F] + ND; LIG_KERN_BASE[F] ← ITALIC_BASE[F] + NI; KERN_BASE[F] ← LIG_KERN_BASE[F] + NL - 256 * 128; EXTEN_BASE[F] ← KERN_BASE[F] + 256 * 128 + NK; PARAM_BASE[F] ← EXTEN_BASE[F] + NE; BEGIN IF LH < 2 THEN GOTO 11; BEGIN GET (TFM_FILE); A ← TFM_FILE↑; QW.B0 ← A + 0; GET (TFM_FILE); B ← TFM_FILE↑; QW.B1 ← B + 0; GET (TFM_FILE); C ← TFM_FILE↑; QW.B2 ← C + 0; GET (TFM_FILE); D ← TFM_FILE↑; QW.B3 ← D + 0; FONT_CHECK[F] ← QW END; GET (TFM_FILE); BEGIN Z ← TFM_FILE↑; IF Z > 127 THEN GOTO 11; GET (TFM_FILE); Z ← Z * 256 + TFM_FILE↑ END; GET (TFM_FILE); Z ← Z * 256 + TFM_FILE↑; GET (TFM_FILE); Z ← Z * 16 + TFM_FILE↑ DIV 16; IF Z < 65536 THEN GOTO 11; WHILE LH > 2 DO BEGIN GET (TFM_FILE); GET (TFM_FILE); GET (TFM_FILE); GET (TFM_FILE); LH ← LH - 1 END; FONT_DSIZE[F] ← Z; IF S ≠ -1000 THEN IF S ≥ 0 THEN Z ← S ELSE Z ← XN_OVER_D (Z, -S, 1000); FONT_SIZE[F] ← Z END; FOR K ← FMEM_PTR TO WIDTH_BASE[F] - 1 DO BEGIN BEGIN GET (TFM_FILE); A ← TFM_FILE↑; QW.B0 ← A + 0; GET (TFM_FILE); B ← TFM_FILE↑; QW.B1 ← B + 0; GET (TFM_FILE); C ← TFM_FILE↑; QW.B2 ← C + 0; GET (TFM_FILE); D ← TFM_FILE↑; QW.B3 ← D + 0; FONT_INFO[K].QQQQ ← QW END; IF (A ≥ NW) OR (B DIV 16 ≥ NH) OR (B MOD 16 ≥ ND) OR (C DIV 4 ≥ NI) THEN GOTO 11; CASE C MOD 4 OF 1: IF D ≥ NL THEN GOTO 11; 3: IF D ≥ NE THEN GOTO 11; 2: BEGIN BEGIN IF (D < BC) OR (D > EC) THEN GOTO 11 END; WHILE D < K + BC - FMEM_PTR DO BEGIN QW ← FONT_INFO[CHAR_BASE[F] + D].QQQQ; IF (QW.B2 - 0) MOD 4 ≠ 2 THEN GOTO 45; D ← QW.B3 - 0 END; IF D = K + BC - FMEM_PTR THEN GOTO 11; 45: END; ELSE ; END END; BEGIN BEGIN ALPHA ← 16; WHILE Z ≥ 8388608 DO BEGIN Z ← Z DIV 2; ALPHA ← ALPHA + ALPHA END; BETA ← 256 DIV ALPHA; ALPHA ← ALPHA * Z END; FOR K ← WIDTH_BASE[F] TO LIG_KERN_BASE[F] - 1 DO BEGIN GET (TFM_FILE); A ← TFM_FILE↑; GET (TFM_FILE); B ← TFM_FILE↑; GET (TFM_FILE); C ← TFM_FILE↑; GET (TFM_FILE); D ← TFM_FILE↑; SW ← ((D * Z DIV 256 + C * Z) DIV 256 + B * Z) DIV BETA; IF A = 0 THEN FONT_INFO[K].INT ← SW ELSE IF A = 255 THEN FONT_INFO[K].INT ← SW - ALPHA ELSE GOTO 11 END; IF FONT_INFO[WIDTH_BASE[F]].INT ≠ 0 THEN GOTO 11; IF FONT_INFO[HEIGHT_BASE[F]].INT ≠ 0 THEN GOTO 11; IF FONT_INFO[DEPTH_BASE[F]].INT ≠ 0 THEN GOTO 11; IF FONT_INFO[ITALIC_BASE[F]].INT ≠ 0 THEN GOTO 11 END; BCH_LABEL ← 32767; BCHAR ← 256; IF NL > 0 THEN BEGIN FOR K ← LIG_KERN_BASE[F] TO KERN_BASE[F] + 256 * 128 - 1 DO BEGIN BEGIN GET (TFM_FILE); A ← TFM_FILE↑; QW.B0 ← A + 0; GET (TFM_FILE); B ← TFM_FILE↑; QW.B1 ← B + 0; GET (TFM_FILE); C ← TFM_FILE↑; QW.B2 ← C + 0; GET (TFM_FILE); D ← TFM_FILE↑; QW.B3 ← D + 0; FONT_INFO[K].QQQQ ← QW END; IF A > 128 THEN BEGIN IF 256 * C + D ≥ NL THEN GOTO 11; IF A = 255 THEN IF K = LIG_KERN_BASE[F] THEN BCHAR ← B END ELSE BEGIN IF B ≠ BCHAR THEN BEGIN BEGIN IF (B < BC) OR (B > EC) THEN GOTO 11 END; QW ← FONT_INFO[CHAR_BASE[F] + B].QQQQ; IF NOT (QW.B0 > 0) THEN GOTO 11 END; IF C < 128 THEN BEGIN BEGIN IF (D < BC) OR (D > EC) THEN GOTO 11 END; QW ← FONT_INFO[CHAR_BASE[F] + D].QQQQ; IF NOT (QW.B0 > 0) THEN GOTO 11 END ELSE IF 256 * (C - 128) + D ≥ NK THEN GOTO 11; IF A < 128 THEN IF K - LIG_KERN_BASE[F] + A + 1 ≥ NL THEN GOTO 11 END END; IF A = 255 THEN BCH_LABEL ← 256 * C + D END; FOR K ← KERN_BASE[F] + 256 * 128 TO EXTEN_BASE[F] - 1 DO BEGIN GET (TFM_FILE); A ← TFM_FILE↑; GET (TFM_FILE); B ← TFM_FILE↑; GET (TFM_FILE); C ← TFM_FILE↑; GET (TFM_FILE); D ← TFM_FILE↑; SW ← ((D * Z DIV 256 + C * Z) DIV 256 + B * Z) DIV BETA; IF A = 0 THEN FONT_INFO[K].INT ← SW ELSE IF A = 255 THEN FONT_INFO[K].INT ← SW - ALPHA ELSE GOTO 11 END; FOR K ← EXTEN_BASE[F] TO PARAM_BASE[F] - 1 DO BEGIN BEGIN GET (TFM_FILE); A ← TFM_FILE↑; QW.B0 ← A + 0; GET (TFM_FILE); B ← TFM_FILE↑; QW.B1 ← B + 0; GET (TFM_FILE); C ← TFM_FILE↑; QW.B2 ← C + 0; GET (TFM_FILE); D ← TFM_FILE↑; QW.B3 ← D + 0; FONT_INFO[K].QQQQ ← QW END; IF A ≠ 0 THEN BEGIN BEGIN IF (A < BC) OR (A > EC) THEN GOTO 11 END; QW ← FONT_INFO[CHAR_BASE[F] + A].QQQQ; IF NOT (QW.B0 > 0) THEN GOTO 11 END; IF B ≠ 0 THEN BEGIN BEGIN IF (B < BC) OR (B > EC) THEN GOTO 11 END; QW ← FONT_INFO[CHAR_BASE[F] + B].QQQQ; IF NOT (QW.B0 > 0) THEN GOTO 11 END; IF C ≠ 0 THEN BEGIN BEGIN IF (C < BC) OR (C > EC) THEN GOTO 11 END; QW ← FONT_INFO[CHAR_BASE[F] + C].QQQQ; IF NOT (QW.B0 > 0) THEN GOTO 11 END; BEGIN BEGIN IF (D < BC) OR (D > EC) THEN GOTO 11 END; QW ← FONT_INFO[CHAR_BASE[F] + D].QQQQ; IF NOT (QW.B0 > 0) THEN GOTO 11 END END; BEGIN FOR K ← 1 TO NP DO IF K = 1 THEN BEGIN GET (TFM_FILE); SW ← TFM_FILE↑; IF SW > 127 THEN SW ← SW - 256; GET (TFM_FILE); SW ← SW * 256 + TFM_FILE↑; GET (TFM_FILE); SW ← SW * 256 + TFM_FILE↑; GET (TFM_FILE); FONT_INFO[PARAM_BASE[F]].INT ← SW * 16 + TFM_FILE↑ DIV 16 END ELSE BEGIN GET (TFM_FILE); A ← TFM_FILE↑; GET (TFM_FILE); B ← TFM_FILE↑; GET (TFM_FILE); C ← TFM_FILE↑; GET (TFM_FILE); D ← TFM_FILE↑; SW ← ((D * Z DIV 256 + C * Z) DIV 256 + B * Z) DIV BETA; IF A = 0 THEN FONT_INFO[PARAM_BASE[F] + K - 1].INT ← SW ELSE IF A = 255 THEN FONT_INFO[PARAM_BASE[F] + K - 1].INT ← SW - ALPHA ELSE GOTO 11 END; IF EOF (TFM_FILE) THEN GOTO 11; FOR K ← NP + 1 TO 7 DO FONT_INFO[PARAM_BASE[F] + K - 1].INT ← 0 END; IF NP ≥ 7 THEN FONT_PARAMS[F] ← NP ELSE FONT_PARAMS[F] ← 7; HYPHEN_CHAR[F] ← EQTB[9209].INT; SKEW_CHAR[F] ← EQTB[9210].INT; IF BCH_LABEL < NL THEN BCHAR_LABEL[F] ← BCH_LABEL + LIG_KERN_BASE[F] ELSE BCHAR_LABEL[F] ← 0; FONT_BCHAR[F] ← BCHAR + 0; FONT_FALSE_BCHAR[F] ← BCHAR + 0; IF BCHAR ≤ EC THEN IF BCHAR ≥ BC THEN BEGIN QW ← FONT_INFO[CHAR_BASE[F] + BCHAR].QQQQ; IF QW.B0 > 0 THEN FONT_FALSE_BCHAR[F] ← 256 END; FONT_NAME[F] ← NOM; FONT_AREA[F] ← AIRE; FONT_BC[F] ← BC; FONT_EC[F] ← EC; FONT_GLUE[F] ← 0; CHAR_BASE[F] ← CHAR_BASE[F] - 0; WIDTH_BASE[F] ← WIDTH_BASE[F] - 0; LIG_KERN_BASE[F] ← LIG_KERN_BASE[F] - 0; KERN_BASE[F] ← KERN_BASE[F] - 0; EXTEN_BASE[F] ← EXTEN_BASE[F] - 0; PARAM_BASE[F] ← PARAM_BASE[F] - 1; FMEM_PTR ← FMEM_PTR + LF; FONT_PTR ← F; G ← F; GOTO 30; 11: BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (802) END; SPRINT_CS (U); PRINT_CHAR (61); PRINT_FILE_NAME (NOM, AIRE, 338); IF S ≥ 0 THEN BEGIN PRINT (741); PRINT_SCALED (S); PRINT (397) END ELSE IF S ≠ -1000 THEN BEGIN PRINT (803); PRINT_INT (-S) END; IF FILE_OPENED THEN PRINT (804) ELSE PRINT (805); BEGIN HELP_PTR ← 5; HELP_LINE[4] ← 806; HELP_LINE[3] ← 807; HELP_LINE[2] ← 808; HELP_LINE[1] ← 809; HELP_LINE[0] ← 810 END; ERROR; 30: IF FILE_OPENED THEN B_CLOSE (TFM_FILE); READ_FONT_INFO ← G END; PROCEDURE CHAR_WARNING (F:INTERNAL_FONT_NUMBER; C:EIGHT_BITS); BEGIN IF EQTB[9198].INT > 0 THEN BEGIN BEGIN_DIAGNOSTIC; PRINT_NL (825); PRINT (C); PRINT (826); SLOW_PRINT (FONT_NAME[F]); PRINT_CHAR (33); END_DIAGNOSTIC (FALSE) END END; FUNCTION NEW_CHARACTER (F:INTERNAL_FONT_NUMBER; C:EIGHT_BITS):HALFWORD; LABEL 10; VAR P : HALFWORD; BEGIN IF FONT_BC[F] ≤ C THEN IF FONT_EC[F] ≥ C THEN IF FONT_INFO[CHAR_BASE[F] + C + 0].QQQQ.B0 > 0 THEN BEGIN P ← GET_AVAIL; MEM[P].HH.B0 ← F; MEM[P].HH.B1 ← C + 0; NEW_CHARACTER ← P; GOTO 10 END; CHAR_WARNING (F, C); NEW_CHARACTER ← 0; 10: END; PROCEDURE WRITE_DVI (A:DVI_INDEX; B:DVI_INDEX); VAR K : DVI_INDEX; BEGIN FOR K ← A TO B DO WRITE (DVI_FILE, DVI_BUF[K]) END; PROCEDURE DVI_SWAP; BEGIN IF DVI_LIMIT = DVI_BUF_SIZE THEN BEGIN WRITE_DVI (0, HALF_BUF - 1); DVI_LIMIT ← HALF_BUF; DVI_OFFSET ← DVI_OFFSET + DVI_BUF_SIZE; DVI_PTR ← 0 END ELSE BEGIN WRITE_DVI (HALF_BUF, DVI_BUF_SIZE - 1); DVI_LIMIT ← DVI_BUF_SIZE END; DVI_GONE ← DVI_GONE + HALF_BUF END; PROCEDURE DVI_FOUR (X:INTEGER); BEGIN IF X ≥ 0 THEN BEGIN DVI_BUF[DVI_PTR] ← X DIV 16777216; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END ELSE BEGIN X ← X + 1073741824; X ← X + 1073741824; BEGIN DVI_BUF[DVI_PTR] ← X DIV 16777216 + 128; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END END; X ← X MOD 16777216; BEGIN DVI_BUF[DVI_PTR] ← X DIV 65536; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; X ← X MOD 65536; BEGIN DVI_BUF[DVI_PTR] ← X DIV 256; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; BEGIN DVI_BUF[DVI_PTR] ← X MOD 256; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END END; PROCEDURE DVI_POP (L:INTEGER); BEGIN IF (L = DVI_OFFSET + DVI_PTR) AND (DVI_PTR > 0) THEN DVI_PTR ← DVI_PTR - 1 ELSE BEGIN DVI_BUF[DVI_PTR] ← 142; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END END; PROCEDURE DVI_FONT_DEF (F:INTERNAL_FONT_NUMBER); VAR K : POOL_POINTER; BEGIN BEGIN DVI_BUF[DVI_PTR] ← 243; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; BEGIN DVI_BUF[DVI_PTR] ← F - 1; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; BEGIN DVI_BUF[DVI_PTR] ← FONT_CHECK[F].B0 - 0; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; BEGIN DVI_BUF[DVI_PTR] ← FONT_CHECK[F].B1 - 0; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; BEGIN DVI_BUF[DVI_PTR] ← FONT_CHECK[F].B2 - 0; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; BEGIN DVI_BUF[DVI_PTR] ← FONT_CHECK[F].B3 - 0; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; DVI_FOUR (FONT_SIZE[F]); DVI_FOUR (FONT_DSIZE[F]); BEGIN DVI_BUF[DVI_PTR] ← STR_START[FONT_AREA[F] + 1] - STR_START[FONT_AREA[F]]; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; BEGIN DVI_BUF[DVI_PTR] ← STR_START[FONT_NAME[F] + 1] - STR_START[FONT_NAME[F]]; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; FOR K ← STR_START[FONT_AREA[F]] TO STR_START[FONT_AREA[F] + 1] - 1 DO BEGIN DVI_BUF[DVI_PTR] ← STR_POOL[K]; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; FOR K ← STR_START[FONT_NAME[F]] TO STR_START[FONT_NAME[F] + 1] - 1 DO BEGIN DVI_BUF[DVI_PTR] ← STR_POOL[K]; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END END; PROCEDURE MOVEMENT (W:SCALED; O:EIGHT_BITS); LABEL 10, 40, 45, 2, 1; VAR MSTATE : SMALL_NUMBER; P : HALFWORD; Q : HALFWORD; K : INTEGER; BEGIN Q ← GET_NODE (3); MEM[Q + 1].INT ← W; MEM[Q + 2].INT ← DVI_OFFSET + DVI_PTR; IF O = 157 THEN BEGIN MEM[Q].HH.RH ← DOWN_PTR; DOWN_PTR ← Q END ELSE BEGIN MEM[Q].HH.RH ← RIGHT_PTR; RIGHT_PTR ← Q END; P ← MEM[Q].HH.RH; MSTATE ← 0; WHILE P ≠ 0 DO BEGIN IF MEM[P + 1].INT = W THEN CASE MSTATE + MEM[P].HH.LH OF 3,4,15, 16: IF MEM[P + 2].INT < DVI_GONE THEN GOTO 45 ELSE BEGIN K ← MEM[P + 2].INT - DVI_OFFSET; IF K < 0 THEN K ← K + DVI_BUF_SIZE; DVI_BUF[K] ← DVI_BUF[K] + 5; MEM[P].HH.LH ← 1; GOTO 40 END; 5,9, 11: IF MEM[P + 2].INT < DVI_GONE THEN GOTO 45 ELSE BEGIN K ← MEM[P + 2].INT - DVI_OFFSET; IF K < 0 THEN K ← K + DVI_BUF_SIZE; DVI_BUF[K] ← DVI_BUF[K] + 10; MEM[P].HH.LH ← 2; GOTO 40 END; 1,2,8,13: GOTO 40; ELSE ; END ELSE CASE MSTATE + MEM[P].HH.LH OF 1: MSTATE ← 6; 2: MSTATE ← 12; 8,13: GOTO 45; ELSE ; END; P ← MEM[P].HH.RH END; 45: ; MEM[Q].HH.LH ← 3; IF ABS (W) ≥ 8388608 THEN BEGIN BEGIN DVI_BUF[DVI_PTR] ← O + 3; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; DVI_FOUR (W); GOTO 10 END; IF ABS (W) ≥ 32768 THEN BEGIN BEGIN DVI_BUF[DVI_PTR] ← O + 2; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; IF W < 0 THEN W ← W + 16777216; BEGIN DVI_BUF[DVI_PTR] ← W DIV 65536; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; W ← W MOD 65536; GOTO 2 END; IF ABS (W) ≥ 128 THEN BEGIN BEGIN DVI_BUF[DVI_PTR] ← O + 1; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; IF W < 0 THEN W ← W + 65536; GOTO 2 END; BEGIN DVI_BUF[DVI_PTR] ← O; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; IF W < 0 THEN W ← W + 256; GOTO 1; 2: BEGIN DVI_BUF[DVI_PTR] ← W DIV 256; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; 1: BEGIN DVI_BUF[DVI_PTR] ← W MOD 256; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; GOTO 10; 40: MEM[Q].HH.LH ← MEM[P].HH.LH; IF MEM[Q].HH.LH = 1 THEN BEGIN BEGIN DVI_BUF[DVI_PTR] ← O + 4; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; WHILE MEM[Q].HH.RH ≠ P DO BEGIN Q ← MEM[Q].HH.RH; CASE MEM[Q].HH.LH OF 3: MEM[Q].HH.LH ← 5; 4: MEM[Q].HH.LH ← 6; ELSE ; END END END ELSE BEGIN BEGIN DVI_BUF[DVI_PTR] ← O + 9; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; WHILE MEM[Q].HH.RH ≠ P DO BEGIN Q ← MEM[Q].HH.RH; CASE MEM[Q].HH.LH OF 3: MEM[Q].HH.LH ← 4; 5: MEM[Q].HH.LH ← 6; ELSE ; END END END; 10: END; PROCEDURE PRUNE_MOVEMENTS (L:INTEGER); LABEL 30, 10; VAR P : HALFWORD; BEGIN WHILE DOWN_PTR ≠ 0 DO BEGIN IF MEM[DOWN_PTR + 2].INT < L THEN GOTO 30; P ← DOWN_PTR; DOWN_PTR ← MEM[P].HH.RH; FREE_NODE (P, 3) END; 30: WHILE RIGHT_PTR ≠ 0 DO BEGIN IF MEM[RIGHT_PTR + 2].INT < L THEN GOTO 10; P ← RIGHT_PTR; RIGHT_PTR ← MEM[P].HH.RH; FREE_NODE (P, 3) END; 10: END; PROCEDURE VLIST_OUT; FORWARD; PROCEDURE SPECIAL_OUT (P:HALFWORD); VAR OLD_SETTING : 0..21; K : POOL_POINTER; BEGIN IF CUR_H ≠ DVI_H THEN BEGIN MOVEMENT (CUR_H - DVI_H, 143); DVI_H ← CUR_H END; IF CUR_V ≠ DVI_V THEN BEGIN MOVEMENT (CUR_V - DVI_V, 157); DVI_V ← CUR_V END; OLD_SETTING ← SELECTOR; SELECTOR ← 21; SHOW_TOKEN_LIST (MEM[MEM[P + 1].HH.RH].HH.RH, 0, POOL_SIZE - POOL_PTR); SELECTOR ← OLD_SETTING; BEGIN IF POOL_PTR + 1 > POOL_SIZE THEN OVERFLOW (257, POOL_SIZE - INIT_POOL_PTR) END; IF POOL_PTR - STR_START[STR_PTR] < 256 THEN BEGIN BEGIN DVI_BUF[DVI_PTR] ← 239; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; BEGIN DVI_BUF[DVI_PTR] ← POOL_PTR - STR_START[STR_PTR]; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END END ELSE BEGIN BEGIN DVI_BUF[DVI_PTR] ← 242; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; DVI_FOUR (POOL_PTR - STR_START[STR_PTR]) END; FOR K ← STR_START[STR_PTR] TO POOL_PTR - 1 DO BEGIN DVI_BUF[DVI_PTR] ← STR_POOL[K]; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; POOL_PTR ← STR_START[STR_PTR] END; PROCEDURE WRITE_OUT (P:HALFWORD); VAR OLD_SETTING : 0..21; OLD_MODE : INTEGER; J : SMALL_NUMBER; Q : HALFWORD; R : HALFWORD; BEGIN Q ← GET_AVAIL; MEM[Q].HH.LH ← 637; R ← GET_AVAIL; MEM[Q].HH.RH ← R; MEM[R].HH.LH ← 10617; BEGIN_TOKEN_LIST (Q, 4); BEGIN_TOKEN_LIST (MEM[P + 1].HH.RH, 15); Q ← GET_AVAIL; MEM[Q].HH.LH ← 379; BEGIN_TOKEN_LIST (Q, 4); OLD_MODE ← CUR_LIST.MODE_FIELD; CUR_LIST.MODE_FIELD ← 0; CUR_CS ← WRITE_LOC; Q ← SCAN_TOKS (FALSE, TRUE); GET_TOKEN; IF CUR_TOK ≠ 10617 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1297) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 1298; HELP_LINE[0] ← 1012 END; ERROR; REPEAT GET_TOKEN UNTIL CUR_TOK = 10617 END; CUR_LIST.MODE_FIELD ← OLD_MODE; END_TOKEN_LIST; OLD_SETTING ← SELECTOR; J ← MEM[P + 1].HH.LH; IF WRITE_OPEN[J] THEN SELECTOR ← J ELSE BEGIN IF (J = 17) AND (SELECTOR = 19) THEN SELECTOR ← 18; PRINT_NL (338) END; TOKEN_SHOW (DEF_REF); PRINT_LN; FLUSH_LIST (DEF_REF); SELECTOR ← OLD_SETTING END; PROCEDURE OUT_WHAT (P:HALFWORD); VAR J : SMALL_NUMBER; BEGIN CASE MEM[P].HH.B1 OF 0,1, 2: IF NOT DOING_LEADERS THEN BEGIN J ← MEM[P + 1].HH.LH; IF MEM[P].HH.B1 = 1 THEN WRITE_OUT (P) ELSE BEGIN IF WRITE_OPEN[J] THEN A_CLOSE (WRITE_FILE[J]); IF MEM[P].HH.B1 = 2 THEN WRITE_OPEN[J] ← FALSE ELSE IF J < 16 THEN BEGIN CUR_NAME ← MEM[P + 1].HH.RH; CUR_AREA ← MEM[P + 2].HH.LH; CUR_EXT ← MEM[P + 2].HH.RH; IF CUR_EXT = 338 THEN CUR_EXT ← 791; PACK_FILE_NAME (CUR_NAME, CUR_AREA, CUR_EXT); WHILE NOT A_OPEN_OUT (WRITE_FILE[J]) DO PROMPT_FILE_NAME (1300, 791); WRITE_OPEN[J] ← TRUE END END END; 3: SPECIAL_OUT (P); 4: ; ELSE CONFUSION (1299); END END; PROCEDURE HLIST_OUT; LABEL 21, 13, 14, 15; VAR BASE_LINE : SCALED; LEFT_EDGE : SCALED; SAVE_H : SCALED; SAVE_V : SCALED; THIS_BOX : HALFWORD; G_ORDER : GLUE_ORD; G_SIGN : 0..2; P : HALFWORD; SAVE_LOC : INTEGER; LEADER_BOX : HALFWORD; LEADER_WD : SCALED; LX : SCALED; OUTER_DOING_LEADERS : BOOLEAN; EDGE : SCALED; GLUE_TEMP : REAL; CUR_GLUE : REAL; CUR_G : SCALED; BEGIN CUR_G ← 0; CUR_GLUE ← 0.0; THIS_BOX ← TEMP_PTR; G_ORDER ← MEM[THIS_BOX + 5].HH.B1; G_SIGN ← MEM[THIS_BOX + 5].HH.B0; P ← MEM[THIS_BOX + 5].HH.RH; CUR_S ← CUR_S + 1; IF CUR_S > 0 THEN BEGIN DVI_BUF[DVI_PTR] ← 141; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; IF CUR_S > MAX_PUSH THEN MAX_PUSH ← CUR_S; SAVE_LOC ← DVI_OFFSET + DVI_PTR; BASE_LINE ← CUR_V; LEFT_EDGE ← CUR_H; WHILE P ≠ 0 DO 21: IF P ≥ HI_MEM_MIN THEN BEGIN IF CUR_H ≠ DVI_H THEN BEGIN MOVEMENT (CUR_H - DVI_H, 143); DVI_H ← CUR_H END; IF CUR_V ≠ DVI_V THEN BEGIN MOVEMENT (CUR_V - DVI_V, 157); DVI_V ← CUR_V END; REPEAT F ← MEM[P].HH.B0; C ← MEM[P].HH.B1; IF F ≠ DVI_F THEN BEGIN IF NOT FONT_USED[F] THEN BEGIN DVI_FONT_DEF (F); FONT_USED[F] ← TRUE END; IF F ≤ 64 THEN BEGIN DVI_BUF[DVI_PTR] ← F + 170; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END ELSE BEGIN BEGIN DVI_BUF[DVI_PTR] ← 235; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; BEGIN DVI_BUF[DVI_PTR] ← F - 1; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END END; DVI_F ← F END; IF C ≥ 128 THEN BEGIN DVI_BUF[DVI_PTR] ← 128; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; BEGIN DVI_BUF[DVI_PTR] ← C - 0; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; CUR_H ← CUR_H + FONT_INFO[WIDTH_BASE[F] + FONT_INFO[CHAR_BASE[F] + C].QQQQ.B0].INT; P ← MEM[P].HH.RH UNTIL NOT (P ≥ HI_MEM_MIN); DVI_H ← CUR_H END ELSE BEGIN CASE MEM[P].HH.B0 OF 0, 1: IF MEM[P + 5].HH.RH = 0 THEN CUR_H ← CUR_H + MEM[P + 1].INT ELSE BEGIN SAVE_H ← DVI_H; SAVE_V ← DVI_V; CUR_V ← BASE_LINE + MEM[P + 4].INT; TEMP_PTR ← P; EDGE ← CUR_H; IF MEM[P].HH.B0 = 1 THEN VLIST_OUT ELSE HLIST_OUT; DVI_H ← SAVE_H; DVI_V ← SAVE_V; CUR_H ← EDGE + MEM[P + 1].INT; CUR_V ← BASE_LINE END; 2: BEGIN RULE_HT ← MEM[P + 3].INT; RULE_DP ← MEM[P + 2].INT; RULE_WD ← MEM[P + 1].INT; GOTO 14 END; 8: OUT_WHAT (P); 10: BEGIN G ← MEM[P + 1].HH.LH; RULE_WD ← MEM[G + 1].INT - CUR_G; IF G_SIGN ≠ 0 THEN BEGIN IF G_SIGN = 1 THEN BEGIN IF MEM[G].HH.B0 = G_ORDER THEN BEGIN CUR_GLUE ← CUR_GLUE + MEM[G + 2].INT; GLUE_TEMP ← MEM[THIS_BOX + 6].GR * CUR_GLUE; IF GLUE_TEMP > 1.0E+9 THEN GLUE_TEMP ← 1.0E+9 ELSE IF GLUE_TEMP < -1.0E+9 THEN GLUE_TEMP ← -1.0E+9; CUR_G ← ROUND (GLUE_TEMP) END END ELSE IF MEM[G].HH.B1 = G_ORDER THEN BEGIN CUR_GLUE ← CUR_GLUE - MEM[G + 3].INT; GLUE_TEMP ← MEM[THIS_BOX + 6].GR * CUR_GLUE; IF GLUE_TEMP > 1.0E+9 THEN GLUE_TEMP ← 1.0E+9 ELSE IF GLUE_TEMP < -1.0E+9 THEN GLUE_TEMP ← -1.0E+9; CUR_G ← ROUND (GLUE_TEMP) END END; RULE_WD ← RULE_WD + CUR_G; IF MEM[P].HH.B1 ≥ 100 THEN BEGIN LEADER_BOX ← MEM[P + 1].HH.RH; IF MEM[LEADER_BOX].HH.B0 = 2 THEN BEGIN RULE_HT ← MEM[LEADER_BOX + 3].INT; RULE_DP ← MEM[LEADER_BOX + 2].INT; GOTO 14 END; LEADER_WD ← MEM[LEADER_BOX + 1].INT; IF (LEADER_WD > 0) AND (RULE_WD > 0) THEN BEGIN RULE_WD ← RULE_WD + 10; EDGE ← CUR_H + RULE_WD; LX ← 0; IF MEM[P].HH.B1 = 100 THEN BEGIN SAVE_H ← CUR_H; CUR_H ← LEFT_EDGE + LEADER_WD * ((CUR_H - LEFT_EDGE) DIV LEADER_WD); IF CUR_H < SAVE_H THEN CUR_H ← CUR_H + LEADER_WD END ELSE BEGIN LQ ← RULE_WD DIV LEADER_WD; LR ← RULE_WD MOD LEADER_WD; IF MEM[P].HH.B1 = 101 THEN CUR_H ← CUR_H + LR DIV 2 ELSE BEGIN LX ← LR DIV (LQ + 1); CUR_H ← CUR_H + (LR - (LQ - 1) * LX) DIV 2 END END; WHILE CUR_H + LEADER_WD ≤ EDGE DO BEGIN CUR_V ← BASE_LINE + MEM[LEADER_BOX + 4].INT; IF CUR_V ≠ DVI_V THEN BEGIN MOVEMENT (CUR_V - DVI_V, 157); DVI_V ← CUR_V END; SAVE_V ← DVI_V; IF CUR_H ≠ DVI_H THEN BEGIN MOVEMENT (CUR_H - DVI_H, 143); DVI_H ← CUR_H END; SAVE_H ← DVI_H; TEMP_PTR ← LEADER_BOX; OUTER_DOING_LEADERS ← DOING_LEADERS; DOING_LEADERS ← TRUE; IF MEM[LEADER_BOX].HH.B0 = 1 THEN VLIST_OUT ELSE HLIST_OUT; DOING_LEADERS ← OUTER_DOING_LEADERS; DVI_V ← SAVE_V; DVI_H ← SAVE_H; CUR_V ← BASE_LINE; CUR_H ← SAVE_H + LEADER_WD + LX END; CUR_H ← EDGE - 10; GOTO 15 END END; GOTO 13 END; 11,9: CUR_H ← CUR_H + MEM[P + 1].INT; 6: BEGIN MEM[59988] ← MEM[P + 1]; MEM[59988].HH.RH ← MEM[P].HH.RH; P ← 59988; GOTO 21 END; ELSE ; END; GOTO 15; 14: IF RULE_HT = -1073741824 THEN RULE_HT ← MEM[THIS_BOX + 3].INT; IF RULE_DP = -1073741824 THEN RULE_DP ← MEM[THIS_BOX + 2].INT; RULE_HT ← RULE_HT + RULE_DP; IF (RULE_HT > 0) AND (RULE_WD > 0) THEN BEGIN IF CUR_H ≠ DVI_H THEN BEGIN MOVEMENT (CUR_H - DVI_H, 143); DVI_H ← CUR_H END; CUR_V ← BASE_LINE + RULE_DP; IF CUR_V ≠ DVI_V THEN BEGIN MOVEMENT (CUR_V - DVI_V, 157); DVI_V ← CUR_V END; BEGIN DVI_BUF[DVI_PTR] ← 132; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; DVI_FOUR (RULE_HT); DVI_FOUR (RULE_WD); CUR_V ← BASE_LINE; DVI_H ← DVI_H + RULE_WD END; 13: CUR_H ← CUR_H + RULE_WD; 15: P ← MEM[P].HH.RH END; PRUNE_MOVEMENTS (SAVE_LOC); IF CUR_S > 0 THEN DVI_POP (SAVE_LOC); CUR_S ← CUR_S - 1 END; PROCEDURE VLIST_OUT; LABEL 13, 14, 15; VAR LEFT_EDGE : SCALED; TOP_EDGE : SCALED; SAVE_H : SCALED; SAVE_V : SCALED; THIS_BOX : HALFWORD; G_ORDER : GLUE_ORD; G_SIGN : 0..2; P : HALFWORD; SAVE_LOC : INTEGER; LEADER_BOX : HALFWORD; LEADER_HT : SCALED; LX : SCALED; OUTER_DOING_LEADERS : BOOLEAN; EDGE : SCALED; GLUE_TEMP : REAL; CUR_GLUE : REAL; CUR_G : SCALED; BEGIN CUR_G ← 0; CUR_GLUE ← 0.0; THIS_BOX ← TEMP_PTR; G_ORDER ← MEM[THIS_BOX + 5].HH.B1; G_SIGN ← MEM[THIS_BOX + 5].HH.B0; P ← MEM[THIS_BOX + 5].HH.RH; CUR_S ← CUR_S + 1; IF CUR_S > 0 THEN BEGIN DVI_BUF[DVI_PTR] ← 141; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; IF CUR_S > MAX_PUSH THEN MAX_PUSH ← CUR_S; SAVE_LOC ← DVI_OFFSET + DVI_PTR; LEFT_EDGE ← CUR_H; CUR_V ← CUR_V - MEM[THIS_BOX + 3].INT; TOP_EDGE ← CUR_V; WHILE P ≠ 0 DO BEGIN IF P ≥ HI_MEM_MIN THEN CONFUSION (828) ELSE BEGIN CASE MEM[P].HH.B0 OF 0, 1: IF MEM[P + 5].HH.RH = 0 THEN CUR_V ← CUR_V + MEM[P + 3].INT + MEM[P + 2].INT ELSE BEGIN CUR_V ← CUR_V + MEM[P + 3].INT; IF CUR_V ≠ DVI_V THEN BEGIN MOVEMENT (CUR_V - DVI_V, 157); DVI_V ← CUR_V END; SAVE_H ← DVI_H; SAVE_V ← DVI_V; CUR_H ← LEFT_EDGE + MEM[P + 4].INT; TEMP_PTR ← P; IF MEM[P].HH.B0 = 1 THEN VLIST_OUT ELSE HLIST_OUT; DVI_H ← SAVE_H; DVI_V ← SAVE_V; CUR_V ← SAVE_V + MEM[P + 2].INT; CUR_H ← LEFT_EDGE END; 2: BEGIN RULE_HT ← MEM[P + 3].INT; RULE_DP ← MEM[P + 2].INT; RULE_WD ← MEM[P + 1].INT; GOTO 14 END; 8: OUT_WHAT (P); 10: BEGIN G ← MEM[P + 1].HH.LH; RULE_HT ← MEM[G + 1].INT - CUR_G; IF G_SIGN ≠ 0 THEN BEGIN IF G_SIGN = 1 THEN BEGIN IF MEM[G].HH.B0 = G_ORDER THEN BEGIN CUR_GLUE ← CUR_GLUE + MEM[G + 2].INT; GLUE_TEMP ← MEM[THIS_BOX + 6].GR * CUR_GLUE; IF GLUE_TEMP > 1.0E+9 THEN GLUE_TEMP ← 1.0E+9 ELSE IF GLUE_TEMP < -1.0E+9 THEN GLUE_TEMP ← -1.0E+9; CUR_G ← ROUND (GLUE_TEMP) END END ELSE IF MEM[G].HH.B1 = G_ORDER THEN BEGIN CUR_GLUE ← CUR_GLUE - MEM[G + 3].INT; GLUE_TEMP ← MEM[THIS_BOX + 6].GR * CUR_GLUE; IF GLUE_TEMP > 1.0E+9 THEN GLUE_TEMP ← 1.0E+9 ELSE IF GLUE_TEMP < -1.0E+9 THEN GLUE_TEMP ← -1.0E+9; CUR_G ← ROUND (GLUE_TEMP) END END; RULE_HT ← RULE_HT + CUR_G; IF MEM[P].HH.B1 ≥ 100 THEN BEGIN LEADER_BOX ← MEM[P + 1].HH.RH; IF MEM[LEADER_BOX].HH.B0 = 2 THEN BEGIN RULE_WD ← MEM[LEADER_BOX + 1].INT; RULE_DP ← 0; GOTO 14 END; LEADER_HT ← MEM[LEADER_BOX + 3].INT + MEM[LEADER_BOX + 2].INT; IF (LEADER_HT > 0) AND (RULE_HT > 0) THEN BEGIN RULE_HT ← RULE_HT + 10; EDGE ← CUR_V + RULE_HT; LX ← 0; IF MEM[P].HH.B1 = 100 THEN BEGIN SAVE_V ← CUR_V; CUR_V ← TOP_EDGE + LEADER_HT * ((CUR_V - TOP_EDGE) DIV LEADER_HT); IF CUR_V < SAVE_V THEN CUR_V ← CUR_V + LEADER_HT END ELSE BEGIN LQ ← RULE_HT DIV LEADER_HT; LR ← RULE_HT MOD LEADER_HT; IF MEM[P].HH.B1 = 101 THEN CUR_V ← CUR_V + LR DIV 2 ELSE BEGIN LX ← LR DIV (LQ + 1); CUR_V ← CUR_V + (LR - (LQ - 1) * LX) DIV 2 END END; WHILE CUR_V + LEADER_HT ≤ EDGE DO BEGIN CUR_H ← LEFT_EDGE + MEM[LEADER_BOX + 4].INT; IF CUR_H ≠ DVI_H THEN BEGIN MOVEMENT (CUR_H - DVI_H, 143); DVI_H ← CUR_H END; SAVE_H ← DVI_H; CUR_V ← CUR_V + MEM[LEADER_BOX + 3].INT; IF CUR_V ≠ DVI_V THEN BEGIN MOVEMENT (CUR_V - DVI_V, 157); DVI_V ← CUR_V END; SAVE_V ← DVI_V; TEMP_PTR ← LEADER_BOX; OUTER_DOING_LEADERS ← DOING_LEADERS; DOING_LEADERS ← TRUE; IF MEM[LEADER_BOX].HH.B0 = 1 THEN VLIST_OUT ELSE HLIST_OUT; DOING_LEADERS ← OUTER_DOING_LEADERS; DVI_V ← SAVE_V; DVI_H ← SAVE_H; CUR_H ← LEFT_EDGE; CUR_V ← SAVE_V - MEM[LEADER_BOX + 3].INT + LEADER_HT + LX END; CUR_V ← EDGE - 10; GOTO 15 END END; GOTO 13 END; 11: CUR_V ← CUR_V + MEM[P + 1].INT; ELSE ; END; GOTO 15; 14: IF RULE_WD = -1073741824 THEN RULE_WD ← MEM[THIS_BOX + 1].INT; RULE_HT ← RULE_HT + RULE_DP; CUR_V ← CUR_V + RULE_HT; IF (RULE_HT > 0) AND (RULE_WD > 0) THEN BEGIN IF CUR_H ≠ DVI_H THEN BEGIN MOVEMENT (CUR_H - DVI_H, 143); DVI_H ← CUR_H END; IF CUR_V ≠ DVI_V THEN BEGIN MOVEMENT (CUR_V - DVI_V, 157); DVI_V ← CUR_V END; BEGIN DVI_BUF[DVI_PTR] ← 137; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; DVI_FOUR (RULE_HT); DVI_FOUR (RULE_WD) END; GOTO 15; 13: CUR_V ← CUR_V + RULE_HT END; 15: P ← MEM[P].HH.RH END; PRUNE_MOVEMENTS (SAVE_LOC); IF CUR_S > 0 THEN DVI_POP (SAVE_LOC); CUR_S ← CUR_S - 1 END; PROCEDURE SHIP_OUT (P:HALFWORD); LABEL 30; VAR PAGE_LOC : INTEGER; J : 0..9; K : 0..9; S : POOL_POINTER; OLD_SETTING : 0..21; BEGIN IF EQTB[9197].INT > 0 THEN BEGIN PRINT_NL (338); PRINT_LN; PRINT (829) END; IF TERM_OFFSET > MAX_PRINT_LINE - 9 THEN PRINT_LN ELSE IF (TERM_OFFSET > 0) OR (FILE_OFFSET > 0) THEN PRINT_CHAR (32); PRINT_CHAR (91); J ← 9; WHILE (EQTB[9218 + J].INT = 0) AND (J > 0) DO J ← J - 1; FOR K ← 0 TO J DO BEGIN PRINT_INT (EQTB[9218 + K].INT); IF K < J THEN PRINT_CHAR (46) END; BREAK (TERM_OUT); IF EQTB[9197].INT > 0 THEN BEGIN PRINT_CHAR (93); BEGIN_DIAGNOSTIC; SHOW_BOX (P); END_DIAGNOSTIC (TRUE) END; IF (MEM[P + 3].INT > 1073741823) OR (MEM[P + 2].INT > 1073741823) OR (MEM[P + 3].INT + MEM[P + 2].INT + EQTB[9749].INT > 1073741823) OR (MEM[P + 1].INT + EQTB[9748].INT > 1073741823) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (833) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 834; HELP_LINE[0] ← 835 END; ERROR; IF EQTB[9197].INT ≤ 0 THEN BEGIN BEGIN_DIAGNOSTIC; PRINT_NL (836); SHOW_BOX (P); END_DIAGNOSTIC (TRUE) END; GOTO 30 END; IF MEM[P + 3].INT + MEM[P + 2].INT + EQTB[9749].INT > MAX_V THEN MAX_V ← MEM[P + 3].INT + MEM[P + 2].INT + EQTB[9749].INT; IF MEM[P + 1].INT + EQTB[9748].INT > MAX_H THEN MAX_H ← MEM[P + 1].INT + EQTB[9748].INT; DVI_H ← 0; DVI_V ← 0; CUR_H ← EQTB[9748].INT; DVI_F ← 0; IF OUTPUT_FILE_NAME = 0 THEN BEGIN IF JOB_NAME = 0 THEN OPEN_LOG_FILE; PACK_JOB_NAME (794); WHILE NOT B_OPEN_OUT (DVI_FILE) DO PROMPT_FILE_NAME (795, 794); OUTPUT_FILE_NAME ← B_MAKE_NAME_STRING (DVI_FILE) END; IF TOTAL_PAGES = 0 THEN BEGIN BEGIN DVI_BUF[DVI_PTR] ← 247; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; BEGIN DVI_BUF[DVI_PTR] ← 2; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; DVI_FOUR (25400000); DVI_FOUR (473628672); PREPARE_MAG; DVI_FOUR (EQTB[9180].INT); OLD_SETTING ← SELECTOR; SELECTOR ← 21; PRINT (827); PRINT_INT (EQTB[9186].INT); PRINT_CHAR (46); PRINT_TWO (EQTB[9185].INT); PRINT_CHAR (46); PRINT_TWO (EQTB[9184].INT); PRINT_CHAR (58); PRINT_TWO (EQTB[9183].INT DIV 60); PRINT_TWO (EQTB[9183].INT MOD 60); SELECTOR ← OLD_SETTING; BEGIN DVI_BUF[DVI_PTR] ← POOL_PTR - STR_START[STR_PTR]; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; FOR S ← STR_START[STR_PTR] TO POOL_PTR - 1 DO BEGIN DVI_BUF[DVI_PTR] ← STR_POOL[S]; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; POOL_PTR ← STR_START[STR_PTR] END; PAGE_LOC ← DVI_OFFSET + DVI_PTR; BEGIN DVI_BUF[DVI_PTR] ← 139; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; FOR K ← 0 TO 9 DO DVI_FOUR (EQTB[9218 + K].INT); DVI_FOUR (LAST_BOP); LAST_BOP ← PAGE_LOC; CUR_V ← MEM[P + 3].INT + EQTB[9749].INT; TEMP_PTR ← P; IF MEM[P].HH.B0 = 1 THEN VLIST_OUT ELSE HLIST_OUT; BEGIN DVI_BUF[DVI_PTR] ← 140; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; TOTAL_PAGES ← TOTAL_PAGES + 1; CUR_S ← -1; 30: ; IF EQTB[9197].INT ≤ 0 THEN PRINT_CHAR (93); DEAD_CYCLES ← 0; BREAK (TERM_OUT); FLUSH_NODE_LIST (P) END; PROCEDURE SCAN_SPEC (C:GROUP_CODE; THREE_CODES:BOOLEAN); LABEL 40; VAR S : INTEGER; SPEC_CODE : 0..1; BEGIN IF THREE_CODES THEN S ← SAVE_STACK[SAVE_PTR + 0].INT; IF SCAN_KEYWORD (842) THEN SPEC_CODE ← 0 ELSE IF SCAN_KEYWORD (843) THEN SPEC_CODE ← 1 ELSE BEGIN SPEC_CODE ← 1; CUR_VAL ← 0; GOTO 40 END; SCAN_DIMEN (FALSE, FALSE, FALSE); 40: IF THREE_CODES THEN BEGIN SAVE_STACK[SAVE_PTR + 0].INT ← S; SAVE_PTR ← SAVE_PTR + 1 END; SAVE_STACK[SAVE_PTR + 0].INT ← SPEC_CODE; SAVE_STACK[SAVE_PTR + 1].INT ← CUR_VAL; SAVE_PTR ← SAVE_PTR + 2; NEW_SAVE_LEVEL (C); SCAN_LEFT_BRACE END; FUNCTION HPACK (P:HALFWORD; W:SCALED; M:SMALL_NUMBER):HALFWORD; LABEL 21, 50, 10; VAR R : HALFWORD; Q : HALFWORD; H : SCALED; D : SCALED; X : SCALED; S : SCALED; G : HALFWORD; O : GLUE_ORD; F : INTERNAL_FONT_NUMBER; I : FOUR_QUARTERS; HD : EIGHT_BITS; BEGIN LAST_BADNESS ← 0; R ← GET_NODE (7); MEM[R].HH.B0 ← 0; MEM[R].HH.B1 ← 0; MEM[R + 4].INT ← 0; Q ← R + 5; MEM[Q].HH.RH ← P; H ← 0; D ← 0; X ← 0; TOTAL_STRETCH[0] ← 0; TOTAL_SHRINK[0] ← 0; TOTAL_STRETCH[1] ← 0; TOTAL_SHRINK[1] ← 0; TOTAL_STRETCH[2] ← 0; TOTAL_SHRINK[2] ← 0; TOTAL_STRETCH[3] ← 0; TOTAL_SHRINK[3] ← 0; WHILE P ≠ 0 DO BEGIN 21: WHILE P ≥ HI_MEM_MIN DO BEGIN F ← MEM[P].HH.B0; I ← FONT_INFO[CHAR_BASE[F] + MEM[P].HH.B1].QQQQ; HD ← I.B1 - 0; X ← X + FONT_INFO[WIDTH_BASE[F] + I.B0].INT; S ← FONT_INFO[HEIGHT_BASE[F] + HD DIV 16].INT; IF S > H THEN H ← S; S ← FONT_INFO[DEPTH_BASE[F] + HD MOD 16].INT; IF S > D THEN D ← S; P ← MEM[P].HH.RH END; IF P ≠ 0 THEN BEGIN CASE MEM[P].HH.B0 OF 0,1,2, 13: BEGIN X ← X + MEM[P + 1].INT; IF MEM[P].HH.B0 ≥ 2 THEN S ← 0 ELSE S ← MEM[P + 4].INT; IF MEM[P + 3].INT - S > H THEN H ← MEM[P + 3].INT - S; IF MEM[P + 2].INT + S > D THEN D ← MEM[P + 2].INT + S END; 3,4, 5: IF ADJUST_TAIL ≠ 0 THEN BEGIN WHILE MEM[Q].HH.RH ≠ P DO Q ← MEM[Q].HH.RH; IF MEM[P].HH.B0 = 5 THEN BEGIN MEM[ADJUST_TAIL].HH.RH ← MEM[P + 1].INT; WHILE MEM[ADJUST_TAIL].HH.RH ≠ 0 DO ADJUST_TAIL ← MEM[ADJUST_TAIL].HH.RH; P ← MEM[P].HH.RH; FREE_NODE (MEM[Q].HH.RH, 2) END ELSE BEGIN MEM[ADJUST_TAIL].HH.RH ← P; ADJUST_TAIL ← P; P ← MEM[P].HH.RH END; MEM[Q].HH.RH ← P; P ← Q END; 8: ; 10: BEGIN G ← MEM[P + 1].HH.LH; X ← X + MEM[G + 1].INT; O ← MEM[G].HH.B0; TOTAL_STRETCH[O] ← TOTAL_STRETCH[O] + MEM[G + 2].INT; O ← MEM[G].HH.B1; TOTAL_SHRINK[O] ← TOTAL_SHRINK[O] + MEM[G + 3].INT; IF MEM[P].HH.B1 ≥ 100 THEN BEGIN G ← MEM[P + 1].HH.RH; IF MEM[G + 3].INT > H THEN H ← MEM[G + 3].INT; IF MEM[G + 2].INT > D THEN D ← MEM[G + 2].INT END END; 11,9: X ← X + MEM[P + 1].INT; 6: BEGIN MEM[59988] ← MEM[P + 1]; MEM[59988].HH.RH ← MEM[P].HH.RH; P ← 59988; GOTO 21 END; ELSE ; END; P ← MEM[P].HH.RH END END; IF ADJUST_TAIL ≠ 0 THEN MEM[ADJUST_TAIL].HH.RH ← 0; MEM[R + 3].INT ← H; MEM[R + 2].INT ← D; IF M = 1 THEN W ← X + W; MEM[R + 1].INT ← W; X ← W - X; IF X = 0 THEN BEGIN MEM[R + 5].HH.B0 ← 0; MEM[R + 5].HH.B1 ← 0; MEM[R + 6].GR ← 0.0; GOTO 10 END ELSE IF X > 0 THEN BEGIN IF TOTAL_STRETCH[3] ≠ 0 THEN O ← 3 ELSE IF TOTAL_STRETCH[2] ≠ 0 THEN O ← 2 ELSE IF TOTAL_STRETCH[1] ≠ 0 THEN O ← 1 ELSE O ← 0; MEM[R + 5].HH.B1 ← O; MEM[R + 5].HH.B0 ← 1; IF TOTAL_STRETCH[O] ≠ 0 THEN MEM[R + 6].GR ← X / TOTAL_STRETCH[O] ELSE BEGIN MEM[R + 5].HH.B0 ← 0; MEM[R + 6].GR ← 0.0 END; IF O = 0 THEN IF MEM[R + 5].HH.RH ≠ 0 THEN BEGIN LAST_BADNESS ← BADNESS (X, TOTAL_STRETCH[0]); IF LAST_BADNESS > EQTB[9189].INT THEN BEGIN PRINT_LN; IF LAST_BADNESS > 100 THEN PRINT_NL (844) ELSE PRINT_NL (845); PRINT (846); PRINT_INT (LAST_BADNESS); GOTO 50 END END; GOTO 10 END ELSE BEGIN IF TOTAL_SHRINK[3] ≠ 0 THEN O ← 3 ELSE IF TOTAL_SHRINK[2] ≠ 0 THEN O ← 2 ELSE IF TOTAL_SHRINK[1] ≠ 0 THEN O ← 1 ELSE O ← 0; MEM[R + 5].HH.B1 ← O; MEM[R + 5].HH.B0 ← 2; IF TOTAL_SHRINK[O] ≠ 0 THEN MEM[R + 6].GR ← (-X) / TOTAL_SHRINK[O] ELSE BEGIN MEM[R + 5].HH.B0 ← 0; MEM[R + 6].GR ← 0.0 END; IF (TOTAL_SHRINK[O] < -X) AND (O = 0) AND (MEM[R + 5].HH.RH ≠ 0) THEN BEGIN LAST_BADNESS ← 1000000; MEM[R + 6].GR ← 1.0; IF (-X - TOTAL_SHRINK[0] > EQTB[9738].INT) OR (EQTB[9189].INT < 100) THEN BEGIN IF (EQTB[9746].INT > 0) AND (-X - TOTAL_SHRINK[0] > EQTB[9738].INT) THEN BEGIN WHILE MEM[Q].HH.RH ≠ 0 DO Q ← MEM[Q].HH.RH; MEM[Q].HH.RH ← NEW_RULE; MEM[MEM[Q].HH.RH + 1].INT ← EQTB[9746].INT END; PRINT_LN; PRINT_NL (852); PRINT_SCALED (-X - TOTAL_SHRINK[0]); PRINT (853); GOTO 50 END END ELSE IF O = 0 THEN IF MEM[R + 5].HH.RH ≠ 0 THEN BEGIN LAST_BADNESS ← BADNESS (-X, TOTAL_SHRINK[0]); IF LAST_BADNESS > EQTB[9189].INT THEN BEGIN PRINT_LN; PRINT_NL (854); PRINT_INT (LAST_BADNESS); GOTO 50 END END; GOTO 10 END; 50: IF OUTPUT_ACTIVE THEN PRINT (847) ELSE BEGIN IF PACK_BEGIN_LINE ≠ 0 THEN BEGIN IF PACK_BEGIN_LINE > 0 THEN PRINT (848) ELSE PRINT (849); PRINT_INT (ABS (PACK_BEGIN_LINE)); PRINT (850) END ELSE PRINT (851); PRINT_INT (LINE) END; PRINT_LN; FONT_IN_SHORT_DISPLAY ← 0; SHORT_DISPLAY (MEM[R + 5].HH.RH); PRINT_LN; BEGIN_DIAGNOSTIC; SHOW_BOX (R); END_DIAGNOSTIC (TRUE); 10: HPACK ← R END; FUNCTION VPACKAGE (P:HALFWORD; H:SCALED; M:SMALL_NUMBER; L:SCALED):HALFWORD; LABEL 50, 10; VAR R : HALFWORD; W : SCALED; D : SCALED; X : SCALED; S : SCALED; G : HALFWORD; O : GLUE_ORD; BEGIN LAST_BADNESS ← 0; R ← GET_NODE (7); MEM[R].HH.B0 ← 1; MEM[R].HH.B1 ← 0; MEM[R + 4].INT ← 0; MEM[R + 5].HH.RH ← P; W ← 0; D ← 0; X ← 0; TOTAL_STRETCH[0] ← 0; TOTAL_SHRINK[0] ← 0; TOTAL_STRETCH[1] ← 0; TOTAL_SHRINK[1] ← 0; TOTAL_STRETCH[2] ← 0; TOTAL_SHRINK[2] ← 0; TOTAL_STRETCH[3] ← 0; TOTAL_SHRINK[3] ← 0; WHILE P ≠ 0 DO BEGIN IF P ≥ HI_MEM_MIN THEN CONFUSION (855) ELSE CASE MEM[P].HH.B0 OF 0,1,2, 13: BEGIN X ← X + D + MEM[P + 3].INT; D ← MEM[P + 2].INT; IF MEM[P].HH.B0 ≥ 2 THEN S ← 0 ELSE S ← MEM[P + 4].INT; IF MEM[P + 1].INT + S > W THEN W ← MEM[P + 1].INT + S END; 8: ; 10: BEGIN X ← X + D; D ← 0; G ← MEM[P + 1].HH.LH; X ← X + MEM[G + 1].INT; O ← MEM[G].HH.B0; TOTAL_STRETCH[O] ← TOTAL_STRETCH[O] + MEM[G + 2].INT; O ← MEM[G].HH.B1; TOTAL_SHRINK[O] ← TOTAL_SHRINK[O] + MEM[G + 3].INT; IF MEM[P].HH.B1 ≥ 100 THEN BEGIN G ← MEM[P + 1].HH.RH; IF MEM[G + 1].INT > W THEN W ← MEM[G + 1].INT END END; 11: BEGIN X ← X + D + MEM[P + 1].INT; D ← 0 END; ELSE ; END; P ← MEM[P].HH.RH END; MEM[R + 1].INT ← W; IF D > L THEN BEGIN X ← X + D - L; MEM[R + 2].INT ← L END ELSE MEM[R + 2].INT ← D; IF M = 1 THEN H ← X + H; MEM[R + 3].INT ← H; X ← H - X; IF X = 0 THEN BEGIN MEM[R + 5].HH.B0 ← 0; MEM[R + 5].HH.B1 ← 0; MEM[R + 6].GR ← 0.0; GOTO 10 END ELSE IF X > 0 THEN BEGIN IF TOTAL_STRETCH[3] ≠ 0 THEN O ← 3 ELSE IF TOTAL_STRETCH[2] ≠ 0 THEN O ← 2 ELSE IF TOTAL_STRETCH[1] ≠ 0 THEN O ← 1 ELSE O ← 0; MEM[R + 5].HH.B1 ← O; MEM[R + 5].HH.B0 ← 1; IF TOTAL_STRETCH[O] ≠ 0 THEN MEM[R + 6].GR ← X / TOTAL_STRETCH[O] ELSE BEGIN MEM[R + 5].HH.B0 ← 0; MEM[R + 6].GR ← 0.0 END; IF O = 0 THEN IF MEM[R + 5].HH.RH ≠ 0 THEN BEGIN LAST_BADNESS ← BADNESS (X, TOTAL_STRETCH[0]); IF LAST_BADNESS > EQTB[9190].INT THEN BEGIN PRINT_LN; IF LAST_BADNESS > 100 THEN PRINT_NL (844) ELSE PRINT_NL (845); PRINT (856); PRINT_INT (LAST_BADNESS); GOTO 50 END END; GOTO 10 END ELSE BEGIN IF TOTAL_SHRINK[3] ≠ 0 THEN O ← 3 ELSE IF TOTAL_SHRINK[2] ≠ 0 THEN O ← 2 ELSE IF TOTAL_SHRINK[1] ≠ 0 THEN O ← 1 ELSE O ← 0; MEM[R + 5].HH.B1 ← O; MEM[R + 5].HH.B0 ← 2; IF TOTAL_SHRINK[O] ≠ 0 THEN MEM[R + 6].GR ← (-X) / TOTAL_SHRINK[O] ELSE BEGIN MEM[R + 5].HH.B0 ← 0; MEM[R + 6].GR ← 0.0 END; IF (TOTAL_SHRINK[O] < -X) AND (O = 0) AND (MEM[R + 5].HH.RH ≠ 0) THEN BEGIN LAST_BADNESS ← 1000000; MEM[R + 6].GR ← 1.0; IF (-X - TOTAL_SHRINK[0] > EQTB[9739].INT) OR (EQTB[9190].INT < 100) THEN BEGIN PRINT_LN; PRINT_NL (857); PRINT_SCALED (-X - TOTAL_SHRINK[0]); PRINT (858); GOTO 50 END END ELSE IF O = 0 THEN IF MEM[R + 5].HH.RH ≠ 0 THEN BEGIN LAST_BADNESS ← BADNESS (-X, TOTAL_SHRINK[0]); IF LAST_BADNESS > EQTB[9190].INT THEN BEGIN PRINT_LN; PRINT_NL (859); PRINT_INT (LAST_BADNESS); GOTO 50 END END; GOTO 10 END; 50: IF OUTPUT_ACTIVE THEN PRINT (847) ELSE BEGIN IF PACK_BEGIN_LINE ≠ 0 THEN BEGIN PRINT (849); PRINT_INT (ABS (PACK_BEGIN_LINE)); PRINT (850) END ELSE PRINT (851); PRINT_INT (LINE); PRINT_LN END; BEGIN_DIAGNOSTIC; SHOW_BOX (R); END_DIAGNOSTIC (TRUE); 10: VPACKAGE ← R END; PROCEDURE APPEND_TO_VLIST (B:HALFWORD); VAR D : SCALED; P : HALFWORD; BEGIN IF CUR_LIST.AUX_FIELD.INT > -65536000 THEN BEGIN D ← MEM[EQTB[6783].HH.RH + 1].INT - CUR_LIST.AUX_FIELD.INT - MEM[B + 3].INT; IF D < EQTB[9732].INT THEN P ← NEW_PARAM_GLUE (0) ELSE BEGIN P ← NEW_SKIP_PARAM (1); MEM[TEMP_PTR + 1].INT ← D END; MEM[CUR_LIST.TAIL_FIELD].HH.RH ← P; CUR_LIST.TAIL_FIELD ← P END; MEM[CUR_LIST.TAIL_FIELD].HH.RH ← B; CUR_LIST.TAIL_FIELD ← B; CUR_LIST.AUX_FIELD.INT ← MEM[B + 2].INT END; FUNCTION NEW_NOAD:HALFWORD; VAR P : HALFWORD; BEGIN P ← GET_NODE (4); MEM[P].HH.B0 ← 16; MEM[P].HH.B1 ← 0; MEM[P + 1].HH ← EMPTY_FIELD; MEM[P + 3].HH ← EMPTY_FIELD; MEM[P + 2].HH ← EMPTY_FIELD; NEW_NOAD ← P END; FUNCTION NEW_STYLE (S:SMALL_NUMBER):HALFWORD; VAR P : HALFWORD; BEGIN P ← GET_NODE (3); MEM[P].HH.B0 ← 14; MEM[P].HH.B1 ← S; MEM[P + 1].INT ← 0; MEM[P + 2].INT ← 0; NEW_STYLE ← P END; FUNCTION NEW_CHOICE:HALFWORD; VAR P : HALFWORD; BEGIN P ← GET_NODE (3); MEM[P].HH.B0 ← 15; MEM[P].HH.B1 ← 0; MEM[P + 1].HH.LH ← 0; MEM[P + 1].HH.RH ← 0; MEM[P + 2].HH.LH ← 0; MEM[P + 2].HH.RH ← 0; NEW_CHOICE ← P END; PROCEDURE SHOW_INFO; BEGIN SHOW_NODE_LIST (MEM[TEMP_PTR].HH.LH) END; FUNCTION FRACTION_RULE (T:SCALED):HALFWORD; VAR P : HALFWORD; BEGIN P ← NEW_RULE; MEM[P + 3].INT ← T; MEM[P + 2].INT ← 0; FRACTION_RULE ← P END; FUNCTION OVERBAR (B:HALFWORD; K:SCALED; T:SCALED):HALFWORD; VAR P : HALFWORD; Q : HALFWORD; BEGIN P ← NEW_KERN (K); MEM[P].HH.RH ← B; Q ← FRACTION_RULE (T); MEM[Q].HH.RH ← P; P ← NEW_KERN (T); MEM[P].HH.RH ← Q; OVERBAR ← VPACKAGE (P, 0, 1, 1073741823) END; FUNCTION CHAR_BOX (F:INTERNAL_FONT_NUMBER; C:QUARTERWORD):HALFWORD; VAR Q : FOUR_QUARTERS; HD : EIGHT_BITS; B : HALFWORD; P : HALFWORD; BEGIN Q ← FONT_INFO[CHAR_BASE[F] + C].QQQQ; HD ← Q.B1 - 0; B ← NEW_NULL_BOX; MEM[B + 1].INT ← FONT_INFO[WIDTH_BASE[F] + Q.B0].INT + FONT_INFO[ITALIC_BASE[F] + (Q.B2 - 0) DIV 4].INT; MEM[B + 3].INT ← FONT_INFO[HEIGHT_BASE[F] + HD DIV 16].INT; MEM[B + 2].INT ← FONT_INFO[DEPTH_BASE[F] + HD MOD 16].INT; P ← GET_AVAIL; MEM[P].HH.B1 ← C; MEM[P].HH.B0 ← F; MEM[B + 5].HH.RH ← P; CHAR_BOX ← B END; PROCEDURE STACK_INTO_BOX (B:HALFWORD; F:INTERNAL_FONT_NUMBER; C:QUARTERWORD); VAR P : HALFWORD; BEGIN P ← CHAR_BOX (F, C); MEM[P].HH.RH ← MEM[B + 5].HH.RH; MEM[B + 5].HH.RH ← P; MEM[B + 3].INT ← MEM[P + 3].INT END; FUNCTION HEIGHT_PLUS_DEPTH (F:INTERNAL_FONT_NUMBER; C:QUARTERWORD):SCALED; VAR Q : FOUR_QUARTERS; HD : EIGHT_BITS; BEGIN Q ← FONT_INFO[CHAR_BASE[F] + C].QQQQ; HD ← Q.B1 - 0; HEIGHT_PLUS_DEPTH ← FONT_INFO[HEIGHT_BASE[F] + HD DIV 16].INT + FONT_INFO[DEPTH_BASE[F] + HD MOD 16].INT END; FUNCTION VAR_DELIMITER (D:HALFWORD; S:SMALL_NUMBER; V:SCALED):HALFWORD; LABEL 40, 22; VAR B : HALFWORD; F : INTERNAL_FONT_NUMBER; G : INTERNAL_FONT_NUMBER; C : QUARTERWORD; X : QUARTERWORD; Y : QUARTERWORD; M : INTEGER; N : INTEGER; U : SCALED; W : SCALED; Q : FOUR_QUARTERS; HD : EIGHT_BITS; R : FOUR_QUARTERS; Z : SMALL_NUMBER; LARGE_ATTEMPT : BOOLEAN; BEGIN F ← 0; W ← 0; LARGE_ATTEMPT ← FALSE; Z ← MEM[D].QQQQ.B0; X ← MEM[D].QQQQ.B1; WHILE TRUE DO BEGIN IF (Z ≠ 0) OR (X ≠ 0) THEN BEGIN Z ← Z + S + 16; REPEAT Z ← Z - 16; G ← EQTB[7835 + Z].HH.RH; IF G ≠ 0 THEN BEGIN Y ← X; IF (Y - 0 ≥ FONT_BC[G]) AND (Y - 0 ≤ FONT_EC[G]) THEN BEGIN 22: Q ← FONT_INFO[CHAR_BASE[G] + Y].QQQQ; IF Q.B0 > 0 THEN BEGIN IF (Q.B2 - 0) MOD 4 = 3 THEN BEGIN F ← G; C ← Y; GOTO 40 END; HD ← Q.B1 - 0; U ← FONT_INFO[HEIGHT_BASE[G] + HD DIV 16].INT + FONT_INFO[DEPTH_BASE[G] + HD MOD 16].INT; IF U > W THEN BEGIN F ← G; C ← Y; W ← U; IF U ≥ V THEN GOTO 40 END; IF (Q.B2 - 0) MOD 4 = 2 THEN BEGIN Y ← Q.B3; GOTO 22 END END END END UNTIL Z < 16 END; IF LARGE_ATTEMPT THEN GOTO 40; LARGE_ATTEMPT ← TRUE; Z ← MEM[D].QQQQ.B2; X ← MEM[D].QQQQ.B3 END; 40: IF F ≠ 0 THEN IF (Q.B2 - 0) MOD 4 = 3 THEN BEGIN B ← NEW_NULL_BOX; MEM[B].HH.B0 ← 1; R ← FONT_INFO[EXTEN_BASE[F] + Q.B3].QQQQ; C ← R.B3; U ← HEIGHT_PLUS_DEPTH (F, C); W ← 0; Q ← FONT_INFO[CHAR_BASE[F] + C].QQQQ; MEM[B + 1].INT ← FONT_INFO[WIDTH_BASE[F] + Q.B0].INT + FONT_INFO[ITALIC_BASE[F] + (Q.B2 - 0) DIV 4].INT; C ← R.B2; IF C ≠ 0 THEN W ← W + HEIGHT_PLUS_DEPTH (F, C); C ← R.B1; IF C ≠ 0 THEN W ← W + HEIGHT_PLUS_DEPTH (F, C); C ← R.B0; IF C ≠ 0 THEN W ← W + HEIGHT_PLUS_DEPTH (F, C); N ← 0; IF U > 0 THEN WHILE W < V DO BEGIN W ← W + U; N ← N + 1; IF R.B1 ≠ 0 THEN W ← W + U END; C ← R.B2; IF C ≠ 0 THEN STACK_INTO_BOX (B, F, C); C ← R.B3; FOR M ← 1 TO N DO STACK_INTO_BOX (B, F, C); C ← R.B1; IF C ≠ 0 THEN BEGIN STACK_INTO_BOX (B, F, C); C ← R.B3; FOR M ← 1 TO N DO STACK_INTO_BOX (B, F, C) END; C ← R.B0; IF C ≠ 0 THEN STACK_INTO_BOX (B, F, C); MEM[B + 2].INT ← W - MEM[B + 3].INT END ELSE B ← CHAR_BOX (F, C) ELSE BEGIN B ← NEW_NULL_BOX; MEM[B + 1].INT ← EQTB[9741].INT END; MEM[B + 4].INT ← HALF (MEM[B + 3].INT - MEM[B + 2].INT) - FONT_INFO[22 + PARAM_BASE[EQTB[7837 + S].HH.RH]].INT; VAR_DELIMITER ← B END; FUNCTION REBOX (B:HALFWORD; W:SCALED):HALFWORD; VAR P : HALFWORD; F : INTERNAL_FONT_NUMBER; V : SCALED; BEGIN IF (MEM[B + 1].INT ≠ W) AND (MEM[B + 5].HH.RH ≠ 0) THEN BEGIN IF MEM[B].HH.B0 = 1 THEN B ← HPACK (B, 0, 1); P ← MEM[B + 5].HH.RH; IF (P ≥ HI_MEM_MIN) AND (MEM[P].HH.RH = 0) THEN BEGIN F ← MEM[P].HH.B0; V ← FONT_INFO[WIDTH_BASE[F] + FONT_INFO[CHAR_BASE[F] + MEM[P].HH.B1].QQQQ.B0].INT; IF V ≠ MEM[B + 1].INT THEN MEM[P].HH.RH ← NEW_KERN (MEM[B + 1].INT - V) END; FREE_NODE (B, 7); B ← NEW_GLUE (12); MEM[B].HH.RH ← P; WHILE MEM[P].HH.RH ≠ 0 DO P ← MEM[P].HH.RH; MEM[P].HH.RH ← NEW_GLUE (12); REBOX ← HPACK (B, W, 0) END ELSE BEGIN MEM[B + 1].INT ← W; REBOX ← B END END; FUNCTION MATH_GLUE (G:HALFWORD; M:SCALED):HALFWORD; VAR P : HALFWORD; N : INTEGER; F : SCALED; BEGIN N ← X_OVER_N (M, 65536); F ← REMAINDER; IF F < 0 THEN BEGIN N ← N - 1; F ← F + 65536 END; P ← GET_NODE (4); MEM[P + 1].INT ← MULT_AND_ADD (N, MEM[G + 1].INT, XN_OVER_D (MEM[G + 1].INT, F, 65536), 1073741823); MEM[P].HH.B0 ← MEM[G].HH.B0; IF MEM[P].HH.B0 = 0 THEN MEM[P + 2].INT ← MULT_AND_ADD (N, MEM[G + 2].INT, XN_OVER_D (MEM[G + 2].INT, F, 65536), 1073741823) ELSE MEM[P + 2].INT ← MEM[G + 2].INT; MEM[P].HH.B1 ← MEM[G].HH.B1; IF MEM[P].HH.B1 = 0 THEN MEM[P + 3].INT ← MULT_AND_ADD (N, MEM[G + 3].INT, XN_OVER_D (MEM[G + 3].INT, F, 65536), 1073741823) ELSE MEM[P + 3].INT ← MEM[G + 3].INT; MATH_GLUE ← P END; PROCEDURE MATH_KERN (P:HALFWORD; M:SCALED); VAR N : INTEGER; F : SCALED; BEGIN IF MEM[P].HH.B1 = 99 THEN BEGIN N ← X_OVER_N (M, 65536); F ← REMAINDER; IF F < 0 THEN BEGIN N ← N - 1; F ← F + 65536 END; MEM[P + 1].INT ← MULT_AND_ADD (N, MEM[P + 1].INT, XN_OVER_D (MEM[P + 1].INT, F, 65536), 1073741823); MEM[P].HH.B1 ← 1 END END; PROCEDURE FLUSH_MATH; BEGIN FLUSH_NODE_LIST (MEM[CUR_LIST.HEAD_FIELD].HH.RH); FLUSH_NODE_LIST (CUR_LIST.AUX_FIELD.INT); MEM[CUR_LIST.HEAD_FIELD].HH.RH ← 0; CUR_LIST.TAIL_FIELD ← CUR_LIST.HEAD_FIELD; CUR_LIST.AUX_FIELD.INT ← 0 END; PROCEDURE MLIST_TO_HLIST; FORWARD; FUNCTION CLEAN_BOX (P:HALFWORD; S:SMALL_NUMBER):HALFWORD; LABEL 40; VAR Q : HALFWORD; SAVE_STYLE : SMALL_NUMBER; X : HALFWORD; R : HALFWORD; BEGIN CASE MEM[P].HH.RH OF 1: BEGIN CUR_MLIST ← NEW_NOAD; MEM[CUR_MLIST + 1] ← MEM[P] END; 2: BEGIN Q ← MEM[P].HH.LH; GOTO 40 END; 3: CUR_MLIST ← MEM[P].HH.LH; ELSE BEGIN Q ← NEW_NULL_BOX; GOTO 40 END; END; SAVE_STYLE ← CUR_STYLE; CUR_STYLE ← S; MLIST_PENALTIES ← FALSE; MLIST_TO_HLIST; Q ← MEM[59997].HH.RH; CUR_STYLE ← SAVE_STYLE; BEGIN IF CUR_STYLE < 4 THEN CUR_SIZE ← 0 ELSE CUR_SIZE ← 16 * ((CUR_STYLE - 2) DIV 2); CUR_MU ← X_OVER_N (FONT_INFO[6 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT, 18) END; 40: IF (Q ≥ HI_MEM_MIN) OR (Q = 0) THEN X ← HPACK (Q, 0, 1) ELSE IF (MEM[Q].HH.RH = 0) AND (MEM[Q].HH.B0 ≤ 1) AND (MEM[Q + 4].INT = 0) THEN X ← Q ELSE X ← HPACK (Q, 0, 1); Q ← MEM[X + 5].HH.RH; IF Q ≥ HI_MEM_MIN THEN BEGIN R ← MEM[Q].HH.RH; IF R ≠ 0 THEN IF MEM[R].HH.RH = 0 THEN IF NOT (R ≥ HI_MEM_MIN) THEN IF MEM[R].HH.B0 = 11 THEN BEGIN FREE_NODE (R, 2); MEM[Q].HH.RH ← 0 END END; CLEAN_BOX ← X END; PROCEDURE FETCH (A:HALFWORD); BEGIN CUR_C ← MEM[A].HH.B1; CUR_F ← EQTB[7835 + MEM[A].HH.B0 + CUR_SIZE].HH.RH; IF CUR_F = 0 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (338) END; PRINT_SIZE (CUR_SIZE); PRINT_CHAR (32); PRINT_INT (MEM[A].HH.B0); PRINT (884); PRINT (CUR_C - 0); PRINT_CHAR (41); BEGIN HELP_PTR ← 4; HELP_LINE[3] ← 885; HELP_LINE[2] ← 886; HELP_LINE[1] ← 887; HELP_LINE[0] ← 888 END; ERROR; CUR_I ← NULL_CHARACTER; MEM[A].HH.RH ← 0 END ELSE BEGIN IF (CUR_C - 0 ≥ FONT_BC[CUR_F]) AND (CUR_C - 0 ≤ FONT_EC[CUR_F]) THEN CUR_I ← FONT_INFO[CHAR_BASE[CUR_F] + CUR_C].QQQQ ELSE CUR_I ← NULL_CHARACTER; IF NOT (CUR_I.B0 > 0) THEN BEGIN CHAR_WARNING (CUR_F, CUR_C - 0); MEM[A].HH.RH ← 0; CUR_I ← NULL_CHARACTER END END END; PROCEDURE MAKE_OVER (Q:HALFWORD); BEGIN MEM[Q + 1].HH.LH ← OVERBAR (CLEAN_BOX (Q + 1, 2 * (CUR_STYLE DIV 2) + 1), 3 * FONT_INFO[8 + PARAM_BASE[EQTB[7838 + CUR_SIZE].HH.RH]].INT, FONT_INFO[8 + PARAM_BASE[EQTB[7838 + CUR_SIZE].HH.RH]].INT); MEM[Q + 1].HH.RH ← 2 END; PROCEDURE MAKE_UNDER (Q:HALFWORD); VAR P : HALFWORD; X : HALFWORD; Y : HALFWORD; DELTA : SCALED; BEGIN X ← CLEAN_BOX (Q + 1, CUR_STYLE); P ← NEW_KERN (3 * FONT_INFO[8 + PARAM_BASE[EQTB[7838 + CUR_SIZE].HH.RH]].INT); MEM[X].HH.RH ← P; MEM[P].HH.RH ← FRACTION_RULE (FONT_INFO[8 + PARAM_BASE[EQTB[7838 + CUR_SIZE].HH.RH]].INT); Y ← VPACKAGE (X, 0, 1, 1073741823); DELTA ← MEM[Y + 3].INT + MEM[Y + 2].INT + FONT_INFO[8 + PARAM_BASE[EQTB[7838 + CUR_SIZE].HH.RH]].INT; MEM[Y + 3].INT ← MEM[X + 3].INT; MEM[Y + 2].INT ← DELTA - MEM[Y + 3].INT; MEM[Q + 1].HH.LH ← Y; MEM[Q + 1].HH.RH ← 2 END; PROCEDURE MAKE_VCENTER (Q:HALFWORD); VAR V : HALFWORD; DELTA : SCALED; BEGIN V ← MEM[Q + 1].HH.LH; IF MEM[V].HH.B0 ≠ 1 THEN CONFUSION (539); DELTA ← MEM[V + 3].INT + MEM[V + 2].INT; MEM[V + 3].INT ← FONT_INFO[22 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT + HALF (DELTA); MEM[V + 2].INT ← DELTA - MEM[V + 3].INT END; PROCEDURE MAKE_RADICAL (Q:HALFWORD); VAR X : HALFWORD; Y : HALFWORD; DELTA : SCALED; CLR : SCALED; BEGIN X ← CLEAN_BOX (Q + 1, 2 * (CUR_STYLE DIV 2) + 1); IF CUR_STYLE < 2 THEN CLR ← FONT_INFO[8 + PARAM_BASE[EQTB[7838 + CUR_SIZE].HH.RH]].INT + ABS (FONT_INFO[5 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT) DIV 4 ELSE BEGIN CLR ← FONT_INFO[8 + PARAM_BASE[EQTB[7838 + CUR_SIZE].HH.RH]].INT; CLR ← CLR + ABS (CLR) DIV 4 END; Y ← VAR_DELIMITER (Q + 4, CUR_SIZE, MEM[X + 3].INT + MEM[X + 2].INT + CLR + FONT_INFO[8 + PARAM_BASE[EQTB[7838 + CUR_SIZE].HH.RH]].INT); DELTA ← MEM[Y + 2].INT - (MEM[X + 3].INT + MEM[X + 2].INT + CLR); IF DELTA > 0 THEN CLR ← CLR + HALF (DELTA); MEM[Y + 4].INT ← -(MEM[X + 3].INT + CLR); MEM[Y].HH.RH ← OVERBAR (X, CLR, MEM[Y + 3].INT); MEM[Q + 1].HH.LH ← HPACK (Y, 0, 1); MEM[Q + 1].HH.RH ← 2 END; PROCEDURE MAKE_MATH_ACCENT (Q:HALFWORD); LABEL 30, 31; VAR P : HALFWORD; X : HALFWORD; Y : HALFWORD; A : INTEGER; C : QUARTERWORD; F : INTERNAL_FONT_NUMBER; I : FOUR_QUARTERS; S : SCALED; H : SCALED; DELTA : SCALED; W : SCALED; BEGIN FETCH (Q + 4); IF CUR_I.B0 > 0 THEN BEGIN I ← CUR_I; C ← CUR_C; F ← CUR_F; S ← 0; IF MEM[Q + 1].HH.RH = 1 THEN BEGIN FETCH (Q + 1); IF (CUR_I.B2 - 0) MOD 4 = 1 THEN BEGIN A ← LIG_KERN_BASE[CUR_F] + CUR_I.B3; CUR_I ← FONT_INFO[A].QQQQ; IF CUR_I.B0 > 128 THEN BEGIN A ← LIG_KERN_BASE[CUR_F] + 256 * CUR_I.B2 + CUR_I.B3 + 32768 - 256 * 128; CUR_I ← FONT_INFO[A].QQQQ END; WHILE TRUE DO BEGIN IF CUR_I.B1 - 0 = SKEW_CHAR[CUR_F] THEN BEGIN IF CUR_I.B2 ≥ 128 THEN IF CUR_I.B0 ≤ 128 THEN S ← FONT_INFO[KERN_BASE[CUR_F] + 256 * CUR_I.B2 + CUR_I.B3].INT; GOTO 31 END; IF CUR_I.B0 ≥ 128 THEN GOTO 31; A ← A + CUR_I.B0 + 1; CUR_I ← FONT_INFO[A].QQQQ END END END; 31: ; X ← CLEAN_BOX (Q + 1, 2 * (CUR_STYLE DIV 2) + 1); W ← MEM[X + 1].INT; H ← MEM[X + 3].INT; WHILE TRUE DO BEGIN IF (I.B2 - 0) MOD 4 ≠ 2 THEN GOTO 30; Y ← I.B3; I ← FONT_INFO[CHAR_BASE[F] + Y].QQQQ; IF NOT (I.B0 > 0) THEN GOTO 30; IF FONT_INFO[WIDTH_BASE[F] + I.B0].INT > W THEN GOTO 30; C ← Y END; 30: ; IF H < FONT_INFO[5 + PARAM_BASE[F]].INT THEN DELTA ← H ELSE DELTA ← FONT_INFO[5 + PARAM_BASE[F]].INT; IF (MEM[Q + 2].HH.RH ≠ 0) OR (MEM[Q + 3].HH.RH ≠ 0) THEN IF MEM[Q + 1].HH.RH = 1 THEN BEGIN FLUSH_NODE_LIST (X); X ← NEW_NOAD; MEM[X + 1] ← MEM[Q + 1]; MEM[X + 2] ← MEM[Q + 2]; MEM[X + 3] ← MEM[Q + 3]; MEM[Q + 2].HH ← EMPTY_FIELD; MEM[Q + 3].HH ← EMPTY_FIELD; MEM[Q + 1].HH.RH ← 3; MEM[Q + 1].HH.LH ← X; X ← CLEAN_BOX (Q + 1, CUR_STYLE); DELTA ← DELTA + MEM[X + 3].INT - H; H ← MEM[X + 3].INT END; Y ← CHAR_BOX (F, C); MEM[Y + 4].INT ← S + HALF ((W - MEM[Y + 1].INT)); MEM[Y + 1].INT ← 0; P ← NEW_KERN (-DELTA); MEM[P].HH.RH ← X; MEM[Y].HH.RH ← P; Y ← VPACKAGE (Y, 0, 1, 1073741823); MEM[Y + 1].INT ← MEM[X + 1].INT; IF MEM[Y + 3].INT < H THEN BEGIN P ← NEW_KERN (H - MEM[Y + 3].INT); MEM[P].HH.RH ← MEM[Y + 5].HH.RH; MEM[Y + 5].HH.RH ← P; MEM[Y + 3].INT ← H END; MEM[Q + 1].HH.LH ← Y; MEM[Q + 1].HH.RH ← 2 END END; PROCEDURE MAKE_FRACTION (Q:HALFWORD); VAR P : HALFWORD; V : HALFWORD; X : HALFWORD; Y : HALFWORD; Z : HALFWORD; DELTA : SCALED; DELTA1 : SCALED; DELTA2 : SCALED; SHIFT_UP : SCALED; SHIFT_DOWN : SCALED; CLR : SCALED; BEGIN IF MEM[Q + 1].INT = 1073741824 THEN MEM[Q + 1].INT ← FONT_INFO[8 + PARAM_BASE[EQTB[7838 + CUR_SIZE].HH.RH]].INT; X ← CLEAN_BOX (Q + 2, CUR_STYLE + 2 - 2 * (CUR_STYLE DIV 6)); Z ← CLEAN_BOX (Q + 3, 2 * (CUR_STYLE DIV 2) + 3 - 2 * (CUR_STYLE DIV 6)); IF MEM[X + 1].INT < MEM[Z + 1].INT THEN X ← REBOX (X, MEM[Z + 1].INT) ELSE Z ← REBOX (Z, MEM[X + 1].INT); IF CUR_STYLE < 2 THEN BEGIN SHIFT_UP ← FONT_INFO[8 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT; SHIFT_DOWN ← FONT_INFO[11 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT END ELSE BEGIN SHIFT_DOWN ← FONT_INFO[12 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT; IF MEM[Q + 1].INT ≠ 0 THEN SHIFT_UP ← FONT_INFO[9 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT ELSE SHIFT_UP ← FONT_INFO[10 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT END; IF MEM[Q + 1].INT = 0 THEN BEGIN IF CUR_STYLE < 2 THEN CLR ← 7 * FONT_INFO[8 + PARAM_BASE[EQTB[7838 + CUR_SIZE].HH.RH]].INT ELSE CLR ← 3 * FONT_INFO[8 + PARAM_BASE[EQTB[7838 + CUR_SIZE].HH.RH]].INT; DELTA ← HALF (CLR - (SHIFT_UP - MEM[X + 2].INT - (MEM[Z + 3].INT - SHIFT_DOWN))); IF DELTA > 0 THEN BEGIN SHIFT_UP ← SHIFT_UP + DELTA; SHIFT_DOWN ← SHIFT_DOWN + DELTA END END ELSE BEGIN IF CUR_STYLE < 2 THEN CLR ← 3 * MEM[Q + 1].INT ELSE CLR ← MEM[Q + 1].INT; DELTA ← HALF (MEM[Q + 1].INT); DELTA1 ← CLR - (SHIFT_UP - MEM[X + 2].INT - (FONT_INFO[22 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT + DELTA)); DELTA2 ← CLR - (FONT_INFO[22 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT - DELTA - (MEM[Z + 3].INT - SHIFT_DOWN)); IF DELTA1 > 0 THEN SHIFT_UP ← SHIFT_UP + DELTA1; IF DELTA2 > 0 THEN SHIFT_DOWN ← SHIFT_DOWN + DELTA2 END; V ← NEW_NULL_BOX; MEM[V].HH.B0 ← 1; MEM[V + 3].INT ← SHIFT_UP + MEM[X + 3].INT; MEM[V + 2].INT ← MEM[Z + 2].INT + SHIFT_DOWN; MEM[V + 1].INT ← MEM[X + 1].INT; IF MEM[Q + 1].INT = 0 THEN BEGIN P ← NEW_KERN (SHIFT_UP - MEM[X + 2].INT - (MEM[Z + 3].INT - SHIFT_DOWN)); MEM[P].HH.RH ← Z END ELSE BEGIN Y ← FRACTION_RULE (MEM[Q + 1].INT); P ← NEW_KERN (FONT_INFO[22 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT - DELTA - (MEM[Z + 3].INT - SHIFT_DOWN)); MEM[Y].HH.RH ← P; MEM[P].HH.RH ← Z; P ← NEW_KERN (SHIFT_UP - MEM[X + 2].INT - (FONT_INFO[22 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT + DELTA)); MEM[P].HH.RH ← Y END; MEM[X].HH.RH ← P; MEM[V + 5].HH.RH ← X; IF CUR_STYLE < 2 THEN DELTA ← FONT_INFO[20 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT ELSE DELTA ← FONT_INFO[21 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT; X ← VAR_DELIMITER (Q + 4, CUR_SIZE, DELTA); MEM[X].HH.RH ← V; Z ← VAR_DELIMITER (Q + 5, CUR_SIZE, DELTA); MEM[V].HH.RH ← Z; MEM[Q + 1].INT ← HPACK (X, 0, 1) END; FUNCTION MAKE_OP (Q:HALFWORD):SCALED; VAR DELTA : SCALED; P : HALFWORD; V : HALFWORD; X : HALFWORD; Y : HALFWORD; Z : HALFWORD; C : QUARTERWORD; I : FOUR_QUARTERS; SHIFT_UP : SCALED; SHIFT_DOWN : SCALED; BEGIN IF (MEM[Q].HH.B1 = 0) AND (CUR_STYLE < 2) THEN MEM[Q].HH.B1 ← 1; IF MEM[Q + 1].HH.RH = 1 THEN BEGIN FETCH (Q + 1); IF (CUR_STYLE < 2) AND ((CUR_I.B2 - 0) MOD 4 = 2) THEN BEGIN C ← CUR_I.B3; I ← FONT_INFO[CHAR_BASE[CUR_F] + C].QQQQ; IF I.B0 > 0 THEN BEGIN CUR_C ← C; CUR_I ← I; MEM[Q + 1].HH.B1 ← C END END; DELTA ← FONT_INFO[ITALIC_BASE[CUR_F] + (CUR_I.B2 - 0) DIV 4].INT; X ← CLEAN_BOX (Q + 1, CUR_STYLE); IF (MEM[Q + 3].HH.RH ≠ 0) AND (MEM[Q].HH.B1 ≠ 1) THEN MEM[X + 1].INT ← MEM[X + 1].INT - DELTA; MEM[X + 4].INT ← HALF (MEM[X + 3].INT - MEM[X + 2].INT) - FONT_INFO[22 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT; MEM[Q + 1].HH.RH ← 2; MEM[Q + 1].HH.LH ← X END ELSE DELTA ← 0; IF MEM[Q].HH.B1 = 1 THEN BEGIN X ← CLEAN_BOX (Q + 2, 2 * (CUR_STYLE DIV 4) + 4 + CUR_STYLE MOD 2); Y ← CLEAN_BOX (Q + 1, CUR_STYLE); Z ← CLEAN_BOX (Q + 3, 2 * (CUR_STYLE DIV 4) + 5); V ← NEW_NULL_BOX; MEM[V].HH.B0 ← 1; MEM[V + 1].INT ← MEM[Y + 1].INT; IF MEM[X + 1].INT > MEM[V + 1].INT THEN MEM[V + 1].INT ← MEM[X + 1].INT; IF MEM[Z + 1].INT > MEM[V + 1].INT THEN MEM[V + 1].INT ← MEM[Z + 1].INT; X ← REBOX (X, MEM[V + 1].INT); Y ← REBOX (Y, MEM[V + 1].INT); Z ← REBOX (Z, MEM[V + 1].INT); MEM[X + 4].INT ← HALF (DELTA); MEM[Z + 4].INT ← -MEM[X + 4].INT; MEM[V + 3].INT ← MEM[Y + 3].INT; MEM[V + 2].INT ← MEM[Y + 2].INT; IF MEM[Q + 2].HH.RH = 0 THEN BEGIN FREE_NODE (X, 7); MEM[V + 5].HH.RH ← Y END ELSE BEGIN SHIFT_UP ← FONT_INFO[11 + PARAM_BASE[EQTB[7838 + CUR_SIZE].HH.RH]].INT - MEM[X + 2].INT; IF SHIFT_UP < FONT_INFO[9 + PARAM_BASE[EQTB[7838 + CUR_SIZE].HH.RH]].INT THEN SHIFT_UP ← FONT_INFO[9 + PARAM_BASE[EQTB[7838 + CUR_SIZE].HH.RH]].INT; P ← NEW_KERN (SHIFT_UP); MEM[P].HH.RH ← Y; MEM[X].HH.RH ← P; P ← NEW_KERN (FONT_INFO[13 + PARAM_BASE[EQTB[7838 + CUR_SIZE].HH.RH]].INT); MEM[P].HH.RH ← X; MEM[V + 5].HH.RH ← P; MEM[V + 3].INT ← MEM[V + 3].INT + FONT_INFO[13 + PARAM_BASE[EQTB[7838 + CUR_SIZE].HH.RH]].INT + MEM[X + 3].INT + MEM[X + 2].INT + SHIFT_UP END; IF MEM[Q + 3].HH.RH = 0 THEN FREE_NODE (Z, 7) ELSE BEGIN SHIFT_DOWN ← FONT_INFO[12 + PARAM_BASE[EQTB[7838 + CUR_SIZE].HH.RH]].INT - MEM[Z + 3].INT; IF SHIFT_DOWN < FONT_INFO[10 + PARAM_BASE[EQTB[7838 + CUR_SIZE].HH.RH]].INT THEN SHIFT_DOWN ← FONT_INFO[10 + PARAM_BASE[EQTB[7838 + CUR_SIZE].HH.RH]].INT; P ← NEW_KERN (SHIFT_DOWN); MEM[Y].HH.RH ← P; MEM[P].HH.RH ← Z; P ← NEW_KERN (FONT_INFO[13 + PARAM_BASE[EQTB[7838 + CUR_SIZE].HH.RH]].INT); MEM[Z].HH.RH ← P; MEM[V + 2].INT ← MEM[V + 2].INT + FONT_INFO[13 + PARAM_BASE[EQTB[7838 + CUR_SIZE].HH.RH]].INT + MEM[Z + 3].INT + MEM[Z + 2].INT + SHIFT_DOWN END; MEM[Q + 1].INT ← V END; MAKE_OP ← DELTA END; PROCEDURE MAKE_ORD (Q:HALFWORD); LABEL 20, 10; VAR A : INTEGER; P : HALFWORD; R : HALFWORD; BEGIN 20: IF MEM[Q + 3].HH.RH = 0 THEN IF MEM[Q + 2].HH.RH = 0 THEN IF MEM[Q + 1].HH.RH = 1 THEN BEGIN P ← MEM[Q].HH.RH; IF P ≠ 0 THEN IF (MEM[P].HH.B0 ≥ 16) AND (MEM[P].HH.B0 ≤ 22) THEN IF MEM[P + 1].HH.RH = 1 THEN IF MEM[P + 1].HH.B0 = MEM[Q + 1].HH.B0 THEN BEGIN MEM[Q + 1].HH.RH ← 4; FETCH (Q + 1); IF (CUR_I.B2 - 0) MOD 4 = 1 THEN BEGIN A ← LIG_KERN_BASE[CUR_F] + CUR_I.B3; CUR_C ← MEM[P + 1].HH.B1; CUR_I ← FONT_INFO[A].QQQQ; IF CUR_I.B0 > 128 THEN BEGIN A ← LIG_KERN_BASE[CUR_F] + 256 * CUR_I.B2 + CUR_I.B3 + 32768 - 256 * 128; CUR_I ← FONT_INFO[A].QQQQ END; WHILE TRUE DO BEGIN IF CUR_I.B1 = CUR_C THEN IF CUR_I.B0 ≤ 128 THEN IF CUR_I.B2 ≥ 128 THEN BEGIN P ← NEW_KERN (FONT_INFO[ KERN_BASE[CUR_F] + 256 * CUR_I.B2 + CUR_I.B3]. INT); MEM[P].HH.RH ← MEM[Q].HH.RH; MEM[Q].HH.RH ← P; GOTO 10 END ELSE BEGIN BEGIN IF INTERRUPT ≠ 0 THEN PAUSE_FOR_INSTRUCTIONS END; CASE CUR_I.B2 OF 1,5: MEM[Q + 1].HH.B1 ← CUR_I.B3; 2,6: MEM[P + 1].HH.B1 ← CUR_I.B3; 3,7, 11: BEGIN R ← NEW_NOAD; MEM[R + 1].HH.B1 ← CUR_I.B3; MEM[R + 1].HH.B0 ← MEM[Q + 1].HH.B0; MEM[Q].HH.RH ← R; MEM[R].HH.RH ← P; IF CUR_I.B2 < 11 THEN MEM[R + 1].HH.RH ← 1 ELSE MEM[R + 1].HH.RH ← 4 END; ELSE BEGIN MEM[Q].HH.RH ← MEM[P].HH.RH; MEM[Q + 1].HH.B1 ← CUR_I.B3; MEM[Q + 3] ← MEM[P + 3]; MEM[Q + 2] ← MEM[P + 2]; FREE_NODE (P, 4) END; END; IF CUR_I.B2 > 3 THEN GOTO 10; MEM[Q + 1].HH.RH ← 1; GOTO 20 END; IF CUR_I.B0 ≥ 128 THEN GOTO 10; A ← A + CUR_I.B0 + 1; CUR_I ← FONT_INFO[A].QQQQ END END END END; 10: END; PROCEDURE MAKE_SCRIPTS (Q:HALFWORD; DELTA:SCALED); VAR P : HALFWORD; X : HALFWORD; Y : HALFWORD; Z : HALFWORD; SHIFT_UP : SCALED; SHIFT_DOWN : SCALED; CLR : SCALED; T : SMALL_NUMBER; BEGIN P ← MEM[Q + 1].INT; IF P ≥ HI_MEM_MIN THEN BEGIN SHIFT_UP ← 0; SHIFT_DOWN ← 0 END ELSE BEGIN Z ← HPACK (P, 0, 1); IF CUR_STYLE < 4 THEN T ← 16 ELSE T ← 32; SHIFT_UP ← MEM[Z + 3].INT - FONT_INFO[18 + PARAM_BASE[EQTB[7837 + T].HH.RH]].INT; SHIFT_DOWN ← MEM[Z + 2].INT + FONT_INFO[19 + PARAM_BASE[EQTB[7837 + T].HH.RH]].INT; FREE_NODE (Z, 7) END; IF MEM[Q + 2].HH.RH = 0 THEN BEGIN X ← CLEAN_BOX (Q + 3, 2 * (CUR_STYLE DIV 4) + 5); MEM[X + 1].INT ← MEM[X + 1].INT + EQTB[9742].INT; IF SHIFT_DOWN < FONT_INFO[16 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT THEN SHIFT_DOWN ← FONT_INFO[16 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT; CLR ← MEM[X + 3].INT - ABS (FONT_INFO[5 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT * 4) DIV 5; IF SHIFT_DOWN < CLR THEN SHIFT_DOWN ← CLR; MEM[X + 4].INT ← SHIFT_DOWN END ELSE BEGIN BEGIN X ← CLEAN_BOX (Q + 2, 2 * (CUR_STYLE DIV 4) + 4 + CUR_STYLE MOD 2); MEM[X + 1].INT ← MEM[X + 1].INT + EQTB[9742].INT; IF ODD (CUR_STYLE) THEN CLR ← FONT_INFO[15 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT ELSE IF CUR_STYLE < 2 THEN CLR ← FONT_INFO[13 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT ELSE CLR ← FONT_INFO[14 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT; IF SHIFT_UP < CLR THEN SHIFT_UP ← CLR; CLR ← MEM[X + 2].INT + ABS (FONT_INFO[5 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT) DIV 4; IF SHIFT_UP < CLR THEN SHIFT_UP ← CLR END; IF MEM[Q + 3].HH.RH = 0 THEN MEM[X + 4].INT ← -SHIFT_UP ELSE BEGIN Y ← CLEAN_BOX (Q + 3, 2 * (CUR_STYLE DIV 4) + 5); MEM[Y + 1].INT ← MEM[Y + 1].INT + EQTB[9742].INT; IF SHIFT_DOWN < FONT_INFO[17 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT THEN SHIFT_DOWN ← FONT_INFO[17 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT; CLR ← 4 * FONT_INFO[8 + PARAM_BASE[EQTB[7838 + CUR_SIZE].HH.RH]].INT - (SHIFT_UP - MEM[X + 2].INT - (MEM[Y + 3].INT - SHIFT_DOWN)); IF CLR > 0 THEN BEGIN SHIFT_DOWN ← SHIFT_DOWN + CLR; CLR ← ABS (FONT_INFO[5 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT * 4) DIV 5 - (SHIFT_UP - MEM[X + 2].INT); IF CLR > 0 THEN BEGIN SHIFT_UP ← SHIFT_UP + CLR; SHIFT_DOWN ← SHIFT_DOWN - CLR END END; MEM[X + 4].INT ← DELTA; P ← NEW_KERN (SHIFT_UP - MEM[X + 2].INT - (MEM[Y + 3].INT - SHIFT_DOWN)); MEM[X].HH.RH ← P; MEM[P].HH.RH ← Y; X ← VPACKAGE (X, 0, 1, 1073741823); MEM[X + 4].INT ← SHIFT_DOWN END END; IF MEM[Q + 1].INT = 0 THEN MEM[Q + 1].INT ← X ELSE BEGIN P ← MEM[Q + 1].INT; WHILE MEM[P].HH.RH ≠ 0 DO P ← MEM[P].HH.RH; MEM[P].HH.RH ← X END END; FUNCTION MAKE_LEFT_RIGHT (Q:HALFWORD; STYLE:SMALL_NUMBER; MAX_D:SCALED; MAX_H:SCALED):SMALL_NUMBER; VAR DELTA : SCALED; DELTA1 : SCALED; DELTA2 : SCALED; BEGIN IF STYLE < 4 THEN CUR_SIZE ← 0 ELSE CUR_SIZE ← 16 * ((STYLE - 2) DIV 2); DELTA2 ← MAX_D + FONT_INFO[22 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT; DELTA1 ← MAX_H + MAX_D - DELTA2; IF DELTA2 > DELTA1 THEN DELTA1 ← DELTA2; DELTA ← DELTA1 DIV 500 * EQTB[9181].INT; DELTA2 ← DELTA1 + DELTA1 - EQTB[9740].INT; IF DELTA < DELTA2 THEN DELTA ← DELTA2; MEM[Q + 1].INT ← VAR_DELIMITER (Q + 1, CUR_SIZE, DELTA); MAKE_LEFT_RIGHT ← MEM[Q].HH.B0 - 10 END; PROCEDURE MLIST_TO_HLIST; LABEL 21, 82, 80, 81, 83, 30; VAR MLIST : HALFWORD; PENALTIES : BOOLEAN; STYLE : SMALL_NUMBER; SAVE_STYLE : SMALL_NUMBER; Q : HALFWORD; R : HALFWORD; R_TYPE : SMALL_NUMBER; T : SMALL_NUMBER; P : HALFWORD; X : HALFWORD; Y : HALFWORD; Z : HALFWORD; PEN : INTEGER; S : SMALL_NUMBER; MAX_H : SCALED; MAX_D : SCALED; DELTA : SCALED; BEGIN MLIST ← CUR_MLIST; PENALTIES ← MLIST_PENALTIES; STYLE ← CUR_STYLE; Q ← MLIST; R ← 0; R_TYPE ← 17; MAX_H ← 0; MAX_D ← 0; BEGIN IF CUR_STYLE < 4 THEN CUR_SIZE ← 0 ELSE CUR_SIZE ← 16 * ((CUR_STYLE - 2) DIV 2); CUR_MU ← X_OVER_N (FONT_INFO[6 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT, 18) END; WHILE Q ≠ 0 DO BEGIN 21: DELTA ← 0; CASE MEM[Q].HH.B0 OF 18: CASE R_TYPE OF 18,17,19,20,22, 30: BEGIN MEM[Q].HH.B0 ← 16; GOTO 21 END; ELSE ; END; 19,21,22, 31: BEGIN IF R_TYPE = 18 THEN MEM[R].HH.B0 ← 16; IF MEM[Q].HH.B0 = 31 THEN GOTO 80 END; 30: GOTO 80; 25: BEGIN MAKE_FRACTION (Q); GOTO 82 END; 17: BEGIN DELTA ← MAKE_OP (Q); IF MEM[Q].HH.B1 = 1 THEN GOTO 82 END; 16: MAKE_ORD (Q); 20,23: ; 24: MAKE_RADICAL (Q); 27: MAKE_OVER (Q); 26: MAKE_UNDER (Q); 28: MAKE_MATH_ACCENT (Q); 29: MAKE_VCENTER (Q); 14: BEGIN CUR_STYLE ← MEM[Q].HH.B1; BEGIN IF CUR_STYLE < 4 THEN CUR_SIZE ← 0 ELSE CUR_SIZE ← 16 * ((CUR_STYLE - 2) DIV 2); CUR_MU ← X_OVER_N (FONT_INFO[6 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT, 18) END; GOTO 81 END; 15: BEGIN CASE CUR_STYLE DIV 2 OF 0: BEGIN P ← MEM[Q + 1].HH.LH; MEM[Q + 1].HH.LH ← 0 END; 1: BEGIN P ← MEM[Q + 1].HH.RH; MEM[Q + 1].HH.RH ← 0 END; 2: BEGIN P ← MEM[Q + 2].HH.LH; MEM[Q + 2].HH.LH ← 0 END; 3: BEGIN P ← MEM[Q + 2].HH.RH; MEM[Q + 2].HH.RH ← 0 END; END; FLUSH_NODE_LIST (MEM[Q + 1].HH.LH); FLUSH_NODE_LIST (MEM[Q + 1].HH.RH); FLUSH_NODE_LIST (MEM[Q + 2].HH.LH); FLUSH_NODE_LIST (MEM[Q + 2].HH.RH); MEM[Q].HH.B0 ← 14; MEM[Q].HH.B1 ← CUR_STYLE; MEM[Q + 1].INT ← 0; MEM[Q + 2].INT ← 0; IF P ≠ 0 THEN BEGIN Z ← MEM[Q].HH.RH; MEM[Q].HH.RH ← P; WHILE MEM[P].HH.RH ≠ 0 DO P ← MEM[P].HH.RH; MEM[P].HH.RH ← Z END; GOTO 81 END; 3,4,5,8,12,7: GOTO 81; 2: BEGIN IF MEM[Q + 3].INT > MAX_H THEN MAX_H ← MEM[Q + 3].INT; IF MEM[Q + 2].INT > MAX_D THEN MAX_D ← MEM[Q + 2].INT; GOTO 81 END; 10: BEGIN IF MEM[Q].HH.B1 = 99 THEN BEGIN X ← MEM[Q + 1].HH.LH; Y ← MATH_GLUE (X, CUR_MU); DELETE_GLUE_REF (X); MEM[Q + 1].HH.LH ← Y; MEM[Q].HH.B1 ← 0 END ELSE IF (CUR_SIZE ≠ 0) AND (MEM[Q].HH.B1 = 98) THEN BEGIN P ← MEM[Q].HH.RH; IF P ≠ 0 THEN IF (MEM[P].HH.B0 = 10) OR (MEM[P].HH.B0 = 11) THEN BEGIN MEM[Q].HH.RH ← MEM[P].HH.RH; MEM[P].HH.RH ← 0; FLUSH_NODE_LIST (P) END END; GOTO 81 END; 11: BEGIN MATH_KERN (Q, CUR_MU); GOTO 81 END; ELSE CONFUSION (889); END; CASE MEM[Q + 1].HH.RH OF 1, 4: BEGIN FETCH (Q + 1); IF CUR_I.B0 > 0 THEN BEGIN DELTA ← FONT_INFO[ITALIC_BASE[CUR_F] + (CUR_I.B2 - 0) DIV 4].INT; P ← NEW_CHARACTER (CUR_F, CUR_C - 0); IF (MEM[Q + 1].HH.RH = 4) AND (FONT_INFO[2 + PARAM_BASE[CUR_F]].INT ≠ 0) THEN DELTA ← 0; IF (MEM[Q + 3].HH.RH = 0) AND (DELTA ≠ 0) THEN BEGIN MEM[P].HH.RH ← NEW_KERN (DELTA); DELTA ← 0 END END ELSE P ← 0 END; 0: P ← 0; 2: P ← MEM[Q + 1].HH.LH; 3: BEGIN CUR_MLIST ← MEM[Q + 1].HH.LH; SAVE_STYLE ← CUR_STYLE; MLIST_PENALTIES ← FALSE; MLIST_TO_HLIST; CUR_STYLE ← SAVE_STYLE; BEGIN IF CUR_STYLE < 4 THEN CUR_SIZE ← 0 ELSE CUR_SIZE ← 16 * ((CUR_STYLE - 2) DIV 2); CUR_MU ← X_OVER_N (FONT_INFO[6 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT, 18) END; P ← HPACK (MEM[59997].HH.RH, 0, 1) END; ELSE CONFUSION (890); END; MEM[Q + 1].INT ← P; IF (MEM[Q + 3].HH.RH = 0) AND (MEM[Q + 2].HH.RH = 0) THEN GOTO 82; MAKE_SCRIPTS (Q, DELTA); 82: Z ← HPACK (MEM[Q + 1].INT, 0, 1); IF MEM[Z + 3].INT > MAX_H THEN MAX_H ← MEM[Z + 3].INT; IF MEM[Z + 2].INT > MAX_D THEN MAX_D ← MEM[Z + 2].INT; FREE_NODE (Z, 7); 80: R ← Q; R_TYPE ← MEM[R].HH.B0; 81: Q ← MEM[Q].HH.RH END; IF R_TYPE = 18 THEN MEM[R].HH.B0 ← 16; P ← 59997; MEM[P].HH.RH ← 0; Q ← MLIST; R_TYPE ← 0; CUR_STYLE ← STYLE; BEGIN IF CUR_STYLE < 4 THEN CUR_SIZE ← 0 ELSE CUR_SIZE ← 16 * ((CUR_STYLE - 2) DIV 2); CUR_MU ← X_OVER_N (FONT_INFO[6 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT, 18) END; WHILE Q ≠ 0 DO BEGIN T ← 16; S ← 4; PEN ← 10000; CASE MEM[Q].HH.B0 OF 17,20,21,22,23: T ← MEM[Q].HH.B0; 18: BEGIN T ← 18; PEN ← EQTB[9172].INT END; 19: BEGIN T ← 19; PEN ← EQTB[9173].INT END; 16,29,27,26: ; 24: S ← 5; 28: S ← 5; 25: S ← 6; 30,31: T ← MAKE_LEFT_RIGHT (Q, STYLE, MAX_D, MAX_H); 14: BEGIN CUR_STYLE ← MEM[Q].HH.B1; S ← 3; BEGIN IF CUR_STYLE < 4 THEN CUR_SIZE ← 0 ELSE CUR_SIZE ← 16 * ((CUR_STYLE - 2) DIV 2); CUR_MU ← X_OVER_N (FONT_INFO[6 + PARAM_BASE[EQTB[7837 + CUR_SIZE].HH.RH]].INT, 18) END; GOTO 83 END; 8,12,2,7,5,3,4,10, 11: BEGIN MEM[P].HH.RH ← Q; P ← Q; Q ← MEM[Q].HH.RH; MEM[P].HH.RH ← 0; GOTO 30 END; ELSE CONFUSION (891); END; IF R_TYPE > 0 THEN BEGIN CASE STR_POOL[R_TYPE * 8 + T + MAGIC_OFFSET] OF 48: X ← 0; 49: IF CUR_STYLE < 4 THEN X ← 15 ELSE X ← 0; 50: X ← 15; 51: IF CUR_STYLE < 4 THEN X ← 16 ELSE X ← 0; 52: IF CUR_STYLE < 4 THEN X ← 17 ELSE X ← 0; ELSE CONFUSION (893); END; IF X ≠ 0 THEN BEGIN Y ← MATH_GLUE (EQTB[6782 + X].HH.RH, CUR_MU); Z ← NEW_GLUE (Y); MEM[Y].HH.RH ← 0; MEM[P].HH.RH ← Z; P ← Z; MEM[Z].HH.B1 ← X + 1 END END; IF MEM[Q + 1].INT ≠ 0 THEN BEGIN MEM[P].HH.RH ← MEM[Q + 1].INT; REPEAT P ← MEM[P].HH.RH UNTIL MEM[P].HH.RH = 0 END; IF PENALTIES THEN IF MEM[Q].HH.RH ≠ 0 THEN IF PEN < 10000 THEN BEGIN R_TYPE ← MEM[MEM[Q].HH.RH].HH.B0; IF R_TYPE ≠ 12 THEN IF R_TYPE ≠ 19 THEN BEGIN Z ← NEW_PENALTY (PEN); MEM[P].HH.RH ← Z; P ← Z END END; R_TYPE ← T; 83: R ← Q; Q ← MEM[Q].HH.RH; FREE_NODE (R, S); 30: END END; PROCEDURE PUSH_ALIGNMENT; VAR P : HALFWORD; BEGIN P ← GET_NODE (5); MEM[P].HH.RH ← ALIGN_PTR; MEM[P].HH.LH ← CUR_ALIGN; MEM[P + 1].HH.LH ← MEM[59992].HH.RH; MEM[P + 1].HH.RH ← CUR_SPAN; MEM[P + 2].INT ← CUR_LOOP; MEM[P + 3].INT ← ALIGN_STATE; MEM[P + 4].HH.LH ← CUR_HEAD; MEM[P + 4].HH.RH ← CUR_TAIL; ALIGN_PTR ← P; CUR_HEAD ← GET_AVAIL END; PROCEDURE POP_ALIGNMENT; VAR P : HALFWORD; BEGIN BEGIN MEM[CUR_HEAD].HH.RH ← AVAIL; AVAIL ← CUR_HEAD END; P ← ALIGN_PTR; CUR_TAIL ← MEM[P + 4].HH.RH; CUR_HEAD ← MEM[P + 4].HH.LH; ALIGN_STATE ← MEM[P + 3].INT; CUR_LOOP ← MEM[P + 2].INT; CUR_SPAN ← MEM[P + 1].HH.RH; MEM[59992].HH.RH ← MEM[P + 1].HH.LH; CUR_ALIGN ← MEM[P].HH.LH; ALIGN_PTR ← MEM[P].HH.RH; FREE_NODE (P, 5) END; PROCEDURE GET_PREAMBLE_TOKEN; LABEL 20; BEGIN 20: GET_TOKEN; WHILE (CUR_CHR = 256) AND (CUR_CMD = 4) DO BEGIN GET_TOKEN; IF CUR_CMD > 100 THEN BEGIN EXPAND; GET_TOKEN END END; IF CUR_CMD = 9 THEN FATAL_ERROR (595); IF (CUR_CMD = 75) AND (CUR_CHR = 6793) THEN BEGIN SCAN_OPTIONAL_EQUALS; SCAN_GLUE (2); IF EQTB[9206].INT > 0 THEN GEQ_DEFINE (6793, 117, CUR_VAL) ELSE EQ_DEFINE (6793, 117, CUR_VAL); GOTO 20 END END; PROCEDURE ALIGN_PEEK; FORWARD; PROCEDURE NORMAL_PARAGRAPH; FORWARD; PROCEDURE INIT_ALIGN; LABEL 30, 31, 32, 22; VAR SAVE_CS_PTR : HALFWORD; P : HALFWORD; BEGIN SAVE_CS_PTR ← CUR_CS; PUSH_ALIGNMENT; ALIGN_STATE ← -1000000; IF (CUR_LIST.MODE_FIELD = 203) AND ((CUR_LIST.TAIL_FIELD ≠ CUR_LIST.HEAD_FIELD) OR (CUR_LIST.AUX_FIELD.INT ≠ 0)) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (680) END; PRINT_ESC (520); PRINT (894); BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 895; HELP_LINE[1] ← 896; HELP_LINE[0] ← 897 END; ERROR; FLUSH_MATH END; PUSH_NEST; IF CUR_LIST.MODE_FIELD = 203 THEN BEGIN CUR_LIST.MODE_FIELD ← -1; CUR_LIST.AUX_FIELD.INT ← NEST[NEST_PTR - 2].AUX_FIELD.INT END ELSE IF CUR_LIST.MODE_FIELD > 0 THEN CUR_LIST.MODE_FIELD ← -CUR_LIST.MODE_FIELD; SCAN_SPEC (6, FALSE); MEM[59992].HH.RH ← 0; CUR_ALIGN ← 59992; CUR_LOOP ← 0; SCANNER_STATUS ← 4; WARNING_INDEX ← SAVE_CS_PTR; ALIGN_STATE ← -1000000; WHILE TRUE DO BEGIN MEM[CUR_ALIGN].HH.RH ← NEW_PARAM_GLUE (11); CUR_ALIGN ← MEM[CUR_ALIGN].HH.RH; IF CUR_CMD = 5 THEN GOTO 30; P ← 59996; MEM[P].HH.RH ← 0; WHILE TRUE DO BEGIN GET_PREAMBLE_TOKEN; IF CUR_CMD = 6 THEN GOTO 31; IF (CUR_CMD ≤ 5) AND (CUR_CMD ≥ 4) AND (ALIGN_STATE = -1000000) THEN IF (P = 59996) AND (CUR_LOOP = 0) AND (CUR_CMD = 4) THEN CUR_LOOP ← CUR_ALIGN ELSE BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (903) END; BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 904; HELP_LINE[1] ← 905; HELP_LINE[0] ← 906 END; BACK_ERROR; GOTO 31 END ELSE IF (CUR_CMD ≠ 10) OR (P ≠ 59996) THEN BEGIN MEM[P].HH.RH ← GET_AVAIL; P ← MEM[P].HH.RH; MEM[P].HH.LH ← CUR_TOK END END; 31: ; MEM[CUR_ALIGN].HH.RH ← NEW_NULL_BOX; CUR_ALIGN ← MEM[CUR_ALIGN].HH.RH; MEM[CUR_ALIGN].HH.LH ← 59991; MEM[CUR_ALIGN + 1].INT ← -1073741824; MEM[CUR_ALIGN + 3].INT ← MEM[59996].HH.RH; P ← 59996; MEM[P].HH.RH ← 0; WHILE TRUE DO BEGIN 22: GET_PREAMBLE_TOKEN; IF (CUR_CMD ≤ 5) AND (CUR_CMD ≥ 4) AND (ALIGN_STATE = -1000000) THEN GOTO 32; IF CUR_CMD = 6 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (907) END; BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 904; HELP_LINE[1] ← 905; HELP_LINE[0] ← 908 END; ERROR; GOTO 22 END; MEM[P].HH.RH ← GET_AVAIL; P ← MEM[P].HH.RH; MEM[P].HH.LH ← CUR_TOK END; 32: MEM[P].HH.RH ← GET_AVAIL; P ← MEM[P].HH.RH; MEM[P].HH.LH ← 10614; MEM[CUR_ALIGN + 2].INT ← MEM[59996].HH.RH END; 30: SCANNER_STATUS ← 0; NEW_SAVE_LEVEL (6); IF EQTB[7320].HH.RH ≠ 0 THEN BEGIN_TOKEN_LIST (EQTB[7320].HH.RH, 13); ALIGN_PEEK END; PROCEDURE INIT_SPAN (P:HALFWORD); BEGIN PUSH_NEST; IF CUR_LIST.MODE_FIELD = -102 THEN CUR_LIST.AUX_FIELD.HH.LH ← 1000 ELSE BEGIN CUR_LIST.AUX_FIELD.INT ← -65536000; NORMAL_PARAGRAPH END; CUR_SPAN ← P END; PROCEDURE INIT_ROW; BEGIN PUSH_NEST; CUR_LIST.MODE_FIELD ← -103 - CUR_LIST.MODE_FIELD; IF CUR_LIST.MODE_FIELD = -102 THEN CUR_LIST.AUX_FIELD.HH.LH ← 0 ELSE CUR_LIST.AUX_FIELD.INT ← 0; BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_GLUE (MEM[MEM[59992].HH.RH + 1].HH.LH); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; MEM[CUR_LIST.TAIL_FIELD].HH.B1 ← 12; CUR_ALIGN ← MEM[MEM[59992].HH.RH].HH.RH; CUR_TAIL ← CUR_HEAD; INIT_SPAN (CUR_ALIGN) END; PROCEDURE INIT_COL; BEGIN MEM[CUR_ALIGN + 5].HH.LH ← CUR_CMD; IF CUR_CMD = 63 THEN ALIGN_STATE ← 0 ELSE BEGIN BACK_INPUT; BEGIN_TOKEN_LIST (MEM[CUR_ALIGN + 3].INT, 1) END END; FUNCTION FIN_COL:BOOLEAN; LABEL 10; VAR P : HALFWORD; Q : HALFWORD; R : HALFWORD; S : HALFWORD; U : HALFWORD; W : SCALED; O : GLUE_ORD; N : HALFWORD; BEGIN IF CUR_ALIGN = 0 THEN CONFUSION (909); Q ← MEM[CUR_ALIGN].HH.RH; IF Q = 0 THEN CONFUSION (909); IF ALIGN_STATE < 500000 THEN FATAL_ERROR (595); P ← MEM[Q].HH.RH; IF (P = 0) AND (MEM[CUR_ALIGN + 5].HH.LH < 257) THEN IF CUR_LOOP ≠ 0 THEN BEGIN MEM[Q].HH.RH ← NEW_NULL_BOX; P ← MEM[Q].HH.RH; MEM[P].HH.LH ← 59991; MEM[P + 1].INT ← -1073741824; CUR_LOOP ← MEM[CUR_LOOP].HH.RH; Q ← 59996; R ← MEM[CUR_LOOP + 3].INT; WHILE R ≠ 0 DO BEGIN MEM[Q].HH.RH ← GET_AVAIL; Q ← MEM[Q].HH.RH; MEM[Q].HH.LH ← MEM[R].HH.LH; R ← MEM[R].HH.RH END; MEM[Q].HH.RH ← 0; MEM[P + 3].INT ← MEM[59996].HH.RH; Q ← 59996; R ← MEM[CUR_LOOP + 2].INT; WHILE R ≠ 0 DO BEGIN MEM[Q].HH.RH ← GET_AVAIL; Q ← MEM[Q].HH.RH; MEM[Q].HH.LH ← MEM[R].HH.LH; R ← MEM[R].HH.RH END; MEM[Q].HH.RH ← 0; MEM[P + 2].INT ← MEM[59996].HH.RH; CUR_LOOP ← MEM[CUR_LOOP].HH.RH; MEM[P].HH.RH ← NEW_GLUE (MEM[CUR_LOOP + 1].HH.LH); MEM[MEM[P].HH.RH].HH.B1 ← 12 END ELSE BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (910) END; PRINT_ESC (899); BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 911; HELP_LINE[1] ← 912; HELP_LINE[0] ← 913 END; MEM[CUR_ALIGN + 5].HH.LH ← 257; ERROR END; IF MEM[CUR_ALIGN + 5].HH.LH ≠ 256 THEN BEGIN UNSAVE; NEW_SAVE_LEVEL (6); BEGIN IF CUR_LIST.MODE_FIELD = -102 THEN BEGIN ADJUST_TAIL ← CUR_TAIL; U ← HPACK (MEM[CUR_LIST.HEAD_FIELD].HH.RH, 0, 1); W ← MEM[U + 1].INT; CUR_TAIL ← ADJUST_TAIL; ADJUST_TAIL ← 0 END ELSE BEGIN U ← VPACKAGE (MEM[CUR_LIST.HEAD_FIELD].HH.RH, 0, 1, 0); W ← MEM[U + 3].INT END; N ← 0; IF CUR_SPAN ≠ CUR_ALIGN THEN BEGIN Q ← CUR_SPAN; REPEAT N ← N + 1; Q ← MEM[MEM[Q].HH.RH].HH.RH UNTIL Q = CUR_ALIGN; IF N > 255 THEN CONFUSION (914); Q ← CUR_SPAN; WHILE MEM[MEM[Q].HH.LH].HH.RH < N DO Q ← MEM[Q].HH.LH; IF MEM[MEM[Q].HH.LH].HH.RH > N THEN BEGIN S ← GET_NODE (2); MEM[S].HH.LH ← MEM[Q].HH.LH; MEM[S].HH.RH ← N; MEM[Q].HH.LH ← S; MEM[S + 1].INT ← W END ELSE IF MEM[MEM[Q].HH.LH + 1].INT < W THEN MEM[MEM[Q].HH.LH + 1].INT ← W END ELSE IF W > MEM[CUR_ALIGN + 1].INT THEN MEM[CUR_ALIGN + 1].INT ← W; MEM[U].HH.B0 ← 13; MEM[U].HH.B1 ← N; IF TOTAL_STRETCH[3] ≠ 0 THEN O ← 3 ELSE IF TOTAL_STRETCH[2] ≠ 0 THEN O ← 2 ELSE IF TOTAL_STRETCH[1] ≠ 0 THEN O ← 1 ELSE O ← 0; MEM[U + 5].HH.B1 ← O; MEM[U + 6].INT ← TOTAL_STRETCH[O]; IF TOTAL_SHRINK[3] ≠ 0 THEN O ← 3 ELSE IF TOTAL_SHRINK[2] ≠ 0 THEN O ← 2 ELSE IF TOTAL_SHRINK[1] ≠ 0 THEN O ← 1 ELSE O ← 0; MEM[U + 5].HH.B0 ← O; MEM[U + 4].INT ← TOTAL_SHRINK[O]; POP_NEST; MEM[CUR_LIST.TAIL_FIELD].HH.RH ← U; CUR_LIST.TAIL_FIELD ← U END; BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_GLUE (MEM[MEM[CUR_ALIGN].HH.RH + 1].HH.LH); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; MEM[CUR_LIST.TAIL_FIELD].HH.B1 ← 12; IF MEM[CUR_ALIGN + 5].HH.LH ≥ 257 THEN BEGIN FIN_COL ← TRUE; GOTO 10 END; INIT_SPAN (P) END; ALIGN_STATE ← 1000000; REPEAT GET_X_TOKEN UNTIL CUR_CMD ≠ 10; CUR_ALIGN ← P; INIT_COL; FIN_COL ← FALSE; 10: END; PROCEDURE FIN_ROW; VAR P : HALFWORD; BEGIN IF CUR_LIST.MODE_FIELD = -102 THEN BEGIN P ← HPACK (MEM[CUR_LIST.HEAD_FIELD].HH.RH, 0, 1); POP_NEST; APPEND_TO_VLIST (P); IF CUR_HEAD ≠ CUR_TAIL THEN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← MEM[CUR_HEAD].HH.RH; CUR_LIST.TAIL_FIELD ← CUR_TAIL END END ELSE BEGIN P ← VPACKAGE (MEM[CUR_LIST.HEAD_FIELD].HH.RH, 0, 1, 1073741823); POP_NEST; MEM[CUR_LIST.TAIL_FIELD].HH.RH ← P; CUR_LIST.TAIL_FIELD ← P; CUR_LIST.AUX_FIELD.HH.LH ← 1000 END; MEM[P].HH.B0 ← 13; MEM[P + 6].INT ← 0; IF EQTB[7320].HH.RH ≠ 0 THEN BEGIN_TOKEN_LIST (EQTB[7320].HH.RH, 13); ALIGN_PEEK END; PROCEDURE DO_ASSIGNMENTS; FORWARD; PROCEDURE RESUME_AFTER_DISPLAY; FORWARD; PROCEDURE BUILD_PAGE; FORWARD; PROCEDURE FIN_ALIGN; VAR P : HALFWORD; Q : HALFWORD; R : HALFWORD; S : HALFWORD; U : HALFWORD; V : HALFWORD; T : SCALED; W : SCALED; O : SCALED; N : HALFWORD; RULE_SAVE : SCALED; AUX_SAVE : MEMORY_WORD; BEGIN IF CUR_GROUP ≠ 6 THEN CONFUSION (915); UNSAVE; IF CUR_GROUP ≠ 6 THEN CONFUSION (916); UNSAVE; IF NEST[NEST_PTR - 1].MODE_FIELD = 203 THEN O ← EQTB[9745].INT ELSE O ← 0; Q ← MEM[MEM[59992].HH.RH].HH.RH; REPEAT FLUSH_LIST (MEM[Q + 3].INT); FLUSH_LIST (MEM[Q + 2].INT); P ← MEM[MEM[Q].HH.RH].HH.RH; IF MEM[Q + 1].INT = -1073741824 THEN BEGIN MEM[Q + 1].INT ← 0; R ← MEM[Q].HH.RH; S ← MEM[R + 1].HH.LH; IF S ≠ 0 THEN BEGIN MEM[0].HH.RH ← MEM[0].HH.RH + 1; DELETE_GLUE_REF (S); MEM[R + 1].HH.LH ← 0 END END; IF MEM[Q].HH.LH ≠ 59991 THEN BEGIN T ← MEM[Q + 1].INT + MEM[MEM[MEM[Q].HH.RH + 1].HH.LH + 1].INT; R ← MEM[Q].HH.LH; S ← 59991; MEM[S].HH.LH ← P; N ← 1; REPEAT MEM[R + 1].INT ← MEM[R + 1].INT - T; U ← MEM[R].HH.LH; WHILE MEM[R].HH.RH > N DO BEGIN S ← MEM[S].HH.LH; N ← MEM[MEM[S].HH.LH].HH.RH + 1 END; IF MEM[R].HH.RH < N THEN BEGIN MEM[R].HH.LH ← MEM[S].HH.LH; MEM[S].HH.LH ← R; MEM[R].HH.RH ← MEM[R].HH.RH - 1; S ← R END ELSE BEGIN IF MEM[R + 1].INT > MEM[MEM[S].HH.LH + 1].INT THEN MEM[MEM[S].HH.LH + 1].INT ← MEM[R + 1].INT; FREE_NODE (R, 2) END; R ← U UNTIL R = 59991 END; MEM[Q].HH.B0 ← 13; MEM[Q].HH.B1 ← 0; MEM[Q + 3].INT ← 0; MEM[Q + 2].INT ← 0; MEM[Q + 5].HH.B1 ← 0; MEM[Q + 5].HH.B0 ← 0; MEM[Q + 6].INT ← 0; MEM[Q + 4].INT ← 0; Q ← P UNTIL Q = 0; SAVE_PTR ← SAVE_PTR - 2; PACK_BEGIN_LINE ← -CUR_LIST.ML_FIELD; IF CUR_LIST.MODE_FIELD = -1 THEN BEGIN RULE_SAVE ← EQTB[9746].INT; EQTB[9746].INT ← 0; P ← HPACK (MEM[59992].HH.RH, SAVE_STACK[SAVE_PTR + 1].INT, SAVE_STACK[SAVE_PTR + 0].INT); EQTB[9746].INT ← RULE_SAVE END ELSE BEGIN Q ← MEM[MEM[59992].HH.RH].HH.RH; REPEAT MEM[Q + 3].INT ← MEM[Q + 1].INT; MEM[Q + 1].INT ← 0; Q ← MEM[MEM[Q].HH.RH].HH.RH UNTIL Q = 0; P ← VPACKAGE (MEM[59992].HH.RH, SAVE_STACK[SAVE_PTR + 1].INT, SAVE_STACK[SAVE_PTR + 0].INT, 1073741823); Q ← MEM[MEM[59992].HH.RH].HH.RH; REPEAT MEM[Q + 1].INT ← MEM[Q + 3].INT; MEM[Q + 3].INT ← 0; Q ← MEM[MEM[Q].HH.RH].HH.RH UNTIL Q = 0 END; PACK_BEGIN_LINE ← 0; Q ← MEM[CUR_LIST.HEAD_FIELD].HH.RH; S ← CUR_LIST.HEAD_FIELD; WHILE Q ≠ 0 DO BEGIN IF NOT (Q ≥ HI_MEM_MIN) THEN IF MEM[Q].HH.B0 = 13 THEN BEGIN IF CUR_LIST.MODE_FIELD = -1 THEN BEGIN MEM[Q].HH.B0 ← 0; MEM[Q + 1].INT ← MEM[P + 1].INT END ELSE BEGIN MEM[Q].HH.B0 ← 1; MEM[Q + 3].INT ← MEM[P + 3].INT END; MEM[Q + 5].HH.B1 ← MEM[P + 5].HH.B1; MEM[Q + 5].HH.B0 ← MEM[P + 5].HH.B0; MEM[Q + 6].GR ← MEM[P + 6].GR; MEM[Q + 4].INT ← O; R ← MEM[MEM[Q + 5].HH.RH].HH.RH; S ← MEM[MEM[P + 5].HH.RH].HH.RH; REPEAT N ← MEM[R].HH.B1; T ← MEM[S + 1].INT; W ← T; U ← 59996; WHILE N > 0 DO BEGIN N ← N - 1; S ← MEM[S].HH.RH; V ← MEM[S + 1].HH.LH; MEM[U].HH.RH ← NEW_GLUE (V); U ← MEM[U].HH.RH; MEM[U].HH.B1 ← 12; T ← T + MEM[V + 1].INT; IF MEM[P + 5].HH.B0 = 1 THEN BEGIN IF MEM[V].HH.B0 = MEM[P + 5].HH.B1 THEN T ← T + ROUND (MEM[P + 6].GR * MEM[V + 2].INT) END ELSE IF MEM[P + 5].HH.B0 = 2 THEN BEGIN IF MEM[V].HH.B1 = MEM[P + 5].HH.B1 THEN T ← T - ROUND (MEM[P + 6].GR * MEM[V + 3].INT) END; S ← MEM[S].HH.RH; MEM[U].HH.RH ← NEW_NULL_BOX; U ← MEM[U].HH.RH; T ← T + MEM[S + 1].INT; IF CUR_LIST.MODE_FIELD = -1 THEN MEM[U + 1].INT ← MEM[S + 1].INT ELSE BEGIN MEM[U].HH.B0 ← 1; MEM[U + 3].INT ← MEM[S + 1].INT END END; IF CUR_LIST.MODE_FIELD = -1 THEN BEGIN MEM[R + 3].INT ← MEM[Q + 3].INT; MEM[R + 2].INT ← MEM[Q + 2].INT; IF T = MEM[R + 1].INT THEN BEGIN MEM[R + 5].HH.B0 ← 0; MEM[R + 5].HH.B1 ← 0; MEM[R + 6].GR ← 0.0 END ELSE IF T > MEM[R + 1].INT THEN BEGIN MEM[R + 5].HH.B0 ← 1; IF MEM[R + 6].INT = 0 THEN MEM[R + 6].GR ← 0.0 ELSE MEM[R + 6].GR ← (T - MEM[R + 1].INT) / MEM[R + 6].INT END ELSE BEGIN MEM[R + 5].HH.B1 ← MEM[R + 5].HH.B0; MEM[R + 5].HH.B0 ← 2; IF MEM[R + 4].INT = 0 THEN MEM[R + 6].GR ← 0.0 ELSE IF (MEM[R + 5].HH.B1 = 0) AND (MEM[R + 1].INT - T > MEM[R + 4].INT) THEN MEM[R + 6].GR ← 1.0 ELSE MEM[R + 6].GR ← (MEM[R + 1].INT - T) / MEM[R + 4].INT END; MEM[R + 1].INT ← W; MEM[R].HH.B0 ← 0 END ELSE BEGIN MEM[R + 1].INT ← MEM[Q + 1].INT; IF T = MEM[R + 3].INT THEN BEGIN MEM[R + 5].HH.B0 ← 0; MEM[R + 5].HH.B1 ← 0; MEM[R + 6].GR ← 0.0 END ELSE IF T > MEM[R + 3].INT THEN BEGIN MEM[R + 5].HH.B0 ← 1; IF MEM[R + 6].INT = 0 THEN MEM[R + 6].GR ← 0.0 ELSE MEM[R + 6].GR ← (T - MEM[R + 3].INT) / MEM[R + 6].INT END ELSE BEGIN MEM[R + 5].HH.B1 ← MEM[R + 5].HH.B0; MEM[R + 5].HH.B0 ← 2; IF MEM[R + 4].INT = 0 THEN MEM[R + 6].GR ← 0.0 ELSE IF (MEM[R + 5].HH.B1 = 0) AND (MEM[R + 3].INT - T > MEM[R + 4].INT) THEN MEM[R + 6].GR ← 1.0 ELSE MEM[R + 6].GR ← (MEM[R + 3].INT - T) / MEM[R + 4].INT END; MEM[R + 3].INT ← W; MEM[R].HH.B0 ← 1 END; MEM[R + 4].INT ← 0; IF U ≠ 59996 THEN BEGIN MEM[U].HH.RH ← MEM[R].HH.RH; MEM[R].HH.RH ← MEM[59996].HH.RH; R ← U END; R ← MEM[MEM[R].HH.RH].HH.RH; S ← MEM[MEM[S].HH.RH].HH.RH UNTIL R = 0 END ELSE IF MEM[Q].HH.B0 = 2 THEN BEGIN IF MEM[Q + 1].INT = -1073741824 THEN MEM[Q + 1].INT ← MEM[P + 1].INT; IF MEM[Q + 3].INT = -1073741824 THEN MEM[Q + 3].INT ← MEM[P + 3].INT; IF MEM[Q + 2].INT = -1073741824 THEN MEM[Q + 2].INT ← MEM[P + 2].INT; IF O ≠ 0 THEN BEGIN R ← MEM[Q].HH.RH; MEM[Q].HH.RH ← 0; Q ← HPACK (Q, 0, 1); MEM[Q + 4].INT ← O; MEM[Q].HH.RH ← R; MEM[S].HH.RH ← Q END END; S ← Q; Q ← MEM[Q].HH.RH END; FLUSH_NODE_LIST (P); POP_ALIGNMENT; AUX_SAVE ← CUR_LIST.AUX_FIELD; P ← MEM[CUR_LIST.HEAD_FIELD].HH.RH; Q ← CUR_LIST.TAIL_FIELD; POP_NEST; IF CUR_LIST.MODE_FIELD = 203 THEN BEGIN DO_ASSIGNMENTS; IF CUR_CMD ≠ 3 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1170) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 895; HELP_LINE[0] ← 896 END; BACK_ERROR END ELSE BEGIN GET_X_TOKEN; IF CUR_CMD ≠ 3 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1166) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 1167; HELP_LINE[0] ← 1168 END; BACK_ERROR END END; POP_NEST; BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_PENALTY (EQTB[9174].INT); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_PARAM_GLUE (3); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; MEM[CUR_LIST.TAIL_FIELD].HH.RH ← P; IF P ≠ 0 THEN CUR_LIST.TAIL_FIELD ← Q; BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_PENALTY (EQTB[9175].INT); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_PARAM_GLUE (4); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; CUR_LIST.AUX_FIELD.INT ← AUX_SAVE.INT; RESUME_AFTER_DISPLAY END ELSE BEGIN CUR_LIST.AUX_FIELD ← AUX_SAVE; MEM[CUR_LIST.TAIL_FIELD].HH.RH ← P; IF P ≠ 0 THEN CUR_LIST.TAIL_FIELD ← Q; IF CUR_LIST.MODE_FIELD = 1 THEN BUILD_PAGE END END; PROCEDURE ALIGN_PEEK; LABEL 20; BEGIN 20: ALIGN_STATE ← 1000000; REPEAT GET_X_TOKEN UNTIL CUR_CMD ≠ 10; IF CUR_CMD = 34 THEN BEGIN SCAN_LEFT_BRACE; NEW_SAVE_LEVEL (7); IF CUR_LIST.MODE_FIELD = -1 THEN NORMAL_PARAGRAPH END ELSE IF CUR_CMD = 2 THEN FIN_ALIGN ELSE IF (CUR_CMD = 5) AND (CUR_CHR = 258) THEN GOTO 20 ELSE BEGIN INIT_ROW; INIT_COL END END; FUNCTION FINITE_SHRINK (P:HALFWORD):HALFWORD; VAR Q : HALFWORD; BEGIN IF NO_SHRINK_ERROR_YET THEN BEGIN NO_SHRINK_ERROR_YET ← FALSE; BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (917) END; BEGIN HELP_PTR ← 5; HELP_LINE[4] ← 918; HELP_LINE[3] ← 919; HELP_LINE[2] ← 920; HELP_LINE[1] ← 921; HELP_LINE[0] ← 922 END; ERROR END; Q ← NEW_SPEC (P); MEM[Q].HH.B1 ← 0; DELETE_GLUE_REF (P); FINITE_SHRINK ← Q END; PROCEDURE TRY_BREAK (PI:INTEGER; BREAK_TYPE:SMALL_NUMBER); LABEL 10, 30, 31, 22, 60; VAR R : HALFWORD; PREV_R : HALFWORD; OLD_L : HALFWORD; NO_BREAK_YET : BOOLEAN; PREV_PREV_R : HALFWORD; S : HALFWORD; Q : HALFWORD; V : HALFWORD; T : INTEGER; F : INTERNAL_FONT_NUMBER; L : HALFWORD; NODE_R_STAYS_ACTIVE : BOOLEAN; LINE_WIDTH : SCALED; FIT_CLASS : 0..3; B : HALFWORD; D : INTEGER; ARTIFICIAL_DEMERITS : BOOLEAN; SAVE_LINK : HALFWORD; SHORTFALL : SCALED; BEGIN IF ABS (PI) ≥ 10000 THEN IF PI > 0 THEN GOTO 10 ELSE PI ← -10000; NO_BREAK_YET ← TRUE; PREV_R ← 59993; OLD_L ← 0; CUR_ACTIVE_WIDTH[1] ← ACTIVE_WIDTH[1]; CUR_ACTIVE_WIDTH[2] ← ACTIVE_WIDTH[2]; CUR_ACTIVE_WIDTH[3] ← ACTIVE_WIDTH[3]; CUR_ACTIVE_WIDTH[4] ← ACTIVE_WIDTH[4]; CUR_ACTIVE_WIDTH[5] ← ACTIVE_WIDTH[5]; CUR_ACTIVE_WIDTH[6] ← ACTIVE_WIDTH[6]; WHILE TRUE DO BEGIN 22: R ← MEM[PREV_R].HH.RH; IF MEM[R].HH.B0 = 2 THEN BEGIN CUR_ACTIVE_WIDTH[1] ← CUR_ACTIVE_WIDTH[1] + MEM[R + 1].INT; CUR_ACTIVE_WIDTH[2] ← CUR_ACTIVE_WIDTH[2] + MEM[R + 2].INT; CUR_ACTIVE_WIDTH[3] ← CUR_ACTIVE_WIDTH[3] + MEM[R + 3].INT; CUR_ACTIVE_WIDTH[4] ← CUR_ACTIVE_WIDTH[4] + MEM[R + 4].INT; CUR_ACTIVE_WIDTH[5] ← CUR_ACTIVE_WIDTH[5] + MEM[R + 5].INT; CUR_ACTIVE_WIDTH[6] ← CUR_ACTIVE_WIDTH[6] + MEM[R + 6].INT; PREV_PREV_R ← PREV_R; PREV_R ← R; GOTO 22 END; BEGIN L ← MEM[R + 1].HH.LH; IF L > OLD_L THEN BEGIN IF (MINIMUM_DEMERITS < 1073741823) AND ((OLD_L ≠ EASY_LINE) OR (R = 59993)) THEN BEGIN IF NO_BREAK_YET THEN BEGIN NO_BREAK_YET ← FALSE; BREAK_WIDTH[1] ← BACKGROUND[1]; BREAK_WIDTH[2] ← BACKGROUND[2]; BREAK_WIDTH[3] ← BACKGROUND[3]; BREAK_WIDTH[4] ← BACKGROUND[4]; BREAK_WIDTH[5] ← BACKGROUND[5]; BREAK_WIDTH[6] ← BACKGROUND[6]; S ← CUR_P; IF BREAK_TYPE > 0 THEN IF CUR_P ≠ 0 THEN BEGIN T ← MEM[CUR_P].HH.B1; V ← CUR_P; S ← MEM[CUR_P + 1].HH.RH; WHILE T > 0 DO BEGIN T ← T - 1; V ← MEM[V].HH.RH; IF V ≥ HI_MEM_MIN THEN BEGIN F ← MEM[V].HH.B0; BREAK_WIDTH[1] ← BREAK_WIDTH[1] - FONT_INFO[ WIDTH_BASE[F] + FONT_INFO[CHAR_BASE[F] + MEM[V].HH.B1].QQQQ.B0]. INT END ELSE CASE MEM[V].HH.B0 OF 6: BEGIN F ← MEM[V + 1].HH.B0; BREAK_WIDTH[1] ← BREAK_WIDTH[1] - FONT_INFO[ WIDTH_BASE[F] + FONT_INFO[CHAR_BASE[F] + MEM[V + 1].HH.B1].QQQQ.B0]. INT END; 0,1,2,11: BREAK_WIDTH[1] ← BREAK_WIDTH[1] - MEM[V + 1].INT; ELSE CONFUSION (923); END END; WHILE S ≠ 0 DO BEGIN IF S ≥ HI_MEM_MIN THEN BEGIN F ← MEM[S].HH.B0; BREAK_WIDTH[1] ← BREAK_WIDTH[1] + FONT_INFO[ WIDTH_BASE[F] + FONT_INFO[CHAR_BASE[F] + MEM[S].HH.B1].QQQQ.B0]. INT END ELSE CASE MEM[S].HH.B0 OF 6: BEGIN F ← MEM[S + 1].HH.B0; BREAK_WIDTH[1] ← BREAK_WIDTH[1] + FONT_INFO[ WIDTH_BASE[F] + FONT_INFO[CHAR_BASE[F] + MEM[S + 1].HH.B1].QQQQ.B0]. INT END; 0,1,2,11: BREAK_WIDTH[1] ← BREAK_WIDTH[1] + MEM[S + 1].INT; ELSE CONFUSION (924); END; S ← MEM[S].HH.RH END; BREAK_WIDTH[1] ← BREAK_WIDTH[1] + DISC_WIDTH; IF MEM[CUR_P + 1].HH.RH = 0 THEN S ← MEM[V].HH.RH END; WHILE S ≠ 0 DO BEGIN IF S ≥ HI_MEM_MIN THEN GOTO 30; CASE MEM[S].HH.B0 OF 10: BEGIN V ← MEM[S + 1].HH.LH; BREAK_WIDTH[1] ← BREAK_WIDTH[1] - MEM[V + 1].INT; BREAK_WIDTH[2 + MEM[V].HH.B0] ← BREAK_WIDTH[2 + MEM[V].HH.B0] - MEM[V + 2].INT; BREAK_WIDTH[6] ← BREAK_WIDTH[6] - MEM[V + 3].INT END; 12: ; 9: BREAK_WIDTH[1] ← BREAK_WIDTH[1] - MEM[S + 1].INT; 11: IF MEM[S].HH.B1 ≠ 1 THEN GOTO 30 ELSE BREAK_WIDTH[1] ← BREAK_WIDTH[1] - MEM[S + 1].INT; ELSE GOTO 30; END; S ← MEM[S].HH.RH END; 30: END; IF MEM[PREV_R].HH.B0 = 2 THEN BEGIN MEM[PREV_R + 1].INT ← MEM[PREV_R + 1].INT - CUR_ACTIVE_WIDTH[1] + BREAK_WIDTH[1]; MEM[PREV_R + 2].INT ← MEM[PREV_R + 2].INT - CUR_ACTIVE_WIDTH[2] + BREAK_WIDTH[2]; MEM[PREV_R + 3].INT ← MEM[PREV_R + 3].INT - CUR_ACTIVE_WIDTH[3] + BREAK_WIDTH[3]; MEM[PREV_R + 4].INT ← MEM[PREV_R + 4].INT - CUR_ACTIVE_WIDTH[4] + BREAK_WIDTH[4]; MEM[PREV_R + 5].INT ← MEM[PREV_R + 5].INT - CUR_ACTIVE_WIDTH[5] + BREAK_WIDTH[5]; MEM[PREV_R + 6].INT ← MEM[PREV_R + 6].INT - CUR_ACTIVE_WIDTH[6] + BREAK_WIDTH[6] END ELSE IF PREV_R = 59993 THEN BEGIN ACTIVE_WIDTH[1] ← BREAK_WIDTH[1]; ACTIVE_WIDTH[2] ← BREAK_WIDTH[2]; ACTIVE_WIDTH[3] ← BREAK_WIDTH[3]; ACTIVE_WIDTH[4] ← BREAK_WIDTH[4]; ACTIVE_WIDTH[5] ← BREAK_WIDTH[5]; ACTIVE_WIDTH[6] ← BREAK_WIDTH[6] END ELSE BEGIN Q ← GET_NODE (7); MEM[Q].HH.RH ← R; MEM[Q].HH.B0 ← 2; MEM[Q].HH.B1 ← 0; MEM[Q + 1].INT ← BREAK_WIDTH[1] - CUR_ACTIVE_WIDTH[1]; MEM[Q + 2].INT ← BREAK_WIDTH[2] - CUR_ACTIVE_WIDTH[2]; MEM[Q + 3].INT ← BREAK_WIDTH[3] - CUR_ACTIVE_WIDTH[3]; MEM[Q + 4].INT ← BREAK_WIDTH[4] - CUR_ACTIVE_WIDTH[4]; MEM[Q + 5].INT ← BREAK_WIDTH[5] - CUR_ACTIVE_WIDTH[5]; MEM[Q + 6].INT ← BREAK_WIDTH[6] - CUR_ACTIVE_WIDTH[6]; MEM[PREV_R].HH.RH ← Q; PREV_PREV_R ← PREV_R; PREV_R ← Q END; IF ABS (EQTB[9179].INT) ≥ 1073741823 - MINIMUM_DEMERITS THEN MINIMUM_DEMERITS ← 1073741822 ELSE MINIMUM_DEMERITS ← MINIMUM_DEMERITS + ABS (EQTB[9179].INT); FOR FIT_CLASS ← 0 TO 3 DO BEGIN IF MINIMAL_DEMERITS[FIT_CLASS] ≤ MINIMUM_DEMERITS THEN BEGIN Q ← GET_NODE (2); MEM[Q].HH.RH ← PASSIVE; PASSIVE ← Q; MEM[Q + 1].HH.RH ← CUR_P; MEM[Q + 1].HH.LH ← BEST_PLACE[FIT_CLASS]; Q ← GET_NODE (3); MEM[Q + 1].HH.RH ← PASSIVE; MEM[Q + 1].HH.LH ← BEST_PL_LINE[FIT_CLASS] + 1; MEM[Q].HH.B1 ← FIT_CLASS; MEM[Q].HH.B0 ← BREAK_TYPE; MEM[Q + 2].INT ← MINIMAL_DEMERITS[FIT_CLASS]; MEM[Q].HH.RH ← R; MEM[PREV_R].HH.RH ← Q; PREV_R ← Q END; MINIMAL_DEMERITS[FIT_CLASS] ← 1073741823 END; MINIMUM_DEMERITS ← 1073741823; IF R ≠ 59993 THEN BEGIN Q ← GET_NODE (7); MEM[Q].HH.RH ← R; MEM[Q].HH.B0 ← 2; MEM[Q].HH.B1 ← 0; MEM[Q + 1].INT ← CUR_ACTIVE_WIDTH[1] - BREAK_WIDTH[1]; MEM[Q + 2].INT ← CUR_ACTIVE_WIDTH[2] - BREAK_WIDTH[2]; MEM[Q + 3].INT ← CUR_ACTIVE_WIDTH[3] - BREAK_WIDTH[3]; MEM[Q + 4].INT ← CUR_ACTIVE_WIDTH[4] - BREAK_WIDTH[4]; MEM[Q + 5].INT ← CUR_ACTIVE_WIDTH[5] - BREAK_WIDTH[5]; MEM[Q + 6].INT ← CUR_ACTIVE_WIDTH[6] - BREAK_WIDTH[6]; MEM[PREV_R].HH.RH ← Q; PREV_PREV_R ← PREV_R; PREV_R ← Q END END; IF R = 59993 THEN GOTO 10; IF L > EASY_LINE THEN BEGIN LINE_WIDTH ← SECOND_WIDTH; OLD_L ← 65534 END ELSE BEGIN OLD_L ← L; IF L > LAST_SPECIAL_LINE THEN LINE_WIDTH ← SECOND_WIDTH ELSE IF EQTB[7312].HH.RH = 0 THEN LINE_WIDTH ← FIRST_WIDTH ELSE LINE_WIDTH ← MEM[EQTB[7312].HH.RH + 2 * L].INT END END END; BEGIN ARTIFICIAL_DEMERITS ← FALSE; SHORTFALL ← LINE_WIDTH - CUR_ACTIVE_WIDTH[1]; IF SHORTFALL > 0 THEN IF (CUR_ACTIVE_WIDTH[3] ≠ 0) OR (CUR_ACTIVE_WIDTH[4] ≠ 0) OR (CUR_ACTIVE_WIDTH[5] ≠ 0) THEN BEGIN B ← 0; FIT_CLASS ← 2 END ELSE BEGIN IF SHORTFALL > 7230584 THEN IF CUR_ACTIVE_WIDTH[2] < 1663497 THEN BEGIN B ← 10000; FIT_CLASS ← 0; GOTO 31 END; B ← BADNESS (SHORTFALL, CUR_ACTIVE_WIDTH[2]); IF B > 12 THEN IF B > 99 THEN FIT_CLASS ← 0 ELSE FIT_CLASS ← 1 ELSE FIT_CLASS ← 2; 31: END ELSE BEGIN IF -SHORTFALL > CUR_ACTIVE_WIDTH[6] THEN B ← 10001 ELSE B ← BADNESS (-SHORTFALL, CUR_ACTIVE_WIDTH[6]); IF B > 12 THEN FIT_CLASS ← 3 ELSE FIT_CLASS ← 2 END; IF (B > 10000) OR (PI = -10000) THEN BEGIN IF FINAL_PASS AND (MINIMUM_DEMERITS = 1073741823) AND (MEM[R].HH.RH = 59993) AND (PREV_R = 59993) THEN ARTIFICIAL_DEMERITS ← TRUE ELSE IF B > THRESHOLD THEN GOTO 60; NODE_R_STAYS_ACTIVE ← FALSE END ELSE BEGIN PREV_R ← R; IF B > THRESHOLD THEN GOTO 22; NODE_R_STAYS_ACTIVE ← TRUE END; IF ARTIFICIAL_DEMERITS THEN D ← 0 ELSE BEGIN D ← EQTB[9165].INT + B; IF ABS (D) ≥ 10000 THEN D ← 100000000 ELSE D ← D * D; IF PI ≠ 0 THEN IF PI > 0 THEN D ← D + PI * PI ELSE IF PI > -10000 THEN D ← D - PI * PI; IF (BREAK_TYPE = 1) AND (MEM[R].HH.B0 = 1) THEN IF CUR_P ≠ 0 THEN D ← D + EQTB[9177].INT ELSE D ← D + EQTB[9178].INT; IF ABS (FIT_CLASS - MEM[R].HH.B1) > 1 THEN D ← D + EQTB[9179].INT END; D ← D + MEM[R + 2].INT; IF D ≤ MINIMAL_DEMERITS[FIT_CLASS] THEN BEGIN MINIMAL_DEMERITS[FIT_CLASS] ← D; BEST_PLACE[FIT_CLASS] ← MEM[R + 1].HH.RH; BEST_PL_LINE[FIT_CLASS] ← L; IF D < MINIMUM_DEMERITS THEN MINIMUM_DEMERITS ← D END; IF NODE_R_STAYS_ACTIVE THEN GOTO 22; 60: MEM[PREV_R].HH.RH ← MEM[R].HH.RH; FREE_NODE (R, 3); IF PREV_R = 59993 THEN BEGIN R ← MEM[59993].HH.RH; IF MEM[R].HH.B0 = 2 THEN BEGIN ACTIVE_WIDTH[1] ← ACTIVE_WIDTH[1] + MEM[R + 1].INT; ACTIVE_WIDTH[2] ← ACTIVE_WIDTH[2] + MEM[R + 2].INT; ACTIVE_WIDTH[3] ← ACTIVE_WIDTH[3] + MEM[R + 3].INT; ACTIVE_WIDTH[4] ← ACTIVE_WIDTH[4] + MEM[R + 4].INT; ACTIVE_WIDTH[5] ← ACTIVE_WIDTH[5] + MEM[R + 5].INT; ACTIVE_WIDTH[6] ← ACTIVE_WIDTH[6] + MEM[R + 6].INT; CUR_ACTIVE_WIDTH[1] ← ACTIVE_WIDTH[1]; CUR_ACTIVE_WIDTH[2] ← ACTIVE_WIDTH[2]; CUR_ACTIVE_WIDTH[3] ← ACTIVE_WIDTH[3]; CUR_ACTIVE_WIDTH[4] ← ACTIVE_WIDTH[4]; CUR_ACTIVE_WIDTH[5] ← ACTIVE_WIDTH[5]; CUR_ACTIVE_WIDTH[6] ← ACTIVE_WIDTH[6]; MEM[59993].HH.RH ← MEM[R].HH.RH; FREE_NODE (R, 7) END END ELSE IF MEM[PREV_R].HH.B0 = 2 THEN BEGIN R ← MEM[PREV_R].HH.RH; IF R = 59993 THEN BEGIN CUR_ACTIVE_WIDTH[1] ← CUR_ACTIVE_WIDTH[1] - MEM[PREV_R + 1].INT; CUR_ACTIVE_WIDTH[2] ← CUR_ACTIVE_WIDTH[2] - MEM[PREV_R + 2].INT; CUR_ACTIVE_WIDTH[3] ← CUR_ACTIVE_WIDTH[3] - MEM[PREV_R + 3].INT; CUR_ACTIVE_WIDTH[4] ← CUR_ACTIVE_WIDTH[4] - MEM[PREV_R + 4].INT; CUR_ACTIVE_WIDTH[5] ← CUR_ACTIVE_WIDTH[5] - MEM[PREV_R + 5].INT; CUR_ACTIVE_WIDTH[6] ← CUR_ACTIVE_WIDTH[6] - MEM[PREV_R + 6].INT; MEM[PREV_PREV_R].HH.RH ← 59993; FREE_NODE (PREV_R, 7); PREV_R ← PREV_PREV_R END ELSE IF MEM[R].HH.B0 = 2 THEN BEGIN CUR_ACTIVE_WIDTH[1] ← CUR_ACTIVE_WIDTH[1] + MEM[R + 1].INT; CUR_ACTIVE_WIDTH[2] ← CUR_ACTIVE_WIDTH[2] + MEM[R + 2].INT; CUR_ACTIVE_WIDTH[3] ← CUR_ACTIVE_WIDTH[3] + MEM[R + 3].INT; CUR_ACTIVE_WIDTH[4] ← CUR_ACTIVE_WIDTH[4] + MEM[R + 4].INT; CUR_ACTIVE_WIDTH[5] ← CUR_ACTIVE_WIDTH[5] + MEM[R + 5].INT; CUR_ACTIVE_WIDTH[6] ← CUR_ACTIVE_WIDTH[6] + MEM[R + 6].INT; MEM[PREV_R + 1].INT ← MEM[PREV_R + 1].INT + MEM[R + 1].INT; MEM[PREV_R + 2].INT ← MEM[PREV_R + 2].INT + MEM[R + 2].INT; MEM[PREV_R + 3].INT ← MEM[PREV_R + 3].INT + MEM[R + 3].INT; MEM[PREV_R + 4].INT ← MEM[PREV_R + 4].INT + MEM[R + 4].INT; MEM[PREV_R + 5].INT ← MEM[PREV_R + 5].INT + MEM[R + 5].INT; MEM[PREV_R + 6].INT ← MEM[PREV_R + 6].INT + MEM[R + 6].INT; MEM[PREV_R].HH.RH ← MEM[R].HH.RH; FREE_NODE (R, 7) END END END END; 10: END; PROCEDURE POST_LINE_BREAK (FINAL_WIDOW_PENALTY:INTEGER); LABEL 30, 31; VAR Q : HALFWORD; R : HALFWORD; S : HALFWORD; DISC_BREAK : BOOLEAN; POST_DISC_BREAK : BOOLEAN; CUR_WIDTH : SCALED; CUR_INDENT : SCALED; T : QUARTERWORD; PEN : INTEGER; CUR_LINE : HALFWORD; BEGIN Q ← MEM[BEST_BET + 1].HH.RH; CUR_P ← 0; REPEAT R ← Q; Q ← MEM[Q + 1].HH.LH; MEM[R + 1].HH.LH ← CUR_P; CUR_P ← R UNTIL Q = 0; CUR_LINE ← CUR_LIST.PG_FIELD + 1; REPEAT Q ← MEM[CUR_P + 1].HH.RH; DISC_BREAK ← FALSE; POST_DISC_BREAK ← FALSE; IF Q ≠ 0 THEN IF MEM[Q].HH.B0 = 10 THEN BEGIN DELETE_GLUE_REF (MEM[Q + 1].HH.LH); MEM[Q + 1].HH.LH ← EQTB[6790].HH.RH; MEM[Q].HH.B1 ← 9; MEM[EQTB[6790].HH.RH].HH.RH ← MEM[EQTB[6790].HH.RH].HH.RH + 1; GOTO 30 END ELSE BEGIN IF MEM[Q].HH.B0 = 7 THEN BEGIN T ← MEM[Q].HH.B1; IF T = 0 THEN R ← MEM[Q].HH.RH ELSE BEGIN R ← Q; WHILE T > 1 DO BEGIN R ← MEM[R].HH.RH; T ← T - 1 END; S ← MEM[R].HH.RH; R ← MEM[S].HH.RH; MEM[S].HH.RH ← 0; FLUSH_NODE_LIST (MEM[Q].HH.RH); MEM[Q].HH.B1 ← 0 END; IF MEM[Q + 1].HH.RH ≠ 0 THEN BEGIN S ← MEM[Q + 1].HH.RH; WHILE MEM[S].HH.RH ≠ 0 DO S ← MEM[S].HH.RH; MEM[S].HH.RH ← R; R ← MEM[Q + 1].HH.RH; MEM[Q + 1].HH.RH ← 0; POST_DISC_BREAK ← TRUE END; IF MEM[Q + 1].HH.LH ≠ 0 THEN BEGIN S ← MEM[Q + 1].HH.LH; MEM[Q].HH.RH ← S; WHILE MEM[S].HH.RH ≠ 0 DO S ← MEM[S].HH.RH; MEM[Q + 1].HH.LH ← 0; Q ← S END; MEM[Q].HH.RH ← R; DISC_BREAK ← TRUE END ELSE IF (MEM[Q].HH.B0 = 9) OR (MEM[Q].HH.B0 = 11) THEN MEM[Q + 1].INT ← 0 END ELSE BEGIN Q ← 59997; WHILE MEM[Q].HH.RH ≠ 0 DO Q ← MEM[Q].HH.RH END; R ← NEW_PARAM_GLUE (8); MEM[R].HH.RH ← MEM[Q].HH.RH; MEM[Q].HH.RH ← R; Q ← R; 30: ; R ← MEM[Q].HH.RH; MEM[Q].HH.RH ← 0; Q ← MEM[59997].HH.RH; MEM[59997].HH.RH ← R; IF EQTB[6789].HH.RH ≠ 0 THEN BEGIN R ← NEW_PARAM_GLUE (7); MEM[R].HH.RH ← Q; Q ← R END; IF CUR_LINE > LAST_SPECIAL_LINE THEN BEGIN CUR_WIDTH ← SECOND_WIDTH; CUR_INDENT ← SECOND_INDENT END ELSE IF EQTB[7312].HH.RH = 0 THEN BEGIN CUR_WIDTH ← FIRST_WIDTH; CUR_INDENT ← FIRST_INDENT END ELSE BEGIN CUR_WIDTH ← MEM[EQTB[7312].HH.RH + 2 * CUR_LINE].INT; CUR_INDENT ← MEM[EQTB[7312].HH.RH + 2 * CUR_LINE - 1].INT END; ADJUST_TAIL ← 59995; JUST_BOX ← HPACK (Q, CUR_WIDTH, 0); MEM[JUST_BOX + 4].INT ← CUR_INDENT; APPEND_TO_VLIST (JUST_BOX); IF 59995 ≠ ADJUST_TAIL THEN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← MEM[59995].HH.RH; CUR_LIST.TAIL_FIELD ← ADJUST_TAIL END; ADJUST_TAIL ← 0; IF CUR_LINE + 1 ≠ BEST_LINE THEN BEGIN PEN ← EQTB[9176].INT; IF CUR_LINE = CUR_LIST.PG_FIELD + 1 THEN PEN ← PEN + EQTB[9168].INT; IF CUR_LINE + 2 = BEST_LINE THEN PEN ← PEN + FINAL_WIDOW_PENALTY; IF DISC_BREAK THEN PEN ← PEN + EQTB[9171].INT; IF PEN ≠ 0 THEN BEGIN R ← NEW_PENALTY (PEN); MEM[CUR_LIST.TAIL_FIELD].HH.RH ← R; CUR_LIST.TAIL_FIELD ← R END END; CUR_LINE ← CUR_LINE + 1; CUR_P ← MEM[CUR_P + 1].HH.LH; IF CUR_P ≠ 0 THEN IF NOT POST_DISC_BREAK THEN BEGIN R ← 59997; WHILE TRUE DO BEGIN Q ← MEM[R].HH.RH; IF Q = MEM[CUR_P + 1].HH.RH THEN GOTO 31; IF Q ≥ HI_MEM_MIN THEN GOTO 31; IF MEM[Q].HH.B0 < 9 THEN GOTO 31; IF MEM[Q].HH.B0 = 11 THEN IF MEM[Q].HH.B1 ≠ 1 THEN GOTO 31; R ← Q END; 31: IF R ≠ 59997 THEN BEGIN MEM[R].HH.RH ← 0; FLUSH_NODE_LIST (MEM[59997].HH.RH); MEM[59997].HH.RH ← Q END END UNTIL CUR_P = 0; IF (CUR_LINE ≠ BEST_LINE) OR (MEM[59997].HH.RH ≠ 0) THEN CONFUSION (939); CUR_LIST.PG_FIELD ← BEST_LINE - 1 END; FUNCTION RECONSTITUTE (J:SMALL_NUMBER; N:SMALL_NUMBER; BCHAR:HALFWORD; HCHAR:HALFWORD):SMALL_NUMBER; LABEL 22, 30; VAR P : HALFWORD; T : HALFWORD; Q : FOUR_QUARTERS; CUR_RH : HALFWORD; TEST_CHAR : HALFWORD; W : SCALED; K : FONT_INDEX; BEGIN HYPHEN_PASSED ← 0; T ← 59996; W ← 0; MEM[59996].HH.RH ← 0; CUR_L ← HU[J] + 0; CUR_Q ← T; IF J = 0 THEN BEGIN LIGATURE_PRESENT ← INIT_LIG; P ← INIT_LIST; IF LIGATURE_PRESENT THEN LFT_HIT ← INIT_LFT; WHILE P > 0 DO BEGIN BEGIN MEM[T].HH.RH ← GET_AVAIL; T ← MEM[T].HH.RH; MEM[T].HH.B0 ← HF; MEM[T].HH.B1 ← MEM[P].HH.B1 END; P ← MEM[P].HH.RH END END ELSE IF CUR_L < 256 THEN BEGIN MEM[T].HH.RH ← GET_AVAIL; T ← MEM[T].HH.RH; MEM[T].HH.B0 ← HF; MEM[T].HH.B1 ← CUR_L END; LIG_STACK ← 0; BEGIN IF J < N THEN CUR_R ← HU[J + 1] + 0 ELSE CUR_R ← BCHAR; IF ODD (HYF[J]) THEN CUR_RH ← HCHAR ELSE CUR_RH ← 256 END; 22: IF CUR_L = 256 THEN BEGIN K ← BCHAR_LABEL[HF]; IF K = 0 THEN GOTO 30 ELSE Q ← FONT_INFO[K].QQQQ END ELSE BEGIN Q ← FONT_INFO[CHAR_BASE[HF] + CUR_L].QQQQ; IF (Q.B2 - 0) MOD 4 ≠ 1 THEN GOTO 30; K ← LIG_KERN_BASE[HF] + Q.B3; Q ← FONT_INFO[K].QQQQ; IF Q.B0 > 128 THEN BEGIN K ← LIG_KERN_BASE[HF] + 256 * Q.B2 + Q.B3 + 32768 - 256 * 128; Q ← FONT_INFO[K].QQQQ END END; IF CUR_RH < 256 THEN TEST_CHAR ← CUR_RH ELSE TEST_CHAR ← CUR_R; WHILE TRUE DO BEGIN IF Q.B1 = TEST_CHAR THEN IF Q.B0 ≤ 128 THEN IF CUR_RH < 256 THEN BEGIN HYPHEN_PASSED ← J; HCHAR ← 256; CUR_RH ← 256; GOTO 22 END ELSE BEGIN IF HCHAR < 256 THEN IF ODD (HYF[J]) THEN BEGIN HYPHEN_PASSED ← J; HCHAR ← 256 END; IF Q.B2 < 128 THEN BEGIN IF CUR_L = 256 THEN LFT_HIT ← TRUE; IF J = N THEN IF LIG_STACK = 0 THEN RT_HIT ← TRUE; BEGIN IF INTERRUPT ≠ 0 THEN PAUSE_FOR_INSTRUCTIONS END; CASE Q.B2 OF 1, 5: BEGIN CUR_L ← Q.B3; LIGATURE_PRESENT ← TRUE END; 2, 6: BEGIN CUR_R ← Q.B3; IF LIG_STACK > 0 THEN MEM[LIG_STACK].HH.B1 ← CUR_R ELSE BEGIN LIG_STACK ← NEW_LIG_ITEM (CUR_R); IF J = N THEN BCHAR ← 256 ELSE BEGIN P ← GET_AVAIL; MEM[LIG_STACK + 1].HH.RH ← P; MEM[P].HH.B1 ← HU[J + 1] + 0; MEM[P].HH.B0 ← HF END END END; 3: BEGIN CUR_R ← Q.B3; P ← LIG_STACK; LIG_STACK ← NEW_LIG_ITEM (CUR_R); MEM[LIG_STACK].HH.RH ← P END; 7, 11: BEGIN IF LIGATURE_PRESENT THEN BEGIN P ← NEW_LIGATURE (HF, CUR_L, MEM[CUR_Q].HH.RH); IF LFT_HIT THEN BEGIN MEM[P].HH.B1 ← 2; LFT_HIT ← FALSE END; IF FALSE THEN IF LIG_STACK = 0 THEN BEGIN MEM[P].HH.B1 ← MEM[P].HH.B1 + 1; RT_HIT ← FALSE END; MEM[CUR_Q].HH.RH ← P; T ← P; LIGATURE_PRESENT ← FALSE END; CUR_Q ← T; CUR_L ← Q.B3; LIGATURE_PRESENT ← TRUE END; ELSE BEGIN CUR_L ← Q.B3; LIGATURE_PRESENT ← TRUE; IF LIG_STACK > 0 THEN BEGIN IF MEM[LIG_STACK + 1].HH.RH > 0 THEN BEGIN MEM[T].HH.RH ← MEM[LIG_STACK + 1].HH.RH; T ← MEM[T].HH.RH; J ← J + 1 END; P ← LIG_STACK; LIG_STACK ← MEM[P].HH.RH; FREE_NODE (P, 2); IF LIG_STACK = 0 THEN BEGIN IF J < N THEN CUR_R ← HU[J + 1] + 0 ELSE CUR_R ← BCHAR; IF ODD (HYF[J]) THEN CUR_RH ← HCHAR ELSE CUR_RH ← 256 END ELSE CUR_R ← MEM[LIG_STACK].HH.B1 END ELSE IF J = N THEN GOTO 30 ELSE BEGIN BEGIN MEM[T].HH.RH ← GET_AVAIL; T ← MEM[T].HH.RH; MEM[T].HH.B0 ← HF; MEM[T].HH.B1 ← CUR_R END; J ← J + 1; BEGIN IF J < N THEN CUR_R ← HU[J + 1] + 0 ELSE CUR_R ← BCHAR; IF ODD (HYF[J]) THEN CUR_RH ← HCHAR ELSE CUR_RH ← 256 END END END; END; IF Q.B2 > 4 THEN IF Q.B2 ≠ 7 THEN GOTO 30; GOTO 22 END; W ← FONT_INFO[KERN_BASE[HF] + 256 * Q.B2 + Q.B3].INT; GOTO 30 END; IF Q.B0 ≥ 128 THEN IF CUR_RH = 256 THEN GOTO 30 ELSE BEGIN CUR_RH ← 256; GOTO 22 END; K ← K + Q.B0 + 1; Q ← FONT_INFO[K].QQQQ END; 30: ; IF LIGATURE_PRESENT THEN BEGIN P ← NEW_LIGATURE (HF, CUR_L, MEM[CUR_Q].HH.RH); IF LFT_HIT THEN BEGIN MEM[P].HH.B1 ← 2; LFT_HIT ← FALSE END; IF RT_HIT THEN IF LIG_STACK = 0 THEN BEGIN MEM[P].HH.B1 ← MEM[P].HH.B1 + 1; RT_HIT ← FALSE END; MEM[CUR_Q].HH.RH ← P; T ← P; LIGATURE_PRESENT ← FALSE END; IF W ≠ 0 THEN BEGIN MEM[T].HH.RH ← NEW_KERN (W); T ← MEM[T].HH.RH; W ← 0 END; IF LIG_STACK > 0 THEN BEGIN CUR_Q ← T; CUR_L ← MEM[LIG_STACK].HH.B1; LIGATURE_PRESENT ← TRUE; BEGIN IF MEM[LIG_STACK + 1].HH.RH > 0 THEN BEGIN MEM[T].HH.RH ← MEM[LIG_STACK + 1].HH.RH; T ← MEM[T].HH.RH; J ← J + 1 END; P ← LIG_STACK; LIG_STACK ← MEM[P].HH.RH; FREE_NODE (P, 2); IF LIG_STACK = 0 THEN BEGIN IF J < N THEN CUR_R ← HU[J + 1] + 0 ELSE CUR_R ← BCHAR; IF ODD (HYF[J]) THEN CUR_RH ← HCHAR ELSE CUR_RH ← 256 END ELSE CUR_R ← MEM[LIG_STACK].HH.B1 END; GOTO 22 END; RECONSTITUTE ← J END; PROCEDURE HYPHENATE; LABEL 50, 30, 40, 41, 42, 45, 10; VAR I : 0..65; J : 0..65; L : 0..65; Q : HALFWORD; R : HALFWORD; S : HALFWORD; BCHAR : HALFWORD; MAJOR_TAIL : HALFWORD; MINOR_TAIL : HALFWORD; C : ASCII_CODE; C_LOC : 0..63; R_COUNT : INTEGER; HYF_NODE : HALFWORD; Z : TRIE_POINTER; V : INTEGER; H : HYPH_POINTER; K : STR_NUMBER; U : POOL_POINTER; BEGIN FOR J ← 0 TO HN DO HYF[J] ← 0; H ← HC[1]; HN ← HN + 1; HC[HN] ← CUR_LANG; FOR J ← 2 TO HN DO H ← (H + H + HC[J]) MOD 307; WHILE TRUE DO BEGIN K ← HYPH_WORD[H]; IF K = 0 THEN GOTO 45; IF STR_START[K + 1] - STR_START[K] < HN THEN GOTO 45; IF STR_START[K + 1] - STR_START[K] = HN THEN BEGIN J ← 1; U ← STR_START[K]; REPEAT IF STR_POOL[U] < HC[J] THEN GOTO 45; IF STR_POOL[U] > HC[J] THEN GOTO 30; J ← J + 1; U ← U + 1 UNTIL J > HN; S ← HYPH_LIST[H]; WHILE S ≠ 0 DO BEGIN HYF[MEM[S].HH.LH] ← 1; S ← MEM[S].HH.RH END; HN ← HN - 1; GOTO 40 END; 30: ; IF H > 0 THEN H ← H - 1 ELSE H ← 307 END; 45: HN ← HN - 1; IF TRIE[CUR_LANG + 1].B1 ≠ CUR_LANG + 0 THEN GOTO 10; HC[0] ← 0; HC[HN + 1] ← 0; HC[HN + 2] ← 256; FOR J ← 0 TO HN - R_HYF + 1 DO BEGIN Z ← TRIE[CUR_LANG + 1].RH + HC[J]; L ← J; WHILE HC[L] = TRIE[Z].B1 - 0 DO BEGIN IF TRIE[Z].B0 ≠ 0 THEN BEGIN V ← TRIE[Z].B0; REPEAT V ← V + OP_START[CUR_LANG]; I ← L - HYF_DISTANCE[V]; IF HYF_NUM[V] > HYF[I] THEN HYF[I] ← HYF_NUM[V]; V ← HYF_NEXT[V] UNTIL V = 0 END; L ← L + 1; Z ← TRIE[Z].RH + HC[L] END END; 40: FOR J ← 0 TO L_HYF - 1 DO HYF[J] ← 0; FOR J ← 0 TO R_HYF - 1 DO HYF[HN - J] ← 0; FOR J ← L_HYF TO HN - R_HYF DO IF ODD (HYF[J]) THEN GOTO 41; GOTO 10; 41: ; Q ← MEM[HB].HH.RH; MEM[HB].HH.RH ← 0; R ← MEM[HA].HH.RH; MEM[HA].HH.RH ← 0; BCHAR ← HYF_BCHAR; IF HA ≥ HI_MEM_MIN THEN IF MEM[HA].HH.B0 ≠ HF THEN GOTO 42 ELSE BEGIN INIT_LIST ← HA; INIT_LIG ← FALSE; HU[0] ← MEM[HA].HH.B1 - 0 END ELSE IF MEM[HA].HH.B0 = 6 THEN IF MEM[HA + 1].HH.B0 ≠ HF THEN GOTO 42 ELSE BEGIN INIT_LIST ← MEM[HA + 1].HH.RH; INIT_LIG ← TRUE; INIT_LFT ← MEM[HA].HH.B1 > 1; HU[0] ← MEM[HA + 1].HH.B1 - 0; IF INIT_LIST = 0 THEN IF INIT_LFT THEN BEGIN HU[0] ← 256; INIT_LIG ← FALSE END; FREE_NODE (HA, 2) END ELSE BEGIN IF NOT (R ≥ HI_MEM_MIN) THEN IF MEM[R].HH.B0 = 6 THEN IF MEM[R].HH.B1 > 1 THEN GOTO 42; J ← 1; S ← HA; INIT_LIST ← 0; GOTO 50 END; S ← CUR_P; WHILE MEM[S].HH.RH ≠ HA DO S ← MEM[S].HH.RH; J ← 0; GOTO 50; 42: S ← HA; J ← 0; HU[0] ← 256; INIT_LIG ← FALSE; INIT_LIST ← 0; 50: FLUSH_NODE_LIST (R); REPEAT L ← J; J ← RECONSTITUTE (J, HN, BCHAR, HYF_CHAR + 0) + 1; IF HYPHEN_PASSED = 0 THEN BEGIN MEM[S].HH.RH ← MEM[59996].HH.RH; WHILE MEM[S].HH.RH > 0 DO S ← MEM[S].HH.RH; IF ODD (HYF[J - 1]) THEN BEGIN L ← J; HYPHEN_PASSED ← J - 1; MEM[59996].HH.RH ← 0 END END; IF HYPHEN_PASSED > 0 THEN REPEAT R ← GET_NODE (2); MEM[R].HH.RH ← MEM[59996].HH.RH; MEM[R].HH.B0 ← 7; MAJOR_TAIL ← R; R_COUNT ← 0; WHILE MEM[MAJOR_TAIL].HH.RH > 0 DO BEGIN MAJOR_TAIL ← MEM[MAJOR_TAIL].HH.RH; R_COUNT ← R_COUNT + 1 END; I ← HYPHEN_PASSED; HYF[I] ← 0; MINOR_TAIL ← 0; MEM[R + 1].HH.LH ← 0; HYF_NODE ← NEW_CHARACTER (HF, HYF_CHAR); IF HYF_NODE ≠ 0 THEN BEGIN I ← I + 1; C ← HU[I]; HU[I] ← HYF_CHAR; BEGIN MEM[HYF_NODE].HH.RH ← AVAIL; AVAIL ← HYF_NODE END END; WHILE L ≤ I DO BEGIN L ← RECONSTITUTE (L, I, FONT_BCHAR[HF], 256) + 1; IF MEM[59996].HH.RH > 0 THEN BEGIN IF MINOR_TAIL = 0 THEN MEM[R + 1].HH.LH ← MEM[59996].HH.RH ELSE MEM[MINOR_TAIL].HH.RH ← MEM[59996].HH.RH; MINOR_TAIL ← MEM[59996].HH.RH; WHILE MEM[MINOR_TAIL].HH.RH > 0 DO MINOR_TAIL ← MEM[MINOR_TAIL].HH.RH END END; IF HYF_NODE ≠ 0 THEN BEGIN HU[I] ← C; L ← I; I ← I - 1 END; MINOR_TAIL ← 0; MEM[R + 1].HH.RH ← 0; C_LOC ← 0; IF BCHAR_LABEL[HF] ≠ 0 THEN BEGIN L ← L - 1; C ← HU[L]; C_LOC ← L; HU[L] ← 256 END; WHILE L < J DO BEGIN REPEAT L ← RECONSTITUTE (L, HN, BCHAR, 256) + 1; IF C_LOC > 0 THEN BEGIN HU[C_LOC] ← C; C_LOC ← 0 END; IF MEM[59996].HH.RH > 0 THEN BEGIN IF MINOR_TAIL = 0 THEN MEM[R + 1].HH.RH ← MEM[59996].HH.RH ELSE MEM[MINOR_TAIL].HH.RH ← MEM[59996].HH.RH; MINOR_TAIL ← MEM[59996].HH.RH; WHILE MEM[MINOR_TAIL].HH.RH > 0 DO MINOR_TAIL ← MEM[MINOR_TAIL].HH.RH END UNTIL L ≥ J; WHILE L > J DO BEGIN J ← RECONSTITUTE (J, HN, BCHAR, 256) + 1; MEM[MAJOR_TAIL].HH.RH ← MEM[59996].HH.RH; WHILE MEM[MAJOR_TAIL].HH.RH > 0 DO BEGIN MAJOR_TAIL ← MEM[MAJOR_TAIL].HH.RH; R_COUNT ← R_COUNT + 1 END END END; IF R_COUNT > 127 THEN BEGIN MEM[S].HH.RH ← MEM[R].HH.RH; MEM[R].HH.RH ← 0; FLUSH_NODE_LIST (R) END ELSE BEGIN MEM[S].HH.RH ← R; MEM[R].HH.B1 ← R_COUNT END; S ← MAJOR_TAIL; HYPHEN_PASSED ← J - 1; MEM[59996].HH.RH ← 0 UNTIL NOT ODD (HYF[J - 1]) UNTIL J > HN; MEM[S].HH.RH ← Q; FLUSH_LIST (INIT_LIST); 10: END; FUNCTION NEW_TRIE_OP (D:SMALL_NUMBER; N:SMALL_NUMBER; V:QUARTERWORD):QUARTERWORD; LABEL 10; VAR H : -TRIE_OP_SIZE..TRIE_OP_SIZE; U : QUARTERWORD; L : 0..TRIE_OP_SIZE; BEGIN H ← ABS ((N + 313 * D + 361 * V + 1009 * CUR_LANG)) MOD (TRIE_OP_SIZE + TRIE_OP_SIZE) - TRIE_OP_SIZE; WHILE TRUE DO BEGIN L ← TRIE_OP_HASH[H]; IF L = 0 THEN BEGIN IF TRIE_OP_PTR = TRIE_OP_SIZE THEN OVERFLOW (949, TRIE_OP_SIZE); U ← TRIE_USED[CUR_LANG]; IF U = 255 THEN OVERFLOW (950, 255); TRIE_OP_PTR ← TRIE_OP_PTR + 1; U ← U + 1; TRIE_USED[CUR_LANG] ← U; HYF_DISTANCE[TRIE_OP_PTR] ← D; HYF_NUM[TRIE_OP_PTR] ← N; HYF_NEXT[TRIE_OP_PTR] ← V; TRIE_OP_LANG[TRIE_OP_PTR] ← CUR_LANG; TRIE_OP_HASH[H] ← TRIE_OP_PTR; TRIE_OP_VAL[TRIE_OP_PTR] ← U; NEW_TRIE_OP ← U; GOTO 10 END; IF (HYF_DISTANCE[L] = D) AND (HYF_NUM[L] = N) AND (HYF_NEXT[L] = V) AND (TRIE_OP_LANG[L] = CUR_LANG) THEN BEGIN NEW_TRIE_OP ← TRIE_OP_VAL[L]; GOTO 10 END; IF H > -TRIE_OP_SIZE THEN H ← H - 1 ELSE H ← TRIE_OP_SIZE END; 10: END; FUNCTION TRIE_NODE (P:TRIE_POINTER):TRIE_POINTER; LABEL 10; VAR H : TRIE_POINTER; Q : TRIE_POINTER; BEGIN H ← ABS ((TRIE_C[P] + 1009 * TRIE_O[P] + 2718 * TRIE_L[P] + 3142 * TRIE_R[P])) MOD TRIE_SIZE; WHILE TRUE DO BEGIN Q ← TRIE_HASH[H]; IF Q = 0 THEN BEGIN TRIE_HASH[H] ← P; TRIE_NODE ← P; GOTO 10 END; IF (TRIE_C[Q] = TRIE_C[P]) AND (TRIE_O[Q] = TRIE_O[P]) AND (TRIE_L[Q] = TRIE_L[P]) AND (TRIE_R[Q] = TRIE_R[P]) THEN BEGIN TRIE_NODE ← Q; GOTO 10 END; IF H > 0 THEN H ← H - 1 ELSE H ← TRIE_SIZE END; 10: END; FUNCTION COMPRESS_TRIE (P:TRIE_POINTER):TRIE_POINTER; BEGIN IF P = 0 THEN COMPRESS_TRIE ← 0 ELSE BEGIN TRIE_L[P] ← COMPRESS_TRIE (TRIE_L[P]); TRIE_R[P] ← COMPRESS_TRIE (TRIE_R[P]); COMPRESS_TRIE ← TRIE_NODE (P) END END; PROCEDURE FIRST_FIT (P:TRIE_POINTER); LABEL 45, 40; VAR H : TRIE_POINTER; Z : TRIE_POINTER; Q : TRIE_POINTER; C : ASCII_CODE; L : TRIE_POINTER; R : TRIE_POINTER; LL : 1..256; BEGIN C ← TRIE_C[P]; Z ← TRIE_MIN[C]; WHILE TRUE DO BEGIN H ← Z - C; IF TRIE_MAX < H + 256 THEN BEGIN IF TRIE_SIZE ≤ H + 256 THEN OVERFLOW (951, TRIE_SIZE); REPEAT TRIE_MAX ← TRIE_MAX + 1; TRIE_TAKEN[TRIE_MAX] ← FALSE; TRIE[TRIE_MAX].RH ← TRIE_MAX + 1; TRIE[TRIE_MAX].LH ← TRIE_MAX - 1 UNTIL TRIE_MAX = H + 256 END; IF TRIE_TAKEN[H] THEN GOTO 45; Q ← TRIE_R[P]; WHILE Q > 0 DO BEGIN IF TRIE[H + TRIE_C[Q]].RH = 0 THEN GOTO 45; Q ← TRIE_R[Q] END; GOTO 40; 45: Z ← TRIE[Z].RH END; 40: TRIE_TAKEN[H] ← TRUE; TRIE_HASH[P] ← H; Q ← P; REPEAT Z ← H + TRIE_C[Q]; L ← TRIE[Z].LH; R ← TRIE[Z].RH; TRIE[R].LH ← L; TRIE[L].RH ← R; TRIE[Z].RH ← 0; IF L < 256 THEN BEGIN IF Z < 256 THEN LL ← Z ELSE LL ← 256; REPEAT TRIE_MIN[L] ← R; L ← L + 1 UNTIL L = LL END; Q ← TRIE_R[Q] UNTIL Q = 0 END; PROCEDURE TRIE_PACK (P:TRIE_POINTER); VAR Q : TRIE_POINTER; BEGIN REPEAT Q ← TRIE_L[P]; IF (Q > 0) AND (TRIE_HASH[Q] = 0) THEN BEGIN FIRST_FIT (Q); TRIE_PACK (Q) END; P ← TRIE_R[P] UNTIL P = 0 END; PROCEDURE TRIE_FIX (P:TRIE_POINTER); VAR Q : TRIE_POINTER; C : ASCII_CODE; Z : TRIE_POINTER; BEGIN Z ← TRIE_HASH[P]; REPEAT Q ← TRIE_L[P]; C ← TRIE_C[P]; TRIE[Z + C].RH ← TRIE_HASH[Q]; TRIE[Z + C].B1 ← C + 0; TRIE[Z + C].B0 ← TRIE_O[P]; IF Q > 0 THEN TRIE_FIX (Q); P ← TRIE_R[P] UNTIL P = 0 END; PROCEDURE NEW_PATTERNS; LABEL 30, 31; VAR K : 0..64; L : 0..64; DIGIT_SENSED : BOOLEAN; V : QUARTERWORD; P : TRIE_POINTER; Q : TRIE_POINTER; FIRST_CHILD : BOOLEAN; C : ASCII_CODE; BEGIN IF TRIE_NOT_READY THEN BEGIN IF EQTB[9213].INT ≤ 0 THEN CUR_LANG ← 0 ELSE IF EQTB[9213].INT > 255 THEN CUR_LANG ← 0 ELSE CUR_LANG ← EQTB[9213].INT; SCAN_LEFT_BRACE; K ← 0; HYF[0] ← 0; DIGIT_SENSED ← FALSE; WHILE TRUE DO BEGIN GET_X_TOKEN; CASE CUR_CMD OF 11, 12: IF DIGIT_SENSED OR (CUR_CHR < 48) OR (CUR_CHR > 57) THEN BEGIN IF CUR_CHR = 46 THEN CUR_CHR ← 0 ELSE BEGIN CUR_CHR ← EQTB[8139 + CUR_CHR].HH.RH; IF CUR_CHR = 0 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (957) END; BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 956 END; ERROR END END; IF K < 63 THEN BEGIN K ← K + 1; HC[K] ← CUR_CHR; HYF[K] ← 0; DIGIT_SENSED ← FALSE END END ELSE IF K < 63 THEN BEGIN HYF[K] ← CUR_CHR - 48; DIGIT_SENSED ← TRUE END; 10, 2: BEGIN IF K > 0 THEN BEGIN IF HC[1] = 0 THEN HYF[0] ← 0; IF HC[K] = 0 THEN HYF[K] ← 0; L ← K; V ← 0; WHILE TRUE DO BEGIN IF HYF[L] ≠ 0 THEN V ← NEW_TRIE_OP (K - L, HYF[L], V); IF L > 0 THEN L ← L - 1 ELSE GOTO 31 END; 31: ; Q ← 0; HC[0] ← CUR_LANG; WHILE L ≤ K DO BEGIN C ← HC[L]; L ← L + 1; P ← TRIE_L[Q]; FIRST_CHILD ← TRUE; WHILE (P > 0) AND (C > TRIE_C[P]) DO BEGIN Q ← P; P ← TRIE_R[Q]; FIRST_CHILD ← FALSE END; IF (P = 0) OR (C < TRIE_C[P]) THEN BEGIN IF TRIE_PTR = TRIE_SIZE THEN OVERFLOW (951, TRIE_SIZE); TRIE_PTR ← TRIE_PTR + 1; TRIE_R[TRIE_PTR] ← P; P ← TRIE_PTR; TRIE_L[P] ← 0; IF FIRST_CHILD THEN TRIE_L[Q] ← P ELSE TRIE_R[Q] ← P; TRIE_C[P] ← C; TRIE_O[P] ← 0 END; Q ← P END; IF TRIE_O[Q] ≠ 0 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (958) END; BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 956 END; ERROR END; TRIE_O[Q] ← V END; IF CUR_CMD = 2 THEN GOTO 30; K ← 0; HYF[0] ← 0; DIGIT_SENSED ← FALSE END; ELSE BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (955) END; PRINT_ESC (953); BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 956 END; ERROR END; END END; 30: END ELSE BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (952) END; PRINT_ESC (953); BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 954 END; ERROR; MEM[59988].HH.RH ← SCAN_TOKS (FALSE, FALSE); FLUSH_LIST (DEF_REF) END END; PROCEDURE INIT_TRIE; VAR P : TRIE_POINTER; J : INTEGER; K : INTEGER; T : INTEGER; R : TRIE_POINTER; S : TRIE_POINTER; H : TWO_HALVES; BEGIN OP_START[0] ← -0; FOR J ← 1 TO 255 DO OP_START[J] ← OP_START[J - 1] + TRIE_USED[J - 1] - 0; FOR J ← 1 TO TRIE_OP_PTR DO TRIE_OP_HASH[J] ← OP_START[TRIE_OP_LANG[J]] + TRIE_OP_VAL[J]; FOR J ← 1 TO TRIE_OP_PTR DO WHILE TRIE_OP_HASH[J] > J DO BEGIN K ← TRIE_OP_HASH[J]; T ← HYF_DISTANCE[K]; HYF_DISTANCE[K] ← HYF_DISTANCE[J]; HYF_DISTANCE[J] ← T; T ← HYF_NUM[K]; HYF_NUM[K] ← HYF_NUM[J]; HYF_NUM[J] ← T; T ← HYF_NEXT[K]; HYF_NEXT[K] ← HYF_NEXT[J]; HYF_NEXT[J] ← T; TRIE_OP_HASH[J] ← TRIE_OP_HASH[K]; TRIE_OP_HASH[K] ← K END; FOR P ← 0 TO TRIE_SIZE DO TRIE_HASH[P] ← 0; TRIE_L[0] ← COMPRESS_TRIE (TRIE_L[0]); FOR P ← 0 TO TRIE_PTR DO TRIE_HASH[P] ← 0; FOR P ← 0 TO 255 DO TRIE_MIN[P] ← P + 1; TRIE[0].RH ← 1; TRIE_MAX ← 0; IF TRIE_L[0] ≠ 0 THEN BEGIN FIRST_FIT (TRIE_L[0]); TRIE_PACK (TRIE_L[0]) END; H.RH ← 0; H.B0 ← 0; H.B1 ← 0; IF TRIE_L[0] = 0 THEN BEGIN FOR R ← 0 TO 256 DO TRIE[R] ← H; TRIE_MAX ← 256 END ELSE BEGIN TRIE_FIX (TRIE_L[0]); R ← 0; REPEAT S ← TRIE[R].RH; TRIE[R] ← H; R ← S UNTIL R > TRIE_MAX END; TRIE[0].B1 ← 63; TRIE_NOT_READY ← FALSE END; PROCEDURE LINE_BREAK (FINAL_WIDOW_PENALTY:INTEGER); LABEL 30, 31, 32, 33, 34, 35, 22; VAR AUTO_BREAKING : BOOLEAN; PREV_P : HALFWORD; Q : HALFWORD; R : HALFWORD; S : HALFWORD; PREV_S : HALFWORD; F : INTERNAL_FONT_NUMBER; J : SMALL_NUMBER; C : 0..255; BEGIN PACK_BEGIN_LINE ← CUR_LIST.ML_FIELD; MEM[59997].HH.RH ← MEM[CUR_LIST.HEAD_FIELD].HH.RH; IF CUR_LIST.TAIL_FIELD ≥ HI_MEM_MIN THEN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_PENALTY (10000); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END ELSE IF MEM[CUR_LIST.TAIL_FIELD].HH.B0 ≠ 10 THEN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_PENALTY (10000); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END ELSE BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.B0 ← 12; DELETE_GLUE_REF (MEM[CUR_LIST.TAIL_FIELD + 1].HH.LH); FLUSH_NODE_LIST (MEM[CUR_LIST.TAIL_FIELD + 1].HH.RH); MEM[CUR_LIST.TAIL_FIELD + 1].INT ← 10000 END; MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_PARAM_GLUE (14); INIT_CUR_LANG ← CUR_LIST.PG_FIELD MOD 65536; INIT_L_HYF ← CUR_LIST.PG_FIELD DIV 4194304; INIT_R_HYF ← CUR_LIST.PG_FIELD DIV 65536 MOD 64; POP_NEST; NO_SHRINK_ERROR_YET ← TRUE; IF (MEM[EQTB[6789].HH.RH].HH.B1 ≠ 0) AND (MEM[EQTB[6789].HH.RH + 3].INT ≠ 0) THEN BEGIN EQTB[6789].HH.RH ← FINITE_SHRINK (EQTB[6789].HH.RH) END; IF (MEM[EQTB[6790].HH.RH].HH.B1 ≠ 0) AND (MEM[EQTB[6790].HH.RH + 3].INT ≠ 0) THEN BEGIN EQTB[6790].HH.RH ← FINITE_SHRINK (EQTB[6790].HH.RH) END; Q ← EQTB[6789].HH.RH; R ← EQTB[6790].HH.RH; BACKGROUND[1] ← MEM[Q + 1].INT + MEM[R + 1].INT; BACKGROUND[2] ← 0; BACKGROUND[3] ← 0; BACKGROUND[4] ← 0; BACKGROUND[5] ← 0; BACKGROUND[2 + MEM[Q].HH.B0] ← MEM[Q + 2].INT; BACKGROUND[2 + MEM[R].HH.B0] ← BACKGROUND[2 + MEM[R].HH.B0] + MEM[R + 2].INT; BACKGROUND[6] ← MEM[Q + 3].INT + MEM[R + 3].INT; MINIMUM_DEMERITS ← 1073741823; MINIMAL_DEMERITS[3] ← 1073741823; MINIMAL_DEMERITS[2] ← 1073741823; MINIMAL_DEMERITS[1] ← 1073741823; MINIMAL_DEMERITS[0] ← 1073741823; IF EQTB[7312].HH.RH = 0 THEN IF EQTB[9747].INT = 0 THEN BEGIN LAST_SPECIAL_LINE ← 0; SECOND_WIDTH ← EQTB[9733].INT; SECOND_INDENT ← 0 END ELSE BEGIN LAST_SPECIAL_LINE ← ABS (EQTB[9204].INT); IF EQTB[9204].INT < 0 THEN BEGIN FIRST_WIDTH ← EQTB[9733].INT - ABS (EQTB[9747].INT); IF EQTB[9747].INT ≥ 0 THEN FIRST_INDENT ← EQTB[9747].INT ELSE FIRST_INDENT ← 0; SECOND_WIDTH ← EQTB[9733].INT; SECOND_INDENT ← 0 END ELSE BEGIN FIRST_WIDTH ← EQTB[9733].INT; FIRST_INDENT ← 0; SECOND_WIDTH ← EQTB[9733].INT - ABS (EQTB[9747].INT); IF EQTB[9747].INT ≥ 0 THEN SECOND_INDENT ← EQTB[9747].INT ELSE SECOND_INDENT ← 0 END END ELSE BEGIN LAST_SPECIAL_LINE ← MEM[EQTB[7312].HH.RH].HH.LH - 1; SECOND_WIDTH ← MEM[EQTB[7312].HH.RH + 2 * (LAST_SPECIAL_LINE + 1)].INT; SECOND_INDENT ← MEM[EQTB[7312].HH.RH + 2 * LAST_SPECIAL_LINE + 1].INT END; IF EQTB[9182].INT = 0 THEN EASY_LINE ← LAST_SPECIAL_LINE ELSE EASY_LINE ← 65535; THRESHOLD ← EQTB[9163].INT; IF THRESHOLD ≥ 0 THEN BEGIN SECOND_PASS ← FALSE; FINAL_PASS ← FALSE END ELSE BEGIN THRESHOLD ← EQTB[9164].INT; SECOND_PASS ← TRUE; FINAL_PASS ← EQTB[9750].INT ≤ 0 END; WHILE TRUE DO BEGIN IF THRESHOLD > 10000 THEN THRESHOLD ← 10000; IF SECOND_PASS THEN BEGIN IF TRIE_NOT_READY THEN INIT_TRIE; CUR_LANG ← INIT_CUR_LANG; L_HYF ← INIT_L_HYF; R_HYF ← INIT_R_HYF END; Q ← GET_NODE (3); MEM[Q].HH.B0 ← 0; MEM[Q].HH.B1 ← 2; MEM[Q].HH.RH ← 59993; MEM[Q + 1].HH.RH ← 0; MEM[Q + 1].HH.LH ← CUR_LIST.PG_FIELD + 1; MEM[Q + 2].INT ← 0; MEM[59993].HH.RH ← Q; ACTIVE_WIDTH[1] ← BACKGROUND[1]; ACTIVE_WIDTH[2] ← BACKGROUND[2]; ACTIVE_WIDTH[3] ← BACKGROUND[3]; ACTIVE_WIDTH[4] ← BACKGROUND[4]; ACTIVE_WIDTH[5] ← BACKGROUND[5]; ACTIVE_WIDTH[6] ← BACKGROUND[6]; PASSIVE ← 0; PRINTED_NODE ← 59997; PASS_NUMBER ← 0; FONT_IN_SHORT_DISPLAY ← 0; CUR_P ← MEM[59997].HH.RH; AUTO_BREAKING ← TRUE; PREV_P ← CUR_P; WHILE (CUR_P ≠ 0) AND (MEM[59993].HH.RH ≠ 59993) DO BEGIN IF CUR_P ≥ HI_MEM_MIN THEN BEGIN PREV_P ← CUR_P; REPEAT F ← MEM[CUR_P].HH.B0; ACTIVE_WIDTH[1] ← ACTIVE_WIDTH[1] + FONT_INFO[WIDTH_BASE[F] + FONT_INFO[CHAR_BASE[F] + MEM[CUR_P].HH.B1].QQQQ.B0]. INT; CUR_P ← MEM[CUR_P].HH.RH UNTIL NOT (CUR_P ≥ HI_MEM_MIN) END; CASE MEM[CUR_P].HH.B0 OF 0,1,2: ACTIVE_WIDTH[1] ← ACTIVE_WIDTH[1] + MEM[CUR_P + 1].INT; 8: IF MEM[CUR_P].HH.B1 = 4 THEN BEGIN CUR_LANG ← MEM[CUR_P + 1].HH.RH; L_HYF ← MEM[CUR_P + 1].HH.B0; R_HYF ← MEM[CUR_P + 1].HH.B1 END; 10: BEGIN IF AUTO_BREAKING THEN BEGIN IF PREV_P ≥ HI_MEM_MIN THEN TRY_BREAK (0, 0) ELSE IF MEM[PREV_P].HH.B0 < 9 THEN TRY_BREAK (0, 0) ELSE IF (MEM[PREV_P].HH.B0 = 11) AND (MEM[PREV_P].HH.B1 ≠ 1) THEN TRY_BREAK (0, 0) END; IF (MEM[MEM[CUR_P + 1].HH.LH].HH.B1 ≠ 0) AND (MEM[MEM[CUR_P + 1].HH.LH + 3].INT ≠ 0) THEN BEGIN MEM[CUR_P + 1].HH.LH ← FINITE_SHRINK (MEM[CUR_P + 1].HH.LH) END; Q ← MEM[CUR_P + 1].HH.LH; ACTIVE_WIDTH[1] ← ACTIVE_WIDTH[1] + MEM[Q + 1].INT; ACTIVE_WIDTH[2 + MEM[Q].HH.B0] ← ACTIVE_WIDTH[2 + MEM[Q].HH.B0] + MEM[Q + 2].INT; ACTIVE_WIDTH[6] ← ACTIVE_WIDTH[6] + MEM[Q + 3].INT; IF SECOND_PASS AND AUTO_BREAKING THEN BEGIN PREV_S ← CUR_P; S ← MEM[PREV_S].HH.RH; IF S ≠ 0 THEN BEGIN WHILE TRUE DO BEGIN IF S ≥ HI_MEM_MIN THEN BEGIN C ← MEM[S].HH.B1 - 0; HF ← MEM[S].HH.B0 END ELSE IF MEM[S].HH.B0 = 6 THEN IF MEM[S + 1].HH.RH = 0 THEN GOTO 22 ELSE BEGIN Q ← MEM[S + 1].HH.RH; C ← MEM[Q].HH.B1 - 0; HF ← MEM[Q].HH.B0 END ELSE IF (MEM[S].HH.B0 = 11) AND (MEM[S].HH.B1 = 0) THEN GOTO 22 ELSE IF MEM[S].HH.B0 = 8 THEN BEGIN IF MEM[S].HH.B1 = 4 THEN BEGIN CUR_LANG ← MEM[S + 1].HH.RH; L_HYF ← MEM[S + 1].HH.B0; R_HYF ← MEM[S + 1].HH.B1 END; GOTO 22 END ELSE GOTO 31; IF EQTB[8139 + C].HH.RH ≠ 0 THEN IF (EQTB[8139 + C].HH.RH = C) OR (EQTB[9201].INT > 0) THEN GOTO 32 ELSE GOTO 31; 22: PREV_S ← S; S ← MEM[PREV_S].HH.RH END; 32: HYF_CHAR ← HYPHEN_CHAR[HF]; IF HYF_CHAR < 0 THEN GOTO 31; IF HYF_CHAR > 255 THEN GOTO 31; HA ← PREV_S; IF L_HYF + R_HYF > 63 THEN GOTO 31; HN ← 0; WHILE TRUE DO BEGIN IF S ≥ HI_MEM_MIN THEN BEGIN IF MEM[S].HH.B0 ≠ HF THEN GOTO 33; HYF_BCHAR ← MEM[S].HH.B1; C ← HYF_BCHAR - 0; IF EQTB[8139 + C].HH.RH = 0 THEN GOTO 33; IF HN = 63 THEN GOTO 33; HB ← S; HN ← HN + 1; HU[HN] ← C; HC[HN] ← EQTB[8139 + C].HH.RH; HYF_BCHAR ← 256 END ELSE IF MEM[S].HH.B0 = 6 THEN BEGIN IF MEM[S + 1].HH.B0 ≠ HF THEN GOTO 33; J ← HN; Q ← MEM[S + 1].HH.RH; IF Q > 0 THEN HYF_BCHAR ← MEM[Q].HH.B1; WHILE Q > 0 DO BEGIN C ← MEM[Q].HH.B1 - 0; IF EQTB[8139 + C].HH.RH = 0 THEN GOTO 33; IF J = 63 THEN GOTO 33; J ← J + 1; HU[J] ← C; HC[J] ← EQTB[8139 + C].HH.RH; Q ← MEM[Q].HH.RH END; HB ← S; HN ← J; IF ODD (MEM[S].HH.B1) THEN HYF_BCHAR ← FONT_BCHAR[HF] ELSE HYF_BCHAR ← 256 END ELSE IF (MEM[S].HH.B0 = 11) AND (MEM[S].HH.B1 = 0) THEN BEGIN HB ← S; HYF_BCHAR ← FONT_BCHAR[HF] END ELSE GOTO 33; S ← MEM[S].HH.RH END; 33: ; IF HN < L_HYF + R_HYF THEN GOTO 31; WHILE TRUE DO BEGIN IF NOT (S ≥ HI_MEM_MIN) THEN CASE MEM[S].HH.B0 OF 6: ; 11: IF MEM[S].HH.B1 ≠ 0 THEN GOTO 34; 8,10,12,3,5,4: GOTO 34; ELSE GOTO 31; END; S ← MEM[S].HH.RH END; 34: ; HYPHENATE END; 31: END END; 11: IF MEM[CUR_P].HH.B1 = 1 THEN BEGIN IF NOT (MEM[CUR_P].HH.RH ≥ HI_MEM_MIN) AND AUTO_BREAKING THEN IF MEM[MEM[CUR_P].HH.RH].HH.B0 = 10 THEN TRY_BREAK (0, 0); ACTIVE_WIDTH[1] ← ACTIVE_WIDTH[1] + MEM[CUR_P + 1].INT END ELSE ACTIVE_WIDTH[1] ← ACTIVE_WIDTH[1] + MEM[CUR_P + 1].INT; 6: BEGIN F ← MEM[CUR_P + 1].HH.B0; ACTIVE_WIDTH[1] ← ACTIVE_WIDTH[1] + FONT_INFO[ WIDTH_BASE[F] + FONT_INFO[CHAR_BASE[F] + MEM[CUR_P + 1].HH.B1].QQQQ.B0]. INT END; 7: BEGIN S ← MEM[CUR_P + 1].HH.LH; DISC_WIDTH ← 0; IF S = 0 THEN TRY_BREAK (EQTB[9167].INT, 1) ELSE BEGIN REPEAT IF S ≥ HI_MEM_MIN THEN BEGIN F ← MEM[S].HH.B0; DISC_WIDTH ← DISC_WIDTH + FONT_INFO[ WIDTH_BASE[F] + FONT_INFO[CHAR_BASE[F] + MEM[S].HH.B1].QQQQ.B0]. INT END ELSE CASE MEM[S].HH.B0 OF 6: BEGIN F ← MEM[S + 1].HH.B0; DISC_WIDTH ← DISC_WIDTH + FONT_INFO[ WIDTH_BASE[F] + FONT_INFO[CHAR_BASE[F] + MEM[S + 1].HH.B1].QQQQ.B0]. INT END; 0,1,2,11: DISC_WIDTH ← DISC_WIDTH + MEM[S + 1].INT; ELSE CONFUSION (937); END; S ← MEM[S].HH.RH UNTIL S = 0; ACTIVE_WIDTH[1] ← ACTIVE_WIDTH[1] + DISC_WIDTH; TRY_BREAK (EQTB[9166].INT, 1); ACTIVE_WIDTH[1] ← ACTIVE_WIDTH[1] - DISC_WIDTH END; R ← MEM[CUR_P].HH.B1; S ← MEM[CUR_P].HH.RH; WHILE R > 0 DO BEGIN IF S ≥ HI_MEM_MIN THEN BEGIN F ← MEM[S].HH.B0; ACTIVE_WIDTH[1] ← ACTIVE_WIDTH[1] + FONT_INFO[ WIDTH_BASE[F] + FONT_INFO[CHAR_BASE[F] + MEM[S].HH.B1].QQQQ.B0]. INT END ELSE CASE MEM[S].HH.B0 OF 6: BEGIN F ← MEM[S + 1].HH.B0; ACTIVE_WIDTH[1] ← ACTIVE_WIDTH[1] + FONT_INFO[ WIDTH_BASE[F] + FONT_INFO[CHAR_BASE[F] + MEM[S + 1].HH.B1].QQQQ.B0]. INT END; 0,1,2,11: ACTIVE_WIDTH[1] ← ACTIVE_WIDTH[1] + MEM[S + 1].INT; ELSE CONFUSION (938); END; R ← R - 1; S ← MEM[S].HH.RH END; PREV_P ← CUR_P; CUR_P ← S; GOTO 35 END; 9: BEGIN AUTO_BREAKING ← MEM[CUR_P].HH.B1 = 1; BEGIN IF NOT (MEM[CUR_P].HH.RH ≥ HI_MEM_MIN) AND AUTO_BREAKING THEN IF MEM[MEM[CUR_P].HH.RH].HH.B0 = 10 THEN TRY_BREAK (0, 0); ACTIVE_WIDTH[1] ← ACTIVE_WIDTH[1] + MEM[CUR_P + 1].INT END END; 12: TRY_BREAK (MEM[CUR_P + 1].INT, 0); 4,3,5: ; ELSE CONFUSION (936); END; PREV_P ← CUR_P; CUR_P ← MEM[CUR_P].HH.RH; 35: END; IF CUR_P = 0 THEN BEGIN TRY_BREAK (-10000, 1); IF MEM[59993].HH.RH ≠ 59993 THEN BEGIN R ← MEM[59993].HH.RH; FEWEST_DEMERITS ← 1073741823; REPEAT IF MEM[R].HH.B0 ≠ 2 THEN IF MEM[R + 2].INT < FEWEST_DEMERITS THEN BEGIN FEWEST_DEMERITS ← MEM[R + 2].INT; BEST_BET ← R END; R ← MEM[R].HH.RH UNTIL R = 59993; BEST_LINE ← MEM[BEST_BET + 1].HH.LH; IF EQTB[9182].INT = 0 THEN GOTO 30; BEGIN R ← MEM[59993].HH.RH; ACTUAL_LOOSENESS ← 0; REPEAT IF MEM[R].HH.B0 ≠ 2 THEN BEGIN LINE_DIFF ← MEM[R + 1].HH.LH - BEST_LINE; IF (LINE_DIFF < ACTUAL_LOOSENESS) AND (EQTB[9182].INT ≤ LINE_DIFF) OR (LINE_DIFF > ACTUAL_LOOSENESS) AND (EQTB[9182].INT ≥ LINE_DIFF) THEN BEGIN BEST_BET ← R; ACTUAL_LOOSENESS ← LINE_DIFF; FEWEST_DEMERITS ← MEM[R + 2].INT END ELSE IF (LINE_DIFF = ACTUAL_LOOSENESS) AND (MEM[R + 2].INT < FEWEST_DEMERITS) THEN BEGIN BEST_BET ← R; FEWEST_DEMERITS ← MEM[R + 2].INT END END; R ← MEM[R].HH.RH UNTIL R = 59993; BEST_LINE ← MEM[BEST_BET + 1].HH.LH END; IF (ACTUAL_LOOSENESS = EQTB[9182].INT) OR FINAL_PASS THEN GOTO 30 END END; Q ← MEM[59993].HH.RH; WHILE Q ≠ 59993 DO BEGIN CUR_P ← MEM[Q].HH.RH; IF MEM[Q].HH.B0 = 2 THEN FREE_NODE (Q, 7) ELSE FREE_NODE (Q, 3); Q ← CUR_P END; Q ← PASSIVE; WHILE Q ≠ 0 DO BEGIN CUR_P ← MEM[Q].HH.RH; FREE_NODE (Q, 2); Q ← CUR_P END; IF NOT SECOND_PASS THEN BEGIN THRESHOLD ← EQTB[9164].INT; SECOND_PASS ← TRUE; FINAL_PASS ← EQTB[9750].INT ≤ 0 END ELSE BEGIN BACKGROUND[2] ← BACKGROUND[2] + EQTB[9750].INT; FINAL_PASS ← TRUE END END; 30: ; POST_LINE_BREAK (FINAL_WIDOW_PENALTY); Q ← MEM[59993].HH.RH; WHILE Q ≠ 59993 DO BEGIN CUR_P ← MEM[Q].HH.RH; IF MEM[Q].HH.B0 = 2 THEN FREE_NODE (Q, 7) ELSE FREE_NODE (Q, 3); Q ← CUR_P END; Q ← PASSIVE; WHILE Q ≠ 0 DO BEGIN CUR_P ← MEM[Q].HH.RH; FREE_NODE (Q, 2); Q ← CUR_P END; PACK_BEGIN_LINE ← 0 END; PROCEDURE NEW_HYPH_EXCEPTIONS; LABEL 21, 10, 40, 45; VAR N : 0..64; J : 0..64; H : HYPH_POINTER; K : STR_NUMBER; P : HALFWORD; Q : HALFWORD; S : STR_NUMBER; T : STR_NUMBER; U : POOL_POINTER; V : POOL_POINTER; BEGIN SCAN_LEFT_BRACE; IF EQTB[9213].INT ≤ 0 THEN CUR_LANG ← 0 ELSE IF EQTB[9213].INT > 255 THEN CUR_LANG ← 0 ELSE CUR_LANG ← EQTB[9213].INT; N ← 0; P ← 0; WHILE TRUE DO BEGIN GET_X_TOKEN; 21: CASE CUR_CMD OF 11,12, 68: IF CUR_CHR = 45 THEN BEGIN IF N < 63 THEN BEGIN Q ← GET_AVAIL; MEM[Q].HH.RH ← P; MEM[Q].HH.LH ← N; P ← Q END END ELSE BEGIN IF EQTB[8139 + CUR_CHR].HH.RH = 0 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (945) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 946; HELP_LINE[0] ← 947 END; ERROR END ELSE IF N < 63 THEN BEGIN N ← N + 1; HC[N] ← EQTB[8139 + CUR_CHR].HH.RH END END; 16: BEGIN SCAN_CHAR_NUM; CUR_CHR ← CUR_VAL; CUR_CMD ← 68; GOTO 21 END; 10, 2: BEGIN IF N > 1 THEN BEGIN N ← N + 1; HC[N] ← CUR_LANG; BEGIN IF POOL_PTR + N > POOL_SIZE THEN OVERFLOW (257, POOL_SIZE - INIT_POOL_PTR) END; H ← 0; FOR J ← 1 TO N DO BEGIN H ← (H + H + HC[J]) MOD 307; BEGIN STR_POOL[POOL_PTR] ← HC[J]; POOL_PTR ← POOL_PTR + 1 END END; S ← MAKE_STRING; IF HYPH_COUNT = 307 THEN OVERFLOW (948, 307); HYPH_COUNT ← HYPH_COUNT + 1; WHILE HYPH_WORD[H] ≠ 0 DO BEGIN K ← HYPH_WORD[H]; IF STR_START[K + 1] - STR_START[K] < STR_START[S + 1] - STR_START[S] THEN GOTO 40; IF STR_START[K + 1] - STR_START[K] > STR_START[S + 1] - STR_START[S] THEN GOTO 45; U ← STR_START[K]; V ← STR_START[S]; REPEAT IF STR_POOL[U] < STR_POOL[V] THEN GOTO 40; IF STR_POOL[U] > STR_POOL[V] THEN GOTO 45; U ← U + 1; V ← V + 1 UNTIL U = STR_START[K + 1]; 40: Q ← HYPH_LIST[H]; HYPH_LIST[H] ← P; P ← Q; T ← HYPH_WORD[H]; HYPH_WORD[H] ← S; S ← T; 45: ; IF H > 0 THEN H ← H - 1 ELSE H ← 307 END; HYPH_WORD[H] ← S; HYPH_LIST[H] ← P END; IF CUR_CMD = 2 THEN GOTO 10; N ← 0; P ← 0 END; ELSE BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (680) END; PRINT_ESC (941); PRINT (942); BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 943; HELP_LINE[0] ← 944 END; ERROR END; END END; 10: END; FUNCTION PRUNE_PAGE_TOP (P:HALFWORD):HALFWORD; VAR PREV_P : HALFWORD; Q : HALFWORD; BEGIN PREV_P ← 59997; MEM[59997].HH.RH ← P; WHILE P ≠ 0 DO CASE MEM[P].HH.B0 OF 0,1, 2: BEGIN Q ← NEW_SKIP_PARAM (10); MEM[PREV_P].HH.RH ← Q; MEM[Q].HH.RH ← P; IF MEM[TEMP_PTR + 1].INT > MEM[P + 3].INT THEN MEM[TEMP_PTR + 1].INT ← MEM[TEMP_PTR + 1].INT - MEM[P + 3].INT ELSE MEM[TEMP_PTR + 1].INT ← 0; P ← 0 END; 8,4, 3: BEGIN PREV_P ← P; P ← MEM[PREV_P].HH.RH END; 10,11, 12: BEGIN Q ← P; P ← MEM[Q].HH.RH; MEM[Q].HH.RH ← 0; MEM[PREV_P].HH.RH ← P; FLUSH_NODE_LIST (Q) END; ELSE CONFUSION (959); END; PRUNE_PAGE_TOP ← MEM[59997].HH.RH END; FUNCTION VERT_BREAK (P:HALFWORD; H:SCALED; D:SCALED):HALFWORD; LABEL 30, 45, 90; VAR PREV_P : HALFWORD; Q : HALFWORD; R : HALFWORD; PI : INTEGER; B : INTEGER; LEAST_COST : INTEGER; BEST_PLACE : HALFWORD; PREV_DP : SCALED; T : SMALL_NUMBER; BEGIN PREV_P ← P; LEAST_COST ← 1073741823; ACTIVE_WIDTH[1] ← 0; ACTIVE_WIDTH[2] ← 0; ACTIVE_WIDTH[3] ← 0; ACTIVE_WIDTH[4] ← 0; ACTIVE_WIDTH[5] ← 0; ACTIVE_WIDTH[6] ← 0; PREV_DP ← 0; WHILE TRUE DO BEGIN IF P = 0 THEN PI ← -10000 ELSE CASE MEM[P].HH.B0 OF 0,1, 2: BEGIN ACTIVE_WIDTH[1] ← ACTIVE_WIDTH[1] + PREV_DP + MEM[P + 3].INT; PREV_DP ← MEM[P + 2].INT; GOTO 45 END; 8: GOTO 45; 10: IF MEM[PREV_P].HH.B0 < 9 THEN PI ← 0 ELSE GOTO 90; 11: BEGIN IF MEM[P].HH.RH = 0 THEN T ← 12 ELSE T ← MEM[MEM[P].HH.RH].HH.B0; IF T = 10 THEN PI ← 0 ELSE GOTO 90 END; 12: PI ← MEM[P + 1].INT; 4,3: GOTO 45; ELSE CONFUSION (960); END; IF PI < 10000 THEN BEGIN IF ACTIVE_WIDTH[1] < H THEN IF (ACTIVE_WIDTH[3] ≠ 0) OR (ACTIVE_WIDTH[4] ≠ 0) OR (ACTIVE_WIDTH[5] ≠ 0) THEN B ← 0 ELSE B ← BADNESS (H - ACTIVE_WIDTH[1], ACTIVE_WIDTH[2]) ELSE IF ACTIVE_WIDTH[1] - H > ACTIVE_WIDTH[6] THEN B ← 1073741823 ELSE B ← BADNESS (ACTIVE_WIDTH[1] - H, ACTIVE_WIDTH[6]); IF B < 1073741823 THEN IF PI ≤ -10000 THEN B ← PI ELSE IF B < 10000 THEN B ← B + PI ELSE B ← 100000; IF B ≤ LEAST_COST THEN BEGIN BEST_PLACE ← P; LEAST_COST ← B; BEST_HEIGHT_PLUS_DEPTH ← ACTIVE_WIDTH[1] + PREV_DP END; IF (B = 1073741823) OR (PI ≤ -10000) THEN GOTO 30 END; IF (MEM[P].HH.B0 < 10) OR (MEM[P].HH.B0 > 11) THEN GOTO 45; 90: IF MEM[P].HH.B0 = 11 THEN Q ← P ELSE BEGIN Q ← MEM[P + 1].HH.LH; ACTIVE_WIDTH[2 + MEM[Q].HH.B0] ← ACTIVE_WIDTH[2 + MEM[Q].HH.B0] + MEM[Q + 2].INT; ACTIVE_WIDTH[6] ← ACTIVE_WIDTH[6] + MEM[Q + 3].INT; IF (MEM[Q].HH.B1 ≠ 0) AND (MEM[Q + 3].INT ≠ 0) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (961) END; BEGIN HELP_PTR ← 4; HELP_LINE[3] ← 962; HELP_LINE[2] ← 963; HELP_LINE[1] ← 964; HELP_LINE[0] ← 922 END; ERROR; R ← NEW_SPEC (Q); MEM[R].HH.B1 ← 0; DELETE_GLUE_REF (Q); MEM[P + 1].HH.LH ← R; Q ← R END END; ACTIVE_WIDTH[1] ← ACTIVE_WIDTH[1] + PREV_DP + MEM[Q + 1].INT; PREV_DP ← 0; 45: IF PREV_DP > D THEN BEGIN ACTIVE_WIDTH[1] ← ACTIVE_WIDTH[1] + PREV_DP - D; PREV_DP ← D END; PREV_P ← P; P ← MEM[PREV_P].HH.RH END; 30: VERT_BREAK ← BEST_PLACE END; FUNCTION VSPLIT (N:EIGHT_BITS; H:SCALED):HALFWORD; LABEL 10, 30; VAR V : HALFWORD; P : HALFWORD; Q : HALFWORD; BEGIN V ← EQTB[7578 + N].HH.RH; IF CUR_MARK[3] ≠ 0 THEN BEGIN DELETE_TOKEN_REF (CUR_MARK[3]); CUR_MARK[3] ← 0; DELETE_TOKEN_REF (CUR_MARK[4]); CUR_MARK[4] ← 0 END; IF V = 0 THEN BEGIN VSPLIT ← 0; GOTO 10 END; IF MEM[V].HH.B0 ≠ 1 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (338) END; PRINT_ESC (965); PRINT (966); PRINT_ESC (967); BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 968; HELP_LINE[0] ← 969 END; ERROR; VSPLIT ← 0; GOTO 10 END; Q ← VERT_BREAK (MEM[V + 5].HH.RH, H, EQTB[9736].INT); P ← MEM[V + 5].HH.RH; IF P = Q THEN MEM[V + 5].HH.RH ← 0 ELSE WHILE TRUE DO BEGIN IF MEM[P].HH.B0 = 4 THEN IF CUR_MARK[3] = 0 THEN BEGIN CUR_MARK[3] ← MEM[P + 1].INT; CUR_MARK[4] ← CUR_MARK[3]; MEM[CUR_MARK[3]].HH.LH ← MEM[CUR_MARK[3]].HH.LH + 2 END ELSE BEGIN DELETE_TOKEN_REF (CUR_MARK[4]); CUR_MARK[4] ← MEM[P + 1].INT; MEM[CUR_MARK[4]].HH.LH ← MEM[CUR_MARK[4]].HH.LH + 1 END; IF MEM[P].HH.RH = Q THEN BEGIN MEM[P].HH.RH ← 0; GOTO 30 END; P ← MEM[P].HH.RH END; 30: ; Q ← PRUNE_PAGE_TOP (Q); P ← MEM[V + 5].HH.RH; FREE_NODE (V, 7); IF Q = 0 THEN EQTB[7578 + N].HH.RH ← 0 ELSE EQTB[7578 + N].HH.RH ← VPACKAGE (Q, 0, 1, 1073741823); VSPLIT ← VPACKAGE (P, H, 0, EQTB[9736].INT); 10: END; PROCEDURE PRINT_TOTALS; BEGIN PRINT_SCALED (PAGE_SO_FAR[1]); IF PAGE_SO_FAR[2] ≠ 0 THEN BEGIN PRINT (312); PRINT_SCALED (PAGE_SO_FAR[2]); PRINT (338) END; IF PAGE_SO_FAR[3] ≠ 0 THEN BEGIN PRINT (312); PRINT_SCALED (PAGE_SO_FAR[3]); PRINT (311) END; IF PAGE_SO_FAR[4] ≠ 0 THEN BEGIN PRINT (312); PRINT_SCALED (PAGE_SO_FAR[4]); PRINT (978) END; IF PAGE_SO_FAR[5] ≠ 0 THEN BEGIN PRINT (312); PRINT_SCALED (PAGE_SO_FAR[5]); PRINT (979) END; IF PAGE_SO_FAR[6] ≠ 0 THEN BEGIN PRINT (313); PRINT_SCALED (PAGE_SO_FAR[6]) END END; PROCEDURE FREEZE_PAGE_SPECS (S:SMALL_NUMBER); BEGIN PAGE_CONTENTS ← S; PAGE_SO_FAR[0] ← EQTB[9734].INT; PAGE_MAX_DEPTH ← EQTB[9735].INT; PAGE_SO_FAR[7] ← 0; PAGE_SO_FAR[1] ← 0; PAGE_SO_FAR[2] ← 0; PAGE_SO_FAR[3] ← 0; PAGE_SO_FAR[4] ← 0; PAGE_SO_FAR[5] ← 0; PAGE_SO_FAR[6] ← 0; LEAST_PAGE_COST ← 1073741823 END; PROCEDURE BOX_ERROR (N:EIGHT_BITS); BEGIN ERROR; BEGIN_DIAGNOSTIC; PRINT_NL (836); SHOW_BOX (EQTB[7578 + N].HH.RH); END_DIAGNOSTIC (TRUE); FLUSH_NODE_LIST (EQTB[7578 + N].HH.RH); EQTB[7578 + N].HH.RH ← 0 END; PROCEDURE ENSURE_VBOX (N:EIGHT_BITS); VAR P : HALFWORD; BEGIN P ← EQTB[7578 + N].HH.RH; IF P ≠ 0 THEN IF MEM[P].HH.B0 = 0 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (989) END; BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 990; HELP_LINE[1] ← 991; HELP_LINE[0] ← 992 END; BOX_ERROR (N) END END; PROCEDURE FIRE_UP (C:HALFWORD); LABEL 10; VAR P : HALFWORD; Q : HALFWORD; R : HALFWORD; S : HALFWORD; PREV_P : HALFWORD; N : 0..255; WAIT : BOOLEAN; SAVE_VBADNESS : INTEGER; SAVE_VFUZZ : SCALED; SAVE_SPLIT_TOP_SKIP : HALFWORD; BEGIN IF MEM[BEST_PAGE_BREAK].HH.B0 = 12 THEN BEGIN GEQ_WORD_DEFINE (9202, MEM[BEST_PAGE_BREAK + 1].INT); MEM[BEST_PAGE_BREAK + 1].INT ← 10000 END ELSE GEQ_WORD_DEFINE (9202, 10000); IF CUR_MARK[2] ≠ 0 THEN BEGIN IF CUR_MARK[0] ≠ 0 THEN DELETE_TOKEN_REF (CUR_MARK[0]); CUR_MARK[0] ← CUR_MARK[2]; MEM[CUR_MARK[0]].HH.LH ← MEM[CUR_MARK[0]].HH.LH + 1; DELETE_TOKEN_REF (CUR_MARK[1]); CUR_MARK[1] ← 0 END; IF C = BEST_PAGE_BREAK THEN BEST_PAGE_BREAK ← 0; IF EQTB[7833].HH.RH ≠ 0 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (338) END; PRINT_ESC (409); PRINT (1003); BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 1004; HELP_LINE[0] ← 992 END; BOX_ERROR (255) END; INSERT_PENALTIES ← 0; SAVE_SPLIT_TOP_SKIP ← EQTB[6792].HH.RH; IF EQTB[9216].INT ≤ 0 THEN BEGIN R ← MEM[60000].HH.RH; WHILE R ≠ 60000 DO BEGIN IF MEM[R + 2].HH.LH ≠ 0 THEN BEGIN N ← MEM[R].HH.B1 - 0; ENSURE_VBOX (N); IF EQTB[7578 + N].HH.RH = 0 THEN EQTB[7578 + N].HH.RH ← NEW_NULL_BOX; P ← EQTB[7578 + N].HH.RH + 5; WHILE MEM[P].HH.RH ≠ 0 DO P ← MEM[P].HH.RH; MEM[R + 2].HH.RH ← P END; R ← MEM[R].HH.RH END END; Q ← 59996; MEM[Q].HH.RH ← 0; PREV_P ← 59998; P ← MEM[PREV_P].HH.RH; WHILE P ≠ BEST_PAGE_BREAK DO BEGIN IF MEM[P].HH.B0 = 3 THEN BEGIN IF EQTB[9216].INT ≤ 0 THEN BEGIN R ← MEM[60000].HH.RH; WHILE MEM[R].HH.B1 ≠ MEM[P].HH.B1 DO R ← MEM[R].HH.RH; IF MEM[R + 2].HH.LH = 0 THEN WAIT ← TRUE ELSE BEGIN WAIT ← FALSE; S ← MEM[R + 2].HH.RH; MEM[S].HH.RH ← MEM[P + 4].HH.LH; IF MEM[R + 2].HH.LH = P THEN BEGIN IF MEM[R].HH.B0 = 1 THEN IF (MEM[R + 1].HH.LH = P) AND (MEM[R + 1].HH.RH ≠ 0) THEN BEGIN WHILE MEM[S].HH.RH ≠ MEM[R + 1].HH.RH DO S ← MEM[S].HH.RH; MEM[S].HH.RH ← 0; EQTB[6792].HH.RH ← MEM[P + 4].HH.RH; MEM[P + 4].HH.LH ← PRUNE_PAGE_TOP (MEM[R + 1].HH.RH); IF MEM[P + 4].HH.LH ≠ 0 THEN BEGIN TEMP_PTR ← VPACKAGE (MEM[P + 4].HH.LH, 0, 1, 1073741823); MEM[P + 3].INT ← MEM[TEMP_PTR + 3].INT + MEM[TEMP_PTR + 2].INT; FREE_NODE (TEMP_PTR, 7); WAIT ← TRUE END END; MEM[R + 2].HH.LH ← 0; N ← MEM[R].HH.B1 - 0; TEMP_PTR ← MEM[EQTB[7578 + N].HH.RH + 5].HH.RH; FREE_NODE (EQTB[7578 + N].HH.RH, 7); EQTB[7578 + N].HH.RH ← VPACKAGE (TEMP_PTR, 0, 1, 1073741823) END ELSE BEGIN WHILE MEM[S].HH.RH ≠ 0 DO S ← MEM[S].HH.RH; MEM[R + 2].HH.RH ← S END END; MEM[PREV_P].HH.RH ← MEM[P].HH.RH; MEM[P].HH.RH ← 0; IF WAIT THEN BEGIN MEM[Q].HH.RH ← P; Q ← P; INSERT_PENALTIES ← INSERT_PENALTIES + 1 END ELSE BEGIN DELETE_GLUE_REF (MEM[P + 4].HH.RH); FREE_NODE (P, 5) END; P ← PREV_P END END ELSE IF MEM[P].HH.B0 = 4 THEN BEGIN IF CUR_MARK[1] = 0 THEN BEGIN CUR_MARK[1] ← MEM[P + 1].INT; MEM[CUR_MARK[1]].HH.LH ← MEM[CUR_MARK[1]].HH.LH + 1 END; IF CUR_MARK[2] ≠ 0 THEN DELETE_TOKEN_REF (CUR_MARK[2]); CUR_MARK[2] ← MEM[P + 1].INT; MEM[CUR_MARK[2]].HH.LH ← MEM[CUR_MARK[2]].HH.LH + 1 END; PREV_P ← P; P ← MEM[PREV_P].HH.RH END; EQTB[6792].HH.RH ← SAVE_SPLIT_TOP_SKIP; IF P ≠ 0 THEN BEGIN IF MEM[59999].HH.RH = 0 THEN IF NEST_PTR = 0 THEN CUR_LIST.TAIL_FIELD ← PAGE_TAIL ELSE NEST[0].TAIL_FIELD ← PAGE_TAIL; MEM[PAGE_TAIL].HH.RH ← MEM[59999].HH.RH; MEM[59999].HH.RH ← P; MEM[PREV_P].HH.RH ← 0 END; SAVE_VBADNESS ← EQTB[9190].INT; EQTB[9190].INT ← 10000; SAVE_VFUZZ ← EQTB[9739].INT; EQTB[9739].INT ← 1073741823; EQTB[7833].HH.RH ← VPACKAGE (MEM[59998].HH.RH, BEST_SIZE, 0, PAGE_MAX_DEPTH); EQTB[9190].INT ← SAVE_VBADNESS; EQTB[9739].INT ← SAVE_VFUZZ; IF LAST_GLUE ≠ 65535 THEN DELETE_GLUE_REF (LAST_GLUE); PAGE_CONTENTS ← 0; PAGE_TAIL ← 59998; MEM[59998].HH.RH ← 0; LAST_GLUE ← 65535; LAST_PENALTY ← 0; LAST_KERN ← 0; PAGE_SO_FAR[7] ← 0; PAGE_MAX_DEPTH ← 0; IF Q ≠ 59996 THEN BEGIN MEM[59998].HH.RH ← MEM[59996].HH.RH; PAGE_TAIL ← Q END; R ← MEM[60000].HH.RH; WHILE R ≠ 60000 DO BEGIN Q ← MEM[R].HH.RH; FREE_NODE (R, 4); R ← Q END; MEM[60000].HH.RH ← 60000; IF (CUR_MARK[0] ≠ 0) AND (CUR_MARK[1] = 0) THEN BEGIN CUR_MARK[1] ← CUR_MARK[0]; MEM[CUR_MARK[0]].HH.LH ← MEM[CUR_MARK[0]].HH.LH + 1 END; IF EQTB[7313].HH.RH ≠ 0 THEN IF DEAD_CYCLES ≥ EQTB[9203].INT THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1005) END; PRINT_INT (DEAD_CYCLES); PRINT (1006); BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 1007; HELP_LINE[1] ← 1008; HELP_LINE[0] ← 1009 END; ERROR END ELSE BEGIN OUTPUT_ACTIVE ← TRUE; DEAD_CYCLES ← DEAD_CYCLES + 1; PUSH_NEST; CUR_LIST.MODE_FIELD ← -1; CUR_LIST.AUX_FIELD.INT ← -65536000; CUR_LIST.ML_FIELD ← -LINE; BEGIN_TOKEN_LIST (EQTB[7313].HH.RH, 6); NEW_SAVE_LEVEL (8); NORMAL_PARAGRAPH; SCAN_LEFT_BRACE; GOTO 10 END; BEGIN IF MEM[59998].HH.RH ≠ 0 THEN BEGIN IF MEM[59999].HH.RH = 0 THEN IF NEST_PTR = 0 THEN CUR_LIST.TAIL_FIELD ← PAGE_TAIL ELSE NEST[0].TAIL_FIELD ← PAGE_TAIL ELSE MEM[PAGE_TAIL].HH.RH ← MEM[59999].HH.RH; MEM[59999].HH.RH ← MEM[59998].HH.RH; MEM[59998].HH.RH ← 0; PAGE_TAIL ← 59998 END; SHIP_OUT (EQTB[7833].HH.RH); EQTB[7833].HH.RH ← 0 END; 10: END; PROCEDURE BUILD_PAGE; LABEL 10, 30, 31, 22, 80, 90; VAR P : HALFWORD; Q : HALFWORD; R : HALFWORD; B : INTEGER; C : INTEGER; PI : INTEGER; N : 0..255; DELTA : SCALED; H : SCALED; W : SCALED; BEGIN IF (MEM[59999].HH.RH = 0) OR OUTPUT_ACTIVE THEN GOTO 10; REPEAT 22: P ← MEM[59999].HH.RH; IF LAST_GLUE ≠ 65535 THEN DELETE_GLUE_REF (LAST_GLUE); LAST_PENALTY ← 0; LAST_KERN ← 0; IF MEM[P].HH.B0 = 10 THEN BEGIN LAST_GLUE ← MEM[P + 1].HH.LH; MEM[LAST_GLUE].HH.RH ← MEM[LAST_GLUE].HH.RH + 1 END ELSE BEGIN LAST_GLUE ← 65535; IF MEM[P].HH.B0 = 12 THEN LAST_PENALTY ← MEM[P + 1].INT ELSE IF MEM[P].HH.B0 = 11 THEN LAST_KERN ← MEM[P + 1].INT END; CASE MEM[P].HH.B0 OF 0,1, 2: IF PAGE_CONTENTS < 2 THEN BEGIN IF PAGE_CONTENTS = 0 THEN FREEZE_PAGE_SPECS (2) ELSE PAGE_CONTENTS ← 2; Q ← NEW_SKIP_PARAM (9); IF MEM[TEMP_PTR + 1].INT > MEM[P + 3].INT THEN MEM[TEMP_PTR + 1].INT ← MEM[TEMP_PTR + 1].INT - MEM[P + 3].INT ELSE MEM[TEMP_PTR + 1].INT ← 0; MEM[Q].HH.RH ← P; MEM[59999].HH.RH ← Q; GOTO 22 END ELSE BEGIN PAGE_SO_FAR[1] ← PAGE_SO_FAR[1] + PAGE_SO_FAR[7] + MEM[P + 3].INT; PAGE_SO_FAR[7] ← MEM[P + 2].INT; GOTO 80 END; 8: GOTO 80; 10: IF PAGE_CONTENTS < 2 THEN GOTO 31 ELSE IF MEM[PAGE_TAIL].HH.B0 < 9 THEN PI ← 0 ELSE GOTO 90; 11: IF PAGE_CONTENTS < 2 THEN GOTO 31 ELSE IF MEM[P].HH.RH = 0 THEN GOTO 10 ELSE IF MEM[MEM[P].HH.RH].HH.B0 = 10 THEN PI ← 0 ELSE GOTO 90; 12: IF PAGE_CONTENTS < 2 THEN GOTO 31 ELSE PI ← MEM[P + 1].INT; 4: GOTO 80; 3: BEGIN IF PAGE_CONTENTS = 0 THEN FREEZE_PAGE_SPECS (1); N ← MEM[P].HH.B1; R ← 60000; WHILE N ≥ MEM[MEM[R].HH.RH].HH.B1 DO R ← MEM[R].HH.RH; N ← N - 0; IF MEM[R].HH.B1 ≠ N + 0 THEN BEGIN Q ← GET_NODE (4); MEM[Q].HH.RH ← MEM[R].HH.RH; MEM[R].HH.RH ← Q; R ← Q; MEM[R].HH.B1 ← N + 0; MEM[R].HH.B0 ← 0; ENSURE_VBOX (N); IF EQTB[7578 + N].HH.RH = 0 THEN MEM[R + 3].INT ← 0 ELSE MEM[R + 3].INT ← MEM[EQTB[7578 + N].HH.RH + 3].INT + MEM[EQTB[7578 + N].HH.RH + 2].INT; MEM[R + 2].HH.LH ← 0; Q ← EQTB[6800 + N].HH.RH; IF EQTB[9218 + N].INT = 1000 THEN H ← MEM[R + 3].INT ELSE H ← X_OVER_N (MEM[R + 3].INT, 1000) * EQTB[9218 + N].INT; PAGE_SO_FAR[0] ← PAGE_SO_FAR[0] - H - MEM[Q + 1].INT; PAGE_SO_FAR[2 + MEM[Q].HH.B0] ← PAGE_SO_FAR[2 + MEM[Q].HH.B0] + MEM[Q + 2].INT; PAGE_SO_FAR[6] ← PAGE_SO_FAR[6] + MEM[Q + 3].INT; IF (MEM[Q].HH.B1 ≠ 0) AND (MEM[Q + 3].INT ≠ 0) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (998) END; PRINT_ESC (395); PRINT_INT (N); BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 999; HELP_LINE[1] ← 1000; HELP_LINE[0] ← 922 END; ERROR END END; IF MEM[R].HH.B0 = 1 THEN INSERT_PENALTIES ← INSERT_PENALTIES + MEM[P + 1].INT ELSE BEGIN MEM[R + 2].HH.RH ← P; DELTA ← PAGE_SO_FAR[0] - PAGE_SO_FAR[1] - PAGE_SO_FAR[7] + PAGE_SO_FAR[6]; IF EQTB[9218 + N].INT = 1000 THEN H ← MEM[P + 3].INT ELSE H ← X_OVER_N (MEM[P + 3].INT, 1000) * EQTB[9218 + N].INT; IF ((H ≤ 0) OR (H ≤ DELTA)) AND (MEM[P + 3].INT + MEM[R + 3].INT ≤ EQTB[9751 + N].INT) THEN BEGIN PAGE_SO_FAR[0] ← PAGE_SO_FAR[0] - H; MEM[R + 3].INT ← MEM[R + 3].INT + MEM[P + 3].INT END ELSE BEGIN IF EQTB[9218 + N].INT ≤ 0 THEN W ← 1073741823 ELSE BEGIN W ← PAGE_SO_FAR[0] - PAGE_SO_FAR[1] - PAGE_SO_FAR[7]; IF EQTB[9218 + N].INT ≠ 1000 THEN W ← X_OVER_N (W, EQTB[9218 + N].INT) * 1000 END; IF W > EQTB[9751 + N].INT - MEM[R + 3].INT THEN W ← EQTB[9751 + N].INT - MEM[R + 3].INT; Q ← VERT_BREAK (MEM[P + 4].HH.LH, W, MEM[P + 2].INT); MEM[R + 3].INT ← MEM[R + 3].INT + BEST_HEIGHT_PLUS_DEPTH; IF EQTB[9218 + N].INT ≠ 1000 THEN BEST_HEIGHT_PLUS_DEPTH ← X_OVER_N (BEST_HEIGHT_PLUS_DEPTH, 1000) * EQTB[9218 + N].INT; PAGE_SO_FAR[0] ← PAGE_SO_FAR[0] - BEST_HEIGHT_PLUS_DEPTH; MEM[R].HH.B0 ← 1; MEM[R + 1].HH.RH ← Q; MEM[R + 1].HH.LH ← P; IF Q = 0 THEN INSERT_PENALTIES ← INSERT_PENALTIES - 10000 ELSE IF MEM[Q].HH.B0 = 12 THEN INSERT_PENALTIES ← INSERT_PENALTIES + MEM[Q + 1].INT END END; GOTO 80 END; ELSE CONFUSION (993); END; IF PI < 10000 THEN BEGIN IF PAGE_SO_FAR[1] < PAGE_SO_FAR[0] THEN IF (PAGE_SO_FAR[3] ≠ 0) OR (PAGE_SO_FAR[4] ≠ 0) OR (PAGE_SO_FAR[5] ≠ 0) THEN B ← 0 ELSE B ← BADNESS (PAGE_SO_FAR[0] - PAGE_SO_FAR[1], PAGE_SO_FAR[2]) ELSE IF PAGE_SO_FAR[1] - PAGE_SO_FAR[0] > PAGE_SO_FAR[6] THEN B ← 1073741823 ELSE B ← BADNESS (PAGE_SO_FAR[1] - PAGE_SO_FAR[0], PAGE_SO_FAR[6]); IF B < 1073741823 THEN IF PI ≤ -10000 THEN C ← PI ELSE IF B < 10000 THEN C ← B + PI + INSERT_PENALTIES ELSE C ← 100000 ELSE C ← B; IF INSERT_PENALTIES ≥ 10000 THEN C ← 1073741823; IF C ≤ LEAST_PAGE_COST THEN BEGIN BEST_PAGE_BREAK ← P; BEST_SIZE ← PAGE_SO_FAR[0]; LEAST_PAGE_COST ← C; R ← MEM[60000].HH.RH; WHILE R ≠ 60000 DO BEGIN MEM[R + 2].HH.LH ← MEM[R + 2].HH.RH; R ← MEM[R].HH.RH END END; IF (C = 1073741823) OR (PI ≤ -10000) THEN BEGIN FIRE_UP (P); IF OUTPUT_ACTIVE THEN GOTO 10; GOTO 30 END END; IF (MEM[P].HH.B0 < 10) OR (MEM[P].HH.B0 > 11) THEN GOTO 80; 90: IF MEM[P].HH.B0 = 11 THEN Q ← P ELSE BEGIN Q ← MEM[P + 1].HH.LH; PAGE_SO_FAR[2 + MEM[Q].HH.B0] ← PAGE_SO_FAR[2 + MEM[Q].HH.B0] + MEM[Q + 2].INT; PAGE_SO_FAR[6] ← PAGE_SO_FAR[6] + MEM[Q + 3].INT; IF (MEM[Q].HH.B1 ≠ 0) AND (MEM[Q + 3].INT ≠ 0) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (994) END; BEGIN HELP_PTR ← 4; HELP_LINE[3] ← 995; HELP_LINE[2] ← 963; HELP_LINE[1] ← 964; HELP_LINE[0] ← 922 END; ERROR; R ← NEW_SPEC (Q); MEM[R].HH.B1 ← 0; DELETE_GLUE_REF (Q); MEM[P + 1].HH.LH ← R; Q ← R END END; PAGE_SO_FAR[1] ← PAGE_SO_FAR[1] + PAGE_SO_FAR[7] + MEM[Q + 1].INT; PAGE_SO_FAR[7] ← 0; 80: IF PAGE_SO_FAR[7] > PAGE_MAX_DEPTH THEN BEGIN PAGE_SO_FAR[1] ← PAGE_SO_FAR[1] + PAGE_SO_FAR[7] - PAGE_MAX_DEPTH; PAGE_SO_FAR[7] ← PAGE_MAX_DEPTH END; MEM[PAGE_TAIL].HH.RH ← P; PAGE_TAIL ← P; MEM[59999].HH.RH ← MEM[P].HH.RH; MEM[P].HH.RH ← 0; GOTO 30; 31: MEM[59999].HH.RH ← MEM[P].HH.RH; MEM[P].HH.RH ← 0; FLUSH_NODE_LIST (P); 30: UNTIL MEM[59999].HH.RH = 0; IF NEST_PTR = 0 THEN CUR_LIST.TAIL_FIELD ← 59999 ELSE NEST[0].TAIL_FIELD ← 59999; 10: END; PROCEDURE APP_SPACE; VAR Q : HALFWORD; BEGIN IF (CUR_LIST.AUX_FIELD.HH.LH ≥ 2000) AND (EQTB[6795].HH.RH ≠ 0) THEN Q ← NEW_PARAM_GLUE (13) ELSE BEGIN IF EQTB[6794].HH.RH ≠ 0 THEN MAIN_P ← EQTB[6794].HH.RH ELSE BEGIN MAIN_P ← FONT_GLUE[EQTB[7834].HH.RH]; IF MAIN_P = 0 THEN BEGIN MAIN_P ← NEW_SPEC (0); MAIN_K ← PARAM_BASE[EQTB[7834].HH.RH] + 2; MEM[MAIN_P + 1].INT ← FONT_INFO[MAIN_K].INT; MEM[MAIN_P + 2].INT ← FONT_INFO[MAIN_K + 1].INT; MEM[MAIN_P + 3].INT ← FONT_INFO[MAIN_K + 2].INT; FONT_GLUE[EQTB[7834].HH.RH] ← MAIN_P END END; MAIN_P ← NEW_SPEC (MAIN_P); IF CUR_LIST.AUX_FIELD.HH.LH ≥ 2000 THEN MEM[MAIN_P + 1].INT ← MEM[MAIN_P + 1].INT + FONT_INFO[7 + PARAM_BASE[EQTB[7834].HH.RH]].INT; MEM[MAIN_P + 2].INT ← XN_OVER_D (MEM[MAIN_P + 2].INT, CUR_LIST.AUX_FIELD.HH.LH, 1000); MEM[MAIN_P + 3].INT ← XN_OVER_D (MEM[MAIN_P + 3].INT, 1000, CUR_LIST.AUX_FIELD.HH.LH); Q ← NEW_GLUE (MAIN_P); MEM[MAIN_P].HH.RH ← 0 END; MEM[CUR_LIST.TAIL_FIELD].HH.RH ← Q; CUR_LIST.TAIL_FIELD ← Q END; PROCEDURE INSERT_DOLLAR_SIGN; BEGIN BACK_INPUT; CUR_TOK ← 804; BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1017) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 1018; HELP_LINE[0] ← 1019 END; INS_ERROR END; PROCEDURE YOU_CANT; BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (685) END; PRINT_CMD_CHR (CUR_CMD, CUR_CHR); PRINT (1020); PRINT_MODE (CUR_LIST.MODE_FIELD) END; PROCEDURE REPORT_ILLEGAL_CASE; BEGIN YOU_CANT; BEGIN HELP_PTR ← 4; HELP_LINE[3] ← 1021; HELP_LINE[2] ← 1022; HELP_LINE[1] ← 1023; HELP_LINE[0] ← 1024 END; ERROR END; FUNCTION PRIVILEGED:BOOLEAN; BEGIN IF CUR_LIST.MODE_FIELD > 0 THEN PRIVILEGED ← TRUE ELSE BEGIN REPORT_ILLEGAL_CASE; PRIVILEGED ← FALSE END END; FUNCTION ITS_ALL_OVER:BOOLEAN; LABEL 10; BEGIN IF PRIVILEGED THEN BEGIN IF (59998 = PAGE_TAIL) AND (CUR_LIST.HEAD_FIELD = CUR_LIST.TAIL_FIELD) AND (DEAD_CYCLES = 0) THEN BEGIN ITS_ALL_OVER ← TRUE; GOTO 10 END; BACK_INPUT; BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_NULL_BOX; CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; MEM[CUR_LIST.TAIL_FIELD + 1].INT ← EQTB[9733].INT; BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_GLUE (8); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_PENALTY (-1073741824); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; BUILD_PAGE END; ITS_ALL_OVER ← FALSE; 10: END; PROCEDURE APPEND_GLUE; VAR S : SMALL_NUMBER; BEGIN S ← CUR_CHR; CASE S OF 0: CUR_VAL ← 4; 1: CUR_VAL ← 8; 2: CUR_VAL ← 12; 3: CUR_VAL ← 16; 4: SCAN_GLUE (2); 5: SCAN_GLUE (3); END; BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_GLUE (CUR_VAL); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; IF S ≥ 4 THEN BEGIN MEM[CUR_VAL].HH.RH ← MEM[CUR_VAL].HH.RH - 1; IF S > 4 THEN MEM[CUR_LIST.TAIL_FIELD].HH.B1 ← 99 END END; PROCEDURE APPEND_KERN; VAR S : QUARTERWORD; BEGIN S ← CUR_CHR; SCAN_DIMEN (S = 99, FALSE, FALSE); BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_KERN (CUR_VAL); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; MEM[CUR_LIST.TAIL_FIELD].HH.B1 ← S END; PROCEDURE OFF_SAVE; VAR P : HALFWORD; BEGIN IF CUR_GROUP = 0 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (777) END; PRINT_CMD_CHR (CUR_CMD, CUR_CHR); BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 1043 END; ERROR END ELSE BEGIN BACK_INPUT; P ← GET_AVAIL; MEM[59997].HH.RH ← P; BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (625) END; CASE CUR_GROUP OF 14: BEGIN MEM[P].HH.LH ← 10611; PRINT_ESC (516) END; 15: BEGIN MEM[P].HH.LH ← 804; PRINT_CHAR (36) END; 16: BEGIN MEM[P].HH.LH ← 10612; MEM[P].HH.RH ← GET_AVAIL; P ← MEM[P].HH.RH; MEM[P].HH.LH ← 3118; PRINT_ESC (1042) END; ELSE BEGIN MEM[P].HH.LH ← 637; PRINT_CHAR (125) END; END; PRINT (626); BEGIN_TOKEN_LIST (MEM[59997].HH.RH, 4); BEGIN HELP_PTR ← 5; HELP_LINE[4] ← 1037; HELP_LINE[3] ← 1038; HELP_LINE[2] ← 1039; HELP_LINE[1] ← 1040; HELP_LINE[0] ← 1041 END; ERROR END END; PROCEDURE EXTRA_RIGHT_BRACE; BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1048) END; CASE CUR_GROUP OF 14: PRINT_ESC (516); 15: PRINT_CHAR (36); 16: PRINT_ESC (877); END; BEGIN HELP_PTR ← 5; HELP_LINE[4] ← 1049; HELP_LINE[3] ← 1050; HELP_LINE[2] ← 1051; HELP_LINE[1] ← 1052; HELP_LINE[0] ← 1053 END; ERROR; ALIGN_STATE ← ALIGN_STATE + 1 END; PROCEDURE NORMAL_PARAGRAPH; BEGIN IF EQTB[9182].INT ≠ 0 THEN EQ_WORD_DEFINE (9182, 0); IF EQTB[9747].INT ≠ 0 THEN EQ_WORD_DEFINE (9747, 0); IF EQTB[9204].INT ≠ 1 THEN EQ_WORD_DEFINE (9204, 1); IF EQTB[7312].HH.RH ≠ 0 THEN EQ_DEFINE (7312, 118, 0) END; PROCEDURE BOX_END (BOX_CONTEXT:INTEGER); VAR P : HALFWORD; BEGIN IF BOX_CONTEXT < 1073741824 THEN BEGIN IF CUR_BOX ≠ 0 THEN BEGIN MEM[CUR_BOX + 4].INT ← BOX_CONTEXT; IF ABS (CUR_LIST.MODE_FIELD) = 1 THEN BEGIN APPEND_TO_VLIST (CUR_BOX); IF ADJUST_TAIL ≠ 0 THEN BEGIN IF 59995 ≠ ADJUST_TAIL THEN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← MEM[59995].HH.RH; CUR_LIST.TAIL_FIELD ← ADJUST_TAIL END; ADJUST_TAIL ← 0 END; IF CUR_LIST.MODE_FIELD > 0 THEN BUILD_PAGE END ELSE BEGIN IF ABS (CUR_LIST.MODE_FIELD) = 102 THEN CUR_LIST.AUX_FIELD.HH.LH ← 1000 ELSE BEGIN P ← NEW_NOAD; MEM[P + 1].HH.RH ← 2; MEM[P + 1].HH.LH ← CUR_BOX; CUR_BOX ← P END; MEM[CUR_LIST.TAIL_FIELD].HH.RH ← CUR_BOX; CUR_LIST.TAIL_FIELD ← CUR_BOX END END END ELSE IF BOX_CONTEXT < 1073742336 THEN IF BOX_CONTEXT < 1073742080 THEN EQ_DEFINE (-1073734246 + BOX_CONTEXT, 119, CUR_BOX) ELSE GEQ_DEFINE (-1073734502 + BOX_CONTEXT, 119, CUR_BOX) ELSE IF CUR_BOX ≠ 0 THEN IF BOX_CONTEXT > 1073742336 THEN BEGIN REPEAT GET_X_TOKEN UNTIL (CUR_CMD ≠ 10) AND (CUR_CMD ≠ 0); IF (CUR_CMD = 26) AND (ABS (CUR_LIST.MODE_FIELD) ≠ 1) OR (CUR_CMD = 27) AND (ABS (CUR_LIST.MODE_FIELD) = 1) THEN BEGIN APPEND_GLUE; MEM[CUR_LIST.TAIL_FIELD].HH.B1 ← BOX_CONTEXT - 1073742237; MEM[CUR_LIST.TAIL_FIELD + 1].HH.RH ← CUR_BOX END ELSE BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1066) END; BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 1067; HELP_LINE[1] ← 1068; HELP_LINE[0] ← 1069 END; BACK_ERROR; FLUSH_NODE_LIST (CUR_BOX) END END ELSE SHIP_OUT (CUR_BOX) END; PROCEDURE BEGIN_BOX (BOX_CONTEXT:INTEGER); LABEL 10, 30; VAR P : HALFWORD; Q : HALFWORD; M : QUARTERWORD; K : HALFWORD; N : EIGHT_BITS; BEGIN CASE CUR_CHR OF 0: BEGIN SCAN_EIGHT_BIT_INT; CUR_BOX ← EQTB[7578 + CUR_VAL].HH.RH; EQTB[7578 + CUR_VAL].HH.RH ← 0 END; 1: BEGIN SCAN_EIGHT_BIT_INT; CUR_BOX ← COPY_NODE_LIST (EQTB[7578 + CUR_VAL].HH.RH) END; 2: BEGIN CUR_BOX ← 0; IF ABS (CUR_LIST.MODE_FIELD) = 203 THEN BEGIN YOU_CANT; BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 1070 END; ERROR END ELSE IF (CUR_LIST.MODE_FIELD = 1) AND (CUR_LIST.HEAD_FIELD = CUR_LIST.TAIL_FIELD) THEN BEGIN YOU_CANT; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 1071; HELP_LINE[0] ← 1072 END; ERROR END ELSE BEGIN IF NOT (CUR_LIST.TAIL_FIELD ≥ HI_MEM_MIN) THEN IF (MEM[CUR_LIST.TAIL_FIELD].HH.B0 = 0) OR (MEM[CUR_LIST.TAIL_FIELD].HH.B0 = 1) THEN BEGIN Q ← CUR_LIST.HEAD_FIELD; REPEAT P ← Q; IF NOT (Q ≥ HI_MEM_MIN) THEN IF MEM[Q].HH.B0 = 7 THEN BEGIN FOR M ← 1 TO MEM[Q].HH.B1 DO P ← MEM[P].HH.RH; IF P = CUR_LIST.TAIL_FIELD THEN GOTO 30 END; Q ← MEM[P].HH.RH UNTIL Q = CUR_LIST.TAIL_FIELD; CUR_BOX ← CUR_LIST.TAIL_FIELD; MEM[CUR_BOX + 4].INT ← 0; CUR_LIST.TAIL_FIELD ← P; MEM[P].HH.RH ← 0; 30: END END END; 3: BEGIN SCAN_EIGHT_BIT_INT; N ← CUR_VAL; IF NOT SCAN_KEYWORD (842) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1073) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 1074; HELP_LINE[0] ← 1075 END; ERROR END; SCAN_DIMEN (FALSE, FALSE, FALSE); CUR_BOX ← VSPLIT (N, CUR_VAL) END; ELSE BEGIN K ← CUR_CHR - 4; SAVE_STACK[SAVE_PTR + 0].INT ← BOX_CONTEXT; IF K = 102 THEN IF (BOX_CONTEXT < 1073741824) AND (ABS (CUR_LIST.MODE_FIELD) = 1) THEN SCAN_SPEC (3, TRUE) ELSE SCAN_SPEC (2, TRUE) ELSE BEGIN IF K = 1 THEN SCAN_SPEC (4, TRUE) ELSE BEGIN SCAN_SPEC (5, TRUE); K ← 1 END; NORMAL_PARAGRAPH END; PUSH_NEST; CUR_LIST.MODE_FIELD ← -K; IF K = 1 THEN BEGIN CUR_LIST.AUX_FIELD.INT ← -65536000; IF EQTB[7318].HH.RH ≠ 0 THEN BEGIN_TOKEN_LIST (EQTB[7318].HH.RH, 11) END ELSE BEGIN CUR_LIST.AUX_FIELD.HH.LH ← 1000; IF EQTB[7317].HH.RH ≠ 0 THEN BEGIN_TOKEN_LIST (EQTB[7317].HH.RH, 10) END; GOTO 10 END; END; BOX_END (BOX_CONTEXT); 10: END; PROCEDURE SCAN_BOX (BOX_CONTEXT:INTEGER); BEGIN REPEAT GET_X_TOKEN UNTIL (CUR_CMD ≠ 10) AND (CUR_CMD ≠ 0); IF CUR_CMD = 20 THEN BEGIN_BOX (BOX_CONTEXT) ELSE IF (BOX_CONTEXT ≥ 1073742337) AND ((CUR_CMD = 36) OR (CUR_CMD = 35)) THEN BEGIN CUR_BOX ← SCAN_RULE_SPEC; BOX_END (BOX_CONTEXT) END ELSE BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1076) END; BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 1077; HELP_LINE[1] ← 1078; HELP_LINE[0] ← 1079 END; BACK_ERROR END END; PROCEDURE PACKAGE (C:SMALL_NUMBER); VAR H : SCALED; P : HALFWORD; D : SCALED; BEGIN D ← EQTB[9737].INT; UNSAVE; SAVE_PTR ← SAVE_PTR - 3; IF CUR_LIST.MODE_FIELD = -102 THEN CUR_BOX ← HPACK (MEM[CUR_LIST.HEAD_FIELD].HH.RH, SAVE_STACK[SAVE_PTR + 2].INT, SAVE_STACK[SAVE_PTR + 1].INT) ELSE BEGIN CUR_BOX ← VPACKAGE (MEM[CUR_LIST.HEAD_FIELD].HH.RH, SAVE_STACK[SAVE_PTR + 2].INT, SAVE_STACK[SAVE_PTR + 1].INT, D); IF C = 4 THEN BEGIN H ← 0; P ← MEM[CUR_BOX + 5].HH.RH; IF P ≠ 0 THEN IF MEM[P].HH.B0 ≤ 2 THEN H ← MEM[P + 3].INT; MEM[CUR_BOX + 2].INT ← MEM[CUR_BOX + 2].INT - H + MEM[CUR_BOX + 3].INT; MEM[CUR_BOX + 3].INT ← H END END; POP_NEST; BOX_END (SAVE_STACK[SAVE_PTR + 0].INT) END; FUNCTION NORM_MIN (H:INTEGER):SMALL_NUMBER; BEGIN IF H ≤ 0 THEN NORM_MIN ← 1 ELSE IF H ≥ 63 THEN NORM_MIN ← 63 ELSE NORM_MIN ← H END; PROCEDURE NEW_GRAF (INDENTED:BOOLEAN); BEGIN CUR_LIST.PG_FIELD ← 0; IF (CUR_LIST.MODE_FIELD = 1) OR (CUR_LIST.HEAD_FIELD ≠ CUR_LIST.TAIL_FIELD) THEN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_PARAM_GLUE (2); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; PUSH_NEST; CUR_LIST.MODE_FIELD ← 102; CUR_LIST.AUX_FIELD.HH.LH ← 1000; IF EQTB[9213].INT ≤ 0 THEN CUR_LANG ← 0 ELSE IF EQTB[9213].INT > 255 THEN CUR_LANG ← 0 ELSE CUR_LANG ← EQTB[9213].INT; CUR_LIST.AUX_FIELD.HH.RH ← CUR_LANG; CUR_LIST.PG_FIELD ← (NORM_MIN (EQTB[9214].INT) * 64 + NORM_MIN (EQTB[9215].INT)) * 65536 + CUR_LANG; IF INDENTED THEN BEGIN CUR_LIST.TAIL_FIELD ← NEW_NULL_BOX; MEM[CUR_LIST.HEAD_FIELD].HH.RH ← CUR_LIST.TAIL_FIELD; MEM[CUR_LIST.TAIL_FIELD + 1].INT ← EQTB[9730].INT END; IF EQTB[7314].HH.RH ≠ 0 THEN BEGIN_TOKEN_LIST (EQTB[7314].HH.RH, 7); IF NEST_PTR = 1 THEN BUILD_PAGE END; PROCEDURE INDENT_IN_HMODE; VAR P : HALFWORD; Q : HALFWORD; BEGIN IF CUR_CHR > 0 THEN BEGIN P ← NEW_NULL_BOX; MEM[P + 1].INT ← EQTB[9730].INT; IF ABS (CUR_LIST.MODE_FIELD) = 102 THEN CUR_LIST.AUX_FIELD.HH.LH ← 1000 ELSE BEGIN Q ← NEW_NOAD; MEM[Q + 1].HH.RH ← 2; MEM[Q + 1].HH.LH ← P; P ← Q END; BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← P; CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END END END; PROCEDURE HEAD_FOR_VMODE; BEGIN IF CUR_LIST.MODE_FIELD < 0 THEN IF CUR_CMD ≠ 36 THEN OFF_SAVE ELSE BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (685) END; PRINT_ESC (521); PRINT (1082); BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 1083; HELP_LINE[0] ← 1084 END; ERROR END ELSE BEGIN BACK_INPUT; CUR_TOK ← PAR_TOKEN; BACK_INPUT; CUR_INPUT.INDEX_FIELD ← 4 END END; PROCEDURE END_GRAF; BEGIN IF CUR_LIST.MODE_FIELD = 102 THEN BEGIN IF CUR_LIST.HEAD_FIELD = CUR_LIST.TAIL_FIELD THEN POP_NEST ELSE LINE_BREAK (EQTB[9169].INT); NORMAL_PARAGRAPH; ERROR_COUNT ← 0 END END; PROCEDURE BEGIN_INSERT_OR_ADJUST; BEGIN IF CUR_CMD = 38 THEN CUR_VAL ← 255 ELSE BEGIN SCAN_EIGHT_BIT_INT; IF CUR_VAL = 255 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1085) END; PRINT_ESC (330); PRINT_INT (255); BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 1086 END; ERROR; CUR_VAL ← 0 END END; SAVE_STACK[SAVE_PTR + 0].INT ← CUR_VAL; SAVE_PTR ← SAVE_PTR + 1; NEW_SAVE_LEVEL (11); SCAN_LEFT_BRACE; NORMAL_PARAGRAPH; PUSH_NEST; CUR_LIST.MODE_FIELD ← -1; CUR_LIST.AUX_FIELD.INT ← -65536000 END; PROCEDURE MAKE_MARK; VAR P : HALFWORD; BEGIN P ← SCAN_TOKS (FALSE, TRUE); P ← GET_NODE (2); MEM[P].HH.B0 ← 4; MEM[P].HH.B1 ← 0; MEM[P + 1].INT ← DEF_REF; MEM[CUR_LIST.TAIL_FIELD].HH.RH ← P; CUR_LIST.TAIL_FIELD ← P END; PROCEDURE APPEND_PENALTY; BEGIN SCAN_INT; BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_PENALTY (CUR_VAL); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; IF CUR_LIST.MODE_FIELD = 1 THEN BUILD_PAGE END; PROCEDURE DELETE_LAST; LABEL 10; VAR P : HALFWORD; Q : HALFWORD; M : QUARTERWORD; BEGIN IF (CUR_LIST.MODE_FIELD = 1) AND (CUR_LIST.TAIL_FIELD = CUR_LIST.HEAD_FIELD) THEN BEGIN IF (CUR_CHR ≠ 10) OR (LAST_GLUE ≠ 65535) THEN BEGIN YOU_CANT; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 1071; HELP_LINE[0] ← 1087 END; IF CUR_CHR = 11 THEN HELP_LINE[0] ← 1088 ELSE IF CUR_CHR ≠ 10 THEN HELP_LINE[0] ← 1089; ERROR END END ELSE BEGIN IF NOT (CUR_LIST.TAIL_FIELD ≥ HI_MEM_MIN) THEN IF MEM[CUR_LIST.TAIL_FIELD].HH.B0 = CUR_CHR THEN BEGIN Q ← CUR_LIST.HEAD_FIELD; REPEAT P ← Q; IF NOT (Q ≥ HI_MEM_MIN) THEN IF MEM[Q].HH.B0 = 7 THEN BEGIN FOR M ← 1 TO MEM[Q].HH.B1 DO P ← MEM[P].HH.RH; IF P = CUR_LIST.TAIL_FIELD THEN GOTO 10 END; Q ← MEM[P].HH.RH UNTIL Q = CUR_LIST.TAIL_FIELD; MEM[P].HH.RH ← 0; FLUSH_NODE_LIST (CUR_LIST.TAIL_FIELD); CUR_LIST.TAIL_FIELD ← P END END; 10: END; PROCEDURE UNPACKAGE; LABEL 10; VAR P : HALFWORD; C : 0..1; BEGIN C ← CUR_CHR; SCAN_EIGHT_BIT_INT; P ← EQTB[7578 + CUR_VAL].HH.RH; IF P = 0 THEN GOTO 10; IF (ABS (CUR_LIST.MODE_FIELD) = 203) OR (ABS (CUR_LIST.MODE_FIELD) = 1) AND (MEM[P].HH.B0 ≠ 1) OR (ABS (CUR_LIST.MODE_FIELD) = 102) AND (MEM[P].HH.B0 ≠ 0) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1097) END; BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 1098; HELP_LINE[1] ← 1099; HELP_LINE[0] ← 1100 END; ERROR; GOTO 10 END; IF C = 1 THEN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← COPY_NODE_LIST (MEM[P + 5].HH.RH) ELSE BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← MEM[P + 5].HH.RH; EQTB[7578 + CUR_VAL].HH.RH ← 0; FREE_NODE (P, 7) END; WHILE MEM[CUR_LIST.TAIL_FIELD].HH.RH ≠ 0 DO CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH; 10: END; PROCEDURE APPEND_ITALIC_CORRECTION; LABEL 10; VAR P : HALFWORD; F : INTERNAL_FONT_NUMBER; BEGIN IF CUR_LIST.TAIL_FIELD ≠ CUR_LIST.HEAD_FIELD THEN BEGIN IF CUR_LIST.TAIL_FIELD ≥ HI_MEM_MIN THEN P ← CUR_LIST.TAIL_FIELD ELSE IF MEM[CUR_LIST.TAIL_FIELD].HH.B0 = 6 THEN P ← CUR_LIST.TAIL_FIELD + 1 ELSE GOTO 10; F ← MEM[P].HH.B0; BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_KERN (FONT_INFO[ ITALIC_BASE[F] + (FONT_INFO[CHAR_BASE[F] + MEM[P].HH.B1].QQQQ.B2 - 0) DIV 4]. INT); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; MEM[CUR_LIST.TAIL_FIELD].HH.B1 ← 1 END; 10: END; PROCEDURE APPEND_DISCRETIONARY; VAR C : INTEGER; BEGIN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_DISC; CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; IF CUR_CHR = 1 THEN BEGIN C ← HYPHEN_CHAR[EQTB[7834].HH.RH]; IF C ≥ 0 THEN IF C < 256 THEN MEM[CUR_LIST.TAIL_FIELD + 1].HH.LH ← NEW_CHARACTER (EQTB[7834].HH.RH, C) END ELSE BEGIN SAVE_PTR ← SAVE_PTR + 1; SAVE_STACK[SAVE_PTR - 1].INT ← 0; NEW_SAVE_LEVEL (10); SCAN_LEFT_BRACE; PUSH_NEST; CUR_LIST.MODE_FIELD ← -102; CUR_LIST.AUX_FIELD.HH.LH ← 1000 END END; PROCEDURE BUILD_DISCRETIONARY; LABEL 30, 10; VAR P : HALFWORD; Q : HALFWORD; N : INTEGER; BEGIN UNSAVE; Q ← CUR_LIST.HEAD_FIELD; P ← MEM[Q].HH.RH; N ← 0; WHILE P ≠ 0 DO BEGIN IF NOT (P ≥ HI_MEM_MIN) THEN IF MEM[P].HH.B0 > 2 THEN IF MEM[P].HH.B0 ≠ 11 THEN IF MEM[P].HH.B0 ≠ 6 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1107) END; BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 1108 END; ERROR; BEGIN_DIAGNOSTIC; PRINT_NL (1109); SHOW_BOX (P); END_DIAGNOSTIC (TRUE); FLUSH_NODE_LIST (P); MEM[Q].HH.RH ← 0; GOTO 30 END; Q ← P; P ← MEM[Q].HH.RH; N ← N + 1 END; 30: ; P ← MEM[CUR_LIST.HEAD_FIELD].HH.RH; POP_NEST; CASE SAVE_STACK[SAVE_PTR - 1].INT OF 0: MEM[CUR_LIST.TAIL_FIELD + 1].HH.LH ← P; 1: MEM[CUR_LIST.TAIL_FIELD + 1].HH.RH ← P; 2: BEGIN IF (N > 0) AND (ABS (CUR_LIST.MODE_FIELD) = 203) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1101) END; PRINT_ESC (349); BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 1102; HELP_LINE[0] ← 1103 END; FLUSH_NODE_LIST (P); N ← 0; ERROR END ELSE MEM[CUR_LIST.TAIL_FIELD].HH.RH ← P; IF N ≤ 255 THEN MEM[CUR_LIST.TAIL_FIELD].HH.B1 ← N ELSE BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1104) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 1105; HELP_LINE[0] ← 1106 END; ERROR END; IF N > 0 THEN CUR_LIST.TAIL_FIELD ← Q; SAVE_PTR ← SAVE_PTR - 1; GOTO 10 END; END; SAVE_STACK[SAVE_PTR - 1].INT ← SAVE_STACK[SAVE_PTR - 1].INT + 1; NEW_SAVE_LEVEL (10); SCAN_LEFT_BRACE; PUSH_NEST; CUR_LIST.MODE_FIELD ← -102; CUR_LIST.AUX_FIELD.HH.LH ← 1000; 10: END; PROCEDURE MAKE_ACCENT; VAR S : REAL; T : REAL; P : HALFWORD; Q : HALFWORD; R : HALFWORD; F : INTERNAL_FONT_NUMBER; A : SCALED; H : SCALED; X : SCALED; W : SCALED; DELTA : SCALED; I : FOUR_QUARTERS; BEGIN SCAN_CHAR_NUM; F ← EQTB[7834].HH.RH; P ← NEW_CHARACTER (F, CUR_VAL); IF P ≠ 0 THEN BEGIN X ← FONT_INFO[5 + PARAM_BASE[F]].INT; S ← FONT_INFO[1 + PARAM_BASE[F]].INT / 65536.0; A ← FONT_INFO[WIDTH_BASE[F] + FONT_INFO[CHAR_BASE[F] + MEM[P].HH.B1].QQQQ.B0].INT; DO_ASSIGNMENTS; Q ← 0; F ← EQTB[7834].HH.RH; IF (CUR_CMD = 11) OR (CUR_CMD = 12) OR (CUR_CMD = 68) THEN Q ← NEW_CHARACTER (F, CUR_CHR) ELSE IF CUR_CMD = 16 THEN BEGIN SCAN_CHAR_NUM; Q ← NEW_CHARACTER (F, CUR_VAL) END ELSE BACK_INPUT; IF Q ≠ 0 THEN BEGIN T ← FONT_INFO[1 + PARAM_BASE[F]].INT / 65536.0; I ← FONT_INFO[CHAR_BASE[F] + MEM[Q].HH.B1].QQQQ; W ← FONT_INFO[WIDTH_BASE[F] + I.B0].INT; H ← FONT_INFO[HEIGHT_BASE[F] + (I.B1 - 0) DIV 16].INT; IF H ≠ X THEN BEGIN P ← HPACK (P, 0, 1); MEM[P + 4].INT ← X - H END; DELTA ← ROUND ((W - A) / 2.0 + H * T - X * S); R ← NEW_KERN (DELTA); MEM[R].HH.B1 ← 2; MEM[CUR_LIST.TAIL_FIELD].HH.RH ← R; MEM[R].HH.RH ← P; CUR_LIST.TAIL_FIELD ← NEW_KERN (-A - DELTA); MEM[CUR_LIST.TAIL_FIELD].HH.B1 ← 2; MEM[P].HH.RH ← CUR_LIST.TAIL_FIELD; P ← Q END; MEM[CUR_LIST.TAIL_FIELD].HH.RH ← P; CUR_LIST.TAIL_FIELD ← P; CUR_LIST.AUX_FIELD.HH.LH ← 1000 END END; PROCEDURE ALIGN_ERROR; BEGIN IF ABS (ALIGN_STATE) > 2 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1114) END; PRINT_CMD_CHR (CUR_CMD, CUR_CHR); IF CUR_TOK = 1062 THEN BEGIN BEGIN HELP_PTR ← 6; HELP_LINE[5] ← 1115; HELP_LINE[4] ← 1116; HELP_LINE[3] ← 1117; HELP_LINE[2] ← 1118; HELP_LINE[1] ← 1119; HELP_LINE[0] ← 1120 END END ELSE BEGIN BEGIN HELP_PTR ← 5; HELP_LINE[4] ← 1115; HELP_LINE[3] ← 1121; HELP_LINE[2] ← 1118; HELP_LINE[1] ← 1119; HELP_LINE[0] ← 1120 END END; ERROR END ELSE BEGIN BACK_INPUT; IF ALIGN_STATE < 0 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (657) END; ALIGN_STATE ← ALIGN_STATE + 1; CUR_TOK ← 379 END ELSE BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1110) END; ALIGN_STATE ← ALIGN_STATE - 1; CUR_TOK ← 637 END; BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 1111; HELP_LINE[1] ← 1112; HELP_LINE[0] ← 1113 END; INS_ERROR END END; PROCEDURE NO_ALIGN_ERROR; BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1114) END; PRINT_ESC (527); BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 1122; HELP_LINE[0] ← 1123 END; ERROR END; PROCEDURE OMIT_ERROR; BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1114) END; PRINT_ESC (530); BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 1124; HELP_LINE[0] ← 1123 END; ERROR END; PROCEDURE DO_ENDV; BEGIN BASE_PTR ← INPUT_PTR; INPUT_STACK[BASE_PTR] ← CUR_INPUT; WHILE (INPUT_STACK[BASE_PTR].INDEX_FIELD ≠ 2) AND (INPUT_STACK[BASE_PTR].LOC_FIELD = 0) AND (INPUT_STACK[BASE_PTR].STATE_FIELD = 0) DO BASE_PTR ← BASE_PTR - 1; IF (INPUT_STACK[BASE_PTR].INDEX_FIELD ≠ 2) OR (INPUT_STACK[BASE_PTR].LOC_FIELD ≠ 0) OR (INPUT_STACK[BASE_PTR].STATE_FIELD ≠ 0) THEN FATAL_ERROR (595); IF CUR_GROUP = 6 THEN BEGIN END_GRAF; IF FIN_COL THEN FIN_ROW END ELSE OFF_SAVE END; PROCEDURE CS_ERROR; BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (777) END; PRINT_ESC (505); BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 1126 END; ERROR END; PROCEDURE PUSH_MATH (C:GROUP_CODE); BEGIN PUSH_NEST; CUR_LIST.MODE_FIELD ← -203; CUR_LIST.AUX_FIELD.INT ← 0; NEW_SAVE_LEVEL (C) END; PROCEDURE INIT_MATH; LABEL 21, 40, 45, 30; VAR W : SCALED; L : SCALED; S : SCALED; P : HALFWORD; Q : HALFWORD; F : INTERNAL_FONT_NUMBER; N : INTEGER; V : SCALED; D : SCALED; BEGIN GET_TOKEN; IF (CUR_CMD = 3) AND (CUR_LIST.MODE_FIELD > 0) THEN BEGIN IF CUR_LIST.HEAD_FIELD = CUR_LIST.TAIL_FIELD THEN BEGIN POP_NEST; W ← -1073741823 END ELSE BEGIN LINE_BREAK (EQTB[9170].INT); V ← MEM[JUST_BOX + 4].INT + 2 * FONT_INFO[6 + PARAM_BASE[EQTB[7834].HH.RH]].INT; W ← -1073741823; P ← MEM[JUST_BOX + 5].HH.RH; WHILE P ≠ 0 DO BEGIN 21: IF P ≥ HI_MEM_MIN THEN BEGIN F ← MEM[P].HH.B0; D ← FONT_INFO[ WIDTH_BASE[F] + FONT_INFO[CHAR_BASE[F] + MEM[P].HH.B1].QQQQ.B0]. INT; GOTO 40 END; CASE MEM[P].HH.B0 OF 0,1, 2: BEGIN D ← MEM[P + 1].INT; GOTO 40 END; 6: BEGIN MEM[59988] ← MEM[P + 1]; MEM[59988].HH.RH ← MEM[P].HH.RH; P ← 59988; GOTO 21 END; 11,9: D ← MEM[P + 1].INT; 10: BEGIN Q ← MEM[P + 1].HH.LH; D ← MEM[Q + 1].INT; IF MEM[JUST_BOX + 5].HH.B0 = 1 THEN BEGIN IF (MEM[JUST_BOX + 5].HH.B1 = MEM[Q].HH.B0) AND (MEM[Q + 2].INT ≠ 0) THEN V ← 1073741823 END ELSE IF MEM[JUST_BOX + 5].HH.B0 = 2 THEN BEGIN IF (MEM[JUST_BOX + 5].HH.B1 = MEM[Q].HH.B1) AND (MEM[Q + 3].INT ≠ 0) THEN V ← 1073741823 END; IF MEM[P].HH.B1 ≥ 100 THEN GOTO 40 END; 8: D ← 0; ELSE D ← 0; END; IF V < 1073741823 THEN V ← V + D; GOTO 45; 40: IF V < 1073741823 THEN BEGIN V ← V + D; W ← V END ELSE BEGIN W ← 1073741823; GOTO 30 END; 45: P ← MEM[P].HH.RH END; 30: END; IF EQTB[7312].HH.RH = 0 THEN IF (EQTB[9747].INT ≠ 0) AND ((EQTB[9204].INT ≥ 0) AND (CUR_LIST.PG_FIELD + 2 > EQTB[9204].INT) OR (CUR_LIST.PG_FIELD + 1 < -EQTB[9204].INT)) THEN BEGIN L ← EQTB[9733].INT - ABS (EQTB[9747].INT); IF EQTB[9747].INT > 0 THEN S ← EQTB[9747].INT ELSE S ← 0 END ELSE BEGIN L ← EQTB[9733].INT; S ← 0 END ELSE BEGIN N ← MEM[EQTB[7312].HH.RH].HH.LH; IF CUR_LIST.PG_FIELD + 2 ≥ N THEN P ← EQTB[7312].HH.RH + 2 * N ELSE P ← EQTB[7312].HH.RH + 2 * (CUR_LIST.PG_FIELD + 2); S ← MEM[P - 1].INT; L ← MEM[P].INT END; PUSH_MATH (15); CUR_LIST.MODE_FIELD ← 203; EQ_WORD_DEFINE (9207, -1); EQ_WORD_DEFINE (9743, W); EQ_WORD_DEFINE (9744, L); EQ_WORD_DEFINE (9745, S); IF EQTB[7316].HH.RH ≠ 0 THEN BEGIN_TOKEN_LIST (EQTB[7316].HH.RH, 9); IF NEST_PTR = 1 THEN BUILD_PAGE END ELSE BEGIN BACK_INPUT; BEGIN PUSH_MATH (15); EQ_WORD_DEFINE (9207, -1); IF EQTB[7315].HH.RH ≠ 0 THEN BEGIN_TOKEN_LIST (EQTB[7315].HH.RH, 8) END END END; PROCEDURE START_EQ_NO; BEGIN SAVE_STACK[SAVE_PTR + 0].INT ← CUR_CHR; SAVE_PTR ← SAVE_PTR + 1; BEGIN PUSH_MATH (15); EQ_WORD_DEFINE (9207, -1); IF EQTB[7315].HH.RH ≠ 0 THEN BEGIN_TOKEN_LIST (EQTB[7315].HH.RH, 8) END END; PROCEDURE SCAN_MATH (P:HALFWORD); LABEL 20, 21, 10; VAR C : INTEGER; BEGIN 20: REPEAT GET_X_TOKEN UNTIL (CUR_CMD ≠ 10) AND (CUR_CMD ≠ 0); 21: CASE CUR_CMD OF 11,12, 68: BEGIN C ← EQTB[8907 + CUR_CHR].HH.RH - 0; IF C = 32768 THEN BEGIN BEGIN CUR_CS ← CUR_CHR + 1; CUR_CMD ← EQTB[CUR_CS].HH.B0; CUR_CHR ← EQTB[CUR_CS].HH.RH; X_TOKEN; BACK_INPUT END; GOTO 20 END END; 16: BEGIN SCAN_CHAR_NUM; CUR_CHR ← CUR_VAL; CUR_CMD ← 68; GOTO 21 END; 17: BEGIN SCAN_FIFTEEN_BIT_INT; C ← CUR_VAL END; 69: C ← CUR_CHR; 15: BEGIN SCAN_TWENTY_SEVEN_BIT_INT; C ← CUR_VAL DIV 4096 END; ELSE BEGIN BACK_INPUT; SCAN_LEFT_BRACE; SAVE_STACK[SAVE_PTR + 0].INT ← P; SAVE_PTR ← SAVE_PTR + 1; PUSH_MATH (9); GOTO 10 END; END; MEM[P].HH.RH ← 1; MEM[P].HH.B1 ← C MOD 256 + 0; IF (C ≥ 28672) AND ((EQTB[9207].INT ≥ 0) AND (EQTB[9207].INT < 16)) THEN MEM[P].HH.B0 ← EQTB[9207].INT ELSE MEM[P].HH.B0 ← C DIV 256 MOD 16; 10: END; PROCEDURE SET_MATH_CHAR (C:INTEGER); VAR P : HALFWORD; BEGIN IF C ≥ 32768 THEN BEGIN CUR_CS ← CUR_CHR + 1; CUR_CMD ← EQTB[CUR_CS].HH.B0; CUR_CHR ← EQTB[CUR_CS].HH.RH; X_TOKEN; BACK_INPUT END ELSE BEGIN P ← NEW_NOAD; MEM[P + 1].HH.RH ← 1; MEM[P + 1].HH.B1 ← C MOD 256 + 0; MEM[P + 1].HH.B0 ← C DIV 256 MOD 16; IF C ≥ 28672 THEN BEGIN IF (EQTB[9207].INT ≥ 0) AND (EQTB[9207].INT < 16) THEN MEM[P + 1].HH.B0 ← EQTB[9207].INT; MEM[P].HH.B0 ← 16 END ELSE MEM[P].HH.B0 ← 16 + C DIV 4096; MEM[CUR_LIST.TAIL_FIELD].HH.RH ← P; CUR_LIST.TAIL_FIELD ← P END END; PROCEDURE MATH_LIMIT_SWITCH; LABEL 10; BEGIN IF CUR_LIST.HEAD_FIELD ≠ CUR_LIST.TAIL_FIELD THEN IF MEM[CUR_LIST.TAIL_FIELD].HH.B0 = 17 THEN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.B1 ← CUR_CHR; GOTO 10 END; BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1130) END; BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 1131 END; ERROR; 10: END; PROCEDURE SCAN_DELIMITER (P:HALFWORD; R:BOOLEAN); BEGIN IF R THEN SCAN_TWENTY_SEVEN_BIT_INT ELSE BEGIN REPEAT GET_X_TOKEN UNTIL (CUR_CMD ≠ 10) AND (CUR_CMD ≠ 0); CASE CUR_CMD OF 11,12: CUR_VAL ← EQTB[9474 + CUR_CHR].INT; 15: SCAN_TWENTY_SEVEN_BIT_INT; ELSE CUR_VAL ← -1; END END; IF CUR_VAL < 0 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1132) END; BEGIN HELP_PTR ← 6; HELP_LINE[5] ← 1133; HELP_LINE[4] ← 1134; HELP_LINE[3] ← 1135; HELP_LINE[2] ← 1136; HELP_LINE[1] ← 1137; HELP_LINE[0] ← 1138 END; BACK_ERROR; CUR_VAL ← 0 END; MEM[P].QQQQ.B0 ← CUR_VAL DIV 1048576 MOD 16; MEM[P].QQQQ.B1 ← CUR_VAL DIV 4096 MOD 256 + 0; MEM[P].QQQQ.B2 ← CUR_VAL DIV 256 MOD 16; MEM[P].QQQQ.B3 ← CUR_VAL MOD 256 + 0 END; PROCEDURE MATH_RADICAL; BEGIN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← GET_NODE (5); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; MEM[CUR_LIST.TAIL_FIELD].HH.B0 ← 24; MEM[CUR_LIST.TAIL_FIELD].HH.B1 ← 0; MEM[CUR_LIST.TAIL_FIELD + 1].HH ← EMPTY_FIELD; MEM[CUR_LIST.TAIL_FIELD + 3].HH ← EMPTY_FIELD; MEM[CUR_LIST.TAIL_FIELD + 2].HH ← EMPTY_FIELD; SCAN_DELIMITER (CUR_LIST.TAIL_FIELD + 4, TRUE); SCAN_MATH (CUR_LIST.TAIL_FIELD + 1) END; PROCEDURE MATH_AC; BEGIN IF CUR_CMD = 45 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1139) END; PRINT_ESC (523); PRINT (1140); BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 1141; HELP_LINE[0] ← 1142 END; ERROR END; BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← GET_NODE (5); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; MEM[CUR_LIST.TAIL_FIELD].HH.B0 ← 28; MEM[CUR_LIST.TAIL_FIELD].HH.B1 ← 0; MEM[CUR_LIST.TAIL_FIELD + 1].HH ← EMPTY_FIELD; MEM[CUR_LIST.TAIL_FIELD + 3].HH ← EMPTY_FIELD; MEM[CUR_LIST.TAIL_FIELD + 2].HH ← EMPTY_FIELD; MEM[CUR_LIST.TAIL_FIELD + 4].HH.RH ← 1; SCAN_FIFTEEN_BIT_INT; MEM[CUR_LIST.TAIL_FIELD + 4].HH.B1 ← CUR_VAL MOD 256 + 0; IF (CUR_VAL ≥ 28672) AND ((EQTB[9207].INT ≥ 0) AND (EQTB[9207].INT < 16)) THEN MEM[CUR_LIST.TAIL_FIELD + 4].HH.B0 ← EQTB[9207].INT ELSE MEM[CUR_LIST.TAIL_FIELD + 4].HH.B0 ← CUR_VAL DIV 256 MOD 16; SCAN_MATH (CUR_LIST.TAIL_FIELD + 1) END; PROCEDURE APPEND_CHOICES; BEGIN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_CHOICE; CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; SAVE_PTR ← SAVE_PTR + 1; SAVE_STACK[SAVE_PTR - 1].INT ← 0; PUSH_MATH (13); SCAN_LEFT_BRACE END; FUNCTION FIN_MLIST (P:HALFWORD):HALFWORD; VAR Q : HALFWORD; BEGIN IF CUR_LIST.AUX_FIELD.INT ≠ 0 THEN BEGIN MEM[CUR_LIST.AUX_FIELD.INT + 3].HH.RH ← 3; MEM[CUR_LIST.AUX_FIELD.INT + 3].HH.LH ← MEM[CUR_LIST.HEAD_FIELD].HH.RH; IF P = 0 THEN Q ← CUR_LIST.AUX_FIELD.INT ELSE BEGIN Q ← MEM[CUR_LIST.AUX_FIELD.INT + 2].HH.LH; IF MEM[Q].HH.B0 ≠ 30 THEN CONFUSION (877); MEM[CUR_LIST.AUX_FIELD.INT + 2].HH.LH ← MEM[Q].HH.RH; MEM[Q].HH.RH ← CUR_LIST.AUX_FIELD.INT; MEM[CUR_LIST.AUX_FIELD.INT].HH.RH ← P END END ELSE BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← P; Q ← MEM[CUR_LIST.HEAD_FIELD].HH.RH END; POP_NEST; FIN_MLIST ← Q END; PROCEDURE BUILD_CHOICES; LABEL 10; VAR P : HALFWORD; BEGIN UNSAVE; P ← FIN_MLIST (0); CASE SAVE_STACK[SAVE_PTR - 1].INT OF 0: MEM[CUR_LIST.TAIL_FIELD + 1].HH.LH ← P; 1: MEM[CUR_LIST.TAIL_FIELD + 1].HH.RH ← P; 2: MEM[CUR_LIST.TAIL_FIELD + 2].HH.LH ← P; 3: BEGIN MEM[CUR_LIST.TAIL_FIELD + 2].HH.RH ← P; SAVE_PTR ← SAVE_PTR - 1; GOTO 10 END; END; SAVE_STACK[SAVE_PTR - 1].INT ← SAVE_STACK[SAVE_PTR - 1].INT + 1; PUSH_MATH (13); SCAN_LEFT_BRACE; 10: END; PROCEDURE SUB_SUP; VAR T : SMALL_NUMBER; P : HALFWORD; BEGIN T ← 0; P ← 0; IF CUR_LIST.TAIL_FIELD ≠ CUR_LIST.HEAD_FIELD THEN IF (MEM[CUR_LIST.TAIL_FIELD].HH.B0 ≥ 16) AND (MEM[CUR_LIST.TAIL_FIELD].HH.B0 < 30) THEN BEGIN P ← CUR_LIST.TAIL_FIELD + 2 + CUR_CMD - 7; T ← MEM[P].HH.RH END; IF (P = 0) OR (T ≠ 0) THEN BEGIN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_NOAD; CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; P ← CUR_LIST.TAIL_FIELD + 2 + CUR_CMD - 7; IF T ≠ 0 THEN BEGIN IF CUR_CMD = 7 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1143) END; BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 1144 END END ELSE BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1145) END; BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 1146 END END; ERROR END END; SCAN_MATH (P) END; PROCEDURE MATH_FRACTION; VAR C : SMALL_NUMBER; BEGIN C ← CUR_CHR; IF CUR_LIST.AUX_FIELD.INT ≠ 0 THEN BEGIN IF C ≥ 3 THEN BEGIN SCAN_DELIMITER (59988, FALSE); SCAN_DELIMITER (59988, FALSE) END; IF C MOD 3 = 0 THEN SCAN_DIMEN (FALSE, FALSE, FALSE); BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1153) END; BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 1154; HELP_LINE[1] ← 1155; HELP_LINE[0] ← 1156 END; ERROR END ELSE BEGIN CUR_LIST.AUX_FIELD.INT ← GET_NODE (6); MEM[CUR_LIST.AUX_FIELD.INT].HH.B0 ← 25; MEM[CUR_LIST.AUX_FIELD.INT].HH.B1 ← 0; MEM[CUR_LIST.AUX_FIELD.INT + 2].HH.RH ← 3; MEM[CUR_LIST.AUX_FIELD.INT + 2].HH.LH ← MEM[CUR_LIST.HEAD_FIELD].HH.RH; MEM[CUR_LIST.AUX_FIELD.INT + 3].HH ← EMPTY_FIELD; MEM[CUR_LIST.AUX_FIELD.INT + 4].QQQQ ← NULL_DELIMITER; MEM[CUR_LIST.AUX_FIELD.INT + 5].QQQQ ← NULL_DELIMITER; MEM[CUR_LIST.HEAD_FIELD].HH.RH ← 0; CUR_LIST.TAIL_FIELD ← CUR_LIST.HEAD_FIELD; IF C ≥ 3 THEN BEGIN SCAN_DELIMITER (CUR_LIST.AUX_FIELD.INT + 4, FALSE); SCAN_DELIMITER (CUR_LIST.AUX_FIELD.INT + 5, FALSE) END; CASE C MOD 3 OF 0: BEGIN SCAN_DIMEN (FALSE, FALSE, FALSE); MEM[CUR_LIST.AUX_FIELD.INT + 1].INT ← CUR_VAL END; 1: MEM[CUR_LIST.AUX_FIELD.INT + 1].INT ← 1073741824; 2: MEM[CUR_LIST.AUX_FIELD.INT + 1].INT ← 0; END END END; PROCEDURE MATH_LEFT_RIGHT; VAR T : SMALL_NUMBER; P : HALFWORD; BEGIN T ← CUR_CHR; IF (T = 31) AND (CUR_GROUP ≠ 16) THEN BEGIN IF CUR_GROUP = 15 THEN BEGIN SCAN_DELIMITER (59988, FALSE); BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (777) END; PRINT_ESC (877); BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 1157 END; ERROR END ELSE OFF_SAVE END ELSE BEGIN P ← NEW_NOAD; MEM[P].HH.B0 ← T; SCAN_DELIMITER (P + 1, FALSE); IF T = 30 THEN BEGIN PUSH_MATH (16); MEM[CUR_LIST.HEAD_FIELD].HH.RH ← P; CUR_LIST.TAIL_FIELD ← P END ELSE BEGIN P ← FIN_MLIST (P); UNSAVE; BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_NOAD; CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; MEM[CUR_LIST.TAIL_FIELD].HH.B0 ← 23; MEM[CUR_LIST.TAIL_FIELD + 1].HH.RH ← 3; MEM[CUR_LIST.TAIL_FIELD + 1].HH.LH ← P END END END; PROCEDURE AFTER_MATH; VAR L : BOOLEAN; DANGER : BOOLEAN; M : INTEGER; P : HALFWORD; A : HALFWORD; B : HALFWORD; W : SCALED; Z : SCALED; E : SCALED; Q : SCALED; D : SCALED; S : SCALED; G1 : SMALL_NUMBER; G2 : SMALL_NUMBER; R : HALFWORD; T : HALFWORD; BEGIN DANGER ← FALSE; IF (FONT_PARAMS[EQTB[7837].HH.RH] < 22) OR (FONT_PARAMS[EQTB[7853].HH.RH] < 22) OR (FONT_PARAMS[EQTB[7869].HH.RH] < 22) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1158) END; BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 1159; HELP_LINE[1] ← 1160; HELP_LINE[0] ← 1161 END; ERROR; FLUSH_MATH; DANGER ← TRUE END ELSE IF (FONT_PARAMS[EQTB[7838].HH.RH] < 13) OR (FONT_PARAMS[EQTB[7854].HH.RH] < 13) OR (FONT_PARAMS[EQTB[7870].HH.RH] < 13) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1162) END; BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 1163; HELP_LINE[1] ← 1164; HELP_LINE[0] ← 1165 END; ERROR; FLUSH_MATH; DANGER ← TRUE END; M ← CUR_LIST.MODE_FIELD; L ← FALSE; P ← FIN_MLIST (0); IF CUR_LIST.MODE_FIELD = -M THEN BEGIN BEGIN GET_X_TOKEN; IF CUR_CMD ≠ 3 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1166) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 1167; HELP_LINE[0] ← 1168 END; BACK_ERROR END END; CUR_MLIST ← P; CUR_STYLE ← 2; MLIST_PENALTIES ← FALSE; MLIST_TO_HLIST; A ← HPACK (MEM[59997].HH.RH, 0, 1); UNSAVE; SAVE_PTR ← SAVE_PTR - 1; IF SAVE_STACK[SAVE_PTR + 0].INT = 1 THEN L ← TRUE; DANGER ← FALSE; IF (FONT_PARAMS[EQTB[7837].HH.RH] < 22) OR (FONT_PARAMS[EQTB[7853].HH.RH] < 22) OR (FONT_PARAMS[EQTB[7869].HH.RH] < 22) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1158) END; BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 1159; HELP_LINE[1] ← 1160; HELP_LINE[0] ← 1161 END; ERROR; FLUSH_MATH; DANGER ← TRUE END ELSE IF (FONT_PARAMS[EQTB[7838].HH.RH] < 13) OR (FONT_PARAMS[EQTB[7854].HH.RH] < 13) OR (FONT_PARAMS[EQTB[7870].HH.RH] < 13) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1162) END; BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 1163; HELP_LINE[1] ← 1164; HELP_LINE[0] ← 1165 END; ERROR; FLUSH_MATH; DANGER ← TRUE END; M ← CUR_LIST.MODE_FIELD; P ← FIN_MLIST (0) END ELSE A ← 0; IF M < 0 THEN BEGIN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_MATH (EQTB[9731].INT, 0); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; CUR_MLIST ← P; CUR_STYLE ← 2; MLIST_PENALTIES ← CUR_LIST.MODE_FIELD > 0; MLIST_TO_HLIST; MEM[CUR_LIST.TAIL_FIELD].HH.RH ← MEM[59997].HH.RH; WHILE MEM[CUR_LIST.TAIL_FIELD].HH.RH ≠ 0 DO CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH; BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_MATH (EQTB[9731].INT, 1); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; CUR_LIST.AUX_FIELD.HH.LH ← 1000; UNSAVE END ELSE BEGIN IF A = 0 THEN BEGIN GET_X_TOKEN; IF CUR_CMD ≠ 3 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1166) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 1167; HELP_LINE[0] ← 1168 END; BACK_ERROR END END; CUR_MLIST ← P; CUR_STYLE ← 0; MLIST_PENALTIES ← FALSE; MLIST_TO_HLIST; P ← MEM[59997].HH.RH; ADJUST_TAIL ← 59995; B ← HPACK (P, 0, 1); P ← MEM[B + 5].HH.RH; T ← ADJUST_TAIL; ADJUST_TAIL ← 0; W ← MEM[B + 1].INT; Z ← EQTB[9744].INT; S ← EQTB[9745].INT; IF (A = 0) OR DANGER THEN BEGIN E ← 0; Q ← 0 END ELSE BEGIN E ← MEM[A + 1].INT; Q ← E + FONT_INFO[6 + PARAM_BASE[EQTB[7837].HH.RH]].INT END; IF W + Q > Z THEN BEGIN IF (E ≠ 0) AND ((W - TOTAL_SHRINK[0] + Q ≤ Z) OR (TOTAL_SHRINK[1] ≠ 0) OR (TOTAL_SHRINK[2] ≠ 0) OR (TOTAL_SHRINK[3] ≠ 0)) THEN BEGIN FREE_NODE (B, 7); B ← HPACK (P, Z - Q, 0) END ELSE BEGIN E ← 0; IF W > Z THEN BEGIN FREE_NODE (B, 7); B ← HPACK (P, Z, 0) END END; W ← MEM[B + 1].INT END; D ← HALF (Z - W); IF (E > 0) AND (D < 2 * E) THEN BEGIN D ← HALF (Z - W - E); IF P ≠ 0 THEN IF NOT (P ≥ HI_MEM_MIN) THEN IF MEM[P].HH.B0 = 10 THEN D ← 0 END; BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_PENALTY (EQTB[9174].INT); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; IF (D + S ≤ EQTB[9743].INT) OR L THEN BEGIN G1 ← 3; G2 ← 4 END ELSE BEGIN G1 ← 5; G2 ← 6 END; IF L AND (E = 0) THEN BEGIN MEM[A + 4].INT ← S; APPEND_TO_VLIST (A); BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_PENALTY (10000); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END END ELSE BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_PARAM_GLUE (G1); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; IF E ≠ 0 THEN BEGIN R ← NEW_KERN (Z - W - E - D); IF L THEN BEGIN MEM[A].HH.RH ← R; MEM[R].HH.RH ← B; B ← A; D ← 0 END ELSE BEGIN MEM[B].HH.RH ← R; MEM[R].HH.RH ← A END; B ← HPACK (B, 0, 1) END; MEM[B + 4].INT ← S + D; APPEND_TO_VLIST (B); IF (A ≠ 0) AND (E = 0) AND NOT L THEN BEGIN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_PENALTY (10000); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; MEM[A + 4].INT ← S + Z - MEM[A + 1].INT; APPEND_TO_VLIST (A); G2 ← 0 END; IF T ≠ 59995 THEN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← MEM[59995].HH.RH; CUR_LIST.TAIL_FIELD ← T END; BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_PENALTY (EQTB[9175].INT); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; IF G2 > 0 THEN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_PARAM_GLUE (G2); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; RESUME_AFTER_DISPLAY END END; PROCEDURE RESUME_AFTER_DISPLAY; BEGIN IF CUR_GROUP ≠ 15 THEN CONFUSION (1169); UNSAVE; CUR_LIST.PG_FIELD ← CUR_LIST.PG_FIELD + 3; PUSH_NEST; CUR_LIST.MODE_FIELD ← 102; CUR_LIST.AUX_FIELD.HH.LH ← 1000; IF EQTB[9213].INT ≤ 0 THEN CUR_LANG ← 0 ELSE IF EQTB[9213].INT > 255 THEN CUR_LANG ← 0 ELSE CUR_LANG ← EQTB[9213].INT; CUR_LIST.AUX_FIELD.HH.RH ← CUR_LANG; CUR_LIST.PG_FIELD ← (NORM_MIN (EQTB[9214].INT) * 64 + NORM_MIN (EQTB[9215].INT)) * 65536 + CUR_LANG; BEGIN GET_X_TOKEN; IF CUR_CMD ≠ 10 THEN BACK_INPUT END; IF NEST_PTR = 1 THEN BUILD_PAGE END; PROCEDURE GET_R_TOKEN; LABEL 20; BEGIN 20: REPEAT GET_TOKEN UNTIL CUR_TOK ≠ 2592; IF (CUR_CS = 0) OR (CUR_CS > 6514) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1184) END; BEGIN HELP_PTR ← 5; HELP_LINE[4] ← 1185; HELP_LINE[3] ← 1186; HELP_LINE[2] ← 1187; HELP_LINE[1] ← 1188; HELP_LINE[0] ← 1189 END; IF CUR_CS = 0 THEN BACK_INPUT; CUR_TOK ← 10609; INS_ERROR; GOTO 20 END END; PROCEDURE TRAP_ZERO_GLUE; BEGIN IF (MEM[CUR_VAL + 1].INT = 0) AND (MEM[CUR_VAL + 2].INT = 0) AND (MEM[CUR_VAL + 3].INT = 0) THEN BEGIN MEM[0].HH.RH ← MEM[0].HH.RH + 1; DELETE_GLUE_REF (CUR_VAL); CUR_VAL ← 0 END END; PROCEDURE DO_REGISTER_COMMAND (A:SMALL_NUMBER); LABEL 40, 10; VAR L : HALFWORD; Q : HALFWORD; R : HALFWORD; S : HALFWORD; P : 0..3; BEGIN Q ← CUR_CMD; BEGIN IF Q ≠ 89 THEN BEGIN GET_X_TOKEN; IF (CUR_CMD ≥ 73) AND (CUR_CMD ≤ 76) THEN BEGIN L ← CUR_CHR; P ← CUR_CMD - 73; GOTO 40 END; IF CUR_CMD ≠ 89 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (685) END; PRINT_CMD_CHR (CUR_CMD, CUR_CHR); PRINT (686); PRINT_CMD_CHR (Q, 0); BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 1210 END; ERROR; GOTO 10 END END; P ← CUR_CHR; SCAN_EIGHT_BIT_INT; CASE P OF 0: L ← CUR_VAL + 9218; 1: L ← CUR_VAL + 9751; 2: L ← CUR_VAL + 6800; 3: L ← CUR_VAL + 7056; END END; 40: ; IF Q = 89 THEN SCAN_OPTIONAL_EQUALS ELSE IF SCAN_KEYWORD (1206) THEN ; ARITH_ERROR ← FALSE; IF Q < 91 THEN IF P < 2 THEN BEGIN IF P = 0 THEN SCAN_INT ELSE SCAN_DIMEN (FALSE, FALSE, FALSE); IF Q = 90 THEN CUR_VAL ← CUR_VAL + EQTB[L].INT END ELSE BEGIN SCAN_GLUE (P); IF Q = 90 THEN BEGIN Q ← NEW_SPEC (CUR_VAL); R ← EQTB[L].HH.RH; DELETE_GLUE_REF (CUR_VAL); MEM[Q + 1].INT ← MEM[Q + 1].INT + MEM[R + 1].INT; IF MEM[Q + 2].INT = 0 THEN MEM[Q].HH.B0 ← 0; IF MEM[Q].HH.B0 = MEM[R].HH.B0 THEN MEM[Q + 2].INT ← MEM[Q + 2].INT + MEM[R + 2].INT ELSE IF (MEM[Q].HH.B0 < MEM[R].HH.B0) AND (MEM[R + 2].INT ≠ 0) THEN BEGIN MEM[Q + 2].INT ← MEM[R + 2].INT; MEM[Q].HH.B0 ← MEM[R].HH.B0 END; IF MEM[Q + 3].INT = 0 THEN MEM[Q].HH.B1 ← 0; IF MEM[Q].HH.B1 = MEM[R].HH.B1 THEN MEM[Q + 3].INT ← MEM[Q + 3].INT + MEM[R + 3].INT ELSE IF (MEM[Q].HH.B1 < MEM[R].HH.B1) AND (MEM[R + 3].INT ≠ 0) THEN BEGIN MEM[Q + 3].INT ← MEM[R + 3].INT; MEM[Q].HH.B1 ← MEM[R].HH.B1 END; CUR_VAL ← Q END END ELSE BEGIN SCAN_INT; IF P < 2 THEN IF Q = 91 THEN IF P = 0 THEN CUR_VAL ← MULT_AND_ADD (EQTB[L].INT, CUR_VAL, 0, 2147483647) ELSE CUR_VAL ← MULT_AND_ADD (EQTB[L].INT, CUR_VAL, 0, 1073741823) ELSE CUR_VAL ← X_OVER_N (EQTB[L].INT, CUR_VAL) ELSE BEGIN S ← EQTB[L].HH.RH; R ← NEW_SPEC (S); IF Q = 91 THEN BEGIN MEM[R + 1].INT ← MULT_AND_ADD (MEM[S + 1].INT, CUR_VAL, 0, 1073741823); MEM[R + 2].INT ← MULT_AND_ADD (MEM[S + 2].INT, CUR_VAL, 0, 1073741823); MEM[R + 3].INT ← MULT_AND_ADD (MEM[S + 3].INT, CUR_VAL, 0, 1073741823) END ELSE BEGIN MEM[R + 1].INT ← X_OVER_N (MEM[S + 1].INT, CUR_VAL); MEM[R + 2].INT ← X_OVER_N (MEM[S + 2].INT, CUR_VAL); MEM[R + 3].INT ← X_OVER_N (MEM[S + 3].INT, CUR_VAL) END; CUR_VAL ← R END END; IF ARITH_ERROR THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1207) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 1208; HELP_LINE[0] ← 1209 END; IF P ≥ 2 THEN DELETE_GLUE_REF (CUR_VAL); ERROR; GOTO 10 END; IF P < 2 THEN IF A ≥ 4 THEN GEQ_WORD_DEFINE (L, CUR_VAL) ELSE EQ_WORD_DEFINE (L, CUR_VAL) ELSE BEGIN TRAP_ZERO_GLUE; IF A ≥ 4 THEN GEQ_DEFINE (L, 117, CUR_VAL) ELSE EQ_DEFINE (L, 117, CUR_VAL) END; 10: END; PROCEDURE ALTER_AUX; VAR C : HALFWORD; BEGIN IF CUR_CHR ≠ ABS (CUR_LIST.MODE_FIELD) THEN REPORT_ILLEGAL_CASE ELSE BEGIN C ← CUR_CHR; SCAN_OPTIONAL_EQUALS; IF C = 1 THEN BEGIN SCAN_DIMEN (FALSE, FALSE, FALSE); CUR_LIST.AUX_FIELD.INT ← CUR_VAL END ELSE BEGIN SCAN_INT; IF (CUR_VAL ≤ 0) OR (CUR_VAL > 32767) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1213) END; BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 1214 END; INT_ERROR (CUR_VAL) END ELSE CUR_LIST.AUX_FIELD.HH.LH ← CUR_VAL END END END; PROCEDURE ALTER_PREV_GRAF; VAR P : 0..NEST_SIZE; BEGIN NEST[NEST_PTR] ← CUR_LIST; P ← NEST_PTR; WHILE ABS (NEST[P].MODE_FIELD) ≠ 1 DO P ← P - 1; SCAN_OPTIONAL_EQUALS; SCAN_INT; IF CUR_VAL < 0 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (955) END; PRINT_ESC (532); BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 1215 END; INT_ERROR (CUR_VAL) END ELSE BEGIN NEST[P].PG_FIELD ← CUR_VAL; CUR_LIST ← NEST[NEST_PTR] END END; PROCEDURE ALTER_PAGE_SO_FAR; VAR C : 0..7; BEGIN C ← CUR_CHR; SCAN_OPTIONAL_EQUALS; SCAN_DIMEN (FALSE, FALSE, FALSE); PAGE_SO_FAR[C] ← CUR_VAL END; PROCEDURE ALTER_INTEGER; VAR C : 0..1; BEGIN C ← CUR_CHR; SCAN_OPTIONAL_EQUALS; SCAN_INT; IF C = 0 THEN DEAD_CYCLES ← CUR_VAL ELSE INSERT_PENALTIES ← CUR_VAL END; PROCEDURE ALTER_BOX_DIMEN; VAR C : SMALL_NUMBER; B : EIGHT_BITS; BEGIN C ← CUR_CHR; SCAN_EIGHT_BIT_INT; B ← CUR_VAL; SCAN_OPTIONAL_EQUALS; SCAN_DIMEN (FALSE, FALSE, FALSE); IF EQTB[7578 + B].HH.RH ≠ 0 THEN MEM[EQTB[7578 + B].HH.RH + C].INT ← CUR_VAL END; PROCEDURE NEW_FONT (A:SMALL_NUMBER); LABEL 50; VAR U : HALFWORD; S : SCALED; F : INTERNAL_FONT_NUMBER; T : STR_NUMBER; OLD_SETTING : 0..21; FLUSHABLE_STRING : STR_NUMBER; BEGIN IF JOB_NAME = 0 THEN OPEN_LOG_FILE; GET_R_TOKEN; U ← CUR_CS; IF U ≥ 514 THEN T ← HASH[U].RH ELSE IF U ≥ 257 THEN IF U = 513 THEN T ← 1219 ELSE T ← U - 257 ELSE BEGIN OLD_SETTING ← SELECTOR; SELECTOR ← 21; PRINT (1219); PRINT (U - 1); SELECTOR ← OLD_SETTING; BEGIN IF POOL_PTR + 1 > POOL_SIZE THEN OVERFLOW (257, POOL_SIZE - INIT_POOL_PTR) END; T ← MAKE_STRING END; IF A ≥ 4 THEN GEQ_DEFINE (U, 87, 0) ELSE EQ_DEFINE (U, 87, 0); SCAN_OPTIONAL_EQUALS; SCAN_FILE_NAME; NAME_IN_PROGRESS ← TRUE; IF SCAN_KEYWORD (1220) THEN BEGIN SCAN_DIMEN (FALSE, FALSE, FALSE); S ← CUR_VAL; IF (S ≤ 0) OR (S ≥ 134217728) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1222) END; PRINT_SCALED (S); PRINT (1223); BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 1224; HELP_LINE[0] ← 1225 END; ERROR; S ← 10 * 65536 END END ELSE IF SCAN_KEYWORD (1221) THEN BEGIN SCAN_INT; S ← -CUR_VAL; IF (CUR_VAL ≤ 0) OR (CUR_VAL > 32768) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (552) END; BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 553 END; INT_ERROR (CUR_VAL); S ← -1000 END END ELSE S ← -1000; NAME_IN_PROGRESS ← FALSE; FLUSHABLE_STRING ← STR_PTR - 1; FOR F ← 1 TO FONT_PTR DO IF STR_EQ_STR (FONT_NAME[F], CUR_NAME) AND STR_EQ_STR (FONT_AREA[F], CUR_AREA) THEN BEGIN IF CUR_NAME = FLUSHABLE_STRING THEN BEGIN BEGIN STR_PTR ← STR_PTR - 1; POOL_PTR ← STR_START[STR_PTR] END; CUR_NAME ← FONT_NAME[F] END; IF S > 0 THEN BEGIN IF S = FONT_SIZE[F] THEN GOTO 50 END ELSE IF FONT_SIZE[F] = XN_OVER_D (FONT_DSIZE[F], -S, 1000) THEN GOTO 50 END; F ← READ_FONT_INFO (U, CUR_NAME, CUR_AREA, S); 50: EQTB[U].HH.RH ← F; EQTB[6524 + F] ← EQTB[U]; HASH[6524 + F].RH ← T END; PROCEDURE NEW_INTERACTION; BEGIN PRINT_LN; INTERACTION ← CUR_CHR; IF INTERACTION = 0 THEN SELECTOR ← 16 ELSE SELECTOR ← 17; IF LOG_OPENED THEN SELECTOR ← SELECTOR + 2 END; PROCEDURE PREFIXED_COMMAND; LABEL 30, 10; VAR A : SMALL_NUMBER; F : INTERNAL_FONT_NUMBER; J : HALFWORD; K : FONT_INDEX; P : HALFWORD; Q : HALFWORD; N : INTEGER; E : BOOLEAN; BEGIN A ← 0; WHILE CUR_CMD = 93 DO BEGIN IF NOT ODD ((A DIV CUR_CHR)) THEN A ← A + CUR_CHR; REPEAT GET_X_TOKEN UNTIL (CUR_CMD ≠ 10) AND (CUR_CMD ≠ 0); IF CUR_CMD ≤ 70 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1179) END; PRINT_CMD_CHR (CUR_CMD, CUR_CHR); PRINT_CHAR (39); BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 1180 END; BACK_ERROR; GOTO 10 END END; IF (CUR_CMD ≠ 97) AND (A MOD 4 ≠ 0) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (685) END; PRINT_ESC (1171); PRINT (1181); PRINT_ESC (1172); PRINT (1182); PRINT_CMD_CHR (CUR_CMD, CUR_CHR); PRINT_CHAR (39); BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 1183 END; ERROR END; IF EQTB[9206].INT ≠ 0 THEN IF EQTB[9206].INT < 0 THEN BEGIN IF A ≥ 4 THEN A ← A - 4 END ELSE BEGIN IF NOT (A ≥ 4) THEN A ← A + 4 END; CASE CUR_CMD OF 87: IF A ≥ 4 THEN GEQ_DEFINE (7834, 120, CUR_CHR) ELSE EQ_DEFINE (7834, 120, CUR_CHR); 97: BEGIN IF ODD (CUR_CHR) AND NOT (A ≥ 4) AND (EQTB[9206].INT ≥ 0) THEN A ← A + 4; E ← CUR_CHR ≥ 2; GET_R_TOKEN; P ← CUR_CS; Q ← SCAN_TOKS (TRUE, E); IF A ≥ 4 THEN GEQ_DEFINE (P, 111 + A MOD 4, DEF_REF) ELSE EQ_DEFINE (P, 111 + A MOD 4, DEF_REF) END; 94: BEGIN N ← CUR_CHR; GET_R_TOKEN; P ← CUR_CS; IF N = 0 THEN BEGIN REPEAT GET_TOKEN UNTIL CUR_CMD ≠ 10; IF CUR_TOK = 3133 THEN BEGIN GET_TOKEN; IF CUR_CMD = 10 THEN GET_TOKEN END END ELSE BEGIN GET_TOKEN; Q ← CUR_TOK; GET_TOKEN; BACK_INPUT; CUR_TOK ← Q; BACK_INPUT END; IF CUR_CMD ≥ 111 THEN MEM[CUR_CHR].HH.LH ← MEM[CUR_CHR].HH.LH + 1; IF A ≥ 4 THEN GEQ_DEFINE (P, CUR_CMD, CUR_CHR) ELSE EQ_DEFINE (P, CUR_CMD, CUR_CHR) END; 95: BEGIN N ← CUR_CHR; GET_R_TOKEN; P ← CUR_CS; IF A ≥ 4 THEN GEQ_DEFINE (P, 0, 256) ELSE EQ_DEFINE (P, 0, 256); SCAN_OPTIONAL_EQUALS; CASE N OF 0: BEGIN SCAN_CHAR_NUM; IF A ≥ 4 THEN GEQ_DEFINE (P, 68, CUR_VAL) ELSE EQ_DEFINE (P, 68, CUR_VAL) END; 1: BEGIN SCAN_FIFTEEN_BIT_INT; IF A ≥ 4 THEN GEQ_DEFINE (P, 69, CUR_VAL) ELSE EQ_DEFINE (P, 69, CUR_VAL) END; ELSE BEGIN SCAN_EIGHT_BIT_INT; CASE N OF 2: IF A ≥ 4 THEN GEQ_DEFINE (P, 73, 9218 + CUR_VAL) ELSE EQ_DEFINE (P, 73, 9218 + CUR_VAL); 3: IF A ≥ 4 THEN GEQ_DEFINE (P, 74, 9751 + CUR_VAL) ELSE EQ_DEFINE (P, 74, 9751 + CUR_VAL); 4: IF A ≥ 4 THEN GEQ_DEFINE (P, 75, 6800 + CUR_VAL) ELSE EQ_DEFINE (P, 75, 6800 + CUR_VAL); 5: IF A ≥ 4 THEN GEQ_DEFINE (P, 76, 7056 + CUR_VAL) ELSE EQ_DEFINE (P, 76, 7056 + CUR_VAL); 6: IF A ≥ 4 THEN GEQ_DEFINE (P, 72, 7322 + CUR_VAL) ELSE EQ_DEFINE (P, 72, 7322 + CUR_VAL); END END; END END; 96: BEGIN SCAN_INT; N ← CUR_VAL; IF NOT SCAN_KEYWORD (842) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1073) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 1200; HELP_LINE[0] ← 1201 END; ERROR END; GET_R_TOKEN; P ← CUR_CS; READ_TOKS (N, P); IF A ≥ 4 THEN GEQ_DEFINE (P, 111, CUR_VAL) ELSE EQ_DEFINE (P, 111, CUR_VAL) END; 71, 72: BEGIN Q ← CUR_CS; IF CUR_CMD = 71 THEN BEGIN SCAN_EIGHT_BIT_INT; P ← 7322 + CUR_VAL END ELSE P ← CUR_CHR; SCAN_OPTIONAL_EQUALS; REPEAT GET_X_TOKEN UNTIL (CUR_CMD ≠ 10) AND (CUR_CMD ≠ 0); IF CUR_CMD ≠ 1 THEN BEGIN IF CUR_CMD = 71 THEN BEGIN SCAN_EIGHT_BIT_INT; CUR_CMD ← 72; CUR_CHR ← 7322 + CUR_VAL END; IF CUR_CMD = 72 THEN BEGIN Q ← EQTB[CUR_CHR].HH.RH; IF Q = 0 THEN IF A ≥ 4 THEN GEQ_DEFINE (P, 101, 0) ELSE EQ_DEFINE (P, 101, 0) ELSE BEGIN MEM[Q].HH.LH ← MEM[Q].HH.LH + 1; IF A ≥ 4 THEN GEQ_DEFINE (P, 111, Q) ELSE EQ_DEFINE (P, 111, Q) END; GOTO 30 END END; BACK_INPUT; CUR_CS ← Q; Q ← SCAN_TOKS (FALSE, FALSE); IF MEM[DEF_REF].HH.RH = 0 THEN BEGIN IF A ≥ 4 THEN GEQ_DEFINE (P, 101, 0) ELSE EQ_DEFINE (P, 101, 0); BEGIN MEM[DEF_REF].HH.RH ← AVAIL; AVAIL ← DEF_REF END END ELSE BEGIN IF P = 7313 THEN BEGIN MEM[Q].HH.RH ← GET_AVAIL; Q ← MEM[Q].HH.RH; MEM[Q].HH.LH ← 637; Q ← GET_AVAIL; MEM[Q].HH.LH ← 379; MEM[Q].HH.RH ← MEM[DEF_REF].HH.RH; MEM[DEF_REF].HH.RH ← Q END; IF A ≥ 4 THEN GEQ_DEFINE (P, 111, DEF_REF) ELSE EQ_DEFINE (P, 111, DEF_REF) END END; 73: BEGIN P ← CUR_CHR; SCAN_OPTIONAL_EQUALS; SCAN_INT; IF A ≥ 4 THEN GEQ_WORD_DEFINE (P, CUR_VAL) ELSE EQ_WORD_DEFINE (P, CUR_VAL) END; 74: BEGIN P ← CUR_CHR; SCAN_OPTIONAL_EQUALS; SCAN_DIMEN (FALSE, FALSE, FALSE); IF A ≥ 4 THEN GEQ_WORD_DEFINE (P, CUR_VAL) ELSE EQ_WORD_DEFINE (P, CUR_VAL) END; 75, 76: BEGIN P ← CUR_CHR; N ← CUR_CMD; SCAN_OPTIONAL_EQUALS; IF N = 76 THEN SCAN_GLUE (3) ELSE SCAN_GLUE (2); TRAP_ZERO_GLUE; IF A ≥ 4 THEN GEQ_DEFINE (P, 117, CUR_VAL) ELSE EQ_DEFINE (P, 117, CUR_VAL) END; 85: BEGIN IF CUR_CHR = 7883 THEN N ← 15 ELSE IF CUR_CHR = 8907 THEN N ← 32768 ELSE IF CUR_CHR = 8651 THEN N ← 32767 ELSE IF CUR_CHR = 9474 THEN N ← 16777215 ELSE N ← 255; P ← CUR_CHR; SCAN_CHAR_NUM; P ← P + CUR_VAL; SCAN_OPTIONAL_EQUALS; SCAN_INT; IF (CUR_VAL < 0) AND (P < 9474) OR (CUR_VAL > N) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1202) END; PRINT_INT (CUR_VAL); IF P < 9474 THEN PRINT (1203) ELSE PRINT (1204); PRINT_INT (N); BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 1205 END; ERROR; CUR_VAL ← 0 END; IF P < 8907 THEN IF A ≥ 4 THEN GEQ_DEFINE (P, 120, CUR_VAL) ELSE EQ_DEFINE (P, 120, CUR_VAL) ELSE IF P < 9474 THEN IF A ≥ 4 THEN GEQ_DEFINE (P, 120, CUR_VAL + 0) ELSE EQ_DEFINE (P, 120, CUR_VAL + 0) ELSE IF A ≥ 4 THEN GEQ_WORD_DEFINE (P, CUR_VAL) ELSE EQ_WORD_DEFINE (P, CUR_VAL) END; 86: BEGIN P ← CUR_CHR; SCAN_FOUR_BIT_INT; P ← P + CUR_VAL; SCAN_OPTIONAL_EQUALS; SCAN_FONT_IDENT; IF A ≥ 4 THEN GEQ_DEFINE (P, 120, CUR_VAL) ELSE EQ_DEFINE (P, 120, CUR_VAL) END; 89,90,91,92: DO_REGISTER_COMMAND (A); 98: BEGIN SCAN_EIGHT_BIT_INT; IF A ≥ 4 THEN N ← 256 + CUR_VAL ELSE N ← CUR_VAL; SCAN_OPTIONAL_EQUALS; IF SET_BOX_ALLOWED THEN SCAN_BOX (1073741824 + N) ELSE BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (680) END; PRINT_ESC (536); BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 1211; HELP_LINE[0] ← 1212 END; ERROR END END; 79: ALTER_AUX; 80: ALTER_PREV_GRAF; 81: ALTER_PAGE_SO_FAR; 82: ALTER_INTEGER; 83: ALTER_BOX_DIMEN; 84: BEGIN SCAN_OPTIONAL_EQUALS; SCAN_INT; N ← CUR_VAL; IF N ≤ 0 THEN P ← 0 ELSE BEGIN P ← GET_NODE (2 * N + 1); MEM[P].HH.LH ← N; FOR J ← 1 TO N DO BEGIN SCAN_DIMEN (FALSE, FALSE, FALSE); MEM[P + 2 * J - 1].INT ← CUR_VAL; SCAN_DIMEN (FALSE, FALSE, FALSE); MEM[P + 2 * J].INT ← CUR_VAL END END; IF A ≥ 4 THEN GEQ_DEFINE (7312, 118, P) ELSE EQ_DEFINE (7312, 118, P) END; 99: IF CUR_CHR = 1 THEN BEGIN NEW_PATTERNS; GOTO 30; BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1216) END; HELP_PTR ← 0; ERROR; REPEAT GET_TOKEN UNTIL CUR_CMD = 2; GOTO 10 END ELSE BEGIN NEW_HYPH_EXCEPTIONS; GOTO 30 END; 77: BEGIN FIND_FONT_DIMEN (TRUE); K ← CUR_VAL; SCAN_OPTIONAL_EQUALS; SCAN_DIMEN (FALSE, FALSE, FALSE); FONT_INFO[K].INT ← CUR_VAL END; 78: BEGIN N ← CUR_CHR; SCAN_FONT_IDENT; F ← CUR_VAL; SCAN_OPTIONAL_EQUALS; SCAN_INT; IF N = 0 THEN HYPHEN_CHAR[F] ← CUR_VAL ELSE SKEW_CHAR[F] ← CUR_VAL END; 88: NEW_FONT (A); 100: NEW_INTERACTION; ELSE CONFUSION (1178); END; 30: IF AFTER_TOKEN ≠ 0 THEN BEGIN CUR_TOK ← AFTER_TOKEN; BACK_INPUT; AFTER_TOKEN ← 0 END; 10: END; PROCEDURE DO_ASSIGNMENTS; LABEL 10; BEGIN WHILE TRUE DO BEGIN REPEAT GET_X_TOKEN UNTIL (CUR_CMD ≠ 10) AND (CUR_CMD ≠ 0); IF CUR_CMD ≤ 70 THEN GOTO 10; SET_BOX_ALLOWED ← FALSE; PREFIXED_COMMAND; SET_BOX_ALLOWED ← TRUE END; 10: END; PROCEDURE OPEN_OR_CLOSE_IN; VAR C : 0..1; N : 0..15; BEGIN C ← CUR_CHR; SCAN_FOUR_BIT_INT; N ← CUR_VAL; IF READ_OPEN[N] ≠ 2 THEN BEGIN A_CLOSE (READ_FILE[N]); READ_OPEN[N] ← 2 END; IF C ≠ 0 THEN BEGIN SCAN_OPTIONAL_EQUALS; SCAN_FILE_NAME; IF CUR_EXT = 338 THEN CUR_EXT ← 791; PACK_FILE_NAME (CUR_NAME, CUR_AREA, CUR_EXT); IF A_OPEN_IN (READ_FILE[N]) THEN READ_OPEN[N] ← 1 END END; PROCEDURE ISSUE_MESSAGE; VAR OLD_SETTING : 0..21; C : 0..1; S : STR_NUMBER; BEGIN C ← CUR_CHR; MEM[59988].HH.RH ← SCAN_TOKS (FALSE, TRUE); OLD_SETTING ← SELECTOR; SELECTOR ← 21; TOKEN_SHOW (DEF_REF); SELECTOR ← OLD_SETTING; FLUSH_LIST (DEF_REF); BEGIN IF POOL_PTR + 1 > POOL_SIZE THEN OVERFLOW (257, POOL_SIZE - INIT_POOL_PTR) END; S ← MAKE_STRING; IF C = 0 THEN BEGIN IF TERM_OFFSET + (STR_START[S + 1] - STR_START[S]) > MAX_PRINT_LINE - 2 THEN PRINT_LN ELSE IF (TERM_OFFSET > 0) OR (FILE_OFFSET > 0) THEN PRINT_CHAR (32); SLOW_PRINT (S); BREAK (TERM_OUT) END ELSE BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (338) END; SLOW_PRINT (S); IF EQTB[7321].HH.RH ≠ 0 THEN USE_ERR_HELP ← TRUE ELSE IF LONG_HELP_SEEN THEN BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 1232 END ELSE BEGIN IF INTERACTION < 3 THEN LONG_HELP_SEEN ← TRUE; BEGIN HELP_PTR ← 4; HELP_LINE[3] ← 1233; HELP_LINE[2] ← 1234; HELP_LINE[1] ← 1235; HELP_LINE[0] ← 1236 END END; ERROR; USE_ERR_HELP ← FALSE END; BEGIN STR_PTR ← STR_PTR - 1; POOL_PTR ← STR_START[STR_PTR] END END; PROCEDURE SHIFT_CASE; VAR B : HALFWORD; P : HALFWORD; T : HALFWORD; C : EIGHT_BITS; BEGIN B ← CUR_CHR; P ← SCAN_TOKS (FALSE, FALSE); P ← MEM[DEF_REF].HH.RH; WHILE P ≠ 0 DO BEGIN T ← MEM[P].HH.LH; IF T < 4352 THEN BEGIN C ← T MOD 256; IF EQTB[B + C].HH.RH ≠ 0 THEN MEM[P].HH.LH ← T - C + EQTB[B + C].HH.RH END; P ← MEM[P].HH.RH END; BEGIN_TOKEN_LIST (MEM[DEF_REF].HH.RH, 3); BEGIN MEM[DEF_REF].HH.RH ← AVAIL; AVAIL ← DEF_REF END END; PROCEDURE SHOW_WHATEVER; LABEL 50; VAR P : HALFWORD; BEGIN CASE CUR_CHR OF 3: BEGIN BEGIN_DIAGNOSTIC; SHOW_ACTIVITIES END; 1: BEGIN SCAN_EIGHT_BIT_INT; BEGIN_DIAGNOSTIC; PRINT_NL (1254); PRINT_INT (CUR_VAL); PRINT_CHAR (61); IF EQTB[7578 + CUR_VAL].HH.RH = 0 THEN PRINT (410) ELSE SHOW_BOX (EQTB[7578 + CUR_VAL].HH.RH) END; 0: BEGIN GET_TOKEN; IF INTERACTION = 3 THEN ; PRINT_NL (1248); IF CUR_CS ≠ 0 THEN BEGIN SPRINT_CS (CUR_CS); PRINT_CHAR (61) END; PRINT_MEANING; GOTO 50 END; ELSE BEGIN P ← THE_TOKS; IF INTERACTION = 3 THEN ; PRINT_NL (1248); TOKEN_SHOW (59997); FLUSH_LIST (MEM[59997].HH.RH); GOTO 50 END; END; END_DIAGNOSTIC (TRUE); BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1255) END; IF SELECTOR = 19 THEN IF EQTB[9192].INT ≤ 0 THEN BEGIN SELECTOR ← 17; PRINT (1256); SELECTOR ← 19 END; 50: IF INTERACTION < 3 THEN BEGIN HELP_PTR ← 0; ERROR_COUNT ← ERROR_COUNT - 1 END ELSE IF EQTB[9192].INT > 0 THEN BEGIN BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 1243; HELP_LINE[1] ← 1244; HELP_LINE[0] ← 1245 END END ELSE BEGIN BEGIN HELP_PTR ← 5; HELP_LINE[4] ← 1243; HELP_LINE[3] ← 1244; HELP_LINE[2] ← 1245; HELP_LINE[1] ← 1246; HELP_LINE[0] ← 1247 END END; ERROR END; PROCEDURE STORE_FMT_FILE; LABEL 41, 42, 31, 32; VAR J : INTEGER; K : INTEGER; L : INTEGER; P : HALFWORD; Q : HALFWORD; X : INTEGER; W : FOUR_QUARTERS; BEGIN IF SAVE_PTR ≠ 0 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1258) END; BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 1259 END; BEGIN IF INTERACTION = 3 THEN INTERACTION ← 2; IF LOG_OPENED THEN ERROR; HISTORY ← 3; JUMP_OUT END END; SELECTOR ← 21; PRINT (1272); PRINT (JOB_NAME); PRINT_CHAR (32); PRINT_INT (EQTB[9186].INT); PRINT_CHAR (46); PRINT_INT (EQTB[9185].INT); PRINT_CHAR (46); PRINT_INT (EQTB[9184].INT); PRINT_CHAR (41); IF INTERACTION = 0 THEN SELECTOR ← 18 ELSE SELECTOR ← 19; BEGIN IF POOL_PTR + 1 > POOL_SIZE THEN OVERFLOW (257, POOL_SIZE - INIT_POOL_PTR) END; FORMAT_IDENT ← MAKE_STRING; PACK_JOB_NAME (786); WHILE NOT W_OPEN_OUT (FMT_FILE) DO PROMPT_FILE_NAME (1273, 786); PRINT_NL (1274); SLOW_PRINT (W_MAKE_NAME_STRING (FMT_FILE)); BEGIN STR_PTR ← STR_PTR - 1; POOL_PTR ← STR_START[STR_PTR] END; PRINT_NL (338); SLOW_PRINT (FORMAT_IDENT); BEGIN FMT_FILE↑.INT ← 504454778; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← 0; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← 60000; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← 10006; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← 1777; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← 307; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← POOL_PTR; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← STR_PTR; PUT (FMT_FILE) END; FOR K ← 0 TO STR_PTR DO BEGIN FMT_FILE↑.INT ← STR_START[K]; PUT (FMT_FILE) END; K ← 0; WHILE K + 4 < POOL_PTR DO BEGIN W.B0 ← STR_POOL[K] + 0; W.B1 ← STR_POOL[K + 1] + 0; W.B2 ← STR_POOL[K + 2] + 0; W.B3 ← STR_POOL[K + 3] + 0; BEGIN FMT_FILE↑.QQQQ ← W; PUT (FMT_FILE) END; K ← K + 4 END; K ← POOL_PTR - 4; W.B0 ← STR_POOL[K] + 0; W.B1 ← STR_POOL[K + 1] + 0; W.B2 ← STR_POOL[K + 2] + 0; W.B3 ← STR_POOL[K + 3] + 0; BEGIN FMT_FILE↑.QQQQ ← W; PUT (FMT_FILE) END; PRINT_LN; PRINT_INT (STR_PTR); PRINT (1260); PRINT_INT (POOL_PTR); SORT_AVAIL; VAR_USED ← 0; BEGIN FMT_FILE↑.INT ← LO_MEM_MAX; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← ROVER; PUT (FMT_FILE) END; P ← 0; Q ← ROVER; X ← 0; REPEAT FOR K ← P TO Q + 1 DO BEGIN FMT_FILE↑ ← MEM[K]; PUT (FMT_FILE) END; X ← X + Q + 2 - P; VAR_USED ← VAR_USED + Q - P; P ← Q + MEM[Q].HH.LH; Q ← MEM[Q + 1].HH.RH UNTIL Q = ROVER; VAR_USED ← VAR_USED + LO_MEM_MAX - P; DYN_USED ← MEM_END + 1 - HI_MEM_MIN; FOR K ← P TO LO_MEM_MAX DO BEGIN FMT_FILE↑ ← MEM[K]; PUT (FMT_FILE) END; X ← X + LO_MEM_MAX + 1 - P; BEGIN FMT_FILE↑.INT ← HI_MEM_MIN; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← AVAIL; PUT (FMT_FILE) END; FOR K ← HI_MEM_MIN TO MEM_END DO BEGIN FMT_FILE↑ ← MEM[K]; PUT (FMT_FILE) END; X ← X + MEM_END + 1 - HI_MEM_MIN; P ← AVAIL; WHILE P ≠ 0 DO BEGIN DYN_USED ← DYN_USED - 1; P ← MEM[P].HH.RH END; BEGIN FMT_FILE↑.INT ← VAR_USED; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← DYN_USED; PUT (FMT_FILE) END; PRINT_LN; PRINT_INT (X); PRINT (1261); PRINT_INT (VAR_USED); PRINT_CHAR (38); PRINT_INT (DYN_USED); K ← 1; REPEAT J ← K; WHILE J < 9162 DO BEGIN IF (EQTB[J].HH.RH = EQTB[J + 1].HH.RH) AND (EQTB[J].HH.B0 = EQTB[J + 1].HH.B0) AND (EQTB[J].HH.B1 = EQTB[J + 1].HH.B1) THEN GOTO 41; J ← J + 1 END; L ← 9163; GOTO 31; 41: J ← J + 1; L ← J; WHILE J < 9162 DO BEGIN IF (EQTB[J].HH.RH ≠ EQTB[J + 1].HH.RH) OR (EQTB[J].HH.B0 ≠ EQTB[J + 1].HH.B0) OR (EQTB[J].HH.B1 ≠ EQTB[J + 1].HH.B1) THEN GOTO 31; J ← J + 1 END; 31: BEGIN FMT_FILE↑.INT ← L - K; PUT (FMT_FILE) END; WHILE K < L DO BEGIN BEGIN FMT_FILE↑ ← EQTB[K]; PUT (FMT_FILE) END; K ← K + 1 END; K ← J + 1; BEGIN FMT_FILE↑.INT ← K - L; PUT (FMT_FILE) END UNTIL K = 9163; REPEAT J ← K; WHILE J < 10006 DO BEGIN IF EQTB[J].INT = EQTB[J + 1].INT THEN GOTO 42; J ← J + 1 END; L ← 10007; GOTO 32; 42: J ← J + 1; L ← J; WHILE J < 10006 DO BEGIN IF EQTB[J].INT ≠ EQTB[J + 1].INT THEN GOTO 32; J ← J + 1 END; 32: BEGIN FMT_FILE↑.INT ← L - K; PUT (FMT_FILE) END; WHILE K < L DO BEGIN BEGIN FMT_FILE↑ ← EQTB[K]; PUT (FMT_FILE) END; K ← K + 1 END; K ← J + 1; BEGIN FMT_FILE↑.INT ← K - L; PUT (FMT_FILE) END UNTIL K > 10006; BEGIN FMT_FILE↑.INT ← PAR_LOC; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← WRITE_LOC; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← HASH_USED; PUT (FMT_FILE) END; CS_COUNT ← 6513 - HASH_USED; FOR P ← 514 TO HASH_USED DO IF HASH[P].RH ≠ 0 THEN BEGIN BEGIN FMT_FILE↑.INT ← P; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.HH ← HASH[P]; PUT (FMT_FILE) END; CS_COUNT ← CS_COUNT + 1 END; FOR P ← HASH_USED + 1 TO 6780 DO BEGIN FMT_FILE↑.HH ← HASH[P]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← CS_COUNT; PUT (FMT_FILE) END; PRINT_LN; PRINT_INT (CS_COUNT); PRINT (1262); BEGIN FMT_FILE↑.INT ← FMEM_PTR; PUT (FMT_FILE) END; FOR K ← 0 TO FMEM_PTR - 1 DO BEGIN FMT_FILE↑ ← FONT_INFO[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← FONT_PTR; PUT (FMT_FILE) END; FOR K ← 0 TO FONT_PTR DO BEGIN BEGIN FMT_FILE↑.QQQQ ← FONT_CHECK[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← FONT_SIZE[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← FONT_DSIZE[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← FONT_PARAMS[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← HYPHEN_CHAR[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← SKEW_CHAR[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← FONT_NAME[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← FONT_AREA[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← FONT_BC[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← FONT_EC[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← CHAR_BASE[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← WIDTH_BASE[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← HEIGHT_BASE[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← DEPTH_BASE[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← ITALIC_BASE[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← LIG_KERN_BASE[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← KERN_BASE[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← EXTEN_BASE[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← PARAM_BASE[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← FONT_GLUE[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← BCHAR_LABEL[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← FONT_BCHAR[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← FONT_FALSE_BCHAR[K]; PUT (FMT_FILE) END; PRINT_NL (1265); PRINT_ESC (HASH[6524 + K].RH); PRINT_CHAR (61); PRINT_FILE_NAME (FONT_NAME[K], FONT_AREA[K], 338); IF FONT_SIZE[K] ≠ FONT_DSIZE[K] THEN BEGIN PRINT (741); PRINT_SCALED (FONT_SIZE[K]); PRINT (397) END END; PRINT_LN; PRINT_INT (FMEM_PTR - 7); PRINT (1263); PRINT_INT (FONT_PTR - 0); PRINT (1264); IF FONT_PTR ≠ 1 THEN PRINT_CHAR (115); BEGIN FMT_FILE↑.INT ← HYPH_COUNT; PUT (FMT_FILE) END; FOR K ← 0 TO 307 DO IF HYPH_WORD[K] ≠ 0 THEN BEGIN BEGIN FMT_FILE↑.INT ← K; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← HYPH_WORD[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← HYPH_LIST[K]; PUT (FMT_FILE) END END; PRINT_LN; PRINT_INT (HYPH_COUNT); PRINT (1266); IF HYPH_COUNT ≠ 1 THEN PRINT_CHAR (115); IF TRIE_NOT_READY THEN INIT_TRIE; BEGIN FMT_FILE↑.INT ← TRIE_MAX; PUT (FMT_FILE) END; FOR K ← 0 TO TRIE_MAX DO BEGIN FMT_FILE↑.HH ← TRIE[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← TRIE_OP_PTR; PUT (FMT_FILE) END; FOR K ← 1 TO TRIE_OP_PTR DO BEGIN BEGIN FMT_FILE↑.INT ← HYF_DISTANCE[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← HYF_NUM[K]; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← HYF_NEXT[K]; PUT (FMT_FILE) END END; PRINT_NL (1267); PRINT_INT (TRIE_MAX); PRINT (1268); PRINT_INT (TRIE_OP_PTR); PRINT (1269); IF TRIE_OP_PTR ≠ 1 THEN PRINT_CHAR (115); PRINT (1270); PRINT_INT (TRIE_OP_SIZE); FOR K ← 255 DOWNTO 0 DO IF TRIE_USED[K] > 0 THEN BEGIN PRINT_NL (800); PRINT_INT (TRIE_USED[K] - 0); PRINT (1271); PRINT_INT (K); BEGIN FMT_FILE↑.INT ← K; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← TRIE_USED[K] - 0; PUT (FMT_FILE) END END; BEGIN FMT_FILE↑.INT ← INTERACTION; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← FORMAT_IDENT; PUT (FMT_FILE) END; BEGIN FMT_FILE↑.INT ← 69069; PUT (FMT_FILE) END; EQTB[9194].INT ← 0; W_CLOSE (FMT_FILE) END; PROCEDURE NEW_WHATSIT (S:SMALL_NUMBER; W:SMALL_NUMBER); VAR P : HALFWORD; BEGIN P ← GET_NODE (W); MEM[P].HH.B0 ← 8; MEM[P].HH.B1 ← S; MEM[CUR_LIST.TAIL_FIELD].HH.RH ← P; CUR_LIST.TAIL_FIELD ← P END; PROCEDURE NEW_WRITE_WHATSIT (W:SMALL_NUMBER); BEGIN NEW_WHATSIT (CUR_CHR, W); IF W ≠ 2 THEN SCAN_FOUR_BIT_INT ELSE BEGIN SCAN_INT; IF CUR_VAL < 0 THEN CUR_VAL ← 17 ELSE IF CUR_VAL > 15 THEN CUR_VAL ← 16 END; MEM[CUR_LIST.TAIL_FIELD + 1].HH.LH ← CUR_VAL END; PROCEDURE DO_EXTENSION; VAR I : INTEGER; J : INTEGER; K : INTEGER; P : HALFWORD; Q : HALFWORD; R : HALFWORD; BEGIN CASE CUR_CHR OF 0: BEGIN NEW_WRITE_WHATSIT (3); SCAN_OPTIONAL_EQUALS; SCAN_FILE_NAME; MEM[CUR_LIST.TAIL_FIELD + 1].HH.RH ← CUR_NAME; MEM[CUR_LIST.TAIL_FIELD + 2].HH.LH ← CUR_AREA; MEM[CUR_LIST.TAIL_FIELD + 2].HH.RH ← CUR_EXT END; 1: BEGIN K ← CUR_CS; NEW_WRITE_WHATSIT (2); CUR_CS ← K; P ← SCAN_TOKS (FALSE, FALSE); MEM[CUR_LIST.TAIL_FIELD + 1].HH.RH ← DEF_REF END; 2: BEGIN NEW_WRITE_WHATSIT (2); MEM[CUR_LIST.TAIL_FIELD + 1].HH.RH ← 0 END; 3: BEGIN NEW_WHATSIT (3, 2); MEM[CUR_LIST.TAIL_FIELD + 1].HH.LH ← 0; P ← SCAN_TOKS (FALSE, TRUE); MEM[CUR_LIST.TAIL_FIELD + 1].HH.RH ← DEF_REF END; 4: BEGIN GET_X_TOKEN; IF (CUR_CMD = 59) AND (CUR_CHR ≤ 2) THEN BEGIN P ← CUR_LIST.TAIL_FIELD; DO_EXTENSION; OUT_WHAT (CUR_LIST.TAIL_FIELD); FLUSH_NODE_LIST (CUR_LIST.TAIL_FIELD); CUR_LIST.TAIL_FIELD ← P; MEM[P].HH.RH ← 0 END ELSE BACK_INPUT END; 5: IF ABS (CUR_LIST.MODE_FIELD) ≠ 102 THEN REPORT_ILLEGAL_CASE ELSE BEGIN NEW_WHATSIT (4, 2); SCAN_INT; IF CUR_VAL ≤ 0 THEN CUR_LIST.AUX_FIELD.HH.RH ← 0 ELSE IF CUR_VAL > 255 THEN CUR_LIST.AUX_FIELD.HH.RH ← 0 ELSE CUR_LIST.AUX_FIELD.HH.RH ← CUR_VAL; MEM[CUR_LIST.TAIL_FIELD + 1].HH.RH ← CUR_LIST.AUX_FIELD.HH.RH; MEM[CUR_LIST.TAIL_FIELD + 1].HH.B0 ← NORM_MIN (EQTB[9214].INT); MEM[CUR_LIST.TAIL_FIELD + 1].HH.B1 ← NORM_MIN (EQTB[9215].INT) END; ELSE CONFUSION (1291); END END; PROCEDURE FIX_LANGUAGE; VAR L : ASCII_CODE; BEGIN IF EQTB[9213].INT ≤ 0 THEN L ← 0 ELSE IF EQTB[9213].INT > 255 THEN L ← 0 ELSE L ← EQTB[9213].INT; IF L ≠ CUR_LIST.AUX_FIELD.HH.RH THEN BEGIN NEW_WHATSIT (4, 2); MEM[CUR_LIST.TAIL_FIELD + 1].HH.RH ← L; CUR_LIST.AUX_FIELD.HH.RH ← L; MEM[CUR_LIST.TAIL_FIELD + 1].HH.B0 ← NORM_MIN (EQTB[9214].INT); MEM[CUR_LIST.TAIL_FIELD + 1].HH.B1 ← NORM_MIN (EQTB[9215].INT) END END; PROCEDURE HANDLE_RIGHT_BRACE; VAR P : HALFWORD; Q : HALFWORD; D : SCALED; F : INTEGER; BEGIN CASE CUR_GROUP OF 1: UNSAVE; 0: BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1044) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 1045; HELP_LINE[0] ← 1046 END; ERROR END; 14,15,16: EXTRA_RIGHT_BRACE; 2: PACKAGE (0); 3: BEGIN ADJUST_TAIL ← 59995; PACKAGE (0) END; 4: BEGIN END_GRAF; PACKAGE (0) END; 5: BEGIN END_GRAF; PACKAGE (4) END; 11: BEGIN END_GRAF; Q ← EQTB[6792].HH.RH; MEM[Q].HH.RH ← MEM[Q].HH.RH + 1; D ← EQTB[9736].INT; F ← EQTB[9205].INT; UNSAVE; SAVE_PTR ← SAVE_PTR - 1; P ← VPACKAGE (MEM[CUR_LIST.HEAD_FIELD].HH.RH, 0, 1, 1073741823); POP_NEST; IF SAVE_STACK[SAVE_PTR + 0].INT < 255 THEN BEGIN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← GET_NODE (5); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; MEM[CUR_LIST.TAIL_FIELD].HH.B0 ← 3; MEM[CUR_LIST.TAIL_FIELD].HH.B1 ← SAVE_STACK[SAVE_PTR + 0].INT + 0; MEM[CUR_LIST.TAIL_FIELD + 3].INT ← MEM[P + 3].INT + MEM[P + 2].INT; MEM[CUR_LIST.TAIL_FIELD + 4].HH.LH ← MEM[P + 5].HH.RH; MEM[CUR_LIST.TAIL_FIELD + 4].HH.RH ← Q; MEM[CUR_LIST.TAIL_FIELD + 2].INT ← D; MEM[CUR_LIST.TAIL_FIELD + 1].INT ← F END ELSE BEGIN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← GET_NODE (2); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; MEM[CUR_LIST.TAIL_FIELD].HH.B0 ← 5; MEM[CUR_LIST.TAIL_FIELD].HH.B1 ← 0; MEM[CUR_LIST.TAIL_FIELD + 1].INT ← MEM[P + 5].HH.RH; DELETE_GLUE_REF (Q) END; FREE_NODE (P, 7); IF NEST_PTR = 0 THEN BUILD_PAGE END; 8: BEGIN IF (CUR_INPUT.LOC_FIELD ≠ 0) OR (CUR_INPUT.INDEX_FIELD ≠ 6) AND (CUR_INPUT.INDEX_FIELD ≠ 3) THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1010) END; BEGIN HELP_PTR ← 2; HELP_LINE[1] ← 1011; HELP_LINE[0] ← 1012 END; ERROR; REPEAT GET_TOKEN UNTIL CUR_INPUT.LOC_FIELD = 0 END; END_TOKEN_LIST; END_GRAF; UNSAVE; OUTPUT_ACTIVE ← FALSE; INSERT_PENALTIES ← 0; IF EQTB[7833].HH.RH ≠ 0 THEN BEGIN BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (1013) END; PRINT_ESC (409); PRINT_INT (255); BEGIN HELP_PTR ← 3; HELP_LINE[2] ← 1014; HELP_LINE[1] ← 1015; HELP_LINE[0] ← 1016 END; BOX_ERROR (255) END; IF CUR_LIST.TAIL_FIELD ≠ CUR_LIST.HEAD_FIELD THEN BEGIN MEM[PAGE_TAIL].HH.RH ← MEM[CUR_LIST.HEAD_FIELD].HH.RH; PAGE_TAIL ← CUR_LIST.TAIL_FIELD END; IF MEM[59998].HH.RH ≠ 0 THEN BEGIN IF MEM[59999].HH.RH = 0 THEN NEST[0].TAIL_FIELD ← PAGE_TAIL; MEM[PAGE_TAIL].HH.RH ← MEM[59999].HH.RH; MEM[59999].HH.RH ← MEM[59998].HH.RH; MEM[59998].HH.RH ← 0; PAGE_TAIL ← 59998 END; POP_NEST; BUILD_PAGE END; 10: BUILD_DISCRETIONARY; 6: BEGIN BACK_INPUT; CUR_TOK ← 10610; BEGIN IF INTERACTION = 3 THEN ; PRINT_NL (262); PRINT (625) END; PRINT_ESC (899); PRINT (626); BEGIN HELP_PTR ← 1; HELP_LINE[0] ← 1125 END; INS_ERROR END; 7: BEGIN END_GRAF; UNSAVE; ALIGN_PEEK END; 12: BEGIN END_GRAF; UNSAVE; SAVE_PTR ← SAVE_PTR - 2; P ← VPACKAGE (MEM[CUR_LIST.HEAD_FIELD].HH.RH, SAVE_STACK[SAVE_PTR + 1].INT, SAVE_STACK[SAVE_PTR + 0].INT, 1073741823); POP_NEST; BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_NOAD; CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; MEM[CUR_LIST.TAIL_FIELD].HH.B0 ← 29; MEM[CUR_LIST.TAIL_FIELD + 1].HH.RH ← 2; MEM[CUR_LIST.TAIL_FIELD + 1].HH.LH ← P END; 13: BUILD_CHOICES; 9: BEGIN UNSAVE; SAVE_PTR ← SAVE_PTR - 1; MEM[SAVE_STACK[SAVE_PTR + 0].INT].HH.RH ← 3; P ← FIN_MLIST (0); MEM[SAVE_STACK[SAVE_PTR + 0].INT].HH.LH ← P; IF P ≠ 0 THEN IF MEM[P].HH.RH = 0 THEN IF MEM[P].HH.B0 = 16 THEN BEGIN IF MEM[P + 3].HH.RH = 0 THEN IF MEM[P + 2].HH.RH = 0 THEN BEGIN MEM[SAVE_STACK[SAVE_PTR + 0].INT].HH ← MEM[P + 1].HH; FREE_NODE (P, 4) END END ELSE IF MEM[P].HH.B0 = 28 THEN IF SAVE_STACK[SAVE_PTR + 0].INT = CUR_LIST.TAIL_FIELD + 1 THEN IF MEM[CUR_LIST.TAIL_FIELD].HH.B0 = 16 THEN BEGIN Q ← CUR_LIST.HEAD_FIELD; WHILE MEM[Q].HH.RH ≠ CUR_LIST.TAIL_FIELD DO Q ← MEM[Q].HH.RH; MEM[Q].HH.RH ← P; FREE_NODE (CUR_LIST.TAIL_FIELD, 4); CUR_LIST.TAIL_FIELD ← P END END; ELSE CONFUSION (1047); END END; PROCEDURE MAIN_CONTROL; LABEL 60, 21, 70, 80, 90, 91, 92, 95, 100, 101, 110, 111, 112, 120, 10; VAR T : INTEGER; BEGIN IF EQTB[7319].HH.RH ≠ 0 THEN BEGIN_TOKEN_LIST (EQTB[7319].HH.RH, 12); 60: GET_X_TOKEN; 21: IF INTERRUPT ≠ 0 THEN IF OK_TO_INTERRUPT THEN BEGIN BACK_INPUT; BEGIN IF INTERRUPT ≠ 0 THEN PAUSE_FOR_INSTRUCTIONS END; GOTO 60 END; IF EQTB[9199].INT > 0 THEN SHOW_CUR_CMD_CHR; CASE ABS (CUR_LIST.MODE_FIELD) + CUR_CMD OF 113,114,170: GOTO 70; 118: BEGIN SCAN_CHAR_NUM; CUR_CHR ← CUR_VAL; GOTO 70 END; 167: BEGIN GET_X_TOKEN; IF (CUR_CMD = 11) OR (CUR_CMD = 12) OR (CUR_CMD = 68) OR (CUR_CMD = 16) THEN CANCEL_BOUNDARY ← TRUE; GOTO 21 END; 112: IF CUR_LIST.AUX_FIELD.HH.LH = 1000 THEN GOTO 120 ELSE APP_SPACE; 166,267: GOTO 120; 1,102,203,11,213,268: ; 40,141, 242: BEGIN REPEAT GET_X_TOKEN UNTIL CUR_CMD ≠ 10; GOTO 21 END; 15: IF ITS_ALL_OVER THEN GOTO 10; 23,123,224,71,172,273,39,45,49,150,7,108,209: REPORT_ILLEGAL_CASE; 8,109,9,110,18,119,70,171,51,152,16,117,50,151,53,154,67,168,54,155,55,156,57,158,56,157, 31,132,52,153,29,130,47,148,212,216,217,230,227,236,239: INSERT_DOLLAR_SIGN; 37,137, 238: BEGIN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← SCAN_RULE_SPEC; CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; IF ABS (CUR_LIST.MODE_FIELD) = 1 THEN CUR_LIST.AUX_FIELD.INT ← -65536000 ELSE IF ABS (CUR_LIST.MODE_FIELD) = 102 THEN CUR_LIST.AUX_FIELD.HH.LH ← 1000 END; 28,128,229,231: APPEND_GLUE; 30,131,232,233: APPEND_KERN; 2,103: NEW_SAVE_LEVEL (1); 62,163,264: NEW_SAVE_LEVEL (14); 63,164, 265: IF CUR_GROUP = 14 THEN UNSAVE ELSE OFF_SAVE; 3,104,205: HANDLE_RIGHT_BRACE; 22,124, 225: BEGIN T ← CUR_CHR; SCAN_DIMEN (FALSE, FALSE, FALSE); IF T = 0 THEN SCAN_BOX (CUR_VAL) ELSE SCAN_BOX (-CUR_VAL) END; 32,133,234: SCAN_BOX (1073742237 + CUR_CHR); 21,122,223: BEGIN_BOX (0); 44: NEW_GRAF (CUR_CHR > 0); 12,13,17,69,4,24,36,46,48,27,34,65, 66: BEGIN BACK_INPUT; NEW_GRAF (TRUE) END; 145,246: INDENT_IN_HMODE; 14: BEGIN NORMAL_PARAGRAPH; IF CUR_LIST.MODE_FIELD > 0 THEN BUILD_PAGE END; 115: BEGIN IF ALIGN_STATE < 0 THEN OFF_SAVE; END_GRAF; IF CUR_LIST.MODE_FIELD = 1 THEN BUILD_PAGE END; 116,129,138,126,134: HEAD_FOR_VMODE; 38,139,240,140,241: BEGIN_INSERT_OR_ADJUST; 19,120,221: MAKE_MARK; 43,144,245: APPEND_PENALTY; 26,127,228: DELETE_LAST; 25,125,226: UNPACKAGE; 146: APPEND_ITALIC_CORRECTION; 247: BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_KERN (0); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; 149,250: APPEND_DISCRETIONARY; 147: MAKE_ACCENT; 6,107,208,5,106,207: ALIGN_ERROR; 35,136,237: NO_ALIGN_ERROR; 64,165,266: OMIT_ERROR; 33,135: INIT_ALIGN; 235: IF PRIVILEGED THEN IF CUR_GROUP = 15 THEN INIT_ALIGN ELSE OFF_SAVE; 10,111: DO_ENDV; 68,169,270: CS_ERROR; 105: INIT_MATH; 251: IF PRIVILEGED THEN IF CUR_GROUP = 15 THEN START_EQ_NO ELSE OFF_SAVE; 204: BEGIN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_NOAD; CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; BACK_INPUT; SCAN_MATH (CUR_LIST.TAIL_FIELD + 1) END; 214,215,271: SET_MATH_CHAR (EQTB[8907 + CUR_CHR].HH.RH - 0); 219: BEGIN SCAN_CHAR_NUM; CUR_CHR ← CUR_VAL; SET_MATH_CHAR (EQTB[8907 + CUR_CHR].HH.RH - 0) END; 220: BEGIN SCAN_FIFTEEN_BIT_INT; SET_MATH_CHAR (CUR_VAL) END; 272: SET_MATH_CHAR (CUR_CHR); 218: BEGIN SCAN_TWENTY_SEVEN_BIT_INT; SET_MATH_CHAR (CUR_VAL DIV 4096) END; 253: BEGIN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_NOAD; CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; MEM[CUR_LIST.TAIL_FIELD].HH.B0 ← CUR_CHR; SCAN_MATH (CUR_LIST.TAIL_FIELD + 1) END; 254: MATH_LIMIT_SWITCH; 269: MATH_RADICAL; 248,249: MATH_AC; 259: BEGIN SCAN_SPEC (12, FALSE); NORMAL_PARAGRAPH; PUSH_NEST; CUR_LIST.MODE_FIELD ← -1; CUR_LIST.AUX_FIELD.INT ← -65536000; IF EQTB[7318].HH.RH ≠ 0 THEN BEGIN_TOKEN_LIST (EQTB[7318].HH.RH, 11) END; 256: BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_STYLE (CUR_CHR); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; 258: BEGIN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_GLUE (0); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; MEM[CUR_LIST.TAIL_FIELD].HH.B1 ← 98 END; 257: APPEND_CHOICES; 211,210: SUB_SUP; 255: MATH_FRACTION; 252: MATH_LEFT_RIGHT; 206: IF CUR_GROUP = 15 THEN AFTER_MATH ELSE OFF_SAVE; 72,173,274,73,174,275,74,175,276,75,176,277,76,177,278,77,178,279,78,179,280,79,180,281, 80,181,282,81,182,283,82,183,284,83,184,285,84,185,286,85,186,287,86,187,288,87,188,289, 88,189,290,89,190,291,90,191,292,91,192,293,92,193,294,93,194,295,94,195,296,95,196,297, 96,197,298,97,198,299,98,199,300,99,200,301,100,201,302,101,202,303: PREFIXED_COMMAND; 41,142, 243: BEGIN GET_TOKEN; AFTER_TOKEN ← CUR_TOK END; 42,143, 244: BEGIN GET_TOKEN; SAVE_FOR_AFTER (CUR_TOK) END; 61,162,263: OPEN_OR_CLOSE_IN; 59,160,261: ISSUE_MESSAGE; 58,159,260: SHIFT_CASE; 20,121,222: SHOW_WHATEVER; 60,161,262: DO_EXTENSION; END; GOTO 60; 70: MAIN_S ← EQTB[8651 + CUR_CHR].HH.RH; IF MAIN_S = 1000 THEN CUR_LIST.AUX_FIELD.HH.LH ← 1000 ELSE IF MAIN_S < 1000 THEN BEGIN IF MAIN_S > 0 THEN CUR_LIST.AUX_FIELD.HH.LH ← MAIN_S END ELSE IF CUR_LIST.AUX_FIELD.HH.LH < 1000 THEN CUR_LIST.AUX_FIELD.HH.LH ← 1000 ELSE CUR_LIST.AUX_FIELD.HH.LH ← MAIN_S; MAIN_F ← EQTB[7834].HH.RH; BCHAR ← FONT_BCHAR[MAIN_F]; FALSE_BCHAR ← FONT_FALSE_BCHAR[MAIN_F]; IF CUR_LIST.MODE_FIELD > 0 THEN IF EQTB[9213].INT ≠ CUR_LIST.AUX_FIELD.HH.RH THEN FIX_LANGUAGE; BEGIN LIG_STACK ← AVAIL; IF LIG_STACK = 0 THEN LIG_STACK ← GET_AVAIL ELSE BEGIN AVAIL ← MEM[LIG_STACK].HH.RH; MEM[LIG_STACK].HH.RH ← 0 END END; MEM[LIG_STACK].HH.B0 ← MAIN_F; CUR_L ← CUR_CHR + 0; MEM[LIG_STACK].HH.B1 ← CUR_L; CUR_Q ← CUR_LIST.TAIL_FIELD; IF CANCEL_BOUNDARY THEN BEGIN CANCEL_BOUNDARY ← FALSE; MAIN_K ← 0 END ELSE MAIN_K ← BCHAR_LABEL[MAIN_F]; IF MAIN_K = 0 THEN GOTO 92; CUR_R ← CUR_L; CUR_L ← 256; GOTO 111; 80: IF CUR_L < 256 THEN BEGIN IF MEM[CUR_Q].HH.RH > 0 THEN IF MEM[CUR_LIST.TAIL_FIELD].HH.B1 = HYPHEN_CHAR[MAIN_F] + 0 THEN INS_DISC ← TRUE; IF LIGATURE_PRESENT THEN BEGIN MAIN_P ← NEW_LIGATURE (MAIN_F, CUR_L, MEM[CUR_Q].HH.RH); IF LFT_HIT THEN BEGIN MEM[MAIN_P].HH.B1 ← 2; LFT_HIT ← FALSE END; IF RT_HIT THEN IF LIG_STACK = 0 THEN BEGIN MEM[MAIN_P].HH.B1 ← MEM[MAIN_P].HH.B1 + 1; RT_HIT ← FALSE END; MEM[CUR_Q].HH.RH ← MAIN_P; CUR_LIST.TAIL_FIELD ← MAIN_P; LIGATURE_PRESENT ← FALSE END; IF INS_DISC THEN BEGIN INS_DISC ← FALSE; IF CUR_LIST.MODE_FIELD > 0 THEN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_DISC; CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END END END; 90: IF LIG_STACK = 0 THEN GOTO 21; CUR_Q ← CUR_LIST.TAIL_FIELD; CUR_L ← MEM[LIG_STACK].HH.B1; 91: IF NOT (LIG_STACK ≥ HI_MEM_MIN) THEN GOTO 95; 92: IF (CUR_CHR < FONT_BC[MAIN_F]) OR (CUR_CHR > FONT_EC[MAIN_F]) THEN BEGIN CHAR_WARNING (MAIN_F, CUR_CHR); BEGIN MEM[LIG_STACK].HH.RH ← AVAIL; AVAIL ← LIG_STACK END; GOTO 60 END; MAIN_I ← FONT_INFO[CHAR_BASE[MAIN_F] + CUR_L].QQQQ; IF NOT (MAIN_I.B0 > 0) THEN BEGIN CHAR_WARNING (MAIN_F, CUR_CHR); BEGIN MEM[LIG_STACK].HH.RH ← AVAIL; AVAIL ← LIG_STACK END; GOTO 60 END; MEM[CUR_LIST.TAIL_FIELD].HH.RH ← LIG_STACK; CUR_LIST.TAIL_FIELD ← LIG_STACK; 100: GET_NEXT; IF CUR_CMD = 11 THEN GOTO 101; IF CUR_CMD = 12 THEN GOTO 101; IF CUR_CMD = 68 THEN GOTO 101; X_TOKEN; IF CUR_CMD = 11 THEN GOTO 101; IF CUR_CMD = 12 THEN GOTO 101; IF CUR_CMD = 68 THEN GOTO 101; IF CUR_CMD = 16 THEN BEGIN SCAN_CHAR_NUM; CUR_CHR ← CUR_VAL; GOTO 101 END; IF CUR_CMD = 65 THEN BCHAR ← 256; CUR_R ← BCHAR; LIG_STACK ← 0; GOTO 110; 101: MAIN_S ← EQTB[8651 + CUR_CHR].HH.RH; IF MAIN_S = 1000 THEN CUR_LIST.AUX_FIELD.HH.LH ← 1000 ELSE IF MAIN_S < 1000 THEN BEGIN IF MAIN_S > 0 THEN CUR_LIST.AUX_FIELD.HH.LH ← MAIN_S END ELSE IF CUR_LIST.AUX_FIELD.HH.LH < 1000 THEN CUR_LIST.AUX_FIELD.HH.LH ← 1000 ELSE CUR_LIST.AUX_FIELD.HH.LH ← MAIN_S; BEGIN LIG_STACK ← AVAIL; IF LIG_STACK = 0 THEN LIG_STACK ← GET_AVAIL ELSE BEGIN AVAIL ← MEM[LIG_STACK].HH.RH; MEM[LIG_STACK].HH.RH ← 0 END END; MEM[LIG_STACK].HH.B0 ← MAIN_F; CUR_R ← CUR_CHR + 0; MEM[LIG_STACK].HH.B1 ← CUR_R; IF CUR_R = FALSE_BCHAR THEN CUR_R ← 256; 110: IF (MAIN_I.B2 - 0) MOD 4 ≠ 1 THEN GOTO 80; IF CUR_R = 256 THEN GOTO 80; MAIN_K ← LIG_KERN_BASE[MAIN_F] + MAIN_I.B3; MAIN_J ← FONT_INFO[MAIN_K].QQQQ; IF MAIN_J.B0 ≤ 128 THEN GOTO 112; MAIN_K ← LIG_KERN_BASE[MAIN_F] + 256 * MAIN_J.B2 + MAIN_J.B3 + 32768 - 256 * 128; 111: MAIN_J ← FONT_INFO[MAIN_K].QQQQ; 112: IF MAIN_J.B1 = CUR_R THEN IF MAIN_J.B0 ≤ 128 THEN BEGIN IF MAIN_J.B2 ≥ 128 THEN BEGIN IF CUR_L < 256 THEN BEGIN IF MEM[CUR_Q].HH.RH > 0 THEN IF MEM[CUR_LIST.TAIL_FIELD].HH.B1 = HYPHEN_CHAR[MAIN_F] + 0 THEN INS_DISC ← TRUE; IF LIGATURE_PRESENT THEN BEGIN MAIN_P ← NEW_LIGATURE (MAIN_F, CUR_L, MEM[CUR_Q].HH.RH); IF LFT_HIT THEN BEGIN MEM[MAIN_P].HH.B1 ← 2; LFT_HIT ← FALSE END; IF RT_HIT THEN IF LIG_STACK = 0 THEN BEGIN MEM[MAIN_P].HH.B1 ← MEM[MAIN_P].HH.B1 + 1; RT_HIT ← FALSE END; MEM[CUR_Q].HH.RH ← MAIN_P; CUR_LIST.TAIL_FIELD ← MAIN_P; LIGATURE_PRESENT ← FALSE END; IF INS_DISC THEN BEGIN INS_DISC ← FALSE; IF CUR_LIST.MODE_FIELD > 0 THEN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_DISC; CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END END END; BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_KERN (FONT_INFO[KERN_BASE[MAIN_F] + 256 * MAIN_J.B2 + MAIN_J.B3].INT); CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; GOTO 90 END; IF CUR_L = 256 THEN LFT_HIT ← TRUE ELSE IF LIG_STACK = 0 THEN RT_HIT ← TRUE; BEGIN IF INTERRUPT ≠ 0 THEN PAUSE_FOR_INSTRUCTIONS END; CASE MAIN_J.B2 OF 1, 5: BEGIN CUR_L ← MAIN_J.B3; MAIN_I ← FONT_INFO[CHAR_BASE[MAIN_F] + CUR_L].QQQQ; LIGATURE_PRESENT ← TRUE END; 2, 6: BEGIN CUR_R ← MAIN_J.B3; IF LIG_STACK = 0 THEN BEGIN LIG_STACK ← NEW_LIG_ITEM (CUR_R); BCHAR ← 256 END ELSE IF LIG_STACK ≥ HI_MEM_MIN THEN BEGIN MAIN_P ← LIG_STACK; LIG_STACK ← NEW_LIG_ITEM (CUR_R); MEM[LIG_STACK + 1].HH.RH ← MAIN_P END ELSE MEM[LIG_STACK].HH.B1 ← CUR_R END; 3: BEGIN CUR_R ← MAIN_J.B3; MAIN_P ← LIG_STACK; LIG_STACK ← NEW_LIG_ITEM (CUR_R); MEM[LIG_STACK].HH.RH ← MAIN_P END; 7, 11: BEGIN IF CUR_L < 256 THEN BEGIN IF MEM[CUR_Q].HH.RH > 0 THEN IF MEM[CUR_LIST.TAIL_FIELD].HH.B1 = HYPHEN_CHAR[MAIN_F] + 0 THEN INS_DISC ← TRUE; IF LIGATURE_PRESENT THEN BEGIN MAIN_P ← NEW_LIGATURE (MAIN_F, CUR_L, MEM[CUR_Q].HH.RH); IF LFT_HIT THEN BEGIN MEM[MAIN_P].HH.B1 ← 2; LFT_HIT ← FALSE END; IF FALSE THEN IF LIG_STACK = 0 THEN BEGIN MEM[MAIN_P].HH.B1 ← MEM[MAIN_P].HH.B1 + 1; RT_HIT ← FALSE END; MEM[CUR_Q].HH.RH ← MAIN_P; CUR_LIST.TAIL_FIELD ← MAIN_P; LIGATURE_PRESENT ← FALSE END; IF INS_DISC THEN BEGIN INS_DISC ← FALSE; IF CUR_LIST.MODE_FIELD > 0 THEN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← NEW_DISC; CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END END END; CUR_Q ← CUR_LIST.TAIL_FIELD; CUR_L ← MAIN_J.B3; MAIN_I ← FONT_INFO[CHAR_BASE[MAIN_F] + CUR_L].QQQQ; LIGATURE_PRESENT ← TRUE END; ELSE BEGIN CUR_L ← MAIN_J.B3; LIGATURE_PRESENT ← TRUE; IF LIG_STACK = 0 THEN GOTO 80 ELSE GOTO 91 END; END; IF MAIN_J.B2 > 4 THEN IF MAIN_J.B2 ≠ 7 THEN GOTO 80; IF CUR_L < 256 THEN GOTO 110; MAIN_K ← BCHAR_LABEL[MAIN_F]; GOTO 111 END; IF MAIN_J.B0 = 0 THEN MAIN_K ← MAIN_K + 1 ELSE BEGIN IF MAIN_J.B0 ≥ 128 THEN GOTO 80; MAIN_K ← MAIN_K + MAIN_J.B0 + 1 END; GOTO 111; 95: MAIN_P ← MEM[LIG_STACK + 1].HH.RH; IF MAIN_P > 0 THEN BEGIN MEM[CUR_LIST.TAIL_FIELD].HH.RH ← MAIN_P; CUR_LIST.TAIL_FIELD ← MEM[CUR_LIST.TAIL_FIELD].HH.RH END; TEMP_PTR ← LIG_STACK; LIG_STACK ← MEM[TEMP_PTR].HH.RH; FREE_NODE (TEMP_PTR, 2); MAIN_I ← FONT_INFO[CHAR_BASE[MAIN_F] + CUR_L].QQQQ; LIGATURE_PRESENT ← TRUE; IF LIG_STACK = 0 THEN IF MAIN_P > 0 THEN GOTO 100 ELSE CUR_R ← BCHAR ELSE CUR_R ← MEM[LIG_STACK].HH.B1; GOTO 110; 120: IF EQTB[6794].HH.RH = 0 THEN BEGIN BEGIN MAIN_P ← FONT_GLUE[EQTB[7834].HH.RH]; IF MAIN_P = 0 THEN BEGIN MAIN_P ← NEW_SPEC (0); MAIN_K ← PARAM_BASE[EQTB[7834].HH.RH] + 2; MEM[MAIN_P + 1].INT ← FONT_INFO[MAIN_K].INT; MEM[MAIN_P + 2].INT ← FONT_INFO[MAIN_K + 1].INT; MEM[MAIN_P + 3].INT ← FONT_INFO[MAIN_K + 2].INT; FONT_GLUE[EQTB[7834].HH.RH] ← MAIN_P END END; TEMP_PTR ← NEW_GLUE (MAIN_P) END ELSE TEMP_PTR ← NEW_PARAM_GLUE (12); MEM[CUR_LIST.TAIL_FIELD].HH.RH ← TEMP_PTR; CUR_LIST.TAIL_FIELD ← TEMP_PTR; GOTO 60; 10: END; PROCEDURE GIVE_ERR_HELP; BEGIN TOKEN_SHOW (EQTB[7321].HH.RH) END; FUNCTION OPEN_FMT_FILE:BOOLEAN; LABEL 40, 10; VAR J : 0..BUF_SIZE; BEGIN J ← CUR_INPUT.LOC_FIELD; IF BUFFER[CUR_INPUT.LOC_FIELD] = 38 THEN BEGIN CUR_INPUT.LOC_FIELD ← CUR_INPUT.LOC_FIELD + 1; J ← CUR_INPUT.LOC_FIELD; BUFFER[LAST] ← 32; WHILE BUFFER[J] ≠ 32 DO J ← J + 1; PACK_BUFFERED_NAME (0, CUR_INPUT.LOC_FIELD, J - 1); IF W_OPEN_IN (FMT_FILE) THEN GOTO 40; PACK_BUFFERED_NAME (11, CUR_INPUT.LOC_FIELD, J - 1); IF W_OPEN_IN (FMT_FILE) THEN GOTO 40; WRITELN (TERM_OUT, 'Sorry, I can''t find that format;', ' will try PLAIN.'); BREAK (TERM_OUT) END; PACK_BUFFERED_NAME (16, 1, 0); IF NOT W_OPEN_IN (FMT_FILE) THEN BEGIN WRITELN (TERM_OUT, 'I can''t find the PLAIN format file!'); OPEN_FMT_FILE ← FALSE; GOTO 10 END; 40: CUR_INPUT.LOC_FIELD ← J; OPEN_FMT_FILE ← TRUE; 10: END; FUNCTION LOAD_FMT_FILE:BOOLEAN; LABEL 6666, 10; VAR J : INTEGER; K : INTEGER; P : HALFWORD; Q : HALFWORD; X : INTEGER; W : FOUR_QUARTERS; BEGIN X ← FMT_FILE↑.INT; IF X ≠ 504454778 THEN GOTO 6666; BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF X ≠ 0 THEN GOTO 6666; BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF X ≠ 60000 THEN GOTO 6666; BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF X ≠ 10006 THEN GOTO 6666; BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF X ≠ 1777 THEN GOTO 6666; BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF X ≠ 307 THEN GOTO 6666; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF X < 0 THEN GOTO 6666; IF X > POOL_SIZE THEN BEGIN WRITELN (TERM_OUT, '---! Must increase the ', 'string pool size'); GOTO 6666 END ELSE POOL_PTR ← X END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF X < 0 THEN GOTO 6666; IF X > MAX_STRINGS THEN BEGIN WRITELN (TERM_OUT, '---! Must increase the ', 'max strings'); GOTO 6666 END ELSE STR_PTR ← X END; FOR K ← 0 TO STR_PTR DO BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 0) OR (X > POOL_PTR) THEN GOTO 6666 ELSE STR_START[K] ← X END; K ← 0; WHILE K + 4 < POOL_PTR DO BEGIN BEGIN GET (FMT_FILE); W ← FMT_FILE↑.QQQQ END; STR_POOL[K] ← W.B0 - 0; STR_POOL[K + 1] ← W.B1 - 0; STR_POOL[K + 2] ← W.B2 - 0; STR_POOL[K + 3] ← W.B3 - 0; K ← K + 4 END; K ← POOL_PTR - 4; BEGIN GET (FMT_FILE); W ← FMT_FILE↑.QQQQ END; STR_POOL[K] ← W.B0 - 0; STR_POOL[K + 1] ← W.B1 - 0; STR_POOL[K + 2] ← W.B2 - 0; STR_POOL[K + 3] ← W.B3 - 0; INIT_STR_PTR ← STR_PTR; INIT_POOL_PTR ← POOL_PTR; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 1019) OR (X > 59986) THEN GOTO 6666 ELSE LO_MEM_MAX ← X END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 20) OR (X > LO_MEM_MAX) THEN GOTO 6666 ELSE ROVER ← X END; P ← 0; Q ← ROVER; REPEAT FOR K ← P TO Q + 1 DO BEGIN GET (FMT_FILE); MEM[K] ← FMT_FILE↑ END; P ← Q + MEM[Q].HH.LH; IF (P > LO_MEM_MAX) OR (Q ≥ MEM[Q + 1].HH.RH) AND (MEM[Q + 1].HH.RH ≠ ROVER) THEN GOTO 6666; Q ← MEM[Q + 1].HH.RH UNTIL Q = ROVER; FOR K ← P TO LO_MEM_MAX DO BEGIN GET (FMT_FILE); MEM[K] ← FMT_FILE↑ END; IF MEM_MIN < -2 THEN BEGIN P ← MEM[ROVER + 1].HH.LH; Q ← MEM_MIN + 1; MEM[MEM_MIN].HH.RH ← 0; MEM[MEM_MIN].HH.LH ← 0; MEM[P + 1].HH.RH ← Q; MEM[ROVER + 1].HH.LH ← Q; MEM[Q + 1].HH.RH ← ROVER; MEM[Q + 1].HH.LH ← P; MEM[Q].HH.RH ← 65535; MEM[Q].HH.LH ← -0 - Q END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < LO_MEM_MAX + 1) OR (X > 59987) THEN GOTO 6666 ELSE HI_MEM_MIN ← X END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 0) OR (X > 60000) THEN GOTO 6666 ELSE AVAIL ← X END; MEM_END ← 60000; FOR K ← HI_MEM_MIN TO MEM_END DO BEGIN GET (FMT_FILE); MEM[K] ← FMT_FILE↑ END; BEGIN GET (FMT_FILE); VAR_USED ← FMT_FILE↑.INT END; BEGIN GET (FMT_FILE); DYN_USED ← FMT_FILE↑.INT END; K ← 1; REPEAT BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 1) OR (K + X > 10007) THEN GOTO 6666; FOR J ← K TO K + X - 1 DO BEGIN GET (FMT_FILE); EQTB[J] ← FMT_FILE↑ END; K ← K + X; BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 0) OR (K + X > 10007) THEN GOTO 6666; FOR J ← K TO K + X - 1 DO EQTB[J] ← EQTB[K - 1]; K ← K + X UNTIL K > 10006; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 514) OR (X > 6514) THEN GOTO 6666 ELSE PAR_LOC ← X END; PAR_TOKEN ← 4095 + PAR_LOC; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 514) OR (X > 6514) THEN GOTO 6666 ELSE WRITE_LOC ← X END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 514) OR (X > 6514) THEN GOTO 6666 ELSE HASH_USED ← X END; P ← 513; REPEAT BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < P + 1) OR (X > HASH_USED) THEN GOTO 6666 ELSE P ← X END; BEGIN GET (FMT_FILE); HASH[P] ← FMT_FILE↑.HH END UNTIL P = HASH_USED; FOR P ← HASH_USED + 1 TO 6780 DO BEGIN GET (FMT_FILE); HASH[P] ← FMT_FILE↑.HH END; BEGIN GET (FMT_FILE); CS_COUNT ← FMT_FILE↑.INT END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF X < 7 THEN GOTO 6666; IF X > FONT_MEM_SIZE THEN BEGIN WRITELN (TERM_OUT, '---! Must increase the ', 'font mem size'); GOTO 6666 END ELSE FMEM_PTR ← X END; FOR K ← 0 TO FMEM_PTR - 1 DO BEGIN GET (FMT_FILE); FONT_INFO[K] ← FMT_FILE↑ END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF X < 0 THEN GOTO 6666; IF X > FONT_MAX THEN BEGIN WRITELN (TERM_OUT, '---! Must increase the ', 'font max'); GOTO 6666 END ELSE FONT_PTR ← X END; FOR K ← 0 TO FONT_PTR DO BEGIN BEGIN GET (FMT_FILE); FONT_CHECK[K] ← FMT_FILE↑.QQQQ END; BEGIN GET (FMT_FILE); FONT_SIZE[K] ← FMT_FILE↑.INT END; BEGIN GET (FMT_FILE); FONT_DSIZE[K] ← FMT_FILE↑.INT END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 0) OR (X > 65535) THEN GOTO 6666 ELSE FONT_PARAMS[K] ← X END; BEGIN GET (FMT_FILE); HYPHEN_CHAR[K] ← FMT_FILE↑.INT END; BEGIN GET (FMT_FILE); SKEW_CHAR[K] ← FMT_FILE↑.INT END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 0) OR (X > STR_PTR) THEN GOTO 6666 ELSE FONT_NAME[K] ← X END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 0) OR (X > STR_PTR) THEN GOTO 6666 ELSE FONT_AREA[K] ← X END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 0) OR (X > 255) THEN GOTO 6666 ELSE FONT_BC[K] ← X END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 0) OR (X > 255) THEN GOTO 6666 ELSE FONT_EC[K] ← X END; BEGIN GET (FMT_FILE); CHAR_BASE[K] ← FMT_FILE↑.INT END; BEGIN GET (FMT_FILE); WIDTH_BASE[K] ← FMT_FILE↑.INT END; BEGIN GET (FMT_FILE); HEIGHT_BASE[K] ← FMT_FILE↑.INT END; BEGIN GET (FMT_FILE); DEPTH_BASE[K] ← FMT_FILE↑.INT END; BEGIN GET (FMT_FILE); ITALIC_BASE[K] ← FMT_FILE↑.INT END; BEGIN GET (FMT_FILE); LIG_KERN_BASE[K] ← FMT_FILE↑.INT END; BEGIN GET (FMT_FILE); KERN_BASE[K] ← FMT_FILE↑.INT END; BEGIN GET (FMT_FILE); EXTEN_BASE[K] ← FMT_FILE↑.INT END; BEGIN GET (FMT_FILE); PARAM_BASE[K] ← FMT_FILE↑.INT END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 0) OR (X > LO_MEM_MAX) THEN GOTO 6666 ELSE FONT_GLUE[K] ← X END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 0) OR (X > FMEM_PTR - 1) THEN GOTO 6666 ELSE BCHAR_LABEL[K] ← X END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 0) OR (X > 256) THEN GOTO 6666 ELSE FONT_BCHAR[K] ← X END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 0) OR (X > 256) THEN GOTO 6666 ELSE FONT_FALSE_BCHAR[K] ← X END END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 0) OR (X > 307) THEN GOTO 6666 ELSE HYPH_COUNT ← X END; FOR K ← 1 TO HYPH_COUNT DO BEGIN BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 0) OR (X > 307) THEN GOTO 6666 ELSE J ← X END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 0) OR (X > STR_PTR) THEN GOTO 6666 ELSE HYPH_WORD[J] ← X END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 0) OR (X > 65535) THEN GOTO 6666 ELSE HYPH_LIST[J] ← X END END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF X < 0 THEN GOTO 6666; IF X > TRIE_SIZE THEN BEGIN WRITELN (TERM_OUT, '---! Must increase the ', 'trie size'); GOTO 6666 END ELSE J ← X END; TRIE_MAX ← J; FOR K ← 0 TO J DO BEGIN GET (FMT_FILE); TRIE[K] ← FMT_FILE↑.HH END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF X < 0 THEN GOTO 6666; IF X > TRIE_OP_SIZE THEN BEGIN WRITELN (TERM_OUT, '---! Must increase the ', 'trie op size'); GOTO 6666 END ELSE J ← X END; TRIE_OP_PTR ← J; FOR K ← 1 TO J DO BEGIN BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 0) OR (X > 63) THEN GOTO 6666 ELSE HYF_DISTANCE[K] ← X END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 0) OR (X > 63) THEN GOTO 6666 ELSE HYF_NUM[K] ← X END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 0) OR (X > 255) THEN GOTO 6666 ELSE HYF_NEXT[K] ← X END END; FOR K ← 0 TO 255 DO TRIE_USED[K] ← 0; K ← 256; WHILE J > 0 DO BEGIN BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 0) OR (X > K - 1) THEN GOTO 6666 ELSE K ← X END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 1) OR (X > J) THEN GOTO 6666 ELSE X ← X END; TRIE_USED[K] ← X + 0; J ← J - X; OP_START[K] ← J - 0 END; TRIE_NOT_READY ← FALSE; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 0) OR (X > 3) THEN GOTO 6666 ELSE INTERACTION ← X END; BEGIN BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X < 0) OR (X > STR_PTR) THEN GOTO 6666 ELSE FORMAT_IDENT ← X END; BEGIN GET (FMT_FILE); X ← FMT_FILE↑.INT END; IF (X ≠ 69069) OR EOF (FMT_FILE) THEN GOTO 6666; LOAD_FMT_FILE ← TRUE; GOTO 10; 6666: ; WRITELN (TERM_OUT, '(Fatal format file error; I''m stymied)'); LOAD_FMT_FILE ← FALSE; 10: END; PROCEDURE CLOSE_FILES_AND_TERMINATE; VAR K : INTEGER; BEGIN FOR K ← 0 TO 15 DO IF WRITE_OPEN[K] THEN A_CLOSE (WRITE_FILE[K]); EQTB[9212].INT ← -1; WHILE CUR_S > -1 DO BEGIN IF CUR_S > 0 THEN BEGIN DVI_BUF[DVI_PTR] ← 142; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END ELSE BEGIN BEGIN DVI_BUF[DVI_PTR] ← 140; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; TOTAL_PAGES ← TOTAL_PAGES + 1 END; CUR_S ← CUR_S - 1 END; IF TOTAL_PAGES = 0 THEN PRINT_NL (837) ELSE BEGIN BEGIN DVI_BUF[DVI_PTR] ← 248; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; DVI_FOUR (LAST_BOP); LAST_BOP ← DVI_OFFSET + DVI_PTR - 5; DVI_FOUR (25400000); DVI_FOUR (473628672); PREPARE_MAG; DVI_FOUR (EQTB[9180].INT); DVI_FOUR (MAX_V); DVI_FOUR (MAX_H); BEGIN DVI_BUF[DVI_PTR] ← MAX_PUSH DIV 256; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; BEGIN DVI_BUF[DVI_PTR] ← MAX_PUSH MOD 256; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; BEGIN DVI_BUF[DVI_PTR] ← TOTAL_PAGES DIV 256 MOD 256; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; BEGIN DVI_BUF[DVI_PTR] ← TOTAL_PAGES MOD 256; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; WHILE FONT_PTR > 0 DO BEGIN IF FONT_USED[FONT_PTR] THEN DVI_FONT_DEF (FONT_PTR); FONT_PTR ← FONT_PTR - 1 END; BEGIN DVI_BUF[DVI_PTR] ← 249; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; DVI_FOUR (LAST_BOP); BEGIN DVI_BUF[DVI_PTR] ← 2; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; K ← 4 + (DVI_BUF_SIZE - DVI_PTR) MOD 4; WHILE K > 0 DO BEGIN BEGIN DVI_BUF[DVI_PTR] ← 223; DVI_PTR ← DVI_PTR + 1; IF DVI_PTR = DVI_LIMIT THEN DVI_SWAP END; K ← K - 1 END; IF DVI_LIMIT = HALF_BUF THEN WRITE_DVI (HALF_BUF, DVI_BUF_SIZE - 1); IF DVI_PTR > 0 THEN WRITE_DVI (0, DVI_PTR - 1); PRINT_NL (838); SLOW_PRINT (OUTPUT_FILE_NAME); PRINT (286); PRINT_INT (TOTAL_PAGES); PRINT (839); IF TOTAL_PAGES ≠ 1 THEN PRINT_CHAR (115); PRINT (840); PRINT_INT (DVI_OFFSET + DVI_PTR); PRINT (841); B_CLOSE (DVI_FILE) END; IF LOG_OPENED THEN BEGIN WRITELN (LOG_FILE); A_CLOSE (LOG_FILE); SELECTOR ← SELECTOR - 2; IF SELECTOR = 17 THEN BEGIN PRINT_NL (1275); SLOW_PRINT (LOG_NAME); PRINT_CHAR (46) END END END; PROCEDURE FINAL_CLEANUP; LABEL 10; VAR C : SMALL_NUMBER; BEGIN C ← CUR_CHR; IF C ≠ 1 THEN EQTB[9212].INT ← -1; IF JOB_NAME = 0 THEN OPEN_LOG_FILE; WHILE INPUT_PTR > 0 DO IF CUR_INPUT.STATE_FIELD = 0 THEN END_TOKEN_LIST ELSE END_FILE_READING; WHILE OPEN_PARENS > 0 DO BEGIN PRINT (1276); OPEN_PARENS ← OPEN_PARENS - 1 END; IF CUR_LEVEL > 1 THEN BEGIN PRINT_NL (40); PRINT_ESC (1277); PRINT (1278); PRINT_INT (CUR_LEVEL - 1); PRINT_CHAR (41) END; WHILE COND_PTR ≠ 0 DO BEGIN PRINT_NL (40); PRINT_ESC (1277); PRINT (1279); PRINT_CMD_CHR (105, CUR_IF); IF IF_LINE ≠ 0 THEN BEGIN PRINT (1280); PRINT_INT (IF_LINE) END; PRINT (1281); IF_LINE ← MEM[COND_PTR + 1].INT; CUR_IF ← MEM[COND_PTR].HH.B1; TEMP_PTR ← COND_PTR; COND_PTR ← MEM[COND_PTR].HH.RH; FREE_NODE (TEMP_PTR, 2) END; IF HISTORY ≠ 0 THEN IF (HISTORY = 1) OR (INTERACTION < 3) THEN IF SELECTOR = 19 THEN BEGIN SELECTOR ← 17; PRINT_NL (1282); SELECTOR ← 19 END; IF C = 1 THEN BEGIN FOR C ← 0 TO 4 DO IF CUR_MARK[C] ≠ 0 THEN DELETE_TOKEN_REF (CUR_MARK[C]); IF LAST_GLUE ≠ 65535 THEN DELETE_GLUE_REF (LAST_GLUE); STORE_FMT_FILE; GOTO 10; PRINT_NL (1283); GOTO 10 END; 10: END; PROCEDURE INIT_PRIM; BEGIN NO_NEW_CONTROL_SEQUENCE ← FALSE; PRIMITIVE (376, 75, 6782); PRIMITIVE (377, 75, 6783); PRIMITIVE (378, 75, 6784); PRIMITIVE (379, 75, 6785); PRIMITIVE (380, 75, 6786); PRIMITIVE (381, 75, 6787); PRIMITIVE (382, 75, 6788); PRIMITIVE (383, 75, 6789); PRIMITIVE (384, 75, 6790); PRIMITIVE (385, 75, 6791); PRIMITIVE (386, 75, 6792); PRIMITIVE (387, 75, 6793); PRIMITIVE (388, 75, 6794); PRIMITIVE (389, 75, 6795); PRIMITIVE (390, 75, 6796); PRIMITIVE (391, 76, 6797); PRIMITIVE (392, 76, 6798); PRIMITIVE (393, 76, 6799); PRIMITIVE (398, 72, 7313); PRIMITIVE (399, 72, 7314); PRIMITIVE (400, 72, 7315); PRIMITIVE (401, 72, 7316); PRIMITIVE (402, 72, 7317); PRIMITIVE (403, 72, 7318); PRIMITIVE (404, 72, 7319); PRIMITIVE (405, 72, 7320); PRIMITIVE (406, 72, 7321); PRIMITIVE (420, 73, 9163); PRIMITIVE (421, 73, 9164); PRIMITIVE (422, 73, 9165); PRIMITIVE (423, 73, 9166); PRIMITIVE (424, 73, 9167); PRIMITIVE (425, 73, 9168); PRIMITIVE (426, 73, 9169); PRIMITIVE (427, 73, 9170); PRIMITIVE (428, 73, 9171); PRIMITIVE (429, 73, 9172); PRIMITIVE (430, 73, 9173); PRIMITIVE (431, 73, 9174); PRIMITIVE (432, 73, 9175); PRIMITIVE (433, 73, 9176); PRIMITIVE (434, 73, 9177); PRIMITIVE (435, 73, 9178); PRIMITIVE (436, 73, 9179); PRIMITIVE (437, 73, 9180); PRIMITIVE (438, 73, 9181); PRIMITIVE (439, 73, 9182); PRIMITIVE (440, 73, 9183); PRIMITIVE (441, 73, 9184); PRIMITIVE (442, 73, 9185); PRIMITIVE (443, 73, 9186); PRIMITIVE (444, 73, 9187); PRIMITIVE (445, 73, 9188); PRIMITIVE (446, 73, 9189); PRIMITIVE (447, 73, 9190); PRIMITIVE (448, 73, 9191); PRIMITIVE (449, 73, 9192); PRIMITIVE (450, 73, 9193); PRIMITIVE (451, 73, 9194); PRIMITIVE (452, 73, 9195); PRIMITIVE (453, 73, 9196); PRIMITIVE (454, 73, 9197); PRIMITIVE (455, 73, 9198); PRIMITIVE (456, 73, 9199); PRIMITIVE (457, 73, 9200); PRIMITIVE (458, 73, 9201); PRIMITIVE (459, 73, 9202); PRIMITIVE (460, 73, 9203); PRIMITIVE (461, 73, 9204); PRIMITIVE (462, 73, 9205); PRIMITIVE (463, 73, 9206); PRIMITIVE (464, 73, 9207); PRIMITIVE (465, 73, 9208); PRIMITIVE (466, 73, 9209); PRIMITIVE (467, 73, 9210); PRIMITIVE (468, 73, 9211); PRIMITIVE (469, 73, 9212); PRIMITIVE (470, 73, 9213); PRIMITIVE (471, 73, 9214); PRIMITIVE (472, 73, 9215); PRIMITIVE (473, 73, 9216); PRIMITIVE (474, 73, 9217); PRIMITIVE (478, 74, 9730); PRIMITIVE (479, 74, 9731); PRIMITIVE (480, 74, 9732); PRIMITIVE (481, 74, 9733); PRIMITIVE (482, 74, 9734); PRIMITIVE (483, 74, 9735); PRIMITIVE (484, 74, 9736); PRIMITIVE (485, 74, 9737); PRIMITIVE (486, 74, 9738); PRIMITIVE (487, 74, 9739); PRIMITIVE (488, 74, 9740); PRIMITIVE (489, 74, 9741); PRIMITIVE (490, 74, 9742); PRIMITIVE (491, 74, 9743); PRIMITIVE (492, 74, 9744); PRIMITIVE (493, 74, 9745); PRIMITIVE (494, 74, 9746); PRIMITIVE (495, 74, 9747); PRIMITIVE (496, 74, 9748); PRIMITIVE (497, 74, 9749); PRIMITIVE (498, 74, 9750); PRIMITIVE (32, 64, 0); PRIMITIVE (47, 44, 0); PRIMITIVE (508, 45, 0); PRIMITIVE (509, 90, 0); PRIMITIVE (510, 40, 0); PRIMITIVE (511, 41, 0); PRIMITIVE (512, 61, 0); PRIMITIVE (513, 16, 0); PRIMITIVE (504, 107, 0); PRIMITIVE (514, 15, 0); PRIMITIVE (515, 92, 0); PRIMITIVE (505, 67, 0); PRIMITIVE (516, 62, 0); HASH[6516].RH ← 516; EQTB[6516] ← EQTB[CUR_VAL]; PRIMITIVE (517, 102, 0); PRIMITIVE (518, 88, 0); PRIMITIVE (519, 77, 0); PRIMITIVE (520, 32, 0); PRIMITIVE (521, 36, 0); PRIMITIVE (522, 39, 0); PRIMITIVE (330, 37, 0); PRIMITIVE (351, 18, 0); PRIMITIVE (523, 46, 0); PRIMITIVE (524, 17, 0); PRIMITIVE (525, 54, 0); PRIMITIVE (526, 91, 0); PRIMITIVE (527, 34, 0); PRIMITIVE (528, 65, 0); PRIMITIVE (529, 103, 0); PRIMITIVE (335, 55, 0); PRIMITIVE (530, 63, 0); PRIMITIVE (408, 84, 0); PRIMITIVE (531, 42, 0); PRIMITIVE (532, 80, 0); PRIMITIVE (533, 66, 0); PRIMITIVE (534, 96, 0); PRIMITIVE (535, 0, 256); HASH[6521].RH ← 535; EQTB[6521] ← EQTB[CUR_VAL]; PRIMITIVE (536, 98, 0); PRIMITIVE (537, 109, 0); PRIMITIVE (407, 71, 0); PRIMITIVE (352, 38, 0); PRIMITIVE (538, 33, 0); PRIMITIVE (539, 56, 0); PRIMITIVE (540, 35, 0); PRIMITIVE (597, 13, 256); PAR_LOC ← CUR_VAL; PAR_TOKEN ← 4095 + PAR_LOC; PRIMITIVE (629, 104, 0); PRIMITIVE (630, 104, 1); PRIMITIVE (631, 110, 0); PRIMITIVE (632, 110, 1); PRIMITIVE (633, 110, 2); PRIMITIVE (634, 110, 3); PRIMITIVE (635, 110, 4); PRIMITIVE (476, 89, 0); PRIMITIVE (500, 89, 1); PRIMITIVE (395, 89, 2); PRIMITIVE (396, 89, 3); PRIMITIVE (668, 79, 102); PRIMITIVE (669, 79, 1); PRIMITIVE (670, 82, 0); PRIMITIVE (671, 82, 1); PRIMITIVE (672, 83, 1); PRIMITIVE (673, 83, 3); PRIMITIVE (674, 83, 2); PRIMITIVE (675, 70, 0); PRIMITIVE (676, 70, 1); PRIMITIVE (677, 70, 2); PRIMITIVE (678, 70, 3); PRIMITIVE (679, 70, 4); PRIMITIVE (735, 108, 0); PRIMITIVE (736, 108, 1); PRIMITIVE (737, 108, 2); PRIMITIVE (738, 108, 3); PRIMITIVE (739, 108, 4); PRIMITIVE (740, 108, 5); PRIMITIVE (757, 105, 0); PRIMITIVE (758, 105, 1); PRIMITIVE (759, 105, 2); PRIMITIVE (760, 105, 3); PRIMITIVE (761, 105, 4); PRIMITIVE (762, 105, 5); PRIMITIVE (763, 105, 6); PRIMITIVE (764, 105, 7); PRIMITIVE (765, 105, 8); PRIMITIVE (766, 105, 9); PRIMITIVE (767, 105, 10); PRIMITIVE (768, 105, 11); PRIMITIVE (769, 105, 12); PRIMITIVE (770, 105, 13); PRIMITIVE (771, 105, 14); PRIMITIVE (772, 105, 15); PRIMITIVE (773, 105, 16); PRIMITIVE (774, 106, 2); HASH[6518].RH ← 774; EQTB[6518] ← EQTB[CUR_VAL]; PRIMITIVE (775, 106, 4); PRIMITIVE (776, 106, 3); PRIMITIVE (801, 87, 0); HASH[6524].RH ← 801; EQTB[6524] ← EQTB[CUR_VAL]; PRIMITIVE (898, 4, 256); PRIMITIVE (899, 5, 257); HASH[6515].RH ← 899; EQTB[6515] ← EQTB[CUR_VAL]; PRIMITIVE (900, 5, 258); HASH[6519].RH ← 901; HASH[6520].RH ← 901; EQTB[6520].HH.B0 ← 9; EQTB[6520].HH.RH ← 59989; EQTB[6520].HH.B1 ← 1; EQTB[6519] ← EQTB[6520]; EQTB[6519].HH.B0 ← 115; PRIMITIVE (970, 81, 0); PRIMITIVE (971, 81, 1); PRIMITIVE (972, 81, 2); PRIMITIVE (973, 81, 3); PRIMITIVE (974, 81, 4); PRIMITIVE (975, 81, 5); PRIMITIVE (976, 81, 6); PRIMITIVE (977, 81, 7); PRIMITIVE (1025, 14, 0); PRIMITIVE (1026, 14, 1); PRIMITIVE (1027, 26, 4); PRIMITIVE (1028, 26, 0); PRIMITIVE (1029, 26, 1); PRIMITIVE (1030, 26, 2); PRIMITIVE (1031, 26, 3); PRIMITIVE (1032, 27, 4); PRIMITIVE (1033, 27, 0); PRIMITIVE (1034, 27, 1); PRIMITIVE (1035, 27, 2); PRIMITIVE (1036, 27, 3); PRIMITIVE (336, 28, 5); PRIMITIVE (340, 29, 1); PRIMITIVE (342, 30, 99); PRIMITIVE (1054, 21, 1); PRIMITIVE (1055, 21, 0); PRIMITIVE (1056, 22, 1); PRIMITIVE (1057, 22, 0); PRIMITIVE (409, 20, 0); PRIMITIVE (1058, 20, 1); PRIMITIVE (1059, 20, 2); PRIMITIVE (965, 20, 3); PRIMITIVE (1060, 20, 4); PRIMITIVE (967, 20, 5); PRIMITIVE (1061, 20, 106); PRIMITIVE (1062, 31, 99); PRIMITIVE (1063, 31, 100); PRIMITIVE (1064, 31, 101); PRIMITIVE (1065, 31, 102); PRIMITIVE (1080, 43, 1); PRIMITIVE (1081, 43, 0); PRIMITIVE (1090, 25, 12); PRIMITIVE (1091, 25, 11); PRIMITIVE (1092, 25, 10); PRIMITIVE (1093, 23, 0); PRIMITIVE (1094, 23, 1); PRIMITIVE (1095, 24, 0); PRIMITIVE (1096, 24, 1); PRIMITIVE (45, 47, 1); PRIMITIVE (349, 47, 0); PRIMITIVE (1127, 48, 0); PRIMITIVE (1128, 48, 1); PRIMITIVE (866, 50, 16); PRIMITIVE (867, 50, 17); PRIMITIVE (868, 50, 18); PRIMITIVE (869, 50, 19); PRIMITIVE (870, 50, 20); PRIMITIVE (871, 50, 21); PRIMITIVE (872, 50, 22); PRIMITIVE (873, 50, 23); PRIMITIVE (875, 50, 26); PRIMITIVE (874, 50, 27); PRIMITIVE (1129, 51, 0); PRIMITIVE (878, 51, 1); PRIMITIVE (879, 51, 2); PRIMITIVE (861, 53, 0); PRIMITIVE (862, 53, 2); PRIMITIVE (863, 53, 4); PRIMITIVE (864, 53, 6); PRIMITIVE (1147, 52, 0); PRIMITIVE (1148, 52, 1); PRIMITIVE (1149, 52, 2); PRIMITIVE (1150, 52, 3); PRIMITIVE (1151, 52, 4); PRIMITIVE (1152, 52, 5); PRIMITIVE (876, 49, 30); PRIMITIVE (877, 49, 31); HASH[6517].RH ← 877; EQTB[6517] ← EQTB[CUR_VAL]; PRIMITIVE (1171, 93, 1); PRIMITIVE (1172, 93, 2); PRIMITIVE (1173, 93, 4); PRIMITIVE (1174, 97, 0); PRIMITIVE (1175, 97, 1); PRIMITIVE (1176, 97, 2); PRIMITIVE (1177, 97, 3); PRIMITIVE (1191, 94, 0); PRIMITIVE (1192, 94, 1); PRIMITIVE (1193, 95, 0); PRIMITIVE (1194, 95, 1); PRIMITIVE (1195, 95, 2); PRIMITIVE (1196, 95, 3); PRIMITIVE (1197, 95, 4); PRIMITIVE (1198, 95, 5); PRIMITIVE (1199, 95, 6); PRIMITIVE (415, 85, 7883); PRIMITIVE (419, 85, 8907); PRIMITIVE (416, 85, 8139); PRIMITIVE (417, 85, 8395); PRIMITIVE (418, 85, 8651); PRIMITIVE (477, 85, 9474); PRIMITIVE (412, 86, 7835); PRIMITIVE (413, 86, 7851); PRIMITIVE (414, 86, 7867); PRIMITIVE (941, 99, 0); PRIMITIVE (953, 99, 1); PRIMITIVE (1217, 78, 0); PRIMITIVE (1218, 78, 1); PRIMITIVE (274, 100, 0); PRIMITIVE (275, 100, 1); PRIMITIVE (276, 100, 2); PRIMITIVE (1227, 100, 3); PRIMITIVE (1228, 60, 1); PRIMITIVE (1229, 60, 0); PRIMITIVE (1230, 58, 0); PRIMITIVE (1231, 58, 1); PRIMITIVE (1237, 57, 8139); PRIMITIVE (1238, 57, 8395); PRIMITIVE (1239, 19, 0); PRIMITIVE (1240, 19, 1); PRIMITIVE (1241, 19, 2); PRIMITIVE (1242, 19, 3); PRIMITIVE (1285, 59, 0); PRIMITIVE (594, 59, 1); WRITE_LOC ← CUR_VAL; PRIMITIVE (1286, 59, 2); PRIMITIVE (1287, 59, 3); PRIMITIVE (1288, 59, 4); PRIMITIVE (1289, 59, 5); NO_NEW_CONTROL_SEQUENCE ← TRUE END; BEGIN HISTORY ← 3; REWRITE (TERM_OUT, 'TTY:', '/O'); IF READY_ALREADY = 314159 THEN GOTO 1; BAD ← 0; IF (HALF_ERROR_LINE < 30) OR (HALF_ERROR_LINE > ERROR_LINE - 15) THEN BAD ← 1; IF MAX_PRINT_LINE < 60 THEN BAD ← 2; IF DVI_BUF_SIZE MOD 8 ≠ 0 THEN BAD ← 3; IF 1100 > 60000 THEN BAD ← 4; IF 1777 > 6000 THEN BAD ← 5; IF MAX_IN_OPEN ≥ 128 THEN BAD ← 6; IF 60000 < 267 THEN BAD ← 7; IF (MEM_MIN ≠ 0) OR (MEM_MAX ≠ 60000) THEN BAD ← 10; IF (MEM_MIN > 0) OR (MEM_MAX < 60000) THEN BAD ← 10; IF (0 > 0) OR (255 < 127) THEN BAD ← 11; IF (0 > 0) OR (65535 < 32767) THEN BAD ← 12; IF (0 < 0) OR (255 > 65535) THEN BAD ← 13; IF (MEM_MIN < 0) OR (MEM_MAX ≥ 65535) OR (-0 - MEM_MIN > 65536) THEN BAD ← 14; IF (0 < 0) OR (FONT_MAX > 255) THEN BAD ← 15; IF FONT_MAX > 256 THEN BAD ← 16; IF (SAVE_SIZE > 65535) OR (MAX_STRINGS > 65535) THEN BAD ← 17; IF BUF_SIZE > 65535 THEN BAD ← 18; IF 255 < 255 THEN BAD ← 19; IF 10876 > 65535 THEN BAD ← 21; IF 20 > FILE_NAME_SIZE THEN BAD ← 31; IF 2 * 65535 < 60000 - MEM_MIN THEN BAD ← 41; IF BAD > 0 THEN BEGIN WRITELN (TERM_OUT, 'Ouch---my internal constants have been clobbered!', '---case ', BAD:1); GOTO 9999 END; INITIALIZE; IF NOT GET_STRINGS_STARTED THEN GOTO 9999; INIT_PRIM; INIT_STR_PTR ← STR_PTR; INIT_POOL_PTR ← POOL_PTR; FIX_DATE_AND_TIME; READY_ALREADY ← 314159; 1: SELECTOR ← 17; TALLY ← 0; TERM_OFFSET ← 0; FILE_OFFSET ← 0; WRITE (TERM_OUT, 'This is TeX, Version 3.141592653'); IF FORMAT_IDENT = 0 THEN WRITELN (TERM_OUT, ' (no format preloaded)') ELSE BEGIN SLOW_PRINT (FORMAT_IDENT); PRINT_LN END; BREAK (TERM_OUT); JOB_NAME ← 0; NAME_IN_PROGRESS ← FALSE; LOG_OPENED ← FALSE; OUTPUT_FILE_NAME ← 0; BEGIN BEGIN INPUT_PTR ← 0; MAX_IN_STACK ← 0; IN_OPEN ← 0; OPEN_PARENS ← 0; MAX_BUF_STACK ← 0; PARAM_PTR ← 0; MAX_PARAM_STACK ← 0; FIRST ← BUF_SIZE; REPEAT BUFFER[FIRST] ← 0; FIRST ← FIRST - 1 UNTIL FIRST = 0; SCANNER_STATUS ← 0; WARNING_INDEX ← 0; FIRST ← 1; CUR_INPUT.STATE_FIELD ← 33; CUR_INPUT.START_FIELD ← 1; CUR_INPUT.INDEX_FIELD ← 0; LINE ← 0; CUR_INPUT.NAME_FIELD ← 0; FORCE_EOF ← FALSE; ALIGN_STATE ← 1000000; IF NOT INIT_TERMINAL THEN GOTO 9999; CUR_INPUT.LIMIT_FIELD ← LAST; FIRST ← LAST + 1 END; IF (FORMAT_IDENT = 0) OR (BUFFER[CUR_INPUT.LOC_FIELD] = 38) THEN BEGIN IF FORMAT_IDENT ≠ 0 THEN INITIALIZE; IF NOT OPEN_FMT_FILE THEN GOTO 9999; IF NOT LOAD_FMT_FILE THEN BEGIN W_CLOSE (FMT_FILE); GOTO 9999 END; W_CLOSE (FMT_FILE); WHILE (CUR_INPUT.LOC_FIELD < CUR_INPUT.LIMIT_FIELD) AND (BUFFER[CUR_INPUT.LOC_FIELD] = 32) DO CUR_INPUT.LOC_FIELD ← CUR_INPUT.LOC_FIELD + 1 END; IF (EQTB[9211].INT < 0) OR (EQTB[9211].INT > 255) THEN CUR_INPUT.LIMIT_FIELD ← CUR_INPUT.LIMIT_FIELD - 1 ELSE BUFFER[CUR_INPUT.LIMIT_FIELD] ← EQTB[9211].INT; FIX_DATE_AND_TIME; MAGIC_OFFSET ← STR_START[892] - 9 * 16; IF INTERACTION = 0 THEN SELECTOR ← 16 ELSE SELECTOR ← 17; IF (CUR_INPUT.LOC_FIELD < CUR_INPUT.LIMIT_FIELD) AND (EQTB[7883 + BUFFER[CUR_INPUT.LOC_FIELD]].HH.RH ≠ 0) THEN START_INPUT END; HISTORY ← 0; MAIN_CONTROL; FINAL_CLEANUP; 9998: CLOSE_FILES_AND_TERMINATE; 9999: READY_ALREADY ← 0 END.