From 6f8f9fb53b5a7ef26496d496a4b93266c78d6332 Mon Sep 17 00:00:00 2001
From: "Kartik K. Agaram" <vc@akkartik.com>
Date: Sun, 17 May 2015 00:52:23 -0700
Subject: 1390 - support non-integer literals

Since '3.14159:literal' looks ugly, we'll just say '3.14159'. It's not
like non-integers can be confused for anything but literals.

Once I tried to turn reagent values into doubles, I uncovered a bug:
arithmetic using signed integers is busted; if either operand of
subtraction is unsigned the result is unsigned as well. If it needs to
be negative: ka-boom. It was only masked because I was eventually
storing the result in a long long int, where it was out of range, and so
overflowing into the correct signed value. Once I switched to doubles
the unsigned value would indeed fit without overflowing. Ka-boom.

Yet another reminder that unsigned integers suck. I started using them
mostly to avoid warnings in loops when comparing with .size(), which is
usually a size_t.

Who knows what other crap lurks here. Just use signed integers
everywhere. (And avoid bitwise operators.)
---
 040brace.cc | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

(limited to '040brace.cc')

diff --git a/040brace.cc b/040brace.cc
index 6fde1713..ec9c6a4d 100644
--- a/040brace.cc
+++ b/040brace.cc
@@ -40,21 +40,23 @@ void transform_braces(const recipe_number r) {
 //?   cout << "AAA transform_braces\n"; //? 1
 //?   exit(0); //? 1
   const int OPEN = 0, CLOSE = 1;
-  list<pair<int/*OPEN/CLOSE*/, /*step*/index_t> > braces;
-  for (index_t index = 0; index < Recipe[r].steps.size(); ++index) {
+  // use signed integer for step index because we'll be doing arithmetic on it
+  list<pair<int/*OPEN/CLOSE*/, /*step*/long long int> > braces;
+  for (long long int index = 0; index < static_cast<long long int>(Recipe[r].steps.size()); ++index) {
     const instruction& inst = Recipe[r].steps.at(index);
     if (inst.label == "{") {
       trace("brace") << r << ": push (open, " << index << ")";
-      braces.push_back(pair<int,index_t>(OPEN, index));
+      braces.push_back(pair<int,long long int>(OPEN, index));
     }
     if (inst.label == "}") {
       trace("brace") << "push (close, " << index << ")";
-      braces.push_back(pair<int,index_t>(CLOSE, index));
+      braces.push_back(pair<int,long long int>(CLOSE, index));
     }
   }
-  stack</*step*/index_t> open_braces;
+  stack</*step*/long long int> open_braces;
   trace("after-brace") << "recipe " << Recipe[r].name;
-  for (index_t index = 0; index < Recipe[r].steps.size(); ++index) {
+  for (long long int index = 0; index < static_cast<long long int>(Recipe[r].steps.size()); ++index) {
+//?     cerr << index << '\n'; //? 1
     instruction& inst = Recipe[r].steps.at(index);
 //?     cout << "AAA " << inst.name << ": " << inst.operation << '\n'; //? 1
     if (inst.label == "{") open_braces.push(index);
@@ -154,9 +156,11 @@ void transform_braces(const recipe_number r) {
   }
 }
 
-int matching_brace(index_t index, const list<pair<int, index_t> >& braces) {
+// returns a signed integer not just so that we can return -1 but also to
+// enable future signed arithmetic
+long long int matching_brace(long long int index, const list<pair<int, long long int> >& braces) {
   int stacksize = 0;
-  for (list<pair<int, index_t> >::const_iterator p = braces.begin(); p != braces.end(); ++p) {
+  for (list<pair<int, long long int> >::const_iterator p = braces.begin(); p != braces.end(); ++p) {
     if (p->second < index) continue;
     stacksize += (p->first ? 1 : -1);
     if (stacksize == 0) return p->second;
-- 
cgit 1.4.1-2-gfad0