Eagle ulp - array als function parameter

Hier roept 1 persoon dat het niet kan en niemand heeft dat tegengesproken sinds 2014

EDIT: Niet zomaar een persoon, een Cadsoft medewerker

ik heb nog nooit met die ulp syntax gewerkt. (DAt zou ik toch nog eens moeten bekijken)
Maar is het op C gebasseerd?
Zoja dan kun je van je argument wellicht een pointer maken en de array by reference meegeven en de lengte van het array in een extra parameter.

iets inde zin van:

#define SIZE_AR_ONE (4)
#define SIZE_AR_TWO (4)
int arrayOne[SIZE_AR_ONE];
int arrayTwo[SIZE_AR_TWO];


int CMP(int* pX, int* pY, int lengthX, int lengthY) {
	int indexX = 0;
	int indexY = 0;
	int isEqual = 1;
	while (	(indexX < lengthX)
		&&	(indexY < lengthY)
	) {
		if (pX[indexX] != pY[indexY]) {
                   isEqual = 0;
                }
		indexX++;
		indexY++;
	}
	return isEqual;
}


void Main() {
	CMP(arrayOne, arrayTwo, SIZE_AR_ONE, SIZE_AR_TWO);
}

@Arco:
... ik was er al bang voor...
En in 2014 waren ze al verder dan de versie 5.12 waar ik nu mee werk...

Oh well, extra exercitie voor het toetsenbord dus.

@Stijnos:
Het is CadSofts' eigen implementatie van een soort C: het lijkt er op, maar is net ff anders en volledig toegespitst op Eagle; pointers bestaan niet.
Los daarvan: dan moet ik alsnog die arrays (die nu locaal zijn in een andere function) globaal definiëren, en dat wilde ik dus niet.

Er is denk ik wel een workaround mogelijk.
In C++ werkt men ook vaak met een getter en setter voor properties. In ieder geval gebeurt dat in Borland/Embarcadero CBuilder.
Als je met een lokale array in een functie wilt werken dat zul je dus een enkele functie moeten schrijven die zowel setter als getter is. Bijvoorbeeld de eerste parameter als index en de tweede als waarde voor de setter. Met een van te voren gedefinieerde waarde werkt de functie dan als getter.

int GetAndSet( int index, int value ) {
    static int arr[32767];
    if( value >= 0 ) {
        arr[index] = value;
    }
    return arr[index];
}

Om de functie als getter te gebruiken geeft je parameter value een negatieve waarde.

EDIT: Als je ook nog meerdere lokale arrays wilt gebruiken. Ik neem aan dat je dat wilt omdat je de array meegeeft als parameter.

int GetAndSet( char which, int index, int value ) {
    static int arr_a[32767];
    static int arr_b[32767];
    if( value >= 0 ) {
        if( which == 'a' ) {
            arr_a[index] = value;
        } else if( which == 'b' ) {
            arr_b[index] = value;
        }
    }
    if( which == 'a' ) {
        return arr_a[index];
    } else if( which == 'b' ) {
        return arr_b[index];
    }
}

Ik geef toe dat het niet zo mooi is als een pointer naar een array maar je moet roeien met de riemen die je hebt.

Alleen de get zou voldoende zijn (ik hoef de inhoud van de array niet te wijzigen), maar om de hele array te krijgen ben ik dan wel ff bezig: dit levert maar 1 element per keer.
Met als bijkomend nadeel dat er geen 'static' bestaat en ik dus die array globaal zou moeten maken wat ik dus niet wou.
Eagle ULP is géén C, welk dialect dan ook.

In de function CMP die ik voor ogen had moet elk element van de array vergeleken worden met elk ander element om vast te stellen of er (minstens) twee elementen met dezelfde waarde zijn. Die array kan best lang zijn, al is de langste op dit moment 'maar' 101 elementen.

Dat moet ik voor twee arrays 'tegelijk' doen (het zijn coordinaten), en op een stuk of vijf plekken in het programma met steeds andere waardes. Met een function zou ik zowel de hoeveelheid typewerk beperken als de leesbaarheid van het programma vergroten...

In Algol60 was dit alles geen enkel probleem, maar ik heb er inmiddels vrede mee.

Ik had me niet gerealiseerd dat er ook geen static variabelen waren in ulp, jammer.
Mogelijk kan het wel wat jij wilt maar niet even snel snel.
Eagle 5.12 laat het niet toe dat je arrays meegeeft aan eigen functies maar heeft wel functies beschikbaar die een array retourneren. Bijvoorbeeld de xmlattributes functie
Ik kan me voorstellen dat je weinig zin hebt om je data naar xml om te zetten dus dan is de weg van de minste weerstand toch maar een globale array te gebruiken.