WebSVN – Kolibri OS – Diff – /programs/develop/metcc/trunk/source/tcc.c

 #include
 #include
 #include
 #include
-#include
+//#include
 #include
 #include
-#include
+//#include
 #include
 #include
 #include
 #ifdef WIN32
 #include
 #endif
+//#ifndef WIN32
 #ifndef WIN32
 #include
-#include
+//#include
-#endif
+//#endif
 #endif /* !CONFIG_TCCBOOT */
 /* target selection */
 //#define TCC_TARGET_I386   /* i386 code generator */
 //#define TCC_TARGET_ARM    /* ARMv4 code generator */
+//#define TCC_TARGET_C67    /* TMS320C67xx code generator */
+//----------------------------------------------------------------
-//#define TCC_TARGET_C67    /* TMS320C67xx code generator */
+#define TCC_TARGET_MEOS
 /* default target is I386 */
 #if !defined(TCC_TARGET_I386) && !defined(TCC_TARGET_ARM) && \
   #define strtold (long double)strtod
   #define strtof (float)strtod
   #define strtoll (long long)strtol
 #endif
 #elif defined(TCC_UCLIBC) || defined(__FreeBSD__)
-/* currently incorrect */
 long double strtold(const char *nptr, char **endptr)
+{
     return (long double)strtod(nptr, endptr);
+}
 float strtof(const char *nptr, char **endptr)
+{
     return (float)strtod(nptr, endptr);
+}
 #else
 /* XXX: need to define this to use them in non ISOC99 context */
 extern float strtof (const char *__nptr, char **__endptr);
 extern long double strtold (const char *__nptr, char **__endptr);
+//extern long long strtoll(const char *__nptr, char **__endptr, int __base)
 #endif
+#define strtold (long double)strtod
+#define strtof (float)strtod
+#define strtoll (long long)strtol
 static char *pstrcpy(char *buf, int buf_size, const char *s);
 static char *pstrcat(char *buf, int buf_size, const char *s);
 static const char *tcc_basename(const char *name);
 /* add the symbol you want here if no dynamic linking is done */
 static TCCSyms tcc_syms[] = {
 #if !defined(CONFIG_TCCBOOT)
     TCCSYM(printf)
-    TCCSYM(fprintf)
+    TCCSYM(printf)
     TCCSYM(fopen)
     TCCSYM(fclose)
 #endif
     { NULL, NULL },
+    }
     return NULL;
+}
-#elif !defined(WIN32)
+#elif !defined(WIN32)
+//-------------------------------------------------------------------------
-#include
+//#include
+void *resolve_sym(TCCState *s1, const char *sym, int type)
-void *resolve_sym(TCCState *s1, const char *sym, int type)
+{
     return(0);
-    return dlsym(RTLD_DEFAULT, sym);
+    //return dlsym(RTLD_DEFAULT, sym);
+}
 //-------------------------------------------------------------------------
 #endif
         strcat_printf(buf, sizeof(buf), "warning: ");
     strcat_vprintf(buf, sizeof(buf), fmt, ap);
     if (!s1->error_func) {
         /* default case: stderr */
-        fprintf(stderr, "%s\n", buf);
+        printf("%s\n", buf);
     } else {
         s1->error_func(s1->error_opaque, buf);
+    }
     if (!is_warning || s1->warn_error)
+{
     return tcc_peekc_slow(file);
+}
 /* read next char from current input file and handle end of input buffer */
