00001: // ===========================================================================
00002: // This file has been generated by
00003: // Typical, version 1.13.2,
00004: // (C) 2004-2007 Robert Grimm and New York University,
00005: // on Saturday, December 1, 2007 at 1:00:08 PM.
00006: // Edit at your own risk.
00007: // ===========================================================================
00008:
00009: package xtc.lang.c;
00010:
00011: import java.math.BigInteger;
00012:
00013: import java.util.List;
00014: import java.util.ArrayList;
00015:
00016: import xtc.util.Pair;
00017: import xtc.util.Runtime;
00018: import xtc.util.Function;
00019:
00020: import xtc.tree.Node;
00021: import xtc.tree.GNode;
00022:
00023: import xtc.typical.Analyzer;
00024: import xtc.typical.Primitives;
00025: import xtc.typical.Tuple;
00026: import xtc.typical.Reduction;
00027: import xtc.typical.Name;
00028: import xtc.typical.Scope;
00029: import xtc.typical.ScopeKind;
00030:
00031: /** Type checker for C. */
00032: public class CAnalyzer extends Analyzer {
00033: public CAnalyzer(Runtime runt) {
00034: super (runt);
00035: analyzer = analyze;
00036: }
00037:
00038: public void getScopeNodes() {
00039: processScopeNodes.add("FunctionDeclarator");
00040: processScopeNodes.add("FunctionDefinition");
00041: processScopeNodes.add("FunctionDeclarator");
00042: processScopeNodes.add("ForStatement");
00043: processScopeNodes.add("ForStatement");
00044: processScopeNodes.add("CompoundStatement");
00045: }
00046:
00047: final Function.F1<Tuple.T3<Name, String, String>, Node> getNameSpace = new Function.F1<Tuple.T3<Name, String, String>, Node>() {
00048: public Tuple.T3<Name, String, String> apply(final Node n) {
00049: return new Match<Tuple.T3<Name, String, String>>() {
00050: public Tuple.T3<Name, String, String> apply() {
00051: final Node arg$0 = GNode.cast(n);
00052:
00053: if ((null == arg$0)) {
00054: return null;
00055: }
00056: if (CSupport.match$1(arg$0)) {
00057: final String s = (arg$0.size() > 0 ? arg$0
00058: .getString(0) : null);
00059:
00060: matching_nodes.add(arg$0);
00061: if ((null != arg$0 && processScopeNodes
00062: .contains(arg$0.getName()))) {
00063: processScope(arg$0, getScope);
00064: }
00065: checkEnterScope(arg$0);
00066:
00067: final Object retValue$4 = Analyzer
00068: .cast(new Tuple.T3<Name, String, String>(
00069: new Name.SimpleName(s),
00070: "ordinary", "type"));
00071:
00072: checkExitScope(arg$0);
00073: matching_nodes
00074: .remove(matching_nodes.size() - 1);
00075: return Analyzer.cast(retValue$4);
00076: }
00077: if (CSupport.match$5(arg$0)) {
00078: final String s = (arg$0.size() > 0 ? arg$0
00079: .getString(0) : null);
00080:
00081: matching_nodes.add(arg$0);
00082: if ((null != arg$0 && processScopeNodes
00083: .contains(arg$0.getName()))) {
00084: processScope(arg$0, getScope);
00085: }
00086: checkEnterScope(arg$0);
00087:
00088: final Object retValue$8 = Analyzer
00089: .cast(new Tuple.T3<Name, String, String>(
00090: new Name.SimpleName(s),
00091: "ordinary", "type"));
00092:
00093: checkExitScope(arg$0);
00094: matching_nodes
00095: .remove(matching_nodes.size() - 1);
00096: return Analyzer.cast(retValue$8);
00097: }
00098: if (CSupport.match$9(arg$0)) {
00099: final Node b = (arg$0.size() > 1 ? arg$0
00100: .getGeneric(1) : null);
00101:
00102: matching_nodes.add(arg$0);
00103: if ((null != arg$0 && processScopeNodes
00104: .contains(arg$0.getName()))) {
00105: processScope(arg$0, getScope);
00106: }
00107: checkEnterScope(arg$0);
00108:
00109: final Object retValue$12 = Analyzer
00110: .cast(new Tuple.T3<Name, String, String>(
00111: new Name.SimpleName(
00112: get_id_declarator
00113: .apply(b)),
00114: "ordinary", "type"));
00115:
00116: checkExitScope(arg$0);
00117: matching_nodes
00118: .remove(matching_nodes.size() - 1);
00119: return Analyzer.cast(retValue$12);
00120: }
00121: if (CSupport.match$13(arg$0)) {
00122: final Node a = (arg$0.size() > 0 ? arg$0
00123: .getGeneric(0) : null);
00124:
00125: matching_nodes.add(arg$0);
00126: if ((null != arg$0 && processScopeNodes
00127: .contains(arg$0.getName()))) {
00128: processScope(arg$0, getScope);
00129: }
00130: checkEnterScope(arg$0);
00131:
00132: final Object retValue$16 = Analyzer
00133: .cast(new Tuple.T3<Name, String, String>(
00134: new Name.SimpleName(
00135: get_id_declarator
00136: .apply(a)),
00137: "ordinary", "type"));
00138:
00139: checkExitScope(arg$0);
00140: matching_nodes
00141: .remove(matching_nodes.size() - 1);
00142: return Analyzer.cast(retValue$16);
00143: }
00144: if (CSupport.match$17(arg$0)) {
00145: final Node a = (arg$0.size() > 0 ? arg$0
00146: .getGeneric(0) : null);
00147:
00148: matching_nodes.add(arg$0);
00149: if ((null != arg$0 && processScopeNodes
00150: .contains(arg$0.getName()))) {
00151: processScope(arg$0, getScope);
00152: }
00153: checkEnterScope(arg$0);
00154:
00155: final Object retValue$20 = Analyzer
00156: .cast(new Tuple.T3<Name, String, String>(
00157: new Name.SimpleName(
00158: get_id_declarator
00159: .apply(a)),
00160: "ordinary", "type"));
00161:
00162: checkExitScope(arg$0);
00163: matching_nodes
00164: .remove(matching_nodes.size() - 1);
00165: return Analyzer.cast(retValue$20);
00166: }
00167: if (CSupport.match$21(arg$0)) {
00168: final String s = (arg$0.size() > 0 ? arg$0
00169: .getString(0) : null);
00170:
00171: matching_nodes.add(arg$0);
00172: if ((null != arg$0 && processScopeNodes
00173: .contains(arg$0.getName()))) {
00174: processScope(arg$0, getScope);
00175: }
00176: checkEnterScope(arg$0);
00177:
00178: final Object retValue$24 = Analyzer
00179: .cast(new Tuple.T3<Name, String, String>(
00180: new Name.SimpleName(s),
00181: "ordinary", "type"));
00182:
00183: checkExitScope(arg$0);
00184: matching_nodes
00185: .remove(matching_nodes.size() - 1);
00186: return Analyzer.cast(retValue$24);
00187: }
00188: if (CSupport.match$25(arg$0)) {
00189: final String s = (arg$0.size() > 0 ? arg$0
00190: .getString(0) : null);
00191:
00192: matching_nodes.add(arg$0);
00193: if ((null != arg$0 && processScopeNodes
00194: .contains(arg$0.getName()))) {
00195: processScope(arg$0, getScope);
00196: }
00197: checkEnterScope(arg$0);
00198:
00199: final Object retValue$28 = Analyzer
00200: .cast(new Tuple.T3<Name, String, String>(
00201: new Name.SimpleName(s),
00202: "ordinary", "type"));
00203:
00204: checkExitScope(arg$0);
00205: matching_nodes
00206: .remove(matching_nodes.size() - 1);
00207: return Analyzer.cast(retValue$28);
00208: }
00209: if (CSupport.match$29(arg$0)) {
00210: final String s = (arg$0.getGeneric(0).size() > 0 ? arg$0
00211: .getGeneric(0).getString(0)
00212: : null);
00213:
00214: matching_nodes.add(arg$0);
00215: if ((null != arg$0 && processScopeNodes
00216: .contains(arg$0.getName()))) {
00217: processScope(arg$0, getScope);
00218: }
00219: checkEnterScope(arg$0);
00220:
00221: List<Node> listName$31 = new ArrayList<Node>();
00222: Node nodeName$30 = arg$0;
00223:
00224: nodeName$30 = nodeName$30.getGeneric(0);
00225: if ((null != nodeName$30 && processScopeNodes
00226: .contains(nodeName$30.getName()))) {
00227: processScope(nodeName$30, getScope);
00228: }
00229: checkEnterScope(nodeName$30);
00230: listName$31.add(0, nodeName$30);
00231:
00232: final Object retValue$32 = Analyzer
00233: .cast(new Tuple.T3<Name, String, String>(
00234: new Name.SimpleName(s),
00235: "label", "type"));
00236:
00237: for (Node no : listName$31) {
00238: checkExitScope(no);
00239: }
00240: checkExitScope(arg$0);
00241: matching_nodes
00242: .remove(matching_nodes.size() - 1);
00243: return Analyzer.cast(retValue$32);
00244: }
00245: if (CSupport.match$33(arg$0)) {
00246: final String s = (arg$0.size() > 0 ? arg$0
00247: .getString(0) : null);
00248:
00249: matching_nodes.add(arg$0);
00250: if ((null != arg$0 && processScopeNodes
00251: .contains(arg$0.getName()))) {
00252: processScope(arg$0, getScope);
00253: }
00254: checkEnterScope(arg$0);
00255:
00256: final Object retValue$36 = Analyzer
00257: .cast(new Tuple.T3<Name, String, String>(
00258: new Name.SimpleName(s),
00259: "label", "type"));
00260:
00261: checkExitScope(arg$0);
00262: matching_nodes
00263: .remove(matching_nodes.size() - 1);
00264: return Analyzer.cast(retValue$36);
00265: }
00266: if (CSupport.match$37(arg$0)) {
00267: final String s = (arg$0.size() > 0 ? arg$0
00268: .getString(0) : null);
00269:
00270: matching_nodes.add(arg$0);
00271: if ((null != arg$0 && processScopeNodes
00272: .contains(arg$0.getName()))) {
00273: processScope(arg$0, getScope);
00274: }
00275: checkEnterScope(arg$0);
00276:
00277: final Object retValue$40 = Analyzer
00278: .cast(new Tuple.T3<Name, String, String>(
00279: new Name.SimpleName(s),
00280: "label", "type"));
00281:
00282: checkExitScope(arg$0);
00283: matching_nodes
00284: .remove(matching_nodes.size() - 1);
00285: return Analyzer.cast(retValue$40);
00286: }
00287: if (CSupport.match$41(arg$0)) {
00288: matching_nodes.add(arg$0);
00289: if ((null != arg$0 && processScopeNodes
00290: .contains(arg$0.getName()))) {
00291: processScope(arg$0, getScope);
00292: }
00293: checkEnterScope(arg$0);
00294:
00295: final Object retValue$44 = Analyzer
00296: .cast(new Tuple.T3<Name, String, String>(
00297: new Name.SimpleName("default"),
00298: "label", "type"));
00299:
00300: checkExitScope(arg$0);
00301: matching_nodes
00302: .remove(matching_nodes.size() - 1);
00303: return Analyzer.cast(retValue$44);
00304: }
00305: if (CSupport.match$45(arg$0)) {
00306: final String s = (arg$0.getGeneric(1).size() > 0 ? arg$0
00307: .getGeneric(1).getString(0)
00308: : null);
00309:
00310: matching_nodes.add(arg$0);
00311: if ((null != arg$0 && processScopeNodes
00312: .contains(arg$0.getName()))) {
00313: processScope(arg$0, getScope);
00314: }
00315: checkEnterScope(arg$0);
00316:
00317: List<Node> listName$47 = new ArrayList<Node>();
00318: Node nodeName$46 = arg$0;
00319:
00320: nodeName$46 = nodeName$46.getGeneric(1);
00321: if ((null != nodeName$46 && processScopeNodes
00322: .contains(nodeName$46.getName()))) {
00323: processScope(nodeName$46, getScope);
00324: }
00325: checkEnterScope(nodeName$46);
00326: listName$47.add(0, nodeName$46);
00327:
00328: final Object retValue$48 = Analyzer
00329: .cast(new Tuple.T3<Name, String, String>(
00330: new Name.SimpleName(s),
00331: "label", "type"));
00332:
00333: for (Node no : listName$47) {
00334: checkExitScope(no);
00335: }
00336: checkExitScope(arg$0);
00337: matching_nodes
00338: .remove(matching_nodes.size() - 1);
00339: return Analyzer.cast(retValue$48);
00340: }
00341: if (CSupport.match$49(arg$0)) {
00342: final String s = (arg$0.size() > 1 ? arg$0
00343: .getString(1) : null);
00344:
00345: matching_nodes.add(arg$0);
00346: if ((null != arg$0 && processScopeNodes
00347: .contains(arg$0.getName()))) {
00348: processScope(arg$0, getScope);
00349: }
00350: checkEnterScope(arg$0);
00351:
00352: final Object retValue$52 = Analyzer
00353: .cast(new Tuple.T3<Name, String, String>(
00354: new Name.SimpleName(s), "tag",
00355: "type"));
00356:
00357: checkExitScope(arg$0);
00358: matching_nodes
00359: .remove(matching_nodes.size() - 1);
00360: return Analyzer.cast(retValue$52);
00361: }
00362: if (CSupport.match$53(arg$0)) {
00363: final String s = (arg$0.size() > 1 ? arg$0
00364: .getString(1) : null);
00365:
00366: matching_nodes.add(arg$0);
00367: if ((null != arg$0 && processScopeNodes
00368: .contains(arg$0.getName()))) {
00369: processScope(arg$0, getScope);
00370: }
00371: checkEnterScope(arg$0);
00372:
00373: final Object retValue$56 = Analyzer
00374: .cast(new Tuple.T3<Name, String, String>(
00375: new Name.SimpleName(s), "tag",
00376: "type"));
00377:
00378: checkExitScope(arg$0);
00379: matching_nodes
00380: .remove(matching_nodes.size() - 1);
00381: return Analyzer.cast(retValue$56);
00382: }
00383: if (CSupport.match$57(arg$0)) {
00384: final String s = (arg$0.size() > 1 ? arg$0
00385: .getString(1) : null);
00386:
00387: matching_nodes.add(arg$0);
00388: if ((null != arg$0 && processScopeNodes
00389: .contains(arg$0.getName()))) {
00390: processScope(arg$0, getScope);
00391: }
00392: checkEnterScope(arg$0);
00393:
00394: final Object retValue$60 = Analyzer
00395: .cast(new Tuple.T3<Name, String, String>(
00396: new Name.SimpleName(s), "tag",
00397: "type"));
00398:
00399: checkExitScope(arg$0);
00400: matching_nodes
00401: .remove(matching_nodes.size() - 1);
00402: return Analyzer.cast(retValue$60);
00403: }
00404: if (CSupport.match$61(arg$0)) {
00405: final String s = (arg$0.size() > 1 ? arg$0
00406: .getString(1) : null);
00407:
00408: matching_nodes.add(arg$0);
00409: if ((null != arg$0 && processScopeNodes
00410: .contains(arg$0.getName()))) {
00411: processScope(arg$0, getScope);
00412: }
00413: checkEnterScope(arg$0);
00414:
00415: final Object retValue$64 = Analyzer
00416: .cast(new Tuple.T3<Name, String, String>(
00417: new Name.SimpleName(s), "tag",
00418: "type"));
00419:
00420: checkExitScope(arg$0);
00421: matching_nodes
00422: .remove(matching_nodes.size() - 1);
00423: return Analyzer.cast(retValue$64);
00424: }
00425: if (CSupport.match$65(arg$0)) {
00426: final Node b = (arg$0.size() > 1 ? arg$0
00427: .getGeneric(1) : null);
00428:
00429: matching_nodes.add(arg$0);
00430: if ((null != arg$0 && processScopeNodes
00431: .contains(arg$0.getName()))) {
00432: processScope(arg$0, getScope);
00433: }
00434: checkEnterScope(arg$0);
00435:
00436: final Object retValue$68 = Analyzer
00437: .cast(new Tuple.T3<Name, String, String>(
00438: new Name.SimpleName(
00439: get_id_declarator
00440: .apply(b)),
00441: "member", "type"));
00442:
00443: checkExitScope(arg$0);
00444: matching_nodes
00445: .remove(matching_nodes.size() - 1);
00446: return Analyzer.cast(retValue$68);
00447: }
00448: if (CSupport.match$69(arg$0)) {
00449: final String s = (arg$0.size() > 1 ? arg$0
00450: .getString(1) : null);
00451:
00452: matching_nodes.add(arg$0);
00453: if ((null != arg$0 && processScopeNodes
00454: .contains(arg$0.getName()))) {
00455: processScope(arg$0, getScope);
00456: }
00457: checkEnterScope(arg$0);
00458:
00459: final Object retValue$72 = Analyzer
00460: .cast(new Tuple.T3<Name, String, String>(
00461: new Name.SimpleName(s),
00462: "member", "type"));
00463:
00464: checkExitScope(arg$0);
00465: matching_nodes
00466: .remove(matching_nodes.size() - 1);
00467: return Analyzer.cast(retValue$72);
00468: }
00469: return null;
00470: }
00471: }.apply();
00472: }
00473: };
00474:
00475: final CTypes.type voidt = Analyzer.cast(new CTypes.type(
00476: new CTypes.VoidT(), null, null, null, null, null, null,
00477: null, null, null, null));
00478:
00479: final Function.F1<Scope, Node> getScope = new Function.F1<Scope, Node>() {
00480: public Scope apply(final Node n) {
00481: if (CSupport.match$78(n)) {
00482: final String id = (n.getGeneric(0).size() > 0 ? n
00483: .getGeneric(0).getString(0) : null);
00484: final Node params = (n.size() > 1 ? n.getGeneric(1)
00485: : null);
00486:
00487: if (Primitives.and.apply(Primitives.isNotBottom
00488: .apply(ancestor.apply(CSupport.nodeMatch$75)),
00489: Primitives.isBottom.apply(ancestor
00490: .apply(CSupport.nodeMatch$77)))) {
00491: return new Scope(new ScopeKind.Named(
00492: new Name.SimpleName(id)), new Pair<Node>(
00493: params));
00494: }
00495: }
00496: if (CSupport.match$79(n)) {
00497: final Node decl = (n.size() > 2 ? n.getGeneric(2)
00498: : null);
00499: final Node defs = (n.size() > 3 ? n.getGeneric(3)
00500: : null);
00501: final Node cs = (n.size() > 4 ? n.getGeneric(4) : null);
00502:
00503: return Analyzer.cast(new Scope(new ScopeKind.Named(
00504: new Name.SimpleName(get_id_declarator
00505: .apply(decl))), new Pair<Node>(defs)
00506: .append(new Pair<Node>(cs))));
00507: }
00508: if (CSupport.match$17(n)) {
00509: final Node decl = (n.size() > 0 ? n.getGeneric(0)
00510: : null);
00511: final Node params = (n.size() > 1 ? n.getGeneric(1)
00512: : null);
00513:
00514: return Analyzer.cast(new Scope(new ScopeKind.Temporary(
00515: get_id_declarator.apply(decl)), new Pair<Node>(
00516: params)));
00517: }
00518: if (CSupport.match$81(n)) {
00519: final Node a = Analyzer.cast(n.getGeneric(0));
00520: final Node b = (n.size() > 1 ? n.getGeneric(1) : null);
00521: final Node c = (n.size() > 2 ? n.getGeneric(2) : null);
00522: final Node d = (n.size() > 3 ? n.getGeneric(3) : null);
00523:
00524: return Analyzer.cast(new Scope(new ScopeKind.Anonymous(
00525: "for"), new Pair<Node>(a).append(
00526: new Pair<Node>(b)).append(new Pair<Node>(c))
00527: .append(new Pair<Node>(d))));
00528: }
00529: if (CSupport.match$82(n)) {
00530: final Node b = (n.size() > 1 ? n.getGeneric(1) : null);
00531: final Node c = (n.size() > 2 ? n.getGeneric(2) : null);
00532: final Node d = (n.size() > 3 ? n.getGeneric(3) : null);
00533:
00534: return Analyzer.cast(new Scope(new ScopeKind.Anonymous(
00535: "for"), new Pair<Node>(b).append(
00536: new Pair<Node>(c)).append(new Pair<Node>(d))));
00537: }
00538: if (CSupport.match$83(n)) {
00539: final Node cs = Analyzer.cast(n);
00540:
00541: return Analyzer.cast(new Scope(new ScopeKind.Anonymous(
00542: "block"), new Pair<Node>(cs)));
00543: }
00544: return null;
00545: }
00546: };
00547:
00548: final Function.F1<CTypes.type, Pair<Node>> extractType = new Function.F1<CTypes.type, Pair<Node>>() {
00549: public CTypes.type apply(final Pair<Node> lst) {
00550: return Analyzer.cast(new Reduction(lst, runtime,
00551: matching_nodes.get(matching_nodes.size() - 1)) {
00552: {
00553: setSing();
00554: setTag("type");
00555:
00556: {
00557: addPattern(new CTypes.type(
00558: new CTypes.ULongLongT(), null, null,
00559: null, null, null, null, null, null,
00560: null, null), CSupport.nodeMatch$86,
00561: CSupport.nodeMatch$88,
00562: CSupport.nodeMatch$88,
00563: CSupport.nodeMatch$91);
00564: }
00565:
00566: {
00567: addPattern(new CTypes.type(
00568: new CTypes.ULongLongT(), null, null,
00569: null, null, null, null, null, null,
00570: null, null), CSupport.nodeMatch$86,
00571: CSupport.nodeMatch$88,
00572: CSupport.nodeMatch$88);
00573: }
00574:
00575: {
00576: addPattern(new CTypes.type(
00577: new CTypes.LongLongT(), null, null,
00578: null, null, null, null, null, null,
00579: null, null), CSupport.nodeMatch$96,
00580: CSupport.nodeMatch$88,
00581: CSupport.nodeMatch$88,
00582: CSupport.nodeMatch$91);
00583: }
00584:
00585: {
00586: addPattern(new CTypes.type(
00587: new CTypes.LongLongT(), null, null,
00588: null, null, null, null, null, null,
00589: null, null), CSupport.nodeMatch$96,
00590: CSupport.nodeMatch$88,
00591: CSupport.nodeMatch$88);
00592: }
00593:
00594: {
00595: addPattern(new CTypes.type(new CTypes.ULongT(),
00596: null, null, null, null, null, null,
00597: null, null, null, null),
00598: CSupport.nodeMatch$86,
00599: CSupport.nodeMatch$88,
00600: CSupport.nodeMatch$91);
00601: }
00602:
00603: {
00604: addPattern(new CTypes.type(new CTypes.LongT(),
00605: null, null, null, null, null, null,
00606: null, null, null, null),
00607: CSupport.nodeMatch$96,
00608: CSupport.nodeMatch$88,
00609: CSupport.nodeMatch$91);
00610: }
00611:
00612: {
00613: addPattern(new CTypes.type(new CTypes.ShortT(),
00614: null, null, null, null, null, null,
00615: null, null, null, null),
00616: CSupport.nodeMatch$96,
00617: CSupport.nodeMatch$111,
00618: CSupport.nodeMatch$91);
00619: }
00620:
00621: {
00622: addPattern(new CTypes.type(
00623: new CTypes.UShortT(), null, null, null,
00624: null, null, null, null, null, null,
00625: null), CSupport.nodeMatch$86,
00626: CSupport.nodeMatch$111,
00627: CSupport.nodeMatch$91);
00628: }
00629:
00630: {
00631: addPattern(new CTypes.type(
00632: new CTypes.LongDoubleComplexT(), null,
00633: null, null, null, null, null, null,
00634: null, null, null),
00635: CSupport.nodeMatch$88,
00636: CSupport.nodeMatch$118,
00637: CSupport.nodeMatch$120);
00638: }
00639:
00640: {
00641: addPattern(new CTypes.type(
00642: new CTypes.LongLongT(), null, null,
00643: null, null, null, null, null, null,
00644: null, null), CSupport.nodeMatch$88,
00645: CSupport.nodeMatch$88,
00646: CSupport.nodeMatch$91);
00647: }
00648:
00649: {
00650: addPattern(new CTypes.type(new CTypes.ULongT(),
00651: null, null, null, null, null, null,
00652: null, null, null, null),
00653: CSupport.nodeMatch$86,
00654: CSupport.nodeMatch$88);
00655: }
00656:
00657: {
00658: addPattern(new CTypes.type(new CTypes.ShortT(),
00659: null, null, null, null, null, null,
00660: null, null, null, null),
00661: CSupport.nodeMatch$96,
00662: CSupport.nodeMatch$111);
00663: }
00664:
00665: {
00666: addPattern(new CTypes.type(new CTypes.ShortT(),
00667: null, null, null, null, null, null,
00668: null, null, null, null),
00669: CSupport.nodeMatch$111,
00670: CSupport.nodeMatch$91);
00671: }
00672:
00673: {
00674: addPattern(new CTypes.type(
00675: new CTypes.UShortT(), null, null, null,
00676: null, null, null, null, null, null,
00677: null), CSupport.nodeMatch$86,
00678: CSupport.nodeMatch$111);
00679: }
00680:
00681: {
00682: addPattern(new CTypes.type(new CTypes.SCharT(),
00683: null, null, null, null, null, null,
00684: null, null, null, null),
00685: CSupport.nodeMatch$96,
00686: CSupport.nodeMatch$134);
00687: }
00688:
00689: {
00690: addPattern(new CTypes.type(new CTypes.UCharT(),
00691: null, null, null, null, null, null,
00692: null, null, null, null),
00693: CSupport.nodeMatch$86,
00694: CSupport.nodeMatch$134);
00695: }
00696:
00697: {
00698: addPattern(new CTypes.type(
00699: new CTypes.FloatComplexT(), null, null,
00700: null, null, null, null, null, null,
00701: null, null), CSupport.nodeMatch$138,
00702: CSupport.nodeMatch$120);
00703: }
00704:
00705: {
00706: addPattern(new CTypes.type(
00707: new CTypes.DoubleComplexT(), null,
00708: null, null, null, null, null, null,
00709: null, null, null),
00710: CSupport.nodeMatch$118,
00711: CSupport.nodeMatch$120);
00712: }
00713:
00714: {
00715: addPattern(new CTypes.type(new CTypes.LongT(),
00716: null, null, null, null, null, null,
00717: null, null, null, null),
00718: CSupport.nodeMatch$96,
00719: CSupport.nodeMatch$88);
00720: }
00721:
00722: {
00723: addPattern(new CTypes.type(new CTypes.LongT(),
00724: null, null, null, null, null, null,
00725: null, null, null, null),
00726: CSupport.nodeMatch$88,
00727: CSupport.nodeMatch$91);
00728: }
00729:
00730: {
00731: addPattern(new CTypes.type(
00732: new CTypes.LongDoubleT(), null, null,
00733: null, null, null, null, null, null,
00734: null, null), CSupport.nodeMatch$88,
00735: CSupport.nodeMatch$118);
00736: }
00737:
00738: {
00739: addPattern(new CTypes.type(
00740: new CTypes.LongLongT(), null, null,
00741: null, null, null, null, null, null,
00742: null, null), CSupport.nodeMatch$88,
00743: CSupport.nodeMatch$88);
00744: }
00745:
00746: {
00747: addPattern(new CTypes.type(new CTypes.UIntT(),
00748: null, null, null, null, null, null,
00749: null, null, null, null),
00750: CSupport.nodeMatch$86,
00751: CSupport.nodeMatch$91);
00752: }
00753:
00754: {
00755: addPattern(new CTypes.type(new CTypes.IntT(),
00756: null, null, null, null, null, null,
00757: null, null, null, null),
00758: CSupport.nodeMatch$96,
00759: CSupport.nodeMatch$91);
00760: }
00761:
00762: {
00763: addPattern(new CTypes.type(new CTypes.UIntT(),
00764: null, null, null, null, null, null,
00765: null, null, null, null),
00766: CSupport.nodeMatch$86);
00767: }
00768:
00769: {
00770: addPattern(new CTypes.type(new CTypes.IntT(),
00771: null, null, null, null, null, null,
00772: null, null, null, null),
00773: CSupport.nodeMatch$96);
00774: }
00775:
00776: {
00777: addPattern(new CTypes.type(new CTypes.LongT(),
00778: null, null, null, null, null, null,
00779: null, null, null, null),
00780: CSupport.nodeMatch$88);
00781: }
00782:
00783: {
00784: addPattern(new CTypes.type(new CTypes.IntT(),
00785: null, null, null, null, null, null,
00786: null, null, null, null),
00787: CSupport.nodeMatch$91);
00788: }
00789:
00790: {
00791: addPattern(new CTypes.type(new CTypes.VoidT(),
00792: null, null, null, null, null, null,
00793: null, null, null, null),
00794: CSupport.nodeMatch$159);
00795: }
00796:
00797: {
00798: addPattern(new CTypes.type(new CTypes.CharT(),
00799: null, null, null, null, null, null,
00800: null, null, null, null),
00801: CSupport.nodeMatch$134);
00802: }
00803:
00804: {
00805: addPattern(new CTypes.type(new CTypes.FloatT(),
00806: null, null, null, null, null, null,
00807: null, null, null, null),
00808: CSupport.nodeMatch$138);
00809: }
00810:
00811: {
00812: addPattern(new CTypes.type(
00813: new CTypes.DoubleT(), null, null, null,
00814: null, null, null, null, null, null,
00815: null), CSupport.nodeMatch$118);
00816: }
00817:
00818: {
00819: addPattern(new CTypes.type(new CTypes.ShortT(),
00820: null, null, null, null, null, null,
00821: null, null, null, null),
00822: CSupport.nodeMatch$111);
00823: }
00824:
00825: {
00826: addPattern(new CTypes.type(new CTypes.BoolT(),
00827: null, null, null, null, null, null,
00828: null, null, null, null),
00829: CSupport.nodeMatch$165);
00830: }
00831:
00832: {
00833: addPattern(new CTypes.type(
00834: new CTypes.VarArgT(), null, null, null,
00835: null, null, null, null, null, null,
00836: null), CSupport.nodeMatch$167);
00837: }
00838:
00839: {
00840: Node me = getMatch(CSupport.nodeMatch$169);
00841:
00842: addPattern(analyze_decl_specifier.apply(me),
00843: CSupport.nodeMatch$169);
00844: }
00845:
00846: {
00847: Node me = getMatch(CSupport.nodeMatch$172);
00848:
00849: addPattern(analyze_decl_specifier.apply(me),
00850: CSupport.nodeMatch$172);
00851: }
00852:
00853: {
00854: Node me = getMatch(CSupport.nodeMatch$175);
00855:
00856: addPattern(analyze_decl_specifier.apply(me),
00857: CSupport.nodeMatch$175);
00858: }
00859:
00860: {
00861: Node me = getMatch(CSupport.nodeMatch$178);
00862:
00863: addPattern(analyze_decl_specifier.apply(me),
00864: CSupport.nodeMatch$178);
00865: }
00866:
00867: {
00868: Node me = getMatch(CSupport.nodeMatch$181);
00869:
00870: addPattern(analyze_decl_specifier.apply(me),
00871: CSupport.nodeMatch$181);
00872: }
00873:
00874: {
00875: Node me = getMatch(CSupport.nodeMatch$184);
00876:
00877: addPattern(analyze_decl_specifier.apply(me),
00878: CSupport.nodeMatch$184);
00879: }
00880:
00881: {
00882: Node me = getMatch(CSupport.nodeMatch$187);
00883:
00884: addPattern(analyze_decl_specifier.apply(me),
00885: CSupport.nodeMatch$187);
00886: }
00887:
00888: {
00889: Node me = getMatch(CSupport.nodeMatch$190);
00890:
00891: addPattern(analyze_decl_specifier.apply(me),
00892: CSupport.nodeMatch$190);
00893: }
00894: }
00895: }.apply());
00896: }
00897: };
00898:
00899: final Function.F1<CTypes.storageClass, Pair<Node>> extractStorage = new Function.F1<CTypes.storageClass, Pair<Node>>() {
00900: public CTypes.storageClass apply(final Pair<Node> lst) {
00901: return Analyzer.cast(new Reduction(lst, runtime,
00902: matching_nodes.get(matching_nodes.size() - 1)) {
00903: {
00904: setSing();
00905: setTag("storage class specifier");
00906:
00907: {
00908: addPattern(new CTypes.ExternS(),
00909: CSupport.nodeMatch$193);
00910: }
00911:
00912: {
00913: addPattern(new CTypes.RegisterS(),
00914: CSupport.nodeMatch$195);
00915: }
00916:
00917: {
00918: addPattern(new CTypes.StaticS(),
00919: CSupport.nodeMatch$197);
00920: }
00921:
00922: {
00923: addPattern(new CTypes.TypedefS(),
00924: CSupport.nodeMatch$199);
00925: }
00926:
00927: {
00928: addPattern(new CTypes.AutoS(),
00929: CSupport.nodeMatch$201);
00930: }
00931: }
00932: }.apply());
00933: }
00934: };
00935:
00936: final Function.F1<Pair<CTypes.qualifier>, Pair<Node>> extractQualifier = new Function.F1<Pair<CTypes.qualifier>, Pair<Node>>() {
00937: public Pair<CTypes.qualifier> apply(final Pair<Node> lst) {
00938: return Analyzer.cast(new Reduction(lst, runtime,
00939: matching_nodes.get(matching_nodes.size() - 1)) {
00940: {
00941: setList();
00942: setTag("qualifier");
00943:
00944: {
00945: addPattern(new CTypes.ConstQ(),
00946: CSupport.nodeMatch$203);
00947: }
00948:
00949: {
00950: addPattern(new CTypes.VolatileQ(),
00951: CSupport.nodeMatch$205);
00952: }
00953:
00954: {
00955: addPattern(new CTypes.RestrictQ(),
00956: CSupport.nodeMatch$207);
00957: }
00958: }
00959: }.apply());
00960: }
00961: };
00962:
00963: final Function.F1<CTypes.functionSpecifier, Pair<Node>> extractFunctionSpecifier = new Function.F1<CTypes.functionSpecifier, Pair<Node>>() {
00964: public CTypes.functionSpecifier apply(final Pair<Node> lst) {
00965: return Analyzer.cast(new Reduction(lst, runtime,
00966: matching_nodes.get(matching_nodes.size() - 1)) {
00967: {
00968: setSing();
00969: setTag("inline specifier");
00970:
00971: {
00972: addPattern(new CTypes.InlineF(),
00973: CSupport.nodeMatch$209);
00974: }
00975: }
00976: }.apply());
00977: }
00978: };
00979:
00980: final Function.F1<CTypes.type, Node> analyze = new Function.F1<CTypes.type, Node>() {
00981: public CTypes.type apply(final Node n) {
00982: return new Match<CTypes.type>() {
00983: public CTypes.type apply() {
00984: final Node arg$210 = GNode.cast(n);
00985:
00986: if ((null == arg$210)) {
00987: return null;
00988: }
00989: if (CSupport.match$211(arg$210)) {
00990: final Pair<Node> l = Analyzer
00991: .cast(Primitives.getChildren(arg$210,
00992: 0, arg$210.size()));
00993:
00994: matching_nodes.add(arg$210);
00995: if ((null != arg$210 && processScopeNodes
00996: .contains(arg$210.getName()))) {
00997: processScope(arg$210, getScope);
00998: }
00999: checkEnterScope(arg$210);
01000:
01001: final Object retValue$215 = Analyzer
01002: .cast(new Let<CTypes.type>() {
01003: {
01004: CSupport.map$212.apply(
01005: analyze_extern_decl, l);
01006: }
01007:
01008: public CTypes.type apply() {
01009: return Analyzer.cast(voidt);
01010: }
01011: }.apply());
01012:
01013: checkExitScope(arg$210);
01014: matching_nodes
01015: .remove(matching_nodes.size() - 1);
01016: if ((null != arg$210)) {
01017: arg$210.setProperty("__type", retValue$215);
01018: }
01019: return Analyzer.cast(retValue$215);
01020: }
01021: return null;
01022: }
01023: }.apply();
01024: }
01025: };
01026:
01027: final Function.F1<CTypes.type, Node> analyze_extern_decl = new Function.F1<CTypes.type, Node>() {
01028: public CTypes.type apply(final Node n) {
01029: return new Match<CTypes.type>() {
01030: public CTypes.type apply() {
01031: final Node arg$217 = GNode.cast(n);
01032:
01033: if ((null == arg$217)) {
01034: return null;
01035: }
01036: if (CSupport.match$218(arg$217)) {
01037: final Node specs = (arg$217.size() > 1 ? arg$217
01038: .getGeneric(1)
01039: : null);
01040: final Node idl = (arg$217.size() > 2 ? arg$217
01041: .getGeneric(2) : null);
01042:
01043: matching_nodes.add(arg$217);
01044: if ((null != arg$217 && processScopeNodes
01045: .contains(arg$217.getName()))) {
01046: processScope(arg$217, getScope);
01047: }
01048: checkEnterScope(arg$217);
01049:
01050: final Object retValue$221 = Analyzer
01051: .cast(new Let<CTypes.type>() {
01052: final CTypes.type t;
01053:
01054: {
01055: t = Analyzer
01056: .cast(analyze_decl_specifiers
01057: .apply(specs));
01058: }
01059:
01060: public CTypes.type apply() {
01061: return Analyzer
01062: .cast(null == Primitives.isBottom
01063: .apply(idl) ? null
01064: : Primitives.isBottom
01065: .apply(idl) ? new Let<CTypes.type>() {
01066: {
01067: Analyzer
01068: .discard(null == Primitives.isNotBottom
01069: .apply(null == t ? null
01070: : t.fSpec)
01071: || !Primitives.isNotBottom
01072: .apply(null == t ? null
01073: : t.fSpec) ? null
01074: : error(
01075: "'iniline in empty declaration",
01076: null));
01077: Analyzer
01078: .discard(null == Primitives.isNotBottom
01079: .apply(null == t ? null
01080: : t.storage)
01081: || !Primitives.isNotBottom
01082: .apply(null == t ? null
01083: : t.storage) ? null
01084: : warning(
01085: "'useless storage classes specifier in empty declaration",
01086: null));
01087: Analyzer
01088: .discard(null == is_qualified
01089: .apply(t)
01090: || !is_qualified
01091: .apply(t) ? null
01092: : warning(
01093: "'useless type qualifier in empty declaration",
01094: null));
01095: Analyzer
01096: .discard(null == Primitives.and
01097: .apply(
01098: Primitives.not
01099: .apply(is_struct_union
01100: .apply(t)),
01101: Primitives.not
01102: .apply(is_enum
01103: .apply(t)))
01104: || !Primitives.and
01105: .apply(
01106: Primitives.not
01107: .apply(is_struct_union
01108: .apply(t)),
01109: Primitives.not
01110: .apply(is_enum
01111: .apply(t))) ? null
01112: : warning(
01113: "declaration does not declare anything",
01114: null));
01115: }
01116:
01117: public CTypes.type apply() {
01118: return Analyzer
01119: .cast(voidt);
01120: }
01121: }.apply()
01122: : new Let<CTypes.type>() {
01123: {
01124: analyze_init_decl_list
01125: .apply(
01126: t,
01127: idl);
01128: }
01129:
01130: public CTypes.type apply() {
01131: return Analyzer
01132: .cast(voidt);
01133: }
01134: }
01135: .apply());
01136: }
01137: }.apply());
01138:
01139: checkExitScope(arg$217);
01140: matching_nodes
01141: .remove(matching_nodes.size() - 1);
01142: return Analyzer.cast(retValue$221);
01143: }
01144: if (CSupport.match$79(arg$217)) {
01145: final Node ds = (arg$217.size() > 1 ? arg$217
01146: .getGeneric(1) : null);
01147: final Node fd = (arg$217.size() > 2 ? arg$217
01148: .getGeneric(2) : null);
01149: final Node dl = (arg$217.size() > 3 ? arg$217
01150: .getGeneric(3) : null);
01151: final Node cs = (arg$217.size() > 4 ? arg$217
01152: .getGeneric(4) : null);
01153:
01154: matching_nodes.add(arg$217);
01155: if ((null != arg$217 && processScopeNodes
01156: .contains(arg$217.getName()))) {
01157: processScope(arg$217, getScope);
01158: }
01159: checkEnterScope(arg$217);
01160:
01161: final Object retValue$243 = Analyzer
01162: .cast(new Let<CTypes.type>() {
01163: final Pair<CTypes.label_record> lbl;
01164: final CTypes.type t;
01165: final String name;
01166: final CTypes.type cht;
01167: final CTypes.type fnt;
01168: final CTypes.type ft;
01169: final CTypes.type ret;
01170:
01171: {
01172: lbl = Analyzer
01173: .cast(find_labels
01174: .apply(
01175: cs,
01176: Pair
01177: .<CTypes.label_record> empty()));
01178: check_defined_labels.apply(lbl,
01179: cs);
01180: t = Analyzer
01181: .cast(null == Primitives.isBottom
01182: .apply(ds) ? null
01183: : Primitives.isBottom
01184: .apply(ds) ? new CTypes.type(
01185: new CTypes.IntT(),
01186: null,
01187: null,
01188: null,
01189: null,
01190: Boolean.TRUE,
01191: null,
01192: null,
01193: null,
01194: null,
01195: null)
01196: : analyze_decl_specifiers
01197: .apply(ds));
01198: name = Analyzer
01199: .cast(get_id_declarator
01200: .apply(fd));
01201: new Match<CTypes.type>() {
01202: public CTypes.type apply() {
01203: final Node arg$232 = GNode
01204: .cast(dl);
01205:
01206: if ((null == arg$232)) {
01207: return null;
01208: }
01209: if (CSupport
01210: .match$224(arg$232)) {
01211: final Pair<Node> dl = Analyzer
01212: .cast(Primitives
01213: .getChildren(
01214: arg$232,
01215: 0,
01216: arg$232
01217: .size()));
01218:
01219: matching_nodes
01220: .add(arg$232);
01221: if ((null != arg$232 && processScopeNodes
01222: .contains(arg$232
01223: .getName()))) {
01224: processScope(
01225: arg$232,
01226: getScope);
01227: }
01228: checkEnterScope(arg$232);
01229:
01230: final Object retValue$236 = Analyzer
01231: .cast(new Let<CTypes.type>() {
01232: {
01233: CSupport.map$212
01234: .apply(
01235: analyze_extern_decl,
01236: dl);
01237: }
01238:
01239: public CTypes.type apply() {
01240: return Analyzer
01241: .cast(voidt);
01242: }
01243: }.apply());
01244:
01245: checkExitScope(arg$232);
01246: matching_nodes
01247: .remove(matching_nodes
01248: .size() - 1);
01249: return Analyzer
01250: .cast(retValue$236);
01251: }
01252: if (true) {
01253: matching_nodes
01254: .add(arg$232);
01255: if ((null != arg$232 && processScopeNodes
01256: .contains(arg$232
01257: .getName()))) {
01258: processScope(
01259: arg$232,
01260: getScope);
01261: }
01262: checkEnterScope(arg$232);
01263:
01264: final Object retValue$239 = Analyzer
01265: .cast(null);
01266:
01267: checkExitScope(arg$232);
01268: matching_nodes
01269: .remove(matching_nodes
01270: .size() - 1);
01271: return Analyzer
01272: .cast(retValue$239);
01273: }
01274: return null;
01275: }
01276: }.apply();
01277: cht = Analyzer
01278: .cast(new CTypes.type(
01279: new CTypes.CharT(),
01280: null, null,
01281: null, null,
01282: null, null,
01283: null, null,
01284: null, null));
01285: fnt = Analyzer
01286: .cast(new CTypes.type(
01287: new CTypes.ArrayT(
01288: cht,
01289: new CTypes.Fixed(
01290: Primitives.ssize
01291: .apply(name))),
01292: null, null,
01293: null, null,
01294: null, null,
01295: null, null,
01296: null, null));
01297: define3.apply(GNode.create(
01298: "PrimaryIdentifier",
01299: "__func__"), fnt,
01300: getNameSpace);
01301: Analyzer
01302: .discard(null == has_auto
01303: .apply(t) ? null
01304: : has_auto
01305: .apply(t) ? error(
01306: "function definition declared 'auto'",
01307: null)
01308: : null == is_register
01309: .apply(t) ? null
01310: : is_register
01311: .apply(t) ? error(
01312: "function definition declared 'register'",
01313: null)
01314: : null == is_typedef
01315: .apply(t)
01316: || !is_typedef
01317: .apply(t) ? null
01318: : error(
01319: "function definition declared 'typedef",
01320: null));
01321: ft = Analyzer
01322: .cast(analyze_declarator
01323: .apply(t, fd));
01324: ret = Analyzer
01325: .cast(get_return_type
01326: .apply(ft));
01327: Analyzer
01328: .discard(null == Primitives.and
01329: .apply(
01330: Primitives.equal
01331: .apply(
01332: "main",
01333: name),
01334: Primitives.not
01335: .apply(Primitives.equal
01336: .apply(
01337: new CTypes.IntT(),
01338: null == ret ? null
01339: : ret.type)))
01340: || !Primitives.and
01341: .apply(
01342: Primitives.equal
01343: .apply(
01344: "main",
01345: name),
01346: Primitives.not
01347: .apply(Primitives.equal
01348: .apply(
01349: new CTypes.IntT(),
01350: null == ret ? null
01351: : ret.type))) ? null
01352: : warning(
01353: "return type of 'main' is not 'int' ",
01354: null));
01355: c_define
01356: .apply(
01357: fd,
01358: get_id_declarator
01359: .apply(fd),
01360: new CTypes.type(
01361: null == ft ? null
01362: : ft.type,
01363: null == ft ? null
01364: : ft.qualifiers,
01365: null == ft ? null
01366: : ft.storage,
01367: null == ft ? null
01368: : ft.fSpec,
01369: null == ft ? null
01370: : ft.value,
01371: null == ft ? null
01372: : ft.implicit,
01373: null == ft ? null
01374: : ft.initialised,
01375: n,
01376: null == ft ? null
01377: : ft.old_style,
01378: null == ft ? null
01379: : ft.var_args,
01380: null == ft ? null
01381: : ft.in_top));
01382: analyze_statement.apply(
01383: Boolean.TRUE, lbl,
01384: Boolean.FALSE, cs);
01385: }
01386:
01387: public CTypes.type apply() {
01388: return Analyzer.cast(voidt);
01389: }
01390: }.apply());
01391:
01392: checkExitScope(arg$217);
01393: matching_nodes
01394: .remove(matching_nodes.size() - 1);
01395: return Analyzer.cast(retValue$243);
01396: }
01397: if (CSupport.match$244(arg$217)) {
01398: matching_nodes.add(arg$217);
01399: if ((null != arg$217 && processScopeNodes
01400: .contains(arg$217.getName()))) {
01401: processScope(arg$217, getScope);
01402: }
01403: checkEnterScope(arg$217);
01404:
01405: final Object retValue$247 = Analyzer
01406: .cast(voidt);
01407:
01408: checkExitScope(arg$217);
01409: matching_nodes
01410: .remove(matching_nodes.size() - 1);
01411: return Analyzer.cast(retValue$247);
01412: }
01413: if (CSupport.match$248(arg$217)) {
01414: matching_nodes.add(arg$217);
01415: if ((null != arg$217 && processScopeNodes
01416: .contains(arg$217.getName()))) {
01417: processScope(arg$217, getScope);
01418: }
01419: checkEnterScope(arg$217);
01420:
01421: final Object retValue$251 = Analyzer
01422: .cast(voidt);
01423:
01424: checkExitScope(arg$217);
01425: matching_nodes
01426: .remove(matching_nodes.size() - 1);
01427: return Analyzer.cast(retValue$251);
01428: }
01429: return null;
01430: }
01431: }.apply();
01432: }
01433: };
01434:
01435: final Function.F1<CTypes.type, Node> analyze_decl_specifiers = new Function.F1<CTypes.type, Node>() {
01436: public CTypes.type apply(final Node n) {
01437: return new Match<CTypes.type>() {
01438: public CTypes.type apply() {
01439: final Node arg$253 = GNode.cast(n);
01440:
01441: if ((null == arg$253)) {
01442: return null;
01443: }
01444: if (CSupport.match$254(arg$253)) {
01445: final Pair<Node> specs = Analyzer
01446: .cast(Primitives.getChildren(arg$253,
01447: 0, arg$253.size()));
01448:
01449: matching_nodes.add(arg$253);
01450: if ((null != arg$253 && processScopeNodes
01451: .contains(arg$253.getName()))) {
01452: processScope(arg$253, getScope);
01453: }
01454: checkEnterScope(arg$253);
01455:
01456: final Object retValue$257 = Analyzer
01457: .cast(process_specifiers.apply(specs));
01458:
01459: checkExitScope(arg$253);
01460: matching_nodes
01461: .remove(matching_nodes.size() - 1);
01462: return Analyzer.cast(retValue$257);
01463: }
01464: if (true) {
01465: matching_nodes.add(arg$253);
01466: if ((null != arg$253 && processScopeNodes
01467: .contains(arg$253.getName()))) {
01468: processScope(arg$253, getScope);
01469: }
01470: checkEnterScope(arg$253);
01471:
01472: final Object retValue$260 = Analyzer.cast(null);
01473:
01474: checkExitScope(arg$253);
01475: matching_nodes
01476: .remove(matching_nodes.size() - 1);
01477: return Analyzer.cast(retValue$260);
01478: }
01479: return null;
01480: }
01481: }.apply();
01482: }
01483: };
01484:
01485: final Function.F1<CTypes.type, Pair<Node>> process_specifiers = new Function.F1<CTypes.type, Pair<Node>>() {
01486: public CTypes.type apply(final Pair<Node> specs) {
01487: return new Let<CTypes.type>() {
01488: final CTypes.type t;
01489: final CTypes.storageClass s;
01490: final Pair<CTypes.qualifier> q;
01491: final CTypes.functionSpecifier f;
01492:
01493: {
01494: t = Analyzer.cast(extractType.apply(specs));
01495: s = Analyzer.cast(extractStorage.apply(specs));
01496: q = Analyzer.cast(extractQualifier.apply(specs));
01497: f = Analyzer.cast(extractFunctionSpecifier
01498: .apply(specs));
01499: }
01500:
01501: public CTypes.type apply() {
01502: return Analyzer.cast(null == Primitives.isBottom
01503: .apply(t) ? null : Primitives.isBottom
01504: .apply(t) ? new CTypes.type(
01505: new CTypes.IntT(), combine_qualifiers
01506: .apply(q, null == t ? null
01507: : t.qualifiers), s, f,
01508: null, null, null, null, null, null, null)
01509: : new CTypes.type(
01510: null == t ? null : t.type,
01511: combine_qualifiers.apply(q,
01512: null == t ? null
01513: : t.qualifiers), s,
01514: f, null == t ? null : t.value,
01515: null == t ? null : t.implicit,
01516: null == t ? null : t.initialised,
01517: null == t ? null : t.position,
01518: null == t ? null : t.old_style,
01519: null == t ? null : t.var_args,
01520: null == t ? null : t.in_top));
01521: }
01522: }.apply();
01523: }
01524: };
01525:
01526: final Function.F1<CTypes.type, Node> analyze_decl_specifier = new Function.F1<CTypes.type, Node>() {
01527: public CTypes.type apply(final Node n) {
01528: return new Match<CTypes.type>() {
01529: public CTypes.type apply() {
01530: final Node arg$262 = GNode.cast(n);
01531:
01532: if ((null == arg$262)) {
01533: return null;
01534: }
01535: if (CSupport.match$263(arg$262)) {
01536: final String s = (arg$262.size() > 1 ? arg$262
01537: .getString(1) : null);
01538: final Node en = Analyzer.cast(arg$262
01539: .getGeneric(2));
01540:
01541: matching_nodes.add(arg$262);
01542: if ((null != arg$262 && processScopeNodes
01543: .contains(arg$262.getName()))) {
01544: processScope(arg$262, getScope);
01545: }
01546: checkEnterScope(arg$262);
01547:
01548: final Object retValue$284 = Analyzer
01549: .cast(new Let<CTypes.type>() {
01550: final Pair<Node> el;
01551: final String name;
01552: final BigInteger non;
01553: final Pair<CTypes.type> tl;
01554:
01555: {
01556: el = Analyzer
01557: .cast(new Match<Pair<Node>>() {
01558: public Pair<Node> apply() {
01559: final Node arg$273 = GNode
01560: .cast(en);
01561:
01562: if ((null == arg$273)) {
01563: return null;
01564: }
01565: if (CSupport
01566: .match$265(arg$273)) {
01567: final Pair<Node> ret = Analyzer
01568: .cast(Primitives
01569: .getChildren(
01570: arg$273,
01571: 0,
01572: arg$273
01573: .size()));
01574:
01575: matching_nodes
01576: .add(arg$273);
01577: if ((null != arg$273 && processScopeNodes
01578: .contains(arg$273
01579: .getName()))) {
01580: processScope(
01581: arg$273,
01582: getScope);
01583: }
01584: checkEnterScope(arg$273);
01585:
01586: final Object retValue$277 = Analyzer
01587: .cast(ret);
01588:
01589: checkExitScope(arg$273);
01590: matching_nodes
01591: .remove(matching_nodes
01592: .size() - 1);
01593: return Analyzer
01594: .cast(retValue$277);
01595: }
01596: if (true) {
01597: matching_nodes
01598: .add(arg$273);
01599: if ((null != arg$273 && processScopeNodes
01600: .contains(arg$273
01601: .getName()))) {
01602: processScope(
01603: arg$273,
01604: getScope);
01605: }
01606: checkEnterScope(arg$273);
01607:
01608: final Object retValue$280 = Analyzer
01609: .cast(null);
01610:
01611: checkExitScope(arg$273);
01612: matching_nodes
01613: .remove(matching_nodes
01614: .size() - 1);
01615: return Analyzer
01616: .cast(retValue$280);
01617: }
01618: return null;
01619: }
01620: }.apply());
01621: name = Analyzer
01622: .cast(null == Primitives.isNotBottom
01623: .apply(s) ? null
01624: : Primitives.isNotBottom
01625: .apply(s) ? s
01626: : freshName
01627: .apply("enum"));
01628: non = Analyzer
01629: .cast(Primitives.nonce
01630: .apply());
01631: tl = Analyzer
01632: .cast(process_enums
01633: .apply(
01634: el,
01635: BigInteger
01636: .valueOf(0)));
01637: define3
01638: .apply(
01639: GNode
01640: .create(
01641: "EnumerationTypeReference",
01642: null,
01643: name),
01644: new CTypes.type(
01645: new CTypes.EnumT(
01646: name,
01647: non,
01648: tl),
01649: null,
01650: null,
01651: null,
01652: null,
01653: null,
01654: null,
01655: null,
01656: null,
01657: null,
01658: null),
01659: getNameSpace);
01660: }
01661:
01662: public CTypes.type apply() {
01663: return Analyzer
01664: .cast(new CTypes.type(
01665: new CTypes.EnumT(
01666: name,
01667: non, tl),
01668: null, null,
01669: null, null,
01670: null, null,
01671: null, null,
01672: null, null));
01673: }
01674: }.apply());
01675:
01676: checkExitScope(arg$262);
01677: matching_nodes
01678: .remove(matching_nodes.size() - 1);
01679: return Analyzer.cast(retValue$284);
01680: }
01681: if (CSupport.match$61(arg$262)) {
01682: final String s = (arg$262.size() > 1 ? arg$262
01683: .getString(1) : null);
01684:
01685: matching_nodes.add(arg$262);
01686: if ((null != arg$262 && processScopeNodes
01687: .contains(arg$262.getName()))) {
01688: processScope(arg$262, getScope);
01689: }
01690: checkEnterScope(arg$262);
01691:
01692: final Object retValue$290 = Analyzer
01693: .cast(null == Primitives.not
01694: .apply(isDefined.apply(n,
01695: getNameSpace)) ? null
01696: : Primitives.not
01697: .apply(isDefined
01698: .apply(n,
01699: getNameSpace)) ? new Let<CTypes.type>() {
01700: {
01701: define3
01702: .apply(
01703: n,
01704: new CTypes.type(
01705: new CTypes.EnumT(
01706: s,
01707: null,
01708: null),
01709: null,
01710: null,
01711: null,
01712: null,
01713: null,
01714: null,
01715: null,
01716: null,
01717: null,
01718: null),
01719: getNameSpace);
01720: }
01721:
01722: public CTypes.type apply() {
01723: return Analyzer
01724: .cast(new CTypes.type(
01725: new CTypes.EnumT(
01726: s,
01727: null,
01728: null),
01729: null,
01730: null,
01731: null,
01732: null,
01733: null,
01734: null,
01735: null,
01736: null,
01737: null,
01738: null));
01739: }
01740: }.apply()
01741: : new Let<CTypes.type>() {
01742: final CTypes.type t;
01743:
01744: {
01745: t = Analyzer
01746: .cast(Analyzer
01747: .cast(lookup2
01748: .apply(
01749: n,
01750: getNameSpace)));
01751: }
01752:
01753: public CTypes.type apply() {
01754: return Analyzer
01755: .cast(new Require<CTypes.type>() {
01756: public CTypes.type apply() {
01757: final Boolean var$287 = is_enum
01758: .apply(t);
01759:
01760: if ((null != var$287 && !var$287)) {
01761: showMessage(
01762: "error",
01763: Primitives.concat
01764: .apply(
01765: Primitives.concat
01766: .apply(
01767: "'",
01768: s),
01769: "' defined as wrong kind of tag"),
01770: null);
01771: }
01772: if ((null == var$287)) {
01773: return null;
01774: }
01775: if (var$287) {
01776: return t;
01777: }
01778: return null;
01779: }
01780: }
01781: .apply());
01782: }
01783: }.apply());
01784:
01785: checkExitScope(arg$262);
01786: matching_nodes
01787: .remove(matching_nodes.size() - 1);
01788: return Analyzer.cast(retValue$290);
01789: }
01790: if (CSupport.match$291(arg$262)) {
01791: final String s = (arg$262.size() > 1 ? arg$262
01792: .getString(1) : null);
01793: final Node sdl = (arg$262.size() > 2 ? arg$262
01794: .getGeneric(2) : null);
01795:
01796: matching_nodes.add(arg$262);
01797: if ((null != arg$262 && processScopeNodes
01798: .contains(arg$262.getName()))) {
01799: processScope(arg$262, getScope);
01800: }
01801: checkEnterScope(arg$262);
01802:
01803: final Object retValue$312 = Analyzer
01804: .cast(new Let<CTypes.type>() {
01805: final String name;
01806: final Node nod;
01807:
01808: {
01809: name = Analyzer
01810: .cast(null == Primitives.isNotBottom
01811: .apply(s) ? null
01812: : Primitives.isNotBottom
01813: .apply(s) ? s
01814: : freshName
01815: .apply("struct"));
01816: nod = Analyzer
01817: .cast(GNode
01818: .create(
01819: "StructureTypeReference",
01820: null,
01821: name));
01822: }
01823:
01824: public CTypes.type apply() {
01825: return Analyzer
01826: .cast(null == Primitives.and
01827: .apply(
01828: Primitives.isNotBottom
01829: .apply(ancestor
01830: .apply(CSupport.nodeMatch$293)),
01831: isDefined
01832: .apply(
01833: nod,
01834: getNameSpace)) ? null
01835: : Primitives.and
01836: .apply(
01837: Primitives.isNotBottom
01838: .apply(ancestor
01839: .apply(CSupport.nodeMatch$293)),
01840: isDefined
01841: .apply(
01842: nod,
01843: getNameSpace)) ? error(
01844: Primitives.concat
01845: .apply(
01846: "redefinition of ",
01847: name),
01848: null)
01849: : new Let<CTypes.type>() {
01850: final BigInteger non;
01851: final CTypes.type t;
01852:
01853: {
01854: non = Analyzer
01855: .cast(null == Primitives.not
01856: .apply(isDefined
01857: .apply(
01858: nod,
01859: getNameSpace)) ? null
01860: : Primitives.not
01861: .apply(isDefined
01862: .apply(
01863: nod,
01864: getNameSpace)) ? Primitives.nonce
01865: .apply()
01866: : new Let<BigInteger>() {
01867: final CTypes.type told;
01868:
01869: {
01870: told = Analyzer
01871: .cast(Analyzer
01872: .cast(lookup2
01873: .apply(
01874: nod,
01875: getNameSpace)));
01876: }
01877:
01878: public BigInteger apply() {
01879: return Analyzer
01880: .cast(new Match<BigInteger>() {
01881: public BigInteger apply() {
01882: final CTypes.raw_type<?> arg$306 = Analyzer
01883: .cast(null == told ? null
01884: : told.type);
01885:
01886: if ((null == arg$306)) {
01887: return null;
01888: }
01889: if ((null != arg$306))
01890: switch (arg$306
01891: .tag()) {
01892: case StructT:
01893: if (CSupport
01894: .match$298(arg$306)) {
01895: final BigInteger no = Analyzer
01896: .cast(arg$306
01897: .getTuple()
01898: .get2());
01899:
01900: return Analyzer
01901: .cast(no);
01902: }
01903: break;
01904: default:
01905: break;
01906: }
01907: ;
01908: if (true) {
01909: return Analyzer
01910: .cast(null);
01911: }
01912: return null;
01913: }
01914: }
01915: .apply());
01916: }
01917: }
01918: .apply());
01919: Analyzer
01920: .discard(null == Primitives.and
01921: .apply(
01922: Primitives.isBottom
01923: .apply(s),
01924: Primitives.isNotBottom
01925: .apply(ancestor
01926: .apply(CSupport.nodeMatch$301)))
01927: || !Primitives.and
01928: .apply(
01929: Primitives.isBottom
01930: .apply(s),
01931: Primitives.isNotBottom
01932: .apply(ancestor
01933: .apply(CSupport.nodeMatch$301))) ? null
01934: : warning(
01935: "anonymous struct declared inside parameter list",
01936: null));
01937: Analyzer
01938: .discard(null == Primitives.not
01939: .apply(isDefined
01940: .apply(
01941: nod,
01942: getNameSpace))
01943: || !Primitives.not
01944: .apply(isDefined
01945: .apply(
01946: nod,
01947: getNameSpace)) ? null
01948: : c_define
01949: .apply(
01950: nod,
01951: name,
01952: new CTypes.type(
01953: new CTypes.StructT(
01954: name,
01955: non,
01956: null),
01957: null,
01958: null,
01959: null,
01960: null,
01961: null,
01962: null,
01963: n,
01964: null,
01965: null,
01966: null)));
01967: t = Analyzer
01968: .cast(analyze_struct_decl_list
01969: .apply(sdl));
01970: }
01971:
01972: public CTypes.type apply() {
01973: return Analyzer
01974: .cast(new Match<CTypes.type>() {
01975: public CTypes.type apply() {
01976: final CTypes.raw_type<?> arg$303 = Analyzer
01977: .cast(null == t ? null
01978: : t.type);
01979:
01980: if ((null == arg$303)) {
01981: return null;
01982: }
01983: if ((null != arg$303))
01984: switch (arg$303
01985: .tag()) {
01986: case ListT:
01987: if (CSupport
01988: .match$295(arg$303)) {
01989: final Pair<CTypes.type> l = Analyzer
01990: .cast(arg$303
01991: .getTuple()
01992: .get1());
01993:
01994: return Analyzer
01995: .cast(new Let<CTypes.type>() {
01996: final CTypes.type res;
01997: final CTypes.type prev;
01998:
01999: {
02000: res = Analyzer
02001: .cast(new CTypes.type(
02002: new CTypes.StructT(
02003: name,
02004: non,
02005: l),
02006: null,
02007: null,
02008: null,
02009: null,
02010: null,
02011: null,
02012: null,
02013: null,
02014: null,
02015: null));
02016: prev = Analyzer
02017: .cast(Analyzer
02018: .cast(lookup2
02019: .apply(
02020: nod,
02021: getNameSpace)));
02022: }
02023:
02024: public CTypes.type apply() {
02025: return Analyzer
02026: .cast(null == is_incomplete
02027: .apply(prev) ? null
02028: : is_incomplete
02029: .apply(prev) ? new Let<CTypes.type>() {
02030: {
02031: redefine
02032: .apply(
02033: nod,
02034: res,
02035: getNameSpace);
02036: }
02037:
02038: public CTypes.type apply() {
02039: return Analyzer
02040: .cast(res);
02041: }
02042: }
02043: .apply()
02044: : c_define
02045: .apply(
02046: nod,
02047: name,
02048: new CTypes.type(
02049: null == res ? null
02050: : res.type,
02051: null == res ? null
02052: : res.qualifiers,
02053: null == res ? null
02054: : res.storage,
02055: null == res ? null
02056: : res.fSpec,
02057: null == res ? null
02058: : res.value,
02059: null == res ? null
02060: : res.implicit,
02061: null == res ? null
02062: : res.initialised,
02063: n,
02064: null == res ? null
02065: : res.old_style,
02066: null == res ? null
02067: : res.var_args,
02068: null == res ? null
02069: : res.in_top)));
02070: }
02071: }
02072: .apply());
02073: }
02074: break;
02075: default:
02076: break;
02077: }
02078: ;
02079: if (true) {
02080: return Analyzer
02081: .cast(null);
02082: }
02083: return null;
02084: }
02085: }
02086: .apply());
02087: }
02088: }
02089: .apply());
02090: }
02091: }.apply());
02092:
02093: checkExitScope(arg$262);
02094: matching_nodes
02095: .remove(matching_nodes.size() - 1);
02096: return Analyzer.cast(retValue$312);
02097: }
02098: if (CSupport.match$49(arg$262)) {
02099: final String s = (arg$262.size() > 1 ? arg$262
02100: .getString(1) : null);
02101:
02102: matching_nodes.add(arg$262);
02103: if ((null != arg$262 && processScopeNodes
02104: .contains(arg$262.getName()))) {
02105: processScope(arg$262, getScope);
02106: }
02107: checkEnterScope(arg$262);
02108:
02109: final Object retValue$318 = Analyzer
02110: .cast(null == Primitives.not
02111: .apply(isDefined.apply(n,
02112: getNameSpace)) ? null
02113: : Primitives.not
02114: .apply(isDefined
02115: .apply(n,
02116: getNameSpace)) ? new Let<CTypes.type>() {
02117: final BigInteger non;
02118:
02119: {
02120: non = Analyzer
02121: .cast(Primitives.nonce
02122: .apply());
02123: Analyzer
02124: .discard(null == Primitives.isNotBottom
02125: .apply(ancestor
02126: .apply(CSupport.nodeMatch$301))
02127: || !Primitives.isNotBottom
02128: .apply(ancestor
02129: .apply(CSupport.nodeMatch$301)) ? null
02130: : warning(
02131: "struct declared inside parameter list",
02132: null));
02133: define3
02134: .apply(
02135: n,
02136: new CTypes.type(
02137: new CTypes.StructT(
02138: s,
02139: non,
02140: null),
02141: null,
02142: null,
02143: null,
02144: null,
02145: null,
02146: null,
02147: null,
02148: null,
02149: null,
02150: null),
02151: getNameSpace);
02152: }
02153:
02154: public CTypes.type apply() {
02155: return Analyzer
02156: .cast(new CTypes.type(
02157: new CTypes.StructT(
02158: s,
02159: non,
02160: null),
02161: null,
02162: null,
02163: null,
02164: null,
02165: null,
02166: null,
02167: null,
02168: null,
02169: null,
02170: null));
02171: }
02172: }.apply()
02173: : Analyzer
02174: .cast(lookup2
02175: .apply(
02176: n,
02177: getNameSpace)));
02178:
02179: checkExitScope(arg$262);
02180: matching_nodes
02181: .remove(matching_nodes.size() - 1);
02182: return Analyzer.cast(retValue$318);
02183: }
02184: if (CSupport.match$319(arg$262)) {
02185: final String s = (arg$262.size() > 1 ? arg$262
02186: .getString(1) : null);
02187: final Node sdl = (arg$262.size() > 2 ? arg$262
02188: .getGeneric(2) : null);
02189:
02190: matching_nodes.add(arg$262);
02191: if ((null != arg$262 && processScopeNodes
02192: .contains(arg$262.getName()))) {
02193: processScope(arg$262, getScope);
02194: }
02195: checkEnterScope(arg$262);
02196:
02197: final Object retValue$338 = Analyzer
02198: .cast(new Let<CTypes.type>() {
02199: final String name;
02200: final Node nod;
02201:
02202: {
02203: name = Analyzer
02204: .cast(null == Primitives.isNotBottom
02205: .apply(s) ? null
02206: : Primitives.isNotBottom
02207: .apply(s) ? s
02208: : freshName
02209: .apply("union"));
02210: nod = Analyzer
02211: .cast(GNode
02212: .create(
02213: "UnionTypeReference",
02214: null,
02215: name));
02216: }
02217:
02218: public CTypes.type apply() {
02219: return Analyzer
02220: .cast(null == Primitives.and
02221: .apply(
02222: Primitives.isNotBottom
02223: .apply(ancestor
02224: .apply(CSupport.nodeMatch$293)),
02225: isDefined
02226: .apply(
02227: nod,
02228: getNameSpace)) ? null
02229: : Primitives.and
02230: .apply(
02231: Primitives.isNotBottom
02232: .apply(ancestor
02233: .apply(CSupport.nodeMatch$293)),
02234: isDefined
02235: .apply(
02236: nod,
02237: getNameSpace)) ? error(
02238: Primitives.concat
02239: .apply(
02240: "redefinition of ",
02241: name),
02242: null)
02243: : new Let<CTypes.type>() {
02244: final BigInteger non;
02245: final CTypes.type t;
02246:
02247: {
02248: non = Analyzer
02249: .cast(null == Primitives.not
02250: .apply(isDefined
02251: .apply(
02252: nod,
02253: getNameSpace)) ? null
02254: : Primitives.not
02255: .apply(isDefined
02256: .apply(
02257: nod,
02258: getNameSpace)) ? Primitives.nonce
02259: .apply()
02260: : new Let<BigInteger>() {
02261: final CTypes.type told;
02262:
02263: {
02264: told = Analyzer
02265: .cast(Analyzer
02266: .cast(lookup2
02267: .apply(
02268: nod,
02269: getNameSpace)));
02270: }
02271:
02272: public BigInteger apply() {
02273: return Analyzer
02274: .cast(new Match<BigInteger>() {
02275: public BigInteger apply() {
02276: final CTypes.raw_type<?> arg$332 = Analyzer
02277: .cast(null == told ? null
02278: : told.type);
02279:
02280: if ((null == arg$332)) {
02281: return null;
02282: }
02283: if ((null != arg$332))
02284: switch (arg$332
02285: .tag()) {
02286: case StructT:
02287: if (CSupport
02288: .match$298(arg$332)) {
02289: final BigInteger no = Analyzer
02290: .cast(arg$332
02291: .getTuple()
02292: .get2());
02293:
02294: return Analyzer
02295: .cast(no);
02296: }
02297: break;
02298: default:
02299: break;
02300: }
02301: ;
02302: if (true) {
02303: return Analyzer
02304: .cast(null);
02305: }
02306: return null;
02307: }
02308: }
02309: .apply());
02310: }
02311: }
02312: .apply());
02313: Analyzer
02314: .discard(null == Primitives.and
02315: .apply(
02316: Primitives.isBottom
02317: .apply(s),
02318: Primitives.isNotBottom
02319: .apply(ancestor
02320: .apply(CSupport.nodeMatch$301)))
02321: || !Primitives.and
02322: .apply(
02323: Primitives.isBottom
02324: .apply(s),
02325: Primitives.isNotBottom
02326: .apply(ancestor
02327: .apply(CSupport.nodeMatch$301))) ? null
02328: : warning(
02329: "anonymous struct declared inside parameter list",
02330: null));
02331: Analyzer
02332: .discard(null == Primitives.not
02333: .apply(isDefined
02334: .apply(
02335: nod,
02336: getNameSpace))
02337: || !Primitives.not
02338: .apply(isDefined
02339: .apply(
02340: nod,
02341: getNameSpace)) ? null
02342: : c_define
02343: .apply(
02344: nod,
02345: name,
02346: new CTypes.type(
02347: new CTypes.UnionT(
02348: name,
02349: non,
02350: null),
02351: null,
02352: null,
02353: null,
02354: null,
02355: null,
02356: null,
02357: n,
02358: null,
02359: null,
02360: null)));
02361: t = Analyzer
02362: .cast(analyze_struct_decl_list
02363: .apply(sdl));
02364: }
02365:
02366: public CTypes.type apply() {
02367: return Analyzer
02368: .cast(new Match<CTypes.type>() {
02369: public CTypes.type apply() {
02370: final CTypes.raw_type<?> arg$329 = Analyzer
02371: .cast(null == t ? null
02372: : t.type);
02373:
02374: if ((null == arg$329)) {
02375: return null;
02376: }
02377: if ((null != arg$329))
02378: switch (arg$329
02379: .tag()) {
02380: case ListT:
02381: if (CSupport
02382: .match$295(arg$329)) {
02383: final Pair<CTypes.type> l = Analyzer
02384: .cast(arg$329
02385: .getTuple()
02386: .get1());
02387:
02388: return Analyzer
02389: .cast(new Let<CTypes.type>() {
02390: final CTypes.type res;
02391: final CTypes.type prev;
02392:
02393: {
02394: res = Analyzer
02395: .cast(new CTypes.type(
02396: new CTypes.UnionT(
02397: name,
02398: non,
02399: l),
02400: null,
02401: null,
02402: null,
02403: null,
02404: null,
02405: null,
02406: null,
02407: null,
02408: null,
02409: null));
02410: prev = Analyzer
02411: .cast(Analyzer
02412: .cast(lookup2
02413: .apply(
02414: nod,
02415: getNameSpace)));
02416: }
02417:
02418: public CTypes.type apply() {
02419: return Analyzer
02420: .cast(null == is_incomplete
02421: .apply(prev) ? null
02422: : is_incomplete
02423: .apply(prev) ? new Let<CTypes.type>() {
02424: {
02425: redefine
02426: .apply(
02427: nod,
02428: res,
02429: getNameSpace);
02430: }
02431:
02432: public CTypes.type apply() {
02433: return Analyzer
02434: .cast(res);
02435: }
02436: }
02437: .apply()
02438: : c_define
02439: .apply(
02440: nod,
02441: name,
02442: new CTypes.type(
02443: null == res ? null
02444: : res.type,
02445: null == res ? null
02446: : res.qualifiers,
02447: null == res ? null
02448: : res.storage,
02449: null == res ? null
02450: : res.fSpec,
02451: null == res ? null
02452: : res.value,
02453: null == res ? null
02454: : res.implicit,
02455: null == res ? null
02456: : res.initialised,
02457: n,
02458: null == res ? null
02459: : res.old_style,
02460: null == res ? null
02461: : res.var_args,
02462: null == res ? null
02463: : res.in_top)));
02464: }
02465: }
02466: .apply());
02467: }
02468: break;
02469: default:
02470: break;
02471: }
02472: ;
02473: if (true) {
02474: return Analyzer
02475: .cast(null);
02476: }
02477: return null;
02478: }
02479: }
02480: .apply());
02481: }
02482: }
02483: .apply());
02484: }
02485: }.apply());
02486:
02487: checkExitScope(arg$262);
02488: matching_nodes
02489: .remove(matching_nodes.size() - 1);
02490: return Analyzer.cast(retValue$338);
02491: }
02492: if (CSupport.match$53(arg$262)) {
02493: final String s = (arg$262.size() > 1 ? arg$262
02494: .getString(1) : null);
02495:
02496: matching_nodes.add(arg$262);
02497: if ((null != arg$262 && processScopeNodes
02498: .contains(arg$262.getName()))) {
02499: processScope(arg$262, getScope);
02500: }
02501: checkEnterScope(arg$262);
02502:
02503: final Object retValue$342 = Analyzer
02504: .cast(null == Primitives.not
02505: .apply(isDefined.apply(n,
02506: getNameSpace)) ? null
02507: : Primitives.not
02508: .apply(isDefined
02509: .apply(n,
02510: getNameSpace)) ? new Let<CTypes.type>() {
02511: final BigInteger non;
02512:
02513: {
02514: non = Analyzer
02515: .cast(Primitives.nonce
02516: .apply());
02517: define3
02518: .apply(
02519: n,
02520: new CTypes.type(
02521: new CTypes.UnionT(
02522: s,
02523: non,
02524: null),
02525: null,
02526: null,
02527: null,
02528: null,
02529: null,
02530: null,
02531: null,
02532: null,
02533: null,
02534: null),
02535: getNameSpace);
02536: }
02537:
02538: public CTypes.type apply() {
02539: return Analyzer
02540: .cast(new CTypes.type(
02541: new CTypes.UnionT(
02542: s,
02543: non,
02544: null),
02545: null,
02546: null,
02547: null,
02548: null,
02549: null,
02550: null,
02551: null,
02552: null,
02553: null,
02554: null));
02555: }
02556: }.apply()
02557: : Analyzer
02558: .cast(lookup2
02559: .apply(
02560: n,
02561: getNameSpace)));
02562:
02563: checkExitScope(arg$262);
02564: matching_nodes
02565: .remove(matching_nodes.size() - 1);
02566: return Analyzer.cast(retValue$342);
02567: }
02568: if (CSupport.match$25(arg$262)) {
02569: final String s = (arg$262.size() > 0 ? arg$262
02570: .getString(0) : null);
02571:
02572: matching_nodes.add(arg$262);
02573: if ((null != arg$262 && processScopeNodes
02574: .contains(arg$262.getName()))) {
02575: processScope(arg$262, getScope);
02576: }
02577: checkEnterScope(arg$262);
02578:
02579: final Object retValue$346 = Analyzer
02580: .cast(Analyzer
02581: .cast(lookup4
02582: .apply(
02583: n,
02584: "error",
02585: Primitives.concat
02586: .apply(
02587: "undeclared typedef name ",
02588: s),
02589: getNameSpace)));
02590:
02591: checkExitScope(arg$262);
02592: matching_nodes
02593: .remove(matching_nodes.size() - 1);
02594: return Analyzer.cast(retValue$346);
02595: }
02596: if (CSupport.match$347(arg$262)) {
02597: final Node e = (arg$262.size() > 0 ? arg$262
02598: .getGeneric(0) : null);
02599:
02600: matching_nodes.add(arg$262);
02601: if ((null != arg$262 && processScopeNodes
02602: .contains(arg$262.getName()))) {
02603: processScope(arg$262, getScope);
02604: }
02605: checkEnterScope(arg$262);
02606:
02607: final Object retValue$368 = Analyzer
02608: .cast(new Match<CTypes.type>() {
02609: public CTypes.type apply() {
02610: final Node arg$357 = GNode
02611: .cast(e);
02612:
02613: if ((null == arg$357)) {
02614: return null;
02615: }
02616: if (CSupport.match$349(arg$357)) {
02617: matching_nodes.add(arg$357);
02618: if ((null != arg$357 && processScopeNodes
02619: .contains(arg$357
02620: .getName()))) {
02621: processScope(arg$357,
02622: getScope);
02623: }
02624: checkEnterScope(arg$357);
02625:
02626: final Object retValue$361 = Analyzer
02627: .cast(analyze_type_name
02628: .apply(e));
02629:
02630: checkExitScope(arg$357);
02631: matching_nodes
02632: .remove(matching_nodes
02633: .size() - 1);
02634: return Analyzer
02635: .cast(retValue$361);
02636: }
02637: if (true) {
02638: matching_nodes.add(arg$357);
02639: if ((null != arg$357 && processScopeNodes
02640: .contains(arg$357
02641: .getName()))) {
02642: processScope(arg$357,
02643: getScope);
02644: }
02645: checkEnterScope(arg$357);
02646:
02647: final Object retValue$364 = Analyzer
02648: .cast(analyze_expression
02649: .apply(e));
02650:
02651: checkExitScope(arg$357);
02652: matching_nodes
02653: .remove(matching_nodes
02654: .size() - 1);
02655: return Analyzer
02656: .cast(retValue$364);
02657: }
02658: return null;
02659: }
02660: }.apply());
02661:
02662: checkExitScope(arg$262);
02663: matching_nodes
02664: .remove(matching_nodes.size() - 1);
02665: return Analyzer.cast(retValue$368);
02666: }
02667: if (true) {
02668: matching_nodes.add(arg$262);
02669: if ((null != arg$262 && processScopeNodes
02670: .contains(arg$262.getName()))) {
02671: processScope(arg$262, getScope);
02672: }
02673: checkEnterScope(arg$262);
02674:
02675: final Object retValue$371 = Analyzer.cast(null);
02676:
02677: checkExitScope(arg$262);
02678: matching_nodes
02679: .remove(matching_nodes.size() - 1);
02680: return Analyzer.cast(retValue$371);
02681: }
02682: return null;
02683: }
02684: }.apply();
02685: }
02686: };
02687:
02688: final Function.F2<CTypes.type, CTypes.type, Node> analyze_init_decl_list = new Function.F2<CTypes.type, CTypes.type, Node>() {
02689: public CTypes.type apply(final CTypes.type t, final Node n) {
02690: return new Match<CTypes.type>() {
02691: public CTypes.type apply() {
02692: final Node arg$373 = GNode.cast(n);
02693:
02694: if ((null == arg$373)) {
02695: return null;
02696: }
02697: if (CSupport.match$374(arg$373)) {
02698: final Pair<Node> dl = Analyzer
02699: .cast(Primitives.getChildren(arg$373,
02700: 0, arg$373.size()));
02701:
02702: matching_nodes.add(arg$373);
02703: if ((null != arg$373 && processScopeNodes
02704: .contains(arg$373.getName()))) {
02705: processScope(arg$373, getScope);
02706: }
02707: checkEnterScope(arg$373);
02708:
02709: final Object retValue$377 = Analyzer
02710: .cast(new Let<CTypes.type>() {
02711: {
02712: analyze_list_init_decl.apply(t,
02713: dl);
02714: }
02715:
02716: public CTypes.type apply() {
02717: return Analyzer.cast(voidt);
02718: }
02719: }.apply());
02720:
02721: checkExitScope(arg$373);
02722: matching_nodes
02723: .remove(matching_nodes.size() - 1);
02724: return Analyzer.cast(retValue$377);
02725: }
02726: if (true) {
02727: matching_nodes.add(arg$373);
02728: if ((null != arg$373 && processScopeNodes
02729: .contains(arg$373.getName()))) {
02730: processScope(arg$373, getScope);
02731: }
02732: checkEnterScope(arg$373);
02733:
02734: final Object retValue$380 = Analyzer.cast(null);
02735:
02736: checkExitScope(arg$373);
02737: matching_nodes
02738: .remove(matching_nodes.size() - 1);
02739: return Analyzer.cast(retValue$380);
02740: }
02741: return null;
02742: }
02743: }.apply();
02744: }
02745: };
02746:
02747: final Function.F2<Pair<CTypes.type>, CTypes.type, Pair<Node>> analyze_list_init_decl = new Function.F2<Pair<CTypes.type>, CTypes.type, Pair<Node>>() {
02748: public Pair<CTypes.type> apply(final CTypes.type t,
02749: final Pair<Node> dl) {
02750: return new Match<Pair<CTypes.type>>() {
02751: public Pair<CTypes.type> apply() {
02752: final Pair<Node> arg$382 = Analyzer.cast(dl);
02753:
02754: if ((null == arg$382)) {
02755: return null;
02756: }
02757: if (CSupport.match$383(arg$382)) {
02758: return Analyzer
02759: .cast(Pair.<CTypes.type> empty());
02760: }
02761: if (true) {
02762: final Pair<Node> list$384 = Analyzer
02763: .cast(Analyzer.cast(arg$382));
02764: final Node x = GNode.cast(Primitives
02765: .wrapHead(list$384));
02766: final Pair<Node> xs = Analyzer.cast(Primitives
02767: .wrapTail(list$384));
02768:
02769: return Analyzer.cast(Primitives.wrapCons(
02770: analyze_init_decl.apply(t, x),
02771: analyze_list_init_decl.apply(t, xs)));
02772: }
02773: return null;
02774: }
02775: }.apply();
02776: }
02777: };
02778:
02779: final Function.F2<CTypes.type, CTypes.type, Node> analyze_init_decl = new Function.F2<CTypes.type, CTypes.type, Node>() {
02780: public CTypes.type apply(final CTypes.type t, final Node n) {
02781: return new Match<CTypes.type>() {
02782: public CTypes.type apply() {
02783: final Node arg$386 = GNode.cast(n);
02784:
02785: if ((null == arg$386)) {
02786: return null;
02787: }
02788: if (CSupport.match$387(arg$386)) {
02789: final Node dec = (arg$386.size() > 1 ? arg$386
02790: .getGeneric(1) : null);
02791: final Node init = (arg$386.size() > 4 ? arg$386
02792: .getGeneric(4) : null);
02793:
02794: matching_nodes.add(arg$386);
02795: if ((null != arg$386 && processScopeNodes
02796: .contains(arg$386.getName()))) {
02797: processScope(arg$386, getScope);
02798: }
02799: checkEnterScope(arg$386);
02800:
02801: final Object retValue$390 = Analyzer
02802: .cast(new Let<CTypes.type>() {
02803: final String s;
02804: final CTypes.type t1;
02805:
02806: {
02807: s = Analyzer
02808: .cast(get_id_declarator
02809: .apply(dec));
02810: t1 = Analyzer
02811: .cast(analyze_declarator
02812: .apply(t, dec));
02813: Analyzer
02814: .discard(null == is_top
02815: .apply(n) ? null
02816: : is_top
02817: .apply(n) ? (null == is_static
02818: .apply(t) ? null
02819: : is_static
02820: .apply(t) ? redefine
02821: .apply(
02822: GNode
02823: .create(
02824: "PrimaryIdentifier",
02825: Primitives.concat
02826: .apply(
02827: "top__",
02828: s)),
02829: new CTypes.type(
02830: null == t1 ? null
02831: : t1.type,
02832: null == t1 ? null
02833: : t1.qualifiers,
02834: null == t1 ? null
02835: : t1.storage,
02836: null == t1 ? null
02837: : t1.fSpec,
02838: null == t1 ? null
02839: : t1.value,
02840: null == t1 ? null
02841: : t1.implicit,
02842: null == t1 ? null
02843: : t1.initialised,
02844: n,
02845: null == t1 ? null
02846: : t1.old_style,
02847: null == t1 ? null
02848: : t1.var_args,
02849: null == t1 ? null
02850: : t1.in_top),
02851: getNameSpace)
02852: : voidt)
02853: : null == Primitives.and
02854: .apply(
02855: Primitives.and
02856: .apply(
02857: in_inner
02858: .apply(GNode
02859: .create(
02860: "PrimaryIdentifier",
02861: s)),
02862: is_extern
02863: .apply(t)),
02864: isDefined
02865: .apply(
02866: GNode
02867: .create(
02868: "PrimaryIdentifier",
02869: Primitives.concat
02870: .apply(
02871: "top__",
02872: s)),
02873: getNameSpace))
02874: || !Primitives.and
02875: .apply(
02876: Primitives.and
02877: .apply(
02878: in_inner
02879: .apply(GNode
02880: .create(
02881: "PrimaryIdentifier",
02882: s)),
02883: is_extern
02884: .apply(t)),
02885: isDefined
02886: .apply(
02887: GNode
02888: .create(
02889: "PrimaryIdentifier",
02890: Primitives.concat
02891: .apply(
02892: "top__",
02893: s)),
02894: getNameSpace)) ? null
02895: : new Let<CTypes.type>() {
02896: final CTypes.type told;
02897: final Node pos;
02898:
02899: {
02900: told = Analyzer
02901: .cast(Analyzer
02902: .cast(lookup2
02903: .apply(
02904: GNode
02905: .create(
02906: "PrimaryIdentifier",
02907: Primitives.concat
02908: .apply(
02909: "top__",
02910: s)),
02911: getNameSpace)));
02912: pos = Analyzer
02913: .cast(null == told ? null
02914: : told.position);
02915: error(
02916: Primitives.concat
02917: .apply(
02918: "variable previously declared 'static' ",
02919: "redeclared 'extern'"),
02920: null);
02921: error(
02922: Primitives.concat
02923: .apply(
02924: Primitives.concat
02925: .apply(
02926: "previous definition of '",
02927: s),
02928: "' was here"),
02929: pos);
02930: }
02931:
02932: public CTypes.type apply() {
02933: return Analyzer
02934: .cast(voidt);
02935: }
02936: }
02937: .apply());
02938: }
02939:
02940: public CTypes.type apply() {
02941: return Analyzer
02942: .cast(null == Primitives.isBottom
02943: .apply(init) ? null
02944: : Primitives.isBottom
02945: .apply(init) ? new Let<CTypes.type>() {
02946: {
02947: Analyzer
02948: .discard(null == Primitives.and
02949: .apply(
02950: Primitives.and
02951: .apply(
02952: is_array
02953: .apply(t1),
02954: is_complete
02955: .apply(t1)),
02956: is_incomplete
02957: .apply(get_base
02958: .apply(t1)))
02959: || !Primitives.and
02960: .apply(
02961: Primitives.and
02962: .apply(
02963: is_array
02964: .apply(t1),
02965: is_complete
02966: .apply(t1)),
02967: is_incomplete
02968: .apply(get_base
02969: .apply(t1))) ? null
02970: : error(
02971: "array type has incomplete element type",
02972: null));
02973: }
02974:
02975: public CTypes.type apply() {
02976: return Analyzer
02977: .cast(c_define
02978: .apply(
02979: dec,
02980: get_id_declarator
02981: .apply(dec),
02982: new CTypes.type(
02983: null == t1 ? null
02984: : t1.type,
02985: null == t1 ? null
02986: : t1.qualifiers,
02987: null == t1 ? null
02988: : t1.storage,
02989: null == t1 ? null
02990: : t1.fSpec,
02991: null == t1 ? null
02992: : t1.value,
02993: null == t1 ? null
02994: : t1.implicit,
02995: null == t1 ? null
02996: : t1.initialised,
02997: n,
02998: null == t1 ? null
02999: : t1.old_style,
03000: null == t1 ? null
03001: : t1.var_args,
03002: is_top
03003: .apply(n))));
03004: }
03005: }.apply()
03006: : new Let<CTypes.type>() {
03007: {
03008: Analyzer
03009: .discard(null == is_extern
03010: .apply(t1)
03011: || !is_extern
03012: .apply(t1) ? null
03013: : warning(
03014: Primitives.concat
03015: .apply(
03016: Primitives.concat
03017: .apply(
03018: "'",
03019: s),
03020: "' initialized and declared 'extern'"),
03021: null));
03022: c_define
03023: .apply(
03024: dec,
03025: get_id_declarator
03026: .apply(dec),
03027: new CTypes.type(
03028: null == t1 ? null
03029: : t1.type,
03030: null == t1 ? null
03031: : t1.qualifiers,
03032: null == t1 ? null
03033: : t1.storage,
03034: null == t1 ? null
03035: : t1.fSpec,
03036: null == t1 ? null
03037: : t1.value,
03038: null == t1 ? null
03039: : t1.implicit,
03040: null == t1 ? null
03041: : t1.initialised,
03042: n,
03043: null == t1 ? null
03044: : t1.old_style,
03045: null == t1 ? null
03046: : t1.var_args,
03047: is_top
03048: .apply(n)));
03049: }
03050:
03051: public CTypes.type apply() {
03052: return Analyzer
03053: .cast(null == Primitives.and
03054: .apply(
03055: is_array
03056: .apply(t1),
03057: is_incomplete
03058: .apply(get_base
03059: .apply(t1))) ? null
03060: : Primitives.and
03061: .apply(
03062: is_array
03063: .apply(t1),
03064: is_incomplete
03065: .apply(get_base
03066: .apply(t1))) ? error(
03067: "array type has incomplete element type",
03068: null)
03069: : analyze_initializer
03070: .apply(
03071: init,
03072: t1));
03073: }
03074: }
03075: .apply());
03076: }
03077: }.apply());
03078:
03079: checkExitScope(arg$386);
03080: matching_nodes
03081: .remove(matching_nodes.size() - 1);
03082: return Analyzer.cast(retValue$390);
03083: }
03084: if (true) {
03085: matching_nodes.add(arg$386);
03086: if ((null != arg$386 && processScopeNodes
03087: .contains(arg$386.getName()))) {
03088: processScope(arg$386, getScope);
03089: }
03090: checkEnterScope(arg$386);
03091:
03092: final Object retValue$393 = Analyzer.cast(null);
03093:
03094: checkExitScope(arg$386);
03095: matching_nodes
03096: .remove(matching_nodes.size() - 1);
03097: return Analyzer.cast(retValue$393);
03098: }
03099: return null;
03100: }
03101: }.apply();
03102: }
03103: };
03104:
03105: final Function.F1<Boolean, Node> in_inner = new Function.F1<Boolean, Node>() {
03106: public Boolean apply(final Node n) {
03107: return (null == Primitives.not.apply(isDefined.apply(n,
03108: getNameSpace)) ? null
03109: : Primitives.not.apply(isDefined.apply(n,
03110: getNameSpace)) ? Boolean.FALSE
03111: : new Let<Boolean>() {
03112: final CTypes.type t;
03113:
03114: {
03115: t = Analyzer.cast(Analyzer
03116: .cast(lookup2.apply(n,
03117: getNameSpace)));
03118: }
03119:
03120: public Boolean apply() {
03121: return Analyzer
03122: .cast(null == Primitives.isBottom
03123: .apply(null == t ? null
03124: : t.in_top) ? null
03125: : Primitives.isBottom
03126: .apply(null == t ? null
03127: : t.in_top) ? Boolean.TRUE
03128: : Primitives.not
03129: .apply(null == t ? null
03130: : t.in_top));
03131: }
03132: }.apply());
03133: }
03134: };
03135:
03136: final Function.F2<CTypes.type, CTypes.type, Node> analyze_declarator = new Function.F2<CTypes.type, CTypes.type, Node>() {
03137: public CTypes.type apply(final CTypes.type t, final Node n) {
03138: return new Match<CTypes.type>() {
03139: public CTypes.type apply() {
03140: final Node arg$395 = GNode.cast(n);
03141:
03142: if ((null == arg$395)) {
03143: return null;
03144: }
03145: if (CSupport.match$9(arg$395)) {
03146: final Node pointer = (arg$395.size() > 0 ? arg$395
03147: .getGeneric(0)
03148: : null);
03149: final Node targ = (arg$395.size() > 1 ? arg$395
03150: .getGeneric(1) : null);
03151:
03152: matching_nodes.add(arg$395);
03153: if ((null != arg$395 && processScopeNodes
03154: .contains(arg$395.getName()))) {
03155: processScope(arg$395, getScope);
03156: }
03157: checkEnterScope(arg$395);
03158:
03159: final Object retValue$399 = Analyzer
03160: .cast(new Let<CTypes.type>() {
03161: final CTypes.type t1;
03162:
03163: {
03164: t1 = Analyzer
03165: .cast(analyze_pointer
03166: .apply(t,
03167: pointer));
03168: }
03169:
03170: public CTypes.type apply() {
03171: return Analyzer
03172: .cast(null == Primitives.isBottom
03173: .apply(targ) ? null
03174: : Primitives.isBottom
03175: .apply(targ) ? t1
03176: : analyze_declarator
03177: .apply(
03178: t1,
03179: targ));
03180: }
03181: }.apply());
03182:
03183: checkExitScope(arg$395);
03184: matching_nodes
03185: .remove(matching_nodes.size() - 1);
03186: return Analyzer.cast(retValue$399);
03187: }
03188: if (CSupport.match$17(arg$395)) {
03189: final Node dec = (arg$395.size() > 0 ? arg$395
03190: .getGeneric(0) : null);
03191: final Node idl = (arg$395.size() > 1 ? arg$395
03192: .getGeneric(1) : null);
03193:
03194: matching_nodes.add(arg$395);
03195: if ((null != arg$395 && processScopeNodes
03196: .contains(arg$395.getName()))) {
03197: processScope(arg$395, getScope);
03198: }
03199: checkEnterScope(arg$395);
03200:
03201: final Object retValue$437 = Analyzer
03202: .cast(null == Primitives.isBottom
03203: .apply(idl) ? null
03204: : Primitives.isBottom
03205: .apply(idl) ? new Let<CTypes.type>() {
03206: final CTypes.type ft;
03207:
03208: {
03209: ft = Analyzer
03210: .cast(new CTypes.type(
03211: new CTypes.FunctionT(
03212: t,
03213: null),
03214: null,
03215: null == t ? null
03216: : t.storage,
03217: null,
03218: null,
03219: null,
03220: null,
03221: null,
03222: null,
03223: null,
03224: null));
03225: }
03226:
03227: public CTypes.type apply() {
03228: return Analyzer
03229: .cast(analyze_declarator
03230: .apply(
03231: ft,
03232: dec));
03233: }
03234: }.apply()
03235: : new Match<CTypes.type>() {
03236: public CTypes.type apply() {
03237: final Node arg$418 = GNode
03238: .cast(idl);
03239:
03240: if ((null == arg$418)) {
03241: return null;
03242: }
03243: if (CSupport
03244: .match$402(arg$418)) {
03245: final Pair<String> strl = Analyzer
03246: .cast(Primitives
03247: .getChildren(
03248: arg$418,
03249: 0,
03250: arg$418
03251: .size()));
03252:
03253: matching_nodes
03254: .add(arg$418);
03255: if ((null != arg$418 && processScopeNodes
03256: .contains(arg$418
03257: .getName()))) {
03258: processScope(
03259: arg$418,
03260: getScope);
03261: }
03262: checkEnterScope(arg$418);
03263:
03264: final Object retValue$422 = Analyzer
03265: .cast(new Let<CTypes.type>() {
03266: final Pair<CTypes.type> tl;
03267: final CTypes.type ft;
03268:
03269: {
03270: tl = Analyzer
03271: .cast(define_id_list
03272: .apply(strl));
03273: ft = Analyzer
03274: .cast(new CTypes.type(
03275: new CTypes.FunctionT(
03276: t,
03277: tl),
03278: null,
03279: null == t ? null
03280: : t.storage,
03281: null,
03282: null,
03283: null,
03284: null,
03285: null,
03286: Boolean.TRUE,
03287: null,
03288: null));
03289: }
03290:
03291: public CTypes.type apply() {
03292: return Analyzer
03293: .cast(analyze_declarator
03294: .apply(
03295: ft,
03296: dec));
03297: }
03298: }
03299: .apply());
03300:
03301: checkExitScope(arg$418);
03302: matching_nodes
03303: .remove(matching_nodes
03304: .size() - 1);
03305: return Analyzer
03306: .cast(retValue$422);
03307: }
03308: if (true) {
03309: matching_nodes
03310: .add(arg$418);
03311: if ((null != arg$418 && processScopeNodes
03312: .contains(arg$418
03313: .getName()))) {
03314: processScope(
03315: arg$418,
03316: getScope);
03317: }
03318: checkEnterScope(arg$418);
03319:
03320: final Object retValue$433 = Analyzer
03321: .cast(new Let<CTypes.type>() {
03322: final CTypes.type lt;
03323: final CTypes.type ft;
03324:
03325: {
03326: lt = Analyzer
03327: .cast(analyze_para_type_list
03328: .apply(idl));
03329: ft = Analyzer
03330: .cast(new Match<CTypes.type>() {
03331: public CTypes.type apply() {
03332: final CTypes.raw_type<?> arg$427 = Analyzer
03333: .cast(null == lt ? null
03334: : lt.type);
03335:
03336: if ((null == arg$427)) {
03337: return null;
03338: }
03339: if ((null != arg$427))
03340: switch (arg$427
03341: .tag()) {
03342: case ListT:
03343: if (CSupport
03344: .match$295(arg$427)) {
03345: final Pair<CTypes.type> l = Analyzer
03346: .cast(arg$427
03347: .getTuple()
03348: .get1());
03349:
03350: return Analyzer
03351: .cast(new CTypes.type(
03352: new CTypes.FunctionT(
03353: t,
03354: l),
03355: null,
03356: null == t ? null
03357: : t.storage,
03358: null,
03359: null,
03360: null,
03361: null,
03362: null,
03363: null,
03364: null == lt ? null
03365: : lt.var_args,
03366: null));
03367: }
03368: break;
03369: case VoidT:
03370: if (CSupport
03371: .match$408(arg$427)) {
03372: return Analyzer
03373: .cast(new CTypes.type(
03374: new CTypes.FunctionT(
03375: t,
03376: new Pair<CTypes.type>(
03377: voidt)),
03378: null,
03379: null == t ? null
03380: : t.storage,
03381: null,
03382: null,
03383: null,
03384: null,
03385: null,
03386: null,
03387: null == lt ? null
03388: : lt.var_args,
03389: null));
03390: }
03391: break;
03392: default:
03393: break;
03394: }
03395: ;
03396: if (true) {
03397: return Analyzer
03398: .cast(null);
03399: }
03400: return null;
03401: }
03402: }
03403: .apply());
03404: }
03405:
03406: public CTypes.type apply() {
03407: return Analyzer
03408: .cast(analyze_declarator
03409: .apply(
03410: ft,
03411: dec));
03412: }
03413: }
03414: .apply());
03415:
03416: checkExitScope(arg$418);
03417: matching_nodes
03418: .remove(matching_nodes
03419: .size() - 1);
03420: return Analyzer
03421: .cast(retValue$433);
03422: }
03423: return null;
03424: }
03425: }.apply());
03426:
03427: checkExitScope(arg$395);
03428: matching_nodes
03429: .remove(matching_nodes.size() - 1);
03430: return Analyzer.cast(retValue$437);
03431: }
03432: if (CSupport.match$438(arg$395)) {
03433: final Node dec = (arg$395.size() > 0 ? arg$395
03434: .getGeneric(0) : null);
03435: final Node aq = Analyzer.cast(arg$395
03436: .getGeneric(1));
03437: final Node no = (arg$395.size() > 2 ? arg$395
03438: .getGeneric(2) : null);
03439:
03440: matching_nodes.add(arg$395);
03441: if ((null != arg$395 && processScopeNodes
03442: .contains(arg$395.getName()))) {
03443: processScope(arg$395, getScope);
03444: }
03445: checkEnterScope(arg$395);
03446:
03447: final Object retValue$459 = Analyzer
03448: .cast(new Let<CTypes.type>() {
03449: final Pair<Node> aql;
03450: final Pair<CTypes.qualifier> q;
03451: final CTypes.type aty;
03452:
03453: {
03454: aql = Analyzer
03455: .cast(new Match<Pair<Node>>() {
03456: public Pair<Node> apply() {
03457: final Node arg$448 = GNode
03458: .cast(aq);
03459:
03460: if ((null == arg$448)) {
03461: return null;
03462: }
03463: if (CSupport
03464: .match$440(arg$448)) {
03465: final Pair<Node> ql = Analyzer
03466: .cast(Primitives
03467: .getChildren(
03468: arg$448,
03469: 0,
03470: arg$448
03471: .size()));
03472:
03473: matching_nodes
03474: .add(arg$448);
03475: if ((null != arg$448 && processScopeNodes
03476: .contains(arg$448
03477: .getName()))) {
03478: processScope(
03479: arg$448,
03480: getScope);
03481: }
03482: checkEnterScope(arg$448);
03483:
03484: final Object retValue$452 = Analyzer
03485: .cast(ql);
03486:
03487: checkExitScope(arg$448);
03488: matching_nodes
03489: .remove(matching_nodes
03490: .size() - 1);
03491: return Analyzer
03492: .cast(retValue$452);
03493: }
03494: if (true) {
03495: matching_nodes
03496: .add(arg$448);
03497: if ((null != arg$448 && processScopeNodes
03498: .contains(arg$448
03499: .getName()))) {
03500: processScope(
03501: arg$448,
03502: getScope);
03503: }
03504: checkEnterScope(arg$448);
03505:
03506: final Object retValue$455 = Analyzer
03507: .cast(null);
03508:
03509: checkExitScope(arg$448);
03510: matching_nodes
03511: .remove(matching_nodes
03512: .size() - 1);
03513: return Analyzer
03514: .cast(retValue$455);
03515: }
03516: return null;
03517: }
03518: }.apply());
03519: q = Analyzer
03520: .cast(extractQualifier
03521: .apply(aql));
03522: aty = Analyzer
03523: .cast(processArray
03524: .apply(t, no));
03525: }
03526:
03527: public CTypes.type apply() {
03528: return Analyzer
03529: .cast(null == Primitives.isNotBottom
03530: .apply(aty)
03531: || !Primitives.isNotBottom
03532: .apply(aty) ? null
03533: : analyze_declarator
03534: .apply(
03535: new CTypes.type(
03536: null == aty ? null
03537: : aty.type,
03538: q,
03539: null == aty ? null
03540: : aty.storage,
03541: null == aty ? null
03542: : aty.fSpec,
03543: null == aty ? null
03544: : aty.value,
03545: null == aty ? null
03546: : aty.implicit,
03547: null == aty ? null
03548: : aty.initialised,
03549: null == aty ? null
03550: : aty.position,
03551: null == aty ? null
03552: : aty.old_style,
03553: null == aty ? null
03554: : aty.var_args,
03555: null == aty ? null
03556: : aty.in_top),
03557: dec));
03558: }
03559: }.apply());
03560:
03561: checkExitScope(arg$395);
03562: matching_nodes
03563: .remove(matching_nodes.size() - 1);
03564: return Analyzer.cast(retValue$459);
03565: }
03566: if (CSupport.match$65(arg$395)) {
03567: final Node dec = (arg$395.size() > 1 ? arg$395
03568: .getGeneric(1) : null);
03569:
03570: matching_nodes.add(arg$395);
03571: if ((null != arg$395 && processScopeNodes
03572: .contains(arg$395.getName()))) {
03573: processScope(arg$395, getScope);
03574: }
03575: checkEnterScope(arg$395);
03576:
03577: final Object retValue$466 = Analyzer
03578: .cast(new Let<CTypes.type>() {
03579: final String s;
03580: final CTypes.type t1;
03581:
03582: {
03583: s = Analyzer
03584: .cast(get_id_declarator
03585: .apply(dec));
03586: t1 = Analyzer
03587: .cast(analyze_declarator
03588: .apply(t, dec));
03589: }
03590:
03591: public CTypes.type apply() {
03592: return Analyzer
03593: .cast(null == Primitives.isNotBottom
03594: .apply(ancestor
03595: .apply(CSupport.nodeMatch$462)) ? null
03596: : Primitives.isNotBottom
03597: .apply(ancestor
03598: .apply(CSupport.nodeMatch$462)) ? (null == Primitives.and
03599: .apply(
03600: Primitives.not
03601: .apply(is_array
03602: .apply(t1)),
03603: is_incomplete
03604: .apply(t1)) ? null
03605: : Primitives.and
03606: .apply(
03607: Primitives.not
03608: .apply(is_array
03609: .apply(t1)),
03610: is_incomplete
03611: .apply(t1)) ? error(
03612: Primitives.concat
03613: .apply(
03614: Primitives.concat
03615: .apply(
03616: "field ",
03617: s),
03618: " has incomplete type"),
03619: null)
03620: : new CTypes.type(
03621: new CTypes.MemberT(
03622: s,
03623: t1),
03624: null,
03625: null,
03626: null,
03627: null,
03628: null,
03629: null,
03630: null,
03631: null,
03632: null,
03633: null))
03634: : t1);
03635: }
03636: }.apply());
03637:
03638: checkExitScope(arg$395);
03639: matching_nodes
03640: .remove(matching_nodes.size() - 1);
03641: return Analyzer.cast(retValue$466);
03642: }
03643: if (CSupport.match$5(arg$395)) {
03644: matching_nodes.add(arg$395);
03645: if ((null != arg$395 && processScopeNodes
03646: .contains(arg$395.getName()))) {
03647: processScope(arg$395, getScope);
03648: }
03649: checkEnterScope(arg$395);
03650:
03651: final Object retValue$470 = Analyzer.cast(t);
03652:
03653: checkExitScope(arg$395);
03654: matching_nodes
03655: .remove(matching_nodes.size() - 1);
03656: return Analyzer.cast(retValue$470);
03657: }
03658: if (CSupport.match$471(arg$395)) {
03659: final Node sd = (arg$395.size() > 1 ? arg$395
03660: .getGeneric(1) : null);
03661: final Node val = (arg$395.size() > 2 ? arg$395
03662: .getGeneric(2) : null);
03663:
03664: matching_nodes.add(arg$395);
03665: if ((null != arg$395 && processScopeNodes
03666: .contains(arg$395.getName()))) {
03667: processScope(arg$395, getScope);
03668: }
03669: checkEnterScope(arg$395);
03670:
03671: final Object retValue$474 = Analyzer
03672: .cast(new Let<CTypes.type>() {
03673: final CTypes.type t1;
03674: final String s;
03675: final BigInteger i;
03676: final CTypes.type ty;
03677:
03678: {
03679: t1 = Analyzer
03680: .cast(analyze_expression
03681: .apply(val));
03682: s = Analyzer
03683: .cast(get_id_declarator
03684: .apply(sd));
03685: i = Analyzer.cast(get_int
03686: .apply(t1));
03687: ty = Analyzer
03688: .cast(new CTypes.type(
03689: new CTypes.BitfieldT(
03690: t, i),
03691: null, null,
03692: null, null,
03693: null, null,
03694: null, null,
03695: null, null));
03696: }
03697:
03698: public CTypes.type apply() {
03699: return Analyzer
03700: .cast(null == Primitives.and
03701: .apply(
03702: Primitives.isNotBottom
03703: .apply(t),
03704: Primitives.greaterEqualInt
03705: .apply(
03706: i,
03707: BigInteger
03708: .valueOf(0))) ? null
03709: : Primitives.and
03710: .apply(
03711: Primitives.isNotBottom
03712: .apply(t),
03713: Primitives.greaterEqualInt
03714: .apply(
03715: i,
03716: BigInteger
03717: .valueOf(0))) ? new CTypes.type(
03718: new CTypes.MemberT(
03719: s,
03720: ty),
03721: null,
03722: null,
03723: null,
03724: null,
03725: null,
03726: null,
03727: null,
03728: null,
03729: null,
03730: null)
03731: : error(
03732: "negative width in bit-field",
03733: null));
03734: }
03735: }.apply());
03736:
03737: checkExitScope(arg$395);
03738: matching_nodes
03739: .remove(matching_nodes.size() - 1);
03740: return Analyzer.cast(retValue$474);
03741: }
03742: if (true) {
03743: matching_nodes.add(arg$395);
03744: if ((null != arg$395 && processScopeNodes
03745: .contains(arg$395.getName()))) {
03746: processScope(arg$395, getScope);
03747: }
03748: checkEnterScope(arg$395);
03749:
03750: final Object retValue$477 = Analyzer.cast(null);
03751:
03752: checkExitScope(arg$395);
03753: matching_nodes
03754: .remove(matching_nodes.size() - 1);
03755: return Analyzer.cast(retValue$477);
03756: }
03757: return null;
03758: }
03759: }.apply();
03760: }
03761: };
03762:
03763: final Function.F4<CTypes.type, Boolean, Pair<CTypes.label_record>, Boolean, Node> analyze_statement = new Function.F4<CTypes.type, Boolean, Pair<CTypes.label_record>, Boolean, Node>() {
03764: public CTypes.type apply(final Boolean is_body,
03765: final Pair<CTypes.label_record> lbl,
03766: final Boolean is_expr, final Node n) {
03767: return (null == Primitives.isBottom.apply(n) ? null
03768: : Primitives.isBottom.apply(n) ? voidt
03769: : new Match<CTypes.type>() {
03770: public CTypes.type apply() {
03771: final Node arg$479 = GNode.cast(n);
03772:
03773: if ((null == arg$479)) {
03774: return null;
03775: }
03776: if (CSupport.match$480(arg$479)) {
03777: matching_nodes.add(arg$479);
03778: if ((null != arg$479 && processScopeNodes
03779: .contains(arg$479
03780: .getName()))) {
03781: processScope(arg$479,
03782: getScope);
03783: }
03784: checkEnterScope(arg$479);
03785:
03786: final Object retValue$483 = Analyzer
03787: .cast(voidt);
03788:
03789: checkExitScope(arg$479);
03790: matching_nodes
03791: .remove(matching_nodes
03792: .size() - 1);
03793: return Analyzer
03794: .cast(retValue$483);
03795: }
03796: if (CSupport.match$484(arg$479)) {
03797: final Node e = (arg$479.size() > 0 ? arg$479
03798: .getGeneric(0)
03799: : null);
03800:
03801: matching_nodes.add(arg$479);
03802: if ((null != arg$479 && processScopeNodes
03803: .contains(arg$479
03804: .getName()))) {
03805: processScope(arg$479,
03806: getScope);
03807: }
03808: checkEnterScope(arg$479);
03809:
03810: final Object retValue$487 = Analyzer
03811: .cast(analyze_expression
03812: .apply(e));
03813:
03814: checkExitScope(arg$479);
03815: matching_nodes
03816: .remove(matching_nodes
03817: .size() - 1);
03818: return Analyzer
03819: .cast(retValue$487);
03820: }
03821: if (CSupport.match$488(arg$479)) {
03822: final Pair<Node> l = Analyzer
03823: .cast(Primitives
03824: .getChildren(
03825: arg$479,
03826: 0,
03827: arg$479
03828: .size()));
03829:
03830: matching_nodes.add(arg$479);
03831: if ((null != arg$479 && processScopeNodes
03832: .contains(arg$479
03833: .getName()))) {
03834: processScope(arg$479,
03835: getScope);
03836: }
03837: checkEnterScope(arg$479);
03838:
03839: final Object retValue$492 = Analyzer
03840: .cast(new Let<CTypes.type>() {
03841: final Pair<CTypes.label_record> local_labels;
03842: final Pair<CTypes.type> tl;
03843:
03844: {
03845: Analyzer
03846: .discard(null == is_body
03847: || !is_body ? null
03848: : define_labels
03849: .apply(
03850: lbl,
03851: Boolean.TRUE));
03852: local_labels = Analyzer
03853: .cast(find_local_labels
03854: .apply(
03855: l,
03856: Pair
03857: .<CTypes.label_record> empty()));
03858: define_labels
03859: .apply(
03860: local_labels,
03861: Boolean.FALSE);
03862: tl = Analyzer
03863: .cast(CSupport.map$212
03864: .apply(
03865: analyze_generic,
03866: l));
03867: }
03868:
03869: public CTypes.type apply() {
03870: return Analyzer
03871: .cast(null == is_expr ? null
03872: : is_expr ? new Let<CTypes.type>() {
03873: final CTypes.type lastt;
03874:
03875: {
03876: lastt = Analyzer
03877: .cast(null == Primitives.greaterInt
03878: .apply(
03879: Primitives.length
03880: .apply(tl),
03881: BigInteger
03882: .valueOf(1)) ? null
03883: : Primitives.greaterInt
03884: .apply(
03885: Primitives.length
03886: .apply(tl),
03887: BigInteger
03888: .valueOf(1)) ? CSupport.nth$489
03889: .apply(
03890: tl,
03891: Primitives.subtractInt
03892: .apply(
03893: Primitives.length
03894: .apply(tl),
03895: BigInteger
03896: .valueOf(2)))
03897: : CSupport.nth$489
03898: .apply(
03899: tl,
03900: Primitives.subtractInt
03901: .apply(
03902: Primitives.length
03903: .apply(tl),
03904: BigInteger
03905: .valueOf(1))));
03906: }
03907:
03908: public CTypes.type apply() {
03909: return Analyzer
03910: .cast(null == Primitives.and
03911: .apply(
03912: Primitives.isNotBottom
03913: .apply(lastt),
03914: Primitives.not
03915: .apply(is_void
03916: .apply(lastt))) ? null
03917: : Primitives.and
03918: .apply(
03919: Primitives.isNotBottom
03920: .apply(lastt),
03921: Primitives.not
03922: .apply(is_void
03923: .apply(lastt))) ? lastt
03924: : voidt);
03925: }
03926: }
03927: .apply()
03928: : voidt);
03929: }
03930: }.apply());
03931:
03932: checkExitScope(arg$479);
03933: matching_nodes
03934: .remove(matching_nodes
03935: .size() - 1);
03936: return Analyzer
03937: .cast(retValue$492);
03938: }
03939: if (CSupport.match$493(arg$479)) {
03940: final Node e = (arg$479.size() > 0 ? arg$479
03941: .getGeneric(0)
03942: : null);
03943: final Node cs1 = (arg$479
03944: .size() > 1 ? arg$479
03945: .getGeneric(1) : null);
03946: final Node cs2 = (arg$479
03947: .size() > 2 ? arg$479
03948: .getGeneric(2) : null);
03949:
03950: matching_nodes.add(arg$479);
03951: if ((null != arg$479 && processScopeNodes
03952: .contains(arg$479
03953: .getName()))) {
03954: processScope(arg$479,
03955: getScope);
03956: }
03957: checkEnterScope(arg$479);
03958:
03959: final Object retValue$496 = Analyzer
03960: .cast(new Let<CTypes.type>() {
03961: {
03962: ensure_scalar
03963: .apply(
03964: pointerize
03965: .apply(analyze_expression
03966: .apply(e)),
03967: "conditional statement");
03968: analyze_statement
03969: .apply(
03970: Boolean.FALSE,
03971: Pair
03972: .<CTypes.label_record> empty(),
03973: Boolean.FALSE,
03974: cs1);
03975: analyze_statement
03976: .apply(
03977: Boolean.FALSE,
03978: Pair
03979: .<CTypes.label_record> empty(),
03980: Boolean.FALSE,
03981: cs2);
03982: }
03983:
03984: public CTypes.type apply() {
03985: return Analyzer
03986: .cast(voidt);
03987: }
03988: }.apply());
03989:
03990: checkExitScope(arg$479);
03991: matching_nodes
03992: .remove(matching_nodes
03993: .size() - 1);
03994: return Analyzer
03995: .cast(retValue$496);
03996: }
03997: if (CSupport.match$497(arg$479)) {
03998: final Node e = (arg$479.size() > 0 ? arg$479
03999: .getGeneric(0)
04000: : null);
04001: final Node cs = (arg$479.size() > 1 ? arg$479
04002: .getGeneric(1)
04003: : null);
04004:
04005: matching_nodes.add(arg$479);
04006: if ((null != arg$479 && processScopeNodes
04007: .contains(arg$479
04008: .getName()))) {
04009: processScope(arg$479,
04010: getScope);
04011: }
04012: checkEnterScope(arg$479);
04013:
04014: final Object retValue$500 = Analyzer
04015: .cast(new Let<CTypes.type>() {
04016: {
04017: ensure_scalar
04018: .apply(
04019: pointerize
04020: .apply(analyze_expression
04021: .apply(e)),
04022: "conditional statement");
04023: analyze_statement
04024: .apply(
04025: Boolean.FALSE,
04026: Pair
04027: .<CTypes.label_record> empty(),
04028: Boolean.FALSE,
04029: cs);
04030: }
04031:
04032: public CTypes.type apply() {
04033: return Analyzer
04034: .cast(voidt);
04035: }
04036: }.apply());
04037:
04038: checkExitScope(arg$479);
04039: matching_nodes
04040: .remove(matching_nodes
04041: .size() - 1);
04042: return Analyzer
04043: .cast(retValue$500);
04044: }
04045: if (CSupport.match$501(arg$479)) {
04046: final Node e = (arg$479.size() > 0 ? arg$479
04047: .getGeneric(0)
04048: : null);
04049: final Node cs = (arg$479.size() > 1 ? arg$479
04050: .getGeneric(1)
04051: : null);
04052:
04053: matching_nodes.add(arg$479);
04054: if ((null != arg$479 && processScopeNodes
04055: .contains(arg$479
04056: .getName()))) {
04057: processScope(arg$479,
04058: getScope);
04059: }
04060: checkEnterScope(arg$479);
04061:
04062: final Object retValue$504 = Analyzer
04063: .cast(new Let<CTypes.type>() {
04064: {
04065: ensure_scalar
04066: .apply(
04067: pointerize
04068: .apply(analyze_expression
04069: .apply(e)),
04070: "conditional statement");
04071: analyze_statement
04072: .apply(
04073: Boolean.FALSE,
04074: Pair
04075: .<CTypes.label_record> empty(),
04076: Boolean.FALSE,
04077: cs);
04078: }
04079:
04080: public CTypes.type apply() {
04081: return Analyzer
04082: .cast(voidt);
04083: }
04084: }.apply());
04085:
04086: checkExitScope(arg$479);
04087: matching_nodes
04088: .remove(matching_nodes
04089: .size() - 1);
04090: return Analyzer
04091: .cast(retValue$504);
04092: }
04093: if (CSupport.match$505(arg$479)) {
04094: final Node cs = (arg$479.size() > 0 ? arg$479
04095: .getGeneric(0)
04096: : null);
04097: final Node e = (arg$479.size() > 1 ? arg$479
04098: .getGeneric(1)
04099: : null);
04100:
04101: matching_nodes.add(arg$479);
04102: if ((null != arg$479 && processScopeNodes
04103: .contains(arg$479
04104: .getName()))) {
04105: processScope(arg$479,
04106: getScope);
04107: }
04108: checkEnterScope(arg$479);
04109:
04110: final Object retValue$508 = Analyzer
04111: .cast(new Let<CTypes.type>() {
04112: {
04113: ensure_scalar
04114: .apply(
04115: pointerize
04116: .apply(analyze_expression
04117: .apply(e)),
04118: "conditional statement");
04119: analyze_statement
04120: .apply(
04121: Boolean.FALSE,
04122: Pair
04123: .<CTypes.label_record> empty(),
04124: Boolean.FALSE,
04125: cs);
04126: }
04127:
04128: public CTypes.type apply() {
04129: return Analyzer
04130: .cast(voidt);
04131: }
04132: }.apply());
04133:
04134: checkExitScope(arg$479);
04135: matching_nodes
04136: .remove(matching_nodes
04137: .size() - 1);
04138: return Analyzer
04139: .cast(retValue$508);
04140: }
04141: if (CSupport.match$509(arg$479)) {
04142: final Node e = (arg$479.size() > 0 ? arg$479
04143: .getGeneric(0)
04144: : null);
04145: final Node cs = (arg$479.size() > 1 ? arg$479
04146: .getGeneric(1)
04147: : null);
04148:
04149: matching_nodes.add(arg$479);
04150: if ((null != arg$479 && processScopeNodes
04151: .contains(arg$479
04152: .getName()))) {
04153: processScope(arg$479,
04154: getScope);
04155: }
04156: checkEnterScope(arg$479);
04157:
04158: final Object retValue$512 = Analyzer
04159: .cast(new Let<CTypes.type>() {
04160: {
04161: ensure_integer
04162: .apply(
04163: analyze_expression
04164: .apply(e),
04165: "switch expression");
04166: analyze_statement
04167: .apply(
04168: Boolean.FALSE,
04169: Pair
04170: .<CTypes.label_record> empty(),
04171: Boolean.FALSE,
04172: cs);
04173: }
04174:
04175: public CTypes.type apply() {
04176: return Analyzer
04177: .cast(voidt);
04178: }
04179: }.apply());
04180:
04181: checkExitScope(arg$479);
04182: matching_nodes
04183: .remove(matching_nodes
04184: .size() - 1);
04185: return Analyzer
04186: .cast(retValue$512);
04187: }
04188: if (CSupport.match$82(arg$479)) {
04189: final Node n1 = (arg$479.size() > 0 ? arg$479
04190: .getGeneric(0)
04191: : null);
04192: final Node n2 = (arg$479.size() > 1 ? arg$479
04193: .getGeneric(1)
04194: : null);
04195: final Node n3 = (arg$479.size() > 2 ? arg$479
04196: .getGeneric(2)
04197: : null);
04198: final Node cs = (arg$479.size() > 3 ? arg$479
04199: .getGeneric(3)
04200: : null);
04201:
04202: matching_nodes.add(arg$479);
04203: if ((null != arg$479 && processScopeNodes
04204: .contains(arg$479
04205: .getName()))) {
04206: processScope(arg$479,
04207: getScope);
04208: }
04209: checkEnterScope(arg$479);
04210:
04211: final Object retValue$516 = Analyzer
04212: .cast(new Let<CTypes.type>() {
04213: {
04214: analyze_init_clause
04215: .apply(n1);
04216: ensure_scalar
04217: .apply(
04218: pointerize
04219: .apply(analyze_expression
04220: .apply(n2)),
04221: "for expression");
04222: analyze_expression
04223: .apply(n3);
04224: analyze_statement
04225: .apply(
04226: Boolean.FALSE,
04227: Pair
04228: .<CTypes.label_record> empty(),
04229: Boolean.FALSE,
04230: cs);
04231: }
04232:
04233: public CTypes.type apply() {
04234: return Analyzer
04235: .cast(voidt);
04236: }
04237: }.apply());
04238:
04239: checkExitScope(arg$479);
04240: matching_nodes
04241: .remove(matching_nodes
04242: .size() - 1);
04243: return Analyzer
04244: .cast(retValue$516);
04245: }
04246: if (CSupport.match$517(arg$479)) {
04247: matching_nodes.add(arg$479);
04248: if ((null != arg$479 && processScopeNodes
04249: .contains(arg$479
04250: .getName()))) {
04251: processScope(arg$479,
04252: getScope);
04253: }
04254: checkEnterScope(arg$479);
04255:
04256: final Object retValue$520 = Analyzer
04257: .cast(new Let<CTypes.type>() {
04258: {
04259: ensure_in_loop_or_switch
04260: .apply(n);
04261: }
04262:
04263: public CTypes.type apply() {
04264: return Analyzer
04265: .cast(voidt);
04266: }
04267: }.apply());
04268:
04269: checkExitScope(arg$479);
04270: matching_nodes
04271: .remove(matching_nodes
04272: .size() - 1);
04273: return Analyzer
04274: .cast(retValue$520);
04275: }
04276: if (CSupport.match$521(arg$479)) {
04277: matching_nodes.add(arg$479);
04278: if ((null != arg$479 && processScopeNodes
04279: .contains(arg$479
04280: .getName()))) {
04281: processScope(arg$479,
04282: getScope);
04283: }
04284: checkEnterScope(arg$479);
04285:
04286: final Object retValue$524 = Analyzer
04287: .cast(new Let<CTypes.type>() {
04288: {
04289: ensure_in_loop
04290: .apply(n);
04291: }
04292:
04293: public CTypes.type apply() {
04294: return Analyzer
04295: .cast(voidt);
04296: }
04297: }.apply());
04298:
04299: checkExitScope(arg$479);
04300: matching_nodes
04301: .remove(matching_nodes
04302: .size() - 1);
04303: return Analyzer
04304: .cast(retValue$524);
04305: }
04306: if (CSupport.match$525(arg$479)) {
04307: final String str = (arg$479
04308: .size() > 0 ? arg$479
04309: .getString(0) : null);
04310: final Node p = Analyzer
04311: .cast(arg$479
04312: .getGeneric(1));
04313:
04314: matching_nodes.add(arg$479);
04315: if ((null != arg$479 && processScopeNodes
04316: .contains(arg$479
04317: .getName()))) {
04318: processScope(arg$479,
04319: getScope);
04320: }
04321: checkEnterScope(arg$479);
04322:
04323: final Object retValue$546 = Analyzer
04324: .cast(new Let<CTypes.type>() {
04325: final String s;
04326:
04327: {
04328: s = Analyzer
04329: .cast(new Match<String>() {
04330: public String apply() {
04331: final Node arg$535 = GNode
04332: .cast(p);
04333:
04334: if ((null == arg$535)) {
04335: return null;
04336: }
04337: if (CSupport
04338: .match$1(arg$535)) {
04339: final String name = (arg$535
04340: .size() > 0 ? arg$535
04341: .getString(0)
04342: : null);
04343:
04344: matching_nodes
04345: .add(arg$535);
04346: if ((null != arg$535 && processScopeNodes
04347: .contains(arg$535
04348: .getName()))) {
04349: processScope(
04350: arg$535,
04351: getScope);
04352: }
04353: checkEnterScope(arg$535);
04354:
04355: final Object retValue$539 = Analyzer
04356: .cast(name);
04357:
04358: checkExitScope(arg$535);
04359: matching_nodes
04360: .remove(matching_nodes
04361: .size() - 1);
04362: return Analyzer
04363: .cast(retValue$539);
04364: }
04365: if (true) {
04366: matching_nodes
04367: .add(arg$535);
04368: if ((null != arg$535 && processScopeNodes
04369: .contains(arg$535
04370: .getName()))) {
04371: processScope(
04372: arg$535,
04373: getScope);
04374: }
04375: checkEnterScope(arg$535);
04376:
04377: final Object retValue$542 = Analyzer
04378: .cast(null);
04379:
04380: checkExitScope(arg$535);
04381: matching_nodes
04382: .remove(matching_nodes
04383: .size() - 1);
04384: return Analyzer
04385: .cast(retValue$542);
04386: }
04387: return null;
04388: }
04389: }
04390: .apply());
04391: }
04392:
04393: public CTypes.type apply() {
04394: return Analyzer
04395: .cast(null == Primitives.isBottom
04396: .apply(str) ? null
04397: : Primitives.isBottom
04398: .apply(str) ? (null == Primitives.not
04399: .apply(isDefined
04400: .apply(
04401: n,
04402: getNameSpace)) ? null
04403: : Primitives.not
04404: .apply(isDefined
04405: .apply(
04406: n,
04407: getNameSpace)) ? new Let<CTypes.type>() {
04408: {
04409: error(
04410: Primitives.concat
04411: .apply(
04412: Primitives.concat
04413: .apply(
04414: "label '",
04415: s),
04416: "' used but not defined"),
04417: null);
04418: }
04419:
04420: public CTypes.type apply() {
04421: return Analyzer
04422: .cast(voidt);
04423: }
04424: }
04425: .apply()
04426: : new Let<CTypes.type>() {
04427: final CTypes.type lt;
04428:
04429: {
04430: lt = Analyzer
04431: .cast(Analyzer
04432: .cast(lookup2
04433: .apply(
04434: n,
04435: getNameSpace)));
04436: }
04437:
04438: public CTypes.type apply() {
04439: return Analyzer
04440: .cast(null == Primitives.not
04441: .apply(null == lt ? null
04442: : lt.initialised) ? null
04443: : Primitives.not
04444: .apply(null == lt ? null
04445: : lt.initialised) ? new Let<CTypes.type>() {
04446: {
04447: error(
04448: Primitives.concat
04449: .apply(
04450: Primitives.concat
04451: .apply(
04452: "label '",
04453: s),
04454: "' used but not defined"),
04455: null);
04456: }
04457:
04458: public CTypes.type apply() {
04459: return Analyzer
04460: .cast(voidt);
04461: }
04462: }
04463: .apply()
04464: : voidt);
04465: }
04466: }
04467: .apply())
04468: : new Let<CTypes.type>() {
04469: {
04470: analyze_expression
04471: .apply(p);
04472: }
04473:
04474: public CTypes.type apply() {
04475: return Analyzer
04476: .cast(voidt);
04477: }
04478: }
04479: .apply());
04480: }
04481: }.apply());
04482:
04483: checkExitScope(arg$479);
04484: matching_nodes
04485: .remove(matching_nodes
04486: .size() - 1);
04487: return Analyzer
04488: .cast(retValue$546);
04489: }
04490: if (CSupport.match$547(arg$479)) {
04491: final Node e = (arg$479.size() > 1 ? arg$479
04492: .getGeneric(1)
04493: : null);
04494:
04495: matching_nodes.add(arg$479);
04496: if ((null != arg$479 && processScopeNodes
04497: .contains(arg$479
04498: .getName()))) {
04499: processScope(arg$479,
04500: getScope);
04501: }
04502: checkEnterScope(arg$479);
04503:
04504: final Object retValue$550 = Analyzer
04505: .cast(new Let<CTypes.type>() {
04506: {
04507: analyze_expression
04508: .apply(e);
04509: }
04510:
04511: public CTypes.type apply() {
04512: return Analyzer
04513: .cast(voidt);
04514: }
04515: }.apply());
04516:
04517: checkExitScope(arg$479);
04518: matching_nodes
04519: .remove(matching_nodes
04520: .size() - 1);
04521: return Analyzer
04522: .cast(retValue$550);
04523: }
04524: if (CSupport.match$551(arg$479)) {
04525: final Node lb = (arg$479.size() > 0 ? arg$479
04526: .getGeneric(0)
04527: : null);
04528: final Node st = (arg$479.size() > 1 ? arg$479
04529: .getGeneric(1)
04530: : null);
04531:
04532: matching_nodes.add(arg$479);
04533: if ((null != arg$479 && processScopeNodes
04534: .contains(arg$479
04535: .getName()))) {
04536: processScope(arg$479,
04537: getScope);
04538: }
04539: checkEnterScope(arg$479);
04540:
04541: final Object retValue$554 = Analyzer
04542: .cast(new Let<CTypes.type>() {
04543: {
04544: analyze_label
04545: .apply(lb);
04546: analyze_statement
04547: .apply(
04548: Boolean.FALSE,
04549: Pair
04550: .<CTypes.label_record> empty(),
04551: Boolean.FALSE,
04552: st);
04553: }
04554:
04555: public CTypes.type apply() {
04556: return Analyzer
04557: .cast(voidt);
04558: }
04559: }.apply());
04560:
04561: checkExitScope(arg$479);
04562: matching_nodes
04563: .remove(matching_nodes
04564: .size() - 1);
04565: return Analyzer
04566: .cast(retValue$554);
04567: }
04568: if (CSupport.match$555(arg$479)) {
04569: matching_nodes.add(arg$479);
04570: if ((null != arg$479 && processScopeNodes
04571: .contains(arg$479
04572: .getName()))) {
04573: processScope(arg$479,
04574: getScope);
04575: }
04576: checkEnterScope(arg$479);
04577:
04578: final Object retValue$558 = Analyzer
04579: .cast(voidt);
04580:
04581: checkExitScope(arg$479);
04582: matching_nodes
04583: .remove(matching_nodes
04584: .size() - 1);
04585: return Analyzer
04586: .cast(retValue$558);
04587: }
04588: if (CSupport.match$559(arg$479)) {
04589: final Node e = (arg$479.size() > 0 ? arg$479
04590: .getGeneric(0)
04591: : null);
04592:
04593: matching_nodes.add(arg$479);
04594: if ((null != arg$479 && processScopeNodes
04595: .contains(arg$479
04596: .getName()))) {
04597: processScope(arg$479,
04598: getScope);
04599: }
04600: checkEnterScope(arg$479);
04601:
04602: final Object retValue$582 = Analyzer
04603: .cast(new Let<CTypes.type>() {
04604: final CTypes.type t;
04605: final CTypes.type rt;
04606:
04607: {
04608: t = Analyzer
04609: .cast(analyze_expression
04610: .apply(e));
04611: rt = Analyzer
04612: .cast(new Match<CTypes.type>() {
04613: public CTypes.type apply() {
04614: final Node arg$570 = GNode
04615: .cast(ancestor
04616: .apply(CSupport.nodeMatch$75));
04617:
04618: if ((null == arg$570)) {
04619: return null;
04620: }
04621: if (CSupport
04622: .match$79(arg$570)) {
04623: final Node fd = (arg$570
04624: .size() > 2 ? arg$570
04625: .getGeneric(2)
04626: : null);
04627:
04628: matching_nodes
04629: .add(arg$570);
04630: if ((null != arg$570 && processScopeNodes
04631: .contains(arg$570
04632: .getName()))) {
04633: processScope(
04634: arg$570,
04635: getScope);
04636: }
04637: checkEnterScope(arg$570);
04638:
04639: final Object retValue$575 = Analyzer
04640: .cast(new Let<CTypes.type>() {
04641: final CTypes.type ft;
04642:
04643: {
04644: ft = Analyzer
04645: .cast(Analyzer
04646: .cast(lookup2
04647: .apply(
04648: fd,
04649: getNameSpace)));
04650: }
04651:
04652: public CTypes.type apply() {
04653: return Analyzer
04654: .cast(get_return_type
04655: .apply(ft));
04656: }
04657: }
04658: .apply());
04659:
04660: checkExitScope(arg$570);
04661: matching_nodes
04662: .remove(matching_nodes
04663: .size() - 1);
04664: return Analyzer
04665: .cast(retValue$575);
04666: }
04667: if (true) {
04668: matching_nodes
04669: .add(arg$570);
04670: if ((null != arg$570 && processScopeNodes
04671: .contains(arg$570
04672: .getName()))) {
04673: processScope(
04674: arg$570,
04675: getScope);
04676: }
04677: checkEnterScope(arg$570);
04678:
04679: final Object retValue$578 = Analyzer
04680: .cast(null);
04681:
04682: checkExitScope(arg$570);
04683: matching_nodes
04684: .remove(matching_nodes
04685: .size() - 1);
04686: return Analyzer
04687: .cast(retValue$578);
04688: }
04689: return null;
04690: }
04691: }
04692: .apply());
04693: Analyzer
04694: .discard(null == Primitives.and
04695: .apply(
04696: Primitives.and
04697: .apply(
04698: Primitives.isNotBottom
04699: .apply(t),
04700: is_void
04701: .apply(rt)),
04702: Primitives.not
04703: .apply(is_void
04704: .apply(t))) ? null
04705: : Primitives.and
04706: .apply(
04707: Primitives.and
04708: .apply(
04709: Primitives.isNotBottom
04710: .apply(t),
04711: is_void
04712: .apply(rt)),
04713: Primitives.not
04714: .apply(is_void
04715: .apply(t))) ? warning(
04716: "'return with a value in function returning void",
04717: null)
04718: : null == Primitives.and
04719: .apply(
04720: Primitives.or
04721: .apply(
04722: is_pointer
04723: .apply(t),
04724: is_array
04725: .apply(t)),
04726: is_integer
04727: .apply(rt)) ? null
04728: : Primitives.and
04729: .apply(
04730: Primitives.or
04731: .apply(
04732: is_pointer
04733: .apply(t),
04734: is_array
04735: .apply(t)),
04736: is_integer
04737: .apply(rt)) ? warning(
04738: "return makes integer from pointer without cast",
04739: null)
04740: : null == Primitives.and
04741: .apply(
04742: is_struct_union
04743: .apply(t),
04744: is_incomplete
04745: .apply(t)) ? null
04746: : Primitives.and
04747: .apply(
04748: is_struct_union
04749: .apply(t),
04750: is_incomplete
04751: .apply(t)) ? error(
04752: "return incomplete type",
04753: null)
04754: : processAssignment
04755: .apply(
04756: Boolean.FALSE,
04757: rt,
04758: "return statement",
04759: t));
04760: }
04761:
04762: public CTypes.type apply() {
04763: return Analyzer
04764: .cast(voidt);
04765: }
04766: }.apply());
04767:
04768: checkExitScope(arg$479);
04769: matching_nodes
04770: .remove(matching_nodes
04771: .size() - 1);
04772: return Analyzer
04773: .cast(retValue$582);
04774: }
04775: if (true) {
04776: matching_nodes.add(arg$479);
04777: if ((null != arg$479 && processScopeNodes
04778: .contains(arg$479
04779: .getName()))) {
04780: processScope(arg$479,
04781: getScope);
04782: }
04783: checkEnterScope(arg$479);
04784:
04785: final Object retValue$585 = Analyzer
04786: .cast(voidt);
04787:
04788: checkExitScope(arg$479);
04789: matching_nodes
04790: .remove(matching_nodes
04791: .size() - 1);
04792: return Analyzer
04793: .cast(retValue$585);
04794: }
04795: return null;
04796: }
04797: }.apply());
04798: }
04799: };
04800:
04801: final Function.F2<BigInteger, Node, BigInteger> analyze_enumerator = new Function.F2<BigInteger, Node, BigInteger>() {
04802: public BigInteger apply(final Node n, final BigInteger val) {
04803: return (null == Primitives.isBottom.apply(n) ? null
04804: : Primitives.isBottom.apply(n) ? Primitives.addInt
04805: .apply(val, BigInteger.valueOf(1))
04806: : new Match<BigInteger>() {
04807: public BigInteger apply() {
04808: final Node arg$587 = GNode.cast(n);
04809:
04810: if ((null == arg$587)) {
04811: return null;
04812: }
04813: if (CSupport.match$21(arg$587)) {
04814: final Node n1 = (arg$587.size() > 1 ? arg$587
04815: .getGeneric(1)
04816: : null);
04817:
04818: matching_nodes.add(arg$587);
04819: if ((null != arg$587 && processScopeNodes
04820: .contains(arg$587
04821: .getName()))) {
04822: processScope(arg$587,
04823: getScope);
04824: }
04825: checkEnterScope(arg$587);
04826:
04827: final Object retValue$591 = Analyzer
04828: .cast(null == Primitives.isBottom
04829: .apply(n1) ? null
04830: : Primitives.isBottom
04831: .apply(n1) ? new Let<BigInteger>() {
04832: {
04833: define3
04834: .apply(
04835: n,
04836: new CTypes.type(
04837: new CTypes.IntT(),
04838: new Pair<CTypes.qualifier>(
04839: new CTypes.ConstQ()),
04840: null,
04841: null,
04842: new CTypes.IValue(
04843: val),
04844: null,
04845: null,
04846: null,
04847: null,
04848: null,
04849: null),
04850: getNameSpace);
04851: }
04852:
04853: public BigInteger apply() {
04854: return Analyzer
04855: .cast(Primitives.addInt
04856: .apply(
04857: val,
04858: BigInteger
04859: .valueOf(1)));
04860: }
04861: }.apply()
04862: : new Let<BigInteger>() {
04863: final CTypes.type t;
04864: final BigInteger new_val;
04865:
04866: {
04867: t = Analyzer
04868: .cast(ensure_integer
04869: .apply(
04870: analyze_expression
04871: .apply(n1),
04872: "enumerator"));
04873: define3
04874: .apply(
04875: n,
04876: t,
04877: getNameSpace);
04878: new_val = Analyzer
04879: .cast(get_int
04880: .apply(t));
04881: }
04882:
04883: public BigInteger apply() {
04884: return Analyzer
04885: .cast(null == Primitives.isBottom
04886: .apply(new_val) ? null
04887: : Primitives.isBottom
04888: .apply(new_val) ? Primitives.addInt
04889: .apply(
04890: val,
04891: BigInteger
04892: .valueOf(1))
04893: : Primitives.addInt
04894: .apply(
04895: new_val,
04896: BigInteger
04897: .valueOf(1)));
04898: }
04899: }
04900: .apply());
04901:
04902: checkExitScope(arg$587);
04903: matching_nodes
04904: .remove(matching_nodes
04905: .size() - 1);
04906: return Analyzer
04907: .cast(retValue$591);
04908: }
04909: if (true) {
04910: matching_nodes.add(arg$587);
04911: if ((null != arg$587 && processScopeNodes
04912: .contains(arg$587
04913: .getName()))) {
04914: processScope(arg$587,
04915: getScope);
04916: }
04917: checkEnterScope(arg$587);
04918:
04919: final Object retValue$594 = Analyzer
04920: .cast(Primitives.addInt
04921: .apply(
04922: val,
04923: BigInteger
04924: .valueOf(1)));
04925:
04926: checkExitScope(arg$587);
04927: matching_nodes
04928: .remove(matching_nodes
04929: .size() - 1);
04930: return Analyzer
04931: .cast(retValue$594);
04932: }
04933: return null;
04934: }
04935: }.apply());
04936: }
04937: };
04938:
04939: final Function.F1<CTypes.type, Node> analyze_expression = new Function.F1<CTypes.type, Node>() {
04940: public CTypes.type apply(final Node n) {
04941: return new Match<CTypes.type>() {
04942: public CTypes.type apply() {
04943: final Node arg$596 = GNode.cast(n);
04944:
04945: if ((null == arg$596)) {
04946: return null;
04947: }
04948: if (CSupport.match$597(arg$596)) {
04949: final Node e1 = (arg$596.size() > 0 ? arg$596
04950: .getGeneric(0) : null);
04951: final Node e2 = (arg$596.size() > 1 ? arg$596
04952: .getGeneric(1) : null);
04953:
04954: matching_nodes.add(arg$596);
04955: if ((null != arg$596 && processScopeNodes
04956: .contains(arg$596.getName()))) {
04957: processScope(arg$596, getScope);
04958: }
04959: checkEnterScope(arg$596);
04960:
04961: final Object retValue$600 = Analyzer
04962: .cast(new Let<CTypes.type>() {
04963: {
04964: analyze_expression.apply(e1);
04965: }
04966:
04967: public CTypes.type apply() {
04968: return Analyzer
04969: .cast(analyze_expression
04970: .apply(e2));
04971: }
04972: }.apply());
04973:
04974: checkExitScope(arg$596);
04975: matching_nodes
04976: .remove(matching_nodes.size() - 1);
04977: return Analyzer.cast(retValue$600);
04978: }
04979: if (CSupport.match$601(arg$596)) {
04980: final Node n1 = (arg$596.size() > 0 ? arg$596
04981: .getGeneric(0) : null);
04982: final String op = (arg$596.size() > 1 ? arg$596
04983: .getString(1) : null);
04984: final Node n2 = (arg$596.size() > 2 ? arg$596
04985: .getGeneric(2) : null);
04986:
04987: matching_nodes.add(arg$596);
04988: if ((null != arg$596 && processScopeNodes
04989: .contains(arg$596.getName()))) {
04990: processScope(arg$596, getScope);
04991: }
04992: checkEnterScope(arg$596);
04993:
04994: final Object retValue$608 = Analyzer
04995: .cast(new Let<CTypes.type>() {
04996: final CTypes.type t1;
04997: final CTypes.type t2;
04998:
04999: {
05000: t1 = Analyzer
05001: .cast(analyze_expression
05002: .apply(n1));
05003: t2 = Analyzer
05004: .cast(analyze_expression
05005: .apply(n2));
05006: ensure_modifiable_lvalue
05007: .apply(t1);
05008: new Match<CTypes.type>() {
05009: public CTypes.type apply() {
05010: final String arg$604 = Analyzer
05011: .cast(op);
05012:
05013: if ((null == arg$604)) {
05014: return null;
05015: }
05016: if ((null != "=" && "="
05017: .equals(arg$604))) {
05018: return Analyzer
05019: .cast(processAssignment
05020: .apply(
05021: Boolean.FALSE,
05022: t1,
05023: op,
05024: t2));
05025: }
05026: if (true) {
05027: return Analyzer
05028: .cast(null);
05029: }
05030: return null;
05031: }
05032: }.apply();
05033: }
05034:
05035: public CTypes.type apply() {
05036: return Analyzer.cast(t1);
05037: }
05038: }.apply());
05039:
05040: checkExitScope(arg$596);
05041: matching_nodes
05042: .remove(matching_nodes.size() - 1);
05043: return Analyzer.cast(retValue$608);
05044: }
05045: if (CSupport.match$609(arg$596)) {
05046: final Node n1 = (arg$596.size() > 0 ? arg$596
05047: .getGeneric(0) : null);
05048: final Node n2 = (arg$596.size() > 1 ? arg$596
05049: .getGeneric(1) : null);
05050: final Node n3 = (arg$596.size() > 2 ? arg$596
05051: .getGeneric(2) : null);
05052:
05053: matching_nodes.add(arg$596);
05054: if ((null != arg$596 && processScopeNodes
05055: .contains(arg$596.getName()))) {
05056: processScope(arg$596, getScope);
05057: }
05058: checkEnterScope(arg$596);
05059:
05060: final Object retValue$612 = Analyzer
05061: .cast(new Let<CTypes.type>() {
05062: final CTypes.type t1;
05063: final CTypes.type t3;
05064:
05065: {
05066: t1 = Analyzer
05067: .cast(analyze_expression
05068: .apply(n1));
05069: t3 = Analyzer
05070: .cast(analyze_expression
05071: .apply(n3));
05072: ensure_scalar
05073: .apply(pointerize
05074: .apply(t1),
05075: "conditional expression");
05076: analyze_expression.apply(n2);
05077: }
05078:
05079: public CTypes.type apply() {
05080: return Analyzer
05081: .cast(null == Primitives.isBottom
05082: .apply(n2) ? null
05083: : Primitives.isBottom
05084: .apply(n2) ? t1
05085: : t3);
05086: }
05087: }.apply());
05088:
05089: checkExitScope(arg$596);
05090: matching_nodes
05091: .remove(matching_nodes.size() - 1);
05092: return Analyzer.cast(retValue$612);
05093: }
05094: if (CSupport.match$613(arg$596)) {
05095: final Node left = (arg$596.size() > 0 ? arg$596
05096: .getGeneric(0) : null);
05097: final Node right = (arg$596.size() > 1 ? arg$596
05098: .getGeneric(1)
05099: : null);
05100:
05101: matching_nodes.add(arg$596);
05102: if ((null != arg$596 && processScopeNodes
05103: .contains(arg$596.getName()))) {
05104: processScope(arg$596, getScope);
05105: }
05106: checkEnterScope(arg$596);
05107:
05108: final Object retValue$616 = Analyzer
05109: .cast(new Let<CTypes.type>() {
05110: {
05111: ensure_scalar
05112: .apply(
05113: pointerize
05114: .apply(analyze_expression
05115: .apply(left)),
05116: "logical expression 1");
05117: ensure_scalar
05118: .apply(
05119: pointerize
05120: .apply(analyze_expression
05121: .apply(right)),
05122: "logical expression 2");
05123: }
05124:
05125: public CTypes.type apply() {
05126: return Analyzer
05127: .cast(new CTypes.type(
05128: new CTypes.IntT(),
05129: null, null,
05130: null, null,
05131: null, null,
05132: null, null,
05133: null, null));
05134: }
05135: }.apply());
05136:
05137: checkExitScope(arg$596);
05138: matching_nodes
05139: .remove(matching_nodes.size() - 1);
05140: return Analyzer.cast(retValue$616);
05141: }
05142: if (CSupport.match$617(arg$596)) {
05143: final Node left = (arg$596.size() > 0 ? arg$596
05144: .getGeneric(0) : null);
05145: final Node right = (arg$596.size() > 1 ? arg$596
05146: .getGeneric(1)
05147: : null);
05148:
05149: matching_nodes.add(arg$596);
05150: if ((null != arg$596 && processScopeNodes
05151: .contains(arg$596.getName()))) {
05152: processScope(arg$596, getScope);
05153: }
05154: checkEnterScope(arg$596);
05155:
05156: final Object retValue$620 = Analyzer
05157: .cast(new Let<CTypes.type>() {
05158: {
05159: ensure_scalar
05160: .apply(
05161: pointerize
05162: .apply(analyze_expression
05163: .apply(left)),
05164: "logical expression 3");
05165: ensure_scalar
05166: .apply(
05167: pointerize
05168: .apply(analyze_expression
05169: .apply(right)),
05170: "logical expression 4");
05171: }
05172:
05173: public CTypes.type apply() {
05174: return Analyzer
05175: .cast(new CTypes.type(
05176: new CTypes.IntT(),
05177: null, null,
05178: null, null,
05179: null, null,
05180: null, null,
05181: null, null));
05182: }
05183: }.apply());
05184:
05185: checkExitScope(arg$596);
05186: matching_nodes
05187: .remove(matching_nodes.size() - 1);
05188: return Analyzer.cast(retValue$620);
05189: }
05190: if (CSupport.match$621(arg$596)) {
05191: final Node e = (arg$596.size() > 0 ? arg$596
05192: .getGeneric(0) : null);
05193:
05194: matching_nodes.add(arg$596);
05195: if ((null != arg$596 && processScopeNodes
05196: .contains(arg$596.getName()))) {
05197: processScope(arg$596, getScope);
05198: }
05199: checkEnterScope(arg$596);
05200:
05201: final Object retValue$624 = Analyzer
05202: .cast(new Let<CTypes.type>() {
05203: {
05204: ensure_scalar
05205: .apply(
05206: pointerize
05207: .apply(analyze_expression
05208: .apply(e)),
05209: "logical expression 5 ");
05210: }
05211:
05212: public CTypes.type apply() {
05213: return Analyzer
05214: .cast(new CTypes.type(
05215: new CTypes.IntT(),
05216: null, null,
05217: null, null,
05218: null, null,
05219: null, null,
05220: null, null));
05221: }
05222: }.apply());
05223:
05224: checkExitScope(arg$596);
05225: matching_nodes
05226: .remove(matching_nodes.size() - 1);
05227: return Analyzer.cast(retValue$624);
05228: }
05229: if (CSupport.match$625(arg$596)) {
05230: final Node l = (arg$596.size() > 0 ? arg$596
05231: .getGeneric(0) : null);
05232: final Node r = (arg$596.size() > 1 ? arg$596
05233: .getGeneric(1) : null);
05234:
05235: matching_nodes.add(arg$596);
05236: if ((null != arg$596 && processScopeNodes
05237: .contains(arg$596.getName()))) {
05238: processScope(arg$596, getScope);
05239: }
05240: checkEnterScope(arg$596);
05241:
05242: final Object retValue$628 = Analyzer
05243: .cast(new Let<CTypes.type>() {
05244: final CTypes.type t1;
05245: final CTypes.type t2;
05246:
05247: {
05248: t1 = Analyzer
05249: .cast(ensure_integer
05250: .apply(
05251: analyze_expression
05252: .apply(l),
05253: "bitwise expression"));
05254: t2 = Analyzer
05255: .cast(ensure_integer
05256: .apply(
05257: analyze_expression
05258: .apply(r),
05259: "bitwise expression"));
05260: }
05261:
05262: public CTypes.type apply() {
05263: return Analyzer
05264: .cast(new CTypes.type(
05265: null == t1 ? null
05266: : t1.type,
05267: null == t1 ? null
05268: : t1.qualifiers,
05269: null == t1 ? null
05270: : t1.storage,
05271: null == t1 ? null
05272: : t1.fSpec,
05273: new CTypes.IValue(
05274: Primitives.orBits
05275: .apply(
05276: get_int
05277: .apply(t1),
05278: get_int
05279: .apply(t2))),
05280: null == t1 ? null
05281: : t1.implicit,
05282: null == t1 ? null
05283: : t1.initialised,
05284: null == t1 ? null
05285: : t1.position,
05286: null == t1 ? null
05287: : t1.old_style,
05288: null == t1 ? null
05289: : t1.var_args,
05290: null == t1 ? null
05291: : t1.in_top));
05292: }
05293: }.apply());
05294:
05295: checkExitScope(arg$596);
05296: matching_nodes
05297: .remove(matching_nodes.size() - 1);
05298: return Analyzer.cast(retValue$628);
05299: }
05300: if (CSupport.match$629(arg$596)) {
05301: final Node l = (arg$596.size() > 0 ? arg$596
05302: .getGeneric(0) : null);
05303: final Node r = (arg$596.size() > 1 ? arg$596
05304: .getGeneric(1) : null);
05305:
05306: matching_nodes.add(arg$596);
05307: if ((null != arg$596 && processScopeNodes
05308: .contains(arg$596.getName()))) {
05309: processScope(arg$596, getScope);
05310: }
05311: checkEnterScope(arg$596);
05312:
05313: final Object retValue$632 = Analyzer
05314: .cast(new Let<CTypes.type>() {
05315: final CTypes.type t1;
05316: final CTypes.type t2;
05317:
05318: {
05319: t1 = Analyzer
05320: .cast(ensure_integer
05321: .apply(
05322: analyze_expression
05323: .apply(l),
05324: "bitwise expression"));
05325: t2 = Analyzer
05326: .cast(ensure_integer
05327: .apply(
05328: analyze_expression
05329: .apply(r),
05330: "bitwise expression"));
05331: }
05332:
05333: public CTypes.type apply() {
05334: return Analyzer
05335: .cast(new CTypes.type(
05336: null == t1 ? null
05337: : t1.type,
05338: null == t1 ? null
05339: : t1.qualifiers,
05340: null == t1 ? null
05341: : t1.storage,
05342: null == t1 ? null
05343: : t1.fSpec,
05344: new CTypes.IValue(
05345: Primitives.andBits
05346: .apply(
05347: get_int
05348: .apply(t1),
05349: get_int
05350: .apply(t2))),
05351: null == t1 ? null
05352: : t1.implicit,
05353: null == t1 ? null
05354: : t1.initialised,
05355: null == t1 ? null
05356: : t1.position,
05357: null == t1 ? null
05358: : t1.old_style,
05359: null == t1 ? null
05360: : t1.var_args,
05361: null == t1 ? null
05362: : t1.in_top));
05363: }
05364: }.apply());
05365:
05366: checkExitScope(arg$596);
05367: matching_nodes
05368: .remove(matching_nodes.size() - 1);
05369: return Analyzer.cast(retValue$632);
05370: }
05371: if (CSupport.match$633(arg$596)) {
05372: final Node l = (arg$596.size() > 0 ? arg$596
05373: .getGeneric(0) : null);
05374: final Node r = (arg$596.size() > 1 ? arg$596
05375: .getGeneric(1) : null);
05376:
05377: matching_nodes.add(arg$596);
05378: if ((null != arg$596 && processScopeNodes
05379: .contains(arg$596.getName()))) {
05380: processScope(arg$596, getScope);
05381: }
05382: checkEnterScope(arg$596);
05383:
05384: final Object retValue$636 = Analyzer
05385: .cast(new Let<CTypes.type>() {
05386: final CTypes.type t1;
05387: final CTypes.type t2;
05388:
05389: {
05390: t1 = Analyzer
05391: .cast(ensure_integer
05392: .apply(
05393: analyze_expression
05394: .apply(l),
05395: "bitwise expression"));
05396: t2 = Analyzer
05397: .cast(ensure_integer
05398: .apply(
05399: analyze_expression
05400: .apply(r),
05401: "bitwise expression"));
05402: }
05403:
05404: public CTypes.type apply() {
05405: return Analyzer
05406: .cast(new CTypes.type(
05407: null == t1 ? null
05408: : t1.type,
05409: null == t1 ? null
05410: : t1.qualifiers,
05411: null == t1 ? null
05412: : t1.storage,
05413: null == t1 ? null
05414: : t1.fSpec,
05415: new CTypes.IValue(
05416: Primitives.xorBits
05417: .apply(
05418: get_int
05419: .apply(t1),
05420: get_int
05421: .apply(t2))),
05422: null == t1 ? null
05423: : t1.implicit,
05424: null == t1 ? null
05425: : t1.initialised,
05426: null == t1 ? null
05427: : t1.position,
05428: null == t1 ? null
05429: : t1.old_style,
05430: null == t1 ? null
05431: : t1.var_args,
05432: null == t1 ? null
05433: : t1.in_top));
05434: }
05435: }.apply());
05436:
05437: checkExitScope(arg$596);
05438: matching_nodes
05439: .remove(matching_nodes.size() - 1);
05440: return Analyzer.cast(retValue$636);
05441: }
05442: if (CSupport.match$637(arg$596)) {
05443: final Node e = (arg$596.size() > 0 ? arg$596
05444: .getGeneric(0) : null);
05445:
05446: matching_nodes.add(arg$596);
05447: if ((null != arg$596 && processScopeNodes
05448: .contains(arg$596.getName()))) {
05449: processScope(arg$596, getScope);
05450: }
05451: checkEnterScope(arg$596);
05452:
05453: final Object retValue$640 = Analyzer
05454: .cast(new Let<CTypes.type>() {
05455: final CTypes.type t;
05456:
05457: {
05458: t = Analyzer
05459: .cast(ensure_integer
05460: .apply(
05461: analyze_expression
05462: .apply(e),
05463: "bitwise expression"));
05464: }
05465:
05466: public CTypes.type apply() {
05467: return Analyzer
05468: .cast(new CTypes.type(
05469: null == t ? null
05470: : t.type,
05471: null == t ? null
05472: : t.qualifiers,
05473: null == t ? null
05474: : t.storage,
05475: null == t ? null
05476: : t.fSpec,
05477: new CTypes.IValue(
05478: Primitives.negateBits
05479: .apply(get_int
05480: .apply(t))),
05481: null == t ? null
05482: : t.implicit,
05483: null == t ? null
05484: : t.initialised,
05485: null == t ? null
05486: : t.position,
05487: null == t ? null
05488: : t.old_style,
05489: null == t ? null
05490: : t.var_args,
05491: null == t ? null
05492: : t.in_top));
05493: }
05494: }.apply());
05495:
05496: checkExitScope(arg$596);
05497: matching_nodes
05498: .remove(matching_nodes.size() - 1);
05499: return Analyzer.cast(retValue$640);
05500: }
05501: if (CSupport.match$641(arg$596)) {
05502: final Node n1 = (arg$596.size() > 0 ? arg$596
05503: .getGeneric(0) : null);
05504: final String op = (arg$596.size() > 1 ? arg$596
05505: .getString(1) : null);
05506: final Node n2 = (arg$596.size() > 2 ? arg$596
05507: .getGeneric(2) : null);
05508:
05509: matching_nodes.add(arg$596);
05510: if ((null != arg$596 && processScopeNodes
05511: .contains(arg$596.getName()))) {
05512: processScope(arg$596, getScope);
05513: }
05514: checkEnterScope(arg$596);
05515:
05516: final Object retValue$644 = Analyzer
05517: .cast(new Let<CTypes.type>() {
05518: final CTypes.type t1;
05519: final CTypes.type t2;
05520:
05521: {
05522: t1 = Analyzer
05523: .cast(pointerize
05524: .apply(analyze_expression
05525: .apply(n1)));
05526: t2 = Analyzer
05527: .cast(pointerize
05528: .apply(analyze_expression
05529: .apply(n2)));
05530: }
05531:
05532: public CTypes.type apply() {
05533: return Analyzer
05534: .cast(null == Primitives.or
05535: .apply(
05536: Primitives.isBottom
05537: .apply(t1),
05538: Primitives.isBottom
05539: .apply(t2)) ? null
05540: : Primitives.or
05541: .apply(
05542: Primitives.isBottom
05543: .apply(t1),
05544: Primitives.isBottom
05545: .apply(t2)) ? null
05546: : null == Primitives.and
05547: .apply(
05548: is_arithmetic
05549: .apply(t1),
05550: is_arithmetic
05551: .apply(t2)) ? null
05552: : Primitives.and
05553: .apply(
05554: is_arithmetic
05555: .apply(t1),
05556: is_arithmetic
05557: .apply(t2)) ? new CTypes.type(
05558: new CTypes.IntT(),
05559: null,
05560: null,
05561: null,
05562: null,
05563: null,
05564: null,
05565: null,
05566: null,
05567: null,
05568: null)
05569: : null == Primitives.and
05570: .apply(
05571: is_pointer
05572: .apply(t1),
05573: is_pointer
05574: .apply(t2)) ? null
05575: : Primitives.and
05576: .apply(
05577: is_pointer
05578: .apply(t1),
05579: is_pointer
05580: .apply(t2)) ? new Let<CTypes.type>() {
05581: final CTypes.type b1;
05582: final CTypes.type b2;
05583:
05584: {
05585: b1 = Analyzer
05586: .cast(get_base
05587: .apply(t1));
05588: b2 = Analyzer
05589: .cast(get_base
05590: .apply(t2));
05591: }
05592:
05593: public CTypes.type apply() {
05594: return Analyzer
05595: .cast(null == Primitives.or
05596: .apply(
05597: Primitives.or
05598: .apply(
05599: Primitives.or
05600: .apply(
05601: type_match
05602: .apply(
05603: t1,
05604: t2),
05605: is_void
05606: .apply(b1)),
05607: is_void
05608: .apply(b2)),
05609: Primitives.and
05610: .apply(
05611: is_arithmetic
05612: .apply(b1),
05613: is_arithmetic
05614: .apply(b2))) ? null
05615: : Primitives.or
05616: .apply(
05617: Primitives.or
05618: .apply(
05619: Primitives.or
05620: .apply(
05621: type_match
05622: .apply(
05623: t1,
05624: t2),
05625: is_void
05626: .apply(b1)),
05627: is_void
05628: .apply(b2)),
05629: Primitives.and
05630: .apply(
05631: is_arithmetic
05632: .apply(b1),
05633: is_arithmetic
05634: .apply(b2))) ? new CTypes.type(
05635: new CTypes.IntT(),
05636: null,
05637: null,
05638: null,
05639: null,
05640: null,
05641: null,
05642: null,
05643: null,
05644: null,
05645: null)
05646: : error(
05647: "comparison of distinct pointer types lacks a cast",
05648: null));
05649: }
05650: }
05651: .apply()
05652: : null == Primitives.and
05653: .apply(
05654: Primitives.and
05655: .apply(
05656: is_pointer
05657: .apply(t1),
05658: is_integer
05659: .apply(t2)),
05660: zero
05661: .apply(t2)) ? null
05662: : Primitives.and
05663: .apply(
05664: Primitives.and
05665: .apply(
05666: is_pointer
05667: .apply(t1),
05668: is_integer
05669: .apply(t2)),
05670: zero
05671: .apply(t2)) ? new CTypes.type(
05672: new CTypes.IntT(),
05673: null,
05674: null,
05675: null,
05676: null,
05677: null,
05678: null,
05679: null,
05680: null,
05681: null,
05682: null)
05683: : error(
05684: Primitives.concat
05685: .apply(
05686: "invalid operands to binary ",
05687: op),
05688: null));
05689: }
05690: }.apply());
05691:
05692: checkExitScope(arg$596);
05693: matching_nodes
05694: .remove(matching_nodes.size() - 1);
05695: return Analyzer.cast(retValue$644);
05696: }
05697: if (CSupport.match$645(arg$596)) {
05698: final Node n1 = (arg$596.size() > 0 ? arg$596
05699: .getGeneric(0) : null);
05700: final Node n2 = (arg$596.size() > 2 ? arg$596
05701: .getGeneric(2) : null);
05702:
05703: matching_nodes.add(arg$596);
05704: if ((null != arg$596 && processScopeNodes
05705: .contains(arg$596.getName()))) {
05706: processScope(arg$596, getScope);
05707: }
05708: checkEnterScope(arg$596);
05709:
05710: final Object retValue$648 = Analyzer
05711: .cast(new Let<CTypes.type>() {
05712: final CTypes.type t1;
05713: final CTypes.type t2;
05714:
05715: {
05716: t1 = Analyzer
05717: .cast(analyze_expression
05718: .apply(n1));
05719: t2 = Analyzer
05720: .cast(analyze_expression
05721: .apply(n2));
05722: }
05723:
05724: public CTypes.type apply() {
05725: return Analyzer
05726: .cast(null == Primitives.and
05727: .apply(
05728: Primitives.or
05729: .apply(
05730: is_float
05731: .apply(t1),
05732: is_integer
05733: .apply(t1)),
05734: Primitives.or
05735: .apply(
05736: is_float
05737: .apply(t2),
05738: is_integer
05739: .apply(t2))) ? null
05740: : Primitives.and
05741: .apply(
05742: Primitives.or
05743: .apply(
05744: is_float
05745: .apply(t1),
05746: is_integer
05747: .apply(t1)),
05748: Primitives.or
05749: .apply(
05750: is_float
05751: .apply(t2),
05752: is_integer
05753: .apply(t2))) ? new CTypes.type(
05754: new CTypes.IntT(),
05755: null,
05756: null,
05757: null,
05758: null,
05759: null,
05760: null,
05761: null,
05762: null,
05763: null,
05764: null)
05765: : null == Primitives.and
05766: .apply(
05767: is_pointer
05768: .apply(t1),
05769: is_pointer
05770: .apply(t2))
05771: || !Primitives.and
05772: .apply(
05773: is_pointer
05774: .apply(t1),
05775: is_pointer
05776: .apply(t2)) ? null
05777: : null == type_match
05778: .apply(
05779: t1,
05780: t2) ? null
05781: : type_match
05782: .apply(
05783: t1,
05784: t2) ? new CTypes.type(
05785: new CTypes.IntT(),
05786: null,
05787: null,
05788: null,
05789: null,
05790: null,
05791: null,
05792: null,
05793: null,
05794: null,
05795: null)
05796: : error(
05797: "comparison of distinct pointer types lacks a cast",
05798: null));
05799: }
05800: }.apply());
05801:
05802: checkExitScope(arg$596);
05803: matching_nodes
05804: .remove(matching_nodes.size() - 1);
05805: return Analyzer.cast(retValue$648);
05806: }
05807: if (CSupport.match$649(arg$596)) {
05808: final Node n1 = (arg$596.size() > 0 ? arg$596
05809: .getGeneric(0) : null);
05810: final Node n2 = (arg$596.size() > 2 ? arg$596
05811: .getGeneric(2) : null);
05812:
05813: matching_nodes.add(arg$596);
05814: if ((null != arg$596 && processScopeNodes
05815: .contains(arg$596.getName()))) {
05816: processScope(arg$596, getScope);
05817: }
05818: checkEnterScope(arg$596);
05819:
05820: final Object retValue$652 = Analyzer
05821: .cast(new Let<CTypes.type>() {
05822: final CTypes.type t1;
05823: final CTypes.type t2;
05824: final BigInteger val;
05825: final Pair<CTypes.qualifier> quals;
05826: final CTypes.type res;
05827:
05828: {
05829: t1 = Analyzer
05830: .cast(ensure_integer
05831: .apply(
05832: analyze_expression
05833: .apply(n1),
05834: "shift expression"));
05835: t2 = Analyzer
05836: .cast(ensure_integer
05837: .apply(
05838: analyze_expression
05839: .apply(n2),
05840: "shift expression"));
05841: val = Analyzer.cast(get_int
05842: .apply(t2));
05843: quals = Analyzer
05844: .cast(null == Primitives.and
05845: .apply(
05846: is_const
05847: .apply(t1),
05848: is_const
05849: .apply(t2)) ? null
05850: : Primitives.and
05851: .apply(
05852: is_const
05853: .apply(t1),
05854: is_const
05855: .apply(t2)) ? new Pair<CTypes.qualifier>(
05856: new CTypes.ConstQ())
05857: : Pair
05858: .<CTypes.qualifier> empty());
05859: res = Analyzer.cast(promote
05860: .apply(t1));
05861: Analyzer
05862: .discard(null == Primitives.and
05863: .apply(
05864: Primitives.isNotBottom
05865: .apply(val),
05866: Primitives.greaterInt
05867: .apply(
05868: BigInteger
05869: .valueOf(0),
05870: val))
05871: || !Primitives.and
05872: .apply(
05873: Primitives.isNotBottom
05874: .apply(val),
05875: Primitives.greaterInt
05876: .apply(
05877: BigInteger
05878: .valueOf(0),
05879: val)) ? null
05880: : warning(
05881: "left shift count is negative",
05882: null));
05883: Analyzer
05884: .discard(null == Primitives.and
05885: .apply(
05886: Primitives.isNotBottom
05887: .apply(val),
05888: Primitives.lessEqualInt
05889: .apply(
05890: Primitives.multiplyInt
05891: .apply(
05892: sizeof
05893: .apply(res),
05894: BigInteger
05895: .valueOf(8)),
05896: val))
05897: || !Primitives.and
05898: .apply(
05899: Primitives.isNotBottom
05900: .apply(val),
05901: Primitives.lessEqualInt
05902: .apply(
05903: Primitives.multiplyInt
05904: .apply(
05905: sizeof
05906: .apply(res),
05907: BigInteger
05908: .valueOf(8)),
05909: val)) ? null
05910: : warning(
05911: "left shift count >= width of type",
05912: null));
05913: }
05914:
05915: public CTypes.type apply() {
05916: return Analyzer
05917: .cast(new CTypes.type(
05918: null == res ? null
05919: : res.type,
05920: quals,
05921: null == res ? null
05922: : res.storage,
05923: null == res ? null
05924: : res.fSpec,
05925: new CTypes.IValue(
05926: Primitives.shiftLeft
05927: .apply(
05928: get_int
05929: .apply(t1),
05930: get_int
05931: .apply(t2))),
05932: null == res ? null
05933: : res.implicit,
05934: null == res ? null
05935: : res.initialised,
05936: null == res ? null
05937: : res.position,
05938: null == res ? null
05939: : res.old_style,
05940: null == res ? null
05941: : res.var_args,
05942: null == res ? null
05943: : res.in_top));
05944: }
05945: }.apply());
05946:
05947: checkExitScope(arg$596);
05948: matching_nodes
05949: .remove(matching_nodes.size() - 1);
05950: return Analyzer.cast(retValue$652);
05951: }
05952: if (CSupport.match$653(arg$596)) {
05953: final Node n1 = (arg$596.size() > 0 ? arg$596
05954: .getGeneric(0) : null);
05955: final Node n2 = (arg$596.size() > 2 ? arg$596
05956: .getGeneric(2) : null);
05957:
05958: matching_nodes.add(arg$596);
05959: if ((null != arg$596 && processScopeNodes
05960: .contains(arg$596.getName()))) {
05961: processScope(arg$596, getScope);
05962: }
05963: checkEnterScope(arg$596);
05964:
05965: final Object retValue$656 = Analyzer
05966: .cast(new Let<CTypes.type>() {
05967: final CTypes.type t1;
05968: final CTypes.type t2;
05969: final BigInteger val;
05970: final Pair<CTypes.qualifier> quals;
05971: final CTypes.type res;
05972:
05973: {
05974: t1 = Analyzer
05975: .cast(ensure_integer
05976: .apply(
05977: analyze_expression
05978: .apply(n1),
05979: "shift expression"));
05980: t2 = Analyzer
05981: .cast(ensure_integer
05982: .apply(
05983: analyze_expression
05984: .apply(n2),
05985: "shift expression"));
05986: val = Analyzer.cast(get_int
05987: .apply(t2));
05988: quals = Analyzer
05989: .cast(null == Primitives.and
05990: .apply(
05991: is_const
05992: .apply(t1),
05993: is_const
05994: .apply(t2)) ? null
05995: : Primitives.and
05996: .apply(
05997: is_const
05998: .apply(t1),
05999: is_const
06000: .apply(t2)) ? new Pair<CTypes.qualifier>(
06001: new CTypes.ConstQ())
06002: : Pair
06003: .<CTypes.qualifier> empty());
06004: res = Analyzer.cast(promote
06005: .apply(t1));
06006: Analyzer
06007: .discard(null == Primitives.and
06008: .apply(
06009: Primitives.isNotBottom
06010: .apply(val),
06011: Primitives.greaterInt
06012: .apply(
06013: BigInteger
06014: .valueOf(0),
06015: val))
06016: || !Primitives.and
06017: .apply(
06018: Primitives.isNotBottom
06019: .apply(val),
06020: Primitives.greaterInt
06021: .apply(
06022: BigInteger
06023: .valueOf(0),
06024: val)) ? null
06025: : warning(
06026: "right shift count is negative",
06027: null));
06028: Analyzer
06029: .discard(null == Primitives.and
06030: .apply(
06031: Primitives.isNotBottom
06032: .apply(val),
06033: Primitives.lessEqualInt
06034: .apply(
06035: Primitives.multiplyInt
06036: .apply(
06037: sizeof
06038: .apply(res),
06039: BigInteger
06040: .valueOf(8)),
06041: val))
06042: || !Primitives.and
06043: .apply(
06044: Primitives.isNotBottom
06045: .apply(val),
06046: Primitives.lessEqualInt
06047: .apply(
06048: Primitives.multiplyInt
06049: .apply(
06050: sizeof
06051: .apply(res),
06052: BigInteger
06053: .valueOf(8)),
06054: val)) ? null
06055: : warning(
06056: "right shift count >= width of type",
06057: null));
06058: }
06059:
06060: public CTypes.type apply() {
06061: return Analyzer
06062: .cast(new CTypes.type(
06063: null == res ? null
06064: : res.type,
06065: quals,
06066: null == res ? null
06067: : res.storage,
06068: null == res ? null
06069: : res.fSpec,
06070: new CTypes.IValue(
06071: Primitives.shiftRight
06072: .apply(
06073: get_int
06074: .apply(t1),
06075: get_int
06076: .apply(t2))),
06077: null == res ? null
06078: : res.implicit,
06079: null == res ? null
06080: : res.initialised,
06081: null == res ? null
06082: : res.position,
06083: null == res ? null
06084: : res.old_style,
06085: null == res ? null
06086: : res.var_args,
06087: null == res ? null
06088: : res.in_top));
06089: }
06090: }.apply());
06091:
06092: checkExitScope(arg$596);
06093: matching_nodes
06094: .remove(matching_nodes.size() - 1);
06095: return Analyzer.cast(retValue$656);
06096: }
06097: if (CSupport.match$657(arg$596)) {
06098: final Node n1 = (arg$596.size() > 0 ? arg$596
06099: .getGeneric(0) : null);
06100: final String op = (arg$596.size() > 1 ? arg$596
06101: .getString(1) : null);
06102: final Node n2 = (arg$596.size() > 2 ? arg$596
06103: .getGeneric(2) : null);
06104:
06105: matching_nodes.add(arg$596);
06106: if ((null != arg$596 && processScopeNodes
06107: .contains(arg$596.getName()))) {
06108: processScope(arg$596, getScope);
06109: }
06110: checkEnterScope(arg$596);
06111:
06112: final Object retValue$664 = Analyzer
06113: .cast(new Let<CTypes.type>() {
06114: final CTypes.type t1;
06115: final CTypes.type t2;
06116:
06117: {
06118: t1 = Analyzer
06119: .cast(analyze_expression
06120: .apply(n1));
06121: t2 = Analyzer
06122: .cast(analyze_expression
06123: .apply(n2));
06124: }
06125:
06126: public CTypes.type apply() {
06127: return Analyzer
06128: .cast(null == Primitives.or
06129: .apply(
06130: Primitives.isBottom
06131: .apply(t1),
06132: Primitives.isBottom
06133: .apply(t2)) ? null
06134: : Primitives.or
06135: .apply(
06136: Primitives.isBottom
06137: .apply(t1),
06138: Primitives.isBottom
06139: .apply(t2)) ? null
06140: : null == Primitives.and
06141: .apply(
06142: is_arithmetic
06143: .apply(t1),
06144: is_arithmetic
06145: .apply(t2)) ? null
06146: : Primitives.and
06147: .apply(
06148: is_arithmetic
06149: .apply(t1),
06150: is_arithmetic
06151: .apply(t2)) ? new Let<CTypes.type>() {
06152: final CTypes.valueType val;
06153: final Pair<CTypes.qualifier> quals;
06154: final CTypes.type res;
06155:
06156: {
06157: val = Analyzer
06158: .cast(null == is_integer
06159: .apply(t1) ? null
06160: : is_integer
06161: .apply(t1) ? (null == Primitives.equal
06162: .apply(
06163: "+",
06164: op) ? null
06165: : Primitives.equal
06166: .apply(
06167: "+",
06168: op) ? new CTypes.IValue(
06169: Primitives.addInt
06170: .apply(
06171: get_int
06172: .apply(t1),
06173: get_int
06174: .apply(t2)))
06175: : new CTypes.IValue(
06176: Primitives.subtractInt
06177: .apply(
06178: get_int
06179: .apply(t1),
06180: get_int
06181: .apply(t2))))
06182: : null == Primitives.equal
06183: .apply(
06184: "+",
06185: op) ? null
06186: : Primitives.equal
06187: .apply(
06188: "+",
06189: op) ? new CTypes.FValue(
06190: Primitives.addFloat64
06191: .apply(
06192: get_float
06193: .apply(t1),
06194: get_float
06195: .apply(t2)))
06196: : new CTypes.FValue(
06197: Primitives.subtractFloat64
06198: .apply(
06199: get_float
06200: .apply(t1),
06201: get_float
06202: .apply(t2))));
06203: quals = Analyzer
06204: .cast(null == Primitives.and
06205: .apply(
06206: is_const
06207: .apply(t1),
06208: is_const
06209: .apply(t2)) ? null
06210: : Primitives.and
06211: .apply(
06212: is_const
06213: .apply(t1),
06214: is_const
06215: .apply(t2)) ? new Pair<CTypes.qualifier>(
06216: new CTypes.ConstQ())
06217: : Pair
06218: .<CTypes.qualifier> empty());
06219: res = Analyzer
06220: .cast(arith_convert
06221: .apply(
06222: t1,
06223: t1));
06224: }
06225:
06226: public CTypes.type apply() {
06227: return Analyzer
06228: .cast(new CTypes.type(
06229: null == res ? null
06230: : res.type,
06231: quals,
06232: null == res ? null
06233: : res.storage,
06234: null == res ? null
06235: : res.fSpec,
06236: val,
06237: null == res ? null
06238: : res.implicit,
06239: null == res ? null
06240: : res.initialised,
06241: null == res ? null
06242: : res.position,
06243: null == res ? null
06244: : res.old_style,
06245: null == res ? null
06246: : res.var_args,
06247: null == res ? null
06248: : res.in_top));
06249: }
06250: }
06251: .apply()
06252: : null == Primitives.and
06253: .apply(
06254: Primitives.and
06255: .apply(
06256: Primitives.or
06257: .apply(
06258: is_pointer
06259: .apply(t1),
06260: is_array
06261: .apply(t1)),
06262: Primitives.not
06263: .apply(is_void
06264: .apply(get_base
06265: .apply(t1)))),
06266: is_incomplete
06267: .apply(get_base
06268: .apply(t1))) ? null
06269: : Primitives.and
06270: .apply(
06271: Primitives.and
06272: .apply(
06273: Primitives.or
06274: .apply(
06275: is_pointer
06276: .apply(t1),
06277: is_array
06278: .apply(t1)),
06279: Primitives.not
06280: .apply(is_void
06281: .apply(get_base
06282: .apply(t1)))),
06283: is_incomplete
06284: .apply(get_base
06285: .apply(t1))) ? error(
06286: "arithmetic on pointer to an incomplete type",
06287: null)
06288: : null == Primitives.and
06289: .apply(
06290: Primitives.and
06291: .apply(
06292: Primitives.or
06293: .apply(
06294: is_pointer
06295: .apply(t2),
06296: is_array
06297: .apply(t2)),
06298: Primitives.not
06299: .apply(is_void
06300: .apply(get_base
06301: .apply(t2)))),
06302: is_incomplete
06303: .apply(get_base
06304: .apply(t2))) ? null
06305: : Primitives.and
06306: .apply(
06307: Primitives.and
06308: .apply(
06309: Primitives.or
06310: .apply(
06311: is_pointer
06312: .apply(t2),
06313: is_array
06314: .apply(t2)),
06315: Primitives.not
06316: .apply(is_void
06317: .apply(get_base
06318: .apply(t2)))),
06319: is_incomplete
06320: .apply(get_base
06321: .apply(t2))) ? error(
06322: "arithmetic on pointer to an incomplete type",
06323: null)
06324: : new Let<CTypes.type>() {
06325: final CTypes.type r1;
06326: final CTypes.type r2;
06327:
06328: {
06329: r1 = Analyzer
06330: .cast(pointerize
06331: .apply(t1));
06332: r2 = Analyzer
06333: .cast(pointerize
06334: .apply(t2));
06335: }
06336:
06337: public CTypes.type apply() {
06338: return Analyzer
06339: .cast(new Match<CTypes.type>() {
06340: public CTypes.type apply() {
06341: final String arg$660 = Analyzer
06342: .cast(op);
06343:
06344: if ((null == arg$660)) {
06345: return null;
06346: }
06347: if ((null != "+" && "+"
06348: .equals(arg$660))) {
06349: return Analyzer
06350: .cast(null == Primitives.and
06351: .apply(
06352: is_pointer
06353: .apply(r1),
06354: is_integer
06355: .apply(r2)) ? null
06356: : Primitives.and
06357: .apply(
06358: is_pointer
06359: .apply(r1),
06360: is_integer
06361: .apply(r2)) ? t1
06362: : null == Primitives.and
06363: .apply(
06364: is_integer
06365: .apply(r1),
06366: is_pointer
06367: .apply(r2)) ? null
06368: : Primitives.and
06369: .apply(
06370: is_integer
06371: .apply(r1),
06372: is_pointer
06373: .apply(r2)) ? t2
06374: : null == Primitives.and
06375: .apply(
06376: Primitives.and
06377: .apply(
06378: is_pointer
06379: .apply(r1),
06380: is_pointer
06381: .apply(r2)),
06382: pointer_equals
06383: .apply(
06384: t1,
06385: t2)) ? null
06386: : Primitives.and
06387: .apply(
06388: Primitives.and
06389: .apply(
06390: is_pointer
06391: .apply(r1),
06392: is_pointer
06393: .apply(r2)),
06394: pointer_equals
06395: .apply(
06396: t1,
06397: t2)) ? to_pointer
06398: .apply(t1)
06399: : null == Primitives.and
06400: .apply(
06401: Primitives.and
06402: .apply(
06403: is_array
06404: .apply(t1),
06405: is_arithmetic
06406: .apply(get_base
06407: .apply(t1))),
06408: is_arithmetic
06409: .apply(t2)) ? null
06410: : Primitives.and
06411: .apply(
06412: Primitives.and
06413: .apply(
06414: is_array
06415: .apply(t1),
06416: is_arithmetic
06417: .apply(get_base
06418: .apply(t1))),
06419: is_arithmetic
06420: .apply(t2)) ? t1
06421: : null == Primitives.and
06422: .apply(
06423: Primitives.and
06424: .apply(
06425: is_arithmetic
06426: .apply(t1),
06427: is_array
06428: .apply(t2)),
06429: is_arithmetic
06430: .apply(get_base
06431: .apply(t2))) ? null
06432: : Primitives.and
06433: .apply(
06434: Primitives.and
06435: .apply(
06436: is_arithmetic
06437: .apply(t1),
06438: is_array
06439: .apply(t2)),
06440: is_arithmetic
06441: .apply(get_base
06442: .apply(t2))) ? t2
06443: : error(
06444: Primitives.concat
06445: .apply(
06446: "invalid operand to 'binary ",
06447: op),
06448: null));
06449: }
06450: if (true) {
06451: return Analyzer
06452: .cast(null == Primitives.and
06453: .apply(
06454: Primitives.and
06455: .apply(
06456: is_pointer
06457: .apply(r1),
06458: is_pointer
06459: .apply(r2)),
06460: pointer_equals
06461: .apply(
06462: r1,
06463: r2)) ? null
06464: : Primitives.and
06465: .apply(
06466: Primitives.and
06467: .apply(
06468: is_pointer
06469: .apply(r1),
06470: is_pointer
06471: .apply(r2)),
06472: pointer_equals
06473: .apply(
06474: r1,
06475: r2)) ? new CTypes.type(
06476: new CTypes.IntT(),
06477: null,
06478: null,
06479: null,
06480: null,
06481: null,
06482: null,
06483: null,
06484: null,
06485: null,
06486: null)
06487: : null == Primitives.and
06488: .apply(
06489: is_pointer
06490: .apply(r1),
06491: is_integer
06492: .apply(r2)) ? null
06493: : Primitives.and
06494: .apply(
06495: is_pointer
06496: .apply(r1),
06497: is_integer
06498: .apply(r2)) ? t1
06499: : null == Primitives.and
06500: .apply(
06501: Primitives.and
06502: .apply(
06503: is_array
06504: .apply(t1),
06505: is_arithmetic
06506: .apply(get_base
06507: .apply(t1))),
06508: is_arithmetic
06509: .apply(t2)) ? null
06510: : Primitives.and
06511: .apply(
06512: Primitives.and
06513: .apply(
06514: is_array
06515: .apply(t1),
06516: is_arithmetic
06517: .apply(get_base
06518: .apply(t1))),
06519: is_arithmetic
06520: .apply(t2)) ? t1
06521: : error(
06522: Primitives.concat
06523: .apply(
06524: "invalid operand to 'binary ",
06525: op),
06526: null));
06527: }
06528: return null;
06529: }
06530: }
06531: .apply());
06532: }
06533: }
06534: .apply());
06535: }
06536: }.apply());
06537:
06538: checkExitScope(arg$596);
06539: matching_nodes
06540: .remove(matching_nodes.size() - 1);
06541: return Analyzer.cast(retValue$664);
06542: }
06543: if (CSupport.match$665(arg$596)) {
06544: final Node n1 = (arg$596.size() > 0 ? arg$596
06545: .getGeneric(0) : null);
06546: final String op = (arg$596.size() > 1 ? arg$596
06547: .getString(1) : null);
06548: final Node n2 = (arg$596.size() > 2 ? arg$596
06549: .getGeneric(2) : null);
06550:
06551: matching_nodes.add(arg$596);
06552: if ((null != arg$596 && processScopeNodes
06553: .contains(arg$596.getName()))) {
06554: processScope(arg$596, getScope);
06555: }
06556: checkEnterScope(arg$596);
06557:
06558: final Object retValue$717 = Analyzer
06559: .cast(new Let<CTypes.type>() {
06560: final CTypes.type t1;
06561: final CTypes.type t2;
06562: final CTypes.valueType val;
06563: final Pair<CTypes.qualifier> quals;
06564: final CTypes.type res;
06565:
06566: {
06567: t1 = Analyzer
06568: .cast(ensure_scalar
06569: .apply(
06570: analyze_expression
06571: .apply(n1),
06572: "multiplicative expression"));
06573: t2 = Analyzer
06574: .cast(ensure_scalar
06575: .apply(
06576: analyze_expression
06577: .apply(n2),
06578: "multiplicative expression"));
06579: val = Analyzer
06580: .cast(null == is_integer
06581: .apply(t1) ? null
06582: : is_integer
06583: .apply(t1) ? (null == Primitives.equal
06584: .apply(
06585: "*",
06586: op) ? null
06587: : Primitives.equal
06588: .apply(
06589: "*",
06590: op) ? new CTypes.IValue(
06591: Primitives.multiplyInt
06592: .apply(
06593: get_int
06594: .apply(t1),
06595: get_int
06596: .apply(t2)))
06597: : new Let<CTypes.valueType>() {
06598: final BigInteger i;
06599:
06600: {
06601: i = Analyzer
06602: .cast(get_int
06603: .apply(t2));
06604: }
06605:
06606: public CTypes.valueType apply() {
06607: return Analyzer
06608: .cast(null == Primitives.equal
06609: .apply(
06610: i,
06611: BigInteger
06612: .valueOf(0)) ? null
06613: : Primitives.equal
06614: .apply(
06615: i,
06616: BigInteger
06617: .valueOf(0)) ? null
06618: : new CTypes.IValue(
06619: Primitives.divideInt
06620: .apply(
06621: get_int
06622: .apply(t1),
06623: i)));
06624: }
06625: }
06626: .apply())
06627: : null == Primitives.equal
06628: .apply(
06629: "*",
06630: op) ? null
06631: : Primitives.equal
06632: .apply(
06633: "*",
06634: op) ? new CTypes.FValue(
06635: Primitives.multiplyFloat64
06636: .apply(
06637: get_float
06638: .apply(t1),
06639: get_float
06640: .apply(t2)))
06641: : new Let<CTypes.valueType>() {
06642: final Double f;
06643:
06644: {
06645: f = Analyzer
06646: .cast(get_float
06647: .apply(t2));
06648: }
06649:
06650: public CTypes.valueType apply() {
06651: return Analyzer
06652: .cast(null == Primitives.equal
06653: .apply(
06654: f,
06655: new Double(
06656: 0.0)) ? null
06657: : Primitives.equal
06658: .apply(
06659: f,
06660: new Double(
06661: 0.0)) ? null
06662: : new CTypes.FValue(
06663: Primitives.divideFloat64
06664: .apply(
06665: get_float
06666: .apply(t1),
06667: f)));
06668: }
06669: }
06670: .apply());
06671: quals = Analyzer
06672: .cast(null == Primitives.and
06673: .apply(
06674: is_const
06675: .apply(t1),
06676: is_const
06677: .apply(t2)) ? null
06678: : Primitives.and
06679: .apply(
06680: is_const
06681: .apply(t1),
06682: is_const
06683: .apply(t2)) ? new Pair<CTypes.qualifier>(
06684: new CTypes.ConstQ())
06685: : Pair
06686: .<CTypes.qualifier> empty());
06687: res = Analyzer
06688: .cast(arith_convert
06689: .apply(t1, t2));
06690: }
06691:
06692: public CTypes.type apply() {
06693: return Analyzer
06694: .cast(new Match<CTypes.type>() {
06695: public CTypes.type apply() {
06696: final String arg$691 = Analyzer
06697: .cast(op);
06698:
06699: if ((null == arg$691)) {
06700: return null;
06701: }
06702: if ((null != "%" && "%"
06703: .equals(arg$691))) {
06704: return Analyzer
06705: .cast(new Let<CTypes.type>() {
06706: final CTypes.type tmod1;
06707: final CTypes.type tmod2;
06708:
06709: {
06710: tmod1 = Analyzer
06711: .cast(ensure_integer
06712: .apply(
06713: t1,
06714: "modulo expression"));
06715: tmod2 = Analyzer
06716: .cast(ensure_integer
06717: .apply(
06718: t2,
06719: "modulo expression"));
06720: }
06721:
06722: public CTypes.type apply() {
06723: return Analyzer
06724: .cast(null == Primitives.and
06725: .apply(
06726: Primitives.isNotBottom
06727: .apply(tmod1),
06728: Primitives.isNotBottom
06729: .apply(tmod2))
06730: || !Primitives.and
06731: .apply(
06732: Primitives.isNotBottom
06733: .apply(tmod1),
06734: Primitives.isNotBottom
06735: .apply(tmod2)) ? null
06736: : new CTypes.type(
06737: null == t1 ? null
06738: : t1.type,
06739: quals,
06740: null == t1 ? null
06741: : t1.storage,
06742: null == t1 ? null
06743: : t1.fSpec,
06744: val,
06745: null == t1 ? null
06746: : t1.implicit,
06747: null == t1 ? null
06748: : t1.initialised,
06749: null == t1 ? null
06750: : t1.position,
06751: null == t1 ? null
06752: : t1.old_style,
06753: null == t1 ? null
06754: : t1.var_args,
06755: null == t1 ? null
06756: : t1.in_top));
06757: }
06758: }
06759: .apply());
06760: }
06761: if ((null != "/" && "/"
06762: .equals(arg$691))) {
06763: return Analyzer
06764: .cast(null == Primitives.and
06765: .apply(
06766: is_const
06767: .apply(t2),
06768: zero
06769: .apply(t2)) ? null
06770: : Primitives.and
06771: .apply(
06772: is_const
06773: .apply(t2),
06774: zero
06775: .apply(t2)) ? new Let<CTypes.type>() {
06776: {
06777: warning(
06778: "division by zero",
06779: null);
06780: Analyzer
06781: .discard(null == Primitives.and
06782: .apply(
06783: is_top
06784: .apply(n),
06785: Primitives.isNotBottom
06786: .apply(ancestor
06787: .apply(CSupport.nodeMatch$668)))
06788: || !Primitives.and
06789: .apply(
06790: is_top
06791: .apply(n),
06792: Primitives.isNotBottom
06793: .apply(ancestor
06794: .apply(CSupport.nodeMatch$668))) ? null
06795: : new Let<Object>() {
06796: final Node init;
06797: final String s;
06798:
06799: {
06800: init = Analyzer
06801: .cast(ancestor
06802: .apply(CSupport.nodeMatch$668));
06803: s = Analyzer
06804: .cast(new Match<String>() {
06805: public String apply() {
06806: final Node arg$705 = GNode
06807: .cast(init);
06808:
06809: if ((null == arg$705)) {
06810: return null;
06811: }
06812: if (CSupport
06813: .match$387(arg$705)) {
06814: final Node dec = (arg$705
06815: .size() > 1 ? arg$705
06816: .getGeneric(1)
06817: : null);
06818:
06819: matching_nodes
06820: .add(arg$705);
06821: if ((null != arg$705 && processScopeNodes
06822: .contains(arg$705
06823: .getName()))) {
06824: processScope(
06825: arg$705,
06826: getScope);
06827: }
06828: checkEnterScope(arg$705);
06829:
06830: final Object retValue$709 = Analyzer
06831: .cast(get_id_declarator
06832: .apply(dec));
06833:
06834: checkExitScope(arg$705);
06835: matching_nodes
06836: .remove(matching_nodes
06837: .size() - 1);
06838: return Analyzer
06839: .cast(retValue$709);
06840: }
06841: if (true) {
06842: matching_nodes
06843: .add(arg$705);
06844: if ((null != arg$705 && processScopeNodes
06845: .contains(arg$705
06846: .getName()))) {
06847: processScope(
06848: arg$705,
06849: getScope);
06850: }
06851: checkEnterScope(arg$705);
06852:
06853: final Object retValue$712 = Analyzer
06854: .cast("");
06855:
06856: checkExitScope(arg$705);
06857: matching_nodes
06858: .remove(matching_nodes
06859: .size() - 1);
06860: return Analyzer
06861: .cast(retValue$712);
06862: }
06863: return null;
06864: }
06865: }
06866: .apply());
06867: }
06868:
06869: public Object apply() {
06870: return Analyzer
06871: .cast(error(
06872: Primitives.concat
06873: .apply(
06874: Primitives.concat
06875: .apply(
06876: "initializer of '",
06877: s),
06878: "' is not constant"),
06879: null));
06880: }
06881: }
06882: .apply());
06883: }
06884:
06885: public CTypes.type apply() {
06886: return Analyzer
06887: .cast(new CTypes.type(
06888: null == res ? null
06889: : res.type,
06890: quals,
06891: null == res ? null
06892: : res.storage,
06893: null == res ? null
06894: : res.fSpec,
06895: val,
06896: null == res ? null
06897: : res.implicit,
06898: null == res ? null
06899: : res.initialised,
06900: null == res ? null
06901: : res.position,
06902: null == res ? null
06903: : res.old_style,
06904: null == res ? null
06905: : res.var_args,
06906: null == res ? null
06907: : res.in_top));
06908: }
06909: }
06910: .apply()
06911: : new CTypes.type(
06912: null == res ? null
06913: : res.type,
06914: quals,
06915: null == res ? null
06916: : res.storage,
06917: null == res ? null
06918: : res.fSpec,
06919: val,
06920: null == res ? null
06921: : res.implicit,
06922: null == res ? null
06923: : res.initialised,
06924: null == res ? null
06925: : res.position,
06926: null == res ? null
06927: : res.old_style,
06928: null == res ? null
06929: : res.var_args,
06930: null == res ? null
06931: : res.in_top));
06932: }
06933: if ((null != "*" && "*"
06934: .equals(arg$691))) {
06935: return Analyzer
06936: .cast(new CTypes.type(
06937: null == res ? null
06938: : res.type,
06939: quals,
06940: null == res ? null
06941: : res.storage,
06942: null == res ? null
06943: : res.fSpec,
06944: val,
06945: null == res ? null
06946: : res.implicit,
06947: null == res ? null
06948: : res.initialised,
06949: null == res ? null
06950: : res.position,
06951: null == res ? null
06952: : res.old_style,
06953: null == res ? null
06954: : res.var_args,
06955: null == res ? null
06956: : res.in_top));
06957: }
06958: if (true) {
06959: return Analyzer
06960: .cast(null);
06961: }
06962: return null;
06963: }
06964: }.apply());
06965: }
06966: }.apply());
06967:
06968: checkExitScope(arg$596);
06969: matching_nodes
06970: .remove(matching_nodes.size() - 1);
06971: return Analyzer.cast(retValue$717);
06972: }
06973: if (CSupport.match$718(arg$596)) {
06974: final Node e = (arg$596.size() > 0 ? arg$596
06975: .getGeneric(0) : null);
06976:
06977: matching_nodes.add(arg$596);
06978: if ((null != arg$596 && processScopeNodes
06979: .contains(arg$596.getName()))) {
06980: processScope(arg$596, getScope);
06981: }
06982: checkEnterScope(arg$596);
06983:
06984: final Object retValue$739 = Analyzer
06985: .cast(new Let<CTypes.type>() {
06986: final CTypes.type t;
06987:
06988: {
06989: t = Analyzer
06990: .cast(new Match<CTypes.type>() {
06991: public CTypes.type apply() {
06992: final Node arg$728 = GNode
06993: .cast(e);
06994:
06995: if ((null == arg$728)) {
06996: return null;
06997: }
06998: if (CSupport
06999: .match$349(arg$728)) {
07000: matching_nodes
07001: .add(arg$728);
07002: if ((null != arg$728 && processScopeNodes
07003: .contains(arg$728
07004: .getName()))) {
07005: processScope(
07006: arg$728,
07007: getScope);
07008: }
07009: checkEnterScope(arg$728);
07010:
07011: final Object retValue$732 = Analyzer
07012: .cast(analyze_type_name
07013: .apply(e));
07014:
07015: checkExitScope(arg$728);
07016: matching_nodes
07017: .remove(matching_nodes
07018: .size() - 1);
07019: return Analyzer
07020: .cast(retValue$732);
07021: }
07022: if (true) {
07023: matching_nodes
07024: .add(arg$728);
07025: if ((null != arg$728 && processScopeNodes
07026: .contains(arg$728
07027: .getName()))) {
07028: processScope(
07029: arg$728,
07030: getScope);
07031: }
07032: checkEnterScope(arg$728);
07033:
07034: final Object retValue$735 = Analyzer
07035: .cast(analyze_expression
07036: .apply(e));
07037:
07038: checkExitScope(arg$728);
07039: matching_nodes
07040: .remove(matching_nodes
07041: .size() - 1);
07042: return Analyzer
07043: .cast(retValue$735);
07044: }
07045: return null;
07046: }
07047: }.apply());
07048: }
07049:
07050: public CTypes.type apply() {
07051: return Analyzer
07052: .cast(null == Primitives.isBottom
07053: .apply(t) ? null
07054: : Primitives.isBottom
07055: .apply(t) ? null
07056: : null == Primitives.and
07057: .apply(
07058: Primitives.not
07059: .apply(is_array
07060: .apply(t)),
07061: is_incomplete
07062: .apply(t)) ? null
07063: : Primitives.and
07064: .apply(
07065: Primitives.not
07066: .apply(is_array
07067: .apply(t)),
07068: is_incomplete
07069: .apply(t)) ? error(
07070: "invalid application of 'sizeof' to incomplete type",
07071: null)
07072: : null == is_bitfield
07073: .apply(t) ? null
07074: : is_bitfield
07075: .apply(t) ? error(
07076: "'sizeof' applied to a bit-field",
07077: null)
07078: : new CTypes.type(
07079: new CTypes.IntT(),
07080: new Pair<CTypes.qualifier>(
07081: new CTypes.ConstQ()),
07082: null,
07083: null,
07084: new CTypes.IValue(
07085: sizeof
07086: .apply(t)),
07087: null,
07088: null,
07089: null,
07090: null,
07091: null,
07092: null));
07093: }
07094: }.apply());
07095:
07096: checkExitScope(arg$596);
07097: matching_nodes
07098: .remove(matching_nodes.size() - 1);
07099: return Analyzer.cast(retValue$739);
07100: }
07101: if (CSupport.match$740(arg$596)) {
07102: final Node e = (arg$596.size() > 0 ? arg$596
07103: .getGeneric(0) : null);
07104:
07105: matching_nodes.add(arg$596);
07106: if ((null != arg$596 && processScopeNodes
07107: .contains(arg$596.getName()))) {
07108: processScope(arg$596, getScope);
07109: }
07110: checkEnterScope(arg$596);
07111:
07112: final Object retValue$761 = Analyzer
07113: .cast(new Let<CTypes.type>() {
07114: final CTypes.type t;
07115:
07116: {
07117: t = Analyzer
07118: .cast(new Match<CTypes.type>() {
07119: public CTypes.type apply() {
07120: final Node arg$750 = GNode
07121: .cast(e);
07122:
07123: if ((null == arg$750)) {
07124: return null;
07125: }
07126: if (CSupport
07127: .match$349(arg$750)) {
07128: matching_nodes
07129: .add(arg$750);
07130: if ((null != arg$750 && processScopeNodes
07131: .contains(arg$750
07132: .getName()))) {
07133: processScope(
07134: arg$750,
07135: getScope);
07136: }
07137: checkEnterScope(arg$750);
07138:
07139: final Object retValue$754 = Analyzer
07140: .cast(analyze_type_name
07141: .apply(e));
07142:
07143: checkExitScope(arg$750);
07144: matching_nodes
07145: .remove(matching_nodes
07146: .size() - 1);
07147: return Analyzer
07148: .cast(retValue$754);
07149: }
07150: if (true) {
07151: matching_nodes
07152: .add(arg$750);
07153: if ((null != arg$750 && processScopeNodes
07154: .contains(arg$750
07155: .getName()))) {
07156: processScope(
07157: arg$750,
07158: getScope);
07159: }
07160: checkEnterScope(arg$750);
07161:
07162: final Object retValue$757 = Analyzer
07163: .cast(analyze_expression
07164: .apply(e));
07165:
07166: checkExitScope(arg$750);
07167: matching_nodes
07168: .remove(matching_nodes
07169: .size() - 1);
07170: return Analyzer
07171: .cast(retValue$757);
07172: }
07173: return null;
07174: }
07175: }.apply());
07176: }
07177:
07178: public CTypes.type apply() {
07179: return Analyzer
07180: .cast(null == Primitives.isBottom
07181: .apply(t) ? null
07182: : Primitives.isBottom
07183: .apply(t) ? null
07184: : null == Primitives.and
07185: .apply(
07186: Primitives.not
07187: .apply(is_array
07188: .apply(t)),
07189: is_incomplete
07190: .apply(t)) ? null
07191: : Primitives.and
07192: .apply(
07193: Primitives.not
07194: .apply(is_array
07195: .apply(t)),
07196: is_incomplete
07197: .apply(t)) ? error(
07198: "invalid application of '__alignof' to incomplete type",
07199: null)
07200: : null == is_bitfield
07201: .apply(t) ? null
07202: : is_bitfield
07203: .apply(t) ? error(
07204: "__alignof' applied to a bit-field",
07205: null)
07206: : new CTypes.type(
07207: new CTypes.IntT(),
07208: new Pair<CTypes.qualifier>(
07209: new CTypes.ConstQ()),
07210: null,
07211: null,
07212: null,
07213: null,
07214: null,
07215: null,
07216: null,
07217: null,
07218: null));
07219: }
07220: }.apply());
07221:
07222: checkExitScope(arg$596);
07223: matching_nodes
07224: .remove(matching_nodes.size() - 1);
07225: return Analyzer.cast(retValue$761);
07226: }
07227: if (CSupport.match$762(arg$596)) {
07228: final Node e = (arg$596.size() > 0 ? arg$596
07229: .getGeneric(0) : null);
07230:
07231: matching_nodes.add(arg$596);
07232: if ((null != arg$596 && processScopeNodes
07233: .contains(arg$596.getName()))) {
07234: processScope(arg$596, getScope);
07235: }
07236: checkEnterScope(arg$596);
07237:
07238: final Object retValue$765 = Analyzer
07239: .cast(new Let<CTypes.type>() {
07240: final CTypes.type t;
07241:
07242: {
07243: t = Analyzer
07244: .cast(ensure_arithmetic
07245: .apply(
07246: analyze_expression
07247: .apply(e),
07248: "unary plus expression"));
07249: }
07250:
07251: public CTypes.type apply() {
07252: return Analyzer
07253: .cast(null == is_float
07254: .apply(t) ? null
07255: : is_float
07256: .apply(t) ? new CTypes.type(
07257: null == t ? null
07258: : t.type,
07259: null == t ? null
07260: : t.qualifiers,
07261: null == t ? null
07262: : t.storage,
07263: null == t ? null
07264: : t.fSpec,
07265: new CTypes.FValue(
07266: Primitives.absFloat64
07267: .apply(get_float
07268: .apply(t))),
07269: null == t ? null
07270: : t.implicit,
07271: null == t ? null
07272: : t.initialised,
07273: null == t ? null
07274: : t.position,
07275: null == t ? null
07276: : t.old_style,
07277: null == t ? null
07278: : t.var_args,
07279: null == t ? null
07280: : t.in_top)
07281: : null == is_integer
07282: .apply(t)
07283: || !is_integer
07284: .apply(t) ? null
07285: : new CTypes.type(
07286: null == t ? null
07287: : t.type,
07288: null == t ? null
07289: : t.qualifiers,
07290: null == t ? null
07291: : t.storage,
07292: null == t ? null
07293: : t.fSpec,
07294: new CTypes.IValue(
07295: Primitives.absInt
07296: .apply(get_int
07297: .apply(t))),
07298: null == t ? null
07299: : t.implicit,
07300: null == t ? null
07301: : t.initialised,
07302: null == t ? null
07303: : t.position,
07304: null == t ? null
07305: : t.old_style,
07306: null == t ? null
07307: : t.var_args,
07308: null == t ? null
07309: : t.in_top));
07310: }
07311: }.apply());
07312:
07313: checkExitScope(arg$596);
07314: matching_nodes
07315: .remove(matching_nodes.size() - 1);
07316: return Analyzer.cast(retValue$765);
07317: }
07318: if (CSupport.match$766(arg$596)) {
07319: final Node e = (arg$596.size() > 0 ? arg$596
07320: .getGeneric(0) : null);
07321:
07322: matching_nodes.add(arg$596);
07323: if ((null != arg$596 && processScopeNodes
07324: .contains(arg$596.getName()))) {
07325: processScope(arg$596, getScope);
07326: }
07327: checkEnterScope(arg$596);
07328:
07329: final Object retValue$769 = Analyzer
07330: .cast(new Let<CTypes.type>() {
07331: final CTypes.type t;
07332:
07333: {
07334: t = Analyzer
07335: .cast(ensure_arithmetic
07336: .apply(
07337: analyze_expression
07338: .apply(e),
07339: "unary minus expression"));
07340: }
07341:
07342: public CTypes.type apply() {
07343: return Analyzer
07344: .cast(null == is_float
07345: .apply(t) ? null
07346: : is_float
07347: .apply(t) ? new CTypes.type(
07348: null == t ? null
07349: : t.type,
07350: null == t ? null
07351: : t.qualifiers,
07352: null == t ? null
07353: : t.storage,
07354: null == t ? null
07355: : t.fSpec,
07356: new CTypes.FValue(
07357: Primitives.negateFloat64
07358: .apply(get_float
07359: .apply(t))),
07360: null == t ? null
07361: : t.implicit,
07362: null == t ? null
07363: : t.initialised,
07364: null == t ? null
07365: : t.position,
07366: null == t ? null
07367: : t.old_style,
07368: null == t ? null
07369: : t.var_args,
07370: null == t ? null
07371: : t.in_top)
07372: : null == is_integer
07373: .apply(t)
07374: || !is_integer
07375: .apply(t) ? null
07376: : new CTypes.type(
07377: null == t ? null
07378: : t.type,
07379: null == t ? null
07380: : t.qualifiers,
07381: null == t ? null
07382: : t.storage,
07383: null == t ? null
07384: : t.fSpec,
07385: new CTypes.IValue(
07386: Primitives.negateInt
07387: .apply(get_int
07388: .apply(t))),
07389: null == t ? null
07390: : t.implicit,
07391: null == t ? null
07392: : t.initialised,
07393: null == t ? null
07394: : t.position,
07395: null == t ? null
07396: : t.old_style,
07397: null == t ? null
07398: : t.var_args,
07399: null == t ? null
07400: : t.in_top));
07401: }
07402: }.apply());
07403:
07404: checkExitScope(arg$596);
07405: matching_nodes
07406: .remove(matching_nodes.size() - 1);
07407: return Analyzer.cast(retValue$769);
07408: }
07409: if (CSupport.match$770(arg$596)) {
07410: final Node e = (arg$596.size() > 0 ? arg$596
07411: .getGeneric(0) : null);
07412:
07413: matching_nodes.add(arg$596);
07414: if ((null != arg$596 && processScopeNodes
07415: .contains(arg$596.getName()))) {
07416: processScope(arg$596, getScope);
07417: }
07418: checkEnterScope(arg$596);
07419:
07420: final Object retValue$799 = Analyzer
07421: .cast(new Match<CTypes.type>() {
07422: public CTypes.type apply() {
07423: final Node arg$784 = GNode
07424: .cast(e);
07425:
07426: if ((null == arg$784)) {
07427: return null;
07428: }
07429: if (CSupport.match$772(arg$784)) {
07430: final Node e1 = (arg$784
07431: .size() > 0 ? arg$784
07432: .getGeneric(0)
07433: : null);
07434:
07435: matching_nodes.add(arg$784);
07436: if ((null != arg$784 && processScopeNodes
07437: .contains(arg$784
07438: .getName()))) {
07439: processScope(arg$784,
07440: getScope);
07441: }
07442: checkEnterScope(arg$784);
07443:
07444: final Object retValue$788 = Analyzer
07445: .cast(new Let<CTypes.type>() {
07446: final CTypes.type t;
07447:
07448: {
07449: t = Analyzer
07450: .cast(analyze_expression
07451: .apply(e1));
07452: process_indirection
07453: .apply(pointerize
07454: .apply(t));
07455: }
07456:
07457: public CTypes.type apply() {
07458: return Analyzer
07459: .cast(t);
07460: }
07461: }.apply());
07462:
07463: checkExitScope(arg$784);
07464: matching_nodes
07465: .remove(matching_nodes
07466: .size() - 1);
07467: return Analyzer
07468: .cast(retValue$788);
07469: }
07470: if (CSupport.match$776(arg$784)) {
07471: final Node e1 = (arg$784
07472: .size() > 0 ? arg$784
07473: .getGeneric(0)
07474: : null);
07475: final Node e2 = (arg$784
07476: .size() > 1 ? arg$784
07477: .getGeneric(1)
07478: : null);
07479:
07480: matching_nodes.add(arg$784);
07481: if ((null != arg$784 && processScopeNodes
07482: .contains(arg$784
07483: .getName()))) {
07484: processScope(arg$784,
07485: getScope);
07486: }
07487: checkEnterScope(arg$784);
07488:
07489: final Object retValue$792 = Analyzer
07490: .cast(new Let<CTypes.type>() {
07491: final CTypes.type t;
07492:
07493: {
07494: t = Analyzer
07495: .cast(analyze_expression
07496: .apply(e1));
07497: ensure_integer
07498: .apply(
07499: analyze_expression
07500: .apply(e2),
07501: "subscript expression");
07502: process_subscript
07503: .apply(t);
07504: }
07505:
07506: public CTypes.type apply() {
07507: return Analyzer
07508: .cast(t);
07509: }
07510: }.apply());
07511:
07512: checkExitScope(arg$784);
07513: matching_nodes
07514: .remove(matching_nodes
07515: .size() - 1);
07516: return Analyzer
07517: .cast(retValue$792);
07518: }
07519: if (true) {
07520: matching_nodes.add(arg$784);
07521: if ((null != arg$784 && processScopeNodes
07522: .contains(arg$784
07523: .getName()))) {
07524: processScope(arg$784,
07525: getScope);
07526: }
07527: checkEnterScope(arg$784);
07528:
07529: final Object retValue$795 = Analyzer
07530: .cast(new CTypes.type(
07531: new CTypes.PointerType(
07532: analyze_expression
07533: .apply(e)),
07534: null, null,
07535: null, null,
07536: null, null,
07537: null, null,
07538: null, null));
07539:
07540: checkExitScope(arg$784);
07541: matching_nodes
07542: .remove(matching_nodes
07543: .size() - 1);
07544: return Analyzer
07545: .cast(retValue$795);
07546: }
07547: return null;
07548: }
07549: }.apply());
07550:
07551: checkExitScope(arg$596);
07552: matching_nodes
07553: .remove(matching_nodes.size() - 1);
07554: return Analyzer.cast(retValue$799);
07555: }
07556: if (CSupport.match$37(arg$596)) {
07557: matching_nodes.add(arg$596);
07558: if ((null != arg$596 && processScopeNodes
07559: .contains(arg$596.getName()))) {
07560: processScope(arg$596, getScope);
07561: }
07562: checkEnterScope(arg$596);
07563:
07564: final Object retValue$803 = Analyzer
07565: .cast(new Let<CTypes.type>() {
07566: {
07567: Analyzer.cast(lookup4.apply(n,
07568: "error",
07569: "undefined label",
07570: getNameSpace));
07571: }
07572:
07573: public CTypes.type apply() {
07574: return Analyzer
07575: .cast(new CTypes.type(
07576: new CTypes.PointerType(
07577: new CTypes.type(
07578: new CTypes.VoidT(),
07579: null,
07580: null,
07581: null,
07582: null,
07583: null,
07584: null,
07585: null,
07586: null,
07587: null,
07588: null)),
07589: null, null,
07590: null, null,
07591: null, null,
07592: null, null,
07593: null, null));
07594: }
07595: }.apply());
07596:
07597: checkExitScope(arg$596);
07598: matching_nodes
07599: .remove(matching_nodes.size() - 1);
07600: return Analyzer.cast(retValue$803);
07601: }
07602: if (CSupport.match$772(arg$596)) {
07603: final Node e = (arg$596.size() > 0 ? arg$596
07604: .getGeneric(0) : null);
07605:
07606: matching_nodes.add(arg$596);
07607: if ((null != arg$596 && processScopeNodes
07608: .contains(arg$596.getName()))) {
07609: processScope(arg$596, getScope);
07610: }
07611: checkEnterScope(arg$596);
07612:
07613: final Object retValue$807 = Analyzer
07614: .cast(new Let<CTypes.type>() {
07615: final CTypes.type t;
07616:
07617: {
07618: t = Analyzer
07619: .cast(pointerize
07620: .apply(analyze_expression
07621: .apply(e)));
07622: }
07623:
07624: public CTypes.type apply() {
07625: return Analyzer
07626: .cast(process_indirection
07627: .apply(t));
07628: }
07629: }.apply());
07630:
07631: checkExitScope(arg$596);
07632: matching_nodes
07633: .remove(matching_nodes.size() - 1);
07634: return Analyzer.cast(retValue$807);
07635: }
07636: if (CSupport.match$808(arg$596)) {
07637: final Node e = (arg$596.size() > 0 ? arg$596
07638: .getGeneric(0) : null);
07639:
07640: matching_nodes.add(arg$596);
07641: if ((null != arg$596 && processScopeNodes
07642: .contains(arg$596.getName()))) {
07643: processScope(arg$596, getScope);
07644: }
07645: checkEnterScope(arg$596);
07646:
07647: final Object retValue$811 = Analyzer
07648: .cast(new Let<CTypes.type>() {
07649: final CTypes.type t;
07650:
07651: {
07652: t = Analyzer
07653: .cast(ensure_scalar
07654: .apply(
07655: analyze_expression
07656: .apply(e),
07657: "increment/decrement expression"));
07658: ensure_modifiable_lvalue
07659: .apply(t);
07660: }
07661:
07662: public CTypes.type apply() {
07663: return Analyzer
07664: .cast(null == Primitives.and
07665: .apply(
07666: Primitives.and
07667: .apply(
07668: Primitives.or
07669: .apply(
07670: is_pointer
07671: .apply(t),
07672: is_array
07673: .apply(t)),
07674: Primitives.not
07675: .apply(is_void
07676: .apply(get_base
07677: .apply(t)))),
07678: is_incomplete
07679: .apply(get_base
07680: .apply(t))) ? null
07681: : Primitives.and
07682: .apply(
07683: Primitives.and
07684: .apply(
07685: Primitives.or
07686: .apply(
07687: is_pointer
07688: .apply(t),
07689: is_array
07690: .apply(t)),
07691: Primitives.not
07692: .apply(is_void
07693: .apply(get_base
07694: .apply(t)))),
07695: is_incomplete
07696: .apply(get_base
07697: .apply(t))) ? error(
07698: "arithmetic on pointer to an incomplete type",
07699: null)
07700: : t);
07701: }
07702: }.apply());
07703:
07704: checkExitScope(arg$596);
07705: matching_nodes
07706: .remove(matching_nodes.size() - 1);
07707: return Analyzer.cast(retValue$811);
07708: }
07709: if (CSupport.match$812(arg$596)) {
07710: final Node e = (arg$596.size() > 0 ? arg$596
07711: .getGeneric(0) : null);
07712:
07713: matching_nodes.add(arg$596);
07714: if ((null != arg$596 && processScopeNodes
07715: .contains(arg$596.getName()))) {
07716: processScope(arg$596, getScope);
07717: }
07718: checkEnterScope(arg$596);
07719:
07720: final Object retValue$815 = Analyzer
07721: .cast(new Let<CTypes.type>() {
07722: final CTypes.type t;
07723:
07724: {
07725: t = Analyzer
07726: .cast(ensure_scalar
07727: .apply(
07728: analyze_expression
07729: .apply(e),
07730: "increment/decrement expression"));
07731: ensure_modifiable_lvalue
07732: .apply(t);
07733: }
07734:
07735: public CTypes.type apply() {
07736: return Analyzer
07737: .cast(null == Primitives.and
07738: .apply(
07739: Primitives.and
07740: .apply(
07741: Primitives.or
07742: .apply(
07743: is_pointer
07744: .apply(t),
07745: is_array
07746: .apply(t)),
07747: Primitives.not
07748: .apply(is_void
07749: .apply(get_base
07750: .apply(t)))),
07751: is_incomplete
07752: .apply(get_base
07753: .apply(t))) ? null
07754: : Primitives.and
07755: .apply(
07756: Primitives.and
07757: .apply(
07758: Primitives.or
07759: .apply(
07760: is_pointer
07761: .apply(t),
07762: is_array
07763: .apply(t)),
07764: Primitives.not
07765: .apply(is_void
07766: .apply(get_base
07767: .apply(t)))),
07768: is_incomplete
07769: .apply(get_base
07770: .apply(t))) ? error(
07771: "arithmetic on pointer to an incomplete type",
07772: null)
07773: : t);
07774: }
07775: }.apply());
07776:
07777: checkExitScope(arg$596);
07778: matching_nodes
07779: .remove(matching_nodes.size() - 1);
07780: return Analyzer.cast(retValue$815);
07781: }
07782: if (CSupport.match$816(arg$596)) {
07783: final Node e = (arg$596.size() > 0 ? arg$596
07784: .getGeneric(0) : null);
07785:
07786: matching_nodes.add(arg$596);
07787: if ((null != arg$596 && processScopeNodes
07788: .contains(arg$596.getName()))) {
07789: processScope(arg$596, getScope);
07790: }
07791: checkEnterScope(arg$596);
07792:
07793: final Object retValue$819 = Analyzer
07794: .cast(analyze_expression.apply(e));
07795:
07796: checkExitScope(arg$596);
07797: matching_nodes
07798: .remove(matching_nodes.size() - 1);
07799: return Analyzer.cast(retValue$819);
07800: }
07801: if (CSupport.match$820(arg$596)) {
07802: final Node e = (arg$596.size() > 0 ? arg$596
07803: .getGeneric(0) : null);
07804:
07805: matching_nodes.add(arg$596);
07806: if ((null != arg$596 && processScopeNodes
07807: .contains(arg$596.getName()))) {
07808: processScope(arg$596, getScope);
07809: }
07810: checkEnterScope(arg$596);
07811:
07812: final Object retValue$823 = Analyzer
07813: .cast(new Let<CTypes.type>() {
07814: final CTypes.type t;
07815:
07816: {
07817: t = Analyzer
07818: .cast(ensure_scalar
07819: .apply(
07820: analyze_expression
07821: .apply(e),
07822: "increment/decrement expression"));
07823: ensure_modifiable_lvalue
07824: .apply(t);
07825: }
07826:
07827: public CTypes.type apply() {
07828: return Analyzer
07829: .cast(null == is_float
07830: .apply(t) ? null
07831: : is_float
07832: .apply(t) ? new CTypes.type(
07833: null == t ? null
07834: : t.type,
07835: null == t ? null
07836: : t.qualifiers,
07837: null == t ? null
07838: : t.storage,
07839: null == t ? null
07840: : t.fSpec,
07841: new CTypes.FValue(
07842: Primitives.subtractFloat64
07843: .apply(
07844: new Double(
07845: 1.0),
07846: get_float
07847: .apply(t))),
07848: null == t ? null
07849: : t.implicit,
07850: null == t ? null
07851: : t.initialised,
07852: null == t ? null
07853: : t.position,
07854: null == t ? null
07855: : t.old_style,
07856: null == t ? null
07857: : t.var_args,
07858: null == t ? null
07859: : t.in_top)
07860: : null == is_integer
07861: .apply(t) ? null
07862: : is_integer
07863: .apply(t) ? new CTypes.type(
07864: null == t ? null
07865: : t.type,
07866: null == t ? null
07867: : t.qualifiers,
07868: null == t ? null
07869: : t.storage,
07870: null == t ? null
07871: : t.fSpec,
07872: new CTypes.IValue(
07873: Primitives.subtractInt
07874: .apply(
07875: BigInteger
07876: .valueOf(1),
07877: get_int
07878: .apply(t))),
07879: null == t ? null
07880: : t.implicit,
07881: null == t ? null
07882: : t.initialised,
07883: null == t ? null
07884: : t.position,
07885: null == t ? null
07886: : t.old_style,
07887: null == t ? null
07888: : t.var_args,
07889: null == t ? null
07890: : t.in_top)
07891: : null == Primitives.and
07892: .apply(
07893: Primitives.and
07894: .apply(
07895: Primitives.or
07896: .apply(
07897: is_pointer
07898: .apply(t),
07899: is_array
07900: .apply(t)),
07901: Primitives.not
07902: .apply(is_void
07903: .apply(get_base
07904: .apply(t)))),
07905: is_incomplete
07906: .apply(get_base
07907: .apply(t))) ? null
07908: : Primitives.and
07909: .apply(
07910: Primitives.and
07911: .apply(
07912: Primitives.or
07913: .apply(
07914: is_pointer
07915: .apply(t),
07916: is_array
07917: .apply(t)),
07918: Primitives.not
07919: .apply(is_void
07920: .apply(get_base
07921: .apply(t)))),
07922: is_incomplete
07923: .apply(get_base
07924: .apply(t))) ? error(
07925: "arithmetic on pointer to an incomplete type",
07926: null)
07927: : t);
07928: }
07929: }.apply());
07930:
07931: checkExitScope(arg$596);
07932: matching_nodes
07933: .remove(matching_nodes.size() - 1);
07934: return Analyzer.cast(retValue$823);
07935: }
07936: if (CSupport.match$824(arg$596)) {
07937: final Node e = (arg$596.size() > 0 ? arg$596
07938: .getGeneric(0) : null);
07939:
07940: matching_nodes.add(arg$596);
07941: if ((null != arg$596 && processScopeNodes
07942: .contains(arg$596.getName()))) {
07943: processScope(arg$596, getScope);
07944: }
07945: checkEnterScope(arg$596);
07946:
07947: final Object retValue$827 = Analyzer
07948: .cast(new Let<CTypes.type>() {
07949: final CTypes.type t;
07950:
07951: {
07952: t = Analyzer
07953: .cast(ensure_scalar
07954: .apply(
07955: analyze_expression
07956: .apply(e),
07957: "increment/decrement expression"));
07958: ensure_modifiable_lvalue
07959: .apply(t);
07960: }
07961:
07962: public CTypes.type apply() {
07963: return Analyzer
07964: .cast(null == is_float
07965: .apply(t) ? null
07966: : is_float
07967: .apply(t) ? new CTypes.type(
07968: null == t ? null
07969: : t.type,
07970: null == t ? null
07971: : t.qualifiers,
07972: null == t ? null
07973: : t.storage,
07974: null == t ? null
07975: : t.fSpec,
07976: new CTypes.FValue(
07977: Primitives.addFloat64
07978: .apply(
07979: new Double(
07980: 1.0),
07981: get_float
07982: .apply(t))),
07983: null == t ? null
07984: : t.implicit,
07985: null == t ? null
07986: : t.initialised,
07987: null == t ? null
07988: : t.position,
07989: null == t ? null
07990: : t.old_style,
07991: null == t ? null
07992: : t.var_args,
07993: null == t ? null
07994: : t.in_top)
07995: : null == is_integer
07996: .apply(t) ? null
07997: : is_integer
07998: .apply(t) ? new CTypes.type(
07999: null == t ? null
08000: : t.type,
08001: null == t ? null
08002: : t.qualifiers,
08003: null == t ? null
08004: : t.storage,
08005: null == t ? null
08006: : t.fSpec,
08007: new CTypes.IValue(
08008: Primitives.addInt
08009: .apply(
08010: BigInteger
08011: .valueOf(1),
08012: get_int
08013: .apply(t))),
08014: null == t ? null
08015: : t.implicit,
08016: null == t ? null
08017: : t.initialised,
08018: null == t ? null
08019: : t.position,
08020: null == t ? null
08021: : t.old_style,
08022: null == t ? null
08023: : t.var_args,
08024: null == t ? null
08025: : t.in_top)
08026: : null == Primitives.and
08027: .apply(
08028: Primitives.and
08029: .apply(
08030: Primitives.or
08031: .apply(
08032: is_pointer
08033: .apply(t),
08034: is_array
08035: .apply(t)),
08036: Primitives.not
08037: .apply(is_void
08038: .apply(get_base
08039: .apply(t)))),
08040: is_incomplete
08041: .apply(get_base
08042: .apply(t))) ? null
08043: : Primitives.and
08044: .apply(
08045: Primitives.and
08046: .apply(
08047: Primitives.or
08048: .apply(
08049: is_pointer
08050: .apply(t),
08051: is_array
08052: .apply(t)),
08053: Primitives.not
08054: .apply(is_void
08055: .apply(get_base
08056: .apply(t)))),
08057: is_incomplete
08058: .apply(get_base
08059: .apply(t))) ? error(
08060: "arithmetic on pointer to an incomplete type",
08061: null)
08062: : t);
08063: }
08064: }.apply());
08065:
08066: checkExitScope(arg$596);
08067: matching_nodes
08068: .remove(matching_nodes.size() - 1);
08069: return Analyzer.cast(retValue$827);
08070: }
08071: if (CSupport.match$828(arg$596)) {
08072: final Node e = (arg$596.size() > 0 ? arg$596
08073: .getGeneric(0) : null);
08074:
08075: matching_nodes.add(arg$596);
08076: if ((null != arg$596 && processScopeNodes
08077: .contains(arg$596.getName()))) {
08078: processScope(arg$596, getScope);
08079: }
08080: checkEnterScope(arg$596);
08081:
08082: final Object retValue$831 = Analyzer
08083: .cast(analyze_statement
08084: .apply(
08085: Boolean.FALSE,
08086: Pair
08087: .<CTypes.label_record> empty(),
08088: Boolean.TRUE, e));
08089:
08090: checkExitScope(arg$596);
08091: matching_nodes
08092: .remove(matching_nodes.size() - 1);
08093: return Analyzer.cast(retValue$831);
08094: }
08095: if (CSupport.match$832(arg$596)) {
08096: final Node tn = (arg$596.size() > 0 ? arg$596
08097: .getGeneric(0) : null);
08098: final Node e = (arg$596.size() > 1 ? arg$596
08099: .getGeneric(1) : null);
08100:
08101: matching_nodes.add(arg$596);
08102: if ((null != arg$596 && processScopeNodes
08103: .contains(arg$596.getName()))) {
08104: processScope(arg$596, getScope);
08105: }
08106: checkEnterScope(arg$596);
08107:
08108: final Object retValue$853 = Analyzer
08109: .cast(new Let<CTypes.type>() {
08110: final CTypes.type t1;
08111:
08112: {
08113: t1 = Analyzer
08114: .cast(analyze_type_name
08115: .apply(tn));
08116: }
08117:
08118: public CTypes.type apply() {
08119: return Analyzer
08120: .cast(new Match<CTypes.type>() {
08121: public CTypes.type apply() {
08122: final Node arg$842 = GNode
08123: .cast(e);
08124:
08125: if ((null == arg$842)) {
08126: return null;
08127: }
08128: if (CSupport
08129: .match$834(arg$842)) {
08130: matching_nodes
08131: .add(arg$842);
08132: if ((null != arg$842 && processScopeNodes
08133: .contains(arg$842
08134: .getName()))) {
08135: processScope(
08136: arg$842,
08137: getScope);
08138: }
08139: checkEnterScope(arg$842);
08140:
08141: final Object retValue$846 = Analyzer
08142: .cast(analyze_initializer
08143: .apply(
08144: e,
08145: t1));
08146:
08147: checkExitScope(arg$842);
08148: matching_nodes
08149: .remove(matching_nodes
08150: .size() - 1);
08151: return Analyzer
08152: .cast(retValue$846);
08153: }
08154: if (true) {
08155: matching_nodes
08156: .add(arg$842);
08157: if ((null != arg$842 && processScopeNodes
08158: .contains(arg$842
08159: .getName()))) {
08160: processScope(
08161: arg$842,
08162: getScope);
08163: }
08164: checkEnterScope(arg$842);
08165:
08166: final Object retValue$849 = Analyzer
08167: .cast(new Let<CTypes.type>() {
08168: final CTypes.type t2;
08169: final CTypes.type rt;
08170:
08171: {
08172: t2 = Analyzer
08173: .cast(analyze_expression
08174: .apply(e));
08175: rt = Analyzer
08176: .cast(processCast
08177: .apply(
08178: t1,
08179: t2));
08180: }
08181:
08182: public CTypes.type apply() {
08183: return Analyzer
08184: .cast(new CTypes.type(
08185: null == rt ? null
08186: : rt.type,
08187: null == t2 ? null
08188: : t2.qualifiers,
08189: null == rt ? null
08190: : rt.storage,
08191: null == rt ? null
08192: : rt.fSpec,
08193: null == rt ? null
08194: : rt.value,
08195: null == rt ? null
08196: : rt.implicit,
08197: null == rt ? null
08198: : rt.initialised,
08199: null == rt ? null
08200: : rt.position,
08201: null == rt ? null
08202: : rt.old_style,
08203: null == rt ? null
08204: : rt.var_args,
08205: null == rt ? null
08206: : rt.in_top));
08207: }
08208: }
08209: .apply());
08210:
08211: checkExitScope(arg$842);
08212: matching_nodes
08213: .remove(matching_nodes
08214: .size() - 1);
08215: return Analyzer
08216: .cast(retValue$849);
08217: }
08218: return null;
08219: }
08220: }.apply());
08221: }
08222: }.apply());
08223:
08224: checkExitScope(arg$596);
08225: matching_nodes
08226: .remove(matching_nodes.size() - 1);
08227: return Analyzer.cast(retValue$853);
08228: }
08229: if (CSupport.match$776(arg$596)) {
08230: final Node e2 = (arg$596.size() > 0 ? arg$596
08231: .getGeneric(0) : null);
08232: final Node e3 = (arg$596.size() > 1 ? arg$596
08233: .getGeneric(1) : null);
08234:
08235: matching_nodes.add(arg$596);
08236: if ((null != arg$596 && processScopeNodes
08237: .contains(arg$596.getName()))) {
08238: processScope(arg$596, getScope);
08239: }
08240: checkEnterScope(arg$596);
08241:
08242: final Object retValue$857 = Analyzer
08243: .cast(new Let<CTypes.type>() {
08244: final CTypes.type t;
08245:
08246: {
08247: ensure_integer.apply(
08248: analyze_expression
08249: .apply(e3),
08250: "subscript expression");
08251: t = Analyzer
08252: .cast(analyze_expression
08253: .apply(e2));
08254: }
08255:
08256: public CTypes.type apply() {
08257: return Analyzer
08258: .cast(process_subscript
08259: .apply(t));
08260: }
08261: }.apply());
08262:
08263: checkExitScope(arg$596);
08264: matching_nodes
08265: .remove(matching_nodes.size() - 1);
08266: return Analyzer.cast(retValue$857);
08267: }
08268: if (CSupport.match$858(arg$596)) {
08269: matching_nodes.add(arg$596);
08270: if ((null != arg$596 && processScopeNodes
08271: .contains(arg$596.getName()))) {
08272: processScope(arg$596, getScope);
08273: }
08274: checkEnterScope(arg$596);
08275:
08276: final Object retValue$861 = Analyzer
08277: .cast(new CTypes.type(
08278: new CTypes.IntT(), null, null,
08279: null, null, null, null, null,
08280: null, null, null));
08281:
08282: checkExitScope(arg$596);
08283: matching_nodes
08284: .remove(matching_nodes.size() - 1);
08285: return Analyzer.cast(retValue$861);
08286: }
08287: if (CSupport.match$862(arg$596)) {
08288: final Node id = (arg$596.size() > 0 ? arg$596
08289: .getGeneric(0) : null);
08290: final Node el = (arg$596.size() > 1 ? arg$596
08291: .getGeneric(1) : null);
08292:
08293: matching_nodes.add(arg$596);
08294: if ((null != arg$596 && processScopeNodes
08295: .contains(arg$596.getName()))) {
08296: processScope(arg$596, getScope);
08297: }
08298: checkEnterScope(arg$596);
08299:
08300: final Object retValue$901 = Analyzer
08301: .cast(new Let<CTypes.type>() {
08302: final Pair<CTypes.type> elt;
08303:
08304: {
08305: elt = Analyzer
08306: .cast(new Match<Pair<CTypes.type>>() {
08307: public Pair<CTypes.type> apply() {
08308: final Node arg$890 = GNode
08309: .cast(el);
08310:
08311: if ((null == arg$890)) {
08312: return null;
08313: }
08314: if (CSupport
08315: .match$873(arg$890)) {
08316: final Pair<Node> elist = Analyzer
08317: .cast(Primitives
08318: .getChildren(
08319: arg$890,
08320: 0,
08321: arg$890
08322: .size()));
08323:
08324: matching_nodes
08325: .add(arg$890);
08326: if ((null != arg$890 && processScopeNodes
08327: .contains(arg$890
08328: .getName()))) {
08329: processScope(
08330: arg$890,
08331: getScope);
08332: }
08333: checkEnterScope(arg$890);
08334:
08335: final Object retValue$894 = Analyzer
08336: .cast(CSupport.map$212
08337: .apply(
08338: analyze_expression,
08339: elist));
08340:
08341: checkExitScope(arg$890);
08342: matching_nodes
08343: .remove(matching_nodes
08344: .size() - 1);
08345: return Analyzer
08346: .cast(retValue$894);
08347: }
08348: if (true) {
08349: matching_nodes
08350: .add(arg$890);
08351: if ((null != arg$890 && processScopeNodes
08352: .contains(arg$890
08353: .getName()))) {
08354: processScope(
08355: arg$890,
08356: getScope);
08357: }
08358: checkEnterScope(arg$890);
08359:
08360: final Object retValue$897 = Analyzer
08361: .cast(null);
08362:
08363: checkExitScope(arg$890);
08364: matching_nodes
08365: .remove(matching_nodes
08366: .size() - 1);
08367: return Analyzer
08368: .cast(retValue$897);
08369: }
08370: return null;
08371: }
08372: }.apply());
08373: }
08374:
08375: public CTypes.type apply() {
08376: return Analyzer
08377: .cast(new Match<CTypes.type>() {
08378: public CTypes.type apply() {
08379: final Node arg$881 = GNode
08380: .cast(id);
08381:
08382: if ((null == arg$881)) {
08383: return null;
08384: }
08385: if (CSupport
08386: .match$864(arg$881)) {
08387: matching_nodes
08388: .add(arg$881);
08389: if ((null != arg$881 && processScopeNodes
08390: .contains(arg$881
08391: .getName()))) {
08392: processScope(
08393: arg$881,
08394: getScope);
08395: }
08396: checkEnterScope(arg$881);
08397:
08398: final Object retValue$885 = Analyzer
08399: .cast(null == Primitives.not
08400: .apply(isDefined
08401: .apply(
08402: id,
08403: getNameSpace)) ? null
08404: : Primitives.not
08405: .apply(isDefined
08406: .apply(
08407: id,
08408: getNameSpace)) ? new Let<CTypes.type>() {
08409: {
08410: define3
08411: .apply(
08412: id,
08413: new CTypes.type(
08414: new CTypes.FunctionT(
08415: new CTypes.type(
08416: new CTypes.IntT(),
08417: null,
08418: null,
08419: null,
08420: null,
08421: null,
08422: null,
08423: null,
08424: null,
08425: null,
08426: null),
08427: elt),
08428: null,
08429: new CTypes.ExternS(),
08430: null,
08431: null,
08432: Boolean.TRUE,
08433: null,
08434: null,
08435: Boolean.TRUE,
08436: null,
08437: null),
08438: getNameSpace);
08439: }
08440:
08441: public CTypes.type apply() {
08442: return Analyzer
08443: .cast(new CTypes.type(
08444: new CTypes.IntT(),
08445: null,
08446: null,
08447: null,
08448: null,
08449: null,
08450: null,
08451: null,
08452: null,
08453: null,
08454: null));
08455: }
08456: }
08457: .apply()
08458: : new Let<CTypes.type>() {
08459: final CTypes.type ft;
08460: final CTypes.type ret;
08461: final Pair<CTypes.type> tl;
08462:
08463: {
08464: ft = Analyzer
08465: .cast(Analyzer
08466: .cast(lookup2
08467: .apply(
08468: id,
08469: getNameSpace)));
08470: ret = Analyzer
08471: .cast(get_return_type
08472: .apply(ft));
08473: tl = Analyzer
08474: .cast(getParameterTypes
08475: .apply(ft));
08476: Analyzer
08477: .discard(null == Primitives.not
08478: .apply(is_old_stype
08479: .apply(ft))
08480: || !Primitives.not
08481: .apply(is_old_stype
08482: .apply(ft)) ? null
08483: : processArguments
08484: .apply(
08485: tl,
08486: elt,
08487: is_var_args
08488: .apply(ft)));
08489: }
08490:
08491: public CTypes.type apply() {
08492: return Analyzer
08493: .cast(ret);
08494: }
08495: }
08496: .apply());
08497:
08498: checkExitScope(arg$881);
08499: matching_nodes
08500: .remove(matching_nodes
08501: .size() - 1);
08502: return Analyzer
08503: .cast(retValue$885);
08504: }
08505: if (true) {
08506: matching_nodes
08507: .add(arg$881);
08508: if ((null != arg$881 && processScopeNodes
08509: .contains(arg$881
08510: .getName()))) {
08511: processScope(
08512: arg$881,
08513: getScope);
08514: }
08515: checkEnterScope(arg$881);
08516:
08517: final Object retValue$888 = Analyzer
08518: .cast(new Let<CTypes.type>() {
08519: final CTypes.type t;
08520:
08521: {
08522: t = Analyzer
08523: .cast(resolve
08524: .apply(analyze_expression
08525: .apply(id)));
08526: }
08527:
08528: public CTypes.type apply() {
08529: return Analyzer
08530: .cast(null == Primitives.isBottom
08531: .apply(t) ? null
08532: : Primitives.isBottom
08533: .apply(t) ? null
08534: : new Let<CTypes.type>() {
08535: final CTypes.type ft;
08536:
08537: {
08538: ft = Analyzer
08539: .cast(null == Primitives.and
08540: .apply(
08541: is_pointer
08542: .apply(t),
08543: is_function
08544: .apply(get_base
08545: .apply(t))) ? null
08546: : Primitives.and
08547: .apply(
08548: is_pointer
08549: .apply(t),
08550: is_function
08551: .apply(get_base
08552: .apply(t))) ? get_base
08553: .apply(t)
08554: : null == is_function
08555: .apply(t) ? null
08556: : is_function
08557: .apply(t) ? t
08558: : error(
08559: "called is not a function",
08560: null));
08561: }
08562:
08563: public CTypes.type apply() {
08564: return Analyzer
08565: .cast(null == Primitives.isNotBottom
08566: .apply(ft)
08567: || !Primitives.isNotBottom
08568: .apply(ft) ? null
08569: : new Let<CTypes.type>() {
08570: final CTypes.type ret;
08571: final Pair<CTypes.type> tl;
08572:
08573: {
08574: ret = Analyzer
08575: .cast(get_return_type
08576: .apply(ft));
08577: tl = Analyzer
08578: .cast(getParameterTypes
08579: .apply(ft));
08580: processArguments
08581: .apply(
08582: tl,
08583: elt,
08584: Boolean.FALSE);
08585: }
08586:
08587: public CTypes.type apply() {
08588: return Analyzer
08589: .cast(ret);
08590: }
08591: }
08592: .apply());
08593: }
08594: }
08595: .apply());
08596: }
08597: }
08598: .apply());
08599:
08600: checkExitScope(arg$881);
08601: matching_nodes
08602: .remove(matching_nodes
08603: .size() - 1);
08604: return Analyzer
08605: .cast(retValue$888);
08606: }
08607: return null;
08608: }
08609: }.apply());
08610: }
08611: }.apply());
08612:
08613: checkExitScope(arg$596);
08614: matching_nodes
08615: .remove(matching_nodes.size() - 1);
08616: return Analyzer.cast(retValue$901);
08617: }
08618: if (CSupport.match$902(arg$596)) {
08619: final Node n1 = (arg$596.size() > 0 ? arg$596
08620: .getGeneric(0) : null);
08621: final String s = (arg$596.size() > 1 ? arg$596
08622: .getString(1) : null);
08623:
08624: matching_nodes.add(arg$596);
08625: if ((null != arg$596 && processScopeNodes
08626: .contains(arg$596.getName()))) {
08627: processScope(arg$596, getScope);
08628: }
08629: checkEnterScope(arg$596);
08630:
08631: final Object retValue$913 = Analyzer
08632: .cast(new Let<CTypes.type>() {
08633: final CTypes.type t;
08634:
08635: {
08636: t = Analyzer
08637: .cast(analyze_expression
08638: .apply(n1));
08639: }
08640:
08641: public CTypes.type apply() {
08642: return Analyzer
08643: .cast(new Match<CTypes.type>() {
08644: public CTypes.type apply() {
08645: final CTypes.raw_type<?> arg$907 = Analyzer
08646: .cast(null == t ? null
08647: : t.type);
08648:
08649: if ((null == arg$907)) {
08650: return null;
08651: }
08652: if ((null != arg$907))
08653: switch (arg$907
08654: .tag()) {
08655: case StructT:
08656: if (CSupport
08657: .match$298(arg$907)) {
08658: final String sn = Analyzer
08659: .cast(arg$907
08660: .getTuple()
08661: .get1());
08662:
08663: return Analyzer
08664: .cast(new Let<CTypes.type>() {
08665: final CTypes.type st;
08666:
08667: {
08668: st = Analyzer
08669: .cast(Analyzer
08670: .cast(lookup2
08671: .apply(
08672: GNode
08673: .create(
08674: "StructureTypeReference",
08675: null,
08676: sn),
08677: getNameSpace)));
08678: }
08679:
08680: public CTypes.type apply() {
08681: return Analyzer
08682: .cast(null == is_complete
08683: .apply(st) ? null
08684: : is_complete
08685: .apply(st) ? get_member_type
08686: .apply(
08687: st,
08688: s)
08689: : error(
08690: "request for member in incomplete type",
08691: null));
08692: }
08693: }
08694: .apply());
08695: }
08696: break;
08697: case UnionT:
08698: if (CSupport
08699: .match$905(arg$907)) {
08700: final String sn = Analyzer
08701: .cast(arg$907
08702: .getTuple()
08703: .get1());
08704:
08705: return Analyzer
08706: .cast(new Let<CTypes.type>() {
08707: final CTypes.type st;
08708:
08709: {
08710: st = Analyzer
08711: .cast(Analyzer
08712: .cast(lookup2
08713: .apply(
08714: GNode
08715: .create(
08716: "StructureTypeReference",
08717: null,
08718: sn),
08719: getNameSpace)));
08720: }
08721:
08722: public CTypes.type apply() {
08723: return Analyzer
08724: .cast(null == is_complete
08725: .apply(st) ? null
08726: : is_complete
08727: .apply(st) ? get_member_type
08728: .apply(
08729: st,
08730: s)
08731: : error(
08732: "request for member in incomplete type",
08733: null));
08734: }
08735: }
08736: .apply());
08737: }
08738: break;
08739: default:
08740: break;
08741: }
08742: ;
08743: if (true) {
08744: return Analyzer
08745: .cast(error(
08746: Primitives.concat
08747: .apply(
08748: Primitives.concat
08749: .apply(
08750: "request for member '",
08751: s),
08752: "' in something that is no struct or union 1"),
08753: null));
08754: }
08755: return null;
08756: }
08757: }.apply());
08758: }
08759: }.apply());
08760:
08761: checkExitScope(arg$596);
08762: matching_nodes
08763: .remove(matching_nodes.size() - 1);
08764: return Analyzer.cast(retValue$913);
08765: }
08766: if (CSupport.match$69(arg$596)) {
08767: final Node n1 = (arg$596.size() > 0 ? arg$596
08768: .getGeneric(0) : null);
08769: final String s = (arg$596.size() > 1 ? arg$596
08770: .getString(1) : null);
08771:
08772: matching_nodes.add(arg$596);
08773: if ((null != arg$596 && processScopeNodes
08774: .contains(arg$596.getName()))) {
08775: processScope(arg$596, getScope);
08776: }
08777: checkEnterScope(arg$596);
08778:
08779: final Object retValue$925 = Analyzer
08780: .cast(new Let<CTypes.type>() {
08781: final CTypes.type t;
08782:
08783: {
08784: t = Analyzer
08785: .cast(pointerize
08786: .apply(analyze_expression
08787: .apply(n1)));
08788: }
08789:
08790: public CTypes.type apply() {
08791: return Analyzer
08792: .cast(null == Primitives.isNotBottom
08793: .apply(t)
08794: || !Primitives.isNotBottom
08795: .apply(t) ? null
08796: : null == is_pointer
08797: .apply(t) ? null
08798: : is_pointer
08799: .apply(t) ? new Let<CTypes.type>() {
08800: final CTypes.type base;
08801:
08802: {
08803: base = Analyzer
08804: .cast(get_base
08805: .apply(t));
08806: }
08807:
08808: public CTypes.type apply() {
08809: return Analyzer
08810: .cast(new Match<CTypes.type>() {
08811: public CTypes.type apply() {
08812: final CTypes.raw_type<?> arg$919 = Analyzer
08813: .cast(null == base ? null
08814: : base.type);
08815:
08816: if ((null == arg$919)) {
08817: return null;
08818: }
08819: if ((null != arg$919))
08820: switch (arg$919
08821: .tag()) {
08822: case StructT:
08823: if (CSupport
08824: .match$298(arg$919)) {
08825: final String sn = Analyzer
08826: .cast(arg$919
08827: .getTuple()
08828: .get1());
08829:
08830: return Analyzer
08831: .cast(new Let<CTypes.type>() {
08832: final CTypes.type st;
08833:
08834: {
08835: st = Analyzer
08836: .cast(Analyzer
08837: .cast(lookup2
08838: .apply(
08839: GNode
08840: .create(
08841: "StructureTypeReference",
08842: null,
08843: sn),
08844: getNameSpace)));
08845: }
08846:
08847: public CTypes.type apply() {
08848: return Analyzer
08849: .cast(null == is_complete
08850: .apply(st) ? null
08851: : is_complete
08852: .apply(st) ? get_member_type
08853: .apply(
08854: st,
08855: s)
08856: : error(
08857: "dereferencing pointer to incomplete type 1",
08858: null));
08859: }
08860: }
08861: .apply());
08862: }
08863: break;
08864: case UnionT:
08865: if (CSupport
08866: .match$905(arg$919)) {
08867: final String sn = Analyzer
08868: .cast(arg$919
08869: .getTuple()
08870: .get1());
08871:
08872: return Analyzer
08873: .cast(new Let<CTypes.type>() {
08874: final CTypes.type st;
08875:
08876: {
08877: st = Analyzer
08878: .cast(Analyzer
08879: .cast(lookup2
08880: .apply(
08881: GNode
08882: .create(
08883: "StructureTypeReference",
08884: null,
08885: sn),
08886: getNameSpace)));
08887: }
08888:
08889: public CTypes.type apply() {
08890: return Analyzer
08891: .cast(null == is_complete
08892: .apply(st) ? null
08893: : is_complete
08894: .apply(st) ? get_member_type
08895: .apply(
08896: st,
08897: s)
08898: : error(
08899: "dereferencing pointer to incomplete type 1",
08900: null));
08901: }
08902: }
08903: .apply());
08904: }
08905: break;
08906: default:
08907: break;
08908: }
08909: ;
08910: if (true) {
08911: return Analyzer
08912: .cast(error(
08913: Primitives.concat
08914: .apply(
08915: Primitives.concat
08916: .apply(
08917: "request for member '",
08918: s),
08919: "' in something that is no struct or union 2"),
08920: null));
08921: }
08922: return null;
08923: }
08924: }
08925: .apply());
08926: }
08927: }
08928: .apply()
08929: : error(
08930: "pointer type is required",
08931: null));
08932: }
08933: }.apply());
08934:
08935: checkExitScope(arg$596);
08936: matching_nodes
08937: .remove(matching_nodes.size() - 1);
08938: return Analyzer.cast(retValue$925);
08939: }
08940: if (CSupport.match$926(arg$596)) {
08941: final Node n1 = (arg$596.size() > 0 ? arg$596
08942: .getGeneric(0) : null);
08943: final Node init = (arg$596.size() > 1 ? arg$596
08944: .getGeneric(1) : null);
08945:
08946: matching_nodes.add(arg$596);
08947: if ((null != arg$596 && processScopeNodes
08948: .contains(arg$596.getName()))) {
08949: processScope(arg$596, getScope);
08950: }
08951: checkEnterScope(arg$596);
08952:
08953: final Object retValue$929 = Analyzer
08954: .cast(new Let<CTypes.type>() {
08955: final CTypes.type t;
08956:
08957: {
08958: t = Analyzer
08959: .cast(analyze_type_name
08960: .apply(n1));
08961: analyze_initializer.apply(init,
08962: t);
08963: }
08964:
08965: public CTypes.type apply() {
08966: return Analyzer.cast(t);
08967: }
08968: }.apply());
08969:
08970: checkExitScope(arg$596);
08971: matching_nodes
08972: .remove(matching_nodes.size() - 1);
08973: return Analyzer.cast(retValue$929);
08974: }
08975: if (CSupport.match$930(arg$596)) {
08976: final Node n1 = (arg$596.size() > 0 ? arg$596
08977: .getGeneric(0) : null);
08978: final Node n2 = (arg$596.size() > 1 ? arg$596
08979: .getGeneric(1) : null);
08980:
08981: matching_nodes.add(arg$596);
08982: if ((null != arg$596 && processScopeNodes
08983: .contains(arg$596.getName()))) {
08984: processScope(arg$596, getScope);
08985: }
08986: checkEnterScope(arg$596);
08987:
08988: final Object retValue$935 = Analyzer
08989: .cast(new Require<CTypes.type>() {
08990: public CTypes.type apply() {
08991: final Boolean var$932 = Primitives.equal
08992: .apply(
08993: analyze_expression
08994: .apply(n1),
08995: new CTypes.type(
08996: new CTypes.VarArgT(),
08997: null,
08998: null,
08999: null,
09000: null,
09001: null,
09002: null,
09003: null,
09004: null,
09005: null,
09006: null));
09007:
09008: if ((null != var$932 && !var$932)) {
09009: showMessage(
09010: "error",
09011: "first argument to 'va_arg' not of type 'va_list'",
09012: null);
09013: }
09014: if ((null == var$932)) {
09015: return null;
09016: }
09017: if (var$932) {
09018: return analyze_type_name
09019: .apply(n2);
09020: }
09021: return null;
09022: }
09023: }.apply());
09024:
09025: checkExitScope(arg$596);
09026: matching_nodes
09027: .remove(matching_nodes.size() - 1);
09028: return Analyzer.cast(retValue$935);
09029: }
09030: if (CSupport.match$1(arg$596)) {
09031: final String s = (arg$596.size() > 0 ? arg$596
09032: .getString(0) : null);
09033:
09034: matching_nodes.add(arg$596);
09035: if ((null != arg$596 && processScopeNodes
09036: .contains(arg$596.getName()))) {
09037: processScope(arg$596, getScope);
09038: }
09039: checkEnterScope(arg$596);
09040:
09041: final Object retValue$939 = Analyzer
09042: .cast(Analyzer
09043: .cast(lookup4
09044: .apply(
09045: n,
09046: "error",
09047: Primitives.concat
09048: .apply(
09049: "undeclared identifier ",
09050: s),
09051: getNameSpace)));
09052:
09053: checkExitScope(arg$596);
09054: matching_nodes
09055: .remove(matching_nodes.size() - 1);
09056: return Analyzer.cast(retValue$939);
09057: }
09058: if (CSupport.match$940(arg$596)) {
09059: final String s = (arg$596.size() > 0 ? arg$596
09060: .getString(0) : null);
09061:
09062: matching_nodes.add(arg$596);
09063: if ((null != arg$596 && processScopeNodes
09064: .contains(arg$596.getName()))) {
09065: processScope(arg$596, getScope);
09066: }
09067: checkEnterScope(arg$596);
09068:
09069: final Object retValue$943 = Analyzer
09070: .cast(new CTypes.type(
09071: new CTypes.LongDoubleT(),
09072: new Pair<CTypes.qualifier>(
09073: new CTypes.ConstQ()),
09074: null, null, new CTypes.FValue(
09075: Primitives.stof
09076: .apply(s)),
09077: null, null, null, null, null,
09078: null));
09079:
09080: checkExitScope(arg$596);
09081: matching_nodes
09082: .remove(matching_nodes.size() - 1);
09083: return Analyzer.cast(retValue$943);
09084: }
09085: if (CSupport.match$944(arg$596)) {
09086: final Pair<String> sl = Analyzer
09087: .cast(Primitives.getChildren(arg$596,
09088: 0, arg$596.size()));
09089:
09090: matching_nodes.add(arg$596);
09091: if ((null != arg$596 && processScopeNodes
09092: .contains(arg$596.getName()))) {
09093: processScope(arg$596, getScope);
09094: }
09095: checkEnterScope(arg$596);
09096:
09097: final Object retValue$947 = Analyzer
09098: .cast(new Let<CTypes.type>() {
09099: final String s;
09100: final CTypes.raw_type<?> t;
09101:
09102: {
09103: s = Analyzer
09104: .cast(Primitives.joinStrings
09105: .apply(sl));
09106: t = Analyzer
09107: .cast(null == Primitives.startsWithi
09108: .apply(s, "l") ? null
09109: : Primitives.startsWithi
09110: .apply(
09111: s,
09112: "l") ? new CTypes.WideCharT()
09113: : new CTypes.CharT());
09114: }
09115:
09116: public CTypes.type apply() {
09117: return Analyzer
09118: .cast(new CTypes.type(
09119: new CTypes.ArrayT(
09120: new CTypes.type(
09121: t,
09122: new Pair<CTypes.qualifier>(
09123: new CTypes.ConstQ()),
09124: null,
09125: null,
09126: null,
09127: null,
09128: null,
09129: null,
09130: null,
09131: null,
09132: null),
09133: new CTypes.Fixed(
09134: Primitives.ssize
09135: .apply(s))),
09136: new Pair<CTypes.qualifier>(
09137: new CTypes.ConstQ()),
09138: null,
09139: null,
09140: new CTypes.SValue(
09141: s),
09142: null, null,
09143: null, null,
09144: null, null));
09145: }
09146: }.apply());
09147:
09148: checkExitScope(arg$596);
09149: matching_nodes
09150: .remove(matching_nodes.size() - 1);
09151: return Analyzer.cast(retValue$947);
09152: }
09153: if (CSupport.match$948(arg$596)) {
09154: matching_nodes.add(arg$596);
09155: if ((null != arg$596 && processScopeNodes
09156: .contains(arg$596.getName()))) {
09157: processScope(arg$596, getScope);
09158: }
09159: checkEnterScope(arg$596);
09160:
09161: final Object retValue$951 = Analyzer
09162: .cast(new CTypes.type(
09163: new CTypes.CharT(),
09164: new Pair<CTypes.qualifier>(
09165: new CTypes.ConstQ()),
09166: null, null, null, null, null,
09167: null, null, null, null));
09168:
09169: checkExitScope(arg$596);
09170: matching_nodes
09171: .remove(matching_nodes.size() - 1);
09172: return Analyzer.cast(retValue$951);
09173: }
09174: if (CSupport.match$952(arg$596)) {
09175: final String s = (arg$596.size() > 0 ? arg$596
09176: .getString(0) : null);
09177:
09178: matching_nodes.add(arg$596);
09179: if ((null != arg$596 && processScopeNodes
09180: .contains(arg$596.getName()))) {
09181: processScope(arg$596, getScope);
09182: }
09183: checkEnterScope(arg$596);
09184:
09185: final Object retValue$955 = Analyzer
09186: .cast(null == Primitives.endsWithi
09187: .apply(s, "ull") ? null
09188: : Primitives.endsWithi.apply(s,
09189: "ull") ? new CTypes.type(
09190: new CTypes.ULongLongT(),
09191: new Pair<CTypes.qualifier>(
09192: new CTypes.ConstQ()),
09193: null,
09194: null,
09195: new CTypes.IValue(
09196: parse_int
09197: .apply(Primitives.substring2
09198: .apply(
09199: s,
09200: BigInteger
09201: .valueOf(0),
09202: Primitives.subtractInt
09203: .apply(
09204: Primitives.ssize
09205: .apply(s),
09206: BigInteger
09207: .valueOf(3))))),
09208: null, null, null, null,
09209: null, null)
09210: : null == Primitives.endsWithi
09211: .apply(s, "ll") ? null
09212: : Primitives.endsWithi
09213: .apply(
09214: s,
09215: "ll") ? new CTypes.type(
09216: new CTypes.LongLongT(),
09217: new Pair<CTypes.qualifier>(
09218: new CTypes.ConstQ()),
09219: null,
09220: null,
09221: new CTypes.IValue(
09222: parse_int
09223: .apply(Primitives.substring2
09224: .apply(
09225: s,
09226: BigInteger
09227: .valueOf(0),
09228: Primitives.subtractInt
09229: .apply(
09230: Primitives.ssize
09231: .apply(s),
09232: BigInteger
09233: .valueOf(2))))),
09234: null,
09235: null,
09236: null,
09237: null,
09238: null,
09239: null)
09240: : null == Primitives.endsWithi
09241: .apply(
09242: s,
09243: "ul") ? null
09244: : Primitives.endsWithi
09245: .apply(
09246: s,
09247: "ul") ? new CTypes.type(
09248: new CTypes.ULongT(),
09249: new Pair<CTypes.qualifier>(
09250: new CTypes.ConstQ()),
09251: null,
09252: null,
09253: new CTypes.IValue(
09254: parse_int
09255: .apply(Primitives.substring2
09256: .apply(
09257: s,
09258: BigInteger
09259: .valueOf(0),
09260: Primitives.subtractInt
09261: .apply(
09262: Primitives.ssize
09263: .apply(s),
09264: BigInteger
09265: .valueOf(2))))),
09266: null,
09267: null,
09268: null,
09269: null,
09270: null,
09271: null)
09272: : null == Primitives.endsWithi
09273: .apply(
09274: s,
09275: "u") ? null
09276: : Primitives.endsWithi
09277: .apply(
09278: s,
09279: "u") ? new CTypes.type(
09280: new CTypes.UIntT(),
09281: new Pair<CTypes.qualifier>(
09282: new CTypes.ConstQ()),
09283: null,
09284: null,
09285: new CTypes.IValue(
09286: parse_int
09287: .apply(Primitives.substring2
09288: .apply(
09289: s,
09290: BigInteger
09291: .valueOf(0),
09292: Primitives.subtractInt
09293: .apply(
09294: Primitives.ssize
09295: .apply(s),
09296: BigInteger
09297: .valueOf(1))))),
09298: null,
09299: null,
09300: null,
09301: null,
09302: null,
09303: null)
09304: : null == Primitives.or
09305: .apply(
09306: Primitives.endsWithi
09307: .apply(
09308: s,
09309: "l"),
09310: Primitives.endsWith
09311: .apply(
09312: s,
09313: "L")) ? null
09314: : Primitives.or
09315: .apply(
09316: Primitives.endsWithi
09317: .apply(
09318: s,
09319: "l"),
09320: Primitives.endsWith
09321: .apply(
09322: s,
09323: "L")) ? new CTypes.type(
09324: new CTypes.LongT(),
09325: new Pair<CTypes.qualifier>(
09326: new CTypes.ConstQ()),
09327: null,
09328: null,
09329: new CTypes.IValue(
09330: parse_int
09331: .apply(Primitives.substring2
09332: .apply(
09333: s,
09334: BigInteger
09335: .valueOf(0),
09336: Primitives.subtractInt
09337: .apply(
09338: Primitives.ssize
09339: .apply(s),
09340: BigInteger
09341: .valueOf(1))))),
09342: null,
09343: null,
09344: null,
09345: null,
09346: null,
09347: null)
09348: : new CTypes.type(
09349: new CTypes.LongT(),
09350: new Pair<CTypes.qualifier>(
09351: new CTypes.ConstQ()),
09352: null,
09353: null,
09354: new CTypes.IValue(
09355: parse_int
09356: .apply(s)),
09357: null,
09358: null,
09359: null,
09360: null,
09361: null,
09362: null));
09363:
09364: checkExitScope(arg$596);
09365: matching_nodes
09366: .remove(matching_nodes.size() - 1);
09367: return Analyzer.cast(retValue$955);
09368: }
09369: if (true) {
09370: matching_nodes.add(arg$596);
09371: if ((null != arg$596 && processScopeNodes
09372: .contains(arg$596.getName()))) {
09373: processScope(arg$596, getScope);
09374: }
09375: checkEnterScope(arg$596);
09376:
09377: final Object retValue$958 = Analyzer.cast(null);
09378:
09379: checkExitScope(arg$596);
09380: matching_nodes
09381: .remove(matching_nodes.size() - 1);
09382: return Analyzer.cast(retValue$958);
09383: }
09384: return null;
09385: }
09386: }.apply();
09387: }
09388: };
09389:
09390: final Function.F1<CTypes.type, Node> analyze_struct_decl_list = new Function.F1<CTypes.type, Node>() {
09391: public CTypes.type apply(final Node n) {
09392: return new Match<CTypes.type>() {
09393: public CTypes.type apply() {
09394: final Node arg$960 = GNode.cast(n);
09395:
09396: if ((null == arg$960)) {
09397: return null;
09398: }
09399: if (CSupport.match$961(arg$960)) {
09400: final Pair<Node> sdl = Analyzer
09401: .cast(Primitives.getChildren(arg$960,
09402: 0, arg$960.size()));
09403:
09404: matching_nodes.add(arg$960);
09405: if ((null != arg$960 && processScopeNodes
09406: .contains(arg$960.getName()))) {
09407: processScope(arg$960, getScope);
09408: }
09409: checkEnterScope(arg$960);
09410:
09411: final Object retValue$964 = Analyzer
09412: .cast(new Let<CTypes.type>() {
09413: final Pair<CTypes.type> tl;
09414: final Pair<CTypes.type> ret;
09415:
09416: {
09417: tl = Analyzer
09418: .cast(CSupport.map$212
09419: .apply(
09420: analyze_struct_declaration,
09421: removeLast
09422: .apply(sdl)));
09423: ret = Analyzer
09424: .cast(flattenListTypes
09425: .apply(tl));
09426: }
09427:
09428: public CTypes.type apply() {
09429: return Analyzer
09430: .cast(new CTypes.type(
09431: new CTypes.ListT(
09432: ret),
09433: null, null,
09434: null, null,
09435: null, null,
09436: null, null,
09437: null, null));
09438: }
09439: }.apply());
09440:
09441: checkExitScope(arg$960);
09442: matching_nodes
09443: .remove(matching_nodes.size() - 1);
09444: return Analyzer.cast(retValue$964);
09445: }
09446: if (true) {
09447: matching_nodes.add(arg$960);
09448: if ((null != arg$960 && processScopeNodes
09449: .contains(arg$960.getName()))) {
09450: processScope(arg$960, getScope);
09451: }
09452: checkEnterScope(arg$960);
09453:
09454: final Object retValue$967 = Analyzer.cast(null);
09455:
09456: checkExitScope(arg$960);
09457: matching_nodes
09458: .remove(matching_nodes.size() - 1);
09459: return Analyzer.cast(retValue$967);
09460: }
09461: return null;
09462: }
09463: }.apply();
09464: }
09465: };
09466:
09467: protected class removeLast {
09468: public <T0> Pair<T0> apply(final Pair<T0> nl) {
09469: return new Match<Pair<T0>>() {
09470: public Pair<T0> apply() {
09471: final Pair<Object> arg$969 = Analyzer.cast(nl);
09472:
09473: if ((null == arg$969)) {
09474: return null;
09475: }
09476: if (CSupport.match$970(arg$969)) {
09477: return Analyzer.cast(Pair.empty());
09478: }
09479: if (CSupport.match$971(arg$969)) {
09480: return Analyzer.cast(Pair.empty());
09481: }
09482: if (true) {
09483: final Pair<Object> list$972 = Analyzer
09484: .cast(Analyzer.cast(arg$969));
09485: final Object x = Analyzer.cast(Primitives
09486: .wrapHead(list$972));
09487: final Pair<Object> xs = Analyzer
09488: .cast(Primitives.wrapTail(list$972));
09489:
09490: return Analyzer.cast(CSupport.append$973.apply(
09491: new Pair<Object>(x), removeLast
09492: .apply(xs)));
09493: }
09494: return null;
09495: }
09496: }.apply();
09497: }
09498: }
09499:
09500: final removeLast removeLast = new removeLast();
09501:
09502: final Function.F1<CTypes.type, Node> analyze_type_name = new Function.F1<CTypes.type, Node>() {
09503: public CTypes.type apply(final Node n) {
09504: return new Match<CTypes.type>() {
09505: public CTypes.type apply() {
09506: final Node arg$975 = GNode.cast(n);
09507:
09508: if ((null == arg$975)) {
09509: return null;
09510: }
09511: if (CSupport.match$976(arg$975)) {
09512: final Node sql = (arg$975.size() > 0 ? arg$975
09513: .getGeneric(0) : null);
09514: final Node ab = (arg$975.size() > 1 ? arg$975
09515: .getGeneric(1) : null);
09516:
09517: matching_nodes.add(arg$975);
09518: if ((null != arg$975 && processScopeNodes
09519: .contains(arg$975.getName()))) {
09520: processScope(arg$975, getScope);
09521: }
09522: checkEnterScope(arg$975);
09523:
09524: final Object retValue$979 = Analyzer
09525: .cast(new Let<CTypes.type>() {
09526: final CTypes.type t;
09527:
09528: {
09529: t = Analyzer
09530: .cast(analyze_spec_qual_list
09531: .apply(sql));
09532: }
09533:
09534: public CTypes.type apply() {
09535: return Analyzer
09536: .cast(null == Primitives.isNotBottom
09537: .apply(t)
09538: || !Primitives.isNotBottom
09539: .apply(t) ? null
09540: : null == Primitives.isBottom
09541: .apply(ab) ? null
09542: : Primitives.isBottom
09543: .apply(ab) ? t
09544: : analyze_abs_declarator
09545: .apply(
09546: t,
09547: ab));
09548: }
09549: }.apply());
09550:
09551: checkExitScope(arg$975);
09552: matching_nodes
09553: .remove(matching_nodes.size() - 1);
09554: return Analyzer.cast(retValue$979);
09555: }
09556: if (true) {
09557: matching_nodes.add(arg$975);
09558: if ((null != arg$975 && processScopeNodes
09559: .contains(arg$975.getName()))) {
09560: processScope(arg$975, getScope);
09561: }
09562: checkEnterScope(arg$975);
09563:
09564: final Object retValue$982 = Analyzer.cast(null);
09565:
09566: checkExitScope(arg$975);
09567: matching_nodes
09568: .remove(matching_nodes.size() - 1);
09569: return Analyzer.cast(retValue$982);
09570: }
09571: return null;
09572: }
09573: }.apply();
09574: }
09575: };
09576:
09577: final Function.F2<CTypes.type, CTypes.type, Node> analyze_pointer = new Function.F2<CTypes.type, CTypes.type, Node>() {
09578: public CTypes.type apply(final CTypes.type t, final Node n) {
09579: return new Match<CTypes.type>() {
09580: public CTypes.type apply() {
09581: final Node arg$984 = GNode.cast(n);
09582:
09583: if ((null == arg$984)) {
09584: return null;
09585: }
09586: if (CSupport.match$985(arg$984)) {
09587: final Pair<Node> tl = Analyzer.cast(Primitives
09588: .getChildren(arg$984.getGeneric(0), 0,
09589: arg$984.getGeneric(0).size()));
09590:
09591: matching_nodes.add(arg$984);
09592: if ((null != arg$984 && processScopeNodes
09593: .contains(arg$984.getName()))) {
09594: processScope(arg$984, getScope);
09595: }
09596: checkEnterScope(arg$984);
09597:
09598: List<Node> listName$987 = new ArrayList<Node>();
09599: Node nodeName$986 = arg$984;
09600:
09601: nodeName$986 = nodeName$986.getGeneric(0);
09602: if ((null != nodeName$986 && processScopeNodes
09603: .contains(nodeName$986.getName()))) {
09604: processScope(nodeName$986, getScope);
09605: }
09606: checkEnterScope(nodeName$986);
09607: listName$987.add(0, nodeName$986);
09608:
09609: final Object retValue$988 = Analyzer
09610: .cast(new Let<CTypes.type>() {
09611: final Pair<CTypes.qualifier> q;
09612: final CTypes.type tt;
09613:
09614: {
09615: q = Analyzer
09616: .cast(extractQualifier
09617: .apply(tl));
09618: tt = Analyzer
09619: .cast(new CTypes.type(
09620: null == t ? null
09621: : t.type,
09622: q,
09623: null == t ? null
09624: : t.storage,
09625: null == t ? null
09626: : t.fSpec,
09627: null == t ? null
09628: : t.value,
09629: null == t ? null
09630: : t.implicit,
09631: null == t ? null
09632: : t.initialised,
09633: null == t ? null
09634: : t.position,
09635: null == t ? null
09636: : t.old_style,
09637: null == t ? null
09638: : t.var_args,
09639: null == t ? null
09640: : t.in_top));
09641: }
09642:
09643: public CTypes.type apply() {
09644: return Analyzer
09645: .cast(new CTypes.type(
09646: new CTypes.PointerType(
09647: tt),
09648: null,
09649: null == t ? null
09650: : t.storage,
09651: null, null,
09652: null, null,
09653: null, null,
09654: null, null));
09655: }
09656: }.apply());
09657:
09658: for (Node no : listName$987) {
09659: checkExitScope(no);
09660: }
09661: checkExitScope(arg$984);
09662: matching_nodes
09663: .remove(matching_nodes.size() - 1);
09664: return Analyzer.cast(retValue$988);
09665: }
09666: if (CSupport.match$989(arg$984)) {
09667: final Node tq = Analyzer.cast(arg$984
09668: .getGeneric(0));
09669: final Node pointer = (arg$984.size() > 1 ? arg$984
09670: .getGeneric(1)
09671: : null);
09672:
09673: matching_nodes.add(arg$984);
09674: if ((null != arg$984 && processScopeNodes
09675: .contains(arg$984.getName()))) {
09676: processScope(arg$984, getScope);
09677: }
09678: checkEnterScope(arg$984);
09679:
09680: final Object retValue$1010 = Analyzer
09681: .cast(new Let<CTypes.type>() {
09682: final Pair<Node> tl;
09683: final Pair<CTypes.qualifier> q;
09684: final CTypes.type rt;
09685: final CTypes.type tt;
09686:
09687: {
09688: tl = Analyzer
09689: .cast(new Match<Pair<Node>>() {
09690: public Pair<Node> apply() {
09691: final Node arg$999 = GNode
09692: .cast(tq);
09693:
09694: if ((null == arg$999)) {
09695: return null;
09696: }
09697: if (CSupport
09698: .match$991(arg$999)) {
09699: final Pair<Node> l = Analyzer
09700: .cast(Primitives
09701: .getChildren(
09702: arg$999,
09703: 0,
09704: arg$999
09705: .size()));
09706:
09707: matching_nodes
09708: .add(arg$999);
09709: if ((null != arg$999 && processScopeNodes
09710: .contains(arg$999
09711: .getName()))) {
09712: processScope(
09713: arg$999,
09714: getScope);
09715: }
09716: checkEnterScope(arg$999);
09717:
09718: final Object retValue$1003 = Analyzer
09719: .cast(l);
09720:
09721: checkExitScope(arg$999);
09722: matching_nodes
09723: .remove(matching_nodes
09724: .size() - 1);
09725: return Analyzer
09726: .cast(retValue$1003);
09727: }
09728: if (true) {
09729: matching_nodes
09730: .add(arg$999);
09731: if ((null != arg$999 && processScopeNodes
09732: .contains(arg$999
09733: .getName()))) {
09734: processScope(
09735: arg$999,
09736: getScope);
09737: }
09738: checkEnterScope(arg$999);
09739:
09740: final Object retValue$1006 = Analyzer
09741: .cast(null);
09742:
09743: checkExitScope(arg$999);
09744: matching_nodes
09745: .remove(matching_nodes
09746: .size() - 1);
09747: return Analyzer
09748: .cast(retValue$1006);
09749: }
09750: return null;
09751: }
09752: }.apply());
09753: q = Analyzer
09754: .cast(extractQualifier
09755: .apply(tl));
09756: rt = Analyzer
09757: .cast(analyze_pointer
09758: .apply(t,
09759: pointer));
09760: tt = Analyzer
09761: .cast(new CTypes.type(
09762: null == rt ? null
09763: : rt.type,
09764: q,
09765: null == rt ? null
09766: : rt.storage,
09767: null == rt ? null
09768: : rt.fSpec,
09769: null == rt ? null
09770: : rt.value,
09771: null == rt ? null
09772: : rt.implicit,
09773: null == rt ? null
09774: : rt.initialised,
09775: null == rt ? null
09776: : rt.position,
09777: null == rt ? null
09778: : rt.old_style,
09779: null == rt ? null
09780: : rt.var_args,
09781: null == rt ? null
09782: : rt.in_top));
09783: }
09784:
09785: public CTypes.type apply() {
09786: return Analyzer
09787: .cast(new CTypes.type(
09788: new CTypes.PointerType(
09789: tt),
09790: null,
09791: null == t ? null
09792: : t.storage,
09793: null, null,
09794: null, null,
09795: null, null,
09796: null, null));
09797: }
09798: }.apply());
09799:
09800: checkExitScope(arg$984);
09801: matching_nodes
09802: .remove(matching_nodes.size() - 1);
09803: return Analyzer.cast(retValue$1010);
09804: }
09805: if (true) {
09806: matching_nodes.add(arg$984);
09807: if ((null != arg$984 && processScopeNodes
09808: .contains(arg$984.getName()))) {
09809: processScope(arg$984, getScope);
09810: }
09811: checkEnterScope(arg$984);
09812:
09813: final Object retValue$1013 = Analyzer
09814: .cast(null);
09815:
09816: checkExitScope(arg$984);
09817: matching_nodes
09818: .remove(matching_nodes.size() - 1);
09819: return Analyzer.cast(retValue$1013);
09820: }
09821: return null;
09822: }
09823: }.apply();
09824: }
09825: };
09826:
09827: final Function.F1<CTypes.type, Node> analyze_para_type_list = new Function.F1<CTypes.type, Node>() {
09828: public CTypes.type apply(final Node n) {
09829: return new Match<CTypes.type>() {
09830: public CTypes.type apply() {
09831: final Node arg$1015 = GNode.cast(n);
09832:
09833: if ((null == arg$1015)) {
09834: return null;
09835: }
09836: if (CSupport.match$1016(arg$1015)) {
09837: final Node p = Analyzer.cast(arg$1015
09838: .getGeneric(0));
09839: final String s = (arg$1015.size() > 1 ? arg$1015
09840: .getString(1)
09841: : null);
09842:
09843: matching_nodes.add(arg$1015);
09844: if ((null != arg$1015 && processScopeNodes
09845: .contains(arg$1015.getName()))) {
09846: processScope(arg$1015, getScope);
09847: }
09848: checkEnterScope(arg$1015);
09849:
09850: final Object retValue$1038 = Analyzer
09851: .cast(new Let<CTypes.type>() {
09852: final Pair<Node> pl;
09853: final Pair<CTypes.type> tl;
09854:
09855: {
09856: pl = Analyzer
09857: .cast(new Match<Pair<Node>>() {
09858: public Pair<Node> apply() {
09859: final Node arg$1027 = GNode
09860: .cast(p);
09861:
09862: if ((null == arg$1027)) {
09863: return null;
09864: }
09865: if (CSupport
09866: .match$1019(arg$1027)) {
09867: final Pair<Node> nl = Analyzer
09868: .cast(Primitives
09869: .getChildren(
09870: arg$1027,
09871: 0,
09872: arg$1027
09873: .size()));
09874:
09875: matching_nodes
09876: .add(arg$1027);
09877: if ((null != arg$1027 && processScopeNodes
09878: .contains(arg$1027
09879: .getName()))) {
09880: processScope(
09881: arg$1027,
09882: getScope);
09883: }
09884: checkEnterScope(arg$1027);
09885:
09886: final Object retValue$1031 = Analyzer
09887: .cast(nl);
09888:
09889: checkExitScope(arg$1027);
09890: matching_nodes
09891: .remove(matching_nodes
09892: .size() - 1);
09893: return Analyzer
09894: .cast(retValue$1031);
09895: }
09896: if (true) {
09897: matching_nodes
09898: .add(arg$1027);
09899: if ((null != arg$1027 && processScopeNodes
09900: .contains(arg$1027
09901: .getName()))) {
09902: processScope(
09903: arg$1027,
09904: getScope);
09905: }
09906: checkEnterScope(arg$1027);
09907:
09908: final Object retValue$1034 = Analyzer
09909: .cast(null);
09910:
09911: checkExitScope(arg$1027);
09912: matching_nodes
09913: .remove(matching_nodes
09914: .size() - 1);
09915: return Analyzer
09916: .cast(retValue$1034);
09917: }
09918: return null;
09919: }
09920: }.apply());
09921: tl = Analyzer
09922: .cast(CSupport.map$212
09923: .apply(
09924: analyze_parameter_declaration,
09925: pl));
09926: }
09927:
09928: public CTypes.type apply() {
09929: return Analyzer
09930: .cast(null == Primitives.not
09931: .apply(CSupport.exists$1017
09932: .apply(
09933: Primitives.isBottom,
09934: tl))
09935: || !Primitives.not
09936: .apply(CSupport.exists$1017
09937: .apply(
09938: Primitives.isBottom,
09939: tl)) ? null
09940: : new CTypes.type(
09941: new CTypes.ListT(
09942: tl),
09943: null,
09944: null,
09945: null,
09946: null,
09947: null,
09948: null,
09949: null,
09950: null,
09951: Primitives.isNotBottom
09952: .apply(s),
09953: null));
09954: }
09955: }.apply());
09956:
09957: checkExitScope(arg$1015);
09958: matching_nodes
09959: .remove(matching_nodes.size() - 1);
09960: return Analyzer.cast(retValue$1038);
09961: }
09962: if (true) {
09963: matching_nodes.add(arg$1015);
09964: if ((null != arg$1015 && processScopeNodes
09965: .contains(arg$1015.getName()))) {
09966: processScope(arg$1015, getScope);
09967: }
09968: checkEnterScope(arg$1015);
09969:
09970: final Object retValue$1041 = Analyzer
09971: .cast(null);
09972:
09973: checkExitScope(arg$1015);
09974: matching_nodes
09975: .remove(matching_nodes.size() - 1);
09976: return Analyzer.cast(retValue$1041);
09977: }
09978: return null;
09979: }
09980: }.apply();
09981: }
09982: };
09983:
09984: final Function.F1<CTypes.type, Node> analyze_generic = new Function.F1<CTypes.type, Node>() {
09985: public CTypes.type apply(final Node n) {
09986: return (null == is_extern_declaration.apply(n) ? null
09987: : is_extern_declaration.apply(n) ? analyze_extern_decl
09988: .apply(n)
09989: : analyze_statement.apply(Boolean.FALSE,
09990: Pair.<CTypes.label_record> empty(),
09991: Boolean.FALSE, n));
09992: }
09993: };
09994:
09995: final Function.F1<CTypes.type, Node> analyze_init_clause = new Function.F1<CTypes.type, Node>() {
09996: public CTypes.type apply(final Node n) {
09997: return (null == Primitives.isBottom.apply(n) ? null
09998: : Primitives.isBottom.apply(n) ? voidt
09999: : null == is_extern_declaration.apply(n) ? null
10000: : is_extern_declaration.apply(n) ? analyze_extern_decl
10001: .apply(n)
10002: : analyze_expression
10003: .apply(n));
10004: }
10005: };
10006:
10007: final Function.F1<CTypes.type, Node> analyze_label = new Function.F1<CTypes.type, Node>() {
10008: public CTypes.type apply(final Node n) {
10009: return new Match<CTypes.type>() {
10010: public CTypes.type apply() {
10011: final Node arg$1043 = GNode.cast(n);
10012:
10013: if ((null == arg$1043)) {
10014: return null;
10015: }
10016: if (CSupport.match$1044(arg$1043)) {
10017: final Node n1 = (arg$1043.size() > 0 ? arg$1043
10018: .getGeneric(0) : null);
10019: final Node n2 = (arg$1043.size() > 1 ? arg$1043
10020: .getGeneric(1) : null);
10021:
10022: matching_nodes.add(arg$1043);
10023: if ((null != arg$1043 && processScopeNodes
10024: .contains(arg$1043.getName()))) {
10025: processScope(arg$1043, getScope);
10026: }
10027: checkEnterScope(arg$1043);
10028:
10029: final Object retValue$1047 = Analyzer
10030: .cast(new Let<CTypes.type>() {
10031: {
10032: ensure_in_switch.apply(n1);
10033: ensure_integer.apply(
10034: analyze_expression
10035: .apply(n1),
10036: "case label");
10037: analyze_expression.apply(n2);
10038: }
10039:
10040: public CTypes.type apply() {
10041: return Analyzer.cast(voidt);
10042: }
10043: }.apply());
10044:
10045: checkExitScope(arg$1043);
10046: matching_nodes
10047: .remove(matching_nodes.size() - 1);
10048: return Analyzer.cast(retValue$1047);
10049: }
10050: if (CSupport.match$41(arg$1043)) {
10051: matching_nodes.add(arg$1043);
10052: if ((null != arg$1043 && processScopeNodes
10053: .contains(arg$1043.getName()))) {
10054: processScope(arg$1043, getScope);
10055: }
10056: checkEnterScope(arg$1043);
10057:
10058: final Object retValue$1051 = Analyzer
10059: .cast(new Let<CTypes.type>() {
10060: {
10061: ensure_in_switch.apply(n);
10062: redefine
10063: .apply(
10064: n,
10065: new CTypes.type(
10066: new CTypes.LabelT(
10067: "default"),
10068: null,
10069: null,
10070: null,
10071: null,
10072: null,
10073: null,
10074: null,
10075: null,
10076: null,
10077: null),
10078: getNameSpace);
10079: }
10080:
10081: public CTypes.type apply() {
10082: return Analyzer.cast(voidt);
10083: }
10084: }.apply());
10085:
10086: checkExitScope(arg$1043);
10087: matching_nodes
10088: .remove(matching_nodes.size() - 1);
10089: return Analyzer.cast(retValue$1051);
10090: }
10091: if (CSupport.match$33(arg$1043)) {
10092: final String str = (arg$1043.size() > 0 ? arg$1043
10093: .getString(0)
10094: : null);
10095:
10096: matching_nodes.add(arg$1043);
10097: if ((null != arg$1043 && processScopeNodes
10098: .contains(arg$1043.getName()))) {
10099: processScope(arg$1043, getScope);
10100: }
10101: checkEnterScope(arg$1043);
10102:
10103: final Object retValue$1055 = Analyzer
10104: .cast(new Let<CTypes.type>() {
10105: {
10106: redefine
10107: .apply(
10108: n,
10109: new CTypes.type(
10110: new CTypes.LabelT(
10111: str),
10112: null,
10113: null,
10114: null,
10115: null,
10116: null,
10117: Boolean.TRUE,
10118: null,
10119: null,
10120: null,
10121: null),
10122: getNameSpace);
10123: }
10124:
10125: public CTypes.type apply() {
10126: return Analyzer.cast(voidt);
10127: }
10128: }.apply());
10129:
10130: checkExitScope(arg$1043);
10131: matching_nodes
10132: .remove(matching_nodes.size() - 1);
10133: return Analyzer.cast(retValue$1055);
10134: }
10135: return null;
10136: }
10137: }.apply();
10138: }
10139: };
10140:
10141: final Function.F1<CTypes.type, Node> analyze_struct_declaration = new Function.F1<CTypes.type, Node>() {
10142: public CTypes.type apply(final Node n) {
10143: return new Match<CTypes.type>() {
10144: public CTypes.type apply() {
10145: final Node arg$1057 = GNode.cast(n);
10146:
10147: if ((null == arg$1057)) {
10148: return null;
10149: }
10150: if (CSupport.match$1058(arg$1057)) {
10151: final Node sql = (arg$1057.size() > 1 ? arg$1057
10152: .getGeneric(1)
10153: : null);
10154: final Node sdl = (arg$1057.size() > 2 ? arg$1057
10155: .getGeneric(2)
10156: : null);
10157:
10158: matching_nodes.add(arg$1057);
10159: if ((null != arg$1057 && processScopeNodes
10160: .contains(arg$1057.getName()))) {
10161: processScope(arg$1057, getScope);
10162: }
10163: checkEnterScope(arg$1057);
10164:
10165: final Object retValue$1067 = Analyzer
10166: .cast(new Let<CTypes.type>() {
10167: final CTypes.type t;
10168:
10169: {
10170: t = Analyzer
10171: .cast(analyze_spec_qual_list
10172: .apply(sql));
10173: }
10174:
10175: public CTypes.type apply() {
10176: return Analyzer
10177: .cast(null == Primitives.isBottom
10178: .apply(sdl) ? null
10179: : Primitives.isBottom
10180: .apply(sdl) ? new Match<CTypes.type>() {
10181: public CTypes.type apply() {
10182: final CTypes.raw_type<?> arg$1062 = Analyzer
10183: .cast(null == t ? null
10184: : t.type);
10185:
10186: if ((null == arg$1062)) {
10187: return null;
10188: }
10189: if ((null != arg$1062))
10190: switch (arg$1062
10191: .tag()) {
10192: case UnionT:
10193: if (CSupport
10194: .match$905(arg$1062)) {
10195: final Pair<CTypes.type> tl = Analyzer
10196: .cast(arg$1062
10197: .getTuple()
10198: .get3());
10199:
10200: return Analyzer
10201: .cast(new CTypes.type(
10202: new CTypes.ListT(
10203: tl),
10204: null,
10205: null,
10206: null,
10207: null,
10208: null,
10209: null,
10210: null,
10211: null,
10212: null,
10213: null));
10214: }
10215: break;
10216: default:
10217: break;
10218: }
10219: ;
10220: if (true) {
10221: return Analyzer
10222: .cast(new Let<CTypes.type>() {
10223: final String name;
10224:
10225: {
10226: name = Analyzer
10227: .cast(freshName
10228: .apply("member"));
10229: }
10230:
10231: public CTypes.type apply() {
10232: return Analyzer
10233: .cast(new CTypes.type(
10234: new CTypes.ListT(
10235: new Pair<CTypes.type>(
10236: new CTypes.type(
10237: new CTypes.MemberT(
10238: name,
10239: t),
10240: null,
10241: null,
10242: null,
10243: null,
10244: null,
10245: null,
10246: null,
10247: null,
10248: null,
10249: null))),
10250: null,
10251: null,
10252: null,
10253: null,
10254: null,
10255: null,
10256: null,
10257: null,
10258: null,
10259: null));
10260: }
10261: }
10262: .apply());
10263: }
10264: return null;
10265: }
10266: }.apply()
10267: : analyze_struct_declarator_list
10268: .apply(
10269: t,
10270: sdl));
10271: }
10272: }.apply());
10273:
10274: checkExitScope(arg$1057);
10275: matching_nodes
10276: .remove(matching_nodes.size() - 1);
10277: return Analyzer.cast(retValue$1067);
10278: }
10279: if (true) {
10280: matching_nodes.add(arg$1057);
10281: if ((null != arg$1057 && processScopeNodes
10282: .contains(arg$1057.getName()))) {
10283: processScope(arg$1057, getScope);
10284: }
10285: checkEnterScope(arg$1057);
10286:
10287: final Object retValue$1070 = Analyzer
10288: .cast(null);
10289:
10290: checkExitScope(arg$1057);
10291: matching_nodes
10292: .remove(matching_nodes.size() - 1);
10293: return Analyzer.cast(retValue$1070);
10294: }
10295: return null;
10296: }
10297: }.apply();
10298: }
10299: };
10300:
10301: final Function.F2<CTypes.type, CTypes.type, Node> analyze_struct_declarator_list = new Function.F2<CTypes.type, CTypes.type, Node>() {
10302: public CTypes.type apply(final CTypes.type t, final Node n) {
10303: return new Match<CTypes.type>() {
10304: public CTypes.type apply() {
10305: final Node arg$1072 = GNode.cast(n);
10306:
10307: if ((null == arg$1072)) {
10308: return null;
10309: }
10310: if (CSupport.match$1073(arg$1072)) {
10311: final Pair<Node> sdl = Analyzer.cast(Primitives
10312: .getChildren(arg$1072, 0, arg$1072
10313: .size()));
10314:
10315: matching_nodes.add(arg$1072);
10316: if ((null != arg$1072 && processScopeNodes
10317: .contains(arg$1072.getName()))) {
10318: processScope(arg$1072, getScope);
10319: }
10320: checkEnterScope(arg$1072);
10321:
10322: final Object retValue$1076 = Analyzer
10323: .cast(new CTypes.type(new CTypes.ListT(
10324: analyze_declarator_list.apply(
10325: t, sdl)), null, null,
10326: null, null, null, null, null,
10327: null, null, null));
10328:
10329: checkExitScope(arg$1072);
10330: matching_nodes
10331: .remove(matching_nodes.size() - 1);
10332: return Analyzer.cast(retValue$1076);
10333: }
10334: if (true) {
10335: matching_nodes.add(arg$1072);
10336: if ((null != arg$1072 && processScopeNodes
10337: .contains(arg$1072.getName()))) {
10338: processScope(arg$1072, getScope);
10339: }
10340: checkEnterScope(arg$1072);
10341:
10342: final Object retValue$1079 = Analyzer
10343: .cast(null);
10344:
10345: checkExitScope(arg$1072);
10346: matching_nodes
10347: .remove(matching_nodes.size() - 1);
10348: return Analyzer.cast(retValue$1079);
10349: }
10350: return null;
10351: }
10352: }.apply();
10353: }
10354: };
10355:
10356: final Function.F2<Pair<CTypes.type>, CTypes.type, Pair<Node>> analyze_declarator_list = new Function.F2<Pair<CTypes.type>, CTypes.type, Pair<Node>>() {
10357: public Pair<CTypes.type> apply(final CTypes.type t,
10358: final Pair<Node> dl) {
10359: return new Match<Pair<CTypes.type>>() {
10360: public Pair<CTypes.type> apply() {
10361: final Pair<Node> arg$1081 = Analyzer.cast(dl);
10362:
10363: if ((null == arg$1081)) {
10364: return null;
10365: }
10366: if (CSupport.match$383(arg$1081)) {
10367: return Analyzer
10368: .cast(Pair.<CTypes.type> empty());
10369: }
10370: if (true) {
10371: final Pair<Node> list$1083 = Analyzer
10372: .cast(Analyzer.cast(arg$1081));
10373: final Node x = GNode.cast(Primitives
10374: .wrapHead(list$1083));
10375: final Pair<Node> xs = Analyzer.cast(Primitives
10376: .wrapTail(list$1083));
10377:
10378: return Analyzer.cast(Primitives.wrapCons(
10379: analyze_declarator.apply(t, x),
10380: analyze_declarator_list.apply(t, xs)));
10381: }
10382: return null;
10383: }
10384: }.apply();
10385: }
10386: };
10387:
10388: final Function.F1<CTypes.type, Node> analyze_spec_qual_list = new Function.F1<CTypes.type, Node>() {
10389: public CTypes.type apply(final Node n) {
10390: return new Match<CTypes.type>() {
10391: public CTypes.type apply() {
10392: final Node arg$1085 = GNode.cast(n);
10393:
10394: if ((null == arg$1085)) {
10395: return null;
10396: }
10397: if (CSupport.match$1086(arg$1085)) {
10398: final Pair<Node> specs = Analyzer
10399: .cast(Primitives.getChildren(arg$1085,
10400: 0, arg$1085.size()));
10401:
10402: matching_nodes.add(arg$1085);
10403: if ((null != arg$1085 && processScopeNodes
10404: .contains(arg$1085.getName()))) {
10405: processScope(arg$1085, getScope);
10406: }
10407: checkEnterScope(arg$1085);
10408:
10409: final Object retValue$1089 = Analyzer
10410: .cast(process_specifiers.apply(specs));
10411:
10412: checkExitScope(arg$1085);
10413: matching_nodes
10414: .remove(matching_nodes.size() - 1);
10415: return Analyzer.cast(retValue$1089);
10416: }
10417: if (true) {
10418: matching_nodes.add(arg$1085);
10419: if ((null != arg$1085 && processScopeNodes
10420: .contains(arg$1085.getName()))) {
10421: processScope(arg$1085, getScope);
10422: }
10423: checkEnterScope(arg$1085);
10424:
10425: final Object retValue$1092 = Analyzer
10426: .cast(null);
10427:
10428: checkExitScope(arg$1085);
10429: matching_nodes
10430: .remove(matching_nodes.size() - 1);
10431: return Analyzer.cast(retValue$1092);
10432: }
10433: return null;
10434: }
10435: }.apply();
10436: }
10437: };
10438:
10439: final Function.F2<CTypes.type, CTypes.type, Node> analyze_abs_declarator = new Function.F2<CTypes.type, CTypes.type, Node>() {
10440: public CTypes.type apply(final CTypes.type t, final Node n) {
10441: return new Match<CTypes.type>() {
10442: public CTypes.type apply() {
10443: final Node arg$1094 = GNode.cast(n);
10444:
10445: if ((null == arg$1094)) {
10446: return null;
10447: }
10448: if (CSupport.match$1095(arg$1094)) {
10449: final Node p = (arg$1094.size() > 0 ? arg$1094
10450: .getGeneric(0) : null);
10451: final Node dec = (arg$1094.size() > 1 ? arg$1094
10452: .getGeneric(1)
10453: : null);
10454:
10455: matching_nodes.add(arg$1094);
10456: if ((null != arg$1094 && processScopeNodes
10457: .contains(arg$1094.getName()))) {
10458: processScope(arg$1094, getScope);
10459: }
10460: checkEnterScope(arg$1094);
10461:
10462: final Object retValue$1098 = Analyzer
10463: .cast(null == Primitives.isBottom
10464: .apply(p) ? null
10465: : Primitives.isBottom.apply(p) ? analyze_direct_abs_decl
10466: .apply(t, dec)
10467: : new Let<CTypes.type>() {
10468: final CTypes.type t1;
10469:
10470: {
10471: t1 = Analyzer
10472: .cast(analyze_pointer
10473: .apply(
10474: t,
10475: p));
10476: }
10477:
10478: public CTypes.type apply() {
10479: return Analyzer
10480: .cast(null == Primitives.isBottom
10481: .apply(dec) ? null
10482: : Primitives.isBottom
10483: .apply(dec) ? t1
10484: : analyze_direct_abs_decl
10485: .apply(
10486: t1,
10487: dec));
10488: }
10489: }.apply());
10490:
10491: checkExitScope(arg$1094);
10492: matching_nodes
10493: .remove(matching_nodes.size() - 1);
10494: return Analyzer.cast(retValue$1098);
10495: }
10496: if (true) {
10497: matching_nodes.add(arg$1094);
10498: if ((null != arg$1094 && processScopeNodes
10499: .contains(arg$1094.getName()))) {
10500: processScope(arg$1094, getScope);
10501: }
10502: checkEnterScope(arg$1094);
10503:
10504: final Object retValue$1101 = Analyzer
10505: .cast(null);
10506:
10507: checkExitScope(arg$1094);
10508: matching_nodes
10509: .remove(matching_nodes.size() - 1);
10510: return Analyzer.cast(retValue$1101);
10511: }
10512: return null;
10513: }
10514: }.apply();
10515: }
10516: };
10517:
10518: final Function.F1<CTypes.type, Node> analyze_parameter_declaration = new Function.F1<CTypes.type, Node>() {
10519: public CTypes.type apply(final Node n) {
10520: return new Match<CTypes.type>() {
10521: public CTypes.type apply() {
10522: final Node arg$1103 = GNode.cast(n);
10523:
10524: if ((null == arg$1103)) {
10525: return null;
10526: }
10527: if (CSupport.match$1104(arg$1103)) {
10528: final Node specs = (arg$1103.size() > 0 ? arg$1103
10529: .getGeneric(0)
10530: : null);
10531: final Node dec = (arg$1103.size() > 1 ? arg$1103
10532: .getGeneric(1)
10533: : null);
10534:
10535: matching_nodes.add(arg$1103);
10536: if ((null != arg$1103 && processScopeNodes
10537: .contains(arg$1103.getName()))) {
10538: processScope(arg$1103, getScope);
10539: }
10540: checkEnterScope(arg$1103);
10541:
10542: final Object retValue$1143 = Analyzer
10543: .cast(new Let<CTypes.type>() {
10544: final CTypes.type t;
10545:
10546: {
10547: t = Analyzer
10548: .cast(analyze_decl_specifiers
10549: .apply(specs));
10550: }
10551:
10552: public CTypes.type apply() {
10553: return Analyzer
10554: .cast(null == Primitives.isBottom
10555: .apply(dec) ? null
10556: : Primitives.isBottom
10557: .apply(dec) ? (null == Primitives.and
10558: .apply(
10559: is_void
10560: .apply(t),
10561: Primitives.not
10562: .apply(Primitives.isEmpty
10563: .apply(null == t ? null
10564: : t.qualifiers))) ? null
10565: : Primitives.and
10566: .apply(
10567: is_void
10568: .apply(t),
10569: Primitives.not
10570: .apply(Primitives.isEmpty
10571: .apply(null == t ? null
10572: : t.qualifiers))) ? error(
10573: "'void' as only parameter may not be qualified",
10574: null)
10575: : null == Primitives.and
10576: .apply(
10577: is_void
10578: .apply(t),
10579: Primitives.isNotBottom
10580: .apply(null == t ? null
10581: : t.storage)) ? null
10582: : Primitives.and
10583: .apply(
10584: is_void
10585: .apply(t),
10586: Primitives.isNotBottom
10587: .apply(null == t ? null
10588: : t.storage)) ? error(
10589: "'void' as only parameter may not have storage class",
10590: null)
10591: : t)
10592: : new Let<CTypes.type>() {
10593: final CTypes.type t2;
10594:
10595: {
10596: t2 = Analyzer
10597: .cast(new Match<CTypes.type>() {
10598: public CTypes.type apply() {
10599: final Node arg$1132 = GNode
10600: .cast(dec);
10601:
10602: if ((null == arg$1132)) {
10603: return null;
10604: }
10605: if (CSupport
10606: .match$1106(arg$1132)) {
10607: matching_nodes
10608: .add(arg$1132);
10609: if ((null != arg$1132 && processScopeNodes
10610: .contains(arg$1132
10611: .getName()))) {
10612: processScope(
10613: arg$1132,
10614: getScope);
10615: }
10616: checkEnterScope(arg$1132);
10617:
10618: final Object retValue$1136 = Analyzer
10619: .cast(analyze_abs_declarator
10620: .apply(
10621: t,
10622: dec));
10623:
10624: checkExitScope(arg$1132);
10625: matching_nodes
10626: .remove(matching_nodes
10627: .size() - 1);
10628: return Analyzer
10629: .cast(retValue$1136);
10630: }
10631: if (true) {
10632: matching_nodes
10633: .add(arg$1132);
10634: if ((null != arg$1132 && processScopeNodes
10635: .contains(arg$1132
10636: .getName()))) {
10637: processScope(
10638: arg$1132,
10639: getScope);
10640: }
10641: checkEnterScope(arg$1132);
10642:
10643: final Object retValue$1139 = Analyzer
10644: .cast(analyze_declarator
10645: .apply(
10646: t,
10647: dec));
10648:
10649: checkExitScope(arg$1132);
10650: matching_nodes
10651: .remove(matching_nodes
10652: .size() - 1);
10653: return Analyzer
10654: .cast(retValue$1139);
10655: }
10656: return null;
10657: }
10658: }
10659: .apply());
10660: }
10661:
10662: public CTypes.type apply() {
10663: return Analyzer
10664: .cast(null == Primitives.and
10665: .apply(
10666: is_incomplete
10667: .apply(t2),
10668: Primitives.not
10669: .apply(is_array
10670: .apply(t2))) ? null
10671: : Primitives.and
10672: .apply(
10673: is_incomplete
10674: .apply(t2),
10675: Primitives.not
10676: .apply(is_array
10677: .apply(t2))) ? error(
10678: "parameter has incomplete type",
10679: null)
10680: : new Match<CTypes.type>() {
10681: public CTypes.type apply() {
10682: final Node arg$1123 = GNode
10683: .cast(dec);
10684:
10685: if ((null == arg$1123)) {
10686: return null;
10687: }
10688: if (CSupport
10689: .match$1106(arg$1123)) {
10690: matching_nodes
10691: .add(arg$1123);
10692: if ((null != arg$1123 && processScopeNodes
10693: .contains(arg$1123
10694: .getName()))) {
10695: processScope(
10696: arg$1123,
10697: getScope);
10698: }
10699: checkEnterScope(arg$1123);
10700:
10701: final Object retValue$1127 = Analyzer
10702: .cast(t2);
10703:
10704: checkExitScope(arg$1123);
10705: matching_nodes
10706: .remove(matching_nodes
10707: .size() - 1);
10708: return Analyzer
10709: .cast(retValue$1127);
10710: }
10711: if (true) {
10712: matching_nodes
10713: .add(arg$1123);
10714: if ((null != arg$1123 && processScopeNodes
10715: .contains(arg$1123
10716: .getName()))) {
10717: processScope(
10718: arg$1123,
10719: getScope);
10720: }
10721: checkEnterScope(arg$1123);
10722:
10723: final Object retValue$1130 = Analyzer
10724: .cast(new Let<CTypes.type>() {
10725: {
10726: define3
10727: .apply(
10728: GNode
10729: .create(
10730: "PrimaryIdentifier",
10731: get_id_declarator
10732: .apply(dec)),
10733: t2,
10734: getNameSpace);
10735: }
10736:
10737: public CTypes.type apply() {
10738: return Analyzer
10739: .cast(t2);
10740: }
10741: }
10742: .apply());
10743:
10744: checkExitScope(arg$1123);
10745: matching_nodes
10746: .remove(matching_nodes
10747: .size() - 1);
10748: return Analyzer
10749: .cast(retValue$1130);
10750: }
10751: return null;
10752: }
10753: }
10754: .apply());
10755: }
10756: }
10757: .apply());
10758: }
10759: }.apply());
10760:
10761: checkExitScope(arg$1103);
10762: matching_nodes
10763: .remove(matching_nodes.size() - 1);
10764: return Analyzer.cast(retValue$1143);
10765: }
10766: if (true) {
10767: matching_nodes.add(arg$1103);
10768: if ((null != arg$1103 && processScopeNodes
10769: .contains(arg$1103.getName()))) {
10770: processScope(arg$1103, getScope);
10771: }
10772: checkEnterScope(arg$1103);
10773:
10774: final Object retValue$1146 = Analyzer
10775: .cast(null);
10776:
10777: checkExitScope(arg$1103);
10778: matching_nodes
10779: .remove(matching_nodes.size() - 1);
10780: return Analyzer.cast(retValue$1146);
10781: }
10782: return null;
10783: }
10784: }.apply();
10785: }
10786: };
10787:
10788: final Function.F2<CTypes.type, CTypes.type, Node> analyze_direct_abs_decl = new Function.F2<CTypes.type, CTypes.type, Node>() {
10789: public CTypes.type apply(final CTypes.type t, final Node n) {
10790: return new Match<CTypes.type>() {
10791: public CTypes.type apply() {
10792: final Node arg$1148 = GNode.cast(n);
10793:
10794: if ((null == arg$1148)) {
10795: return null;
10796: }
10797: if (CSupport.match$1149(arg$1148)) {
10798: final Node n1 = (arg$1148.size() > 0 ? arg$1148
10799: .getGeneric(0) : null);
10800: final String str = (arg$1148.size() > 1 ? arg$1148
10801: .getString(1)
10802: : null);
10803: final Node n2 = (arg$1148.size() > 2 ? arg$1148
10804: .getGeneric(2) : null);
10805:
10806: matching_nodes.add(arg$1148);
10807: if ((null != arg$1148 && processScopeNodes
10808: .contains(arg$1148.getName()))) {
10809: processScope(arg$1148, getScope);
10810: }
10811: checkEnterScope(arg$1148);
10812:
10813: final Object retValue$1160 = Analyzer
10814: .cast(new Let<CTypes.type>() {
10815: final CTypes.type ret;
10816:
10817: {
10818: ret = Analyzer
10819: .cast(null == Primitives.equal
10820: .apply("[", str) ? null
10821: : Primitives.equal
10822: .apply(
10823: "[",
10824: str) ? processArray
10825: .apply(
10826: t,
10827: n2)
10828: : null == Primitives.isBottom
10829: .apply(n2) ? null
10830: : Primitives.isBottom
10831: .apply(n2) ? new CTypes.type(
10832: new CTypes.FunctionT(
10833: t,
10834: null),
10835: null,
10836: null == t ? null
10837: : t.storage,
10838: null,
10839: null,
10840: null,
10841: null,
10842: null,
10843: null,
10844: null,
10845: null)
10846: : new Let<CTypes.type>() {
10847: final CTypes.type lt;
10848:
10849: {
10850: lt = Analyzer
10851: .cast(analyze_para_type_list
10852: .apply(n2));
10853: }
10854:
10855: public CTypes.type apply() {
10856: return Analyzer
10857: .cast(new Match<CTypes.type>() {
10858: public CTypes.type apply() {
10859: final CTypes.raw_type<?> arg$1154 = Analyzer
10860: .cast(null == lt ? null
10861: : lt.type);
10862:
10863: if ((null == arg$1154)) {
10864: return null;
10865: }
10866: if ((null != arg$1154))
10867: switch (arg$1154
10868: .tag()) {
10869: case ListT:
10870: if (CSupport
10871: .match$295(arg$1154)) {
10872: final Pair<CTypes.type> l = Analyzer
10873: .cast(arg$1154
10874: .getTuple()
10875: .get1());
10876:
10877: return Analyzer
10878: .cast(new CTypes.type(
10879: new CTypes.FunctionT(
10880: t,
10881: l),
10882: null,
10883: null == t ? null
10884: : t.storage,
10885: null,
10886: null,
10887: null,
10888: null,
10889: null,
10890: null,
10891: null == lt ? null
10892: : lt.var_args,
10893: null));
10894: }
10895: break;
10896: case VoidT:
10897: if (CSupport
10898: .match$408(arg$1154)) {
10899: return Analyzer
10900: .cast(new CTypes.type(
10901: new CTypes.FunctionT(
10902: t,
10903: new Pair<CTypes.type>(
10904: voidt)),
10905: null,
10906: null == t ? null
10907: : t.storage,
10908: null,
10909: null,
10910: null,
10911: null,
10912: null,
10913: null,
10914: null == lt ? null
10915: : lt.var_args,
10916: null));
10917: }
10918: break;
10919: default:
10920: break;
10921: }
10922: ;
10923: if (true) {
10924: return Analyzer
10925: .cast(null);
10926: }
10927: return null;
10928: }
10929: }
10930: .apply());
10931: }
10932: }
10933: .apply());
10934: }
10935:
10936: public CTypes.type apply() {
10937: return Analyzer
10938: .cast(null == Primitives.isBottom
10939: .apply(n1) ? null
10940: : Primitives.isBottom
10941: .apply(n1) ? ret
10942: : analyze_direct_abs_decl
10943: .apply(
10944: ret,
10945: n1));
10946: }
10947: }.apply());
10948:
10949: checkExitScope(arg$1148);
10950: matching_nodes
10951: .remove(matching_nodes.size() - 1);
10952: return Analyzer.cast(retValue$1160);
10953: }
10954: if (CSupport.match$1161(arg$1148)) {
10955: final Node dec = (arg$1148.size() > 1 ? arg$1148
10956: .getGeneric(1)
10957: : null);
10958:
10959: matching_nodes.add(arg$1148);
10960: if ((null != arg$1148 && processScopeNodes
10961: .contains(arg$1148.getName()))) {
10962: processScope(arg$1148, getScope);
10963: }
10964: checkEnterScope(arg$1148);
10965:
10966: final Object retValue$1164 = Analyzer
10967: .cast(analyze_abs_declarator.apply(t,
10968: dec));
10969:
10970: checkExitScope(arg$1148);
10971: matching_nodes
10972: .remove(matching_nodes.size() - 1);
10973: return Analyzer.cast(retValue$1164);
10974: }
10975: if (true) {
10976: matching_nodes.add(arg$1148);
10977: if ((null != arg$1148 && processScopeNodes
10978: .contains(arg$1148.getName()))) {
10979: processScope(arg$1148, getScope);
10980: }
10981: checkEnterScope(arg$1148);
10982:
10983: final Object retValue$1167 = Analyzer
10984: .cast(null);
10985:
10986: checkExitScope(arg$1148);
10987: matching_nodes
10988: .remove(matching_nodes.size() - 1);
10989: return Analyzer.cast(retValue$1167);
10990: }
10991: return null;
10992: }
10993: }.apply();
10994: }
10995: };
10996:
10997: final Function.F1<CTypes.type, CTypes.type> process_indirection = new Function.F1<CTypes.type, CTypes.type>() {
10998: public CTypes.type apply(final CTypes.type t) {
10999: return new Let<CTypes.type>() {
11000: final CTypes.type ret;
11001:
11002: {
11003: ret = Analyzer.cast(get_base.apply(t));
11004: }
11005:
11006: public CTypes.type apply() {
11007: return Analyzer
11008: .cast(null == Primitives.isBottom.apply(t) ? null
11009: : Primitives.isBottom.apply(t) ? null
11010: : null == Primitives.not
11011: .apply(is_pointer
11012: .apply(t)) ? null
11013: : Primitives.not
11014: .apply(is_pointer
11015: .apply(t)) ? new Let<CTypes.type>() {
11016: {
11017: error(
11018: "operand to 'unary *' not a pointer type",
11019: null);
11020: }
11021:
11022: public CTypes.type apply() {
11023: return Analyzer
11024: .cast(ret);
11025: }
11026: }.apply()
11027: : null == is_void
11028: .apply(get_base
11029: .apply(t)) ? null
11030: : is_void
11031: .apply(get_base
11032: .apply(t)) ? new Let<CTypes.type>() {
11033: {
11034: warning(
11035: "dereferencing 'void *' pointer",
11036: null);
11037: }
11038:
11039: public CTypes.type apply() {
11040: return Analyzer
11041: .cast(get_base
11042: .apply(t));
11043: }
11044: }
11045: .apply()
11046: : null == Primitives.and
11047: .apply(
11048: is_incomplete
11049: .apply(get_base
11050: .apply(t)),
11051: Primitives.not
11052: .apply(is_void
11053: .apply(get_base
11054: .apply(t)))) ? null
11055: : Primitives.and
11056: .apply(
11057: is_incomplete
11058: .apply(get_base
11059: .apply(t)),
11060: Primitives.not
11061: .apply(is_void
11062: .apply(get_base
11063: .apply(t)))) ? error(
11064: "dereferencing pointer to incomplete type 2",
11065: null)
11066: : get_base
11067: .apply(t));
11068: }
11069: }.apply();
11070: }
11071: };
11072:
11073: final Function.F1<CTypes.type, CTypes.type> process_subscript = new Function.F1<CTypes.type, CTypes.type>() {
11074: public CTypes.type apply(final CTypes.type t) {
11075: return new Let<CTypes.type>() {
11076: final CTypes.type ret;
11077:
11078: {
11079: ret = Analyzer.cast(get_base.apply(t));
11080: }
11081:
11082: public CTypes.type apply() {
11083: return Analyzer
11084: .cast(null == Primitives.isBottom.apply(t) ? null
11085: : Primitives.isBottom.apply(t) ? null
11086: : null == Primitives.not
11087: .apply(Primitives.or
11088: .apply(
11089: is_array
11090: .apply(t),
11091: is_pointer
11092: .apply(t))) ? null
11093: : Primitives.not
11094: .apply(Primitives.or
11095: .apply(
11096: is_array
11097: .apply(t),
11098: is_pointer
11099: .apply(t))) ? new Let<CTypes.type>() {
11100: {
11101: error(
11102: "pointer or array required in subscript expression",
11103: null);
11104: }
11105:
11106: public CTypes.type apply() {
11107: return Analyzer
11108: .cast(ret);
11109: }
11110: }.apply()
11111: : null == Primitives.and
11112: .apply(
11113: is_incomplete
11114: .apply(get_base
11115: .apply(t)),
11116: Primitives.not
11117: .apply(is_void
11118: .apply(get_base
11119: .apply(t)))) ? null
11120: : Primitives.and
11121: .apply(
11122: is_incomplete
11123: .apply(get_base
11124: .apply(t)),
11125: Primitives.not
11126: .apply(is_void
11127: .apply(get_base
11128: .apply(t)))) ? error(
11129: "dereferencing pointer to incomplete type 3",
11130: null)
11131: : get_base
11132: .apply(t));
11133: }
11134: }.apply();
11135: }
11136: };
11137:
11138: final Function.F2<Pair<CTypes.type>, Pair<Node>, BigInteger> process_enums = new Function.F2<Pair<CTypes.type>, Pair<Node>, BigInteger>() {
11139: public Pair<CTypes.type> apply(final Pair<Node> nl,
11140: final BigInteger val) {
11141: return new Match<Pair<CTypes.type>>() {
11142: public Pair<CTypes.type> apply() {
11143: final Pair<Node> arg$1169 = Analyzer.cast(nl);
11144:
11145: if ((null == arg$1169)) {
11146: return null;
11147: }
11148: if (CSupport.match$383(arg$1169)) {
11149: return Analyzer
11150: .cast(Pair.<CTypes.type> empty());
11151: }
11152: if (true) {
11153: final Pair<Node> list$1171 = Analyzer
11154: .cast(Analyzer.cast(arg$1169));
11155: final Node x = GNode.cast(Primitives
11156: .wrapHead(list$1171));
11157: final Pair<Node> xs = Analyzer.cast(Primitives
11158: .wrapTail(list$1171));
11159:
11160: return Analyzer
11161: .cast(new Let<Pair<CTypes.type>>() {
11162: final BigInteger newval;
11163: final String id;
11164: final CTypes.type et;
11165:
11166: {
11167: newval = Analyzer
11168: .cast(analyze_enumerator
11169: .apply(x, val));
11170: id = Analyzer
11171: .cast(new Match<String>() {
11172: public String apply() {
11173: final Node arg$1181 = GNode
11174: .cast(x);
11175:
11176: if ((null == arg$1181)) {
11177: return null;
11178: }
11179: if (CSupport
11180: .match$21(arg$1181)) {
11181: final String s = (arg$1181
11182: .size() > 0 ? arg$1181
11183: .getString(0)
11184: : null);
11185:
11186: matching_nodes
11187: .add(arg$1181);
11188: if ((null != arg$1181 && processScopeNodes
11189: .contains(arg$1181
11190: .getName()))) {
11191: processScope(
11192: arg$1181,
11193: getScope);
11194: }
11195: checkEnterScope(arg$1181);
11196:
11197: final Object retValue$1185 = Analyzer
11198: .cast(s);
11199:
11200: checkExitScope(arg$1181);
11201: matching_nodes
11202: .remove(matching_nodes
11203: .size() - 1);
11204: return Analyzer
11205: .cast(retValue$1185);
11206: }
11207: if (true) {
11208: matching_nodes
11209: .add(arg$1181);
11210: if ((null != arg$1181 && processScopeNodes
11211: .contains(arg$1181
11212: .getName()))) {
11213: processScope(
11214: arg$1181,
11215: getScope);
11216: }
11217: checkEnterScope(arg$1181);
11218:
11219: final Object retValue$1188 = Analyzer
11220: .cast(null);
11221:
11222: checkExitScope(arg$1181);
11223: matching_nodes
11224: .remove(matching_nodes
11225: .size() - 1);
11226: return Analyzer
11227: .cast(retValue$1188);
11228: }
11229: return null;
11230: }
11231: }.apply());
11232: et = Analyzer
11233: .cast(new CTypes.type(
11234: new CTypes.EnumeratorT(
11235: id,
11236: new CTypes.type(
11237: new CTypes.IntT(),
11238: null,
11239: null,
11240: null,
11241: null,
11242: null,
11243: null,
11244: null,
11245: null,
11246: null,
11247: null),
11248: Primitives.subtractInt
11249: .apply(
11250: newval,
11251: BigInteger
11252: .valueOf(1))),
11253: null, null,
11254: null, null,
11255: null, null,
11256: null, null,
11257: null, null));
11258: }
11259:
11260: public Pair<CTypes.type> apply() {
11261: return Analyzer
11262: .cast(Primitives
11263: .wrapCons(
11264: et,
11265: process_enums
11266: .apply(
11267: xs,
11268: newval)));
11269: }
11270: }.apply());
11271: }
11272: return null;
11273: }
11274: }.apply();
11275: }
11276: };
11277:
11278: final Function.F3<CTypes.type, Node, String, CTypes.type> c_define = new Function.F3<CTypes.type, Node, String, CTypes.type>() {
11279: public CTypes.type apply(final Node n, final String name,
11280: final CTypes.type t) {
11281: return (null == Primitives.not.apply(isDefined.apply(n,
11282: getNameSpace)) ? null
11283: : Primitives.not.apply(isDefined.apply(n,
11284: getNameSpace)) ? new Let<CTypes.type>() {
11285: {
11286: define3.apply(n, t, getNameSpace);
11287: }
11288:
11289: public CTypes.type apply() {
11290: return Analyzer.cast(t);
11291: }
11292: }.apply() : new Let<CTypes.type>() {
11293: final CTypes.type val;
11294:
11295: {
11296: val = Analyzer.cast(Analyzer.cast(lookup2
11297: .apply(n, getNameSpace)));
11298: }
11299:
11300: public CTypes.type apply() {
11301: return Analyzer
11302: .cast(null == Primitives.or.apply(
11303: is_extern.apply(val),
11304: is_static.apply(val)) ? null
11305: : Primitives.or
11306: .apply(
11307: is_extern
11308: .apply(val),
11309: is_static
11310: .apply(val)) ? (null == is_extern
11311: .apply(t) ? null
11312: : is_extern
11313: .apply(t) ? new Let<CTypes.type>() {
11314: final CTypes.type ret;
11315:
11316: {
11317: ret = Analyzer
11318: .cast(compose
11319: .apply(
11320: val,
11321: t));
11322: }
11323:
11324: public CTypes.type apply() {
11325: return Analyzer
11326: .cast(null == Primitives.isNotBottom
11327: .apply(ret) ? null
11328: : Primitives.isNotBottom
11329: .apply(ret) ? new Let<CTypes.type>() {
11330: {
11331: redefine
11332: .apply(
11333: n,
11334: ret,
11335: getNameSpace);
11336: }
11337:
11338: public CTypes.type apply() {
11339: return Analyzer
11340: .cast(ret);
11341: }
11342: }
11343: .apply()
11344: : null);
11345: }
11346: }.apply()
11347: : new Let<CTypes.type>() {
11348: {
11349: redefine
11350: .apply(
11351: n,
11352: t,
11353: getNameSpace);
11354: }
11355:
11356: public CTypes.type apply() {
11357: return Analyzer
11358: .cast(t);
11359: }
11360: }.apply())
11361: : null == isDefinedLocally
11362: .apply(n,
11363: getNameSpace) ? null
11364: : isDefinedLocally
11365: .apply(
11366: n,
11367: getNameSpace) ? new Let<CTypes.type>() {
11368: final CTypes.type ty;
11369: final Node pos;
11370:
11371: {
11372: ty = Analyzer
11373: .cast(Analyzer
11374: .cast(lookupLocally2
11375: .apply(
11376: n,
11377: getNameSpace)));
11378: pos = Analyzer
11379: .cast(null == ty ? null
11380: : ty.position);
11381: }
11382:
11383: public CTypes.type apply() {
11384: return Analyzer
11385: .cast(null == Primitives.and
11386: .apply(
11387: Primitives.and
11388: .apply(
11389: Primitives.not
11390: .apply(is_function
11391: .apply(ty)),
11392: is_complete
11393: .apply(ty)),
11394: Primitives.not
11395: .apply(is_top
11396: .apply(n))) ? null
11397: : Primitives.and
11398: .apply(
11399: Primitives.and
11400: .apply(
11401: Primitives.not
11402: .apply(is_function
11403: .apply(ty)),
11404: is_complete
11405: .apply(ty)),
11406: Primitives.not
11407: .apply(is_top
11408: .apply(n))) ? new Let<CTypes.type>() {
11409: {
11410: Analyzer
11411: .discard(null == is_struct_union
11412: .apply(ty) ? null
11413: : is_struct_union
11414: .apply(ty) ? error(
11415: "redefinition of ",
11416: null)
11417: : new Let<Object>() {
11418: {
11419: error(
11420: Primitives.concat
11421: .apply(
11422: "redeclaration of ",
11423: name),
11424: null);
11425: error(
11426: Primitives.concat
11427: .apply(
11428: Primitives.concat
11429: .apply(
11430: "previous declaration of '",
11431: name),
11432: "' was here"),
11433: pos);
11434: }
11435:
11436: public Object apply() {
11437: return Analyzer
11438: .cast(null);
11439: }
11440: }
11441: .apply());
11442: }
11443:
11444: public CTypes.type apply() {
11445: return Analyzer
11446: .cast(t);
11447: }
11448: }
11449: .apply()
11450: : new Let<CTypes.type>() {
11451: {
11452: redefine
11453: .apply(
11454: n,
11455: t,
11456: getNameSpace);
11457: }
11458:
11459: public CTypes.type apply() {
11460: return Analyzer
11461: .cast(t);
11462: }
11463: }
11464: .apply());
11465: }
11466: }.apply()
11467: : new Let<CTypes.type>() {
11468: {
11469: redefine
11470: .apply(
11471: n,
11472: t,
11473: getNameSpace);
11474: }
11475:
11476: public CTypes.type apply() {
11477: return Analyzer
11478: .cast(t);
11479: }
11480: }
11481: .apply());
11482: }
11483: }.apply());
11484: }
11485: };
11486:
11487: final Function.F1<CTypes.type, Node> ensure_in_loop_or_switch = new Function.F1<CTypes.type, Node>() {
11488: public CTypes.type apply(final Node n) {
11489: return new Require<CTypes.type>() {
11490: public CTypes.type apply() {
11491: final Boolean var$1199 = Primitives.or
11492: .apply(
11493: Primitives.or
11494: .apply(
11495: Primitives.or
11496: .apply(
11497: Primitives.isNotBottom
11498: .apply(ancestor
11499: .apply(CSupport.nodeMatch$1192)),
11500: Primitives.isNotBottom
11501: .apply(ancestor
11502: .apply(CSupport.nodeMatch$1194))),
11503: Primitives.isNotBottom
11504: .apply(ancestor
11505: .apply(CSupport.nodeMatch$1196))),
11506: Primitives.isNotBottom
11507: .apply(ancestor
11508: .apply(CSupport.nodeMatch$1198)));
11509:
11510: if ((null != var$1199 && !var$1199)) {
11511: showMessage("error",
11512: "not within a loop or switch", n);
11513: }
11514: if ((null == var$1199)) {
11515: return null;
11516: }
11517: if (var$1199) {
11518: return voidt;
11519: }
11520: return null;
11521: }
11522: }.apply();
11523: }
11524: };
11525:
11526: final Function.F1<CTypes.type, Node> ensure_in_loop = new Function.F1<CTypes.type, Node>() {
11527: public CTypes.type apply(final Node n) {
11528: return new Require<CTypes.type>() {
11529: public CTypes.type apply() {
11530: final Boolean var$1203 = Primitives.or
11531: .apply(
11532: Primitives.or
11533: .apply(
11534: Primitives.isNotBottom
11535: .apply(ancestor
11536: .apply(CSupport.nodeMatch$1192)),
11537: Primitives.isNotBottom
11538: .apply(ancestor
11539: .apply(CSupport.nodeMatch$1194))),
11540: Primitives.isNotBottom
11541: .apply(ancestor
11542: .apply(CSupport.nodeMatch$1196)));
11543:
11544: if ((null != var$1203 && !var$1203)) {
11545: showMessage("error", "not within a loop", n);
11546: }
11547: if ((null == var$1203)) {
11548: return null;
11549: }
11550: if (var$1203) {
11551: return voidt;
11552: }
11553: return null;
11554: }
11555: }.apply();
11556: }
11557: };
11558:
11559: final Function.F1<CTypes.type, Node> ensure_in_switch = new Function.F1<CTypes.type, Node>() {
11560: public CTypes.type apply(final Node n) {
11561: return new Require<CTypes.type>() {
11562: public CTypes.type apply() {
11563: final Boolean var$1205 = Primitives.isNotBottom
11564: .apply(ancestor
11565: .apply(CSupport.nodeMatch$1198));
11566:
11567: if ((null != var$1205 && !var$1205)) {
11568: showMessage("error",
11569: "not within a switch statement", n);
11570: }
11571: if ((null == var$1205)) {
11572: return null;
11573: }
11574: if (var$1205) {
11575: return voidt;
11576: }
11577: return null;
11578: }
11579: }.apply();
11580: }
11581: };
11582:
11583: final Function.F1<Boolean, Object> is_top = new Function.F1<Boolean, Object>() {
11584: public Boolean apply(final Object n) {
11585: return new Match<Boolean>() {
11586: public Boolean apply() {
11587: final Object arg$1206 = Analyzer.cast(n);
11588:
11589: if ((null == arg$1206)) {
11590: return null;
11591: }
11592: if (true) {
11593: return Analyzer
11594: .cast(Primitives.isBottom
11595: .apply(ancestor
11596: .apply(CSupport.nodeMatch$1208)));
11597: }
11598: return null;
11599: }
11600: }.apply();
11601: }
11602: };
11603:
11604: final Function.F4<CTypes.type, Boolean, CTypes.type, String, CTypes.type> processAssignment = new Function.F4<CTypes.type, Boolean, CTypes.type, String, CTypes.type>() {
11605: public CTypes.type apply(final Boolean init,
11606: final CTypes.type t1, final String op,
11607: final CTypes.type t2) {
11608: return new Let<CTypes.type>() {
11609: final CTypes.type ret;
11610: final CTypes.type r1;
11611: final CTypes.type r2;
11612:
11613: {
11614: ret = Analyzer
11615: .cast(null == Primitives.and.apply(init,
11616: is_const.apply(t1)) ? null
11617: : Primitives.and.apply(init,
11618: is_const.apply(t1)) ? new CTypes.type(
11619: null == t1 ? null : t1.type,
11620: null == t1 ? null
11621: : t1.qualifiers,
11622: null == t1 ? null
11623: : t1.storage,
11624: null == t1 ? null
11625: : t1.fSpec,
11626: null == t2 ? null
11627: : t2.value,
11628: null == t1 ? null
11629: : t1.implicit,
11630: null == t1 ? null
11631: : t1.initialised,
11632: null == t1 ? null
11633: : t1.position,
11634: null == t1 ? null
11635: : t1.old_style,
11636: null == t1 ? null
11637: : t1.var_args,
11638: null == t1 ? null
11639: : t1.in_top)
11640: : t1);
11641: r1 = Analyzer.cast(pointerize.apply(t1));
11642: r2 = Analyzer.cast(pointerize.apply(t2));
11643: }
11644:
11645: public CTypes.type apply() {
11646: return Analyzer
11647: .cast(null == Primitives.or.apply(
11648: Primitives.isBottom.apply(t1),
11649: Primitives.isBottom.apply(t2)) ? null
11650: : Primitives.or.apply(
11651: Primitives.isBottom
11652: .apply(t1),
11653: Primitives.isBottom
11654: .apply(t2)) ? null
11655: : null == Primitives.and
11656: .apply(
11657: is_arithmetic
11658: .apply(r1),
11659: is_arithmetic
11660: .apply(r2)) ? null
11661: : Primitives.and
11662: .apply(
11663: is_arithmetic
11664: .apply(r1),
11665: is_arithmetic
11666: .apply(r2)) ? ret
11667: : null == Primitives.and
11668: .apply(
11669: is_void
11670: .apply(r2),
11671: Primitives.not
11672: .apply(Primitives.startsWithi
11673: .apply(
11674: op,
11675: "return"))) ? null
11676: : Primitives.and
11677: .apply(
11678: is_void
11679: .apply(r2),
11680: Primitives.not
11681: .apply(Primitives.startsWithi
11682: .apply(
11683: op,
11684: "return"))) ? new Let<CTypes.type>() {
11685: {
11686: error(
11687: Primitives.concat
11688: .apply(
11689: "void value not ignored as it ought to be in ",
11690: op),
11691: null);
11692: }
11693:
11694: public CTypes.type apply() {
11695: return Analyzer
11696: .cast(t1);
11697: }
11698: }
11699: .apply()
11700: : null == Primitives.and
11701: .apply(
11702: is_integer
11703: .apply(r1),
11704: is_pointer
11705: .apply(r2)) ? null
11706: : Primitives.and
11707: .apply(
11708: is_integer
11709: .apply(r1),
11710: is_pointer
11711: .apply(r2)) ? (null == is_char
11712: .apply(r1) ? null
11713: : is_char
11714: .apply(r1) ? t1
11715: : new Let<CTypes.type>() {
11716: {
11717: warning(
11718: Primitives.concat
11719: .apply(
11720: "makes integer from pointer without a cast in ",
11721: op),
11722: null);
11723: }
11724:
11725: public CTypes.type apply() {
11726: return Analyzer
11727: .cast(ret);
11728: }
11729: }
11730: .apply())
11731: : null == Primitives.and
11732: .apply(
11733: is_pointer
11734: .apply(r1),
11735: is_integer
11736: .apply(r2)) ? null
11737: : Primitives.and
11738: .apply(
11739: is_pointer
11740: .apply(r1),
11741: is_integer
11742: .apply(r2)) ? new Let<CTypes.type>() {
11743: {
11744: Analyzer
11745: .discard(null == Primitives.and
11746: .apply(
11747: Primitives.not
11748: .apply(zero
11749: .apply(r2)),
11750: Primitives.not
11751: .apply(is_array
11752: .apply(t1)))
11753: || !Primitives.and
11754: .apply(
11755: Primitives.not
11756: .apply(zero
11757: .apply(r2)),
11758: Primitives.not
11759: .apply(is_array
11760: .apply(t1))) ? null
11761: : warning(
11762: Primitives.concat
11763: .apply(
11764: "makes pointer from integer without a cast in ",
11765: op),
11766: null));
11767: }
11768:
11769: public CTypes.type apply() {
11770: return Analyzer
11771: .cast(ret);
11772: }
11773: }
11774: .apply()
11775: : null == Primitives.and
11776: .apply(
11777: Primitives.and
11778: .apply(
11779: init,
11780: is_array
11781: .apply(t1)),
11782: is_array
11783: .apply(t2)) ? null
11784: : Primitives.and
11785: .apply(
11786: Primitives.and
11787: .apply(
11788: init,
11789: is_array
11790: .apply(t1)),
11791: is_array
11792: .apply(t2)) ? ret
11793: : null == Primitives.and
11794: .apply(
11795: is_pointer
11796: .apply(r1),
11797: is_pointer
11798: .apply(r2)) ? null
11799: : Primitives.and
11800: .apply(
11801: is_pointer
11802: .apply(r1),
11803: is_pointer
11804: .apply(r2)) ? new Let<CTypes.type>() {
11805: final CTypes.type b1;
11806: final CTypes.type b2;
11807:
11808: {
11809: b1 = Analyzer
11810: .cast(get_base
11811: .apply(r1));
11812: b2 = Analyzer
11813: .cast(get_base
11814: .apply(r2));
11815: }
11816:
11817: public CTypes.type apply() {
11818: return Analyzer
11819: .cast(null == Primitives.or
11820: .apply(
11821: Primitives.or
11822: .apply(
11823: Primitives.or
11824: .apply(
11825: is_void
11826: .apply(b1),
11827: is_void
11828: .apply(b2)),
11829: pointer_equals
11830: .apply(
11831: r1,
11832: r2)),
11833: Primitives.and
11834: .apply(
11835: is_arithmetic
11836: .apply(b1),
11837: is_arithmetic
11838: .apply(t2))) ? null
11839: : Primitives.or
11840: .apply(
11841: Primitives.or
11842: .apply(
11843: Primitives.or
11844: .apply(
11845: is_void
11846: .apply(b1),
11847: is_void
11848: .apply(b2)),
11849: pointer_equals
11850: .apply(
11851: r1,
11852: r2)),
11853: Primitives.and
11854: .apply(
11855: is_arithmetic
11856: .apply(b1),
11857: is_arithmetic
11858: .apply(t2))) ? t1
11859: : null == Primitives.and
11860: .apply(
11861: Primitives.and
11862: .apply(
11863: is_arithmetic
11864: .apply(b1),
11865: is_arithmetic
11866: .apply(b2)),
11867: equal_ignore_signedness
11868: .apply(
11869: b1,
11870: b2)) ? null
11871: : Primitives.and
11872: .apply(
11873: Primitives.and
11874: .apply(
11875: is_arithmetic
11876: .apply(b1),
11877: is_arithmetic
11878: .apply(b2)),
11879: equal_ignore_signedness
11880: .apply(
11881: b1,
11882: b2)) ? new Let<CTypes.type>() {
11883: {
11884: warning(
11885: Primitives.concat
11886: .apply(
11887: Primitives.concat
11888: .apply(
11889: "pointer targets in ",
11890: op),
11891: " differ in signedness"),
11892: null);
11893: }
11894:
11895: public CTypes.type apply() {
11896: return Analyzer
11897: .cast(t1);
11898: }
11899: }
11900: .apply()
11901: : new Let<CTypes.type>() {
11902: {
11903: warning(
11904: Primitives.concat
11905: .apply(
11906: "incompatible pointer types in ",
11907: op),
11908: null);
11909: }
11910:
11911: public CTypes.type apply() {
11912: return Analyzer
11913: .cast(t1);
11914: }
11915: }
11916: .apply());
11917: }
11918: }
11919: .apply()
11920: : null == type_match
11921: .apply(
11922: t1,
11923: t2) ? null
11924: : type_match
11925: .apply(
11926: t1,
11927: t2) ? t1
11928: : new Let<CTypes.type>() {
11929: {
11930: error(
11931: Primitives.concat
11932: .apply(
11933: "incompatible types in ",
11934: op),
11935: null);
11936: }
11937:
11938: public CTypes.type apply() {
11939: return Analyzer
11940: .cast(t1);
11941: }
11942: }
11943: .apply());
11944: }
11945: }.apply();
11946: }
11947: };
11948:
11949: final Function.F3<Object, Pair<CTypes.type>, Pair<CTypes.type>, Boolean> processArguments = new Function.F3<Object, Pair<CTypes.type>, Pair<CTypes.type>, Boolean>() {
11950: public Object apply(final Pair<CTypes.type> tl,
11951: final Pair<CTypes.type> elt, final Boolean is_var) {
11952: return new Let<Object>() {
11953: {
11954: Analyzer
11955: .discard(null == Primitives.and
11956: .apply(
11957: Primitives.not
11958: .apply(is_var),
11959: Primitives.greaterInt
11960: .apply(
11961: Primitives.length
11962: .apply(tl),
11963: Primitives.length
11964: .apply(elt))) ? null
11965: : Primitives.and
11966: .apply(
11967: Primitives.not
11968: .apply(is_var),
11969: Primitives.greaterInt
11970: .apply(
11971: Primitives.length
11972: .apply(tl),
11973: Primitives.length
11974: .apply(elt))) ? error(
11975: "too few arguments to function",
11976: null)
11977: : null == Primitives.and
11978: .apply(
11979: Primitives.not
11980: .apply(is_var),
11981: Primitives.lessInt
11982: .apply(
11983: Primitives.length
11984: .apply(tl),
11985: Primitives.length
11986: .apply(elt)))
11987: || !Primitives.and
11988: .apply(
11989: Primitives.not
11990: .apply(is_var),
11991: Primitives.lessInt
11992: .apply(
11993: Primitives.length
11994: .apply(tl),
11995: Primitives.length
11996: .apply(elt))) ? null
11997: : error(
11998: "too many arguments to function",
11999: null));
12000: }
12001:
12002: public Object apply() {
12003: return Analyzer.cast(processArgumentsHelper.apply(
12004: tl, elt, BigInteger.valueOf(1)));
12005: }
12006: }.apply();
12007: }
12008: };
12009:
12010: final Function.F3<Object, Pair<CTypes.type>, Pair<CTypes.type>, BigInteger> processArgumentsHelper = new Function.F3<Object, Pair<CTypes.type>, Pair<CTypes.type>, BigInteger>() {
12011: public Object apply(final Pair<CTypes.type> tl,
12012: final Pair<CTypes.type> elt, final BigInteger index) {
12013: return new Match<Object>() {
12014: public Object apply() {
12015: final Pair<CTypes.type> arg$1211 = Analyzer
12016: .cast(tl);
12017:
12018: if ((null == arg$1211)) {
12019: return null;
12020: }
12021: if (CSupport.match$1212(arg$1211)) {
12022: return Analyzer.cast(null);
12023: }
12024: if (true) {
12025: final Pair<CTypes.type> list$1213 = Analyzer
12026: .cast(Analyzer.cast(arg$1211));
12027: final CTypes.type x = Analyzer.cast(Primitives
12028: .wrapHead(list$1213));
12029: final Pair<CTypes.type> xs = Analyzer
12030: .cast(Primitives.wrapTail(list$1213));
12031:
12032: return Analyzer.cast(new Let<Object>() {
12033: final String op;
12034:
12035: {
12036: op = Analyzer.cast(Primitives.concat
12037: .apply("passing argument ",
12038: Primitives.itos
12039: .apply(index)));
12040: }
12041:
12042: public Object apply() {
12043: return Analyzer
12044: .cast(null == Primitives.or
12045: .apply(
12046: Primitives.isBottom
12047: .apply(elt),
12048: Primitives.isEmpty
12049: .apply(elt)) ? null
12050: : Primitives.or
12051: .apply(
12052: Primitives.isBottom
12053: .apply(elt),
12054: Primitives.isEmpty
12055: .apply(elt)) ? null
12056: : new Let<Object>() {
12057: {
12058: processAssignment
12059: .apply(
12060: Boolean.FALSE,
12061: x,
12062: op,
12063: CSupport.head$1215
12064: .apply(elt));
12065: }
12066:
12067: public Object apply() {
12068: return Analyzer
12069: .cast(processArgumentsHelper
12070: .apply(
12071: xs,
12072: CSupport.tail$1214
12073: .apply(elt),
12074: Primitives.addInt
12075: .apply(
12076: index,
12077: BigInteger
12078: .valueOf(1))));
12079: }
12080: }.apply());
12081: }
12082: }.apply());
12083: }
12084: return null;
12085: }
12086: }.apply();
12087: }
12088: };
12089:
12090: final Function.F1<Boolean, CTypes.type> is_var_args = new Function.F1<Boolean, CTypes.type>() {
12091: public Boolean apply(final CTypes.type ft) {
12092: return (null == Primitives.isBottom.apply(null == ft ? null
12093: : ft.var_args) ? null
12094: : Primitives.isBottom.apply(null == ft ? null
12095: : ft.var_args) ? Boolean.FALSE
12096: : null == ft ? null : ft.var_args);
12097: }
12098: };
12099:
12100: final Function.F1<Boolean, CTypes.type> is_old_stype = new Function.F1<Boolean, CTypes.type>() {
12101: public Boolean apply(final CTypes.type ft) {
12102: return Primitives.isNotBottom.apply(null == ft ? null
12103: : ft.old_style);
12104: }
12105: };
12106:
12107: final Function.F1<Pair<CTypes.type>, Pair<String>> define_id_list = new Function.F1<Pair<CTypes.type>, Pair<String>>() {
12108: public Pair<CTypes.type> apply(final Pair<String> strl) {
12109: return new Match<Pair<CTypes.type>>() {
12110: public Pair<CTypes.type> apply() {
12111: final Pair<String> arg$1217 = Analyzer.cast(strl);
12112:
12113: if ((null == arg$1217)) {
12114: return null;
12115: }
12116: if (CSupport.match$1218(arg$1217)) {
12117: return Analyzer
12118: .cast(Pair.<CTypes.type> empty());
12119: }
12120: if (true) {
12121: final Pair<String> list$1219 = Analyzer
12122: .cast(Analyzer.cast(arg$1217));
12123: final String x = Analyzer.cast(Primitives
12124: .wrapHead(list$1219));
12125: final Pair<String> xs = Analyzer
12126: .cast(Primitives.wrapTail(list$1219));
12127:
12128: return Analyzer
12129: .cast(new Let<Pair<CTypes.type>>() {
12130: final CTypes.type t;
12131:
12132: {
12133: t = Analyzer
12134: .cast(null == Primitives.not
12135: .apply(isDefinedLocally
12136: .apply(
12137: GNode
12138: .create(
12139: "PrimaryIdentifier",
12140: x),
12141: getNameSpace)) ? null
12142: : Primitives.not
12143: .apply(isDefinedLocally
12144: .apply(
12145: GNode
12146: .create(
12147: "PrimaryIdentifier",
12148: x),
12149: getNameSpace)) ? new Let<CTypes.type>() {
12150: {
12151: define3
12152: .apply(
12153: GNode
12154: .create(
12155: "PrimaryIdentifier",
12156: x),
12157: new CTypes.type(
12158: new CTypes.IntT(),
12159: null,
12160: null,
12161: null,
12162: null,
12163: null,
12164: null,
12165: null,
12166: null,
12167: null,
12168: null),
12169: getNameSpace);
12170: }
12171:
12172: public CTypes.type apply() {
12173: return Analyzer
12174: .cast(new CTypes.type(
12175: new CTypes.IntT(),
12176: null,
12177: null,
12178: null,
12179: null,
12180: null,
12181: null,
12182: null,
12183: null,
12184: null,
12185: null));
12186: }
12187: }.apply()
12188: : Analyzer
12189: .cast(lookupLocally2
12190: .apply(
12191: GNode
12192: .create(
12193: "PrimaryIdentifier",
12194: x),
12195: getNameSpace)));
12196: }
12197:
12198: public Pair<CTypes.type> apply() {
12199: return Analyzer
12200: .cast(Primitives
12201: .wrapCons(
12202: t,
12203: define_id_list
12204: .apply(xs)));
12205: }
12206: }.apply());
12207: }
12208: return null;
12209: }
12210: }.apply();
12211: }
12212: };
12213:
12214: final Function.F2<Object, Pair<CTypes.label_record>, Boolean> define_labels = new Function.F2<Object, Pair<CTypes.label_record>, Boolean>() {
12215: public Object apply(final Pair<CTypes.label_record> lbl,
12216: final Boolean val) {
12217: return new Match<Object>() {
12218: public Object apply() {
12219: final Pair<CTypes.label_record> arg$1221 = Analyzer
12220: .cast(lbl);
12221:
12222: if ((null == arg$1221)) {
12223: return null;
12224: }
12225: if (CSupport.match$1222(arg$1221)) {
12226: return Analyzer.cast(null);
12227: }
12228: if (true) {
12229: final Pair<CTypes.label_record> list$1223 = Analyzer
12230: .cast(Analyzer.cast(arg$1221));
12231: final CTypes.label_record x = Analyzer
12232: .cast(Primitives.wrapHead(list$1223));
12233: final Pair<CTypes.label_record> xs = Analyzer
12234: .cast(Primitives.wrapTail(list$1223));
12235:
12236: return Analyzer.cast(new Let<Object>() {
12237: final String name;
12238:
12239: {
12240: name = Analyzer.cast(null == x ? null
12241: : x.label_name);
12242: redefine.apply(GNode.create(
12243: "LabeledStatement", GNode
12244: .create("NamedLabel",
12245: name, null),
12246: null), new CTypes.type(
12247: new CTypes.LabelT(name), null,
12248: null, null, null, null, val,
12249: null, null, null, null),
12250: getNameSpace);
12251: }
12252:
12253: public Object apply() {
12254: return Analyzer.cast(define_labels
12255: .apply(xs, val));
12256: }
12257: }.apply());
12258: }
12259: return null;
12260: }
12261: }.apply();
12262: }
12263: };
12264:
12265: final Function.F2<CTypes.type, CTypes.type, Node> processArray = new Function.F2<CTypes.type, CTypes.type, Node>() {
12266: public CTypes.type apply(final CTypes.type t, final Node n) {
12267: return (null == Primitives.isBottom.apply(n) ? null
12268: : Primitives.isBottom.apply(n) ? new CTypes.type(
12269: new CTypes.ArrayT(t,
12270: new CTypes.Incomplete()), null,
12271: null == t ? null : t.storage, null, null,
12272: null, null, null, null, null, null)
12273: : new Match<CTypes.type>() {
12274: public CTypes.type apply() {
12275: final Node arg$1225 = GNode.cast(n);
12276:
12277: if ((null == arg$1225)) {
12278: return null;
12279: }
12280: if (CSupport.match$1226(arg$1225)) {
12281: matching_nodes.add(arg$1225);
12282: if ((null != arg$1225 && processScopeNodes
12283: .contains(arg$1225
12284: .getName()))) {
12285: processScope(arg$1225,
12286: getScope);
12287: }
12288: checkEnterScope(arg$1225);
12289:
12290: final Object retValue$1231 = Analyzer
12291: .cast(null == Primitives.isNotBottom
12292: .apply(ancestor
12293: .apply(CSupport.nodeMatch$301)) ? null
12294: : Primitives.isNotBottom
12295: .apply(ancestor
12296: .apply(CSupport.nodeMatch$301)) ? error(
12297: "'[*]' in non-parameter array declarator",
12298: n)
12299: : new CTypes.type(
12300: new CTypes.ArrayT(
12301: t,
12302: new CTypes.VarLength(
12303: new CTypes.Unknown())),
12304: null,
12305: null == t ? null
12306: : t.storage,
12307: null,
12308: null,
12309: null,
12310: null,
12311: null,
12312: null,
12313: null,
12314: null));
12315:
12316: checkExitScope(arg$1225);
12317: matching_nodes
12318: .remove(matching_nodes
12319: .size() - 1);
12320: return Analyzer
12321: .cast(retValue$1231);
12322: }
12323: if (true) {
12324: matching_nodes.add(arg$1225);
12325: if ((null != arg$1225 && processScopeNodes
12326: .contains(arg$1225
12327: .getName()))) {
12328: processScope(arg$1225,
12329: getScope);
12330: }
12331: checkEnterScope(arg$1225);
12332:
12333: final Object retValue$1234 = Analyzer
12334: .cast(new Let<CTypes.type>() {
12335: final CTypes.type st;
12336:
12337: {
12338: st = Analyzer
12339: .cast(analyze_expression
12340: .apply(n));
12341: }
12342:
12343: public CTypes.type apply() {
12344: return Analyzer
12345: .cast(null == Primitives.isBottom
12346: .apply(st) ? null
12347: : Primitives.isBottom
12348: .apply(st) ? null
12349: : new Let<CTypes.type>() {
12350: final BigInteger size;
12351:
12352: {
12353: ensure_integer
12354: .apply(
12355: st,
12356: "array index");
12357: size = Analyzer
12358: .cast(get_int
12359: .apply(st));
12360: }
12361:
12362: public CTypes.type apply() {
12363: return Analyzer
12364: .cast(new CTypes.type(
12365: new CTypes.ArrayT(
12366: t,
12367: new CTypes.Fixed(
12368: size)),
12369: null,
12370: null == t ? null
12371: : t.storage,
12372: null,
12373: null,
12374: null,
12375: null,
12376: null,
12377: null,
12378: null,
12379: null));
12380: }
12381: }
12382: .apply());
12383: }
12384: }.apply());
12385:
12386: checkExitScope(arg$1225);
12387: matching_nodes
12388: .remove(matching_nodes
12389: .size() - 1);
12390: return Analyzer
12391: .cast(retValue$1234);
12392: }
12393: return null;
12394: }
12395: }.apply());
12396: }
12397: };
12398:
12399: final Function.F1<Boolean, CTypes.type> zero = new Function.F1<Boolean, CTypes.type>() {
12400: public Boolean apply(final CTypes.type t) {
12401: return (null == Primitives.isBottom.apply(null == t ? null
12402: : t.value) ? null : Primitives.isBottom
12403: .apply(null == t ? null : t.value) ? Boolean.FALSE
12404: : new Match<Boolean>() {
12405: public Boolean apply() {
12406: final CTypes.valueType arg$1236 = Analyzer
12407: .cast(null == t ? null : t.value);
12408:
12409: if ((null == arg$1236)) {
12410: return null;
12411: }
12412: if ((null != arg$1236))
12413: switch (arg$1236.tag()) {
12414: case FValue:
12415: if (CSupport.match$1238(arg$1236)) {
12416: return Analyzer
12417: .cast(null == Primitives.equal
12418: .apply(
12419: get_float
12420: .apply(t),
12421: new Double(
12422: 0.0)) ? null
12423: : Primitives.equal
12424: .apply(
12425: get_float
12426: .apply(t),
12427: new Double(
12428: 0.0)) ? Boolean.TRUE
12429: : Boolean.FALSE);
12430: }
12431: break;
12432: case IValue:
12433: if (CSupport.match$1237(arg$1236)) {
12434: return Analyzer
12435: .cast(null == Primitives.equal
12436: .apply(
12437: get_int
12438: .apply(t),
12439: BigInteger
12440: .valueOf(0)) ? null
12441: : Primitives.equal
12442: .apply(
12443: get_int
12444: .apply(t),
12445: BigInteger
12446: .valueOf(0)) ? Boolean.TRUE
12447: : Boolean.FALSE);
12448: }
12449: break;
12450: default:
12451: break;
12452: }
12453: ;
12454: if (true) {
12455: return Analyzer.cast(Boolean.FALSE);
12456: }
12457: return null;
12458: }
12459: }.apply());
12460: }
12461: };
12462:
12463: final Function.F2<Boolean, CTypes.type, CTypes.type> pointer_equals = new Function.F2<Boolean, CTypes.type, CTypes.type>() {
12464: public Boolean apply(final CTypes.type t1, final CTypes.type t2) {
12465: return type_match.apply(get_base.apply(t1), get_base
12466: .apply(t2));
12467: }
12468: };
12469:
12470: final Function.F2<Boolean, CTypes.type, CTypes.type> type_match = new Function.F2<Boolean, CTypes.type, CTypes.type>() {
12471: public Boolean apply(final CTypes.type t1, final CTypes.type t2) {
12472: return new Match<Boolean>() {
12473: public Boolean apply() {
12474: final Tuple.T2<CTypes.raw_type<?>, CTypes.raw_type<?>> arg$1240 = Analyzer
12475: .cast(new Tuple.T2<CTypes.raw_type<?>, CTypes.raw_type<?>>(
12476: null == t1 ? null : t1.type,
12477: null == t2 ? null : t2.type));
12478:
12479: if ((null == arg$1240)) {
12480: return null;
12481: }
12482: if (CSupport.match$1241(arg$1240)) {
12483: final String s1 = Analyzer.cast(arg$1240.get1()
12484: .getTuple().get1());
12485: final BigInteger i1 = Analyzer.cast(arg$1240
12486: .get1().getTuple().get2());
12487: final String s2 = Analyzer.cast(arg$1240.get2()
12488: .getTuple().get1());
12489: final BigInteger i2 = Analyzer.cast(arg$1240
12490: .get2().getTuple().get2());
12491:
12492: return Analyzer.cast(Primitives.and.apply(
12493: Primitives.equal.apply(s1, s2),
12494: Primitives.equal.apply(i1, i2)));
12495: }
12496: if (CSupport.match$1242(arg$1240)) {
12497: final String s1 = Analyzer.cast(arg$1240.get1()
12498: .getTuple().get1());
12499: final String s2 = Analyzer.cast(arg$1240.get2()
12500: .getTuple().get1());
12501:
12502: return Analyzer.cast(Primitives.equal.apply(s1,
12503: s2));
12504: }
12505: if (CSupport.match$1243(arg$1240)) {
12506: final CTypes.type tt1 = Analyzer.cast(arg$1240
12507: .get1().getTuple().get1());
12508: final CTypes.type tt2 = Analyzer.cast(arg$1240
12509: .get2().getTuple().get1());
12510:
12511: return Analyzer
12512: .cast(type_match.apply(tt1, tt2));
12513: }
12514: if (CSupport.match$1244(arg$1240)) {
12515: final CTypes.type r1 = Analyzer.cast(arg$1240
12516: .get1().getTuple().get1());
12517: final CTypes.type r2 = Analyzer.cast(arg$1240
12518: .get2().getTuple().get1());
12519:
12520: return Analyzer.cast(type_match.apply(r1, r2));
12521: }
12522: if (true) {
12523: return Analyzer.cast(Primitives.equal.apply(
12524: null == t1 ? null : t1.type,
12525: null == t2 ? null : t2.type));
12526: }
12527: return null;
12528: }
12529: }.apply();
12530: }
12531: };
12532:
12533: final Function.F1<CTypes.type, CTypes.type> get_base = new Function.F1<CTypes.type, CTypes.type>() {
12534: public CTypes.type apply(final CTypes.type t) {
12535: return new Match<CTypes.type>() {
12536: public CTypes.type apply() {
12537: final CTypes.raw_type<?> arg$1246 = Analyzer
12538: .cast(null == t ? null : t.type);
12539:
12540: if ((null == arg$1246)) {
12541: return null;
12542: }
12543: if ((null != arg$1246))
12544: switch (arg$1246.tag()) {
12545: case ArrayT:
12546: if (CSupport.match$1248(arg$1246)) {
12547: final CTypes.type t1 = Analyzer
12548: .cast(arg$1246.getTuple()
12549: .get1());
12550:
12551: return Analyzer.cast(t1);
12552: }
12553: break;
12554: case PointerType:
12555: if (CSupport.match$1247(arg$1246)) {
12556: final CTypes.type t1 = Analyzer
12557: .cast(arg$1246.getTuple()
12558: .get1());
12559:
12560: return Analyzer.cast(t1);
12561: }
12562: break;
12563: default:
12564: break;
12565: }
12566: ;
12567: if (true) {
12568: return Analyzer.cast(t);
12569: }
12570: return null;
12571: }
12572: }.apply();
12573: }
12574: };
12575:
12576: final Function.F2<CTypes.type, CTypes.type, String> get_member_type = new Function.F2<CTypes.type, CTypes.type, String>() {
12577: public CTypes.type apply(final CTypes.type t, final String s) {
12578: return new Match<CTypes.type>() {
12579: public CTypes.type apply() {
12580: final CTypes.raw_type<?> arg$1250 = Analyzer
12581: .cast(null == t ? null : t.type);
12582:
12583: if ((null == arg$1250)) {
12584: return null;
12585: }
12586: if ((null != arg$1250))
12587: switch (arg$1250.tag()) {
12588: case StructT:
12589: if (CSupport.match$298(arg$1250)) {
12590: final String sn = Analyzer
12591: .cast(arg$1250.getTuple()
12592: .get1());
12593: final Pair<CTypes.type> ml = Analyzer
12594: .cast(arg$1250.getTuple()
12595: .get3());
12596:
12597: return Analyzer
12598: .cast(null == Primitives.isBottom
12599: .apply(ml) ? null
12600: : Primitives.isBottom
12601: .apply(ml) ? new Let<CTypes.type>() {
12602: final CTypes.type ty;
12603:
12604: {
12605: ty = Analyzer
12606: .cast(Analyzer
12607: .cast(lookup2
12608: .apply(
12609: GNode
12610: .create(
12611: "StructureTypeReference",
12612: null,
12613: sn),
12614: getNameSpace)));
12615: }
12616:
12617: public CTypes.type apply() {
12618: return Analyzer
12619: .cast(new Match<CTypes.type>() {
12620: public CTypes.type apply() {
12621: final CTypes.raw_type<?> arg$1256 = Analyzer
12622: .cast(null == ty ? null
12623: : ty.type);
12624:
12625: if ((null == arg$1256)) {
12626: return null;
12627: }
12628: if ((null != arg$1256))
12629: switch (arg$1256
12630: .tag()) {
12631: case StructT:
12632: if (CSupport
12633: .match$298(arg$1256)) {
12634: final Pair<CTypes.type> ll = Analyzer
12635: .cast(arg$1256
12636: .getTuple()
12637: .get3());
12638:
12639: return Analyzer
12640: .cast(null == Primitives.isBottom
12641: .apply(ll) ? null
12642: : Primitives.isBottom
12643: .apply(ll) ? null
12644: : get_member_type_helper
12645: .apply(
12646: ll,
12647: s));
12648: }
12649: break;
12650: case UnionT:
12651: if (CSupport
12652: .match$905(arg$1256)) {
12653: final Pair<CTypes.type> ll = Analyzer
12654: .cast(arg$1256
12655: .getTuple()
12656: .get3());
12657:
12658: return Analyzer
12659: .cast(null == Primitives.isBottom
12660: .apply(ll) ? null
12661: : Primitives.isBottom
12662: .apply(ll) ? null
12663: : get_member_type_helper
12664: .apply(
12665: ll,
12666: s));
12667: }
12668: break;
12669: default:
12670: break;
12671: }
12672: ;
12673: if (true) {
12674: return Analyzer
12675: .cast(null);
12676: }
12677: return null;
12678: }
12679: }
12680: .apply());
12681: }
12682: }.apply()
12683: : get_member_type_helper
12684: .apply(
12685: ml,
12686: s));
12687: }
12688: break;
12689: case UnionT:
12690: if (CSupport.match$905(arg$1250)) {
12691: final String sn = Analyzer
12692: .cast(arg$1250.getTuple()
12693: .get1());
12694: final Pair<CTypes.type> ml = Analyzer
12695: .cast(arg$1250.getTuple()
12696: .get3());
12697:
12698: return Analyzer
12699: .cast(null == Primitives.isBottom
12700: .apply(ml) ? null
12701: : Primitives.isBottom
12702: .apply(ml) ? new Let<CTypes.type>() {
12703: final CTypes.type ty;
12704:
12705: {
12706: ty = Analyzer
12707: .cast(Analyzer
12708: .cast(lookup2
12709: .apply(
12710: GNode
12711: .create(
12712: "StructureTypeReference",
12713: null,
12714: sn),
12715: getNameSpace)));
12716: }
12717:
12718: public CTypes.type apply() {
12719: return Analyzer
12720: .cast(new Match<CTypes.type>() {
12721: public CTypes.type apply() {
12722: final CTypes.raw_type<?> arg$1265 = Analyzer
12723: .cast(null == ty ? null
12724: : ty.type);
12725:
12726: if ((null == arg$1265)) {
12727: return null;
12728: }
12729: if ((null != arg$1265))
12730: switch (arg$1265
12731: .tag()) {
12732: case StructT:
12733: if (CSupport
12734: .match$298(arg$1265)) {
12735: final Pair<CTypes.type> ll = Analyzer
12736: .cast(arg$1265
12737: .getTuple()
12738: .get3());
12739:
12740: return Analyzer
12741: .cast(null == Primitives.isBottom
12742: .apply(ll) ? null
12743: : Primitives.isBottom
12744: .apply(ll) ? null
12745: : get_member_type_helper
12746: .apply(
12747: ll,
12748: s));
12749: }
12750: break;
12751: case UnionT:
12752: if (CSupport
12753: .match$905(arg$1265)) {
12754: final Pair<CTypes.type> ll = Analyzer
12755: .cast(arg$1265
12756: .getTuple()
12757: .get3());
12758:
12759: return Analyzer
12760: .cast(null == Primitives.isBottom
12761: .apply(ll) ? null
12762: : Primitives.isBottom
12763: .apply(ll) ? null
12764: : get_member_type_helper
12765: .apply(
12766: ll,
12767: s));
12768: }
12769: break;
12770: default:
12771: break;
12772: }
12773: ;
12774: if (true) {
12775: return Analyzer
12776: .cast(null);
12777: }
12778: return null;
12779: }
12780: }
12781: .apply());
12782: }
12783: }.apply()
12784: : get_member_type_helper
12785: .apply(
12786: ml,
12787: s));
12788: }
12789: break;
12790: default:
12791: break;
12792: }
12793: ;
12794: if (true) {
12795: return Analyzer.cast(null);
12796: }
12797: return null;
12798: }
12799: }.apply();
12800: }
12801: };
12802:
12803: final Function.F2<CTypes.type, Pair<CTypes.type>, String> get_member_type_helper = new Function.F2<CTypes.type, Pair<CTypes.type>, String>() {
12804: public CTypes.type apply(final Pair<CTypes.type> tl,
12805: final String s) {
12806: return new Match<CTypes.type>() {
12807: public CTypes.type apply() {
12808: final Pair<CTypes.type> arg$1270 = Analyzer
12809: .cast(tl);
12810:
12811: if ((null == arg$1270)) {
12812: return null;
12813: }
12814: if (CSupport.match$1212(arg$1270)) {
12815: return Analyzer.cast(null);
12816: }
12817: if (true) {
12818: final Pair<CTypes.type> list$1272 = Analyzer
12819: .cast(Analyzer.cast(arg$1270));
12820: final CTypes.type x = Analyzer.cast(Primitives
12821: .wrapHead(list$1272));
12822: final Pair<CTypes.type> xs = Analyzer
12823: .cast(Primitives.wrapTail(list$1272));
12824:
12825: return Analyzer.cast(new Match<CTypes.type>() {
12826: public CTypes.type apply() {
12827: final CTypes.raw_type<?> arg$1276 = Analyzer
12828: .cast(null == x ? null : x.type);
12829:
12830: if ((null == arg$1276)) {
12831: return null;
12832: }
12833: if ((null != arg$1276))
12834: switch (arg$1276.tag()) {
12835: case MemberT:
12836: if (CSupport
12837: .match$1274(arg$1276)) {
12838: final String str = Analyzer
12839: .cast(arg$1276
12840: .getTuple()
12841: .get1());
12842: final CTypes.type mt = Analyzer
12843: .cast(arg$1276
12844: .getTuple()
12845: .get2());
12846:
12847: return Analyzer
12848: .cast(null == Primitives.equal
12849: .apply(str,
12850: s) ? null
12851: : Primitives.equal
12852: .apply(
12853: str,
12854: s) ? mt
12855: : get_member_type_helper
12856: .apply(
12857: xs,
12858: s));
12859: }
12860: break;
12861: default:
12862: break;
12863: }
12864: ;
12865: if (true) {
12866: return Analyzer.cast(null);
12867: }
12868: return null;
12869: }
12870: }.apply());
12871: }
12872: return null;
12873: }
12874: }.apply();
12875: }
12876: };
12877:
12878: final Function.F1<Pair<CTypes.type>, CTypes.type> getParameterTypes = new Function.F1<Pair<CTypes.type>, CTypes.type>() {
12879: public Pair<CTypes.type> apply(final CTypes.type t) {
12880: return new Match<Pair<CTypes.type>>() {
12881: public Pair<CTypes.type> apply() {
12882: final CTypes.raw_type<?> arg$1280 = Analyzer
12883: .cast(null == t ? null : t.type);
12884:
12885: if ((null == arg$1280)) {
12886: return null;
12887: }
12888: if ((null != arg$1280))
12889: switch (arg$1280.tag()) {
12890: case PointerType:
12891: if (CSupport.match$1247(arg$1280)) {
12892: final CTypes.type ty = Analyzer
12893: .cast(arg$1280.getTuple()
12894: .get1());
12895:
12896: return Analyzer.cast(getParameterTypes
12897: .apply(ty));
12898: }
12899: break;
12900: case FunctionT:
12901: if (CSupport.match$1281(arg$1280)) {
12902: final Pair<CTypes.type> l = Analyzer
12903: .cast(arg$1280.getTuple()
12904: .get2());
12905:
12906: return Analyzer.cast(l);
12907: }
12908: break;
12909: default:
12910: break;
12911: }
12912: ;
12913: if (true) {
12914: return Analyzer.cast(error(
12915: "function type required", null));
12916: }
12917: return null;
12918: }
12919: }.apply();
12920: }
12921: };
12922:
12923: final Function.F1<BigInteger, CTypes.type> get_int = new Function.F1<BigInteger, CTypes.type>() {
12924: public BigInteger apply(final CTypes.type t) {
12925: return new Match<BigInteger>() {
12926: public BigInteger apply() {
12927: final CTypes.valueType arg$1284 = Analyzer
12928: .cast(null == t ? null : t.value);
12929:
12930: if ((null == arg$1284)) {
12931: return null;
12932: }
12933: if ((null != arg$1284))
12934: switch (arg$1284.tag()) {
12935: case IValue:
12936: if (CSupport.match$1237(arg$1284)) {
12937: final BigInteger i = Analyzer
12938: .cast(arg$1284.getTuple()
12939: .get1());
12940:
12941: return Analyzer.cast(i);
12942: }
12943: break;
12944: default:
12945: break;
12946: }
12947: ;
12948: if (true) {
12949: return Analyzer.cast(null);
12950: }
12951: return null;
12952: }
12953: }.apply();
12954: }
12955: };
12956:
12957: final Function.F1<Double, CTypes.type> get_float = new Function.F1<Double, CTypes.type>() {
12958: public Double apply(final CTypes.type t) {
12959: return new Match<Double>() {
12960: public Double apply() {
12961: final CTypes.valueType arg$1287 = Analyzer
12962: .cast(null == t ? null : t.value);
12963:
12964: if ((null == arg$1287)) {
12965: return null;
12966: }
12967: if ((null != arg$1287))
12968: switch (arg$1287.tag()) {
12969: case FValue:
12970: if (CSupport.match$1238(arg$1287)) {
12971: final Double f = Analyzer.cast(arg$1287
12972: .getTuple().get1());
12973:
12974: return Analyzer.cast(f);
12975: }
12976: break;
12977: default:
12978: break;
12979: }
12980: ;
12981: if (true) {
12982: return Analyzer.cast(null);
12983: }
12984: return null;
12985: }
12986: }.apply();
12987: }
12988: };
12989:
12990: final Function.F1<Boolean, CTypes.type> is_auto = new Function.F1<Boolean, CTypes.type>() {
12991: public Boolean apply(final CTypes.type t) {
12992: return (null == Primitives.isBottom.apply(null == t ? null
12993: : t.storage) ? null : Primitives.isBottom
12994: .apply(null == t ? null : t.storage) ? Boolean.TRUE
12995: : new Match<Boolean>() {
12996: public Boolean apply() {
12997: final CTypes.storageClass arg$1290 = Analyzer
12998: .cast(null == t ? null : t.storage);
12999:
13000: if ((null == arg$1290)) {
13001: return null;
13002: }
13003: if ((null != arg$1290))
13004: switch (arg$1290.tag()) {
13005: case StaticS:
13006: if (CSupport.match$1292(arg$1290)) {
13007: return Analyzer
13008: .cast(Boolean.FALSE);
13009: }
13010: break;
13011: case ExternS:
13012: if (CSupport.match$1291(arg$1290)) {
13013: return Analyzer
13014: .cast(Boolean.FALSE);
13015: }
13016: break;
13017: default:
13018: break;
13019: }
13020: ;
13021: if (true) {
13022: return Analyzer.cast(Boolean.TRUE);
13023: }
13024: return null;
13025: }
13026: }.apply());
13027: }
13028: };
13029:
13030: final Function.F1<Boolean, CTypes.type> has_auto = new Function.F1<Boolean, CTypes.type>() {
13031: public Boolean apply(final CTypes.type t) {
13032: return (null == Primitives.isBottom.apply(null == t ? null
13033: : t.storage) ? null
13034: : Primitives.isBottom.apply(null == t ? null
13035: : t.storage) ? Boolean.FALSE
13036: : new Match<Boolean>() {
13037: public Boolean apply() {
13038: final CTypes.storageClass arg$1294 = Analyzer
13039: .cast(null == t ? null
13040: : t.storage);
13041:
13042: if ((null == arg$1294)) {
13043: return null;
13044: }
13045: if ((null != arg$1294))
13046: switch (arg$1294.tag()) {
13047: case AutoS:
13048: if (CSupport
13049: .match$1295(arg$1294)) {
13050: return Analyzer
13051: .cast(Boolean.TRUE);
13052: }
13053: break;
13054: default:
13055: break;
13056: }
13057: ;
13058: if (true) {
13059: return Analyzer
13060: .cast(Boolean.FALSE);
13061: }
13062: return null;
13063: }
13064: }.apply());
13065: }
13066: };
13067:
13068: final Function.F1<Boolean, CTypes.type> is_register = new Function.F1<Boolean, CTypes.type>() {
13069: public Boolean apply(final CTypes.type t) {
13070: return (null == Primitives.isBottom.apply(null == t ? null
13071: : t.storage) ? null
13072: : Primitives.isBottom.apply(null == t ? null
13073: : t.storage) ? Boolean.FALSE
13074: : new Match<Boolean>() {
13075: public Boolean apply() {
13076: final CTypes.storageClass arg$1297 = Analyzer
13077: .cast(null == t ? null
13078: : t.storage);
13079:
13080: if ((null == arg$1297)) {
13081: return null;
13082: }
13083: if ((null != arg$1297))
13084: switch (arg$1297.tag()) {
13085: case RegisterS:
13086: if (CSupport
13087: .match$1298(arg$1297)) {
13088: return Analyzer
13089: .cast(Boolean.TRUE);
13090: }
13091: break;
13092: default:
13093: break;
13094: }
13095: ;
13096: if (true) {
13097: return Analyzer
13098: .cast(Boolean.FALSE);
13099: }
13100: return null;
13101: }
13102: }.apply());
13103: }
13104: };
13105:
13106: final Function.F1<Boolean, CTypes.type> is_typedef = new Function.F1<Boolean, CTypes.type>() {
13107: public Boolean apply(final CTypes.type t) {
13108: return (null == Primitives.isBottom.apply(null == t ? null
13109: : t.storage) ? null
13110: : Primitives.isBottom.apply(null == t ? null
13111: : t.storage) ? Boolean.FALSE
13112: : new Match<Boolean>() {
13113: public Boolean apply() {
13114: final CTypes.storageClass arg$1300 = Analyzer
13115: .cast(null == t ? null
13116: : t.storage);
13117:
13118: if ((null == arg$1300)) {
13119: return null;
13120: }
13121: if ((null != arg$1300))
13122: switch (arg$1300.tag()) {
13123: case TypedefS:
13124: if (CSupport
13125: .match$1301(arg$1300)) {
13126: return Analyzer
13127: .cast(Boolean.TRUE);
13128: }
13129: break;
13130: default:
13131: break;
13132: }
13133: ;
13134: if (true) {
13135: return Analyzer
13136: .cast(Boolean.FALSE);
13137: }
13138: return null;
13139: }
13140: }.apply());
13141: }
13142: };
13143:
13144: final Function.F1<Boolean, CTypes.type> is_extern = new Function.F1<Boolean, CTypes.type>() {
13145: public Boolean apply(final CTypes.type t) {
13146: return (null == Primitives.isBottom.apply(null == t ? null
13147: : t.storage) ? null
13148: : Primitives.isBottom.apply(null == t ? null
13149: : t.storage) ? Boolean.FALSE
13150: : new Match<Boolean>() {
13151: public Boolean apply() {
13152: final CTypes.storageClass arg$1303 = Analyzer
13153: .cast(null == t ? null
13154: : t.storage);
13155:
13156: if ((null == arg$1303)) {
13157: return null;
13158: }
13159: if ((null != arg$1303))
13160: switch (arg$1303.tag()) {
13161: case ExternS:
13162: if (CSupport
13163: .match$1291(arg$1303)) {
13164: return Analyzer
13165: .cast(Boolean.TRUE);
13166: }
13167: break;
13168: default:
13169: break;
13170: }
13171: ;
13172: if (true) {
13173: return Analyzer
13174: .cast(Boolean.FALSE);
13175: }
13176: return null;
13177: }
13178: }.apply());
13179: }
13180: };
13181:
13182: final Function.F1<Boolean, CTypes.type> is_static = new Function.F1<Boolean, CTypes.type>() {
13183: public Boolean apply(final CTypes.type t) {
13184: return (null == Primitives.isBottom.apply(null == t ? null
13185: : t.storage) ? null
13186: : Primitives.isBottom.apply(null == t ? null
13187: : t.storage) ? Boolean.FALSE
13188: : new Match<Boolean>() {
13189: public Boolean apply() {
13190: final CTypes.storageClass arg$1306 = Analyzer
13191: .cast(null == t ? null
13192: : t.storage);
13193:
13194: if ((null == arg$1306)) {
13195: return null;
13196: }
13197: if ((null != arg$1306))
13198: switch (arg$1306.tag()) {
13199: case StaticS:
13200: if (CSupport
13201: .match$1292(arg$1306)) {
13202: return Analyzer
13203: .cast(Boolean.TRUE);
13204: }
13205: break;
13206: default:
13207: break;
13208: }
13209: ;
13210: if (true) {
13211: return Analyzer
13212: .cast(Boolean.FALSE);
13213: }
13214: return null;
13215: }
13216: }.apply());
13217: }
13218: };
13219:
13220: final Function.F1<Boolean, CTypes.type> is_integer = new Function.F1<Boolean, CTypes.type>() {
13221: public Boolean apply(final CTypes.type t) {
13222: return new Match<Boolean>() {
13223: public Boolean apply() {
13224: final CTypes.raw_type<?> arg$1309 = Analyzer
13225: .cast(null == t ? null : t.type);
13226:
13227: if ((null == arg$1309)) {
13228: return null;
13229: }
13230: if ((null != arg$1309))
13231: switch (arg$1309.tag()) {
13232: case BitfieldT:
13233: if (CSupport.match$1322(arg$1309)) {
13234: return Analyzer.cast(Boolean.TRUE);
13235: }
13236: break;
13237: case UIntT:
13238: if (CSupport.match$1316(arg$1309)) {
13239: return Analyzer.cast(Boolean.TRUE);
13240: }
13241: break;
13242: case ShortT:
13243: if (CSupport.match$1314(arg$1309)) {
13244: return Analyzer.cast(Boolean.TRUE);
13245: }
13246: break;
13247: case IntT:
13248: if (CSupport.match$1317(arg$1309)) {
13249: return Analyzer.cast(Boolean.TRUE);
13250: }
13251: break;
13252: case LongT:
13253: if (CSupport.match$1319(arg$1309)) {
13254: return Analyzer.cast(Boolean.TRUE);
13255: }
13256: break;
13257: case SCharT:
13258: if (CSupport.match$1312(arg$1309)) {
13259: return Analyzer.cast(Boolean.TRUE);
13260: }
13261: break;
13262: case CharT:
13263: if (CSupport.match$1310(arg$1309)) {
13264: return Analyzer.cast(Boolean.TRUE);
13265: }
13266: break;
13267: case LongLongT:
13268: if (CSupport.match$1321(arg$1309)) {
13269: return Analyzer.cast(Boolean.TRUE);
13270: }
13271: break;
13272: case EnumT:
13273: if (CSupport.match$1323(arg$1309)) {
13274: return Analyzer.cast(Boolean.TRUE);
13275: }
13276: break;
13277: case UShortT:
13278: if (CSupport.match$1315(arg$1309)) {
13279: return Analyzer.cast(Boolean.TRUE);
13280: }
13281: break;
13282: case ULongLongT:
13283: if (CSupport.match$1320(arg$1309)) {
13284: return Analyzer.cast(Boolean.TRUE);
13285: }
13286: break;
13287: case BoolT:
13288: if (CSupport.match$1313(arg$1309)) {
13289: return Analyzer.cast(Boolean.TRUE);
13290: }
13291: break;
13292: case ULongT:
13293: if (CSupport.match$1318(arg$1309)) {
13294: return Analyzer.cast(Boolean.TRUE);
13295: }
13296: break;
13297: case UCharT:
13298: if (CSupport.match$1311(arg$1309)) {
13299: return Analyzer.cast(Boolean.TRUE);
13300: }
13301: break;
13302: default:
13303: break;
13304: }
13305: ;
13306: if (true) {
13307: return Analyzer.cast(Boolean.FALSE);
13308: }
13309: return null;
13310: }
13311: }.apply();
13312: }
13313: };
13314:
13315: final Function.F1<Boolean, CTypes.type> is_char = new Function.F1<Boolean, CTypes.type>() {
13316: public Boolean apply(final CTypes.type t) {
13317: return new Match<Boolean>() {
13318: public Boolean apply() {
13319: final CTypes.raw_type<?> arg$1325 = Analyzer
13320: .cast(null == t ? null : t.type);
13321:
13322: if ((null == arg$1325)) {
13323: return null;
13324: }
13325: if ((null != arg$1325))
13326: switch (arg$1325.tag()) {
13327: case SCharT:
13328: if (CSupport.match$1312(arg$1325)) {
13329: return Analyzer.cast(Boolean.TRUE);
13330: }
13331: break;
13332: case CharT:
13333: if (CSupport.match$1310(arg$1325)) {
13334: return Analyzer.cast(Boolean.TRUE);
13335: }
13336: break;
13337: case UCharT:
13338: if (CSupport.match$1311(arg$1325)) {
13339: return Analyzer.cast(Boolean.TRUE);
13340: }
13341: break;
13342: default:
13343: break;
13344: }
13345: ;
13346: if (true) {
13347: return Analyzer.cast(Boolean.FALSE);
13348: }
13349: return null;
13350: }
13351: }.apply();
13352: }
13353: };
13354:
13355: final Function.F1<Boolean, CTypes.type> is_bitfield = new Function.F1<Boolean, CTypes.type>() {
13356: public Boolean apply(final CTypes.type t) {
13357: return (null == Primitives.isBottom.apply(null == t ? null
13358: : t.type) ? null : Primitives.isBottom
13359: .apply(null == t ? null : t.type) ? Boolean.FALSE
13360: : new Match<Boolean>() {
13361: public Boolean apply() {
13362: final CTypes.raw_type<?> arg$1330 = Analyzer
13363: .cast(null == t ? null : t.type);
13364:
13365: if ((null == arg$1330)) {
13366: return null;
13367: }
13368: if ((null != arg$1330))
13369: switch (arg$1330.tag()) {
13370: case BitfieldT:
13371: if (CSupport.match$1322(arg$1330)) {
13372: return Analyzer
13373: .cast(Boolean.TRUE);
13374: }
13375: break;
13376: case MemberT:
13377: if (CSupport.match$1274(arg$1330)) {
13378: final CTypes.type ty = Analyzer
13379: .cast(arg$1330
13380: .getTuple()
13381: .get2());
13382:
13383: return Analyzer
13384: .cast(is_bitfield
13385: .apply(ty));
13386: }
13387: break;
13388: default:
13389: break;
13390: }
13391: ;
13392: if (true) {
13393: return Analyzer.cast(Boolean.FALSE);
13394: }
13395: return null;
13396: }
13397: }.apply());
13398: }
13399: };
13400:
13401: final Function.F2<CTypes.type, CTypes.type, String> ensure_integer = new Function.F2<CTypes.type, CTypes.type, String>() {
13402: public CTypes.type apply(final CTypes.type t, final String op) {
13403: return (null == Primitives.or.apply(Primitives.or.apply(
13404: Primitives.isBottom.apply(t), Primitives.isBottom
13405: .apply(null == t ? null : t.type)),
13406: is_integer.apply(t)) ? null
13407: : Primitives.or.apply(Primitives.or.apply(
13408: Primitives.isBottom.apply(t),
13409: Primitives.isBottom.apply(null == t ? null
13410: : t.type)), is_integer.apply(t)) ? t
13411: : new Let<CTypes.type>() {
13412: {
13413: error(
13414: Primitives.concat
13415: .apply(
13416: "integer required in ",
13417: op), null);
13418: }
13419:
13420: public CTypes.type apply() {
13421: return Analyzer.cast(t);
13422: }
13423: }.apply());
13424: }
13425: };
13426:
13427: final Function.F1<Boolean, CTypes.type> is_qualified = new Function.F1<Boolean, CTypes.type>() {
13428: public Boolean apply(final CTypes.type t) {
13429: return (null == Primitives.isBottom.apply(null == t ? null
13430: : t.qualifiers) ? null
13431: : Primitives.isBottom.apply(null == t ? null
13432: : t.qualifiers) ? Boolean.FALSE
13433: : null == Primitives.greaterInt.apply(
13434: Primitives.length
13435: .apply(null == t ? null
13436: : t.qualifiers),
13437: BigInteger.valueOf(0)) ? null
13438: : Primitives.greaterInt
13439: .apply(
13440: Primitives.length
13441: .apply(null == t ? null
13442: : t.qualifiers),
13443: BigInteger
13444: .valueOf(0)) ? Boolean.TRUE
13445: : Boolean.FALSE);
13446: }
13447: };
13448:
13449: final Function.F1<Boolean, CTypes.type> is_float = new Function.F1<Boolean, CTypes.type>() {
13450: public Boolean apply(final CTypes.type t) {
13451: return new Match<Boolean>() {
13452: public Boolean apply() {
13453: final CTypes.raw_type<?> arg$1334 = Analyzer
13454: .cast(null == t ? null : t.type);
13455:
13456: if ((null == arg$1334)) {
13457: return null;
13458: }
13459: if ((null != arg$1334))
13460: switch (arg$1334.tag()) {
13461: case DoubleT:
13462: if (CSupport.match$1336(arg$1334)) {
13463: return Analyzer.cast(Boolean.TRUE);
13464: }
13465: break;
13466: case LongDoubleT:
13467: if (CSupport.match$1337(arg$1334)) {
13468: return Analyzer.cast(Boolean.TRUE);
13469: }
13470: break;
13471: case FloatT:
13472: if (CSupport.match$1335(arg$1334)) {
13473: return Analyzer.cast(Boolean.TRUE);
13474: }
13475: break;
13476: default:
13477: break;
13478: }
13479: ;
13480: if (true) {
13481: return Analyzer.cast(Boolean.FALSE);
13482: }
13483: return null;
13484: }
13485: }.apply();
13486: }
13487: };
13488:
13489: final Function.F1<Boolean, CTypes.type> is_arithmetic = new Function.F1<Boolean, CTypes.type>() {
13490: public Boolean apply(final CTypes.type t) {
13491: return Primitives.or.apply(Primitives.or.apply(is_integer
13492: .apply(t), is_float.apply(t)), is_complex.apply(t));
13493: }
13494: };
13495:
13496: final Function.F1<Boolean, CTypes.type> is_complex = new Function.F1<Boolean, CTypes.type>() {
13497: public Boolean apply(final CTypes.type t) {
13498: return new Match<Boolean>() {
13499: public Boolean apply() {
13500: final CTypes.raw_type<?> arg$1339 = Analyzer
13501: .cast(null == t ? null : t.type);
13502:
13503: if ((null == arg$1339)) {
13504: return null;
13505: }
13506: if ((null != arg$1339))
13507: switch (arg$1339.tag()) {
13508: case DoubleComplexT:
13509: if (CSupport.match$1341(arg$1339)) {
13510: return Analyzer.cast(Boolean.TRUE);
13511: }
13512: break;
13513: case ComplexT:
13514: if (CSupport.match$1343(arg$1339)) {
13515: return Analyzer.cast(Boolean.TRUE);
13516: }
13517: break;
13518: case FloatComplexT:
13519: if (CSupport.match$1340(arg$1339)) {
13520: return Analyzer.cast(Boolean.TRUE);
13521: }
13522: break;
13523: case LongDoubleComplexT:
13524: if (CSupport.match$1342(arg$1339)) {
13525: return Analyzer.cast(Boolean.TRUE);
13526: }
13527: break;
13528: default:
13529: break;
13530: }
13531: ;
13532: if (true) {
13533: return Analyzer.cast(Boolean.FALSE);
13534: }
13535: return null;
13536: }
13537: }.apply();
13538: }
13539: };
13540:
13541: final Function.F2<CTypes.type, CTypes.type, String> ensure_arithmetic = new Function.F2<CTypes.type, CTypes.type, String>() {
13542: public CTypes.type apply(final CTypes.type t, final String op) {
13543: return new Let<CTypes.type>() {
13544: {
13545: new Guard<Boolean>() {
13546: public Boolean apply() {
13547: if ((null == t)) {
13548: return null;
13549: }
13550: if ((null == is_arithmetic)) {
13551: return null;
13552: }
13553:
13554: final Boolean result$1345 = is_arithmetic
13555: .apply(t);
13556:
13557: if ((null == result$1345)) {
13558: return Analyzer
13559: .cast(error(
13560: Primitives.concat
13561: .apply(
13562: "arithmetic value required in ",
13563: op),
13564: null));
13565: }
13566: return result$1345;
13567: }
13568: }.apply();
13569: }
13570:
13571: public CTypes.type apply() {
13572: return Analyzer.cast(t);
13573: }
13574: }.apply();
13575: }
13576: };
13577:
13578: final Function.F1<Boolean, CTypes.type> is_scalar = new Function.F1<Boolean, CTypes.type>() {
13579: public Boolean apply(final CTypes.type t) {
13580: return Primitives.or.apply(Primitives.or.apply(
13581: is_arithmetic.apply(t), is_pointer.apply(t)),
13582: is_array.apply(t));
13583: }
13584: };
13585:
13586: final Function.F2<CTypes.type, CTypes.type, String> ensure_scalar = new Function.F2<CTypes.type, CTypes.type, String>() {
13587: public CTypes.type apply(final CTypes.type t, final String op) {
13588: return (null == Primitives.or.apply(Primitives.or.apply(
13589: Primitives.isBottom.apply(t), Primitives.isBottom
13590: .apply(null == t ? null : t.type)),
13591: is_scalar.apply(t)) ? null : Primitives.or.apply(
13592: Primitives.or.apply(Primitives.isBottom.apply(t),
13593: Primitives.isBottom.apply(null == t ? null
13594: : t.type)), is_scalar.apply(t)) ? t
13595: : new Let<CTypes.type>() {
13596: {
13597: error(Primitives.concat.apply(
13598: "scalar required in ", op), null);
13599: }
13600:
13601: public CTypes.type apply() {
13602: return Analyzer.cast(t);
13603: }
13604: }.apply());
13605: }
13606: };
13607:
13608: final Function.F1<Boolean, CTypes.type> is_pointer = new Function.F1<Boolean, CTypes.type>() {
13609: public Boolean apply(final CTypes.type t) {
13610: return new Match<Boolean>() {
13611: public Boolean apply() {
13612: final CTypes.raw_type<?> arg$1346 = Analyzer
13613: .cast(null == t ? null : t.type);
13614:
13615: if ((null == arg$1346)) {
13616: return null;
13617: }
13618: if ((null != arg$1346))
13619: switch (arg$1346.tag()) {
13620: case PointerType:
13621: if (CSupport.match$1247(arg$1346)) {
13622: return Analyzer.cast(Boolean.TRUE);
13623: }
13624: break;
13625: default:
13626: break;
13627: }
13628: ;
13629: if (true) {
13630: return Analyzer.cast(Boolean.FALSE);
13631: }
13632: return null;
13633: }
13634: }.apply();
13635: }
13636: };
13637:
13638: final Function.F1<CTypes.type, CTypes.type> to_pointer = new Function.F1<CTypes.type, CTypes.type>() {
13639: public CTypes.type apply(final CTypes.type t) {
13640: return new Match<CTypes.type>() {
13641: public CTypes.type apply() {
13642: final CTypes.raw_type<?> arg$1349 = Analyzer
13643: .cast(null == t ? null : t.type);
13644:
13645: if ((null == arg$1349)) {
13646: return null;
13647: }
13648: if ((null != arg$1349))
13649: switch (arg$1349.tag()) {
13650: case ArrayT:
13651: if (CSupport.match$1248(arg$1349)) {
13652: return Analyzer.cast(new CTypes.type(
13653: new CTypes.PointerType(get_base
13654: .apply(t)), null, null,
13655: null, null, null, null, null,
13656: null, null, null));
13657: }
13658: break;
13659: case PointerType:
13660: if (CSupport.match$1247(arg$1349)) {
13661: return Analyzer.cast(t);
13662: }
13663: break;
13664: default:
13665: break;
13666: }
13667: ;
13668: if (true) {
13669: return Analyzer.cast(null);
13670: }
13671: return null;
13672: }
13673: }.apply();
13674: }
13675: };
13676:
13677: final Function.F1<Boolean, CTypes.type> is_array = new Function.F1<Boolean, CTypes.type>() {
13678: public Boolean apply(final CTypes.type t) {
13679: return new Match<Boolean>() {
13680: public Boolean apply() {
13681: final CTypes.raw_type<?> arg$1353 = Analyzer
13682: .cast(null == t ? null : t.type);
13683:
13684: if ((null == arg$1353)) {
13685: return null;
13686: }
13687: if ((null != arg$1353))
13688: switch (arg$1353.tag()) {
13689: case ArrayT:
13690: if (CSupport.match$1248(arg$1353)) {
13691: return Analyzer.cast(Boolean.TRUE);
13692: }
13693: break;
13694: default:
13695: break;
13696: }
13697: ;
13698: if (true) {
13699: return Analyzer.cast(Boolean.FALSE);
13700: }
13701: return null;
13702: }
13703: }.apply();
13704: }
13705: };
13706:
13707: final Function.F1<Boolean, CTypes.type> is_fixed = new Function.F1<Boolean, CTypes.type>() {
13708: public Boolean apply(final CTypes.type t) {
13709: return (null == Primitives.isBottom.apply(null == t ? null
13710: : t.type) ? null : Primitives.isBottom
13711: .apply(null == t ? null : t.type) ? Boolean.FALSE
13712: : new Match<Boolean>() {
13713: public Boolean apply() {
13714: final CTypes.raw_type<?> arg$1356 = Analyzer
13715: .cast(null == t ? null : t.type);
13716:
13717: if ((null == arg$1356)) {
13718: return null;
13719: }
13720: if ((null != arg$1356))
13721: switch (arg$1356.tag()) {
13722: case ArrayT:
13723: if (CSupport.match$1248(arg$1356)) {
13724: final CTypes.arraySize si = Analyzer
13725: .cast(arg$1356
13726: .getTuple()
13727: .get2());
13728:
13729: return Analyzer
13730: .cast(new Match<Boolean>() {
13731: public Boolean apply() {
13732: final CTypes.arraySize arg$1361 = Analyzer
13733: .cast(si);
13734:
13735: if ((null == arg$1361)) {
13736: return null;
13737: }
13738: if ((null != arg$1361))
13739: switch (arg$1361
13740: .tag()) {
13741: case Fixed:
13742: if (CSupport
13743: .match$1359(arg$1361)) {
13744: return Analyzer
13745: .cast(Boolean.TRUE);
13746: }
13747: break;
13748: default:
13749: break;
13750: }
13751: ;
13752: if (true) {
13753: return Analyzer
13754: .cast(Boolean.FALSE);
13755: }
13756: return null;
13757: }
13758: }.apply());
13759: }
13760: break;
13761: default:
13762: break;
13763: }
13764: ;
13765: if (true) {
13766: return Analyzer.cast(Boolean.FALSE);
13767: }
13768: return null;
13769: }
13770: }.apply());
13771: }
13772: };
13773:
13774: final Function.F1<Boolean, CTypes.type> ensure_function = new Function.F1<Boolean, CTypes.type>() {
13775: public Boolean apply(final CTypes.type t) {
13776: return new Guard<Boolean>() {
13777: public Boolean apply() {
13778: if ((null == is_function)) {
13779: return null;
13780: }
13781: if ((null == t)) {
13782: return null;
13783: }
13784:
13785: final Boolean result$1365 = is_function.apply(t);
13786:
13787: if ((null == result$1365)) {
13788: return Analyzer.cast(error(
13789: "function type required", null));
13790: }
13791: return result$1365;
13792: }
13793: }.apply();
13794: }
13795: };
13796:
13797: final Function.F1<Boolean, CTypes.type> is_function = new Function.F1<Boolean, CTypes.type>() {
13798: public Boolean apply(final CTypes.type t) {
13799: return (null == Primitives.isBottom.apply(null == t ? null
13800: : t.type) ? null : Primitives.isBottom
13801: .apply(null == t ? null : t.type) ? Boolean.FALSE
13802: : new Match<Boolean>() {
13803: public Boolean apply() {
13804: final CTypes.raw_type<?> arg$1366 = Analyzer
13805: .cast(null == t ? null : t.type);
13806:
13807: if ((null == arg$1366)) {
13808: return null;
13809: }
13810: if ((null != arg$1366))
13811: switch (arg$1366.tag()) {
13812: case FunctionT:
13813: if (CSupport.match$1281(arg$1366)) {
13814: return Analyzer
13815: .cast(Boolean.TRUE);
13816: }
13817: break;
13818: default:
13819: break;
13820: }
13821: ;
13822: if (true) {
13823: return Analyzer.cast(Boolean.FALSE);
13824: }
13825: return null;
13826: }
13827: }.apply());
13828: }
13829: };
13830:
13831: final Function.F1<Boolean, CTypes.type> is_const = new Function.F1<Boolean, CTypes.type>() {
13832: public Boolean apply(final CTypes.type t) {
13833: return new Let<Boolean>() {
13834: final Pair<CTypes.qualifier> quals;
13835:
13836: {
13837: quals = Analyzer.cast(null == t ? null
13838: : t.qualifiers);
13839: }
13840:
13841: public Boolean apply() {
13842: return Analyzer.cast(null == Primitives.isBottom
13843: .apply(quals) ? null : Primitives.isBottom
13844: .apply(quals) ? Boolean.FALSE
13845: : Primitives.contains.apply(
13846: new CTypes.ConstQ(), quals));
13847: }
13848: }.apply();
13849: }
13850: };
13851:
13852: final Function.F1<Boolean, CTypes.type> is_void = new Function.F1<Boolean, CTypes.type>() {
13853: public Boolean apply(final CTypes.type t) {
13854: return new Match<Boolean>() {
13855: public Boolean apply() {
13856: final CTypes.raw_type<?> arg$1369 = Analyzer
13857: .cast(null == t ? null : t.type);
13858:
13859: if ((null == arg$1369)) {
13860: return null;
13861: }
13862: if ((null != arg$1369))
13863: switch (arg$1369.tag()) {
13864: case VoidT:
13865: if (CSupport.match$408(arg$1369)) {
13866: return Analyzer.cast(Boolean.TRUE);
13867: }
13868: break;
13869: default:
13870: break;
13871: }
13872: ;
13873: if (true) {
13874: return Analyzer.cast(Boolean.FALSE);
13875: }
13876: return null;
13877: }
13878: }.apply();
13879: }
13880: };
13881:
13882: final Function.F1<Boolean, CTypes.type> is_lvalue = new Function.F1<Boolean, CTypes.type>() {
13883: public Boolean apply(final CTypes.type t) {
13884: return Primitives.and.apply(Primitives.not.apply(is_void
13885: .apply(t)), Primitives.not.apply(is_function
13886: .apply(t)));
13887: }
13888: };
13889:
13890: final Function.F1<Boolean, CTypes.type> is_modifiable_lvalue = new Function.F1<Boolean, CTypes.type>() {
13891: public Boolean apply(final CTypes.type t) {
13892: return Primitives.and.apply(is_lvalue.apply(t),
13893: Primitives.not.apply(is_const.apply(t)));
13894: }
13895: };
13896:
13897: final Function.F1<CTypes.type, CTypes.type> ensure_modifiable_lvalue = new Function.F1<CTypes.type, CTypes.type>() {
13898: public CTypes.type apply(final CTypes.type t) {
13899: return (null == Primitives.isBottom.apply(t) ? null
13900: : Primitives.isBottom.apply(t) ? t
13901: : null == Primitives.not
13902: .apply(is_modifiable_lvalue
13903: .apply(t))
13904: || !Primitives.not
13905: .apply(is_modifiable_lvalue
13906: .apply(t)) ? null
13907: : new Let<CTypes.type>() {
13908: {
13909: error(
13910: "modifiable lvalue required ",
13911: null);
13912: }
13913:
13914: public CTypes.type apply() {
13915: return Analyzer.cast(t);
13916: }
13917: }.apply());
13918: }
13919: };
13920:
13921: final Function.F1<Boolean, CTypes.type> is_aggregate = new Function.F1<Boolean, CTypes.type>() {
13922: public Boolean apply(final CTypes.type t) {
13923: return new Match<Boolean>() {
13924: public Boolean apply() {
13925: final CTypes.raw_type<?> arg$1372 = Analyzer
13926: .cast(null == t ? null : t.type);
13927:
13928: if ((null == arg$1372)) {
13929: return null;
13930: }
13931: if ((null != arg$1372))
13932: switch (arg$1372.tag()) {
13933: case StructT:
13934: if (CSupport.match$298(arg$1372)) {
13935: return Analyzer.cast(Boolean.TRUE);
13936: }
13937: break;
13938: case ArrayT:
13939: if (CSupport.match$1248(arg$1372)) {
13940: return Analyzer.cast(Boolean.TRUE);
13941: }
13942: break;
13943: case UnionT:
13944: if (CSupport.match$905(arg$1372)) {
13945: return Analyzer.cast(Boolean.TRUE);
13946: }
13947: break;
13948: default:
13949: break;
13950: }
13951: ;
13952: if (true) {
13953: return Analyzer.cast(Boolean.FALSE);
13954: }
13955: return null;
13956: }
13957: }.apply();
13958: }
13959: };
13960:
13961: final Function.F1<Boolean, CTypes.type> is_struct_union = new Function.F1<Boolean, CTypes.type>() {
13962: public Boolean apply(final CTypes.type t) {
13963: return new Match<Boolean>() {
13964: public Boolean apply() {
13965: final CTypes.raw_type<?> arg$1377 = Analyzer
13966: .cast(null == t ? null : t.type);
13967:
13968: if ((null == arg$1377)) {
13969: return null;
13970: }
13971: if ((null != arg$1377))
13972: switch (arg$1377.tag()) {
13973: case StructT:
13974: if (CSupport.match$298(arg$1377)) {
13975: return Analyzer.cast(Boolean.TRUE);
13976: }
13977: break;
13978: case UnionT:
13979: if (CSupport.match$905(arg$1377)) {
13980: return Analyzer.cast(Boolean.TRUE);
13981: }
13982: break;
13983: default:
13984: break;
13985: }
13986: ;
13987: if (true) {
13988: return Analyzer.cast(Boolean.FALSE);
13989: }
13990: return null;
13991: }
13992: }.apply();
13993: }
13994: };
13995:
13996: final Function.F1<Boolean, CTypes.type> is_enum = new Function.F1<Boolean, CTypes.type>() {
13997: public Boolean apply(final CTypes.type t) {
13998: return new Match<Boolean>() {
13999: public Boolean apply() {
14000: final CTypes.raw_type<?> arg$1381 = Analyzer
14001: .cast(null == t ? null : t.type);
14002:
14003: if ((null == arg$1381)) {
14004: return null;
14005: }
14006: if ((null != arg$1381))
14007: switch (arg$1381.tag()) {
14008: case EnumT:
14009: if (CSupport.match$1323(arg$1381)) {
14010: return Analyzer.cast(Boolean.TRUE);
14011: }
14012: break;
14013: default:
14014: break;
14015: }
14016: ;
14017: if (true) {
14018: return Analyzer.cast(Boolean.FALSE);
14019: }
14020: return null;
14021: }
14022: }.apply();
14023: }
14024: };
14025:
14026: final Function.F1<Boolean, CTypes.type> is_anonymous = new Function.F1<Boolean, CTypes.type>() {
14027: public Boolean apply(final CTypes.type t) {
14028: return (null == Primitives.isBottom.apply(null == t ? null
14029: : t.type) ? null : Primitives.isBottom
14030: .apply(null == t ? null : t.type) ? Boolean.FALSE
14031: : new Match<Boolean>() {
14032: public Boolean apply() {
14033: final CTypes.raw_type<?> arg$1384 = Analyzer
14034: .cast(null == t ? null : t.type);
14035:
14036: if ((null == arg$1384)) {
14037: return null;
14038: }
14039: if ((null != arg$1384))
14040: switch (arg$1384.tag()) {
14041: case StructT:
14042: if (CSupport.match$298(arg$1384)) {
14043: final String s = Analyzer
14044: .cast(arg$1384
14045: .getTuple()
14046: .get1());
14047:
14048: return Analyzer
14049: .cast(Primitives.startsWith
14050: .apply(s,
14051: "struct("));
14052: }
14053: break;
14054: case UnionT:
14055: if (CSupport.match$905(arg$1384)) {
14056: final String s = Analyzer
14057: .cast(arg$1384
14058: .getTuple()
14059: .get1());
14060:
14061: return Analyzer
14062: .cast(Primitives.startsWith
14063: .apply(s,
14064: "union("));
14065: }
14066: break;
14067: default:
14068: break;
14069: }
14070: ;
14071: if (true) {
14072: return Analyzer.cast(Boolean.FALSE);
14073: }
14074: return null;
14075: }
14076: }.apply());
14077: }
14078: };
14079:
14080: final Function.F1<Boolean, CTypes.type> is_complete = new Function.F1<Boolean, CTypes.type>() {
14081: public Boolean apply(final CTypes.type t) {
14082: return Primitives.not.apply(is_incomplete.apply(t));
14083: }
14084: };
14085:
14086: final Function.F1<CTypes.type, CTypes.type> ensure_complete = new Function.F1<CTypes.type, CTypes.type>() {
14087: public CTypes.type apply(final CTypes.type t) {
14088: return new Let<CTypes.type>() {
14089: {
14090: new Guard<Boolean>() {
14091: public Boolean apply() {
14092: if ((null == is_complete)) {
14093: return null;
14094: }
14095: if ((null == t)) {
14096: return null;
14097: }
14098:
14099: final Boolean result$1388 = is_complete
14100: .apply(t);
14101:
14102: if ((null == result$1388)) {
14103: return Analyzer
14104: .cast(error(
14105: "complete type required",
14106: null));
14107: }
14108: return result$1388;
14109: }
14110: }.apply();
14111: }
14112:
14113: public CTypes.type apply() {
14114: return Analyzer.cast(t);
14115: }
14116: }.apply();
14117: }
14118: };
14119:
14120: final Function.F1<CTypes.type, CTypes.type> get_return_type = new Function.F1<CTypes.type, CTypes.type>() {
14121: public CTypes.type apply(final CTypes.type t) {
14122: return new Match<CTypes.type>() {
14123: public CTypes.type apply() {
14124: final CTypes.raw_type<?> arg$1389 = Analyzer
14125: .cast(null == t ? null : t.type);
14126:
14127: if ((null == arg$1389)) {
14128: return null;
14129: }
14130: if ((null != arg$1389))
14131: switch (arg$1389.tag()) {
14132: case PointerType:
14133: if (CSupport.match$1247(arg$1389)) {
14134: final CTypes.type ty = Analyzer
14135: .cast(arg$1389.getTuple()
14136: .get1());
14137:
14138: return Analyzer.cast(get_return_type
14139: .apply(ty));
14140: }
14141: break;
14142: case FunctionT:
14143: if (CSupport.match$1281(arg$1389)) {
14144: final CTypes.type r = Analyzer
14145: .cast(arg$1389.getTuple()
14146: .get1());
14147:
14148: return Analyzer.cast(r);
14149: }
14150: break;
14151: default:
14152: break;
14153: }
14154: ;
14155: if (true) {
14156: return Analyzer.cast(null);
14157: }
14158: return null;
14159: }
14160: }.apply();
14161: }
14162: };
14163:
14164: final Function.F1<Boolean, CTypes.type> is_incomplete = new Function.F1<Boolean, CTypes.type>() {
14165: public Boolean apply(final CTypes.type t) {
14166: return (null == Primitives.isBottom.apply(null == t ? null
14167: : t.type) ? null : Primitives.isBottom
14168: .apply(null == t ? null : t.type) ? Boolean.FALSE
14169: : new Match<Boolean>() {
14170: public Boolean apply() {
14171: final CTypes.raw_type<?> arg$1393 = Analyzer
14172: .cast(null == t ? null : t.type);
14173:
14174: if ((null == arg$1393)) {
14175: return null;
14176: }
14177: if ((null != arg$1393))
14178: switch (arg$1393.tag()) {
14179: case EnumT:
14180: if (CSupport.match$1323(arg$1393)) {
14181: final Pair<CTypes.type> tl = Analyzer
14182: .cast(arg$1393
14183: .getTuple()
14184: .get3());
14185:
14186: return Analyzer
14187: .cast(Primitives.isBottom
14188: .apply(tl));
14189: }
14190: break;
14191: case StructT:
14192: if (CSupport.match$298(arg$1393)) {
14193: final String s = Analyzer
14194: .cast(arg$1393
14195: .getTuple()
14196: .get1());
14197: final Pair<CTypes.type> ty = Analyzer
14198: .cast(arg$1393
14199: .getTuple()
14200: .get3());
14201:
14202: return Analyzer
14203: .cast(null == Primitives.isBottom
14204: .apply(ty) ? null
14205: : Primitives.isBottom
14206: .apply(ty) ? new Let<Boolean>() {
14207: final CTypes.type tt;
14208:
14209: {
14210: tt = Analyzer
14211: .cast(Analyzer
14212: .cast(lookup2
14213: .apply(
14214: GNode
14215: .create(
14216: "StructureTypeReference",
14217: null,
14218: s),
14219: getNameSpace)));
14220: }
14221:
14222: public Boolean apply() {
14223: return Analyzer
14224: .cast(new Match<Boolean>() {
14225: public Boolean apply() {
14226: final CTypes.raw_type<?> arg$1407 = Analyzer
14227: .cast(null == tt ? null
14228: : tt.type);
14229:
14230: if ((null == arg$1407)) {
14231: return null;
14232: }
14233: if ((null != arg$1407))
14234: switch (arg$1407
14235: .tag()) {
14236: case StructT:
14237: if (CSupport
14238: .match$298(arg$1407)) {
14239: final Pair<CTypes.type> ttt = Analyzer
14240: .cast(arg$1407
14241: .getTuple()
14242: .get3());
14243:
14244: return Analyzer
14245: .cast(Primitives.isBottom
14246: .apply(ttt));
14247: }
14248: break;
14249: case UnionT:
14250: if (CSupport
14251: .match$905(arg$1407)) {
14252: final Pair<CTypes.type> ttt = Analyzer
14253: .cast(arg$1407
14254: .getTuple()
14255: .get3());
14256:
14257: return Analyzer
14258: .cast(Primitives.isBottom
14259: .apply(ttt));
14260: }
14261: break;
14262: default:
14263: break;
14264: }
14265: ;
14266: if (true) {
14267: return Analyzer
14268: .cast(null);
14269: }
14270: return null;
14271: }
14272: }
14273: .apply());
14274: }
14275: }.apply()
14276: : Boolean.FALSE);
14277: }
14278: break;
14279: case ArrayT:
14280: if (CSupport.match$1248(arg$1393)) {
14281: final CTypes.type b = Analyzer
14282: .cast(arg$1393
14283: .getTuple()
14284: .get1());
14285: final CTypes.arraySize size = Analyzer
14286: .cast(arg$1393
14287: .getTuple()
14288: .get2());
14289:
14290: return Analyzer
14291: .cast(null == Primitives.isBottom
14292: .apply(size) ? null
14293: : Primitives.isBottom
14294: .apply(size) ? Boolean.FALSE
14295: : new Match<Boolean>() {
14296: public Boolean apply() {
14297: final CTypes.arraySize arg$1399 = Analyzer
14298: .cast(size);
14299:
14300: if ((null == arg$1399)) {
14301: return null;
14302: }
14303: if ((null != arg$1399))
14304: switch (arg$1399
14305: .tag()) {
14306: case Incomplete:
14307: if (CSupport
14308: .match$1397(arg$1399)) {
14309: return Analyzer
14310: .cast(Primitives.not
14311: .apply(is_typedef
14312: .apply(b)));
14313: }
14314: break;
14315: default:
14316: break;
14317: }
14318: ;
14319: if (true) {
14320: return Analyzer
14321: .cast(Boolean.FALSE);
14322: }
14323: return null;
14324: }
14325: }
14326: .apply());
14327: }
14328: break;
14329: case UnionT:
14330: if (CSupport.match$905(arg$1393)) {
14331: final String s = Analyzer
14332: .cast(arg$1393
14333: .getTuple()
14334: .get1());
14335: final Pair<CTypes.type> ty = Analyzer
14336: .cast(arg$1393
14337: .getTuple()
14338: .get3());
14339:
14340: return Analyzer
14341: .cast(null == Primitives.isBottom
14342: .apply(ty) ? null
14343: : Primitives.isBottom
14344: .apply(ty) ? new Let<Boolean>() {
14345: final CTypes.type tt;
14346:
14347: {
14348: tt = Analyzer
14349: .cast(Analyzer
14350: .cast(lookup2
14351: .apply(
14352: GNode
14353: .create(
14354: "StructureTypeReference",
14355: null,
14356: s),
14357: getNameSpace)));
14358: }
14359:
14360: public Boolean apply() {
14361: return Analyzer
14362: .cast(new Match<Boolean>() {
14363: public Boolean apply() {
14364: final CTypes.raw_type<?> arg$1416 = Analyzer
14365: .cast(null == tt ? null
14366: : tt.type);
14367:
14368: if ((null == arg$1416)) {
14369: return null;
14370: }
14371: if ((null != arg$1416))
14372: switch (arg$1416
14373: .tag()) {
14374: case StructT:
14375: if (CSupport
14376: .match$298(arg$1416)) {
14377: final Pair<CTypes.type> ttt = Analyzer
14378: .cast(arg$1416
14379: .getTuple()
14380: .get3());
14381:
14382: return Analyzer
14383: .cast(Primitives.isBottom
14384: .apply(ttt));
14385: }
14386: break;
14387: case UnionT:
14388: if (CSupport
14389: .match$905(arg$1416)) {
14390: final Pair<CTypes.type> ttt = Analyzer
14391: .cast(arg$1416
14392: .getTuple()
14393: .get3());
14394:
14395: return Analyzer
14396: .cast(Primitives.isBottom
14397: .apply(ttt));
14398: }
14399: break;
14400: default:
14401: break;
14402: }
14403: ;
14404: if (true) {
14405: return Analyzer
14406: .cast(null);
14407: }
14408: return null;
14409: }
14410: }
14411: .apply());
14412: }
14413: }.apply()
14414: : Boolean.FALSE);
14415: }
14416: break;
14417: case VoidT:
14418: if (CSupport.match$408(arg$1393)) {
14419: return Analyzer
14420: .cast(Boolean.TRUE);
14421: }
14422: break;
14423: default:
14424: break;
14425: }
14426: ;
14427: if (true) {
14428: return Analyzer.cast(Boolean.FALSE);
14429: }
14430: return null;
14431: }
14432: }.apply());
14433: }
14434: };
14435:
14436: final Function.F2<Boolean, CTypes.type, CTypes.type> equal_ignore_signedness = new Function.F2<Boolean, CTypes.type, CTypes.type>() {
14437: public Boolean apply(final CTypes.type t1, final CTypes.type t2) {
14438: return new Match<Boolean>() {
14439: public Boolean apply() {
14440: final CTypes.raw_type<?> arg$1422 = Analyzer
14441: .cast(null == t1 ? null : t1.type);
14442:
14443: if ((null == arg$1422)) {
14444: return null;
14445: }
14446: if ((null != arg$1422))
14447: switch (arg$1422.tag()) {
14448: case UShortT:
14449: if (CSupport.match$1315(arg$1422)) {
14450: return Analyzer
14451: .cast(Primitives.or
14452: .apply(
14453: Primitives.equal
14454: .apply(
14455: null == t2 ? null
14456: : t2.type,
14457: new CTypes.ShortT()),
14458: Primitives.equal
14459: .apply(
14460: null == t2 ? null
14461: : t2.type,
14462: new CTypes.UShortT())));
14463: }
14464: break;
14465: case UIntT:
14466: if (CSupport.match$1316(arg$1422)) {
14467: return Analyzer
14468: .cast(Primitives.or
14469: .apply(
14470: Primitives.equal
14471: .apply(
14472: null == t2 ? null
14473: : t2.type,
14474: new CTypes.UIntT()),
14475: Primitives.equal
14476: .apply(
14477: null == t2 ? null
14478: : t2.type,
14479: new CTypes.IntT())));
14480: }
14481: break;
14482: case ULongLongT:
14483: if (CSupport.match$1320(arg$1422)) {
14484: return Analyzer
14485: .cast(Primitives.or
14486: .apply(
14487: Primitives.equal
14488: .apply(
14489: null == t2 ? null
14490: : t2.type,
14491: new CTypes.LongLongT()),
14492: Primitives.equal
14493: .apply(
14494: null == t2 ? null
14495: : t2.type,
14496: new CTypes.ULongLongT())));
14497: }
14498: break;
14499: case LongT:
14500: if (CSupport.match$1319(arg$1422)) {
14501: return Analyzer
14502: .cast(Primitives.or
14503: .apply(
14504: Primitives.equal
14505: .apply(
14506: null == t2 ? null
14507: : t2.type,
14508: new CTypes.LongT()),
14509: Primitives.equal
14510: .apply(
14511: null == t2 ? null
14512: : t2.type,
14513: new CTypes.ULongT())));
14514: }
14515: break;
14516: case IntT:
14517: if (CSupport.match$1317(arg$1422)) {
14518: return Analyzer
14519: .cast(Primitives.or
14520: .apply(
14521: Primitives.equal
14522: .apply(
14523: null == t2 ? null
14524: : t2.type,
14525: new CTypes.UIntT()),
14526: Primitives.equal
14527: .apply(
14528: null == t2 ? null
14529: : t2.type,
14530: new CTypes.IntT())));
14531: }
14532: break;
14533: case ShortT:
14534: if (CSupport.match$1314(arg$1422)) {
14535: return Analyzer
14536: .cast(Primitives.or
14537: .apply(
14538: Primitives.equal
14539: .apply(
14540: null == t2 ? null
14541: : t2.type,
14542: new CTypes.ShortT()),
14543: Primitives.equal
14544: .apply(
14545: null == t2 ? null
14546: : t2.type,
14547: new CTypes.UShortT())));
14548: }
14549: break;
14550: case SCharT:
14551: if (CSupport.match$1312(arg$1422)) {
14552: return Analyzer
14553: .cast(Primitives.or
14554: .apply(
14555: Primitives.or
14556: .apply(
14557: Primitives.equal
14558: .apply(
14559: null == t2 ? null
14560: : t2.type,
14561: new CTypes.CharT()),
14562: Primitives.equal
14563: .apply(
14564: null == t2 ? null
14565: : t2.type,
14566: new CTypes.UCharT())),
14567: Primitives.equal
14568: .apply(
14569: null == t2 ? null
14570: : t2.type,
14571: new CTypes.SCharT())));
14572: }
14573: break;
14574: case ULongT:
14575: if (CSupport.match$1318(arg$1422)) {
14576: return Analyzer
14577: .cast(Primitives.or
14578: .apply(
14579: Primitives.equal
14580: .apply(
14581: null == t2 ? null
14582: : t2.type,
14583: new CTypes.LongT()),
14584: Primitives.equal
14585: .apply(
14586: null == t2 ? null
14587: : t2.type,
14588: new CTypes.ULongT())));
14589: }
14590: break;
14591: case CharT:
14592: if (CSupport.match$1310(arg$1422)) {
14593: return Analyzer
14594: .cast(Primitives.or
14595: .apply(
14596: Primitives.or
14597: .apply(
14598: Primitives.equal
14599: .apply(
14600: null == t2 ? null
14601: : t2.type,
14602: new CTypes.CharT()),
14603: Primitives.equal
14604: .apply(
14605: null == t2 ? null
14606: : t2.type,
14607: new CTypes.UCharT())),
14608: Primitives.equal
14609: .apply(
14610: null == t2 ? null
14611: : t2.type,
14612: new CTypes.SCharT())));
14613: }
14614: break;
14615: case LongLongT:
14616: if (CSupport.match$1321(arg$1422)) {
14617: return Analyzer
14618: .cast(Primitives.or
14619: .apply(
14620: Primitives.equal
14621: .apply(
14622: null == t2 ? null
14623: : t2.type,
14624: new CTypes.LongLongT()),
14625: Primitives.equal
14626: .apply(
14627: null == t2 ? null
14628: : t2.type,
14629: new CTypes.ULongLongT())));
14630: }
14631: break;
14632: case UCharT:
14633: if (CSupport.match$1311(arg$1422)) {
14634: return Analyzer
14635: .cast(Primitives.or
14636: .apply(
14637: Primitives.or
14638: .apply(
14639: Primitives.equal
14640: .apply(
14641: null == t2 ? null
14642: : t2.type,
14643: new CTypes.CharT()),
14644: Primitives.equal
14645: .apply(
14646: null == t2 ? null
14647: : t2.type,
14648: new CTypes.UCharT())),
14649: Primitives.equal
14650: .apply(
14651: null == t2 ? null
14652: : t2.type,
14653: new CTypes.SCharT())));
14654: }
14655: break;
14656: default:
14657: break;
14658: }
14659: ;
14660: if (true) {
14661: return Analyzer.cast(Primitives.equal.apply(
14662: null == t1 ? null : t1.type,
14663: null == t2 ? null : t2.type));
14664: }
14665: return null;
14666: }
14667: }.apply();
14668: }
14669: };
14670:
14671: final Function.F2<CTypes.type, CTypes.type, CTypes.type> compose = new Function.F2<CTypes.type, CTypes.type, CTypes.type>() {
14672: public CTypes.type apply(final CTypes.type t1,
14673: final CTypes.type t2) {
14674: return (null == type_match.apply(t1, t2) ? null
14675: : type_match.apply(t1, t2) ? t1
14676: : new Match<CTypes.type>() {
14677: public CTypes.type apply() {
14678: final Tuple.T2<CTypes.raw_type<?>, CTypes.raw_type<?>> arg$1435 = Analyzer
14679: .cast(new Tuple.T2<CTypes.raw_type<?>, CTypes.raw_type<?>>(
14680: null == t1 ? null
14681: : t1.type,
14682: null == t2 ? null
14683: : t2.type));
14684:
14685: if ((null == arg$1435)) {
14686: return null;
14687: }
14688: if (CSupport.match$1436(arg$1435)) {
14689: final CTypes.type b1 = Analyzer
14690: .cast(arg$1435.get1()
14691: .getTuple()
14692: .get1());
14693: final CTypes.arraySize s1 = Analyzer
14694: .cast(arg$1435.get1()
14695: .getTuple()
14696: .get2());
14697: final CTypes.type b2 = Analyzer
14698: .cast(arg$1435.get2()
14699: .getTuple()
14700: .get1());
14701: final CTypes.arraySize s2 = Analyzer
14702: .cast(arg$1435.get2()
14703: .getTuple()
14704: .get2());
14705:
14706: return Analyzer
14707: .cast(new Let<CTypes.type>() {
14708: final CTypes.type ret;
14709:
14710: {
14711: ret = Analyzer
14712: .cast(compose
14713: .apply(
14714: b1,
14715: b2));
14716: }
14717:
14718: public CTypes.type apply() {
14719: return Analyzer
14720: .cast(null == Primitives.isNotBottom
14721: .apply(ret)
14722: || !Primitives.isNotBottom
14723: .apply(ret) ? null
14724: : new Match<CTypes.type>() {
14725: public CTypes.type apply() {
14726: final Tuple.T2<CTypes.arraySize, CTypes.arraySize> arg$1443 = Analyzer
14727: .cast(new Tuple.T2<CTypes.arraySize, CTypes.arraySize>(
14728: s1,
14729: s2));
14730:
14731: if ((null == arg$1443)) {
14732: return null;
14733: }
14734: if (CSupport
14735: .match$1438(arg$1443)) {
14736: return Analyzer
14737: .cast(t1);
14738: }
14739: if (CSupport
14740: .match$1439(arg$1443)) {
14741: final BigInteger i1 = Analyzer
14742: .cast(arg$1443
14743: .get1()
14744: .getTuple()
14745: .get1());
14746: final BigInteger i2 = Analyzer
14747: .cast(arg$1443
14748: .get2()
14749: .getTuple()
14750: .get1());
14751:
14752: return Analyzer
14753: .cast(null == Primitives.equal
14754: .apply(
14755: i1,
14756: i2)
14757: || !Primitives.equal
14758: .apply(
14759: i1,
14760: i2) ? null
14761: : t1);
14762: }
14763: if (CSupport
14764: .match$1440(arg$1443)) {
14765: return Analyzer
14766: .cast(t1);
14767: }
14768: if (CSupport
14769: .match$1441(arg$1443)) {
14770: return Analyzer
14771: .cast(t2);
14772: }
14773: if (true) {
14774: return Analyzer
14775: .cast(t1);
14776: }
14777: return null;
14778: }
14779: }
14780: .apply());
14781: }
14782: }.apply());
14783: }
14784: if (true) {
14785: return Analyzer.cast(t1);
14786: }
14787: return null;
14788: }
14789: }.apply());
14790: }
14791: };
14792:
14793: final Function.F1<CTypes.type, CTypes.type> pointerize = new Function.F1<CTypes.type, CTypes.type>() {
14794: public CTypes.type apply(final CTypes.type t) {
14795: return new Match<CTypes.type>() {
14796: public CTypes.type apply() {
14797: final CTypes.raw_type<?> arg$1450 = Analyzer
14798: .cast(null == t ? null : t.type);
14799:
14800: if ((null == arg$1450)) {
14801: return null;
14802: }
14803: if ((null != arg$1450))
14804: switch (arg$1450.tag()) {
14805: case ArrayT:
14806: if (CSupport.match$1248(arg$1450)) {
14807: return Analyzer.cast(new CTypes.type(
14808: new CTypes.PointerType(get_base
14809: .apply(t)), null, null,
14810: null, null, null, null, null,
14811: null, null, null));
14812: }
14813: break;
14814: case FunctionT:
14815: if (CSupport.match$1281(arg$1450)) {
14816: return Analyzer.cast(new CTypes.type(
14817: new CTypes.PointerType(t),
14818: null, null, null, null, null,
14819: null, null, null, null, null));
14820: }
14821: break;
14822: case MemberT:
14823: if (CSupport.match$1274(arg$1450)) {
14824: final CTypes.type ty = Analyzer
14825: .cast(arg$1450.getTuple()
14826: .get2());
14827:
14828: return Analyzer.cast(pointerize
14829: .apply(ty));
14830: }
14831: break;
14832: default:
14833: break;
14834: }
14835: ;
14836: if (true) {
14837: return Analyzer.cast(t);
14838: }
14839: return null;
14840: }
14841: }.apply();
14842: }
14843: };
14844:
14845: final Function.F1<BigInteger, CTypes.type> sizeof = new Function.F1<BigInteger, CTypes.type>() {
14846: public BigInteger apply(final CTypes.type t) {
14847: return new Match<BigInteger>() {
14848: public BigInteger apply() {
14849: final CTypes.raw_type<?> arg$1455 = Analyzer
14850: .cast(null == t ? null : t.type);
14851:
14852: if ((null == arg$1455)) {
14853: return null;
14854: }
14855: if ((null != arg$1455))
14856: switch (arg$1455.tag()) {
14857: case UIntT:
14858: if (CSupport.match$1316(arg$1455)) {
14859: return Analyzer.cast(BigInteger
14860: .valueOf(xtc.Limits.INT_SIZE));
14861: }
14862: break;
14863: case DoubleT:
14864: if (CSupport.match$1336(arg$1455)) {
14865: return Analyzer
14866: .cast(BigInteger
14867: .valueOf(xtc.Limits.DOUBLE_SIZE));
14868: }
14869: break;
14870: case ShortT:
14871: if (CSupport.match$1314(arg$1455)) {
14872: return Analyzer
14873: .cast(BigInteger
14874: .valueOf(xtc.Limits.SHORT_SIZE));
14875: }
14876: break;
14877: case IntT:
14878: if (CSupport.match$1317(arg$1455)) {
14879: return Analyzer.cast(BigInteger
14880: .valueOf(xtc.Limits.INT_SIZE));
14881: }
14882: break;
14883: case LongT:
14884: if (CSupport.match$1319(arg$1455)) {
14885: return Analyzer.cast(BigInteger
14886: .valueOf(xtc.Limits.INT_SIZE));
14887: }
14888: break;
14889: case SCharT:
14890: if (CSupport.match$1312(arg$1455)) {
14891: return Analyzer.cast(BigInteger
14892: .valueOf(1));
14893: }
14894: break;
14895: case LongDoubleT:
14896: if (CSupport.match$1337(arg$1455)) {
14897: return Analyzer
14898: .cast(BigInteger
14899: .valueOf(xtc.Limits.LONG_DOUBLE_SIZE));
14900: }
14901: break;
14902: case CharT:
14903: if (CSupport.match$1310(arg$1455)) {
14904: return Analyzer.cast(BigInteger
14905: .valueOf(1));
14906: }
14907: break;
14908: case FloatT:
14909: if (CSupport.match$1335(arg$1455)) {
14910: return Analyzer
14911: .cast(BigInteger
14912: .valueOf(xtc.Limits.FLOAT_SIZE));
14913: }
14914: break;
14915: case LongLongT:
14916: if (CSupport.match$1321(arg$1455)) {
14917: return Analyzer
14918: .cast(BigInteger
14919: .valueOf(xtc.Limits.LONG_LONG_SIZE));
14920: }
14921: break;
14922: case UShortT:
14923: if (CSupport.match$1315(arg$1455)) {
14924: return Analyzer
14925: .cast(BigInteger
14926: .valueOf(xtc.Limits.SHORT_SIZE));
14927: }
14928: break;
14929: case PointerType:
14930: if (CSupport.match$1247(arg$1455)) {
14931: return Analyzer
14932: .cast(BigInteger
14933: .valueOf(xtc.Limits.POINTER_SIZE));
14934: }
14935: break;
14936: case ULongLongT:
14937: if (CSupport.match$1320(arg$1455)) {
14938: return Analyzer
14939: .cast(BigInteger
14940: .valueOf(xtc.Limits.LONG_LONG_SIZE));
14941: }
14942: break;
14943: case ULongT:
14944: if (CSupport.match$1318(arg$1455)) {
14945: return Analyzer.cast(BigInteger
14946: .valueOf(xtc.Limits.INT_SIZE));
14947: }
14948: break;
14949: case UCharT:
14950: if (CSupport.match$1311(arg$1455)) {
14951: return Analyzer.cast(BigInteger
14952: .valueOf(1));
14953: }
14954: break;
14955: default:
14956: break;
14957: }
14958: ;
14959: if (true) {
14960: return Analyzer.cast(null);
14961: }
14962: return null;
14963: }
14964: }.apply();
14965: }
14966: };
14967:
14968: final Function.F1<CTypes.type, CTypes.type> promote = new Function.F1<CTypes.type, CTypes.type>() {
14969: public CTypes.type apply(final CTypes.type t) {
14970: return new Match<CTypes.type>() {
14971: public CTypes.type apply() {
14972: final CTypes.raw_type<?> arg$1472 = Analyzer
14973: .cast(null == t ? null : t.type);
14974:
14975: if ((null == arg$1472)) {
14976: return null;
14977: }
14978: if ((null != arg$1472))
14979: switch (arg$1472.tag()) {
14980: case UShortT:
14981: if (CSupport.match$1315(arg$1472)) {
14982: return Analyzer.cast(new CTypes.type(
14983: new CTypes.UIntT(), null, null,
14984: null, null, null, null, null,
14985: null, null, null));
14986: }
14987: break;
14988: case IntT:
14989: if (CSupport.match$1317(arg$1472)) {
14990: return Analyzer.cast(new CTypes.type(
14991: new CTypes.UIntT(), null, null,
14992: null, null, null, null, null,
14993: null, null, null));
14994: }
14995: break;
14996: case ShortT:
14997: if (CSupport.match$1314(arg$1472)) {
14998: return Analyzer.cast(new CTypes.type(
14999: new CTypes.UIntT(), null, null,
15000: null, null, null, null, null,
15001: null, null, null));
15002: }
15003: break;
15004: case SCharT:
15005: if (CSupport.match$1312(arg$1472)) {
15006: return Analyzer.cast(new CTypes.type(
15007: new CTypes.UIntT(), null, null,
15008: null, null, null, null, null,
15009: null, null, null));
15010: }
15011: break;
15012: case CharT:
15013: if (CSupport.match$1310(arg$1472)) {
15014: return Analyzer.cast(new CTypes.type(
15015: new CTypes.UIntT(), null, null,
15016: null, null, null, null, null,
15017: null, null, null));
15018: }
15019: break;
15020: case UCharT:
15021: if (CSupport.match$1311(arg$1472)) {
15022: return Analyzer.cast(new CTypes.type(
15023: new CTypes.UIntT(), null, null,
15024: null, null, null, null, null,
15025: null, null, null));
15026: }
15027: break;
15028: default:
15029: break;
15030: }
15031: ;
15032: if (true) {
15033: return Analyzer.cast(t);
15034: }
15035: return null;
15036: }
15037: }.apply();
15038: }
15039: };
15040:
15041: final Function.F2<CTypes.type, CTypes.type, CTypes.type> convert_int = new Function.F2<CTypes.type, CTypes.type, CTypes.type>() {
15042: public CTypes.type apply(final CTypes.type t1,
15043: final CTypes.type t2) {
15044: return new Match<CTypes.type>() {
15045: public CTypes.type apply() {
15046: final Tuple.T2<CTypes.raw_type<?>, CTypes.raw_type<?>> arg$1480 = Analyzer
15047: .cast(new Tuple.T2<CTypes.raw_type<?>, CTypes.raw_type<?>>(
15048: null == t1 ? null : t1.type,
15049: null == t2 ? null : t2.type));
15050:
15051: if ((null == arg$1480)) {
15052: return null;
15053: }
15054: if (CSupport.match$1481(arg$1480)) {
15055: return Analyzer.cast(new CTypes.type(
15056: new CTypes.ULongLongT(), null, null,
15057: null, null, null, null, null, null,
15058: null, null));
15059: }
15060: if (CSupport.match$1482(arg$1480)) {
15061: return Analyzer.cast(new CTypes.type(
15062: new CTypes.ULongLongT(), null, null,
15063: null, null, null, null, null, null,
15064: null, null));
15065: }
15066: if (CSupport.match$1483(arg$1480)) {
15067: return Analyzer.cast(new CTypes.type(
15068: new CTypes.LongLongT(), null, null,
15069: null, null, null, null, null, null,
15070: null, null));
15071: }
15072: if (CSupport.match$1484(arg$1480)) {
15073: return Analyzer.cast(new CTypes.type(
15074: new CTypes.LongLongT(), null, null,
15075: null, null, null, null, null, null,
15076: null, null));
15077: }
15078: if (CSupport.match$1485(arg$1480)) {
15079: return Analyzer.cast(new CTypes.type(
15080: new CTypes.LongT(), null, null, null,
15081: null, null, null, null, null, null,
15082: null));
15083: }
15084: if (CSupport.match$1486(arg$1480)) {
15085: return Analyzer.cast(new CTypes.type(
15086: new CTypes.LongT(), null, null, null,
15087: null, null, null, null, null, null,
15088: null));
15089: }
15090: if (CSupport.match$1487(arg$1480)) {
15091: return Analyzer.cast(new CTypes.type(
15092: new CTypes.ULongT(), null, null, null,
15093: null, null, null, null, null, null,
15094: null));
15095: }
15096: if (CSupport.match$1488(arg$1480)) {
15097: return Analyzer.cast(new CTypes.type(
15098: new CTypes.ULongT(), null, null, null,
15099: null, null, null, null, null, null,
15100: null));
15101: }
15102: if (CSupport.match$1489(arg$1480)) {
15103: return Analyzer.cast(new CTypes.type(
15104: new CTypes.UIntT(), null, null, null,
15105: null, null, null, null, null, null,
15106: null));
15107: }
15108: if (CSupport.match$1490(arg$1480)) {
15109: return Analyzer.cast(new CTypes.type(
15110: new CTypes.UIntT(), null, null, null,
15111: null, null, null, null, null, null,
15112: null));
15113: }
15114: if (CSupport.match$1491(arg$1480)) {
15115: return Analyzer.cast(new CTypes.type(
15116: new CTypes.IntT(), null, null, null,
15117: null, null, null, null, null, null,
15118: null));
15119: }
15120: if (CSupport.match$1492(arg$1480)) {
15121: return Analyzer.cast(new CTypes.type(
15122: new CTypes.IntT(), null, null, null,
15123: null, null, null, null, null, null,
15124: null));
15125: }
15126: if (CSupport.match$1493(arg$1480)) {
15127: return Analyzer.cast(new CTypes.type(
15128: new CTypes.UShortT(), null, null, null,
15129: null, null, null, null, null, null,
15130: null));
15131: }
15132: if (CSupport.match$1494(arg$1480)) {
15133: return Analyzer.cast(new CTypes.type(
15134: new CTypes.UShortT(), null, null, null,
15135: null, null, null, null, null, null,
15136: null));
15137: }
15138: if (CSupport.match$1495(arg$1480)) {
15139: return Analyzer.cast(new CTypes.type(
15140: new CTypes.ShortT(), null, null, null,
15141: null, null, null, null, null, null,
15142: null));
15143: }
15144: if (CSupport.match$1496(arg$1480)) {
15145: return Analyzer.cast(new CTypes.type(
15146: new CTypes.ShortT(), null, null, null,
15147: null, null, null, null, null, null,
15148: null));
15149: }
15150: if (CSupport.match$1497(arg$1480)) {
15151: return Analyzer.cast(new CTypes.type(
15152: new CTypes.CharT(), null, null, null,
15153: null, null, null, null, null, null,
15154: null));
15155: }
15156: if (CSupport.match$1498(arg$1480)) {
15157: return Analyzer.cast(new CTypes.type(
15158: new CTypes.CharT(), null, null, null,
15159: null, null, null, null, null, null,
15160: null));
15161: }
15162: if (true) {
15163: return Analyzer.cast(new CTypes.type(
15164: new CTypes.IntT(), null, null, null,
15165: null, null, null, null, null, null,
15166: null));
15167: }
15168: return null;
15169: }
15170: }.apply();
15171: }
15172: };
15173:
15174: final Function.F2<CTypes.type, CTypes.type, CTypes.type> arith_convert = new Function.F2<CTypes.type, CTypes.type, CTypes.type>() {
15175: public CTypes.type apply(final CTypes.type t1,
15176: final CTypes.type t2) {
15177: return new Let<CTypes.type>() {
15178: {
15179: new Function.F1<CTypes.type, String>() {
15180: public CTypes.type apply(final String para$1500) {
15181: final CTypes.type var$1501 = t1;
15182:
15183: return ensure_arithmetic.apply(var$1501,
15184: para$1500);
15185: }
15186: };
15187: new Function.F1<CTypes.type, String>() {
15188: public CTypes.type apply(final String para$1502) {
15189: final CTypes.type var$1503 = t2;
15190:
15191: return ensure_arithmetic.apply(var$1503,
15192: para$1502);
15193: }
15194: };
15195: }
15196:
15197: public CTypes.type apply() {
15198: return Analyzer
15199: .cast(null == Primitives.or
15200: .apply(
15201: Primitives.equal
15202: .apply(
15203: new CTypes.LongDoubleT(),
15204: null == t1 ? null
15205: : t1.type),
15206: Primitives.equal
15207: .apply(
15208: new CTypes.LongDoubleT(),
15209: null == t2 ? null
15210: : t2.type)) ? null
15211: : Primitives.or
15212: .apply(
15213: Primitives.equal
15214: .apply(
15215: new CTypes.LongDoubleT(),
15216: null == t1 ? null
15217: : t1.type),
15218: Primitives.equal
15219: .apply(
15220: new CTypes.LongDoubleT(),
15221: null == t2 ? null
15222: : t2.type)) ? new CTypes.type(
15223: new CTypes.LongDoubleT(),
15224: null, null, null, null,
15225: null, null, null, null,
15226: null, null)
15227: : null == Primitives.or
15228: .apply(
15229: Primitives.equal
15230: .apply(
15231: new CTypes.DoubleT(),
15232: null == t1 ? null
15233: : t1.type),
15234: Primitives.equal
15235: .apply(
15236: new CTypes.DoubleT(),
15237: null == t2 ? null
15238: : t2.type)) ? null
15239: : Primitives.or
15240: .apply(
15241: Primitives.equal
15242: .apply(
15243: new CTypes.DoubleT(),
15244: null == t1 ? null
15245: : t1.type),
15246: Primitives.equal
15247: .apply(
15248: new CTypes.DoubleT(),
15249: null == t2 ? null
15250: : t2.type)) ? new CTypes.type(
15251: new CTypes.DoubleT(),
15252: null, null,
15253: null, null,
15254: null, null,
15255: null, null,
15256: null, null)
15257: : null == Primitives.or
15258: .apply(
15259: Primitives.equal
15260: .apply(
15261: new CTypes.FloatT(),
15262: null == t1 ? null
15263: : t1.type),
15264: Primitives.equal
15265: .apply(
15266: new CTypes.FloatT(),
15267: null == t2 ? null
15268: : t2.type)) ? null
15269: : Primitives.or
15270: .apply(
15271: Primitives.equal
15272: .apply(
15273: new CTypes.FloatT(),
15274: null == t1 ? null
15275: : t1.type),
15276: Primitives.equal
15277: .apply(
15278: new CTypes.FloatT(),
15279: null == t2 ? null
15280: : t2.type)) ? new CTypes.type(
15281: new CTypes.FloatT(),
15282: null,
15283: null,
15284: null,
15285: null,
15286: null,
15287: null,
15288: null,
15289: null,
15290: null,
15291: null)
15292: : null == Primitives.and
15293: .apply(
15294: is_integer
15295: .apply(t1),
15296: is_integer
15297: .apply(t2)) ? null
15298: : Primitives.and
15299: .apply(
15300: is_integer
15301: .apply(t1),
15302: is_integer
15303: .apply(t2)) ? convert_int
15304: .apply(
15305: t1,
15306: t2)
15307: : null == type_match
15308: .apply(
15309: t1,
15310: t2) ? null
15311: : type_match
15312: .apply(
15313: t1,
15314: t2) ? t1
15315: : t1);
15316: }
15317: }.apply();
15318: }
15319: };
15320:
15321: final Function.F1<CTypes.type, CTypes.type> resolve = new Function.F1<CTypes.type, CTypes.type>() {
15322: public CTypes.type apply(final CTypes.type t) {
15323: return new Match<CTypes.type>() {
15324: public CTypes.type apply() {
15325: final CTypes.raw_type<?> arg$1504 = Analyzer
15326: .cast(null == t ? null : t.type);
15327:
15328: if ((null == arg$1504)) {
15329: return null;
15330: }
15331: if ((null != arg$1504))
15332: switch (arg$1504.tag()) {
15333: case MemberT:
15334: if (CSupport.match$1274(arg$1504)) {
15335: final CTypes.type ty = Analyzer
15336: .cast(arg$1504.getTuple()
15337: .get2());
15338:
15339: return Analyzer.cast(resolve.apply(ty));
15340: }
15341: break;
15342: default:
15343: break;
15344: }
15345: ;
15346: if (true) {
15347: return Analyzer.cast(t);
15348: }
15349: return null;
15350: }
15351: }.apply();
15352: }
15353: };
15354:
15355: final Function.F2<CTypes.type, CTypes.type, CTypes.type> processCast = new Function.F2<CTypes.type, CTypes.type, CTypes.type>() {
15356: public CTypes.type apply(final CTypes.type t1,
15357: final CTypes.type t2) {
15358: return (null == Primitives.and.apply(Primitives.equal
15359: .apply(new CTypes.BoolT(), null == t1 ? null
15360: : t1.type), Primitives.not.apply(is_scalar
15361: .apply(t2))) ? null
15362: : Primitives.and.apply(Primitives.equal.apply(
15363: new CTypes.BoolT(), null == t1 ? null
15364: : t1.type), Primitives.not
15365: .apply(is_scalar.apply(t2))) ? new Let<CTypes.type>() {
15366: {
15367: error("scalar required to cast to boolean",
15368: null);
15369: }
15370:
15371: public CTypes.type apply() {
15372: return Analyzer.cast(t1);
15373: }
15374: }.apply()
15375: : new CTypes.type(null == t1 ? null
15376: : t1.type, null == t1 ? null
15377: : t1.qualifiers, null == t1 ? null
15378: : t1.storage, null == t1 ? null
15379: : t1.fSpec, null == t2 ? null
15380: : t2.value, null == t1 ? null
15381: : t1.implicit, null == t1 ? null
15382: : t1.initialised, null == t1 ? null
15383: : t1.position, null == t1 ? null
15384: : t1.old_style, null == t1 ? null
15385: : t1.var_args, null == t1 ? null
15386: : t1.in_top));
15387: }
15388: };
15389:
15390: final Function.F2<Pair<CTypes.qualifier>, Pair<CTypes.qualifier>, Pair<CTypes.qualifier>> combine_qualifiers = new Function.F2<Pair<CTypes.qualifier>, Pair<CTypes.qualifier>, Pair<CTypes.qualifier>>() {
15391: public Pair<CTypes.qualifier> apply(
15392: final Pair<CTypes.qualifier> q1,
15393: final Pair<CTypes.qualifier> q2) {
15394: return (null == Primitives.and.apply(Primitives.isBottom
15395: .apply(q1), Primitives.isBottom.apply(q2)) ? null
15396: : Primitives.and.apply(Primitives.isBottom
15397: .apply(q1), Primitives.isBottom.apply(q2)) ? null
15398: : null == Primitives.isBottom.apply(q1) ? null
15399: : Primitives.isBottom.apply(q1) ? q2
15400: : null == Primitives.isBottom
15401: .apply(q2) ? null
15402: : Primitives.isBottom
15403: .apply(q2) ? q1
15404: : CSupport.union$1507
15405: .apply(
15406: q1,
15407: q2));
15408: }
15409: };
15410:
15411: final Function.F1<BigInteger, CTypes.type> get_size = new Function.F1<BigInteger, CTypes.type>() {
15412: public BigInteger apply(final CTypes.type t) {
15413: return new Match<BigInteger>() {
15414: public BigInteger apply() {
15415: final CTypes.raw_type<?> arg$1508 = Analyzer
15416: .cast(null == t ? null : t.type);
15417:
15418: if ((null == arg$1508)) {
15419: return null;
15420: }
15421: if ((null != arg$1508))
15422: switch (arg$1508.tag()) {
15423: case StructT:
15424: if (CSupport.match$298(arg$1508)) {
15425: final Pair<CTypes.type> tl = Analyzer
15426: .cast(arg$1508.getTuple()
15427: .get3());
15428:
15429: return Analyzer.cast(Primitives.length
15430: .apply(tl));
15431: }
15432: break;
15433: case ArrayT:
15434: if (CSupport.match$1248(arg$1508)) {
15435: final CTypes.type ty = Analyzer
15436: .cast(arg$1508.getTuple()
15437: .get1());
15438: final CTypes.arraySize si = Analyzer
15439: .cast(arg$1508.getTuple()
15440: .get2());
15441:
15442: return Analyzer
15443: .cast(new Let<BigInteger>() {
15444: final BigInteger s1;
15445: final BigInteger s2;
15446:
15447: {
15448: s1 = Analyzer
15449: .cast(new Match<BigInteger>() {
15450: public BigInteger apply() {
15451: final CTypes.arraySize arg$1514 = Analyzer
15452: .cast(si);
15453:
15454: if ((null == arg$1514)) {
15455: return null;
15456: }
15457: if ((null != arg$1514))
15458: switch (arg$1514
15459: .tag()) {
15460: case Fixed:
15461: if (CSupport
15462: .match$1359(arg$1514)) {
15463: final BigInteger ret = Analyzer
15464: .cast(arg$1514
15465: .getTuple()
15466: .get1());
15467:
15468: return Analyzer
15469: .cast(ret);
15470: }
15471: break;
15472: case Incomplete:
15473: if (CSupport
15474: .match$1397(arg$1514)) {
15475: return Analyzer
15476: .cast(xtc.Limits.ARRAY_MAX);
15477: }
15478: break;
15479: default:
15480: break;
15481: }
15482: ;
15483: if (true) {
15484: return Analyzer
15485: .cast(null);
15486: }
15487: return null;
15488: }
15489: }.apply());
15490: s2 = Analyzer
15491: .cast(get_size
15492: .apply(ty));
15493: }
15494:
15495: public BigInteger apply() {
15496: return Analyzer
15497: .cast(null == Primitives.or
15498: .apply(
15499: Primitives.isBottom
15500: .apply(s1),
15501: Primitives.isBottom
15502: .apply(s2)) ? null
15503: : Primitives.or
15504: .apply(
15505: Primitives.isBottom
15506: .apply(s1),
15507: Primitives.isBottom
15508: .apply(s2)) ? null
15509: : null == Primitives.or
15510: .apply(
15511: Primitives.equal
15512: .apply(
15513: s1,
15514: xtc.Limits.ARRAY_MAX),
15515: Primitives.equal
15516: .apply(
15517: s2,
15518: xtc.Limits.ARRAY_MAX)) ? null
15519: : Primitives.or
15520: .apply(
15521: Primitives.equal
15522: .apply(
15523: s1,
15524: xtc.Limits.ARRAY_MAX),
15525: Primitives.equal
15526: .apply(
15527: s2,
15528: xtc.Limits.ARRAY_MAX)) ? xtc.Limits.ARRAY_MAX
15529: : Primitives.multiplyInt
15530: .apply(
15531: s1,
15532: s2));
15533: }
15534: }.apply());
15535: }
15536: break;
15537: case UnionT:
15538: if (CSupport.match$905(arg$1508)) {
15539: return Analyzer.cast(BigInteger
15540: .valueOf(1));
15541: }
15542: break;
15543: default:
15544: break;
15545: }
15546: ;
15547: if (true) {
15548: return Analyzer.cast(BigInteger.valueOf(1));
15549: }
15550: return null;
15551: }
15552: }.apply();
15553: }
15554: };
15555:
15556: final Function.F1<Pair<CTypes.type>, Pair<CTypes.type>> flattenListTypes = new Function.F1<Pair<CTypes.type>, Pair<CTypes.type>>() {
15557: public Pair<CTypes.type> apply(final Pair<CTypes.type> l) {
15558: return (null == Primitives.isBottom.apply(l) ? null
15559: : Primitives.isBottom.apply(l) ? Pair
15560: .<CTypes.type> empty()
15561: : new Match<Pair<CTypes.type>>() {
15562: public Pair<CTypes.type> apply() {
15563: final Pair<CTypes.type> arg$1521 = Analyzer
15564: .cast(l);
15565:
15566: if ((null == arg$1521)) {
15567: return null;
15568: }
15569: if (CSupport.match$1212(arg$1521)) {
15570: return Analyzer.cast(Pair
15571: .<CTypes.type> empty());
15572: }
15573: if (true) {
15574: final Pair<CTypes.type> list$1523 = Analyzer
15575: .cast(Analyzer
15576: .cast(arg$1521));
15577: final CTypes.type x = Analyzer
15578: .cast(Primitives
15579: .wrapHead(list$1523));
15580: final Pair<CTypes.type> xs = Analyzer
15581: .cast(Primitives
15582: .wrapTail(list$1523));
15583:
15584: return Analyzer
15585: .cast(new Match<Pair<CTypes.type>>() {
15586: public Pair<CTypes.type> apply() {
15587: final CTypes.raw_type<?> arg$1528 = Analyzer
15588: .cast(null == x ? null
15589: : x.type);
15590:
15591: if ((null == arg$1528)) {
15592: return null;
15593: }
15594: if ((null != arg$1528))
15595: switch (arg$1528
15596: .tag()) {
15597: case ListT:
15598: if (CSupport
15599: .match$295(arg$1528)) {
15600: final Pair<CTypes.type> lt = Analyzer
15601: .cast(arg$1528
15602: .getTuple()
15603: .get1());
15604:
15605: return Analyzer
15606: .cast(CSupport.append$1526
15607: .apply(
15608: lt,
15609: flattenListTypes
15610: .apply(xs)));
15611: }
15612: break;
15613: default:
15614: break;
15615: }
15616: ;
15617: if (true) {
15618: return Analyzer
15619: .cast(flattenListTypes
15620: .apply(xs));
15621: }
15622: return null;
15623: }
15624: }.apply());
15625: }
15626: return null;
15627: }
15628: }.apply());
15629: }
15630: };
15631:
15632: final Function.F2<Boolean, CTypes.label_record, Pair<CTypes.label_record>> label_exists = new Function.F2<Boolean, CTypes.label_record, Pair<CTypes.label_record>>() {
15633: public Boolean apply(final CTypes.label_record l,
15634: final Pair<CTypes.label_record> ll) {
15635: return (null == Primitives.isBottom.apply(ll) ? null
15636: : Primitives.isBottom.apply(ll) ? Boolean.FALSE
15637: : new Match<Boolean>() {
15638: public Boolean apply() {
15639: final Pair<CTypes.label_record> arg$1532 = Analyzer
15640: .cast(ll);
15641:
15642: if ((null == arg$1532)) {
15643: return null;
15644: }
15645: if (CSupport.match$1222(arg$1532)) {
15646: return Analyzer
15647: .cast(Boolean.FALSE);
15648: }
15649: if (true) {
15650: final Pair<CTypes.label_record> list$1534 = Analyzer
15651: .cast(Analyzer
15652: .cast(arg$1532));
15653: final CTypes.label_record x = Analyzer
15654: .cast(Primitives
15655: .wrapHead(list$1534));
15656: final Pair<CTypes.label_record> xs = Analyzer
15657: .cast(Primitives
15658: .wrapTail(list$1534));
15659:
15660: return Analyzer
15661: .cast(null == Primitives.equal
15662: .apply(
15663: null == x ? null
15664: : x.label_name,
15665: null == l ? null
15666: : l.label_name) ? null
15667: : Primitives.equal
15668: .apply(
15669: null == x ? null
15670: : x.label_name,
15671: null == l ? null
15672: : l.label_name) ? Boolean.TRUE
15673: : label_exists
15674: .apply(
15675: l,
15676: xs));
15677: }
15678: return null;
15679: }
15680: }.apply());
15681: }
15682: };
15683:
15684: final Function.F2<Pair<CTypes.label_record>, Pair<CTypes.label_record>, Pair<CTypes.label_record>> labels_union = new Function.F2<Pair<CTypes.label_record>, Pair<CTypes.label_record>, Pair<CTypes.label_record>>() {
15685: public Pair<CTypes.label_record> apply(
15686: final Pair<CTypes.label_record> lr1,
15687: final Pair<CTypes.label_record> lr2) {
15688: return (null == Primitives.isBottom.apply(lr2) ? null
15689: : Primitives.isBottom.apply(lr2) ? lr1
15690: : new Match<Pair<CTypes.label_record>>() {
15691: public Pair<CTypes.label_record> apply() {
15692: final Pair<CTypes.label_record> arg$1536 = Analyzer
15693: .cast(lr2);
15694:
15695: if ((null == arg$1536)) {
15696: return null;
15697: }
15698: if (CSupport.match$1222(arg$1536)) {
15699: return Analyzer.cast(lr1);
15700: }
15701: if (true) {
15702: final Pair<CTypes.label_record> list$1538 = Analyzer
15703: .cast(Analyzer
15704: .cast(arg$1536));
15705: final CTypes.label_record x = Analyzer
15706: .cast(Primitives
15707: .wrapHead(list$1538));
15708: final Pair<CTypes.label_record> xs = Analyzer
15709: .cast(Primitives
15710: .wrapTail(list$1538));
15711:
15712: return Analyzer
15713: .cast(null == label_exists
15714: .apply(x, lr1) ? null
15715: : label_exists
15716: .apply(
15717: x,
15718: lr1) ? labels_union
15719: .apply(
15720: lr1,
15721: xs)
15722: : labels_union
15723: .apply(
15724: CSupport.append$1539
15725: .apply(
15726: lr1,
15727: new Pair<CTypes.label_record>(
15728: x)),
15729: xs));
15730: }
15731: return null;
15732: }
15733: }.apply());
15734: }
15735: };
15736:
15737: final Function.F3<Pair<CTypes.label_record>, Pair<CTypes.label_record>, Pair<CTypes.label_record>, Pair<CTypes.label_record>> labels_subtraction = new Function.F3<Pair<CTypes.label_record>, Pair<CTypes.label_record>, Pair<CTypes.label_record>, Pair<CTypes.label_record>>() {
15738: public Pair<CTypes.label_record> apply(
15739: final Pair<CTypes.label_record> lr1,
15740: final Pair<CTypes.label_record> lr2,
15741: final Pair<CTypes.label_record> res) {
15742: return (null == Primitives.isBottom.apply(lr1) ? null
15743: : Primitives.isBottom.apply(lr1) ? res
15744: : new Match<Pair<CTypes.label_record>>() {
15745: public Pair<CTypes.label_record> apply() {
15746: final Pair<CTypes.label_record> arg$1541 = Analyzer
15747: .cast(lr1);
15748:
15749: if ((null == arg$1541)) {
15750: return null;
15751: }
15752: if (CSupport.match$1222(arg$1541)) {
15753: return Analyzer.cast(res);
15754: }
15755: if (true) {
15756: final Pair<CTypes.label_record> list$1543 = Analyzer
15757: .cast(Analyzer
15758: .cast(arg$1541));
15759: final CTypes.label_record x = Analyzer
15760: .cast(Primitives
15761: .wrapHead(list$1543));
15762: final Pair<CTypes.label_record> xs = Analyzer
15763: .cast(Primitives
15764: .wrapTail(list$1543));
15765:
15766: return Analyzer
15767: .cast(null == label_exists
15768: .apply(x, lr2) ? null
15769: : label_exists
15770: .apply(
15771: x,
15772: lr2) ? labels_subtraction
15773: .apply(
15774: xs,
15775: lr2,
15776: res)
15777: : labels_subtraction
15778: .apply(
15779: xs,
15780: lr2,
15781: CSupport.append$1539
15782: .apply(
15783: res,
15784: new Pair<CTypes.label_record>(
15785: x))));
15786: }
15787: return null;
15788: }
15789: }.apply());
15790: }
15791: };
15792:
15793: final Function.F1<BigInteger, String> parse_int = new Function.F1<BigInteger, String>() {
15794: public BigInteger apply(final String s) {
15795: return (null == Primitives.startsWithi.apply(s, "0x") ? null
15796: : Primitives.startsWithi.apply(s, "0x") ? new Let<BigInteger>() {
15797: final String news;
15798:
15799: {
15800: news = Analyzer.cast(Primitives.substring
15801: .apply(s, BigInteger.valueOf(2)));
15802: }
15803:
15804: public BigInteger apply() {
15805: return Analyzer.cast(Primitives.stoi.apply(
15806: news, BigInteger.valueOf(16)));
15807: }
15808: }.apply()
15809: : null == Primitives.startsWith.apply(s,
15810: "0") ? null : Primitives.startsWith
15811: .apply(s, "0") ? Primitives.stoi
15812: .apply(s, BigInteger.valueOf(8))
15813: : Primitives.stoi.apply(s,
15814: BigInteger.valueOf(10)));
15815: }
15816: };
15817:
15818: final Function.F1<String, Node> get_id_declarator = new Function.F1<String, Node>() {
15819: public String apply(final Node n) {
15820: return new Match<String>() {
15821: public String apply() {
15822: final Node arg$1545 = GNode.cast(n);
15823:
15824: if ((null == arg$1545)) {
15825: return null;
15826: }
15827: if (CSupport.match$5(arg$1545)) {
15828: final String s = (arg$1545.size() > 0 ? arg$1545
15829: .getString(0)
15830: : null);
15831:
15832: matching_nodes.add(arg$1545);
15833: if ((null != arg$1545 && processScopeNodes
15834: .contains(arg$1545.getName()))) {
15835: processScope(arg$1545, getScope);
15836: }
15837: checkEnterScope(arg$1545);
15838:
15839: final Object retValue$1549 = Analyzer.cast(s);
15840:
15841: checkExitScope(arg$1545);
15842: matching_nodes
15843: .remove(matching_nodes.size() - 1);
15844: return Analyzer.cast(retValue$1549);
15845: }
15846: if (CSupport.match$9(arg$1545)) {
15847: final Node b = (arg$1545.size() > 1 ? arg$1545
15848: .getGeneric(1) : null);
15849:
15850: matching_nodes.add(arg$1545);
15851: if ((null != arg$1545 && processScopeNodes
15852: .contains(arg$1545.getName()))) {
15853: processScope(arg$1545, getScope);
15854: }
15855: checkEnterScope(arg$1545);
15856:
15857: final Object retValue$1553 = Analyzer
15858: .cast(get_id_declarator.apply(b));
15859:
15860: checkExitScope(arg$1545);
15861: matching_nodes
15862: .remove(matching_nodes.size() - 1);
15863: return Analyzer.cast(retValue$1553);
15864: }
15865: if (CSupport.match$13(arg$1545)) {
15866: final Node a = (arg$1545.size() > 0 ? arg$1545
15867: .getGeneric(0) : null);
15868:
15869: matching_nodes.add(arg$1545);
15870: if ((null != arg$1545 && processScopeNodes
15871: .contains(arg$1545.getName()))) {
15872: processScope(arg$1545, getScope);
15873: }
15874: checkEnterScope(arg$1545);
15875:
15876: final Object retValue$1557 = Analyzer
15877: .cast(get_id_declarator.apply(a));
15878:
15879: checkExitScope(arg$1545);
15880: matching_nodes
15881: .remove(matching_nodes.size() - 1);
15882: return Analyzer.cast(retValue$1557);
15883: }
15884: if (CSupport.match$17(arg$1545)) {
15885: final Node a = (arg$1545.size() > 0 ? arg$1545
15886: .getGeneric(0) : null);
15887:
15888: matching_nodes.add(arg$1545);
15889: if ((null != arg$1545 && processScopeNodes
15890: .contains(arg$1545.getName()))) {
15891: processScope(arg$1545, getScope);
15892: }
15893: checkEnterScope(arg$1545);
15894:
15895: final Object retValue$1561 = Analyzer
15896: .cast(get_id_declarator.apply(a));
15897:
15898: checkExitScope(arg$1545);
15899: matching_nodes
15900: .remove(matching_nodes.size() - 1);
15901: return Analyzer.cast(retValue$1561);
15902: }
15903: if (CSupport.match$65(arg$1545)) {
15904: final Node b = (arg$1545.size() > 1 ? arg$1545
15905: .getGeneric(1) : null);
15906:
15907: matching_nodes.add(arg$1545);
15908: if ((null != arg$1545 && processScopeNodes
15909: .contains(arg$1545.getName()))) {
15910: processScope(arg$1545, getScope);
15911: }
15912: checkEnterScope(arg$1545);
15913:
15914: final Object retValue$1565 = Analyzer
15915: .cast(get_id_declarator.apply(b));
15916:
15917: checkExitScope(arg$1545);
15918: matching_nodes
15919: .remove(matching_nodes.size() - 1);
15920: return Analyzer.cast(retValue$1565);
15921: }
15922: if (true) {
15923: matching_nodes.add(arg$1545);
15924: if ((null != arg$1545 && processScopeNodes
15925: .contains(arg$1545.getName()))) {
15926: processScope(arg$1545, getScope);
15927: }
15928: checkEnterScope(arg$1545);
15929:
15930: final Object retValue$1568 = Analyzer
15931: .cast(error(
15932: Primitives.concat
15933: .apply(
15934: "Unable to extract identifier from ",
15935: Primitives.node_name
15936: .apply(n)),
15937: null));
15938:
15939: checkExitScope(arg$1545);
15940: matching_nodes
15941: .remove(matching_nodes.size() - 1);
15942: return Analyzer.cast(retValue$1568);
15943: }
15944: return null;
15945: }
15946: }.apply();
15947: }
15948: };
15949:
15950: final Function.F2<Boolean, String, Node> is_used = new Function.F2<Boolean, String, Node>() {
15951: public Boolean apply(final String s, final Node st) {
15952: return (null == Primitives.isBottom.apply(st) ? null
15953: : Primitives.isBottom.apply(st) ? Boolean.FALSE
15954: : new Match<Boolean>() {
15955: public Boolean apply() {
15956: final Node arg$1570 = GNode
15957: .cast(st);
15958:
15959: if ((null == arg$1570)) {
15960: return null;
15961: }
15962: if (CSupport.match$488(arg$1570)) {
15963: final Pair<Node> l = Analyzer
15964: .cast(Primitives
15965: .getChildren(
15966: arg$1570,
15967: 0,
15968: arg$1570
15969: .size()));
15970:
15971: matching_nodes.add(arg$1570);
15972: if ((null != arg$1570 && processScopeNodes
15973: .contains(arg$1570
15974: .getName()))) {
15975: processScope(arg$1570,
15976: getScope);
15977: }
15978: checkEnterScope(arg$1570);
15979:
15980: final Object retValue$1574 = Analyzer
15981: .cast(is_used_in_list
15982: .apply(s, l));
15983:
15984: checkExitScope(arg$1570);
15985: matching_nodes
15986: .remove(matching_nodes
15987: .size() - 1);
15988: return Analyzer
15989: .cast(retValue$1574);
15990: }
15991: if (CSupport.match$501(arg$1570)) {
15992: final Node e = (arg$1570.size() > 0 ? arg$1570
15993: .getGeneric(0)
15994: : null);
15995: final Node cs = (arg$1570
15996: .size() > 1 ? arg$1570
15997: .getGeneric(1) : null);
15998:
15999: matching_nodes.add(arg$1570);
16000: if ((null != arg$1570 && processScopeNodes
16001: .contains(arg$1570
16002: .getName()))) {
16003: processScope(arg$1570,
16004: getScope);
16005: }
16006: checkEnterScope(arg$1570);
16007:
16008: final Object retValue$1578 = Analyzer
16009: .cast(Primitives.or
16010: .apply(
16011: is_used_expr
16012: .apply(
16013: s,
16014: e),
16015: is_used
16016: .apply(
16017: s,
16018: cs)));
16019:
16020: checkExitScope(arg$1570);
16021: matching_nodes
16022: .remove(matching_nodes
16023: .size() - 1);
16024: return Analyzer
16025: .cast(retValue$1578);
16026: }
16027: if (CSupport.match$505(arg$1570)) {
16028: final Node cs = (arg$1570
16029: .size() > 0 ? arg$1570
16030: .getGeneric(0) : null);
16031: final Node e = (arg$1570.size() > 1 ? arg$1570
16032: .getGeneric(1)
16033: : null);
16034:
16035: matching_nodes.add(arg$1570);
16036: if ((null != arg$1570 && processScopeNodes
16037: .contains(arg$1570
16038: .getName()))) {
16039: processScope(arg$1570,
16040: getScope);
16041: }
16042: checkEnterScope(arg$1570);
16043:
16044: final Object retValue$1582 = Analyzer
16045: .cast(Primitives.or
16046: .apply(
16047: is_used_expr
16048: .apply(
16049: s,
16050: e),
16051: is_used
16052: .apply(
16053: s,
16054: cs)));
16055:
16056: checkExitScope(arg$1570);
16057: matching_nodes
16058: .remove(matching_nodes
16059: .size() - 1);
16060: return Analyzer
16061: .cast(retValue$1582);
16062: }
16063: if (CSupport.match$509(arg$1570)) {
16064: final Node e = (arg$1570.size() > 0 ? arg$1570
16065: .getGeneric(0)
16066: : null);
16067: final Node cs = (arg$1570
16068: .size() > 1 ? arg$1570
16069: .getGeneric(1) : null);
16070:
16071: matching_nodes.add(arg$1570);
16072: if ((null != arg$1570 && processScopeNodes
16073: .contains(arg$1570
16074: .getName()))) {
16075: processScope(arg$1570,
16076: getScope);
16077: }
16078: checkEnterScope(arg$1570);
16079:
16080: final Object retValue$1586 = Analyzer
16081: .cast(Primitives.or
16082: .apply(
16083: is_used_expr
16084: .apply(
16085: s,
16086: e),
16087: is_used
16088: .apply(
16089: s,
16090: cs)));
16091:
16092: checkExitScope(arg$1570);
16093: matching_nodes
16094: .remove(matching_nodes
16095: .size() - 1);
16096: return Analyzer
16097: .cast(retValue$1586);
16098: }
16099: if (CSupport.match$497(arg$1570)) {
16100: final Node e = (arg$1570.size() > 0 ? arg$1570
16101: .getGeneric(0)
16102: : null);
16103: final Node cs = (arg$1570
16104: .size() > 1 ? arg$1570
16105: .getGeneric(1) : null);
16106:
16107: matching_nodes.add(arg$1570);
16108: if ((null != arg$1570 && processScopeNodes
16109: .contains(arg$1570
16110: .getName()))) {
16111: processScope(arg$1570,
16112: getScope);
16113: }
16114: checkEnterScope(arg$1570);
16115:
16116: final Object retValue$1590 = Analyzer
16117: .cast(Primitives.or
16118: .apply(
16119: is_used_expr
16120: .apply(
16121: s,
16122: e),
16123: is_used
16124: .apply(
16125: s,
16126: cs)));
16127:
16128: checkExitScope(arg$1570);
16129: matching_nodes
16130: .remove(matching_nodes
16131: .size() - 1);
16132: return Analyzer
16133: .cast(retValue$1590);
16134: }
16135: if (CSupport.match$82(arg$1570)) {
16136: final Node ic = (arg$1570
16137: .size() > 0 ? arg$1570
16138: .getGeneric(0) : null);
16139: final Node e1 = (arg$1570
16140: .size() > 1 ? arg$1570
16141: .getGeneric(1) : null);
16142: final Node e2 = (arg$1570
16143: .size() > 2 ? arg$1570
16144: .getGeneric(2) : null);
16145: final Node cs = (arg$1570
16146: .size() > 3 ? arg$1570
16147: .getGeneric(3) : null);
16148:
16149: matching_nodes.add(arg$1570);
16150: if ((null != arg$1570 && processScopeNodes
16151: .contains(arg$1570
16152: .getName()))) {
16153: processScope(arg$1570,
16154: getScope);
16155: }
16156: checkEnterScope(arg$1570);
16157:
16158: final Object retValue$1594 = Analyzer
16159: .cast(new Let<Boolean>() {
16160: final Boolean b;
16161:
16162: {
16163: b = Analyzer
16164: .cast(null == is_extern_declaration
16165: .apply(ic) ? null
16166: : is_extern_declaration
16167: .apply(ic) ? is_used_decl
16168: .apply(
16169: s,
16170: ic)
16171: : is_used_expr
16172: .apply(
16173: s,
16174: ic));
16175: }
16176:
16177: public Boolean apply() {
16178: return Analyzer
16179: .cast(Primitives.or
16180: .apply(
16181: Primitives.or
16182: .apply(
16183: Primitives.or
16184: .apply(
16185: b,
16186: is_used_expr
16187: .apply(
16188: s,
16189: e1)),
16190: is_used_expr
16191: .apply(
16192: s,
16193: e2)),
16194: is_used
16195: .apply(
16196: s,
16197: cs)));
16198: }
16199: }.apply());
16200:
16201: checkExitScope(arg$1570);
16202: matching_nodes
16203: .remove(matching_nodes
16204: .size() - 1);
16205: return Analyzer
16206: .cast(retValue$1594);
16207: }
16208: if (CSupport.match$551(arg$1570)) {
16209: final Node cs = (arg$1570
16210: .size() > 1 ? arg$1570
16211: .getGeneric(1) : null);
16212:
16213: matching_nodes.add(arg$1570);
16214: if ((null != arg$1570 && processScopeNodes
16215: .contains(arg$1570
16216: .getName()))) {
16217: processScope(arg$1570,
16218: getScope);
16219: }
16220: checkEnterScope(arg$1570);
16221:
16222: final Object retValue$1598 = Analyzer
16223: .cast(is_used.apply(s,
16224: cs));
16225:
16226: checkExitScope(arg$1570);
16227: matching_nodes
16228: .remove(matching_nodes
16229: .size() - 1);
16230: return Analyzer
16231: .cast(retValue$1598);
16232: }
16233: if (CSupport.match$493(arg$1570)) {
16234: final Node e = (arg$1570.size() > 0 ? arg$1570
16235: .getGeneric(0)
16236: : null);
16237: final Node cs1 = (arg$1570
16238: .size() > 1 ? arg$1570
16239: .getGeneric(1) : null);
16240: final Node cs2 = (arg$1570
16241: .size() > 2 ? arg$1570
16242: .getGeneric(2) : null);
16243:
16244: matching_nodes.add(arg$1570);
16245: if ((null != arg$1570 && processScopeNodes
16246: .contains(arg$1570
16247: .getName()))) {
16248: processScope(arg$1570,
16249: getScope);
16250: }
16251: checkEnterScope(arg$1570);
16252:
16253: final Object retValue$1602 = Analyzer
16254: .cast(Primitives.or
16255: .apply(
16256: Primitives.or
16257: .apply(
16258: is_used_expr
16259: .apply(
16260: s,
16261: e),
16262: is_used
16263: .apply(
16264: s,
16265: cs1)),
16266: is_used
16267: .apply(
16268: s,
16269: cs2)));
16270:
16271: checkExitScope(arg$1570);
16272: matching_nodes
16273: .remove(matching_nodes
16274: .size() - 1);
16275: return Analyzer
16276: .cast(retValue$1602);
16277: }
16278: if (CSupport.match$559(arg$1570)) {
16279: final Node e = (arg$1570.size() > 0 ? arg$1570
16280: .getGeneric(0)
16281: : null);
16282:
16283: matching_nodes.add(arg$1570);
16284: if ((null != arg$1570 && processScopeNodes
16285: .contains(arg$1570
16286: .getName()))) {
16287: processScope(arg$1570,
16288: getScope);
16289: }
16290: checkEnterScope(arg$1570);
16291:
16292: final Object retValue$1606 = Analyzer
16293: .cast(is_used_expr
16294: .apply(s, e));
16295:
16296: checkExitScope(arg$1570);
16297: matching_nodes
16298: .remove(matching_nodes
16299: .size() - 1);
16300: return Analyzer
16301: .cast(retValue$1606);
16302: }
16303: if (CSupport.match$484(arg$1570)) {
16304: final Node e = (arg$1570.size() > 0 ? arg$1570
16305: .getGeneric(0)
16306: : null);
16307:
16308: matching_nodes.add(arg$1570);
16309: if ((null != arg$1570 && processScopeNodes
16310: .contains(arg$1570
16311: .getName()))) {
16312: processScope(arg$1570,
16313: getScope);
16314: }
16315: checkEnterScope(arg$1570);
16316:
16317: final Object retValue$1610 = Analyzer
16318: .cast(is_used_expr
16319: .apply(s, e));
16320:
16321: checkExitScope(arg$1570);
16322: matching_nodes
16323: .remove(matching_nodes
16324: .size() - 1);
16325: return Analyzer
16326: .cast(retValue$1610);
16327: }
16328: if (CSupport.match$45(arg$1570)) {
16329: final String str = (arg$1570
16330: .getGeneric(1).size() > 0 ? arg$1570
16331: .getGeneric(1)
16332: .getString(0)
16333: : null);
16334:
16335: matching_nodes.add(arg$1570);
16336: if ((null != arg$1570 && processScopeNodes
16337: .contains(arg$1570
16338: .getName()))) {
16339: processScope(arg$1570,
16340: getScope);
16341: }
16342: checkEnterScope(arg$1570);
16343:
16344: List<Node> listName$1613 = new ArrayList<Node>();
16345: Node nodeName$1612 = arg$1570;
16346:
16347: nodeName$1612 = nodeName$1612
16348: .getGeneric(1);
16349: if ((null != nodeName$1612 && processScopeNodes
16350: .contains(nodeName$1612
16351: .getName()))) {
16352: processScope(nodeName$1612,
16353: getScope);
16354: }
16355: checkEnterScope(nodeName$1612);
16356: listName$1613.add(0,
16357: nodeName$1612);
16358:
16359: final Object retValue$1614 = Analyzer
16360: .cast(Primitives.equal
16361: .apply(str, s));
16362:
16363: for (Node no : listName$1613) {
16364: checkExitScope(no);
16365: }
16366: checkExitScope(arg$1570);
16367: matching_nodes
16368: .remove(matching_nodes
16369: .size() - 1);
16370: return Analyzer
16371: .cast(retValue$1614);
16372: }
16373: if (true) {
16374: matching_nodes.add(arg$1570);
16375: if ((null != arg$1570 && processScopeNodes
16376: .contains(arg$1570
16377: .getName()))) {
16378: processScope(arg$1570,
16379: getScope);
16380: }
16381: checkEnterScope(arg$1570);
16382:
16383: final Object retValue$1617 = Analyzer
16384: .cast(Boolean.FALSE);
16385:
16386: checkExitScope(arg$1570);
16387: matching_nodes
16388: .remove(matching_nodes
16389: .size() - 1);
16390: return Analyzer
16391: .cast(retValue$1617);
16392: }
16393: return null;
16394: }
16395: }.apply());
16396: }
16397: };
16398:
16399: final Function.F2<Boolean, String, Node> is_used_expr = new Function.F2<Boolean, String, Node>() {
16400: public Boolean apply(final String s, final Node n) {
16401: return (null == Primitives.isBottom.apply(n) ? null
16402: : Primitives.isBottom.apply(n) ? Boolean.FALSE
16403: : new Match<Boolean>() {
16404: public Boolean apply() {
16405: final Node arg$1619 = GNode.cast(n);
16406:
16407: if ((null == arg$1619)) {
16408: return null;
16409: }
16410: if (CSupport.match$657(arg$1619)) {
16411: final Node e1 = (arg$1619
16412: .size() > 0 ? arg$1619
16413: .getGeneric(0) : null);
16414: final Node e2 = (arg$1619
16415: .size() > 2 ? arg$1619
16416: .getGeneric(2) : null);
16417:
16418: matching_nodes.add(arg$1619);
16419: if ((null != arg$1619 && processScopeNodes
16420: .contains(arg$1619
16421: .getName()))) {
16422: processScope(arg$1619,
16423: getScope);
16424: }
16425: checkEnterScope(arg$1619);
16426:
16427: final Object retValue$1623 = Analyzer
16428: .cast(Primitives.or
16429: .apply(
16430: is_used_expr
16431: .apply(
16432: s,
16433: e1),
16434: is_used_expr
16435: .apply(
16436: s,
16437: e2)));
16438:
16439: checkExitScope(arg$1619);
16440: matching_nodes
16441: .remove(matching_nodes
16442: .size() - 1);
16443: return Analyzer
16444: .cast(retValue$1623);
16445: }
16446: if (CSupport.match$645(arg$1619)) {
16447: final Node e1 = (arg$1619
16448: .size() > 0 ? arg$1619
16449: .getGeneric(0) : null);
16450: final Node e2 = (arg$1619
16451: .size() > 2 ? arg$1619
16452: .getGeneric(2) : null);
16453:
16454: matching_nodes.add(arg$1619);
16455: if ((null != arg$1619 && processScopeNodes
16456: .contains(arg$1619
16457: .getName()))) {
16458: processScope(arg$1619,
16459: getScope);
16460: }
16461: checkEnterScope(arg$1619);
16462:
16463: final Object retValue$1627 = Analyzer
16464: .cast(Primitives.or
16465: .apply(
16466: is_used_expr
16467: .apply(
16468: s,
16469: e1),
16470: is_used_expr
16471: .apply(
16472: s,
16473: e2)));
16474:
16475: checkExitScope(arg$1619);
16476: matching_nodes
16477: .remove(matching_nodes
16478: .size() - 1);
16479: return Analyzer
16480: .cast(retValue$1627);
16481: }
16482: if (CSupport.match$601(arg$1619)) {
16483: final Node e1 = (arg$1619
16484: .size() > 0 ? arg$1619
16485: .getGeneric(0) : null);
16486: final Node e2 = (arg$1619
16487: .size() > 2 ? arg$1619
16488: .getGeneric(2) : null);
16489:
16490: matching_nodes.add(arg$1619);
16491: if ((null != arg$1619 && processScopeNodes
16492: .contains(arg$1619
16493: .getName()))) {
16494: processScope(arg$1619,
16495: getScope);
16496: }
16497: checkEnterScope(arg$1619);
16498:
16499: final Object retValue$1631 = Analyzer
16500: .cast(Primitives.or
16501: .apply(
16502: is_used_expr
16503: .apply(
16504: s,
16505: e1),
16506: is_used_expr
16507: .apply(
16508: s,
16509: e2)));
16510:
16511: checkExitScope(arg$1619);
16512: matching_nodes
16513: .remove(matching_nodes
16514: .size() - 1);
16515: return Analyzer
16516: .cast(retValue$1631);
16517: }
16518: if (CSupport.match$597(arg$1619)) {
16519: final Node e1 = (arg$1619
16520: .size() > 0 ? arg$1619
16521: .getGeneric(0) : null);
16522: final Node e2 = (arg$1619
16523: .size() > 1 ? arg$1619
16524: .getGeneric(1) : null);
16525:
16526: matching_nodes.add(arg$1619);
16527: if ((null != arg$1619 && processScopeNodes
16528: .contains(arg$1619
16529: .getName()))) {
16530: processScope(arg$1619,
16531: getScope);
16532: }
16533: checkEnterScope(arg$1619);
16534:
16535: final Object retValue$1635 = Analyzer
16536: .cast(Primitives.or
16537: .apply(
16538: is_used_expr
16539: .apply(
16540: s,
16541: e1),
16542: is_used_expr
16543: .apply(
16544: s,
16545: e2)));
16546:
16547: checkExitScope(arg$1619);
16548: matching_nodes
16549: .remove(matching_nodes
16550: .size() - 1);
16551: return Analyzer
16552: .cast(retValue$1635);
16553: }
16554: if (CSupport.match$617(arg$1619)) {
16555: final Node e1 = (arg$1619
16556: .size() > 0 ? arg$1619
16557: .getGeneric(0) : null);
16558: final Node e2 = (arg$1619
16559: .size() > 1 ? arg$1619
16560: .getGeneric(1) : null);
16561:
16562: matching_nodes.add(arg$1619);
16563: if ((null != arg$1619 && processScopeNodes
16564: .contains(arg$1619
16565: .getName()))) {
16566: processScope(arg$1619,
16567: getScope);
16568: }
16569: checkEnterScope(arg$1619);
16570:
16571: final Object retValue$1639 = Analyzer
16572: .cast(Primitives.or
16573: .apply(
16574: is_used_expr
16575: .apply(
16576: s,
16577: e1),
16578: is_used_expr
16579: .apply(
16580: s,
16581: e2)));
16582:
16583: checkExitScope(arg$1619);
16584: matching_nodes
16585: .remove(matching_nodes
16586: .size() - 1);
16587: return Analyzer
16588: .cast(retValue$1639);
16589: }
16590: if (CSupport.match$613(arg$1619)) {
16591: final Node e1 = (arg$1619
16592: .size() > 0 ? arg$1619
16593: .getGeneric(0) : null);
16594: final Node e2 = (arg$1619
16595: .size() > 1 ? arg$1619
16596: .getGeneric(1) : null);
16597:
16598: matching_nodes.add(arg$1619);
16599: if ((null != arg$1619 && processScopeNodes
16600: .contains(arg$1619
16601: .getName()))) {
16602: processScope(arg$1619,
16603: getScope);
16604: }
16605: checkEnterScope(arg$1619);
16606:
16607: final Object retValue$1643 = Analyzer
16608: .cast(Primitives.or
16609: .apply(
16610: is_used_expr
16611: .apply(
16612: s,
16613: e1),
16614: is_used_expr
16615: .apply(
16616: s,
16617: e2)));
16618:
16619: checkExitScope(arg$1619);
16620: matching_nodes
16621: .remove(matching_nodes
16622: .size() - 1);
16623: return Analyzer
16624: .cast(retValue$1643);
16625: }
16626: if (CSupport.match$625(arg$1619)) {
16627: final Node e1 = (arg$1619
16628: .size() > 0 ? arg$1619
16629: .getGeneric(0) : null);
16630: final Node e2 = (arg$1619
16631: .size() > 1 ? arg$1619
16632: .getGeneric(1) : null);
16633:
16634: matching_nodes.add(arg$1619);
16635: if ((null != arg$1619 && processScopeNodes
16636: .contains(arg$1619
16637: .getName()))) {
16638: processScope(arg$1619,
16639: getScope);
16640: }
16641: checkEnterScope(arg$1619);
16642:
16643: final Object retValue$1647 = Analyzer
16644: .cast(Primitives.or
16645: .apply(
16646: is_used_expr
16647: .apply(
16648: s,
16649: e1),
16650: is_used_expr
16651: .apply(
16652: s,
16653: e2)));
16654:
16655: checkExitScope(arg$1619);
16656: matching_nodes
16657: .remove(matching_nodes
16658: .size() - 1);
16659: return Analyzer
16660: .cast(retValue$1647);
16661: }
16662: if (CSupport.match$633(arg$1619)) {
16663: final Node e1 = (arg$1619
16664: .size() > 0 ? arg$1619
16665: .getGeneric(0) : null);
16666: final Node e2 = (arg$1619
16667: .size() > 1 ? arg$1619
16668: .getGeneric(1) : null);
16669:
16670: matching_nodes.add(arg$1619);
16671: if ((null != arg$1619 && processScopeNodes
16672: .contains(arg$1619
16673: .getName()))) {
16674: processScope(arg$1619,
16675: getScope);
16676: }
16677: checkEnterScope(arg$1619);
16678:
16679: final Object retValue$1651 = Analyzer
16680: .cast(Primitives.or
16681: .apply(
16682: is_used_expr
16683: .apply(
16684: s,
16685: e1),
16686: is_used_expr
16687: .apply(
16688: s,
16689: e2)));
16690:
16691: checkExitScope(arg$1619);
16692: matching_nodes
16693: .remove(matching_nodes
16694: .size() - 1);
16695: return Analyzer
16696: .cast(retValue$1651);
16697: }
16698: if (CSupport.match$629(arg$1619)) {
16699: final Node e1 = (arg$1619
16700: .size() > 0 ? arg$1619
16701: .getGeneric(0) : null);
16702: final Node e2 = (arg$1619
16703: .size() > 1 ? arg$1619
16704: .getGeneric(1) : null);
16705:
16706: matching_nodes.add(arg$1619);
16707: if ((null != arg$1619 && processScopeNodes
16708: .contains(arg$1619
16709: .getName()))) {
16710: processScope(arg$1619,
16711: getScope);
16712: }
16713: checkEnterScope(arg$1619);
16714:
16715: final Object retValue$1655 = Analyzer
16716: .cast(Primitives.or
16717: .apply(
16718: is_used_expr
16719: .apply(
16720: s,
16721: e1),
16722: is_used_expr
16723: .apply(
16724: s,
16725: e2)));
16726:
16727: checkExitScope(arg$1619);
16728: matching_nodes
16729: .remove(matching_nodes
16730: .size() - 1);
16731: return Analyzer
16732: .cast(retValue$1655);
16733: }
16734: if (CSupport.match$641(arg$1619)) {
16735: final Node e1 = (arg$1619
16736: .size() > 0 ? arg$1619
16737: .getGeneric(0) : null);
16738: final Node e2 = (arg$1619
16739: .size() > 2 ? arg$1619
16740: .getGeneric(2) : null);
16741:
16742: matching_nodes.add(arg$1619);
16743: if ((null != arg$1619 && processScopeNodes
16744: .contains(arg$1619
16745: .getName()))) {
16746: processScope(arg$1619,
16747: getScope);
16748: }
16749: checkEnterScope(arg$1619);
16750:
16751: final Object retValue$1659 = Analyzer
16752: .cast(Primitives.or
16753: .apply(
16754: is_used_expr
16755: .apply(
16756: s,
16757: e1),
16758: is_used_expr
16759: .apply(
16760: s,
16761: e2)));
16762:
16763: checkExitScope(arg$1619);
16764: matching_nodes
16765: .remove(matching_nodes
16766: .size() - 1);
16767: return Analyzer
16768: .cast(retValue$1659);
16769: }
16770: if (CSupport.match$1660(arg$1619)) {
16771: final Node e1 = (arg$1619
16772: .size() > 0 ? arg$1619
16773: .getGeneric(0) : null);
16774: final Node e2 = (arg$1619
16775: .size() > 2 ? arg$1619
16776: .getGeneric(2) : null);
16777:
16778: matching_nodes.add(arg$1619);
16779: if ((null != arg$1619 && processScopeNodes
16780: .contains(arg$1619
16781: .getName()))) {
16782: processScope(arg$1619,
16783: getScope);
16784: }
16785: checkEnterScope(arg$1619);
16786:
16787: final Object retValue$1663 = Analyzer
16788: .cast(Primitives.or
16789: .apply(
16790: is_used_expr
16791: .apply(
16792: s,
16793: e1),
16794: is_used_expr
16795: .apply(
16796: s,
16797: e2)));
16798:
16799: checkExitScope(arg$1619);
16800: matching_nodes
16801: .remove(matching_nodes
16802: .size() - 1);
16803: return Analyzer
16804: .cast(retValue$1663);
16805: }
16806: if (CSupport.match$665(arg$1619)) {
16807: final Node e1 = (arg$1619
16808: .size() > 0 ? arg$1619
16809: .getGeneric(0) : null);
16810: final Node e2 = (arg$1619
16811: .size() > 2 ? arg$1619
16812: .getGeneric(2) : null);
16813:
16814: matching_nodes.add(arg$1619);
16815: if ((null != arg$1619 && processScopeNodes
16816: .contains(arg$1619
16817: .getName()))) {
16818: processScope(arg$1619,
16819: getScope);
16820: }
16821: checkEnterScope(arg$1619);
16822:
16823: final Object retValue$1667 = Analyzer
16824: .cast(Primitives.or
16825: .apply(
16826: is_used_expr
16827: .apply(
16828: s,
16829: e1),
16830: is_used_expr
16831: .apply(
16832: s,
16833: e2)));
16834:
16835: checkExitScope(arg$1619);
16836: matching_nodes
16837: .remove(matching_nodes
16838: .size() - 1);
16839: return Analyzer
16840: .cast(retValue$1667);
16841: }
16842: if (CSupport.match$776(arg$1619)) {
16843: final Node e1 = (arg$1619
16844: .size() > 0 ? arg$1619
16845: .getGeneric(0) : null);
16846: final Node e2 = (arg$1619
16847: .size() > 1 ? arg$1619
16848: .getGeneric(1) : null);
16849:
16850: matching_nodes.add(arg$1619);
16851: if ((null != arg$1619 && processScopeNodes
16852: .contains(arg$1619
16853: .getName()))) {
16854: processScope(arg$1619,
16855: getScope);
16856: }
16857: checkEnterScope(arg$1619);
16858:
16859: final Object retValue$1671 = Analyzer
16860: .cast(Primitives.or
16861: .apply(
16862: is_used_expr
16863: .apply(
16864: s,
16865: e1),
16866: is_used_expr
16867: .apply(
16868: s,
16869: e2)));
16870:
16871: checkExitScope(arg$1619);
16872: matching_nodes
16873: .remove(matching_nodes
16874: .size() - 1);
16875: return Analyzer
16876: .cast(retValue$1671);
16877: }
16878: if (CSupport.match$609(arg$1619)) {
16879: final Node e1 = (arg$1619
16880: .size() > 0 ? arg$1619
16881: .getGeneric(0) : null);
16882: final Node e2 = (arg$1619
16883: .size() > 1 ? arg$1619
16884: .getGeneric(1) : null);
16885: final Node e3 = (arg$1619
16886: .size() > 2 ? arg$1619
16887: .getGeneric(2) : null);
16888:
16889: matching_nodes.add(arg$1619);
16890: if ((null != arg$1619 && processScopeNodes
16891: .contains(arg$1619
16892: .getName()))) {
16893: processScope(arg$1619,
16894: getScope);
16895: }
16896: checkEnterScope(arg$1619);
16897:
16898: final Object retValue$1675 = Analyzer
16899: .cast(Primitives.or
16900: .apply(
16901: Primitives.or
16902: .apply(
16903: is_used_expr
16904: .apply(
16905: s,
16906: e1),
16907: is_used_expr
16908: .apply(
16909: s,
16910: e2)),
16911: is_used_expr
16912: .apply(
16913: s,
16914: e3)));
16915:
16916: checkExitScope(arg$1619);
16917: matching_nodes
16918: .remove(matching_nodes
16919: .size() - 1);
16920: return Analyzer
16921: .cast(retValue$1675);
16922: }
16923: if (CSupport.match$37(arg$1619)) {
16924: final String str = (arg$1619
16925: .size() > 0 ? arg$1619
16926: .getString(0) : null);
16927:
16928: matching_nodes.add(arg$1619);
16929: if ((null != arg$1619 && processScopeNodes
16930: .contains(arg$1619
16931: .getName()))) {
16932: processScope(arg$1619,
16933: getScope);
16934: }
16935: checkEnterScope(arg$1619);
16936:
16937: final Object retValue$1679 = Analyzer
16938: .cast(Primitives.equal
16939: .apply(str, s));
16940:
16941: checkExitScope(arg$1619);
16942: matching_nodes
16943: .remove(matching_nodes
16944: .size() - 1);
16945: return Analyzer
16946: .cast(retValue$1679);
16947: }
16948: if (CSupport.match$1680(arg$1619)) {
16949: final Node e = (arg$1619.size() > 0 ? arg$1619
16950: .getGeneric(0)
16951: : null);
16952: final Node el = Analyzer
16953: .cast(arg$1619
16954: .getGeneric(1));
16955:
16956: matching_nodes.add(arg$1619);
16957: if ((null != arg$1619 && processScopeNodes
16958: .contains(arg$1619
16959: .getName()))) {
16960: processScope(arg$1619,
16961: getScope);
16962: }
16963: checkEnterScope(arg$1619);
16964:
16965: final Object retValue$1701 = Analyzer
16966: .cast(new Let<Boolean>() {
16967: final Pair<Node> nl;
16968:
16969: {
16970: nl = Analyzer
16971: .cast(new Match<Pair<Node>>() {
16972: public Pair<Node> apply() {
16973: final Node arg$1690 = GNode
16974: .cast(el);
16975:
16976: if ((null == arg$1690)) {
16977: return null;
16978: }
16979: if (CSupport
16980: .match$873(arg$1690)) {
16981: final Pair<Node> res = Analyzer
16982: .cast(Primitives
16983: .getChildren(
16984: arg$1690,
16985: 0,
16986: arg$1690
16987: .size()));
16988:
16989: matching_nodes
16990: .add(arg$1690);
16991: if ((null != arg$1690 && processScopeNodes
16992: .contains(arg$1690
16993: .getName()))) {
16994: processScope(
16995: arg$1690,
16996: getScope);
16997: }
16998: checkEnterScope(arg$1690);
16999:
17000: final Object retValue$1694 = Analyzer
17001: .cast(res);
17002:
17003: checkExitScope(arg$1690);
17004: matching_nodes
17005: .remove(matching_nodes
17006: .size() - 1);
17007: return Analyzer
17008: .cast(retValue$1694);
17009: }
17010: if (true) {
17011: matching_nodes
17012: .add(arg$1690);
17013: if ((null != arg$1690 && processScopeNodes
17014: .contains(arg$1690
17015: .getName()))) {
17016: processScope(
17017: arg$1690,
17018: getScope);
17019: }
17020: checkEnterScope(arg$1690);
17021:
17022: final Object retValue$1697 = Analyzer
17023: .cast(null);
17024:
17025: checkExitScope(arg$1690);
17026: matching_nodes
17027: .remove(matching_nodes
17028: .size() - 1);
17029: return Analyzer
17030: .cast(retValue$1697);
17031: }
17032: return null;
17033: }
17034: }
17035: .apply());
17036: }
17037:
17038: public Boolean apply() {
17039: return Analyzer
17040: .cast(Primitives.or
17041: .apply(
17042: is_used_expr
17043: .apply(
17044: s,
17045: e),
17046: is_used_in_list
17047: .apply(
17048: s,
17049: nl)));
17050: }
17051: }.apply());
17052:
17053: checkExitScope(arg$1619);
17054: matching_nodes
17055: .remove(matching_nodes
17056: .size() - 1);
17057: return Analyzer
17058: .cast(retValue$1701);
17059: }
17060: if (CSupport.match$1702(arg$1619)) {
17061: final Pair<Node> l = Analyzer
17062: .cast(Primitives
17063: .getChildren(
17064: arg$1619,
17065: 0,
17066: arg$1619
17067: .size()));
17068:
17069: matching_nodes.add(arg$1619);
17070: if ((null != arg$1619 && processScopeNodes
17071: .contains(arg$1619
17072: .getName()))) {
17073: processScope(arg$1619,
17074: getScope);
17075: }
17076: checkEnterScope(arg$1619);
17077:
17078: final Object retValue$1705 = Analyzer
17079: .cast(is_used_in_list
17080: .apply(s, l));
17081:
17082: checkExitScope(arg$1619);
17083: matching_nodes
17084: .remove(matching_nodes
17085: .size() - 1);
17086: return Analyzer
17087: .cast(retValue$1705);
17088: }
17089: if (CSupport.match$832(arg$1619)) {
17090: final Node e = (arg$1619.size() > 1 ? arg$1619
17091: .getGeneric(1)
17092: : null);
17093:
17094: matching_nodes.add(arg$1619);
17095: if ((null != arg$1619 && processScopeNodes
17096: .contains(arg$1619
17097: .getName()))) {
17098: processScope(arg$1619,
17099: getScope);
17100: }
17101: checkEnterScope(arg$1619);
17102:
17103: final Object retValue$1709 = Analyzer
17104: .cast(is_used_expr
17105: .apply(s, e));
17106:
17107: checkExitScope(arg$1619);
17108: matching_nodes
17109: .remove(matching_nodes
17110: .size() - 1);
17111: return Analyzer
17112: .cast(retValue$1709);
17113: }
17114: if (CSupport.match$926(arg$1619)) {
17115: final Node e = (arg$1619.size() > 1 ? arg$1619
17116: .getGeneric(1)
17117: : null);
17118:
17119: matching_nodes.add(arg$1619);
17120: if ((null != arg$1619 && processScopeNodes
17121: .contains(arg$1619
17122: .getName()))) {
17123: processScope(arg$1619,
17124: getScope);
17125: }
17126: checkEnterScope(arg$1619);
17127:
17128: final Object retValue$1713 = Analyzer
17129: .cast(is_used_expr
17130: .apply(s, e));
17131:
17132: checkExitScope(arg$1619);
17133: matching_nodes
17134: .remove(matching_nodes
17135: .size() - 1);
17136: return Analyzer
17137: .cast(retValue$1713);
17138: }
17139: if (CSupport.match$766(arg$1619)) {
17140: final Node e = (arg$1619.size() > 0 ? arg$1619
17141: .getGeneric(0)
17142: : null);
17143:
17144: matching_nodes.add(arg$1619);
17145: if ((null != arg$1619 && processScopeNodes
17146: .contains(arg$1619
17147: .getName()))) {
17148: processScope(arg$1619,
17149: getScope);
17150: }
17151: checkEnterScope(arg$1619);
17152:
17153: final Object retValue$1717 = Analyzer
17154: .cast(is_used_expr
17155: .apply(s, e));
17156:
17157: checkExitScope(arg$1619);
17158: matching_nodes
17159: .remove(matching_nodes
17160: .size() - 1);
17161: return Analyzer
17162: .cast(retValue$1717);
17163: }
17164: if (CSupport.match$762(arg$1619)) {
17165: final Node e = (arg$1619.size() > 0 ? arg$1619
17166: .getGeneric(0)
17167: : null);
17168:
17169: matching_nodes.add(arg$1619);
17170: if ((null != arg$1619 && processScopeNodes
17171: .contains(arg$1619
17172: .getName()))) {
17173: processScope(arg$1619,
17174: getScope);
17175: }
17176: checkEnterScope(arg$1619);
17177:
17178: final Object retValue$1721 = Analyzer
17179: .cast(is_used_expr
17180: .apply(s, e));
17181:
17182: checkExitScope(arg$1619);
17183: matching_nodes
17184: .remove(matching_nodes
17185: .size() - 1);
17186: return Analyzer
17187: .cast(retValue$1721);
17188: }
17189: if (CSupport.match$621(arg$1619)) {
17190: final Node e = (arg$1619.size() > 0 ? arg$1619
17191: .getGeneric(0)
17192: : null);
17193:
17194: matching_nodes.add(arg$1619);
17195: if ((null != arg$1619 && processScopeNodes
17196: .contains(arg$1619
17197: .getName()))) {
17198: processScope(arg$1619,
17199: getScope);
17200: }
17201: checkEnterScope(arg$1619);
17202:
17203: final Object retValue$1725 = Analyzer
17204: .cast(is_used_expr
17205: .apply(s, e));
17206:
17207: checkExitScope(arg$1619);
17208: matching_nodes
17209: .remove(matching_nodes
17210: .size() - 1);
17211: return Analyzer
17212: .cast(retValue$1725);
17213: }
17214: if (CSupport.match$637(arg$1619)) {
17215: final Node e = (arg$1619.size() > 0 ? arg$1619
17216: .getGeneric(0)
17217: : null);
17218:
17219: matching_nodes.add(arg$1619);
17220: if ((null != arg$1619 && processScopeNodes
17221: .contains(arg$1619
17222: .getName()))) {
17223: processScope(arg$1619,
17224: getScope);
17225: }
17226: checkEnterScope(arg$1619);
17227:
17228: final Object retValue$1729 = Analyzer
17229: .cast(is_used_expr
17230: .apply(s, e));
17231:
17232: checkExitScope(arg$1619);
17233: matching_nodes
17234: .remove(matching_nodes
17235: .size() - 1);
17236: return Analyzer
17237: .cast(retValue$1729);
17238: }
17239: if (CSupport.match$770(arg$1619)) {
17240: final Node e = (arg$1619.size() > 0 ? arg$1619
17241: .getGeneric(0)
17242: : null);
17243:
17244: matching_nodes.add(arg$1619);
17245: if ((null != arg$1619 && processScopeNodes
17246: .contains(arg$1619
17247: .getName()))) {
17248: processScope(arg$1619,
17249: getScope);
17250: }
17251: checkEnterScope(arg$1619);
17252:
17253: final Object retValue$1733 = Analyzer
17254: .cast(is_used_expr
17255: .apply(s, e));
17256:
17257: checkExitScope(arg$1619);
17258: matching_nodes
17259: .remove(matching_nodes
17260: .size() - 1);
17261: return Analyzer
17262: .cast(retValue$1733);
17263: }
17264: if (CSupport.match$772(arg$1619)) {
17265: final Node e = (arg$1619.size() > 0 ? arg$1619
17266: .getGeneric(0)
17267: : null);
17268:
17269: matching_nodes.add(arg$1619);
17270: if ((null != arg$1619 && processScopeNodes
17271: .contains(arg$1619
17272: .getName()))) {
17273: processScope(arg$1619,
17274: getScope);
17275: }
17276: checkEnterScope(arg$1619);
17277:
17278: final Object retValue$1737 = Analyzer
17279: .cast(is_used_expr
17280: .apply(s, e));
17281:
17282: checkExitScope(arg$1619);
17283: matching_nodes
17284: .remove(matching_nodes
17285: .size() - 1);
17286: return Analyzer
17287: .cast(retValue$1737);
17288: }
17289: if (CSupport.match$808(arg$1619)) {
17290: final Node e = (arg$1619.size() > 0 ? arg$1619
17291: .getGeneric(0)
17292: : null);
17293:
17294: matching_nodes.add(arg$1619);
17295: if ((null != arg$1619 && processScopeNodes
17296: .contains(arg$1619
17297: .getName()))) {
17298: processScope(arg$1619,
17299: getScope);
17300: }
17301: checkEnterScope(arg$1619);
17302:
17303: final Object retValue$1741 = Analyzer
17304: .cast(is_used_expr
17305: .apply(s, e));
17306:
17307: checkExitScope(arg$1619);
17308: matching_nodes
17309: .remove(matching_nodes
17310: .size() - 1);
17311: return Analyzer
17312: .cast(retValue$1741);
17313: }
17314: if (CSupport.match$812(arg$1619)) {
17315: final Node e = (arg$1619.size() > 0 ? arg$1619
17316: .getGeneric(0)
17317: : null);
17318:
17319: matching_nodes.add(arg$1619);
17320: if ((null != arg$1619 && processScopeNodes
17321: .contains(arg$1619
17322: .getName()))) {
17323: processScope(arg$1619,
17324: getScope);
17325: }
17326: checkEnterScope(arg$1619);
17327:
17328: final Object retValue$1745 = Analyzer
17329: .cast(is_used_expr
17330: .apply(s, e));
17331:
17332: checkExitScope(arg$1619);
17333: matching_nodes
17334: .remove(matching_nodes
17335: .size() - 1);
17336: return Analyzer
17337: .cast(retValue$1745);
17338: }
17339: if (CSupport.match$816(arg$1619)) {
17340: final Node e = (arg$1619.size() > 0 ? arg$1619
17341: .getGeneric(0)
17342: : null);
17343:
17344: matching_nodes.add(arg$1619);
17345: if ((null != arg$1619 && processScopeNodes
17346: .contains(arg$1619
17347: .getName()))) {
17348: processScope(arg$1619,
17349: getScope);
17350: }
17351: checkEnterScope(arg$1619);
17352:
17353: final Object retValue$1749 = Analyzer
17354: .cast(is_used_expr
17355: .apply(s, e));
17356:
17357: checkExitScope(arg$1619);
17358: matching_nodes
17359: .remove(matching_nodes
17360: .size() - 1);
17361: return Analyzer
17362: .cast(retValue$1749);
17363: }
17364: if (CSupport.match$902(arg$1619)) {
17365: final Node e = (arg$1619.size() > 0 ? arg$1619
17366: .getGeneric(0)
17367: : null);
17368:
17369: matching_nodes.add(arg$1619);
17370: if ((null != arg$1619 && processScopeNodes
17371: .contains(arg$1619
17372: .getName()))) {
17373: processScope(arg$1619,
17374: getScope);
17375: }
17376: checkEnterScope(arg$1619);
17377:
17378: final Object retValue$1753 = Analyzer
17379: .cast(is_used_expr
17380: .apply(s, e));
17381:
17382: checkExitScope(arg$1619);
17383: matching_nodes
17384: .remove(matching_nodes
17385: .size() - 1);
17386: return Analyzer
17387: .cast(retValue$1753);
17388: }
17389: if (CSupport.match$69(arg$1619)) {
17390: final Node e = (arg$1619.size() > 0 ? arg$1619
17391: .getGeneric(0)
17392: : null);
17393:
17394: matching_nodes.add(arg$1619);
17395: if ((null != arg$1619 && processScopeNodes
17396: .contains(arg$1619
17397: .getName()))) {
17398: processScope(arg$1619,
17399: getScope);
17400: }
17401: checkEnterScope(arg$1619);
17402:
17403: final Object retValue$1757 = Analyzer
17404: .cast(is_used_expr
17405: .apply(s, e));
17406:
17407: checkExitScope(arg$1619);
17408: matching_nodes
17409: .remove(matching_nodes
17410: .size() - 1);
17411: return Analyzer
17412: .cast(retValue$1757);
17413: }
17414: if (CSupport.match$824(arg$1619)) {
17415: final Node e = (arg$1619.size() > 0 ? arg$1619
17416: .getGeneric(0)
17417: : null);
17418:
17419: matching_nodes.add(arg$1619);
17420: if ((null != arg$1619 && processScopeNodes
17421: .contains(arg$1619
17422: .getName()))) {
17423: processScope(arg$1619,
17424: getScope);
17425: }
17426: checkEnterScope(arg$1619);
17427:
17428: final Object retValue$1761 = Analyzer
17429: .cast(is_used_expr
17430: .apply(s, e));
17431:
17432: checkExitScope(arg$1619);
17433: matching_nodes
17434: .remove(matching_nodes
17435: .size() - 1);
17436: return Analyzer
17437: .cast(retValue$1761);
17438: }
17439: if (CSupport.match$820(arg$1619)) {
17440: final Node e = (arg$1619.size() > 0 ? arg$1619
17441: .getGeneric(0)
17442: : null);
17443:
17444: matching_nodes.add(arg$1619);
17445: if ((null != arg$1619 && processScopeNodes
17446: .contains(arg$1619
17447: .getName()))) {
17448: processScope(arg$1619,
17449: getScope);
17450: }
17451: checkEnterScope(arg$1619);
17452:
17453: final Object retValue$1765 = Analyzer
17454: .cast(is_used_expr
17455: .apply(s, e));
17456:
17457: checkExitScope(arg$1619);
17458: matching_nodes
17459: .remove(matching_nodes
17460: .size() - 1);
17461: return Analyzer
17462: .cast(retValue$1765);
17463: }
17464: if (CSupport.match$930(arg$1619)) {
17465: final Node e = (arg$1619.size() > 0 ? arg$1619
17466: .getGeneric(0)
17467: : null);
17468:
17469: matching_nodes.add(arg$1619);
17470: if ((null != arg$1619 && processScopeNodes
17471: .contains(arg$1619
17472: .getName()))) {
17473: processScope(arg$1619,
17474: getScope);
17475: }
17476: checkEnterScope(arg$1619);
17477:
17478: final Object retValue$1769 = Analyzer
17479: .cast(is_used_expr
17480: .apply(s, e));
17481:
17482: checkExitScope(arg$1619);
17483: matching_nodes
17484: .remove(matching_nodes
17485: .size() - 1);
17486: return Analyzer
17487: .cast(retValue$1769);
17488: }
17489: if (CSupport.match$858(arg$1619)) {
17490: final Node e = (arg$1619.size() > 1 ? arg$1619
17491: .getGeneric(1)
17492: : null);
17493:
17494: matching_nodes.add(arg$1619);
17495: if ((null != arg$1619 && processScopeNodes
17496: .contains(arg$1619
17497: .getName()))) {
17498: processScope(arg$1619,
17499: getScope);
17500: }
17501: checkEnterScope(arg$1619);
17502:
17503: final Object retValue$1773 = Analyzer
17504: .cast(is_used_expr
17505: .apply(s, e));
17506:
17507: checkExitScope(arg$1619);
17508: matching_nodes
17509: .remove(matching_nodes
17510: .size() - 1);
17511: return Analyzer
17512: .cast(retValue$1773);
17513: }
17514: if (CSupport.match$718(arg$1619)) {
17515: final Node et = (arg$1619
17516: .size() > 0 ? arg$1619
17517: .getGeneric(0) : null);
17518:
17519: matching_nodes.add(arg$1619);
17520: if ((null != arg$1619 && processScopeNodes
17521: .contains(arg$1619
17522: .getName()))) {
17523: processScope(arg$1619,
17524: getScope);
17525: }
17526: checkEnterScope(arg$1619);
17527:
17528: final Object retValue$1795 = Analyzer
17529: .cast(new Match<Boolean>() {
17530: public Boolean apply() {
17531: final Node arg$1784 = GNode
17532: .cast(et);
17533:
17534: if ((null == arg$1784)) {
17535: return null;
17536: }
17537: if (CSupport
17538: .match$349(arg$1784)) {
17539: matching_nodes
17540: .add(arg$1784);
17541: if ((null != arg$1784 && processScopeNodes
17542: .contains(arg$1784
17543: .getName()))) {
17544: processScope(
17545: arg$1784,
17546: getScope);
17547: }
17548: checkEnterScope(arg$1784);
17549:
17550: final Object retValue$1788 = Analyzer
17551: .cast(Boolean.FALSE);
17552:
17553: checkExitScope(arg$1784);
17554: matching_nodes
17555: .remove(matching_nodes
17556: .size() - 1);
17557: return Analyzer
17558: .cast(retValue$1788);
17559: }
17560: if (true) {
17561: matching_nodes
17562: .add(arg$1784);
17563: if ((null != arg$1784 && processScopeNodes
17564: .contains(arg$1784
17565: .getName()))) {
17566: processScope(
17567: arg$1784,
17568: getScope);
17569: }
17570: checkEnterScope(arg$1784);
17571:
17572: final Object retValue$1791 = Analyzer
17573: .cast(is_used_expr
17574: .apply(
17575: s,
17576: et));
17577:
17578: checkExitScope(arg$1784);
17579: matching_nodes
17580: .remove(matching_nodes
17581: .size() - 1);
17582: return Analyzer
17583: .cast(retValue$1791);
17584: }
17585: return null;
17586: }
17587: }.apply());
17588:
17589: checkExitScope(arg$1619);
17590: matching_nodes
17591: .remove(matching_nodes
17592: .size() - 1);
17593: return Analyzer
17594: .cast(retValue$1795);
17595: }
17596: if (CSupport.match$740(arg$1619)) {
17597: final Node et = (arg$1619
17598: .size() > 0 ? arg$1619
17599: .getGeneric(0) : null);
17600:
17601: matching_nodes.add(arg$1619);
17602: if ((null != arg$1619 && processScopeNodes
17603: .contains(arg$1619
17604: .getName()))) {
17605: processScope(arg$1619,
17606: getScope);
17607: }
17608: checkEnterScope(arg$1619);
17609:
17610: final Object retValue$1817 = Analyzer
17611: .cast(new Match<Boolean>() {
17612: public Boolean apply() {
17613: final Node arg$1806 = GNode
17614: .cast(et);
17615:
17616: if ((null == arg$1806)) {
17617: return null;
17618: }
17619: if (CSupport
17620: .match$349(arg$1806)) {
17621: matching_nodes
17622: .add(arg$1806);
17623: if ((null != arg$1806 && processScopeNodes
17624: .contains(arg$1806
17625: .getName()))) {
17626: processScope(
17627: arg$1806,
17628: getScope);
17629: }
17630: checkEnterScope(arg$1806);
17631:
17632: final Object retValue$1810 = Analyzer
17633: .cast(Boolean.FALSE);
17634:
17635: checkExitScope(arg$1806);
17636: matching_nodes
17637: .remove(matching_nodes
17638: .size() - 1);
17639: return Analyzer
17640: .cast(retValue$1810);
17641: }
17642: if (true) {
17643: matching_nodes
17644: .add(arg$1806);
17645: if ((null != arg$1806 && processScopeNodes
17646: .contains(arg$1806
17647: .getName()))) {
17648: processScope(
17649: arg$1806,
17650: getScope);
17651: }
17652: checkEnterScope(arg$1806);
17653:
17654: final Object retValue$1813 = Analyzer
17655: .cast(is_used_expr
17656: .apply(
17657: s,
17658: et));
17659:
17660: checkExitScope(arg$1806);
17661: matching_nodes
17662: .remove(matching_nodes
17663: .size() - 1);
17664: return Analyzer
17665: .cast(retValue$1813);
17666: }
17667: return null;
17668: }
17669: }.apply());
17670:
17671: checkExitScope(arg$1619);
17672: matching_nodes
17673: .remove(matching_nodes
17674: .size() - 1);
17675: return Analyzer
17676: .cast(retValue$1817);
17677: }
17678: if (CSupport.match$828(arg$1619)) {
17679: final Node st = (arg$1619
17680: .size() > 0 ? arg$1619
17681: .getGeneric(0) : null);
17682:
17683: matching_nodes.add(arg$1619);
17684: if ((null != arg$1619 && processScopeNodes
17685: .contains(arg$1619
17686: .getName()))) {
17687: processScope(arg$1619,
17688: getScope);
17689: }
17690: checkEnterScope(arg$1619);
17691:
17692: final Object retValue$1821 = Analyzer
17693: .cast(is_used.apply(s,
17694: st));
17695:
17696: checkExitScope(arg$1619);
17697: matching_nodes
17698: .remove(matching_nodes
17699: .size() - 1);
17700: return Analyzer
17701: .cast(retValue$1821);
17702: }
17703: if (true) {
17704: matching_nodes.add(arg$1619);
17705: if ((null != arg$1619 && processScopeNodes
17706: .contains(arg$1619
17707: .getName()))) {
17708: processScope(arg$1619,
17709: getScope);
17710: }
17711: checkEnterScope(arg$1619);
17712:
17713: final Object retValue$1824 = Analyzer
17714: .cast(Boolean.FALSE);
17715:
17716: checkExitScope(arg$1619);
17717: matching_nodes
17718: .remove(matching_nodes
17719: .size() - 1);
17720: return Analyzer
17721: .cast(retValue$1824);
17722: }
17723: return null;
17724: }
17725: }.apply());
17726: }
17727: };
17728:
17729: final Function.F2<Boolean, String, Node> is_used_decl = new Function.F2<Boolean, String, Node>() {
17730: public Boolean apply(final String s, final Node n) {
17731: return (null == Primitives.isBottom.apply(n) ? null
17732: : Primitives.isBottom.apply(n) ? Boolean.FALSE
17733: : new Match<Boolean>() {
17734: public Boolean apply() {
17735: final Node arg$1826 = GNode.cast(n);
17736:
17737: if ((null == arg$1826)) {
17738: return null;
17739: }
17740: if (CSupport.match$1827(arg$1826)) {
17741: final Pair<Node> dl = Analyzer
17742: .cast(Primitives
17743: .getChildren(
17744: arg$1826
17745: .getGeneric(2),
17746: 0,
17747: arg$1826
17748: .getGeneric(
17749: 2)
17750: .size()));
17751:
17752: matching_nodes.add(arg$1826);
17753: if ((null != arg$1826 && processScopeNodes
17754: .contains(arg$1826
17755: .getName()))) {
17756: processScope(arg$1826,
17757: getScope);
17758: }
17759: checkEnterScope(arg$1826);
17760:
17761: List<Node> listName$1829 = new ArrayList<Node>();
17762: Node nodeName$1828 = arg$1826;
17763:
17764: nodeName$1828 = nodeName$1828
17765: .getGeneric(2);
17766: if ((null != nodeName$1828 && processScopeNodes
17767: .contains(nodeName$1828
17768: .getName()))) {
17769: processScope(nodeName$1828,
17770: getScope);
17771: }
17772: checkEnterScope(nodeName$1828);
17773: listName$1829.add(0,
17774: nodeName$1828);
17775:
17776: final Object retValue$1830 = Analyzer
17777: .cast(is_used_in_list
17778: .apply(s, dl));
17779:
17780: for (Node no : listName$1829) {
17781: checkExitScope(no);
17782: }
17783: checkExitScope(arg$1826);
17784: matching_nodes
17785: .remove(matching_nodes
17786: .size() - 1);
17787: return Analyzer
17788: .cast(retValue$1830);
17789: }
17790: if (true) {
17791: matching_nodes.add(arg$1826);
17792: if ((null != arg$1826 && processScopeNodes
17793: .contains(arg$1826
17794: .getName()))) {
17795: processScope(arg$1826,
17796: getScope);
17797: }
17798: checkEnterScope(arg$1826);
17799:
17800: final Object retValue$1833 = Analyzer
17801: .cast(Boolean.FALSE);
17802:
17803: checkExitScope(arg$1826);
17804: matching_nodes
17805: .remove(matching_nodes
17806: .size() - 1);
17807: return Analyzer
17808: .cast(retValue$1833);
17809: }
17810: return null;
17811: }
17812: }.apply());
17813: }
17814: };
17815:
17816: final Function.F2<Boolean, String, Pair<Node>> is_used_in_list = new Function.F2<Boolean, String, Pair<Node>>() {
17817: public Boolean apply(final String s, final Pair<Node> nl) {
17818: return new Match<Boolean>() {
17819: public Boolean apply() {
17820: final Pair<Node> arg$1835 = Analyzer.cast(nl);
17821:
17822: if ((null == arg$1835)) {
17823: return null;
17824: }
17825: if (CSupport.match$383(arg$1835)) {
17826: return Analyzer.cast(Boolean.FALSE);
17827: }
17828: if (true) {
17829: final Pair<Node> list$1837 = Analyzer
17830: .cast(Analyzer.cast(arg$1835));
17831: final Node x = GNode.cast(Primitives
17832: .wrapHead(list$1837));
17833: final Pair<Node> xs = Analyzer.cast(Primitives
17834: .wrapTail(list$1837));
17835:
17836: return Analyzer.cast(Primitives.or.apply(
17837: is_used_generic.apply(s, x),
17838: is_used_in_list.apply(s, xs)));
17839: }
17840: return null;
17841: }
17842: }.apply();
17843: }
17844: };
17845:
17846: final Function.F2<Boolean, String, Node> is_used_generic = new Function.F2<Boolean, String, Node>() {
17847: public Boolean apply(final String s, final Node n) {
17848: return (null == is_extern_declaration.apply(n) ? null
17849: : is_extern_declaration.apply(n) ? is_used_decl
17850: .apply(s, n) : null == is_init_decl_list
17851: .apply(n) ? null : is_init_decl_list
17852: .apply(n) ? new Let<Boolean>() {
17853: final Pair<Node> dl;
17854:
17855: {
17856: dl = Analyzer.cast(new Match<Pair<Node>>() {
17857: public Pair<Node> apply() {
17858: final Node arg$1839 = GNode.cast(n);
17859:
17860: if ((null == arg$1839)) {
17861: return null;
17862: }
17863: if (CSupport.match$374(arg$1839)) {
17864: final Pair<Node> res = Analyzer
17865: .cast(Primitives
17866: .getChildren(
17867: arg$1839,
17868: 0,
17869: arg$1839
17870: .size()));
17871:
17872: matching_nodes.add(arg$1839);
17873: if ((null != arg$1839 && processScopeNodes
17874: .contains(arg$1839
17875: .getName()))) {
17876: processScope(arg$1839,
17877: getScope);
17878: }
17879: checkEnterScope(arg$1839);
17880:
17881: final Object retValue$1843 = Analyzer
17882: .cast(res);
17883:
17884: checkExitScope(arg$1839);
17885: matching_nodes
17886: .remove(matching_nodes
17887: .size() - 1);
17888: return Analyzer
17889: .cast(retValue$1843);
17890: }
17891: if (true) {
17892: matching_nodes.add(arg$1839);
17893: if ((null != arg$1839 && processScopeNodes
17894: .contains(arg$1839
17895: .getName()))) {
17896: processScope(arg$1839,
17897: getScope);
17898: }
17899: checkEnterScope(arg$1839);
17900:
17901: final Object retValue$1846 = Analyzer
17902: .cast(null);
17903:
17904: checkExitScope(arg$1839);
17905: matching_nodes
17906: .remove(matching_nodes
17907: .size() - 1);
17908: return Analyzer
17909: .cast(retValue$1846);
17910: }
17911: return null;
17912: }
17913: }.apply());
17914: }
17915:
17916: public Boolean apply() {
17917: return Analyzer.cast(is_used_in_list.apply(
17918: s, dl));
17919: }
17920: }.apply()
17921: : null == is_init_decl.apply(n) ? null
17922: : is_init_decl.apply(n) ? new Let<Boolean>() {
17923: final Node init;
17924:
17925: {
17926: init = Analyzer
17927: .cast(new Match<Node>() {
17928: public Node apply() {
17929: final Node arg$1848 = GNode
17930: .cast(n);
17931:
17932: if ((null == arg$1848)) {
17933: return null;
17934: }
17935: if (CSupport
17936: .match$387(arg$1848)) {
17937: final Node res = (arg$1848
17938: .size() > 4 ? arg$1848
17939: .getGeneric(4)
17940: : null);
17941:
17942: matching_nodes
17943: .add(arg$1848);
17944: if ((null != arg$1848 && processScopeNodes
17945: .contains(arg$1848
17946: .getName()))) {
17947: processScope(
17948: arg$1848,
17949: getScope);
17950: }
17951: checkEnterScope(arg$1848);
17952:
17953: final Object retValue$1852 = Analyzer
17954: .cast(res);
17955:
17956: checkExitScope(arg$1848);
17957: matching_nodes
17958: .remove(matching_nodes
17959: .size() - 1);
17960: return Analyzer
17961: .cast(retValue$1852);
17962: }
17963: if (true) {
17964: matching_nodes
17965: .add(arg$1848);
17966: if ((null != arg$1848 && processScopeNodes
17967: .contains(arg$1848
17968: .getName()))) {
17969: processScope(
17970: arg$1848,
17971: getScope);
17972: }
17973: checkEnterScope(arg$1848);
17974:
17975: final Object retValue$1855 = Analyzer
17976: .cast(null);
17977:
17978: checkExitScope(arg$1848);
17979: matching_nodes
17980: .remove(matching_nodes
17981: .size() - 1);
17982: return Analyzer
17983: .cast(retValue$1855);
17984: }
17985: return null;
17986: }
17987: }.apply());
17988: }
17989:
17990: public Boolean apply() {
17991: return Analyzer
17992: .cast(is_used_expr
17993: .apply(s,
17994: init));
17995: }
17996: }.apply()
17997: : null == is_init_entry
17998: .apply(n) ? null
17999: : is_init_entry
18000: .apply(n) ? new Let<Boolean>() {
18001: final Node init;
18002:
18003: {
18004: init = Analyzer
18005: .cast(new Match<Node>() {
18006: public Node apply() {
18007: final Node arg$1857 = GNode
18008: .cast(n);
18009:
18010: if ((null == arg$1857)) {
18011: return null;
18012: }
18013: if (CSupport
18014: .match$1858(arg$1857)) {
18015: final Node res = (arg$1857
18016: .size() > 1 ? arg$1857
18017: .getGeneric(1)
18018: : null);
18019:
18020: matching_nodes
18021: .add(arg$1857);
18022: if ((null != arg$1857 && processScopeNodes
18023: .contains(arg$1857
18024: .getName()))) {
18025: processScope(
18026: arg$1857,
18027: getScope);
18028: }
18029: checkEnterScope(arg$1857);
18030:
18031: final Object retValue$1861 = Analyzer
18032: .cast(res);
18033:
18034: checkExitScope(arg$1857);
18035: matching_nodes
18036: .remove(matching_nodes
18037: .size() - 1);
18038: return Analyzer
18039: .cast(retValue$1861);
18040: }
18041: if (true) {
18042: matching_nodes
18043: .add(arg$1857);
18044: if ((null != arg$1857 && processScopeNodes
18045: .contains(arg$1857
18046: .getName()))) {
18047: processScope(
18048: arg$1857,
18049: getScope);
18050: }
18051: checkEnterScope(arg$1857);
18052:
18053: final Object retValue$1864 = Analyzer
18054: .cast(null);
18055:
18056: checkExitScope(arg$1857);
18057: matching_nodes
18058: .remove(matching_nodes
18059: .size() - 1);
18060: return Analyzer
18061: .cast(retValue$1864);
18062: }
18063: return null;
18064: }
18065: }
18066: .apply());
18067: }
18068:
18069: public Boolean apply() {
18070: return Analyzer
18071: .cast(is_used_expr
18072: .apply(
18073: s,
18074: init));
18075: }
18076: }.apply()
18077: : null == is_statement
18078: .apply(n) ? null
18079: : is_statement
18080: .apply(n) ? is_used
18081: .apply(
18082: s,
18083: n)
18084: : is_used_expr
18085: .apply(
18086: s,
18087: n));
18088: }
18089: };
18090:
18091: final Function.F1<Boolean, Node> is_extern_declaration = new Function.F1<Boolean, Node>() {
18092: public Boolean apply(final Node n) {
18093: return (null == Primitives.isBottom.apply(n) ? null
18094: : Primitives.isBottom.apply(n) ? Boolean.FALSE
18095: : new Match<Boolean>() {
18096: public Boolean apply() {
18097: final Node arg$1866 = GNode.cast(n);
18098:
18099: if ((null == arg$1866)) {
18100: return null;
18101: }
18102: if (CSupport.match$1867(arg$1866)) {
18103: matching_nodes.add(arg$1866);
18104: if ((null != arg$1866 && processScopeNodes
18105: .contains(arg$1866
18106: .getName()))) {
18107: processScope(arg$1866,
18108: getScope);
18109: }
18110: checkEnterScope(arg$1866);
18111:
18112: final Object retValue$1870 = Analyzer
18113: .cast(Boolean.TRUE);
18114:
18115: checkExitScope(arg$1866);
18116: matching_nodes
18117: .remove(matching_nodes
18118: .size() - 1);
18119: return Analyzer
18120: .cast(retValue$1870);
18121: }
18122: if (CSupport.match$1871(arg$1866)) {
18123: matching_nodes.add(arg$1866);
18124: if ((null != arg$1866 && processScopeNodes
18125: .contains(arg$1866
18126: .getName()))) {
18127: processScope(arg$1866,
18128: getScope);
18129: }
18130: checkEnterScope(arg$1866);
18131:
18132: final Object retValue$1874 = Analyzer
18133: .cast(Boolean.TRUE);
18134:
18135: checkExitScope(arg$1866);
18136: matching_nodes
18137: .remove(matching_nodes
18138: .size() - 1);
18139: return Analyzer
18140: .cast(retValue$1874);
18141: }
18142: if (CSupport.match$248(arg$1866)) {
18143: matching_nodes.add(arg$1866);
18144: if ((null != arg$1866 && processScopeNodes
18145: .contains(arg$1866
18146: .getName()))) {
18147: processScope(arg$1866,
18148: getScope);
18149: }
18150: checkEnterScope(arg$1866);
18151:
18152: final Object retValue$1878 = Analyzer
18153: .cast(Boolean.TRUE);
18154:
18155: checkExitScope(arg$1866);
18156: matching_nodes
18157: .remove(matching_nodes
18158: .size() - 1);
18159: return Analyzer
18160: .cast(retValue$1878);
18161: }
18162: if (CSupport.match$244(arg$1866)) {
18163: matching_nodes.add(arg$1866);
18164: if ((null != arg$1866 && processScopeNodes
18165: .contains(arg$1866
18166: .getName()))) {
18167: processScope(arg$1866,
18168: getScope);
18169: }
18170: checkEnterScope(arg$1866);
18171:
18172: final Object retValue$1882 = Analyzer
18173: .cast(Boolean.TRUE);
18174:
18175: checkExitScope(arg$1866);
18176: matching_nodes
18177: .remove(matching_nodes
18178: .size() - 1);
18179: return Analyzer
18180: .cast(retValue$1882);
18181: }
18182: if (true) {
18183: matching_nodes.add(arg$1866);
18184: if ((null != arg$1866 && processScopeNodes
18185: .contains(arg$1866
18186: .getName()))) {
18187: processScope(arg$1866,
18188: getScope);
18189: }
18190: checkEnterScope(arg$1866);
18191:
18192: final Object retValue$1885 = Analyzer
18193: .cast(Boolean.FALSE);
18194:
18195: checkExitScope(arg$1866);
18196: matching_nodes
18197: .remove(matching_nodes
18198: .size() - 1);
18199: return Analyzer
18200: .cast(retValue$1885);
18201: }
18202: return null;
18203: }
18204: }.apply());
18205: }
18206: };
18207:
18208: final Function.F1<Boolean, Node> is_statement = new Function.F1<Boolean, Node>() {
18209: public Boolean apply(final Node n) {
18210: return (null == Primitives.isBottom.apply(n) ? null
18211: : Primitives.isBottom.apply(n) ? Boolean.FALSE
18212: : new Match<Boolean>() {
18213: public Boolean apply() {
18214: final Node arg$1887 = GNode.cast(n);
18215:
18216: if ((null == arg$1887)) {
18217: return null;
18218: }
18219: if (CSupport.match$1888(arg$1887)) {
18220: matching_nodes.add(arg$1887);
18221: if ((null != arg$1887 && processScopeNodes
18222: .contains(arg$1887
18223: .getName()))) {
18224: processScope(arg$1887,
18225: getScope);
18226: }
18227: checkEnterScope(arg$1887);
18228:
18229: final Object retValue$1891 = Analyzer
18230: .cast(Boolean.TRUE);
18231:
18232: checkExitScope(arg$1887);
18233: matching_nodes
18234: .remove(matching_nodes
18235: .size() - 1);
18236: return Analyzer
18237: .cast(retValue$1891);
18238: }
18239: if (CSupport.match$83(arg$1887)) {
18240: matching_nodes.add(arg$1887);
18241: if ((null != arg$1887 && processScopeNodes
18242: .contains(arg$1887
18243: .getName()))) {
18244: processScope(arg$1887,
18245: getScope);
18246: }
18247: checkEnterScope(arg$1887);
18248:
18249: final Object retValue$1895 = Analyzer
18250: .cast(Boolean.TRUE);
18251:
18252: checkExitScope(arg$1887);
18253: matching_nodes
18254: .remove(matching_nodes
18255: .size() - 1);
18256: return Analyzer
18257: .cast(retValue$1895);
18258: }
18259: if (CSupport.match$1896(arg$1887)) {
18260: matching_nodes.add(arg$1887);
18261: if ((null != arg$1887 && processScopeNodes
18262: .contains(arg$1887
18263: .getName()))) {
18264: processScope(arg$1887,
18265: getScope);
18266: }
18267: checkEnterScope(arg$1887);
18268:
18269: final Object retValue$1899 = Analyzer
18270: .cast(Boolean.TRUE);
18271:
18272: checkExitScope(arg$1887);
18273: matching_nodes
18274: .remove(matching_nodes
18275: .size() - 1);
18276: return Analyzer
18277: .cast(retValue$1899);
18278: }
18279: if (CSupport.match$1900(arg$1887)) {
18280: matching_nodes.add(arg$1887);
18281: if ((null != arg$1887 && processScopeNodes
18282: .contains(arg$1887
18283: .getName()))) {
18284: processScope(arg$1887,
18285: getScope);
18286: }
18287: checkEnterScope(arg$1887);
18288:
18289: final Object retValue$1903 = Analyzer
18290: .cast(Boolean.TRUE);
18291:
18292: checkExitScope(arg$1887);
18293: matching_nodes
18294: .remove(matching_nodes
18295: .size() - 1);
18296: return Analyzer
18297: .cast(retValue$1903);
18298: }
18299: if (CSupport.match$1904(arg$1887)) {
18300: matching_nodes.add(arg$1887);
18301: if ((null != arg$1887 && processScopeNodes
18302: .contains(arg$1887
18303: .getName()))) {
18304: processScope(arg$1887,
18305: getScope);
18306: }
18307: checkEnterScope(arg$1887);
18308:
18309: final Object retValue$1907 = Analyzer
18310: .cast(Boolean.TRUE);
18311:
18312: checkExitScope(arg$1887);
18313: matching_nodes
18314: .remove(matching_nodes
18315: .size() - 1);
18316: return Analyzer
18317: .cast(retValue$1907);
18318: }
18319: if (CSupport.match$1908(arg$1887)) {
18320: matching_nodes.add(arg$1887);
18321: if ((null != arg$1887 && processScopeNodes
18322: .contains(arg$1887
18323: .getName()))) {
18324: processScope(arg$1887,
18325: getScope);
18326: }
18327: checkEnterScope(arg$1887);
18328:
18329: final Object retValue$1911 = Analyzer
18330: .cast(Boolean.TRUE);
18331:
18332: checkExitScope(arg$1887);
18333: matching_nodes
18334: .remove(matching_nodes
18335: .size() - 1);
18336: return Analyzer
18337: .cast(retValue$1911);
18338: }
18339: if (CSupport.match$1912(arg$1887)) {
18340: matching_nodes.add(arg$1887);
18341: if ((null != arg$1887 && processScopeNodes
18342: .contains(arg$1887
18343: .getName()))) {
18344: processScope(arg$1887,
18345: getScope);
18346: }
18347: checkEnterScope(arg$1887);
18348:
18349: final Object retValue$1915 = Analyzer
18350: .cast(Boolean.TRUE);
18351:
18352: checkExitScope(arg$1887);
18353: matching_nodes
18354: .remove(matching_nodes
18355: .size() - 1);
18356: return Analyzer
18357: .cast(retValue$1915);
18358: }
18359: if (CSupport.match$1916(arg$1887)) {
18360: matching_nodes.add(arg$1887);
18361: if ((null != arg$1887 && processScopeNodes
18362: .contains(arg$1887
18363: .getName()))) {
18364: processScope(arg$1887,
18365: getScope);
18366: }
18367: checkEnterScope(arg$1887);
18368:
18369: final Object retValue$1919 = Analyzer
18370: .cast(Boolean.TRUE);
18371:
18372: checkExitScope(arg$1887);
18373: matching_nodes
18374: .remove(matching_nodes
18375: .size() - 1);
18376: return Analyzer
18377: .cast(retValue$1919);
18378: }
18379: if (CSupport.match$1920(arg$1887)) {
18380: matching_nodes.add(arg$1887);
18381: if ((null != arg$1887 && processScopeNodes
18382: .contains(arg$1887
18383: .getName()))) {
18384: processScope(arg$1887,
18385: getScope);
18386: }
18387: checkEnterScope(arg$1887);
18388:
18389: final Object retValue$1923 = Analyzer
18390: .cast(Boolean.TRUE);
18391:
18392: checkExitScope(arg$1887);
18393: matching_nodes
18394: .remove(matching_nodes
18395: .size() - 1);
18396: return Analyzer
18397: .cast(retValue$1923);
18398: }
18399: if (CSupport.match$517(arg$1887)) {
18400: matching_nodes.add(arg$1887);
18401: if ((null != arg$1887 && processScopeNodes
18402: .contains(arg$1887
18403: .getName()))) {
18404: processScope(arg$1887,
18405: getScope);
18406: }
18407: checkEnterScope(arg$1887);
18408:
18409: final Object retValue$1927 = Analyzer
18410: .cast(Boolean.TRUE);
18411:
18412: checkExitScope(arg$1887);
18413: matching_nodes
18414: .remove(matching_nodes
18415: .size() - 1);
18416: return Analyzer
18417: .cast(retValue$1927);
18418: }
18419: if (CSupport.match$521(arg$1887)) {
18420: matching_nodes.add(arg$1887);
18421: if ((null != arg$1887 && processScopeNodes
18422: .contains(arg$1887
18423: .getName()))) {
18424: processScope(arg$1887,
18425: getScope);
18426: }
18427: checkEnterScope(arg$1887);
18428:
18429: final Object retValue$1931 = Analyzer
18430: .cast(Boolean.TRUE);
18431:
18432: checkExitScope(arg$1887);
18433: matching_nodes
18434: .remove(matching_nodes
18435: .size() - 1);
18436: return Analyzer
18437: .cast(retValue$1931);
18438: }
18439: if (CSupport.match$1932(arg$1887)) {
18440: matching_nodes.add(arg$1887);
18441: if ((null != arg$1887 && processScopeNodes
18442: .contains(arg$1887
18443: .getName()))) {
18444: processScope(arg$1887,
18445: getScope);
18446: }
18447: checkEnterScope(arg$1887);
18448:
18449: final Object retValue$1935 = Analyzer
18450: .cast(Boolean.TRUE);
18451:
18452: checkExitScope(arg$1887);
18453: matching_nodes
18454: .remove(matching_nodes
18455: .size() - 1);
18456: return Analyzer
18457: .cast(retValue$1935);
18458: }
18459: if (CSupport.match$1936(arg$1887)) {
18460: matching_nodes.add(arg$1887);
18461: if ((null != arg$1887 && processScopeNodes
18462: .contains(arg$1887
18463: .getName()))) {
18464: processScope(arg$1887,
18465: getScope);
18466: }
18467: checkEnterScope(arg$1887);
18468:
18469: final Object retValue$1939 = Analyzer
18470: .cast(Boolean.TRUE);
18471:
18472: checkExitScope(arg$1887);
18473: matching_nodes
18474: .remove(matching_nodes
18475: .size() - 1);
18476: return Analyzer
18477: .cast(retValue$1939);
18478: }
18479: if (CSupport.match$555(arg$1887)) {
18480: matching_nodes.add(arg$1887);
18481: if ((null != arg$1887 && processScopeNodes
18482: .contains(arg$1887
18483: .getName()))) {
18484: processScope(arg$1887,
18485: getScope);
18486: }
18487: checkEnterScope(arg$1887);
18488:
18489: final Object retValue$1943 = Analyzer
18490: .cast(Boolean.TRUE);
18491:
18492: checkExitScope(arg$1887);
18493: matching_nodes
18494: .remove(matching_nodes
18495: .size() - 1);
18496: return Analyzer
18497: .cast(retValue$1943);
18498: }
18499: if (CSupport.match$480(arg$1887)) {
18500: matching_nodes.add(arg$1887);
18501: if ((null != arg$1887 && processScopeNodes
18502: .contains(arg$1887
18503: .getName()))) {
18504: processScope(arg$1887,
18505: getScope);
18506: }
18507: checkEnterScope(arg$1887);
18508:
18509: final Object retValue$1947 = Analyzer
18510: .cast(Boolean.TRUE);
18511:
18512: checkExitScope(arg$1887);
18513: matching_nodes
18514: .remove(matching_nodes
18515: .size() - 1);
18516: return Analyzer
18517: .cast(retValue$1947);
18518: }
18519: if (true) {
18520: matching_nodes.add(arg$1887);
18521: if ((null != arg$1887 && processScopeNodes
18522: .contains(arg$1887
18523: .getName()))) {
18524: processScope(arg$1887,
18525: getScope);
18526: }
18527: checkEnterScope(arg$1887);
18528:
18529: final Object retValue$1950 = Analyzer
18530: .cast(Boolean.FALSE);
18531:
18532: checkExitScope(arg$1887);
18533: matching_nodes
18534: .remove(matching_nodes
18535: .size() - 1);
18536: return Analyzer
18537: .cast(retValue$1950);
18538: }
18539: return null;
18540: }
18541: }.apply());
18542: }
18543: };
18544:
18545: final Function.F1<Boolean, Node> is_init_decl_list = new Function.F1<Boolean, Node>() {
18546: public Boolean apply(final Node n) {
18547: return (null == Primitives.isBottom.apply(n) ? null
18548: : Primitives.isBottom.apply(n) ? Boolean.FALSE
18549: : new Match<Boolean>() {
18550: public Boolean apply() {
18551: final Node arg$1952 = GNode.cast(n);
18552:
18553: if ((null == arg$1952)) {
18554: return null;
18555: }
18556: if (CSupport.match$1953(arg$1952)) {
18557: matching_nodes.add(arg$1952);
18558: if ((null != arg$1952 && processScopeNodes
18559: .contains(arg$1952
18560: .getName()))) {
18561: processScope(arg$1952,
18562: getScope);
18563: }
18564: checkEnterScope(arg$1952);
18565:
18566: final Object retValue$1956 = Analyzer
18567: .cast(Boolean.TRUE);
18568:
18569: checkExitScope(arg$1952);
18570: matching_nodes
18571: .remove(matching_nodes
18572: .size() - 1);
18573: return Analyzer
18574: .cast(retValue$1956);
18575: }
18576: if (true) {
18577: matching_nodes.add(arg$1952);
18578: if ((null != arg$1952 && processScopeNodes
18579: .contains(arg$1952
18580: .getName()))) {
18581: processScope(arg$1952,
18582: getScope);
18583: }
18584: checkEnterScope(arg$1952);
18585:
18586: final Object retValue$1959 = Analyzer
18587: .cast(Boolean.FALSE);
18588:
18589: checkExitScope(arg$1952);
18590: matching_nodes
18591: .remove(matching_nodes
18592: .size() - 1);
18593: return Analyzer
18594: .cast(retValue$1959);
18595: }
18596: return null;
18597: }
18598: }.apply());
18599: }
18600: };
18601:
18602: final Function.F1<Boolean, Node> is_init_decl = new Function.F1<Boolean, Node>() {
18603: public Boolean apply(final Node n) {
18604: return (null == Primitives.isBottom.apply(n) ? null
18605: : Primitives.isBottom.apply(n) ? Boolean.FALSE
18606: : new Match<Boolean>() {
18607: public Boolean apply() {
18608: final Node arg$1961 = GNode.cast(n);
18609:
18610: if ((null == arg$1961)) {
18611: return null;
18612: }
18613: if (CSupport.match$1962(arg$1961)) {
18614: matching_nodes.add(arg$1961);
18615: if ((null != arg$1961 && processScopeNodes
18616: .contains(arg$1961
18617: .getName()))) {
18618: processScope(arg$1961,
18619: getScope);
18620: }
18621: checkEnterScope(arg$1961);
18622:
18623: final Object retValue$1965 = Analyzer
18624: .cast(Boolean.TRUE);
18625:
18626: checkExitScope(arg$1961);
18627: matching_nodes
18628: .remove(matching_nodes
18629: .size() - 1);
18630: return Analyzer
18631: .cast(retValue$1965);
18632: }
18633: if (true) {
18634: matching_nodes.add(arg$1961);
18635: if ((null != arg$1961 && processScopeNodes
18636: .contains(arg$1961
18637: .getName()))) {
18638: processScope(arg$1961,
18639: getScope);
18640: }
18641: checkEnterScope(arg$1961);
18642:
18643: final Object retValue$1968 = Analyzer
18644: .cast(Boolean.FALSE);
18645:
18646: checkExitScope(arg$1961);
18647: matching_nodes
18648: .remove(matching_nodes
18649: .size() - 1);
18650: return Analyzer
18651: .cast(retValue$1968);
18652: }
18653: return null;
18654: }
18655: }.apply());
18656: }
18657: };
18658:
18659: final Function.F1<Boolean, Node> is_init_entry = new Function.F1<Boolean, Node>() {
18660: public Boolean apply(final Node n) {
18661: return (null == Primitives.isBottom.apply(n) ? null
18662: : Primitives.isBottom.apply(n) ? Boolean.FALSE
18663: : new Match<Boolean>() {
18664: public Boolean apply() {
18665: final Node arg$1970 = GNode.cast(n);
18666:
18667: if ((null == arg$1970)) {
18668: return null;
18669: }
18670: if (CSupport.match$1971(arg$1970)) {
18671: matching_nodes.add(arg$1970);
18672: if ((null != arg$1970 && processScopeNodes
18673: .contains(arg$1970
18674: .getName()))) {
18675: processScope(arg$1970,
18676: getScope);
18677: }
18678: checkEnterScope(arg$1970);
18679:
18680: final Object retValue$1974 = Analyzer
18681: .cast(Boolean.TRUE);
18682:
18683: checkExitScope(arg$1970);
18684: matching_nodes
18685: .remove(matching_nodes
18686: .size() - 1);
18687: return Analyzer
18688: .cast(retValue$1974);
18689: }
18690: if (true) {
18691: matching_nodes.add(arg$1970);
18692: if ((null != arg$1970 && processScopeNodes
18693: .contains(arg$1970
18694: .getName()))) {
18695: processScope(arg$1970,
18696: getScope);
18697: }
18698: checkEnterScope(arg$1970);
18699:
18700: final Object retValue$1977 = Analyzer
18701: .cast(Boolean.FALSE);
18702:
18703: checkExitScope(arg$1970);
18704: matching_nodes
18705: .remove(matching_nodes
18706: .size() - 1);
18707: return Analyzer
18708: .cast(retValue$1977);
18709: }
18710: return null;
18711: }
18712: }.apply());
18713: }
18714: };
18715:
18716: final Function.F2<Object, Pair<CTypes.label_record>, Node> check_defined_labels = new Function.F2<Object, Pair<CTypes.label_record>, Node>() {
18717: public Object apply(final Pair<CTypes.label_record> sl,
18718: final Node n) {
18719: return new Match<Object>() {
18720: public Object apply() {
18721: final Pair<CTypes.label_record> arg$1979 = Analyzer
18722: .cast(sl);
18723:
18724: if ((null == arg$1979)) {
18725: return null;
18726: }
18727: if (CSupport.match$1222(arg$1979)) {
18728: return Analyzer.cast(null);
18729: }
18730: if (true) {
18731: final Pair<CTypes.label_record> list$1981 = Analyzer
18732: .cast(Analyzer.cast(arg$1979));
18733: final CTypes.label_record x = Analyzer
18734: .cast(Primitives.wrapHead(list$1981));
18735: final Pair<CTypes.label_record> xs = Analyzer
18736: .cast(Primitives.wrapTail(list$1981));
18737:
18738: return Analyzer.cast(new Let<Object>() {
18739: final String name;
18740: final Node nod;
18741:
18742: {
18743: name = Analyzer.cast(null == x ? null
18744: : x.label_name);
18745: nod = Analyzer.cast(null == x ? null
18746: : x.label_position);
18747: Analyzer
18748: .discard(null == Primitives.not
18749: .apply(is_used.apply(
18750: name, n))
18751: || !Primitives.not
18752: .apply(is_used
18753: .apply(
18754: name,
18755: n)) ? null
18756: : warning(
18757: Primitives.concat
18758: .apply(
18759: Primitives.concat
18760: .apply(
18761: "label '",
18762: name),
18763: "' defined but not used"),
18764: nod));
18765: }
18766:
18767: public Object apply() {
18768: return Analyzer
18769: .cast(check_defined_labels
18770: .apply(xs, n));
18771: }
18772: }.apply());
18773: }
18774: return null;
18775: }
18776: }.apply();
18777: }
18778: };
18779:
18780: final Function.F2<Object, Node, Pair<CTypes.label_record>> check_declared_labels = new Function.F2<Object, Node, Pair<CTypes.label_record>>() {
18781: public Object apply(final Node st,
18782: final Pair<CTypes.label_record> sl) {
18783: return new Match<Object>() {
18784: public Object apply() {
18785: final Pair<CTypes.label_record> arg$1983 = Analyzer
18786: .cast(sl);
18787:
18788: if ((null == arg$1983)) {
18789: return null;
18790: }
18791: if (CSupport.match$1222(arg$1983)) {
18792: return Analyzer.cast(null);
18793: }
18794: if (true) {
18795: final Pair<CTypes.label_record> list$1985 = Analyzer
18796: .cast(Analyzer.cast(arg$1983));
18797: final CTypes.label_record x = Analyzer
18798: .cast(Primitives.wrapHead(list$1985));
18799: final Pair<CTypes.label_record> xs = Analyzer
18800: .cast(Primitives.wrapTail(list$1985));
18801:
18802: return Analyzer.cast(new Let<Object>() {
18803: final String name;
18804: final Node nod;
18805: final CTypes.type ty;
18806:
18807: {
18808: name = Analyzer.cast(null == x ? null
18809: : x.label_name);
18810: nod = Analyzer.cast(null == x ? null
18811: : x.label_position);
18812: ty = Analyzer.cast(Analyzer
18813: .cast(lookup2.apply(GNode
18814: .create("NamedLabel",
18815: name, null),
18816: getNameSpace)));
18817: Analyzer
18818: .discard(null == Primitives.not
18819: .apply(null == ty ? null
18820: : ty.initialised) ? null
18821: : Primitives.not
18822: .apply(null == ty ? null
18823: : ty.initialised) ? warning(
18824: Primitives.concat
18825: .apply(
18826: Primitives.concat
18827: .apply(
18828: "'",
18829: name),
18830: " declared but not defined"),
18831: nod)
18832: : null == Primitives.not
18833: .apply(is_used
18834: .apply(
18835: name,
18836: st))
18837: || !Primitives.not
18838: .apply(is_used
18839: .apply(
18840: name,
18841: st)) ? null
18842: : new Let<Object>() {
18843: final Node nod;
18844:
18845: {
18846: nod = Analyzer
18847: .cast(null == ty ? null
18848: : ty.position);
18849: }
18850:
18851: public Object apply() {
18852: return Analyzer
18853: .cast(warning(
18854: Primitives.concat
18855: .apply(
18856: Primitives.concat
18857: .apply(
18858: "'",
18859: name),
18860: " defined but not used"),
18861: nod));
18862: }
18863: }
18864: .apply());
18865: }
18866:
18867: public Object apply() {
18868: return Analyzer
18869: .cast(check_declared_labels
18870: .apply(st, xs));
18871: }
18872: }.apply());
18873: }
18874: return null;
18875: }
18876: }.apply();
18877: }
18878: };
18879:
18880: final Function.F2<Pair<CTypes.label_record>, Node, Pair<CTypes.label_record>> find_labels = new Function.F2<Pair<CTypes.label_record>, Node, Pair<CTypes.label_record>>() {
18881: public Pair<CTypes.label_record> apply(final Node n,
18882: final Pair<CTypes.label_record> res) {
18883: return (null == Primitives.isBottom.apply(n) ? null
18884: : Primitives.isBottom.apply(n) ? res
18885: : new Match<Pair<CTypes.label_record>>() {
18886: public Pair<CTypes.label_record> apply() {
18887: final Node arg$1987 = GNode.cast(n);
18888:
18889: if ((null == arg$1987)) {
18890: return null;
18891: }
18892: if (CSupport.match$488(arg$1987)) {
18893: final Pair<Node> l = Analyzer
18894: .cast(Primitives
18895: .getChildren(
18896: arg$1987,
18897: 0,
18898: arg$1987
18899: .size()));
18900:
18901: matching_nodes.add(arg$1987);
18902: if ((null != arg$1987 && processScopeNodes
18903: .contains(arg$1987
18904: .getName()))) {
18905: processScope(arg$1987,
18906: getScope);
18907: }
18908: checkEnterScope(arg$1987);
18909:
18910: final Object retValue$1991 = Analyzer
18911: .cast(new Let<Pair<CTypes.label_record>>() {
18912: final Pair<CTypes.label_record> local_labels;
18913: final Pair<CTypes.label_record> sl;
18914: final Pair<CTypes.label_record> new_labels;
18915:
18916: {
18917: local_labels = Analyzer
18918: .cast(find_local_labels
18919: .apply(
18920: l,
18921: Pair
18922: .<CTypes.label_record> empty()));
18923: Analyzer
18924: .discard(null == Primitives.not
18925: .apply(Primitives.isEmpty
18926: .apply(local_labels))
18927: || !Primitives.not
18928: .apply(Primitives.isEmpty
18929: .apply(local_labels)) ? null
18930: : define_labels
18931: .apply(
18932: local_labels,
18933: Boolean.FALSE));
18934: sl = Analyzer
18935: .cast(find_labels_in_list
18936: .apply(l));
18937: check_declared_labels
18938: .apply(
18939: n,
18940: local_labels);
18941: new_labels = Analyzer
18942: .cast(labels_subtraction
18943: .apply(
18944: sl,
18945: local_labels,
18946: Pair
18947: .<CTypes.label_record> empty()));
18948: }
18949:
18950: public Pair<CTypes.label_record> apply() {
18951: return Analyzer
18952: .cast(labels_union
18953: .apply(
18954: res,
18955: new_labels));
18956: }
18957: }.apply());
18958:
18959: checkExitScope(arg$1987);
18960: matching_nodes
18961: .remove(matching_nodes
18962: .size() - 1);
18963: return Analyzer
18964: .cast(retValue$1991);
18965: }
18966: if (CSupport.match$497(arg$1987)) {
18967: final Node cs = (arg$1987
18968: .size() > 1 ? arg$1987
18969: .getGeneric(1) : null);
18970:
18971: matching_nodes.add(arg$1987);
18972: if ((null != arg$1987 && processScopeNodes
18973: .contains(arg$1987
18974: .getName()))) {
18975: processScope(arg$1987,
18976: getScope);
18977: }
18978: checkEnterScope(arg$1987);
18979:
18980: final Object retValue$1995 = Analyzer
18981: .cast(labels_union
18982: .apply(
18983: res,
18984: find_labels
18985: .apply(
18986: cs,
18987: Pair
18988: .<CTypes.label_record> empty())));
18989:
18990: checkExitScope(arg$1987);
18991: matching_nodes
18992: .remove(matching_nodes
18993: .size() - 1);
18994: return Analyzer
18995: .cast(retValue$1995);
18996: }
18997: if (CSupport.match$501(arg$1987)) {
18998: final Node cs = (arg$1987
18999: .size() > 1 ? arg$1987
19000: .getGeneric(1) : null);
19001:
19002: matching_nodes.add(arg$1987);
19003: if ((null != arg$1987 && processScopeNodes
19004: .contains(arg$1987
19005: .getName()))) {
19006: processScope(arg$1987,
19007: getScope);
19008: }
19009: checkEnterScope(arg$1987);
19010:
19011: final Object retValue$1999 = Analyzer
19012: .cast(labels_union
19013: .apply(
19014: res,
19015: find_labels
19016: .apply(
19017: cs,
19018: Pair
19019: .<CTypes.label_record> empty())));
19020:
19021: checkExitScope(arg$1987);
19022: matching_nodes
19023: .remove(matching_nodes
19024: .size() - 1);
19025: return Analyzer
19026: .cast(retValue$1999);
19027: }
19028: if (CSupport.match$505(arg$1987)) {
19029: final Node cs = (arg$1987
19030: .size() > 0 ? arg$1987
19031: .getGeneric(0) : null);
19032:
19033: matching_nodes.add(arg$1987);
19034: if ((null != arg$1987 && processScopeNodes
19035: .contains(arg$1987
19036: .getName()))) {
19037: processScope(arg$1987,
19038: getScope);
19039: }
19040: checkEnterScope(arg$1987);
19041:
19042: final Object retValue$2003 = Analyzer
19043: .cast(labels_union
19044: .apply(
19045: res,
19046: find_labels
19047: .apply(
19048: cs,
19049: Pair
19050: .<CTypes.label_record> empty())));
19051:
19052: checkExitScope(arg$1987);
19053: matching_nodes
19054: .remove(matching_nodes
19055: .size() - 1);
19056: return Analyzer
19057: .cast(retValue$2003);
19058: }
19059: if (CSupport.match$509(arg$1987)) {
19060: final Node cs = (arg$1987
19061: .size() > 1 ? arg$1987
19062: .getGeneric(1) : null);
19063:
19064: matching_nodes.add(arg$1987);
19065: if ((null != arg$1987 && processScopeNodes
19066: .contains(arg$1987
19067: .getName()))) {
19068: processScope(arg$1987,
19069: getScope);
19070: }
19071: checkEnterScope(arg$1987);
19072:
19073: final Object retValue$2007 = Analyzer
19074: .cast(labels_union
19075: .apply(
19076: res,
19077: find_labels
19078: .apply(
19079: cs,
19080: Pair
19081: .<CTypes.label_record> empty())));
19082:
19083: checkExitScope(arg$1987);
19084: matching_nodes
19085: .remove(matching_nodes
19086: .size() - 1);
19087: return Analyzer
19088: .cast(retValue$2007);
19089: }
19090: if (CSupport.match$82(arg$1987)) {
19091: final Node cs = (arg$1987
19092: .size() > 3 ? arg$1987
19093: .getGeneric(3) : null);
19094:
19095: matching_nodes.add(arg$1987);
19096: if ((null != arg$1987 && processScopeNodes
19097: .contains(arg$1987
19098: .getName()))) {
19099: processScope(arg$1987,
19100: getScope);
19101: }
19102: checkEnterScope(arg$1987);
19103:
19104: final Object retValue$2011 = Analyzer
19105: .cast(labels_union
19106: .apply(
19107: res,
19108: find_labels
19109: .apply(
19110: cs,
19111: Pair
19112: .<CTypes.label_record> empty())));
19113:
19114: checkExitScope(arg$1987);
19115: matching_nodes
19116: .remove(matching_nodes
19117: .size() - 1);
19118: return Analyzer
19119: .cast(retValue$2011);
19120: }
19121: if (CSupport.match$484(arg$1987)) {
19122: final Node e = (arg$1987.size() > 0 ? arg$1987
19123: .getGeneric(0)
19124: : null);
19125:
19126: matching_nodes.add(arg$1987);
19127: if ((null != arg$1987 && processScopeNodes
19128: .contains(arg$1987
19129: .getName()))) {
19130: processScope(arg$1987,
19131: getScope);
19132: }
19133: checkEnterScope(arg$1987);
19134:
19135: final Object retValue$2016 = Analyzer
19136: .cast(CSupport.union$2013
19137: .apply(
19138: res,
19139: find_labels_expr
19140: .apply(
19141: e,
19142: Pair
19143: .<CTypes.label_record> empty())));
19144:
19145: checkExitScope(arg$1987);
19146: matching_nodes
19147: .remove(matching_nodes
19148: .size() - 1);
19149: return Analyzer
19150: .cast(retValue$2016);
19151: }
19152: if (CSupport.match$493(arg$1987)) {
19153: final Node cs1 = (arg$1987
19154: .size() > 1 ? arg$1987
19155: .getGeneric(1) : null);
19156: final Node cs2 = (arg$1987
19157: .size() > 2 ? arg$1987
19158: .getGeneric(2) : null);
19159:
19160: matching_nodes.add(arg$1987);
19161: if ((null != arg$1987 && processScopeNodes
19162: .contains(arg$1987
19163: .getName()))) {
19164: processScope(arg$1987,
19165: getScope);
19166: }
19167: checkEnterScope(arg$1987);
19168:
19169: final Object retValue$2020 = Analyzer
19170: .cast(new Let<Pair<CTypes.label_record>>() {
19171: final Pair<CTypes.label_record> sl1;
19172: final Pair<CTypes.label_record> sl2;
19173:
19174: {
19175: sl1 = Analyzer
19176: .cast(find_labels
19177: .apply(
19178: cs1,
19179: Pair
19180: .<CTypes.label_record> empty()));
19181: sl2 = Analyzer
19182: .cast(find_labels
19183: .apply(
19184: cs2,
19185: Pair
19186: .<CTypes.label_record> empty()));
19187: }
19188:
19189: public Pair<CTypes.label_record> apply() {
19190: return Analyzer
19191: .cast(labels_union
19192: .apply(
19193: res,
19194: CSupport.union$2013
19195: .apply(
19196: sl1,
19197: sl2)));
19198: }
19199: }.apply());
19200:
19201: checkExitScope(arg$1987);
19202: matching_nodes
19203: .remove(matching_nodes
19204: .size() - 1);
19205: return Analyzer
19206: .cast(retValue$2020);
19207: }
19208: if (CSupport.match$2021(arg$1987)) {
19209: final Node nlb = Analyzer
19210: .cast(arg$1987
19211: .getGeneric(0));
19212: final Node st = (arg$1987
19213: .size() > 1 ? arg$1987
19214: .getGeneric(1) : null);
19215:
19216: matching_nodes.add(arg$1987);
19217: if ((null != arg$1987 && processScopeNodes
19218: .contains(arg$1987
19219: .getName()))) {
19220: processScope(arg$1987,
19221: getScope);
19222: }
19223: checkEnterScope(arg$1987);
19224:
19225: final Object retValue$2042 = Analyzer
19226: .cast(new Let<Pair<CTypes.label_record>>() {
19227: final String s;
19228: final Pair<CTypes.label_record> sl;
19229: final Pair<CTypes.label_record> ret;
19230:
19231: {
19232: s = Analyzer
19233: .cast(new Match<String>() {
19234: public String apply() {
19235: final Node arg$2031 = GNode
19236: .cast(nlb);
19237:
19238: if ((null == arg$2031)) {
19239: return null;
19240: }
19241: if (CSupport
19242: .match$33(arg$2031)) {
19243: final String str = (arg$2031
19244: .size() > 0 ? arg$2031
19245: .getString(0)
19246: : null);
19247:
19248: matching_nodes
19249: .add(arg$2031);
19250: if ((null != arg$2031 && processScopeNodes
19251: .contains(arg$2031
19252: .getName()))) {
19253: processScope(
19254: arg$2031,
19255: getScope);
19256: }
19257: checkEnterScope(arg$2031);
19258:
19259: final Object retValue$2035 = Analyzer
19260: .cast(str);
19261:
19262: checkExitScope(arg$2031);
19263: matching_nodes
19264: .remove(matching_nodes
19265: .size() - 1);
19266: return Analyzer
19267: .cast(retValue$2035);
19268: }
19269: if (true) {
19270: matching_nodes
19271: .add(arg$2031);
19272: if ((null != arg$2031 && processScopeNodes
19273: .contains(arg$2031
19274: .getName()))) {
19275: processScope(
19276: arg$2031,
19277: getScope);
19278: }
19279: checkEnterScope(arg$2031);
19280:
19281: final Object retValue$2038 = Analyzer
19282: .cast(null);
19283:
19284: checkExitScope(arg$2031);
19285: matching_nodes
19286: .remove(matching_nodes
19287: .size() - 1);
19288: return Analyzer
19289: .cast(retValue$2038);
19290: }
19291: return null;
19292: }
19293: }
19294: .apply());
19295: sl = Analyzer
19296: .cast(find_labels
19297: .apply(
19298: st,
19299: Pair
19300: .<CTypes.label_record> empty()));
19301: ret = Analyzer
19302: .cast(labels_union
19303: .apply(
19304: res,
19305: sl));
19306: }
19307:
19308: public Pair<CTypes.label_record> apply() {
19309: return Analyzer
19310: .cast(null == Primitives.not
19311: .apply(isDefined
19312: .apply(
19313: n,
19314: getNameSpace)) ? null
19315: : Primitives.not
19316: .apply(isDefined
19317: .apply(
19318: n,
19319: getNameSpace)) ? new Let<Pair<CTypes.label_record>>() {
19320: {
19321: define3
19322: .apply(
19323: n,
19324: new CTypes.type(
19325: new CTypes.LabelT(
19326: s),
19327: null,
19328: null,
19329: null,
19330: null,
19331: null,
19332: Boolean.TRUE,
19333: n,
19334: null,
19335: null,
19336: null),
19337: getNameSpace);
19338: }
19339:
19340: public Pair<CTypes.label_record> apply() {
19341: return Analyzer
19342: .cast(labels_union
19343: .apply(
19344: ret,
19345: new Pair<CTypes.label_record>(
19346: new CTypes.label_record(
19347: s,
19348: n))));
19349: }
19350: }
19351: .apply()
19352: : new Let<Pair<CTypes.label_record>>() {
19353: final CTypes.type t;
19354:
19355: {
19356: t = Analyzer
19357: .cast(Analyzer
19358: .cast(lookup2
19359: .apply(
19360: n,
19361: getNameSpace)));
19362: }
19363:
19364: public Pair<CTypes.label_record> apply() {
19365: return Analyzer
19366: .cast(null == Primitives.not
19367: .apply(null == t ? null
19368: : t.initialised) ? null
19369: : Primitives.not
19370: .apply(null == t ? null
19371: : t.initialised) ? new Let<Pair<CTypes.label_record>>() {
19372: {
19373: redefine
19374: .apply(
19375: n,
19376: new CTypes.type(
19377: new CTypes.LabelT(
19378: s),
19379: null,
19380: null,
19381: null,
19382: null,
19383: null,
19384: Boolean.TRUE,
19385: n,
19386: null,
19387: null,
19388: null),
19389: getNameSpace);
19390: }
19391:
19392: public Pair<CTypes.label_record> apply() {
19393: return Analyzer
19394: .cast(labels_union
19395: .apply(
19396: ret,
19397: new Pair<CTypes.label_record>(
19398: new CTypes.label_record(
19399: s,
19400: n))));
19401: }
19402: }
19403: .apply()
19404: : new Let<Pair<CTypes.label_record>>() {
19405: final Node pos;
19406:
19407: {
19408: pos = Analyzer
19409: .cast(null == t ? null
19410: : t.position);
19411: error(
19412: Primitives.concat
19413: .apply(
19414: Primitives.concat
19415: .apply(
19416: "duplicate label '",
19417: s),
19418: "'"),
19419: null);
19420: error(
19421: Primitives.concat
19422: .apply(
19423: Primitives.concat
19424: .apply(
19425: "previous definition of '",
19426: s),
19427: "' was here **"),
19428: pos);
19429: }
19430:
19431: public Pair<CTypes.label_record> apply() {
19432: return Analyzer
19433: .cast(ret);
19434: }
19435: }
19436: .apply());
19437: }
19438: }
19439: .apply());
19440: }
19441: }.apply());
19442:
19443: checkExitScope(arg$1987);
19444: matching_nodes
19445: .remove(matching_nodes
19446: .size() - 1);
19447: return Analyzer
19448: .cast(retValue$2042);
19449: }
19450: if (CSupport.match$551(arg$1987)) {
19451: final Node st = (arg$1987
19452: .size() > 1 ? arg$1987
19453: .getGeneric(1) : null);
19454:
19455: matching_nodes.add(arg$1987);
19456: if ((null != arg$1987 && processScopeNodes
19457: .contains(arg$1987
19458: .getName()))) {
19459: processScope(arg$1987,
19460: getScope);
19461: }
19462: checkEnterScope(arg$1987);
19463:
19464: final Object retValue$2046 = Analyzer
19465: .cast(labels_union
19466: .apply(
19467: res,
19468: find_labels
19469: .apply(
19470: st,
19471: Pair
19472: .<CTypes.label_record> empty())));
19473:
19474: checkExitScope(arg$1987);
19475: matching_nodes
19476: .remove(matching_nodes
19477: .size() - 1);
19478: return Analyzer
19479: .cast(retValue$2046);
19480: }
19481: if (true) {
19482: matching_nodes.add(arg$1987);
19483: if ((null != arg$1987 && processScopeNodes
19484: .contains(arg$1987
19485: .getName()))) {
19486: processScope(arg$1987,
19487: getScope);
19488: }
19489: checkEnterScope(arg$1987);
19490:
19491: final Object retValue$2049 = Analyzer
19492: .cast(res);
19493:
19494: checkExitScope(arg$1987);
19495: matching_nodes
19496: .remove(matching_nodes
19497: .size() - 1);
19498: return Analyzer
19499: .cast(retValue$2049);
19500: }
19501: return null;
19502: }
19503: }.apply());
19504: }
19505: };
19506:
19507: final Function.F2<Pair<CTypes.label_record>, Node, Pair<CTypes.label_record>> find_labels_expr = new Function.F2<Pair<CTypes.label_record>, Node, Pair<CTypes.label_record>>() {
19508: public Pair<CTypes.label_record> apply(final Node n,
19509: final Pair<CTypes.label_record> res) {
19510: return (null == Primitives.isBottom.apply(n) ? null
19511: : Primitives.isBottom.apply(n) ? res
19512: : new Match<Pair<CTypes.label_record>>() {
19513: public Pair<CTypes.label_record> apply() {
19514: final Node arg$2051 = GNode.cast(n);
19515:
19516: if ((null == arg$2051)) {
19517: return null;
19518: }
19519: if (CSupport.match$828(arg$2051)) {
19520: final Node cs = (arg$2051
19521: .size() > 0 ? arg$2051
19522: .getGeneric(0) : null);
19523:
19524: matching_nodes.add(arg$2051);
19525: if ((null != arg$2051 && processScopeNodes
19526: .contains(arg$2051
19527: .getName()))) {
19528: processScope(arg$2051,
19529: getScope);
19530: }
19531: checkEnterScope(arg$2051);
19532:
19533: final Object retValue$2055 = Analyzer
19534: .cast(labels_union
19535: .apply(
19536: res,
19537: find_labels
19538: .apply(
19539: cs,
19540: Pair
19541: .<CTypes.label_record> empty())));
19542:
19543: checkExitScope(arg$2051);
19544: matching_nodes
19545: .remove(matching_nodes
19546: .size() - 1);
19547: return Analyzer
19548: .cast(retValue$2055);
19549: }
19550: if (CSupport.match$609(arg$2051)) {
19551: final Node e1 = (arg$2051
19552: .size() > 1 ? arg$2051
19553: .getGeneric(1) : null);
19554: final Node e2 = (arg$2051
19555: .size() > 2 ? arg$2051
19556: .getGeneric(2) : null);
19557:
19558: matching_nodes.add(arg$2051);
19559: if ((null != arg$2051 && processScopeNodes
19560: .contains(arg$2051
19561: .getName()))) {
19562: processScope(arg$2051,
19563: getScope);
19564: }
19565: checkEnterScope(arg$2051);
19566:
19567: final Object retValue$2059 = Analyzer
19568: .cast(new Let<Pair<CTypes.label_record>>() {
19569: final Pair<CTypes.label_record> sl1;
19570: final Pair<CTypes.label_record> sl2;
19571:
19572: {
19573: sl1 = Analyzer
19574: .cast(find_labels_expr
19575: .apply(
19576: e1,
19577: Pair
19578: .<CTypes.label_record> empty()));
19579: sl2 = Analyzer
19580: .cast(find_labels_expr
19581: .apply(
19582: e2,
19583: Pair
19584: .<CTypes.label_record> empty()));
19585: }
19586:
19587: public Pair<CTypes.label_record> apply() {
19588: return Analyzer
19589: .cast(labels_union
19590: .apply(
19591: res,
19592: labels_union
19593: .apply(
19594: sl1,
19595: sl2)));
19596: }
19597: }.apply());
19598:
19599: checkExitScope(arg$2051);
19600: matching_nodes
19601: .remove(matching_nodes
19602: .size() - 1);
19603: return Analyzer
19604: .cast(retValue$2059);
19605: }
19606: if (true) {
19607: matching_nodes.add(arg$2051);
19608: if ((null != arg$2051 && processScopeNodes
19609: .contains(arg$2051
19610: .getName()))) {
19611: processScope(arg$2051,
19612: getScope);
19613: }
19614: checkEnterScope(arg$2051);
19615:
19616: final Object retValue$2062 = Analyzer
19617: .cast(res);
19618:
19619: checkExitScope(arg$2051);
19620: matching_nodes
19621: .remove(matching_nodes
19622: .size() - 1);
19623: return Analyzer
19624: .cast(retValue$2062);
19625: }
19626: return null;
19627: }
19628: }.apply());
19629: }
19630: };
19631:
19632: final Function.F2<Pair<CTypes.label_record>, Pair<Node>, Pair<CTypes.label_record>> find_local_labels = new Function.F2<Pair<CTypes.label_record>, Pair<Node>, Pair<CTypes.label_record>>() {
19633: public Pair<CTypes.label_record> apply(final Pair<Node> nl,
19634: final Pair<CTypes.label_record> res) {
19635: return new Match<Pair<CTypes.label_record>>() {
19636: public Pair<CTypes.label_record> apply() {
19637: final Pair<Node> arg$2064 = Analyzer.cast(nl);
19638:
19639: if ((null == arg$2064)) {
19640: return null;
19641: }
19642: if (CSupport.match$383(arg$2064)) {
19643: return Analyzer.cast(res);
19644: }
19645: if (true) {
19646: final Pair<Node> list$2066 = Analyzer
19647: .cast(Analyzer.cast(arg$2064));
19648: final Node x = GNode.cast(Primitives
19649: .wrapHead(list$2066));
19650: final Pair<Node> xs = Analyzer.cast(Primitives
19651: .wrapTail(list$2066));
19652:
19653: return Analyzer
19654: .cast(null == Primitives.isBottom
19655: .apply(x) ? null
19656: : Primitives.isBottom.apply(x) ? find_local_labels
19657: .apply(xs, res)
19658: : new Match<Pair<CTypes.label_record>>() {
19659: public Pair<CTypes.label_record> apply() {
19660: final Node arg$2076 = GNode
19661: .cast(x);
19662:
19663: if ((null == arg$2076)) {
19664: return null;
19665: }
19666: if (CSupport
19667: .match$2068(arg$2076)) {
19668: final Pair<String> sl = Analyzer
19669: .cast(Primitives
19670: .getChildren(
19671: arg$2076,
19672: 0,
19673: arg$2076
19674: .size()));
19675:
19676: matching_nodes
19677: .add(arg$2076);
19678: if ((null != arg$2076 && processScopeNodes
19679: .contains(arg$2076
19680: .getName()))) {
19681: processScope(
19682: arg$2076,
19683: getScope);
19684: }
19685: checkEnterScope(arg$2076);
19686:
19687: final Object retValue$2080 = Analyzer
19688: .cast(new Let<Pair<CTypes.label_record>>() {
19689: final Pair<CTypes.label_record> ll;
19690:
19691: {
19692: ll = Analyzer
19693: .cast(process_local_labels
19694: .apply(
19695: sl,
19696: x,
19697: Pair
19698: .<CTypes.label_record> empty()));
19699: }
19700:
19701: public Pair<CTypes.label_record> apply() {
19702: return Analyzer
19703: .cast(find_local_labels
19704: .apply(
19705: xs,
19706: labels_union
19707: .apply(
19708: res,
19709: ll)));
19710: }
19711: }
19712: .apply());
19713:
19714: checkExitScope(arg$2076);
19715: matching_nodes
19716: .remove(matching_nodes
19717: .size() - 1);
19718: return Analyzer
19719: .cast(retValue$2080);
19720: }
19721: if (true) {
19722: matching_nodes
19723: .add(arg$2076);
19724: if ((null != arg$2076 && processScopeNodes
19725: .contains(arg$2076
19726: .getName()))) {
19727: processScope(
19728: arg$2076,
19729: getScope);
19730: }
19731: checkEnterScope(arg$2076);
19732:
19733: final Object retValue$2083 = Analyzer
19734: .cast(find_local_labels
19735: .apply(
19736: xs,
19737: res));
19738:
19739: checkExitScope(arg$2076);
19740: matching_nodes
19741: .remove(matching_nodes
19742: .size() - 1);
19743: return Analyzer
19744: .cast(retValue$2083);
19745: }
19746: return null;
19747: }
19748: }.apply());
19749: }
19750: return null;
19751: }
19752: }.apply();
19753: }
19754: };
19755:
19756: final Function.F3<Pair<CTypes.label_record>, Pair<String>, Node, Pair<CTypes.label_record>> process_local_labels = new Function.F3<Pair<CTypes.label_record>, Pair<String>, Node, Pair<CTypes.label_record>>() {
19757: public Pair<CTypes.label_record> apply(final Pair<String> sl,
19758: final Node loc, final Pair<CTypes.label_record> res) {
19759: return new Match<Pair<CTypes.label_record>>() {
19760: public Pair<CTypes.label_record> apply() {
19761: final Pair<String> arg$2086 = Analyzer.cast(sl);
19762:
19763: if ((null == arg$2086)) {
19764: return null;
19765: }
19766: if (CSupport.match$1218(arg$2086)) {
19767: return Analyzer.cast(res);
19768: }
19769: if (true) {
19770: final Pair<String> list$2088 = Analyzer
19771: .cast(Analyzer.cast(arg$2086));
19772: final String x = Analyzer.cast(Primitives
19773: .wrapHead(list$2088));
19774: final Pair<String> xs = Analyzer
19775: .cast(Primitives.wrapTail(list$2088));
19776:
19777: return Analyzer
19778: .cast(new Let<Pair<CTypes.label_record>>() {
19779: {
19780: redefine
19781: .apply(
19782: GNode
19783: .create(
19784: "NamedLabel",
19785: x,
19786: null),
19787: new CTypes.type(
19788: new CTypes.LabelT(
19789: x),
19790: null,
19791: null,
19792: null,
19793: null,
19794: null,
19795: Boolean.FALSE,
19796: loc,
19797: null,
19798: null,
19799: null),
19800: getNameSpace);
19801: }
19802:
19803: public Pair<CTypes.label_record> apply() {
19804: return Analyzer
19805: .cast(process_local_labels
19806: .apply(
19807: xs,
19808: loc,
19809: CSupport.union$2013
19810: .apply(
19811: res,
19812: new Pair<CTypes.label_record>(
19813: new CTypes.label_record(
19814: x,
19815: loc)))));
19816: }
19817: }.apply());
19818: }
19819: return null;
19820: }
19821: }.apply();
19822: }
19823: };
19824:
19825: final Function.F1<Pair<CTypes.label_record>, Pair<Node>> find_labels_in_list = new Function.F1<Pair<CTypes.label_record>, Pair<Node>>() {
19826: public Pair<CTypes.label_record> apply(final Pair<Node> nl) {
19827: return (null == Primitives.isBottom.apply(nl) ? null
19828: : Primitives.isBottom.apply(nl) ? Pair
19829: .<CTypes.label_record> empty()
19830: : new Match<Pair<CTypes.label_record>>() {
19831: public Pair<CTypes.label_record> apply() {
19832: final Pair<Node> arg$2090 = Analyzer
19833: .cast(nl);
19834:
19835: if ((null == arg$2090)) {
19836: return null;
19837: }
19838: if (CSupport.match$383(arg$2090)) {
19839: return Analyzer
19840: .cast(Pair
19841: .<CTypes.label_record> empty());
19842: }
19843: if (true) {
19844: final Pair<Node> list$2092 = Analyzer
19845: .cast(Analyzer
19846: .cast(arg$2090));
19847: final Node x = GNode
19848: .cast(Primitives
19849: .wrapHead(list$2092));
19850: final Pair<Node> xs = Analyzer
19851: .cast(Primitives
19852: .wrapTail(list$2092));
19853:
19854: return Analyzer
19855: .cast(labels_union
19856: .apply(
19857: find_labels
19858: .apply(
19859: x,
19860: Pair
19861: .<CTypes.label_record> empty()),
19862: find_labels_in_list
19863: .apply(xs)));
19864: }
19865: return null;
19866: }
19867: }.apply());
19868: }
19869: };
19870:
19871: final Function.F2<CTypes.type, Node, CTypes.type> analyze_initializer = new Function.F2<CTypes.type, Node, CTypes.type>() {
19872: public CTypes.type apply(final Node n, final CTypes.type t) {
19873: return (null == Primitives.isBottom.apply(t) ? null
19874: : Primitives.isBottom.apply(t) ? null
19875: : new Match<CTypes.type>() {
19876: public CTypes.type apply() {
19877: final Node arg$2094 = GNode.cast(n);
19878:
19879: if ((null == arg$2094)) {
19880: return null;
19881: }
19882: if (CSupport.match$1702(arg$2094)) {
19883: final Pair<Node> l = Analyzer
19884: .cast(Primitives
19885: .getChildren(
19886: arg$2094,
19887: 0,
19888: arg$2094
19889: .size()));
19890:
19891: matching_nodes.add(arg$2094);
19892: if ((null != arg$2094 && processScopeNodes
19893: .contains(arg$2094
19894: .getName()))) {
19895: processScope(arg$2094,
19896: getScope);
19897: }
19898: checkEnterScope(arg$2094);
19899:
19900: final Object retValue$2098 = Analyzer
19901: .cast(null == Primitives.isEmpty
19902: .apply(l) ? null
19903: : Primitives.isEmpty
19904: .apply(l) ? t
19905: : null == Primitives.and
19906: .apply(
19907: is_array
19908: .apply(t),
19909: is_char
19910: .apply(get_base
19911: .apply(t))) ? null
19912: : Primitives.and
19913: .apply(
19914: is_array
19915: .apply(t),
19916: is_char
19917: .apply(get_base
19918: .apply(t))) ? new Let<CTypes.type>() {
19919: final BigInteger size;
19920:
19921: {
19922: size = Analyzer
19923: .cast(get_size
19924: .apply(t));
19925: }
19926:
19927: public CTypes.type apply() {
19928: return Analyzer
19929: .cast(null == Primitives.and
19930: .apply(
19931: Primitives.greaterInt
19932: .apply(
19933: Primitives.length
19934: .apply(l),
19935: BigInteger
19936: .valueOf(1)),
19937: Primitives.greaterInt
19938: .apply(
19939: Primitives.length
19940: .apply(l),
19941: size)) ? null
19942: : Primitives.and
19943: .apply(
19944: Primitives.greaterInt
19945: .apply(
19946: Primitives.length
19947: .apply(l),
19948: BigInteger
19949: .valueOf(1)),
19950: Primitives.greaterInt
19951: .apply(
19952: Primitives.length
19953: .apply(l),
19954: size)) ? error(
19955: "excess elements in char array initializer",
19956: null)
19957: : t);
19958: }
19959: }
19960: .apply()
19961: : process_initializer
19962: .apply(
19963: n,
19964: t));
19965:
19966: checkExitScope(arg$2094);
19967: matching_nodes
19968: .remove(matching_nodes
19969: .size() - 1);
19970: return Analyzer
19971: .cast(retValue$2098);
19972: }
19973: if (true) {
19974: matching_nodes.add(arg$2094);
19975: if ((null != arg$2094 && processScopeNodes
19976: .contains(arg$2094
19977: .getName()))) {
19978: processScope(arg$2094,
19979: getScope);
19980: }
19981: checkEnterScope(arg$2094);
19982:
19983: final Object retValue$2101 = Analyzer
19984: .cast(processAssignment
19985: .apply(
19986: Boolean.TRUE,
19987: t,
19988: "initializer",
19989: analyze_expression
19990: .apply(n)));
19991:
19992: checkExitScope(arg$2094);
19993: matching_nodes
19994: .remove(matching_nodes
19995: .size() - 1);
19996: return Analyzer
19997: .cast(retValue$2101);
19998: }
19999: return null;
20000: }
20001: }.apply());
20002: }
20003: };
20004:
20005: final Function.F2<CTypes.type, Node, CTypes.type> process_initializer = new Function.F2<CTypes.type, Node, CTypes.type>() {
20006: public CTypes.type apply(final Node n, final CTypes.type t) {
20007: return new Match<CTypes.type>() {
20008: public CTypes.type apply() {
20009: final Node arg$2103 = GNode.cast(n);
20010:
20011: if ((null == arg$2103)) {
20012: return null;
20013: }
20014: if (CSupport.match$1702(arg$2103)) {
20015: final Pair<Node> nl = Analyzer.cast(Primitives
20016: .getChildren(arg$2103, 0, arg$2103
20017: .size()));
20018:
20019: matching_nodes.add(arg$2103);
20020: if ((null != arg$2103 && processScopeNodes
20021: .contains(arg$2103.getName()))) {
20022: processScope(arg$2103, getScope);
20023: }
20024: checkEnterScope(arg$2103);
20025:
20026: final Object retValue$2107 = Analyzer
20027: .cast(new Let<CTypes.type>() {
20028: {
20029: process_init_list.apply(t,
20030: BigInteger.valueOf(1),
20031: nl);
20032: }
20033:
20034: public CTypes.type apply() {
20035: return Analyzer.cast(t);
20036: }
20037: }.apply());
20038:
20039: checkExitScope(arg$2103);
20040: matching_nodes
20041: .remove(matching_nodes.size() - 1);
20042: return Analyzer.cast(retValue$2107);
20043: }
20044: if (true) {
20045: matching_nodes.add(arg$2103);
20046: if ((null != arg$2103 && processScopeNodes
20047: .contains(arg$2103.getName()))) {
20048: processScope(arg$2103, getScope);
20049: }
20050: checkEnterScope(arg$2103);
20051:
20052: final Object retValue$2110 = Analyzer
20053: .cast(null);
20054:
20055: checkExitScope(arg$2103);
20056: matching_nodes
20057: .remove(matching_nodes.size() - 1);
20058: return Analyzer.cast(retValue$2110);
20059: }
20060: return null;
20061: }
20062: }.apply();
20063: }
20064: };
20065:
20066: final Function.F3<CTypes.type, CTypes.type, BigInteger, Pair<Node>> process_init_list = new Function.F3<CTypes.type, CTypes.type, BigInteger, Pair<Node>>() {
20067: public CTypes.type apply(final CTypes.type t,
20068: final BigInteger index, final Pair<Node> el) {
20069: return (null == Primitives.isBottom.apply(el) ? null
20070: : Primitives.isBottom.apply(el) ? voidt
20071: : new Match<CTypes.type>() {
20072: public CTypes.type apply() {
20073: final Pair<Node> arg$2112 = Analyzer
20074: .cast(el);
20075:
20076: if ((null == arg$2112)) {
20077: return null;
20078: }
20079: if (CSupport.match$383(arg$2112)) {
20080: return Analyzer.cast(voidt);
20081: }
20082: if (true) {
20083: final Pair<Node> list$2114 = Analyzer
20084: .cast(Analyzer
20085: .cast(arg$2112));
20086: final Pair<Node> xs = Analyzer
20087: .cast(Primitives
20088: .wrapTail(list$2114));
20089:
20090: return Analyzer
20091: .cast(new Let<CTypes.type>() {
20092: final CTypes.type rt;
20093:
20094: {
20095: rt = Analyzer
20096: .cast(process_init_entry
20097: .apply(
20098: t,
20099: index,
20100: el));
20101: }
20102:
20103: public CTypes.type apply() {
20104: return Analyzer
20105: .cast(null == Primitives.isBottom
20106: .apply(rt) ? null
20107: : Primitives.isBottom
20108: .apply(rt) ? voidt
20109: : process_init_list
20110: .apply(
20111: t,
20112: Primitives.addInt
20113: .apply(
20114: index,
20115: BigInteger
20116: .valueOf(1)),
20117: xs));
20118: }
20119: }.apply());
20120: }
20121: return null;
20122: }
20123: }.apply());
20124: }
20125: };
20126:
20127: final Function.F3<CTypes.type, CTypes.type, BigInteger, Pair<Node>> process_init_entry = new Function.F3<CTypes.type, CTypes.type, BigInteger, Pair<Node>>() {
20128: public CTypes.type apply(final CTypes.type t,
20129: final BigInteger index, final Pair<Node> el) {
20130: return new Let<CTypes.type>() {
20131: final Node en;
20132:
20133: {
20134: en = Analyzer.cast(CSupport.head$2143.apply(el));
20135: }
20136:
20137: public CTypes.type apply() {
20138: return Analyzer.cast(new Match<CTypes.type>() {
20139: public CTypes.type apply() {
20140: final Node arg$2116 = GNode.cast(en);
20141:
20142: if ((null == arg$2116)) {
20143: return null;
20144: }
20145: if (CSupport.match$1858(arg$2116)) {
20146: final Node ds = (arg$2116.size() > 0 ? arg$2116
20147: .getGeneric(0)
20148: : null);
20149: final Node init = (arg$2116.size() > 1 ? arg$2116
20150: .getGeneric(1)
20151: : null);
20152:
20153: matching_nodes.add(arg$2116);
20154: if ((null != arg$2116 && processScopeNodes
20155: .contains(arg$2116.getName()))) {
20156: processScope(arg$2116, getScope);
20157: }
20158: checkEnterScope(arg$2116);
20159:
20160: final Object retValue$2138 = Analyzer
20161: .cast(new Let<CTypes.type>() {
20162: final CTypes.type element;
20163:
20164: {
20165: element = Analyzer
20166: .cast(process_designation
20167: .apply(
20168: t,
20169: index,
20170: ds,
20171: el));
20172: }
20173:
20174: public CTypes.type apply() {
20175: return Analyzer
20176: .cast(null == Primitives.isBottom
20177: .apply(element) ? null
20178: : Primitives.isBottom
20179: .apply(element) ? null
20180: : new Match<CTypes.type>() {
20181: public CTypes.type apply() {
20182: final Node arg$2127 = GNode
20183: .cast(init);
20184:
20185: if ((null == arg$2127)) {
20186: return null;
20187: }
20188: if (CSupport
20189: .match$834(arg$2127)) {
20190: matching_nodes
20191: .add(arg$2127);
20192: if ((null != arg$2127 && processScopeNodes
20193: .contains(arg$2127
20194: .getName()))) {
20195: processScope(
20196: arg$2127,
20197: getScope);
20198: }
20199: checkEnterScope(arg$2127);
20200:
20201: final Object retValue$2131 = Analyzer
20202: .cast(null == Primitives.not
20203: .apply(is_aggregate
20204: .apply(element)) ? null
20205: : Primitives.not
20206: .apply(is_aggregate
20207: .apply(element)) ? element
20208: : process_initializer
20209: .apply(
20210: init,
20211: element));
20212:
20213: checkExitScope(arg$2127);
20214: matching_nodes
20215: .remove(matching_nodes
20216: .size() - 1);
20217: return Analyzer
20218: .cast(retValue$2131);
20219: }
20220: if (true) {
20221: matching_nodes
20222: .add(arg$2127);
20223: if ((null != arg$2127 && processScopeNodes
20224: .contains(arg$2127
20225: .getName()))) {
20226: processScope(
20227: arg$2127,
20228: getScope);
20229: }
20230: checkEnterScope(arg$2127);
20231:
20232: final Object retValue$2134 = Analyzer
20233: .cast(new Let<CTypes.type>() {
20234: final CTypes.type rt;
20235:
20236: {
20237: rt = Analyzer
20238: .cast(analyze_expression
20239: .apply(init));
20240: }
20241:
20242: public CTypes.type apply() {
20243: return Analyzer
20244: .cast(null == Primitives.and
20245: .apply(
20246: Primitives.not
20247: .apply(is_struct_union
20248: .apply(element)),
20249: is_struct_union
20250: .apply(rt)) ? null
20251: : Primitives.and
20252: .apply(
20253: Primitives.not
20254: .apply(is_struct_union
20255: .apply(element)),
20256: is_struct_union
20257: .apply(rt)) ? new Let<CTypes.type>() {
20258: final CTypes.type new_rt;
20259:
20260: {
20261: new_rt = Analyzer
20262: .cast(resolve_element
20263: .apply(
20264: rt,
20265: BigInteger
20266: .valueOf(0)));
20267: }
20268:
20269: public CTypes.type apply() {
20270: return Analyzer
20271: .cast(processAssignment
20272: .apply(
20273: Boolean.TRUE,
20274: element,
20275: "initializer",
20276: new_rt));
20277: }
20278: }
20279: .apply()
20280: : new Let<CTypes.type>() {
20281: final CTypes.type new_element;
20282:
20283: {
20284: new_element = Analyzer
20285: .cast(null == Primitives.not
20286: .apply(is_aggregate
20287: .apply(rt)) ? null
20288: : Primitives.not
20289: .apply(is_aggregate
20290: .apply(rt)) ? resolve_element
20291: .apply(
20292: element,
20293: Primitives.subtractInt
20294: .apply(
20295: index,
20296: BigInteger
20297: .valueOf(1)))
20298: : element);
20299: }
20300:
20301: public CTypes.type apply() {
20302: return Analyzer
20303: .cast(processAssignment
20304: .apply(
20305: Boolean.TRUE,
20306: new_element,
20307: "initializer",
20308: rt));
20309: }
20310: }
20311: .apply());
20312: }
20313: }
20314: .apply());
20315:
20316: checkExitScope(arg$2127);
20317: matching_nodes
20318: .remove(matching_nodes
20319: .size() - 1);
20320: return Analyzer
20321: .cast(retValue$2134);
20322: }
20323: return null;
20324: }
20325: }
20326: .apply());
20327: }
20328: }.apply());
20329:
20330: checkExitScope(arg$2116);
20331: matching_nodes.remove(matching_nodes
20332: .size() - 1);
20333: return Analyzer.cast(retValue$2138);
20334: }
20335: if (true) {
20336: matching_nodes.add(arg$2116);
20337: if ((null != arg$2116 && processScopeNodes
20338: .contains(arg$2116.getName()))) {
20339: processScope(arg$2116, getScope);
20340: }
20341: checkEnterScope(arg$2116);
20342:
20343: final Object retValue$2141 = Analyzer
20344: .cast(null);
20345:
20346: checkExitScope(arg$2116);
20347: matching_nodes.remove(matching_nodes
20348: .size() - 1);
20349: return Analyzer.cast(retValue$2141);
20350: }
20351: return null;
20352: }
20353: }.apply());
20354: }
20355: }.apply();
20356: }
20357: };
20358:
20359: final Function.F2<CTypes.type, CTypes.type, BigInteger> resolve_element = new Function.F2<CTypes.type, CTypes.type, BigInteger>() {
20360: public CTypes.type apply(final CTypes.type element,
20361: final BigInteger index) {
20362: return (null == is_struct_union.apply(element) ? null
20363: : is_struct_union.apply(element) ? resolve_element
20364: .apply(
20365: get_index_type
20366: .apply(element, index),
20367: BigInteger.valueOf(0))
20368: : null == is_array.apply(element) ? null
20369: : is_array.apply(element) ? resolve_element
20370: .apply(get_base
20371: .apply(element),
20372: BigInteger
20373: .valueOf(0))
20374: : element);
20375: }
20376: };
20377:
20378: final Function.F4<CTypes.type, CTypes.type, BigInteger, Node, Pair<Node>> process_designation = new Function.F4<CTypes.type, CTypes.type, BigInteger, Node, Pair<Node>>() {
20379: public CTypes.type apply(final CTypes.type base,
20380: final BigInteger index, final Node des,
20381: final Pair<Node> nl) {
20382: return new Let<CTypes.type>() {
20383: final CTypes.type new_base;
20384:
20385: {
20386: new_base = Analyzer
20387: .cast(null == Primitives.and
20388: .apply(
20389: Primitives.and
20390: .apply(
20391: is_struct_union
20392: .apply(base),
20393: Primitives.equal
20394: .apply(
20395: BigInteger
20396: .valueOf(1),
20397: get_size
20398: .apply(base))),
20399: is_flat_init_list.apply(nl)) ? null
20400: : Primitives.and
20401: .apply(
20402: Primitives.and
20403: .apply(
20404: is_struct_union
20405: .apply(base),
20406: Primitives.equal
20407: .apply(
20408: BigInteger
20409: .valueOf(1),
20410: get_size
20411: .apply(base))),
20412: is_flat_init_list
20413: .apply(nl)) ? get_index_type
20414: .apply(base, BigInteger
20415: .valueOf(0))
20416: : base);
20417: }
20418:
20419: public CTypes.type apply() {
20420: return Analyzer.cast(null == Primitives.isBottom
20421: .apply(des) ? null : Primitives.isBottom
20422: .apply(des) ? new Let<CTypes.type>() {
20423: final BigInteger si;
20424:
20425: {
20426: si = Analyzer
20427: .cast(get_size.apply(new_base));
20428: }
20429:
20430: public CTypes.type apply() {
20431: return Analyzer
20432: .cast(null == Primitives.and
20433: .apply(
20434: Primitives.greaterInt
20435: .apply(
20436: si,
20437: BigInteger
20438: .valueOf(0)),
20439: Primitives.greaterInt
20440: .apply(
20441: index,
20442: si)) ? null
20443: : Primitives.and
20444: .apply(
20445: Primitives.greaterInt
20446: .apply(
20447: si,
20448: BigInteger
20449: .valueOf(0)),
20450: Primitives.greaterInt
20451: .apply(
20452: index,
20453: si)) ? new Let<CTypes.type>() {
20454: {
20455: warning(
20456: "excess elements in initializer",
20457: des);
20458: show_excess_error
20459: .apply(nl);
20460: }
20461:
20462: public CTypes.type apply() {
20463: return Analyzer
20464: .cast(null);
20465: }
20466: }.apply()
20467: : get_index_type
20468: .apply(
20469: new_base,
20470: Primitives.subtractInt
20471: .apply(
20472: index,
20473: BigInteger
20474: .valueOf(1))));
20475: }
20476: }.apply()
20477: : new Match<CTypes.type>() {
20478: public CTypes.type apply() {
20479: final Node arg$2144 = GNode
20480: .cast(des);
20481:
20482: if ((null == arg$2144)) {
20483: return null;
20484: }
20485: if (CSupport.match$2145(arg$2144)) {
20486: final Pair<Node> nl = Analyzer
20487: .cast(Primitives
20488: .getChildren(
20489: arg$2144,
20490: 0,
20491: arg$2144
20492: .size()));
20493:
20494: matching_nodes.add(arg$2144);
20495: if ((null != arg$2144 && processScopeNodes
20496: .contains(arg$2144
20497: .getName()))) {
20498: processScope(arg$2144,
20499: getScope);
20500: }
20501: checkEnterScope(arg$2144);
20502:
20503: final Object retValue$2148 = Analyzer
20504: .cast(process_des_list
20505: .apply(base,
20506: index,
20507: nl));
20508:
20509: checkExitScope(arg$2144);
20510: matching_nodes
20511: .remove(matching_nodes
20512: .size() - 1);
20513: return Analyzer
20514: .cast(retValue$2148);
20515: }
20516: if (CSupport.match$2149(arg$2144)) {
20517: final Node n1 = (arg$2144
20518: .size() > 1 ? arg$2144
20519: .getGeneric(1) : null);
20520: final Node n2 = (arg$2144
20521: .size() > 2 ? arg$2144
20522: .getGeneric(2) : null);
20523:
20524: matching_nodes.add(arg$2144);
20525: if ((null != arg$2144 && processScopeNodes
20526: .contains(arg$2144
20527: .getName()))) {
20528: processScope(arg$2144,
20529: getScope);
20530: }
20531: checkEnterScope(arg$2144);
20532:
20533: final Object retValue$2152 = Analyzer
20534: .cast(new Let<CTypes.type>() {
20535: final CTypes.type element;
20536: final Boolean res;
20537:
20538: {
20539: element = Analyzer
20540: .cast(get_index_type
20541: .apply(
20542: new_base,
20543: Primitives.subtractInt
20544: .apply(
20545: index,
20546: BigInteger
20547: .valueOf(1))));
20548: res = Analyzer
20549: .cast(process_array_des
20550: .apply(
20551: n1,
20552: n2));
20553: }
20554:
20555: public CTypes.type apply() {
20556: return Analyzer
20557: .cast(null == res
20558: || !res ? null
20559: : element);
20560: }
20561: }.apply());
20562:
20563: checkExitScope(arg$2144);
20564: matching_nodes
20565: .remove(matching_nodes
20566: .size() - 1);
20567: return Analyzer
20568: .cast(retValue$2152);
20569: }
20570: if (CSupport.match$2153(arg$2144)) {
20571: final String str = (arg$2144
20572: .size() > 0 ? arg$2144
20573: .getString(0) : null);
20574:
20575: matching_nodes.add(arg$2144);
20576: if ((null != arg$2144 && processScopeNodes
20577: .contains(arg$2144
20578: .getName()))) {
20579: processScope(arg$2144,
20580: getScope);
20581: }
20582: checkEnterScope(arg$2144);
20583:
20584: final Object retValue$2156 = Analyzer
20585: .cast(process_field_des
20586: .apply(base,
20587: str));
20588:
20589: checkExitScope(arg$2144);
20590: matching_nodes
20591: .remove(matching_nodes
20592: .size() - 1);
20593: return Analyzer
20594: .cast(retValue$2156);
20595: }
20596: return null;
20597: }
20598: }.apply());
20599: }
20600: }.apply();
20601: }
20602: };
20603:
20604: final Function.F2<Boolean, Node, Node> process_array_des = new Function.F2<Boolean, Node, Node>() {
20605: public Boolean apply(final Node n1, final Node n2) {
20606: return new Let<Boolean>() {
20607: final CTypes.type t1;
20608: final CTypes.type t2;
20609: final BigInteger size;
20610:
20611: {
20612: t1 = Analyzer.cast(analyze_expression.apply(n1));
20613: t2 = Analyzer.cast(analyze_expression.apply(n2));
20614: Analyzer
20615: .discard(null == Primitives.or
20616: .apply(
20617: Primitives.not
20618: .apply(is_integer
20619: .apply(t1)),
20620: Primitives.and
20621: .apply(
20622: Primitives.isNotBottom
20623: .apply(n2),
20624: Primitives.not
20625: .apply(is_integer
20626: .apply(t2))))
20627: || !Primitives.or
20628: .apply(
20629: Primitives.not
20630: .apply(is_integer
20631: .apply(t1)),
20632: Primitives.and
20633: .apply(
20634: Primitives.isNotBottom
20635: .apply(n2),
20636: Primitives.not
20637: .apply(is_integer
20638: .apply(t2)))) ? null
20639: : error(
20640: "array index in initializer not of integer type",
20641: n1));
20642: Analyzer
20643: .discard(null == Primitives.or
20644: .apply(
20645: Primitives.not
20646: .apply(is_const
20647: .apply(t1)),
20648: Primitives.and
20649: .apply(
20650: Primitives.isNotBottom
20651: .apply(n2),
20652: Primitives.not
20653: .apply(is_const
20654: .apply(t2))))
20655: || !Primitives.or
20656: .apply(
20657: Primitives.not
20658: .apply(is_const
20659: .apply(t1)),
20660: Primitives.and
20661: .apply(
20662: Primitives.isNotBottom
20663: .apply(n2),
20664: Primitives.not
20665: .apply(is_const
20666: .apply(t2)))) ? null
20667: : error(
20668: "nonconstant array index in initializer",
20669: n1));
20670: size = Analyzer.cast(get_int.apply(t1));
20671: }
20672:
20673: public Boolean apply() {
20674: return Analyzer
20675: .cast(null == Primitives.and.apply(
20676: Primitives.isNotBottom.apply(size),
20677: Primitives.greaterInt
20678: .apply(BigInteger
20679: .valueOf(0), size)) ? null
20680: : Primitives.and
20681: .apply(
20682: Primitives.isNotBottom
20683: .apply(size),
20684: Primitives.greaterInt
20685: .apply(
20686: BigInteger
20687: .valueOf(0),
20688: size)) ? new Let<Boolean>() {
20689: {
20690: error(
20691: "negative array index in initializer",
20692: null);
20693: }
20694:
20695: public Boolean apply() {
20696: return Analyzer
20697: .cast(Boolean.FALSE);
20698: }
20699: }.apply()
20700: : Boolean.TRUE);
20701: }
20702: }.apply();
20703: }
20704: };
20705:
20706: final Function.F2<CTypes.type, CTypes.type, String> process_field_des = new Function.F2<CTypes.type, CTypes.type, String>() {
20707: public CTypes.type apply(final CTypes.type base,
20708: final String str) {
20709: return (null == Primitives.not.apply(is_struct_union
20710: .apply(base)) ? null
20711: : Primitives.not.apply(is_struct_union.apply(base)) ? new Let<CTypes.type>() {
20712: {
20713: error(
20714: "field name not in struct or union initializer",
20715: null);
20716: }
20717:
20718: public CTypes.type apply() {
20719: return Analyzer.cast(null);
20720: }
20721: }.apply()
20722: : new Let<CTypes.type>() {
20723: final CTypes.type member;
20724:
20725: {
20726: member = Analyzer
20727: .cast(get_member_type
20728: .apply(base, str));
20729: }
20730:
20731: public CTypes.type apply() {
20732: return Analyzer
20733: .cast(null == Primitives.isBottom
20734: .apply(member) ? null
20735: : Primitives.isBottom
20736: .apply(member) ? new Let<CTypes.type>() {
20737: {
20738: error(
20739: Primitives.concat
20740: .apply(
20741: "unknown field ",
20742: str),
20743: null);
20744: }
20745:
20746: public CTypes.type apply() {
20747: return Analyzer
20748: .cast(null);
20749: }
20750: }.apply()
20751: : member);
20752: }
20753: }.apply());
20754: }
20755: };
20756:
20757: final Function.F3<CTypes.type, CTypes.type, BigInteger, Pair<Node>> process_des_list = new Function.F3<CTypes.type, CTypes.type, BigInteger, Pair<Node>>() {
20758: public CTypes.type apply(final CTypes.type base,
20759: final BigInteger index, final Pair<Node> nl) {
20760: return new Match<CTypes.type>() {
20761: public CTypes.type apply() {
20762: final Pair<Node> arg$2158 = Analyzer.cast(nl);
20763:
20764: if ((null == arg$2158)) {
20765: return null;
20766: }
20767: if (CSupport.match$383(arg$2158)) {
20768: return Analyzer.cast(base);
20769: }
20770: if (true) {
20771: final Pair<Node> list$2160 = Analyzer
20772: .cast(Analyzer.cast(arg$2158));
20773: final Node x = GNode.cast(Primitives
20774: .wrapHead(list$2160));
20775: final Pair<Node> xs = Analyzer.cast(Primitives
20776: .wrapTail(list$2160));
20777:
20778: return Analyzer.cast(new Match<CTypes.type>() {
20779: public CTypes.type apply() {
20780: final Node arg$2174 = GNode.cast(x);
20781:
20782: if ((null == arg$2174)) {
20783: return null;
20784: }
20785: if (CSupport.match$2162(arg$2174)) {
20786: final String str = (arg$2174
20787: .getGeneric(1).size() > 0 ? arg$2174
20788: .getGeneric(1).getString(0)
20789: : null);
20790:
20791: matching_nodes.add(arg$2174);
20792: if ((null != arg$2174 && processScopeNodes
20793: .contains(arg$2174
20794: .getName()))) {
20795: processScope(arg$2174, getScope);
20796: }
20797: checkEnterScope(arg$2174);
20798:
20799: List<Node> listName$2177 = new ArrayList<Node>();
20800: Node nodeName$2176 = arg$2174;
20801:
20802: nodeName$2176 = nodeName$2176
20803: .getGeneric(1);
20804: if ((null != nodeName$2176 && processScopeNodes
20805: .contains(nodeName$2176
20806: .getName()))) {
20807: processScope(nodeName$2176,
20808: getScope);
20809: }
20810: checkEnterScope(nodeName$2176);
20811: listName$2177.add(0, nodeName$2176);
20812:
20813: final Object retValue$2178 = Analyzer
20814: .cast(new Let<CTypes.type>() {
20815: final CTypes.type new_base;
20816:
20817: {
20818: new_base = Analyzer
20819: .cast(process_field_des
20820: .apply(
20821: base,
20822: str));
20823: }
20824:
20825: public CTypes.type apply() {
20826: return Analyzer
20827: .cast(null == Primitives.isBottom
20828: .apply(new_base) ? null
20829: : Primitives.isBottom
20830: .apply(new_base) ? null
20831: : process_des_list
20832: .apply(
20833: resolve
20834: .apply(new_base),
20835: index,
20836: xs));
20837: }
20838: }.apply());
20839:
20840: for (Node no : listName$2177) {
20841: checkExitScope(no);
20842: }
20843: checkExitScope(arg$2174);
20844: matching_nodes
20845: .remove(matching_nodes
20846: .size() - 1);
20847: return Analyzer.cast(retValue$2178);
20848: }
20849: if (CSupport.match$2166(arg$2174)) {
20850: final Node n1 = (arg$2174.size() > 1 ? arg$2174
20851: .getGeneric(1)
20852: : null);
20853: final Node n2 = (arg$2174.size() > 2 ? arg$2174
20854: .getGeneric(2)
20855: : null);
20856:
20857: matching_nodes.add(arg$2174);
20858: if ((null != arg$2174 && processScopeNodes
20859: .contains(arg$2174
20860: .getName()))) {
20861: processScope(arg$2174, getScope);
20862: }
20863: checkEnterScope(arg$2174);
20864:
20865: final Object retValue$2182 = Analyzer
20866: .cast(new Let<CTypes.type>() {
20867: final CTypes.type element;
20868: final Boolean res;
20869:
20870: {
20871: element = Analyzer
20872: .cast(get_index_type
20873: .apply(
20874: base,
20875: Primitives.subtractInt
20876: .apply(
20877: index,
20878: BigInteger
20879: .valueOf(1))));
20880: res = Analyzer
20881: .cast(process_array_des
20882: .apply(
20883: n1,
20884: n2));
20885: }
20886:
20887: public CTypes.type apply() {
20888: return Analyzer
20889: .cast(null == res
20890: || !res ? null
20891: : element);
20892: }
20893: }.apply());
20894:
20895: checkExitScope(arg$2174);
20896: matching_nodes
20897: .remove(matching_nodes
20898: .size() - 1);
20899: return Analyzer.cast(retValue$2182);
20900: }
20901: if (true) {
20902: matching_nodes.add(arg$2174);
20903: if ((null != arg$2174 && processScopeNodes
20904: .contains(arg$2174
20905: .getName()))) {
20906: processScope(arg$2174, getScope);
20907: }
20908: checkEnterScope(arg$2174);
20909:
20910: final Object retValue$2185 = Analyzer
20911: .cast(error(
20912: "Unsupport designator list",
20913: null));
20914:
20915: checkExitScope(arg$2174);
20916: matching_nodes
20917: .remove(matching_nodes
20918: .size() - 1);
20919: return Analyzer.cast(retValue$2185);
20920: }
20921: return null;
20922: }
20923: }.apply());
20924: }
20925: return null;
20926: }
20927: }.apply();
20928: }
20929: };
20930:
20931: final Function.F1<Boolean, Pair<Node>> is_flat_init_list = new Function.F1<Boolean, Pair<Node>>() {
20932: public Boolean apply(final Pair<Node> nl) {
20933: return new Match<Boolean>() {
20934: public Boolean apply() {
20935: final Pair<Node> arg$2188 = Analyzer.cast(nl);
20936:
20937: if ((null == arg$2188)) {
20938: return null;
20939: }
20940: if (CSupport.match$383(arg$2188)) {
20941: return Analyzer.cast(Boolean.TRUE);
20942: }
20943: if (true) {
20944: final Pair<Node> list$2190 = Analyzer
20945: .cast(Analyzer.cast(arg$2188));
20946: final Node x = GNode.cast(Primitives
20947: .wrapHead(list$2190));
20948: final Pair<Node> xs = Analyzer.cast(Primitives
20949: .wrapTail(list$2190));
20950:
20951: return Analyzer.cast(new Match<Boolean>() {
20952: public Boolean apply() {
20953: final Node arg$2200 = GNode.cast(x);
20954:
20955: if ((null == arg$2200)) {
20956: return null;
20957: }
20958: if (CSupport.match$2192(arg$2200)) {
20959: matching_nodes.add(arg$2200);
20960: if ((null != arg$2200 && processScopeNodes
20961: .contains(arg$2200
20962: .getName()))) {
20963: processScope(arg$2200, getScope);
20964: }
20965: checkEnterScope(arg$2200);
20966:
20967: final Object retValue$2204 = Analyzer
20968: .cast(Boolean.FALSE);
20969:
20970: checkExitScope(arg$2200);
20971: matching_nodes
20972: .remove(matching_nodes
20973: .size() - 1);
20974: return Analyzer.cast(retValue$2204);
20975: }
20976: if (true) {
20977: matching_nodes.add(arg$2200);
20978: if ((null != arg$2200 && processScopeNodes
20979: .contains(arg$2200
20980: .getName()))) {
20981: processScope(arg$2200, getScope);
20982: }
20983: checkEnterScope(arg$2200);
20984:
20985: final Object retValue$2207 = Analyzer
20986: .cast(is_flat_init_list
20987: .apply(xs));
20988:
20989: checkExitScope(arg$2200);
20990: matching_nodes
20991: .remove(matching_nodes
20992: .size() - 1);
20993: return Analyzer.cast(retValue$2207);
20994: }
20995: return null;
20996: }
20997: }.apply());
20998: }
20999: return null;
21000: }
21001: }.apply();
21002: }
21003: };
21004:
21005: final Function.F2<CTypes.type, CTypes.type, BigInteger> get_index_type = new Function.F2<CTypes.type, CTypes.type, BigInteger>() {
21006: public CTypes.type apply(final CTypes.type t,
21007: final BigInteger index) {
21008: return new Match<CTypes.type>() {
21009: public CTypes.type apply() {
21010: final CTypes.raw_type<?> arg$2210 = Analyzer
21011: .cast(null == t ? null : t.type);
21012:
21013: if ((null == arg$2210)) {
21014: return null;
21015: }
21016: if ((null != arg$2210))
21017: switch (arg$2210.tag()) {
21018: case StructT:
21019: if (CSupport.match$298(arg$2210)) {
21020: final Pair<CTypes.type> tl = Analyzer
21021: .cast(arg$2210.getTuple()
21022: .get3());
21023:
21024: return Analyzer
21025: .cast(null == Primitives.isBottom
21026: .apply(tl) ? null
21027: : Primitives.isBottom
21028: .apply(tl) ? null
21029: : null == Primitives.greaterEqualInt
21030: .apply(
21031: index,
21032: Primitives.length
21033: .apply(tl)) ? null
21034: : Primitives.greaterEqualInt
21035: .apply(
21036: index,
21037: Primitives.length
21038: .apply(tl)) ? voidt
21039: : new Let<CTypes.type>() {
21040: final CTypes.type member;
21041:
21042: {
21043: member = Analyzer
21044: .cast(CSupport.nth$489
21045: .apply(
21046: tl,
21047: index));
21048: }
21049:
21050: public CTypes.type apply() {
21051: return Analyzer
21052: .cast(resolve
21053: .apply(member));
21054: }
21055: }
21056: .apply());
21057: }
21058: break;
21059: case ArrayT:
21060: if (CSupport.match$1248(arg$2210)) {
21061: return Analyzer.cast(get_base.apply(t));
21062: }
21063: break;
21064: case UnionT:
21065: if (CSupport.match$905(arg$2210)) {
21066: final Pair<CTypes.type> tl = Analyzer
21067: .cast(arg$2210.getTuple()
21068: .get3());
21069:
21070: return Analyzer
21071: .cast(null == Primitives.isBottom
21072: .apply(tl) ? null
21073: : Primitives.isBottom
21074: .apply(tl) ? null
21075: : null == Primitives.greaterEqualInt
21076: .apply(
21077: index,
21078: Primitives.length
21079: .apply(tl)) ? null
21080: : Primitives.greaterEqualInt
21081: .apply(
21082: index,
21083: Primitives.length
21084: .apply(tl)) ? voidt
21085: : new Let<CTypes.type>() {
21086: final CTypes.type member;
21087:
21088: {
21089: member = Analyzer
21090: .cast(CSupport.nth$489
21091: .apply(
21092: tl,
21093: index));
21094: }
21095:
21096: public CTypes.type apply() {
21097: return Analyzer
21098: .cast(resolve
21099: .apply(member));
21100: }
21101: }
21102: .apply());
21103: }
21104: break;
21105: default:
21106: break;
21107: }
21108: ;
21109: if (true) {
21110: return Analyzer.cast(t);
21111: }
21112: return null;
21113: }
21114: }.apply();
21115: }
21116: };
21117:
21118: final Function.F1<Object, Pair<Node>> show_excess_error = new Function.F1<Object, Pair<Node>>() {
21119: public Object apply(final Pair<Node> nl) {
21120: return new Match<Object>() {
21121: public Object apply() {
21122: final Pair<Node> arg$2215 = Analyzer.cast(nl);
21123:
21124: if ((null == arg$2215)) {
21125: return null;
21126: }
21127: if (CSupport.match$383(arg$2215)) {
21128: return Analyzer.cast(null);
21129: }
21130: if (true) {
21131: final Pair<Node> list$2217 = Analyzer
21132: .cast(Analyzer.cast(arg$2215));
21133: final Node x = GNode.cast(Primitives
21134: .wrapHead(list$2217));
21135: final Pair<Node> xs = Analyzer.cast(Primitives
21136: .wrapTail(list$2217));
21137:
21138: return Analyzer.cast(new Let<Object>() {
21139: {
21140: new Match<Object>() {
21141: public Object apply() {
21142: final Node arg$2227 = GNode
21143: .cast(x);
21144:
21145: if ((null == arg$2227)) {
21146: return null;
21147: }
21148: if (CSupport
21149: .match$2192(arg$2227)) {
21150: matching_nodes
21151: .add(arg$2227);
21152: if ((null != arg$2227 && processScopeNodes
21153: .contains(arg$2227
21154: .getName()))) {
21155: processScope(arg$2227,
21156: getScope);
21157: }
21158: checkEnterScope(arg$2227);
21159:
21160: final Object retValue$2231 = Analyzer
21161: .cast(error(
21162: "extra brace group at end of initializer",
21163: x));
21164:
21165: checkExitScope(arg$2227);
21166: matching_nodes
21167: .remove(matching_nodes
21168: .size() - 1);
21169: return Analyzer
21170: .cast(retValue$2231);
21171: }
21172: if (true) {
21173: matching_nodes
21174: .add(arg$2227);
21175: if ((null != arg$2227 && processScopeNodes
21176: .contains(arg$2227
21177: .getName()))) {
21178: processScope(arg$2227,
21179: getScope);
21180: }
21181: checkEnterScope(arg$2227);
21182:
21183: final Object retValue$2234 = Analyzer
21184: .cast(null);
21185:
21186: checkExitScope(arg$2227);
21187: matching_nodes
21188: .remove(matching_nodes
21189: .size() - 1);
21190: return Analyzer
21191: .cast(retValue$2234);
21192: }
21193: return null;
21194: }
21195: }.apply();
21196: }
21197:
21198: public Object apply() {
21199: return Analyzer.cast(show_excess_error
21200: .apply(xs));
21201: }
21202: }.apply());
21203: }
21204: return null;
21205: }
21206: }.apply();
21207: }
21208: };
21209: }
|