From 4a943d4ed313eff001504c2b5c472266e86a38af Mon Sep 17 00:00:00 2001 From: Kartik Agaram Date: Tue, 12 Mar 2019 18:56:55 -0700 Subject: 5001 - drop the :(scenario) DSL I've been saying for a while[1][2][3] that adding extra abstractions makes things harder for newcomers, and adding new notations doubly so. And then I notice this DSL in my own backyard. Makes me feel like a hypocrite. [1] https://news.ycombinator.com/item?id=13565743#13570092 [2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning [3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2 The implementation of the DSL was also highly hacky: a) It was happening in the tangle/ tool, but was utterly unrelated to tangling layers. b) There were several persnickety constraints on the different kinds of lines and the specific order they were expected in. I kept finding bugs where the translator would silently do the wrong thing. Or the error messages sucked, and readers may be stuck looking at the generated code to figure out what happened. Fixing error messages would require a lot more code, which is one of my arguments against DSLs in the first place: they may be easy to implement, but they're hard to design to go with the grain of the underlying platform. They require lots of iteration. Is that effort worth prioritizing in this project? On the other hand, the DSL did make at least some readers' life easier, the ones who weren't immediately put off by having to learn a strange syntax. There were fewer quotes to parse, fewer backslash escapes. Anyway, since there are also people who dislike having to put up with strange syntaxes, we'll call that consideration a wash and tear this DSL out. --- This commit was sheer drudgery. Hopefully it won't need to be redone with a new DSL because I grow sick of backslashes. --- 045closure_name.cc | 139 ++++++++++++++++++++++++++++++----------------------- 1 file changed, 79 insertions(+), 60 deletions(-) (limited to '045closure_name.cc') diff --git a/045closure_name.cc b/045closure_name.cc index b4a8ea24..d5f26f81 100644 --- a/045closure_name.cc +++ b/045closure_name.cc @@ -6,28 +6,33 @@ //: todo: warn on default-space abuse. default-space for one recipe should //: never come from another, otherwise memory will be corrupted. -:(scenario closure) -def main [ - default-space:space <- new location:type, 30 - 2:space/names:new-counter <- new-counter - 10:num/raw <- increment-counter 2:space/names:new-counter - 11:num/raw <- increment-counter 2:space/names:new-counter -] -def new-counter [ - default-space:space <- new location:type, 30 - x:num <- copy 23 - y:num <- copy 13 # variable that will be incremented - return default-space:space -] -def increment-counter [ - default-space:space <- new location:type, 30 - 0:space/names:new-counter <- next-ingredient # outer space must be created by 'new-counter' above - y:num/space:1 <- add y:num/space:1, 1 # increment - y:num <- copy 234 # dummy - return y:num/space:1 -] -+name: lexically surrounding space for recipe increment-counter comes from new-counter -+mem: storing 15 in location 11 +void test_closure() { + run( + "def main [\n" + " default-space:space <- new location:type, 30\n" + " 2:space/names:new-counter <- new-counter\n" + " 10:num/raw <- increment-counter 2:space/names:new-counter\n" + " 11:num/raw <- increment-counter 2:space/names:new-counter\n" + "]\n" + "def new-counter [\n" + " default-space:space <- new location:type, 30\n" + " x:num <- copy 23\n" + " y:num <- copy 13\n" // variable that will be incremented + " return default-space:space\n" + "]\n" + "def increment-counter [\n" + " default-space:space <- new location:type, 30\n" + " 0:space/names:new-counter <- next-ingredient\n" // outer space must be created by 'new-counter' above + " y:num/space:1 <- add y:num/space:1, 1\n" // increment + " y:num <- copy 234\n" // dummy + " return y:num/space:1\n" + "]\n" + ); + CHECK_TRACE_CONTENTS( + "name: lexically surrounding space for recipe increment-counter comes from new-counter\n" + "mem: storing 15 in location 11\n" + ); +} //: To make this work, compute the recipe that provides names for the //: surrounding space of each recipe. @@ -142,44 +147,58 @@ bool already_transformed(const reagent& r, const map& names) { return contains_key(names, r.name); } -:(scenario missing_surrounding_space) -% Hide_errors = true; -def f [ - local-scope - x:num/space:1 <- copy 34 -] -+error: don't know surrounding recipe of 'f' -+error: f: can't find a place to store 'x' +:(code) +void test_missing_surrounding_space() { + Hide_errors = true; + run( + "def f [\n" + " local-scope\n" + " x:num/space:1 <- copy 34\n" + "]\n" + ); + CHECK_TRACE_CONTENTS( + "error: don't know surrounding recipe of 'f'\n" + "error: f: can't find a place to store 'x'\n" + ); +} //: extra test for try_reclaim_locals() from previous layers -:(scenario local_scope_ignores_nonlocal_spaces) -def new-scope [ - local-scope - x:&:num <- new number:type - *x:&:num <- copy 34 - return default-space:space -] -def use-scope [ - local-scope - outer:space/names:new-scope <- next-ingredient - 0:space/names:new-scope <- copy outer:space - return *x:&:num/space:1 -] -def main [ - 1:space/raw <- new-scope - 3:num/raw <- use-scope 1:space/raw -] -+mem: storing 34 in location 3 +void test_local_scope_ignores_nonlocal_spaces() { + run( + "def new-scope [\n" + " local-scope\n" + " x:&:num <- new number:type\n" + " *x:&:num <- copy 34\n" + " return default-space:space\n" + "]\n" + "def use-scope [\n" + " local-scope\n" + " outer:space/names:new-scope <- next-ingredient\n" + " 0:space/names:new-scope <- copy outer:space\n" + " return *x:&:num/space:1\n" + "]\n" + "def main [\n" + " 1:space/raw <- new-scope\n" + " 3:num/raw <- use-scope 1:space/raw\n" + "]\n" + ); + CHECK_TRACE_CONTENTS( + "mem: storing 34 in location 3\n" + ); +} -:(scenario recursive_transform_names) -def foo [ - local-scope - x:num <- copy 0 - return default-space:space/names:foo -] -def main [ - local-scope - 0:space/names:foo <- foo - x:num/space:1 <- copy 34 -] -$error: 0 +void test_recursive_transform_names() { + run( + "def foo [\n" + " local-scope\n" + " x:num <- copy 0\n" + " return default-space:space/names:foo\n" + "]\n" + "def main [\n" + " local-scope\n" + " 0:space/names:foo <- foo\n" + " x:num/space:1 <- copy 34\n" + "]\n" + ); + CHECK_TRACE_COUNT("error", 0); +} -- cgit 1.4.1-2-gfad0 '#n117'>117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
//: Clean syntax to manipulate and check the screen in scenarios.
//: Instructions 'assume-screen' and 'screen-should-contain' implicitly create
//: a variable called 'screen' that is accessible inside other 'run'
//: instructions in the scenario. 'screen-should-contain' can check unicode
//: characters in the fake screen

