Question

编辑：我已经解决了一些指出的问题，但真正的问题仍未解决。

这个bash脚本：

set -vx

/usr/bin/llvm-gcc-4.2 -ansi -g -o mytest mytest.c 
ls -l mytest
./mytest
file mytest

生成此输出：

/usr/bin/llvm-gcc-4.2 -ansi -g -o mytest mytest.c 
++ /usr/bin/llvm-gcc-4.2 -ansi -g -o mytest mytest.c
ls -l mytest
++ ls -l mytest
-rwxr-xr-x  1 jimslager  wheel  37496 May 27 17:26 mytest
./mytest
++ ./mytest
error: unknown command ./mytest
file mytest
++ file mytest
mytest: Mach-O 64-bit executable x86_64

我已经从我已经使用了几个月的更大的东西中提取了这个，但从未见过像这样的结果。 gcc如何生成一个没有错误或警告但对象未知的对象？

我会发布test.c如果有人问，但是很长，我的问题似乎与test.c中的内容无关。

编辑：这是代码。对不起，这太久了。

/* Test Exercise 5-10: Write the program myexpr, which evaluates a reverse Polish expression from the command line, where each operator or operand is a separate argument.  For example,
 *      expr 2 3 4 + *
 * evaluates 2 x (3+4).
 * */
#include <stdio.h>
#include <string.h>
#define MAXLINE 68
#define TABSIZE 8
#define TAB '`'
#define SPACE '-'
#define NEW '\\'
#define TRUE 1
#define FALSE 0
#define IN 1
#define OUT 0
#define FOLDLENGTH 20
#define MAXLEN 12
#define SMALLER(i, j) ((i) > (j) ? (j) : (i))
#define N(c) (c=='\0' ? '\\' : c)

/* #include "subs.c" */

#define MAXOP 100 /* max size of operand or operator */ 
#define NUMBER '0' /* signal that a number was found */

int getop(char []); 
void push(double); 
double pop(void);
double top(void);
void dup(void);
void clear(void);
void stackswap(void);
double atof(char s[]);
int myisdigit(char c);
int myisspace(char c);

/* reverse Polish calculator */ 
int main(int argc, char *argv[]) 
{
    int type; 
    double op2; 
    char s[MAXOP];

    while (--argc>0) 
        while (type = getop(&(*++argv[0])))
printf("Just after while: type = %d, *argv[0] = %s\n", type, *argv);
        switch (type) {
        case NUMBER: 
            push(atof(*argv));
printf("NUMBER: atof(*argv[0]) = %g, *argv[0] = %s\n", atof(*argv), *argv);
            break; 
        case '+':
printf("+ detected\n");
            push(pop() + pop());
            break; 
        case '*':
printf("* detected\n");
            push(pop() * pop()); 
            break; 
        case '-':
printf("- detected\n");
            op2 = pop(); 
            push(pop() - op2);
            break;
        case '/': 
printf("/ detected\n");
            op2 = pop();
            if (op2 != 0.0) 
                push(pop() / op2);
            else
                printf("error: zero divisor\n"); 
            break;
        case '%': 
printf("Modulo detected\n");
            op2 = pop();
            if (op2 != 0.0) 
                push((int) pop() % (int) op2);
            else
                printf("error: zero divisor\n"); 
            break;
        case 't':
printf("t detected\n");
            printf("%g\n", top());
            break; 
        case 'd':
printf("d detected\n");
            dup();

            break; 
        case 's': 
printf("s detected\n");
            stackswap();
            break;
        case 'c':
printf("c detected\n");
            clear();
            break;
        case '\n': 
printf("\\n detected\n");
            printf("\t%.8g\n", pop()); 
            break;
        default: 
            printf("error: unknown command %s\n", *argv); 
            break;
        }
     return 0;
}

#define MAXVAL 100 /* maximum depth of val stack */

int sp = 0; /* next free stack position */ 
double val[MAXVAL]; /* value stack */

/* push: push f onto value stack */ 
void push(double f) 
{
printf("push: Started.   f = %g, sp = %d\n", f, sp);
    if (sp < MAXVAL) 
        val[sp++] = f;
    else
        printf("error: stack full, can't push %g\n", f);
printf("push: Finished.  f = %g, sp = %d\n", f, sp);
}

/* dup: duplicate top of stack */ 
void dup(void) 
{
printf("dup: Started.   top = %g, sp = %d\n", top(), sp);
    push(top());
printf("dup: Finished.   top = %g, sp = %d\n", top(), sp);
}

/* pop: pop and return top value from stack */ 
double pop(void) 
{
printf("pop: sp = %d, val[--sp] = %g\n", sp, val[sp-1]);
    if (sp > 0) 
        return val[--sp];
    else { 
        printf("error: stack empty\n"); 
        return 0.0;
    }
}

/* top: return top value from stack without changing sp */ 
double top(void) 
{
printf("top: sp = %d, val[0] = %g\n", sp, val[0]);
    if (sp > 0) 
        return val[sp-1];
    else { 
        printf("error: stack empty\n"); 
        return 0.0;
    }
}

