int expand_token(char *s, u_int max, void (*func)(void *t, u_int n), void *t )
{
char *str = strdup(s);
char *p, *q, r;
char *end;
u_int a = 0, b = 0;
DEBUG_MSG("expand_token %s", s);
p = str;
end = p + strlen(p);
while (p < end) {
q = p;
/* find the end of the first digit */
while ( isdigit((int)*q) && q++ < end);
r = *q;
*q = 0;
/* get the first digit */
a = atoi(p);
if (a > max)
FATAL_MSG("Out of range (%d) !!", max);
/* it is a range ? */
if ( r == '-') {
p = ++q;
/* find the end of the range */
while ( isdigit((int)*q) && q++ < end);
*q = 0;
if (*p == '\0')
FATAL_MSG("Invalid range !!");
/* get the second digit */
b = atoi(p);
if (b > max)
FATAL_MSG("Out of range (%d)!!", max);
if (b < a)
FATAL_MSG("Invalid decrementing range !!");
} else {
/* it is not a range */
b = a;
}
/* process the range and invoke the callback */
for(; a <= b; a++) {
func(t, a);
}
if (q == end) break;
else p = q + 1;
}
SAFE_FREE(str);
return ESUCCESS;
}
/*
* compile the regex of a filter_op
*/
static int compile_regex(struct filter_env *fenv, struct filter_header *fh)
{
size_t i = 0;
struct filter_op *fop = fenv->chain;
char errbuf[100];
int err;
#ifdef HAVE_PCRE
const char *perrbuf = NULL;
#endif
/* parse all the instruction */
while (i < (fenv->len / sizeof(struct filter_op)) ) {
/* search for func regex and pcre */
if(fop[i].opcode == FOP_FUNC) {
switch(fop[i].op.func.op) {
case FFUNC_REGEX:
/* alloc the structures */
SAFE_CALLOC(fop[i].op.func.ropt, 1, sizeof(struct regex_opt));
SAFE_CALLOC(fop[i].op.func.ropt->regex, 1, sizeof(regex_t));
/* prepare the regex */
err = regcomp(fop[i].op.func.ropt->regex, fop[i].op.func.string, REG_EXTENDED | REG_NOSUB | REG_ICASE );
if (err) {
regerror(err, fop[i].op.func.ropt->regex, errbuf, sizeof(errbuf));
FATAL_MSG("filter engine: %s", errbuf);
}
break;
case FFUNC_PCRE:
#ifdef HAVE_PCRE
/* alloc the structure */
SAFE_CALLOC(fop[i].op.func.ropt, 1, sizeof(struct regex_opt));
/* prepare the regex (with default option) */
fop[i].op.func.ropt->pregex = pcre_compile(fop[i].op.func.string, 0, &perrbuf, &err, NULL );
if (fop[i].op.func.ropt->pregex == NULL)
FATAL_MSG("filter engine: %s\n", perrbuf);
/* optimize the pcre */
fop[i].op.func.ropt->preg_extra = pcre_study(fop[i].op.func.ropt->pregex, 0, &perrbuf);
if (perrbuf != NULL)
FATAL_MSG("filter engine: %s\n", perrbuf);
#endif
break;
}
}
i++;
}
return ESUCCESS;
}
void clASELoader::ASE_ReadTVertexList( iIStream* FStream, clVAMender* Mender )
{
guard();
#ifdef ASE_HEAVY_DEBUG
Env->Logger->Log( L_DEBUG, "Reading Tvertex list..." );
#endif
char Keyword[32];
while ( !FStream->Eof() )
{
LString Line = FStream->ReadLineTrimLeadSpaces();
if ( LStr::ContainsSubStr( Line, "}" ) )
{
break;
}
else if ( LStr::StartsWith( Line, ASE_MeshTVertex ) )
{
int Index;
float U, V, W;
sscanf( Line.c_str(), "%s %d %f %f %f", Keyword, &Index, &U, &V, &W );
Mender->EmitTextureVertex( Index, LVector3( U, 1.0f - V, W ) );
}
else
{
FATAL_MSG( "Unexpected token in " + ASE_MeshTVertexList + " : " + Line );
}
}
unguard();
}
void clASELoader::ASE_ReadVertexList( iIStream* FStream, clVAMender* Mender )
{
guard();
#ifdef ASE_HEAVY_DEBUG
Env->Logger->Log( L_DEBUG, "Reading vertex list..." );
#endif
char Keyword[32];
int Index;
float X, Y, Z;
while ( !FStream->Eof() )
{
LString Line( FStream->ReadLineTrimLeadSpaces() );
if ( LStr::StartsWith( Line, ASE_MeshVertex ) )
{
sscanf( Line.c_str(), "%s %d %f %f %f", Keyword, &Index, &X, &Y, &Z );
Mender->EmitVertex( Index, LVector3( X, Y, Z ), -1, -1 );
}
else if ( LStr::ContainsSubStr( Line, "}" ) )
{
break;
}
else
{
FATAL_MSG( "Unexpected token in " + ASE_MeshVertexList + " : " + Line );
}
}
unguard();
}
void clASELoader::ASE_ReadMaterialList( iIStream* FStream )
{
guard();
while ( !FStream->Eof() )
{
LString Line = FStream->ReadLineTrimLeadSpaces();
if ( LStr::ContainsSubStr( Line, "}" ) )
{
break;
}
else if ( LStr::StartsWith( Line, ASE_MaterialCount ) )
{
int MaterialCount = LStr::ToInt( LStr::GetToken( Line, 2 ) );
FMaterialList.resize( MaterialCount );
}
else if ( LStr::StartsWith( Line, ASE_Material ) )
{
int MaterialIndex = LStr::ToInt( LStr::GetToken( Line, 2 ) );
//ASE_ReadMaterial( MaterialIndex, -1, 0 );
FMaterialList[ MaterialIndex ] = ASE_ReadMaterial( FStream, 0 );
}
else
{
FATAL_MSG( "Unexpected token in " + ASE_MaterialList + " : " + Line );
}
}
unguard();
}
int set_regex(char *regex)
{
int err;
char errbuf[100];
DEBUG_MSG("set_regex: %s", regex);
/* free any previous compilation */
if (GBL_OPTIONS->regex)
regfree(GBL_OPTIONS->regex);
/* unset the regex if empty */
if (!strcmp(regex, "")) {
SAFE_FREE(GBL_OPTIONS->regex);
return ESUCCESS;
}
/* allocate the new structure */
SAFE_CALLOC(GBL_OPTIONS->regex, 1, sizeof(regex_t));
/* compile the regex */
err = regcomp(GBL_OPTIONS->regex, regex, REG_EXTENDED | REG_NOSUB | REG_ICASE );
if (err) {
regerror(err, GBL_OPTIONS->regex, errbuf, sizeof(errbuf));
FATAL_MSG("%s\n", errbuf);
}
return ESUCCESS;
}
/*
* inject a file into the communication
*/
static int func_inject(struct filter_op *fop, struct packet_object *po)
{
int fd;
void *file;
size_t size, ret;
/* check the offensiveness */
if (GBL_OPTIONS->unoffensive)
JIT_FAULT("Cannot inject packets in unoffensive mode");
DEBUG_MSG("filter engine: func_inject %s", fop->op.func.string);
/* open the file */
if ((fd = open(fop->op.func.string, O_RDONLY | O_BINARY)) == -1) {
USER_MSG("filter engine: inject(): File not found (%s)\n", fop->op.func.string);
return -EFATAL;
}
/* get the size */
size = lseek(fd, 0, SEEK_END);
/* load the file in memory */
SAFE_CALLOC(file, size, sizeof(char));
/* rewind the pointer */
lseek(fd, 0, SEEK_SET);
ret = read(fd, file, size);
close(fd);
if (ret != size)
FATAL_MSG("Cannot read the file into memory");
/* check if we are overflowing pcap buffer */
if(GBL_PCAP->snaplen - (po->L4.header - (po->packet + po->L2.len) + po->L4.len) <= po->DATA.len + size)
JIT_FAULT("injected file too long");
/* copy the file into the buffer */
memcpy(po->DATA.data + po->DATA.len, file, size);
/* Adjust packet len and delta */
po->DATA.delta += size;
po->DATA.len += size;
/* mark the packet as modified */
po->flags |= PO_MODIFIED;
/* unset the flag to be dropped */
if (po->flags & PO_DROPPED)
po->flags ^= PO_DROPPED;
/* close and unmap the file */
SAFE_FREE(file);
return ESUCCESS;
}
void clConsole::DisplayMessage( const LString& Message, const LConsoleMessageType MSGType ) const
{
if ( Env )
{
Env->SendSync( L_EVENT_CONSOLELOG, LEventArgs( &Message ), false );
}
FTimeVisible = MESSAGE_VISIBILITY_TIME;
LVector4 Color;
switch ( MSGType )
{
case CMSG_ENGINEMESSAGE:
Color = LC_LinderdaumConsoleEM;
break;
case CMSG_ERRORMESSAGE:
Color = LC_LinderdaumConsoleERR;
break;
case CMSG_INFOTIP:
Color = LC_LinderdaumConsoleIT;
break;
default:
FATAL_MSG( "Unknown message type" );
}
LString Msg = Message;
LMutex Lock( &FMessagesHistoryMutex );
while ( true )
{
size_t Separation = Msg.find( "\n" );
if ( Separation == LString::npos )
{
break;
}
LString NewMsg = Msg.substr( 0, Separation );
FMessagesHistory.push_back( sConsoleMessage( NewMsg, Color ) );
if ( FMessagesHistory.size() > MAX_HISTORY_SIZE )
{
FMessagesHistory.pop_front();
}
Msg = Msg.substr( Separation + 1, Message.length() - 1 );
}
FMessagesHistory.push_back( sConsoleMessage( Msg, Color ) );
}
void clLoaderThread::clLoadOp_Image::Load()
{
// this Env is used in guard()
sEnvironment* Env = this->FResource->Env;
guard( "%s", this->FResource->GetFileName().c_str() );
LString FileName = this->FResource->GetFileName();
clBitmap* Bitmap = clBitmap::CreateEmptyBitmap( Env );
sBitmapParams* Params = &( this->FResource->GetDefaultBitmap()->FBitmapParams );
Env->Logger->Log( L_DEBUG, "Reallocating image data for new bitmap..." );
Bitmap->ReallocImageData( Params );
switch ( Bitmap->GetTextureType() )
{
case L_TEXTURE_2D:
FATAL( Bitmap->Load2DImage( Env, FileName ) == false, "Unable to load 2D texture: " + FileName );
break;
case L_TEXTURE_3D:
if ( Params->FAutoGradient )
{
FATAL( Bitmap->Load3DImageGradients( Env, FileName ) == false, "Unable to load Gradients 3D texture: " + FileName );
}
else if ( Params->FAutoESL )
{
FATAL( Bitmap->Load3DImageESL( Env, FileName ) == false, "Unable to load ESL 3D texture: " + FileName );
}
else
{
FATAL( Bitmap->Load3DImage( Env, FileName ) == false, "Unable to load 3D texture: " + FileName );
}
break;
case L_TEXTURE_CUBE:
FATAL( Bitmap->LoadCubeImage( Env, FileName ) == false, "Unable to load CUBE texture: " + FileName );
break;
default:
FATAL_MSG( "Unknown texture type" );
}
Env->Logger->Log( L_DEBUG, "Updating bitmap in resource..." );
this->FResource->SetBitmap( Bitmap );
this->FResource->SetAsyncLoadComplete( true );
unguard();
}
void clASELoader::ASE_ReadTFaceList( iIStream* FStream, clVAMender* Mender )
{
guard();
#ifdef ASE_HEAVY_DEBUG
Env->Logger->Log( L_DEBUG, "Reading Tface list..." );
#endif
LStr::clStringsVector Tokens( 6 );
while ( !FStream->Eof() )
{
LString Line = FStream->ReadLineTrimLeadSpaces();
if ( LStr::ContainsSubStr( Line, "}" ) )
{
break;
}
else if ( LStr::StartsWith( Line, ASE_MeshTFace ) )
{
LStr::FastSplitLine( 1, 5, Line, Tokens, true );
int Index = LStr::ToInt( Tokens[2] );
int A = LStr::ToInt( Tokens[3] );
int B = LStr::ToInt( Tokens[4] );
int C = LStr::ToInt( Tokens[5] );
Mender->EmitTextureFace( Index, A, B, C );
}
else
{
FATAL_MSG( "Unexpected token in " + ASE_MeshTFaceList + " : " + Line );
}
}
unguard();
}
/*
* open/close the file to store all the USER_MSG
*/
int set_msg_loglevel(int level, char *filename)
{
switch (level) {
case LOG_TRUE:
/* close the filedesc if already opened */
set_msg_loglevel(LOG_FALSE, filename);
EC_GBL_OPTIONS->msg_fd = fopen(filename, FOPEN_WRITE_TEXT);
if (EC_GBL_OPTIONS->msg_fd == NULL)
FATAL_MSG("Cannot open \"%s\" for writing", filename);
break;
case LOG_FALSE:
/* close the file and set the pointer to NULL */
if (EC_GBL_OPTIONS->msg_fd) {
fclose(EC_GBL_OPTIONS->msg_fd);
EC_GBL_OPTIONS->msg_fd = NULL;
}
break;
}
return E_SUCCESS;
}
/*
* parses the "format" and set the right visualization method
*/
int set_format(char *format)
{
DEBUG_MSG("set_format: %s", format);
if (!strcasecmp(format, "hex")) {
GBL_FORMAT = &hex_format;
return ESUCCESS;
}
if (!strcasecmp(format, "ascii")) {
GBL_FORMAT = &ascii_format;
return ESUCCESS;
}
if (!strcasecmp(format, "text")) {
GBL_FORMAT = &text_format;
return ESUCCESS;
}
if (!strcasecmp(format, "html")) {
GBL_FORMAT = &html_format;
return ESUCCESS;
}
if (!strcasecmp(format, "ebcdic")) {
GBL_FORMAT = &ebcdic_format;
return ESUCCESS;
}
if (!strcasecmp(format, "utf8")) {
GBL_FORMAT = &utf8_format;
return ESUCCESS;
}
FATAL_MSG("Unsupported format (%s)", format);
}
/*
* load the filter from a file
*/
int filter_load_file(char *filename, struct filter_list **list)
{
int fd;
void *file;
size_t size, ret;
struct filter_env *fenv;
struct filter_header fh;
DEBUG_MSG("filter_load_file (%s)", filename);
/* open the file */
if ((fd = open(filename, O_RDONLY | O_BINARY)) == -1)
FATAL_MSG("File not found or permission denied");
/* read the header */
if (read(fd, &fh, sizeof(struct filter_header)) != sizeof(struct filter_header))
FATAL_MSG("The file is corrupted");
/* sanity checks */
if (fh.magic != htons(EC_FILTER_MAGIC))
FATAL_MSG("Bad magic in filter file\nMake sure to compile the filter with etterfilter");
/* which version has compiled the filter ? */
if (strcmp(fh.version, EC_VERSION))
FATAL_MSG("Filter compiled for a different version");
/* get the size */
size = lseek(fd, 0, SEEK_END);
/* load the file in memory */
SAFE_CALLOC(file, size, sizeof(char));
/* rewind the pointer */
lseek(fd, 0, SEEK_SET);
ret = read(fd, file, size);
close(fd);
if (ret != size)
FATAL_MSG("Cannot read the file into memory");
FILTERS_LOCK;
/* advance to the end of the filter list */
while (*list) list = &(*list)->next;
/* allocate memory for the list entry */
SAFE_CALLOC(*list, 1, sizeof(struct filter_list));
fenv = &(*list)->env;
/* set the global variables */
fenv->map = file;
fenv->chain = (struct filter_op *)(file + fh.code);
fenv->len = size - sizeof(struct filter_header) - fh.code;
/*
* adjust all the string pointers
* they must point to the data segment
*/
reconstruct_strings(fenv, &fh);
/* save the name of the loaded filter */
(*list)->name = strdup(filename);
/* enable the filter */
(*list)->enabled = 1;
FILTERS_UNLOCK;
/* compile the regex to speed up the matching */
if (compile_regex(fenv, &fh) != ESUCCESS)
return -EFATAL;
USER_MSG("Content filters loaded from %s...\n", filename);
return ESUCCESS;
}
// =========
bool Tape::check_alphabet () const
{
bool ret_bool_value = true;
symbol_t phisical_empty_symbol = string();
vector<symbol_t>::const_iterator iter;
assert (!empty_symbols_alphabet_.empty());
assert (!input_alphabet_.empty());
assert (!internal_alphabet_.empty());
// ---------
iter = find (empty_symbols_alphabet_.begin(), empty_symbols_alphabet_.end(), phisical_empty_symbol);
if (iter != empty_symbols_alphabet_.end())
{
ret_bool_value = false;
FATAL_MSG ("Empty symbols alphabet -> symbol#"
<< distance (empty_symbols_alphabet_.begin(), iter)
<< " is phisically empty : <"
<< *iter
<< ">"
);
}
iter = find (input_alphabet_.begin(), input_alphabet_.end(), phisical_empty_symbol);
if (iter != input_alphabet_.end())
{
ret_bool_value = false;
FATAL_MSG ("Input alphabet -> symbol#"
<< distance (input_alphabet_.begin(), iter)
<< " is phisically empty : <"
<< *iter
<< ">"
);
}
iter = find (internal_alphabet_.begin(), internal_alphabet_.end(), phisical_empty_symbol);
if (iter != internal_alphabet_.end())
{
ret_bool_value = false;
FATAL_MSG ("Internal alphabet -> symbol#"
<< distance (internal_alphabet_.begin(), iter)
<< " is phisically empty : <"
<< *iter
<< ">"
);
}
// ------
vector<symbol_t> tmp_full_alphabet = get_full_alphabet();
vector<symbol_t>::iterator iter2;
for (iter2 = tmp_full_alphabet.begin(); iter2 != tmp_full_alphabet.end(); iter2++)
{
assert (count (iter2, tmp_full_alphabet.end(), *iter2));
if (count (iter2, tmp_full_alphabet.end(), *iter2) > 1)
{
ret_bool_value = false;
FATAL_MSG ("Alphabets -> symbol "
<< "<"
<< (*iter2)
<< ">"
<< " occurs more than once"
);
}
}
return ret_bool_value;
}
/*
* download the file and replace
* the existing one
*/
static int do_update(char *file, char *url, char *errbuf)
{
FILE *fd;
int sock;
int len, header_skipped = 0;
char *ptr = NULL;
char *host;
char getmsg[512];
char buffer[4096];
memset(buffer, 0, sizeof(buffer));
/* check if the url is valid */
if (!match_pattern(url, "http://*/*")) {
snprintf(errbuf, ERR_MAX_LEN, "invalid URL");
return 0;
}
/* get the hostname */
host = strdup(url + strlen("http://"));
ptr = host;
while (*ptr != '/') ptr++;
*ptr = '\0';
/* open the file for writing */
fd = open_data("share", file, FOPEN_WRITE_TEXT);
if (fd == NULL) {
snprintf(errbuf, ERR_MAX_LEN, "cannot open %s", file);
return 0;
}
sock = open_socket(host, 80);
switch(sock) {
case -ENOADDRESS:
FATAL_MSG("Cannot resolve %s", host);
break;
case -EFATAL:
FATAL_MSG("Cannot create the socket");
break;
case -ETIMEOUT:
FATAL_MSG("Connect timeout to %s on port 80", host);
break;
case -EINVALID:
FATAL_MSG("Error connecting to %s on port 80", host);
break;
}
/* prepare the HTTP request */
snprintf(getmsg, sizeof(getmsg), "GET %s HTTP/1.0\r\n"
"Host: %s\r\n"
"User-Agent: %s (%s)\r\n"
"\r\n", url, host, GBL_PROGRAM, GBL_VERSION );
/* send the request to the server */
socket_send(sock, getmsg, strlen(getmsg));
DEBUG_MSG("do_update - SEND \n\n%s\n\n", getmsg);
/* get the server response */
while ( (len = socket_recv(sock, buffer, sizeof(buffer) - 1)) ) {
DEBUG_MSG("do_update - RECEIVE \n\n%s\n\n", buffer);
/* skip the HTTP header */
if ( (ptr = strstr(buffer, "\r\n\r\n")))
header_skipped = 1;
/* write the data in the file */
if (header_skipped) {
if (ptr) {
write(fileno(fd), ptr + 4, len - (ptr + 4 - buffer));
} else {
write(fileno(fd), buffer, len);
}
}
memset(buffer, 0, sizeof(buffer));
ptr = NULL;
}
SAFE_FREE(host);
close_socket(sock);
fclose(fd);
return 1;
}
void clASELoader::ASE_ReadNormals( iIStream* FStream, clVAMender* Mender )
{
guard();
#ifdef ASE_HEAVY_DEBUG
Env->Logger->Log( L_DEBUG, "Reading normals..." );
#endif
int CurrentFace = -1;
int VertexIndex = 0;
sFaceNormal FaceNormal;
LStr::clStringsVector Tokens( 6 );
while ( !FStream->Eof() )
{
LString Line = FStream->ReadLineTrimLeadSpaces();
if ( LStr::ContainsSubStr( Line, "}" ) )
{
break;
}
else if ( LStr::StartsWith( Line, ASE_MeshFaceNormal ) )
{
if ( CurrentFace > -1 )
{
Mender->EmitFaceNormal( CurrentFace, FaceNormal );
}
LStr::FastSplitLine( 1, 5, Line, Tokens, true );
CurrentFace = LStr::ToInt( Tokens[2] );
float X = LStr::ToFloat( Tokens[3] );
float Y = LStr::ToFloat( Tokens[4] );
float Z = LStr::ToFloat( Tokens[5] );
VertexIndex = 0;
FaceNormal.FFaceNormal = LVector3( X, Y, Z );
}
else if ( LStr::StartsWith( Line, ASE_MeshVertexNormal ) )
{
LStr::FastSplitLine( 1, 5, Line, Tokens, true );
int Index = LStr::ToInt( Tokens[2] );
float X = LStr::ToFloat( Tokens[3] );
float Y = LStr::ToFloat( Tokens[4] );
float Z = LStr::ToFloat( Tokens[5] );
LVector3 Vec( X, Y, Z );
Mender->EmitNormal( Index, Vec );
FaceNormal.FVertexNormal[ VertexIndex++ ] = Vec;
}
else
{
FATAL_MSG( "Unexpected token in " + ASE_MeshNormals + " : " + Line );
}
}
if ( CurrentFace > -1 )
{
Mender->EmitFaceNormal( CurrentFace, FaceNormal );
}
unguard();
}
void clASELoader::ASE_ReadFaceList( iIStream* FStream, clVAMender* Mender )
{
guard();
#ifdef ASE_HEAVY_DEBUG
Env->Logger->Log( L_DEBUG, "Reading face list..." );
#endif
LStr::clStringsVector Tokens( 19 );
while ( !FStream->Eof() )
{
LString Line = FStream->ReadLineTrimLeadSpaces();
if ( LStr::ContainsSubStr( Line, "}" ) )
{
break;
}
else if ( LStr::StartsWith( Line, ASE_MeshFace ) )
{
LStr::FastSplitLine( 1, 18, Line, Tokens, true );
int Index = LStr::ToInt( Tokens[2].substr( 0, Tokens[2].length() - 1 ) );
int A = LStr::ToInt( Tokens[4] );
int B = LStr::ToInt( Tokens[6] );
int C = LStr::ToInt( Tokens[8] );
LString Token = Tokens[16];
int SubMTLTokenIndex = ( Token == ASE_MeshMaterialID ) ? 17 : 18;
LString SubMTL_ID = Tokens[SubMTLTokenIndex];
int SubMTL = SubMTL_ID.empty() ? -1 : LStr::ToInt( SubMTL_ID );
int SmoothingGroup = LStr::ToInt( Tokens[SubMTLTokenIndex-2] );
/*
LString IndexS = LStr::GetToken(Line, 2);
int Index = LStr::ToInt( IndexS.substr(0, IndexS.length()-1) );
int A = LStr::ToInt( LStr::GetToken(Line, 4) );
int B = LStr::ToInt( LStr::GetToken(Line, 6) );
int C = LStr::ToInt( LStr::GetToken(Line, 8) );
LString Token = LStr::GetToken(Line, 16);
int SubMTLTokenIndex = ( Token == ASE_MeshMaterialID ) ? 17 : 18;
LString SubMTL_ID = LStr::GetToken( Line, SubMTLTokenIndex );
int SubMTL = SubMTL_ID.empty() ? -1 : LStr::ToInt( SubMTL_ID );
int SmoothingGroup = LStr::ToInt( LStr::GetToken( Line, SubMTLTokenIndex-2 ) );
*/
/*
char Keyword[32];
int A, B, C;
int Index;
int AB, BC, CA;
int SmoothingGroup;
int SubMTL;
sscanf( Line.c_str(), "%s %d: A: %d B: %d C: %d AB: %d BC: %d CA: %d *MESH_SMOOTHING %d",
Keyword, &Index, &A, &B, &C, &AB, &BC, &CA, &SmoothingGroup);
char* pBuf = strrchr(Keyword, '*');
sscanf(pBuf,"*MESH_MTLID %d", &SubMTL);
*/
#ifdef ASE_HEAVY_DEBUG
Env->Logger->Log( L_DEBUG, "Smoothing group:" + LStr::ToStr( SmoothingGroup ) );
#endif
Mender->EmitFace( Index, A, B, C, SubMTL, SmoothingGroup );
}
else
{
FATAL_MSG( "Unexpected token in " + ASE_MeshFaceList + " : " + Line );
}
}
unguard();
}
void interrupt0() {
FATAL_MSG(("Attempted to divide by zero."));
DEBUG_MSG(("Eventually, this should only kill the current task."));
__asm__("hlt");
}