:(scenarios run_mu_scenario)
:(scenario screen_in_scenario)
scenario screen-in-scenario [
  assume-screen 5/width, 3/height
  run [
    1:character <- copy 97/a
    screen:address:screen <- print screen:address:screen, 1:character/a
  ]
  screen-should-contain [
  #  01234
    .a    .
    .     .
    .     .
  ]
]
# checks are inside scenario

:(scenario screen_in_scenario_unicode)
scenario screen-in-scenario-unicode-color [
  assume-screen 5/width, 3/height
  run [
    1:character <- copy 955/greek-small-lambda
    screen:address:screen <- print screen:address:screen, 1:character/lambda, 1/red
    2:character <- copy 97/a
    screen:address:screen <- print screen:address:screen, 2:character/a
  ]
  screen-should-contain [
  #  01234
    .λa   .
    .     .
    .     .
  ]
]
# checks are inside scenario

:(scenario screen_in_scenario_color)
# screen-should-contain can check unicode characters in the fake screen
scenario screen-in-scenario-color [
  assume-screen 5/width, 3/height
  run [
    1:character <- copy 955/greek-small-lambda
    screen:address:screen <- print screen:address:screen, 1:character/lambda, 1/red
    2:character <- copy 97/a
    screen:address:screen <- print screen:address:screen, 2:character/a, 7/white
  ]
  # screen-should-contain shows everything
  screen-should-contain [
  #  01234
    .λa   .
    .     .
    .     .
  ]
  # screen-should-contain-in-color filters out everything except the given
  # color, all you see is the 'a' in white.
  screen-should-contain-in-color 7/white, [
  #  01234
    . a   .
    .     .
    .     .
  ]
  # ..and the λ in red.
  screen-should-contain-in-color 1/red, [
  #  01234
    .λ    .
    .     .
    .     .
  ]
]
# checks are inside scenario