/* stackswap: swap the top 2 values in stack */
void stackswap(void)
{
printf("Starting stackswap: val[sp-1] = %g, val[sp-2] = %g\n", val[sp-1], val[sp-2]);
    double op2, op3;
    op2 = pop();
    op3 = pop();
    push(op2);
    push(op3);
printf("Finishing stackswap: val[sp-1] = %g, val[sp-2] = %g\n", val[sp-1], val[sp-2]);
}

/* clear: clear the stack */
void clear(void)
{
    sp = 0;
}

int getch(void); 
void ungetch(int);

/* getop: get next character or numeric operand */ 
int getop(char s[]) 
{
    int i, c;

    while ((s[0] = c = getch()) == ' ' || c == '\t')
        ;
    s[1] = '\0'; 
    if (!isdigit(c) && c != '.')
        return c; /* not a number */
    i = 0;
    if (isdigit(c)) /* collect integer part */ 
        while (isdigit(s[++i] = c = getch()))
            ;
    if (c=='.') /* collect fraction part */
        while (isdigit(s[++i] = c = getch())) ;
    s[i] = '\0'; 
    if (c != EOF)
        ungetch(c); 
    return NUMBER;
}

#define BUFSIZE 100

char buf[BUFSIZE];  /* buffer for ungetch */ 
int bufp = 0;   /* next free position in buf */

int getch(void) /* get a (possibly pushed-back) character */ 
{
    return (bufp > 0) ? buf[--bufp] : getchar();
}

void ungetch(int c) /* push character back on input */ 
{
    if (bufp >= BUFSIZE) 
        printf("ungetch: too many characters\n");
    else
        buf[bufp++] = c;
}

/* atof: convert s to double */
double atof(char s[])
{
    double val, power, epower, d; 
    int i, j, sign, esign=0, eval;
printf("atof: s = %s\n", s);

    for (i = 0; myisspace(s[i]); i++); /* skip white space */

    sign = (s[i] == '-') ? -1 : 1; /* Determine sign and strip it */
    if (s[i] == '+' || s[i] == '-')
        i++; 

    for (val = 0.0; myisdigit(s[i]); i++) /* Determine value before dec point */
        val = 10.0 * val + (s[i] - '0'); 

    if (s[i] == '.')
        i++; 

    for (power = 1.0; myisdigit(s[i]); i++) { /* include value after dec */
        val = 10.0 * val + (s[i] - '0'); 
        power *= 10;            /* power is where . goes */
    } 

    if (s[i]=='e' || s[i]=='E') { /* Exponential form */

        esign = (s[++i]=='-') ? -1 : 1; /* Sign of exponent */
        if (s[i]=='+' || s[i]=='-')
            i++;

        for (epower=0.1, eval=0.0; myisdigit(s[i]); i++) { /* Determine exponent */
            eval = 10*eval + (s[i]-'0');
            epower *= 10;
        }
    }

    d = (sign*val / power);     /* Place dec point in mantissa */

    if (esign!=0) {         /* If exp form then adjust exponent */
        for (j=1; j<=eval; j++) {
            d = (esign==1 ? d*10.0 : d/10.0);
        }
    }
    return (d);
}

/* Determine is c is a digit */
int myisdigit(char c)
{
    if (c>='0' && c<='9') 
        return TRUE;
    else 
        return FALSE;
}

/* Returns 1 if c is whitespace, 0 otherwise */
int myisspace(char c)
{
    return ((c==' ' || c=='\n' || c=='\t') ? 1 : 0); 
}

Answer 1

运行它应该是./test.o。通常，UNIX系统没有“。” （默认情况下，PATH中的当前目录）。

此外，“。o”扩展名有点误导，因为这是中间对象文件的惯例，而不是像您在此处生成的独立可执行文件。

Answer 2

制作最后一行./test.o，一切都行之有效。

如果您只提供文件名但不提供路径，那么只会考虑搜索路径，并且在大多数情况下您当前的工作目录不属于他们（或者更确切地说不是，在您的示例中）

Answer 3

.不在$PATH中，因此您需要指定文件的路径。 ./test.o
.o个文件通常不可执行;它们必须先链接才能运行。虽然情况并非如此。

Answer 4

可能本地目录不在您的路径中（您也不希望它）。您应该可以使用./test.o运行它。此外，这里的.o后缀很奇怪。您有一个动态链接的可执行文件，而不是目标文件。（尝试file test.o。）在Unix上通常没有扩展名的用户，在Windows上他们通常有扩展名.exe。

Answer 5

卫生署！我终于想到了这里发生了什么。该程序是来自K＆amp; R的练习5-10，它是修改第76页的反向波兰计算器以从命令行而不是从stdin接收其输入。当我收到“未知命令”消息并认为它来自编译器但我实际上是来自我自己的代码时，我正在这样做！

现在我将返回并修改它以使用argv [0]为所有错误消息添加前缀（并从现在开始使用它），以便此错误永远不会再发生。

gcc产生.o但是bash说未知的命令

5 个答案: