summary refs log blame commit diff stats
path: root/INSTALL
blob: 8ba89921e59643f16564e9e9c806ffe1cd1ddac4 (plain) (tree) 
94c5d83e ^


f51bd48a ^

582f3519 ^

f51bd48a ^

582f3519 ^

3edc9f86 ^

94c5d83e ^

582f3519 ^


f51bd48a ^


7582555b ^



b06433bc ^


582f3519 ^

b06433bc ^

3edc9f86 ^

b06433bc ^

7582555b ^

84c49ab7 ^

1
2

3

4

5

6

7

8

9
10

11
12

13
14
15

16
17

18

19

20

21

22

23


          
 
                                                                   
 
                                       
                                                             
 

                 

 


            

                                                                      
 
                                                                            
                                                                                
                     
 
                                                              
Installing
==========

Use the package manager of your operating system to install ranger.

To install ranger manually, use either:
sudo ./setup.py install --optimize=1 --record=install_log.txt

or for short:
sudo make install


Uninstalling
============

Again, use your package manager to uninstall ranger.  No other way for
automatically removing ranger is supported!

However, if you installed ranger with the command above, all installed files
have been recorded to "install_log.txt".  This information can be used to remove
ranger by hand, e.g.:

cat install_log.txt | sed s/\^/\\// | xargs -d "\n" sudo rm --
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-12-11 14:29:47 +0000
an> ^ 
af023b32 ^

6808ff7d ^

a17f9186 ^

6808ff7d ^


9cfd925a ^

1ead3562 ^

15f79a66 ^

6808ff7d ^

15f79a66 ^





acc4792d ^

87196c34 ^

a2a20225 ^






87196c34 ^





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

65

66

67
68
69
70
71
72
73
74
75
76

77

78

79

80

81

82

83
84

85

86

87

88

89
90
91
92
93

94

95

96
97
98
99
100
101

102
103
104
105
106




                                                                              

                                                                             

                                                                          


                                                                             
 
                 
                                                
          

                                               
                                                               
 
                                                       
                                 

                                                                 


                                                
                  
                                            











                                                    
                                      
                                 




                         






                                                                      
                  

                        

                               
                
                                        


                                        
                           
                                            









                                                                        
                           
   
                        
                        
                
 

                                          
                                                 
          
                                                              
 




                      
                                                                                
 





                                           




                                                
// So far instructions can only contain linear lists of properties. Now we add
// support for more complex trees of properties in dilated reagents. This will
// come in handy later for expressing complex types, like "a dictionary from
// (address to array of charaters) to (list of numbers)".
//
// Type trees aren't as general as s-expressions even if they look like them:
// the first element of a type tree is always an atom, and it can never be
// dotted (right->right->right->...->right is always NULL).
//
// For now you can't use the simpler 'colon-based' representation inside type
// trees. Once you start typing parens, keep on typing parens.

:(scenarios load)
:(scenario dilated_reagent_with_nested_brackets)
def main [
  {1: number, foo: (bar (baz quux))} <- copy 34
]
+parse:   product: {1: "number", "foo": ("bar" ("baz" "quux"))}

:(before "End Parsing Dilated Reagent Property(value)")
value = parse_string_tree(value);
:(before "End Parsing Dilated Reagent Type Property(type_names)")
type_names = parse_string_tree(type_names);

:(code)
string_tree* parse_string_tree(string_tree* s) {
  assert(s->atom);
  if (!starts_with(s->value, "(")) return s;
  string_tree* result = parse_string_tree(s->value);
  delete s;
  return result;
}

string_tree* parse_string_tree(const string& s) {
  istringstream in(s);
  in >> std::noskipws;
  return parse_string_tree(in);
}

string_tree* parse_string_tree(istream& in) {
  skip_whitespace_but_not_newline(in);
  if (!has_data(in)) return NULL;
  if (in.peek() == ')') {
    in.get();
    return NULL;
  }
  if (in.peek() != '(') {
    string s = next_word(in);
    if (s.empty()) {
      assert(!has_data(in));
      raise << "incomplete string tree at end of file (0)\n" << end();
      return NULL;
    }
    string_tree* result = new string_tree(s);
    return result;
  }
  in.get();  // skip '('
  string_tree* result = NULL;
  string_tree** curr = &result;
  while (true) {
    skip_whitespace_but_not_newline(in);
    assert(has_data(in));
    if (in.peek() == ')') break;
    *curr = new string_tree(NULL, NULL);
    if (in.peek() == '(') {
      (*curr)->left = parse_string_tree(in);
    }
    else {
      string s = next_word(in);
      if (s.empty()) {
        assert(!has_data(in));
        raise << "incomplete string tree at end of file (1)\n" << end();
        return NULL;
      }
      (*curr)->left = new string_tree(s);
    }
    curr = &(*curr)->right;
  }
  in.get();  // skip ')'
  assert(*curr == NULL);
  return result;
}

:(scenario dilated_reagent_with_type_tree)
% Hide_errors = true;  // 'map' isn't defined yet
def main [
  {1: (foo (address array character) (bar number))} <- copy 34
]
# just to avoid errors
container foo [
]
container bar [
]
+parse:   product: {1: ("foo" ("address" "array" "character") ("bar" "number"))}

:(scenario dilated_empty_tree)
def main [
  {1: number, foo: ()} <- copy 34
]
+parse:   product: {1: "number", "foo": ()}

:(scenario dilated_singleton_tree)
def main [
  {1: number, foo: (bar)} <- copy 34
]
+parse:   product: {1: "number", "foo": ("bar")}
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-12-11 14:29:43 +0000