Beispiel #1
0
String *sConcat(const String *s, const String *t) {
    size_t len;
    String *n = NULL;
    char *p;
    const String *vs, *vt;

    if (s == NULL) {
        vs = new_String("");
    }
    else {
        vs = s;
    }

    if (t == NULL) {
        vt = new_String("");
    }
    else {
        vt = t;
    }

    len = sLength(vs) + sLength(vt);
    if ((p = (char *) GC_MALLOC(sizeof(char) * len + 1)) != NULL) {
        strcpy(p, vs->characters);
        strcat(p, vt->characters);
        if ((n = (String *) GC_MALLOC(sizeof(struct String_))) != NULL) {
            n->cls = CLS_STRING;
            n->characters = p;
            n->length = len;
        }
        else {
            GC_FREE(p);
        }
    }
    return n;
}
void
set_params(int argc, char * argv[])
{ /* {{{ */
  struct stat file_stat;

  if(argc != 3) {
    usage(argv[0]);
    exit(SHELL_FALSE);
  }

  if(stat(argv[1], &file_stat) == -1) {
    perror("stat() error for format file");
    exit(1);
  }

  if(! S_ISREG(file_stat.st_mode)) {
    fprintf(stderr, "Format file is not a regular file.\n");
    exit(1);
  }


  if(stat(argv[2], &file_stat) == -1) {
    perror("stat() error for input file");
    exit(1);
  }

  if(! S_ISREG(file_stat.st_mode)) {
    fprintf(stderr, "Input file is not a regular file.\n");
    exit(1);
  }

  format_file = new_String(argv[1], strlen(argv[1]));
  input_file = new_String(argv[2], strlen(argv[2]));
} /* }}} */
Beispiel #3
0
int main(int argc, char *argv[]){
   String s1;
   String s2;
   char   *c1 = NULL;
   
   s1 = new_String("This ");
   s2 = new_String("is a test");
   
   if(!String_appendString(s1, s2)){
      fprintf(stderr, "String_appendString(): Uh oh!\n");
   }
   else{
      if(String_getChars(s1, &c1)){
         printf("%s\n", c1);
      }
      else{
         fprintf(stderr, "String_getChars(): Uh oh!\n");
      }
   }
   
   delete_String(s1);
   delete_String(s2);
   
   return EXIT_SUCCESS;
}
Beispiel #4
0
void
set_params(int argc, char * argv[])
{ /* {{{ */
  struct stat file_stat;

  if(argc <= 2 || argc >= 5) {
    usage(argv[0]);
    exit(SHELL_FALSE);
  }

  /* Format File */
  if(stat(argv[1], &file_stat) == -1) {
    perror("stat() error for format file");
    exit(1);
  }
  if(! S_ISREG(file_stat.st_mode)) {
    fprintf(stderr, "Format file is not a regular file.\n");
    exit(1);
  }
  format_file = new_String(argv[1], strlen(argv[1]));


  /* Input File */
  if(stat(argv[2], &file_stat) == -1) {
    perror("stat() error for input file");
    exit(1);
  }
  if(! S_ISREG(file_stat.st_mode)) {
    fprintf(stderr, "Input file is not a regular file.\n");
    exit(1);
  }
  input_file = new_String(argv[2], strlen(argv[2]));


  /* Output File */
  if(argc == 4
     && strncmp(argv[3], "-", 1) != 0) {
    if(stat(argv[3], &file_stat) == -1) {
      if(errno != ENOENT) {
        perror("stat() error for output file");
        exit(1);
      }
    }
    else if(! S_ISREG(file_stat.st_mode)) {
      fprintf(stderr, "Output file exists, but is not a regular file.\n");
      exit(1);
    }
    output_file = new_String(argv[3], strlen(argv[3]));
  }
  else {
    output_file = new_String("-", 1);
  }

} /* }}} */
Beispiel #5
0
static ktype_t msgpack_read(CTX ctx, msgpack_object obj, ksfp_t *sfp)
{
	switch (obj.type) {
	case MSGPACK_OBJECT_NIL:
		KNH_SETv(ctx, sfp[0].o, KNH_NULL);
		return CLASS_Tdynamic;
	case MSGPACK_OBJECT_BOOLEAN:
		sfp[0].bvalue = obj.via.boolean;
		return CLASS_Boolean;
	case MSGPACK_OBJECT_NEGATIVE_INTEGER:
		sfp[0].ivalue = obj.via.i64;
		return CLASS_Int;
	case MSGPACK_OBJECT_POSITIVE_INTEGER:
		sfp[0].uvalue = obj.via.u64;
		return CLASS_Int;
	case MSGPACK_OBJECT_DOUBLE:
		sfp[0].fvalue = obj.via.dec;
		return CLASS_Float;
	case MSGPACK_OBJECT_RAW:
		KNH_SETv(ctx, sfp[0].o, new_String(ctx, obj.via.raw.ptr));
		return CLASS_String;
	case MSGPACK_OBJECT_ARRAY:
	{
		msgpack_object *a = obj.via.array.ptr;
		size_t asize = obj.via.array.size;
		const msgpack_object *array_end = obj.via.array.ptr + asize;
		KNH_SETv(ctx, sfp[0].o, new_Array(ctx, CLASS_Tdynamic, asize));
		for (; a < array_end; a++) {
			ktype_t type = msgpack_read(ctx, *a, sfp+1);
			knh_boxing(ctx, sfp+1, type);
			knh_Array_add(ctx, sfp[0].a, sfp[1].o);
		}
		return CLASS_Array;
	}
	case MSGPACK_OBJECT_MAP:
		{
			if (obj.via.map.size == 0) break;
			msgpack_object_kv *map = obj.via.map.ptr;
			msgpack_object_kv *map_end = obj.via.map.ptr + obj.via.map.size;
			KNH_SETv(ctx, sfp[0].o, new_DataMap(ctx/*, obj.via.map.size*/));
			for (; map < map_end; map++) {
				const char *key = map->key.via.raw.ptr;
				ktype_t type = msgpack_read(ctx, map->val, sfp+1);
				knh_boxing(ctx, sfp+1, type);
				klr_setesp(ctx, sfp+2);
				knh_DataMap_set(ctx, sfp[0].m, new_String(ctx, key), sfp[1].o);
			}
			return CLASS_Map;
		}
	}
	return CLASS_Tvoid;
}
Beispiel #6
0
static SV *new_Token(pTHX_ Token *token)
{
	HV *hash = (HV*)new_Hash();
	(void)hv_stores(hash, "stype", set(new_Int(token->stype)));
	(void)hv_stores(hash, "type", set(new_Int(token->info.type)));
	(void)hv_stores(hash, "kind", set(new_Int(token->info.kind)));
	(void)hv_stores(hash, "line", set(new_Int(token->finfo.start_line_num)));
	(void)hv_stores(hash, "has_warnings", set(new_Int(token->info.has_warnings)));
	(void)hv_stores(hash, "name", set(new_String(token->info.name, strlen(token->info.name))));
	(void)hv_stores(hash, "data", set(new_String(token->data.c_str(), strlen(token->data.c_str()))));
	HV *stash = (HV *)gv_stashpv("Compiler::Lexer::Token", sizeof("Compiler::Lexer::Token") + 1);
	return sv_bless(new_Ref(hash), stash);
}
Beispiel #7
0
static METHOD knh__String_get(Ctx *ctx, knh_sfp_t *sfp)
{
	knh_bytes_t base = knh_String_tobytes(sfp[0].s);
	if(knh_String_isASCII(sfp[0].s)) {
		size_t n = knh_array_index(ctx, p_int(sfp[1]), knh_String_strlen(sfp[0].s));
		base.buf = base.buf + n;
		base.len = 1;
		KNH_RETURN(ctx, sfp, new_String(ctx, base, sfp[0].s));
	}
	else {
		size_t off = knh_array_index(ctx, p_int(sfp[1]), knh_bytes_mlen(base));
		knh_bytes_t sub = knh_bytes_mofflen(base, off, 1);
		KNH_RETURN(ctx, sfp, new_String(ctx, sub, sfp[0].s));
	}
}
Beispiel #8
0
void test_heap_dump()
{
  char *expected, *result;
  User *u;
  String *s;
  Array *a;
  GC_SAVE_RP;

  gc();

  s = new_String("tim");
  u = new_User(103, s);
  a = (Array *) alloc_Array(2, ARRAY_POINTER);
  ((void **) a->elements)[0] = s;
  ((void **) a->elements)[1] = u;

  ADD_ROOT(s);
  ADD_ROOT(u);
  ADD_ROOT(a);

  expected = "heap2[116,1000]\n"
             "0000:String[32+4]=\"tim\"\n"
             "0036:User[32]->[0]\n"
             "0068:Array[32+2]->[0, 36]\n";

  result = calloc(1000, sizeof(char));
  heap_dump(result);

//  printf("\n%s", result);
  ASSERT_STR(expected, result);

  GC_RESTORE_RP;
  free(result);
}
Beispiel #9
0
static METHOD knh__String_substring(Ctx *ctx, knh_sfp_t *sfp)
{
	knh_bytes_t base = knh_String_tobytes(sfp[0].s);
	knh_bytes_t sub;
	if(knh_String_isASCII(sfp[0].s)) {
		size_t offset = IS_NULL(sfp[1].o) ? 0 : knh_array_index(ctx, sfp[1].ivalue, base.len);
		sub = knh_bytes_last(base, offset);
		if(IS_NOTNULL(sfp[2].o)) {
			size_t len = (size_t)sfp[2].ivalue;
			if(len < sub.len) sub = knh_bytes_first(sub, len);
		}
	}
	else { // multibytes
		size_t mlen = knh_bytes_mlen(base);
		size_t offset = IS_NULL(sfp[1].o) ? 0 : knh_array_index(ctx, sfp[1].ivalue, mlen);
		size_t length = IS_NULL(sfp[2].o) ? (mlen - offset) : (size_t)sfp[2].ivalue;
		sub = knh_bytes_mofflen(base, offset, length);
	}

	String *s;
	if(sub.len == 0) {
		s = TS_EMPTY;
	}
	else if(sub.len == base.len) {
		s = sfp[0].s;
	}
	else {
		s = new_String(ctx, sub, sfp[0].s);
	}
	KNH_RETURN(ctx, sfp, s);
}
Beispiel #10
0
/* @method String XmlReader.lookupNameSpace(String ns) */
METHOD XmlReader_lookupNameSpace(Ctx *ctx, knh_sfp_t *sfp)
{
    xmlTextReaderPtr reader = (xmlTextReaderPtr) p_cptr(sfp[0]);
    xmlChar* ns   = (xmlChar*) p_char(sfp[1]);
    char* ret = (char*) xmlTextReaderLookupNamespace(reader,ns);
    KNH_RETURN(ctx,sfp,new_String(ctx,B(ret),NULL));
}
Beispiel #11
0
bool AttrList_setItem(AttrList l, String key, int v){
   bool   retVal = false;
   int    idx    = -1;
   size_t i;
   String tmpKey;

   idx = getIndex(l);
   if(idx >= 0){
      if(!keyExists(l, key)){
         if(attrListPool[idx].length == (attrListPool[idx].size - 1)){
            growList(idx, (attrListPool[idx].size * 2));
         }
         for(i = 0; i < attrListPool[idx].size; ++i){
            if(attrListPool[idx].keys[i] == INVALID_STRING){
               break;
            }
         }
         tmpKey = new_String(NULL);
         if(tmpKey != INVALID_STRING && String_copyString(tmpKey, key)){
            attrListPool[idx].keys[i] = tmpKey;
            attrListPool[idx].data[i] = v;
            attrListPool[idx].length++;
            retVal = true;
         }
      }
   }
   return retVal;
}
Beispiel #12
0
static int
validate_header(void)
{ /* {{{ */
  String *    found;
  PDTColumn * expected;

  String *    separator;
  String *    found_fields;
  String *    expected_fields;
  int         valid;

  /* Initialize */
  found           = null_String;
  expected        = null_PDTColumn;

  found_fields    = null_String;
  expected_fields = null_String;
  separator       = new_String("|", 1);
  valid           = 1;

  void *
  column_join(Array * array, ArrayElement * element, void * target)
  {
    ((String *)target)->m->append((String *)target, ((PDTColumn *)element->data)->column_name);
    if(array->position < (array->length - 1)) {
      ((String *)target)->m->append((String *)target, separator);
    }
    return target;
  }
Beispiel #13
0
int main(int argc, char *argv[]) {
  String *str = new_String(5);
  set_String(str, "ololo");
  for (int i = 0; i < 5; i++)
    printf("%c", str->str[i]);
  free_String(str);
}
Beispiel #14
0
/* @method String XmlReader.getAttributeNo(Int numer) */
METHOD XmlReader_getAttributeNo(Ctx *ctx, knh_sfp_t *sfp)
{
    xmlTextReaderPtr reader = (xmlTextReaderPtr) p_cptr(sfp[0]);
    int num = p_int(sfp[1]);
    char* ret = (char*) xmlTextReaderGetAttributeNo(reader,num);
    KNH_RETURN(ctx,sfp,new_String(ctx,B(ret),NULL));
}
Beispiel #15
0
int main(int argc, char* argv[])
{
    fs::path game_dir("C:\\my\\unity\\proj1\\proj1\\build\\1_Data");

    fs::path managed_dir = game_dir / "Managed";
    fs::path mono_dir = game_dir / "Mono";
    fs::path dll_path = mono_dir / "_mono.dll";

    HMODULE dll = LoadLibraryA(dll_path.string().c_str());
    auto f = make_shared<mono_wrapper::functions_t>(mono_wrapper::load_mono_functions_from_dll(dll));

    f->mono_set_dirs(managed_dir.string().c_str(), (game_dir / "Mono/etc").string().c_str());
    
    {
        std::stringstream ss;
        ss << managed_dir.string() << ";" << mono_dir.string();
        f->mono_set_assemblies_path(ss.str().c_str());
    }

    MonoDomain* domain = f->mono_jit_init("My domain");

    auto s = new_String(f, "Hello!");
    auto s1 = s->ToUpper();

    string s1_content = s1->to_utf8();

    int32_t len = s->get_Length();

	return 0;
}
Beispiel #16
0
METHOD Xml_dump(Ctx *ctx, knh_sfp_t *sfp)
{
    xmlDocPtr doc = (xmlDocPtr) p_cptr(sfp[0]);
    xmlChar* ret;
    int   size;
    xmlDocDumpMemory(doc,&ret,&size);
    KNH_RETURN(ctx, sfp, new_String(ctx, B((char*)ret), NULL));
}
Beispiel #17
0
/* @method String XmlReader.getAttributeNs(String ns, String name) */
METHOD XmlReader_getAttributeNs(Ctx *ctx, knh_sfp_t *sfp)
{
    xmlTextReaderPtr reader = (xmlTextReaderPtr) p_cptr(sfp[0]);
    xmlChar* ns   = (xmlChar*) p_char(sfp[1]);
    xmlChar* name = (xmlChar*) p_char(sfp[2]);
    char* ret = (char*) xmlTextReaderGetAttributeNs(reader,ns,name);
    KNH_RETURN(ctx,sfp,new_String(ctx,B(ret),NULL));
}
Beispiel #18
0
METHOD XmlNode_getName(Ctx *ctx, knh_sfp_t *sfp)
{
    xmlNodePtr node= (xmlNodePtr) p_cptr(sfp[0]);
    xmlChar* ret = (xmlChar *)"";
    if(node->name){
        ret = (xmlChar *)node->name;
    }
    KNH_RETURN(ctx, sfp, new_String(ctx, B((char*)ret), NULL));
}
Beispiel #19
0
static METHOD knh__String_trim(Ctx *ctx, knh_sfp_t *sfp)
{
	knh_bytes_t t = knh_String_tobytes(sfp[0].s);
	knh_bytes_t t2 = knh_bytes_trim(t);
	String *s = sfp[0].s;
	if(t.len > t2.len) {
		s = new_String(ctx, t2, s);
	}
	KNH_RETURN(ctx, sfp, s);
}
Beispiel #20
0
METHOD XmlNode_getContent(Ctx *ctx, knh_sfp_t *sfp)
{
    xmlNodePtr node= (xmlNodePtr) p_cptr(sfp[0]);
    xmlChar* ret = (xmlChar *)"";
    if(node->content){
        ret = node->content;
        fprintf(stdout,"[%s]\n",(char*)node->content);
    }
    KNH_RETURN(ctx, sfp, new_String(ctx, B((char*)ret), NULL));
}
Beispiel #21
0
METHOD XmlNode_getAttr(Ctx *ctx, knh_sfp_t *sfp)
{
    xmlNodePtr node= (xmlNodePtr) p_cptr(sfp[0]);
    xmlChar *name = (xmlChar *) p_char(sfp[1]);
    xmlChar *ret  = (xmlChar *)"";
    if(node->properties){
        ret  = xmlGetProp(node,name);
    }
    KNH_RETURN(ctx, sfp, new_String(ctx, B((char*)ret), NULL));
}
Beispiel #22
0
/* @method String XmlReader.getAttribute() */
METHOD XmlReader_getAttribute(Ctx *ctx, knh_sfp_t *sfp)
{
    xmlTextReaderPtr reader = (xmlTextReaderPtr) p_cptr(sfp[0]);
    xmlChar * ns = (xmlChar *) p_char(sfp[1]);
    char* ret = (char*) xmlTextReaderGetAttribute(reader,ns);
    if(ret == NULL){
        ret = "";
    }
    KNH_RETURN(ctx,sfp,new_String(ctx,B(ret),NULL));
}
Beispiel #23
0
/* @method String XmlReader.getQuoteChar() */
METHOD XmlReader_getQuoteChar(Ctx *ctx, knh_sfp_t *sfp)
{
    xmlTextReaderPtr reader = (xmlTextReaderPtr) p_cptr(sfp[0]);
    int num = xmlTextReaderQuoteChar(reader);
    char* ret = " ";
    if(num == 34){
        ret[0] = '"';
    } else {
        ret[0] = '\0';
    }
    KNH_RETURN(ctx,sfp,new_String(ctx,B(ret),NULL));
}
Beispiel #24
0
String *createGaugeQCDML ( gaugeConfigurationMetadata *gaugeConfiguration )
{
  char dummy[] = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><title>Dummy QCDML</title>";
  size_t size = 4000;
  String* st = new_String ( size, "\n####### String ############\n" );
  outStream* os = new_outStreamString ( st );

  gaugeConfigurationMetadataEncode ( os, "gaugeConfiguration",
				     gaugeConfiguration );

  delete_outStream ( os );
}
Beispiel #25
0
void testString ( testStruct const* obj )
{
  size_t size = 2048;
  String* st = new_String ( size, "" );
  outStream* os = new_outStreamString ( st );

  printf ( "\noutput to String\n" );
  testStructEncode ( os, "myTestStruct", obj );
  printf ( "%s\n", st -> chars );

  delete_String ( st );
  delete_outStream ( os );
}
Beispiel #26
0
static METHOD knh__String_new(Ctx *ctx, knh_sfp_t *sfp)
{
	String *s;
	if(IS_NULL(sfp[2].o)) {
		s = new_String(ctx, knh_Bytes_tobytes(sfp[1].ba), NULL);
	}
	else {
		BytesConv *bc = new_BytesConv__in(ctx, knh_String_tochar(sfp[2].s));
		KNH_SETv(ctx, sfp[3].o, bc);
		s = new_String__bconv(ctx, knh_Bytes_tobytes(sfp[1].ba), bc);
	}
	KNH_RETURN(ctx, sfp, s);
}
Beispiel #27
0
static METHOD knh__String_split(Ctx *ctx, knh_sfp_t *sfp)
{
	Array *a = NULL;
	int istrim = IS_NULL(sfp[2].o) ? 0 : (int)sfp[2].ivalue;
	if(IS_NULL(sfp[1].o)) {
		a = knh_String_toCharArray(ctx, sfp[0].s, istrim);
	}
	else {
		knh_bytes_t delim = knh_String_tobytes(sfp[1].s);
		if(delim.len == 0) {
			a = knh_String_toCharArray(ctx, sfp[0].s, istrim);
		}
		else {
			knh_bytes_t base = knh_String_tobytes(sfp[0].s);
			a = new_Array(ctx, CLASS_String, 8);
			while(1) {
				knh_index_t loc = knh_bytes_indexOf(base, delim);
				if(loc == -1) {
					if(istrim) base = knh_bytes_trim(base);
					knh_Array_add(ctx, a, UP(new_String(ctx, base, sfp[0].s)));
					break;
				}
				else if(loc == 0) {
					knh_Array_add(ctx, a, UP(TS_EMPTY));
				}
				else {
					knh_bytes_t t = knh_bytes_first(base, loc);
					if(istrim) t = knh_bytes_trim(t);
					knh_Array_add(ctx, a, UP(new_String(ctx, t, sfp[0].s)));
				}
				base.buf = base.buf + loc + delim.len;
				base.len = base.len - loc - delim.len;
			}
		}
	}
	KNH_ASSERT(a != NULL);
	KNH_RETURN(ctx, sfp, a);
}
Beispiel #28
0
static METHOD knh__String_format(Ctx *ctx, knh_sfp_t *sfp)
{
	knh_bytes_t fmt = knh_String_tobytes(sfp[0].s);
	knh_sfp_t *param = sfp + 1;
	int ac = knh_stack_argc(ctx, param);
	knh_bytes_t mt, expr, next;

	if(!knh_bytes_findMT(ctx, fmt, &mt, &expr, &next)) {
		KNH_RETURN(ctx, sfp, sfp[0].s);
	}

	knh_cwb_t cwbbuf, *cwb = knh_cwb_open(ctx, &cwbbuf);
	int count;
	for(count = 0; ; count++) {
		if(mt.buf > fmt.buf + 1) {
			fmt.len = (mt.buf - fmt.buf) - 1;
			knh_Bytes_write(ctx, cwb->ba, fmt);
		}
		int index = count;
		if(expr.len > 0) {
			knh_int_t num;
			if(knh_bytes_parseint(expr, &num)) {
				index = (int)num;
			}
		}
		if(0 <= index && index < ac) {
			knh_sfp_t *esp = KNH_LOCAL(ctx);
			KNH_SETv(ctx, esp[1].o, param[index].o); esp[1].data = param[index].data;
			Object *m = KNH_NULL;
			if(knh_bytes_isOptionalMT(mt)) m = UP(new_String(ctx, mt, NULL));
			mt.buf = mt.buf - 1; mt.len++;   /* 's' == > '%s' */
			knh_methodn_t mn = knh_getmn(ctx, mt, METHODN__empty);
			knh_esp1_format(ctx, mn, cwb->w, m);
		}
		else {
			if(knh_Context_isDebug(ctx)) {
				KNH_THROW_OUTOFINDEX(ctx, index, ac);
			}
		}
		fmt.buf = next.buf; fmt.len = next.len;
		if(!knh_bytes_findMT(ctx, fmt, &mt, &expr, &next)) {
			break;
		}
	}
	if(fmt.len > 0) {
		knh_Bytes_write(ctx, cwb->ba, fmt);
	}
	KNH_RETURN(ctx, sfp, new_StringX__cwb(ctx, knh_Object_cid(sfp[0].o), cwb));
}
Beispiel #29
0
static Array *knh_String_toCharArray(Ctx *ctx, String *bs, int istrim)
{
	knh_bytes_t base = knh_String_tobytes(bs);
	if(knh_String_isASCII(bs)) {
		size_t i, n = base.len;
		Array *a = new_Array(ctx, CLASS_String, n);
		for(i = 0; i < n; i++) {
			if(istrim && isspace(base.buf[i])) continue;
			knh_bytes_t sub = { base.buf + i, 1};
			knh_Array_add(ctx, a, UP(new_String(ctx, sub, bs)));
		}
		return a;
	}
	else {
		size_t i, n = knh_bytes_mlen(base);
		Array *a = new_Array(ctx, CLASS_String, n);
		for(i = 0; i < n; i++) {
			if(istrim && isspace(base.buf[i])) continue;
			knh_bytes_t sub = knh_bytes_mofflen(base, n, 1);
			knh_Array_add(ctx, a, UP(new_String(ctx, sub, bs)));
		}
		return a;
	}
}
Beispiel #30
0
static PDTColumn *
PDTColumn_init(PDTColumn * self, char * column, size_t column_length)
{
  /* Variables */
  if(self != null_PDTColumn) {
    self->column_name = new_String(column, column_length);
  }
  else {
    self->column_name = null_String;
  }

  self->validations = null_Array;

  return self;
}