/////////////////////////////////////
//
// #keyword
//
Token *parseHashkeyword( Tokenizer *tokenizer ) {
assert( isHashkeywordStart( tokenizer->ss_, 0 ) );
StatefulStringPosition *start = malloc( sizeof( StatefulStringPosition ) );
memcpy( start, &( ( tokenizer->ss_ )->next_position ), sizeof( StatefulStringPosition ) );
ss_getchar( tokenizer->ss_ ); // Throw away the `#`
Token *t = parseName( tokenizer );
t->type = HASHKEYWORD;
free( t->start );
t->start = start;
return t;
}
TimeSource::TimeSource(const QString &name, QObject *parent)
: Plasma::DataContainer(parent),
m_offset(0),
m_latitude(0),
m_longitude(0),
m_sun(0),
m_moon(0),
m_moonPosition(false),
m_solarPosition(false),
m_local(false)
{
setObjectName(name);
setTimeZone(parseName(name));
}
void CModelReaderNode093_Color::parseXML(_In_ CXmlReader * pXMLReader)
{
// Parse name
parseName(pXMLReader);
// Parse attribute
parseAttributes(pXMLReader);
// Parse Content
parseContent(pXMLReader);
// Parse Color
parseColor();
}
char *OpenDDLParser::parseReference( char *in, char *end, std::vector<Name*> &names ) {
if( ddl_nullptr == in || in == end ) {
return in;
}
Name *nextName( ddl_nullptr );
in = parseName( in, end, &nextName );
if( nextName ) {
names.push_back( nextName );
}
while( Grammar::CommaSeparator[ 0 ] == *in ) {
in = getNextSeparator( in, end );
if( Grammar::CommaSeparator[ 0 ] == *in ) {
in = parseName( in, end, &nextName );
if( nextName ) {
names.push_back( nextName );
}
} else {
break;
}
}
return in;
}
void CModelReaderNode100_Colors::parseXML(_In_ CXmlReader * pXMLReader)
{
// Parse name
parseName(pXMLReader);
// Parse attribute
parseAttributes(pXMLReader);
// Use parameter and assign to model Object
if (m_nID == 0)
throw CNMRException(NMR_ERROR_MISSINGMODELRESOURCEID);
// Parse Content
parseContent(pXMLReader);
}
Spell::Spell(xmlNodePtr rootNode) {
xmlNodePtr curNode = rootNode->children;
priority = 100;
while(curNode) {
if(NODE_NAME(curNode, "Name")) {
xml::copyToBString(name, curNode);
parseName();
}
else if(NODE_NAME(curNode, "Script")) xml::copyToBString(script, curNode);
else if(NODE_NAME(curNode, "Priority")) xml::copyToNum(priority, curNode);
else if(NODE_NAME(curNode, "Description")) xml::copyToBString(description, curNode);
curNode = curNode->next;
}
}
XMLNode* XMLDecoderUTF8::parseAttribute()
{
String name, value ;
if( !parseName( name ) )
throw CVTException("Malformed attribute name");
skipWhitespace();
if( ! match( '=') )
throw CVTException("Malformed attribute - expected '='");
advance( 1 );
skipWhitespace();
if( !parseAttributeValue( value ) )
throw CVTException("Malformed attribute value");
skipWhitespace();
return new XMLAttribute( name, value );
}
static void liftSide(char *desc, struct hash *seqSizes, struct psl *psl, char *name, char strand, unsigned *seqSize, int *start, int *end, unsigned *starts)
/* life one side of the alignment */
{
int regStart, regEnd, i;
if (parseName(desc, name, ®Start, ®End))
{
*seqSize = hashIntVal(seqSizes, name);
if (*end > *seqSize)
errAbort("subrange %s:%d-%d extends past sequence end %ud", name, regStart, regEnd, *seqSize);
*start += regStart;
*end += regStart;
if (strand == '-')
reverseIntRange(®Start, ®End, *seqSize);
for (i = 0; i < psl->blockCount; i++)
starts[i] += regStart;
}
}
int saveNewEvent(char *keyword, char *id, char *value, int type){
xmlDocPtr doc;
xmlNodePtr cur;
doc = xmlParseFile(db_uri);
if (doc == NULL) {
fprintf(stderr, "Failed to parse %s\n", db_uri);
return 1;
}
cur = xmlDocGetRootElement(doc);
if (cur == NULL){
fprintf(stderr, "Empty document\n");
xmlFreeDoc(doc);
return 1;
}
if(type == 2) cur = cur->xmlChildrenNode;
while(cur != NULL){
if(type == 0){
if((!xmlStrcmp(cur->name, (const xmlChar *)"remendo_db"))){
return parseName(doc, cur, keyword, value);
}
}
if(type == 1){
if((!xmlStrcmp(cur->name, (const xmlChar *)"remendo_db"))){
xmlNodePtr event_node = xmlNewTextChild(cur, NULL, keyword, NULL);
xmlNewProp(event_node, "id", value);
}
}else{
if((!xmlStrcmp(cur->name, (const xmlChar *)"event"))){
xmlChar *current_id = xmlGetProp(cur, "id");
if(!strcmp(current_id, id)){
xmlNewTextChild(cur, NULL, keyword, value);
}
}
}
cur = cur->next;
}
xmlSaveFormatFile(db_uri, doc, 1);
xmlFreeDoc(doc);
}
std::shared_ptr<VirtualStruct> VirtualStruct::allocateFromC(
void * handle,
VirtualStruct_names names,
VirtualStruct_prettyNames prettyNames_optional,
VirtualStruct_read read_recommended,
VirtualStruct_write write_optional,
VirtualStruct_setListenerCallback setListenerCallback_optional,
std::function<void(void* handle)> cleanup
)
{
const int baseflags = (read_recommended?etiss::VirtualStruct::Field::R:0) | (write_optional?etiss::VirtualStruct::Field::W:0) | (setListenerCallback_optional?etiss::VirtualStruct::Field::L:0) | etiss::VirtualStruct::Field::P;
if (!names)
{
etiss::log(etiss::ERROR,"VirtualStruct::allocateFromC: names cannot be 0");
return std::shared_ptr<VirtualStruct>();
}
bool handle_deleted = false;
std::shared_ptr<VirtualStruct> ret = allocate(handle,[handle_deleted,handle,cleanup](Field*f) mutable
{
if (!handle_deleted)
{
handle_deleted = true;
cleanup(handle);
}
delete f;
});
size_t apos = 0;
const char * const * name_array = names(handle);
//const char * const * pname_array = names(handle);
while (name_array[apos] != 0)
{
unsigned flags;
std::string name;
parseName(name_array[apos],baseflags,flags,name);
///TODO
}
return ret;
}
bool Parser::parseProcessingInstruction (Node * node)
{
// Processing instructions start with <?
if (!doesStreamMatchString ("<?"))
return false;
std::string name;
if (!parseName (name))
reportError ("Valid processing instructions have to have a name.");
if (name == "xml")
reportError
("Processing instructions cannot have the reserved name 'xml'");
Node *thisNode = new Node;
thisNode->setName (name);
thisNode->setNodeType (ProcessingInstruction);
try
{
parseWhitespace ();
std::string chars;
while (!doesStreamMatchString ("?>"))
{
readChar (false);
data += current;
// We're in the middle of parsing a processing instruction
if (endOfData ())
reportError ("Unterminated processing instruction!");
}
thisNode->setData (data);
}
catch (...)
{
delete thisNode;
throw;
}
node->addNode (thisNode);
return true;
}
void CModelReaderNode_Slices1507_Polygon::parseXML(_In_ CXmlReader * pXMLReader) {
m_PolygonIndex = m_pSlice->beginPolygon();
// Parse name
parseName(pXMLReader);
// Parse attribute
parseAttributes(pXMLReader);
m_pSlice->addPolygonIndex(m_PolygonIndex, m_StartV);
// Parse Content
parseContent(pXMLReader);
if (!m_pSlice->isPolygonValid(m_PolygonIndex)) {
throw CNMRException(NMR_ERROR_CLOSED_SLICE_POLYGON_IS_LINE);
}
}
Error parseOne() {
read();
switch (Tok.K) {
case Eof:
return Error::success();
case KwExports:
for (;;) {
read();
if (Tok.K != Identifier) {
unget();
return Error::success();
}
if (Error Err = parseExport())
return Err;
}
case KwHeapsize:
return parseNumbers(&Info.HeapReserve, &Info.HeapCommit);
case KwStacksize:
return parseNumbers(&Info.StackReserve, &Info.StackCommit);
case KwLibrary:
case KwName: {
bool IsDll = Tok.K == KwLibrary; // Check before parseName.
std::string Name;
if (Error Err = parseName(&Name, &Info.ImageBase))
return Err;
Info.ImportName = Name;
// Set the output file, but don't override /out if it was already passed.
if (Info.OutputFile.empty()) {
Info.OutputFile = Name;
// Append the appropriate file extension if not already present.
if (!sys::path::has_extension(Name))
Info.OutputFile += IsDll ? ".dll" : ".exe";
}
return Error::success();
}
case KwVersion:
return parseVersion(&Info.MajorImageVersion, &Info.MinorImageVersion);
default:
return createError("unknown directive: " + Tok.Value);
}
}
/*
* createDirKFS
*/
SysStatus
createDirKFS(char *prog, Disk *disk, char *dir, uval uid, uval gid)
{
LSOBasicDir *lsoDir, *lsoNewDir;
ObjTokenID fileID;
char *dirname;
SysStatus rc;
// initialize the in-memory structures
if (sb == NULL) initFS(disk);
rc = parseName(1, sb, g, dir, lsoDir, dirname);
tassertMsg(_SUCCESS(rc), "? rc 0x%lx\n", rc);
// check if the file already exists
rc = lsoDir->matchDir(dirname, strlen(dirname), &fileID);
if (rc < 0) {
// doesn't exist, so create the new directory
#ifdef KFS_USE_GLOBAL_RECORDMAP
rc = lsoDir->createRecord(&fileID, OT_LSO_BASIC_DIR);
#else
rc = lsoDir->createRecord(&fileID, OT_LSO_DIR_EMB);
#endif
_IF_FAILURE_RET(rc);
lsoNewDir = (LSOBasicDir *)lsoDir->getLocalRecordMap()->getObj(&fileID);
lsoNewDir->initAttribute(S_IFDIR | (0755 & ~S_IFMT), uid, gid);
lsoDir->createDir(dirname, strlen(dirname), 0755, uid, &fileID);
lsoDir->flush();
lsoNewDir->flush();
} else {
err_printf("%s: directory %s already exists, no action taken by "
"createDirKFS\n", prog, dir);
return 0;
}
// sync the disk metadata
g->recordMap->flush();
sb->sync();
return 0;
}
bool Parser::parseETag( Node *node )
{
if( !doesStreamMatchString( "</" ) )
return false;
std::string name;
if( !parseName( name ) )
return false;
if( name != node->name() )
reportError( "End tag name '" + name + "' does not match start tag name '" + node->name() + "'" );
parseWhitespace();
if( current != '>' )
reportError( "End tag missing: '>'" );
readChar(); // Skip to the next char
return true;
}
void CModelReaderNode100_BaseMaterials::parseXML(_In_ CXmlReader * pXMLReader)
{
// Parse name
parseName(pXMLReader);
// Parse attribute
parseAttributes(pXMLReader);
// Use parameter and assign to model Object
if (m_nID == 0)
throw CNMRException(NMR_ERROR_MISSINGMODELRESOURCEID);
// Create Resource
m_pBaseMaterialResource = std::make_shared<CModelBaseMaterialResource> (m_nID, m_pModel);
m_pModel->addResource(m_pBaseMaterialResource);
// Parse Content
parseContent(pXMLReader);
}
bool Parser::parseAttribute( Node *node )
{
std::string name;
if( !parseName( name ) )
return false;
if( !parseEq() )
reportError( "Equals sign missing in attribute." );
std::string value;
if( !parseAttributeValue( value ) )
reportError( "Value missing in attribute" );
Node *thisNode = new Node;
thisNode->setNodeType( Attribute );
thisNode->setName( name );
thisNode->setData( value );
node->addNode( thisNode );
return true;
}
void Model::parseMesh(std::string fileName) {
std::string line;
std::ifstream myFile(fileName.c_str());
if (myFile.is_open()) {
while (getline(myFile, line)) {
if (line.at(0) == 'o') {
meshName = parseName(line);
} else if (line.at(0) == 'v' && line.at(1) == ' ') {
vertexArray.push_back(parseVertex(line));
} else if (line.at(0) == 'f') {
std::vector<std::string> elements = split(line, ' ');
if ((elements.size() - 1) == 4) {
quadArray.push_back(parseFace(elements));
} else if ((elements.size() - 1) == 3) {
triArray.push_back(parseFace(elements));
}
elements.clear();
} else {
// N-Gons
}
}
}
myFile.close();
}
static void
parseMember(xmlrpc_env * const envP,
xml_element * const memberP,
unsigned int const maxRecursion,
xmlrpc_value ** const keyPP,
xmlrpc_value ** const valuePP) {
unsigned int const childCount = xml_element_children_size(memberP);
if (childCount != 2)
setParseFault(envP,
"<member> element has %u children. Only one <name> and "
"one <value> make sense.", childCount);
else {
xml_element * nameElemP;
getNameChild(envP, memberP, &nameElemP);
if (!envP->fault_occurred) {
parseName(envP, nameElemP, keyPP);
if (!envP->fault_occurred) {
xml_element * valueElemP;
getValueChild(envP, memberP, &valueElemP);
if (!envP->fault_occurred)
xmlrpc_parseValue(envP, maxRecursion-1, valueElemP,
valuePP);
if (envP->fault_occurred)
xmlrpc_DECREF(*keyPP);
}
}
}
}
bool Parser::parseElement( Node *node )
{
if( current != '<' )
return false;
State state = SaveState();
std::string name;
readChar( false );
if( !parseName( name ) )
{
RestoreState( state );
return false;
}
Node *thisNode = new Node;
thisNode->setName( name );
thisNode->setNodeType( Element );
try
{
do
{
parseWhitespace();
}
while( parseAttribute( thisNode ) );
// Empty Element Tag
if( current == '/' )
{
readChar( false );
if( current != '>' )
reportError( "Tag not terminated properly." );
readChar(); // Skip Char
}
// Normal Start Tag
else if( current == '>' )
{
readChar( false );
parseContent( thisNode );
//thisNode->setData( thisNode->data().replace( ... ) );
// was: ThisNode.Data := TrimChars(ThisNode.Data, [' ', #9, #13, #10]);
if( !parseETag( thisNode ) )
reportError( "No ending tag for " + name );
}
// Not terminated properly
else
{
reportError( "Tag not terminated properly." );
}
}
catch( ... )
{
delete thisNode;
throw;
}
node->addNode( thisNode );
return true;
}
void NameModifiers::setName( const char* functionName )
{
if ( !name )
delete[] name;
parseName(functionName);
}
NameModifiers::NameModifiers( const char* functionName )
{
parseName(functionName);
}
/*
<type> ::= <CV-qualifiers> <type>
::= P <type>
::= R <type>
::= <builtin-type>
::= <function-type>
::= <name> # class-enum-type
::= <array-type>
::= <pointer-to-member-type>
::= <template-param>
::= <template-template-param> <template-args>
::= <substitution>
*/
static int parseType(LargeStaticString &src, LargeStaticString &dest, demangle_t &data)
{
START("Type");
// CV-qualifiers?
if (src[0] == 'r' || src[0] == 'V' || src[0] == 'K')
{
LargeStaticString tmp;
if (parseCvQualifiers(src, tmp, data) == FAIL)
END_FAIL("Type");
if (parseType(src, tmp, data) == FAIL)
END_FAIL("Type");
dest += tmp;
addSubstitution(tmp, data);
END_SUCCESS("Type");
}
// Pointer?
else if (src[0] == 'P')
{
src.stripFirst(1);
LargeStaticString tmp;
if (parseType(src, tmp, data) == FAIL)
END_FAIL("Type");
dest += tmp;
tmp += "*";
dest += "*";
addSubstitution(tmp, data);
END_SUCCESS("Type");
}
// Reference?
else if (src[0] == 'R')
{
src.stripFirst(1);
LargeStaticString tmp;
if (parseType(src, tmp, data) == FAIL)
END_FAIL("Type");
dest += tmp;
tmp += "&";
dest += "&";
addSubstitution(tmp, data);
END_SUCCESS("Type");
}
// Function-type?
else if (src[0] == 'F')
{
if (parseFunctionType(src, dest, data) == FAIL)
END_FAIL("Type");
END_SUCCESS("Type");
}
// Array type?
else if (src[0] == 'A')
{
if (parseArrayType(src, dest, data) == FAIL)
END_FAIL("Type");
END_SUCCESS("Type");
}
// Pointer-to-member type?
else if (src[0] == 'M')
{
if (parsePointerToMemberType(src, dest, data) == FAIL)
END_FAIL("Type");
END_SUCCESS("Type");
}
// Template parameter type?
else if (src[0] == 'T')
{
// Try the template-template-type first, if it fails fall back.
LargeStaticString origsrc = src;
LargeStaticString origdest = dest;
if (parseTemplateTemplateParam(src, dest, data) == SUCCESS &&
parseTemplateArgs(src, dest, data) == SUCCESS)
END_SUCCESS("Type");
src = origsrc;
dest = origdest;
if (parseTemplateParam(src, dest, data) == FAIL)
END_FAIL("Type");
END_SUCCESS("Type");
}
else
{
// OK then, try a builtin-type.
LargeStaticString origsrc = src;
LargeStaticString origdest = dest;
if (parseBuiltinType(src, dest, data) == SUCCESS)
END_SUCCESS("Type");
src = origsrc;
dest = origdest;
LargeStaticString tmp;
if (parseName(src, tmp, data) == SUCCESS)
{
dest += tmp;
addSubstitution(tmp, data);
END_SUCCESS("Type");
}
if (src[0] == 'S')
{
src = origsrc;
dest = origdest;
if (parseSubstitution(src, dest, data) == FAIL)
END_FAIL("Type");
END_SUCCESS("Type");
}
END_FAIL("Type");
}
}
/**
*
* @param name :: The name of a parameter
* @return index of the requested named parameter
*/
size_t CompositeFunction::parameterIndex(const std::string &name) const {
std::string pname;
size_t index;
parseName(name, index, pname);
return getFunction(index)->parameterIndex(pname) + m_paramOffsets[index];
}
bool LineParser::parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner)
{
if (mState==SetMemberVarState)
{
mMemberName = loc.mLiteral;
std::pair<char, bool> type = getContext().getMemberType (mMemberName, mName);
if (type.first!=' ')
{
mState = SetMemberVarState2;
mType = type.first;
mReferenceMember = type.second;
return true;
}
}
if (mState==SetPotentialMemberVarState && keyword==Scanner::K_to)
{
getErrorHandler().warning ("unknown variable (ignoring set instruction)", loc);
SkipParser skip (getErrorHandler(), getContext());
scanner.scan (skip);
return false;
}
if (mState==SetState)
{
// allow keywords to be used as variable names when assigning a value to a variable.
return parseName (loc.mLiteral, loc, scanner);
}
if (mState==BeginState || mState==ExplicitState)
{
switch (keyword)
{
case Scanner::K_enable:
Generator::enable (mCode, mLiterals, mExplicit);
mState = PotentialEndState;
return true;
case Scanner::K_disable:
Generator::disable (mCode, mLiterals, mExplicit);
mState = PotentialEndState;
return true;
case Scanner::K_startscript:
mExprParser.parseArguments ("c", scanner, mCode);
Generator::startScript (mCode, mLiterals, mExplicit);
mState = EndState;
return true;
case Scanner::K_stopscript:
mExprParser.parseArguments ("c", scanner, mCode);
Generator::stopScript (mCode);
mState = EndState;
return true;
}
// check for custom extensions
if (const Extensions *extensions = getContext().getExtensions())
{
std::string argumentType;
bool hasExplicit = mState==ExplicitState;
if (extensions->isInstruction (keyword, argumentType, hasExplicit))
{
if (!hasExplicit && mState==ExplicitState)
{
getErrorHandler().warning ("stray explicit reference (ignoring it)", loc);
mExplicit.clear();
}
int optionals = 0;
try
{
// workaround for broken positioncell instructions.
/// \todo add option to disable this
std::auto_ptr<ErrorDowngrade> errorDowngrade (0);
if (Misc::StringUtils::lowerCase (loc.mLiteral)=="positioncell")
errorDowngrade.reset (new ErrorDowngrade (getErrorHandler()));
std::vector<Interpreter::Type_Code> code;
optionals = mExprParser.parseArguments (argumentType, scanner, code);
mCode.insert (mCode.end(), code.begin(), code.end());
extensions->generateInstructionCode (keyword, mCode, mLiterals,
mExplicit, optionals);
}
catch (const SourceException& exception)
{
// Ignore argument exceptions for positioncell.
/// \todo add option to disable this
if (Misc::StringUtils::lowerCase (loc.mLiteral)=="positioncell")
{
SkipParser skip (getErrorHandler(), getContext());
scanner.scan (skip);
return false;
}
throw;
}
mState = EndState;
return true;
}
}
if (mAllowExpression)
{
if (keyword==Scanner::K_getdisabled || keyword==Scanner::K_getdistance)
{
scanner.putbackKeyword (keyword, loc);
parseExpression (scanner, loc);
mState = EndState;
return true;
}
if (const Extensions *extensions = getContext().getExtensions())
{
char returnType;
std::string argumentType;
bool hasExplicit = !mExplicit.empty();
if (extensions->isFunction (keyword, returnType, argumentType, hasExplicit))
{
if (!hasExplicit && !mExplicit.empty())
{
getErrorHandler().warning ("stray explicit reference (ignoring it)", loc);
mExplicit.clear();
}
scanner.putbackKeyword (keyword, loc);
parseExpression (scanner, loc);
mState = EndState;
return true;
}
}
}
}
if (mState==ExplicitState)
{
// drop stray explicit reference
getErrorHandler().warning ("stray explicit reference (ignoring it)", loc);
mState = BeginState;
mExplicit.clear();
}
if (mState==BeginState)
{
switch (keyword)
{
case Scanner::K_short:
case Scanner::K_long:
case Scanner::K_float:
{
if (!getContext().canDeclareLocals())
{
getErrorHandler().error (
"local variables can't be declared in this context", loc);
SkipParser skip (getErrorHandler(), getContext());
scanner.scan (skip);
return true;
}
DeclarationParser declaration (getErrorHandler(), getContext(), mLocals);
if (declaration.parseKeyword (keyword, loc, scanner))
scanner.scan (declaration);
return false;
}
case Scanner::K_set: mState = SetState; return true;
case Scanner::K_messagebox: mState = MessageState; return true;
case Scanner::K_return:
Generator::exit (mCode);
mState = EndState;
return true;
case Scanner::K_stopscript:
mExprParser.parseArguments ("c", scanner, mCode);
Generator::stopScript (mCode);
mState = EndState;
return true;
case Scanner::K_else:
getErrorHandler().warning ("stray else (ignoring it)", loc);
mState = EndState;
return true;
case Scanner::K_endif:
getErrorHandler().warning ("stray endif (ignoring it)", loc);
mState = EndState;
return true;
case Scanner::K_begin:
getErrorHandler().warning ("stray begin (ignoring it)", loc);
mState = EndState;
return true;
}
}
else if (mState==SetLocalVarState && keyword==Scanner::K_to)
{
mExprParser.reset();
scanner.scan (mExprParser);
std::vector<Interpreter::Type_Code> code;
char type = mExprParser.append (code);
Generator::assignToLocal (mCode, mLocals.getType (mName),
mLocals.getIndex (mName), code, type);
mState = EndState;
return true;
}
else if (mState==SetGlobalVarState && keyword==Scanner::K_to)
{
mExprParser.reset();
scanner.scan (mExprParser);
std::vector<Interpreter::Type_Code> code;
char type = mExprParser.append (code);
Generator::assignToGlobal (mCode, mLiterals, mType, mName, code, type);
mState = EndState;
return true;
}
else if (mState==SetMemberVarState2 && keyword==Scanner::K_to)
{
mExprParser.reset();
scanner.scan (mExprParser);
std::vector<Interpreter::Type_Code> code;
char type = mExprParser.append (code);
Generator::assignToMember (mCode, mLiterals, mType, mMemberName, mName, code, type,
!mReferenceMember);
mState = EndState;
return true;
}
if (mAllowExpression)
{
if (keyword==Scanner::K_getsquareroot || keyword==Scanner::K_menumode ||
keyword==Scanner::K_random || keyword==Scanner::K_scriptrunning ||
keyword==Scanner::K_getsecondspassed)
{
scanner.putbackKeyword (keyword, loc);
parseExpression (scanner, loc);
mState = EndState;
return true;
}
}
return Parser::parseKeyword (keyword, loc, scanner);
}
bool scanOmfLib(void *pctx,
void (*pAddObjModule)(void* pctx, char* name, void *base, size_t length),
void *buf, size_t buflen,
unsigned pagesize)
{
/* Split up the buffer buf[0..buflen] into multiple object modules,
* each aligned on a pagesize boundary.
*/
bool first_module = true;
unsigned char *base = NULL;
char name[LIBIDMAX + 1];
unsigned char *p = (unsigned char *)buf;
unsigned char *pend = p + buflen;
unsigned char *pnext;
for (; p < pend; p = pnext) // for each OMF record
{
if (p + 3 >= pend)
return true; // corrupt
unsigned char recTyp = *p;
unsigned short recLen = *(unsigned short *)(p + 1);
pnext = p + 3 + recLen;
if (pnext > pend)
return true; // corrupt
recLen--; // forget the checksum
switch (recTyp)
{
case LHEADR :
case THEADR :
if (!base)
{
base = p;
p += 3;
parseName(&p, name);
if (name[0] == 'C' && name[1] == 0) // old C compilers did this
base = pnext; // skip past THEADR
}
break;
case MODEND :
case M386END:
{
if (base)
{
(*pAddObjModule)(pctx, name, base, pnext - base);
base = NULL;
}
// Round up to next page
unsigned t = pnext - (unsigned char *)buf;
t = (t + pagesize - 1) & ~(unsigned)(pagesize - 1);
pnext = (unsigned char *)buf + t;
break;
}
default:
// ignore
;
}
}
return (base != NULL); // missing MODEND record
}
void scanOmfObjModule(void* pctx, void (*pAddSymbol)(void* pctx, char* name, int pickAny),
void *base, size_t buflen, const char *module_name, Loc loc)
{
#if LOG
printf("scanMSCoffObjModule(%s)\n", module_name);
#endif
int easyomf;
unsigned char result = 0;
char name[LIBIDMAX + 1];
Strings names;
names.push(NULL); // don't use index 0
easyomf = 0; // assume not EASY-OMF
unsigned char *pend = (unsigned char *)base + buflen;
unsigned char *pnext;
for (unsigned char *p = (unsigned char *)base; 1; p = pnext)
{
assert(p < pend);
unsigned char recTyp = *p++;
unsigned short recLen = *(unsigned short *)p;
p += 2;
pnext = p + recLen;
recLen--; // forget the checksum
switch (recTyp)
{
case LNAMES:
case LLNAMES:
while (p + 1 < pnext)
{
parseName(&p, name);
names.push(strdup(name));
}
break;
case PUBDEF:
if (easyomf)
recTyp = PUB386; // convert to MS format
case PUB386:
if (!(parseIdx(&p) | parseIdx(&p)))
p += 2; // skip seg, grp, frame
while (p + 1 < pnext)
{
parseName(&p, name);
p += (recTyp == PUBDEF) ? 2 : 4; // skip offset
parseIdx(&p); // skip type index
(*pAddSymbol)(pctx, name, 0);
}
break;
case COMDAT:
if (easyomf)
recTyp = COMDAT+1; // convert to MS format
case COMDAT+1:
{
int pickAny = 0;
if (*p++ & 5) // if continuation or local comdat
break;
unsigned char attr = *p++;
if (attr & 0xF0) // attr: if multiple instances allowed
pickAny = 1;
p++; // align
p += 2; // enum data offset
if (recTyp == COMDAT+1)
p += 2; // enum data offset
parseIdx(&p); // type index
if ((attr & 0x0F) == 0) // if explicit allocation
{ parseIdx(&p); // base group
parseIdx(&p); // base segment
}
unsigned idx = parseIdx(&p); // public name index
if( idx == 0 || idx >= names.dim)
{
//debug(printf("[s] name idx=%d, uCntNames=%d\n", idx, uCntNames));
error(loc, "corrupt COMDAT");
return;
}
//printf("[s] name='%s'\n",name);
(*pAddSymbol)(pctx, names[idx],pickAny);
break;
}
case ALIAS:
while (p + 1 < pnext)
{
parseName(&p, name);
(*pAddSymbol)(pctx, name, 0);
parseName(&p, name);
}
break;
case MODEND:
case M386END:
result = 1;
goto Ret;
case COMENT:
// Recognize Phar Lap EASY-OMF format
{ static unsigned char omfstr[7] =
{0x80,0xAA,'8','0','3','8','6'};
if (recLen == sizeof(omfstr))
{
for (unsigned i = 0; i < sizeof(omfstr); i++)
if (*p++ != omfstr[i])
goto L1;
easyomf = 1;
break;
L1: ;
}
}
// Recognize .IMPDEF Import Definition Records
{ static unsigned char omfstr[] =
{0,0xA0,1};
if (recLen >= 7)
{
p++;
for (unsigned i = 1; i < sizeof(omfstr); i++)
if (*p++ != omfstr[i])
goto L2;
p++; // skip OrdFlag field
parseName(&p, name);
(*pAddSymbol)(pctx, name, 0);
break;
L2: ;
}
}
break;
default:
// ignore
;
}
}
Ret:
for (size_t u = 1; u < names.dim; u++)
free(names[u]);
}
void Library::addObject(const char *module_name, void *buf, size_t buflen)
{
#if LOG
printf("Library::addObject(%s)\n", module_name ? module_name : "");
#endif
if (!buf)
{ assert(module_name);
FileName f((char *)module_name, 0);
File file(&f);
file.readv();
buf = file.buffer;
buflen = file.len;
file.ref = 1;
}
unsigned g_page_size;
unsigned char *pstart = (unsigned char *)buf;
int islibrary = 0;
/* See if it's an OMF library.
* Don't go by file extension.
*/
#pragma pack(1)
struct LibHeader
{
unsigned char recTyp; // 0xF0
unsigned short pagesize;
long lSymSeek;
unsigned short ndicpages;
unsigned char flags;
};
#pragma pack()
/* Determine if it is an OMF library, an OMF object module,
* or something else.
*/
if (buflen < sizeof(LibHeader))
{
Lcorrupt:
error("corrupt object module");
}
LibHeader *lh = (LibHeader *)buf;
if (lh->recTyp == 0xF0)
{ /* OMF library
* The modules are all at buf[g_page_size .. lh->lSymSeek]
*/
islibrary = 1;
g_page_size = lh->pagesize + 3;
buf = (void *)(pstart + g_page_size);
if (lh->lSymSeek > buflen ||
g_page_size > buflen)
goto Lcorrupt;
buflen = lh->lSymSeek - g_page_size;
}
else if (lh->recTyp == '!' && memcmp(lh, "!<arch>\n", 8) == 0)
{
error("COFF libraries not supported");
return;
}
else
{ // Not a library, assume OMF object module
g_page_size = 16;
}
/* Split up the buffer buf[0..buflen] into multiple object modules,
* each aligned on a g_page_size boundary.
*/
ObjModule *om = NULL;
int first_module = 1;
unsigned char *p = (unsigned char *)buf;
unsigned char *pend = p + buflen;
unsigned char *pnext;
for (; p < pend; p = pnext) // for each OMF record
{
if (p + 3 >= pend)
goto Lcorrupt;
unsigned char recTyp = *p;
unsigned short recLen = *(unsigned short *)(p + 1);
pnext = p + 3 + recLen;
if (pnext > pend)
goto Lcorrupt;
recLen--; /* forget the checksum */
switch (recTyp)
{
case LHEADR :
case THEADR :
if (!om)
{ char name[LIBIDMAX + 1];
om = new ObjModule();
om->flags = 0;
om->base = p;
p += 3;
parseName(&p, name);
if (first_module && module_name && !islibrary)
{ // Remove path and extension
om->name = strdup(FileName::name(module_name));
char *ext = FileName::ext(om->name);
if (ext)
ext[-1] = 0;
}
else
{ /* Use THEADR name as module name,
* removing path and extension.
*/
om->name = strdup(FileName::name(name));
char *ext = FileName::ext(om->name);
if (ext)
ext[-1] = 0;
om->flags |= MFtheadr;
}
if (strcmp(name, "C") == 0) // old C compilers did this
{ om->flags |= MFgentheadr; // generate our own THEADR
om->base = pnext; // skip past THEADR
}
objmodules.push(om);
first_module = 0;
}
break;
case MODEND :
case M386END:
if (om)
{ om->page = (om->base - pstart) / g_page_size;
om->length = pnext - om->base;
om = NULL;
}
// Round up to next page
unsigned t = pnext - pstart;
t = (t + g_page_size - 1) & ~(unsigned)(g_page_size - 1);
pnext = pstart + t;
break;
default:
// ignore
;
}
}
if (om)
goto Lcorrupt; // missing MODEND record
}
bool ExprParser::parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner)
{
if (const Extensions *extensions = getContext().getExtensions())
{
std::string argumentType; // ignored
bool hasExplicit = false; // ignored
if (extensions->isInstruction (keyword, argumentType, hasExplicit))
{
// pretend this is not a keyword
return parseName (loc.mLiteral, loc, scanner);
}
}
if (keyword==Scanner::K_end || keyword==Scanner::K_begin ||
keyword==Scanner::K_short || keyword==Scanner::K_long ||
keyword==Scanner::K_float || keyword==Scanner::K_if ||
keyword==Scanner::K_endif || keyword==Scanner::K_else ||
keyword==Scanner::K_elseif || keyword==Scanner::K_while ||
keyword==Scanner::K_endwhile || keyword==Scanner::K_return ||
keyword==Scanner::K_messagebox || keyword==Scanner::K_set ||
keyword==Scanner::K_to || keyword==Scanner::K_startscript ||
keyword==Scanner::K_stopscript || keyword==Scanner::K_enable ||
keyword==Scanner::K_disable)
{
return parseName (loc.mLiteral, loc, scanner);
}
mFirst = false;
if (!mExplicit.empty())
{
if (mRefOp && mNextOperand)
{
if (keyword==Scanner::K_getdisabled)
{
start();
mTokenLoc = loc;
Generator::getDisabled (mCode, mLiterals, mExplicit);
mOperands.push_back ('l');
mExplicit.clear();
mRefOp = false;
mNextOperand = false;
return true;
}
else if (keyword==Scanner::K_getdistance)
{
start();
mTokenLoc = loc;
parseArguments ("c", scanner);
Generator::getDistance (mCode, mLiterals, mExplicit);
mOperands.push_back ('f');
mExplicit.clear();
mRefOp = false;
mNextOperand = false;
return true;
}
// check for custom extensions
if (const Extensions *extensions = getContext().getExtensions())
{
char returnType;
std::string argumentType;
bool hasExplicit = true;
if (extensions->isFunction (keyword, returnType, argumentType, hasExplicit))
{
if (!hasExplicit)
{
getErrorHandler().warning ("stray explicit reference (ignoring it)", loc);
mExplicit.clear();
}
start();
mTokenLoc = loc;
int optionals = parseArguments (argumentType, scanner);
extensions->generateFunctionCode (keyword, mCode, mLiterals, mExplicit,
optionals);
mOperands.push_back (returnType);
mExplicit.clear();
mRefOp = false;
mNextOperand = false;
return true;
}
}
}
return Parser::parseKeyword (keyword, loc, scanner);
}
if (mNextOperand)
{
if (keyword==Scanner::K_getsquareroot)
{
start();
mTokenLoc = loc;
parseArguments ("f", scanner);
Generator::squareRoot (mCode);
mOperands.push_back ('f');
mNextOperand = false;
return true;
}
else if (keyword==Scanner::K_menumode)
{
start();
mTokenLoc = loc;
Generator::menuMode (mCode);
mOperands.push_back ('l');
mNextOperand = false;
return true;
}
else if (keyword==Scanner::K_random)
{
start();
mTokenLoc = loc;
parseArguments ("l", scanner);
Generator::random (mCode);
mOperands.push_back ('l');
mNextOperand = false;
return true;
}
else if (keyword==Scanner::K_scriptrunning)
{
start();
mTokenLoc = loc;
parseArguments ("c", scanner);
Generator::scriptRunning (mCode);
mOperands.push_back ('l');
mNextOperand = false;
return true;
}
else if (keyword==Scanner::K_getdistance)
{
start();
mTokenLoc = loc;
parseArguments ("c", scanner);
Generator::getDistance (mCode, mLiterals, "");
mOperands.push_back ('f');
mNextOperand = false;
return true;
}
else if (keyword==Scanner::K_getsecondspassed)
{
start();
mTokenLoc = loc;
Generator::getSecondsPassed (mCode);
mOperands.push_back ('f');
mNextOperand = false;
return true;
}
else if (keyword==Scanner::K_getdisabled)
{
start();
mTokenLoc = loc;
Generator::getDisabled (mCode, mLiterals, "");
mOperands.push_back ('l');
mNextOperand = false;
return true;
}
else
{
// check for custom extensions
if (const Extensions *extensions = getContext().getExtensions())
{
start();
char returnType;
std::string argumentType;
bool hasExplicit = false;
if (extensions->isFunction (keyword, returnType, argumentType, hasExplicit))
{
mTokenLoc = loc;
int optionals = parseArguments (argumentType, scanner);
extensions->generateFunctionCode (keyword, mCode, mLiterals, "", optionals);
mOperands.push_back (returnType);
mNextOperand = false;
return true;
}
}
}
}
else
{
// no comma was used between arguments
scanner.putbackKeyword (keyword, loc);
return false;
}
return Parser::parseKeyword (keyword, loc, scanner);
}
/**
* Parameters by name.
* @param name :: The name of the parameter.
* @return value of the requested named parameter
*/
double CompositeFunction::getParameter(const std::string &name) const {
std::string pname;
size_t index;
parseName(name, index, pname);
return getFunction(index)->getParameter(pname);
}