-static inline void inp(void)
+static inline void input(void)
+{
     ch = *(++(file->buf_ptr));
     /* end of buffer/file handling */
     if (ch == CH_EOB)
 /* handle '\[\r]\n' */
 static void handle_stray(void)
+{
     while (ch == '\\') {
-        inp();
+        input();
         if (ch == '\n') {
             file->line_num++;
-            inp();
+            input();
         } else if (ch == '\r') {
-            inp();
+            input();
             if (ch != '\n')
                 goto fail;
             file->line_num++;
-            inp();
+            input();
         } else {
         fail:
             error("stray '\\' in program");
+        }
 /* input with '\[\r]\n' handling. Note that this function cannot
    handle other characters after '\', so you cannot call it inside
    strings or comments */
 static void minp(void)
+{
-    inp();
+    input();
     if (ch == '\\')
         handle_stray();
+}
             minp();
 #if 0
             /* eat all spaces and comments after include */
             /* XXX: slightly incorrect */
             while (ch1 != '\n' && ch1 != CH_EOF)
-                inp();
+                input();
 #endif
         } else {
             /* computed #include : either we have only strings or
                we have anything enclosed in '<>' */
             next();
                     ch = *p++;
+                }
+            }
             *q = '\0';
             t = toup(ch);
-            errno = 0;
+            //errno = 0;
             if (t == 'F') {
                 ch = *p++;
                 tok = TOK_CFLOAT;
                 tokc.f = strtof(token_buf, NULL);
             } else if (t == 'L') {
 /* return type size. Put alignment at 'a' */
 static int type_size(CType *type, int *a)
+{
     Sym *s;
     int bt;
+    int size;
     bt = type->t & VT_BTYPE;
     if (bt == VT_STRUCT) {
         /* struct/union */
         s = type->ref;
+        *a = s->r;
         *a = s->r;
         return s->c;
+    } else if (bt == VT_PTR) {
     } else if (bt == VT_PTR) {
         if (type->t & VT_ARRAY) {
+            s = type->ref;
-            s = type->ref;
+		size=type_size(&s->type, a) * s->c;
-            return type_size(&s->type, a) * s->c;
+            return size;//type_size(&s->type, a) * s->c;
         } else {
             *a = PTR_SIZE;
             return PTR_SIZE;
+        }
                     if (v) {
                         /* add new memory data only if starting
                            bit field */
                         if (lbit_pos == 0) {
                             if (a == TOK_STRUCT) {
+				//17.09.2007
-                                c = (c + align - 1) & -align;
+                                //c = (c + align - 1) & -align;
                                 offset = c;
-                                c += size;
+                                //c += size;
+				if (size<=4) {c=c+size;}
+					else
+					{c=c+align;}
                             } else {
                                 offset = 0;
                                 if (size > c)
                                     c = size;
+                            }
     unsigned long func_addr, last_pc, pc;
     const char *incl_files[INCLUDE_STACK_SIZE];
     int incl_index, len, last_line_num, i;
     const char *str, *p;
-    fprintf(stderr, "0x%08lx:", wanted_pc);
+    printf("0x%08lx:", wanted_pc);
     func_name[0] = '\0';
     func_addr = 0;
+                }
+            }
+        }
+    }
     /* did not find any info: */
-    fprintf(stderr, " ???\n");
+    printf(" ???\n");
     return;
  found:
     if (last_func_name[0] != '\0') {
-        fprintf(stderr, " %s()", last_func_name);
+        printf(" %s()", last_func_name);
+    }
     if (incl_index > 0) {
-        fprintf(stderr, " (%s:%d",
+        printf(" (%s:%d",
                 incl_files[incl_index - 1], last_line_num);
         for(i = incl_index - 2; i >= 0; i--)
-            fprintf(stderr, ", included from %s", incl_files[i]);
+            printf(", included from %s", incl_files[i]);
-        fprintf(stderr, ")");
+        printf(")");
+    }
-    fprintf(stderr, "\n");
+    printf("\n");
+}
 #if !defined(WIN32) && !defined(CONFIG_TCCBOOT)
 #define REG_EIP EIP
 #define REG_EBP EBP
 #endif
+/* return the PC at frame level 'level'. Return non zero if not found */
-/* return the PC at frame level 'level'. Return non zero if not found */
+/*
 static int rt_get_caller_pc(unsigned long *paddr,
                             ucontext_t *uc, int level)
+{
     unsigned long fp;
         fp = uc->uc_mcontext.ebp;
 #else
         fp = uc->uc_mcontext.gregs[REG_EBP];
 #endif
         for(i=1;i
-            /* XXX: check address validity with program info */
+	// XXX: check address validity with program info
             if (fp <= 0x1000 || fp >= 0xc0000000)
                 return -1;
             fp = ((unsigned long *)fp)[0];
+        }
         *paddr = ((unsigned long *)fp)[1];
         return 0;
+    }
+}
+*/
 #else
 #warning add arch specific rt_get_caller_pc()
 /*
 static int rt_get_caller_pc(unsigned long *paddr,
                             ucontext_t *uc, int level)
+{
     return -1;
+}
 */
 #endif
 /* emit a run time error at position 'pc' */
