src/ui/xmlwin.c


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

/*
 * xmlwin.c
 *
 * Copyright (C) 2012 - 2015 James Booth <boothj5@gmail.com>
 *
 * This file is part of Profanity.
 *
 * Profanity is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Profanity is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Profanity.  If not, see <http://www.gnu.org/licenses/>.
 *
 * In addition, as a special exception, the copyright holders give permission to
 * link the code of portions of this program with the OpenSSL library under
 * certain conditions as described in each individual source file, and
 * distribute linked combinations including the two.
 *
 * You must obey the GNU General Public License in all respects for all of the
 * code used other than OpenSSL. If you modify file(s) with this exception, you
 * may extend this exception to your version of the file(s), but you are not
 * obligated to do so. If you do not wish to do so, delete this exception
 * statement from your version. If you delete this exception statement from all
 * source files in the program, then also delete it here.
 *
 */

#include <assert.h>
#include <string.h>

#include "ui/win_types.h"
#include "window_list.h"

void
xmlwin_show(ProfXMLWin *xmlwin, const char *const msg)
{
    assert(xmlwin != NULL);

    ProfWin *window = (ProfWin*)xmlwin;
    if (g_str_has_prefix(msg, "SENT:")) {
        win_print(window, '-', 0, NULL, 0, 0, "", "SENT:");
        win_print(window, '-', 0, NULL, 0, THEME_ONLINE, "", &msg[6]);
        win_print(window, '-', 0, NULL, 0, THEME_ONLINE, "", "");
    } else if (g_str_has_prefix(msg, "RECV:")) {
        win_print(window, '-', 0, NULL, 0, 0, "", "RECV:");
        win_print(window, '-', 0, NULL, 0, THEME_AWAY, "", &msg[6]);
        win_print(window, '-', 0, NULL, 0, THEME_AWAY, "", "");
    }
}

char*
xmlwin_get_string(ProfXMLWin *xmlwin)
{
    assert(xmlwin != NULL);

    return strdup("XML console");
}
//: Clean syntax to manipulate and check the file system in scenarios.
//: Instruction 'assume-resources' implicitly creates a variable called
//: 'resources' that is accessible to later instructions in the scenario.

void test_simple_filesystem() {
  run_mu_scenario(
      "scenario simple-filesystem [\n"
      "  local-scope\n"
      "  assume-resources [\n"
           // file 'a' containing two lines of data
      "    [a] <- [\n"
      "      |a bc|\n"
      "      |de f|\n"
      "    ]\n"
           // directory 'b' containing two files, 'c' and 'd'
      "    [b/c] <- []\n"
      "    [b/d] <- [\n"
      "      |xyz|\n"
      "    ]\n"
      "  ]\n"
      "  data:&:@:resource <- get *resources, data:offset\n"
      "  file1:resource <- index *data, 0\n"
      "  file1-name:text <- get file1, name:offset\n"
      "  10:@:char/raw <- copy *file1-name\n"
      "  file1-contents:text <- get file1, contents:offset\n"
      "  100:@:char/raw <- copy *file1-contents\n"
      "  file2:resource <- index *data, 1\n"
      "  file2-name:text <- get file2, name:offset\n"
      "  30:@:char/raw <- copy *file2-name\n"
      "  file2-contents:text <- get file2, contents:offset\n"
      "  40:@:char/raw <- copy *file2-contents\n"
      "  file3:resource <- index *data, 2\n"
      "  file3-name:text <- get file3, name:offset\n"
      "  50:@:char/raw <- copy *file3-name\n"
      "  file3-contents:text <- get file3, contents:offset\n"
      "  60:@:char/raw <- copy *file3-contents\n"
      "  memory-should-contain [\n"
      "    10:array:character <- [a]\n"
      "    100:array:character <- [a bc\n"
      "de f\n"
      "]\n"
      "    30:array:character <- [b/c]\n"
      "    40:array:character <- []\n"
      "    50:array:character <- [b/d]\n"
      "    60:array:character <- [xyz\n"
      "]\n"
      "  ]\n"
      "]\n"
  );
}

void test_escaping_file_contents() {
  run_mu_scenario(
      "scenario escaping-file-contents [\n"
      "  local-scope\n"
      "  assume-resources [\n"
           // file 'a' containing a '|'
           // need to escape '\\' once for each block
      "    [a] <- [\n"
      "      |x\\\\\\\\|yz|\n"
      "    ]\n"
      "  ]\n"
      "  data:&:@:resource <- get *resources, data:offset\n"
      "  file1:resource <- index *data, 0\n"
      "  file1-name:text <- get file1, name:offset\n"
      "  10:@:char/raw <- copy *file1-name\n"
      "  file1-contents:text <- get file1, contents:offset\n"
      "  20:@:char/raw <- copy *file1-contents\n"
      "  memory-should-contain [\n"
      "    10:array:character <- [a]\n"
      "    20:array:character <- [x|yz\n"
      "]\n"
      "  ]\n"
      "]\n"
  );
}

:(before "End Globals")
extern const int RESOURCES = next_predefined_global_for_scenarios(/*size_of(address:resources)*/2);
//: give 'resources' a fixed location in scenarios
:(before "End Special Scenario Variable Names(r)")
Name[r]["resources"] = RESOURCES;
//: make 'resources' always a raw location in scenarios
:(before "End is_special_name Special-cases")
if (s == "resources") return true;
:(before "End Initialize Type Of Special Name In Scenario(r)")
if (r.name == "resources") r.type = new_type_tree("address:resources");

:(before "End initialize_transform_rewrite_literal_string_to_text()")
recipes_taking_literal_strings.insert("assume-resources");

