static gboolean
IsMemberInList (uid_t user, struct group *g)
{
gboolean result = FALSE;
gchar *utf8_username = GetTokenName (user);
if (!utf8_username)
return FALSE;
if (g) {
gchar **users = g->gr_mem;
while (*users) {
gchar *u = *(users);
if (strcmp (utf8_username, u) == 0) {
result = TRUE;
break;
}
users++;
}
}
g_free (utf8_username);
return result;
}
/** Display an invalid tag error message. */
void InvalidTag(const TokenNode *tp, TokenType parent)
{
ParseError(tp, _("invalid tag in %s: %s"),
GetTokenTypeName(parent), GetTokenName(tp));
}
/** Parse a token value using a string mapping. */
int ParseTokenValue(const StringMappingType *mapping, int count,
const TokenNode *tp, int def)
{
if(JUNLIKELY(tp->value == NULL)) {
ParseError(tp, "%s is empty", GetTokenName(tp));
return def;
} else {
const int x = FindValue(mapping, count, tp->value);
if(JLIKELY(x >= 0)) {
return x;
} else {
ParseError(tp, "invalid %s: \"%s\"", GetTokenName(tp), tp->value);
return def;
}
}
}
int CInterpreter::GetType( char *get )
{
CToken *token;
char *string;
int type;
token = m_tokenizer->GetToken(0, 0);
type = token->GetType();
if ( type != TK_IDENTIFIER )
{
return Error("syntax error : expected identifier; found %s", GetTokenName(type));
}
string = (char *) token->GetStringValue();
if ( (strlen(string) + 1) > MAX_STRING_LENGTH)
{
Error("string exceeds 256 character limit");
return false;
}
strcpy(get, string);
return true;
}
int CInterpreter::GetIdentifier( CBlock *block )
{
CToken *token;
int type;
//FIXME: Should identifiers do this?
if ( MatchGet() )
{
if ( GetGet( block ) == false )
return false;
return true;
}
token = m_tokenizer->GetToken(0, 0);
type = token->GetType();
if ( type != TK_IDENTIFIER )
{
return Error("syntax error : expected indentifier; found %s", GetTokenName(type));
}
block->Write( TK_IDENTIFIER, (const char *) token->GetStringValue() );
token->Delete();
return true;
}
int CInterpreter::GetString( CBlock *block )
{
CToken *token;
int type;
//Look for a get
if ( MatchGet() )
{
return GetGet( block );
}
//Look for a random
if ( MatchRandom() )
{
return GetRandom( block );
}
token = m_tokenizer->GetToken(0, 0);
type = token->GetType();
if ( (type != TK_STRING) && (type != TK_CHAR) )
{
return Error("syntax error : expected string; found %s", GetTokenName(type));
}
//UGLY HACK!!!
const char *temptr;
char temp[1024];
temptr = token->GetStringValue();
if ( strlen(temptr)+1 > sizeof( temp ) )
{
return false;
}
for ( int i = 0; i < strlen( temptr ); i++ )
{
if ( temptr[i] == '#' )
temp[i] = '\n';
else
temp[i] = temptr[i];
}
temp[ strlen( temptr ) ] = 0;
//UGLY HACK END!!!
block->Write( TK_STRING, (const char *) &temp );
token->Delete();
return true;
}
static gint32
internal_get_token_name (gpointer token, gunichar2 ** uniname)
{
gint32 size = 0;
gchar *uname = GetTokenName ((uid_t) GPOINTER_TO_INT (token));
if (uname) {
size = strlen (uname);
*uniname = g_utf8_to_utf16 (uname, size, NULL, NULL, NULL);
g_free (uname);
}
return size;
}
void HLSLTokenizer::GetTokenName(char buffer[s_maxIdentifier]) const
{
if (m_token == HLSLToken_FloatLiteral)
{
sprintf(buffer, "%f", m_fValue);
}
else if (m_token == HLSLToken_IntLiteral)
{
sprintf(buffer, "%d", m_iValue);
}
else if (m_token == HLSLToken_Identifier)
{
strcpy(buffer, m_identifier);
}
else
{
GetTokenName(m_token, buffer);
}
}
MonoString*
ves_icall_System_Security_Principal_WindowsIdentity_GetTokenName (gpointer token)
{
MonoString *result = NULL;
gunichar2 *uniname = NULL;
gint32 size = 0;
#ifdef HOST_WIN32
MONO_ARCH_SAVE_REGS;
GetTokenInformation (token, TokenUser, NULL, size, (PDWORD)&size);
if (size > 0) {
TOKEN_USER *tu = g_malloc0 (size);
if (GetTokenInformation (token, TokenUser, tu, size, (PDWORD)&size)) {
uniname = GetSidName (NULL, tu->User.Sid, &size);
}
g_free (tu);
}
#else
gchar *uname = GetTokenName ((uid_t) GPOINTER_TO_INT (token));
MONO_ARCH_SAVE_REGS;
if (uname) {
size = strlen (uname);
uniname = g_utf8_to_utf16 (uname, size, NULL, NULL, NULL);
g_free (uname);
}
#endif /* HOST_WIN32 */
if (size > 0) {
result = mono_string_new_utf16 (mono_domain_get (), uniname, size);
}
else
result = mono_string_new (mono_domain_get (), "");
if (uniname)
g_free (uniname);
return result;
}
int CInterpreter::GetEvaluator( CBlock *block )
{
CToken *token;
int type;
if ( MatchGet() )
return false;
if ( MatchRandom() )
return false;
token = m_tokenizer->GetToken(0, 0);
type = token->GetType();
token->Delete();
switch ( type )
{
case TK_GREATER_THAN:
case TK_LESS_THAN:
case TK_EQUALS:
case TK_NOT:
break;
case TK_VECTOR_START:
type = TK_LESS_THAN;
break;
case TK_VECTOR_END:
type = TK_GREATER_THAN;
break;
default:
return Error("syntax error : expected operator type, found %s", GetTokenName( type ) );
}
block->Write( type, 0 );
return true;
}
int CInterpreter::GetFloat( CBlock *block )
{
CToken *token;
int type;
//Look for a get
if ( MatchGet() )
{
return GetGet( block );
}
//Look for a random
if ( MatchRandom() )
{
return GetRandom( block );
}
token = m_tokenizer->GetToken(0,0);
type = token->GetType();
//Floats can accept either int or float values
if ( ( type != TK_FLOAT ) && ( type != TK_INT ) )
{
return Error("syntax error : expected float; found %s", GetTokenName(type) );
}
if (type == TK_FLOAT)
{
block->Write( TK_FLOAT, (float) token->GetFloatValue() );
}
else
{
block->Write( TK_FLOAT, (float) token->GetIntValue() );
}
token->Delete();
return true;
}
/** Parse a menu item. */
MenuItem *ParseMenuItem(const TokenNode *start, Menu *menu, MenuItem *last)
{
Menu *child;
const char *value;
Assert(menu);
menu->offsets = NULL;
while(start) {
switch(start->type) {
case TOK_DYNAMIC:
last = InsertMenuItem(last);
if(!menu->items) {
menu->items = last;
}
value = FindAttribute(start->attributes, LABEL_ATTRIBUTE);
last->name = CopyString(value);
value = FindAttribute(start->attributes, ICON_ATTRIBUTE);
last->iconName = CopyString(value);
last->action.type = MA_DYNAMIC;
last->action.str = CopyString(start->value);
value = FindAttribute(start->attributes, HEIGHT_ATTRIBUTE);
if(value) {
last->action.value = ParseUnsigned(start, value);
} else {
last->action.value = menu->itemHeight;
}
break;
case TOK_MENU:
last = InsertMenuItem(last);
last->type = MENU_ITEM_SUBMENU;
if(!menu->items) {
menu->items = last;
}
value = FindAttribute(start->attributes, LABEL_ATTRIBUTE);
last->name = CopyString(value);
value = FindAttribute(start->attributes, ICON_ATTRIBUTE);
last->iconName = CopyString(value);
last->submenu = Allocate(sizeof(Menu));
child = last->submenu;
value = FindAttribute(start->attributes, HEIGHT_ATTRIBUTE);
if(value) {
child->itemHeight = ParseUnsigned(start, value);
} else {
child->itemHeight = menu->itemHeight;
}
value = FindAttribute(start->attributes, LABELED_ATTRIBUTE);
if(value && !strcmp(value, TRUE_VALUE)) {
if(last->name) {
child->label = CopyString(last->name);
} else {
child->label = CopyString(DEFAULT_TITLE);
}
} else {
child->label = NULL;
}
last->submenu->items = NULL;
ParseMenuItem(start->subnodeHead, last->submenu, NULL);
break;
case TOK_PROGRAM:
last = InsertMenuItem(last);
if(!menu->items) {
menu->items = last;
}
value = FindAttribute(start->attributes, LABEL_ATTRIBUTE);
if(value) {
last->name = CopyString(value);
} else if(start->value) {
last->name = CopyString(start->value);
}
value = FindAttribute(start->attributes, ICON_ATTRIBUTE);
last->iconName = CopyString(value);
last->action.type = MA_EXECUTE;
last->action.str = CopyString(start->value);
break;
case TOK_SEPARATOR:
last = InsertMenuItem(last);
last->type = MENU_ITEM_SEPARATOR;
if(!menu->items) {
menu->items = last;
}
break;
case TOK_INCLUDE:
last = ParseMenuInclude(start, menu, last);
break;
case TOK_DESKTOPS:
case TOK_STICK:
case TOK_MAXIMIZE:
case TOK_MINIMIZE:
case TOK_SHADE:
case TOK_MOVE:
case TOK_RESIZE:
case TOK_KILL:
case TOK_CLOSE:
case TOK_SENDTO:
last = InsertMenuItem(last);
if(!menu->items) {
menu->items = last;
}
value = FindAttribute(start->attributes, LABEL_ATTRIBUTE);
if(!value) {
value = GetTokenName(start);
}
last->name = CopyString(value);
value = FindAttribute(start->attributes, ICON_ATTRIBUTE);
last->iconName = CopyString(value);
switch(start->type) {
case TOK_DESKTOPS:
last->action.type = MA_DESKTOP_MENU;
break;
case TOK_STICK:
last->action.type = MA_STICK;
break;
case TOK_MAXIMIZE:
last->action.type = MA_MAXIMIZE;
break;
case TOK_MINIMIZE:
last->action.type = MA_MINIMIZE;
break;
case TOK_SHADE:
last->action.type = MA_SHADE;
break;
case TOK_MOVE:
last->action.type = MA_MOVE;
break;
case TOK_RESIZE:
last->action.type = MA_RESIZE;
break;
case TOK_KILL:
last->action.type = MA_KILL;
break;
case TOK_CLOSE:
last->action.type = MA_CLOSE;
break;
case TOK_SENDTO:
last->action.type = MA_SENDTO_MENU;
break;
default:
break;
}
break;
case TOK_EXIT:
last = InsertMenuItem(last);
if(!menu->items) {
menu->items = last;
}
value = FindAttribute(start->attributes, CONFIRM_ATTRIBUTE);
if(value && !strcmp(value, FALSE_VALUE)) {
settings.exitConfirmation = 0;
} else {
settings.exitConfirmation = 1;
}
value = FindAttribute(start->attributes, LABEL_ATTRIBUTE);
if(!value) {
value = GetTokenName(start);
}
last->name = CopyString(value);
value = FindAttribute(start->attributes, ICON_ATTRIBUTE);
last->iconName = CopyString(value);
last->action.type = MA_EXIT;
last->action.str = CopyString(start->value);
break;
case TOK_RESTART:
last = InsertMenuItem(last);
if(!menu->items) {
menu->items = last;
}
value = FindAttribute(start->attributes, LABEL_ATTRIBUTE);
if(!value) {
value = GetTokenName(start);
}
last->name = CopyString(value);
value = FindAttribute(start->attributes, ICON_ATTRIBUTE);
last->iconName = CopyString(value);
last->action.type = MA_RESTART;
break;
default:
InvalidTag(start, TOK_MENU);
break;
}
start = start->next;
}
return last;
}
/** Parse a token list. */
void Parse(const TokenNode *start, int depth)
{
TokenNode *tp;
if(!start) {
return;
}
if(JLIKELY(start->type == TOK_JWM)) {
for(tp = start->subnodeHead; tp; tp = tp->next) {
if(shouldReload) {
switch(tp->type) {
case TOK_ROOTMENU:
ParseRootMenu(tp);
break;
case TOK_INCLUDE:
ParseInclude(tp, depth);
break;
default:
break;
}
} else {
switch(tp->type) {
case TOK_DESKTOPS:
ParseDesktops(tp);
break;
case TOK_DOUBLECLICKSPEED:
settings.doubleClickSpeed = ParseUnsigned(tp, tp->value);
break;
case TOK_DOUBLECLICKDELTA:
settings.doubleClickDelta = ParseUnsigned(tp, tp->value);
break;
case TOK_FOCUSMODEL:
ParseFocusModel(tp);
break;
case TOK_GROUP:
ParseGroup(tp);
break;
case TOK_ICONPATH:
AddIconPath(tp->value);
break;
case TOK_INCLUDE:
ParseInclude(tp, depth);
break;
case TOK_KEY:
ParseKey(tp);
break;
case TOK_MENUSTYLE:
ParseMenuStyle(tp);
break;
case TOK_MOVEMODE:
ParseMoveMode(tp);
break;
case TOK_PAGERSTYLE:
ParsePagerStyle(tp);
break;
case TOK_POPUPSTYLE:
ParsePopupStyle(tp);
break;
case TOK_RESIZEMODE:
ParseResizeMode(tp);
break;
case TOK_RESTARTCOMMAND:
AddRestartCommand(tp->value);
break;
case TOK_ROOTMENU:
ParseRootMenu(tp);
break;
case TOK_SHUTDOWNCOMMAND:
AddShutdownCommand(tp->value);
break;
case TOK_SNAPMODE:
ParseSnapMode(tp);
break;
case TOK_STARTUPCOMMAND:
AddStartupCommand(tp->value);
break;
case TOK_TASKLISTSTYLE:
ParseTaskListStyle(tp);
break;
case TOK_TRAY:
ParseTray(tp);
break;
case TOK_TRAYSTYLE:
ParseTrayStyle(tp);
break;
case TOK_TRAYBUTTONSTYLE:
ParseTrayButtonStyle(tp);
break;
case TOK_CLOCKSTYLE:
ParseClockStyle(tp);
break;
case TOK_WINDOWSTYLE:
ParseWindowStyle(tp);
break;
case TOK_BUTTONCLOSE:
SetBorderIcon(BI_CLOSE, tp->value);
break;
case TOK_BUTTONMAX:
SetBorderIcon(BI_MAX, tp->value);
break;
case TOK_BUTTONMAXACTIVE:
SetBorderIcon(BI_MAX_ACTIVE, tp->value);
break;
case TOK_BUTTONMIN:
SetBorderIcon(BI_MIN, tp->value);
break;
default:
InvalidTag(tp, TOK_JWM);
break;
}
}
}
} else {
ParseError(start, "invalid start tag: %s", GetTokenName(start));
}
}
//
// This is the main loop.
//
void SmartCardMonitoringThread::Execute()
{
PK11SlotInfo *slot;
const char *tokenName = nsnull;
//
// populate token names for already inserted tokens.
//
PK11SlotList *sl =
PK11_FindSlotsByNames(mModule->dllName, nsnull, nsnull, true);
PK11SlotListElement *sle;
if (sl) {
for (sle=PK11_GetFirstSafe(sl); sle;
sle=PK11_GetNextSafe(sl,sle,false)) {
SetTokenName(PK11_GetSlotID(sle->slot),
PK11_GetTokenName(sle->slot), PK11_GetSlotSeries(sle->slot));
}
PK11_FreeSlotList(sl);
}
// loop starts..
do {
slot = SECMOD_WaitForAnyTokenEvent(mModule, 0, PR_SecondsToInterval(1) );
if (slot == nsnull) {
break;
}
// now we have a potential insertion or removal event, see if the slot
// is present to determine which it is...
if (PK11_IsPresent(slot)) {
// insertion
CK_SLOT_ID slotID = PK11_GetSlotID(slot);
PRUint32 series = PK11_GetSlotSeries(slot);
// skip spurious insertion events...
if (series != GetTokenSeries(slotID)) {
// if there's a token name, then we have not yet issued a remove
// event for the previous token, do so now...
tokenName = GetTokenName(slotID);
if (tokenName) {
SendEvent(NS_LITERAL_STRING(SMARTCARDEVENT_REMOVE), tokenName);
}
tokenName = PK11_GetTokenName(slot);
// save the token name and series
SetTokenName(slotID, tokenName, series);
SendEvent(NS_LITERAL_STRING(SMARTCARDEVENT_INSERT), tokenName);
}
} else {
// retrieve token name
CK_SLOT_ID slotID = PK11_GetSlotID(slot);
tokenName = GetTokenName(slotID);
// if there's not a token name, then the software isn't expecting
// a (or another) remove event.
if (tokenName) {
SendEvent(NS_LITERAL_STRING(SMARTCARDEVENT_REMOVE), tokenName);
// clear the token name (after we send it)
SetTokenName(slotID, nsnull, 0);
}
}
PK11_FreeSlot(slot);
} while (1);
}
// Original, primitive stack-based code generator
// DONE: test 32-bit code generation
void GenExpr0(void)
{
int i;
int gotUnary = 0;
int maxCallDepth = 0;
int callDepth = 0;
int paramOfs = 0;
for (i = 0; i < sp; i++)
if (stack[i][0] == '(')
{
if (++callDepth > maxCallDepth)
maxCallDepth = callDepth;
}
else if (stack[i][0] == ')')
{
callDepth--;
}
CanUseTempRegs = maxCallDepth == 0;
TempsUsed = 0;
for (i = 0; i < sp; i++)
{
int tok = stack[i][0];
int v = stack[i][1];
#ifndef NO_ANNOTATIONS
switch (tok)
{
case tokNumInt: printf2(" # %d\n", truncInt(v)); break;
case tokNumUint: printf2(" # %uu\n", truncUint(v)); break;
case tokIdent: printf2(" # %s\n", IdentTable + v); break;
case tokLocalOfs: printf2(" # local ofs\n"); break;
case ')': printf2(" # ) fxn call\n"); break;
case tokUnaryStar: printf2(" # * (read dereference)\n"); break;
case '=': printf2(" # = (write dereference)\n"); break;
case tokShortCirc: printf2(" # short-circuit "); break;
case tokGoto: printf2(" # sh-circ-goto "); break;
case tokLogAnd: printf2(" # short-circuit && target\n"); break;
case tokLogOr: printf2(" # short-circuit || target\n"); break;
case tokIf: case tokIfNot: break;
default: printf2(" # %s\n", GetTokenName(tok)); break;
}
#endif
switch (tok)
{
case tokNumInt:
case tokNumUint:
if (!(i + 1 < sp && (strchr("+-&^|", stack[i + 1][0]) ||
stack[i + 1][0] == tokLShift ||
stack[i + 1][0] == tokRShift ||
stack[i + 1][0] == tokURShift)))
{
if (gotUnary)
GenPushReg(MipsOpRegV0);
GenPrintInstr2Operands(MipsInstrLI, 0,
MipsOpRegV0, 0,
MipsOpConst, v);
}
gotUnary = 1;
break;
case tokIdent:
if (gotUnary)
GenPushReg(MipsOpRegV0);
if (!(i + 1 < sp && (stack[i + 1][0] == ')' ||
stack[i + 1][0] == tokUnaryStar ||
stack[i + 1][0] == tokInc ||
stack[i + 1][0] == tokDec ||
stack[i + 1][0] == tokPostInc ||
stack[i + 1][0] == tokPostDec)))
{
GenPrintInstr2Operands(MipsInstrLA, 0,
MipsOpRegV0, 0,
MipsOpLabel, v);
}
gotUnary = 1;
break;
case tokLocalOfs:
if (gotUnary)
GenPushReg(MipsOpRegV0);
if (!(i + 1 < sp && (stack[i + 1][0] == tokUnaryStar ||
stack[i + 1][0] == tokInc ||
stack[i + 1][0] == tokDec ||
stack[i + 1][0] == tokPostInc ||
stack[i + 1][0] == tokPostDec)))
{
GenPrintInstr3Operands(MipsInstrAddU, 0,
MipsOpRegV0, 0,
MipsOpRegFp, 0,
MipsOpConst, v);
}
gotUnary = 1;
break;
case '(':
if (gotUnary)
GenPushReg(MipsOpRegV0);
gotUnary = 0;
if (v < 16)
GenLocalAlloc(16 - v);
paramOfs = v - 4;
break;
case ',':
if (maxCallDepth == 1)
{
if (paramOfs == 16)
{
GenPushReg(MipsOpRegV0);
gotUnary = 0;
}
if (paramOfs >= 0 && paramOfs <= 12)
{
GenPrintInstr2Operands(MipsInstrMov, 0,
MipsOpRegA0 + paramOfs / 4, 0,
MipsOpRegV0, 0);
gotUnary = 0;
}
paramOfs -= 4;
}
break;
case ')':
if (maxCallDepth != 1)
{
if (v >= 4)
GenPrintInstr2Operands(MipsInstrLW, 0,
MipsOpRegA0, 0,
MipsOpIndRegSp, 0);
if (v >= 8)
GenPrintInstr2Operands(MipsInstrLW, 0,
MipsOpRegA1, 0,
MipsOpIndRegSp, 4);
if (v >= 12)
GenPrintInstr2Operands(MipsInstrLW, 0,
MipsOpRegA2, 0,
MipsOpIndRegSp, 8);
if (v >= 16)
GenPrintInstr2Operands(MipsInstrLW, 0,
MipsOpRegA3, 0,
MipsOpIndRegSp, 12);
}
else
{
int vv = v;
if (vv > 16)
vv = 16;
if (vv)
GenLocalAlloc(vv);
}
if (stack[i - 1][0] == tokIdent)
{
GenPrintInstr1Operand(MipsInstrJAL, 0,
MipsOpLabel, stack[i - 1][1]);
}
else
{
GenPrintInstr1Operand(MipsInstrJAL, 0,
MipsOpRegV0, 0);
}
if (v < 16)
v = 16;
GenLocalAlloc(-v);
break;
case tokUnaryStar:
if (stack[i - 1][0] == tokIdent)
GenReadIdent(MipsOpRegV0, v, stack[i - 1][1]);
else if (stack[i - 1][0] == tokLocalOfs)
GenReadLocal(MipsOpRegV0, v, stack[i - 1][1]);
else
GenReadIndirect(MipsOpRegV0, MipsOpRegV0, v);
break;
case tokUnaryPlus:
break;
case '~':
GenPrintInstr3Operands(MipsInstrNor, 0,
MipsOpRegV0, 0,
MipsOpRegV0, 0,
MipsOpRegV0, 0);
break;
case tokUnaryMinus:
GenPrintInstr3Operands(MipsInstrSubU, 0,
MipsOpRegV0, 0,
MipsOpRegZero, 0,
MipsOpRegV0, 0);
break;
case '+':
case '-':
case '*':
case '&':
case '^':
case '|':
case tokLShift:
case tokRShift:
case tokURShift:
if ((stack[i - 1][0] == tokNumInt || stack[i - 1][0] == tokNumUint) && tok != '*')
{
int instr = GenGetBinaryOperatorInstr(tok);
GenPrintInstr3Operands(instr, 0,
MipsOpRegV0, 0,
MipsOpRegV0, 0,
MipsOpConst, stack[i - 1][1]);
}
else
{
int instr = GenGetBinaryOperatorInstr(tok);
int reg = GenPopReg(MipsOpRegT0);
GenPrintInstr3Operands(instr, 0,
MipsOpRegV0, 0,
reg, 0,
MipsOpRegV0, 0);
}
break;
case '/':
case tokUDiv:
case '%':
case tokUMod:
{
int reg = GenPopReg(MipsOpRegT0);
if (tok == '/' || tok == '%')
GenPrintInstr2Operands(MipsInstrDiv, 0,
reg, 0,
MipsOpRegV0, 0);
else
GenPrintInstr2Operands(MipsInstrDivU, 0,
reg, 0,
MipsOpRegV0, 0);
if (tok == '%' || tok == tokUMod)
GenPrintInstr1Operand(MipsInstrMfHi, 0,
MipsOpRegV0, 0);
else
GenPrintInstr1Operand(MipsInstrMfLo, 0,
MipsOpRegV0, 0);
}
break;
case tokInc:
case tokDec:
if (stack[i - 1][0] == tokIdent)
{
GenIncDecIdent(MipsOpRegV0, v, stack[i - 1][1], tok);
}
else if (stack[i - 1][0] == tokLocalOfs)
{
GenIncDecLocal(MipsOpRegV0, v, stack[i - 1][1], tok);
}
else
{
GenPrintInstr2Operands(MipsInstrMov, 0,
MipsOpRegT0, 0,
MipsOpRegV0, 0);
GenIncDecIndirect(MipsOpRegV0, MipsOpRegT0, v, tok);
}
break;
case tokPostInc:
case tokPostDec:
if (stack[i - 1][0] == tokIdent)
{
GenPostIncDecIdent(MipsOpRegV0, v, stack[i - 1][1], tok);
}
else if (stack[i - 1][0] == tokLocalOfs)
{
GenPostIncDecLocal(MipsOpRegV0, v, stack[i - 1][1], tok);
}
else
{
GenPrintInstr2Operands(MipsInstrMov, 0,
MipsOpRegT0, 0,
MipsOpRegV0, 0);
GenPostIncDecIndirect(MipsOpRegV0, MipsOpRegT0, v, tok);
}
break;
case tokPostAdd:
case tokPostSub:
{
int instr = GenGetBinaryOperatorInstr(tok);
int reg = GenPopReg(MipsOpRegT0);
GenPrintInstr2Operands(MipsInstrMov, 0,
MipsOpRegT1, 0,
MipsOpRegV0, 0);
GenReadIndirect(MipsOpRegV0, reg, v);
GenPrintInstr3Operands(instr, 0,
MipsOpRegT1, 0,
MipsOpRegT1, 0,
MipsOpRegV0, 0);
GenWriteIndirect(reg, MipsOpRegT1, v);
}
break;
case tokAssignAdd:
case tokAssignSub:
case tokAssignMul:
case tokAssignAnd:
case tokAssignXor:
case tokAssignOr:
case tokAssignLSh:
case tokAssignRSh:
case tokAssignURSh:
{
int instr = GenGetBinaryOperatorInstr(tok);
int reg = GenPopReg(MipsOpRegT0);
GenPrintInstr2Operands(MipsInstrMov, 0,
MipsOpRegT1, 0,
MipsOpRegV0, 0);
GenReadIndirect(MipsOpRegV0, reg, v);
GenPrintInstr3Operands(instr, 0,
MipsOpRegV0, 0,
MipsOpRegV0, 0,
MipsOpRegT1, 0);
GenWriteIndirect(reg, MipsOpRegV0, v);
GenExtendRegIfNeeded(MipsOpRegV0, v);
}
break;
case tokAssignDiv:
case tokAssignUDiv:
case tokAssignMod:
case tokAssignUMod:
{
int reg = GenPopReg(MipsOpRegT0);
GenReadIndirect(MipsOpRegT1, reg, v);
if (tok == tokAssignDiv || tok == tokAssignMod)
GenPrintInstr2Operands(MipsInstrDiv, 0,
MipsOpRegT1, 0,
MipsOpRegV0, 0);
else
GenPrintInstr2Operands(MipsInstrDivU, 0,
MipsOpRegT1, 0,
MipsOpRegV0, 0);
if (tok == tokAssignMod || tok == tokAssignUMod)
GenPrintInstr1Operand(MipsInstrMfHi, 0,
MipsOpRegV0, 0);
else
GenPrintInstr1Operand(MipsInstrMfLo, 0,
MipsOpRegV0, 0);
GenWriteIndirect(reg, MipsOpRegV0, v);
GenExtendRegIfNeeded(MipsOpRegV0, v);
}
break;
case '=':
{
int reg = GenPopReg(MipsOpRegT0);
GenWriteIndirect(reg, MipsOpRegV0, v);
GenExtendRegIfNeeded(MipsOpRegV0, v);
}
break;
/*
i = il < ir; // i = slt(il, ir);
i = il <= ir; // i = slt(ir, il) ^ 1;
i = il > ir; // i = slt(ir, il);
i = il >= ir; // i = slt(il, ir) ^ 1;
i = il == ir; // i = sltu(il ^ ir, 1);
i = il != ir; // i = sltu(0, il ^ ir);
*/
case '<':
{
int reg = GenPopReg(MipsOpRegT0);
GenPrintInstr3Operands(MipsInstrSLT, 0,
MipsOpRegV0, 0,
reg, 0,
MipsOpRegV0, 0);
}
break;
case tokULess:
{
int reg = GenPopReg(MipsOpRegT0);
GenPrintInstr3Operands(MipsInstrSLTU, 0,
MipsOpRegV0, 0,
reg, 0,
MipsOpRegV0, 0);
}
break;
case '>':
{
int reg = GenPopReg(MipsOpRegT0);
GenPrintInstr3Operands(MipsInstrSLT, 0,
MipsOpRegV0, 0,
MipsOpRegV0, 0,
reg, 0);
}
break;
case tokUGreater:
{
int reg = GenPopReg(MipsOpRegT0);
GenPrintInstr3Operands(MipsInstrSLTU, 0,
MipsOpRegV0, 0,
MipsOpRegV0, 0,
reg, 0);
}
break;
case tokLEQ:
{
int reg = GenPopReg(MipsOpRegT0);
GenPrintInstr3Operands(MipsInstrSLT, 0,
MipsOpRegV0, 0,
MipsOpRegV0, 0,
reg, 0);
GenPrintInstr3Operands(MipsInstrXor, 0,
MipsOpRegV0, 0,
MipsOpRegV0, 0,
MipsOpConst, 1);
}
break;
case tokULEQ:
{
int reg = GenPopReg(MipsOpRegT0);
GenPrintInstr3Operands(MipsInstrSLTU, 0,
MipsOpRegV0, 0,
MipsOpRegV0, 0,
reg, 0);
GenPrintInstr3Operands(MipsInstrXor, 0,
MipsOpRegV0, 0,
MipsOpRegV0, 0,
MipsOpConst, 1);
}
break;
case tokGEQ:
{
int reg = GenPopReg(MipsOpRegT0);
GenPrintInstr3Operands(MipsInstrSLT, 0,
MipsOpRegV0, 0,
reg, 0,
MipsOpRegV0, 0);
GenPrintInstr3Operands(MipsInstrXor, 0,
MipsOpRegV0, 0,
MipsOpRegV0, 0,
MipsOpConst, 1);
}
break;
case tokUGEQ:
{
int reg = GenPopReg(MipsOpRegT0);
GenPrintInstr3Operands(MipsInstrSLTU, 0,
MipsOpRegV0, 0,
reg, 0,
MipsOpRegV0, 0);
GenPrintInstr3Operands(MipsInstrXor, 0,
MipsOpRegV0, 0,
MipsOpRegV0, 0,
MipsOpConst, 1);
}
break;
case tokEQ:
{
int reg = GenPopReg(MipsOpRegT0);
GenPrintInstr3Operands(MipsInstrXor, 0,
MipsOpRegV0, 0,
reg, 0,
MipsOpRegV0, 0);
GenPrintInstr3Operands(MipsInstrSLTU, 0,
MipsOpRegV0, 0,
MipsOpRegV0, 0,
MipsOpConst, 1);
}
break;
case tokNEQ:
{
int reg = GenPopReg(MipsOpRegT0);
GenPrintInstr3Operands(MipsInstrXor, 0,
MipsOpRegV0, 0,
reg, 0,
MipsOpRegV0, 0);
GenPrintInstr3Operands(MipsInstrSLTU, 0,
MipsOpRegV0, 0,
MipsOpRegZero, 0,
MipsOpRegV0, 0);
}
break;
case tok_Bool:
GenPrintInstr3Operands(MipsInstrSLTU, 0,
MipsOpRegV0, 0,
MipsOpRegZero, 0,
MipsOpRegV0, 0);
break;
case tokSChar:
GenPrintInstr3Operands(MipsInstrSLL, 0,
MipsOpRegV0, 0,
MipsOpRegV0, 0,
MipsOpConst, 24);
GenPrintInstr3Operands(MipsInstrSRA, 0,
MipsOpRegV0, 0,
MipsOpRegV0, 0,
MipsOpConst, 24);
break;
case tokUChar:
GenPrintInstr3Operands(MipsInstrAnd, 0,
MipsOpRegV0, 0,
MipsOpRegV0, 0,
MipsOpConst, 0xFF);
break;
case tokShort:
GenPrintInstr3Operands(MipsInstrSLL, 0,
MipsOpRegV0, 0,
MipsOpRegV0, 0,
MipsOpConst, 16);
GenPrintInstr3Operands(MipsInstrSRA, 0,
MipsOpRegV0, 0,
MipsOpRegV0, 0,
MipsOpConst, 16);
break;
case tokUShort:
GenPrintInstr3Operands(MipsInstrAnd, 0,
MipsOpRegV0, 0,
MipsOpRegV0, 0,
MipsOpConst, 0xFFFF);
break;
case tokShortCirc:
#ifndef NO_ANNOTATIONS
if (v >= 0)
printf2("&&\n");
else
printf2("||\n");
#endif
if (v >= 0)
GenJumpIfZero(v); // &&
else
GenJumpIfNotZero(-v); // ||
gotUnary = 0;
break;
case tokGoto:
#ifndef NO_ANNOTATIONS
printf2("goto\n");
#endif
GenJumpUncond(v);
gotUnary = 0;
break;
case tokLogAnd:
case tokLogOr:
GenNumLabel(v);
break;
case tokVoid:
gotUnary = 0;
break;
case tokComma:
break;
case tokIf:
GenJumpIfNotZero(stack[i][1]);
break;
case tokIfNot:
GenJumpIfZero(stack[i][1]);
break;
default:
//error("Error: Internal Error: GenExpr0(): unexpected token %s\n", GetTokenName(tok));
errorInternal(102);
break;
}
}
}
/** Tokenize a data. */
TokenNode *Tokenize(const char *line, const char *fileName) {
TokenNode *np;
AttributeNode *ap;
char *temp;
int inElement;
int x;
int found;
int lineNumber;
head = NULL;
current = NULL;
inElement = 0;
lineNumber = 1;
x = 0;
/* Skip any initial white space */
while(IsSpace(line[x], &lineNumber)) ++x;
/* Skip any XML stuff */
if(!strncmp(line + x, "<?", 2)) {
while(line[x]) {
if(line[x] == '\n') {
++lineNumber;
}
if(!strncmp(line + x, "?>", 2)) {
x += 2;
break;
}
++x;
}
}
while(line[x]) {
do {
while(IsSpace(line[x], &lineNumber)) ++x;
/* Skip comments */
found = 0;
if(!strncmp(line + x, "<!--", 4)) {
while(line[x]) {
if(line[x] == '\n') {
++lineNumber;
}
if(!strncmp(line + x, "-->", 3)) {
x += 3;
found = 1;
break;
}
++x;
}
}
} while(found);
switch(line[x]) {
case '<':
++x;
if(line[x] == '/') {
++x;
temp = ReadElementName(line + x);
if(current) {
if(temp) {
if(current->type != LookupType(temp, NULL)) {
Warning("%s[%d]: close tag \"%s\" does not "
"match open tag \"%s\"",
fileName, lineNumber, temp,
GetTokenName(current));
}
} else {
Warning("%s[%d]: unexpected and invalid close tag",
fileName, lineNumber);
}
current = current->parent;
} else {
if(temp) {
Warning("%s[%d]: close tag \"%s\" without open "
"tag", fileName, lineNumber, temp);
} else {
Warning("%s[%d]: invalid close tag", fileName, lineNumber);
}
}
if(temp) {
x += strlen(temp);
Release(temp);
}
} else {
np = current;
current = NULL;
np = CreateNode(np, fileName, lineNumber);
temp = ReadElementName(line + x);
if(temp) {
x += strlen(temp);
LookupType(temp, np);
Release(temp);
} else {
Warning("%s[%d]: invalid open tag", fileName, lineNumber);
}
}
inElement = 1;
break;
case '/':
if(inElement) {
++x;
if(line[x] == '>' && current) {
++x;
current = current->parent;
inElement = 0;
} else {
Warning("%s[%d]: invalid tag", fileName, lineNumber);
}
} else {
goto ReadDefault;
}
break;
case '>':
++x;
inElement = 0;
break;
default:
ReadDefault:
if(inElement) {
ap = CreateAttribute(current);
ap->name = ReadElementName(line + x);
if(ap->name) {
x += strlen(ap->name);
if(line[x] == '=') {
++x;
}
if(line[x] == '\"') {
++x;
}
ap->value = ReadAttributeValue(line + x, fileName,
&lineNumber);
if(ap->value) {
x += strlen(ap->value);
}
if(line[x] == '\"') {
++x;
}
}
} else {
temp = ReadElementValue(line + x, fileName, &lineNumber);
if(temp) {
x += strlen(temp);
if(current) {
if(current->value) {
current->value = Reallocate(current->value,
strlen(current->value) + strlen(temp) + 1);
strcat(current->value, temp);
Release(temp);
} else {
current->value = temp;
}
} else {
if(temp[0]) {
Warning("%s[%d]: unexpected text: \"%s\"",
fileName, lineNumber, temp);
}
Release(temp);
}
}
}
break;
}
}
return head;
}
/** Tokenize data. */
TokenNode *Tokenize(const char *line, const char *fileName)
{
AttributeNode *ap;
TokenNode *current;
char *temp;
unsigned int x;
unsigned int offset;
unsigned int lineNumber;
char inElement;
char found;
head = NULL;
current = NULL;
inElement = 0;
lineNumber = 1;
x = 0;
/* Skip any initial white space. */
while(IsSpace(line[x], &lineNumber)) {
x += 1;
}
/* Skip any XML stuff. */
if(!strncmp(line + x, "<?", 2)) {
while(line[x]) {
if(line[x] == '\n') {
lineNumber += 1;
}
if(!strncmp(line + x, "?>", 2)) {
x += 2;
break;
}
x += 1;
}
}
/* Process the XML data. */
while(line[x]) {
/* Skip comments and white space. */
do {
/* Skip white space. */
while(IsSpace(line[x], &lineNumber)) {
x += 1;
}
/* Skip comments */
found = 0;
if(!strncmp(line + x, "<!--", 4)) {
while(line[x]) {
if(line[x] == '\n') {
lineNumber += 1;
}
if(!strncmp(line + x, "-->", 3)) {
x += 3;
found = 1;
break;
}
x += 1;
}
}
} while(found);
switch(line[x]) {
case '<':
x += 1;
if(line[x] == '/') {
/* Close tag. */
x += 1;
temp = ReadElementName(line + x);
if(current) {
if(JLIKELY(temp)) {
if(JUNLIKELY(current->type != LookupType(temp, NULL))) {
Warning(_("%s[%u]: close tag \"%s\" does not "
"match open tag \"%s\""),
fileName, lineNumber, temp,
GetTokenName(current));
}
} else {
Warning(_("%s[%u]: unexpected and invalid close tag"),
fileName, lineNumber);
}
current = current->parent;
} else {
if(temp) {
Warning(_("%s[%u]: close tag \"%s\" without open tag"),
fileName, lineNumber, temp);
} else {
Warning(_("%s[%u]: invalid close tag"), fileName, lineNumber);
}
}
if(temp) {
x += strlen(temp);
Release(temp);
}
} else {
/* Open tag. */
current = CreateNode(current, fileName, lineNumber);
temp = ReadElementName(line + x);
if(JLIKELY(temp)) {
x += strlen(temp);
LookupType(temp, current);
Release(temp);
} else {
Warning(_("%s[%u]: invalid open tag"), fileName, lineNumber);
}
}
inElement = 1;
break;
case '/':
/* End of open/close tag. */
if(inElement) {
x += 1;
if(JLIKELY(line[x] == '>' && current)) {
x += 1;
current = current->parent;
inElement = 0;
} else {
Warning(_("%s[%u]: invalid tag"), fileName, lineNumber);
}
} else {
goto ReadDefault;
}
break;
case '>':
/* End of open tag. */
x += 1;
inElement = 0;
break;
default:
ReadDefault:
if(inElement) {
/* In the open tag; read attributes. */
ap = CreateAttribute(current);
ap->name = ReadElementName(line + x);
if(ap->name) {
x += strlen(ap->name);
if(line[x] == '=') {
x += 1;
}
if(line[x] == '\"') {
x += 1;
}
ap->value = ReadAttributeValue(line + x, fileName,
&offset, &lineNumber);
x += offset;
if(line[x] == '\"') {
x += 1;
}
}
} else {
/* In tag body; read text. */
temp = ReadElementValue(line + x, fileName, &offset, &lineNumber);
x += offset;
if(temp) {
if(current) {
if(current->value) {
current->value = Reallocate(current->value,
strlen(current->value) +
strlen(temp) + 1);
strcat(current->value, temp);
Release(temp);
} else {
current->value = temp;
}
} else {
if(JUNLIKELY(temp[0])) {
Warning(_("%s[%u]: unexpected text: \"%s\""),
fileName, lineNumber, temp);
}
Release(temp);
}
}
}
break;
}
}
return head;
}
nsresult
nsNSSCertificate::FormatUIStrings(const nsAutoString &nickname, nsAutoString &nickWithSerial, nsAutoString &details)
{
if (!NS_IsMainThread()) {
NS_ERROR("nsNSSCertificate::FormatUIStrings called off the main thread");
return NS_ERROR_NOT_SAME_THREAD;
}
nsresult rv = NS_OK;
nsCOMPtr<nsINSSComponent> nssComponent(do_GetService(kNSSComponentCID, &rv));
if (NS_FAILED(rv) || !nssComponent) {
return NS_ERROR_FAILURE;
}
nsAutoString info;
nsAutoString temp1;
nickWithSerial.Append(nickname);
if (NS_SUCCEEDED(nssComponent->GetPIPNSSBundleString("CertInfoIssuedFor", info))) {
details.Append(info);
details.Append(PRUnichar(' '));
if (NS_SUCCEEDED(GetSubjectName(temp1)) && !temp1.IsEmpty()) {
details.Append(temp1);
}
details.Append(PRUnichar('\n'));
}
if (NS_SUCCEEDED(GetSerialNumber(temp1)) && !temp1.IsEmpty()) {
details.AppendLiteral(" ");
if (NS_SUCCEEDED(nssComponent->GetPIPNSSBundleString("CertDumpSerialNo", info))) {
details.Append(info);
details.AppendLiteral(": ");
}
details.Append(temp1);
nickWithSerial.AppendLiteral(" [");
nickWithSerial.Append(temp1);
nickWithSerial.Append(PRUnichar(']'));
details.Append(PRUnichar('\n'));
}
nsCOMPtr<nsIX509CertValidity> validity;
rv = GetValidity(getter_AddRefs(validity));
if (NS_SUCCEEDED(rv) && validity) {
details.AppendLiteral(" ");
if (NS_SUCCEEDED(nssComponent->GetPIPNSSBundleString("CertInfoValid", info))) {
details.Append(info);
}
if (NS_SUCCEEDED(validity->GetNotBeforeLocalTime(temp1)) && !temp1.IsEmpty()) {
details.Append(PRUnichar(' '));
if (NS_SUCCEEDED(nssComponent->GetPIPNSSBundleString("CertInfoFrom", info))) {
details.Append(info);
details.Append(PRUnichar(' '));
}
details.Append(temp1);
}
if (NS_SUCCEEDED(validity->GetNotAfterLocalTime(temp1)) && !temp1.IsEmpty()) {
details.Append(PRUnichar(' '));
if (NS_SUCCEEDED(nssComponent->GetPIPNSSBundleString("CertInfoTo", info))) {
details.Append(info);
details.Append(PRUnichar(' '));
}
details.Append(temp1);
}
details.Append(PRUnichar('\n'));
}
if (NS_SUCCEEDED(GetKeyUsagesString(mCert, nssComponent, temp1)) && !temp1.IsEmpty()) {
details.AppendLiteral(" ");
if (NS_SUCCEEDED(nssComponent->GetPIPNSSBundleString("CertDumpKeyUsage", info))) {
details.Append(info);
details.AppendLiteral(": ");
}
details.Append(temp1);
details.Append(PRUnichar('\n'));
}
nsAutoString firstEmail;
const char *aWalkAddr;
for (aWalkAddr = CERT_GetFirstEmailAddress(mCert)
;
aWalkAddr
;
aWalkAddr = CERT_GetNextEmailAddress(mCert, aWalkAddr))
{
NS_ConvertUTF8toUTF16 email(aWalkAddr);
if (email.IsEmpty())
continue;
if (firstEmail.IsEmpty()) {
/*
* If the first email address from the subject DN is also present
* in the subjectAltName extension, GetEmailAddresses() will return
* it twice (as received from NSS). Remember the first address so that
* we can filter out duplicates later on.
*/
firstEmail = email;
details.AppendLiteral(" ");
if (NS_SUCCEEDED(nssComponent->GetPIPNSSBundleString("CertInfoEmail", info))) {
details.Append(info);
details.AppendLiteral(": ");
}
details.Append(email);
}
else {
// Append current address if it's different from the first one.
if (!firstEmail.Equals(email)) {
details.AppendLiteral(", ");
details.Append(email);
}
}
}
if (!firstEmail.IsEmpty()) {
// We got at least one email address, so we want a newline
details.Append(PRUnichar('\n'));
}
if (NS_SUCCEEDED(nssComponent->GetPIPNSSBundleString("CertInfoIssuedBy", info))) {
details.Append(info);
details.Append(PRUnichar(' '));
if (NS_SUCCEEDED(GetIssuerName(temp1)) && !temp1.IsEmpty()) {
details.Append(temp1);
}
details.Append(PRUnichar('\n'));
}
if (NS_SUCCEEDED(nssComponent->GetPIPNSSBundleString("CertInfoStoredIn", info))) {
details.Append(info);
details.Append(PRUnichar(' '));
if (NS_SUCCEEDED(GetTokenName(temp1)) && !temp1.IsEmpty()) {
details.Append(temp1);
}
}
/*
the above produces the following output:
Issued to: $subjectName
Serial number: $serialNumber
Valid from: $starting_date to $expiration_date
Certificate Key usage: $usages
Email: $address(es)
Issued by: $issuerName
Stored in: $token
*/
return rv;
}
