But if I'm not mistaken, the source code looks like this:

primDigitCompare: secondInteger
  | firstVal secondVal firstInteger |
  self debugCode: [self msg: 'primDigitCompare: secondInteger'].
  firstInteger := self
        primitive: 'primDigitCompare'
        parameters: #(#Integer )
        receiver: #Integer.
  "shortcut: aSmallInteger has to be smaller in Magnitude as aLargeInteger"
  (interpreterProxy isIntegerObject: firstInteger)
    ifTrue: ["first"
      (interpreterProxy isIntegerObject: secondInteger)
        ifTrue: ["second"
          (firstVal := interpreterProxy integerValueOf: firstInteger) > 
(secondVal := interpreterProxy integerValueOf: secondInteger)
            ifTrue: [^ 1 asOop: SmallInteger"first > second"]
            ifFalse: [firstVal < secondVal
                ifTrue: [^ -1 asOop: SmallInteger"first < second"]
                ifFalse: [^ 0 asOop: SmallInteger"first = second"]]]
        ifFalse: ["SECOND"
          ^ -1 asOop: SmallInteger"first < SECOND"]]
    ifFalse: ["FIRST"
      (interpreterProxy isIntegerObject: secondInteger)
        ifTrue: ["second"
          ^ 1 asOop: SmallInteger"FIRST > second"]
        ifFalse: ["SECOND"
          ^ self digitCompareLarge: firstInteger with: secondInteger]]

This is compiled into this C code:

EXPORT(sqInt) primDigitCompare(void) {
        sqInt firstVal;
        sqInt firstInteger;
        sqInt secondVal;
        sqInt secondInteger;
        sqInt _return_value;

        
interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(0),
 "Integer"));
        secondInteger = interpreterProxy->stackValue(0);
        /* missing DebugCode */;
        
interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(1),
 "Integer"));
        firstInteger = interpreterProxy->stackValue(1);
        if (interpreterProxy->failed()) {
                return null;
        }
        if ((firstInteger & 1)) {
                if ((secondInteger & 1)) {
                        if ((firstVal = (firstInteger >> 1)) > (secondVal = 
(secondInteger >> 1))) {
                                _return_value = 
interpreterProxy->integerObjectOf(1);
                                if (interpreterProxy->failed()) {
                                        return null;
                                }
                                interpreterProxy->popthenPush(2, _return_value);
                                return null;
                        } else {
                                if (firstVal < secondVal) {
                                        _return_value = 
interpreterProxy->integerObjectOf(-1);
                                        if (interpreterProxy->failed()) {
                                                return null;
                                        }
                                        interpreterProxy->popthenPush(2, 
_return_value);
                                        return null;
                                } else {
                                        _return_value = 
interpreterProxy->integerObjectOf(0);
                                        if (interpreterProxy->failed()) {
                                                return null;
                                        }
                                        interpreterProxy->popthenPush(2, 
_return_value);
                                        return null;
                                }
                        }
                } else {
                        _return_value = interpreterProxy->integerObjectOf(-1);
                        if (interpreterProxy->failed()) {
                                return null;
                        }
                        interpreterProxy->popthenPush(2, _return_value);
                        return null;
                }
        } else {
                if ((secondInteger & 1)) {
                        _return_value = interpreterProxy->integerObjectOf(1);
                        if (interpreterProxy->failed()) {
                                return null;
                        }
                        interpreterProxy->popthenPush(2, _return_value);
                        return null;
                } else {
                        _return_value = digitCompareLargewith(firstInteger, 
secondInteger);
                        if (interpreterProxy->failed()) {
                                return null;
                        }
                        interpreterProxy->popthenPush(2, _return_value);
                        return null;
                }
        }
}

So the C code in the package is not the original source code.

At the very least, you should replace CRs with LFs in those files, so
that diffs are easier to generate.



-- 
To UNSUBSCRIBE, email to [EMAIL PROTECTED]
with a subject of "unsubscribe". Trouble? Contact [EMAIL PROTECTED]

Reply via email to