Merging master and adapting _MEM_* on new mem-vector functions

diff --cc gmqcc.h
index e9e153ee8ce54ff56d601f0df35b9462df4be674,75dceaf6527352256020b790c6c9f116b3c15e94..90d1e05b98e0830763d74d9ed116d4d39efd947a
--- 1/gmqcc.h
--- 2/gmqcc.h
+++ b/gmqcc.h
@@@ -371,26 -371,14 +371,33 @@@ enum 
  };
  
  extern size_t type_sizeof[TYPE_COUNT];
+ extern uint16_t type_store_instr[TYPE_COUNT];
+ /* could use type_store_instr + INSTR_STOREP_F - INSTR_STORE_F
+  * but this breaks when TYPE_INTEGER is added, since with the enhanced
+  * instruction set, the old ones are left untouched, thus the _I instructions
+  * are at a seperate place.
+  */
+ extern uint16_t type_storep_instr[TYPE_COUNT];
  
 +typedef struct {
 +    uint32_t offset;      /* Offset in file of where data begins  */
 +    uint32_t length;      /* Length of section (how many of)      */
 +} prog_section;
 +
 +typedef struct {
 +    uint32_t     version;      /* Program version (6)     */
 +    uint16_t     crc16;        /* What is this?           */
 +    uint16_t     skip;         /* see propsal.txt         */
 +
 +    prog_section statements;   /* prog_section_statement  */
 +    prog_section defs;         /* prog_section_def        */
 +    prog_section fields;       /* prog_section_field      */
 +    prog_section functions;    /* prog_section_function   */
 +    prog_section strings;      /* What is this?           */
 +    prog_section globals;      /* What is this?           */
 +    uint32_t     entfield;     /* Number of entity fields */
 +} prog_header;
 +
  /*
   * Each paramater incerements by 3 since vector types hold
   * 3 components (x,y,z).
@@@ -756,57 -744,7 +763,57 @@@ bool GMQCC_WARN Tself##_##mem##_find(Ts
      return false;                                               \
  }
  
- #define _MEM_VEC_FUN_APPEND(Tself, Twhat, mem)                       \
++#define MEM_VEC_FUN_APPEND(Tself, Twhat, mem)                        \
 +bool GMQCC_WARN Tself##_##mem##_append(Tself *s, Twhat *p, size_t c) \
 +{                                                                    \
 +    Twhat *reall;                                                    \
 +    if (s->mem##_count+c >= s->mem##_alloc) {                        \
 +        if (!s->mem##_alloc) {                                       \
 +            s->mem##_alloc = c < 16 ? 16 : c;                        \
 +        } else {                                                     \
 +            s->mem##_alloc *= 2;                                     \
 +            if (s->mem##_count+c >= s->mem##_alloc) {                \
 +                s->mem##_alloc = s->mem##_count+c;                   \
 +            }                                                        \
 +        }                                                            \
 +        reall = (Twhat*)mem_a(sizeof(Twhat) * s->mem##_alloc);       \
 +        if (!reall) {                                                \
 +            return false;                                            \
 +        }                                                            \
 +        memcpy(reall, s->mem, sizeof(Twhat) * s->mem##_count);       \
 +        mem_d(s->mem);                                               \
 +        s->mem = reall;                                              \
 +    }                                                                \
 +    memcpy(&s->mem[s->mem##_count], p, c*sizeof(*p));                \
 +    s->mem##_count += c;                                             \
 +    return true;                                                     \
 +}
 +
- #define _MEM_VEC_FUN_RESIZE(Tself, Twhat, mem)                   \
++#define MEM_VEC_FUN_RESIZE(Tself, Twhat, mem)                    \
 +bool GMQCC_WARN Tself##_##mem##_resize(Tself *s, size_t c)       \
 +{                                                                \
 +    Twhat *reall;                                                \
 +    if (c > s->mem##_alloc) {                                    \
 +        reall = (Twhat*)mem_a(sizeof(Twhat) * c);                \
 +        if (!reall) { return false; }                            \
 +        memcpy(reall, s->mem, sizeof(Twhat) * s->mem##_count);   \
 +        s->mem##_alloc = c;                                      \
 +        mem_d(s->mem);                                           \
 +        s->mem = reall;                                          \
 +        return true;                                             \
 +    }                                                            \
 +    s->mem##_count = c;                                          \
 +    if (c < (s->mem##_alloc / 2)) {                              \
 +        reall = (Twhat*)mem_a(sizeof(Twhat) * c);                \
 +        if (!reall) { return false; }                            \
 +        memcpy(reall, s->mem, sizeof(Twhat) * c);                \
 +        mem_d(s->mem);                                           \
 +        s->mem = reall;                                          \
 +    }                                                            \
 +    return true;                                                 \
 +}
 +
- #define _MEM_VEC_FUN_CLEAR(Tself, mem)  \
+ #define MEM_VEC_FUN_CLEAR(Tself, mem)   \
  void Tself##_##mem##_clear(Tself *self) \
  {                                       \
      if (!self->mem)                     \