src/cmd/new5a/y.go

   1 //line a.y:32
   2 package main
   3
   4 import __yyfmt__ "fmt"
   5
   6 //line a.y:32
   7 import (
   8         "cmd/internal/asm"
   9         "cmd/internal/obj"
  10         . "cmd/internal/obj/arm"
  11 )
  12
  13 //line a.y:41
  14 type yySymType struct {
  15         yys  int
  16         sym  *asm.Sym
  17         lval int32
  18         dval float64
  19         sval string
  20         addr obj.Addr
  21 }
  22
  23 const LTYPE1 = 57346
  24 const LTYPE2 = 57347
  25 const LTYPE3 = 57348
  26 const LTYPE4 = 57349
  27 const LTYPE5 = 57350
  28 const LTYPE6 = 57351
  29 const LTYPE7 = 57352
  30 const LTYPE8 = 57353
  31 const LTYPE9 = 57354
  32 const LTYPEA = 57355
  33 const LTYPEB = 57356
  34 const LTYPEC = 57357
  35 const LTYPED = 57358
  36 const LTYPEE = 57359
  37 const LTYPEG = 57360
  38 const LTYPEH = 57361
  39 const LTYPEI = 57362
  40 const LTYPEJ = 57363
  41 const LTYPEK = 57364
  42 const LTYPEL = 57365
  43 const LTYPEM = 57366
  44 const LTYPEN = 57367
  45 const LTYPEBX = 57368
  46 const LTYPEPLD = 57369
  47 const LCONST = 57370
  48 const LSP = 57371
  49 const LSB = 57372
  50 const LFP = 57373
  51 const LPC = 57374
  52 const LTYPEX = 57375
  53 const LTYPEPC = 57376
  54 const LTYPEF = 57377
  55 const LR = 57378
  56 const LREG = 57379
  57 const LF = 57380
  58 const LFREG = 57381
  59 const LC = 57382
  60 const LCREG = 57383
  61 const LPSR = 57384
  62 const LFCR = 57385
  63 const LCOND = 57386
  64 const LS = 57387
  65 const LAT = 57388
  66 const LFCONST = 57389
  67 const LSCONST = 57390
  68 const LNAME = 57391
  69 const LLAB = 57392
  70 const LVAR = 57393
  71
  72 var yyToknames = []string{
  73         "'|'",
  74         "'^'",
  75         "'&'",
  76         "'<'",
  77         "'>'",
  78         "'+'",
  79         "'-'",
  80         "'*'",
  81         "'/'",
  82         "'%'",
  83         "LTYPE1",
  84         "LTYPE2",
  85         "LTYPE3",
  86         "LTYPE4",
  87         "LTYPE5",
  88         "LTYPE6",
  89         "LTYPE7",
  90         "LTYPE8",
  91         "LTYPE9",
  92         "LTYPEA",
  93         "LTYPEB",
  94         "LTYPEC",
  95         "LTYPED",
  96         "LTYPEE",
  97         "LTYPEG",
  98         "LTYPEH",
  99         "LTYPEI",
 100         "LTYPEJ",
 101         "LTYPEK",
 102         "LTYPEL",
 103         "LTYPEM",
 104         "LTYPEN",
 105         "LTYPEBX",
 106         "LTYPEPLD",
 107         "LCONST",
 108         "LSP",
 109         "LSB",
 110         "LFP",
 111         "LPC",
 112         "LTYPEX",
 113         "LTYPEPC",
 114         "LTYPEF",
 115         "LR",
 116         "LREG",
 117         "LF",
 118         "LFREG",
 119         "LC",
 120         "LCREG",
 121         "LPSR",
 122         "LFCR",
 123         "LCOND",
 124         "LS",
 125         "LAT",
 126         "LFCONST",
 127         "LSCONST",
 128         "LNAME",
 129         "LLAB",
 130         "LVAR",
 131 }
 132 var yyStatenames = []string{}
 133
 134 const yyEofCode = 1
 135 const yyErrCode = 2
 136 const yyMaxDepth = 200
 137
 138 //line yacctab:1
 139 var yyExca = []int{
 140         -1, 1,
 141         1, -1,
 142         -2, 2,
 143         -1, 194,
 144         67, 59,
 145         -2, 48,
 146 }
 147
 148 const yyNprod = 130
 149 const yyPrivate = 57344
 150
 151 var yyTokenNames []string
 152 var yyStates []string
 153
 154 const yyLast = 694
 155
 156 var yyAct = []int{
 157
 158         123, 317, 71, 83, 98, 104, 200, 77, 82, 193,
 159         89, 127, 271, 73, 113, 85, 3, 106, 227, 134,
 160         327, 88, 87, 313, 76, 52, 52, 101, 102, 293,
 161         283, 278, 84, 84, 270, 72, 81, 81, 70, 69,
 162         84, 84, 84, 142, 269, 268, 81, 257, 84, 220,
 163         114, 118, 323, 120, 310, 97, 99, 110, 75, 51,
 164         60, 131, 132, 133, 103, 103, 294, 138, 140, 143,
 165         137, 144, 103, 90, 121, 149, 92, 204, 111, 246,
 166         93, 91, 112, 148, 195, 188, 136, 163, 101, 102,
 167         156, 94, 145, 146, 157, 162, 43, 45, 151, 147,
 168         108, 126, 302, 251, 106, 252, 62, 101, 102, 57,
 169         56, 179, 149, 165, 184, 250, 95, 84, 44, 329,
 170         194, 81, 322, 186, 182, 109, 320, 189, 316, 116,
 171         199, 198, 122, 124, 206, 207, 197, 314, 54, 90,
 172         209, 300, 92, 299, 44, 296, 93, 91, 187, 289,
 173         286, 84, 222, 282, 260, 81, 256, 255, 218, 219,
 174         44, 55, 217, 216, 215, 84, 131, 229, 59, 81,
 175         214, 58, 212, 90, 211, 190, 92, 196, 192, 242,
 176         93, 91, 84, 230, 191, 181, 81, 232, 233, 234,
 177         235, 236, 249, 180, 239, 240, 241, 247, 178, 44,
 178         164, 150, 125, 243, 86, 244, 219, 38, 37, 221,
 179         254, 258, 34, 35, 36, 261, 262, 259, 264, 210,
 180         57, 56, 228, 231, 272, 272, 272, 272, 273, 273,
 181         273, 273, 72, 248, 213, 265, 277, 274, 275, 276,
 182         245, 266, 267, 306, 57, 161, 158, 319, 318, 54,
 183         135, 194, 305, 287, 194, 88, 87, 280, 281, 238,
 184         285, 78, 292, 288, 226, 101, 102, 90, 295, 141,
 185         92, 225, 55, 54, 93, 91, 224, 253, 100, 59,
 186         291, 160, 58, 57, 56, 152, 153, 205, 154, 303,
 187         237, 120, 160, 159, 53, 223, 55, 88, 263, 308,
 188         307, 105, 105, 74, 129, 130, 58, 301, 7, 105,
 189         312, 315, 54, 96, 304, 90, 2, 321, 92, 107,
 190         1, 324, 93, 91, 325, 311, 117, 183, 101, 102,
 191         101, 102, 284, 139, 155, 55, 309, 290, 8, 328,
 192         119, 44, 74, 326, 0, 58, 0, 297, 0, 331,
 193         9, 10, 11, 12, 14, 15, 16, 17, 18, 19,
 194         20, 21, 22, 33, 0, 23, 24, 27, 25, 26,
 195         28, 29, 13, 30, 57, 56, 202, 201, 203, 248,
 196         31, 32, 176, 175, 174, 172, 173, 167, 168, 169,
 197         170, 171, 88, 87, 0, 4, 0, 5, 101, 102,
 198         6, 57, 56, 54, 90, 92, 0, 92, 0, 93,
 199         91, 93, 91, 88, 87, 0, 0, 79, 80, 101,
 200         102, 202, 201, 203, 53, 0, 55, 169, 170, 171,
 201         54, 90, 0, 74, 92, 85, 58, 0, 93, 91,
 202         88, 87, 0, 0, 79, 80, 128, 330, 129, 130,
 203         0, 53, 0, 55, 0, 57, 56, 0, 0, 0,
 204         74, 0, 85, 58, 176, 175, 174, 172, 173, 167,
 205         168, 169, 170, 171, 176, 175, 174, 172, 173, 167,
 206         168, 169, 170, 171, 54, 0, 57, 56, 0, 0,
 207         57, 56, 0, 0, 57, 56, 202, 201, 203, 92,
 208         0, 0, 0, 93, 91, 53, 0, 55, 57, 56,
 209         0, 0, 57, 56, 74, 54, 0, 58, 0, 54,
 210         0, 57, 56, 54, 0, 57, 56, 0, 0, 279,
 211         0, 0, 0, 0, 228, 0, 0, 54, 55, 208,
 212         0, 54, 55, 0, 185, 59, 55, 0, 58, 59,
 213         54, 106, 58, 74, 54, 0, 58, 0, 115, 0,
 214         55, 0, 53, 0, 55, 0, 0, 59, 0, 0,
 215         58, 59, 0, 55, 58, 0, 0, 55, 0, 0,
 216         59, 0, 0, 58, 74, 0, 0, 58, 176, 175,
 217         174, 172, 173, 167, 168, 169, 170, 171, 176, 175,
 218         174, 172, 173, 167, 168, 169, 170, 171, 176, 175,
 219         174, 172, 173, 167, 168, 169, 170, 171, 90, 0,
 220         0, 92, 0, 0, 0, 93, 91, 39, 167, 168,
 221         169, 170, 171, 101, 102, 0, 0, 0, 40, 41,
 222         42, 0, 0, 46, 47, 48, 49, 50, 0, 298,
 223         61, 0, 63, 64, 65, 66, 67, 68, 177, 175,
 224         174, 172, 173, 167, 168, 169, 170, 171, 166, 176,
 225         175, 174, 172, 173, 167, 168, 169, 170, 171, 174,
 226         172, 173, 167, 168, 169, 170, 171, 172, 173, 167,
 227         168, 169, 170, 171,
 228 }
 229 var yyPact = []int{
 230
 231         -1000, -1000, 336, -1000, 150, 151, -1000, 144, 143, -1000,
 232         -1000, -1000, -1000, 79, 79, -1000, -1000, -1000, -1000, -1000,
 233         503, 503, -1000, 79, -1000, -1000, -1000, -1000, -1000, -1000,
 234         446, 392, 392, 79, -1000, 512, 512, -1000, -1000, 34,
 235         34, 365, 53, 10, 79, 499, 53, 34, 274, 276,
 236         53, 137, 33, 439, -1000, -1000, 512, 512, 512, 512,
 237         238, 579, -55, 344, -27, 344, 211, 579, 579, -1000,
 238         31, -1000, 15, -1000, 100, 136, -1000, -1000, 30, -1000,
 239         -1000, 15, -1000, -1000, 278, 235, -1000, -1000, 27, -1000,
 240         -1000, -1000, -1000, 19, 135, -1000, 336, 604, -1000, 594,
 241         133, -1000, -1000, -1000, -1000, -1000, 512, 128, 120, 485,
 242         -1000, 228, -1000, -1000, 17, 295, 392, 119, 113, 228,
 243         16, 112, 10, -1000, -1000, 481, 382, 9, 279, 512,
 244         512, -1000, -1000, -1000, 470, 512, 79, -1000, 109, 107,
 245         -1000, -1000, 224, 105, 99, 98, 97, 363, 457, -20,
 246         392, 228, 288, 268, 263, 256, 15, -1000, -52, -1000,
 247         -1000, 477, 512, 512, 392, -1000, -1000, 512, 512, 512,
 248         512, 512, 283, 251, 512, 512, 512, -1000, 228, -1000,
 249         228, 392, -1000, -1000, 11, 439, -1000, -1000, 191, -1000,
 250         -1000, 228, 49, 36, 95, 363, 10, 92, -1000, 91,
 251         -22, -1000, -1000, -1000, 382, 295, -1000, -1000, -1000, 89,
 252         -1000, 207, 249, 165, 207, 512, 228, 228, -24, -25,
 253         -1000, -1000, -35, 100, 100, 100, 100, 446, -1000, -38,
 254         460, -1000, 416, 416, -1000, -1000, -1000, 512, 512, 680,
 255         673, 654, 88, -1000, -1000, -1000, 337, 9, -39, 79,
 256         228, 85, 228, 228, 84, 228, -53, -1000, -40, -2,
 257         -55, -1000, -1000, 80, 79, 584, 78, 76, -1000, -1000,
 258         -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
 259         619, 619, 228, -1000, -1000, 35, 516, -1000, -1000, 134,
 260         -1000, -1000, 242, -1000, 203, -1000, 207, -1000, 228, -14,
 261         228, -1000, -1000, -1000, -1000, 512, -46, -1000, 72, -1000,
 262         228, 63, -1000, -1000, 197, 61, 228, 57, -1000, -16,
 263         228, -1000, 197, 512, -49, 54, 378, -1000, -1000, 512,
 264         -1000, 665,
 265 }
 266 var yyPgo = []int{
 267
 268         0, 4, 19, 339, 6, 11, 10, 0, 1, 12,
 269         627, 9, 58, 14, 24, 336, 3, 261, 204, 333,
 270         5, 7, 38, 8, 13, 327, 2, 278, 320, 316,
 271         16, 313, 308, 82,
 272 }
 273 var yyR1 = []int{
 274
 275         0, 28, 29, 28, 31, 30, 30, 30, 30, 30,
 276         30, 32, 32, 32, 32, 32, 32, 32, 32, 32,
 277         32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
 278         32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
 279         32, 32, 32, 32, 32, 10, 10, 10, 33, 33,
 280         13, 13, 21, 21, 21, 21, 21, 18, 18, 11,
 281         11, 11, 12, 12, 12, 12, 12, 12, 12, 12,
 282         12, 25, 25, 24, 26, 26, 23, 23, 23, 27,
 283         27, 27, 20, 14, 15, 17, 17, 17, 17, 9,
 284         9, 6, 6, 6, 7, 7, 8, 8, 19, 19,
 285         16, 16, 22, 22, 22, 5, 5, 5, 4, 4,
 286         4, 1, 1, 1, 1, 1, 1, 3, 3, 2,
 287         2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 288 }
 289 var yyR2 = []int{
 290
 291         0, 0, 0, 3, 0, 4, 4, 4, 1, 2,
 292         2, 7, 6, 5, 5, 5, 4, 4, 3, 3,
 293         4, 6, 7, 7, 7, 6, 6, 3, 4, 6,
 294         8, 6, 4, 3, 5, 5, 7, 6, 12, 7,
 295         9, 2, 4, 4, 2, 0, 2, 2, 0, 2,
 296         4, 2, 2, 2, 4, 2, 1, 2, 3, 1,
 297         3, 3, 1, 1, 1, 4, 1, 1, 1, 1,
 298         1, 1, 1, 3, 1, 4, 1, 4, 1, 1,
 299         1, 1, 2, 1, 5, 4, 4, 4, 4, 1,
 300         1, 1, 1, 4, 1, 1, 1, 4, 1, 1,
 301         1, 4, 4, 5, 7, 0, 2, 2, 1, 1,
 302         1, 1, 1, 2, 2, 2, 3, 0, 2, 1,
 303         3, 3, 3, 3, 3, 4, 4, 3, 3, 3,
 304 }
 305 var yyChk = []int{
 306
 307         -1000, -28, -29, -30, 59, 61, 64, -32, 2, 14,
 308         15, 16, 17, 36, 18, 19, 20, 21, 22, 23,
 309         24, 25, 26, 29, 30, 32, 33, 31, 34, 35,
 310         37, 44, 45, 27, 62, 63, 63, 64, 64, -10,
 311         -10, -10, -10, -33, 65, -33, -10, -10, -10, -10,
 312         -10, -22, -1, 59, 38, 61, 10, 9, 71, 68,
 313         -22, -10, -33, -10, -10, -10, -10, -10, -10, -23,
 314         -22, -26, -1, -24, 68, -12, -14, -21, -17, 52,
 315         53, -1, -23, -16, -7, 70, -18, 49, 48, -6,
 316         39, 47, 42, 46, -12, -33, -31, -2, -1, -2,
 317         -27, 54, 55, -14, -20, -17, 70, -27, -12, -33,
 318         -24, 68, -33, -13, -1, 59, -33, -27, -26, 66,
 319         -1, -14, -33, -7, -33, 65, 68, -5, 7, 9,
 320         10, -1, -1, -1, -2, 12, -14, -21, -16, -19,
 321         -16, -18, 70, -16, -1, -14, -14, 68, 68, -7,
 322         65, 68, 7, 8, 10, 56, -1, -23, 11, 58,
 323         57, 10, 68, 68, 65, -30, 64, 9, 10, 11,
 324         12, 13, 7, 8, 6, 5, 4, 64, 65, -1,
 325         65, 65, -13, -25, -1, 59, -24, -22, 68, -5,
 326         -12, 65, 65, -11, -7, 68, 65, -24, -20, -1,
 327         -4, 40, 39, 41, 68, 8, -1, -1, 69, -1,
 328         -33, 65, 65, 10, 65, 65, 65, 65, -6, -6,
 329         69, -12, -7, 7, 8, 8, 8, 70, 57, -1,
 330         -2, -12, -2, -2, -2, -2, -2, 7, 8, -2,
 331         -2, -2, -7, -14, -14, -12, 68, -5, 42, -7,
 332         66, 67, 10, -33, -24, 65, 65, 69, -4, -5,
 333         65, -16, -16, 49, -16, -2, -14, -14, 69, 69,
 334         69, -9, -7, -1, -9, -9, -9, -23, 69, 69,
 335         -2, -2, 65, 69, -33, -11, 65, -7, -11, 65,
 336         -33, -14, -20, 69, 68, -21, 65, -33, 65, 65,
 337         65, -14, 67, -26, -14, 10, 40, -16, -7, -15,
 338         68, -14, -1, 69, 65, -7, 65, -8, 51, 50,
 339         65, -7, 65, 68, -7, -8, -2, 69, -3, 65,
 340         69, -2,
 341 }
 342 var yyDef = []int{
 343
 344         1, -2, 0, 3, 0, 0, 8, 0, 0, 45,
 345         45, 45, 45, 48, 48, 45, 45, 45, 45, 45,
 346         0, 0, 45, 48, 45, 45, 45, 45, 45, 45,
 347         0, 0, 0, 48, 4, 0, 0, 9, 10, 0,
 348         0, 0, 48, 0, 48, 0, 48, 0, 0, 48,
 349         48, 0, 0, 105, 111, 112, 0, 0, 0, 0,
 350         0, 0, 0, 0, 0, 0, 0, 0, 0, 41,
 351         76, 78, 0, 74, 0, 0, 62, 63, 64, 66,
 352         67, 68, 69, 70, 83, 0, 56, 100, 0, 94,
 353         95, 91, 92, 0, 0, 44, 0, 0, 119, 0,
 354         0, 46, 47, 79, 80, 81, 0, 0, 0, 0,
 355         18, 0, 49, 19, 0, 105, 0, 0, 0, 0,
 356         0, 0, 0, 83, 27, 0, 0, 0, 0, 0,
 357         0, 113, 114, 115, 0, 0, 48, 33, 0, 0,
 358         98, 99, 0, 0, 0, 0, 0, 0, 0, 0,
 359         0, 0, 0, 0, 0, 0, 52, 53, 0, 55,
 360         57, 0, 0, 0, 0, 5, 6, 0, 0, 0,
 361         0, 0, 0, 0, 0, 0, 0, 7, 0, 82,
 362         0, 0, 16, 17, 0, 105, 71, 72, 0, 51,
 363         20, 0, 0, 0, -2, 0, 0, 0, 28, 0,
 364         0, 108, 109, 110, 0, 105, 106, 107, 116, 0,
 365         32, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 366         73, 42, 0, 0, 0, 0, 0, 0, 58, 0,
 367         0, 43, 120, 121, 122, 123, 124, 0, 0, 127,
 368         128, 129, 83, 13, 14, 15, 0, 51, 0, 48,
 369         0, 0, 0, 0, 48, 0, 0, 102, 0, 0,
 370         0, 34, 35, 100, 48, 0, 0, 0, 77, 75,
 371         65, 85, 89, 90, 86, 87, 88, 54, 101, 93,
 372         125, 126, 12, 50, 21, 0, 0, 60, 61, 48,
 373         25, 26, 29, 103, 0, 31, 0, 37, 0, 0,
 374         0, 11, 22, 23, 24, 0, 0, 36, 0, 39,
 375         0, 0, 30, 104, 0, 0, 0, 0, 96, 0,
 376         0, 40, 0, 0, 0, 117, 0, 84, 38, 0,
 377         97, 118,
 378 }
 379 var yyTok1 = []int{
 380
 381         1, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 382         3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 383         3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 384         3, 3, 3, 3, 3, 3, 70, 13, 6, 3,
 385         68, 69, 11, 9, 65, 10, 3, 12, 3, 3,
 386         3, 3, 3, 3, 3, 3, 3, 3, 62, 64,
 387         7, 63, 8, 3, 3, 3, 3, 3, 3, 3,
 388         3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 389         3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 390         3, 66, 3, 67, 5, 3, 3, 3, 3, 3,
 391         3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 392         3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 393         3, 3, 3, 3, 4, 3, 71,
 394 }
 395 var yyTok2 = []int{
 396
 397         2, 3, 14, 15, 16, 17, 18, 19, 20, 21,
 398         22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
 399         32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
 400         42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
 401         52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
 402 }
 403 var yyTok3 = []int{
 404         0,
 405 }
 406
 407 //line yaccpar:1
 408
 409 /*      parser for yacc output  */
 410
 411 var yyDebug = 0
 412
 413 type yyLexer interface {
 414         Lex(lval *yySymType) int
 415         Error(s string)
 416 }
 417
 418 const yyFlag = -1000
 419
 420 func yyTokname(c int) string {
 421         // 4 is TOKSTART above
 422         if c >= 4 && c-4 < len(yyToknames) {
 423                 if yyToknames[c-4] != "" {
 424                         return yyToknames[c-4]
 425                 }
 426         }
 427         return __yyfmt__.Sprintf("tok-%v", c)
 428 }
 429
 430 func yyStatname(s int) string {
 431         if s >= 0 && s < len(yyStatenames) {
 432                 if yyStatenames[s] != "" {
 433                         return yyStatenames[s]
 434                 }
 435         }
 436         return __yyfmt__.Sprintf("state-%v", s)
 437 }
 438
 439 func yylex1(lex yyLexer, lval *yySymType) int {
 440         c := 0
 441         char := lex.Lex(lval)
 442         if char <= 0 {
 443                 c = yyTok1[0]
 444                 goto out
 445         }
 446         if char < len(yyTok1) {
 447                 c = yyTok1[char]
 448                 goto out
 449         }
 450         if char >= yyPrivate {
 451                 if char < yyPrivate+len(yyTok2) {
 452                         c = yyTok2[char-yyPrivate]
 453                         goto out
 454                 }
 455         }
 456         for i := 0; i < len(yyTok3); i += 2 {
 457                 c = yyTok3[i+0]
 458                 if c == char {
 459                         c = yyTok3[i+1]
 460                         goto out
 461                 }
 462         }
 463
 464 out:
 465         if c == 0 {
 466                 c = yyTok2[1] /* unknown char */
 467         }
 468         if yyDebug >= 3 {
 469                 __yyfmt__.Printf("lex %s(%d)\n", yyTokname(c), uint(char))
 470         }
 471         return c
 472 }
 473
 474 func yyParse(yylex yyLexer) int {
 475         var yyn int
 476         var yylval yySymType
 477         var yyVAL yySymType
 478         yyS := make([]yySymType, yyMaxDepth)
 479
 480         Nerrs := 0   /* number of errors */
 481         Errflag := 0 /* error recovery flag */
 482         yystate := 0
 483         yychar := -1
 484         yyp := -1
 485         goto yystack
 486
 487 ret0:
 488         return 0
 489
 490 ret1:
 491         return 1
 492
 493 yystack:
 494         /* put a state and value onto the stack */
 495         if yyDebug >= 4 {
 496                 __yyfmt__.Printf("char %v in %v\n", yyTokname(yychar), yyStatname(yystate))
 497         }
 498
 499         yyp++
 500         if yyp >= len(yyS) {
 501                 nyys := make([]yySymType, len(yyS)*2)
 502                 copy(nyys, yyS)
 503                 yyS = nyys
 504         }
 505         yyS[yyp] = yyVAL
 506         yyS[yyp].yys = yystate
 507
 508 yynewstate:
 509         yyn = yyPact[yystate]
 510         if yyn <= yyFlag {
 511                 goto yydefault /* simple state */
 512         }
 513         if yychar < 0 {
 514                 yychar = yylex1(yylex, &yylval)
 515         }
 516         yyn += yychar
 517         if yyn < 0 || yyn >= yyLast {
 518                 goto yydefault
 519         }
 520         yyn = yyAct[yyn]
 521         if yyChk[yyn] == yychar { /* valid shift */
 522                 yychar = -1
 523                 yyVAL = yylval
 524                 yystate = yyn
 525                 if Errflag > 0 {
 526                         Errflag--
 527                 }
 528                 goto yystack
 529         }
 530
 531 yydefault:
 532         /* default state action */
 533         yyn = yyDef[yystate]
 534         if yyn == -2 {
 535                 if yychar < 0 {
 536                         yychar = yylex1(yylex, &yylval)
 537                 }
 538
 539                 /* look through exception table */
 540                 xi := 0
 541                 for {
 542                         if yyExca[xi+0] == -1 && yyExca[xi+1] == yystate {
 543                                 break
 544                         }
 545                         xi += 2
 546                 }
 547                 for xi += 2; ; xi += 2 {
 548                         yyn = yyExca[xi+0]
 549                         if yyn < 0 || yyn == yychar {
 550                                 break
 551                         }
 552                 }
 553                 yyn = yyExca[xi+1]
 554                 if yyn < 0 {
 555                         goto ret0
 556                 }
 557         }
 558         if yyn == 0 {
 559                 /* error ... attempt to resume parsing */
 560                 switch Errflag {
 561                 case 0: /* brand new error */
 562                         yylex.Error("syntax error")
 563                         Nerrs++
 564                         if yyDebug >= 1 {
 565                                 __yyfmt__.Printf("%s", yyStatname(yystate))
 566                                 __yyfmt__.Printf(" saw %s\n", yyTokname(yychar))
 567                         }
 568                         fallthrough
 569
 570                 case 1, 2: /* incompletely recovered error ... try again */
 571                         Errflag = 3
 572
 573                         /* find a state where "error" is a legal shift action */
 574                         for yyp >= 0 {
 575                                 yyn = yyPact[yyS[yyp].yys] + yyErrCode
 576                                 if yyn >= 0 && yyn < yyLast {
 577                                         yystate = yyAct[yyn] /* simulate a shift of "error" */
 578                                         if yyChk[yystate] == yyErrCode {
 579                                                 goto yystack
 580                                         }
 581                                 }
 582
 583                                 /* the current p has no shift on "error", pop stack */
 584                                 if yyDebug >= 2 {
 585                                         __yyfmt__.Printf("error recovery pops state %d\n", yyS[yyp].yys)
 586                                 }
 587                                 yyp--
 588                         }
 589                         /* there is no state on the stack with an error shift ... abort */
 590                         goto ret1
 591
 592                 case 3: /* no shift yet; clobber input char */
 593                         if yyDebug >= 2 {
 594                                 __yyfmt__.Printf("error recovery discards %s\n", yyTokname(yychar))
 595                         }
 596                         if yychar == yyEofCode {
 597                                 goto ret1
 598                         }
 599                         yychar = -1
 600                         goto yynewstate /* try again in the same state */
 601                 }
 602         }
 603
 604         /* reduction by production yyn */
 605         if yyDebug >= 2 {
 606                 __yyfmt__.Printf("reduce %v in:\n\t%v\n", yyn, yyStatname(yystate))
 607         }
 608
 609         yynt := yyn
 610         yypt := yyp
 611         _ = yypt // guard against "declared and not used"
 612
 613         yyp -= yyR2[yyn]
 614         // yyp is now the index of $0. Perform the default action. Iff the
 615         // reduced production is ε, $1 is possibly out of range.
 616         if yyp+1 >= len(yyS) {
 617                 nyys := make([]yySymType, len(yyS)*2)
 618                 copy(nyys, yyS)
 619                 yyS = nyys
 620         }
 621         yyVAL = yyS[yyp+1]
 622
 623         /* consult goto table to find next state */
 624         yyn = yyR1[yyn]
 625         yyg := yyPgo[yyn]
 626         yyj := yyg + yyS[yyp].yys + 1
 627
 628         if yyj >= yyLast {
 629                 yystate = yyAct[yyg]
 630         } else {
 631                 yystate = yyAct[yyj]
 632                 if yyChk[yystate] != -yyn {
 633                         yystate = yyAct[yyg]
 634                 }
 635         }
 636         // dummy call; replaced with literal code
 637         switch yynt {
 638
 639         case 2:
 640                 //line a.y:73
 641                 {
 642                         stmtline = asm.Lineno
 643                 }
 644         case 4:
 645                 //line a.y:80
 646                 {
 647                         yyS[yypt-1].sym = asm.LabelLookup(yyS[yypt-1].sym)
 648                         if yyS[yypt-1].sym.Type == LLAB && yyS[yypt-1].sym.Value != int64(asm.PC) {
 649                                 yyerror("redeclaration of %s", yyS[yypt-1].sym.Labelname)
 650                         }
 651                         yyS[yypt-1].sym.Type = LLAB
 652                         yyS[yypt-1].sym.Value = int64(asm.PC)
 653                 }
 654         case 6:
 655                 //line a.y:90
 656                 {
 657                         yyS[yypt-3].sym.Type = LVAR
 658                         yyS[yypt-3].sym.Value = int64(yyS[yypt-1].lval)
 659                 }
 660         case 7:
 661                 //line a.y:95
 662                 {
 663                         if yyS[yypt-3].sym.Value != int64(yyS[yypt-1].lval) {
 664                                 yyerror("redeclaration of %s", yyS[yypt-3].sym.Name)
 665                         }
 666                         yyS[yypt-3].sym.Value = int64(yyS[yypt-1].lval)
 667                 }
 668         case 11:
 669                 //line a.y:110
 670                 {
 671                         outcode(yyS[yypt-6].lval, yyS[yypt-5].lval, &yyS[yypt-4].addr, yyS[yypt-2].lval, &yyS[yypt-0].addr)
 672                 }
 673         case 12:
 674                 //line a.y:114
 675                 {
 676                         outcode(yyS[yypt-5].lval, yyS[yypt-4].lval, &yyS[yypt-3].addr, yyS[yypt-1].lval, &nullgen)
 677                 }
 678         case 13:
 679                 //line a.y:118
 680                 {
 681                         outcode(yyS[yypt-4].lval, yyS[yypt-3].lval, &yyS[yypt-2].addr, NREG, &yyS[yypt-0].addr)
 682                 }
 683         case 14:
 684                 //line a.y:125
 685                 {
 686                         outcode(yyS[yypt-4].lval, yyS[yypt-3].lval, &yyS[yypt-2].addr, NREG, &yyS[yypt-0].addr)
 687                 }
 688         case 15:
 689                 //line a.y:132
 690                 {
 691                         outcode(yyS[yypt-4].lval, yyS[yypt-3].lval, &yyS[yypt-2].addr, NREG, &yyS[yypt-0].addr)
 692                 }
 693         case 16:
 694                 //line a.y:139
 695                 {
 696                         outcode(yyS[yypt-3].lval, yyS[yypt-2].lval, &nullgen, NREG, &yyS[yypt-0].addr)
 697                 }
 698         case 17:
 699                 //line a.y:143
 700                 {
 701                         outcode(yyS[yypt-3].lval, yyS[yypt-2].lval, &nullgen, NREG, &yyS[yypt-0].addr)
 702                 }
 703         case 18:
 704                 //line a.y:150
 705                 {
 706                         outcode(yyS[yypt-2].lval, Always, &nullgen, NREG, &yyS[yypt-0].addr)
 707                 }
 708         case 19:
 709                 //line a.y:157
 710                 {
 711                         outcode(yyS[yypt-2].lval, Always, &nullgen, NREG, &yyS[yypt-0].addr)
 712                 }
 713         case 20:
 714                 //line a.y:164
 715                 {
 716                         outcode(yyS[yypt-3].lval, yyS[yypt-2].lval, &nullgen, NREG, &yyS[yypt-0].addr)
 717                 }
 718         case 21:
 719                 //line a.y:171
 720                 {
 721                         outcode(yyS[yypt-5].lval, yyS[yypt-4].lval, &yyS[yypt-3].addr, yyS[yypt-1].lval, &nullgen)
 722                 }
 723         case 22:
 724                 //line a.y:178
 725                 {
 726                         var g obj.Addr
 727
 728                         g = nullgen
 729                         g.Type_ = D_CONST
 730                         g.Offset = int64(yyS[yypt-1].lval)
 731                         outcode(yyS[yypt-6].lval, yyS[yypt-5].lval, &yyS[yypt-4].addr, NREG, &g)
 732                 }
 733         case 23:
 734                 //line a.y:187
 735                 {
 736                         var g obj.Addr
 737
 738                         g = nullgen
 739                         g.Type_ = D_CONST
 740                         g.Offset = int64(yyS[yypt-3].lval)
 741                         outcode(yyS[yypt-6].lval, yyS[yypt-5].lval, &g, NREG, &yyS[yypt-0].addr)
 742                 }
 743         case 24:
 744                 //line a.y:199
 745                 {
 746                         outcode(yyS[yypt-6].lval, yyS[yypt-5].lval, &yyS[yypt-2].addr, int32(yyS[yypt-4].addr.Reg), &yyS[yypt-0].addr)
 747                 }
 748         case 25:
 749                 //line a.y:203
 750                 {
 751                         outcode(yyS[yypt-5].lval, yyS[yypt-4].lval, &yyS[yypt-1].addr, int32(yyS[yypt-3].addr.Reg), &yyS[yypt-3].addr)
 752                 }
 753         case 26:
 754                 //line a.y:207
 755                 {
 756                         outcode(yyS[yypt-5].lval, yyS[yypt-4].lval, &yyS[yypt-2].addr, int32(yyS[yypt-0].addr.Reg), &yyS[yypt-0].addr)
 757                 }
 758         case 27:
 759                 //line a.y:214
 760                 {
 761                         outcode(yyS[yypt-2].lval, yyS[yypt-1].lval, &nullgen, NREG, &nullgen)
 762                 }
 763         case 28:
 764                 //line a.y:221
 765                 {
 766                         asm.Settext(yyS[yypt-2].addr.Sym)
 767                         yyS[yypt-0].addr.Type_ = D_CONST2
 768                         yyS[yypt-0].addr.Offset2 = -obj.ArgsSizeUnknown
 769                         outcode(yyS[yypt-3].lval, Always, &yyS[yypt-2].addr, 0, &yyS[yypt-0].addr)
 770                 }
 771         case 29:
 772                 //line a.y:228
 773                 {
 774                         asm.Settext(yyS[yypt-4].addr.Sym)
 775                         yyS[yypt-0].addr.Type_ = D_CONST2
 776                         yyS[yypt-0].addr.Offset2 = -obj.ArgsSizeUnknown
 777                         outcode(yyS[yypt-5].lval, Always, &yyS[yypt-4].addr, yyS[yypt-2].lval, &yyS[yypt-0].addr)
 778                 }
 779         case 30:
 780                 //line a.y:235
 781                 {
 782                         asm.Settext(yyS[yypt-6].addr.Sym)
 783                         yyS[yypt-2].addr.Type_ = D_CONST2
 784                         yyS[yypt-2].addr.Offset2 = yyS[yypt-0].lval
 785                         outcode(yyS[yypt-7].lval, Always, &yyS[yypt-6].addr, yyS[yypt-4].lval, &yyS[yypt-2].addr)
 786                 }
 787         case 31:
 788                 //line a.y:245
 789                 {
 790                         outcode(yyS[yypt-5].lval, Always, &yyS[yypt-4].addr, yyS[yypt-2].lval, &yyS[yypt-0].addr)
 791                 }
 792         case 32:
 793                 //line a.y:252
 794                 {
 795                         outcode(yyS[yypt-3].lval, yyS[yypt-2].lval, &yyS[yypt-1].addr, NREG, &nullgen)
 796                 }
 797         case 33:
 798                 //line a.y:259
 799                 {
 800                         outcode(yyS[yypt-2].lval, Always, &nullgen, NREG, &yyS[yypt-0].addr)
 801                 }
 802         case 34:
 803                 //line a.y:266
 804                 {
 805                         outcode(yyS[yypt-4].lval, yyS[yypt-3].lval, &yyS[yypt-2].addr, NREG, &yyS[yypt-0].addr)
 806                 }
 807         case 35:
 808                 //line a.y:270
 809                 {
 810                         outcode(yyS[yypt-4].lval, yyS[yypt-3].lval, &yyS[yypt-2].addr, NREG, &yyS[yypt-0].addr)
 811                 }
 812         case 36:
 813                 //line a.y:274
 814                 {
 815                         outcode(yyS[yypt-6].lval, yyS[yypt-5].lval, &yyS[yypt-4].addr, yyS[yypt-2].lval, &yyS[yypt-0].addr)
 816                 }
 817         case 37:
 818                 //line a.y:278
 819                 {
 820                         outcode(yyS[yypt-5].lval, yyS[yypt-4].lval, &yyS[yypt-3].addr, int32(yyS[yypt-1].addr.Reg), &nullgen)
 821                 }
 822         case 38:
 823                 //line a.y:285
 824                 {
 825                         var g obj.Addr
 826
 827                         g = nullgen
 828                         g.Type_ = D_CONST
 829                         g.Offset = int64(
 830                                 (0xe << 24) | /* opcode */
 831                                         (yyS[yypt-11].lval << 20) | /* MCR/MRC */
 832                                         (yyS[yypt-10].lval << 28) | /* scond */
 833                                         ((yyS[yypt-9].lval & 15) << 8) | /* coprocessor number */
 834                                         ((yyS[yypt-7].lval & 7) << 21) | /* coprocessor operation */
 835                                         ((yyS[yypt-5].lval & 15) << 12) | /* arm register */
 836                                         ((yyS[yypt-3].lval & 15) << 16) | /* Crn */
 837                                         ((yyS[yypt-1].lval & 15) << 0) | /* Crm */
 838                                         ((yyS[yypt-0].lval & 7) << 5) | /* coprocessor information */
 839                                         (1 << 4)) /* must be set */
 840                         outcode(AMRC, Always, &nullgen, NREG, &g)
 841                 }
 842         case 39:
 843                 //line a.y:297
 844                 {
 845                         outcode(yyS[yypt-6].lval, yyS[yypt-5].lval, &yyS[yypt-4].addr, int32(yyS[yypt-2].addr.Reg), &yyS[yypt-0].addr)
 846                 }
 847         case 40:
 848                 //line a.y:305
 849                 {
 850                         yyS[yypt-2].addr.Type_ = D_REGREG2
 851                         yyS[yypt-2].addr.Offset = int64(yyS[yypt-0].lval)
 852                         outcode(yyS[yypt-8].lval, yyS[yypt-7].lval, &yyS[yypt-6].addr, int32(yyS[yypt-4].addr.Reg), &yyS[yypt-2].addr)
 853                 }
 854         case 41:
 855                 //line a.y:314
 856                 {
 857                         outcode(yyS[yypt-1].lval, Always, &yyS[yypt-0].addr, NREG, &nullgen)
 858                 }
 859         case 42:
 860                 //line a.y:321
 861                 {
 862                         if yyS[yypt-2].addr.Type_ != D_CONST || yyS[yypt-0].addr.Type_ != D_CONST {
 863                                 yyerror("arguments to PCDATA must be integer constants")
 864                         }
 865                         outcode(yyS[yypt-3].lval, Always, &yyS[yypt-2].addr, NREG, &yyS[yypt-0].addr)
 866                 }
 867         case 43:
 868                 //line a.y:331
 869                 {
 870                         if yyS[yypt-2].addr.Type_ != D_CONST {
 871                                 yyerror("index for FUNCDATA must be integer constant")
 872                         }
 873                         if yyS[yypt-0].addr.Type_ != D_EXTERN && yyS[yypt-0].addr.Type_ != D_STATIC && yyS[yypt-0].addr.Type_ != D_OREG {
 874                                 yyerror("value for FUNCDATA must be symbol reference")
 875                         }
 876                         outcode(yyS[yypt-3].lval, Always, &yyS[yypt-2].addr, NREG, &yyS[yypt-0].addr)
 877                 }
 878         case 44:
 879                 //line a.y:344
 880                 {
 881                         outcode(yyS[yypt-1].lval, Always, &nullgen, NREG, &nullgen)
 882                 }
 883         case 45:
 884                 //line a.y:349
 885                 {
 886                         yyVAL.lval = Always
 887                 }
 888         case 46:
 889                 //line a.y:353
 890                 {
 891                         yyVAL.lval = (yyS[yypt-1].lval & ^C_SCOND) | yyS[yypt-0].lval
 892                 }
 893         case 47:
 894                 //line a.y:357
 895                 {
 896                         yyVAL.lval = yyS[yypt-1].lval | yyS[yypt-0].lval
 897                 }
 898         case 50:
 899                 //line a.y:366
 900                 {
 901                         yyVAL.addr = nullgen
 902                         yyVAL.addr.Type_ = D_BRANCH
 903                         yyVAL.addr.Offset = int64(yyS[yypt-3].lval) + int64(asm.PC)
 904                 }
 905         case 51:
 906                 //line a.y:372
 907                 {
 908                         yyS[yypt-1].sym = asm.LabelLookup(yyS[yypt-1].sym)
 909                         yyVAL.addr = nullgen
 910                         if asm.Pass == 2 && yyS[yypt-1].sym.Type != LLAB {
 911                                 yyerror("undefined label: %s", yyS[yypt-1].sym.Labelname)
 912                         }
 913                         yyVAL.addr.Type_ = D_BRANCH
 914                         yyVAL.addr.Offset = yyS[yypt-1].sym.Value + int64(yyS[yypt-0].lval)
 915                 }
 916         case 52:
 917                 //line a.y:383
 918                 {
 919                         yyVAL.addr = nullgen
 920                         yyVAL.addr.Type_ = D_CONST
 921                         yyVAL.addr.Offset = int64(yyS[yypt-0].lval)
 922                 }
 923         case 53:
 924                 //line a.y:389
 925                 {
 926                         yyVAL.addr = yyS[yypt-0].addr
 927                         yyVAL.addr.Type_ = D_CONST
 928                 }
 929         case 54:
 930                 //line a.y:394
 931                 {
 932                         yyVAL.addr = yyS[yypt-0].addr
 933                         yyVAL.addr.Type_ = D_OCONST
 934                 }
 935         case 55:
 936                 //line a.y:399
 937                 {
 938                         yyVAL.addr = nullgen
 939                         yyVAL.addr.Type_ = D_SCONST
 940                         yyVAL.addr.U.Sval = yyS[yypt-0].sval
 941                 }
 942         case 56:
 943                 yyVAL.addr = yyS[yypt-0].addr
 944         case 57:
 945                 //line a.y:408
 946                 {
 947                         yyVAL.addr = nullgen
 948                         yyVAL.addr.Type_ = D_FCONST
 949                         yyVAL.addr.U.Dval = yyS[yypt-0].dval
 950                 }
 951         case 58:
 952                 //line a.y:414
 953                 {
 954                         yyVAL.addr = nullgen
 955                         yyVAL.addr.Type_ = D_FCONST
 956                         yyVAL.addr.U.Dval = -yyS[yypt-0].dval
 957                 }
 958         case 59:
 959                 //line a.y:422
 960                 {
 961                         yyVAL.lval = 1 << uint(yyS[yypt-0].lval)
 962                 }
 963         case 60:
 964                 //line a.y:426
 965                 {
 966                         yyVAL.lval = 0
 967                         for i := yyS[yypt-2].lval; i <= yyS[yypt-0].lval; i++ {
 968                                 yyVAL.lval |= 1 << uint(i)
 969                         }
 970                         for i := yyS[yypt-0].lval; i <= yyS[yypt-2].lval; i++ {
 971                                 yyVAL.lval |= 1 << uint(i)
 972                         }
 973                 }
 974         case 61:
 975                 //line a.y:436
 976                 {
 977                         yyVAL.lval = (1 << uint(yyS[yypt-2].lval)) | yyS[yypt-0].lval
 978                 }
 979         case 62:
 980                 yyVAL.addr = yyS[yypt-0].addr
 981         case 63:
 982                 yyVAL.addr = yyS[yypt-0].addr
 983         case 64:
 984                 yyVAL.addr = yyS[yypt-0].addr
 985         case 65:
 986                 //line a.y:445
 987                 {
 988                         yyVAL.addr = yyS[yypt-3].addr
 989                         yyVAL.addr.Reg = int8(yyS[yypt-1].lval)
 990                 }
 991         case 66:
 992                 //line a.y:450
 993                 {
 994                         yyVAL.addr = nullgen
 995                         yyVAL.addr.Type_ = D_PSR
 996                         yyVAL.addr.Reg = int8(yyS[yypt-0].lval)
 997                 }
 998         case 67:
 999                 //line a.y:456
1000                 {
1001                         yyVAL.addr = nullgen
1002                         yyVAL.addr.Type_ = D_FPCR
1003                         yyVAL.addr.Reg = int8(yyS[yypt-0].lval)
1004                 }
1005         case 68:
1006                 //line a.y:462
1007                 {
1008                         yyVAL.addr = nullgen
1009                         yyVAL.addr.Type_ = D_OREG
1010                         yyVAL.addr.Offset = int64(yyS[yypt-0].lval)
1011                 }
1012         case 69:
1013                 yyVAL.addr = yyS[yypt-0].addr
1014         case 70:
1015                 yyVAL.addr = yyS[yypt-0].addr
1016         case 71:
1017                 yyVAL.addr = yyS[yypt-0].addr
1018         case 72:
1019                 //line a.y:473
1020                 {
1021                         yyVAL.addr = yyS[yypt-0].addr
1022                         if yyS[yypt-0].addr.Name != D_EXTERN && yyS[yypt-0].addr.Name != D_STATIC {
1023                         }
1024                 }
1025         case 73:
1026                 //line a.y:481
1027                 {
1028                         yyVAL.addr = nullgen
1029                         yyVAL.addr.Type_ = D_OREG
1030                         yyVAL.addr.Reg = int8(yyS[yypt-1].lval)
1031                         yyVAL.addr.Offset = 0
1032                 }
1033         case 74:
1034                 yyVAL.addr = yyS[yypt-0].addr
1035         case 75:
1036                 //line a.y:491
1037                 {
1038                         yyVAL.addr = nullgen
1039                         yyVAL.addr.Type_ = D_OREG
1040                         yyVAL.addr.Reg = int8(yyS[yypt-1].lval)
1041                         yyVAL.addr.Offset = int64(yyS[yypt-3].lval)
1042                 }
1043         case 76:
1044                 yyVAL.addr = yyS[yypt-0].addr
1045         case 77:
1046                 //line a.y:501
1047                 {
1048                         yyVAL.addr = yyS[yypt-3].addr
1049                         yyVAL.addr.Type_ = D_OREG
1050                         yyVAL.addr.Reg = int8(yyS[yypt-1].lval)
1051                 }
1052         case 78:
1053                 yyVAL.addr = yyS[yypt-0].addr
1054         case 79:
1055                 yyVAL.addr = yyS[yypt-0].addr
1056         case 80:
1057                 yyVAL.addr = yyS[yypt-0].addr
1058         case 81:
1059                 yyVAL.addr = yyS[yypt-0].addr
1060         case 82:
1061                 //line a.y:514
1062                 {
1063                         yyVAL.addr = nullgen
1064                         yyVAL.addr.Type_ = D_CONST
1065                         yyVAL.addr.Offset = int64(yyS[yypt-0].lval)
1066                 }
1067         case 83:
1068                 //line a.y:522
1069                 {
1070                         yyVAL.addr = nullgen
1071                         yyVAL.addr.Type_ = D_REG
1072                         yyVAL.addr.Reg = int8(yyS[yypt-0].lval)
1073                 }
1074         case 84:
1075                 //line a.y:530
1076                 {
1077                         yyVAL.addr = nullgen
1078                         yyVAL.addr.Type_ = D_REGREG
1079                         yyVAL.addr.Reg = int8(yyS[yypt-3].lval)
1080                         yyVAL.addr.Offset = int64(yyS[yypt-1].lval)
1081                 }
1082         case 85:
1083                 //line a.y:539
1084                 {
1085                         yyVAL.addr = nullgen
1086                         yyVAL.addr.Type_ = D_SHIFT
1087                         yyVAL.addr.Offset = int64(yyS[yypt-3].lval) | int64(yyS[yypt-0].lval) | (0 << 5)
1088                 }
1089         case 86:
1090                 //line a.y:545
1091                 {
1092                         yyVAL.addr = nullgen
1093                         yyVAL.addr.Type_ = D_SHIFT
1094                         yyVAL.addr.Offset = int64(yyS[yypt-3].lval) | int64(yyS[yypt-0].lval) | (1 << 5)
1095                 }
1096         case 87:
1097                 //line a.y:551
1098                 {
1099                         yyVAL.addr = nullgen
1100                         yyVAL.addr.Type_ = D_SHIFT
1101                         yyVAL.addr.Offset = int64(yyS[yypt-3].lval) | int64(yyS[yypt-0].lval) | (2 << 5)
1102                 }
1103         case 88:
1104                 //line a.y:557
1105                 {
1106                         yyVAL.addr = nullgen
1107                         yyVAL.addr.Type_ = D_SHIFT
1108                         yyVAL.addr.Offset = int64(yyS[yypt-3].lval) | int64(yyS[yypt-0].lval) | (3 << 5)
1109                 }
1110         case 89:
1111                 //line a.y:565
1112                 {
1113                         if yyVAL.lval < 0 || yyVAL.lval >= 16 {
1114                                 print("register value out of range\n")
1115                         }
1116                         yyVAL.lval = ((yyS[yypt-0].lval & 15) << 8) | (1 << 4)
1117                 }
1118         case 90:
1119                 //line a.y:572
1120                 {
1121                         if yyVAL.lval < 0 || yyVAL.lval >= 32 {
1122                                 print("shift value out of range\n")
1123                         }
1124                         yyVAL.lval = (yyS[yypt-0].lval & 31) << 7
1125                 }
1126         case 91:
1127                 yyVAL.lval = yyS[yypt-0].lval
1128         case 92:
1129                 //line a.y:582
1130                 {
1131                         yyVAL.lval = REGPC
1132                 }
1133         case 93:
1134                 //line a.y:586
1135                 {
1136                         if yyS[yypt-1].lval < 0 || yyS[yypt-1].lval >= NREG {
1137                                 print("register value out of range\n")
1138                         }
1139                         yyVAL.lval = yyS[yypt-1].lval
1140                 }
1141         case 94:
1142                 yyVAL.lval = yyS[yypt-0].lval
1143         case 95:
1144                 //line a.y:596
1145                 {
1146                         yyVAL.lval = REGSP
1147                 }
1148         case 96:
1149                 yyVAL.lval = yyS[yypt-0].lval
1150         case 97:
1151                 //line a.y:603
1152                 {
1153                         if yyS[yypt-1].lval < 0 || yyS[yypt-1].lval >= NREG {
1154                                 print("register value out of range\n")
1155                         }
1156                         yyVAL.lval = yyS[yypt-1].lval
1157                 }
1158         case 98:
1159                 yyVAL.addr = yyS[yypt-0].addr
1160         case 99:
1161                 yyVAL.addr = yyS[yypt-0].addr
1162         case 100:
1163                 //line a.y:616
1164                 {
1165                         yyVAL.addr = nullgen
1166                         yyVAL.addr.Type_ = D_FREG
1167                         yyVAL.addr.Reg = int8(yyS[yypt-0].lval)
1168                 }
1169         case 101:
1170                 //line a.y:622
1171                 {
1172                         yyVAL.addr = nullgen
1173                         yyVAL.addr.Type_ = D_FREG
1174                         yyVAL.addr.Reg = int8(yyS[yypt-1].lval)
1175                 }
1176         case 102:
1177                 //line a.y:630
1178                 {
1179                         yyVAL.addr = nullgen
1180                         yyVAL.addr.Type_ = D_OREG
1181                         yyVAL.addr.Name = int8(yyS[yypt-1].lval)
1182                         yyVAL.addr.Sym = nil
1183                         yyVAL.addr.Offset = int64(yyS[yypt-3].lval)
1184                 }
1185         case 103:
1186                 //line a.y:638
1187                 {
1188                         yyVAL.addr = nullgen
1189                         yyVAL.addr.Type_ = D_OREG
1190                         yyVAL.addr.Name = int8(yyS[yypt-1].lval)
1191                         yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyS[yypt-4].sym.Name, 0)
1192                         yyVAL.addr.Offset = int64(yyS[yypt-3].lval)
1193                 }
1194         case 104:
1195                 //line a.y:646
1196                 {
1197                         yyVAL.addr = nullgen
1198                         yyVAL.addr.Type_ = D_OREG
1199                         yyVAL.addr.Name = D_STATIC
1200                         yyVAL.addr.Sym = obj.Linklookup(asm.Ctxt, yyS[yypt-6].sym.Name, 1)
1201                         yyVAL.addr.Offset = int64(yyS[yypt-3].lval)
1202                 }
1203         case 105:
1204                 //line a.y:655
1205                 {
1206                         yyVAL.lval = 0
1207                 }
1208         case 106:
1209                 //line a.y:659
1210                 {
1211                         yyVAL.lval = yyS[yypt-0].lval
1212                 }
1213         case 107:
1214                 //line a.y:663
1215                 {
1216                         yyVAL.lval = -yyS[yypt-0].lval
1217                 }
1218         case 108:
1219                 yyVAL.lval = yyS[yypt-0].lval
1220         case 109:
1221                 yyVAL.lval = yyS[yypt-0].lval
1222         case 110:
1223                 yyVAL.lval = yyS[yypt-0].lval
1224         case 111:
1225                 yyVAL.lval = yyS[yypt-0].lval
1226         case 112:
1227                 //line a.y:675
1228                 {
1229                         yyVAL.lval = int32(yyS[yypt-0].sym.Value)
1230                 }
1231         case 113:
1232                 //line a.y:679
1233                 {
1234                         yyVAL.lval = -yyS[yypt-0].lval
1235                 }
1236         case 114:
1237                 //line a.y:683
1238                 {
1239                         yyVAL.lval = yyS[yypt-0].lval
1240                 }
1241         case 115:
1242                 //line a.y:687
1243                 {
1244                         yyVAL.lval = ^yyS[yypt-0].lval
1245                 }
1246         case 116:
1247                 //line a.y:691
1248                 {
1249                         yyVAL.lval = yyS[yypt-1].lval
1250                 }
1251         case 117:
1252                 //line a.y:696
1253                 {
1254                         yyVAL.lval = 0
1255                 }
1256         case 118:
1257                 //line a.y:700
1258                 {
1259                         yyVAL.lval = yyS[yypt-0].lval
1260                 }
1261         case 119:
1262                 yyVAL.lval = yyS[yypt-0].lval
1263         case 120:
1264                 //line a.y:707
1265                 {
1266                         yyVAL.lval = yyS[yypt-2].lval + yyS[yypt-0].lval
1267                 }
1268         case 121:
1269                 //line a.y:711
1270                 {
1271                         yyVAL.lval = yyS[yypt-2].lval - yyS[yypt-0].lval
1272                 }
1273         case 122:
1274                 //line a.y:715
1275                 {
1276                         yyVAL.lval = yyS[yypt-2].lval * yyS[yypt-0].lval
1277                 }
1278         case 123:
1279                 //line a.y:719
1280                 {
1281                         yyVAL.lval = yyS[yypt-2].lval / yyS[yypt-0].lval
1282                 }
1283         case 124:
1284                 //line a.y:723
1285                 {
1286                         yyVAL.lval = yyS[yypt-2].lval % yyS[yypt-0].lval
1287                 }
1288         case 125:
1289                 //line a.y:727
1290                 {
1291                         yyVAL.lval = yyS[yypt-3].lval << uint(yyS[yypt-0].lval)
1292                 }
1293         case 126:
1294                 //line a.y:731
1295                 {
1296                         yyVAL.lval = yyS[yypt-3].lval >> uint(yyS[yypt-0].lval)
1297                 }
1298         case 127:
1299                 //line a.y:735
1300                 {
1301                         yyVAL.lval = yyS[yypt-2].lval & yyS[yypt-0].lval
1302                 }
1303         case 128:
1304                 //line a.y:739
1305                 {
1306                         yyVAL.lval = yyS[yypt-2].lval ^ yyS[yypt-0].lval
1307                 }
1308         case 129:
1309                 //line a.y:743
1310                 {
1311                         yyVAL.lval = yyS[yypt-2].lval | yyS[yypt-0].lval
1312                 }
1313         }
1314         goto yystack /* stack new state and value */
1315 }