//: screen-should-contain is a regular instruction
:(before "End Primitive Recipe Declarations")
ASSUME_RESOURCES,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "assume-resources", ASSUME_RESOURCES);
:(before "End Primitive Recipe Checks")
case ASSUME_RESOURCES: {
  break;
}
:(before "End Primitive Recipe Implementations")
case ASSUME_RESOURCES: {
  assert(scalar(ingredients.at(0)));
  assume_resources(current_instruction().ingredients.at(0).name, current_recipe_name());
  break;
}

:(code)
void assume_resources(const string& data, const string& caller) {
  map<string, string> contents;
  parse_resources(data, contents, caller);
  construct_resources_object(contents);
}

void parse_resources(const string& data, map<string, string>& out, const string& caller) {
  istringstream in(data);
  in >> std::noskipws;
  while (true) {
    if (!has_data(in)) break;
    skip_whitespace_and_comments(in);
    if (!has_data(in)) break;
    string filename = next_word(in);
    if (filename.empty()) {
      assert(!has_data(in));
      raise << "incomplete 'resources' block at end of file (0)\n" << end();
      return;
    }
    if (*filename.begin() != '[') {
      raise << caller << ": assume-resources: filename '" << filename << "' must begin with a '['\n" << end();
      break;
    }
    if (*filename.rbegin() != ']') {
      raise << caller << ": assume-resources: filename '" << filename << "' must end with a ']'\n" << end();
      break;
    }
    filename.erase(0, 1);
    filename.erase(SIZE(filename)-1);
    if (!has_data(in)) {
      raise << caller << ": assume-resources: no data for filename '" << filename << "'\n" << end();
      break;
    }
    string arrow = next_word(in);
    if (arrow.empty()) {
      assert(!has_data(in));
      raise << "incomplete 'resources' block at end of file (1)\n" << end();
      return;
    }
    if (arrow != "<-") {
      raise << caller << ": assume-resources: expected '<-' after filename '" << filename << "' but got '" << arrow << "'\n" << end();
      break;
    }
    if (!has_data(in)) {
      raise << caller << ": assume-resources: no data for filename '" << filename << "' after '<-'\n" << end();
      break;
    }
    string contents = next_word(in);
    if (contents.empty()) {
      assert(!has_data(in));
      raise << "incomplete 'resources' block at end of file (2)\n" << end();
      return;
    }
    if (*contents.begin() != '[') {
      raise << caller << ": assume-resources: file contents '" << contents << "' for filename '" << filename << "' must begin with a '['\n" << end();
      break;
    }
    if (*contents.rbegin() != ']') {
      raise << caller << ": assume-resources: file contents '" << contents << "' for filename '" << filename << "' must end with a ']'\n" << end();
      break;
    }
    contents.erase(0, 1);
    contents.erase(SIZE(contents)-1);
    put(out, filename, munge_resources_contents(contents, filename, caller));
  }
}

string munge_resources_contents(const string& data, const string& filename, const string& caller) {
  if (data.empty()) return "";
  istringstream in(data);
  in >> std::noskipws;
  skip_whitespace_and_comments(in);
  ostringstream out;
  while (true) {
    if (!has_data(in)) break;
    skip_whitespace(in);
    if (!has_data(in)) break;
    if (in.peek() != '|') {
      raise << caller << ": assume-resources: file contents for filename '" << filename << "' must be delimited in '|'s\n" << end();
      break;
    }
    in.get();  // skip leading '|'
    string line;
    getline(in, line);
    for (int i = 0;  i < SIZE(line);  ++i) {
      if (line.at(i) == '|') break;
      if (line.at(i) == '\\') {
        ++i;  // skip
        if (i == SIZE(line)) {
          raise << caller << ": assume-resources: file contents can't end a line with '\\'\n" << end();
          break;
        }
      }
      out << line.at(i);
    }
    // todo: some way to represent a file without a final newline
    out << '\n';
  }
  return out.str();
}

void construct_resources_object(const map<string, string>& contents) {
  int resources_data_address = allocate(SIZE(contents) * /*size of resource*/4 + /*array length*/1);
  int curr = resources_data_address + /*skip alloc id*/1 + /*skip array length*/1;
  for (map<string, string>::const_iterator p = contents.begin();  p != contents.end();  ++p) {
    ++curr;  // skip alloc id of resource.name
    put(Memory, curr, new_mu_text(p->first));
    trace(Callstack_depth+1, "mem") << "storing file name " << get(Memory, curr) << " in location " << curr << end();
    ++curr;
    ++curr;  // skip alloc id of resource.contents
    put(Memory, curr, new_mu_text(p->second));
    trace(Callstack_depth+1, "mem") << "storing file contents " << get(Memory, curr) << " in location " << curr << end();
    ++curr;
  }
  curr = resources_data_address + /*skip alloc id of resources.data*/1;
  put(Memory, curr, SIZE(contents));  // array length
  trace(Callstack_depth+1, "mem") << "storing resources size " << get(Memory, curr) << " in location " << curr << end();
  // wrap the resources data in a 'resources' object
  int resources_address = allocate(size_of_resources());
  curr = resources_address+/*alloc id*/1+/*offset of 'data' element*/1+/*skip alloc id of 'data' element*/1;
  put(Memory, curr, resources_data_address);
  trace(Callstack_depth+1, "mem") << "storing resources data address " << resources_data_address << " in location " << curr << end();
  // save in product
  put(Memory, RESOURCES+/*skip alloc id*/1, resources_address);
  trace(Callstack_depth+1, "mem") << "storing resources address " << resources_address << " in location " << RESOURCES << end();
}

int size_of_resources() {
  // memoize result if already computed
  static int result = 0;
  if (result) return result;
  assert(get(Type_ordinal, "resources"));
  type_tree* type = new type_tree("resources");
  result = size_of(type);
  delete type;
  return result;
}