void SetSLD_Line(int line)
{
if (Final_Pass)
{
ArraySet(&SLD_Line_Array, CodeIP, line);
ArraySet(&SLD_File_Array, CodeIP, This_SLD_File);
}
}
/* \int R(n0,l0)R(n1,l1)r */
double HydrogenicDipole(const cfac_t *cfac, int n0, int l0, int n1, int l1) {
gsl_coulomb_me *r, ***qk;
double z, am, scale;
if (n0 > n1) {
int tmp;
tmp = n0; n0 = n1; n1 = tmp;
tmp = l0; l0 = l1; l1 = tmp;
}
if (l1 != l0 + 1 && l1 != l0 - 1) {
return 0.0;
}
z = GetResidualZ(cfac);
am = cfac_get_atomic_mass(cfac);
scale = gsl_coulomb_me_scale(z, am);
qk = ArraySet(cfac->coulomb.dipole_array, n1, NULL);
if (*qk == NULL) {
int np;
*qk = malloc(n1*sizeof(gsl_coulomb_me *));
for (np = 1; np <= n1; np++) {
r = gsl_coulomb_me_alloc(n1, np);
(*qk)[np - 1] = r;
}
}
r = (*qk)[n0 - 1];
return scale*gsl_coulomb_me_get(r, l1, l0);
}
/*
** FUNCTION: ArrayAppend
** PURPOSE: append an element to the array
** INPUT: {ARRAY *a},
** pointer to the array.
** {void *d},
** data to be appened.
** RETURN: {void *},
** pointer to the appended element.
** SIDE EFFECT:
** NOTE:
*/
void *ArrayAppend(ARRAY *a, const void *d) {
int i;
if (!a) {
return NULL;
}
i = a->dim;
return ArraySet(a, i, d);
}
void SetAsmDataChar()
{
int v;
if (Section == SECT_code)
return;
v = DataIP;
if (Section == SECT_bss)
v += MaxDataIP;
ArraySet(&AsmCharDataArray, v, (int) DataCharPtr);
}
void ArrayCopy(ArrayStore *dstArray, ArrayStore *srcArray)
{
uint n;
if (dstArray->array == srcArray->array)
return;
if (!dstArray->array)
return;
if (!srcArray->array)
return;
// !! Fix ARH 21/09/10 - srcArray->lo is incorrect should be 0 !!
for (n=0;n<srcArray->hi+1;n++)
{
ArraySet(dstArray, n, ArrayGet(srcArray, n));
}
dstArray->ps = srcArray->ps;
return;
}
void Rebuild_Data(SYMBOL *sym)
{
SYMBOL *thisSym;
//uint ta = 0;
int ip;
int len;
int n;
int c;
int left;
int align;
int opt_bss;
// decode the field
ip = sym->Value;
if (sym->Type == SECT_bss)
ip += MaxDataIP;
len = sym->EndIP;
left = len;
// Has this been done already
if (ArrayGet(&LabelDone, ip))
return;
// Mark as done
ArraySet(&LabelDone, ip, 1);
if (!len)
{
len = FindLabelExtent(ip);
if (!len)
{
RebuildEmit("// empty %s_%d,%d\n", sym->Name, sym->LocalScope, len);
return;
}
// Save the result for later
sym->EndIP = len;
RebuildEmit("// found extent %s_%d,%d\n", sym->Name, sym->LocalScope, len);
}
align = ArrayGet(&DataAlignArray, ip);
if (sym->Type == SECT_bss)
{
RebuildEmit("\t.comm %s_%d,%d\n", sym->Name, sym->LocalScope, len);
return;
}
if (sym->Type != SECT_data)
Error(Error_System, "(Rebuild_Data) Illegal section in data output");
// Check if this data field can be moved to bss
#if 1
opt_bss = Rebuild_CanMoveToBss(ip, len);
if (opt_bss)
{
// Make sure bss output is aligned
int bss_len = len;
while(bss_len & 3)
bss_len++;
RebuildEmit("\t.comm %s_%d,%d //moved to bss\n", sym->Name, sym->LocalScope, bss_len);
return;
}
#endif
if (align)
RebuildEmit("\t.align %d\n", align);
// write a data section field
RebuildEmit("%s_%d:\n", sym->Name, sym->LocalScope );
// write array
c = 0;
for (n=ip;n<ip+len;n++)
{
thisSym = (SYMBOL *) ArrayGet(&DataArray, n);
if (!thisSym)
{
RebuildEmit("\t.byte 0x%s\n", Hex8(GetDataMem(n)) );
left--;
continue;
}
// check if we hit a .word reference
if (left >= 4)
{
if (thisSym)
{
SYMBOL *labref = NULL;
int addr;
addr = thisSym->Value;
if (thisSym->Type == SECT_code)
{
labref = (SYMBOL *) ArrayGet(&CodeLabelArray, addr);
if (labref == 0)
Error(Error_System, "Could not repoint label !!");
// labref = thisSym;
}
if (thisSym->Type == SECT_data)
{
labref = (SYMBOL *) ArrayGet(&LabelArray, addr);
if (labref == 0)
Error(Error_System, "Could not repoint label !!");
}
if (thisSym->Type == SECT_bss)
{
labref = (SYMBOL *) ArrayGet(&LabelArray, addr + MaxDataIP);
if (labref == 0)
Error(Error_System, "Could not repoint label !!");
}
if(labref == NULL)
Error(Error_System, "Broken label");
RebuildEmit("\t.word %s_%d\n", labref->Name, labref->LocalScope);
left-=4;
n+=3;
}
}
}
RebuildEmit("\n\n");
return;
}
short Directives()
{
int t;
SkipWhiteSpace();
if (*FilePtr != '.')
return 0;
DataCharPtr = FilePtr;
if (QToken(".eof"))
{
// mark end of label array as end of bss
strcpy(Name, "_________eof_________");
Section = SECT_bss;
DefineLabel(label_Local);
SourceFileCheckEOF(LastTokenPtr() - FileTop);
EndFile = 1;
return 1;
}
GetToken();
t = ScanAsmToken();
switch(t)
{
//---------------------------------------------------------
case 0:
Error(Error_Skip, "Illegal directive '%s'",Name);
//---------------------------------------------------------
case dir_sourcefile:
{
int file;
SkipWhiteSpace();
GetLFileName();
// SetCSourceFile(Name);
file = SetSLD_Name(Name);
SetCSourceFile(Name, file);
return 1;
}
//---------------------------------------------------------
case dir_model:
{
int model=0;
if (Token("full")) // Get return type
model = MODEL_full;
else if (Token("half")) // Get return type
model = MODEL_half;
else if (Token("compact")) // Get return type
model = MODEL_compact;
else if (Token("mini")) // Get return type
model = MODEL_mini;
else if (Token("tiny")) // Get return type
model = MODEL_tiny;
else
Error(Error_Fatal, "invalid model type");
// if model is not set then set it
if (!CurrentModel)
CurrentModel = model;
else
{
if (model != CurrentModel)
Error(Error_Fatal, "multiple architectual models defined");
}
return 1;
}
//---------------------------------------------------------
case dir_ctor:
{
SYMBOL* ref;
imm = GetExpression(); // Get the number
ref = GetLastSymbolRef();
if(pass_count > 1)
{
if (!ref)
Error(Error_Fatal, "Constructor has bad reference");
ArraySet(&CtorArrayImm, CtorCount, imm);
ArraySet(&CtorArray, CtorCount++, (int) ref);
}
return 1;
}
//---------------------------------------------------------
case dir_dtor:
{
SYMBOL* ref;
imm = GetExpression(); // Get the number
ref = GetLastSymbolRef();
if(pass_count > 1)
{
if (!ref)
Error(Error_Fatal, "Destructor has bad reference");
ArraySet(&DtorArrayImm, DtorCount, imm);
ArraySet(&DtorArray, DtorCount++, (int) ref);
}
return 1;
}
//---------------------------------------------------------
case dir_sourcedir:
{
SkipWhiteSpace();
GetLFileName();
SetCSourceDir(Name);
return 1;
}
//---------------------------------------------------------
case dir_line:
{
int v;
SkipWhiteSpace();
v = GetNum();
SetCSourceLine(v);
SetSLD_Line(v);
return 1;
}
//---------------------------------------------------------
case dir_dlab:
{
if (!ArgUseStabs)
{
SkipLine(); // Skip excess debug labels
return 1;
}
// Define a label
Section = SECT_code;
GetAsmName();
DefineLabel(label_Local);
return 1;
}
//---------------------------------------------------------
case dir_library:
{
SkipLine();
return 1;
}
//---------------------------------------------------------
case dir_exit:
{
if (NextToken("\""))
{
GetStringName(1024);
Error(Error_Fatal, "User: %s", Name);
return 1;
}
Error(Error_Fatal, "Exiting with user error");
return 1;
}
//---------------------------------------------------------
case dir_asm_on:
{
return 1;
}
//---------------------------------------------------------
case dir_asm_off:
{
/* if (QToken(".asm_off"))
{
return 1;
}
*/
return 1;
}
//---------------------------------------------------------
case dir_AllowFarBranches:
{
AllowFarBranches = 1;
return 1;
}
//---------------------------------------------------------
case dir_bp:
{
return 1;
}
//---------------------------------------------------------
case dir_localscope:
{
SkipWhiteSpace();
if (Token("+"))
{
LocalScope++;
return 1;
}
if (Token("reset"))
{
LocalScope = 1;
return 1;
}
Error(Error_Fatal, "Bad .localscope type");
return 1;
}
//---------------------------------------------------------
case dir_func:
{
Function_Return_Type = RET_void;
GetName();
ReplaceChar(Name, '.', '_');
Function_Param_Count = -1;
if (Token(","))
{
Function_Param_Count = GetNum();
if (Token(",")) // Get param count
{
if (Token("int")) // Get return type
Function_Return_Type = RET_int;
else if (Token("float"))
Function_Return_Type = RET_float;
else if (Token("double"))
Function_Return_Type = RET_double;
else if (Token("void"))
Function_Return_Type = RET_void;
else if (Token("?"))
Function_Return_Type = RET_double; //patch fix
}
}
DefineLabel(label_Function);
return 1;
}
//---------------------------------------------------------
case dir_local:
{
GetName();
return 1;
}
//---------------------------------------------------------
case dir_vec_elt:
{
GetName();
return 1;
}
//---------------------------------------------------------
case dir_syscall:
{
char SysCallName[256];
char istr[4096];
char *iptr = 0;
int v, p, r;
p = 0;
r = RET_void;
GetName();
strcpy(SysCallName,Name);
SkipWhiteSpace();
v = GetExpression();
if (Token(",")) // Get param count
{
p = GetExpression();
NeedToken(",");
if (Token("int")) // Get return type
r = RET_int;
else if (Token("float"))
r = RET_float;
else if (Token("double"))
r = RET_double;
else if (Token("void"))
r = RET_void;
if (Token(",")) // Get interface
{
GetStringName(2048);
strcpy(istr,Name);
iptr = istr;
}
}
if (Pass == 1)
MapSysCall(SysCallName, v, p, r, iptr);
return 1;
}
//---------------------------------------------------------
case dir_lfile:
{
SkipWhiteSpace();
GetLFileName();
strcpy(CurrentFile, Name);
// CurrentFileLine = GetLineNumber(FileTop,GetPrevFilePtr());
AddFileSym(Name, LocalScope+1);
GetRelPath(CurrentFile);
return 1;
}
//---------------------------------------------------------
case dir_org:
{
int v = GetExpression();
if (v >= MAX_CODE_MEM)
Error(Error_Fatal, ".org has illegal address");
CodeIP = v;
//! CodePtr = &CodeMem[v];
printf("*Warning* org %x\n", v);
return 1;
}
//---------------------------------------------------------
case dir_set:
{
SkipWhiteSpace();
// Catch Thunks
if (Token("%"))
{
SYMBOL *ThunkSym;
int v;
v = GetDecNum(5);
if (GetDecNumDigitCount() == 0)
Error(Error_Fatal, "Missing Thunk Number");
NeedToken("=");
SkipWhiteSpace();
GetName(); // Get the name of the thunk alias
GetEnumValue(Name); // Evaluate the symbol
ThunkSym = GetLastSymbolRef();
//N_FUN 141 4935 '_Z7XPClosev:F(0,6)'
StabsEmit("N_THUNK %d %d '%s'\n", v, ThunkSym, Name);
RegisterThunk(v, ThunkSym);
return 1;
}
// Catch normal sets
GetName(); // Get the new type Name
NeedToken("=");
RedefENum(Name, GetExpression());
return 1;
}
//---------------------------------------------------------
case dir_debug:
{
DEBUG = (short)GetExpression();
return 1;
}
//---------------------------------------------------------
case dir_info:
{
INFO = (short)GetExpression();
return 1;
}
//---------------------------------------------------------
case dir_list:
{
LIST = (short)GetExpression();
return 1;
}
//---------------------------------------------------------
case dir_show:
{
int exp = GetExpression();
if (Pass == 1)
printf("%d",exp);
if (!Token(";"))
if (Pass == 1) printf("\n");
return 1;
}
//---------------------------------------------------------
case dir_print:
//if (QToken(".print") || QToken(".?"))
{
int exp;
char v;
if (Token("\""))
{
while(1)
{
v = *FilePtr;
if (v == 0 || v == '"')
break;
printf("%c",v);
FilePtr++;
}
NeedToken("\"");
if (!Token(";"))
printf("\n");
return 1;
}
exp = GetExpression();
printf("%d",exp);
if (!Token(";"))
printf("\n");
return 1;
}
//---------------------------------------------------------
case dir_ifdef:
{
GetName(); // Get the new type Name
SkipWhiteSpace();
if (!SymbolExists(Name, section_Script, -1))
{
if (NextToken("{"))
{
SkipPair('{','}');
}
}
return 1;
}
//---------------------------------------------------------
case dir_ifdefglobal:
{
GetName(); // Get the new type Name
SkipWhiteSpace();
if (!SymbolExists(Name, section_Enum, 0))
{
if (NextToken("{"))
{
SkipPair('{','}');
}
}
return 1;
}
//---------------------------------------------------------
case dir_ifndefglobal:
{
GetName(); // Get the new type Name
SkipWhiteSpace();
if (SymbolExists(Name, section_Enum, 0))
{
if (NextToken("{"))
{
SkipPair('{','}');
}
}
return 1;
}
//---------------------------------------------------------
case dir_ifndef:
{
GetName(); // Get the new type Name
SkipWhiteSpace();
if (SymbolExists(Name, section_Script, -1))
{
if (NextToken("{"))
{
SkipPair('{','}');
}
}
return 1;
}
//---------------------------------------------------------
case dir_if:
{
if (!GetExpression())
{
SkipWhiteSpace();
if (NextToken("{"))
{
SkipPair('{','}');
}
}
return 1;
}
//---------------------------------------------------------
case dir_do:
{
// If we have a '{' just ignore it an keep going
if (Token("{"))
return 1;
// Must be an expression then
// if false then skip to while
if (!GetExpression())
{
SearchScopeForward();
NeedToken(".enddo");
}
return 1;
}
//---------------------------------------------------------
case dir_enddo:
{
FilePtr = SearchScope(FilePtr);
return 1;
}
//---------------------------------------------------------
case dir_while:
{
if (GetExpression())
{
FilePtr = SearchScope(FilePtr);
}
return 1;
}
//---------------------------------------------------------
case dir_enum:
{
AsmEnums();
return 1;
}
//---------------------------------------------------------
case dir_breakpoint:
{
SkipWhiteSpace();
return 1;
}
//---------------------------------------------------------
case dir_globals_in_code:
{
GlobalsInCode = 1;
SkipWhiteSpace();
return 1;
}
//---------------------------------------------------------
case dir_globl:
// if (QToken(".globl") || QToken(".global") || QToken(".weak"))
{
unsigned int n;
GetAsmName();
if (GlobalsInCode && (Section == SECT_code))
{
//! *CodePtr++ = '*';
ArraySet(&CodeMemArray, CodeIP, '*');
CodeIP++;
for (n=0;n<strlen(Name);n++)
{
//! *CodePtr++ = Name[n];
ArraySet(&CodeMemArray, CodeIP, Name[n]);
CodeIP++;
}
//! *CodePtr++ = '*';
ArraySet(&CodeMemArray, CodeIP, '*');
CodeIP++;
}
if (LIST)
printf("Found global '%s'\n",Name);
DefineLabelGlobal();
//#ifdef INCLUDE_JAVAGEN
// if (JavaPass)
// JavaGen_Global(Name);
//#endif
SkipWhiteSpace();
return 1;
}
//---------------------------------------------------------
case dir_extern:
// if (QToken(".extern") || QToken(".extrn"))
{
GetAsmName();
if (LIST)
printf("Found external '%s'\n",Name);
// SHOULD DO NOTHING
//ExternDecl(Name);
SkipWhiteSpace();
return 1;
}
//---------------------------------------------------------
case dir_byte:
{
SetAsmDataChar();
do
{
imm = GetExpression(); // Get the number
WriteDataTypeArray(dir_byte, 1);
WriteByte(imm);
}
while (QToken(","));
return 1;
}
//---------------------------------------------------------
case dir_half:
{
SetAsmDataChar();
do
{
imm = GetExpression(); // Get the number
WriteDataTypeArray(dir_half, 2);
WriteWord(imm);
}
while (QToken(","));
return 1;
}
//---------------------------------------------------------
case dir_word:
{
SYMBOL *ref;
if (Section != SECT_data)
Error(Error_Skip,"data word in not in data section");
SetAsmDataChar();
do
{
imm = GetExpression(); // Get the number
WriteDataTypeArray(dir_word, 4);
ref = GetLastSymbolRef();
WriteLongRef(imm, ref);
}
while (QToken(","));
return 1;
}
//---------------------------------------------------------
case dir_space:
{
SetAsmDataChar();
imm = GetExpression(); // Get the number
if (LIST)
printf("space %d\n",imm);
if (!imm)
return 1;
WriteDataTypeArray(dir_space, imm);
do
{
WriteByteSpace(0);
}
while(--imm);
return 1;
}
//---------------------------------------------------------
case dir_string:
{
SetAsmDataChar();
WriteDataTypeArray(dir_string, 1);
GetStrings();
return 1;
}
//---------------------------------------------------------
case dir_comm:
{
int LastSect = Section;
SetAsmDataChar();
Section = SECT_bss;
GetAsmName();
//!! make this global too
DefineLabelGlobal();
DefineLabel(label_Local);
NeedToken(",");
imm = GetExpression(); // Get the number
if (LIST)
printf("comm %d to .bss\n",imm);
if (imm == 0)
return 1;
WriteDataTypeArray(dir_comm, imm);
BssIP += imm;
Section = LastSect;
return 1;
}
//---------------------------------------------------------
case dir_lcomm:
{
int LastSect = Section;
SetAsmDataChar();
Section = SECT_bss;
GetAsmName();
DefineLabel(label_Local);
NeedToken(",");
imm = GetExpression(); // Get the number
if (LIST)
printf("lcomm %d to .bss\n",imm);
if (imm == 0)
return 1;
WriteDataTypeArray(dir_lcomm, imm);
BssIP += imm;
Section = LastSect;
return 1;
}
//---------------------------------------------------------
case dir_align:
{
imm = GetExpression(); // Get the number
if (Section == SECT_code)
return 1;
AddAlignRef(imm);
return 1;
}
//---------------------------------------------------------
case dir_bss:
{
Section = SECT_bss;
if (LIST)
printf("** Section .bss IP = %x\n",BssIP);
return 1;
}
//---------------------------------------------------------
case dir_data:
{
Section = SECT_data;
if (LIST)
printf("** Section .data IP = %x\n",DataIP);
return 1;
}
//---------------------------------------------------------
case dir_code:
// if (QToken(".code") || QToken(".text"))
{
Section = SECT_code;
if (LIST)
printf("** Section .code IP = %x\n",CodeIP);
return 1;
}
//---------------------------------------------------------
case dir_ent:
{
SkipLine();
return 1;
}
//---------------------------------------------------------
case dir_end:
return 1;
//---------------------------------------------------------
case dir_stabs:
{
Parse_stabs();
//SkipLine();
return 1;
}
//---------------------------------------------------------
case dir_stabn:
{
Parse_stabn();
//SkipLine();
return 1;
}
//---------------------------------------------------------
case dir_stabd:
{
SkipLine();
return 1;
}
//---------------------------------------------------------
} // End of switch
return 0;
}
void arraySet(int index, uint val)
{
ArraySet(CurrentArray, index, val);
}
void ArrayAppend(ArrayStore *theArray, uint value)
{
ArraySet(theArray, theArray->ps, value);
theArray->ps++;
}
short ResourceCommands()
{
char *filemem;
int filelen;
int n,v;
SkipWhiteSpace();
//---------------------------------------------------------
if (QToken(".library"))
{
SkipLine();
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".lfile"))
{
SkipWhiteSpace();
GetLFileName();
GetRelPath(Name);
return 1;
}
if (QToken(".localscope"))
{
SkipWhiteSpace();
NeedToken("+");
// LocalScope++;
return 1;
}
if (QToken(".res"))
{
// If there is previous data to be written out
// do it here !!
if (ResType != 0)
{
FinalizeResource();
}
SkipWhiteSpace();
ResName[0] = 0;
Name[0] = 0;
if (isalpha(*FilePtr))
{
GetName(); // Get the new type Name
strcpy(ResName, Name);
}
// Clear index table
IndexCount = 0;
IndexWidth = 0;
MakeNewResource(Name); // Make this symbolic
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".index"))
{
int IndexOffset = GetDataIndex();
SkipWhiteSpace();
Name[0] = 0;
if (isalpha(*FilePtr))
GetName(); // Get the index ref name
// add index to table
IndexTable[IndexCount] = IndexOffset;
// MakeIndexedResource(IndexName, IndexCount);
infoprintf("%d: index = %d ('%s')\n",IndexCount, IndexOffset, Name);
if (Pass == 2)
if (Name[0])
fprintf(HeaderFile,"#define idx_%s %d\n", Name, IndexCount);
IndexCount++;
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".wideindex"))
{
IndexWidth = 1;
SkipWhiteSpace();
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".extension"))
{
SkipWhiteSpace();
v = GetExpression(); // x
ResType = v;
infoprintf("%d: Prototype = %d\n",CurrentResource, ResType);
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".dispose"))
{
SkipWhiteSpace();
ResDispose = 1;
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".placeholder"))
{
ResType = ResType_PlaceHolder;
infoprintf("%d: Placeholder\n",CurrentResource);
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".skip"))
{
ResType = ResType_Skip;
infoprintf("%d: Skip\n",CurrentResource);
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".bin"))
{
ResType = ResType_Binary;
infoprintf("%d: Binary\n",CurrentResource);
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".ubin"))
{
ResType = ResType_UBinary;
infoprintf("%d: UBinary\n",CurrentResource);
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".media"))
{
int slen;
SkipWhiteSpace();
ResType = ResType_Binary; //ResType_Media;
GetStringName(128);
slen = strlen(Name) + 1;
for (n=0;n<slen;n++)
WriteByte(Name[n]);
SkipWhiteSpace();
NeedToken(",");
SkipWhiteSpace();
GetStringName(128);
if(Do_Export_Dependencies && Pass == 2) {
ExportFileDependency(Name);
}
filemem = Open_FileAlloc(AddRelPrefix(Name));
if (!filemem)
{
Error(Error_Fatal, "Error reading data file '%s'", Name);
return 1;
}
filelen = FileAlloc_Len();
for (n=0;n<filelen;n++)
{
WriteByte(filemem[n]);
}
Free_File(filemem);
infoprintf("%d: Media Binary\n",CurrentResource);
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".umedia"))
{
int slen;
SkipWhiteSpace();
ResType = ResType_UBinary; //ResType_UMedia;
GetStringName(128);
slen = strlen(Name) + 1;
for (n=0;n<slen;n++)
WriteByte(Name[n]);
SkipWhiteSpace();
NeedToken(",");
SkipWhiteSpace();
GetStringName(128);
if(Do_Export_Dependencies && Pass == 2) {
ExportFileDependency(Name);
}
filemem = Open_FileAlloc(AddRelPrefix(Name));
if (!filemem)
{
Error(Error_Fatal, "Error reading data file '%s'", Name);
return 1;
}
filelen = FileAlloc_Len();
for (n=0;n<filelen;n++)
{
WriteByte(filemem[n]);
}
Free_File(filemem);
infoprintf("%d: Media Binary\n",CurrentResource);
return 1;
}
//------------------------------------
//
//------------------------------------
/*
if (QToken(".file"))
{
SkipWhiteSpace();
ResType = ResType_File;
GetStringName(128);
filemem = Open_FileAlloc(AddRelPrefix(Name));
if (!filemem)
{
Error("Error reading data file '%s'", Name);
return 1;
}
filelen = FileAlloc_Len();
for (n=0;n<filelen;n++)
{
WriteByte(filemem[n]);
}
Free_File(filemem);
printf("%d: File '%s' size %d\n", CurrentResource, Name, filelen);
return 1;
}
*/
//------------------------------------
//
//------------------------------------
if (QToken(".label")) // filename
{
int slen;
SkipWhiteSpace();
ResType = ResType_Label;
GetStringName(128);
slen = strlen(Name) + 1;
for (n=0;n<slen;n++)
WriteByte(Name[n]);
return 1;
}
//------------------------------------
//
//------------------------------------
// ResType_TileSet = 7
// ushort xsize, ysize
// bytes png_image
if (QToken(".tileset")) // filename
{
int xsize,ysize;
SkipWhiteSpace();
ResType = ResType_TileSet;
GetStringName(128);
SkipWhiteSpace();
NeedToken(",");
SkipWhiteSpace();
xsize = GetExpression(); // xsize
SkipWhiteSpace();
NeedToken(",");
SkipWhiteSpace();
ysize = GetExpression(); // ysize
WriteWord(xsize);
WriteWord(ysize);
if(Do_Export_Dependencies && Pass == 2) {
ExportFileDependency(Name);
}
filemem = Open_FileAlloc(AddRelPrefix(Name));
if (!filemem)
{
Error(Error_Fatal, "Error reading tileset file '%s'", Name);
return 1;
}
filelen = FileAlloc_Len();
for (n=0;n<filelen;n++)
WriteByte(filemem[n]);
Free_File(filemem);
infoprintf("%d: Tileset '%s' cxy %d,%d size %d\n", CurrentResource, Name, xsize, ysize, filelen);
return 1;
}
//------------------------------------
//
//------------------------------------
// ResType_TileMap = 8
// ushort mapWidth, mapHeight
// ushort map[mapWidth*mapHeight]
if (QToken(".tilemap")) // filename
{
int xsize,ysize;
SkipWhiteSpace();
ResType = ResType_TileMap;
GetStringName(128);
SkipWhiteSpace();
NeedToken(",");
SkipWhiteSpace();
xsize = GetExpression(); // xsize
SkipWhiteSpace();
NeedToken(",");
SkipWhiteSpace();
ysize = GetExpression(); // ysize
if(Do_Export_Dependencies && Pass == 2) {
ExportFileDependency(Name);
}
filemem = Open_FileAlloc(AddRelPrefix(Name));
if (!filemem)
{
Error(Error_Fatal, "Error reading tilemap file '%s'", Name);
return 1;
}
filelen = FileAlloc_Len();
if (filelen != (xsize * ysize * 2))
{
Error(Error_Fatal, "%d: Tilemap '%s' xy %d,%d size %d\n", CurrentResource, Name, xsize, ysize, filelen);
return 1;
}
WriteWord(xsize);
WriteWord(ysize);
for (n=0;n<filelen;n++)
WriteByte(filemem[n]);
Free_File(filemem);
infoprintf("%d: Tilemap '%s' cxy %d,%d size %d\n", CurrentResource, Name, xsize, ysize, filelen);
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".image")) // filename
{
SkipWhiteSpace();
ResType = ResType_Image;
GetStringName(128);
/*
spr_cx = spr_cy = 0;
SkipWhiteSpace();
if (QToken(","))
{
spr_cx = GetExpression(); // cx
SkipWhiteSpace();
NeedToken(",");
SkipWhiteSpace();
spr_cy = GetExpression(); // cy
}
WriteWord(spr_cx);
WriteWord(spr_cy);
*/
if(Do_Export_Dependencies && Pass == 2) {
ExportFileDependency(Name);
}
filemem = Open_FileAlloc(AddRelPrefix(Name));
if (!filemem)
{
Error(Error_Fatal, "Error reading image file '%s'", Name);
return 1;
}
filelen = FileAlloc_Len();
// write the length
//WriteEncodedInt(filelen);
for (n=0;n<filelen;n++)
WriteByte(filemem[n]);
Free_File(filemem);
infoprintf("%d: Image '%s' cxy %d,%d size %d\n", CurrentResource, Name, spr_cx, spr_cy, filelen);
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".sprite")) // index, x,y,w,h,cx,cy
{
ResType = ResType_Sprite;
SkipWhiteSpace();
spr_ind = v = GetExpression(); // ind
WriteWord(v);
SkipWhiteSpace();
NeedToken(",");
SkipWhiteSpace();
spr_x = v = GetExpression(); // x
WriteWord(v);
SkipWhiteSpace();
NeedToken(",");
SkipWhiteSpace();
spr_y = v = GetExpression(); // y
WriteWord(v);
SkipWhiteSpace();
NeedToken(",");
SkipWhiteSpace();
spr_w = v = GetExpression(); // w
WriteWord(v);
SkipWhiteSpace();
NeedToken(",");
SkipWhiteSpace();
spr_h = v = GetExpression(); // h
WriteWord(v);
spr_cx = spr_cy = 0;
SkipWhiteSpace();
if (QToken(","))
{
spr_cx = (short)GetExpression(); // cx
SkipWhiteSpace();
NeedToken(",");
SkipWhiteSpace();
spr_cy = (short)GetExpression(); // cy
}
WriteWord(spr_cx);
WriteWord(spr_cy);
infoprintf("%d: Sprite ind %d, xy %d,%d, wh %d,%d cxy %d,%d\n",
CurrentResource, spr_ind, spr_x, spr_y, spr_w, spr_h, spr_cx, spr_cy);
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".end"))
{
SkipLine();
// EndComp = 1;
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".eof"))
{
SkipLine();
EndComp = 1;
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".parseheader"))
{
GetStringName(128);
ReadAndParseHeaders(Name);
return 1;
}
//------------------------------------
// Other directives
//------------------------------------
if (QToken(".set"))
{
if (QToken("$"))
{
char VarName[256];
// Accept a string
GetName(); // Get the new type Name
strcpy(VarName, Name);
NeedToken("=");
GetStringName(128);
printf("string set %s = '%s'\n", VarName, Name);
RedefENumString(VarName, Name);
return 1;
}
GetName(); // Get the new type Name
NeedToken("=");
RedefENum(Name, GetExpression());
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".debug"))
{
DEBUG = (short)GetExpression();
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".info"))
{
INFO = (short)GetExpression();
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".list"))
{
LIST = (short)GetExpression();
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".show"))
{
int exp = GetExpression();
printf("%d",exp);
if (!Token(";"))
printf("\n");
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".print") || QToken(".?"))
{
int exp;
char c;
if (Token("\""))
{
while(1)
{
c = *FilePtr;
if (c == 0 || c == '"')
break;
printf("%c",c);
FilePtr++;
}
NeedToken("\"");
if (!Token(";"))
printf("\n");
return 1;
}
exp = GetExpression();
printf("%d",exp);
if (!Token(";"))
printf("\n");
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".if"))
{
if (!GetExpression())
{
if (NextToken("{"))
{
SkipPair('{','}');
}
}
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".ifdef"))
{
GetName(); // Get the new type Name
SkipWhiteSpace();
if (!SymbolExists(Name, section_Script, -1))
{
if (NextToken("{"))
{
SkipPair('{','}');
}
}
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".ifndef"))
{
GetName(); // Get the new type Name
SkipWhiteSpace();
if (SymbolExists(Name, section_Script, -1))
{
if (NextToken("{"))
{
SkipPair('{','}');
}
}
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".while"))
{
if (GetExpression())
{
FilePtr = SearchScope(FilePtr);
}
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".enum"))
{
AsmEnums();
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".include")) // filename
{
SkipWhiteSpace();
GetStringName(128);
if(Do_Export_Dependencies && Pass == 2) {
ExportFileDependency(Name);
}
filemem = Open_FileAlloc(AddRelPrefix(Name));
if (!filemem)
{
Error(Error_Fatal, "Error reading include file '%s'", Name);
return 1;
}
filelen = FileAlloc_Len();
for (n=0;n<filelen;n++)
WriteByte(filemem[n]);
Free_File(filemem);
infoprintf("bin include '%s' size %d\n", Name, filelen);
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".varint"))
{
do
{
imm = GetExpression(); // Get the number
WriteEncodedInt(imm);
}
while (QToken(","));
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".varsint"))
{
do
{
imm = GetExpression(); // Get the number
WriteEncodedSignedInt(imm);
}
while (QToken(","));
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".byte"))
{
do
{
imm = GetExpression(); // Get the number
WriteByte(imm);
}
while (QToken(","));
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".half"))
{
do
{
imm = GetExpression(); // Get the number
WriteWord(imm);
}
while (QToken(","));
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".word"))
{
do
{
imm = GetExpression(); // Get the number
WriteLong(imm);
}
while (QToken(","));
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".fill"))
{
imm = GetExpression(); // Get the number
if (!imm)
return 1;
NeedToken(",");
v = GetExpression();
do
{
WriteByte(v);
}
while(--imm);
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".pstring"))
{
int dataStart;
int len;
// Write length byte
WriteByte(0);
// Get current data location
dataStart = DataIP;
// read string to mem
GetStrings();
// find the string length
len = DataIP - dataStart;
if (len > 255)
{
Error(Error_Skip, "pstring is longer that 255 chars\n");
return 1;
}
// Patch the string length
ArraySet(&DataMemArray, dataStart-1, len);
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".cstring"))
{
GetStrings();
WriteByte(0);
return 1;
}
//------------------------------------
//
//------------------------------------
if (QToken(".string"))
{
GetStrings();
return 1;
}
//------------------------------------
//
//------------------------------------
// Error
GetAsmName();
Error(Error_Fatal, "Illegal resource directive '%s'",Name);
return 0;
}