:(scenario screen_in_scenario_error)
% Scenario_testing_scenario = true;
% Hide_errors = true;
scenario screen-in-scenario-error [
  assume-screen 5/width, 3/height
  run [
    1:character <- copy 97/a
    screen:address:screen <- print screen:address:screen, 1:character/a
  ]
  screen-should-contain [
  #  01234
    .b    .
    .     .
    .     .
  ]
]
+error: expected screen location (0, 0) to contain 98 ('b') instead of 97 ('a')

:(scenario screen_in_scenario_color_error)
% Scenario_testing_scenario = true;
% Hide_errors = true;
# screen-should-contain can check unicode characters in the fake screen
scenario screen-in-scenario-color [
  assume-screen 5/width, 3/height
  run [
    1:character <- copy 97/a
    screen:address:screen <- print screen:address:screen, 1:character/a, 1/red
  ]
  screen-should-contain-in-color 2/green, [
  #  01234
    .a    .
    .     .
    .     .
  ]
]
+error: expected screen location (0, 0) to be in color 2 instead of 1

//: allow naming just for 'screen'
:(before "End is_special_name Cases")
if (s == "screen") return true;

:(scenarios run)
:(scenario convert_names_does_not_fail_when_mixing_special_names_and_numeric_locations)
% Scenario_testing_scenario = true;
def main [
  screen:number <- copy 1:number
]
-error: mixing variable names and numeric addresses in main
$error: 0
:(scenarios run_mu_scenario)

:(before "End Globals")
// Scenarios may not define default-space, so they should fit within the
// initial area of memory reserved for tests. We'll put the predefined
// variables available to them at the end of that region.
const int Max_variables_in_scenarios = Reserved_for_tests-100;
int Next_predefined_global_for_scenarios = Max_variables_in_scenarios;
:(before "End Setup")
assert(Next_predefined_global_for_scenarios < Reserved_for_tests);
:(after "transform_all()" following "case RUN:")
// There's a restriction on the number of variables 'run' can use, so that
// it can avoid colliding with the dynamic allocator in case it doesn't
// initialize a default-space.
assert(Name[tmp_recipe.at(0)][""] < Max_variables_in_scenarios);

:(before "End Globals")
// Scenario Globals.
const int SCREEN = Next_predefined_global_for_scenarios++;
// End Scenario Globals.
:(before "End Special Scenario Variable Names(r)")
Name[r]["screen"] = SCREEN;

:(before "End Rewrite Instruction(curr, recipe result)")
// rewrite `assume-screen width, height` to
// `screen:address:screen <- new-fake-screen width, height`
if (curr.name == "assume-screen") {
  curr.name = "new-fake-screen";
  assert(curr.products.empty());
  curr.products.push_back(reagent("screen:address:screen/raw"));  // only allowed in scenario blocks
  curr.products.at(0).set_value(SCREEN);
}

//: screen-should-contain is a regular instruction
:(before "End Primitive Recipe Declarations")
SCREEN_SHOULD_CONTAIN,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "screen-should-contain", SCREEN_SHOULD_CONTAIN);
:(before "End Primitive Recipe Checks")
case SCREEN_SHOULD_CONTAIN: {
  break;
}
:(before "End Primitive Recipe Implementations")
case SCREEN_SHOULD_CONTAIN: {
  if (!Passed) break;
  assert(scalar(ingredients.at(0)));
  check_screen(current_instruction().ingredients.at(0).name, -1);
  break;
}

