Mu - 014literal

From 4690ce81e079fc58cae8d6d583e5e3eb3ed81a83 Mon Sep 17 00:00:00 2001 From: "Kartik K. Agaram" Date: Wed, 9 Mar 2016 02:56:27 -0800 Subject: 2743 Looks like "TOhtml | " doesn't work on Mac OS X for some reason.. --- html/014literal_string.cc.html | 128 +++++++++++++++++++---------------------- 1 file changed, 60 insertions(+), 68 deletions(-) (limited to 'html/014literal_string.cc.html') diff --git a/html/014literal_string.cc.html b/html/014literal_string.cc.html index bc4affd9..5dd9d17b 100644 --- a/html/014literal_string.cc.html +++ b/html/014literal_string.cc.html @@ -3,34 +3,27 @@ Mu - 014literal_string.cc - - + + - - + - - -
+ //: For convenience, some instructions will take literal arrays of characters (strings).
 //:
 //: Instead of quotes, we'll use [] to delimit strings. That'll reduce the
@@ -40,13 +33,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 
 :(scenarios load)
 :(scenario string_literal)
-recipe main [
+def main [
   1:address:array:character <- copy [abc def]  # copy can't really take a string
 ]
 +parse:   ingredient: "abc def": "literal-string"
 
 :(scenario string_literal_with_colons)
-recipe main [
+def main [
   1:address:array:character <- copy [abc:def/ghi]
 ]
 +parse:   ingredient: "abc:def/ghi": "literal-string"
@@ -55,7 +48,7 @@ recipe main [
 put(Type_ordinal, "literal-string", 0);
 
 :(before "End next_word Special-cases")
-if (in.peek() == '[') {
+if (in.peek() == '[') {
   string result = slurp_quoted(in);
   skip_whitespace_and_comments_but_not_newline(in);
   return result;
@@ -64,25 +57,25 @@ if (in.peek:(code)
 string slurp_quoted(istream& in) {
   ostringstream out;
-  assert(has_data(in));  assert(in.peek() == '[');  out << static_cast<char>(in.get());  // slurp the '['
-  if (is_code_string(in, out))
+  assert(has_data(in));  assert(in.peek() == '[');  out << static_cast<char>(in.get());  // slurp the '['
+  if (is_code_string(in, out))
     slurp_quoted_comment_aware(in, out);
-  else
+  else
     slurp_quoted_comment_oblivious(in, out);
   return out.str();
 }
 
 // A string is a code string if it contains a newline before any non-whitespace
 // todo: support comments before the newline. But that gets messy.
-bool is_code_string(istream& in, ostream& out) {
-  while (has_data(in)) {
-    char c = in.get();
-    if (!isspace(c)) {
+bool is_code_string(istream& in, ostream& out) {
+  while (has_data(in)) {
+    char c = in.get();
+    if (!isspace(c)) {
       in.putback(c);
       return false;
     }
     out << c;
-    if (c == '\n') {
+    if (c == '\n') {
       return true;
     }
   }
@@ -91,59 +84,59 @@ bool is_code_string(istream& in// Read a regular string. Regular strings can only contain other regular
 // strings.
-void slurp_quoted_comment_oblivious(istream& in, ostream& out) {
-  int brace_depth = 1;
-  while (has_data(in)) {
-    char c = in.get();
-    if (c == '\\') {
-      out << static_cast<char>(in.get());
+void slurp_quoted_comment_oblivious(istream& in, ostream& out) {
+  int brace_depth = 1;
+  while (has_data(in)) {
+    char c = in.get();
+    if (c == '\\') {
+      out << static_cast<char>(in.get());
       continue;
     }
     out << c;
-    if (c == '[') ++brace_depth;
-    if (c == ']') --brace_depth;
-    if (brace_depth == 0) break;
+    if (c == '[') ++brace_depth;
+    if (c == ']') --brace_depth;
+    if (brace_depth == 0) break;
   }
-  if (!has_data(in) && brace_depth > 0) {
-    raise_error << "unbalanced '['\n" << end();
+  if (!has_data(in) && brace_depth > 0) {
+    raise << "unbalanced '['\n" << end();
     out.clear();
   }
 }
 
 // Read a code string. Code strings can contain either code or regular strings.
-void slurp_quoted_comment_aware(istream& in, ostream& out) {
-  char c;
-  while (in >> c) {
-    if (c == '\\') {
-      out << static_cast<char>(in.get());
+void slurp_quoted_comment_aware(istream& in, ostream& out) {
+  char c;
+  while (in >> c) {
+    if (c == '\\') {
+      out << static_cast<char>(in.get());
       continue;
     }
-    if (c == '#') {
+    if (c == '#') {
       out << c;
-      while (has_data(in) && in.peek() != '\n') out << static_cast<char>(in.get());
+      while (has_data(in) && in.peek() != '\n') out << static_cast<char>(in.get());
       continue;
     }
-    if (c == '[') {
+    if (c == '[') {
       in.putback(c);
       // recurse
       out << slurp_quoted(in);
       continue;
     }
     out << c;
-    if (c == ']') return;
+    if (c == ']') return;
   }
-  raise_error << "unbalanced '['\n" << end();
+  raise << "unbalanced '['\n" << end();
   out.clear();
 }
 
 :(after "Parsing reagent(string s)")
-if (s.at(0) == '[') {
+if (s.at(0) == '[') {
   assert(*s.rbegin() == ']');
   // delete [] delimiters
   s.erase(0, 1);
   strip_last(s);
   name = s;
-  type = new type_tree("literal-string", 0);
+  type = new type_tree("literal-string", 0);
   return;
 }
 
@@ -151,53 +144,53 @@ if (s.at//: more friendly to trace().
 
 :(after "string to_string(const reagent& r)")
-  if (is_literal_string(r))
+  if (is_literal_string(r))
     return emit_literal_string(r.name);
 
 :(code)
-bool is_literal_string(const reagent& x) {
+bool is_literal_string(const reagent& x) {
   return x.type && x.type->name == "literal-string";
 }
 
 string emit_literal_string(string name) {
-  size_t pos = 0;
-  while (pos != string::npos)
+  size_t pos = 0;
+  while (pos != string::npos)
     pos = replace(name, "\n", "\\n", pos);
   return '"'+name+"\": \"literal-string\"";
 }
 
-size_t replace(string& str, const string& from, const string& to, size_t n) {
-  size_t result = str.find(from, n);
-  if (result != string::npos)
+size_t replace(string& str, const string& from, const string& to, size_t n) {
+  size_t result = str.find(from, n);
+  if (result != string::npos)
     str.replace(result, from.length(), to);
   return result;
 }
 
-void strip_last(string& s) {
-  if (!s.empty()) s.erase(SIZE(s)-1);
+void strip_last(string& s) {
+  if (!s.empty()) s.erase(SIZE(s)-1);
 }
 
 :(scenario string_literal_nested)
-recipe main [
+def main [
   1:address:array:character <- copy [abc [def]]
 ]
 +parse:   ingredient: "abc [def]": "literal-string"
 
 :(scenario string_literal_escaped)
-recipe main [
+def main [
   1:address:array:character <- copy [abc \[def]
 ]
 +parse:   ingredient: "abc [def": "literal-string"
 
 :(scenario string_literal_escaped_comment_aware)
-recipe main [
+def main [
   1:address:array:character <- copy [
 abc \\\[def]
 ]
 +parse:   ingredient: "\nabc \[def": "literal-string"
 
 :(scenario string_literal_and_comment)
-recipe main [
+def main [
   1:address:array:character <- copy [abc]  # comment
 ]
 +parse: --- defining main
@@ -207,14 +200,14 @@ recipe main [
 +parse:   product: 1: ("address" "array" "character")
 
 :(scenario string_literal_escapes_newlines_in_trace)
-recipe main [
+def main [
   copy [abc
 def]
 ]
 +parse:   ingredient: "abc\ndef": "literal-string"
 
 :(scenario string_literal_can_skip_past_comments)
-recipe main [
+def main [
   copy [
     # ']' inside comment
     bar
@@ -223,11 +216,10 @@ recipe main [
 +parse:   ingredient: "\n    # ']' inside comment\n    bar\n  ": "literal-string"
 
 :(scenario string_literal_empty)
-recipe main [
+def main [
   copy []
 ]
 +parse:   ingredient: "": "literal-string"
 
 
 
-
-- 
cgit 1.4.1-2-gfad0