Merge branch 'main' into JsonType

# Conflicts:
#	examples/data/json_config.zc

1 files changed, 29 insertions, 29 deletions

diff --git a/std/json.zc b/std/json.zc
index 6c4a0da..e6a15cd 100644
--- a/std/json.zc
+++ b/std/json.zc
@@ -192,13 +192,13 @@ impl JsonValue {
     }
     
     fn array() -> JsonValue {
-        var v: Vec<JsonValue*>* = malloc(sizeof(Vec_JsonValuePtr));
+        let v: Vec<JsonValue*>* = malloc(sizeof(Vec_JsonValuePtr));
         *v = Vec_JsonValuePtr::new();
         return JsonValue { kind: JsonType::JSON_ARRAY(), string_val: 0, number_val: 0, bool_val: false, array_val: v, object_val: 0 };
     }
     
     fn object() -> JsonValue {
-        var m: Map<JsonValue*>* = malloc(sizeof(Map_JsonValuePtr));
+        let m: Map<JsonValue*>* = malloc(sizeof(Map_JsonValuePtr));
         *m = Map_JsonValuePtr::new();
         return JsonValue { kind: JsonType::JSON_OBJECT(), string_val: 0, number_val: 0, bool_val: false, array_val: 0, object_val: m };
     }
@@ -208,57 +208,57 @@ impl JsonValue {
     // ============================================
 
     fn null_ptr() -> JsonValue* {
-        var p: JsonValue* = malloc(sizeof(JsonValue));
+        let p: JsonValue* = malloc(sizeof(JsonValue));
         *p = JsonValue::null();
         return p;
     }
 
     fn bool_ptr(b: bool) -> JsonValue* {
-        var p: JsonValue* = malloc(sizeof(JsonValue));
+        let p: JsonValue* = malloc(sizeof(JsonValue));
         *p = JsonValue::bool(b);
         return p;
     }
 
     fn number_ptr(n: double) -> JsonValue* {
-        var p: JsonValue* = malloc(sizeof(JsonValue));
+        let p: JsonValue* = malloc(sizeof(JsonValue));
         *p = JsonValue::number(n);
         return p;
     }
 
     fn string_ptr(s: char*) -> JsonValue* {
-        var p: JsonValue* = malloc(sizeof(JsonValue));
+        let p: JsonValue* = malloc(sizeof(JsonValue));
         *p = JsonValue::string(s);
         return p;
     }
 
     fn array_ptr() -> JsonValue* {
-        var p: JsonValue* = malloc(sizeof(JsonValue));
+        let p: JsonValue* = malloc(sizeof(JsonValue));
         *p = JsonValue::array();
         return p;
     }
 
     fn object_ptr() -> JsonValue* {
-        var p: JsonValue* = malloc(sizeof(JsonValue));
+        let p: JsonValue* = malloc(sizeof(JsonValue));
         *p = JsonValue::object();
         return p;
     }
 
     fn push(self, val: JsonValue) {
         if (self.kind.tag != JsonType::JSON_ARRAY().tag) return;
-        var p: JsonValue* = malloc(sizeof(JsonValue));
+        let p: JsonValue* = malloc(sizeof(JsonValue));
         *p = val;
         self.array_val.push(p);
     }
     
     fn set(self, key: char*, val: JsonValue) {
         if (self.kind.tag != JsonType::JSON_OBJECT().tag) return;
-        var p: JsonValue* = malloc(sizeof(JsonValue));
+        let p: JsonValue* = malloc(sizeof(JsonValue));
         *p = val;
         self.object_val.put(key, p);
     }
     
     fn parse(json: char*) -> Result<JsonValue*> {
-        var result: JsonValue* = _json_do_parse(json);
+        let result: JsonValue* = _json_do_parse(json);
         if (result != NULL) {
             return Result<JsonValue*>::Ok(result);
         }
@@ -340,47 +340,47 @@ impl JsonValue {
     }
 
     fn get_string(self, key: char*) -> Option<char*> {
-        var opt = self.get(key);
+        let opt = self.get(key);
         if opt.is_none() {
             return Option<char*>::None();
         }
-        var val = opt.unwrap();
+        let val = opt.unwrap();
         return (*val).as_string();
     }
 
     fn get_int(self, key: char*) -> Option<int> {
-        var opt = self.get(key);
+        let opt = self.get(key);
         if opt.is_none() {
             return Option<int>::None();
         }
-        var val = opt.unwrap();
+        let val = opt.unwrap();
         return (*val).as_int();
     }
 
     fn get_float(self, key: char*) -> Option<double> {
-        var opt = self.get(key);
+        let opt = self.get(key);
         if opt.is_none() {
             return Option<double>::None();
         }
-        var val = opt.unwrap();
+        let val = opt.unwrap();
         return (*val).as_float();
     }
 
     fn get_bool(self, key: char*) -> Option<bool> {
-        var opt = self.get(key);
+        let opt = self.get(key);
         if opt.is_none() {
             return Option<bool>::None();
         }
-        var val = opt.unwrap();
+        let val = opt.unwrap();
         return (*val).as_bool();
     }
 
     fn get_object(self, key: char*) -> Option<JsonValue*> {
-        var opt = self.get(key);
+        let opt = self.get(key);
         if opt.is_none() {
             return Option<JsonValue*>::None();
         }
-        var val = opt.unwrap();
+        let val = opt.unwrap();
         if (*val).kind.tag == JsonType::JSON_OBJECT().tag {
             return Option<JsonValue*>::Some(val);
         }
@@ -388,11 +388,11 @@ impl JsonValue {
     }
 
     fn get_array(self, key: char*) -> Option<JsonValue*> {
-        var opt = self.get(key);
+        let opt = self.get(key);
         if opt.is_none() {
             return Option<JsonValue*>::None();
         }
-        var val = opt.unwrap();
+        let val = opt.unwrap();
         if (*val).kind.tag == JsonType::JSON_ARRAY().tag {
             return Option<JsonValue*>::Some(val);
         }
@@ -426,9 +426,9 @@ impl JsonValue {
     fn free(self) {
         if (self.kind.tag == JsonType::JSON_STRING().tag) free(self.string_val);
         if (self.kind.tag == JsonType::JSON_ARRAY().tag) {
-             var v: Vec<JsonValue*>* = self.array_val;
-             for (var i: usize = 0; i < v.length(); i = i + 1) {
-                 var item: JsonValue* = v.get(i);
+             let v: Vec<JsonValue*>* = self.array_val;
+             for (let i: usize = 0; i < v.length(); i = i + 1) {
+                 let item: JsonValue* = v.get(i);
                  item.free();
                  free(item);
              }
@@ -437,10 +437,10 @@ impl JsonValue {
              free(v);
         }
         if (self.kind.tag == JsonType::JSON_OBJECT().tag) {
-             var m: Map<JsonValue*>* = self.object_val;
-             for (var i: usize = 0; i < m.capacity(); i = i + 1) {
+             let m: Map<JsonValue*>* = self.object_val;
+             for (let i: usize = 0; i < m.capacity(); i = i + 1) {
                  if (m.is_slot_occupied(i)) {
-                     var child: JsonValue* = m.val_at(i);
+                     let child: JsonValue* = m.val_at(i);
                      child.free();
                      free(child);
                  }