:(before "End Primitive Recipe Declarations")
SCREEN_SHOULD_CONTAIN_IN_COLOR,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "screen-should-contain-in-color", SCREEN_SHOULD_CONTAIN_IN_COLOR);
:(before "End Primitive Recipe Checks")
case SCREEN_SHOULD_CONTAIN_IN_COLOR: {
  break;
}
:(before "End Primitive Recipe Implementations")
case SCREEN_SHOULD_CONTAIN_IN_COLOR: {
  if (!Passed) break;
  assert(scalar(ingredients.at(0)));
  assert(scalar(ingredients.at(1)));
  check_screen(current_instruction().ingredients.at(1).name, ingredients.at(0).at(0));
  break;
}

:(before "End Types")
// scan an array of characters in a unicode-aware, bounds-checked manner
struct raw_string_stream {
  int index;
  const int max;
  const char* buf;

  raw_string_stream(const string&);
  uint32_t get();  // unicode codepoint
  uint32_t peek();  // unicode codepoint
  bool at_end() const;
  void skip_whitespace_and_comments();
};

:(code)
void check_screen(const string& expected_contents, const int color) {
  int screen_location = get_or_insert(Memory, SCREEN)+/*skip refcount*/1;
  int data_offset = find_element_name(get(Type_ordinal, "screen"), "data", "");
  assert(data_offset >= 0);
  int screen_data_location = screen_location+data_offset;  // type: address:array:character
  int screen_data_start = get_or_insert(Memory, screen_data_location) + /*skip refcount*/1;  // type: array:character
  int width_offset = find_element_name(get(Type_ordinal, "screen"), "num-columns", "");
  int screen_width = get_or_insert(Memory, screen_location+width_offset);
  int height_offset = find_element_name(get(Type_ordinal, "screen"), "num-rows", "");
  int screen_height = get_or_insert(Memory, screen_location+height_offset);
  raw_string_stream cursor(expected_contents);
  // todo: too-long expected_contents should fail
  int addr = screen_data_start+/*skip length*/1;
  for (int row = 0; row < screen_height; ++row) {
    cursor.skip_whitespace_and_comments();
    if (cursor.at_end()) break;
    assert(cursor.get() == '.');
    for (int column = 0;  column < screen_width;  ++column, addr+= /*size of screen-cell*/2) {
      const int cell_color_offset = 1;
      uint32_t curr = cursor.get();
      if (get_or_insert(Memory, addr) == 0 && isspace(curr)) continue;
      if (curr == ' ' && color != -1 && color != get_or_insert(Memory, addr+cell_color_offset)) {
        // filter out other colors
        continue;
      }
      if (get_or_insert(Memory, addr) != 0 && get_or_insert(Memory, addr) == curr) {
        if (color == -1 || color == get_or_insert(Memory, addr+cell_color_offset)) continue;
        // contents match but color is off
        if (Current_scenario && !Scenario_testing_scenario) {
          // genuine test in a mu file
          raise << "\nF - " << Current_scenario->name << ": expected screen location (" << row << ", " << column << ", address " << addr << ", value " << no_scientific(get_or_insert(Memory, addr)) << ") to be in color " << color << " instead of " << no_scientific(get_or_insert(Memory, addr+cell_color_offset)) << "\n" << end();
          dump_screen();
        }
        else {
          // just testing check_screen
          raise << "expected screen location (" << row << ", " << column << ") to be in color " << color << " instead of " << no_scientific(get_or_insert(Memory, addr+cell_color_offset)) << '\n' << end();
        }
        if (!Scenario_testing_scenario) {
          Passed = false;
          ++Num_failures;
        }
        return;
      }

      // really a mismatch
      // can't print multi-byte unicode characters in errors just yet. not very useful for debugging anyway.
      char expected_pretty[10] = {0};
      if (curr < 256 && !iscntrl(curr)) {
        // " ('<curr>')"
        expected_pretty[0] = ' ', expected_pretty[1] = '(', expected_pretty[2] = '\'', expected_pretty[3] = static_cast<unsigned char>(curr), expected_pretty[4] = '\'', expected_pretty[5] = ')', expected_pretty[6] = '\0';
      }
      char actual_pretty[10] = {0};
      if (get_or_insert(Memory, addr) < 256 && !iscntrl(get_or_insert(Memory, addr))) {
        // " ('<curr>')"
        actual_pretty[0] = ' ', actual_pretty[1] = '(', actual_pretty[2] = '\'', actual_pretty[3] = static_cast<unsigned char>(get_or_insert(Memory, addr)), actual_pretty[4] = '\'', actual_pretty[5] = ')', actual_pretty[6] = '\0';
      }

      ostringstream color_phrase;
      if (color != -1) color_phrase << " in color " << color;
      if (Current_scenario && !Scenario_testing_scenario) {
        // genuine test in a mu file
        raise << "\nF - " << Current_scenario->name << ": expected screen location (" << row << ", " << column << ") to contain " << curr << expected_pretty << color_phrase.str() << " instead of " << no_scientific(get_or_insert(Memory, addr)) << actual_pretty << '\n' << end();
        dump_screen();
      }
      else {
        // just testing check_screen
        raise << "expected screen location (" << row << ", " << column << ") to contain " << curr << expected_pretty << color_phrase.str() << " instead of " << no_scientific(get_or_insert(Memory, addr)) << actual_pretty << '\n' << end();
      }
      if (!Scenario_testing_scenario) {
        Passed = false;
        ++Num_failures;
      }
      return;
    }
    assert(cursor.get() == '.');
  }
  cursor.skip_whitespace_and_comments();
  assert(cursor.at_end());
}

