int Parser_EmitInstruction(Parser* parser, Instruction inst)
{
Function* function = parser->function;
GrowArray(parser->L, function->code, function->codeSize, function->maxCodeSize);
GrowArray(parser->L, function->sourceLine, function->codeSize, function->maxSourceLines);
int n = function->codeSize;
++function->codeSize;
function->code[n] = inst;
function->sourceLine[n] = parser->lineNumber;
return n;
}
void FArray::InsertUninitialized(int index, int count, int elementSize)
{
guard(FArray::InsertUninitialized);
assert(index >= 0);
assert(index <= DataCount);
assert(count >= 0);
if (!count) return;
GrowArray(count, elementSize);
// move data
if (index != DataCount)
{
memmove(
(byte*)DataPtr + (index + count) * elementSize,
(byte*)DataPtr + index * elementSize,
(DataCount - index) * elementSize
);
}
#if DEBUG_MEMORY
// fill memory with some pattern for debugging
memset((byte*)DataPtr + index * elementSize, 0xCC, count * elementSize);
#endif
// last operation: advance counter
DataCount += count;
unguard;
}
/*
Get pointer to a (possibly new) font object. FontManager retains ownership and will destroy it for you!!!!
If you call this before LoadFonts() then it just stores the details and then loads them all later when you call LoadFonts.
If you call this after calling LoadFonts() then it will load the font immediately.
The purpose of caching all of these in the font manager is to avoid having to keep loading files while the program is running.
*/
Font* FontManager::GetFont(const char* szFontName, int iFontSize)
{
for ( int i = 0 ; i < m_iFontCount ; i++ )
if ( (m_pArrayFonts[i]->GetSize() == iFontSize)
&& strcmp(m_pArrayFonts[i]->GetName(), szFontName ) == 0 )
return m_pArrayFonts[i];
// Otherwise font is a new one so go through the process of loading it
// If array not big enough then grow it by 10 elements. This is a template function - worth a look at maybe when you get to template functions
if ( (m_iFontCount+1) > m_iArraySize )
m_pArrayFonts = GrowArray( m_pArrayFonts, m_iArraySize, 10 );
// Array is now big enough
printf( "Loading font: %d point %s\n", iFontSize, szFontName );
m_pArrayFonts[m_iFontCount++] = new Font( szFontName,iFontSize );
if ( m_bInitialised ) // Fonts already loaded, so load this one too
{
m_pArrayFonts[m_iFontCount - 1]->m_pFont = TTF_OpenFont( szFontName,iFontSize );
}
// Output a warning message if font load failed
if ( m_pArrayFonts[m_iFontCount - 1]->m_pFont == NULL )
{
printf( "Font loading failed.\n" );
}
return m_pArrayFonts[m_iFontCount-1];
}
int Parser_AddFunction(Parser* parser, Function* f)
{
lua_State* L = parser->L;
Function* function = parser->function;
GrowArray(L, function->function, function->numFunctions, function->maxFunctions);
int index = function->numFunctions;
function->function[index] = f;
++function->numFunctions;
Gc_IncrementReference(&L->gc, function, f);
return index;
}
// Makes sure the array has enought capacity to hold at least size elements
StaticArrayAdjuster& EnsureHasCapacityFor(size_t size)
{
if(size >= GetArraySize()) GrowArray();
return *this;
}
void matscan(FILE *fs, int maxVarsToSearch, int returnString)
{
int info[5];
long i;
long fileptr,tfileptr,tfp;
long nbyt=0,nelem,skip;
int type;
int mrows,mcols;
int imagf;
int namelen;
long varNumber = 0;
char varname[80];
char *stype="";
int varnum=0;
Array *a= PushDataBlock(NewArray(&stringStruct, (Dimension *)0));
long extra=1;
fileptr = ftell(fs);
if (DEBUG) printf("Entering matscan\n");
while (1) {
tfileptr = ftell(fs);
if (DEBUG) printf("at address %ld \n",tfileptr);
if (fread(info,4,5,fs)==5) {
if (info[4] & 0xffff0000) { // convert header from little endian to big indian
// info[0] changed to info[4] 2006/3/15 as double type can be 0, hence
// no way to know big from little endian info[0] for doubles.
if (DEBUG) printf("swapping!\n");
for (i=0;i<5;i++) SWAP_INT(info[i]);
}
info[0] = info[0]%1000;
tfp = ftell(fs);
if (DEBUG) printf("at address %ld \n",tfp);
if (DEBUG) printf("info = %d %d %d %d %d\n",info[0],info[1],info[2],info[3],info[4]);
type = info[0]%1000;
if ((namelen = info[4])<80L) {
if (fread(varname,1,info[4],fs)==(int)info[4]) {
if (type==0) {
// 8-byte doubles
stype=p_strcpy("double*8"); nbyt=8;
} else if (type==10) {
// 4-byte reals
stype=p_strcpy("real*4 "); nbyt=4;
} else if ((type==120) || (type==20)) {
// 4-byte int
stype=p_strcpy("int*4 "); nbyt=4;
} else if (type==30) {
// 2-byte signed (30) shorts
stype=p_strcpy("short*2 "); nbyt=2;
} else if (type==40) {
// 2-byte unsigned (40) shorts
stype=p_strcpy("ushort*2"); nbyt=2;
} else if ((type==50) || (type==51)) {
// 1-byte signed or unsigned chars (50) or text (51)
stype=p_strcpy("char*1 "); nbyt=1;
} else {
sprintf(message,"Unknown data type %d",type);
YError(message);
}
if (returnString) {
if (varnum!=0) a= PushDataBlock((void *)GrowArray(a, extra));
a->value.q[varnum] = p_malloc(81);
sprintf(a->value.q[varnum],"%30s %s array [%d,%d]",varname, \
stype,info[1],info[2]);
varnum++;
} else {
printf("%30s %s array [%d,%d]\n",varname,stype,info[1],info[2]);
}
mrows=info[1];
mcols=info[2];
nelem=mrows*mcols;
imagf=info[3];
if (imagf) nbyt=2*nbyt;
skip = nbyt*nelem;
if (DEBUG) printf("skiping data part: %ld bytes\n",skip);
if (skip) fseek(fs,nbyt*nelem,SEEK_CUR);
}
}
} else {
break;
}
if (maxVarsToSearch) {
if (++varNumber >= maxVarsToSearch) {
break;
}
}
}
}
void Y_grow(int nArgs)
{
Symbol *s0, *s= sp-nArgs+1;
long index= s->index;
Array *array;
Dimension *dims;
StructDef *base;
Operand op;
long extra, number;
int nDims;
DataBlock *db;
int amSubroutine= CalledAsSubroutine();
if (nArgs < 2) YError("grow function needs at least two arguments");
if (amSubroutine && s->ops!=&referenceSym)
YError("1st argument to grow must be a variable reference");
if (!s->ops) YError("unxepected keyword argument in grow");
dims= growDims;
growDims= 0;
FreeDimension(dims);
/* scan argument list to find first non-nil argument */
base= 0;
s0= 0;
for (;;) {
if (!s0 && amSubroutine) array= (Array *)ForceToDB(&globTab[index]);
else array= (Array *)ForceToDB(s); /* does ReplaceRef if required */
s0= s;
if (array->ops==&lvalueOps) array= FetchLValue(array, s);
if (array->ops->isArray) {
base= array->type.base;
if (array->references) {
/* the grow operation is destructive, must copy 1st arg */
Array *copy= PushDataBlock(NewArray(base, array->type.dims));
base->Copy(base, copy->value.c, array->value.c, array->type.number);
PopTo(s);
array= copy;
}
if (array->type.dims) {
growDims= NewDimension(1L, 1L, Ref(array->type.dims->next));
} else {
growDims= NewDimension(1L, 1L, (Dimension *)0);
array->type.dims= NewDimension(1L, 1L, (Dimension *)0);
}
break;
} else if (array->ops!=&voidOps) {
YError("bad data type in function grow");
}
if (++s > sp) { /* all arguments void, will return nil */
Drop(nArgs-1);
PopTo(sp-1);
return;
}
}
nDims= CountDims(growDims);
/* scan through remaining arguments to force right-conformability with
growDims and count the number of extra dimensions */
extra= 0;
while (s<sp) {
s++;
if (!s->ops) YError("unxepected keyword argument in grow");
s->ops->FormOperand(s, &op);
if (op.ops->isArray) {
if (nDims==CountDims(op.type.dims))
growDims->number= op.type.dims->number;
else
growDims->number= 1;
if (RightConform(growDims, &op))
YError("later arguments not conformable with 1st in grow");
extra+= growDims->number;
} else if (op.ops!=&voidOps) {
YError("illegal data type in function grow");
}
}
if (extra) {
LValue lvalue;
long size;
BinaryOp *Assign= base->dataOps->Assign;
/* phony LValue necessary for Assign virtual function */
lvalue.references= nArgs; /* NEVER want to free this */
lvalue.ops= &lvalueOps;
lvalue.owner= 0; /* not true, but safer */
lvalue.type.base= base; /* NOT Ref(base) -- won't be freed */
lvalue.address.m= 0;
lvalue.strider= 0;
size= base->size;
/* copy 1st non-nil argument */
number= array->type.number;
array= PushDataBlock(GrowArray(array, extra));
lvalue.address.m= array->value.c + size*number;
/* second pass through argument list copies 2nd-Nth arguments
into result array using the Assign virtual function */
s= s0;
while (++s<sp) { /* note that sp is bigger than for previous loop */
s->ops->FormOperand(s, &op);
if (op.ops->isArray) {
lvalue.type.dims= op.type.dims; /* NOT Ref(dims) -- won't be freed */
lvalue.type.number= op.type.number;
/* Assign virtual functions assume their first parameter is an
LValue* rather than an Operation* (like all other BinaryOps). */
(*Assign)((Operand *)&lvalue, &op);
lvalue.address.m+= size*lvalue.type.number;
}
}
}
/* store result back to first reference -- will also be left on stack
by EvalBI */
if (amSubroutine) {
s= &globTab[index]; /* guaranteed this is a dataBlockSym by ForceToDB */
db= s->value.db;
s->value.db= (DataBlock *)Ref(array);
Unref(db);
if (extra) Drop(nArgs);
else Drop(nArgs-1);
ReplaceRef(sp); /* result is 1st argument */
PopTo(sp-1);
} else {
if (extra) { /* result is on top of stack */
PopTo(sp-nArgs-1);
Drop(nArgs);
} else { /* result is unchanged s0 argument */
int nAbove= sp-s0;
Drop(nAbove);
nArgs-= nAbove;
PopTo(sp-nArgs);
Drop(nArgs-1);
}
}
}