id
stringlengths 36
36
| text
stringlengths 1
1.25M
|
|---|---|
ec31d6de-ed64-4f08-a189-b5e4c368e231 | public crmondemand.xml.opportunity.query.QueryType getCustomPickList69() {
return this.customPickList69;
} |
b7f71c57-b85c-4497-908e-7a241800d467 | public java.lang.String getCustomText86() {
return this.customText86;
} |
6ea57a4a-695d-44cc-859d-8b5a7b3a81f7 | public crmondemand.xml.customobject6.query.QueryType getCustomNumber30() {
return this.customNumber30;
} |
57db3283-2d68-4721-8c20-3fc3744e3d92 | public abstract String genererCle(); |
64905e29-9ab1-4b92-8078-34b59d840a3c | public void setContactFirstName(crmondemand.xml.contact.query.QueryType contactFirstName) {
this.contactFirstName = contactFirstName;
} |
3b2c38be-7c46-4098-8a7d-e1a893e1edea | public V put(K key, V val); |
bfaa8137-933e-4c8c-9a23-2bde86177f73 | public void setAssetId(crmondemand.xml.opportunity.query.QueryType assetId) {
this.assetId = assetId;
} |
7ec0282c-75eb-4dd7-a383-12f80cd58a78 | public crmondemand.xml.opportunity.query.QueryType getCustomObject7Type() {
return this.customObject7Type;
} |
4cdde2d6-da89-472c-9206-8b2333357a43 | public ModifierContext modifier(int i) {
return getRuleContext(ModifierContext.class,i);
} |
9c4462fb-cae0-4bf0-a120-3c095cc77ca3 | @Override
public String fillAreasVectorFromXML(String buf, List<List<XMLTag>> areas, List<CMObject> custom, Map<String,String> externalFiles)
{
final List<XMLLibrary.XMLTag> xml=CMLib.xml().parseAllXML(buf);
if(xml==null)
return unpackErr("Areas","null 'xml'");
fillCustomVectorFromXML(xml,custom,externalFiles);
final List<XMLLibrary.XMLTag> aV=CMLib.xml().getContentsFromPieces(xml,"AREAS");
if(aV==null)
return unpackErr("Areas","null 'AREAS'",xml);
for(int r=0;r<aV.size();r++)
{
final XMLTag ablk=aV.get(r);
if((!ablk.tag().equalsIgnoreCase("AREA"))||(ablk.contents()==null))
return unpackErr("Areas","??"+ablk.tag(),ablk);
areas.add(ablk.contents());
}
return "";
} |
948a0bf1-9c2e-4260-bc24-80dc9ba16e03 | public void setCustomBoolean27(java.lang.Boolean customBoolean27) {
this.customBoolean27 = customBoolean27;
} |
5414f178-b9fd-4a25-9954-7f2a35d086b3 | public void setCustomBoolean9(java.lang.Boolean customBoolean9) {
this.customBoolean9 = customBoolean9;
} |
425b9577-536d-439a-9c0f-e8709d508116 | public void draw(Graphics g){
g.drawImage(sprite, abspx_xPos - Game.window().screen().px_xOffset(), abspx_yPos - Game.window().screen().px_yOffset(), null);
} |
02d740fe-efff-4c2f-aa03-49d530ac6d37 | public java.lang.String getCustomPickList14() {
return this.customPickList14;
} |
9c3b335a-444e-4a31-a93e-0adb75b90b7e | public void setCustomPickList51(java.lang.String customPickList51) {
this.customPickList51 = customPickList51;
} |
a878503f-e5e4-4725-b745-2f8d8291f46b | public void setCustomPickList152(crmondemand.xml.customobject6.query.QueryType customPickList152) {
this.customPickList152 = customPickList152;
} |
3cefbcd2-7c77-4b1d-8df6-01c937f35e09 | public crmondemand.xml.opportunity.query.QueryType getCustomDate25() {
return this.customDate25;
} |
23d10f04-713f-4c18-a4a5-ce663202526f | public void setCustomDate57(java.util.Calendar customDate57) {
this.customDate57 = customDate57;
} |
31924ed1-7558-4efb-a313-35540c465fdf | public void setZCustomDate11(java.util.Calendar zCustomDate11) {
this.zCustomDate11 = zCustomDate11;
} |
ba83a264-e422-4755-8a88-be8b423659d4 | public Object getFieldValue(_Fields field) {
switch (field) {
case SUCCESS:
return getSuccess();
}
throw new IllegalStateException();
} |
5c7d3e3b-8784-40bc-aaed-041f559ee69a | public void setServiceRequestId(java.lang.String serviceRequestId) {
this.serviceRequestId = serviceRequestId;
} |
5f571d7a-8aa2-4547-8427-1ded143cc2af | public void setCustomNumber34(java.math.BigDecimal customNumber34) {
this.customNumber34 = customNumber34;
} |
93e63073-897d-467f-bb03-649ce1e10530 | public void setCustomText4(java.lang.String customText4) {
this.customText4 = customText4;
} |
a33381fd-e24b-41a4-bc51-1ff79f3b4189 | private boolean isStraight(List<Card> cards) {
if (valueIncreasesByOne(cards, 0)) {
return true;
}
/* Since ace has value one when sorting, we need to check the
* broadway straight A-K-Q-J-T separately
*/
if (cards.get(0).getRank() == Rank.ACE && cards.get(1).getRank() == Rank.TEN) {
return valueIncreasesByOne(cards, 1);
}
return false;
} |
0cb3dd17-f097-4181-8b08-b5ac511b5363 | public void setCustomText32(java.lang.String customText32) {
this.customText32 = customText32;
} |
428ee9d6-e7c2-40cc-bbb1-559aa847feba | public static void pprintAtomicObject(Stella_Object self, org.powerloom.PrintableStringWriter stream) {
if (!(self == null)) {
{ Surrogate testValue000 = Stella_Object.safePrimaryType(self);
if (Surrogate.subtypeOfP(testValue000, OntosaurusUtil.SGT_STELLA_LITERAL_WRAPPER)) {
{ LiteralWrapper self000 = ((LiteralWrapper)(self));
OntosaurusUtil.pprintLiteralWrapper(self000, stream);
}
}
else if (Surrogate.subtypeOfP(testValue000, OntosaurusUtil.SGT_LOGIC_PATTERN_VARIABLE)) {
{ PatternVariable self000 = ((PatternVariable)(self));
if ((((KeyValueMap)(Logic.$SKOLEMNAMEMAPPINGTABLE$.get())) != null) &&
(((Skolem)(((KeyValueMap)(Logic.$SKOLEMNAMEMAPPINGTABLE$.get())).lookup(self000))) != null)) {
stream.print(PatternVariable.generateNameOfVariable(((PatternVariable)(((Skolem)(((KeyValueMap)(Logic.$SKOLEMNAMEMAPPINGTABLE$.get())).lookup(self000)))))));
}
else if ((((Justification)(Logic.$CURRENTJUSTIFICATION$.get())) != null) &&
(Logic.justificationArgumentBoundTo(self000, null) != null)) {
OntosaurusUtil.pprintObject(Logic.justificationArgumentBoundTo(self000, null), stream);
}
else {
stream.print(PatternVariable.generateNameOfVariable(self000));
}
}
}
else if (Surrogate.subtypeOfP(testValue000, OntosaurusUtil.SGT_LOGIC_SKOLEM)) {
{ Skolem self000 = ((Skolem)(self));
if (Logic.nativeValueOf(self000) != null) {
OntosaurusUtil.pprintAtomicObject(Logic.nativeValueOf(self000), stream);
}
else if (Logic.innermostOf(self000) != null) {
stream.print(Native.stringDowncase(Skolem.getSkolemPrintName(self000)));
if (!(Logic.innermostOf(self000) == self000)) {
stream.print(Logic.VALUE_OF_SEPARATOR);
OntosaurusUtil.pprintObject(Logic.innermostOf(self000), stream);
}
else if (self000.definingProposition != null) {
stream.print(Logic.VALUE_OF_SEPARATOR);
OntosaurusUtil.pprintFunctionTerm(self000.definingProposition, stream);
}
else {
}
}
else {
stream.print(Skolem.generateSkolem(self000));
}
}
}
else if (Surrogate.subtypeOfP(testValue000, OntosaurusUtil.SGT_LOGIC_LOGIC_OBJECT)) {
{ LogicObject self000 = ((LogicObject)(self));
if (self000.surrogateValueInverse != null) {
stream.print(Surrogate.surrogateToSymbol(self000.surrogateValueInverse));
}
else {
stream.print("Unamed_Object");
}
}
}
else if (Surrogate.subtypeOfSurrogateP(testValue000)) {
{ Surrogate self000 = ((Surrogate)(self));
stream.print(OntosaurusUtil.operatorToString(self000));
}
}
else if (Surrogate.subtypeOfP(testValue000, OntosaurusUtil.SGT_LOGIC_LOGIC_THING)) {
{ LogicThing self000 = ((LogicThing)(self));
if (Logic.generateTerm(self000) != null) {
OntosaurusUtil.pprintObject(Logic.generateTerm(self000), stream);
}
else if (self000.surrogateValueInverse != null) {
stream.print(self000.surrogateValueInverse);
}
else {
stream.print(self000);
}
}
}
else if (Surrogate.subtypeOfP(testValue000, OntosaurusUtil.SGT_STELLA_THING)) {
{ Thing self000 = ((Thing)(self));
if (self000.surrogateValueInverse != null) {
stream.print(self000.surrogateValueInverse);
}
else {
stream.print(self000);
}
}
}
else {
stream.print(self);
}
}
}
} |
0f542776-0791-451f-a6b3-5c2713217e58 | public void setCustomText34(java.lang.String customText34) {
this.customText34 = customText34;
} |
7cd259c7-0915-404c-873b-d7a58b9d9d56 | public static void main(String[] args)
{
new Announcement(
"Player 1 probably wants to do something with his life other than cry about it");
} |
3125423b-781d-4306-940f-a8f30d110a06 | public void setCustomText18(crmondemand.xml.opportunity.query.QueryType customText18) {
this.customText18 = customText18;
} |
1d463ac0-51ef-487b-ad24-91e9de3a2d3c | public crmondemand.xml.customobject6.query.QueryType getObjectiveStatus() {
return this.objectiveStatus;
} |
ecaa1c61-4283-48c4-acad-2fae60ac05d3 | public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); } |
c20980d7-b9b9-4295-a1ca-271841407f00 | public void setCustomDate27(crmondemand.xml.contact.query.QueryType customDate27) {
this.customDate27 = customDate27;
} |
a529e3a8-7d6f-4483-a442-82a66fe0fc39 | public java.lang.String getCustomText53() {
return this.customText53;
} |
6fc22ba0-69af-46b0-9eec-fec7b13eeb51 | public crmondemand.xml.contact.query.QueryType getCustomText12() {
return this.customText12;
} |
36dc3b4f-58c9-42a4-bc57-037bd13fec04 | public void setCustomText0(java.lang.String customText0) {
this.customText0 = customText0;
} |
d219cbfe-421e-46fd-bc80-93c4e38ab8be | @Override
public void actionPerformed(ActionEvent arg0)
{
EditorMapInformation currentMap = frame.getLevels().get("level " + selectedLevel).getMaps().get("map " + selectedMap);
String txt = ((JTextField) arg0.getSource()).getText();
currentMap.setLine2(txt);
} |
65333556-7945-43c8-85d5-ae76a373866f | public java.math.BigDecimal getCustomCurrency12() {
return this.customCurrency12;
} |
34cc4137-4dbc-4223-bc61-502a53f9710d | @Override
public void initializeClass()
{
} |
eb992a8d-bec7-4b1d-aa1f-fb864c330b6d | public java.lang.String getCustomPickList57() {
return this.customPickList57;
} |
2647d478-1153-42c7-add9-8cc90db11d0d | public void setCustomNumber63(crmondemand.xml.customobject3.query.QueryType customNumber63) {
this.customNumber63 = customNumber63;
} |
d9c923f0-e4f2-4549-8690-e5b5f410cc46 | public void setCustomText8(java.lang.String customText8) {
this.customText8 = customText8;
} |
eae0ecee-f352-4792-a799-f6436058033e | public void setCustomPickList26(java.lang.String customPickList26) {
this.customPickList26 = customPickList26;
} |
07879d49-1774-420c-8875-65159f7fd9b1 | public void factory_ofInstant_maxYear() {
OffsetTime test = OffsetTime.ofInstant(Instant.ofEpochSecond(Long.MAX_VALUE), ZoneOffset.UTC);
int hour = (int) ((Long.MAX_VALUE / (60 * 60)) % 24);
int min = (int) ((Long.MAX_VALUE / 60) % 60);
int sec = (int) (Long.MAX_VALUE % 60);
assertEquals(test.getHour(), hour);
assertEquals(test.getMinute(), min);
assertEquals(test.getSecond(), sec);
assertEquals(test.getNano(), 0);
}
@Test(groups = { "tck" } |
09d3cda4-5283-4a0a-9365-479c67e339d6 | @Override
public void run() {
AlphaBetaRun(host,port);
//MinimaxRun();
} |
05184c02-a452-4e8e-a139-7fd924b4f6f4 | public crmondemand.xml.contact.query.QueryType getPolicyTerm() {
return this.policyTerm;
} |
a21dba2a-d2b3-49ca-8685-be86108e0b0a | public crmondemand.xml.contact.query.QueryType getCustomObject9IntegrationId() {
return this.customObject9IntegrationId;
} |
0957df1f-b101-4551-924f-e6fc90764f15 | public AstType getType()
{
m_predicateL.checkType();
m_predicateR.checkType();
return new AstType(AstType.TYPE_BOOL);
}
}
public class AstBiimpliesP extends AstPredicate
{
AstPredicate m_predicateL;
AstPredicate m_predicateR;
public AstBiimpliesP(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "BIIMPLIES - Predicate");
m_predicateL.print(l + 1);
m_predicateR.print(l + 1);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_predicateL.populateTypeTable(m_stable);
m_predicateR.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_predicateL.populateSymbolTable();
m_predicateR.populateSymbolTable();
}
public AstType getType()
{
m_predicateL.checkType();
m_predicateR.checkType();
return new AstType(AstType.TYPE_BOOL);
}
}
public class AstRelationsP extends AstPredicate
{
List m_relations = new ArrayList();
AstExpression m_expressionL;
AstExpression m_expressionR;
public AstRelationsP(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, getName());
m_expressionL.print(l + 1);
m_expressionR.print(l + 1);
}
public String getName()
{
int i;
AstRelation rnode;
String name = "";
for (i = 0; i < m_relations.size(); i++)
{
rnode = (AstRelation) m_relations.get(0);
name += rnode.m_infixRelationName.m_token.m_value + " ";
}
return name;
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expressionL.populateTypeTable(m_stable);
m_expressionR.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_expressionL.populateSymbolTable();
m_expressionR.populateSymbolTable();
}
public AstType getType()
{
AstRelation r = (AstRelation) m_relations.get(0);
AstType ret;
AstType t1 = m_expressionL.getType();
AstType t2 = m_expressionR.getType();
if ((t1.isUndefined())
|| (t2.isUndefined()))
{
return new AstType(AstType.TYPE_BOOL);
}
switch (r.m_infixRelationName.m_token.m_id)
{
case TozeTokenizer.TOKEN_MEM:
case TozeTokenizer.TOKEN_NEM:
if (!t2.isSet())
{
reportTypeError("Right side of " + getName() + " must be a set",
r.m_infixRelationName.m_token,
specObject,
property
);
}
if (!t1.isEqual(t2.m_setType))
{
reportTypeError("Element is not the same type as the set for " + getName(),
r.m_infixRelationName.m_token,
specObject,
property
);
}
break;
case TozeTokenizer.TOKEN_PSUBS:
case TozeTokenizer.TOKEN_SUBS:
if (!t1.isEqual(t2))
{
reportTypeError("Both sides of " + getName() + " must be sets of the same type",
r.m_infixRelationName.m_token,
specObject,
property
);
}
break;
case TozeTokenizer.TOKEN_EQUAL:
case TozeTokenizer.TOKEN_NEQ:
if (!t1.isCompatible(t2))
{
reportTypeError("Both sides of " + getName() + " must be the same type",
r.m_infixRelationName.m_token,
specObject,
property
);
}
break;
case TozeTokenizer.TOKEN_LESSTHAN:
case TozeTokenizer.TOKEN_LEQ:
case TozeTokenizer.TOKEN_GEQ:
case TozeTokenizer.TOKEN_GREATERTHAN:
if ((!t1.isANumber() || !t2.isANumber()))
{
reportTypeError("Both sides of " + getName() + " must be numbers",
r.m_infixRelationName.m_token,
specObject,
property
);
}
break;
case TozeTokenizer.TOKEN_PREFIX:
case TozeTokenizer.TOKEN_SUFFIX:
case TozeTokenizer.TOKEN_INSEQ:
if (!t2.isSequence())
{
reportTypeError("Right side of " + getName() + " must be a sequence",
r.m_infixRelationName.m_token,
specObject,
property
);
}
if (!t1.isSequence())
{
reportTypeError("Left side of " + getName() + " must be a sequence",
r.m_infixRelationName.m_token,
specObject,
property
);
}
if (!t1.isEqual(t2))
{
reportTypeError("Both sequences of " + getName() + " must be of the same type",
r.m_infixRelationName.m_token,
specObject,
property
);
}
return new AstType(AstType.TYPE_BOOL);
case TozeTokenizer.TOKEN_BAGMEMBERSHIP:
case TozeTokenizer.TOKEN_SQUAREIMAGEOREQUAL:
case TozeTokenizer.TOKEN_PARTITIONS:
return new AstType();
default:
return new AstType();
}
return new AstType(AstType.TYPE_BOOL);
}
}
public class AstRelation extends AstBase
{
AstIdentifier m_identifier;
AstInfixRelationName m_infixRelationName;
public void print(int l)
{
if (m_infixRelationName != null)
{
m_infixRelationName.print(l);
}
if (m_identifier != null)
{
m_identifier.print(l);
}
}
}
public class AstPrefixRelationNameP extends AstPredicate
{
AstPrefixRelationName m_prefixRelationName;
AstExpression m_expression;
public AstPrefixRelationNameP(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expression.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_expression.populateSymbolTable();
}
public void checkType()
{
AstType type = m_expression.getType();
if (!type.isSet())
{
reportTypeError("Expression for " + m_prefixRelationName.getName() + " must evaluate to a set",
m_expression.m_token,
specObject,
property
);
}
}
public AstType getType()
{
checkType();
return new AstType(AstType.TYPE_BOOL);
}
}
public class AstSchemaReferenceP extends AstPredicate
{
AstSchemaReference m_schemaReference;
public AstSchemaReferenceP(SpecObject specObject, String property)
{
super(specObject, property);
}
}
public class AstPreP extends AstPredicate
{
AstSchemaReference m_schemaReference;
public AstPreP(SpecObject specObject, String property)
{
super(specObject, property);
}
}
public class AstInitP extends AstPredicate
{
AstExpression m_expression;
public AstInitP(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expression.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_expression.populateSymbolTable();
}
public AstType getType()
{
m_expression.getType();
return new AstType(AstType.TYPE_BOOL);
}
}
public class AstTrueFalseP extends AstPredicate
{
public AstTrueFalseP(SpecObject specObject, String property)
{
super(specObject, property);
}
public AstType getType()
{
return new AstType(AstType.TYPE_BOOL);
}
public void print(int l)
{
print(l, m_token.m_value);
}
}
public class AstNotP extends AstPredicate
{
AstPredicate m_predicate;
public AstNotP(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_predicate.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_predicate.populateSymbolTable();
}
public AstType getType()
{
m_predicate.getType();
return new AstType(AstType.TYPE_BOOL);
}
}
public class AstParenP extends AstPredicate
{
AstPredicate m_predicate;
public AstParenP(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_predicate.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_predicate.populateSymbolTable();
}
public AstType getType()
{
m_predicate.getType();
return new AstType(AstType.TYPE_BOOL);
}
}
/*
* Schema Expressions
*/
public class AstSchemaExpression extends AstBase
{
}
public class AstForAllS extends AstSchemaExpression
{
AstSchemaText m_schemaText;
AstSchemaExpression m_schemaExpression;
public void print(int l)
{
print(l, "ForAll SchemaExpression");
m_schemaText.print(l + 1);
m_schemaExpression.print(l + 1);
}
}
public class AstThereExistsS extends AstSchemaExpression
{
AstSchemaText m_schemaText;
AstSchemaExpression m_schemaExpression;
public void print(int l)
{
print(l, "ThereExists SchemaExpression");
m_schemaText.print(l + 1);
m_schemaExpression.print(l + 1);
}
}
public class AstThereExists1S extends AstSchemaExpression
{
AstSchemaText m_schemaText;
AstSchemaExpression m_schemaExpression;
public void print(int l)
{
print(l, "ThereExists1 SchemaExpression");
m_schemaText.print(l + 1);
m_schemaExpression.print(l + 1);
}
}
public class AstSchemaTextS extends AstSchemaExpression
{
AstSchemaText m_schemaText;
public void print(int l)
{
print(l, "SchemaText SchemaExpression");
m_schemaText.print(l + 1);
}
}
public class AstSchemaReferenceS extends AstSchemaExpression
{
AstSchemaReference m_schemaReference;
public void print(int l)
{
print(l, "SchemaReference SchemaExpression");
m_schemaReference.print(l + 1);
}
}
public class AstNotS extends AstSchemaExpression
{
AstSchemaExpression m_schemaExpression;
public void print(int l)
{
print(l, "Not SchemaExpression");
m_schemaExpression.print(l + 1);
}
}
public class AstPreS extends AstSchemaExpression
{
AstSchemaExpression m_schemaExpression;
public void print(int l)
{
print(l, "pre SchemaExpression");
m_schemaExpression.print(l + 1);
}
}
public class AstAndS extends AstSchemaExpression
{
AstSchemaExpression m_schemaExpressionL;
AstSchemaExpression m_schemaExpressionR;
public void print(int l)
{
print(l, "AND SchemaExpression");
m_schemaExpressionL.print(l + 1);
m_schemaExpressionR.print(l + 1);
}
}
public class AstOrS extends AstSchemaExpression
{
AstSchemaExpression m_schemaExpressionL;
AstSchemaExpression m_schemaExpressionR;
public void print(int l)
{
print(l, "OR SchemaExpression");
m_schemaExpressionL.print(l + 1);
m_schemaExpressionR.print(l + 1);
}
}
public class AstImpliesS extends AstSchemaExpression
{
AstSchemaExpression m_schemaExpressionL;
AstSchemaExpression m_schemaExpressionR;
public void print(int l)
{
print(l, "IMPLIES SchemaExpression");
m_schemaExpressionL.print(l + 1);
m_schemaExpressionR.print(l + 1);
}
}
public class AstBiimpliesS extends AstSchemaExpression
{
AstSchemaExpression m_schemaExpressionL;
AstSchemaExpression m_schemaExpressionR;
public void print(int l)
{
print(l, "BIIMPLIES SchemaExpression");
m_schemaExpressionL.print(l + 1);
m_schemaExpressionR.print(l + 1);
}
}
public class AstProjS extends AstSchemaExpression
{
AstSchemaExpression m_schemaExpressionL;
AstSchemaExpression m_schemaExpressionR;
public void print(int l)
{
print(l, "PROJ SchemaExpression");
m_schemaExpressionL.print(l + 1);
m_schemaExpressionR.print(l + 1);
}
}
public class AstBslashS extends AstSchemaExpression
{
AstSchemaExpression m_schemaExpression;
AstDeclarationNameList m_declarationNameList;
public void print(int l)
{
print(l, "BSLASH SchemaExpression");
m_schemaExpression.print(l + 1);
m_declarationNameList.print(l + 1);
}
}
public class AstCompS extends AstSchemaExpression
{
AstSchemaExpression m_schemaExpressionL;
AstSchemaExpression m_schemaExpressionR;
public void print(int l)
{
print(l, "COMP SchemaExpression");
m_schemaExpressionL.print(l + 1);
m_schemaExpressionR.print(l + 1);
}
}
public class AstMgtS extends AstSchemaExpression
{
AstSchemaExpression m_schemaExpressionL;
AstSchemaExpression m_schemaExpressionR;
public void print(int l)
{
print(l, ">> SchemaExpression");
m_schemaExpressionL.print(l + 1);
m_schemaExpressionR.print(l + 1);
}
}
public class AstParenS extends AstSchemaExpression
{
AstSchemaExpression m_schemaExpression;
public void print(int l)
{
print(l, "() SchemaExpression");
m_schemaExpression.print(l + 1);
}
}
/*
* Expression
*/
public class AstExpression extends AstBase
{
SpecObject specObject;
String property;
public AstExpression(SpecObject specObject, String property)
{
this.specObject = specObject;
this.property = property;
}
public void checkType()
{
getType();
}
}
public class AstBinaryOpX extends AstExpression
{
AstExpression m_expressionL;
AstExpression m_expressionR;
public AstBinaryOpX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
m_expressionL.print(l);
m_expressionR.print(l);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expressionL.populateTypeTable(m_stable);
m_expressionR.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_expressionL.populateSymbolTable();
m_expressionR.populateSymbolTable();
}
public AstType getType()
{
AstType typeL = m_expressionL.getType();
AstType typeR = m_expressionR.getType();
if ((typeL.isUndefined())
|| (typeR.isUndefined()))
{
return new AstType();
}
if (!typeL.isCompatible(typeR))
{
reportTypeError("Type mismatch",
m_token,
specObject,
property
);
}
return typeL.resultantType(typeR);
}
}
public class AstIfThenElseX extends AstExpression
{
AstPredicate m_predicate;
AstExpression m_then;
AstExpression m_else;
public AstIfThenElseX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "IfThenElse");
m_predicate.print(l + 1);
m_then.print(l + 1);
m_else.print(l + 1);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_predicate.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_predicate.populateSymbolTable();
m_then.populateSymbolTable();
m_else.populateSymbolTable();
}
public AstType getType()
{
AstType t1 = m_then.getType();
AstType t2 = m_else.getType();
if ((t1.isUndefined())
|| (t2.isUndefined()))
{
return new AstType();
}
if (!t1.isCompatible(t2))
{
reportTypeError(
"The expression used for the then clause is a different type than the one used for the else clause",
m_then.m_token,
specObject,
property
);
}
return t1.resultantType(t2);
}
}
public class AstCrossProductX extends AstBinaryOpX
{
public AstCrossProductX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "CrossProduct");
super.print(l + 1);
}
public AstType getType()
{
AstType typeL = m_expressionL.getType();
AstType typeR = m_expressionR.getType();
if ((typeL.isUndefined())
|| (typeR.isUndefined()))
{
return new AstType();
}
typeL = typeL.getSetType();
typeR = typeR.getSetType();
if ((typeL == null) || (typeR == null))
{
reportTypeError("Both expressions of a cross-product must evaluate to a set",
m_token,
specObject,
property
);
return new AstType();
}
AstType result = new AstType(AstType.TYPE_SET);
result.m_setType = new AstType(AstType.TYPE_TUPLE);
result.m_setType.newTuple(typeL, typeR);
return result;
}
}
public class AstInfixGenericNameX extends AstBinaryOpX
{
AstInfixGenericName m_infixGenericName = new AstInfixGenericName();
public AstInfixGenericNameX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
m_infixGenericName.print(l);
super.print(l + 1);
}
public String getName()
{
return m_infixGenericName.getName();
}
public AstType getType()
{
AstType typeL = m_expressionL.getType();
AstType typeR = m_expressionR.getType();
if ((typeL.isUndefined())
|| (typeR.isUndefined()))
{
return new AstType();
}
if ((!typeL.isSet() || !typeR.isSet()))
{
reportTypeError("Both sides of an infix generic operator must be sets",
m_infixGenericName.m_token,
specObject,
property
);
return new AstType();
}
AstType type = new AstType(AstType.TYPE_SET);
type.m_setType = new AstType(AstType.TYPE_SET);
type.m_setType.m_setType = new AstType(AstType.TYPE_TUPLE);
type.m_setType.m_setType.newTuple(typeL.getSetType(), typeR.getSetType());
return type;
}
}
public class AstInfixFunctionNameX extends AstBinaryOpX
{
AstInfixFunctionName m_infixFunctionName = new AstInfixFunctionName();
public AstInfixFunctionNameX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
m_infixFunctionName.print(l);
super.print(l + 1);
}
public AstType getType()
{
boolean bad = false;
int tid = m_infixFunctionName.m_token.m_id;
String tname = m_infixFunctionName.m_token.m_value;
AstType typeL = m_expressionL.getType();
AstType typeR = m_expressionR.getType();
if ((typeL.isUndefined())
|| (typeR.isUndefined()))
{
return new AstType();
}
if (tid == TozeTokenizer.TOKEN_MAP)
{
AstType type = new AstType(AstType.TYPE_TUPLE);
type.m_tupleTypes.add(typeL);
type.m_tupleTypes.add(typeR);
return type;
}
if ((tid == TozeTokenizer.TOKEN_PLUS)
|| (tid == TozeTokenizer.TOKEN_MINUS)
|| (tid == TozeTokenizer.TOKEN_DIV)
|| (tid == TozeTokenizer.TOKEN_MOD)
|| (tid == TozeTokenizer.TOKEN_FSLASH)
|| (tid == TozeTokenizer.TOKEN_TIMES))
{
AstType rtype = typeL.resultantType(typeR);
if (!rtype.isANumber())
{
reportTypeError("The expressions for the " + tname + " operator must be numbers",
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
return rtype;
}
if ((tid == TozeTokenizer.TOKEN_UNI)
|| (tid == TozeTokenizer.TOKEN_SETMINUS)
|| (tid == TozeTokenizer.TOKEN_INT)
|| (tid == TozeTokenizer.TOKEN_BSLASH))
{
if (!typeL.isSet() || !typeR.isSet())
{
reportTypeError("Expressions for the " + tname + " operator must be sets",
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
if (!typeL.isEqual(typeR))
{
reportTypeError("Sets must be the same type for the operator " + tname,
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
return typeL;
}
if ((tid == TozeTokenizer.TOKEN_CAT)
|| (tid == TozeTokenizer.TOKEN_DCAT)
|| (tid == TozeTokenizer.TOKEN_PREFIX)
|| (tid == TozeTokenizer.TOKEN_SUFFIX))
{
if (!typeL.isSequence() || !typeR.isSequence())
{
reportTypeError("Expressions for the " + tname + " operator must be sequences",
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
return typeL;
}
if (tid == TozeTokenizer.TOKEN_UPTO)
{
if (!typeL.isANumber()
|| !typeR.isANumber())
{
reportTypeError("Expressions for " + tname + " must be numbers",
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
AstType type = new AstType(AstType.TYPE_SET);
type.m_setType = typeL;
return type;
}
if ((tid == TozeTokenizer.TOKEN_FOVR)
|| (tid == TozeTokenizer.TOKEN_FCMP)
|| (tid == TozeTokenizer.TOKEN_CIRC))
{
if (!typeL.isRelation()
|| !typeR.isRelation())
{
reportTypeError("Expressions for " + tname + " must be relations",
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
if (!typeL.isEqual(typeR))
{
reportTypeError("Relations used in " + tname + " must be of the same type",
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
return typeL;
}
if ((tid == TozeTokenizer.TOKEN_DRES)
|| (tid == TozeTokenizer.TOKEN_DSUB))
{
if (!typeL.isSet())
{
reportTypeError("Left-hand argument to " + tname + " must be a set",
m_infixFunctionName.m_token,
specObject,
property
);
bad = true;
}
if (!typeR.isRelation())
{
reportTypeError("Right-hand argument to " + tname + " must be a relation",
m_infixFunctionName.m_token,
specObject,
property
);
bad = true;
}
if (bad)
{
return new AstType();
}
if (!((AstType) typeR.getSetType().m_tupleTypes.get(0)).isEqual(typeL.getSetType()))
{
reportTypeError("Type of set must be the same as the domain type of the range",
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
return typeR;
}
if ((tid == TozeTokenizer.TOKEN_RRES)
|| (tid == TozeTokenizer.TOKEN_RSUB))
{
if (!typeR.isSet())
{
reportTypeError("Right-hand argument to " + tname + " must be a set",
m_infixFunctionName.m_token,
specObject,
property
);
bad = true;
}
if (!typeL.isRelation())
{
reportTypeError("Left-hand argument to " + tname + " must be a relation",
m_infixFunctionName.m_token,
specObject,
property
);
bad = true;
}
if (bad)
{
return new AstType();
}
if (!((AstType) typeL.getSetType().m_tupleTypes.get(1)).isEqual(typeR.getSetType()))
{
reportTypeError("Type of set must be the same as the range type of the relation",
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
return typeL;
}
if ((tid == TozeTokenizer.TOKEN_PROJECT))
{
if (!typeL.isSequence())
{
reportTypeError("Left-hand expression for a projection must be a sequence",
m_infixFunctionName.m_token,
specObject,
property
);
bad = true;
}
if (!typeR.isSet())
{
reportTypeError("Right-hand expression for a projection must be a set",
m_infixFunctionName.m_token,
specObject,
property
);
bad = true;
}
if (bad)
{
return new AstType();
}
AstType tl = (AstType) typeL.getSetType().m_tupleTypes.get(1);
AstType tr = typeR.getSetType();
if (!tl.isCompatible(tr))
{
reportTypeError("Type of set must be the same as the sequence type.",
m_infixFunctionName.m_token,
specObject,
property
);
}
return typeL;
}
if ((tid == TozeTokenizer.TOKEN_EXTRACT))
{
if (!typeL.isSet())
{
reportTypeError("Left-hand expression must be a set",
m_infixFunctionName.m_token,
specObject,
property
);
bad = true;
}
else
{
}
if (!typeR.isSequence())
{
reportTypeError("Right-hand expression for a projection must be a sequence",
m_infixFunctionName.m_token,
specObject,
property
);
bad = true;
}
if (bad)
{
return new AstType();
}
AstType tl = typeL.getSetType();
/*
* Check that the set contains natural numbers.
*/
if (!tl.isANumber())
{
reportTypeError("The set must contain numbers",
m_infixFunctionName.m_token,
specObject,
property
);
}
return typeR;
}
if (tid == TozeTokenizer.TOKEN_HASH)
{
if (!typeL.isBag())
{
reportTypeError("Left-hand expression for '#' must be a bag",
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
if (!((AstType) typeL.getSetType().m_tupleTypes.get(0)).isEqual(typeR))
{
reportTypeError("Right-hand expression for '#' must be the same type as contained in the bag",
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
return new AstType(AstType.TYPE_NATURAL);
}
if (tid == TozeTokenizer.TOKEN_UPLUS)
{
if (!typeL.isBag()
|| !typeR.isBag())
{
reportTypeError("Expressions for bag union must be bags",
m_infixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
if (!typeL.isEqual(typeR))
{
reportTypeError("Both sides of bag union must be the same type",
m_infixFunctionName.m_token,
specObject,
property
);
}
}
return new AstType();
}
}
public class AstPowerX extends AstExpression
{
AstExpression m_expression;
public AstPowerX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expression.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_expression.populateSymbolTable();
}
public AstType getType()
{
AstType ttype = m_expression.getType();
if (ttype.isUndefined())
{
return new AstType();
}
if (ttype.getSetType() == null)
{
reportTypeError("Power set must be applied to a set",
m_token,
specObject,
property
);
return new AstType();
}
AstType type = new AstType(AstType.TYPE_SET);
type.m_setType = ttype;
return type;
}
}
public class AstUnaryOpX extends AstExpression
{
AstExpression m_expression;
public AstUnaryOpX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, m_token.m_value);
m_expression.print(l + 1);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expression.populateTypeTable(stable);
}
public void populateSymbolTable()
{
m_expression.populateSymbolTable();
}
public AstType getType()
{
return m_expression.getType();
}
}
public class AstPrefixGenericNameX extends AstUnaryOpX
{
AstPrefixGenericName m_prefixGenericName = new AstPrefixGenericName();
public AstPrefixGenericNameX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
m_prefixGenericName.print(l);
}
public AstType getType()
{
switch (m_prefixGenericName.m_token.m_id)
{
case TozeTokenizer.TOKEN_SEQ:
case TozeTokenizer.TOKEN_SEQONE:
case TozeTokenizer.TOKEN_ISEQ:
AstType t = m_expression.getType();
if (t.isUndefined())
{
return new AstType();
}
// AstType type = new AstType(AstType.TYPE_SET);
// type.m_setType = new AstType(AstType.TYPE_SEQUENCE);
if (t.isSet())
{
t = t.getSetType();
}
AstType rtype = new AstType(AstType.TYPE_SET);
rtype.m_setType = new AstType(AstType.TYPE_SEQUENCE);
rtype.m_setType.m_setType = new AstType(AstType.TYPE_TUPLE);
rtype.m_setType.m_setType.newTuple(new AstType(AstType.TYPE_NATURAL1),
t
);
rtype.m_setType.m_setType.m_tupleIsSeq = true;
return rtype;
case TozeTokenizer.TOKEN_BAG:
t = m_expression.getType();
if (t.isUndefined())
{
return new AstType();
}
// type = new AstType(AstType.TYPE_SET);
// type.m_setType = new AstType(AstType.TYPE_BAG);
if (t.isSet())
{
t = t.getSetType();
}
rtype = new AstType(AstType.TYPE_SET);
rtype.m_setType = new AstType(AstType.TYPE_BAG);
rtype.m_setType.m_setType = new AstType(AstType.TYPE_TUPLE);
rtype.m_setType.m_setType.newTuple(t,
new AstType(AstType.TYPE_NATURAL1)
);
rtype.m_setType.m_setType.m_tupleIsSeq = true;
return rtype;
}
return new AstType();
}
}
public class AstHyphenX extends AstUnaryOpX
{
AstDecorations m_decoration;
public AstHyphenX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expression.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_expression.populateSymbolTable();
}
public AstType getType()
{
AstType t = m_expression.getType();
if (!t.isANumber())
{
reportTypeError("The expression for - must be a number",
m_token,
specObject,
property
);
return new AstType();
}
return t;
}
}
public class AstImageX extends AstExpression // (| |)
{
AstExpression m_expression1;
AstExpression m_expression0;
AstDecorations m_decoration;
public AstImageX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expression1.populateTypeTable(m_stable);
m_expression0.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_expression1.populateSymbolTable();
m_expression0.populateSymbolTable();
}
public AstType getType()
{
boolean bad = false;
AstType typeL = m_expression1.getType();
AstType typeM = m_expression0.getType();
if ((typeL.isUndefined())
|| (typeM.isUndefined()))
{
return new AstType();
}
if (!typeL.isRelation())
{
reportTypeError("Left-hand expression to the image operator must be a relation",
m_token,
specObject,
property
);
bad = true;
}
if (!typeM.isSet())
{
reportTypeError("Inside expression of the image operator must be a set",
m_token,
specObject,
property
);
bad = true;
}
if (bad)
{
return new AstType();
}
if (!typeM.getSetType().isEqual((AstType) typeL.getSetType().m_tupleTypes.get(0)))
{
reportTypeError(
"The type of the inside set expression must the the same type as the domain type of the relation for the image operator",
m_token,
specObject,
property
);
return new AstType();
}
AstType type = new AstType(AstType.TYPE_SET);
type.m_setType = (AstType) typeL.getSetType().m_tupleTypes.get(1);
return type;
}
}
public class AstExpressionListX extends AstExpression
{
List m_expressions = new ArrayList();
public AstExpressionListX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
int i;
for (i = 0; i < m_expressions.size(); i++)
{
((AstBase) m_expressions.get(i)).populateTypeTable(m_stable);
}
}
public void populateSymbolTable()
{
int i;
for (i = 0; i < m_expressions.size(); i++)
{
((AstBase) m_expressions.get(i)).populateSymbolTable();
}
}
public AstType getType()
{
AstType type = new AstType(AstType.TYPE_TUPLE);
int i;
for (i = 0; i < m_expressions.size(); i++)
{
AstType t = ((AstBase) m_expressions.get(i)).getType();
type.m_tupleTypes.add(t);
}
/*
* Special case where a tuple is surrounded by parenthesis
*/
if (m_expressions.size() == 1)
{
AstType t = (AstType) type.m_tupleTypes.get(0);
if (t.getType() == AstType.TYPE_TUPLE)
{
return t;
}
}
return type;
}
}
public class AstDistUnionX extends AstExpression
{
AstExpression m_expression = null;
public AstDistUnionX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expression.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_expression.populateSymbolTable();
}
public AstType getType()
{
AstType type = m_expression.getType();
if (type.isUndefined())
{
return new AstType();
}
if (type.getType() != AstType.TYPE_SET)
{
reportTypeError("Expression used in distributed union must be a set of sets.",
m_token,
specObject,
property
);
return new AstType();
}
/*
* If the set is a tuple, then we need to make sure that each tuple
* is of the same type.
*/
if (type.getSetType().getType() == AstType.TYPE_TUPLE)
{
int i;
AstType stype = type.getSetType();
if (stype.m_tupleTypes.size() == 0)
{
return new AstType(AstType.TYPE_EMPTY);
}
AstType type1 = (AstType) stype.m_tupleTypes.get(0);
for (i = 1; i < stype.m_tupleTypes.size(); i++)
{
AstType type2 = (AstType) stype.m_tupleTypes.get(i);
if (!type1.isCompatible(type2))
{
reportTypeError("All sets used in a distributed union must be of the same type.",
m_token,
specObject,
property
);
return new AstType();
}
}
return type1;
}
else
{
if (type.getSetType().getType() != AstType.TYPE_SET)
{
reportTypeError("Expression used in distributed union must be a set of sets.",
m_token,
specObject,
property
);
return new AstType();
}
return type.getSetType();
}
}
}
public class AstDistIntersectionX extends AstExpression
{
AstExpression m_expression = null;
public AstDistIntersectionX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expression.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_expression.populateSymbolTable();
}
public AstType getType()
{
AstType type = m_expression.getType();
if (type.isUndefined())
{
return new AstType();
}
if (type.getType() != AstType.TYPE_SET)
{
reportTypeError("Expression used in distributed intersection must be a set of sets.",
m_token,
specObject,
property
);
return new AstType();
}
/*
* If the set is a tuple, then we need to make sure that each tuple
* is of the same type.
*/
if (type.getSetType().getType() == AstType.TYPE_TUPLE)
{
int i;
AstType stype = type.getSetType();
if (stype.m_tupleTypes.size() == 0)
{
return new AstType(AstType.TYPE_EMPTY);
}
AstType type1 = (AstType) stype.m_tupleTypes.get(0);
for (i = 1; i < stype.m_tupleTypes.size(); i++)
{
AstType type2 = (AstType) stype.m_tupleTypes.get(i);
if (!type1.isCompatible(type2))
{
reportTypeError("All sets used in a distributed intersection must be of the same type.",
m_token,
specObject,
property
);
return new AstType();
}
}
return type1;
}
else
{
if (type.getSetType().getType() != AstType.TYPE_SET)
{
reportTypeError("Expression used in distributed intersection must be a set of sets.",
m_token,
specObject,
property
);
return new AstType();
}
return type.getSetType();
}
}
}
public class AstVariableX extends AstExpression
{
AstVariableName m_variable;
AstActualParameters m_actualParameters;
public AstVariableX(SpecObject specObject, String property)
{
super(specObject, property);
}
}
public class AstSelfX extends AstExpression
{
public AstSelfX(SpecObject specObject, String property)
{
super(specObject, property);
}
}
public class AstNumberX extends AstExpression
{
public AstNumberX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, m_token.m_value);
}
public AstType getType()
{
AstType type = new AstType();
if (m_token.m_value.indexOf('.') >= 0)
{
type.m_type = AstType.TYPE_REAL;
}
else
{
type.m_type = AstType.TYPE_NATURAL;
}
return type;
}
}
public class AstSchemaReferenceX extends AstExpression
{
AstSchemaReference m_schemaReference;
public AstSchemaReferenceX(SpecObject specObject, String property)
{
super(specObject, property);
}
}
public class AstClassNameX extends AstExpression
{
AstClassName m_className;
AstActualParameters m_actualParameters;
AstRenameList m_renameList;
public AstClassNameX(SpecObject specObject, String property)
{
super(specObject, property);
}
}
public class AstDownArrowX extends AstExpression
{
AstExpression m_expression;
public AstDownArrowX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expression.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_expression.populateSymbolTable();
}
public AstType getType()
{
if (m_expression == null)
{
return new AstType();
}
return m_expression.getType();
}
}
public class AstUnionX extends AstBinaryOpX
{
public void print(int l)
{
print(l, "Union");
super.print(l + 1);
}
public AstUnionX(SpecObject specObject, String property)
{
super(specObject, property);
}
public AstType getType()
{
AstType typeL = m_expressionL.getType();
AstType typeR = m_expressionR.getType();
if ((typeL.isUndefined())
|| (typeR.isUndefined()))
{
return new AstType();
}
if (!typeL.isSet() || !typeR.isSet())
{
reportTypeError(
"Expressions for the " + Character.toString(TozeFontMap.CHAR_CUP) + " operator must be sets",
m_token,
specObject,
property
);
return new AstType();
}
if (!typeL.isEqual(typeR))
{
reportTypeError(
"Sets must be the same type for the operator " + Character.toString(TozeFontMap.CHAR_CUP),
m_token,
specObject,
property
);
return new AstType();
}
return typeL;
}
}
public class AstCopyrightX extends AstUnaryOpX
{
public AstCopyrightX(SpecObject specObject, String property)
{
super(specObject, property);
}
}
public class AstAngleX extends AstExpression
{
List m_expressions = new ArrayList();
public AstAngleX(SpecObject specObject, String property)
{
super(specObject, property);
}
}
public class AstBagX extends AstExpression
{
List m_expressions = new ArrayList();
public AstBagX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
int i;
print(l, "BagExpression");
for (i = 0; i < m_expressions.size(); i++)
{
((AstExpression) m_expressions.get(i)).print(l + 1);
}
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
int i;
for (i = 0; i < m_expressions.size(); i++)
{
((AstBase) m_expressions.get(i)).populateTypeTable(m_stable);
}
}
public void populateSymbolTable()
{
int i;
for (i = 0; i < m_expressions.size(); i++)
{
((AstBase) m_expressions.get(i)).populateSymbolTable();
}
}
public AstType getType()
{
int i;
boolean wasUndefined = false;
AstType type = new AstType(AstType.TYPE_BAG);
if (m_expressions.size() == 0)
{
return new AstType(AstType.TYPE_EMPTY);
}
AstType stype = ((AstBase) m_expressions.get(0)).getType();
if (stype.isUndefined())
{
return new AstType();
}
for (i = 1; i < m_expressions.size(); i++)
{
AstType ttype = ((AstBase) m_expressions.get(i)).getType();
if (ttype.isUndefined())
{
wasUndefined = true;
}
else
{
if (!ttype.isEqual(stype))
{
reportTypeError("All expressions of a bag must be of the same type",
m_token,
specObject,
property
);
}
}
}
if (wasUndefined)
{
return new AstType();
}
AstType rtype = new AstType(AstType.TYPE_BAG);
rtype.m_setType = new AstType(AstType.TYPE_TUPLE);
rtype.m_setType.newTuple(stype,
new AstType(AstType.TYPE_NATURAL1)
);
rtype.m_setType.m_tupleIsSeq = false;
return rtype;
}
}
public class AstThetaX extends AstExpression
{
AstSchemaName m_schemaName;
AstDecorations m_decorations;
AstRenameList m_renameList;
public AstThetaX(SpecObject specObject, String property)
{
super(specObject, property);
}
}
public class AstMemberX extends AstExpression
{
AstExpression m_expression;
AstVariableName m_variableName;
public AstMemberX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "AstMember");
m_expression.print(l + 1);
m_variableName.print(l + 1);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_expression.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_expression.populateSymbolTable();
}
public AstType getType()
{
AstType ctype = m_expression.getType();
if (ctype.isUndefined())
{
return new AstType();
}
if (ctype == null)
{
reportTypeError("Undefined class variable",
m_expression.m_token,
specObject,
property
);
return new AstType();
}
if (ctype.getType() != AstType.TYPE_CLASS)
{
reportTypeError("Member access must be from a class type",
m_expression.m_token,
specObject,
property
);
return new AstType();
}
AstType type = null;
if (m_variableName != null)
{
type = ctype.getClassMembers().getTypeVisible(m_variableName.getName());
}
if (type == null)
{
// the variable name may be null after a class.member syntax
// where member is blank, handle as a null and use a unique
// TozeToken
String member = "<null>";
TozeToken token = null;
if (m_variableName != null)
{
member = m_variableName.getName();
token = m_variableName.m_token;
}
if (token == null)
{
token = new TozeToken(-1, member, -1, -1);
}
reportTypeError("The member " + member + " is not visible",
token,
specObject,
property
);
return new AstType();
}
if (type.isUndefined())
{
reportTypeError("The member " + m_variableName.getName() + " is undefined",
m_variableName.m_token,
specObject,
property
);
return new AstType();
}
return type;
}
}
public class AstPostfixFunctionNameX extends AstUnaryOpX
{
AstPostfixFunctionName m_postfixFunctionName;
public AstPostfixFunctionNameX(SpecObject specObject, String property)
{
super(specObject, property);
}
public AstType getType()
{
AstType type = m_expression.getType();
if (type.isUndefined())
{
return new AstType();
}
if ((m_postfixFunctionName.m_token.m_id == TozeTokenizer.TOKEN_TILDE)
|| (m_postfixFunctionName.m_token.m_id == TozeTokenizer.TOKEN_INV))
{
if (!type.isRelation())
{
reportTypeError("The argument to '~' must be a relation",
m_postfixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
AstType rtype = new AstType(AstType.TYPE_SET);
rtype.m_setType = new AstType(AstType.TYPE_TUPLE);
rtype.m_setType.newTuple((AstType) type.m_setType.m_tupleTypes.get(1),
(AstType) type.m_setType.m_tupleTypes.get(0)
);
return rtype;
}
if ((m_postfixFunctionName.m_token.m_id == TozeTokenizer.TOKEN_TCL)
|| (m_postfixFunctionName.m_token.m_id == TozeTokenizer.TOKEN_RTCL))
{
if (!type.isRelation())
{
reportTypeError(
"The argument to '" + m_postfixFunctionName.m_token.m_value + "' must be a relation",
m_postfixFunctionName.m_token,
specObject,
property
);
return new AstType();
}
}
return type;
}
}
public class AstParenX extends AstExpression
{
public AstParenX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "Parenthesis");
super.print(l + 1);
}
}
public class AstLambdaX extends AstExpression
{
AstSchemaText m_schemaText;
AstExpression m_expression;
public AstLambdaX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "Lambda");
m_schemaText.print(l + 1);
m_expression.print(l + 1);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_schemaText.populateTypeTable(m_stable);
m_expression.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_schemaText.populateSymbolTable();
m_expression.populateSymbolTable();
}
public AstType getType()
{
m_schemaText.checkType();
List decls = m_schemaText.m_declaration.m_decls;
AstType ttype = new AstType(AstType.TYPE_TUPLE);
int i;
for (i = 0; i < decls.size(); i++)
{
if (decls.get(i) instanceof AstBasicDeclaration1)
{
AstBasicDeclaration1 dec = (AstBasicDeclaration1) decls.get(i);
List names = dec.m_declarationNameList.m_declarationNameList;
int j;
for (j = 0; j < names.size(); j++)
{
AstDeclarationName name = (AstDeclarationName) names.get(j);
AstType nt = m_stable.getType(name.getName());
ttype.m_tupleTypes.add(nt);
}
}
}
AstType et = m_expression.getType();
if (et.isUndefined())
{
return new AstType();
}
ttype.m_tupleTypes.add(et);
AstType type = new AstType(AstType.TYPE_SET);
type.m_setType = ttype;
return type;
}
}
public class AstMuX extends AstExpression
{
AstSchemaText m_schemaText;
AstExpression m_expression;
public AstMuX(SpecObject specObject, String property)
{
super(specObject, property);
}
}
public class AstLetX extends AstExpression
{
List m_letDefinitions = new ArrayList();
AstExpression m_expression;
public AstLetX(SpecObject specObject, String property)
{
super(specObject, property);
}
}
/*
* This class is a merging of a variable (V), Schema Reference (S), and
* class (C).
* This is done because sometimes it is not possible to know at the time of
* parsing whether something is either of the three.
*
* Word -> VSC
* Word, Decoration -> VS
* Word, ActualParameters -> VSC
* Word, RenameList -> SC
* Word, ActualParameters, RenameList -> SC
* Word, Decoration, ActualParameters -> VS
* Word, Decoration, RenameList -> S
* Word, Decoration, ActualParameters, RenameList -> S
*/
public class AstVSCX extends AstExpression
{
// The Word will be stored in the token in the base class.
AstDecorations m_decorations;
AstActualParameters m_actualParameters;
AstRenameList m_renameList;
public AstVSCX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "VSC");
print(l + 1, m_token.m_value);
if (m_decorations != null)
{
m_decorations.print(l + 1);
}
if (m_actualParameters != null)
{
m_actualParameters.print(l + 1);
}
if (m_renameList != null)
{
m_renameList.print(l + 1);
}
}
public AstType getType()
{
AstType type = m_stable.getTypeDef(getName());
if (type == null)
{
type = m_stable.getType(getName());
if (type == null)
{
reportTypeError(getName() + " is undefined",
m_token,
specObject,
property
);
return new AstType();
}
if (type.isUndefined())
{
reportTypeError(getName() + " is undefined",
m_token,
specObject,
property
);
return new AstType();
}
}
return type;
}
public String getName()
{
if (m_decorations == null)
{
return m_token.m_value;
}
return m_token.m_value + m_decorations.getName();
}
}
public class AstSetExpressionX extends AstExpression
{
public AstSetExpressionX(SpecObject specObject, String property)
{
super(specObject, property);
}
}
public class AstSetExpressionX1 extends AstSetExpressionX
{
List m_expressions = new ArrayList();
public AstSetExpressionX1(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
int i;
print(l, "SetExpression");
for (i = 0; i < m_expressions.size(); i++)
{
((AstExpression) m_expressions.get(i)).print(l + 1);
}
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
int i;
for (i = 0; i < m_expressions.size(); i++)
{
((AstBase) m_expressions.get(i)).populateTypeTable(m_stable);
}
}
public void populateSymbolTable()
{
int i;
for (i = 0; i < m_expressions.size(); i++)
{
((AstBase) m_expressions.get(i)).populateSymbolTable();
}
}
public AstType getType()
{
AstType type;
int i;
boolean wasUndefined = false;
//ttp
/*
* if (m_expressions.size() > 1)
* {
* AstType ttype = new AstType();
* ttype.m_type = AstType.TYPE_TUPLE;
* for (i=0; i<m_expressions.size(); i++)
* {
* type = ((AstBase)m_expressions.get(i)).getType();
* ttype.m_tupleTypes.add(type);
* if (type.isUndefined()) wasUndefined = true;
* }
* if (wasUndefined) return new AstType();
* type = new AstType(AstType.TYPE_SET);
* type.m_setType = ttype;
* }
* else if (m_expressions.size() == 1)
*/
if (m_expressions.size() != 0)
{
type = new AstType(AstType.TYPE_SET);
type.m_setType = ((AstBase) m_expressions.get(0)).getType();
if (type.m_setType.isUndefined())
{
return new AstType();
}
}
else
{
type = new AstType(AstType.TYPE_SET);
type.m_setType = new AstType(AstType.TYPE_EMPTY);
if (type.m_setType.isUndefined())
{
return new AstType();
}
}
return type;
}
}
public class AstSetExpressionX2 extends AstSetExpressionX
{
AstSchemaText m_schemaText;
AstExpression m_expression;
public AstSetExpressionX2(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "SetExpression");
if (m_schemaText != null)
{
m_schemaText.print(l + 1);
}
m_expression.print(l + 1);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = new AstSymbolTable(stable);
stable.addKid(m_stable);
if (m_schemaText != null)
{
m_schemaText.populateTypeTable(m_stable);
}
if (m_expression != null)
{
m_expression.populateTypeTable(m_stable);
}
}
public void populateSymbolTable()
{
if (m_schemaText != null)
{
m_schemaText.populateSymbolTable();
}
if (m_expression != null)
{
m_expression.populateSymbolTable();
}
}
public AstType getType()
{
if (m_schemaText != null)
{
m_schemaText.checkType();
}
if (m_expression == null)
{
return m_schemaText.getType();
}
AstType type = new AstType(AstType.TYPE_SET);
type.m_setType = m_expression.getType();
if (type.m_setType.isUndefined())
{
return new AstType();
}
return type;
}
}
public class AstSetExpressionX3 extends AstSetExpressionX
{
public AstSetExpressionX3(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "SetExpression - " + m_token.m_value);
}
public AstType getType()
{
AstType type = new AstType();
if (m_token.m_id == TozeTokenizer.TOKEN_NAT)
{
return m_stable.getTypeDef(m_token.m_value);
}
else if (m_token.m_id == TozeTokenizer.TOKEN_NATONE)
{
return m_stable.getTypeDef(m_token.m_value);
}
else if (m_token.m_id == TozeTokenizer.TOKEN_INTEGER)
{
return m_stable.getTypeDef(m_token.m_value);
}
else if (m_token.m_id == TozeTokenizer.TOKEN_REAL)
{
return m_stable.getTypeDef(m_token.m_value);
}
else if (m_token.m_id == TozeTokenizer.TOKEN_BOOL)
{
return m_stable.getTypeDef(m_token.m_value);
}
return m_stable.getTypeDef(m_token.m_value);
}
}
public class AstSequenceX extends AstExpression
{
List m_expressions = new ArrayList();
public AstSequenceX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void print(int l)
{
print(l, "Sequence");
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
int i;
for (i = 0; i < m_expressions.size(); i++)
{
((AstBase) m_expressions.get(i)).populateTypeTable(m_stable);
}
}
public void populateSymbolTable()
{
int i;
for (i = 0; i < m_expressions.size(); i++)
{
((AstBase) m_expressions.get(i)).populateSymbolTable();
}
}
public AstType getType()
{
int i;
boolean wasUndefined = false;
AstType type = new AstType(AstType.TYPE_SEQUENCE);
if (m_expressions.size() == 0)
{
type.m_setType = new AstType(AstType.TYPE_EMPTY);
return type;
}
AstType stype = ((AstBase) m_expressions.get(0)).getType();
if (stype.isUndefined())
{
return new AstType();
}
for (i = 1; i < m_expressions.size(); i++)
{
AstType ttype = ((AstBase) m_expressions.get(i)).getType();
if (ttype.isUndefined())
{
wasUndefined = true;
}
else
{
if (!ttype.isEqual(stype))
{
reportTypeError("All expressions of a sequence must be of the same type",
m_token,
specObject,
property
);
}
}
}
if (wasUndefined)
{
return new AstType();
}
AstType rtype = new AstType(AstType.TYPE_SEQUENCE);
rtype.m_setType = new AstType(AstType.TYPE_TUPLE);
rtype.m_setType.newTuple(new AstType(AstType.TYPE_NATURAL1),
stype
);
rtype.m_setType.m_tupleIsSeq = true;
return rtype;
}
}
public class AstBuiltInFunctionX extends AstUnaryOpX
{
public AstBuiltInFunctionX(SpecObject specObject, String property)
{
super(specObject, property);
}
public AstType getType()
{
AstType type = m_expression.getType();
if (type.isUndefined())
{
return new AstType();
}
if (m_token.m_id == TozeTokenizer.TOKEN_DOM)
{
if (type.getType() != AstType.TYPE_SET)
{
reportTypeError("The argument to the function 'dom' must be a set of tuples",
m_token,
specObject,
property
);
return new AstType();
}
if (type.getSetType().getType() != AstType.TYPE_TUPLE)
{
reportTypeError("The argument to the function 'dom' must be a set of tuples",
m_token,
specObject, property
);
return new AstType();
}
if (type.getSetType().m_tupleTypes.size() != 2)
{
reportTypeError("The argument to the function 'dom' must be a tuple of size 2",
m_token,
specObject,
property
);
return new AstType();
}
AstType rtype = new AstType(AstType.TYPE_SET);
rtype.m_setType = (AstType) type.getSetType().m_tupleTypes.get(0);
return rtype;
}
if (m_token.m_id == TozeTokenizer.TOKEN_RAN)
{
if (type.getType() != AstType.TYPE_SET)
{
reportTypeError("The argument to the function 'ran' must be a set of tuples",
m_token,
specObject,
property
);
return new AstType();
}
if (type.getSetType().getType() != AstType.TYPE_TUPLE)
{
reportTypeError("The argument to the function 'ran' must be a set of tuples",
m_token,
specObject,
property
);
return new AstType();
}
if (type.getSetType().m_tupleTypes.size() != 2)
{
reportTypeError("The argument to the function 'ran' must be a tuple of size 2",
m_token,
specObject,
property
);
return new AstType();
}
AstType rtype = new AstType(AstType.TYPE_SET);
rtype.m_setType = (AstType) type.getSetType().m_tupleTypes.get(1);
return rtype;
}
if (m_token.m_id == TozeTokenizer.TOKEN_REV)
{
if (type.getType() != AstType.TYPE_SEQUENCE)
{
reportTypeError("The argument to the function 'rev' must be a sequence",
m_token,
specObject,
property
);
return new AstType();
}
return type;
}
if (m_token.m_id == TozeTokenizer.TOKEN_HEAD)
{
if (type.getType() != AstType.TYPE_SEQUENCE)
{
reportTypeError("The argument to the function 'head' must be a sequence",
m_token,
specObject,
property
);
return new AstType();
}
return (AstType) type.getSetType().m_tupleTypes.get(1);
// return type.m_setType;
}
if (m_token.m_id == TozeTokenizer.TOKEN_LAST)
{
if (type.getType() != AstType.TYPE_SEQUENCE)
{
reportTypeError("The argument to the function 'last' must be a sequence",
m_token,
specObject,
property
);
return new AstType();
}
return (AstType) type.getSetType().m_tupleTypes.get(1);
// return type.m_setType;
}
if (m_token.m_id == TozeTokenizer.TOKEN_TAIL)
{
if (type.getType() != AstType.TYPE_SEQUENCE)
{
reportTypeError("The argument to the function 'tail' must be a sequence",
m_token,
specObject,
property
);
return new AstType();
}
return type;
}
if (m_token.m_id == TozeTokenizer.TOKEN_FRONT)
{
if (type.getType() != AstType.TYPE_SEQUENCE)
{
reportTypeError("The argument to the function 'front' must be a sequence",
m_token,
specObject,
property
);
return new AstType();
}
return type;
}
if ((m_token.m_id == TozeTokenizer.TOKEN_FIRST)
|| (m_token.m_id == TozeTokenizer.TOKEN_SECOND))
{
if ((type.getType() != AstType.TYPE_TUPLE)
|| (type.m_tupleTypes.size() != 2))
{
reportTypeError("The argument to " + m_token.m_value + " must be a tuple of size 2",
m_token,
specObject,
property
);
return new AstType();
}
if (m_token.m_id == TozeTokenizer.TOKEN_FIRST)
{
return (AstType) type.m_tupleTypes.get(0);
}
return (AstType) type.m_tupleTypes.get(1);
}
if (m_token.m_id == TozeTokenizer.TOKEN_HASH)
{
if (!type.isSet() && !type.isSequence())
{
reportTypeError("Argument to '#' must be either a set or a sequence",
m_token,
specObject,
property
);
}
return new AstType(AstType.TYPE_NATURAL);
}
return new AstType();
}
}
public class AstFunctionX extends AstExpression
{
AstExpression m_fexpression;
AstExpression m_pexpression;
public AstFunctionX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_fexpression.populateTypeTable(m_stable);
m_pexpression.populateTypeTable(m_stable);
}
public void populateSymbolTable()
{
m_fexpression.populateSymbolTable();
m_pexpression.populateSymbolTable();
}
public AstType getType()
{
AstType ftype = m_fexpression.getType();
AstType ptype = m_pexpression.getType();
if ((ftype.isUndefined())
|| (ptype.isUndefined()))
{
return new AstType();
}
/*
* Check the special case where it looks like an expression function
* but it is really where a single element of a sequence is being
* referenced.
*/
if (ftype.getType() == AstType.TYPE_SEQUENCE)
{
if (!ptype.isANumber())
{
reportTypeError("Subscript to a sequence must be a number",
m_token,
specObject,
property
);
}
return (AstType) ftype.getSetType().m_tupleTypes.get(1);
}
if ((ftype.getType() != AstType.TYPE_SET)
&& (ftype.getType() != AstType.TYPE_SEQUENCE))
{
reportTypeError("Expression used as a function must evaluate to a set of a tuple",
m_token,
specObject,
property
);
return new AstType();
}
if (ftype.getSetType().getType() != AstType.TYPE_TUPLE)
{
reportTypeError("Expression used as a function must evaluate to a tuple",
m_token,
specObject,
property
);
return new AstType();
}
if (ftype.getSetType().m_tupleTypes.size() < 2)
{
reportTypeError("The tuple must be a binary relation",
m_token,
specObject,
property
);
return new AstType();
}
//if (ptype.getType() == AstType.TYPE_TUPLE)
if (ptype.isTuple())
{
if ((ptype.m_tupleTypes.size() + 1) != ftype.m_setType.m_tupleTypes.size())
{
reportTypeError("Number of parameters for the function do not match definition.",
m_token,
specObject,
property
);
}
int i;
for (i = 0; i < ptype.m_tupleTypes.size(); i++)
{
AstType t1 = (AstType) ptype.m_tupleTypes.get(i);
AstType t2 = (AstType) ftype.m_setType.m_tupleTypes.get(i);
if (!t1.isCompatible(t2))
{
reportTypeError("Parameter " + (i + 1) + " does not match definition.",
m_token,
specObject,
property
);
}
}
}
else
{
if (!ptype.isEqual((AstType) ftype.getSetType().m_tupleTypes.get(0)))
{
reportTypeError("Parameter types do not match function parameters",
m_token,
specObject,
property
);
}
}
List vtmp = ftype.getSetType().m_tupleTypes;
return (AstType) vtmp.get(vtmp.size() - 1);
}
}
public class AstPredicateX extends AstExpression
{
AstPredicate m_predicate;
public AstPredicateX(SpecObject specObject, String property)
{
super(specObject, property);
}
public void populateTypeTable(AstSymbolTable stable)
{
m_stable = stable;
m_predicate.populateTypeTable(stable);
}
public void populateSymbolTable()
{
m_predicate.populateSymbolTable();
}
public AstType getType()
{
boolean bad = false;
return new AstType(AstType.TYPE_BOOL);
}
}
/*
* Infix, Postfix, Prefix
*/
public class AstPrefixGenericName extends AstBase
{
AstDecorations m_decoration;
public void print(int l)
{
print(l, "PrefixGenericName = " + m_token.m_value);
if (m_decoration != null)
{
m_decoration.print(l + 1);
}
}
}
public class AstInfixGenericName extends AstBase
{
AstDecorations m_decoration;
public void print(int l)
{
print(l, "InfixGenericName = " + getName());
if (m_decoration != null)
{
m_decoration.print(l + 1);
}
}
public String getName()
{
return m_token.m_value;
}
}
public class AstInfixFunctionName extends AstBase
{
AstDecorations m_decoration;
public void print(int l)
{
print(l, m_token.m_value);
if (m_decoration != null)
{
m_decoration.print(l + 1);
}
}
}
public class AstInfixRelationName extends AstBase
{
AstDecorations m_decoration;
public void print(int l)
{
print(l, "InfixRelationName = " + m_token.m_value);
if (m_decoration != null)
{
m_decoration.print(l + 1);
}
}
}
public class AstPrefixRelationName extends AstBase
{
public void print(int l)
{
print(l, "PrefixRelationName = " + getName());
}
public String getName()
{
return m_token.m_value;
}
}
public class AstPostfixFunctionName extends AstBase
{
AstDecorations m_decoration;
public void print(int l)
{
print(l, "PrefixFunctionName = " + m_token.m_value);
m_decoration.print(l + 1);
} |
e56ad889-f8ce-43d7-a85d-9f19e822c9fb | public crmondemand.xml.customobject3.query.QueryType getCustomDate21() {
return this.customDate21;
} |
d34a1f70-c609-4cb9-9de8-9e2f6000f083 | public crmondemand.xml.contact.query.QueryType getCustomObject1Type() {
return this.customObject1Type;
} |
21fe12c5-23dd-4891-95af-39342b41e67a | public void setCustomObject10IntegrationId(crmondemand.xml.contact.query.QueryType customObject10IntegrationId) {
this.customObject10IntegrationId = customObject10IntegrationId;
} |
05bfc019-2b00-42c9-939f-fa6e95e7cb5e | public java.math.BigDecimal getModalPremium() {
return this.modalPremium;
} |
2f24426b-8ec5-498d-9a20-5ce9e72de343 | public java.lang.String getExamIdentifier() {
return this.examIdentifier;
} |
976547c0-b03b-40aa-8f5a-9cee89939a91 | public void setUpdatedByFullName(java.lang.String updatedByFullName) {
this.updatedByFullName = updatedByFullName;
} |
9c3199c1-a203-433c-b28c-dbd3bf598517 | public void setCustomBoolean34(java.lang.Boolean customBoolean34) {
this.customBoolean34 = customBoolean34;
} |
ebda25c7-4841-4b59-a2dc-438a75f0e833 | public void setUpdatedByFullName(java.lang.String updatedByFullName) {
this.updatedByFullName = updatedByFullName;
} |
aa79b326-42f4-43a3-8d17-66e86830d570 | public java.lang.Boolean getCustomBoolean20() {
return this.customBoolean20;
} |
eab536ac-7ef8-459a-9a1c-f0bd5010f917 | public void setCustomDate3(java.util.Calendar customDate3) {
this.customDate3 = customDate3;
} |
d79c9943-ee4d-4bce-8619-b09e8123e072 | public java.lang.String getCustomText69() {
return this.customText69;
} |
4a0cbe93-a1f3-41fa-818a-1b9cba37d37a | public void setCustomText34(crmondemand.xml.opportunity.query.QueryType customText34) {
this.customText34 = customText34;
} |
368f11ce-42c5-4c0c-ba78-685d005ec40e | public void setListOfAccreditation(crmondemand.xml.customobject3.query.ListOfAccreditationQuery listOfAccreditation) {
this.listOfAccreditation = listOfAccreditation;
} |
08a75b07-960c-4ad5-9aea-746f01384456 | public static Keyword minimumOfNumbersSpecialist(ControlFrame frame, Keyword lastmove) {
{ Proposition proposition = frame.proposition;
Stella_Object listarg = (proposition.arguments.theArray)[0];
Stella_Object listskolem = Logic.argumentBoundTo(listarg);
Stella_Object minarg = (proposition.arguments.theArray)[1];
Stella_Object minvalue = Logic.argumentBoundTo(minarg);
NumberWrapper minimum = null;
boolean missingnumbersP = false;
lastmove = lastmove;
if ((listskolem != null) &&
(!Logic.logicalCollectionP(listskolem))) {
{
System.out.println();
System.out.println("Non list appears in second argument to 'MINIMUM-OF-NUMBERS'");
System.out.println();
}
;
return (Logic.KWD_TERMINAL_FAILURE);
}
{ List listvalue = Logic.assertedCollectionMembers(listskolem, true);
if (listvalue.emptyP()) {
return (Logic.KWD_TERMINAL_FAILURE);
}
{ Stella_Object v = null;
Cons iter000 = listvalue.theConsList;
for (;!(iter000 == Stella.NIL); iter000 = iter000.rest) {
v = iter000.value;
if (Stella_Object.isaP(v, Logic.SGT_STELLA_NUMBER_WRAPPER)) {
if ((minimum == null) ||
PlKernelKb.arithmeticLessTest(((NumberWrapper)(v)), minimum)) {
minimum = ((NumberWrapper)(v));
}
}
else {
missingnumbersP = true;
}
}
}
if (minimum == null) {
return (Logic.KWD_TERMINAL_FAILURE);
}
if (missingnumbersP) {
if ((minvalue != null) &&
(Stella_Object.isaP(minvalue, Logic.SGT_STELLA_NUMBER_WRAPPER) &&
PlKernelKb.arithmeticGreaterTest(((NumberWrapper)(minvalue)), minimum))) {
{
ControlFrame.setFrameTruthValue(frame, Logic.FALSE_TRUTH_VALUE);
return (Logic.KWD_TERMINAL_FAILURE);
}
}
else {
{
ControlFrame.setFrameTruthValue(frame, Logic.UNKNOWN_TRUTH_VALUE);
return (Logic.KWD_FAILURE);
}
}
}
return (Logic.selectTestResult(Logic.bindArgumentToValueP(minarg, minimum, true), true, frame));
}
}
} |
88876c5c-14a1-411d-b3a0-de66691e6128 | public void setCustomNumber12(java.math.BigDecimal customNumber12) {
this.customNumber12 = customNumber12;
} |
8abf3462-9b21-4176-9c69-d9f26c8ed30d | public void setKeywordExtractMode(String keywordExtractMode) {
if( !keywordExtractMode.equals(AlchemyAPI_KeywordParams.EXTRACT_MODE_STRICT))
{
throw new RuntimeException("Invalid setting " + keywordExtractMode + " for parameter keywordExtractMode");
}
this.keywordExtractMode = keywordExtractMode;
} |
a38815b6-2b5b-4afb-b127-c9e08fadf1c6 | public java.lang.String getCustomPickList77() {
return this.customPickList77;
} |
f04fd798-e3e3-471a-98d5-21fa793a620d | public void setAssetSerialNumber(crmondemand.xml.contact.query.QueryType assetSerialNumber) {
this.assetSerialNumber = assetSerialNumber;
} |
77ac4ffe-69fd-4b81-bafc-ce67eac207a0 | public java.lang.Boolean getCustomBoolean19() {
return this.customBoolean19;
} |
59589870-7337-40a5-bdcc-019055478c56 | public JLabel getjLabel7() {
return jLabel7;
} |
855494bf-b48e-4547-a5ac-804f8e4bd838 | public void setUpdatedByExternalSystemId(crmondemand.xml.contact.query.QueryType updatedByExternalSystemId) {
this.updatedByExternalSystemId = updatedByExternalSystemId;
} |
9f31d1e2-8883-4294-8ec9-c6a7d4c20a58 | private void painelConsultarVenda() {
painelConsultarVenda = new JPanel();
painelConsultarVenda.setBorder(BorderFactory.createTitledBorder("Consultar vendas"));
painelConsultarVenda.setLayout(new GridBagLayout());
painelConsultarVenda.setSize(new Dimension(500, 500));
this.add(BorderLayout.BEFORE_FIRST_LINE, painelConsultarVenda);
GridBagConstraints gridConsultaVendas = new GridBagConstraints();
gridConsultaVendas.insets = new Insets(4, 4, 4, 4);
gridConsultaVendas.gridx = 0;
gridConsultaVendas.gridy = 0;
JLabel dataDasVendasLabel = new JLabel("Data das vendas");
painelConsultarVenda.add(dataDasVendasLabel, gridConsultaVendas);
gridConsultaVendas.gridx = 1;
gridConsultaVendas.gridy = 0;
dataVendasText = new JTextField(15);
painelConsultarVenda.add(dataVendasText, gridConsultaVendas);
gridConsultaVendas.gridx = 2;
gridConsultaVendas.gridy = 0;
consultarVenda = new JButton("Consultar");
consultarVenda.addActionListener(this);
painelConsultarVenda.add(consultarVenda, gridConsultaVendas);
gridConsultaVendas.gridx = 1;
gridConsultaVendas.gridy = 1;
botaoVoltarConsultarVenda = new JButton("Voltar...");
botaoVoltarConsultarVenda.addActionListener(this);
painelConsultarVenda.add(botaoVoltarConsultarVenda, gridConsultaVendas);
painelConsultarVenda.setVisible(true);
} |
08116747-29c1-40e3-ae04-07b574583c07 | opcode op_1e = new opcode() { public void handler()/* LD E,n */
{
//_E = ARG();
Z80.DE.SetL(ARG() & 0xFF);
}} |
f72b7b2f-311b-402c-a4fc-b076619e4d49 | public void setCustomDate10(java.util.Calendar customDate10) {
this.customDate10 = customDate10;
} |
94264a81-90b2-4770-b3d7-269f265ea79c | private boolean jj_3_70() {
if (jj_3R_47()) return true;
return false;
} |
1cc27627-2357-425d-9366-d2791644dfa3 | public void setCustomPickList7(crmondemand.xml.contact.query.QueryType customPickList7) {
this.customPickList7 = customPickList7;
} |
90eb3564-b72a-45e7-be85-b5c80a920e1a | public void setAssetProduct(java.lang.String assetProduct) {
this.assetProduct = assetProduct;
} |
1d15067f-f4e8-43c6-ad0c-1ea3b33cff78 | public java.lang.String getCurrencyCode() {
return this.currencyCode;
} |
44d7f3a2-313f-43f1-9bd8-0625c38c6a35 | public void setCustomBoolean6(crmondemand.xml.contact.query.QueryType customBoolean6) {
this.customBoolean6 = customBoolean6;
} |
b5744c21-9a1c-419b-9231-79efb2135ad6 | public java.util.Calendar getCustomDate55() {
return this.customDate55;
} |
1c8171de-0aa8-4706-99fe-9ae46db81c09 | private void DecodeLogicalInstruct(){
getOPCODE().set(getStrSwitches().substring(0,6));;
getRF().set(getStrSwitches().substring(8,10));
getI().set(getStrSwitches().substring(10,11));
getT().set(getStrSwitches().substring(11,12));
getCOUNT().set(getStrSwitches().substring(15,20));
} |
8ed9667b-f381-4add-8ac9-13ecd7f2bdb6 | public java.util.List<? extends com.google.protobuf.DescriptorProtos.UninterpretedOptionOrBuilder>
getUninterpretedOptionOrBuilderList() {
if (uninterpretedOptionBuilder_ != null) {
return uninterpretedOptionBuilder_.getMessageOrBuilderList();
} else {
return java.util.Collections.unmodifiableList(uninterpretedOption_);
}
} |
38bfaaf7-46f1-4aa2-9952-74afb19d01af | public void setTransactionName(java.lang.String transactionName) {
this.transactionName = transactionName;
} |
f69d4c04-b47c-4a46-846c-72337a2ba0f3 | public void setCustomPickList97(crmondemand.xml.customobject6.query.QueryType customPickList97) {
this.customPickList97 = customPickList97;
} |
23a4b53a-0373-4ee6-8b09-15392d907383 | @Override
public void widgetSelected(SelectionEvent e) {
gotoTime();
} |
e540f1aa-0678-4bdd-8cd3-3e096d156be6 | public crmondemand.xml.customobject6.query.QueryType getCustomPickList95() {
return this.customPickList95;
} |
f05aef1d-3118-4760-9a1a-52ee32601d39 | public void setCustomCurrency2(crmondemand.xml.contact.query.QueryType customCurrency2) {
this.customCurrency2 = customCurrency2;
} |
01790484-8336-421c-9340-420b5c91588f | @Override
public void primitiveOperation2() {
System.out.println("ConcreteClassA.primitiveOperation2()");
} |
07f3384b-934d-43a1-99ea-c0cd77327dc3 | public void setCustomNumber3(java.math.BigDecimal customNumber3) {
this.customNumber3 = customNumber3;
} |
c8a96433-5a6d-4847-a1d0-d096885c91f7 | public java.lang.String getOwnerFirstName() {
return this.ownerFirstName;
} |
061defef-dbae-4095-894c-5f25417abc78 | void send(String request)
{
// request : [USER], [ROOM]
Message m=null;
if(request.equals("[USER]"))
{
m=new Message(roomid, //int roomid
Msg.user, //int msgtype
"USERLIST", //String room
UserSetting.username, //String sendUserName
request, //String msg
""); //String remark
}
else if(request.equals("[ROOM]"))
{
m=new Message(roomid, //int roomid
Msg.user, //int msgtype
"ROOMLIST", //String room
UserSetting.username, //String sendUserName
request, //String msg
""); //String remark
}
write(m);
} |
7f2a49ba-609e-4eaa-81cd-c7cc072d751b | opcode fd_a1 = new opcode() { public void handler(){ illegal_1(); }} |
e9240079-a198-4419-81d2-0d62807c3c86 | public crmondemand.xml.customobject6.query.QueryType getZCustomNumber55() {
return this.zCustomNumber55;
} |
ab6f5423-d5fe-4df4-a11f-0351cc7ac2ef | public java.math.BigDecimal getCustomNumber15() {
return this.customNumber15;
} |
8786704a-dd09-4f8d-9fe7-dde922743621 | public crmondemand.xml.contact.query.QueryType getCustomObject2Type() {
return this.customObject2Type;
} |
11f7aa2a-4170-4810-8978-45a5d8771503 | public java.lang.String getCustomObject1Id() {
return this.customObject1Id;
} |
4a0ca6c2-2d5f-4406-b528-b616c52ad3bf | public void setCustomPickList45(crmondemand.xml.customobject3.query.QueryType customPickList45) {
this.customPickList45 = customPickList45;
} |
50923b89-0c8a-4a8c-9041-2e370724c471 | public void setProductCategoryName(crmondemand.xml.customobject6.query.QueryType productCategoryName) {
this.productCategoryName = productCategoryName;
} |
6e0f0528-3553-4cd7-b105-76084dbad7c0 | * otherwise.
*/
public boolean onScreen(Tile tileToCheck) {
if (tileToCheck == null)
return false;
repositionMapIfNeeded();
return tileToCheck.getY() - 2 > topRow
&& tileToCheck.getY() + 4 < bottomRow
&& tileToCheck.getX() - 1 > leftColumn
&& tileToCheck.getX() + 2 < rightColumn;
} |
04f1cb7b-6abc-423b-9d74-dbcb9ee88a18 | public crmondemand.xml.customobject3.query.QueryType getCustomText66() {
return this.customText66;
} |
e8a23ea1-6929-433c-b01c-895625bc2405 | public void setCustomPhone17(java.lang.String customPhone17) {
this.customPhone17 = customPhone17;
} |
77f0208f-462a-4eb3-bcb4-daab89ac289b | public java.lang.String getOwnerExternalSystemId() {
return this.ownerExternalSystemId;
} |
69251dd0-292b-4066-a1cc-1c3b135cd94d | public void setDealerStatus(java.lang.String dealerStatus) {
this.dealerStatus = dealerStatus;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.