raw_string_stream::raw_string_stream(const string& backing) :index(0), max(SIZE(backing)), buf(backing.c_str()) {}

bool raw_string_stream::at_end() const {
  if (index >= max) return true;
  if (tb_utf8_char_length(buf[index]) > max-index) {
    raise << "unicode string seems corrupted at index "<< index << " character " << static_cast<int>(buf[index]) << '\n' << end();
    return true;
  }
  return false;
}

uint32_t raw_string_stream::get() {
  assert(index < max);  // caller must check bounds before calling 'get'
  uint32_t result = 0;
  int length = tb_utf8_char_to_unicode(&result, &buf[index]);
  assert(length != TB_EOF);
  index += length;
  return result;
}

uint32_t raw_string_stream::peek() {
  assert(index < max);  // caller must check bounds before calling 'get'
  uint32_t result = 0;
  int length = tb_utf8_char_to_unicode(&result, &buf[index]);
  assert(length != TB_EOF);
  return result;
}

void raw_string_stream::skip_whitespace_and_comments() {
  while (!at_end()) {
    if (isspace(peek())) get();
    else if (peek() == '#') {
      // skip comment
      get();
      while (peek() != '\n') get();  // implicitly also handles CRLF
    }
    else break;
  }
}

:(before "End Primitive Recipe Declarations")
_DUMP_SCREEN,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "$dump-screen", _DUMP_SCREEN);
:(before "End Primitive Recipe Checks")
case _DUMP_SCREEN: {
  break;
}
:(before "End Primitive Recipe Implementations")
case _DUMP_SCREEN: {
  dump_screen();
  break;
}

:(code)
void dump_screen() {
  int screen_location = get_or_insert(Memory, SCREEN) + /*skip refcount*/1;
  int width_offset = find_element_name(get(Type_ordinal, "screen"), "num-columns", "");
  int screen_width = get_or_insert(Memory, screen_location+width_offset);
  int height_offset = find_element_name(get(Type_ordinal, "screen"), "num-rows", "");
  int screen_height = get_or_insert(Memory, screen_location+height_offset);
  int data_offset = find_element_name(get(Type_ordinal, "screen"), "data", "");
  assert(data_offset >= 0);
  int screen_data_location = screen_location+data_offset;  // type: address:array:character
  int screen_data_start = get_or_insert(Memory, screen_data_location) + /*skip refcount*/1;  // type: array:character
  assert(get_or_insert(Memory, screen_data_start) == screen_width*screen_height);
  int curr = screen_data_start+1;  // skip length
  for (int row = 0; row < screen_height; ++row) {
    cerr << '.';
    for (int col = 0; col < screen_width; ++col) {
      if (get_or_insert(Memory, curr))
        cerr << to_unicode(static_cast<uint32_t>(get_or_insert(Memory, curr)));
      else
        cerr << ' ';
      curr += /*size of screen-cell*/2;
    }
    cerr << ".\n";
  }
}