contrib/bc/tests/bc/errors.txt

   1 4 != 0 &^ 34 == 5
   2 4 & 5
   3 4 != 0 |% 34 == 5
   4 4 | 5
   5 3 $ 7
   6 4 @^ 5
   7 '
   8 1.892389ep
   9 "ontsjahoesu
  10 /* oerchaoegu
  11 \(<267)11111111111111111111111111111
  12 j(1,)
  13 a(3,3
  14 ()
  15 (((((((((((((((((((()))))))))))))))
  16 3 +
  17 3 - -
  18 233*+ 32
  19 233*+ 32 869356734856
  20 293 * += 38297
  21 293 * += 38297 2839
  22 293 - %= 38297
  23 a * += 38297 2839
  24 a += * 38297
  25 a += * 38297 2839
  26 a %= % 38297
  27 a %= / 38297 2839
  28 "s" + 3
  29 3 - "o"
  30 "e" * "j"
  31 "3" / "2"
  32 !"3"
  33 --"4"
  34 "4"++
  35 + 4
  36 * 3
  37 + 4 + 3
  38 * 3 + 2
  39 c++ +
  40 c + ++
  41 (e * a)++
  42 ++(e ^ a)
  43 (e + a)--
  44 --(e - a)
  45 ++e++
  46 ++e--
  47 --e++
  48 --e--
  49 ++(e)
  50 (e)--
  51 ++++e
  52 e----
  53 ++-e
  54 ---e
  55 ++x += 4
  56 x++ += 4
  57 (i += 1) += 1
  58 -i+=1
  59 e a
  60 c!
  61 e! + a
  62 a + e!
  63 (0||!)
  64 (238497*(29348+238)
  65 a[234
  66 a238]
  67 a[(0] + 1)
  68 (1 + a[0)]
  69 283947 2983745289
  70 a 4
  71 a g
  72 define r(e,) {}
  73 p(,e)
  74 p(e,)
  75 ! + 1l(2)
  76 l957)
  77 l(
  78 g[si+= j []a[s]>=]
  79 j[s
  80 !>5d
  81 a(1..)
  82 a(1;)
  83 1..
  84 1..0
  85 99""""""""""""""""""""""""""""""""99.9999999 + 0.0000000000001
  86 pll[zx<zb]--(<.+)1
  87 a(g2[] -3)
  88 .--1)-1)
  89 .--1)
  90 -1)
  91 (.2==)--d_ -8234+68. -d_ ---d_ -d_ ---d_ -d2 + 5
  92 break
  93 continue
  94 auto a,u
  95 define i(e) { auto p,; return(p); }
  96 define i(e) { auto e; return(e); }
  97 define i(e) { auto q; auto n; return(e); }
  98 define i(e) { auto q; e+=q; auto n; return(e); }
  99 define i(e, e) { auto p; return(p*e); }
 100 define i(e, g, e) { auto p; return(p*e*g); }
 101 define x(e) { define q(f) { return (0); } return q(e); }
 102 define x(3) { return q(e); }
 103 define x([]e) { return q(e); }
 104 define x([]) { return q(e); }
 105 define x(e,[]) { return q(e); }
 106 define x(a[]) { return a[]; }
 107 define x(*a) { return a; }
 108 define x(a) return a;
 109 while e!=0 { i+=1 }
 110 while (e!=0) { i+=1 } if (x) x
 111 for i=0;i<2;++i { c+=i; }
 112 for (i=0;i<2,++i) { c+=i; }
 113 for (i=0,i<2;++i) { c+=i; }
 114 for (i<2;++i) { c+=i; }
 115 for (i=0;++i) { c+=i; }
 116 return (0)
 117 sqrt(3,4)
 118 length(3,4)
 119 scale(3,4)
 120 3=4
 121 3+=4
 122 4-=3
 123 4*=3
 124 4/=3
 125 4%=3
 126 4^=3
 127 3++
 128 --3
 129 a[] = 4
 130 1 + $
 131 a[18446744073709552000] = 0
 132 j(1,2,3)
 133 j(1,a[])
 134 x(2)
 135 read(3)
 136 scale = 18446744073709552000
 137 ibase = 18446744073709552000
 138 obase = 18446744073709552000
 139 scale = -1
 140 sqrt(-1)
 141 0 ^ -251
 142 1/0
 143 1%0
 144 0/0
 145 0%0
 146 0/0.000000
 147 0.000000%0.00000000
 148 root(-15, 4)
 149 root(5, 0)
 150 root(13, -5)
 151 root(1548, 0)
 152 irand(-4)
 153 irand(3289.10827340)
 154 scale = 10000000000000000000000000000000000
 155 obase += 999999999999999999999999999999999999999999999999999999999999999999999999
 156 ibase *= 9999999999999999999999999999999999999999999999999999999999999.9
 157 obase += 9999999999999999999999999999999
 158 ibase *= 99999999999999999999999999999.9
 159 scale = 18446744073709551616
 160 1<<18446744073709551616
 161 1>>18446744073709551616
 162 1<<18446744073709551614
 163 1>>18446744073709551614
 164 i /= 0
 165 4^2903482.29304823
 166 2^340282366920938463463374607431768211456)
 167 4 @ 2389.21982
 168 1 @ -38
 169 3 @ 81906237540187263501872350127351023651023517239512635109283651203985123581235
 170 9 << 182397.283906123
 171 8 << -19
 172 4 << 1298376540182376510982365108263510823651082365120983561239851623590812365192830
 173 5 >> 21892073.28901672
 174 2 >> -29
 175 7 >> 10289374108237541829374123894571028345718923751908237518927809127350891723908
 176 "string"$
 177 -"str2"
 178 a[] + a
 179 a - a[]
 180 a[] * a[]
 181 a[] / a
 182 a % a[]
 183 a[] ^ a[]
 184 c(a[])
 185 j(a[], a)
 186 j(a, a[])
 187 j(a[], a[])
 188 c(;
 189 c(0;
 190 c[0;
 191 ++c(0)
 192 --c(1)
 193 ++scale(34.4)
 194 print "3", a[], "3"
 195 print a[]
 196 print a[], "e"
 197 print;
 198 print 1,2 print 45
 199 print "s" "4"
 200 }
 201 if x x
 202 if (x
 203 while (x
 204 for (i = 0
 205 for (i = 0; i < 10
 206 for (i = 0; i < 10; ++i
 207 define %(x) { return x; }
 208 define x x) { return x; }
 209 for (i=0; i; ++i) if (i) print "stuff"; else i; if (!i) i + 1; else i; }
 210 for (i=0; i; ++i) }
 211 if (i == 0) break; else i;
 212 while (x != 0) { break 4; }
 213 while (x != 0) { continue 4; }
 214 while (x != 0) 4 else 5
 215 else 1
 216 define t(a[) { return a[0]; }
 217 define u() { auto a[; return a[0]; }
 218 define v() { auto a, 4; return a; }
 219 define w() { auto a 4; return a; }
 220 define r() { auto a[], 4; return a[0]; }
 221 define s() { auto a[ 4; return a[0]; }
 222 define void y() { return (1); }
 223 print uint(0)
 224 for (i = 0; i < 10; ++i) { print 4, 5 define
 225 4 + uint(4)
 226 s(uint(5))
 227 4 + 4 scale
 228 4 + 4 scale(s)
 229 4 * 4 read()
 230 5 abs(-5)
 231 2 sqrt(4)
 232 5 + 3 length(4)
 233 x$if(x) x else x
 234 bytes(1) + 4
 235 3 / 0.00000000000000
 236 4e4.4
 237 4e-4.2
 238 a[2^63] = 1
 239 ibase = 100
 240 length(l[] + i[])
 241 abs("string")
 242 abs(a[])
 243 scale("string")
 244 v = "s"; scale(v)
 245 v += "string"
 246 scale(b[])
 247 sqrt("string")
 248 sqrt(c[])
 249 sqrt
 250 length
 251 abs
 252 sqrt(1
 253 length(1
 254 abs(1
 255 divmod 24
 256 modexp 23
 257 divmod(if
 258 modexp(if
 259 divmod(24)
 260 modexp(24)
 261 divmod(24 24)
 262 modexp(24 24)
 263 divmod(24,)
 264 modexp(24,)
 265 divmod(24,
 266 modexp(24,
 267 divmod(24,5
 268 modexp(24,5
 269 divmod(24,5)
 270 modexp(24,5)
 271 divmod(24,5,)
 272 modexp(24,5,)
 273 divmod(24,5,
 274 modexp(24,5,
 275 divmod(24,5,4
 276 modexp(24,5,4
 277 divmod(24,5,a
 278 modexp(24,5,a
 279 divmod(24,5,a[]
 280 divmod(24,5,a[
 281 divmod(24,5,a[2
 282 divmod(24,5,a[2]
 283 divmod(24,5,a[];
 284 modexp(24,5,a;
 285 divmod(24,5,a[];)
 286 modexp(24,5,a;)
 287 divmod(24,5,4)
 288 scale(4.5) modexp(25,5,5)
 289 scale(.2093
 290 a2(0,0)
 291 v = "stuff" + "other"
 292 v = "stuff"; v + v
 293 v = "stuff"; v * 3
 294 v = "stuff"; v - 3
 295 v = "stuff"; v / 3
 296 v = "stuff"; divmod(v, 3, a[])
 297 v = "stuff"; modexp(v, 3, 2)
 298 define f(x) { x * x }; f("stuff")
 299 define f(x) { x * x }; v = "stuff"; f(v)
 300 read
 301 read(
 302 read()
 303 read()
 304 read()