summaryrefslogtreecommitdiff
path: root/src/runtime/c
diff options
context:
space:
mode:
Diffstat (limited to 'src/runtime/c')
-rw-r--r--src/runtime/c/gu/map.c47
-rw-r--r--src/runtime/c/gu/seq.c10
-rw-r--r--src/runtime/c/gu/seq.h7
-rw-r--r--src/runtime/c/gu/string.c399
-rw-r--r--src/runtime/c/gu/string.h46
-rw-r--r--src/runtime/c/pgf/data.c6
-rw-r--r--src/runtime/c/pgf/data.h2
-rw-r--r--src/runtime/c/pgf/expr.c87
-rw-r--r--src/runtime/c/pgf/expr.h4
-rw-r--r--src/runtime/c/pgf/graphviz.c6
-rw-r--r--src/runtime/c/pgf/jit.c4
-rw-r--r--src/runtime/c/pgf/lexer.c2
-rw-r--r--src/runtime/c/pgf/linearizer.c37
-rw-r--r--src/runtime/c/pgf/literals.c36
-rw-r--r--src/runtime/c/pgf/parser.c74
-rw-r--r--src/runtime/c/pgf/parseval.c2
-rw-r--r--src/runtime/c/pgf/pgf.c52
-rw-r--r--src/runtime/c/pgf/pgf.h2
-rw-r--r--src/runtime/c/pgf/reader.c93
-rw-r--r--src/runtime/c/pgf/reasoner.c8
-rw-r--r--src/runtime/c/utils/pgf-parse.c8
-rw-r--r--src/runtime/c/utils/pgf-service.c10
-rw-r--r--src/runtime/c/utils/pgf-translate.c12
23 files changed, 331 insertions, 623 deletions
diff --git a/src/runtime/c/gu/map.c b/src/runtime/c/gu/map.c
index ea045f82a..f01b0943a 100644
--- a/src/runtime/c/gu/map.c
+++ b/src/runtime/c/gu/map.c
@@ -4,11 +4,13 @@
#include <gu/map.h>
#include <gu/assert.h>
#include <gu/prime.h>
+#include <gu/string.h>
typedef enum {
GU_MAP_GENERIC,
GU_MAP_ADDR,
- GU_MAP_WORD
+ GU_MAP_WORD,
+ GU_MAP_STRING
} GuMapKind;
typedef struct GuMapData GuMapData;
@@ -66,6 +68,9 @@ gu_map_entry_is_free(GuMap* map, GuMapData* data, size_t idx)
} else if (map->kind == GU_MAP_WORD) {
GuWord key = ((GuWord*)data->keys)[idx];
return key == 0;
+ } else if (map->kind == GU_MAP_STRING) {
+ GuString key = ((GuString*)data->keys)[idx];
+ return key == NULL;
}
gu_assert(map->kind == GU_MAP_GENERIC);
const void* key = &data->keys[idx * map->key_size];
@@ -137,6 +142,27 @@ gu_map_lookup(GuMap* map, const void* key, size_t* idx_out)
gu_impossible();
break;
}
+ case GU_MAP_STRING: {
+ GuHasher* hasher = map->hasher;
+ GuEquality* eq = (GuEquality*) hasher;
+ GuHash hash = hasher->hash(hasher, key);
+ size_t idx = hash % n;
+ size_t offset = (hash % (n - 2)) + 1;
+ while (true) {
+ GuString entry_key =
+ ((GuString*)map->data.keys)[idx];
+ if (entry_key == NULL && map->data.zero_idx != idx) {
+ *idx_out = idx;
+ return false;
+ } else if (eq->is_equal(eq, key, entry_key)) {
+ *idx_out = idx;
+ return true;
+ }
+ idx = (idx + offset) % n;
+ }
+ gu_impossible();
+ break;
+ }
default:
gu_impossible();
}
@@ -179,6 +205,11 @@ gu_map_resize(GuMap* map)
((const void**)data->keys)[i] = NULL;
}
break;
+ case GU_MAP_STRING:
+ for (size_t i = 0; i < data->n_entries; i++) {
+ ((GuString*)data->keys)[i] = NULL;
+ }
+ break;
default:
gu_impossible();
}
@@ -195,6 +226,8 @@ gu_map_resize(GuMap* map)
void* old_key = &old_data.keys[i * key_size];
if (map->kind == GU_MAP_ADDR) {
old_key = *(void**)old_key;
+ } else if (map->kind == GU_MAP_STRING) {
+ old_key = (void*) *(GuString*)old_key;
}
void* old_value = &old_data.values[i * value_size];
@@ -268,6 +301,8 @@ gu_map_insert(GuMap* map, const void* key)
}
if (map->kind == GU_MAP_ADDR) {
((const void**)map->data.keys)[idx] = key;
+ } else if (map->kind == GU_MAP_STRING) {
+ ((GuString*)map->data.keys)[idx] = key;
} else {
memcpy(&map->data.keys[idx * map->key_size],
key, map->key_size);
@@ -296,6 +331,8 @@ gu_map_iter(GuMap* map, GuMapItor* itor, GuExn* err)
void* value = &map->data.values[i * map->value_size];
if (map->kind == GU_MAP_ADDR) {
key = *(const void* const*) key;
+ } else if (map->kind == GU_MAP_STRING) {
+ key = *(GuString*) key;
}
itor->fn(itor, key, value, err);
}
@@ -323,8 +360,10 @@ gu_map_enum_next(GuEnum* self, void* to, GuPool* pool)
en->x.value = &en->ht->data.values[i * en->ht->value_size];
if (en->ht->kind == GU_MAP_ADDR) {
en->x.key = *(const void* const*) en->x.key;
+ } else if (en->ht->kind == GU_MAP_STRING) {
+ en->x.key = *(GuString*) en->x.key;
}
-
+
*((GuMapKeyValue**) to) = &en->x;
break;
}
@@ -365,10 +404,12 @@ gu_make_map(size_t key_size, GuHasher* hasher,
GuMapKind kind =
((!hasher || hasher == gu_addr_hasher)
? GU_MAP_ADDR
+ : (hasher == gu_string_hasher)
+ ? GU_MAP_STRING
: (key_size == sizeof(GuWord) && hasher == gu_word_hasher)
? GU_MAP_WORD
: GU_MAP_GENERIC);
- if (kind == GU_MAP_ADDR) {
+ if (kind == GU_MAP_ADDR || kind == GU_MAP_STRING) {
key_size = sizeof(GuWord);
}
GuMapData data = {
diff --git a/src/runtime/c/gu/seq.c b/src/runtime/c/gu/seq.c
index 538ce0762..b798d2923 100644
--- a/src/runtime/c/gu/seq.c
+++ b/src/runtime/c/gu/seq.c
@@ -427,13 +427,3 @@ gu_buf_out(GuBuf* buf, GuPool* pool)
GU_DEFINE_KIND(GuSeq, GuOpaque);
GU_DEFINE_KIND(GuBuf, abstract);
-
-char*
-gu_char_buf_str(GuCharBuf* chars, GuPool* pool)
-{
- size_t len = gu_buf_length(chars);
- char* data = gu_buf_data(chars);
- char* str = gu_new_str(len, pool);
- memcpy(str, data, len);
- return str;
-}
diff --git a/src/runtime/c/gu/seq.h b/src/runtime/c/gu/seq.h
index 6bc050088..90c664271 100644
--- a/src/runtime/c/gu/seq.h
+++ b/src/runtime/c/gu/seq.h
@@ -135,13 +135,6 @@ gu_buf_heapify(GuBuf *buf, GuOrder *order);
GuSeq*
gu_buf_freeze(GuBuf* buf, GuPool* pool);
-
-typedef GuBuf GuCharBuf;
-typedef GuBuf GuByteBuf;
-
-char*
-gu_char_buf_str(GuCharBuf* chars, GuPool* pool);
-
#endif // GU_SEQ_H_
#if defined(GU_OUT_H_) && !defined(GU_SEQ_H_OUT_)
diff --git a/src/runtime/c/gu/string.c b/src/runtime/c/gu/string.c
index ba7eaf0c6..995812fbf 100644
--- a/src/runtime/c/gu/string.c
+++ b/src/runtime/c/gu/string.c
@@ -7,21 +7,17 @@
#include <gu/assert.h>
#include <stdlib.h>
-const GuString gu_empty_string = { 1 };
-
struct GuStringBuf {
- GuByteBuf* bbuf;
+ GuBuf* buf;
GuOut* out;
};
GuStringBuf*
gu_string_buf(GuPool* pool)
{
- GuBuf* buf = gu_new_buf(uint8_t, pool);
- GuOut* out = gu_buf_out(buf, pool);
GuStringBuf* sbuf = gu_new(GuStringBuf, pool);
- sbuf->bbuf = buf;
- sbuf->out = out;
+ sbuf->buf = gu_new_buf(char, pool);
+ sbuf->out = gu_buf_out(sbuf->buf, pool);
return sbuf;
}
@@ -31,176 +27,64 @@ gu_string_buf_out(GuStringBuf* sb)
return sb->out;
}
-static GuString
-gu_utf8_string(const uint8_t* buf, size_t sz, GuPool* pool)
-{
- if (sz < GU_MIN(sizeof(GuWord), 128)) {
- GuWord w = 0;
- for (size_t n = 0; n < sz; n++) {
- w = w << 8 | buf[n];
- }
- w = w << 8 | (sz << 1) | 1;
- return (GuString) { w };
- }
- uint8_t* p = NULL;
- if (sz < 256) {
- p = gu_malloc_aligned(pool, 1 + sz, 2);
- p[0] = (uint8_t) sz;
- } else {
- p = gu_malloc_prefixed(pool, gu_alignof(size_t),
- sizeof(size_t), 1, 1 + sz);
- ((size_t*) p)[-1] = sz;
- p[0] = 0;
- }
- memcpy(&p[1], buf, sz);
- return (GuString) { (GuWord) (void*) p };
-}
-
-
-
GuString
gu_string_buf_freeze(GuStringBuf* sb, GuPool* pool)
{
gu_out_flush(sb->out, NULL);
- uint8_t* data = gu_buf_data(sb->bbuf);
- size_t len = gu_buf_length(sb->bbuf);
- return gu_utf8_string(data, len, pool);
-}
-
-GuIn*
-gu_string_in(GuString s, GuPool* pool)
-{
- GuWord w = s.w_;
- uint8_t* buf = NULL;
- size_t len = 0;
- if (w & 1) {
- len = (w & 0xff) >> 1;
- buf = gu_new_n(uint8_t, len, pool);
- for (int i = len - 1; i >= 0; i--) {
- w >>= 8;
- buf[i] = w & 0xff;
- }
- } else {
- uint8_t* p = (void*) w;
- len = (p[0] == 0) ? ((size_t*) p)[-1] : p[0];
- buf = &p[1];
- }
- return gu_data_in(buf, len, pool);
-}
-
-static bool
-gu_string_is_long(GuString s)
-{
- return !(s.w_ & 1);
-}
-
-bool
-gu_string_is_stable(GuString s)
-{
- return !gu_string_is_long(s);
-}
+ char* data = gu_buf_data(sb->buf);
+ size_t len = gu_buf_length(sb->buf);
-static size_t
-gu_string_long_length(GuString s)
-{
- gu_assert(gu_string_is_long(s));
- uint8_t* p = (void*) s.w_;
- uint8_t len = p[0];
- if (len > 0) {
- return len;
- }
- return ((size_t*) p)[-1];
-}
+ char* p = gu_malloc_aligned(pool, len+1, 2);
+ memcpy(p, data, len);
+ p[len] = 0;
-size_t
-gu_string_length(GuString s)
-{
- if (gu_string_is_long(s)) {
- return gu_string_long_length(s);
- }
- return (s.w_ & 0xff) >> 1;
+ return p;
}
-static uint8_t*
-gu_string_long_data(GuString s)
+GuIn*
+gu_string_in(GuString s, GuPool* pool)
{
- gu_require(gu_string_is_long(s));
- uint8_t* p = (void*) s.w_;
- return &p[1];
+ return gu_data_in((uint8_t*) s, strlen(s), pool);
}
GuString
gu_string_copy(GuString string, GuPool* pool)
{
- if (gu_string_is_long(string)) {
- uint8_t* data = gu_string_long_data(string);
- size_t len = gu_string_long_length(string);
- return gu_utf8_string(data, len, pool);
- } else {
- return string;
- }
+ size_t len = strlen(string);
+ char* p = gu_malloc_aligned(pool, len+1, 2);
+ memcpy(p, string, len+1);
+ return p;
}
-
void
gu_string_write(GuString s, GuOut* out, GuExn* err)
{
- GuWord w = s.w_;
- uint8_t buf[sizeof(GuWord)];
- uint8_t* src;
- size_t sz;
- if (w & 1) {
- sz = (w & 0xff) >> 1;
- gu_assert(sz <= sizeof(GuWord));
- size_t i = sz;
- while (i > 0) {
- w >>= 8;
- buf[--i] = w & 0xff;
- }
- src = buf;
- } else {
- uint8_t* p = (void*) w;
- sz = (p[0] == 0) ? ((size_t*) p)[-1] : p[0];
- src = &p[1];
- }
- gu_out_bytes(out, src, sz, err);
+ gu_out_bytes(out, (uint8_t*) s, strlen(s), err);
}
GuString
gu_string_read(size_t len, GuPool* pool, GuIn* in, GuExn* err)
{
- uint8_t* buf = alloca(len*4);
- uint8_t* p = buf;
+ char* buf = alloca(len*6+1);
+ char* p = buf;
for (size_t i = 0; i < len; i++) {
- gu_in_utf8_buf(&p, in, err);
+ gu_in_utf8_buf((uint8_t**) &p, in, err);
}
- return gu_utf8_string(buf, p-buf, pool);
+ *p++ = 0;
+
+ p = gu_malloc_aligned(pool, p-buf, 2);
+ strcpy(p, buf);
+
+ return p;
}
GuString
gu_string_read_latin1(size_t len, GuPool* pool, GuIn* in, GuExn* err)
{
- if (len < GU_MIN(sizeof(GuWord), 128)) {
- GuWord w = 0;
- for (size_t n = 0; n < len; n++) {
- w = w << 8 | gu_in_u8(in, err);
- }
- w = w << 8 | (len << 1) | 1;
- return (GuString) { w };
- }
- uint8_t* p = NULL;
- if (len < 256) {
- p = gu_malloc_aligned(pool, 1 + len, 2);
- p[0] = (uint8_t) len;
- } else {
- p = gu_malloc_prefixed(pool, gu_alignof(size_t),
- sizeof(size_t), 1, 1 + len);
- ((size_t*) p)[-1] = len;
- p[0] = 0;
- }
-
- gu_in_bytes(in, &p[1], len, err);
- return (GuString) { (GuWord) (void*) p };
+ char* p = gu_malloc_aligned(pool, len+1, 2);
+ gu_in_bytes(in, (uint8_t*)p, len, err);
+ p[len] = 0;
+ return p;
}
GuString
@@ -226,52 +110,24 @@ gu_format_string(GuPool* pool, const char* fmt, ...)
return s;
}
-GuString
-gu_str_string(const char* str, GuPool* pool)
-{
- return gu_utf8_string((const uint8_t*) str, strlen(str), pool);
-}
-
bool
gu_string_to_int(GuString s, int *res)
{
- GuWord w = s.w_;
- uint8_t buf[sizeof(GuWord)];
- char* src;
- size_t sz;
- if (w & 1) {
- sz = (w & 0xff) >> 1;
- gu_assert(sz <= sizeof(GuWord));
- size_t i = sz;
- while (i > 0) {
- w >>= 8;
- buf[--i] = w & 0xff;
- }
- src = (char*) buf;
- } else {
- uint8_t* p = (void*) w;
- sz = (p[0] == 0) ? ((size_t*) p)[-1] : p[0];
- src = (char*) &p[1];
- }
-
- size_t i = 0;
-
bool neg = false;
-
- if (src[i] == '-') {
+ if (*s == '-') {
neg = true;
- i++;
+ s++;
}
- if (i >= sz)
+ if (*s == 0)
return false;
int n = 0;
- for (; i < sz; i++) {
- if (src[i] < '0' || src[i] > '9')
+ for (; *s; s++) {
+ if (*s < '0' || *s > '9')
return false;
- n = n * 10 + (src[i] - '0');
+ n = n * 10 + (*s - '0');
}
*res = neg ? -n : n;
@@ -281,54 +137,33 @@ gu_string_to_int(GuString s, int *res)
bool
gu_string_to_double(GuString s, double *res)
{
- GuWord w = s.w_;
- uint8_t buf[sizeof(GuWord)];
- char* src;
- size_t sz;
- if (w & 1) {
- sz = (w & 0xff) >> 1;
- gu_assert(sz <= sizeof(GuWord));
- size_t i = sz;
- while (i > 0) {
- w >>= 8;
- buf[--i] = w & 0xff;
- }
- src = (char*) buf;
- } else {
- uint8_t* p = (void*) w;
- sz = (p[0] == 0) ? ((size_t*) p)[-1] : p[0];
- src = (char*) &p[1];
- }
-
- size_t i = 0;
-
bool neg = false;
bool dec = false;
double exp = 1;
- if (src[i] == '-') {
+ if (*s == '-') {
neg = true;
- i++;
+ s++;
}
- if (i >= sz)
+ if (*s == 0)
return false;
double d = 0;
- for (; i < sz; i++) {
- if (src[i] == '.') {
+ for (; *s; s++) {
+ if (*s == '.') {
if (dec) return false;
dec = true;
continue;
}
- if (src[i] < '0' || src[i] > '9')
+ if (*s < '0' || *s > '9')
return false;
if (dec) exp = exp * 10;
- d = d * 10 + (src[i] - '0');
+ d = d * 10 + (*s - '0');
}
*res = (neg ? -d : d) / exp;
@@ -338,54 +173,18 @@ gu_string_to_double(GuString s, double *res)
bool
gu_string_is_prefix(GuString s1, GuString s2)
{
- GuWord w1 = s1.w_;
- uint8_t buf1[sizeof(GuWord)];
- size_t sz1;
- char* str1;
- if (w1 & 1) {
- sz1 = (w1 & 0xff) >> 1;
- gu_assert(sz1 <= sizeof(GuWord));
- size_t i = sz1;
- while (i > 0) {
- w1 >>= 8;
- buf1[--i] = w1 & 0xff;
- }
- str1 = (char*) buf1;
- } else {
- uint8_t* p = (void*) w1;
- sz1 = (p[0] == 0) ? ((size_t*) p)[-1] : p[0];
- str1 = (char*) &p[1];
- }
+ size_t len1 = strlen(s1);
+ size_t len2 = strlen(s2);
- GuWord w2 = s2.w_;
- uint8_t buf2[sizeof(GuWord)];
- size_t sz2;
- char* str2;
- if (w2 & 1) {
- sz2 = (w2 & 0xff) >> 1;
- gu_assert(sz2 <= sizeof(GuWord));
- size_t i = sz2;
- while (i > 0) {
- w2 >>= 8;
- buf2[--i] = w2 & 0xff;
- }
- str2 = (char*) buf2;
- } else {
- uint8_t* p = (void*) w2;
- sz2 = (p[0] == 0) ? ((size_t*) p)[-1] : p[0];
- str2 = (char*) &p[1];
- }
-
-
- if (sz1 > sz2)
+ if (len1 > len2)
return false;
- for (size_t sz = sz1; sz--; sz > 0) {
- if (*str1 != *str2)
+ for (size_t len = len1; len--; len > 0) {
+ if (*s1 != *s2)
return false;
-
- str1++;
- str2++;
+
+ s1++;
+ s2++;
}
return true;
@@ -394,108 +193,23 @@ gu_string_is_prefix(GuString s1, GuString s2)
GuHash
gu_string_hash(GuHash h, GuString s)
{
- if (s.w_ & 1) {
- return h*101 + s.w_;
- }
- size_t len = gu_string_length(s);
- uint8_t* data = gu_string_long_data(s);
- return gu_hash_bytes(h, data, len);
-}
-
-bool
-gu_string_eq(GuString s1, GuString s2)
-{
- if (s1.w_ == s2.w_) {
- return true;
- } else if (gu_string_is_long(s1) && gu_string_is_long(s2)) {
- size_t len1 = gu_string_long_length(s1);
- size_t len2 = gu_string_long_length(s2);
- if (len1 != len2) {
- return false;
- }
- uint8_t* data1 = gu_string_long_data(s1);
- uint8_t* data2 = gu_string_long_data(s2);
- return (memcmp(data1, data2, len1) == 0);
- }
- return false;
-
+ return gu_hash_bytes(h, (uint8_t*)s, strlen(s));
}
static bool
gu_string_eq_fn(GuEquality* self, const void* p1, const void* p2)
{
(void) self;
- const GuString* sp1 = p1;
- const GuString* sp2 = p2;
- return gu_string_eq(*sp1, *sp2);
+ return strcmp((GuString) p1, (GuString) p2) == 0;
}
GuEquality gu_string_equality[1] = { { gu_string_eq_fn } };
-int
-gu_string_cmp(GuString s1, GuString s2)
-{
- uint8_t buf1[sizeof(GuWord)];
- char* src1;
- size_t sz1;
- if (s1.w_ & 1) {
- sz1 = (s1.w_ & 0xff) >> 1;
- gu_assert(sz1 <= sizeof(GuWord));
- size_t i = sz1;
- while (i > 0) {
- s1.w_ >>= 8;
- buf1[--i] = s1.w_ & 0xff;
- }
- src1 = (char*) buf1;
- } else {
- uint8_t* p = (void*) s1.w_;
- sz1 = (p[0] == 0) ? ((size_t*) p)[-1] : p[0];
- src1 = (char*) &p[1];
- }
-
- uint8_t buf2[sizeof(GuWord)];
- char* src2;
- size_t sz2;
- if (s2.w_ & 1) {
- sz2 = (s2.w_ & 0xff) >> 1;
- gu_assert(sz2 <= sizeof(GuWord));
- size_t i = sz2;
- while (i > 0) {
- s2.w_ >>= 8;
- buf2[--i] = s2.w_ & 0xff;
- }
- src2 = (char*) buf2;
- } else {
- uint8_t* p = (void*) s2.w_;
- sz2 = (p[0] == 0) ? ((size_t*) p)[-1] : p[0];
- src2 = (char*) &p[1];
- }
-
- for (size_t i = 0; ; i++) {
- if (sz1 == i && i == sz2)
- break;
-
- if (sz1 <= i)
- return -1;
- if (i >= sz2)
- return 1;
-
- if (src1[i] > src2[i])
- return 1;
- else if (src1[i] < src2[i])
- return -1;
- }
-
- return 0;
-}
-
static int
gu_string_cmp_fn(GuOrder* self, const void* p1, const void* p2)
{
(void) self;
- const GuString* sp1 = p1;
- const GuString* sp2 = p2;
- return gu_string_cmp(*sp1, *sp2);
+ return strcmp((GuString) p1, (GuString) p2);
}
GuOrder gu_string_order[1] = { { gu_string_cmp_fn } };
@@ -504,8 +218,7 @@ static GuHash
gu_string_hasher_hash(GuHasher* self, const void* p)
{
(void) self;
- const GuString* sp = p;
- return gu_string_hash(0, *sp);
+ return gu_string_hash(0, (GuString) p);
}
GuHasher gu_string_hasher[1] = {
@@ -516,5 +229,5 @@ GuHasher gu_string_hasher[1] = {
};
-GU_DEFINE_TYPE(GuString, GuOpaque, _);
+GU_DEFINE_KIND(GuString, pointer);
GU_DEFINE_KIND(GuStringMap, GuMap);
diff --git a/src/runtime/c/gu/string.h b/src/runtime/c/gu/string.h
index 8f6f035a1..46244b96c 100644
--- a/src/runtime/c/gu/string.h
+++ b/src/runtime/c/gu/string.h
@@ -1,22 +1,3 @@
-/*
- * Copyright 2011 University of Helsinki.
- *
- * This file is part of libgu.
- *
- * Libgu is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * Libgu 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 Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with libgu. If not, see <http://www.gnu.org/licenses/>.
- */
-
#ifndef GU_STRING_H_
#define GU_STRING_H_
@@ -24,9 +5,7 @@
#include <gu/in.h>
#include <gu/out.h>
-typedef GuOpaque() GuString;
-
-extern const GuString gu_empty_string;
+typedef const char* GuString;
GuString
gu_string_copy(GuString string, GuPool* pool);
@@ -43,12 +22,6 @@ gu_string_read_latin1(size_t len, GuPool* pool, GuIn* in, GuExn* err);
GuIn*
gu_string_in(GuString string, GuPool* pool);
-bool
-gu_string_is_stable(GuString string);
-
-GuString
-gu_ucs_string(const GuUCS* ubuf, size_t len, GuPool* pool);
-
typedef struct GuStringBuf GuStringBuf;
GuStringBuf*
@@ -66,34 +39,21 @@ gu_format_string_v(const char* fmt, va_list args, GuPool* pool);
GuString
gu_format_string(GuPool* pool, const char* fmt, ...);
-GuString
-gu_str_string(const char* str, GuPool* pool);
-
bool
gu_string_to_int(GuString s, int *res);
bool
gu_string_to_double(GuString s, double *res);
-
bool
gu_string_is_prefix(GuString s1, GuString s2);
-size_t
-gu_string_length(GuString s);
-
#endif // GU_STRING_H_
#if defined(GU_FUN_H_) && !defined(GU_STRING_H_FUN_)
#define GU_STRING_H_FUN_
-bool
-gu_string_eq(GuString s1, GuString s2);
-
extern GuEquality gu_string_equality[1];
-int
-gu_string_cmp(GuString s1, GuString s2);
-
extern GuOrder gu_string_order[1];
#endif
@@ -110,7 +70,7 @@ extern GuHasher gu_string_hasher[1];
# ifndef GU_STRING_H_TYPE_
# define GU_STRING_H_TYPE_
-extern GU_DECLARE_TYPE(GuString, GuOpaque);
+extern GU_DECLARE_KIND(GuString);
# endif
# if defined(GU_MAP_H_TYPE_) && !defined(GU_STRING_H_MAP_TYPE_)
@@ -132,8 +92,6 @@ typedef GuType_GuMap GuType_GuStringMap;
#define GU_STRING_H_SEQ_
typedef GuSeq GuStrings;
-// typedef GuBuf GuStringBuf;
-
#endif
diff --git a/src/runtime/c/pgf/data.c b/src/runtime/c/pgf/data.c
index 905857e1b..79cd3e8a2 100644
--- a/src/runtime/c/pgf/data.c
+++ b/src/runtime/c/pgf/data.c
@@ -15,7 +15,7 @@ pgf_tokens_equal(PgfTokens* t1, PgfTokens* t2)
for (size_t i = 0; i < len1; i++) {
GuString s1 = gu_seq_get(t1, PgfToken, i);
GuString s2 = gu_seq_get(t2, PgfToken, i);
- if (!gu_string_eq(s1, s2)) {
+ if (strcmp(s1, s2) != 0) {
return false;
}
}
@@ -51,7 +51,9 @@ GU_DEFINE_TYPE(PgfMetaChildMap, GuMap,
GU_DEFINE_TYPE(PgfAbsCat, abstract);
+static GuString empty_string = "";
+
GU_DEFINE_TYPE(
- PgfPrintNames, PgfCIdMap, gu_type(GuString), &gu_empty_string);
+ PgfPrintNames, PgfCIdMap, gu_type(GuString), &empty_string);
GU_DEFINE_TYPE(PgfConcr, abstract);
diff --git a/src/runtime/c/pgf/data.h b/src/runtime/c/pgf/data.h
index f4513d240..2562af651 100644
--- a/src/runtime/c/pgf/data.h
+++ b/src/runtime/c/pgf/data.h
@@ -190,7 +190,7 @@ typedef struct {
typedef PgfSymbolIdx PgfSymbolCat, PgfSymbolLit, PgfSymbolVar;
typedef struct {
- PgfToken token;
+ char token[0]; // a flexible array that contains the token
} PgfSymbolKS;
typedef struct PgfSymbolKP
diff --git a/src/runtime/c/pgf/expr.c b/src/runtime/c/pgf/expr.c
index d7f23c207..12cbe8e47 100644
--- a/src/runtime/c/pgf/expr.c
+++ b/src/runtime/c/pgf/expr.c
@@ -152,7 +152,7 @@ struct PgfExprParser {
GuPool* expr_pool;
GuPool* tmp_pool;
PGF_TOKEN_TAG token_tag;
- GuCharBuf* token_value;
+ GuBuf* token_value;
int ch;
};
@@ -232,7 +232,7 @@ pgf_expr_parser_token(PgfExprParser* parser)
parser->token_tag = PGF_TOKEN_WILD;
break;
default: {
- GuCharBuf* chars = gu_new_buf(char, parser->tmp_pool);
+ GuBuf* chars = gu_new_buf(char, parser->tmp_pool);
if (isalpha(parser->ch)) {
while (isalnum(parser->ch) ||
@@ -241,6 +241,7 @@ pgf_expr_parser_token(PgfExprParser* parser)
gu_buf_push(chars, char, parser->ch);
pgf_expr_parser_getc(parser);
}
+ gu_buf_push(chars, char, 0);
parser->token_tag = PGF_TOKEN_IDENT;
parser->token_value = chars;
} else if (isdigit(parser->ch)) {
@@ -257,9 +258,11 @@ pgf_expr_parser_token(PgfExprParser* parser)
gu_buf_push(chars, char, parser->ch);
pgf_expr_parser_getc(parser);
}
+ gu_buf_push(chars, char, 0);
parser->token_tag = PGF_TOKEN_FLT;
parser->token_value = chars;
} else {
+ gu_buf_push(chars, char, 0);
parser->token_tag = PGF_TOKEN_INT;
parser->token_value = chars;
}
@@ -273,6 +276,7 @@ pgf_expr_parser_token(PgfExprParser* parser)
if (parser->ch == '"') {
pgf_expr_parser_getc(parser);
+ gu_buf_push(chars, char, 0);
parser->token_tag = PGF_TOKEN_STR;
parser->token_value = chars;
}
@@ -341,18 +345,20 @@ pgf_expr_parser_term(PgfExprParser* parser)
0);
}
case PGF_TOKEN_IDENT: {
- char* str =
- gu_char_buf_str(parser->token_value, parser->tmp_pool);
- PgfCId id = gu_str_string(str, parser->expr_pool);
+ PgfCId id = gu_buf_data(parser->token_value);
pgf_expr_parser_token(parser);
- return gu_new_variant_i(parser->expr_pool,
- PGF_EXPR_FUN,
- PgfExprFun,
- id);
+ PgfExpr e;
+ PgfExprFun* fun =
+ gu_new_flex_variant(PGF_EXPR_FUN,
+ PgfExprFun,
+ fun, strlen(id)+1,
+ &e, parser->expr_pool);
+ strcpy(fun->fun, id);
+ return e;
}
case PGF_TOKEN_INT: {
char* str =
- gu_char_buf_str(parser->token_value, parser->tmp_pool);
+ gu_buf_data(parser->token_value);
int n = atoi(str);
pgf_expr_parser_token(parser);
PgfLiteral lit =
@@ -367,22 +373,23 @@ pgf_expr_parser_term(PgfExprParser* parser)
}
case PGF_TOKEN_STR: {
char* str =
- gu_char_buf_str(parser->token_value, parser->tmp_pool);
- GuString s = gu_str_string(str, parser->expr_pool);
+ gu_buf_data(parser->token_value);
pgf_expr_parser_token(parser);
- PgfLiteral lit =
- gu_new_variant_i(parser->expr_pool,
- PGF_LITERAL_STR,
- PgfLiteralStr,
- s);
+ PgfLiteral lit;
+ PgfLiteralStr* plit =
+ gu_new_flex_variant(PGF_LITERAL_STR,
+ PgfLiteralStr,
+ val, strlen(str)+1,
+ &lit, parser->expr_pool);
+ strcpy(plit->val, str);
return gu_new_variant_i(parser->expr_pool,
- PGF_EXPR_LIT,
- PgfExprLit,
- lit);
+ PGF_EXPR_LIT,
+ PgfExprLit,
+ lit);
}
case PGF_TOKEN_FLT: {
char* str =
- gu_char_buf_str(parser->token_value, parser->tmp_pool);
+ gu_buf_data(parser->token_value);
double d = atof(str);
pgf_expr_parser_token(parser);
PgfLiteral lit =
@@ -442,12 +449,11 @@ pgf_expr_parser_bind(PgfExprParser* parser, GuBuf* binds)
for (;;) {
if (parser->token_tag == PGF_TOKEN_IDENT) {
- char* str =
- gu_char_buf_str(parser->token_value, parser->tmp_pool);
- var = gu_str_string(str, parser->expr_pool);
+ var =
+ gu_string_copy(gu_buf_data(parser->token_value), parser->expr_pool);
pgf_expr_parser_token(parser);
} else if (parser->token_tag == PGF_TOKEN_WILD) {
- var = gu_str_string("_", parser->expr_pool);
+ var = "_";
pgf_expr_parser_token(parser);
} else {
return false;
@@ -562,12 +568,11 @@ pgf_expr_parser_hypos(PgfExprParser* parser, GuBuf* hypos)
}
if (parser->token_tag == PGF_TOKEN_IDENT) {
- char* str =
- gu_char_buf_str(parser->token_value, parser->tmp_pool);
- var = gu_str_string(str, parser->expr_pool);
+ var =
+ gu_string_copy(gu_buf_data(parser->token_value), parser->expr_pool);
pgf_expr_parser_token(parser);
} else if (parser->token_tag == PGF_TOKEN_WILD) {
- var = gu_str_string("_", parser->expr_pool);
+ var = "_";
pgf_expr_parser_token(parser);
} else {
return false;
@@ -603,9 +608,8 @@ pgf_expr_parser_atom(PgfExprParser* parser)
if (parser->token_tag != PGF_TOKEN_IDENT)
return NULL;
- char* str =
- gu_char_buf_str(parser->token_value, parser->tmp_pool);
- PgfCId cid = gu_str_string(str, parser->expr_pool);
+ PgfCId cid =
+ gu_string_copy(gu_buf_data(parser->token_value), parser->expr_pool);
pgf_expr_parser_token(parser);
GuBuf* args = gu_new_buf(PgfExpr, parser->tmp_pool);
@@ -663,7 +667,7 @@ pgf_expr_parser_type(PgfExprParser* parser)
} else {
PgfHypo* hypo = gu_buf_extend(hypos);
hypo->bind_type = PGF_BIND_TYPE_EXPLICIT;
- hypo->cid = gu_str_string("_", parser->expr_pool);
+ hypo->cid = "_";
hypo->type = NULL;
}
@@ -699,7 +703,7 @@ pgf_expr_parser_type(PgfExprParser* parser)
PgfHypo* hypo = gu_buf_extend(hypos);
hypo->bind_type = PGF_BIND_TYPE_EXPLICIT;
- hypo->cid = gu_str_string("_", parser->expr_pool);
+ hypo->cid = "_";
hypo->type = type;
}
}
@@ -761,7 +765,7 @@ pgf_literal_eq(PgfLiteral lit1, PgfLiteral lit2)
case PGF_LITERAL_STR: {
PgfLiteralStr* lit1 = ei1.data;
PgfLiteralStr* lit2 = ei2.data;
- return gu_string_eq(lit1->val, lit2->val);
+ return strcmp(lit1->val, lit2->val) == 0;
}
case PGF_LITERAL_INT: {
PgfLiteralInt* lit1 = ei1.data;
@@ -793,7 +797,7 @@ pgf_expr_eq(PgfExpr e1, PgfExpr e2)
case PGF_EXPR_ABS: {
PgfExprAbs* abs1 = ei1.data;
PgfExprAbs* abs2 = ei2.data;
- return gu_string_eq(abs1->id, abs2->id) &&
+ return strcmp(abs1->id, abs2->id) == 0 &&
pgf_expr_eq(abs1->body, abs2->body);
}
case PGF_EXPR_APP: {
@@ -815,7 +819,7 @@ pgf_expr_eq(PgfExpr e1, PgfExpr e2)
case PGF_EXPR_FUN: {
PgfExprFun* fun1 = ei1.data;
PgfExprFun* fun2 = ei2.data;
- return gu_string_eq(fun1->fun, fun2->fun);
+ return strcmp(fun1->fun, fun2->fun) == 0;
}
case PGF_EXPR_VAR: {
PgfExprVar* var1 = ei1.data;
@@ -1076,9 +1080,8 @@ pgf_print_hypo(PgfHypo *hypo, PgfPrintContext* ctxt, int prec,
gu_puts(")", out, err);
} else {
GuPool* tmp_pool = gu_new_pool();
- GuString tmp = gu_str_string("_", tmp_pool);
-
- if (!gu_string_eq(hypo->cid, tmp)) {
+
+ if (strcmp(hypo->cid, "_") != 0) {
gu_puts("(", out, err);
gu_string_write(hypo->cid, out, err);
gu_puts(" : ", out, err);
@@ -1158,14 +1161,14 @@ pgf_type_eq(PgfType* t1, PgfType* t2)
if (hypo1->bind_type != hypo2->bind_type)
return false;
- if (!gu_string_eq(hypo1->cid, hypo2->cid))
+ if (strcmp(hypo1->cid, hypo2->cid) != 0)
return false;
if (!pgf_type_eq(hypo1->type, hypo2->type))
return false;
}
- if (!gu_string_eq(t1->cid, t2->cid))
+ if (strcmp(t1->cid, t2->cid) != 0)
return false;
if (t1->n_exprs != t2->n_exprs)
diff --git a/src/runtime/c/pgf/expr.h b/src/runtime/c/pgf/expr.h
index 08200a716..dffe5ac27 100644
--- a/src/runtime/c/pgf/expr.h
+++ b/src/runtime/c/pgf/expr.h
@@ -37,7 +37,7 @@ typedef enum {
} PgfLiteralTag;
typedef struct {
- GuString val;
+ char val[0]; // a flexible array that contains the value
} PgfLiteralStr;
typedef struct {
@@ -102,7 +102,7 @@ typedef struct {
} PgfExprMeta;
typedef struct {
- PgfCId fun;
+ char fun[0];
} PgfExprFun;
typedef struct {
diff --git a/src/runtime/c/pgf/graphviz.c b/src/runtime/c/pgf/graphviz.c
index e17d658b4..5bf270003 100644
--- a/src/runtime/c/pgf/graphviz.c
+++ b/src/runtime/c/pgf/graphviz.c
@@ -112,7 +112,6 @@ typedef struct {
size_t level;
GuBuf* internals;
GuBuf* leaves;
- GuString wildcard;
} PgfBracketLznState;
static void
@@ -167,7 +166,7 @@ pgf_bracket_lzn_begin_phrase(PgfLinFuncs** funcs, PgfCId cat, int fid, int linde
{
PgfBracketLznState* state = gu_container(funcs, PgfBracketLznState, funcs);
- if (gu_string_eq(cat, state->wildcard))
+ if (strcmp(cat, "_") == 0)
return;
state->level++;
@@ -203,7 +202,7 @@ pgf_bracket_lzn_end_phrase(PgfLinFuncs** funcs, PgfCId cat, int fid, int lindex,
{
PgfBracketLznState* state = gu_container(funcs, PgfBracketLznState, funcs);
- if (gu_string_eq(cat, state->wildcard))
+ if (strcmp(cat, "_") == 0)
return;
state->level--;
@@ -281,7 +280,6 @@ pgf_graphviz_parse_tree(PgfConcr* concr, PgfExpr expr, GuOut* out, GuExn* err)
state.level = -1;
state.internals = gu_new_buf(GuBuf*, tmp_pool);
state.leaves = gu_new_buf(PgfParseNode*, tmp_pool);
- state.wildcard = gu_str_string("_", tmp_pool);
pgf_lzr_linearize(concr, ctree, 0, &state.funcs);
size_t len = gu_buf_length(state.internals);
diff --git a/src/runtime/c/pgf/jit.c b/src/runtime/c/pgf/jit.c
index edb2ec97b..901ab66b1 100644
--- a/src/runtime/c/pgf/jit.c
+++ b/src/runtime/c/pgf/jit.c
@@ -201,7 +201,7 @@ pgf_jit_predicate(PgfJitState* state, PgfCIdMap* abscats,
// call the predicate for the category in hypo->type->cid
PgfAbsCat* arg =
- gu_map_get(abscats, &hypo->type->cid, PgfAbsCat*);
+ gu_map_get(abscats, hypo->type->cid, PgfAbsCat*);
#ifdef PGF_JIT_DEBUG
gu_puts(" CALL ", wtr, err);
@@ -314,7 +314,7 @@ pgf_jit_done(PgfJitState* state, PgfAbstr* abstr)
PgfCallPatch* patch =
gu_buf_index(state->patches, PgfCallPatch, i);
PgfAbsCat* arg =
- gu_map_get(abstr->cats, &patch->cid, PgfAbsCat*);
+ gu_map_get(abstr->cats, patch->cid, PgfAbsCat*);
gu_assert(arg != NULL);
jit_patch_calli(patch->ref,(jit_insn*) arg->predicate);
diff --git a/src/runtime/c/pgf/lexer.c b/src/runtime/c/pgf/lexer.c
index 48ab6eb70..dda0bf6e0 100644
--- a/src/runtime/c/pgf/lexer.c
+++ b/src/runtime/c/pgf/lexer.c
@@ -108,7 +108,7 @@ pgf_new_simple_lexer(GuIn *in, GuPool *pool)
{
PgfSimpleLexer* lexer = gu_new(PgfSimpleLexer, pool);
lexer->base.read_token = pgf_simple_lexer_read_token;
- lexer->base.tok = gu_empty_string;
+ lexer->base.tok = "";
lexer->in = in;
lexer->pool = pool;
lexer->ucs = ' ';
diff --git a/src/runtime/c/pgf/linearizer.c b/src/runtime/c/pgf/linearizer.c
index 4bb8e9153..aa47bd825 100644
--- a/src/runtime/c/pgf/linearizer.c
+++ b/src/runtime/c/pgf/linearizer.c
@@ -45,12 +45,12 @@ pgf_lzr_index(PgfConcr* concr,
case PGF_PRODUCTION_APPLY: {
PgfProductionApply* papply = data;
PgfCncOverloadMap* overl_table =
- gu_map_get(concr->fun_indices, &papply->fun->absfun->name,
+ gu_map_get(concr->fun_indices, papply->fun->absfun->name,
PgfCncOverloadMap*);
if (!overl_table) {
overl_table = gu_map_type_new(PgfCncOverloadMap, pool);
gu_map_put(concr->fun_indices,
- &papply->fun->absfun->name, PgfCncOverloadMap*, overl_table);
+ papply->fun->absfun->name, PgfCncOverloadMap*, overl_table);
}
pgf_lzr_add_overl_entry(overl_table, ccat, papply, pool);
break;
@@ -227,11 +227,12 @@ pgf_lzn_resolve_def(PgfLzn* lzn, PgfCncFuns* lindefs, GuString s, GuPool* pool)
PgfCncTreeLit,
&lit, pool);
clit->fid = lzn->fid++;
- clit->lit =
- gu_new_variant_i(pool,
- PGF_LITERAL_STR,
- PgfLiteralStr,
- s);
+ PgfLiteralStr* lit_str =
+ gu_new_flex_variant(PGF_LITERAL_STR,
+ PgfLiteralStr,
+ val, strlen(s),
+ &clit->lit, pool);
+ strcpy((char*) lit_str->val, (char*) s);
if (lindefs == NULL)
return lit;
@@ -322,8 +323,7 @@ pgf_lzn_resolve(PgfLzn* lzn, PgfExpr expr, PgfCCat* ccat, GuPool* pool)
goto done;
}
- GuString s = gu_str_string("?", pool);
- ret = pgf_lzn_resolve_def(lzn, ccat->lindefs, s, pool);
+ ret = pgf_lzn_resolve_def(lzn, ccat->lindefs, "?", pool);
goto done;
}
}
@@ -331,7 +331,7 @@ pgf_lzn_resolve(PgfLzn* lzn, PgfExpr expr, PgfCCat* ccat, GuPool* pool)
PgfExprFun* efun = i.data;
PgfCncOverloadMap* overl_table =
- gu_map_get(lzn->concr->fun_indices, &efun->fun, PgfCncOverloadMap*);
+ gu_map_get(lzn->concr->fun_indices, efun->fun, PgfCncOverloadMap*);
if (overl_table == NULL) {
if (ccat != NULL && ccat->lindefs == NULL) {
goto done;
@@ -345,7 +345,7 @@ pgf_lzn_resolve(PgfLzn* lzn, PgfExpr expr, PgfCCat* ccat, GuPool* pool)
gu_putc('[', out, err);
gu_string_write(efun->fun, out, err);
gu_putc(']', out, err);
- GuString s = gu_string_buf_freeze(sbuf, pool);
+ GuString s = gu_string_buf_freeze(sbuf, tmp_pool);
if (ccat != NULL) {
ret = pgf_lzn_resolve_def(lzn, ccat->lindefs, s, pool);
@@ -356,10 +356,11 @@ pgf_lzn_resolve(PgfLzn* lzn, PgfExpr expr, PgfCCat* ccat, GuPool* pool)
&ret, pool);
clit->fid = lzn->fid++;
PgfLiteralStr* lit =
- gu_new_variant(PGF_LITERAL_STR,
- PgfLiteralStr,
- &clit->lit, pool);
- lit->val = s;
+ gu_new_flex_variant(PGF_LITERAL_STR,
+ PgfLiteralStr,
+ val, strlen(s)+1,
+ &clit->lit, pool);
+ strcpy(lit->val, s);
}
gu_pool_free(tmp_pool);
@@ -557,7 +558,7 @@ pgf_lzr_linearize(PgfConcr* concr, PgfCncTree ctree, size_t lin_idx, PgfLinFuncs
if (fns->begin_phrase) {
fns->begin_phrase(fnsp,
cat, flit->fid, 0,
- gu_empty_string);
+ "");
}
if (fns->expr_literal) {
@@ -567,7 +568,7 @@ pgf_lzr_linearize(PgfConcr* concr, PgfCncTree ctree, size_t lin_idx, PgfLinFuncs
if (fns->end_phrase) {
fns->end_phrase(fnsp,
cat, flit->fid, 0,
- gu_empty_string);
+ "");
}
break;
@@ -697,7 +698,7 @@ pgf_get_tokens(PgfSequence* seq, uint16_t seq_idx, GuPool* pool)
pgf_lzr_linearize_sequence(NULL, NULL, seq, seq_idx, &flin.funcs);
GuString tokens = gu_ok(err) ? gu_string_buf_freeze(sbuf, pool)
- : gu_empty_string;
+ : "";
gu_pool_free(tmp_pool);
diff --git a/src/runtime/c/pgf/literals.c b/src/runtime/c/pgf/literals.c
index 7e0c664c6..ad8d900cc 100644
--- a/src/runtime/c/pgf/literals.c
+++ b/src/runtime/c/pgf/literals.c
@@ -39,10 +39,11 @@ pgf_match_string_lit(PgfConcr* concr, PgfItem* item, PgfToken tok,
PgfExprLit,
&ep->expr, pool);
PgfLiteralStr *lit_str =
- gu_new_variant(PGF_LITERAL_STR,
- PgfLiteralStr,
- &expr_lit->lit, pool);
- lit_str->val = sks->token;
+ gu_new_flex_variant(PGF_LITERAL_STR,
+ PgfLiteralStr,
+ val, strlen(sks->token)+1,
+ &expr_lit->lit, pool);
+ strcpy(lit_str->val, sks->token);
*out_ep = ep;
accepted = false;
@@ -185,12 +186,10 @@ pgf_match_name_lit(PgfConcr* concr, PgfItem* item, PgfToken tok,
GuExn* err = gu_new_exn(NULL, gu_kind(type), tmp_pool);
- GuString hyp = gu_str_string("-", tmp_pool);
-
bool iscap = false;
- if (gu_string_eq(tok, hyp)) {
+ if (strcmp(tok, "-") == 0) {
iscap = true;
- } else if (!gu_string_eq(tok, gu_empty_string)) {
+ } else if (*tok) {
GuIn* in = gu_string_in(tok, tmp_pool);
iscap = iswupper(gu_in_utf8(in, err));
}
@@ -218,21 +217,24 @@ pgf_match_name_lit(PgfConcr* concr, PgfItem* item, PgfToken tok,
gu_new_variant(PGF_EXPR_APP,
PgfExprApp,
&ep->expr, pool);
+ GuString con = "MkSymb";
PgfExprFun *expr_fun =
- gu_new_variant(PGF_EXPR_FUN,
- PgfExprFun,
- &expr_app->fun, pool);
- expr_fun->fun = gu_str_string("MkSymb", pool);
+ gu_new_flex_variant(PGF_EXPR_FUN,
+ PgfExprFun,
+ fun, strlen(con)+1,
+ &expr_app->fun, pool);
+ strcpy(expr_fun->fun, con);
PgfExprLit *expr_lit =
gu_new_variant(PGF_EXPR_LIT,
PgfExprLit,
&expr_app->arg, pool);
+ GuString val = gu_string_buf_freeze(sbuf, tmp_pool);
PgfLiteralStr *lit_str =
- gu_new_variant(PGF_LITERAL_STR,
- PgfLiteralStr,
- &expr_lit->lit, pool);
- lit_str->val = gu_string_buf_freeze(sbuf, pool);
-
+ gu_new_flex_variant(PGF_LITERAL_STR,
+ PgfLiteralStr,
+ val, strlen(val)+1,
+ &expr_lit->lit, pool);
+ strcpy(lit_str->val, val);
*out_ep = ep;
} else {
*out_ep = NULL;
diff --git a/src/runtime/c/pgf/parser.c b/src/runtime/c/pgf/parser.c
index c83873b5e..69ecc093b 100644
--- a/src/runtime/c/pgf/parser.c
+++ b/src/runtime/c/pgf/parser.c
@@ -145,24 +145,7 @@ GU_DEFINE_TYPE(PgfLeftcornerTokIdx, GuStringMap,
static PgfSymbol
pgf_prev_extern_sym(PgfSymbol sym)
{
- GuVariantInfo i = gu_variant_open(sym);
- switch (i.tag) {
- case PGF_SYMBOL_CAT:
- return *((PgfSymbol*) (((PgfSymbolCat*) i.data)+1));
- case PGF_SYMBOL_KP:
- return *((PgfSymbol*) (((PgfSymbolKP*) i.data)+1));
- case PGF_SYMBOL_KS:
- return *((PgfSymbol*) (((PgfSymbolKS*) i.data)+1));
- case PGF_SYMBOL_LIT:
- return *((PgfSymbol*) (((PgfSymbolLit*) i.data)+1));
- case PGF_SYMBOL_VAR:
- return *((PgfSymbol*) (((PgfSymbolVar*) i.data)+1));
- case PGF_SYMBOL_NE:
- return *((PgfSymbol*) (((PgfSymbolNE*) i.data)+1));
- default:
- gu_impossible();
- return gu_null_variant;
- }
+ return *(((PgfSymbol*) gu_variant_data(sym))-1);
}
size_t
@@ -1126,19 +1109,19 @@ pgf_parsing_meta_scan(PgfParseState* before, PgfParseState* after,
PgfItem* meta_item, prob_t meta_prob)
{
PgfToken tok = after->ts->fn->get_token(after->ts);
-
- if (!gu_string_eq(tok, gu_empty_string)) {
+
+ if (*tok == 0) {
PgfItem* item = pgf_item_copy(meta_item, before->ps->pool, before->ps);
item->inside_prob += meta_prob;
PgfSymbol prev = item->curr_sym;
PgfSymbolKS* sks = (PgfSymbolKS*)
gu_alloc_variant(PGF_SYMBOL_KS,
- sizeof(PgfSymbolKS)+sizeof(PgfSymbol),
+ sizeof(PgfSymbol)+sizeof(PgfSymbolKS)+strlen(tok)+1,
gu_alignof(PgfSymbolKS),
&item->curr_sym, after->ps->pool);
- *((PgfSymbol*)(sks+1)) = prev;
- sks->token = tok;
+ *(((PgfSymbol*) sks)-1) = prev;
+ strcpy((char*) sks->token, (char*) tok);
gu_buf_heap_push(before->agenda, &pgf_item_prob_order, &item);
}
@@ -1162,7 +1145,7 @@ pgf_parsing_meta_predict(GuMapItor* fn, const void* key, void* value, GuExn* err
PgfItem* meta_item = clo->meta_item;
PgfCncCat* cnccat =
- gu_map_get(state->ps->concr->cnccats, &abscat->name, PgfCncCat*);
+ gu_map_get(state->ps->concr->cnccats, abscat->name, PgfCncCat*);
if (cnccat == NULL)
return;
@@ -1193,7 +1176,7 @@ pgf_parsing_meta_predict(GuMapItor* fn, const void* key, void* value, GuExn* err
sizeof(PgfSymbolCat)+sizeof(PgfSymbol),
gu_alignof(PgfSymbolCat),
&item->curr_sym, state->ps->pool);
- *((PgfSymbol*)(scat+1)) = prev;
+ *(((PgfSymbol*)scat)-1) = prev;
scat->d = nargs;
scat->r = lin_idx;
@@ -1342,6 +1325,10 @@ pgf_parsing_symbol(PgfParseState* before, PgfParseState* after,
pgf_item_free(before, after, item);
break;
}
+ case PGF_SYMBOL_BIND: {
+ pgf_item_free(before, after, item);
+ break;
+ }
default:
gu_impossible();
}
@@ -1412,7 +1399,7 @@ pgf_parsing_item(PgfParseState* before, PgfParseState* after, PgfItem* item)
} else {
PgfToken tok = (after != NULL)
? after->ts->fn->get_token(after->ts)
- : gu_empty_string;
+ : "";
PgfExprProb *ep = NULL;
bool accepted =
@@ -1428,11 +1415,11 @@ pgf_parsing_item(PgfParseState* before, PgfParseState* after, PgfItem* item)
PgfSymbol prev = item->curr_sym;
PgfSymbolKS* sks = (PgfSymbolKS*)
gu_alloc_variant(PGF_SYMBOL_KS,
- sizeof(PgfSymbolKS)+sizeof(PgfSymbol),
+ sizeof(PgfSymbol)+sizeof(PgfSymbolKS)+strlen(tok)+1,
gu_alignof(PgfSymbolKS),
&item->curr_sym, after->ps->pool);
- *((PgfSymbol*)(sks+1)) = prev;
- sks->token = tok;
+ *(((PgfSymbol*) sks)-1) = prev;
+ strcpy((char*) sks->token, (char*) tok);
item->seq_idx++;
pgf_parsing_add_transition(before, after, tok, item);
@@ -1546,9 +1533,7 @@ pgf_parsing_proceed(PgfParseState* state)
static prob_t
pgf_parsing_default_beam_size(PgfConcr* concr)
{
- GuPool* tmp_pool = gu_new_pool();
- PgfCId flag_name = gu_str_string("beam_size", tmp_pool);
- PgfLiteral lit = gu_map_get(concr->cflags, &flag_name, PgfLiteral);
+ PgfLiteral lit = gu_map_get(concr->cflags, "beam_size", PgfLiteral);
if (gu_variant_is_null(lit))
return 0;
@@ -1677,7 +1662,7 @@ typedef struct {
static bool
pgf_real_match_token(PgfTokenState* ts, PgfToken tok, PgfItem* item)
{
- return gu_string_eq(gu_container(ts, PgfRealTokenState, ts)->tok, tok);
+ return strcmp(gu_container(ts, PgfRealTokenState, ts)->tok, tok) == 0;
}
static PgfToken
@@ -1707,7 +1692,7 @@ pgf_parser_next_state(PgfParseState* prev, PgfToken tok)
pgf_new_token_state(PgfRealTokenState, prev->ps->pool);
ts->tok = tok;
ts->lexicon_idx = gu_map_get(prev->ps->concr->leftcorner_tok_idx,
- &tok, PgfProductionIdx*);
+ tok, PgfProductionIdx*);
if (ts->lexicon_idx != NULL) {
PgfLexiconFn clo = { { pgf_parser_compute_lexicon_prob }, &ts->ts };
gu_map_iter(ts->lexicon_idx, &clo.fn, NULL);
@@ -1758,7 +1743,7 @@ pgf_prefix_match_token(PgfTokenState* ts0, PgfToken tok, PgfItem* item)
static PgfToken
pgf_prefix_get_token(PgfTokenState* ts) {
- return gu_empty_string;
+ return "";
}
static PgfProductionIdx*
@@ -2165,7 +2150,7 @@ pgf_parser_init_state(PgfConcr* concr, PgfCId cat, size_t lin_idx,
GuPool* pool, GuPool* out_pool)
{
PgfCncCat* cnccat =
- gu_map_get(concr->cnccats, &cat, PgfCncCat*);
+ gu_map_get(concr->cnccats, cat, PgfCncCat*);
if (!cnccat)
return NULL;
@@ -2226,7 +2211,7 @@ pgf_parser_add_literal(PgfConcr *concr, PgfCId cat,
PgfLiteralCallback* callback)
{
PgfCncCat* cnccat =
- gu_map_get(concr->cnccats, &cat, PgfCncCat*);
+ gu_map_get(concr->cnccats, cat, PgfCncCat*);
if (cnccat == NULL)
return;
@@ -2281,7 +2266,7 @@ pgf_morpho_iter(GuMapItor* fn, const void* key, void* value, GuExn* err)
PgfToken tok1 = symks->token;
PgfToken tok2 = gu_seq_get(clo->tokens, PgfToken, pos++);
- if (!gu_string_eq(tok1, tok2))
+ if (strcmp(tok1, tok2) != 0)
goto cont;
}
default:
@@ -2320,7 +2305,7 @@ pgf_lookup_morpho(PgfConcr *concr, PgfLexer *lexer,
}
PgfProductionIdx* lexicon_idx =
- gu_map_get(concr->leftcorner_tok_idx, &tok, PgfProductionIdx*);
+ gu_map_get(concr->leftcorner_tok_idx, tok, PgfProductionIdx*);
if (lexicon_idx == NULL) {
gu_pool_free(tmp_pool);
return;
@@ -2374,10 +2359,10 @@ pgf_fullform_iter(GuMapItor* fn, const void* key, void* value, GuExn* err)
// create a new production index with keys that
// are multiword units
PgfProductionIdx* lexicon_idx =
- gu_map_get(st->new_idx, &tokens, PgfProductionIdx*);
+ gu_map_get(st->new_idx, tokens, PgfProductionIdx*);
if (lexicon_idx == NULL) {
lexicon_idx = gu_map_type_new(PgfProductionIdx, st->pool);
- gu_map_put(st->new_idx, &tokens, PgfProductionIdx*, lexicon_idx);
+ gu_map_put(st->new_idx, tokens, PgfProductionIdx*, lexicon_idx);
}
PgfProductionBuf* prods =
@@ -2443,7 +2428,7 @@ pgf_fullform_lexicon(PgfConcr *concr, GuPool* pool)
GuString
pgf_fullform_get_string(PgfFullFormEntry* entry)
{
- return *((GuString*) entry->key);
+ return (GuString) entry->key;
}
void
@@ -2462,10 +2447,10 @@ pgf_parser_index_token(PgfConcr* concr,
GuPool *pool)
{
PgfProductionIdx* set =
- gu_map_get(concr->leftcorner_tok_idx, &tok, PgfProductionIdx*);
+ gu_map_get(concr->leftcorner_tok_idx, tok, PgfProductionIdx*);
if (set == NULL) {
set = gu_map_type_new(PgfProductionIdx, pool);
- gu_map_put(concr->leftcorner_tok_idx, &tok, PgfProductionIdx*, set);
+ gu_map_put(concr->leftcorner_tok_idx, tok, PgfProductionIdx*, set);
}
PgfCFCat cfc = {ccat, lin_idx};
@@ -2527,6 +2512,7 @@ pgf_parser_index_symbol(PgfConcr* concr, PgfSymbol sym,
case PGF_SYMBOL_CAT:
case PGF_SYMBOL_LIT:
case PGF_SYMBOL_NE:
+ case PGF_SYMBOL_BIND:
case PGF_SYMBOL_VAR:
// Nothing to be done here
break;
diff --git a/src/runtime/c/pgf/parseval.c b/src/runtime/c/pgf/parseval.c
index 8b38d252d..ebd52d4ce 100644
--- a/src/runtime/c/pgf/parseval.c
+++ b/src/runtime/c/pgf/parseval.c
@@ -111,7 +111,7 @@ pgf_metrics_lzn_end_phrase2(PgfLinFuncs** funcs, PgfCId cat, int fid, int lin_id
if (phrase->start == start &&
phrase->end == end &&
- gu_string_eq(phrase->cat, cat) &&
+ strcmp(phrase->cat, cat) == 0 &&
phrase->lin_idx == lin_idx) {
state->matches++;
break;
diff --git a/src/runtime/c/pgf/pgf.c b/src/runtime/c/pgf/pgf.c
index 13195c33e..a1eb62c95 100644
--- a/src/runtime/c/pgf/pgf.c
+++ b/src/runtime/c/pgf/pgf.c
@@ -49,30 +49,28 @@ pgf_load_meta_child_probs(PgfPGF* pgf, const char* fpath,
GuPool* tmp_pool = gu_new_pool();
for (;;) {
- char cat1_s[21];
- char cat2_s[21];
+ char cat1[21];
+ char cat2[21];
prob_t prob;
- if (fscanf(fp, "%20s\t%20s\t%f", cat1_s, cat2_s, &prob) < 3)
+ if (fscanf(fp, "%20s\t%20s\t%f", cat1, cat2, &prob) < 3)
break;
prob = - log(prob);
- GuString cat1 = gu_str_string(cat1_s, tmp_pool);
PgfAbsCat* abscat1 =
- gu_map_get(pgf->abstract.cats, &cat1, PgfAbsCat*);
+ gu_map_get(pgf->abstract.cats, cat1, PgfAbsCat*);
if (abscat1 == NULL) {
gu_raise(err, PgfExn);
goto close;
}
- if (strcmp(cat2_s, "*") == 0) {
+ if (strcmp(cat2, "*") == 0) {
abscat1->meta_prob = prob;
- } else if (strcmp(cat2_s, "_") == 0) {
+ } else if (strcmp(cat2, "_") == 0) {
abscat1->meta_token_prob = prob;
} else {
- GuString cat2 = gu_str_string(cat2_s, tmp_pool);
- PgfAbsCat* abscat2 = gu_map_get(pgf->abstract.cats, &cat2, PgfAbsCat*);
+ PgfAbsCat* abscat2 = gu_map_get(pgf->abstract.cats, cat2, PgfAbsCat*);
if (abscat2 == NULL) {
gu_raise(err, PgfExn);
goto close;
@@ -107,7 +105,7 @@ pgf_iter_languages(PgfPGF* pgf, GuMapItor* fn, GuExn* err)
PgfConcr*
pgf_get_language(PgfPGF* pgf, PgfCId lang)
{
- return gu_map_get(pgf->concretes, &lang, PgfConcr*);
+ return gu_map_get(pgf->concretes, lang, PgfConcr*);
}
GuString
@@ -123,16 +121,13 @@ pgf_iter_categories(PgfPGF* pgf, GuMapItor* fn, GuExn* err)
}
PgfCId
-pgf_start_cat(PgfPGF* pgf, GuPool* pool)
+pgf_start_cat(PgfPGF* pgf)
{
- GuPool* tmp_pool = gu_local_pool();
-
- GuString s = gu_str_string("startcat", tmp_pool);
PgfLiteral lit =
- gu_map_get(pgf->abstract.aflags, &s, PgfLiteral);
+ gu_map_get(pgf->abstract.aflags, "startcat", PgfLiteral);
if (gu_variant_is_null(lit))
- return gu_str_string("S", pool);
+ return "S";
GuVariantInfo i = gu_variant_open(lit);
switch (i.tag) {
@@ -142,20 +137,17 @@ pgf_start_cat(PgfPGF* pgf, GuPool* pool)
}
}
- return gu_str_string("S", pool);
+ return "S";
}
GuString
pgf_language_code(PgfConcr* concr)
{
- GuPool* tmp_pool = gu_local_pool();
-
- GuString s = gu_str_string("language", tmp_pool);
PgfLiteral lit =
- gu_map_get(concr->cflags, &s, PgfLiteral);
+ gu_map_get(concr->cflags, "language", PgfLiteral);
if (gu_variant_is_null(lit))
- return gu_empty_string;
+ return "";
GuVariantInfo i = gu_variant_open(lit);
switch (i.tag) {
@@ -165,7 +157,7 @@ pgf_language_code(PgfConcr* concr)
}
}
- return gu_empty_string;
+ return "";
}
void
@@ -188,8 +180,8 @@ pgf_filter_by_cat(GuMapItor* fn, const void* key, void* value, GuExn* err)
PgfFunByCatIter* clo = (PgfFunByCatIter*) fn;
PgfAbsFun* absfun = *((PgfAbsFun**) value);
- if (gu_string_eq(absfun->type->cid, clo->catname)) {
- clo->client_fn->fn(clo->client_fn, &absfun->name, NULL, err);
+ if (strcmp(absfun->type->cid, clo->catname) == 0) {
+ clo->client_fn->fn(clo->client_fn, absfun->name, NULL, err);
}
}
@@ -205,10 +197,10 @@ PgfType*
pgf_function_type(PgfPGF* pgf, PgfCId funname)
{
PgfAbsFun* absfun =
- gu_map_get(pgf->abstract.funs, &funname, PgfAbsFun*);
+ gu_map_get(pgf->abstract.funs, funname, PgfAbsFun*);
if (absfun == NULL)
return NULL;
-
+
return absfun->type;
}
@@ -216,8 +208,8 @@ GuString
pgf_print_name(PgfConcr* concr, PgfCId id)
{
PgfCId name =
- gu_map_get(concr->printnames, &id, PgfCId);
- if (gu_string_eq(name, gu_empty_string))
+ gu_map_get(concr->printnames, id, PgfCId);
+ if (*name == 0)
name = id;
return name;
}
@@ -226,7 +218,7 @@ void
pgf_linearize(PgfConcr* concr, PgfExpr expr, GuOut* out, GuExn* err)
{
GuPool* tmp_pool = gu_local_pool();
-
+
GuEnum* cts =
pgf_lzr_concretize(concr, expr, tmp_pool);
PgfCncTree ctree = gu_next(cts, PgfCncTree, tmp_pool);
diff --git a/src/runtime/c/pgf/pgf.h b/src/runtime/c/pgf/pgf.h
index 9a88cebff..9c95f6f90 100644
--- a/src/runtime/c/pgf/pgf.h
+++ b/src/runtime/c/pgf/pgf.h
@@ -102,7 +102,7 @@ void
pgf_iter_categories(PgfPGF* pgf, GuMapItor* fn, GuExn* err);
PgfCId
-pgf_start_cat(PgfPGF* pgf, GuPool* pool);
+pgf_start_cat(PgfPGF* pgf);
void
pgf_iter_functions(PgfPGF* pgf, GuMapItor* fn, GuExn* err);
diff --git a/src/runtime/c/pgf/reader.c b/src/runtime/c/pgf/reader.c
index ebc5050e4..9f08662e3 100644
--- a/src/runtime/c/pgf/reader.c
+++ b/src/runtime/c/pgf/reader.c
@@ -13,7 +13,7 @@
#include <gu/exn.h>
#include <gu/utf8.h>
#include <math.h>
-#include <stdio.h>
+#include <stdlib.h>
//
// PgfReader
@@ -116,11 +116,21 @@ pgf_read_literal(PgfReader* rdr)
uint8_t tag = pgf_read_tag(rdr);
switch (tag) {
case PGF_LITERAL_STR: {
+ GuLength len = pgf_read_len(rdr);
+ uint8_t* buf = alloca(len*6+1);
+ uint8_t* p = buf;
+ for (size_t i = 0; i < len; i++) {
+ gu_in_utf8_buf(&p, rdr->in, rdr->err);
+ gu_return_on_exn(rdr->err, gu_null_variant);
+ }
+ *p++ = 0;
+
PgfLiteralStr *lit_str =
- gu_new_variant(PGF_LITERAL_STR,
- PgfLiteralStr,
- &lit, rdr->opool);
- lit_str->val = pgf_read_string(rdr);
+ gu_new_flex_variant(PGF_LITERAL_STR,
+ PgfLiteralStr,
+ val, p-buf,
+ &lit, rdr->opool);
+ strcpy((char*) lit_str->val, (char*) buf);
break;
}
case PGF_LITERAL_INT: {
@@ -160,7 +170,7 @@ pgf_read_flags(PgfReader* rdr)
PgfLiteral value = pgf_read_literal(rdr);
gu_return_on_exn(rdr->err, NULL);
- gu_map_put(flags, &name, PgfLiteral, value);
+ gu_map_put(flags, name, PgfLiteral, value);
}
return flags;
@@ -224,11 +234,16 @@ pgf_read_expr_(PgfReader* rdr)
break;
}
case PGF_EXPR_FUN: {
+ size_t len = pgf_read_len(rdr);
+
PgfExprFun *efun =
- gu_new_variant(PGF_EXPR_FUN,
- PgfExprFun,
- &expr, rdr->opool);
- efun->fun = pgf_read_cid(rdr, rdr->opool);
+ gu_new_flex_variant(PGF_EXPR_FUN,
+ PgfExprFun,
+ fun, len+1,
+ &expr, rdr->opool);
+ gu_in_bytes(rdr->in, (uint8_t*)efun->fun, len, rdr->err);
+ efun->fun[len] = 0;
+
gu_return_on_exn(rdr->err, gu_null_variant);
break;
}
@@ -403,7 +418,17 @@ pgf_read_absfun(PgfReader* rdr)
{
PgfAbsFun* absfun = gu_new(PgfAbsFun, rdr->opool);
- absfun->name = pgf_read_cid(rdr, rdr->opool);
+ size_t len = pgf_read_len(rdr);
+
+ PgfExprFun *efun =
+ gu_new_flex_variant(PGF_EXPR_FUN,
+ PgfExprFun,
+ fun, len+1,
+ &absfun->ep.expr, rdr->opool);
+ gu_in_bytes(rdr->in, (uint8_t*)efun->fun, len, rdr->err);
+ efun->fun[len] = 0;
+ absfun->name = efun->fun;
+
gu_return_on_exn(rdr->err, NULL);
absfun->type = pgf_read_type_(rdr);
@@ -449,12 +474,6 @@ pgf_read_absfun(PgfReader* rdr)
absfun->ep.prob = - log(gu_in_f64be(rdr->in, rdr->err));
- PgfExprFun* expr_fun =
- gu_new_variant(PGF_EXPR_FUN,
- PgfExprFun,
- &absfun->ep.expr, rdr->opool);
- expr_fun->fun = absfun->name;
-
return absfun;
}
@@ -474,7 +493,7 @@ pgf_read_absfuns(PgfReader* rdr)
PgfAbsFun* absfun = pgf_read_absfun(rdr);
gu_return_on_exn(rdr->err, NULL);
- gu_map_put(absfuns, &absfun->name, PgfAbsFun*, absfun);
+ gu_map_put(absfuns, absfun->name, PgfAbsFun*, absfun);
}
return absfuns;
@@ -514,7 +533,8 @@ pgf_read_abscat(PgfReader* rdr, PgfAbstr* abstr, PgfCIdMap* abscats)
gu_return_on_exn(rdr->err, NULL);
PgfAbsFun* absfun =
- gu_map_get(abstr->funs, &name, PgfAbsFun*);
+ gu_map_get(abstr->funs, name, PgfAbsFun*);
+ assert(absfun != NULL);
gu_buf_push(functions, PgfAbsFun*, absfun);
}
@@ -539,7 +559,7 @@ pgf_read_abscats(PgfReader* rdr, PgfAbstr* abstr)
PgfAbsCat* abscat = pgf_read_abscat(rdr, abstr, abscats);
gu_return_on_exn(rdr->err, NULL);
- gu_map_put(abscats, &abscat->name, PgfAbsCat*, abscat);
+ gu_map_put(abscats, abscat->name, PgfAbsCat*, abscat);
}
return abscats;
@@ -567,7 +587,7 @@ pgf_read_printnames(PgfReader* rdr)
GuMapType* map_type = (GuMapType*)
GU_TYPE_LIT(GuStringMap, _,
gu_type(GuString),
- &gu_empty_string);
+ &"");
PgfCIdMap* printnames = gu_map_type_make(map_type, rdr->opool);
size_t len = pgf_read_len(rdr);
@@ -580,7 +600,7 @@ pgf_read_printnames(PgfReader* rdr)
GuString printname = pgf_read_string(rdr);
gu_return_on_exn(rdr->err, NULL);
- gu_map_put(printnames, &name, GuString, printname);
+ gu_map_put(printnames, name, GuString, printname);
}
return printnames;
@@ -654,12 +674,21 @@ pgf_read_symbol(PgfReader* rdr)
break;
}
case PGF_SYMBOL_KS: {
+ GuLength len = pgf_read_len(rdr);
+ uint8_t* buf = alloca(len*6+1);
+ uint8_t* p = buf;
+ for (size_t i = 0; i < len; i++) {
+ gu_in_utf8_buf(&p, rdr->in, rdr->err);
+ gu_return_on_exn(rdr->err, gu_null_variant);
+ }
+ *p++ = 0;
+
PgfSymbolKS *sym_ks =
- gu_new_variant(PGF_SYMBOL_KS,
- PgfSymbolKS,
- &sym, rdr->opool);
- sym_ks->token = pgf_read_string(rdr);
- gu_return_on_exn(rdr->err, gu_null_variant);
+ gu_new_flex_variant(PGF_SYMBOL_KS,
+ PgfSymbolKS,
+ token, p-buf,
+ &sym, rdr->opool);
+ strcpy((char*) sym_ks->token, (char*) buf);
break;
}
case PGF_SYMBOL_KP: {
@@ -747,7 +776,7 @@ pgf_read_cncfun(PgfReader* rdr, PgfAbstr* abstr, PgfConcr* concr, int funid)
gu_return_on_exn(rdr->err, NULL);
PgfAbsFun* absfun =
- gu_map_get(abstr->funs, &name, PgfAbsFun*);
+ gu_map_get(abstr->funs, name, PgfAbsFun*);
PgfCncFun* cncfun = gu_new_flex(rdr->opool, PgfCncFun, lins, len);
cncfun->absfun = absfun;
@@ -956,7 +985,7 @@ pgf_read_cnccat(PgfReader* rdr, PgfAbstr* abstr, PgfConcr* concr, PgfCId name)
gu_malloc(rdr->opool, sizeof(PgfCncCat)+n_lins*sizeof(GuString));
cnccat->abscat =
- gu_map_get(abstr->cats, &name, PgfAbsCat*);
+ gu_map_get(abstr->cats, name, PgfAbsCat*);
gu_assert(cnccat->abscat != NULL);
int len = last + 1 - first;
@@ -1011,7 +1040,7 @@ pgf_read_cnccats(PgfReader* rdr, PgfAbstr* abstr, PgfConcr* concr)
pgf_read_cnccat(rdr, abstr, concr, name);
gu_return_on_exn(rdr->err, NULL);
- gu_map_put(cnccats, &name, PgfCncCat*, cnccat);
+ gu_map_put(cnccats, name, PgfCncCat*, cnccat);
}
return cnccats;
@@ -1100,7 +1129,7 @@ pgf_read_concrete(PgfReader* rdr, PgfAbstr* abstr)
pgf_read_cid(rdr, rdr->opool);
gu_return_on_exn(rdr->err, NULL);
- concr->cflags =
+ concr->cflags =
pgf_read_flags(rdr);
gu_return_on_exn(rdr->err, NULL);
@@ -1150,7 +1179,7 @@ pgf_read_concretes(PgfReader* rdr, PgfAbstr* abstr)
PgfConcr* concr = pgf_read_concrete(rdr, abstr);
gu_return_on_exn(rdr->err, NULL);
- gu_map_put(concretes, &concr->name, PgfConcr*, concr);
+ gu_map_put(concretes, concr->name, PgfConcr*, concr);
}
return concretes;
diff --git a/src/runtime/c/pgf/reasoner.c b/src/runtime/c/pgf/reasoner.c
index c308dac9a..7cb4380cf 100644
--- a/src/runtime/c/pgf/reasoner.c
+++ b/src/runtime/c/pgf/reasoner.c
@@ -230,14 +230,14 @@ pgf_reasoner_try_first(PgfReasoner* rs, PgfExprState* parent, PgfAbsFun* absfun)
{
PgfCId cat = absfun->type->cid;
- PgfAnswers* answers = gu_map_get(rs->table, &cat, PgfAnswers*);
+ PgfAnswers* answers = gu_map_get(rs->table, cat, PgfAnswers*);
if (answers == NULL) {
answers = gu_new(PgfAnswers, rs->tmp_pool);
answers->parents = gu_new_buf(PgfExprState*, rs->tmp_pool);
answers->exprs = gu_new_buf(PgfExprProb*, rs->tmp_pool);
answers->outside_prob = parent->base.prob;
- gu_map_put(rs->table, &cat, PgfAnswers*, answers);
+ gu_map_put(rs->table, cat, PgfAnswers*, answers);
}
gu_buf_push(answers->parents, PgfExprState*, parent);
@@ -397,9 +397,9 @@ pgf_generate_all(PgfPGF* pgf, PgfCId cat, GuPool* pool)
answers->parents = gu_new_buf(PgfExprState*, rs->tmp_pool);
answers->exprs = rs->exprs;
answers->outside_prob = 0;
- gu_map_put(rs->table, &cat, PgfAnswers*, answers);
+ gu_map_put(rs->table, cat, PgfAnswers*, answers);
- PgfAbsCat* abscat = gu_map_get(rs->abstract->cats, &cat, PgfAbsCat*);
+ PgfAbsCat* abscat = gu_map_get(rs->abstract->cats, cat, PgfAbsCat*);
if (abscat != NULL) {
((PgfPredicate) abscat->predicate)(rs, NULL);
}
diff --git a/src/runtime/c/utils/pgf-parse.c b/src/runtime/c/utils/pgf-parse.c
index 692fec31e..2790e49de 100644
--- a/src/runtime/c/utils/pgf-parse.c
+++ b/src/runtime/c/utils/pgf-parse.c
@@ -28,8 +28,8 @@ int main(int argc, char* argv[]) {
goto fail;
}
char* filename = argv[1];
- GuString cat = gu_str_string(argv[2], pool);
- GuString lang = gu_str_string(argv[3], pool);
+ GuString cat = argv[2];
+ GuString lang = argv[3];
double heuristics = 0.95;
if (argc == 5) {
@@ -61,7 +61,7 @@ int main(int argc, char* argv[]) {
}
/* // Register a callback for the literal category Symbol */
- /* pgf_parser_add_literal(from_concr, gu_str_string("Symb", pool), */
+ /* pgf_parser_add_literal(from_concr, "Symb", */
/* &pgf_nerc_literal_callback); */
clock_t end = clock();
@@ -110,7 +110,7 @@ int main(int argc, char* argv[]) {
clock_t start = clock();
- GuIn *in = gu_string_in(gu_str_string(line, ppool), ppool);
+ GuIn *in = gu_string_in(line, ppool);
PgfLexer *lexer = pgf_new_simple_lexer(in, ppool);
GuEnum* result = pgf_parse_with_heuristics(concr, cat, lexer, heuristics, ppool, ppool);
diff --git a/src/runtime/c/utils/pgf-service.c b/src/runtime/c/utils/pgf-service.c
index 36b781a3f..f63b17f9f 100644
--- a/src/runtime/c/utils/pgf-service.c
+++ b/src/runtime/c/utils/pgf-service.c
@@ -200,8 +200,8 @@ int main ()
goto fail;
}
- GuString cat = gu_str_string("Phr", pool);
- GuString from_lang = gu_str_string("ParseEng", pool);
+ GuString cat = "Phr";
+ GuString from_lang = "ParseEng";
PgfConcr* from_concr =
pgf_get_language(pgf, from_lang);
if (!from_concr) {
@@ -210,7 +210,7 @@ int main ()
}
// Register a callback for the literal category Symbol
- pgf_parser_add_literal(from_concr, gu_str_string("Symb", pool),
+ pgf_parser_add_literal(from_concr, "Symb",
&pgf_nerc_literal_callback);
while (FCGI_Accept() >= 0) {
@@ -233,7 +233,7 @@ int main ()
PgfConcr* to_concr = NULL;
if (strlen(to_lang_buf) > 0) {
- GuString to_lang = gu_str_string(to_lang_buf, ppool);
+ GuString to_lang = to_lang_buf;
to_concr =
pgf_get_language(pgf, to_lang);
if (!to_concr) {
@@ -248,7 +248,7 @@ int main ()
sentence[len+1] = '\0';
GuReader *rdr =
- gu_string_reader(gu_str_string(sentence, ppool), ppool);
+ gu_string_reader(sentence, ppool);
PgfLexer *lexer =
pgf_new_simple_lexer(rdr, ppool);
diff --git a/src/runtime/c/utils/pgf-translate.c b/src/runtime/c/utils/pgf-translate.c
index cb3b1d6ec..aa98f1a7a 100644
--- a/src/runtime/c/utils/pgf-translate.c
+++ b/src/runtime/c/utils/pgf-translate.c
@@ -53,10 +53,10 @@ int main(int argc, char* argv[]) {
}
char* filename = argv[1];
- GuString cat = gu_str_string(argv[2], pool);
+ GuString cat = argv[2];
- GuString from_lang = gu_str_string(argv[3], pool);
- GuString to_lang = gu_str_string(argv[4], pool);
+ GuString from_lang = argv[3];
+ GuString to_lang = argv[4];
// Create an exception frame that catches all errors.
GuExn* err = gu_new_exn(NULL, gu_kind(type), pool);
@@ -91,7 +91,7 @@ int main(int argc, char* argv[]) {
}
// Register a callback for the literal category Symbol
- pgf_parser_add_literal(from_concr, gu_str_string("Symb", pool),
+ pgf_parser_add_literal(from_concr, "Symb",
&pgf_nerc_literal_callback);
// Create an output stream for stdout
@@ -154,7 +154,7 @@ int main(int argc, char* argv[]) {
ppool = gu_new_pool();
GuIn *in =
- gu_string_in(gu_str_string(line, ppool), ppool);
+ gu_string_in(line, ppool);
PgfLexer *lexer =
pgf_new_simple_lexer(in, ppool);
@@ -166,7 +166,7 @@ int main(int argc, char* argv[]) {
PgfToken tok =
pgf_lexer_current_token(lexer);
- if (gu_string_eq(tok, gu_empty_string))
+ if (*tok == 0)
gu_puts("Couldn't begin parsing", out, err);
else {
gu_puts("Unexpected token: \"", out, err);
generated by cgit v1.2.3 (git 2.39.1) at 2026-05-20 07:32:04 +0000