コード例 #1
0
ファイル: compiler.c プロジェクト: axelmuhr/Helios-NG
static void pre_include(char *file)
{   FILE *f;
    if ((f = fopen(file, "r")) != NULL)
    {   pp_notesource(file, f);
        preprocess_only();
    }
    else
        cc_msg("can't open pre-include file %s (ignored)\n", file);
}
コード例 #2
0
ファイル: store.c プロジェクト: axelmuhr/Helios-NG
static char *new_synalloc_segment(void)
{
    char *w;
    if (synsegcnt >= segmax) expand_segmax(segmax * SEGMAX_FACTOR);
    if (bindsegcur < bindsegcnt)
    {   w = bindsegbase[--bindsegcnt];
        if (debugging(DEBUG_2STORE) && synsegcnt>0)
            cc_msg("Syntax store %d from binder size %ld at %p\n",
                    (int)synsegcnt, (long)SEGSIZE, w);
    }
    else
    {   w = (char *)cc_alloc(SEGSIZE);
        if (debugging(DEBUG_STORE))
            cc_msg("Syntax store alloc %d size %ld at %p (%s in $r)\n",
                    (int)synsegcnt, (long)SEGSIZE, w,
                    phasename, currentfunction.symstr);
    }
    return synsegbase[synsegcnt++] = w;
}
コード例 #3
0
ファイル: compiler.c プロジェクト: axelmuhr/Helios-NG
static PathElement *mk_path_element(PathElement *link, int flags, char *name)
{ PathElement *p;
  if (debugging(DEBUG_FILES))
    cc_msg("mk_path_element(%s)\n", name);
  p = (PathElement *) ccom_alloc((int32)strlen(name) + sizeof(PathElement));
  p->link = link;
  p->flags = flags;
  strcpy(p->name, name);
  return p;
}
コード例 #4
0
ファイル: hashset_test.c プロジェクト: 3k/Collections-C
void test_hashset_new()
{
    HashSetConf conf;
    hashset_conf_init(&conf);
    conf.initial_capacity = 7;

    HashSet *set = hashset_new_conf(&conf);

    cc_assert(hashset_size(set) == 0,
              cc_msg("hashset_new: Initial size not 0"));

    size_t capacity = hashset_capacity(set);

    /* power of 2 rounding */
    cc_assert(capacity == 8,
              cc_msg("hashset_new: Expected capactity was 8, but got %d",
                     capacity));

    hashset_destroy(set);
}
コード例 #5
0
ファイル: stack_test.c プロジェクト: 3k/Collections-C
void test_stack_pop()
{
    Stack *s = stack_new();

    int a = 1;
    int b = 2;
    int c = 3;

    stack_push(s, &a);
    stack_push(s, &b);
    stack_push(s, &c);

    cc_assert(stack_pop(s) == &c,
              cc_msg("stack_pop: Top stack element not as expected"));

    cc_assert(stack_peek(s) == &b,
              cc_msg("stack_pop: Top stack element not as expected"));

    stack_destroy(s);
}
コード例 #6
0
ファイル: store.c プロジェクト: axelmuhr/Helios-NG
static char *new_global_segment(void)
{
    char *w;
/* I will recycle a segment that had been used for local space if there  */
/* are any such available.                                               */
    if (bindsegcur < bindsegcnt)
    {   w = bindsegbase[--bindsegcnt];
        if (debugging(DEBUG_STORE))
            cc_msg("Global store %d from binder size %ld at %p\n",
                    (int)globallcnt, (long)SEGSIZE, w);
    }
    else
    {   w = (char *)cc_alloc(SEGSIZE);
        if (debugging(DEBUG_STORE))
            cc_msg("Global store alloc %d size %ld at %p (in $r)\n",
                    (int)globallcnt, (long)SEGSIZE, w, currentfunction.symstr);
    }
    globallcnt++;
    globallp = w, globalltop = w + SEGSIZE;
    return w;
}
コード例 #7
0
ファイル: store.c プロジェクト: axelmuhr/Helios-NG
void show_store_use(void)
{
#ifdef ENABLE_STORE
    cc_msg(
        "Total store use (excluding stdio buffers/stack) %ld bytes\n",
        (long)stuse_total);
    cc_msg("Global store use %ld/%ld + %ld bytes\n",
        (long)((int32)globallcnt*SEGSIZE - (globalltop - globallp)),
        (long)((int32)globallcnt*SEGSIZE),
        (long)globallxtra);
    cc_msg(
        "  thereof %ld+%ld bytes pended relocation, %ld bytes pended data\n",
        (long)stuse[(int)SU_Xref],
        (long)stuse[(int)SU_Xsym],
        (long)stuse[(int)SU_Data]);
    cc_msg(
        "  %ld bytes symbols, %ld bytes top-level vars, %ld bytes types\n",
        (long)stuse[(int)SU_Sym],
        (long)stuse[(int)SU_Bind],
        (long)stuse[(int)SU_Type]);
    cc_msg(
        "  %ld bytes constants, %ld bytes pre-processor, %ld bytes wasted\n",
        (long)stuse[(int)SU_Const], (long)stuse[(int)SU_PP], (long)stuse_waste);
    cc_msg( "Local store use %ld+%ld/%ld bytes - front end max %ld\n",
        (long)synallmax, (long)bindallmax,
        (long)((int32)(int)(synsegcnt+bindsegcnt)*SEGSIZE),
        (long)maxAEstore);
#endif /* ENABLE_STORE */
}
コード例 #8
0
ファイル: store.c プロジェクト: axelmuhr/Helios-NG
static char *new_bindalloc_segment(void)
{
    if (bindsegcur >= bindsegcnt)
    {   char *w = (char *)cc_alloc(SEGSIZE);
        if (bindsegcnt >= segmax) expand_segmax(segmax * SEGMAX_FACTOR);
        if (debugging(DEBUG_STORE))
            cc_msg("Binder store alloc %d size %ld at %p (%s in $r)\n",
                    (int)bindsegcnt, (long)SEGSIZE, w,
                    phasename, currentfunction.symstr);
        bindsegbase[bindsegcnt++] = w;
    }
    return bindsegbase[bindsegcur++];
}
コード例 #9
0
ファイル: compiler.c プロジェクト: axelmuhr/Helios-NG
static FILE *try_instore_file(char *file, bool *sf)
{   FILE *include_file;
    if (debugging(DEBUG_FILES)) cc_msg("Try instore file '%s'\n", file);
    include_file = open_builtin_header(file, sf);
    if (include_file != NULL)
    {   show_h_line(1, file, NO);
#ifdef TARGET_IS_HELIOS
        push_include(NULL, file, PE_SYS);
#else
        push_include(NULL, file);
#endif
    }
    return include_file;
}
コード例 #10
0
ファイル: store.c プロジェクト: axelmuhr/Helios-NG
void alloc_mark(void)           /* @@@ not used essentially for C       */
{
    Mark *p;
    if ((p = freemarks) != NULL)
        freemarks = p->prev;
    else
        p = (Mark *) GlobAlloc(SU_Other, sizeof(Mark));

    p->prev = marklist; marklist = p;
    p->syn_segno = synsegcnt;
    p->syn_allp = synallp; p->syn_hwm = synallhwm;
    p->bind_segno = bindsegcur;
    p->bind_allp = bindallp; p->bind_hwm = bindallhwm;

    if (debugging(DEBUG_STORE))
        cc_msg("Mark %d, %p, %lx :: %d, %p, %lx\n",
                synsegcnt, synallp, (long)synallhwm,
                bindsegcur, bindallp, (long)bindallhwm);
}
コード例 #11
0
ファイル: compiler.c プロジェクト: axelmuhr/Helios-NG
static void rtcheck_set(char *opts)
{
  int opt;
  int32 new_rtcheck;

  for (opt = *opts; opt != 0; opt = *++opts) {
      new_rtcheck = 0;
      switch (safe_toupper(opt)) {
          case 'A': new_rtcheck = RTCHECK_ARRAY;     break;
          case 'C': new_rtcheck = RTCHECK_CASE;      break;
          case 'N': new_rtcheck = RTCHECK_NIL;       break;
          case 'R': new_rtcheck = RTCHECK_REFERENCE; break;
          case 'P': new_rtcheck = RTCHECK_ASSERT; break;
          case 'D': new_rtcheck = RTCHECK_DEADCODE;  break;
          default:  cc_msg("unknown option -r%c: ignored\n", opt);
      }
      rtcheck ^= new_rtcheck;
  }
}
コード例 #12
0
ファイル: compiler.c プロジェクト: axelmuhr/Helios-NG
static void disable_warnings(char *opts)
{
  int opt = *opts;
  int32 new_suppress;

  if (opt == 0)
  {
      var_warn_implicit_fns   = 0;
      var_warn_deprecated     = 0;
      feature |= FEATURE_NOWARNINGS;
      suppress |= D_ASSIGNTEST | D_IMPLICITNARROWING | D_IMPLICITVOID |
                  D_PPNOSYSINCLUDECHECK;
  }
  else
  {
    while (opt)
    {
      new_suppress = 0L;
      switch (safe_toupper(opt))
      {
case 'A': new_suppress = D_ASSIGNTEST;          break;
case 'N': new_suppress = D_IMPLICITNARROWING;   break;
case 'P': new_suppress = D_PPNOSYSINCLUDECHECK; break;
case 'V': new_suppress = D_IMPLICITVOID;        break;
case 'D': var_warn_deprecated = 0;              break;
case 'F': var_warn_implicit_fns = 0;            break;

/* Do I really want to put this in the new version ??? Tony 3/1/95 */
#if 0 
#ifdef TARGET_IS_C40
case 'X':
    new_suppress = D_VOIDRETURN;		break;
#endif
#endif /* 0 */

default:  cc_msg("unknown option -w%c: ignored\n", opt);
      }
      suppress |= new_suppress;
      opt = *++opts;
    }
  }
}
コード例 #13
0
ファイル: store.c プロジェクト: axelmuhr/Helios-NG
VoidStar GlobAlloc(StoreUse t, int32 n)
{   char *p = globallp;
    n = n + 3 & ~(int32)3;     /* make n a multiple of sizeof(int) */
    if (n > SEGSIZE)
    {   /* Big global store requests get a single oversize page.        */
        p = (char *)cc_alloc(n);
        if (debugging(DEBUG_STORE))
            cc_msg("Global overlarge store alloc size %ld at %p (in $r)\n",
                    (long)n, p, currentfunction.symstr);
        globallxtra += n;               /* could update globallcnt?     */
    }
    else
    {   if (p+n > globalltop)
            stuse_waste += globalltop-p,
            p = new_global_segment();
        globallp = p + n;
    }
    stuse[(int)t] += n;
    return p;
}
コード例 #14
0
ファイル: store.c プロジェクト: axelmuhr/Helios-NG
/* #ifdef PASCAL_OR_FORTRAN -- comment out? */
void alloc_unmark(void)
{
    Mark *p = marklist;
    if (p->prev == NULL) syserr(syserr_alloc_unmark);
    if (synsegcnt > p->syn_segno)
        syserr(syserr_alloc_unmark1);
    marklist = p->prev;
    p->prev = freemarks; freemarks = p;
    synsegcnt = p->syn_segno; synallp = p->syn_allp;
    synalltop = (synallp == DUFF_ADDR) ? (char *)DUFF_ADDR
                                       : synsegbase[synsegcnt-1] + SEGSIZE;
    synallhwm = p->syn_hwm;
    bindsegcur = p->bind_segno; bindallp = p->bind_allp;
    bindalltop = (bindallp == DUFF_ADDR) ? (char *)DUFF_ADDR
                                         : bindsegbase[bindsegcur-1] + SEGSIZE;
    bindallhwm = p->bind_hwm;

    if (debugging(DEBUG_STORE))
        cc_msg("Unmark %d, %p, %lx :: %d, %p, %lx\n",
                synsegcnt, synallp, (long)synallhwm,
                bindsegcur, bindallp, (long)bindallhwm);
}
コード例 #15
0
ファイル: hashset_test.c プロジェクト: 3k/Collections-C
void test_hashset_iter_next()
{
    HashSet *hs = hashset_new();

    char *a = "foo";
    char *b = "bar";
    char *c = "baz";

    hashset_add(hs, a);
    hashset_add(hs, b);
    hashset_add(hs, c);

    size_t x = 0;
    size_t y = 0;
    size_t z = 0;

    HashSetIter iter;
    hashset_iter_init(&iter, hs);

    while (hashset_iter_has_next(&iter)) {
        char const *e = hashset_iter_next(&iter);

        if (!strcmp(e, "foo"))
            x++;

        if (!strcmp(e, "bar"))
            y++;

        if (!strcmp(e, "baz"))
            z++;
    }

    cc_assert((x == 1) && (y == 1) && (z == 1),
              cc_msg("hashset_iter: Unexpected number of "
                     "elements returned by the iterator"));

    hashset_destroy(hs);
}
コード例 #16
0
ファイル: store.c プロジェクト: axelmuhr/Helios-NG
VoidStar BindAlloc(int32 n)
{
    char *p = bindallp;
    n = n + 3 & ~(int32)3;     /* make n a multiple of sizeof(int) */
    if (n > SEGSIZE) syserr(syserr_overlarge_store1, (long)n);
    if (p + n > bindalltop)
    {   int i;                                 /* 0..segmax */
        if (bindsegcur > 0)
            bindsegptr[bindsegcur-1] = p;      /* stash highest used */
        for (i = marklist->bind_segno;; i++)   /* search for scraps  */
        {   if (i == bindsegcur)               /* nowhere big enough */
            {   p = new_bindalloc_segment();
                bindalltop = p + SEGSIZE;
                break;
            }
            p = bindsegptr[i];                 /* hope springs eternal */
            bindalltop = bindsegbase[i] + SEGSIZE;
            if (p+n <= bindalltop)             /* fingers crossed      */
            {   /* we have scavenged something useful - swap to current */
                char *t = bindsegbase[i];
                bindsegbase[i] = bindsegbase[bindsegcur-1];
                bindsegbase[bindsegcur-1] = t;
                bindsegptr[i] = bindsegptr[bindsegcur-1];
                if (debugging(DEBUG_2STORE))
                {   cc_msg("Scavenge binder %d (%p), %ld left\n",
                            (int)i, t, (long)(bindalltop-(p+n)));
                }
                break;
            }
        }
        bindsegptr[bindsegcur-1] = (char *)DUFF_ADDR;
    }
    bindallp = p + n;
    if ((bindallhwm += n) > bindallmax) bindallmax = bindallhwm;
    return p;
}
コード例 #17
0
ファイル: compiler.c プロジェクト: axelmuhr/Helios-NG
extern void driver_abort(char *message)
{
  cc_msg("Compilation aborted: %s\n",message );
  exit(EXIT_error);
}
コード例 #18
0
ファイル: compiler.c プロジェクト: axelmuhr/Helios-NG
static void set_compile_options(int argc, char *argv[])
{
  int count, files = 0;
  char message[MAX_NAME];

   /* AM: the following code is intended to deal with things like          */
   /* __CLK_TCK (see <time.h>) being different for different targets.      */
   /* It probably needs better amalgamation into Acorn's code for predefs  */
#ifdef TARGET_PREDEFINES
    {   static char *predefs[] = TARGET_PREDEFINES;
        int i;
        for (i=0; i < sizeof(predefs)/sizeof(predefs[0]); i++)
            /* note that the arg may be of the form "name" or "name=toks" */
            /* the "name" for is equivalent to "name=1".                  */
            pp_predefine(predefs[i]);
    }
#endif

  for (count=1;  count < argc;  ++count)
  {   char *current = argv[count];
      if (current[0] == '-' && current[1] != 0)
      {
          switch (safe_toupper(current[1]))
          {
      case 'C': if (ccom_flags & FLG_PREPROCESS)
                    feature |= FEATURE_PPCOMMENT;
                else
                    ccom_flags |= FLG_NO_OBJECT_OUTPUT;
                break;

      case 'D': pp_predefine(current+2);      break;

      case 'E': /* do we wish to fault -Exxx more generally?            */
#ifdef DISABLE_ERRORS
                if (current[2])
                {   disable_errors(current+2);
                    break;
                }
#endif
#ifdef COMPILING_ON_MVS
                if (current[2])
                {   cc_msg(
       "Obsolete use of '%s' to suppress errors -- use '-zu' for PCC mode\n",
                           current);
                    break;
                }
#endif
                ccom_flags = (ccom_flags | FLG_PREPROCESS) & ~FLG_COMPILE;
                break;

      case 'F': feature_set(current+2);       break;

#ifdef TARGET_HAS_DEBUGGER
      case 'G': usrdbg_set(current+2);        break;
#endif

      case 'I': set_include_path(current+2, PE_USER);  break;

      case 'J': ccom_flags &= ~FLG_INSTORE_FILES_IMPLICITLY;
                set_include_path(current+2, PE_SYS);  break;

      case 'K': ccom_flags |= FLG_COUNTS;
                break;

#ifndef NO_LISTING_OUTPUT
      case 'L': ccom_flags |= FLG_LISTING;
                listingfile = current + 2;
                break;
#endif

      case 'M': ccom_flags |= FLG_MAKEFILE;
                if (current[2] == '<' || current[2] == 0)
                {   ccom_flags &= ~(FLG_COMPILE+FLG_NOSYSINCLUDES);
                    if (current[2] == '<') ccom_flags |= FLG_NOSYSINCLUDES;
                }
                else
                    makefile = current+2;
                break;

      case 'O': /*
                 * Hum, really we should never get here because this
                 * this should be done by -zpz1.
                 */
                break;

/* Paranoid define check. Tony 3/1/95 */
#ifdef TARGET_HAS_PROFILE
#error	Old style define TARGET_HAS_PROFILE (replaced by TARGET_HAS_PROFILER)
#endif

#ifdef TARGET_HAS_PROFILER
      case 'P': { int ch = safe_toupper(current[2]);
                  int32 profile = 1L;
                  if (ch == 0)
                    /* do nothing */;
                  else if (ch == 'G' || ch == 'X' && current[3] == 0)
                    profile = 2L;
                  else
                    cc_msg("unknown profile option %s: -p assumed\n",current);
                  var_profile_option = profile;
                }
                break;
#endif /* TARGET_HAS_PROFILER */

      case 'R':
#ifdef PASCAL /*ECN*/
                rtcheck_set(current+2);
#else
                feature &= ~FEATURE_WR_STR_LITS;
#endif
                break;

      case 'S': asmfile = current+2;  /* "" for -S */
#ifdef COMPILING_ON_MVS
                /* pesky cc163 compatibility */
                if (*asmfile == 0 && count+1<argc)
                    asmfile = argv[++count];
#endif
                break;

#ifdef TARGET_IS_XPUTER
      case 'T': /* -tn sets processor type == -tn */
	  	pragma_set(current + 1);
	  	break;
#endif
	  

      case 'U': pp_preundefine(current+2);          break;

      case 'W': disable_warnings(current+2);        break;

#ifdef TARGET_IS_MVS    /* TARGET_USES_CCOM_INTERFACE ??? */
/* The following case provides -Xcsectname for CC 163 compatibility.    */
/* It may be that the CCOM-style interface should stuff ALL unknown     */
/* options to mcdep_config_option()?                                    */
      case 'X': if (!mcdep_config_option(current[1], current+2))
                    cc_msg("unknown option %s: ignored\n", current);
                break;
#endif

      case 'Z': switch(safe_toupper(current[2]))
                {
          case 'B': target_lsbitfirst = !target_lsbytefirst;
                    if (isdigit(current[3]))
                        target_lsbitfirst = (current[3]-'0');
                    break;
#ifdef TARGET_ENDIANNESS_CONFIGURABLE
          case 'E': { int lsbytefirst = current[3] - '0';
                      if (lsbytefirst)
                          config &= ~CONFIG_BIG_ENDIAN;
                      else
                          config |= CONFIG_BIG_ENDIAN;
                      target_lsbitfirst = lsbytefirst;
                    }
                    break;
#endif
          case 'C': feature |= FEATURE_SIGNED_CHAR;
                    break;
          case 'F': feature = (feature | FEATURE_FUSSY) & ~FEATURE_LIMITED_PCC;
                    break;
          case 'I': pre_include(current+3);
                    break;
          case 'J': config |= CONFIG_INDIRECT_SETJMP;  /* related to -fR */
                    break;
          case 'P': pragma_set(current+3);
                    break;
          case 'O': feature |= FEATURE_AOF_AREA_PER_FN;
                    break;
          case 'Q': debug_set(current+3);
                    break;
#ifndef TARGET_IS_HELIOS
          case 'S': system_flavour = current+3;
                    break;
#endif
          case 'U': feature |= pcc_features();
                    break;
#ifdef TARGET_IS_TRAN
	      /*
	       * Addition to remove C++ warnings (for fussy IGM people).
	       * Tony 8/2/95.
	       */
	  case 'W':
	      feature |= FEATURE_NO_CPLUSPLUS_WARNINGS;
	      
	      break;
#endif /* TARGET_IS_TRAN */

#ifdef PASCAL /*ECN*/
          case 'Z': feature |= FEATURE_ISO;
                    break;
#endif
          default:  if (!mcdep_config_option(current[2], current+3))
                        cc_msg("unknown option %s: ignored\n", current);
                    break;
                }
                break;
      default:  cc_msg("unknown option %s: ignored\n", current);
                break;
          }
      }
      else
      {
          switch (++files)
          {
      case 1:   if (strcmp(current, "-") == 0)
                {   /* then just leave as stdin */
#ifdef COMPILING_ON_RISC_OS
#  ifndef OBSOLETE_ARM_NAMES
                    /* Hack round default no-buffering library.         */
                    setvbuf(stdin, NULL, _IOLBF, 256);
#  endif
#endif
                }
                else if (freopen(current,"r",stdin) != NULL)
                {   UnparsedName unparse;
                    char new_dir[MAX_NAME];
                    ccom_flags &= ~FLG_STDIN;
                    sourcefile = current;
                    /*
                     * Add path name of source file to the -I list.
                     */
                    translate_fname(current, &unparse, new_dir);
                    new_dir[unparse.un_pathlen] = '\0';
                    path_hd = mk_path_element(path_hd, PE_USER, new_dir);
/* Make sure path_tl is always the tail, even if file precedes -I    */
                    if (path_hd->link == 0) path_tl = path_hd;
                }
                else
                {
                    sprintf(message, "couldn't read file '%s'", current);
                    driver_abort(message);
                }
                break;
      case 2:   objectfile = current;
                break;
      default:  driver_abort("too many file arguments");
          }
      }
  }
  if (ccom_flags & FLG_STDIN)
  {   path_hd = mk_path_element(path_hd, PE_USER, "");
      if (path_hd->link == 0) path_tl = path_hd;
  }

#ifdef TARGET_HAS_SEPARATE_CODE_DATA_SEGS
  /* On machines like amd29000 code and data buses are separate    */
  /* so that all non-instruction data must go in the data segment. */
#if defined TARGET_IS_C40
  /*
   * Ho Hum
   *
   * The problem is that programs built with the -Zr option, (such as
   * the kernel and device drivers), do not have a static data area.
   * This means that strings MUST be placed into the code segment.  BUT
   * on the C40 data pointers can only address 1/4 of the address map, and
   * so they may not be able to reach the code segment.  (This is especially
   * true when you consider that the C40 has two address buses, and the plan
   * is to have data on one bus and code on the other).  HENCE by default we
   * want to disable placing strings in the code segment, but for -Zr programs
   * we have no choice ...
   */
  
  if (suppress_module != 1)
    {
      feature |= FEATURE_WR_STR_LITS;
    }
  else
    {
      feature &= ~FEATURE_WR_STR_LITS;
    }
#else
  feature |= FEATURE_WR_STR_LITS;
#endif /* TARGET_IS_C40 */
#endif /* TARGET_HAS_SEPARATE_CODE_DATA_SEGS */

  if (ccom_flags & FLG_COMPILE)
  {
      /* under the driver.c interface at most one of the following is true */
#ifndef NO_OBJECT_OUTPUT
      if (objectfile[0] != '\0' && !(ccom_flags & FLG_NO_OBJECT_OUTPUT))
      {   objstream = cc_open(objectfile, BINARY_FILE);
# ifdef COMPILING_ON_RISC_OS
          set_time_stamp(objectfile, NO);
# endif
      }
#endif
#ifndef NO_ASSEMBLER_OUTPUT
      if (asmfile[0] != '\0') asmstream = cc_open(asmfile, TEXT_FILE);
#endif
      if (objectfile[0] == '\0' && asmfile[0] == '\0')
      {
          asmstream = stdout;
          feature |= FEATURE_ANNOTATE;   /* simple test use */
      }

#ifndef NO_LISTING_OUTPUT
      if (ccom_flags & FLG_LISTING)
      {
          if (listingfile[0] != '\0')
          {
              listingstream = cc_open(listingfile, TEXT_FILE);
              if (listingstream != stdout)   /* @@@ get rid of this hack */
                  fprintf(listingstream, "     1  ");
          }
          else listingstream = stdout;
          if (ccom_flags & FLG_COUNTS)
          { FILE *map = fopen("counts", "rb");
            if (map == NULL) driver_abort("couldn't read \"counts\" file");
            if (!map_init(map)) driver_abort("malformed \"counts\" file");
          }
      }
#endif
  }

  if (ccom_flags & FLG_MAKEFILE)
  {
      if (makefile[0] == 0)
          makestream = stdout;
      else
      {
          makestream = cc_open(makefile, TEXT_FILE);
      }
      /*
       *  Print out source file and object file for -M option
       */
      fprintf(makestream, DEPEND_FORMAT, objectfile, sourcefile);
  }
}
コード例 #19
0
ファイル: compiler.c プロジェクト: axelmuhr/Helios-NG
static void debug_set(char *opts)
{
  int opt;
  long debugmask = 0L;

  for (opt = *opts;  opt != 0;  opt = *++opts)
  {
    debugmask = 0L;
    switch (safe_toupper(opt))
    {
#ifdef ENABLE_AETREE
case 'A': debugmask = DEBUG_AETREE;    break;
#endif
#ifdef ENABLE_BIND
case 'B': debugmask = DEBUG_BIND;      break;
#endif
#ifdef ENABLE_CSE
case 'C': cse_debugcount++;
          debugmask = DEBUG_CSE;       break;
#endif
#ifdef ENABLE_DATA
case 'D': debugmask = DEBUG_DATA;      break;
#endif
#ifdef ENABLE_FNAMES
case 'F': debugmask = DEBUG_FNAMES;    break;
#endif
#ifdef ENABLE_CG
case 'G': debugmask = DEBUG_CG;        break;
#endif
#ifdef ENABLE_SPILL
case 'H': debugmask = DEBUG_SPILL;     break;
#endif
#ifdef ENABLE_FILES
case 'I': debugmask = DEBUG_FILES;     break;
#endif
#ifdef ENABLE_LOCALCG
case 'K': localcg_debugcount++;
          debugmask = DEBUG_LOCALCG;   break;
#endif
#ifdef ENABLE_LEX
case 'L': debugmask = DEBUG_LEX;       break;
#endif
#ifdef ENABLE_MAPSTORE
case 'M': debugmask = DEBUG_MAPSTORE;  break;
#endif
#ifdef ENABLE_OBJ
case 'O': debugmask = DEBUG_OBJ;       break;
#endif
#ifdef ENABLE_PP
case 'P': debugmask = DEBUG_PP;        break;
#endif
#ifdef ENABLE_Q
case 'Q': debugmask = DEBUG_Q;         break;
#endif
#ifdef ENABLE_REGS
case 'R': debugmask = DEBUG_REGS;      break;
#endif
#ifdef ENABLE_SYN
case 'S': debugmask = DEBUG_SYN;       break;
#endif
#ifdef ENABLE_TYPE
case 'T': debugmask = DEBUG_TYPE;      break;
#endif
#ifdef ENABLE_STORE
case 'U': debugmask = DEBUG_STORE;     break;
#endif
#ifdef ENABLE_2STORE
case 'W': debugmask = DEBUG_2STORE;    break;
#endif
#ifdef ENABLE_X
case 'X': debugmask = DEBUG_X;         break;
#endif
#ifdef ENABLE_LOOP
case 'Y': debugmask = DEBUG_LOOP;      break;
#endif
/*
 * -Qz to modify syserr behaviour is always available
 */
case 'Z': syserr_behaviour++;
#ifndef COMPILING_ON_MSDOS
#ifdef __CC_NORCROFT
          (void) signal(SIGINT, SIG_DFL);     /* permit NorCroft backtrace */
#endif
#endif
          break;
default:  cc_msg("unknown option -zq%c: ignored\n", opt);
    }
    sysdebugmask |= debugmask;
  }
}
コード例 #20
0
ファイル: compiler.c プロジェクト: axelmuhr/Helios-NG
static void feature_set(char *opts)
{
  int opt;
#define UNUSED 0
  static int32 feature_flags[] = {
        /* 'A' */ FEATURE_ANOMALY,
        /* 'B' */ FEATURE_VERBOSE,
        /* 'C' */ FEATURE_LIMITED_PCC,
#ifdef TARGET_IS_C40
        /* 'D' */ FEATURE_OLD_STUBS,
#else
        /* 'D' */ UNUSED,
#endif
        /* 'E' */ FEATURE_6CHARMONOCASE,
        /* 'F' */ 0L-FEATURE_SAVENAME,               /* N.B. -ve */
        /* 'G' */ UNUSED,
        /* 'H' */ FEATURE_PREDECLARE,
        /* 'I' */ FEATURE_USERINCLUDE_LISTING,
        /* 'J' */ FEATURE_SYSINCLUDE_LISTING,
        /* 'K' */ FEATURE_KANDR_INCLUDE,
        /* 'L' */ FEATURE_DONTUSE_LINKREG,
        /* 'M' */ FEATURE_PPNOUSE,
        /* 'N' */ FEATURE_SAVENAME,
        /* 'O' */ FEATURE_WARNOLDFNS,
        /* 'P' */ FEATURE_TELL_PTRINT,
        /* 'Q' */ FEATURE_ALLOWCOUNTEDSTRINGS,
        /* 'R' */ FEATURE_LET_LONGJMP_CORRUPT_REGVARS,
        /* 'S' */ FEATURE_ANNOTATE,
#ifdef TARGET_IS_C40
        /* 'T' */ 0L - FEATURE_WARNOLDFNS,
#else
        /* 'T' */ UNUSED,
#endif
        /* 'U' */ FEATURE_UNEXPANDED_LISTING,
        /* 'V' */ FEATURE_NOUSE,
        /* 'W' */ FEATURE_WR_STR_LITS,
        /* 'X' */ UNUSED,
        /* 'Y' */ UNUSED,
        /* 'Z' */ FEATURE_INLINE_CALL_KILLS_LINKREG
    };
#undef UNUSED

  for (opt = *opts;  opt != 0;  opt = *++opts)
  {   int ch = safe_toupper(opt);
      if (ch >= 'A')
      {   int n = ASCII(ch) - ASCII('A');
          if (n < sizeof(feature_flags)/sizeof(int32))
          {   int32 flag = feature_flags[n];
              if (flag < 0)
                  feature &= ~-flag;
              else if (flag > 0)
                  feature |= flag;
              else
                  goto unknown;
          }
          else if (ch == 'X')
              suppress &= ~D_SUPPRESSED;
          else if (ch == 'Z')
              ccom_flags |= FLG_USE_SYSTEM_PATH;
          else
unknown:      cc_msg("unknown option -f%c: ignored\n", opt);
      }
  }
}
コード例 #21
0
ファイル: compiler.c プロジェクト: axelmuhr/Helios-NG
extern FILE *pp_inclopen(char *file, bool systemheader,
            bool *sf, char **hostname)
{
  FILE *new_include_file;
  UnparsedName unparse;
  char new_file[MAX_NAME];

  *hostname = file;
  translate_fname(file, &unparse, new_file);

  if (!(unparse.type & FNAME_ROOTED))
  {   PathElement *p;
#ifndef NO_INSTORE_FILES
      if ((ccom_flags & FLG_INSTORE_FILES_IMPLICITLY) && systemheader)
      {
/* Note that it is important for portability (even across unix/riscos)  */
/* to have the original 'file' and not the munged 'new_file' instore.   */
          new_include_file = try_instore_file(file, sf);
          if (new_include_file != NULL) return new_include_file;
      }
#endif
      p = path_hd;
      if (systemheader || (ccom_flags & FLG_USE_SYSTEM_PATH)) p = p->link;
      while (p != NULL)
      {   char current[MAX_NAME];
          if (p->flags & INSTORE_FILE)
          {
#ifndef NO_INSTORE_FILES
/* Note that it is important for portability (even across unix/riscos)  */
/* to have the original 'file' and not the munged 'new_file' instore.   */
              new_include_file = try_instore_file(file, sf);
              if (new_include_file != NULL) return new_include_file;
#endif
          }
#ifdef TARGET_IS_HELIOS
	  /*
	   * XXX - NC - 14/5/93 (Day after official C40 release!)
	   *
	   * The code appears to just skip the first element in the
	   * include path list if the file is a system file.  This
	   * is wierd, since the flags field encodes whether the
	   * directory has been added to the list as a user or a
	   * system file.
	   */
	  
	  else if (((p->flags & PE_USER) && !systemheader) ||
		   ((p->flags & PE_SYS)  &&  systemheader)  )
#else
          else /* current path is not :mem */
#endif
          {   strcpy(current, p->name);
              if (strlen(current) + strlen(new_file) + 1 <= MAX_NAME)
              {   strcat(current, new_file);
                  if (debugging(DEBUG_FILES))
                      cc_msg("Try file '%s'\n", current);
                  if ((new_include_file = fopen(current, "r")) != 0)
                  {   if (!(systemheader && (ccom_flags & FLG_NOSYSINCLUDES)))
                          show_h_line(1, current, YES);
#ifdef TARGET_IS_HELIOS
                      *hostname = push_include(current, current, p->flags);
#else
                      *hostname = push_include(current, current);
#endif
                      return new_include_file;
                  }
		  else if (debugging(DEBUG_FILES))
		    cc_msg("Open attempt failed, errno = %d\n", errno );
              }
          }
          p = p->link;
      }
#ifndef NO_INSTORE_FILES
/* Not found - ANSI require looking for "stdio.h" as <stdio.h> when all */
/* else has failed.                                                     */
/* Note that it is important for portability (even across unix/riscos)  */
/* to have the original 'file' and not the munged 'new_file' instore.   */
      return try_instore_file(file, sf);
#endif
  }