-/* emit a run time error at position 'pc' */
+/*
 void rt_error(ucontext_t *uc, const char *fmt, ...)
+{
     va_list ap;
     unsigned long pc;
     int i;
     va_start(ap, fmt);
-    fprintf(stderr, "Runtime error: ");
+    printf("Runtime error: ");
-    vfprintf(stderr, fmt, ap);
+    //vfprintf(stderr, fmt, ap);
-    fprintf(stderr, "\n");
+    printf("\n");
     for(i=0;i
         if (rt_get_caller_pc(&pc, uc, i) < 0)
             break;
         if (i == 0)
-            fprintf(stderr, "at ");
+            printf("at ");
         else
-            fprintf(stderr, "by ");
+            printf("by ");
         rt_printline(pc);
+    }
+    exit(255);
-    exit(255);
+    va_end(ap);
+}
     va_end(ap);
 */
 /* signal handler for fatal errors */
-/* signal handler for fatal errors */
+/*
         rt_error(uc, "caught signal %d", signum);
         break;
+    }
     exit(255);
+}
+*/
 #endif
 /* do all relocations (needed before using tcc_get_symbol()) */
 int tcc_relocate(TCCState *s1)
+{
     Section *s;
     if (do_debug) {
 #if defined(WIN32) || defined(CONFIG_TCCBOOT)
         error("debug mode currently not available for Windows");
 #else
-        struct sigaction sigact;
+        //struct sigaction sigact;
         /* install TCC signal handlers to print debug info on fatal
            runtime errors */
-        sigact.sa_flags = SA_SIGINFO | SA_RESETHAND;
+        //sigact.sa_flags = SA_SIGINFO | SA_RESETHAND;
-        sigact.sa_sigaction = sig_error;
+        //sigact.sa_sigaction = sig_error;
-        sigemptyset(&sigact.sa_mask);
+        //sigemptyset(&sigact.sa_mask);
-        sigaction(SIGFPE, &sigact, NULL);
+        //sigaction(SIGFPE, &sigact, NULL);
-        sigaction(SIGILL, &sigact, NULL);
+        //sigaction(SIGILL, &sigact, NULL);
-        sigaction(SIGSEGV, &sigact, NULL);
+        //sigaction(SIGSEGV, &sigact, NULL);
-        sigaction(SIGBUS, &sigact, NULL);
+        //sigaction(SIGBUS, &sigact, NULL);
-        sigaction(SIGABRT, &sigact, NULL);
+        //sigaction(SIGABRT, &sigact, NULL);
 #endif
+    }
         snprintf(buf, sizeof(buf), "%s/lib", tcc_lib_path);
         tcc_add_library_path(s, buf);
+    }
 #else
 #ifdef TCC_TARGET_MEOS
+    tcc_add_library_path(s, ".//lib");
 #else
     tcc_add_library_path(s, "/usr/local/lib");
     tcc_add_library_path(s, "/usr/lib");
     tcc_add_library_path(s, "/lib");
 #endif
         /* XXX: reverse order needed if -isystem support */
 #if !defined(TCC_TARGET_PE) && !defined(TCC_TARGET_MEOS)
         tcc_add_sysinclude_path(s, "/usr/local/include");
         tcc_add_sysinclude_path(s, "/usr/include");
 #endif
+#if defined(TCC_TARGET_MEOS)
+        tcc_add_sysinclude_path(s, ".//include");
+#endif
         snprintf(buf, sizeof(buf), "%s/include", tcc_lib_path);
         tcc_add_sysinclude_path(s, buf);
 #ifdef TCC_TARGET_PE
         snprintf(buf, sizeof(buf), "%s/include/winapi", tcc_lib_path);
         tcc_add_sysinclude_path(s, buf);
         tcc_add_file(s, CONFIG_TCC_CRT_PREFIX "/crti.o");
+    }
 #endif
 #if defined(TCC_TARGET_MEOS)
     if (s->output_type != TCC_OUTPUT_OBJ)
-        tcc_add_file(s,".\\start.o");
+        tcc_add_file(s,".//start.o");
 #endif
     return 0;
+}
            "  -static     static linking\n"
            "  -rdynamic   export all global symbols to dynamic linker\n"
            "  -r          relocatable output\n"
            "Debugger options:\n"
            "  -g          generate runtime debug info\n"
-#ifdef CONFIG_TCC_BCHECK
-           "  -b          compile with built-in memory and bounds checker (implies -g)\n"
-#endif
            "  -bt N       show N callers in stack traces\n"
            );
+}
 static const char *outfile;
 int parse_args(TCCState *s, int argc, char **argv)
