Initial revision
diff --git a/libasn1compiler/asn1c_misc.c b/libasn1compiler/asn1c_misc.c
new file mode 100644
index 0000000..b464b64
--- /dev/null
+++ b/libasn1compiler/asn1c_misc.c
@@ -0,0 +1,232 @@
+#include "asn1c_internal.h"
+#include <asn1fix_export.h>
+
+#ifndef DEFFILEMODE /* Normally in <sys/stat.h> */
+#define DEFFILEMODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)
+#endif
+
+/*
+ * Construct identifier from multiple parts.
+ * Convert unsafe characters to underscores.
+ */
+char *
+asn1c_make_identifier(int unsafe_only_spaces, char *arg1, ...) {
+ static char *storage;
+ static int storage_size;
+ int nodelimiter = 0;
+ va_list ap;
+ char *str;
+ int size;
+ char *p;
+
+ if(arg1 == NULL)
+ return NULL;
+
+ /*
+ * Estimate the necessary storage size
+ */
+ size = strlen(arg1);
+ va_start(ap, arg1);
+ while((str = va_arg(ap, char *)))
+ size += 1 + strlen(str);
+ va_end(ap);
+
+ /*
+ * Make sure we have this amount of storage.
+ */
+ if(storage_size <= size) {
+ if(storage) free(storage);
+ storage = malloc(size + 1);
+ if(storage) {
+ storage_size = size;
+ } else {
+ storage_size = 0;
+ return NULL;
+ }
+ }
+
+ /*
+ * Fill-in the storage.
+ */
+ va_start(ap, arg1);
+ str = arg1;
+ p = storage;
+ for(str = arg1; str; str = va_arg(ap, char *)) {
+ int subst_made = 0;
+
+ if(str[0] == ' ' && str[1] == '\0') {
+ *p++ = ' ';
+ nodelimiter = 1; /* No delimiter */
+ continue;
+ }
+
+ if(str != arg1 && !nodelimiter)
+ *p++ = '_'; /* Delimiter between tokens */
+ nodelimiter = 0;
+
+ for(; *str; str++) {
+ if(isalnum(*str)) {
+ *p++ = *str;
+ subst_made = 0;
+ } else if(!subst_made++) {
+ if(unsafe_only_spaces && !isspace(*str)) {
+ *p ++ = *str;
+ } else {
+ *p++ = '_';
+ }
+ }
+ }
+ }
+ va_end(ap);
+ *p = '\0';
+
+ assert((p - storage) <= storage_size);
+
+ return storage;
+}
+
+FILE *
+asn1c_open_file(arg_t *arg, const char *name, const char *ext) {
+ int created = 1;
+ struct stat sb;
+ char *fname;
+ int len;
+ FILE *fp;
+ int fd;
+
+ /*
+ * Compute filenames.
+ */
+ len = strlen(name) + strlen(ext) + 1;
+ fname = alloca(len);
+ snprintf(fname, len, "%s%s", name, ext);
+
+ /*
+ * Create files.
+ */
+ fd = open(fname, O_CREAT | O_EXCL | O_WRONLY, DEFFILEMODE);
+ if(fd == -1 && errno == EEXIST) {
+ fd = open(fname, O_WRONLY, DEFFILEMODE);
+ created = 0;
+ }
+ if(fd == -1) {
+ perror(fname);
+ return NULL;
+ }
+
+ /*
+ * Check sanity.
+ */
+ if(fstat(fd, &sb) || !S_ISREG(sb.st_mode)) {
+ fprintf(stderr, "%s: Not a regular file\n", fname);
+ if(created) unlink(fname);
+ close(fd);
+ return NULL;
+ }
+
+ (void)ftruncate(fd, 0);
+
+ /*
+ * Convert file descriptor into file pointer.
+ */
+ fp = fdopen(fd, "w");
+ if(fp == NULL) {
+ if(created) unlink(fname);
+ close(fd);
+ }
+ return fp;
+}
+
+char *
+asn1c_type_name(arg_t *arg, asn1p_expr_t *expr, enum tnfmt _format) {
+ char *typename;
+
+ switch(expr->expr_type) {
+ case A1TC_REFERENCE:
+ typename = expr->reference->components[
+ expr->reference->comp_count-1].name;
+ if(typename[0] == '&') {
+ arg_t tmp = *arg;
+
+ /*
+ * This is a reference to a type defined in a class.
+ * Resolve it and use instead.
+ */
+ tmp.expr = asn1f_class_access_ex(arg->asn, arg->mod,
+ arg->expr, expr->reference, &tmp.mod);
+ if(tmp.expr) return NULL;
+
+ return asn1c_type_name(&tmp, tmp.expr, _format);
+ } else if(_format == TNF_RSAFE) {
+ /*
+ * The recursion-safe format is requested.
+ * The problem here is that only constructed types
+ * might be referenced with "struct".
+ * Change RSAFE to CTYPE if the terminal type
+ * is primitive.
+ */
+ asn1p_expr_t *terminal;
+ terminal = asn1f_find_terminal_type_ex(
+ arg->asn, arg->mod, arg->expr, NULL);
+ if(terminal
+ && (terminal->expr_type
+ & (ASN_BASIC_MASK | ASN_STRING_MASK)))
+ _format = TNF_CTYPE;
+ }
+ break;
+ case ASN_CONSTR_SEQUENCE_OF:
+ case ASN_CONSTR_SET_OF:
+ if(expr->Identifier) {
+ typename = expr->Identifier;
+ } else {
+ asn1p_expr_t *child;
+ child = TQ_FIRST(&(expr->members));
+ typename = asn1c_type_name(arg, child, _format);
+ if(typename)
+ return typename;
+ _format = TNF_SAFE;
+ typename = child->Identifier;
+ }
+ break;
+ case ASN_BASIC_INTEGER:
+ case ASN_BASIC_ENUMERATED:
+ if((arg->flags & A1C_USE_NATIVE_INTEGERS)) {
+ switch(_format) {
+ case TNF_CTYPE:
+ case TNF_RSAFE:
+ return "int";
+ default:
+ if(expr->expr_type == ASN_BASIC_INTEGER)
+ return "NativeInteger";
+ else
+ return "NativeEnumerated";
+ }
+ }
+ /* Fall through */
+ default:
+ if(expr->expr_type & (ASN_BASIC_MASK | ASN_STRING_MASK)) {
+ if(_format == TNF_RSAFE)
+ _format = TNF_CTYPE;
+ typename = ASN_EXPR_TYPE2STR(expr->expr_type);
+ } else {
+ _format = TNF_SAFE;
+ typename = expr->Identifier;
+ }
+ }
+
+ switch(_format) {
+ case TNF_UNMODIFIED:
+ case TNF_INCLUDE:
+ return asn1c_make_identifier(1, typename, 0);
+ case TNF_SAFE:
+ return asn1c_make_identifier(0, typename, 0);
+ case TNF_CTYPE:
+ return asn1c_make_identifier(0, typename, "t", 0);
+ case TNF_RSAFE:
+ return asn1c_make_identifier(0, "struct", " ", typename, 0);
+ }
+
+ assert("!unreachable");
+ return typename;
+}
+