void SQArray::Extend(const SQArray *a){
SQInteger xlen;
if((xlen=a->Size()))
for(SQInteger i=0;i<xlen;i++)
Append(a->_values[i]);
}
std::unique_ptr<Ephemeris<Frame>> Ephemeris<Frame>::ReadFromPreBourbakiMessages(
google::protobuf::RepeatedPtrField<
serialization::Plugin::CelestialAndProperties> const& messages,
Length const& fitting_tolerance,
typename Ephemeris<Frame>::FixedStepParameters const& fixed_parameters) {
LOG(INFO) << "Reading "<< messages.SpaceUsedExcludingSelf()
<< " bytes in pre-Bourbaki compatibility mode ";
std::vector<not_null<std::unique_ptr<MassiveBody const>>> bodies;
std::vector<DegreesOfFreedom<Frame>> initial_state;
std::vector<std::unique_ptr<DiscreteTrajectory<Frame>>> histories;
std::set<Instant> initial_time;
std::set<Instant> final_time;
for (auto const& message : messages) {
serialization::Celestial const& celestial = message.celestial();
bodies.emplace_back(MassiveBody::ReadFromMessage(celestial.body()));
histories.emplace_back(DiscreteTrajectory<Frame>::ReadFromMessage(
celestial.history_and_prolongation().history(), /*forks=*/{}));
auto const prolongation =
DiscreteTrajectory<Frame>::ReadPointerFromMessage(
celestial.history_and_prolongation().prolongation(),
histories.back().get());
typename DiscreteTrajectory<Frame>::Iterator const history_begin =
histories.back()->Begin();
initial_state.push_back(history_begin.degrees_of_freedom());
initial_time.insert(history_begin.time());
final_time.insert(prolongation->last().time());
}
CHECK_EQ(1, initial_time.size());
CHECK_EQ(1, final_time.size());
LOG(INFO) << "Initial time is " << *initial_time.cbegin()
<< ", final time is " << *final_time.cbegin();
// Construct a new ephemeris using the bodies and initial states and time
// extracted from the serialized celestials.
auto ephemeris = std::make_unique<Ephemeris<Frame>>(std::move(bodies),
initial_state,
*initial_time.cbegin(),
fitting_tolerance,
fixed_parameters);
// Extend the continuous trajectories using the data from the discrete
// trajectories.
std::set<Instant> last_state_time;
for (int i = 0; i < histories.size(); ++i) {
not_null<MassiveBody const*> const body = ephemeris->unowned_bodies_[i];
auto const& history = histories[i];
int const j = ephemeris->serialization_index_for_body(body);
auto continuous_trajectory = ephemeris->trajectories_[j];
typename DiscreteTrajectory<Frame>::Iterator it = history->Begin();
Instant last_time = it.time();
DegreesOfFreedom<Frame> last_degrees_of_freedom = it.degrees_of_freedom();
for (; it != history->End(); ++it) {
Time const duration_since_last_time = it.time() - last_time;
if (duration_since_last_time == fixed_parameters.step_) {
// A time in the discrete trajectory that is aligned on the continuous
// trajectory.
last_time = it.time();
last_degrees_of_freedom = it.degrees_of_freedom();
continuous_trajectory->Append(last_time, last_degrees_of_freedom);
} else if (duration_since_last_time > fixed_parameters.step_) {
// A time in the discrete trajectory that is not aligned on the
// continuous trajectory. Stop here, we'll use prolong to recompute the
// rest.
break;
}
}
// Fill the |last_state_| for this body. It will be the starting state for
// Prolong.
last_state_time.insert(last_time);
ephemeris->last_state_.positions[j] = last_degrees_of_freedom.position();
ephemeris->last_state_.velocities[j] = last_degrees_of_freedom.velocity();
}
CHECK_EQ(1, last_state_time.size());
ephemeris->last_state_.time = *last_state_time.cbegin();
LOG(INFO) << "Last time in discrete trajectories is "
<< *last_state_time.cbegin();
// Prolong the ephemeris to the final time. This might create discrepancies
// from the discrete trajectories.
ephemeris->Prolong(*final_time.cbegin());
return ephemeris;
}
CBool CScene::Load( CChar * fileName, CBool reportWarningsAndErrors, CBool readFromBuffer )
{
if ( fileName == NULL )
return CFalse;
CChar * nameOnly = GetAfterPath( fileName );
SetName( nameOnly );
// Instantiate the reference implementation
m_collada = new DAE;
PrintInfo( "\n" );
PrintInfo( _T("\n========Importing new external scene========"), COLOR_BLUE );
numErrors = numWarnings = 0;
domCOLLADA *dom;
if( readFromBuffer )
{
/////////////////////////////////////////////////////////////////
//zip path
CChar zipPath[MAX_NAME_SIZE];
Cpy( zipPath, fileName );
GetWithoutDot( zipPath );
Append(zipPath, ".zip" );
//file name inside zip file
CChar fileNameInZip[MAX_NAME_SIZE];
Cpy( fileNameInZip, GetAfterPath( fileName ) );
//Uncompress zip file
std::string buffer = ReadZipFile( zipPath, fileNameInZip );
//res = m_collada->load( "", buffer.c_str() );
dom = m_collada->openFromMemory( "", buffer.c_str() );
///////////////////////////////////////////////////////////////
}
else
{
// load with full path
//res = m_collada->load( fileName );
dom = m_collada->open(fileName);
}
//if (res != DAE_OK)
//{
// PrintInfo(_T("\nCScene::Load > Error loading the COLLADA file:") + CString(fileName), COLOR_RED );
// delete m_collada;
// m_collada = NULL;
//if( reportWarningsAndErrors )
//{
// char tempReport[MAX_NAME_SIZE];;
// sprintf( tempReport, "%s - fatal error (s)", nameOnly );
// PrintInfo2( tempReport, COLOR_RED );
//}
// return CFalse;
//}
PrintInfo( _T("\nCOLLADA_DOM Runtime database initialized from" ) );
PrintInfo( _T("'") + CString( fileName ), COLOR_RED_GREEN );
//PrintInfo( _T("nameOnly: '") + (CString)nameOnly + _T( "'\n" ) );
//domCOLLADA *dom = m_collada->getDom(nameOnly);
//if ( !dom )
// dom = m_collada->getDom( fileName);
if ( !dom )
{
PrintInfo( _T("\nCScene::Load > COLLADA File loaded to the dom, but query for the dom assets failed "), COLOR_RED );
PrintInfo( _T("\nCScene::Load > COLLADA Load Aborted! "), COLOR_RED );
delete m_collada;
m_collada = NULL;
if( reportWarningsAndErrors )
{
char tempReport[MAX_NAME_SIZE];;
sprintf( tempReport, "\n%s - Fatal error (s)", nameOnly );
PrintInfo( tempReport, COLOR_RED );
}
return CFalse;
}
CInt ret = 0;
//PrintInfo("Begin Conditioning\n");
//ret = kmzcleanup(m_collada, true);
//if (ret)
// PrintInfo("kmzcleanup complete\n");
ret = Triangulate(m_collada);
if (ret)
PrintInfo("\nTriangulate complete");
//ret = deindexer(m_collada);
//if (ret)
// PrintInfo("deindexer complete\n");
//PrintInfo("Finish Conditioning\n");
// Need to now get the asset tag which will determine what vector x y or z is up. Typically y or z.
if ( dom->getAsset()->getUp_axis() )
{
domAsset::domUp_axis *up = dom->getAsset()->getUp_axis();
switch( up->getValue() )
{
case UPAXISTYPE_X_UP:
PrintInfo(_T("\nWarning!X is Up Data and Hiearchies must be converted!") );
PrintInfo(_T("\nConversion to X axis Up isn't currently supported!") );
PrintInfo(_T("\nCOLLADA defaulting to Y Up") );
numWarnings +=1;
//CRender.SetUpAxis(eCYUp);
break;
case UPAXISTYPE_Y_UP:
PrintInfo( _T("\nY Axis is Up for this file...COLLADA set to Y Up ") );
//CRender.SetUpAxis(eCYUp);
break;
case UPAXISTYPE_Z_UP:
PrintInfo( _T("\nZ Axis is Up for this file ") );
PrintInfo( _T("\nAll Geometries and Hiearchies converted!"), COLOR_YELLOW ) ;
numWarnings +=1;
//CRender.SetUpAxis(eCZUp);
break;
default:
break;
}
}
strcpy( m_fileName, fileName );
strcpy( m_pureFileName, nameOnly );
// Load all the image libraries
//for ( CUInt i = 0; i < dom->getLibrary_images_array().getCount(); i++)
//{
// ReadImageLibrary( dom->getLibrary_images_array()[i] );
//}
CBool success = CFalse;
/*
CChar *cfxBinFilename = ReadCfxBinaryFilename( dom->getExtra_array() );
if ( cfxBinFilename != NULL )
{
cfxLoader::setBinaryLoadRemotePath( BasePath );
success = (CBool) cfxLoader::loadMaterialsAndEffectsFromBinFile(cfxBinFilename, cfxMaterials, cfxEffects, cgContext);
assert(success);
}
else
{
*/
//success = ( CBool ) cfxLoader::loadMaterialsAndEffects( m_collada, m_cfxMaterials, m_cfxEffects, m_cgContext );
//assert(success);
/*}*/
// Load all the effect libraries
//for ( CUInt i = 0; i < dom->getLibrary_effects_array().getCount(); i++)
//{
// ReadEffectLibrary( dom->getLibrary_effects_array()[i] );
//}
//// Load all the material libraries
//for ( CUInt i = 0; i < dom->getLibrary_materials_array().getCount(); i++)
//{
// ReadMaterialLibrary( dom->getLibrary_materials_array()[i] );
//}
// Load all the animation libraries
for ( CUInt i = 0; i < dom->getLibrary_animations_array().getCount(); i++)
{
ReadAnimationLibrary( dom->getLibrary_animations_array()[i] );
m_hasAnimation = CTrue;
}
//Load all animation clips
for ( CUInt i = 0; i < dom->getLibrary_animation_clips_array().getCount(); i++)
{
ReadAnimationClipLibrary( dom->getLibrary_animation_clips_array()[i] );
}
//If there's no clip in COLLADA file, try to create a default clip
if( m_numClips == 0 && dom->getLibrary_animations_array().getCount() > 0 )
{
//Create a default clip and attach all the animations to this clip
PrintInfo( "\nAdding default animation clip..." );
CAnimationClip * newAnimClip = CNew(CAnimationClip);
//CAssert("No memory\n", newAnimClip!=NULL);
newAnimClip->SetName( "defaultClip" );
newAnimClip->SetIndex(0);
newAnimClip->SetStart(0.0);
CFloat endTime = 0.0;
for(CUInt i=0; i<m_animations.size(); i++)
{
CAnimation * anim = m_animations[i];
PrintInfo( "\nAttaching animation ' ", COLOR_WHITE );PrintInfo( anim->GetName(), COLOR_RED_GREEN );
PrintInfo( " ' to the default animation clip", COLOR_WHITE );
anim->SetClipTarget( newAnimClip );
newAnimClip->m_animations.push_back( anim );
if( anim->GetEndTime() > endTime )
endTime = anim->GetEndTime();
}
newAnimClip->SetEnd((CDouble)endTime);
m_numClips = 1;
m_animationClips.push_back( newAnimClip );
}
// Find the scene we want
daeElement* defaultScene = dom->getScene()->getInstance_visual_scene()->getUrl().getElement();
domAsset::domUp_axis *up = dom->getAsset()->getUp_axis();
switch( up->getValue() )
{
case UPAXISTYPE_X_UP:
upAxis = eCXUp;
break;
case UPAXISTYPE_Y_UP:
upAxis = eCYUp;
break;
case UPAXISTYPE_Z_UP:
upAxis = eCZUp;
break;
default:
break;
}
if(defaultScene)
ReadScene( (domVisual_scene *)defaultScene, upAxis );
if (m_collada)
{
delete m_collada;
m_collada = 0;
}
if( reportWarningsAndErrors )
{
char tempReport[MAX_NAME_SIZE];
COLORREF color;
if( numErrors > 0 )
color = COLOR_RED;
else if (numWarnings > 0 )
color = COLOR_YELLOW;
else
color = COLOR_GREEN;
sprintf( tempReport, "\n%s - %i error (s), %i warning (s)", nameOnly, numErrors, numWarnings );
PrintInfo( tempReport, color );
totalErrors += numErrors;
totalWarnings += numWarnings;
}
return CTrue;
}
//--------------------------------------------------------------------------------
CUTF16String& CUTF16String::Append( const CUTF16String& Str )
{
return Append( Str.m_String, Str.m_String.Len() );
}
int main(int argc, char* argv[])
{
NodePtr head = NULL;
NodePtr second = NULL;
NodePtr third = NULL;
head = malloc(sizeof(Node));
second = malloc(sizeof(Node));
third = malloc(sizeof(Node));
assert(head != NULL);
assert(second != NULL);
assert(third != NULL);
head = buildList(head, second, third);
NodePtr newNode;
newNode = malloc(sizeof(Node));
newNode->data = 1;
newNode->next = head;
head = newNode; // now head points to list {1,2,3}
printList(head);
Push(&head, 13);
Push(&head, 2);
Push(&head, 1);
Push(&head, 23);
Push(&head, 35);
printf("Before reverse:\n");
printList(head);
Reverse(&head);
printf("After reverse:\n");
printList(head);
int count = countIntInList(head, 1);
printf("count of %d in list is : %d\n", 1, count);
printf("Third item in list is : %d\n", getNth(head, 3) );
#if 0
printf("Test code for append()\n");
NodePtr a;
a = malloc(sizeof(a));
assert( a!= NULL);
Push(&a, 100);
Push(&a, 200);
printf("Built list a :\n");
printList(a);
NodePtr b;
b = malloc(sizeof(a));
assert( b!= NULL);
Push(&b, 300);
Push(&b, 400);
printf("Built list b :\n");
printList(b);
//Delete(&a);
Append(&a, &b);
printf("After appending a to b :\n");
printList(a);
free(head);
#endif
#if 0
free(second);
free(third);
free(newNode);
free(a);
free(b);
#endif
return 0;
}
int yylex(void) {
int l;
char *yytext;
if (!scan_init) {
scanner_init();
}
if (next_token) {
l = next_token;
next_token = 0;
return l;
}
l = yylook();
/* Printf(stdout, "%s:%d:::%d: '%s'\n", cparse_file, cparse_line, l, Scanner_text(scan)); */
if (l == NONID) {
last_id = 1;
} else {
last_id = 0;
}
/* We got some sort of non-white space object. We set the start_line
variable unless it has already been set */
if (!cparse_start_line) {
cparse_start_line = cparse_line;
}
/* Copy the lexene */
switch (l) {
case NUM_INT:
case NUM_FLOAT:
case NUM_ULONG:
case NUM_LONG:
case NUM_UNSIGNED:
case NUM_LONGLONG:
case NUM_ULONGLONG:
if (l == NUM_INT)
yylval.dtype.type = T_INT;
if (l == NUM_FLOAT)
yylval.dtype.type = T_DOUBLE;
if (l == NUM_ULONG)
yylval.dtype.type = T_ULONG;
if (l == NUM_LONG)
yylval.dtype.type = T_LONG;
if (l == NUM_UNSIGNED)
yylval.dtype.type = T_UINT;
if (l == NUM_LONGLONG)
yylval.dtype.type = T_LONGLONG;
if (l == NUM_ULONGLONG)
yylval.dtype.type = T_ULONGLONG;
yylval.dtype.val = NewString(Scanner_text(scan));
yylval.dtype.bitfield = 0;
yylval.dtype.throws = 0;
return (l);
case ID:
yytext = Char(Scanner_text(scan));
if (yytext[0] != '%') {
/* Look for keywords now */
if (strcmp(yytext, "int") == 0) {
yylval.type = NewSwigType(T_INT);
return (TYPE_INT);
}
if (strcmp(yytext, "double") == 0) {
yylval.type = NewSwigType(T_DOUBLE);
return (TYPE_DOUBLE);
}
if (strcmp(yytext, "void") == 0) {
yylval.type = NewSwigType(T_VOID);
return (TYPE_VOID);
}
if (strcmp(yytext, "char") == 0) {
yylval.type = NewSwigType(T_CHAR);
return (TYPE_CHAR);
}
if (strcmp(yytext, "wchar_t") == 0) {
yylval.type = NewSwigType(T_WCHAR);
return (TYPE_WCHAR);
}
if (strcmp(yytext, "short") == 0) {
yylval.type = NewSwigType(T_SHORT);
return (TYPE_SHORT);
}
if (strcmp(yytext, "long") == 0) {
yylval.type = NewSwigType(T_LONG);
return (TYPE_LONG);
}
if (strcmp(yytext, "float") == 0) {
yylval.type = NewSwigType(T_FLOAT);
return (TYPE_FLOAT);
}
if (strcmp(yytext, "signed") == 0) {
yylval.type = NewSwigType(T_INT);
return (TYPE_SIGNED);
}
if (strcmp(yytext, "unsigned") == 0) {
yylval.type = NewSwigType(T_UINT);
return (TYPE_UNSIGNED);
}
if (strcmp(yytext, "bool") == 0) {
yylval.type = NewSwigType(T_BOOL);
return (TYPE_BOOL);
}
/* Non ISO (Windows) C extensions */
if (strcmp(yytext, "__int8") == 0) {
yylval.type = NewString(yytext);
return (TYPE_NON_ISO_INT8);
}
if (strcmp(yytext, "__int16") == 0) {
yylval.type = NewString(yytext);
return (TYPE_NON_ISO_INT16);
}
if (strcmp(yytext, "__int32") == 0) {
yylval.type = NewString(yytext);
return (TYPE_NON_ISO_INT32);
}
if (strcmp(yytext, "__int64") == 0) {
yylval.type = NewString(yytext);
return (TYPE_NON_ISO_INT64);
}
/* C++ keywords */
if (cparse_cplusplus) {
if (strcmp(yytext, "and") == 0)
return (LAND);
if (strcmp(yytext, "or") == 0)
return (LOR);
if (strcmp(yytext, "not") == 0)
return (LNOT);
if (strcmp(yytext, "class") == 0)
return (CLASS);
if (strcmp(yytext, "private") == 0)
return (PRIVATE);
if (strcmp(yytext, "public") == 0)
return (PUBLIC);
if (strcmp(yytext, "protected") == 0)
return (PROTECTED);
if (strcmp(yytext, "friend") == 0)
return (FRIEND);
if (strcmp(yytext, "virtual") == 0)
return (VIRTUAL);
if (strcmp(yytext, "operator") == 0) {
int nexttok;
String *s = NewString("operator ");
/* If we have an operator, we have to collect the operator symbol and attach it to
the operator identifier. To do this, we need to scan ahead by several tokens.
Cases include:
(1) If the next token is an operator as determined by Scanner_isoperator(),
it means that the operator applies to one of the standard C++ mathematical,
assignment, or logical operator symbols (e.g., '+','<=','==','&', etc.)
In this case, we merely append the symbol text to the operator string above.
(2) If the next token is (, we look for ). This is operator ().
(3) If the next token is [, we look for ]. This is operator [].
(4) If the next token is an identifier. The operator is possibly a conversion operator.
(a) Must check for special case new[] and delete[]
Error handling is somewhat tricky here. We'll try to back out gracefully if we can.
*/
nexttok = Scanner_token(scan);
if (Scanner_isoperator(nexttok)) {
/* One of the standard C/C++ symbolic operators */
Append(s,Scanner_text(scan));
yylval.str = s;
return OPERATOR;
} else if (nexttok == SWIG_TOKEN_LPAREN) {
/* Function call operator. The next token MUST be a RPAREN */
nexttok = Scanner_token(scan);
if (nexttok != SWIG_TOKEN_RPAREN) {
Swig_error(Scanner_file(scan),Scanner_line(scan),"Syntax error. Bad operator name.\n");
} else {
Append(s,"()");
yylval.str = s;
return OPERATOR;
}
} else if (nexttok == SWIG_TOKEN_LBRACKET) {
/* Array access operator. The next token MUST be a RBRACKET */
nexttok = Scanner_token(scan);
if (nexttok != SWIG_TOKEN_RBRACKET) {
Swig_error(Scanner_file(scan),Scanner_line(scan),"Syntax error. Bad operator name.\n");
} else {
Append(s,"[]");
yylval.str = s;
return OPERATOR;
}
} else if (nexttok == SWIG_TOKEN_ID) {
/* We have an identifier. This could be any number of things. It could be a named version of
an operator (e.g., 'and_eq') or it could be a conversion operator. To deal with this, we're
going to read tokens until we encounter a ( or ;. Some care is needed for formatting. */
int needspace = 1;
int termtoken = 0;
const char *termvalue = 0;
Append(s,Scanner_text(scan));
while (1) {
nexttok = Scanner_token(scan);
if (nexttok <= 0) {
Swig_error(Scanner_file(scan),Scanner_line(scan),"Syntax error. Bad operator name.\n");
}
if (nexttok == SWIG_TOKEN_LPAREN) {
termtoken = SWIG_TOKEN_LPAREN;
termvalue = "(";
break;
} else if (nexttok == SWIG_TOKEN_CODEBLOCK) {
termtoken = SWIG_TOKEN_CODEBLOCK;
termvalue = Scanner_text(scan);
break;
} else if (nexttok == SWIG_TOKEN_LBRACE) {
termtoken = SWIG_TOKEN_LBRACE;
termvalue = "{";
break;
} else if (nexttok == SWIG_TOKEN_SEMI) {
termtoken = SWIG_TOKEN_SEMI;
termvalue = ";";
break;
} else if (nexttok == SWIG_TOKEN_ID) {
if (needspace) {
Append(s," ");
}
Append(s,Scanner_text(scan));
} else {
Append(s,Scanner_text(scan));
needspace = 0;
}
}
yylval.str = s;
if (!rename_active) {
String *cs;
char *t = Char(s) + 9;
if (!((strcmp(t, "new") == 0)
|| (strcmp(t, "delete") == 0)
|| (strcmp(t, "new[]") == 0)
|| (strcmp(t, "delete[]") == 0)
|| (strcmp(t, "and") == 0)
|| (strcmp(t, "and_eq") == 0)
|| (strcmp(t, "bitand") == 0)
|| (strcmp(t, "bitor") == 0)
|| (strcmp(t, "compl") == 0)
|| (strcmp(t, "not") == 0)
|| (strcmp(t, "not_eq") == 0)
|| (strcmp(t, "or") == 0)
|| (strcmp(t, "or_eq") == 0)
|| (strcmp(t, "xor") == 0)
|| (strcmp(t, "xor_eq") == 0)
)) {
/* retract(strlen(t)); */
/* The operator is a conversion operator. In order to deal with this, we need to feed the
type information back into the parser. For now this is a hack. Needs to be cleaned up later. */
cs = NewString(t);
if (termtoken) Append(cs,termvalue);
Seek(cs,0,SEEK_SET);
Setline(cs,cparse_line);
Setfile(cs,cparse_file);
Scanner_push(scan,cs);
Delete(cs);
return COPERATOR;
}
}
if (termtoken)
Scanner_pushtoken(scan, termtoken, termvalue);
return (OPERATOR);
}
}
if (strcmp(yytext, "throw") == 0)
return (THROW);
if (strcmp(yytext, "try") == 0)
return (yylex());
if (strcmp(yytext, "catch") == 0)
return (CATCH);
if (strcmp(yytext, "inline") == 0)
return (yylex());
if (strcmp(yytext, "mutable") == 0)
return (yylex());
if (strcmp(yytext, "explicit") == 0)
return (EXPLICIT);
if (strcmp(yytext, "export") == 0)
return (yylex());
if (strcmp(yytext, "typename") == 0)
return (TYPENAME);
if (strcmp(yytext, "template") == 0) {
yylval.ivalue = cparse_line;
return (TEMPLATE);
}
if (strcmp(yytext, "delete") == 0) {
return (DELETE_KW);
}
if (strcmp(yytext, "using") == 0) {
return (USING);
}
if (strcmp(yytext, "namespace") == 0) {
return (NAMESPACE);
}
} else {
if (strcmp(yytext, "class") == 0) {
Swig_warning(WARN_PARSE_CLASS_KEYWORD, cparse_file, cparse_line, "class keyword used, but not in C++ mode.\n");
}
if (strcmp(yytext, "complex") == 0) {
yylval.type = NewSwigType(T_COMPLEX);
return (TYPE_COMPLEX);
}
if (strcmp(yytext, "restrict") == 0)
return (yylex());
}
/* Misc keywords */
if (strcmp(yytext, "extern") == 0)
return (EXTERN);
if (strcmp(yytext, "const") == 0)
return (CONST_QUAL);
if (strcmp(yytext, "static") == 0)
return (STATIC);
if (strcmp(yytext, "struct") == 0)
return (STRUCT);
if (strcmp(yytext, "union") == 0)
return (UNION);
if (strcmp(yytext, "enum") == 0)
return (ENUM);
if (strcmp(yytext, "sizeof") == 0)
return (SIZEOF);
if (strcmp(yytext, "typedef") == 0) {
yylval.ivalue = 0;
return (TYPEDEF);
}
/* Ignored keywords */
if (strcmp(yytext, "volatile") == 0)
return (VOLATILE);
if (strcmp(yytext, "register") == 0)
return (REGISTER);
if (strcmp(yytext, "inline") == 0)
return (yylex());
/* SWIG directives */
} else {
if (strcmp(yytext, "%module") == 0)
return (MODULE);
if (strcmp(yytext, "%insert") == 0)
return (INSERT);
if (strcmp(yytext, "%name") == 0)
return (NAME);
if (strcmp(yytext, "%rename") == 0) {
rename_active = 1;
return (RENAME);
}
if (strcmp(yytext, "%namewarn") == 0) {
rename_active = 1;
return (NAMEWARN);
}
if (strcmp(yytext, "%includefile") == 0)
return (INCLUDE);
if (strcmp(yytext, "%val") == 0) {
Swig_warning(WARN_DEPRECATED_VAL, cparse_file, cparse_line, "%%val directive deprecated (ignored).\n");
return (yylex());
}
if (strcmp(yytext, "%out") == 0) {
Swig_warning(WARN_DEPRECATED_OUT, cparse_file, cparse_line, "%%out directive deprecated (ignored).\n");
return (yylex());
}
if (strcmp(yytext, "%constant") == 0)
return (CONSTANT);
if (strcmp(yytext, "%typedef") == 0) {
yylval.ivalue = 1;
return (TYPEDEF);
}
if (strcmp(yytext, "%native") == 0)
return (NATIVE);
if (strcmp(yytext, "%pragma") == 0)
return (PRAGMA);
if (strcmp(yytext, "%extend") == 0)
return (EXTEND);
if (strcmp(yytext, "%fragment") == 0)
return (FRAGMENT);
if (strcmp(yytext, "%inline") == 0)
return (INLINE);
if (strcmp(yytext, "%typemap") == 0)
return (TYPEMAP);
if (strcmp(yytext, "%feature") == 0) {
/* The rename_active indicates we don't need the information of the
* following function's return type. This applied for %rename, so do
* %feature.
*/
rename_active = 1;
return (FEATURE);
}
if (strcmp(yytext, "%except") == 0)
return (EXCEPT);
if (strcmp(yytext, "%importfile") == 0)
return (IMPORT);
if (strcmp(yytext, "%echo") == 0)
return (ECHO);
if (strcmp(yytext, "%apply") == 0)
return (APPLY);
if (strcmp(yytext, "%clear") == 0)
return (CLEAR);
if (strcmp(yytext, "%types") == 0)
return (TYPES);
if (strcmp(yytext, "%parms") == 0)
return (PARMS);
if (strcmp(yytext, "%varargs") == 0)
return (VARARGS);
if (strcmp(yytext, "%template") == 0) {
return (SWIGTEMPLATE);
}
if (strcmp(yytext, "%warn") == 0)
return (WARN);
}
/* Have an unknown identifier, as a last step, we'll do a typedef lookup on it. */
/* Need to fix this */
if (check_typedef) {
if (SwigType_istypedef(yytext)) {
yylval.type = NewString(yytext);
return (TYPE_TYPEDEF);
}
}
yylval.id = Swig_copy_string(yytext);
last_id = 1;
return (ID);
case POUND:
return yylex();
case SWIG_TOKEN_COMMENT:
return yylex();
default:
return (l);
}
}
ssize_t MemKeyCache::StartRecover()
{
//非新建的共享内存,不用恢复
if (m_iInitType!=emInit)
{
return 0;
}
m_pMemCacheHead->m_iDataOK = 0;
//关闭binlog
ssize_t iOldBinLogOpen = m_iBinLogOpen;
m_iBinLogOpen = 0;
if (access(m_szDumpFile, F_OK) == 0)
{
//恢复core
ssize_t iRet = _CoreRecover(m_iDumpType);
if (iRet > 0)
{
if (m_iDumpType == DUMP_TYPE_MIRROR)
{
printf("Recover from dumpfile(%s) %lld bytes.\n",m_szDumpFile,(long long)iRet);
}
else
{
printf("Recover from dumpfile(%s) %lld records.\n",m_szDumpFile,(long long)iRet);
}
}
else
{
printf("not recover from dumpfile\n");
}
}
else
{
printf("no dumpfile to recover.\n");
}
char cOp = 0;
ssize_t iCount = 0;
ssize_t iLogLen = 0;
char* pTmpBuffer = new char[BUFFSIZE];
u_int64_t tLogTime;
//恢复日志流水,均为脏数据
m_stBinLog.ReadRecordStart();
while(0<(iLogLen = m_stBinLog.ReadRecordFromBinLog(pTmpBuffer,BUFFSIZE,tLogTime)))
{
memcpy(&cOp,pTmpBuffer,sizeof(cOp));
char *pBuffer = pTmpBuffer+sizeof(cOp);
ssize_t iBufferLen = iLogLen - sizeof(cOp);
if (cOp == op_set)
{
DecodeBufferFormat(pBuffer,iBufferLen);
Set(pNodeKey,*piNodeKeyLen,pNodeData,iNodeDataLen,*piDataFlag,pNodeReserve,*piNodeReserveLen);
}
else if (cOp == op_mark)
{
DecodeBufferKeyFormat(pBuffer,iBufferLen);
MarkFlag(pNodeKey,*piNodeKeyLen,*piDataFlag);
}
else if (cOp == op_del)
{
DecodeBufferKeyFormat(pBuffer,iBufferLen);
Del(pNodeKey,*piNodeKeyLen);
}
else if (cOp == op_append)
{
DecodeBufferFormat(pBuffer,iBufferLen);
Append(pNodeKey,*piNodeKeyLen,pNodeData,iNodeDataLen,*piDataFlag);
}
else
{
printf("bad binlog op %lld.\n",(long long)cOp);
}
iCount++;
}
printf("recover from binlog %lld records.\n",(long long)iCount);
delete []pTmpBuffer;
//恢复binlog开关
m_iBinLogOpen = iOldBinLogOpen;
m_pMemCacheHead->m_iDataOK = 1;
return 0;
}
//+-------------------------------------------------------------------------------------------------------------------------------
FvDynamicTuple::FvDynamicTuple(const FvBaseTuple& kOther)
{
Append(kOther);
}
BannerWindow::BannerWindow(GameBrowseMenu *m, struct discHdr *header)
: GuiWindow(screenwidth, screenheight)
, browserMenu(m)
, MaxAnimSteps(Settings.BannerZoomDuration)
{
ScreenProps.x = screenwidth;
ScreenProps.y = screenheight;
f32 xOffset = Settings.BannerProjectionOffsetX;
f32 yOffset = Settings.BannerProjectionOffsetY;
guMtxIdentity(modelview);
guMtxTransApply (modelview, modelview, xOffset, yOffset, 0.0F);
memcpy(&originalProjection, &FSProjection2D, sizeof(Mtx44));
returnVal = -1;
gameSelected = 0;
gameSound = NULL;
dvdheader = NULL;
reducedVol = false;
if(!bannerFrame.IsLoaded())
bannerFrame.Load(U8Archive(SystemMenuResources::Instance()->GetChanTtlAsh(),
SystemMenuResources::Instance()->GetChanTtlAshSize()));
AnimStep = 0;
AnimPosX = 0.5f * (ScreenProps.x - fIconWidth);
AnimPosY = 0.5f * (ScreenProps.y - fIconHeight);
AnimZoomIn = true;
AnimationRunning = false;
int gameIdx;
//! get the game index to this header
for(gameIdx = 0; gameIdx < gameList.size(); ++gameIdx)
{
if(gameList[gameIdx] == header)
{
gameSelected = gameIdx;
break;
}
}
//! Set dvd header if the header does not match any of the list games
if(gameIdx == gameList.size())
dvdheader = header;
GuiBannerGrid *bannerBrowser = dynamic_cast<GuiBannerGrid *>(browserMenu->GetGameBrowser());
if(bannerBrowser)
bannerBrowser->GetIconCoordinates(gameSelected, &AnimPosX, &AnimPosY);
gameBanner = new Banner;
imgLeft = Resources::GetImageData("startgame_arrow_left.png");
imgRight = Resources::GetImageData("startgame_arrow_right.png");
trigA = new GuiTrigger;
trigA->SetSimpleTrigger(-1, WPAD_BUTTON_A | WPAD_CLASSIC_BUTTON_A, PAD_BUTTON_A);
trigB = new GuiTrigger;
trigB->SetButtonOnlyTrigger(-1, WPAD_BUTTON_B | WPAD_CLASSIC_BUTTON_B, PAD_BUTTON_B);
trigL = new GuiTrigger;
trigL->SetButtonOnlyTrigger(-1, WPAD_BUTTON_LEFT | WPAD_CLASSIC_BUTTON_LEFT, PAD_BUTTON_LEFT);
trigR = new GuiTrigger;
trigR->SetButtonOnlyTrigger(-1, WPAD_BUTTON_RIGHT | WPAD_CLASSIC_BUTTON_RIGHT, PAD_BUTTON_RIGHT);
trigPlus = new GuiTrigger;
trigPlus->SetButtonOnlyTrigger(-1, WPAD_BUTTON_PLUS | WPAD_CLASSIC_BUTTON_PLUS, PAD_TRIGGER_R);
trigMinus = new GuiTrigger;
trigMinus->SetButtonOnlyTrigger(-1, WPAD_BUTTON_MINUS | WPAD_CLASSIC_BUTTON_MINUS, PAD_TRIGGER_L);
playcntTxt = new GuiText((char*) NULL, 18, thColor("r=0 g=0 b=0 a=255 - banner window playcount text color"));
playcntTxt->SetAlignment(ALIGN_CENTER, ALIGN_MIDDLE);
playcntTxt->SetPosition(thInt("0 - banner window play count pos x"),
thInt("215 - banner window play count pos y") - Settings.AdjustOverscanY / 2);
settingsBtn = new GuiButton(215, 75);
settingsBtn->SetAlignment(ALIGN_CENTER, ALIGN_MIDDLE);
settingsBtn->SetSoundOver(btnSoundOver);
settingsBtn->SetSoundClick(btnSoundAccept);
settingsBtn->SetPosition(-120, 175);
settingsBtn->SetTrigger(trigA);
startBtn = new GuiButton(215, 75);
startBtn->SetAlignment(ALIGN_CENTER, ALIGN_MIDDLE);
startBtn->SetSoundOver(btnSoundOver);
startBtn->SetSoundClick(btnSoundClick3);
startBtn->SetPosition(110, 175);
startBtn->SetTrigger(trigA);
backBtn = new GuiButton(215, 75);
backBtn->SetAlignment(ALIGN_CENTER, ALIGN_MIDDLE);
backBtn->SetSoundOver(btnSoundOver);
backBtn->SetSoundClick(btnSoundBack);
backBtn->SetPosition(-screenwidth, -screenheight); // set out of screen
backBtn->SetTrigger(0, trigA);
backBtn->SetTrigger(1, trigB);
btnLeftImg = new GuiImage(imgLeft);
if (Settings.wsprompt) btnLeftImg->SetWidescreen(Settings.widescreen);
btnLeft = new GuiButton(btnLeftImg, btnLeftImg, ALIGN_LEFT, ALIGN_MIDDLE, 20, -50, trigA, btnSoundOver, btnSoundClick2, 1);
btnLeft->SetTrigger(trigL);
btnLeft->SetTrigger(trigMinus);
btnRightImg = new GuiImage(imgRight);
if (Settings.wsprompt) btnRightImg->SetWidescreen(Settings.widescreen);
btnRight = new GuiButton(btnRightImg, btnRightImg, ALIGN_RIGHT, ALIGN_MIDDLE, -20, -50, trigA, btnSoundOver, btnSoundClick2, 1);
btnRight->SetTrigger(trigR);
btnRight->SetTrigger(trigPlus);
if (Settings.ShowPlayCount)
Append(playcntTxt);
Append(backBtn);
if (!dvdheader) //stuff we don't show if it is a DVD mounted
{
Append(btnLeft);
Append(btnRight);
}
bannerFrame.SetButtonBText(tr("Start"));
//check if unlocked
if (Settings.godmode || !(Settings.ParentalBlocks & BLOCK_GAME_SETTINGS))
{
bannerFrame.SetButtonAText(tr("Settings"));
Append(settingsBtn);
}
else
{
bannerFrame.SetButtonAText(tr("Back"));
backBtn->SetPosition(-120, 175);
}
Append(startBtn); //! Appending the disc on top of all
ChangeGame(false);
}
C4PacketList::C4PacketList(const C4PacketList &List2)
: C4PacketBase(List2),
pFirst(NULL), pLast(NULL)
{
Append(List2);
}
void FvDynamicTuple::operator=(const FvBaseTuple& kOther)
{
Clear();
Append(kOther);
}
const CDuiString& CDuiString::operator+=(const TCHAR ch)
{
TCHAR str[] = { ch, '\0' };
Append(str);
return *this;
}
const CDuiString& CDuiString::operator+=(const CDuiString& src)
{
Append(src);
return *this;
}
List<T>::List (const List<T>& x) : head_(nullptr), tail_(nullptr)
// copy constructor
{
Init();
Append(x);
}
static Node *template_locate(String *name, Parm *tparms, Symtab *tscope) {
Node *n = 0;
String *tname = 0;
Node *templ;
Symtab *primary_scope = 0;
List *possiblepartials = 0;
Parm *p;
Parm *parms = 0;
Parm *targs;
ParmList *expandedparms;
int *priorities_matrix = 0;
int max_possible_partials = 0;
int posslen = 0;
/* Search for primary (unspecialized) template */
templ = Swig_symbol_clookup(name, 0);
if (template_debug) {
tname = Copy(name);
SwigType_add_template(tname, tparms);
Printf(stdout, "\n");
Swig_diagnostic(cparse_file, cparse_line, "template_debug: Searching for match to: '%s'\n", tname);
Delete(tname);
tname = 0;
}
if (templ) {
tname = Copy(name);
parms = CopyParmList(tparms);
/* All template specializations must be in the primary template's scope, store the symbol table for this scope for specialization lookups */
primary_scope = Getattr(templ, "sym:symtab");
/* Add default values from primary template */
targs = Getattr(templ, "templateparms");
expandedparms = Swig_symbol_template_defargs(parms, targs, tscope, primary_scope);
/* reduce the typedef */
p = expandedparms;
while (p) {
SwigType *ty = Getattr(p, "type");
if (ty) {
SwigType *nt = Swig_symbol_type_qualify(ty, tscope);
Setattr(p, "type", nt);
Delete(nt);
}
p = nextSibling(p);
}
SwigType_add_template(tname, expandedparms);
/* Search for an explicit (exact) specialization. Example: template<> class name<int> { ... } */
{
if (template_debug) {
Printf(stdout, " searching for : '%s' (explicit specialization)\n", tname);
}
n = Swig_symbol_clookup_local(tname, primary_scope);
if (!n) {
SwigType *rname = Swig_symbol_typedef_reduce(tname, tscope);
if (!Equal(rname, tname)) {
if (template_debug) {
Printf(stdout, " searching for : '%s' (explicit specialization with typedef reduction)\n", rname);
}
n = Swig_symbol_clookup_local(rname, primary_scope);
}
Delete(rname);
}
if (n) {
Node *tn;
String *nodeType = nodeType(n);
if (Equal(nodeType, "template")) {
if (template_debug) {
Printf(stdout, " explicit specialization found: '%s'\n", Getattr(n, "name"));
}
goto success;
}
tn = Getattr(n, "template");
if (tn) {
if (template_debug) {
Printf(stdout, " previous instantiation found: '%s'\n", Getattr(n, "name"));
}
n = tn;
goto success; /* Previously wrapped by a template instantiation */
}
Swig_error(cparse_file, cparse_line, "'%s' is not defined as a template. (%s)\n", name, nodeType(n));
Delete(tname);
Delete(parms);
return 0; /* Found a match, but it's not a template of any kind. */
}
}
/* Search for partial specializations.
* Example: template<typename T> class name<T *> { ... }
* There are 3 types of template arguments:
* (1) Template type arguments
* (2) Template non type arguments
* (3) Template template arguments
* only (1) is really supported for partial specializations
*/
/* Rank each template parameter against the desired template parameters then build a matrix of best matches */
possiblepartials = NewList();
{
char tmp[32];
List *partials;
partials = Getattr(templ, "partials"); /* note that these partial specializations do not include explicit specializations */
if (partials) {
Iterator pi;
int parms_len = ParmList_len(parms);
int *priorities_row;
max_possible_partials = Len(partials);
priorities_matrix = (int *)malloc(sizeof(int) * max_possible_partials * parms_len); /* slightly wasteful allocation for max possible matches */
priorities_row = priorities_matrix;
for (pi = First(partials); pi.item; pi = Next(pi)) {
Parm *p = parms;
int all_parameters_match = 1;
int i = 1;
Parm *partialparms = Getattr(pi.item, "partialparms");
Parm *pp = partialparms;
String *templcsymname = Getattr(pi.item, "templcsymname");
if (template_debug) {
Printf(stdout, " checking match: '%s' (partial specialization)\n", templcsymname);
}
if (ParmList_len(partialparms) == parms_len) {
while (p && pp) {
SwigType *t;
sprintf(tmp, "$%d", i);
t = Getattr(p, "type");
if (!t)
t = Getattr(p, "value");
if (t) {
EMatch match = does_parm_match(t, Getattr(pp, "type"), tmp, tscope, priorities_row + i - 1);
if (match < (int)PartiallySpecializedMatch) {
all_parameters_match = 0;
break;
}
}
i++;
p = nextSibling(p);
pp = nextSibling(pp);
}
if (all_parameters_match) {
Append(possiblepartials, pi.item);
priorities_row += parms_len;
}
}
}
}
}
posslen = Len(possiblepartials);
if (template_debug) {
int i;
if (posslen == 0)
Printf(stdout, " matched partials: NONE\n");
else if (posslen == 1)
Printf(stdout, " chosen partial: '%s'\n", Getattr(Getitem(possiblepartials, 0), "templcsymname"));
else {
Printf(stdout, " possibly matched partials:\n");
for (i = 0; i < posslen; i++) {
Printf(stdout, " '%s'\n", Getattr(Getitem(possiblepartials, i), "templcsymname"));
}
}
}
if (posslen > 1) {
/* Now go through all the possibly matched partial specialization templates and look for a non-ambiguous match.
* Exact matches rank the highest and deduced parameters are ranked by how specialized they are, eg looking for
* a match to const int *, the following rank (highest to lowest):
* const int * (exact match)
* const T *
* T *
* T
*
* An ambiguous example when attempting to match as either specialization could match: %template() X<int *, double *>;
* template<typename T1, typename T2> X class {}; // primary template
* template<typename T1> X<T1, double *> class {}; // specialization (1)
* template<typename T2> X<int *, T2> class {}; // specialization (2)
*/
if (template_debug) {
int row, col;
int parms_len = ParmList_len(parms);
Printf(stdout, " parameter priorities matrix (%d parms):\n", parms_len);
for (row = 0; row < posslen; row++) {
int *priorities_row = priorities_matrix + row*parms_len;
Printf(stdout, " ");
for (col = 0; col < parms_len; col++) {
Printf(stdout, "%5d ", priorities_row[col]);
}
Printf(stdout, "\n");
}
}
{
int row, col;
int parms_len = ParmList_len(parms);
/* Printf(stdout, " parameter priorities inverse matrix (%d parms):\n", parms_len); */
for (col = 0; col < parms_len; col++) {
int *priorities_col = priorities_matrix + col;
int maxpriority = -1;
/*
Printf(stdout, "max_possible_partials: %d col:%d\n", max_possible_partials, col);
Printf(stdout, " ");
*/
/* determine the highest rank for this nth parameter */
for (row = 0; row < posslen; row++) {
int *element_ptr = priorities_col + row*parms_len;
int priority = *element_ptr;
if (priority > maxpriority)
maxpriority = priority;
/* Printf(stdout, "%5d ", priority); */
}
/* Printf(stdout, "\n"); */
/* flag all the parameters which equal the highest rank */
for (row = 0; row < posslen; row++) {
int *element_ptr = priorities_col + row*parms_len;
int priority = *element_ptr;
*element_ptr = (priority >= maxpriority) ? 1 : 0;
}
}
}
{
int row, col;
int parms_len = ParmList_len(parms);
Iterator pi = First(possiblepartials);
Node *chosenpartials = NewList();
if (template_debug)
Printf(stdout, " priority flags matrix:\n");
for (row = 0; row < posslen; row++) {
int *priorities_row = priorities_matrix + row*parms_len;
int highest_count = 0; /* count of highest priority parameters */
for (col = 0; col < parms_len; col++) {
highest_count += priorities_row[col];
}
if (template_debug) {
Printf(stdout, " ");
for (col = 0; col < parms_len; col++) {
Printf(stdout, "%5d ", priorities_row[col]);
}
Printf(stdout, "\n");
}
if (highest_count == parms_len) {
Append(chosenpartials, pi.item);
}
pi = Next(pi);
}
if (Len(chosenpartials) > 0) {
/* one or more best match found */
Delete(possiblepartials);
possiblepartials = chosenpartials;
posslen = Len(possiblepartials);
} else {
/* no best match found */
Delete(chosenpartials);
}
}
}
if (posslen > 0) {
String *s = Getattr(Getitem(possiblepartials, 0), "templcsymname");
n = Swig_symbol_clookup_local(s, primary_scope);
if (posslen > 1) {
int i;
if (n) {
Swig_warning(WARN_PARSE_TEMPLATE_AMBIG, cparse_file, cparse_line, "Instantiation of template '%s' is ambiguous,\n", SwigType_namestr(tname));
Swig_warning(WARN_PARSE_TEMPLATE_AMBIG, Getfile(n), Getline(n), " instantiation '%s' used,\n", SwigType_namestr(Getattr(n, "name")));
}
for (i = 1; i < posslen; i++) {
String *templcsymname = Getattr(Getitem(possiblepartials, i), "templcsymname");
Node *ignored_node = Swig_symbol_clookup_local(templcsymname, primary_scope);
assert(ignored_node);
Swig_warning(WARN_PARSE_TEMPLATE_AMBIG, Getfile(ignored_node), Getline(ignored_node), " instantiation '%s' ignored.\n", SwigType_namestr(Getattr(ignored_node, "name")));
}
}
}
if (!n) {
if (template_debug) {
Printf(stdout, " chosen primary template: '%s'\n", Getattr(templ, "name"));
}
n = templ;
}
} else {
if (template_debug) {
Printf(stdout, " primary template not found\n");
}
/* Give up if primary (unspecialized) template not found as specializations will only exist if there is a primary template */
n = 0;
}
if (!n) {
Swig_error(cparse_file, cparse_line, "Template '%s' undefined.\n", name);
} else if (n) {
String *nodeType = nodeType(n);
if (!Equal(nodeType, "template")) {
Swig_error(cparse_file, cparse_line, "'%s' is not defined as a template. (%s)\n", name, nodeType);
n = 0;
}
}
success:
Delete(tname);
Delete(possiblepartials);
if ((template_debug) && (n)) {
/*
Printf(stdout, "Node: %p\n", n);
Swig_print_node(n);
*/
Printf(stdout, " chosen template:'%s'\n", Getattr(n, "name"));
}
Delete(parms);
free(priorities_matrix);
return n;
}
void swill_deny(const char *ip) {
if (!SwillInit) return;
if (!ip_deny) ip_deny = NewList();
Append(ip_deny,ip);
}
static void cparse_template_expand(Node *templnode, Node *n, String *tname, String *rname, String *templateargs, List *patchlist, List *typelist, List *cpatchlist) {
static int expanded = 0;
String *nodeType;
if (!n)
return;
nodeType = nodeType(n);
if (Getattr(n, "error"))
return;
if (Equal(nodeType, "template")) {
/* Change the node type back to normal */
if (!expanded) {
expanded = 1;
set_nodeType(n, Getattr(n, "templatetype"));
cparse_template_expand(templnode, n, tname, rname, templateargs, patchlist, typelist, cpatchlist);
expanded = 0;
return;
} else {
/* Called when template appears inside another template */
/* Member templates */
set_nodeType(n, Getattr(n, "templatetype"));
cparse_template_expand(templnode, n, tname, rname, templateargs, patchlist, typelist, cpatchlist);
set_nodeType(n, "template");
return;
}
} else if (Equal(nodeType, "cdecl")) {
/* A simple C declaration */
SwigType *t, *v, *d;
String *code;
t = Getattr(n, "type");
v = Getattr(n, "value");
d = Getattr(n, "decl");
code = Getattr(n, "code");
Append(typelist, t);
Append(typelist, d);
Append(patchlist, v);
Append(cpatchlist, code);
if (Getattr(n, "conversion_operator")) {
Append(cpatchlist, Getattr(n, "name"));
if (Getattr(n, "sym:name")) {
Append(cpatchlist, Getattr(n, "sym:name"));
}
}
if (checkAttribute(n, "storage", "friend")) {
String *symname = Getattr(n, "sym:name");
if (symname) {
String *stripped_name = SwigType_templateprefix(symname);
Setattr(n, "sym:name", stripped_name);
Delete(stripped_name);
}
Append(typelist, Getattr(n, "name"));
}
add_parms(Getattr(n, "parms"), cpatchlist, typelist);
add_parms(Getattr(n, "throws"), cpatchlist, typelist);
} else if (Equal(nodeType, "class")) {
/* Patch base classes */
{
int b = 0;
for (b = 0; b < 3; ++b) {
List *bases = Getattr(n, baselists[b]);
if (bases) {
int i;
int ilen = Len(bases);
for (i = 0; i < ilen; i++) {
String *name = Copy(Getitem(bases, i));
Setitem(bases, i, name);
Append(typelist, name);
}
}
}
}
/* Patch children */
{
Node *cn = firstChild(n);
while (cn) {
cparse_template_expand(templnode, cn, tname, rname, templateargs, patchlist, typelist, cpatchlist);
cn = nextSibling(cn);
}
}
} else if (Equal(nodeType, "constructor")) {
String *name = Getattr(n, "name");
if (!(Getattr(n, "templatetype"))) {
String *symname;
String *stripped_name = SwigType_templateprefix(name);
if (Strstr(tname, stripped_name)) {
Replaceid(name, stripped_name, tname);
}
Delete(stripped_name);
symname = Getattr(n, "sym:name");
if (symname) {
stripped_name = SwigType_templateprefix(symname);
if (Strstr(tname, stripped_name)) {
Replaceid(symname, stripped_name, tname);
}
Delete(stripped_name);
}
if (strchr(Char(name), '<')) {
Append(patchlist, Getattr(n, "name"));
} else {
Append(name, templateargs);
}
name = Getattr(n, "sym:name");
if (name) {
if (strchr(Char(name), '<')) {
Clear(name);
Append(name, rname);
} else {
String *tmp = Copy(name);
Replace(tmp, tname, rname, DOH_REPLACE_ANY);
Clear(name);
Append(name, tmp);
Delete(tmp);
}
}
/* Setattr(n,"sym:name",name); */
}
Append(cpatchlist, Getattr(n, "code"));
Append(typelist, Getattr(n, "decl"));
add_parms(Getattr(n, "parms"), cpatchlist, typelist);
add_parms(Getattr(n, "throws"), cpatchlist, typelist);
} else if (Equal(nodeType, "destructor")) {
/* We only need to patch the dtor of the template itself, not the destructors of any nested classes, so check that the parent of this node is the root
* template node, with the special exception for %extend which adds its methods under an intermediate node. */
Node* parent = parentNode(n);
if (parent == templnode || (parentNode(parent) == templnode && Equal(nodeType(parent), "extend"))) {
String *name = Getattr(n, "name");
if (name) {
if (strchr(Char(name), '<'))
Append(patchlist, Getattr(n, "name"));
else
Append(name, templateargs);
}
name = Getattr(n, "sym:name");
if (name) {
if (strchr(Char(name), '<')) {
String *sn = Copy(tname);
Setattr(n, "sym:name", sn);
Delete(sn);
} else {
Replace(name, tname, rname, DOH_REPLACE_ANY);
}
}
/* Setattr(n,"sym:name",name); */
Append(cpatchlist, Getattr(n, "code"));
}
} else if (Equal(nodeType, "using")) {
String *uname = Getattr(n, "uname");
if (uname && strchr(Char(uname), '<')) {
Append(patchlist, uname);
}
if (Getattr(n, "namespace")) {
/* Namespace link. This is nasty. Is other namespace defined? */
}
} else {
/* Look for obvious parameters */
Node *cn;
Append(cpatchlist, Getattr(n, "code"));
Append(typelist, Getattr(n, "type"));
Append(typelist, Getattr(n, "decl"));
add_parms(Getattr(n, "parms"), cpatchlist, typelist);
add_parms(Getattr(n, "kwargs"), cpatchlist, typelist);
add_parms(Getattr(n, "pattern"), cpatchlist, typelist);
add_parms(Getattr(n, "throws"), cpatchlist, typelist);
cn = firstChild(n);
while (cn) {
cparse_template_expand(templnode, cn, tname, rname, templateargs, patchlist, typelist, cpatchlist);
cn = nextSibling(cn);
}
}
}
BString&
BString::AppendChars(const char* string, int32 charCount)
{
return Append(string, UTF8CountBytes(string, charCount));
}
void WS_DRAW_ITEM_LIST::BuildWorkSheetGraphicList(
const PAGE_INFO& aPageInfo,
const TITLE_BLOCK& aTitleBlock,
COLOR4D aColor, COLOR4D aAltColor )
{
WORKSHEET_LAYOUT& pglayout = WORKSHEET_LAYOUT::GetTheInstance();
#define milsTomm (25.4/1000)
m_titleBlock = &aTitleBlock;
m_paperFormat = &aPageInfo.GetType();
wxPoint LTmargin( Mm2mils( pglayout.GetLeftMargin() ),
Mm2mils( pglayout.GetTopMargin() ) );
wxPoint RBmargin( Mm2mils( pglayout.GetRightMargin() ),
Mm2mils( pglayout.GetBottomMargin() ) );
SetMargins( LTmargin, RBmargin );
SetPageSize( aPageInfo.GetSizeMils() );
// Build the basic layout shape, if the layout list is empty
if( pglayout.GetCount() == 0 && !pglayout.VoidListAllowed() )
pglayout.SetPageLayout();
WORKSHEET_DATAITEM::m_WSunits2Iu = m_milsToIu / milsTomm;
WORKSHEET_DATAITEM::m_Color = aColor; // the default color to draw items
WORKSHEET_DATAITEM::m_AltColor = aAltColor; // an alternate color to draw items
// Left top corner position
DPOINT lt_corner;
lt_corner.x = pglayout.GetLeftMargin();
lt_corner.y = pglayout.GetTopMargin();
WORKSHEET_DATAITEM::m_LT_Corner = lt_corner;
// Right bottom corner position
DPOINT rb_corner;
rb_corner.x = (m_pageSize.x*milsTomm) - pglayout.GetRightMargin();
rb_corner.y = (m_pageSize.y*milsTomm) - pglayout.GetBottomMargin();
WORKSHEET_DATAITEM::m_RB_Corner = rb_corner;
WS_DRAW_ITEM_TEXT* gtext;
int pensize;
for( unsigned ii = 0; ; ii++ )
{
WORKSHEET_DATAITEM* wsItem = pglayout.GetItem( ii );
if( wsItem == NULL )
break;
// Generate it only if the page option allows this
if( wsItem->GetPage1Option() < 0 // Not on page 1
&& m_sheetNumber <= 1 )
continue;
if( wsItem->GetPage1Option() > 0 // Only on page 1
&& m_sheetNumber > 1 )
continue;
COLOR4D color = wsItem->GetItemColor();
pensize = wsItem->GetPenSizeUi();
switch( wsItem->GetType() )
{
case WORKSHEET_DATAITEM::WS_TEXT:
{
WORKSHEET_DATAITEM_TEXT * wsText = (WORKSHEET_DATAITEM_TEXT*)wsItem;
bool multilines = false;
if( wsText->m_SpecialMode )
wsText->m_FullText = wsText->m_TextBase;
else
{
wsText->m_FullText = BuildFullText( wsText->m_TextBase );
multilines = wsText->ReplaceAntiSlashSequence();
}
if( wsText->m_FullText.IsEmpty() )
break;
if( pensize == 0 )
pensize = m_penSize;
wsText->SetConstrainedTextSize();
wxSize textsize;
textsize.x = KiROUND( wsText->m_ConstrainedTextSize.x
* WORKSHEET_DATAITEM::m_WSunits2Iu );
textsize.y = KiROUND( wsText->m_ConstrainedTextSize.y
* WORKSHEET_DATAITEM::m_WSunits2Iu );
if( wsText->IsBold())
pensize = GetPenSizeForBold( std::min( textsize.x, textsize.y ) );
for( int jj = 0; jj < wsText->m_RepeatCount; jj++)
{
if( jj && ! wsText->IsInsidePage( jj ) )
continue;
gtext = new WS_DRAW_ITEM_TEXT( wsText, wsText->m_FullText,
wsText->GetStartPosUi( jj ),
textsize, pensize, color,
wsText->IsItalic(),
wsText->IsBold() );
Append( gtext );
gtext->SetMultilineAllowed( multilines );
wsText->TransfertSetupToGraphicText( gtext );
// Increment label for the next text
// (has no meaning for multiline texts)
if( wsText->m_RepeatCount > 1 && !multilines )
wsText->IncrementLabel( (jj+1)*wsText->m_IncrementLabel);
}
}
break;
case WORKSHEET_DATAITEM::WS_SEGMENT:
if( pensize == 0 )
pensize = m_penSize;
for( int jj = 0; jj < wsItem->m_RepeatCount; jj++ )
{
if( jj && ! wsItem->IsInsidePage( jj ) )
continue;
Append( new WS_DRAW_ITEM_LINE( wsItem, wsItem->GetStartPosUi( jj ),
wsItem->GetEndPosUi( jj ),
pensize, color ) );
}
break;
case WORKSHEET_DATAITEM::WS_RECT:
if( pensize == 0 )
pensize = m_penSize;
for( int jj = 0; jj < wsItem->m_RepeatCount; jj++ )
{
if( jj && ! wsItem->IsInsidePage( jj ) )
break;
Append( new WS_DRAW_ITEM_RECT( wsItem, wsItem->GetStartPosUi( jj ),
wsItem->GetEndPosUi( jj ),
pensize, color ) );
}
break;
case WORKSHEET_DATAITEM::WS_POLYPOLYGON:
{
WORKSHEET_DATAITEM_POLYPOLYGON * wspoly =
(WORKSHEET_DATAITEM_POLYPOLYGON*) wsItem;
for( int jj = 0; jj < wsItem->m_RepeatCount; jj++ )
{
if( jj && ! wsItem->IsInsidePage( jj ) )
continue;
for( int kk = 0; kk < wspoly->GetPolyCount(); kk++ )
{
const bool fill = true;
WS_DRAW_ITEM_POLYGON* poly = new WS_DRAW_ITEM_POLYGON( wspoly,
wspoly->GetStartPosUi( jj ),
fill, pensize, color );
Append( poly );
// Create polygon outline
unsigned ist = wspoly->GetPolyIndexStart( kk );
unsigned iend = wspoly->GetPolyIndexEnd( kk );
while( ist <= iend )
poly->m_Corners.push_back(
wspoly->GetCornerPositionUi( ist++, jj ) );
}
}
}
break;
case WORKSHEET_DATAITEM::WS_BITMAP:
((WORKSHEET_DATAITEM_BITMAP*)wsItem)->SetPixelScaleFactor();
for( int jj = 0; jj < wsItem->m_RepeatCount; jj++ )
{
if( jj && ! wsItem->IsInsidePage( jj ) )
continue;
Append( new WS_DRAW_ITEM_BITMAP( wsItem,
wsItem->GetStartPosUi( jj ) ) );
}
break;
}
}
}
bool wxChoice::CreateAndInit(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
int n, const wxString choices[],
long style,
const wxValidator& validator,
const wxString& name)
{
if ( !(style & wxSP_VERTICAL) )
style |= wxSP_HORIZONTAL;
if ( (style & wxBORDER_MASK) == wxBORDER_DEFAULT )
style |= wxBORDER_SIMPLE;
style |= wxSP_ARROW_KEYS;
SetWindowStyle(style);
WXDWORD exStyle = 0;
WXDWORD msStyle = MSWGetStyle(GetWindowStyle(), & exStyle) ;
wxSize sizeText(size), sizeBtn(size);
sizeBtn.x = GetBestSpinnerSize(IsVertical(style)).x;
if ( sizeText.x == wxDefaultCoord )
{
// DEFAULT_ITEM_WIDTH is the default width for the text control
sizeText.x = DEFAULT_ITEM_WIDTH + MARGIN_BETWEEN + sizeBtn.x;
}
sizeText.x -= sizeBtn.x + MARGIN_BETWEEN;
if ( sizeText.x <= 0 )
{
wxLogDebug(wxT("not enough space for wxSpinCtrl!"));
}
wxPoint posBtn(pos);
posBtn.x += sizeText.x + MARGIN_BETWEEN;
// we must create the list control before the spin button for the purpose
// of the dialog navigation: if there is a static text just before the spin
// control, activating it by Alt-letter should give focus to the text
// control, not the spin and the dialog navigation code will give focus to
// the next control (at Windows level), not the one after it
// create the text window
m_hwndBuddy = (WXHWND)::CreateWindowEx
(
exStyle, // sunken border
wxT("LISTBOX"), // window class
NULL, // no window title
msStyle, // style (will be shown later)
pos.x, pos.y, // position
0, 0, // size (will be set later)
GetHwndOf(parent), // parent
(HMENU)-1, // control id
wxGetInstance(), // app instance
NULL // unused client data
);
if ( !m_hwndBuddy )
{
wxLogLastError(wxT("CreateWindow(buddy text window)"));
return false;
}
// initialize wxControl
if ( !CreateControl(parent, id, posBtn, sizeBtn, style, validator, name) )
return false;
// now create the real HWND
WXDWORD spiner_style = WS_VISIBLE |
UDS_ALIGNRIGHT |
UDS_ARROWKEYS |
UDS_SETBUDDYINT |
UDS_EXPANDABLE;
if ( !IsVertical(style) )
spiner_style |= UDS_HORZ;
if ( style & wxSP_WRAP )
spiner_style |= UDS_WRAP;
if ( !MSWCreateControl(UPDOWN_CLASS, spiner_style, posBtn, sizeBtn, wxEmptyString, 0) )
return false;
// subclass the text ctrl to be able to intercept some events
wxSetWindowUserData(GetBuddyHwnd(), this);
m_wndProcBuddy = (WXFARPROC)wxSetWindowProc(GetBuddyHwnd(),
wxBuddyChoiceWndProc);
// set up fonts and colours (This is nomally done in MSWCreateControl)
InheritAttributes();
if (!m_hasFont)
SetFont(GetDefaultAttributes().font);
// set the size of the text window - can do it only now, because we
// couldn't call DoGetBestSize() before as font wasn't set
if ( sizeText.y <= 0 )
{
int cx, cy;
wxGetCharSize(GetHWND(), &cx, &cy, GetFont());
sizeText.y = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);
}
SetInitialSize(size);
(void)::ShowWindow(GetBuddyHwnd(), SW_SHOW);
// associate the list window with the spin button
(void)::SendMessage(GetHwnd(), UDM_SETBUDDY, (WPARAM)GetBuddyHwnd(), 0);
// do it after finishing with m_hwndBuddy creation to avoid generating
// initial wxEVT_COMMAND_TEXT_UPDATED message
ms_allChoiceSpins.Add(this);
// initialize the controls contents
for ( int i = 0; i < n; i++ )
{
Append(choices[i]);
}
return true;
}
//--------------------------------------------------------------------------------
CUTF16String& CUTF16String::Append( CChar16 ch )
{
return Append( const_cast< const CChar16* >( &ch ), 1 );
}
// ProcessOne() takes a track, transforms it to bunch of buffer-blocks,
// and calls libsamplerate code on these blocks.
bool EffectChangeSpeed::ProcessOne(WaveTrack * track,
sampleCount start, sampleCount end)
{
if (track == NULL)
return false;
// initialization, per examples of Mixer::Mixer and
// EffectSoundTouch::ProcessOne
auto outputTrack = mFactory->NewWaveTrack(track->GetSampleFormat(),
track->GetRate());
//Get the length of the selection (as double). len is
//used simple to calculate a progress meter, so it is easier
//to make it a double now than it is to do it later
auto len = (end - start).as_double();
// Initiate processing buffers, most likely shorter than
// the length of the selection being processed.
auto inBufferSize = track->GetMaxBlockSize();
Floats inBuffer{ inBufferSize };
// mFactor is at most 100-fold so this shouldn't overflow size_t
auto outBufferSize = size_t( mFactor * inBufferSize + 10 );
Floats outBuffer{ outBufferSize };
// Set up the resampling stuff for this track.
Resample resample(true, mFactor, mFactor); // constant rate resampling
//Go through the track one buffer at a time. samplePos counts which
//sample the current buffer starts at.
bool bResult = true;
auto samplePos = start;
while (samplePos < end) {
//Get a blockSize of samples (smaller than the size of the buffer)
auto blockSize = limitSampleBufferSize(
track->GetBestBlockSize(samplePos),
end - samplePos
);
//Get the samples from the track and put them in the buffer
track->Get((samplePtr) inBuffer.get(), floatSample, samplePos, blockSize);
const auto results = resample.Process(mFactor,
inBuffer.get(),
blockSize,
((samplePos + blockSize) >= end),
outBuffer.get(),
outBufferSize);
const auto outgen = results.second;
if (outgen > 0)
outputTrack->Append((samplePtr)outBuffer.get(), floatSample,
outgen);
// Increment samplePos
samplePos += results.first;
// Update the Progress meter
if (TrackProgress(mCurTrackNum, (samplePos - start).as_double() / len)) {
bResult = false;
break;
}
}
// Flush the output WaveTrack (since it's buffered, too)
outputTrack->Flush();
// Take the output track and insert it in place of the original
// sample data
double newLength = outputTrack->GetEndTime();
if (bResult)
{
LinearTimeWarper warper { mCurT0, mCurT0, mCurT1, mCurT0 + newLength };
track->ClearAndPaste(
mCurT0, mCurT1, outputTrack.get(), true, false, &warper);
}
if (newLength > mMaxNewLength)
mMaxNewLength = newLength;
return bResult;
}
StaticStringBase<T, max> &operator +=(value_type ch) {
Append(ch);
return *this;
}
/// ---------------------------------------------------------------------------
/// Adds to the string.
/// ---------------------------------------------------------------------------
void prString::Append(const prString &str)
{
Append(str.Text());
}
void wxPropertyValue::Copy(wxPropertyValue& copyFrom)
{
if (m_type == wxPropertyValueString)
{
delete[] m_value.string ;
m_value.string = NULL;
}
m_type = copyFrom.Type();
switch (m_type)
{
case wxPropertyValueInteger:
(*this) = copyFrom.IntegerValue();
return ;
case wxPropertyValueReal:
(*this) = copyFrom.RealValue();
return ;
case wxPropertyValueString:
(*this) = wxString(copyFrom.StringValue());
return ;
case wxPropertyValuebool:
(*this) = copyFrom.BoolValue();
return ;
// Pointers
case wxPropertyValueboolPtr:
(*this) = copyFrom.BoolValuePtr();
return ;
case wxPropertyValueRealPtr:
(*this) = copyFrom.RealValuePtr();
return ;
case wxPropertyValueIntegerPtr:
(*this) = copyFrom.IntegerValuePtr();
return ;
case wxPropertyValueStringPtr:
{
wxChar** s = copyFrom.StringValuePtr();
#if 0
// what is this? are you trying to assign a bool or a string? VA can't figure it out..
#if defined(__VISAGECPP__) || defined( __VISUALC__ )
(*this) = s;
#else
(*this) = s != 0;
#endif
#endif // if 0
(*this) = (bool)(s != 0);
return ;
}
case wxPropertyValueList:
{
m_value.first = NULL;
m_next = NULL;
m_last = NULL;
wxPropertyValue *expr = copyFrom.m_value.first;
while (expr)
{
wxPropertyValue *expr2 = expr->NewCopy();
Append(expr2);
expr = expr->m_next;
}
return;
}
case wxPropertyValueNull:
wxFAIL_MSG( wxT("Should never get here!\n" ) );
break;
}
}
bool wxListBox::Create( wxWindow* pParent,
wxWindowID vId,
const wxPoint& rPos,
const wxSize& rSize,
int n,
const wxString asChoices[],
long lStyle,
const wxValidator& rValidator,
const wxString& rsName )
{
m_nNumItems = 0;
m_hWnd = 0;
m_nSelected = 0;
SetName(rsName);
#if wxUSE_VALIDATORS
SetValidator(rValidator);
#endif
if (pParent)
pParent->AddChild(this);
wxSystemSettings vSettings;
SetBackgroundColour(vSettings.GetColour(wxSYS_COLOUR_WINDOW));
SetForegroundColour(pParent->GetForegroundColour());
m_windowId = (vId == -1) ? (int)NewControlId() : vId;
int nX = rPos.x;
int nY = rPos.y;
int nWidth = rSize.x;
int nHeight = rSize.y;
m_windowStyle = lStyle;
lStyle = WS_VISIBLE;
if (m_windowStyle & wxCLIP_SIBLINGS )
lStyle |= WS_CLIPSIBLINGS;
if (m_windowStyle & wxLB_MULTIPLE)
lStyle |= LS_MULTIPLESEL;
else if (m_windowStyle & wxLB_EXTENDED)
lStyle |= LS_EXTENDEDSEL;
if (m_windowStyle & wxLB_HSCROLL)
lStyle |= LS_HORZSCROLL;
if (m_windowStyle & wxLB_OWNERDRAW)
lStyle |= LS_OWNERDRAW;
//
// Without this style, you get unexpected heights, so e.g. constraint layout
// doesn't work properly
//
lStyle |= LS_NOADJUSTPOS;
m_hWnd = (WXHWND)::WinCreateWindow( GetWinHwnd(pParent) // Parent
,WC_LISTBOX // Default Listbox class
,"LISTBOX" // Control's name
,lStyle // Initial Style
,0, 0, 0, 0 // Position and size
,GetWinHwnd(pParent) // Owner
,HWND_TOP // Z-Order
,(HMENU)m_windowId // Id
,NULL // Control Data
,NULL // Presentation Parameters
);
if (m_hWnd == 0)
{
return false;
}
//
// Subclass again for purposes of dialog editing mode
//
SubclassWin(m_hWnd);
LONG lUi;
for (lUi = 0; lUi < (LONG)n; lUi++)
{
Append(asChoices[lUi]);
}
wxFont* pTextFont = new wxFont( 10
,wxMODERN
,wxNORMAL
,wxNORMAL
);
SetFont(*pTextFont);
//
// Set OS/2 system colours for Listbox items and highlighting
//
wxColour vColour;
vColour = wxSystemSettingsNative::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
LONG lColor = (LONG)vColour.GetPixel();
::WinSetPresParam( m_hWnd
,PP_HILITEFOREGROUNDCOLOR
,sizeof(LONG)
,(PVOID)&lColor
);
vColour = wxSystemSettingsNative::GetColour(wxSYS_COLOUR_HIGHLIGHT);
lColor = (LONG)vColour.GetPixel();
::WinSetPresParam( m_hWnd
,PP_HILITEBACKGROUNDCOLOR
,sizeof(LONG)
,(PVOID)&lColor
);
SetXComp(0);
SetYComp(0);
SetSize( nX
,nY
,nWidth
,nHeight
);
delete pTextFont;
return true;
} // end of wxListBox::Create
/* Copy all content from ring buffer 'rBuf' to this ring buffer overwriting any existing data */
bool CRingBuffer::Copy(CRingBuffer &rBuf)
{
Clear();
return Append(rBuf);
}
int Swig_cparse_template_expand(Node *n, String *rname, ParmList *tparms, Symtab *tscope) {
List *patchlist, *cpatchlist, *typelist;
String *templateargs;
String *tname;
String *iname;
String *tbase;
patchlist = NewList();
cpatchlist = NewList();
typelist = NewList();
{
String *tmp = NewStringEmpty();
if (tparms) {
SwigType_add_template(tmp, tparms);
}
templateargs = Copy(tmp);
Delete(tmp);
}
tname = Copy(Getattr(n, "name"));
tbase = Swig_scopename_last(tname);
/* Look for partial specialization matching */
if (Getattr(n, "partialargs")) {
Parm *p, *tp;
ParmList *ptargs = SwigType_function_parms(Getattr(n, "partialargs"), n);
p = ptargs;
tp = tparms;
while (p && tp) {
SwigType *ptype;
SwigType *tptype;
SwigType *partial_type;
ptype = Getattr(p, "type");
tptype = Getattr(tp, "type");
if (ptype && tptype) {
partial_type = partial_arg(tptype, ptype);
/* Printf(stdout,"partial '%s' '%s' ---> '%s'\n", tptype, ptype, partial_type); */
Setattr(tp, "type", partial_type);
Delete(partial_type);
}
p = nextSibling(p);
tp = nextSibling(tp);
}
assert(ParmList_len(ptargs) == ParmList_len(tparms));
Delete(ptargs);
}
/*
Parm *p = tparms;
while (p) {
Printf(stdout, "tparm: '%s' '%s' '%s'\n", Getattr(p, "name"), Getattr(p, "type"), Getattr(p, "value"));
p = nextSibling(p);
}
*/
/* Printf(stdout,"targs = '%s'\n", templateargs);
Printf(stdout,"rname = '%s'\n", rname);
Printf(stdout,"tname = '%s'\n", tname); */
cparse_template_expand(n, n, tname, rname, templateargs, patchlist, typelist, cpatchlist);
/* Set the name */
{
String *name = Getattr(n, "name");
if (name) {
Append(name, templateargs);
}
iname = name;
}
/* Patch all of the types */
{
Parm *tp = Getattr(n, "templateparms");
Parm *p = tparms;
/* Printf(stdout,"%s\n", ParmList_str_defaultargs(tp)); */
if (tp) {
Symtab *tsdecl = Getattr(n, "sym:symtab");
while (p && tp) {
String *name, *value, *valuestr, *tmp, *tmpr;
int sz, i;
String *dvalue = 0;
String *qvalue = 0;
name = Getattr(tp, "name");
value = Getattr(p, "value");
if (name) {
if (!value)
value = Getattr(p, "type");
qvalue = Swig_symbol_typedef_reduce(value, tsdecl);
dvalue = Swig_symbol_type_qualify(qvalue, tsdecl);
if (SwigType_istemplate(dvalue)) {
String *ty = Swig_symbol_template_deftype(dvalue, tscope);
Delete(dvalue);
dvalue = ty;
}
assert(dvalue);
valuestr = SwigType_str(dvalue, 0);
/* Need to patch default arguments */
{
Parm *rp = nextSibling(p);
while (rp) {
String *rvalue = Getattr(rp, "value");
if (rvalue) {
Replace(rvalue, name, dvalue, DOH_REPLACE_ID);
}
rp = nextSibling(rp);
}
}
sz = Len(patchlist);
for (i = 0; i < sz; i++) {
String *s = Getitem(patchlist, i);
Replace(s, name, dvalue, DOH_REPLACE_ID);
}
sz = Len(typelist);
for (i = 0; i < sz; i++) {
String *s = Getitem(typelist, i);
/* Replace(s,name,value, DOH_REPLACE_ID); */
/* Printf(stdout,"name = '%s', value = '%s', tbase = '%s', iname='%s' s = '%s' --> ", name, dvalue, tbase, iname, s); */
SwigType_typename_replace(s, name, dvalue);
SwigType_typename_replace(s, tbase, iname);
/* Printf(stdout,"'%s'\n", s); */
}
tmp = NewStringf("#%s", name);
tmpr = NewStringf("\"%s\"", valuestr);
sz = Len(cpatchlist);
for (i = 0; i < sz; i++) {
String *s = Getitem(cpatchlist, i);
Replace(s, tmp, tmpr, DOH_REPLACE_ID);
Replace(s, name, valuestr, DOH_REPLACE_ID);
}
Delete(tmp);
Delete(tmpr);
Delete(valuestr);
Delete(dvalue);
Delete(qvalue);
}
p = nextSibling(p);
tp = nextSibling(tp);
if (!p)
p = tp;
}
} else {
/* No template parameters at all. This could be a specialization */
int i, sz;
sz = Len(typelist);
for (i = 0; i < sz; i++) {
String *s = Getitem(typelist, i);
SwigType_typename_replace(s, tbase, iname);
}
}
}
/* Patch bases */
{
List *bases = Getattr(n, "baselist");
if (bases) {
Iterator b;
for (b = First(bases); b.item; b = Next(b)) {
String *qn = Swig_symbol_type_qualify(b.item, tscope);
Clear(b.item);
Append(b.item, qn);
Delete(qn);
}
}
}
Delete(patchlist);
Delete(cpatchlist);
Delete(typelist);
Delete(tbase);
Delete(tname);
Delete(templateargs);
/* set_nodeType(n,"template"); */
return 0;
}
Datum& Attributed::AddEmptySignature(const std::string& name)
{
DefineUniqueAttributeName(name);
return Append(name);
}
/** append bytes from given source blob to the end of existing data bytes - reallocates if necessary */
FORCEINLINE void AppendRaw(const ByteBlob& src)
{
if (!src.IsEmpty()) {
memcpy(Append(src.Length()), src.Begin(), src.Length());
}
}