+{
+    int optind;
-    int optind;
+    int i;
     const TCCOption *popt;
     const char *optarg, *p1, *r1;
+    char *r;
+    /*
+    printf("\n%d\n",argc);
+    for(i=0;i
+	{
+		printf("\n parameter  %d = %s",i+1,argv[i]);
+	}
-    char *r;
+    printf("\n");
     */
     optind = 0;
     while (1) {
         if (optind >= argc) {
             if (nb_files == 0 && !print_search_dirs)
-                goto show_help;
+                  goto show_help;
             else
                 break;
+        }
+        r = argv[optind++];
-        r = argv[optind++];
+        if (r[0] != '-') {
         if (r[0] != '-') {
             /* add a new file */
             dynarray_add((void ***)&files, &nb_files, r);
             if (!multiple_files) {
             /* find option in table (match only the first chars */
             popt = tcc_options;
             for(;;) {
                 p1 = popt->name;
                 if (p1 == NULL)
-                    error("invalid option -- '%s'", r);
+                    printf("\n invalid option -- '%s'", r);
                 r1 = r + 1;
                 for(;;) {
                     if (*p1 == '\0')
                         goto option_found;
                     if (*r1 != *p1)
             if (popt->flags & TCC_OPTION_HAS_ARG) {
                 if (*r1 != '\0' || (popt->flags & TCC_OPTION_NOSEP)) {
                     optarg = r1;
                 } else {
                     if (optind >= argc)
-                        error("argument to '%s' is missing", r);
+                        printf("\n argument to '%s' is missing", r);
                     optarg = argv[optind++];
+                }
             } else {
                 if (*r1 != '\0')
                     goto show_help;
             show_help:
                 help();
                 exit(1);
             case TCC_OPTION_I:
                 if (tcc_add_include_path(s, optarg) < 0)
-                    error("too many include paths");
+                    printf("\n too many include paths");
                 break;
             case TCC_OPTION_D:
+                {
                     char *sym, *value;
                     sym = (char *)optarg;
                         if (!strcmp(p, "coff")) {
                             s->output_format = TCC_OUTPUT_FORMAT_COFF;
                         } else
 #endif
+                        {
-                            error("target %s not found", p);
+                            printf("\n target %s not found", p);
+                        }
                     } else {
-                        error("unsupported linker option '%s'", optarg);
+                        printf("\n unsupported linker option '%s'", optarg);
+                    }
+                }
                 break;
             default:
                 if (s->warn_unsupported) {
                 unsupported_option:
                     warning("unsupported option '%s'", r);
+		    printf("\n unsupported option '%s'", r);
+                }
                 break;
+            }
+        }
+    }
     return optind;
+}
-int main(int argc, char **argv)
+int app_main(int argc, char **argv)
+{
     int i;
     TCCState *s;
     int nb_objfiles, ret, optind;
     char objfilename[1024];
+    int64_t start_time = 0;
+    int bug;
     int64_t start_time = 0;
     printf("\nTinyC compiler started.\n ");
 #ifdef WIN32
     /* on win32, we suppose the lib and includes are at the location
        of 'tcc.exe' */
     files = NULL;
     nb_files = 0;
     nb_libraries = 0;
     reloc_output = 0;
     print_search_dirs = 0;
+    printf("TinyC initializated.\n");
+    bug=argc;
+    if (bug==0) {bug==1;}
-    optind = parse_args(s, argc - 1, argv + 1) + 1;
+    optind = parse_args(s, bug - 1, argv + 1) + 1;
+    printf("\n Arguments parsed.\n");
     if (print_search_dirs) {
         /* enough for Linux kernel */
         printf("install: %s/\n", tcc_lib_path);
     /* if outfile provided without other options, we output an
        executable */
     if (outfile && output_type == TCC_OUTPUT_MEMORY)
         output_type = TCC_OUTPUT_EXE;
+    /* check -c
-    /* check -c consistency : only single file handled. XXX: checks file type */
+consistency : only single file handled. XXX: checks file type */
     if (output_type == TCC_OUTPUT_OBJ && !reloc_output) {
         /* accepts only a single input file */
         if (nb_objfiles != 1)
-            error("cannot specify multiple files with -c");
+            printf("\n cannot specify multiple files with -c");
         if (nb_libraries != 0)
-            error("cannot specify libraries with -c");
+            printf("\n cannot specify libraries with -c");
+    }
     if (output_type != TCC_OUTPUT_MEMORY) {
 #ifdef MEM_DEBUG
     if (do_bench) {
         printf("memory: %d bytes, max = %d bytes\n", mem_cur_size, mem_max_size);
+    }
 #endif
+    printf("\n TinyC finished work\n");
     return ret;
+}

Subversion Repositories Kolibri OS

(root)/programs/develop/metcc/trunk/source/tcc.c – Rev 145 → 609